码迷，mamicode.com
首页 > 其他好文 > 详细

实验五 网络编程与安全-----实验报告

时间：2019-05-26 17:57:31      阅读：234      评论：0      收藏：0      [点我收藏+]

标签：求值   移除   ocs   private   des   OLE   密码学   加密算法   encoding   

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

1.实验要求：
两人一组结对编程：

（1）参考http://www.cnblogs.com/rocedu/p/6766748.html#SECDSA ；

（2）结对实现中缀表达式转后缀表达式的功能 MyBC.java；

（3）结对实现从上面功能中获取的表达式中实现后缀表达式求值的功能,调用MyDC.java；

（4）上传测试代码运行结果截图和码云链接；

2.实验过程：
（1）MyDC代码：

import java.util.*;

public class MyDC {
    private final char ADD = '+';
    private final char SUBTRACT = '-';
    private final char MUTIPLY = '*';
    private final char DIVIDE = '/';
    private Stack<Integer> stack;

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

    public int evaluate(String expr) {
        int op1, op2, result = 0;
        String token;
        StringTokenizer tokenizer = new StringTokenizer(expr);
        while (tokenizer.hasMoreTokens()) {
            token = tokenizer.nextToken();
            if (isOperator(token)) {
                op2 = (stack.pop().intValue());
                op1 = (stack.pop().intValue());
                result = evalSingleOp(token.charAt(0), op1, op2);
                stack.push(result);
            } else {
                stack.push((Integer.parseInt(token)));
            }
        }
        return result;
    }

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

    private int evalSingleOp(char operation, int op1, int op2) {
        int result = 0;
        switch (operation) {
            case ADD:
                result = op1 + op2;
                break;
            case SUBTRACT:
                result = op1 - op2;
                break;
            case MUTIPLY:
                result = op1 * op2;
                break;
            case DIVIDE:
                result = op1 / op2;
        }
        return result;
    }
}

（2）MyDCTest代码：

