Botan  2.19.1
Crypto and TLS for C++11
Public Member Functions | Protected Attributes | List of all members
Botan::McEliece_PrivateKey Class Referencefinal

#include <mceliece.h>

Inheritance diagram for Botan::McEliece_PrivateKey:
Botan::McEliece_PublicKey Botan::Private_Key Botan::Public_Key Botan::Public_Key

Public Member Functions

std::string algo_name () const override
 
AlgorithmIdentifier algorithm_identifier () const override
 
bool check_key (RandomNumberGenerator &rng, bool strong) const override
 
virtual std::unique_ptr< PK_Ops::Decryptioncreate_decryption_op (RandomNumberGenerator &rng, const std::string &params, const std::string &provider) const
 
virtual std::unique_ptr< PK_Ops::Encryptioncreate_encryption_op (RandomNumberGenerator &rng, const std::string &params, const std::string &provider) const
 
std::unique_ptr< PK_Ops::KEM_Decryptioncreate_kem_decryption_op (RandomNumberGenerator &rng, const std::string &params, const std::string &provider) const override
 
std::unique_ptr< PK_Ops::KEM_Encryptioncreate_kem_encryption_op (RandomNumberGenerator &rng, const std::string &params, const std::string &provider) const override
 
virtual std::unique_ptr< PK_Ops::Key_Agreementcreate_key_agreement_op (RandomNumberGenerator &rng, const std::string &params, const std::string &provider) const
 
virtual std::unique_ptr< PK_Ops::Signaturecreate_signature_op (RandomNumberGenerator &rng, const std::string &params, const std::string &provider) const
 
virtual std::unique_ptr< PK_Ops::Verificationcreate_verification_op (const std::string &params, const std::string &provider) const
 
virtual Signature_Format default_x509_signature_format () const
 
size_t estimated_strength () const override
 
std::string fingerprint (const std::string &alg) const
 
std::string fingerprint_private (const std::string &alg) const
 
std::string fingerprint_public (const std::string &alg="SHA-256") const
 
size_t get_code_length () const
 
size_t get_codimension () const
 
size_t get_dimension () const
 
polyn_gf2m const & get_goppa_polyn () const
 
std::vector< uint32_t > const & get_H_coeffs () const
 
std::vector< gf2m > const & get_Linv () const
 
size_t get_message_word_bit_length () const
 
virtual OID get_oid () const
 
const std::vector< uint8_t > & get_public_matrix () const
 
std::vector< polyn_gf2m > const & get_sqrtmod () const
 
size_t get_t () const
 
size_t key_length () const override
 
 McEliece_PrivateKey (RandomNumberGenerator &rng, size_t code_length, size_t t)
 
 McEliece_PrivateKey (const secure_vector< uint8_t > &key_bits)
 
 McEliece_PrivateKey (polyn_gf2m const &goppa_polyn, std::vector< uint32_t > const &parity_check_matrix_coeffs, std::vector< polyn_gf2m > const &square_root_matrix, std::vector< gf2m > const &inverse_support, std::vector< uint8_t > const &public_matrix)
 
virtual size_t message_part_size () const
 
virtual size_t message_parts () const
 
bool operator!= (const McEliece_PublicKey &other) const
 
bool operator!= (const McEliece_PrivateKey &other) const
 
bool operator== (const McEliece_PublicKey &other) const
 
bool operator== (const McEliece_PrivateKey &other) const
 
virtual AlgorithmIdentifier pkcs8_algorithm_identifier () const
 
secure_vector< uint8_t > private_key_bits () const override
 
secure_vector< uint8_t > private_key_info () const
 
std::vector< uint8_t > public_key_bits () const override
 
secure_vector< uint8_t > random_plaintext_element (RandomNumberGenerator &rng) const
 
virtual bool stateful_operation () const
 
std::vector< uint8_t > subject_public_key () const
 
 ~McEliece_PrivateKey ()
 

Protected Attributes

size_t m_code_length
 
std::vector< uint8_t > m_public_matrix
 
size_t m_t
 

Detailed Description

Definition at line 73 of file mceliece.h.

Constructor & Destructor Documentation

Botan::McEliece_PrivateKey::McEliece_PrivateKey ( RandomNumberGenerator rng,
size_t  code_length,
size_t  t 
)

Generate a McEliece key pair

Suggested parameters for a given security level (SL)

SL=80 n=1632 t=33 - 59 KB pubkey 140 KB privkey SL=107 n=2480 t=45 - 128 KB pubkey 300 KB privkey SL=128 n=2960 t=57 - 195 KB pubkey 459 KB privkey SL=147 n=3408 t=67 - 265 KB pubkey 622 KB privkey SL=191 n=4624 t=95 - 516 KB pubkey 1234 KB privkey SL=256 n=6624 t=115 - 942 KB pubkey 2184 KB privkey

