Botan 2.19.5 Crypto and TLS for C&

Public Member Functions | Static Public Member Functions | Protected Member Functions | List of all members
Botan::CCM_Encryption Class Referencefinal

`#include <ccm.h>`

Inheritance diagram for Botan::CCM_Encryption:

## Public Member Functions
bool | associated_data_requires_key () const override
bool | authenticated () const override
| CCM_Encryption (BlockCipher *cipher, size_t tag_size=16, size_t L=3)
void | clear () override
size_t | default_nonce_length () const override
void | finish (secure_vector< uint8_t > &final_block, size_t offset=0) override
Key_Length_Specification | key_spec () const override
virtual size_t | maximum_associated_data_inputs () const
size_t | maximum_keylength () const
size_t | minimum_final_size () const override
size_t | minimum_keylength () const
std::string | name () const override
size_t | output_length (size_t input_length) const override
size_t | process (uint8_t buf[], size_t sz) override
virtual std::string | provider () const
void | reset () override
template<typename Alloc >
void | set_ad (const std::vector< uint8_t, Alloc > &ad)
void | set_associated_data (const uint8_t ad[], size_t ad_len) override
virtual void | set_associated_data_n (size_t i, const uint8_t ad[], size_t ad_len)
template<typename Alloc >
void | set_associated_data_vec (const std::vector< uint8_t, Alloc > &ad)
template<typename Alloc >
void | set_key (const std::vector< uint8_t, Alloc > &key)
void | set_key (const SymmetricKey &key)
void | set_key (const uint8_t key[], size_t length)
void | start ()
template<typename Alloc >
void | start (const std::vector< uint8_t, Alloc > &nonce)
void | start (const uint8_t nonce[], size_t nonce_len)
size_t | tag_size () const override
void | update (secure_vector< uint8_t > &buffer, size_t offset=0)
size_t | update_granularity () const override
bool | valid_keylength (size_t length) const
bool | valid_nonce_length (size_t) const override

## Static Public Member Functions
static std::unique_ptr< AEAD_Mode > | create (const std::string &algo, Cipher_Dir direction, const std::string &provider="")
static std::unique_ptr< AEAD_Mode > | create_or_throw (const std::string &algo, Cipher_Dir direction, const std::string &provider="")
static std::vector< std::string > | providers (const std::string &algo_spec)

## Protected Member Functions
const secure_vector< uint8_t > & | ad_buf () const
const BlockCipher & | cipher () const
void | encode_length (uint64_t len, uint8_t out[])
secure_vector< uint8_t > | format_b0 (size_t msg_size)
secure_vector< uint8_t > | format_c0 ()
void | inc (secure_vector< uint8_t > &C)
size_t | L () const
secure_vector< uint8_t > & | msg_buf ()
void | verify_key_set (bool cond) const

## Detailed Description

CCM Encryption

Definition at line 80 of file ccm.h.

## Constructor & Destructor Documentation

## ◆ CCM_Encryption()

Botan::CCM_Encryption::CCM_Encryption | ( | BlockCipher * | cipher,
|  | size_t | tag_size = `16`,
|  | size_t | L = `3`
| ) |  |
| inline

Parameters

  cipher | a 128-bit block cipher
  tag_size | is how big the auth tag will be (even values between 4 and 16 are accepted)
  L | length of L parameter. The total message length must be less than 2**L bytes, and the nonce is 15-L bytes.

Definition at line 90 of file ccm.h.

90 :
91 CCM_Mode(cipher, tag_size, L) {}
Botan::CCM_Mode::cipher
const BlockCipher & cipher() const
Definition: ccm.h:53
Botan::CCM_Mode::L
size_t L() const
Definition: ccm.h:51
Botan::CCM_Mode::CCM_Mode
CCM_Mode(BlockCipher *cipher, size_t tag_size, size_t L)
Definition: ccm.cpp:20
Botan::CCM_Mode::tag_size
size_t tag_size() const override
Definition: ccm.h:46

## Member Function Documentation

## ◆ ad_buf()

const secure_vector< uint8_t > & Botan::CCM_Mode::ad_buf | ( |  | ) | const
| inline protected inherited

Definition at line 59 of file ccm.h.

59{ return m_ad_buf; }

Referenced by finish(), and Botan::CCM_Decryption::finish().

## ◆ associated_data_requires_key()

bool Botan::CCM_Mode::associated_data_requires_key | ( |  | ) | const
| inline override virtual inherited

Most AEADs require the key to be set prior to setting the AD A few allow the AD to be set even before the cipher is keyed. Such ciphers would return false from this function.

Reimplemented from Botan::AEAD_Mode.

Definition at line 30 of file ccm.h.

30{ return false; }

## ◆ authenticated()

bool Botan::AEAD_Mode::authenticated | ( |  | ) | const
| inline override virtual inherited

Returns
  true iff this mode provides authentication as well as confidentiality.

Reimplemented from Botan::Cipher_Mode.

Definition at line 47 of file aead.h.

47{ return true; }

## ◆ cipher()

const BlockCipher & Botan::CCM_Mode::cipher | ( |  | ) | const
| inline protected inherited

Definition at line 53 of file ccm.h.

53{ return *m_cipher; }

Referenced by finish(), and Botan::CCM_Decryption::finish().

## ◆ clear()

