Make it actually possible to register a crypto impl

Jay Berkenbilt
1 parent 28a049a0
Showing 5 changed files with 135 additions and 13 deletions
include/qpdf/QPDFCryptoProvider.hh
libqpdf/QPDFCryptoProvider.cc
libtests/CMakeLists.txt
libtests/crypto_provider.cc
libtests/qtest/crypto_provider.test
@@ -46,10 +46,21 @@ class QPDFCryptoProvider
     QPDF_DLL
     static std::shared_ptr<QPDFCryptoImpl> getImpl(std::string const& name);
+    typedef std::function<std::shared_ptr<QPDFCryptoImpl>()> provider_fn;
+
+    // Register a crypto implementation with the given name. The provider function must return
+    // a shared pointer to an instance of the implementation class, which must be derived from
+    // QPDFCryptoImpl.
+    QPDF_DLL static void registerImpl(std::string const& name, provider_fn f);
+
     // Register the given type (T) as a crypto implementation. T must be derived from QPDFCryptoImpl
     // and must have a constructor that takes no arguments.
     template <typename T>
-    QPDF_DLL static void registerImpl(std::string const& name);
+    static void
+    registerImpl(std::string const& name)
+    {
+        registerImpl(name, std::make_shared<T>);
+    }
     // Set the crypto provider registered with the given name as the default crypto implementation.
     QPDF_DLL
@@ -72,8 +83,7 @@ class QPDFCryptoProvider
     static QPDFCryptoProvider& getInstance();
     std::shared_ptr<QPDFCryptoImpl> getImpl_internal(std::string const& name) const;
-    template <typename T>
-    void registerImpl_internal(std::string const& name);
+    void registerImpl_internal(std::string const& name, provider_fn f);
     void setDefaultProvider_internal(std::string const& name);
     class Members
@@ -89,7 +99,6 @@ class QPDFCryptoProvider
         Members(Members const&) = delete;
         Members& operator=(Members const&) = delete;
-        typedef std::function<std::shared_ptr<QPDFCryptoImpl>()> provider_fn;
         std::string default_provider;
         std::map<std::string, provider_fn> providers;
     };
@@ -30,11 +30,10 @@ QPDFCryptoProvider::getImpl(std::string const&amp; name)
     return getInstance().getImpl_internal(name);
 }
-template <typename T>
 void
-QPDFCryptoProvider::registerImpl(std::string const& name)
+QPDFCryptoProvider::registerImpl(std::string const& name, provider_fn f)
 {
-    getInstance().registerImpl_internal<T>(name);
+    getInstance().registerImpl_internal(name, std::move(f));
 }
 void
@@ -47,13 +46,13 @@ QPDFCryptoProvider::QPDFCryptoProvider() :
     m(std::make_shared<Members>())
 {
 #ifdef USE_CRYPTO_NATIVE
-    registerImpl_internal<QPDFCrypto_native>("native");
+    registerImpl_internal("native", std::make_shared<QPDFCrypto_native>);
 #endif
 #ifdef USE_CRYPTO_GNUTLS
-    registerImpl_internal<QPDFCrypto_gnutls>("gnutls");
+    registerImpl_internal("gnutls", std::make_shared<QPDFCrypto_gnutls>);
 #endif
 #ifdef USE_CRYPTO_OPENSSL
-    registerImpl_internal<QPDFCrypto_openssl>("openssl");
+    registerImpl_internal("openssl", std::make_shared<QPDFCrypto_openssl>);
 #endif
     std::string default_crypto;
     if (!QUtil::get_env("QPDF_CRYPTO_PROVIDER", &default_crypto)) {
@@ -80,11 +79,10 @@ QPDFCryptoProvider::getImpl_internal(std::string const&amp; name) const
     return m->providers[name]();
 }
-template <typename T>
 void
-QPDFCryptoProvider::registerImpl_internal(std::string const& name)
+QPDFCryptoProvider::registerImpl_internal(std::string const& name, provider_fn f)
 {
-    m->providers[name] = std::make_shared<T>;
+    m->providers[name] = std::move(f);
 }
 void
@@ -8,6 +8,7 @@ set(TEST_PROGRAMS
   buffer
   closed_file_input_source
   concatenate
+  crypto_provider
   dct_compress
   dct_uncompress
   flate
+#include <qpdf/assert_test.h>
+
+#include <qpdf/MD5.hh>
+#include <qpdf/QPDFCryptoImpl.hh>
+#include <qpdf/QPDFCryptoProvider.hh>
+#include <cstring>
+#include <iostream>
+
+// This is a dummy crypto implementation that only implements MD5 digest. It doesn't work, but
+// it enables us to exercise the wiring of registering, querying, and setting a crypto provider.
+class Potato: public QPDFCryptoImpl
+{
+  public:
+    void
+    provideRandomData(unsigned char* data, size_t len) override
+    {
+    }
+    void
+    MD5_init() override
+    {
+    }
+    void
+    MD5_update(const unsigned char* data, size_t len) override
+    {
+    }
+    void
+    MD5_finalize() override
+    {
+    }
+    void
+    MD5_digest(unsigned char* digest) override
+    {
+        std::memcpy(digest, "0123456789abcdef", sizeof(QPDFCryptoImpl::MD5_Digest));
+    }
+    void
+    SHA2_init(int bits) override
+    {
+    }
+    void
+    SHA2_update(const unsigned char* data, size_t len) override
+    {
+    }
+    void
+    SHA2_finalize() override
+    {
+    }
+    std::string
+    SHA2_digest() override
+    {
+        return std::string();
+    }
+    void
+    RC4_init(const unsigned char* key_data, int key_len) override
+    {
+    }
+    void
+    RC4_process(const unsigned char* in_data, size_t len, unsigned char* out_data) override
+    {
+    }
+    void
+    RC4_finalize() override
+    {
+    }
+    void
+    rijndael_init(
+        bool encrypt,
+        const unsigned char* key_data,
+        size_t key_len,
+        bool cbc_mode,
+        unsigned char* cbc_block) override
+    {
+    }
+    void
+    rijndael_process(unsigned char* in_data, unsigned char* out_data) override
+    {
+    }
+    void
+    rijndael_finalize() override
+    {
+    }
+};
+
+int
+main()
+{
+    auto initial = QPDFCryptoProvider::getDefaultProvider();
+    QPDFCryptoProvider::registerImpl<Potato>("potato");
+    QPDFCryptoProvider::setDefaultProvider("potato");
+    assert(QPDFCryptoProvider::getDefaultProvider() == "potato");
+    MD5 m;
+    m.encodeString("quack"); // anything
+    MD5::Digest d;
+    m.digest(d);
+    // hex for 0123456789abcdef
+    assert(m.unparse() == "30313233343536373839616263646566");
+    std::cout << "assertions passed\n";
+    return 0;
+}
+#!/usr/bin/env perl
+require 5.008;
+use warnings;
+use strict;
+
+require TestDriver;
+
+my $td = new TestDriver('crypto_provider');
+
+$td->runtest("QINTC",
+             {$td->COMMAND => "crypto_provider"},
+             {$td->STRING => "assertions passed\n",
+              $td->EXIT_STATUS => 0},
+             $td->NORMALIZE_NEWLINES);
+
+$td->report(1);