20155202张旭 实验五 网络编程与安全

20155202张旭 实验五 网络编程与安全

任务一：

两人一组结对编程：

参考http://www.cnblogs.com/rocedu/p/6766748.html#SECDSA

结对实现中缀表达式转后缀表达式的功能 MyBC.java

结对实现从上面功能中获取的表达式中实现后缀表达式求值的功能,调用MyDC.java

上传测试代码运行结果截图和码云链接

任务二：

结对编程：1人负责客户端，一人负责服务器

注意责任归宿，要会通过测试证明自己没有问题

基于Java Socket实现客户端/服务器功能，传输方式用TCP

客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式通过网络发送给服务器

服务器接收到后缀表达式，调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端

客户端显示服务器发送过来的结果

上传测试结果截图和码云链接

任务三：

加密结对编程：1人负责客户端，一人负责服务器

注意责任归宿，要会通过测试证明自己没有问题

基于Java Socket实现客户端/服务器功能，传输方式用TCP

客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密后通过网络把密文发送给服务器

服务器接收到后缀表达式表达式后，进行解密（和客户端协商密钥，可以用数组保存），然后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端

客户端显示服务器发送过来的结果

上传测试结果截图和码云链接

任务四：

密钥分发结对编程：1人负责客户端，一人负责服务器

注意责任归宿，要会通过测试证明自己没有问题

基于Java Socket实现客户端/服务器功能，传输方式用TCP

客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密通过网络把密文发送给服务器

客户端和服务器用DH算法进行3DES或AES算法的密钥交换

服务器接收到后缀表达式表达式后，进行解密，然后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端

客户端显示服务器发送过来的结果

上传测试结果截图和码云链接

任务五：

完整性校验结对编程：1人负责客户端，一人负责服务器

注意责任归宿，要会通过测试证明自己没有问题

基于Java Socket实现客户端/服务器功能，传输方式用TCP

客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密通过网络把密文和明文的MD5値发送给服务器

客户端和服务器用DH算法进行3DES或AES算法的密钥交换

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

客户端显示服务器发送过来的结果

任务六：

Android 开发：

客户端功能用Android实现，完成有加分

任务一：

求值伪代码如下：

设置一个操作数栈，开始栈为空；

从左到右扫描后缀表达式，遇操作数，进栈；

若遇运算符，则从栈中退出两个元素，先退出的放到运算符的右边，后退出的放到运算符左边，运算后的结果再进栈，直到后缀表达式扫描完毕。

此时，栈中仅有一个元素，即为运算的结果。

产品代码：

1 import java.util.StringTokenizer;
2 import java.util.Stack;
3
4 public class MyDC
5 {
6   /** constant for addition symbol */
7   private final char ADD = '+';
8   /** constant for subtraction symbol */
9   private final char SUBTRACT = '-';
10   /** constant for multiplication symbol */
11   private final char MULTIPLY = '*';
12   /** constant for division symbol */
13   private final char DIVIDE = '/';
14   /** the stack */
15   private Stack<Integer> stack;
16
17   /**
18    * Sets up this evalutor by creating a new stack.
19    */
20   public MyDC()
21   {
22     stack = new Stack<Integer>();
23   }
24
25   public int evaluate (String expr)
26   {
27     int op1, op2, result = 0;
28     String token;
29     StringTokenizer tokenizer = new StringTokenizer (expr);
30
31     while (tokenizer.hasMoreTokens())
32     {
33       token = tokenizer.nextToken();
34
35       if (isOperator(token))
36       {
37         op2 = (stack.pop()).intValue();
38         op1 = (stack.pop()).intValue();
39         result = evalSingleOp (token.charAt(0), op1, op2);
40         stack.push (new Integer(result));
41       }
42       else
43         stack.push (new Integer(Integer.parseInt(token)));
44     }
45
46     return result;
47   }
48
49   private boolean isOperator (String token)
50   {
51     return ( token.equals("+") || token.equals("-") ||
52              token.equals("*") || token.equals("/") );
53   }
54
55   private int evalSingleOp (char operation, int op1, int op2)
56   {
57     int result = 0;
58
59     switch (operation)
60     {
61       case ADD:
62         result = op1 + op2;
63         break;
64       case SUBTRACT:
65         result = op1 - op2;
66         break;
67       case MULTIPLY:
68         result = op1 * op2;
69         break;
70       case DIVIDE:
71         result = op1 / op2;
72     }
73
74     return result;
75   }
76 }44     }
45
46     return result;
47   }
48
49   private boolean isOperator (String token)
50   {
51     return ( token.equals("+") || token.equals("-") ||
52              token.equals("*") || token.equals("/") );
53   }
54
55   private int evalSingleOp (char operation, int op1, int op2)
56   {
57     int result = 0;
58
59     switch (operation)
60     {
61       case ADD:
62         result = op1 + op2;
63         break;
64       case SUBTRACT:
65         result = op1 - op2;
66         break;
67       case MULTIPLY:
68         result = op1 * op2;
69         break;
70       case DIVIDE:
71         result = op1 / op2;
72     }
73
74     return result;
75   }
76 }

