java RSAUtils 加密工具类操作

2023-07-18 15:45:03 86

1.RSA加密算法是一种非对称加密算法。在公开密钥加密和电子商业中RSA被广泛使用。RSA公开密钥密码体制。所谓的公开密钥密码体制就是使用不同的加密密钥与解密密钥，是一种“由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制。在公开密钥密码体制中，加密密钥（即公开密钥）PK是公开信息，而解密密钥（即秘密密钥）SK是需要保密的。加密算法E和解密算法D也都是公开的。虽然解密密钥SK是由公开密钥PK决定的，但却不能根据PK计算出SK。

2.本工具类涉及到BASE64编码，所以先展示出BASE64Utils：

packagecom.example.springboottest.common.util;

importsun.misc.BASE64Decoder;
importsun.misc.BASE64Encoder;
importjava.security.MessageDigest;

/**
*BASE64的加解密
*@authorNeo
*@date2018-4-1522:21:51
*
*/
@SuppressWarnings("restriction")
publicclassBase64Utils{
publicstaticfinalStringKEY_SHA="SHA";
publicstaticfinalStringKEY_MD5="MD5";

/**
*BASE64解密
*
*@paramkey
*@return
*@throwsException
*/
publicstaticbyte[]decryptBASE64(Stringkey)throwsException{
return(newBASE64Decoder()).decodeBuffer(key);
}

/**
*BASE64加密
*
*@paramkey
*@return
*@throwsException
*/
publicstaticStringencryptBASE64(byte[]key)throwsException{
return(newBASE64Encoder()).encodeBuffer(key);
}

/**
*MD5加密
*
*@paramdata
*@return
*@throwsException
*/
publicstaticbyte[]encryptMD5(byte[]data)throwsException{

MessageDigestmd5=MessageDigest.getInstance(KEY_MD5);
md5.update(data);
returnmd5.digest();

}

/**
*SHA加密
*
*@paramdata
*@return
*@throwsException
*/
publicstaticbyte[]encryptSHA(byte[]data)throwsException{

MessageDigestsha=MessageDigest.getInstance(KEY_SHA);
sha.update(data);

returnsha.digest();

}
}

3.然后我们展示RSAUtils：

packagecom.example.springboottest.common.util;

importjavax.crypto.Cipher;
importjava.security.*;
importjava.security.interfaces.RSAPrivateKey;
importjava.security.interfaces.RSAPublicKey;
importjava.security.spec.PKCS8EncodedKeySpec;
importjava.security.spec.X509EncodedKeySpec;
importjava.util.HashMap;
importjava.util.Map;