Definition at line 41 of file mceliece_key.cpp.

References Botan::ceil_log2(), and Botan::generate_mceliece_key().

42  {
43  uint32_t ext_deg = ceil_log2(code_length);
44  *this = generate_mceliece_key(rng, ext_deg, code_length, t);
45  }
uint8_t ceil_log2(T x)
Definition: bit_ops.h:119
McEliece_PrivateKey generate_mceliece_key(RandomNumberGenerator &rng, size_t ext_deg, size_t code_length, size_t t)
Botan::McEliece_PrivateKey::McEliece_PrivateKey ( const secure_vector< uint8_t > &  key_bits)
explicit

Definition at line 177 of file mceliece_key.cpp.

References Botan::bit_size_to_32bit_size(), Botan::ceil_log2(), Botan::BER_Decoder::decode(), Botan::BER_Decoder::end_cons(), Botan::McEliece_PublicKey::m_code_length, Botan::McEliece_PublicKey::m_public_matrix, Botan::McEliece_PublicKey::m_t, Botan::OCTET_STRING, Botan::BER_Decoder::push_back(), Botan::SEQUENCE, and Botan::BER_Decoder::start_cons().

178  {
179  size_t n, t;
180  secure_vector<uint8_t> enc_g;
181  BER_Decoder dec_base(key_bits);
182  BER_Decoder dec = dec_base.start_cons(SEQUENCE)
183  .start_cons(SEQUENCE)
184  .decode(n)
185  .decode(t)
186  .end_cons()
187  .decode(m_public_matrix, OCTET_STRING)
188  .decode(enc_g, OCTET_STRING);
189 
190  if(t == 0 || n == 0)
191  throw Decoding_Error("invalid McEliece parameters");
192 
193  uint32_t ext_deg = ceil_log2(n);
194  m_code_length = n;
195  m_t = t;
196  m_codimension = (ext_deg * t);
197  m_dimension = (n - m_codimension);
198 
199  std::shared_ptr<GF2m_Field> sp_field(new GF2m_Field(ext_deg));
200  m_g = { polyn_gf2m(enc_g, sp_field) };
201  if(m_g[0].get_degree() != static_cast<int>(t))
202  {
203  throw Decoding_Error("degree of decoded Goppa polynomial is incorrect");
204  }
205  BER_Decoder dec2 = dec.start_cons(SEQUENCE);
206  for(uint32_t i = 0; i < t/2; i++)
207  {
208  secure_vector<uint8_t> sqrt_enc;
209  dec2.decode(sqrt_enc, OCTET_STRING);
210  while(sqrt_enc.size() < (t*2))
211  {
212  // ensure that the length is always t
213  sqrt_enc.push_back(0);
214  sqrt_enc.push_back(0);
215  }
216  if(sqrt_enc.size() != t*2)
217  {
218  throw Decoding_Error("length of square root polynomial entry is too large");
219  }
220  m_sqrtmod.push_back(polyn_gf2m(sqrt_enc, sp_field));
221  }
222  secure_vector<uint8_t> enc_support;
223  BER_Decoder dec3 = dec2.end_cons()
224  .decode(enc_support, OCTET_STRING);
225  if(enc_support.size() % 2)
226  {
227  throw Decoding_Error("encoded support has odd length");
228  }
229  if(enc_support.size() / 2 != n)
230  {
231  throw Decoding_Error("encoded support has length different from code length");
232  }
233  for(uint32_t i = 0; i < n*2; i+=2)
234  {
235  gf2m el = (enc_support[i] << 8) | enc_support[i+1];
236  m_Linv.push_back(el);
237  }
238  secure_vector<uint8_t> enc_H;
239  dec3.decode(enc_H, OCTET_STRING)
240  .end_cons();
241  if(enc_H.size() % 4)
242  {
243  throw Decoding_Error("encoded parity check matrix has length which is not a multiple of four");
244  }
245  if(enc_H.size() / 4 != bit_size_to_32bit_size(m_codimension) * m_code_length)
246  {
247  throw Decoding_Error("encoded parity check matrix has wrong length");
248  }
249 
250  for(uint32_t i = 0; i < enc_H.size(); i+=4)
251  {
252  uint32_t coeff = (enc_H[i] << 24) | (enc_H[i+1] << 16) | (enc_H[i+2] << 8) | enc_H[i+3];
253  m_coeffs.push_back(coeff);
254  }
255 
256  }
std::vector< uint8_t > m_public_matrix
Definition: mceliece.h:68
size_t bit_size_to_32bit_size(size_t bit_size)
uint16_t gf2m
Definition: gf2m_small_m.h:22
uint8_t ceil_log2(T x)
Definition: bit_ops.h:119
Botan::McEliece_PrivateKey::McEliece_PrivateKey ( polyn_gf2m const &  goppa_polyn,
std::vector< uint32_t > const &  parity_check_matrix_coeffs,
std::vector< polyn_gf2m > const &  square_root_matrix,
std::vector< gf2m > const &  inverse_support,
std::vector< uint8_t > const &  public_matrix 
)

