RSA非对称加密

小百菜

已于 2023-07-18 10:49:28 修改

阅读量1.9k

点赞数

分类专栏：加密文章标签： java RSA

于 2023-01-31 02:09:54 首次发布

原文链接：https://mp.csdn.net/mp_blog/creation/editor?not_checkout=1

版权

加密专栏收录该内容

2 篇文章 0 订阅

订阅专栏

不可逆性算法：加密后的结果，不可逆向算出明文。如md5，加密结果固定，不安全，弱密码可以通过穷举法反推出明文。
对称加密算法：加密和解密使用同一个密码。如AES，加密结果固定。
非对加密算法：加密和解密使用不同的密码。如RSA，每次加密结果是不同的。

根据已经披露的文献，目前被破解的最长RSA密钥是768个二进制位。也就是说，长度超过768位的密钥，还无法破解（至少没人公开宣布）。
因此可以认为，1024位的RSA密钥基本安全，2048位的密钥极其安全。

公钥和私钥是成对的，公钥加密要用私钥解密，私钥加密要用公钥解密。每次加密结果是变化的。
1、公钥加密，私钥解密用于信息加密。
2、私钥加密，公钥解密。
3、私钥签名，公钥验证。在https中公钥任何人都有，用私钥加密意义不大，还不如使用签名。
签名实际上是对明文的摘要做了加密。收到的人会收到明文和签名，利用公钥可以进行验证真伪，数字签名保证信息是服务端发的，并且没有遭到篡改。
前面两点是加密，后面一点是认证。两者的侧重点是不同的。后面一点鉴别服务端的真伪

package com.study;


import com.sun.org.slf4j.internal.Logger;
import com.sun.org.slf4j.internal.LoggerFactory;

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.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

/**
 * 公钥和私钥是成对的，公钥加密要用私钥解密，私钥加密要用公钥解密。每次加密结果是变化的。
 * 1、公钥加密，私钥解密用于信息加密。
 * 2、私钥加密，公钥解密。
 * 3、私钥签名，公钥验证。在https中公钥任何人都有，用私钥加密意义不大，还不如使用签名。
 * 签名实际上是对明文的摘要做了加密。收到的人会收到明文和签名，利用公钥可以进行验证真伪，数字签名保证信息是服务端发的，并且没有遭到篡改。
 * 前面两点是加密，后面一点是认证。两者的侧重点是不同的。后面一点鉴别服务端的真伪
 * @date:2018年10月31日 上午11:15:13
 */
public class RSAUtil {
    private static final Logger logger = LoggerFactory.getLogger(RSAUtil.class);
    //定义加密方式
    public static final String KEY_RSA = "RSA";
    //定义签名算法
    private final static String KEY_RSA_SIGNATURE = "MD5withRSA";
    //公钥
    public final static String publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCjCReEky22QiNbadrYAO0Rz9aIUAmkVyeuemmwu0KDohsA+GlZB96bW4Q+8AYPsAiPfJYHyQPTofTITh7374XzTv2xZBicXFaUfiXbFo8SnBLXYO/Jjp1zrbxiFtgVLf1cUp76pBVUJCSc0A0URQVuijpT1HlyAEqG+5xxxconhwIDAQAB";
    //私钥
    public final static String privateKey = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAKMJF4STLbZCI1tp2tgA7RHP1ohQCaRXJ656abC7QoOiGwD4aVkH3ptbhD7wBg+wCI98lgfJA9Oh9MhOHvfvhfNO/bFkGJxcVpR+JdsWjxKcEtdg78mOnXOtvGIW2BUt/VxSnvqkFVQkJJzQDRRFBW6KOlPUeXIASob7nHHFyieHAgMBAAECgYAhNUfiDCyCdERJaW1XFBE10JTNHShpngsKIgsHIY1xzIIdl3u108GG+YQdYbyKU3va5jCVE1/BKrr2Vds++z3YNpeaAFI6SOxk26huYUQCyqcXT5PoyWEvE6HvbJdYHXJLtmXX0GpXjS2CBSvgiSLe1NtEP24lXYlUVyIASi7xQQJBAOUenOh2LhI4zeRGotxQomP/nhMENEOVk4cWLF3mLQqhYSXThz27xu2ZkseWJ2kNAzBdarsDi61AGaEuUelFc2ECQQC2KbUTl6Q2shk3cpkFofL6OuIv/8oLdUFOutzmyJXBeDn8r96YzX/MTH9nwmTo8hxOhvSED372w73LObk4VevnAkEAgv8Tux0GjkiH/0Ibj1dS4VWerUS0FQgKByw4RZ96lR9bieL86eDYhbROZWqGMdvMvPRMN4x5aZ7CiJMRJgwdQQJARLobnVa7F/+9z9OmtB9T4uDQcbeZ7RTCHQgXS+MlzSalChb4bsIpk1TRRL5tAA5Ia8AzBJgsGMHlG4Wdwgl4xQJALCh/8VsI/YUSYoLOc/jg/X19FIES8P+6+81h4KsBhrD6gIVIFtuWf4cQzQkncjsny3/GuEx0JAGSmnnWqLsR1w==";


