AES与RSA加解密及签名

最新推荐文章于 2024-07-02 10:11:26 发布

好怪~

最新推荐文章于 2024-07-02 10:11:26 发布

阅读量3.4k

点赞数

本文链接：https://blog.csdn.net/qq_53314126/article/details/131242771

版权

一、AES（对称性加密）加密解密

      使用注意点：
       AES生成的钥匙只有一个叫密钥，加密和解密都用密钥来进行操作。注意生成的密钥是Base64位编码，在加密解密时候需要将其转化为密钥对象来进行加解密。
      模式及原理：
1、ECB模式：

ECB （电子密码本）模式是最简单的块密码加密模式,加密前根据数据块大小（如AES为128位）分成若干块，之后将每块使用相同的密钥单独通过块加密器密器。这种加密模式的优点就是简单,不需要初始化向量（IV），每个数据块独立进行加/解密，利于并行计算，加/解密效率很高。但这种模式中，所有数据都采用相同密钥进行加/解密，也没有经过任何逻辑运算，相同明文得到相同的密文，所以可能导致“选择明文攻击”的发生。

2、CBC模式：

CBC （密码分组链接）模式是先将明文切分成若干小块，然后每个小块与初始块或者上一段的密文段进行逻辑异或运算后，再用密钥进行加密。第一个明文块与一个叫初始化向量的数据块进行逻辑异或运算。这样就有效的解决了ECB模式所暴露出来的问题，即使两个明文块相同，加密后得到的密文块也不相同。但是缺点也相当明显，如加密过程复杂，效率低等。

3、CFB模式：

与ECB和CBC模式只能够加密块数据不同，CFB模式能够将密文转化成为流密文。这种加密模式中，由于加密流程和解密流程中被块加密器加密的数据是前块的密文，因此即使本块明文数据的长度不是数据块大小的整数倍也是不需要填充的，这保证了数据长度在加密前后是相同的。

4、OFB模式：

不再直接加密明文块，其加密过程是先使用块加密器生成密钥流，然后再将密钥流和明文流进行逻辑异或运算得到密文流。

加密算法的一般设计准则

混淆 (Confusion) 最大限度地复杂化密文、明文与密钥之间的关系，通常用非线性变换算法达到最大化的混淆。

扩散 (Diffusion) 明文或密钥每变动一位将最大化地影响密文中的位数，通常采用线性变换算法达到最大化的扩散

AES工具类

package com.zkyq.acss.util;1

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

public class AESUtil {

   /**
    * 生成AES秘钥，然后Base64编码
    * @return
    * @throws Exception
    */
   public static String genKeyAES() throws Exception{
       KeyGenerator keyGen = KeyGenerator.getInstance("AES");
       keyGen.init(128);
       SecretKey key = keyGen.generateKey();
       String base64Str = byte2Base64(key.getEncoded());
       return base64Str;
   }

   /**
    * 将Base64编码后的AES秘钥转换成SecretKey对象
    * @param base64Key
    * @return
    * @throws Exception
    */
   public static SecretKey loadKeyAES(String base64Key) throws Exception{
       SecretKeySpec key = new SecretKeySpec(base64Key.getBytes("utf-8"), "AES");
       return key;
   }

   /**
    * 字节数组转Base64编码
    * @param bytes
    * @return
    */
   public static String byte2Base64(byte[] bytes){
       return Base64.getEncoder().encodeToString(bytes);
   }

   /**
    * Base64编码转字节数组
    * @param base64Key
    * @return
    */
   public static byte[] base642Byte(String base64Key) {
       return Base64.getDecoder().decode(base64Key);
   }

   /**
    * 加密
    * @param source
    * @param key
    * @return
    * @throws Exception
    */
   public static byte[] encryptAES(byte[] source, SecretKey key) throws Exception{
       Cipher cipher = Cipher.getInstance("AES");
       cipher.init(Cipher.ENCRYPT_MODE, key);
       return cipher.doFinal(source);
   }

   /**
    * 解密
    * @param source
    * @param key
    * @return
    * @throws Exception
    */
   public static byte[] decryptAES(byte[] source, SecretKey key) throws Exception{
       Cipher cipher = Cipher.getInstance("AES");
       cipher.init(Cipher.DECRYPT_MODE, key);
       return cipher.doFinal(source);
   }

}

二、RSA（非对称性加密）加密解密及签名

使用注意点：在签名和加密解密时用到的钥匙数据类型是不相同

