13089344942

Committed 01 Feb 2025 02:06PM UTC coverage: 91.224% (-0.003%) from 91.227%

Build # 13089344942

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #4622 from randombit/jack/cli-perf-keygen-fix

In public key perf tests exit early if keygen fails

Run Details

94169 of 103228 relevant lines covered (91.22%)

11304027.04 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

64.79

/src/cli/perf_pk_kem.cpp

/*
* (C) 2024 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include "perf.h"

#if defined(BOTAN_HAS_PUBLIC_KEY_CRYPTO)
   #include <botan/pk_algs.h>
   #include <botan/pubkey.h>
#endif

namespace Botan_CLI {

#if defined(BOTAN_HAS_PUBLIC_KEY_CRYPTO)

class PerfTest_PK_KEM : public PerfTest {
   public:
      virtual std::string algo() const = 0;

      virtual std::vector<std::string> keygen_params(const PerfConfig& config) const {
         BOTAN_UNUSED(config);
         return {""};
      }

      void go(const PerfConfig& config) override {
         const std::string alg = this->algo();

         const auto params = this->keygen_params(config);

         for(const auto& param : params) {
            const std::string nm = this->format_name(alg, param);
            bench_pk_kem(config, nm, alg, param);
         }
      }

      void bench_pk_kem(const PerfConfig& config,
                        const std::string& nm,
                        const std::string& algo,
                        const std::string& params,
                        const std::string& provider = "") {
         const auto msec = config.runtime();
         auto& rng = config.rng();

         const std::string kdf = "KDF2(SHA-256)";  // arbitrary choice

         auto keygen_timer = config.make_timer(nm, 1, "keygen");

         auto sk = keygen_timer->run([&] { return Botan::create_private_key(algo, rng, params); });

         if(sk) {
            while(keygen_timer->under(msec)) {
               sk = keygen_timer->run([&] { return Botan::create_private_key(algo, rng, params); });
            }

            auto pk = sk->public_key();

            Botan::PK_KEM_Decryptor dec(*sk, rng, kdf, provider);
            Botan::PK_KEM_Encryptor enc(*pk, kdf, provider);

            auto kem_enc_timer = config.make_timer(nm, 1, "KEM encrypt");
            auto kem_dec_timer = config.make_timer(nm, 1, "KEM decrypt");

            while(kem_enc_timer->under(msec) && kem_dec_timer->under(msec)) {
               Botan::secure_vector<uint8_t> salt = rng.random_vec(16);

               kem_enc_timer->start();
               const auto kem_result = enc.encrypt(rng, 64, salt);
               kem_enc_timer->stop();

               kem_dec_timer->start();
               Botan::secure_vector<uint8_t> dec_shared_key =
                  dec.decrypt(kem_result.encapsulated_shared_key(), 64, salt);
               kem_dec_timer->stop();

               if(kem_result.shared_key() != dec_shared_key) {
                  config.error_output() << "KEM mismatch in PK bench\n";
               }
            }
            config.record_result(*keygen_timer);
            config.record_result(*kem_enc_timer);
            config.record_result(*kem_dec_timer);
         }
      }
};

#endif

#if defined(BOTAN_HAS_KYBER) || defined(BOTAN_HAS_KYBER_90S)

class PerfTest_Kyber final : public PerfTest_PK_KEM {
   public:
      std::string algo() const override { return "Kyber"; }

      std::vector<std::string> keygen_params(const PerfConfig& config) const override {
         BOTAN_UNUSED(config);
         return {
            "Kyber-512-r3",
            "Kyber-512-90s-r3",
            "Kyber-768-r3",
            "Kyber-768-90s-r3",
            "Kyber-1024-r3",
            "Kyber-1024-90s-r3",
         };
      }
};

BOTAN_REGISTER_PERF_TEST("Kyber", PerfTest_Kyber);

#endif

#if defined(BOTAN_HAS_ML_KEM)

class PerfTest_ML_KEM final : public PerfTest_PK_KEM {
   public:
      std::string algo() const override { return "ML-KEM"; }

      std::vector<std::string> keygen_params(const PerfConfig& config) const override {
         BOTAN_UNUSED(config);
         return {
            "ML-KEM-512",
            "ML-KEM-768",
            "ML-KEM-1024",
         };
      }
};

BOTAN_REGISTER_PERF_TEST("ML-KEM", PerfTest_ML_KEM);

#endif

#if defined(BOTAN_HAS_FRODOKEM)

class PerfTest_FrodoKEM final : public PerfTest_PK_KEM {
   public:
      std::string algo() const override { return "FrodoKEM"; }

      std::vector<std::string> keygen_params(const PerfConfig& config) const override {
         BOTAN_UNUSED(config);
         return {
            "FrodoKEM-640-SHAKE",
            "FrodoKEM-640-AES",
            "eFrodoKEM-640-SHAKE",
            "eFrodoKEM-640-AES",
            "FrodoKEM-976-SHAKE",
            "FrodoKEM-976-AES",
            "eFrodoKEM-976-SHAKE",
            "eFrodoKEM-976-AES",
            "FrodoKEM-1344-SHAKE",
            "FrodoKEM-1344-AES",
            "eFrodoKEM-1344-SHAKE",
            "eFrodoKEM-1344-AES",
         };
      }
};

BOTAN_REGISTER_PERF_TEST("FrodoKEM", PerfTest_FrodoKEM);

#endif

#if defined(BOTAN_HAS_CLASSICMCELIECE)

class PerfTest_Classic_McEliece final : public PerfTest_PK_KEM {
   public:
      std::string algo() const override { return "ClassicMcEliece"; }

      std::vector<std::string> keygen_params(const PerfConfig& config) const override {
         BOTAN_UNUSED(config);
         return {
            "mceliece348864",
            "mceliece348864f",
            "mceliece460896",
            "mceliece460896f",
            "mceliece6688128",
            "mceliece6688128f",
            "mceliece6688128pc",
            "mceliece6688128pcf",
            "mceliece6960119",
            "mceliece6960119f",
            "mceliece6960119pc",
            "mceliece6960119pcf",
            "mceliece8192128",
            "mceliece8192128f",
            "mceliece8192128pc",
            "mceliece8192128pcf",
         };
      }
};

BOTAN_REGISTER_PERF_TEST("ClassicMcEliece", PerfTest_Classic_McEliece);

#endif

}  // namespace Botan_CLI

1	/*
2	* (C) 2024 Jack Lloyd
3	*
4	* Botan is released under the Simplified BSD License (see license.txt)
5	*/
6
7	#include "perf.h"
8
9	#if defined(BOTAN_HAS_PUBLIC_KEY_CRYPTO)
10	#include <botan/pk_algs.h>
11	#include <botan/pubkey.h>
12	#endif
13
14	namespace Botan_CLI {
15
16	#if defined(BOTAN_HAS_PUBLIC_KEY_CRYPTO)
17
18	class PerfTest_PK_KEM : public PerfTest {	1✔
19	public:
20	virtual std::string algo() const = 0;
21
22	virtual std::vector<std::string> keygen_params(const PerfConfig& config) const {	×
23	BOTAN_UNUSED(config);	×
24	return {""};	×
25	}
26
27	void go(const PerfConfig& config) override {	1✔
28	const std::string alg = this->algo();	1✔
29
30	const auto params = this->keygen_params(config);	1✔
31
32	for(const auto& param : params) {	7✔
33	const std::string nm = this->format_name(alg, param);	6✔
34	bench_pk_kem(config, nm, alg, param);	12✔
35	}	6✔
36	}	1✔
37
38	void bench_pk_kem(const PerfConfig& config,	6✔
39	const std::string& nm,
40	const std::string& algo,
41	const std::string& params,
42	const std::string& provider = "") {
43	const auto msec = config.runtime();	6✔
44	auto& rng = config.rng();	6✔
45
46	const std::string kdf = "KDF2(SHA-256)"; // arbitrary choice	6✔
47
48	auto keygen_timer = config.make_timer(nm, 1, "keygen");	12✔
49
50	auto sk = keygen_timer->run([&] { return Botan::create_private_key(algo, rng, params); });	12✔
51
52	if(sk) {	6✔
53	while(keygen_timer->under(msec)) {	22✔
54	sk = keygen_timer->run([&] { return Botan::create_private_key(algo, rng, params); });	48✔
55	}
56
57	auto pk = sk->public_key();	6✔
58
59	Botan::PK_KEM_Decryptor dec(*sk, rng, kdf, provider);	6✔
60	Botan::PK_KEM_Encryptor enc(*pk, kdf, provider);	6✔
61
62	auto kem_enc_timer = config.make_timer(nm, 1, "KEM encrypt");	12✔
63	auto kem_dec_timer = config.make_timer(nm, 1, "KEM decrypt");	12✔
64
65	while(kem_enc_timer->under(msec) && kem_dec_timer->under(msec)) {	42✔
66	Botan::secure_vector<uint8_t> salt = rng.random_vec(16);	36✔
67
68	kem_enc_timer->start();	36✔
69	const auto kem_result = enc.encrypt(rng, 64, salt);	36✔
70	kem_enc_timer->stop();	36✔
71
72	kem_dec_timer->start();	36✔
73	Botan::secure_vector<uint8_t> dec_shared_key =	36✔
74	dec.decrypt(kem_result.encapsulated_shared_key(), 64, salt);	36✔
75	kem_dec_timer->stop();	36✔
76
77	if(kem_result.shared_key() != dec_shared_key) {	36✔
78	config.error_output() << "KEM mismatch in PK bench\n";	×
79	}
80	}	72✔
81	config.record_result(*keygen_timer);	6✔
82	config.record_result(*kem_enc_timer);	6✔
83	config.record_result(*kem_dec_timer);	12✔
84	}	12✔
85	}	6✔
86	};
87
88	#endif
89
90	#if defined(BOTAN_HAS_KYBER) \|\| defined(BOTAN_HAS_KYBER_90S)
91
92	class PerfTest_Kyber final : public PerfTest_PK_KEM {	1✔
93	public:
94	std::string algo() const override { return "Kyber"; }	1✔
95
96	std::vector<std::string> keygen_params(const PerfConfig& config) const override {	1✔
97	BOTAN_UNUSED(config);	1✔
98	return {	1✔
99	"Kyber-512-r3",
100	"Kyber-512-90s-r3",
101	"Kyber-768-r3",
102	"Kyber-768-90s-r3",
103	"Kyber-1024-r3",
104	"Kyber-1024-90s-r3",
105	};	1✔
106	}
107	};
108
109	BOTAN_REGISTER_PERF_TEST("Kyber", PerfTest_Kyber);	1✔
110
111	#endif
112
113	#if defined(BOTAN_HAS_ML_KEM)
114
115	class PerfTest_ML_KEM final : public PerfTest_PK_KEM {	×
116	public:
117	std::string algo() const override { return "ML-KEM"; }	×
118
119	std::vector<std::string> keygen_params(const PerfConfig& config) const override {	×
120	BOTAN_UNUSED(config);	×
121	return {	×
122	"ML-KEM-512",
123	"ML-KEM-768",
124	"ML-KEM-1024",
125	};	×
126	}
127	};
128
129	BOTAN_REGISTER_PERF_TEST("ML-KEM", PerfTest_ML_KEM);	×
130
131	#endif
132
133	#if defined(BOTAN_HAS_FRODOKEM)
134
135	class PerfTest_FrodoKEM final : public PerfTest_PK_KEM {	×
136	public:
137	std::string algo() const override { return "FrodoKEM"; }	×
138
139	std::vector<std::string> keygen_params(const PerfConfig& config) const override {	×
140	BOTAN_UNUSED(config);	×
141	return {	×
142	"FrodoKEM-640-SHAKE",
143	"FrodoKEM-640-AES",
144	"eFrodoKEM-640-SHAKE",
145	"eFrodoKEM-640-AES",
146	"FrodoKEM-976-SHAKE",
147	"FrodoKEM-976-AES",
148	"eFrodoKEM-976-SHAKE",
149	"eFrodoKEM-976-AES",
150	"FrodoKEM-1344-SHAKE",
151	"FrodoKEM-1344-AES",
152	"eFrodoKEM-1344-SHAKE",
153	"eFrodoKEM-1344-AES",
154	};	×
155	}
156	};
157
158	BOTAN_REGISTER_PERF_TEST("FrodoKEM", PerfTest_FrodoKEM);	×
159
160	#endif
161
162	#if defined(BOTAN_HAS_CLASSICMCELIECE)
163
164	class PerfTest_Classic_McEliece final : public PerfTest_PK_KEM {	×
165	public:
166	std::string algo() const override { return "ClassicMcEliece"; }	×
167
168	std::vector<std::string> keygen_params(const PerfConfig& config) const override {	×
169	BOTAN_UNUSED(config);	×
170	return {	×
171	"mceliece348864",
172	"mceliece348864f",
173	"mceliece460896",
174	"mceliece460896f",
175	"mceliece6688128",
176	"mceliece6688128f",
177	"mceliece6688128pc",
178	"mceliece6688128pcf",
179	"mceliece6960119",
180	"mceliece6960119f",
181	"mceliece6960119pc",
182	"mceliece6960119pcf",
183	"mceliece8192128",
184	"mceliece8192128f",
185	"mceliece8192128pc",
186	"mceliece8192128pcf",
187	};	×
188	}
189	};
190
191	BOTAN_REGISTER_PERF_TEST("ClassicMcEliece", PerfTest_Classic_McEliece);	×
192
193	#endif
194
195	} // namespace Botan_CLI

randombit / botan / 13089344942

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous