2018-2019-2 20175308 实验五 《网络编程与安全》实验报告

---

实验内容

（一）网络编程与安全-1

要求

两人一组结对编程：

1、 参考http://www.cnblogs.com/rocedu/p/6766748.html#SECDSA

2、结对实现中缀表达式转后缀表达式的功能 MyBC.java

3、结对实现从上面功能中获取的表达式中实现后缀表达式求值的功能,调用MyDC.java

4、上传测试代码运行结果截图和码云链接

原理

中缀表达式转后缀表达式转换过程需要用到栈，具体过程如下：

1、如果遇到操作数，我们就直接将其输出。

2、如果遇到操作符，则我们将其放入到栈中，遇到左括号时我们也将其放入栈中。

3、如果遇到一个右括号，则将栈元素弹出，将弹出的操作符输出直到遇到左括号为止。注意，左括号只弹出并不输出。

4、如果遇到任何其他的操作符，如（“+”， “*”，“（”）等，从栈中弹出元素直到遇到发现更低优先级的元素(或者栈为空)为止。弹出完这些元素后，才将遇到的操作符压入到栈中。有一点需要注意，只有在遇到" ) "的情况下我们才弹出" ( "，其他情况我们都不会弹出" ( "。

5、如果我们读到了输入的末尾，则将栈中所有元素依次弹出。

代码

MyBC.java

/**
 * @author lxy
 */
public class MyBC {
    private Stack theStack;
    private String input;
    private String output = "";
public MyBC(String in) {
    input = in;
    int stackSize = input.length();
    theStack = new Stack(stackSize);
}

public String doTrans() {
    for (int j = 0; j < input.length(); j++) {
        char ch = input.charAt(j);
        switch (ch) {
            case '+':
            case '-':
                gotOper(ch, 1);
                break;
            case '*':
            case '/':
                gotOper(ch, 2);
                break;
            case '(':
                theStack.push(ch);
                break;
            case ')':
                gotParen(ch);
                break;
            default:
                output = output + ch;
                break;
        }
    }
    while (!theStack.isEmpty()) {
        output = output + theStack.pop();
    }
    return output;
}

public void gotOper(char opThis, int prec1) {
    while (!theStack.isEmpty()) {
        char opTop = theStack.pop();
        if (opTop == '(') {
            theStack.push(opTop);
            break;
        } else {
            int prec2;
            if (opTop == '+' || opTop == '-')
                prec2 = 1;
            else
                prec2 = 2;
            if (prec2 < prec1) {
                theStack.push(opTop);
                break;
            } else
                output = output + opTop;
        }
    }
    theStack.push(opThis);
}

public void gotParen(char ch) {
    while (!theStack.isEmpty()) {
        char chx = theStack.pop();
        if (chx == '(')
            break;
        else
            output = output + chx;
    }
}

class Stack {
    private int maxSize;
    private char[] stackArray;
    private int top;

    public Stack(int max) {
        maxSize = max;
        stackArray = new char[maxSize];
        top = -1;
    }

    public void push(char j) {
        stackArray[++top] = j;
    }

    public char pop() {
        return stackArray[top--];
    }

    public char peek() {
        return stackArray[top];
    }

    public boolean isEmpty() {
        return (top == -1);
    }
}
}

MyDC.java

import java.util.StringTokenizer;
import java.util.Stack;

/**
 * @author lxy
 */
public class MyDC {
    /**
     * constant for addition symbol
     */
    private final char ADD = '+';
    /**
     * constant for subtraction symbol
     */
    private final char SUBTRACT = '-';
    /**
     * constant for multiplication symbol
     */
    private final char MULTIPLY = '*';
    /**
     * constant for division symbol
     */
    private final char DIVIDE = '/';
    /**
     * the stack
     */
    private Stack<Integer> stack;

public MyDC() {
    stack = new Stack<Integer>();
}

public int evaluate(String expr) {
    int op1, op2, result = 0;
    String token;
    StringTokenizer tokenizer = new StringTokenizer(expr);

    while (tokenizer.hasMoreTokens()) {
        token = tokenizer.nextToken();
        if (isOperator(token)) {
            op2 = (stack.pop()).intValue();
            op1 = (stack.pop()).intValue();
            result = evalSingleOp(token.charAt(0), op1, op2);
            stack.push(new Integer(result));
        } else//如果是操作数
        {
            stack.push(new Integer(Integer.parseInt(token)));
        }
    }
    return result;
}

private boolean isOperator(String token) {
    return (token.equals("+") || token.equals("-") ||
            token.equals("*") || token.equals("/"));
}

private int evalSingleOp(char operation, int op1, int op2) {
    int result = 0;

    switch (operation) {
        case ADD:
            result = op1 + op2;
            break;
        case SUBTRACT:
            result = op1 - op2;
            break;
        case MULTIPLY:
            result = op1 * op2;
            break;
        case DIVIDE:
            result = op1 / op2;
            break;
    }

    return result;
}
}