import java.util.Scanner;

           public class MyDCTest  {

             public static void main (String[] args) {

             String expression, again;

             int result;

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

                   do
                       {
                         MyDC evaluator = new MyDC();
                         System.out.println ("Enter a valid postfix expression: ");
                         expression = in.nextLine();

                         result = evaluator.evaluate (expression);
                         System.out.println();System.out.println ("That expression equals " + result);

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

（3）MyBC代码：

import java.util.*;
public class MyBC {
    public String result(String s) {
        Stack<String> sta = new Stack<String>();   //新建栈
        String str = "";
        StringTokenizer t=new StringTokenizer(s);
        while (t.hasMoreTokens()){    //依次遍历元素，转为后缀表达式
            String temp;
            String c;
            c=t.nextToken();
            if (c.equals("+") || c.equals("-")) {   //遇到优先级最低的“+”、“-”，弹出“（”之前的所有元素
                while (sta.size() != 0) {
                    temp = sta.pop();
                    if (temp.equals("(")) {
                        sta.push("(");
                        break;
                    }
                    str = str + temp + " ";
                }
                sta.push(c);
            } else if (c.equals("*")|| c.equals("÷")) {   //遇到优先级高的“*”、“/”，弹出“（”之前的“*”、“/”
                while (sta.size() != 0) {
                    temp = sta.pop();
                    if (temp.equals("(") || temp.equals("+") || temp.equals("-")) {
                        sta.push(temp);
                        break;
                    } else {
                        str = str + temp + " ";
                    }
                }
                sta.push(c);
            } else if (c.equals("(")) {     //遇到“(”直接入栈
                sta.push(c);
            } else if (c.equals(")")) {     //遇到“）”，弹出“（”之前的所有元素
                while (sta.size() != 0) {
                    temp = sta.pop();
                    if (temp.equals("(")) {
                        break;
                    } else {
                        str = str + temp + " ";
                    }
                }
            } else                       //遇到数字，直接存入数组
            {
                str = str + c + " ";
            }
        }
        while (sta.size()!=0){     //弹出栈中剩余的元素
            str=str+sta.pop()+" ";
        }
        return str;
    }
}

（4）Calculate代码：

import java.util.Scanner;
public class Caculate {
    public static void main(String[] args) {
        MyDC a = new MyDC();
        MyBC b = new MyBC();
        String str;
        int result;
        System.out.println("输入算式：");
        Scanner reader = new Scanner(System.in);
        str = reader.nextLine();
        str = b.result(str);
        result = a.evaluate(str);
        System.out.println("答案为："+result);
    }
}

3.实验截图：
（1）测试MyDC截图：
技术图片

（2）计算结果截图：
技术图片

4.码云链接：
https://gitee.com/zzm-zcc/zhang_zhi_min/tree/master/%E5%AE%9E%E9%AA%8C5--1

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

1.实验要求：
结对编程：1人负责客户端，一人负责服务器；

（1）注意责任归宿，要会通过测试证明自己没有问题；

（2）基于Java Socket实现客户端/服务器功能，传输方式用TCP；

（3）客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式通过网络发送给服务器；

（4）服务器接收到后缀表达式，调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端；

（5）客户端显示服务器发送过来的结果；

（6）上传测试结果截图和码云链接；

2.实验过程：
（1）Server代码（服务器端）：

import java.io.*;
import java.net.*;
public class Server {
    public static void main(String args[]) {
        int answer;
        ServerSocket serverForClient=null;
        Socket socketOnServer=null;
        DataOutputStream out=null;
        DataInputStream  in=null;
        try { serverForClient = new ServerSocket(2010);
        }
        catch(IOException e1) {
            System.out.println(e1);
        }
        try{ System.out.println("等待客户呼叫");
            socketOnServer = serverForClient.accept(); //堵塞状态，除非有客户呼叫
            out=new DataOutputStream(socketOnServer.getOutputStream());
            in=new DataInputStream(socketOnServer.getInputStream());
            String s=in.readUTF(); // in读取信息，堵塞状态
            System.out.println("服务器收到客户的提问:"+s);
            MyDC d=new MyDC();
            answer=d.evaluate(s);
            out.writeUTF(answer+"");
            Thread.sleep(500);
        }
        catch(Exception e) {
            System.out.println("客户已断开"+e);
        }
    }
}

（2）Client代码（客户端）：

import java.io.*;
import java.net.*;
import java.lang.*;
import java.util.Scanner;

public class Client {
    public static void main(String args[]) {
        Socket mysocket;
        DataInputStream in=null;
        DataOutputStream out=null;
        try{  mysocket=new Socket("127.1.0.0",2010);
            in=new DataInputStream(mysocket.getInputStream());
            out=new DataOutputStream(mysocket.getOutputStream());
            System.out.println("请输入算式：");
            Scanner scanner=new Scanner(System.in);
            String str=scanner.nextLine();
            MyBC b=new MyBC();
            str=b.result(str);
            out.writeUTF(str);
            String  s=in.readUTF();   //in读取信息，堵塞状态
            System.out.println("客户收到服务器的回答:"+s);
            Thread.sleep(500);
        }
        catch(Exception e) {
            System.out.println("服务器已断开"+e);
        }
    }
}

注：任然需要MyDC代码与MyBC代码。
3.实验截图：
（1）服务器端截图：
技术图片

（2）客户端截图：
技术图片

4.码云链接：
https://gitee.com/zzm-zcc/zhang_zhi_min/commit/5377d0290f76f29daae2099b11936647409ae965

三、实验五 网络编程与安全-3

1.实验要求：
加密结对编程：1人负责客户端，一人负责服务器；

（1）注意责任归宿，要会通过测试证明自己没有问题；

（2）基于Java Socket实现客户端/服务器功能，传输方式用TCP；

（3）客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密后通过网络把密文发送给服务器；

（4）服务器接收到后缀表达式表达式后，进行解密（和客户端协商密钥，可以用数组保存），然后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端；

（5）客户端显示服务器发送过来的结果；

（6）上传测试结果截图和码云链接；

2.实验过程：
（1）ServerOne代码（服务器端）

import java.io.*;
import java.net.*;
public class ServerOne {
    public static void main (String args[]) throws Exception {
        /*String key="";
        int n=-1;
        byte [] a=new byte[128];
        try{  File f=new File("key1.dat");
            InputStream in = new FileInputStream(f);
            while((n=in.read(a,0,100))!=-1) {
                key=key+new String (a,0,n);
            }
            in.close();
        }
        catch(IOException e) {
            System.out.println("File read Error"+e);
        }*/
        ServerSocket serverForClient=null;
        Socket socketOnServer=null;
        DataOutputStream out=null;
        DataInputStream  in=null;
        try { serverForClient = new ServerSocket(2010);
        }
        catch(IOException e1) {
            System.out.println(e1);
        }
        try{ System.out.println("等待客户呼叫");
            socketOnServer = serverForClient.accept(); //堵塞状态，除非有客户呼叫
            out=new DataOutputStream(socketOnServer.getOutputStream());
            in=new DataInputStream(socketOnServer.getInputStream());
            String key = in.readUTF();
            String s=in.readUTF(); // in读取信息，堵塞状态
            System.out.println("服务器收到的信息:"+s);
            String clear=Encoder.AESDncode(key,s);
            MyDC d=new MyDC();
            System.out.println("服务器收到客户的提问:"+clear);
            int answer=d.evaluate(clear);
            out.writeUTF(answer+"");
            Thread.sleep(500);
        }
        catch(Exception e) {
            System.out.println("客户已断开"+e);
        }
    }
}

（2） ClientOne代码（客户端）

import java.io.*;
import java.net.*;
import java.lang.*;
import java.util.Scanner;

public class ClientOne {
    public static void main(String args[]) throws Exception {
        String key = "";
        int n = -1;
        byte[] a = new byte[128];
        try {
            File f = new File("key1.dat");
            InputStream in = new FileInputStream(f);
            while ((n = in.read(a, 0, 100)) != -1) {
                key = key + new String(a, 0, n);
            }
            in.close();
        } catch (IOException e) {
            System.out.println("File read Error" + e);
        }
        Socket mysocket;
        DataInputStream in = null;
        DataOutputStream out = null;
        System.out.println("请输入算式：");
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();//输入算式
        MyBC b = new MyBC();
        str = b.result(str);
        String secret=Encoder.AESEncode(key,str);//客户端进行加密

        try {
            mysocket = new Socket("127.1.0.0", 2010);
            in = new DataInputStream(mysocket.getInputStream());
            out = new DataOutputStream(mysocket.getOutputStream());
            out.writeUTF(key);
            out.writeUTF(secret);
            String s = in.readUTF();   //in读取信息，堵塞状态
            System.out.println("客户收到服务器的回答:" + s);
            Thread.sleep(500);
        } catch (Exception e) {
            System.out.println("服务器已断开" + e);
        }
    }
}

（3） Encoder代码（加解密代码）

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;
import java.util.Scanner;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/*
 * AES对称加密和解密
 */
public class Encoder {
    /*
     * 加密
     * 1.构造密钥生成器
     * 2.根据ecnodeRules规则初始化密钥生成器
     * 3.产生密钥
     * 4.创建和初始化密码器
     * 5.内容加密
     * 6.返回字符串
     */
    public static String AESEncode(String encodeRules,String content){
        try {
            //1.构造密钥生成器，指定为AES算法,不区分大小写
            KeyGenerator keygen=KeyGenerator.getInstance("AES");
            //2.根据ecnodeRules规则初始化密钥生成器
            //生成一个128位的随机源,根据传入的字节数组
            keygen.init(128, new SecureRandom(encodeRules.getBytes()));
            //3.产生原始对称密钥
            SecretKey original_key=keygen.generateKey();
            //4.获得原始对称密钥的字节数组
            byte [] raw=original_key.getEncoded();
            //5.根据字节数组生成AES密钥
            SecretKey key=new SecretKeySpec(raw, "AES");
            //6.根据指定算法AES自成密码器
            Cipher cipher=Cipher.getInstance("AES");
            //7.初始化密码器，第一个参数为加密(Encrypt_mode)或者解密解密(Decrypt_mode)操作，第二个参数为使用的KEY
            cipher.init(Cipher.ENCRYPT_MODE, key);
            //8.获取加密内容的字节数组(这里要设置为utf-8)不然内容中如果有中文和英文混合中文就会解密为乱码
            byte [] byte_encode=content.getBytes("utf-8");
            //9.根据密码器的初始化方式--加密：将数据加密
            byte [] byte_AES=cipher.doFinal(byte_encode);
            //10.将加密后的数据转换为字符串
            //这里用Base64Encoder中会找不到包
            //解决办法：
            //在项目的Build path中先移除JRE System Library，再添加库JRE System Library，重新编译后就一切正常了。
            String AES_encode=new String(new BASE64Encoder().encode(byte_AES));
            //11.将字符串返回
            return AES_encode;
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        //如果有错就返加nulll
        return null;
    }
    /*
     * 解密
     * 解密过程：
     * 1.同加密1-4步
     * 2.将加密后的字符串反纺成byte[]数组
     * 3.将加密内容解密
     */
    public static String AESDncode(String encodeRules,String content){
        try {
            //1.构造密钥生成器，指定为AES算法,不区分大小写
            KeyGenerator keygen=KeyGenerator.getInstance("AES");
            //2.根据ecnodeRules规则初始化密钥生成器
            //生成一个128位的随机源,根据传入的字节数组
            keygen.init(128, new SecureRandom(encodeRules.getBytes()));
            //3.产生原始对称密钥
            SecretKey original_key=keygen.generateKey();
            //4.获得原始对称密钥的字节数组
            byte [] raw=original_key.getEncoded();
            //5.根据字节数组生成AES密钥
            SecretKey key=new SecretKeySpec(raw, "AES");
            //6.根据指定算法AES自成密码器
            Cipher cipher=Cipher.getInstance("AES");
            //7.初始化密码器，第一个参数为加密(Encrypt_mode)或者解密(Decrypt_mode)操作，第二个参数为使用的KEY
            cipher.init(Cipher.DECRYPT_MODE, key);
            //8.将加密并编码后的内容解码成字节数组
            byte [] byte_content= new BASE64Decoder().decodeBuffer(content);
            /*
             * 解密
             */
            byte [] byte_decode=cipher.doFinal(byte_content);
            String AES_decode=new String(byte_decode,"utf-8");
            return AES_decode;
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        }

        //如果有错就返加nulll
        return null;
    }

}

（4）Skey_AES代码（AES调用代码）

import java.io.*;
import javax.crypto.*;
public class Skey_AES{
    public static void main(String args[]) throws Exception{
        KeyGenerator kg=KeyGenerator.getInstance("AES");
        kg.init(128);
        SecretKey k=kg.generateKey( );
        FileOutputStream  f=new FileOutputStream("key1.dat");
        ObjectOutputStream b=new  ObjectOutputStream(f);
        b.writeObject(k);
    }
}

注： Encoder代码和Skey_AES代码为参考网上的代码，在运行ServerOne代码和ClientOne代码前应先运行Skey_AES代码，任然需要MyDC代码与MyBC代码。

3.实验截图：
（1）服务器端截图：
技术图片

（2）客户端截图：
技术图片

4.码云链接：
https://gitee.com/zzm-zcc/zhang_zhi_min/commit/c3d15a343490157a6c1eda6e6c102c2590fa526b

四、实验五 网络编程与安全-4

1.实验要求：
密钥分发结对编程：1人负责客户端，一人负责服务器；

（1）注意责任归宿，要会通过测试证明自己没有问题；

（2）基于Java Socket实现客户端/服务器功能，传输方式用TCP；

（3）客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密通过网络把密文发送给服务器；

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

（5）服务器接收到后缀表达式表达式后，进行解密，然后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端；

（6）客户端显示服务器发送过来的结果；

（7）上传测试结果截图和码云链接；

2.实验过程：
（1）Key_DH代码：

import java.io.*;
import java.math.*;
import java.security.*;
import java.security.spec.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import javax.crypto.interfaces.*;

public class Key_DH{
    //三个静态变量的定义从
// C:\j2sdk-1_4_0-doc\docs\guide\security\jce\JCERefGuide.html
// 拷贝而来
// The 1024 bit Diffie-Hellman modulus values used by SKIP
    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);
    }
}

（2）KeyAgree代码：

import java.security.PublicKey;
import java.security.PrivateKey;
import java.io.*;
import javax.crypto.KeyAgreement;
import javax.crypto.spec.*;

public class KeyAgree{
    public static void main(String args[ ]) throws Exception{
        File file=new File("Sharekey.dat");
        // 读取对方的DH公钥
        FileInputStream f1=new FileInputStream("Apub.dat");
        ObjectInputStream b1=new ObjectInputStream(f1);
        PublicKey  pbk=(PublicKey)b1.readObject( );
        //读取自己的DH私钥
        FileInputStream f2=new FileInputStream("Bpri.dat");
        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]+",");
        }
        OutputStream out=new FileOutputStream(file);
        out.write(sb);
        out.close();
        SecretKeySpec k=new  SecretKeySpec(sb,"AES");
    }
}

