2018-2019-2 20175216张雪原 实验五《网络编程与安全》实验报告
实验五 网络编程与安全-1
两人一组结对编程：
-
- 参考http://www.cnblogs.com/rocedu/p/6766748.html#SECDSA
-
- 结对实现中缀表达式转后缀表达式的功能 MyBC.java
-
- 结对实现从上面功能中获取的表达式中实现后缀表达式求值的功能,调用MyDC.java
-
- 上传测试代码运行结果截图和码云链接
实验原理
-
栈的应用：栈 (Stack)是一种只允许在表尾插入和删除的线性表，有先进后出（FILO），后进先出(LIFO)的特点。允许插入和删除的一端称为栈顶(top)，另一端称为栈底(bottom)。
-
由中缀式求得后缀式可以使用栈，伪代码如下：
设立一个栈，存放运算符，首先栈为空；
从左到右扫描中缀式，若遇到操作数，直接输出，并输出一个空格作为两个操作数的分隔符；
若遇到运算符，则与栈顶比较，比栈顶级别高则进栈，否则退出栈顶元素并输出，然后输出一个空格作分隔符；
若遇到左括号，进栈；若遇到右括号，则一直退栈输出，直到退到左括号止。
当栈变成空时，输出的结果即为后缀表达式。
后缀式的运算
- dc运算符：
+: 依次弹出w1与w2，将w2+w1压栈。精度为结果值精度
-: 依次弹出w1与w2，将w2-w1压栈
: 依次弹出w1与w2，将w2w1压栈。精度为结果值精度与precision中较大值
/ : 依次弹出w1与w2，将w2/w1压栈。精度为precision
求值伪代码如下：
- 设置一个操作数栈，开始栈为空；
从左到右扫描后缀表达式，遇操作数，进栈；
若遇运算符，则从栈中退出两个元素，先退出的放到运算符的右边，后退出的放到运算符左边，运算后的结果再进栈，直到后缀表达式扫描完毕。
import java.util.Stack;
import java.util.StringTokenizer;
/**
* Created by zxy on 2019/5/28.
*/
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()) {
System.out.println(tokenizer.nextToken());
}*/
while (tokenizer.hasMoreTokens())
{
token = tokenizer.nextToken();
//如果是运算符，调用isOperator
if (isOperator(token))
{
//调用Precede比较优先级
topelem=stack1.peek();
optr = token.charAt(0);
if(Precede(topelem,optr)=='<')
{
stack1.push(optr);
}
else if(Precede(topelem,optr)=='=')
{
/*if(optr==')'){
optr=stack1.pop();
while(optr!='('){
exper1[i++]=optr;
exper1[i++]=' ';
optr=stack1.pop();
}
}*/
optr =stack1.pop();
exper1[i++] = optr;
exper1[i++] = ' ';
}
else if(Precede(topelem,optr)=='>')
{
optr =stack1.pop();
//从运算符栈中退出栈顶元素并放入后缀表达式exper1
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//如果是操作数
//操作数放入后缀表达式exper1
{
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++] = ' ';
}
}
//System.out.println(exper1);
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];
}
//System.out.println(str);
return str;
}
/*public static void main(String[] args) {
String pp=null;
MyBC turner = new MyBC();
pp=turner.turn("( 1 + 2 ) * ( ( 8 - 2 ) / ( 7 - 4 ) )");
System.out.println(pp);
}*/
}
import java.util.StringTokenizer;
import java.util.Stack;
/**
* Created by zxy on 2019/5/28.
*/
public class MyDC2
{
// 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 MyDC2() {
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 =Integer.parseInt(stack.pop());
op2 =stack.pop();
//从栈中弹出操作数
//op1 =Integer.parseInt(stack.pop());
op1 =stack.pop();
//根据运算符和两个操作数调用evalSingleOp计算result;
result = evalSingleOp(token.charAt(0),op1,op2);
//计算result入栈;
stack.push(result);
}
else//如果是操作数
//操作数入栈;
stack.push(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;
}
}
import java.util.Scanner;
import static org.junit.Assert.*;
/**
* Created by lxkj on 2017/6/2.
*/
import java.util.Scanner;
public class MyBCTest {
public static void main (String[] args) {
String expression1=null,expression2=null, again=null;
int result,i=0,length=0;
try
{
Scanner in = new Scanner(System.in);
do
{
MyDC2 evaluator = new MyDC2();
MyBC turner = new MyBC();
System.out.println ("Enter a valid midfix expression: ");
expression1 = in.nextLine();
//System.out.println(expression1);
expression2 = turner.turn(expression1);
while(expression2.charAt(i)!=' '){
length++;
i++;
}
//length 表示字符串包括‘ ’的字符个数
expression2 = expression2.substring(1,length-1);
//System.out.println(expression2);
result = evaluator.evaluate (expression2);
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 (again.equalsIgnoreCase("y"));
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
实验结果截图：
网络编程与安全-2
结对编程：1人负责客户端，一人负责服务器
-
- 注意责任归宿，要会通过测试证明自己没有问题
-
- 基于Java Socket实现客户端/服务器功能，传输方式用TCP
-
- 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式通过网络发送给服务器
-
- 服务器接收到后缀表达式，调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
-
- 客户端显示服务器发送过来的结果
-
- 上传测试结果截图和码云链接
结对：
20175202负责服务器
20175216负责客户端
- 上传测试结果截图和码云链接
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
/**
* Created by zxy on 2019/5/28.
*/
public class Client {
public static final String IP_ADDR = "127.0.0.1";//服务器地址
public static final int PORT = 12345;//服务器端口号
public static void main(String[] args) {
System.out.println("客户端启动...");
System.out.println("当接收到服务器端字符为 "OK" 的时候, 客户端将终止
");
while (true) {
Socket socket = null;
try {
socket = new Socket(IP_ADDR, PORT);
DataInputStream input = new DataInputStream(socket.getInputStream());
DataOutputStream out = new DataOutputStream(socket.getOutputStream());
System.out.print("请输入: ");
String str = new BufferedReader(new InputStreamReader(System.in)).readLine();
MyBC turner = new MyBC();
String str1 = turner.turn(str);
int length=0,i=0;
while(str1.charAt(i)!=' '){
length++;
i++;
}
String str2 = str1.substring(1,length-1);
out.writeUTF(str2);
String ret = input.readUTF();
System.out.println("服务器端返回过来的是: " + ret);
out.close();
input.close();
} catch (Exception e) {
System.out.println("客户端异常:" + e.getMessage());
} finally {
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
socket = null;
System.out.println("客户端 finally 异常:" + e.getMessage());
}
}
}
}
}
}
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
/**
* Created by zxy on 2019/5/28.
*/
public class Server {
public static final int PORT = 12345;//监听的端口号
public static void main(String[] args) {
System.out.println("服务器启动...
");
Server server = new Server();
server.init();
}
public void init() {
try {
ServerSocket serverSocket = new ServerSocket(PORT);
while (true) {
// 一旦有堵塞, 则表示服务器与客户端获得了连接
Socket client = serverSocket.accept();
// 处理这次连接
new HandlerThread(client);
}
} catch (Exception e) {
System.out.println("服务器异常: " + e.getMessage());
}
}
private class HandlerThread implements Runnable {
private Socket socket;
public HandlerThread(Socket client) {
socket = client;
new Thread(this).start();
}
public void run() {
try {
// 读取客户端数据
DataInputStream input = new DataInputStream(socket.getInputStream());
String clientInputStr = input.readUTF();//这里要注意和客户端输出流的写方法对应,否则会抛 EOFException
// 处理客户端数据
System.out.println("客户端发过来的内容:" + clientInputStr);
MyDC2 evalute = new MyDC2();
int result = evalute.evaluate(clientInputStr);
// 向客户端回复信息
DataOutputStream out = new DataOutputStream(socket.getOutputStream());
System.out.print("计算结果: ");
// 发送键盘输入的一行
//String s = new BufferedReader(new InputStreamReader(System.in)).readLine();
out.writeUTF(String.valueOf(result));
out.close();
input.close();
} catch (Exception e) {
System.out.println("服务器 run 异常: " + e.getMessage());
} finally {
if (socket != null) {
try {
socket.close();
} catch (Exception e) {
socket = null;
System.out.println("服务端 finally 异常:" + e.getMessage());
}
}
}
}
}
}
实验截图
客户端
服务器
网络编程与安全-3
加密结对编程：1人负责客户端，一人负责服务器
-
- 注意责任归宿，要会通过测试证明自己没有问题
-
- 基于Java Socket实现客户端/服务器功能，传输方式用TCP
-
- 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密后通过网络把密文发送给服务器
-
- 服务器接收到后缀表达式表达式后，进行解密（和客户端协商密钥，可以用数组保存），然后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
-
- 客户端显示服务器发送过来的结果
-
- 上传测试结果截图和码云链接
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
public class Server2 {
public static final int PORT = 12345;//监听的端口号
public static void main(String[] args) {
System.out.println("服务器启动...
");
Server server = new Server();
server.init();
}
public void init() {
try {
ServerSocket serverSocket = new ServerSocket(PORT);
while (true) {
// 一旦有堵塞, 则表示服务器与客户端获得了连接
Socket client = serverSocket.accept();
// 处理这次连接
new HandlerThread(client);
}
} catch (Exception e) {
System.out.println("服务器异常: " + e.getMessage());
}
}
private class HandlerThread implements Runnable {
private Socket socket;
public HandlerThread(Socket client) {
socket = client;
new Thread(this).start();
}
public void run() {
try {
// 读取客户端数据
DataInputStream input = new DataInputStream(socket.getInputStream());
String clientInputStr = input.readUTF();//这里要注意和客户端输出流的写方法对应,否则会抛 EOFException
// 处理客户端数据
System.out.println("客户端发过来的内容:" + clientInputStr);
MyDC2 evalute = new MyDC2();
SDec sDec = new SDec();
int result = evalute.evaluate(clientInputStr);
// 向客户端回复信息
DataOutputStream out = new DataOutputStream(socket.getOutputStream());
System.out.print("计算结果: ");
// 发送键盘输入的一行
//String s = new BufferedReader(new InputStreamReader(System.in)).readLine();
out.writeUTF(String.valueOf(result));
out.close();
input.close();
} catch (Exception e) {
System.out.println("服务器 run 异常: " + e.getMessage());
} finally {
if (socket != null) {
try {
socket.close();
} catch (Exception e) {
socket = null;
System.out.println("服务端 finally 异常:" + e.getMessage());
}
}
}
}
}
}
/**
* Created by lxkj on 2017/6/2.
*/
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
public class Client2 {
public static final String IP_ADDR = "127.0.0.1";//服务器地址
public static final int PORT = 12345;//服务器端口号
public static void main(String[] args) {
System.out.println("客户端启动...");
System.out.println("当接收到服务器端字符为 "OK" 的时候, 客户端将终止
");
while (true) {
Socket socket = null;
try {
//创建一个流套接字并将其连接到指定主机上的指定端口号
socket = new Socket(IP_ADDR, PORT);
//读取服务器端数据
DataInputStream input = new DataInputStream(socket.getInputStream());
//向服务器端发送数据
DataOutputStream out = new DataOutputStream(socket.getOutputStream());
System.out.print("请输入: ");
String str = new BufferedReader(new InputStreamReader(System.in)).readLine();
MyBC turner = new MyBC();
Skey_DES skey_des = new Skey_DES();
skey_des.key_DES();
Skey_kb skey_kb = new Skey_kb();
skey_kb.key();
/*产生密钥*/
SEnc sEnc = new SEnc();
String str1 = turner.turn(str);
int length=0,i=0;
while(str1.charAt(i)!=' '){
length++;
i++;
}
String str2 = str1.substring(1,length-1);
out.writeUTF(str2);
String ret = input.readUTF();
System.out.println("服务器端返回过来的是: " + ret);
// 如接收到 "OK" 则断开连接
/*if ("OK".equals(ret)) {
System.out.println("客户端将关闭连接");
Thread.sleep(500);
break;
}*/
out.close();
input.close();
} catch (Exception e) {
System.out.println("客户端异常:" + e.getMessage());
} finally {
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
socket = null;
System.out.println("客户端 finally 异常:" + e.getMessage());
}
}
}
}
}
}
import java.io.*;
import javax.crypto.*;
/**
* Created by zxy on 2019/5/28.
*/
public class Skey_DES{
public static void key_DES()
throws Exception{
KeyGenerator kg=KeyGenerator.getInstance("DESede");
kg.init(168);
SecretKey k=kg.generateKey( );
FileOutputStream f=new FileOutputStream("key1.dat");
ObjectOutputStream b=new ObjectOutputStream(f);
b.writeObject(k);
}
}
import java.io.*;
import java.security.*;
/**
* Created by zxy on 2019/5/28.
*/
public class Skey_kb{
public static void key() throws Exception{
FileInputStream f=new FileInputStream("key1.dat");
ObjectInputStream b=new ObjectInputStream(f);
Key k=(Key)b.readObject( );
byte[ ] kb=k.getEncoded( );
FileOutputStream f2=new FileOutputStream("keykb1.dat");
f2.write(kb);
// 打印密钥编码中的内容
System.out.println("密钥为：");
for(int i=0;i<kb.length;i++){
System.out.print(kb[i]+",");
}
System.out.println();
}
}
实验截图
客户端
服务器
网络编程与安全-4
密钥分发结对编程：1人负责客户端，一人负责服务器
-
- 注意责任归宿，要会通过测试证明自己没有问题
-
- 基于Java Socket实现客户端/服务器功能，传输方式用TCP
-
- 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密通过网络把密文发送给服务器
-
- 客户端和服务器用DH算法进行3DES或AES算法的密钥交换
-
- 服务器接收到后缀表达式表达式后，进行解密，然后调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
-
- 客户端显示服务器发送过来的结果
-
- 上传测试结果截图和码云链接
/**
* Created by lxkj on 2017/6/2.
*/
import javax.crypto.spec.DHParameterSpec;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.math.BigInteger;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
public class Key_DH{
private static final byte skip1024ModulusBytes[] = {
(byte)0xF4, (byte)0x88, (byte)0xFD, (byte)0x58,
(byte)0x4E, (byte)0x49, (byte)0xDB, (byte)0xCD,
(byte)0x20, (byte)0xB4, (byte)0x9D, (byte)0xE4,
(byte)0x91, (byte)0x07, (byte)0x36, (byte)0x6B,
(byte)0x33, (byte)0x6C, (byte)0x38, (byte)0x0D,
(byte)0x45, (byte)0x1D, (byte)0x0F, (byte)0x7C,
(byte)0x88, (byte)0xB3, (byte)0x1C, (byte)0x7C,
(byte)0x5B, (byte)0x2D, (byte)0x8E, (byte)0xF6,
(byte)0xF3, (byte)0xC9, (byte)0x23, (byte)0xC0,
(byte)0x43, (byte)0xF0, (byte)0xA5, (byte)0x5B,
(byte)0x18, (byte)0x8D, (byte)0x8E, (byte)0xBB,
(byte)0x55, (byte)0x8C, (byte)0xB8, (byte)0x5D,
(byte)0x38, (byte)0xD3, (byte)0x34, (byte)0xFD,
(byte)0x7C, (byte)0x17, (byte)0x57, (byte)0x43,
(byte)0xA3, (byte)0x1D, (byte)0x18, (byte)0x6C,
(byte)0xDE, (byte)0x33, (byte)0x21, (byte)0x2C,
(byte)0xB5, (byte)0x2A, (byte)0xFF, (byte)0x3C,
(byte)0xE1, (byte)0xB1, (byte)0x29, (byte)0x40,
(byte)0x18, (byte)0x11, (byte)0x8D, (byte)0x7C,
(byte)0x84, (byte)0xA7, (byte)0x0A, (byte)0x72,
(byte)0xD6, (byte)0x86, (byte)0xC4, (byte)0x03,
(byte)0x19, (byte)0xC8, (byte)0x07, (byte)0x29,
(byte)0x7A, (byte)0xCA, (byte)0x95, (byte)0x0C,
(byte)0xD9, (byte)0x96, (byte)0x9F, (byte)0xAB,
(byte)0xD0, (byte)0x0A, (byte)0x50, (byte)0x9B,
(byte)0x02, (byte)0x46, (byte)0xD3, (byte)0x08,
(byte)0x3D, (byte)0x66, (byte)0xA4, (byte)0x5D,
(byte)0x41, (byte)0x9F, (byte)0x9C, (byte)0x7C,
(byte)0xBD, (byte)0x89, (byte)0x4B, (byte)0x22,
(byte)0x19, (byte)0x26, (byte)0xBA, (byte)0xAB,
(byte)0xA2, (byte)0x5E, (byte)0xC3, (byte)0x55,
(byte)0xE9, (byte)0x2F, (byte)0x78, (byte)0xC7
};
// The SKIP 1024 bit modulus
private static final BigInteger skip1024Modulus
= new BigInteger(1, skip1024ModulusBytes);
// The base used with the SKIP 1024 bit modulus
private static final BigInteger skip1024Base = BigInteger.valueOf(2);
public static void main(String args[ ]) throws Exception{
DHParameterSpec DHP=
new DHParameterSpec(skip1024Modulus,skip1024Base);
KeyPairGenerator kpg= KeyPairGenerator.getInstance("DH");
kpg.initialize(DHP);
KeyPair kp=kpg.genKeyPair();
PublicKey pbk=kp.getPublic();
PrivateKey prk=kp.getPrivate();
// 保存公钥
FileOutputStream f1=new FileOutputStream(args[0]);
ObjectOutputStream b1=new ObjectOutputStream(f1);
b1.writeObject(pbk);
// 保存私钥
FileOutputStream f2=new FileOutputStream(args[1]);
ObjectOutputStream b2=new ObjectOutputStream(f2);
b2.writeObject(prk);
}
}
/**
* Created by lxkj on 2017/6/2.
*/
import javax.crypto.KeyAgreement;
import javax.crypto.spec.SecretKeySpec;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.security.PrivateKey;
import java.security.PublicKey;
public class KeyAgree{
public static void main(String args[ ]) throws Exception{
// 读取对方的DH公钥
FileInputStream f1=new FileInputStream(args[0]);
ObjectInputStream b1=new ObjectInputStream(f1);
PublicKey pbk=(PublicKey)b1.readObject( );
//读取自己的DH私钥
FileInputStream f2=new FileInputStream(args[1]);
ObjectInputStream b2=new ObjectInputStream(f2);
PrivateKey prk=(PrivateKey)b2.readObject( );
// 执行密钥协定
KeyAgreement ka=KeyAgreement.getInstance("DH");
ka.init(prk);
ka.doPhase(pbk,true);
//生成共享信息
byte[ ] sb=ka.generateSecret();
for(int i=0;i<sb.length;i++){
System.out.print(sb[i]+",");
}
SecretKeySpec k=new SecretKeySpec(sb,"DESede");
}
}
实验截图
客户端
服务器
网络编程与安全-5
完整性校验结对编程：1人负责客户端，一人负责服务器
-
- 注意责任归宿，要会通过测试证明自己没有问题
-
- 基于Java Socket实现客户端/服务器功能，传输方式用TCP
-
- 客户端让用户输入中缀表达式，然后把中缀表达式调用MyBC.java的功能转化为后缀表达式，把后缀表达式用3DES或AES算法加密通过网络把密文和明文的MD5値发送给服务器
-
- 客户端和服务器用DH算法进行3DES或AES算法的密钥交换
-
- 服务器接收到后缀表达式表达式后，进行解密，解密后计算明文的MD5值，和客户端传来的MD5进行比较，一致则调用MyDC.java的功能计算后缀表达式的值，把结果发送给客户端
-
- 客户端显示服务器发送过来的结果
-
- 上传测试结果截图和码云链接
实验截图
客户端
服务器
实验问题
解决方法：关掉IDEA，重新打开。
实验总结
这次实验比前几次实验花费的时间更多，也比其他实验更难，以前学过的知识忘记了一部分，学习就是不断预习和不断复习，这样才能更快的去掌握一门课程。
| 步骤 | 耗时 | 百分比 |
|---|---|---|
| 需求分析 | 10min | 6.7% |
| 设计 | 25min | 16.7% |
| 代码实现 | 90min | 60% |
| 测试 | 10min | 6.7% |
| 分析总结 | 15min | 10% |