Java实现RSA工具类（加密、解密、签名、验签）

最新推荐文章于 2025-04-15 18:20:55 发布
最新推荐文章于 2025-04-15 18:20:55 发布
阅读量2.6w 收藏 127
点赞数 32
分类专栏： Java常用工具类 文章标签： 算法 java 加密解密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alian_1223/article/details/117672964
版权

目录

一、简介

  RSA是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。RSA就是他们三人姓氏开头字母拼在一起组成的。
  RSA公开密钥密码体制是一种使用不同的加密密钥与解密密钥，“由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制。

二、RSA

2.1 算法原理

  RSA公开密钥密码体制的原理是：根据数论，寻求两个大素数比较简单，而将它们的乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。

2.2RSA与RSA2区别

  RSA和RSA2分不清楚？你就记住一点：RSA2 密钥的长度至少为 2048；RSA密钥长度不限制，默认长度1024，推荐长度2048。（密钥长度必须是64的倍数，在512到65536位之间）

签名算法名称标准签名验证算法名称说明
RSASHA1WithRSA密钥长度不限制，默认长度1024，推荐长度2048
RSA2SHA256WithRSARSA2 密钥的长度至少为 2048

  标准算法签名名称可能还有使用到其他的，比如MD5WithRSA，本文都是采用的SHA1WithRSA或SHA256WithRSA

2.2 公钥加密、私钥解密、私钥签名、公钥验签

如下图所示双向对称加密双方都是有三个密钥的，比如：

组织/密钥支付宝公钥支付宝私钥商家公钥商家私钥
支付宝平台拥有拥有拥有(商家上传)-
商家拥有(支付宝平台下载)-拥有拥有

为了让大家分清楚这四者的区别，我们用支付宝支付进行举例，但是一定要知道两个前提：

  • 密钥是有两对，支付宝公钥和私钥，商家公钥和私钥
  • 公钥双方都会有（包括对方的），私钥只有自己拥有自己的，不会支付宝有商家私钥或者商家有支付宝私钥

当商户向支付宝发送订单请求时：
商户是用支付宝的公钥进行数据加密，用商户的私钥进行签名。
支付宝接收数据后
支付宝可以用支付宝私钥进行数据的解密，用商户的公钥进行验签。

当支付宝异步通知商户支付结果时：
支付宝是用商户的公钥进行数据加密，用支付宝私钥进行签名。
商户接收数据后
商户就用商户的私钥进行解密，用支付宝公钥进行验签。

结合上面的图表，这样大家就应该理解了吧。实际支付宝支付都有SDK，不用你进行实质的加密加签，只要你不把密钥传错就行了，这里也是举这个例子让大家了解RSA这种加密机制的安全性。

三、RsaUtil工具类

工具类里包含RSA及RSA2密钥生成，公钥加密、私钥解密、私钥签名、公钥验签等，可以仔细阅读我的注释，以示区别。

RsaUtil.java

package com.alian.csdn.utils;

import javax.crypto.Cipher;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;

/**
 * @program: CSDN
 * @description: RSA工具类
 * @author: Alian
 * @create: 2021-06-08 09:30:14
 **/
public class RsaUtil {

    //签名算法名称
    private static final String RSA_KEY_ALGORITHM = "RSA";

    //标准签名算法名称
    private static final String RSA_SIGNATURE_ALGORITHM = "SHA1withRSA";
    private static final String RSA2_SIGNATURE_ALGORITHM = "SHA256withRSA";

    //RSA密钥长度,默认密钥长度是1024,密钥长度必须是64的倍数，在512到65536位之间,不管是RSA还是RSA2长度推荐使用2048
    private static final int KEY_SIZE = 2048;

    /**
     * 生成密钥对
     *
     * @return 返回包含公私钥的map
     */
    public static Map<String, String> generateKey() {
        KeyPairGenerator keygen;
        try {
            keygen = KeyPairGenerator.getInstance(RSA_KEY_ALGORITHM);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("RSA初始化密钥出现错误,算法异常");
        }
        SecureRandom secrand = new SecureRandom();
        //初始化随机产生器
        secrand.setSeed("Alian".getBytes());
        //初始化密钥生成器
        keygen.initialize(KEY_SIZE, secrand);
        KeyPair keyPair = keygen.genKeyPair();
        //获取公钥并转成base64编码
        byte[] pub_key = keyPair.getPublic().getEncoded();
        String publicKeyStr = Base64.getEncoder().encodeToString(pub_key);
        //获取私钥并转成base64编码
        byte[] pri_key = keyPair.getPrivate().getEncoded();
        String privateKeyStr = Base64.getEncoder().encodeToString(pri_key);
        //创建一个Map返回结果
        Map<String, String> keyPairMap = new HashMap<>();
        keyPairMap.put("publicKeyStr", publicKeyStr);
        keyPairMap.put("privateKeyStr", privateKeyStr);
        return keyPairMap;
    }

    /**
     * 公钥加密(用于数据加密)
     *
     * @param data         加密前的字符串
     * @param publicKeyStr base64编码后的公钥
     * @return base64编码后的字符串
     * @throws Exception
     */
    public static String encryptByPublicKey(String data, String publicKeyStr) throws Exception {
        //Java原生base64解码
        byte[] pubKey = Base64.getDecoder().decode(publicKeyStr);
        //创建X509编码密钥规范
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pubKey);
        //返回转换指定算法的KeyFactory对象
        KeyFactory keyFactory = KeyFactory.getInstance(RSA_KEY_ALGORITHM);
        //根据X509编码密钥规范产生公钥对象
        PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
        //根据转换的名称获取密码对象Cipher（转换的名称：算法/工作模式/填充模式）
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        //用公钥初始化此Cipher对象（加密模式）
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        //对数据加密
        byte[] encrypt = cipher.doFinal(data.getBytes());
        //返回base64编码后的字符串
        return Base64.getEncoder().encodeToString(encrypt);
    }

    /**
     * 私钥解密(用于数据解密)
     *
     * @param data          解密前的字符串
     * @param privateKeyStr 私钥
     * @return 解密后的字符串
     * @throws Exception
     */
    public static String decryptByPrivateKey(String data, String privateKeyStr) throws Exception {
        //Java原生base64解码
        byte[] priKey = Base64.getDecoder().decode(privateKeyStr);
        //创建PKCS8编码密钥规范
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(priKey);
        //返回转换指定算法的KeyFactory对象
        KeyFactory keyFactory = KeyFactory.getInstance(RSA_KEY_ALGORITHM);
        //根据PKCS8编码密钥规范产生私钥对象
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        //根据转换的名称获取密码对象Cipher（转换的名称：算法/工作模式/填充模式）
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        //用私钥初始化此Cipher对象（解密模式）
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        //对数据解密
        byte[] decrypt = cipher.doFinal(Base64.getDecoder().decode(data));
        //返回字符串
        return new String(decrypt);
    }

    /**
     * 私钥加密(用于数据签名)
     *
     * @param data          加密前的字符串
     * @param privateKeyStr base64编码后的私钥
     * @return base64编码后后的字符串
     * @throws Exception
     */
    public static String encryptByPrivateKey(String data, String privateKeyStr) throws Exception {
        //Java原生base64解码
        byte[] priKey = Base64.getDecoder().decode(privateKeyStr);
        //创建PKCS8编码密钥规范
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(priKey);
        //返回转换指定算法的KeyFactory对象
        KeyFactory keyFactory = KeyFactory.getInstance(RSA_KEY_ALGORITHM);
        //根据PKCS8编码密钥规范产生私钥对象
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        //根据转换的名称获取密码对象Cipher（转换的名称：算法/工作模式/填充模式）
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        //用私钥初始化此Cipher对象（加密模式）
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        //对数据加密
        byte[] encrypt = cipher.doFinal(data.getBytes());
        //返回base64编码后的字符串
        return Base64.getEncoder().encodeToString(encrypt);
    }

    /**
     * 公钥解密(用于数据验签)
     *
     * @param data         解密前的字符串
     * @param publicKeyStr base64编码后的公钥
     * @return 解密后的字符串
     * @throws Exception
     */
    public static String decryptByPublicKey(String data, String publicKeyStr) throws Exception {
        //Java原生base64解码
        byte[] pubKey = Base64.getDecoder().decode(publicKeyStr);
        //创建X509编码密钥规范
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pubKey);
        //返回转换指定算法的KeyFactory对象
        KeyFactory keyFactory = KeyFactory.getInstance(RSA_KEY_ALGORITHM);
        //根据X509编码密钥规范产生公钥对象
        PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
        //根据转换的名称获取密码对象Cipher（转换的名称：算法/工作模式/填充模式）
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        //用公钥初始化此Cipher对象（解密模式）
        cipher.init(Cipher.DECRYPT_MODE, publicKey);
        //对数据解密
        byte[] decrypt = cipher.doFinal(Base64.getDecoder().decode(data));
        //返回字符串
        return new String(decrypt);
    }

    /**
     * RSA签名
     *
     * @param data     待签名数据
     * @param priKey   私钥
     * @param signType RSA或RSA2
     * @return 签名
     * @throws Exception
     */
    public static String sign(byte[] data, byte[] priKey, String signType) throws Exception {
        //创建PKCS8编码密钥规范
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(priKey);
        //返回转换指定算法的KeyFactory对象
        KeyFactory keyFactory = KeyFactory.getInstance(RSA_KEY_ALGORITHM);
        //根据PKCS8编码密钥规范产生私钥对象
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        //标准签名算法名称(RSA还是RSA2)
        String algorithm = RSA_KEY_ALGORITHM.equals(signType) ? RSA_SIGNATURE_ALGORITHM : RSA2_SIGNATURE_ALGORITHM;
        //用指定算法产生签名对象Signature
        Signature signature = Signature.getInstance(algorithm);
        //用私钥初始化签名对象Signature
        signature.initSign(privateKey);
        //将待签名的数据传送给签名对象(须在初始化之后)
        signature.update(data);
        //返回签名结果字节数组
        byte[] sign = signature.sign();
        //返回Base64编码后的字符串
        return Base64.getEncoder().encodeToString(sign);
    }

    /**
     * RSA校验数字签名
     *
     * @param data     待校验数据
     * @param sign     数字签名
     * @param pubKey   公钥
     * @param signType RSA或RSA2
     * @return boolean 校验成功返回true，失败返回false
     */
    public static boolean verify(byte[] data, byte[] sign, byte[] pubKey, String signType) throws Exception {
        //返回转换指定算法的KeyFactory对象
        KeyFactory keyFactory = KeyFactory.getInstance(RSA_KEY_ALGORITHM);
        //创建X509编码密钥规范
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pubKey);
        //根据X509编码密钥规范产生公钥对象
        PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
        //标准签名算法名称(RSA还是RSA2)
        String algorithm = RSA_KEY_ALGORITHM.equals(signType) ? RSA_SIGNATURE_ALGORITHM : RSA2_SIGNATURE_ALGORITHM;
        //用指定算法产生签名对象Signature
        Signature signature = Signature.getInstance(algorithm);
        //用公钥初始化签名对象,用于验证签名
        signature.initVerify(publicKey);
        //更新签名内容
        signature.update(data);
        //得到验证结果
        return signature.verify(sign);
    }
}

