Merge GH #1022 Support CBC ciphers via OpenSSL

1 files changed, 84 insertions, 66 deletions

diff --git a/src/tests/test_modes.cpp b/src/tests/test_modes.cpp
index 480b15527..63edba5f1 100644
--- a/src/tests/test_modes.cpp
+++ b/src/tests/test_modes.cpp
@@ -22,6 +22,11 @@ class Cipher_Mode_Tests : public Text_Based_Test
          Text_Based_Test("modes", "Key,Nonce,In,Out")
          {}
 
+      std::vector<std::string> possible_providers(const std::string& algo) override
+         {
+         return provider_filter(Botan::Cipher_Mode::providers(algo));
+         }
+
       Test::Result run_one_test(const std::string& algo, const VarMap& vars) override
          {
          const std::vector<uint8_t> key      = get_req_bin(vars, "Key");
@@ -31,102 +36,115 @@ class Cipher_Mode_Tests : public Text_Based_Test
 
          Test::Result result(algo);
 
-         std::unique_ptr<Botan::Cipher_Mode> enc(Botan::get_cipher_mode(algo, Botan::ENCRYPTION));
-         std::unique_ptr<Botan::Cipher_Mode> dec(Botan::get_cipher_mode(algo, Botan::DECRYPTION));
+         const std::vector<std::string> providers = possible_providers(algo);
 
-         if(!enc || !dec)
+         if(providers.empty())
             {
-            result.note_missing(algo);
+            result.note_missing("cipher mode " + algo);
             return result;
             }
 
-         result.test_is_nonempty("provider", enc->provider());
-         result.test_eq("name", enc->name(), algo);
-
-         result.test_eq("mode not authenticated", enc->authenticated(), false);
+         for(auto&& provider_ask : providers)
+            {
+            std::unique_ptr<Botan::Cipher_Mode> enc(Botan::get_cipher_mode(
+               algo, Botan::ENCRYPTION, provider_ask));
+            std::unique_ptr<Botan::Cipher_Mode> dec(Botan::get_cipher_mode(
+               algo, Botan::DECRYPTION, provider_ask));
 
-         // Test to make sure reset() resets what we need it to
-         enc->set_key(mutate_vec(key));
-         Botan::secure_vector<uint8_t> garbage = Test::rng().random_vec(enc->update_granularity());
-         enc->start(mutate_vec(nonce));
-         enc->update(garbage);
+            if(!enc || !dec)
+               {
+               result.note_missing(algo);
+               return result;
+               }
 
-         enc->reset();
+            result.test_is_nonempty("provider", enc->provider());
+            result.test_eq("name", enc->name(), algo);
 
-         enc->set_key(key);
-         enc->start(nonce);
+            result.test_eq("mode not authenticated", enc->authenticated(), false);
 
-         Botan::secure_vector<uint8_t> buf(input.begin(), input.end());
-         // TODO: should first update if possible
-         enc->finish(buf);
-         result.test_eq("encrypt", buf, expected);
+            // Test to make sure reset() resets what we need it to
+            enc->set_key(mutate_vec(key));
+            Botan::secure_vector<uint8_t> garbage = Test::rng().random_vec(enc->update_granularity());
+            enc->start(mutate_vec(nonce));
+            enc->update(garbage);
 
-         // additionally test process() if possible
-         size_t update_granularity = enc->update_granularity();
-         size_t input_length = input.size();
-         size_t min_final_bytes = enc->minimum_final_size();
-         if(input_length > (update_granularity + min_final_bytes))
-            {
-            // reset state first
             enc->reset();
 
+            enc->set_key(key);
             enc->start(nonce);
-            buf.assign(input.begin(), input.end());
 
-            // we can process at max input_length
-            const size_t max_blocks_to_process = (input_length - min_final_bytes) / update_granularity;
-            const size_t bytes_to_process = max_blocks_to_process * update_granularity;
+            Botan::secure_vector<uint8_t> buf(input.begin(), input.end());
+            // TODO: should first update if possible
+            enc->finish(buf);
+            result.test_eq("encrypt", buf, expected);
 
-            const size_t bytes_written = enc->process(buf.data(), bytes_to_process);
+            // additionally test process() if possible
+            size_t update_granularity = enc->update_granularity();
+            size_t input_length = input.size();
+            size_t min_final_bytes = enc->minimum_final_size();
+            if(input_length > (update_granularity + min_final_bytes))
+               {
+               // reset state first
+               enc->reset();
 
-            result.test_eq("correct number of bytes processed", bytes_written, bytes_to_process);
+               enc->start(nonce);
+               buf.assign(input.begin(), input.end());
 
-            enc->finish(buf, bytes_to_process);
-            result.test_eq("encrypt", buf, expected);
-            }
+               // we can process at max input_length
+               const size_t max_blocks_to_process = (input_length - min_final_bytes) / update_granularity;
+               const size_t bytes_to_process = max_blocks_to_process * update_granularity;
 
-         // decryption
-         buf.assign(expected.begin(), expected.end());
+               const size_t bytes_written = enc->process(buf.data(), bytes_to_process);
 
-         // Test to make sure reset() resets what we need it to
-         dec->set_key(mutate_vec(key));
-         garbage = Test::rng().random_vec(dec->update_granularity());
-         dec->start(mutate_vec(nonce));
-         dec->update(garbage);
+               result.test_eq("correct number of bytes processed", bytes_written, bytes_to_process);
 
-         dec->reset();
+               enc->finish(buf, bytes_to_process);
+               result.test_eq("encrypt", buf, expected);
+               }
 
-         dec->set_key(key);
-         dec->start(nonce);
-         dec->finish(buf);
-         result.test_eq("decrypt", buf, input);
+            // decryption
+            buf.assign(expected.begin(), expected.end());
+
+            // Test to make sure reset() resets what we need it to
+            dec->set_key(mutate_vec(key));
+            garbage = Test::rng().random_vec(dec->update_granularity());
+            dec->start(mutate_vec(nonce));
+            dec->update(garbage);
 
-         // additionally test process() if possible
-         update_granularity = dec->update_granularity();
-         input_length = expected.size();
-         min_final_bytes = dec->minimum_final_size();
-         if(input_length > (update_granularity + min_final_bytes))
-            {
-            // reset state first
             dec->reset();
 
+            dec->set_key(key);
             dec->start(nonce);
-            buf.assign(expected.begin(), expected.end());
+            dec->finish(buf);
+            result.test_eq("decrypt", buf, input);
 
-            // we can process at max input_length
-            const size_t max_blocks_to_process = (input_length - min_final_bytes) / update_granularity;
-            const size_t bytes_to_process = max_blocks_to_process * update_granularity;
+            // additionally test process() if possible
+            update_granularity = dec->update_granularity();
+            input_length = expected.size();
+            min_final_bytes = dec->minimum_final_size();
+            if(input_length > (update_granularity + min_final_bytes))
+               {
+               // reset state first
+               dec->reset();
 
-            const size_t bytes_written = dec->process(buf.data(), bytes_to_process);
+               dec->start(nonce);
+               buf.assign(expected.begin(), expected.end());
 
-            result.test_eq("correct number of bytes processed", bytes_written, bytes_to_process);
+               // we can process at max input_length
+               const size_t max_blocks_to_process = (input_length - min_final_bytes) / update_granularity;
+               const size_t bytes_to_process = max_blocks_to_process * update_granularity;
 
-            dec->finish(buf, bytes_to_process);
-            result.test_eq("decrypt", buf, input);
-            }
+               const size_t bytes_written = dec->process(buf.data(), bytes_to_process);
+
+               result.test_eq("correct number of bytes processed", bytes_written, bytes_to_process);
 
-         enc->clear();
-         dec->clear();
+               dec->finish(buf, bytes_to_process);
+               result.test_eq("decrypt", buf, input);
+               }
+
+            enc->clear();
+            dec->clear();
+            }
 
          return result;
          }