非对称加密 RSA算法

已于 2022-05-20 01:10:42 修改
阅读量861 收藏
点赞数
分类专栏： 密码学 文章标签： java
于 2022-03-24 23:20:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013837825/article/details/123724489
版权
本文详细介绍了RSA算法的概念和原理，并提供了使用Java JDK和BC库实现RSA加密、解密及数字签名的代码示例。通过示例代码展示了如何生成公钥和私钥，以及如何进行私钥加密公钥解密和公钥加密私钥解密的操作，同时也包含了签名的生成和验证过程。
摘要由CSDN通过智能技术生成

文章目录

概念

RSA是由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）在1977年一起提出的。当时他们三人都在麻省理工学院工作。RSA 就是他们三人姓氏开头字母拼在一起组成的。

RSA算法（可用于加密和数字签名）的安全性基于这样的事实：大整数的因式分解 被认为是‘难以破解’的。

原理

  1. 公钥与私钥的产生
    在这里插入图片描述

  2. 加密消息
    在这里插入图片描述

  3. 解密消息
    在这里插入图片描述

java jdk实现

package crypto.rsa;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.crypto.Cipher;
import java.security.*;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

/**
 * 非对称加密 RSA
 */
public class RsaUtils {

    private static final String ALGORITHM = "RSA";

    private static final String SIGNATURE_ALGORITHM = "MD5withRSA";

    public static InnerKey generateKey() throws NoSuchAlgorithmException {
        return generateKey(1024);
    }

    /**
     * 初始化密钥
     * <p>
     * 工作模式 ECB
     * 填充方式 NoPadding PKCS1Padding ...
     *
     * @param keysize 默认1024；范围在 [512~65536] ,且需要为 64 的倍数
     * @return
     * @throws NoSuchAlgorithmException
     */
    public static InnerKey generateKey(int keysize) throws NoSuchAlgorithmException {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);
        keyPairGenerator.initialize(keysize);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        //RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
        //RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
        return InnerKey.builder()
                .publicKey(keyPair.getPublic().getEncoded())
                .privateKey(keyPair.getPrivate().getEncoded())
                .build();
    }

    private static PublicKey getPublicKey(byte[] key) throws NoSuchAlgorithmException, InvalidKeySpecException {
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(key);
        PublicKey publicKey = KeyFactory.getInstance(ALGORITHM).generatePublic(x509EncodedKeySpec);
        return publicKey;
    }

    private static PrivateKey getPrivateKey(byte[] key) throws NoSuchAlgorithmException, InvalidKeySpecException {
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(key);
        PrivateKey privateKey = KeyFactory.getInstance(ALGORITHM).generatePrivate(pkcs8EncodedKeySpec);
        return privateKey;
    }

    /**
     * 私钥加密 公钥解密---加密
     *
     * @param privateKey
     * @param data
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] privateKey, byte[] data) throws Exception {
        return encrypt(true, privateKey, data);
    }

    /**
     * 私钥加密 公钥解密---解密
     *
     * @param publicKey
     * @param data
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] publicKey, byte[] data) throws Exception {
        return decrypt(false, publicKey, data);
    }

    /**
     * 公钥加密 私钥解密---加密
     *
     * @param publicKey
     * @param data
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(byte[] publicKey, byte[] data) throws Exception {
        return encrypt(false, publicKey, data);
    }

    /**
     * 公钥加密 私钥解密---解密
     *
     * @param privateKey
     * @param data
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] privateKey, byte[] data) throws Exception {
        return decrypt(true, privateKey, data);
    }

    private static byte[] encrypt(boolean isPrivate, byte[] key, byte[] data) throws Exception {
        Key thisKey = isPrivate ? getPrivateKey(key) : getPublicKey(key);
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, thisKey);
        return cipher.doFinal(data);
    }

    private static byte[] decrypt(boolean isPrivate, byte[] key, byte[] data) throws Exception {
        Key thisKey = isPrivate ? getPrivateKey(key) : getPublicKey(key);
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, thisKey);
        return cipher.doFinal(data);
    }

    /**
     * 用私钥对信息生成数字签名
     *
     * @param privateKey
     * @param data
     * @return
     * @throws Exception
     */
    public static byte[] sign(byte[] privateKey, byte[] data) throws Exception {
        //
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(getPrivateKey(privateKey));
        signature.update(data);
        return signature.sign();
    }

    /**
     * 验证签名
     *
     * @param publicKey
     * @param data
     * @param sign
     * @return
     * @throws Exception
     */
    public static boolean verifySign(byte[] publicKey, byte[] data, byte[] sign) throws Exception {
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(getPublicKey(publicKey));
        signature.update(data);
        return signature.verify(sign);
    }

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @Builder
    public static class InnerKey {
        private byte[] publicKey;
        private byte[] privateKey;
    }

}