四、实践

4.1 数据的加密和解密

自动生成公钥和私钥，然后对数据进行加密和解密。

/**
     * RSA数据加密和解密
     *
     * @throws Exception
     */
    @Test
    public void encryptAndDecrypt() throws Exception {
        Map<String, String> keyMap = RsaUtil.generateKey();
        String publicKeyStr = keyMap.get("publicKeyStr");
        String privateKeyStr = keyMap.get("privateKeyStr");
        System.out.println("-----------------生成的公钥和私钥------------------------------");
        System.out.println("获取到的公钥：" + publicKeyStr);
        System.out.println("获取到的私钥：" + privateKeyStr);
        // 待加密数据
        String data = "tranSeq=1920542585&amount=100&payType=wechat";
        // 公钥加密
        System.out.println("-----------------加密和解密------------------------------");
        System.out.println("待加密的数据：" + data);
        String encrypt = RsaUtil.encryptByPublicKey(data, publicKeyStr);
        System.out.println("加密后数据：" + encrypt);
        // 私钥解密
        String decrypt = RsaUtil.decryptByPrivateKey(encrypt, privateKeyStr);
        System.out.println("解密后数据：" + decrypt);
    }

运行结果：

-----------------生成的公钥和私钥------------------------------
获取到的公钥：MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAohMRTo1UbmSXBl9gl4+BdQP7j5xB4PuDaM2UoIyX7t0X7djexOhzQ2z/ZZQRHLxw9y0a0MVSmGDQDUj6+yQKcgKgeZjsTajNsa0ceNhH64y4bDj8O9EWHqEwIAiDur3o9K0WFoXgIXeXS0G4puYNauu4hFEDM8FQE/BZ8C7OX2NLdCqqX6JIhfmq8pOlloLaDllS58XLtR8oIfQnBiwTIaxqYALUf/4Sh8DzN4mviIvnO7fcGFBTTw0aNTroRysbzRJldrlU77LtHgZAj019srcIEdZJmeA5nUweqyC+RWaDxDdh/WF9HNCfeLLtffTj7j4wQlRFvQylrejTVCaA4wIDAQAB
获取到的私钥：MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCiExFOjVRuZJcGX2CXj4F1A/uPnEHg+4NozZSgjJfu3Rft2N7E6HNDbP9llBEcvHD3LRrQxVKYYNANSPr7JApyAqB5mOxNqM2xrRx42EfrjLhsOPw70RYeoTAgCIO6vej0rRYWheAhd5dLQbim5g1q67iEUQMzwVAT8FnwLs5fY0t0KqpfokiF+aryk6WWgtoOWVLnxcu1Hygh9CcGLBMhrGpgAtR//hKHwPM3ia+Ii+c7t9wYUFNPDRo1OuhHKxvNEmV2uVTvsu0eBkCPTX2ytwgR1kmZ4DmdTB6rIL5FZoPEN2H9YX0c0J94su199OPuPjBCVEW9DKWt6NNUJoDjAgMBAAECggEAJARgwDggHzgzZ7MiYAwAFOUBrnRnH3xFQ7EL6nHUAb0YaD7dopyVoNJEH2q8MsqdwBBB+Usgg8Rf99PUEqN7vsJerycQvGFa9LUnsqM9uFbZVROE2jYo2D2x2CyMOZ+ieV1Nn0u49zcAZDUCt/Q/3xbrNlxafdHj3cp38iw0qHWn5JD4R3cBuZTvvlgrkPYXPHPYXJQ6y5bDDonb5FaDfdZRNuEdY73i2VT//DeivgZ+F4fj2uuxdTxW8dYmgXBrjjHAni6c06H7LCg8LTdam8jojVhLFvTnmwZALi0F2AMjZA4CL3bloHKjJwO6qwbKZdJ+WIeFsPsVZeoeQPQ24QKBgQD79ALiCDuwHZitEG4b1CPm2WzA3BMA0yiU+RBdFiPFbUqq8b1fMOcGwJhHw6gfV75t1BY2tso0++on9WPM6j6VPIGrbVhfGRmnCCBQ1HM26hRBAUYVhqi6VAdxrJbatzAkqjT5fMLbPRWDxWI+nhWNSHVulqEVP7AhZybQqZsG9wKBgQCkrX2L3erCBWfJ3cn14G9CMNy8gXU2LfD5TD1kTPDAp+e0pviIsxWGIbikZnVft7TdEb9l6V8W7QOnrqFQPluZOKeHNBIW6jx8L9pmUWU2fKOLiuNxeBy79xz24gqydfAkVhmkPYZJJ19cN2CvLXgrC13zv7SgfDkJ2TkK+qe+dQKBgCWz0wad8sic9S7YqZFygljWKmcFx7Y04vq/9onneTze6PCBsjPfboLdKSx8A9mE2NM4jIZtff7Fv7lxCBku6GSOpFzRxQqeB++t0KAn2oHaL2O23BT2jKMtVdvV1tEt3n9uFPVMjSAfmOuaCuSR5Wm58RC2a65xVFr7Q5yv9KnrAoGAImtorE1L/hWnJdhHmC660njoCjZ8y0A698BprIcwYvQ1R9sGY3wa6ZguwZ3wtnrtQK+u85wdlesgMnIboWwHNTVUPrwxc7ytu788xNoKb6MJg+cZtuPGDbuOwENqvPZNpSqh3WRGpw+lrN6eRL8aONT9ZC8Tj9+nBFn0xEizuukCgYA4sBJOJvdwxLXGkf87WWXjgpaVudLwfWquOy67hoM2Mn9Ilf3Wbl99rFJLq+QcHv9jllIza56E9ooVLYnMiVDzZNRceewYhCIExRppY7/sn/qeJHsymGU2S749zxNbwii6N1XmWncrr9kshP2sB3Cn5eUlr5YE8mQ++WJLD8Rhnw==
-----------------加密和解密------------------------------
待加密的数据：tranSeq=1920542585&amount=100&payType=wechat
加密后数据：RoXB0OyE8uHZS0tlO6yND8iv1m1MibLbyzVRWUM0vNBjm/mnMqO9hZxaCGlNBKhPoK3KA+V4cWpmRj8q+38Y5lQDudAJAJ6FlHJP3GJyTuJu4CoWv+sw5tGMb7cIdQFcREAitKrvxw5VXPIF4ex7XdvqcJQ2vVM1zbNKHXeYmg1GmIvMYnBWz0Z/sBIAocTM6eijlGwDqTUMOKX+fjIJWOEX1uLd4fdQ/bvK2nTJk0uK2y2id+rhbiLW9o7u+3CIUI3FroIaCMtpCa8G3qiFz8epZuFGLP+NhdBz4TjEheJBiEFZ+IkUttFFwhzww30Mb5EhN+JGhIxvS+bGKF0ukw==
解密后数据：tranSeq=1920542585&amount=100&payType=wechat

