2018-2019-2 20175204 张湲祯 实验五《网络编程与安全》实验报告
实验五《网络编程与安全》
一.实验内容：
1.网络编程与安全-1
任务详情
两人一组结对编程：
0.参考http://www.cnblogs.com/rocedu/p/6766748.html#SECDSA
1.结对实现中缀表达式转后缀表达式的功能 MyBC.java
2.结对实现从上面功能中获取的表达式中实现后缀表达式求值的功能,调用MyDC.java
3.上传测试代码运行结果截图和码云链接
2.网络编程与安全-2
结对编程：1人负责客户端，一人负责服务器
- 注意责任归宿，要会通过测试证明自己没有问题
- 基于Java Socket实现客户端/服务器功能，传输方式用TCP
- 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式通过网络发送给服务器
- 服务器接收到后缀表达式，调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
- 客户端显示服务器发送过来的结果
- 上传测试结果截图和码云链接
3.网络编程与安全-3
加密结对编程：1人负责客户端，一人负责服务器
- 注意责任归宿，要会通过测试证明自己没有问题
- 基于Java Socket实现客户端/服务器功能，传输方式用TCP
- 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密后通过网络把密文发送给服务器
- 服务器接收到后缀表达式表达式后，进行解密（和客户端协商密钥，可以用数组保存），然后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
- 客户端显示服务器发送过来的结果
- 上传测试结果截图和码云链接
4.网络编程与安全-4
密钥分发结对编程：1人负责客户端，一人负责服务器
- 注意责任归宿，要会通过测试证明自己没有问题
- 基于Java Socket实现客户端/服务器功能，传输方式用TCP
- 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密通过网络把密文发送给服务器
- 客户端和服务器用DH算法进行3DES或AES算法的密钥交换
- 服务器接收到后缀表达式表达式后，进行解密，然后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
- 客户端显示服务器发送过来的结果
- 上传测试结果截图和码云链接
5.网络编程与安全-5
实验五 网络编程与安全-5
完整性校验结对编程：1人负责客户端，一人负责服务器
- 注意责任归宿，要会通过测试证明自己没有问题
- 基于Java Socket实现客户端/服务器功能，传输方式用TCP
- 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密通过网络把密文和明文的MD5値发送给服务器
- 客户端和服务器用DH算法进行3DES或AES算法的密钥交换
- 服务器接收到后缀表达式表达式后，进行解密，解密后计算明文的MD5值，和客户端传来的MD5进行比较，一致则调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
- 客户端显示服务器发送过来的结果
- 上传测试结果截图和码云链接
二.实验步骤
1.任务一
1.使用栈对后缀表达式扫描:
-设置一个操作数栈，开始栈为空；
-从左到右扫描后缀表达式，遇操作数，进栈；
-若遇运算符，则从栈中退出两个元素，先退出的放到运算符的右边，后退出的放到运算符左边，运算后的结果再进栈，直到后缀表达式扫描完毕。
2.实验代码
/**
* MyDC
*
* @author 20175204
* @date 2019/5/28
*/
import java.util.StringTokenizer;
import java.util.Stack;
public class MyDC {
/** constant for addition symbol */
private final char ADD = '+';
/** constant for subtraction symbol */
private final char SUBTRACT = '-';
/** constant for multiplication symbol */
private final char MULTIPLY = '*';
/** constant for division symbol */
private final char DIVIDE = '/';
/** the stack */
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();
//如果是运算符，调用isOperator
if (isOperator(token))
{
op2 = (stack.pop()).intValue();
//从栈中弹出操作数2
op1 = (stack.pop()).intValue();
//从栈中弹出操作数1
result = evalSingleOp(token.charAt(0),op1,op2);
//根据运算符和两个操作数调用evalSingleOp计算result;
stack.push(new Integer(result));
//计算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 MULTIPLY:
result = op1 * op2;
break;
case DIVIDE:
result = op1 / op2;
}
return result;
}
}3.测试代码
import java.util.Scanner;
public class MyDCTester {
public static void main (String[] args) {
String expression, again;
int result;
try
{
Scanner in = new Scanner(System.in);
do
{
MyDC evaluator = new MyDC();
System.out.println ("Enter a valid postfix expression: ");
expression = in.nextLine();
result = evaluator.evaluate (expression);
System.out.println();
System.out.println ("That expression equals " + result);
System.out.print ("Evaluate another expression [Y/N]? ");
again = in.nextLine();
System.out.println();
}
while ("y".equalsIgnoreCase(again));
}
catch (Exception IOException)
{
System.out.println("Input exception reported");
}
}
}4.实验截图
5.MyBC
-设立一个栈，存放运算符，首先栈为空；
-从左到右扫描中缀式，若遇到操作数，直接输出，并输出一个空格作为两个操作数的分隔符；
-若遇到运算符，则与栈顶比较，比栈顶级别高则进栈，否则退出栈顶元素并输出，然后输出一个空格作分隔符；
-若遇到左括号，进栈；若遇到右括号，则一直退栈输出，直到退到左括号止；
-当栈变成空时，输出的结果即为后缀表达式。
6.实验代码
/**
* MyDC
*
* @author 20175204
* @date 2019/5/28
*/
import java.util.StringTokenizer;
import java.util.Stack;
public class MyBC{
private Stack<Character> stack1;
public char Precede(char a,char b)
{
if(a=='#')
if(b!='#')
return '<';
else
return '=';
if(a==')')
return '>';
if(a=='(')
if(b!=')')
return '<';
else
return '=';
if(a=='/'||a=='*')
if(b!='(')
return '>';
else
return '<';
if(a=='-'||a=='+')
if(b!='*'&&b!='/'&&b!='(')
return '>';
else
return '<';
return '>';
}
public MyBC() {
stack1 = new Stack<Character>();
stack1.push('#');
}
public String turn(String expr) {
int result = 0;
String token;
char topelem,optr;
char[] exper1 = new char[100];
int i = 0;
StringTokenizer tokenizer = new StringTokenizer (expr);
while (tokenizer.hasMoreTokens())
{
token = tokenizer.nextToken();
if (isOperator(token))
{
topelem=stack1.peek();
optr = token.charAt(0);
if(Precede(topelem,optr)=='<')
{
stack1.push(optr);
}
else if(Precede(topelem,optr)=='=')
{
optr =stack1.pop();
exper1[i++] = optr;
exper1[i++] = ' ';
}
else if(Precede(topelem,optr)=='>')
{
optr =stack1.pop();
exper1[i++] = optr;
exper1[i++] = ' ';
}
}
else if(token.equals("(")) {
optr = token.charAt(0);
stack1.push(optr);
}
else if(token.equals(")")) {
optr = stack1.pop();
while(optr!='(')
{
exper1[i++] = optr;
exper1[i++] = ' ';
optr = stack1.pop();
}
}
else
{
optr = token.charAt(0);
//System.out.println(optr);
exper1[i++]=optr;
exper1[i++] = ' ';
}
}
while(!stack1.isEmpty())
{
optr = stack1.pop();
if(optr!='#'){
exper1[i++] = optr;
exper1[i++] = ' ';
}
}
return ToString(exper1);
}
//@Override
private boolean isOperator(String token)
{
return (token.equals("+") || token.equals("-") ||token.equals("*") || token.equals("/") );
}
public static String ToString(char[] exper1){
int length = exper1.length;
String str=" ";
for(int i=0;i<length;i++)
{
str=str+exper1[i];
}
return str;
}
}7.实验截图
