20145226夏艺华《Java程序设计》实验报告五

最新推荐文章于 2024-09-13 21:40:38 发布

weixin_30263277

最新推荐文章于 2024-09-13 21:40:38 发布

阅读量116

点赞数

文章标签： java 网络

原文链接：http://www.cnblogs.com/bestixyh/p/6394973.html

版权

实验五 Java网络编程及安全

实验内容

运行下载的TCP代码，结对进行
利用加解密代码包，编译运行代码，结对进行
集成代码，加密后通过TCP发送
结对伙伴：20145203 马超

实验步骤

（一）中缀表达式转后缀表达式并计算

中缀表达式转后缀表达式代码如下：

package xyh01;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.Stack;

public class MyBC {
    /** 
     * 优先级比较 
     * @param operator1 比较值 
     * @param operator2 被比较值 
     * @return 小于等于返回false,大于返回true 
     */  
    public boolean comparePrior(String operator1, String operator2) {  
        if("(".equals(operator2)) {  
            return true;  
        }  
        if ("*".equals(operator1) || "/".equals(operator1)) {  
            if ("+".equals(operator2) || "-".equals(operator2)) {  
                return true;  
            }  
        }  
        return false;  
    }  

    public String[] toSuffixExpression(String[] expressionStrs) {  
        //新组成的表达式  
        List<String> newExpressionStrs = new ArrayList<String>();  
        Stack<String> stack = new Stack<String>();  

        for (int i = 0; i < expressionStrs.length; i++) {  
            if ("(".equals(expressionStrs[i])) { // 如果是左括号,则入栈  
                stack.push(expressionStrs[i]);  
            } else if ("+".equals(expressionStrs[i]) || "-".equals(expressionStrs[i]) || "*".equals(expressionStrs[i]) || "/".equals(expressionStrs[i])) {  
                if (!stack.empty()) { // 取出先入栈的运算符  
                    String s = stack.pop();  
                    if(comparePrior(expressionStrs[i], s)) { //如果栈值优先级小于要入栈的值,则继续压入栈  
                        stack.push(s);  
                    } else {  //否则取出值  
                        newExpressionStrs.add(s);  
                    }  
                }  
                stack.push(expressionStrs[i]);  
            } else if (")".equals(expressionStrs[i])) { //如果是")",则出栈,一直到遇到"("  
                while (!stack.empty()) {  
                    String s = stack.pop();  
                    if (!"(".equals(s)) {  
                        newExpressionStrs.add(s);  
                    } else {  
                        break;  
                    }  
                }  
            } else {  
                newExpressionStrs.add(expressionStrs[i]);  
            }  
        }  
        while (!stack.empty()) {  
            String s = stack.pop();  
            newExpressionStrs.add(s);  
        }  
        return newExpressionStrs.toArray(new String[0]);  
    }   
}

调用中缀表达式转后缀表达式，并且调用已有的MyDC.java来计算后缀表达式的值，具体代码如下：

package xyh01;

import java.util.Scanner;

public class MyBCTest {
    public static void main(String[] args) {  
        int result;
        try
        {
            Scanner in = new Scanner(System.in);
            MyDC evaluator = new MyDC();

            System.out.println ("请输入对应的中缀表达式: ");
            String expressionStr = in.nextLine();
            String[] expressionStrs = expressionStr.split("");
            String[] newExpressionStrs = new MyBC().toSuffixExpression(expressionStrs);
            for (int i = 0; i < newExpressionStrs.length; i++) {  
                System.out.print(newExpressionStrs[i]); 
            }

            result = evaluator.evaluate(String.join("", newExpressionStrs));
            System.out.print("\n"+result+"");

        }
        catch (Exception IOException)
        {
            System.out.println("Input exception reported");
        }

    }
}

运行结果如下所示：

（二）运行TCP代码

下载对应的TCP代码，下面给出对应的客户端代码和服务器代码。

客户端TCP代码：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;

public class ComputeTCPClient {
    public static void main(String srgs[]) {
        try {
            //创建连接特定服务器的指定端口的Socket对象
            Socket socket = new Socket("127.0.0.1", 4421);
            //获得从服务器端来的网络输入流
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            //获得从客户端向服务器端输出数据的网络输出流
            PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())),true);
            //创建键盘输入流，以便客户端从键盘上输入信息
            BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
            System.out.print("请输入待发送的数据：");
            String str=stdin.readLine(); //从键盘读入待发送的数据
            out.println(str);  //通过网络传送到服务器
            str=in.readLine();//从网络输入流读取结果
            System.out.println( "从服务器接收到的结果为："+str); //输出服务器返回的结果
        }
        catch (Exception e) {
            System.out.println(e);
        }
        finally{
            //stdin.close();
            //in.close();
            //out.close();
            //socket.close();
        }
    }
}