实验截图

---

（二）网络编程与安全-2

要求

结对编程：1人负责客户端，一人负责服务器

1、基于Java Socket实现客户端/服务器功能，传输方式用TCP

2、客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式通过网络发送给服务器

3、服务器接收到后缀表达式，调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端

4、客户端显示服务器发送过来的结果

原理

套接字是一个网络连接的端点。

1、在java中，使用java.net.Socket对象来表示一个套接字。

2、创建一个套接字，可以使用Socket的构造方法。

如：public Socket(java.lang.String host, int port)其中，host是IP地址，port是端口号。

3、使用方法accept()将客户端的套接字和服务器端的套接字连接起来

代码

Client.java

import java.net.*;
import java.io.*;
public class Client
{
    public static void main(String srgs[]) throws Exception
    {
        try
        {
            // 1、创建客户端Socket，指定服务器地址和端口
            Socket socket=new Socket("127.0.0.1",5328);

        System.out.println("客户端启动成功");
        // 2、获取输出流，向服务器端发送信息
        // 向本机的10001端口发出客户请求
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        // 由系统标准输入设备构造BufferedReader对象
        PrintWriter write = new PrintWriter(socket.getOutputStream());
        // 由Socket对象得到输出流，并构造PrintWriter对象
        //3、获取输入流，并读取服务器端的响应信息
        BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        // 由Socket对象得到输入流，并构造相应的BufferedReader对象
        String readline, infix, expression;
        readline = br.readLine(); // 从系统标准输入读入一字符串

        MyBC theTrans = new MyBC(readline);
        infix = theTrans.doTrans();
        StringBuilder newInfix = new StringBuilder(infix.replace(" ",""));
        for (int i = 1; i < infix.length()+(i+1)/2 ; i=i+2) {
            newInfix.insert(i," ");
        }
        System.out.println("后缀表达式为： " + newInfix);
        expression=newInfix.toString();

        while (!readline.equals("end")) {
            // 若从标准输入读入的字符串为 "end"则停止循环
            write.println(expression);
            // 将从系统标准输入读入的字符串输出到Server
            write.flush();
            // 刷新输出流，使Server马上收到该字符串
            System.out.println("客户端发来的消息为:" + expression);
            // 在系统标准输出上打印读入的字符串
            System.out.println("服务器发来的结果为:" + in.readLine());
            // 从Server读入一字符串，并打印到标准输出上
            readline = br.readLine(); // 从系统标准输入读入一字符串
        } // 继续循环
        //4、关闭资源
        write.close(); // 关闭Socket输出流
        in.close(); // 关闭Socket输入流
        socket.close(); // 关闭Socket
    }
    catch (Exception e)
    {
        System.out.println(e);//输出异常
    }
    finally
    {
    }
}
}

Client.java

import java.net.*;
import java.io.*;

public class Server{
    public static void main(String srgs[]) throws Exception
    {
        ServerSocket sc = null;
        Socket socket=null;
        try
        {
            MyDC evaluator = new MyDC();

        sc= new ServerSocket(5328);//创建服务器套接字
        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 aline2=in.readLine();
        System.out.println("客户端发来的信息为："+aline2);

        int ans = evaluator.evaluate(aline2);
        out.println(ans);
        System.out.println("result = "+ans);
    } catch (Exception e) {
        System.out.println(e);
    }
}

//十六进制和十进制转换
public static byte[] parseHexStr2Byte(String hexStr)
{
    if (hexStr.length() < 1)
        return null;
    byte[] result = new byte[hexStr.length()/2];
    for (int i = 0;i< hexStr.length()/2; i++)
    {
        int high = Integer.parseInt(hexStr.substring(i*2, i*2+1 ), 16);
        int low = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16);
        result[i] = (byte) (high * 16 + low);
    }
    return result;
}
}

实验截图

---

（三）网络编程与安全-3

要求

1、基于Java Socket实现客户端/服务器功能，传输方式用TCP

