一、JS的RSA加密
JS在RSA加密方面做的比较好的是jsencrypt，大家可以在附件中下载页面jsencrypt加解密的小例子。
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title></title>
<script src="http://code.jquery.com/jquery-1.8.3.min.js"></script>
<script src="http://passport.cnblogs.com/scripts/jsencrypt.min.js"></script>
<script type="text/javascript">
$(function () {
$('#testme').click(function () {
var encrypt = new JSEncrypt();
var pubKey = $('#pubkey').val();
var privkey = $('#privkey').val();
encrypt.setPublicKey(pubKey);
var encrypted = encrypt.encrypt($('#passwd').val());
console.log(encrypted);
var decrypt = new JSEncrypt();
decrypt.setPrivateKey($('#privkey').val());
var uncrypted = decrypt.decrypt(encrypted);
if (uncrypted == $('#passwd').val()) {
alert('It works!!!');
}
console.log(uncrypted);
});
});
</script>
</head>
<body>
<form id="form1" runat="server">
<div>
<label for="pubkey">Public Key</label><br/>
<textarea id="pubkey" rows="15" cols="65">30819f300d06092a864886f70d010101050003818d0030818902818100994614bb2c14a701a7cfd73d107751110dde9f78bdbc9b97eb4e9ccfd587fa3df80c699a345ea1577fd76a191419a10891919b094e42f0bc3fde17c06b10c8b59e3e099426e376499669b7d9b1f17bb8d604b4cca60a39e09de3d51fbe85886240957ad2dbeffcef3427d7f4ca59bbef23ab35722a07fc9d5ef74b87926a579b0203010001</textarea><br/>
<br />
<label for="privkey">Private Key</label><br/>
<textarea id="privkey" rows="15" cols="65">30820277020100300d06092a864886f70d0101010500048202613082025d02010002818100994614bb2c14a701a7cfd73d107751110dde9f78bdbc9b97eb4e9ccfd587fa3df80c699a345ea1577fd76a191419a10891919b094e42f0bc3fde17c06b10c8b59e3e099426e376499669b7d9b1f17bb8d604b4cca60a39e09de3d51fbe85886240957ad2dbeffcef3427d7f4ca59bbef23ab35722a07fc9d5ef74b87926a579b02030100010281804a619415f12264998d1273e5926414d72ddfe78bf4a7deea2eab0bb6606d88a72205040a6d77aedc8391ca4f394de6b3fdd0a76830ae939d0771841d40d7f84e44d949c817e1c9af3d4f48ae82a2b9c51dd5844bc2ef7549497cd1fb6de425cabc881ac709a2fa52af8693f21ea68abe3a6ede68686bf77d3544435860708481024100fd1897e0be000b41a0f8274611209e81c0a151a3d5a263a598c098a97627ee2f95c09fc381f46fc08f304a428df465783f761a74fed0bd4de1c99878bd434b0b0241009b0848d4d96707152aef601afda166f4c2af424ed85d56b93e34d1f3a09f204eeaf2082cd73ee88b63c1eace10cba635f0b0eddab1ed0890d7ddbfb4cf9b7fb1024100ae5d29151e10adb09313230b7475427e25957dc71f40f6e178f106bb88b94db0debc8bd4874d3d482ddd98eb6d1cb86335654a28dbfc36ced704a9d4549f6dad0240245e4727977071dae75d8c4008abaa4954ba6465b69ffece29e79e30f6c71d7f25e26d4487a1fc4f66b180f1a24303d4b787e9e459c4ef337b504bbe90cd3ba1024100d91056b9823941b53d593f253236ba75c382efa5b88365124c70850e8c965e18262b0664440967024d3fe158b1f1c066df8f9031ebc5f2886aa07514c8fe77fb</textarea>
<br/>
<label for="input">Text to encrypt:</label><br />
<input id="passwd" name="passwd" ></input><br />
<input id="testme" type="button" value="submit" /><br />
</div>
</form>
</body>
</html>
二、java服务端解密
1、引入所需jar
<dependency> <groupId>commons-codec</groupId> <artifactId>commons-codec</artifactId> <version>1.4</version> <scope>compile</scope> </dependency> <dependency> <groupId>org.bouncycastle</groupId> <artifactId>bcprov-jdk15on</artifactId> <version>1.52</version> </dependency>
2、添加RSAUtils工具类
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.math.BigInteger;
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.RSAPublicKeySpec;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.ShortBufferException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* RSA表单加密
*
* @author xx
* @version 1.0
* @since 2013-11-10
*/
public class RSAUtils {
private static final Logger LOGGER = LoggerFactory.getLogger(RSAUtils.class);
private static String keyPath = null;
static {
keyPath = RSAUtils.class.getResource("/").getPath() + "RSAKey.txt";
try {
@SuppressWarnings("unused")
RSAPublicKey rsap = (RSAPublicKey) RSAUtils.generateKeyPair().getPublic();
} catch (Exception e) {
LOGGER.error(e.getMessage(), e);
}
}
/**
* * 生成密钥对 *
*
* @return KeyPair
* @throws NoSuchAlgorithmException
* @throws IOException *
* @throws EncryptException
*/
public static KeyPair generateKeyPair() throws NoSuchAlgorithmException, IOException {
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA",
new org.bouncycastle.jce.provider.BouncyCastleProvider());
final int KEY_SIZE = 1024;// 没什么好说的了，这个值关系到块加密的大小，可以更改，但是不要太大，否则效率会低
keyPairGen.initialize(KEY_SIZE, new SecureRandom());
KeyPair keyPair = keyPairGen.generateKeyPair();
saveKeyPair(keyPair);
return keyPair;
}
public static KeyPair getKeyPair() throws IOException, ClassNotFoundException {
FileInputStream fis = new FileInputStream(keyPath);
ObjectInputStream oos = new ObjectInputStream(fis);
KeyPair kp = (KeyPair) oos.readObject();
oos.close();
fis.close();
return kp;
}
public static void saveKeyPair(KeyPair kp) throws IOException {
FileOutputStream fos = new FileOutputStream(keyPath);
ObjectOutputStream oos = new ObjectOutputStream(fos);
// 生成密钥
oos.writeObject(kp);
oos.close();
fos.close();
}
/**
* * 生成公钥 *
*
* @param modulus *
* @param publicExponent *
* @return RSAPublicKey *
* @throws NoSuchAlgorithmException, InvalidKeySpecException
*/
public static RSAPublicKey generateRSAPublicKey(byte[] modulus, byte[] publicExponent)throws NoSuchAlgorithmException, InvalidKeySpecException {
KeyFactory keyFac = KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(new BigInteger(modulus), new BigInteger(publicExponent));
return (RSAPublicKey) keyFac.generatePublic(pubKeySpec);
}
/**
* * 生成私钥 *
*
* @param modulus *
* @param privateExponent *
* @return RSAPrivateKey *
*/
public static RSAPrivateKey generateRSAPrivateKey(byte[] modulus, byte[] privateExponent) throws NoSuchAlgorithmException, InvalidKeySpecException {
KeyFactory keyFac = KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
RSAPrivateKeySpec priKeySpec = new RSAPrivateKeySpec(new BigInteger(modulus), new BigInteger(privateExponent));
return (RSAPrivateKey) keyFac.generatePrivate(priKeySpec);
}
/**
* * 加密 *
*
* @param key 加密的密钥 *
* @param data 待加密的明文数据 *
* @return 加密后的数据
* @throws NoSuchPaddingException
* @throws NoSuchAlgorithmException
* @throws InvalidKeyException
* @throws BadPaddingException
* @throws IllegalBlockSizeException
* @throws ShortBufferException *
* @throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, ShortBufferException, IllegalBlockSizeException, BadPaddingException
*/
public static byte[] encrypt(PublicKey pk, byte[] data) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, ShortBufferException, IllegalBlockSizeException, BadPaddingException {
Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
cipher.init(Cipher.ENCRYPT_MODE, pk);
int blockSize = cipher.getBlockSize();// 获得加密块大小，如：加密前数据为128个byte，而key_size=1024
// 加密块大小为127
// byte,加密后为128个byte;因此共有2个加密块，第一个127
// byte第二个为1个byte
int outputSize = cipher.getOutputSize(data.length);// 获得加密块加密后块大小
int leavedSize = data.length % blockSize;
int blocksSize = leavedSize != 0 ? data.length / blockSize + 1 : data.length / blockSize;
byte[] raw = new byte[outputSize * blocksSize];
int i = 0;
while (data.length - i * blockSize > 0) {
if (data.length - i * blockSize > blockSize)
cipher.doFinal(data, i * blockSize, blockSize, raw, i * outputSize);
else
cipher.doFinal(data, i * blockSize, data.length - i * blockSize, raw, i * outputSize);
// 这里面doUpdate方法不可用，查看源代码后发现每次doUpdate后并没有什么实际动作除了把byte[]放到
// ByteArrayOutputStream中，而最后doFinal的时候才将所有的byte[]进行加密，可是到了此时加密块大小很可能已经超出了
// OutputSize所以只好用dofinal方法。
i++;
}
return raw;
}
/**
* * 解密 *
*
* @param key 解密的密钥 *
* @param raw 已经加密的数据 *
* @return 解密后的明文
* @throws NoSuchPaddingException
* @throws NoSuchAlgorithmException
* @throws InvalidKeyException
* @throws IOException
* @throws BadPaddingException
* @throws IllegalBlockSizeException *
* @throws Exception
*/
@SuppressWarnings("static-access")
public static byte[] decrypt(PrivateKey pk, byte[] raw) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, IOException {
Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
cipher.init(cipher.DECRYPT_MODE, pk);
int blockSize = cipher.getBlockSize();
ByteArrayOutputStream bout = new ByteArrayOutputStream(64);
int j = 0;
while (raw.length - j * blockSize > 0) {
bout.write(cipher.doFinal(raw, j * blockSize, blockSize));
j++;
}
return bout.toByteArray();
}
public static String getRSADecrypt(String str) {
byte[] en_result = hexStringToBytes(str);
byte[] de_result = {};
try {
de_result = RSAUtils.decrypt(RSAUtils.getKeyPair().getPrivate(), en_result);
} catch (Exception e) {
LOGGER.error(e.getMessage(), e);
}
StringBuffer sb = new StringBuffer(new String(de_result));
return sb.reverse().toString();
}
/**
* 16进制 To byte[]
*
* @param hexString
* @return byte[]
*/
public static byte[] hexStringToBytes(String hexString) {
if (hexString == null || hexString.equals("")) {
return null;
}
hexString = hexString.toUpperCase();
int length = hexString.length() / 2;
char[] hexChars = hexString.toCharArray();
byte[] d = new byte[length];
for (int i = 0; i < length; i++) {
int pos = i * 2;
d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
}
return d;
}
/**
* Convert char to byte
*
* @param c char
* @return byte
*/
private static byte charToByte(char c) {
return (byte) "0123456789ABCDEF".indexOf(c);
}
}
3、添加页面表单解密工具类FormDecryptUtils
import java.io.IOException;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.Provider;
import java.security.PublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import javax.crypto.Cipher;
import org.apache.commons.codec.binary.Base64;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 页面表单解密工具类
* <p>
* JS版RSA加密请参考：https://github.com/travist/jsencrypt
* </p>
* @author lh
* @since 2017-05-16
* @version 3.0
*
*/
public class FormDecryptUtils {
private static final Logger LOGGER = LoggerFactory.getLogger(FormDecryptUtils.class);
//private static final String BASE64PUBKEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCfU3jYhR8QzD+0x7SG/gGuQ9w3JOlJJ2CNbN8eAdiDKCPZ9gektP52tZE31txQ5NQraqW13+un16jJTs/iumQVw2n9L5ZmXCDZueNWrOwaaTA6vHs9KD9SgEVM6+7ml0NJpRBeBEr58Dtjzh51f6YDVn0nJeJ6pr0GdWXi3kNqMQIDAQAB";
private static final String BASE64PRIKEY = "MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAJ9TeNiFHxDMP7THtIb+Aa5D3Dck6UknYI1s3x4B2IMoI9n2B6S0/na1kTfW3FDk1CtqpbXf66fXqMlOz+K6ZBXDaf0vlmZcINm541as7BppMDq8ez0oP1KARUzr7uaXQ0mlEF4ESvnwO2POHnV/pgNWfScl4nqmvQZ1ZeLeQ2oxAgMBAAECgYAXUQjzbu/v7mQ4Wa2Sv+ORFD9LFqzJVujraY5xfsWn1B0DDd1qfk5rIwFAkcImWIawX+gmaMG9C3OZGl6UCMESrr+0E7cQceyoz3vHuY2uRuJZq7yfnQyJKmPZ5kf+tY4T9DgfgYvt/J+xz9X5IGQYvUiLpZd9iXLrQYHqoehJbQJBAOOzxbIfJTlF5EU2dKDzM9uKdKeDiZvt4k6tXHM107fstk1rz/NA78IyorRs/uj9hPH82WIwfC9XNMwBhK6+0BMCQQCzIFj6HL0XuNqZoKcTb2O45eYpudIXl2Q2DPKu9pkrmh5fFnSqNhEa2fO/PaYktJTiL0vdm/hNX3KTEr2xdI0rAkEAkwJV+RIyri95mVX3JpLeQDe76Qr7pTiIi9NRhPCTqIOjj4iz0ZFzOiYG9gYI7dQAKVvd3Y8AHnBnHe89ArUfEQJBAIIDaJGhal5dfc0kHiCtKOR7eaOvjB4zdDkHDN6Rfnt3UbQSyHsC40dqCtE0HfNmXuoNCjO/kWoXbUHyyFyVDCECQD7TBTc9JDQ1fJItyL/QrqmXH4ixOjaHS5ZC0eeWxkHdlsTbzibonqk6YC9R0628DB+MYkCdi4rouvvS7V8f50o=";
private static final String KEY_ALGORITHM = "RSA";
/** 安全服务提供者 */
private static final Provider PROVIDER = new BouncyCastleProvider();
/**
* 解密
* @param text
* Base64编码字符串
* @return 解密后的数据
*/
public static String decrypt(String text) {
byte[] data = null;
try {
Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", PROVIDER);
//cipher.init(Cipher.DECRYPT_MODE, RSAUtils.getKeyPair().getPrivate());
cipher.init(Cipher.DECRYPT_MODE, getPrivateKey(BASE64PRIKEY));
data = cipher.doFinal(Base64.decodeBase64(text));
} catch (Exception e) {
LOGGER.error(e.getMessage(),e);
return null;
}
return data != null ? new String(data) : null;
}
/**
* 取得公钥对象
* @param key 公钥key
* @return
* @throws IOException
* @throws NoSuchAlgorithmException
* @throws InvalidKeySpecException
*/
public static PublicKey getPublicKey(String key){
// 解密由base64编码的公钥
byte[] keyBytes = Base64.decodeBase64(key.getBytes());
// 构造X509EncodedKeySpec对象
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
try{
// KEY_ALGORITHM 指定的加密算法
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
return keyFactory.generatePublic(keySpec);
} catch (NoSuchAlgorithmException|InvalidKeySpecException e) {
LOGGER.error(e.getMessage(),e);
return null;
}
}
/**
* 取得私钥对象
* @param key 私钥key
* @return
* @throws Exception
*/
public static PrivateKey getPrivateKey(String key){
byte[] keyBytes = Base64.decodeBase64(key);
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory;
try {
keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
return keyFactory.generatePrivate(keySpec);
} catch (NoSuchAlgorithmException|InvalidKeySpecException e) {
LOGGER.error(e.getMessage(),e);
return null;
}
}
/**
* 取得公钥key(base64加密)
* @return
*/
public static String getPublicKey(){
try {
return new String(Base64.encodeBase64(RSAUtils.getKeyPair().getPublic().getEncoded()));
} catch (ClassNotFoundException | IOException e) {
LOGGER.error(e.getMessage(),e);
return null;
}
}
/**
* 取得私钥key(base64加密)
* @return
*/
public static String getPrivateKey(){
try {
return new String(Base64.encodeBase64(RSAUtils.getKeyPair().getPrivate().getEncoded()));
} catch (ClassNotFoundException | IOException e) {
LOGGER.error(e.getMessage(),e);
return null;
}
}
}
4、对js加密的内容解密
model.setLoginPwd(FormDecryptUtils.decrypt(model.getLoginPwd()));
相关推荐
这个TestRSA项目提供的应该是完整的示例代码，包括JS端的加密函数和Java端的解密Servlet，可以直接部署运行，帮助开发者理解和实践RSA加密的客户端-服务器通信。通过分析和运行这些代码，开发者可以深入理解RSA加密...
经过本人修改，简化并完善了别人的代码，使其更加的容易理解和学习！ 此为一个完整的项目，...功能：服务端随机生成密钥，JS用公钥加密，服务端用私钥解密。用到的JS加密文件是从官网下载的最新版，速度快，稳定性好！
在这个场景中，客户端（浏览器）通常会使用JavaScript库，如`jsencrypt.js`，来实现RSA加密。`jsencrypt.js`是一个轻量级的JavaScript库，它提供了简单易用的接口来进行RSA加密。用户可以在浏览器中加载这个库，然后...
这篇博文"关于使用JS前台加密、JAVA后台解密的RSA实现，RSA加密和签名"探讨了如何在JavaScript前端进行RSA加密，并在Java后端进行解密，以及如何使用RSA进行数字签名。 RSA加密的核心在于一对公钥和私钥。公钥用于...
总的来说，"js加密服务端解密"是一种常见的安全通信模式，通过结合JavaScript和Java，利用RSA非对称加密算法，实现了客户端数据的加密和服务器端的安全解密，有效保护了用户的隐私和数据安全。在实际开发中，还需要...
在提供的压缩包中，有两个Java文件（RSACrypt.java和RSACryptTest.java）和一个JavaScript文件（jsencrypt.min.js），这表明代码实现了RSA加密解密的Java版本和JavaScript版本，可以在客户端和服务端之间进行安全的...
总结来说，这个压缩包提供了一套完整的RSA加密解密解决方案，涵盖了客户端的JavaScript加密和服务器端的Java解密。通过这些工具，开发者可以在JSP应用中安全地处理用户的敏感信息，提升系统的安全性。
通过分析和理解这些代码，我们可以更好地掌握AES+RSA加密服务端的工作原理和实现细节。 综上所述，"AES+RSA加解密服务端"是信息安全领域的一个重要应用，它利用了两种加密算法的优势，确保了数据在传输过程中的安全...
在实际应用中，这种Java和JavaScript之间的RSA加密解密方案可以增强安全性，防止数据在传输过程中被窃取。但需要注意的是，RSA的效率较低，不适用于大量数据的加密，一般用于加密较小的密钥或者对其他算法的密钥进行...
在Flutter和Java混合开发的场景中，"flutter加密java解密"的主题涉及到如何在Flutter客户端与Java后台之间进行安全的数据交互，确保信息在传输过程中不被窃取或篡改。这里我们将详细讨论如何实现这一目标，并保证App...
在本文中，我们将深入探讨如何使用Java来模仿QQ通信，并实现RSA加密解密技术，同时涉及多客户端连接和消息安全性的关键概念。首先，我们来看看socket编程，它是网络通信的基础。 **Socket编程**： Socket是网络上的...
如果源码与此有关，可能涉及将RSA加密应用于Word文档内容的某部分，或者是在处理XML数据时使用了RSA加密。 8. **安全注意事项**： 在实际应用中，务必妥善保管私钥，避免暴露。同时，由于RSA的加密速度较慢，通常...
本文将深入探讨基于`AES+RSA`的加密客户端实现，以及如何利用`Cryptopp`库进行加解密操作。`AES`（Advanced Encryption Standard）是一种对称加密算法，用于快速加密大量数据，而`RSA`（Rivest-Shamir-Adleman）是一...
Java实现RSA加密解密,数字证书生成与验证,模拟两个端通信，AB双方通信,客户端A把需要传输的文件MD5值用自己的私钥生成数字签名,连同明文用服务端B的公钥加密后传送给服务端B,服务端B用私钥解密验证数字签名,并计算...
【标题】基于AES和RSA加密的文件上传系统，服务端Servlet+Jetty，客户端SpringBoot.zip 本项目是一个综合性的IT毕业设计，旨在实现一个安全的文件上传系统，结合了现代密码学中的两种主要加密算法——AES（高级加密...
本文将深入探讨如何在服务器集成环境中实现在客户端进行数据的加密和解密，以及相关的JavaScript安全和LocalStorage的应用。 首先，理解“客户端加密”意味着数据在用户的设备（如浏览器）上进行加密，而不是在...
JavaScript代码会使用公钥对数据进行RSA加密，然后发送到服务器。服务器端的Java程序接收这些数据，使用私钥进行RSA解密，接着可能再使用AES解密数据，或者在服务器端使用AES对新生成的数据进行加密后再返回给前端。...