JAVA RSA 前后端代码实现践行记录

最新推荐文章于 2025-05-07 13:44:29 发布
最新推荐文章于 2025-05-07 13:44:29 发布
阅读量1k 收藏 13
点赞数 8
CC 4.0 BY-SA版权
分类专栏： 技术分享区 文章标签： rsa java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kkillala/article/details/107957117

有时候后端需要通过回调来与前端交互，但回调url上往往有关键性的信息例如用户的token，为了防止此链接被恶意拦截反复使用，有必要将关键参数加上时间戳并用加密算法加密与前端交互。前端可以控制时间戳大于多少分钟则忽略此token，拦截者不知道密钥情况下无法伪造加密文，就可以避免此链接反复被使用。因为前端代码能被破解故而使用非对称加密算法RSA。【当然，前端手机用户可以通过修改系统时间来破解此判断，但可以往所有与后端接口交互中后端加入时间戳判断，一样可以解决此问题。】

后端RSA加解密算法

网上有些算法是只支持加密117位解密128位限制的写法，以下参考互联网的一些代码，变为不限制，密钥长度为1024位，若改为2048位则需要变更解密算法的长度为256。

import org.bouncycastle.jce.provider.BouncyCastleProvider;
import sun.misc.BASE64Decoder;

import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Arrays;
import java.util.Base64;

/**
 * @author katasea
 * 2020/8/11 11:01
 */
public class RSAUtils4Mall {


	private static final String RSA_ALGORITHM = "RSA";
	private static final int MAX_DECRYPT_BLOCK = 128;
	private static final int MAX_ENCRYPT_BLOCK = 117;
	private static RSAPublicKey publicKey;
	private static RSAPrivateKey privateKey;

	public RSAPublicKey getPublicKey() {
		return RSAUtils4Mall.publicKey;
	}
	public RSAPrivateKey getPrivateKey() {
		return RSAUtils4Mall.privateKey;
	}

	public void getKeys() throws Exception {
		// 从 公钥保存的文件 读取 公钥的Base64文本
		String pubKeyBase64 = "你自己的公钥，可以放此处方便固定，若不需要固定则使用geneKeys() 方法";
// 把 公钥的Base64文本 转换为已编码的 公钥bytes
		byte[] encPubKey = new BASE64Decoder().decodeBuffer(pubKeyBase64);

// 创建 已编码的公钥规格
		X509EncodedKeySpec encPubKeySpec = new X509EncodedKeySpec(encPubKey);

// 获取指定算法的密钥工厂, 根据 已编码的公钥规格, 生成公钥对象
		publicKey = (RSAPublicKey)KeyFactory.getInstance("RSA").generatePublic(encPubKeySpec);

		// 从 私钥保存的文件 读取 私钥的base文本
		String priKeyBase64 = "你自己的私钥，可以放此处方便固定，若不需要固定则使用geneKeys() 方法";

// 把 私钥的Base64文本 转换为已编码的 私钥bytes
		byte[] encPriKey = new BASE64Decoder().decodeBuffer(priKeyBase64);

// 创建 已编码的私钥规格
		PKCS8EncodedKeySpec encPriKeySpec = new PKCS8EncodedKeySpec(encPriKey);

// 获取指定算法的密钥工厂, 根据 已编码的私钥规格, 生成私钥对象
		privateKey = (RSAPrivateKey)KeyFactory.getInstance("RSA").generatePrivate(encPriKeySpec);
	}

	public void geneKeys() throws NoSuchAlgorithmException {
		KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(RSA_ALGORITHM, new BouncyCastleProvider());
		keyPairGenerator.initialize(1024);
		KeyPair keyPair = keyPairGenerator.generateKeyPair();
		privateKey = (RSAPrivateKey) keyPair.getPrivate();
		publicKey = (RSAPublicKey) keyPair.getPublic();
	}


