propagate from branch 'net.randombit.botan.1_8' (head 3158f8272a3582dd44dfb771665eb71f7d005339)

            to branch 'net.randombit.botan' (head bf629b13dd132b263e76a72b7eca0f7e4ab19aac)

9 files changed, 214 insertions, 110 deletions

diff --git a/src/engine/def_engine/def_eng.h b/src/engine/def_engine/def_eng.h
index 2d7145480..ba5bee8ef 100644
--- a/src/engine/def_engine/def_eng.h
+++ b/src/engine/def_engine/def_eng.h
@@ -78,6 +78,11 @@ class BOTAN_DLL Default_Engine : public Engine
                                           Algorithm_Factory&) const;
    };
 
+Keyed_Filter* get_cipher_mode(const BlockCipher* block_cipher,
+                              Cipher_Dir direction,
+                              const std::string& mode,
+                              const std::string& padding);
+
 }
 
 #endif
diff --git a/src/engine/def_engine/def_mode.cpp b/src/engine/def_engine/def_mode.cpp
index 2b093a0a3..b7373ef84 100644
--- a/src/engine/def_engine/def_mode.cpp
+++ b/src/engine/def_engine/def_mode.cpp
@@ -32,7 +32,7 @@
   #include <botan/ofb.h>
 #endif
 
-#if defined(BOTAN_HAS_CTR)
+#if defined(BOTAN_HAS_CTR_BE)
   #include <botan/ctr.h>
 #endif
 