void Botan::CCM_Mode::clear | ( |  | ) |
| override virtual inherited

Reset the state.

Implements Botan::SymmetricAlgorithm.

Definition at line 35 of file ccm.cpp.

36 {
37 m_cipher->clear();
38 reset();
39 }
Botan::CCM_Mode::reset
void reset() override
Definition: ccm.cpp:41

References Botan::CCM_Mode::reset().

## ◆ create()

std::unique_ptr< AEAD_Mode > Botan::AEAD_Mode::create | ( | const std::string & | algo,
|  | Cipher_Dir | direction,
|  | const std::string & | provider = `""`
| ) |  |
| static inherited

Create an AEAD mode

Parameters

  algo | the algorithm to create
  direction | specify if this should be an encryption or decryption AEAD
  provider | optional specification for provider to use

Returns
  an AEAD mode or a null pointer if not available

Definition at line 60 of file aead.cpp.

63 {
64 BOTAN_UNUSED(provider);
65#if defined(BOTAN_HAS_AEAD_CHACHA20_POLY1305)
66 if(algo == "ChaCha20Poly1305")
67 {
68 if(dir == ENCRYPTION)
69 return std::unique_ptr<AEAD_Mode>(new ChaCha20Poly1305_Encryption);
70 else
71 return std::unique_ptr<AEAD_Mode>(new ChaCha20Poly1305_Decryption);
72
73 }
74#endif
75
76 if(algo.find('/') != std::string::npos)
77 {
78 const std::vector<std::string> algo_parts = split_on(algo, '/');
79 const std::string cipher_name = algo_parts[0];
80 const std::vector<std::string> mode_info = parse_algorithm_name(algo_parts[1]);
81
82 if(mode_info.empty())
83 return std::unique_ptr<AEAD_Mode>();
84
85 std::ostringstream alg_args;
86
87 alg_args << '(' << cipher_name;
88 for(size_t i = 1; i < mode_info.size(); ++i)
89 alg_args << ',' << mode_info[i];
90 for(size_t i = 2; i < algo_parts.size(); ++i)
91 alg_args << ',' << algo_parts[i];
92 alg_args << ')';
93
94 const std::string mode_name = mode_info[0] + alg_args.str();
95 return AEAD_Mode::create(mode_name, dir);
96 }
97
98#if defined(BOTAN_HAS_BLOCK_CIPHER)
99
100 SCAN_Name req(algo);
101
102 if(req.arg_count() == 0)
103 {
104 return std::unique_ptr<AEAD_Mode>();
105 }
106
107 std::unique_ptr<BlockCipher> bc(BlockCipher::create(req.arg(0), provider));
108
109 if(!bc)
110 {
111 return std::unique_ptr<AEAD_Mode>();
112 }
113
114#if defined(BOTAN_HAS_AEAD_CCM)
115 if(req.algo_name() == "CCM")
116 {
117 size_t tag_len = req.arg_as_integer(1, 16);
118 size_t L_len = req.arg_as_integer(2, 3);
119 if(dir == ENCRYPTION)
120 return std::unique_ptr<AEAD_Mode>(new CCM_Encryption(bc.release(), tag_len, L_len));
121 else
122 return std::unique_ptr<AEAD_Mode>(new CCM_Decryption(bc.release(), tag_len, L_len));
123 }
124#endif
125
126#if defined(BOTAN_HAS_AEAD_GCM)
127 if(req.algo_name() == "GCM")
128 {
129 size_t tag_len = req.arg_as_integer(1, 16);
130 if(dir == ENCRYPTION)
131 return std::unique_ptr<AEAD_Mode>(new GCM_Encryption(bc.release(), tag_len));
132 else
133 return std::unique_ptr<AEAD_Mode>(new GCM_Decryption(bc.release(), tag_len));
134 }
135#endif
136
137#if defined(BOTAN_HAS_AEAD_OCB)
138 if(req.algo_name() == "OCB")
139 {
140 size_t tag_len = req.arg_as_integer(1, 16);
141 if(dir == ENCRYPTION)
142 return std::unique_ptr<AEAD_Mode>(new OCB_Encryption(bc.release(), tag_len));
143 else
144 return std::unique_ptr<AEAD_Mode>(new OCB_Decryption(bc.release(), tag_len));
145 }
146#endif
147
148#if defined(BOTAN_HAS_AEAD_EAX)
149 if(req.algo_name() == "EAX")
150 {
151 size_t tag_len = req.arg_as_integer(1, bc->block_size());
152 if(dir == ENCRYPTION)
153 return std::unique_ptr<AEAD_Mode>(new EAX_Encryption(bc.release(), tag_len));
154 else
155 return std::unique_ptr<AEAD_Mode>(new EAX_Decryption(bc.release(), tag_len));
156 }
157#endif
158
159#if defined(BOTAN_HAS_AEAD_SIV)
160 if(req.algo_name() == "SIV")
161 {
162 if(dir == ENCRYPTION)
163 return std::unique_ptr<AEAD_Mode>(new SIV_Encryption(bc.release()));
164 else
165 return std::unique_ptr<AEAD_Mode>(new SIV_Decryption(bc.release()));
166 }
167#endif
168
169#endif
170
171 return std::unique_ptr<AEAD_Mode>();
172 }
BOTAN_UNUSED
#define BOTAN_UNUSED(...)
Definition: assert.h:142
Botan::AEAD_Mode::create
static std::unique_ptr< AEAD_Mode > create(const std::string &algo, Cipher_Dir direction, const std::string &provider="")
Definition: aead.cpp:60
Botan::BlockCipher::create
static std::unique_ptr< BlockCipher > create(const std::string &algo_spec, const std::string &provider="")
Definition: block_cipher.cpp:104
Botan::Cipher_Mode::provider
virtual std::string provider() const
Definition: cipher_mode.h:180
Botan::split_on
std::vector< std::string > split_on(const std::string &str, char delim)
Definition: parsing.cpp:148
Botan::ENCRYPTION
@ ENCRYPTION
Definition: cipher_mode.h:23
Botan::parse_algorithm_name
std::vector< std::string > parse_algorithm_name(const std::string &namex)
Definition: parsing.cpp:95