为什么要加密和签名：
加密：加密是为了防止信息被泄露；
签名：签名是为了防止信息被篡改,保证数据完整性和发送方角色的可靠性和不可抵赖性。
加密解密原理：
RSA算法常用于非对称加密，非对称加密流程如下：

（1）乙方生成两把密钥(公钥和私钥)。公钥是公开的，任何人都可以获得，私钥则是保密的。
（2）甲方获取乙方的公钥，然后用它对信息加密。
（3）乙方得到加密后的信息，用私钥解密。
RSA工具类：

package com.zkyq.acss.util;

import javax.crypto.Cipher;
import java.io.IOException;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
 
public class RSAUtil {
 
    /**
     * 生成秘钥对
     * @return
     * @throws Exception
     */
    public static KeyPair getKeyPair() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(2048);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        return keyPair;
    }
 
    /**
     * 获取公钥(Base64编码)
     * @param keyPair
     * @return
     */
    public static String getPublicKey(KeyPair keyPair){
        PublicKey publicKey = keyPair.getPublic();
        byte[] bytes = publicKey.getEncoded();
        return byte2Base64(bytes);
    }
 
    /**
     * 获取私钥(Base64编码)
     * @param keyPair
     * @return
     */
    public static String getPrivateKey(KeyPair keyPair){
        PrivateKey privateKey = keyPair.getPrivate();
        byte[] bytes = privateKey.getEncoded();
        return byte2Base64(bytes);
    }
 
    /**
     * 将Base64编码后的公钥转换成PublicKey对象
     * @param pubStr
     * @return
     * @throws Exception
     */
    public static PublicKey string2PublicKey(String pubStr) throws Exception{
        byte[] keyBytes = base642Byte(pubStr);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(keySpec);
        return publicKey;
    }
 
    /**
     * 将Base64编码后的私钥转换成PrivateKey对象
     * @param priStr
     * @return
     * @throws Exception
     */
    public static PrivateKey string2PrivateKey(String priStr) throws Exception{
        byte[] keyBytes = base642Byte(priStr);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        return privateKey;
    }
 
    /**
     * 公钥加密
     * @param content
     * @param publicKey
     * @return
     * @throws Exception
     */
    public static byte[] publicEncrypt(byte[] content, PublicKey publicKey) throws Exception{
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] bytes = cipher.doFinal(content);
        return bytes;
    }
 
    /**
     * 私钥解密
     * @param content
     * @param privateKey
     * @return
     * @throws Exception
     */
    public static byte[] privateDecrypt(byte[] content, PrivateKey privateKey) throws Exception{
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] bytes = cipher.doFinal(content);
        return bytes;
    }
 
    /**
     * 字节数组转Base64编码
     * @param bytes
     * @return
     */
    public static String byte2Base64(byte[] bytes){
        return Base64.getEncoder().encodeToString(bytes);
    }
 
    /**
     * Base64编码转字节数组
     * @param base64Key
     * @return
     * @throws IOException
     */
    public static byte[] base642Byte(String base64Key) {
        return Base64.getDecoder().decode(base64Key);
    }
}

三、RSA和AES配合使用及签名：

