1 /* 2 * (C) 2014,2015 Jack Lloyd 3 * 4 * Botan is released under the Simplified BSD License (see license.txt) 5 */ 6 7 #ifndef BOTAN_TEST_PUBKEY_H_ 8 #define BOTAN_TEST_PUBKEY_H_ 9 10 #include "tests.h" 11 12 #include "test_rng.h" 13 14 #if defined(BOTAN_HAS_PUBLIC_KEY_CRYPTO) 15 16 #include <botan/pubkey.h> 17 18 namespace Botan_Tests { 19 20 class PK_Test : public Text_Based_Test 21 { 22 public: 23 PK_Test(const std::string& algo, 24 const std::string& test_src, 25 const std::string& required_keys, 26 const std::string& optional_keys = {}) Text_Based_Test(test_src,required_keys,optional_keys)27 : Text_Based_Test(test_src, required_keys, optional_keys), m_algo(algo) {} 28 algo_name()29 std::string algo_name() const 30 { 31 return m_algo; 32 } 33 34 protected: 35 std::vector<std::string> possible_providers(const std::string& params) override; 36 default_padding(const VarMap &)37 virtual std::string default_padding(const VarMap&) const 38 { 39 throw Test_Error("No default padding scheme set for " + algo_name()); 40 } 41 42 virtual std::string choose_padding(const VarMap& vars, 43 const std::string& pad_hdr); 44 45 private: 46 std::string m_algo; 47 }; 48 49 class PK_Signature_Generation_Test : public PK_Test 50 { 51 public: 52 PK_Signature_Generation_Test(const std::string& algo, 53 const std::string& test_src, 54 const std::string& required_keys, 55 const std::string& optional_keys = "") PK_Test(algo,test_src,required_keys,optional_keys)56 : PK_Test(algo, test_src, required_keys, optional_keys) {} 57 58 59 virtual std::unique_ptr<Botan::Private_Key> load_private_key(const VarMap& vars) = 0; 60 test_rng(const std::vector<uint8_t> & nonce)61 virtual Botan::RandomNumberGenerator* test_rng(const std::vector<uint8_t>& nonce) const 62 { 63 return new Fixed_Output_RNG(nonce); 64 } 65 66 private: 67 Test::Result run_one_test(const std::string&, const VarMap& vars) override final; 68 }; 69 70 class PK_Signature_Verification_Test : public PK_Test 71 { 72 public: 73 PK_Signature_Verification_Test(const std::string& algo, 74 const std::string& test_src, 75 const std::string& required_keys, 76 const std::string& optional_keys = "") PK_Test(algo,test_src,required_keys,optional_keys)77 : PK_Test(algo, test_src, required_keys, optional_keys) {} 78 79 virtual Botan::Signature_Format sig_format() const; 80 test_random_invalid_sigs()81 virtual bool test_random_invalid_sigs() const { return true; } 82 83 virtual std::unique_ptr<Botan::Public_Key> load_public_key(const VarMap& vars) = 0; 84 private: 85 Test::Result run_one_test(const std::string& header, const VarMap& vars) override final; 86 }; 87 88 class PK_Signature_NonVerification_Test : public PK_Test 89 { 90 public: 91 PK_Signature_NonVerification_Test(const std::string& algo, 92 const std::string& test_src, 93 const std::string& required_keys, 94 const std::string& optional_keys = "") PK_Test(algo,test_src,required_keys,optional_keys)95 : PK_Test(algo, test_src, required_keys, optional_keys) {} 96 clear_between_callbacks()97 bool clear_between_callbacks() const override 98 { 99 return false; 100 } 101 102 virtual std::unique_ptr<Botan::Public_Key> load_public_key(const VarMap& vars) = 0; 103 private: 104 Test::Result run_one_test(const std::string& header, const VarMap& vars) override final; 105 }; 106 107 class PK_Sign_Verify_DER_Test : public Test 108 { 109 public: PK_Sign_Verify_DER_Test(const std::string & algo,const std::string & padding)110 PK_Sign_Verify_DER_Test(const std::string& algo, 111 const std::string& padding) 112 : m_algo(algo), m_padding(padding) {} 113 algo_name()114 std::string algo_name() const 115 { 116 return m_algo; 117 } 118 119 protected: 120 std::vector<Test::Result> run() override final; 121 122 virtual std::unique_ptr<Botan::Private_Key> key() const = 0; 123 test_random_invalid_sigs()124 virtual bool test_random_invalid_sigs() const { return true; } 125 126 std::vector<std::string> possible_providers(const std::string& params) override; 127 128 private: 129 std::string m_algo; 130 std::string m_padding; 131 }; 132 133 class PK_Encryption_Decryption_Test : public PK_Test 134 { 135 public: 136 PK_Encryption_Decryption_Test(const std::string& algo, 137 const std::string& test_src, 138 const std::string& required_keys, 139 const std::string& optional_keys = "") PK_Test(algo,test_src,required_keys,optional_keys)140 : PK_Test(algo, test_src, required_keys, optional_keys) {} 141 142 virtual std::unique_ptr<Botan::Private_Key> load_private_key(const VarMap& vars) = 0; 143 default_padding(const VarMap &)144 std::string default_padding(const VarMap&) const override 145 { 146 return "Raw"; 147 } 148 test_rng(const std::vector<uint8_t> & nonce)149 virtual Botan::RandomNumberGenerator* test_rng(const std::vector<uint8_t>& nonce) const 150 { 151 return new Fixed_Output_RNG(nonce); 152 } 153 154 private: 155 Test::Result run_one_test(const std::string& header, const VarMap& vars) override final; 156 }; 157 158 class PK_Decryption_Test : public PK_Test 159 { 160 public: 161 PK_Decryption_Test(const std::string& algo, 162 const std::string& test_src, 163 const std::string& required_keys, 164 const std::string& optional_keys = "") PK_Test(algo,test_src,required_keys,optional_keys)165 : PK_Test(algo, test_src, required_keys, optional_keys) {} 166 167 virtual std::unique_ptr<Botan::Private_Key> load_private_key(const VarMap& vars) = 0; 168 default_padding(const VarMap &)169 std::string default_padding(const VarMap&) const override 170 { 171 return "Raw"; 172 } 173 174 private: 175 Test::Result run_one_test(const std::string& header, const VarMap& vars) override final; 176 }; 177 178 class PK_Key_Agreement_Test : public PK_Test 179 { 180 public: 181 PK_Key_Agreement_Test(const std::string& algo, 182 const std::string& test_src, 183 const std::string& required_keys, 184 const std::string& optional_keys = "") PK_Test(algo,test_src,required_keys,optional_keys)185 : PK_Test(algo, test_src, required_keys, optional_keys) {} 186 187 virtual std::unique_ptr<Botan::Private_Key> load_our_key(const std::string& header, 188 const VarMap& vars) = 0; 189 190 virtual std::vector<uint8_t> load_their_key(const std::string& header, 191 const VarMap& vars) = 0; 192 default_kdf(const VarMap &)193 virtual std::string default_kdf(const VarMap&) const 194 { 195 return "Raw"; 196 } 197 198 private: 199 Test::Result run_one_test(const std::string& header, const VarMap& vars) override final; 200 }; 201 202 class PK_KEM_Test : public PK_Test 203 { 204 public: 205 PK_KEM_Test(const std::string& algo, 206 const std::string& test_src, 207 const std::string& required_keys, 208 const std::string& optional_keys = "") PK_Test(algo,test_src,required_keys,optional_keys)209 : PK_Test(algo, test_src, required_keys, optional_keys) {} 210 211 virtual std::unique_ptr<Botan::Private_Key> load_private_key(const VarMap& vars) = 0; 212 private: 213 Test::Result run_one_test(const std::string& header, const VarMap& vars) override final; 214 }; 215 216 class PK_Key_Generation_Test : public Test 217 { 218 protected: 219 std::vector<Test::Result> run() override final; 220 221 virtual std::vector<std::string> keygen_params() const = 0; 222 223 virtual std::string algo_name() const = 0; 224 225 std::vector<std::string> possible_providers(const std::string& params) override; 226 }; 227 228 void check_invalid_signatures(Test::Result& result, 229 Botan::PK_Verifier& verifier, 230 const std::vector<uint8_t>& message, 231 const std::vector<uint8_t>& signature); 232 233 void check_invalid_ciphertexts(Test::Result& result, 234 Botan::PK_Decryptor& decryptor, 235 const std::vector<uint8_t>& plaintext, 236 const std::vector<uint8_t>& ciphertext); 237 238 } 239 240 #endif 241 242 #endif 243