11507839509

Committed 24 Oct 2024 09:35PM UTC coverage: 91.139% (+0.006%) from 91.133%

Build # 11507839509

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #4381 from cr-marcstevens/master

cli speed: also measure keygen for specified duration

Run Details

91069 of 99923 relevant lines covered (91.14%)

9355539.52 hits per line

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

98.21

/src/cli/perf_pk_ka.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_PKKa : 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_ka(config, nm, alg, param);
         }
      }

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

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

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

         auto& rng = config.rng();

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

         config.record_result(*keygen_timer);

         const Botan::PK_Key_Agreement_Key& ka_key1 = dynamic_cast<const Botan::PK_Key_Agreement_Key&>(*key1);
         const Botan::PK_Key_Agreement_Key& ka_key2 = dynamic_cast<const Botan::PK_Key_Agreement_Key&>(*key2);

         Botan::PK_Key_Agreement ka1(ka_key1, rng, kdf, provider);
         Botan::PK_Key_Agreement ka2(ka_key2, rng, kdf, provider);

         const std::vector<uint8_t> ka1_pub = ka_key1.public_value();
         const std::vector<uint8_t> ka2_pub = ka_key2.public_value();

         auto ka_timer = config.make_timer(nm, 1, "key agreements");

         while(ka_timer->under(msec)) {
            auto k1 = ka_timer->run([&]() { return ka1.derive_key(32, ka2_pub); });
            auto k2 = ka_timer->run([&]() { return ka2.derive_key(32, ka1_pub); });

            if(k1 != k2) {
               config.error_output() << "Key agreement mismatch in PK bench\n";
            }
         }

         config.record_result(*ka_timer);
      }
};

#endif

#if defined(BOTAN_HAS_DIFFIE_HELLMAN)

class PerfTest_DH final : public PerfTest_PKKa {
   public:
      std::string algo() const override { return "DH"; }

      std::vector<std::string> keygen_params(const PerfConfig& config) const override {
         BOTAN_UNUSED(config);
         return {
            "ffdhe/ietf/2048",
            "ffdhe/ietf/3072",
            "ffdhe/ietf/4096",
            "ffdhe/ietf/6144",
            "ffdhe/ietf/8192",
         };
      }

      std::string format_name(const std::string& alg, const std::string& param) const override {
         return Botan::fmt("{}-{}", alg, param.substr(param.find_last_of('/') + 1));
      }
};

BOTAN_REGISTER_PERF_TEST("DH", PerfTest_DH);

#endif

#if defined(BOTAN_HAS_ECDH)

class PerfTest_ECDH final : public PerfTest_PKKa {
   public:
      std::string algo() const override { return "ECDH"; }

      std::vector<std::string> keygen_params(const PerfConfig& config) const override { return config.ecc_groups(); }
};

BOTAN_REGISTER_PERF_TEST("ECDH", PerfTest_ECDH);

#endif

#if defined(BOTAN_HAS_X25519)

class PerfTest_X25519 final : public PerfTest_PKKa {
   public:
      std::string algo() const override { return "X25519"; }
};

BOTAN_REGISTER_PERF_TEST("X25519", PerfTest_X25519);

#endif

#if defined(BOTAN_HAS_X448)

class PerfTest_X448 final : public PerfTest_PKKa {
   public:
      std::string algo() const override { return "X448"; }
};

BOTAN_REGISTER_PERF_TEST("X448", PerfTest_X448);