Definition at line 26 of file mceliece_key.cpp.

30  :
31  McEliece_PublicKey(public_matrix, goppa_polyn.get_degree(), inverse_support.size()),
32  m_g{goppa_polyn},
33  m_sqrtmod(square_root_matrix),
34  m_Linv(inverse_support),
35  m_coeffs(parity_check_matrix_coeffs),
36  m_codimension(static_cast<size_t>(ceil_log2(inverse_support.size())) * goppa_polyn.get_degree()),
37  m_dimension(inverse_support.size() - m_codimension)
38  {
39  }
uint8_t ceil_log2(T x)
Definition: bit_ops.h:119
Botan::McEliece_PrivateKey::~McEliece_PrivateKey ( )
default

Member Function Documentation

std::string Botan::McEliece_PublicKey::algo_name ( ) const
inlineoverridevirtualinherited

Get the name of the underlying public key scheme.

Returns
name of the public key scheme

Implements Botan::Public_Key.

Definition at line 40 of file mceliece.h.

Referenced by create_kem_decryption_op(), and Botan::McEliece_PublicKey::create_kem_encryption_op().

40 { return "McEliece"; }
AlgorithmIdentifier Botan::McEliece_PublicKey::algorithm_identifier ( ) const
overridevirtualinherited
Returns
X.509 AlgorithmIdentifier for this key

Implements Botan::Public_Key.

Definition at line 77 of file mceliece_key.cpp.

References Botan::Public_Key::get_oid(), and Botan::AlgorithmIdentifier::USE_EMPTY_PARAM.

78  {
79  return AlgorithmIdentifier(get_oid(), AlgorithmIdentifier::USE_EMPTY_PARAM);
80  }
virtual OID get_oid() const
Definition: pk_keys.cpp:53
bool Botan::McEliece_PrivateKey::check_key ( RandomNumberGenerator rng,
bool  strong 
) const
overridevirtual

Test the key values for consistency.

Parameters
rngrng to use
strongwhether to perform strong and lengthy version of the test
Returns
true if the test is passed

Reimplemented from Botan::McEliece_PublicKey.

Definition at line 159 of file mceliece_key.cpp.

References Botan::mceliece_decrypt(), Botan::mceliece_encrypt(), and Botan::McEliece_PublicKey::random_plaintext_element().

160  {
161  const secure_vector<uint8_t> plaintext = this->random_plaintext_element(rng);
162 
163  secure_vector<uint8_t> ciphertext;
164  secure_vector<uint8_t> errors;
165  mceliece_encrypt(ciphertext, errors, plaintext, *this, rng);
166 
167  secure_vector<uint8_t> plaintext_out;
168  secure_vector<uint8_t> errors_out;
169  mceliece_decrypt(plaintext_out, errors_out, ciphertext, *this);
170 
171  if(errors != errors_out || plaintext != plaintext_out)
172  return false;
173 
174  return true;
175  }
secure_vector< uint8_t > random_plaintext_element(RandomNumberGenerator &rng) const
void mceliece_decrypt(secure_vector< uint8_t > &plaintext_out, secure_vector< uint8_t > &error_mask_out, const secure_vector< uint8_t > &ciphertext, const McEliece_PrivateKey &key)
Definition: goppa_code.cpp:130
void mceliece_encrypt(secure_vector< uint8_t > &ciphertext_out, secure_vector< uint8_t > &error_mask_out, const secure_vector< uint8_t > &plaintext, const McEliece_PublicKey &key, RandomNumberGenerator &rng)
Definition: mceliece.cpp:120
std::unique_ptr< PK_Ops::Decryption > Botan::Private_Key::create_decryption_op ( RandomNumberGenerator rng,
const std::string &  params,
const std::string &  provider 
) const
virtualinherited

This is an internal library function exposed on key types. In almost all cases applications should use wrappers in pubkey.h

Return an decryption operation for this key/params or throw

Parameters
rnga random number generator. The PK_Op may maintain a reference to the RNG and use it many times. The rng must outlive any operations which reference it.
paramsadditional parameters
providerthe provider to use

Reimplemented in Botan::RSA_PrivateKey, Botan::SM2_PrivateKey, and Botan::ElGamal_PrivateKey.

Definition at line 114 of file pk_keys.cpp.

References Botan::Public_Key::algo_name().

Referenced by Botan::PK_Decryptor_EME::PK_Decryptor_EME().