	public String encodeByPrivateKey(String body) throws Exception {
		Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
		cipher.init(Cipher.ENCRYPT_MODE, privateKey);
		byte[] inputArray = body.getBytes();
		int inputLength = inputArray.length;
		System.out.println("加密字节数：" + inputLength);
		// 标识
		int offSet = 0;
		byte[] resultBytes = {};
		byte[] cache = {};
		while (inputLength - offSet > 0) {
			if (inputLength - offSet > MAX_ENCRYPT_BLOCK) {
				cache = cipher.doFinal(inputArray, offSet, MAX_ENCRYPT_BLOCK);
				offSet += MAX_ENCRYPT_BLOCK;
			} else {
				cache = cipher.doFinal(inputArray, offSet, inputLength - offSet);
				offSet = inputLength;
			}
			resultBytes = Arrays.copyOf(resultBytes, resultBytes.length + cache.length);
			System.arraycopy(cache, 0, resultBytes, resultBytes.length - cache.length, cache.length);
		}
		return Base64.getEncoder().encodeToString(resultBytes);
	}

	public String encodeByPublicKey(String body) throws Exception {
		Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
		cipher.init(Cipher.ENCRYPT_MODE, publicKey);
		byte[] inputArray = body.getBytes();
		int inputLength = inputArray.length;
		System.out.println("加密字节数：" + inputLength);
		// 标识
		int offSet = 0;
		byte[] resultBytes = {};
		byte[] cache = {};
		while (inputLength - offSet > 0) {
			if (inputLength - offSet > MAX_ENCRYPT_BLOCK) {
				cache = cipher.doFinal(inputArray, offSet, MAX_ENCRYPT_BLOCK);
				offSet += MAX_ENCRYPT_BLOCK;
			} else {
				cache = cipher.doFinal(inputArray, offSet, inputLength - offSet);
				offSet = inputLength;
			}
			resultBytes = Arrays.copyOf(resultBytes, resultBytes.length + cache.length);
			System.arraycopy(cache, 0, resultBytes, resultBytes.length - cache.length, cache.length);
		}
		return Base64.getEncoder().encodeToString(resultBytes);
	}

	public String decodeByPublicKey(String body) throws Exception {
		Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
		cipher.init(Cipher.DECRYPT_MODE, publicKey);
		return decryptByPublicKey(body);
	}

	public String decodeByPrivateKey(String body) throws Exception {
		Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
		cipher.init(Cipher.DECRYPT_MODE, privateKey);
		return decryptByPrivateKey(body);
	}

	public String decryptByPublicKey(String encryptedStr) {
		try {
			// 对公钥解密
			byte[] privateKeyBytes = publicKey.getEncoded();
			// 获得公钥
			X509EncodedKeySpec keySpec = new X509EncodedKeySpec(privateKeyBytes);
			// 获得待解密数据
			byte[] data = decryptBase64(encryptedStr);
			KeyFactory factory = KeyFactory.getInstance("RSA");
			PublicKey publicKey = factory.generatePublic(keySpec);
			// 对数据解密
			Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
			cipher.init(Cipher.DECRYPT_MODE, publicKey);
			// 返回UTF-8编码的解密信息
			int inputLen = data.length;
			ByteArrayOutputStream out = new ByteArrayOutputStream();
			int offSet = 0;
			byte[] cache;
			int i = 0;
			// 对数据分段解密
			while (inputLen - offSet > 0) {
				if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
					cache = cipher.doFinal(data, offSet, MAX_DECRYPT_BLOCK);
				} else {
					cache = cipher.doFinal(data, offSet, inputLen - offSet);
				}
				out.write(cache, 0, cache.length);
				i++;
				offSet = i * MAX_DECRYPT_BLOCK;
			}
			byte[] decryptedData = out.toByteArray();
			out.close();
			return new String(decryptedData, "UTF-8");
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}



