diff options
Diffstat (limited to 'src')
92 files changed, 1419 insertions, 1551 deletions
diff --git a/src/lib/base/algo_registry.h b/src/lib/base/algo_registry.h deleted file mode 100644 index bca3715b6..000000000 --- a/src/lib/base/algo_registry.h +++ /dev/null @@ -1,299 +0,0 @@ -/* -* (C) 2014,2015 Jack Lloyd -* (C) 2015 Matej Kenda -* -* Botan is released under the Simplified BSD License (see license.txt) -*/ - -#ifndef BOTAN_ALGO_REGISTRY_H__ -#define BOTAN_ALGO_REGISTRY_H__ - -#include <botan/build.h> -#include <botan/types.h> -#include <botan/exceptn.h> -#include <botan/scan_name.h> -#include <functional> -#include <botan/mutex.h> -#include <vector> -#include <map> -#include <string> -#include <unordered_map> - -#if defined(_MSC_VER) && (_MSC_VER <= 1800) - - #define BOTAN_WORKAROUND_GH_321 - #define NOMINMAX 1 - #define WIN32_LEAN_AND_MEAN 1 - #include <windows.h> - -#endif - -namespace Botan { - -#if defined(BOTAN_WORKAROUND_GH_321) - -class WinCS_Mutex - { - public: - WinCS_Mutex() - { - ::InitializeCriticalSection(&m_cs); - } - - ~WinCS_Mutex() - { - ::DeleteCriticalSection(&m_cs); - } - - void lock() - { - ::EnterCriticalSection(&m_cs); - } - - void unlock() - { - ::LeaveCriticalSection(&m_cs); - } - - private: - CRITICAL_SECTION m_cs; - }; - -#endif - -template<typename T> -class Algo_Registry - { - public: - typedef typename T::Spec Spec; - - typedef std::function<T* (const Spec&)> maker_fn; - - static Algo_Registry<T>& global_registry() - { - static Algo_Registry<T> g_registry; - return g_registry; - } - - void add(const std::string& name, const std::string& provider, maker_fn fn, byte pref) - { - lock_guard_type<af_mutex_type> lock(m_mutex); - if(!m_algo_info[name].add_provider(provider, fn, pref)) - throw Exception("Duplicated registration of " + name + "/" + provider); - } - - std::vector<std::string> providers_of(const Spec& spec) - { - lock_guard_type<af_mutex_type> lock(m_mutex); - auto i = m_algo_info.find(spec.algo_name()); - if(i != m_algo_info.end()) - return i->second.providers(); - return std::vector<std::string>(); - } - - void set_provider_preference(const Spec& spec, const std::string& provider, byte pref) - { - lock_guard_type<af_mutex_type> lock(m_mutex); - auto i = m_algo_info.find(spec.algo_name()); - if(i != m_algo_info.end()) - i->second.set_pref(provider, pref); - } - - T* make(const Spec& spec, const std::string& provider = "") - { - const std::vector<maker_fn> makers = get_makers(spec, provider); - - try - { - for(auto&& maker : makers) - { - if(T* t = maker(spec)) - return t; - } - } - catch(std::exception& e) - { - throw Lookup_Error("Creating '" + spec.as_string() + "' failed: " + e.what()); - } - - return nullptr; - } - - class Add - { - public: - Add(const std::string& basename, maker_fn fn, const std::string& provider, byte pref) - { - Algo_Registry<T>::global_registry().add(basename, provider, fn, pref); - } - - Add(bool cond, const std::string& basename, maker_fn fn, const std::string& provider, byte pref) - { - if(cond) - Algo_Registry<T>::global_registry().add(basename, provider, fn, pref); - } - }; - - private: - -#if defined(BOTAN_WORKAROUND_GH_321) - using af_mutex_type = WinCS_Mutex; -#else - using af_mutex_type = mutex_type; -#endif - - Algo_Registry() { } - - std::vector<maker_fn> get_makers(const Spec& spec, const std::string& provider) - { - lock_guard_type<af_mutex_type> lock(m_mutex); - return m_algo_info[spec.algo_name()].get_makers(provider); - } - - struct Algo_Info - { - public: - bool add_provider(const std::string& provider, maker_fn fn, byte pref) - { - if(m_maker_fns.count(provider) > 0) - return false; - - m_maker_fns[provider] = fn; - m_prefs.insert(std::make_pair(pref, provider)); - return true; - } - - std::vector<std::string> providers() const - { - std::vector<std::string> v; - for(auto&& k : m_prefs) - v.push_back(k.second); - return v; - } - - void set_pref(const std::string& provider, byte pref) - { - auto i = m_prefs.begin(); - while(i != m_prefs.end()) - { - if(i->second == provider) - i = m_prefs.erase(i); - else - ++i; - } - m_prefs.insert(std::make_pair(pref, provider)); - } - - std::vector<maker_fn> get_makers(const std::string& req_provider) - { - std::vector<maker_fn> r; - - if(!req_provider.empty()) - { - // find one explicit provider requested by user or fail - auto i = m_maker_fns.find(req_provider); - if(i != m_maker_fns.end()) - r.push_back(i->second); - } - else - { - for(auto&& pref : m_prefs) - r.push_back(m_maker_fns[pref.second]); - } - - return r; - } - private: - std::multimap<byte, std::string, std::greater<byte>> m_prefs; - std::unordered_map<std::string, maker_fn> m_maker_fns; - }; - - af_mutex_type m_mutex; - std::unordered_map<std::string, Algo_Info> m_algo_info; - }; - -template<typename T> T* -make_a(const typename T::Spec& spec, const std::string& provider = "") - { - return Algo_Registry<T>::global_registry().make(spec, provider); - } - -template<typename T> std::vector<std::string> providers_of(const typename T::Spec& spec) - { - return Algo_Registry<T>::global_registry().providers_of(spec); - } - -template<typename T> T* -make_new_T(const typename Algo_Registry<T>::Spec& spec) - { - if(spec.arg_count() == 0) - return new T; - return nullptr; - } - -template<typename T, size_t DEF_VAL> T* -make_new_T_1len(const typename Algo_Registry<T>::Spec& spec) - { - return new T(spec.arg_as_integer(0, DEF_VAL)); - } - -template<typename T, size_t DEF1, size_t DEF2> T* -make_new_T_2len(const typename Algo_Registry<T>::Spec& spec) - { - return new T(spec.arg_as_integer(0, DEF1), spec.arg_as_integer(1, DEF2)); - } - -template<typename T> T* -make_new_T_1str(const typename Algo_Registry<T>::Spec& spec, const std::string& def) - { - return new T(spec.arg(0, def)); - } - -template<typename T> T* -make_new_T_1str_req(const typename Algo_Registry<T>::Spec& spec) - { - return new T(spec.arg(0)); - } - -template<typename T, typename X> T* -make_new_T_1X(const typename Algo_Registry<T>::Spec& spec) - { - std::unique_ptr<X> x(Algo_Registry<X>::global_registry().make(Botan::SCAN_Name(spec.arg(0)))); - if(!x) - throw Exception(spec.arg(0)); - return new T(x.release()); - } - -#define BOTAN_REGISTER_TYPE(T, type, name, maker, provider, pref) \ - namespace { Algo_Registry<T>::Add g_ ## type ## _reg(name, maker, provider, pref); } \ - BOTAN_FORCE_SEMICOLON - -#define BOTAN_REGISTER_TYPE_COND(cond, T, type, name, maker, provider, pref) \ - namespace { Algo_Registry<T>::Add g_ ## type ## _reg(cond, name, maker, provider, pref); } \ - BOTAN_FORCE_SEMICOLON - -#define BOTAN_DEFAULT_ALGORITHM_PRIO 100 -#define BOTAN_SIMD_ALGORITHM_PRIO 110 - -#define BOTAN_REGISTER_NAMED_T(T, name, type, maker) \ - BOTAN_REGISTER_TYPE(T, type, name, maker, "base", BOTAN_DEFAULT_ALGORITHM_PRIO) - -#define BOTAN_REGISTER_T(T, type, maker) \ - BOTAN_REGISTER_TYPE(T, type, #type, maker, "base", BOTAN_DEFAULT_ALGORITHM_PRIO) - -#define BOTAN_REGISTER_T_NOARGS(T, type) \ - BOTAN_REGISTER_TYPE(T, type, #type, make_new_T<type>, "base", BOTAN_DEFAULT_ALGORITHM_PRIO) -#define BOTAN_REGISTER_T_1LEN(T, type, def) \ - BOTAN_REGISTER_TYPE(T, type, #type, (make_new_T_1len<type,def>), "base", BOTAN_DEFAULT_ALGORITHM_PRIO) - -#define BOTAN_REGISTER_NAMED_T_NOARGS(T, type, name, provider) \ - BOTAN_REGISTER_TYPE(T, type, name, make_new_T<type>, provider, BOTAN_DEFAULT_ALGORITHM_PRIO) -#define BOTAN_COND_REGISTER_NAMED_T_NOARGS(cond, T, type, name, provider, pref) \ - BOTAN_REGISTER_TYPE_COND(cond, T, type, name, make_new_T<type>, provider, pref) - -#define BOTAN_REGISTER_NAMED_T_2LEN(T, type, name, provider, len1, len2) \ - BOTAN_REGISTER_TYPE(T, type, name, (make_new_T_2len<type,len1,len2>), provider, BOTAN_DEFAULT_ALGORITHM_PRIO) - -} - -#endif diff --git a/src/lib/base/info.txt b/src/lib/base/info.txt index 7553007e5..001ed9e1b 100644 --- a/src/lib/base/info.txt +++ b/src/lib/base/info.txt @@ -10,10 +10,6 @@ sym_algo.h symkey.h </header:public> -<header:internal> -algo_registry.h -</header:internal> - <requires> block hash diff --git a/src/lib/base/scan_name.h b/src/lib/base/scan_name.h index 75f7d1089..981d54765 100644 --- a/src/lib/base/scan_name.h +++ b/src/lib/base/scan_name.h @@ -8,7 +8,7 @@ #ifndef BOTAN_SCAN_NAME_H__ #define BOTAN_SCAN_NAME_H__ -#include <botan/types.h> +#include <botan/exceptn.h> #include <string> #include <vector> #include <botan/mutex.h> @@ -126,6 +126,23 @@ class BOTAN_DLL SCAN_Name std::vector<std::string> m_mode_info; }; +// This is unrelated but it is convenient to stash it here +template<typename T> +std::vector<std::string> probe_providers_of(const std::string& algo_spec, + const std::vector<std::string>& possible) + { + std::vector<std::string> providers; + for(auto&& prov : possible) + { + std::unique_ptr<T> o(T::create(algo_spec, prov)); + if(o) + { + providers.push_back(prov); // available + } + } + return providers; + } + } #endif diff --git a/src/lib/block/block_cipher.cpp b/src/lib/block/block_cipher.cpp index 2388057c6..abfaf55ef 100644 --- a/src/lib/block/block_cipher.cpp +++ b/src/lib/block/block_cipher.cpp @@ -6,8 +6,7 @@ */ #include <botan/block_cipher.h> -#include <botan/cpuid.h> -#include <botan/internal/algo_registry.h> +#include <botan/scan_name.h> #if defined(BOTAN_HAS_AES) #include <botan/aes.h> @@ -79,109 +78,220 @@ #include <botan/xtea.h> #endif -namespace Botan { - -BlockCipher::~BlockCipher() {} +#if defined(BOTAN_HAS_OPENSSL) + #include <botan/internal/openssl.h> +#endif -std::unique_ptr<BlockCipher> BlockCipher::create(const std::string& algo_spec, - const std::string& provider) - { - return std::unique_ptr<BlockCipher>(make_a<BlockCipher>(Botan::BlockCipher::Spec(algo_spec), provider)); - } +namespace Botan { -std::vector<std::string> BlockCipher::providers(const std::string& algo_spec) +std::unique_ptr<BlockCipher> +BlockCipher::create(const std::string& algo, + const std::string& provider) { - return providers_of<BlockCipher>(BlockCipher::Spec(algo_spec)); - } + const SCAN_Name req(algo); -#define BOTAN_REGISTER_BLOCK_CIPHER(name, maker) BOTAN_REGISTER_T(BlockCipher, name, maker) -#define BOTAN_REGISTER_BLOCK_CIPHER_NOARGS(name) BOTAN_REGISTER_T_NOARGS(BlockCipher, name) +#if defined(BOTAN_HAS_OPENSSL) + if(provider.empty() || provider == "openssl") + { + if(auto bc = make_openssl_block_cipher(algo)) + return bc; -#define BOTAN_REGISTER_BLOCK_CIPHER_1LEN(name, def) BOTAN_REGISTER_T_1LEN(BlockCipher, name, def) + if(!provider.empty()) + return nullptr; + } +#endif -#define BOTAN_REGISTER_BLOCK_CIPHER_NAMED_NOARGS(type, name) \ - BOTAN_REGISTER_NAMED_T(BlockCipher, name, type, make_new_T<type>) -#define BOTAN_REGISTER_BLOCK_CIPHER_NAMED_1LEN(type, name, def) \ - BOTAN_REGISTER_NAMED_T(BlockCipher, name, type, (make_new_T_1len<type,def>)) -#define BOTAN_REGISTER_BLOCK_CIPHER_NAMED_1STR(type, name, def) \ - BOTAN_REGISTER_NAMED_T(BlockCipher, name, type, std::bind(make_new_T_1str<type>, std::placeholders::_1, def)) + // TODO: CommonCrypto + // TODO: CryptoAPI + // TODO: /dev/crypto -#define BOTAN_REGISTER_BLOCK_CIPHER_NOARGS_IF(cond, type, name, provider, pref) \ - BOTAN_COND_REGISTER_NAMED_T_NOARGS(cond, BlockCipher, type, name, provider, pref) + // Only base providers from here on out + if(provider.empty() == false && provider != "base") + return nullptr; #if defined(BOTAN_HAS_AES) -BOTAN_REGISTER_BLOCK_CIPHER_NAMED_NOARGS(AES_128, "AES-128"); -BOTAN_REGISTER_BLOCK_CIPHER_NAMED_NOARGS(AES_192, "AES-192"); -BOTAN_REGISTER_BLOCK_CIPHER_NAMED_NOARGS(AES_256, "AES-256"); + if(req.algo_name() == "AES-128" && req.arg_count() == 0) + { + return std::unique_ptr<BlockCipher>(new AES_128); + } + + if(req.algo_name() == "AES-192" && req.arg_count() == 0) + { + return std::unique_ptr<BlockCipher>(new AES_192); + } + + if(req.algo_name() == "AES-256" && req.arg_count() == 0) + { + return std::unique_ptr<BlockCipher>(new AES_256); + } #endif -#if defined(BOTAN_HAS_BLOWFISH) -BOTAN_REGISTER_BLOCK_CIPHER_NOARGS(Blowfish); +#if defined(BOTAN_HAS_SERPENT) + if(req.algo_name() == "Serpent" && req.arg_count() == 0) + { + return std::unique_ptr<BlockCipher>(new Serpent); + } #endif -#if defined(BOTAN_HAS_CAMELLIA) -BOTAN_REGISTER_BLOCK_CIPHER_NAMED_NOARGS(Camellia_128, "Camellia-128"); -BOTAN_REGISTER_BLOCK_CIPHER_NAMED_NOARGS(Camellia_192, "Camellia-192"); -BOTAN_REGISTER_BLOCK_CIPHER_NAMED_NOARGS(Camellia_256, "Camellia-256"); +#if defined(BOTAN_HAS_TWOFISH) + if(req.algo_name() == "Twofish" && req.arg_count() == 0) + { + return std::unique_ptr<BlockCipher>(new Twofish); + } #endif -#if defined(BOTAN_HAS_CAST) -BOTAN_REGISTER_BLOCK_CIPHER_NAMED_NOARGS(CAST_128, "CAST-128"); -BOTAN_REGISTER_BLOCK_CIPHER_NAMED_NOARGS(CAST_256, "CAST-256"); +#if defined(BOTAN_HAS_THREEFISH_512) + if(req.algo_name() == "Threefish-512" && req.arg_count() == 0) + { + return std::unique_ptr<BlockCipher>(new Threefish_512); + } #endif -#if defined(BOTAN_HAS_DES) -BOTAN_REGISTER_BLOCK_CIPHER_NOARGS(DES); -BOTAN_REGISTER_BLOCK_CIPHER_NOARGS(TripleDES); -BOTAN_REGISTER_BLOCK_CIPHER_NOARGS(DESX); +#if defined(BOTAN_HAS_BLOWFISH) + if(req.algo_name() == "Blowfish" && req.arg_count() == 0) + { + return std::unique_ptr<BlockCipher>(new Blowfish); + } #endif -#if defined(BOTAN_HAS_GOST_28147_89) -BOTAN_REGISTER_BLOCK_CIPHER_NAMED_1STR(GOST_28147_89, "GOST-28147-89", "R3411_94_TestParam"); +#if defined(BOTAN_HAS_CAMELLIA) + if(req.algo_name() == "Camellia-128" && req.arg_count() == 0) + { + return std::unique_ptr<BlockCipher>(new Camellia_128); + } + + if(req.algo_name() == "Camellia-192" && req.arg_count() == 0) + { + return std::unique_ptr<BlockCipher>(new Camellia_192); + } + + if(req.algo_name() == "Camellia-256" && req.arg_count() == 0) + { + return std::unique_ptr<BlockCipher>(new Camellia_256); + } #endif -#if defined(BOTAN_HAS_IDEA) -BOTAN_REGISTER_BLOCK_CIPHER_NOARGS(IDEA); +#if defined(BOTAN_HAS_DES) + if(req.algo_name() == "DES" && req.arg_count() == 0) + { + return std::unique_ptr<BlockCipher>(new DES); + } + + if(req.algo_name() == "DESX" && req.arg_count() == 0) + { + return std::unique_ptr<BlockCipher>(new DESX); + } + + if(req.algo_name() == "TripleDES" && req.arg_count() == 0) + { + return std::unique_ptr<BlockCipher>(new TripleDES); + } #endif -#if defined(BOTAN_HAS_KASUMI) -BOTAN_REGISTER_BLOCK_CIPHER_NOARGS(KASUMI); +#if defined(BOTAN_HAS_NOEKEON) + if(req.algo_name() == "Noekeon" && req.arg_count() == 0) + { + return std::unique_ptr<BlockCipher>(new Noekeon); + } #endif -#if defined(BOTAN_HAS_MISTY1) -BOTAN_REGISTER_BLOCK_CIPHER_NOARGS(MISTY1); +#if defined(BOTAN_HAS_CAST) + if(req.algo_name() == "CAST-128" && req.arg_count() == 0) + { + return std::unique_ptr<BlockCipher>(new CAST_128); + } + + if(req.algo_name() == "CAST-256" && req.arg_count() == 0) + { + return std::unique_ptr<BlockCipher>(new CAST_256); + } #endif -#if defined(BOTAN_HAS_NOEKEON) -BOTAN_REGISTER_BLOCK_CIPHER_NOARGS(Noekeon); +#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_SEED) -BOTAN_REGISTER_BLOCK_CIPHER_NOARGS(SEED); +#if defined(BOTAN_HAS_IDEA) + if(req.algo_name() == "IDEA" && req.arg_count() == 0) + { + return std::unique_ptr<BlockCipher>(new IDEA); + } #endif -#if defined(BOTAN_HAS_SERPENT) -BOTAN_REGISTER_BLOCK_CIPHER_NOARGS(Serpent); +#if defined(BOTAN_HAS_KASUMI) + if(req.algo_name() == "KASUMI" && req.arg_count() == 0) + { + return std::unique_ptr<BlockCipher>(new KASUMI); + } #endif -#if defined(BOTAN_HAS_TWOFISH) -BOTAN_REGISTER_BLOCK_CIPHER_NOARGS(Twofish); +#if defined(BOTAN_HAS_MISTY1) + if(req.algo_name() == "MISTY1" && req.arg_count() == 0) + { + return std::unique_ptr<BlockCipher>(new MISTY1); + } #endif -#if defined(BOTAN_HAS_THREEFISH_512) -BOTAN_REGISTER_BLOCK_CIPHER_NAMED_NOARGS(Threefish_512, "Threefish-512"); +#if defined(BOTAN_HAS_SEED) + if(req.algo_name() == "SEED" && req.arg_count() == 0) + { + return std::unique_ptr<BlockCipher>(new SEED); + } #endif #if defined(BOTAN_HAS_XTEA) -BOTAN_REGISTER_BLOCK_CIPHER_NOARGS(XTEA); + if(req.algo_name() == "XTEA" && req.arg_count() == 0) + { + return std::unique_ptr<BlockCipher>(new XTEA); + } #endif #if defined(BOTAN_HAS_CASCADE) -BOTAN_REGISTER_NAMED_T(BlockCipher, "Cascade", Cascade_Cipher, Cascade_Cipher::make); + 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) -BOTAN_REGISTER_NAMED_T(BlockCipher, "Lion", Lion, Lion::make); + 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 + 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" }); + } + } diff --git a/src/lib/block/block_cipher.h b/src/lib/block/block_cipher.h index 7c7084155..2062160bc 100644 --- a/src/lib/block/block_cipher.h +++ b/src/lib/block/block_cipher.h @@ -8,7 +8,6 @@ #ifndef BOTAN_BLOCK_CIPHER_H__ #define BOTAN_BLOCK_CIPHER_H__ -#include <botan/scan_name.h> #include <botan/sym_algo.h> #include <string> @@ -20,7 +19,6 @@ namespace Botan { class BOTAN_DLL BlockCipher : public SymmetricAlgorithm { public: - typedef SCAN_Name Spec; /** * Create an instance based on a name @@ -29,8 +27,18 @@ class BOTAN_DLL BlockCipher : public SymmetricAlgorithm * @param provider provider implementation to choose * @return a null pointer if the algo/provider combination cannot be found */ - static std::unique_ptr<BlockCipher> create(const std::string& algo_spec, - const std::string& provider = ""); + static std::unique_ptr<BlockCipher> + create(const std::string& algo_spec, + const std::string& provider = ""); + + /** + * Create an instance based on a name, or throw if the + * algo/provider combination cannot be found. If provider is + * empty then best available is chosen. + */ + static std::unique_ptr<BlockCipher> + create_or_throw(const std::string& algo_spec, + const std::string& provider = ""); /** * @return list of available providers for this algorithm, empty if not available @@ -165,7 +173,7 @@ class BOTAN_DLL BlockCipher : public SymmetricAlgorithm */ virtual BlockCipher* clone() const = 0; - virtual ~BlockCipher(); + virtual ~BlockCipher() {} }; /** diff --git a/src/lib/block/cascade/cascade.cpp b/src/lib/block/cascade/cascade.cpp index 100fb33ab..98e862de9 100644 --- a/src/lib/block/cascade/cascade.cpp +++ b/src/lib/block/cascade/cascade.cpp @@ -9,16 +9,6 @@ namespace Botan { -Cascade_Cipher* Cascade_Cipher::make(const BlockCipher::Spec& spec) - { - std::unique_ptr<BlockCipher> c1(BlockCipher::create(spec.arg(0))); - std::unique_ptr<BlockCipher> c2(BlockCipher::create(spec.arg(1))); - - if(c1 && c2) - return new Cascade_Cipher(c1.release(), c2.release()); - return nullptr; - } - void Cascade_Cipher::encrypt_n(const byte in[], byte out[], size_t blocks) const { diff --git a/src/lib/block/cascade/cascade.h b/src/lib/block/cascade/cascade.h index 21af5bea4..aa7bd0421 100644 --- a/src/lib/block/cascade/cascade.h +++ b/src/lib/block/cascade/cascade.h @@ -33,8 +33,6 @@ class BOTAN_DLL Cascade_Cipher final : public BlockCipher std::string name() const override; BlockCipher* clone() const override; - static Cascade_Cipher* make(const Spec& spec); - /** * Create a cascade of two block ciphers * @param cipher1 the first cipher diff --git a/src/lib/block/lion/lion.cpp b/src/lib/block/lion/lion.cpp index 7ae620504..56aa55c2f 100644 --- a/src/lib/block/lion/lion.cpp +++ b/src/lib/block/lion/lion.cpp @@ -10,22 +10,6 @@ namespace Botan { -Lion* Lion::make(const BlockCipher::Spec& spec) - { - if(spec.arg_count_between(2, 3)) - { - std::unique_ptr<HashFunction> hash(HashFunction::create(spec.arg(0))); - std::unique_ptr<StreamCipher> stream(StreamCipher::create(spec.arg(1))); - - if(hash && stream) - { - const size_t block_size = spec.arg_as_integer(2, 1024); - return new Lion(hash.release(), stream.release(), block_size); - } - } - return nullptr; - } - /* * Lion Encryption */ diff --git a/src/lib/block/lion/lion.h b/src/lib/block/lion/lion.h index f22f0f8a8..e6ecca64f 100644 --- a/src/lib/block/lion/lion.h +++ b/src/lib/block/lion/lion.h @@ -39,8 +39,6 @@ class BOTAN_DLL Lion final : public BlockCipher std::string name() const override; BlockCipher* clone() const override; - static Lion* make(const Spec&); - /** * @param hash the hash to use internally * @param cipher the stream cipher to use internally diff --git a/src/lib/compression/bzip2/bzip2.cpp b/src/lib/compression/bzip2/bzip2.cpp index 565eb09fc..1d1af7e29 100644 --- a/src/lib/compression/bzip2/bzip2.cpp +++ b/src/lib/compression/bzip2/bzip2.cpp @@ -8,6 +8,7 @@ */ #include <botan/bzip2.h> +#include <botan/exceptn.h> #include <botan/internal/compress_utils.h> #define BZ_NO_STDIO @@ -15,8 +16,6 @@ namespace Botan { -BOTAN_REGISTER_COMPRESSION(Bzip2_Compression, Bzip2_Decompression); - namespace { class Bzip2_Stream : public Zlib_Style_Stream<bz_stream, char> diff --git a/src/lib/compression/compress_utils.cpp b/src/lib/compression/compress_utils.cpp new file mode 100644 index 000000000..2af629b9c --- /dev/null +++ b/src/lib/compression/compress_utils.cpp @@ -0,0 +1,189 @@ +/* +* Compression Utils +* (C) 2014,2016 Jack Lloyd +* +* Botan is released under the Simplified BSD License (see license.txt) +*/ + +#include <botan/internal/compress_utils.h> +#include <botan/exceptn.h> + +namespace Botan { + +void* Compression_Alloc_Info::do_malloc(size_t n, size_t size) + { + const size_t total_size = n * size; + + BOTAN_ASSERT_EQUAL(total_size / size, n, "Overflow check"); + + // TODO maximum length check here? + + void* ptr = std::malloc(total_size); + + /* + * Return null rather than throwing here as we are being called by a + * C library and it may not be possible for an exception to unwind + * the call stack from here. The compression library is expecting a + * function written in C and a null return on error, which it will + * send upwards to the compression wrappers. + */ + + if(ptr) + { + std::memset(ptr, 0, total_size); + m_current_allocs[ptr] = total_size; + } + + return ptr; + } + +void Compression_Alloc_Info::do_free(void* ptr) + { + if(ptr) + { + auto i = m_current_allocs.find(ptr); + + if(i == m_current_allocs.end()) + throw Exception("Compression_Alloc_Info::free got pointer not allocated by us"); + + zero_mem(ptr, i->second); + std::free(ptr); + m_current_allocs.erase(i); + } + } + +void Stream_Compression::clear() + { + m_stream.reset(); + } + +void Stream_Compression::start(size_t level) + { + m_stream.reset(make_stream(level)); + } + +void Stream_Compression::process(secure_vector<byte>& buf, size_t offset, u32bit flags) + { + BOTAN_ASSERT(m_stream, "Initialized"); + BOTAN_ASSERT(buf.size() >= offset, "Offset is sane"); + + if(m_buffer.size() < buf.size() + offset) + m_buffer.resize(buf.size() + offset); + + // If the output buffer has zero length, .data() might return nullptr. This would + // make some compression algorithms (notably those provided by zlib) fail. + // Any small positive value works fine, but we choose 32 as it is the smallest power + // of two that is large enough to hold all the headers and trailers of the common + // formats, preventing further resizings to make room for output data. + if(m_buffer.size() == 0) + m_buffer.resize(32); + + m_stream->next_in(buf.data() + offset, buf.size() - offset); + m_stream->next_out(m_buffer.data() + offset, m_buffer.size() - offset); + + while(true) + { + m_stream->run(flags); + + if(m_stream->avail_out() == 0) + { + const size_t added = 8 + m_buffer.size(); + m_buffer.resize(m_buffer.size() + added); + m_stream->next_out(m_buffer.data() + m_buffer.size() - added, added); + } + else if(m_stream->avail_in() == 0) + { + m_buffer.resize(m_buffer.size() - m_stream->avail_out()); + break; + } + } + + copy_mem(m_buffer.data(), buf.data(), offset); + buf.swap(m_buffer); + } + +void Stream_Compression::update(secure_vector<byte>& buf, size_t offset, bool flush) + { + BOTAN_ASSERT(m_stream, "Initialized"); + process(buf, offset, flush ? m_stream->flush_flag() : m_stream->run_flag()); + } + +void Stream_Compression::finish(secure_vector<byte>& buf, size_t offset) + { + BOTAN_ASSERT(m_stream, "Initialized"); + process(buf, offset, m_stream->finish_flag()); + clear(); + } + +void Stream_Decompression::clear() + { + m_stream.reset(); + } + +void Stream_Decompression::start() + { + m_stream.reset(make_stream()); + } + +void Stream_Decompression::process(secure_vector<byte>& buf, size_t offset, u32bit flags) + { + BOTAN_ASSERT(m_stream, "Initialized"); + BOTAN_ASSERT(buf.size() >= offset, "Offset is sane"); + + if(m_buffer.size() < buf.size() + offset) + m_buffer.resize(buf.size() + offset); + + m_stream->next_in(buf.data() + offset, buf.size() - offset); + m_stream->next_out(m_buffer.data() + offset, m_buffer.size() - offset); + + while(true) + { + const bool stream_end = m_stream->run(flags); + + if(stream_end) + { + if(m_stream->avail_in() == 0) // all data consumed? + { + m_buffer.resize(m_buffer.size() - m_stream->avail_out()); + clear(); + break; + } + + // More data follows: try to process as a following stream + const size_t read = (buf.size() - offset) - m_stream->avail_in(); + start(); + m_stream->next_in(buf.data() + offset + read, buf.size() - offset - read); + } + + if(m_stream->avail_out() == 0) + { + const size_t added = 8 + m_buffer.size(); + m_buffer.resize(m_buffer.size() + added); + m_stream->next_out(m_buffer.data() + m_buffer.size() - added, added); + } + else if(m_stream->avail_in() == 0) + { + m_buffer.resize(m_buffer.size() - m_stream->avail_out()); + break; + } + } + + copy_mem(m_buffer.data(), buf.data(), offset); + buf.swap(m_buffer); + } + +void Stream_Decompression::update(secure_vector<byte>& buf, size_t offset) + { + process(buf, offset, m_stream->run_flag()); + } + +void Stream_Decompression::finish(secure_vector<byte>& buf, size_t offset) + { + if(buf.size() != offset || m_stream.get()) + process(buf, offset, m_stream->finish_flag()); + + if(m_stream.get()) + throw Exception(name() + " finished but not at stream end"); + } + +} diff --git a/src/lib/compression/compress_utils.h b/src/lib/compression/compress_utils.h index a60ae3c22..9f6871a0b 100644 --- a/src/lib/compression/compress_utils.h +++ b/src/lib/compression/compress_utils.h @@ -9,7 +9,6 @@ #define BOTAN_COMPRESSION_UTILS_H__ #include <botan/compression.h> -#include <botan/internal/algo_registry.h> #include <memory> #include <unordered_map> @@ -85,10 +84,6 @@ class Zlib_Style_Stream : public Compression_Stream std::unique_ptr<Compression_Alloc_Info> m_allocs; }; -#define BOTAN_REGISTER_COMPRESSION(C, D) \ - BOTAN_REGISTER_T_NOARGS(Compression_Algorithm, C); \ - BOTAN_REGISTER_T_NOARGS(Decompression_Algorithm, D) - } #endif diff --git a/src/lib/compression/compression.cpp b/src/lib/compression/compression.cpp index f289aa79f..92004a071 100644 --- a/src/lib/compression/compression.cpp +++ b/src/lib/compression/compression.cpp @@ -1,233 +1,75 @@ /* -* Compression Transform -* (C) 2014 Jack Lloyd +* Compression Factory +* (C) 2014,2016 Jack Lloyd * * Botan is released under the Simplified BSD License (see license.txt) */ #include <botan/compression.h> -#include <botan/internal/compress_utils.h> #include <botan/mem_ops.h> #include <cstdlib> -namespace Botan { - -void* Compression_Alloc_Info::do_malloc(size_t n, size_t size) - { - const size_t total_size = n * size; - - BOTAN_ASSERT_EQUAL(total_size / size, n, "Overflow check"); - - // TODO maximum length check here? - - void* ptr = std::malloc(total_size); - - /* - * Return null rather than throwing here as we are being called by a - * C library and it may not be possible for an exception to unwind - * the call stack from here. The compression library is expecting a - * function written in C and a null return on error, which it will - * send upwards to the compression wrappers. - */ - - if(ptr) - { - std::memset(ptr, 0, total_size); - m_current_allocs[ptr] = total_size; - } - - return ptr; - } - -void Compression_Alloc_Info::do_free(void* ptr) - { - if(ptr) - { - auto i = m_current_allocs.find(ptr); - - if(i == m_current_allocs.end()) - throw Exception("Compression_Alloc_Info::free got pointer not allocated by us"); - - zero_mem(ptr, i->second); - std::free(ptr); - m_current_allocs.erase(i); - } - } - -Compression_Algorithm* make_compressor(const std::string& type) - { - const std::map<std::string, std::string> trans{ - {"zlib", "Zlib"}, - {"deflate", "Deflate"}, - {"gzip", "Gzip"}, - {"gz", "Gzip"}, - {"bzip2", "Bzip2"}, - {"bz2", "Bzip2"}, - {"lzma", "LZMA"}, - {"xz", "LZMA"}}; - - auto i = trans.find(type); - - if(i == trans.end()) - return nullptr; - - const SCAN_Name t_name(i->second + "_Compression"); - return Algo_Registry<Compression_Algorithm>::global_registry().make(t_name); - } - -Decompression_Algorithm* make_decompressor(const std::string& type) - { - const std::map<std::string, std::string> trans{ - {"zlib", "Zlib"}, - {"deflate", "Deflate"}, - {"gzip", "Gzip"}, - {"gz", "Gzip"}, - {"bzip2", "Bzip2"}, - {"bz2", "Bzip2"}, - {"lzma", "LZMA"}, - {"xz", "LZMA"}}; - - auto i = trans.find(type); - - if(i == trans.end()) - return nullptr; - - const SCAN_Name t_name(i->second + "_Decompression"); - return Algo_Registry<Decompression_Algorithm>::global_registry().make(t_name); - } - -void Stream_Compression::clear() - { - m_stream.reset(); - } - -void Stream_Compression::start(size_t level) - { - m_stream.reset(make_stream(level)); - } - -void Stream_Compression::process(secure_vector<byte>& buf, size_t offset, u32bit flags) - { - BOTAN_ASSERT(m_stream, "Initialized"); - BOTAN_ASSERT(buf.size() >= offset, "Offset is sane"); - - if(m_buffer.size() < buf.size() + offset) - m_buffer.resize(buf.size() + offset); - - // If the output buffer has zero length, .data() might return nullptr. This would - // make some compression algorithms (notably those provided by zlib) fail. - // Any small positive value works fine, but we choose 32 as it is the smallest power - // of two that is large enough to hold all the headers and trailers of the common - // formats, preventing further resizings to make room for output data. - if(m_buffer.size() == 0) - m_buffer.resize(32); - - m_stream->next_in(buf.data() + offset, buf.size() - offset); - m_stream->next_out(m_buffer.data() + offset, m_buffer.size() - offset); - - while(true) - { - m_stream->run(flags); +#if defined(BOTAN_HAS_ZLIB) + #include <botan/zlib.h> +#endif - if(m_stream->avail_out() == 0) - { - const size_t added = 8 + m_buffer.size(); - m_buffer.resize(m_buffer.size() + added); - m_stream->next_out(m_buffer.data() + m_buffer.size() - added, added); - } - else if(m_stream->avail_in() == 0) - { - m_buffer.resize(m_buffer.size() - m_stream->avail_out()); - break; - } - } +#if defined(BOTAN_HAS_BZIP2) + #include <botan/bzip2.h> +#endif - copy_mem(m_buffer.data(), buf.data(), offset); - buf.swap(m_buffer); - } - -void Stream_Compression::update(secure_vector<byte>& buf, size_t offset, bool flush) - { - BOTAN_ASSERT(m_stream, "Initialized"); - process(buf, offset, flush ? m_stream->flush_flag() : m_stream->run_flag()); - } +#if defined(BOTAN_HAS_LZMA) + #include <botan/lzma.h> +#endif -void Stream_Compression::finish(secure_vector<byte>& buf, size_t offset) - { - BOTAN_ASSERT(m_stream, "Initialized"); - process(buf, offset, m_stream->finish_flag()); - clear(); - } - -void Stream_Decompression::clear() - { - m_stream.reset(); - } +namespace Botan { -void Stream_Decompression::start() +Compression_Algorithm* make_compressor(const std::string& name) { - m_stream.reset(make_stream()); +#if defined(BOTAN_HAS_ZLIB) + if(name == "Zlib" || name == "zlib") + return new Zlib_Compression; + if(name == "Gzip" || name == "gzip" || name == "gz") + return new Gzip_Compression; + if(name == "Deflate" || name == "deflate") + return new Deflate_Compression; +#endif + +#if defined(BOTAN_HAS_BZIP2) + if(name == "bzip2" || name == "bz2" || name == "Bzip2") + return new Bzip2_Compression; +#endif + +#if defined(BOTAN_HAS_LZMA) + if(name == "lzma" || name == "xz" || name == "LZMA") + return new LZMA_Compression; +#endif + + return nullptr; } -void Stream_Decompression::process(secure_vector<byte>& buf, size_t offset, u32bit flags) +Decompression_Algorithm* make_decompressor(const std::string& name) { - BOTAN_ASSERT(m_stream, "Initialized"); - BOTAN_ASSERT(buf.size() >= offset, "Offset is sane"); - - if(m_buffer.size() < buf.size() + offset) - m_buffer.resize(buf.size() + offset); - - m_stream->next_in(buf.data() + offset, buf.size() - offset); - m_stream->next_out(m_buffer.data() + offset, m_buffer.size() - offset); - - while(true) - { - const bool stream_end = m_stream->run(flags); - - if(stream_end) - { - if(m_stream->avail_in() == 0) // all data consumed? - { - m_buffer.resize(m_buffer.size() - m_stream->avail_out()); - clear(); - break; - } - - // More data follows: try to process as a following stream - const size_t read = (buf.size() - offset) - m_stream->avail_in(); - start(); - m_stream->next_in(buf.data() + offset + read, buf.size() - offset - read); - } - - if(m_stream->avail_out() == 0) - { - const size_t added = 8 + m_buffer.size(); - m_buffer.resize(m_buffer.size() + added); - m_stream->next_out(m_buffer.data() + m_buffer.size() - added, added); - } - else if(m_stream->avail_in() == 0) - { - m_buffer.resize(m_buffer.size() - m_stream->avail_out()); - break; - } - } - - copy_mem(m_buffer.data(), buf.data(), offset); - buf.swap(m_buffer); - } - -void Stream_Decompression::update(secure_vector<byte>& buf, size_t offset) - { - process(buf, offset, m_stream->run_flag()); +#if defined(BOTAN_HAS_ZLIB) + if(name == "Zlib" || name == "zlib") + return new Zlib_Decompression; + if(name == "Gzip" || name == "gzip" || name == "gz") + return new Gzip_Decompression; + if(name == "Deflate" || name == "deflate") + return new Deflate_Decompression; +#endif + +#if defined(BOTAN_HAS_BZIP2) + if(name == "bzip2" || name == "bz2" || name == "Bzip2") + return new Bzip2_Decompression; +#endif + +#if defined(BOTAN_HAS_LZMA) + if(name == "lzma" || name == "xz" || name == "LZMA") + return new LZMA_Decompression; +#endif + + return nullptr; } -void Stream_Decompression::finish(secure_vector<byte>& buf, size_t offset) - { - if(buf.size() != offset || m_stream.get()) - process(buf, offset, m_stream->finish_flag()); - - if(m_stream.get()) - throw Exception(name() + " finished but not at stream end"); - } } diff --git a/src/lib/compression/compression.h b/src/lib/compression/compression.h index f135f6d04..693772b6a 100644 --- a/src/lib/compression/compression.h +++ b/src/lib/compression/compression.h @@ -9,7 +9,6 @@ #define BOTAN_COMPRESSION_TRANSFORM_H__ #include <botan/secmem.h> -#include <botan/scan_name.h> namespace Botan { @@ -19,8 +18,6 @@ namespace Botan { class BOTAN_DLL Compression_Algorithm { public: - typedef SCAN_Name Spec; - /** * Begin compressing. Most compression algorithms offer a tunable * time/compression tradeoff parameter generally represented by @@ -67,8 +64,6 @@ class BOTAN_DLL Compression_Algorithm class BOTAN_DLL Decompression_Algorithm { public: - typedef SCAN_Name Spec; - /** * Begin decompressing. * Decompression does not support levels, as compression does. @@ -108,7 +103,7 @@ BOTAN_DLL Compression_Algorithm* make_compressor(const std::string& type); BOTAN_DLL Decompression_Algorithm* make_decompressor(const std::string& type); /** -* FIXME add doc +* Adapts a zlib style API */ class Compression_Stream { @@ -131,7 +126,7 @@ class Compression_Stream }; /** -* FIXME add doc +* Used to implement compression using Compression_Stream */ class Stream_Compression : public Compression_Algorithm { diff --git a/src/lib/compression/lzma/lzma.cpp b/src/lib/compression/lzma/lzma.cpp index 18701278d..3831ef68c 100644 --- a/src/lib/compression/lzma/lzma.cpp +++ b/src/lib/compression/lzma/lzma.cpp @@ -10,12 +10,11 @@ #include <botan/lzma.h> #include <botan/internal/compress_utils.h> +#include <botan/exceptn.h> #include <lzma.h> namespace Botan { -BOTAN_REGISTER_COMPRESSION(LZMA_Compression, LZMA_Decompression); - namespace { class LZMA_Stream : public Zlib_Style_Stream<lzma_stream, byte> diff --git a/src/lib/compression/zlib/zlib.cpp b/src/lib/compression/zlib/zlib.cpp index 836925a68..27ae6fb20 100644 --- a/src/lib/compression/zlib/zlib.cpp +++ b/src/lib/compression/zlib/zlib.cpp @@ -9,15 +9,12 @@ #include <botan/zlib.h> #include <botan/internal/compress_utils.h> +#include <botan/exceptn.h> #include <ctime> #include <zlib.h> namespace Botan { -BOTAN_REGISTER_COMPRESSION(Zlib_Compression, Zlib_Decompression); -BOTAN_REGISTER_COMPRESSION(Gzip_Compression, Gzip_Decompression); -BOTAN_REGISTER_COMPRESSION(Deflate_Compression, Deflate_Decompression); - namespace { class Zlib_Stream : public Zlib_Style_Stream<z_stream, Bytef> diff --git a/src/lib/filters/filters.h b/src/lib/filters/filters.h index 2b6e2b1cd..af2b6c70d 100644 --- a/src/lib/filters/filters.h +++ b/src/lib/filters/filters.h @@ -18,8 +18,6 @@ #include <botan/key_filt.h> #include <botan/data_snk.h> -#include <botan/scan_name.h> - #if defined(BOTAN_HAS_CODEC_FILTERS) #include <botan/b64_filt.h> #include <botan/hex_filt.h> diff --git a/src/lib/hash/blake2/blake2b.cpp b/src/lib/hash/blake2/blake2b.cpp index 10ccbf5c0..928f344d7 100644 --- a/src/lib/hash/blake2/blake2b.cpp +++ b/src/lib/hash/blake2/blake2b.cpp @@ -39,11 +39,6 @@ const u64bit blake2b_sigma[12][16] = { }; } -Blake2b* Blake2b::make(const Spec& spec) - { - return new Blake2b(spec.arg_as_integer(0, 512)); - } - Blake2b::Blake2b(size_t output_bits) : m_output_bits(output_bits), m_buffer(BLAKE2B_BLOCKBYTES), diff --git a/src/lib/hash/blake2/blake2b.h b/src/lib/hash/blake2/blake2b.h index 290db10f0..343f276b5 100644 --- a/src/lib/hash/blake2/blake2b.h +++ b/src/lib/hash/blake2/blake2b.h @@ -34,8 +34,6 @@ class BOTAN_DLL Blake2b final : public HashFunction size_t hash_block_size() const override { return BLAKE2B_BLOCKBYTES; } size_t output_length() const override { return m_output_bits / 8; } - static Blake2b* make(const Spec& spec); - HashFunction* clone() const override; std::string name() const override; void clear() override; diff --git a/src/lib/hash/comb4p/comb4p.cpp b/src/lib/hash/comb4p/comb4p.cpp index 015873473..4659ace77 100644 --- a/src/lib/hash/comb4p/comb4p.cpp +++ b/src/lib/hash/comb4p/comb4p.cpp @@ -33,19 +33,6 @@ void comb4p_round(secure_vector<byte>& out, } -Comb4P* Comb4P::make(const Spec& spec) - { - if(spec.arg_count() == 2) - { - std::unique_ptr<HashFunction> h1(HashFunction::create(spec.arg(0))); - std::unique_ptr<HashFunction> h2(HashFunction::create(spec.arg(1))); - - if(h1 && h2) - return new Comb4P(h1.release(), h2.release()); - } - return nullptr; - } - Comb4P::Comb4P(HashFunction* h1, HashFunction* h2) : m_hash1(h1), m_hash2(h2) { diff --git a/src/lib/hash/comb4p/comb4p.h b/src/lib/hash/comb4p/comb4p.h index c05953ea5..cb78914e7 100644 --- a/src/lib/hash/comb4p/comb4p.h +++ b/src/lib/hash/comb4p/comb4p.h @@ -32,8 +32,6 @@ class BOTAN_DLL Comb4P final : public HashFunction return m_hash1->output_length() + m_hash2->output_length(); } - static Comb4P* make(const Spec& spec); - HashFunction* clone() const override { return new Comb4P(m_hash1->clone(), m_hash2->clone()); diff --git a/src/lib/hash/hash.cpp b/src/lib/hash/hash.cpp index 016f60df1..dc95099b8 100644 --- a/src/lib/hash/hash.cpp +++ b/src/lib/hash/hash.cpp @@ -6,8 +6,7 @@ */ #include <botan/hash.h> -#include <botan/cpuid.h> -#include <botan/internal/algo_registry.h> +#include <botan/scan_name.h> #if defined(BOTAN_HAS_ADLER32) #include <botan/adler32.h> @@ -81,109 +80,213 @@ #include <botan/blake2b.h> #endif +#if defined(BOTAN_HAS_OPENSSL) + #include <botan/internal/openssl.h> +#endif + namespace Botan { std::unique_ptr<HashFunction> HashFunction::create(const std::string& algo_spec, const std::string& provider) { - return std::unique_ptr<HashFunction>(make_a<HashFunction>(Botan::HashFunction::Spec(algo_spec), provider)); - } + const SCAN_Name req(algo_spec); -std::vector<std::string> HashFunction::providers(const std::string& algo_spec) - { - return providers_of<HashFunction>(HashFunction::Spec(algo_spec)); - } +#if defined(BOTAN_HAS_OPENSSL) + if(provider.empty() || provider == "openssl") + { + if(auto hash = make_openssl_hash(algo_spec)) + return hash; -HashFunction::HashFunction() {} + if(!provider.empty()) + return nullptr; + } +#endif -HashFunction::~HashFunction() {} + if(provider.empty() == false && provider != "base") + return nullptr; // unknown provider -#define BOTAN_REGISTER_HASH(name, maker) BOTAN_REGISTER_T(HashFunction, name, maker) -#define BOTAN_REGISTER_HASH_NOARGS(name) BOTAN_REGISTER_T_NOARGS(HashFunction, name) +#if defined(BOTAN_HAS_SHA1) + if(req.algo_name() == "SHA-160") + { + return std::unique_ptr<HashFunction>(new SHA_160); + } +#endif -#define BOTAN_REGISTER_HASH_1LEN(name, def) BOTAN_REGISTER_T_1LEN(HashFunction, name, def) +#if defined(BOTAN_HAS_SHA2_32) + if(req.algo_name() == "SHA-224") + { + return std::unique_ptr<HashFunction>(new SHA_224); + } -#define BOTAN_REGISTER_HASH_NAMED_NOARGS(type, name) \ - BOTAN_REGISTER_NAMED_T(HashFunction, name, type, make_new_T<type>) -#define BOTAN_REGISTER_HASH_NAMED_1LEN(type, name, def) \ - BOTAN_REGISTER_NAMED_T(HashFunction, name, type, (make_new_T_1len<type,def>)) + if(req.algo_name() == "SHA-256") + { + return std::unique_ptr<HashFunction>(new SHA_256); + } +#endif -#define BOTAN_REGISTER_HASH_NOARGS_IF(cond, type, name, provider, pref) \ - BOTAN_COND_REGISTER_NAMED_T_NOARGS(cond, HashFunction, type, name, provider, pref) +#if defined(BOTAN_HAS_SHA2_64) + if(req.algo_name() == "SHA-384") + { + return std::unique_ptr<HashFunction>(new SHA_384); + } -#if defined(BOTAN_HAS_ADLER32) -BOTAN_REGISTER_HASH_NOARGS(Adler32); -#endif + if(req.algo_name() == "SHA-512") + { + return std::unique_ptr<HashFunction>(new SHA_512); + } -#if defined(BOTAN_HAS_CRC24) -BOTAN_REGISTER_HASH_NOARGS(CRC24); + if(req.algo_name() == "SHA-512-256") + { + return std::unique_ptr<HashFunction>(new SHA_512_256); + } #endif -#if defined(BOTAN_HAS_CRC32) -BOTAN_REGISTER_HASH_NOARGS(CRC32); +#if defined(BOTAN_HAS_RIPEMD_160) + if(req.algo_name() == "RIPEMD-160") + { + return std::unique_ptr<HashFunction>(new RIPEMD_160); + } #endif -#if defined(BOTAN_HAS_COMB4P) -BOTAN_REGISTER_NAMED_T(HashFunction, "Comb4P", Comb4P, Comb4P::make); +#if defined(BOTAN_HAS_TIGER) + if(req.algo_name() == "Tiger") + { + return std::unique_ptr<HashFunction>( + new Tiger(req.arg_as_integer(0, 24), + req.arg_as_integer(1, 3))); + } #endif -#if defined(BOTAN_HAS_PARALLEL_HASH) -BOTAN_REGISTER_NAMED_T(HashFunction, "Parallel", Parallel, Parallel::make); +#if defined(BOTAN_HAS_SKEIN_512) + if(req.algo_name() == "Skein-512") + { + return std::unique_ptr<HashFunction>( + new Skein_512(req.arg_as_integer(0, 512), req.arg(1, ""))); + } #endif -#if defined(BOTAN_HAS_GOST_34_11) -BOTAN_REGISTER_HASH_NAMED_NOARGS(GOST_34_11, "GOST-R-34.11-94"); +#if defined(BOTAN_HAS_BLAKE2B) + if(req.algo_name() == "Blake2b") + { + return std::unique_ptr<HashFunction>( + new Blake2b(req.arg_as_integer(0, 512))); + } #endif #if defined(BOTAN_HAS_KECCAK) -BOTAN_REGISTER_HASH_NAMED_1LEN(Keccak_1600, "Keccak-1600", 512); + if(req.algo_name() == "Keccak-1600") + { + return std::unique_ptr<HashFunction>( + new Keccak_1600(req.arg_as_integer(0, 512))); + } #endif #if defined(BOTAN_HAS_SHA3) -BOTAN_REGISTER_HASH_NAMED_1LEN(SHA_3, "SHA-3", 512); + if(req.algo_name() == "SHA-3") + { + return std::unique_ptr<HashFunction>( + new SHA_3(req.arg_as_integer(0, 512))); + } #endif -#if defined(BOTAN_HAS_MD4) -BOTAN_REGISTER_HASH_NOARGS(MD4); +#if defined(BOTAN_HAS_WHIRLPOOL) + if(req.algo_name() == "Whirlpool") + { + return std::unique_ptr<HashFunction>(new Whirlpool); + } #endif -#if defined(BOTAN_HAS_MD5) -BOTAN_REGISTER_HASH_NOARGS(MD5); -#endif +#if defined(BOTAN_HAS_PARALLEL_HASH) + if(req.algo_name() == "Parallel") + { + std::vector<std::unique_ptr<HashFunction>> hashes; -#if defined(BOTAN_HAS_RIPEMD_160) -BOTAN_REGISTER_HASH_NAMED_NOARGS(RIPEMD_160, "RIPEMD-160"); + for(size_t i = 0; i != req.arg_count(); ++i) + { + auto h = HashFunction::create(req.arg(i)); + if(!h) + { + return nullptr; + } + hashes.push_back(std::move(h)); + } + + return std::unique_ptr<HashFunction>(new Parallel(hashes)); + } #endif -#if defined(BOTAN_HAS_SHA1) -BOTAN_REGISTER_HASH_NAMED_NOARGS(SHA_160, "SHA-160"); +#if defined(BOTAN_HAS_COMB4P) + if(req.algo_name() == "Comb4p" && req.arg_count() == 2) + { + std::unique_ptr<HashFunction> h1(HashFunction::create(req.arg(0))); + std::unique_ptr<HashFunction> h2(HashFunction::create(req.arg(1))); + + if(h1 && h2) + return std::unique_ptr<HashFunction>(new Comb4P(h1.release(), h2.release())); + } #endif -#if defined(BOTAN_HAS_SHA2_32) -BOTAN_REGISTER_HASH_NAMED_NOARGS(SHA_224, "SHA-224"); -BOTAN_REGISTER_HASH_NAMED_NOARGS(SHA_256, "SHA-256"); +#if defined(BOTAN_HAS_MD5) + if(req.algo_name() == "MD5") + { + return std::unique_ptr<HashFunction>(new MD5); + } #endif -#if defined(BOTAN_HAS_SHA2_64) -BOTAN_REGISTER_HASH_NAMED_NOARGS(SHA_384, "SHA-384"); -BOTAN_REGISTER_HASH_NAMED_NOARGS(SHA_512, "SHA-512"); -BOTAN_REGISTER_HASH_NAMED_NOARGS(SHA_512_256, "SHA-512-256"); +#if defined(BOTAN_HAS_MD4) + if(req.algo_name() == "MD4") + { + return std::unique_ptr<HashFunction>(new MD4); + } #endif -#if defined(BOTAN_HAS_TIGER) -BOTAN_REGISTER_NAMED_T_2LEN(HashFunction, Tiger, "Tiger", "base", 24, 3); +#if defined(BOTAN_HAS_GOST_34_11) + if(req.algo_name() == "GOST-R-34.11-94") + { + return std::unique_ptr<HashFunction>(new GOST_34_11); + } #endif -#if defined(BOTAN_HAS_SKEIN_512) -BOTAN_REGISTER_NAMED_T(HashFunction, "Skein-512", Skein_512, Skein_512::make); +#if defined(BOTAN_HAS_ADLER32) + if(req.algo_name() == "Adler32") + { + return std::unique_ptr<HashFunction>(new Adler32); + } #endif -#if defined(BOTAN_HAS_WHIRLPOOL) -BOTAN_REGISTER_HASH_NOARGS(Whirlpool); +#if defined(BOTAN_HAS_CRC24) + if(req.algo_name() == "CRC24") + { + return std::unique_ptr<HashFunction>(new CRC24); + } #endif -#if defined(BOTAN_HAS_BLAKE2B) -BOTAN_REGISTER_NAMED_T(HashFunction, "Blake2b", Blake2b, Blake2b::make); +#if defined(BOTAN_HAS_CRC32) + if(req.algo_name() == "CRC32") + { + return std::unique_ptr<HashFunction>(new CRC32); + } #endif + return nullptr; + } + +//static +std::unique_ptr<HashFunction> +HashFunction::create_or_throw(const std::string& algo, + const std::string& provider) + { + if(auto hash = HashFunction::create(algo, provider)) + { + return hash; + } + throw Lookup_Error("Hash", algo, provider); + } + +std::vector<std::string> HashFunction::providers(const std::string& algo_spec) + { + return probe_providers_of<HashFunction>(algo_spec, {"base", "openssl"}); + } + } + diff --git a/src/lib/hash/hash.h b/src/lib/hash/hash.h index 206333b9f..f6cf470cb 100644 --- a/src/lib/hash/hash.h +++ b/src/lib/hash/hash.h @@ -8,7 +8,6 @@ #ifndef BOTAN_HASH_FUNCTION_BASE_CLASS_H__ #define BOTAN_HASH_FUNCTION_BASE_CLASS_H__ -#include <botan/scan_name.h> #include <botan/buf_comp.h> #include <string> @@ -20,17 +19,25 @@ namespace Botan { class BOTAN_DLL HashFunction : public Buffered_Computation { public: - typedef SCAN_Name Spec; + /** + * Create an instance based on a name, or return null if the + * algo/provider combination cannot be found. If provider is + * empty then best available is chosen. + */ + static std::unique_ptr<HashFunction> + create(const std::string& algo_spec, + const std::string& provider = ""); /** * Create an instance based on a name * If provider is empty then best available is chosen. * @param algo_spec algorithm name * @param provider provider implementation to use - * @return a null pointer if the algo/provider combination cannot be found + * Throws Lookup_Error if not not found. */ - static std::unique_ptr<HashFunction> create(const std::string& algo_spec, - const std::string& provider = ""); + static std::unique_ptr<HashFunction> + create_or_throw(const std::string& algo_spec, + const std::string& provider = ""); /** * @return list of available providers for this algorithm, empty if not available @@ -49,9 +56,7 @@ class BOTAN_DLL HashFunction : public Buffered_Computation */ virtual std::string provider() const { return "base"; } - HashFunction(); - - virtual ~HashFunction(); + virtual ~HashFunction() {} /** * Reset the state. diff --git a/src/lib/hash/par_hash/par_hash.cpp b/src/lib/hash/par_hash/par_hash.cpp index f6bed96ee..7320afee3 100644 --- a/src/lib/hash/par_hash/par_hash.cpp +++ b/src/lib/hash/par_hash/par_hash.cpp @@ -10,23 +10,6 @@ namespace Botan { -Parallel* Parallel::make(const Spec& spec) - { - std::vector<std::unique_ptr<HashFunction>> m_hashes; - - for(size_t i = 0; i != spec.arg_count(); ++i) - { - auto h = HashFunction::create(spec.arg(i)); - if(!h) - return nullptr; - m_hashes.push_back(std::move(h)); - } - - Parallel* p = new Parallel; - std::swap(p->m_hashes, m_hashes); - return p; - } - void Parallel::add_data(const byte input[], size_t length) { for(auto&& hash : m_hashes) @@ -65,10 +48,10 @@ std::string Parallel::name() const HashFunction* Parallel::clone() const { - std::vector<HashFunction*> hash_copies; + std::vector<std::unique_ptr<HashFunction>> hash_copies; for(auto&& hash : m_hashes) - hash_copies.push_back(hash.get()); + hash_copies.push_back(std::unique_ptr<HashFunction>(hash->clone())); return new Parallel(hash_copies); } @@ -79,12 +62,11 @@ void Parallel::clear() hash->clear(); } -Parallel::Parallel(const std::vector<HashFunction*>& in) +Parallel::Parallel(std::vector<std::unique_ptr<HashFunction>>& h) { - for(size_t i = 0; i != in.size(); ++i) + for(size_t i = 0; i != h.size(); ++i) { - std::unique_ptr<HashFunction> h(in[i]->clone()); - m_hashes.push_back(std::move(h)); + m_hashes.push_back(std::unique_ptr<HashFunction>(h[i].release())); } } diff --git a/src/lib/hash/par_hash/par_hash.h b/src/lib/hash/par_hash/par_hash.h index 3a93f4e8e..67d026c2f 100644 --- a/src/lib/hash/par_hash/par_hash.h +++ b/src/lib/hash/par_hash/par_hash.h @@ -27,13 +27,12 @@ class BOTAN_DLL Parallel final : public HashFunction /** * @param hashes a set of hashes to compute in parallel + * Takes ownership of all pointers */ - explicit Parallel(const std::vector<HashFunction*>& hashes); + explicit Parallel(std::vector<std::unique_ptr<HashFunction>>& hashes); Parallel(const Parallel&) = delete; Parallel& operator=(const Parallel&) = delete; - - static Parallel* make(const Spec& spec); private: Parallel() {} diff --git a/src/lib/hash/skein/skein_512.cpp b/src/lib/hash/skein/skein_512.cpp index 86ea9e75a..21eeb1f27 100644 --- a/src/lib/hash/skein/skein_512.cpp +++ b/src/lib/hash/skein/skein_512.cpp @@ -12,11 +12,6 @@ namespace Botan { -Skein_512* Skein_512::make(const Spec& spec) - { - return new Skein_512(spec.arg_as_integer(0, 512), spec.arg(1, "")); - } - Skein_512::Skein_512(size_t arg_output_bits, const std::string& arg_personalization) : m_personalization(arg_personalization), diff --git a/src/lib/hash/skein/skein_512.h b/src/lib/hash/skein/skein_512.h index 001d9a991..1f34f1583 100644 --- a/src/lib/hash/skein/skein_512.h +++ b/src/lib/hash/skein/skein_512.h @@ -32,8 +32,6 @@ class BOTAN_DLL Skein_512 final : public HashFunction size_t hash_block_size() const override { return 64; } size_t output_length() const override { return m_output_bits / 8; } - static Skein_512* make(const Spec& spec); - HashFunction* clone() const override; std::string name() const override; void clear() override; diff --git a/src/lib/kdf/hkdf/hkdf.cpp b/src/lib/kdf/hkdf/hkdf.cpp index 56dc72f09..13d5832d2 100644 --- a/src/lib/kdf/hkdf/hkdf.cpp +++ b/src/lib/kdf/hkdf/hkdf.cpp @@ -9,17 +9,6 @@ namespace Botan { -HKDF* HKDF::make(const Spec& spec) - { - if(auto mac = MessageAuthenticationCode::create(spec.arg(0))) - return new HKDF(mac.release()); - - if(auto mac = MessageAuthenticationCode::create("HMAC(" + spec.arg(0) + ")")) - return new HKDF(mac.release()); - - return nullptr; - } - size_t HKDF::kdf(byte out[], size_t out_len, const byte secret[], size_t secret_len, const byte salt[], size_t salt_len, diff --git a/src/lib/kdf/hkdf/hkdf.h b/src/lib/kdf/hkdf/hkdf.h index ea17f8c01..54ecc5283 100644 --- a/src/lib/kdf/hkdf/hkdf.h +++ b/src/lib/kdf/hkdf/hkdf.h @@ -27,8 +27,6 @@ class BOTAN_DLL HKDF final : public KDF */ explicit HKDF(MessageAuthenticationCode* prf) : m_prf(prf) {} - static HKDF* make(const Spec& spec); - KDF* clone() const override { return new HKDF(m_prf->clone()); } std::string name() const override { return "HKDF(" + m_prf->name() + ")"; } diff --git a/src/lib/kdf/kdf.cpp b/src/lib/kdf/kdf.cpp index 66296bf96..f8f822809 100644 --- a/src/lib/kdf/kdf.cpp +++ b/src/lib/kdf/kdf.cpp @@ -6,8 +6,8 @@ */ #include <botan/kdf.h> +#include <botan/scan_name.h> #include <botan/exceptn.h> -#include <botan/internal/algo_registry.h> #if defined(BOTAN_HAS_HKDF) #include <botan/hkdf.h> @@ -45,77 +45,176 @@ #include <botan/sp800_56c.h> #endif -#define BOTAN_REGISTER_KDF_NOARGS(type, name) \ - BOTAN_REGISTER_NAMED_T(KDF, name, type, (make_new_T<type>)) -#define BOTAN_REGISTER_KDF_1HASH(type, name) \ - BOTAN_REGISTER_NAMED_T(KDF, name, type, (make_new_T_1X<type, HashFunction>)) - -#define BOTAN_REGISTER_KDF_NAMED_1STR(type, name) \ - BOTAN_REGISTER_NAMED_T(KDF, name, type, (make_new_T_1str_req<type>)) - namespace Botan { -KDF::~KDF() {} +namespace { -std::unique_ptr<KDF> KDF::create(const std::string& algo_spec, - const std::string& provider) +template<typename KDF_Type> +std::unique_ptr<KDF> +kdf_create_mac_or_hash(const std::string& nm) { - return std::unique_ptr<KDF>(make_a<KDF>(Botan::KDF::Spec(algo_spec), provider)); - } + if(auto mac = MessageAuthenticationCode::create(nm)) + return std::unique_ptr<KDF>(new KDF_Type(mac.release())); -std::vector<std::string> KDF::providers(const std::string& algo_spec) - { - return providers_of<KDF>(KDF::Spec(algo_spec)); - } + if(auto mac = MessageAuthenticationCode::create("HMAC(" + nm + ")")) + return std::unique_ptr<KDF>(new KDF_Type(mac.release())); -KDF* get_kdf(const std::string& algo_spec) - { - SCAN_Name request(algo_spec); + return nullptr; + } - if(request.algo_name() == "Raw") - return nullptr; // No KDF +} - auto kdf = KDF::create(algo_spec); - if(!kdf) - throw Algorithm_Not_Found(algo_spec); - return kdf.release(); - } +std::unique_ptr<KDF> KDF::create(const std::string& algo_spec, + const std::string& provider) + { + const SCAN_Name req(algo_spec); #if defined(BOTAN_HAS_HKDF) -BOTAN_REGISTER_NAMED_T(KDF, "HKDF", HKDF, HKDF::make); -#endif - -#if defined(BOTAN_HAS_KDF1) -BOTAN_REGISTER_KDF_1HASH(KDF1, "KDF1"); + if(req.algo_name() == "HKDF" && req.arg_count() == 1) + { + if(provider.empty() || provider == "base") + { + return kdf_create_mac_or_hash<HKDF>(req.arg(0)); + } + } #endif #if defined(BOTAN_HAS_KDF2) -BOTAN_REGISTER_KDF_1HASH(KDF2, "KDF2"); + if(req.algo_name() == "KDF2" && req.arg_count() == 1) + { + if(provider.empty() || provider == "base") + { + if(auto hash = HashFunction::create(req.arg(0))) + return std::unique_ptr<KDF>(new KDF2(hash.release())); + } + } #endif #if defined(BOTAN_HAS_KDF1_18033) -BOTAN_REGISTER_KDF_1HASH( KDF1_18033, "KDF1-18033" ); + if(req.algo_name() == "KDF1-18033" && req.arg_count() == 1) + { + if(provider.empty() || provider == "base") + { + if(auto hash = HashFunction::create(req.arg(0))) + return std::unique_ptr<KDF>(new KDF1_18033(hash.release())); + } + } +#endif + +#if defined(BOTAN_HAS_KDF1) + if(req.algo_name() == "KDF1" && req.arg_count() == 1) + { + if(provider.empty() || provider == "base") + { + if(auto hash = HashFunction::create(req.arg(0))) + return std::unique_ptr<KDF>(new KDF1(hash.release())); + } + } #endif #if defined(BOTAN_HAS_TLS_V10_PRF) -BOTAN_REGISTER_KDF_NOARGS(TLS_PRF, "TLS-PRF"); + if(req.algo_name() == "TLS-PRF" && req.arg_count() == 0) + { + if(provider.empty() || provider == "base") + { + return std::unique_ptr<KDF>(new TLS_PRF); + } + } #endif #if defined(BOTAN_HAS_TLS_V12_PRF) -BOTAN_REGISTER_NAMED_T(KDF, "TLS-12-PRF", TLS_12_PRF, TLS_12_PRF::make); + if(req.algo_name() == "TLS-12-PRF" && req.arg_count() == 1) + { + if(provider.empty() || provider == "base") + { + return kdf_create_mac_or_hash<TLS_12_PRF>(req.arg(0)); + } + } #endif #if defined(BOTAN_HAS_X942_PRF) -BOTAN_REGISTER_KDF_NAMED_1STR(X942_PRF, "X9.42-PRF"); + if(req.algo_name() == "X9.42-PRF" && req.arg_count() == 1) + { + if(provider.empty() || provider == "base") + { + return std::unique_ptr<KDF>(new X942_PRF(req.arg(0))); + } + } #endif #if defined(BOTAN_HAS_SP800_108) -BOTAN_REGISTER_NAMED_T(KDF, "SP800-108-Counter", SP800_108_Counter, SP800_108_Counter::make); -BOTAN_REGISTER_NAMED_T(KDF, "SP800-108-Feedback", SP800_108_Feedback, SP800_108_Feedback::make); -BOTAN_REGISTER_NAMED_T(KDF, "SP800-108-Pipeline", SP800_108_Pipeline, SP800_108_Pipeline::make); + if(req.algo_name() == "SP800-108-Counter" && req.arg_count() == 1) + { + if(provider.empty() || provider == "base") + { + return kdf_create_mac_or_hash<SP800_108_Counter>(req.arg(0)); + } + } + + if(req.algo_name() == "SP800-108-Feedback" && req.arg_count() == 1) + { + if(provider.empty() || provider == "base") + { + return kdf_create_mac_or_hash<SP800_108_Feedback>(req.arg(0)); + } + } + + if(req.algo_name() == "SP800-108-Pipeline" && req.arg_count() == 1) + { + if(provider.empty() || provider == "base") + { + return kdf_create_mac_or_hash<SP800_108_Pipeline>(req.arg(0)); + } + } #endif #if defined(BOTAN_HAS_SP800_56C) -BOTAN_REGISTER_NAMED_T(KDF, "SP800-56C", SP800_56C, SP800_56C::make); + if(req.algo_name() == "SP800-56C" && req.arg_count() == 1) + { + std::unique_ptr<KDF> exp(kdf_create_mac_or_hash<SP800_108_Feedback>(req.arg(0))); + if(exp) + { + if(auto mac = MessageAuthenticationCode::create(req.arg(0))) + return std::unique_ptr<KDF>(new SP800_56C(mac.release(), exp.release())); + + if(auto mac = MessageAuthenticationCode::create("HMAC(" + req.arg(0) + ")")) + return std::unique_ptr<KDF>(new SP800_56C(mac.release(), exp.release())); + } + } #endif + + return nullptr; + } + +//static +std::unique_ptr<KDF> +KDF::create_or_throw(const std::string& algo, + const std::string& provider) + { + if(auto bc = KDF::create(algo, provider)) + { + return bc; + } + throw Lookup_Error("Block cipher", algo, provider); + } + +std::vector<std::string> KDF::providers(const std::string& algo_spec) + { + return probe_providers_of<KDF>(algo_spec, { "base" }); + } + +KDF* get_kdf(const std::string& algo_spec) + { + SCAN_Name request(algo_spec); + + if(request.algo_name() == "Raw") + return nullptr; // No KDF + + //return KDF::create_or_throw(algo_spec).release(); + auto kdf = KDF::create(algo_spec); + if(!kdf) + throw Algorithm_Not_Found(algo_spec); + return kdf.release(); + } + } diff --git a/src/lib/kdf/kdf.h b/src/lib/kdf/kdf.h index f9acb9d38..ab793da87 100644 --- a/src/lib/kdf/kdf.h +++ b/src/lib/kdf/kdf.h @@ -8,7 +8,6 @@ #ifndef BOTAN_KDF_BASE_H__ #define BOTAN_KDF_BASE_H__ -#include <botan/scan_name.h> #include <botan/secmem.h> #include <botan/types.h> #include <string> @@ -21,7 +20,7 @@ namespace Botan { class BOTAN_DLL KDF { public: - virtual ~KDF(); + virtual ~KDF() {} /** * Create an instance based on a name @@ -30,8 +29,18 @@ class BOTAN_DLL KDF * @param provider provider implementation to choose * @return a null pointer if the algo/provider combination cannot be found */ - static std::unique_ptr<KDF> create(const std::string& algo_spec, - const std::string& provider = ""); + static std::unique_ptr<KDF> + create(const std::string& algo_spec, + const std::string& provider = ""); + + /** + * Create an instance based on a name, or throw if the + * algo/provider combination cannot be found. If provider is + * empty then best available is chosen. + */ + static std::unique_ptr<KDF> + create_or_throw(const std::string& algo_spec, + const std::string& provider = ""); /** * @return list of available providers for this algorithm, empty if not available @@ -173,8 +182,11 @@ class BOTAN_DLL KDF * @return new object representing the same algorithm as *this */ virtual KDF* clone() const = 0; +<<<<<<< HEAD typedef SCAN_Name Spec; +======= +>>>>>>> 8978841... Remove Algo_Registry }; /** diff --git a/src/lib/kdf/prf_tls/prf_tls.cpp b/src/lib/kdf/prf_tls/prf_tls.cpp index 14b330901..e83d07692 100644 --- a/src/lib/kdf/prf_tls/prf_tls.cpp +++ b/src/lib/kdf/prf_tls/prf_tls.cpp @@ -10,17 +10,6 @@ namespace Botan { -TLS_12_PRF* TLS_12_PRF::make(const Spec& spec) - { - if(auto mac = MessageAuthenticationCode::create(spec.arg(0))) - return new TLS_12_PRF(mac.release()); - - if(auto mac = MessageAuthenticationCode::create("HMAC(" + spec.arg(0) + ")")) - return new TLS_12_PRF(mac.release()); - - return nullptr; - } - TLS_PRF::TLS_PRF() : m_hmac_md5(MessageAuthenticationCode::create("HMAC(MD5)")), m_hmac_sha1(MessageAuthenticationCode::create("HMAC(SHA-1)")) diff --git a/src/lib/kdf/prf_tls/prf_tls.h b/src/lib/kdf/prf_tls/prf_tls.h index 58cd5758e..64891144a 100644 --- a/src/lib/kdf/prf_tls/prf_tls.h +++ b/src/lib/kdf/prf_tls/prf_tls.h @@ -53,8 +53,6 @@ class BOTAN_DLL TLS_12_PRF final : public KDF * @param mac MAC algorithm to use */ explicit TLS_12_PRF(MessageAuthenticationCode* mac) : m_mac(mac) {} - - static TLS_12_PRF* make(const Spec& spec); private: std::unique_ptr<MessageAuthenticationCode> m_mac; }; diff --git a/src/lib/kdf/sp800_108/sp800_108.cpp b/src/lib/kdf/sp800_108/sp800_108.cpp index aafb349b2..77973600a 100644 --- a/src/lib/kdf/sp800_108/sp800_108.cpp +++ b/src/lib/kdf/sp800_108/sp800_108.cpp @@ -12,17 +12,6 @@ namespace Botan { -SP800_108_Counter* SP800_108_Counter::make(const Spec& spec) - { - if(auto mac = MessageAuthenticationCode::create(spec.arg(0))) - return new SP800_108_Counter(mac.release()); - - if(auto mac = MessageAuthenticationCode::create("HMAC(" + spec.arg(0) + ")")) - return new SP800_108_Counter(mac.release()); - - return nullptr; - } - size_t SP800_108_Counter::kdf(byte key[], size_t key_len, const byte secret[], size_t secret_len, const byte salt[], size_t salt_len, @@ -65,17 +54,6 @@ size_t SP800_108_Counter::kdf(byte key[], size_t key_len, return key_len; } -SP800_108_Feedback* SP800_108_Feedback::make(const Spec& spec) - { - if(auto mac = MessageAuthenticationCode::create(spec.arg(0))) - return new SP800_108_Feedback(mac.release()); - - if(auto mac = MessageAuthenticationCode::create("HMAC(" + spec.arg(0) + ")")) - return new SP800_108_Feedback(mac.release()); - - return nullptr; - } - size_t SP800_108_Feedback::kdf(byte key[], size_t key_len, const byte secret[], size_t secret_len, const byte salt[], size_t salt_len, @@ -122,17 +100,6 @@ size_t SP800_108_Feedback::kdf(byte key[], size_t key_len, return key_len; } -SP800_108_Pipeline* SP800_108_Pipeline::make(const Spec& spec) - { - if(auto mac = MessageAuthenticationCode::create(spec.arg(0))) - return new SP800_108_Pipeline(mac.release()); - - if(auto mac = MessageAuthenticationCode::create("HMAC(" + spec.arg(0) + ")")) - return new SP800_108_Pipeline(mac.release()); - - return nullptr; - } - size_t SP800_108_Pipeline::kdf(byte key[], size_t key_len, const byte secret[], size_t secret_len, const byte salt[], size_t salt_len, diff --git a/src/lib/kdf/sp800_108/sp800_108.h b/src/lib/kdf/sp800_108/sp800_108.h index 2d4d028b2..e368457b4 100644 --- a/src/lib/kdf/sp800_108/sp800_108.h +++ b/src/lib/kdf/sp800_108/sp800_108.h @@ -49,8 +49,6 @@ class BOTAN_DLL SP800_108_Counter : public KDF * @param mac MAC algorithm to use */ SP800_108_Counter(MessageAuthenticationCode* mac) : m_prf(mac) {} - - static SP800_108_Counter* make(const Spec& spec); private: std::unique_ptr<MessageAuthenticationCode> m_prf; }; @@ -88,8 +86,6 @@ class BOTAN_DLL SP800_108_Feedback : public KDF const byte label[], size_t label_len) const override; SP800_108_Feedback(MessageAuthenticationCode* mac) : m_prf(mac) {} - - static SP800_108_Feedback* make(const Spec& spec); private: std::unique_ptr<MessageAuthenticationCode> m_prf; }; @@ -128,7 +124,6 @@ class BOTAN_DLL SP800_108_Pipeline : public KDF SP800_108_Pipeline(MessageAuthenticationCode* mac) : m_prf(mac) {} - static SP800_108_Pipeline* make(const Spec& spec); private: std::unique_ptr<MessageAuthenticationCode> m_prf; }; diff --git a/src/lib/kdf/sp800_56c/sp800_56c.cpp b/src/lib/kdf/sp800_56c/sp800_56c.cpp index 338feba2a..f6d01ec2f 100644 --- a/src/lib/kdf/sp800_56c/sp800_56c.cpp +++ b/src/lib/kdf/sp800_56c/sp800_56c.cpp @@ -11,20 +11,6 @@ namespace Botan { -SP800_56C* SP800_56C::make(const Spec& spec) - { - if(auto exp = SP800_108_Feedback::make(spec)) - { - if(auto mac = MessageAuthenticationCode::create(spec.arg(0))) - return new SP800_56C(mac.release(), exp); - - if(auto mac = MessageAuthenticationCode::create("HMAC(" + spec.arg(0) + ")")) - return new SP800_56C(mac.release(), exp); - } - - return nullptr; - } - size_t SP800_56C::kdf(byte key[], size_t key_len, const byte secret[], size_t secret_len, const byte salt[], size_t salt_len, diff --git a/src/lib/kdf/sp800_56c/sp800_56c.h b/src/lib/kdf/sp800_56c/sp800_56c.h index 83f11906a..5c5acb075 100644 --- a/src/lib/kdf/sp800_56c/sp800_56c.h +++ b/src/lib/kdf/sp800_56c/sp800_56c.h @@ -50,8 +50,6 @@ class BOTAN_DLL SP800_56C : public KDF * @param exp KDF used for key expansion */ SP800_56C(MessageAuthenticationCode* mac, KDF* exp) : m_prf(mac), m_exp(exp) {} - - static SP800_56C* make(const Spec& spec); private: std::unique_ptr<MessageAuthenticationCode> m_prf; std::unique_ptr<KDF> m_exp; diff --git a/src/lib/mac/cbc_mac/cbc_mac.cpp b/src/lib/mac/cbc_mac/cbc_mac.cpp index 449865255..741d550e5 100644 --- a/src/lib/mac/cbc_mac/cbc_mac.cpp +++ b/src/lib/mac/cbc_mac/cbc_mac.cpp @@ -9,16 +9,6 @@ namespace Botan { -CBC_MAC* CBC_MAC::make(const Spec& spec) - { - if(spec.arg_count() == 1) - { - if(auto bc = BlockCipher::create(spec.arg(0))) - return new CBC_MAC(bc.release()); - } - return nullptr; - } - /* * Update an CBC-MAC Calculation */ diff --git a/src/lib/mac/cbc_mac/cbc_mac.h b/src/lib/mac/cbc_mac/cbc_mac.h index 4a3dece95..dd4877d1c 100644 --- a/src/lib/mac/cbc_mac/cbc_mac.h +++ b/src/lib/mac/cbc_mac/cbc_mac.h @@ -33,8 +33,6 @@ class BOTAN_DLL CBC_MAC final : public MessageAuthenticationCode * @param cipher the block cipher to use */ explicit CBC_MAC(BlockCipher* cipher); - - static CBC_MAC* make(const Spec& spec); private: void add_data(const byte[], size_t) override; void final_result(byte[]) override; diff --git a/src/lib/mac/cmac/cmac.cpp b/src/lib/mac/cmac/cmac.cpp index 1501bc316..9afd86cdb 100644 --- a/src/lib/mac/cmac/cmac.cpp +++ b/src/lib/mac/cmac/cmac.cpp @@ -9,16 +9,6 @@ namespace Botan { -CMAC* CMAC::make(const Spec& spec) - { - if(spec.arg_count() == 1) - { - if(auto bc = BlockCipher::create(spec.arg(0))) - return new CMAC(bc.release()); - } - return nullptr; - } - /* * Perform CMAC's multiplication in GF(2^n) */ diff --git a/src/lib/mac/cmac/cmac.h b/src/lib/mac/cmac/cmac.h index fac754e62..6897665c0 100644 --- a/src/lib/mac/cmac/cmac.h +++ b/src/lib/mac/cmac/cmac.h @@ -41,8 +41,6 @@ class BOTAN_DLL CMAC final : public MessageAuthenticationCode */ explicit CMAC(BlockCipher* cipher); - static CMAC* make(const Spec& spec); - CMAC(const CMAC&) = delete; CMAC& operator=(const CMAC&) = delete; private: diff --git a/src/lib/mac/hmac/hmac.cpp b/src/lib/mac/hmac/hmac.cpp index f445ab0cf..a2021515f 100644 --- a/src/lib/mac/hmac/hmac.cpp +++ b/src/lib/mac/hmac/hmac.cpp @@ -10,16 +10,6 @@ namespace Botan { -HMAC* HMAC::make(const Spec& spec) - { - if(spec.arg_count() == 1) - { - if(auto h = HashFunction::create(spec.arg(0))) - return new HMAC(h.release()); - } - return nullptr; - } - /* * Update a HMAC Calculation */ diff --git a/src/lib/mac/hmac/hmac.h b/src/lib/mac/hmac/hmac.h index 654a167e7..bfb425fa8 100644 --- a/src/lib/mac/hmac/hmac.h +++ b/src/lib/mac/hmac/hmac.h @@ -36,8 +36,6 @@ class BOTAN_DLL HMAC final : public MessageAuthenticationCode */ explicit HMAC(HashFunction* hash); - static HMAC* make(const Spec& spec); - HMAC(const HMAC&) = delete; HMAC& operator=(const HMAC&) = delete; private: diff --git a/src/lib/mac/mac.cpp b/src/lib/mac/mac.cpp index a3917141d..919ce959d 100644 --- a/src/lib/mac/mac.cpp +++ b/src/lib/mac/mac.cpp @@ -6,7 +6,7 @@ */ #include <botan/mac.h> -#include <botan/internal/algo_registry.h> +#include <botan/scan_name.h> #include <botan/mem_ops.h> #if defined(BOTAN_HAS_CBC_MAC) @@ -35,18 +35,97 @@ namespace Botan { -std::unique_ptr<MessageAuthenticationCode> MessageAuthenticationCode::create(const std::string& algo_spec, - const std::string& provider) +std::unique_ptr<MessageAuthenticationCode> +MessageAuthenticationCode::create(const std::string& algo_spec, + const std::string& provider) { - return std::unique_ptr<MessageAuthenticationCode>(make_a<MessageAuthenticationCode>(MessageAuthenticationCode::Spec(algo_spec), provider)); + const SCAN_Name req(algo_spec); + +#if defined(BOTAN_HAS_HMAC) + if(req.algo_name() == "HMAC" && req.arg_count() == 1) + { + // TODO OpenSSL + if(provider.empty() || provider == "base") + { + if(auto h = HashFunction::create(req.arg(0))) + return std::unique_ptr<MessageAuthenticationCode>(new HMAC(h.release())); + } + } +#endif + +#if defined(BOTAN_HAS_POLY1305) + if(req.algo_name() == "Poly1305" && req.arg_count() == 0) + { + if(provider.empty() || provider == "base") + return std::unique_ptr<MessageAuthenticationCode>(new Poly1305); + } +#endif + +#if defined(BOTAN_HAS_SIPHASH) + if(req.algo_name() == "SipHash") + { + if(provider.empty() || provider == "base") + { + return std::unique_ptr<MessageAuthenticationCode>( + new SipHash(req.arg_as_integer(0, 2), + req.arg_as_integer(1, 4))); + } + } +#endif + +#if defined(BOTAN_HAS_CMAC) + if(req.algo_name() == "CMAC" && req.arg_count() == 1) + { + if(provider.empty() || provider == "base") + { + if(auto bc = BlockCipher::create(req.arg(0))) + return std::unique_ptr<MessageAuthenticationCode>(new CMAC(bc.release())); + } + } +#endif + + +#if defined(BOTAN_HAS_CBC_MAC) + if(req.algo_name() == "CBC-MAC" && req.arg_count() == 1) + { + if(provider.empty() || provider == "base") + { + if(auto bc = BlockCipher::create(req.arg(0))) + return std::unique_ptr<MessageAuthenticationCode>(new CBC_MAC(bc.release())); + } + } +#endif + +#if defined(BOTAN_HAS_ANSI_X919_MAC) + if(req.algo_name() == "X9.19-MAC") + { + if(provider.empty() || provider == "base") + { + return std::unique_ptr<MessageAuthenticationCode>(new ANSI_X919_MAC); + } + } +#endif + + return nullptr; } -std::vector<std::string> MessageAuthenticationCode::providers(const std::string& algo_spec) +std::vector<std::string> +MessageAuthenticationCode::providers(const std::string& algo_spec) { - return providers_of<MessageAuthenticationCode>(MessageAuthenticationCode::Spec(algo_spec)); + return probe_providers_of<MessageAuthenticationCode>(algo_spec, {"base", "openssl"}); } -MessageAuthenticationCode::~MessageAuthenticationCode() {} +//static +std::unique_ptr<MessageAuthenticationCode> +MessageAuthenticationCode::create_or_throw(const std::string& algo, + const std::string& provider) + { + if(auto mac = MessageAuthenticationCode::create(algo, provider)) + { + return mac; + } + throw Lookup_Error("MAC", algo, provider); + } /* * Default (deterministic) MAC verification operation @@ -61,28 +140,4 @@ bool MessageAuthenticationCode::verify_mac(const byte mac[], size_t length) return same_mem(our_mac.data(), mac, length); } -#if defined(BOTAN_HAS_CBC_MAC) -BOTAN_REGISTER_NAMED_T(MessageAuthenticationCode, "CBC-MAC", CBC_MAC, CBC_MAC::make); -#endif - -#if defined(BOTAN_HAS_CMAC) -BOTAN_REGISTER_NAMED_T(MessageAuthenticationCode, "CMAC", CMAC, CMAC::make); -#endif - -#if defined(BOTAN_HAS_HMAC) -BOTAN_REGISTER_NAMED_T(MessageAuthenticationCode, "HMAC", HMAC, HMAC::make); -#endif - -#if defined(BOTAN_HAS_POLY1305) -BOTAN_REGISTER_T_NOARGS(MessageAuthenticationCode, Poly1305); -#endif - -#if defined(BOTAN_HAS_SIPHASH) -BOTAN_REGISTER_NAMED_T_2LEN(MessageAuthenticationCode, SipHash, "SipHash", "base", 2, 4); -#endif - -#if defined(BOTAN_HAS_ANSI_X919_MAC) -BOTAN_REGISTER_NAMED_T(MessageAuthenticationCode, "X9.19-MAC", ANSI_X919_MAC, make_new_T<ANSI_X919_MAC>); -#endif - } diff --git a/src/lib/mac/mac.h b/src/lib/mac/mac.h index 69b7ea581..f3befc512 100644 --- a/src/lib/mac/mac.h +++ b/src/lib/mac/mac.h @@ -10,7 +10,6 @@ #include <botan/buf_comp.h> #include <botan/sym_algo.h> -#include <botan/scan_name.h> #include <string> namespace Botan { @@ -22,8 +21,6 @@ class BOTAN_DLL MessageAuthenticationCode : public Buffered_Computation, public SymmetricAlgorithm { public: - typedef SCAN_Name Spec; - /** * Create an instance based on a name * If provider is empty then best available is chosen. @@ -31,15 +28,27 @@ class BOTAN_DLL MessageAuthenticationCode : public Buffered_Computation, * @param provider provider implementation to use * @return a null pointer if the algo/provider combination cannot be found */ - static std::unique_ptr<MessageAuthenticationCode> create(const std::string& algo_spec, - const std::string& provider = ""); + static std::unique_ptr<MessageAuthenticationCode> + create(const std::string& algo_spec, + const std::string& provider = ""); + + /* + * Create an instance based on a name + * If provider is empty then best available is chosen. + * @param algo_spec algorithm name + * @param provider provider implementation to use + * Throws a Lookup_Error if algo/provider combination cannot be found + */ + static std::unique_ptr<MessageAuthenticationCode> + create_or_throw(const std::string& algo_spec, + const std::string& provider = ""); /** * @return list of available providers for this algorithm, empty if not available */ static std::vector<std::string> providers(const std::string& algo_spec); - virtual ~MessageAuthenticationCode(); + virtual ~MessageAuthenticationCode() {} /** * Verify a MAC. diff --git a/src/lib/modes/aead/aead.cpp b/src/lib/modes/aead/aead.cpp index 88e6cbeaa..033dad94e 100644 --- a/src/lib/modes/aead/aead.cpp +++ b/src/lib/modes/aead/aead.cpp @@ -5,8 +5,12 @@ */ #include <botan/aead.h> -#include <botan/internal/mode_utils.h> -#include <botan/internal/algo_registry.h> +#include <botan/scan_name.h> +#include <sstream> + +#if defined(BOTAN_HAS_BLOCK_CIPHER) + #include <botan/block_cipher.h> +#endif #if defined(BOTAN_HAS_AEAD_CCM) #include <botan/ccm.h> @@ -34,42 +38,107 @@ namespace Botan { -AEAD_Mode::~AEAD_Mode() {} +AEAD_Mode* get_aead(const std::string& algo, Cipher_Dir dir) + { +#if defined(BOTAN_HAS_AEAD_CHACHA20_POLY1305) + if(algo == "ChaCha20Poly1305") + { + if(dir == ENCRYPTION) + return new ChaCha20Poly1305_Encryption; + else + return new ChaCha20Poly1305_Decryption; -#if defined(BOTAN_HAS_AEAD_CCM) -BOTAN_REGISTER_BLOCK_CIPHER_MODE_LEN2(CCM_Encryption, CCM_Decryption, 16, 3); + } #endif -#if defined(BOTAN_HAS_AEAD_CHACHA20_POLY1305) -BOTAN_REGISTER_T_NOARGS(Cipher_Mode, ChaCha20Poly1305_Encryption); -BOTAN_REGISTER_T_NOARGS(Cipher_Mode, ChaCha20Poly1305_Decryption); -#endif + if(algo.find('/') != std::string::npos) + { + const std::vector<std::string> algo_parts = split_on(algo, '/'); + const std::string cipher_name = algo_parts[0]; + const std::vector<std::string> mode_info = parse_algorithm_name(algo_parts[1]); -#if defined(BOTAN_HAS_AEAD_EAX) -BOTAN_REGISTER_BLOCK_CIPHER_MODE_LEN(EAX_Encryption, EAX_Decryption, 0); + if(mode_info.empty()) + return nullptr; + + std::ostringstream alg_args; + + alg_args << '(' << cipher_name; + for(size_t i = 1; i < mode_info.size(); ++i) + alg_args << ',' << mode_info[i]; + for(size_t i = 2; i < algo_parts.size(); ++i) + alg_args << ',' << algo_parts[i]; + alg_args << ')'; + + const std::string mode_name = mode_info[0] + alg_args.str(); + return get_aead(mode_name, dir); + } + +#if defined(BOTAN_HAS_BLOCK_CIPHER) + + SCAN_Name req(algo); + std::unique_ptr<BlockCipher> bc(BlockCipher::create(req.arg(0))); + + if(!bc) + { + return nullptr; + } + +#if defined(BOTAN_HAS_AEAD_CCM) + if(req.algo_name() == "CCM") + { + size_t tag_len = req.arg_as_integer(1, 16); + size_t L_len = req.arg_as_integer(2, 3); + if(dir == ENCRYPTION) + return new CCM_Encryption(bc.release(), tag_len, L_len); + else + return new CCM_Decryption(bc.release(), tag_len, L_len); + } #endif #if defined(BOTAN_HAS_AEAD_GCM) -BOTAN_REGISTER_BLOCK_CIPHER_MODE_LEN(GCM_Encryption, GCM_Decryption, 16); + if(req.algo_name() == "GCM") + { + size_t tag_len = req.arg_as_integer(1, 16); + if(dir == ENCRYPTION) + return new GCM_Encryption(bc.release(), tag_len); + else + return new GCM_Decryption(bc.release(), tag_len); + } #endif #if defined(BOTAN_HAS_AEAD_OCB) -BOTAN_REGISTER_BLOCK_CIPHER_MODE_LEN(OCB_Encryption, OCB_Decryption, 16); + if(req.algo_name() == "OCB") + { + size_t tag_len = req.arg_as_integer(1, 16); + if(dir == ENCRYPTION) + return new OCB_Encryption(bc.release(), tag_len); + else + return new OCB_Decryption(bc.release(), tag_len); + } #endif -#if defined(BOTAN_HAS_AEAD_SIV) -BOTAN_REGISTER_BLOCK_CIPHER_MODE(SIV_Encryption, SIV_Decryption); +#if defined(BOTAN_HAS_AEAD_EAX) + if(req.algo_name() == "EAX") + { + size_t tag_len = req.arg_as_integer(1, bc->block_size()); + if(dir == ENCRYPTION) + return new EAX_Encryption(bc.release(), tag_len); + else + return new EAX_Decryption(bc.release(), tag_len); + } #endif -AEAD_Mode* get_aead(const std::string& algo_spec, Cipher_Dir direction) - { - std::unique_ptr<Cipher_Mode> mode(get_cipher_mode(algo_spec, direction)); - - if(AEAD_Mode* aead = dynamic_cast<AEAD_Mode*>(mode.get())) +#if defined(BOTAN_HAS_AEAD_SIV) + if(req.algo_name() == "SIV") { - mode.release(); - return aead; + if(dir == ENCRYPTION) + return new SIV_Encryption(bc.release()); + else + return new SIV_Decryption(bc.release()); } +#endif + +#endif return nullptr; } diff --git a/src/lib/modes/aead/aead.h b/src/lib/modes/aead/aead.h index 0769a1829..2cdc6137e 100644 --- a/src/lib/modes/aead/aead.h +++ b/src/lib/modes/aead/aead.h @@ -74,7 +74,7 @@ class BOTAN_DLL AEAD_Mode : public Cipher_Mode */ size_t default_nonce_length() const override { return 12; } - virtual ~AEAD_Mode(); + virtual ~AEAD_Mode() {} }; /** diff --git a/src/lib/modes/aead/ccm/ccm.cpp b/src/lib/modes/aead/ccm/ccm.cpp index d5559bfb5..81b9f4943 100644 --- a/src/lib/modes/aead/ccm/ccm.cpp +++ b/src/lib/modes/aead/ccm/ccm.cpp @@ -5,7 +5,6 @@ * Botan is released under the Simplified BSD License (see license.txt) */ -#include <botan/internal/mode_utils.h> #include <botan/ccm.h> #include <botan/parsing.h> diff --git a/src/lib/modes/aead/chacha20poly1305/chacha20poly1305.cpp b/src/lib/modes/aead/chacha20poly1305/chacha20poly1305.cpp index 04326dede..d2f16c225 100644 --- a/src/lib/modes/aead/chacha20poly1305/chacha20poly1305.cpp +++ b/src/lib/modes/aead/chacha20poly1305/chacha20poly1305.cpp @@ -6,7 +6,6 @@ */ #include <botan/chacha20poly1305.h> -#include <botan/internal/mode_utils.h> namespace Botan { diff --git a/src/lib/modes/aead/eax/eax.cpp b/src/lib/modes/aead/eax/eax.cpp index f26a1eae3..c76f15b48 100644 --- a/src/lib/modes/aead/eax/eax.cpp +++ b/src/lib/modes/aead/eax/eax.cpp @@ -5,7 +5,6 @@ * Botan is released under the Simplified BSD License (see license.txt) */ -#include <botan/internal/mode_utils.h> #include <botan/eax.h> #include <botan/cmac.h> #include <botan/ctr.h> diff --git a/src/lib/modes/aead/gcm/gcm.cpp b/src/lib/modes/aead/gcm/gcm.cpp index 32c6c0b70..a73e5ee5b 100644 --- a/src/lib/modes/aead/gcm/gcm.cpp +++ b/src/lib/modes/aead/gcm/gcm.cpp @@ -6,8 +6,8 @@ */ #include <botan/gcm.h> -#include <botan/internal/mode_utils.h> #include <botan/internal/ct_utils.h> +#include <botan/loadstor.h> #include <botan/ctr.h> #if defined(BOTAN_HAS_GCM_CLMUL) diff --git a/src/lib/modes/aead/ocb/ocb.cpp b/src/lib/modes/aead/ocb/ocb.cpp index e21749f3b..0ce2b6f00 100644 --- a/src/lib/modes/aead/ocb/ocb.cpp +++ b/src/lib/modes/aead/ocb/ocb.cpp @@ -5,9 +5,9 @@ * Botan is released under the Simplified BSD License (see license.txt) */ -#include <botan/internal/mode_utils.h> #include <botan/ocb.h> #include <botan/cmac.h> +#include <botan/internal/bit_ops.h> namespace Botan { diff --git a/src/lib/modes/aead/siv/siv.cpp b/src/lib/modes/aead/siv/siv.cpp index 5f8c13f7f..ce20f3ada 100644 --- a/src/lib/modes/aead/siv/siv.cpp +++ b/src/lib/modes/aead/siv/siv.cpp @@ -5,7 +5,6 @@ * Botan is released under the Simplified BSD License (see license.txt) */ -#include <botan/internal/mode_utils.h> #include <botan/siv.h> #include <botan/cmac.h> #include <botan/ctr.h> diff --git a/src/lib/modes/cbc/cbc.cpp b/src/lib/modes/cbc/cbc.cpp index 8066dae12..7e1fe4d0f 100644 --- a/src/lib/modes/cbc/cbc.cpp +++ b/src/lib/modes/cbc/cbc.cpp @@ -5,9 +5,9 @@ * Botan is released under the Simplified BSD License (see license.txt) */ -#include <botan/internal/mode_utils.h> #include <botan/cbc.h> #include <botan/mode_pad.h> +#include <botan/internal/rounding.h> namespace Botan { diff --git a/src/lib/modes/cfb/cfb.cpp b/src/lib/modes/cfb/cfb.cpp index cc5e9bae7..793bfaf46 100644 --- a/src/lib/modes/cfb/cfb.cpp +++ b/src/lib/modes/cfb/cfb.cpp @@ -5,7 +5,6 @@ * Botan is released under the Simplified BSD License (see license.txt) */ -#include <botan/internal/mode_utils.h> #include <botan/cfb.h> #include <botan/parsing.h> diff --git a/src/lib/modes/cipher_mode.cpp b/src/lib/modes/cipher_mode.cpp index e7040772c..df2944323 100644 --- a/src/lib/modes/cipher_mode.cpp +++ b/src/lib/modes/cipher_mode.cpp @@ -7,10 +7,17 @@ #include <botan/cipher_mode.h> #include <botan/stream_mode.h> -#include <botan/internal/mode_utils.h> -#include <botan/internal/algo_registry.h> +#include <botan/scan_name.h> #include <sstream> +#if defined(BOTAN_HAS_BLOCK_CIPHER) + #include <botan/block_cipher.h> +#endif + +#if defined(BOTAN_HAS_AEAD_MODES) + #include <botan/aead.h> +#endif + #if defined(BOTAN_HAS_MODE_ECB) #include <botan/ecb.h> #endif @@ -27,126 +34,121 @@ #include <botan/xts.h> #endif -namespace Botan { - -#define BOTAN_REGISTER_CIPHER_MODE(name, maker) BOTAN_REGISTER_T(Cipher_Mode, name, maker) -#define BOTAN_REGISTER_CIPHER_MODE_NOARGS(name) BOTAN_REGISTER_T_NOARGS(Cipher_Mode, name) - -#if defined(BOTAN_HAS_MODE_ECB) - -template<typename T> -Cipher_Mode* make_ecb_mode(const Cipher_Mode::Spec& spec) - { - std::unique_ptr<BlockCipher> bc(BlockCipher::create(spec.arg(0))); - std::unique_ptr<BlockCipherModePaddingMethod> pad(get_bc_pad(spec.arg(1, "NoPadding"))); - if(bc && pad) - return new T(bc.release(), pad.release()); - return nullptr; - } - -BOTAN_REGISTER_CIPHER_MODE(ECB_Encryption, make_ecb_mode<ECB_Encryption>); -BOTAN_REGISTER_CIPHER_MODE(ECB_Decryption, make_ecb_mode<ECB_Decryption>); +#if defined(BOTAN_HAS_MODE_XTS) + #include <botan/xts.h> #endif -#if defined(BOTAN_HAS_MODE_CBC) +namespace Botan { -template<typename CBC_T, typename CTS_T> -Cipher_Mode* make_cbc_mode(const Cipher_Mode::Spec& spec) +Cipher_Mode* get_cipher_mode(const std::string& algo, Cipher_Dir direction) { - std::unique_ptr<BlockCipher> bc(BlockCipher::create(spec.arg(0))); - - if(bc) + if(auto sc = StreamCipher::create(algo)) { - const std::string padding = spec.arg(1, "PKCS7"); - - if(padding == "CTS") - return new CTS_T(bc.release()); - else - return new CBC_T(bc.release(), get_bc_pad(padding)); + return new Stream_Cipher_Mode(sc.release()); } - return nullptr; - } - -BOTAN_REGISTER_CIPHER_MODE(CBC_Encryption, (make_cbc_mode<CBC_Encryption,CTS_Encryption>)); -BOTAN_REGISTER_CIPHER_MODE(CBC_Decryption, (make_cbc_mode<CBC_Decryption,CTS_Decryption>)); -#endif - -#if defined(BOTAN_HAS_MODE_CFB) -BOTAN_REGISTER_BLOCK_CIPHER_MODE_LEN(CFB_Encryption, CFB_Decryption, 0); -#endif - -#if defined(BOTAN_HAS_MODE_XTS) -BOTAN_REGISTER_BLOCK_CIPHER_MODE(XTS_Encryption, XTS_Decryption); +#if defined(BOTAN_HAS_AEAD_MODES) + if(auto aead = get_aead(algo, direction)) + { + return aead; + } #endif -Cipher_Mode* get_cipher_mode(const std::string& algo_spec, Cipher_Dir direction) - { - const std::string provider = ""; + if(algo.find('/') != std::string::npos) + { + const std::vector<std::string> algo_parts = split_on(algo, '/'); + const std::string cipher_name = algo_parts[0]; + const std::vector<std::string> mode_info = parse_algorithm_name(algo_parts[1]); - const char* dir_string = (direction == ENCRYPTION) ? "_Encryption" : "_Decryption"; + if(mode_info.empty()) + return nullptr; - Cipher_Mode::Spec spec(algo_spec, dir_string); + std::ostringstream alg_args; - std::unique_ptr<Cipher_Mode> cipher_mode( - Algo_Registry<Cipher_Mode>::global_registry().make( - Cipher_Mode::Spec(algo_spec, dir_string), - provider) - ); + alg_args << '(' << cipher_name; + for(size_t i = 1; i < mode_info.size(); ++i) + alg_args << ',' << mode_info[i]; + for(size_t i = 2; i < algo_parts.size(); ++i) + alg_args << ',' << algo_parts[i]; + alg_args << ')'; - if(cipher_mode) - { - return cipher_mode.release(); + const std::string mode_name = mode_info[0] + alg_args.str(); + return get_cipher_mode(mode_name, direction); } - const std::vector<std::string> algo_parts = split_on(algo_spec, '/'); - if(algo_parts.size() < 2) - return nullptr; +#if defined(BOTAN_HAS_BLOCK_CIPHER) - const std::string cipher_name = algo_parts[0]; - const std::vector<std::string> mode_info = parse_algorithm_name(algo_parts[1]); + SCAN_Name spec(algo); + std::unique_ptr<BlockCipher> bc(BlockCipher::create(spec.arg(0))); - if(mode_info.empty()) + if(!bc) + { return nullptr; + } - std::ostringstream alg_args; - - alg_args << '(' << cipher_name; - for(size_t i = 1; i < mode_info.size(); ++i) - alg_args << ',' << mode_info[i]; - for(size_t i = 2; i < algo_parts.size(); ++i) - alg_args << ',' << algo_parts[i]; - alg_args << ')'; - - const std::string mode_name = mode_info[0] + alg_args.str(); - const std::string mode_name_directional = mode_info[0] + dir_string + alg_args.str(); +#if defined(BOTAN_HAS_MODE_CBC) + if(spec.algo_name() == "CBC") + { + const std::string padding = spec.arg(1, "PKCS7"); - cipher_mode.reset( - Algo_Registry<Cipher_Mode>::global_registry().make( - Cipher_Mode::Spec(mode_name_directional), - provider) - ); + if(padding == "CTS") + { + if(direction == ENCRYPTION) + return new CTS_Encryption(bc.release()); + else + return new CTS_Decryption(bc.release()); + } + else + { + std::unique_ptr<BlockCipherModePaddingMethod> pad(get_bc_pad(padding)); + + if(pad) + { + if(direction == ENCRYPTION) + return new CBC_Encryption(bc.release(), pad.release()); + else + return new CBC_Decryption(bc.release(), pad.release()); + } + } + } +#endif - if(cipher_mode) +#if defined(BOTAN_HAS_MODE_XTS) + if(spec.algo_name() == "XTS") { - return cipher_mode.release(); + if(direction == ENCRYPTION) + return new XTS_Encryption(bc.release()); + else + return new XTS_Decryption(bc.release()); } +#endif - cipher_mode.reset( - Algo_Registry<Cipher_Mode>::global_registry().make( - Cipher_Mode::Spec(mode_name), - provider) - ); - - if(cipher_mode) +#if defined(BOTAN_HAS_MODE_CFB) + if(spec.algo_name() == "CFB") { - return cipher_mode.release(); + const size_t feedback_bits = spec.arg_as_integer(1, 8*bc->block_size()); + if(direction == ENCRYPTION) + return new CFB_Encryption(bc.release(), feedback_bits); + else + return new CFB_Decryption(bc.release(), feedback_bits); } +#endif - if(auto sc = StreamCipher::create(mode_name, provider)) +#if defined(BOTAN_HAS_MODE_ECB) + if(spec.algo_name() == "ECB") { - return new Stream_Cipher_Mode(sc.release()); + std::unique_ptr<BlockCipherModePaddingMethod> pad(get_bc_pad(spec.arg(1, "NoPadding"))); + if(pad) + { + if(direction == ENCRYPTION) + return new ECB_Encryption(bc.release(), pad.release()); + else + return new ECB_Decryption(bc.release(), pad.release()); + } } +#endif + +#endif return nullptr; } diff --git a/src/lib/modes/cipher_mode.h b/src/lib/modes/cipher_mode.h index f08989a9e..7c0f8fc57 100644 --- a/src/lib/modes/cipher_mode.h +++ b/src/lib/modes/cipher_mode.h @@ -12,7 +12,6 @@ #include <botan/key_spec.h> #include <botan/exceptn.h> #include <botan/symkey.h> -#include <botan/scan_name.h> #include <string> #include <vector> @@ -24,8 +23,6 @@ namespace Botan { class BOTAN_DLL Cipher_Mode { public: - typedef SCAN_Name Spec; - virtual ~Cipher_Mode() {} /* diff --git a/src/lib/modes/ecb/ecb.cpp b/src/lib/modes/ecb/ecb.cpp index 650cfedf1..b39682fdf 100644 --- a/src/lib/modes/ecb/ecb.cpp +++ b/src/lib/modes/ecb/ecb.cpp @@ -5,8 +5,8 @@ * Botan is released under the Simplified BSD License (see license.txt) */ -#include <botan/internal/mode_utils.h> #include <botan/ecb.h> +#include <botan/internal/rounding.h> namespace Botan { diff --git a/src/lib/modes/info.txt b/src/lib/modes/info.txt index 24508ecaa..1e50e7de5 100644 --- a/src/lib/modes/info.txt +++ b/src/lib/modes/info.txt @@ -4,7 +4,3 @@ define MODES 20150626 cipher_mode.h stream_mode.h </header:public> - -<header:internal> -mode_utils.h -</header:internal> diff --git a/src/lib/modes/mode_utils.h b/src/lib/modes/mode_utils.h deleted file mode 100644 index 3e4b7370b..000000000 --- a/src/lib/modes/mode_utils.h +++ /dev/null @@ -1,67 +0,0 @@ -/* -* Helper include for mode implementations -* (C) 2015 Jack Lloyd -* -* Botan is released under the Simplified BSD License (see license.txt) -*/ - -#ifndef BOTAN_MODE_UTILS_H__ -#define BOTAN_MODE_UTILS_H__ - -#include <botan/cipher_mode.h> -#include <botan/block_cipher.h> -#include <botan/loadstor.h> -#include <botan/internal/rounding.h> -#include <botan/internal/bit_ops.h> -#include <algorithm> - -namespace Botan { - -template<typename T> -T* make_block_cipher_mode(const Cipher_Mode::Spec& spec) - { - if(std::unique_ptr<BlockCipher> bc = BlockCipher::create(spec.arg(0))) - return new T(bc.release()); - return nullptr; - } - -template<typename T, size_t LEN1> -T* make_block_cipher_mode_len(const Cipher_Mode::Spec& spec) - { - if(std::unique_ptr<BlockCipher> bc = BlockCipher::create(spec.arg(0))) - { - const size_t len1 = spec.arg_as_integer(1, LEN1); - return new T(bc.release(), len1); - } - - return nullptr; - } - -template<typename T, size_t LEN1, size_t LEN2> -T* make_block_cipher_mode_len2(const Cipher_Mode::Spec& spec) - { - if(std::unique_ptr<BlockCipher> bc = BlockCipher::create(spec.arg(0))) - { - const size_t len1 = spec.arg_as_integer(1, LEN1); - const size_t len2 = spec.arg_as_integer(2, LEN2); - return new T(bc.release(), len1, len2); - } - - return nullptr; - } - -#define BOTAN_REGISTER_BLOCK_CIPHER_MODE(E, D) \ - BOTAN_REGISTER_NAMED_T(Cipher_Mode, #E, E, make_block_cipher_mode<E>); \ - BOTAN_REGISTER_NAMED_T(Cipher_Mode, #D, D, make_block_cipher_mode<D>) - -#define BOTAN_REGISTER_BLOCK_CIPHER_MODE_LEN(E, D, LEN) \ - BOTAN_REGISTER_NAMED_T(Cipher_Mode, #E, E, (make_block_cipher_mode_len<E, LEN>)); \ - BOTAN_REGISTER_NAMED_T(Cipher_Mode, #D, D, (make_block_cipher_mode_len<D, LEN>)) - -#define BOTAN_REGISTER_BLOCK_CIPHER_MODE_LEN2(E, D, LEN1, LEN2) \ - BOTAN_REGISTER_NAMED_T(Cipher_Mode, #E, E, (make_block_cipher_mode_len2<E, LEN1, LEN2>)); \ - BOTAN_REGISTER_NAMED_T(Cipher_Mode, #D, D, (make_block_cipher_mode_len2<D, LEN1, LEN2>)) - -} - -#endif diff --git a/src/lib/modes/xts/xts.cpp b/src/lib/modes/xts/xts.cpp index 1993bf15f..4b697ae6c 100644 --- a/src/lib/modes/xts/xts.cpp +++ b/src/lib/modes/xts/xts.cpp @@ -5,8 +5,8 @@ * Botan is released under the Simplified BSD License (see license.txt) */ -#include <botan/internal/mode_utils.h> #include <botan/xts.h> +#include <botan/loadstor.h> namespace Botan { diff --git a/src/lib/pbkdf/pbkdf.cpp b/src/lib/pbkdf/pbkdf.cpp index 01f52853a..a3485654b 100644 --- a/src/lib/pbkdf/pbkdf.cpp +++ b/src/lib/pbkdf/pbkdf.cpp @@ -6,7 +6,7 @@ */ #include <botan/pbkdf.h> -#include <botan/internal/algo_registry.h> +#include <botan/scan_name.h> #if defined(BOTAN_HAS_PBKDF1) #include <botan/pbkdf1.h> @@ -18,28 +18,46 @@ namespace Botan { -#define BOTAN_REGISTER_PBKDF_1HASH(type, name) \ - BOTAN_REGISTER_NAMED_T(PBKDF, name, type, (make_new_T_1X<type, HashFunction>)) +PBKDF::~PBKDF() {} -#if defined(BOTAN_HAS_PBKDF1) -BOTAN_REGISTER_PBKDF_1HASH(PKCS5_PBKDF1, "PBKDF1"); -#endif +std::unique_ptr<PBKDF> PBKDF::create(const std::string& algo_spec, + const std::string& provider) + { + const SCAN_Name req(algo_spec); #if defined(BOTAN_HAS_PBKDF2) -BOTAN_REGISTER_NAMED_T(PBKDF, "PBKDF2", PKCS5_PBKDF2, PKCS5_PBKDF2::make); + if(req.algo_name() == "PBKDF2") + { + // TODO OpenSSL + + if(provider.empty() || provider == "base") + { + if(auto mac = MessageAuthenticationCode::create(req.arg(0))) + return std::unique_ptr<PBKDF>(new PKCS5_PBKDF2(mac.release())); + + if(auto mac = MessageAuthenticationCode::create("HMAC(" + req.arg(0) + ")")) + return std::unique_ptr<PBKDF>(new PKCS5_PBKDF2(mac.release())); + } + + return nullptr; + } #endif -PBKDF::~PBKDF() {} +#if defined(BOTAN_HAS_PBKDF1) + if(req.algo_name() == "PBKDF1" && req.arg_count() == 1) + { + if(auto hash = HashFunction::create(req.arg(0))) + return std::unique_ptr<PBKDF>(new PKCS5_PBKDF1(hash.release())); -std::unique_ptr<PBKDF> PBKDF::create(const std::string& algo_spec, - const std::string& provider) - { - return std::unique_ptr<PBKDF>(make_a<PBKDF>(Botan::PBKDF::Spec(algo_spec), provider)); + } +#endif + + return nullptr; } std::vector<std::string> PBKDF::providers(const std::string& algo_spec) { - return providers_of<PBKDF>(PBKDF::Spec(algo_spec)); + return probe_providers_of<PBKDF>(algo_spec, { "base", "openssl" }); } void PBKDF::pbkdf_timed(byte out[], size_t out_len, diff --git a/src/lib/pbkdf/pbkdf.h b/src/lib/pbkdf/pbkdf.h index 63a8a82f0..3abac0896 100644 --- a/src/lib/pbkdf/pbkdf.h +++ b/src/lib/pbkdf/pbkdf.h @@ -9,8 +9,6 @@ #define BOTAN_PBKDF_H__ #include <botan/symkey.h> -#include <botan/scan_name.h> -#include <botan/scan_name.h> #include <botan/exceptn.h> #include <chrono> @@ -39,8 +37,6 @@ class BOTAN_DLL PBKDF */ static std::vector<std::string> providers(const std::string& algo_spec); - typedef SCAN_Name Spec; - /** * @return new instance of this same algorithm */ diff --git a/src/lib/pbkdf/pbkdf2/pbkdf2.cpp b/src/lib/pbkdf/pbkdf2/pbkdf2.cpp index 5a8f529c6..0041fd537 100644 --- a/src/lib/pbkdf/pbkdf2/pbkdf2.cpp +++ b/src/lib/pbkdf/pbkdf2/pbkdf2.cpp @@ -11,17 +11,6 @@ namespace Botan { -PKCS5_PBKDF2* PKCS5_PBKDF2::make(const Spec& spec) - { - if(auto mac = MessageAuthenticationCode::create(spec.arg(0))) - return new PKCS5_PBKDF2(mac.release()); - - if(auto mac = MessageAuthenticationCode::create("HMAC(" + spec.arg(0) + ")")) - return new PKCS5_PBKDF2(mac.release()); - - return nullptr; - } - size_t pbkdf2(MessageAuthenticationCode& prf, byte out[], diff --git a/src/lib/pbkdf/pbkdf2/pbkdf2.h b/src/lib/pbkdf/pbkdf2/pbkdf2.h index 4f77f338b..36a3c640a 100644 --- a/src/lib/pbkdf/pbkdf2/pbkdf2.h +++ b/src/lib/pbkdf/pbkdf2/pbkdf2.h @@ -49,8 +49,6 @@ class BOTAN_DLL PKCS5_PBKDF2 final : public PBKDF * @param mac_fn the MAC object to use as PRF */ explicit PKCS5_PBKDF2(MessageAuthenticationCode* mac_fn) : m_mac(mac_fn) {} - - static PKCS5_PBKDF2* make(const Spec& spec); private: std::unique_ptr<MessageAuthenticationCode> m_mac; }; diff --git a/src/lib/pk_pad/eme.cpp b/src/lib/pk_pad/eme.cpp index b36ed6e67..fa569d8e4 100644 --- a/src/lib/pk_pad/eme.cpp +++ b/src/lib/pk_pad/eme.cpp @@ -6,7 +6,7 @@ */ #include <botan/eme.h> -#include <botan/internal/algo_registry.h> +#include <botan/scan_name.h> #if defined(BOTAN_HAS_EME_OAEP) #include <botan/oaep.h> @@ -22,34 +22,32 @@ namespace Botan { -#define BOTAN_REGISTER_EME(name, maker) BOTAN_REGISTER_T(EME, name, maker) -#define BOTAN_REGISTER_EME_NOARGS(name) BOTAN_REGISTER_T_NOARGS(EME, name) - -#define BOTAN_REGISTER_EME_NAMED_NOARGS(type, name) \ - BOTAN_REGISTER_NAMED_T(EME, name, type, make_new_T<type>) +EME* get_eme(const std::string& algo_spec) + { + SCAN_Name req(algo_spec); #if defined(BOTAN_HAS_EME_OAEP) -BOTAN_REGISTER_NAMED_T(EME, "OAEP", OAEP, OAEP::make); + if(req.algo_name() == "OAEP" && req.arg_count_between(1, 2)) + { + if(req.arg_count() == 1 || + (req.arg_count() == 2 && req.arg(1) == "MGF1")) + { + if(auto hash = HashFunction::create(req.arg(0))) + return new OAEP(hash.release()); + } + } #endif #if defined(BOTAN_HAS_EME_PKCS1v15) -BOTAN_REGISTER_EME_NAMED_NOARGS(EME_PKCS1v15, "PKCS1v15"); + if(req.algo_name() == "PKCS1v15" && req.arg_count() == 0) + return new EME_PKCS1v15; #endif #if defined(BOTAN_HAS_EME_RAW) -BOTAN_REGISTER_EME_NAMED_NOARGS(EME_Raw, "Raw"); + if(req.algo_name() == "Raw" && req.arg_count() == 0) + return new EME_Raw; #endif -EME* get_eme(const std::string& algo_spec) - { - SCAN_Name request(algo_spec); - - if(EME* eme = make_a<EME>(Botan::EME::Spec(algo_spec))) - return eme; - - if(request.algo_name() == "Raw") - return nullptr; // No padding - throw Algorithm_Not_Found(algo_spec); } diff --git a/src/lib/pk_pad/eme.h b/src/lib/pk_pad/eme.h index 9c72cb023..a5ad27b4e 100644 --- a/src/lib/pk_pad/eme.h +++ b/src/lib/pk_pad/eme.h @@ -8,7 +8,6 @@ #ifndef BOTAN_PUBKEY_EME_ENCRYPTION_PAD_H__ #define BOTAN_PUBKEY_EME_ENCRYPTION_PAD_H__ -#include <botan/scan_name.h> #include <botan/secmem.h> #include <botan/rng.h> @@ -20,8 +19,6 @@ namespace Botan { class BOTAN_DLL EME { public: - typedef SCAN_Name Spec; - virtual ~EME() = default; /** diff --git a/src/lib/pk_pad/eme_oaep/oaep.cpp b/src/lib/pk_pad/eme_oaep/oaep.cpp index 1ae1068a7..81d41afea 100644 --- a/src/lib/pk_pad/eme_oaep/oaep.cpp +++ b/src/lib/pk_pad/eme_oaep/oaep.cpp @@ -11,21 +11,6 @@ namespace Botan { -OAEP* OAEP::make(const Spec& request) - { - if(request.algo_name() == "OAEP" && request.arg_count_between(1, 2)) - { - if(request.arg_count() == 1 || - (request.arg_count() == 2 && request.arg(1) == "MGF1")) - { - if(auto hash = HashFunction::create(request.arg(0))) - return new OAEP(hash.release()); - } - } - - return nullptr; - } - /* * OAEP Pad Operation */ diff --git a/src/lib/pk_pad/eme_oaep/oaep.h b/src/lib/pk_pad/eme_oaep/oaep.h index 2a0f0f28c..3e476f6a3 100644 --- a/src/lib/pk_pad/eme_oaep/oaep.h +++ b/src/lib/pk_pad/eme_oaep/oaep.h @@ -21,8 +21,6 @@ class BOTAN_DLL OAEP final : public EME public: size_t maximum_input_size(size_t) const override; - static OAEP* make(const Spec& spec); - /** * @param hash function to use for hashing (takes ownership) * @param P an optional label. Normally empty. diff --git a/src/lib/pk_pad/emsa.cpp b/src/lib/pk_pad/emsa.cpp index 4d4b96ad1..c091319e2 100644 --- a/src/lib/pk_pad/emsa.cpp +++ b/src/lib/pk_pad/emsa.cpp @@ -5,7 +5,7 @@ */ #include <botan/emsa.h> -#include <botan/internal/algo_registry.h> +#include <botan/scan_name.h> #if defined(BOTAN_HAS_EMSA1) #include <botan/emsa1.h> @@ -33,10 +33,63 @@ EMSA::~EMSA() {} EMSA* get_emsa(const std::string& algo_spec) { - SCAN_Name request(algo_spec); + SCAN_Name req(algo_spec); - if(EMSA* emsa = make_a<EMSA>(Botan::EMSA::Spec(algo_spec))) - return emsa; +#if defined(BOTAN_HAS_EMSA1) + if(req.algo_name() == "EMSA1" && req.arg_count() == 1) + { + if(auto hash = HashFunction::create(req.arg(0))) + return new EMSA1(hash.release()); + } +#endif + +#if defined(BOTAN_HAS_EMSA_PKCS1) + if(req.algo_name() == "EMSA_PKCS1" && req.arg_count() == 1) + { + if(req.arg(0) == "Raw") + { + return new EMSA_PKCS1v15_Raw; + } + else + { + if(auto hash = HashFunction::create(req.arg(0))) + { + return new EMSA_PKCS1v15(hash.release()); + } + } + } +#endif + +#if defined(BOTAN_HAS_EMSA_PSSR) + if(req.algo_name() == "PSSR") + { + if(req.arg(1, "MGF1") != "MGF1") + return nullptr; // not supported + + if(auto h = HashFunction::create(req.arg(0))) + { + const size_t salt_size = req.arg_as_integer(2, h->output_length()); + return new PSSR(h.release(), salt_size); + } + } +#endif + +#if defined(BOTAN_HAS_EMSA_X931) + if(req.algo_name() == "EMSA_X931" && req.arg_count() == 1) + { + if(auto hash = HashFunction::create(req.arg(0))) + { + return new EMSA_X931(hash.release()); + } + } +#endif + +#if defined(BOTAN_HAS_EMSA_RAW) + if(req.algo_name() == "Raw" && req.arg_count() == 0) + { + return new EMSA_Raw; + } +#endif throw Algorithm_Not_Found(algo_spec); } @@ -54,35 +107,6 @@ std::string hash_for_emsa(const std::string& algo_spec) return "SHA-512"; // safe default if nothing we understand } -#define BOTAN_REGISTER_EMSA_NAMED_NOARGS(type, name) \ - BOTAN_REGISTER_NAMED_T(EMSA, name, type, make_new_T<type>) - -#define BOTAN_REGISTER_EMSA(name, maker) BOTAN_REGISTER_T(EMSA, name, maker) -#define BOTAN_REGISTER_EMSA_NOARGS(name) BOTAN_REGISTER_T_NOARGS(EMSA, name) - -#define BOTAN_REGISTER_EMSA_1HASH(type, name) \ - BOTAN_REGISTER_NAMED_T(EMSA, name, type, (make_new_T_1X<type, HashFunction>)) - -#if defined(BOTAN_HAS_EMSA1) -BOTAN_REGISTER_EMSA_1HASH(EMSA1, "EMSA1"); -#endif - -#if defined(BOTAN_HAS_EMSA_PKCS1) -BOTAN_REGISTER_NAMED_T(EMSA, "EMSA_PKCS1", EMSA_PCS1v15, EMSA_PKCS1v15::make); -#endif - -#if defined(BOTAN_HAS_EMSA_PSSR) -BOTAN_REGISTER_NAMED_T(EMSA, "PSSR", PSSR, PSSR::make); -#endif - -#if defined(BOTAN_HAS_EMSA_X931) -BOTAN_REGISTER_EMSA_1HASH(EMSA_X931, "EMSA_X931"); -#endif - -#if defined(BOTAN_HAS_EMSA_RAW) -BOTAN_REGISTER_EMSA_NAMED_NOARGS(EMSA_Raw, "Raw"); -#endif - } diff --git a/src/lib/pk_pad/emsa.h b/src/lib/pk_pad/emsa.h index 8e8720a66..bc930ae22 100644 --- a/src/lib/pk_pad/emsa.h +++ b/src/lib/pk_pad/emsa.h @@ -8,7 +8,6 @@ #ifndef BOTAN_PUBKEY_EMSA_H__ #define BOTAN_PUBKEY_EMSA_H__ -#include <botan/scan_name.h> #include <botan/secmem.h> #include <botan/rng.h> @@ -22,8 +21,6 @@ namespace Botan { class BOTAN_DLL EMSA { public: - typedef SCAN_Name Spec; - /** * Add more data to the signature computation * @param input some data diff --git a/src/lib/pk_pad/emsa_pkcs1/emsa_pkcs1.cpp b/src/lib/pk_pad/emsa_pkcs1/emsa_pkcs1.cpp index e990ef8af..b3f74930b 100644 --- a/src/lib/pk_pad/emsa_pkcs1/emsa_pkcs1.cpp +++ b/src/lib/pk_pad/emsa_pkcs1/emsa_pkcs1.cpp @@ -10,18 +10,6 @@ namespace Botan { -EMSA* EMSA_PKCS1v15::make(const EMSA::Spec& spec) - { - if(spec.arg(0) == "Raw") - return new EMSA_PKCS1v15_Raw; - else - { - if(auto h = HashFunction::create(spec.arg(0))) - return new EMSA_PKCS1v15(h.release()); - } - return nullptr; - } - namespace { secure_vector<byte> emsa3_encoding(const secure_vector<byte>& msg, diff --git a/src/lib/pk_pad/emsa_pkcs1/emsa_pkcs1.h b/src/lib/pk_pad/emsa_pkcs1/emsa_pkcs1.h index 917f03ac8..65daaf7ce 100644 --- a/src/lib/pk_pad/emsa_pkcs1/emsa_pkcs1.h +++ b/src/lib/pk_pad/emsa_pkcs1/emsa_pkcs1.h @@ -21,8 +21,6 @@ namespace Botan { class BOTAN_DLL EMSA_PKCS1v15 final : public EMSA { public: - static EMSA* make(const EMSA::Spec& spec); - /** * @param hash the hash function to use */ diff --git a/src/lib/pk_pad/emsa_pssr/pssr.cpp b/src/lib/pk_pad/emsa_pssr/pssr.cpp index ddd8c5f0b..a41e79e78 100644 --- a/src/lib/pk_pad/emsa_pssr/pssr.cpp +++ b/src/lib/pk_pad/emsa_pssr/pssr.cpp @@ -11,20 +11,6 @@ namespace Botan { -PSSR* PSSR::make(const Spec& request) - { - if(request.arg(1, "MGF1") != "MGF1") - return nullptr; - - if(auto h = HashFunction::create(request.arg(0))) - { - const size_t salt_size = request.arg_as_integer(2, h->output_length()); - return new PSSR(h.release(), salt_size); - } - - return nullptr; - } - /* * PSSR Update Operation */ diff --git a/src/lib/pk_pad/emsa_pssr/pssr.h b/src/lib/pk_pad/emsa_pssr/pssr.h index fa8687fee..bf465eadf 100644 --- a/src/lib/pk_pad/emsa_pssr/pssr.h +++ b/src/lib/pk_pad/emsa_pssr/pssr.h @@ -32,8 +32,6 @@ class BOTAN_DLL PSSR final : public EMSA PSSR(HashFunction* hash, size_t salt_size); EMSA* clone() override { return new PSSR(m_hash->clone(), m_SALT_SIZE); } - - static PSSR* make(const Spec& spec); private: void update(const byte input[], size_t length) override; diff --git a/src/lib/prov/openssl/openssl.h b/src/lib/prov/openssl/openssl.h index 58a7d77dc..8b2b41c1d 100644 --- a/src/lib/prov/openssl/openssl.h +++ b/src/lib/prov/openssl/openssl.h @@ -1,12 +1,12 @@ /* * Utils for calling OpenSSL -* (C) 2015 Jack Lloyd +* (C) 2015,2016 Jack Lloyd * * Botan is released under the Simplified BSD License (see license.txt) */ -#ifndef BOTAN_OPENSSL_H__ -#define BOTAN_OPENSSL_H__ +#ifndef BOTAN_INTERNAL_OPENSSL_H__ +#define BOTAN_INTERNAL_OPENSSL_H__ #include <botan/internal/pk_ops.h> #include <botan/secmem.h> @@ -15,9 +15,18 @@ #include <string> #include <openssl/err.h> +#include <openssl/evp.h> + +#if defined(BOTAN_HAS_RC4) +#include <openssl/rc4.h> +#endif namespace Botan { +class BlockCipher; +class StreamCipher; +class HashFunction; + class OpenSSL_Error : public Exception { public: @@ -25,9 +34,15 @@ class OpenSSL_Error : public Exception Exception(what + " failed: " + ERR_error_string(ERR_get_error(), nullptr)) {} }; -#define BOTAN_OPENSSL_BLOCK_PRIO 150 -#define BOTAN_OPENSSL_HASH_PRIO 150 -#define BOTAN_OPENSSL_RC4_PRIO 150 +/* Block Ciphers */ + +std::unique_ptr<BlockCipher> +make_openssl_block_cipher(const std::string& name); + +/* Hash */ + +std::unique_ptr<HashFunction> +make_openssl_hash(const std::string& name); /* RSA */ @@ -73,6 +88,12 @@ make_openssl_ecdh_ka_op(const ECDH_PrivateKey& key, const std::string& params); #endif +#if defined(BOTAN_HAS_RC4) + +std::unique_ptr<StreamCipher> +make_openssl_rc4(size_t skip); + +#endif } diff --git a/src/lib/prov/openssl/openssl_block.cpp b/src/lib/prov/openssl/openssl_block.cpp index 8f5ae89b1..cb98be70d 100644 --- a/src/lib/prov/openssl/openssl_block.cpp +++ b/src/lib/prov/openssl/openssl_block.cpp @@ -6,7 +6,6 @@ */ #include <botan/block_cipher.h> -#include <botan/internal/algo_registry.h> #include <botan/internal/openssl.h> #include <openssl/evp.h> @@ -17,10 +16,12 @@ namespace { class OpenSSL_BlockCipher : public BlockCipher { public: - OpenSSL_BlockCipher(const EVP_CIPHER*, const std::string&); + OpenSSL_BlockCipher(const std::string& name, + const EVP_CIPHER* cipher); - OpenSSL_BlockCipher(const EVP_CIPHER*, const std::string&, - size_t, size_t, size_t); + OpenSSL_BlockCipher(const std::string& name, + const EVP_CIPHER* cipher, + size_t kl_min, size_t kl_max, size_t kl_mod); ~OpenSSL_BlockCipher(); @@ -53,8 +54,8 @@ class OpenSSL_BlockCipher : public BlockCipher mutable EVP_CIPHER_CTX m_encrypt, m_decrypt; }; -OpenSSL_BlockCipher::OpenSSL_BlockCipher(const EVP_CIPHER* algo, - const std::string& algo_name) : +OpenSSL_BlockCipher::OpenSSL_BlockCipher(const std::string& algo_name, + const EVP_CIPHER* algo) : m_block_sz(EVP_CIPHER_block_size(algo)), m_cipher_key_spec(EVP_CIPHER_key_length(algo)), m_cipher_name(algo_name) @@ -72,10 +73,11 @@ OpenSSL_BlockCipher::OpenSSL_BlockCipher(const EVP_CIPHER* algo, EVP_CIPHER_CTX_set_padding(&m_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) : +OpenSSL_BlockCipher::OpenSSL_BlockCipher(const std::string& algo_name, + const EVP_CIPHER* algo, + size_t key_min, + size_t key_max, + size_t key_mod) : m_block_sz(EVP_CIPHER_block_size(algo)), m_cipher_key_spec(key_min, key_max, key_mod), m_cipher_name(algo_name) @@ -125,11 +127,11 @@ void OpenSSL_BlockCipher::key_schedule(const byte key[], size_t length) */ BlockCipher* OpenSSL_BlockCipher::clone() const { - return new OpenSSL_BlockCipher(EVP_CIPHER_CTX_cipher(&m_encrypt), - m_cipher_name, - m_cipher_key_spec.minimum_keylength(), - m_cipher_key_spec.maximum_keylength(), - m_cipher_key_spec.keylength_multiple()); + return new OpenSSL_BlockCipher(m_cipher_name, + EVP_CIPHER_CTX_cipher(&m_encrypt), + m_cipher_key_spec.minimum_keylength(), + m_cipher_key_spec.maximum_keylength(), + m_cipher_key_spec.keylength_multiple()); } /* @@ -149,67 +151,63 @@ void OpenSSL_BlockCipher::clear() EVP_CIPHER_CTX_set_padding(&m_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) +std::unique_ptr<BlockCipher> +make_openssl_block_cipher(const std::string& name) { - 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", BOTAN_OPENSSL_BLOCK_PRIO) - -#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", BOTAN_OPENSSL_BLOCK_PRIO) - -#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); +#define MAKE_OPENSSL_BLOCK(evp_fn) \ + std::unique_ptr<BlockCipher>(new OpenSSL_BlockCipher(name, evp_fn())) +#define MAKE_OPENSSL_BLOCK_KEYLEN(evp_fn, kl_min, kl_max, kl_mod) \ + std::unique_ptr<BlockCipher>(new OpenSSL_BlockCipher(name, evp_fn(), kl_min, kl_max, kl_mod)) + +#if defined(BOTAN_HAS_AES) && !defined(OPENSSL_NO_AES) + if(name == "AES-128") + return MAKE_OPENSSL_BLOCK(EVP_aes_128_ecb); + if(name == "AES-192") + return MAKE_OPENSSL_BLOCK(EVP_aes_192_ecb); + if(name == "AES-256") + return MAKE_OPENSSL_BLOCK(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); +#if defined(BOTAN_HAS_CAMELLIA) && !defined(OPENSSL_NO_CAMELLIA) + if(name == "Camellia-128") + return MAKE_OPENSSL_BLOCK(EVP_camellia_128_ecb); + if(name == "Camellia-192") + return MAKE_OPENSSL_BLOCK(EVP_camellia_192_ecb); + if(name == "Camellia-256") + return MAKE_OPENSSL_BLOCK(EVP_camellia_256_ecb); #endif -#if !defined(OPENSSL_NO_BF) - BOTAN_REGISTER_OPENSSL_EVP_BLOCK_KEYLEN("Blowfish", EVP_bf_ecb, 1, 56, 1); +#if defined(BOTAN_HAS_DES) && !defined(OPENSSL_NO_DES) + if(name == "DES") + return MAKE_OPENSSL_BLOCK(EVP_des_ecb); + if(name == "TripleDES") + return MAKE_OPENSSL_BLOCK_KEYLEN(EVP_des_ede3_ecb, 16, 24, 8); #endif -#if !defined(OPENSSL_NO_CAST) - BOTAN_REGISTER_OPENSSL_EVP_BLOCK_KEYLEN("CAST-128", EVP_cast5_ecb, 1, 16, 1); +#if defined(BOTAN_HAS_BLOWFISH) && !defined(OPENSSL_NO_BF) + if(name == "Blowfish") + return MAKE_OPENSSL_BLOCK_KEYLEN(EVP_bf_ecb, 1, 56, 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); +#if defined(BOTAN_HAS_CAST) && !defined(OPENSSL_NO_CAST) + if(name == "CAST-128") + return MAKE_OPENSSL_BLOCK_KEYLEN(EVP_cast5_ecb, 1, 16, 1); #endif -#if !defined(OPENSSL_NO_IDEA) - BOTAN_REGISTER_OPENSSL_EVP_BLOCK("IDEA", EVP_idea_ecb); +#if defined(BOTAN_HAS_IDEA) && !defined(OPENSSL_NO_IDEA) + if(name == "IDEA") + return MAKE_OPENSSL_BLOCK(EVP_idea_ecb); #endif -#if !defined(OPENSSL_NO_SEED) - BOTAN_REGISTER_OPENSSL_EVP_BLOCK("SEED", EVP_seed_ecb); +#if defined(BOTAN_HAS_SEED) && !defined(OPENSSL_NO_SEED) + if(name == "SEED") + return MAKE_OPENSSL_BLOCK(EVP_seed_ecb); #endif -} + return nullptr; + } } + diff --git a/src/lib/prov/openssl/openssl_hash.cpp b/src/lib/prov/openssl/openssl_hash.cpp index 15aebeb94..8e36866a1 100644 --- a/src/lib/prov/openssl/openssl_hash.cpp +++ b/src/lib/prov/openssl/openssl_hash.cpp @@ -7,8 +7,8 @@ #include <botan/hash.h> #include <botan/internal/openssl.h> -#include <botan/internal/algo_registry.h> #include <openssl/evp.h> +#include <unordered_map> namespace Botan { @@ -29,7 +29,7 @@ class OpenSSL_HashFunction : public HashFunction HashFunction* clone() const override { const EVP_MD* algo = EVP_MD_CTX_md(&m_md); - return new OpenSSL_HashFunction(algo, name()); + return new OpenSSL_HashFunction(name(), algo); } size_t output_length() const override @@ -42,7 +42,7 @@ class OpenSSL_HashFunction : public HashFunction return EVP_MD_block_size(EVP_MD_CTX_md(&m_md)); } - OpenSSL_HashFunction(const EVP_MD* md, const std::string& name) : m_name(name) + OpenSSL_HashFunction(const std::string& name, const EVP_MD* md) : m_name(name) { EVP_MD_CTX_init(&m_md); EVP_DigestInit_ex(&m_md, md, nullptr); @@ -70,45 +70,49 @@ class OpenSSL_HashFunction : public HashFunction 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", BOTAN_OPENSSL_HASH_PRIO) +} -#if !defined(OPENSSL_NO_SHA) - BOTAN_REGISTER_OPENSSL_EVP_HASH("SHA-160", EVP_sha1); +std::unique_ptr<HashFunction> +make_openssl_hash(const std::string& name) + { +#define MAKE_OPENSSL_HASH(fn) \ + std::unique_ptr<HashFunction>(new OpenSSL_HashFunction(name, fn ())) + +#if defined(BOTAN_HAS_SHA2_32) && !defined(OPENSSL_NO_SHA256) + if(name == "SHA-224") + return MAKE_OPENSSL_HASH(EVP_sha224); + if(name == "SHA-256") + return MAKE_OPENSSL_HASH(EVP_sha256); #endif -#if !defined(OPENSSL_NO_SHA256) - BOTAN_REGISTER_OPENSSL_EVP_HASH("SHA-224", EVP_sha224); - BOTAN_REGISTER_OPENSSL_EVP_HASH("SHA-256", EVP_sha256); +#if defined(BOTAN_HAS_SHA2_64) && !defined(OPENSSL_NO_SHA512) + if(name == "SHA-384") + return MAKE_OPENSSL_HASH(EVP_sha384); + if(name == "SHA-512") + return MAKE_OPENSSL_HASH(EVP_sha512); #endif -#if !defined(OPENSSL_NO_SHA512) - BOTAN_REGISTER_OPENSSL_EVP_HASH("SHA-384", EVP_sha384); - BOTAN_REGISTER_OPENSSL_EVP_HASH("SHA-512", EVP_sha512); +#if defined(BOTAN_HAS_SHA1) && !defined(OPENSSL_NO_SHA) + if(name == "SHA-160") + return MAKE_OPENSSL_HASH(EVP_sha1); #endif -#if !defined(OPENSSL_NO_MD4) - BOTAN_REGISTER_OPENSSL_EVP_HASH("MD4", EVP_md4); +#if defined(BOTAN_HAS_RIPEMD_160) && !defined(OPENSSL_NO_RIPEMD) + if(name == "RIPEMD-160") + return MAKE_OPENSSL_HASH(EVP_ripemd160); #endif -#if !defined(OPENSSL_NO_MD5) - BOTAN_REGISTER_OPENSSL_EVP_HASH("MD5", EVP_md5); -#endif +#if defined(BOTAN_HAS_MD5) && !defined(OPENSSL_NO_MD5) + if(name == "MD5") + return MAKE_OPENSSL_HASH(EVP_md5); + #endif -#if !defined(OPENSSL_NO_RIPEMD) - BOTAN_REGISTER_OPENSSL_EVP_HASH("RIPEMD-160", EVP_ripemd160); +#if defined(BOTAN_HAS_MD4) && !defined(OPENSSL_NO_MD4) + if(name == "MD4") + return MAKE_OPENSSL_HASH(EVP_md4); #endif -} + return nullptr; + } } diff --git a/src/lib/prov/openssl/openssl_rc4.cpp b/src/lib/prov/openssl/openssl_rc4.cpp index 3db62c32a..a9b793678 100644 --- a/src/lib/prov/openssl/openssl_rc4.cpp +++ b/src/lib/prov/openssl/openssl_rc4.cpp @@ -9,7 +9,6 @@ #if defined(BOTAN_HAS_OPENSSL) && defined(BOTAN_HAS_RC4) -#include <botan/internal/algo_registry.h> #include <botan/internal/openssl.h> #include <botan/parsing.h> #include <botan/exceptn.h> @@ -78,8 +77,12 @@ class OpenSSL_RC4 : public StreamCipher } -BOTAN_REGISTER_TYPE(StreamCipher, OpenSSL_RC4, "RC4", (make_new_T_1len<OpenSSL_RC4,0>), - "openssl", BOTAN_OPENSSL_RC4_PRIO); +std::unique_ptr<StreamCipher> +make_openssl_rc4(size_t skip) + { + return std::unique_ptr<StreamCipher>(new OpenSSL_RC4(skip)); + } + } diff --git a/src/lib/prov/pkcs11/p11_ecdh.cpp b/src/lib/prov/pkcs11/p11_ecdh.cpp index 6f88f43d6..474d1dac0 100644 --- a/src/lib/prov/pkcs11/p11_ecdh.cpp +++ b/src/lib/prov/pkcs11/p11_ecdh.cpp @@ -13,7 +13,6 @@ #include <botan/internal/p11_mechanism.h> #include <botan/ber_dec.h> #include <botan/der_enc.h> -#include <botan/internal/algo_registry.h> #include <botan/internal/pk_ops.h> #include <botan/rng.h> diff --git a/src/lib/prov/pkcs11/p11_ecdsa.cpp b/src/lib/prov/pkcs11/p11_ecdsa.cpp index 076bb2498..dede8bd6c 100644 --- a/src/lib/prov/pkcs11/p11_ecdsa.cpp +++ b/src/lib/prov/pkcs11/p11_ecdsa.cpp @@ -11,7 +11,6 @@ #if defined(BOTAN_HAS_ECDSA) #include <botan/internal/p11_mechanism.h> -#include <botan/internal/algo_registry.h> #include <botan/internal/pk_ops.h> #include <botan/keypair.h> #include <botan/rng.h> diff --git a/src/lib/prov/pkcs11/p11_rsa.cpp b/src/lib/prov/pkcs11/p11_rsa.cpp index c23c8f5f3..9c0f75157 100644 --- a/src/lib/prov/pkcs11/p11_rsa.cpp +++ b/src/lib/prov/pkcs11/p11_rsa.cpp @@ -12,7 +12,6 @@ #include <botan/internal/p11_mechanism.h> #include <botan/internal/pk_ops.h> -#include <botan/internal/algo_registry.h> #include <botan/internal/pk_ops.h> #include <botan/rng.h> #include <botan/blinding.h> diff --git a/src/lib/stream/ctr/ctr.cpp b/src/lib/stream/ctr/ctr.cpp index 43609ba2d..c4552d459 100644 --- a/src/lib/stream/ctr/ctr.cpp +++ b/src/lib/stream/ctr/ctr.cpp @@ -9,16 +9,6 @@ namespace Botan { -CTR_BE* CTR_BE::make(const Spec& spec) - { - if(spec.algo_name() == "CTR-BE" && spec.arg_count() == 1) - { - if(auto c = BlockCipher::create(spec.arg(0))) - return new CTR_BE(c.release()); - } - return nullptr; - } - CTR_BE::CTR_BE(BlockCipher* ciph) : m_cipher(ciph), m_counter(m_cipher->parallel_bytes()), diff --git a/src/lib/stream/ctr/ctr.h b/src/lib/stream/ctr/ctr.h index 385edac54..c4a28bd2b 100644 --- a/src/lib/stream/ctr/ctr.h +++ b/src/lib/stream/ctr/ctr.h @@ -38,8 +38,6 @@ class BOTAN_DLL CTR_BE final : public StreamCipher void clear() override; - static CTR_BE* make(const Spec& spec); - /** * @param cipher the block cipher to use */ diff --git a/src/lib/stream/ofb/ofb.cpp b/src/lib/stream/ofb/ofb.cpp index 3337a0c14..0c23188d5 100644 --- a/src/lib/stream/ofb/ofb.cpp +++ b/src/lib/stream/ofb/ofb.cpp @@ -9,16 +9,6 @@ namespace Botan { -OFB* OFB::make(const Spec& spec) - { - if(spec.algo_name() == "OFB" && spec.arg_count() == 1) - { - if(auto c = BlockCipher::create(spec.arg(0))) - return new OFB(c.release()); - } - return nullptr; - } - OFB::OFB(BlockCipher* cipher) : m_cipher(cipher), m_buffer(m_cipher->block_size()), diff --git a/src/lib/stream/ofb/ofb.h b/src/lib/stream/ofb/ofb.h index 7d77bae7a..f8beb4956 100644 --- a/src/lib/stream/ofb/ofb.h +++ b/src/lib/stream/ofb/ofb.h @@ -38,8 +38,6 @@ class BOTAN_DLL OFB final : public StreamCipher void clear() override; - static OFB* make(const Spec& spec); - /** * @param cipher the block cipher to use */ diff --git a/src/lib/stream/rc4/rc4.cpp b/src/lib/stream/rc4/rc4.cpp index e5ea2e2b8..7200288b6 100644 --- a/src/lib/stream/rc4/rc4.cpp +++ b/src/lib/stream/rc4/rc4.cpp @@ -10,15 +10,6 @@ namespace Botan { -RC4* RC4::make(const Spec& spec) - { - if(spec.algo_name() == "RC4") - return new RC4(spec.arg_as_integer(0, 0)); - if(spec.algo_name() == "RC4_drop") - return new RC4(768); - return nullptr; - } - /* * Combine cipher stream with message */ diff --git a/src/lib/stream/rc4/rc4.h b/src/lib/stream/rc4/rc4.h index 82dd6097b..46715f7d2 100644 --- a/src/lib/stream/rc4/rc4.h +++ b/src/lib/stream/rc4/rc4.h @@ -33,8 +33,6 @@ class BOTAN_DLL RC4 final : public StreamCipher return Key_Length_Specification(1, 256); } - static RC4* make(const Spec& spec); - /** * @param skip skip this many initial bytes in the keystream */ diff --git a/src/lib/stream/stream_cipher.cpp b/src/lib/stream/stream_cipher.cpp index 7c41722a0..74b9db9e7 100644 --- a/src/lib/stream/stream_cipher.cpp +++ b/src/lib/stream/stream_cipher.cpp @@ -1,12 +1,12 @@ /* * Stream Ciphers -* (C) 2015 Jack Lloyd +* (C) 2015,2016 Jack Lloyd * * Botan is released under the Simplified BSD License (see license.txt) */ #include <botan/stream_cipher.h> -#include <botan/internal/algo_registry.h> +#include <botan/scan_name.h> #if defined(BOTAN_HAS_CHACHA) #include <botan/chacha.h> @@ -32,44 +32,101 @@ #include <botan/rc4.h> #endif +#if defined(BOTAN_HAS_OPENSSL) + #include <botan/internal/openssl.h> +#endif + namespace Botan { std::unique_ptr<StreamCipher> StreamCipher::create(const std::string& algo_spec, const std::string& provider) { - return std::unique_ptr<StreamCipher>(make_a<StreamCipher>(Botan::StreamCipher::Spec(algo_spec), provider)); - } - -std::vector<std::string> StreamCipher::providers(const std::string& algo_spec) - { - return providers_of<StreamCipher>(StreamCipher::Spec(algo_spec)); - } + const SCAN_Name req(algo_spec); -StreamCipher::StreamCipher() {} -StreamCipher::~StreamCipher() {} +#if defined(BOTAN_HAS_CTR_BE) + if(req.algo_name() == "CTR-BE" && req.arg_count() == 1) + { + if(provider.empty() || provider == "base") + { + if(auto c = BlockCipher::create(req.arg(0))) + return std::unique_ptr<StreamCipher>(new CTR_BE(c.release())); + } + } +#endif #if defined(BOTAN_HAS_CHACHA) -BOTAN_REGISTER_T_1LEN(StreamCipher, ChaCha, 20); + if(req.algo_name() == "ChaCha") + { + if(provider.empty() || provider == "base") + return std::unique_ptr<StreamCipher>(new ChaCha(req.arg_as_integer(0, 20))); + } #endif #if defined(BOTAN_HAS_SALSA20) -BOTAN_REGISTER_T_NOARGS(StreamCipher, Salsa20); + if(req.algo_name() == "Salsa20") + { + if(provider.empty() || provider == "base") + return std::unique_ptr<StreamCipher>(new Salsa20); + } #endif #if defined(BOTAN_HAS_SHAKE_CIPHER) -BOTAN_REGISTER_NAMED_T(StreamCipher, "SHAKE-128", SHAKE_128, make_new_T<SHAKE_128>); -#endif - -#if defined(BOTAN_HAS_CTR_BE) -BOTAN_REGISTER_NAMED_T(StreamCipher, "CTR-BE", CTR_BE, CTR_BE::make); + if(req.algo_name() == "SHAKE-128") + { + if(provider.empty() || provider == "base") + return std::unique_ptr<StreamCipher>(new SHAKE_128); + } #endif #if defined(BOTAN_HAS_OFB) -BOTAN_REGISTER_NAMED_T(StreamCipher, "OFB", OFB, OFB::make); + if(req.algo_name() == "OFB" && req.arg_count() == 1) + { + if(provider.empty() || provider == "base") + { + if(auto c = BlockCipher::create(req.arg(0))) + return std::unique_ptr<StreamCipher>(new OFB(c.release())); + } + } #endif #if defined(BOTAN_HAS_RC4) -BOTAN_REGISTER_NAMED_T(StreamCipher, "RC4", RC4, RC4::make); + + if(req.algo_name() == "RC4") + { + const size_t skip = req.arg_as_integer(0, 0); +#if defined(BOTAN_HAS_OPENSSL) + if(provider.empty() || provider == "openssl") + { + return std::unique_ptr<StreamCipher>(make_openssl_rc4(skip)); + } #endif + if(provider.empty() || provider == "base") + { + return std::unique_ptr<StreamCipher>(new RC4(skip)); + } + } + +#endif + + return nullptr; + } + +//static +std::unique_ptr<StreamCipher> +StreamCipher::create_or_throw(const std::string& algo, + const std::string& provider) + { + if(auto sc = StreamCipher::create(algo, provider)) + { + return sc; + } + throw Lookup_Error("Stream cipher", algo, provider); + } + +std::vector<std::string> StreamCipher::providers(const std::string& algo_spec) + { + return probe_providers_of<StreamCipher>(algo_spec, {"base", "openssl"}); + } + } diff --git a/src/lib/stream/stream_cipher.h b/src/lib/stream/stream_cipher.h index 0cbdf3c65..7654bf427 100644 --- a/src/lib/stream/stream_cipher.h +++ b/src/lib/stream/stream_cipher.h @@ -9,7 +9,7 @@ #define BOTAN_STREAM_CIPHER_H__ #include <botan/sym_algo.h> -#include <botan/scan_name.h> +#include <string> namespace Botan { @@ -19,7 +19,7 @@ namespace Botan { class BOTAN_DLL StreamCipher : public SymmetricAlgorithm { public: - typedef SCAN_Name Spec; + virtual ~StreamCipher() {} /** * Create an instance based on a name @@ -28,8 +28,20 @@ class BOTAN_DLL StreamCipher : public SymmetricAlgorithm * @param provider provider implementation to use * @return a null pointer if the algo/provider combination cannot be found */ - static std::unique_ptr<StreamCipher> create(const std::string& algo_spec, - const std::string& provider = ""); + static std::unique_ptr<StreamCipher> + create(const std::string& algo_spec, + const std::string& provider = ""); + + /** + * Create an instance based on a name + * If provider is empty then best available is chosen. + * @param algo_spec algorithm name + * @param provider provider implementation to use + * Throws a Lookup_Error if the algo/provider combination cannot be found + */ + static std::unique_ptr<StreamCipher> + create_or_throw(const std::string& algo_spec, + const std::string& provider = ""); /** * @return list of available providers for this algorithm, empty if not available @@ -109,9 +121,6 @@ class BOTAN_DLL StreamCipher : public SymmetricAlgorithm * might also return "sse2", "avx2", "openssl", or some other arbitrary string. */ virtual std::string provider() const { return "base"; } - - StreamCipher(); - virtual ~StreamCipher(); }; } diff --git a/src/lib/utils/exceptn.h b/src/lib/utils/exceptn.h index bfde49002..798f2240a 100644 --- a/src/lib/utils/exceptn.h +++ b/src/lib/utils/exceptn.h @@ -73,6 +73,13 @@ struct BOTAN_DLL Lookup_Error : public Exception explicit Lookup_Error(const std::string& err) : Exception(err) {} + + Lookup_Error(const std::string& type, + const std::string& algo, + const std::string& provider) : + Exception("Unavailable " + type + " " + algo + + (provider.empty() ? std::string("") : (" for provider " + provider))) + {} }; /** diff --git a/src/tests/test_hash.cpp b/src/tests/test_hash.cpp index aca9d7ef6..dc93bb4d1 100644 --- a/src/tests/test_hash.cpp +++ b/src/tests/test_hash.cpp @@ -8,10 +8,6 @@ #include <botan/hash.h> -#if defined (BOTAN_HAS_PARALLEL_HASH) - #include <botan/par_hash.h> -#endif - namespace Botan_Tests { namespace { @@ -46,14 +42,19 @@ class Hash_Function_Tests : public Text_Based_Test continue; } + std::unique_ptr<Botan::HashFunction> clone(hash->clone()); + const std::string provider(hash->provider()); result.test_is_nonempty("provider", provider); result.test_eq(provider, hash->name(), algo); + result.test_eq(provider, hash->name(), clone->name()); hash->update(input); - result.test_eq(provider, "hashing", hash->final(), expected); + clone->update(input); + result.test_eq(provider, "hashing (clone)", clone->final(), expected); + // Test to make sure clear() resets what we need it to hash->update("some discarded input"); hash->clear(); @@ -77,97 +78,6 @@ class Hash_Function_Tests : public Text_Based_Test BOTAN_REGISTER_TEST("hash", Hash_Function_Tests); -#if defined(BOTAN_HAS_PARALLEL_HASH) - -Test::Result test_clone() - { - Test::Result result("Parallel hash"); - - std::string algo = "Parallel(MD5,SHA-160)"; - std::unique_ptr<Botan::HashFunction> hash(Botan::HashFunction::create(algo)); - - if(!hash) - { - result.note_missing(algo); - return result; - } - - hash->update(""); - result.test_eq("Parallel hashing", hash->final(), "D41D8CD98F00B204E9800998ECF8427EDA39A3EE5E" - "6B4B0D3255BFEF95601890AFD80709"); - - std::unique_ptr<Botan::HashFunction> hash_clone(hash->clone()); - - hash_clone->clear(); - hash_clone->update(""); - result.test_eq("Parallel hashing (clone)", hash_clone->final(), "D41D8CD98F00B204E9800998ECF8427" - "EDA39A3EE5E6B4B0D3255BFEF95601890AFD80709"); - - return result; - } - -Test::Result test_ctor() - { - Test::Result result("Parallel hash"); - - std::unique_ptr<Botan::HashFunction> sha256(Botan::HashFunction::create("SHA-256")); - if(!sha256) - { - result.note_missing("SHA-256"); - return result; - } - - std::unique_ptr<Botan::HashFunction> sha512(Botan::HashFunction::create("SHA-512")); - if(!sha512) - { - result.note_missing("SHA-512"); - return result; - } - - std::vector<Botan::HashFunction*> hashes = { sha256.get(), sha512.get() }; - Botan::Parallel par_hash(hashes); - - par_hash.update(""); - result.test_eq("Parallel hashing", par_hash.final(), "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B" - "934CA495991B7852B855CF83E1357EEFB8BDF1542850D66D8007D620E4050B5715DC83F4A921D36CE9C" - "E47D0D13C5D85F2B0FF8318D2877EEC2F63B931BD47417A81A538327AF927DA3E"); - - return result; - } - -class Parallel_Hash_Tests : public Test - { - public: - std::vector<Test::Result> run() override - { - std::vector<Test::Result> results; - - std::vector<std::function<Test::Result()>> fns = - { - test_clone, - test_ctor - }; - - for(size_t i = 0; i != fns.size(); ++i) - { - try - { - results.push_back(fns[ i ]()); - } - catch(std::exception& e) - { - results.push_back(Test::Result::Failure("Parallel hash tests " + std::to_string(i), e.what())); - } - } - - return results; - } - }; - -BOTAN_REGISTER_TEST("par_hash", Parallel_Hash_Tests); - -#endif - } } |