2018-2019-20175225 實驗五《網絡編程與安全》實驗報告

實驗步驟

任務一

• 兩人一組結對編程
• 結對實現中綴表達式轉後綴表達式的功能 MyBC.java
• 結對實現從上面功能中獲取的表達式中實現後綴表達式求值的功能,調用MyDC.java

實驗過程

• 將運算符寫在兩個操做數中間的表達式，稱爲「中綴表達式」，如1+2*(3-4)+5。在中綴表達式中，運算符具備不一樣的優先級，圓括號用於改變運算符的運算次序，因此求值過程不能直接按照從左到右的順序進行。

• 將運算符寫在兩個操做數以後的表達式稱爲「後綴表達式」，如上面的中綴表達式可轉換爲後綴表達式1 2 3 4 - * + 5 +。後綴表達式中沒有括號，並且運算符沒有優先級。後綴表達式的求值過程可以嚴格地從左到右按順序進行，符合運算器的求值規律。

• 表達式求值算法分兩步進行：①中綴轉後綴；②求後綴表達式的值。

• 由中綴式求得後綴式可使用棧，僞代碼以下：
  • 設立一個棧，存放運算符，首先棧爲空；
  • 從左到右掃描中綴式，若遇到操做數，直接輸出，並輸出一個空格做爲兩個操做數的分隔符；
  • 若遇到運算符，則與棧頂比較，比棧頂級別高則進棧，不然退出棧頂元素並輸出，而後輸出一個空格做分隔符；
  • 若遇到左括號，進棧；若遇到右括號，則一直退棧輸出，直到退到左括號止。
  • 當棧變成空時，輸出的結果即爲後綴表達式。

實驗主要代碼

• 中綴轉後綴

package shiyan5;

import java.util.Stack;
public class MyBC{
    String jieguo = "";
    public MyBC (String[] args) {
        Stack<String> z = new Stack<String>();
        String t = "";
        for (int i = 0; i < args.length; i++) {
            switch (args[i]) {
                case "(":
                    z.push(args[i]);
                    break;
                case "+":
                case "-":
                    while(z.empty() != true) {
                        t = z.pop();
                        if (t.equals("(")) {
                            z.push(t);
                            break;
                        }
                        jieguo = jieguo + t + " ";
                    }
                    z.push(args[i]);
                    break;
                case "*":
                case "/":
                    while(z.empty() != true) {
                        t = z.pop();
                        if (t.equals("+") || t.equals("-") || t.equals("(")) {
                            z.push(t);
                            break;
                        }
                        jieguo = jieguo + t + " ";
                    }
                    z.push(args[i]);
                    break;
                case ")":
                    while (z.empty()== false) {
                        t = z.pop();
                        if (t.equals("(")) {
                            break;
                        } else {
                            jieguo = jieguo + t + " ";
                        }
                    }
                    break;
                case" ":
                    break;

                default:
                    jieguo = jieguo + args[i] + " ";
                    break;
            }

        }

        while (z.empty() == false) {
            jieguo = jieguo + z.pop() + " ";
        }
        System.out.println(jieguo);
    }
}

實驗結果

任務二

• 結對編程：1人負責客戶端，一人負責服務器
• 注意責任歸宿，要會經過測試證實本身沒有問題
• 基於Java Socket實現客戶端/服務器功能，傳輸方式用TCP
• 客戶端讓用戶輸入中綴表達式，而後把中綴表達式調用MyBC.java的功能轉化爲後綴表達式，把後綴表達式經過網絡發送給服務器
• 服務器接收到後綴表達式，調用MyDC.java的功能計算後綴表達式的值，把結果發送給客戶端
• 客戶端顯示服務器發送過來的結果

實驗過程

• 經過終端中輸入ipconfig 或者使用InetAddress類的靜態方法getLocalHost()得到一個InetAddress的對象獲取服務器端IP地址
• 客戶端經過命令行輸入待鏈接的服務器的IP地址
  • 調用InetAddress類中的geetByName方法獲取輸入的IP地址；
  • 建立一個套接字，可使用Socket的構造方法，如：public Socket(java.lang.String host, int port) 其中，host是遠程機器名或IP地址，port是遠程應用程序的端口號。
  • 方法getInputStream() 得到一個輸入流
  • 方法getOutputStream() 得到一個輸出流