（3）ServerTwo代码（服务器端）：

import java.io.*;
import java.net.*;
public class ServerTwo {
    public static void main(String args[]) throws  IOException{
        String sharekey="";
        int n=-1;
        byte [] a=new byte[128];
        try{  File f=new File("Sharekey.dat");
            InputStream in = new FileInputStream(f);
            while((n=in.read(a,0,100))!=-1) {
                sharekey=sharekey+new String (a,0,n);
            }
            in.close();
        }
        catch(IOException e) {
            System.out.println("File read Error"+e);
        }

        ServerSocket serverForClient=null;
        Socket socketOnServer=null;
        DataOutputStream out=null;
        DataInputStream  in=null;
        try { serverForClient = new ServerSocket(2010);
        }
        catch(IOException e1) {
            System.out.println(e1);
        }
        try{ System.out.println("等待客户呼叫");
            socketOnServer = serverForClient.accept(); //堵塞状态，除非有客户呼叫
            out=new DataOutputStream(socketOnServer.getOutputStream());
            in=new DataInputStream(socketOnServer.getInputStream());
            String keyone =in.readUTF();//读取被DH算法加密的密钥
            String truekey = Encoder.AESDncode(sharekey,keyone);//使用共享密钥对被加密的原密钥解密。
            String secret =in.readUTF(); // in读取信息，堵塞状态
            System.out.println("服务器收到的信息:"+secret);
            String clear = Encoder.AESDncode(truekey,secret);//使用原密钥解密表达式
            MyDC d=new MyDC();
            int answer=d.evaluate(clear);
            out.writeUTF(answer+"");
            System.out.println("服务器提供的解密:"+clear);


            Thread.sleep(500);
        }
        catch(Exception e) {
            System.out.println("客户已断开"+e);
        }
    }
}

