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

時間 2019-12-04

原文原文鏈接

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

實驗步驟

任務一java

兩人一組結對編程
結對實現中綴表達式轉後綴表達式的功能 MyBC.java
結對實現從上面功能中獲取的表達式中實現後綴表達式求值的功能,調用MyDC.java
實驗過程
以前結隊編程作過同樣的題目，因此就肥腸簡單啦
爲何要將中綴表達式轉爲後綴表達式
中綴表達式，雖然符合咱們的數學計算習慣，可是並不符合計算機運算的方式
後綴表達式嚴格按照從左到右進行計算的模式符合計算機運行方式而中綴表達式須要計算機遇到符號後向後掃描一位若爲括號或優先級更高的操做符還須要向後繼續掃描
後綴表達式的定義
後綴表達式(又稱爲逆波蘭reverse polish)就是不須要括號就能夠實現調整運算順序的一種技法。
好比：ab+cde+**，改成中綴表達式實際上是(a+b)*((d+e)*c)
後綴表達式不含括號
中綴轉後綴
重要的數據結構----棧
若是讀入操做數，則直接放入輸出字符串；若是讀入通常運算符如+-*/，則放入堆棧，可是放入堆棧以前必需要檢查棧頂，並肯定棧頂運算符的優先級比放入的運算符的優先級低；若是放入的優先級較低，則須要將棧頂的運算符放入輸出字符串
若是讀入(，由於左括號優先級最高，所以放入棧中，可是注意，當左括號放入棧中後，則優先級最低
若是讀入），則將棧中運算符取出放入輸出字符串，直到取出（爲止，注意：（）不輸出到輸出字符串順序讀完表達式，若是棧中還有操做符，則彈出，並放入輸出字符串
後綴表達式的計算
從左到右掃描後綴表達式
若是遇到操做數，將其壓入棧中
若是遇到操做符，則從棧中彈出兩個操做數，計算結果真後把結果入棧直到遍歷完後綴表達式，則計算完成
此時的棧頂元素即爲計算結果。
實驗代碼

/* creat by xyw,cyy
*/
import java.util.Stack;

public class MyBC {
    MyBC(){}
    public static String infixToSuffix(String exp){
        Stack<String> s = new Stack<String>();         // 建立操做符堆棧
        String suffix = "";            // 要輸出的後綴表達式字符串
        String suffix1 = "";             //上一次的後綴表達式
        String suffix2 = "";
        String str[] = exp.split(" ");
        int length = str.length; // 輸入的中綴表達式的長度
        String temp="";
        for (int i = 0; i < length; i++) {            // 對該中綴表達式的每個字符並進行判斷
            switch (str[i]) {
                case " ":break;           // 忽略空格
                case "(":
                    s.push(str[i]);                  // 若是是左括號直接壓入堆棧
                    break;
                case "+":
                case "-":
                    if(s.size() != 0){          // 碰到'+' '-'，將棧中的全部運算符所有彈出去，直至碰到左括號爲止，輸出到隊列中去
                        temp = s.pop();
                        if (temp.equals("(")) {     // 將左括號放回堆棧，終止循環
                            s.push(temp);
                            s.push(str[i]);
                            break;
                        }
                        else{
                            s.push(str[i]);
                            suffix2 = suffix2 + temp + " ";
                            break;
                        }
                    }
                    else{
                        s.push(str[i]);      // 說明是當前爲第一次進入或者其餘前面運算都有括號等狀況致使棧已經爲空,此時須要將符號進棧
                        break;
                    }
                    // 若是是乘號或者除號，則彈出全部序列，直到碰到加好、減號、左括號爲止，最後將該操做符壓入堆棧
                case "*":
                case "÷":
                    if(s.size()!=0){
                        temp = s.pop();
                        if(temp.equals("+")||temp.equals("-")||temp.equals("(")){
                            s.push(temp);
                            s.push(str[i]);
                            break;
                        }
                        else{
                            s.push(str[i]);
                            suffix2 = suffix2+temp+" ";
                            break;
                        }
                    }
                    else {
                        s.push(str[i]);     //當前爲第一次進入或者其餘前面運算都有括號等狀況致使棧已經爲空,此時須要將符號進棧
                        break;
                    }
                    // 若是碰到的是右括號，則距離棧頂的第一個左括號上面的全部運算符彈出棧並拋棄左括號
                case ")":
                    while (!s.isEmpty()) {
                        temp = s.pop();
                        if (temp.equals("(")) {
                            break;
                        } else {
                            suffix2 = suffix2+temp+" ";
                        }
                    }
                    break;
                // 默認狀況，若是讀取到的是數字，則直接送至輸出序列
                default:
                    suffix2 = suffix2+str[i]+" ";
                    break;
            }

        }
        // 若是堆棧不爲空，則把剩餘運算符一次彈出，送至輸出序列
        while (s.size() != 0) {
            suffix2 = suffix2+s.pop()+" ";
        }
        if(suffix1.equals("")){          //第一個題目
            suffix1 = suffix2;
            suffix = suffix2;
        }
        else{
            if(suffix2.equals(suffix1))
                suffix = "";
            else
                suffix = suffix2;
        }
        suffix1 = suffix2;
        return suffix;
    }
}

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

import java.io.*;
import java.net.*;
public class Server {
    public static void main(String args[]) {
        int answer;
        ServerSocket serverForClient=null;
        Socket socketOnServer=null;
        DataOutputStream out=null;
        DataInputStream  in=null;
        try { serverForClient = new ServerSocket(2010);
        }
        catch(IOException e1) {
            System.out.println(e1);
        }
        try{ System.out.println("等待客戶呼叫");
            socketOnServer = serverForClient.accept(); //堵塞狀態，除非有客戶呼叫
            out=new DataOutputStream(socketOnServer.getOutputStream());
            in=new DataInputStream(socketOnServer.getInputStream());
            String s=in.readUTF(); // in讀取信息，堵塞狀態
            System.out.println("服務器收到客戶的提問:"+s);
            MyDC d=new MyDC();
            answer=d.evaluate(s);
            out.writeUTF(answer+"");
            Thread.sleep(500);
        }
        catch(Exception e) {
            System.out.println("客戶已斷開"+e);
        }
    }
}

**客戶端**

import java.io.*;
import java.net.*;
import java.lang.*;
import java.util.Scanner;

public class Client {
    public static void main(String args[]) {
        Socket mysocket;
        DataInputStream in=null;
        DataOutputStream out=null;
        try{  mysocket=new Socket("127.1.0.0",2010);
            in=new DataInputStream(mysocket.getInputStream());
            out=new DataOutputStream(mysocket.getOutputStream());
            System.out.println("請輸入算式：");
            Scanner scanner=new Scanner(System.in);
            String str=scanner.nextLine();
            MyBC b=new MyBC();
            str=b.result(str);
            out.writeUTF(str);
            String  s=in.readUTF();   //in讀取信息，堵塞狀態
            System.out.println("客戶收到服務器的回答:"+s);
            Thread.sleep(500);
        }
        catch(Exception e) {
            System.out.println("服務器已斷開"+e);
        }
    }
}

實驗過程
使用java.net.Socket對象來表示一個套接字
使用Socket的構造方法建立套接字，如：public Socket(java.lang.String host, int port)。其中，host是遠程機器名或IP地址，port是端口號，IP地址查詢方法以下：
調用Socket類的getOutputStream方法來獲取一個java.io.OutputStream對象。要向遠程應用程序發送文本，一般要從返回的OutputStream對象構建一個java.io.PrintWriter對象。要接收來自鏈接的另外一端的字節流
調用Socket類的getInputStream方法，它返回一個java.io.InputStream
ServerSocket是服務器套接字的一個實現，一旦服務器套接字得到了一個鏈接請求，它就會建立一個Socket實例
任務截圖

任務三
加密結對編程：1人負責客戶端，一人負責服務器
注意責任歸宿，要會經過測試證實本身沒有問題
基於Java Socket實現客戶端/服務器功能，傳輸方式用TCP
客戶端讓用戶輸入中綴表達式，而後把中綴表達式調用MyBC.java的功能轉化爲後綴表達式，把後綴表達式用DES或AES算法加密後經過網絡把密文發送給服務器
服務器接收到後綴表達式表達式後，進行解密（和客戶端協商密鑰，能夠用數組保存），而後調用MyDC.java的功能計算後綴表達式的值，把結果發送給客戶端
客戶端顯示服務器發送過來的結果
實驗原理
本部分須要參考Java密碼學算法中「Java對稱加密-DES算法」部分的內容，不一樣的是我和夥伴沒有經過對象序列化方式寫入文件中，而是直接將密鑰進行傳遞，具體過程以下：
客戶端
獲取密鑰生成器KeyGenerator kg=KeyGenerator.getInstance("DESede")
初始化密鑰生成器kg.init(168);
生成密鑰SecretKey k=kg.generateKey( );
獲取主要編碼格式byte[ ] kb=k.getEncoded( );
傳送密鑰長度及密鑰內容
建立密碼器Cipher cp=Cipher.getInstance("DESede");
初始化密碼器cp.init(Cipher.ENCRYPT_MODE, k);
獲取等待加密的明文byte ptext[]=s.getBytes("UTF8");
執行加密byte []ptext=cp.doFinal(ctext)
服務器
接收密鑰長度
接收密鑰內容
建立密碼器Cipher cp=Cipher.getInstance("DESede");
初始化密碼器cp.init(Cipher.DECRYPT_MODE, k);
執行解密byte []ptext=cp.doFinal(ctext)
實驗代碼
客戶端

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.io.*;
import java.net.*;
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("127.0.0.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+"");
            for(int i=0; i<kb.length; i++){
                out.writeUTF(kb[i]+"");
            }
            System.out.println("請輸入中綴表達式：");
            String infix = inn.nextLine();
            MyBC myBC = new MyBC();
            String suffix = myBC.infixToSuffix(infix);
            Cipher cp=Cipher.getInstance("DESede");
            cp.init(Cipher.ENCRYPT_MODE, k);
            byte ptext[]=suffix.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);
        }
    }
}

服務器

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
import java.net.*;
public class Sever1 {
    public static void main(String[] args) {
        ServerSocket serverForClient = null;
        Socket socketOnServer = null;
        DataOutputStream out = null;
        DataInputStream in = null;
        MyDC myDC = new MyDC();
        try{
            serverForClient = new ServerSocket(2010);
        }catch (IOException e1){
            System.out.println("請客戶端回覆"+e1);
        }
        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)];
            for(int i=0; i<Integer.parseInt(keylength); i++){
                String t = in.readUTF();
                kb[i] = Byte.parseByte(t);
            }
            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);
            }
            SecretKeySpec k=new  SecretKeySpec(kb,"DESede");
            Cipher cp=Cipher.getInstance("DESede");
            cp.init(Cipher.DECRYPT_MODE, k);
            byte []ptext=cp.doFinal(ctext);
            String suffix = new String(ptext,"UTF8");
            System.out.println("請提問"+suffix);
            out.writeUTF(myDC.evaluate(suffix)+"");
            Thread.sleep(500);
        }catch (Exception e){
            System.out.println("已斷開鏈接");
        }
    }
}

實驗截圖

編程

4.任務四數組

基於Java Socket實現客戶端/服務器功能，傳輸方式用TCP
客戶端讓用戶輸入中綴表達式，而後把中綴表達式調用MyBC.java的功能轉化爲後綴表達式，把後綴表達式用3DES或AES算法加密經過網絡把密文發送給服務器
客戶端和服務器用DH算法進行3DES或AES算法的密鑰交換
服務器接收到後綴表達式表達式後，進行解密，而後調用MyDC.java的功能計算後綴表達式的值，把結果發送給客戶端
客戶端顯示服務器發送過來的結果
上傳測試結果截圖和碼雲連接
實驗原理
本部分須要參考Java密碼學算法中「使用密鑰協定建立共享密鑰」部分的內容，對博客中的代碼進行了部分更改以下：
Key_DH和KeyAgree主類的參數改成由客戶端和服務器傳遞，並修改方法名
public static void DH(String str1,String str2) throws Exception
public static void Agree(String str1,String str2)
客戶端和服務器分別產生本身的公鑰和私鑰，並用過字節數組的形式分別向另外一方傳遞本身的公鑰；
客戶端和服務器接受對方的公鑰後利用本身的私鑰建立共享密鑰
建立密鑰協定對象KeyAgreement ka=KeyAgreement.getInstance("DH");
初始化密鑰協定對象ka.init(prk);
執行密鑰協定ka.doPhase(pbk,true);
生成共享信息byte[ ] sb=ka.generateSecret();
從文件中讀取信息並給出共享密鑰
實驗代碼
客戶端

import javax.crypto.spec.*;
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 Client4 {
    public static void main(String[] args) {
        Scanner inn = new Scanner(System.in);
        Socket mysocket;
        DataInputStream in = null;
        DataOutputStream out = null;
        try {
            mysocket = new Socket("127.0.0.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();
            System.out.println("請輸入中綴表達式：");
            String infix = inn.nextLine();
            MyBC myBC = new MyBC();
            String suffix = myBC.infixToSuffix(infix);
            System.out.println(suffix);
            //中綴表達式加密
            Cipher cp = Cipher.getInstance("DESede");
            cp.init(Cipher.ENCRYPT_MODE, k);
            byte ptext[] = suffix.getBytes("UTF8");
            byte ctext[] = cp.doFinal(ptext);
            out.writeUTF(ctext.length + "");
            for (int i = 0; i < ctext.length; i++) {
                out.writeUTF(ctext[i] + "");
            }
            //對密鑰進行加密
            KeyAgree keyAgree = new KeyAgree();
            SecretKeySpec k1 = keyAgree.KeyAgree("Serverpub.dat","Clientpri.dat");
            cp.init(Cipher.ENCRYPT_MODE, k1);
            byte ckey[] = cp.doFinal(kb);
            out.writeUTF(ckey.length + "");
            for (int i = 0; i < ckey.length; i++) {
                out.writeUTF(ckey[i] + "");
            }
            String result = in.readUTF();
            System.out.println("服務器收到請回去" + result);
            Thread.sleep(500);
        } catch (Exception e) {
            System.out.println("服務器斷開鏈接" + e);
        }
    }
}

服務器

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
import java.net.*;
public class Server4 {
    public static void main(String[] args) {
        ServerSocket serverForClient = null;
        Socket socketOnServer = null;
        DataOutputStream out = null;
        DataInputStream in = null;
        MyDC myDC = new MyDC();
        try{
            serverForClient = new ServerSocket(2010);
        }catch (IOException e1){
            System.out.println("請提出問題"+e1);
        }
        try{
            System.out.println("等待中");
            socketOnServer = serverForClient.accept();
            out = new DataOutputStream(socketOnServer.getOutputStream());
            in = new DataInputStream(socketOnServer.getInputStream());
            //獲取密文
            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);
            }
            //獲取密鑰
            String keylength = in.readUTF();
            byte []ckey = new byte[Integer.parseInt(keylength)];
            for(int i=0; i<Integer.parseInt(keylength); i++){
                String temp = in.readUTF();
                ckey[i] = Byte.parseByte(temp);
            }
            //密鑰解密
            SecretKeySpec k1 = KeyAgree.KeyAgree("Clientpub.dat","Serverpri.dat");
            Cipher cp=Cipher.getInstance("DESede");
            cp.init(Cipher.DECRYPT_MODE, k1);
            byte []pkey=cp.doFinal(ckey);
            //密文解密
            SecretKeySpec k=new  SecretKeySpec(pkey,"DESede");
            cp.init(Cipher.DECRYPT_MODE, k);
            byte []ptext=cp.doFinal(ctext);
            String suffix = new String(ptext,"UTF8");
            System.out.println("受到提問"+suffix);
            out.writeUTF(myDC.evaluate(suffix)+"");
            Thread.sleep(500);
        }catch (Exception e){
            System.out.println("已斷開鏈接");
        }
    }
}

實驗截圖

安全

任務五
完整性校驗結對編程：1人負責客戶端，一人負責服務器
注意責任歸宿，要會經過測試證實本身沒有問題
基於Java Socket實現客戶端/服務器功能，傳輸方式用TCP
客戶端讓用戶輸入中綴表達式，而後把中綴表達式調用MyBC.java的功能轉化爲後綴表達式，把後綴表達式用3DES或AES算法加密經過網絡把密文和明文的MD5値發送給服務器
客戶端和服務器用DH算法進行3DES或AES算法的密鑰交換
服務器接收到後綴表達式表達式後，進行解密，解密後計算明文的MD5值，和客戶端傳來的MD5進行比較，一致則調用MyDC.java的功能計算後綴表達式的值，把結果發送給客戶端
客戶端顯示服務器發送過來的結果
實驗過程
Java摘要算法-MD5
生成MessageDigest對象，MessageDigest m=MessageDigest.getInstance("MD5")
傳入須要計算的字符串，m.update(x.getBytes("UTF8" ))
計算消息摘要，byte s[ ]=m.digest( )
處理計算結果
實驗截圖

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。