Rename Default_Engine to Core_Engine which describes its purposes

(slightly) better.

9 files changed, 1141 insertions, 0 deletions

diff --git a/src/engine/core_engine/core_engine.h b/src/engine/core_engine/core_engine.h
new file mode 100644
index 000000000..b8b8262ce
--- /dev/null
+++ b/src/engine/core_engine/core_engine.h
@@ -0,0 +1,68 @@
+/*
+* Core Engine
+* (C) 1999-2007 Jack Lloyd
+*
+* Distributed under the terms of the Botan license
+*/
+
+#ifndef BOTAN_CORE_ENGINE_H__
+#define BOTAN_CORE_ENGINE_H__
+
+#include <botan/engine.h>
+
+namespace Botan {
+
+/**
+* Core Engine
+*/
+class Core_Engine : public Engine
+   {
+   public:
+      std::string provider_name() const { return "core"; }
+
+      PK_Ops::Key_Agreement*
+         get_key_agreement_op(const Private_Key& key) const;
+
+      PK_Ops::Signature*
+         get_signature_op(const Private_Key& key) const;
+
+      PK_Ops::Verification* get_verify_op(const Public_Key& key) const;
+
+      PK_Ops::Encryption* get_encryption_op(const Public_Key& key) const;
+
+      PK_Ops::Decryption* get_decryption_op(const Private_Key& key) const;
+
+      Modular_Exponentiator* mod_exp(const BigInt& n,
+                                     Power_Mod::Usage_Hints) const;
+
+      Keyed_Filter* get_cipher(const std::string&, Cipher_Dir,
+                               Algorithm_Factory&);
+
+      BlockCipher* find_block_cipher(const SCAN_Name&,
+                                     Algorithm_Factory&) const;
+
+      StreamCipher* find_stream_cipher(const SCAN_Name&,
+                                       Algorithm_Factory&) const;
+
+      HashFunction* find_hash(const SCAN_Name& reqeust,
+                              Algorithm_Factory&) const;
+
+      MessageAuthenticationCode* find_mac(const SCAN_Name& reqeust,
+                                          Algorithm_Factory&) const;
+   };
+
+/**
+* Create a cipher mode filter object
+* @param block_cipher a block cipher object
+* @param direction are we encrypting or decrypting?
+* @param mode the name of the cipher mode to use
+* @param padding the mode padding to use (only used for ECB, CBC)
+*/
+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/core_engine/core_modes.cpp b/src/engine/core_engine/core_modes.cpp
new file mode 100644
index 000000000..a0d857a11
--- /dev/null
+++ b/src/engine/core_engine/core_modes.cpp
@@ -0,0 +1,224 @@
+/*
+* Core Engine
+* (C) 1999-2007 Jack Lloyd
+*
+* Distributed under the terms of the Botan license
+*/
+
+#include <botan/internal/core_engine.h>
+#include <botan/parsing.h>
+#include <botan/filters.h>
+#include <botan/algo_factory.h>
+#include <botan/mode_pad.h>
+#include <memory>
+
+#if defined(BOTAN_HAS_ECB)
+  #include <botan/ecb.h>
+#endif
+
+#if defined(BOTAN_HAS_CBC)
+  #include <botan/cbc.h>
+#endif
+
+#if defined(BOTAN_HAS_CTS)
+  #include <botan/cts.h>
+#endif
+
+#if defined(BOTAN_HAS_CFB)
+  #include <botan/cfb.h>
+#endif
+
+#if defined(BOTAN_HAS_OFB)
+  #include <botan/ofb.h>
+#endif
+
+#if defined(BOTAN_HAS_CTR_BE)
+  #include <botan/ctr.h>
+#endif
+
+#if defined(BOTAN_HAS_EAX)
+  #include <botan/eax.h>
+#endif
+
+#if defined(BOTAN_HAS_XTS)
+  #include <botan/xts.h>
+#endif
+
+namespace Botan {
+
+namespace {
+
+/**
+* Get a block cipher padding method by name
+*/
+BlockCipherModePaddingMethod* get_bc_pad(const std::string& algo_spec,
+                                         const std::string& def_if_empty)
+   {
+#if defined(BOTAN_HAS_CIPHER_MODE_PADDING)
+   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(algo_spec == "OneAndZeros")
+      return new OneAndZeros_Padding;
+
+   if(algo_spec == "X9.23")
+      return new ANSI_X923_Padding;
+
+#endif
+
+   throw Algorithm_Not_Found(algo_spec);
+   }
+
+}
+
+Keyed_Filter* get_cipher_mode(const BlockCipher* block_cipher,
+                              Cipher_Dir direction,
+                              const std::string& mode,
+                              const std::string& padding)
+   {
+#if defined(BOTAN_HAS_OFB)
+   if(mode == "OFB")
+      return new StreamCipher_Filter(new OFB(block_cipher->clone()));
+#endif
+
+#if defined(BOTAN_HAS_CTR_BE)
+   if(mode == "CTR-BE")
+      return new StreamCipher_Filter(new CTR_BE(block_cipher->clone()));
+#endif
+
+#if defined(BOTAN_HAS_ECB)
+   if(mode == "ECB" || mode == "")
+      {
+      if(direction == ENCRYPTION)
+         return new ECB_Encryption(block_cipher->clone(),
+                                   get_bc_pad(padding, "NoPadding"));
+      else
+         return new ECB_Decryption(block_cipher->clone(),
+                                   get_bc_pad(padding, "NoPadding"));
+      }
+#endif
+
+   if(mode == "CBC")
+      {
+      if(padding == "CTS")
+         {
+#if defined(BOTAN_HAS_CTS)
+         if(direction == ENCRYPTION)
+            return new CTS_Encryption(block_cipher->clone());
+         else
+            return new CTS_Decryption(block_cipher->clone());
+#else
+         return 0;
+#endif
+         }
+
+#if defined(BOTAN_HAS_CBC)
+      if(direction == ENCRYPTION)
+         return new CBC_Encryption(block_cipher->clone(),
+                                   get_bc_pad(padding, "PKCS7"));
+      else
+         return new CBC_Decryption(block_cipher->clone(),
+                                   get_bc_pad(padding, "PKCS7"));
+#else
+      return 0;
+#endif
+      }
+
+#if defined(BOTAN_HAS_XTS)
+   if(mode == "XTS")
+      {
+      if(direction == ENCRYPTION)
+         return new XTS_Encryption(block_cipher->clone());
+      else
+         return new XTS_Decryption(block_cipher->clone());
+      }
+#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* Core_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/core_engine/def_pk_ops.cpp b/src/engine/core_engine/def_pk_ops.cpp
new file mode 100644
index 000000000..db418d5bc
--- /dev/null
+++ b/src/engine/core_engine/def_pk_ops.cpp
@@ -0,0 +1,170 @@
+/*
+* PK Operations
+* (C) 1999-2010 Jack Lloyd
+*
+* Distributed under the terms of the Botan license
+*/
+
+#include <botan/internal/core_engine.h>
+
+#if defined(BOTAN_HAS_RSA)
+  #include <botan/rsa.h>
+#endif
+
+#if defined(BOTAN_HAS_RW)
+  #include <botan/rw.h>
+#endif
+
+#if defined(BOTAN_HAS_DSA)
+  #include <botan/dsa.h>
+#endif
+
+#if defined(BOTAN_HAS_ECDSA)
+  #include <botan/ecdsa.h>
+#endif
+
+#if defined(BOTAN_HAS_ELGAMAL)
+  #include <botan/elgamal.h>
+#endif
+
+#if defined(BOTAN_HAS_GOST_34_10_2001)
+  #include <botan/gost_3410.h>
+#endif
+
+#if defined(BOTAN_HAS_NYBERG_RUEPPEL)
+  #include <botan/nr.h>
+#endif
+
+#if defined(BOTAN_HAS_DIFFIE_HELLMAN)
+  #include <botan/dh.h>
+#endif
+
+#if defined(BOTAN_HAS_ECDH)
+  #include <botan/ecdh.h>
+#endif
+
+namespace Botan {
+
+PK_Ops::Encryption*
+Core_Engine::get_encryption_op(const Public_Key& key) const
+   {
+#if defined(BOTAN_HAS_RSA)
+   if(const RSA_PublicKey* s = dynamic_cast<const RSA_PublicKey*>(&key))
+      return new RSA_Public_Operation(*s);
+#endif
+
+#if defined(BOTAN_HAS_ELGAMAL)
+   if(const ElGamal_PublicKey* s = dynamic_cast<const ElGamal_PublicKey*>(&key))
+      return new ElGamal_Encryption_Operation(*s);
+#endif
+
+   return 0;
+   }
+
+PK_Ops::Decryption*
+Core_Engine::get_decryption_op(const Private_Key& key) const
+   {
+#if defined(BOTAN_HAS_RSA)
+   if(const RSA_PrivateKey* s = dynamic_cast<const RSA_PrivateKey*>(&key))
+      return new RSA_Private_Operation(*s);
+#endif
+
+#if defined(BOTAN_HAS_ELGAMAL)
+   if(const ElGamal_PrivateKey* s = dynamic_cast<const ElGamal_PrivateKey*>(&key))
+      return new ElGamal_Decryption_Operation(*s);
+#endif
+
+   return 0;
+   }
+
+PK_Ops::Key_Agreement*
+Core_Engine::get_key_agreement_op(const Private_Key& key) const
+   {
+#if defined(BOTAN_HAS_DIFFIE_HELLMAN)
+   if(const DH_PrivateKey* dh = dynamic_cast<const DH_PrivateKey*>(&key))
+      return new DH_KA_Operation(*dh);
+#endif
+
+#if defined(BOTAN_HAS_ECDH)
+   if(const ECDH_PrivateKey* ecdh = dynamic_cast<const ECDH_PrivateKey*>(&key))
+      return new ECDH_KA_Operation(*ecdh);
+#endif
+
+   return 0;
+   }
+
+PK_Ops::Signature*
+Core_Engine::get_signature_op(const Private_Key& key) const
+   {
+#if defined(BOTAN_HAS_RSA)
+   if(const RSA_PrivateKey* s = dynamic_cast<const RSA_PrivateKey*>(&key))
+      return new RSA_Private_Operation(*s);
+#endif
+
+#if defined(BOTAN_HAS_RW)
+   if(const RW_PrivateKey* s = dynamic_cast<const RW_PrivateKey*>(&key))
+      return new RW_Signature_Operation(*s);
+#endif
+
+#if defined(BOTAN_HAS_DSA)
+   if(const DSA_PrivateKey* s = dynamic_cast<const DSA_PrivateKey*>(&key))
+      return new DSA_Signature_Operation(*s);
+#endif
+
+#if defined(BOTAN_HAS_ECDSA)
+   if(const ECDSA_PrivateKey* s = dynamic_cast<const ECDSA_PrivateKey*>(&key))
+      return new ECDSA_Signature_Operation(*s);
+#endif
+
+#if defined(BOTAN_HAS_GOST_34_10_2001)
+   if(const GOST_3410_PrivateKey* s =
+         dynamic_cast<const GOST_3410_PrivateKey*>(&key))
+      return new GOST_3410_Signature_Operation(*s);
+#endif
+
+#if defined(BOTAN_HAS_NYBERG_RUEPPEL)
+   if(const NR_PrivateKey* s = dynamic_cast<const NR_PrivateKey*>(&key))
+      return new NR_Signature_Operation(*s);
+#endif
+
+   return 0;
+   }
+
+PK_Ops::Verification*
+Core_Engine::get_verify_op(const Public_Key& key) const
+   {
+#if defined(BOTAN_HAS_RSA)
+   if(const RSA_PublicKey* s = dynamic_cast<const RSA_PublicKey*>(&key))
+      return new RSA_Public_Operation(*s);
+#endif
+
+#if defined(BOTAN_HAS_RW)
+   if(const RW_PublicKey* s = dynamic_cast<const RW_PublicKey*>(&key))
+      return new RW_Verification_Operation(*s);
+#endif
+
+#if defined(BOTAN_HAS_DSA)
+   if(const DSA_PublicKey* s = dynamic_cast<const DSA_PublicKey*>(&key))
+      return new DSA_Verification_Operation(*s);
+#endif
+
+#if defined(BOTAN_HAS_ECDSA)
+   if(const ECDSA_PublicKey* s = dynamic_cast<const ECDSA_PublicKey*>(&key))
+      return new ECDSA_Verification_Operation(*s);
+#endif
+
+#if defined(BOTAN_HAS_GOST_34_10_2001)
+   if(const GOST_3410_PublicKey* s =
+         dynamic_cast<const GOST_3410_PublicKey*>(&key))
+      return new GOST_3410_Verification_Operation(*s);
+#endif
+
+#if defined(BOTAN_HAS_NYBERG_RUEPPEL)
+   if(const NR_PublicKey* s = dynamic_cast<const NR_PublicKey*>(&key))
+      return new NR_Verification_Operation(*s);
+#endif
+
+   return 0;
+   }
+
+}
diff --git a/src/engine/core_engine/def_powm.cpp b/src/engine/core_engine/def_powm.cpp
new file mode 100644
index 000000000..56a4b6844
--- /dev/null
+++ b/src/engine/core_engine/def_powm.cpp
@@ -0,0 +1,24 @@
+/*
+* Modular Exponentiation
+* (C) 1999-2007 Jack Lloyd
+*
+* Distributed under the terms of the Botan license
+*/
+
+#include <botan/internal/core_engine.h>
+#include <botan/internal/def_powm.h>
+
+namespace Botan {
+
+/*
+* Choose a modular exponentation algorithm
+*/
+Modular_Exponentiator*
+Core_Engine::mod_exp(const BigInt& n, Power_Mod::Usage_Hints hints) const
+   {
+   if(n.is_odd())
+      return new Montgomery_Exponentiator(n, hints);
+   return new Fixed_Window_Exponentiator(n, hints);
+   }
+
+}
diff --git a/src/engine/core_engine/info.txt b/src/engine/core_engine/info.txt
new file mode 100644
index 000000000..ea059b3c6
--- /dev/null
+++ b/src/engine/core_engine/info.txt
@@ -0,0 +1,23 @@
+define CORE_ENGINE
+
+<header:internal>
+core_engine.h
+</header:internal>
+
+<source>
+core_modes.cpp
+def_pk_ops.cpp
+def_powm.cpp
+lookup_block.cpp
+lookup_hash.cpp
+lookup_mac.cpp
+lookup_stream.cpp
+</source>
+
+<requires>
+algo_factory
+filters
+libstate
+mode_pad
+numbertheory
+</requires>
diff --git a/src/engine/core_engine/lookup_block.cpp b/src/engine/core_engine/lookup_block.cpp
new file mode 100644
index 000000000..52967fade
--- /dev/null
+++ b/src/engine/core_engine/lookup_block.cpp
@@ -0,0 +1,278 @@
+/*
+* Block Cipher Lookup
+* (C) 1999-2007 Jack Lloyd
+*
+* Distributed under the terms of the Botan license
+*/
+
+#include <botan/internal/core_engine.h>
+#include <botan/scan_name.h>
+#include <botan/algo_factory.h>
+
+#if defined(BOTAN_HAS_AES)
+  #include <botan/aes.h>
+#endif
+
+#if defined(BOTAN_HAS_BLOWFISH)
+  #include <botan/blowfish.h>
+#endif
+
+#if defined(BOTAN_HAS_CAST)
+  #include <botan/cast128.h>
+  #include <botan/cast256.h>
+#endif
+
+#if defined(BOTAN_HAS_CASCADE)
+  #include <botan/cascade.h>
+#endif
+
+#if defined(BOTAN_HAS_DES)
+  #include <botan/des.h>
+  #include <botan/desx.h>
+#endif
+
+#if defined(BOTAN_HAS_GOST_28147_89)
+  #include <botan/gost_28147.h>
+#endif
+
+#if defined(BOTAN_HAS_IDEA)
+  #include <botan/idea.h>
+#endif
+
+#if defined(BOTAN_HAS_KASUMI)
+  #include <botan/kasumi.h>
+#endif
+
+#if defined(BOTAN_HAS_LION)
+  #include <botan/lion.h>
+#endif
+
+#if defined(BOTAN_HAS_LUBY_RACKOFF)
+  #include <botan/lubyrack.h>
+#endif
+
+#if defined(BOTAN_HAS_MARS)
+  #include <botan/mars.h>
+#endif
+
+#if defined(BOTAN_HAS_MISTY1)
+  #include <botan/misty1.h>
+#endif
+
+#if defined(BOTAN_HAS_NOEKEON)
+  #include <botan/noekeon.h>
+#endif
+
+#if defined(BOTAN_HAS_RC2)
+  #include <botan/rc2.h>
+#endif
+
+#if defined(BOTAN_HAS_RC5)
+  #include <botan/rc5.h>
+#endif
+
+#if defined(BOTAN_HAS_RC6)
+  #include <botan/rc6.h>
+#endif
+
+#if defined(BOTAN_HAS_SAFER)
+  #include <botan/safer_sk.h>
+#endif
+
+#if defined(BOTAN_HAS_SEED)
+  #include <botan/seed.h>
+#endif
+
+#if defined(BOTAN_HAS_SERPENT)
+  #include <botan/serpent.h>
+#endif
+
+#if defined(BOTAN_HAS_SKIPJACK)
+  #include <botan/skipjack.h>
+#endif
+
+#if defined(BOTAN_HAS_SQUARE)
+  #include <botan/square.h>
+#endif
+
+#if defined(BOTAN_HAS_TEA)
+  #include <botan/tea.h>
+#endif
+
+#if defined(BOTAN_HAS_TWOFISH)
+  #include <botan/twofish.h>
+#endif
+
+#if defined(BOTAN_HAS_XTEA)
+  #include <botan/xtea.h>
+#endif
+
+namespace Botan {
+
+/*
+* Look for an algorithm with this name
+*/
+BlockCipher* Core_Engine::find_block_cipher(const SCAN_Name& request,
+                                            Algorithm_Factory& af) const
+   {
+
+#if defined(BOTAN_HAS_AES)
+   if(request.algo_name() == "AES")
+      return new AES;
+   if(request.algo_name() == "AES-128")
+      return new AES_128;
+   if(request.algo_name() == "AES-192")
+      return new AES_192;
+   if(request.algo_name() == "AES-256")
+      return new AES_256;
+#endif
+
+#if defined(BOTAN_HAS_BLOWFISH)
+   if(request.algo_name() == "Blowfish")
+      return new Blowfish;
+#endif
+
+#if defined(BOTAN_HAS_CAST)
+   if(request.algo_name() == "CAST-128")
+      return new CAST_128;
+   if(request.algo_name() == "CAST-256")
+      return new CAST_256;
+#endif
+
+#if defined(BOTAN_HAS_DES)
+   if(request.algo_name() == "DES")
+      return new DES;
+   if(request.algo_name() == "DESX")
+      return new DESX;
+   if(request.algo_name() == "TripleDES")
+      return new TripleDES;
+#endif
+
+#if defined(BOTAN_HAS_GOST_28147_89)
+   if(request.algo_name() == "GOST-28147-89")
+      return new GOST_28147_89(request.arg(0, "R3411_94_TestParam"));
+#endif
+
+#if defined(BOTAN_HAS_IDEA)
+   if(request.algo_name() == "IDEA")
+      return new IDEA;
+#endif
+
+#if defined(BOTAN_HAS_KASUMI)
+   if(request.algo_name() == "KASUMI")
+      return new KASUMI;
+#endif
+
+#if defined(BOTAN_HAS_MARS)
+   if(request.algo_name() == "MARS")
+      return new MARS;
+#endif
+
+#if defined(BOTAN_HAS_MISTY1)
+   if(request.algo_name() == "MISTY1")
+      return new MISTY1(request.arg_as_u32bit(0, 8));
+#endif
+
+#if defined(BOTAN_HAS_NOEKEON)
+   if(request.algo_name() == "Noekeon")
+      return new Noekeon;
+#endif
+
+#if defined(BOTAN_HAS_RC2)
+   if(request.algo_name() == "RC2")
+      return new RC2;
+#endif
+
+#if defined(BOTAN_HAS_RC5)
+   if(request.algo_name() == "RC5")
+      return new RC5(request.arg_as_u32bit(0, 12));
+#endif
+
+#if defined(BOTAN_HAS_RC6)
+   if(request.algo_name() == "RC6")
+      return new RC6;
+#endif
+
+#if defined(BOTAN_HAS_SAFER)
+   if(request.algo_name() == "SAFER-SK")
+      return new SAFER_SK(request.arg_as_u32bit(0, 10));
+#endif
+
+#if defined(BOTAN_HAS_SEED)
+   if(request.algo_name() == "SEED")
+      return new SEED;
+#endif
+
+#if defined(BOTAN_HAS_SERPENT)
+   if(request.algo_name() == "Serpent")
+      return new Serpent;
+#endif
+
+#if defined(BOTAN_HAS_SKIPJACK)
+   if(request.algo_name() == "Skipjack")
+      return new Skipjack;
+#endif
+
+#if defined(BOTAN_HAS_SQUARE)
+   if(request.algo_name() == "Square")
+      return new Square;
+#endif
+
+#if defined(BOTAN_HAS_TEA)
+   if(request.algo_name() == "TEA")
+      return new TEA;
+#endif
+
+#if defined(BOTAN_HAS_TWOFISH)
+   if(request.algo_name() == "Twofish")
+      return new Twofish;
+#endif
+
+#if defined(BOTAN_HAS_XTEA)
+   if(request.algo_name() == "XTEA")
+      return new XTEA;
+#endif
+
+#if defined(BOTAN_HAS_LUBY_RACKOFF)
+   if(request.algo_name() == "Luby-Rackoff" && request.arg_count() == 1)
+      {
+      const HashFunction* hash = af.prototype_hash_function(request.arg(0));
+
+      if(hash)
+         return new LubyRackoff(hash->clone());
+      }
+#endif
+
+#if defined(BOTAN_HAS_CASCADE)
+   if(request.algo_name() == "Cascade" && request.arg_count() == 2)
+      {
+      const BlockCipher* c1 = af.prototype_block_cipher(request.arg(0));
+      const BlockCipher* c2 = af.prototype_block_cipher(request.arg(1));
+
+      if(c1 && c2)
+         return new Cascade_Cipher(c1->clone(), c2->clone());
+      }
+#endif
+
+#if defined(BOTAN_HAS_LION)
+   if(request.algo_name() == "Lion" && request.arg_count_between(2, 3))
+      {
+      const u32bit block_size = request.arg_as_u32bit(2, 1024);
+
+      const HashFunction* hash =
+         af.prototype_hash_function(request.arg(0));
+
+      const StreamCipher* stream_cipher =
+         af.prototype_stream_cipher(request.arg(1));
+
+      if(!hash || !stream_cipher)
+         return 0;
+
+      return new Lion(hash->clone(), stream_cipher->clone(), block_size);
+      }
+#endif
+
+   return 0;
+   }
+
+}
diff --git a/src/engine/core_engine/lookup_hash.cpp b/src/engine/core_engine/lookup_hash.cpp
new file mode 100644
index 000000000..1524015dd
--- /dev/null
+++ b/src/engine/core_engine/lookup_hash.cpp
@@ -0,0 +1,223 @@
+/*
+* Hash Algorithms Lookup
+* (C) 1999-2007 Jack Lloyd
+*
+* Distributed under the terms of the Botan license
+*/
+
+#include <botan/internal/core_engine.h>
+#include <botan/scan_name.h>
+#include <botan/algo_factory.h>
+#include <memory>
+
+#if defined(BOTAN_HAS_ADLER32)
+  #include <botan/adler32.h>
+#endif
+
+#if defined(BOTAN_HAS_CRC24)
+  #include <botan/crc24.h>
+#endif
+
+#if defined(BOTAN_HAS_CRC32)
+  #include <botan/crc32.h>
+#endif
+
+#if defined(BOTAN_HAS_BMW_512)
+  #include <botan/bmw_512.h>
+#endif
+
+#if defined(BOTAN_HAS_GOST_34_11)
+  #include <botan/gost_3411.h>
+#endif
+
+#if defined(BOTAN_HAS_HAS_160)
+  #include <botan/has160.h>
+#endif
+
+#if defined(BOTAN_HAS_MD2)
+  #include <botan/md2.h>
+#endif
+
+#if defined(BOTAN_HAS_MD4)
+  #include <botan/md4.h>
+#endif
+
+#if defined(BOTAN_HAS_MD5)
+  #include <botan/md5.h>
+#endif
+
+#if defined(BOTAN_HAS_RIPEMD_128)
+  #include <botan/rmd128.h>
+#endif
+
+#if defined(BOTAN_HAS_RIPEMD_160)
+  #include <botan/rmd160.h>
+#endif
+
+#if defined(BOTAN_HAS_SHA1)
+  #include <botan/sha160.h>
+#endif
+
+#if defined(BOTAN_HAS_SHA2)
+  #include <botan/sha2_32.h>
+  #include <botan/sha2_64.h>
+#endif
+
+#if defined(BOTAN_HAS_SKEIN_512)
+  #include <botan/skein_512.h>
+#endif
+
+#if defined(BOTAN_HAS_TIGER)
+  #include <botan/tiger.h>
+#endif
+
+#if defined(BOTAN_HAS_WHIRLPOOL)
+  #include <botan/whrlpool.h>
+#endif
+
+#if defined(BOTAN_HAS_PARALLEL_HASH)
+  #include <botan/par_hash.h>
+#endif
+
+#if defined(BOTAN_HAS_COMB4P)
+  #include <botan/comb4p.h>
+#endif
+
+namespace Botan {
+
+/*
+* Look for an algorithm with this name
+*/
+HashFunction* Core_Engine::find_hash(const SCAN_Name& request,
+                                     Algorithm_Factory& af) const
+   {
+#if defined(BOTAN_HAS_ADLER32)
+   if(request.algo_name() == "Adler32")
+      return new Adler32;
+#endif
+
+#if defined(BOTAN_HAS_CRC24)
+   if(request.algo_name() == "CRC24")
+      return new CRC24;
+#endif
+
+#if defined(BOTAN_HAS_CRC32)
+   if(request.algo_name() == "CRC32")
+      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_GOST_34_11)
+   if(request.algo_name() == "GOST-34.11")
+      return new GOST_34_11;
+#endif
+
+#if defined(BOTAN_HAS_HAS_160)
+   if(request.algo_name() == "HAS-160")
+      return new HAS_160;
+#endif
+
+#if defined(BOTAN_HAS_MD2)
+   if(request.algo_name() == "MD2")
+      return new MD2;
+#endif
+
+#if defined(BOTAN_HAS_MD4)
+   if(request.algo_name() == "MD4")
+      return new MD4;
+#endif
+
+#if defined(BOTAN_HAS_MD5)
+   if(request.algo_name() == "MD5")
+      return new MD5;
+#endif
+
+#if defined(BOTAN_HAS_RIPEMD_128)
+   if(request.algo_name() == "RIPEMD-128")
+      return new RIPEMD_128;
+#endif
+
+#if defined(BOTAN_HAS_RIPEMD_160)
+   if(request.algo_name() == "RIPEMD-160")
+      return new RIPEMD_160;
+#endif
+
+#if defined(BOTAN_HAS_SHA1)
+   if(request.algo_name() == "SHA-160")
+      return new SHA_160;
+#endif
+
+#if defined(BOTAN_HAS_SHA2)
+   if(request.algo_name() == "SHA-224")
+      return new SHA_224;
+   if(request.algo_name() == "SHA-256")
+      return new SHA_256;
+   if(request.algo_name() == "SHA-384")
+      return new SHA_384;
+   if(request.algo_name() == "SHA-512")
+      return new SHA_512;
+#endif
+
+#if defined(BOTAN_HAS_TIGER)
+   if(request.algo_name() == "Tiger")
+      return new Tiger(request.arg_as_u32bit(0, 24), // hash output
+                       request.arg_as_u32bit(1, 3)); // # passes
+#endif
+
+#if defined(BOTAN_HAS_SKEIN_512)
+   if(request.algo_name() == "Skein-512")
+      return new Skein_512(request.arg_as_u32bit(0, 512),
+                           request.arg(1, ""));
+#endif
+
+#if defined(BOTAN_HAS_WHIRLPOOL)
+   if(request.algo_name() == "Whirlpool")
+      return new Whirlpool;
+#endif
+
+#if defined(BOTAN_HAS_COMB4P)
+   if(request.algo_name() == "Comb4P" && request.arg_count() == 2)
+      {
+      const HashFunction* h1 = af.prototype_hash_function(request.arg(0));
+      const HashFunction* h2 = af.prototype_hash_function(request.arg(1));
+
+      if(h1 && h2)
+         return new Comb4P(h1->clone(), h2->clone());
+      }
+#endif
+
+#if defined(BOTAN_HAS_PARALLEL_HASH)
+
+   if(request.algo_name() == "Parallel")
+      {
+      std::vector<const HashFunction*> hash_prototypes;
+
+      /* First pass, just get the prototypes (no memory allocation). Then
+         if all were found, replace each prototype with a newly created clone
+      */
+      for(size_t i = 0; i != request.arg_count(); ++i)
+         {
+         const HashFunction* hash = af.prototype_hash_function(request.arg(i));
+         if(!hash)
+            return 0;
+
+         hash_prototypes.push_back(hash);
+         }
+
+      std::vector<HashFunction*> hashes;
+      for(size_t i = 0; i != hash_prototypes.size(); ++i)
+         hashes.push_back(hash_prototypes[i]->clone());
+
+      return new Parallel(hashes);
+      }
+
+#endif
+
+   return 0;
+   }
+
+}
diff --git a/src/engine/core_engine/lookup_mac.cpp b/src/engine/core_engine/lookup_mac.cpp
new file mode 100644
index 000000000..9f322b399
--- /dev/null
+++ b/src/engine/core_engine/lookup_mac.cpp
@@ -0,0 +1,70 @@
+/*
+* MAC Lookup
+* (C) 1999-2007 Jack Lloyd
+*
+* Distributed under the terms of the Botan license
+*/
+
+#include <botan/internal/core_engine.h>
+#include <botan/scan_name.h>
+#include <botan/algo_factory.h>
+
+#if defined(BOTAN_HAS_CBC_MAC)
+  #include <botan/cbc_mac.h>
+#endif
+
+#if defined(BOTAN_HAS_CMAC)
+  #include <botan/cmac.h>
+#endif
+
+#if defined(BOTAN_HAS_HMAC)
+  #include <botan/hmac.h>
+#endif
+
+#if defined(BOTAN_HAS_SSL3_MAC)
+  #include <botan/ssl3_mac.h>
+#endif
+
+#if defined(BOTAN_HAS_ANSI_X919_MAC)
+  #include <botan/x919_mac.h>
+#endif
+
+namespace Botan {
+
+/*
+* Look for an algorithm with this name
+*/
+MessageAuthenticationCode*
+Core_Engine::find_mac(const SCAN_Name& request,
+                      Algorithm_Factory& af) const
+   {
+
+#if defined(BOTAN_HAS_CBC_MAC)
+   if(request.algo_name() == "CBC-MAC" && request.arg_count() == 1)
+      return new CBC_MAC(af.make_block_cipher(request.arg(0)));
+#endif
+
+#if defined(BOTAN_HAS_CMAC)
+   if(request.algo_name() == "CMAC" && request.arg_count() == 1)
+      return new CMAC(af.make_block_cipher(request.arg(0)));
+#endif
+
+#if defined(BOTAN_HAS_HMAC)
+   if(request.algo_name() == "HMAC" && request.arg_count() == 1)
+      return new HMAC(af.make_hash_function(request.arg(0)));
+#endif
+
+#if defined(BOTAN_HAS_SSL3_MAC)
+   if(request.algo_name() == "SSL3-MAC" && request.arg_count() == 1)
+      return new SSL3_MAC(af.make_hash_function(request.arg(0)));
+#endif
+
+#if defined(BOTAN_HAS_ANSI_X919_MAC)
+   if(request.algo_name() == "X9.19-MAC" && request.arg_count() == 0)
+      return new ANSI_X919_MAC(af.make_block_cipher("DES"));
+#endif
+
+   return 0;
+   }
+
+}
diff --git a/src/engine/core_engine/lookup_stream.cpp b/src/engine/core_engine/lookup_stream.cpp
new file mode 100644
index 000000000..52ca4fb8d
--- /dev/null
+++ b/src/engine/core_engine/lookup_stream.cpp
@@ -0,0 +1,61 @@
+/*
+* Stream Cipher Lookup
+* (C) 1999-2007 Jack Lloyd
+*
+* Distributed under the terms of the Botan license
+*/
+
+#include <botan/internal/core_engine.h>
+#include <botan/scan_name.h>
+
+#if defined(BOTAN_HAS_ARC4)
+  #include <botan/arc4.h>
+#endif
+
+#if defined(BOTAN_HAS_SALSA20)
+  #include <botan/salsa20.h>
+#endif
+
+#if defined(BOTAN_HAS_TURING)
+  #include <botan/turing.h>
+#endif
+
+#if defined(BOTAN_HAS_WID_WAKE)
+  #include <botan/wid_wake.h>
+#endif
+
+namespace Botan {
+
+/*
+* Look for an algorithm with this name
+*/
+StreamCipher*
+Core_Engine::find_stream_cipher(const SCAN_Name& request,
+                                Algorithm_Factory&) const
+   {
+#if defined(BOTAN_HAS_ARC4)
+   if(request.algo_name() == "ARC4")
+      return new ARC4(request.arg_as_u32bit(0, 0));
+   if(request.algo_name() == "RC4_drop")
+      return new ARC4(768);
+#endif
+
+#if defined(BOTAN_HAS_SALSA20)
+   if(request.algo_name() == "Salsa20")
+      return new Salsa20;
+#endif
+
+#if defined(BOTAN_HAS_TURING)
+   if(request.algo_name() == "Turing")
+      return new Turing;
+#endif
+
+#if defined(BOTAN_HAS_WID_WAKE)
+   if(request.algo_name() == "WiderWake4+1-BE")
+      return new WiderWake_41_BE;
+#endif
+
+   return 0;
+   }
+
+}