• 实验五 Java网络编程


    实验五 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<mt.length;i++){
           System.out.print((char) mt[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<s.length; i++){
           result+=Integer.toHexString((0x000000ff & s[i]) | 0xffffff00).substring(6);
      }
    

    实验步骤:

    • 与结对伙伴链接上同一个热点。
    • 在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<String> op1 = new LinkedList<>();
        private static LinkedList<String> op2 = new LinkedList<>();
        private static StringBuilder a = new StringBuilder();
    
        public StringBuilder houzhui(LinkedList<String> list) {
            Iterator<String> 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<String> 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<String> 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<String> 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人负责客户端,一人负责服务器
    0. 注意责任归宿,要会通过测试证明自己没有问题

    1. 基于Java Socket实现客户端/服务器功能,传输方式用TCP
    2. 客户端让用户输入中缀表达式,然后把中缀表达式调用MyBC.java的功能转化为后缀表达式,把后缀表达式通过网络发送给服务器
    3. 服务器接收到后缀表达式,调用MyDC.java的功能计算后缀表达式的值,把结果发送给客户端
    4. 客户端显示服务器发送过来的结果
    5. 上传测试结果截图和码云链接
    • 套接字是一个网络连接的端点。在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 MyStack<T> implements SStack<T> {
        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<T> {
        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人负责客户端,一人负责服务器
    0. 注意责任归宿,要会通过测试证明自己没有问题

    1. 基于Java Socket实现客户端/服务器功能,传输方式用TCP
    2. 客户端让用户输入中缀表达式,然后把中缀表达式调用MyBC.java的功能转化为后缀表达式,把后缀表达式用3DES或AES算法加密后通过网络把密文发送给服务器
    3. 服务器接收到后缀表达式表达式后,进行解密(和客户端协商密钥,可以用数组保存),然后调用MyDC.java的功能计算后缀表达式的值,把结果发送给客户端
    4. 客户端显示服务器发送过来的结果
    5. 上传测试结果截图和码云链接
    • 实现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
    ",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("
    ");
                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<p.length();i++)
                    Np+=p.charAt(i);
                a=mydc.evaluate(Np);
    
                    writer.println(a);
                    writer.flush();
    
                writer.close();
                in.close();
                socket.close();
                server.close();
            }catch(Exception e) {
                System.out.println("Error."+e);
            }
            // 获取密文
    
        }
    
    }
    
    • 客户端代码
    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人负责客户端,一人负责服务器
    0. 注意责任归宿,要会通过测试证明自己没有问题

    1. 基于Java Socket实现客户端/服务器功能,传输方式用TCP
    2. 客户端让用户输入中缀表达式,然后把中缀表达式调用MyBC.java的功能转化为后缀表达式,把后缀表达式用3DES或AES算法加密通过网络把密文发送给服务器
    3. 客户端和服务器用DH算法进行3DES或AES算法的密钥交换
    4. 服务器接收到后缀表达式表达式后,进行解密,然后调用MyDC.java的功能计算后缀表达式的值,把结果发送给客户端
    5. 客户端显示服务器发送过来的结果
    6. 上传测试结果截图和码云链接
    • 执行密钥协定的标准算法是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<sb.length;i++){
                System.out.print(sb[i]+",");
            }
            SecretKeySpec k=new  SecretKeySpec(sb,"DESede");
        }
    }
    
    
    实验截图


    第五题:

    完整性校验结对编程:1人负责客户端,一人负责服务器
    0. 注意责任归宿,要会通过测试证明自己没有问题

    1. 基于Java Socket实现客户端/服务器功能,传输方式用TCP
    2. 客户端让用户输入中缀表达式,然后把中缀表达式调用MyBC.java的功能转化为后缀表达式,把后缀表达式用3DES或AES算法加密通过网络把密文和明文的MD5値发送给服务器
    3. 客户端和服务器用DH算法进行3DES或AES算法的密钥交换
    4. 服务器接收到后缀表达式表达式后,进行解密,解密后计算明文的MD5值,和客户端传来的MD5进行比较,一致则调用MyDC.java的功能计算后缀表达式的值,把结果发送给客户端
    5. 客户端显示服务器发送过来的结果
    代码如下:

    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
    ",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("
    ");
                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<p.length();i++)
                    Np+=p.charAt(i);
                a=mydc.evaluate(Np);
                String x=p;
                MessageDigest m=MessageDigest.getInstance("MD5");
                m.update(x.getBytes("UTF8"));
                byte s[ ]=m.digest( );
                String result="";
                for (int i=0; i<s.length; i++){
                    result+=Integer.toHexString((0x000000ff & s[i]) |
                            0xffffff00).substring(6);
                }
                if(!(line1.equals(result)))System.out.printf("MD5比对正确!
    ");
    
                writer.println(a);
                writer.flush();
    
                writer.close();
                in.close();
                socket.close();
                server.close();
            }catch(Exception e) {
                System.out.println("Error."+e);
            }
            // 获取密文
    
        }
    
    
    

    创建共享密钥

    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");
        }
    }
    
    
    实验截图


    码云链接

    实验总结与体会

    这次实验是java这门课程的最后一次实验,在这次实验中拿到题目的第一反应就是怎么办呀,老师也没给教程,什么都没有,好无助,好绝望呀。
    但是想想再挣扎一下吧,代码好难不会写怎么办呀,最后拿了学长的代码来用,拿来的代码也有很多问题,慢慢改到能编译了,发现运行结果不对,再继续修改到,编译运行都对了。本次实验花了两天时间,虽然时间花费了很多,但也学习到了很多知识。我认为这次实验完成的很棒。{{uploading-image-522164.png(uploading...)}}

    重温本次实验,真正的用到了结对编程。虽然代码不是自己的,重新仔细的看了一遍。明白了每段代码发挥的作用。相对与信息安全专业来说,密码是保证信息安全得重要手段,本次实验让我们体会到了编程实现密码算法对信息安全的实用性,正确性。

    实验中的一些重点问题:

    -对称加密-DES算法

  • 相关阅读:
    单例模式
    Curator Zookeeper分布式锁
    LruCache算法原理及实现
    lombok 简化java代码注解
    Oracle客户端工具出现“Cannot access NLS data files or invalid environment specified”错误的解决办法
    解决mysql Table ‘xxx’ is marked as crashed and should be repaired的问题。
    Redis 3.0 Cluster集群配置
    分布式锁的三种实现方式
    maven发布项目到私服-snapshot快照库和release发布库的区别和作用及maven常用命令
    How to Use Convolutional Neural Networks for Time Series Classification
  • 原文地址:https://www.cnblogs.com/hpl20155329/p/6925704.html
Copyright © 2020-2023  润新知