RSA 公钥加密-私钥解密、私钥加密-公钥解密、数字签名、数字验签

最新推荐文章于 2024-09-15 20:51:37 发布
最新推荐文章于 2024-09-15 20:51:37 发布
阅读量3.1k 收藏 7
点赞数 1
分类专栏： 加密 文章标签： 加密解密 base64 rsa java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qmdluck/article/details/107405237
版权

数字签名和加密的区别

数字签名和验证：

发送报文时，发送方用一个hash算法从报文中产生固定长度的报文摘要，然后利用自己的私钥对这个摘要进行加密，这个过程就叫签名。这个加密后的摘要作为报文的数字签名和报文一起发送给接收方，接收方用发送方的公钥解密被加密的摘要（报文附加的数字签名）得到结果A，然后用于发送方一样的hash算法从接收到的原始报文中算出报文摘要B。最后,把A和B作比较。如果相同，那么接收方就能确认该数字签名是发送方的。

数字签名的功能:

1、对签名者进行身份认证；

2、保证信息的完整性（在交易过程中，没有被篡改）

3、防止交易中的抵赖发生（签名者无法否认信息是由自己发出的）

 加密和解密：

发送方利用接收方的公钥对要发送的明文进行加密,接受方利用自己的私钥进行解密,其中公钥和私钥匙相对的,任何一个作为公钥,则另一个就为私钥。

加密的功能：

重点在于“数据的安全性”，可以防止数据被监听攻击。

import org.apache.commons.codec.binary.Base64;
import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
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;
import java.util.HashMap;
import java.util.Map;


public class RSASignUtil {

    public static final String CHARSET = "UTF-8";
    public static final String RSA = "RSA";

    //签名算法采用SHA256WithRSA,(也可使用MD5withRSA的算法方式)
    public static final String SIGN_ALGORITHM = "SHA256WithRSA"; 

    //采用长度为2048bits的pkcs8格式的秘钥,(一般长度为512-2048)
    public static final int KEY_SIZE = 2048; 

    private static String publicKeyString;
    private static String privateKeyString;

    //加密的数据
    private static String str = "111222333444-1 111222333444-2 111222333444-3 111222333444-4 111222333444-5 "
            + "111222333444-6 111222333444-7 111222333444-8 111222333444-9 111222333444-10 "
            + "111222333444-11 111222333444-12 111222333444-13 111222333444-14 111222333444-15 "
            + "111222333444-16 111222333444-17 111222333444-18 111222333444-19 111222333444-20";

    static {
        Map<String, String> keyMap = createKeys(KEY_SIZE);
        publicKeyString = keyMap.get("publicKey");
        privateKeyString = keyMap.get("privateKey");
        System.out.println("公钥: \n\r" + publicKeyString);
        System.out.println("私钥： \n\r" + privateKeyString);
    }

    public static void main(String[] args) throws Exception {
        //公钥加密——私钥解密
        pub_pri_test();
        //私钥加密——公钥解密
        pri_pub_test();
        //私钥签名-公钥验签
        signTest();
    }

    /**
     * 公钥加密——私钥解密
     */
    private static void pub_pri_test() throws InvalidKeySpecException, NoSuchAlgorithmException {
        System.out.println("\n公钥加密——私钥解密------------------------------------------------------");
        System.out.println("\r加密前的数据：\r\n" + str + "  \n 加密前的数据大小：" + str.getBytes().length);
        String encodedData = publicEncrypt(str);
        System.out.println("公钥加密后的数据：\r\n" + encodedData);
        String decodedData = privateDecrypt(encodedData);
        System.out.println("私钥解密后的数据: \r\n" + decodedData + "\n");
    }

    /**
     * 私钥加密——公钥解密
     */
    private static void pri_pub_test() throws InvalidKeySpecException, NoSuchAlgorithmException {
        System.out.println("\n私钥加密——公钥解密------------------------------------------------------");
        System.out.println("\r加密前的数据：\r\n" + str + "  \n 加密前的数据大小：" + str.getBytes().length);
        String encryptData = privateEncrypt(str);
        System.out.println("加密后的数据：\r\n" + encryptData);
        String decryptData = publicDecrypt(encryptData);
        System.out.println("解密后的数据: \r\n" + decryptData + "\n");
    }

    /**
     * 私钥签名-公钥验签
     */
    private static void signTest() {
        System.out.println("\r签名前的数据：\r\n" + str);
        String sign = sign(str);
        System.out.println("签名后的数据 : \n" + sign);
        boolean validation = verify(str, sign);
        System.out.println("验签结果 : \n" + validation);
    }

