unsigned char* CreatePrivateKey(size_t* len, size_t* pubLen) { AutoSeededRandomPool rand; InvertibleRSAFunction params; params.GenerateRandomWithKeySize(rand,4096); const Integer& modulus = params.GetModulus(); const Integer& exponent = params.GetPublicExponent(); const Integer& private_exponent = params.GetPrivateExponent(); size_t dlen = 4+modulus.MinEncodedSize()+4+exponent.MinEncodedSize()+4+private_exponent.MinEncodedSize(); unsigned char* izard = new unsigned char[dlen]; unsigned char* str = izard; uint32_t cval = modulus.MinEncodedSize(); memcpy(str,&cval,4); str+=4; modulus.Encode(str,modulus.MinEncodedSize()); str+=modulus.MinEncodedSize(); cval = exponent.MinEncodedSize(); memcpy(str,&cval,4); str+=4; exponent.Encode(str,exponent.MinEncodedSize()); str+=exponent.MinEncodedSize(); cval = private_exponent.MinEncodedSize(); memcpy(str,&cval,4); str+=4; *pubLen = ((size_t)str-(size_t)izard); private_exponent.Encode(str,private_exponent.MinEncodedSize()); str+=private_exponent.MinEncodedSize(); *len = dlen; return izard; }
int main(int argc, const char *argv[]) { // monty pythons! string text = "Are you suggesting coconuts migrate?"; AutoSeededRandomPool rng; InvertibleRSAFunction keys; keys.GenerateRandomWithKeySize(rng, 384); RSASS<PKCS1v15, SHA>::Signer signer(keys); byte* signature = new byte[signer.MaxSignatureLength()]; if(NULL == signature) { return -1; } // Sign... size_t length = signer.SignMessage(rng, (const byte*) text.c_str(), text.length(), signature); RSASS<PKCS1v15, SHA>::Verifier verifier(signer); bool result = verifier.VerifyMessage((const byte*)text.c_str(), text.length(), signature, length); return 0; }
void GenerateKeyPair() { // Generate keys AutoSeededRandomPool rng; InvertibleRSAFunction parameters; parameters.GenerateRandomWithKeySize( rng, 1024 ); RSA::PrivateKey privateKey( parameters ); RSA::PublicKey publicKey( parameters ); SaveKey(privateKey, "priv.key"); SaveKey(publicKey, "pub.key"); }
pair<string /*privKey*/, string /*pubKey*/> GenerateKeys() { AutoSeededRandomPool rng; InvertibleRSAFunction params; params.GenerateRandomWithKeySize(rng, DEFAULT_ASSYMETRICAL_KEY_LENGTH); RSA::PrivateKey privateKey(params); RSA::PublicKey publicKey(params); string privKey; string pubKey; privateKey.Save(StringSink(privKey).Ref()); publicKey.Save(StringSink(pubKey).Ref()); return pair<string, string>(privKey, pubKey); }
void SharedKey_Init(InvertibleRSAFunction & privkey){ // InvertibleRSAFunction is used directly only because the private key // won't actually be used to perform any cryptographic operation; // otherwise, an appropriate typedef'ed type from rsa.h would have been used. AutoSeededRandomPool rng; //InvertibleRSAFunction privkey; privkey.Initialize(rng, 1024); // With the current version of Crypto++, MessageEnd() needs to be called // explicitly because Base64Encoder doesn't flush its buffer on destruction. /* Base64Encoder privkeysink(new FileSink("privkey.txt")); privkey.DEREncode(privkeysink); privkeysink.MessageEnd(); */ // Suppose we want to store the public key separately, // possibly because we will be sending the public key to a third party. RSAFunction pubkey(privkey); Base64Encoder pubkeysink(new FileSink("pubkey.txt")); pubkey.DEREncode(pubkeysink); pubkeysink.MessageEnd(); }
void BCipher::generateRSAkeys(){ std::cout<<"Generating RSA keys for receiver..."<<std::endl; // Generate keys AutoSeededRandomPool rng; InvertibleRSAFunction params; params.GenerateRandomWithKeySize(rng, 3072); RSA::PrivateKey privateKey(params); RSA::PublicKey publicKey(params); { FileSink output("receiver_private.dat"); privateKey.DEREncode(output); } { FileSink output("receiver_public.dat"); publicKey.DEREncode(output); } std::cout<<"Produce receiver_private.dat and receiver_public.dat" <<std::endl; }
/* * Class: edu_biu_scapi_midLayer_asymmetricCrypto_encryption_CryptoPPRSAOaep * Method: initRSADecryptor * Signature: ([B[B[B)J */ JNIEXPORT void JNICALL Java_edu_biu_scapi_midLayer_asymmetricCrypto_encryption_CryptoPPRSAOaep_initRSADecryptor (JNIEnv *env, jobject, jlong decryptor, jbyteArray modulus, jbyteArray pubExp, jbyteArray privExp) { Integer n, e, d; Utils utils; // get the Integers values for the RSA permutation n = utils.jbyteArrayToCryptoPPInteger(env, modulus); e = utils.jbyteArrayToCryptoPPInteger(env, pubExp); d = utils.jbyteArrayToCryptoPPInteger(env, privExp); //create pointer to InvertibleRSAFunction object InvertibleRSAFunction* invRsaFunc = new InvertibleRSAFunction; //initialize the trapdoor object with the RSA values invRsaFunc->Initialize(n, e, d); RSA::PrivateKey privateKey(*invRsaFunc); ((RSAES_OAEP_SHA_Decryptor * ) decryptor)->AccessKey().AssignFrom(privateKey); }
void cKeysStorage::GenerateRSAKey(unsigned int keyLength, std::string fileName) { using namespace CryptoPP; AutoSeededRandomPool rng; // Generate Parameters InvertibleRSAFunction params; params.GenerateRandomWithKeySize(rng, keyLength); // Create Keys CryptoPP::RSA::PrivateKey privateKey(params); CryptoPP::RSA::PublicKey publicKey(params); //mPrvKeys.push_back(privateKey); mPrvKeys[mCurrentKey] = privateKey; std::cout << "start saving pub file" << std::endl; std::cout << "generated file: " << fileName << std::endl; savePubFile(mCurrentKey, publicKey, fileName); mCurrentKey++; std::cout << "end of GenerateRSAKey" << std::endl; }
void GenerateKeyPair(std::string& public_key, std::string & private_key) { std::string strprivkey, strpubkey; AutoSeededRandomPool rng; InvertibleRSAFunction privkey; privkey.Initialize(rng, 1024); Base64Encoder privkeysink(new StringSink(strprivkey), false); privkey.DEREncode(privkeysink); privkeysink.MessageEnd(); RSAFunction pubkey(privkey); Base64Encoder pubkeysink(new StringSink(strpubkey), false); pubkey.DEREncode(pubkeysink); pubkeysink.MessageEnd(); public_key = strpubkey; private_key = strprivkey; }
RSAKeys genRSAKeys(){ AutoSeededRandomPool rnd; InvertibleRSAFunction params; params.GenerateRandomWithKeySize(rnd, 16000); RSAKeys keys; keys.privateKey = new RSA::PrivateKey(params); keys.publicKey = new RSA::PublicKey(params); /* //Test code saveRSAPriKey(*(keys.privateKey), "private"); saveRSAPubKey(*(keys.publicKey), "public"); ifstream ipub("private"); string pubKey; getline(ipub, pubKey, (char)ipub.eof()); ipub.close(); ofstream opub("private1"); opub << pubKey; opub.close(); RSA::PublicKey pubK; RSA::PrivateKey privK; loadRSAPubKey(pubK, "public"); loadRSAPriKey(privK, "private1"); string plain = "RSA Encryption"; string cipher = RSAEncrypt(pubK, plain); cout << cipher << endl; string recovered = RSADecrypt(privK, cipher); cout << recovered << endl; */ return keys; }
bool CClientCreditsList::CreateKeyPair() { try{ AutoSeededRandomPool rng; InvertibleRSAFunction privkey; privkey.Initialize(rng,RSAKEYSIZE); Base64Encoder privkeysink(new FileSink(CStringA(thePrefs.GetConfigDir() + _T("cryptkey.dat")))); privkey.DEREncode(privkeysink); privkeysink.MessageEnd(); if (thePrefs.GetLogSecureIdent()) AddDebugLogLine(false, _T("Created new RSA keypair")); } catch(...) { if (thePrefs.GetVerbose()) AddDebugLogLine(false, _T("Failed to create new RSA keypair")); ASSERT ( false ); return false; } return true; }
int main(int argc, char** argv) { using namespace CryptoPP; namespace po = boost::program_options; std::string publicKeyName, privateKeyName; size_t keyLength; po::options_description desc("Allowed Options"); desc.add_options() ("help", "produce help message") ("length,l", po::value<size_t>(&keyLength)->default_value(1024), "set key length") ("pubKey,r", po::value<std::string>(&publicKeyName)->default_value("key.pub"), "set public key name") ("privKey,u", po::value<std::string>(&privateKeyName)->default_value("key.pem"), "set private key name") ; po::variables_map vm; po::store(po::parse_command_line(argc, argv, desc), vm); po::notify(vm); if (vm.count("help")) { std::cout << desc << "\n"; return 1; } AutoSeededRandomPool prng; InvertibleRSAFunction parameters; parameters.GenerateRandomWithKeySize(prng, keyLength); RSA::PrivateKey privateKey(parameters); RSA::PublicKey publicKey(parameters); SaveKey(publicKeyName, publicKey); SaveKey(privateKeyName, privateKey); }
void GenKeyPair(string s, int size) { // InvertibleRSAFunction is used directly only because the private key // won't actually be used to perform any cryptographic operation; // otherwise, an appropriate typedef'ed type from rsa.h would have been used. AutoSeededRandomPool rng; InvertibleRSAFunction privkey; privkey.Initialize(rng, size); // With the current version of Crypto++, MessageEnd() needs to be called // explicitly because Base64Encoder doesn't flush its buffer on destruction. Base64Encoder privkeysink(new FileSink((s+".pri").c_str())); privkey.DEREncode(privkeysink); privkeysink.MessageEnd(); // Suppose we want to store the public key separately, // possibly because we will be sending the public key to a third party. RSAFunction pubkey(privkey); Base64Encoder pubkeysink(new FileSink((s+".pub").c_str())); pubkey.DEREncode(pubkeysink); pubkeysink.MessageEnd(); cout << size << endl; }
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; }
void CCollectionCreateDialog::OnBnClickedOk() { //Some users have noted that the collection can at times //save a collection with a invalid name... OnEnKillFocusCollectionName(); CString sFileName; m_CollectionNameEdit.GetWindowText(sFileName); if (!sFileName.IsEmpty()) { m_pCollection->m_sCollectionAuthorName.Empty(); m_pCollection->SetCollectionAuthorKey(NULL, 0); m_pCollection->m_sCollectionName = sFileName; m_pCollection->m_bTextFormat = (m_CollectionCreateFormatCheck.GetCheck() == BST_CHECKED); CString sFilePath; sFilePath.Format(_T("%s\\%s.emulecollection"), thePrefs.GetMuleDirectory(EMULE_INCOMINGDIR), m_pCollection->m_sCollectionName); using namespace CryptoPP; RSASSA_PKCS1v15_SHA_Signer* pSignkey = NULL; if (m_CollectionCreateSignNameKeyCheck.GetCheck()) { bool bCreateNewKey = false; HANDLE hKeyFile = ::CreateFile(thePrefs.GetMuleDirectory(EMULE_CONFIGDIR) + _T("collectioncryptkey.dat"), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (hKeyFile != INVALID_HANDLE_VALUE) { if (::GetFileSize(hKeyFile, NULL) == 0) bCreateNewKey = true; ::CloseHandle(hKeyFile); } else bCreateNewKey = true; if (bCreateNewKey) { try { AutoSeededRandomPool rng; InvertibleRSAFunction privkey; privkey.Initialize(rng, 1024); Base64Encoder privkeysink(new FileSink(CStringA(thePrefs.GetMuleDirectory(EMULE_CONFIGDIR) + _T("collectioncryptkey.dat")))); privkey.DEREncode(privkeysink); privkeysink.MessageEnd(); } catch(...) { ASSERT(0); } } try { FileSource filesource(CStringA(thePrefs.GetMuleDirectory(EMULE_CONFIGDIR) + _T("collectioncryptkey.dat")), true,new Base64Decoder); pSignkey = new RSASSA_PKCS1v15_SHA_Signer(filesource); RSASSA_PKCS1v15_SHA_Verifier pubkey(*pSignkey); byte abyMyPublicKey[1000]; ArraySink asink(abyMyPublicKey, 1000); pubkey.DEREncode(asink); int nLen = asink.TotalPutLength(); asink.MessageEnd(); m_pCollection->SetCollectionAuthorKey(abyMyPublicKey, nLen); } catch(...) { ASSERT(0); } m_pCollection->m_sCollectionAuthorName = thePrefs.GetUserNick(); } if (!PathFileExists(sFilePath)) { m_pCollection->WriteToFileAddShared(pSignkey); } else { if (AfxMessageBox(GetResString(IDS_COLL_REPLACEEXISTING), MB_ICONWARNING | MB_ICONQUESTION | MB_DEFBUTTON2 | MB_YESNO) == IDNO) return; bool bDeleteSuccessful = ShellDeleteFile(sFilePath); if (bDeleteSuccessful) { CKnownFile* pKnownFile = theApp.knownfiles->FindKnownFileByPath(sFilePath); if (pKnownFile) { theApp.sharedfiles->RemoveFile(pKnownFile, true); if (pKnownFile->IsKindOf(RUNTIME_CLASS(CPartFile))) theApp.emuledlg->transferwnd->GetDownloadList()->ClearCompleted(static_cast<CPartFile*>(pKnownFile)); } m_pCollection->WriteToFileAddShared(pSignkey); } else { AfxMessageBox(GetResString(IDS_COLL_ERR_DELETING),MB_ICONWARNING | MB_ICONQUESTION | MB_DEFBUTTON2 | MB_YESNO); } } delete pSignkey; pSignkey = NULL; OnOK(); } }
void SecTpmFile::generateKeyPairInTpm(const Name& keyName, const KeyParams& params) { string keyURI = keyName.toUri(); if (doesKeyExistInTpm(keyName, KeyClass::PUBLIC)) BOOST_THROW_EXCEPTION(Error("public key exists")); if (doesKeyExistInTpm(keyName, KeyClass::PRIVATE)) BOOST_THROW_EXCEPTION(Error("private key exists")); string keyFileName = m_impl->maintainMapping(keyURI); try { switch (params.getKeyType()) { case KeyType::RSA: { using namespace CryptoPP; const RsaKeyParams& rsaParams = static_cast<const RsaKeyParams&>(params); AutoSeededRandomPool rng; InvertibleRSAFunction privateKey; privateKey.Initialize(rng, rsaParams.getKeySize()); string privateKeyFileName = keyFileName + ".pri"; Base64Encoder privateKeySink(new FileSink(privateKeyFileName.c_str())); privateKey.DEREncode(privateKeySink); privateKeySink.MessageEnd(); RSAFunction publicKey(privateKey); string publicKeyFileName = keyFileName + ".pub"; Base64Encoder publicKeySink(new FileSink(publicKeyFileName.c_str())); publicKey.DEREncode(publicKeySink); publicKeySink.MessageEnd(); // set file permission chmod(privateKeyFileName.c_str(), 0000400); chmod(publicKeyFileName.c_str(), 0000444); return; } case KeyType::EC: { using namespace CryptoPP; const EcdsaKeyParams& ecdsaParams = static_cast<const EcdsaKeyParams&>(params); CryptoPP::OID curveName; switch (ecdsaParams.getKeySize()) { case 256: curveName = ASN1::secp256r1(); break; case 384: curveName = ASN1::secp384r1(); break; default: curveName = ASN1::secp256r1(); break; } AutoSeededRandomPool rng; ECDSA<ECP, SHA256>::PrivateKey privateKey; DL_GroupParameters_EC<ECP> cryptoParams(curveName); cryptoParams.SetEncodeAsOID(true); privateKey.Initialize(rng, cryptoParams); ECDSA<ECP, SHA256>::PublicKey publicKey; privateKey.MakePublicKey(publicKey); publicKey.AccessGroupParameters().SetEncodeAsOID(true); string privateKeyFileName = keyFileName + ".pri"; Base64Encoder privateKeySink(new FileSink(privateKeyFileName.c_str())); privateKey.DEREncode(privateKeySink); privateKeySink.MessageEnd(); string publicKeyFileName = keyFileName + ".pub"; Base64Encoder publicKeySink(new FileSink(publicKeyFileName.c_str())); publicKey.Save(publicKeySink); publicKeySink.MessageEnd(); // set file permission chmod(privateKeyFileName.c_str(), 0000400); chmod(publicKeyFileName.c_str(), 0000444); return; } default: BOOST_THROW_EXCEPTION(Error("Unsupported key type")); } } catch (const KeyParams::Error& e) { BOOST_THROW_EXCEPTION(Error(e.what())); } catch (const CryptoPP::Exception& e) { BOOST_THROW_EXCEPTION(Error(e.what())); } }