Esempio n. 1
0
std::unique_ptr<ArchiveKeys> ArchiveKeys::create_and_save(std::ostream &stream, RsaKeyPair *keypair){
	std::unique_ptr<ArchiveKeys> ret;
	if (keypair){
		ret = make_unique(new ArchiveKeys(CryptoPP::Twofish::MAX_KEYLENGTH, CryptoPP::Twofish::BLOCKSIZE));

		CryptoPP::RSA::PublicKey pub;
		auto &public_key = keypair->get_public_key();
		pub.Load(CryptoPP::ArraySource((const byte *)&public_key[0], public_key.size(), true));

		typedef CryptoPP::RSAES<CryptoPP::OAEP<CryptoPP::SHA>>::Encryptor encryptor_t;
		typedef CryptoPP::PK_EncryptorFilter filter_t;

		encryptor_t enc(pub);
		CryptoPP::SecByteBlock buffer(ret->get_size());
		size_t offset = 0;
		for (size_t i = 0; i < ret->key_count; i++){
			auto &key = ret->get_key(i);
			auto &iv = ret->get_iv(i);
			memcpy(buffer.data() + offset, key.data(), key.size());
			offset += key.size();
			memcpy(buffer.data() + offset, iv.data(), iv.size());
			offset += iv.size();
		}
		CryptoPP::ArraySource(buffer.data(), buffer.size(), true, new filter_t(*random_number_generator, enc, new CryptoPP::FileSink(stream)));
	}
	return ret;
}
                shared_ptr<ndn::Data>
                makeData( shared_ptr<const ndn::Interest> interest ) override
                {
                        bool verified = false;
                        if( !interest->hasPayload() )
                            return NULL;

                        Block payload( interest->getPayload(),
                                       interest->getPayloadLength() );
                        try
                        {
                            payload.parse();
                            NdnTagVerificationRequest request( payload );

                            const KeyLocator& locator = request.getLocator();
                            if( locator.getType() != KeyLocator::KeyLocator_KeyDigest )
                            {
                                verified = false;
                            }
                            else
                            {
                                CryptoPP::RSA::PublicKey pkey;
                                const Block& key_digest = locator.getKeyDigest();
                                string keystr( (char*)key_digest.value(), key_digest.value_size() );
                                CryptoPP::StringSource keysource( keystr, true );
                                pkey.Load( keysource );
                                NdnVerifier verifier( pkey );

                                verified = verifier.verify( request.getTag() );
                            }

                            auto data = make_shared< Data >( interest->getName() );
                            data->setContentType( tlv::ContentType_Blob );
                            data->setFreshnessPeriod( time::milliseconds( 0 ) );
                            NdnTagVerificationResponse response( request.getTag(),
                                                                 verified );
                            data->setContent( response.wireEncode() );

                            // no legit signature is required since
                            // packets/interests with the prefix "ndn/internal"
                            // should be rejected by network gateways
                            Signature sig( SignatureInfo( tlv::SignatureNone ),
                                           Block( tlv::SignatureValue ) );
                            data->setSignature( sig );
                            data->wireEncode();

                            return data;
                        }
                        catch( ... )
                        {
                            return NULL;
                        }
                }