References Botan::SCAN_Name::algo_name(), Botan::SCAN_Name::arg(), Botan::SCAN_Name::arg_as_integer(), Botan::SCAN_Name::arg_count(), BOTAN_UNUSED, Botan::AEAD_Mode::create(), Botan::BlockCipher::create(), Botan::ENCRYPTION, Botan::parse_algorithm_name(), Botan::Cipher_Mode::provider(), and Botan::split_on().

Referenced by Botan::AEAD_Mode::create(), Botan::Cipher_Mode::create(), Botan::AEAD_Mode::create_or_throw(), and Botan::get_aead().

## ◆ create_or_throw()

std::unique_ptr< AEAD_Mode > Botan::AEAD_Mode::create_or_throw | ( | const std::string & | algo,
|  | Cipher_Dir | direction,
|  | const std::string & | provider = `""`
| ) |  |
| static inherited

Create an AEAD mode, or throw

Parameters

  algo | the algorithm to create
  direction | specify if this should be an encryption or decryption AEAD
  provider | optional specification for provider to use

Returns
  an AEAD mode, or throw an exception

Definition at line 50 of file aead.cpp.

53 {
54 if(auto aead = AEAD_Mode::create(algo, dir, provider))
55 return aead;
56
57 throw Lookup_Error("AEAD", algo, provider);
58 }

References Botan::AEAD_Mode::create(), and Botan::Cipher_Mode::provider().

Referenced by Botan::TLS::Connection_Cipher_State::Connection_Cipher_State(), Botan::TLS::Session::decrypt(), Botan::TLS::Session::encrypt(), Botan::mceies_decrypt(), and Botan::mceies_encrypt().

## ◆ default_nonce_length()

size_t Botan::CCM_Mode::default_nonce_length | ( |  | ) | const
| override virtual inherited

Returns
  default AEAD nonce size (a commonly supported value among AEAD modes, and large enough that random collisions are unlikely)

Reimplemented from Botan::AEAD_Mode.

Definition at line 58 of file ccm.cpp.

59 {
60 return (15-L());
61 }

References Botan::CCM_Mode::L().

## ◆ encode_length()

void Botan::CCM_Mode::encode_length | ( | uint64_t | len,
|  | uint8_t | out[]
| ) |  |
| protected inherited

Definition at line 117 of file ccm.cpp.

118 {
119 const size_t len_bytes = L();
120
121 BOTAN_ASSERT_NOMSG(len_bytes >= 2 && len_bytes <= 8);
122
123 for(size_t i = 0; i != len_bytes; ++i)
124 out[len_bytes-1-i] = get_byte(sizeof(uint64_t)-1-i, len);
125
126 if(len_bytes < 8 && (len >> (len_bytes*8)) > 0)
127 throw Encoding_Error("CCM message length too long to encode in L field");
128 }
BOTAN_ASSERT_NOMSG
#define BOTAN_ASSERT_NOMSG(expr)
Definition: assert.h:68
Botan::get_byte
constexpr uint8_t get_byte(size_t byte_num, T input)
Definition: loadstor.h:41

References BOTAN_ASSERT_NOMSG, Botan::get_byte(), and Botan::CCM_Mode::L().

Referenced by Botan::CCM_Mode::format_b0().

## ◆ finish()

void Botan::CCM_Encryption::finish | ( | secure_vector< uint8_t > & | final_block,
|  | size_t | offset = `0`
| ) |  |
| override virtual

Complete processing of a message.

Parameters

  final_block | in/out parameter which must be at least minimum_final_size() bytes, and will be set to any final output
  offset | an offset into final_block to begin processing

Implements Botan::Cipher_Mode.

Definition at line 167 of file ccm.cpp.

168 {
169 BOTAN_ARG_CHECK(buffer.size() >= offset, "Offset is sane");
170
171 buffer.insert(buffer.begin() + offset, msg_buf().begin(), msg_buf().end());
172
173 const size_t sz = buffer.size() - offset;
174 uint8_t* buf = buffer.data() + offset;
175
176 const secure_vector<uint8_t>& ad = ad_buf();
177 BOTAN_ARG_CHECK(ad.size() % CCM_BS == 0, "AD is block size multiple");
178
179 const BlockCipher& E = cipher();
180
181 secure_vector<uint8_t> T(CCM_BS);
182 E.encrypt(format_b0(sz), T);
183
184 for(size_t i = 0; i != ad.size(); i += CCM_BS)
185 {
186 xor_buf(T.data(), &ad[i], CCM_BS);
187 E.encrypt(T);
188 }
189
190 secure_vector<uint8_t> C = format_c0();
191 secure_vector<uint8_t> S0(CCM_BS);
192 E.encrypt(C, S0);
193 inc(C);
194
195 secure_vector<uint8_t> X(CCM_BS);
196
197 const uint8_t* buf_end = &buf[sz];
198
199 while(buf != buf_end)
200 {
201 const size_t to_proc = std::min<size_t>(CCM_BS, buf_end - buf);
202
203 xor_buf(T.data(), buf, to_proc);
204 E.encrypt(T);
205
206 E.encrypt(C, X);
207 xor_buf(buf, X.data(), to_proc);
208 inc(C);
209
210 buf += to_proc;
211 }
212
213 T ^= S0;
214
215 buffer += std::make_pair(T.data(), tag_size());
216
217 reset();
218 }
BOTAN_ARG_CHECK
#define BOTAN_ARG_CHECK(expr, msg)
Definition: assert.h:37
Botan::CCM_Mode::inc
void inc(secure_vector< uint8_t > &C)
Definition: ccm.cpp:130
Botan::CCM_Mode::msg_buf
secure_vector< uint8_t > & msg_buf()
Definition: ccm.h:61
Botan::CCM_Mode::format_c0
secure_vector< uint8_t > format_c0()
Definition: ccm.cpp:153
Botan::CCM_Mode::ad_buf
const secure_vector< uint8_t > & ad_buf() const
Definition: ccm.h:59
Botan::CCM_Mode::format_b0
secure_vector< uint8_t > format_b0(size_t msg_size)
Definition: ccm.cpp:137
T
fe T
Definition: ge.cpp:37
X
fe X
Definition: ge.cpp:27
Botan::xor_buf
void xor_buf(uint8_t out[], const uint8_t in[], size_t length)
Definition: mem_ops.h:262

References Botan::CCM_Mode::ad_buf(), BOTAN_ARG_CHECK, Botan::CCM_Mode::cipher(), Botan::BlockCipher::encrypt(), Botan::CCM_Mode::format_b0(), Botan::CCM_Mode::format_c0(), Botan::CCM_Mode::inc(), Botan::CCM_Mode::msg_buf(), Botan::CCM_Mode::reset(), T, Botan::CCM_Mode::tag_size(), X, and Botan::xor_buf().

## ◆ format_b0()

secure_vector< uint8_t > Botan::CCM_Mode::format_b0 | ( | size_t | msg_size | ) |
| protected inherited

Definition at line 137 of file ccm.cpp.

138 {
139 if(m_nonce.size() != 15-L())
140 throw Invalid_State("CCM mode must set nonce");
141 secure_vector<uint8_t> B0(CCM_BS);
142
143 const uint8_t b_flags =
144 static_cast<uint8_t>((m_ad_buf.size() ? 64 : 0) + (((tag_size()/2)-1) << 3) + (L()-1));
145
146 B0[0] = b_flags;
147 copy_mem(&B0[1], m_nonce.data(), m_nonce.size());
148 encode_length(sz, &B0[m_nonce.size()+1]);
149
150 return B0;
151 }
Botan::CCM_Mode::encode_length
void encode_length(uint64_t len, uint8_t out[])
Definition: ccm.cpp:117
Botan::copy_mem
void copy_mem(T *out, const T *in, size_t n)
Definition: mem_ops.h:133

References Botan::copy_mem(), Botan::CCM_Mode::encode_length(), Botan::CCM_Mode::L(), and Botan::CCM_Mode::tag_size().

Referenced by finish(), and Botan::CCM_Decryption::finish().

## ◆ format_c0()

secure_vector< uint8_t > Botan::CCM_Mode::format_c0 | ( |  | ) |
| protected inherited

Definition at line 153 of file ccm.cpp.

154 {
155 if(m_nonce.size() != 15-L())
156 throw Invalid_State("CCM mode must set nonce");
157 secure_vector<uint8_t> C(CCM_BS);
158
159 const uint8_t a_flags = static_cast<uint8_t>(L() - 1);
160
161 C[0] = a_flags;
162 copy_mem(&C[1], m_nonce.data(), m_nonce.size());
163
164 return C;
165 }

References Botan::copy_mem(), and Botan::CCM_Mode::L().

Referenced by finish(), and Botan::CCM_Decryption::finish().

## ◆ inc()

void Botan::CCM_Mode::inc | ( | secure_vector< uint8_t > & | C | ) |
| protected inherited

Definition at line 130 of file ccm.cpp.

131 {
132 for(size_t i = 0; i != C.size(); ++i)
133 if(++C[C.size()-i-1])
134 break;
135 }

Referenced by finish(), and Botan::CCM_Decryption::finish().

## ◆ key_spec()

Key_Length_Specification Botan::CCM_Mode::key_spec | ( |  | ) | const
| override virtual inherited

Returns
  object describing limits on key size

Implements Botan::SymmetricAlgorithm.

Definition at line 74 of file ccm.cpp.

75 {
76 return m_cipher->key_spec();
77 }

## ◆ L()

size_t Botan::CCM_Mode::L | ( |  | ) | const
| inline protected inherited

