实验五 Java网络编程

实验五所涉及的密码学算法及编程思路

## Java对称加密-DES算法

（1）获取密钥生成器

KeyGenerator kg=KeyGenerator.getInstance("DESede");

（2）初始化密钥生成器

kg.init(168);

（3）生成密钥

SecretKey k=kg.generateKey( );

（4）通过对象序列化方式将密钥保存在文件中

FileOutputStream f=new FileOutputStream("key1.dat");
ObjectOutputStream b=new ObjectOutputStream(f);
b.writeObject(k);

-解密阶段
（1）获取密文

    FileInputStream f=new FileInputStream("SEnc.dat");
    int num=f.available();
    byte[ ] ctext=new byte[num];          
    f.read(ctext);

2）获取密钥

FileInputStream  f2=new FileInputStream("keykb1.dat");
int num2=f2.available();
byte[ ] keykb=new byte[num2];          
f2.read(keykb);
SecretKeySpec k=new  SecretKeySpec(keykb,"DESede");

（3）创建密码器（Cipher对象）

Cipher cp=Cipher.getInstance("DESede");

（4）初始化密码器

cp.init(Cipher.DECRYPT_MODE, k);

（5）执行解密

byte []ptext=cp.doFinal(ctext);

非对称加密-RSA算法

（1）创建密钥对生成器

KeyPairGenerator kpg=KeyPairGenerator.getInstance("RSA");

（2）初始化密钥生成器

kpg.initialize(1024);

（3）生成密钥对

KeyPair kp=kpg.genKeyPair( );

（4）获取公钥和私钥

PublicKey pbkey=kp.getPublic( );
PrivateKey prkey=kp.getPrivate( );

-加密过程
（1）获取公钥

  FileInputStream f=new FileInputStream("Skey_RSA_pub.dat");
  ObjectInputStream b=new ObjectInputStream(f);
  RSAPublicKey  pbk=(RSAPublicKey)b.readObject( );

（2）获取公钥的参数(e, n)

BigInteger e=pbk.getPublicExponent();

BigInteger n=pbk.getModulus();

（3）获取明文整数(m)

String s="Hello World!";

byte ptext[]=s.getBytes("UTF8");

BigInteger m=new BigInteger(ptext);

（4）执行计算

BigInteger c=m.modPow(e,n);

-解密过程
（1）读取密文

BufferedReader in=  new BufferedReader(new 
          
InputStreamReader(newFileInputStream("Enc_RSA.dat")));

String ctext=in.readLine();

BigInteger c=new BigInteger(ctext);

2）获取私钥

FileInputStream f=new FileInputStream("Skey_RSA_priv.dat");
ObjectInputStream b=new ObjectInputStream(f);
RSAPrivateKey prk=(RSAPrivateKey)b.readObject( );

（3）获取私钥的参数(d, n)

BigInteger d=prk.getPrivateExponent( );
BigInteger n=prk.getModulus( );

（4）执行计算

BigInteger m=c.modPow(d,n);

（5）计算明文整型数对应的字符串

byte[] mt=m.toByteArray();
for(int i=0;i<mt.length;i++){
       System.out.print((char) mt[i]);
}

创建共享密钥

（1）读取自己的DH私钥和对方的DH公钥

FileInputStream f1=new FileInputStream(args[0]);
ObjectInputStream b1=new ObjectInputStream(f1);
PublicKey  pbk=(PublicKey)b1.readObject( );
FileInputStream f2=newJava摘要算法- MD5 FileInputStream(args[1]);
ObjectInputStream b2=new ObjectInputStream(f2);
PrivateKey  prk=(PrivateKey)b2.readObject( );

（2）创建密钥协定对象

KeyAgreement ka=KeyAgreement.getInstance("DH");

（3）初始化密钥协定对象

 ka.init(prk);

（4）执行密钥协定

ka.doPhase(pbk,true);

（5）生成共享信息

byte[ ] sb=ka.generateSecret();