117  {
118  throw Lookup_Error(algo_name() + " does not support decryption");
119  }
virtual std::string algo_name() const =0
std::unique_ptr< PK_Ops::Encryption > Botan::Public_Key::create_encryption_op ( RandomNumberGenerator rng,
const std::string &  params,
const std::string &  provider 
) const
virtualinherited

This is an internal library function exposed on key types. In almost all cases applications should use wrappers in pubkey.h

Return an encryption operation for this key/params or throw

Parameters
rnga random number generator. The PK_Op may maintain a reference to the RNG and use it many times. The rng must outlive any operations which reference it.
paramsadditional parameters
providerthe provider to use

Reimplemented in Botan::RSA_PublicKey, Botan::SM2_PublicKey, and Botan::ElGamal_PublicKey.

Definition at line 91 of file pk_keys.cpp.

References Botan::Public_Key::algo_name().

Referenced by Botan::PK_Encryptor_EME::PK_Encryptor_EME().

94  {
95  throw Lookup_Error(algo_name() + " does not support encryption");
96  }
virtual std::string algo_name() const =0
std::unique_ptr< PK_Ops::KEM_Decryption > Botan::McEliece_PrivateKey::create_kem_decryption_op ( RandomNumberGenerator rng,
const std::string &  params,
const std::string &  provider 
) const
overridevirtual

This is an internal library function exposed on key types. In almost all cases applications should use wrappers in pubkey.h

Return a KEM decryption operation for this key/params or throw

Parameters
rnga random number generator. The PK_Op may maintain a reference to the RNG and use it many times. The rng must outlive any operations which reference it.
paramsadditional parameters
providerthe provider to use

Reimplemented from Botan::Private_Key.

Definition at line 375 of file mceliece_key.cpp.

References Botan::McEliece_PublicKey::algo_name().

378  {
379  if(provider == "base" || provider.empty())
380  return std::unique_ptr<PK_Ops::KEM_Decryption>(new MCE_KEM_Decryptor(*this, params));
381  throw Provider_Not_Found(algo_name(), provider);
382  }
std::string algo_name() const override
Definition: mceliece.h:40
std::unique_ptr< PK_Ops::KEM_Encryption > Botan::McEliece_PublicKey::create_kem_encryption_op ( RandomNumberGenerator rng,
const std::string &  params,
const std::string &  provider 
) const
overridevirtualinherited

This is an internal library function exposed on key types. In almost all cases applications should use wrappers in pubkey.h

Return a KEM encryption operation for this key/params or throw

Parameters
rnga random number generator. The PK_Op may maintain a reference to the RNG and use it many times. The rng must outlive any operations which reference it.
paramsadditional parameters
providerthe provider to use

Reimplemented from Botan::Public_Key.

Definition at line 365 of file mceliece_key.cpp.

References Botan::McEliece_PublicKey::algo_name().

368  {
369  if(provider == "base" || provider.empty())
370  return std::unique_ptr<PK_Ops::KEM_Encryption>(new MCE_KEM_Encryptor(*this, params));
371  throw Provider_Not_Found(algo_name(), provider);
372  }
std::string algo_name() const override
Definition: mceliece.h:40
std::unique_ptr< PK_Ops::Key_Agreement > Botan::Private_Key::create_key_agreement_op ( RandomNumberGenerator rng,
const std::string &  params,
const std::string &  provider 
) const
virtualinherited

This is an internal library function exposed on key types. In almost all cases applications should use wrappers in pubkey.h

Return a key agreement operation for this key/params or throw

Parameters
rnga random number generator. The PK_Op may maintain a reference to the RNG and use it many times. The rng must outlive any operations which reference it.
paramsadditional parameters
providerthe provider to use

Reimplemented in Botan::ECDH_PrivateKey, Botan::Curve25519_PrivateKey, and Botan::DH_PrivateKey.

Definition at line 138 of file pk_keys.cpp.

References Botan::Public_Key::algo_name().

Referenced by Botan::PK_Key_Agreement::PK_Key_Agreement().

141  {
142  throw Lookup_Error(algo_name() + " does not support key agreement");
143  }
virtual std::string algo_name() const =0
std::unique_ptr< PK_Ops::Signature > Botan::Private_Key::create_signature_op ( RandomNumberGenerator rng,
const std::string &  params,
const std::string &  provider 
) const
virtualinherited

This is an internal library function exposed on key types. In almost all cases applications should use wrappers in pubkey.h

Return a signature operation for this key/params or throw

Parameters
rnga random number generator. The PK_Op may maintain a reference to the RNG and use it many times. The rng must outlive any operations which reference it.
paramsadditional parameters
providerthe provider to use

Reimplemented in Botan::XMSS_PrivateKey, Botan::TPM_PrivateKey, Botan::RSA_PrivateKey, Botan::ECDSA_PrivateKey, Botan::GOST_3410_PrivateKey, Botan::SM2_PrivateKey, Botan::ECGDSA_PrivateKey, Botan::ECKCDSA_PrivateKey, Botan::Ed25519_PrivateKey, and Botan::DSA_PrivateKey.