（4）ClientTwo代码（客户端）：

import java.io.*;
import java.net.*;
import java.util.Scanner;

public class ClientTwo {
    public static void main(String args[]) throws Exception {
        String key1="";
        int n1=-1;
        byte [] a1=new byte[128];
        try{  File f=new File("key1.dat");
            InputStream in = new FileInputStream(f);
            while((n1=in.read(a1,0,100))!=-1) {
                key1=key1+new String (a1,0,n1);
            }
            in.close();
        }
        catch(IOException e) {
            System.out.println("File read Error"+e);
        }
        String sharekey="";
        int n=-1;
        byte [] a=new byte[128];
        try{  File f=new File("Sharekey.dat");
            InputStream in = new FileInputStream(f);
            while((n=in.read(a,0,100))!=-1) {
                sharekey=sharekey+new String (a,0,n);
            }
            in.close();
        }
        catch(IOException e) {
            System.out.println("File read Error"+e);
        }
        Socket mysocket;
        DataInputStream in=null;
        DataOutputStream out=null;
        System.out.println("请输入算式：");
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();//输入算式
        MyBC b=new MyBC();
        str=b.result(str);
        String secret=Encoder.AESEncode(key1, str);//客户端对表达式进行加密
        key1 = Encoder.AESEncode(sharekey,key1);//客户端对密钥进行DH加密
        try{  mysocket=new Socket("127.1.0.0",2010);
            in=new DataInputStream(mysocket.getInputStream());
            out=new DataOutputStream(mysocket.getOutputStream());
            out.writeUTF(key1);
            out.writeUTF(secret);
            String  s=in.readUTF();   //in读取信息，堵塞状态
            System.out.println("客户收到服务器的回答:"+s);
            Thread.sleep(50000);
        }
        catch(Exception e) {
            System.out.println("服务器已断开"+e);
        }
    }
}

