20165230 《Java程序设计》实验五《网络编程与安全》实验报告

一、实验报告封面

课程：Java程序设计 班级：1652班 姓名：田坤烨 学号：20165230 成绩：

指导教师：娄嘉鹏 实验日期：2018年5月28日

实验时间：13:45 - 15:25

实验序号：实验五 实验名称：网络编程与安全

实验要求：

  1. 没有Linux基础的同学建议先学习《Linux基础入门（新版）》《Vim编辑器》 课程；
  2. 完成实验、撰写实验报告，注意实验报告重点是运行结果，遇到的问题(工具查找，安装，使用，程序的编辑，调试，运行等)、解决办法（空洞的方法如“查网络”、“问同学”、“看书”等一律得0分）以及分析（从中可以得到什么启示，有什么收获，教训等）；
  3. 实验报告中统计自己的PSP(Personal Software Process)时间；
  4. 严禁抄袭。

二、实验内容及步骤

（一）实现中缀表达式转后缀表达式并实现后缀表达式求值的功能

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

MyBC.java

  1. import java.util.Stack;
  2. import java.util.StringTokenizer;
  4. public class MyBC{
  5.     private Stack<Character> stack1;
  6.     public char Precede(char a,char b)
  7.     {
  8.         if(a=='#')
  9.             if(b!='#')
  10.                 return '<';
  11.             else
  12.                 return '=';
  13.         if(a==')')
  14.             return '>';
  15.         if(a=='(')
  16.             if(b!=')')
  17.                 return '<';
  18.             else
  19.                 return '=';
  20.         if(a=='/'||a=='*')
  21.             if(b!='(')
  22.                 return '>';
  23.             else
  24.                 return '<';
  25.         if(a=='-'||a=='+')
  26.             if(b!='*'&&b!='/'&&b!='(')
  27.                 return '>';
  28.             else
  29.                 return '<';
  30.         return '>';
  31.     }
  32.     public MyBC() {
  33.         stack1 = new Stack<Character>();
  34.         stack1.push('#');
  35.     }
  36.     public String turn(String expr) {
  37.         int  result = 0;
  38.         String token;
  39.         char topelem,optr;
  40.         char[] exper1 = new char[100];
  41.         int i = 0;
  43.         StringTokenizer tokenizer = new StringTokenizer (expr);
  44.         while (tokenizer.hasMoreTokens())
  45.         {
  46.             token = tokenizer.nextToken();
  48.             //如果是运算符，调用isOperator
  50.             if (isOperator(token))
  51.             {
  52.                 //调用Precede比较优先级
  54.                 topelem=stack1.peek();
  56.                 optr = token.charAt(0);
  58.                 if(Precede(topelem,optr)=='<')
  59.                 {
  61.                     stack1.push(optr);
  63.                 }
  64.                 else if(Precede(topelem,optr)=='=')
  65.                 {
  66.                     optr =stack1.pop();
  67.                     exper1[i++] = optr;
  68.                     exper1[i++] = ' ';
  69.                 }
  70.                 else if(Precede(topelem,optr)=='>')
  71.                 {
  72.                     optr =stack1.pop();
  73.                     //从运算符栈中退出栈顶元素并放入后缀表达式exper1
  74.                     exper1[i++] = optr;
  75.                     exper1[i++] = ' ';
  76.                 }
  77.             }//如果是(则入栈
  78.             else if(token.equals("(")) {
  79.                 optr = token.charAt(0);
  80.                 stack1.push(optr);
  81.             }//如果是）则退栈直到出现第一个（
  82.             else if(token.equals(")")) {
  83.                 optr = stack1.pop();
  84.                 while(optr!='(')
  85.                 {
  86.                     exper1[i++] = optr;
  87.                     exper1[i++] = ' ';
  88.                     optr = stack1.pop();
  89.                 }
  90.             }
  91.             else//如果是操作数
  92.             //操作数放入后缀表达式exper1
  93.             {
  94.                 optr = token.charAt(0);
  95.                 //System.out.println(optr);
  96.                 exper1[i++]=optr;
  97.                 exper1[i++] = ' ';
  99.             }
  100.         }
  101.         while(!stack1.isEmpty())
  102.         {
  103.             optr = stack1.pop();
  104.             if(optr!='#'){
  105.                 exper1[i++] = optr;
  106.                 exper1[i++] = ' ';
  107.             }
  108.         }
  109.         //System.out.println(exper1);
  111.         return ToString(exper1);
  112.     }
  113.     //@Override
  114.     private boolean isOperator(String token)
  115.     {
  117.         return (token.equals("+") || token.equals("-") ||token.equals("*") || token.equals("/") );
  118.     }
  119.     public  static String ToString(char[] exper1){
  120.         int length = exper1.length;
  121.         String str=" ";
  122.         for(int i=0;i<length;i++)
  123.         {
  124.             str=str+exper1[i];
  125.         }
  126.         return str;
  127.     }
  129. }
  • MyBC测试结果截图

