aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--checks/check.cpp2
-rwxr-xr-xconfigure.pl2
-rw-r--r--doc/log.txt3
-rw-r--r--readme.txt2
-rw-r--r--src/algo_factory/algo_cache.h91
-rw-r--r--src/algo_factory/algo_factory.cpp219
-rw-r--r--src/algo_factory/algo_factory.h83
-rw-r--r--src/algo_factory/info.txt1
-rw-r--r--src/benchmark/benchmark.cpp13
-rw-r--r--src/engine/def_engine/lookup_mac.cpp2
-rw-r--r--src/libstate/get_enc.cpp6
-rw-r--r--src/pbe/get_pbe.cpp12
-rw-r--r--src/pbe/pbes2/pbes2.cpp2
-rw-r--r--src/selftest/selftest.cpp10
-rw-r--r--src/utils/scan_name.cpp14
-rw-r--r--src/utils/scan_name.h28
16 files changed, 277 insertions, 213 deletions
diff --git a/checks/check.cpp b/checks/check.cpp
index 93d7e9b94..5cf5c1c31 100644
--- a/checks/check.cpp
+++ b/checks/check.cpp
@@ -102,6 +102,8 @@ int main(int argc, char* argv[])
Botan::LibraryInitializer init("thread_safe=no");
+ //Botan::global_state().algorithm_factory().set_preferred_provider("SHA-160", "core");
+
Botan::AutoSeeded_RNG rng;
if(opts.is_set("help") || argc <= 1)
diff --git a/configure.pl b/configure.pl
index 8fa976fff..737800665 100755
--- a/configure.pl
+++ b/configure.pl
@@ -13,7 +13,7 @@ use Sys::Hostname;
my $MAJOR_VERSION = 1;
my $MINOR_VERSION = 7;
-my $PATCH_VERSION = 21;
+my $PATCH_VERSION = 22;
my $VERSION_STRING = "$MAJOR_VERSION.$MINOR_VERSION.$PATCH_VERSION";
diff --git a/doc/log.txt b/doc/log.txt
index 923279e34..02c5609f9 100644
--- a/doc/log.txt
+++ b/doc/log.txt
@@ -1,4 +1,7 @@
+* 1.7.22, ????-??-??
+ - Add provider preferences to Algorithm_Factory
+
* 1.7.21, 2008-11-11
- Make algorithm lookup much more configuable
- Add facilities for runtime performance testing of algorithms
diff --git a/readme.txt b/readme.txt
index 505f59a63..c11a1ea27 100644
--- a/readme.txt
+++ b/readme.txt
@@ -1,4 +1,4 @@
-Botan 1.7.21 2008-11-11
+Botan 1.7.22 ????-??-??
http://botan.randombit.net/
Please note that this is an experimental / development version of
diff --git a/src/algo_factory/algo_cache.h b/src/algo_factory/algo_cache.h
index 699078b03..17ea9964a 100644
--- a/src/algo_factory/algo_cache.h
+++ b/src/algo_factory/algo_cache.h
@@ -5,25 +5,46 @@
#ifndef BOTAN_ALGORITHM_CACHE_TEMPLATE_H__
#define BOTAN_ALGORITHM_CACHE_TEMPLATE_H__
-#include <botan/scan_name.h>
#include <botan/mutex.h>
+#include <botan/stl_util.h>
#include <string>
+#include <vector>
#include <map>
namespace Botan {
/**
+* @param prov_name a provider name
+* @return weight for this provider
+*/
+u32bit static_provider_weight(const std::string& prov_name);
+
+/**
* Algorithm_Cache (used by Algorithm_Factory)
*/
template<typename T>
class Algorithm_Cache
{
public:
- const T* get(const SCAN_Name& request);
+ const T* get(const std::string& algo_spec,
+ const std::string& pref_provider);
+
+ /**
+ * Add a new algorithm implementation to the cache
+ */
void add(T* algo,
const std::string& requested_name,
- const std::string& provider);
+ const std::string& provider_name);
+
+ /**
+ * Set the preferred provider
+ */
+ void set_preferred_provider(const std::string& algo_spec,
+ const std::string& provider);
+ /**
+ * Return the list of providers of this algorithm
+ */
std::vector<std::string> providers_of(const std::string& algo_name);
Algorithm_Cache(Mutex* m) : mutex(m) {}
@@ -38,17 +59,18 @@ class Algorithm_Cache
Mutex* mutex;
std::map<std::string, std::string> aliases;
+ std::map<std::string, std::string> pref_providers;
std::map<std::string, std::map<std::string, T*> > algorithms;
};
/**
* Look for an algorithm implementation in the cache, also checking aliases
+* Assumes object lock is held
*/
template<typename T>
typename Algorithm_Cache<T>::algorithms_iterator
Algorithm_Cache<T>::find_algorithm(const std::string& algo_spec)
{
- // Assumes mutex is held
algorithms_iterator algo = algorithms.find(algo_spec);
// Not found? Check if a known alias
@@ -65,40 +87,51 @@ Algorithm_Cache<T>::find_algorithm(const std::string& algo_spec)
}
/**
-* Look for an algorithm implementation in the cache
+* Look for an algorithm implementation by a particular provider
*/
template<typename T>
-const T* Algorithm_Cache<T>::get(const SCAN_Name& request)
+const T* Algorithm_Cache<T>::get(const std::string& algo_spec,
+ const std::string& requested_provider)
{
Mutex_Holder lock(mutex);
- algorithms_iterator algo = find_algorithm(request.as_string());
- if(algo == algorithms.end()) // not found at all
+ algorithms_iterator algo = find_algorithm(algo_spec);
+ if(algo == algorithms.end()) // algo not found at all (no providers)
return 0;
- const std::string requested_provider = request.provider();
-
+ // If a provider is requested specifically, return it or fail entirely
if(requested_provider != "")
{
- provider_iterator provider = algo->second.find(requested_provider);
-
- if(provider != algo->second.end())
- return provider->second;
+ provider_iterator prov = algo->second.find(requested_provider);
+ if(prov != algo->second.end())
+ return prov->second;
+ return 0;
}
- else // no specific provider requested: pick one
+
+ const T* prototype = 0;
+ std::string prototype_provider;
+ u32bit prototype_prov_weight = 0;
+
+ const std::string pref_provider = search_map(pref_providers, algo_spec);
+
+ for(provider_iterator i = algo->second.begin(); i != algo->second.end(); ++i)
{
- provider_iterator provider = algo->second.begin();
+ const std::string prov_name = i->first;
+ const u32bit prov_weight = static_provider_weight(prov_name);
- while(provider != algo->second.end())
- ++provider;
+ // preferred prov exists, return immediately
+ if(prov_name == pref_provider)
+ return i->second;
- provider = algo->second.begin();
- // @fixme: Just picks the lexicographically first one
- if(provider != algo->second.end())
- return provider->second;
+ if(prototype == 0 || prov_weight > prototype_prov_weight)
+ {
+ prototype = i->second;
+ prototype_provider = i->first;
+ prototype_prov_weight = prov_weight;
+ }
}
- return 0; // cache miss
+ return prototype;
}
/**
@@ -151,6 +184,18 @@ Algorithm_Cache<T>::providers_of(const std::string& algo_name)
}
/**
+* Set the preferred provider for an algorithm
+*/
+template<typename T>
+void Algorithm_Cache<T>::set_preferred_provider(const std::string& algo_spec,
+ const std::string& provider)
+ {
+ Mutex_Holder lock(mutex);
+
+ pref_providers[algo_spec] = provider;
+ }
+
+/**
* Algorithm_Cache<T> Destructor
*/
template<typename T>
diff --git a/src/algo_factory/algo_factory.cpp b/src/algo_factory/algo_factory.cpp
index 0756d02d8..5b300b7c6 100644
--- a/src/algo_factory/algo_factory.cpp
+++ b/src/algo_factory/algo_factory.cpp
@@ -45,9 +45,25 @@ void Algorithm_Factory::add_engine(Engine* engine)
engines.push_back(engine);
}
-/*************************************************
-* Get an engine out of the list *
-*************************************************/
+/**
+* Set the preferred provider for an algorithm
+*/
+void Algorithm_Factory::set_preferred_provider(const std::string& algo_spec,
+ const std::string& provider)
+ {
+ if(prototype_block_cipher(algo_spec))
+ block_cipher_cache.set_preferred_provider(algo_spec, provider);
+ else if(prototype_stream_cipher(algo_spec))
+ stream_cipher_cache.set_preferred_provider(algo_spec, provider);
+ else if(prototype_hash_function(algo_spec))
+ hash_cache.set_preferred_provider(algo_spec, provider);
+ else if(prototype_mac(algo_spec))
+ mac_cache.set_preferred_provider(algo_spec, provider);
+ }
+
+/**
+* Get an engine out of the list
+*/
Engine* Algorithm_Factory::get_engine_n(u32bit n) const
{
if(n >= engines.size())
@@ -57,180 +73,173 @@ Engine* Algorithm_Factory::get_engine_n(u32bit n) const
/**
* Return the possible providers of a request
+* Note: assumes you don't have different types by the same name
*/
std::vector<std::string>
-Algorithm_Factory::providers_of(const std::string& algo_name)
+Algorithm_Factory::providers_of(const std::string& algo_spec)
{
- if(prototype_block_cipher(algo_name))
- return block_cipher_cache.providers_of(algo_name);
-
- if(prototype_stream_cipher(algo_name))
- return stream_cipher_cache.providers_of(algo_name);
-
- if(prototype_hash_function(algo_name))
- return hash_cache.providers_of(algo_name);
-
- if(prototype_mac(algo_name))
- return mac_cache.providers_of(algo_name);
-
- return std::vector<std::string>();
+ if(prototype_block_cipher(algo_spec))
+ return block_cipher_cache.providers_of(algo_spec);
+ else if(prototype_stream_cipher(algo_spec))
+ return stream_cipher_cache.providers_of(algo_spec);
+ else if(prototype_hash_function(algo_spec))
+ return hash_cache.providers_of(algo_spec);
+ else if(prototype_mac(algo_spec))
+ return mac_cache.providers_of(algo_spec);
+ else
+ return std::vector<std::string>();
}
/**
* Return the prototypical block cipher cooresponding to this request
*/
const BlockCipher*
-Algorithm_Factory::prototype_block_cipher(const SCAN_Name& request)
+Algorithm_Factory::prototype_block_cipher(const std::string& algo_spec,
+ const std::string& provider)
{
- if(const BlockCipher* cache_hit = block_cipher_cache.get(request))
- return cache_hit;
+ if(const BlockCipher* hit = block_cipher_cache.get(algo_spec, provider))
+ return hit;
+ SCAN_Name scan_name(algo_spec);
for(u32bit i = 0; i != engines.size(); ++i)
{
- const std::string provider = engines[i]->provider_name();
-
- SCAN_Name request_i(request.as_string(), provider);
-
- if(BlockCipher* impl = engines[i]->find_block_cipher(request_i, *this))
- block_cipher_cache.add(impl, request.as_string(), provider);
+ if(BlockCipher* impl = engines[i]->find_block_cipher(scan_name, *this))
+ block_cipher_cache.add(impl, algo_spec, engines[i]->provider_name());
}
- return block_cipher_cache.get(request);
+ return block_cipher_cache.get(algo_spec, provider);
}
/**
-* Return a new block cipher cooresponding to this request
+* Return the prototypical stream cipher cooresponding to this request
*/
-BlockCipher* Algorithm_Factory::make_block_cipher(const SCAN_Name& request)
+const StreamCipher*
+Algorithm_Factory::prototype_stream_cipher(const std::string& algo_spec,
+ const std::string& provider)
{
- if(const BlockCipher* prototype = prototype_block_cipher(request))
- return prototype->clone();
- throw Algorithm_Not_Found(request.as_string());
+ if(const StreamCipher* hit = stream_cipher_cache.get(algo_spec, provider))
+ return hit;
+
+ SCAN_Name scan_name(algo_spec);
+ for(u32bit i = 0; i != engines.size(); ++i)
+ {
+ if(StreamCipher* impl = engines[i]->find_stream_cipher(scan_name, *this))
+ stream_cipher_cache.add(impl, algo_spec, engines[i]->provider_name());
+ }
+
+ return stream_cipher_cache.get(algo_spec, provider);
}
/**
-* Add a new block cipher
+* Return the prototypical object cooresponding to this request (if found)
*/
-void Algorithm_Factory::add_block_cipher(BlockCipher* block_cipher,
- const std::string& provider)
+const HashFunction*
+Algorithm_Factory::prototype_hash_function(const std::string& algo_spec,
+ const std::string& provider)
{
- block_cipher_cache.add(block_cipher, block_cipher->name(), provider);
+ if(const HashFunction* hit = hash_cache.get(algo_spec, provider))
+ return hit;
+
+ SCAN_Name scan_name(algo_spec);
+ for(u32bit i = 0; i != engines.size(); ++i)
+ {
+ if(HashFunction* impl = engines[i]->find_hash(scan_name, *this))
+ hash_cache.add(impl, algo_spec, engines[i]->provider_name());
+ }
+
+ return hash_cache.get(algo_spec, provider);
}
/**
-* Return the prototypical stream cipher cooresponding to this request
+* Return the prototypical object cooresponding to this request
*/
-const StreamCipher*
-Algorithm_Factory::prototype_stream_cipher(const SCAN_Name& request)
+const MessageAuthenticationCode*
+Algorithm_Factory::prototype_mac(const std::string& algo_spec,
+ const std::string& provider)
{
- if(const StreamCipher* cache_hit = stream_cipher_cache.get(request))
- return cache_hit;
+ if(const MessageAuthenticationCode* hit = mac_cache.get(algo_spec, provider))
+ return hit;
+ SCAN_Name scan_name(algo_spec);
for(u32bit i = 0; i != engines.size(); ++i)
{
- const std::string provider = engines[i]->provider_name();
-
- SCAN_Name request_i(request.as_string(), provider);
-
- if(StreamCipher* impl = engines[i]->find_stream_cipher(request_i, *this))
- stream_cipher_cache.add(impl, request.as_string(), provider);
+ if(MessageAuthenticationCode* impl = engines[i]->find_mac(scan_name, *this))
+ mac_cache.add(impl, algo_spec, engines[i]->provider_name());
}
- return stream_cipher_cache.get(request);
+ return mac_cache.get(algo_spec, provider);
}
/**
-* Return a new stream cipher cooresponding to this request
+* Return a new block cipher cooresponding to this request
*/
-StreamCipher* Algorithm_Factory::make_stream_cipher(const SCAN_Name& request)
+BlockCipher* Algorithm_Factory::make_block_cipher(const std::string& algo_spec,
+ const std::string& provider)
{
- if(const StreamCipher* prototype = prototype_stream_cipher(request))
- return prototype->clone();
- throw Algorithm_Not_Found(request.as_string());
+ if(const BlockCipher* proto = prototype_block_cipher(algo_spec, provider))
+ return proto->clone();
+ throw Algorithm_Not_Found(algo_spec);
}
/**
-* Add a new stream cipher
+* Return a new stream cipher cooresponding to this request
*/
-void Algorithm_Factory::add_stream_cipher(StreamCipher* stream_cipher,
- const std::string& provider)
+StreamCipher* Algorithm_Factory::make_stream_cipher(const std::string& algo_spec,
+ const std::string& provider)
{
- stream_cipher_cache.add(stream_cipher, stream_cipher->name(), provider);
+ if(const StreamCipher* prototype = prototype_stream_cipher(algo_spec, provider))
+ return prototype->clone();
+ throw Algorithm_Not_Found(algo_spec);
}
/**
-* Return the prototypical object cooresponding to this request (if found)
+* Return a new object cooresponding to this request
*/
-const HashFunction*
-Algorithm_Factory::prototype_hash_function(const SCAN_Name& request)
+HashFunction* Algorithm_Factory::make_hash_function(const std::string& algo_spec,
+ const std::string& provider)
{
- if(const HashFunction* cache_hit = hash_cache.get(request))
- return cache_hit;
-
- for(u32bit i = 0; i != engines.size(); ++i)
- {
- const std::string provider = engines[i]->provider_name();
-
- SCAN_Name request_i(request.as_string(), provider);
-
- if(HashFunction* impl = engines[i]->find_hash(request_i, *this))
- hash_cache.add(impl, request.as_string(), provider);
- }
-
- return hash_cache.get(request);
+ if(const HashFunction* prototype = prototype_hash_function(algo_spec, provider))
+ return prototype->clone();
+ throw Algorithm_Not_Found(algo_spec);
}
/**
* Return a new object cooresponding to this request
*/
-HashFunction* Algorithm_Factory::make_hash_function(const SCAN_Name& request)
+MessageAuthenticationCode*
+Algorithm_Factory::make_mac(const std::string& algo_spec,
+ const std::string& provider)
{
- if(const HashFunction* prototype = prototype_hash_function(request))
+ if(const MessageAuthenticationCode* prototype = prototype_mac(algo_spec, provider))
return prototype->clone();
- throw Algorithm_Not_Found(request.as_string());
+ throw Algorithm_Not_Found(algo_spec);
}
/**
-* Add a new hash
+* Add a new block cipher
*/
-void Algorithm_Factory::add_hash_function(HashFunction* hash,
- const std::string& provider)
+void Algorithm_Factory::add_block_cipher(BlockCipher* block_cipher,
+ const std::string& provider)
{
- hash_cache.add(hash, hash->name(), provider);
+ block_cipher_cache.add(block_cipher, block_cipher->name(), provider);
}
/**
-* Return the prototypical object cooresponding to this request
+* Add a new stream cipher
*/
-const MessageAuthenticationCode*
-Algorithm_Factory::prototype_mac(const SCAN_Name& request)
+void Algorithm_Factory::add_stream_cipher(StreamCipher* stream_cipher,
+ const std::string& provider)
{
- if(const MessageAuthenticationCode* cache_hit = mac_cache.get(request))
- return cache_hit;
-
- for(u32bit i = 0; i != engines.size(); ++i)
- {
- const std::string provider = engines[i]->provider_name();
-
- SCAN_Name request_i(request.as_string(), provider);
-
- if(MessageAuthenticationCode* impl =
- engines[i]->find_mac(request_i, *this))
- mac_cache.add(impl, request.as_string(), provider);
- }
-
- return mac_cache.get(request);
+ stream_cipher_cache.add(stream_cipher, stream_cipher->name(), provider);
}
/**
-* Return a new object cooresponding to this request
+* Add a new hash
*/
-MessageAuthenticationCode*
-Algorithm_Factory::make_mac(const SCAN_Name& request)
+void Algorithm_Factory::add_hash_function(HashFunction* hash,
+ const std::string& provider)
{
- if(const MessageAuthenticationCode* prototype = prototype_mac(request))
- return prototype->clone();
- throw Algorithm_Not_Found(request.as_string());
+ hash_cache.add(hash, hash->name(), provider);
}
/**
diff --git a/src/algo_factory/algo_factory.h b/src/algo_factory/algo_factory.h
index 07a8c93f1..fbaf26ebf 100644
--- a/src/algo_factory/algo_factory.h
+++ b/src/algo_factory/algo_factory.h
@@ -7,11 +7,9 @@
#define BOTAN_ALGORITHM_FACTORY_H__
#include <botan/algo_cache.h>
-#include <botan/scan_name.h>
#include <botan/mutex.h>
#include <string>
#include <vector>
-#include <map>
namespace Botan {
@@ -29,11 +27,70 @@ class MessageAuthenticationCode;
class BOTAN_DLL Algorithm_Factory
{
public:
+ /**
+ * Contructor
+ * @param mf a mutex factory
+ */
Algorithm_Factory(Mutex_Factory& mf);
+
+ /**
+ * Destructor
+ */
~Algorithm_Factory();
+ /**
+ * Add an engine implementation to this factory (how steampunk)
+ */
void add_engine(class Engine*);
+ /*
+ * Provider management
+ */
+ std::vector<std::string> providers_of(const std::string& algo_spec);
+
+ void set_preferred_provider(const std::string& algo_spec,
+ const std::string& provider);
+
+ /*
+ * Block cipher operations
+ */
+ const BlockCipher* prototype_block_cipher(const std::string& algo_spec,
+ const std::string& provider = "");
+ BlockCipher* make_block_cipher(const std::string& algo_spec,
+ const std::string& provider = "");
+ void add_block_cipher(BlockCipher* hash, const std::string& provider);
+
+ /*
+ * Stream cipher operations
+ */
+ const StreamCipher* prototype_stream_cipher(const std::string& algo_spec,
+ const std::string& provider = "");
+ StreamCipher* make_stream_cipher(const std::string& algo_spec,
+ const std::string& provider = "");
+ void add_stream_cipher(StreamCipher* hash, const std::string& provider);
+
+ /*
+ * Hash function operations
+ */
+ const HashFunction* prototype_hash_function(const std::string& algo_spec,
+ const std::string& provider = "");
+ HashFunction* make_hash_function(const std::string& algo_spec,
+ const std::string& provider = "");
+ void add_hash_function(HashFunction* hash, const std::string& provider);
+
+ /*
+ * MAC operations
+ */
+ const MessageAuthenticationCode* prototype_mac(const std::string& algo_spec,
+ const std::string& provider = "");
+ MessageAuthenticationCode* make_mac(const std::string& algo_spec,
+ const std::string& provider = "");
+ void add_mac(MessageAuthenticationCode* mac,
+ const std::string& provider);
+
+ /*
+ * Deprecated
+ */
class BOTAN_DLL Engine_Iterator
{
public:
@@ -45,28 +102,6 @@ class BOTAN_DLL Algorithm_Factory
};
friend class Engine_Iterator;
- std::vector<std::string> providers_of(const std::string& algo_spec);
-
- // Block cipher operations
- const BlockCipher* prototype_block_cipher(const SCAN_Name& request);
- BlockCipher* make_block_cipher(const SCAN_Name& request);
- void add_block_cipher(BlockCipher* hash, const std::string& provider);
-
- // Stream cipher operations
- const StreamCipher* prototype_stream_cipher(const SCAN_Name& request);
- StreamCipher* make_stream_cipher(const SCAN_Name& request);
- void add_stream_cipher(StreamCipher* hash, const std::string& provider);
-
- // Hash function operations
- const HashFunction* prototype_hash_function(const SCAN_Name& request);
- HashFunction* make_hash_function(const SCAN_Name& request);
- void add_hash_function(HashFunction* hash, const std::string& provider);
-
- // MAC operations
- const MessageAuthenticationCode* prototype_mac(const SCAN_Name& request);
- MessageAuthenticationCode* make_mac(const SCAN_Name& request);
- void add_mac(MessageAuthenticationCode* mac,
- const std::string& provider);
private:
class Engine* get_engine_n(u32bit) const;
diff --git a/src/algo_factory/info.txt b/src/algo_factory/info.txt
index 34f2a94cc..937b91353 100644
--- a/src/algo_factory/info.txt
+++ b/src/algo_factory/info.txt
@@ -12,4 +12,5 @@ utils
algo_factory.cpp
algo_factory.h
algo_cache.h
+prov_weight.cpp
</add>
diff --git a/src/benchmark/benchmark.cpp b/src/benchmark/benchmark.cpp
index 41e41bfcc..fe6cf0a41 100644
--- a/src/benchmark/benchmark.cpp
+++ b/src/benchmark/benchmark.cpp
@@ -137,32 +137,33 @@ algorithm_benchmark(const std::string& name,
{
const std::string provider = providers[i];
- SCAN_Name request(name, provider);
-
std::pair<u32bit, u64bit> results = std::make_pair(0, 0);
- if(const BlockCipher* proto = af.prototype_block_cipher(request))
+ if(const BlockCipher* proto =
+ af.prototype_block_cipher(name, provider))
{
std::auto_ptr<BlockCipher> block_cipher(proto->clone());
results = bench_block_cipher(block_cipher.get(), timer,
ns_per_provider,
&buf[0], buf.size());
}
- else if(const StreamCipher* proto = af.prototype_stream_cipher(request))
+ else if(const StreamCipher* proto =
+ af.prototype_stream_cipher(name, provider))
{
std::auto_ptr<StreamCipher> stream_cipher(proto->clone());
results = bench_stream_cipher(stream_cipher.get(), timer,
ns_per_provider,
&buf[0], buf.size());
}
- else if(const HashFunction* proto = af.prototype_hash_function(request))
+ else if(const HashFunction* proto =
+ af.prototype_hash_function(name, provider))
{
std::auto_ptr<HashFunction> hash(proto->clone());
results = bench_hash(hash.get(), timer, ns_per_provider,
&buf[0], buf.size());
}
else if(const MessageAuthenticationCode* proto =
- af.prototype_mac(request))
+ af.prototype_mac(name, provider))
{
std::auto_ptr<MessageAuthenticationCode> mac(proto->clone());
results = bench_mac(mac.get(), timer, ns_per_provider,
diff --git a/src/engine/def_engine/lookup_mac.cpp b/src/engine/def_engine/lookup_mac.cpp
index ae44bbe3d..35f17e134 100644
--- a/src/engine/def_engine/lookup_mac.cpp
+++ b/src/engine/def_engine/lookup_mac.cpp
@@ -59,7 +59,7 @@ Default_Engine::find_mac(const SCAN_Name& request,
#if defined(BOTAN_HAS_ANSI_X919_MAC)
if(request.algo_name() == "X9.19-MAC" && request.arg_count() == 0)
- return new ANSI_X919_MAC(af.make_block_cipher(SCAN_Name("DES")));
+ return new ANSI_X919_MAC(af.make_block_cipher("DES"));
#endif
return 0;
diff --git a/src/libstate/get_enc.cpp b/src/libstate/get_enc.cpp
index a5231db91..60a92d53e 100644
--- a/src/libstate/get_enc.cpp
+++ b/src/libstate/get_enc.cpp
@@ -146,7 +146,7 @@ EMSA* get_emsa(const std::string& algo_spec)
if(request.arg_count() == 1)
return new EMSA4(af.make_hash_function(request.arg(0)));
- if(request.arg_count() == 2 && request.arg_as_string(1) != "MGF1")
+ if(request.arg_count() == 2 && request.arg(1) != "MGF1")
return new EMSA4(af.make_hash_function(request.arg(0)));
if(request.arg_count() == 3)
@@ -179,7 +179,7 @@ EME* get_eme(const std::string& algo_spec)
if(request.algo_name() == "EME1" && request.arg_count_between(1, 2))
{
if(request.arg_count() == 1 ||
- (request.arg_count() == 2 && request.arg_as_string(1) == "MGF1"))
+ (request.arg_count() == 2 && request.arg(1) == "MGF1"))
{
return new EME1(af.make_hash_function(request.arg(0)));
}
@@ -213,7 +213,7 @@ KDF* get_kdf(const std::string& algo_spec)
#if defined(BOTAN_HAS_X942_PRF)
if(request.algo_name() == "X9.42-PRF" && request.arg_count() == 1)
- return new X942_PRF(request.arg_as_string(0)); // OID
+ return new X942_PRF(request.arg(0)); // OID
#endif
#if defined(BOTAN_HAS_TLS_V10_PRF)
diff --git a/src/pbe/get_pbe.cpp b/src/pbe/get_pbe.cpp
index 985f61cf8..5fa0291c8 100644
--- a/src/pbe/get_pbe.cpp
+++ b/src/pbe/get_pbe.cpp
@@ -27,8 +27,8 @@ PBE* get_pbe(const std::string& algo_spec)
SCAN_Name request(algo_spec);
const std::string pbe = request.algo_name();
- SCAN_Name digest_name = request.arg(0);
- const std::string cipher = request.arg_as_string(1);
+ std::string digest_name = request.arg(0);
+ const std::string cipher = request.arg(1);
std::vector<std::string> cipher_spec = split_on(cipher, '/');
if(cipher_spec.size() != 2)
@@ -48,7 +48,7 @@ PBE* get_pbe(const std::string& algo_spec)
const HashFunction* hash_function = af.make_hash_function(digest_name);
if(!hash_function)
- throw Algorithm_Not_Found(digest_name.as_string());
+ throw Algorithm_Not_Found(digest_name);
if(request.arg_count() != 2)
throw Invalid_Algorithm_Name(algo_spec);
@@ -84,8 +84,8 @@ PBE* get_pbe(const OID& pbe_oid, DataSource& params)
if(request.arg_count() != 2)
throw Invalid_Algorithm_Name(request.as_string());
- SCAN_Name digest_name = request.arg(0);
- const std::string cipher = request.arg_as_string(1);
+ std::string digest_name = request.arg(0);
+ const std::string cipher = request.arg(1);
std::vector<std::string> cipher_spec = split_on(cipher, '/');
if(cipher_spec.size() != 2)
@@ -105,7 +105,7 @@ PBE* get_pbe(const OID& pbe_oid, DataSource& params)
const HashFunction* hash_function = af.make_hash_function(digest_name);
if(!hash_function)
- throw Algorithm_Not_Found(digest_name.as_string());
+ throw Algorithm_Not_Found(digest_name);
PBE* pbe = new PBE_PKCS5v15(block_cipher->clone(),
hash_function->clone(),
diff --git a/src/pbe/pbes2/pbes2.cpp b/src/pbe/pbes2/pbes2.cpp
index 25be6f98a..3935bd702 100644
--- a/src/pbe/pbes2/pbes2.cpp
+++ b/src/pbe/pbes2/pbes2.cpp
@@ -176,7 +176,7 @@ void PBE_PKCS5v20::decode_params(DataSource& source)
BER_Decoder(enc_algo.parameters).decode(iv, OCTET_STRING).verify_end();
block_cipher = af.make_block_cipher(cipher_spec[0]);
- hash_function = af.make_hash_function(SCAN_Name("SHA-160"));
+ hash_function = af.make_hash_function("SHA-160");
if(key_length == 0)
key_length = block_cipher->MAXIMUM_KEYLENGTH;
diff --git a/src/selftest/selftest.cpp b/src/selftest/selftest.cpp
index f18ab5f7e..4222dc3c9 100644
--- a/src/selftest/selftest.cpp
+++ b/src/selftest/selftest.cpp
@@ -80,7 +80,7 @@ bool passes_self_tests(Algorithm_Factory& af)
{
try
{
- if(const BlockCipher* proto = af.prototype_block_cipher(SCAN_Name("DES")))
+ if(const BlockCipher* proto = af.prototype_block_cipher("DES"))
{
cipher_kat(proto,
"0123456789ABCDEF", "1234567890ABCDEF",
@@ -92,7 +92,7 @@ bool passes_self_tests(Algorithm_Factory& af)
"F3096249C7F46E51163A8CA0FFC94C27FA2F80F480B86F75");
}
- if(const BlockCipher* proto = af.prototype_block_cipher(SCAN_Name("TripleDES")))
+ if(const BlockCipher* proto = af.prototype_block_cipher("TripleDES"))
{
cipher_kat(proto,
"385D7189A5C3D485E1370AA5D408082B5CCCCB5E19F2D90E",
@@ -105,7 +105,7 @@ bool passes_self_tests(Algorithm_Factory& af)
"E26BA806A59B03303C62C2EFF32D3ACDD5D5F35EBCC53371");
}
- if(const BlockCipher* proto = af.prototype_block_cipher(SCAN_Name("AES")))
+ if(const BlockCipher* proto = af.prototype_block_cipher("AES"))
{
cipher_kat(proto,
"2B7E151628AED2A6ABF7158809CF4F3C",
@@ -124,7 +124,7 @@ bool passes_self_tests(Algorithm_Factory& af)
"010C041999E03F36448624483E582D0E");
}
- if(const HashFunction* proto = af.prototype_hash_function(SCAN_Name("SHA-1")))
+ if(const HashFunction* proto = af.prototype_hash_function("SHA-1"))
{
do_kat("", "DA39A3EE5E6B4B0D3255BFEF95601890AFD80709",
proto->name(), new Hash_Filter(proto->clone()));
@@ -144,7 +144,7 @@ bool passes_self_tests(Algorithm_Factory& af)
SymmetricKey("0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B")));
}
- if(const HashFunction* proto = af.prototype_hash_function(SCAN_Name("SHA-256")))
+ if(const HashFunction* proto = af.prototype_hash_function("SHA-256"))
{
do_kat("",
"E3B0C44298FC1C149AFBF4C8996FB924"
diff --git a/src/utils/scan_name.cpp b/src/utils/scan_name.cpp
index f5a1a9245..c0e931e14 100644
--- a/src/utils/scan_name.cpp
+++ b/src/utils/scan_name.cpp
@@ -40,11 +40,9 @@ parse_and_deref_aliases(const std::string& algo_spec)
}
-SCAN_Name::SCAN_Name(const std::string& algo_spec,
- const std::string& provider)
+SCAN_Name::SCAN_Name(const std::string& algo_spec)
{
orig_algo_spec = algo_spec;
- m_provider = provider;
name = parse_and_deref_aliases(algo_spec);
@@ -52,15 +50,7 @@ SCAN_Name::SCAN_Name(const std::string& algo_spec,
throw Decoding_Error("Bad SCAN name " + algo_spec);
}
-SCAN_Name SCAN_Name::arg(u32bit i) const
- {
- if(i > arg_count())
- throw std::range_error("SCAN_Name::argument");
-
- return SCAN_Name(name[i+1], m_provider);
- }
-
-std::string SCAN_Name::arg_as_string(u32bit i) const
+std::string SCAN_Name::arg(u32bit i) const
{
if(i > arg_count())
throw std::range_error("SCAN_Name::argument");
diff --git a/src/utils/scan_name.h b/src/utils/scan_name.h
index b01411c94..4e391c37d 100644
--- a/src/utils/scan_name.h
+++ b/src/utils/scan_name.h
@@ -22,10 +22,8 @@ class SCAN_Name
public:
/**
@param algo_spec A SCAN name
- @param providers An optional provider name
*/
- SCAN_Name(const std::string& algo_spec,
- const std::string& providers = "");
+ SCAN_Name(const std::string& algo_spec);
/**
@return the original input string
@@ -33,11 +31,6 @@ class SCAN_Name
std::string as_string() const { return orig_algo_spec; }
/**
- @return the provider name (or empty)
- */
- std::string provider() const { return m_provider; }
-
- /**
@return the algorithm name
*/
std::string algo_name() const { return name[0]; }
@@ -48,15 +41,6 @@ class SCAN_Name
u32bit arg_count() const { return name.size() - 1; }
/**
- @param provider a provider name
- @returns if this provider was allowed by the request
- */
- bool provider_allowed(const std::string& provider) const
- {
- return (m_provider == "" || m_provider == provider);
- }
-
- /**
@return if the number of arguments is between lower and upper
*/
bool arg_count_between(u32bit lower, u32bit upper) const
@@ -66,13 +50,7 @@ class SCAN_Name
@param i which argument
@return the ith argument
*/
- std::string arg_as_string(u32bit i) const;
-
- /**
- @param i which argument
- @return the ith argument
- */
- SCAN_Name arg(u32bit i) const;
+ std::string arg(u32bit i) const;
/**
@param i which argument
@@ -80,7 +58,7 @@ class SCAN_Name
*/
u32bit arg_as_u32bit(u32bit i, u32bit def_value) const;
private:
- std::string orig_algo_spec, m_provider;
+ std::string orig_algo_spec;
std::vector<std::string> name;
};