Esempio n. 3
0
string RSA_Encryption(const string & plain){
  //Encryption
  AutoSeededRandomPool rng;
  
  //Load public key
  CryptoPP::RSA::PublicKey pubKey;
  CryptoPP::ByteQueue bytes;
  FileSource file("pubkey.txt", true, new Base64Decoder);
  file.TransferTo(bytes);
  bytes.MessageEnd();
  pubKey.Load(bytes);
  
  
  RSAES_OAEP_SHA_Encryptor e(pubKey);
  
  string cipher;
  StringSource ss1(plain, true,
                   new PK_EncryptorFilter(rng, e,
                                          new StringSink(cipher)
                                          ) // PK_EncryptorFilter
                   ); // StringSource
  return cipher;
}
Esempio n. 4
0
void cKeysStorage::savePubFile(unsigned int numberOfKey, const CryptoPP::RSA::PublicKey& pPubKey, std::string fileName)
{
	std::ofstream mOutFile;
    std::string mOutName; //(std::to_string(numberOfKey));
    //mOutName += ".pub";
    mOutName = fileName;
    std::cout << "Pub file: " << fileName << std::endl;
    //mOutFile.open(mOutName);
    //save header
    //mOutFile << "version 1" << std::endl;
    //mOutFile << "crypto rsa" << std::endl;
    //mOutFile << "size 4096" << std::endl;
    //mOutFile << "END" << std::endl;
    
    //generate pub key in txt file
    //Base64Encoder pubkeysink(new FileSink("tmp"));
    Base64Encoder pubkeysink(new FileSink(mOutName.c_str()));
	pPubKey.DEREncode(pubkeysink);
	pubkeysink.MessageEnd();
	
	//std::cout << "Pub key:" << std::endl;
	//append from tmp to pub file
	/*std::ifstream tmpFile("tmp");
	char s;
	while (!tmpFile.eof())
	{
		tmpFile >> std::noskipws >> s;
		mOutFile << s;
		std::cout << s;
	}
	
    mOutFile.close();
    std::cout << std::endl;*/
    
    std::cout << "end of savePubFile" << std::endl;
}
Esempio n. 5
0
bool cKeysStorage::RSAVerifyFile(const std::string &fileName, const std::string &instance) // load .sig file
{
	using namespace CryptoPP;
	std::cout << "Start RSAVerifyFile" << std::endl;
	std::cout << "File name: " << fileName << std::endl;
	std::cout << "instance: " << instance << std::endl;
	std::string line;
	std::string clearTextFileName;
	int pubicKeyNumber;
	// read sig file
	std::ifstream input(fileName);
	input >> line;
	//parse data
	input >> pubicKeyNumber;
	//std::cout << line << " " << pubicKeyNumber << std::endl;
	std::cout << "====sig===" << std::endl;
	for (int i = 0; i < 4; ++i)	// 3 lines
	{
		input >> line;
		std::cout << line << " ";
		input >> line;
		std::cout << line << " " << std::endl;
	}
	std::cout << "====sig===" << std::endl;
	
	clearTextFileName = line;
	input >> line;
	input >> line;
	
	std::string sig2file = line;
	
	std::cout << std::endl;
	std::cout << "clear file: " << clearTextFileName << std::endl;
	std::cout << "sig2 file: " << sig2file << std::endl;
	
	//load signature
	std::string signedTxt;
	FileSource(clearTextFileName.c_str(), true, new StringSink(signedTxt)); 
	std::string signature;
	FileSource(sig2file.c_str(), true, new StringSink(signature)); 
	
	//std::cout << std::endl << "signature " << std::noskipws << signature << std::endl;
	//std::cout << std::endl << "pubicKeyNumber " << pubicKeyNumber << std::endl;
	
	std::string pubFile;
	pubFile = instance + "-key" + std::to_string(pubicKeyNumber) + ".pub";
	std::cout << "pub file: " << pubFile << std::endl;
	CryptoPP::RSA::PublicKey currentPubKey = loadPubFile(pubFile);
	AutoSeededRandomPool rng;
	std::cout << "pub key validate " << currentPubKey.Validate(rng, 1);
	std::cout << std::endl << "start verify" << std::endl;
	RSASSA_PKCS1v15_SHA_Verifier verifier(currentPubKey);


	std::string combined(signedTxt);
	combined.append(signature); 

	try
	{
		StringSource(combined, true, 
			new SignatureVerificationFilter(verifier, NULL, SignatureVerificationFilter::THROW_EXCEPTION) );
		std::cout << "Signature OK" << std::endl;
		return true;
	}
	catch(SignatureVerificationFilter::SignatureVerificationFailed &err)
	{
		std::cout << "verify error " << err.what() << std::endl;
		return false;
	}
	//std::cout << "end of RsaVerifyFile" << std::endl;
}