21783203606

Committed 07 Feb 2026 04:30PM UTC coverage: 90.068% (-0.005%) from 90.073%

Build # 21783203606

Build Type

Pull #5295

github

Committed by

web-flow

Commit Message

Merge a6c023b97 into ebf8f0044

Pull Request Pull Request #5295: Reduce header dependencies in tests and cli

Run Details

102233 of 113507 relevant lines covered (90.07%)

11542227.95 hits per line

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

69.23

/src/cli/perf_pk_kem.cpp

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

#include "perf.h"

#include <ostream>

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

randombit / botan / 21783203606

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