首页 > 编程语言> > 2018-2019-2 20175209王梓鸿实验五《网络编程与安全》实验报告

2018-2019-2 20175209王梓鸿实验五《网络编程与安全》实验报告

2019-05-26 16:49:30 作者：互联网

2018-2019-2 20175209王梓鸿实验五《网络编程与安全》实验报告

实验报告封面

课程：Java程序设计班级：1752班姓名：王梓鸿学号：20175209
指导教师：娄嘉鹏实验日期：2019年5月25日
实验时间：--- 实验序号：实验五
实验名称：网络编程与安全
实验要求：
- 完成云班课中的检查点，也可以先完成实验报告，直接提交。注意不能只有截图，要有知识点，原理，遇到的问题和解决过程等说明。实验报告中一个检查点要有多张截图。
- 发表实验报告博客，标题“学期（如2018-2019-2）学号（如20175300）实验五 Java网络编程实验报告”

一、实验准备情况概述

之前的结对项目已经完成过四则运算的内容，因此在完成实验时没有完全使用博客链接中给定的代码，基本采用之前结对项目的代码，并且结对项目中的四则运算还可以实现分数的运算，更加全面。
在完成实验的过程中需要参考实验三中Java密码学算法中的内容。

二、实验内容及步骤

1.任务一

实验要求

结对实现中缀表达式转后缀表达式的功能 MyBC.java
结对实现从上面功能中获取的表达式中实现后缀表达式求值的功能,调用MyDC.java
上传测试代码运行结果截图和码云链接

实验原理

我们在计算中习惯使用的表达式成为中缀表达式，即依据运算符顺序和优先级依次运算
计算机在计算时并使用上述方法，原因是计算机按照中缀表达式的顺序运算会丢掉括号信息，因此我们若想使用计算机进行计算，则应将表达式转换为计算机可以正确识别并计算的后缀表达式，后缀表达式严格按照从左至右依次计算运算符和其前面两个数字的顺序进行求值运算
后缀表达式中运算符的顺序为在表达式中的运算顺序，因此表达式求值分为两部分：中缀转后缀、后缀表达式计算

实验代码

中缀转后缀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;       
        }    
    }
}

有理数类

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;    
    }
}

测试代码

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.任务二

基于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() 获得一个输出流

实验代码

客户端

import java.io.*;
import java.net.*;
import java.util.Scanner;
public class Client2 {
    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);
        }
    }
}

服务器

import java.io.*;
import java.net.*;
public class Server2 {
    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.任务三

基于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)

实验代码

客户端

import java.io.*;
import java.net.*;
import javax.crypto.*;
import java.util.Scanner;
public class Client3 {
    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);
        }
    }
}

服务器

import java.io.*;
import java.net.*;
import javax.crypto.*;
import javax.crypto.spec.*;
public class Server3 {
    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.任务四

基于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.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
import java.security.*;
import java.util.Scanner;
import java.net.*;
public class Client4 {
    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);
        }
    }
}

服务器

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 Server4 {
    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”部分的内容，同样将类中的参数改为由客户端和服务器传递，在任务四基础上进行操作

实验代码

客户端

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 Client5 {
    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);
        }
    }
}

服务器

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 Server5 {
    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);
        }
    }
}

实验结果

客户端
服务器

三、代码托管

四、实验心得体会

本次实验综合了教材第十三章和Java密码学的相关内容，在完成实验的同时也对这些知识有了更好地掌握；对于个人的的代码感觉有一些长，但是所有需要的公钥或者共享密钥等均可以通过端口进行传送，对于任务四中的公钥和私钥，开始时想在客户端和服务器生成后再拷贝给对方，但后来认为这种方式比较繁琐，如果和不同端口进行通信时每次都需要先拷贝公钥，这样在操作上的可行性比较复杂，因此最后还是选择通过端口直接进行传送。通过本次实验让我对于网络之间的交互有了更好的掌握和了解。

五、参考资料

Java密码学算法

标签：java,String,王梓鸿,2018,20175209,import,new,表达式,out
来源： https://www.cnblogs.com/wangzihong0213/p/10926536.html

2018-2019-2 20175209王梓鸿 实验五《网络编程与安全》实验报告

2018-2019-2 20175209王梓鸿 实验五《网络编程与安全》实验报告

实验报告封面

一、实验准备情况概述

二、实验内容及步骤

1.任务一

实验要求

实验原理

实验代码

中缀转后缀MyBC.java

后缀表达式计算MyDC.java

有理数类

测试代码

运行截图

2.任务二

实验原理

实验代码

实验结果

3.任务三

实验原理

实验代码

实验结果

4.任务四

实验原理

实验代码

实验结果

5.任务五

实验原理

实验代码

实验结果

三、代码托管

四、实验心得体会

五、参考资料

2018-2019-2 20175209王梓鸿实验五《网络编程与安全》实验报告

2018-2019-2 20175209王梓鸿实验五《网络编程与安全》实验报告