• 服務器端調用ServerSocket實現套接字
  • 使用accept() 方法鏈接客戶端和服務器的套接字
  • 方法getInputStream() 得到一個輸入流
  • 方法getOutputStream() 得到一個輸出流

實驗代碼

• 獲取本機的地址

package shiyan5;

import java.net.*;
public class getHostAddress {
    public static void main(String[] args) {
        try{
            InetAddress hostaddress = InetAddress.getLocalHost();
            System.out.println(hostaddress.toString());
        }catch (UnknownHostException e){
            System.out.println(e);
        }
    }
}

• 客戶端

package 實驗五;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.Socket;
import java.util.Scanner;

public class Client {
    public static void main(String[] args) {
        Scanner inn = new Scanner(System.in);
        Socket mysocket;
        DataInputStream in = null;
        DataOutputStream out = null;
        try{
            mysocket = new Socket("192.168.56.1",2010);
            in = new DataInputStream(mysocket.getInputStream());
            out = new DataOutputStream(mysocket.getOutputStream());
            System.out.println("請輸入中綴表達式：");
            String infix = inn.nextLine();
            String [] str = infix.split(" ");
            System.out.println("已傳遞後綴表達式");
            MyBC suffix =new MyBC(str);
            out.writeUTF(suffix.jieguo);
            String result = in.readUTF();
            System.out.println("已收到計算結果"+result);
            Thread.sleep(500);
        }catch (Exception e){
            System.out.println("雙方已斷開鏈接"+e);
        }
    }
}

• 服務器端

package 實驗五;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class Sever {
    public static void main(String[] args) {
        ServerSocket serverForClient = null;
        Socket socketOnServer = null;
        DataOutputStream out = null;
        DataInputStream in = null;

        try{
            serverForClient = new ServerSocket(2010);
        }catch (IOException e){
            System.out.println("雙方已斷開鏈接"+e);
        }
        try{
            System.out.println("準備接受對方傳來的問題");
            socketOnServer = serverForClient.accept();
            out = new DataOutputStream(socketOnServer.getOutputStream());
            in = new DataInputStream(socketOnServer.getInputStream());
            String suffix = in.readUTF();
            String [] str = suffix.split(" ");
            System.out.println("收到問題，正在解決:"+suffix);
            System.out.println("已傳輸得出結果：");
            MyDC myDC = new MyDC(str);
            String answer =  String.valueOf(myDC.answer);
            out.writeUTF(answer+"");
            Thread.sleep(500);
        }catch (Exception e){
            System.out.println("雙方已斷開鏈接");
        }
    }
}

實驗結果

• 客戶端

• 服務器端

任務三

• 加密結對編程：1人負責客戶端，一人負責服務器
• 注意責任歸宿，要會經過測試證實本身沒有問題
• 基於Java Socket實現客戶端/服務器功能，傳輸方式用TCP
• 客戶端讓用戶輸入中綴表達式，而後把中綴表達式調用MyBC.java的功能轉化爲後綴表達式，把後綴表達式用DES或AES算法加密後經過網絡把密文發送給服務器
• 服務器接收到後綴表達式表達式後，進行解密（和客戶端協商密鑰，能夠用數組保存），而後調用MyDC.java的功能計算後綴表達式的值，把結果發送給客戶端
• 客戶端顯示服務器發送過來的結果

實驗過程

• 實現DES加密主要有如下幾個步驟：
  • 對稱密鑰的生成和保存；
  • 使用對稱密鑰進行加密和解密；
  • 從文件中獲取加密時使用的密鑰，使用密鑰進行解密；
• 生成密鑰文件

實驗代碼

• 客戶端

package 實驗五;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.Socket;
import java.util.Scanner;