@@ -51,22 +51,22 @@ namespace {
 /**
 * Get a block cipher padding method by name
 */
-BlockCipherModePaddingMethod* get_bc_pad(const std::string& algo_spec)
+BlockCipherModePaddingMethod* get_bc_pad(const std::string& algo_spec,
+                                         const std::string& def_if_empty)
    {
-   SCAN_Name request(algo_spec);
-
 #if defined(BOTAN_HAS_CIPHER_MODE_PADDING)
-   if(request.algo_name() == "PKCS7")
+   if(algo_spec == "NoPadding" || (algo_spec == "" && def_if_empty == "NoPadding"))
+      return new Null_Padding;
+
+   if(algo_spec == "PKCS7" || (algo_spec == "" && def_if_empty == "PKCS7"))
       return new PKCS7_Padding;
 
-   if(request.algo_name() == "OneAndZeros")
+   if(algo_spec == "OneAndZeros")
       return new OneAndZeros_Padding;
 
-   if(request.algo_name() == "X9.23")
+   if(algo_spec == "X9.23")
       return new ANSI_X923_Padding;
 
-   if(request.algo_name() == "NoPadding")
-      return new Null_Padding;
 #endif
 
    throw Algorithm_Not_Found(algo_spec);
@@ -74,85 +74,30 @@ BlockCipherModePaddingMethod* get_bc_pad(const std::string& algo_spec)
 
 }
 
-/*
-* Get a cipher object
-*/
-Keyed_Filter* Default_Engine::get_cipher(const std::string& algo_spec,
-                                         Cipher_Dir direction,
-                                         Algorithm_Factory& af)
+Keyed_Filter* get_cipher_mode(const BlockCipher* block_cipher,
+                              Cipher_Dir direction,
+                              const std::string& mode,
+                              const std::string& padding)
    {
-   std::vector<std::string> algo_parts = split_on(algo_spec, '/');
-   if(algo_parts.empty())
-      throw Invalid_Algorithm_Name(algo_spec);
-
-   const std::string cipher_name = algo_parts[0];
-
-   // check if it is a stream cipher first (easy case)
-   const StreamCipher* stream_cipher = af.prototype_stream_cipher(cipher_name);
-   if(stream_cipher)
-      return new StreamCipher_Filter(stream_cipher->clone());
-
-   const BlockCipher* block_cipher = af.prototype_block_cipher(cipher_name);
-   if(!block_cipher)
-      return 0;
-
-   if(algo_parts.size() != 2 && algo_parts.size() != 3)
-      return 0;
-
-   std::string mode = algo_parts[1];
-   u32bit bits = 0;
-
-   if(mode.find("CFB") != std::string::npos ||
-      mode.find("EAX") != std::string::npos)
-      {
-      std::vector<std::string> algo_info = parse_algorithm_name(mode);
-      mode = algo_info[0];
-      if(algo_info.size() == 1)
-         bits = 8*block_cipher->BLOCK_SIZE;
-      else if(algo_info.size() == 2)
-         bits = to_u32bit(algo_info[1]);
-      else
-         throw Invalid_Algorithm_Name(algo_spec);
-      }
-
-   std::string padding;
-   if(algo_parts.size() == 3)
-      padding = algo_parts[2];
-   else
-      padding = (mode == "CBC") ? "PKCS7" : "NoPadding";
-
-   if(mode == "ECB" && padding == "CTS")
-      return 0;
-   else if((mode != "CBC" && mode != "ECB") && padding != "NoPadding")
-      throw Invalid_Algorithm_Name(algo_spec);
-
 #if defined(BOTAN_HAS_OFB)
    if(mode == "OFB")
-      return new OFB(block_cipher->clone());
+      return new StreamCipher_Filter(new OFB(block_cipher->clone()));
 #endif
 
-#if defined(BOTAN_HAS_CTR)
+#if defined(BOTAN_HAS_CTR_BE)
    if(mode == "CTR-BE")
-      return new CTR_BE(block_cipher->clone());
+      return new StreamCipher_Filter(new CTR_BE(block_cipher->clone()));
 #endif
 
 #if defined(BOTAN_HAS_ECB)
-   if(mode == "ECB")
-      {
-      if(direction == ENCRYPTION)
-         return new ECB_Encryption(block_cipher->clone(), get_bc_pad(padding));
-      else
-         return new ECB_Decryption(block_cipher->clone(), get_bc_pad(padding));
-      }
-#endif
-
-#if defined(BOTAN_HAS_CFB)
-   if(mode == "CFB")
+   if(mode == "ECB" || mode == "")
       {
       if(direction == ENCRYPTION)
-         return new CFB_Encryption(block_cipher->clone(), bits);
+         return new ECB_Encryption(block_cipher->clone(),
+                                   get_bc_pad(padding, "NoPadding"));
       else
-         return new CFB_Decryption(block_cipher->clone(), bits);
+         return new ECB_Decryption(block_cipher->clone(),
+                                   get_bc_pad(padding, "NoPadding"));
       }
 #endif
 
@@ -173,25 +118,15 @@ Keyed_Filter* Default_Engine::get_cipher(const std::string& algo_spec,
 #if defined(BOTAN_HAS_CBC)
       if(direction == ENCRYPTION)
          return new CBC_Encryption(block_cipher->clone(),
-                                   get_bc_pad(padding));
+                                   get_bc_pad(padding, "PKCS7"));
       else
          return new CBC_Decryption(block_cipher->clone(),
-                                   get_bc_pad(padding));
+                                   get_bc_pad(padding, "PKCS7"));
 #else
       return 0;
 #endif
       }
 