    public static void main(String[] args) {
        //生成新的公私密钥对
        init();

        String str = "你好, RSA!";
        // 公钥加密，私钥解密
        String enStr1 = RSAUtil.encryptByPublic(str, publicKey);
        System.out.println("公钥加密后：" + enStr1);
        String deStr1 = RSAUtil.decryptByPrivate(enStr1, privateKey);
        System.out.println("私钥解密后：" + deStr1);

        // 私钥加密，公钥解密
        String enStr2 = RSAUtil.encryptByPrivate(str, privateKey);
        System.out.println("私钥加密后：" + enStr2);
        String deStr2 = RSAUtil.decryptByPublic(enStr2, publicKey);
        System.out.println("公钥解密后：" + deStr2);

        // 产生签名
        String sign = sign(enStr2, privateKey);
        System.out.println("签名:" + sign);
        // 验证签名 
        boolean status = verify(enStr2, publicKey, sign);
        System.out.println("验证签名状态:" + status);

    }

    /**
     * 生成公私密钥对
     * @date:2018年10月31日 上午11:16:41
     */
    public static void init() {
        try {
            KeyPairGenerator generator = KeyPairGenerator.getInstance(KEY_RSA);
            //设置密钥对的bit数，越大越安全，但速度减慢，一般使用512或1024
            generator.initialize(1024);
            KeyPair keyPair = generator.generateKeyPair();
            // 获取公钥  
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
            // 获取私钥  
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            // Base64编码的公钥字符串
            String publicKeyStr = encryptBase64(publicKey.getEncoded());
            //Base64编码的私钥字符串
            String privateKeyStr = encryptBase64(privateKey.getEncoded());
            // 打印密钥对
            System.out.println("publicKey=" + publicKeyStr);
            System.out.println("privateKey=" + privateKeyStr);
        } catch (NoSuchAlgorithmException e) {
            logger.error(e.getMessage(), e);
        }
    }

    /**
     * BASE64 解码
     * @param key 需要Base64解码的字符串
     * @date:2018年10月31日 上午11:17:46
     */
    public static byte[] decryptBase64(String key) {
        return Base64.getDecoder().decode(key);
    }

    /**
     * BASE64 编码
     * @param key 需要Base64编码的字节数组
     * @date:2018年10月31日 上午11:18:03
     */
    public static String encryptBase64(byte[] key) {
        return new String(Base64.getEncoder().encode(key));
    }

