char err[130];

ERR_error_string_n(ERR_get_error(), err, sizeof(err));

throw std::runtime_error(err);

try {

RSA* rsa = readPublicKeyFromBuffer(publicKeyStr);

int rsaLen = RSA_size(rsa);

unsigned char* encrypted = new unsigned char[rsaLen];

int result = RSA_public_encrypt(data.size(), reinterpret_cast<const unsigned char*>(data.c_str()), encrypted, rsa, RSA_PKCS1_OAEP_PADDING);

if (result == -1) {

delete[] encrypted;

RSA_free(rsa);

handleOpenSSLErrors();

}

std::string encryptedData(reinterpret_cast<char*>(encrypted), result); // this is in binary form

// Calculate the size of the encoded data

std::string encryptedEncodedData;

encryptedEncodedData.resize(boost::beast::detail::base64::encoded_size(encryptedData.size()));

// Encode the binary data using Base64

const auto encoded = boost::beast::detail::base64::encode(&encryptedEncodedData[0], encryptedData.data(), encryptedData.size());

encryptedEncodedData.resize(encoded);

delete[] encrypted;

RSA_free(rsa);

return encryptedEncodedData;

} catch (const std::exception& e) {

throw std::runtime_error(e.what());

}

try {

// Decode the Base64 encoded data

std::string encryptedData;

encryptedData.resize(boost::beast::detail::base64::decoded_size(encryptedEncodedData.size()));

const auto decoded = boost::beast::detail::base64::decode(&encryptedData[0], encryptedEncodedData.data(), encryptedEncodedData.size());

encryptedData.resize(decoded.first);

RSA* rsa = readPrivateKeyFromBuffer(privateKeyStr);

int rsaLen = RSA_size(rsa);

unsigned char* decrypted = new unsigned char[rsaLen];

int result = RSA_private_decrypt(encryptedData.size(), reinterpret_cast<const unsigned char*>(encryptedData.c_str()), decrypted, rsa, RSA_PKCS1_OAEP_PADDING);

if (result == -1) {

delete[] decrypted;

RSA_free(rsa);

handleOpenSSLErrors();

}

std::string decryptedData(reinterpret_cast<char*>(decrypted), result);

delete[] decrypted;

RSA_free(rsa);

return decryptedData;

} catch (const std::exception& e) {

throw std::runtime_error(e.what());

}