8#include <botan/internal/commoncrypto.h>
10#include <botan/assert.h>
11#include <botan/block_cipher.h>
12#include <botan/cipher_mode.h>
13#include <botan/mem_ops.h>
14#include <botan/internal/bit_ops.h>
15#include <botan/internal/commoncrypto_utils.h>
23class CommonCrypto_Cipher_Mode final :
public Cipher_Mode {
25 CommonCrypto_Cipher_Mode(std::string_view
name,
Cipher_Dir direction,
const CommonCryptor_Opts& opts);
27 ~CommonCrypto_Cipher_Mode();
29 std::string provider()
const override {
return "commoncrypto"; }
31 std::string
name()
const override {
return m_mode_name; }
33 size_t output_length(
size_t input_length)
const override;
34 size_t update_granularity()
const override;
35 size_t ideal_granularity()
const override;
36 size_t minimum_final_size()
const override;
37 size_t default_nonce_length()
const override;
38 bool valid_nonce_length(
size_t nonce_len)
const override;
39 void clear()
override;
40 void reset()
override;
41 Key_Length_Specification key_spec()
const override;
43 bool has_keying_material()
const override {
return m_key_set; }
46 void key_schedule(std::span<const uint8_t> key)
override;
48 void start_msg(
const uint8_t nonce[],
size_t nonce_len)
override;
49 size_t process_msg(uint8_t msg[],
size_t msg_len)
override;
52 const std::string m_mode_name;
54 CommonCryptor_Opts m_opts;
55 CCCryptorRef m_cipher =
nullptr;
60CommonCrypto_Cipher_Mode::CommonCrypto_Cipher_Mode(std::string_view
name,
63 m_mode_name(
name), m_direction(direction), m_opts(opts), m_key_set(false), m_nonce_set(false) {}
65CommonCrypto_Cipher_Mode::~CommonCrypto_Cipher_Mode() {
67 CCCryptorRelease(m_cipher);
71void CommonCrypto_Cipher_Mode::start_msg(
const uint8_t nonce[],
size_t nonce_len) {
72 if(!valid_nonce_length(nonce_len)) {
73 throw Invalid_IV_Length(
name(), nonce_len);
76 assert_key_material_set();
80 if(status != kCCSuccess) {
81 throw CommonCrypto_Error(
"CCCryptorReset on start_msg", status);
87size_t CommonCrypto_Cipher_Mode::process_msg(uint8_t msg[],
size_t msg_len) {
88 assert_key_material_set();
94 if(msg_len > INT_MAX) {
97 size_t outl = CCCryptorGetOutputLength(m_cipher, msg_len,
false);
99 secure_vector<uint8_t> out(outl);
101 if(m_opts.padding == ccNoPadding && msg_len % m_opts.block_size) {
105 CCCryptorStatus status = CCCryptorUpdate(m_cipher, msg, msg_len, out.data(), outl, &outl);
106 if(status != kCCSuccess) {
107 throw CommonCrypto_Error(
"CCCryptorUpdate", status);
114void CommonCrypto_Cipher_Mode::finish_msg(secure_vector<uint8_t>& buffer,
size_t offset) {
115 assert_key_material_set();
119 uint8_t* buf = buffer.data() + offset;
120 const size_t buf_size = buffer.size() - offset;
122 size_t written = process(buf, buf_size);
124 size_t outl = CCCryptorGetOutputLength(m_cipher, buf_size - written,
true);
125 secure_vector<uint8_t> out(outl);
127 CCCryptorStatus status = CCCryptorFinal(m_cipher, out.data(), outl, &outl);
128 if(status != kCCSuccess) {
129 throw CommonCrypto_Error(
"CCCryptorFinal", status);
132 size_t new_len = offset + written + outl;
133 if(m_opts.padding != ccNoPadding || buffer.size() < new_len) {
134 buffer.resize(new_len);
136 copy_mem(buffer.data() + offset + written, out.data(), outl);
140size_t CommonCrypto_Cipher_Mode::update_granularity()
const {
141 return m_opts.block_size;
144size_t CommonCrypto_Cipher_Mode::ideal_granularity()
const {
145 return m_opts.block_size * BlockCipher::ParallelismMult;
148size_t CommonCrypto_Cipher_Mode::minimum_final_size()
const {
149 if(m_direction == Cipher_Dir::Encryption)
152 return m_opts.block_size;
155size_t CommonCrypto_Cipher_Mode::default_nonce_length()
const {
156 return m_opts.block_size;
159bool CommonCrypto_Cipher_Mode::valid_nonce_length(
size_t nonce_len)
const {
160 return (nonce_len == 0 || nonce_len == m_opts.block_size);
163size_t CommonCrypto_Cipher_Mode::output_length(
size_t input_length)
const {
164 if(input_length == 0) {
165 return m_opts.block_size;
167 return m_opts.block_size *
ceil_division(input_length, m_opts.block_size);
171void CommonCrypto_Cipher_Mode::clear() {
174 if(m_cipher ==
nullptr) {
179 CCCryptorRelease(m_cipher);
184void CommonCrypto_Cipher_Mode::reset() {
185 if(m_cipher ==
nullptr) {
192 if(status != kCCSuccess) {
193 throw CommonCrypto_Error(
"CCCryptorReset", status);
197Key_Length_Specification CommonCrypto_Cipher_Mode::key_spec()
const {
198 return m_opts.key_spec;
201void CommonCrypto_Cipher_Mode::key_schedule(std::span<const uint8_t> key) {
203 CCOperation op = m_direction == Cipher_Dir::Encryption ? kCCEncrypt : kCCDecrypt;
204 status = CCCryptorCreateWithMode(
205 op, m_opts.mode, m_opts.algo, m_opts.padding,
nullptr, key.data(), key.size(),
nullptr, 0, 0, 0, &m_cipher);
206 if(status != kCCSuccess) {
207 throw CommonCrypto_Error(
"CCCryptorCreate", status);
218 return std::make_unique<CommonCrypto_Cipher_Mode>(
name, direction, opts);
#define BOTAN_STATE_CHECK(expr)
#define BOTAN_ASSERT(expr, assertion_made)
BOTAN_FORCE_INLINE constexpr T ceil_division(T a, T b)
std::unique_ptr< Cipher_Mode > make_commoncrypto_cipher_mode(std::string_view name, Cipher_Dir direction)
constexpr void copy_mem(T *out, const T *in, size_t n)
std::vector< T, secure_allocator< T > > secure_vector
CommonCryptor_Opts commoncrypto_opts_from_algo(std::string_view algo)