Definition at line 130 of file pk_keys.cpp.

References Botan::Public_Key::algo_name().

Referenced by Botan::PK_Signer::PK_Signer().

133  {
134  throw Lookup_Error(algo_name() + " does not support signatures");
135  }
virtual std::string algo_name() const =0
std::unique_ptr< PK_Ops::Verification > Botan::Public_Key::create_verification_op ( const std::string &  params,
const std::string &  provider 
) const
virtualinherited

This is an internal library function exposed on key types. In almost all cases applications should use wrappers in pubkey.h

Return a verification operation for this key/params or throw

Parameters
paramsadditional parameters
providerthe provider to use

Reimplemented in Botan::XMSS_PublicKey, Botan::RSA_PublicKey, Botan::ECDSA_PublicKey, Botan::XMSS_WOTS_Addressed_PublicKey, Botan::GOST_3410_PublicKey, Botan::ECGDSA_PublicKey, Botan::ECKCDSA_PublicKey, Botan::SM2_PublicKey, Botan::Ed25519_PublicKey, and Botan::DSA_PublicKey.

Definition at line 107 of file pk_keys.cpp.

References Botan::Public_Key::algo_name().

Referenced by Botan::XMSS_WOTS_Addressed_PublicKey::create_verification_op(), and Botan::PK_Verifier::PK_Verifier().

109  {
110  throw Lookup_Error(algo_name() + " does not support verification");
111  }
virtual std::string algo_name() const =0
virtual Signature_Format Botan::Public_Key::default_x509_signature_format ( ) const
inlinevirtualinherited

Reimplemented in Botan::GOST_3410_PublicKey.

Definition at line 125 of file pk_keys.h.

References Botan::DER_SEQUENCE, and Botan::IEEE_1363.

Referenced by Botan::X509_Object::choose_sig_format(), and Botan::X509_Object::verify_signature().

126  {
127  return (this->message_parts() >= 2) ? DER_SEQUENCE : IEEE_1363;
128  }
virtual size_t message_parts() const
Definition: pk_keys.h:112
size_t Botan::McEliece_PublicKey::estimated_strength ( ) const
overridevirtualinherited

Return the estimated strength of the underlying key against the best currently known attack. Note that this ignores anything but pure attacks against the key itself and do not take into account padding schemes, usage mistakes, etc which might reduce the strength. However it does suffice to provide an upper bound.

Returns
estimated strength in bits

Implements Botan::Public_Key.

Definition at line 101 of file mceliece_key.cpp.

References Botan::McEliece_PublicKey::m_code_length, Botan::McEliece_PublicKey::m_t, and Botan::mceliece_work_factor().

102  {
104  }
size_t mceliece_work_factor(size_t n, size_t t)
std::string Botan::Private_Key::fingerprint ( const std::string &  alg) const
inlineinherited

Definition at line 215 of file pk_keys.h.

216  {
217  return fingerprint_private(alg); // match behavior in previous versions
218  }
std::string fingerprint_private(const std::string &alg) const
Definition: pk_keys.cpp:85
std::string Botan::Private_Key::fingerprint_private ( const std::string &  alg) const
inherited
Returns
Hash of the PKCS #8 encoding for this key object

Definition at line 85 of file pk_keys.cpp.

References Botan::create_hex_fingerprint(), and Botan::Private_Key::private_key_bits().

Referenced by Botan::Certificate_Store_In_SQL::find_certs_for_key(), Botan::Certificate_Store_In_SQL::insert_key(), and Botan::Certificate_Store_In_SQL::remove_key().

86  {
88  }
virtual secure_vector< uint8_t > private_key_bits() const =0
AlgorithmIdentifier hash_algo
Definition: x509_obj.cpp:22
std::string create_hex_fingerprint(const uint8_t bits[], size_t bits_len, const std::string &hash_name)
Definition: pk_keys.cpp:17
std::string Botan::Public_Key::fingerprint_public ( const std::string &  alg = "SHA-256") const
inherited
Returns
Hash of the subject public key

Definition at line 77 of file pk_keys.cpp.

References Botan::create_hex_fingerprint(), and Botan::Public_Key::subject_public_key().

78  {
80  }
AlgorithmIdentifier hash_algo
Definition: x509_obj.cpp:22
std::string create_hex_fingerprint(const uint8_t bits[], size_t bits_len, const std::string &hash_name)
Definition: pk_keys.cpp:17
std::vector< uint8_t > subject_public_key() const
Definition: pk_keys.cpp:38
size_t Botan::McEliece_PublicKey::get_code_length ( ) const
inlineinherited
size_t Botan::McEliece_PrivateKey::get_codimension ( ) const
inline

Definition at line 111 of file mceliece.h.

Referenced by Botan::mceliece_decrypt().

111 { return m_codimension; }
size_t Botan::McEliece_PrivateKey::get_dimension ( ) const
inline

Definition at line 109 of file mceliece.h.

Referenced by Botan::mceliece_decrypt().

109 { return m_dimension; }
const polyn_gf2m & Botan::McEliece_PrivateKey::get_goppa_polyn ( ) const

Definition at line 49 of file mceliece_key.cpp.

Referenced by Botan::mceliece_decrypt().

50  {
51  return m_g[0];
52  }
std::vector<uint32_t> const& Botan::McEliece_PrivateKey::get_H_coeffs ( ) const
inline

Definition at line 105 of file mceliece.h.

Referenced by Botan::mceliece_decrypt().

105 { return m_coeffs; }
std::vector<gf2m> const& Botan::McEliece_PrivateKey::get_Linv ( ) const
inline

Definition at line 106 of file mceliece.h.

Referenced by Botan::mceliece_decrypt().

106 { return m_Linv; }
size_t Botan::McEliece_PublicKey::get_message_word_bit_length ( ) const
inherited

Definition at line 54 of file mceliece_key.cpp.

References Botan::ceil_log2(), Botan::McEliece_PublicKey::m_code_length, and Botan::McEliece_PublicKey::m_t.

Referenced by Botan::mceliece_decrypt(), and Botan::McEliece_PublicKey::random_plaintext_element().

55  {
56  size_t codimension = ceil_log2(m_code_length) * m_t;
57  return m_code_length - codimension;
58  }
uint8_t ceil_log2(T x)
Definition: bit_ops.h:119
OID Botan::Public_Key::get_oid ( ) const
virtualinherited
const std::vector<uint8_t>& Botan::McEliece_PublicKey::get_public_matrix ( ) const
inlineinherited

Definition at line 55 of file mceliece.h.

Referenced by Botan::mceliece_encrypt().

55 { return m_public_matrix; }
std::vector< uint8_t > m_public_matrix
Definition: mceliece.h:68
std::vector<polyn_gf2m> const& Botan::McEliece_PrivateKey::get_sqrtmod ( ) const
inline

Definition at line 107 of file mceliece.h.

Referenced by Botan::mceliece_decrypt().

107 { return m_sqrtmod; }
size_t Botan::McEliece_PublicKey::get_t ( ) const
inlineinherited
size_t Botan::McEliece_PublicKey::key_length ( ) const
overridevirtualinherited

Return an integer value best approximating the length of the primary security parameter. For example for RSA this will be the size of the modulus, for ECDSA the size of the ECC group, and for McEliece the size of the code will be returned.

Implements Botan::Public_Key.

Definition at line 96 of file mceliece_key.cpp.

References Botan::McEliece_PublicKey::m_code_length.

97  {
98  return m_code_length;
99  }
virtual size_t Botan::Public_Key::message_part_size ( ) const
inlinevirtualinherited

Returns how large each of the message parts refered to by message_parts() is

This function is public but applications should have few reasons to ever call this.

Returns
size of the message parts in bits

Reimplemented in Botan::ECDSA_PublicKey, Botan::GOST_3410_PublicKey, Botan::ECGDSA_PublicKey, Botan::ECKCDSA_PublicKey, Botan::SM2_PublicKey, and Botan::DSA_PublicKey.

Definition at line 123 of file pk_keys.h.

Referenced by Botan::PK_Signer::PK_Signer(), and Botan::PK_Verifier::PK_Verifier().

123 { return 0; }
virtual size_t Botan::Public_Key::message_parts ( ) const
inlinevirtualinherited

Returns more than 1 if the output of this algorithm (ciphertext, signature) should be treated as more than one value. This is used for algorithms like DSA and ECDSA, where the (r,s) output pair can be encoded as either a plain binary list or a TLV tagged DER encoding depending on the protocol.

This function is public but applications should have few reasons to ever call this.

Returns
number of message parts

Reimplemented in Botan::ECDSA_PublicKey, Botan::GOST_3410_PublicKey, Botan::ECGDSA_PublicKey, Botan::ECKCDSA_PublicKey, Botan::SM2_PublicKey, and Botan::DSA_PublicKey.

Definition at line 112 of file pk_keys.h.

Referenced by Botan::PK_Signer::PK_Signer(), and Botan::PK_Verifier::PK_Verifier().

112 { return 1; }
bool Botan::McEliece_PublicKey::operator!= ( const McEliece_PublicKey other) const
inlineinherited

Definition at line 58 of file mceliece.h.

58 { return !(*this == other); }
bool Botan::McEliece_PrivateKey::operator!= ( const McEliece_PrivateKey other) const
inline

Definition at line 117 of file mceliece.h.