    /**
     * 公钥加密
     * @param encryptingStr 字符串
     * @param publicKeyStr  公钥
     * @date:2018年10月31日 上午11:18:17
     */
    public static String encryptByPublic(String encryptingStr, String publicKeyStr) {
        try {
            // 将公钥由字符串转为UTF-8格式的字节数组
            byte[] publicKeyBytes = decryptBase64(publicKeyStr);
            // 获得公钥  
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
            // 取得待加密数据
            byte[] data = encryptingStr.getBytes(StandardCharsets.UTF_8);
            KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
            PublicKey publicKey = factory.generatePublic(keySpec);
            // 对数据加密  
            Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            // 返回加密后由Base64编码的加密信息
            return encryptBase64(cipher.doFinal(data));
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    /**
     * 私钥解密
     * @param encryptedStr  字符串
     * @param privateKeyStr 私钥
     * @date:2018年10月31日 上午11:18:36
     */
    public static String decryptByPrivate(String encryptedStr, String privateKeyStr) {
        try {
            // 对私钥解密  
            byte[] privateKeyBytes = decryptBase64(privateKeyStr);
            // 获得私钥 
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
            // 获得待解密数据
            byte[] data = decryptBase64(encryptedStr);
            KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
            PrivateKey privateKey = factory.generatePrivate(keySpec);
            // 对数据解密
            Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            // 返回UTF-8编码的解密信息
            return new String(cipher.doFinal(data), StandardCharsets.UTF_8);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    /**
     * 私钥加密
     * @param encryptingStr 字符串
     * @param privateKeyStr 私钥
     * @date:2018年10月31日 上午11:18:57
     */
    public static String encryptByPrivate(String encryptingStr, String privateKeyStr) {
        try {
            byte[] privateKeyBytes = decryptBase64(privateKeyStr);
            // 获得私钥  
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
            // 取得待加密数据
            byte[] data = encryptingStr.getBytes(StandardCharsets.UTF_8);
            KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
            PrivateKey privateKey = factory.generatePrivate(keySpec);
            // 对数据加密 
            Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, privateKey);
            // 返回加密后由Base64编码的加密信息
            return encryptBase64(cipher.doFinal(data));
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    /**
     * 公钥解密
     * @param encryptedStr 字符串
     * @param publicKeyStr 公钥
     * @date:2018年10月31日 上午11:19:07
     */
    public static String decryptByPublic(String encryptedStr, String publicKeyStr) {
        try {
            // 对公钥解密  
            byte[] publicKeyBytes = decryptBase64(publicKeyStr);
            // 取得公钥  
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
            // 取得待加密数据
            byte[] data = decryptBase64(encryptedStr);
            KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
            PublicKey publicKey = factory.generatePublic(keySpec);
            // 对数据解密  
            Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, publicKey);
            // 返回UTF-8编码的解密信息
            return new String(cipher.doFinal(data), StandardCharsets.UTF_8);
        } catch (Exception e) {
            e.printStackTrace();
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    /**
     * 用私钥对私钥加密数据进行签名
     * @param encryptedStr 私钥加密后的字符串
     * @param privateKey   私钥
     * @date:2018年10月31日 上午11:19:37
     */
    public static String sign(String encryptedStr, String privateKey) {
        String str = "";
        try {
            //将私钥加密数据字符串转换为字节数组
            byte[] data = encryptedStr.getBytes(StandardCharsets.UTF_8);
            // 解密由base64编码的私钥  
            byte[] bytes = decryptBase64(privateKey);
            // 构造PKCS8EncodedKeySpec对象  
            PKCS8EncodedKeySpec pkcs = new PKCS8EncodedKeySpec(bytes);
            // 指定的加密算法  
            KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
            // 取私钥对象  
            PrivateKey key = factory.generatePrivate(pkcs);
            // 用私钥对信息生成数字签名  
            Signature signature = Signature.getInstance(KEY_RSA_SIGNATURE);
            signature.initSign(key);
            signature.update(data);
            str = encryptBase64(signature.sign());
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return str;
    }

    /**
     * 校验数字签名
     * @param encryptedStr 私钥加密后的字符串
     * @param publicKey    公钥
     * @param sign         签名
     * @date:2018年10月31日 上午11:19:50
     */
    public static boolean verify(String encryptedStr, String publicKey, String sign) {
        try {
            //将私钥加密数据字符串转换为字节数组
            byte[] data = encryptedStr.getBytes(StandardCharsets.UTF_8);
            // 解密由base64编码的公钥  
            byte[] bytes = decryptBase64(publicKey);
            // 构造X509EncodedKeySpec对象  
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes);
            // 指定的加密算法  
            KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
            // 取公钥对象  
            PublicKey key = factory.generatePublic(keySpec);
            // 用公钥验证数字签名  
            Signature signature = Signature.getInstance(KEY_RSA_SIGNATURE);
            signature.initVerify(key);
            signature.update(data);
            return signature.verify(decryptBase64(sign));
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return false;
    }
}