服务器端TCP代码：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class ComputeTCPServer {
    public static void main(String srgs[]) {
        ServerSocket sc = null;
        Socket socket=null;
        try {
            sc= new ServerSocket(4421);//创建服务器套接字
            System.out.println("端口号:" + sc.getLocalPort());
            System.out.println("服务器已经启动...");
            socket = sc.accept();   //等待客户端连接
            System.out.println("已经建立连接");
            //获得网络输入流对象的引用
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            获得网络输出流对象的引用
            PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())),true);
            String   aline=in.readLine();//读取客户端传送来的数据
            System.out.println("从客户端接收到信息为："+aline); //通过网络输出流返回结果给客户端
            out.println("Echo:" + aline);
            out.close();
            in.close();
            sc.close();
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

客户端的运行结果为：

服务器端的运行结果为：

查看自己电脑的IP地址，使用ipconfig命令来查询电脑的相关网络信息，结果如下所示：

（二）加解密

1.密钥的加密：发送方A——>接收方B

（1）A加密时，用B的公钥；

（2）B解密时，用B的私钥。

发送方A对信息(明文)采用DES密钥加密,使用RSA公钥加密前面的DES密钥信息,最终将混合信息进行传递。同时用hash函数将明文进行用作验证。

接收方B接收到信息后，用RSA私钥解密DES密钥信息，再用RSA解密获取到的密钥信息解密密文信息，最终就可以得到我们要的信息(明文)。用hash函数对解出的明文进行验证，与发送过来的hash值相等，验证通过。

客户端的具体代码如下：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.net.Socket;
import java.security.MessageDigest;
import java.security.interfaces.RSAPublicKey;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;

public class ComputeTCPClient {
    public static void main(String srgs[]) {
        try {
            KeyGenerator kg = KeyGenerator.getInstance("DESede");
            kg.init(168);
            SecretKey k = kg.generateKey();
            byte[] ptext2 = k.getEncoded();
            Socket socket = new Socket("222.28.128.64", 5288);
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);
            BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));

                    //RSA算法，使用服务器端的公钥对DES的密钥进行加密
                    FileInputStream f3 = new FileInputStream("Skey_RSA_pub.dat");
                    ObjectInputStream b2 = new ObjectInputStream(f3);
                    RSAPublicKey pbk = (RSAPublicKey) b2.readObject();
                    BigInteger e = pbk.getPublicExponent();
                    BigInteger n = pbk.getModulus();
                    BigInteger m = new BigInteger(ptext2);
                    BigInteger c = m.modPow(e, n);
                    String cs = c.toString();
                    out.println(cs); // 通过网络将加密后的秘钥传送到服务器
                    System.out.print("请输入待发送的数据：");

                    //用DES加密明文得到密文
                    String s = stdin.readLine(); // 从键盘读入待发送的数据
                    Cipher cp = Cipher.getInstance("DESede");
                    cp.init(Cipher.ENCRYPT_MODE, k);
                    byte ptext[] = s.getBytes("UTF8");
                    byte ctext[] = cp.doFinal(ptext);
                    String str = parseByte2HexStr(ctext);
                    out.println(str); // 通过网络将密文传送到服务器

                    // 将客户端明文的Hash值传送给服务器
                    String x = s;
                    MessageDigest m2 = MessageDigest.getInstance("MD5");
                    m2.update(x.getBytes());
                    byte a[] = m2.digest();
                    String result = "";
                    for (int i = 0; i < a.length; i++)
                    {
                        result += Integer.toHexString((0x000000ff & a[i]) | 0xffffff00).substring(6);
                    }
                    System.out.println(result);
                    out.println(result);//通过网络将明文的Hash函数值传送到服务器

                    str = in.readLine();// 从网络输入流读取结果
                    System.out.println("从服务器接收到的结果为：" + str); // 输出服务器返回的结果
        }
        catch (Exception e) {
            System.out.println(e);
        }
        finally{
            //stdin.close();
            //in.close();
            //out.close();
            //socket.close();
        }
    }

    private static String parseByte2HexStr(byte[] ctext) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < ctext.length; i++)
        {
            String hex = Integer.toHexString(ctext[i] & 0xFF);
            if (hex.length() == 1)
            {
                hex = '0' + hex;
            }
            sb.append(hex.toUpperCase());
        }
        return sb.toString();
    }
}

客户端的运行结果如下所示：