3 files changed, 376 insertions, 0 deletions
diff --git a/src/lib/vendor/openssl/openssl_block.cpp b/src/lib/vendor/openssl/openssl_block.cpp
new file mode 100644
index 000000000..34f0e5607
--- /dev/null
+++ b/src/lib/vendor/openssl/openssl_block.cpp
@@ -0,0 +1,212 @@
+/*
+* OpenSSL Block Cipher
+* (C) 1999-2010,2015 Jack Lloyd
+*
+* Botan is released under the Simplified BSD License (see license.txt)
+*/
+
+#include <botan/internal/block_utils.h>
+#include <openssl/evp.h>
+
+namespace Botan {
+
+namespace {
+
+class OpenSSL_BlockCipher : public BlockCipher
+   {
+   public:
+      void clear();
+      std::string name() const { return cipher_name; }
+      BlockCipher* clone() const;
+
+      size_t block_size() const { return block_sz; }
+
+      OpenSSL_BlockCipher(const EVP_CIPHER*, const std::string&);
+
+      OpenSSL_BlockCipher(const EVP_CIPHER*, const std::string&,
+                      size_t, size_t, size_t);
+
+      Key_Length_Specification key_spec() const { return cipher_key_spec; }
+
+      ~OpenSSL_BlockCipher();
+   private:
+      void encrypt_n(const byte in[], byte out[], size_t blocks) const
+         {
+         int out_len = 0;
+         EVP_EncryptUpdate(&encrypt, out, &out_len, in, blocks * block_sz);
+         }
+
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const
+         {
+         int out_len = 0;
+         EVP_DecryptUpdate(&decrypt, out, &out_len, in, blocks * block_sz);
+         }
+
+      void key_schedule(const byte[], size_t);
+
+      size_t block_sz;
+      Key_Length_Specification cipher_key_spec;
+      std::string cipher_name;
+      mutable EVP_CIPHER_CTX encrypt, decrypt;
+   };
+
+OpenSSL_BlockCipher::OpenSSL_BlockCipher(const EVP_CIPHER* algo,
+                                         const std::string& algo_name) :
+   block_sz(EVP_CIPHER_block_size(algo)),
+   cipher_key_spec(EVP_CIPHER_key_length(algo)),
+   cipher_name(algo_name)
+   {
+   if(EVP_CIPHER_mode(algo) != EVP_CIPH_ECB_MODE)
+      throw Invalid_Argument("OpenSSL_BlockCipher: Non-ECB EVP was passed in");
+
+   EVP_CIPHER_CTX_init(&encrypt);
+   EVP_CIPHER_CTX_init(&decrypt);
+
+   EVP_EncryptInit_ex(&encrypt, algo, nullptr, nullptr, nullptr);
+   EVP_DecryptInit_ex(&decrypt, algo, nullptr, nullptr, nullptr);
+
+   EVP_CIPHER_CTX_set_padding(&encrypt, 0);
+   EVP_CIPHER_CTX_set_padding(&decrypt, 0);
+   }
+
+OpenSSL_BlockCipher::OpenSSL_BlockCipher(const EVP_CIPHER* algo,
+                                 const std::string& algo_name,
+                                 size_t key_min, size_t key_max,
+                                 size_t key_mod) :
+   block_sz(EVP_CIPHER_block_size(algo)),
+   cipher_key_spec(key_min, key_max, key_mod),
+   cipher_name(algo_name)
+   {
+   if(EVP_CIPHER_mode(algo) != EVP_CIPH_ECB_MODE)
+      throw Invalid_Argument("OpenSSL_BlockCipher: Non-ECB EVP was passed in");
+
+   EVP_CIPHER_CTX_init(&encrypt);
+   EVP_CIPHER_CTX_init(&decrypt);
+
+   EVP_EncryptInit_ex(&encrypt, algo, nullptr, nullptr, nullptr);
+   EVP_DecryptInit_ex(&decrypt, algo, nullptr, nullptr, nullptr);
+
+   EVP_CIPHER_CTX_set_padding(&encrypt, 0);
+   EVP_CIPHER_CTX_set_padding(&decrypt, 0);
+   }
+
+OpenSSL_BlockCipher::~OpenSSL_BlockCipher()
+   {
+   EVP_CIPHER_CTX_cleanup(&encrypt);
+   EVP_CIPHER_CTX_cleanup(&decrypt);
+   }
+
+/*
+* Set the key
+*/
+void OpenSSL_BlockCipher::key_schedule(const byte key[], size_t length)
+   {
+   secure_vector<byte> full_key(key, key + length);
+
+   if(cipher_name == "TripleDES" && length == 16)
+      {
+      full_key += std::make_pair(key, 8);
+      }
+   else
+      if(EVP_CIPHER_CTX_set_key_length(&encrypt, length) == 0 ||
+         EVP_CIPHER_CTX_set_key_length(&decrypt, length) == 0)
+         throw Invalid_Argument("OpenSSL_BlockCipher: Bad key length for " +
+                                cipher_name);
+
+   EVP_EncryptInit_ex(&encrypt, nullptr, nullptr, &full_key[0], nullptr);
+   EVP_DecryptInit_ex(&decrypt, nullptr, nullptr, &full_key[0], nullptr);
+   }
+
+/*
+* Return a clone of this object
+*/
+BlockCipher* OpenSSL_BlockCipher::clone() const
+   {
+   return new OpenSSL_BlockCipher(EVP_CIPHER_CTX_cipher(&encrypt),
+                              cipher_name,
+                              cipher_key_spec.minimum_keylength(),
+                              cipher_key_spec.maximum_keylength(),
+                              cipher_key_spec.keylength_multiple());
+   }
+
+/*
+* Clear memory of sensitive data
+*/
+void OpenSSL_BlockCipher::clear()
+   {
+   const EVP_CIPHER* algo = EVP_CIPHER_CTX_cipher(&encrypt);
+
+   EVP_CIPHER_CTX_cleanup(&encrypt);
+   EVP_CIPHER_CTX_cleanup(&decrypt);
+   EVP_CIPHER_CTX_init(&encrypt);
+   EVP_CIPHER_CTX_init(&decrypt);
+   EVP_EncryptInit_ex(&encrypt, algo, nullptr, nullptr, nullptr);
+   EVP_DecryptInit_ex(&decrypt, algo, nullptr, nullptr, nullptr);
+   EVP_CIPHER_CTX_set_padding(&encrypt, 0);
+   EVP_CIPHER_CTX_set_padding(&decrypt, 0);
+   }
+
+std::function<BlockCipher* (const BlockCipher::Spec&)>
+make_evp_block_maker(const EVP_CIPHER* cipher, const char* algo)
+   {
+   return [cipher,algo](const BlockCipher::Spec&)
+      {
+      return new OpenSSL_BlockCipher(cipher, algo);
+      };
+   }
+
+std::function<BlockCipher* (const BlockCipher::Spec&)>
+make_evp_block_maker_keylen(const EVP_CIPHER* cipher, const char* algo,
+                            size_t kmin, size_t kmax, size_t kmod)
+   {
+   return [cipher,algo,kmin,kmax,kmod](const BlockCipher::Spec&)
+      {
+      return new OpenSSL_BlockCipher(cipher, algo, kmin, kmax, kmod);
+      };
+   }
+
+#define BOTAN_REGISTER_OPENSSL_EVP_BLOCK(NAME, EVP)                            \
+   BOTAN_REGISTER_TYPE(BlockCipher, EVP_BlockCipher ## EVP, NAME,              \
+                       make_evp_block_maker(EVP(), NAME), "openssl", 96);
+
+#define BOTAN_REGISTER_OPENSSL_EVP_BLOCK_KEYLEN(NAME, EVP, KMIN, KMAX, KMOD)       \
+   BOTAN_REGISTER_TYPE(BlockCipher, OpenSSL_BlockCipher ## EVP, NAME,              \
+                       make_evp_block_maker_keylen(EVP(), NAME, KMIN, KMAX, KMOD), \
+                       "openssl", 96);
+
+#if !defined(OPENSSL_NO_AES)
+   BOTAN_REGISTER_OPENSSL_EVP_BLOCK("AES-128", EVP_aes_128_ecb);
+   BOTAN_REGISTER_OPENSSL_EVP_BLOCK("AES-192", EVP_aes_192_ecb);
+   BOTAN_REGISTER_OPENSSL_EVP_BLOCK("AES-256", EVP_aes_256_ecb);
+#endif
+
+#if !defined(OPENSSL_NO_DES)
+   BOTAN_REGISTER_OPENSSL_EVP_BLOCK("DES", EVP_des_ecb);
+   BOTAN_REGISTER_OPENSSL_EVP_BLOCK_KEYLEN("TripleDES", EVP_des_ede3_ecb, 16, 24, 8);
+#endif
+
+#if !defined(OPENSSL_NO_BF)
+   BOTAN_REGISTER_OPENSSL_EVP_BLOCK_KEYLEN("Blowfish", EVP_bf_ecb, 1, 56, 1);
+#endif
+
+#if !defined(OPENSSL_NO_CAST)
+   BOTAN_REGISTER_OPENSSL_EVP_BLOCK_KEYLEN("CAST-128", EVP_cast5_ecb, 1, 16, 1);
+#endif
+
+#if !defined(OPENSSL_NO_CAMELLIA)
+   BOTAN_REGISTER_OPENSSL_EVP_BLOCK("Camellia-128", EVP_camellia_128_ecb);
+   BOTAN_REGISTER_OPENSSL_EVP_BLOCK("Camellia-192", EVP_camellia_192_ecb);
+   BOTAN_REGISTER_OPENSSL_EVP_BLOCK("Camellia-256", EVP_camellia_256_ecb);
+#endif
+
+#if !defined(OPENSSL_NO_IDEA)
+   BOTAN_REGISTER_OPENSSL_EVP_BLOCK("IDEA", EVP_idea_ecb);
+#endif
+
+#if !defined(OPENSSL_NO_SEED)
+   BOTAN_REGISTER_OPENSSL_EVP_BLOCK("SEED", EVP_seed_ecb);
+#endif
+
+}
+
+}
diff --git a/src/lib/vendor/openssl/openssl_hash.cpp b/src/lib/vendor/openssl/openssl_hash.cpp
new file mode 100644
index 000000000..6133e36a4
--- /dev/null
+++ b/src/lib/vendor/openssl/openssl_hash.cpp
@@ -0,0 +1,115 @@
+/*
+* OpenSSL Hash Functions
+* (C) 1999-2007,2015 Jack Lloyd
+*
+* Botan is released under the Simplified BSD License (see license.txt)
+*/
+
+#include <botan/internal/hash_utils.h>
+#include <openssl/evp.h>
+
+namespace Botan {
+
+namespace {
+
+class OpenSSL_HashFunction : public HashFunction
+   {
+   public:
+      void clear()
+         {
+         const EVP_MD* algo = EVP_MD_CTX_md(&m_md);
+         EVP_DigestInit_ex(&m_md, algo, nullptr);
+         }
+
+      std::string name() const { return m_name; }
+
+      HashFunction* clone() const
+         {
+         const EVP_MD* algo = EVP_MD_CTX_md(&m_md);
+         return new OpenSSL_HashFunction(algo, name());
+         }
+
+      size_t output_length() const
+         {
+         return EVP_MD_size(EVP_MD_CTX_md(&m_md));
+         }
+
+      size_t hash_block_size() const
+         {
+         return EVP_MD_block_size(EVP_MD_CTX_md(&m_md));
+         }
+
+      OpenSSL_HashFunction(const EVP_MD* md, const std::string& name) : m_name(name)
+         {
+         EVP_MD_CTX_init(&m_md);
+         EVP_DigestInit_ex(&m_md, md, nullptr);
+         }
+
+      ~OpenSSL_HashFunction()
+         {
+         EVP_MD_CTX_cleanup(&m_md);
+         }
+
+   private:
+      void add_data(const byte input[], size_t length)
+         {
+         EVP_DigestUpdate(&m_md, input, length);
+         }
+
+      void final_result(byte output[])
+         {
+         EVP_DigestFinal_ex(&m_md, output, nullptr);
+         const EVP_MD* algo = EVP_MD_CTX_md(&m_md);
+         EVP_DigestInit_ex(&m_md, algo, nullptr);
+         }
+
+      std::string m_name;
+      EVP_MD_CTX m_md;
+   };
+
+std::function<HashFunction* (const HashFunction::Spec&)>
+make_evp_hash_maker(const EVP_MD* md, const char* algo)
+   {
+   return [md,algo](const HashFunction::Spec&)
+      {
+      return new OpenSSL_HashFunction(md, algo);
+      };
+   }
+
+#define BOTAN_REGISTER_OPENSSL_EVP_HASH(NAME, EVP)                      \
+   BOTAN_REGISTER_TYPE(HashFunction, OpenSSL_HashFunction ## EVP, NAME, \
+                       make_evp_hash_maker(EVP(), NAME), "openssl", 32);
+
+#if !defined(OPENSSL_NO_SHA)
+   BOTAN_REGISTER_OPENSSL_EVP_HASH("SHA-160", EVP_sha1);
+#endif
+
+#if !defined(OPENSSL_NO_SHA256)
+   BOTAN_REGISTER_OPENSSL_EVP_HASH("SHA-224", EVP_sha224);
+   BOTAN_REGISTER_OPENSSL_EVP_HASH("SHA-256", EVP_sha256);
+#endif
+
+#if !defined(OPENSSL_NO_SHA512)
+   BOTAN_REGISTER_OPENSSL_EVP_HASH("SHA-384", EVP_sha384);
+   BOTAN_REGISTER_OPENSSL_EVP_HASH("SHA-512", EVP_sha512);
+#endif
+
+#if !defined(OPENSSL_NO_MD2)
+   BOTAN_REGISTER_OPENSSL_EVP_HASH("MD2", EVP_md2);
+#endif
+
+#if !defined(OPENSSL_NO_MD4)
+   BOTAN_REGISTER_OPENSSL_EVP_HASH("MD4", EVP_md4);
+#endif
+
+#if !defined(OPENSSL_NO_MD5)
+   BOTAN_REGISTER_OPENSSL_EVP_HASH("MD5", EVP_md5);
+#endif
+
+#if !defined(OPENSSL_NO_RIPEMD)
+   BOTAN_REGISTER_OPENSSL_EVP_HASH("RIPEMD-160", EVP_ripemd160);
+#endif
+
+}
+
+}
diff --git a/src/lib/vendor/openssl/openssl_rc4.cpp b/src/lib/vendor/openssl/openssl_rc4.cpp
new file mode 100644
index 000000000..966aecd66
--- /dev/null
+++ b/src/lib/vendor/openssl/openssl_rc4.cpp
@@ -0,0 +1,49 @@
+/*
+* OpenSSL RC4
+* (C) 1999-2007,2015 Jack Lloyd
+*
+* Botan is released under the Simplified BSD License (see license.txt)
+*/
+
+#include <botan/internal/stream_utils.h>
+#include <botan/parsing.h>
+#include <openssl/rc4.h>
+
+namespace Botan {
+
+namespace {
+
+class OpenSSL_RC4 : public StreamCipher
+   {
+   public:
+      void clear() { clear_mem(&m_rc4, 1); }
+
+      std::string name() const { return "RC4"; }
+      StreamCipher* clone() const { return new OpenSSL_RC4; }
+
+      Key_Length_Specification key_spec() const
+         {
+         return Key_Length_Specification(1, 32);
+         }
+
+      OpenSSL_RC4() { clear(); }
+      ~OpenSSL_RC4() { clear(); }
+   private:
+      void cipher(const byte in[], byte out[], size_t length)
+         {
+         RC4(&m_rc4, length, in, out);
+         }
+
+      void key_schedule(const byte key[], size_t length)
+         {
+         RC4_set_key(&m_rc4, length, key);
+         }
+
+      RC4_KEY m_rc4;
+   };
+
+}
+
+BOTAN_REGISTER_TYPE(StreamCipher, OpenSSL_RC4, "RC4", make_new_T<OpenSSL_RC4>, "openssl", 64);
+
+}