一 密钥分配

实习一密钥分配

一、实习目的

1．理解密钥管理的重要性；

2．掌握对称密码和公钥密码密钥管理的不同特性；

3．掌握密钥分发基本方法，能设计密钥分发方案

二、实习要求

1．实习前认真预习第2章的有关内容；

2．复习对称密码和公钥密码相关内容；

3．熟悉Java平台的JCE包有关类。

三、实习内容

假定两个用户A、B，用户A、B的通讯密钥为K，他们的公私钥对分别是K PUa、K PRa和K PUb、K PRb，他们要进行安全通讯，密钥分发与通信过程如1所示。

图1 基于混合加密的安全通信模型

Fig.1 Model of secure communication based on mixed cryptography

(1)根据图1所示，实现利用公钥密码算法分发对称密钥的过程。

实现的阶梯任务如下：

①以本地两个目录模拟两个用户，采用变量方式直接实现密钥的分发；

②实现算法的图形化方式，用户可以选择算法、参数、工作模式等；

③以文件方式管理密钥及明文、密文；

④采用Socket，建立安全通信过程；

⑤将方案移植到某个web应用中。

(2)按照(1)的阶梯任务，实现基于DH密钥协定的密钥分发。

四、实验过程

1.知识回顾

DES 是数据加密标准（Data Encryption Standard）的简称，出自IBM 的研究工作，并在1977 年被美国政府正式采纳。它是使用较为广泛的密钥系统，最初开发DES 是嵌入硬件中DES 特别是在保护金融数据的安全，如自动取款机中，使用较多。

在DES 中，使用了一个56 位的密钥以及附加的8 位奇偶校验位，产生最大64 位的分组大小。加密过程中，将加密的文本块分成两半。使用子密钥对其中一半应用循环功能，然后将输出与另一半进行“异或”运算；接着交换这两半。循环往复。DES 使用16 个循环，但最后一个循环不交换。

攻击DES，一般只能使用穷举的密钥搜索，即重复尝试各种密钥直到有一个符合为止。如果DES使用56 位的密钥，则可能的密钥数量是2 56 个，穷举难度较大。IBM曾对DES拥有几年的专利权，但在1983 年到期。

在公开密钥密码体制中，加密密钥（即公开密钥）PK是公开信息，而解密密钥（即秘密密钥）SK是需要保密的。加密算法E和解密算法D也都是公开的。虽然解密密钥SK是由公开密钥PK决定的，但却不能根据PK计算出SK。

正是基于这种理论，1978年出现了著名的RSA算法，它通常是先生成一对RSA 密钥，其中之一是保密密钥，由用户保存；另一个为公开密钥，可对外公开，甚至可在网络服务器中注册。为提高保密强度，RSA密钥至少为500位长，一般推荐使用1024位。这就使加密的计算量很大。为减少计算量，在传送信息时，常采用传统加密方法与公开密钥加密方法相结合的方式，即信息采用改进的DES或IDEA对话密钥加密，然后使用RSA密钥加密对话密钥和信息摘要。对方收到信息后，用不同的密钥解密并可核对信息摘要。

2.问题分析

(1)．对称密钥密码体系

对称密钥密码体系也叫密钥密码体系，它是指消息发送方和消息接收方必须使用相同的密钥，该密钥必须保密。发送方用该密钥对待发消息进行加密，然后将消息传输至接收方，接收方再用相同的密钥对收到的消息进行解密。这一过程可用数学形式来表示。消息发送方使用的加密函数encrypt有两个参数：密钥K 和待加密消息M，加密后的消息为E，E可以表示为E=encrypt(K，M)消息接收方使用的解密函数decrypt把这一过程逆过来，就产生了原来的消息

M=decrypt(K，E)=decrypt(K，encrypt(K，M))

(2)．非对称密钥密码体系