-#if defined(BOTAN_HAS_EAX)
-   if(mode == "EAX")
-      {
-      if(direction == ENCRYPTION)
-         return new EAX_Encryption(block_cipher->clone(), bits);
-      else
-         return new EAX_Decryption(block_cipher->clone(), bits);
-      }
-#endif
-
 #if defined(BOTAN_HAS_XTS)
    if(mode == "XTS")
       {
@@ -202,6 +137,86 @@ Keyed_Filter* Default_Engine::get_cipher(const std::string& algo_spec,
       }
 #endif
 
+   if(mode.find("CFB") != std::string::npos ||
+      mode.find("EAX") != std::string::npos)
+      {
+      u32bit bits = 0;
+
+      std::vector<std::string> algo_info = parse_algorithm_name(mode);
+      std::string mode_name = algo_info[0];
+      if(algo_info.size() == 1)
+         bits = 8*block_cipher->BLOCK_SIZE;
+      else if(algo_info.size() == 2)
+         bits = to_u32bit(algo_info[1]);
+      else
+         return 0;
+
+#if defined(BOTAN_HAS_CFB)
+      if(mode_name == "CFB")
+         {
+         if(direction == ENCRYPTION)
+            return new CFB_Encryption(block_cipher->clone(), bits);
+         else
+            return new CFB_Decryption(block_cipher->clone(), bits);
+         }
+#endif
+
+#if defined(BOTAN_HAS_EAX)
+      if(mode_name == "EAX")
+         {
+         if(direction == ENCRYPTION)
+            return new EAX_Encryption(block_cipher->clone(), bits);
+         else
+            return new EAX_Decryption(block_cipher->clone(), bits);
+         }
+#endif
+      }
+
+   return 0;
+   }
+
+/*
+* Get a cipher object
+*/
+Keyed_Filter* Default_Engine::get_cipher(const std::string& algo_spec,
+                                         Cipher_Dir direction,
+                                         Algorithm_Factory& af)
+   {
+   std::vector<std::string> algo_parts = split_on(algo_spec, '/');
+   if(algo_parts.empty())
+      throw Invalid_Algorithm_Name(algo_spec);
+
+   const std::string cipher_name = algo_parts[0];
+
+   // check if it is a stream cipher first (easy case)
+   const StreamCipher* stream_cipher = af.prototype_stream_cipher(cipher_name);
+   if(stream_cipher)
+      return new StreamCipher_Filter(stream_cipher->clone());
+
+   const BlockCipher* block_cipher = af.prototype_block_cipher(cipher_name);
+   if(!block_cipher)
+      return 0;
+
+   if(algo_parts.size() != 2 && algo_parts.size() != 3)
+      return 0;
+
+   std::string mode = algo_parts[1];
+
+   std::string padding;
+   if(algo_parts.size() == 3)
+      padding = algo_parts[2];
+   else
+      padding = (mode == "CBC") ? "PKCS7" : "NoPadding";
+
+   if(mode == "ECB" && padding == "CTS")
+      return 0;
+   else if((mode != "CBC" && mode != "ECB") && padding != "NoPadding")
+      throw Invalid_Algorithm_Name(algo_spec);
+
+   Keyed_Filter* filt = get_cipher_mode(block_cipher, direction, mode, padding);
+   if(filt)
+      return filt;
+
    throw Algorithm_Not_Found("get_mode: " + cipher_name + "/" +
                              mode + "/" + padding);
    }
diff --git a/src/engine/def_engine/lookup_hash.cpp b/src/engine/def_engine/lookup_hash.cpp
index 58136fc5a..9b2018736 100644
--- a/src/engine/def_engine/lookup_hash.cpp
+++ b/src/engine/def_engine/lookup_hash.cpp
@@ -22,6 +22,10 @@
   #include <botan/crc32.h>
 #endif
 
+#if defined(BOTAN_HAS_BMW_512)
+  #include <botan/bmw_512.h>
+#endif
+
 #if defined(BOTAN_HAS_FORK_256)
   #include <botan/fork256.h>
 #endif
