RAS算法，JS公钥加密，JAVA私钥解密

最新推荐文章于 2024-09-12 17:12:18 发布
最新推荐文章于 2024-09-12 17:12:18 发布
阅读量2.4k 收藏 4
点赞数 2
分类专栏： 算法类

总体思路：前端用公钥加密，后端用私钥解密rsa.html  展示了js进行加密、解密的过程RSAUtil.java  是一个java类，后端用到的RSA加解密工具类，里面包含了一个main方法，可以允许进行测试一般范式  

1、前端请求后端生成RSA公钥信息；

 2、后台端可以利用RSAUtil.java生成的RSA信息，将私钥自己存起来，将公钥返回给前端 

 

 3、前端拿到公钥，进行加密，并提交加密后的密文给后端  4、后端拿到前端提交过来的密文，利用之前生成好的私钥进行解密

 

rsa.html
 


<!DOCTYPE html>

<html>

<head>

    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>

    <meta name=viewport content="width=device-width,initial-scale=1,minimum-scale=1,maximum-scale=1,user-scalable=no">

    <meta http-equiv="Cache-Control" content="no-transform"/>

    <meta http-equiv="Cache-Control" content="no-siteapp"/>

    <meta name="applicable-device" content="pc,mobile">

	<script language="JavaScript" type="text/javascript" src="http://www-cs-students.stanford.edu/~tjw/jsbn/jsbn.js"></script>

	<script language="JavaScript" type="text/javascript" src="http://www-cs-students.stanford.edu/~tjw/jsbn/jsbn2.js"></script>

	<script language="JavaScript" type="text/javascript" src="http://www-cs-students.stanford.edu/~tjw/jsbn/prng4.js"></script>

	<script language="JavaScript" type="text/javascript" src="http://www-cs-students.stanford.edu/~tjw/jsbn/rng.js"></script>

	<script language="JavaScript" type="text/javascript" src="http://www-cs-students.stanford.edu/~tjw/jsbn/rsa.js"></script>

	<script language="JavaScript" type="text/javascript" src="http://www-cs-students.stanford.edu/~tjw/jsbn/rsa2.js"></script>

    <title>RSA</title>

</head>

<body>
<script type="text/javascript">
		// 这个是后台生成并返回的RSA信息（公钥）
var RSADo = {
	"modulus":"a5261939975948bb7a58dffe5ff54e65f0498f9175f5a09288810b8975871e99af3b5dd94057b0fc07535f5f97444504fa35169d461d0d30cf0192e307727c065168c788771c561a9400fb49175e9e6aa4e23fe11af69e9412dd23b0cb6684c4c2429bce139e848ab26d0829073351f4acd36074eafd036a5eb83359d2a698d3",

	"publicExponent":"10001"}
var privateKey= "8e9912f6d3645894e8d38cb58c0db81ff516cf4c7e5a14c7f1eddb1459d2cded4d8d293fc97aee6aefb861859c8b6a3d1dfe710463e1f9ddc72048c09751971c4a580aa51eb523357a3cc48d31cfad1d4a165066ed92d4748fb6571211da5cb14bc11b6e2df7c1a559e6d5ac1cd5c94703a22891464fba23d0d965086277a161"

		// 加密：要测试的明文数据

		var str = 'test就撒3242旦立刻反击啊是！@#￥#%……￥#%43' 

		// 实例化js的RSA对象生成
		var rsa = new RSAKey()
		rsa.setPublic(RSADo.modulus, RSADo.publicExponent)
		var encryptStr = rsa.encrypt(str);
		console.log('RSADo', JSON.stringify(RSADo))
		console.log('明文（explain）：', str)
		console.log('加密后（encrypt）：', encryptStr)
		// 解密
		rsa.setPrivate(RSADo.modulus, RSADo.publicExponent, privateKey)
		var decryptStr = rsa.decrypt(encryptStr)
		console.log('解密私钥：', privateKey)
		console.log('解密后（decrypt）', decryptStr)
</script>
</body>
</html>

RSAUtil.java


package com.xxx.common.crypto;

 

import javax.crypto.Cipher;

import java.io.ByteArrayOutputStream;

import java.math.BigInteger;

import java.security.KeyFactory;

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.NoSuchAlgorithmException;

import java.security.interfaces.RSAPrivateKey;

import java.security.interfaces.RSAPublicKey;

import java.security.spec.RSAPrivateKeySpec;

import java.security.spec.RSAPublicKeySpec;

 

 

public class RSAUtil {

    private static final int MAX_ENCRYPT_BLOCK = 117; // RSA最大加密明文大小

