void signature_sign(const string & account_num, string & signature){
// Setup
string message = account_num;
RSA::PrivateKey privateKey;
AutoSeededRandomPool rng;
// Load private key
CryptoPP::ByteQueue bytes;
FileSource file("privkey.txt", true, new Base64Decoder);
file.TransferTo(bytes);
bytes.MessageEnd();
privateKey.Load(bytes);
// Sign and Encode
RSASS<PSSR, SHA1>::Signer signer(privateKey);
// StringSource
StringSource(message, true,
new SignerFilter(rng, signer,
new StringSink(signature),
true // putMessage
) // SignerFilter
);
}
void Sign(string str){
// string strContents = "A message to be signed";
string strContents = str;
//FileSource("tobesigned.dat", true, new StringSink(strContents));
AutoSeededRandomPool rng;
//Read private key
CryptoPP::ByteQueue bytes;
FileSource file("privkey.txt", true, new Base64Decoder);
file.TransferTo(bytes);
bytes.MessageEnd();
RSA::PrivateKey privateKey;
privateKey.Load(bytes);
//Sign message
RSASSA_PKCS1v15_SHA_Signer privkey(privateKey);
SecByteBlock sbbSignature(privkey.SignatureLength());
privkey.SignMessage( rng, (byte const*) strContents.data(), strContents.size(), sbbSignature);
//Save result
FileSink sink("message.dat"); //c
sink.Put((byte const*) strContents.data(), strContents.size());
FileSink sinksig("cipher.dat"); //m
sinksig.Put(sbbSignature, sbbSignature.size());
}
size_t CreateSignature(const unsigned char* data, size_t dlen, unsigned char* privateKey, unsigned char* signature) {
RSA::PrivateKey key;
uint32_t len;
memcpy(&len,privateKey,4);
privateKey+=4;
key.SetModulus(Integer(privateKey,len));
privateKey+=len;
memcpy(&len,privateKey,4);
privateKey+=4;
key.SetPublicExponent(Integer(privateKey,len));
privateKey+=len;
memcpy(&len,privateKey,4);
privateKey+=4;
key.SetPrivateExponent(Integer(privateKey,len));
RSASSA_PKCS1v15_SHA_Signer signer(key);
size_t mlen = signer.MaxSignatureLength();
bool rst = false;
if (signature == 0) {
signature = new unsigned char[mlen];
rst = true;
}
AutoSeededRandomPool generator;
size_t retval = signer.SignMessage(generator, data, dlen, signature);
if (rst) {
delete[] signature;
}
return retval;
}
std::string DecryptAsymmetrical(const std::string& privKey, const std::string& data) {
assert(!data.empty());
string result;
AutoSeededRandomPool rng;
RSA::PrivateKey privateKey;
privateKey.Load(StringSource(privKey, true).Ref());
RSAES_OAEP_SHA_Decryptor d(privateKey);
ui32 blocksCount = *(ui16*)data.data();
const char* ptr = data.data() + 2;
for (size_t i = 0; i < blocksCount; ++i) {
ui16 blockSize = *(ui16*)ptr;
ptr += 2;
string currData = string(ptr, blockSize);
ptr += blockSize;
string currResult;
StringSource ss(currData, true,
new PK_DecryptorFilter(rng, d,
new StringSink(currResult)));
result += currResult;
}
assert(!result.empty());
return result;
}
void PrintPrivateKey(const RSA::PrivateKey& key)
{
cout << "n: " << key.GetModulus() << endl;
cout << "d: " << key.GetPrivateExponent() << endl;
cout << "e: " << key.GetPublicExponent() << endl;
cout << "p: " << key.GetPrime1() << endl;
cout << "q: " << key.GetPrime2() << endl;
}
std::string Sign(const std::string& privKey, const std::string& message) {
AutoSeededRandomPool rng;
string signature;
RSA::PrivateKey privateKey;
privateKey.Load(StringSource(privKey, true).Ref());
RSASSA_PKCS1v15_SHA_Signer signer(privateKey);
StringSource(message, true,
new SignerFilter(rng, signer,
new StringSink(signature)));
return signature;
}
static bool DecodeFromFile(const char* filename, RSA::PrivateKey& key)
{
try {
ByteQueue queue;
FileSource file(filename, true);
file.TransferTo(queue);
queue.MessageEnd();
key.BERDecodePrivateKey(queue, false, queue.MaxRetrievable());
return key.Validate(rng, 3);
} catch (...) {
return false;
}
}
string SignLicense(AutoSeededRandomPool &rng, string strContents, string pass)
{
//Read private key
string encPrivKey;
StringSink encPrivKeySink(encPrivKey);
FileSource file("secondary-privkey-enc.txt", true, new Base64Decoder);
file.CopyTo(encPrivKeySink);
//Read initialization vector
byte iv[AES::BLOCKSIZE];
CryptoPP::ByteQueue bytesIv;
FileSource file2("secondary-privkey-iv.txt", true, new Base64Decoder);
file2.TransferTo(bytesIv);
bytesIv.MessageEnd();
bytesIv.Get(iv, AES::BLOCKSIZE);
//Hash the pass phrase to create 128 bit key
string hashedPass;
RIPEMD128 hash;
StringSource(pass, true, new HashFilter(hash, new StringSink(hashedPass)));
//Decrypt private key
byte test[encPrivKey.length()];
CFB_Mode<AES>::Decryption cfbDecryption((const unsigned char*)hashedPass.c_str(), hashedPass.length(), iv);
cfbDecryption.ProcessData(test, (byte *)encPrivKey.c_str(), encPrivKey.length());
StringSource privateKeySrc(test, encPrivKey.length(), true, NULL);
//Decode key
RSA::PrivateKey privateKey;
privateKey.Load(privateKeySrc);
//Sign message
RSASSA_PKCS1v15_SHA_Signer privkey(privateKey);
SecByteBlock sbbSignature(privkey.SignatureLength());
privkey.SignMessage(
rng,
(byte const*) strContents.data(),
strContents.size(),
sbbSignature);
//Save result
string out;
Base64Encoder enc(new StringSink(out));
enc.Put(sbbSignature, sbbSignature.size());
enc.MessageEnd();
return out;
}
void loadRSAPriKey(RSA::PrivateKey& key, const char* filename){
ByteQueue byte;
FileSource file(filename, true, new Base64Decoder);
file.TransferTo(byte);
byte.MessageEnd();
key.Load(byte);
}
void LoadKey(const char* file, RSA::PrivateKey& key)
{
ByteQueue q;
FileSource KeyFile(file, true, new Base64Decoder());
KeyFile.TransferTo(q);
key.BERDecodePrivateKey(q,false,0); // last 2 params unused
}
void LoadKey(const string& filename, RSA::PrivateKey& PrivateKey)
{
// DER Encode Key - PKCS #8 key format
PrivateKey.Load(
FileSource(filename.c_str(), true, NULL, true /*binary*/).Ref()
);
}
void SaveKey(const RSA::PrivateKey& PrivateKey, const string& filename)
{
// DER Encode Key - PKCS #8 key format
PrivateKey.Save(
FileSink(filename.c_str(), true /*binary*/).Ref()
);
}
static void printPrivateKey(RSA::PrivateKey key)
{
///////////////////////////////////////
// Generated Parameters
const Integer& n = key.GetModulus();
const Integer& p = key.GetPrime1();
const Integer& q = key.GetPrime2();
const Integer& d = key.GetPrivateExponent();
const Integer& e = key.GetPublicExponent();
cout << "RSA Parameters:" << endl;
cout << " n: " << n << endl;
cout << " p: " << p << endl;
cout << " q: " << q << endl;
cout << " d: " << d << endl;
cout << " e: " << e << endl;
cout << endl;
}
extern "C" int rsa_pss_sign(const char *key_file, const unsigned char *msg,
int len, unsigned char *sig_buf, unsigned char *modulus_buf)
{
try {
AutoSeededRandomPool rng;
FileSource file(key_file, true);
RSA::PrivateKey key;
ByteQueue bq;
// Load the key
file.TransferTo(bq);
bq.MessageEnd();
key.BERDecodePrivateKey(bq, false, bq.MaxRetrievable());
// Write the modulus
Integer mod = key.GetModulus();
// error check
if (mod.ByteCount() != RCM_RSA_MODULUS_SIZE)
throw std::length_error("incorrect rsa key modulus length");
for (int i = 0; i < mod.ByteCount(); i++)
modulus_buf[i] = mod.GetByte(i);
// Sign the message
RSASS<PSS, SHA256>::Signer signer(key);
size_t length = signer.MaxSignatureLength();
SecByteBlock signature(length);
length = signer.SignMessage(rng, msg, len, signature);
// Copy in reverse order
for (int i = 0; i < length; i++)
sig_buf[length - i - 1] = signature[i];
}
catch(const CryptoPP::Exception& e) {
cerr << e.what() << endl;
return 1;
}
catch(std::length_error& le) {
cerr << "Error: " << le.what() << endl;
return 1;
}
return 0;
}
/*
* generate the RSA public key and private key in separate file
*/
void MyRSA::GenerateRSAKey(unsigned int keyLength, const char *privFilename,
const char *pubFilename)
{ AutoSeededRandomPool rng;
RSA::PrivateKey priv;
priv.GenerateRandomWithKeySize(rng, 1024);
if (!priv.Validate(rng, 3))
{
throw("RSA key generation failed");
}
HexEncoder privFile(new FileSink(privFilename));
priv.DEREncode(privFile);
privFile.MessageEnd();
RSA::PublicKey pub;
pub.AssignFrom(priv);
HexEncoder pubFile(new FileSink(pubFilename));
pub.DEREncode(pubFile);
pubFile.MessageEnd();
}
std::string BCipher::signature(std::string content){
std::string keyfile,signature,cipher1;
std::cout<<"Begin to implement digital signature"<<std::endl;
RSA::PrivateKey rsaPrivate;
std::cout<<"Signature by sender's private key"<<std::endl;
{
FileSource input("sender_private.dat", true);
rsaPrivate.BERDecode(input);
}
RSASSA_PKCS1v15_SHA_Signer signer(rsaPrivate);
AutoSeededRandomPool rng;
StringSource ss3(content, true,
new SignerFilter(rng, signer,
new StringSink(cipher1)
) // SignerFilter
); // StringSource
std::cout<<"Sending files to cloud server"<<std::endl;
return cipher1;
}
extern "C" int rsa_pss_sign_file(const char *key_file, const char *msg_file,
unsigned char *sig_buf)
{
try {
AutoSeededRandomPool rng;
FileSource file(key_file, true);
RSA::PrivateKey key;
ByteQueue bq;
// Load the key
file.TransferTo(bq);
bq.MessageEnd();
key.BERDecodePrivateKey(bq, false, bq.MaxRetrievable());
// Sign the message
RSASS<PSS, SHA256>::Signer signer(key);
string signature;
FileSource src(msg_file, true,
new SignerFilter(rng, signer,
new StringSink(signature)));
int length = signature.length();
// error check
if (length != RCM_RSA_SIG_SIZE)
throw std::length_error("incorrect rsa key length");
// Copy in reverse order
for (int i = 0; i < length; i++)
sig_buf[length - i - 1] = signature[i];
}
catch(const CryptoPP::Exception& e) {
cerr << e.what() << endl;
return 1;
}
catch(std::length_error& le) {
cerr << "Error: " << le.what() << endl;
return 1;
}
return 0;
}
int
main(int argc, char ** argv)
{
if (argc != 2) {
cout << "Usage: keygen <outputname>" << endl;
return -1;
}
AutoSeededRandomPool rng;
InvertibleRSAFunction params;
params.GenerateRandomWithKeySize(rng, 3072);
RSA::PublicKey pubkey(params);
RSA::PrivateKey privkey(params);
Integer m = params.GetModulus();
Integer p = params.GetModulus();
Integer q = params.GetModulus();
Integer priv = params.GetPrivateExponent();
Integer pub = params.GetPublicExponent();
string privname = string(argv[1]).append(".priv");
string pubname = string(argv[1]).append(".pub");
CryptoEngine::pubkeyToFile(pubkey, pubname);
CryptoEngine::privkeyToFile(privkey, privname);
cout << "Loading and verifying..." << endl;
RSA::PrivateKey newpriv = CryptoEngine::privkeyFromFile(privname);
RSA::PublicKey newpub = CryptoEngine::pubkeyFromFile(pubname);
cout << (m == newpriv.GetModulus() ? "TRUE" : "FALSE") << endl;
cout << (priv == newpriv.GetPrivateExponent() ? "TRUE" : "FALSE") << endl;
cout << (pub == newpriv.GetPublicExponent() ? "TRUE" : "FALSE") << endl;
cout << (m == newpub.GetModulus() ? "TRUE" : "FALSE") << endl;
cout << (pub == newpub.GetPublicExponent() ? "TRUE" : "FALSE") << endl;
return 0;
}
CppRsaPublicKeyImpl::CppRsaPublicKeyImpl(const QByteArray &data, bool seed) :
m_public_key(new RSA::PublicKey())
{
if(seed) {
RSA::PrivateKey key;
CryptoRandom rand(data);
key.GenerateRandomWithKeySize(GetCppRandom(rand),
RsaPrivateKey::DefaultKeySize());
m_public_key.reset(new RSA::PublicKey(key));
} else {
ByteQueue queue;
queue.Put2(reinterpret_cast<const byte *>(data.data()), data.size(), 0, true);
try {
m_public_key->Load(queue);
} catch (std::exception &e) {
qWarning() << "In CppRsaPublicKey: " << e.what();
m_valid = false;
return;
}
}
m_valid = true;
}
int main (int argc, const char* argv[]) {
string toSign;
FileSource(argv[1], true, new StringSink(toSign));
AutoSeededRandomPool rng;
//Read private key
CryptoPP::ByteQueue bytes;
FileSource file(argv[2], true, new Base64Decoder);
file.TransferTo(bytes);
bytes.MessageEnd();
RSA::PrivateKey privateKey;
privateKey.Load(bytes);
//Sign message
RSASSA_PKCS1v15_SHA_Signer signer(privateKey);
SecByteBlock signature(signer.SignatureLength());
signer.SignMessage(
rng,
(byte const*) toSign.data(),
toSign.size(),
signature);
//Print string of signature
HexEncoder encoder;
string signatureString;
encoder.Put(signature.data(), signature.size());
encoder.MessageEnd();
word64 signatureSize = encoder.MaxRetrievable();
if (signatureSize) {
signatureString.resize(signatureSize);
encoder.Get((byte*) signatureString.data(), signatureString.size());
}
cout << signatureString << endl;
}
int main(int argc, char** argv)
{
std::ios_base::sync_with_stdio(false);
// http://www.cryptopp.com/docs/ref/class_auto_seeded_random_pool.html
AutoSeededRandomPool rnd;
try
{
// http://www.cryptopp.com/docs/ref/rsa_8h.html
RSA::PrivateKey rsaPrivate;
rsaPrivate.GenerateRandomWithKeySize(rnd, 1024);
RSA::PublicKey rsaPublic(rsaPrivate);
if(!rsaPrivate.Validate(rnd, 3)) {
throw runtime_error("Validation failed");
}
SavePrivateKey("rsa-private.key", rsaPrivate);
SavePublicKey("rsa-public.key", rsaPublic);
cout << "Successfully generated and saved RSA keys:" << endl;
cout << "Values:" << endl;
cout << "N: " << rsaPrivate.GetModulus() << endl;
cout << "E: " << rsaPrivate.GetPublicExponent() << endl;
cout << "D: " << rsaPrivate.GetPrivateExponent() << endl;
}
catch(CryptoPP::Exception& e)
{
cerr << e.what() << endl;
return -2;
}
catch(std::exception& e)
{
cerr << e.what() << endl;
return -1;
}
return 0;
}
bool
SecTpm::importPrivateKeyPkcs5IntoTpm(const Name& keyName,
const uint8_t* buf, size_t size,
const std::string& passwordStr)
{
using namespace CryptoPP;
Oid pbes2Id;
Oid pbkdf2Id;
SecByteBlock saltBlock;
uint32_t iterationCount;
Oid pbes2encsId;
SecByteBlock ivBlock;
SecByteBlock encryptedDataBlock;
try {
// decode some decoding processes are not necessary for now,
// because we assume only one encryption scheme.
StringSource source(buf, size, true);
// EncryptedPrivateKeyInfo ::= SEQUENCE {
// encryptionAlgorithm EncryptionAlgorithmIdentifier,
// encryptedData OCTET STRING }
BERSequenceDecoder encryptedPrivateKeyInfo(source);
{
// EncryptionAlgorithmIdentifier ::= SEQUENCE {
// algorithm OBJECT IDENTIFIER {{PBES2-id}},
// parameters SEQUENCE {{PBES2-params}} }
BERSequenceDecoder encryptionAlgorithm(encryptedPrivateKeyInfo);
{
pbes2Id.decode(encryptionAlgorithm);
// PBES2-params ::= SEQUENCE {
// keyDerivationFunc AlgorithmIdentifier {{PBES2-KDFs}},
// encryptionScheme AlgorithmIdentifier {{PBES2-Encs}} }
BERSequenceDecoder pbes2Params(encryptionAlgorithm);
{
// AlgorithmIdentifier ::= SEQUENCE {
// algorithm OBJECT IDENTIFIER {{PBKDF2-id}},
// parameters SEQUENCE {{PBKDF2-params}} }
BERSequenceDecoder pbes2KDFs(pbes2Params);
{
pbkdf2Id.decode(pbes2KDFs);
// AlgorithmIdentifier ::= SEQUENCE {
// salt OCTET STRING,
// iterationCount INTEGER (1..MAX),
// keyLength INTEGER (1..MAX) OPTIONAL,
// prf AlgorithmIdentifier {{PBKDF2-PRFs}} DEFAULT algid-hmacWithSHA1 }
BERSequenceDecoder pbkdf2Params(pbes2KDFs);
{
BERDecodeOctetString(pbkdf2Params, saltBlock);
BERDecodeUnsigned<uint32_t>(pbkdf2Params, iterationCount, INTEGER);
}
pbkdf2Params.MessageEnd();
}
pbes2KDFs.MessageEnd();
// AlgorithmIdentifier ::= SEQUENCE {
// algorithm OBJECT IDENTIFIER {{DES-EDE3-CBC-PAD}},
// parameters OCTET STRING} {{iv}} }
BERSequenceDecoder pbes2Encs(pbes2Params);
{
pbes2encsId.decode(pbes2Encs);
BERDecodeOctetString(pbes2Encs, ivBlock);
}
pbes2Encs.MessageEnd();
}
pbes2Params.MessageEnd();
}
encryptionAlgorithm.MessageEnd();
BERDecodeOctetString(encryptedPrivateKeyInfo, encryptedDataBlock);
}
encryptedPrivateKeyInfo.MessageEnd();
}
catch (const CryptoPP::Exception& e) {
return false;
}
PKCS5_PBKDF2_HMAC<SHA1> keyGenerator;
size_t derivedLen = 24; //For DES-EDE3-CBC-PAD
byte derived[24] = {0};
byte purpose = 0;
try {
keyGenerator.DeriveKey(derived, derivedLen,
purpose,
reinterpret_cast<const byte*>(passwordStr.c_str()), passwordStr.size(),
saltBlock.BytePtr(), saltBlock.size(),
iterationCount);
}
catch (const CryptoPP::Exception& e) {
return false;
}
//decrypt
CBC_Mode< DES_EDE3 >::Decryption d;
d.SetKeyWithIV(derived, derivedLen, ivBlock.BytePtr());
OBufferStream privateKeyOs;
try {
StringSource encryptedSource(encryptedDataBlock.BytePtr(), encryptedDataBlock.size(), true,
new StreamTransformationFilter(d, new FileSink(privateKeyOs)));
}
catch (const CryptoPP::Exception& e) {
return false;
}
if (!importPrivateKeyPkcs8IntoTpm(keyName,
privateKeyOs.buf()->buf(), privateKeyOs.buf()->size()))
return false;
// determine key type
StringSource privateKeySource(privateKeyOs.buf()->buf(), privateKeyOs.buf()->size(), true);
KeyType publicKeyType = KeyType::NONE;
SecByteBlock rawKeyBits;
// PrivateKeyInfo ::= SEQUENCE {
// INTEGER,
// SEQUENCE,
// OCTECT STRING}
BERSequenceDecoder privateKeyInfo(privateKeySource);
{
uint32_t versionNum;
BERDecodeUnsigned<uint32_t>(privateKeyInfo, versionNum, INTEGER);
BERSequenceDecoder sequenceDecoder(privateKeyInfo);
{
Oid keyTypeOid;
keyTypeOid.decode(sequenceDecoder);
if (keyTypeOid == oid::RSA)
publicKeyType = KeyType::RSA;
else if (keyTypeOid == oid::ECDSA)
publicKeyType = KeyType::EC;
else
return false; // Unsupported key type;
}
}
// derive public key
OBufferStream publicKeyOs;
try {
switch (publicKeyType) {
case KeyType::RSA: {
RSA::PrivateKey privateKey;
privateKey.Load(StringStore(privateKeyOs.buf()->buf(), privateKeyOs.buf()->size()).Ref());
RSAFunction publicKey(privateKey);
FileSink publicKeySink(publicKeyOs);
publicKey.DEREncode(publicKeySink);
publicKeySink.MessageEnd();
break;
}
case KeyType::EC: {
ECDSA<ECP, SHA256>::PrivateKey privateKey;
privateKey.Load(StringStore(privateKeyOs.buf()->buf(), privateKeyOs.buf()->size()).Ref());
ECDSA<ECP, SHA256>::PublicKey publicKey;
privateKey.MakePublicKey(publicKey);
publicKey.AccessGroupParameters().SetEncodeAsOID(true);
FileSink publicKeySink(publicKeyOs);
publicKey.DEREncode(publicKeySink);
publicKeySink.MessageEnd();
break;
}
default:
return false;
}
}
catch (const CryptoPP::Exception& e) {
return false;
}
if (!importPublicKeyPkcs1IntoTpm(keyName, publicKeyOs.buf()->buf(), publicKeyOs.buf()->size()))
return false;
return true;
}
void saveRSAPriKey(RSA::PrivateKey& key, const char* filename){
Base64Encoder privateKey(new FileSink(filename));
key.DEREncode(privateKey);
privateKey.MessageEnd();
}
Block
SecTpmFile::signInTpm(const uint8_t* data, size_t dataLength,
const Name& keyName, DigestAlgorithm digestAlgorithm)
{
string keyURI = keyName.toUri();
if (!doesKeyExistInTpm(keyName, KeyClass::PRIVATE))
BOOST_THROW_EXCEPTION(Error("private key doesn't exist"));
try {
using namespace CryptoPP;
AutoSeededRandomPool rng;
// Read public key
shared_ptr<v1::PublicKey> pubkeyPtr;
pubkeyPtr = getPublicKeyFromTpm(keyName);
switch (pubkeyPtr->getKeyType()) {
case KeyType::RSA: {
// Read private key
ByteQueue bytes;
FileSource file(m_impl->transformName(keyURI, ".pri").string().c_str(),
true, new Base64Decoder);
file.TransferTo(bytes);
bytes.MessageEnd();
RSA::PrivateKey privateKey;
privateKey.Load(bytes);
// Sign message
switch (digestAlgorithm) {
case DigestAlgorithm::SHA256: {
RSASS<PKCS1v15, SHA256>::Signer signer(privateKey);
OBufferStream os;
StringSource(data, dataLength,
true,
new SignerFilter(rng, signer, new FileSink(os)));
return Block(tlv::SignatureValue, os.buf());
}
default:
BOOST_THROW_EXCEPTION(Error("Unsupported digest algorithm"));
}
}
case KeyType::EC: {
// Read private key
ByteQueue bytes;
FileSource file(m_impl->transformName(keyURI, ".pri").string().c_str(),
true, new Base64Decoder);
file.TransferTo(bytes);
bytes.MessageEnd();
// Sign message
switch (digestAlgorithm) {
case DigestAlgorithm::SHA256: {
ECDSA<ECP, SHA256>::PrivateKey privateKey;
privateKey.Load(bytes);
ECDSA<ECP, SHA256>::Signer signer(privateKey);
OBufferStream os;
StringSource(data, dataLength,
true,
new SignerFilter(rng, signer, new FileSink(os)));
uint8_t buf[200];
size_t bufSize = DSAConvertSignatureFormat(buf, sizeof(buf), DSA_DER,
os.buf()->buf(), os.buf()->size(),
DSA_P1363);
shared_ptr<Buffer> sigBuffer = make_shared<Buffer>(buf, bufSize);
return Block(tlv::SignatureValue, sigBuffer);
}
default:
BOOST_THROW_EXCEPTION(Error("Unsupported digest algorithm"));
}
}
default:
BOOST_THROW_EXCEPTION(Error("Unsupported key type"));
}
}
catch (const CryptoPP::Exception& e) {
BOOST_THROW_EXCEPTION(Error(e.what()));
}
}
void BCipher::decrypt(std::string fkfile,std::string filename,std::string encryptedfile,std::string decryptedfile,std::string content,std::string signature){
AutoSeededRandomPool rng;
RSA::PrivateKey privateKey;
{
FileSource input("receiver_private.dat", true);
privateKey.BERDecode(input);
}
RSA::PublicKey publicKey;
{
FileSource input("receiver_public.dat", true);
publicKey.BERDecode(input);
}
//InvertibleRSAFunction params;
//params.GenerateRandomWithKeySize(rng, 3072);
//RSA::PrivateKey privateKey(params);
//RSA::PublicKey publicKey(params);
std::cout<<"Sending public key to sender..."<<std::endl;
std::string plain, cipher, recovered, cipher1,hmaccontents;
std::stringstream ss;
//read key file
std::ifstream infk(fkfile.c_str());
ss << infk.rdbuf();
std::string fk = ss.str();
ss.str("");
infk.close();
plain=fk;
//read HMAC file
std::ifstream inmd5(("hmac_"+encryptedfile).c_str());
ss << inmd5.rdbuf();
//std::string hmaccontents = ss.str();
std::string hmac = ss.str();
ss.str("");
inmd5.close();
// Encryption
std::cout<<"User encrypting key and HMAC of uploaded file with public key..."<<std::endl;
RSAES_OAEP_SHA_Encryptor e(publicKey);
StringSource ss1(plain, true,
new PK_EncryptorFilter(rng, e,
new StringSink(cipher)
) // PK_EncryptorFilter
); // StringSource
StringSource ss3(hmac, true,
new PK_EncryptorFilter(rng, e,
new StringSink(cipher1)
) // PK_EncryptorFilter
); // StringSource
std::cout<<"Encryption Complete.\nSender now sharing the encrypted key and HMAC of uploaded file over unsecure channel..."<<std::endl;
std::ofstream encrtptedkey("ekey.txt");
encrtptedkey << cipher;
encrtptedkey.close();
std::ofstream encrtptedhmac("ehmac_efile.txt");
encrtptedhmac << cipher1;
encrtptedhmac.close();
std::cout<<"Peer receives the encrypted files."<<std::endl;
std::cout<<"Decrypting the files using his private key..."<<std::endl;
// Decryption
RSAES_OAEP_SHA_Decryptor d(privateKey);
StringSource ss2(cipher, true,
new PK_DecryptorFilter(rng, d,
new StringSink(recovered)
) // PK_DecryptorFilter
); // StringSource
StringSource ss4(cipher1, true,
new PK_DecryptorFilter(rng, d,
new StringSink(hmaccontents)
) // PK_DecryptorFilter
); // StringSource
fk=recovered;
std::cout<<"====================================================================="<<std::endl;
//check if file is what I want.
authorize(filename);
std::cout<<"====================================================================="<<std::endl;
// verify digital signature.
verify_signature(content,signature);
std::cout<<"====================================================================="<<std::endl;
Hexa b;
std::string hmackey = fk.substr(AES::MAX_KEYLENGTH*2 + AES::BLOCKSIZE*2,HMAC_KEYLENGTH*2);
std::string skey = fk.substr(0,AES::MAX_KEYLENGTH*2);
std::string siv = fk.substr(AES::MAX_KEYLENGTH*2,AES::BLOCKSIZE*2);
//std::cout<<hmackey<<std::endl;
//std::cout<<skey<<std::endl;
//std::cout<<siv<<std::endl;
// Get key in byte form from hex
byte *key=b.hex_to_byte_decoder(skey);
// Get iv in byte form from hex
byte *iv=b.hex_to_byte_decoder(siv);
// Get cipher text from file
std::ifstream in(encryptedfile.c_str());
ss << in.rdbuf();
std::string input=ss.str();
size_t len = input.length();
int ctlen = len/2;
ss.str("");
in.close();
std::cout<<"Checking HMAC of downloaded file ..."<<std::endl;
HashMac h;
if(h.verify_hmac(hmackey,input,hmaccontents)){
std::cout<<"File authenticated and integrity maintained!"<<std::endl;
}
else{
std::cout<<"File could not be authenticated!"<<std::endl;
return;
}
// Convert ciphertext to bytes from hex
byte *ciphertext=b.hex_to_byte_decoder(input);
unsigned char *plaintext = new unsigned char[ctlen+1];
plaintext[ctlen]='\0';
std::cout<<"====================================================================="<<std::endl;
// Decrypt the file and store contents to file
CFB_Mode<AES>::Decryption cfbDecryption(key, AES::MAX_KEYLENGTH, iv);
cfbDecryption.ProcessData(plaintext, ciphertext, ctlen+1);
std::string x = b.byte_to_hex_encoder(plaintext,ctlen);
std::ofstream outfinal(decryptedfile.c_str());
outfinal << x;
outfinal.close();
std::cout<<"Succeed! You can check file_recovered.txt"<<std::endl;
}