/**
*RSA安全编码组件
*
*@version1.0
*@desc公钥和私钥存放在properties文件的时候每行的末尾加上“\r\n\”

*“\r\n”起到换行的作用,最后的“\”在properties在里表示连接
*
*@authorNeo
*@date2018-4-1522:23:19
*@since1.0
*/
publicclassRSAUtilsextendsBase64Utils{
publicstaticfinalStringKEY_ALGORITHM="RSA";
publicstaticfinalStringSIGNATURE_ALGORITHM="MD5withRSA";

privatestaticfinalStringPUBLIC_KEY="RSAPublicKey";
privatestaticfinalStringPRIVATE_KEY="RSAPrivateKey";

/**
*用私钥对信息生成数字签名
*
*@paramdata加密数据
*@paramprivateKey私钥
*@return
*@throwsException
*/
publicstaticStringsign(Stringdata,StringprivateKey)throwsException{
returnsign(data.getBytes(),privateKey);
}

/**
*用私钥对信息生成数字签名
*
*@paramdata加密数据
*@paramprivateKey私钥
*@return
*@throwsException
*/
publicstaticStringsign(byte[]data,StringprivateKey)throwsException{
//解密由base64编码的私钥
byte[]keyBytes=decryptBASE64(privateKey);

//构造PKCS8EncodedKeySpec对象
PKCS8EncodedKeySpecpkcs8KeySpec=newPKCS8EncodedKeySpec(keyBytes);

//KEY_ALGORITHM指定的加密算法
KeyFactorykeyFactory=KeyFactory.getInstance(KEY_ALGORITHM);

//取私钥匙对象
PrivateKeypriKey=keyFactory.generatePrivate(pkcs8KeySpec);

//用私钥对信息生成数字签名
Signaturesignature=Signature.getInstance(SIGNATURE_ALGORITHM);
signature.initSign(priKey);
signature.update(data);

returnencryptBASE64(signature.sign());
}

/**
*校验数字签名
*
*@paramdata加密数据
*@parampublicKey公钥
*@paramsign数字签名
*@return校验成功返回true失败返回false
*@throwsException
*/
publicstaticbooleanverify(Stringdata,StringpublicKey,Stringsign)throwsException{
returnverify(data.getBytes(),publicKey,sign);
}

/**
*校验数字签名
*
*@paramdata加密数据
*@parampublicKey公钥
*@paramsign数字签名
*@return校验成功返回true失败返回false
*@throwsException
*/
publicstaticbooleanverify(byte[]data,StringpublicKey,Stringsign)throwsException{

//解密由base64编码的公钥
byte[]keyBytes=decryptBASE64(publicKey);

//构造X509EncodedKeySpec对象
X509EncodedKeySpeckeySpec=newX509EncodedKeySpec(keyBytes);

//KEY_ALGORITHM指定的加密算法
KeyFactorykeyFactory=KeyFactory.getInstance(KEY_ALGORITHM);

//取公钥匙对象
PublicKeypubKey=keyFactory.generatePublic(keySpec);

Signaturesignature=Signature.getInstance(SIGNATURE_ALGORITHM);
signature.initVerify(pubKey);
signature.update(data);

//验证签名是否正常
returnsignature.verify(decryptBASE64(sign));
}

/**
*解密

*用私钥解密
*
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticStringdecryptByPrivateKey(Stringdata,Stringkey)throwsException{
returnnewString(decryptByPrivateKey(Base64Utils.decryptBASE64(data),key));
}

/**
*解密

*用私钥解密
*
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticbyte[]decryptByPrivateKey(byte[]data,Stringkey)throwsException{
//对密钥解密
byte[]keyBytes=decryptBASE64(key);

//取得私钥
PKCS8EncodedKeySpecpkcs8KeySpec=newPKCS8EncodedKeySpec(keyBytes);
KeyFactorykeyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
KeyprivateKey=keyFactory.generatePrivate(pkcs8KeySpec);

//对数据解密
Ciphercipher=Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE,privateKey);

returncipher.doFinal(data);
}

/**
*解密

*用私钥解密
*
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticStringdecryptByPublicKey(Stringdata,Stringkey)throwsException{
returnnewString(decryptByPublicKey(Base64Utils.decryptBASE64(data),key));
}

/**
*解密

*用私钥解密
*
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticbyte[]decryptByPublicKey(byte[]data,Stringkey)throwsException{
//对密钥解密
byte[]keyBytes=decryptBASE64(key);

//取得公钥
X509EncodedKeySpecx509KeySpec=newX509EncodedKeySpec(keyBytes);
KeyFactorykeyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
KeypublicKey=keyFactory.generatePublic(x509KeySpec);

//对数据解密
Ciphercipher=Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE,publicKey);
returncipher.doFinal(data);
}

/**
*加密

*用公钥加密
*
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticStringencryptByPublicKey(Stringdata,Stringkey)throwsException{
returnBase64Utils.encryptBASE64(encryptByPublicKey(data.getBytes(),key));
}

/**
*加密

*用公钥加密
*
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticbyte[]encryptByPublicKey(byte[]data,Stringkey)throwsException{
//对公钥解密
byte[]keyBytes=decryptBASE64(key);

//取得公钥
X509EncodedKeySpecx509KeySpec=newX509EncodedKeySpec(keyBytes);
KeyFactorykeyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
KeypublicKey=keyFactory.generatePublic(x509KeySpec);

//对数据加密
Ciphercipher=Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE,publicKey);
returncipher.doFinal(data);
}

/**
*加密

*用私钥加密
*
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticStringencryptByPrivateKey(Stringdata,Stringkey)throwsException{
returnBase64Utils.encryptBASE64(encryptByPrivateKey(data.getBytes(),key));
}

/**
*加密

*用私钥加密
*
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticbyte[]encryptByPrivateKey(byte[]data,Stringkey)throwsException{
//对密钥解密
byte[]keyBytes=decryptBASE64(key);

//取得私钥
PKCS8EncodedKeySpecpkcs8KeySpec=newPKCS8EncodedKeySpec(keyBytes);
KeyFactorykeyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
KeyprivateKey=keyFactory.generatePrivate(pkcs8KeySpec);

//对数据加密
Ciphercipher=Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE,privateKey);
returncipher.doFinal(data);
}

/**
*取得私钥
*
*@paramkeyMap
*@return
*@throwsException
*/
publicstaticStringgetPrivateKey(MapkeyMap)throwsException{
Keykey=(Key)keyMap.get(PRIVATE_KEY);

returnencryptBASE64(key.getEncoded());
}

/**
*取得公钥
*
*@paramkeyMap
*@return
*@throwsException
*/
publicstaticStringgetPublicKey(MapkeyMap)throwsException{
Keykey=(Key)keyMap.get(PUBLIC_KEY);

returnencryptBASE64(key.getEncoded());
}

/**
*初始化密钥
*
*@return
*@throwsException
*/
publicstaticMapinitKey()throwsException{
KeyPairGeneratorkeyPairGen=KeyPairGenerator.getInstance(KEY_ALGORITHM);
keyPairGen.initialize(1024);

KeyPairkeyPair=keyPairGen.generateKeyPair();

//公钥
RSAPublicKeypublicKey=(RSAPublicKey)keyPair.getPublic();

//私钥
RSAPrivateKeyprivateKey=(RSAPrivateKey)keyPair.getPrivate();

MapkeyMap=newHashMap(2);
keyMap.put(PUBLIC_KEY,publicKey);
keyMap.put(PRIVATE_KEY,privateKey);
returnkeyMap;
}

publicstaticvoidmain(String[]args){
try{
Mapmap=RSAUtils.initKey();
StringpublicKey=RSAUtils.getPublicKey(map);
StringprivateKey=RSAUtils.getPrivateKey(map);
System.out.println("公钥："+publicKey);
System.out.println("私钥："+privateKey);
Stringdata="Java是世界上最好的编程语言";
StringencryptData=RSAUtils.encryptByPublicKey(data,publicKey);
System.out.println("加密后："+encryptData);
StringdecryptData=RSAUtils.decryptByPrivateKey(encryptData,privateKey);
System.out.println("解密后："+decryptData);
}catch(Exceptione){
e.printStackTrace();
}
}
}

