RSA和DES加密解密实验.docx
- 文档编号:11474950
- 上传时间:2023-03-01
- 格式:DOCX
- 页数:20
- 大小:285.20KB
RSA和DES加密解密实验.docx
《RSA和DES加密解密实验.docx》由会员分享,可在线阅读,更多相关《RSA和DES加密解密实验.docx(20页珍藏版)》请在冰豆网上搜索。
RSA和DES加密解密实验
实验一加密解密实验
一、实验目的:
通过JAVA语言,来实现对称密钥加密算法,非对称秘钥加密算法对信息的加密解密,通过实际操作加深学生对对称密钥加密、非对称秘钥加密解密的理解。
二、实验内容:
安装JDK,配置Java开发环境,加压eclipse,编写对称秘钥的生成、对称密钥加密、解密的程序。
编写非对称秘钥加密解密的程序,用私钥对信息进行加密,用公钥对信息进行解密,然后用公钥对信息进行加密,用私钥对信息进行解密。
三、实验用到的主要技术及工具
主要技术:
Java、BouncyCastle
主要工具:
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
packagecn.xupt.YVCB.code;
importjava.security.Key;
importjava.security.Security;
importjavax.crypto.Cipher;
importjavax.crypto.KeyGenerator;
importjavax.crypto.SecretKey;
importjavax.crypto.SecretKeyFactory;
importjavax.crypto.spec.DESKeySpec;
importmons.codec.binary.Base64;
importorg.bouncycastle.jce.provider.BouncyCastleProvider;
publicclassDESDemo{
//加密算法
publicstaticfinalStringKEY_ALGORITHM="DES";
publicstaticfinalStringCIPHER_ALGORITHM="DES/ECB/PKCS5Padding";
/**
*对密钥进行初始化,并返回字节码
*@return
*@throwsException
*/
publicstaticbyte[]initKey()throwsException{
KeyGeneratorkg=KeyGenerator.getInstance(KEY_ALGORITHM);
kg.init(64);//初始化的密钥的长度
SecretKeysecretKey=kg.generateKey();
returnsecretKey.getEncoded();
}
publicstaticKeytoKey(byte[]key)throwsException{
//实例化DES密钥材料
DESKeySpecdks=newDESKeySpec(key);
//实例化秘密密钥莞式服务
SecretKeyFactorykeyFactory=SecretKeyFactory.getInstance(KEY_ALGORITHM);
//生成秘密密钥
SecretKeysecretKey=keyFactory.generateSecret(dks);
returnsecretKey;
}
/**
*解密
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticbyte[]decrypt(byte[]data,byte[]key)throwsException{
Keyk=toKey(key);//还原密钥
Ciphercipher=Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE,k);
returncipher.doFinal(data);
}
/**
*加密
*@paramdata需要加密的数据
*@paramkey加密密钥
*@return
*@throwsException
*/
publicstaticbyte[]encrypt(byte[]data,byte[]key)throwsException{
Keyk=toKey(key);//还原密钥
Ciphercipher=Cipher.getInstance(CIPHER_ALGORITHM);//实例化
cipher.init(Cipher.ENCRYPT_MODE,k);//初始化,设置为解密模式
returncipher.doFinal(data);//执行操作
}
publicstaticvoidtest(Stringstr)throwsException{
Security.addProvider(newBouncyCastleProvider());
StringinputStr=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);
StringoutputStr=newString(outputData);
System.err.println("解密后:
"+outputStr);
System.err.println("===========DES加密与解密完成========");
}
}
RSADemo.java
packagecn.xupt.YVCB.code;
importjava.security.*;
importjava.security.interfaces.*;
importjava.security.spec.*;
importjava.util.*;
importjavax.crypto.Cipher;
importmons.codec.binary.Base64;
publicclassRSADemo{
privatestaticbyte[]publicKey;
privatestaticbyte[]privateKey;
//非对称加密算法:
RSA
publicstaticfinalStringKEY_ALGORITHM="RSA";
//公钥
privatestaticfinalStringPUBLIC_KEY="RSAPublicKey";
//私钥
privatestaticfinalStringPRIVATE_KEY="RSAPrivateKey";
//密钥长度
privatestaticfinalintKEY_SIZE=512;
/**
*初始化密钥
*
*@returnkeyMap密钥Map
*@throwsException
*/
publicstaticMap
KeyPairGeneratorkeyPairgen=KeyPairGenerator
.getInstance(KEY_ALGORITHM);//实例化密钥对生成器
keyPairgen.initialize(KEY_SIZE);//初始化密钥对生成器
KeyPairkeyPair=keyPairgen.generateKeyPair();//生成密钥对
RSAPublicKeypublicKey=(RSAPublicKey)keyPair.getPublic();//生成公钥
RSAPrivateKeyprivateKey=(RSAPrivateKey)keyPair.getPrivate();//生成私钥
Map
(2);//封闭密钥
keyMap.put(PUBLIC_KEY,publicKey);
keyMap.put(PRIVATE_KEY,privateKey);
returnkeyMap;
}
/**
*获取私钥
*
*@paramkeyMap
*密钥Map
*@return返回私钥二进制
*@throwsException
*/
publicstaticbyte[]getPrivateKey(Map
throwsException{
Keykey=(Key)keyMap.get(PRIVATE_KEY);
returnkey.getEncoded();
}
/**
*取得公钥
*
*@paramkeyMap
*公钥Map
*@return
*@throwsException
*/
publicstaticbyte[]getPublicKey(Map
throwsException{
Keykey=(Key)keyMap.get(PUBLIC_KEY);
returnkey.getEncoded();
}
/**
*使用私钥进行加密
*
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticbyte[]decryptByPrivateKey(byte[]data,byte[]key)
throwsException{
//取得私钥
PKCS8EncodedKeySpecpkcs8KeySpec=newPKCS8EncodedKeySpec(key);
KeyFactorykeyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
//生成私钥
PrivateKeyprivateKey=keyFactory.generatePrivate(pkcs8KeySpec);
//对数据进行加密
Ciphercipher=Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE,privateKey);
returncipher.doFinal(data);
}
/**
*公钥解密
*
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticbyte[]decryptByPublicKey(byte[]data,byte[]key)
throwsException{
//获取公钥
X509EncodedKeySpecx509KeySpec=newX509EncodedKeySpec(key);
KeyFactorykeyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
//生成公钥
PublicKeypublicKey=keyFactory.generatePublic(x509KeySpec);
//对数据进行加密
Ciphercipher=Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE,publicKey);
returncipher.doFinal(data);
}
/**
*公钥加密
*
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticbyte[]encryptByPublicKey(byte[]data,byte[]key)
throwsException{
//取得公钥
X509EncodedKeySpecx509KeySpec=newX509EncodedKeySpec(key);
KeyFactorykeyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
PublicKeypublicKey=keyFactory.generatePublic(x509KeySpec);
//对数据加密
Ciphercipher=Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE,publicKey);
returncipher.doFinal(data);
}
/**
*私钥加密
*
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticbyte[]encryptByPrivateKey(byte[]data,byte[]key)
throwsException{
//取得私钥
PKCS8EncodedKeySpecpkcs8KeySpec=newPKCS8EncodedKeySpec(key);
KeyFactorykeyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
PrivateKeyprivateKey=keyFactory.generatePrivate(pkcs8KeySpec);
//对数据进行加密
Ciphercipher=Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE,privateKey);
returncipher.doFinal(data);
}
publicstaticvoidprintCode()throwsException{
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("=================密钥生成完成=========================");
}
publicvoidtest(Stringstr)throwsException{
System.err
.println("\n\n\n=================RSA加密算法:
私钥加密——公钥解密=============");
StringinputStr1=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);
StringoutputStr1=newString(decodedData1);
System.err.println("解密后:
"+outputStr1);
System.err.println("\n\n\n========公钥加密——私钥解密=============");
StringinputStr2=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);
StringoutputStr2=newString(decodedData2);
System.err.println("解密后:
"+outputStr2);
}
/**
*对别人已经加密进行解密
*
*@throwsException
*/
publicvoidtest()throwsException{
//公钥
StringpubKey="MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAIswBjSKnOZcaqc1fnz2SQPw1K3EzMoFa8WPfRq3c/Z/G+FafjY/Cy1t0mekmpS20szhz5MVyqg2C1WjO1oda3kCAwEAAQ==";
//私钥
StringpriKey="MIIBVAIBADANBgkqhkiG9w0BAQEFAASCAT4wggE6AgEAAkEAizAGNIqc5lxq
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- RSA DES 加密 解密 实验
![提示](https://static.bdocx.com/images/bang_tan.gif)