注：任然需要MyDC代码与MyBC代码和Encoder代码，在运行ServerTwo代码和ClientTwo代码前应先运行Key_DH代码、再运行KeyAgree代码、最后运行ServerTwo代码和ClientTwo代码。

3.实验截图：
（1）运行Key_DH代码的截图（需要通过命令行）：
技术图片
技术图片

（2）运行KeyAgree代码的截图：
技术图片

（3）服务器端运行截图：
技术图片

（4）客户端运行截图：
技术图片

4.码云链接：
https://gitee.com/zzm-zcc/zhang_zhi_min/commit/bba1a88b5ede8025aeb19f22c4254300c2cee901

五、实验五 网络编程与安全-5

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

（1）注意责任归宿，要会通过测试证明自己没有问题；

（2）基于Java Socket实现客户端/服务器功能，传输方式用TCP；

（3）客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密通过网络把密文和明文的MD5値发送给服务器；

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

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

（6）客户端显示服务器发送过来的结果；

（7）上传测试结果截图和码云链接；

2.实验过程：
（1）DigestPass代码：

import java.security.*;
public class DigestPass{
    static String MD5(String str) throws Exception{
        MessageDigest m=MessageDigest.getInstance("MD5");
        m.update(str.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);
        }
        return result;
    }
}