@@ -103,6 +107,11 @@ Default_Engine::find_hash(const SCAN_Name& request,
       return new CRC32;
 #endif
 
+#if defined(BOTAN_HAS_BMW_512)
+   if(request.algo_name() == "BMW-512")
+      return new BMW_512;
+#endif
+
 #if defined(BOTAN_HAS_FORK_256)
    if(request.algo_name() == "FORK-256")
       return new FORK_256;
diff --git a/src/engine/openssl/arc4_openssl.cpp b/src/engine/openssl/arc4_openssl.cpp
index 08ed3eb10..793e1faff 100644
--- a/src/engine/openssl/arc4_openssl.cpp
+++ b/src/engine/openssl/arc4_openssl.cpp
@@ -19,7 +19,7 @@ namespace {
 class ARC4_OpenSSL : public StreamCipher
    {
    public:
-      void clear() throw() { std::memset(&state, 0, sizeof(state)); }
+      void clear() { std::memset(&state, 0, sizeof(state)); }
       std::string name() const;
       StreamCipher* clone() const { return new ARC4_OpenSSL(SKIP); }
 
diff --git a/src/engine/openssl/ossl_bc.cpp b/src/engine/openssl/ossl_bc.cpp
index 4d3761adb..7fdf54e42 100644
--- a/src/engine/openssl/ossl_bc.cpp
+++ b/src/engine/openssl/ossl_bc.cpp
@@ -18,7 +18,7 @@ namespace {
 class EVP_BlockCipher : public BlockCipher
    {
    public:
-      void clear() throw();
+      void clear();
       std::string name() const { return cipher_name; }
       BlockCipher* clone() const;
       EVP_BlockCipher(const EVP_CIPHER*, const std::string&);
@@ -27,8 +27,8 @@ class EVP_BlockCipher : public BlockCipher
 
       ~EVP_BlockCipher();
    private:
-      void enc(const byte[], byte[]) const;
-      void dec(const byte[], byte[]) const;
+      void encrypt_n(const byte in[], byte out[], u32bit blocks) const;
+      void decrypt_n(const byte in[], byte out[], u32bit blocks) const;
       void key_schedule(const byte[], u32bit);
       std::string cipher_name;
       mutable EVP_CIPHER_CTX encrypt, decrypt;
@@ -90,19 +90,21 @@ EVP_BlockCipher::~EVP_BlockCipher()
 /*
 * Encrypt a block
 */
-void EVP_BlockCipher::enc(const byte in[], byte out[]) const
+void EVP_BlockCipher::encrypt_n(const byte in[], byte out[],
+                                u32bit blocks) const
    {
    int out_len = 0;
-   EVP_EncryptUpdate(&encrypt, out, &out_len, in, BLOCK_SIZE);
+   EVP_EncryptUpdate(&encrypt, out, &out_len, in, blocks * BLOCK_SIZE);
    }
 
 /*
 * Decrypt a block
 */
-void EVP_BlockCipher::dec(const byte in[], byte out[]) const
+void EVP_BlockCipher::decrypt_n(const byte in[], byte out[],
+                                u32bit blocks) const
    {
    int out_len = 0;
-   EVP_DecryptUpdate(&decrypt, out, &out_len, in, BLOCK_SIZE);
+   EVP_DecryptUpdate(&decrypt, out, &out_len, in, blocks * BLOCK_SIZE);
    }
 
 /*
@@ -143,7 +145,7 @@ BlockCipher* EVP_BlockCipher::clone() const
 /*
 * Clear memory of sensitive data
 */
-void EVP_BlockCipher::clear() throw()
+void EVP_BlockCipher::clear()
    {
    const EVP_CIPHER* algo = EVP_CIPHER_CTX_cipher(&encrypt);
 
@@ -174,7 +176,7 @@ OpenSSL_Engine::find_block_cipher(const SCAN_Name& request,
    if(request.algo_name() == NAME && request.arg_count() == 0)  \
       return new EVP_BlockCipher(EVP, NAME, MIN, MAX, MOD);
 
-#if 0
+#if !defined(OPENSSL_NO_AES)
    /*
    Using OpenSSL's AES causes crashes inside EVP on x86-64 with OpenSSL 0.9.8g
    cause is unknown
@@ -184,12 +186,36 @@ OpenSSL_Engine::find_block_cipher(const SCAN_Name& request,
    HANDLE_EVP_CIPHER("AES-256", EVP_aes_256_ecb());
 #endif
 
+#if !defined(OPENSSL_NO_DES)
    HANDLE_EVP_CIPHER("DES", EVP_des_ecb());
    HANDLE_EVP_CIPHER_KEYLEN("TripleDES", EVP_des_ede3_ecb(), 16, 24, 8);
+#endif
 
+#if !defined(OPENSSL_NO_BF)
    HANDLE_EVP_CIPHER_KEYLEN("Blowfish", EVP_bf_ecb(), 1, 56, 1);
+#endif
+
+#if !defined(OPENSSL_NO_CAST)
    HANDLE_EVP_CIPHER_KEYLEN("CAST-128", EVP_cast5_ecb(), 1, 16, 1);
+#endif
+
+#if !defined(OPENSSL_NO_RC2)
    HANDLE_EVP_CIPHER_KEYLEN("RC2", EVP_rc2_ecb(), 1, 32, 1);
+#endif
+
+#if !defined(OPENSSL_NO_RC5)
+   if(request.algo_name() == "RC5")
+      if(request.arg_as_u32bit(0, 12) == 12)
+         return new EVP_BlockCipher(EVP_rc5_32_12_16_ecb(), "RC5(12)", 1, 32, 1);
+#endif
+
+#if !defined(OPENSSL_NO_IDEA)
+   HANDLE_EVP_CIPHER("IDEA", EVP_idea_ecb());
+#endif
+
+#if !defined(OPENSSL_NO_SEED)
+   HANDLE_EVP_CIPHER("SEED", EVP_seed_ecb());
+#endif
 
 #undef HANDLE_EVP_CIPHER
 #undef HANDLE_EVP_CIPHER_KEYLEN
diff --git a/src/engine/openssl/ossl_md.cpp b/src/engine/openssl/ossl_md.cpp
index 7c8fb678c..1e01a6f25 100644
--- a/src/engine/openssl/ossl_md.cpp
+++ b/src/engine/openssl/ossl_md.cpp
@@ -18,7 +18,7 @@ namespace {
 class EVP_HashFunction : public HashFunction
    {
    public:
-      void clear() throw();
+      void clear();
       std::string name() const { return algo_name; }
       HashFunction* clone() const;
       EVP_HashFunction(const EVP_MD*, const std::string&);
@@ -52,7 +52,7 @@ void EVP_HashFunction::final_result(byte output[])
 /*
 * Clear memory of sensitive data
 */
-void EVP_HashFunction::clear() throw()
+void EVP_HashFunction::clear()
    {
    const EVP_MD* algo = EVP_MD_CTX_md(&md);
    EVP_DigestInit_ex(&md, algo, 0);
@@ -95,27 +95,41 @@ EVP_HashFunction::~EVP_HashFunction()
 HashFunction* OpenSSL_Engine::find_hash(const SCAN_Name& request,
                                         Algorithm_Factory&) const
    {
-#ifndef OPENSSL_NO_SHA
+#if !defined(OPENSSL_NO_SHA)
    if(request.algo_name() == "SHA-160")
       return new EVP_HashFunction(EVP_sha1(), "SHA-160");
 #endif
 
-#ifndef OPENSSL_NO_MD2
+#if !defined(OPENSSL_NO_SHA256)
+   if(request.algo_name() == "SHA-224")
+      return new EVP_HashFunction(EVP_sha224(), "SHA-224");
+   if(request.algo_name() == "SHA-256")
+      return new EVP_HashFunction(EVP_sha256(), "SHA-256");
+#endif
+
+#if !defined(OPENSSL_NO_SHA512)
+   if(request.algo_name() == "SHA-384")
+      return new EVP_HashFunction(EVP_sha384(), "SHA-384");
+   if(request.algo_name() == "SHA-512")
+      return new EVP_HashFunction(EVP_sha512(), "SHA-512");
+#endif
+
+#if !defined(OPENSSL_NO_MD2)
    if(request.algo_name() == "MD2")
       return new EVP_HashFunction(EVP_md2(), "MD2");
 #endif
 
-#ifndef OPENSSL_NO_MD4
+#if !defined(OPENSSL_NO_MD4)
    if(request.algo_name() == "MD4")
       return new EVP_HashFunction(EVP_md4(), "MD4");
 #endif
 
-#ifndef OPENSSL_NO_MD5
+#if !defined(OPENSSL_NO_MD5)
    if(request.algo_name() == "MD5")
       return new EVP_HashFunction(EVP_md5(), "MD5");
 #endif
 
-#ifndef OPENSSL_NO_RIPEMD
+#if !defined(OPENSSL_NO_RIPEMD)
    if(request.algo_name() == "RIPEMD-160")
       return new EVP_HashFunction(EVP_ripemd160(), "RIPEMD-160");
 #endif
diff --git a/src/engine/sse2_eng/eng_sse2.cpp b/src/engine/sse2_eng/eng_sse2.cpp
index c738b3d96..07c625c7c 100644
--- a/src/engine/sse2_eng/eng_sse2.cpp
+++ b/src/engine/sse2_eng/eng_sse2.cpp
@@ -1,21 +1,45 @@
 /**
 * SSE2 Assembly Engine
-* (C) 1999-2008 Jack Lloyd
+* (C) 1999-2009 Jack Lloyd
 *
 * Distributed under the terms of the Botan license
 */
 
 #include <botan/eng_sse2.h>
+#include <botan/cpuid.h>
 
 #if defined(BOTAN_HAS_SHA1_SSE2)
   #include <botan/sha1_sse2.h>
 #endif
 
+#if defined(BOTAN_HAS_SERPENT_SSE2)
+  #include <botan/serp_sse2.h>
+#endif
+
 namespace Botan {
 
-HashFunction* SSE2_Assembler_Engine::find_hash(const SCAN_Name& request,
-                                               Algorithm_Factory&) const
+BlockCipher*
+SSE2_Assembler_Engine::find_block_cipher(const SCAN_Name& request,
+                                         Algorithm_Factory&) const
+   {
+   if(!CPUID::has_sse2())
+      return 0;
+
+#if defined(BOTAN_HAS_SERPENT_SSE2)
+   if(request.algo_name() == "Serpent")
+      return new Serpent_SSE2;
+#endif
+
+   return 0;
+   }
+
+HashFunction*
+SSE2_Assembler_Engine::find_hash(const SCAN_Name& request,
+                                 Algorithm_Factory&) const
    {
+   if(!CPUID::has_sse2())
+      return 0;
+
 #if defined(BOTAN_HAS_SHA1_SSE2)
    if(request.algo_name() == "SHA-160")
       return new SHA_160_SSE2;
diff --git a/src/engine/sse2_eng/eng_sse2.h b/src/engine/sse2_eng/eng_sse2.h
index 129697e8f..c6b0ce889 100644
--- a/src/engine/sse2_eng/eng_sse2.h
+++ b/src/engine/sse2_eng/eng_sse2.h
@@ -1,6 +1,6 @@
 /**
 * SSE2 Assembly Engine
-* (C) 1999-2008 Jack Lloyd
+* (C) 1999-2009 Jack Lloyd
 *
 * Distributed under the terms of the Botan license
 */
@@ -17,6 +17,9 @@ class BOTAN_DLL SSE2_Assembler_Engine : public Engine
    public:
       std::string provider_name() const { return "sse2"; }
    private:
+      BlockCipher* find_block_cipher(const SCAN_Name&,
+                                     Algorithm_Factory&) const;
+
       HashFunction* find_hash(const SCAN_Name& reqeust,
                               Algorithm_Factory&) const;
    };
diff --git a/src/engine/sse2_eng/info.txt b/src/engine/sse2_eng/info.txt
index 6242c7fee..7508b9874 100644
--- a/src/engine/sse2_eng/info.txt
+++ b/src/engine/sse2_eng/info.txt
@@ -10,6 +10,14 @@ eng_sse2.h
 </add>
 
 <arch>
-ia32
+pentium-m
+pentium4
+prescott
 amd64
 </arch>
+
+<cc>
+gcc
+icc
+msvc
+</cc>