20175333曹雅坤實驗五 網絡編程與安全

20175333曹雅坤實驗五 網絡編程與安全

實驗內容及步驟

1、網絡編程與安全-1

一、實驗要求
兩人一組結對編程：

• 參考http://www.cnblogs.com/rocedu/p/6766748.html#SECDSA
• 結對實現中綴表達式轉後綴表達式的功能 MyBC.java
• 結對實現從上面功能中獲取的表達式中實現後綴表達式求值的功能,調用MyDC.java
• 上傳測試代碼運行結果截圖和碼雲連接
  2.實驗方法
• 由中綴式求得後綴式可使用棧，僞代碼以下：
  設立一個棧，存放運算符，首先棧爲空；
  從左到右掃描中綴式，若遇到操做數，直接輸出，並輸出一個空格做爲兩個操做數的分隔符；
  若遇到運算符，則與棧頂比較，比棧頂級別高則進棧，不然退出棧頂元素並輸出，而後輸出一個空格做分隔符；
  若遇到左括號，進棧；若遇到右括號，則一直退棧輸出，直到退到左括號止。
  當棧變成空時，輸出的結果即爲後綴表達式。
• 後綴表達式求值的僞代碼以下：
  設置一個操做數棧，開始棧爲空；
  從左到右掃描後綴表達式，遇操做數，進棧；
  若遇運算符，則從棧中退出兩個元素，先退出的放到運算符的右邊，後退出的放到運算符左邊，運算後的結果再進棧，直到後綴表達式掃描完畢。
  重複以上步驟，直至後綴表達式結束，棧中最後一個數字就是所求表達式的值。
• 實驗代碼：
  MyDC：

import javax.xml.bind.annotation.XmlType;
import java.lang.Integer;
import java.util.StringTokenizer;
import java.util.Stack;

public class MyDC
{
    /** constant for addition symbol */
    private final String ADD="+";
    /** constant for subtraction symbol */
    private final String SUBTRACT="-";
    /** constant for multiplication symbol */
    private final String MULTIPLY="*";
    /** constant for division symbol */
    private final String DIVIDE="/";
    /** the stack */
    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();

            //若是是運算符，調用isOperator
            if (isOperator(token)) {

                //從棧中彈出操做數2
                op2 = stack.pop();
                //從棧中彈出操做數1
                op1 = stack.pop();
                //根據運算符和兩個操做數調用evalSingleOp計算result;
                result = evalSingleOp(token, op1, op2);
                //計算result入棧;
                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(String operation,int op1,int op2)
    {
        int result=0;

        switch(operation)
        {
            case ADD:
                result=op1+op2;
                break;
            case SUBTRACT:
                result=op1-op2;
                break;
            case MULTIPLY:
                result=op1*op2;
                break;
            case DIVIDE:
                result=op1/op2;
            default:
                break;
        }

        return result;
    }
}

MyBC:

import java.util.StringTokenizer;

import java.util.Stack;

public class MyBC{

    private Stack<Character> stack1;

    public char Precede(char a,char b)

    {

        if(a=='#')

            if(b!='#')

                return '<';

            else

                return '=';

        if(a==')')

            return '>';

        if(a=='(')

            if(b!=')')

                return '<';

            else

                return '=';

        if(a=='/'||a=='*')

            if(b!='(')

                return '>';

            else

                return '<';

        if(a=='-'||a=='+')

            if(b!='*'&&b!='/'&&b!='(')

                return '>';

            else

                return '<';

        return '>';

    }

    public MyBC() {

        stack1 = new Stack<Character>();

        stack1.push('#');

    }

