RSA非对称加密

最新推荐文章于 2024-03-19 18:38:26 发布
最新推荐文章于 2024-03-19 18:38:26 发布
阅读量189 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WXS_0218/article/details/121282803
版权

引入 pom.xml 依赖：

<dependency>
	<groupId>commons-codec</groupId>
	<artifactId>commons-codec</artifactId>
	<version>1.14</version>
</dependency>

工具类：

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.security.spec.X509EncodedKeySpec;
import java.util.Arrays;

/**
 * RSA加解密工具类 <br />
 *
 * <ol>
 *     <li>公钥加密，私钥解密</li>
 *     <li>私钥解密，公钥解密</li>
 * </ol>
 *
 */
public class RSAUtil
{
    /**
     * 最大加密字节数 <br/>
     * 超出最大字节数需要分组加密
     */
    private static final int MAX_ENCRYPT_BLOCK = 117;

    /**
     * 最大解密字节数 <br/>
     * 超出最大字节数需要分组加密
     */
    private static final int MAX_DECRYPT_BLOCK = 128;

    /**
     * 公钥加密
     *
     * @param publicKeyText （经过 Base64 编码）公钥
     * @param text （原始）明文
     * @return （经过 Base64 编码）密文
     * @throws Exception
     */
    public static String encryptByPublicKey(String publicKeyText, String text) throws Exception
    {
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKeyText));
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);

        // byte[] result = cipher.doFinal(text.getBytes());
        byte[] result = doBlockEncrypt(text.getBytes(), cipher);

        return Base64.encodeBase64String(result);
    }

    /**
     * 私钥加密
     *
     * @param privateKeyText （经过 Base64 编码）私钥
     * @param text （原始）明文
     * @return （经过 Base64 编码）密文
     * @throws Exception
     */
    public static String encryptByPrivateKey(String privateKeyText, String text) throws Exception
    {
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKeyText));
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);

        // byte[] result = cipher.doFinal(text.getBytes());
        byte[] result = doBlockEncrypt(text.getBytes(), cipher);

        return Base64.encodeBase64String(result);
    }


    /**
     * 分段加密
     * @param textBytes （原始）明文字节数组
     * @param cipher 加密器
     * @return
     * @throws Exception
     */
    private static byte[] doBlockEncrypt(byte[] textBytes, Cipher cipher) throws Exception
    {
        int length = textBytes.length;
        int offSet = 0;

        byte[] resultBytes = {};
        byte[] cache;

        while (length - offSet > 0)
        {
            if (length - offSet > MAX_ENCRYPT_BLOCK)
            {
                cache = cipher.doFinal(textBytes, offSet, MAX_ENCRYPT_BLOCK);
                offSet += MAX_ENCRYPT_BLOCK;
            }
            else
            {
                cache = cipher.doFinal(textBytes, offSet, length - offSet);
                offSet = length;
            }
            resultBytes = Arrays.copyOf(resultBytes, resultBytes.length + cache.length);
            System.arraycopy(cache, 0, resultBytes, resultBytes.length - cache.length, cache.length);
        }

        return resultBytes;
    }

    /**
     * 公钥解密
     *
     * @param publicKeyText  （经过 Base64 编码）公钥
     * @param text （经过 Base64 编码）密文
     * @return （解密）明文
     * @throws Exception
     */
    public static String decryptByPublicKey(String publicKeyText, String text) throws Exception
    {
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKeyText));
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, publicKey);

        // byte[] result = cipher.doFinal(Base64.decodeBase64(text));
        byte[] result = doBlockDecrypt(Base64.decodeBase64(text), cipher);

        return new String(result);
    }

    /**
     * 私钥解密
     *
     * @param privateKeyText （经过 Base64 编码）私钥
     * @param text （经过 Base64 编码）密文
     * @return （解密）明文
     * @throws Exception
     */
    public static String decryptByPrivateKey(String privateKeyText, String text) throws Exception
    {
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec5 = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKeyText));
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec5);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);

        // byte[] result = cipher.doFinal(Base64.decodeBase64(text));
        byte[] result = doBlockDecrypt(Base64.decodeBase64(text), cipher);

        return new String(result);
    }


    /**
     * 分段解密
     * @param textBytes （经过 Base64 解码）密文字节数组
     * @param cipher 解密器
     * @return
     * @throws Exception
     */
    private static byte[] doBlockDecrypt(byte[] textBytes, Cipher cipher) throws Exception
    {
        int length = textBytes.length;
        int offSet = 0;

        byte[] resultBytes = {};
        byte[] cache;

        while (length - offSet > 0)
        {
            if (length - offSet > MAX_DECRYPT_BLOCK)
            {
                cache = cipher.doFinal(textBytes, offSet, MAX_DECRYPT_BLOCK);
                offSet += MAX_DECRYPT_BLOCK;
            }
            else
            {
                cache = cipher.doFinal(textBytes, offSet, length - offSet);
                offSet = length;
            }
            resultBytes = Arrays.copyOf(resultBytes, resultBytes.length + cache.length);
            System.arraycopy(cache, 0, resultBytes, resultBytes.length - cache.length, cache.length);
        }

        return resultBytes;
    }

    /**
     * 构建RSA密钥对
     *
     * @return Base64 编码后的 RAS 秘钥
     * @throws NoSuchAlgorithmException
     */
    public static RSAKeyPair generateKeyPair() throws NoSuchAlgorithmException
    {
        // 生成秘钥对（公钥、私钥）
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(1024);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();

        // 对秘钥进行 Base64 编码
        String publicKeyString = Base64.encodeBase64String(rsaPublicKey.getEncoded());
        String privateKeyString = Base64.encodeBase64String(rsaPrivateKey.getEncoded());
        RSAKeyPair rsaKeyPair = new RSAKeyPair(publicKeyString, privateKeyString);

        return rsaKeyPair;
    }


    /**
     * RSA密钥对对象
     */
    public static class RSAKeyPair
    {
        private String publicKey;
        private String privateKey;

        public RSAKeyPair(String publicKey, String privateKey)
        {
            this.publicKey = publicKey;
            this.privateKey = privateKey;
        }

        public String getPublicKey() {
            return publicKey;
        }

        public String getPrivateKey() {
            return privateKey;
        }

    }

    /**
     * 生成 licence
     * @param privateKey
     * @param text
     * @return
     * @throws Exception
     */
    public static String generateLicence(String privateKey, String text) throws Exception
    {
        return RSAUtil.encryptByPrivateKey(privateKey, text);
    }

    /**
     * 解析 licence
     * @param publicKey
     * @param text
     * @return
     * @throws Exception
     */
    public static String resolveLicence(String publicKey, String text)
    {
        try
        {
            return RSAUtil.decryptByPublicKey(publicKey, text);
        }
        catch (Exception e)
        {
            throw new ParseLicenceException();
        }
    }

}

