2018-2019-2 20175216张雪原实验五《网络编程与安全》实验报告

实验五网络编程与安全-1

两人一组结对编程：

1. 参考http://www.cnblogs.com/rocedu/p/6766748.html#SECDSA
1. 结对实现中缀表达式转后缀表达式的功能 MyBC.java
1. 结对实现从上面功能中获取的表达式中实现后缀表达式求值的功能,调用MyDC.java
1. 上传测试代码运行结果截图和码云链接

实验原理

栈的应用：栈 (Stack)是一种只允许在表尾插入和删除的线性表，有先进后出（FILO），后进先出(LIFO)的特点。允许插入和删除的一端称为栈顶(top)，另一端称为栈底(bottom)。
由中缀式求得后缀式可以使用栈，伪代码如下：

设立一个栈，存放运算符，首先栈为空；
从左到右扫描中缀式，若遇到操作数，直接输出，并输出一个空格作为两个操作数的分隔符；
若遇到运算符，则与栈顶比较，比栈顶级别高则进栈，否则退出栈顶元素并输出，然后输出一个空格作分隔符；
若遇到左括号，进栈；若遇到右括号，则一直退栈输出，直到退到左括号止。
当栈变成空时，输出的结果即为后缀表达式。
后缀式的运算

dc运算符：

+: 依次弹出w1与w2，将w2+w1压栈。精度为结果值精度
-: 依次弹出w1与w2，将w2-w1压栈
: 依次弹出w1与w2，将w2w1压栈。精度为结果值精度与precision中较大值
/ : 依次弹出w1与w2，将w2/w1压栈。精度为precision
求值伪代码如下：

设置一个操作数栈，开始栈为空；
从左到右扫描后缀表达式，遇操作数，进栈；
若遇运算符，则从栈中退出两个元素，先退出的放到运算符的右边，后退出的放到运算符左边，运算后的结果再进栈，直到后缀表达式扫描完毕。

import java.util.Stack;
import java.util.StringTokenizer;
/**
 * Created by zxy on 2019/5/28.
 */

public class MyBC{
    private Stack<Character> stack1;
    public char Precede(char a,char b)
    {
        if(a=='#')
            if(b!='#')
                return '<';
            else
                return '=';
        if(a==')')
            return '>';
        if(a=='(')
            if(b!=')')
                return '<';
            else
                return '=';
        if(a=='/'||a=='*')
            if(b!='(')
                return '>';
            else
                return '<';
        if(a=='-'||a=='+')
            if(b!='*'&&b!='/'&&b!='(')
                return '>';
            else
                return '<';
        return '>';
    }
    public MyBC() {
        stack1 = new Stack<Character>();
        stack1.push('#');
    }
    public String turn(String expr) {
        int  result = 0;
        String token;
        char topelem,optr;
        char[] exper1 = new char[100];
        int i = 0;

        StringTokenizer tokenizer = new StringTokenizer (expr);
          /*while (tokenizer.hasMoreTokens()) {
              System.out.println(tokenizer.nextToken());
          }*/
        while (tokenizer.hasMoreTokens())
        {
            token = tokenizer.nextToken();

            //如果是运算符，调用isOperator

            if (isOperator(token))
            {
                //调用Precede比较优先级

                topelem=stack1.peek();

                optr = token.charAt(0);

                if(Precede(topelem,optr)=='<')
                {

                    stack1.push(optr);

                }
                else if(Precede(topelem,optr)=='=')
                {
                      /*if(optr==')'){
                          optr=stack1.pop();
                          while(optr!='('){
                              exper1[i++]=optr;
                              exper1[i++]=' ';
                              optr=stack1.pop();
                          }
                      }*/
                    optr =stack1.pop();
                    exper1[i++] = optr;
                    exper1[i++] = ' ';
                }
                else if(Precede(topelem,optr)=='>')
                {
                    optr =stack1.pop();
                    //从运算符栈中退出栈顶元素并放入后缀表达式exper1
                    exper1[i++] = optr;
                    exper1[i++] = ' ';
                }
            }//如果是(则入栈
            else if(token.equals("(")) {
                optr = token.charAt(0);
                stack1.push(optr);
            }//如果是）则退栈直到出现第一个（
            else if(token.equals(")")) {
                optr = stack1.pop();
                while(optr!='(')
                {
                    exper1[i++] = optr;
                    exper1[i++] = ' ';
                    optr = stack1.pop();
                }
            }
            else//如果是操作数
            //操作数放入后缀表达式exper1
            {
                optr = token.charAt(0);
                //System.out.println(optr);
                exper1[i++]=optr;
                exper1[i++] = ' ';

            }
        }
        while(!stack1.isEmpty())
        {
            optr = stack1.pop();
            if(optr!='#'){
                exper1[i++] = optr;
                exper1[i++] = ' ';
            }
        }
        //System.out.println(exper1);

        return ToString(exper1);
    }
    //@Override
    private boolean isOperator(String token)
    {

        return (token.equals("+") || token.equals("-") ||token.equals("*") || token.equals("/") );
    }
    public  static String ToString(char[] exper1){
        int length = exper1.length;
        String str=" ";
        for(int i=0;i<length;i++)
        {
            str=str+exper1[i];
        }
        //System.out.println(str);
        return str;
    }
     /*public static void main(String[] args) {
         String pp=null;
         MyBC turner = new MyBC();

         pp=turner.turn("( 1 + 2 ) * ( ( 8 - 2 ) / ( 7 - 4     ) )");
         System.out.println(pp);
     }*/
}