    public String turn(String expr) {

        int  result = 0;

        String token;

        char topelem,optr;

        char[] exper1 = new char[100];

        int i = 0;



        StringTokenizer tokenizer = new StringTokenizer (expr);

          /*while (tokenizer.hasMoreTokens()) {

              System.out.println(tokenizer.nextToken());

          }*/

        while (tokenizer.hasMoreTokens())

        {

            token = tokenizer.nextToken();



            //若是是運算符，調用isOperator



            if (isOperator(token))

            {

                //調用Precede比較優先級



                topelem=stack1.peek();



                optr = token.charAt(0);



                if(Precede(topelem,optr)=='<')

                {



                    stack1.push(optr);



                }

                else if(Precede(topelem,optr)=='=')

                {

                      /*if(optr==')'){

                          optr=stack1.pop();

                          while(optr!='('){

                              exper1[i++]=optr;

                              exper1[i++]=' ';

                              optr=stack1.pop();

                          }

                      }*/

                    optr =stack1.pop();

                    exper1[i++] = optr;

                    exper1[i++] = ' ';

                }

                else if(Precede(topelem,optr)=='>')

                {

                    optr =stack1.pop();

                    //從運算符棧中退出棧頂元素並放入後綴表達式exper1

                    exper1[i++] = optr;

                    exper1[i++] = ' ';

                }

            }//若是是(則入棧

            else if(token.equals("(")) {

                optr = token.charAt(0);

                stack1.push(optr);

            }//若是是）則退棧直到出現第一個（

            else if(token.equals(")")) {

                optr = stack1.pop();

                while(optr!='(')

                {

                    exper1[i++] = optr;

                    exper1[i++] = ' ';

                    optr = stack1.pop();

                }

            }

            else//若是是操做數

            //操做數放入後綴表達式exper1

            {

                optr = token.charAt(0);

                //System.out.println(optr);

                exper1[i++]=optr;

                exper1[i++] = ' ';



            }

        }

        while(!stack1.isEmpty())

        {

            optr = stack1.pop();

            if(optr!='#'){

                exper1[i++] = optr;

                exper1[i++] = ' ';

            }

        }

        //System.out.println(exper1);



        return ToString(exper1);

    }

    //@Override

    private boolean isOperator(String token)

    {



        return (token.equals("+") || token.equals("-") ||token.equals("*") || token.equals("/") );

    }

    public  static String ToString(char[] exper1){

        int length = exper1.length;

        String str=" ";

        for(int i=0;i<length;i++)

        {

            str=str+exper1[i];

        }

        //System.out.println(str);

        return str;

    }

     /*public static void main(String[] args) {

         String pp=null;

         MyBC turner = new MyBC();



         pp=turner.turn("( 1 + 2 ) * ( ( 8 - 2 ) / ( 7 - 4     ) )");

         System.out.println(pp);

     }*/

}

• 測試結果
  

網絡編程與安全-2

• 結對編程：1人負責客戶端，一人負責服務器
• 注意責任歸宿，要會經過測試證實本身沒有問題
• 基於Java Socket實現客戶端/服務器功能，傳輸方式用TCP
• 客戶端讓用戶輸入中綴表達式，而後把中綴表達式調用MyBC.java的功能轉化爲後綴表達式，把後綴表達式經過網絡發送給服務器
• 服務器接收到後綴表達式，調用MyDC.java的功能計算後綴表達式的值，把結果發送給客戶端
• 客戶端顯示服務器發送過來的結果
  『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。
• 創建客戶端

import java.io.BufferedReader;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.net.Socket;



public class Client {

    public static final String IP_ADDR = "127.0.0.1";//服務器地址

    public static final int PORT = 12345;//服務器端口號



    public static void main(String[] args) {

        System.out.println("客戶端啓動...");

        System.out.println("當接收到服務器端字符爲 \"OK\" 的時候, 客戶端將終止\n");

        while (true) {

            Socket socket = null;

            try {

                //建立一個流套接字並將其鏈接到指定主機上的指定端口號

                socket = new Socket(IP_ADDR, PORT);



                //讀取服務器端數據

                DataInputStream input = new DataInputStream(socket.getInputStream());

                //向服務器端發送數據

                DataOutputStream out = new DataOutputStream(socket.getOutputStream());

                System.out.print("請輸入: \t");

                String str = new BufferedReader(new InputStreamReader(System.in)).readLine();

                MyBC turner = new MyBC();

                String str1 = turner.turn(str);

                int length=0,i=0;

                while(str1.charAt(i)!='\0'){

                    length++;

                    i++;

                }

                String str2 = str1.substring(1,length-1);

                out.writeUTF(str2);



                String ret = input.readUTF();



                System.out.println("服務器端返回過來的是: " + ret);

                // 如接收到 "OK" 則斷開鏈接

                /*if ("OK".equals(ret)) {

                    System.out.println("客戶端將關閉鏈接");

                    Thread.sleep(500);

                    break;

                }*/



                out.close();

                input.close();

            } catch (Exception e) {

                System.out.println("客戶端異常:" + e.getMessage());

            } finally {

                if (socket != null) {

                    try {

                        socket.close();

                    } catch (IOException e) {

                        socket = null;

                        System.out.println("客戶端 finally 異常:" + e.getMessage());

                    }

                }

            }

        }

    }

}

• 創建服務器

import java.io.BufferedReader;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.InputStreamReader;

import java.net.ServerSocket;

import java.net.Socket;



public class Server {