Java摘要算法- MD5

（1）生成MessageDigest对象

MessageDigest m=MessageDigest.getInstance("MD5");

（2）传入需要计算的字符串

m.update(x.getBytes("UTF8" ));

（3）计算消息摘要

byte s[ ]=m.digest( );

（4）处理计算结果

String result="";
for (int i=0; i<s.length; i++){
       result+=Integer.toHexString((0x000000ff & s[i]) | 0xffffff00).substring(6);
  }

实验步骤：

与结对伙伴链接上同一个热点。
在cmd中输入ipconfig
找到相应的网域的ip(如我的ip为192.168.43.159)
伙伴在cmd中输入ping 192.168.43.159(应先关闭防火墙）
显示连接成功
找到一个闲置的端口（我用的端口为我的学号5329）
伙伴或自己打开服务器，自己在运行客户端，便可以开始测试代码了。
-此时可以连接服务器了

实验内容

-实验截图分别为我idea截图和与我合作的黄斐学长的idea截图

第一题：

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

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

将运算符写在两个操作数中间的表达式，称为“中缀表达式”，如1+2/(3-4)+5。在中缀表达式中，运算符具有不同的优先级，圆括号用于改变运算符的运算次序，所以求值过程不能直接按照从左到右的顺序进行。
将运算符写在两个操作数之后的表达式称为“后缀表达式”，如上面的中缀表达式可转换为后缀表达式1 2 3 4 - * + 5 +。后缀表达式中没有括号，而且运算符没有优先级。后缀表达式的求值过程能够严格地从左到右按顺序进行，符合运算器的求值规律。
表达式求值算法分两步进行：①中缀转后缀；②求后缀表达式的值。

①中缀转后缀的算法可描述为：

设置一个运算符栈，设置一个后缀表达式字符串；
从左到右依次对中缀表达式中的每个字符ch分别进行以下处理，直至表达式结束：
若ch是左括号‘（’，将其入栈；
若ch是数字，将其后连续若干数字添加到后缀表达式字符串之后，并添加空格作为分隔符；
若ch是运算符，先将栈顶若干优先级高于ch的运算符出栈，添加到后缀表达式字符串之后，再将ch入栈。当‘（’运算符在栈中时，它的优先级最低。
若ch是‘）’，则若干运算符全部出栈，直到出栈的是左括号，一对括号匹配。
若表达式结束，将栈中运算符全部出栈，添加到后缀表达式字符串之后。

代码如下：

MyBC

import java.util.*;
public class MyBC {
    private static LinkedList<String> op1 = new LinkedList<>();
    private static LinkedList<String> op2 = new LinkedList<>();
    private static StringBuilder a = new StringBuilder();

    public StringBuilder houzhui(LinkedList<String> list) {
        Iterator<String> i = list.iterator();
        while (i.hasNext()) {
            String s = i.next();
            if (isOperator(s)) {
                if (op1.isEmpty()) {
                    op1.push(s);
                } else {
                    if (priority(op1.peek()) <= priority(s) && !s.equals(")")) {
                        op1.push(s);
                    } else if (!s.equals(")") && priority(op1.peek()) > priority(s)) {
                        while (op1.size() != 0 && priority(op1.peek()) >= priority(s)
                                && !op1.peek().equals("(")) {
                            if (!op1.peek().equals("(")) {
                                String operator = op1.pop();
                                a.append(operator).append(" ");
                                op2.push(operator);
                            }
                        }
                        op1.push(s);
                    } else if (s.equals(")")) {
                        while (!op1.peek().equals("(")) {
                            String operator = op1.pop();
                            a.append(operator).append(" ");
                            op2.push(operator);
                        }
                        op1.pop();
                    }
                }
            } else {
                a.append(s).append(" ");
                op2.push(s);
            }
        }
        if (!op1.isEmpty()) {
            Iterator<String> iterator = op1.iterator();
            while (iterator.hasNext()) {
                String operator = iterator.next();
                a.append(operator).append(" ");
                op2.push(operator);
                iterator.remove();
            }
        }
        return a;
    }

    private static boolean isOperator(String oper) {
        if (oper.equals("+") || oper.equals("-") || oper.equals("/") || oper.equals("*")
                || oper.equals("(") || oper.equals(")")) {
            return true;
        }
        return false;
    }

    private static int priority(String s) {
        switch (s) {
            case "+":
                return 1;
            case "-":
                return 1;
            case "*":
                return 2;
            case "/":
                return 2;
            case "(":
                return 3;
            case ")":
                return 3;
            default:
                return 0;
        }
    }
}

MyDC

import java.util.LinkedList;
import java.util.*;

import java.util.*;



public class MyDC {
    public static int evaluate(StringBuilder b) {
        LinkedList<String> mList = new LinkedList<>();
        String[] postStr = b.toString().split(" ");
        int result;
        for (String s : postStr) {
            if (fuhao(s)) {
                if (!mList.isEmpty()) {
                    int num1 = Integer.valueOf(mList.pop());
                    int num2 = Integer.valueOf(mList.pop());
                    if (s.equals("/") && num1 == 0) {
                        System.out.println("除数不能为0");
                        return 0;
                    }
                    int newNum = cal(num2, num1, s);
                    mList.push(String.valueOf(newNum));
                }
            } else {
                mList.push(s);
            }
        }


        result=Integer.parseInt(mList.pop());

        return result;
    }

    private static boolean fuhao(String a) {
        if (a.equals("+") || a.equals("-") || a.equals("/") || a.equals("*")
                || a.equals("(") || a.equals(")")) {
            return true;
        }
        return false;
    }


    private static int cal(int num1, int num2, String operator) {
        switch (operator) {
            case "+":
                return num1 + num2;
            case "-":
                return num1 - num2;
            case "*":
                return num1 * num2;
            case "/":
                return num1 / num2;
            default:
                return 0;
        }
    }
}

MyDCTest

import java.util.LinkedList;
import java.util.*;

public class MyDCTest {
    public static void main(String[] args){
        LinkedList<String> list=new LinkedList<>();
        StringBuilder result1;
        int result2;
        String expression, again;
        System.out.println("请输入一个中缀表达式并以#结束");
        Scanner scanner=new Scanner(System.in);
        String s;
        while (!(s=scanner.next()).equals("#")) {
            list.add(s);
        }
        MyBC hz=new MyBC();
        result1 = hz.houzhui(list);
        System.out.println("后缀表达式： "+result1);
        MyDC evaluator = new MyDC();
        result2 = evaluator.evaluate(result1);
        System.out.println("That expression equals " + result2);
        System.out.println();

    }
}

实验截图

第二题：

结对编程：1人负责客户端，一人负责服务器
0. 注意责任归宿，要会通过测试证明自己没有问题

基于Java Socket实现客户端/服务器功能，传输方式用TCP
客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式通过网络发送给服务器
服务器接收到后缀表达式，调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
客户端显示服务器发送过来的结果
上传测试结果截图和码云链接

套接字是一个网络连接的端点。在java中，使用java.net.Socket对象来表示一个套接字。
要创建一个套接字，可以使用Socket的构造方法，如：public Socket(java.lang.String host, int port)。其中，host是远程机器名或IP地址，port是远程应用程序的端口号。
一旦成功创建了Socket类的一个实例，就可以使用它发送或接收字节流。要发送字节流，必须先调用Socket类的getOutputStream方法来获取一个java.io.OutputStream对象。要向远程应用程序发送文本，通常要从返回的OutputStream对象构建一个java.io.PrintWriter对象。要接收来自连接的另一端的字节流，可以调用Socket类的getInputStream方法，它返回一个java.io.InputStream。

代码如下

Stack

public class MyStack<T> implements SStack<T> {
    private Object element[];
    private int top;
    public MyStack(int size){
        this.element = new Object[Math.abs(size)];
        this.top = -1;
    }
    public MyStack() {
        this(64);
    }
    public boolean isEmpty() {
        return this.top == -1;
    }
    public void push(T x) {
        if(x==null)
            return;
        if(this.top == element.length-1){
            Object[] temp = this.element;
            this.element = new Object[temp.length*2];
            for(int i = 0; i < temp.length; i++)
                this.element[i] = temp[i];
        }
        this.top++;
        this.element[this.top] = x;
    }
    public T pop() {
        return this.top==-1 ? null:(T)this.element[this.top--];
    }
    public T get() {
        return this.top==-1 ? null:(T)this.element[this.top];
    }
}

SStack

public interface SStack<T> {
    boolean isEmpty();
    void push(T x);
    T pop();
    T get();
}

Client（客户端代码）

import java.net.*;
import java.io.*;
public class TCPClient {
    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(); //从键盘读入待发送的数据
            String postfix = MyBC.toPostfix(str);
            out.println(postfix);  //通过网络传送到服务器
            str=in.readLine();//从网络输入流读取结果
            System.out.println( "从服务器接收到的结果为："+str); //输出服务器返回的结果
        }
        catch (Exception e) {
            System.out.println(e);
        }
        finally{
            //stdin.close();
            //in.close();
            //out.close();
            //socket.close();
        }
    }
}

