The "Programming for Everyone" forum is a welcoming space for anyone eager to learn programming, regardless of skill level. Find resources, engage in discussions, and get support from fellow coders!
https://syntaxerror.site/
Code: Select all
#include <openssl/aes.h>
#include <openssl/rand.h>
#include <fstream>
#include <iostream>
#include <vector>
void handleErrors() {
ERR_print_errors_fp(stderr);
abort();
}
void encrypt(const std::vector<unsigned char>& key, const std::string& input_file, const std::string& output_file) {
AES_KEY encryptKey;
AES_set_encrypt_key(key.data(), 128, &encryptKey);
std::ifstream infile(input_file, std::ios::binary);
std::ofstream outfile(output_file, std::ios::binary);
unsigned char buffer[16];
while (infile.read(reinterpret_cast<char*>(buffer), sizeof(buffer))) {
unsigned char out[16];
AES_encrypt(buffer, out, &encryptKey);
outfile.write(reinterpret_cast<char*>(out), sizeof(out));
}
}
int main() {
std::vector<unsigned char> key(16); // 128-bit key
if (!RAND_bytes(key.data(), key.size())) handleErrors();
std::string input_file = "input.txt";
std::string output_file = "encrypted.dat";
encrypt(key, input_file, output_file);
std::cout << "File encrypted successfully!" << std::endl;
return 0;
}
Code: Select all
#include <sodium.h>
#include <iostream>
#include <fstream>
#include <vector>
void handleErrors() {
std::cerr << "Error occurred!" << std::endl;
exit(EXIT_FAILURE);
}
void encrypt(const std::string& input_file, const std::string& output_file, const unsigned char* key) {
std::ifstream infile(input_file, std::ios::binary);
std::ofstream outfile(output_file, std::ios::binary);
if (!infile.is_open() || !outfile.is_open()) {
handleErrors();
}
// Generate a nonce
unsigned char nonce[crypto_secretbox_NONCEBYTES];
if (crypto_generichash(nonce, sizeof nonce, nullptr, 0, key, crypto_secretbox_KEYBYTES) != 0) {
handleErrors();
}
outfile.write(reinterpret_cast<const char*>(nonce), crypto_secretbox_NONCEBYTES); // Write nonce to the output file
std::vector<unsigned char> buffer(4096);
while (infile.read(reinterpret_cast<char*>(buffer.data()), buffer.size()) || infile.gcount()) {
size_t bytes_read = infile.gcount();
std::vector<unsigned char> ciphertext(bytes_read + crypto_secretbox_MACBYTES);
// Encrypt
if (crypto_secretbox_easy(ciphertext.data(), buffer.data(), bytes_read, nonce, key) != 0) {
handleErrors();
}
// Write ciphertext to the output file
outfile.write(reinterpret_cast<const char*>(ciphertext.data()), ciphertext.size());
}
}
void decrypt(const std::string& input_file, const std::string& output_file, const unsigned char* key) {
std::ifstream infile(input_file, std::ios::binary);
std::ofstream outfile(output_file, std::ios::binary);
if (!infile.is_open() || !outfile.is_open()) {
handleErrors();
}
// Read nonce from the input file
unsigned char nonce[crypto_secretbox_NONCEBYTES];
infile.read(reinterpret_cast<char*>(nonce), crypto_secretbox_NONCEBYTES);
std::vector<unsigned char> buffer(4096);
while (infile.read(reinterpret_cast<char*>(buffer.data()), buffer.size()) || infile.gcount()) {
size_t bytes_read = infile.gcount();
std::vector<unsigned char> decrypted(bytes_read - crypto_secretbox_MACBYTES);
// Decrypt
if (crypto_secretbox_open_easy(decrypted.data(), buffer.data(), bytes_read, nonce, key) != 0) {
handleErrors();
}
// Write decrypted data to the output file
outfile.write(reinterpret_cast<const char*>(decrypted.data()), decrypted.size());
}
}
int main() {
// Initialize Libsodium
if (sodium_init() == -1) {
return 1;
}
// Generate a random key
unsigned char key[crypto_secretbox_KEYBYTES];
if (sodium_mlock(key, sizeof key) != 0) {
handleErrors();
}
// Replace this part with secure key storage/retrieval
randombytes_buf(key, sizeof key);
// Encrypt the file
encrypt("input.txt", "encrypted.dat", key);
std::cout << "File encrypted successfully!" << std::endl;
// Decrypt the file
decrypt("encrypted.dat", "decrypted.txt", key);
std::cout << "File decrypted successfully!" << std::endl;
return 0;
}
Code: Select all
#include <cryptlib.h>
#include <aes.h>
#include <modes.h>
#include <filters.h>
#include <files.h>
#include <osrng.h>
#include <hex.h>
#include <iostream>
#include <string>
using namespace CryptoPP;
void handleErrors() {
std::cerr << "Error occurred!" << std::endl;
exit(EXIT_FAILURE);
}
void encrypt(const std::string& input_file, const std::string& output_file, const SecByteBlock& key) {
// Generate a random initialization vector (IV)
byte iv[AES::BLOCKSIZE];
AutoSeededRandomPool prng;
prng.GenerateBlock(iv, sizeof(iv));
// Write IV to the output file
FileSink fileSink(output_file.c_str());
fileSink.Put(iv, sizeof(iv));
// Encryption
try {
CBC_Mode<AES>::Encryption encryptor(key, key.size(), iv);
FileSource fileSource(input_file.c_str(), true,
new StreamTransformationFilter(encryptor,
new Redirector(fileSink)
)
);
} catch (const Exception& e) {
handleErrors();
}
}
void decrypt(const std::string& input_file, const std::string& output_file, const SecByteBlock& key) {
// Read IV from the input file
byte iv[AES::BLOCKSIZE];
FileSource fileSource(input_file.c_str(), true);
fileSource.Pump(iv, sizeof(iv));
// Decryption
try {
CBC_Mode<AES>::Decryption decryptor(key, key.size(), iv);
FileSink fileSink(output_file.c_str());
fileSource.Attach(new StreamTransformationFilter(decryptor,
new Redirector(fileSink)
));
} catch (const Exception& e) {
handleErrors();
}
}
int main() {
// Generate a random key
AutoSeededRandomPool prng;
SecByteBlock key(AES::DEFAULT_KEYLENGTH);
prng.GenerateBlock(key, key.size());
// Input file names
std::string input_file = "input.txt";
std::string encrypted_file = "encrypted.dat";
std::string decrypted_file = "decrypted.txt";
// Encrypt the file
encrypt(input_file, encrypted_file, key);
std::cout << "File encrypted successfully!" << std::endl;
// Decrypt the file
decrypt(encrypted_file, decrypted_file, key);
std::cout << "File decrypted successfully!" << std::endl;
return 0;
}