4.最后展示测试结果：

补充知识：java使用RSA生成公钥和私钥，并进行加解密

废话不多说，上代码：

importjavax.crypto.Cipher;
importsun.misc.BASE64Decoder;
importsun.misc.BASE64Encoder;

importjava.security.KeyFactory;
importjava.security.KeyPair;
importjava.security.KeyPairGenerator;
importjava.security.SecureRandom;
importjava.security.interfaces.RSAPrivateKey;
importjava.security.interfaces.RSAPublicKey;
importjava.security.spec.PKCS8EncodedKeySpec;
importjava.security.spec.X509EncodedKeySpec;
importjava.util.HashMap;
importjava.util.Map;

/**
*JavaRSA加密工具类
*/
publicclassRSAUtils{
/**
*密钥长度于原文长度对应以及越长速度越慢
*/
privatefinalstaticintKEY_SIZE=1024;
/**
*用于封装随机产生的公钥与私钥
*/
privatestaticMapkeyMap=newHashMap();

/**
*随机生成密钥对
*@throwsException
*/
publicstaticvoidgenKeyPair()throwsException{
//KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象
KeyPairGeneratorkeyPairGen=KeyPairGenerator.getInstance("RSA");
//初始化密钥对生成器
keyPairGen.initialize(KEY_SIZE,newSecureRandom());
//生成一个密钥对，保存在keyPair中
KeyPairkeyPair=keyPairGen.generateKeyPair();
//得到私钥
RSAPrivateKeyprivateKey=(RSAPrivateKey)keyPair.getPrivate();
//得到公钥
RSAPublicKeypublicKey=(RSAPublicKey)keyPair.getPublic();
StringpublicKeyString=encryptBASE64(publicKey.getEncoded());
//得到私钥字符串
StringprivateKeyString=encryptBASE64(privateKey.getEncoded());
//将公钥和私钥保存到Map
//0表示公钥
keyMap.put(0,publicKeyString);
//1表示私钥
keyMap.put(1,privateKeyString);
}

//编码返回字符串
publicstaticStringencryptBASE64(byte[]key)throwsException{
return(newBASE64Encoder()).encodeBuffer(key);
}

//解码返回byte
publicstaticbyte[]decryptBASE64(Stringkey)throwsException{
return(newBASE64Decoder()).decodeBuffer(key);
}

/**
*RSA公钥加密
*
*@paramstr加密字符串
*@parampublicKey公钥
*@return密文
*@throwsException加密过程中的异常信息
*/
publicstaticStringencrypt(Stringstr,StringpublicKey)throwsException{
//base64编码的公钥
byte[]decoded=decryptBASE64(publicKey);
RSAPublicKeypubKey=(RSAPublicKey)KeyFactory.getInstance("RSA").generatePublic(newX509EncodedKeySpec(decoded));
//RSA加密
Ciphercipher=Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE,pubKey);
StringoutStr=encryptBASE64(cipher.doFinal(str.getBytes("UTF-8")));
returnoutStr;
}

