Java 网络安全治理 java和网络安全

转载

我心依旧 2024-01-25 23:18:37

文章标签 Java 网络安全治理后缀表达式客户端字符串 文章分类 Java 后端开发

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

改变

修改了之前仅仅是贴了图片，连代码都没粘的状态。不过这篇博客我只能做到写好，毕竟里面的东西我说我做得出来我自己都不信。。

代码贴的·，这个真的不会做实话实说

网络编程与安全实验要求

任务一：

编写MyBC.java实现中缀表达式转后缀表达式的功能
编写MyDC.java实现从上面功能中获取的表达式中实现后缀表达式求值的功能

任务二：

结对编程：一人负责客户端，另一人负责服务器
注意责任归宿，要会通过测试证明自己没有问题
基于Java Socket实现客户端/服务器功能，传输方式用TCP
客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式通过网络发送给服务器
服务器接收到后缀表达式，调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
客户端显示服务器发送过来的结果

任务三：

客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密后通过网络把密文发送给服务器
服务器接收到后缀表达式表达式后，进行解密（和客户端协商密钥，可以用数组保存），然后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
其他要求同任务二

任务四：

客户端和服务器用DH算法进行3DES或AES算法的密钥交换
其他要求同任务三

任务五：

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

任务六：

客户端功能用Android实现

实验成果

任务一

题目：①编写MyBC.java实现中缀表达式转后缀表达式的功能；②编写MyDC.java实现从上面功能中获取的表达式中实现后缀表达式求值的功能

将运算符写在两个操作数中间的表达式，称为“中缀表达式”，如1+2*(3-4)+5。在中缀表达式中，运算符具有不同的优先级，圆括号用于改变运算符的运算次序，所以求值过程不能直接按照从左到右的顺序进行。
将运算符写在两个操作数之后的表达式称为“后缀表达式”，如上面的中缀表达式可转换为后缀表达式1 2 3 4 - * + 5 +。后缀表达式中没有括号，而且运算符没有优先级。后缀表达式的求值过程能够严格地从左到右按顺序进行，符合运算器的求值规律。
表达式求值算法分两步进行：①中缀转后缀；②求后缀表达式的值。

①中缀转后缀的算法可描述为：

设置一个运算符栈，设置一个后缀表达式字符串；
从左到右依次对中缀表达式中的每个字符ch分别进行以下处理，直至表达式结束：

若ch是左括号‘（’，将其入栈；
若ch是数字，将其后连续若干数字添加到后缀表达式字符串之后，并添加空格作为分隔符；
若ch是运算符，先将栈顶若干优先级高于ch的运算符出栈，添加到后缀表达式字符串之后，再将ch入栈。当‘（’运算符在栈中时，它的优先级最低。
若ch是‘）’，则若干运算符全部出栈，直到出栈的是左括号，一对括号匹配。

若表达式结束，将栈中运算符全部出栈，添加到后缀表达式字符串之后。

中缀转后缀的代码为：

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

②后缀表达式求值的算法可描述为（参考：娄老师的博客）：

设置一个操作数栈，从左向右依次对后缀表达式字符串中的每个字符ch进行处理；
若ch是数字，先将其后连续若干数字转化为整数，再将该整数入栈；
若ch是运算符，出栈两个值进行运算，运算结果再入栈；
重复以上步骤，直至后缀表达式结束，栈中最后一个数字就是所求表达式的值。

后缀表达式求值的代码为：

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

最后添加测试代码即可：

public class NewMyDCTester {
    public static void main(String [] args) {
        String expression;
        int result;
        try
        {
            Scanner in = new Scanner(System.in);
            NewMyDC evaluator = new NewMyDC();
            System.out.println ("Enter a valid postfix expression: ");
            expression = in.nextLine();
            String postfix = MyBC.toPostfix(expression);
            System.out.println ("The postfix expression is :" + postfix);
            result = evaluator.value (postfix);
            System.out.println ("That expression equals :" + result);
        }
        catch (Exception IOException)
        {
            System.out.println("Input exception reported");
        }
    }
}

任务二

题目：①结对编程：一人负责客户端，另一人负责服务器；②注意责任归宿，要会通过测试证明自己没有问题；③基于Java Socket实现客户端/服务器功能，传输方式用TCP；④客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式通过网络发送给服务器；⑤服务器接收到后缀表达式，调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端；⑥客户端显示服务器发送过来的结果

java.net.Socket与java.net.ServerSocket

『java.net.Socket』：

套接字是一个网络连接的端点。在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。

以下代码创建了一个客户端：