    public static final int PORT = 12345;//監聽的端口號



    public static void main(String[] args) {

        System.out.println("服務器啓動...\n");

        Server server = new Server();

        server.init();

    }



    public void init() {

        try {

            ServerSocket serverSocket = new ServerSocket(PORT);

            while (true) {

                // 一旦有堵塞, 則表示服務器與客戶端得到了鏈接

                Socket client = serverSocket.accept();

                // 處理此次鏈接

                new HandlerThread(client);

            }

        } catch (Exception e) {

            System.out.println("服務器異常: " + e.getMessage());

        }

    }



    private class HandlerThread implements Runnable {

        private Socket socket;

        public HandlerThread(Socket client) {

            socket = client;

            new Thread(this).start();

        }



        public void run() {

            try {

                // 讀取客戶端數據

                DataInputStream input = new DataInputStream(socket.getInputStream());

                String clientInputStr = input.readUTF();//這裏要注意和客戶端輸出流的寫方法對應,不然會拋 EOFException

                // 處理客戶端數據

                System.out.println("客戶端發過來的內容:" + clientInputStr);

                MyDC evalute = new MyDC();

                int result = evalute.evaluate(clientInputStr);

                // 向客戶端回覆信息

                DataOutputStream out = new DataOutputStream(socket.getOutputStream());

                System.out.print("計算結果:\t");

                // 發送鍵盤輸入的一行

                //String s = new BufferedReader(new InputStreamReader(System.in)).readLine();

                out.writeUTF(String.valueOf(result));



                out.close();

                input.close();

            } catch (Exception e) {

                System.out.println("服務器 run 異常: " + e.getMessage());

            } finally {

                if (socket != null) {

                    try {

                        socket.close();

                    } catch (Exception e) {

                        socket = null;

                        System.out.println("服務端 finally 異常:" + e.getMessage());

                    }

                }

            }

        }

    }

}

• 結果
  

網絡編程與安全-3

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

• 注意責任歸宿，要會經過測試證實本身沒有問題
• 基於Java Socket實現客戶端/服務器功能，傳輸方式用TCP
• 客戶端讓用戶輸入中綴表達式，而後把中綴表達式調用MyBC.java的功能轉化爲後綴表達式，把後綴表達式用3DES或AES算法加密後經過網絡把密文發送給服務器
• 服務器接收到後綴表達式表達式後，進行解密（和客戶端協商密鑰，能夠用數組保存），而後調用MyDC.java的功能計算後綴表達式的值，把結果發送給客戶端
• 客戶端顯示服務器發送過來的結果
• 實現DES加密主要有如下幾個步驟：
  1.對稱密鑰的生成和保存；
  2.使用對稱密鑰進行加密和解密；
  3.從文件中獲取加密時使用的密鑰，使用密鑰進行解密；
  客戶端

import java.io.BufferedReader;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.net.Socket;



public class Client2 {

    public static final String IP_ADDR = "127.0.0.1";//服務器地址

    public static final int PORT = 12345;//服務器端口號



    public static void main(String[] args) {

        System.out.println("客戶端啓動...");

        System.out.println("當接收到服務器端字符爲 \"OK\" 的時候, 客戶端將終止\n");

        while (true) {

            Socket socket = null;

            try {

                //建立一個流套接字並將其鏈接到指定主機上的指定端口號

                socket = new Socket(IP_ADDR, PORT);



                //讀取服務器端數據

                DataInputStream input = new DataInputStream(socket.getInputStream());

                //向服務器端發送數據

                DataOutputStream out = new DataOutputStream(socket.getOutputStream());

                System.out.print("請輸入: \t");

                String str = new BufferedReader(new InputStreamReader(System.in)).readLine();

                MyBC turner = new MyBC();

                Skey_DES skey_des = new Skey_DES();

                skey_des.key_DES();

                Skey_kb skey_kb = new Skey_kb();

                skey_kb.key();

                /*產生密鑰*/

                SEnc sEnc = new SEnc();

                String str1 = turner.turn(str);

                int length=0,i=0;

                while(str1.charAt(i)!='\0'){

                    length++;

                    i++;

                }

                String str2 = str1.substring(1,length-1);

                out.writeUTF(str2);



                String ret = input.readUTF();



                System.out.println("服務器端返回過來的是: " + ret);

                // 如接收到 "OK" 則斷開鏈接

                /*if ("OK".equals(ret)) {

                    System.out.println("客戶端將關閉鏈接");

                    Thread.sleep(500);

                    break;

                }*/



                out.close();

                input.close();

            } catch (Exception e) {

                System.out.println("客戶端異常:" + e.getMessage());

            } finally {

                if (socket != null) {

                    try {

                        socket.close();

                    } catch (IOException e) {

                        socket = null;

                        System.out.println("客戶端 finally 異常:" + e.getMessage());

                    }

                }

            }

        }

    }

}

服務器

import java.io.BufferedReader;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.InputStreamReader;

import java.net.ServerSocket;

import java.net.Socket;



public class Server2 {