	/**
	 * 私钥解密
	 *
	 * @param encryptedStr
	 * @return
	 */
	public String decryptByPrivateKey(String encryptedStr) {
		try {
			// 对私钥解密
			byte[] privateKeyBytes = privateKey.getEncoded();
			// 获得私钥
			PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
			// 获得待解密数据
			byte[] data = decryptBase64(encryptedStr);
			KeyFactory factory = KeyFactory.getInstance("RSA");
			PrivateKey privateKey = factory.generatePrivate(keySpec);
			// 对数据解密
			Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
			cipher.init(Cipher.DECRYPT_MODE, privateKey);
			// 返回UTF-8编码的解密信息
			int inputLen = data.length;
			ByteArrayOutputStream out = new ByteArrayOutputStream();
			int offSet = 0;
			byte[] cache;
			int i = 0;
			// 对数据分段解密
			while (inputLen - offSet > 0) {
				if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
					cache = cipher.doFinal(data, offSet, MAX_DECRYPT_BLOCK);
				} else {
					cache = cipher.doFinal(data, offSet, inputLen - offSet);
				}
				out.write(cache, 0, cache.length);
				i++;
				offSet = i * MAX_DECRYPT_BLOCK;
			}
			byte[] decryptedData = out.toByteArray();
			out.close();
			return new String(decryptedData, "UTF-8");
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * BASE64 解码
	 *
	 * @param key 需要Base64解码的字符串
	 * @return 字节数组
	 */
	public static byte[] decryptBase64(String key) {
		return Base64.getDecoder().decode(key);
	}


	public static void main(String[] args) throws Exception {
		RSAUtils4Mall rsaUtils = new RSAUtils4Mall();
		//使用固定key
		rsaUtils.getKeys();
		//使用自动生成key 一台机器会生成一次并固定，后续可以后端开放获取公钥接口给前端，用来解决公钥变化问题。也可以直接使用上面固定公私钥
//		rsaUtils.geneKeys();
		String plain = "{\"Authorization\":\"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1OTY3OTA5NjYsInRlcm1fdHlwZSI6bnVsbCwidXNlcl9uYW1lIjoiMTI4Nzc1Njc1NTIxMTY0OTA2NiIsImp0aSI6IjM5NjM2ZDBiLTcxOGUtNGIxYS04ZTZiLWExNDc4ZGMyYThhZCIsImNsaWVudF9pZCI6ImZyb250ZW5kIiwic2NvcGUiOlsiYWxsIl19.WRD-T4tpXLpAA7VaSNCdmVdh0cjqVlLI-Vq0lJw9QZI\",\"timestamp\":\"20200811 135244\"}";
		String encryptData = rsaUtils.encodeByPublicKey(plain);
		String encryptData2 = rsaUtils.encodeByPrivateKey(plain);
		System.out.println("公钥加密："+encryptData);
		System.out.println("私钥加密："+encryptData2);
		System.out.println("私钥解密后:" + rsaUtils.decodeByPrivateKey(encryptData));
		System.out.println("公钥解密后:" + rsaUtils.decodeByPublicKey(encryptData2));
		String encodes = rsaUtils.encodeByPrivateKey("123");
		System.out.println("加密前:" + 123);
		System.out.println("公钥:" + Base64.getEncoder().encodeToString(RSAUtils4Mall.publicKey.getEncoded()));
		System.out.println("私钥:" + Base64.getEncoder().encodeToString(RSAUtils4Mall.privateKey.getEncoded()));
		System.out.println("私钥加密后:" + encodes);
		System.out.println("公钥加密后:" + rsaUtils.encodeByPublicKey("123"));
		System.out.println("公钥解密后:" + rsaUtils.decodeByPublicKey(encodes));
		String plain2 = "fELmp2H3m%2BhY9DnZHj6QmgxVqVXGTDDeCXxfYNDM2ow6E0hVGQ%2FjT%2FiSMKTxJoXTJS1I2XouybUczzBppF6fDUTwlyNIFViI9wO2ErfEEnikwc9O%2Bgt1SuOScZjLVpkvrw0RrcXzhg1n2rqqJuzYwG0lvrpIAg2haJmyzgiCn4oRiBHexLNQ%2BLcJdYu%2FN9BTndk1ytuPX4osiue1kGBrqKMW3zX97m7%2FRdqeS90OyW29C5tcDq80eWQQXteh0B2L%2B2wgEwiGMLnKw4EOdTYSyJ1k9tQQ90JA4gj%2BlwEgyQ3yB7Gj0ZrqplxoSxJ8NnNbNtHRfGKbB60rvMIHD4Z7SpQZRHsZyihT3CdAdwOzvu91ZSq52EQOLPE0EkMfHDtent1ExOliB950YLJFn%2BHKQTuixDyUusUzABhpOJfp1bxjJDcJPlWoMWoe%2B8%2B2mzMIiVsvKKsgIZivsLm%2FWnNkKr0F9wBJ1RS6yuWr0z7yzg3%2BxfUQyNyPSJXdv2cOq%2B3G";
		plain2 = URLDecoder.decode(plain2,"UTF-8");
		System.out.println(plain2);
		System.out.println(rsaUtils.decodeByPublicKey(plain2));
	}
}

具体使用样例如下，由于放置与url跳转到前端，故而需要对加密后的密文做url 编码，否则+号等会丢失。

try {
				log.info("RSA加密前报文：{}", JSONObject.toJSONString(paramMap));
				RSAUtils4Mall rsaUtils = new RSAUtils4Mall();
				rsaUtils.getKeys();
				encryptData = rsaUtils.encodeByPublicKey(JSONObject.toJSONString(paramMap));
				log.info("RSA加密后报文：{}", encryptData);
				encryptData = URLEncoder.encode(encryptData,"UTF-8");
			} catch (Exception e) {
				e.printStackTrace();
				log.error("返回前端token时候加密失败了！{}", e.getMessage());
			}

URLEncoder.encode 编码对应前端的 decodeURIComponent() 来解码

前端RSA加解密算法

注意、由于前端使用jsencrypt.js实现加解密，其中它默认公钥加密，私钥解密，故而服务端如果加密务必使用公钥加密，前端这边用私钥解密。反之无法测试成功。一般公钥加密，私钥用于签名。因为公钥加密只有私钥才能解密，而如果私钥加密知道公钥的都可以解密。这里虽然私钥放于前端会被人截获，但是公钥这边并未对外开放。这里穿插一个个人的理解，密钥对其实是一个长一个短，一般短的用来加密，长的用来签名效率会比反之来的快。所谓公钥私钥只是一个概念，对外开放的就是公钥。不管对不对，反正工具是死的。

前端测试页面代码

<script>
    //获取url后面的密文参数 
    var encryptData = getQueryVariable("encryptData")
    // var publicKey= "相对短的公钥";
    var privateKey="你的长长的私钥";
    // var plain = "{\"Authorization\":\"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1OTY3OTA5NjYsInRlcm1fdHlwZSI6bnVsbCwidXNlcl9uYW1lIjoiMTI4Nzc1Njc1NTIxMTY0OTA2NiIsImp0aSI6IjM5NjM2ZDBiLTcxOGUtNGIxYS04ZTZiLWExNDc4ZGMyYThhZCIsImNsaWVudF9pZCI6ImZyb250ZW5kIiwic2NvcGUiOlsiYWxsIl19.WRD-T4tpXLpAA7VaSNCdmVdh0cjqVlLI-Vq0lJw9QZI\",\"timestamp\":\"20200811 135244\"}";
    var encrypt = new JSEncrypt();
    // encrypt.setPublicKey(publicKey);
    encrypt.setPrivateKey(privateKey);
    // alert(encrypt.encryptLong(plain));
    if(encryptData!=null) {
        alert(encryptData);
		//URL解码 将 %2 解码 + 等
        encryptData = decodeURIComponent(encryptData);
        alert(encryptData);
        alert(encrypt.decryptLong(encryptData));
    }