public class Client1{
    public static void main(String[] args) {
        Scanner inn = new Scanner(System.in);
        Socket mysocket;
        DataInputStream in = null;
        DataOutputStream out = null;
        try{
            mysocket = new Socket("192.168.56.1",2010);
            in = new DataInputStream(mysocket.getInputStream());
            out = new DataOutputStream(mysocket.getOutputStream());
            KeyGenerator kg = KeyGenerator.getInstance("DESede");
            kg.init(168);
            SecretKey k = kg.generateKey();
            byte []kb = k.getEncoded();
            out.writeUTF(kb.length+ "");
            System.out.println("產生的密鑰爲");
            for(int i=0;i<kb.length;i++) {
                System.out.print(kb[i]+ " ");
                out.writeUTF(kb[i] +"");
            }
            System.out.println("\n請輸入中綴表達式：");
            String infix = inn.nextLine();
            String [] str = infix.split(" ");
            System.out.println("後綴表達式爲");
            MyBC suffix =new MyBC(str);
            Cipher cp = Cipher.getInstance("DESede");
            cp.init(Cipher.ENCRYPT_MODE,k);
            byte ptext[] = suffix.jieguo.getBytes("UTF8");
            byte ctext[] = cp.doFinal(ptext);
            out.writeUTF(ctext.length + "");
            for(int i=0;i<ctext.length;i++) {
                out.writeUTF(ctext[i] +"");
            }
            String result = in.readUTF();
            System.out.println("已收到計算結果"+result);
            Thread.sleep(500);
        }catch (Exception e){
            System.out.println("雙方已斷開鏈接"+e);
        }
    }
}

• 服務器端

package 實驗五;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class Sever1{
    public static void main(String[] args) {
        ServerSocket serverForClient = null;
        Socket socketOnServer = null;
        DataOutputStream out = null;
        DataInputStream in = null;
        try{
            serverForClient = new ServerSocket(2010);
        }catch (IOException e){
            System.out.println("雙方已斷開鏈接"+e);
        }
        try{
            System.out.println("準備接受對方傳來的問題");
            socketOnServer = serverForClient.accept();
            out = new DataOutputStream(socketOnServer.getOutputStream());
            in = new DataInputStream(socketOnServer.getInputStream());
            String keylength = in.readUTF();
            byte []kb = new byte[Integer.parseInt(keylength)];
            System.out.println("收到的密鑰爲：");
            for(int i = 0;i<Integer.parseInt(keylength);i++) {
                String str = in.readUTF();
                kb[i] = Byte.parseByte(str);
                System.out.print(kb[i] + " ");
            }
            SecretKeySpec k = new SecretKeySpec(kb, "DESede");
            Cipher cp = Cipher.getInstance("DESede");
            cp.init(Cipher.DECRYPT_MODE, k);
            String clength = in.readUTF();
            byte ctext[] = new byte[Integer.parseInt(clength)];
            for (int i = 0;i<Integer.parseInt(clength);i++) {
                String temp = in.readUTF();
                ctext[i] = Byte.parseByte(temp);
            }
            byte[] ptext = cp.doFinal(ctext);
            String suffix = new String(ptext,"UTF8");
            String [] str = suffix.split(" ");
            System.out.println("\n收到問題，解密後的後綴表達式爲:"+suffix);
            System.out.println("已傳輸得出結果：");
            MyDC myDC = new MyDC(str);
            String answer =  String.valueOf(myDC.answer);
            out.writeUTF(answer+"");
            Thread.sleep(500);
        }catch (Exception e){
            System.out.println("雙方已斷開鏈接");
        }
    }
}

實驗結果

• 客戶端
  

• 服務器端
  

任務四

• 密鑰分發結對編程：1人負責客戶端，一人負責服務器
• 注意責任歸宿，要會經過測試證實本身沒有問題
• 基於Java Socket實現客戶端/服務器功能，傳輸方式用TCP
• 客戶端讓用戶輸入中綴表達式，而後把中綴表達式調用MyBC.java的功能轉化爲後綴表達式，把後綴表達式用DES或AES算法加密經過網絡把密文發送給服務器
• 客戶端和服務器用DH算法進行DES或AES算法的密鑰交換
• 服務器接收到後綴表達式表達式後，進行解密，而後調用MyDC.java的功能計算後綴表達式的值，把結果發送給客戶端
• 客戶端顯示服務器發送過來的結果

