当前位置：物联沃-IOTWORD物联网 > 技术教程 > 12 对称加密AES和非对称加密RSA
代码收藏家代码收藏家 技术教程

12 对称加密AES和非对称加密RSA

文章目录

  • 一、对称加密算法AES
  • 1. AES简介
  • 2. AES代码
  • 二、非对称加密算法RSA
  • 1. RSA简介
  • 2. RSA代码

    • 一、对称加密算法AES

    1. AES简介

    对称加密算法AES是目前广泛使用的一种加密技术，它采用相同的密钥来进行数据的加密和解密。

    AES的优点

  • 高效性：AES在多种平台上都具有很好的性能，能够快速加密和解密数据。
  • 安全性：AES被认为是一个非常安全的加密标准。
  • 灵活性：支持多种密钥长度，可以根据不同的安全需求选择合适的密钥。

    • AES的注意事项

  • 密钥管理：由于AES使用的是对称密钥，因此密钥的安全存储和分发至关重要。
  • 填充方式：在加密过程中，需要对数据块进行填充以使其符合块大小要求，常用的填充方式有PKCS、CBC等。
  • 初始化向量：在某些AES模式下，如CBC模式，需要使用IV来增加加密的随机性。

    • 2. AES代码

    import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

/**
 * AES 加密和解密
 */
public class AesTest {

    // 秘钥
    private static String KEY = "aaccB1123Mopac31";

    // 向量
    private static String IV = "CdmccsaCCcdsADf";

    /**
     * 加密
     * @param content 待加密内容
     * */
    public static String encrypt(String content) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        SecretKeySpec secretKeySpec = new SecretKeySpec(KEY.getBytes(StandardCharsets.UTF_8), "AES");
        cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, new IvParameterSpec(IV.getBytes(StandardCharsets.UTF_8)));
        return Base64.getEncoder().encodeToString(cipher.doFinal(content.getBytes(StandardCharsets.UTF_8)));
    }

    /**
     * 解密
     * @param content 加密内容
     * */
    public static String decrypt(String content) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        SecretKeySpec secretKeySpec = new SecretKeySpec(KEY.getBytes(StandardCharsets.UTF_8), "AES");
        cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, new IvParameterSpec(IV.getBytes(StandardCharsets.UTF_8)));
        byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(content));
        return new String(decryptedBytes, StandardCharsets.UTF_8);
    }
    
    public static void main(String[] args) throws Exception {
        String text = "加密内容";
        String encryptText = encrypt(text);
        System.out.println("加密后内容：" + encryptText);
        System.out.println("解密后内容：" + decrypt(encryptText));
    }
}
  • 效果

    • 二、非对称加密算法RSA

    1. RSA简介

    RSA是一种非对称加密算法，使用一对公钥和私钥来进行加密和解密操作，公钥用于加密数据，私钥用于解密数据。

    RSA的优点

  • 安全性：RSA基于大数因子分解难题，被认为是一种非常安全的加密算法。
  • 灵活性：RSA支持不同的密钥长度，可以根据需要选择适合的密钥长度来平衡安全性和性能。
  • 数字签名：RSA算法可以用于生成和验证数字签名，提供数据的完整性和身份验证功能。

    • RSA的注意事项

  • 密钥长度：选择合适的密钥长度非常重要，常见的密钥长度有1024位、2048位等，长度越长安全性越高。
  • 安全存储：私钥需要严格保密，确保私钥不被泄露，否则将导致加密数据的泄露。
  • 性能：RSA加密和解密的性能相对较低，需要注意在大量数据加密时可能会影响性能。

    • 加密场景

  • A生成一对密钥：公钥、私钥
  • B使用公钥对消息进行加密
  • A使用私钥对消息进行解密

    • 验签场景

  • A生成一对密钥：公钥、私钥
  • A使用私钥对消息进行签名
  • B使用私公钥对消息内容和消息签名进行验签

    • 2. RSA代码

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

/**
 * RSA 加密解密和签名验签
 */
public class RsaTest {

    // 公钥
    private static String PUBLIC_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDHDYWXIMltI+zia0lrxm1dJu96" +
            "QkogDVLsaFXxnjCZl72evCU0CAlWGDPc3gzJYFNw1KZvNRuTTiKbGa0enFc8hDoG" +
            "Sjg37Na8OqMzLZZ/N6/DCAUywk1JNhMfYDr0GSYNgV37NXWvKD3rbvfxCkoH3ojn" +
            "B3zUgr31VQfryzXq+QIDAQAB";