import java.util.StringTokenizer;
import java.util.Stack;

/**
 * Created by zxy on 2019/5/28.
 */


public class MyDC2
{
    // constant for addition symbol */
    private final char ADD = '+';
    // constant for subtraction symbol */
    private final char SUBTRACT = '-';
    // constant for multiplication symbol */
    private final char MULTIPLY = '*';
    // constant for division symbol */
    private final char DIVIDE = '/';
    // the stack */
    private Stack<Integer> stack;

    public MyDC2() {
        stack = new Stack<Integer>();
    }

    public int evaluate (String expr)
    {
        int op1, op2, result = 0;
        String token;
        StringTokenizer tokenizer = new StringTokenizer (expr);

        while (tokenizer.hasMoreTokens())
        {
            token = tokenizer.nextToken();

            //如果是运算符，调用isOperator

            if (isOperator(token))
            {
                //从栈中弹出操作数

                //op2 =Integer.parseInt(stack.pop());
                op2 =stack.pop();
                //从栈中弹出操作数
                //op1 =Integer.parseInt(stack.pop());
                op1 =stack.pop();
                //根据运算符和两个操作数调用evalSingleOp计算result;
                result = evalSingleOp(token.charAt(0),op1,op2);
                //计算result入栈;
                stack.push(result);
            }
            else//如果是操作数
                //操作数入栈;
                stack.push(Integer.parseInt(token));
        }

        return result;
    }

    private boolean isOperator (String token)
    {
        return ( token.equals("+") || token.equals("-") ||
                token.equals("*") || token.equals("/") );
    }

    private int evalSingleOp (char operation, int op1, int op2)
    {
        int result = 0;

        switch (operation)
        {
            case ADD:
                result = op1 + op2;
                break;
            case SUBTRACT:
                result = op1 - op2;
                break;
            case MULTIPLY:
                result = op1 * op2;
                break;
            case DIVIDE:
                result = op1 / op2;
        }

        return result;
    }
}


import java.util.Scanner;
import static org.junit.Assert.*;
/**
 * Created by lxkj on 2017/6/2.
 */

import java.util.Scanner;