（二） 基于Java Socket实现客户端/服务器功能

  1. 基于Java Socket实现客户端/服务器功能，传输方式用TCP
  2. 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式通过网络发送给服务器
  3. 服务器接收到后缀表达式，调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
  4. 客户端显示服务器发送过来的结果
  5. 上传测试结果截图和码云链接
  • 服务器端代码（由我负责）
  1. import java.io.BufferedReader;
  2. import java.io.DataInputStream;
  3. import java.io.DataOutputStream;
  4. import java.io.InputStreamReader;
  5. import java.net.ServerSocket;
  6. import java.net.Socket;
  8. public class Server {
  9.     public static final int PORT = 12345;//监听的端口号
  11.     public static void main(String[] args) {
  12.         System.out.println("服务器启动...\n");
  13.         Server server = new Server();
  14.         server.init();
  15.     }
  17.     public void init() {
  18.         try {
  19.             ServerSocket serverSocket = new ServerSocket(PORT);
  20.             while (true) {
  21.                 // 一旦有堵塞, 则表示服务器与客户端获得了连接
  22.                 Socket client = serverSocket.accept();
  23.                 // 处理这次连接
  24.                 new HandlerThread(client);
  25.             }
  26.         } catch (Exception e) {
  27.             System.out.println("服务器异常: " + e.getMessage());
  28.         }
  29.     }
  31.     private class HandlerThread implements Runnable {
  32.         private Socket socket;
  33.         public HandlerThread(Socket client) {
  34.             socket = client;
  35.             new Thread(this).start();
  36.         }
  38.         public void run() {
  39.             try {
  40.                 // 读取客户端数据
  41.                 DataInputStream input = new DataInputStream(socket.getInputStream());
  42.                 String clientInputStr = input.readUTF();//这里要注意和客户端输出流的写方法对应,否则会抛 EOFException
  43.                 // 处理客户端数据
  44.                 System.out.println("客户端发过来的内容:" + clientInputStr);
  45.                 MyDC evalute = new MyDC();
  46.                 int result = evalute.evaluate(clientInputStr);
  47.                 // 向客户端回复信息
  48.                 DataOutputStream out = new DataOutputStream(socket.getOutputStream());
  49.                 System.out.print("计算结果:\t");
  50.                 // 发送键盘输入的一行
  51.                 //String s = new BufferedReader(new InputStreamReader(System.in)).readLine();
  52.                 out.writeUTF(String.valueOf(result));
  54.                 out.close();
  55.                 input.close();
  56.             } catch (Exception e) {
  57.                 System.out.println("服务器 run 异常: " + e.getMessage());
  58.             } finally {
  59.                 if (socket != null) {
  60.                     try {
  61.                         socket.close();
  62.                     } catch (Exception e) {
  63.                         socket = null;
  64.                         System.out.println("服务端 finally 异常:" + e.getMessage());
  65.                     }
  66.                 }
  67.             }
  68.         }
  69.     }
  70. }

  • 运行截图

  • 客户端代码（由搭档负责）

  1. import java.io.BufferedReader;
  2. import java.io.DataInputStream;
  3. import java.io.DataOutputStream;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.net.Socket;
  8. public class Client {
  9.     public static final String IP_ADDR = "127.0.0.1";//服务器地址
  10.     public static final int PORT = 12345;//服务器端口号
  12.     public static void main(String[] args) {
  13.         System.out.println("客户端启动...");
  14.         System.out.println("当接收到服务器端字符为 \"OK\" 的时候, 客户端将终止\n");
  15.         while (true) {
  16.             Socket socket = null;
  17.             try {
  19.                 socket = new Socket(IP_ADDR, PORT);
  20.                 DataInputStream input = new DataInputStream(socket.getInputStream());
  21.                 DataOutputStream out = new DataOutputStream(socket.getOutputStream());
  22.                 System.out.print("请输入: \t");
  23.                 String str = new BufferedReader(new InputStreamReader(System.in)).readLine();
  24.                 MyBC turner = new MyBC();
  25.                 String str1 = turner.turn(str);
  26.                 int length=0,i=0;
  27.                 while(str1.charAt(i)!='\0'){
  28.                     length++;
  29.                     i++;
  30.                 }
  31.                 String str2 = str1.substring(1,length-1);
  32.                 out.writeUTF(str2);
  34.                 String ret = input.readUTF();
  36.                 System.out.println("服务器端返回过来的是: " + ret);
  37.                 out.close();
  38.                 input.close();
  39.             } catch (Exception e) {
  40.                 System.out.println("客户端异常:" + e.getMessage());
  41.             } finally {
  42.                 if (socket != null) {
  43.                     try {
  44.                         socket.close();
  45.                     } catch (IOException e) {
  46.                         socket = null;
  47.                         System.out.println("客户端 finally 异常:" + e.getMessage());
  48.                     }
  49.                 }
  50.             }
  51.         }
  52.     }
  53. }
  • 运行截图