ServerSocket是服务器套接字的一个实现。ServerSocket和Socket不同，服务器套接字的角色是，等待来自客户端的连接请求。一旦服务器套接字获得了一个连接请求，它就会创建一个Socket实例，以处理和客户端的通信。
Service（服务端代码）

import java.net.*;
import java.io.*;
public class TCPServer{
    public static void main(String srgs[]) {
        ServerSocket sc = null;
        Socket socket=null;
        try {
            NewMyDC evaluator = new NewMyDC();
            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); //通过网络输出流返回结果给客户端
            int result = evaluator.value(aline);
            out.println("Echo:" + result);
            out.close();
            in.close();
            sc.close();
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

实验截图：

第三题：

加密结对编程：1人负责客户端，一人负责服务器
0. 注意责任归宿，要会通过测试证明自己没有问题

基于Java Socket实现客户端/服务器功能，传输方式用TCP
客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密后通过网络把密文发送给服务器
服务器接收到后缀表达式表达式后，进行解密（和客户端协商密钥，可以用数组保存），然后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
客户端显示服务器发送过来的结果
上传测试结果截图和码云链接

实现DES加密主要有以下几个步骤：
对称密钥的生成和保存；
使用对称密钥进行加密和解密；
从文件中获取加密时使用的密钥，使用密钥进行解密；

代码如下

客户端加密并发送至服务器部分的代码如下：

            KeyGenerator kg = KeyGenerator.getInstance("DESede");
            kg.init(168);
            SecretKey k = kg.generateKey();
            byte[] ptext2 = k.getEncoded();
            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));
            //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(); // 从键盘读入待发送的数据
            String postfix = MyBC.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); // 通过网络将密文传送到服务器

