20396224971

Committed 20 Dec 2025 03:14PM UTC coverage: 91.706% (+1.3%) from 90.391%

Build # 20396224971

Build Type

Pull #5185

github

Committed by

web-flow

Commit Message

Merge 3e7cec3db into 8bb0a997b

Pull Request Pull Request #5185: Deprecate Threaded_Fork

Run Details

102792 of 112089 relevant lines covered (91.71%)

12662601.65 hits per line

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

67.69

/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 { 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);
         }
      }

      static 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();
               const 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 {
         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 {
         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 {
         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 {
         return {
            "348864",
            "348864f",
            "460896",
            "460896f",
            "6688128",
            "6688128f",
            "6688128pc",
            "6688128pcf",
            "6960119",
            "6960119f",
            "6960119pc",
            "6960119pcf",
            "8192128",
            "8192128f",
            "8192128pc",
            "8192128pcf",
         };
      }
};

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 { return {""}; }	×
23
24	void go(const PerfConfig& config) override {	1✔
25	const std::string alg = this->algo();	1✔
26
27	const auto params = this->keygen_params(config);	1✔
28
29	for(const auto& param : params) {	7✔
30	const std::string nm = this->format_name(alg, param);	6✔
31	bench_pk_kem(config, nm, alg, param);	12✔
32	}	6✔
33	}	1✔
34
35	static void bench_pk_kem(const PerfConfig& config,	6✔
36	const std::string& nm,
37	const std::string& algo,
38	const std::string& params,
39	const std::string& provider = "") {
40	const auto msec = config.runtime();	6✔
41	auto& rng = config.rng();	6✔
42
43	const std::string kdf = "KDF2(SHA-256)"; // arbitrary choice	6✔
44
45	auto keygen_timer = config.make_timer(nm, 1, "keygen");	12✔
46
47	auto sk = keygen_timer->run([&] { return Botan::create_private_key(algo, rng, params); });	12✔
48
49	if(sk) {	6✔
50	while(keygen_timer->under(msec)) {	6✔
51	sk = keygen_timer->run([&] { return Botan::create_private_key(algo, rng, params); });	×
52	}
53
54	auto pk = sk->public_key();	6✔
55
56	Botan::PK_KEM_Decryptor dec(*sk, rng, kdf, provider);	6✔
57	Botan::PK_KEM_Encryptor enc(*pk, kdf, provider);	6✔
58
59	auto kem_enc_timer = config.make_timer(nm, 1, "KEM encrypt");	12✔
60	auto kem_dec_timer = config.make_timer(nm, 1, "KEM decrypt");	12✔
61
62	while(kem_enc_timer->under(msec) && kem_dec_timer->under(msec)) {	12✔
63	Botan::secure_vector<uint8_t> salt = rng.random_vec(16);	6✔
64
65	kem_enc_timer->start();	6✔
66	const auto kem_result = enc.encrypt(rng, 64, salt);	6✔
67	kem_enc_timer->stop();	6✔
68
69	kem_dec_timer->start();	6✔
70	const Botan::secure_vector<uint8_t> dec_shared_key =	6✔
71	dec.decrypt(kem_result.encapsulated_shared_key(), 64, salt);	6✔
72	kem_dec_timer->stop();	6✔
73
74	if(kem_result.shared_key() != dec_shared_key) {	6✔
75	config.error_output() << "KEM mismatch in PK bench\n";	×
76	}
77	}	12✔
78	config.record_result(*keygen_timer);	6✔
79	config.record_result(*kem_enc_timer);	6✔
80	config.record_result(*kem_dec_timer);	12✔
81	}	12✔
82	}	6✔
83	};
84
85	#endif
86
87	#if defined(BOTAN_HAS_KYBER) \|\| defined(BOTAN_HAS_KYBER_90S)
88
89	class PerfTest_Kyber final : public PerfTest_PK_KEM {	1✔
90	public:
91	std::string algo() const override { return "Kyber"; }	1✔
92
93	std::vector<std::string> keygen_params(const PerfConfig& /config/) const override {	1✔
94	return {	1✔
95	"Kyber-512-r3",
96	"Kyber-512-90s-r3",
97	"Kyber-768-r3",
98	"Kyber-768-90s-r3",
99	"Kyber-1024-r3",
100	"Kyber-1024-90s-r3",
101	};	1✔
102	}
103	};
104
105	BOTAN_REGISTER_PERF_TEST("Kyber", PerfTest_Kyber);	1✔
106
107	#endif
108
109	#if defined(BOTAN_HAS_ML_KEM)
110
111	class PerfTest_ML_KEM final : public PerfTest_PK_KEM {	×
112	public:
113	std::string algo() const override { return "ML-KEM"; }	×
114
115	std::vector<std::string> keygen_params(const PerfConfig& /config/) const override {	×
116	return {	×
117	"ML-KEM-512",
118	"ML-KEM-768",
119	"ML-KEM-1024",
120	};	×
121	}
122	};
123
124	BOTAN_REGISTER_PERF_TEST("ML-KEM", PerfTest_ML_KEM);	×
125
126	#endif
127
128	#if defined(BOTAN_HAS_FRODOKEM)
129
130	class PerfTest_FrodoKEM final : public PerfTest_PK_KEM {	×
131	public:
132	std::string algo() const override { return "FrodoKEM"; }	×
133
134	std::vector<std::string> keygen_params(const PerfConfig& /config/) const override {	×
135	return {	×
136	"FrodoKEM-640-SHAKE",
137	"FrodoKEM-640-AES",
138	"eFrodoKEM-640-SHAKE",
139	"eFrodoKEM-640-AES",
140	"FrodoKEM-976-SHAKE",
141	"FrodoKEM-976-AES",
142	"eFrodoKEM-976-SHAKE",
143	"eFrodoKEM-976-AES",
144	"FrodoKEM-1344-SHAKE",
145	"FrodoKEM-1344-AES",
146	"eFrodoKEM-1344-SHAKE",
147	"eFrodoKEM-1344-AES",
148	};	×
149	}
150	};
151
152	BOTAN_REGISTER_PERF_TEST("FrodoKEM", PerfTest_FrodoKEM);	×
153
154	#endif
155
156	#if defined(BOTAN_HAS_CLASSICMCELIECE)
157
158	class PerfTest_Classic_McEliece final : public PerfTest_PK_KEM {	×
159	public:
160	std::string algo() const override { return "ClassicMcEliece"; }	×
161
162	std::vector<std::string> keygen_params(const PerfConfig& /config/) const override {	×
163	return {	×
164	"348864",
165	"348864f",
166	"460896",
167	"460896f",
168	"6688128",
169	"6688128f",
170	"6688128pc",
171	"6688128pcf",
172	"6960119",
173	"6960119f",
174	"6960119pc",
175	"6960119pcf",
176	"8192128",
177	"8192128f",
178	"8192128pc",
179	"8192128pcf",
180	};	×
181	}
182	};
183
184	BOTAN_REGISTER_PERF_TEST("ClassicMcEliece", PerfTest_Classic_McEliece);	×
185
186	#endif
187
188	} // namespace Botan_CLI

randombit / botan / 20396224971

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