// 1、创建客户端Socket，指定服务器地址和端口
            Socket socket=new Socket("127.0.0.1",5200);
            //Socket socket = new Socket("192.168.1.115", 5209);
            System.out.println("客户端启动成功");
            // 2、获取输出流，向服务器端发送信息
            // 向本机的5200端口发出客户请求
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            // 由系统标准输入设备构造BufferedReader对象
            PrintWriter write = new PrintWriter(socket.getOutputStream());
            // 由Socket对象得到输出流，并构造PrintWriter对象
            //3、获取输入流，并读取服务器端的响应信息
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            // 由Socket对象得到输入流，并构造相应的BufferedReader对象
            String readline;
            readline = br.readLine(); // 从系统标准输入读入一字符串
            while (!readline.equals("end")) {
                // 若从标准输入读入的字符串为 "end"则停止循环
                write.println(readline);
                // 将从系统标准输入读入的字符串输出到Server
                write.flush();
                // 刷新输出流，使Server马上收到该字符串
                System.out.println("Client:" + readline);
                // 在系统标准输出上打印读入的字符串
                System.out.println("Server:" + in.readLine());
                // 从Server读入一字符串，并打印到标准输出上
                readline = br.readLine(); // 从系统标准输入读入一字符串
            } // 继续循环
            //4、关闭资源
            write.close(); // 关闭Socket输出流
            in.close(); // 关闭Socket输入流
            socket.close(); // 关闭Socket

『java.net.ServerSocket』：

ServerSocket是服务器套接字的一个实现。ServerSocket和Socket不同，服务器套接字的角色是，等待来自客户端的连接请求。一旦服务器套接字获得了一个连接请求，它就会创建一个Socket实例，以处理和客户端的通信。

以下代码创建了一个服务器：（代码贴的）

//搭建服务器端
    public static void main(String[] args) throws IOException{
        SocketService socketService = new SocketService();
        //1、a)创建一个服务器端Socket，即SocketService
        socketService.oneServer();
    }
    public  void oneServer(){
        try{
            ServerSocket server=null;
            try{
                server=new ServerSocket(5200);
                //b)指定绑定的端口，并监听此端口。
                System.out.println("服务器启动成功");
                //创建一个ServerSocket在端口5209监听客户请求
            }catch(Exception e) {
                System.out.println("没有启动监听："+e);
                //出错，打印出错信息
            }
            Socket socket=null;
            try{
                socket=server.accept();
                //2、调用accept()方法开始监听，等待客户端的连接
                //使用accept()阻塞等待客户请求，有客户
                //请求到来则产生一个Socket对象，并继续执行
            }catch(Exception e) {
                System.out.println("Error."+e);
                //出错，打印出错信息
            }
            //3、获取输入流，并读取客户端信息
            String line;
            BufferedReader in=new BufferedReader(new InputStreamReader(socket.getInputStream()));
            //由Socket对象得到输入流，并构造相应的BufferedReader对象
            PrintWriter writer=new PrintWriter(socket.getOutputStream());
            //由Socket对象得到输出流，并构造PrintWriter对象
            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
            //由系统标准输入设备构造BufferedReader对象
            System.out.println("Client:"+in.readLine());
            //在标准输出上打印从客户端读入的字符串
            line=br.readLine();
            //从标准输入读入一字符串
            //4、获取输出流，响应客户端的请求
            while(!line.equals("end")){
                //如果该字符串为 "bye"，则停止循环
                writer.println(line);
                //向客户端输出该字符串
                writer.flush();
                //刷新输出流，使Client马上收到该字符串
                System.out.println("Server:"+line);
                //在系统标准输出上打印读入的字符串
                System.out.println("Client:"+in.readLine());
                //从Client读入一字符串，并打印到标准输出上
                line=br.readLine();
                //从系统标准输入读入一字符串
            } //继续循环
            //5、关闭资源
            writer.close(); //关闭Socket输出流
            in.close(); //关闭Socket输入流
            socket.close(); //关闭Socket
            server.close(); //关闭ServerSocket
        }catch(Exception e) {//出错，打印出错信息
            System.out.println("Error."+e);
        }
    }

创建了客户端和服务器，调用任务一中的中缀表达式转后缀表达式与后缀表达式求值的方法即可。运行结果如下：

任务三

题目：①客户端让用户输入中缀表达式，然后把中缀表达式调用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();

任务四

题目：客户端和服务器用DH算法进行3DES或AES算法的密钥交换。其他要求同任务三。

执行密钥协定的标准算法是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)

改变

修改了之前仅仅是贴了图片，连代码都没粘的状态。不过这篇博客我只能做到写好，毕竟里面的东西我说我做得出来我自己都不信。。

代码贴的·，这个真的不会做实话实说

网络编程与安全实验要求

任务一：

编写MyBC.java实现中缀表达式转后缀表达式的功能
编写MyDC.java实现从上面功能中获取的表达式中实现后缀表达式求值的功能

任务二：

结对编程：一人负责客户端，另一人负责服务器
注意责任归宿，要会通过测试证明自己没有问题
基于Java Socket实现客户端/服务器功能，传输方式用TCP
客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式通过网络发送给服务器
服务器接收到后缀表达式，调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
客户端显示服务器发送过来的结果

任务三：

客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密后通过网络把密文发送给服务器
服务器接收到后缀表达式表达式后，进行解密（和客户端协商密钥，可以用数组保存），然后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
其他要求同任务二

任务四：

客户端和服务器用DH算法进行3DES或AES算法的密钥交换
其他要求同任务三

任务五：

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

任务六：

客户端功能用Android实现

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：vue IOS切换视频会黑屏 vue闪退视频没有了

下一篇：vba程序转java vba转vb工具

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