RSA 加密,解密,签名,验签总结

熊孩纸 阅读:238 2021-07-21 22:31:51 评论:0

  一、RSA加密简介

  RSA加密是一种非对称加密。可以在不直接传递密钥的情况下,完成解密。这能够确保信息的安全性,避免了直接传递密钥所造成的被破解的风险。

是由一对密钥来进行加解密的过程,分别称为公钥和私钥。两者之间有数学相关,该加密算法的原理就是对一极大整数做因数分解的困难性来保证安全性。

通常个人保存私钥,公钥是公开的(可能同时多人持有)。

  二.使用场景:

    加密和签名是两个不同的概念,又都涉及公钥和私钥的概念。

  公钥和私钥相当于钥匙和锁,锁可以用来锁住东西,钥匙可以用来打开对应的锁,一把钥匙只能开一把锁,当然钥匙和锁都可以复制。

    1.加密相当于我自己生成一把锁和一把钥匙,然后把锁发给你,你用我的锁把想发给我的东西锁上再发给我,我收到之后用钥匙打开锁。

  天下人都能拿到我的锁,但只有我有这把锁的钥匙。这个例子中,钥匙相当于私钥,锁相当于公钥。数字加密涉及三个过程:
    - 生成一对公钥和私钥
    - 加密:公钥+明文->密文
    - 解密:私钥+密文->明文

    2。签名 相当于我自己生成一把锁和一把钥匙,然后把我想发布的内容用我的锁锁起来形成一个签名,把内容和签名一起发布,并且告诉大家我的钥匙是什么。

  人们可以拿到钥匙来打开签名里的内容来验证是不是跟发布的内容一致。天下人都能拿到钥匙来验证签名与内容的一致性,但只有我有签名的锁。

这个例子中,钥匙相当于公钥,锁相当于私钥。数字签名涉及三个过程:
    - 生成一对公钥和私钥
    - 签名:私钥+内容->签名
    - 验证:公钥+签名+内容->内容有没有改变

  三。代码示例:

import java.io.ByteArrayOutputStream; 
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.spec.PKCS8EncodedKeySpec; 
import java.security.spec.X509EncodedKeySpec; 
import javax.crypto.Cipher; 
import org.apache.tomcat.util.codec.binary.Base64; 
 
public class TestRSA { 
 
    /** 
     * RSA最大加密明文大小 
     */ 
    private static final int MAX_ENCRYPT_BLOCK = 117; 
 
    /** 
     * RSA最大解密密文大小 
     */ 
    private static final int MAX_DECRYPT_BLOCK = 128; 
 
    /** 
     * 获取密钥对 
     * 
     * @return 密钥对 
     */ 
    public static KeyPair getKeyPair() throws Exception { 
        KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA"); 
        generator.initialize(1024); 
        return generator.generateKeyPair(); 
    } 
 
