InvalidCiphertext исключение

Ваша главная проблема, кажется, заключается в использовании getline с '\0' разделитель в Decryption(), Это может работать для простого текста в Encryption() если он не содержит нулевых символов, но очень вероятно, что зашифрованный текст будет пронизан '\0'с повсюду.

Похоже, что вы правильно определили, что зашифрованный файл содержит двоичные данные, но вам необходимо прочитать их как таковые, например, с помощью std::ifstream::read или же std::istreambuf_iterator.

Я обновил ваш пример кода ниже:

#include "windows.h"
#include <algorithm>  // for std::copy
#include <fstream>
#include <iostream>
#include <iterator>  // for std::istreambuf_iterator
#include <string>

#ifdef _MSC_VER
#  pragma warning(push)
#  pragma warning(disable: 4100 4127 4189 4244)
#endif
#include "cryptopp/aes.h"#include "cryptopp/config.h"#include "cryptopp/files.h"#include "cryptopp/filters.h"#include "cryptopp/modes.h"#ifdef _MSC_VER
#  pragma warning(pop)
#endif

namespace {
const std::string original_file("original.txt");
const std::string encrypted_file("encrypted.txt");
const std::string decrypted_file("decrypted.txt");
const int key_size(CryptoPP::AES::DEFAULT_KEYLENGTH);
const int iv_size(CryptoPP::AES::BLOCKSIZE);
}

void GetKeyAndIv(byte* key, byte* iv) {
HW_PROFILE_INFOA profile;
GetCurrentHwProfileA(&profile);
char* guid(profile.szHwProfileGuid);
assert(std::char_traits<char>::length(guid) >= key_size + iv_size);
// Assign first 'key_size' chars of GUID to 'key'
std::copy(guid, guid + key_size, key);
// Assign next 'iv_size' chars of GUID to 'iv'
std::copy(guid + key_size, guid + key_size + iv_size, iv);
};

void Encrypt() {
// Initialise the key and IV
byte key[key_size] = {0}, iv[iv_size] = {0};
GetKeyAndIv(key, iv);

// Read the file contents to a string and output to cout.  Safest to read
// contents as binary data, although non-printable characters shouldn't be
// output to cout.
std::ifstream infile(original_file.c_str(), std::ios::binary);
const std::string plaintext((std::istreambuf_iterator<char>(infile)),
std::istreambuf_iterator<char>());
infile.close();
std::cout << "Plain Text (" << plaintext.size() << " bytes)\n"<< plaintext << "\n\n";

// Encrypt
CryptoPP::AES::Encryption cipher(key, key_size);
CryptoPP::CBC_Mode_ExternalCipher::Encryption encryption(cipher, iv);
std::string cipher_text;
CryptoPP::StreamTransformationFilter filter(encryption,
new CryptoPP::StringSink(cipher_text));
filter.Put(reinterpret_cast<const byte*>(plaintext.c_str()), plaintext.size());
filter.MessageEnd();

// Dump cipher text
std::ofstream outfile(encrypted_file.c_str(), std::ios::binary);
outfile.write(cipher_text.c_str(), cipher_text.size());
outfile.close();
}

void Decrypt() {
// Initialise the key and IV
byte key[key_size] = {0}, iv[iv_size] = {0};
GetKeyAndIv(key, iv);

// Read the encrypted file contents to a string as binary data.
std::ifstream infile(encrypted_file.c_str(), std::ios::binary);
const std::string cipher_text((std::istreambuf_iterator<char>(infile)),
std::istreambuf_iterator<char>());
infile.close();

// Decrypt
CryptoPP::AES::Decryption cipher(key, key_size);
CryptoPP::CBC_Mode_ExternalCipher::Decryption decryption(cipher, iv);
std::string decrypted_test;
CryptoPP::StreamTransformationFilter filter(decryption,
new CryptoPP::StringSink(decrypted_test));
filter.Put(reinterpret_cast<const byte*>(cipher_text.c_str()),
cipher_text.size());
filter.MessageEnd();

// Dump decrypted text
std::ofstream outfile(decrypted_file.c_str(), std::ios::binary);
outfile.write(decrypted_test.c_str(), decrypted_test.size());
outfile.close();
}

int main() {
try {
Encrypt();
Decrypt();
}
catch(const CryptoPP::Exception& exception) {
std::cout << "Caught exception: " << exception.what() << '\n';
return -1;
}
return 0;
}

Еще более простой вариант — использовать CryptoPP FileSource а также FileSink классы, чтобы избежать чтения / записи файлов вручную:

void Encrypt() {
byte key[key_size] = {0}, iv[iv_size] = {0};
GetKeyAndIv(key, iv);
CryptoPP::CBC_Mode<CryptoPP::AES>::Encryption encryption;
encryption.SetKeyWithIV(key, key_size, iv, iv_size);
CryptoPP::FileSource file_source(original_file.c_str(), true,
new CryptoPP::StreamTransformationFilter(encryption,
new CryptoPP::FileSink(encrypted_file.c_str())));
}

void Decrypt() {
byte key[key_size] = {0}, iv[iv_size] = {0};
GetKeyAndIv(key, iv);
CryptoPP::CBC_Mode<CryptoPP::AES>::Decryption decryption;
decryption.SetKeyWithIV(key, key_size, iv, iv_size);
CryptoPP::FileSource file_source(encrypted_file.c_str(), true,
new CryptoPP::StreamTransformationFilter(decryption,
new CryptoPP::FileSink(decrypted_file.c_str())));
}