（三）加密结对编程

  1. 基于Java Socket实现客户端/服务器功能，传输方式用TCP
  2. 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密后通过网络把密文发送给服务器
  3. 服务器接收到后缀表达式表达式后，进行解密（和客户端协商密钥，可以用数组保存），然后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
  4. 客户端显示服务器发送过来的结果
  5. 上传测试结果截图和码云链接
  • 服务器端（由我负责）
  1. import java.io.BufferedReader;
  2. import java.io.DataInputStream;
  3. import java.io.DataOutputStream;
  4. import java.io.InputStreamReader;
  5. import java.net.ServerSocket;
  6. import java.net.Socket;
  8. public class ServerReceive{
  10.     public static final int PORT = 12345;//监听的端口号
  11.     public static void main(String[] args) {
  12.         System.out.println("服务器启动...\n");
  13.         Server server = new Server();
  14.         server.init();
  16.     }
  18.     public void init() {
  19.         try {
  20.             ServerSocket serverSocket = new ServerSocket(PORT);
  21.             while (true) {
  22.                 // 一旦有堵塞, 则表示服务器与客户端获得了连接
  23.                 Socket client = serverSocket.accept();
  24.                 // 处理这次连接
  25.                 new HandlerThread(client);
  26.             }
  28.         } catch (Exception e) {
  29.             System.out.println("服务器异常: " + e.getMessage());
  31.         }
  33.     }
  35.     private class HandlerThread implements Runnable {
  36.         private Socket socket;
  37.         public HandlerThread(Socket client) {
  38.             socket = client;
  39.             new Thread(this).start();
  41.         }
  42.         public void run() {
  44.             try {
  45.                 /*读取客户端数据*/
  46.                 DataInputStream input = new DataInputStream(socket.getInputStream());
  47.                 String clientInputStr = input.readUTF();
  48.                 /*处理客户端数据*/
  49.                 System.out.println("客户端发过来的内容:" + clientInputStr);
  50.                 MyDC evalute = new MyDC();
  51.                 SDec sDec = new SDec();//解密
  52.                 int result = evalute.evaluate(clientInputStr);
  53.                 /* 向客户端回复信息*/
  54.                 DataOutputStream out = new DataOutputStream(socket.getOutputStream());
  55.                 System.out.print("计算结果:\t");
  56.                 /*发送键盘输入的一行*/
  57.                 out.writeUTF(String.valueOf(result));
  58.                 out.close();
  59.                 input.close();
  61.             }
  62.             catch (Exception e) {
  63.                 System.out.println("服务器 run 异常: " + e.getMessage());
  64.             }
  65.             finally {
  66.                 if (socket != null) {
  67.                     try {
  68.                         socket.close();
  69.                     }
  70.                     catch (Exception e) {
  71.                         socket = null;
  72.                         System.out.println("服务端 finally 异常:" + e.getMessage());
  73.                     }
  74.                 }
  75.             }
  76.         }
  77.     }
  78. }

  • 运行截图

  • 客户端代码（由搭档负责）

  1. import java.io.BufferedReader;
  3. import java.io.DataInputStream;
  5. import java.io.DataOutputStream;
  7. import java.io.IOException;
  9. import java.io.InputStreamReader;
  11. import java.net.Socket;
  13. public class Client2 {
  14.     public static final String IP_ADDR = "127.0.0.1";//服务器地址
  15.     public static final int PORT = 12345;//服务器端口号
  16.     public static void main(String[] args) {
  17.         System.out.println("客户端启动...");
  18.         System.out.println("当接收到服务器端字符为 \"OK\" 的时候, 客户端将终止\n");
  19.         while (true) {
  20.             Socket socket = null;
  21.             try {
  22.                 //创建一个流套接字并将其连接到指定主机上的指定端口号
  23.                 socket = new Socket(IP_ADDR, PORT);
  24.                 //读取服务器端数据
  25.                 DataInputStream input = new DataInputStream(socket.getInputStream());
  26.                 //向服务器端发送数据
  27.                 DataOutputStream out = new DataOutputStream(socket.getOutputStream());
  28.                 System.out.print("请输入: \t");
  29.                 String str = new BufferedReader(new InputStreamReader(System.in)).readLine();
  30.                 MyBC turner = new MyBC();
  31.                 Skey_DES skey_des = new Skey_DES();
  32.                 skey_des.key_DES();
  33.                 Skey_kb skey_kb = new Skey_kb();
  34.                 skey_kb.key();
  35.                 /*产生密钥*/
  36.                 SEnc sEnc = new SEnc();
  37.                 String str1 = turner.turn(str);
  38.                 int length=0,i=0;
  39.                 while(str1.charAt(i)!='\0'){
  40.                     length++;
  41.                     i++;
  42.                 }
  43.                 String str2 = str1.substring(1,length-1);
  44.                 out.writeUTF(str2);
  45.                 String ret = input.readUTF();
  46.                 System.out.println("服务器端返回过来的是: " + ret);
  47.                 out.close();
  48.                 input.close();
  49.             } catch (Exception e) {
  50.                 System.out.println("客户端异常:" + e.getMessage());
  51.             } finally {
  52.                 if (socket != null) {
  53.                     try {
  54.                         socket.close();
  55.                     } catch (IOException e) {
  56.                         socket = null;
  57.                         System.out.println("客户端 finally 异常:" + e.getMessage());
  58.                     }
  59.                 }
  60.             }
  61.         }
  62.     }
  63. }
  • 运行截图

