23225340130

Committed 18 Mar 2026 01:53AM UTC coverage: 89.677% (-0.001%) from 89.678%

Build # 23225340130

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #5456 from randombit/jack/clang-tidy-22

Fix various warnings from clang-tidy 22

Run Details

104438 of 116460 relevant lines covered (89.68%)

11819947.55 hits per line

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

70.31

/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 {

namespace {

#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

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

randombit / botan / 23225340130

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