    /**
     * 签名
     *
     * @param content
     */
    public static String sign(String content) {
        try {
            RSAPrivateKey rsaPrivateKey = getPrivateKey(privateKeyString);
            //2、执行签名
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
            KeyFactory keyFactory = KeyFactory.getInstance(RSA);
            PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            Signature signature = Signature.getInstance(SIGN_ALGORITHM);
            signature.initSign(privateKey);
            signature.update(content.getBytes());
            byte[] result = signature.sign();
            String resultData = Base64.encodeBase64URLSafeString(result);
            return resultData;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 验签
     *
     * @param content 签名前的数据
     * @param signData 签名后的数据
     * @return
     */
    public static boolean verify(String content, String signData) {
        try {
            RSAPublicKey rsaPublicKey = getPublicKey(publicKeyString);
            //3、验证签名
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
            KeyFactory keyFactory = KeyFactory.getInstance(RSA);
            PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
            Signature signature = Signature.getInstance(SIGN_ALGORITHM);
            signature.initVerify(publicKey);
            signature.update(content.getBytes());
            boolean result = signature.verify(Base64.decodeBase64(signData));
            return result;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 公钥加密
     * @param content 需要加密的内容
     * @return
     */
    public static String publicEncrypt(String content) {
        Cipher cipher = null;
        try {
            cipher = Cipher.getInstance(RSA);
            RSAPublicKey publicKey = getPublicKey(publicKeyString);
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, content.getBytes(CHARSET), publicKey.getModulus().bitLength()));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 私钥解密
     * @param content 需要解密的内容
     * @return
     */
    public static String privateDecrypt(String content) {
        try {
            Cipher cipher = Cipher.getInstance(RSA);
            RSAPrivateKey privateKey = getPrivateKey(privateKeyString);
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(content), privateKey.getModulus().bitLength()), CHARSET);
        } catch (Exception e) {
            throw new RuntimeException("解密字符串[" + content + "]时遇到异常", e);
        }
    }

    /**
     * 私钥加密
     * @param content 需要加密的内容
     */
    public static String privateEncrypt(String content) {
        try {
            Cipher cipher = Cipher.getInstance(RSA);
            RSAPrivateKey privateKey = getPrivateKey(privateKeyString);
            cipher.init(Cipher.ENCRYPT_MODE, privateKey);
            return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, content.getBytes(CHARSET), privateKey.getModulus().bitLength()));
        } catch (Exception e) {
            throw new RuntimeException("加密字符串[" + content + "]时遇到异常", e);
        }
    }

    /**
     * 公钥解密
     * @param content 需要解密的内容
     * @return
     */
    public static String publicDecrypt(String content) {
        try {
            Cipher cipher = Cipher.getInstance(RSA);
            RSAPublicKey publicKey = getPublicKey(publicKeyString);
            cipher.init(Cipher.DECRYPT_MODE, publicKey);
            return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(content), publicKey.getModulus().bitLength()), CHARSET);
        } catch (Exception e) {
            throw new RuntimeException("解密字符串[" + content + "]时遇到异常", e);
        }
    }

    /**
     * 长度为keySize的密钥
     *
     * @param keySize
     * @return
     */
    private static Map<String, String> createKeys(int keySize) {
        //为RSA算法创建一个KeyPairGenerator对象
        KeyPairGenerator kpg;
        try {
            kpg = KeyPairGenerator.getInstance(RSA);
        } catch (NoSuchAlgorithmException e) {
            throw new IllegalArgumentException("No such algorithm-->[" + RSA + "]");
        }

        //初始化KeyPairGenerator对象,密钥长度
        kpg.initialize(keySize);
        //生成密匙对
        KeyPair keyPair = kpg.generateKeyPair();
        //得到公钥
        Key publicKey = keyPair.getPublic();
        String publicKeyStr = Base64.encodeBase64URLSafeString(publicKey.getEncoded());
        //得到私钥
        Key privateKey = keyPair.getPrivate();
        String privateKeyStr = Base64.encodeBase64URLSafeString(privateKey.getEncoded());
        Map<String, String> keyPairMap = new HashMap<String, String>();
        keyPairMap.put("publicKey", publicKeyStr);
        keyPairMap.put("privateKey", privateKeyStr);

        return keyPairMap;
    }

    /**
     * 得到公钥
     *
     * @param publicKey 密钥字符串（经过base64编码）
     * @throws Exception
     */
    private static RSAPublicKey getPublicKey(String publicKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
        //通过X509编码的Key指令获得公钥对象
        KeyFactory keyFactory = KeyFactory.getInstance(RSA);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKey));
        RSAPublicKey key = (RSAPublicKey) keyFactory.generatePublic(x509KeySpec);
        return key;
    }

    /**
     * 得到私钥
     *
     * @param privateKey 密钥字符串（经过base64编码）
     * @throws Exception
     */
    private static RSAPrivateKey getPrivateKey(String privateKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
        //通过PKCS#8编码的Key指令获得私钥对象
        KeyFactory keyFactory = KeyFactory.getInstance(RSA);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKey));
        RSAPrivateKey key = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8KeySpec);
        return key;
    }

    private static byte[] rsaSplitCodec(Cipher cipher, int opmode, byte[] datas, int keySize) {
        int maxBlock = 0;
        if (opmode == Cipher.DECRYPT_MODE) {
            maxBlock = keySize / 8;
        } else {
            maxBlock = keySize / 8 - 11;
        }
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] buff;
        int i = 0;
        try {
            while (datas.length > offSet) {
                if (datas.length - offSet > maxBlock) {
                    buff = cipher.doFinal(datas, offSet, maxBlock);
                } else {
                    buff = cipher.doFinal(datas, offSet, datas.length - offSet);
                }
                out.write(buff, 0, buff.length);
                i++;
                offSet = i * maxBlock;
            }
        } catch (Exception e) {
            throw new RuntimeException("加解密阀值为[" + maxBlock + "]的数据时发生异常", e);
        }
        byte[] resultDatas = out.toByteArray();
        try {
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return resultDatas;
    }


}

 