#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_PKKa : public PerfTest {	4✔
19	public:
20	virtual std::string algo() const = 0;
21
22	virtual std::vector<std::string> keygen_params(const PerfConfig& config) const {	2✔
23	BOTAN_UNUSED(config);	2✔
24	return {""};	2✔
25	}
26
27	void go(const PerfConfig& config) override {	4✔
28	const std::string alg = this->algo();	4✔
29
30	const auto params = this->keygen_params(config);	4✔
31
32	for(const auto& param : params) {	17✔
33	const std::string nm = this->format_name(alg, param);	13✔
34	bench_pk_ka(config, nm, alg, param);	26✔
35	}	13✔
36	}	4✔
37
38	void bench_pk_ka(const PerfConfig& config,	13✔
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();	13✔
44
45	const std::string kdf = "KDF2(SHA-256)"; // arbitrary choice	13✔
46
47	auto keygen_timer = config.make_timer(nm, 1, "keygen");	26✔
48
49	auto& rng = config.rng();	13✔
50
51	auto key1 = keygen_timer->run([&] { return Botan::create_private_key(algo, rng, params); });	26✔
52	auto key2 = keygen_timer->run([&] { return Botan::create_private_key(algo, rng, params); });	26✔
53	while(keygen_timer->under(msec)) {	31✔
54	key2 = keygen_timer->run([&] { return Botan::create_private_key(algo, rng, params); });	54✔
55	}
56
57	config.record_result(*keygen_timer);	13✔
58
59	const Botan::PK_Key_Agreement_Key& ka_key1 = dynamic_cast<const Botan::PK_Key_Agreement_Key&>(*key1);	13✔
60	const Botan::PK_Key_Agreement_Key& ka_key2 = dynamic_cast<const Botan::PK_Key_Agreement_Key&>(*key2);	13✔
61
62	Botan::PK_Key_Agreement ka1(ka_key1, rng, kdf, provider);	13✔
63	Botan::PK_Key_Agreement ka2(ka_key2, rng, kdf, provider);	13✔
64
65	const std::vector<uint8_t> ka1_pub = ka_key1.public_value();	13✔
66	const std::vector<uint8_t> ka2_pub = ka_key2.public_value();	13✔
67
68	auto ka_timer = config.make_timer(nm, 1, "key agreements");	26✔
69
70	while(ka_timer->under(msec)) {	31✔
71	auto k1 = ka_timer->run([&]() { return ka1.derive_key(32, ka2_pub); });	36✔
72	auto k2 = ka_timer->run([&]() { return ka2.derive_key(32, ka1_pub); });	36✔
73
74	if(k1 != k2) {	18✔
75	config.error_output() << "Key agreement mismatch in PK bench\n";	×
76	}
77	}	36✔
78
79	config.record_result(*ka_timer);	13✔
80	}	65✔
81	};
82
83	#endif
84
85	#if defined(BOTAN_HAS_DIFFIE_HELLMAN)
86
87	class PerfTest_DH final : public PerfTest_PKKa {	1✔
88	public:
89	std::string algo() const override { return "DH"; }	1✔
90
91	std::vector<std::string> keygen_params(const PerfConfig& config) const override {	1✔
92	BOTAN_UNUSED(config);	1✔
93	return {	1✔
94	"ffdhe/ietf/2048",
95	"ffdhe/ietf/3072",
96	"ffdhe/ietf/4096",
97	"ffdhe/ietf/6144",
98	"ffdhe/ietf/8192",
99	};	1✔
100	}
101
102	std::string format_name(const std::string& alg, const std::string& param) const override {	5✔
103	return Botan::fmt("{}-{}", alg, param.substr(param.find_last_of('/') + 1));	10✔
104	}
105	};
106
107	BOTAN_REGISTER_PERF_TEST("DH", PerfTest_DH);	1✔
108
109	#endif
110
111	#if defined(BOTAN_HAS_ECDH)
112
113	class PerfTest_ECDH final : public PerfTest_PKKa {	1✔
114	public:
115	std::string algo() const override { return "ECDH"; }	1✔
116
117	std::vector<std::string> keygen_params(const PerfConfig& config) const override { return config.ecc_groups(); }	1✔
118	};
119
120	BOTAN_REGISTER_PERF_TEST("ECDH", PerfTest_ECDH);	1✔
121
122	#endif
123
124	#if defined(BOTAN_HAS_X25519)
125
126	class PerfTest_X25519 final : public PerfTest_PKKa {	1✔
127	public:
128	std::string algo() const override { return "X25519"; }	1✔
129	};
130
131	BOTAN_REGISTER_PERF_TEST("X25519", PerfTest_X25519);	1✔
132
133	#endif
134
135	#if defined(BOTAN_HAS_X448)
136
137	class PerfTest_X448 final : public PerfTest_PKKa {	1✔
138	public:
139	std::string algo() const override { return "X448"; }	1✔
140	};
141
142	BOTAN_REGISTER_PERF_TEST("X448", PerfTest_X448);	1✔
143
144	#endif
145
146	} // namespace Botan_CLI

randombit / botan / 11507839509

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