java实验报告五

一、实验内容

1．掌握Socket程序的编写；

2．掌握密码技术的使用；

3．设计安全传输系统。

二、实验基础：

IP和端口：IP是用来标示计算机，而端口是用来标示某个计算机上面的特定应用。至于它们的详细介绍，可以查阅相关资料。总之，网络上通信和交互，就是指计算机上端口之间通信与交互。

客户端和服务端：客户端就是享用服务的计算机，而服务端就是提供服务的计算机。客户端和服务端，可以简称为C/S模型。另外，还有一类模型，即B/S模型，利用各种浏览器来享用服务的方式。

TCP和UDP：TCP，传输控制协议，是一种面向连接的可靠传输协议，UDP，用户数据包协议，是一种无连接的不可靠的传输协议。根据不同的应用场景和对于应用的具体要求，选择合适的通信协议。比方说，对于那种注重可靠性，应该选择TCP方式，而对于那种能够容纳一定程度的差错，同时注重传输速度，应该选择UDP方式。

三、实验步骤

1.我负责服务器，搭档负责客户端。搭档20135330张若嘉

2.创建服务器和客户程序，在运行客户程序的计算机上输入的内容，可以在服务器屏幕上看到。

服务器源程序：

3.选择对称算法进行数据加解密.

4. 选择非对称算法对对称加密密钥进行密钥分发.

5. 选择合适的Hash算法进行完整性验证.

6. 选择合适的算法对Hash值进行签名/验证.

四、实验结果

五、实验中遇到的问题

如何建立连接

IPv4地址为本机IP地址

 

六、统计时间

步骤	耗时(min)	百分比
需求分析	40	18.18%
设计	50	22.72%
代码实现	60	27.27%
测试	50	22.72%
分析总结	20	9.09%

七、实验总结

Java网络编程，又称为套接字编程。基于不同的协议，实现通信方式，实现了桌面应用程序的互联网化。将两个电脑相连传输数据，对代码进行组合，不熟悉的编程形式给自己带来了很大的进步。

八、实验代码

 

import java.net.*;

import java.io.*;

import java.security.*;

import java.security.spec.*;

import javax.crypto.*;

import javax.crypto.spec.*;

import javax.crypto.interfaces.*;

import java.security.interfaces.*;

import java.math.*;

public class ComputeTCPServer{

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

        ServerSocket sc = null;

        Socket socket=null;

            try {

                         sc= new ServerSocket(4420);//创建服务器套接字

            System.out.println("端口号:" + sc.getLocalPort());

            System.out.println("服务器已经启动...");

            socket = sc.accept();   //等待客户端连接

            System.out.println("已经建立连接");

                //获得网络输入流对象的引用

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

                ////获得网络输出流对象的引用

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

                        

                         String aline2=in.readLine();

                         BigInteger c=new BigInteger(aline2);

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

                         //System.out.println("d= "+d);

                         //System.out.println("n= "+n);

                         BigInteger m=c.modPow(d,n);

                         //System.out.println("m= "+m);

                         byte[] keykb=m.toByteArray();

                         //String aline3=new String(mt,"UTF8");

                         //String aline3=parseByte2HexStr(byte buf[]);

                        

                         String aline=in.readLine();//读取客户端传送来的数据

                         //FileInputStream  f2=new FileInputStream("keykb1.dat");

                         //int num2=f2.available();

                         //byte[] keykb=new byte[num2];         

                         //f2.read(keykb);

                         byte[] ctext=parseHexStr2Byte(aline);

                         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); //通过网络输出流返回结果给客户端

                        

                         /*String aline2=in.readLine();

                         BigInteger c=new BigInteger(aline2);

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

                         //System.out.println("d= "+d);

                         //System.out.println("n= "+n);

                         BigInteger m=c.modPow(d,n);

                         //System.out.println("m= "+m);

                         byte[] mt=m.toByteArray();

                         //String aline3=new String(mt,"UTF8");*/

                        

                 String aline3=in.readLine();

                 String x=p;

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

                  

                 if(aline3.equals(result)){

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

                 }

                

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

                         out.close();

                         in.close();

                         sc.close();

            } catch (Exception e) {

            System.out.println(e);

        }

    }

        public static String parseByte2HexStr(byte buf[]) { 

        StringBuffer sb = new StringBuffer(); 

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

            String hex = Integer.toHexString(buf[i] & 0xFF); 

            if (hex.length() == 1) { 

                hex = '0' + hex; 

            } 

            sb.append(hex.toUpperCase()); 

        } 

        return sb.toString(); 

    } 

        public static byte[] parseHexStr2Byte(String hexStr) { 

        if (hexStr.length() < 1) 

            return null; 

        byte[] result = new byte[hexStr.length()/2]; 

        for (int i = 0;i< hexStr.length()/2; i++) { 

            int high = Integer.parseInt(hexStr.substring(i*2, i*2+1 ), 16); 

            int low = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16); 

            result[i] = (byte) (high * 16 + low); 

        } 

        return result; 

    } 

}