/*

* Block Ciphers

* (C) 2015 Jack Lloyd

*

* Botan is released under the Simplified BSD License (see license.txt)

*/

#include <botan/block_cipher.h>

#include <botan/scan_name.h>

#include <botan/exceptn.h>

#if defined(BOTAN_HAS_AES)

  #include <botan/aes.h>

#endif

#if defined(BOTAN_HAS_ARIA)

  #include <botan/aria.h>

#endif

#if defined(BOTAN_HAS_BLOWFISH)

  #include <botan/blowfish.h>

#endif

#if defined(BOTAN_HAS_CAMELLIA)

  #include <botan/camellia.h>

#endif

#if defined(BOTAN_HAS_CAST_128)

  #include <botan/cast128.h>

#endif

#if defined(BOTAN_HAS_CAST_256)

  #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_MISTY1)

  #include <botan/misty1.h>

#endif

#if defined(BOTAN_HAS_NOEKEON)

  #include <botan/noekeon.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_SHACAL2)

  #include <botan/shacal2.h>

#endif

#if defined(BOTAN_HAS_SM4)

  #include <botan/sm4.h>

#endif

#if defined(BOTAN_HAS_TWOFISH)

  #include <botan/twofish.h>

#endif

#if defined(BOTAN_HAS_THREEFISH_512)

  #include <botan/threefish_512.h>

#endif

#if defined(BOTAN_HAS_XTEA)

  #include <botan/xtea.h>

#endif

#if defined(BOTAN_HAS_OPENSSL)

  #include <botan/internal/openssl.h>

#endif

#if defined(BOTAN_HAS_COMMONCRYPTO)

  #include <botan/internal/commoncrypto.h>

#endif

namespace Botan {

std::unique_ptr<BlockCipher>

BlockCipher::create(const std::string& algo,

                    const std::string& provider)