-服务器解密、计算并发送至客户端部分的代码如下：

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); //打印解密结果
            NewMyDC evaluator = new NewMyDC();
            int _result = evaluator.value(p);
            out.println("Echo:" + _result);
            out.close();
            in.close();
            link.close();

服务端代码如下（Serice)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

import java.io.*;
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;

public class SocketService {
    public static void main(String[] args) throws IOException, IllegalBlockSizeException, InvalidKeyException, BadPaddingException, NoSuchAlgorithmException, NoSuchPaddingException {
        SocketService socketService = new SocketService();
        try {
            socketService.oneServer();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        }
    }
    public  void oneServer() throws IOException, NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
        MyDC mydc=new MyDC();

        try{
            ServerSocket server=null;
            try{
                server=new ServerSocket(5204);
                System.out.println("服务器启动成功");
            }catch(Exception e) {
                System.out.println("没有启动监听："+e);
            }
            Socket socket=null;
            try{
                socket=server.accept();
            }catch(Exception e) {
                System.out.println("Error."+e);
            }
            String line;
            BufferedReader in=new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintWriter writer=new PrintWriter(socket.getOutputStream());

            line=in.readLine();
            System.out.printf("密文=%s
",line);
            // 获取密钥
            byte[]ctext=line.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,"UTF8");




            System.out.println("明文:"+p);
            int a;
            String Np="";
            for(int i=1;i<p.length();i++)
                Np+=p.charAt(i);
            a=mydc.evaluate(Np);

                writer.println(a);
                writer.flush();

            writer.close();
            in.close();
            socket.close();
            server.close();
        }catch(Exception e) {
            System.out.println("Error."+e);
        }
        // 获取密文

    }

}

