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