Handle dependencies re static linking. GH #279

Previously we were hanging on the type destructors to pull in
the relevant objects. However that fails in many simple cases
where the object is never deleted.

For every type involved in the algo registry add static create
and providers functions to access the algo registry. Modify
lookup.h to be inline and call those functions, and move
a few to sub-headers (eg, get_pbkdf going to pbkdf.h). So
accessing the registry involves going through the same file
that handles the initialization, so there is no way to end up
with missing objs.

2 files changed, 42 insertions, 1 deletions

diff --git a/src/lib/pbkdf/pbkdf.cpp b/src/lib/pbkdf/pbkdf.cpp
index f11fbc44d..6d7a6542f 100644
--- a/src/lib/pbkdf/pbkdf.cpp
+++ b/src/lib/pbkdf/pbkdf.cpp
@@ -30,6 +30,19 @@ BOTAN_REGISTER_PBKDF_1HASH(PKCS5_PBKDF1, "PBKDF1");
 BOTAN_REGISTER_NAMED_T(PBKDF, "PBKDF2", PKCS5_PBKDF2, PKCS5_PBKDF2::make);
 #endif
 
+PBKDF::~PBKDF() {}
+
+std::unique_ptr<PBKDF> PBKDF::create(const std::string& algo_spec,
+                                     const std::string& provider)
+   {
+   return std::unique_ptr<PBKDF>(make_a<PBKDF>(algo_spec, provider));
+   }
+
+std::vector<std::string> PBKDF::providers(const std::string& algo_spec)
+   {
+   return providers_of<PBKDF>(PBKDF::Spec(algo_spec));
+   }
+
 void PBKDF::pbkdf_timed(byte out[], size_t out_len,
                         const std::string& passphrase,
                         const byte salt[], size_t salt_len,
diff --git a/src/lib/pbkdf/pbkdf.h b/src/lib/pbkdf/pbkdf.h
index 5f6cd904c..1a1299c75 100644
--- a/src/lib/pbkdf/pbkdf.h
+++ b/src/lib/pbkdf/pbkdf.h
@@ -10,6 +10,8 @@
 
 #include <botan/symkey.h>
 #include <botan/scan_name.h>
+#include <botan/scan_name.h>
+#include <botan/exceptn.h>
 #include <chrono>
 
 namespace Botan {
@@ -22,8 +24,18 @@ namespace Botan {
 class BOTAN_DLL PBKDF
    {
    public:
+      /**
+      * Create an instance based on a name
+      * Will return a null pointer if the algo/provider combination cannot
+      * be found. If providers is empty then best available is chosen.
+      */
+      static std::unique_ptr<PBKDF> create(const std::string& algo_spec,
+                                           const std::string& provider = "");
 
-      virtual ~PBKDF() {}
+      /**
+      * Returns the list of available providers for this algorithm, empty if not available
+      */
+      static std::vector<std::string> providers(const std::string& algo_spec);
 
       typedef SCAN_Name Spec;
 
@@ -34,6 +46,8 @@ class BOTAN_DLL PBKDF
 
       virtual std::string name() const = 0;
 
+      virtual ~PBKDF();
+
       /**
       * Derive a key from a passphrase for a number of iterations
       * specified by either iterations or if iterations == 0 then
@@ -147,6 +161,20 @@ class BOTAN_DLL PBKDF
          }
    };
 
+/**
+* Password based key derivation function factory method
+* @param algo_spec the name of the desired PBKDF algorithm
+* @return pointer to newly allocated object of that type
+*/
+inline PBKDF* get_pbkdf(const std::string& algo_spec,
+                           const std::string& provider = "")
+   {
+   std::unique_ptr<PBKDF> p(PBKDF::create(algo_spec, provider));
+   if(p)
+      return p.release();
+   throw Algorithm_Not_Found(algo_spec);
+   }
+
 }
 
 #endif