    private static final int MAX_DECRYPT_BLOCK = 128; // RSA最大解密密文大小

 

    /**

     * 生成公钥和私钥

     *

     * @throws NoSuchAlgorithmException

     */

    public static KeyPair genRSAKeyPair() throws NoSuchAlgorithmException {

        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");

        keyPairGen.initialize(1024);

        return keyPairGen.generateKeyPair();

    }

 

    /**

     * 使用模和指数生成RSA公钥

     * 注意：【此代码用了默认补位方式，为RSA/None/PKCS1Padding，不同JDK默认的补位方式可能不同，如Android默认是RSA

     * /None/NoPadding】

     *

     * @param modulus  模

     * @param exponent 指数

     * @return

     */

    public static RSAPublicKey getPublicKey(String modulus, String exponent) {

        try {

            BigInteger b1 = new BigInteger(modulus, 16);

            BigInteger b2 = new BigInteger(exponent, 16);

            KeyFactory keyFactory = KeyFactory.getInstance("RSA");

            RSAPublicKeySpec keySpec = new RSAPublicKeySpec(b1, b2);

            return (RSAPublicKey) keyFactory.generatePublic(keySpec);

        } catch (Exception e) {

            e.printStackTrace();

            return null;

        }

    }

 

    /**

     * 使用模和指数生成RSA私钥

     * 注意：【此代码用了默认补位方式，为RSA/None/PKCS1Padding，不同JDK默认的补位方式可能不同，如Android默认是RSA

     * /None/NoPadding】

     *

     * @param modulus  模

     * @param exponent 指数

     * @return

     */