非对称密钥密码体系又叫公钥密码体系，它使用两个密钥：一个公共密钥PK和一个私有密钥SK。这两个密钥在数学上是相关的，并且不能由公钥计算出对应的私钥，同样也不能由私钥计算出对应的公钥。这种用两把密钥加密和解密的方法表示成如下数学形式。假设M表示一条消息，pub—a表示用户a的公共密钥，prv—a表示用户a的私有密钥，那么：

M=decrypt(pub—a，encrypt(prv—a，M))

3.算法分析及流程图

4．实验原理

(1) 利用java中的KeypairGenerator类创建公钥密钥对，工厂类KeypairGenerator的静态方法getInstance()可以获得KeypairGenerator类型对象。

(2) 方法getInstance()的参数为字符串类型，指定加密算法为RSA。

(3) RSA算法是使用整数进行加密运算的，RSA的公钥中包含两个信息：公钥对应的整数e和用于取模的整数n。对于明文m计算密文的公式是m e mod n。java中的BigInteger类中定义的modPow()方法可以计算m e mod n。

(4) RSA的私钥中包含两个信息：私钥对应的整数d和用于取模的整数n。计算明文的公式是：C e mod n。

5.类图

四．数据测试及结果

1

、利用DES 算法生成对称密钥Key ，运行程序后生成Key.dat 文件

2、利用RSA 算法生成公钥密钥对，将公钥存入A 文件夹下，将私钥存入B 文件夹下，运行程序后在A 文件夹下生成

Skey_RSA_pub.dat 文件，在B

文件夹下生成Skey_RSA_priv.dat 文件：

3.利用RSA加密算法对对称密钥加密，将加密后文件保存为Enc_RSA.dat文件，运行程序后：

4、利用RSA解密算法对密文进行解密，将解密后的文件Key.dat写入B文件夹下，运行程

序后B文件夹下生成Key.dat文件：

五．总结

通过本次实习，复习了DES和RSA的相关知识，通过使用DES算法和RSA算法实现密钥分发与通信过程，对密钥的分配过程有了一定的了解。让我更加认识到了加密算法的复杂，也更加巩固了我们的java知识，理解了公钥密码算法，掌握了RSA密码算法加解密过程的实现，学习了java.security.*和java.crypto.* 中相关类。对于KeypairGenerator，KeyPair，PublicKey，PrivateKey等类有了进一步的了解，RSA算法是使用整数进行加密运算的，RSA的公钥中包含两个信息公钥对应的整数e和用于取模的整数n。由于时间精力有限，本次实验还存在很多问题，在控制台进行明文的加密解密正常，图形界面的加密也正常，解密时调用Skey_RSA的解密方法时未能完成解密工作。加密方法的参数密钥由KeypairGenerator的静态方法getInstance()可以获得KeypairGenerator类型对象，所以在界面使用文本框获得key值会造成初始化方法init()的publickey参数错误，于是设置成密钥由系统生成。

Cipher cipher = Cipher.getInstance("RSA");// Cipher负责完成加密或解密工作，基于RSA cipher.init(Cipher.ENCRYPT_MODE, publicKey); // 根据公钥，对Cipher对象进行初始化

对称密码一般要求：

1、加密解密用相同的密钥

2、收发双方必须共享密钥

安全性要求：

1、密钥必须保密

2、没有密钥，解密不可行

3、知道算法和若干密文不足以确定密钥

公钥密码一般要求：

1、加密解密算法相同，但使用不同的密钥

2、发送方拥有加密或解密密钥，而接收方拥有另一个密钥

安全性要求：

1、两个密钥之一必须保密

2、无解密密钥，解密不可行

3、知道算法和其中一个密钥以及若干密文不能确定另一个密钥

源程序

//生成对称密钥

package Skey;

import java.io.FileOutputStream;

import java.io.ObjectOutputStream;

import javax.crypto.KeyGenerator;

import javax.crypto.SecretKey;