客户端代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

import java.io.*;
import java.security.*;
import java.util.Arrays;
import javax.crypto.*;

public class SocketClient {
    // 搭建客户端
    public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
        MyBC mybc=new MyBC();
        try {
            Socket socket = new Socket("192.168.43.166",5329);
            System.out.println("客户端启动成功");
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            PrintWriter write = new PrintWriter(socket.getOutputStream());
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            String readline;
            System.out.println("Client:" );
            readline = br.readLine();
            String line=mybc.evaluate(readline);
            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[]=line.getBytes("UTF-8");


            byte ctext[]=cp.doFinal(ptext);
            String Str=new String(ctext,"ISO-8859-1");

            write.println(Str);
            write.flush();






                System.out.println("Server return:" + in.readLine());

            write.close();
            in.close();
            socket.close();

        } catch (Exception e) {
            System.out.println("can not listen to:" + e);
        }

    }

}

实验截图

第四题：

密钥分发结对编程：1人负责客户端，一人负责服务器
0. 注意责任归宿，要会通过测试证明自己没有问题

基于Java Socket实现客户端/服务器功能，传输方式用TCP
客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密通过网络把密文发送给服务器
客户端和服务器用DH算法进行3DES或AES算法的密钥交换
服务器接收到后缀表达式表达式后，进行解密，然后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
客户端显示服务器发送过来的结果
上传测试结果截图和码云链接

执行密钥协定的标准算法是DH算法（Diffie-Hellman算法），分为以下两步：
创建DH公钥和私钥；
创建共享密钥。
创建DH公钥和私钥：

代码如下