    /** 
     * 获取私钥 
     * 
     * @param privateKey 私钥字符串 
     * @return 
     */ 
    public static PrivateKey getPrivateKey(String privateKey) throws Exception { 
        KeyFactory keyFactory = KeyFactory.getInstance("RSA"); 
        byte[] decodedKey = Base64.decodeBase64(privateKey.getBytes()); 
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decodedKey); 
        return keyFactory.generatePrivate(keySpec); 
    } 
 
    /** 
     * 获取公钥 
     * 
     * @param publicKey 公钥字符串 
     * @return 
     */ 
    public static PublicKey getPublicKey(String publicKey) throws Exception { 
        KeyFactory keyFactory = KeyFactory.getInstance("RSA"); 
        byte[] decodedKey = Base64.decodeBase64(publicKey.getBytes()); 
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decodedKey); 
        return keyFactory.generatePublic(keySpec); 
    } 
 
    /** 
     * RSA加密 
     * 
     * @param data 待加密数据 
     * @param publicKey 公钥 
     * @return 
     */ 
    public static String encrypt(String data, PublicKey publicKey) throws Exception { 
        Cipher cipher = Cipher.getInstance("RSA"); 
        cipher.init(Cipher.ENCRYPT_MODE, publicKey); 
        int inputLen = data.getBytes().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.getBytes(), offset, MAX_ENCRYPT_BLOCK); 
            } else { 
                cache = cipher.doFinal(data.getBytes(), offset, inputLen - offset); 
            } 
            out.write(cache, 0, cache.length); 
            i++; 
            offset = i * MAX_ENCRYPT_BLOCK; 
        } 
        byte[] encryptedData = out.toByteArray(); 
        out.close(); 
        // 获取加密内容使用base64进行编码,并以UTF-8为标准转化成字符串 
        // 加密后的字符串 
        return new String(Base64.encodeBase64String(encryptedData)); 
    } 
 
    /** 
     * RSA解密 
     * 
     * @param data 待解密数据 
     * @param privateKey 私钥 
     * @return 
     */ 
    public static String decrypt(String data, PrivateKey privateKey) throws Exception { 
        Cipher cipher = Cipher.getInstance("RSA"); 
        cipher.init(Cipher.DECRYPT_MODE, privateKey); 
        byte[] dataBytes = Base64.decodeBase64(data); 
        int inputLen = dataBytes.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(dataBytes, offset, MAX_DECRYPT_BLOCK); 
            } else { 
                cache = cipher.doFinal(dataBytes, offset, inputLen - offset); 
            } 
            out.write(cache, 0, cache.length); 
            i++; 
            offset = i * MAX_DECRYPT_BLOCK; 
        } 
        byte[] decryptedData = out.toByteArray(); 
        out.close(); 
        // 解密后的内容 
        return new String(decryptedData, "UTF-8"); 
    } 
 
    /** 
     * 签名 
     * 
     * @param data 待签名数据 
     * @param privateKey 私钥 
     * @return 签名 
     */ 
    public static String sign(String data, PrivateKey privateKey) throws Exception { 
        byte[] keyBytes = privateKey.getEncoded(); 
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes); 
        KeyFactory keyFactory = KeyFactory.getInstance("RSA"); 
        PrivateKey key = keyFactory.generatePrivate(keySpec); 
        Signature signature = Signature.getInstance("MD5withRSA"); 
        signature.initSign(key); 
        signature.update(data.getBytes()); 
        return new String(Base64.encodeBase64(signature.sign())); 
    } 
 
    /** 
     * 验签 
     * 
     * @param srcData 原始字符串 
     * @param publicKey 公钥 
     * @param sign 签名 
     * @return 是否验签通过 
     */ 
    public static boolean verify(String srcData, PublicKey publicKey, String sign) throws Exception { 
        byte[] keyBytes = publicKey.getEncoded(); 
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes); 
        KeyFactory keyFactory = KeyFactory.getInstance("RSA"); 
        PublicKey key = keyFactory.generatePublic(keySpec); 
        Signature signature = Signature.getInstance("MD5withRSA"); 
        signature.initVerify(key); 
        signature.update(srcData.getBytes()); 
        return signature.verify(Base64.decodeBase64(sign.getBytes())); 
    } 
 
    public static void main(String[] args) { 
        try { 
            // 生成密钥对 
            KeyPair keyPair = getKeyPair(); 
            String privateKey = new String(Base64.encodeBase64(keyPair.getPrivate().getEncoded())); 
            String publicKey = new String(Base64.encodeBase64(keyPair.getPublic().getEncoded())); 
            System.out.println("私钥:" + privateKey); 
            System.out.println("公钥:" + publicKey); 
            // RSA加密 
            String data = "待加密的文字内容"; 
            String encryptData = encrypt(data, getPublicKey(publicKey)); 
            System.out.println("加密后内容:" + encryptData); 
            // RSA解密 
            String decryptData = decrypt(encryptData, getPrivateKey(privateKey)); 
            System.out.println("解密后内容:" + decryptData); 
 
            // RSA签名 
            String sign = sign(data, getPrivateKey(privateKey)); 
            // RSA验签 
            boolean result = verify(data, getPublicKey(publicKey), sign); 
            System.out.print("验签结果:" + result); 
        } catch (Exception e) { 
            e.printStackTrace(); 
            System.out.print("加解密异常"); 
        } 
    } 
}

参考博客:https://www.cnblogs.com/pcheng/p/9629621.html


标签:加密算法
声明

1.本站遵循行业规范,任何转载的稿件都会明确标注作者和来源;2.本站的原创文章,请转载时务必注明文章作者和来源,不尊重原创的行为我们将追究责任;3.作者投稿可能会经我们编辑修改或补充。

发表评论
搜索
排行榜
KIKK导航

KIKK导航

关注我们