2018-2019-2 20175218 實驗五《網絡編程與安全》實驗報告

本文轉載自查看原文 2019-05-27 15:00 897

2018-2019-2 20175218 實驗五《網絡編程與安全》實驗報告

姓名	陳敬勇
班級	1752
學號	20175218
實驗序號	實驗五
實驗名稱	網絡編程與安全

一、網絡編程與安全-1

1、實驗要求

兩人一組結對編程：

參考http://www.cnblogs.com/rocedu/p/6766748.html#SECDSA
結對實現中綴表達式轉后綴表達式的功能 MyBC.java
結對實現從上面功能中獲取的表達式中實現后綴表達式求值的功能,調用MyDC.java
上傳測試代碼運行結果截圖和碼雲鏈接

2、實驗代碼

（一）MyDC.java>>核心代碼

    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;
    }

（二）MyDCTest.java>>核心代碼

        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"));
        }

（三）MyBC.java>>核心代碼

        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 + " ";
            }
        }

（四）Calculate.java>>核心代碼

        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、Calculate計算代碼運行截圖

4、碼雲鏈接

二、網絡編程與安全-2

1、實驗要求

結對編程：1人負責客戶端，一人負責服務器

注意責任歸宿，要會通過測試證明自己沒有問題
基於Java Socket實現客戶端/服務器功能，傳輸方式用TCP
客戶端讓用戶輸入中綴表達式，然后把中綴表達式調用MyBC.java的功能轉化為后綴表達式，把后綴表達式通過網絡發送給服務器
服務器接收到后綴表達式，調用MyDC.java的功能計算后綴表達式的值，把結果發送給客戶端
客戶端顯示服務器發送過來的結果
上傳測試結果截圖和碼雲鏈接

2、實驗代碼

（一）Server.java（服務器端）>>核心代碼

        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);
        }

（二）Client.java（客戶端）>>核心代碼

        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.java>>核心代碼

    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;
    }

（四）MyBC.java>>核心代碼

        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 + " ";
            }
        }

3、實驗截圖

（一）服務器端運行

（二）客戶端運行並輸入算式

（三）服務器端收到客戶提問

4、碼雲鏈接

三、網絡編程與安全-3

1、實驗要求

加密結對編程：1人負責客戶端，一人負責服務器

注意責任歸宿，要會通過測試證明自己沒有問題
基於Java Socket實現客戶端/服務器功能，傳輸方式用TCP
客戶端讓用戶輸入中綴表達式，然后把中綴表達式調用MyBC.java的功能轉化為后綴表達式，把后綴表達式用3DES或AES算法加密后通過網絡把密文發送給服務器
服務器接收到后綴表達式表達式后，進行解密（和客戶端協商密鑰，可以用數組保存），然后調用MyDC.java的功能計算后綴表達式的值，把結果發送給客戶端
客戶端顯示服務器發送過來的結果
上傳測試結果截圖和碼雲鏈接

2、實驗代碼

（一）ServerOne.java（服務器端）>>核心代碼

        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);
        }

（二）ClientOne.java（客戶端）>>核心代碼

        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);
        }

（三）Encoder.java（加解密）>>核心代碼


        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.將加密內容解密
     */


        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();
        }

（四）Skey_AES.java（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);
    }

（五）MyBC.java>>核心代碼

        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 + " ";
            }
        }

（六）MyDC.java>>核心代碼

    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;
    }

3、實驗截圖

（一）服務器端運行

（二）客戶端運行並輸入算式

（三）服務器端收到客戶提問

4、碼雲鏈接

四、網絡編程與安全-4

1、實驗要求

密鑰分發結對編程：1人負責客戶端，一人負責服務器

注意責任歸宿，要會通過測試證明自己沒有問題
基於Java Socket實現客戶端/服務器功能，傳輸方式用TCP
客戶端讓用戶輸入中綴表達式，然后把中綴表達式調用MyBC.java的功能轉化為后綴表達式，把后綴表達式用3DES或AES算法加密通過網絡把密文發送給服務器
客戶端和服務器用DH算法進行3DES或AES算法的密鑰交換
服務器接收到后綴表達式表達式后，進行解密，然后調用MyDC.java的功能計算后綴表達式的值，把結果發送給客戶端
客戶端顯示服務器發送過來的結果
上傳測試結果截圖和碼雲鏈接

