实验五 Java网络编程及安全

北京电子科技学院（BESTI）

　　　　　　　　　　　　　　　　　　　　　实     验    报     告

　　　　　　课程：Java 　　班级： 1352  　　 姓名：程涵  　　学号：20135210

　　　　　　成绩：             　　指导教师：娄嘉鹏  　　　　　　实验日期：2015.6.9

　　　　　　实验密级：         　　预习程度：        　　　　　 实验时间：15:30~18:00

　　　　　　仪器组次：10        　必修/选修：选修    　　　　实验序号：04

　　　　　　实验名称： 网络编程与安全                                                        

　　　　　　实验目的与要求：  

　　　　　　　　   1．掌握Java网络编程的方法；

　　　　　　　　　2．掌握Java安全编程的方法；

　　　　　　　　　3．能综合使用各种技术。                                                

　　　　　　实验仪器：

名称	型号	数量
计算机		2

 

　　　　　　统计的PSP(Personal Software Process)时间

 

步骤	耗时(min)	百分比
需求分析	10	10%
设计	20	20%
代码实现	40	40%
测试	10	10%
分析总结	20	20%

 

一、实验内容

1．掌握Socket程序的编写；

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

3．设计安全传输系统。

 

二、实验基础：

 

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

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

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

 

三、实验步骤

 

1.我负责服务器，搭档负责客户端。搭档20135218姬梦馨。博客地址http://www.cnblogs.com/ShadowStealer/

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

 

服务器源程序：

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

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

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

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

 

 

四、实验结果

 

 

 

五、实验总结

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

 

六、实验代码

 

  1 import java.net.*;
  2 
  3 import java.io.*;
  4 
  5 import java.security.*;
  6 
  7 import java.security.spec.*;
  8 
  9 import javax.crypto.*;
 10 
 11 import javax.crypto.spec.*;
 12 
 13 import javax.crypto.interfaces.*;
 14 
 15 import java.security.interfaces.*;
 16 
 17 import java.math.*;
 18 
 19 public class ComputeTCPServer{
 20 
 21         public static void main(String srgs[]) throws Exception {
 22 
 23         ServerSocket sc = null;
 24 
 25         Socket socket=null;
 26 
 27             try {
 28 
 29                          sc= new ServerSocket(4420);//创建服务器套接字
 30 
 31             System.out.println("端口号:" + sc.getLocalPort());
 32 
 33             System.out.println("服务器已经启动...");
 34 
 35             socket = sc.accept();   //等待客户端连接
 36 
 37             System.out.println("已经建立连接");
 38 
 39                 //获得网络输入流对象的引用
 40 
 41             BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
 42 
 43                 ////获得网络输出流对象的引用
 44 
 45                          PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())),true);
 46 
 47                         
 48 
 49                          String aline2=in.readLine();
 50 
 51                          BigInteger c=new BigInteger(aline2);
 52 
 53                          FileInputStream f=new FileInputStream("Skey_RSA_priv.dat");
 54 
 55                          ObjectInputStream b=new ObjectInputStream(f);
 56 
 57                          RSAPrivateKey prk=(RSAPrivateKey)b.readObject( );
 58 
 59                          BigInteger d=prk.getPrivateExponent();
 60 
 61                          BigInteger n=prk.getModulus();
 62 
 63                          //System.out.println("d= "+d);
 64 
 65                          //System.out.println("n= "+n);
 66 
 67                          BigInteger m=c.modPow(d,n);
 68 
 69                          //System.out.println("m= "+m);
 70 
 71                          byte[] keykb=m.toByteArray();
 72 
 73                          //String aline3=new String(mt,"UTF8");
 74 
 75                          //String aline3=parseByte2HexStr(byte buf[]);
 76 
 77                         
 78 
 79                          String aline=in.readLine();//读取客户端传送来的数据
 80 
 81                          //FileInputStream  f2=new FileInputStream("keykb1.dat");
 82 
 83                          //int num2=f2.available();
 84 
 85                          //byte[] keykb=new byte[num2];         
 86 
 87                          //f2.read(keykb);
 88 
 89                          byte[] ctext=parseHexStr2Byte(aline);
 90 
 91                          Key k=new  SecretKeySpec(keykb,"DESede");
 92 
 93                          Cipher cp=Cipher.getInstance("DESede");
 94 
 95                          cp.init(Cipher.DECRYPT_MODE, k);
 96 
 97                          byte []ptext=cp.doFinal(ctext);
 98 
 99                         
100 
101                          String p=new String(ptext,"UTF8");
102 
103                          System.out.println("从客户端接收到信息为："+p); //通过网络输出流返回结果给客户端
104 
105                         
106 
107                          /*String aline2=in.readLine();
108 
109                          BigInteger c=new BigInteger(aline2);
110 
111                          FileInputStream f=new FileInputStream("Skey_RSA_priv.dat");
112 
113                          ObjectInputStream b=new ObjectInputStream(f);
114 
115                          RSAPrivateKey prk=(RSAPrivateKey)b.readObject( );
116 
117                          BigInteger d=prk.getPrivateExponent();
118 
119                          BigInteger n=prk.getModulus();
120 
121                          //System.out.println("d= "+d);
122 
123                          //System.out.println("n= "+n);
124 
125                          BigInteger m=c.modPow(d,n);
126 
127                          //System.out.println("m= "+m);
128 
129                          byte[] mt=m.toByteArray();
130 
131                          //String aline3=new String(mt,"UTF8");*/
132 
133                         
134 
135                  String aline3=in.readLine();
136 
137                  String x=p;
138 
139                  MessageDigest m2=MessageDigest.getInstance("MD5");
140 
141          m2.update(x.getBytes( ));
142 
143          byte a[ ]=m2.digest( );
144 
145          String result="";
146 
147          for (int i=0; i<a.length; i++){
148 
149             result+=Integer.toHexString((0x000000ff & a[i]) |
150 
151                                   0xffffff00).substring(6);
152 
153              }
154 
155          System.out.println(result);
156 
157                   
158 
159                  if(aline3.equals(result)){
160 
161                          System.out.println("匹配成功");
162 
163                  }
164 
165                 
166 
167                          out.println("匹配成功");
168 
169                          out.close();
170 
171                          in.close();
172 
173                          sc.close();
174 
175             } catch (Exception e) {
176 
177             System.out.println(e);
178 
179         }
180 
181     }
182 
183         public static String parseByte2HexStr(byte buf[]) { 
184 
185         StringBuffer sb = new StringBuffer(); 
186 
187         for (int i = 0; i < buf.length; i++) { 
188 
189             String hex = Integer.toHexString(buf[i] & 0xFF); 
190 
191             if (hex.length() == 1) { 
192 
193                 hex = '0' + hex; 
194 
195             } 
196 
197             sb.append(hex.toUpperCase()); 
198 
199         } 
200 
201         return sb.toString(); 
202 
203     } 
204 
205         public static byte[] parseHexStr2Byte(String hexStr) { 
206 
207         if (hexStr.length() < 1) 
208 
209             return null; 
210 
211         byte[] result = new byte[hexStr.length()/2]; 
212 
213         for (int i = 0;i< hexStr.length()/2; i++) { 
214 
215             int high = Integer.parseInt(hexStr.substring(i*2, i*2+1 ), 16); 
216 
217             int low = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16); 
218 
219             result[i] = (byte) (high * 16 + low); 
220 
221         } 
222 
223         return result; 
224 
225     } 
226 
227 }