	/**
	 *  这里将密文放于url后面，通过这个方法可以获取url后面参数的具体值。
	 *  eg : http://a.b.com?param=xxxx    传入param 获取 xxxx
	 */
    function getQueryVariable(variable)
    {
        var query = window.location.search.substring(1);
        var vars = query.split("&");
        for (var i=0;i<vars.length;i++) {
            var pair = vars[i].split("=");
            if(pair[0] == variable){return pair[1];}
        }
        return(false);
    }
</script>

网上找的 jsencrypt.js基本无法使用，尤其是长度超过默认限制的加密117 解密128 的新增方法段，更是各种抄来抄去，后面寻的一个可以使用的。建议大家调试的时候先脚本加密看看与后台加密的密文是否一致。由简到难

这里贴出关键方法

//十六进制转字节
    function hexToBytes(hex) {
        for (var bytes = [], c = 0; c < hex.length; c += 2)
            bytes.push(parseInt(hex.substr(c, 2), 16));
        return bytes;
    }

    // 字节转十六进制
    function bytesToHex(bytes) {
        for (var hex = [], i = 0; i < bytes.length; i++) {
            hex.push((bytes[i] >>> 4).toString(16));
            hex.push((bytes[i] & 0xF).toString(16));
        }
        return hex.join("");
    }


