Botan 3.14.1
Crypto and TLS for C&
mceliece_key.cpp
Go to the documentation of this file.
1/*
2 * (C) Copyright Projet SECRET, INRIA, Rocquencourt
3 * (C) Bhaskar Biswas and Nicolas Sendrier
4 *
5 * (C) 2014 cryptosource GmbH
6 * (C) 2014 Falko Strenzke fstrenzke@cryptosource.de
7 * (C) 2015 Jack Lloyd
8 *
9 * Botan is released under the Simplified BSD License (see license.txt)
10 *
11 */
12
13#include <botan/mceliece.h>
14
15#include <botan/ber_dec.h>
16#include <botan/der_enc.h>
17#include <botan/rng.h>
18#include <botan/internal/bit_ops.h>
19#include <botan/internal/buffer_stuffer.h>
20#include <botan/internal/code_based_util.h>
21#include <botan/internal/loadstor.h>
22#include <botan/internal/mce_internal.h>
23#include <botan/internal/pk_ops_impl.h>
24#include <botan/internal/pk_options_impl.h>
25#include <botan/internal/polyn_gf2m.h>
26
27#include <array>
28#include <utility>
29
30namespace Botan {
31
32namespace {
33
34constexpr std::array<std::pair<size_t, size_t>, 6> MCE_SUPPORTED_PARAMS = {
35 {{1632, 33}, {2480, 45}, {2960, 57}, {3408, 67}, {4624, 95}, {6624, 115}}};
36
37bool mceliece_params_are_supported(size_t code_length, size_t t) {
38 for(const auto& [supported_n, supported_t] : MCE_SUPPORTED_PARAMS) {
39 if(code_length == supported_n && t == supported_t) {
40 return true;
41 }
42 }
43 return false;
44}
45
46uint32_t padding_mask(size_t bit_count) {
47 const size_t used_bits = bit_count % 32;
48 if(used_bits == 0) {
49 return 0;
50 }
51 return ~((static_cast<uint32_t>(1) << used_bits) - 1);
52}
53
54void validate_public_matrix(const std::vector<uint8_t>& public_matrix, const McEliece_Params& params) {
55 if(public_matrix.size() != params.public_matrix_bytes) {
56 throw Decoding_Error("McEliece public matrix size does not match parameters");
57 }
58
59 const uint32_t unused_bits_mask = padding_mask(params.codimension);
60 if(unused_bits_mask == 0) {
61 return;
62 }
63
64 const size_t row_bytes = params.words_per_matrix_row * sizeof(uint32_t);
65 const size_t final_word_offset = (params.words_per_matrix_row - 1) * sizeof(uint32_t);
66 for(size_t row = 0; row != params.dimension; ++row) {
67 const uint8_t* row_ptr = public_matrix.data() + row * row_bytes;
68 const uint32_t final_word = load_le<uint32_t>(row_ptr + final_word_offset, 0);
69 if((final_word & unused_bits_mask) != 0) {
70 throw Decoding_Error("McEliece public matrix contains non-zero padding bits");
71 }
72 }
73}
74
75void validate_polynomial(const polyn_gf2m& polyn,
76 const McEliece_Params& params,
77 size_t min_coeff_count,
78 size_t max_degree) {
79 const std::shared_ptr<GF2m_Field> field = polyn.get_sp_field();
80 if(!field || field->get_extension_degree() != params.ext_deg) {
81 throw Decoding_Error("McEliece polynomial uses an inconsistent field");
82 }
83
84 if(polyn.get_coeff_count() < min_coeff_count) {
85 throw Decoding_Error("McEliece polynomial has too few coefficients");
86 }
87
88 const int degree = polyn.get_degree();
89 // NOLINTNEXTLINE(modernize-use-integer-sign-comparison)
90 if(degree >= 0 && static_cast<size_t>(degree) > max_degree) {
91 throw Decoding_Error("McEliece polynomial degree is too large");
92 }
93
94 const size_t field_cardinality = static_cast<size_t>(1) << params.ext_deg;
95 for(size_t i = 0; i != polyn.get_coeff_count(); ++i) {
96 if(polyn.get_coef(i) >= field_cardinality) {
97 throw Decoding_Error("McEliece polynomial coefficient is out of range");
98 }
99 }
100}
101
102void validate_support_inverse(const std::vector<gf2m>& inverse_support, const McEliece_Params& params) {
103 if(inverse_support.size() != params.code_length) {
104 throw Decoding_Error("McEliece support size does not match code length");
105 }
106
107 std::vector<uint8_t> seen(params.code_length);
108 for(const gf2m support_elem : inverse_support) {
109 if(support_elem >= params.code_length) {
110 throw Decoding_Error("McEliece support element is out of range");
111 }
112 if(seen[support_elem] != 0) {
113 throw Decoding_Error("McEliece support is not a permutation");
114 }
115 seen[support_elem] = 1;
116 }
117}
118
119void validate_parity_check_matrix(const std::vector<uint32_t>& parity_check_matrix_coeffs,
120 const McEliece_Params& params) {
121 if(parity_check_matrix_coeffs.size() != params.words_per_matrix_row * params.code_length) {
122 throw Decoding_Error("McEliece parity check matrix has wrong length");
123 }
124
125 const uint32_t unused_bits_mask = padding_mask(params.codimension);
126 if(unused_bits_mask == 0) {
127 return;
128 }
129
130 for(size_t row = 0; row != params.code_length; ++row) {
131 const uint32_t final_word =
132 parity_check_matrix_coeffs[row * params.words_per_matrix_row + params.words_per_matrix_row - 1];
133 if((final_word & unused_bits_mask) != 0) {
134 throw Decoding_Error("McEliece parity check matrix contains non-zero padding bits");
135 }
136 }
137}
138
139void validate_private_components(const polyn_gf2m& goppa_polyn,
140 const std::vector<uint32_t>& parity_check_matrix_coeffs,
141 const std::vector<polyn_gf2m>& square_root_matrix,
142 const std::vector<gf2m>& inverse_support,
143 const std::vector<uint8_t>& public_matrix,
144 const McEliece_Params& params) {
145 validate_public_matrix(public_matrix, params);
146
147 if(goppa_polyn.get_degree() != static_cast<int>(params.t)) {
148 throw Decoding_Error("degree of decoded Goppa polynomial is incorrect");
149 }
150 validate_polynomial(goppa_polyn, params, params.t + 1, params.t);
151 if(goppa_polyn.get_lead_coef() != 1) {
152 throw Decoding_Error("McEliece Goppa polynomial is not monic");
153 }
154
155 if(square_root_matrix.size() != params.t / 2) {
156 throw Decoding_Error("McEliece square root matrix has wrong length");
157 }
158 for(const auto& sqrt_polyn : square_root_matrix) {
159 validate_polynomial(sqrt_polyn, params, params.t, params.t - 1);
160 }
161
162 validate_support_inverse(inverse_support, params);
163 validate_parity_check_matrix(parity_check_matrix_coeffs, params);
164}
165
166} // namespace
167
168McEliece_Params mceliece_validate_key_params(size_t code_length, size_t t) {
169 if(!mceliece_params_are_supported(code_length, t)) {
170 throw Decoding_Error("Unsupported McEliece parameters");
171 }
172
173 const size_t ext_deg = ceil_log2(code_length);
174 if(ext_deg < 2 || ext_deg > 15) {
175 throw Decoding_Error("McEliece code length out of supported range");
176 }
177
178 const size_t codimension = ext_deg * t;
179 if(codimension >= code_length) {
180 throw Decoding_Error("McEliece parameters are inconsistent");
181 }
182
183 const size_t dimension = code_length - codimension;
184 const size_t words_per_matrix_row = bit_size_to_32bit_size(codimension);
185 const size_t public_matrix_bytes = dimension * words_per_matrix_row * sizeof(uint32_t);
186
187 return McEliece_Params{code_length, t, ext_deg, codimension, dimension, words_per_matrix_row, public_matrix_bytes};
188}
189
191 // Requesting unsupported parameters for key generation is a caller error
192 // rather than malformed key material
193 if(!mceliece_params_are_supported(code_length, t)) {
194 throw Invalid_Argument("Unsupported McEliece parameters");
195 }
196 return mceliece_validate_key_params(code_length, t);
197}
198
199McEliece_PrivateKey::McEliece_PrivateKey(const McEliece_PrivateKey&) = default;
200McEliece_PrivateKey::McEliece_PrivateKey(McEliece_PrivateKey&&) noexcept = default;
201McEliece_PrivateKey& McEliece_PrivateKey::operator=(const McEliece_PrivateKey&) = default;
202McEliece_PrivateKey& McEliece_PrivateKey::operator=(McEliece_PrivateKey&&) noexcept = default;
203McEliece_PrivateKey::~McEliece_PrivateKey() = default;
204
206 const std::vector<uint32_t>& parity_check_matrix_coeffs,
207 const std::vector<polyn_gf2m>& square_root_matrix,
208 const std::vector<gf2m>& inverse_support,
209 const std::vector<uint8_t>& public_matrix) {
210 const int goppa_degree = goppa_polyn.get_degree();
211 if(goppa_degree <= 0) {
212 throw Decoding_Error("invalid McEliece Goppa polynomial degree");
213 }
214
215 const McEliece_Params params = mceliece_validate_key_params(inverse_support.size(), goppa_degree);
216 validate_private_components(
217 goppa_polyn, parity_check_matrix_coeffs, square_root_matrix, inverse_support, public_matrix, params);
218
219 m_public = std::make_shared<const McEliece_PublicKeyInternal>(public_matrix, params.t, params.code_length);
220 m_private = std::make_shared<const McEliece_PrivateKeyInternal>(std::vector<polyn_gf2m>{goppa_polyn},
221 square_root_matrix,
222 inverse_support,
223 parity_check_matrix_coeffs,
224 params.codimension,
225 params.dimension);
226}
227
228// NOLINTNEXTLINE(*-member-init)
230 const McEliece_Params params = mceliece_validate_keygen_params(code_length, t);
231 *this = generate_mceliece_key(rng, params.ext_deg, code_length, t);
232}
233
235 const size_t codimension = ceil_log2(m_code_length) * m_t;
236 return m_code_length - codimension;
237}
238
240 const size_t bits = message_word_bit_length();
241
242 secure_vector<uint8_t> plaintext((bits + 7) / 8);
243 rng.randomize(plaintext.data(), plaintext.size());
244
245 // unset unused bits in the last plaintext byte
246 if(const uint32_t used = bits % 8) {
247 const uint8_t mask = (1 << used) - 1;
248 plaintext[plaintext.size() - 1] &= mask;
249 }
250
251 return plaintext;
252}
253
254McEliece_PublicKey::McEliece_PublicKey(const std::vector<uint8_t>& pub_matrix, size_t t, size_t the_code_length) {
255 const McEliece_Params params = mceliece_validate_key_params(the_code_length, t);
256 validate_public_matrix(pub_matrix, params);
257 m_public = std::make_shared<const McEliece_PublicKeyInternal>(pub_matrix, t, the_code_length);
258}
259
261 return m_public->t();
262}
263
265 return m_public->code_length();
266}
267
268const std::vector<uint8_t>& McEliece_PublicKey::get_public_matrix() const {
269 return m_public->public_matrix();
270}
271
273 return m_public->message_word_bit_length();
274}
275
277 return m_public->random_plaintext_element(rng);
278}
279
280bool McEliece_PublicKey::check_key(RandomNumberGenerator& /*rng*/, bool /*strong*/) const {
281 try {
282 if(!m_public) {
283 return false;
284 }
285
286 const McEliece_Params params = mceliece_validate_key_params(m_public->code_length(), m_public->t());
287 validate_public_matrix(m_public->public_matrix(), params);
288 return true;
289 } catch(...) {
290 return false;
291 }
292}
293
295 return m_private->goppa_polyn();
296}
297
298const std::vector<uint32_t>& McEliece_PrivateKey::get_H_coeffs() const {
299 return m_private->H_coeffs();
300}
301
302const std::vector<gf2m>& McEliece_PrivateKey::get_Linv() const {
303 return m_private->Linv();
304}
305
306const std::vector<polyn_gf2m>& McEliece_PrivateKey::get_sqrtmod() const {
307 return m_private->sqrtmod();
308}
309
311 return m_private->dimension();
312}
313
315 return m_private->codimension();
316}
317
321
322std::vector<uint8_t> McEliece_PublicKey::raw_public_key_bits() const {
323 return m_public->public_matrix();
324}
325
326std::vector<uint8_t> McEliece_PublicKey::public_key_bits() const {
327 std::vector<uint8_t> output;
328 DER_Encoder(output)
332 .encode(get_t())
333 .end_cons()
334 .encode(m_public->public_matrix(), ASN1_Type::OctetString)
335 .end_cons();
336 return output;
337}
338
340 return m_public->code_length();
341}
342
344 return mceliece_work_factor(m_public->code_length(), m_public->t());
345}
346
347McEliece_PublicKey::McEliece_PublicKey(std::span<const uint8_t> key_bits) :
349
350McEliece_PublicKey::McEliece_PublicKey(const AlgorithmIdentifier& alg_id, std::span<const uint8_t> key_bits) {
351 // The McEliece parameters are carried in the key bits; no AlgorithmIdentifier
352 // parameters are defined.
353 if(!alg_id.parameters_are_empty()) {
354 throw Decoding_Error("Unexpected parameters for McEliece public key");
355 }
356
357 BER_Decoder dec(key_bits, BER_Decoder::Limits::DER());
358 size_t n = 0;
359 size_t t = 0;
360 std::vector<uint8_t> public_matrix;
361 dec.start_sequence()
363 .decode(n)
364 .decode(t)
365 .end_cons()
366 .decode(public_matrix, ASN1_Type::OctetString)
367 .end_cons()
368 .verify_end();
369
371 validate_public_matrix(public_matrix, params);
372
373 m_public = std::make_shared<const McEliece_PublicKeyInternal>(std::move(public_matrix), t, n);
374}
375
377 DER_Encoder enc;
378 enc.start_sequence()
381 .encode(get_t())
382 .end_cons()
383 .encode(m_public->public_matrix(), ASN1_Type::OctetString)
384 .encode(m_private->goppa_polyn().encode(), ASN1_Type::OctetString); // g as octet string
385 enc.start_sequence();
386 for(const auto& x : m_private->sqrtmod()) {
387 enc.encode(x.encode(), ASN1_Type::OctetString);
388 }
389 enc.end_cons();
390 secure_vector<uint8_t> enc_support;
391
392 for(const uint16_t Linv : m_private->Linv()) {
393 enc_support.push_back(get_byte<0>(Linv));
394 enc_support.push_back(get_byte<1>(Linv));
395 }
396 enc.encode(enc_support, ASN1_Type::OctetString);
398 for(const uint32_t coef : m_private->H_coeffs()) {
399 enc_H.push_back(get_byte<0>(coef));
400 enc_H.push_back(get_byte<1>(coef));
401 enc_H.push_back(get_byte<2>(coef));
402 enc_H.push_back(get_byte<3>(coef));
403 }
404 enc.encode(enc_H, ASN1_Type::OctetString);
405 enc.end_cons();
406 return enc.get_contents();
407}
408
410 if(!McEliece_PublicKey::check_key(rng, strong)) {
411 return false;
412 }
413
414 if(!strong) {
415 return true;
416 }
417
418 const secure_vector<uint8_t> plaintext = this->random_plaintext_element(rng);
419
420 secure_vector<uint8_t> ciphertext;
422 mceliece_encrypt(ciphertext, errors, plaintext, *m_public, rng);
423
424 secure_vector<uint8_t> plaintext_out;
425 secure_vector<uint8_t> errors_out;
426 mceliece_decrypt(plaintext_out, errors_out, ciphertext, *m_private);
427
428 if(errors != errors_out || plaintext != plaintext_out) {
429 return false;
430 }
431
432 return true;
433}
434
435McEliece_PrivateKey::McEliece_PrivateKey(std::span<const uint8_t> key_bits) :
437
438McEliece_PrivateKey::McEliece_PrivateKey(const AlgorithmIdentifier& alg_id, std::span<const uint8_t> key_bits) {
439 // The McEliece parameters are carried in the key bits; no AlgorithmIdentifier
440 // parameters are defined.
441 if(!alg_id.parameters_are_empty()) {
442 throw Decoding_Error("Unexpected parameters for McEliece private key");
443 }
444
445 size_t n = 0;
446 size_t t = 0;
447 std::vector<uint8_t> public_matrix;
449 BER_Decoder dec_base(key_bits, BER_Decoder::Limits::DER());
450 BER_Decoder dec = dec_base.start_sequence();
451 dec.start_sequence().decode(n).decode(t).end_cons();
453
455 validate_public_matrix(public_matrix, params);
456
457 const auto sp_field = std::make_shared<GF2m_Field>(params.ext_deg);
458 std::vector<polyn_gf2m> g = {polyn_gf2m(enc_g, sp_field)};
459 std::vector<polyn_gf2m> sqrtmod;
460 BER_Decoder dec2 = dec.start_sequence();
461 for(uint32_t i = 0; i < t / 2; i++) {
462 secure_vector<uint8_t> sqrt_enc;
463 dec2.decode(sqrt_enc, ASN1_Type::OctetString);
464 while(sqrt_enc.size() < (t * 2)) {
465 // ensure that the length is always t
466 sqrt_enc.push_back(0);
467 sqrt_enc.push_back(0);
468 }
469 if(sqrt_enc.size() != t * 2) {
470 throw Decoding_Error("length of square root polynomial entry is too large");
471 }
472 sqrtmod.push_back(polyn_gf2m(sqrt_enc, sp_field));
473 }
474 secure_vector<uint8_t> enc_support;
475 dec2.end_cons();
476 dec.decode(enc_support, ASN1_Type::OctetString);
477 if(enc_support.size() % 2 != 0) {
478 throw Decoding_Error("encoded support has odd length");
479 }
480 if(enc_support.size() / 2 != n) {
481 throw Decoding_Error("encoded support has length different from code length");
482 }
483 std::vector<gf2m> Linv;
484 for(uint32_t i = 0; i < n * 2; i += 2) {
485 const gf2m el = (enc_support[i] << 8) | enc_support[i + 1];
486 Linv.push_back(el);
487 }
490 if(enc_H.size() % 4 != 0) {
491 throw Decoding_Error("encoded parity check matrix has length which is not a multiple of four");
492 }
493 if(enc_H.size() / 4 != params.words_per_matrix_row * n) {
494 throw Decoding_Error("encoded parity check matrix has wrong length");
495 }
496
497 std::vector<uint32_t> coeffs;
498 for(uint32_t i = 0; i < enc_H.size(); i += 4) {
499 coeffs.push_back(make_uint32(enc_H[i], enc_H[i + 1], enc_H[i + 2], enc_H[i + 3]));
500 }
501
502 validate_private_components(g[0], coeffs, sqrtmod, Linv, public_matrix, params);
503
504 m_public = std::make_shared<const McEliece_PublicKeyInternal>(std::move(public_matrix), t, n);
505 m_private = std::make_shared<const McEliece_PrivateKeyInternal>(
506 std::move(g), std::move(sqrtmod), std::move(Linv), std::move(coeffs), params.codimension, params.dimension);
507}
508
510 if(*static_cast<const McEliece_PublicKey*>(this) != *static_cast<const McEliece_PublicKey*>(&other)) {
511 return false;
512 }
513 if(m_private->goppa_polyn_vec() != other.m_private->goppa_polyn_vec()) {
514 return false;
515 }
516
517 if(m_private->sqrtmod() != other.m_private->sqrtmod()) {
518 return false;
519 }
520 if(m_private->Linv() != other.m_private->Linv()) {
521 return false;
522 }
523 if(m_private->H_coeffs() != other.m_private->H_coeffs()) {
524 return false;
525 }
526
527 if(m_private->codimension() != other.m_private->codimension() ||
528 m_private->dimension() != other.m_private->dimension()) {
529 return false;
530 }
531
532 return true;
533}
534
535std::unique_ptr<Public_Key> McEliece_PrivateKey::public_key() const {
536 return std::make_unique<McEliece_PublicKey>(get_public_matrix(), get_t(), get_code_length());
537}
538
540 if(m_public->public_matrix() != other.m_public->public_matrix()) {
541 return false;
542 }
543 if(m_public->t() != other.m_public->t()) {
544 return false;
545 }
546 if(m_public->code_length() != other.m_public->code_length()) {
547 return false;
548 }
549 return true;
550}
551
552namespace {
553
554class MCE_KEM_Encryptor final : public PK_Ops::KEM_Encryption_with_KDF {
555 public:
556 // The raw shared key is the plaintext and error mask, which is not uniform
557 MCE_KEM_Encryptor(std::shared_ptr<const McEliece_PublicKeyInternal> key, const PK_KEM_Options_Reader& options) :
558 KEM_Encryption_with_KDF(options, PK_Ops::KemSharedKeyQuality::RequiresKDF), m_key(std::move(key)) {}
559
560 private:
561 size_t raw_kem_shared_key_length() const override {
562 const size_t err_sz = (m_key->code_length() + 7) / 8;
563 const size_t ptext_sz = (m_key->message_word_bit_length() + 7) / 8;
564 return ptext_sz + err_sz;
565 }
566
567 size_t encapsulated_key_length() const override { return (m_key->code_length() + 7) / 8; }
568
569 void raw_kem_encrypt(std::span<uint8_t> out_encapsulated_key,
570 std::span<uint8_t> raw_shared_key,
571 RandomNumberGenerator& rng) override {
572 secure_vector<uint8_t> plaintext = m_key->random_plaintext_element(rng);
573
574 secure_vector<uint8_t> ciphertext;
575 secure_vector<uint8_t> error_mask;
576 mceliece_encrypt(ciphertext, error_mask, plaintext, *m_key, rng);
577
578 // TODO: Perhaps avoid the copies below
579 BOTAN_ASSERT_NOMSG(out_encapsulated_key.size() == ciphertext.size());
580 std::copy(ciphertext.begin(), ciphertext.end(), out_encapsulated_key.begin());
581
582 BOTAN_ASSERT_NOMSG(raw_shared_key.size() == plaintext.size() + error_mask.size());
583 BufferStuffer bs(raw_shared_key);
584 bs.append(plaintext);
585 bs.append(error_mask);
586 }
587
588 std::shared_ptr<const McEliece_PublicKeyInternal> m_key;
589};
590
591class MCE_KEM_Decryptor final : public PK_Ops::KEM_Decryption_with_KDF {
592 public:
593 MCE_KEM_Decryptor(std::shared_ptr<const McEliece_PrivateKeyInternal> key, const PK_KEM_Options_Reader& options) :
594 KEM_Decryption_with_KDF(options, PK_Ops::KemSharedKeyQuality::RequiresKDF), m_key(std::move(key)) {}
595
596 private:
597 size_t raw_kem_shared_key_length() const override {
598 const size_t err_sz = (m_key->code_length() + 7) / 8;
599 const size_t ptext_sz = (m_key->message_word_bit_length() + 7) / 8;
600 return ptext_sz + err_sz;
601 }
602
603 size_t encapsulated_key_length() const override { return (m_key->code_length() + 7) / 8; }
604
605 void raw_kem_decrypt(std::span<uint8_t> out_shared_key, std::span<const uint8_t> encapsulated_key) override {
606 secure_vector<uint8_t> plaintext;
607 secure_vector<uint8_t> error_mask;
608 mceliece_decrypt(plaintext, error_mask, encapsulated_key.data(), encapsulated_key.size(), *m_key);
609
610 // TODO: perhaps avoid the copies below
611 BOTAN_ASSERT_NOMSG(out_shared_key.size() == plaintext.size() + error_mask.size());
612 BufferStuffer bs(out_shared_key);
613 bs.append(plaintext);
614 bs.append(error_mask);
615 }
616
617 std::shared_ptr<const McEliece_PrivateKeyInternal> m_key;
618};
619
620} // namespace
621
622std::unique_ptr<Private_Key> McEliece_PublicKey::generate_another(RandomNumberGenerator& rng) const {
623 return std::make_unique<McEliece_PrivateKey>(rng, get_code_length(), get_t());
624}
625
626std::unique_ptr<PK_Ops::KEM_Encryption> McEliece_PublicKey::_create_kem_encryption_op(
627 const PK_KEM_Options_Reader& options) const {
629
630 return std::make_unique<MCE_KEM_Encryptor>(m_public, options);
631}
632
633std::unique_ptr<PK_Ops::KEM_Decryption> McEliece_PrivateKey::_create_kem_decryption_op(
634 RandomNumberGenerator& rng, const PK_KEM_Options_Reader& options) const {
635 BOTAN_UNUSED(rng);
637
638 return std::make_unique<MCE_KEM_Decryptor>(m_private, options);
639}
640
641} // 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
virtual OID object_identifier() const
Definition pk_keys.cpp:24
static Limits DER()
Definition ber_dec.h:44
void push_back(const BER_Object &obj)
Definition ber_dec.cpp:605
BER_Decoder & decode(bool &out)
Definition ber_dec.h:361
BER_Decoder & verify_end()
Definition ber_dec.cpp:471
BER_Decoder & end_cons()
Definition ber_dec.cpp:635
BER_Decoder start_sequence()
Definition ber_dec.h:279
secure_vector< uint8_t > get_contents()
Definition der_enc.cpp:161
DER_Encoder & start_sequence()
Definition der_enc.h:86
DER_Encoder & end_cons()
Definition der_enc.cpp:208
DER_Encoder & encode(bool b)
Definition der_enc.cpp:313
secure_vector< uint8_t > private_key_bits() const override
const std::vector< polyn_gf2m > & get_sqrtmod() const
McEliece_PrivateKey(RandomNumberGenerator &rng, size_t code_length, size_t t)
std::unique_ptr< Public_Key > public_key() const override
std::unique_ptr< PK_Ops::KEM_Decryption > _create_kem_decryption_op(RandomNumberGenerator &rng, const PK_KEM_Options_Reader &options) const override
const polyn_gf2m & get_goppa_polyn() const
const std::vector< gf2m > & get_Linv() const
bool operator==(const McEliece_PrivateKey &other) const
const std::vector< uint32_t > & get_H_coeffs() const
bool check_key(RandomNumberGenerator &rng, bool strong) const override
secure_vector< uint8_t > random_plaintext_element(RandomNumberGenerator &rng) const
secure_vector< uint8_t > random_plaintext_element(RandomNumberGenerator &rng) const
size_t get_message_word_bit_length() const
std::shared_ptr< const McEliece_PublicKeyInternal > m_public
Definition mceliece.h:80
std::vector< uint8_t > raw_public_key_bits() const override
std::string algo_name() const override
Definition mceliece.h:44
std::vector< uint8_t > public_key_bits() const override
std::unique_ptr< PK_Ops::KEM_Encryption > _create_kem_encryption_op(const PK_KEM_Options_Reader &options) const override
std::unique_ptr< Private_Key > generate_another(RandomNumberGenerator &rng) const final
McEliece_PublicKey(const AlgorithmIdentifier &alg_id, std::span< const uint8_t > key_bits)
const std::vector< uint8_t > & get_public_matrix() const
bool check_key(RandomNumberGenerator &rng, bool strong) const override
size_t estimated_strength() const override
bool operator==(const McEliece_PublicKey &other) const
AlgorithmIdentifier algorithm_identifier() const override
size_t key_length() const override
void randomize(std::span< uint8_t > output)
Definition rng.h:86
constexpr uint8_t get_byte(T input)
Definition loadstor.h:79
void mceliece_decrypt(secure_vector< uint8_t > &plaintext_out, secure_vector< uint8_t > &error_mask_out, const secure_vector< uint8_t > &ciphertext, const McEliece_PrivateKeyInternal &key)
constexpr uint32_t make_uint32(uint8_t i0, uint8_t i1, uint8_t i2, uint8_t i3)
Definition loadstor.h:104
constexpr uint8_t ceil_log2(T x)
Definition bit_ops.h:140
McEliece_PrivateKey generate_mceliece_key(RandomNumberGenerator &rng, size_t ext_deg, size_t code_length, size_t t)
size_t mceliece_work_factor(size_t n, size_t t)
void require_software_provider(const OptionsT &options, std::string_view algo_name)
constexpr auto load_le(ParamTs &&... params)
Definition loadstor.h:495
void mceliece_encrypt(secure_vector< uint8_t > &ciphertext_out, secure_vector< uint8_t > &error_mask_out, const secure_vector< uint8_t > &plaintext, const McEliece_PublicKeyInternal &key, RandomNumberGenerator &rng)
Definition mceliece.cpp:119
std::vector< T, secure_allocator< T > > secure_vector
Definition secmem.h:128
size_t bit_size_to_32bit_size(size_t bit_size)
McEliece_Params mceliece_validate_key_params(size_t code_length, size_t t)
McEliece_Params mceliece_validate_keygen_params(size_t code_length, size_t t)
uint16_t gf2m