Botan 3.5.0
Crypto and TLS for C&
mceliece.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 *
8 * Botan is released under the Simplified BSD License (see license.txt)
9 *
10 */
11
12#include <botan/internal/mce_internal.h>
13
14#include <botan/mceliece.h>
15#include <botan/mem_ops.h>
16#include <botan/internal/bit_ops.h>
17#include <botan/internal/code_based_util.h>
18
19namespace Botan {
20
21namespace {
22
25 size_t dimension,
26 size_t codimension) {
28
29 const size_t final_bits = dimension % 8;
30
31 if(final_bits == 0) {
32 const size_t dim_bytes = bit_size_to_byte_size(dimension);
33 copy_mem(&x[0], a.data(), dim_bytes);
34 copy_mem(&x[dim_bytes], b.data(), bit_size_to_byte_size(codimension));
35 } else {
36 copy_mem(&x[0], a.data(), (dimension / 8));
37 size_t l = dimension / 8;
38 x[l] = static_cast<uint8_t>(a[l] & ((1 << final_bits) - 1));
39
40 for(size_t k = 0; k < codimension / 8; ++k) {
41 x[l] ^= static_cast<uint8_t>(b[k] << final_bits);
42 ++l;
43 x[l] = static_cast<uint8_t>(b[k] >> (8 - final_bits));
44 }
45 x[l] ^= static_cast<uint8_t>(b[codimension / 8] << final_bits);
46 }
47
48 return x;
49}
50
51secure_vector<uint8_t> mult_by_pubkey(const secure_vector<uint8_t>& cleartext,
52 const std::vector<uint8_t>& public_matrix,
53 size_t code_length,
54 size_t t) {
55 const size_t ext_deg = ceil_log2(code_length);
56 const size_t codimension = ext_deg * t;
57 const size_t dimension = code_length - codimension;
58 secure_vector<uint8_t> cR(bit_size_to_32bit_size(codimension) * sizeof(uint32_t));
59
60 const uint8_t* pt = public_matrix.data();
61
62 for(size_t i = 0; i < dimension / 8; ++i) {
63 for(size_t j = 0; j < 8; ++j) {
64 if(cleartext[i] & (1 << j)) {
65 xor_buf(cR.data(), pt, cR.size());
66 }
67 pt += cR.size();
68 }
69 }
70
71 for(size_t i = 0; i < dimension % 8; ++i) {
72 if(cleartext[dimension / 8] & (1 << i)) {
73 xor_buf(cR.data(), pt, cR.size());
74 }
75 pt += cR.size();
76 }
77
78 secure_vector<uint8_t> ciphertext = concat_vectors(cleartext, cR, dimension, codimension);
79 ciphertext.resize((code_length + 7) / 8);
80 return ciphertext;
81}
82
83secure_vector<uint8_t> create_random_error_vector(size_t code_length, size_t error_weight, RandomNumberGenerator& rng) {
84 secure_vector<uint8_t> result((code_length + 7) / 8);
85
86 size_t bits_set = 0;
87
88 while(bits_set < error_weight) {
89 gf2m x = random_code_element(static_cast<uint16_t>(code_length), rng);
90
91 const size_t byte_pos = x / 8;
92 const size_t bit_pos = x % 8;
93
94 const uint8_t mask = (1 << bit_pos);
95
96 if(result[byte_pos] & mask) {
97 continue; // already set this bit
98 }
99
100 result[byte_pos] |= mask;
101 bits_set++;
102 }
103
104 return result;
105}
106
107} // namespace
108
110 secure_vector<uint8_t>& error_mask_out,
111 const secure_vector<uint8_t>& plaintext,
112 const McEliece_PublicKey& key,
114 const uint16_t code_length = static_cast<uint16_t>(key.get_code_length());
115
116 secure_vector<uint8_t> error_mask = create_random_error_vector(code_length, key.get_t(), rng);
117
118 secure_vector<uint8_t> ciphertext =
119 mult_by_pubkey(plaintext, key.get_public_matrix(), key.get_code_length(), key.get_t());
120
121 ciphertext ^= error_mask;
122
123 ciphertext_out.swap(ciphertext);
124 error_mask_out.swap(error_mask);
125}
126
127} // namespace Botan
size_t get_t() const
Definition mceliece.h:50
const std::vector< uint8_t > & get_public_matrix() const
Definition mceliece.h:56
size_t get_code_length() const
Definition mceliece.h:52
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:109
gf2m random_code_element(uint16_t code_length, RandomNumberGenerator &rng)
constexpr void xor_buf(ranges::contiguous_output_range< uint8_t > auto &&out, ranges::contiguous_range< uint8_t > auto &&in)
Definition mem_ops.h:341
std::vector< T, secure_allocator< T > > secure_vector
Definition secmem.h:61
size_t bit_size_to_32bit_size(size_t bit_size)
size_t bit_size_to_byte_size(size_t bit_size)
constexpr void copy_mem(T *out, const T *in, size_t n)
Definition mem_ops.h:146
constexpr uint8_t ceil_log2(T x)
Definition bit_ops.h:122
uint16_t gf2m