  //先增加上面两个方法 ， 寻找源文件里面的 加解密算法，在旁边增加


  JSEncrypt.prototype.decryptLong = function (string) {
            var k = this.getKey();
            // var MAX_DECRYPT_BLOCK = ((k.n.bitLength()+7)>>3);
            var MAX_DECRYPT_BLOCK = 128;
            try {
                var ct = "";
                var t1;
                var bufTmp;
                var hexTmp;
                var str = b64tohex(string);
                var buf = hexToBytes(str);
                var inputLen = buf.length;
                //开始长度
                var offSet = 0;
                //结束长度
                var endOffSet = MAX_DECRYPT_BLOCK;

                //分段加密
                while (inputLen - offSet > 0) {
                    if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                        bufTmp = buf.slice(offSet, endOffSet);
                        hexTmp = bytesToHex(bufTmp);
                        t1 = k.decrypt(hexTmp);
                        ct += t1;

                    } else {
                        bufTmp = buf.slice(offSet, inputLen);
                        hexTmp = bytesToHex(bufTmp);
                        t1 = k.decrypt(hexTmp);
                        ct += t1;

                    }
                    offSet += MAX_DECRYPT_BLOCK;
                    endOffSet += MAX_DECRYPT_BLOCK;
                }
                return ct;
            } catch (ex) {
                return ex;
            }
        };