（四）客户端和服务器用DH算法进行3DES或AES算法的密钥交换

  • 服务器和客户端分别运行Key_DH.java代码产生各自的公钥和私钥，然后将公钥通过网络发送给对方，，客户端和服务器利用对方发送的公钥和自己私钥运行 KeyAgree.java生成相同的共享密钥，各自利用共享密钥进行加解密工作。

Key_DH.java

  1. import java.io.*;
  2. import java.math.*;
  3. import java.security.*;
  4. import java.security.spec.*;
  5. import javax.crypto.*;
  6. import javax.crypto.spec.*;
  7. import javax.crypto.interfaces.*;
  9. public class Key_DH{
  10.     private static final byte skip1024ModulusBytes[] = {
  11.             (byte)0xF4, (byte)0x88, (byte)0xFD, (byte)0x58,
  12.             (byte)0x4E, (byte)0x49, (byte)0xDB, (byte)0xCD,
  13.             (byte)0x20, (byte)0xB4, (byte)0x9D, (byte)0xE4,
  14.             (byte)0x91, (byte)0x07, (byte)0x36, (byte)0x6B,
  15.             (byte)0x33, (byte)0x6C, (byte)0x38, (byte)0x0D,
  16.             (byte)0x45, (byte)0x1D, (byte)0x0F, (byte)0x7C,
  17.             (byte)0x88, (byte)0xB3, (byte)0x1C, (byte)0x7C,
  18.             (byte)0x5B, (byte)0x2D, (byte)0x8E, (byte)0xF6,
  19.             (byte)0xF3, (byte)0xC9, (byte)0x23, (byte)0xC0,
  20.             (byte)0x43, (byte)0xF0, (byte)0xA5, (byte)0x5B,
  21.             (byte)0x18, (byte)0x8D, (byte)0x8E, (byte)0xBB,
  22.             (byte)0x55, (byte)0x8C, (byte)0xB8, (byte)0x5D,
  23.             (byte)0x38, (byte)0xD3, (byte)0x34, (byte)0xFD,
  24.             (byte)0x7C, (byte)0x17, (byte)0x57, (byte)0x43,
  25.             (byte)0xA3, (byte)0x1D, (byte)0x18, (byte)0x6C,
  26.             (byte)0xDE, (byte)0x33, (byte)0x21, (byte)0x2C,
  27.             (byte)0xB5, (byte)0x2A, (byte)0xFF, (byte)0x3C,
  28.             (byte)0xE1, (byte)0xB1, (byte)0x29, (byte)0x40,
  29.             (byte)0x18, (byte)0x11, (byte)0x8D, (byte)0x7C,
  30.             (byte)0x84, (byte)0xA7, (byte)0x0A, (byte)0x72,
  31.             (byte)0xD6, (byte)0x86, (byte)0xC4, (byte)0x03,
  32.             (byte)0x19, (byte)0xC8, (byte)0x07, (byte)0x29,
  33.             (byte)0x7A, (byte)0xCA, (byte)0x95, (byte)0x0C,
  34.             (byte)0xD9, (byte)0x96, (byte)0x9F, (byte)0xAB,
  35.             (byte)0xD0, (byte)0x0A, (byte)0x50, (byte)0x9B,
  36.             (byte)0x02, (byte)0x46, (byte)0xD3, (byte)0x08,
  37.             (byte)0x3D, (byte)0x66, (byte)0xA4, (byte)0x5D,
  38.             (byte)0x41, (byte)0x9F, (byte)0x9C, (byte)0x7C,
  39.             (byte)0xBD, (byte)0x89, (byte)0x4B, (byte)0x22,
  40.             (byte)0x19, (byte)0x26, (byte)0xBA, (byte)0xAB,
  41.             (byte)0xA2, (byte)0x5E, (byte)0xC3, (byte)0x55,
  42.             (byte)0xE9, (byte)0x2F, (byte)0x78, (byte)0xC7
  43.     };
  44.     // The SKIP 1024 bit modulus
  45.     private static final BigInteger skip1024Modulus
  46.             = new BigInteger(1, skip1024ModulusBytes);
  47.     // The base used with the SKIP 1024 bit modulus
  48.     private static final BigInteger skip1024Base = BigInteger.valueOf(2);
  49.     public static void main(String args[ ]) throws Exception{
  50.         DHParameterSpec DHP=
  51.                 new DHParameterSpec(skip1024Modulus,skip1024Base);
  53.         KeyPairGenerator kpg= KeyPairGenerator.getInstance("DH");
  54.         kpg.initialize(DHP);
  55.         KeyPair kp=kpg.genKeyPair();
  57.         PublicKey pbk=kp.getPublic();
  58.         PrivateKey prk=kp.getPrivate();
  59.         // 保存公钥
  60.         FileOutputStream  f1=new FileOutputStream(args[0]);
  61.         ObjectOutputStream b1=new  ObjectOutputStream(f1);
  62.         b1.writeObject(pbk);
  63.         // 保存私钥
  64.         FileOutputStream  f2=new FileOutputStream(args[1]);
  65.         ObjectOutputStream b2=new  ObjectOutputStream(f2);
  66.         b2.writeObject(prk);
  67.     }
  68. }
  • 运行截图

（五）解密后计算明文的MD5值，和客户端传来的MD5进行比较，一致则调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端

  • 服务器端：
  1. import java.io.*;
  2. import java.net.*;
  3. import java.security.MessageDigest;
  4. public class Server5 {
  5.     public static void main(String args[]) {
  6.         MyDC evalute = new MyDC();
  7.         SDec sDec = new SDec();
  8.         try {
  9.             ServerSocket server = null;
  10.             try {
  11.                 server = new ServerSocket(12345);
  12.                 //创建一个ServerSocket在端口4700监听客户请求
  13.             } catch (Exception e) {
  14.                 System.out.println("can not listen to:" + e);
  15.                 //出错，打印出错信息
  16.             }
  17.             Socket socket = null;
  18.             try {
  19.                 socket = server.accept();
  20.                 //使用accept()阻塞等待客户请求，有客户
  21.                 //请求到来则产生一个Socket对象，并继续执行
  22.             } catch (Exception e) {
  23.                 System.out.println("Error." + e);
  24.                 //出错，打印出错信息
  25.             }
  26.             String line;
  27.             BufferedReader is = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  28.             //由Socket对象得到输入流，并构造相应的BufferedReader对象
  29.             PrintWriter os = new PrintWriter(socket.getOutputStream());
  30.             //由Socket对象得到输出流，并构造PrintWriter对象
  31.             BufferedReader sin = new BufferedReader(new InputStreamReader(System.in));
  33.             //由系统标准输入设备构造BufferedReader对象
  34.             //使用Hash函数检测明文完整性
  35.             String x = sin.readLine();
  36.             MessageDigest m2 = MessageDigest.getInstance("MD5");
  37.             //使用MD5算法返回实现指定摘要算法的 MessageDigest对象
  38.             m2.update(x.getBytes());
  39.             byte a[] = m2.digest();
  40.             String result = "";
  41.             for (int i = 0; i < a.length; i++) {
  42.                 result += Integer.toHexString((0x000000ff & a[i]) | 0xffffff00).substring(6);
  43.             }
  44.             System.out.println(result);
  45.             String match = is.readLine();
  46.             if (match.equals(result)) {
  47.                 System.out.println("匹配成功");
  48.             }
  49.             System.out.println("Client:" + is.readLine());
  50.             //在标准输出上打印从客户端读入的字符串
  51.             line = sin.readLine();
  52.             //从标准输入读入一字符串
  53.             while (!line.equals("bye")) {
  54.                 //如果该字符串为 "bye"，则停止循环
  55.                 os.println(evalute.evaluate(line));
  56.                 //向客户端输出该字符串
  57.                 os.flush();
  58.                 //刷新输出流，使Client马上收到该字符串
  59.                 System.out.println("Server:" + evalute.evaluate(line));
  61.                 //在系统标准输出上打印读入的字符串
  62.                 System.out.println("Client:" + is.readLine());
  63.                 //从Client读入一字符串，并打印到标准输出上
  64.                 line = sin.readLine();
  65.                 //从系统标准输入读入一字符串
  66.             }  //继续循环
  67.             os.close(); //关闭Socket输出流
  68.             is.close(); //关闭Socket输入流
  69.             socket.close(); //关闭Socket
  70.             server.close(); //关闭ServerSocket
  71.         } catch (Exception e) {
  72.             System.out.println("Error:" + e);
  73. //出错，打印出错信息
  75.         }
  76.     }
  77. }
  • 客户端
  1. import java.io.*;
  3. import java.net.*;
  5. import java.security.MessageDigest;
  6. /**
  7.  * Created by lxkj on 2017/6/2.
  8.  */
  10. public class Client5 {
  12.     public static void main(String args[]) throws Exception {
  14.         MyBC turner = new MyBC();
  16.         Skey_DES skey_des = new Skey_DES();
  18.         skey_des.key_DES();
  20.         Skey_kb skey_kb = new Skey_kb();
  22.         skey_kb.key();
  24.         /*产生密钥*/
  25.         SEnc sEnc = new SEnc();
  26.         try {
  27.             Socket socket = new Socket("127.0.0.1", 12345);
  28. //向本机的4700端口发出客户请求
  29.             BufferedReader sin = new BufferedReader(new InputStreamReader(System.in));
  30. //由系统标准输入设备构造BufferedReader对象
  31.             PrintWriter os = new PrintWriter(socket.getOutputStream());
  33. //由Socket对象得到输出流，并构造PrintWriter对象
  34.             BufferedReader is = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  35. //由Socket对象得到输入流，并构造相应的BufferedReader对象
  36.             String readline;
  37.             System.out.println("请输入：");
  38.             readline =sin.readLine();
  39.             //从系统标准输入读入一字符串
  40.             String x = readline;
  41.             // 将客户端明文的Hash值传送给服务器
  42.             MessageDigest m2 = MessageDigest.getInstance("MD5");
  43.             m2.update(x.getBytes());
  44.             byte a[] = m2.digest();
  45.             String result = "";
  46.             for (int i = 0; i < a.length; i++) {
  47.                 result += Integer.toHexString((0x000000ff & a[i]) | 0xffffff00).substring(6);
  48.             }
  49.             System.out.println("明文MD5值为:" + result);
  50.             os.println(result);//通过网络将明文的Hash函数值传送到服务器
  52.             // String str = is.readLine();// 从网络输入流读取结果
  53.             System.out.println("从服务器接收到的结果为：" + result); // 输出服务器返回的结果
  54.             while (!readline.equals("ok")) {
  56. //若从标准输入读入的字符串为 "ok"则停止循环
  58.                 readline = SEnc.Enc(turner.turn(readline));
  59.                 os.println(readline);
  60.                 /*把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES加密后通过网络发送给服务器*/
  62.                 //将从系统标准输入读入的字符串输出到Server
  64.                 os.flush();
  66.                 //刷新输出流，使Server马上收到该字符串
  68.                 System.out.println("Client:" + readline);
  70.                 //在系统标准输出上打印读入的字符串
  72.                 System.out.println("Server:" + is.readLine());
  74.                 //从Server读入一字符串，并打印到标准输出上
  76.                 readline = sin.readLine(); //从系统标准输入读入一字符串
  78.             } //继续循环
  80.             os.close(); //关闭Socket输出流
  81.             is.close(); //关闭Socket输入流
  82.             socket.close(); //关闭Socket
  84.         } catch (Exception e) {
  85.             System.out.println("Error" + e); //出错，则打印出错信息
  86.         }
  88.     }
  90. }
  • 运行截图

三、实验遇到的问题

四、PSP时间

步骤 耗时 百分比 
  1.    |需求分析           |   30min           | 12%
  2.        |  设计         | 40min            |     15%
  3. | 代码实现          |   90min          | 34%
  4. |测试          |   45min          | 17%
  5.   |分析总结          |   60min          |23%

六、代码链接

七、参考资料

20165230 《Java程序设计》实验五《网络编程与安全》实验报告的更多相关文章

  1. 20155326 《Java程序设计》实验五网络编程与安全实验报告

    20155326 <Java程序设计>实验五网络编程与安全实验报告 实验内容 任务一 1.两人一组结对编程: 参考http://www.cnblogs.com/rocedu/p/67667 ...

  2. 20155317 《Java程序设计》实验五网络编程与安全实验报告

    20155317 <Java程序设计>实验五网络编程与安全实验报告 遇到问题 在刚开始启动客户端或者服务端时,出现了一系列的错误情况,总是提示异常信息 后来经过询问同学,反应将端口号修改一 ...

  3. 20155320 《Java程序设计》实验五网络编程与安全实验报告

    20155320 <Java程序设计>实验五网络编程与安全实验报告 实验内容 实验一 1.两人一组结对编程: 参考http://www.cnblogs.com/rocedu/p/67667 ...

  4. 20155339 《Java程序设计》实验五网络编程与安全实验报告

    20155339 <Java程序设计>实验五网络编程与安全实验报告 实验内容 实验一 1.两人一组结对编程: 参考http://www.cnblogs.com/rocedu/p/67667 ...

  5. 20162328WJH实验五网络编程与安全实验报告

    20162328WJH实验五网络编程与安全实验报告 一.实验五 网络编程与安全-1 结对实现中缀表达式转后缀表达式的功能 MyBC.java 结对实现从上面功能中获取的表达式中实现后缀表达式求值的功能 ...

  6. 20155338 《JAVA程序设计》实验五网络编程与安全实验报告

    20155338 <JAVA程序设计>实验五网络编程安全实验报告 实验内容 实验一: •两人一组结对编程: •结对实现中缀表达式转后缀表达式的功能 MyBC.java •结对实现从上面功能 ...

  7. 20155324 《Java程序设计》实验五 网络编程与安全

    20155324 <Java程序设计>实验五 网络编程与安全 实验内容 任务一 编写MyBC.java实现中缀表达式转后缀表达式的功能 编写MyDC.java实现从上面功能中获取的表达式中 ...

  8. #《JAVA程序设计》 20155214 实验五 网络编程与安全

    <JAVA程序设计> 20155214 实验五 网络编程与安全 实验内容 掌握Socket程序的编写: 掌握密码技术的使用: 设计安全传输系统. 实验要求 要求一 结对实现中缀表达式转后缀 ...

  9. 20155301 《Java程序设计》实验五网络编程与安全

    20155301 <Java程序设计>实验五网络编程与安全 实验内容 实验1: 两人一组结对编程:参考http://www.cnblogs.com/rocedu/p/6766748.htm ...

  10. 20155308 《Java程序设计》实验五 网络编程与安全

    20155308 <Java程序设计>实验五 网络编程与安全 实验内容 任务一 两人一组结对编程: 参考http://www.cnblogs.com/rocedu/p/6766748.ht ...

随机推荐

  1. 12.18daily_scrum

    本软件中的最后一个界面——“关于”界面的设计已经开始进行,数据传输的内容也差不多进行过半,最主要的任务依旧在测试过程中,我们组接下来还是要大力加强测试的强度和数量,注意边际数据和错误数据的测试处理: ...

  2. mark1-git

    Administrator@-20131003RY MINGW64 ~ $ pwd /c/Users/Administrator Administrator@-20131003RY MINGW64 ~ ...

  3. 【转载】Understanding When to use RabbitMQ or Apache Kafka

    https://content.pivotal.io/rabbitmq/understanding-when-to-use-rabbitmq-or-apache-kafka RabbitMQ: Erl ...

  4. [Asp.net MVC]Asp.net MVC5系列——布局视图

    目录 系列文章 概述 布局视图 系列文章 [Asp.net MVC]Asp.net MVC5系列——第一个项目 [Asp.net MVC]Asp.net MVC5系列——添加视图 [Asp.net M ...

  5. vue 请求后台数据2（copy）

    https://blog.csdn.net/vergilgeekopen/article/details/68954940 需要引用vue-resource 安装请参考https://github.c ...

  6. SSH-keygen用法

    很多朋友在用github管理项目的时候,都是直接使用https url克隆到本地,当然也有有些人使用 SSH url 克隆到本地.然而,为什么绝大多数人会使用https url克隆呢? 这是因为,使用 ...

  7. Java 8新特性之接口改善（八恶人-1）

    Daisy Donergue 多莫歌·黛西 “By woman, you mean her?” 她也能叫女人? Java 8在13年9月发布,写这篇博文的时间已经是17年12月份了.来的有点晚,但是有 ...

  8. Queries about less or equal elements CodeForces - 600B(二分)

    You are given two arrays of integers a and b. For each element of the second arraybj you should find ...

  9. css后代选择器 .属性 元素 与 元素.属性的区别

    经常看见css的后代选择器是这样的写法: div.class   和 .class div 的形式两者的区别: div.class  是选中的类名为class 的div元素,与直接使用类选择器.cla ...

  10. Markdown公式（二）

    参考资料https://gavin_nicholas.coding.me/archives/ 1. 如何输入括号和分隔符 () . [] 和 | 表示自己, {} 表示 {} .当要显示大号的括号或分 ...