测试代码

package crypto.rsa;

import org.apache.commons.codec.binary.Base64;

public class RsaUtilsTest {

    public static void main(String[] args) throws Exception {
        RsaUtils.InnerKey innerKey = RsaUtils.generateKey();
        System.out.println("公钥：" + Base64.encodeBase64String(innerKey.getPublicKey()));
        System.out.println("私钥：" + Base64.encodeBase64String(innerKey.getPrivateKey()));

        byte[] data = "你好，世界".getBytes();
        testEncrypt1(innerKey.getPublicKey(), innerKey.getPrivateKey(), data);
        testEncrypt2(innerKey.getPublicKey(), innerKey.getPrivateKey(), data);
        testSign(innerKey.getPublicKey(), innerKey.getPrivateKey(), data);
    }

    private static void testEncrypt1(byte[] publicKey, byte[] privateKey, byte[] data) throws Exception {
        // 私钥加密 公钥解密---加密
        byte[] encryptBytes = RsaUtils.encryptByPrivateKey(privateKey, data);
        System.out.println("私钥加密公钥解密-密文：" + Base64.encodeBase64String(encryptBytes));
        // 私钥加密 公钥解密---解密
        byte[] result = RsaUtils.decryptByPublicKey(publicKey, encryptBytes);
        System.out.println("解密后：" + new String(result));
    }

    private static void testEncrypt2(byte[] publicKey, byte[] privateKey, byte[] data) throws Exception {
        // 公钥加密 私钥解密---加密
        byte[] encryptBytes = RsaUtils.encryptByPublicKey(publicKey, data);
        System.out.println("公钥加密私钥解密-密文：" + Base64.encodeBase64String(encryptBytes));
        // 公钥加密 私钥解密---解密
        byte[] result = RsaUtils.decryptByPrivateKey(privateKey, encryptBytes);
        System.out.println("解密后：" + new String(result));
    }

    private static void testSign(byte[] publicKey, byte[] privateKey, byte[] data) throws Exception {
        byte[] sign = RsaUtils.sign(privateKey, data);
        System.out.println("签名：" + Base64.encodeBase64String(sign));
        boolean result = RsaUtils.verifySign(publicKey, data, sign);
        System.out.println("验签结果：" + result);
    }
}

java bc实现

java jdk实现2 - modulus publicExponent

package crypto.rsa;

import org.apache.commons.codec.binary.Base64;

import javax.crypto.Cipher;
import java.math.BigInteger;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.RSAPublicKeySpec;

public class RsaTest {
    public static final String ALGORITHM = "RSA";

    public static void main(String[] args) throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);
        keyPairGenerator.initialize(512);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();

        byte[] data = encrypt(rsaPublicKey.getModulus(), rsaPublicKey.getPublicExponent(), "Hello 世界".getBytes());
        System.out.println(Base64.encodeBase64String(data));
        data = decrypt(rsaPrivateKey.getModulus(), rsaPrivateKey.getPrivateExponent(), data);
        System.out.println(new String(data));
    }

    public static byte[] encrypt(BigInteger modulus, BigInteger publicExponent, byte[] data) throws Exception {
        PublicKey publicKey = generateRSAPublicKey(modulus.toByteArray(), publicExponent.toByteArray());
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        return cipher.doFinal(data);
    }

    public static byte[] decrypt(BigInteger modulus, BigInteger privateExponent, byte[] data) throws Exception {
        PrivateKey privateKey = generateRSAPrivateKey(modulus.toByteArray(), privateExponent.toByteArray());
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        return cipher.doFinal(data);
    }

    /**
     * 根据给定的系数和专用指数构造一个RSA专用的公钥对象。
     *
     * @param modulus        系数。
     * @param publicExponent 专用指数。
     * @return RSA专用公钥对象。
     */
    public static RSAPublicKey generateRSAPublicKey(byte[] modulus, byte[] publicExponent) throws Exception {
        RSAPublicKeySpec publicKeySpec = new RSAPublicKeySpec(new BigInteger(modulus), new BigInteger(publicExponent));
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        return (RSAPublicKey) keyFactory.generatePublic(publicKeySpec);
    }

    /**
     * 根据给定的系数和专用指数构造一个RSA专用的私钥对象。
     *
     * @param modulus         系数。
     * @param privateExponent 专用指数。
     * @return RSA专用私钥对象。
     */
    public static RSAPrivateKey generateRSAPrivateKey(byte[] modulus, byte[] privateExponent) throws Exception {
        RSAPrivateKeySpec privateKeySpec = new RSAPrivateKeySpec(new BigInteger(modulus), new BigInteger(privateExponent));
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        return (RSAPrivateKey) keyFactory.generatePrivate(privateKeySpec);
    }
}