public class MyBCTest  {
    public static void main (String[] args) {

        String expression1=null,expression2=null, again=null;

        int result,i=0,length=0;

        try
        {
            Scanner in = new Scanner(System.in);

            do
            {
                MyDC2 evaluator = new MyDC2();
                MyBC turner = new MyBC();
                System.out.println ("Enter a valid midfix expression: ");
                expression1 = in.nextLine();
                //System.out.println(expression1);
                expression2 = turner.turn(expression1);
                while(expression2.charAt(i)!=''){
                    length++;
                    i++;
                }
                //length 表示字符串包括‘’的字符个数
                expression2 = expression2.substring(1,length-1);
                //System.out.println(expression2);
                result = evaluator.evaluate (expression2);
                System.out.println();
                System.out.println ("That expression equals " + result);

                System.out.print ("Evaluate another expression [Y/N]? ");
                again = in.nextLine();
                System.out.println();
            }
            while (again.equalsIgnoreCase("y"));
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

实验结果截图：
1_水印.png

网络编程与安全-2

结对编程：1人负责客户端，一人负责服务器

1. 注意责任归宿，要会通过测试证明自己没有问题
1. 基于Java Socket实现客户端/服务器功能，传输方式用TCP
1. 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式通过网络发送给服务器
1. 服务器接收到后缀表达式，调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
1. 客户端显示服务器发送过来的结果
1. 上传测试结果截图和码云链接
  结对：
  20175202负责服务器
  20175216负责客户端

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
/**
 * Created by zxy on 2019/5/28.
 */

public class Client {
    public static final String IP_ADDR = "127.0.0.1";//服务器地址
    public static final int PORT = 12345;//服务器端口号

    public static void main(String[] args) {
        System.out.println("客户端启动...");
        System.out.println("当接收到服务器端字符为 "OK" 的时候, 客户端将终止
");
        while (true) {
            Socket socket = null;
            try {

                socket = new Socket(IP_ADDR, PORT);
                DataInputStream input = new DataInputStream(socket.getInputStream());
                DataOutputStream out = new DataOutputStream(socket.getOutputStream());
                System.out.print("请输入: 	");
                String str = new BufferedReader(new InputStreamReader(System.in)).readLine();
                MyBC turner = new MyBC();
                String str1 = turner.turn(str);
                int length=0,i=0;
                while(str1.charAt(i)!=''){
                    length++;
                    i++;
                }
                String str2 = str1.substring(1,length-1);
                out.writeUTF(str2);

                String ret = input.readUTF();

                System.out.println("服务器端返回过来的是: " + ret);
                out.close();
                input.close();
            } catch (Exception e) {
                System.out.println("客户端异常:" + e.getMessage());
            } finally {
                if (socket != null) {
                    try {
                        socket.close();
                    } catch (IOException e) {
                        socket = null;
                        System.out.println("客户端 finally 异常:" + e.getMessage());
                    }
                }
            }
        }
    }
}

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * Created by zxy on 2019/5/28.
 */

public class Server {
    public static final int PORT = 12345;//监听的端口号

    public static void main(String[] args) {
        System.out.println("服务器启动...
");
        Server server = new Server();
        server.init();
    }

    public void init() {
        try {
            ServerSocket serverSocket = new ServerSocket(PORT);
            while (true) {
                // 一旦有堵塞, 则表示服务器与客户端获得了连接
                Socket client = serverSocket.accept();
                // 处理这次连接
                new HandlerThread(client);
            }
        } catch (Exception e) {
            System.out.println("服务器异常: " + e.getMessage());
        }
    }

    private class HandlerThread implements Runnable {
        private Socket socket;
        public HandlerThread(Socket client) {
            socket = client;
            new Thread(this).start();
        }

        public void run() {
            try {
                // 读取客户端数据
                DataInputStream input = new DataInputStream(socket.getInputStream());
                String clientInputStr = input.readUTF();//这里要注意和客户端输出流的写方法对应,否则会抛 EOFException
                // 处理客户端数据
                System.out.println("客户端发过来的内容:" + clientInputStr);
                MyDC2 evalute = new MyDC2();
                int result = evalute.evaluate(clientInputStr);
                // 向客户端回复信息
                DataOutputStream out = new DataOutputStream(socket.getOutputStream());
                System.out.print("计算结果:	");
                // 发送键盘输入的一行
                //String s = new BufferedReader(new InputStreamReader(System.in)).readLine();
                out.writeUTF(String.valueOf(result));

                out.close();
                input.close();
            } catch (Exception e) {
                System.out.println("服务器 run 异常: " + e.getMessage());
            } finally {
                if (socket != null) {
                    try {
                        socket.close();
                    } catch (Exception e) {
                        socket = null;
                        System.out.println("服务端 finally 异常:" + e.getMessage());
                    }
                }
            }
        }
    }
}

实验截图
客户端
2-1_水印.png
服务器
2-2_水印.png

网络编程与安全-3

加密结对编程：1人负责客户端，一人负责服务器

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

import java.io.BufferedReader;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.InputStreamReader;

import java.net.ServerSocket;

import java.net.Socket;



public class Server2 {

    public static final int PORT = 12345;//监听的端口号



    public static void main(String[] args) {

        System.out.println("服务器启动...
");

        Server server = new Server();

        server.init();

    }



    public void init() {

        try {

            ServerSocket serverSocket = new ServerSocket(PORT);

            while (true) {

                // 一旦有堵塞, 则表示服务器与客户端获得了连接

                Socket client = serverSocket.accept();

                // 处理这次连接

                new HandlerThread(client);

            }

        } catch (Exception e) {

            System.out.println("服务器异常: " + e.getMessage());

        }

    }



    private class HandlerThread implements Runnable {

        private Socket socket;

        public HandlerThread(Socket client) {

            socket = client;

            new Thread(this).start();

        }
        public void run() {

            try {

                // 读取客户端数据

                DataInputStream input = new DataInputStream(socket.getInputStream());

                String clientInputStr = input.readUTF();//这里要注意和客户端输出流的写方法对应,否则会抛 EOFException

                // 处理客户端数据

                System.out.println("客户端发过来的内容:" + clientInputStr);

                MyDC2 evalute = new MyDC2();

                SDec sDec = new SDec();

                int result = evalute.evaluate(clientInputStr);

                // 向客户端回复信息

                DataOutputStream out = new DataOutputStream(socket.getOutputStream());

                System.out.print("计算结果:	");

                // 发送键盘输入的一行

                //String s = new BufferedReader(new InputStreamReader(System.in)).readLine();

                out.writeUTF(String.valueOf(result));



                out.close();

                input.close();

            } catch (Exception e) {

                System.out.println("服务器 run 异常: " + e.getMessage());

            } finally {

                if (socket != null) {

                    try {

                        socket.close();

                    } catch (Exception e) {

                        socket = null;

                        System.out.println("服务端 finally 异常:" + e.getMessage());

                    }

                }

            }

        }

    }

}

/**
 * Created by lxkj on 2017/6/2.
 */
import java.io.BufferedReader;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.net.Socket;



public class Client2 {

    public static final String IP_ADDR = "127.0.0.1";//服务器地址

    public static final int PORT = 12345;//服务器端口号



    public static void main(String[] args) {

        System.out.println("客户端启动...");

        System.out.println("当接收到服务器端字符为 "OK" 的时候, 客户端将终止
");

        while (true) {

            Socket socket = null;

            try {

                //创建一个流套接字并将其连接到指定主机上的指定端口号

                socket = new Socket(IP_ADDR, PORT);



                //读取服务器端数据

                DataInputStream input = new DataInputStream(socket.getInputStream());

                //向服务器端发送数据

                DataOutputStream out = new DataOutputStream(socket.getOutputStream());

                System.out.print("请输入: 	");

                String str = new BufferedReader(new InputStreamReader(System.in)).readLine();

                MyBC turner = new MyBC();

                Skey_DES skey_des = new Skey_DES();

                skey_des.key_DES();

                Skey_kb skey_kb = new Skey_kb();

                skey_kb.key();

                /*产生密钥*/
                SEnc sEnc = new SEnc();

                String str1 = turner.turn(str);

                int length=0,i=0;

                while(str1.charAt(i)!=''){

                    length++;

                    i++;

                }

                String str2 = str1.substring(1,length-1);

                out.writeUTF(str2);



                String ret = input.readUTF();



                System.out.println("服务器端返回过来的是: " + ret);

                // 如接收到 "OK" 则断开连接

                /*if ("OK".equals(ret)) {

                    System.out.println("客户端将关闭连接");

                    Thread.sleep(500);

                    break;

                }*/



                out.close();

                input.close();

            } catch (Exception e) {

                System.out.println("客户端异常:" + e.getMessage());

            } finally {

                if (socket != null) {

                    try {

                        socket.close();

                    } catch (IOException e) {

                        socket = null;

                        System.out.println("客户端 finally 异常:" + e.getMessage());

                    }

                }

            }

        }

    }

}

import java.io.*;
import javax.crypto.*;
/**
 * Created by zxy on 2019/5/28.
 */

public class Skey_DES{
    public static void key_DES()
            throws Exception{
        KeyGenerator kg=KeyGenerator.getInstance("DESede");
        kg.init(168);
        SecretKey k=kg.generateKey( );
        FileOutputStream  f=new FileOutputStream("key1.dat");
        ObjectOutputStream b=new  ObjectOutputStream(f);
        b.writeObject(k);
    }
}

import java.io.*;
import java.security.*;
/**
 * Created by zxy on 2019/5/28.
 */

public class Skey_kb{
    public static void key() throws Exception{
        FileInputStream f=new FileInputStream("key1.dat");
        ObjectInputStream b=new ObjectInputStream(f);
        Key k=(Key)b.readObject( );
        byte[ ] kb=k.getEncoded( );
        FileOutputStream  f2=new FileOutputStream("keykb1.dat");
        f2.write(kb);

        // 打印密钥编码中的内容
        System.out.println("密钥为：");
        for(int i=0;i<kb.length;i++){
            System.out.print(kb[i]+",");
        }
        System.out.println();
    }
}

实验截图
客户端
3-1_水印.png
服务器
3-2_水印.png

网络编程与安全-4

密钥分发结对编程：1人负责客户端，一人负责服务器

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

/**
 * Created by lxkj on 2017/6/2.
 */
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 main(String args[ ]) throws Exception{
        DHParameterSpec DHP=
                new DHParameterSpec(skip1024Modulus,skip1024Base);

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

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

/**
 * Created by lxkj on 2017/6/2.
 */
import javax.crypto.KeyAgreement;
import javax.crypto.spec.SecretKeySpec;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.security.PrivateKey;
import java.security.PublicKey;

public class KeyAgree{
    public static void main(String args[ ]) throws Exception{
        // 读取对方的DH公钥
        FileInputStream f1=new FileInputStream(args[0]);
        ObjectInputStream b1=new ObjectInputStream(f1);
        PublicKey pbk=(PublicKey)b1.readObject( );
//读取自己的DH私钥
        FileInputStream f2=new FileInputStream(args[1]);
        ObjectInputStream b2=new ObjectInputStream(f2);
        PrivateKey prk=(PrivateKey)b2.readObject( );
        // 执行密钥协定
        KeyAgreement ka=KeyAgreement.getInstance("DH");
        ka.init(prk);
        ka.doPhase(pbk,true);
        //生成共享信息
        byte[ ] sb=ka.generateSecret();
        for(int i=0;i<sb.length;i++){
            System.out.print(sb[i]+",");
        }
        SecretKeySpec k=new  SecretKeySpec(sb,"DESede");
    }
}

实验截图
客户端

服务器

网络编程与安全-5

完整性校验结对编程：1人负责客户端，一人负责服务器

1. 注意责任归宿，要会通过测试证明自己没有问题
1. 基于Java Socket实现客户端/服务器功能，传输方式用TCP
1. 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密通过网络把密文和明文的MD5値发送给服务器
1. 客户端和服务器用DH算法进行3DES或AES算法的密钥交换
1. 服务器接收到后缀表达式表达式后，进行解密，解密后计算明文的MD5值，和客户端传来的MD5进行比较，一致则调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
1. 客户端显示服务器发送过来的结果
1. 上传测试结果截图和码云链接

实验截图
客户端

服务器

实验问题

解决方法：关掉IDEA，重新打开。

实验总结

这次实验比前几次实验花费的时间更多，也比其他实验更难，以前学过的知识忘记了一部分，学习就是不断预习和不断复习，这样才能更快的去掌握一门课程。

步骤	耗时	百分比
需求分析	10min	6.7%
设计	25min	16.7%
代码实现	90min	60%
测试	10min	6.7%
分析总结	15min	10%

相关阅读:
两小时入门Docker
Django之Model操作
 Django-channels 实现WebSocket实例
 Python项目中的单元测试
 將Python打包成 exe可执行文件
 CORS 跨域
 购物车模块
 登陆模块
 Git 基本用法
 Django ORM性能优化和图片验证码
原文地址：https://www.cnblogs.com/besti20175216/p/10938864.html

2018-2019-2 20175216张雪原 实验五《网络编程与安全》实验报告

2018-2019-2 20175216张雪原 实验五《网络编程与安全》实验报告

实验五 网络编程与安全-1

实验原理

网络编程与安全-2

网络编程与安全-3

网络编程与安全-4

网络编程与安全-5

实验问题

实验总结

2018-2019-2 20175216张雪原实验五《网络编程与安全》实验报告

2018-2019-2 20175216张雪原实验五《网络编程与安全》实验报告

实验五网络编程与安全-1