    public static RSAPrivateKey getPrivateKey(String modulus, String exponent) {

        try {

            BigInteger b1 = new BigInteger(modulus, 16);

            BigInteger b2 = new BigInteger(exponent, 16);

            KeyFactory keyFactory = KeyFactory.getInstance("RSA");

            RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(b1, b2);

            return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);

        } catch (Exception e) {

            e.printStackTrace();

            return null;

        }

    }

 

    /**

     * 公钥加密

     */

    public static byte[] encryptByPublicKey(byte[] data, RSAPublicKey publicKey) throws Exception {

        Cipher cipher = Cipher.getInstance("RSA");

        cipher.init(Cipher.ENCRYPT_MODE, publicKey);

        int inputLen = data.length;

 

        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

            int offSet = 0;

            byte[] cache;

            int i = 0;

            // 对数据分段加密

            while (inputLen - offSet > 0) {

                if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {

                    cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);

                } else {

                    cache = cipher.doFinal(data, offSet, inputLen - offSet);

                }

                out.write(cache, 0, cache.length);

                i++;

                offSet = i * MAX_ENCRYPT_BLOCK;

            }

            return out.toByteArray();

        }

    }

 

    /**

     * 私钥解密

     */

    public static byte[] decryptByPrivateKey(byte[] encryptedData, RSAPrivateKey privateKey) throws Exception {

        Cipher cipher = Cipher.getInstance("RSA");

        cipher.init(Cipher.DECRYPT_MODE, privateKey);

        int inputLen = encryptedData.length;

 

        try (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(encryptedData, offSet, MAX_DECRYPT_BLOCK);

                } else {

                    cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);

                }

                out.write(cache, 0, cache.length);

                i++;

                offSet = i * MAX_DECRYPT_BLOCK;

            }

            return out.toByteArray();

        }

    }

 

    /**

     * ASCII码转BCD码

     */

    public static byte[] ASCII_To_BCD(byte[] ascii, int asc_len) {

        byte[] bcd = new byte[asc_len / 2];

        int j = 0;

        for (int i = 0; i < (asc_len + 1) / 2; i++) {

            bcd[i] = asc_to_bcd(ascii[j++]);

            bcd[i] = (byte) (((j >= asc_len) ? 0x00 : asc_to_bcd(ascii[j++])) + (bcd[i] << 4));

        }

        return bcd;

    }

 

    public static byte asc_to_bcd(byte asc) {

        byte bcd;

 

        if ((asc >= '0') && (asc <= '9'))

            bcd = (byte) (asc - '0');

        else if ((asc >= 'A') && (asc <= 'F'))

            bcd = (byte) (asc - 'A' + 10);

        else if ((asc >= 'a') && (asc <= 'f'))

            bcd = (byte) (asc - 'a' + 10);

        else

            bcd = (byte) (asc - 48);

        return bcd;

    }

 

    /**

     * BCD转字符串

     */

    public static String bcd2Str(byte[] bytes) {

        char temp[] = new char[bytes.length * 2], val;

 

        for (int i = 0; i < bytes.length; i++) {

            val = (char) (((bytes[i] & 0xf0) >> 4) & 0x0f);

            temp[i * 2] = (char) (val > 9 ? val + 'A' - 10 : val + '0');

 

            val = (char) (bytes[i] & 0x0f);

            temp[i * 2 + 1] = (char) (val > 9 ? val + 'A' - 10 : val + '0');

        }

        return new String(temp);

    }

 

    /**

     * 拆分字符串

     */

    public static String[] splitString(String string, int len) {

        int x = string.length() / len;

        int y = string.length() % len;

        int z = 0;

        if (y != 0) {

            z = 1;

        }

        String[] strings = new String[x + z];

        String str = "";

        for (int i = 0; i < x + z; i++) {

            if (i == x + z - 1 && y != 0) {

                str = string.substring(i * len, i * len + y);

            } else {

                str = string.substring(i * len, i * len + len);

            }

            strings[i] = str;

        }

        return strings;

    }

 

    /**

     * 拆分数组

     */

    public static byte[][] splitArray(byte[] data, int len) {

        int x = data.length / len;

        int y = data.length % len;

        int z = 0;

        if (y != 0) {

            z = 1;

        }

        byte[][] arrays = new byte[x + z][];

        byte[] arr;

        for (int i = 0; i < x + z; i++) {

            arr = new byte[len];

            if (i == x + z - 1 && y != 0) {

                System.arraycopy(data, i * len, arr, 0, y);

            } else {

                System.arraycopy(data, i * len, arr, 0, len);
            }
            arrays[i] = arr;
        }
        return arrays;
    }

    public static void main(String[] args) throws Exception {
        KeyPair keyPair = genRSAKeyPair();
        //生成公钥和私钥
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        //模hex
        String modulus = publicKey.getModulus().toString(16);
        //公钥指数hex
        String public_exponent = publicKey.getPublicExponent().toString(16);
        //私钥指数hex
        String private_exponent = privateKey.getPrivateExponent().toString(16);
        System.err.println("public_modulus: " + modulus);
        System.err.println("public_exponent: " + public_exponent);
        System.err.println("private_exponent: " + private_exponent);

        //明文
        String plaintStr = "test就撒3242旦立刻反击啊是！@#￥#%……￥#%43";
        System.err.println("plaintStr: " + plaintStr);

        //使用模和指数生成公钥和私钥
        RSAPublicKey pubKey = getPublicKey(modulus, public_exponent);
        RSAPrivateKey priKey = getPrivateKey(modulus, private_exponent);

        //公钥加密后的密文
        byte[] encryptStr = encryptByPublicKey(plaintStr.getBytes("utf-8"), pubKey);
        System.err.println("encryptStr: " + HexUtil.bytesToHexString(encryptStr));
        //私钥解密后的明文
        byte[] decryptStr = decryptByPrivateKey(encryptStr, priKey);
        System.err.println("decryptStr: " + new String(decryptStr, "utf-8"));
    }
}

 

