Comment effectuer des opérations de cryptage et de décryptage AES en Java

1. Connaissances de base

• En cryptographie, les algorithmes de cryptage sont divisés en cryptage unidirectionnel et cryptage bidirectionnel.

• Le cryptage symétrique signifie que le cryptage et le déchiffrement utilisent la même clé, y compris le cryptage AES, le cryptage DES, etc.

• Le cryptage asymétrique signifie que le cryptage et le déchiffrement utilisent des clés différentes, notamment le cryptage RSA, etc.

• Le cryptage unidirectionnel inclut des algorithmes de digestion tels que MD5 et SHA, qui sont irréversibles.

• Le cryptage bidirectionnel comprend le cryptage symétrique et le cryptage asymétrique. Le cryptage bidirectionnel est réversible et la clé du texte chiffré existe.

2. Introduction à AES

AES : Advanced Encryption Standard (Advanced Encryption Standard) est une norme de cryptage par blocs adoptée par le gouvernement fédéral américain. Il s'agit actuellement de l'algorithme de cryptage symétrique le plus populaire <.>. <code>对称加密算法。

• 是用来替代DES的新一代分组加密算法。

• AES支持三种长度的密钥：128位、192位、256位。

3.AES的加密过程（AES处理单位：字节）

AES的加解密过程和DES一样，都是通过分组加密、分组解密。所谓分组加密，就是将待加解密的内容按照128位进行分组，将密钥按照128位、192位、256位进行分组，分别将分组后的明文与相应分组后的密钥进行加解密。

加密： 明文与密钥分组后，对每组：明文组与密钥组处理 -> 轮密钥加 -> 10轮加密 -> 密文组

解密： 对每组：密文组 -> 轮密钥加 -> 10轮解密 -> 明文组

明文分组： 每组长度相等，都是128位（16字节）；

密钥分组： 有128位、192位、256位，推荐加密轮数分别为 10、12、14

密钥组处理： 以密钥分组每组128位为例（则推荐加密轮数为10，前9次执行操作一样，第十次有所不同） 类似地，128位密钥也是用字节为单位的矩阵表示，通过密钥编排函数，形成具有44个元素的序列W[0],W[1], … ,W[43]（每个元素4个字节）；其中，W[0],W[1],W[2],W[3]为原始密钥，其余40个元素分为10组，每组4个元素（4*4=16字节），分别用于10轮加密。

AES加密算法涉及4种操作： 字节替代（SubBytes）、行移位（ShiftRows）、列混淆（MixColumns）和轮密钥加（AddRoundKey）。

下图给出了AES加解密的流程：

• AddRoundKey （轮密钥加）— 矩阵中的每一个字节都与该次轮密钥（round key）做XOR运算；每个子密钥由密钥生成方案产生。

• SubBytes（字节替代） — 通过非线性的替换函数，用查找表的方式把每个字节替换成对应的字节。

• ShiftRows（行移位） — 将矩阵中的每个横列进行循环式移位。

• MixColumns （列混淆）— 为了充分混合矩阵中各个直行的操作。这个步骤使用线性转换来混合每列的四个字节。

假如一段明文长度是192bit，如果按每128bit一个明文块来拆分的话，第二个明文块只有64bit，不足128bit。这时候怎么办呢？就需要对明文块进行填充（Padding）。

填充涉及以下三种填充模式：

• NoPadding：不做任何填充，但是要求明文必须是16字节的整数倍。

• PKCS5Padding（默认）：如果明文块少于16个字节（128bit），在明文块末尾补足相应数量的字符，且每个字节的值等于缺少的字符数。

比如明文：{1,2,3,4,5,a,b,c,d,e},缺少6个字节，则补全为{1,2,3,4,5,a,b,c,d,e,6,6,6,6,6,6}

• ISO10126Padding

est un algorithme de chiffrement par blocs de nouvelle génération utilisé pour remplacer le DES.

AES prend en charge trois longueurs de clé : 128 bits, 192 bits et 256 bits.

3. Processus de cryptage AES (unité de traitement AES : octet)

Le processus de cryptage et de décryptage d'AES est le même que celui du DES, à la fois via le cryptage par bloc et le décryptage de groupe. Le chiffrement dit par bloc consiste à regrouper le contenu à chiffrer et déchiffrer en groupes selon 128 bits, à regrouper les clés en groupes selon 128 bits, 192 bits et 256 bits, et à chiffrer et déchiffrer le texte en clair groupé et le correspondant. touches regroupées respectivement.

