まず、ラボレポートカバー
コース:Javaプログラミングのクラス:クラス1753名:Haoran学生ID:20175318
講師:Loujia鵬実験日:2019年5月31日
実験時間:13:45 - 15時25分テスト番号:実験5
実験名:ネットワークプログラミングとセキュリティ
第二に、実験的なコンテンツとプロセス
タスク
実験的な要件
- 1.ペアのペアプログラミング
- 2.インフィックス発現転写後置表現を達成するノードの機能MyBC.java
- 3.ペアは、コールの機能実装後置式で上記の関数から得られた発現を達成MyDC.java
原則
式書き込ま二つのオペランドの間に、オペレータは、1 + 2 *(3-4)+5として、「インフィックス式」と呼びます。中置式で、オペレータは、括弧オペレータを変更するための操作の順序を異なる優先順位を持っているので、そのまま左から右へ順に評価することができません。
オペレータは、上記* + 1234-- + 5のpostfixに変換することができるように、「後置」中置式と呼ばれる2つのオペランド式の後に書き込まれます。いいえ後置式は、オペレータと優先順位なし括弧ません。デマンド値演算部の法則に沿って、左から右へのPostfix表情評価プロセスは厳密順序で行うことができます。
式の評価アルゴリズムは、2つのステップで実行:①中置サフィックスを回し、②評価後置式。
後置スタックから求め中央の共役は、以下の擬似コードを使用してもよいです。
- スタックの確立は、ストレージ・オペレータは、最初のスタックが空です。
- オペランドが発生した場合、右スキャン共役式に左、直接出力から、セパレータ空間として出力する2つのオペランドを。
- もしスタック、スタックにスタックの最上部よりも高いレベル、またはスタックと出力の上部を出るの上部に比べて、オペレータが発生した場合、セパレータとしての空間の、出力。
- 彼らは括弧を残している場合は、プッシュする;あなたは右括弧が発生した場合のみ、左括弧を後退されるまで、それは、出力を解除積み重ねてきました。
- スタックが空になると、結果は後置式の出力です。
後置表現擬似コードを次のように
- セットオペランドスタックは、スタックが空で開始。
- Postfixの式はプッシュし、オペランドの場合には、左から右にスキャンし、
- オペレータ、オペレータにスタック出口からの二つの要素終了する権利の場合には、終了した後スキャン後置式までスタックに、次に、オペレータに操作の結果を残したと。
- 後置式の終わりまで、上記の手順を繰り返し、スタックは、表現の必要な値の最後の数字です。
テストコード
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);
}
}
スクリーンショットの業績
タスクII
実験的な要件
- 1.クライアントの担当者、サーバー責任
- 2.ケアホームの義務を、彼は質問しなかったことを証明するための試験に合格します
- 3. Javaのソケットは、TCPを使用して、送信をクライアント/サーバーベースの機能を実装します
- 4.次に、クライアントは、ポストフィックス表記関数にMyBC.javaの中置式を呼び出し、後置表現は、ネットワークを介してサーバに送信され、ユーザは中置式を入力することを可能にします
- サーバは、後置式、関数呼び出しMyDC.javaの後置式計算値を受け取り、クライアントに結果を送信します
- 6.クライアントは、サーバーから送信された結果を表示します
原則
『のjava.net.Socket』:
- ソケットは、ネットワーク接続のエンドポイントです。Javaでソケットを表すためにjava.net.Socketオブジェクトを使用して。
- 公共のソケット(のjava.lang.Stringホスト、int型ポート):ソケットを作成するには、次のような、ソケットのコンストラクタを使用することができます。ここで、ホストがリモートマシン名またはIPアドレスで、ポートは、リモートアプリケーションのポート番号です。
Socketクラスの成功したインスタンスが作成されると、バイトストリームを送信または受信するために使用することができます。バイトストリームを送信するには、まずにjava.io.OutputStreamオブジェクトを取得する方法のgetOutputStream Socketクラスを呼び出す必要があります。テキストリモートアプリケーションを送信するには、OutputStreamのオブジェクトは通常、戻りjava.io.PrintWriterオブジェクトから構成されています。接続の他端からバイトストリームを受信するためには、それは、java.io.InputStreamを返し、ソケットクラスのgetInputStreamメソッドを呼び出すことができます。
"Java.net.ServerSocket":ServerSocketのは、サーバソケットの実装です。ソケットとServerSocketの異なる役割サーバソケットは、クライアントからの接続要求を待っています。サーバソケットが接続要求を取得すると、それはソケットのインスタンスを作成し、通信クライアントを処理するために。
テストコード
调用任务一中的MyBC.java和MyDC.java,将中缀表达式转后缀表达式,并对后缀表达式求值。
查看自己电脑的IP地址:
Address.java
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 Client2 {
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 Server2 {
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);
}
//}
}
}
实验截图
任务三
实验要求
- 1.一人负责客户端,一人负责服务器
- 2.注意责任归宿,要会通过测试证明自己没有问题
- 3.基于Java Socket实现客户端/服务器功能,传输方式用TCP
- 4.客户端让用户输入中缀表达式,然后把中缀表达式调用MyBC.java的功能转化为后缀表达式,把后缀表达式用3DES或AES算法加密后通过网络把密文发送给服务器
- 5.服务器接收到后缀表达式表达式后,进行解密(和客户端协商密钥,可以用数组保存),然后调用MyDC.java的功能计算后缀表达式的值,把结果发送给客户端
- 6.客户端显示服务器发送过来的结果
实验原理
- 实现DES加密主要有以下几个步骤:
- 对称密钥的生成和保存;
- 使用对称密钥进行加密和解密;
- 从文件中获取加密时使用的密钥,使用密钥进行解密。
实验代码
客户端
import javax.crypto.Cipher;
import java.io.*;
import java.net.Socket;
import java.security.Key;
import java.util.Scanner;
public class Client3 {
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 Server3 {
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);
}
}
}
实验截图
任务四
实验要求
- 1.一人负责客户端,一人负责服务器
- 2.注意责任归宿,要会通过测试证明自己没有问题
- 3.基于Java Socket实现客户端/服务器功能,传输方式用TCP
- 4.客户端让用户输入中缀表达式,然后把中缀表达式调用MyBC.java的功能转化为后缀表达式,把后缀表达式用3DES或AES算法加密通过网络把密文发送给服务器
- 5.客户端和服务器用DH算法进行3DES或AES算法的密钥交换
- 6.服务器接收到后缀表达式表达式后,进行解密,然后调用MyDC.java的功能计算后缀表达式的值,把结果发送给客户端
- 7.客户端显示服务器发送过来的结果
实验原理
- 执行密钥协定的标准算法是DH算法(Diffie-Hellman算法),分为以下两步:
- 创建DH公钥和私钥;
- 创建共享密钥。
实验代码
客户端
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
import java.net.Socket;
import java.security.Key;
import java.util.Optional;
import java.util.Scanner;
public class Client4 {
public static void main(String args[]) {
MyBC mybc = new MyBC();
Socket mysocket;
DataInputStream in = null;
DataOutputStream out = null;
Scanner scanner = new Scanner(System.in);
String str;
try {
mysocket = new Socket("192.168.232.1", 5318);
System.out.println("客户端启动...");
in = new DataInputStream(mysocket.getInputStream());
out = new DataOutputStream(mysocket.getOutputStream());
System.out.println("请输入中缀表达式:");
str = scanner.nextLine();
Key_DH.DH("Cpub.dat","Cpri.dat");
FileInputStream fp = new FileInputStream("Cpub.dat");
ObjectInputStream bp = new ObjectInputStream(fp);
Key kp = (Key) bp.readObject();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(kp);
byte[] kb = baos.toByteArray();
out.writeUTF(kb.length + "");
for (int i = 0; i < kb.length; i++) {
out.writeUTF(kb[i] + "");
}
Thread.sleep(1000);
int len = Integer.parseInt(in.readUTF());
byte np[] = new byte[len];
for (int i = 0;i<len;i++) {
String temp = in.readUTF();
np[i] = Byte.parseByte(temp);
}
ObjectInputStream ois = new ObjectInputStream (new ByteArrayInputStream (np));
Key k2 = (Key)ois.readObject();;
FileOutputStream f2 = new FileOutputStream("Spub.dat");
ObjectOutputStream b2 = new ObjectOutputStream(f2);
b2.writeObject(k2);
KeyAgree.DH("Spub.dat","Cpri.dat");
FileInputStream f = new FileInputStream("sb.dat");
byte[] keysb = new byte[24];
f.read(keysb);
System.out.println("公共密钥:");
for (int i = 0;i<24;i++) {
System.out.print(keysb[i]+",");
}
System.out.println("");
SecretKeySpec k = new SecretKeySpec(keysb, "DESede");
Cipher cp = Cipher.getInstance("DESede");
cp.init(Cipher.ENCRYPT_MODE, k);
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] + "");
}
String s = in.readUTF(); //in读取信息,堵塞状态
System.out.println("客户收到服务器的回应:" + s);
} catch (Exception e) {
System.out.println("服务器已断开" + e);
}
}
}
服务器
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.security.Key;
public class Server4 {
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());
Key_DH.DH("Spub.dat","Spri.dat");
int len = Integer.parseInt(in.readUTF());
byte np[] = new byte[len];
for (int i = 0;i<len;i++) {
String temp = in.readUTF();
np[i] = Byte.parseByte(temp);
}
ObjectInputStream ois = new ObjectInputStream (new ByteArrayInputStream (np));
Key k2 = (Key)ois.readObject();;
FileOutputStream f2 = new FileOutputStream("Cpub.dat");
ObjectOutputStream b2 = new ObjectOutputStream(f2);
b2.writeObject(k2);
FileInputStream fp = new FileInputStream("Spub.dat");
ObjectInputStream bp = new ObjectInputStream(fp);
Key kp = (Key) bp.readObject();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(kp);
byte[] kb = baos.toByteArray();
out.writeUTF(kb.length + "");
for (int i = 0; i < kb.length; i++) {
out.writeUTF(kb[i] + "");
}
KeyAgree.DH("Cpub.dat","Spri.dat");
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 f = new FileInputStream("sb.dat");
byte[] keysb = new byte[24];
f.read(keysb);
System.out.println("公共密钥:");
for (int i = 0;i<24;i++) {
System.out.print(keysb[i]+",");
}
System.out.println("");
SecretKeySpec k = new SecretKeySpec(keysb, "DESede");
// 解密
Cipher cp = Cipher.getInstance("DESede");
cp.init(Cipher.DECRYPT_MODE, k);
byte[] ptext = cp.doFinal(ctext);
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);
}
}
}
实验截图
任务五
实验要求
- 1.一人负责客户端,一人负责服务器
- 2.注意责任归宿,要会通过测试证明自己没有问题
- 3.基于Java Socket实现客户端/服务器功能,传输方式用TCP
- 4.客户端让用户输入中缀表达式,然后把中缀表达式调用MyBC.java的功能转化为后缀表达式,把后缀表达式用3DES或AES算法加密通过网络把密文和明文的MD5値发送给服务器
- 5.客户端和服务器用DH算法进行3DES或AES算法的密钥交换
- 6.服务器接收到后缀表达式表达式后,进行解密,解密后计算明文的MD5值,和客户端传来的MD5进行比较,一致则调用MyDC.java的功能计算后缀表达式的值,把结果发送给客户端
- 7.客户端显示服务器发送过来的结果
实验原理 - 可以使用Java计算指定字符串的消息摘要。java.security包中的MessageDigest类提供了计算消息摘要的方法,首先生成对象,执行其update()方法可以将原始数据传递给该对象,然后执行其digest( )方法即可得到消息摘要。
实验代码
客户端
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
import java.net.Socket;
import java.security.Key;
import java.util.Scanner;
public class Client5 {
public static void main(String args[]) {
MyBC mybc = new MyBC();
Socket mysocket;
DataInputStream in = null;
DataOutputStream out = null;
Scanner scanner = new Scanner(System.in);
String str;
try {
mysocket = new Socket("192.168.232.1", 5318);
System.out.println("客户端启动...");
in = new DataInputStream(mysocket.getInputStream());
out = new DataOutputStream(mysocket.getOutputStream());
System.out.println("请输入中缀表达式:");
str = scanner.nextLine();
Key_DH.DH("Cpub.dat","Cpri.dat");
FileInputStream fp = new FileInputStream("Cpub.dat");
ObjectInputStream bp = new ObjectInputStream(fp);
Key kp = (Key) bp.readObject();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(kp);
byte[] kb = baos.toByteArray();
out.writeUTF(kb.length + "");
for (int i = 0; i < kb.length; i++) {
out.writeUTF(kb[i] + "");
}
Thread.sleep(500);
int len = Integer.parseInt(in.readUTF());
byte np[] = new byte[len];
for (int i = 0;i<len;i++) {
String temp = in.readUTF();
np[i] = Byte.parseByte(temp);
}
ObjectInputStream ois = new ObjectInputStream (new ByteArrayInputStream (np));
Key k2 = (Key)ois.readObject();;
FileOutputStream f2 = new FileOutputStream("Spub.dat");
ObjectOutputStream b2 = new ObjectOutputStream(f2);
b2.writeObject(k2);
KeyAgree.DH("Spub.dat","Cpri.dat");
FileInputStream f = new FileInputStream("sb.dat");
byte[] keysb = new byte[24];
f.read(keysb);
System.out.println("公共密钥:");
for (int i = 0;i<24;i++) {
System.out.print(keysb[i]+",");
}
System.out.println("");
SecretKeySpec k = new SecretKeySpec(keysb, "DESede");
Cipher cp = Cipher.getInstance("DESede");
cp.init(Cipher.ENCRYPT_MODE, k);
mybc.conversion(str);
String str1 = mybc.getMessage();
byte ptext[] = str1.getBytes("UTF-8");
String ptextMd5 = DigestPass.DP(str1);
System.out.println("明文的MD5值:"+ptextMd5);
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] + "");
}
out.writeUTF(ptextMd5);
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;
import java.security.Key;
public class Server5 {
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());
Key_DH.DH("Spub.dat","Spri.dat");
int len = Integer.parseInt(in.readUTF());
byte np[] = new byte[len];
for (int i = 0;i<len;i++) {
String temp = in.readUTF();
np[i] = Byte.parseByte(temp);
}
ObjectInputStream ois = new ObjectInputStream (new ByteArrayInputStream(np));
Key k2 = (Key)ois.readObject();;
FileOutputStream f2 = new FileOutputStream("Cpub.dat");
ObjectOutputStream b2 = new ObjectOutputStream(f2);
b2.writeObject(k2);
FileInputStream fp = new FileInputStream("Spub.dat");
ObjectInputStream bp = new ObjectInputStream(fp);
Key kp = (Key) bp.readObject();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(kp);
byte[] kb = baos.toByteArray();
out.writeUTF(kb.length + "");
for (int i = 0; i < kb.length; i++) {
out.writeUTF(kb[i] + "");
}
KeyAgree.DH("Cpub.dat","Spri.dat");
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);
}
String check = in.readUTF();
// 获取密钥
FileInputStream f = new FileInputStream("sb.dat");
byte[] keysb = new byte[24];
f.read(keysb);
System.out.println("公共密钥:");
for (int i = 0;i<24;i++) {
System.out.print(keysb[i]+",");
}
System.out.println("");
SecretKeySpec k = new SecretKeySpec(keysb, "DESede");
// 解密
Cipher cp = Cipher.getInstance("DESede");
cp.init(Cipher.DECRYPT_MODE, k);
byte[] ptext = cp.doFinal(ctext);
System.out.println("");
// 显示明文
String p = new String(ptext, "UTF8");
String pMd5 = DigestPass.DP(p);
System.out.println("被解密明文的MD5值:"+pMd5);
if (pMd5.equals(check)){
System.out.println("和客户端的MD5值一致");
System.out.println("计算后缀表达式" + p);
out.writeUTF(mydc.evaluate(p)+"");
}
else {
System.out.println("警告:和客户端的MD5值不一致!");
}
} catch (Exception e) {
System.out.println("客户已断开" + e);
}
}
}
实验截图
实验体会
此次实验的内容主要是是网络编程,同时结合密码学算法。在这次实验之前,虽然有学过Java网络编程理论内容,但真正自己动手编程时,发现并不太理解如何实现客户端和服务器,在和结对伙伴一起复习网络编程和密码学算法相关内容后,我们参考书上代码和Java 密码学算法,最终完成了实验,在这个过程中,我们复习了相关知识,也学到了很多信息安全的内容。
代码托管
码云链接