117 { return !(*this == other); }
bool Botan::McEliece_PublicKey::operator== ( const McEliece_PublicKey other) const
inherited

Definition at line 290 of file mceliece_key.cpp.

References Botan::McEliece_PublicKey::m_code_length, Botan::McEliece_PublicKey::m_public_matrix, and Botan::McEliece_PublicKey::m_t.

291  {
292  if(m_public_matrix != other.m_public_matrix)
293  {
294  return false;
295  }
296  if(m_t != other.m_t)
297  {
298  return false;
299  }
300  if( m_code_length != other.m_code_length)
301  {
302  return false;
303  }
304  return true;
305  }
std::vector< uint8_t > m_public_matrix
Definition: mceliece.h:68
bool Botan::McEliece_PrivateKey::operator== ( const McEliece_PrivateKey other) const

Definition at line 258 of file mceliece_key.cpp.

259  {
260  if(*static_cast<const McEliece_PublicKey*>(this) != *static_cast<const McEliece_PublicKey*>(&other))
261  {
262  return false;
263  }
264  if(m_g != other.m_g)
265  {
266  return false;
267  }
268 
269  if( m_sqrtmod != other.m_sqrtmod)
270  {
271  return false;
272  }
273  if( m_Linv != other.m_Linv)
274  {
275  return false;
276  }
277  if( m_coeffs != other.m_coeffs)
278  {
279  return false;
280  }
281 
282  if(m_codimension != other.m_codimension || m_dimension != other.m_dimension)
283  {
284  return false;
285  }
286 
287  return true;
288  }
virtual AlgorithmIdentifier Botan::Private_Key::pkcs8_algorithm_identifier ( ) const
inlinevirtualinherited
Returns
PKCS #8 AlgorithmIdentifier for this key Might be different from the X.509 identifier, but normally is not

Reimplemented in Botan::XMSS_WOTS_PrivateKey, Botan::GOST_3410_PrivateKey, and Botan::XMSS_WOTS_Addressed_PrivateKey.

Definition at line 204 of file pk_keys.h.

Referenced by Botan::Private_Key::private_key_info().

205  { return algorithm_identifier(); }
virtual AlgorithmIdentifier algorithm_identifier() const =0
secure_vector< uint8_t > Botan::McEliece_PrivateKey::private_key_bits ( ) const
overridevirtual
Returns
BER encoded private key bits

Implements Botan::Private_Key.

Definition at line 122 of file mceliece_key.cpp.

References Botan::PEM_Code::encode(), Botan::DER_Encoder::encode(), Botan::DER_Encoder::end_cons(), Botan::get_byte(), Botan::McEliece_PublicKey::get_code_length(), Botan::DER_Encoder::get_contents(), Botan::McEliece_PublicKey::get_t(), Botan::McEliece_PublicKey::m_public_matrix, Botan::OCTET_STRING, Botan::SEQUENCE, and Botan::DER_Encoder::start_cons().

123  {
124  DER_Encoder enc;
125  enc.start_cons(SEQUENCE)
126  .start_cons(SEQUENCE)
127  .encode(static_cast<size_t>(get_code_length()))
128  .encode(static_cast<size_t>(get_t()))
129  .end_cons()
130  .encode(m_public_matrix, OCTET_STRING)
131  .encode(m_g[0].encode(), OCTET_STRING); // g as octet string
132  enc.start_cons(SEQUENCE);
133  for(size_t i = 0; i < m_sqrtmod.size(); i++)
134  {
135  enc.encode(m_sqrtmod[i].encode(), OCTET_STRING);
136  }
137  enc.end_cons();
138  secure_vector<uint8_t> enc_support;
139 
140  for(uint16_t Linv : m_Linv)
141  {
142  enc_support.push_back(get_byte(0, Linv));
143  enc_support.push_back(get_byte(1, Linv));
144  }
145  enc.encode(enc_support, OCTET_STRING);
146  secure_vector<uint8_t> enc_H;
147  for(uint32_t coef : m_coeffs)
148  {
149  enc_H.push_back(get_byte(0, coef));
150  enc_H.push_back(get_byte(1, coef));
151  enc_H.push_back(get_byte(2, coef));
152  enc_H.push_back(get_byte(3, coef));
153  }
154  enc.encode(enc_H, OCTET_STRING);
155  enc.end_cons();
156  return enc.get_contents();
157  }
std::vector< uint8_t > m_public_matrix
Definition: mceliece.h:68
size_t get_code_length() const
Definition: mceliece.h:53
constexpr uint8_t get_byte(size_t byte_num, T input)
Definition: loadstor.h:41
std::string encode(const uint8_t der[], size_t length, const std::string &label, size_t width)
Definition: pem.cpp:43
size_t get_t() const
Definition: mceliece.h:52
secure_vector< uint8_t > Botan::Private_Key::private_key_info ( ) const
inherited
Returns
PKCS #8 private key encoding for this key object

