[Calculer la valeur CMAC basée sur AES-128]

Préface

Utilisez simplement Qt pour développer un petit outil permettant de calculer la valeur CMAC d'un fichier binaire. L'utilisateur sélectionne un fichier binaire puis entre la valeur clé pour calculer la valeur CMAC. Cet article donnera le code d'implémentation. Je présenterai brièvement ce qu'est AES. le cryptage et CAMC le sont. Allons droit au but.

AES

AES (Advanced Encryption Standard) est un algorithme de chiffrement symétrique largement utilisé pour protéger la sécurité des données sensibles. AES est conçu pour offrir un haut degré de sécurité et pour fonctionner efficacement sur une variété d’appareils.
L'algorithme AES a trois longueurs de clé fixes : 128 bits, 192 bits et 256 bits. Parmi eux, AES-128 utilise une longueur de clé de 128 bits (16 octets). Voici quelques fonctionnalités clés de l'AES-128 :
1. Longueur de la clé : AES-128 utilise une clé de 128 bits (16 octets). le niveau de sécurité de base de l’algorithme. La longueur de la clé affecte directement la sécurité de l'algorithme. Des clés plus longues offrent généralement une sécurité plus élevée, mais augmentent également la complexité des calculs.
2. Longueur du paquet : AES-128 divise les données en blocs de 128 bits (16 octets) pour le chiffrement. Il s'agit de la longueur de paquet fixe dans l'algorithme AES.
3. Nombre de tours : AES-128 utilise 10 tours d'itérations de chiffrement. Chaque tour implique différentes opérations, notamment la substitution d'octets, le déplacement de lignes, l'obscurcissement de colonnes et l'ajout de clés de tour. Ensemble, ces opérations améliorent la sécurité de l'algorithme.
4. Octet de substitution (SubBytes) : Dans l'étape d'octet de substitution, chaque octet sera remplacé par un octet prédéfini, via la boîte de substitution S. Cette étape augmente la non-linéarité de l'algorithme et améliore la sécurité.
5. Décalage de ligne (ShiftRows) : Dans l'étape de décalage de ligne, chaque ligne dans AES-128 sera décalée cycliquement vers la gauche selon des règles fixes. Cette étape contribue à augmenter l’obscurcissement des données.
6. Confusion de colonnes (MixColumns) : La confusion de colonnes est une transformation linéaire qui augmente la complexité de l'algorithme en multipliant chaque colonne par une matrice fixe. .
7. Ajout de clé ronde (AddRoundKey) : À chaque tour, la clé ronde effectuera une opération XOR au niveau du bit avec le bloc de données. La clé ronde est développée à partir de la clé principale et générée via une série d'algorithmes d'expansion de clé.

CMAC

CMAC (Cipher-based Message Authentication Code) est un algorithme de code d'authentification de message basé sur un mot de passe. Il s'agit d'une fonction déterministe liée à la clé utilisée pour calculer le code d'authentification d'un message afin de vérifier l'intégrité et l'authenticité du message. CMAC a évolué à partir de CBC-MAC (Cipher Block Chaining Message Authentication Code), mais a résolu certains problèmes de sécurité lors de la conception.
CMAC comporte deux étapes principales : la génération et la vérification.
Phase de génération :
Saisir le message et la clé.
Utilisez un algorithme de cryptage pour traiter le message et générer un code d'authentification de longueur fixe.
Phase de vérification :
Saisissez le message, la clé et le code d'authentification.
Utilisez l'algorithme de cryptage pour traiter le message et générer un nouveau code d'authentification.
Compare le code d'authentification généré avec le code d'authentification saisi. Si les deux correspondent, le message est vérifié comme étant complet et authentique.
CMAC fournit un moyen sécurisé d'authentifier les messages sans utiliser de signatures numériques. Il convient à diverses applications, telles que la communication réseau, le transfert de fichiers, etc., pour garantir que les messages n'ont pas été falsifiés pendant la transmission.

Une implémentation spécifique de CMAC consiste à utiliser l'algorithme AES (Advanced Encryption Standard). Ainsi, dans certains contextes, CMAC est également appelé AES-CMAC.

accomplir

ouvressl

