20162323周楠 实验五 实验报告

20162323周楠 实验五 网络编程与安全 实验报告

实验内容

实验一:两人一组结对编程:

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

实验二:结对编程:1人负责客户端,一人负责服务器

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

实验三:加密结对编程:1人负责客户端,一人负责服务器

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

实验四:密钥分发结对编程:1人负责客户端,一人负责服务器

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

实验五:完整性校验结对编程:1人负责客户端,一人负责服务器

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

实验要求

  • 严禁抄袭,有该行为者实验成绩归零,并附加其他惩罚措施。

实验步骤

实验一

  • 1.编写MyBC.java实现中缀表达式转后缀表达式的功能
  • 2.编写MyDC.java实现由1获取的表达式中后缀表达式求值的功能

中缀表达式转后缀表达式:

public static String toPostfix(String expr){
        MyStack<String> stack = new MyStack<>(expr.length());
        String postfix = "";
        int i = 0;
        while(i<expr.length()){
            char ch = expr.charAt(i);
            switch (ch){
                case  '+':
                case  '-':while(!stack.isEmpty() && !stack.get().equals("("))
                    postfix += stack.pop();
                    //postfix += " ";
                    stack.push(ch + "");
                    i++;
                    break;
                case '*':
                case '/':while (!stack.isEmpty() && (stack.get().equals("*")||stack.get().equals("/")))
                    postfix += stack.pop();
                    //postfix += " ";
                    stack.push(ch + "");
                    i++;
                    break;
                case '(':stack.push(ch + "");
                    i++;
                    break;
                case ')':String out = stack.pop();
                    while(out!=null && !out.equals("(")){
                        postfix += out;
                        out = stack.pop();
                        //postfix += " ";
                    }
                    i++;
                    break;
                default:while(i < expr.length() && ch>='0' && ch<='9'){
                    postfix += ch;
                    i++;
                    if(i<expr.length())
                        ch = expr.charAt(i);
                }
                postfix += " ";
            }
        }
        while (!stack.isEmpty())
            postfix += stack.pop();
        return postfix;
    }

后缀表达式计算:

public int value(String postfix){
        Stack<Integer> stack = new Stack();
        int i = 0, result = 0;
        while(i < postfix.length()){
            char ch = postfix.charAt(i);
            if(ch>='0' && ch<='9'){
                result = 0;
                while(ch!=' '){
                    result = result*10 + Integer.parseInt(ch+"");
                    i++;
                    ch = postfix.charAt(i);
                }
                i++;
                stack.push(new Integer(result));
            }
            else{
                int y = stack.pop().intValue();
                int x = stack.pop().intValue();
                switch (ch){
                    case ADD:
                        result = x + y;
                        break;
                    case SUBTRACT:
                        result = x - y;
                        break;
                    case MULTIPLY:
                        result = x * y;
                        break;
                    case DIVIDE:
                        result = x / y;
                }
                stack.push(new Integer(result));
                i++;
            }
        }
        return stack.pop().intValue();
    }

运行结果:

实验二

创建客户端:

            Socket socket = new Socket("192.168.1.115", 5209);
            System.out.println("客户端启动成功");
             
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            
            PrintWriter write = new PrintWriter(socket.getOutputStream());
            
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            
            String readline;
            readline = br.readLine(); 
            while (!readline.equals("end")) {
                 write.println(readline);
                
               System.out.println("Client:" + readline);
                 System.out.println("Server:" + in.readLine());
                
                readline = br.readLine(); 
            write.close(); 
            in.close(); 
            socket.close(); 
        

创建服务器:

        SocketService socketService = new SocketService();
       
        socketService.oneServer();
    }
    public  void oneServer(){
        try{
            ServerSocket server=null;
            try{
                server=new ServerSocket(5200);
              
                System.out.println("服务器启动成功");
              
            }catch(Exception e) {
                System.out.println("没有启动监听:"+e);
                
            }
            Socket socket=null;
            try{
                socket=server.accept();
            
            }catch(Exception e) {
                System.out.println("Error."+e);
                
            }
            
            String line;
            BufferedReader in=new BufferedReader(new InputStreamReader(socket.getInputStream()));
            
            PrintWriter writer=new PrintWriter(socket.getOutputStream());
            
            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
             System.out.println("Client:"+in.readLine());
            
            line=br.readLine();
            
            
            while(!line.equals("end")){
              
                writer.println(line);
                
                writer.flush();
                 System.out.println("Server:"+line);
                
                System.out.println("Client:"+in.readLine());
                 line=br.readLine();
                
            writer.close(); 
            in.close(); 
            socket.close(); 
            server.close(); 
        }catch(Exception e) {
            System.out.println("Error."+e);
        }
    }

运行结果:

实验三

  • 对称密钥的生成和保存
  • 使用对称密钥进行加密和解密
  • 从文件中获取加密时使用的密钥
  • 使用密钥进行解密

运行结果:

实验四

  • 创建DH公钥和私钥
  • 创建共享密钥

运行结果:

实验五

运行结果:

posted on 2017-06-12 09:09  GiggleKV  阅读(176)  评论(0)    收藏  举报

导航