Definition at line 51 of file ccm.h.

51{ return m_L; }

Referenced by Botan::CCM_Mode::default_nonce_length(), Botan::CCM_Mode::encode_length(), Botan::CCM_Mode::format_b0(), Botan::CCM_Mode::format_c0(), Botan::CCM_Mode::name(), and Botan::CCM_Mode::valid_nonce_length().

## ◆ maximum_associated_data_inputs()

virtual size_t Botan::AEAD_Mode::maximum_associated_data_inputs | ( |  | ) | const
| inline virtual inherited

Returns the maximum supported number of associated data inputs which can be provided to set_associated_data_n

If returns 0, then no associated data is supported.

Reimplemented in Botan::SIV_Mode.

Definition at line 87 of file aead.h.

87{ return 1; }

## ◆ maximum_keylength()

size_t Botan::SymmetricAlgorithm::maximum_keylength | ( |  | ) | const
| inline inherited

Returns
  maximum allowed key length

Definition at line 120 of file sym_algo.h.

121 {
122 return key_spec().maximum_keylength();
123 }
Botan::Key_Length_Specification::maximum_keylength
size_t maximum_keylength() const
Definition: sym_algo.h:70
Botan::SymmetricAlgorithm::key_spec
virtual Key_Length_Specification key_spec() const =0

## ◆ minimum_final_size()

size_t Botan::CCM_Encryption::minimum_final_size | ( |  | ) | const
| inline override virtual

Returns
  required minimium size to finalize() - may be any length larger than this.

Implements Botan::Cipher_Mode.

Definition at line 98 of file ccm.h.

98{ return 0; }

## ◆ minimum_keylength()

size_t Botan::SymmetricAlgorithm::minimum_keylength | ( |  | ) | const
| inline inherited

Returns
  minimum allowed key length

Definition at line 128 of file sym_algo.h.

129 {
130 return key_spec().minimum_keylength();
131 }
Botan::Key_Length_Specification::minimum_keylength
size_t minimum_keylength() const
Definition: sym_algo.h:62

Referenced by botan_block_cipher_get_keyspec(), and botan_mac_get_keyspec().

## ◆ msg_buf()

secure_vector< uint8_t > & Botan::CCM_Mode::msg_buf | ( |  | ) |
| inline protected inherited

Definition at line 61 of file ccm.h.

61{ return m_msg_buf; }

Referenced by finish(), and Botan::CCM_Decryption::finish().

## ◆ name()

std::string Botan::CCM_Mode::name | ( |  | ) | const
| override virtual inherited

Returns
  the algorithm name

Implements Botan::SymmetricAlgorithm.

Definition at line 48 of file ccm.cpp.

49 {
50 return (m_cipher->name() + "/CCM(" + std::to_string(tag_size()) + "," + std::to_string(L())) + ")";
51 }
Botan::ASN1::to_string
std::string to_string(const BER_Object &obj)
Definition: asn1_obj.cpp:213

References Botan::CCM_Mode::L(), Botan::CCM_Mode::tag_size(), and Botan::ASN1::to_string().

## ◆ output_length()

size_t Botan::CCM_Encryption::output_length | ( | size_t | input_length | ) | const
| inline override virtual

Returns the size of the output if this transform is used to process a message with input_length bytes. In most cases the answer is precise. If it is not possible to precise (namely for CBC decryption) instead a lower bound is returned.

Implements Botan::Cipher_Mode.

Definition at line 95 of file ccm.h.

96 { return input_length + tag_size(); }

References Botan::Cipher_Mode::tag_size().

## ◆ process()

size_t Botan::CCM_Mode::process | ( | uint8_t | msg[],
|  | size_t | msg_len
| ) |  |
| override virtual inherited

Process message blocks

Input must be a multiple of update_granularity

Processes msg in place and returns bytes written. Normally this will be either msg_len (indicating the entire message was processed) or for certain AEAD modes zero (indicating that the mode requires the entire message be processed in one pass).

Parameters

  msg | the message to be processed
  msg_len | length of the message in bytes

Implements Botan::Cipher_Mode.

Definition at line 110 of file ccm.cpp.

111 {
112 BOTAN_STATE_CHECK(m_nonce.size() > 0);
113 m_msg_buf.insert(m_msg_buf.end(), buf, buf + sz);
114 return 0; // no output until finished
115 }
BOTAN_STATE_CHECK
#define BOTAN_STATE_CHECK(expr)
Definition: assert.h:49

References BOTAN_STATE_CHECK.

## ◆ provider()

virtual std::string Botan::Cipher_Mode::provider | ( |  | ) | const
| inline virtual inherited

Returns
  provider information about this implementation. Default is "base", might also return "sse2", "avx2", "openssl", or some other arbitrary string.

Reimplemented in Botan::GCM_Mode.

Definition at line 180 of file cipher_mode.h.

180{ return "base"; }

Referenced by Botan::AEAD_Mode::create(), Botan::Cipher_Mode::create(), Botan::AEAD_Mode::create_or_throw(), and Botan::Cipher_Mode::create_or_throw().

## ◆ providers()

std::vector< std::string > Botan::Cipher_Mode::providers | ( | const std::string & | algo_spec | ) |
| static inherited

Returns
  list of available providers for this algorithm, empty if not available