實驗過程

• 兩人先使用Key_DH類生成各自的DH公鑰和私鑰
• 倆人使用對方的公鑰和本身的私鑰，用KeyAgree，生成共享密鑰
• 客戶端使用共享密鑰對原有的密鑰進行加密，並把密文和加密後的密鑰傳輸給服務器
• 服務器先用共享密鑰對客戶端加密的密鑰進行解密，再用解密後的密鑰解密密文

實驗代碼

• 客戶端

package 實驗五;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
import java.security.*;
import java.util.Scanner;
import java.net.*;
public class Client2 {
    public static void main(String[] args) {
        Scanner inn = new Scanner(System.in

        );
        Socket mysocket;
        DataInputStream in = null;
        DataOutputStream out = null;
        try{
            mysocket = new Socket("192.168.56.1",2010);
                    in = new DataInputStream(mysocket.getInputStream());
            out = new DataOutputStream(mysocket.getOutputStream());
            Key_DH.DH ("Lpub.dat","Lpri.dat");
            FileInputStream my = new FileInputStream("Lpub.dat");
            ObjectInputStream mypub = new ObjectInputStream(my);
            Key kp = (Key) mypub.readObject();
            ByteArrayOutputStream DH = new ByteArrayOutputStream();
            ObjectOutputStream myDH = new ObjectOutputStream(DH);
            myDH.writeObject(kp);
            byte []pub = DH.toByteArray();
            out.writeUTF(pub.length+"");
            for(int i=0;i<pub.length;i++) {
                out.writeUTF(pub[i]+ "");
            }
            Thread.sleep(1000);
            int length = Integer.parseInt(in.readUTF());
            byte cpub[] = new byte[length];
            for(int i=0;i<length;i++) {
                String temp = in.readUTF();
                cpub[i] = Byte.parseByte(temp);
            }
            ByteArrayInputStream ckey1 = new ByteArrayInputStream(cpub);
            ObjectInputStream ckey = new ObjectInputStream(ckey1);
            Key k = (Key) ckey.readObject();
            FileOutputStream f2 = new FileOutputStream("W1pub.dat");
            ObjectOutputStream b2 = new ObjectOutputStream(f2);
            b2.writeObject(k);
            KeyAgree.Agree("W1pub.dat","Lpri.dat");
            FileInputStream f = new FileInputStream("sb.dat");
            byte[] keysb = new byte[24];
            f.read(keysb);
            System.out.println("公共密鑰爲：");
            for (int i = 0;i<24;i++) {
                System.out.print(keysb[i]+" ");
            }
            System.out.println("\n請輸入中綴表達式：");
            String infix = inn.nextLine();
            String [] str = infix.split(" ");
            System.out.println("已傳遞後綴表達式");
            MyBC suffix =new MyBC(str);
            SecretKeySpec k1 = new SecretKeySpec(keysb, "DESede");
            Cipher cp = Cipher.getInstance("DESede");
            cp.init(Cipher.ENCRYPT_MODE, k1);
            byte ptext[] = suffix.jieguo.getBytes("UTF8");
            byte ctext[] = cp.doFinal(ptext);
            System.out.println("加密後的後綴表達式爲：");
            for (int i = 0; i < ctext.length; i++) {
                System.out.print(ctext[i] + " ");
            }
            out.writeUTF(ctext.length + "");
            for (int i = 0; i < ctext.length; i++) {
                out.writeUTF(ctext[i] + "");
            }
            String result = in.readUTF();
            System.out.println("\n已收到計算結果"+result);
            Thread.sleep(500);
        }catch (Exception e){
            System.out.println("雙方已斷開鏈接"+e);
        }
    }
}

• 服務器端