public class Skey_DES {

/**

* @param args

*/

// TODO Auto-generated method stub

//对称密钥的生成，并通过对象序列化方式保存在文件中

public static void main(String args[]) throws Exception

{

KeyGenerator kg=KeyGenerator.getInstance("DESede");//创建密钥生成器

kg.init(168);//初始化密钥生成器

SecretKey k=kg.generateKey( );//生成密钥

//通过对象序列化方式将密钥保存在文件中

FileOutputStream f1=new FileOutputStream("A/Key.dat");

ObjectOutputStream b1=new ObjectOutputStream(f1);

b1.writeObject(k);

}

}

//生成对称密钥对

package RSA;

import java.io.*;

import java.security.*;

import java.security.interfaces.RSAPrivateKey;

import java.security.interfaces.RSAPublicKey;

import javax.crypto.Cipher;

public class Skey_RSA {

// KeyGenerator提供对称密钥生成器的功能，支持各种算法

public KeyPairGenerator keyPairGen;

// SecretKey负责保存对称密钥

KeyPair keyPair;

RSAPrivateKey privateKey;

RSAPublicKey publicKey;

// Cipher负责完成加密或解密工作

private Cipher c;

// 该字节数组负责保存加密的结果

private byte[] cipherByte;

// KeyPairGenerator 类用于生成公钥和私钥对，基于RSA算法生成对象

/**

* @param args

*/

Skey_RSA() {

// KeyPairGenerator 类用于生成公钥和私钥对，基于RSA算法生成对象

KeyPairGenerator keyPairGen = null;

try {

keyPairGen = KeyPairGenerator.getInstance("RSA");

} catch (NoSuchAlgorithmException e) {

// TODO 自动生成的catch 块

e.printStackTrace();

}

// 初始化密钥对生成器,密钥大小为1024位

keyPairGen.initialize(1024);

// 生成一个密钥对，保存在keyPair中

KeyPair keyPair = keyPairGen.generateKeyPair();

// 得到私钥

RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

// 得到公钥

RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();

}

public RSAPrivateKey getPrivateKey() {

return privateKey;

}

public void setPrivateKey(RSAPrivateKey privateKey) {

this.privateKey = privateKey;

}

public RSAPublicKey getPublicKey() {

return publicKey;

}

public void setPublicKey(RSAPublicKey publicKey) {

this.publicKey = publicKey;

}

public byte[] encrypt(RSAPublicKey publicKey, byte[] srcBytes) { if (publicKey != null) {

try {

// Cipher负责完成加密或解密工作，基于RSA

Cipher cipher = Cipher.getInstance("RSA");

// 根据公钥，对Cipher对象进行初始化

cipher.init(Cipher.ENCRYPT_MODE, publicKey);

// 加密，结果保存进resultBytes

byte[] resultBytes = cipher.doFinal(srcBytes);

return resultBytes;

} catch (Exception e) {

e.printStackTrace();

}

}

return null;

}

public byte[] decrypt(RSAPrivateKey privateKey, byte[] encBytes) {

if (privateKey != null) {

try {

Cipher cipher = Cipher.getInstance("RSA");

// 根据私钥，对Cipher对象进行初始化

cipher.init(Cipher.DECRYPT_MODE, privateKey);

// 解密，结果保存进resultBytes

byte[] decBytes = cipher.doFinal(encBytes);

return decBytes;

} catch (Exception e)

{

e.printStackTrace();

}

}

return null;

}

public static void main(String[] args) throws Exception {

// 密钥对生成器KeyPairGenerator工厂，非对称加密算法：RSA,DSA

KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");

// 制定密钥长度

kpg.initialize(1024);

// 生成密钥对

KeyPair kp = kpg.genKeyPair();

PublicKey pbkey = kp.getPublic();

PrivateKey prkey = kp.getPrivate();

FileOutputStream f1 = new FileOutputStream("A/Skey_RSA_pub.dat");

ObjectOutputStream b1 = new ObjectOutputStream(f1);

b1.writeObject(pbkey);

FileOutputStream f2 = new FileOutputStream("B/Skey_RSA_priv.dat");

ObjectOutputStream b2 = new ObjectOutputStream(f2);

b2.writeObject(prkey);

Skey_RSA rsa = new Skey_RSA();

String msg = "rsa_安全编程技术";

System.out.println("明文是:" + msg);

// KeyPairGenerator 类用于生成公钥和私钥对，基于RSA算法生成对象

KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");

// 初始化密钥对生成器,密钥大小为1024位

keyPairGen.initialize(1024);

// 生成一个密钥对，保存在keyPair中

KeyPair keyPair = keyPairGen.generateKeyPair();

// 得到私钥

RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

// 得到公钥

RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();

// 用公钥加密

byte[] srcBytes = msg.getBytes();

byte[] resultBytes = rsa.encrypt(publicKey, srcBytes);

String result = new String(resultBytes);

System.out.println("用公钥加密后密文是:" + result);

// 用私钥解密

byte[] decBytes = rsa.decrypt(privateKey, resultBytes);

String dec = new String(decBytes);

System.out.println("用私钥解密后结果是:" + dec);

}

}