JSEncrypt.prototype.encryptLong = function (string) {
            var k = this.getKey();
            //var MAX_ENCRYPT_BLOCK = (((k.n.bitLength() + 7) >> 3) - 11);
            var MAX_ENCRYPT_BLOCK = 117;

            try {
                var lt = "";
                var ct = "";
                //RSA每次加密117bytes，需要辅助方法判断字符串截取位置
                //1.获取字符串截取点
                var bytes = new Array();
                bytes.push(0);
                var byteNo = 0;
                var len, c;
                len = string.length;

                var temp = 0;
                for (var i = 0; i < len; i++) {
                    c = string.charCodeAt(i);
                    if (c >= 0x010000 && c <= 0x10FFFF) {
                        byteNo += 4;
                    } else if (c >= 0x000800 && c <= 0x00FFFF) {
                        byteNo += 3;
                    } else if (c >= 0x000080 && c <= 0x0007FF) {
                        byteNo += 2;
                    } else {
                        byteNo += 1;
                    }
                    if ((byteNo % MAX_ENCRYPT_BLOCK) >= 114 || (byteNo % MAX_ENCRYPT_BLOCK) == 0) {
                        if (byteNo - temp >= 114) {
                            bytes.push(i);
                            temp = byteNo;
                        }
                    }
                }

                //2.截取字符串并分段加密
                if (bytes.length > 1) {
                    for (var i = 0; i < bytes.length - 1; i++) {
                        var str;
                        if (i == 0) {
                            str = string.substring(0, bytes[i + 1] + 1);
                        } else {
                            str = string.substring(bytes[i] + 1, bytes[i + 1] + 1);
                        }
                        var t1 = k.encrypt(str);
                        ct += t1;
                    }
                    ;
                    if (bytes[bytes.length - 1] != string.length - 1) {
                        var lastStr = string.substring(bytes[bytes.length - 1] + 1);
                        ct += k.encrypt(lastStr);
                    }
                    return hex2b64(ct);
                }
                var t = k.encrypt(string);
                var y = hex2b64(t);
                return y;
            } catch (ex) {
                return ex;
            }
        };

完整的jsencrypt.js 上传到百度云盘了。
链接: https://pan.baidu.com/s/1Savj-671W8dOZzbNDRxtyA 提取码: 9t9e