Parameters

  algo_spec | algorithm name

Definition at line 173 of file cipher_mode.cpp.

174 {
175 const std::vector<std::string>& possible = { "base", "openssl", "commoncrypto" };
176 std::vector<std::string> providers;
177 for(auto&& prov : possible)
178 {
179 std::unique_ptr<Cipher_Mode> mode = Cipher_Mode::create(algo_spec, ENCRYPTION, prov);
180 if(mode)
181 {
182 providers.push_back(prov); // available
183 }
184 }
185 return providers;
186 }
Botan::Cipher_Mode::providers
static std::vector< std::string > providers(const std::string &algo_spec)
Definition: cipher_mode.cpp:173
Botan::Cipher_Mode::create
static std::unique_ptr< Cipher_Mode > create(const std::string &algo, Cipher_Dir direction, const std::string &provider="")
Definition: cipher_mode.cpp:50

References Botan::Cipher_Mode::create(), Botan::ENCRYPTION, and Botan::Cipher_Mode::providers().

Referenced by Botan::Cipher_Mode::providers().

## ◆ reset()

void Botan::CCM_Mode::reset | ( |  | ) |
| override virtual inherited

Resets just the message specific state and allows encrypting again under the existing key

Implements Botan::Cipher_Mode.

Definition at line 41 of file ccm.cpp.

42 {
43 m_nonce.clear();
44 m_msg_buf.clear();
45 m_ad_buf.clear();
46 }

Referenced by Botan::CCM_Mode::clear(), finish(), and Botan::CCM_Decryption::finish().

## ◆ set_ad()

template<typename Alloc >

void Botan::AEAD_Mode::set_ad | ( | const std::vector< uint8_t, Alloc > & | ad | ) |
| inline inherited

Set associated data that is not included in the ciphertext but that should be authenticated. Must be called after set_key and before start.

See set_associated_data().

Parameters

  ad | the associated data

Definition at line 121 of file aead.h.

122 {
123 set_associated_data(ad.data(), ad.size());
124 }
Botan::AEAD_Mode::set_associated_data
virtual void set_associated_data(const uint8_t ad[], size_t ad_len)=0

Referenced by Botan::TLS::write_record().

## ◆ set_associated_data()

void Botan::CCM_Mode::set_associated_data | ( | const uint8_t | ad[],
|  | size_t | ad_len
| ) |  |
| override virtual inherited

Set associated data that is not included in the ciphertext but that should be authenticated. Must be called after set_key and before start.

Unless reset by another call, the associated data is kept between messages. Thus, if the AD does not change, calling once (after set_key) is the optimum.

Parameters

  ad | the associated data
  ad_len | length of add in bytes

Implements Botan::AEAD_Mode.

Definition at line 84 of file ccm.cpp.

85 {
86 m_ad_buf.clear();
87
88 if(length)
89 {
90 // FIXME: support larger AD using length encoding rules
91 BOTAN_ARG_CHECK(length < (0xFFFF - 0xFF), "Supported CCM AD length");
92
93 m_ad_buf.push_back(get_byte(0, static_cast<uint16_t>(length)));
94 m_ad_buf.push_back(get_byte(1, static_cast<uint16_t>(length)));
95 m_ad_buf += std::make_pair(ad, length);
96 while(m_ad_buf.size() % CCM_BS)
97 m_ad_buf.push_back(0); // pad with zeros to full block size
98 }
99 }

References BOTAN_ARG_CHECK, and Botan::get_byte().

## ◆ set_associated_data_n()

void Botan::AEAD_Mode::set_associated_data_n | ( | size_t | i,
|  | const uint8_t | ad[],
|  | size_t | ad_len
| ) |  |
| virtual inherited

Set associated data that is not included in the ciphertext but that should be authenticated. Must be called after set_key and before start.

Unless reset by another call, the associated data is kept between messages. Thus, if the AD does not change, calling once (after set_key) is the optimum.

Some AEADs (namely SIV) support multiple AD inputs. For all other modes only nominal AD input 0 is supported; all other values of i will cause an exception.

Parameters

  ad | the associated data
  ad_len | length of add in bytes

Reimplemented in Botan::SIV_Mode.

Definition at line 42 of file aead.cpp.

43 {
44 if(i == 0)
45 this->set_associated_data(ad, ad_len);
46 else
47 throw Invalid_Argument("AEAD '" + name() + "' does not support multiple associated data");
48 }
Botan::SymmetricAlgorithm::name
virtual std::string name() const =0

References Botan::SymmetricAlgorithm::name(), and Botan::AEAD_Mode::set_associated_data().

Referenced by Botan::SIV_Mode::set_associated_data().

## ◆ set_associated_data_vec()

template<typename Alloc >

void Botan::AEAD_Mode::set_associated_data_vec | ( | const std::vector< uint8_t, Alloc > & | ad | ) |
| inline inherited

Set associated data that is not included in the ciphertext but that should be authenticated. Must be called after set_key and before start.

See set_associated_data().

Parameters

  ad | the associated data

Definition at line 106 of file aead.h.

107 {
108 set_associated_data(ad.data(), ad.size());
109 }

## ◆ set_key() [1/3]

template<typename Alloc >

void Botan::SymmetricAlgorithm::set_key | ( | const std::vector< uint8_t, Alloc > & | key | ) |
| inline inherited