测试用例：

@Test
void test() throws Exception
{
	String text = "i am a good man!";

	RSAUtil.RSAKeyPair keyPair = RSAUtil.generateKeyPair();

	System.out.println("\n");
	System.out.println("公钥：" + keyPair.getPublicKey());
	System.out.println("私钥：" + keyPair.getPrivateKey());

	System.out.println("\n");
	test1(keyPair, text);

	System.out.println("\n");
	test2(keyPair, text);
}

/**
 * 公钥加密，私钥解密
 */
private static void test1(RSAUtil.RSAKeyPair keyPair, String source) throws Exception
{
	System.out.println("***************** 公钥加密，私钥解密 开始 *****************");
	String cipherText = RSAUtil.encryptByPublicKey(keyPair.getPublicKey(), source);
	String decipherText = RSAUtil.decryptByPrivateKey(keyPair.getPrivateKey(), cipherText);
	System.out.println("加密前：" + source);
	System.out.println("加密后：" + cipherText);
	System.out.println("解密后：" + decipherText);
	if (source.equals(decipherText)) {
		System.out.println("解密字符串和原始字符串一致，解密成功");
	} else {
		System.out.println("解密字符串和原始字符串不一致，解密失败");
	}
	System.out.println("***************** 公钥加密，私钥解密 结束 *****************");
}

