2018-2019 20175335实验五 网络编程与安全
实验报告封面
· 课程：Java程序设计 班级：1753班 姓名：丹增罗布 学号：20175335
· 指导教师：娄嘉鹏 实验日期：2018年5月31日
· 实验时间：15:25 - 17:15 实验序号：实验五
· 实验名称：网络编程与安全实验内容
实验内容
网络编程与安全-1
两人一组结对编程：
1. 参考http://www.cnblogs.com/rocedu/p/6766748.html#SECDSA。
2. 结对实现中缀表达式转后缀表达式的功能 MyBC.java。
3. 结对实现从上面功能中获取的表达式中实现后缀表达式求值的功能,调用MyDC.java。
4. 上传测试代码运行结果截图和码云链接。
实验代码：
MyBC.java
import java.util.*;
public class MyBC {
private Stack<String> stack;
private List<String> list;
private String message, Message = "";
public MyBC() {
stack = new Stack<String>();//用来暂时存放运算符的栈
list = new ArrayList<String>();//用来暂时存放操作数及运算符的列表
}
public void conversion(String expr) { //中缀转后缀
String token;
StringTokenizer tokenizer = new StringTokenizer(expr);
while (tokenizer.hasMoreTokens()) {
//当tokenizer有下一个值时，进行循环，并把值赋给token
token = tokenizer.nextToken();
if (token.equals("(")) {
//如果是左括号，入栈
stack.push(token);
} else if (token.equals("+") || token.equals("-")) {
//如果是“+”或“-”，继续判断栈是否为空
if (!stack.empty()) {
//如果栈非空，判断栈顶元素是什么
if (stack.peek().equals("(")) {
//如果栈顶为“（”，运算符入栈
stack.push(token);
} else {
//否则先把栈顶元素移除，加到列表中，再将运算符入栈
list.add(stack.pop());
stack.push(token);
}
} else {
//若栈为空，运算符入栈
stack.push(token);
}
} else if (token.equals("*") || token.equals("÷")) {
//如果是“*”或“÷”，继续判断栈是否为空
if (!stack.empty()) {
//如果栈非空，判断栈顶元素是什么
if (stack.peek().equals("*") || stack.peek().equals("÷")) {
//如果栈顶为“*”或“÷”，先把栈顶元素移除，加到列表中，再将运算符入栈
list.add(stack.pop());
stack.push(token);
} else {
//如果栈顶为其他，运算符直接入栈
stack.push(token);
}
} else {
//如果栈为空，运算符直接入栈
stack.push(token);
}
} else if (token.equals(")")) {
//如果遇到“）”，开始循环
while (true) {
//先把栈顶元素移除并赋给A
String A = stack.pop();
if (!A.equals("(")) {
//如果A不为“（”，则加到列表
list.add(A);
} else {
//如果A为“（”，退出循环
break;
}
}
} else {
//如果为操作数，进入列表
list.add(token);
}
}
while (!stack.empty()) {
//将栈中元素取出，加到列表中，直到栈为空
list.add(stack.pop());
}
ListIterator<String> li = list.listIterator();//返回此列表元素的列表迭代器（按适当顺序）。
while (li.hasNext()) {
//将迭代器中的元素依次取出，并加上空格作为分隔符
Message += li.next() + " ";
li.remove();
}
message = Message;
}
public String getMessage() {
return message;
}
}MyDC.java
import java.util.*;
public class MyDC {
private final char ADD = '+';
private final char SUBTRACT = '-';
private final char MUTIPLY = '*';
private final char DIVIDE = '/';
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();
if(isOperator(token)){
op2 = (stack.pop().intValue());
op1 = (stack.pop().intValue());
result = evalSingleOp(token.charAt(0),op1,op2);
stack.push(new Integer(result));
}
else {
stack.push(new Integer((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;
}
}测试代码
Calculator.java
import java.util.*;
public class Calculator {
public static void main(String[] args) {
String expression;
int result;
MyBC nts = new MyBC();
MyDC value = new MyDC();
System.out.println("Please input a nifix expression");
Scanner in = new Scanner(System.in);
expression = in.nextLine();
nts.conversion(expression);
System.out.println("The postfix expression is :"+nts.getMessage());
result = value.evaluate(nts.getMessage());
System.out.println("The result is :"+result);
}
}网络编程与安全-2
结对编程：一人负责客户端，一人负责服务器
1. 注意责任归宿，要会通过测试证明自己没有问题。
2. 基于Java Socket实现客户端/服务器功能，传输方式用TCP。
3. 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式通过网络发送给服务器。
4. 服务器接收到后缀表达式，调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端。
5. 客户端显示服务器发送过来的结果。
6. 上传测试结果截图和码云链接。
实验代码：
import java.net.*;
public class Address {
public static void main(String[] args) throws UnknownHostException {
InetAddress net = InetAddress.getLocalHost();
System.out.println(net.toString());
}
}
客户端
import java.io.*;
import java.net.*;
public class dan {
public static void main(String args[]) {
System.out.println("客户端启动...");
//while (true) {
Socket mysocket;
DataInputStream in = null;
DataOutputStream out = null;
try {
mysocket = new Socket("192.168.232.1", 2010);
in = new DataInputStream(mysocket.getInputStream());
out = new DataOutputStream(mysocket.getOutputStream());
System.out.println("请输入:");
String str = new BufferedReader(new InputStreamReader(System.in)).readLine();
MyBC turner = new MyBC();
turner.conversion(str);
String str1 = turner.getMessage();
out.writeUTF(str1);
String s = in.readUTF(); //in读取信息，堵塞状态
System.out.println("客户收到服务器的回答:" + s);
Thread.sleep(500);
} catch (Exception e) {
System.out.println("服务器已断开" + e);
}
//}
}
}
服务器
import java.io.*;
import java.net.*;
public class zhang {
public static void main(String[] args) throws IOException {
int answer;
//while (true) {
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 s = in.readUTF(); // in读取信息，堵塞状态
System.out.println("服务器收到客户的提问:" + s);
MyDC myDC = new MyDC();
answer = myDC.evaluate(s);
out.writeUTF(answer + "");
Thread.sleep(500);
} catch (Exception e) {
System.out.println("客户已断开" + e);
}
//}
}
}
网络编程与安全-3
加密结对编程：1人负责客户端，一人负责服务器
1. 注意责任归宿，要会通过测试证明自己没有问题。
2. 基于Java Socket实现客户端/服务器功能，传输方式用TCP。
3. 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密后通过网络把密文发送给服务器。
4. 服务器接收到后缀表达式表达式后，进行解密（和客户端协商密钥，可以用数组保存），然后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端。
5. 客户端显示服务器发送过来的结果。
6. 上传测试结果截图和码云链接。
实验代码：
import javax.crypto.Cipher;
import java.io.*;
import java.net.Socket;
import java.security.Key;
import java.util.Scanner;
public class dan2{
public static void main(String args[]) {
Socket mysocket;
MyBC mybc = new MyBC();
DataInputStream in = null;
DataOutputStream out = null;
Scanner scanner = new Scanner(System.in);
String str;
try {
mysocket = new Socket("192.168.232.1", 5318);
in = new DataInputStream(mysocket.getInputStream());
out = new DataOutputStream(mysocket.getOutputStream());
System.out.println("客户端启动...");
FileInputStream f = new FileInputStream("key1.dat");
ObjectInputStream b = new ObjectInputStream(f);
Key key = (Key) b.readObject();
Cipher cp = Cipher.getInstance("DESede");
cp.init(Cipher.ENCRYPT_MODE, key);
System.out.println("请输入中缀表达式：");
str = scanner.nextLine();
mybc.conversion(str);
String str1 = mybc.getMessage();
byte ptext[] = str1.getBytes("UTF-8");
byte ctext[] = cp.doFinal(ptext);
System.out.println("被加密的后缀表达式：");
for (int i = 0; i < ctext.length; i++) {
System.out.print(ctext[i] + ",");
}
System.out.println("");
out.writeUTF(ctext.length + "");
for (int i = 0; i < ctext.length; i++) {
out.writeUTF(ctext[i] + "");
//System.out.print();
}
String s = in.readUTF(); //in读取信息，堵塞状态
System.out.println("客户收到服务器的回应:" + s);
} catch (Exception e) {
System.out.println("服务器已断开" + e);
}
}
}
服务器
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class zahng2 {
public static void main(String args[]) {
MyDC mydc = new MyDC();
ServerSocket serverForClient = null;
Socket socketOnServer = null;
DataOutputStream out = null;
DataInputStream in = null;
try {
serverForClient = new ServerSocket(5318);
} catch (IOException e1) {
System.out.println(e1);
}
try {
System.out.println("等待客户呼叫");
socketOnServer = serverForClient.accept(); //堵塞状态，除非有客户呼叫
System.out.println("客户已连接");
out = new DataOutputStream(socketOnServer.getOutputStream());
in = new DataInputStream(socketOnServer.getInputStream());
String leng = in.readUTF(); // in读取信息，堵塞状态
byte ctext[] = new byte[Integer.parseInt(leng)];
for (int i = 0;i<Integer.parseInt(leng);i++) {
String temp = in.readUTF();
ctext[i] = Byte.parseByte(temp);
}
// 获取密钥
FileInputStream f2 = new FileInputStream("keykb1.dat");
int num2 = f2.available();
byte[] keykb = new byte[num2];
f2.read(keykb);
SecretKeySpec k = new SecretKeySpec(keykb, "DESede");
// 解密
Cipher cp = Cipher.getInstance("DESede");
cp.init(Cipher.DECRYPT_MODE, k);
byte[] ptext = cp.doFinal(ctext);
/*for (int i = 0; i < ptext.length; i++) {
System.out.print(ptext[i] + ",");
}
*/
System.out.println("");
// 显示明文
String p = new String(ptext,"UTF8");
System.out.println("被解密的后缀表达式：" + p);
System.out.println("计算后缀表达式" + p);
out.writeUTF(mydc.evaluate(p)+"");
} catch (Exception e) {
System.out.println("客户已断开" + e);
}
}
}
网络编程与安全-4
密钥分发结对编程：1人负责客户端，一人负责服务器
1. 注意责任归宿，要会通过测试证明自己没有问题。
2. 基于Java Socket实现客户端/服务器功能，传输方式用TCP。
3. 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密通过网络把密文发送给服务器。
4. 客户端和服务器用DH算法进行3DES或AES算法的密钥交换。
5. 服务器接收到后缀表达式表达式后，进行解密，然后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端。
6. 客户端显示服务器发送过来的结果。
7. 上传测试结果截图和码云链接。
网络编程与安全-5
完整性校验结对编程：1人负责客户端，一人负责服务器
1. 注意责任归宿，要会通过测试证明自己没有问题。
2. 基于Java Socket实现客户端/服务器功能，传输方式用TCP。
3. 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密通过网络把密文和明文的MD5値发送给服务器。
4. 客户端和服务器用DH算法进行3DES或AES算法的密钥交换。
5. 服务器接收到后缀表达式表达式后，进行解密，解密后计算明文的MD5值，和客户端传来的MD5进行比较，一致则调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端。
6. 客户端显示服务器发送过来的结果。
7. 上传测试结果截图和码云链接。
实验心得体会：此次的实验自认为感觉很难，实验里包括这现在学的密码学的知识并转化成实验代码，So真的挺难的。我跟我结伴的同学不仅在问了很多学习好的同学而且还在网上查了相关知识，一步一步靠着自己及同学的帮助完成此次的实验。和结对伙伴一起复习网络编程和密码学算法相关内容，我们参考书上网上代码和Java 密码学算法代码，最终完成了实验，在这个过程中，我们复习了相关很多的关于此次网络编程的知识，也学到了很多信息安全的内容，为以后打下好的基础。