4.2 数据的签名和验签

自动生成公钥和私钥，然后对数据进行签名和验签。

/**
     * RSA数据签名和验签
     *
     * @throws Exception
     */
    @Test
    public void signAndVerify() throws Exception {
        Map<String, String> keyMap = RsaUtil.generateKey();
        String publicKeyStr = keyMap.get("publicKeyStr");
        String privateKeyStr = keyMap.get("privateKeyStr");
        System.out.println("-----------------生成的公钥和私钥------------------------------");
        System.out.println("获取到的公钥：" + publicKeyStr);
        System.out.println("获取到的私钥：" + privateKeyStr);
        // 数字签名
        String data = "tranSeq=1920542585&amount=100&payType=wechat";
        System.out.println("待签名的数据：" + data);
        String sign = RsaUtil.sign(data.getBytes(), Base64.getDecoder().decode(privateKeyStr), "RSA");
        System.out.println("数字签名结果：" + sign);
        boolean verify = RsaUtil.verify(data.getBytes(), Base64.getDecoder().decode(sign), Base64.getDecoder().decode(publicKeyStr), "RSA");
        System.out.println("数字签名验证结果：" + verify);
    }

运行结果：

-----------------生成的公钥和私钥------------------------------
获取到的公钥：MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAohMRTo1UbmSXBl9gl4+BdQP7j5xB4PuDaM2UoIyX7t0X7djexOhzQ2z/ZZQRHLxw9y0a0MVSmGDQDUj6+yQKcgKgeZjsTajNsa0ceNhH64y4bDj8O9EWHqEwIAiDur3o9K0WFoXgIXeXS0G4puYNauu4hFEDM8FQE/BZ8C7OX2NLdCqqX6JIhfmq8pOlloLaDllS58XLtR8oIfQnBiwTIaxqYALUf/4Sh8DzN4mviIvnO7fcGFBTTw0aNTroRysbzRJldrlU77LtHgZAj019srcIEdZJmeA5nUweqyC+RWaDxDdh/WF9HNCfeLLtffTj7j4wQlRFvQylrejTVCaA4wIDAQAB
获取到的私钥：MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCiExFOjVRuZJcGX2CXj4F1A/uPnEHg+4NozZSgjJfu3Rft2N7E6HNDbP9llBEcvHD3LRrQxVKYYNANSPr7JApyAqB5mOxNqM2xrRx42EfrjLhsOPw70RYeoTAgCIO6vej0rRYWheAhd5dLQbim5g1q67iEUQMzwVAT8FnwLs5fY0t0KqpfokiF+aryk6WWgtoOWVLnxcu1Hygh9CcGLBMhrGpgAtR//hKHwPM3ia+Ii+c7t9wYUFNPDRo1OuhHKxvNEmV2uVTvsu0eBkCPTX2ytwgR1kmZ4DmdTB6rIL5FZoPEN2H9YX0c0J94su199OPuPjBCVEW9DKWt6NNUJoDjAgMBAAECggEAJARgwDggHzgzZ7MiYAwAFOUBrnRnH3xFQ7EL6nHUAb0YaD7dopyVoNJEH2q8MsqdwBBB+Usgg8Rf99PUEqN7vsJerycQvGFa9LUnsqM9uFbZVROE2jYo2D2x2CyMOZ+ieV1Nn0u49zcAZDUCt/Q/3xbrNlxafdHj3cp38iw0qHWn5JD4R3cBuZTvvlgrkPYXPHPYXJQ6y5bDDonb5FaDfdZRNuEdY73i2VT//DeivgZ+F4fj2uuxdTxW8dYmgXBrjjHAni6c06H7LCg8LTdam8jojVhLFvTnmwZALi0F2AMjZA4CL3bloHKjJwO6qwbKZdJ+WIeFsPsVZeoeQPQ24QKBgQD79ALiCDuwHZitEG4b1CPm2WzA3BMA0yiU+RBdFiPFbUqq8b1fMOcGwJhHw6gfV75t1BY2tso0++on9WPM6j6VPIGrbVhfGRmnCCBQ1HM26hRBAUYVhqi6VAdxrJbatzAkqjT5fMLbPRWDxWI+nhWNSHVulqEVP7AhZybQqZsG9wKBgQCkrX2L3erCBWfJ3cn14G9CMNy8gXU2LfD5TD1kTPDAp+e0pviIsxWGIbikZnVft7TdEb9l6V8W7QOnrqFQPluZOKeHNBIW6jx8L9pmUWU2fKOLiuNxeBy79xz24gqydfAkVhmkPYZJJ19cN2CvLXgrC13zv7SgfDkJ2TkK+qe+dQKBgCWz0wad8sic9S7YqZFygljWKmcFx7Y04vq/9onneTze6PCBsjPfboLdKSx8A9mE2NM4jIZtff7Fv7lxCBku6GSOpFzRxQqeB++t0KAn2oHaL2O23BT2jKMtVdvV1tEt3n9uFPVMjSAfmOuaCuSR5Wm58RC2a65xVFr7Q5yv9KnrAoGAImtorE1L/hWnJdhHmC660njoCjZ8y0A698BprIcwYvQ1R9sGY3wa6ZguwZ3wtnrtQK+u85wdlesgMnIboWwHNTVUPrwxc7ytu788xNoKb6MJg+cZtuPGDbuOwENqvPZNpSqh3WRGpw+lrN6eRL8aONT9ZC8Tj9+nBFn0xEizuukCgYA4sBJOJvdwxLXGkf87WWXjgpaVudLwfWquOy67hoM2Mn9Ilf3Wbl99rFJLq+QcHv9jllIza56E9ooVLYnMiVDzZNRceewYhCIExRppY7/sn/qeJHsymGU2S749zxNbwii6N1XmWncrr9kshP2sB3Cn5eUlr5YE8mQ++WJLD8Rhnw==
待签名的数据：tranSeq=1920542585&amount=100&payType=wechat
数字签名结果：Nz3i87LUGbn32vsxreuSENkSAxcQGLMYnxzGr+Yb2maTuXVcG0JIhYV7p3/oYgooD3hcvdBjt9jjUNZo1pTSM10mFBvoHLCCrbKln+Ia9EqgwIyOV2xF/qdNrvwBD1iuogUXfVjJ6+jf07uJOUUub+hIlbhdLAN+Rol4Xa7TU2nopPlG5sQuM5HmmIov6jQ+RgWk8nIi/IMbskOIGaHrFR1/N4MVm4tpwOAbpg1LGw6Xv2lPtlHd7clKWrmlPVI+QnTddw7sJffo2Hfalx0roHuBk2kuPWsNP1/8Q6UsMay5fkB0Nh43Lw3Dqahsyi+8PEbEIldJ2pWhEQX2p6u3bQ==
数字签名验证结果：true