shell实例手册
yonggeit的博客
05-27 6428
shell实例手册 1文件{ touch file # 创建空白文件 rm -rf 目录名 # 不提示删除非空目录(-r:递归删除 -f强制) dos2unix # windows文本转linux文本 unix2dos # linux文本转windows文本 enca filename ...
JAVA RSA算法工具类
zoubaicai的博客
11-09 1万+
JAVA自带包实现RSA工具类
记录后端实现RSA加解密过程及问题解决
qq_45797293的博客
11-13 1158
前后端分离框架搭建，后端开始使用spring security的PasswordEncoder.encode()方法进行的加密，发现在前端想要修改加密内容的时候没法进行解密，就想着集成RSA加密方式来实现，之间遇到了各种问题。尝试过修改位数，检测字符是不是合适等等，一直以为是base64字符串的问题。这是我第一次使用测试工具请求接口的报错，当时理解有问题，一直以为是单纯的Base64字符串的问题。这里是我第一次配置提供的是密钥，结尾都是以**…这里做以下修改，以为是base64的错误，将**…
Java 使用 RSA算法 进行前后端加密解密
m0_61341973的博客
05-16 3470
ts前端使用forge的RSA算法対密码进行加密,Java后端进行解密 .forge还支持ED25519 RSA,RSA-KEM,X.509,PKCS#5,PKCS#7等多种算法的加密解密。
实现RSA加密与Java解密的前后端通信流程
最新发布
weixin_42601547的博客
05-07 963
RSA的核心思想是基于一个简单的数学事实：将两个大质数相乘十分容易，但想要对其乘积进行质因数分解却极为困难。这种特性使得RSA成为了计算上难以破解的加密方法，尤其适用于需要公开加密密钥的场景。在JavaScript中，为了简化RSA加密和解密的过程，开发者们通常会依赖于成熟的第三方库。其中，crypto-js和jsrsasign是两款广泛使用的加密库，各自拥有独特的功能和用途。crypto-js是一个用于加密的JavaScript库，支持多种加密算法，包括但不限于AES、DES、RSA等。
【java】前端RSA加密后端解密
m0_74824574的博客
12-11 1659
System.out.println(“解密数据：”+decryptFromBase64(privateBase64, encryptToBase64(publicBase64, “hello world”)));System.out.println(“解密数据：”+RsaUtil.decryptFromBase64(privateBase64, data));// System.out.println(“解密数据：”+decryptFromBase64(privateBase64, data));
使用RSA算法实现表单数据加密——前端js后端Java
YangangwuWuyangang的专栏
11-30 2749
使用RSA算法实现表单数据加密——前端js后端Java
springboot+security基于前后端分离的RSA密码加密登录流程
Mr_chen的博客
06-07 4689
????摘要 今天分享下 —— springboot 前后端分离，实现 RSA加密 ，欢迎关注！ ????RSA加密简介 RSA加密 是一种非对称加密。可以在不直接传递密钥的情况下，完成解密。这能够确保信息的安全性，避免了直接传递密钥所造成的被破解的风险。是由一对密钥来进行加解密的过程，分别称为公钥和私钥。两者之间有数学相关，该加密算法的原理就是对一极大整数做因数分解的困难性来保证安全性。通常个人保存私钥，公钥是公开的（可能同时多人持有）。 ✨RSA加密 加密是为了安全性考虑，简单的说，加密
java实现RSA的简单加密解密
infi
01-18 3万+
RSAUtil   package com.zhuyun.rsa; import java.io.IOException; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.PrivateKey;...
Rsa前后端交互（JAVA && JS）
珈蓝的博客
03-16 2323
问题描述     问题描述：在应用程序测试过程中，检测到将未加密的登录请求发送到服务器。由于登录过程中所使用的部分输入字段（例如：用户名、密码、电子邮件地址、社会安全号等）是个人敏感信息，因此建议通过加密连接（例如 SSL）将其发送到服务器。任何以明文传给服务器的信息都可能被窃，稍后可用来电子欺骗身份或伪装用户。此外，若干隐私权法规指出，用户凭证之类的敏感信息一律以加密方式传给 Web 站点。     安全风险：可能会窃取诸如用
RSA前端JS加密，后端JAVA解密实现
ccecwg的专栏
01-20 7987
用RSA非对称加密方式实现。后台生成rsa密钥对，然后在页面设置rsa公钥，提交时用公钥加密密码，生成的密文传到后台，后台再用私钥解密，获取密码明文。     这样客户端只需要知道rsa加密方式和公钥，前台不知道私钥是无法解密的，此解决方案还是相对比较安全的。     需要到http://www.bouncycastle.org下载bcprov-jdk16-140.jar文件。     缺陷
JavaScript-RSA加解密
08-10
RSA前端加解密。是通过用jsencrypt.min.js来实现的，支持超长文本加解密。亲测可用。
java RSA
guolian3382的专栏
07-22 585
package test;     import java.io.ByteArrayOutputStream;   import java.io.File;   import java.io.FileInputStream;   import java.math.BigInteger;   import java.security.Key;   import java.security.KeyFactory;   import java.security.KeyPair;   import java.sec
rsa 前后端加解密
weixin_30470857的博客
07-18 842
1、服务端加密解密： import org.bouncycastle.jce.provider.BouncyCastleProvider; import javax.crypto.Cipher; import java.io.ByteArrayOutputStream; import java.security.*; import java.security.interfaces...
前后端如何实现非对称加解密-使用RSA为例讲解！
舒一笑的博客
07-10 1194
写在最前面，RSA是一种非对称加密算法，使用不同的公钥和私钥进行加密和解密。
java RSA加密解密实现
热门推荐
Central-Perk的专栏
01-24 8万+
该工具类中用到了BASE64，需要借助第三方类库：javabase64-1.3.1.jar 下载地址：http://download.csdn.net/detail/centralperk/5025595 注意： RSA加密明文最大长度117字节，解密要求密文最大长度为128字节，所以在加密和解密的过程中需要分块进行。 RSA加密对明文的长度是有限制的，如果加密数据过大会抛出如下异常：
Java 工具类 RSA加解密
weixin_45414738的博客
06-24 452
import org.apache.commons.codec.binary.Base64; import javax.crypto.Cipher; import java.security.*; import java.security.interfaces.RSAPrivateKey; import java.security.interfaces.RSAPublicKey; import java.security.spec.PKCS8EncodedKeySpec; import java.sec..
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

呆呆的小青蛙

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值