Botan 3.14.1
Crypto and TLS for C&
frodokem.cpp
Go to the documentation of this file.
1/*
2 * FrodoKEM implementation
3 * Based on the MIT licensed reference implementation by the designers
4 * (https://github.com/microsoft/PQCrypto-LWEKE/tree/master)
5 *
6 * The Fellowship of the FrodoKEM:
7 * (C) 2023 Jack Lloyd
8 * 2023 René Meusel, Amos Treiber - Rohde & Schwarz Cybersecurity
9 *
10 * Botan is released under the Simplified BSD License (see license.txt)
11 */
12
13#include <botan/frodokem.h>
14
15#include <botan/assert.h>
16#include <botan/pubkey.h>
17#include <botan/rng.h>
18#include <botan/xof.h>
19#include <botan/internal/buffer_slicer.h>
20#include <botan/internal/buffer_stuffer.h>
21#include <botan/internal/concat_util.h>
22#include <botan/internal/ct_utils.h>
23#include <botan/internal/frodo_constants.h>
24#include <botan/internal/frodo_matrix.h>
25#include <botan/internal/frodo_types.h>
26#include <botan/internal/pk_ops_impl.h>
27#include <botan/internal/pk_options_impl.h>
28
29#include <memory>
30#include <tuple>
31#include <vector>
32
33namespace Botan {
34
35class FrodoKEM_PublicKeyInternal final {
36 public:
37 FrodoKEM_PublicKeyInternal(FrodoKEMConstants constants, FrodoSeedA seed_a, FrodoMatrix b) :
38 m_constants(std::move(constants)), m_seed_a(std::move(seed_a)), m_b(std::move(b)) {
39 auto shake = m_constants.create_xof();
40 shake->update(serialize());
41 m_hash = shake->output<FrodoPublicKeyHash>(m_constants.len_sec_bytes());
42 }
43
44 const FrodoKEMConstants& constants() const { return m_constants; }
45
46 const FrodoSeedA& seed_a() const { return m_seed_a; }
47
48 const FrodoMatrix& b() const { return m_b; }
49
50 const FrodoPublicKeyHash& hash() const { return m_hash; }
51
52 std::vector<uint8_t> serialize() const { return concat<std::vector<uint8_t>>(seed_a(), b().pack(m_constants)); }
53
54 private:
55 FrodoKEMConstants m_constants;
56 FrodoSeedA m_seed_a;
57 FrodoMatrix m_b;
58 FrodoPublicKeyHash m_hash;
59};
60
61class FrodoKEM_PrivateKeyInternal final {
62 public:
63 FrodoKEM_PrivateKeyInternal(FrodoSeedS s, FrodoMatrix s_trans) :
64 m_s(std::move(s)), m_s_trans(std::move(s_trans)) {}
65
66 const FrodoSeedS& s() const { return m_s; }
67
68 const FrodoMatrix& s_trans() const { return m_s_trans; }
69
70 constexpr void _const_time_poison() const { CT::poison_all(m_s, m_s_trans); }
71
72 constexpr void _const_time_unpoison() const { CT::unpoison_all(m_s, m_s_trans); }
73
74 private:
75 FrodoSeedS m_s;
76 FrodoMatrix m_s_trans;
77};
78
79//
80// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
81//
82
83namespace {
84
85class Frodo_KEM_Encryptor final : public PK_Ops::KEM_Encryption_with_KDF {
86 public:
87 // The shared secret is the output of SHAKE, so it can be used directly
88 Frodo_KEM_Encryptor(std::shared_ptr<const FrodoKEM_PublicKeyInternal> key, const PK_KEM_Options_Reader& options) :
89 KEM_Encryption_with_KDF(options, PK_Ops::KemSharedKeyQuality::IsUniform), m_public_key(std::move(key)) {}
90
91 size_t raw_kem_shared_key_length() const override { return m_public_key->constants().len_sec_bytes(); }
92
93 size_t encapsulated_key_length() const override { return m_public_key->constants().len_ct_bytes(); }
94
95 void raw_kem_encrypt(std::span<uint8_t> out_encapsulated_key,
96 std::span<uint8_t> out_shared_key,
97 RandomNumberGenerator& rng) override {
98 const auto& constants = m_public_key->constants();
99 auto shake = constants.create_xof();
100 const auto sample_generator = FrodoMatrix::make_sample_generator(constants, *shake);
101
102 BufferStuffer out_ct_bs(out_encapsulated_key);
103
104 const auto c_1 = out_ct_bs.next<FrodoPackedMatrix>(constants.len_packed_b_bytes());
105 const auto c_2 = out_ct_bs.next<FrodoPackedMatrix>(constants.len_packed_c_bytes());
106 auto salt = out_ct_bs.next<FrodoSalt>(constants.len_salt_bytes());
107
108 BOTAN_ASSERT_NOMSG(out_ct_bs.full());
109
110 const auto u = rng.random_vec<FrodoPlaintext>(constants.len_sec_bytes());
111 rng.randomize(salt);
112
113 CT::poison(u);
114
115 shake->update(m_public_key->hash());
116 shake->update(u);
117 shake->update(salt);
118 const auto seed_se = shake->output<FrodoSeedSE>(constants.len_se_bytes());
119 const auto k = shake->output<FrodoIntermediateSharedSecret>(constants.len_sec_bytes());
120 shake->clear();
121
122 shake->update(constants.encapsulation_domain_separator());
123 shake->update(seed_se);
124
125 const auto s_p = sample_generator(std::tuple(constants.n_bar(), constants.n()));
126
127 const auto e_p = sample_generator(std::tuple(constants.n_bar(), constants.n()));
128
129 const auto b_p = FrodoMatrix::mul_add_sa_plus_e(constants, s_p, e_p, m_public_key->seed_a());
130
131 b_p.pack(constants, c_1);
132
133 const auto e_pp = sample_generator(std::tuple(constants.n_bar(), constants.n_bar()));
134 shake->clear();
135
136 const auto v = FrodoMatrix::mul_add_sb_plus_e(constants, m_public_key->b(), s_p, e_pp);
137
138 const auto encoded = FrodoMatrix::encode(constants, u);
139
140 const auto c = FrodoMatrix::add(constants, v, encoded);
141
142 c.pack(constants, c_2);
143
144 shake->update(out_encapsulated_key);
145 shake->update(k);
146 shake->output(out_shared_key);
147
148 CT::unpoison_all(out_shared_key, out_encapsulated_key);
149 }
150
151 private:
152 std::shared_ptr<const FrodoKEM_PublicKeyInternal> m_public_key;
153};
154
155class Frodo_KEM_Decryptor final : public PK_Ops::KEM_Decryption_with_KDF {
156 public:
157 Frodo_KEM_Decryptor(std::shared_ptr<const FrodoKEM_PublicKeyInternal> public_key,
158 std::shared_ptr<const FrodoKEM_PrivateKeyInternal> private_key,
159 const PK_KEM_Options_Reader& options) :
160 KEM_Decryption_with_KDF(options, PK_Ops::KemSharedKeyQuality::IsUniform),
161 m_public_key(std::move(public_key)),
162 m_private_key(std::move(private_key)) {}
163
164 size_t raw_kem_shared_key_length() const override { return m_public_key->constants().len_sec_bytes(); }
165
166 size_t encapsulated_key_length() const override { return m_public_key->constants().len_ct_bytes(); }
167
168 void raw_kem_decrypt(std::span<uint8_t> out_shared_key, std::span<const uint8_t> encapsulated_key) override {
169 const auto scope = CT::scoped_poison(*m_private_key);
170
171 const auto& constants = m_public_key->constants();
172 auto shake = constants.create_xof();
173 const auto sample_generator = FrodoMatrix::make_sample_generator(constants, *shake);
174
175 if(encapsulated_key.size() != constants.len_ct_bytes()) {
176 throw Invalid_Argument("FrodoKEM ciphertext does not have the correct byte count");
177 }
178
179 BufferSlicer ct_bs(encapsulated_key);
180 const auto c_1 = ct_bs.take<FrodoPackedMatrix>(constants.len_packed_b_bytes());
181 const auto c_2 = ct_bs.take<FrodoPackedMatrix>(constants.len_packed_c_bytes());
182 auto salt = ct_bs.take<FrodoSalt>(constants.len_salt_bytes());
183 BOTAN_ASSERT_NOMSG(ct_bs.empty());
184
185 const auto b_p = FrodoMatrix::unpack(constants, {constants.n_bar(), constants.n()}, c_1);
186 const auto c = FrodoMatrix::unpack(constants, {constants.n_bar(), constants.n_bar()}, c_2);
187
188 const auto w = FrodoMatrix::mul_bs(constants, b_p, m_private_key->s_trans());
189 const auto m = FrodoMatrix::sub(constants, c, w);
190
191 const auto seed_u_p = m.decode(constants);
192
193 shake->update(m_public_key->hash());
194 shake->update(seed_u_p);
195 shake->update(salt);
196
197 const auto seed_se_p = shake->output<FrodoSeedSE>(constants.len_se_bytes());
198 const auto k_p = shake->output<FrodoIntermediateSharedSecret>(constants.len_sec_bytes());
199 shake->clear();
200
201 shake->update(constants.encapsulation_domain_separator());
202 shake->update(seed_se_p);
203 const auto s_p = sample_generator(std::tuple(constants.n_bar(), constants.n()));
204
205 const auto e_p = sample_generator(std::tuple(constants.n_bar(), constants.n()));
206
207 auto b_pp = FrodoMatrix::mul_add_sa_plus_e(constants, s_p, e_p, m_public_key->seed_a());
208
209 const auto e_pp = sample_generator(std::tuple(constants.n_bar(), constants.n_bar()));
210 shake->clear();
211
212 const auto v = FrodoMatrix::mul_add_sb_plus_e(constants, m_public_key->b(), s_p, e_pp);
213
214 const auto encoded = FrodoMatrix::encode(constants, seed_u_p);
215 auto c_p = FrodoMatrix::add(constants, v, encoded);
216
217 // b_p and c are unpacked values that are reduced by definition.
218 // b_pp and c_p are calculated values that need the reduction for
219 // an unambiguous comparison that is required next.
220 b_pp.reduce(constants);
221 c_p.reduce(constants);
222
223 // The spec concats the matrices b_p and c (b_pp and c_p respectively)
224 // and performs a single CT comparison. For convenience we compare the
225 // matrices individually in CT and CT-&& the resulting masks.
226 const auto cmp = b_p.constant_time_compare(b_pp) & c.constant_time_compare(c_p);
227
228 secure_vector<uint8_t> k_bar(constants.len_sec_bytes(), 0);
229 CT::conditional_copy_mem(cmp, k_bar.data(), k_p.data(), m_private_key->s().data(), constants.len_sec_bytes());
230
231 shake->update(encapsulated_key);
232 shake->update(k_bar);
233 shake->output(out_shared_key);
234
235 CT::unpoison(out_shared_key);
236 }
237
238 private:
239 std::shared_ptr<const FrodoKEM_PublicKeyInternal> m_public_key;
240 std::shared_ptr<const FrodoKEM_PrivateKeyInternal> m_private_key;
241};
242
243// The entries of S^T are samples from the error distribution, which is
244// supported on [-(cdf_table_len - 1), cdf_table_len - 1]
245bool s_trans_in_range(const FrodoKEMConstants& constants, const FrodoMatrix& s_trans) {
246 const auto bound = static_cast<uint16_t>(constants.cdf_table_len() - 1);
247 auto in_range = CT::Mask<uint16_t>::set();
248 for(size_t i = 0; i != s_trans.element_count(); ++i) {
249 // Adding the bound maps the valid two's complement entries onto [0, 2*bound]
250 const auto shifted = static_cast<uint16_t>(s_trans.elements_at(i) + bound);
251 in_range &= CT::Mask<uint16_t>::is_lte(shifted, static_cast<uint16_t>(2 * bound));
252 }
253 return in_range.as_bool();
254}
255
256} // namespace
257
258//
259// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
260//
261
262FrodoKEM_PublicKey::FrodoKEM_PublicKey(std::span<const uint8_t> pub_key, FrodoKEMMode mode) {
263 FrodoKEMConstants constants(mode);
264 if(pub_key.size() != constants.len_public_key_bytes()) {
265 throw Decoding_Error("FrodoKEM public key does not have the correct byte count");
266 }
267
268 BufferSlicer pk_bs(pub_key);
269 auto seed_a = pk_bs.copy<FrodoSeedA>(constants.len_a_bytes());
270 const auto packed_b = pk_bs.take<FrodoPackedMatrix>(constants.d() * constants.n() * constants.n_bar() / 8);
271 BOTAN_ASSERT_NOMSG(pk_bs.empty());
272
273 auto b = FrodoMatrix::unpack(constants, std::tuple(constants.n(), constants.n_bar()), packed_b);
274
275 m_public = std::make_shared<FrodoKEM_PublicKeyInternal>(std::move(constants), std::move(seed_a), std::move(b));
276}
277
278FrodoKEM_PublicKey::FrodoKEM_PublicKey(const AlgorithmIdentifier& alg_id, std::span<const uint8_t> key_bits) :
279 FrodoKEM_PublicKey(key_bits, FrodoKEMMode(alg_id.oid())) {
280 // The parameter set is identified by the OID; no parameters are defined.
281 if(!alg_id.parameters_are_empty()) {
282 throw Decoding_Error("Unexpected parameters for FrodoKEM public key");
283 }
284}
285
287 m_public = std::make_shared<FrodoKEM_PublicKeyInternal>(
288 other.m_public->constants(), other.m_public->seed_a(), other.m_public->b());
289}
290
292 if(this != &other) {
293 m_public = std::make_shared<FrodoKEM_PublicKeyInternal>(
294 other.m_public->constants(), other.m_public->seed_a(), other.m_public->b());
295 }
296 return *this;
297}
298
302
304 return m_public->constants().mode().object_identifier();
305}
306
308 return m_public->constants().n();
309}
310
312 return m_public->constants().estimated_strength();
313}
314
315std::vector<uint8_t> FrodoKEM_PublicKey::raw_public_key_bits() const {
316 return concat<std::vector<uint8_t>>(m_public->seed_a(), m_public->b().pack(m_public->constants()));
317}
318
319std::vector<uint8_t> FrodoKEM_PublicKey::public_key_bits() const {
320 // Currently, there isn't a finalized definition of an ASN.1 structure for
321 // FrodoKEM public keys. Therefore, we return the raw public key bits.
322 return raw_public_key_bits();
323}
324
325bool FrodoKEM_PublicKey::check_key(RandomNumberGenerator& /*rng*/, bool /*strong*/) const {
326 // The public key consists of (seed_a, b) where b is a matrix of elements
327 // mod q = 2^d. Length validation is performed in the constructor, and bit
328 // unpacking naturally constrains all matrix elements to [0, 2^d - 1] which
329 // is the full valid range, leaving no further structural checks to perform.
330 return true;
331}
332
333std::unique_ptr<Private_Key> FrodoKEM_PublicKey::generate_another(RandomNumberGenerator& rng) const {
334 return std::make_unique<FrodoKEM_PrivateKey>(rng, m_public->constants().mode());
335}
336
337std::unique_ptr<PK_Ops::KEM_Encryption> FrodoKEM_PublicKey::_create_kem_encryption_op(
338 const PK_KEM_Options_Reader& options) const {
340
341 return std::make_unique<Frodo_KEM_Encryptor>(m_public, options);
342}
343
344//
345// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
346//
347
349 FrodoKEMConstants constants(mode);
350 auto shake = constants.create_xof();
351
352 auto s = rng.random_vec<FrodoSeedS>(constants.len_sec_bytes());
353 const auto seed_se = rng.random_vec<FrodoSeedSE>(constants.len_se_bytes());
354 const auto z = rng.random_vec<FrodoSeedZ>(constants.len_a_bytes());
355
356 CT::poison_all(s, seed_se);
357
358 shake->update(z);
359 auto seed_a = shake->output<FrodoSeedA>(constants.len_a_bytes());
360 shake->clear();
361
362 shake->update(constants.keygen_domain_separator());
363 shake->update(seed_se);
364
365 const auto sample_generator = FrodoMatrix::make_sample_generator(constants, *shake);
366 auto s_trans = sample_generator(std::tuple(constants.n_bar(), constants.n()));
367 const auto e = sample_generator(std::tuple(constants.n(), constants.n_bar()));
368 shake->clear();
369
370 auto b = FrodoMatrix::mul_add_as_plus_e(constants, s_trans, e, seed_a);
371
372 CT::unpoison_all(s, s_trans, b);
373
374 m_public = std::make_shared<FrodoKEM_PublicKeyInternal>(std::move(constants), std::move(seed_a), std::move(b));
375 m_private = std::make_shared<FrodoKEM_PrivateKeyInternal>(std::move(s), std::move(s_trans));
376}
377
378FrodoKEM_PrivateKey::FrodoKEM_PrivateKey(std::span<const uint8_t> sk, FrodoKEMMode mode) {
379 FrodoKEMConstants constants(mode);
380
381 if(sk.size() != constants.len_private_key_bytes()) {
382 throw Decoding_Error("FrodoKEM private key does not have the correct byte count");
383 }
384
385 BufferSlicer sk_bs(sk);
386 auto s = sk_bs.copy<FrodoSeedS>(constants.len_sec_bytes());
387 auto seed_a = sk_bs.copy<FrodoSeedA>(constants.len_a_bytes());
388 const auto packed_b = sk_bs.take<FrodoPackedMatrix>(constants.d() * constants.n() * constants.n_bar() / 8);
389 const auto s_trans_bytes = sk_bs.take<FrodoSerializedMatrix>(constants.n_bar() * constants.n() * 2);
390 const auto pkh = sk_bs.copy<FrodoPublicKeyHash>(constants.len_sec_bytes());
391 BOTAN_ASSERT_NOMSG(sk_bs.empty());
392
393 auto b = FrodoMatrix::unpack(constants, std::tuple(constants.n(), constants.n_bar()), packed_b);
394 auto s_trans = FrodoMatrix::deserialize({constants.n_bar(), constants.n()}, s_trans_bytes);
395 if(!s_trans_in_range(constants, s_trans)) {
396 throw Decoding_Error("FrodoKEM private key matrix entry is out of range");
397 }
398
399 m_public = std::make_shared<FrodoKEM_PublicKeyInternal>(std::move(constants), std::move(seed_a), std::move(b));
400 m_private = std::make_shared<FrodoKEM_PrivateKeyInternal>(std::move(s), std::move(s_trans));
401
402 if(pkh != m_public->hash()) {
403 throw Decoding_Error("FrodoKEM embedded public key hash did not match recomputed value");
404 }
405}
406
407FrodoKEM_PrivateKey::FrodoKEM_PrivateKey(const AlgorithmIdentifier& alg_id, std::span<const uint8_t> key_bits) :
408 FrodoKEM_PrivateKey(key_bits, FrodoKEMMode(alg_id.oid())) {
409 // The parameter set is identified by the OID; no parameters are defined.
410 if(!alg_id.parameters_are_empty()) {
411 throw Decoding_Error("Unexpected parameters for FrodoKEM private key");
412 }
413}
414
415std::unique_ptr<Public_Key> FrodoKEM_PrivateKey::public_key() const {
416 return std::make_unique<FrodoKEM_PublicKey>(*this);
417}
418
420 if(!FrodoKEM_PublicKey::check_key(rng, strong)) {
421 return false;
422 }
423
424 if(strong) {
425 PK_KEM_Encryptor enc(*this, "Raw");
426 PK_KEM_Decryptor dec(*this, rng, "Raw");
427 const auto [c, K] = KEM_Encapsulation::destructure(enc.encrypt(rng));
428 const auto K_prime = dec.decrypt(c);
429 return K == K_prime;
430 }
431
432 return true;
433}
434
436 return raw_private_key_bits(); // TODO: check if we need to do something else here
437}
438
440 return concat<secure_vector<uint8_t>>(m_private->s(),
441 m_public->seed_a(),
442 m_public->b().pack(m_public->constants()),
443 m_private->s_trans().serialize(),
444 m_public->hash());
445}
446
447std::unique_ptr<PK_Ops::KEM_Decryption> FrodoKEM_PrivateKey::_create_kem_decryption_op(
448 RandomNumberGenerator& rng, const PK_KEM_Options_Reader& options) const {
449 BOTAN_UNUSED(rng);
451
452 return std::make_unique<Frodo_KEM_Decryptor>(m_public, m_private, options);
453}
454
455} // namespace Botan
#define BOTAN_UNUSED
Definition assert.h:151
#define BOTAN_ASSERT_NOMSG(expr)
Definition assert.h:82
bool parameters_are_empty() const
Definition asn1_obj.h:715
auto copy(const size_t count)
std::span< const uint8_t > take(const size_t count)
static constexpr Mask< T > is_lte(T x, T y)
Definition ct_utils.h:468
static constexpr Mask< T > set()
Definition ct_utils.h:387
FrodoDomainSeparator keygen_domain_separator() const
size_t len_private_key_bytes() const
size_t len_public_key_bytes() const
std::unique_ptr< XOF > create_xof() const
FrodoKEM_PrivateKey(RandomNumberGenerator &rng, FrodoKEMMode mode)
Definition frodokem.cpp:348
secure_vector< uint8_t > raw_private_key_bits() const override
Definition frodokem.cpp:439
bool check_key(RandomNumberGenerator &rng, bool strong) const override
Definition frodokem.cpp:419
std::unique_ptr< PK_Ops::KEM_Decryption > _create_kem_decryption_op(RandomNumberGenerator &rng, const PK_KEM_Options_Reader &options) const override
Definition frodokem.cpp:447
secure_vector< uint8_t > private_key_bits() const override
Definition frodokem.cpp:435
std::unique_ptr< Public_Key > public_key() const override
Definition frodokem.cpp:415
size_t estimated_strength() const override
Definition frodokem.cpp:311
std::shared_ptr< const FrodoKEM_PublicKeyInternal > m_public
Definition frodokem.h:75
std::unique_ptr< PK_Ops::KEM_Encryption > _create_kem_encryption_op(const PK_KEM_Options_Reader &options) const override
Definition frodokem.cpp:337
AlgorithmIdentifier algorithm_identifier() const override
Definition frodokem.cpp:299
size_t key_length() const override
Definition frodokem.cpp:307
FrodoKEM_PublicKey(std::span< const uint8_t > pub_key, FrodoKEMMode mode)
Definition frodokem.cpp:262
std::unique_ptr< Private_Key > generate_another(RandomNumberGenerator &rng) const final
Definition frodokem.cpp:333
std::vector< uint8_t > public_key_bits() const override
Definition frodokem.cpp:319
FrodoKEM_PublicKey & operator=(const FrodoKEM_PublicKey &other)
Definition frodokem.cpp:291
std::string algo_name() const override
Definition frodokem.h:46
bool check_key(RandomNumberGenerator &rng, bool strong) const override
Definition frodokem.cpp:325
std::vector< uint8_t > raw_public_key_bits() const override
Definition frodokem.cpp:315
OID object_identifier() const override
Definition frodokem.cpp:303
static FrodoMatrix mul_add_sa_plus_e(const FrodoKEMConstants &constants, const FrodoMatrix &s, const FrodoMatrix &e, StrongSpan< const FrodoSeedA > seed_a)
static std::function< FrodoMatrix(const Dimensions &dimensions)> make_sample_generator(const FrodoKEMConstants &constants, Botan::XOF &shake)
static FrodoMatrix mul_add_sb_plus_e(const FrodoKEMConstants &constants, const FrodoMatrix &b, const FrodoMatrix &s, const FrodoMatrix &e)
static FrodoMatrix mul_add_as_plus_e(const FrodoKEMConstants &constants, const FrodoMatrix &s, const FrodoMatrix &e, StrongSpan< const FrodoSeedA > seed_a)
static FrodoMatrix sub(const FrodoKEMConstants &constants, const FrodoMatrix &a, const FrodoMatrix &b)
static FrodoMatrix add(const FrodoKEMConstants &constants, const FrodoMatrix &a, const FrodoMatrix &b)
static FrodoMatrix encode(const FrodoKEMConstants &constants, StrongSpan< const FrodoPlaintext > in)
static FrodoMatrix unpack(const FrodoKEMConstants &constants, const Dimensions &dimensions, StrongSpan< const FrodoPackedMatrix > packed_bytes)
static FrodoMatrix mul_bs(const FrodoKEMConstants &constants, const FrodoMatrix &b_p, const FrodoMatrix &s)
static FrodoMatrix deserialize(const Dimensions &dimensions, StrongSpan< const FrodoSerializedMatrix > bytes)
static std::pair< std::vector< uint8_t >, secure_vector< uint8_t > > destructure(KEM_Encapsulation &&kem)
Definition pubkey.h:654
void decrypt(std::span< uint8_t > out_shared_key, std::span< const uint8_t > encap_key, size_t desired_shared_key_len=32, std::span< const uint8_t > salt={})
Definition pubkey.cpp:255
KEM_Encapsulation encrypt(RandomNumberGenerator &rng, size_t desired_shared_key_len=32, std::span< const uint8_t > salt={})
Definition pubkey.h:745
void random_vec(std::span< uint8_t > v)
Definition rng.h:254
constexpr Mask< T > conditional_copy_mem(Mask< T > mask, T *dest, const T *if_set, const T *if_unset, size_t elems)
Definition ct_utils.h:737
constexpr void poison_all(const Ts &... ts)
Definition ct_utils.h:201
constexpr auto scoped_poison(const Ts &... xs)
Definition ct_utils.h:222
constexpr void unpoison_all(const Ts &... ts)
Definition ct_utils.h:207
constexpr void unpoison(const T *p, size_t n)
Definition ct_utils.h:67
constexpr void poison(const T *p, size_t n)
Definition ct_utils.h:56
Strong< secure_vector< uint8_t >, struct FrodoSeedSE_ > FrodoSeedSE
Definition frodo_types.h:29
Strong< secure_vector< uint8_t >, struct FrodoSerializedMatrix_ > FrodoSerializedMatrix
Definition frodo_types.h:44
Strong< std::vector< uint8_t >, struct FrodoSeedZ_ > FrodoSeedZ
Definition frodo_types.h:32
Strong< secure_vector< uint8_t >, struct FrodoIntermediateSharedSecret_ > FrodoIntermediateSharedSecret
Definition frodo_types.h:56
Strong< std::vector< uint8_t >, struct FrodoPublicKeyHash_ > FrodoPublicKeyHash
Definition frodo_types.h:38
void require_software_provider(const OptionsT &options, std::string_view algo_name)
constexpr auto concat(Rs &&... ranges)
Definition concat_util.h:95
std::vector< T, secure_allocator< T > > secure_vector
Definition secmem.h:128
Strong< std::vector< uint8_t >, struct FrodoSeedA_ > FrodoSeedA
Definition frodo_types.h:23
Strong< secure_vector< uint8_t >, struct FrodoPlaintext_ > FrodoPlaintext
Definition frodo_types.h:50
Strong< std::vector< uint8_t >, struct FrodoSalt_ > FrodoSalt
Definition frodo_types.h:53
Strong< std::vector< uint8_t >, struct FrodoPackedMatrix_ > FrodoPackedMatrix
Definition frodo_types.h:41
Strong< secure_vector< uint8_t >, struct FrodoSeedS_ > FrodoSeedS
Definition frodo_types.h:26