//公钥加密

package RSA;

import java.security.interfaces.RSAPublicKey;

import java.math.*;

import java.io.*;

public class Enc_RSA {

public static void main(String[] args) throws Exception{

BufferedReader in=new BufferedReader(new InputStreamReader(new FileInputStream("A/Key.dat")));

String s=in.readLine();

FileInputStream f=new FileInputStream("A/Skey_RSA_pub.dat");

ObjectInputStream b=new ObjectInputStream(f);

//公钥转换为RSA公钥

RSAPublicKey pbk=(RSAPublicKey)b.readObject();

//获取公钥参数：公钥对应的整数e，用于取模的整数n

BigInteger e=pbk.getPublicExponent();

BigInteger n=pbk.getModulus();

System.out.println("e="+e);

System.out.println("n="+n);

byte ptext[]=s.getBytes("UTF8");

BigInteger m=new BigInteger(ptext);

BigInteger c=m.modPow(e,n);

System.out.println("c="+c);

String cs=c.toString();

BufferedWriter out=

new BufferedWriter(new OutputStreamWriter(

new FileOutputStream("Enc_RSA.dat")));

out.write(cs,0,cs.length());

out.close();

}

}

//私钥解密

package RSA;

import java.security.interfaces.*;

import java.math.*;

import java.io.*;

public class Dec_RSA {

public static void main(String[] args) throws Exception{

BufferedReader in=new BufferedReader (

new InputStreamReader(

new FileInputStream("Enc_RSA.dat")));

String ctext=in.readLine();

BigInteger c=new BigInteger(ctext);

FileInputStream f=new FileInputStream("B/Skey_RSA_priv.dat");

ObjectInputStream b=new ObjectInputStream(f);

RSAPrivateKey prk=(RSAPrivateKey)b.readObject();

BigInteger d=prk.getPrivateExponent();

BigInteger n=prk.getModulus();

System.out.println("d="+d);

System.out.println("n="+n);

BigInteger m=c.modPow(d, n);

System.out.println("m="+m);

byte[]mt=m.toByteArray();

System.out.println("Plain Text is");

for(int i=0;i

System.out.print((char)mt[i]);

FileOutputStream f1=new FileOutputStream("B/Key.dat");

ObjectOutputStream b1=new ObjectOutputStream(f1);

b1.writeObject(m);

}

}

}

//图形界面

package Dec;

/*

* Window.java

*

* Created on __DATE__, __TIME__

*/

import java.io.IOException;

import java.security.interfaces.RSAPublicKey;

import java.util.Scanner;

/**

*

* @author __USER__

*/