code

morningcat2018
关注
专栏目录
PHP封装的非对称加密RSA算法示例
10-18
总结来说，PHP封装的非对称加密RSA算法示例涉及到了openssl扩展的安装和配置、Rsa类的封装和使用技巧等多个方面的知识点。掌握这些知识，对于提升网络安全防护能力，确保数据传输的安全，具有非常重要的意义。
我的java web登录RSA加密
热门推荐
yys79的专栏
11-26 2万+
之前一直没关注过web应用登录密码加密的问题，这两天用appscan扫描应用，最严重的问题就是这个了，提示我明文发送密码。这个的确很不安全，以前也大概想过，但是没有具体研究过，都不了了之，这次借这个机会，终于搞定了这个问题。 首先，有不少帖子说在客户端用js对密码进行md5摘要，然后提交给登录处理的url。这种做法无非是自欺欺人，就算别人抓包抓不到你原始密码，用这个md5后的密码一样可以模拟登录...
Java 工具类 RSA加解密
weixin_45414738的博客
06-24 412
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..
Java：实现RSA加密与验证的方法详解
最新发布
u013938578的博客
07-25 2437
RSA加密是一种非对称加密。可以在不直接传递密钥的情况下，完成解密。这能够确保信息的安全性，避免了直接传递密钥所造成的被破解的风险。是由一对密钥来进行加解密的过程，分别称为公钥和私钥。两者之间有数学相关，该加密算法的原理就是对一极大整数做因数分解的困难性来保证安全性。通常个人保存私钥，公钥是公开的（可能同时多人持有）。非对称加密： RSA是一种非对称加密算法，意味着它使用不同的密钥进行加密和解密。公钥用于加密数据，只有拥有相应私钥的用户才能解密它。
java Rsa加密解密 RsaUtils.java 工具类的使用
test
01-06 4363
java Rsa加密解密 RsaUtils.java 工具类的使用
java公钥加密私钥解密_公钥加密,私钥解密示例程序(JAVA)详解
weixin_30999777的博客
02-12 2467
公钥与私钥机制属于非对称加密的范畴，非对称是相对于对称加密而言的，对称加密用于加密与解密的密钥是同一把，而非对称加密则用于加密与解密的密钥不相同，一个公开，称为公钥；一个保密，称为私钥，公钥与私钥必须成对出现，只有是配对的公钥与私钥才能用于加解密。公钥通过非安全通道发放，私钥则由发放者保留，公钥加密的数据，只能使用其配对的私钥对其解密；反之，私钥加密的数据，只可使用公钥对其解密。对称加密出现后有效...
Java 实现 RSA 非对称加密算法-加解密和签名验签
迪曼奥特迦-博客
06-12 1317
1.非对称加密算法简介 非对称加密算法又称现代加密算法，是计算机通信安全的基石，保证了加密数据不会被破解。与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥（publickey）和私有密（privatekey），因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。公钥和私钥是一对，如果用公钥对数据进行加密，只有用对应的私钥才能解密。常见算法：RSA、ECC。 RSA 加密算法是一种非对称加密算法，即 RSA 拥有一对密钥（公钥 和 私钥），公钥可公开。公钥加密的数据，只能由私钥.
RSA非对称加密，前台vue加密，后台java解密
水蜜桃桃桃的博客
12-06 2422
目录 前言 公钥和私钥的获取 公钥私钥例子 公钥 私钥 一、前端vue加密 1.1安装jsencrypt 1.2安装好后，在文件里引用 1.3 使用私钥加密 2.后端java解密 2.1调用代码 2.2 RSAUtils工具类 2.3RSAUtils运行结果 参考文档 前言 RSA加密非对称加密，简单理解为就是有一个私钥一个公钥，我们在前台用私钥进行加密，到后台以后再使用对应的公钥进行解密。(这一对公钥和私钥可以由后台实时生成,每次生成的公钥和私钥都不...
RSA非对称加密算法
02-14
RSA 非对称加密算法 RSA 非对称加密算法是一种经典的非对称加密算法，由罗纳德·李维斯特、阿迪·萨莫尔和伦纳德·阿德曼三人于 1977 年共同提出的。该算法的主要思想是基于大素数的乘积和因式分解之间的关系，通过...
C语言实现非对称密码算法RSA
10-26
C语言实现非对称密码算法RSA，其中RSA计算采用的是平方乘算法
C#实现简单的RSA非对称加密算法示例
08-29
RSA非对称加密算法是公钥密码体制中的一种，使用了一对密钥，一个是公开的公钥，另一个是私有的私钥。公钥用于加密，私钥用于解密。RSA算法的安全性基于大数因子分解的难度和离散对数问题的难度。 在C#中实现RSA...
RSA生成公私钥文件&私钥加签/公钥验签&公钥加密/私钥解密
TonnisN的博客
07-24 1679
 1.编写RSAUtil.java工具类 package util; import sun.misc.BASE64Decoder; import sun.misc.BASE64Encoder; import javax.crypto.Cipher; import java.io.*; import java.security.*; import java.security.interfac...
java 对证书文件以及秘钥.key的解析
a995222199的博客
03-30 2440
2.第二种方式为java去除了开头的“-----BEGIN CERTIFICATE-----”以及中间的“/n”末尾的“-----END CERTIFICATE-----”1.为证书的标准格式，java通过jdk进行对标准证书进行base64解密转换、解析，由于网上对于该方式的描述较多，本文不做过多描述。java支持pksc8格式的私钥文件读取，把拿到的pksc1格式私钥转换为pksc8格式。备注：第一种方式可通过代码处理去除证书文件的分隔符以及开头结尾标识转为第二种情况。读取私钥获得转为私钥对象。
如何实现接口加密？
yanghang520520的博客
12-31 7045
如何实现接口加密？ 为什么要使用接口加密？ 系统明文传输的数据会被不明身份的人用抓包工具抓取，从而威胁系统和数据的安全性 我这里采用非对称加密算法： 非对称加密算法是一种密钥的保密方法，加密和解密使用两个不同的密钥，公开密钥（publickey:简称公钥）和私有密钥（privatekey:简称私钥）。公钥与私钥是一对，如果用公钥对数据进行加密，只有用对应的私钥才能解密。 非对称加密算法的特点： 算法强度复杂 加密解密速度没有对称密钥算法的速度快 经典应用场景：数字签名（私钥加密，公钥验证） 常用的算法：
RSA
f543711700的专栏
10-21 195
[code="java"]package com.ghca.roam.sync; import java.io.ByteArrayOutputStream; import java.security.Key; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyP...
RSA非对称加密
点滴记录，积流成河！
03-09 507
RSA算法
RSA前后台公钥私钥加密解密以及公钥私钥存储
mintent的博客
08-14 2931
不多说了，直接看代码吧 首先需要俩个工具类 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实现js前台加密java后台解密
zhangxiong0797的专栏
11-04 2581
rsa前段加密 准备工作：其实鄙人也没那么强啦，第三方包是必须的                             bcprov-jdk15on-148.jar                             commons-codec-1.7.jar                             commons-lang-2.4.jar       
RSA非对称加密过程
Leon_Jinhai_Sun的博客
11-17 275
package com.learn.rsa; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.NoSuchAlgorithmException; import java.security.Priva...
public static String decryptByPrivateKey(String encryptedDataStr, PrivateKey priKey) throws Exception { //获取密钥长度，生成解密长度 KeyFactory keyF = KeyFactory.getInstance(priKey.getAlgorithm()); RSAPrivateKeySpec keySpec = keyF.getKeySpec(priKey, RSAPrivateKeySpec.class); BigInteger prime = keySpec.getModulus(); int maxDecryptBlock = prime.toString(2).length()/8; //私钥解密 Cipher cipher = Cipher.getInstance(RSA); cipher.init(Cipher.DECRYPT_MODE, priKey); byte[] encryptedData = Base64.getDecoder().decode(encryptedDataStr); int inputLen = encryptedData.length; ByteArrayOutputStream out = new ByteArrayOutputStream(); int offSet = 0; byte[] cache; int i = 0; // 对数据分段解密 while (inputLen - offSet > 0) { if (inputLen - offSet > maxDecryptBlock) { cache = cipher.doFinal(encryptedData, offSet, maxDecryptBlock); } else { cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet); } out.write(cache, 0, cache.length); i++; offSet = i * maxDecryptBlock; } byte[] decryptedData = out.toByteArray(); out.close(); return new String(decryptedData , StandardCharsets.UTF_8); }
06-08
这段代码是使用私钥对加密后的数据进行解密。它首先获取私钥的长度，然后根据长度生成解密长度。接着使用私钥初始化 Cipher 对象，然后对使用 Base64 编码后的加密数据进行解码。接下来对数据进行分段解密，每次解密的数据块大小不能超过最大解密长度。最后将解密后的数据转换成字符串返回。这段代码使用的是 RSA 算法进行加解密。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值