bool BotanDSA::signFinal(ByteString& signature)
{
if (!AsymmetricAlgorithm::signFinal(signature))
{
return false;
}
// Perform the signature operation
Botan::SecureVector<Botan::byte> signResult;
try
{
BotanRNG* rng = (BotanRNG*)BotanCryptoFactory::i()->getRNG();
signResult = signer->signature(*rng->getRNG());
}
catch (...)
{
ERROR_MSG("Could not sign the data");
delete signer;
signer = NULL;
return false;
}
// Return the result
signature.resize(signResult.size());
memcpy(&signature[0], signResult.begin(), signResult.size());
delete signer;
signer = NULL;
return true;
}
// Encode into PKCS#8 DER
ByteString BotanDSAPrivateKey::PKCS8Encode()
{
ByteString der;
createBotanKey();
if (dsa == NULL) return der;
const Botan::SecureVector<Botan::byte> ber = Botan::PKCS8::BER_encode(*dsa);
der.resize(ber.size());
memcpy(&der[0], ber.begin(), ber.size());
return der;
}
bool ne7ssh_crypt::decryptPacket (Botan::SecureVector<Botan::byte> &decrypted, Botan::SecureVector<Botan::byte> &packet, uint32 len)
{
uint32 pLen = packet.size();
if (len % decryptBlock) len = len + (len % decryptBlock);
if (len > pLen) len = pLen;
decrypt->process_msg (packet.begin(), len);
decrypted = decrypt->read_all (decrypt->message_count() - 1);
return true;
}
bool ne7ssh_crypt::negotiatedHostkey (Botan::SecureVector<Botan::byte> &hostkeyAlgo)
{
if (!memcmp (hostkeyAlgo.begin(), "ssh-dss", hostkeyAlgo.size()))
{
hostkeyMethod = SSH_DSS;
return true;
}
else if (!memcmp (hostkeyAlgo.begin(), "ssh-rsa", hostkeyAlgo.size()))
{
hostkeyMethod = SSH_RSA;
return true;
}
ne7ssh::errors()->push (session->getSshChannel(), "Hostkey algorithm: '%B' not defined.", &hostkeyAlgo);
return false;
}
bool ne7ssh_crypt::negotiatedKex (Botan::SecureVector<Botan::byte> &kexAlgo)
{
if (!memcmp (kexAlgo.begin(), "diffie-hellman-group1-sha1", kexAlgo.size()))
{
kexMethod = DH_GROUP1_SHA1;
return true;
}
else if (!memcmp (kexAlgo.begin(), "diffie-hellman-group14-sha1", kexAlgo.size()))
{
kexMethod = DH_GROUP14_SHA1;
return true;
}
ne7ssh::errors()->push (session->getSshChannel(), "KEX algorithm: '%B' not defined.", &kexAlgo);
return false;
}
void ne7ssh_string::addVectorField(const Botan::SecureVector<Botan::byte> &vector)
{
uint32 nLen = htonl(vector.size());
_buffer += SecureVector<Botan::byte>((Botan::byte*)&nLen, sizeof(uint32));
_buffer += vector;
}
bool ne7ssh_crypt::negotiatedCmprsS2c (Botan::SecureVector<Botan::byte> &cmprsAlgo)
{
if (!memcmp (cmprsAlgo.begin(), "none", cmprsAlgo.size()))
{
s2cCmprsMethod = NONE;
return true;
}
else if (!memcmp (cmprsAlgo.begin(), "zlib", cmprsAlgo.size()))
{
s2cCmprsMethod = ZLIB;
return true;
}
ne7ssh::errors()->push (session->getSshChannel(), "Compression algorithm: '%B' not defined.", &cmprsAlgo);
return false;
}
// Decode from PKCS#8 BER
bool BotanECDHPrivateKey::PKCS8Decode(const ByteString& ber)
{
Botan::DataSource_Memory source(ber.const_byte_str(), ber.size());
if (source.end_of_data()) return false;
Botan::SecureVector<Botan::byte> keydata;
Botan::AlgorithmIdentifier alg_id;
const Botan::OID oid("1.2.840.10045.2.1");
Botan::ECDH_PrivateKey* key = NULL;
try
{
Botan::BER_Decoder(source)
.start_cons(Botan::SEQUENCE)
.decode_and_check<size_t>(0, "Unknown PKCS #8 version number")
.decode(alg_id)
.decode(keydata, Botan::OCTET_STRING)
.discard_remaining()
.end_cons();
if (keydata.empty())
throw Botan::Decoding_Error("PKCS #8 private key decoding failed");
// Botan defines == but not != ?!
if (!(alg_id.oid == oid))
{
ERROR_MSG("Decoded private key not ECDH");
return false;
}
key = new Botan::ECDH_PrivateKey(alg_id, keydata);
if (key == NULL) return false;
setFromBotan(key);
delete key;
}
catch (std::exception& e)
{
ERROR_MSG("Decode failed on %s", e.what());
return false;
}
return true;
}
// Decode from PKCS#8 BER
bool BotanDSAPrivateKey::PKCS8Decode(const ByteString& ber)
{
Botan::DataSource_Memory source(ber.const_byte_str(), ber.size());
if (source.end_of_data()) return false;
Botan::SecureVector<Botan::byte> keydata;
Botan::AlgorithmIdentifier alg_id;
Botan::DSA_PrivateKey* key = NULL;
try
{
Botan::BER_Decoder(source)
.start_cons(Botan::SEQUENCE)
.decode_and_check<size_t>(0, "Unknown PKCS #8 version number")
.decode(alg_id)
.decode(keydata, Botan::OCTET_STRING)
.discard_remaining()
.end_cons();
if (keydata.empty())
throw Botan::Decoding_Error("PKCS #8 private key decoding failed");
if (Botan::OIDS::lookup(alg_id.oid).compare("DSA"))
{
ERROR_MSG("Decoded private key not DSA");
return false;
}
BotanRNG* rng = (BotanRNG*)BotanCryptoFactory::i()->getRNG();
key = new Botan::DSA_PrivateKey(alg_id, keydata, *rng->getRNG());
if (key == NULL) return false;
setFromBotan(key);
delete key;
}
catch (std::exception& e)
{
ERROR_MSG("Decode failed on %s", e.what());
return false;
}
return true;
}
bool ne7ssh_crypt::encryptPacket (Botan::SecureVector<Botan::byte> &crypted, Botan::SecureVector<Botan::byte> &hmac, Botan::SecureVector<Botan::byte> &packet, uint32 seq)
{
SecureVector<Botan::byte> macStr;
uint32 nSeq = (uint32)htonl (seq);
encrypt->start_msg();
encrypt->write (packet.begin(), packet.size());
encrypt->end_msg();
// encrypt->process_msg (packet);
crypted = encrypt->read_all (encrypt->message_count() - 1);
if (hmacOut)
{
macStr = Botan::SecureVector<Botan::byte>((Botan::byte*)&nSeq, 4);
macStr += packet;
hmac = hmacOut->process (macStr);
}
return true;
}
char* digestPIN(CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen) {
// We do not use any salt
Botan::Pipe *digestPIN = new Botan::Pipe(new Botan::Hash_Filter(new Botan::SHA_256), new Botan::Hex_Encoder);
digestPIN->start_msg();
digestPIN->write((Botan::byte*)pPin, (Botan::u32bit)ulPinLen);
digestPIN->write((Botan::byte*)pPin, (Botan::u32bit)ulPinLen);
digestPIN->write((Botan::byte*)pPin, (Botan::u32bit)ulPinLen);
digestPIN->end_msg();
// Get the digested PIN
Botan::SecureVector<Botan::byte> pinVector = digestPIN->read_all();
int size = pinVector.size();
char *tmpPIN = (char *)malloc(size + 1);
if(tmpPIN != NULL_PTR) {
tmpPIN[size] = '\0';
memcpy(tmpPIN, pinVector.begin(), size);
}
delete digestPIN;
return tmpPIN;
}
EpadResult ExtractFromWad(RandomInStream &in, OutStream &out, std::string &key_file)
{
WadMetadata metadata;
auto result = ExtractWadMetadata(in, in.GetCount(), metadata);
in.Seek(metadata.payload_offset);
if(result != EpadResult::Success)
return result;
Botan::SecureVector<byte> buffer;
buffer.resize(metadata.payload_size != 0 ? metadata.payload_size : in.GetCount());
in.Read(buffer.data(), buffer.size());
out.Write(buffer.data(), buffer.size());
key_file.clear();
if(metadata.key_file_offset != kInvalid)
{
key_file.resize(metadata.key_file_size);
in.Seek(metadata.key_file_offset);
in.Read(reinterpret_cast<byte *>(&*key_file.begin()), metadata.key_file_size);
}
return EpadResult::Success;
}
void ne7ssh_crypt::computeMac (Botan::SecureVector<Botan::byte> &hmac, Botan::SecureVector<Botan::byte> &packet, uint32 seq)
{
SecureVector<Botan::byte> macStr;
uint32 nSeq = htonl (seq);
if (hmacIn)
{
macStr = Botan::SecureVector<Botan::byte>((Botan::byte*)&nSeq, 4);
macStr += packet;
hmac = hmacIn->process (macStr);
}
else hmac.clear();
}
// Encode into PKCS#8 DER
ByteString BotanECDHPrivateKey::PKCS8Encode()
{
ByteString der;
createBotanKey();
if (eckey == NULL) return der;
const size_t PKCS8_VERSION = 0;
// No OID for ECDH
const Botan::OID oid("1.2.840.10045.2.1");
// Force EC_DOMPAR_ENC_OID
const Botan::MemoryVector<Botan::byte> parameters = eckey->domain().DER_encode(Botan::EC_DOMPAR_ENC_OID);
const Botan::AlgorithmIdentifier alg_id(oid, parameters);
const Botan::SecureVector<Botan::byte> ber =
Botan::DER_Encoder()
.start_cons(Botan::SEQUENCE)
.encode(PKCS8_VERSION)
.encode(alg_id)
.encode(eckey->pkcs8_private_key(), Botan::OCTET_STRING)
.end_cons()
.get_contents();
der.resize(ber.size());
memcpy(&der[0], ber.begin(), ber.size());
return der;
}
void ne7ssh_string::bn2vector(Botan::SecureVector<Botan::byte>& result, const Botan::BigInt& bi)
{
int high;
Botan::byte zero = '\0';
SecureVector<Botan::byte> strVector = BigInt::encode(bi);
high = (*(strVector.begin()) & 0x80) ? 1 : 0;
if (high)
{
result = SecureVector<Botan::byte>(&zero, 1);
}
else
{
result.clear();
}
result += strVector;
}
bool ne7ssh_crypt::agree (Botan::SecureVector<Botan::byte> &result, const char* local, Botan::SecureVector<Botan::byte> &remote)
{
ne7ssh_string localAlgos (local, 0);
ne7ssh_string remoteAlgos (remote, 0);
char* localAlgo, *remoteAlgo;
bool match;
size_t len;
localAlgos.split (',');
localAlgos.resetParts();
remoteAlgos.split (',');
remoteAlgos.resetParts();
match = false;
while ((localAlgo = localAlgos.nextPart()))
{
len = strlen(localAlgo);
while ((remoteAlgo = remoteAlgos.nextPart()))
{
if (!memcmp (localAlgo, remoteAlgo, len))
{
match = true;
break;
}
}
if (match) break;
remoteAlgos.resetParts();
}
if (match)
{
result = Botan::SecureVector<Botan::byte>((Botan::byte*)localAlgo, (uint32_t) len);
return true;
}
else
{
result.clear();
return false;
}
}
bool BotanGOST::signFinal(ByteString& signature)
{
if (!AsymmetricAlgorithm::signFinal(signature))
{
return false;
}
// Perform the signature operation
#if BOTAN_VERSION_MINOR == 11
std::vector<Botan::byte> signResult;
#else
Botan::SecureVector<Botan::byte> signResult;
#endif
try
{
BotanRNG* rng = (BotanRNG*)BotanCryptoFactory::i()->getRNG();
signResult = signer->signature(*rng->getRNG());
}
catch (...)
{
ERROR_MSG("Could not sign the data");
delete signer;
signer = NULL;
return false;
}
// Return the result
signature.resize(signResult.size());
#if BOTAN_VERSION_MINOR == 11
memcpy(&signature[0], signResult.data(), signResult.size());
#else
memcpy(&signature[0], signResult.begin(), signResult.size());
#endif
delete signer;
signer = NULL;
return true;
}
bool ne7ssh_crypt::negotiatedMacS2c (Botan::SecureVector<Botan::byte> &macAlgo)
{
if (!memcmp (macAlgo.begin(), "hmac-sha1", macAlgo.size()))
{
s2cMacMethod = HMAC_SHA1;
return true;
}
else if (!memcmp (macAlgo.begin(), "hmac-md5", macAlgo.size()))
{
s2cMacMethod = HMAC_MD5;
return true;
}
else if (!memcmp (macAlgo.begin(), "none", macAlgo.size()))
{
s2cMacMethod = HMAC_NONE;
return true;
}
ne7ssh::errors()->push (session->getSshChannel(), "HMAC algorithm: '%B' not defined.", &macAlgo);
return false;
}
bool failed_test(const std::string& algo,
std::vector<std::string> params,
bool is_extension, bool exp_pass,
std::string& last_missing,
Botan::RandomNumberGenerator& rng)
{
#if !EXTRA_TESTS
if(!exp_pass) return true;
#endif
std::map<std::string, std::string> vars;
vars["input"] = params[0];
vars["output"] = params[1];
if(params.size() > 2)
vars["key"] = params[2];
if(params.size() > 3)
vars["iv"] = params[3];
std::map<std::string, bool> results =
algorithm_kat(algo, vars, global_state().algorithm_factory());
if(results.size())
{
for(std::map<std::string, bool>::const_iterator i = results.begin();
i != results.end(); ++i)
{
if(i->second == false)
{
std::cout << algo << " test with provider "
<< i->first << " failed\n";
return true;
}
}
return false; // OK
}
const std::string in = params[0];
const std::string expected = params[1];
params.erase(params.begin());
params.erase(params.begin());
if(in.size() % 2 == 1)
{
std::cout << "Can't have an odd sized hex string!" << std::endl;
return true;
}
Botan::Pipe pipe;
try {
Botan::Filter* test = lookup(algo, params);
if(test == 0 && is_extension) return !exp_pass;
if(test == 0)
{
if(algo != last_missing)
{
std::cout << "WARNING: \"" + algo + "\" is not a known "
<< "algorithm name." << std::endl;
last_missing = algo;
}
return 0;
}
pipe.reset();
pipe.append(test);
pipe.append(new Botan::Hex_Encoder);
Botan::SecureVector<byte> data = Botan::hex_decode(in);
const byte* data_ptr = &data[0];
// this can help catch errors with buffering, etc
size_t len = data.size();
pipe.start_msg();
while(len)
{
u32bit how_much = random_word(rng, len);
pipe.write(data_ptr, how_much);
data_ptr += how_much;
len -= how_much;
}
pipe.end_msg();
}
catch(Botan::Algorithm_Not_Found& e)
{
std::cout << "Algorithm not found: " << e.what() << std::endl;
return false;
}
catch(Botan::Exception& e)
{
if(exp_pass || DEBUG)
std::cout << "Exception caught: " << e.what() << std::endl;
return true;
}
catch(std::exception& e)
{
if(exp_pass || DEBUG)
std::cout << "Standard library exception caught: "
<< e.what() << std::endl;
return true;
}
catch(...)
{
if(exp_pass || DEBUG)
std::cout << "Unknown exception caught." << std::endl;
return true;
}
std::string output;
if(pipe.remaining())
{
/* Test peeking at an offset in Pipe/SecureQueue */
size_t offset = random_word(rng, pipe.remaining() - 1);
size_t length = random_word(rng, pipe.remaining() - offset);
Botan::SecureVector<byte> peekbuf(length);
pipe.peek(&peekbuf[0], peekbuf.size(), offset);
output = pipe.read_all_as_string();
bool OK = true;
for(size_t j = offset; j != offset+length; j++)
if(static_cast<byte>(output[j]) != peekbuf[j-offset])
OK = false;
if(!OK)
throw Botan::Self_Test_Failure("Peek testing failed in validate.cpp");
}
if(output == expected && !exp_pass)
{
std::cout << "FAILED: " << expected << " == " << std::endl
<< " " << output << std::endl;
return false;
}
if(output != expected && exp_pass)
{
std::cout << "\nFAILED: " << expected << " != " << std::endl
<< " " << output << std::endl;
return true;
}
if(output != expected && !exp_pass) return true;
return false;
}
// Signing functions
bool BotanDSA::sign(PrivateKey* privateKey, const ByteString& dataToSign,
ByteString& signature, const std::string mechanism)
{
std::string lowerMechanism;
lowerMechanism.resize(mechanism.size());
std::transform(mechanism.begin(), mechanism.end(), lowerMechanism.begin(), tolower);
std::string emsa;
if (!lowerMechanism.compare("dsa"))
{
emsa = "Raw";
}
else
{
// Call default implementation
return AsymmetricAlgorithm::sign(privateKey, dataToSign, signature, mechanism);
}
// Check if the private key is the right type
if (!privateKey->isOfType(BotanDSAPrivateKey::type))
{
ERROR_MSG("Invalid key type supplied");
return false;
}
BotanDSAPrivateKey* pk = (BotanDSAPrivateKey*) privateKey;
Botan::DSA_PrivateKey* botanKey = pk->getBotanKey();
if (!botanKey)
{
ERROR_MSG("Could not get the Botan private key");
return false;
}
try
{
signer = new Botan::PK_Signer(*botanKey, emsa);
// Should we add DISABLE_FAULT_PROTECTION? Makes this operation faster.
}
catch (...)
{
ERROR_MSG("Could not create the signer token");
return false;
}
// Perform the signature operation
Botan::SecureVector<Botan::byte> signResult;
try
{
BotanRNG* rng = (BotanRNG*)BotanCryptoFactory::i()->getRNG();
signResult = signer->sign_message(dataToSign.const_byte_str(), dataToSign.size(), *rng->getRNG());
}
catch (...)
{
ERROR_MSG("Could not sign the data");
delete signer;
signer = NULL;
return false;
}
// Return the result
signature.resize(signResult.size());
memcpy(&signature[0], signResult.begin(), signResult.size());
delete signer;
signer = NULL;
return true;
}
ne7ssh_string::ne7ssh_string(Botan::SecureVector<Botan::byte>& var, uint32 position)
: _currentPart(0),
_buffer(SecureVector<Botan::byte>((var.begin() + position), (var.size() - position)))
{
}
// Encryption functions
bool BotanRSA::encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const std::string padding)
{
// Check if the public key is the right type
if (!publicKey->isOfType(BotanRSAPublicKey::type))
{
ERROR_MSG("Invalid key type supplied");
return false;
}
std::string lowerPadding;
lowerPadding.resize(padding.size());
std::transform(padding.begin(), padding.end(), lowerPadding.begin(), tolower);
std::string eme;
if (!lowerPadding.compare("rsa-pkcs"))
{
eme = "PKCS1v15";
}
else if (!lowerPadding.compare("rsa-pkcs-oaep"))
{
eme = "EME1(SHA-160)";
}
else if (!lowerPadding.compare("rsa-raw"))
{
eme = "Raw";
}
else
{
ERROR_MSG("Invalid padding mechanism supplied (%s)", padding.c_str());
return false;
}
BotanRSAPublicKey* pk = (BotanRSAPublicKey*) publicKey;
Botan::RSA_PublicKey* botanKey = pk->getBotanKey();
if (!botanKey)
{
ERROR_MSG("Could not get the Botan public key");
return false;
}
Botan::PK_Encryptor_EME* encryptor = NULL;
try
{
encryptor = new Botan::PK_Encryptor_EME(*botanKey, eme);
}
catch (...)
{
ERROR_MSG("Could not create the encryptor token");
return false;
}
// Perform the encryption operation
Botan::SecureVector<Botan::byte> encResult;
try
{
BotanRNG* rng = (BotanRNG*)BotanCryptoFactory::i()->getRNG();
encResult = encryptor->encrypt(data.const_byte_str(), data.size(), *rng->getRNG());
}
catch (...)
{
ERROR_MSG("Could not encrypt the data");
delete encryptor;
return false;
}
// Return the result
encryptedData.resize(encResult.size());
memcpy(&encryptedData[0], encResult.begin(), encResult.size());
delete encryptor;
return true;
}
Fixed_Output_RNG(const Botan::SecureVector<byte>& in)
{
buf.insert(buf.end(), in.begin(), in.end());
}
// Signing functions
bool BotanRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign,
ByteString& signature, const AsymMech::Type mechanism,
const void* param /* = NULL */, const size_t paramLen /* = 0 */)
{
std::string emsa = "";
switch (mechanism)
{
case AsymMech::RSA:
emsa = "Raw";
break;
case AsymMech::RSA_PKCS:
emsa = "EMSA3(Raw)";
break;
default:
// Call default implementation
return AsymmetricAlgorithm::sign(privateKey, dataToSign, signature, mechanism, param, paramLen);
}
// Check if the private key is the right type
if (!privateKey->isOfType(BotanRSAPrivateKey::type))
{
ERROR_MSG("Invalid key type supplied");
return false;
}
BotanRSAPrivateKey* pk = (BotanRSAPrivateKey*) privateKey;
Botan::RSA_PrivateKey* botanKey = pk->getBotanKey();
if (!botanKey)
{
ERROR_MSG("Could not get the Botan private key");
return false;
}
try
{
signer = new Botan::PK_Signer(*botanKey, emsa);
// Should we add DISABLE_FAULT_PROTECTION? Makes this operation faster.
}
catch (...)
{
ERROR_MSG("Could not create the signer token");
return false;
}
// Perform the signature operation
#if BOTAN_VERSION_MINOR == 11
std::vector<Botan::byte> signResult;
#else
Botan::SecureVector<Botan::byte> signResult;
#endif
try
{
BotanRNG* rng = (BotanRNG*)BotanCryptoFactory::i()->getRNG();
signResult = signer->sign_message(dataToSign.const_byte_str(), dataToSign.size(), *rng->getRNG());
}
catch (std::exception& e)
{
ERROR_MSG("Could not sign the data: %s", e.what());
delete signer;
signer = NULL;
return false;
}
// Return the result
signature.resize(signResult.size());
#if BOTAN_VERSION_MINOR == 11
memcpy(&signature[0], signResult.data(), signResult.size());
#else
memcpy(&signature[0], signResult.begin(), signResult.size());
#endif
delete signer;
signer = NULL;
return true;
}
bool ne7ssh_crypt::negotiatedCryptoS2c (Botan::SecureVector<Botan::byte> &cryptoAlgo)
{
if (!memcmp (cryptoAlgo.begin(), "3des-cbc", cryptoAlgo.size()))
{
s2cCryptoMethod = TDES_CBC;
return true;
}
else if (!memcmp (cryptoAlgo.begin(), "aes128-cbc", cryptoAlgo.size()))
{
s2cCryptoMethod = AES128_CBC;
return true;
}
else if (!memcmp (cryptoAlgo.begin(), "aes192-cbc", cryptoAlgo.size()))
{
s2cCryptoMethod = AES192_CBC;
return true;
}
else if (!memcmp (cryptoAlgo.begin(), "aes256-cbc", cryptoAlgo.size()))
{
s2cCryptoMethod = AES256_CBC;
return true;
}
else if (!memcmp (cryptoAlgo.begin(), "blowfish-cbc", cryptoAlgo.size()))
{
s2cCryptoMethod = BLOWFISH_CBC;
return true;
}
else if (!memcmp (cryptoAlgo.begin(), "cast128-cbc", cryptoAlgo.size()))
{
s2cCryptoMethod = CAST128_CBC;
return true;
}
else if (!memcmp (cryptoAlgo.begin(), "twofish-cbc", cryptoAlgo.size()) || !memcmp (cryptoAlgo.begin(), "twofish256-cbc", cryptoAlgo.size()))
{
s2cCryptoMethod = TWOFISH_CBC;
return true;
}
ne7ssh::errors()->push (session->getSshChannel(), "Cryptographic method: '%B' not defined.", &cryptoAlgo);
return false;
}
// Decryption functions
bool BotanRSA::decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const std::string padding)
{
// Check if the private key is the right type
if (!privateKey->isOfType(BotanRSAPrivateKey::type))
{
ERROR_MSG("Invalid key type supplied");
return false;
}
std::string lowerPadding;
lowerPadding.resize(padding.size());
std::transform(padding.begin(), padding.end(), lowerPadding.begin(), tolower);
std::string eme;
if (!lowerPadding.compare("rsa-pkcs"))
{
eme = "PKCS1v15";
}
else if (!lowerPadding.compare("rsa-pkcs-oaep"))
{
eme = "EME1(SHA-160)";
}
else if (!lowerPadding.compare("rsa-raw"))
{
eme = "Raw";
}
else
{
ERROR_MSG("Invalid padding mechanism supplied (%s)", padding.c_str());
return false;
}
BotanRSAPrivateKey* pk = (BotanRSAPrivateKey*) privateKey;
Botan::RSA_PrivateKey* botanKey = pk->getBotanKey();
if (!botanKey)
{
ERROR_MSG("Could not get the Botan private key");
return false;
}
Botan::PK_Decryptor_EME* decryptor = NULL;
try
{
decryptor = new Botan::PK_Decryptor_EME(*botanKey, eme);
}
catch (...)
{
ERROR_MSG("Could not create the decryptor token");
return false;
}
// Perform the decryption operation
Botan::SecureVector<Botan::byte> decResult;
try
{
decResult = decryptor->decrypt(encryptedData.const_byte_str(), encryptedData.size());
}
catch (...)
{
ERROR_MSG("Could not decrypt the data");
delete decryptor;
return false;
}
// Return the result
if (!eme.compare("Raw"))
{
// We compensate that Botan removes leading zeros
int modSize = pk->getN().size();
int decSize = decResult.size();
data.resize(modSize);
memcpy(&data[0] + modSize - decSize, decResult.begin(), decSize);
}
else
{
data.resize(decResult.size());
memcpy(&data[0], decResult.begin(), decResult.size());
}
delete decryptor;
return true;
}
Fixed_Output_RNG(const std::string& in_str)
{
Botan::SecureVector<byte> in = Botan::hex_decode(in_str);
buf.insert(buf.end(), in.begin(), in.end());
}
// Encryption functions
bool BotanRSA::encrypt(PublicKey* publicKey, const ByteString& data,
ByteString& encryptedData, const AsymMech::Type padding)
{
// Check if the public key is the right type
if (!publicKey->isOfType(BotanRSAPublicKey::type))
{
ERROR_MSG("Invalid key type supplied");
return false;
}
std::string eme;
switch (padding)
{
case AsymMech::RSA_PKCS:
eme = "PKCS1v15";
break;
case AsymMech::RSA_PKCS_OAEP:
eme = "EME1(SHA-160)";
break;
case AsymMech::RSA:
eme = "Raw";
break;
default:
ERROR_MSG("Invalid padding mechanism supplied (%i)", padding);
return false;
}
BotanRSAPublicKey* pk = (BotanRSAPublicKey*) publicKey;
Botan::RSA_PublicKey* botanKey = pk->getBotanKey();
if (!botanKey)
{
ERROR_MSG("Could not get the Botan public key");
return false;
}
Botan::PK_Encryptor_EME* encryptor = NULL;
try
{
encryptor = new Botan::PK_Encryptor_EME(*botanKey, eme);
}
catch (...)
{
ERROR_MSG("Could not create the encryptor token");
return false;
}
// Perform the encryption operation
#if BOTAN_VERSION_MINOR == 11
std::vector<Botan::byte> encResult;
#else
Botan::SecureVector<Botan::byte> encResult;
#endif
try
{
BotanRNG* rng = (BotanRNG*)BotanCryptoFactory::i()->getRNG();
encResult = encryptor->encrypt(data.const_byte_str(), data.size(), *rng->getRNG());
}
catch (...)
{
ERROR_MSG("Could not encrypt the data");
delete encryptor;
return false;
}
// Return the result
encryptedData.resize(encResult.size());
#if BOTAN_VERSION_MINOR == 11
memcpy(&encryptedData[0], encResult.data(), encResult.size());
#else
memcpy(&encryptedData[0], encResult.begin(), encResult.size());
#endif
delete encryptor;
return true;
}
void ne7ssh_string::addVector(Botan::SecureVector<Botan::byte> &secvec)
{
_buffer += SecureVector<Botan::byte>(secvec.begin(), secvec.size());
}