OpenSSL est une boîte à outils de cryptographie open source qui fournit une série d'algorithmes de chiffrement et la mise en œuvre de protocoles de communication sécurisés. Il prend en charge une variété de systèmes d'exploitation, y compris les systèmes de type Unix tels que Linux et BSD, ainsi que Windows. Voici quelques-unes des principales fonctionnalités et utilisations d'OpenSSL :
Algorithme de chiffrement : OpenSSL fournit une série d'algorithmes de chiffrement, y compris des algorithmes de chiffrement symétriques (tels que AES , DES, 3DES ), des algorithmes de chiffrement asymétriques (tels que RSA, DSA, ECDSA), des fonctions de hachage (telles que MD5, SHA-1, SHA-256), etc. Ces algorithmes peuvent être utilisés pour le cryptage des données, les signatures numériques, les codes d'authentification des messages, etc.
Protocole SSL/TLS : OpenSSL implémente les protocoles SSL (Secure Sockets Layer) et TLS (Transport Layer Security) pour une communication réseau sécurisée. Il prend en charge plusieurs versions de protocole, notamment SSLv2, SSLv3, TLSv1, TLSv1.1, TLSv1.2, TLSv1.3. Le protocole SSL/TLS est utilisé pour établir un canal de communication crypté entre le client et le serveur, garantissant la confidentialité et l'intégrité des données.
Outils de ligne de commande : OpenSSL fournit des outils de ligne de commande, dont le plus couramment utilisé est la commande openssl. Grâce à la commande openssl, les utilisateurs peuvent effectuer diverses opérations, telles que générer des paires de clés, créer des certificats numériques, effectuer des opérations de cryptage et de décryptage, etc.

calculerFichierCMAC

Cette fonction sera exécutée lorsque l'utilisateur sélectionnera un fichier sur l'interface.
Paramètres :
clé : clé, la longueur est AES_BLOCK_SIZE.
filePath : le chemin du fichier pour lequel CMAC doit être calculé.
Étapes de l'opération :
1. Ouvrez le fichier et lisez toutes les données du fichier.
2. Si la longueur des données du fichier est inférieure à 64 Ko, un remplissage est effectué et les données de remplissage sont 0xFF.
3. Appelez la fonction calculateCMAC pour calculer le CMAC du fichier et renvoyer le résultat.

calculerCMAC

Cette fonction sera exécutée après avoir lu les données du fichier
Paramètres :
clé : clé, la longueur est AES_BLOCK_SIZE (généralement 16 octets) .
données : données nécessaires au calcul du CMAC.
Étapes de l'opération :
Vérifiez si la longueur de la clé est correcte. Si elle est incorrecte, un message d'erreur sera affiché et un QByteArray vide sera renvoyé.
Créez un contexte CMAC (CMAC_CTX).
Effectuez une inversion de l'ordre des octets sur les données d'entrée (inversion tous les quatre octets).
Initialisez le contexte CMAC à l'aide de la fonction OpenSSL CMAC_Init, en spécifiant l'algorithme AES-128-CBC.
Utilisez CMAC_Update pour mettre à jour le contexte CMAC afin d'ajouter des données au calcul.
Utilisez CMAC_Final pour terminer le calcul CMAC et obtenir le code d'authentification final.
Convertissez le code d'authentification en résultat de type QByteArray.
Libère le contexte CMAC.
Traitement des fichiers :
Créez un nouveau chemin de fichier basé sur le chemin d'accès au fichier d'origine et copiez le fichier vers le nouveau chemin.
Ajoute le CMAC calculé dans un nouveau fichier.
Afficher le CMAC calculé sous forme hexadécimale dans la zone d'édition de texte de l'interface.
Créez un nouveau fichier et écrivez les données inversées dans le nouveau fichier.

code clé

calculateFileCMAC：

