JAVA 中解密RSA算法JS加密实例详解

2024-02-25 17:45:03 315

JAVA中解密RSA算法JS加密实例详解

有这样一个需求，前端登录的用户名密码，密码必需加密，但不可使用MD5，因为后台要检测密码的复杂度，那么在保证安全的前提下将密码传到后台呢，答案就是使用RSA非对称加密算法解决。

java代码

需要依赖commons-codec包

RSACoder.Java

importorg.apache.commons.codec.binary.Base64;

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

/**
*Createdbylakeon17-4-12.
*/
publicclassRSACoder{
publicstaticfinalStringKEY_ALGORITHM="RSA";
publicstaticfinalStringSIGNATURE_ALGORITHM="MD5withRSA";

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

publicstaticbyte[]decryptBASE64(Stringkey){
returnBase64.decodeBase64(key);
}

publicstaticStringencryptBASE64(byte[]bytes){
returnBase64.encodeBase64String(bytes);
}

/**
*用私钥对信息生成数字签名
*
*@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(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));
}

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
*/
publicstaticbyte[]decryptByPrivateKey(Stringdata,Stringkey)
throwsException{
returndecryptByPrivateKey(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
*/
publicstaticbyte[]encryptByPublicKey(Stringdata,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.getBytes());
}

/**
*加密

*用私钥加密
*
*@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=keyMap.get(PUBLIC_KEY);
returnencryptBASE64(key.getEncoded());
}

/**
*初始化密钥
*
*@return
*@throwsException
*/
publicstaticMapinitKey()throwsException{
KeyPairGeneratorkeyPairGen=KeyPairGenerator
.getInstance(KEY_ALGORITHM);
keyPairGen.initialize(1024);
KeyPairkeyPair=keyPairGen.generateKeyPair();
MapkeyMap=newHashMap(2);
keyMap.put(PUBLIC_KEY,keyPair.getPublic());//公钥
keyMap.put(PRIVATE_KEY,keyPair.getPrivate());//私钥
returnkeyMap;
}
}

测试类

RSACoderTest.java

importorg.junit.Before;
importorg.junit.Test;

importjava.security.Key;
importjava.util.Map;

importstaticorg.junit.Assert.assertEquals;
importstaticorg.junit.Assert.assertTrue;

/**
*Createdbylakeon17-4-12.
*/
publicclassRSACoderTest{
privateStringpublicKey;
privateStringprivateKey;

@Before
publicvoidsetUp()throwsException{
MapkeyMap=RSACoder.initKey();
publicKey=RSACoder.getPublicKey(keyMap);
privateKey=RSACoder.getPrivateKey(keyMap);
System.err.println("公钥:\n\r"+publicKey);
System.err.println("私钥：\n\r"+privateKey);
}

@Test
publicvoidtest()throwsException{
System.err.println("公钥加密——私钥解密");
StringinputStr="abc";
byte[]encodedData=RSACoder.encryptByPublicKey(inputStr,publicKey);
byte[]decodedData=RSACoder.decryptByPrivateKey(encodedData,
privateKey);
StringoutputStr=newString(decodedData);
System.err.println("加密前:"+inputStr+"\n\r"+"解密后:"+outputStr);
assertEquals(inputStr,outputStr);
}

@Test
publicvoidtestSign()throwsException{
System.err.println("私钥加密——公钥解密");
StringinputStr="sign";
byte[]data=inputStr.getBytes();
byte[]encodedData=RSACoder.encryptByPrivateKey(data,privateKey);
byte[]decodedData=RSACoder.decryptByPublicKey(encodedData,publicKey);
StringoutputStr=newString(decodedData);
System.err.println("加密前:"+inputStr+"\n\r"+"解密后:"+outputStr);
assertEquals(inputStr,outputStr);
System.err.println("私钥签名——公钥验证签名");
//产生签名
Stringsign=RSACoder.sign(encodedData,privateKey);
System.err.println("签名:"+sign);
//验证签名
booleanstatus=RSACoder.verify(encodedData,publicKey,sign);
System.err.println("状态:"+status);
assertTrue(status);
}
}

前端代码

依赖jsencrypt项目



varencrypt=newJSEncrypt();
encrypt.setPublicKey('java生成的公钥');
varencrypted=encrypt.encrypt('加密的字符串');

说明

前端生成加密的字符串encrypted，传到后台，java使用私钥进行解密即可。

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！

JAVA 中解密RSA算法JS加密实例详解

热门推荐

随机推荐