Definition at line 153 of file sym_algo.h.

154 {
155 set_key(key.data(), key.size());
156 }
Botan::SymmetricAlgorithm::set_key
void set_key(const SymmetricKey &key)
Definition: sym_algo.h:147

## ◆ set_key() [2/3]

void Botan::SymmetricAlgorithm::set_key | ( | const SymmetricKey & | key | ) |
| inline inherited

Set the symmetric key of this object.

Parameters

  key | the SymmetricKey to be set.

Definition at line 147 of file sym_algo.h.

148 {
149 set_key(key.begin(), key.length());
150 }

References Botan::OctetString::begin(), and Botan::OctetString::length().

Referenced by Botan::aont_package(), Botan::aont_unpackage(), botan_block_cipher_set_key(), botan_cipher_set_key(), botan_mac_set_key(), Botan::Sodium::crypto_stream_salsa20(), Botan::Sodium::crypto_stream_salsa20_xor_ic(), Botan::Sodium::crypto_stream_xsalsa20(), Botan::Sodium::crypto_stream_xsalsa20_xor_ic(), Botan::FPE::fe1_decrypt(), Botan::FPE::fe1_encrypt(), and Botan::Sodium::randombytes_buf_deterministic().

## ◆ set_key() [3/3]

void Botan::SymmetricAlgorithm::set_key | ( | const uint8_t | key[],
|  | size_t | length
| ) |  |
| inherited

Set the symmetric key of this object.

Parameters

  key | the to be set as a byte array.
  length | in bytes of key param

Definition at line 17 of file sym_algo.cpp.

18 {
19 if(!valid_keylength(length))
20 throw Invalid_Key_Length(name(), length);
21 key_schedule(key, length);
22 }
Botan::SymmetricAlgorithm::valid_keylength
bool valid_keylength(size_t length) const
Definition: sym_algo.h:138

References Botan::SymmetricAlgorithm::name(), and Botan::SymmetricAlgorithm::valid_keylength().

## ◆ start() [1/3]

void Botan::Cipher_Mode::start | ( |  | ) |
| inline inherited

Begin processing a message.

Definition at line 87 of file cipher_mode.h.

88 {
89 return start_msg(nullptr, 0);
90 }
Botan::Cipher_Mode::start_msg
virtual void start_msg(const uint8_t nonce[], size_t nonce_len)=0

## ◆ start() [2/3]

template<typename Alloc >

void Botan::Cipher_Mode::start | ( | const std::vector< uint8_t, Alloc > & | nonce | ) |
| inline inherited

Begin processing a message.

Parameters

  nonce | the per message nonce

Definition at line 69 of file cipher_mode.h.

70 {
71 start_msg(nonce.data(), nonce.size());
72 }

Referenced by botan_cipher_start(), and Botan::TLS::write_record().

## ◆ start() [3/3]

void Botan::Cipher_Mode::start | ( | const uint8_t | nonce[],
|  | size_t | nonce_len
| ) |  |
| inline inherited

Begin processing a message.

Parameters

  nonce | the per message nonce
  nonce_len | length of nonce

Definition at line 79 of file cipher_mode.h.

80 {
81 start_msg(nonce, nonce_len);
82 }

## ◆ tag_size()

size_t Botan::CCM_Mode::tag_size | ( |  | ) | const
| inline override virtual inherited

Returns
  the size of the authentication tag used (in bytes)

Reimplemented from Botan::Cipher_Mode.

Definition at line 46 of file ccm.h.

46{ return m_tag_size; }

Referenced by finish(), Botan::CCM_Decryption::finish(), Botan::CCM_Mode::format_b0(), and Botan::CCM_Mode::name().

## ◆ update()

void Botan::Cipher_Mode::update | ( | secure_vector< uint8_t > & | buffer,
|  | size_t | offset = `0`
| ) |  |
| inline inherited

Process some data. Input must be in size update_granularity() uint8_t blocks.

Parameters

  buffer | in/out parameter which will possibly be resized
  offset | an offset into blocks to begin processing

Definition at line 112 of file cipher_mode.h.

113 {
114 BOTAN_ASSERT(buffer.size() >= offset, "Offset ok");
115 uint8_t* buf = buffer.data() + offset;
116 const size_t buf_size = buffer.size() - offset;
117
118 const size_t written = process(buf, buf_size);
119 buffer.resize(offset + written);
120 }
BOTAN_ASSERT
#define BOTAN_ASSERT(expr, assertion_made)
Definition: assert.h:55
Botan::Cipher_Mode::process
virtual size_t process(uint8_t msg[], size_t msg_len)=0

References BOTAN_ASSERT.

Referenced by botan_cipher_update(), Botan::ChaCha20Poly1305_Encryption::finish(), Botan::EAX_Encryption::finish(), Botan::CBC_Encryption::finish(), Botan::CTS_Encryption::finish(), Botan::CBC_Decryption::finish(), Botan::CTS_Decryption::finish(), Botan::CFB_Encryption::finish(), Botan::CFB_Decryption::finish(), Botan::XTS_Encryption::finish(), Botan::XTS_Decryption::finish(), Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::finish(), and Botan::TLS::TLS_CBC_HMAC_AEAD_Decryption::finish().

## ◆ update_granularity()