    public static final int PORT = 12345;//監聽的端口號



    public static void main(String[] args) {

        System.out.println("服務器啓動...\n");

        Server server = new Server();

        server.init();

    }



    public void init() {

        try {

            ServerSocket serverSocket = new ServerSocket(PORT);

            while (true) {

                // 一旦有堵塞, 則表示服務器與客戶端得到了鏈接

                Socket client = serverSocket.accept();

                // 處理此次鏈接

                new HandlerThread(client);

            }

        } catch (Exception e) {

            System.out.println("服務器異常: " + e.getMessage());

        }

    }



    private class HandlerThread implements Runnable {

        private Socket socket;

        public HandlerThread(Socket client) {

            socket = client;

            new Thread(this).start();

        }



        public void run() {

            try {

                // 讀取客戶端數據

                DataInputStream input = new DataInputStream(socket.getInputStream());

                String clientInputStr = input.readUTF();//這裏要注意和客戶端輸出流的寫方法對應,不然會拋 EOFException

                // 處理客戶端數據

                System.out.println("客戶端發過來的內容:" + clientInputStr);

                MyDC evalute = new MyDC();

                SDec sDec = new SDec();

                int result = evalute.evaluate(clientInputStr);

                // 向客戶端回覆信息

                DataOutputStream out = new DataOutputStream(socket.getOutputStream());

                System.out.print("計算結果:\t");

                // 發送鍵盤輸入的一行

                //String s = new BufferedReader(new InputStreamReader(System.in)).readLine();

                out.writeUTF(String.valueOf(result));



                out.close();

                input.close();

            } catch (Exception e) {

                System.out.println("服務器 run 異常: " + e.getMessage());

            } finally {

                if (socket != null) {

                    try {

                        socket.close();

                    } catch (Exception e) {

                        socket = null;

                        System.out.println("服務端 finally 異常:" + e.getMessage());

                    }

                }

            }

        }

    }

}

運行截圖

網絡編程與安全-4

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

• 基於Java Socket實現客戶端/服務器功能，傳輸方式用TCP
• 客戶端讓用戶輸入中綴表達式，而後把中綴表達式調用MyBC.java的功能轉化爲後綴表達式，把後綴表達式用3DES或AES算法加密經過網絡把密文發送給服務器
• 客戶端和服務器用DH算法進行3DES或AES算法的密鑰交換
• 服務器接收到後綴表達式表達式後，進行解密，而後調用MyDC.java的功能計算後綴表達式的值，把結果發送給客戶端
• 客戶端顯示服務器發送過來的結果
  執行密鑰協定的標準算法是DH算法（Diffie-Hellman算法），分爲如下兩步：
  1.建立DH公鑰和私鑰；
  2.建立共享密鑰。
• 建立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{
    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
    };
    private static final BigInteger skip1024Modulus = new BigInteger(1, skip1024ModulusBytes);
    private static final BigInteger skip1024Base = BigInteger.valueOf(2);
    public static void fun(String s1,String s2) 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(s1);
        ObjectOutputStream b1=new  ObjectOutputStream(f1);
        b1.writeObject(pbk);
        // 保存私鑰
        FileOutputStream  f2=new FileOutputStream(s2);
        ObjectOutputStream b2=new  ObjectOutputStream(f2);
        b2.writeObject(prk);
    }
}

• 建立共享密鑰:

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_Agree{

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

    }

    public static void fun(String s, String s1) {

    }
}

• 運行截圖
  

網絡編程與安全-5

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

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

import java.io.*;

import java.net.*;

import java.applet.Applet;

import java.security.MessageDigest;



public class Server3 {

