RSA非对称密钥加密解密签名验签

最新推荐文章于 2024-04-09 14:11:25 发布
最新推荐文章于 2024-04-09 14:11:25 发布
阅读量487 收藏
点赞数
分类专栏： 加密

转：https://www.cnblogs.com/zhujiabin/p/7118126.html

 

import org.springframework.util.Base64Utils;

import java.io.ByteArrayOutputStream;
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.Signature;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;

/** */
/**
 * <p>
 * RSA公钥/私钥/签名工具包
 * </p>
 * <p>
 * 罗纳德·李维斯特（Ron [R]ivest）、阿迪·萨莫尔（Adi [S]hamir）和伦纳德·阿德曼（Leonard [A]dleman）
 * </p>
 * <p>
 * 字符串格式的密钥在未在特殊说明情况下都为BASE64编码格式<br/>
 * 由于非对称加密速度极其缓慢，一般文件不使用它来加密而是使用对称加密，<br/>
 * 非对称加密算法可以用来对对称加密的密钥加密，这样保证密钥的安全也就保证了数据的安全
 * </p>
 * 
 * @author IceWee
 * @date 2012-4-26
 * @version 1.0
 */
public class RSAUtils {

    /** */
    /**
     * 加密算法RSA
     */
    public static final String KEY_ALGORITHM = "RSA";

    /** */
    /**
     * 签名算法
     */
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

    /** */
    /**
     * 获取公钥的key
     */
    private static final String PUBLIC_KEY = "RSAPublicKey";

    /** */
    /**
     * 获取私钥的key
     */
    private static final String PRIVATE_KEY = "RSAPrivateKey";

    /** */
    /**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 117;

    /** */
    /**
     * RSA最大解密密文大小
     */
    private static final int MAX_DECRYPT_BLOCK = 128;