拖石马
关注
专栏目录
公钥加密，私钥解密示例程序(JAVA)
whl_ys的博客
10-25 615
**1.证书生成** 前提：JDK已安装且正确配置环境变量 首先在C盘建立目录 MyKeyStore，用来存放证书库以及导出的证书文件，然后在命令行执行下列2句 下句含义：在当前目录创建 TestStore 密钥库，库密码 000000 ，创建证书 TestKey2 ：非对称密钥，RSA 算法，key密码为 000000 ，存于 TestStore C:/MyKeyStore > keytool -genkey -alias TestKe...
aes、ras,前端js加密，后端java解密
07-11
3. **后端**：Java服务器接收到数据后，使用`RSACoder.java`中的私钥解密RSA加密的数据，得到AES密钥。 4. **解密**：服务器再用`AesUtils.java`解密AES加密的数据，恢复原始信息。 在实际应用中，这样的加密方案...
js实现rsa加密算法
09-21
本rsa算法是使用Java与javascript加密解密范例代码,该资料从互联网收集，加上了自己的使用体会，如果对你有帮助那是万幸！ js加密部分
用javascript与java进行RSA加密与解密
sunxboy的专栏
06-29 531
这几天一直做安全登录，网上查了好多资料，不尽如意。 具体实现思路如下： 1。服务端生成公钥与私钥，保存。 2。客户端在请求到登录页面后，随机生成一字符串。 3。后此随机字符串作为密钥加密密码，再用从服务端获取到的公钥加密生成的随机字符串。 4。将此两段密文传入服务端，服务端用私钥解出随机字符串，再用此私钥解出加密的密文。 这其中有一个关键是解决服务端的公钥，传入客户端，客户端用此公钥加密字符串后，...
JavaScript实现RSA加密和解密
最新发布
weixin_48839391的博客
09-12 986
在JavaScript中，可以使用RSA算法实现数据的加密和解密。下载链接RSA 是一种非对称加密算法，使用一对密钥：公钥 和 私钥。公钥加密：任何人可以使用公钥加密信息。私钥解密：只有拥有私钥的人才能解密加密的信息。私钥签名：私钥可以用于对消息进行签名。公钥验证签名：任何人都可以用公钥验证签名的真实性。通过这个封装好的 rsa-crypto.js 文件，所有与RSA加密和解密相关的操作（密钥生成、密钥存储、加密、解密）都被整理为独立的功能模块。
js RSA加密 java RSA解密
weixin_32691913的博客
07-21 136
JS RSA加密与Java RSA解密：入门指南 作为一名开发者，你可能会在Web开发中遇到需要对数据进行加密和解密的情况。RSA加密算法是一种常用的非对称加密算法，它在很多安全通信场景中都有应用。本文将指导你如何使用JavaScript进行RSA加密，以及如何使用Java进行RSA解密。 流程概览 首先，我们通过一个表格...
前端RAS 加密（RAS for JavaScript）
xiaozhahza的博客
05-10 801
RAS for JavaScript
RAS加密
yuell102的博客
02-21 729
maven
RAS公钥加密私钥解密
04-19
本文将深入探讨RSA公钥加密私钥解密的工作原理及其在Java和JavaScript中的实现。 RSA算法基于数论中的大数因子分解难题，它提供了一对密钥：公钥和私钥。公钥是可以公开的，用于加密数据；私钥必须保密，用于解密...
RAS公钥加密私钥解密的例子(加密文件)
12-08
在"RAS公钥加密私钥解密的例子(加密文件)"这个场景中，我们将讨论如何使用RSA算法对文件进行加密和解密。首先，我们需要生成一对RSA密钥，这通常通过一个密钥生成工具完成。生成的密钥对包含一个公钥和一个私钥，...
Delphi RSA加解密【支持RSA公钥加密私钥解密，RSA私钥加密公钥解密，秘钥格式支持PKCS8和PKCS1】D7~XE10可用
02-26
无论是公钥加密私钥解密还是私钥加密公钥解密，都需要对RSA算法有深入理解，并能灵活运用OpenSSL库提供的API。这样的工具或代码对于Delphi开发者来说，是确保数据安全、实现安全通信的重要资源，适用于D7到XE10等多...
js版本实现rsa加密
01-17
js版rsa加密，用法参考资源里面的index.html，服务器返回rsa参数，页面加密得到加密数据，不支持包含中文的加密
RAS前端加密，JAVA后端解密。实现加密传送（补充了一个JS）
04-30
实现前端jsencrypt加密，后端用java进行解密，然后用md5进行登录，非对称加密算法实现。包含代码示例代码详解
RSA.js及依赖库
09-25
Web端RSA加密机密库包含RSA.js Barrett.js BigInt.js JavaScript文件，直接解压即可使用。ohdave.com官网资源，无偏移加密
java+js基于RSA解密解密
07-22
java接口数据加密解密，基于RSA原理，java与js对数据加密，解密的demo案例。 java+js基于RSA解密解密。
RSA加密解密之javascript与java配套源码.zip
10-26
这是我有自己的项目中使用的加密解密代码，下载后按说明放到自己的项目中就能使用，如有问题请留言给我，我会第一时间回复大家。
使用jsencrypt在web前端对字符串进行Ras加密
weixin_43578304的博客
07-13 304
使用jsencrypt在web前端对字符串进行Ras加密
javascript RSA公钥加密
热门推荐
k21325的博客
01-13 1万+
前面写了两篇:javascript SHA1加密,  javascript MD5加密 现在再来一篇RSA公钥加密 首先引入js文件，不要问为什么，just引 然后，js里面就可以这么加密了 var encrypt = new JSEncrypt(); encrypt.setPublicKey("这里放入你的公钥"); var encryptData = encrypt.en
ras算法的公钥，私钥，和明文的长度要求
04-25
RAS（RSA）算法是一种非对称加密算法，其公钥与私钥不同，用于加密和解密数据。明文长度要求根据使用的 RSA 算法密钥的长度而定。通常情况下，如果使用 2048 位或以上的 RSA 密钥，则可以加密多达 245 个字节的数据...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值