    public static void main(String args[]) {



        MyDC evalute = new MyDC();



        SDec sDec = new SDec();



        try {

            ServerSocket server = null;

            try {

                server = new ServerSocket(4700);

                //建立一個ServerSocket在端口4700監聽客戶請求


            } catch (Exception e) {

                System.out.println("can not listen to:" + e);

                //出錯，打印出錯信息


            }

            Socket socket = null;

            try {

                socket = server.accept();

                //使用accept()阻塞等待客戶請求，有客戶


                //請求到來則產生一個Socket對象，並繼續執行


            } catch (Exception e) {

                System.out.println("Error." + e);

                //出錯，打印出錯信息


            }



            String line;



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

            //由Socket對象獲得輸入流，並構造相應的BufferedReader對象


            PrintWriter os = new PrintWriter(socket.getOutputStream());

            //由Socket對象獲得輸出流，並構造PrintWriter對象


            BufferedReader sin = new BufferedReader(new InputStreamReader(System.in));

            //由系統標準輸入設備構造BufferedReader對象




            //使用Hash函數檢測明文完整性


            String x = sin.readLine();



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



            String match = is.readLine();

            if (match.equals(result)) {

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

            }



            System.out.println("Client:" + is.readLine());

            //在標準輸出上打印從客戶端讀入的字符串




            line = sin.readLine();

            //從標準輸入讀入一字符串




            while (!line.equals("bye")) {

                //若是該字符串爲 "bye"，則中止循環




                os.println(evalute.evaluate(line));

                //向客戶端輸出該字符串


                os.flush();

                //刷新輸出流，使Client立刻收到該字符串




                System.out.println("Server:" + evalute.evaluate(line));

                //在系統標準輸出上打印讀入的字符串




                System.out.println("Client:" + is.readLine());

                //從Client讀入一字符串，並打印到標準輸出上


                line = sin.readLine();





                //從系統標準輸入讀入一字符串


            }  //繼續循環


            os.close(); //關閉Socket輸出流


            is.close(); //關閉Socket輸入流


            socket.close(); //關閉Socket


            server.close(); //關閉ServerSocket


        } catch (Exception e) {

            System.out.println("Error:" + e);

//出錯，打印出錯信息


        }

    }

}

• 創建客戶端

import java.io.*;

import java.net.*;

import java.security.MessageDigest;



public class Client3 {

    public static void main(String args[]) throws Exception {



        MyBC turner = new MyBC();



        Skey_DES skey_des = new Skey_DES();

        skey_des.key_DES();

        Skey_kb skey_kb = new Skey_kb();

        skey_kb.key();

        /*產生密鑰*/



        SEnc sEnc = new SEnc();



        try {

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

//向本機的4700端口發出客戶請求


            BufferedReader sin = new BufferedReader(new InputStreamReader(System.in));

//由系統標準輸入設備構造BufferedReader對象


            PrintWriter os = new PrintWriter(socket.getOutputStream());

//由Socket對象獲得輸出流，並構造PrintWriter對象


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

//由Socket對象獲得輸入流，並構造相應的BufferedReader對象




            String readline;



            readline =sin.readLine();

            //從系統標準輸入讀入一字符串




            String x = readline;



            // 將客戶端明文的Hash值傳送給服務器


            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("明文MD5值爲:" + result);

            os.println(result);//經過網絡將明文的Hash函數值傳送到服務器




            // String str = is.readLine();// 從網絡輸入流讀取結果


            System.out.println("從服務器接收到的結果爲：" + result); // 輸出服務器返回的結果




            while (!readline.equals("bye")) {

//若從標準輸入讀入的字符串爲 "bye"則中止循環




                readline = SEnc.Enc(turner.turn(readline));



                os.println(readline);

                /*把中綴表達式調用MyBC.java的功能轉化爲後綴表達式，把後綴表達式用3DES加密後經過網絡發送給服務器*/



                //將從系統標準輸入讀入的字符串輸出到Server


                os.flush();



                //刷新輸出流，使Server立刻收到該字符串


                System.out.println("Client:" + readline);



                //在系統標準輸出上打印讀入的字符串


                System.out.println("Server:" + is.readLine());



                //從Server讀入一字符串，並打印到標準輸出上


                readline = sin.readLine(); //從系統標準輸入讀入一字符串




            } //繼續循環


            os.close(); //關閉Socket輸出流


            is.close(); //關閉Socket輸入流


            socket.close(); //關閉Socket


        } catch (Exception e) {

            System.out.println("Error" + e); //出錯，則打印出錯信息


        }

    }

}

• 運行結果
  

代碼連接