Comment chiffrer des données en code C++ ?

Comment chiffrer des données en code C++ ?

Avec le développement rapide d'Internet et la maturité croissante des technologies de l'information, la sécurité des données est devenue de plus en plus importante. En programmation, il est très important de protéger la sécurité des données et d’empêcher tout accès illégal ou toute falsification des données. Cet article explique comment utiliser le code C++ pour crypter et déchiffrer les données afin de garantir la sécurité des données.

1. Utiliser l'algorithme de cryptage par clé

L'algorithme de cryptage par clé est un algorithme de cryptage symétrique couramment utilisé qui utilise la même clé pour le cryptage et le déchiffrement des données. En C++, vous pouvez utiliser certaines bibliothèques de chiffrement open source (telles que OpenSSL) pour implémenter des algorithmes de chiffrement à clé. Vous trouverez ci-dessous un exemple de code qui utilise l'algorithme AES pour crypter et déchiffrer les données :

#include <openssl/aes.h>
#include <string>

std::string encryptAES(std::string data, std::string key) {
    AES_KEY aesKey;
    AES_set_encrypt_key((const unsigned char*)key.c_str(), 128, &aesKey);

    std::string encryptedData;
    encryptedData.resize(data.size() + AES_BLOCK_SIZE);

    unsigned char iv[AES_BLOCK_SIZE];
    memset(iv, 0, sizeof(iv));

    AES_cbc_encrypt((const unsigned char*)data.c_str(),
                    (unsigned char*)encryptedData.data(),
                    data.size(),
                    &aesKey,
                    iv,
                    AES_ENCRYPT);

    return encryptedData;
}

std::string decryptAES(std::string encryptedData, std::string key) {
    AES_KEY aesKey;
    AES_set_decrypt_key((const unsigned char*)key.c_str(), 128, &aesKey);

    std::string decryptedData;
    decryptedData.resize(encryptedData.size());

    unsigned char iv[AES_BLOCK_SIZE];
    memset(iv, 0, sizeof(iv));

    AES_cbc_encrypt((const unsigned char*)encryptedData.c_str(),
                    (unsigned char*)decryptedData.data(),
                    encryptedData.size(),
                    &aesKey,
                    iv,
                    AES_DECRYPT);

    return decryptedData;
}

Le code ci-dessus utilise l'algorithme AES pour prendre les données et les clés en entrée, puis effectue des opérations de cryptage et de décryptage et renvoie les résultats cryptés/déchiffrés. En utilisation réelle, vous devez garantir la sécurité de la clé et ne pas la stocker ni la transmettre en texte brut.

2. Utiliser un algorithme de cryptage asymétrique

L'algorithme de cryptage asymétrique est un algorithme qui utilise différentes clés pour le cryptage et le déchiffrement. Les algorithmes de cryptage asymétriques courants incluent RSA et ECC. En C++, vous pouvez utiliser certaines bibliothèques de chiffrement open source (telles que Crypto++) pour implémenter des algorithmes de chiffrement asymétriques. Vous trouverez ci-dessous un exemple de code qui utilise l'algorithme RSA pour crypter et déchiffrer les données :

#include <cryptopp/rsa.h>
#include <cryptopp/osrng.h>
#include <cryptopp/base64.h>
#include <string>

std::string encryptRSA(std::string data, std::string publicKey) {
    CryptoPP::RSA::PublicKey rsaPublicKey;
    CryptoPP::Base64Decoder base64Decoder;

    base64Decoder.Attach(new CryptoPP::StringSink(publicKey), false);
    rsaPublicKey.Load(base64Decoder);

    CryptoPP::AutoSeededRandomPool rng;
    std::string encryptedData;

    CryptoPP::RSAES_OAEP_SHA_Encryptor encryptor(rsaPublicKey);
    CryptoPP::StringSource(data,
                           true,
                           new CryptoPP::PK_EncryptorFilter(rng,
                                                            encryptor,
                                                            new CryptoPP::StringSink(encryptedData)));

    return encryptedData;
}

std::string decryptRSA(std::string encryptedData, std::string privateKey) {
    CryptoPP::RSA::PrivateKey rsaPrivateKey;
    CryptoPP::Base64Decoder base64Decoder;

    base64Decoder.Attach(new CryptoPP::StringSink(privateKey), false);
    rsaPrivateKey.Load(base64Decoder);

    CryptoPP::AutoSeededRandomPool rng;
    std::string decryptedData;

    CryptoPP::RSAES_OAEP_SHA_Decryptor decryptor(rsaPrivateKey);
    CryptoPP::StringSource(encryptedData,
                           true,
                           new CryptoPP::PK_DecryptorFilter(rng,
                                                            decryptor,
                                                            new CryptoPP::StringSink(decryptedData)));

    return decryptedData;
}

Le code ci-dessus utilise l'algorithme RSA pour prendre les données et les clés publiques/privées en entrée, puis effectue les opérations de cryptage et de décryptage et renvoie les informations cryptées/déchiffrées. résultats. La clé publique est généralement utilisée pour chiffrer les données et la clé privée pour déchiffrer les données. En utilisation réelle, il est nécessaire d'assurer la sécurité de la clé privée et de ne pas la divulguer.

3. Contrôle de l'intégrité des données

Dans le processus de cryptage des données, l'intégrité des données doit également être prise en compte. La vérification de l'intégrité des données ajoute un code de contrôle aux données pour garantir que les données n'ont pas été falsifiées pendant la transmission. Les algorithmes courants de vérification de l’intégrité des données incluent les algorithmes CRC et Hash. En C++, vous pouvez utiliser certaines bibliothèques de vérification open source (telles que Crypto++) pour implémenter la vérification de l'intégrité des données. Voici un exemple de code qui utilise l'algorithme de hachage pour calculer le code de contrôle des données :

#include <cryptopp/sha.h>
#include <cryptopp/hex.h>
#include <string>

std::string calculateHash(std::string data) {
    CryptoPP::SHA256 hash;
    std::string hashValue;

    CryptoPP::StringSource(data,
                           true,
                           new CryptoPP::HashFilter(hash,
                                                    new CryptoPP::HexEncoder(new CryptoPP::StringSink(hashValue))));

    return hashValue;
}

Le code ci-dessus utilise l'algorithme SHA256 pour calculer le code de contrôle des données et renvoie la représentation hexadécimale du code de contrôle. Une fois le code de contrôle calculé, il est transmis ou stocké avec les données. Le récepteur calcule à nouveau le code de contrôle après avoir reçu les données et le compare avec le code de contrôle reçu. Si les deux sont cohérents, les données n'ont pas été falsifiées. .

Résumé :

Cet article explique comment utiliser le code C++ pour crypter et déchiffrer des données, et comment effectuer une vérification de l'intégrité des données. Dans les applications pratiques, des algorithmes de chiffrement et des algorithmes de vérification appropriés peuvent être sélectionnés en fonction des besoins réels, et la sécurité des clés et des clés privées peut être assurée pour garantir la sécurité et l'intégrité des données. Lors de la transmission ou du stockage des données, d'autres mesures de sécurité (telles que les protocoles SSL/TLS) peuvent également être combinées pour améliorer encore la sécurité des données.

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!