    // 私钥
    private static String PRIVATE_KEY = "MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAMcNhZcgyW0j7OJr" +
            "SWvGbV0m73pCSiANUuxoVfGeMJmXvZ68JTQICVYYM9zeDMlgU3DUpm81G5NOIpsZ" +
            "rR6cVzyEOgZKODfs1rw6ozMtln83r8MIBTLCTUk2Ex9gOvQZJg2BXfs1da8oPetu" +
            "9/EKSgfeiOcHfNSCvfVVB+vLNer5AgMBAAECgYBNTSADJ9VxkBEPgRC7TQztrxAz" +
            "T4kP13zLmF0//unqy/X0riZYhYJyr+V8MbOPhNwCpmKYL2ytERv5VchYaeiqRBsQ" +
            "vVqVhz5oBGmVxyrHsfiRl4F+3vUA/qeewmNl/rFTxXBH5T3J0SzppSD6Z9+gdPiy" +
            "wl51fut+FqggqbiH/QJBAP9ETAF+qKM5pW2KHhNbeKwxc2e0y3fvxAEfFKD6GakT" +
            "d38QMTULN6kmZl3vhJXSxY/Xt8OjZVOvOTWj4yoqXycCQQDHn+O9viCin1HGtv1W" +
            "LIMxYFIj3m+3CgE2RltgVErmxS5Jo3bh86UFk8t+/JRRhatpxKaPBlOzN4WsmbkW" +
            "b7jfAkAWuTOy5l2Iujb5u1PWEUx6t6Q4VSXPtW5TUzr44YqrPGpky0I2IJuB2UM/" +
            "lXTOCYdAuMlJByCcBHspRT+Rn1f9AkEAibZAqxXtd6KHDJoSXI9qlfaH09zQnqoV" +
            "OfcBdIvR/C9NBlnxWmD1l8pkmR7vxul63gVejc5kkX8dBXwq1lKOawJBAKeVg9VB" +
            "hj7WkjgoIVnuI8CIrO6IpboS+ySV/CZalkyNNVRWq2rOJbpIHe4baXqPomZ8mFEA" +
            "4SGoEW3AiyFiqb8=";

    /**
     * 获取密钥对
     */
    public static KeyPair getKeyPair() throws Exception {
        KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
        generator.initialize(1024);
        return generator.generateKeyPair();
    }
    
    /**
     * 实例化公钥
     * @param publicKey 公钥
     */
    public static PublicKey getPublicKey(String publicKey) throws Exception {
        byte[] publicKeyBytes = Base64.getDecoder().decode(publicKey.getBytes());
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        return keyFactory.generatePublic(keySpec);
    }

    /**
     * 实例化私钥
     * @param privateKey 私钥
     */
    public static PrivateKey getPrivateKey(String privateKey) throws Exception {
        byte[] privateKeyBytes = Base64.getDecoder().decode(privateKey.getBytes());
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        return keyFactory.generatePrivate(keySpec);
    }

    /**
     * 公钥加密
     * @param content 待加密内容
     */
    public static String encrypt(String content, String publicKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, getPublicKey(publicKey));
        return new String(Base64.getEncoder().encode(cipher.doFinal(content.getBytes("UTF-8"))));
    }

    /**
     * 私钥解密
     * @param content 加密内容
     */
    public static String decrypt(String content, String privateKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, getPrivateKey(privateKey));
        return new String(cipher.doFinal(Base64.getDecoder().decode(content)));
    }

    /**
     * 私钥签名
     * @param content 待签名内容
     */
    public static String sign(String content, String privateKey) throws Exception {
        Signature signature = Signature.getInstance("SHA1WithRSA");
        signature.initSign(getPrivateKey(privateKey));
        signature.update(content.getBytes("UTF-8"));
        return new String(Base64.getEncoder().encode(signature.sign()));
    }

    /**
     * 公钥验签
     * @param content 原始内容
     * @param sign 签名内容
     */
    public static boolean verify(String content, String sign, String publicKey) throws Exception {
        Signature signature = Signature.getInstance("SHA1WithRSA");
        signature.initVerify(getPublicKey(publicKey));
        signature.update(content.getBytes("UTF-8"));
        return signature.verify(Base64.getDecoder().decode(sign));
    }
    
    public static void main(String[] args) throws Exception {
        KeyPair keyPair = getKeyPair();
        System.out.println("私钥");
        System.out.println(new String(Base64.getEncoder().encode(keyPair.getPrivate().getEncoded())));
        System.out.println("公钥");
        System.out.println(new String(Base64.getEncoder().encode(keyPair.getPublic().getEncoded())));

        String content = "消息内容";

        String encrypt = encrypt(content,PUBLIC_KEY);
        System.out.println("加密内容");
        System.out.println(encrypt);
        String decryp = decrypt(encrypt,PRIVATE_KEY);
        System.out.println("解密内容");
        System.out.println(decryp);

        String sign = sign(content,PRIVATE_KEY);
        System.out.println("签名内容");
        System.out.println(sign);
        boolean verify = verify(content,sign,PUBLIC_KEY);
        System.out.println("验证结果");
        System.out.println(verify);
    }
}
  • 效果

    • 作者：yancqitcode

    物联沃分享整理
    物联沃-IOTWORD物联网 » 12 对称加密AES和非对称加密RSA

    代码收藏家 普通

    分享到：

    相关推荐

    发表回复