RSA加密算法的常用工具类

最新推荐文章于 2024-05-14 03:33:01 发布
最新推荐文章于 2024-05-14 03:33:01 发布
阅读量1.2k 收藏 2
点赞数 1
分类专栏： java 文章标签： java RSA
原文链接：https://blog.csdn.net/cwr452829537/article/details/125445982
版权

这里提供一个RSA加密算法的工具类，其中包含生成密钥、加密、解密、加签、验签等RSA常用的方法，可以直接使用

package priv.cwr.utils;
 
import org.springframework.stereotype.Component;
 
import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
 
/**
 * @Description RSA非对称加密算法工具类
 * @Author CWR
 * @Date 2022/3/21 20:26
 */
public class RsaSecretUtils {
 
    private static final String RSA = "RSA";
 
    /**
     * 签名算法
     */
    private static final String SIGN_ALGORITHMS = "SHA1WithRSA";
 
    /**
     * 生成秘钥对
     *
     * @return
     * @throws Exception
     */
    public KeyPair getKeyPair() throws NoSuchAlgorithmException {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(RSA);
        keyPairGenerator.initialize(2048);
        return keyPairGenerator.generateKeyPair();
    }
 
    /**
     * 获取公钥(Base64编码)
     *
     * @param keyPair 秘钥对
     * @return
     */
    public String getPublicKeyBase64(KeyPair keyPair) {
        PublicKey publicKey = keyPair.getPublic();
        byte[] bytes = publicKey.getEncoded();
        return new String(bytes, StandardCharsets.UTF_8);
    }
 
    /**
     * 获取私钥(Base64编码)
     *
     * @param keyPair 秘钥对
     * @return
     */
    public String getPrivateKeyBase64(KeyPair keyPair) {
        PrivateKey privateKey = keyPair.getPrivate();
        byte[] bytes = privateKey.getEncoded();
        return new String(bytes, StandardCharsets.UTF_8);
    }
 
    /**
     * 将Base64编码后的公钥转换成PublicKey对象
     *
     * @param publicKeyBase64 公钥base64
     * @return
     */
    public static PublicKey getPublicKey(String publicKeyBase64) throws NoSuchAlgorithmException, InvalidKeySpecException {
        byte[] keyBytes = Base64Utils.decode(publicKeyBase64);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(RSA);
        return keyFactory.generatePublic(keySpec);
    }
 
    /**
     * 将Base64编码后的私钥转换成PrivateKey对象
     *
     * @param privateKeyBase64 私钥base64
     * @return
     * @throws Exception
     */
    public static PrivateKey getPrivateKey(String privateKeyBase64) throws NoSuchAlgorithmException, InvalidKeySpecException {
        byte[] keyBytes = Base64Utils.decode((privateKeyBase64));
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(RSA);
        return keyFactory.generatePrivate(keySpec);
    }
 