Cryptage :

Une fois le texte en clair et la clé regroupés, pour chaque groupe : traitement du groupe de texte en clair et du groupe de clés-> Ajout de clé ronde-> 10 cycles de chiffrement-> groupe : Groupe de texte chiffré-> Ajout de clé ronde-> 10 tours de décryptage-> Groupe de texte brut

Groupe de texte brut :

Chaque groupe est de longueur égale, les deux 128 bits (16 octets) ; Regroupement de clés cryptographiques : Il y a 128 bits, 192 bits et 256 bits. Les cycles de cryptage recommandés sont respectivement de 10, 12 et 14.

🎜 Traitement des groupes de clés : 🎜 En prenant comme exemple le groupement de clés de 128 bits par groupe. (le nombre recommandé de tours de cryptage est de 10, les 9 premières fois l'opération est la même et la dixième fois est différente) De même, la clé de 128 bits est également représentée par une matrice en unités d'octets, et une séquence de 44 éléments W[0 est formé via la fonction d'arrangement des touches ],W[1], …,W[43] (parmi eux, W[0], W[1], W[2], W) ; [3] sont les clés originales. Les 40 éléments restants sont divisés en 10 groupes, chaque groupe comporte 4 éléments (4*4=16 octets), qui sont utilisés respectivement pour 10 tours de cryptage. 🎜🎜🎜L'algorithme de chiffrement AES implique 4 opérations : 🎜 Substitution d'octets (SubBytes), Décalage de ligne (ShiftRows), Obfuscation de colonne ( MixColumns) et Ajout de clé ronde (AddRoundKey). 🎜🎜La figure suivante montre le processus de cryptage et de déchiffrement AES : 🎜🎜🎜🎜🎜AddRoundKey (ajout de clé ronde)🎜— Chaque octet de la matrice est XORé avec la clé ronde. Chaque sous-clé est générée par un schéma de génération de clé ; . 🎜🎜🎜🎜🎜SubBytes (remplacement d'octets)🎜 — Remplacez chaque octet par l'octet correspondant à l'aide d'une table de recherche via une fonction de remplacement non linéaire. 🎜🎜🎜🎜🎜ShiftRows (décalage de ligne)🎜 — Décalez circulairement chaque colonne de la matrice. 🎜🎜🎜🎜🎜MixColumns (confusion de colonnes)🎜— Afin de mélanger complètement les opérations de chaque ligne droite de la matrice. Cette étape utilise une transformation linéaire pour mélanger les quatre octets de chaque colonne. 🎜🎜🎜🎜🎜 🎜Si un paragraphe La longueur du texte en clair est de 192 bits. S'il est divisé en un bloc de texte en clair tous les 128 bits, le deuxième bloc de texte en clair ne fait que 64 bits, soit moins de 128 bits. Que faire à ce moment ? Il est nécessaire de remplir le bloc de texte en clair (Padding). 🎜🎜Le remplissage implique les Trois modes de remplissage suivants : 🎜🎜🎜🎜NoPadding : aucun remplissage n'est effectué, mais le texte en clair doit être un multiple entier de 16 octets. 🎜🎜🎜🎜PKCS5Padding (par défaut) : Si le bloc de texte en clair fait moins de 16 octets (128 bits), le nombre de caractères correspondant est ajouté à la fin du bloc de texte en clair, et la valeur de chaque octet est égal au numéro du caractère manquant. 🎜🎜🎜🎜Par exemple, texte brut : {1,2,3,4,5,a,b,c,d,e}, s'il manque 6 octets, la complétion est {1,2,3,4, 5, a,b,c,d,e,6,6,6,6,6,6}🎜🎜🎜🎜ISO10126Padding : Si le bloc de texte en clair fait moins de 16 octets (128 bits), dans le texte en clair La fin du bloc est complétée avec le nombre d'octets correspondant, la valeur du dernier caractère est égale au nombre de caractères manquants et les autres caractères sont remplis de nombres aléatoires. 🎜🎜🎜🎜Par exemple, texte brut : {1,2,3,4,5,a,b,c,d,e}, s'il manque 6 octets, la complétion peut être {1,2,3,4 ,5 ,a,b,c,d,e,5,c,3,G,$,6}🎜🎜4. Implémentation Java🎜🎜🎜Remarque : le cryptage AES contient le cryptage Base64🎜🎜🎜🎜🎜Cryptage :🎜 AES chiffrement- > Chiffrement Base64-> Texte chiffré 🎜🎜🎜 Décryptage : 🎜 Décryptage Base64-> Texte brut 🎜🎜🎜 Adresse de test : Cliquez ici 🎜🎜

4.1 Générer des clés et des décalages

Générer 16 nombres aléatoires de lettres et de chiffres majuscules et minuscules :

private static final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; // 数字和26个字母组成
private static final Random RANDOM = new SecureRandom();
/**
 * 获取长度为 6 的随机字母+数字
 * @return 随机数字
 */
public static String getRandomNumber() {
    char[] nonceChars = new char[16];  //指定长度为6位/自己可以要求设置
    for (int index = 0; index < nonceChars.length; ++index) {
        nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
    }
    return new String(nonceChars);
}

4.2 Code source AESUtil.java

import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.Base64Utils;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
/**
 * AES加密工具类
 *
 * @author ACGkaka
 * @since 2021-06-18 19:11:03
 */
public class AESUtil {
    /**
     * 日志相关
     */
    private static final Logger LOGGER = LoggerFactory.getLogger(AESUtil.class);
    /**
     * 编码
     */
    private static final String ENCODING = "UTF-8";
    /**
     * 算法定义
     */
    private static final String AES_ALGORITHM = "AES";
    /**
     * 指定填充方式
     */
    private static final String CIPHER_PADDING = "AES/ECB/PKCS5Padding";
    private static final String CIPHER_CBC_PADDING = "AES/CBC/PKCS5Padding";
    /**
     * 偏移量(CBC中使用，增强加密算法强度)
     */
    private static final String IV_SEED = "1234567812345678";
    /**
     * AES加密
     * @param content 待加密内容
     * @param aesKey  密码
     * @return
     */
    public static String encrypt(String content, String aesKey){
        if(StringUtils.isBlank(content)){
            LOGGER.info("AES encrypt: the content is null!");
            return null;
        }
        //判断秘钥是否为16位
        if(StringUtils.isNotBlank(aesKey) && aesKey.length() == 16){
            try {
                //对密码进行编码
                byte[] bytes = aesKey.getBytes(ENCODING);
                //设置加密算法，生成秘钥
                SecretKeySpec skeySpec = new SecretKeySpec(bytes, AES_ALGORITHM);
                // "算法/模式/补码方式"
                Cipher cipher = Cipher.getInstance(CIPHER_PADDING);
                //选择加密
                cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
                //根据待加密内容生成字节数组
                byte[] encrypted = cipher.doFinal(content.getBytes(ENCODING));
                //返回base64字符串
                return Base64Utils.encodeToString(encrypted);
            } catch (Exception e) {
                LOGGER.info("AES encrypt exception:" + e.getMessage());
                throw new RuntimeException(e);
            }
        }else {
            LOGGER.info("AES encrypt: the aesKey is null or error!");
            return null;
        }
    }
    /**
     * 解密
     * 
     * @param content 待解密内容
     * @param aesKey  密码
     * @return
     */
    public static String decrypt(String content, String aesKey){
        if(StringUtils.isBlank(content)){
            LOGGER.info("AES decrypt: the content is null!");
            return null;
        }
        //判断秘钥是否为16位
        if(StringUtils.isNotBlank(aesKey) && aesKey.length() == 16){
            try {
                //对密码进行编码
                byte[] bytes = aesKey.getBytes(ENCODING);
                //设置解密算法，生成秘钥
                SecretKeySpec skeySpec = new SecretKeySpec(bytes, AES_ALGORITHM);
                // "算法/模式/补码方式"
                Cipher cipher = Cipher.getInstance(CIPHER_PADDING);
                //选择解密
                cipher.init(Cipher.DECRYPT_MODE, skeySpec);
                //先进行Base64解码
                byte[] decodeBase64 = Base64Utils.decodeFromString(content);
                //根据待解密内容进行解密
                byte[] decrypted = cipher.doFinal(decodeBase64);
                //将字节数组转成字符串
                return new String(decrypted, ENCODING);
            } catch (Exception e) {
                LOGGER.info("AES decrypt exception:" + e.getMessage());
                throw new RuntimeException(e);
            }
        }else {
            LOGGER.info("AES decrypt: the aesKey is null or error!");
            return null;
        }
    }
    /**
     * AES_CBC加密
     * 
     * @param content 待加密内容
     * @param aesKey  密码
     * @return
     */
    public static String encryptCBC(String content, String aesKey){
        if(StringUtils.isBlank(content)){
            LOGGER.info("AES_CBC encrypt: the content is null!");
            return null;
        }
        //判断秘钥是否为16位
        if(StringUtils.isNotBlank(aesKey) && aesKey.length() == 16){
            try {
                //对密码进行编码
                byte[] bytes = aesKey.getBytes(ENCODING);
                //设置加密算法，生成秘钥
                SecretKeySpec skeySpec = new SecretKeySpec(bytes, AES_ALGORITHM);
                // "算法/模式/补码方式"
                Cipher cipher = Cipher.getInstance(CIPHER_CBC_PADDING);
                //偏移
                IvParameterSpec iv = new IvParameterSpec(IV_SEED.getBytes(ENCODING));
                //选择加密
                cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);
                //根据待加密内容生成字节数组
                byte[] encrypted = cipher.doFinal(content.getBytes(ENCODING));
                //返回base64字符串
                return Base64Utils.encodeToString(encrypted);
            } catch (Exception e) {
                LOGGER.info("AES_CBC encrypt exception:" + e.getMessage());
                throw new RuntimeException(e);
            }
        }else {
            LOGGER.info("AES_CBC encrypt: the aesKey is null or error!");
            return null;
        }
    }
    /**
     * AES_CBC解密
     * 
     * @param content 待解密内容
     * @param aesKey  密码
     * @return
     */
    public static String decryptCBC(String content, String aesKey){
        if(StringUtils.isBlank(content)){
            LOGGER.info("AES_CBC decrypt: the content is null!");
            return null;
        }
        //判断秘钥是否为16位
        if(StringUtils.isNotBlank(aesKey) && aesKey.length() == 16){
            try {
                //对密码进行编码
                byte[] bytes = aesKey.getBytes(ENCODING);
                //设置解密算法，生成秘钥
                SecretKeySpec skeySpec = new SecretKeySpec(bytes, AES_ALGORITHM);
                //偏移
                IvParameterSpec iv = new IvParameterSpec(IV_SEED.getBytes(ENCODING));
                // "算法/模式/补码方式"
                Cipher cipher = Cipher.getInstance(CIPHER_CBC_PADDING);
                //选择解密
                cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv);
                //先进行Base64解码
                byte[] decodeBase64 = Base64Utils.decodeFromString(content);
                //根据待解密内容进行解密
                byte[] decrypted = cipher.doFinal(decodeBase64);
                //将字节数组转成字符串
                return new String(decrypted, ENCODING);
            } catch (Exception e) {
                LOGGER.info("AES_CBC decrypt exception:" + e.getMessage());
                throw new RuntimeException(e);
            }
        }else {
            LOGGER.info("AES_CBC decrypt: the aesKey is null or error!");
            return null;
        }
    }
    public static void main(String[] args) {
        // AES支持三种长度的密钥：128位、192位、256位。
        // 代码中这种就是128位的加密密钥，16字节 * 8位/字节 = 128位。
        String random = RandomStringUtils.random(16, "abcdefghijklmnopqrstuvwxyz1234567890");
        System.out.println("随机key:" + random);
        System.out.println();
        System.out.println("---------加密---------");
        String aesResult = encrypt("测试AES加密12", random);
        System.out.println("aes加密结果:" + aesResult);
        System.out.println();
        System.out.println("---------解密---------");
        String decrypt = decrypt(aesResult, random);
        System.out.println("aes解密结果:" + decrypt);
        System.out.println();
        System.out.println("--------AES_CBC加密解密---------");
        String cbcResult = encryptCBC("测试AES加密12456", random);
        System.out.println("aes_cbc加密结果:" + cbcResult);
        System.out.println();
        System.out.println("---------解密CBC---------");
        String cbcDecrypt = decryptCBC(cbcResult, random);
        System.out.println("aes解密结果:" + cbcDecrypt);
        System.out.println();
    }
}

4.3 Résultats d'exécution

随机key:golrtt58318fx7ol
---------加密---------
aes加密结果:Xy8W9lCeVue9Ao36z+duM7D7WeS5tdBihIMb1q9KpNg=
---------解密---------
aes解密结果:测试AES加密12
--------AES_CBC加密解密---------
aes_cbc加密结果:xs3ypQXyd62P9jB0+RvOqxFnHIHBIlVdqoZLuqYNBLw=
---------解密CBC---------
aes解密结果:测试AES加密12456

4.4 Vérification en ligne

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!