（2）ServerThree代码（服务器端）：

import java.io.*;
import java.net.*;
public class ServerThree {
    public static void main(String args[]) throws  IOException{
        String sharekey="";
        int n=-1;
        byte [] a=new byte[128];
        try{  File f=new File("Sharekey.dat");
            InputStream in = new FileInputStream(f);
            while((n=in.read(a,0,100))!=-1) {
                sharekey=sharekey+new String (a,0,n);
            }
            in.close();
        }
        catch(IOException e) {
            System.out.println("File read Error"+e);
        }

        ServerSocket serverForClient=null;
        Socket socketOnServer=null;
        DataOutputStream out=null;
        DataInputStream  in=null;
        try { serverForClient = new ServerSocket(2010);
        }
        catch(IOException e1) {
            System.out.println(e1);
        }
        try{ System.out.println("等待客户呼叫");
            socketOnServer = serverForClient.accept(); //堵塞状态，除非有客户呼叫
            out=new DataOutputStream(socketOnServer.getOutputStream());
            in=new DataInputStream(socketOnServer.getInputStream());
            String keyone =in.readUTF();//读取被DH算法加密的密钥
            String truekey = Encoder.AESDncode(sharekey,keyone);//使用共享密钥对被加密的原密钥解密。
            String secret =in.readUTF(); // in读取信息，堵塞状态
            System.out.println("服务器收到的信息:"+secret);
            String mdClient=in.readUTF();
            System.out.println("客户端提供的MD5为:"+ mdClient);
            String clear = Encoder.AESDncode(truekey,secret);//使用原密钥解密表达式
            MyDC d=new MyDC();
            int answer=d.evaluate(clear);
            if((mdClient.equals(DigestPass.MD5(clear)))==true) {//判断MD5值是否相等，若相等，则返回答案
                System.out.println("MD5值匹配");
                System.out.println("服务器提供的解密:" + clear);
                System.out.println("服务器解出密文的MD5为:" + DigestPass.MD5(clear));
                out.writeUTF(answer + "");
            }
            Thread.sleep(500);
        }
        catch(Exception e) {
            System.out.println("客户已断开"+e);
        }
    }
}

