20155215 宣言 实验五 网络编程与安全 实验报告
实验要求
1.没有Linux基础的同窗建议先学习《Linux基础入门（新版）》《Vim编辑器》 课程；html
2.完成实验、撰写实验报告，实验报告模板见QQ群，注意实验报告重点是运行结果，遇到的问题(工具查找，安装，使用，程序的编辑，调试，运行等)、解决办法（空洞的方法如“查网络”、“问同窗”、“看书”等一概得0分）以及分析（从中能够获得什么启示，有什么收获，教训等）；java
3.实验报告中统计本身的PSP(Personal Software Process)时间：算法
| 步骤 | 耗时 | 百分比 |
|---|---|---|
| 需求分析 | ||
| 设计 | ||
| 代码实现 | ||
| 测试 | ||
| 分析总结 |
实验内容
1、两人一组结对编程：
- 参考http://www.cnblogs.com/rocedu/p/6766748.html#SECDSA
- 结对实现中缀表达式转后缀表达式的功能 MyBC.java
- 结对实现从上面功能中获取的表达式中实现后缀表达式求值的功能,调用MyDC.java
- 上传测试代码运行结果截图和码云连接
这题一共有三个代码，比起后面的四道题，这题仍是较为简单的。
MyBC.java的代码以下所示：编程
/**
* Created by XY on 2017/6/1.
*/
import java.util.Iterator;
import java.util.LinkedList;
public class MyBC {
private static LinkedList<String> op1 = new LinkedList<>();
private static LinkedList<String> op2 = new LinkedList<>();
private static StringBuilder a = new StringBuilder();
public StringBuilder houzhui(LinkedList<String> list) {
Iterator<String> i = list.iterator();
while (i.hasNext()) {
String s = i.next();
if (isOperator(s)) {
if (op1.isEmpty()) {
op1.push(s);
} else {
if (priority(op1.peek()) <= priority(s) && !s.equals(")")) {
op1.push(s);
} else if (!s.equals(")") && priority(op1.peek()) > priority(s)) {
while (op1.size() != 0 && priority(op1.peek()) >= priority(s)
&& !op1.peek().equals("(")) {
if (!op1.peek().equals("(")) {
String operator = op1.pop();
a.append(operator).append(" ");
op2.push(operator);
}
}
op1.push(s);
} else if (s.equals(")")) {
while (!op1.peek().equals("(")) {
String operator = op1.pop();
a.append(operator).append(" ");
op2.push(operator);
}
op1.pop();
}
}
} else {
a.append(s).append(" ");
op2.push(s);
}
}
if (!op1.isEmpty()) {
Iterator<String> iterator = op1.iterator();
while (iterator.hasNext()) {
String operator = iterator.next();
a.append(operator).append(" ");
op2.push(operator);
iterator.remove();
}
}
return a;
}
private static boolean isOperator(String oper) {
if (oper.equals("+") || oper.equals("-") || oper.equals("/") || oper.equals("*")
|| oper.equals("(") || oper.equals(")")) {
return true;
}
return false;
}
private static int priority(String s) {
switch (s) {
case "+":
return 1;
case "-":
return 1;
case "*":
return 2;
case "/":
return 2;
case "(":
return 3;
case ")":
return 3;
default:
return 0;
}
}
}
MyBCTest.java的代码以下：数组
/**
* Created by XY on 2017/6/1.
*/
import java.util.Iterator;
import java.util.LinkedList;
public class MyBC {
private static LinkedList<String> op1 = new LinkedList<>();
private static LinkedList<String> op2 = new LinkedList<>();
private static StringBuilder a = new StringBuilder();
public StringBuilder houzhui(LinkedList<String> list) {
Iterator<String> i = list.iterator();
while (i.hasNext()) {
String s = i.next();
if (isOperator(s)) {
if (op1.isEmpty()) {
op1.push(s);
} else {
if (priority(op1.peek()) <= priority(s) && !s.equals(")")) {
op1.push(s);
} else if (!s.equals(")") && priority(op1.peek()) > priority(s)) {
while (op1.size() != 0 && priority(op1.peek()) >= priority(s)
&& !op1.peek().equals("(")) {
if (!op1.peek().equals("(")) {
String operator = op1.pop();
a.append(operator).append(" ");
op2.push(operator);
}
}
op1.push(s);
} else if (s.equals(")")) {
while (!op1.peek().equals("(")) {
String operator = op1.pop();
a.append(operator).append(" ");
op2.push(operator);
}
op1.pop();
}
}
} else {
a.append(s).append(" ");
op2.push(s);
}
}
if (!op1.isEmpty()) {
Iterator<String> iterator = op1.iterator();
while (iterator.hasNext()) {
String operator = iterator.next();
a.append(operator).append(" ");
op2.push(operator);
iterator.remove();
}
}
return a;
}
private static boolean isOperator(String oper) {
if (oper.equals("+") || oper.equals("-") || oper.equals("/") || oper.equals("*")
|| oper.equals("(") || oper.equals(")")) {
return true;
}
return false;
}
private static int priority(String s) {
switch (s) {
case "+":
return 1;
case "-":
return 1;
case "*":
return 2;
case "/":
return 2;
case "(":
return 3;
case ")":
return 3;
default:
return 0;
}
}
}
MyDC的代码以下：服务器
/**
* Created by XY on 2017/6/1.
*/
import java.util.LinkedList;
public class MyDC {
public static int evaluate(StringBuilder b) {
LinkedList<String> mList = new LinkedList<>();
String[] postStr = b.toString().split(" ");
int result;
for (String s : postStr) {
if (fuhao(s)) {
if (!mList.isEmpty()) {
int num1 = Integer.valueOf(mList.pop());
int num2 = Integer.valueOf(mList.pop());
if (s.equals("/") && num1 == 0) {
System.out.println("除数不能为0");
return 0;
}
int newNum = cal(num2, num1, s);
mList.push(String.valueOf(newNum));
}
} else {
mList.push(s);
}
}
//if (!mList.isEmpty()) {
//System.out.println("result: "+mList.pop());
result=Integer.parseInt(mList.pop());
// }
return result;
}
private static boolean fuhao(String a) {
if (a.equals("+") || a.equals("-") || a.equals("/") || a.equals("*")
|| a.equals("(") || a.equals(")")) {
return true;
}
return false;
}
/*private static int priority(String s) {
switch (s) {
case "+":
return 1;
case "-":
return 1;
case "*":
return 2;
case "/":
return 2;
case "(":
return 3;
case ")":
return 3;
default:
return 0;
}
}*/
private static int cal(int num1, int num2, String operator) {
switch (operator) {
case "+":
return num1 + num2;
case "-":
return num1 - num2;
case "*":
return num1 * num2;
case "/":
return num1 / num2;
default:
return 0;
}
}
}
/*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 MULTIPLY:
result = op1 * op2;
break;
case DIVIDE:
result = op1 / op2;
}
return result;
}*/
最后的运行结果以下图所示：
网络
2、结对编程：1人负责客户端，一人负责服务器
- 注意责任归宿，要会经过测试证实本身没有问题
- 基于Java Socket实现客户端/服务器功能，传输方式用TCP
- 客户端让用户输入中缀表达式，而后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式经过网络发送给服务器
- 服务器接收到后缀表达式，调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
- 客户端显示服务器发送过来的结果
- 上传测试结果截图和码云连接
服务器的代码以下：app
/**
* Created by XY on 2017/6/2.
*/
import java.io.*;
import java.net.*;
import static java.lang.Integer.*;
public class fuwuqi {
public static void main(String[] args) {
ServerSocket serverSocket = null;
Socket socket = null;
OutputStream os = null;
InputStream is = null;
//监听端口号
int port = 10000;
try {
//创建链接
serverSocket = new ServerSocket(port);
System.out.println("创建链接成功！");
//得到链接
socket = serverSocket.accept();
System.out.println("得到链接成功！");
//接收客户端发送内容
is = socket.getInputStream();
byte[] b = new byte[1024];
int n = is.read(b);
System.out.println("接收数据成功！");
//输出
String message=new String(b,0,n);
System.out.println("来自客户端的数据内容为：" + message);
String result=code06011.dealEquation(message);
//向客户端发送反馈内容
//os = socket.getOutputStream();
//os.write(b,0,n);
os = socket.getOutputStream();
os.write(result.getBytes());
} catch (Exception e) {
e.printStackTrace();
}finally{
try{
//关闭流和链接
os.close();
is.close();
socket.close();
serverSocket.close();
}catch(Exception e){}
}
}
}
客户端的代码以下socket
/**
* Created by XY on 2017/6/2.
*/
import java.io.*;
import java.net.*;
public class kehuduan {
public static void main(String[] args) {
Socket socket = null;
InputStream is = null;
OutputStream os = null;
//服务器端IP地址
String serverIP = "10.43.32.95";
//服务器端端口号
int port = 10000;
//发送内容
System.out.println("输入中缀表达式：(1+2)*3/4");
String data = code06011.toSuffix("(1+2)*3/4");
System.out.println("转换后缀表达式："+data);
try {
//创建链接
socket = new Socket(serverIP, port);
System.out.println("创建链接成功！");
//发送数据
os = socket.getOutputStream();
os.write(data.getBytes());
System.out.println("发送数据成功！");
//接收数据
is = socket.getInputStream();
byte[] b = new byte[1024];
int n = is.read(b);
System.out.println("接收数据成功！");
//输出反馈数据
System.out.println("来自服务器的数据内容为：" + new String(b, 0, n));
} catch (Exception e) {
e.printStackTrace(); //打印异常信息
} finally {
try {
//关闭流和链接
is.close();
os.close();
socket.close();
} catch (Exception e2) {
}
}
}
}
3、加密结对编程：1人负责客户端，一人负责服务器
- 注意责任归宿，要会经过测试证实本身没有问题
- 基于Java Socket实现客户端/服务器功能，传输方式用TCP
- 客户端让用户输入中缀表达式，而后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密后经过网络把密文发送给服务器
- 服务器接收到后缀表达式表达式后，进行解密（和客户端协商密钥，能够用数组保存），而后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
- 客户端显示服务器发送过来的结果
- 上传测试结果截图和码云连接
这题一共有三个代码
ComputeTCPServer代码以下：编辑器
/**
* Created by XY on 2017/6/1.
*/
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(9999);//建立服务器套接字
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); //经过网络输出流返回结果给客户端
//验证实文的准确性
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;
}
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();
}
}
SocketService的代码以下：
/**
* Created by XY on 2017/6/1.
*/
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class SocketService {
//搭建服务器端
public static void main(String[] args) throws IOException{
SocketService socketService = new SocketService();
//一、a)建立一个服务器端Socket，即SocketService
socketService.oneServer();
}
public void oneServer(){
try{
ServerSocket server=null;
try{
server=new ServerSocket(9999);
//b)指定绑定的端口，并监听此端口。
System.out.println("服务器启动成功");
//建立一个ServerSocket在端口5200监听客户请求
}catch(Exception e) {
System.out.println("没有启动监听："+e);
//出错，打印出错信息
}
Socket socket=null;
try{
socket=server.accept();
//二、调用accept()方法开始监听，等待客户端的链接
//使用accept()阻塞等待客户请求，有客户
//请求到来则产生一个Socket对象，并继续执行
}catch(Exception e) {
System.out.println("Error."+e);
//出错，打印出错信息
}
//三、获取输入流，并读取客户端信息
String line;
BufferedReader in=new BufferedReader(new InputStreamReader(socket.getInputStream()));
//由Socket对象获得输入流，并构造相应的BufferedReader对象
PrintWriter writer=new PrintWriter(socket.getOutputStream());
//由Socket对象获得输出流，并构造PrintWriter对象
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
//由系统标准输入设备构造BufferedReader对象
System.out.println("Client:"+in.readLine());
//在标准输出上打印从客户端读入的字符串
line=br.readLine();
//从标准输入读入一字符串
//四、获取输出流，响应客户端的请求
while(!line.equals("end")){
//若是该字符串为"end"，则中止循环
writer.println(line);
//向客户端输出该字符串
writer.flush();
//刷新输出流，使Client立刻收到该字符串
System.out.println("Server:"+line);
//在系统标准输出上打印读入的字符串
System.out.println("Client:"+in.readLine());
//从Client读入一字符串，并打印到标准输出上
line=br.readLine();
//从系统标准输入读入一字符串
} //继续循环
//五、关闭资源
writer.close(); //关闭Socket输出流
in.close(); //关闭Socket输入流
socket.close(); //关闭Socket
server.close(); //关闭ServerSocket
}catch(Exception e) {//出错，打印出错信息
System.out.println("Error."+e);
}
}
}
StockCline的代码以下：
/**
* Created by XY on 2017/6/1.
*/
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.net.URL;
public class StockCline{
// 搭建客户端
public static void main(String[] args) throws IOException {
try {
// 一、建立客户端Socket，指定服务器地址和端口
// Socket socket=new Socket("127.0.0.1",5200);
Socket socket = new Socket("127.0.0.1", 9999);
System.out.println("客户端启动成功");
// 二、获取输出流，向服务器端发送信息
// 向本机的52000端口发出客户请求
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
// 由系统标准输入设备构造BufferedReader对象
PrintWriter write = new PrintWriter(socket.getOutputStream());
// 由Socket对象获得输出流，并构造PrintWriter对象
//三、获取输入流，并读取服务器端的响应信息
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
// 由Socket对象获得输入流，并构造相应的BufferedReader对象
String readline;
readline = br.readLine(); // 从系统标准输入读入一字符串
while (!readline.equals("end")) {
// 若从标准输入读入的字符串为 "end"则中止循环
write.println(readline);
// 将从系统标准输入读入的字符串输出到Server
write.flush();
// 刷新输出流，使Server立刻收到该字符串
System.out.println("Client:" + readline);
// 在系统标准输出上打印读入的字符串
System.out.println("Server:" + in.readLine());
// 从Server读入一字符串，并打印到标准输出上
readline = br.readLine(); // 从系统标准输入读入一字符串
} // 继续循环
//四、关闭资源
write.close(); // 关闭Socket输出流
in.close(); // 关闭Socket输入流
socket.close(); // 关闭Socket
} catch (Exception e) {
System.out.println("can not listen to:" + e);// 出错，打印出错信息
}
}
}
4、密钥分发结对编程：1人负责客户端，一人负责服务器
- 注意责任归宿，要会经过测试证实本身没有问题
- 基于Java Socket实现客户端/服务器功能，传输方式用TCP
- 客户端让用户输入中缀表达式，而后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密经过网络把密文发送给服务器
- 客户端和服务器用DH算法进行3DES或AES算法的密钥交换
- 服务器接收到后缀表达式表达式后，进行解密，而后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
- 客户端显示服务器发送过来的结果
- 上传测试结果截图和码云连接
5、完整性校验结对编程：1人负责客户端，一人负责服务器
- 注意责任归宿，要会经过测试证实本身没有问题
- 基于Java Socket实现客户端/服务器功能，传输方式用TCP
- 客户端让用户输入中缀表达式，而后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密经过网络把密文和明文的MD5値发送给服务器
- 客户端和服务器用DH算法进行3DES或AES算法的密钥交换
- 服务器接收到后缀表达式表达式后，进行解密，解密后计算明文的MD5值，和客户端传来的MD5进行比较，一致则调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
- 客户端显示服务器发送过来的结果
- 上传测试结果截图和码云连接
最后两题其实和第三题相似，可是有一些小的改动，因此代码我就不重复贴了，下面是个人运行截图：
实验感想
此次实验我以为难度真的很大，我和个人结对对象20155232花了整整一周来作这个实验。咱们在网上查了不少资料，而后请教同窗，最后才赶在最后期限作完的，感受本身不会的还有不少，还须要加油。
PSP时间
| 步骤 | 耗时 | 百分比 |
|---|---|---|
| 需求分析 | 30 | 7.5% |
| 设计 | 50 | 12.5% |
| 代码实现 | 240 | 60% |
| 测试 | 60 | 15% |
| 分析总结 | 20 | 5% |
相关文章
- 1. 20155213 实验五《网络编程与安全》实验报告
- 2. 实验五 网络编程与安全 实验报告
- 3. 20145209 实验五 《网络编程与安全》 实验报告
- 4. 20165328 实验五《网络安全编程》实验报告
- 5. 20175325 《JAVA程序设计》实验五《网络编程与安全》实验报告
- 6. 学号 20175313 《实验五 网络编程与安全》实验报告
- 7. 2017-2018-2 20165236实验五 《网络编程与安全》实验报告
- 8. 2017-2018-2 20165302 实验五《网络编程与安全》实验报告
- 9. 2018-2019-2 20175217 实验五《网络编程与安全》实验报告
- 10. 2018-2019-2 20175218 实验五《网络编程与安全》实验报告
- 更多相关文章...
- • Web 网页 验证 - 网站建设指南
- • DTD - 来自网络的实例 - DTD 教程
- • Composer 安装与使用
- • Git五分钟教程
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
欢迎关注本站公众号,获取更多信息
相关文章
- 1. 20155213 实验五《网络编程与安全》实验报告
- 2. 实验五 网络编程与安全 实验报告
- 3. 20145209 实验五 《网络编程与安全》 实验报告
- 4. 20165328 实验五《网络安全编程》实验报告
- 5. 20175325 《JAVA程序设计》实验五《网络编程与安全》实验报告
- 6. 学号 20175313 《实验五 网络编程与安全》实验报告
- 7. 2017-2018-2 20165236实验五 《网络编程与安全》实验报告
- 8. 2017-2018-2 20165302 实验五《网络编程与安全》实验报告
- 9. 2018-2019-2 20175217 实验五《网络编程与安全》实验报告
- 10. 2018-2019-2 20175218 实验五《网络编程与安全》实验报告