public class Window extends javax.swing.JFrame {

/** Creates new form Window */

public Window() {

initComponents();

}

/** This method is called from within the constructor to

* initialize the form.

* WARNING: Do NOT modify this code. The content of this method is

* always regenerated by the Form Editor.

*/

//GEN-BEGIN:initComponents

//

private void initComponents() {

button1 = new java.awt.Button();

textField1 = new java.awt.TextField();

textField2 = new java.awt.TextField();

内容= new https://www.360docs.net/doc/ec2642535.html,bel();

密钥= new https://www.360docs.net/doc/ec2642535.html,bel();

textArea1 = new java.awt.TextArea();

button2 = new java.awt.Button();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

button1.setLabel("加密");

button1.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

// textField1.setText("");

// textField2.setText("");

// textField1.requestFocus();

try {

button1ActionPerformed(evt);

} catch (IOException e) {

// TODO 自动生成的catch 块

e.printStackTrace();

}

}

});

textField1.setText("请输入明文或者密文");

textField1.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

textField1ActionPerformed(evt);

}

});

textField2.setText("密钥由系统随机生成");

textField2.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

textField2ActionPerformed(evt);

}

});

内容.setText("内容");

密钥.setText("密钥");

button2.setLabel("解密");

button2.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

try {

button2ActionPerformed(evt);

} catch (IOException e) {

// TODO 自动生成的catch 块

e.printStackTrace();

}

}

});

javax.swing.GroupLayout layout = new javax.swing.GroupLayout(

getContentPane());

getContentPane().setLayout(layout);