Definition at line 61 of file pk_keys.cpp.

References Botan::DER_Encoder::encode(), Botan::DER_Encoder::end_cons(), Botan::DER_Encoder::get_contents(), Botan::OCTET_STRING, Botan::Private_Key::pkcs8_algorithm_identifier(), Botan::Private_Key::private_key_bits(), Botan::SEQUENCE, and Botan::DER_Encoder::start_cons().

Referenced by Botan::PKCS8::BER_encode(), Botan::PKCS8::BER_encode_encrypted_pbkdf_iter(), and Botan::PKCS8::BER_encode_encrypted_pbkdf_msec().

62  {
63  const size_t PKCS8_VERSION = 0;
64 
65  return DER_Encoder()
66  .start_cons(SEQUENCE)
67  .encode(PKCS8_VERSION)
69  .encode(private_key_bits(), OCTET_STRING)
70  .end_cons()
71  .get_contents();
72  }
virtual secure_vector< uint8_t > private_key_bits() const =0
virtual AlgorithmIdentifier pkcs8_algorithm_identifier() const
Definition: pk_keys.h:204
std::vector< uint8_t > Botan::McEliece_PublicKey::public_key_bits ( ) const
overridevirtualinherited
Returns
BER encoded public key bits

Implements Botan::Public_Key.

Definition at line 82 of file mceliece_key.cpp.

References Botan::DER_Encoder::encode(), Botan::DER_Encoder::end_cons(), Botan::McEliece_PublicKey::get_code_length(), Botan::McEliece_PublicKey::get_t(), Botan::McEliece_PublicKey::m_public_matrix, Botan::OCTET_STRING, Botan::SEQUENCE, and Botan::DER_Encoder::start_cons().

83  {
84  std::vector<uint8_t> output;
85  DER_Encoder(output)
86  .start_cons(SEQUENCE)
87  .start_cons(SEQUENCE)
88  .encode(static_cast<size_t>(get_code_length()))
89  .encode(static_cast<size_t>(get_t()))
90  .end_cons()
92  .end_cons();
93  return output;
94  }
std::vector< uint8_t > m_public_matrix
Definition: mceliece.h:68
size_t get_code_length() const
Definition: mceliece.h:53
size_t get_t() const
Definition: mceliece.h:52
secure_vector< uint8_t > Botan::McEliece_PublicKey::random_plaintext_element ( RandomNumberGenerator rng) const
inherited

Definition at line 60 of file mceliece_key.cpp.

References Botan::McEliece_PublicKey::get_message_word_bit_length(), and Botan::RandomNumberGenerator::randomize().

Referenced by check_key().

61  {
62  const size_t bits = get_message_word_bit_length();
63 
64  secure_vector<uint8_t> plaintext((bits+7)/8);
65  rng.randomize(plaintext.data(), plaintext.size());
66 
67  // unset unused bits in the last plaintext byte
68  if(uint32_t used = bits % 8)
69  {
70  const uint8_t mask = (1 << used) - 1;
71  plaintext[plaintext.size() - 1] &= mask;
72  }
73 
74  return plaintext;
75  }
size_t get_message_word_bit_length() const
virtual bool Botan::Private_Key::stateful_operation ( ) const
inlinevirtualinherited

Reimplemented in Botan::XMSS_PrivateKey.

Definition at line 188 of file pk_keys.h.

188 { return false; }
std::vector< uint8_t > Botan::Public_Key::subject_public_key ( ) const
inherited
Returns
X.509 subject key encoding for this key object

Definition at line 38 of file pk_keys.cpp.

References Botan::Public_Key::algorithm_identifier(), Botan::BIT_STRING, Botan::DER_Encoder::encode(), Botan::DER_Encoder::end_cons(), Botan::Public_Key::public_key_bits(), Botan::SEQUENCE, and Botan::DER_Encoder::start_cons().

Referenced by Botan::X509::BER_encode(), Botan::PKCS10_Request::create(), Botan::Public_Key::fingerprint_public(), and Botan::X509::PEM_encode().

39  {
40  std::vector<uint8_t> output;
41 
42  DER_Encoder(output).start_cons(SEQUENCE)
43  .encode(algorithm_identifier())
44  .encode(public_key_bits(), BIT_STRING)
45  .end_cons();
46 
47  return output;
48  }
virtual std::vector< uint8_t > public_key_bits() const =0
virtual AlgorithmIdentifier algorithm_identifier() const =0

Member Data Documentation

size_t Botan::McEliece_PublicKey::m_code_length
protectedinherited
std::vector<uint8_t> Botan::McEliece_PublicKey::m_public_matrix
protectedinherited
size_t Botan::McEliece_PublicKey::m_t
protectedinherited

The documentation for this class was generated from the following files: