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

時間  2019-12-07
標籤 實驗 網絡編程與安全 報告 欄目 系統網絡 简体版
原文   原文鏈接

1、實驗準備狀況概述

  • 結對對象：20175209王梓鴻
  • 以前的結對項目已經完成過四則運算的內容，所以在完成實驗時沒有徹底使用博客連接中給定的代碼，基本採用以前結對項目的代碼，而且結對項目中的四則運算還能夠實現分數的運算，更加全面。
  • 在完成實驗的過程當中須要參考實驗三中Java密碼學算法中的內容。

2、實驗內容及步驟

  • 1.提交1html

    • 實驗要求：
    結對實現中綴表達式轉後綴表達式的功能 MyBC.java
結對實現從上面功能中獲取的表達式中實現後綴表達式求值的功能,調用MyDC.java
上傳測試代碼運行結果截圖和碼雲連接

    • 實驗原理java

      • 咱們習慣使用的計算表達式稱做中綴表達式，但計算機在計算時不使用中綴表達式；
      • 由於中綴表達式須要計算機遇到符號後向後掃描一位 若爲括號或優先級更高的操做符還須要向後繼續掃描；
      • 然後綴表達式嚴格按照從左到右進行計算的模式 符合計算機運行方式；
      • 所以表達式求值分爲兩部分：中綴轉後綴、後綴表達式求值。

    • 實驗代碼git

      • 中綴轉後綴MyBC.java算法

        • 僞代碼
        一、設立空棧用於存放操做符
二、從左到右掃描中綴式，若遇到操做數，直接輸出，並以空格做爲分隔符；
三、若遇到運算符，則與棧頂元素比較，比棧頂級別高則進棧，不然退出棧頂元素並輸出，並以空格做爲分隔符，優先級從高到低爲')' '/' (÷*) (+-) ；
四、若遇到左括號，進棧；若遇到右括號，則一直退棧輸出，直到退到左括號止;
五、當棧變成空時，輸出的結果即爲後綴表達式。
        • 產品代碼
        import java.util.Stack;
public class MyBC {
 String C = new String();
 String End = "";            //存儲數字的字符串
 public void ChangeString(String str) {
 C = str;
 }
 public String ChangeOrder() {
Stack store = new Stack();     //建立一個存儲字符的棧
for (int i = 0; i < C.length(); i++) {
   char op = C.charAt(i);     //將索引值爲i處的字符的值返回
   if (op >= '0' && op <= '9') {
       End = End + op;
   }
   else if (op == '(') {
       store.push(op);
   }
   else if (op == '+' || op == '-' || op == '*' || op == '÷'|| op == '/') {
       End = End + " ";
       if (store.empty()) {
           store.push(op);
       }
       else if (compareValue(op) > compareValue((char) store.peek())) {     //比較運算符優先級
           store.push(op);
       }
       else {
           End = End + String.valueOf(store.pop());
           i--;
       }
   }
   else if (op == ')') {
       while ((char) store.peek() != '(') {
           End = End + " " + String.valueOf(store.pop());
       }
   store.pop();
   }
}
while (!store.empty()) {
   End = End + " " + String.valueOf(store.pop());
}
return End;
 }
 public int compareValue(char chi) {
int number = 0;
switch (chi) {
case '(':
   number = 1;
   break;
case '+':
case '-':
   number = 2;
   break;
case '*':
case '÷':
   number = 3;
   break;
case '/':
   number = 4;
   break;
case ')':
   number = 5;
   break;
default:
   number = 0;
   break;
}
return number;
 }
}

      • 後綴表達式計算MyDC.java編程

        • 僞代碼
        一、設置一個空棧用於存儲數字元素；
二、從左到右掃描後綴表達式，遇操做數，進棧；
三、若遇運算符，則從棧頂彈出兩個操做數，執行對應的運算，並將運算後的結果壓棧棧；
四、重複執行直至後綴表達式掃描完畢，彈出棧中的最後一個元素即爲表達式的值。
        • 產品代碼
        import java.util.StringTokenizer;
import java.util.Stack;
public class MyDC {
 String q;
 Stack stack;
 public MyDC() {
stack = new Stack();
 }
 void set(String question) {   //輸入後續排列的字符串
q = question;
 }
 public Rational get() {
Rational op1 = new Rational();
Rational op2 = new Rational();
Rational result = new Rational();
result.setNumerator(0);
StringTokenizer token = new StringTokenizer(q, " ");
String temp;
while (token.hasMoreTokens()) {
   temp = token.nextToken();
   if (Isop(temp) == 1) {     //遇到操做符，彈出棧頂的兩個數進行運算
       op2 = (Rational) stack.pop();
       op1 = (Rational) stack.pop();//彈出最上面兩個操做數
       result = cal(temp.charAt(0), op1, op2);//根據運算符進行運算
       stack.push(result);//將計算結果壓棧
   }
   else {
       Rational num = new Rational();
       num.setNumerator(Integer.parseInt(temp));
       stack.push(num);//操做數入棧
   }
}
return result;
 }
 Rational cal(char op, Rational a, Rational b) {           //對棧頂彈出的兩個數進行運算
Rational c = new Rational();
switch (op) {
   case '+':
       c = a.add(b);
       break;
   case '-':
       c = a.sub(b);
       break;
   case '*':
       c = a.muti(b);
       break;
   case '÷':
   case '/':
       if(b.getNumerator()==0) {
           System.out.println("生成的算式計算時出現了分母爲0的狀況！");
           System.exit(0);
       }
       else {
           c = a.div(b);
           break;
       }
   default:
       System.out.println("Wrong!");
}
return c;
 }
 int Isop(String op) {       //判斷是否是運算符
if (op.equals("+") || op.equals("-") || op.equals("*") || op.equals("÷") || op.equals("/")) {
   return 1;
}
else {
   return 0;
}
 }
}
      • 有理數類Rational
        • 用於實現分數運算
        public class Rational {
 int numerator = 1 ;   //分子
 int denominator = 1; //分母
 void setNumerator(int a) {  //設置分子
int c=f(Math.abs(a),denominator);  //計算最大公約數
numerator = a/c;
denominator = denominator/c;
if(numerator<0&&denominator<0) {
   numerator = -numerator;
   denominator = -denominator;
}
 }
 void setDenominator(int b) {  //設置分母
int c=f(numerator,Math.abs(b));  //計算最大公約數
numerator = numerator/c;
denominator = b/c;
if(numerator<0&&denominator<0) {
   numerator = -numerator;
   denominator = -denominator;
}
 }
 int getNumerator() {
return numerator;
 }
 int getDenominator() {
return denominator;
 }
 int f(int a,int b) { //求a和b的最大公約數
if(a==0) {
   return 1;
}
if(a<b) {
   int c=a;
   a=b;
   b=c;
}
int r=a%b;
while(r!=0) {
   a=b;
   b=r;
   r=a%b;
}
return b;
 }
 Rational add(Rational r) {  //加法運算
int a=r.getNumerator();
int b=r.getDenominator();
int newNumerator=numerator*b+denominator*a; //計算出新分子
int newDenominator=denominator*b;           //計算出新分母
Rational result=new Rational();
result.setNumerator(newNumerator);
result.setDenominator(newDenominator);
return result;
 }
 Rational sub(Rational r) {  //減法運算
int a=r.getNumerator();
int b=r.getDenominator();
int newNumerator=numerator*b-denominator*a;
int newDenominator=denominator*b;
Rational result=new Rational();
result.setNumerator(newNumerator);
result.setDenominator(newDenominator);
return result;
 }
 Rational muti(Rational r) { //乘法運算
int a=r.getNumerator();
int b=r.getDenominator();
int newNumerator=numerator*a;
int newDenominator=denominator*b;
Rational result=new Rational();
result.setNumerator(newNumerator);
result.setDenominator(newDenominator);
return result;
 }
 Rational div(Rational r)  { //除法運算
int a=r.getNumerator();
int b=r.getDenominator();
int newNumerator=numerator*b;
int newDenominator=denominator*a;
Rational result=new Rational();
if(a==0) {
   System.out.println("該算式無解");
   result.setNumerator(0);
}
else {
   result.setNumerator(newNumerator);
   result.setDenominator(newDenominator);
}
return result;
 }
}

      • 測試代碼Test數組

        import java.util.*;
public class Test {
 public static void main(String[] args) {
String question = "";
String question1 = "";
Scanner scanner = new Scanner(System.in);
System.out.println("請輸入題目：");
question = scanner.nextLine();
MyBC change = new MyBC();
change.ChangeString(question);
question1 = change.ChangeOrder();
System.out.println(question1);
MyDC getanswer = new MyDC();
getanswer.set(question1);
Rational answer = getanswer.get();
int a = answer.getNumerator();
int b = answer.getDenominator();
float result = (float)a/b;
System.out.println("結果爲（保留兩位小數）：");
System.out.println(String.format("%.2f",result));
 }
}

    • 測試結果截圖安全

  • 2.提交2服務器

    • 實驗要求
    一、基於Java Socket實現客戶端/服務器功能，傳輸方式用TCP
二、客戶端讓用戶輸入中綴表達式，而後把中綴表達式調用MyBC.java的功能轉化爲後綴表達式，把後綴表達式經過網絡發送給服務器
三、服務器接收到後綴表達式，調用MyDC.java的功能計算後綴表達式的值，把結果發送給客戶端
四、客戶端顯示服務器發送過來的結果
五、上傳測試結果截圖和碼雲連接

    • 實驗原理網絡

      • 獲取Client端的IP地址
        • 打開終端，輸入ipconfig查看；
        • 在命令行輸入IP地址；
        • 調用InetAddress類中的geetByName方法獲取輸入的IP地址；
      • 建立一個套接字，可使用Socket的構造方法；
        • 如：public Socket(java.lang.String host, int port) 其中，host是IP地址，port是端口號。
      • 調用getInputStream()方法得到一個輸入流
      • 調用getOutputStream()方法得到一個輸出流
      • 服務器端調用ServerSocket實現套接字
      • 使用accept()方法鏈接客戶端和服務器的套接字
      • 調用getInputStream()方法得到一個輸入流
      • 調用getOutputStream()方法得到一個輸出流

    • 實驗代碼socket

      • 客戶端Client
      import java.io.*;
import java.net.*;
import java.util.Scanner;
public class Client {
 public static void main(String args[]) {
  Socket mysocket;
  DataInputStream in=null;
  DataOutputStream out=null;
  Scanner scanner = new Scanner(System.in);
  try{
      System.out.print("輸入服務器的IP:");
      String IP = scanner.nextLine();
      InetAddress address=InetAddress.getByName(IP);
      mysocket = new Socket(address, 2010);
      in=new DataInputStream(mysocket.getInputStream());
      out=new DataOutputStream(mysocket.getOutputStream());
      System.out.println("請輸入中綴表達式：");
      while (scanner.hasNext()) {
          String question = scanner.next();
          MyBC change = new MyBC();
          change.ChangeString(question);
          String question1 = change.ChangeOrder();
          System.out.println("後綴表達式爲："+question1);
          out.writeUTF(question1);
          String s=in.readUTF(); //in讀取信息，堵塞狀態
          System.out.println("客戶收到服務器的回答:"+s);
          Thread.sleep(500);
          System.out.println("請輸入中綴表達式:");
      }
  }
  catch(Exception e) {
      System.out.println("服務器已斷開"+e);
  }
 }
}
      • 服務器Server
      import java.io.*;
import java.net.*;
public class Server {
 public static void main(String[] args) {
  ServerSocket serverForClient = null;
  Socket socketOnServer = null;
  DataOutputStream out = null;
  DataInputStream in = null;
  String question = "";
  try {
      serverForClient = new ServerSocket(2010);
  } catch (IOException e) {
      System.out.println(e);
  }
  System.out.println("等待客戶呼叫");
  try {
      socketOnServer = serverForClient.accept();
      out = new DataOutputStream(socketOnServer.getOutputStream());
      in = new DataInputStream(socketOnServer.getInputStream());
      while(true) {
          question = in.readUTF(); // in讀取信息，堵塞狀態
          System.out.println("服務器收到客戶傳遞的後綴表達式爲:" + question);
          MyDC getanswer = new MyDC();
          getanswer.set(question);
          Rational answer = getanswer.get();
          int a = answer.getNumerator();
          int b = answer.getDenominator();
          float result = (float) a / b;
          System.out.println("計算出的結果爲"+String.format("%.2f",result));
          out.writeUTF(String.format("%.2f",result));
          Thread.sleep(500);
      }
  } catch (Exception e) {
      System.out.println("客戶已斷開" + e);
  }
 }
}

    • 測試結果截圖

      • 客戶端

      • 服務器

  • 3.提交3

    • 實驗要求
    一、基於Java Socket實現客戶端/服務器功能，傳輸方式用TCP
二、客戶端讓用戶輸入中綴表達式，而後把中綴表達式調用MyBC.java的功能轉化爲後綴表達式，把後綴表達式用3DES或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)

    • 實驗代碼

      • 客戶端Client
      import java.io.*;
import java.net.*;
import javax.crypto.*;
import java.util.Scanner;
public class Client {
 public static void main(String args[]) throws Exception{
  Socket mysocket;
  DataInputStream in=null;
  DataOutputStream out=null;
  Scanner scanner = new Scanner(System.in);
  try {
      System.out.print("輸入服務器的IP:");
      String IP = scanner.nextLine();
      InetAddress address=InetAddress.getByName(IP);
      mysocket = new Socket(address, 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請輸入中綴表達式：");
      while(scanner.hasNext()) {
          String question = scanner.next();
          MyBC change = new MyBC();
          change.ChangeString(question);
          String question1 = change.ChangeOrder();
          System.out.println("後綴表達式爲："+question1);
          Cipher cp = Cipher.getInstance("DESede");
          cp.init(Cipher.ENCRYPT_MODE,k);
          byte ptext[] = question1.getBytes("UTF8");
          byte ctext[] = cp.doFinal(ptext);
          out.writeUTF(ctext.length + "");
          for(int i=0;i<ctext.length;i++) {
              out.writeUTF(ctext[i] +"");
          }
          String s=in.readUTF(); //in讀取信息，堵塞狀態
          System.out.println("客戶收到服務器的回答:"+s);
          Thread.sleep(500);
          System.out.println("請輸入中綴表達式:");
      }
  }
  catch (IOException e) {
      System.out.println("服務器已斷開"+e);
  }
 }
}
      • 服務器Server
      import java.io.*;
import java.net.*;
import javax.crypto.*;
import javax.crypto.spec.*;
public class Server {
 public static void main(String[] args) throws Exception{
  ServerSocket serverForClient = null;
  Socket socketOnServer = null;
  DataOutputStream out = null;
  DataInputStream in = null;
  try {
      serverForClient = new ServerSocket(2010);
  } catch (IOException e) {
  System.out.println(e);
  }
  System.out.println("等待客戶呼叫");
  try {
      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] + " ");
      }
      while(true) {
          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 question = new String(ptext,"UTF8");
          System.out.print("\n後綴表達式爲："+ question);
          MyDC getanswer = new MyDC();
          getanswer.set(question);
          Rational answer = getanswer.get();
          int a = answer.getNumerator();
          int b = answer.getDenominator();
          float result = (float) a / b;
          System.out.println("\n計算出的結果爲"+String.format("%.2f",result));
          out.writeUTF(String.format("%.2f",result));
          Thread.sleep(500);
      }
  } catch (IOException e) {
      System.out.println("客戶已斷開" + e);
  }
 }
}

    • 測試結果截圖

      • 客戶端

      • 服務器

  • 4.提交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();
        • 從文件中讀取信息並給出共享密鑰

    • 實驗代碼

      • 客戶端Client
      import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
import java.security.*;
import java.util.Scanner;
import java.net.*;
public class Client {
 public static void main(String[] args) {
  Socket mysocket;
  DataInputStream in=null;
  DataOutputStream out=null;
  Scanner scanner = new Scanner(System.in);
  try {
      System.out.print("輸入服務器的IP:");
      String IP = scanner.nextLine();
      InetAddress address=InetAddress.getByName(IP);
      mysocket = new Socket(address, 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請輸入中綴表達式：");
      while(scanner.hasNext()) {
          String question = scanner.next();
          MyBC change = new MyBC();
          change.ChangeString(question);
          String question1 = change.ChangeOrder();
          System.out.println("後綴表達式爲：" + question1);
          SecretKeySpec k1 = new SecretKeySpec(keysb, "DESede");
          Cipher cp = Cipher.getInstance("DESede");
          cp.init(Cipher.ENCRYPT_MODE, k1);
          byte ptext[] = question1.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 s=in.readUTF(); //in讀取信息，堵塞狀態
          System.out.println("\n客戶收到服務器的回答:"+s);
          Thread.sleep(500);
          System.out.println("請輸入中綴表達式:");
      }
  }
  catch (Exception e) {
      System.out.println(e);
  }
 }
}
      • 服務器Server
      import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.security.*;
public class Server {
 public static void main(String[] args) throws Exception {
  ServerSocket serverForClient = null;
  Socket socketOnServer = null;
  DataOutputStream out = null;
  DataInputStream in = null;
  try {
      serverForClient = new ServerSocket(2010);
  } catch (IOException e) {
      System.out.println(e);
  }
  System.out.println("等待客戶呼叫");
  try {
      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]+" ");
      }
      while(true) {
          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 question = new String(ptext, "UTF8");
          System.out.print("\n解密後的後綴表達式爲：" + question);
          MyDC getanswer = new MyDC();
          getanswer.set(question);
          Rational answer = getanswer.get();
          int a = answer.getNumerator();
          int b = answer.getDenominator();
          float result = (float) a / b;
          System.out.println("\n計算出的結果爲"+String.format("%.2f",result));
          out.writeUTF(String.format("%.2f",result));
          Thread.sleep(500);
      }
  }
  catch(Exception e) {
      System.out.println("客戶已斷開" + e);
  }
 }
}

    • 測試結果截圖

      • 客戶端

      • 服務器

  • 5.任務五

    • 實驗要求
    一、基於Java Socket實現客戶端/服務器功能，傳輸方式用TCP
二、客戶端讓用戶輸入中綴表達式，而後把中綴表達式調用MyBC.java的功能轉化爲後綴表達式，把後綴表達式用3DES或AES算法加密經過網絡把密文和明文的MD5値發送給服務器
三、客戶端和服務器用DH算法進行3DES或AES算法的密鑰交換
四、服務器接收到後綴表達式表達式後，進行解密，解密後計算明文的MD5值，和客戶端傳來的MD5進行比較，一致則調用MyDC.java的功能計算後綴表達式的值，把結果發送給客戶端
五、客戶端顯示服務器發送過來的結果
六、上傳測試結果截圖和碼雲連接

    • 實驗原理

      • 本部分主要參考Java密碼學算法中「Java摘要算法- MD5」部分；
      • 主要在任務四基礎上進行操做。

    • 實驗代碼

      • 客戶端Client
      import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
import java.net.Socket;
import java.security.*;
import java.util.Scanner;
import java.net.*;
public class Client {
 public static void main(String[] args) {
  Socket mysocket;
  DataInputStream in=null;
  DataOutputStream out=null;
  Scanner scanner = new Scanner(System.in);
  try {
      System.out.print("輸入服務器的IP:");
      String IP = scanner.nextLine();
      InetAddress address=InetAddress.getByName(IP);
      mysocket = new Socket(address, 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請輸入中綴表達式：");
      while(scanner.hasNext()) {
          String question = scanner.next();
          MyBC change = new MyBC();
          change.ChangeString(question);
          String question1 = change.ChangeOrder();
          System.out.println("後綴表達式爲：" + question1);
          String mtoMD5 = DigestPass.MD5(question1);
          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[] = question1.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 s=in.readUTF(); //in讀取信息，堵塞狀態
          System.out.println("\n客戶收到服務器的回答:"+s);
          Thread.sleep(500);
          System.out.println("請輸入中綴表達式:");
      }
  }
  catch (Exception e) {
      System.out.println(e);
  }
 }
}
      • 服務器Server
      import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.security.*;
public class Server {
 public static void main(String[] args) throws Exception {
  ServerSocket serverForClient = null;
  Socket socketOnServer = null;
  DataOutputStream out = null;
  DataInputStream in = null;
  try {
      serverForClient = new ServerSocket(2010);
  } catch (IOException e) {
      System.out.println(e);
  }
  System.out.println("等待客戶呼叫");
  try {
      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]+" ");
      }
      while(true) {
          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 question = new String(ptext, "UTF8");
          System.out.println("\n解密後的後綴表達式爲：" + question);
          String mtoMD5 = DigestPass.MD5(question);
          System.out.println("MD5的值爲"+ mtoMD5);
          if(mtoMD5.equals(c)) {
              System.out.println("傳遞的MD5值和解密的後綴表達式的MD5值相同，能夠解密！");
              MyDC getanswer = new MyDC();
              getanswer.set(question);
              Rational answer = getanswer.get();
              int a = answer.getNumerator();
              int b = answer.getDenominator();
              float result = (float) a / b;
              System.out.println("計算出的結果爲"+String.format("%.2f",result));
              out.writeUTF(String.format("%.2f",result));
          }
          else {
              System.out.println("密文有誤，不能解密！");
          }
          Thread.sleep(500);
      }
  }
  catch(Exception e) {
      System.out.println("客戶已斷開" + e);
  }
 }
}

    • 測試結果截圖

      • 客戶端

      • 服務器

3、代碼託管

4、實驗心得體會

本次實驗綜合了教材第十三章和Java密碼學的相關內容，在和夥伴的討論中，對於java的網絡和安全方面的編程有了更好地掌握。

5、參考資料

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程