size_t Botan::CCM_Mode::update_granularity | ( |  | ) | const
| override virtual inherited

Returns
  size of required blocks to update

Implements Botan::Cipher_Mode.

Definition at line 63 of file ccm.cpp.

64 {
65 /*
66 This value does not particularly matter as regardless CCM_Mode::update
67 buffers all input, so in theory this could be 1. However as for instance
68 Transform_Filter creates update_granularity() uint8_t buffers, use a
69 somewhat large size to avoid bouncing on a tiny buffer.
70 */
71 return m_cipher->parallel_bytes();
72 }

## ◆ valid_keylength()

bool Botan::SymmetricAlgorithm::valid_keylength | ( | size_t | length | ) | const
| inline inherited

Check whether a given key length is valid for this algorithm.

Parameters

  length | the key length to be checked.

Returns
  true if the key length is valid.

Definition at line 138 of file sym_algo.h.

139 {
140 return key_spec().valid_keylength(length);
141 }
Botan::Key_Length_Specification::valid_keylength
bool valid_keylength(size_t length) const
Definition: sym_algo.h:52

Referenced by Botan::aont_package(), Botan::aont_unpackage(), and Botan::SymmetricAlgorithm::set_key().

## ◆ valid_nonce_length()

bool Botan::CCM_Mode::valid_nonce_length | ( | size_t | nonce_len | ) | const
| override virtual inherited

Returns
  true iff nonce_len is a valid length for the nonce

Implements Botan::Cipher_Mode.

Definition at line 53 of file ccm.cpp.

54 {
55 return (n == (15-L()));
56 }

References Botan::CCM_Mode::L().

## ◆ verify_key_set()

void Botan::SymmetricAlgorithm::verify_key_set | ( | bool | cond | ) | const
| inline protected inherited

Definition at line 171 of file sym_algo.h.

172 {
173 if(cond == false)
174 throw_key_not_set_error();
175 }

Referenced by Botan::ChaCha::cipher(), Botan::CTR_BE::cipher(), Botan::RC4::cipher(), Botan::Salsa20::cipher(), Botan::SHAKE_128_Cipher::cipher(), Botan::AES_128::decrypt_n(), Botan::AES_192::decrypt_n(), Botan::AES_256::decrypt_n(), Botan::ARIA_128::decrypt_n(), Botan::ARIA_192::decrypt_n(), Botan::ARIA_256::decrypt_n(), Botan::Blowfish::decrypt_n(), Botan::Camellia_128::decrypt_n(), Botan::Camellia_192::decrypt_n(), Botan::Camellia_256::decrypt_n(), Botan::CAST_128::decrypt_n(), Botan::CAST_256::decrypt_n(), Botan::DES::decrypt_n(), Botan::TripleDES::decrypt_n(), Botan::DESX::decrypt_n(), Botan::GOST_28147_89::decrypt_n(), Botan::IDEA::decrypt_n(), Botan::KASUMI::decrypt_n(), Botan::Lion::decrypt_n(), Botan::MISTY1::decrypt_n(), Botan::Noekeon::decrypt_n(), Botan::SEED::decrypt_n(), Botan::Serpent::decrypt_n(), Botan::SHACAL2::decrypt_n(), Botan::SM4::decrypt_n(), Botan::Threefish_512::decrypt_n(), Botan::Twofish::decrypt_n(), Botan::XTEA::decrypt_n(), Botan::AES_128::encrypt_n(), Botan::AES_192::encrypt_n(), Botan::AES_256::encrypt_n(), Botan::ARIA_128::encrypt_n(), Botan::ARIA_192::encrypt_n(), Botan::ARIA_256::encrypt_n(), Botan::Blowfish::encrypt_n(), Botan::Camellia_128::encrypt_n(), Botan::Camellia_192::encrypt_n(), Botan::Camellia_256::encrypt_n(), Botan::CAST_128::encrypt_n(), Botan::CAST_256::encrypt_n(), Botan::DES::encrypt_n(), Botan::TripleDES::encrypt_n(), Botan::DESX::encrypt_n(), Botan::GOST_28147_89::encrypt_n(), Botan::IDEA::encrypt_n(), Botan::KASUMI::encrypt_n(), Botan::Lion::encrypt_n(), Botan::MISTY1::encrypt_n(), Botan::Noekeon::encrypt_n(), Botan::SEED::encrypt_n(), Botan::Serpent::encrypt_n(), Botan::SHACAL2::encrypt_n(), Botan::SM4::encrypt_n(), Botan::Threefish_512::encrypt_n(), Botan::Twofish::encrypt_n(), Botan::XTEA::encrypt_n(), Botan::OCB_Encryption::finish(), Botan::OCB_Decryption::finish(), Botan::GHASH::ghash_update(), Botan::CFB_Encryption::process(), Botan::CFB_Decryption::process(), Botan::ChaCha::seek(), Botan::CTR_BE::seek(), Botan::Salsa20::seek(), Botan::OCB_Mode::set_associated_data(), Botan::ChaCha::set_iv(), Botan::Salsa20::set_iv(), Botan::GHASH::update(), Botan::GHASH::update_associated_data(), and Botan::ChaCha::write_keystream().

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

- src/lib/modes/aead/ccm/ccm.h
- src/lib/modes/aead/ccm/ccm.cpp