package 實驗五;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.security.Key;
public class Sever2{
    public static void main(String[] args) {
        ServerSocket serverForClient = null;
        Socket socketOnServer = null;
        DataOutputStream out = null;
        DataInputStream in = null;
        try{
            serverForClient = new ServerSocket(2010);
        }catch (IOException e){
            System.out.println("雙方已斷開鏈接"+e);
        }
        try{
            System.out.println("準備接受對方傳來的問題");
            socketOnServer = serverForClient.accept();
            out = new DataOutputStream(socketOnServer.getOutputStream());
            in = new DataInputStream(socketOnServer.getInputStream());
            Key_DH.DH("Wpub.dat","Wpri.dat");
            int length = Integer.parseInt(in.readUTF());
            byte cpub[] = new byte[length];
            for(int i=0;i<length;i++) {
                String temp = in.readUTF();
                cpub[i] = Byte.parseByte(temp);
            }
            ByteArrayInputStream ckey1 = new ByteArrayInputStream(cpub);
            ObjectInputStream ckey = new ObjectInputStream(ckey1);
            Key k1 = (Key) ckey.readObject();
            FileOutputStream f2 = new FileOutputStream("Lpub.dat");
            ObjectOutputStream b2 = new ObjectOutputStream(f2);
            b2.writeObject(k1);
            FileInputStream my = new FileInputStream("Wpub.dat");
            ObjectInputStream mypub = new ObjectInputStream(my);
            Key kp = (Key) mypub.readObject();
            ByteArrayOutputStream DH = new ByteArrayOutputStream();
            ObjectOutputStream myDH = new ObjectOutputStream(DH);
            myDH.writeObject(kp);
            byte []pub = DH.toByteArray();
            out.writeUTF(pub.length+"");
            for(int i=0;i<pub.length;i++) {
                out.writeUTF(pub[i]+ "");
            }
            KeyAgree.Agree("Lpub.dat","Wpri.dat");
            FileInputStream f = new FileInputStream("sb.dat");
            byte[] keysb = new byte[24];
            f.read(keysb);
            System.out.println("公共密鑰爲：");
            for (int i = 0;i<24;i++) {
                System.out.print(keysb[i]+" ");
            }
            SecretKeySpec k = new SecretKeySpec(keysb, "DESede");
            Cipher cp = Cipher.getInstance("DESede");
            cp.init(Cipher.DECRYPT_MODE, k);
            String clength = in.readUTF();
            byte ctext[] = new byte[Integer.parseInt(clength)];
            for (int i = 0; i < Integer.parseInt(clength); i++) {
                String temp = in.readUTF();
                ctext[i] = Byte.parseByte(temp);
            }
            byte[] ptext = cp.doFinal(ctext);
            String suffix = new String(ptext, "UTF8");
            String [] str = suffix.split(" ");
            System.out.println("\n收到問題，正在解密後綴表達式:"+suffix);
            System.out.println("已傳輸得出結果：");
            MyDC myDC = new MyDC(str);
            String answer =  String.valueOf(myDC.answer);
            out.writeUTF(answer+"");
            Thread.sleep(500);
        }catch (Exception e){
            System.out.println("雙方已斷開鏈接");
        }
    }
}

• KeyAgree

package 實驗五;

import javax.crypto.KeyAgreement;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.security.PrivateKey;
import java.security.PublicKey;

public class KeyAgree {
    public static void Agree(String str1,String str2) throws Exception{
        // 讀取對方的DH公鑰
        FileInputStream f1=new FileInputStream(str1);
        ObjectInputStream b1=new ObjectInputStream(f1);
        PublicKey  pbk=(PublicKey)b1.readObject( );
//讀取本身的DH私鑰
        FileInputStream f2=new FileInputStream(str2);
        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();
        FileOutputStream fsb = new FileOutputStream("sb.dat");
        fsb.write(sb);
    }
}

• Key_DH

package 實驗五;

import javax.crypto.spec.DHParameterSpec;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.math.BigInteger;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;

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 DH(String str1,String str2) 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(str1);
        ObjectOutputStream b1=new  ObjectOutputStream(f1);
        b1.writeObject(pbk);
        // 保存私鑰
        FileOutputStream  f2=new FileOutputStream(str2);
        ObjectOutputStream b2=new  ObjectOutputStream(f2);
        b2.writeObject(prk);
    }
}