2、客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密后通过网络把密文发送给服务器

3、服务器接收到后缀表达式表达式后，进行解密（和客户端协商密钥，可以用数组保存），然后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端

4、客户端显示服务器发送过来的结果

原理

利用DES算法实现加密和解密

代码

Skey_kb.java

Skey_DES.java

SEnc.java

SDec.java

Client.java

import java.net.*;
import java.beans.Expression;
import java.io.*;
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import java.security.spec.*;
import javax.crypto.interfaces.*;
import java.security.interfaces.*;
import java.math.*;


public class Client {
    public static void main(String srgs[]) throws Exception {
        try
        {
            // 1、创建客户端Socket，指定服务器地址和端口
            Socket socket=new Socket("127.0.0.1",5328);
            System.out.println("客户端成功启动，等待客户端呼叫");
            // 2、获取输出流，向服务器端发送信息
            // 向本机的10001端口发出客户请求
            System.out.println("请输入中缀表达式：");
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            // 由系统标准输入设备构造BufferedReader对象
            PrintWriter write = new PrintWriter(socket.getOutputStream());
            // 由Socket对象得到输出流，并构造PrintWriter对象
            //3、获取输入流，并读取服务器端的响应信息
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            // 由Socket对象得到输入流，并构造相应的BufferedReader对象
            String readline, infix, expression;
            readline = br.readLine(); // 从系统标准输入读入一字符串
            MyBC theTrans = new MyBC(readline);
            infix = theTrans.doTrans();
            StringBuilder newInfix = new StringBuilder(infix.replace(" ",""));
            for (int i = 1; i < infix.length()+(i+1)/2 ; i=i+2) {
                newInfix.insert(i," ");
            }
            System.out.println("后缀表达式：" + newInfix);
            expression=newInfix.toString();

        FileInputStream f=new FileInputStream("key1.dat");
        ObjectInputStream b=new ObjectInputStream(f);
        Key k=(Key)b.readObject();
        Cipher cp=Cipher.getInstance("DESede");
        cp.init(Cipher.ENCRYPT_MODE, k);
        byte ptext[]=expression.getBytes("UTF-8");
        byte ctext[]=cp.doFinal(ptext);
        String Str=new String(ctext,"ISO-8859-1");
        while (!readline.equals("end")) {
            // 若从标准输入读入的字符串为 "end"则停止循环
            System.out.println("加密后的信息:" + Str);
            // 在系统标准输出上打印读入的字符串
            write.println(Str);
            // 将从系统标准输入读入的字符串输出到Server
            write.flush();
            // 刷新输出流，使Server马上收到该字符串
            System.out.println("服务器发来的信息:" + in.readLine());
            // 从Server读入一字符串，并打印到标准输出上
            readline = br.readLine(); // 从系统标准输入读入一字符串
        } // 继续循环
        //4、关闭资源
        write.close(); // 关闭Socket输出流
        in.close(); // 关闭Socket输入流
        socket.close(); // 关闭Socket
    }
    catch (Exception e)
    {
        System.out.println(e);//输出异常
    }
    finally
    {
    }
}
}

Server.java

import java.net.*;
import java.io.*;
import java.security.*;
import java.security.spec.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import javax.crypto.interfaces.*;
import java.security.interfaces.*;
import java.math.*;
public class Server{
    public static void main(String srgs[]) throws Exception
    {
        ServerSocket sc = null;
        Socket socket=null;
        try
        {
            MyDC evaluator = new MyDC();
            sc= new ServerSocket(5328);//创建服务器套接字
            //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);
            //使用服务器端RSA的私钥对DES的密钥进行解密
            String aline2=in.readLine();
            System.out.println("客户端发来的信息为："+aline2);


        // 获取密钥
        byte[]ctext=aline2.getBytes("ISO-8859-1");
        FileInputStream  f2=new FileInputStream("keykb1.dat");
        int num2=f2.available();
        byte[ ] keykb=new byte[num2];
        System.out.printf("
");
        f2.read(keykb);
        SecretKeySpec k=new  SecretKeySpec(keykb,"DESede");
        // 解密
        Cipher cp=Cipher.getInstance("DESede");
        cp.init(Cipher.DECRYPT_MODE, k);
        byte []ptext=cp.doFinal(ctext);
        // 显示明文
        String p=new String(ptext,"UTF-8");
        int ans = evaluator.evaluate(p);
        out.println(ans);
        System.out.println("Result = "+ans);
    } catch (Exception e) {
        System.out.println(e);
    }
}

//十六进制和十进制转换
public static byte[] parseHexStr2Byte(String hexStr)
{
    if (hexStr.length() < 1)
        return null;
    byte[] result = new byte[hexStr.length()/2];
    for (int i = 0;i< hexStr.length()/2; i++)
    {
        int high = Integer.parseInt(hexStr.substring(i*2, i*2+1 ), 16);
        int low = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16);
        result[i] = (byte) (high * 16 + low);
    }
    return result;
}
}

