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

任务一

题目：①编写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)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");

    }

}

任务五

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

• 可以使用Java计算指定字符串的消息摘要。java.security包中的MessageDigest类提供了计算消息摘要的方法，首先生成对象，执行其update()方法可以将原始数据传递给该对象，然后执行其digest( )方法即可得到消息摘要。

• 在客户端添加如下代码：

            // 将客户端明文的Hash值传送给服务器

            String x = postfix;

            MessageDigest m2 = MessageDigest.getInstance("MD5");

            m2.update(x.getBytes());

            byte a[] = m2.digest();

            String result = "";

            for (int i = 0; i < a.length; i++) {

                result += Integer.toHexString((0x000000ff & a[i]) | 0xffffff00).substring(6);

            }

            System.out.println(result);

            out.println(result);//通过网络将明文的Hash函数值传送到服务器

            str = in.readLine();// 从网络输入流读取结果

            System.out.println("从服务器接收到的结果为：" + str); // 输出服务器返回的结果

• 在服务器添加如下代码：

            // 使用Hash函数检测明文完整性

            String aline3 = in.readLine();

            String x = p;

            MessageDigest m2 = MessageDigest.getInstance("MD5");//使用MD5算法返回实现指定摘要算法的 MessageDigest对象

            m2.update(x.getBytes());

            byte a[] = m2.digest();

            String result = "";

            for (int i = 0; i < a.length; i++) {

                result += Integer.toHexString((0x000000ff & a[i]) | 0xffffff00).substring(6);

            }

            System.out.println(result);

            if (aline3.equals(result)) {

                System.out.println("匹配成功");

            }

任务六

客户端功能用Android实现

• 由于服务端通常运行在有固定IP的服务器上，所以可以直接将PC作为服务器。

• 下面的代码显示了如何运用Socket类建立，实现连接到指定IP端口并获取服务端发送的数据的功能。该程序创建连接后，将接收到的数据显示在文本框中。

• 建立客户端程序如下：

import android.support.v7.app.AppCompatActivity;

import android.os.Bundle;

import android.util.Log;

import android.view.View;

import android.widget.Button;

import android.widget.EditText;

import android.widget.TextView;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.net.Socket;

import java.net.UnknownHostException;

public class MainActivity extends AppCompatActivity {

    private TextView text1;

    private Button but1;

    private EditText edit1;

    private final String DEBUG_TAG="mySocketAct";

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        text1 = (TextView)findViewById(R.id.text1);

        but1 = (Button)findViewById(R.id.but1);

        edit1 = (EditText) findViewById(R.id.edit);

        but1.setOnClickListener(new Button.OnClickListener()

        {

            @Override

                public void onClick(View v){

                Socket socket = null;

                String mesg = edit1.getText().toString()+"\r\n";

                edit1.setText("");

                Log.e("dddd","set id");

                try{

                    socket = new Socket("127.0.0.1", 4421);

                    PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())),true);

                    out.println(mesg);

                    BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

                    String mstr = br.readLine();

                    if(mstr!=null){

                        text1.setText(mstr);

                    }else{

                        text1.setText("数据错误");

                    }

                    out.close();

                    br.close();

                    socket.close();

                }catch (UnknownHostException e){

                    e.printStackTrace();

                }catch (IOException e){

                    e.printStackTrace();

                }catch (Exception e){

                    Log.e(DEBUG_TAG, e.toString());

                }

            }

        });

    }

}

• 注意：由于使用了网络连接，还需要在Mainfest文件中添加网络访问权限，如下所示：

<uses-permission android:name="android.permission.INTERNET"/>

• 再在客户端添加中缀表达式转为后缀表达式和加密的部分即可完成

实验体会与总结

感触挺多的，这次实验我是真不会做，看懂都有点困难。

差距确实拉开的挺大的

我对程序实在不感冒，能做的也就这些，希望您可理解

这篇博客整体参考5303这位同学的博客，实话实说

参考资料

• 娄老师的博客：Java密码学算法
• 常用加密算法的Java实现(一)
• JAVA的网络编程
• 简单的java socket 示例