实验五 Java网络编程
实验五 Java网络编程
实验五所涉及的密码学算法及编程思路
## Java对称加密-DES算法
（1） 获取密钥生成器
KeyGenerator kg=KeyGenerator.getInstance("DESede");
（2） 初始化密钥生成器
kg.init(168);
（3） 生成密钥
SecretKey k=kg.generateKey( );
（4） 通过对象序列化方式将密钥保存在文件中
FileOutputStream f=new FileOutputStream("key1.dat");
ObjectOutputStream b=new ObjectOutputStream(f); b.writeObject(k);-解密阶段
（1） 获取密文FileInputStream f=new FileInputStream("SEnc.dat"); int num=f.available(); byte[ ] ctext=new byte[num]; f.read(ctext); 2） 获取密钥
FileInputStream f2=new FileInputStream("keykb1.dat");int num2=f2.available();byte[ ] keykb=new byte[num2]; f2.read(keykb);SecretKeySpec k=new SecretKeySpec(keykb,"DESede"); （3） 创建密码器（Cipher对象）
Cipher cp=Cipher.getInstance("DESede");
（4） 初始化密码器
cp.init(Cipher.DECRYPT_MODE, k);
（5） 执行解密
byte []ptext=cp.doFinal(ctext);
非对称加密-RSA算法
（1） 创建密钥对生成器
KeyPairGenerator kpg=KeyPairGenerator.getInstance("RSA");
（2） 初始化密钥生成器
kpg.initialize(1024);
（3） 生成密钥对
KeyPair kp=kpg.genKeyPair( );
（4） 获取公钥和私钥
PublicKey pbkey=kp.getPublic( );
PrivateKey prkey=kp.getPrivate( );-加密过程
（1） 获取公钥FileInputStream f=new FileInputStream("Skey_RSA_pub.dat"); ObjectInputStream b=new ObjectInputStream(f); RSAPublicKey pbk=(RSAPublicKey)b.readObject( ); （2） 获取公钥的参数(e, n)
BigInteger e=pbk.getPublicExponent();
BigInteger n=pbk.getModulus();
（3） 获取明文整数(m)
String s="Hello World!";
byte ptext[]=s.getBytes("UTF8");
BigInteger m=new BigInteger(ptext);
（4） 执行计算
BigInteger c=m.modPow(e,n);
-解密过程
（1） 读取密文BufferedReader in= new BufferedReader(new InputStreamReader(newFileInputStream("Enc_RSA.dat")));String ctext=in.readLine();BigInteger c=new BigInteger(ctext); 2） 获取私钥
FileInputStream f=new FileInputStream("Skey_RSA_priv.dat");ObjectInputStream b=new ObjectInputStream(f);RSAPrivateKey prk=(RSAPrivateKey)b.readObject( ); （3） 获取私钥的参数(d, n)
BigInteger d=prk.getPrivateExponent( );BigInteger n=prk.getModulus( );
（4） 执行计算
BigInteger m=c.modPow(d,n);
（5） 计算明文整型数对应的字符串
byte[] mt=m.toByteArray();for(int i=0;i
创建共享密钥
- （1） 读取自己的DH私钥和对方的DH公钥
FileInputStream f1=new FileInputStream(args[0]);ObjectInputStream b1=new ObjectInputStream(f1);PublicKey pbk=(PublicKey)b1.readObject( );FileInputStream f2=newJava摘要算法- MD5 FileInputStream(args[1]);ObjectInputStream b2=new ObjectInputStream(f2);PrivateKey prk=(PrivateKey)b2.readObject( );
（2） 创建密钥协定对象
KeyAgreement ka=KeyAgreement.getInstance("DH"); （3） 初始化密钥协定对象
ka.init(prk);
（4） 执行密钥协定
ka.doPhase(pbk,true);
（5） 生成共享信息
byte[ ] sb=ka.generateSecret();
Java摘要算法- MD5
（1） 生成MessageDigest对象
MessageDigest m=MessageDigest.getInstance("MD5"); （2） 传入需要计算的字符串
m.update(x.getBytes("UTF8" )); （3） 计算消息摘要
byte s[ ]=m.digest( );
（4） 处理计算结果
String result="";for (int i=0; i
实验步骤：
- 与结对伙伴链接上同一个热点。
- 在cmd中输入ipconfig
- 找到相应的网域的ip(如我的ip为192.168.43.159)
- 伙伴在cmd中输入ping 192.168.43.159(应先关闭防火墙）
- 显示连接成功
- 找到一个闲置的端口（我用的端口为我的学号5329）
伙伴或自己打开服务器，自己在运行客户端，便可以开始测试代码了。
-此时可以连接服务器了实验内容
-实验截图分别为我idea截图和与我合作的黄斐学长的idea截图
第一题：
结对实现中缀表达式转后缀表达式的功能 MyBC.java
结对实现从上面功能中获取的表达式中实现后缀表达式求值的功能,调用MyDC.java- 将运算符写在两个操作数中间的表达式，称为“中缀表达式”，如1+2/(3-4)+5。在中缀表达式中，运算符具有不同的优先级，圆括号用于改变运算符的运算次序，所以求值过程不能直接按照从左到右的顺序进行。
将运算符写在两个操作数之后的表达式称为“后缀表达式”，如上面的中缀表达式可转换为后缀表达式1 2 3 4 - * + 5 +。后缀表达式中没有括号，而且运算符没有优先级。后缀表达式的求值过程能够严格地从左到右按顺序进行，符合运算器的求值规律。
表达式求值算法分两步进行：①中缀转后缀；②求后缀表达式的值。
①中缀转后缀的算法可描述为：
- 设置一个运算符栈，设置一个后缀表达式字符串；
- 从左到右依次对中缀表达式中的每个字符ch分别进行以下处理，直至表达式结束：
- 若ch是左括号‘（’，将其入栈；
- 若ch是数字，将其后连续若干数字添加到后缀表达式字符串之后，并添加空格作为分隔符；
- 若ch是运算符，先将栈顶若干优先级高于ch的运算符出栈，添加到后缀表达式字符串之后，再将ch入栈。当‘（’运算符在栈中时，它的优先级最低。
- 若ch是‘）’，则若干运算符全部出栈，直到出栈的是左括号，一对括号匹配。
- 若表达式结束，将栈中运算符全部出栈，添加到后缀表达式字符串之后。
代码如下：
- MyBC
import java.util.*;public class MyBC { private static LinkedList op1 = new LinkedList<>(); private static LinkedList op2 = new LinkedList<>(); private static StringBuilder a = new StringBuilder(); public StringBuilder houzhui(LinkedList list) { Iterator i = list.iterator(); while (i.hasNext()) { String s = i.next(); if (isOperator(s)) { if (op1.isEmpty()) { op1.push(s); } else { if (priority(op1.peek()) <= priority(s) && !s.equals(")")) { op1.push(s); } else if (!s.equals(")") && priority(op1.peek()) > priority(s)) { while (op1.size() != 0 && priority(op1.peek()) >= priority(s) && !op1.peek().equals("(")) { if (!op1.peek().equals("(")) { String operator = op1.pop(); a.append(operator).append(" "); op2.push(operator); } } op1.push(s); } else if (s.equals(")")) { while (!op1.peek().equals("(")) { String operator = op1.pop(); a.append(operator).append(" "); op2.push(operator); } op1.pop(); } } } else { a.append(s).append(" "); op2.push(s); } } if (!op1.isEmpty()) { Iterator iterator = op1.iterator(); while (iterator.hasNext()) { String operator = iterator.next(); a.append(operator).append(" "); op2.push(operator); iterator.remove(); } } return a; } private static boolean isOperator(String oper) { if (oper.equals("+") || oper.equals("-") || oper.equals("/") || oper.equals("*") || oper.equals("(") || oper.equals(")")) { return true; } return false; } private static int priority(String s) { switch (s) { case "+": return 1; case "-": return 1; case "*": return 2; case "/": return 2; case "(": return 3; case ")": return 3; default: return 0; } }} - MyDC
import java.util.LinkedList;import java.util.*;import java.util.*;public class MyDC { public static int evaluate(StringBuilder b) { LinkedList mList = new LinkedList<>(); String[] postStr = b.toString().split(" "); int result; for (String s : postStr) { if (fuhao(s)) { if (!mList.isEmpty()) { int num1 = Integer.valueOf(mList.pop()); int num2 = Integer.valueOf(mList.pop()); if (s.equals("/") && num1 == 0) { System.out.println("除数不能为0"); return 0; } int newNum = cal(num2, num1, s); mList.push(String.valueOf(newNum)); } } else { mList.push(s); } } result=Integer.parseInt(mList.pop()); return result; } private static boolean fuhao(String a) { if (a.equals("+") || a.equals("-") || a.equals("/") || a.equals("*") || a.equals("(") || a.equals(")")) { return true; } return false; } private static int cal(int num1, int num2, String operator) { switch (operator) { case "+": return num1 + num2; case "-": return num1 - num2; case "*": return num1 * num2; case "/": return num1 / num2; default: return 0; } }} - MyDCTest
import java.util.LinkedList;import java.util.*;public class MyDCTest { public static void main(String[] args){ LinkedList list=new LinkedList<>(); StringBuilder result1; int result2; String expression, again; System.out.println("请输入一个中缀表达式并以#结束"); Scanner scanner=new Scanner(System.in); String s; while (!(s=scanner.next()).equals("#")) { list.add(s); } MyBC hz=new MyBC(); result1 = hz.houzhui(list); System.out.println("后缀表达式： "+result1); MyDC evaluator = new MyDC(); result2 = evaluator.evaluate(result1); System.out.println("That expression equals " + result2); System.out.println(); }} 实验截图
第二题：
结对编程：1人负责客户端，一人负责服务器
- 注意责任归宿，要会通过测试证明自己没有问题
- 基于Java Socket实现客户端/服务器功能，传输方式用TCP
- 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式通过网络发送给服务器
- 服务器接收到后缀表达式，调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
- 客户端显示服务器发送过来的结果
- 上传测试结果截图和码云链接
- 套接字是一个网络连接的端点。在java中，使用java.net.Socket对象来表示一个套接字。
- 要创建一个套接字，可以使用Socket的构造方法，如：public Socket(java.lang.String host, int port)。其中，host是远程机器名或IP地址，port是远程应用程序的端口号。
- 一旦成功创建了Socket类的一个实例，就可以使用它发送或接收字节流。要发送字节流，必须先调用Socket类的getOutputStream方法来获取一个java.io.OutputStream对象。要向远程应用程序发送文本，通常要从返回的OutputStream对象构建一个java.io.PrintWriter对象。要接收来自连接的另一端的字节流，可以调用Socket类的getInputStream方法，它返回一个java.io.InputStream。
代码如下
Stack
public class MyStackimplements SStack { private Object element[]; private int top; public MyStack(int size){ this.element = new Object[Math.abs(size)]; this.top = -1; } public MyStack() { this(64); } public boolean isEmpty() { return this.top == -1; } public void push(T x) { if(x==null) return; if(this.top == element.length-1){ Object[] temp = this.element; this.element = new Object[temp.length*2]; for(int i = 0; i < temp.length; i++) this.element[i] = temp[i]; } this.top++; this.element[this.top] = x; } public T pop() { return this.top==-1 ? null:(T)this.element[this.top--]; } public T get() { return this.top==-1 ? null:(T)this.element[this.top]; }}
SStack
public interface SStack{ boolean isEmpty(); void push(T x); T pop(); T get();}
Client（客户端代码）
import java.net.*;import java.io.*;public class TCPClient { public static void main(String srgs[]) { try { //创建连接特定服务器的指定端口的Socket对象 Socket socket = new Socket("127.0.0.1", 4421); //获得从服务器端来的网络输入流 BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream())); //获得从客户端向服务器端输出数据的网络输出流 PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())),true); //创建键盘输入流，以便客户端从键盘上输入信息 BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in)); System.out.print("请输入待发送的数据："); String str=stdin.readLine(); //从键盘读入待发送的数据 String postfix = MyBC.toPostfix(str); out.println(postfix); //通过网络传送到服务器 str=in.readLine();//从网络输入流读取结果 System.out.println( "从服务器接收到的结果为："+str); //输出服务器返回的结果 } catch (Exception e) { System.out.println(e); } finally{ //stdin.close(); //in.close(); //out.close(); //socket.close(); } }} - ServerSocket是服务器套接字的一个实现。ServerSocket和Socket不同，服务器套接字的角色是，等待来自客户端的连接请求。一旦服务器套接字获得了一个连接请求，它就会创建一个Socket实例，以处理和客户端的通信。 Service（服务端代码）
import java.net.*;import java.io.*;public class TCPServer{ public static void main(String srgs[]) { ServerSocket sc = null; Socket socket=null; try { NewMyDC evaluator = new NewMyDC(); sc= new ServerSocket(4421);//创建服务器套接字 System.out.println("端口号:" + sc.getLocalPort()); System.out.println("服务器已经启动..."); socket = sc.accept(); //等待客户端连接 System.out.println("已经建立连接"); //获得网络输入流对象的引用 BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream())); 获得网络输出流对象的引用 PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())),true); String aline=in.readLine();//读取客户端传送来的数据 System.out.println("从客户端接收到信息为："+aline); //通过网络输出流返回结果给客户端 int result = evaluator.value(aline); out.println("Echo:" + result); out.close(); in.close(); sc.close(); } catch (Exception e) { System.out.println(e); } }} 实验截图：
第三题：
加密结对编程：1人负责客户端，一人负责服务器
- 注意责任归宿，要会通过测试证明自己没有问题
- 基于Java Socket实现客户端/服务器功能，传输方式用TCP
- 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密后通过网络把密文发送给服务器
- 服务器接收到后缀表达式表达式后，进行解密（和客户端协商密钥，可以用数组保存），然后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
- 客户端显示服务器发送过来的结果
- 上传测试结果截图和码云链接
- 实现DES加密主要有以下几个步骤：
- 对称密钥的生成和保存；
- 使用对称密钥进行加密和解密；
- 从文件中获取加密时使用的密钥，使用密钥进行解密；
代码如下
- 客户端加密并发送至服务器部分的代码如下：
KeyGenerator kg = KeyGenerator.getInstance("DESede"); kg.init(168); SecretKey k = kg.generateKey(); byte[] ptext2 = k.getEncoded(); Socket socket = new Socket("127.0.0.1", 4421); BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream())); PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true); BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in)); //RSA算法，使用服务器端的公钥对DES的密钥进行加密 FileInputStream f3 = new FileInputStream("Skey_RSA_pub.dat"); ObjectInputStream b2 = new ObjectInputStream(f3); RSAPublicKey pbk = (RSAPublicKey) b2.readObject(); BigInteger e = pbk.getPublicExponent(); BigInteger n = pbk.getModulus(); BigInteger m = new BigInteger(ptext2); BigInteger c = m.modPow(e, n); String cs = c.toString(); out.println(cs); // 通过网络将加密后的秘钥传送到服务器 System.out.print("请输入待发送的数据："); //用DES加密明文得到密文 String s = stdin.readLine(); // 从键盘读入待发送的数据 String postfix = MyBC.toPostfix(s); Cipher cp = Cipher.getInstance("DESede"); cp.init(Cipher.ENCRYPT_MODE, k); byte ptext[] = postfix.getBytes("UTF8"); byte ctext[] = cp.doFinal(ptext); String str = parseByte2HexStr(ctext); out.println(str); // 通过网络将密文传送到服务器 -服务器解密、计算并发送至客户端部分的代码如下：
String line = in.readLine(); BigInteger cipher = new BigInteger(line); FileInputStream f = new FileInputStream("Skey_RSA_priv.dat"); ObjectInputStream b = new ObjectInputStream(f); RSAPrivateKey prk = (RSAPrivateKey) b.readObject(); BigInteger d = prk.getPrivateExponent(); BigInteger n = prk.getModulus();//mod n BigInteger m = cipher.modPow(d, n);//m=d (mod n) System.out.println("d= " + d); System.out.println("n= " + n); System.out.println("m= " + m); byte[] keykb = m.toByteArray(); // 使用DES对密文进行解密 String readline = in.readLine();//读取客户端传送来的数据 FileInputStream f2 = new FileInputStream("keykb1.dat"); int num2 = f2.available(); byte[] ctext = parseHexStr2Byte(readline); Key k = new SecretKeySpec(keykb,"DESede"); Cipher cp = Cipher.getInstance("DESede"); cp.init(Cipher.DECRYPT_MODE, k); byte[] ptext = cp.doFinal(ctext); String p = new String(ptext, "UTF8");//编码转换 System.out.println("从客户端接收到信息为：" + p); //打印解密结果 NewMyDC evaluator = new NewMyDC(); int _result = evaluator.value(p); out.println("Echo:" + _result); out.close(); in.close(); link.close(); - 服务端代码如下（Serice)
import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.io.PrintWriter;import java.net.ServerSocket;import java.net.Socket;import java.io.*;import java.security.*;import javax.crypto.*;import javax.crypto.spec.*;public class SocketService { public static void main(String[] args) throws IOException, IllegalBlockSizeException, InvalidKeyException, BadPaddingException, NoSuchAlgorithmException, NoSuchPaddingException { SocketService socketService = new SocketService(); try { socketService.oneServer(); } catch (IOException e) { e.printStackTrace(); } catch (NoSuchPaddingException e) { e.printStackTrace(); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } catch (InvalidKeyException e) { e.printStackTrace(); } catch (BadPaddingException e) { e.printStackTrace(); } catch (IllegalBlockSizeException e) { e.printStackTrace(); } } public void oneServer() throws IOException, NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException { MyDC mydc=new MyDC(); try{ ServerSocket server=null; try{ server=new ServerSocket(5204); 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()); line=in.readLine(); System.out.printf("密文=%s\n",line); // 获取密钥 byte[]ctext=line.getBytes("ISO-8859-1"); FileInputStream f2=new FileInputStream("keykb1.dat"); int num2=f2.available(); byte[ ] keykb=new byte[num2]; System.out.printf("\n"); f2.read(keykb); SecretKeySpec k=new SecretKeySpec(keykb,"DESede"); // 解密 Cipher cp=Cipher.getInstance("DESede"); cp.init(Cipher.DECRYPT_MODE, k); byte []ptext=cp.doFinal(ctext); // 显示明文 String p=new String(ptext,"UTF8"); System.out.println("明文:"+p); int a; String Np=""; for(int i=1;i - 客户端代码
import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.io.PrintWriter;import java.net.Socket;import java.io.*;import java.security.*;import java.util.Arrays;import javax.crypto.*;public class SocketClient { // 搭建客户端 public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException { MyBC mybc=new MyBC(); try { Socket socket = new Socket("192.168.43.166",5329); 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; System.out.println("Client:" ); readline = br.readLine(); String line=mybc.evaluate(readline); FileInputStream f=new FileInputStream("key1.dat"); ObjectInputStream b=new ObjectInputStream(f); Key k=(Key)b.readObject(); Cipher cp=Cipher.getInstance("DESede"); cp.init(Cipher.ENCRYPT_MODE, k); byte ptext[]=line.getBytes("UTF-8"); byte ctext[]=cp.doFinal(ptext); String Str=new String(ctext,"ISO-8859-1"); write.println(Str); write.flush(); System.out.println("Server return:" + in.readLine()); write.close(); in.close(); socket.close(); } catch (Exception e) { System.out.println("can not listen to:" + e); } }} 实验截图
第四题：
密钥分发结对编程：1人负责客户端，一人负责服务器
- 注意责任归宿，要会通过测试证明自己没有问题
- 基于Java Socket实现客户端/服务器功能，传输方式用TCP
- 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密通过网络把密文发送给服务器
- 客户端和服务器用DH算法进行3DES或AES算法的密钥交换
- 服务器接收到后缀表达式表达式后，进行解密，然后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
- 客户端显示服务器发送过来的结果
- 上传测试结果截图和码云链接
- 执行密钥协定的标准算法是DH算法（Diffie-Hellman算法），分为以下两步：
- 创建DH公钥和私钥；
- 创建共享密钥。
- 创建DH公钥和私钥：
代码如下
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); }} -创建共享密钥:
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 实验截图
第五题：
完整性校验结对编程：1人负责客户端，一人负责服务器
- 注意责任归宿，要会通过测试证明自己没有问题
- 基于Java Socket实现客户端/服务器功能，传输方式用TCP
- 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密通过网络把密文和明文的MD5値发送给服务器
- 客户端和服务器用DH算法进行3DES或AES算法的密钥交换
- 服务器接收到后缀表达式表达式后，进行解密，解密后计算明文的MD5值，和客户端传来的MD5进行比较，一致则调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
客户端显示服务器发送过来的结果
代码如下：
Service
import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.io.PrintWriter;import java.net.ServerSocket;import java.net.Socket;import java.io.*;import java.security.*;import javax.crypto.*;import javax.crypto.spec.*;public class SocketService { public static void main(String[] args) throws IOException, IllegalBlockSizeException, InvalidKeyException, BadPaddingException, NoSuchAlgorithmException, NoSuchPaddingException { SocketService socketService = new SocketService(); try { socketService.oneServer(); } catch (IOException e) { e.printStackTrace(); } catch (NoSuchPaddingException e) { e.printStackTrace(); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } catch (InvalidKeyException e) { e.printStackTrace(); } catch (BadPaddingException e) { e.printStackTrace(); } catch (IllegalBlockSizeException e) { e.printStackTrace(); } } public void oneServer() throws IOException, NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException { MyDC mydc=new MyDC(); try{ ServerSocket server=null; try{ server=new ServerSocket(5329); 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()); line=in.readLine(); String line1=in.readLine(); System.out.printf("密文=%s\n",line); // 获取密钥 byte[]ctext=line.getBytes("ISO-8859-1"); FileInputStream f2=new FileInputStream("keykb1.dat"); int num2=f2.available(); byte[ ] keykb=new byte[num2]; System.out.printf("\n"); f2.read(keykb); SecretKeySpec k=new SecretKeySpec(keykb,"DESede"); // 解密 Cipher cp=Cipher.getInstance("DESede"); cp.init(Cipher.DECRYPT_MODE, k); byte []ptext=cp.doFinal(ctext); // 显示明文 String p=new String(ptext,"UTF8"); int a; System.out.println("明文:"+p); String Np=""; for(int i=1;i 创建共享密钥
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 实验截图
实验总结与体会
这次实验是java这门课程的最后一次实验，在这次实验中拿到题目的第一反应就是怎么办呀，老师也没给教程，什么都没有，好无助，好绝望呀。
但是想想再挣扎一下吧，代码好难不会写怎么办呀，最后拿了学长的代码来用，拿来的代码也有很多问题，慢慢改到能编译了，发现运行结果不对，再继续修改到，编译运行都对了。本次实验花了两天时间，虽然时间花费了很多，但也学习到了很多知识。我认为这次实验完成的很棒。{ {uploading-image-522164.png(uploading...)}}重温本次实验，真正的用到了结对编程。虽然代码不是自己的，重新仔细的看了一遍。明白了每段代码发挥的作用。相对与信息安全专业来说，密码是保证信息安全得重要手段，本次实验让我们体会到了编程实现密码算法对信息安全的实用性，正确性。