实验截图

---

（四）网络编程与安全-4

要求

1、基于Java Socket实现客户端/服务器功能，传输方式用TCP

2、客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密通过网络把密文发送给服务器

3、客户端和服务器用DH算法进行3DES或AES算法的密钥交换

4、服务器接收到后缀表达式表达式后，进行解密，然后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端

5、客户端显示服务器发送过来的结果

原理

DH密钥交换算法

1、该算法的安全性基于有限域上的离散对数难题。基于这种安全性，通过DH算法进行密钥分配，使得消息的收发双方可以安全地交换一个密钥，再通过这个密钥对数据进行加密和解密处理。

2、创建DH公钥和私钥；

3、再创建共享密钥

4、客户端使用共享密钥对原有的密钥进行加密，并把密文和加密后的密钥传输给服务器

5、服务器先用共享密钥对客户端加密的密钥进行解密，再用解密后的密钥解密密文

代码

Key_DH.java

KeyAgree.java

Client.java

import java.net.*;
import java.beans.Expression;
import java.io.*;
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import java.security.spec.*;
import javax.crypto.interfaces.*;
import java.security.interfaces.*;
import java.math.*;

public class Client {
    public static void main(String[] args) throws Exception {
        try {
            // 1、创建客户端Socket，指定服务器地址和端口
            Socket socket = new Socket("127.0.0.1", 50);

        System.out.println("客户端成功启动，等待客户端呼叫");
        // 2、获取输出流，向服务器端发送信息
        // 向本机的10001端口发出客户请求
        System.out.println("请输入中缀表达式：");
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        // 由系统标准输入设备构造BufferedReader对象
        PrintWriter write = new PrintWriter(socket.getOutputStream());
        // 由Socket对象得到输出流，并构造PrintWriter对象
        //3、获取输入流，并读取服务器端的响应信息
        BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        // 由Socket对象得到输入流，并构造相应的BufferedReader对象
        String readline, infix, expression;
        readline = br.readLine(); // 从系统标准输入读入一字符串

        MyBC theTrans = new MyBC(readline);
        infix = theTrans.doTrans();
        StringBuilder newInfix = new StringBuilder(infix.replace(" ", ""));
        for (int i = 1; i < infix.length() + (i + 1) / 2; i = i + 2) {
            newInfix.insert(i, " ");
        }
        System.out.println("后缀表达式： " + newInfix);
        expression = newInfix.toString();

        // 读取对方的DH公钥
        FileInputStream f1 = new FileInputStream("Bpub");
        ObjectInputStream b1 = new ObjectInputStream(f1);
        PublicKey pbk = (PublicKey) b1.readObject();
        //读取自己的DH私钥
        FileInputStream f2 = new FileInputStream("Asec");
        ObjectInputStream b2 = new ObjectInputStream(f2);
        PrivateKey prk = (PrivateKey) b2.readObject();
        // 执行密钥协定
        KeyAgreement ka = KeyAgreement.getInstance("DH");
        ka.init(prk);
        ka.doPhase(pbk, true);
        //生成共享信息
        byte[] sb = ka.generateSecret();
        //System.out.println(sb.length);
        byte[] ssb = new byte[24];
        for (int i = 0; i < 24; i++)
            ssb[i] = sb[i];
        Key k = new SecretKeySpec(ssb, "DESede");
        Cipher cp = Cipher.getInstance("DESede");
        cp.init(Cipher.ENCRYPT_MODE, k);
        byte ptext[] = expression.getBytes("UTF-8");
        byte ctext[] = cp.doFinal(ptext);
        String Str = new String(ctext, "ISO-8859-1");

        while (!readline.equals("end")) {
            // 若从标准输入读入的字符串为 "end"则停止循环
            write.println(Str);
            // 将从系统标准输入读入的字符串输出到Server
            write.flush();
            // 刷新输出流，使Server马上收到该字符串
            System.out.println("加密后的信息:" + Str);
            // 在系统标准输出上打印读入的字符串
            System.out.println("服务器发来的信息:" + in.readLine());
            // 从Server读入一字符串，并打印到标准输出上
            readline = br.readLine(); // 从系统标准输入读入一字符串
        } // 继续循环
        //4、关闭资源
        write.close(); // 关闭Socket输出流
        in.close(); // 关闭Socket输入流
        socket.close(); // 关闭Socket
    } catch (Exception e) {
        System.out.println(e);//输出异常
    } finally {
    }
}
}