不带签名测试类

 //测试RSA与AES的结合。
    //					客户端用公钥加密AES秘钥，AES秘钥加密实际内容；
    //
    //
    //
    //					服务端用私钥解密AES秘钥，AES秘钥解密实际内容


    public static void mtestAesAndRsa() throws Exception {
        //===============生成公钥和私钥，公钥传给客户端，私钥服务端保留==================
        //生成RSA公钥和私钥，并Base64编码，生成一次以后，就写死在配置文件或代码中，下次不再重新生成
        KeyPair keyPair = RSAUtil.getKeyPair();
        String publicKeyStr = RSAUtil.getPublicKey(keyPair);
        String privateKeyStr = RSAUtil.getPrivateKey(keyPair);
        System.out.println("RSA公钥Base64编码:" + publicKeyStr);
        System.out.println("RSA私钥Base64编码:" + privateKeyStr);

        //=================客户端=================
        //hello, i am infi, good night!  需要加密的实际内容
        String message = "";
        //将Base64编码后的公钥转换成PublicKey对象
        PublicKey publicKey = RSAUtil.string2PublicKey(publicKeyStr);
        //生成AES秘钥，并Base64编码
        String aesKeyStr = AESUtil.genKeyAES();
        System.out.println("AES秘钥Base64编码:" + aesKeyStr);
        //用公钥加密AES秘钥
        //将AES加密
        byte[] publicEncrypt = RSAUtil.publicEncrypt(aesKeyStr.getBytes(), publicKey);
        //公钥加密AES秘钥后的内容Base64编码
        //转Base64
        String publicEncryptStr = RSAUtil.byte2Base64(publicEncrypt);
        System.out.println("公钥加密AES秘钥并Base64编码的结果：" + publicEncryptStr);

        //将Base64编码后的AES秘钥转换成SecretKey对象
        SecretKey aesKey = AESUtil.loadKeyAES(aesKeyStr);
        //用AES秘钥加密实际的内容
        byte[] encryptAES = AESUtil.encryptAES(message.getBytes(), aesKey);
        //AES秘钥加密后的内容Base64编码
        String encryptAESStr = AESUtil.byte2Base64(encryptAES);
        System.out.println("AES秘钥加密实际的内容并Base64编码的结果：" + encryptAESStr);


        //##############	网络上传输的内容有Base64编码后的公钥加密AES秘钥的结果 和 Base64编码后的AES秘钥加密实际内容的结果   #################
        //##############	即publicEncryptStr和encryptAESStr	###################


        //===================服务端================
        //将Base64编码后的私钥转换成PrivateKey对象
        PrivateKey privateKey = RSAUtil.string2PrivateKey(privateKeyStr);
        //公钥加密AES秘钥后的内容(Base64编码)，进行Base64解码
        byte[] publicEncrypt2 = RSAUtil.base642Byte(publicEncryptStr);
        //用私钥解密,得到aesKey
        byte[] aesKeyStrBytes = RSAUtil.privateDecrypt(publicEncrypt2, privateKey);
        //解密后的aesKey
        String aesKeyStr2 = new String(aesKeyStrBytes);
        System.out.println("解密后的aesKey(Base64编码): " + aesKeyStr2);

        //将Base64编码后的AES秘钥转换成SecretKey对象
        SecretKey aesKey2 = AESUtil.loadKeyAES(aesKeyStr2);
        //AES秘钥加密后的内容(Base64编码)，进行Base64解码
        byte[] encryptAES2 = AESUtil.base642Byte(encryptAESStr);
        //用AES秘钥解密实际的内容
        byte[] decryptAES = AESUtil.decryptAES(encryptAES2, aesKey2);
        //解密后的实际内容
        System.out.println("解密后的实际内容: " + new String(decryptAES));
    }

带签名测试类：

@Test
    void contextLoad2() throws Exception  {

        AcssVehicleTravelInfoDTO travelInfoDTO = new AcssVehicleTravelInfoDTO();
        //企业编号
        travelInfoDTO.setEnterpriseNo("ceshi");
        //企业名称
        travelInfoDTO.setEnterpriseName("ceshi");
        //出入口编号
        travelInfoDTO.setDoorNo("ceshi");
        //道闸编号
        travelInfoDTO.setRoadGateNo("ceshi");
        //车牌号码
        travelInfoDTO.setLicensePlateNo("ceshi");
//        acssVehicleInfo.setLicensePlateColour(acssVehicleInfoDTO.getLicensePlateColour());
        //车辆类型
        travelInfoDTO.setVehicleType("ceshi");
        //燃油类型
        travelInfoDTO.setFuelType("ceshi");
        //排放阶段
        travelInfoDTO.setDischargeStage("ceshi");
        //注册日期
        travelInfoDTO.setRegistrationDate("ceshi");
        //车牌识别代码
        travelInfoDTO.setVehicleIdentificationNo("ceshi");
//        acssVehicleInfo.setEngineNo(acssVehicleInfoDTO.getEngineNo());
        //使用性质
        travelInfoDTO.setUseCharacter("ceshi");
//        acssVehicleInfo.setVehicleOwner(acssVehicleInfo.getVehicleOwner());
//        acssVehicleInfo.setEngineModel(acssVehicleInfoDTO.getEngineModel());
        //行驶证
        travelInfoDTO.setDrivingLicense("ceshi");
        //车队名称
        travelInfoDTO.setFleetName("ceshi");
        //车牌识别可信度
        travelInfoDTO.setLicensePlateConfidenceLevel("ceshi");
        //车牌在图片中的位置XY坐标值，顺序为左-右-上-下，各5字节
        travelInfoDTO.setLicensePlatePosition("ceshi");
        //车身颜色
        travelInfoDTO.setVehicleColour("ceshi");

        //生成钥匙对
        KeyPair keyPair = RSAUtil.getKeyPair();
        //企业的公钥私钥
//        String publicKeyStr = RSAUtil.getPublicKey(keyPair);
//        String privateKeyStr = RSAUtil.getPrivateKey(keyPair);
        String publicKeyStr = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAia0VLs5/OAkMDJo3h1ZdLApeq/epM34kCmrNxZHsS2dnAAKKcRBuEpOyBlG5ZYIzsTD5WWIY+QpvrsqjIyQfaKrbd1KRSZxatgARkpPox/ScP17ixUzFNgAc6nt87RCzPkNhX8rjZ8GgeNNXb7UTXJAlR8p9cLDNYCskOsjQ89Syp28Nfq9y6Ya50un42TVHLqUNFGOiJh7cvpcSqyPZGAlj2ma5qztmk3azyABuSC79b3tZeTdJOMX3jjBaPubn1VyoEh8dAYF0/NoDRK2Z+rlvSbklVI2pX2rG6Gp/980LgsILUM7qHdsMfWTuVN93w/gToik5Il6Bc020QuUczQIDAQAB";
        String privateKeyStr = "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCJrRUuzn84CQwMmjeHVl0sCl6r96kzfiQKas3FkexLZ2cAAopxEG4Sk7IGUbllgjOxMPlZYhj5Cm+uyqMjJB9oqtt3UpFJnFq2ABGSk+jH9Jw/XuLFTMU2ABzqe3ztELM+Q2FfyuNnwaB401dvtRNckCVHyn1wsM1gKyQ6yNDz1LKnbw1+r3LphrnS6fjZNUcupQ0UY6ImHty+lxKrI9kYCWPaZrmrO2aTdrPIAG5ILv1ve1l5N0k4xfeOMFo+5ufVXKgSHx0BgXT82gNErZn6uW9JuSVUjalfasboan/3zQuCwgtQzuod2wx9ZO5U33fD+BOiKTkiXoFzTbRC5RzNAgMBAAECggEAFeCJEy0BDjhxz7bZyAmzOIJVVOI/4szSkU0zcYekkr7VoSzGLv07YHxTt6lY2oZ8DFYJ6WgrK7e6032jurvMuecchLN8HsRXrcAJCs+yF8QI6BD92/g9Bj2yWphQ26LhuK0gVgZ5aE1eYJTEuh19/CFzqxrEIBoYKIXyddzfRz9wzzfgjT9pmPrje/dquIkZ/ZAxzTIbxqTlfSAaecg33gTUOWAlEapJRdaPmcm4N7xtfNsFB3NX75ELA6GcHn9PE0dzoeNNE9RANYH41PrhqVXl5IgPA55G7T8bZwxh4Ra9neu0I0b7jyotqW9Bqx1iA89DzEZXGe7dyJfCPlOQQQKBgQD+MXsgGKujwD1oq+pQPfxQqLpN2Suq5DKPawk87h3Od+tYlgBQvHHv4cOBvrnTVu/qGDiemUsrn7eZnUEJvb4sVW1NQBsZedKWeA9QQV0ExKyXqah8vhDvwWzOUSsc7DnWwZn/0oKvQTHJrOb8EPfqyyogA+nkULGKGEjAl4a12QKBgQCKp5eaFgZk6C43RU+h687BKccq3hpk4EQCJze1V3tOwwHRTA+Gb6nHUi1iHFG3X3UgYxjLoNXCxL1HwFhJeKruRbYOPPmRMc8eyGN+lIE9cm9jGDl58Ed3Z3e8XEFhPTdM1DMnl2SxfhMwuzr1AmQ0TIAVpr/c5l/uqq1egICCFQKBgDqpCJT7nICJmKJTKhuiclva1EOq3lztlI1sUhFxkgdXvUQQObpoApMtMoT6kr+mzG7lcAuJrMNAdIpKs/ufggeRH0w4gwh6CJMY2c/XhbPX/0xwpqVC532s0YM7UAu4qBBbVUKoPehbzzWPZS6+a7gPcoU44f0CcjZALGnljfzhAoGBAIGKVHQsMasi1NLkmaKQ+ei0DJT7TrOCZ2ePlleBNP3/6PnO0w5p0rgbCbWI+buVnos0qlzMlgnS33hittlluGTGknG4+/1wCK8czv/a5OgwuupdHo3TNCHVdCNyGc8sbzcDZguOQRAm1u0Hb+yqYE4QTvZrhQNv5J7JrRIGgomFAoGARbFpWT8IxI1CN0zvSlVrjwhAvEBy5WFQng+9yuJbNoUagSi7v2eKd4zIb4ROPc92g7Zws2Zl66Wj1PGTL+C9qIS/EEEE2BgOvDYdM0WPE2rFFEIyQuhK8TUOgM7euRfUDS/LMGI9a3BBjEF/pYmyNuCWCyOwQC7RYsqXwALQc38=";
        //平台的公钥
        String publicKeyStrPingTai = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAhh89WYaHzysO9R8jhsjddZaBB8xd+OXuioe5b2/IaTAS29dGAWON0E9HT7CHOhJbVHhNMcPc2ePvODNUcRmjnxiTOT0SSiBvAav/Jf+XGukDLkfzpzpuWkB3V0abMMduor3WHol4hrSXqZfi7xD4a+RoPVs7OyoT8g6IqkUwYV4LZJ9JB2kyjrnFSJvo4mRnczTDCiY9EE0Bb33ECFeEdEoJv9qNQYE3SKZZpXpyYtHLCT3K6gnKjtsRbsqCtrhhqtw2bDhBddngdW6LgUBvDO36cUZx0/dlzu+hLmWTMoTpMXOuhwPxV8EfZSNdXBRZmQwhO+0yT+WKdO84I51Y+QIDAQABMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAhh89WYaHzysO9R8jhsjddZaBB8xd+OXuioe5b2/IaTAS29dGAWON0E9HT7CHOhJbVHhNMcPc2ePvODNUcRmjnxiTOT0SSiBvAav/Jf+XGukDLkfzpzpuWkB3V0abMMduor3WHol4hrSXqZfi7xD4a+RoPVs7OyoT8g6IqkUwYV4LZJ9JB2kyjrnFSJvo4mRnczTDCiY9EE0Bb33ECFeEdEoJv9qNQYE3SKZZpXpyYtHLCT3K6gnKjtsRbsqCtrhhqtw2bDhBddngdW6LgUBvDO36cUZx0/dlzu+hLmWTMoTpMXOuhwPxV8EfZSNdXBRZmQwhO+0yT+WKdO84I51Y+QIDAQAB";

        //密钥
//        String s = AESUtil.genKeyAES();
        String s = "hHI5tshTPYKq2Xxp4MjIYA==";

        //转json
        String company = JSON.toJSONString(travelInfoDTO);
        //将Base64编码后的公钥转换成PublicKey对象
        PublicKey publicKey = RSAUtil.string2PublicKey(publicKeyStrPingTai);
        //用监管系统公钥加密密钥
        byte[] publicEncrypt = RSAUtil.publicEncrypt(s.getBytes(), publicKey);
        //公钥加密AES秘钥后的内容Base64编码
        //转Base64
        String publicEncryptStr = RSAUtil.byte2Base64(publicEncrypt);
        System.out.println("公钥加密AES秘钥并Base64编码的结果：" + publicEncryptStr);
        //将Base64编码后的AES秘钥转换成SecretKey对象
        SecretKey aesKey = AESUtil.loadKeyAES(s);


        System.out.println("公钥为："+publicKeyStr);
        System.out.println("私钥为："+privateKeyStr);
        System.out.println("签名数据为："+company);
        //签名
        String S = signByPrivateKey(company, privateKeyStr);
        System.out.println("签名为："+S);
        //验签
        if (verifySignByPublicKey(company, S, publicKeyStr)){}else {
            System.out.println("验签数据为："+company);
            System.out.println("签名值："+S);

        }

        //AES加密数据
        byte[] encryptAES = AESUtil.encryptAES(company.getBytes(),aesKey);
        //组装公钥
        Map map = new HashMap();
        //数据
        map.put("info" , encryptAES);
        //签名
        map.put("sign" , S);
        //密钥
        map.put("secretKey" , publicEncryptStr);
        String token = "a14cacf0-4c82-4abb-a9b0-eb0b45c66bbe";
        map.put("token" , token);
        JSONObject jsonObject = new JSONObject(map);
        System.out.println(jsonObject);
    }

好怪~

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
AES与RSA加解密及签名

ECB （电子密码本）模式是最简单的块密码加密模式,加密前根据数据块大小（如AES为128位）分成若干块，之后将每块使用相同的密钥单独通过块加密器密器。但这种模式中，所有数据都采用相同密钥进行加/解密，也没有经过任何逻辑运算，相同明文得到相同的密文，所以可能导致“选择明文攻击”的发生。这种加密模式中，由于加密流程和解密流程中被块加密器加密的数据是前块的密文，因此即使本块明文数据的长度不是数据块大小的整数倍也是不需要填充的，这保证了数据长度在加密前后是相同的。公钥是公开的，任何人都可以获得，私钥则是保密的。
复制链接

扫一扫