测试代码：

1 import java.util.Scanner;
2
3 public class MyDCTester  {
4
5   public static void main (String[] args) {
6
7     String expression, again;
8
9     int result;
10
11     try
12     {
13       Scanner in = new Scanner(System.in);
14
15       do
16       {
17         MyDC evaluator = new MyDC();
18         System.out.println ("Enter a valid postfix expression: ");
19         expression = in.nextLine();
20
21         result = evaluator.evaluate (expression);
22         System.out.println();
23         System.out.println ("That expression equals " + result);
24
25         System.out.print ("Evaluate another expression [Y/N]? ");
26         again = in.nextLine();
27         System.out.println();
28       }
29       while (again.equalsIgnoreCase("y"));
30     }
31     catch (Exception IOException)
32     {
33       System.out.println("Input exception reported");
34     }
35   }
36 }

客户端网络编程步骤

首先指定连接到的服务器的IP地址和端口号来建立网络连接

连接建立以后，就可以通过这个连接交换数据了。交换数据严格按照请求响应模型进行，由客户端发送一个请求数据到服务器，服务器反馈一个响应数据给客户端，如果客户端不发送请求则服务器端就不响应。

本次实验要求要对数据进行加密操作：

先获得DES的密钥

然后使用RSA算法，使用服务器端的公钥对DES的密钥进行加密

再用DES加密明文得到密文

得到了明文就可以将客户端明文的Hash值传送给服务器，然后会收到来自服务器的返回数据

数据交换完毕后关闭连接

服务器端网络编程步骤

服务器属于被动等待连接，所以首先要进行监听端口，等待客户端进行连接。

在客户端连接之后，服务器就获得一个与客户端之间的连接，二者就可以通过这个连接进行数据交换了。

服务器接收到客户端传来的数据之后要进行处理，针对本次实验来说，客户端传来的数据是加密过的，所以服务器需要进行解密的操作：

首先要使用服务器端RSA的私钥对DES的密钥进行解密

再将十六进制数据转换成十进制

之后用解密得到的DES密钥对DES进行解密

然后使用解密得到的DES对十进制进制密文数据进行解密

最后将得到的十进制明文用“UTF-8”转码成明文字符

解密之后得到明文之后还需要验证数据完整性，在这里使用Hash函数来检测。

检测成功之后再向客户端返回数据表示匹配成功或者失败

最后关闭连接。

服务器代码：

/**
* Created by zx on 2017/5/29
*/
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(10001);//创建服务器套接字
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);
//使用服务器端RSA的私钥对DES的密钥进行解密
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();
BigInteger m=c.modPow(d,n);
byte[] keykb=m.toByteArray();
//使用DES对密文进行解密
String aline=in.readLine();//读取客户端传送来的数据
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); //通过网络输出流返回结果给客户端
//使用Hash函数检测明文完整性
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 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;
}
}

客户端代码的编写：

首先，我们要对计算机网络的一些基本概念有所了解，大家可以参考一下娄老师提供的Java网络编程，这里面对客户端及服务器有较详细的介绍，在此我就不一一赘述了。