public class Key_DH{
    private static final byte skip1024ModulusBytes[] = {
            (byte)0xF4, (byte)0x88, (byte)0xFD, (byte)0x58,
            (byte)0x4E, (byte)0x49, (byte)0xDB, (byte)0xCD,
            (byte)0x20, (byte)0xB4, (byte)0x9D, (byte)0xE4,
            (byte)0x91, (byte)0x07, (byte)0x36, (byte)0x6B,
            (byte)0x33, (byte)0x6C, (byte)0x38, (byte)0x0D,
            (byte)0x45, (byte)0x1D, (byte)0x0F, (byte)0x7C,
            (byte)0x88, (byte)0xB3, (byte)0x1C, (byte)0x7C,
            (byte)0x5B, (byte)0x2D, (byte)0x8E, (byte)0xF6,
            (byte)0xF3, (byte)0xC9, (byte)0x23, (byte)0xC0,
            (byte)0x43, (byte)0xF0, (byte)0xA5, (byte)0x5B,
            (byte)0x18, (byte)0x8D, (byte)0x8E, (byte)0xBB,
            (byte)0x55, (byte)0x8C, (byte)0xB8, (byte)0x5D,
            (byte)0x38, (byte)0xD3, (byte)0x34, (byte)0xFD,
            (byte)0x7C, (byte)0x17, (byte)0x57, (byte)0x43,
            (byte)0xA3, (byte)0x1D, (byte)0x18, (byte)0x6C,
            (byte)0xDE, (byte)0x33, (byte)0x21, (byte)0x2C,
            (byte)0xB5, (byte)0x2A, (byte)0xFF, (byte)0x3C,
            (byte)0xE1, (byte)0xB1, (byte)0x29, (byte)0x40,
            (byte)0x18, (byte)0x11, (byte)0x8D, (byte)0x7C,
            (byte)0x84, (byte)0xA7, (byte)0x0A, (byte)0x72,
            (byte)0xD6, (byte)0x86, (byte)0xC4, (byte)0x03,
            (byte)0x19, (byte)0xC8, (byte)0x07, (byte)0x29,
            (byte)0x7A, (byte)0xCA, (byte)0x95, (byte)0x0C,
            (byte)0xD9, (byte)0x96, (byte)0x9F, (byte)0xAB,
            (byte)0xD0, (byte)0x0A, (byte)0x50, (byte)0x9B,
            (byte)0x02, (byte)0x46, (byte)0xD3, (byte)0x08,
            (byte)0x3D, (byte)0x66, (byte)0xA4, (byte)0x5D,
            (byte)0x41, (byte)0x9F, (byte)0x9C, (byte)0x7C,
            (byte)0xBD, (byte)0x89, (byte)0x4B, (byte)0x22,
            (byte)0x19, (byte)0x26, (byte)0xBA, (byte)0xAB,
            (byte)0xA2, (byte)0x5E, (byte)0xC3, (byte)0x55,
            (byte)0xE9, (byte)0x2F, (byte)0x78, (byte)0xC7
    };
    // The SKIP 1024 bit modulus
    private static final BigInteger skip1024Modulus
            = new BigInteger(1, skip1024ModulusBytes);
    // The base used with the SKIP 1024 bit modulus
    private static final BigInteger skip1024Base = BigInteger.valueOf(2);
    public static void main(String args[ ]) throws Exception{
        DHParameterSpec DHP=
                new DHParameterSpec(skip1024Modulus,skip1024Base);

        KeyPairGenerator kpg= KeyPairGenerator.getInstance("DH");
        kpg.initialize(DHP);
        KeyPair kp=kpg.genKeyPair();

        PublicKey pbk=kp.getPublic();
        PrivateKey prk=kp.getPrivate();
        // 保存公钥
        FileOutputStream  f1=new FileOutputStream(args[0]);
        ObjectOutputStream b1=new  ObjectOutputStream(f1);
        b1.writeObject(pbk);
        // 保存私钥
        FileOutputStream  f2=new FileOutputStream(args[1]);
        ObjectOutputStream b2=new  ObjectOutputStream(f2);
        b2.writeObject(prk);
    }
}

-创建共享密钥:

public class KeyAgree{
    public static void main(String args[ ]) throws Exception{
        // 读取对方的DH公钥
        FileInputStream f1=new FileInputStream(args[0]);
        ObjectInputStream b1=new ObjectInputStream(f1);
        PublicKey  pbk=(PublicKey)b1.readObject( );
//读取自己的DH私钥
        FileInputStream f2=new FileInputStream(args[1]);
        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();
        for(int i=0;i<sb.length;i++){
            System.out.print(sb[i]+",");
        }
        SecretKeySpec k=new  SecretKeySpec(sb,"DESede");
    }
}

实验截图

第五题：

完整性校验结对编程：1人负责客户端，一人负责服务器
0. 注意责任归宿，要会通过测试证明自己没有问题

基于Java Socket实现客户端/服务器功能，传输方式用TCP
客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密通过网络把密文和明文的MD5値发送给服务器
客户端和服务器用DH算法进行3DES或AES算法的密钥交换
服务器接收到后缀表达式表达式后，进行解密，解密后计算明文的MD5值，和客户端传来的MD5进行比较，一致则调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
客户端显示服务器发送过来的结果

代码如下：

Service

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

import java.io.*;
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;