/**
*RSA私钥解密
*
*@paramstr加密字符串
*@paramprivateKey私钥
*@return明文
*@throwsException解密过程中的异常信息
*/
publicstaticStringdecrypt(Stringstr,StringprivateKey)throwsException{
//64位解码加密后的字符串
byte[]inputByte=decryptBASE64(str);
//base64编码的私钥
byte[]decoded=decryptBASE64(privateKey);
RSAPrivateKeypriKey=(RSAPrivateKey)KeyFactory.getInstance("RSA").generatePrivate(newPKCS8EncodedKeySpec(decoded));
//RSA解密
Ciphercipher=Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE,priKey);
StringoutStr=newString(cipher.doFinal(inputByte));
returnoutStr;
}

publicstaticvoidmain(String[]args)throwsException{
longtemp=System.currentTimeMillis();
//生成公钥和私钥
genKeyPair();
//加密字符串
System.out.println("公钥:"+keyMap.get(0));
System.out.println("私钥:"+keyMap.get(1));
System.out.println("生成密钥消耗时间:"+(System.currentTimeMillis()-temp)/1000.0+"秒");

Stringmessage="RSA测试aaa";
System.out.println("原文:"+message);

temp=System.currentTimeMillis();
StringmessageEn=encrypt(message,keyMap.get(0));
System.out.println("密文:"+messageEn);
System.out.println("加密消耗时间:"+(System.currentTimeMillis()-temp)/1000.0+"秒");

temp=System.currentTimeMillis();

StringmessageDe=decrypt(messageEn,keyMap.get(1));
System.out.println("解密:"+messageDe);
System.out.println("解密消耗时间:"+(System.currentTimeMillis()-temp)/1000.0+"秒");
}
}

以上这篇javaRSAUtils加密工具类操作就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持毛票票。

声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。

java RSAUtils 加密工具类操作

热门推荐

随机推荐