2、實驗代碼

（一）Key_DH.java>>核心代碼

    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);
    }
}

（二）KeyAgree.java>>核心代碼

        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]+",");
        }

（三）ServerTwo.java（服務器端）>>核心代碼

        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);
        }

（四）ClientTwo.java（客戶端）>>核心代碼

        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);
        }

（五）MyBC.java>>核心代碼

        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 + " ";
            }
        }

（六）MyDC.java>>核心代碼

    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;
    }

（七）Encoder.java（加解密）>>核心代碼


        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.將加密內容解密
     */


        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();
        }

3、實驗截圖

（一）服務器端運行

（二）客戶端運行並輸入算式

（三）服務器端收到信息並提供解密

4、碼雲鏈接

五、網絡編程與安全-5

1、實驗要求

完整性校驗結對編程：1人負責客戶端，一人負責服務器

注意責任歸宿，要會通過測試證明自己沒有問題
基於Java Socket實現客戶端/服務器功能，傳輸方式用TCP
客戶端讓用戶輸入中綴表達式，然后把中綴表達式調用MyBC.java的功能轉化為后綴表達式，把后綴表達式用3DES或AES算法加密通過網絡把密文和明文的MD5値發送給服務器
客戶端和服務器用DH算法進行3DES或AES算法的密鑰交換
服務器接收到后綴表達式表達式后，進行解密，解密后計算明文的MD5值，和客戶端傳來的MD5進行比較，一致則調用MyDC.java的功能計算后綴表達式的值，把結果發送給客戶端
客戶端顯示服務器發送過來的結果
上傳測試結果截圖和碼雲鏈接

2、實驗代碼

（一）DigestPass.java>>核心代碼

        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);

（二）ServerThree.java（服務器端）>>核心代碼

        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);
        }

（三）ClientThree.java（客戶端）>>核心代碼

        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);
        }

（四）MyBC.java>>核心代碼

        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 + " ";
            }
        }

（五）MyDC.java>>核心代碼

    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;
    }

（六）Encoder.java（加解密）>>核心代碼


        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.將加密內容解密
     */


        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();
        }

（七）Key_DH.java>>核心代碼

    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);
    }
}

（八）KeyAgree.java>>核心代碼

        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]+",");
        }

3、實驗截圖

（一）服務器端運行

（二）客戶端運行並輸入算式

（三）服務器端收到信息並匹配MD5后解密

4、碼雲鏈接

六、實驗中遇到的問題及解決方法

問題一

在IDEA中，運行代碼時，會有找不到一些文件的情況，但是並不影響程序運行

解決方法

因為沒有影響到程序運行，並且在虛擬機里也能夠成功實現，所以就暫時沒有解決好這個問題

七、代碼托管

實驗五代碼碼雲鏈接

八、實驗感想

對於這次實驗，總的來說，綜合性比較高，在臨近學期末，來做對Java學習很有幫助。特別的是還聯系到了其他科目，讓我們在學習Java的同時，還兼顧到了其他科目，對我們有着很大的幫助。通過這次實驗，我也更加知道了結對編程的重要性，如果這個實驗只要我自己一個人做，那么肯定是非常非常困難的，幸好有搭檔幫助，這樣，最終才完成了這個實驗，希望在以后的實驗中能夠利用好伙伴的力量結伴做出更好的實驗。

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 20145326 《Java程序設計》實驗五——Java網絡編程及安全實驗報告 20145228 《Java程序設計》實驗報告五：Java網絡編程【信息安全技術】實驗報告：口令破解實驗報告三數組實驗報告 python實驗報告2 Java實驗報告（一）數組實驗報告函數實驗報告 Java實驗報告（實驗一）