layout.setHorizontalGroup(layout

.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(

layout.createSequentialGroup()

.addGap(127, 127, 127)

.addGroup(

layout.createParallelGroup(

javax.swing.GroupLayout.Alignment.TRAILING)

.addGroup(

layout.createParallelGroup(

javax.swing.GroupLayout.Alignment.LEADING)

.addComponent( textArea1,

javax.swing.GroupLayout.Alignment.TRAILING,

javax.swing.GroupLayout.DEFAULT_SIZE,

124,

Short.MAX_VALUE)

.addGroup( layout.createSequentialGroup()

.addGroup(

layout.createParallelGroup(

javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(

javax.swing.GroupLayout.Alignment.TRAILING,

layout.createSequentialGroup()

.addPreferredGap(

https://www.360docs.net/doc/ec2642535.html,ponentPlacement.RELATED)

.addComponent(

内容,

javax.swing.GroupLayout.PREFERRED_SIZE,

38,

javax.swing.GroupLayout.PREFERRED_SIZE))

.addComponent(

密钥,

javax.swing.GroupLayout.PREFERRED_SIZE,

javax.swing.GroupLayout.DEFAULT_SIZE,

javax.swing.GroupLayout.PREFERRED_SIZE)) .addGap(2,

2,

2)

.addGroup(

layout.createParallelGroup(

javax.swing.GroupLayout.Alignment.LEADING)

.addComponent(

textField1,

javax.swing.GroupLayout.DEFAULT_SIZE,

84,

Short.MAX_VALUE)

.addComponent(

textField2,

javax.swing.GroupLayout.DEFAULT_SIZE,

84,

Short.MAX_VALUE))))

.addGroup(

layout.createSequentialGroup()

.addComponent(

button1,

javax.swing.GroupLayout.PREFERRED_SIZE,

javax.swing.GroupLayout.DEFAULT_SIZE,

javax.swing.GroupLayout.PREFERRED_SIZE)

.addPreferredGap(

https://www.360docs.net/doc/ec2642535.html,ponentPlacement.RELATED)

.addComponent(

button2, javax.swing.GroupLayout.PREFERRED_SIZE,

javax.swing.GroupLayout.DEFAULT_SIZE,

javax.swing.GroupLayout.PREFERRED_SIZE)))

.addGap(149, 149, 149)));

layout.setVerticalGroup(layout

.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(

layout.createSequentialGroup()

.addGap(29, 29, 29)

.addGroup(

layout.createParallelGroup(

javax.swing.GroupLayout.Alignment.TRAILING)

.addComponent(

textField1,

javax.swing.GroupLayout.PREFERRED_SIZE,

javax.swing.GroupLayout.DEFAULT_SIZE,

javax.swing.GroupLayout.PREFERRED_SIZE)

.addComponent(

内容,

javax.swing.GroupLayout.PREFERRED_SIZE,

javax.swing.GroupLayout.DEFAULT_SIZE,

javax.swing.GroupLayout.PREFERRED_SIZE))

.addPreferredGap(

https://www.360docs.net/doc/ec2642535.html,ponentPlacement.RELATED)

.addGroup(

layout.createParallelGroup(

javax.swing.GroupLayout.Alignment.LEADING)

.addComponent(

密钥, javax.swing.GroupLayout.PREFERRED_SIZE,

javax.swing.GroupLayout.DEFAULT_SIZE,

javax.swing.GroupLayout.PREFERRED_SIZE)

.addComponent(

textField2, javax.swing.GroupLayout.PREFERRED_SIZE,

javax.swing.GroupLayout.DEFAULT_SIZE,

javax.swing.GroupLayout.PREFERRED_SIZE))

.addPreferredGap(

https://www.360docs.net/doc/ec2642535.html,ponentPlacement.RELATED)

.addGroup(

layout.createParallelGroup(

javax.swing.GroupLayout.Alignment.TRAILING)

.addComponent(

button2, javax.swing.GroupLayout.PREFERRED_SIZE,

javax.swing.GroupLayout.DEFAULT_SIZE,

javax.swing.GroupLayout.PREFERRED_SIZE)

.addComponent(

button1,

javax.swing.GroupLayout.PREFERRED_SIZE,

javax.swing.GroupLayout.DEFAULT_SIZE,

javax.swing.GroupLayout.PREFERRED_SIZE))

.addPreferredGap(

https://www.360docs.net/doc/ec2642535.html,ponentPlacement.RELATED)

.addComponent(textArea1,

javax.swing.GroupLayout.PREFERRED_SIZE,

javax.swing.GroupLayout.DEFAULT_SIZE,

javax.swing.GroupLayout.PREFERRED_SIZE)

.addContainerGap(91, Short.MAX_VALUE)));

pack();

}//

//GEN-END:initComponents

private void button2ActionPerformed(java.awt.event.ActionEvent evt) throws IOException { // 解密得到两个输入框的输入值

textArea1.setText("");

// textArea1.append("欢迎使用64位RSA加密解密演示程序。"+" ");

String data= textField1.getText();

String key = textField2.getText();

RSA desUtil = new RSA();

textArea1.append("解密前密文：" + data+ " ");

// 加密后的byte型的密文

byte[] src=data.getBytes();

byte[] result1 = desUtil.DesEncrypt(src);

textArea1.append("解密后明文：" + new String(result1));

}

private void textField2ActionPerformed(java.awt.event.ActionEvent evt) {

textField2.setText("");

}

private void textField1ActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:

textField1.setText("");

}

private void button1ActionPerformed(java.awt.event.ActionEvent evt) throws IOException { textArea1.setText("");

// textArea1.append("欢迎使用64位RSA加密解密演示程序。"+" ");

String data= textField1.getText();

RSA desUtil = new RSA();

textArea1.append("加密前明文：" + data+" ");

// 加密后的byte型的密文

byte[] result = desUtil.createEncryptor(data);

textArea1.append("加密后密文：" + new String(result));

}

/**

* @param args the command line arguments

*/

public static void main(String args[]) {

Des desUtil = new Des();

java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {

new Window().setVisible(true);

}

});

}

//GEN-BEGIN:variables

// Variables declaration - do not modify

private java.awt.Button button1;

private java.awt.Button button2;

private java.awt.TextArea textArea1;

private java.awt.TextField textField1;

private java.awt.TextField textField2;

private https://www.360docs.net/doc/ec2642535.html,bel 内容;

private https://www.360docs.net/doc/ec2642535.html,bel 密钥;

// End of variables declaration//GEN-END:variables

}