根据文章中所提到的客户端网络编程步骤可以知道，客户端的编程主要由三个步骤实现：建立网络连接、数据交换、关闭网络连接。首先我们要建立连接，在Java API中以java.net.Socket类的对象代表网络连接，所以建立客户端网络连接，也就是创建Socket类型的对象，因此，我先创建一个socket对象，```Socket socket = new Socket("192.168.43.246",10001);这里socket实现的是连接到IP地址为192.168.43.246的10001号端口(端口号任意指定)，需要特别说明的是，这里的IP地址指的是服务器电脑的IP地址，端口号也要与服务器上的端口号保持一致。这里提供一个查询IP地址的方法，打开命令提示符，输入指令ipconfig，找到你现在所使用的网络，显示的IPv4地址就是你的电脑现在使用的IP地址

接着利用BufferedReader对象获得从服务器传来的网络输入流，用PrintWriter对象获得从客户端向服务器输出数据的网络输出流，用BufferedReader对象创建键盘输入流，以便客户端从键盘上输入信息，可以参考之前娄老师所上传到QQ群里的ComputeTCPClient.java文件，大概的传输框架就是这样。

由于我们需要进行安全传输，所以在传输过程中还要对数据进行加密，一般来说，采用对称性加密算法与非对称性加密算法结合的方式安全性要更高，因此这里我先用的是RSA算法，用服务器的公钥先对DES的密钥进行加密，然后将加密后的密钥传给服务器，接着让用户输入需要传输的明文，再使用DES算法对明文进行加密，将加密后的密文通过网络传到服务器，然后计算明文的Hash值，传送到服务器。服务器总共会收到来自客户端发送的DES的密钥、密文以及明文的Hash值，服务器会采用RSA公钥密码中服务器的私钥解密DES的密钥，接着用解密后的DES的密钥对密文进行解密，得到明文。服务器再将解得的明文计算Hash值，检查其是否与传过来的Hash值一致，如果一致说明匹配成功。

代码如下：

import java.net.*;
import java.io.*;
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import java.security.spec.*;
import javax.crypto.interfaces.*;
import java.security.interfaces.*;
import java.math.*;

public class Client
{
public static void main(String srgs[]) throws Exception
{
try
{
KeyGenerator kg = KeyGenerator.getInstance("DESede");
kg.init(168);
SecretKey k = kg.generateKey();
byte[] ptext2 = k.getEncoded();
Socket socket = new Socket("10.43.62.8", 10001);
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(); // 从键盘读入待发送的数据
Cipher cp = Cipher.getInstance("DESede");
cp.init(Cipher.ENCRYPT_MODE, k);
byte ptext[] = s.getBytes("UTF8");
byte ctext[] = cp.doFinal(ptext);
String str = parseByte2HexStr(ctext);
out.println(str); // 通过网络将密文传送到服务器

// 将客户端明文的Hash值传送给服务器
String x = s;
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); // 输出服务器返回的结果
}
catch (Exception e)
{
System.out.println(e);//输出异常
}
finally
{

}

}

//将十六进制转换成二进制
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();
}
}

实验六：实现app钟表：

清单文件：

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.administrator.mysecond"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk
android:minSdkVersion="8"
android:targetSdkVersion="17" />
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
<activity
android:name="com.example.administrator.mysecond.MainActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER"
/>
</intent-filter>
</activity>
</application>
</manifest>

这是布局文件：

<RelativeLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="2dp"
android:paddingRight="2dp">
398 Java for Android, Second Edition
<Button
android:id="@+id/cancelButton"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Cancel"
android:layout_marginLeft="36dp"
android:layout_marginStart="36dp"
android:layout_alignBaseline="@+id/saveButton"
android:layout_alignBottom="@+id/saveButton"
android:layout_alignParentLeft="true"
android:layout_alignParentStart="true" />
<Button
android:id="@+id/saveButton"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Save"
android:layout_alignParentTop="true"
android:layout_alignParentRight="true"
android:layout_alignParentEnd="true"
android:layout_marginRight="51dp"
android:layout_marginEnd="51dp"
android:layout_marginTop="54dp" />
<ImageView
android:layout_width="150dp"
android:layout_height="150dp"
android:padding="4dp"
android:src="@android:drawable/ic_btn_speak_now"
android:id="@+id/imageView"
android:layout_above="@+id/filter_button_container"
android:layout_toRightOf="@+id/cancelButton"
android:layout_toEndOf="@+id/cancelButton"
android:layout_marginBottom="100dp" />
<LinearLayout
android:id="@+id/filter_button_container"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_alignParentBottom="true"
android:gravity="center|bottom"
android:background="@android:color/white"
android:orientation="horizontal" >

<Button
android:id="@+id/filterButton"
android:layout_width="wrap_content"
android:layout_height="fill_parent"
android:text="Filter" />

<Button
android:id="@+id/shareButton"
android:layout_width="wrap_content"
android:layout_height="fill_parent"
android:text="Share" />
<Button
android:id="@+id/deleteButton"
android:layout_width="wrap_content"
android:layout_height="fill_parent"
android:text="Delete" />
</LinearLayout>
</RelativeLayout>

结果如下：

布局文件：

package com.example.administrator.mysecond;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class MulticolorClock extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_multicolor_clock);
}
}

PSP(Personal Software Process)时间

步骤	耗时	百分比
需求分析	15分钟	9%
设计	15分钟	9%
代码实现	110分钟	64%
测试	10分钟	6%
分析总结	20分钟	12%

实验感想：

感觉这些东西挺有趣的，软件开发的过程复杂,而团队方式可以使其简单许多,团队操作在很大程度上可以实现优势的互补。但是代码还是很陌生，练的少，但是自己做一个app还是很厉害的，我以后也应该好好学习这些东西，就算以后不学习这个了，但是还是应该去学习，不功利的学习。