/**
 * 私钥加密，公钥解密
 *
 * @throws Exception
 */
private static void test2(RSAUtil.RSAKeyPair keyPair, String source) throws Exception
{
	System.out.println("***************** 私钥加密，公钥解密 开始 *****************");
	String cipherText = RSAUtil.encryptByPrivateKey(keyPair.getPrivateKey(), source);
	String decipherText = RSAUtil.decryptByPublicKey(keyPair.getPublicKey(), cipherText);
	System.out.println("加密前：" + source);
	System.out.println("加密后：" + cipherText);
	System.out.println("解密后：" + decipherText);
	if (source.equals(decipherText)) {
		System.out.println("解密字符串和原始字符串一致，解密成功");
	} else {
		System.out.println("解密字符串和原始字符串不一致，解密失败");
	}
	System.out.println("***************** 私钥加密，公钥解密 结束 *****************");
}

wxs_0218
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java RSAUtils.java 文件
09-25
使用 RSA 前端加密，后端解密的解决方法，其中RSAUtils.java为后端解密依赖！
JS逆向学习---简单的rsa
m0_46639364的博客
05-13 1823
今日目标：aHR0cHM6Ly9jbi5mYXdteC5jb20vaG9tZS9yZWdpc3Rlcg== 登录接口有一个加密参数，也就是密码加密值，就是今天的小目标 直接搜索，只有一个js文件有结果，第一个便是加密位置 很明显，是把明文密码传入做了rsa加密得到enPassword，再把enPassword赋值给了loginpwd。 在setPublic开始打断点进行调试。 加密的公钥是固定不变的，写死就可以。但为了篇幅能更长，看起来更牛逼，还是把生成过程push一下。 打上断点再次发送请求，毫无
Java 工具类 RSA加解密
weixin_45414738的博客
06-24 395
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..
RSAUtils工具类
小布1994的博客
04-29 2866
package com.xiaobu.base.util; import javax.crypto.Cipher; import java.io.ByteArrayOutputStream; import java.nio.charset.StandardCharsets; import java.security.*; import java.security.interfaces.RSAPr...
java公钥加密私钥解密_公钥加密,私钥解密示例程序(JAVA)详解
weixin_30999777的博客
02-12 2345
公钥与私钥机制属于非对称加密的范畴，非对称是相对于对称加密而言的，对称加密用于加密与解密的密钥是同一把，而非对称加密则用于加密与解密的密钥不相同，一个公开，称为公钥；一个保密，称为私钥，公钥与私钥必须成对出现，只有是配对的公钥与私钥才能用于加解密。公钥通过非安全通道发放，私钥则由发放者保留，公钥加密的数据，只能使用其配对的私钥对其解密；反之，私钥加密的数据，只可使用公钥对其解密。对称加密出现后有效...
RSA 非对称加密 RSAUtils
lockie的博客
06-03 1269
RSA 非对称加密
RSA非对称加密算法
02-14
主要介绍RSA非对称加密算法的由来和应用场景，以及加密原理
ThinkPHP实现的rsa非对称加密类示例
10-18
主要介绍了ThinkPHP实现的rsa非对称加密类,结合实例形式分析了thinkPHP引入密钥文件实现rsa加密解密的相关操作技巧,需要的朋友可以参考下
C#实现简单的RSA非对称加密算法示例
12-31
本文实例讲述了C#实现简单的RSA非对称加密算法。分享给大家供大家参考，具体如下： 界面控件 namespace RSA算法 { partial class Form1 { /// /// 必需的设计器变量。 /// private System.ComponentModel....
java Rsa加密解密 RsaUtils.java 工具类的使用
test
01-06 3867
java Rsa加密解密 RsaUtils.java 工具类的使用
非对称加密 RSA算法
晨猫
03-24 812
RSA是由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）在1977年一起提出的。当时他们三人都在麻省理工学院工作。RSA 就是他们三人姓氏开头字母拼在一起组成的。 RSA算法（可用于加密和数字签名）的安全性基于这样的事实：大整数的因式分解 被认为是‘难以破解’的。
jsencrypt加密，并解决Message too long for RSA
一切都不太晚
10-20 6301
在这里我们有两种选择方案，jsencrypt和 encryptlong使用后者的原因是因为jsencrypt的加密长度有限制，不过encryptlong本身也是有bug，有事又会问题，加密后解析不出来，可能是我的个人原因这次我主要就说明jsencrypt如果能加密比较长的数据。
Java 实现 RSA 非对称加密算法-加解密和签名验签
迪曼奥特迦-博客
06-12 1133
1.非对称加密算法简介 非对称加密算法又称现代加密算法，是计算机通信安全的基石，保证了加密数据不会被破解。与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥（publickey）和私有密（privatekey），因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。公钥和私钥是一对，如果用公钥对数据进行加密，只有用对应的私钥才能解密。常见算法：RSA、ECC。 RSA 加密算法是一种非对称加密算法，即 RSA 拥有一对密钥（公钥 和 私钥），公钥可公开。公钥加密的数据，只能由私钥.
RSA前后台公钥私钥加密解密以及公钥私钥存储
mintent的博客
08-14 2865
不多说了，直接看代码吧 首先需要俩个工具类 package com.example.aasd; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.OutputStream; /** * Created by pw on 2019/8/14 11:04 * E-Mail Add...
RSA非对称加密，前台vue加密，后台java解密
水蜜桃桃桃的博客
12-06 2122
目录 前言 公钥和私钥的获取 公钥私钥例子 公钥 私钥 一、前端vue加密 1.1安装jsencrypt 1.2安装好后，在文件里引用 1.3 使用私钥加密 2.后端java解密 2.1调用代码 2.2 RSAUtils工具类 2.3RSAUtils运行结果 参考文档 前言 RSA加密非对称加密，简单理解为就是有一个私钥一个公钥，我们在前台用私钥进行加密，到后台以后再使用对应的公钥进行解密。(这一对公钥和私钥可以由后台实时生成,每次生成的公钥和私钥都不...
rsautils java,RSAUtils.java
weixin_35761245的博客
03-27 445
package com.study.util.rsa;import java.math.BigInteger;import java.security.KeyFactory;import java.security.KeyPair;import java.security.KeyPairGenerator;import java.security.NoSuchAlgorithmException;...
RSA加密解密签名加签验签RsaUtils工具类
最新发布
gongjin28_csdn的博客
03-19 1112
RSA基于数学上的大整数因子分解难题，只要密钥足够大（通常建议至少2048位），在现有的计算机技术和算法条件下，破解RSA加密的数据所需的时间极其漫长，从而确保了高度的安全性。RSA算法基于大数因子分解难题，提供了公钥加密和私钥解密的能力。：除了加密外，RSA还可用于数字签名，通过私钥对数据进行签名，然后接收方可以用公钥验证签名的真实性，确保数据完整性并确认发送者的身份。：虽然实际运算复杂，但RSA算法本身是公开的，这增强了人们对算法安全性的信任，因为任何潜在的漏洞都可以经过全球专家的审查和改进。
rsa非对称加密解密python
09-12
RSA是一种非对称加密技术，可以用于数据的加密和解密。在Python中，可以使用rsa模块来实现RSA非对称加密和解密操作。通过引用中的文章，我们可以了解到如何在Python中使用rsa模块进行非对称加密和解密。 首先，需要...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值