Remove Algo_Registry usage from public key code.

Instead the key types exposes operations like `create_encryption_op`
which will return the relevant operation if the algorithm supports it.

Changes pubkey.h interface, now RNG is passed at init time.
Blinder previous created its own RNG, now it takes it from app.

9 files changed, 38 insertions, 38 deletions

diff --git a/src/tests/test_c25519.cpp b/src/tests/test_c25519.cpp
index 67e2104c3..fcf63a0be 100644
--- a/src/tests/test_c25519.cpp
+++ b/src/tests/test_c25519.cpp
@@ -83,8 +83,8 @@ class Curve25519_Roundtrip_Test : public Test
 
             if(a_pub_key && b_pub_key)
                {
-               Botan::PK_Key_Agreement a_ka(*a_priv, "KDF2(SHA-256)");
-               Botan::PK_Key_Agreement b_ka(*b_priv, "KDF2(SHA-256)");
+               Botan::PK_Key_Agreement a_ka(*a_priv, Test::rng(), "KDF2(SHA-256)");
+               Botan::PK_Key_Agreement b_ka(*b_priv, Test::rng(), "KDF2(SHA-256)");
 
                const std::string context = "shared context value";
                Botan::SymmetricKey a_key = a_ka.derive_key(32, b_pub_key->public_value(), context);
diff --git a/src/tests/test_dh.cpp b/src/tests/test_dh.cpp
index e82ce522a..8724d92fb 100644
--- a/src/tests/test_dh.cpp
+++ b/src/tests/test_dh.cpp
@@ -66,7 +66,7 @@ class Diffie_Hellman_KAT_Tests : public PK_Key_Agreement_Test
          const Botan::BigInt x("46205663093589612668746163860870963912226379131190812163519349848291472898748");
          std::unique_ptr<Private_Key> privkey(new DH_PrivateKey(Test::rng(), grp, x));
 
-         std::unique_ptr<PK_Key_Agreement> kas(new PK_Key_Agreement(*privkey, "Raw"));
+         std::unique_ptr<PK_Key_Agreement> kas(new PK_Key_Agreement(*privkey, rng(), "Raw"));
 
          result.test_throws("agreement input too big", [&kas]()
             {
diff --git a/src/tests/test_dlies.cpp b/src/tests/test_dlies.cpp
index 2aa9b9b70..4ef3bc2ed 100644
--- a/src/tests/test_dlies.cpp
+++ b/src/tests/test_dlies.cpp
@@ -76,8 +76,8 @@ class DLIES_KAT_Tests : public Text_Based_Test
          Botan::DH_PrivateKey from(Test::rng(), domain, x1);
          Botan::DH_PrivateKey to(Test::rng(), domain, x2);
 
-         Botan::DLIES_Encryptor encryptor(from, kdf->clone(), enc.release(), cipher_key_len, mac->clone(), mac_key_len);
-         Botan::DLIES_Decryptor decryptor(to, kdf.release(), dec.release(), cipher_key_len, mac.release(), mac_key_len);
+         Botan::DLIES_Encryptor encryptor(from, Test::rng(), kdf->clone(), enc.release(), cipher_key_len, mac->clone(), mac_key_len);
+         Botan::DLIES_Decryptor decryptor(to, Test::rng(), kdf.release(), dec.release(), cipher_key_len, mac.release(), mac_key_len);
 
          if(!iv.empty())
             {
@@ -133,7 +133,7 @@ Test::Result test_xor()
             continue;
             }
 
-         Botan::DLIES_Encryptor encryptor(alice, kdf->clone(), mac->clone(), mac_key_len);
+         Botan::DLIES_Encryptor encryptor(alice, Test::rng(), kdf->clone(), mac->clone(), mac_key_len);
 
          // negative test: other pub key not set
          Botan::secure_vector<byte> plaintext = Test::rng().random_vec(32);
@@ -146,7 +146,7 @@ Test::Result test_xor()
          encryptor.set_other_key(bob.public_value());
          std::vector<byte> ciphertext = encryptor.encrypt(plaintext, Test::rng());
 
-         Botan::DLIES_Decryptor decryptor(bob, kdf->clone(), mac->clone(), mac_key_len);
+         Botan::DLIES_Decryptor decryptor(bob, Test::rng(), kdf->clone(), mac->clone(), mac_key_len);
 
          // negative test: ciphertext too short
          result.test_throws("ciphertext too short", [ &decryptor ]()
diff --git a/src/tests/test_mceliece.cpp b/src/tests/test_mceliece.cpp
index 5e3501b3e..0ffed8176 100644
--- a/src/tests/test_mceliece.cpp
+++ b/src/tests/test_mceliece.cpp
@@ -81,8 +81,8 @@ class McEliece_Keygen_Encrypt_Test : public Text_Based_Test
 
          try
             {
-            Botan::PK_KEM_Encryptor kem_enc(mce_priv, "KDF1(SHA-512)");
-            Botan::PK_KEM_Decryptor kem_dec(mce_priv, "KDF1(SHA-512)");
+            Botan::PK_KEM_Encryptor kem_enc(mce_priv, Test::rng(), "KDF1(SHA-512)");
+            Botan::PK_KEM_Decryptor kem_dec(mce_priv, Test::rng(), "KDF1(SHA-512)");
 
             Botan::secure_vector<byte> encap_key, prod_shared_key;
             kem_enc.encrypt(encap_key, prod_shared_key, 64, rng);
@@ -180,8 +180,8 @@ class McEliece_Tests : public Test
          {
          Test::Result result("McEliece KEM");
 
-         Botan::PK_KEM_Encryptor enc_op(pk, "KDF2(SHA-256)");
-         Botan::PK_KEM_Decryptor dec_op(sk, "KDF2(SHA-256)");
+         Botan::PK_KEM_Encryptor enc_op(pk, Test::rng(), "KDF2(SHA-256)");
+         Botan::PK_KEM_Decryptor dec_op(sk, Test::rng(), "KDF2(SHA-256)");
 
          for(size_t i = 0; i <= Test::soak_level(); i++)
             {
diff --git a/src/tests/test_pubkey.cpp b/src/tests/test_pubkey.cpp
index c7bd8f932..04fa6292f 100644
--- a/src/tests/test_pubkey.cpp
+++ b/src/tests/test_pubkey.cpp
@@ -102,7 +102,7 @@ PK_Signature_Generation_Test::run_one_test(const std::string&, const VarMap& var
 
       try
          {
-         signer.reset(new Botan::PK_Signer(*privkey, padding, Botan::IEEE_1363, sign_provider));
+         signer.reset(new Botan::PK_Signer(*privkey, Test::rng(), padding, Botan::IEEE_1363, sign_provider));
          }
       catch(Botan::Lookup_Error&)
          {
@@ -130,7 +130,7 @@ PK_Signature_Generation_Test::run_one_test(const std::string&, const VarMap& var
 
          try
             {
-            verifier.reset(new Botan::PK_Verifier(*pubkey, padding, Botan::IEEE_1363, verify_provider));
+            verifier.reset(new Botan::PK_Verifier(*pubkey, Test::rng(), padding, Botan::IEEE_1363, verify_provider));
             }
          catch(Botan::Lookup_Error&)
             {
@@ -168,7 +168,7 @@ PK_Signature_Verification_Test::run_one_test(const std::string&, const VarMap& v
 
       try
          {
-         verifier.reset(new Botan::PK_Verifier(*pubkey, padding, Botan::IEEE_1363, verify_provider));
+         verifier.reset(new Botan::PK_Verifier(*pubkey, Test::rng(), padding, Botan::IEEE_1363, verify_provider));
          result.test_eq("correct signature valid", verifier->verify_message(message, signature), true);
          check_invalid_signatures(result, *verifier, message, signature);
          }
@@ -216,7 +216,7 @@ PK_Encryption_Decryption_Test::run_one_test(const std::string&, const VarMap& va
 
       try
          {
-         encryptor.reset(new Botan::PK_Encryptor_EME(*pubkey, padding, enc_provider));
+         encryptor.reset(new Botan::PK_Encryptor_EME(*pubkey, Test::rng(),padding, enc_provider));
          }
       catch(Botan::Lookup_Error&)
          {
@@ -245,7 +245,7 @@ PK_Encryption_Decryption_Test::run_one_test(const std::string&, const VarMap& va
 
          try
             {
-            decryptor.reset(new Botan::PK_Decryptor_EME(*privkey, padding, dec_provider));
+            decryptor.reset(new Botan::PK_Decryptor_EME(*privkey, Test::rng(), padding, dec_provider));
             }
          catch(Botan::Lookup_Error&)
             {
@@ -285,7 +285,7 @@ Test::Result PK_KEM_Test::run_one_test(const std::string&, const VarMap& vars)
    std::unique_ptr<Botan::PK_KEM_Encryptor> enc;
    try
       {
-      enc.reset(new Botan::PK_KEM_Encryptor(pubkey, kdf));
+      enc.reset(new Botan::PK_KEM_Encryptor(pubkey, Test::rng(), kdf));
       }
    catch(Botan::Lookup_Error&)
       {
@@ -308,7 +308,7 @@ Test::Result PK_KEM_Test::run_one_test(const std::string&, const VarMap& vars)
    std::unique_ptr<Botan::PK_KEM_Decryptor> dec;
    try
       {
-      dec.reset(new Botan::PK_KEM_Decryptor(*privkey, kdf));
+      dec.reset(new Botan::PK_KEM_Decryptor(*privkey, Test::rng(), kdf));
       }
    catch(Botan::Lookup_Error&)
       {
@@ -346,7 +346,7 @@ Test::Result PK_Key_Agreement_Test::run_one_test(const std::string& header, cons
 
       try
          {
-         kas.reset(new Botan::PK_Key_Agreement(*privkey, kdf, provider));
+         kas.reset(new Botan::PK_Key_Agreement(*privkey, Test::rng(), kdf, provider));
          result.test_eq(provider, "agreement", kas->derive_key(key_len, pubkey).bits_of(), shared);
          }
       catch(Botan::Lookup_Error&)
diff --git a/src/tests/unit_ecdh.cpp b/src/tests/unit_ecdh.cpp
index 40a10203a..83935a898 100644
--- a/src/tests/unit_ecdh.cpp
+++ b/src/tests/unit_ecdh.cpp
@@ -49,8 +49,8 @@ class ECDH_Unit_Tests : public Test
                Botan::ECDH_PrivateKey private_a(Test::rng(), dom_pars);
                Botan::ECDH_PrivateKey private_b(Test::rng(), dom_pars);
 
-               Botan::PK_Key_Agreement ka(private_a, "KDF2(SHA-512)");
-               Botan::PK_Key_Agreement kb(private_b, "KDF2(SHA-512)");
+               Botan::PK_Key_Agreement ka(private_a, Test::rng(), "KDF2(SHA-512)");
+               Botan::PK_Key_Agreement kb(private_b, Test::rng(), "KDF2(SHA-512)");
 
                Botan::SymmetricKey alice_key = ka.derive_key(32, private_b.public_value());
                Botan::SymmetricKey bob_key = kb.derive_key(32, private_a.public_value());
diff --git a/src/tests/unit_ecdsa.cpp b/src/tests/unit_ecdsa.cpp
index 421323fda..869ca7716 100644
--- a/src/tests/unit_ecdsa.cpp
+++ b/src/tests/unit_ecdsa.cpp
@@ -58,17 +58,17 @@ Test::Result test_hash_larger_than_n()
       return result;
       }
 
-   Botan::PK_Signer pk_signer_160(priv_key, "EMSA1(SHA-1)");
-   Botan::PK_Verifier pk_verifier_160(priv_key, "EMSA1(SHA-1)");
+   Botan::PK_Signer pk_signer_160(priv_key, Test::rng(), "EMSA1(SHA-1)");
+   Botan::PK_Verifier pk_verifier_160(priv_key, Test::rng(), "EMSA1(SHA-1)");
 
    // Verify we can sign and verify with SHA-160
    std::vector<byte> signature_160 = pk_signer_160.sign_message(message, Test::rng());
    result.test_eq("message verifies", pk_verifier_160.verify_message(message, signature_160), true);
 
    // Verify we can sign and verify with SHA-224
-   Botan::PK_Signer pk_signer(priv_key, "EMSA1(SHA-224)");
+   Botan::PK_Signer pk_signer(priv_key, Test::rng(), "EMSA1(SHA-224)");
    std::vector<byte> signature = pk_signer.sign_message(message, Test::rng());
-   Botan::PK_Verifier pk_verifier(priv_key, "EMSA1(SHA-224)");
+   Botan::PK_Verifier pk_verifier(priv_key, Test::rng(), "EMSA1(SHA-224)");
    result.test_eq("message verifies", pk_verifier.verify_message(message, signature), true);
 
    return result;
@@ -122,12 +122,12 @@ Test::Result test_sign_then_ver()
    Botan::EC_Group dom_pars(Botan::OID("1.3.132.0.8"));
    Botan::ECDSA_PrivateKey ecdsa(Test::rng(), dom_pars);
 
-   Botan::PK_Signer signer(ecdsa, "EMSA1(SHA-256)");
+   Botan::PK_Signer signer(ecdsa, Test::rng(), "EMSA1(SHA-256)");
 
    auto msg = Botan::hex_decode("12345678901234567890abcdef12");
    std::vector<byte> sig = signer.sign_message(msg, Test::rng());
 
-   Botan::PK_Verifier verifier(ecdsa, "EMSA1(SHA-256)");
+   Botan::PK_Verifier verifier(ecdsa, Test::rng(), "EMSA1(SHA-256)");
 
    result.confirm("signature verifies", verifier.verify_message(msg, sig));
 
@@ -144,8 +144,8 @@ Test::Result test_ec_sign()
       {
       Botan::EC_Group dom_pars(Botan::OID("1.3.132.0.8"));
       Botan::ECDSA_PrivateKey priv_key(Test::rng(), dom_pars);
-      Botan::PK_Signer signer(priv_key, "EMSA1(SHA-224)");
-      Botan::PK_Verifier verifier(priv_key, "EMSA1(SHA-224)");
+      Botan::PK_Signer signer(priv_key, Test::rng(), "EMSA1(SHA-224)");
+      Botan::PK_Verifier verifier(priv_key, Test::rng(), "EMSA1(SHA-224)");
 
       for(size_t i = 0; i != 256; ++i)
          {
@@ -197,7 +197,7 @@ Test::Result test_ecdsa_create_save_load()
       Botan::EC_Group dom_pars(Botan::OID("1.3.132.0.8"));
       Botan::ECDSA_PrivateKey key(Test::rng(), dom_pars);
 
-      Botan::PK_Signer signer(key, "EMSA1(SHA-256)");
+      Botan::PK_Signer signer(key, Test::rng(), "EMSA1(SHA-256)");
       msg_signature = signer.sign_message(msg, Test::rng());
 
       ecc_private_key_pem = Botan::PKCS8::PEM_encode(key);
@@ -212,7 +212,7 @@ Test::Result test_ecdsa_create_save_load()
    Botan::ECDSA_PrivateKey* loaded_ec_key = dynamic_cast<Botan::ECDSA_PrivateKey*>(loaded_key.get());
    result.confirm("the loaded key could be converted into an ECDSA_PrivateKey", loaded_ec_key);
 
-   Botan::PK_Verifier verifier(*loaded_ec_key, "EMSA1(SHA-256)");
+   Botan::PK_Verifier verifier(*loaded_ec_key, Test::rng(), "EMSA1(SHA-256)");
 
    result.confirm("generated signature valid", verifier.verify_message(msg, msg_signature));
 
@@ -260,8 +260,8 @@ Test::Result test_read_pkcs8()
       Botan::ECDSA_PrivateKey* ecdsa_nodp = dynamic_cast<Botan::ECDSA_PrivateKey*>(loaded_key_nodp.get());
       result.confirm("key loaded", ecdsa_nodp);
 
-      Botan::PK_Signer signer(*ecdsa_nodp, "EMSA1(SHA-256)");
-      Botan::PK_Verifier verifier(*ecdsa_nodp, "EMSA1(SHA-256)");
+      Botan::PK_Signer signer(*ecdsa_nodp, Test::rng(), "EMSA1(SHA-256)");
+      Botan::PK_Verifier verifier(*ecdsa_nodp, Test::rng(), "EMSA1(SHA-256)");
 
       std::vector<byte> signature_nodp = signer.sign_message(msg, Test::rng());
 
@@ -327,8 +327,8 @@ Test::Result test_curve_registry()
          Botan::EC_Group dom_pars(oid);
          Botan::ECDSA_PrivateKey ecdsa(Test::rng(), dom_pars);
 
-         Botan::PK_Signer signer(ecdsa, "EMSA1(SHA-256)");
-         Botan::PK_Verifier verifier(ecdsa, "EMSA1(SHA-256)");
+         Botan::PK_Signer signer(ecdsa, Test::rng(), "EMSA1(SHA-256)");
+         Botan::PK_Verifier verifier(ecdsa, Test::rng(), "EMSA1(SHA-256)");
 
          auto msg = Botan::hex_decode("12345678901234567890abcdef12");
          std::vector<byte> sig = signer.sign_message(msg, Test::rng());
diff --git a/src/tests/unit_tls.cpp b/src/tests/unit_tls.cpp
index f869f426b..445077490 100644
--- a/src/tests/unit_tls.cpp
+++ b/src/tests/unit_tls.cpp
@@ -145,7 +145,7 @@ Botan::Credentials_Manager* create_creds(Botan::RandomNumberGenerator& rng,
                                                             "SHA-256",
                                                             rng);
 
-   Botan::X509_CA ca(ca_cert, *ca_key, "SHA-256");
+   Botan::X509_CA ca(ca_cert, *ca_key, "SHA-256", Test::rng());
 
    auto now = std::chrono::system_clock::now();
    Botan::X509_Time start_time(now);
diff --git a/src/tests/unit_x509.cpp b/src/tests/unit_x509.cpp
index 4313e1373..35718d90d 100644
--- a/src/tests/unit_x509.cpp
+++ b/src/tests/unit_x509.cpp
@@ -289,7 +289,7 @@ Test::Result test_x509_cert(const std::string& sig_algo, const std::string& hash
                                    Test::rng());
 
    /* Create the CA object */
-   Botan::X509_CA ca(ca_cert, *ca_key, hash_fn);
+   Botan::X509_CA ca(ca_cert, *ca_key, hash_fn, Test::rng());
 
    /* Sign the requests to create the certs */
    Botan::X509_Certificate user1_cert =
@@ -408,7 +408,7 @@ Test::Result test_usage(const std::string& sig_algo, const std::string& hash_fn
                                            Test::rng());
 
    /* Create the CA object */
-   Botan::X509_CA ca(ca_cert, *ca_key, hash_fn);
+   Botan::X509_CA ca(ca_cert, *ca_key, hash_fn, Test::rng());
 
    std::unique_ptr<Botan::Private_Key> user1_key(make_a_private_key(sig_algo));