實驗結果

• 客戶端
  

• 服務器端
  

任務五

• 完整性校驗結對編程：1人負責客戶端，一人負責服務器
• 注意責任歸宿，要會經過測試證實本身沒有問題
• 基於Java Socket實現客戶端/服務器功能，傳輸方式用TCP
• 客戶端讓用戶輸入中綴表達式，而後把中綴表達式調用MyBC.java的功能轉化爲後綴表達式，把後綴表達式用3DES或AES算法加密經過網絡把密文和明文的MD5値發送給服務器
• 客戶端和服務器用DH算法進行3DES或AES算法的密鑰交換
• 服務器接收到後綴表達式表達式後，進行解密，解密後計算明文的MD5值，和客戶端傳來的MD5進行比較，一致則調用MyDC.java的功能計算後綴表達式的值，把結果發送給客戶端
• 客戶端顯示服務器發送過來的結果

實驗代碼

• 客戶端

package 實驗五;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
import java.net.Socket;
import java.security.Key;
import java.util.Scanner;

public class Client3 {
    public static void main(String[] args) {
        Scanner inn = new Scanner(System.in

        );
        Socket mysocket;
        DataInputStream in = null;
        DataOutputStream out = null;
        try{
            mysocket = new Socket("192.168.56.1",2010);
                    in = new DataInputStream(mysocket.getInputStream());
            out = new DataOutputStream(mysocket.getOutputStream());
            Key_DH.DH("Lpub.dat","Lpri.dat");
            FileInputStream my = new FileInputStream("Lpub.dat");
            ObjectInputStream mypub = new ObjectInputStream(my);
            Key kp = (Key) mypub.readObject();
            ByteArrayOutputStream DH = new ByteArrayOutputStream();
            ObjectOutputStream myDH = new ObjectOutputStream(DH);
            myDH.writeObject(kp);
            byte []pub = DH.toByteArray();
            out.writeUTF(pub.length+"");
            for(int i=0;i<pub.length;i++) {
                out.writeUTF(pub[i]+ "");
            }
            Thread.sleep(1000);
            int length = Integer.parseInt(in.readUTF());
            byte cpub[] = new byte[length];
            for(int i=0;i<length;i++) {
                String temp = in.readUTF();
                cpub[i] = Byte.parseByte(temp);
            }
            ByteArrayInputStream ckey1 = new ByteArrayInputStream(cpub);
            ObjectInputStream ckey = new ObjectInputStream(ckey1);
            Key k = (Key) ckey.readObject();
            FileOutputStream f2 = new FileOutputStream("W1pub.dat");
            ObjectOutputStream b2 = new ObjectOutputStream(f2);
            b2.writeObject(k);
            KeyAgree.Agree("W1pub.dat","Lpri.dat");
            FileInputStream f = new FileInputStream("sb.dat");
            byte[] keysb = new byte[24];
            f.read(keysb);
            System.out.println("公共密鑰爲：");
            for (int i = 0;i<24;i++) {
                System.out.print(keysb[i]+" ");
            }
            System.out.println("\n請輸入中綴表達式：");
            String infix = inn.nextLine();
            String [] str = infix.split(" ");
            System.out.println("已傳遞後綴表達式");
            MyBC suffix =new MyBC(str);
            String mtoMD5 = DigestPass.MD5(suffix.jieguo);
            System.out.println("明文的MD5值爲："+mtoMD5);
            out.writeUTF(mtoMD5);
            SecretKeySpec k1 = new SecretKeySpec(keysb, "DESede");
            Cipher cp = Cipher.getInstance("DESede");
            cp.init(Cipher.ENCRYPT_MODE, k1);
            byte ptext[] = suffix.jieguo.getBytes("UTF8");
            byte ctext[] = cp.doFinal(ptext);
            System.out.println("加密後的後綴表達式爲：");
            for (int i = 0; i < ctext.length; i++) {
                System.out.print(ctext[i] + " ");
            }
            out.writeUTF(ctext.length + "");
            for (int i = 0; i < ctext.length; i++) {
                out.writeUTF(ctext[i] + "");
            }
            String result = in.readUTF();
            System.out.println("\n已收到計算結果"+result);
            Thread.sleep(500);
        }catch (Exception e){
            System.out.println("雙方已斷開鏈接"+e);
        }
    }
}