结语

  以上就是今天要讲的内容，本文仅仅简单介绍了RSA，简单编写了一个RsaUtil工具类,包含了RSA和RSA2两种模式。实现了密钥生成、公钥加密、私钥解密、私钥签名、公钥验签，有兴趣的同学可以先去了解一下RSA具体的算法原理，希望对您有所帮助，欢迎大家评论交流。

JAVA RSA工具类
qq_20138047的博客
02-14 313
【代码】JAVA RAS工具类。
rsa工具类 java_Java实现RSA加密工具类
weixin_32384503的博客
02-13 1297
公钥加密算法，也就是 非对称加密算法，这种算法加密和解密的密码不一样，一个是公钥，另一个是私钥：公钥和私钥成对出现公开的密钥叫公钥，只有自己知道的叫私钥用公钥加密的数据只有对应的私钥可以解密用私钥加密的数据只有对应的公钥可以解密如果可以用公钥解密，则必然是对应的私钥加的密如果可以用私钥解密，则必然是对应的公钥加的密公钥和私钥是相对的，两者本身并没有规定哪一个必须是公钥或私钥。代码如下package...
java版RSA工具类
唐小白的花园
11-06 179
&#13; /** * RSA算法加密/解密工具类 */ public class RSAUtils { private static final Logger LOGGER = LoggerFactory.getLogger(RSAUtils.class); /** 算法名称 */ private static final String ALG...
java实现RSA加密解密
最新发布
weixin_45620445的博客
04-15 926
RSA（Rivest-Shamir-Adleman）是1977年提出的非对称加密算法，广泛应用于数字签名、HTTPS通信、密钥交换等场景。非对称加密：公钥加密，私钥解密。安全性依赖：大整数质因数分解的数学难题。优势：安全性高，支持数字签名。缺点：计算速度慢，适合加密小数据（如对称密钥）。
Java RSA加密工具类（含密钥对生成和根据私钥计算公钥）
cl617287的博客
11-11 3599
Java RSA和RSA2加密工具（生成密钥对，加密解密，根据私钥计算公钥等）
Java RSA 加密解密工具类 RSAUtil 支持长文本加密解密（密钥对生成、公钥加密、私钥加密、公钥解密、私钥解密）
emmmm.....
10-24 3514
对于加密解密的代码，我把我能想到的可能会使用的都封装在了如下工具类中，代码注释也尽量写详细了，如：密钥对生成、公钥加密、私钥加密、公钥解密、私钥解密，不包括其中的 main 测试的话，加上注释 500+ 行，嘿嘿~
RSA工具类（Java）
PinelliaLogic的博客
05-30 1151
【代码】RSA加密工具类。
RSA加密解密签名加签验签RsaUtils工具类
04-15
RSA加密解密签名加签验签RsaUtils工具类 RSA算法基于大数因子分解难题，提供了公钥加密和私钥解密的能力。公钥用于加密，私钥则负责解密。这种特性使得RSA成为保证数据传输安全的理想选择。 公钥加密私钥解密与...
RSA2--》加签+加密+解密+验签
09-23
本文将详细讲解RSA算法的加签、加密、解密以及验签的过程，结合Java语言来实现这一系列操作，并涉及到证书的使用。 首先，我们需要理解RSA算法的基本原理。RSA算法基于两个大素数的乘积难以分解这一数学难题，生成...
Android之RSA加密解密签名验签（亲测可用）
05-11
在Android开发中，数据安全是至关重要的，尤其是在...通过以上步骤，您可以在Android应用中实现RSA加密解密和签名验签功能，确保数据的安全传输和验证。记住，安全无小事，合理的加密策略是保障应用安全的重要一环。
Java非对称加密：RSA 数据加密与解密、数字签名与验签
pan_junbiao的博客
10-28 1649
非对称加密（asymmetric cryptography），也称为公开密钥加密（public-key cryptography），是密码学中的一种重要算法。非对称加密使用一对密钥进行加密和解密操作，这两个密钥分别是公开密钥（public key）和私有密钥（private key）。公开密钥可以公开给任何人使用，而私有密钥则必须保密，只有密钥的持有者才能访问。这两个密钥之间存在数学上的联系，但不能从一个推导出另一个。
RSA工具类java加密解密非常全
01-31
设计到的方法如下： DigitalSign init getInstance SignMsgByRelativePath SignMsgByInputStream signMsgByAbsolutePath verifyMsgByInputSteam verifyMsgByAbsolutePath verifyMsgByRelativePath encryptMsg decodeMsg getPriKeyByInputStream getPriKeyByAbsolutePath getPriKeyByRelativePath getPubKeyByInputSteam getPublicKey getPriKey sign appendMap verify
JAVA中RSA加密解密工具类
07-13
JAVA中RSA加密解密工具类
JAVA中RSA加密解密工具类加强版
07-14
博客地址 http://blog.csdn.net/sbsujjbcy/article/details/46873403
Java RSA 加密/解密/签名 工具类
12-18
Java RSA 加密/解密/签名 工具类 Java RSA 加密/解密/签名 工具类 Java RSA 加密/解密/签名 工具类
java安全算法RSA 工具类
05-11
RSA 工具类。提供加密，解密，生成密钥对等方法。 * 需要到http://www.bouncycastle.org下载bcprov-jdk14-123.jar。 * RSA加密原理概述 * RSA的安全性依赖于大数的分解，公钥和私钥都是两个大素数（大于100的十进制位）的函数。 * 据猜测，从一个密钥和密文推断出明文的难度等同于分解两个大素数的积 * =================================================================== * （该算法的安全性未得到理论的证明） * =================================================================== * 密钥的产生： * 1.选择两个大素数 p,q ,计算 n=p*q; * 2.随机选择加密密钥 e ,要求 e 和 (p-1)*(q-1)互质 * 3.利用 Euclid 算法计算解密密钥 d , 使其满足 e*d = 1(mod(p-1)*(q-1)) (其中 n,d 也要互质) * 4:至此得出公钥为 (n,e) 私钥为 (n,d) * =================================================================== * 加解密方法： * 1.首先将要加密的信息 m(二进制表示) 分成等长的数据块 m1,m2,...,mi 块长 s(尽可能大) ,其中 2^s<n * 2:对应的密文是： ci = mi^e(mod n) * 3:解密时作如下计算： mi = ci^d(mod n)
C# RSA读取密钥文件pfx cer 签名验签加密解密帮助类
09-25
本篇文章将深入探讨如何在C#中使用RSA算法处理pfx和cer密钥文件，进行签名验证、加密和解密，并介绍如何实现C#与Java之间的公钥私钥互转。 首先，`pfx`文件是一种包含证书和私钥的二进制文件，通常用于存储服务器...
Java RSA 工具类
q42368773的博客
02-07 373
package cn.fg.util; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.PrivateKey; import java.security.PublicKey; import java...
Java实现RSA加密解密工具类
hakood的博客
04-18 753
Java实现RSA加密解密工具类
java rsa工具类
07-08
以下是一个简单的Java RSA工具类的示例代码： ```java import java.security.Key; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.PrivateKey; import java.security.PublicKey; import java.security.spec.PKCS8EncodedKeySpec; import java.security.spec.X509EncodedKeySpec; import javax.crypto.Cipher; import org.apache.commons.codec.binary.Base64; public class RSAUtils { private static final String RSA_ALGORITHM = "RSA"; public static KeyPair generateKeyPair() throws Exception { KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(RSA_ALGORITHM); keyPairGenerator.initialize(2048); return keyPairGenerator.genKeyPair(); } public static String encrypt(String plainText, PublicKey publicKey) throws Exception { Cipher cipher = Cipher.getInstance(RSA_ALGORITHM); cipher.init(Cipher.ENCRYPT_MODE, publicKey); byte[] encryptedBytes = cipher.doFinal(plainText.getBytes()); return Base64.encodeBase64String(encryptedBytes); } public static String decrypt(String encryptedText, PrivateKey privateKey) throws Exception { Cipher cipher = Cipher.getInstance(RSA_ALGORITHM); cipher.init(Cipher.DECRYPT_MODE, privateKey); byte[] encryptedBytes = Base64.decodeBase64(encryptedText); byte[] decryptedBytes = cipher.doFinal(encryptedBytes); return new String(decryptedBytes); } public static PublicKey getPublicKey(byte[] publicKeyBytes) throws Exception { X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes); KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM); return keyFactory.generatePublic(keySpec); } public static PrivateKey getPrivateKey(byte[] privateKeyBytes) throws Exception { PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes); KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM); return keyFactory.generatePrivate(keySpec); } } ``` 使用示例： ```java public class Main { public static void main(String[] args) { try { // 生成密钥对 KeyPair keyPair = RSAUtils.generateKeyPair(); PublicKey publicKey = keyPair.getPublic(); PrivateKey privateKey = keyPair.getPrivate(); // 加密 String plainText = "Hello, RSA!"; String encryptedText = RSAUtils.encrypt(plainText, publicKey); System.out.println("Encrypted Text: " + encryptedText); // 解密 String decryptedText = RSAUtils.decrypt(encryptedText, privateKey); System.out.println("Decrypted Text: " + decryptedText); } catch (Exception e) { e.printStackTrace(); } } } ``` 请注意，这只是一个简单的示例，用于演示RSA加密和解密过程。在实际应用中，您需要更加严格的错误处理和安全性措施。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值