（3）ClientThree代码（客户端）：

import java.io.*;
import java.net.*;
import java.util.Scanner;

public class ClientThree {
    public static void main(String args[]) throws Exception {
        String key1="";
        int n1=-1;
        byte [] a1=new byte[128];
        try{  File f=new File("key1.dat");
            InputStream in = new FileInputStream(f);
            while((n1=in.read(a1,0,100))!=-1) {
                key1=key1+new String (a1,0,n1);
            }
            in.close();
        }
        catch(IOException e) {
            System.out.println("File read Error"+e);
        }
        String sharekey="";
        int n=-1;
        byte [] a=new byte[128];
        try{  File f=new File("Sharekey.dat");
            InputStream in = new FileInputStream(f);
            while((n=in.read(a,0,100))!=-1) {
                sharekey=sharekey+new String (a,0,n);
            }
            in.close();
        }
        catch(IOException e) {
            System.out.println("File read Error"+e);
        }
        Socket mysocket;
        DataInputStream in=null;
        DataOutputStream out=null;
        System.out.println("请输入算式：");
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();//输入算式
        MyBC b=new MyBC();
        str=b.result(str);
        String secret=Encoder.AESEncode(key1, str);//客户端对表达式进行加密
        String md=DigestPass.MD5(str);//客户端提供的MD5
        key1 = Encoder.AESEncode(sharekey,key1);//客户端对密钥进行DH加密
        try{  mysocket=new Socket("127.1.0.0",2010);
            in=new DataInputStream(mysocket.getInputStream());
            out=new DataOutputStream(mysocket.getOutputStream());
            out.writeUTF(key1);
            out.writeUTF(secret);
            out.writeUTF(md);
            String  s=in.readUTF();   //in读取信息，堵塞状态
            System.out.println("客户收到服务器的回答:"+s);
            Thread.sleep(50000);
        }
        catch(Exception e) {
            System.out.println("服务器已断开"+e);
        }
    }
}

注：任然需要MyDC代码、MyBC代码、Encoder代码、Key_DH代码和KeyAgree代码，在运行ServerThree代码和ClientThree代码前应先运行Key_DH代码（与实验五 网络编程与安全-4中相同）、再运行KeyAgree代码、最后运行ServerThree代码和ClientThree代码。

3.实验截图：
（1）服务器端截图：
技术图片

（2）客户端截图：
技术图片

4.码云链接：
https://gitee.com/zzm-zcc/zhang_zhi_min/commit/33995dbe0838b1eebdceff7f6bb1b8a6b86e3922

六、实验感想：

通过此次实验，充分了解了各种加密算法的结构与思想，也加深了密码学的部分知识，拓展了知识面。

实验五 网络编程与安全-----实验报告

标签：求值   移除   ocs   private   des   OLE   密码学   加密算法   encoding   

原文地址：https://www.cnblogs.com/zzmzcc/p/10925810.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！