public class SocketService {
    public static void main(String[] args) throws IOException, IllegalBlockSizeException, InvalidKeyException, BadPaddingException, NoSuchAlgorithmException, NoSuchPaddingException {
        SocketService socketService = new SocketService();
        try {
            socketService.oneServer();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        }
    }
    public  void oneServer() throws IOException, NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
        MyDC mydc=new MyDC();

        try{
            ServerSocket server=null;
            try{
                server=new ServerSocket(5329);
                System.out.println("服务器启动成功");
            }catch(Exception e) {
                System.out.println("没有启动监听："+e);
            }
            Socket socket=null;
            try{
                socket=server.accept();
            }catch(Exception e) {
                System.out.println("Error."+e);
            }
            String line;
            BufferedReader in=new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintWriter writer=new PrintWriter(socket.getOutputStream());

            line=in.readLine();
            String line1=in.readLine();
            System.out.printf("密文=%s
",line);
            // 获取密钥
            byte[]ctext=line.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,"UTF8");

            int a;


            System.out.println("明文:"+p);
            String Np="";
            for(int i=1;i<p.length();i++)
                Np+=p.charAt(i);
            a=mydc.evaluate(Np);
            String x=p;
            MessageDigest m=MessageDigest.getInstance("MD5");
            m.update(x.getBytes("UTF8"));
            byte s[ ]=m.digest( );
            String result="";
            for (int i=0; i<s.length; i++){
                result+=Integer.toHexString((0x000000ff & s[i]) |
                        0xffffff00).substring(6);
            }
            if(!(line1.equals(result)))System.out.printf("MD5比对正确！
");

            writer.println(a);
            writer.flush();

            writer.close();
            in.close();
            socket.close();
            server.close();
        }catch(Exception e) {
            System.out.println("Error."+e);
        }
        // 获取密文

    }

创建共享密钥

public class KeyAgree{
    public static void main(String args[ ]) throws Exception{
        // 读取对方的DH公钥
        FileInputStream f1=new FileInputStream(args[0]);
        ObjectInputStream b1=new ObjectInputStream(f1);
        PublicKey  pbk=(PublicKey)b1.readObject( );
//读取自己的DH私钥
        FileInputStream f2=new FileInputStream(args[1]);
        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();
        for(int i=0;i<sb.length;i++){
            System.out.print(sb[i]+",");
        }
        SecretKeySpec k=new  SecretKeySpec(sb,"DESede");
    }
}

实验截图

码云链接

实验总结与体会

这次实验是java这门课程的最后一次实验，在这次实验中拿到题目的第一反应就是怎么办呀，老师也没给教程，什么都没有，好无助，好绝望呀。
但是想想再挣扎一下吧，代码好难不会写怎么办呀，最后拿了学长的代码来用，拿来的代码也有很多问题，慢慢改到能编译了，发现运行结果不对，再继续修改到，编译运行都对了。本次实验花了两天时间，虽然时间花费了很多，但也学习到了很多知识。我认为这次实验完成的很棒。{{uploading-image-522164.png(uploading...)}}

重温本次实验，真正的用到了结对编程。虽然代码不是自己的，重新仔细的看了一遍。明白了每段代码发挥的作用。相对与信息安全专业来说，密码是保证信息安全得重要手段，本次实验让我们体会到了编程实现密码算法对信息安全的实用性，正确性。

实验中的一些重点问题：

-对称加密-DES算法

相关阅读:
insert 语句后面的一些参数使用知识
 mysql通信协议的半双工机制理解
 整理超级全局变量与全局变量的知识
 php获取输入流
 插入数据sql使用“insert into set”形式的理解
 《LINUX与UNIX SHELL编程指南》学习笔记
 转载别人空间的一篇好文技术没有转换成生产力
 C# 查找打开的窗口
 sql:inner join,left join,right join,full join的用法及含义
 pc doctor启动到进度条的时候自动退出
原文地址：https://www.cnblogs.com/hpl20155329/p/6925704.html