Server.java

import java.net.*;
import java.io.*;
import java.security.*;
import java.security.spec.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import javax.crypto.interfaces.*;
import java.security.interfaces.*;
import java.math.*;

public class Server {
    public static void main(String[] args) throws Exception {
        ServerSocket sc = null;
        Socket socket = null;
        try {
            MyDC evaluator = new MyDC();
            sc = new ServerSocket(50);//创建服务器套接字
            //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);
            //使用服务器端RSA的私钥对DES的密钥进行解密
            String aline2 = in.readLine();
            System.out.println("客户端发来的信息为：" + aline2);


        // 获取密钥
        byte[] ctext = aline2.getBytes("ISO-8859-1");
        // 读取对方的DH公钥
        FileInputStream f1 = new FileInputStream("Bpub");
        ObjectInputStream b1 = new ObjectInputStream(f1);
        PublicKey pbk = (PublicKey) b1.readObject();
        //读取自己的DH私钥
        FileInputStream f2 = new FileInputStream("Asec");
        ObjectInputStream b2 = new ObjectInputStream(f2);
        PrivateKey prk = (PrivateKey) b2.readObject();
        // 执行密钥协定
        KeyAgreement ka = KeyAgreement.getInstance("DH");
        ka.init(prk);
        ka.doPhase(pbk, true);
        //生成共享信息
        byte[] sb = ka.generateSecret();
        byte[] ssb = new byte[24];
        for (int i = 0; i < 24; i++)
            ssb[i] = sb[i];
        SecretKeySpec k = new SecretKeySpec(ssb, "DESede");

        // 解密
        Cipher cp = Cipher.getInstance("DESede");
        cp.init(Cipher.DECRYPT_MODE, k);
        byte[] ptext = cp.doFinal(ctext);
        // 显示明文
        String p = new String(ptext, "UTF8");
        int ans = evaluator.evaluate(p);
        out.println(ans);
        System.out.println("Result = " + ans);

    } catch (Exception e) {
        System.out.println(e);
    }
}

//十六进制和十进制转换
public static byte[] parseHexStr2Byte(String hexStr) {
    if (hexStr.length() < 1)
        return null;
    byte[] result = new byte[hexStr.length() / 2];
    for (int i = 0; i < hexStr.length() / 2; i++) {
        int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
        int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
        result[i] = (byte) (high * 16 + low);
    }
    return result;
}
}

实验截图

---

（五）网络编程与安全-5

要求

1、基于Java Socket实现客户端/服务器功能，传输方式用TCP

2、客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密通过网络把密文和明文的MD5値发送给服务器

3、客户端和服务器用DH算法进行3DES或AES算法的密钥交换

4、服务器接收到后缀表达式表达式后，进行解密，解密后计算明文的MD5值，和客户端传来的MD5进行比较，一致则调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端

5、客户端显示服务器发送过来的结果

原理

使用DigestPass.MD5(String s)生成MD5值

代码

Client.java

import java.net.*;
import java.io.*;
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import java.security.spec.*;
import javax.crypto.interfaces.*;
import java.security.interfaces.*;
import java.math.*;

