Botan 3.14.1
Crypto and TLS for C&
cmce.cpp
Go to the documentation of this file.
1/*
2 * Classic McEliece Key Generation
3 * (C) 2023 Jack Lloyd
4 * 2023,2024 Fabian Albert, Amos Treiber - Rohde & Schwarz Cybersecurity
5 *
6 * Botan is released under the Simplified BSD License (see license.txt)
7 **/
8
9#include <botan/cmce.h>
10#include <botan/pk_ops.h>
11#include <botan/rng.h>
12#include <botan/internal/cmce_decaps.h>
13#include <botan/internal/cmce_encaps.h>
14#include <botan/internal/cmce_keys_internal.h>
15#include <botan/internal/cmce_matrix.h>
16#include <botan/internal/ct_utils.h>
17#include <botan/internal/pk_options_impl.h>
18
19namespace Botan {
20
22 std::span<const uint8_t> key_bits) :
23 Classic_McEliece_PublicKey(key_bits, Classic_McEliece_Parameter_Set::from_oid(alg_id.oid())) {
24 // The parameter set is identified by the OID; no parameters are defined.
25 if(!alg_id.parameters_are_empty()) {
26 throw Decoding_Error("Unexpected parameters for Classic McEliece public key");
27 }
28}
29
32 const auto params = Classic_McEliece_Parameters::create(param_set);
33 if(key_bits.size() != params.pk_size_bytes()) {
34 throw Decoding_Error("Invalid Classic McEliece public key length");
35 }
36 m_public = std::make_shared<Classic_McEliece_PublicKeyInternal>(
37 params, Classic_McEliece_Matrix(params, {key_bits.begin(), key_bits.end()}));
38}
39
41 m_public = std::make_shared<Classic_McEliece_PublicKeyInternal>(*other.m_public);
42}
43
45 if(this != &other) {
46 m_public = std::make_shared<Classic_McEliece_PublicKeyInternal>(*other.m_public);
47 }
48 return *this;
49}
50
54
56 return m_public->params().object_identifier();
57}
58
60 // The key length is the dimension k of the goppa code (i.e. the code has 2^k codewords)
61 return m_public->params().pk_no_cols();
62}
63
65 return m_public->params().estimated_strength();
66}
67
68std::vector<uint8_t> Classic_McEliece_PublicKey::public_key_bits() const {
69 return raw_public_key_bits();
70}
71
73 return m_public->matrix().bytes();
74}
75
76bool Classic_McEliece_PublicKey::check_key(RandomNumberGenerator& /*rng*/, bool /*strong*/) const {
77 return true;
78}
79
81 return std::make_unique<Classic_McEliece_PrivateKey>(rng, m_public->params().parameter_set());
82}
83
84std::unique_ptr<PK_Ops::KEM_Encryption> Classic_McEliece_PublicKey::_create_kem_encryption_op(
85 const PK_KEM_Options_Reader& options) const {
87
88 return std::make_unique<Classic_McEliece_Encryptor>(this->m_public, options);
89}
90
93 const auto params = Classic_McEliece_Parameters::create(param_set);
94 const auto seed = rng.random_vec<CmceInitialSeed>(params.seed_len());
95 CT::poison(seed);
96 std::tie(m_private, m_public) = Classic_McEliece_KeyPair_Internal::generate(params, seed).decompose_to_pair();
97
98 BOTAN_ASSERT_NONNULL(m_private);
100 CT::unpoison_all(*m_private, *m_public);
101}
102
105 const auto scope = CT::scoped_poison(sk);
106 const auto params = Classic_McEliece_Parameters::create(param_set);
107 auto sk_internal = Classic_McEliece_PrivateKeyInternal::from_bytes(params, sk);
108 m_private = std::make_shared<Classic_McEliece_PrivateKeyInternal>(std::move(sk_internal));
109 // This creates and loads the public key, which is very large. Potentially, we could only load
110 // it on demand (since one may use the private key only for decapsulation without needing the public key).
111 // TODO: consider building a load-on-demand mechanism for the public key
113 CT::unpoison_all(*m_public, *m_private);
114}
115
117 std::span<const uint8_t> key_bits) :
118 Classic_McEliece_PrivateKey(key_bits, Classic_McEliece_Parameter_Set::from_oid(alg_id.oid())) {
119 // The parameter set is identified by the OID; no parameters are defined.
120 if(!alg_id.parameters_are_empty()) {
121 throw Decoding_Error("Unexpected parameters for Classic McEliece private key");
122 }
123}
124
125std::unique_ptr<Public_Key> Classic_McEliece_PrivateKey::public_key() const {
126 return std::make_unique<Classic_McEliece_PublicKey>(*this);
127}
128
132
134 return m_private->serialize();
135}
136
138 // Loading verified the key's structure (including that the public matrix it
139 // yields is systematic); re-deriving s, g and alpha from delta is expensive
140 return !strong || m_private->check_key();
141}
142
143std::unique_ptr<PK_Ops::KEM_Decryption> Classic_McEliece_PrivateKey::_create_kem_decryption_op(
144 RandomNumberGenerator& rng, const PK_KEM_Options_Reader& options) const {
145 BOTAN_UNUSED(rng);
147
148 return std::make_unique<Classic_McEliece_Decryptor>(this->m_private, options);
149}
150
151} // namespace Botan
#define BOTAN_UNUSED
Definition assert.h:151
#define BOTAN_ASSERT_NONNULL(ptr)
Definition assert.h:121
bool parameters_are_empty() const
Definition asn1_obj.h:715
Representation of the binary Classic McEliece matrix H, with H = (I_mt | T).
Definition cmce_matrix.h:26
static Classic_McEliece_Parameters create(Classic_McEliece_Parameter_Set set)
Create Classic McEliece parameters from a parameter set.
static Classic_McEliece_PrivateKeyInternal from_bytes(const Classic_McEliece_Parameters &params, std::span< const uint8_t > sk_bytes)
Parses a Classic McEliece private key from a byte sequence.
std::unique_ptr< PK_Ops::KEM_Decryption > _create_kem_decryption_op(RandomNumberGenerator &rng, const PK_KEM_Options_Reader &options) const override
Definition cmce.cpp:143
Classic_McEliece_PrivateKey(RandomNumberGenerator &rng, Classic_McEliece_Parameter_Set param_set)
Create a new Classic McEliece private key for a specified parameter set.
Definition cmce.cpp:91
bool check_key(RandomNumberGenerator &rng, bool strong) const override
Definition cmce.cpp:137
secure_vector< uint8_t > private_key_bits() const override
Definition cmce.cpp:129
std::unique_ptr< Public_Key > public_key() const override
Definition cmce.cpp:125
secure_vector< uint8_t > raw_private_key_bits() const override
Definition cmce.cpp:133
static std::shared_ptr< Classic_McEliece_PublicKeyInternal > create_from_private_key(const Classic_McEliece_PrivateKeyInternal &sk)
Create a Classic McEliece public key from a private key.
size_t key_length() const override
Definition cmce.cpp:59
AlgorithmIdentifier algorithm_identifier() const override
Definition cmce.cpp:51
std::unique_ptr< PK_Ops::KEM_Encryption > _create_kem_encryption_op(const PK_KEM_Options_Reader &options) const override
Definition cmce.cpp:84
std::unique_ptr< Private_Key > generate_another(RandomNumberGenerator &rng) const final
Definition cmce.cpp:80
bool check_key(RandomNumberGenerator &rng, bool strong) const override
Definition cmce.cpp:76
Classic_McEliece_PublicKey & operator=(const Classic_McEliece_PublicKey &other)
Definition cmce.cpp:44
Classic_McEliece_PublicKey(const AlgorithmIdentifier &alg_id, std::span< const uint8_t > key_bits)
Load a Classic McEliece public key from bytes.
Definition cmce.cpp:21
std::shared_ptr< const Classic_McEliece_PublicKeyInternal > m_public
Definition cmce.h:100
size_t estimated_strength() const override
Definition cmce.cpp:64
std::string algo_name() const override
Definition cmce.h:71
OID object_identifier() const override
Definition cmce.cpp:55
std::vector< uint8_t > public_key_bits() const override
Definition cmce.cpp:68
std::vector< uint8_t > raw_public_key_bits() const override
Definition cmce.cpp:72
void random_vec(std::span< uint8_t > v)
Definition rng.h:254
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 poison(const T *p, size_t n)
Definition ct_utils.h:56
Strong< secure_vector< uint8_t >, struct CmceInitialSeed_ > CmceInitialSeed
Represents initial delta of keygen.
Definition cmce_types.h:31
void require_software_provider(const OptionsT &options, std::string_view algo_name)
std::vector< T, secure_allocator< T > > secure_vector
Definition secmem.h:128
static Classic_McEliece_KeyPair_Internal generate(const Classic_McEliece_Parameters &params, StrongSpan< const CmceInitialSeed > seed)
Generate a Classic McEliece key pair using the algorithm described in Classic McEliece ISO Section 8....
std::pair< std::shared_ptr< Classic_McEliece_PrivateKeyInternal >, std::shared_ptr< Classic_McEliece_PublicKeyInternal > > decompose_to_pair() &&
Decompose the key pair into a pair of shared pointers to the private and public key.