Как шифровать данные в c++?

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

#include 

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

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

    std::string cipherText;
    const size_t length = plainText.length();

    for (size_t i = 0; i < length; i += AES_BLOCK_SIZE) {
        unsigned char inBlock[AES_BLOCK_SIZE];
        unsigned char outBlock[AES_BLOCK_SIZE];

        memset(inBlock, 0x00, AES_BLOCK_SIZE);

        size_t blockSize = std::min(AES_BLOCK_SIZE, length - i);
        memcpy(inBlock, plainText.c_str() + i, blockSize);

        AES_encrypt(inBlock, outBlock, &aesKey);

        cipherText.append((char*)outBlock, AES_BLOCK_SIZE);
    }

    return cipherText;
}

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

    std::string plainText;
    const size_t length = cipherText.length();

    for (size_t i = 0; i < length; i += AES_BLOCK_SIZE) {
        unsigned char inBlock[AES_BLOCK_SIZE];
        unsigned char outBlock[AES_BLOCK_SIZE];

        memset(inBlock, 0x00, AES_BLOCK_SIZE);

        memcpy(inBlock, cipherText.c_str() + i, AES_BLOCK_SIZE);

        AES_decrypt(inBlock, outBlock, &aesKey);

        plainText.append((char*)outBlock, AES_BLOCK_SIZE);
    }

    return plainText;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

#include 
#include 
#include 
#include 

std::string encryptRSA(const std::string& plainText, const CryptoPP::RSA::PublicKey& publicKey) {
    CryptoPP::AutoSeededRandomPool rng;

    CryptoPP::RSAES_OAEP_SHA_Encryptor encryptor(publicKey);
    std::string cipherText;

    CryptoPP::StringSource(plainText, true,
        new CryptoPP::PK_EncryptorFilter(rng, encryptor,
            new CryptoPP::StringSink(cipherText)
        )
    );

    return cipherText;
}

std::string decryptRSA(const std::string& cipherText, const CryptoPP::RSA::PrivateKey& privateKey) {
    CryptoPP::AutoSeededRandomPool rng;

    CryptoPP::RSAES_OAEP_SHA_Decryptor decryptor(privateKey);
    std::string recoveredText;

    CryptoPP::StringSource(cipherText, true,
        new CryptoPP::PK_DecryptorFilter(rng, decryptor,
            new CryptoPP::StringSink(recoveredText)
        )
    );

    return recoveredText;
}

int main() {
    CryptoPP::AutoSeededRandomPool rng;

    CryptoPP::RSA::PrivateKey privateKey;
    privateKey.GenerateRandomWithKeySize(rng, 1024);

    CryptoPP::RSA::PublicKey publicKey(privateKey);

    std::string plainText = "Hello, world!";
    std::string cipherText = encryptRSA(plainText, publicKey);

    std::cout << "Cipher text: " << CryptoPP::base64_encode((const unsigned char*)cipherText.c_str(), cipherText.length()) << std::endl;

    std::string recoveredText = decryptRSA(cipherText, privateKey);

    std::cout << "Recovered text: " << recoveredText << std::endl;

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include 
#include 
#include 

std::string hashSHA256(const std::string& input) {
    CryptoPP::SHA256 hash;
    std::string digest;

    CryptoPP::StringSource(input, true,
        new CryptoPP::HashFilter(hash,
            new CryptoPP::StringSink(digest)
        )
    );

    return digest;
}

int main() {
    std::string input = "Hello, world!";
    std::string hash = hashSHA256(input);

    std::cout << "SHA-256 hash: " << CryptoPP::HexEncoder(new CryptoPP::StringSink(std::cout)).Put((const unsigned char*)hash.c_str(), hash.length()) << std::endl;

    return 0;
}