public class Client {
    public static void main(String srgs[]) throws Exception {
        try {
            KeyGenerator kg = KeyGenerator.getInstance("DESede");
            kg.init(168);
            SecretKey k = kg.generateKey();
            byte[] ptext2 = k.getEncoded();
            Socket socket = new Socket("127.0.0.1", 3);
            System.out.println("客户端成功启动，等待客户端呼叫");
            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.println("请输入中缀表达式：");
            //用DES加密明文得到密文
            String s = stdin.readLine(); // 从键盘读入待发送的数据
            String postfix = MyBC1.toPostfix(s);
            Cipher cp = Cipher.getInstance("DESede");
            cp.init(Cipher.ENCRYPT_MODE, k);
            byte ptext[] = postfix.getBytes("UTF8");
            byte ctext[] = cp.doFinal(ptext);
            String str = parseByte2HexStr(ctext);
            out.println(str); // 通过网络将密文传送到服务器

        // 将客户端明文的Hash值传送给服务器
        String x = postfix;
        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("MD5:" + result);
        out.println(result);//通过网络将明文的Hash函数值传送到服务器
        str = in.readLine();// 从网络输入流读取结果
        System.out.println("从服务器接收到的结果为：" + str); // 输出服务器返回的结果
    } catch (Exception e) {
        System.out.println(e);//输出异常
    } finally {
    }

}

//将十六进制转换成二进制
public static String parseByte2HexStr(byte buf[]) {
    StringBuffer sb = new StringBuffer();
    for (int i = 0; i < buf.length; i++) {
        String hex = Integer.toHexString(buf[i] & 0xFF);
        if (hex.length() == 1) {
            hex = '0' + hex;
        }
        sb.append(hex.toUpperCase());
    }
    return sb.toString();
}
}

Server.java

import java.net.*;
import java.io.*;
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import java.security.interfaces.*;
import java.math.*;

public class Server {
    public static void main(String args[]) throws Exception {
        ServerSocket link = null;
        Socket socket = null;
        try {
            link = new ServerSocket(3);// 创建服务器套接字
            //System.out.println("端口号:" + link.getLocalPort());
            System.out.println("服务器成功启动，等待客户端应答");
            socket = link.accept(); // 等待客户端连接
            System.out.println("已经建立连接");
            //获得网络输入流对象的引用
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            //获得网络输出流对象的引用
            PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);
            // 使用服务器端RSA的私钥对DES的密钥进行解密

        String line = in.readLine();
        BigInteger cipher = new BigInteger(line);
        FileInputStream f = new FileInputStream("Skey_RSA_priv.dat");
        ObjectInputStream b = new ObjectInputStream(f);
        RSAPrivateKey prk = (RSAPrivateKey) b.readObject();
        BigInteger d = prk.getPrivateExponent();
        BigInteger n = prk.getModulus();//mod n
        BigInteger m = cipher.modPow(d, n);//m=d (mod n)
        System.out.println("d= " + d);
        System.out.println("n= " + n);
        System.out.println("m= " + m);
        byte[] keykb = m.toByteArray();
        // 使用DES对密文进行解密
        String readline = in.readLine();//读取客户端传送来的数据
        FileInputStream f2 = new FileInputStream("keykb1.dat");
        int num2 = f2.available();
        byte[] ctext = parseHexStr2Byte(readline);
        Key k = new SecretKeySpec(keykb, "DESede");
        Cipher cp = Cipher.getInstance("DESede");
        cp.init(Cipher.DECRYPT_MODE, k);
        byte[] ptext = cp.doFinal(ctext);
        String p = new String(ptext, "UTF8");//编码转换
        System.out.println("从客户端接收到信息为：" + p); //打印解密结果
        // 使用Hash函数检测明文完整性
        String aline3 = in.readLine();
        String x = p;
        MessageDigest m2 = MessageDigest.getInstance("MD5");//使用MD5算法返回实现指定摘要算法的 MessageDigest对象
        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("MD5:" + result);
        if (aline3.equals(result)) {
            System.out.println("匹配成功");
        }
        MyDC1 evaluator = new MyDC1();
        int _result = evaluator.value(p);
        out.println(_result);
        out.close();
        in.close();
        link.close();
    } catch (Exception e) {
        System.out.println(e);
    }
}

//二进制转换成十六进制，防止byte[]数字转换成string类型时造成的数据损失
public static String parseByte2HexStr(byte buf[]) {
    StringBuffer sb = new StringBuffer();
    for (int i = 0; i < buf.length; i++) {
        String hex = Integer.toHexString(buf[i] & 0xFF);
        if (hex.length() == 1) {
            hex = '0' + hex;
        }
        sb.append(hex.toUpperCase());//将字符串中的小写字母转换成大写字母,然后加在字符串上
    }
    return sb.toString();
}

//将十六进制转换为二进制
public static byte[] parseHexStr2Byte(String hexStr) {
    if (hexStr.length() < 1)
        return null;
    byte[] result = new byte[hexStr.length() / 2];
    for (int i = 0; i < hexStr.length() / 2; i++) {
        int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
        int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
        result[i] = (byte) (high * 16 + low);
    }
    return result;
}
}

实验截图

---