QByteArray cmacopenssl::calculateFileCMAC(const QByteArray &key, const QString &filePath)
{
    
    
    QByteArray result;

    // Read the content of the file
    QFile file(filePath);
    if (!file.open(QIODevice::ReadOnly)) {
    
    
        qDebug() << "Failed to open file:" << file.errorString();
        return result;
    }
    //qint64 fileSize = file.size();
    QByteArray fileData = file.readAll();
    file.close();
    //fileData = QByteArray::fromHex("aaaaaaaaaa");
    // Calculate CMAC for the file data
    // Check the length of the fileData
    qint64 dataSize = fileData.size();
    qint64 paddingSize = 64 * 1024 - dataSize;

    // Check if padding is needed
    if (paddingSize > 0) {
    
    
        QByteArray paddingData(paddingSize, '\xff');
        //fileData.append(paddingData);
    }
    //qDebug()<<fileData.toHex();
    qDebug()<<"size:  "<<fileData.size();
    qDebug()<<fileData.toHex();
    result = calculateCMAC(key, fileData);
    return result;
}

calculerCMAC :

QByteArray cmacopenssl::calculateCMAC(const QByteArray &key, const QByteArray &data)
{
    
    
    QByteArray result;
    // Check key length
    if (key.length() != AES_BLOCK_SIZE) {
    
    
        qDebug() << "Key length should be " << AES_BLOCK_SIZE << " bytes.";
        return result;
    }
    // Create a CMAC context
    CMAC_CTX *ctx = CMAC_CTX_new();
    // Reverse the endianness of every four bytes in the input data
    QByteArray reversedData = data;
    qDebug()<<reversedData.toHex();
    for (int i = 0; i < reversedData.size(); i += 4) {
    
    
        // Ensure that we have at least four bytes to convert
        if (i + 3 < reversedData.size()) {
    
    
            char temp = reversedData[i];
            reversedData[i] = reversedData[i + 3];
            reversedData[i + 3] = temp;

            temp = reversedData[i + 1];
            reversedData[i + 1] = reversedData[i + 2];
            reversedData[i + 2] = temp;
        }
    }
    // Initialize CMAC context with the key
    if (CMAC_Init(ctx, key.constData(), key.length(), EVP_aes_128_cbc(), nullptr) != 1) {
    
    
        qDebug() << "CMAC_Init failed.";
        CMAC_CTX_free(ctx);
        return result;
    }
    //Update CMAC context with the data
    if (CMAC_Update(ctx, data.constData(), data.length()) != 1) {
    
    
        qDebug() << "CMAC_Update failed.";
        CMAC_CTX_free(ctx);
        return result;
    }

    // Finalize CMAC calculation
    unsigned char mac[AES_BLOCK_SIZE];
    size_t macLength;
    if (CMAC_Final(ctx, mac, &macLength) != 1) {
    
    
        qDebug() << "CMAC_Final failed.";
        CMAC_CTX_free(ctx);
        return result;
    }
    // Convert the result to QByteArray
    result = QByteArray(reinterpret_cast<char*>(mac), macLength);
    // Free the CMAC context
    CMAC_CTX_free(ctx);
    QFileInfo fileInfo(filePath);
    QString newFilePath = fileInfo.path() + "/" + fileInfo.baseName() + ".security." + fileInfo.suffix();
    if (!QFile::copy(filePath, newFilePath)) {
    
    
            qDebug() << "Failed to create a copy of the original file:" << filePath;
    }
    QFile copiedFile(newFilePath);
    if (!copiedFile.open(QIODevice::Append)) {
    
    
        qDebug() << "Failed to open copied file for appending:" << newFilePath;
    }
    // Append the result to the copied file
    copiedFile.write(result);
    copiedFile.close();
    qDebug() << "CMAC result appended to the copied file and saved to:" << newFilePath;
    ui->textEdit->setText(result.toHex());
    QFileInfo fileInf(filePath);
       QString newFile = fileInf.path() + "/" + fileInf.baseName() + "_reversedData." + fileInf.suffix();
       QFile reversedDataFile(newFile);
       if (reversedDataFile.open(QIODevice::WriteOnly)) {
    
    
           reversedDataFile.write(reversedData);
           reversedDataFile.close();
           qDebug() << "Reversed data written to the new file:" << newFilePath;
       } else {
    
    
           qDebug() << "Failed to open the new file for writing:" << newFilePath;
       }
    return result;
}

PS : à la recherche d'un grand gars en ligne qui connaît les algorithmes de cryptage

Je veux poser quelques questions