    /**
     * 公钥加密
     *
     * @param plaintext       明文
     * @param publicKeyBase64 公钥base64
     * @return 密文数组base64编码后的字符串
     */
    public static String publicKeyEncrypt(String plaintext, String publicKeyBase64) {
        try {
            // 获取明文字节数组
            byte[] bytes = plaintext.getBytes(StandardCharsets.UTF_8);
            Cipher cipher = Cipher.getInstance(RSA);
            // 编码前设定编码方式及密钥
            PublicKey publicKey = getPublicKey(publicKeyBase64);
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            int keyBit = getKeySize(publicKey);
            int inputLen = bytes.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            int step = keyBit / 8 - 11;
 
            for (int i = 0; inputLen - offSet > 0; offSet = i * step) {
                byte[] cache;
                if (inputLen - offSet > step) {
                    cache = cipher.doFinal(bytes, offSet, step);
                } else {
                    cache = cipher.doFinal(bytes, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                ++i;
            }
            // 密文字节数组
            byte[] ciphertextBytes = out.toByteArray();
            out.close();
            // 返回密文字节数组base64编码后的字符串
            return Base64Utils.encodeToString(ciphertextBytes);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
 
    /**
     * 公钥解密
     *
     * @param ciphertext      密文
     * @param publicKeyBase64 公钥base64
     * @return 明文
     */
    public static String publicKeyDecrypt(String ciphertext, String publicKeyBase64) {
        try {
            // 密文base64解码字节数组
            byte[] bytes = Base64Utils.decode(ciphertext);
            Cipher cipher = Cipher.getInstance(RSA);
            PublicKey publicKey = getPublicKey(publicKeyBase64);
            cipher.init(Cipher.DECRYPT_MODE, publicKey);
            int keyBit = getKeySize(publicKey);
            int inputLen = bytes.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            int step = keyBit / 8;
 
            for (int i = 0; inputLen - offSet > 0; offSet = i * step) {
                byte[] cache;
                if (inputLen - offSet > step) {
                    cache = cipher.doFinal(bytes, offSet, step);
                } else {
                    cache = cipher.doFinal(bytes, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                ++i;
            }
            // 明文字节数组
            byte[] plaintextBytes = out.toByteArray();
            out.close();
            return new String(plaintextBytes, StandardCharsets.UTF_8);
        } catch (Exception e) {
            return null;
        }
    }
 
    /**
     * 私钥加密
     *
     * @param plaintext        明文
     * @param privateKeyBase64 私钥base64
     * @return
     */
    public static String privateKeyEncrypt(String plaintext, String privateKeyBase64) {
        try {
            // 获取明文字节数组
            byte[] bytes = plaintext.getBytes(StandardCharsets.UTF_8);
            Cipher cipher = Cipher.getInstance(RSA);
            // 编码前设定编码方式及密钥
            PrivateKey privateKey = getPrivateKey(privateKeyBase64);
            cipher.init(Cipher.ENCRYPT_MODE, privateKey);
            int keyBit = getKeySize(privateKey);
            int inputLen = bytes.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            int step = keyBit / 8 - 11;
 
            for (int i = 0; inputLen - offSet > 0; offSet = i * step) {
                byte[] cache;
                if (inputLen - offSet > step) {
                    cache = cipher.doFinal(bytes, offSet, step);
                } else {
                    cache = cipher.doFinal(bytes, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                ++i;
            }
            // 密文字节数组
            byte[] ciphertextBytes = out.toByteArray();
            out.close();
            // 返回密文字节数组base64编码后的字符串
            return Base64Utils.encodeToString(ciphertextBytes);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
 
    /**
     * 私钥解密
     *
     * @param ciphertext       密文
     * @param privateKeyBase64 私钥base64
     * @return 明文
     */
    public static String privateKeyDecrypt(String ciphertext, String privateKeyBase64) {
        try {
            // 密文base64解码字节数组
            byte[] bytes = Base64Utils.decode(ciphertext);
            Cipher cipher = Cipher.getInstance(RSA);
            PrivateKey privateKey = getPrivateKey(privateKeyBase64);
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            int keyBit = getKeySize(privateKey);
            int inputLen = bytes.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            int step = keyBit / 8;
 
            for (int i = 0; inputLen - offSet > 0; offSet = i * step) {
                byte[] cache;
                if (inputLen - offSet > step) {
                    cache = cipher.doFinal(bytes, offSet, step);
                } else {
                    cache = cipher.doFinal(bytes, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                ++i;
            }
            // 明文字节数组
            byte[] plaintextBytes = out.toByteArray();
            out.close();
            return new String(plaintextBytes, StandardCharsets.UTF_8);
        } catch (Exception e) {
            return null;
        }
    }
 
    /**
     * 私钥加签
     *
     * @param ciphertext       密文
     * @param privateKeyBase64 私钥Base64
     * @return 加密后的base64签名
     */
    public static String rsaSign(String ciphertext, String privateKeyBase64) {
        try {
            // 密文字节数组
            byte[] ciphertextBytes = Base64Utils.decode(ciphertext);
            PrivateKey privateKey = getPrivateKey(privateKeyBase64);
            Signature signature = Signature.getInstance(SIGN_ALGORITHMS);
            signature.initSign(privateKey);
            signature.update(ciphertextBytes);
            byte[] signed = signature.sign();
            return Base64Utils.encodeToString(signed);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
 
    /**
     * 公钥验签
     *
     * @param ciphertext      密文
     * @param sign            签名
     * @param publicKeyBase64 公钥base64
     * @return 是否篡改了数据
     */
    public static boolean rsaSignCheck(String ciphertext, String sign, String publicKeyBase64) {
        try {
            // 密文base64解码字节数组
            byte[] ciphertextBytes = Base64Utils.decode(ciphertext);
            // 签名base64解码字节数组
            byte[] signBytes = Base64Utils.decode(sign);
            PublicKey publicKey = getPublicKey(publicKeyBase64);
            Signature signature = Signature.getInstance(SIGN_ALGORITHMS);
            signature.initVerify(publicKey);
            signature.update(ciphertextBytes);
            return signature.verify(signBytes);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }
 
    /**
     * 获取公钥长度
     *
     * @param publicKey 公钥
     * @return
     */
    public static int getKeySize(PublicKey publicKey) {
        RSAPublicKey rsaPublicKey = (RSAPublicKey) publicKey;
        return rsaPublicKey.getModulus().bitLength();
    }
 
    /**
     * 获取私钥长度
     *
     * @param privateKey 私钥
     * @return
     */
    public static int getKeySize(PrivateKey privateKey) {
        RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) privateKey;
        return rsaPrivateKey.getModulus().bitLength();
    }
 
    public static void main(String[] args) throws Exception {
        // 获取密钥
        KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
        generator.initialize(1024);
        KeyPair keyPair = generator.generateKeyPair();
        String privateKey = Base64Utils.encodeToString(keyPair.getPrivate().getEncoded());
        String publicKey = Base64Utils.encodeToString(keyPair.getPublic().getEncoded());
        System.out.println("1.私钥:" + privateKey);
        System.out.println("2.公钥:" + publicKey);
 
        String text = "hello world";
        System.out.println("3.明文:" + text);
        // 使用公钥加密
        String encryptText = publicKeyEncrypt(text, publicKey);
        System.out.println("4.密文:" + encryptText);
        String changeText = "goodbye world";
        System.out.println("5.篡改后明文:" + changeText);
        // 使用公钥加密
        String encryptChangeText = publicKeyEncrypt(changeText, publicKey);
        System.out.println("6.篡改后密文:" + encryptChangeText);
 
        // 解密密文
        String decryptText = privateKeyDecrypt(encryptText, privateKey);
        // 解密篡改后密文
        String decryptChangeText = privateKeyDecrypt(encryptChangeText, privateKey);
        // 解密后明文
        System.out.println("7.解密后明文:" + decryptText);
        System.out.println("7.解密后篡改明文:" + decryptChangeText);
        // 加签
        String sign = rsaSign(encryptText, privateKey);
        System.out.println("8.签名:" + sign);
        // 验签
        boolean pass = rsaSignCheck(encryptText, sign, publicKey);
        System.out.println("9.是否一致:" + pass);
 
    }
}
渔老师
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
AES和RSA加密简介+Java使用工具类
socct_yj的博客
12-14 5959
一、AES和RSA 1、对称加密和非对称加密简介 目前常见的加密方式是有两种，一种是对称加密(AES为代表），一种是非对称加密（RSA为代表）。 对称加密只有一个秘钥，加密和解密都是用同一个秘钥，所以叫做对称加密。 非对称加密有两个秘钥，一个是公钥，一个是私钥。非对称的特点在于，公钥加密的私钥可以解密，但私钥加密的，公钥解不出来，只能验证是否由私钥进行加密 这样可以保证就算有人拿到公钥，也解密不出私钥加密后的信息，公钥可以在网上安全的传输。而且公钥可以验证这个密文是不是由私钥加密出来的..
工具类-06-RSA工具类(支持分段，验签)
Alan0517
09-09 455
【代码】工具类-06-RSA工具类(支持分段，验签)
最新JAVA RSA非对称加密工具类(1)，2024最新Java大厂面试题来袭
最新发布
2401_84692641的博客
05-14 935
看完上述知识点如果你深感Java基础不够扎实，或者刷题刷的不够、知识不全面小编专门为你量身定制了一套针对知识面不够，也莫慌！还有一整套的，可以瞬间查漏补缺全都是一丢一丢的收集整理纯手打出来的。
RSA工具类（Java）
PinelliaLogic的博客
05-30 924
【代码】RSA加密工具类。
RSA非对称加密（附工具类Util）
Javaの甘乃迪的博客
05-03 3084
RSA非对称加密（附工具类Util）
RSA公私钥加密工具类
tjd5214的博客
08-26 494
import org.apache.commons.codec.binary.Base64; import javax.crypto.Cipher; import java.nio.charset.StandardCharsets; import java.security.*; import java.security.interfaces.RSAPrivateKey; import java.security.interfaces.RSAPublicKey; import java.security..
RSA+AES 加密工具类 Java
03-13
RSA和AES是两种常见的加密算法，用于保护敏感信息不被未授权的访问者窃取。在这个“RSA+AES加密工具类 Java”中，我们将深入探讨这两种加密技术以及如何在Java环境中，包括Android和Web应用，实现它们。 首先，RSA...
unity工具类RSA加密和解密
11-04
在Unity引擎中，RSA（Rivest-Shamir-Adleman）是一种广泛使用的非对称加密算法，常用于安全传输数据、数字签名等场景。本文将深入探讨RSA加密和解密的基础知识以及如何在Unity中实现这一功能。 首先，RSA加密的核心...
RSA.rar_rsa_rsa java_rsa加密算法
09-24
在描述中提到的“RSA加密算法简单实现，主要包括字符的加密，不能处理汉字”，这暗示了RSA在处理ASCII字符集时较为便捷，但对于Unicode字符集，特别是包含汉字的字符串，处理起来会比较复杂。这是因为RSA默认处理的...
C#RSA加密解密工具
09-07
C# RSA加密解密工具是一种基于公钥/私钥对的加密算法实现，主要用于保障数据的安全传输和存储。RSA（Rivest-Shamir-Adleman）算法是公开密钥加密技术的鼻祖，由Ron Rivest、Adi Shamir和Leonard Adleman在1977年提出...
rsa公钥私钥生成工具类代码
03-20
rsa公钥私钥生成工具-java代码实现。 常见的加解密算法处理工具
国际RSA算法工具，非常实用
08-17
支持模长N、私钥D、指数E、CRT五元组运算模式；支持功能：密钥产生、密钥检测（实用）、公钥加密、私钥解密、密钥补全（非常实用，输入P、Q后补全后面的DP\DQ\Qinv，以及根据NDE补全CRT五元组），提供给有需要的开发者
rsa加密工具类
07-13
非常实用的rsa加解密工具类，加签验签，拿过去就能用，包含测试代码
微信小程序能用RSA分段加解密工具类
09-29
微信小程序能用RSA分段加解密工具类。直接复制到你的工程下就能用
RSA加密解密签名加签验签RsaUtils工具类
gongjin28_csdn的博客
03-19 1367
RSA基于数学上的大整数因子分解难题，只要密钥足够大（通常建议至少2048位），在现有的计算机技术和算法条件下，破解RSA加密的数据所需的时间极其漫长，从而确保了高度的安全性。RSA算法基于大数因子分解难题，提供了公钥加密和私钥解密的能力。：除了加密外，RSA还可用于数字签名，通过私钥对数据进行签名，然后接收方可以用公钥验证签名的真实性，确保数据完整性并确认发送者的身份。：虽然实际运算复杂，但RSA算法本身是公开的，这增强了人们对算法安全性的信任，因为任何潜在的漏洞都可以经过全球专家的审查和改进。
使用RSA密钥对进行加密解密示例
有一只海豚
07-21 1915
私钥则是保密的，只有私钥的持有者才能使用它来解密数据。因此，RSA密钥对的私钥应该被妥善保护，只有授权的人员可以使用它。为了确保数据的安全性，建议随机生成一个密钥文件，并将其保存在一个安全的位置，例如 U 盘等。只有知道密码的人才能使用该私钥进行操作，即使私钥被窃取，攻击者也无法直接使用私钥，除非他们能够破解密码。RSA算法使用随机数生成器进行加密，导致每次加密的结果都不同，增加了破解的难度。但只要使用正确的私钥进行解密，无论加密结果是否相同，都可以将密文还原成相同的明文。
初试加解密工具RSA Tool 1.7
howard2005的专栏
11-25 1914
一、获取加密工具； 二、实现数据加密； 三、实现数据解密
java RSA加密解密
kf的专栏
02-03 752
该工具类中用到了BASE64，需要借助第三方类库：javabase64-1.3.1.jar 注意： RSA加密明文最大长度117字节，解密要求密文最大长度为128字节，所以在加密和解密的过程中需要分块进行。 RSA加密对明文的长度是有限制的，如果加密数据过大会抛出如下异常： RSA加密解密" />Exception in thread "main" javax.crypto.Illega
RSA加密算法PEM格式转换XML解密
10-25
RSA加密算法是一种非对称加密算法，它的安全性基于大数分解的难度。PEM格式和XML格式都是存储RSA公钥和私钥的格式，但是它们之间的格式不同，需要进行转换。下面是PEM格式转换XML的步骤： 1. 将PEM格式的公钥或私钥...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值