   {

#if defined(BOTAN_HAS_COMMONCRYPTO)

   if(provider.empty() || provider == "commoncrypto")

      {

      if(auto bc = make_commoncrypto_block_cipher(algo))

         return bc;

      if(!provider.empty())

         return nullptr;

      }

#endif

#if defined(BOTAN_HAS_OPENSSL)

   if(provider.empty() || provider == "openssl")

      {

      if(auto bc = make_openssl_block_cipher(algo))

         return bc;

      if(!provider.empty())

         return nullptr;

      }

#endif

   // TODO: CryptoAPI

   // TODO: /dev/crypto

   // Only base providers from here on out

   if(provider.empty() == false && provider != "base")

      return nullptr;

#if defined(BOTAN_HAS_AES)

   if(algo == "AES-128")

      {

      return std::unique_ptr<BlockCipher>(new AES_128);

      }

   if(algo == "AES-192")

      {

      return std::unique_ptr<BlockCipher>(new AES_192);

      }

   if(algo == "AES-256")

      {

      return std::unique_ptr<BlockCipher>(new AES_256);

      }

#endif

#if defined(BOTAN_HAS_ARIA)

   if(algo == "ARIA-128")

      {

      return std::unique_ptr<BlockCipher>(new ARIA_128);

      }

   if(algo == "ARIA-192")

      {

      return std::unique_ptr<BlockCipher>(new ARIA_192);

      }

   if(algo == "ARIA-256")

      {

      return std::unique_ptr<BlockCipher>(new ARIA_256);

      }

#endif

#if defined(BOTAN_HAS_SERPENT)

   if(algo == "Serpent")

      {

      return std::unique_ptr<BlockCipher>(new Serpent);

      }

#endif

#if defined(BOTAN_HAS_SHACAL2)

   if(algo == "SHACAL2")

      {

      return std::unique_ptr<BlockCipher>(new SHACAL2);

      }

#endif

#if defined(BOTAN_HAS_TWOFISH)

   if(algo == "Twofish")

      {

      return std::unique_ptr<BlockCipher>(new Twofish);

      }

#endif

#if defined(BOTAN_HAS_THREEFISH_512)

   if(algo == "Threefish-512")

      {

      return std::unique_ptr<BlockCipher>(new Threefish_512);

      }

#endif

#if defined(BOTAN_HAS_BLOWFISH)

   if(algo == "Blowfish")

      {

      return std::unique_ptr<BlockCipher>(new Blowfish);

      }

#endif

#if defined(BOTAN_HAS_CAMELLIA)

   if(algo == "Camellia-128")

      {

      return std::unique_ptr<BlockCipher>(new Camellia_128);

      }

   if(algo == "Camellia-192")

      {

      return std::unique_ptr<BlockCipher>(new Camellia_192);

      }

   if(algo == "Camellia-256")

      {

      return std::unique_ptr<BlockCipher>(new Camellia_256);

      }

#endif

#if defined(BOTAN_HAS_DES)

   if(algo == "DES")

      {

      return std::unique_ptr<BlockCipher>(new DES);

      }

   if(algo == "DESX")

      {

      return std::unique_ptr<BlockCipher>(new DESX);

      }

   if(algo == "TripleDES" || algo == "3DES" || algo == "DES-EDE")

      {

      return std::unique_ptr<BlockCipher>(new TripleDES);

      }

#endif

#if defined(BOTAN_HAS_NOEKEON)

   if(algo == "Noekeon")

      {

      return std::unique_ptr<BlockCipher>(new Noekeon);

      }

#endif

#if defined(BOTAN_HAS_CAST_128)

   if(algo == "CAST-128" || algo == "CAST5")

      {

      return std::unique_ptr<BlockCipher>(new CAST_128);

      }

#endif

#if defined(BOTAN_HAS_CAST_256)

   if(algo == "CAST-256")

      {

      return std::unique_ptr<BlockCipher>(new CAST_256);

      }

#endif

#if defined(BOTAN_HAS_IDEA)

   if(algo == "IDEA")

      {

      return std::unique_ptr<BlockCipher>(new IDEA);

      }

#endif

#if defined(BOTAN_HAS_KASUMI)

   if(algo == "KASUMI")

      {

      return std::unique_ptr<BlockCipher>(new KASUMI);

      }

#endif

#if defined(BOTAN_HAS_MISTY1)

   if(algo == "MISTY1")

      {

      return std::unique_ptr<BlockCipher>(new MISTY1);

      }

#endif

#if defined(BOTAN_HAS_SEED)

   if(algo == "SEED")

      {

      return std::unique_ptr<BlockCipher>(new SEED);

      }

#endif

#if defined(BOTAN_HAS_SM4)

   if(algo == "SM4")

      {

      return std::unique_ptr<BlockCipher>(new SM4);

      }

#endif

#if defined(BOTAN_HAS_XTEA)

   if(algo == "XTEA")

      {

      return std::unique_ptr<BlockCipher>(new XTEA);

      }

#endif

   const SCAN_Name req(algo);

#if defined(BOTAN_HAS_GOST_28147_89)

   if(req.algo_name() == "GOST-28147-89")

      {

      return std::unique_ptr<BlockCipher>(new GOST_28147_89(req.arg(0, "R3411_94_TestParam")));

      }

#endif

#if defined(BOTAN_HAS_CASCADE)

   if(req.algo_name() == "Cascade" && req.arg_count() == 2)

      {

      std::unique_ptr<BlockCipher> c1(BlockCipher::create(req.arg(0)));

      std::unique_ptr<BlockCipher> c2(BlockCipher::create(req.arg(1)));

      if(c1 && c2)

         return std::unique_ptr<BlockCipher>(new Cascade_Cipher(c1.release(), c2.release()));

      }

#endif

#if defined(BOTAN_HAS_LION)

   if(req.algo_name() == "Lion" && req.arg_count_between(2, 3))

      {

      std::unique_ptr<HashFunction> hash(HashFunction::create(req.arg(0)));

      std::unique_ptr<StreamCipher> stream(StreamCipher::create(req.arg(1)));

      if(hash && stream)

         {

         const size_t block_size = req.arg_as_integer(2, 1024);

         return std::unique_ptr<BlockCipher>(new Lion(hash.release(), stream.release(), block_size));

         }

      }

#endif

   BOTAN_UNUSED(req);

   BOTAN_UNUSED(provider);

   return nullptr;

   }

//static

std::unique_ptr<BlockCipher>

BlockCipher::create_or_throw(const std::string& algo,

                             const std::string& provider)

   {

   if(auto bc = BlockCipher::create(algo, provider))

      {

      return bc;

      }

   throw Lookup_Error("Block cipher", algo, provider);

   }

std::vector<std::string> BlockCipher::providers(const std::string& algo)

   {

   return probe_providers_of<BlockCipher>(algo, { "base", "openssl", "commoncrypto" });

   }

}