    /** */
    /**
     * <p>
     * 生成密钥对(公钥和私钥)
     * </p>
     * 
     * @return
     * @throws Exception
     */
    public static Map<String, Object> genKeyPair() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(1024);
        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        Map<String, Object> keyMap = new HashMap<String, Object>(2);
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }

    /** */
    /**
     * <p>
     * 用私钥对信息生成数字签名
     * </p>
     * 
     * @param data
     *            已加密数据
     * @param privateKey
     *            私钥(BASE64编码)
     * 
     * @return
     * @throws Exception
     */
    public static String sign(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey.getBytes());
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(privateK);
        signature.update(data);
        byte[]arr= Base64Utils.encode(signature.sign());
        return new String(arr);
    }

    /** */
    /**
     * <p>
     * 校验数字签名
     * </p>
     * 
     * @param data
     *            已加密数据
     * @param publicKey
     *            公钥(BASE64编码)
     * @param sign
     *            数字签名
     * 
     * @return
     * @throws Exception
     * 
     */
    public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey.getBytes());
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PublicKey publicK = keyFactory.generatePublic(keySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(publicK);
        signature.update(data);
        return signature.verify(Base64Utils.decode(sign.getBytes()));
    }

    /** */
    /**
     * <P>
     * 私钥解密
     * </p>
     * 
     * @param encryptedData
     *            已加密数据
     * @param privateKey
     *            私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey.getBytes());
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }

    /** */
    /**
     * <p>
     * 公钥解密
     * </p>
     * 
     * @param encryptedData
     *            已加密数据
     * @param publicKey
     *            公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey.getBytes());
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, publicK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }

    /** */
    /**
     * <p>
     * 公钥加密
     * </p>
     * 
     * @param data
     *            源数据
     * @param publicKey
     *            公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey.getBytes());
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }

    /** */
    /**
     * <p>
     * 私钥加密
     * </p>
     * 
     * @param data
     *            源数据
     * @param privateKey
     *            私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey.getBytes());
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }

    /** */
    /**
     * <p>
     * 获取私钥
     * </p>
     * 
     * @param keyMap
     *            密钥对
     * @return
     * @throws Exception
     */
    public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        byte[]arr = Base64Utils.encode(key.getEncoded());
        return new String(arr);
    }

    /** */
    /**
     * <p>
     * 获取公钥
     * </p>
     * 
     * @param keyMap
     *            密钥对
     * @return
     * @throws Exception
     */
    public static String getPublicKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        byte[]arr = Base64Utils.encode(key.getEncoded());
        return new String(arr);
    }

    /**
     * java端公钥加密
     */
    public static String encryptedDataOnJava(String data, String PUBLICKEY) {
        try {
            byte[]arr = Base64Utils.encode(encryptByPublicKey(data.getBytes(), PUBLICKEY));
            return new String(arr);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return data;
    }

    /**
     * java端私钥解密
     */
    public static String decryptDataOnJava(String data, String PRIVATEKEY) {
        String temp = "";
        try {
            byte[] rs = Base64Utils.decode(data.getBytes());
            temp = new String(RSAUtils.decryptByPrivateKey(rs, PRIVATEKEY),"UTF-8"); //以utf-8的方式生成字符串

        } catch (Exception e) {
            e.printStackTrace();
        }
        return temp;
    }

    static String publicKey;
    static String privateKey;

    public static void main(String[] args) throws Exception{
        Map<String, Object> keyMap = RSAUtils.genKeyPair();
        publicKey = RSAUtils.getPublicKey(keyMap);
        privateKey = RSAUtils.getPrivateKey(keyMap);

        privateToPublic();
//        publicToPrivate();
    }
    static void privateToPublic() throws Exception {
        System.err.println("私钥加密——公钥解密");
        String source = "123456";
        System.out.println("原文字：" + source);
        byte[] data = source.getBytes();
        byte[] encodedData = RSAUtils.encryptByPrivateKey(data, privateKey);
        System.out.println("加密后：" + new String(encodedData));
        byte[] decodedData = RSAUtils.decryptByPublicKey(encodedData, publicKey);
        String target = new String(decodedData);
        System.out.println("解密后: " + target);
        System.err.println("私钥签名——公钥验证签名");
        String sign = RSAUtils.sign(encodedData, privateKey);
        System.err.println("签名:" + sign);
        boolean status = RSAUtils.verify(encodedData, publicKey, sign);
        System.err.println("验证结果:" + status);
    }

    static void publicToPrivate() throws Exception {
        System.err.println("公钥加密——私钥解密");
        String source = "567890";
        System.out.println("加密前文字：" + source);
        byte[] data = source.getBytes();
        byte[] encodedData = RSAUtils.encryptByPublicKey(data, publicKey);
        System.out.println("加密后文字：" + new String(encodedData));
        System.out.println("----------------:base64处理：" + Base64Utils.encode(encodedData));
        byte[] decodedData = RSAUtils.decryptByPrivateKey(encodedData, privateKey);
        String target = new String(decodedData);
        System.out.println("解密后文字: " + target);
    }

}
梅八哥
关注
专栏目录
非对称加密算法 - RSA签名&验签授权
寻找小小的博客
12-27 3295
非对称加密算法 - RSA签名&验签授权
RSA非对称加密/解密和签名/验签
P.L.C的博客
02-19 2894
对称和非对称加密 1.什么是对称加密技术？ 对称加密采用了对称密码编码技术，它的特点是文件加密和解密使用相同的密钥加密。 也就是密钥也可以用作解密密钥，这种方法在密码学中叫做对称加密算法，对称加密算法使用起来简单快捷，密钥较短，且破译困难，除了数据加密标准（DES），另一个对称密钥加密系统是国际数据加密算法（IDEA），它比DES的加密性好，而且对计算机功能要求也没有那么高。 对称加密算法在电子商务交易过程中存在几个问题： 1、要求提供一条安全的渠道使通讯双方在首次通讯时协商一个共同的密钥。直接的面对面协商
Java 实现RSA非对称加密算法的签名与验签
qq_42972134的博客
06-28 672
1.RAS简介 RSA加密是非对称加密，由一对秘钥进行完成加密解密，分别称为公钥和私钥，公钥加密，私钥解密，RSA可以完成加密和签名； 2.加密与签名的区别 加密是为了防止信息被泄露，签名是为了防止信息被篡改； 3.RSA加密过程 假如B要发消息给A，首先A在本地生产一对秘钥，公钥和私钥，并将公钥发送给B，B使用公钥对消息进行加密，然后传输给A，A接收到消息后在本地使用私钥解密； 缺点：这种加密过程保证了消息不被泄露，但是避免不了消息被篡改，假如B发送给A的消息被黑客劫持，他通过公钥，自己伪造一条消息，通过
Java 实现 RSA 非对称加密算法-加解密和签名验签
迪曼奥特迦-博客
06-12 1363
1.非对称加密算法简介 非对称加密算法又称现代加密算法，是计算机通信安全的基石，保证了加密数据不会被破解。与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥（publickey）和私有密（privatekey），因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。公钥和私钥是一对，如果用公钥对数据进行加密，只有用对应的私钥才能解密。常见算法：RSA、ECC。 RSA 加密算法是一种非对称加密算法，即 RSA 拥有一对密钥（公钥 和 私钥），公钥可公开。公钥加密的数据，只能由私钥.
非对称加密解密
andy_5555的博客
09-11 481
一. 加密代码 #私钥加密 公钥解密import rsa import base64 # #生成公钥私钥 pub_key_obj, priv_key_obj = rsa.newkeys(1024) pub_key_str = pub_key_obj.save_pkcs1() pub_key_code = base64.standard_b64encode(pu...
非对称加密算法/数字签名算法——RSA
Evan's learning log
08-25 2332
接下来我们介绍典型的非对称加密算法/数字签名算法——RSA  RSA      这种算法1978年就出现了，它是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作，也很流行。算法的名字以发明者的名字命名：Ron Rivest, AdiShamir 和Leonard Adleman。      这种加密算法的特点主要是密钥的变化，上文我们看到DES只有一个密钥。相当于只有一把钥
C# RSA读取密钥文件pfx cer 签名验签加密解密帮助类
09-25
C#作为.NET框架的主要编程语言，提供了丰富的库来支持加密和签名操作，其中RSA算法是一种广泛应用的非对称加密技术。本篇文章将深入探讨如何在C#中使用RSA算法处理pfx和cer密钥文件，进行签名验证、加密和解密，并...
Delphi RSA 加密解密签名验签控件 RSA_Component(1.0.0.0).rar
12-13
在公开密钥加密和电子商业中RSA被广泛使用。 典型的应用 1. 苹果App签名, iOS App 签名的原理; 2. 支付宝签名验证 ; 2. HTTPS 加密连接; 3. 程序直接用RSA+AES加密通信 ; 如：利用OpenSSL库对Socket传输进行...
RSA签名验签工具windows_V1.4.zip_rsa_rsa2生成签名_rsa签名工具_工具_验签
09-19
RSA是一种非对称加密算法，由Ron Rivest、Adi Shamir和Leonard Adleman在1977年提出，因此得名。该算法基于大整数因子分解的难度，即RSA难题。RSA算法有两个密钥：公钥和私钥。公钥可以公开，用于加密信息；而私钥...
C++使用Openssl进行RSA加密解密及签名验签功能（SHA256）
09-19
RSA是一种广泛使用的公钥加密算法，它结合了非对称加密和数字签名技术，确保数据的机密性和完整性。本文将深入探讨如何使用OpenSSL库在C++中实现RSA加密、解密以及签名和验签功能，特别关注SHA256WithRSA这一安全...
RSA非对称加密验签参考demo
12-10
RSA非对称加密 通过私钥加密，公钥解密来实现数据的安全交互。公钥私钥存放在单独的文本中，自己替换即可。
RSA 非对称加密/解密/签名
何惜戈
03-28 1376
RSA 是一种非对称加密算法，可以对交互的数据进行加密和加签。 非对称加密算法需要两个密钥：公开密钥（publickey）和私有密钥（privatekey）。 公开密钥与私有密钥是一对，如果用私有密钥对数据进行加签，只有用对应的公开密钥才能验签；如果用公开密钥对数据进行加密，那么只有用对应的私有密钥才能解密。 如何生成公私钥？ 通过openssl工具生成RSA的公钥和私钥(...
安全：非对称秘钥加密及签名原理
IamOceanKing的博客
12-20 977
数字证书的简单介绍
网络安全 - 对称密钥 非对称密钥 数字信封以及数字签名(笔记+图解)_对称密钥数字信封
最新发布
2401_84139728的博客
04-09 498
5、乙使用对称密钥再对密文信息进行解密，得到最原始的明文信息优点：很好的规避了对称密钥和非对称密钥的加密数据时的缺点(在保证安全性的前提下，又提升加解密的数据)缺点：无法证伪。
RSA非对称加密解密与加签验签
weixin_41325595的博客
12-24 371
package com.test.testSign; import java.io.ByteArrayOutputStream; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.PrivateKey;...
Java中RSA非对称密钥加解密使用示例
huozhicheng的专栏
09-06 6759
一、简介： RSA加密算法是最常用的非对称加密算法，CFCA在证书服务中离不了它。RSA是第一个比较完善的公开密钥算法，它既能用于加密，也能用于数字签名。这个算法经受住了多年深入的密码分析，虽然密码分析者既不能证明也不能否定RSA的安全性，但这恰恰说明该算法有一定的可信性，目前它已经成为最流行的公开密钥算法。 二、RSA的公钥、私钥的组成，以及加密、解密的公式可见于下表 三、使用方式
Java 实现 RSA 非对称加密算法的签名与验签
谢TS的博客
03-10 6340
RSA 非对称加密算法，除了用来加密/解密数据外，还可以用于对数据（文件）的签名和验签，可用于确认数据或文件的完整性与签名者（所有者）。私钥加密，公钥解密。私钥签名，公钥验签。
非对称加密的签名和验签、加密和解密的Java语言实现
jellyjiao2008的专栏
08-29 1049
本文采用java.security包的签名和验签。采用A的私钥签名发送至B，B采用A的公钥进行验签。 加解密可以私钥加密、公钥解密（或者公钥加密、私钥解密）。 一般用于银行报文传输、支付宝、微信、银行以及各大银行的数据交换。 package com.example.demo; import java.security.KeyPair; import java.security.KeyPa...
几个例子理解对称加密与非对称加密、公钥与私钥、签名与验签、数字证书、HTTPS加密方式
PanPa_WoNiu的博客
04-25 349
写的比较好的博客： https://www.cnblogs.com/chichung/p/10067336.html
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值