• 服務器端

package 實驗五;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.security.Key;
public class Sever3 {
    public static void main(String[] args) {
        ServerSocket serverForClient = null;
        Socket socketOnServer = null;
        DataOutputStream out = null;
        DataInputStream in = null;

        try{
            serverForClient = new ServerSocket(2010);
        }catch (IOException e){
            System.out.println("雙方已斷開鏈接"+e);
        }
        try{
            System.out.println("準備接受對方傳來的問題");
            socketOnServer = serverForClient.accept();
            out = new DataOutputStream(socketOnServer.getOutputStream());
            in = new DataInputStream(socketOnServer.getInputStream());
            Key_DH.DH("Wpub.dat","Wpri.dat");
            int length = Integer.parseInt(in.readUTF());
            byte cpub[] = new byte[length];
            for(int i=0;i<length;i++) {
                String temp = in.readUTF();
                cpub[i] = Byte.parseByte(temp);
            }
            ByteArrayInputStream ckey1 = new ByteArrayInputStream(cpub);
            ObjectInputStream ckey = new ObjectInputStream(ckey1);
            Key k1 = (Key) ckey.readObject();
            FileOutputStream f2 = new FileOutputStream("L1pub.dat");
            ObjectOutputStream b2 = new ObjectOutputStream(f2);
            b2.writeObject(k1);
            FileInputStream my = new FileInputStream("Wpub.dat");
            ObjectInputStream mypub = new ObjectInputStream(my);
            Key kp = (Key) mypub.readObject();
            ByteArrayOutputStream DH = new ByteArrayOutputStream();
            ObjectOutputStream myDH = new ObjectOutputStream(DH);
            myDH.writeObject(kp);
            byte []pub = DH.toByteArray();
            out.writeUTF(pub.length+"");
            for(int i=0;i<pub.length;i++) {
                out.writeUTF(pub[i]+ "");
            }
            KeyAgree.Agree("L1pub.dat","Wpri.dat");
            FileInputStream f = new FileInputStream("sb.dat");
            byte[] keysb = new byte[24];
            f.read(keysb);
            System.out.println("公共密鑰爲：");
            for (int i = 0;i<24;i++) {
                System.out.print(keysb[i]+" ");
            }
            String c = in.readUTF();
            SecretKeySpec k = new SecretKeySpec(keysb, "DESede");
            Cipher cp = Cipher.getInstance("DESede");
            cp.init(Cipher.DECRYPT_MODE, k);
            String clength = in.readUTF();
            byte ctext[] = new byte[Integer.parseInt(clength)];
            for (int i = 0; i < Integer.parseInt(clength); i++) {
                String temp = in.readUTF();
                ctext[i] = Byte.parseByte(temp);
            }
            byte[] ptext = cp.doFinal(ctext);
            String suffix = new String(ptext, "UTF8");
            String [] str = suffix.split(" ");
            System.out.println("\n收到問題，解密後綴表達式爲:"+suffix);
            String mtoMD5 = DigestPass.MD5(suffix);
            System.out.println("MD5的值爲"+ mtoMD5);
            if(mtoMD5.equals(c)) {
                System.out.println("傳遞的MD5值和解密的後綴表達式的MD5值相同，能夠解密！");
                System.out.println("已傳輸得出結果：");
                MyDC myDC = new MyDC(str);
                String answer = String.valueOf(myDC.answer);
                out.writeUTF(answer + "");
            }
            else {
                System.out.println("密文有誤，不能解密！");
            }
            Thread.sleep(500);
        }catch (Exception e){
            System.out.println("雙方已斷開鏈接");
        }
    }
}

實驗結果

• 客戶端
  

• 服務器端
  

碼雲連接