RSA和DES加密解密实验
实验一加密解密实验
一、实验目的：
通过JAVA语言，来实现对称密钥加密算法，非对称秘钥加密算法对信息的加密解密，通过实际操作加深学生对对称密钥加密、非对称秘钥加密解密的理解。
二、实验内容：
安装JDK，配置Java开发环境，加压eclipse，编写对称秘钥的生成、对称密钥加密、解密的程序。编写非对称秘钥加密解密的程序，用私钥对信息进行加密，用公钥对信息进行解密，然后用公钥对信息进行加密，用私钥对信息进行解密。
三、实验用到的主要技术及工具
主要技术：Java、Bouncy Castle
主要工具：Eclipse
四、开发步骤：
1、安装JDK，配置JAVA环境变量。
2、解压eclipse。
3、在eclipse中新建项目
4、编写使用DES算法生成秘钥的程序。
1.初始化密钥，并对密钥进行Base64位编码
5、使用生成的秘钥对“电子商务安全技术”进行加密。
加密，使用生成的密钥和明文作为参数进行传递，并使用密钥对明文加密
以下是对明文进行初始化，在第4点中已对密钥初始化
已下是加密算法
6、用第4步骤中生成的秘钥对第5部中生成的加密后的内容进行解密。
inputData为第五步中出现的加密过后的明文，由于DES 为对称加密，所以解密密钥key和加密密钥key使用的是同一把密钥
以下是解密算法：
以下是DES加密与解密算法的结果
7、使用AES算法重复4-6步骤。
8、使用RSA算法生成公钥和私钥。
对密钥进行初始化
取得公钥
取得私钥
对密钥进行编码并输出到控制台
获取明文，并对明文进行编码
9、用公钥对“电子商务安全技术RSA”进行加密。
以下是加密算法
10、用私钥对第九步中加密的信息进行解密。
私钥解密：
以下是解密算法
11、用生成的私钥对“电子商务安全技术RSA”进行加密。
12、用公钥对11步中的信息进行解密。
私钥加密算法
公钥解密算法：
以下是其中一次进行加密与解密的情况
13、请把你的公钥发送给你旁边的同学，让该同学用公钥进行加密，
然后再把加密后的信息发送给你，你再用你的私钥对信息进行解密。
使用其中的一对公钥和私钥，并对公钥加密的数据进行私钥解密，对私钥加密的数据进行公钥解密
以下是固定公钥和私钥，公钥加密的密文，私钥加密的密钥
以公钥解密为例
对私钥加密的密文进行解码，同时也对传输过来的公钥进行同样的解码
byte[] encodedData1 = Base64.decodeBase64(PriMi);
publicKey = Base64.decodeBase64(pubKey);
使用解码的密文和公钥对数据进行解密
byte[] pri_pub_Data = Demo.decryptByPublicKey(encodedData1, publicKey);
以下附上完整代码：
DESDemo.java
package cn.xupt.YVCB.code;
import java.security.Key;
import java.security.Security;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import https://www.360docs.net/doc/d512875977.html,mons.codec.binary.Base64;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public class DESDemo {
//加密算法
public static final String KEY_ALGORITHM = "DES";
public static final String CIPHER_ALGORITHM = "DES/ECB/PKCS5Padding";
/**
* 对密钥进行初始化，并返回字节码
* @return
* @throws Exception
*/
public static byte[] initKey() throws Exception{
KeyGenerator kg = KeyGenerator.getInstance(KEY_ALGORITHM);
kg.init(64); //初始化的密钥的长度
SecretKey secretKey = kg.generateKey();
return secretKey.getEncoded();
}
public static Key toKey(byte[] key) throws Exception{
//实例化DES密钥材料
DESKeySpec dks = new DESKeySpec(key);
//实例化秘密密钥莞式服务
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(KEY_ALGORITHM);
//生成秘密密钥
SecretKey secretKey = keyFactory.generateSecret(dks);
return secretKey;
}
/**
* 解密
* @param data
* @param key
* @return
* @throws Exception
*/
public static byte[] decrypt(byte[] data, byte[] key) throws Exception{
Key k = toKey(key); //还原密钥
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE,k);
return cipher.doFinal(data);
}
/**
* 加密
* @param data 需要加密的数据
* @param key 加密密钥
* @return
* @throws Exception
*/
public static byte[] encrypt(byte[] data, byte[] key) throws Exception{
Key k = toKey(key); //还原密钥
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM); //实例化
cipher.init(Cipher.ENCRYPT_MODE, k); //初始化，设置为解密模式
return cipher.doFinal(data); //执行操作
}
public static void test(String str) throws Exception{
Security.addProvider(new BouncyCastleProvider());
String inputStr = str + "使用DES加密与解密"; //获取字符串
byte[] inputData = inputStr.getBytes(); //将字符转换成二风景进制
System.err.println("\n============使用DES加密与解密==================");
System.err.println("原文："+inputStr); //打印转换后的字节码
//初始化密钥
byte[] key = DESDemo.initKey();
System.err.println("密钥编码前："+key);
System.err.println("密钥：" +Base64.encodeBase64String(key));
//加密
inputData = DESDemo.encrypt(inputData,key);
System.err.println("加密后：" + Base64.encodeBase64String(inputData));
//解密
byte[] outputData = DESDemo.decrypt(inputData, key);
String outputStr = new String(outputData);
System.err.println("解密后：" + outputStr);
System.err.println("===========DES加密与解密完成========");
}
}
RSADemo.java
package cn.xupt.YVCB.code;
import java.security.*;
import java.security.interfaces.*;
import java.security.spec.*;
import java.util.*;
import javax.crypto.Cipher;
import https://www.360docs.net/doc/d512875977.html,mons.codec.binary.Base64;
public class RSADemo {
private static byte[] publicKey;
private static byte[] privateKey;
// 非对称加密算法：RSA
public static final String KEY_ALGORITHM = "RSA";
// 公钥
private static final String PUBLIC_KEY = "RSAPublicKey";
// 私钥
private static final String PRIV ATE_KEY = "RSAPrivateKey";
// 密钥长度
private static final int KEY_SIZE = 512;
/**
* 初始化密钥
*
* @return keyMap 密钥Map
* @throws Exception
*/
public static Map
KeyPairGenerator keyPairgen = KeyPairGenerator
.getInstance(KEY_ALGORITHM); // 实例化密钥对生成器keyPairgen.initialize(KEY_SIZE); // 初始化密钥对生成器
KeyPair keyPair = keyPairgen.generateKeyPair(); // 生成密钥对
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic(); // 生成公钥
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate(); // 生成私钥
Map
keyMap.put(PRIV ATE_KEY, privateKey);
return keyMap;
}
/**
* 获取私钥
*
* @param keyMap
* 密钥Map
* @return 返回私钥二进制
* @throws Exception
*/
public static byte[] getPrivateKey(Map
throws Exception {
Key key = (Key) keyMap.get(PRIV ATE_KEY);
return key.getEncoded();
}
/**
* 取得公钥
*
* @param keyMap
* 公钥Map
* @return
* @throws Exception
*/
public static byte[] getPublicKey(Map
throws Exception {
Key key = (Key) keyMap.get(PUBLIC_KEY);
return key.getEncoded();
}
/**
* 使用私钥进行加密
*
* @param data
* @param key
* @return
* @throws Exception
*/
public static byte[] decryptByPrivateKey(byte[] data, byte[] key)
throws Exception {
// 取得私钥
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
// 生成私钥
PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
// 对数据进行加密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE, privateKey);
return cipher.doFinal(data);
}
/**
* 公钥解密
*
* @param data
* @param key
* @return
* @throws Exception
*/
public static byte[] decryptByPublicKey(byte[] data, byte[] key)
throws Exception {
// 获取公钥
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
// 生成公钥
PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
// 对数据进行加密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE, publicKey);
return cipher.doFinal(data);
}
/**
* 公钥加密
*
* @param data
* @param key
* @return
* @throws Exception
*/
public static byte[] encryptByPublicKey(byte[] data, byte[] key)
throws Exception {
// 取得公钥
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
// 对数据加密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
return cipher.doFinal(data);
}
/**
* 私钥加密
*
* @param data
* @param key
* @return
* @throws Exception
*/
public static byte[] encryptByPrivateKey(byte[] data, byte[] key)
throws Exception {
// 取得私钥
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
// 对数据进行加密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, privateKey);
return cipher.doFinal(data);
}
public static void printCode() throws Exception {
System.err.println("\n\n\n===========使用RSA生成公钥与私钥
================");
// 初始化密钥
Map
publicKey = RSADemo.getPublicKey(keyMap);
privateKey = RSADemo.getPrivateKey(keyMap);
System.err.println("公钥：" + Base64.encodeBase64String(publicKey));
System.err.println("私钥：" + Base64.encodeBase64String(privateKey));
System.err.println("=================密钥生成完成=========================");
}
public void test(String str) throws Exception {
System.err
.println("\n\n\n ================= RSA加密算法：私钥加密——公钥解密=============");
String inputStr1 = str + " ：RSA加密算法：私钥加密——私钥解密";
byte[] data1 = inputStr1.getBytes();
System.err.println("原文：" + inputStr1);
// 私钥加密
byte[] encodedData1 = RSADemo.encryptByPrivateKey(data1, privateKey);
System.err.println("加密后：" + Base64.encodeBase64String(encodedData1));
// 公钥解密
byte[] decodedData1 = RSADemo.decryptByPublicKey(encodedData1,
publicKey);
String outputStr1 = new String(decodedData1);
System.err.println("解密后：" + outputStr1);
System.err.println("\n\n\n========公钥加密——私钥解密=============");
String inputStr2 = str + " ：RSA加密算法：公钥加密——私钥解密";
byte[] data2 = inputStr2.getBytes();
System.err.println("原文：" + inputStr2);
// 公钥加密
byte[] encodedData2 = RSADemo.encryptByPublicKey(data2, publicKey);
System.err.println("加密后：" + Base64.encodeBase64String(encodedData2));
// 私钥解密
byte[] decodedData2 = RSADemo.decryptByPrivateKey(encodedData2,
privateKey);
String outputStr2 = new String(decodedData2);
System.err.println("解密后：" + outputStr2);
}
/**
* 对别人已经加密进行解密
*
* @throws Exception
*/
public void test() throws Exception {
// 公钥
String pubKey = "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAIswBjSKnOZcaqc1fnz2SQPw1K3EzMoFa8 WPfRq3c/Z/G+FafjY/Cy1t0mekmpS20szhz5MVyqg2C1WjO1oda3kCAwEAAQ==";
// 私钥
String priKey = "MIIBV AIBADANBgkqhkiG9w0BAQEFAASCAT4wggE6AgEAAkEAizAGNIqc5lxqpzV+fPZJ A/DUrcTMygVrxY99Grdz9n8b4Vp+Nj8LLW3SZ6SalLbSzOHPkxXKqDYLVaM7Wh1reQIDA QABAkByUwHlyizRsfsQWIoKjiivCfNGv60OCqHY5eD2PtULE2L8u7gDEC7J7UB6MdMbyX mIAkVN1pp6SHEdHWMV+GPhAiEA6v14HJzJ5c6uIBwM7jDO/TjWzTFsw/pp07aKJiimm90C IQCXocuqF4CIJ756IgkelhXJh589FeIX18H8YH3MXgcSTQIgMFZtY61Y1p3aMZ6zhjeiDHKpt NHK5tFW/YbaChlolD0CIGgOQiNxiWTmUVKi9Lsmp8Dq7x4OXF+cUqUM2odap2OpAiEAiw o8yK6oWncDnXwv7naXB9WZbO3DCFmXYBngLiLLnak=";
// 公钥加密后的密文
String PubMi = "fDUU1gCNwWJ9j7LfBLQI65h9IoQ6bQaWPIlnYc4ZM4wcVj01Yo8HNXJ25yiv2PrH/iEczV99 QC0pZkJ4huIiCA==";
// 私钥加密后的密文
String PriMi = "He0OOcxzcHSUHZofSczVCKqnWk3OSG1tUpdU7SPKZvYXY+/UjzdjuW8I84hYtovUqSspRa Xd1Ou0wVqc8QTX4Q==";
// 指定公钥加密
// pubKey =
// "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAJdGLmHuUxgOtGoRoyYoeLXWT+HcLaK ONSgJq8TssOWIAk9pf+LUDjyUqPbGm7cMZAgrJuDi58Bc+PpsFK6iiwcCAwEAAQ==";
System.out.println("\n\n\n===========对别人的数据进行解密===========");
String str = "用**的公钥加密";
// 公钥解密
System.out.println("\n===========公钥解密===========");
byte[] encodedData1 = Base64.decodeBase64(PriMi);
publicKey = Base64.decodeBase64(pubKey);
byte[] pri_pub_Data = Demo.decryptByPublicKey(encodedData1, publicKey);
String outputStr1 = new String(pri_pub_Data);
System.out.println("解密后：" + outputStr1);
// 私钥解密
System.out.println("\n===========私钥解密==========");
byte[] encodedData2 = Base64.decodeBase64(PubMi);
privateKey = Base64.decodeBase64(priKey);
byte[] pub_pri_Data = Demo
.decryptByPrivateKey(encodedData2, privateKey);
String outputSt2 = new String(pub_pri_Data);
System.out.println("解密后：" + outputSt2);
// 用指定的公钥对明文加密
System.out.println("====用指定的公钥对数据进行加密====");
System.out.println("原明文为："+str);
byte[] data2 = str.getBytes();
byte[] encodedData3 = RSADemo.encryptByPublicKey(data2, publicKey);
System.err.println("加密后：" + Base64.encodeBase64String(encodedData2));
}
}
CodeDemo.java
package cn.xupt.YVCB.code;
public class CodeDemo {
public static void main(String[] args) throws Exception { String str = "海浪之心加密";
// 使用DES加密与解密
DESDemo.test(str);
// 使用AES加密与解密
// AESDemo.test();
// 使用RSA加密与解密
RSADemo rsa = new RSADemo();
RSADemo.printCode();
rsa.test(str);
//对别人加密的数据进行解密
rsa.test();
}
}