jar包依赖：

<!-- https://mvnrepository.com/artifact/commons-codec/commons-codec -->
<dependency>
  <groupId>commons-codec</groupId>
  <artifactId>commons-codec</artifactId>
  <version>1.10</version>
</dependency>

 

 

qmdluck
关注
专栏目录
RSA 公钥加密-私钥解密
06-14
RSA 公钥加密-私钥解密 博客地址 http://www.cnblogs.com/zyw-205520/p/5585043.html
RSA生成密钥对、公钥加密和私钥解密
05-29
支持最大2048位RSA计算，主要是生成公私钥对、公钥加密、私钥解密功能。每次重新生成公私钥对，随机产生一定长度的随机数作为输入数据，公钥加密后再私钥解密。每一项结果都清晰打印。
RSA 公钥加密——私钥解密
weixin_33801856的博客
06-14 417
    作者：刘巍然-学酥链接：http://www.zhihu.com/question/25912483/answer/31653639来源：知乎著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 我们来回顾一下RSA的加密算法。我们从公钥加密算法和签名算法的定义出发，用比较规范的语言来描述这一算法。 RSA公钥加密体制包含如下3个算法：KeyGen（密钥生成算法），...
【加密算法基础——RSA 加密】
XWWW668899的博客
09-15 1564
RSA（Rivest-Shamir-Adleman）加密是非对称加密，一种广泛使用的公钥加密算法，主要用于安全数据传输。公钥用于加密，私钥用于解密。
rsa公钥和私钥到底哪个才是用来加密，哪个用来解密？
极客神殿
07-19 780
公钥和私钥在一些银行系统、第三方支付系统SDK中经常会遇到，刚接触公钥私钥的朋友们估计很难区分两者的区别。
RSA不对称加密，公钥加密私钥解密，私钥加密公钥解密
蛰伏--当你不够强大时，就不要放弃努力
04-24 952
RSA算法是第一个能同时用于加密和数字签名的算法，也易于理解和操作。 RSA是被研究得最广泛的公钥算法，从提出到现在已近二十年，经历了各种攻击的考验，逐渐为人们接受，普遍认为是目前最优秀的公钥方案之一。RSA的安全性依赖于大数的因子分解，但并没有从理论上证明破译RSA的难度与大数分解难度等价。 .NET提供常用的加密算法类，支持RSA的类是RSACryptoServiceProvider
C# .net版 RSA 公钥加密私钥解密 私钥加密公钥解密
02-15
本教程主要讲解如何在C# .NET环境中使用RSA进行公钥加密和私钥解密，以及私钥加密和公钥解密的操作。 首先，让我们了解RSA的基本原理。RSA算法基于两个大素数的乘积，这个乘积作为公钥，而这两个大素数作为私钥。...
C# RSA 公钥加密，私钥解密
04-20
总结来说，C#中的RSA公钥加密和私钥解密是通过RSACryptoServiceProvider类实现的，它为开发者提供了加密和解密的便捷接口。在VS2017这样的开发环境中，我们可以方便地构建这样的系统，确保数据在传输过程中的安全。
基于JavaScript的RSA公钥加密、私钥解密库
最新发布
10-07
【作品名称】：基于JavaScript的RSA公钥加密、私钥解密库 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】：为了更加...
C# RSA 公钥加密，私钥解密(.net core) 源码 CCCRSAGYJMSYJMNETCORE.rar
01-26
C# RSA 公钥加密，私钥解密(.net core) 源码 一、源码描述 C# RSA 公钥加密，私钥解密,与大家分享，开发工具是VS2017. 二、功能介绍 C# RSA 公钥加密，私钥解密,与大家分享，开发工具是VS2017 请先输入要...
RSA双向加解密（公钥加密-私钥解密；私钥加密-公钥解密）
qq_42014561的博客
12-20 1万+
RSA私钥加密-公钥解密
RSA加密 私钥加密公钥解密
01-18
此包内包含云端和客户端。实现RSA私钥加密，公钥解密，保证了可现实加密和解密使用不同的字符串。
公钥加密私钥解密&私钥加密公钥解密
07-16
先明确一下概念： 公钥加密私钥解密，也可以说是 "公共密钥加密系统 " 私钥加密公钥解密,一般不这么说，应叫 "私钥签名,公钥验证 ",也可以说是“公共密钥签名系统” 再来说一下 "公共密钥签名系统 "目的:(如果晕就多看几遍，这个没搞清，后面的代码就更晕)
Rsa 私钥加密 公钥解密
04-25
用于私钥加密 公钥解密用于私钥加密 公钥解密用于私钥加密 公钥解密
RSA公钥加密私钥解密
weixin_30348519的博客
08-29 456
公司的项目需要电科院测评，必须保证数据的完整性和保密性，为这两个特性不得不搞个RSA+SHA1加密。 页面处理过程： 每次登录前，先向后端发送请求，由RSA生成一对公钥和私钥，获取公钥中的模modulus和指数exponent，然后传到前端，私钥存入当前请求的session中。前端使用security.js先根据后传过来模和指数生成公钥，然后用公钥加密密码。 对加密后的数据进行SH...
RSA的公钥和私钥到底哪个才是用来加密和哪个用来解密？
weixin_30802171的博客
07-04 2611
来自知乎提问https://www.zhihu.com/question/25912483 匿名用户 不要去硬记。你只要想：既然是加密，那肯定是不希望别人知道我的消息，所以只有我才能解密，所以可得出公钥负责加密，私钥负责解密；同理，既然是签名，那肯定是不希望有人冒充我发消息，只有我才能发布这个签名，所以可得出私钥负责签名，公钥负责验证。 ...
非对称加解密，私钥和公钥到底是谁来加密，谁来解密
热门推荐
全冉 的博客
06-07 6万+
第一种用法：公钥加密，私钥解密。---用于加解密 第二种用法：私钥签名，公钥验签。---用于签名 有点混乱，不要去硬记，总结一下: 你只要想： 既然是加密，那肯定是不希望别人知道我的消息，所以只有我才能解密，所以可得出公钥负责加密，私钥负责解密； 既然是签名，那肯定是不希望有人冒充我发消息，只有我才能发布这个签名，所以可得出私钥负责签名，公钥负责验证。 同一种道理，我在换种说法： 私钥和公钥是一对...
公钥、私钥、加密、解密
caoniuniu25的专栏
03-30 5076
第一种用法：公钥加密，私钥解密。---用于加解密 第二种用法：私钥签名，公钥验签。---用于签名 有点混乱，不要去硬记，总结一下: 你只要想： 既然是加密，那肯定是不希望别人知道我的消息，所以只有我才能解密，所以可得出公钥负责加密，私钥负责解密； 既然是签名，那肯定是不希望有人冒充我发消息，只有我才能发布这个签名，所以可得出私钥负责签名，公钥负责验证。 同一种道理，我在换种说法： 私钥和公钥是...
hutool工具的rsa公钥加密和私钥解密
05-31
好的，我来为您讲解一下hutool工具的rsa公钥加密和私钥解密的方法。 首先，您需要导入hutool工具包，并且生成RSA公私钥对，可以使用下面的代码： ```java // 生成RSA公私钥对 KeyPair keyPair = SecureUtil.generateKeyPair("RSA"); RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic(); RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate(); // 获取公私钥的Base64编码 String publicKeyStr = Base64.encode(publicKey.getEncoded()); String privateKeyStr = Base64.encode(privateKey.getEncoded()); ``` 接下来，使用公钥进行加密，可以使用下面的代码： ```java // 使用公钥进行加密 String plainText = "Hello, world!"; byte[] encryptedBytes = SecureUtil.rsa(publicKey.getModulus().toString(16), publicKey.getPublicExponent().toString(16)).encrypt(plainText.getBytes(), KeyType.PublicKey); String encryptedStr = Base64.encode(encryptedBytes); ``` 最后，使用私钥进行解密，可以使用下面的代码： ```java // 使用私钥进行解密 byte[] decryptedBytes = SecureUtil.rsa(privateKey.getModulus().toString(16), privateKey.getPrivateExponent().toString(16)).decrypt(Base64.decode(encryptedStr), KeyType.PrivateKey); String decryptedStr = new String(decryptedBytes); ``` 以上就是使用hutool工具进行RSA公钥加密和私钥解密的方法，希望能对您有所帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值