From ef465af87d61c0cfbba17b86a3e1cc48b90ab391 Mon Sep 17 00:00:00 2001 From: lloyd Date: Sat, 18 Jan 2014 19:45:16 +0000 Subject: Use unique_ptr instead of bare pointers and explicit delete in block, mac, hash. m_ namespaced everything while I'm in there. Changed CMAC poly_double signature. --- src/lib/block/cascade/cascade.cpp | 42 +++++++-------- src/lib/block/cascade/cascade.h | 14 +++-- src/lib/block/lion/lion.cpp | 86 +++++++++++++++-------------- src/lib/block/lion/lion.h | 34 ++++++------ src/lib/block/lubyrack/lubyrack.cpp | 75 ++++++++++++-------------- src/lib/block/lubyrack/lubyrack.h | 27 +++++----- src/lib/hash/comb4p/comb4p.cpp | 54 +++++++++---------- src/lib/hash/comb4p/comb4p.h | 15 ++---- src/lib/mac/cbc_mac/cbc_mac.cpp | 53 ++++++++---------- src/lib/mac/cbc_mac/cbc_mac.h | 13 ++--- src/lib/mac/cmac/cmac.cpp | 104 ++++++++++++++++-------------------- src/lib/mac/cmac/cmac.h | 19 +++---- src/lib/mac/hmac/hmac.cpp | 54 +++++++++---------- src/lib/mac/hmac/hmac.h | 12 ++--- src/lib/mac/ssl3mac/ssl3_mac.cpp | 46 ++++++++-------- src/lib/mac/ssl3mac/ssl3_mac.h | 5 +- src/lib/mac/x919_mac/info.txt | 2 +- src/lib/mac/x919_mac/x919_mac.cpp | 64 ++++++++++------------ src/lib/mac/x919_mac/x919_mac.h | 13 +++-- src/lib/modes/aead/ocb/ocb.cpp | 2 +- src/lib/modes/aead/siv/siv.cpp | 6 +-- 21 files changed, 347 insertions(+), 393 deletions(-) (limited to 'src') diff --git a/src/lib/block/cascade/cascade.cpp b/src/lib/block/cascade/cascade.cpp index f1b1a8f2c..67846204d 100644 --- a/src/lib/block/cascade/cascade.cpp +++ b/src/lib/block/cascade/cascade.cpp @@ -12,46 +12,46 @@ namespace Botan { void Cascade_Cipher::encrypt_n(const byte in[], byte out[], size_t blocks) const { - size_t c1_blocks = blocks * (block_size() / cipher1->block_size()); - size_t c2_blocks = blocks * (block_size() / cipher2->block_size()); + size_t c1_blocks = blocks * (block_size() / m_cipher1->block_size()); + size_t c2_blocks = blocks * (block_size() / m_cipher2->block_size()); - cipher1->encrypt_n(in, out, c1_blocks); - cipher2->encrypt_n(out, out, c2_blocks); + m_cipher1->encrypt_n(in, out, c1_blocks); + m_cipher2->encrypt_n(out, out, c2_blocks); } void Cascade_Cipher::decrypt_n(const byte in[], byte out[], size_t blocks) const { - size_t c1_blocks = blocks * (block_size() / cipher1->block_size()); - size_t c2_blocks = blocks * (block_size() / cipher2->block_size()); + size_t c1_blocks = blocks * (block_size() / m_cipher1->block_size()); + size_t c2_blocks = blocks * (block_size() / m_cipher2->block_size()); - cipher2->decrypt_n(in, out, c2_blocks); - cipher1->decrypt_n(out, out, c1_blocks); + m_cipher2->decrypt_n(in, out, c2_blocks); + m_cipher1->decrypt_n(out, out, c1_blocks); } void Cascade_Cipher::key_schedule(const byte key[], size_t) { - const byte* key2 = key + cipher1->maximum_keylength(); + const byte* key2 = key + m_cipher1->maximum_keylength(); - cipher1->set_key(key , cipher1->maximum_keylength()); - cipher2->set_key(key2, cipher2->maximum_keylength()); + m_cipher1->set_key(key , m_cipher1->maximum_keylength()); + m_cipher2->set_key(key2, m_cipher2->maximum_keylength()); } void Cascade_Cipher::clear() { - cipher1->clear(); - cipher2->clear(); + m_cipher1->clear(); + m_cipher2->clear(); } std::string Cascade_Cipher::name() const { - return "Cascade(" + cipher1->name() + "," + cipher2->name() + ")"; + return "Cascade(" + m_cipher1->name() + "," + m_cipher2->name() + ")"; } BlockCipher* Cascade_Cipher::clone() const { - return new Cascade_Cipher(cipher1->clone(), - cipher2->clone()); + return new Cascade_Cipher(m_cipher1->clone(), + m_cipher2->clone()); } namespace { @@ -81,18 +81,12 @@ size_t block_size_for_cascade(size_t bs, size_t bs2) } Cascade_Cipher::Cascade_Cipher(BlockCipher* c1, BlockCipher* c2) : - cipher1(c1), cipher2(c2) + m_cipher1(c1), m_cipher2(c2) { - block = block_size_for_cascade(c1->block_size(), c2->block_size()); + m_block = block_size_for_cascade(c1->block_size(), c2->block_size()); if(block_size() % c1->block_size() || block_size() % c2->block_size()) throw Internal_Error("Failure in " + name() + " constructor"); } -Cascade_Cipher::~Cascade_Cipher() - { - delete cipher1; - delete cipher2; - } - } diff --git a/src/lib/block/cascade/cascade.h b/src/lib/block/cascade/cascade.h index 9b7d44fdf..3634b2f5b 100644 --- a/src/lib/block/cascade/cascade.h +++ b/src/lib/block/cascade/cascade.h @@ -9,6 +9,7 @@ #define BOTAN_CASCADE_H__ #include +#include namespace Botan { @@ -21,12 +22,12 @@ class BOTAN_DLL Cascade_Cipher : public BlockCipher void encrypt_n(const byte in[], byte out[], size_t blocks) const; void decrypt_n(const byte in[], byte out[], size_t blocks) const; - size_t block_size() const { return block; } + size_t block_size() const { return m_block; } Key_Length_Specification key_spec() const { - return Key_Length_Specification(cipher1->maximum_keylength() + - cipher2->maximum_keylength()); + return Key_Length_Specification(m_cipher1->maximum_keylength() + + m_cipher2->maximum_keylength()); } void clear(); @@ -42,14 +43,11 @@ class BOTAN_DLL Cascade_Cipher : public BlockCipher Cascade_Cipher(const Cascade_Cipher&) = delete; Cascade_Cipher& operator=(const Cascade_Cipher&) = delete; - - ~Cascade_Cipher(); private: void key_schedule(const byte[], size_t); - size_t block; - BlockCipher* cipher1; - BlockCipher* cipher2; + size_t m_block; + std::unique_ptr m_cipher1, m_cipher2; }; diff --git a/src/lib/block/lion/lion.cpp b/src/lib/block/lion/lion.cpp index e1e0b56c6..95f703f8b 100644 --- a/src/lib/block/lion/lion.cpp +++ b/src/lib/block/lion/lion.cpp @@ -1,6 +1,6 @@ /* * Lion -* (C) 1999-2007 Jack Lloyd +* (C) 1999-2007,2014 Jack Lloyd * * Distributed under the terms of the Botan license */ @@ -16,25 +16,28 @@ namespace Botan { */ void Lion::encrypt_n(const byte in[], byte out[], size_t blocks) const { + const size_t LEFT_SIZE = left_size(); + const size_t RIGHT_SIZE = right_size(); + secure_vector buffer_vec(LEFT_SIZE); byte* buffer = &buffer_vec[0]; for(size_t i = 0; i != blocks; ++i) { - xor_buf(buffer, in, &key1[0], LEFT_SIZE); - cipher->set_key(buffer, LEFT_SIZE); - cipher->cipher(in + LEFT_SIZE, out + LEFT_SIZE, RIGHT_SIZE); + xor_buf(buffer, in, &m_key1[0], LEFT_SIZE); + m_cipher->set_key(buffer, LEFT_SIZE); + m_cipher->cipher(in + LEFT_SIZE, out + LEFT_SIZE, RIGHT_SIZE); - hash->update(out + LEFT_SIZE, RIGHT_SIZE); - hash->final(buffer); + m_hash->update(out + LEFT_SIZE, RIGHT_SIZE); + m_hash->final(buffer); xor_buf(out, in, buffer, LEFT_SIZE); - xor_buf(buffer, out, &key2[0], LEFT_SIZE); - cipher->set_key(buffer, LEFT_SIZE); - cipher->cipher1(out + LEFT_SIZE, RIGHT_SIZE); + xor_buf(buffer, out, &m_key2[0], LEFT_SIZE); + m_cipher->set_key(buffer, LEFT_SIZE); + m_cipher->cipher1(out + LEFT_SIZE, RIGHT_SIZE); - in += BLOCK_SIZE; - out += BLOCK_SIZE; + in += m_block_size; + out += m_block_size; } } @@ -43,25 +46,28 @@ void Lion::encrypt_n(const byte in[], byte out[], size_t blocks) const */ void Lion::decrypt_n(const byte in[], byte out[], size_t blocks) const { + const size_t LEFT_SIZE = left_size(); + const size_t RIGHT_SIZE = right_size(); + secure_vector buffer_vec(LEFT_SIZE); byte* buffer = &buffer_vec[0]; for(size_t i = 0; i != blocks; ++i) { - xor_buf(buffer, in, &key2[0], LEFT_SIZE); - cipher->set_key(buffer, LEFT_SIZE); - cipher->cipher(in + LEFT_SIZE, out + LEFT_SIZE, RIGHT_SIZE); + xor_buf(buffer, in, &m_key2[0], LEFT_SIZE); + m_cipher->set_key(buffer, LEFT_SIZE); + m_cipher->cipher(in + LEFT_SIZE, out + LEFT_SIZE, RIGHT_SIZE); - hash->update(out + LEFT_SIZE, RIGHT_SIZE); - hash->final(buffer); + m_hash->update(out + LEFT_SIZE, RIGHT_SIZE); + m_hash->final(buffer); xor_buf(out, in, buffer, LEFT_SIZE); - xor_buf(buffer, out, &key1[0], LEFT_SIZE); - cipher->set_key(buffer, LEFT_SIZE); - cipher->cipher1(out + LEFT_SIZE, RIGHT_SIZE); + xor_buf(buffer, out, &m_key1[0], LEFT_SIZE); + m_cipher->set_key(buffer, LEFT_SIZE); + m_cipher->cipher1(out + LEFT_SIZE, RIGHT_SIZE); - in += BLOCK_SIZE; - out += BLOCK_SIZE; + in += m_block_size; + out += m_block_size; } } @@ -73,8 +79,8 @@ void Lion::key_schedule(const byte key[], size_t length) clear(); const size_t half = length / 2; - copy_mem(&key1[0], key, half); - copy_mem(&key2[0], key + half, half); + copy_mem(&m_key1[0], key, half); + copy_mem(&m_key2[0], key + half, half); } /* @@ -82,9 +88,9 @@ void Lion::key_schedule(const byte key[], size_t length) */ std::string Lion::name() const { - return "Lion(" + hash->name() + "," + - cipher->name() + "," + - std::to_string(BLOCK_SIZE) + ")"; + return "Lion(" + m_hash->name() + "," + + m_cipher->name() + "," + + std::to_string(block_size()) + ")"; } /* @@ -92,7 +98,7 @@ std::string Lion::name() const */ BlockCipher* Lion::clone() const { - return new Lion(hash->clone(), cipher->clone(), BLOCK_SIZE); + return new Lion(m_hash->clone(), m_cipher->clone(), block_size()); } /* @@ -100,30 +106,28 @@ BlockCipher* Lion::clone() const */ void Lion::clear() { - zeroise(key1); - zeroise(key2); - hash->clear(); - cipher->clear(); + zeroise(m_key1); + zeroise(m_key2); + m_hash->clear(); + m_cipher->clear(); } /* * Lion Constructor */ -Lion::Lion(HashFunction* hash_in, StreamCipher* sc_in, size_t block_len) : - BLOCK_SIZE(std::max(2*hash_in->output_length() + 1, block_len)), - LEFT_SIZE(hash_in->output_length()), - RIGHT_SIZE(BLOCK_SIZE - LEFT_SIZE), - hash(hash_in), - cipher(sc_in) +Lion::Lion(HashFunction* hash, StreamCipher* cipher, size_t block_size) : + m_block_size(std::max(2*hash->output_length() + 1, block_size)), + m_hash(hash), + m_cipher(cipher) { - if(2*LEFT_SIZE + 1 > BLOCK_SIZE) + if(2*left_size() + 1 > m_block_size) throw Invalid_Argument(name() + ": Chosen block size is too small"); - if(!cipher->valid_keylength(LEFT_SIZE)) + if(!m_cipher->valid_keylength(left_size())) throw Invalid_Argument(name() + ": This stream/hash combo is invalid"); - key1.resize(LEFT_SIZE); - key2.resize(LEFT_SIZE); + m_key1.resize(left_size()); + m_key2.resize(left_size()); } } diff --git a/src/lib/block/lion/lion.h b/src/lib/block/lion/lion.h index 37aad19f2..afee95b4e 100644 --- a/src/lib/block/lion/lion.h +++ b/src/lib/block/lion/lion.h @@ -1,6 +1,6 @@ /* * Lion -* (C) 1999-2007 Jack Lloyd +* (C) 1999-2007,2014 Jack Lloyd * * Distributed under the terms of the Botan license */ @@ -11,6 +11,7 @@ #include #include #include +#include namespace Botan { @@ -25,19 +26,19 @@ namespace Botan { class BOTAN_DLL Lion : public BlockCipher { public: - void encrypt_n(const byte in[], byte out[], size_t blocks) const; - void decrypt_n(const byte in[], byte out[], size_t blocks) const; + void encrypt_n(const byte in[], byte out[], size_t blocks) const override; + void decrypt_n(const byte in[], byte out[], size_t blocks) const override; - size_t block_size() const { return BLOCK_SIZE; } + size_t block_size() const override { return m_block_size; } - Key_Length_Specification key_spec() const + Key_Length_Specification key_spec() const override { - return Key_Length_Specification(2, 2*hash->output_length(), 2); + return Key_Length_Specification(2, 2*m_hash->output_length(), 2); } - void clear(); - std::string name() const; - BlockCipher* clone() const; + void clear() override; + std::string name() const override; + BlockCipher* clone() const override; /** * @param hash the hash to use internally @@ -47,19 +48,16 @@ class BOTAN_DLL Lion : public BlockCipher Lion(HashFunction* hash, StreamCipher* cipher, size_t block_size); - - Lion(const Lion&) = delete; - Lion& operator=(const Lion&) = delete; - - ~Lion() { delete hash; delete cipher; } private: void key_schedule(const byte[], size_t); - const size_t BLOCK_SIZE, LEFT_SIZE, RIGHT_SIZE; + size_t left_size() const { return m_hash->output_length(); } + size_t right_size() const { return m_block_size - left_size(); } - HashFunction* hash; - StreamCipher* cipher; - secure_vector key1, key2; + const size_t m_block_size; + std::unique_ptr m_hash; + std::unique_ptr m_cipher; + secure_vector m_key1, m_key2; }; } diff --git a/src/lib/block/lubyrack/lubyrack.cpp b/src/lib/block/lubyrack/lubyrack.cpp index 9be079003..92974b761 100644 --- a/src/lib/block/lubyrack/lubyrack.cpp +++ b/src/lib/block/lubyrack/lubyrack.cpp @@ -1,6 +1,6 @@ /* * Luby-Rackoff -* (C) 1999-2008 Jack Lloyd +* (C) 1999-2008,2014 Jack Lloyd * * Distributed under the terms of the Botan license */ @@ -15,31 +15,31 @@ namespace Botan { */ void LubyRackoff::encrypt_n(const byte in[], byte out[], size_t blocks) const { - const size_t len = hash->output_length(); + const size_t len = m_hash->output_length(); secure_vector buffer_vec(len); byte* buffer = &buffer_vec[0]; for(size_t i = 0; i != blocks; ++i) { - hash->update(K1); - hash->update(in, len); - hash->final(buffer); + m_hash->update(m_K1); + m_hash->update(in, len); + m_hash->final(buffer); xor_buf(out + len, in + len, buffer, len); - hash->update(K2); - hash->update(out + len, len); - hash->final(buffer); + m_hash->update(m_K2); + m_hash->update(out + len, len); + m_hash->final(buffer); xor_buf(out, in, buffer, len); - hash->update(K1); - hash->update(out, len); - hash->final(buffer); + m_hash->update(m_K1); + m_hash->update(out, len); + m_hash->final(buffer); xor_buf(out + len, buffer, len); - hash->update(K2); - hash->update(out + len, len); - hash->final(buffer); + m_hash->update(m_K2); + m_hash->update(out + len, len); + m_hash->final(buffer); xor_buf(out, buffer, len); in += 2 * len; @@ -52,31 +52,31 @@ void LubyRackoff::encrypt_n(const byte in[], byte out[], size_t blocks) const */ void LubyRackoff::decrypt_n(const byte in[], byte out[], size_t blocks) const { - const size_t len = hash->output_length(); + const size_t len = m_hash->output_length(); secure_vector buffer_vec(len); byte* buffer = &buffer_vec[0]; for(size_t i = 0; i != blocks; ++i) { - hash->update(K2); - hash->update(in + len, len); - hash->final(buffer); + m_hash->update(m_K2); + m_hash->update(in + len, len); + m_hash->final(buffer); xor_buf(out, in, buffer, len); - hash->update(K1); - hash->update(out, len); - hash->final(buffer); + m_hash->update(m_K1); + m_hash->update(out, len); + m_hash->final(buffer); xor_buf(out + len, in + len, buffer, len); - hash->update(K2); - hash->update(out + len, len); - hash->final(buffer); + m_hash->update(m_K2); + m_hash->update(out + len, len); + m_hash->final(buffer); xor_buf(out, buffer, len); - hash->update(K1); - hash->update(out, len); - hash->final(buffer); + m_hash->update(m_K1); + m_hash->update(out, len); + m_hash->final(buffer); xor_buf(out + len, buffer, len); in += 2 * len; @@ -89,8 +89,8 @@ void LubyRackoff::decrypt_n(const byte in[], byte out[], size_t blocks) const */ void LubyRackoff::key_schedule(const byte key[], size_t length) { - K1.assign(key, key + (length / 2)); - K2.assign(key + (length / 2), key + length); + m_K1.assign(key, key + (length / 2)); + m_K2.assign(key + (length / 2), key + length); } /* @@ -98,9 +98,9 @@ void LubyRackoff::key_schedule(const byte key[], size_t length) */ void LubyRackoff::clear() { - zap(K1); - zap(K2); - hash->clear(); + zap(m_K1); + zap(m_K2); + m_hash->clear(); } /* @@ -108,7 +108,7 @@ void LubyRackoff::clear() */ BlockCipher* LubyRackoff::clone() const { - return new LubyRackoff(hash->clone()); + return new LubyRackoff(m_hash->clone()); } /* @@ -116,14 +116,7 @@ BlockCipher* LubyRackoff::clone() const */ std::string LubyRackoff::name() const { - return "Luby-Rackoff(" + hash->name() + ")"; - } - -/* -* Luby-Rackoff Constructor -*/ -LubyRackoff::LubyRackoff(HashFunction* h) : hash(h) - { + return "Luby-Rackoff(" + m_hash->name() + ")"; } } diff --git a/src/lib/block/lubyrack/lubyrack.h b/src/lib/block/lubyrack/lubyrack.h index e28c60be7..236be53d6 100644 --- a/src/lib/block/lubyrack/lubyrack.h +++ b/src/lib/block/lubyrack/lubyrack.h @@ -1,6 +1,6 @@ /* * Luby-Rackoff -* (C) 1999-2008 Jack Lloyd +* (C) 1999-2008,2014 Jack Lloyd * * Distributed under the terms of the Botan license */ @@ -10,6 +10,7 @@ #include #include +#include namespace Botan { @@ -19,30 +20,30 @@ namespace Botan { class BOTAN_DLL LubyRackoff : public BlockCipher { public: - void encrypt_n(const byte in[], byte out[], size_t blocks) const; - void decrypt_n(const byte in[], byte out[], size_t blocks) const; + void encrypt_n(const byte in[], byte out[], size_t blocks) const override; + void decrypt_n(const byte in[], byte out[], size_t blocks) const override; - size_t block_size() const { return 2 * hash->output_length(); } + size_t block_size() const override { return 2 * m_hash->output_length(); } - Key_Length_Specification key_spec() const + Key_Length_Specification key_spec() const override { return Key_Length_Specification(2, 32, 2); } - void clear(); - std::string name() const; - BlockCipher* clone() const; + void clear() override; + std::string name() const override; + BlockCipher* clone() const override; /** * @param hash function to use to form the block cipher */ - LubyRackoff(HashFunction* hash); - ~LubyRackoff() { delete hash; } + LubyRackoff(HashFunction* hash) : m_hash(hash) {} + private: - void key_schedule(const byte[], size_t); + void key_schedule(const byte[], size_t) override; - HashFunction* hash; - secure_vector K1, K2; + std::unique_ptr m_hash; + secure_vector m_K1, m_K2; }; } diff --git a/src/lib/hash/comb4p/comb4p.cpp b/src/lib/hash/comb4p/comb4p.cpp index 7aec5972e..7abc3a3d2 100644 --- a/src/lib/hash/comb4p/comb4p.cpp +++ b/src/lib/hash/comb4p/comb4p.cpp @@ -16,42 +16,42 @@ namespace { void comb4p_round(secure_vector& out, const secure_vector& in, byte round_no, - HashFunction* h1, - HashFunction* h2) + HashFunction& h1, + HashFunction& h2) { - h1->update(round_no); - h2->update(round_no); + h1.update(round_no); + h2.update(round_no); - h1->update(&in[0], in.size()); - h2->update(&in[0], in.size()); + h1.update(&in[0], in.size()); + h2.update(&in[0], in.size()); - secure_vector h_buf = h1->final(); + secure_vector h_buf = h1.final(); xor_buf(&out[0], &h_buf[0], std::min(out.size(), h_buf.size())); - h_buf = h2->final(); + h_buf = h2.final(); xor_buf(&out[0], &h_buf[0], std::min(out.size(), h_buf.size())); } } Comb4P::Comb4P(HashFunction* h1, HashFunction* h2) : - hash1(h1), hash2(h2) + m_hash1(h1), m_hash2(h2) { - if(hash1->name() == hash2->name()) + if(m_hash1->name() == m_hash2->name()) throw std::invalid_argument("Comb4P: Must use two distinct hashes"); - if(hash1->output_length() != hash2->output_length()) + if(m_hash1->output_length() != m_hash2->output_length()) throw std::invalid_argument("Comb4P: Incompatible hashes " + - hash1->name() + " and " + - hash2->name()); + m_hash1->name() + " and " + + m_hash2->name()); clear(); } size_t Comb4P::hash_block_size() const { - if(hash1->hash_block_size() == hash2->hash_block_size()) - return hash1->hash_block_size(); + if(m_hash1->hash_block_size() == m_hash2->hash_block_size()) + return m_hash1->hash_block_size(); /* * Return LCM of the block sizes? This would probably be OK for @@ -62,40 +62,40 @@ size_t Comb4P::hash_block_size() const void Comb4P::clear() { - hash1->clear(); - hash2->clear(); + m_hash1->clear(); + m_hash2->clear(); // Prep for processing next message, if any - hash1->update(0); - hash2->update(0); + m_hash1->update(0); + m_hash2->update(0); } void Comb4P::add_data(const byte input[], size_t length) { - hash1->update(input, length); - hash2->update(input, length); + m_hash1->update(input, length); + m_hash2->update(input, length); } void Comb4P::final_result(byte out[]) { - secure_vector h1 = hash1->final(); - secure_vector h2 = hash2->final(); + secure_vector h1 = m_hash1->final(); + secure_vector h2 = m_hash2->final(); // First round xor_buf(&h1[0], &h2[0], std::min(h1.size(), h2.size())); // Second round - comb4p_round(h2, h1, 1, hash1, hash2); + comb4p_round(h2, h1, 1, *m_hash1, *m_hash2); // Third round - comb4p_round(h1, h2, 2, hash1, hash2); + comb4p_round(h1, h2, 2, *m_hash1, *m_hash2); copy_mem(out , &h1[0], h1.size()); copy_mem(out + h1.size(), &h2[0], h2.size()); // Prep for processing next message, if any - hash1->update(0); - hash2->update(0); + m_hash1->update(0); + m_hash2->update(0); } } diff --git a/src/lib/hash/comb4p/comb4p.h b/src/lib/hash/comb4p/comb4p.h index e0cffc22b..818990439 100644 --- a/src/lib/hash/comb4p/comb4p.h +++ b/src/lib/hash/comb4p/comb4p.h @@ -9,6 +9,7 @@ #define BOTAN_COMB4P_H__ #include +#include namespace Botan { @@ -25,26 +26,21 @@ class BOTAN_DLL Comb4P : public HashFunction */ Comb4P(HashFunction* h1, HashFunction* h2); - Comb4P(const Comb4P&) = delete; - Comb4P& operator=(const Comb4P&) = delete; - - ~Comb4P() { delete hash1; delete hash2; } - size_t hash_block_size() const; size_t output_length() const { - return hash1->output_length() + hash2->output_length(); + return m_hash1->output_length() + m_hash2->output_length(); } HashFunction* clone() const { - return new Comb4P(hash1->clone(), hash2->clone()); + return new Comb4P(m_hash1->clone(), m_hash2->clone()); } std::string name() const { - return "Comb4P(" + hash1->name() + "," + hash2->name() + ")"; + return "Comb4P(" + m_hash1->name() + "," + m_hash2->name() + ")"; } void clear(); @@ -52,8 +48,7 @@ class BOTAN_DLL Comb4P : public HashFunction void add_data(const byte input[], size_t length); void final_result(byte out[]); - HashFunction* hash1; - HashFunction* hash2; + std::unique_ptr m_hash1, m_hash2; }; } diff --git a/src/lib/mac/cbc_mac/cbc_mac.cpp b/src/lib/mac/cbc_mac/cbc_mac.cpp index 118570e72..7d9a55e28 100644 --- a/src/lib/mac/cbc_mac/cbc_mac.cpp +++ b/src/lib/mac/cbc_mac/cbc_mac.cpp @@ -16,26 +16,26 @@ namespace Botan { */ void CBC_MAC::add_data(const byte input[], size_t length) { - size_t xored = std::min(output_length() - position, length); - xor_buf(&state[position], input, xored); - position += xored; + size_t xored = std::min(output_length() - m_position, length); + xor_buf(&m_state[m_position], input, xored); + m_position += xored; - if(position < output_length()) + if(m_position < output_length()) return; - e->encrypt(state); + m_cipher->encrypt(m_state); input += xored; length -= xored; while(length >= output_length()) { - xor_buf(state, input, output_length()); - e->encrypt(state); + xor_buf(m_state, input, output_length()); + m_cipher->encrypt(m_state); input += output_length(); length -= output_length(); } - xor_buf(state, input, length); - position = length; + xor_buf(m_state, input, length); + m_position = length; } /* @@ -43,12 +43,12 @@ void CBC_MAC::add_data(const byte input[], size_t length) */ void CBC_MAC::final_result(byte mac[]) { - if(position) - e->encrypt(state); + if(m_position) + m_cipher->encrypt(m_state); - copy_mem(mac, &state[0], state.size()); - zeroise(state); - position = 0; + copy_mem(mac, &m_state[0], m_state.size()); + zeroise(m_state); + m_position = 0; } /* @@ -56,7 +56,7 @@ void CBC_MAC::final_result(byte mac[]) */ void CBC_MAC::key_schedule(const byte key[], size_t length) { - e->set_key(key, length); + m_cipher->set_key(key, length); } /* @@ -64,9 +64,9 @@ void CBC_MAC::key_schedule(const byte key[], size_t length) */ void CBC_MAC::clear() { - e->clear(); - zeroise(state); - position = 0; + m_cipher->clear(); + zeroise(m_state); + m_position = 0; } /* @@ -74,7 +74,7 @@ void CBC_MAC::clear() */ std::string CBC_MAC::name() const { - return "CBC-MAC(" + e->name() + ")"; + return "CBC-MAC(" + m_cipher->name() + ")"; } /* @@ -82,24 +82,15 @@ std::string CBC_MAC::name() const */ MessageAuthenticationCode* CBC_MAC::clone() const { - return new CBC_MAC(e->clone()); + return new CBC_MAC(m_cipher->clone()); } /* * CBC-MAC Constructor */ -CBC_MAC::CBC_MAC(BlockCipher* e_in) : - e(e_in), state(e->block_size()) +CBC_MAC::CBC_MAC(BlockCipher* cipher) : + m_cipher(cipher), m_state(cipher->block_size()) { - position = 0; - } - -/* -* CBC-MAC Destructor -*/ -CBC_MAC::~CBC_MAC() - { - delete e; } } diff --git a/src/lib/mac/cbc_mac/cbc_mac.h b/src/lib/mac/cbc_mac/cbc_mac.h index be25718d9..e7285d0cb 100644 --- a/src/lib/mac/cbc_mac/cbc_mac.h +++ b/src/lib/mac/cbc_mac/cbc_mac.h @@ -10,6 +10,7 @@ #include #include +#include namespace Botan { @@ -21,27 +22,27 @@ class BOTAN_DLL CBC_MAC : public MessageAuthenticationCode public: std::string name() const; MessageAuthenticationCode* clone() const; - size_t output_length() const { return e->block_size(); } + size_t output_length() const { return m_cipher->block_size(); } void clear(); Key_Length_Specification key_spec() const { - return e->key_spec(); + return m_cipher->key_spec(); } /** * @param cipher the underlying block cipher to use */ CBC_MAC(BlockCipher* cipher); - ~CBC_MAC(); + private: void add_data(const byte[], size_t); void final_result(byte[]); void key_schedule(const byte[], size_t); - BlockCipher* e; - secure_vector state; - size_t position; + std::unique_ptr m_cipher; + secure_vector m_state; + size_t m_position = 0; }; } diff --git a/src/lib/mac/cmac/cmac.cpp b/src/lib/mac/cmac/cmac.cpp index 00120cf14..16524faec 100644 --- a/src/lib/mac/cmac/cmac.cpp +++ b/src/lib/mac/cmac/cmac.cpp @@ -1,11 +1,12 @@ /* * CMAC -* (C) 1999-2007 Jack Lloyd +* (C) 1999-2007,2014 Jack Lloyd * * Distributed under the terms of the Botan license */ #include +#include #include namespace Botan { @@ -13,9 +14,10 @@ namespace Botan { /* * Perform CMAC's multiplication in GF(2^n) */ -secure_vector CMAC::poly_double(const secure_vector& in, - byte polynomial) +secure_vector CMAC::poly_double(const secure_vector& in) { + const byte polynomial = (in.size() == 16) ? 0x87 : 0x1B; + const byte poly_xor = (in[0] & 0x80) ? polynomial : 0; secure_vector out = in; @@ -38,24 +40,24 @@ secure_vector CMAC::poly_double(const secure_vector& in, */ void CMAC::add_data(const byte input[], size_t length) { - buffer_insert(buffer, position, input, length); - if(position + length > output_length()) + buffer_insert(m_buffer, m_position, input, length); + if(m_position + length > output_length()) { - xor_buf(state, buffer, output_length()); - e->encrypt(state); - input += (output_length() - position); - length -= (output_length() - position); + xor_buf(m_state, m_buffer, output_length()); + m_cipher->encrypt(m_state); + input += (output_length() - m_position); + length -= (output_length() - m_position); while(length > output_length()) { - xor_buf(state, input, output_length()); - e->encrypt(state); + xor_buf(m_state, input, output_length()); + m_cipher->encrypt(m_state); input += output_length(); length -= output_length(); } - copy_mem(&buffer[0], input, length); - position = 0; + copy_mem(&m_buffer[0], input, length); + m_position = 0; } - position += length; + m_position += length; } /* @@ -63,26 +65,26 @@ void CMAC::add_data(const byte input[], size_t length) */ void CMAC::final_result(byte mac[]) { - xor_buf(state, buffer, position); + xor_buf(m_state, m_buffer, m_position); - if(position == output_length()) + if(m_position == output_length()) { - xor_buf(state, B, output_length()); + xor_buf(m_state, m_B, output_length()); } else { - state[position] ^= 0x80; - xor_buf(state, P, output_length()); + m_state[m_position] ^= 0x80; + xor_buf(m_state, m_P, output_length()); } - e->encrypt(state); + m_cipher->encrypt(m_state); for(size_t i = 0; i != output_length(); ++i) - mac[i] = state[i]; + mac[i] = m_state[i]; - zeroise(state); - zeroise(buffer); - position = 0; + zeroise(m_state); + zeroise(m_buffer); + m_position = 0; } /* @@ -91,10 +93,10 @@ void CMAC::final_result(byte mac[]) void CMAC::key_schedule(const byte key[], size_t length) { clear(); - e->set_key(key, length); - e->encrypt(B); - B = poly_double(B, polynomial); - P = poly_double(B, polynomial); + m_cipher->set_key(key, length); + m_cipher->encrypt(m_B); + m_B = poly_double(m_B); + m_P = poly_double(m_B); } /* @@ -102,12 +104,12 @@ void CMAC::key_schedule(const byte key[], size_t length) */ void CMAC::clear() { - e->clear(); - zeroise(state); - zeroise(buffer); - zeroise(B); - zeroise(P); - position = 0; + m_cipher->clear(); + zeroise(m_state); + zeroise(m_buffer); + zeroise(m_B); + zeroise(m_P); + m_position = 0; } /* @@ -115,7 +117,7 @@ void CMAC::clear() */ std::string CMAC::name() const { - return "CMAC(" + e->name() + ")"; + return "CMAC(" + m_cipher->name() + ")"; } /* @@ -123,34 +125,22 @@ std::string CMAC::name() const */ MessageAuthenticationCode* CMAC::clone() const { - return new CMAC(e->clone()); + return new CMAC(m_cipher->clone()); } /* * CMAC Constructor */ -CMAC::CMAC(BlockCipher* e_in) : e(e_in) - { - if(e->block_size() == 16) - polynomial = 0x87; - else if(e->block_size() == 8) - polynomial = 0x1B; - else - throw Invalid_Argument("CMAC cannot use the cipher " + e->name()); - - state.resize(output_length()); - buffer.resize(output_length()); - B.resize(output_length()); - P.resize(output_length()); - position = 0; - } - -/* -* CMAC Destructor -*/ -CMAC::~CMAC() +CMAC::CMAC(BlockCipher* cipher) : m_cipher(cipher) { - delete e; + if(m_cipher->block_size() != 8 && m_cipher->block_size() != 16) + throw Invalid_Argument("CMAC cannot use the cipher " + m_cipher->name()); + + m_state.resize(output_length()); + m_buffer.resize(output_length()); + m_B.resize(output_length()); + m_P.resize(output_length()); + m_position = 0; } } diff --git a/src/lib/mac/cmac/cmac.h b/src/lib/mac/cmac/cmac.h index c1b75cfa5..f363eade5 100644 --- a/src/lib/mac/cmac/cmac.h +++ b/src/lib/mac/cmac/cmac.h @@ -1,6 +1,6 @@ /* * CMAC -* (C) 1999-2007 Jack Lloyd +* (C) 1999-2007,2014 Jack Lloyd * * Distributed under the terms of the Botan license */ @@ -10,6 +10,7 @@ #include #include +#include namespace Botan { @@ -20,14 +21,14 @@ class BOTAN_DLL CMAC : public MessageAuthenticationCode { public: std::string name() const; - size_t output_length() const { return e->block_size(); } + size_t output_length() const { return m_cipher->block_size(); } MessageAuthenticationCode* clone() const; void clear(); Key_Length_Specification key_spec() const { - return e->key_spec(); + return m_cipher->key_spec(); } /** @@ -35,8 +36,7 @@ class BOTAN_DLL CMAC : public MessageAuthenticationCode * @param in the input * @param polynomial the byte value of the polynomial */ - static secure_vector poly_double(const secure_vector& in, - byte polynomial); + static secure_vector poly_double(const secure_vector& in); /** * @param cipher the underlying block cipher to use @@ -45,17 +45,14 @@ class BOTAN_DLL CMAC : public MessageAuthenticationCode CMAC(const CMAC&) = delete; CMAC& operator=(const CMAC&) = delete; - - ~CMAC(); private: void add_data(const byte[], size_t); void final_result(byte[]); void key_schedule(const byte[], size_t); - BlockCipher* e; - secure_vector buffer, state, B, P; - size_t position; - byte polynomial; + std::unique_ptr m_cipher; + secure_vector m_buffer, m_state, m_B, m_P; + size_t m_position; }; } diff --git a/src/lib/mac/hmac/hmac.cpp b/src/lib/mac/hmac/hmac.cpp index 9e9a643db..6d8e393ae 100644 --- a/src/lib/mac/hmac/hmac.cpp +++ b/src/lib/mac/hmac/hmac.cpp @@ -1,6 +1,6 @@ /* * HMAC -* (C) 1999-2007 Jack Lloyd +* (C) 1999-2007,2014 Jack Lloyd * 2007 Yves Jerschow * * Distributed under the terms of the Botan license @@ -16,7 +16,7 @@ namespace Botan { */ void HMAC::add_data(const byte input[], size_t length) { - hash->update(input, length); + m_hash->update(input, length); } /* @@ -24,11 +24,11 @@ void HMAC::add_data(const byte input[], size_t length) */ void HMAC::final_result(byte mac[]) { - hash->final(mac); - hash->update(o_key); - hash->update(mac, output_length()); - hash->final(mac); - hash->update(i_key); + m_hash->final(mac); + m_hash->update(m_okey); + m_hash->update(mac, output_length()); + m_hash->final(mac); + m_hash->update(m_ikey); } /* @@ -36,27 +36,27 @@ void HMAC::final_result(byte mac[]) */ void HMAC::key_schedule(const byte key[], size_t length) { - hash->clear(); + m_hash->clear(); - i_key.resize(hash->hash_block_size()); - o_key.resize(hash->hash_block_size()); + m_ikey.resize(m_hash->hash_block_size()); + m_okey.resize(m_hash->hash_block_size()); - std::fill(i_key.begin(), i_key.end(), 0x36); - std::fill(o_key.begin(), o_key.end(), 0x5C); + std::fill(m_ikey.begin(), m_ikey.end(), 0x36); + std::fill(m_okey.begin(), m_okey.end(), 0x5C); - if(length > hash->hash_block_size()) + if(length > m_hash->hash_block_size()) { - secure_vector hmac_key = hash->process(key, length); - xor_buf(i_key, hmac_key, hmac_key.size()); - xor_buf(o_key, hmac_key, hmac_key.size()); + secure_vector hmac_key = m_hash->process(key, length); + xor_buf(m_ikey, hmac_key, hmac_key.size()); + xor_buf(m_okey, hmac_key, hmac_key.size()); } else { - xor_buf(i_key, key, length); - xor_buf(o_key, key, length); + xor_buf(m_ikey, key, length); + xor_buf(m_okey, key, length); } - hash->update(i_key); + m_hash->update(m_ikey); } /* @@ -64,9 +64,9 @@ void HMAC::key_schedule(const byte key[], size_t length) */ void HMAC::clear() { - hash->clear(); - zap(i_key); - zap(o_key); + m_hash->clear(); + zap(m_ikey); + zap(m_okey); } /* @@ -74,7 +74,7 @@ void HMAC::clear() */ std::string HMAC::name() const { - return "HMAC(" + hash->name() + ")"; + return "HMAC(" + m_hash->name() + ")"; } /* @@ -82,16 +82,16 @@ std::string HMAC::name() const */ MessageAuthenticationCode* HMAC::clone() const { - return new HMAC(hash->clone()); + return new HMAC(m_hash->clone()); } /* * HMAC Constructor */ -HMAC::HMAC(HashFunction* hash_in) : hash(hash_in) +HMAC::HMAC(HashFunction* hash) : m_hash(hash) { - if(hash->hash_block_size() == 0) - throw Invalid_Argument("HMAC cannot be used with " + hash->name()); + if(m_hash->hash_block_size() == 0) + throw Invalid_Argument("HMAC cannot be used with " + m_hash->name()); } } diff --git a/src/lib/mac/hmac/hmac.h b/src/lib/mac/hmac/hmac.h index 39a084874..359d4e6f3 100644 --- a/src/lib/mac/hmac/hmac.h +++ b/src/lib/mac/hmac/hmac.h @@ -1,6 +1,6 @@ /* * HMAC -* (C) 1999-2007 Jack Lloyd +* (C) 1999-2007,2014 Jack Lloyd * * Distributed under the terms of the Botan license */ @@ -10,6 +10,7 @@ #include #include +#include namespace Botan { @@ -23,10 +24,11 @@ class BOTAN_DLL HMAC : public MessageAuthenticationCode std::string name() const; MessageAuthenticationCode* clone() const; - size_t output_length() const { return hash->output_length(); } + size_t output_length() const { return m_hash->output_length(); } Key_Length_Specification key_spec() const { + // Absurd max length here is to support PBKDF2 return Key_Length_Specification(0, 512); } @@ -37,15 +39,13 @@ class BOTAN_DLL HMAC : public MessageAuthenticationCode HMAC(const HMAC&) = delete; HMAC& operator=(const HMAC&) = delete; - - ~HMAC() { delete hash; } private: void add_data(const byte[], size_t); void final_result(byte[]); void key_schedule(const byte[], size_t); - HashFunction* hash; - secure_vector i_key, o_key; + std::unique_ptr m_hash; + secure_vector m_ikey, m_okey; }; } diff --git a/src/lib/mac/ssl3mac/ssl3_mac.cpp b/src/lib/mac/ssl3mac/ssl3_mac.cpp index 64f3103ef..82a26cfaf 100644 --- a/src/lib/mac/ssl3mac/ssl3_mac.cpp +++ b/src/lib/mac/ssl3mac/ssl3_mac.cpp @@ -14,7 +14,7 @@ namespace Botan { */ void SSL3_MAC::add_data(const byte input[], size_t length) { - hash->update(input, length); + m_hash->update(input, length); } /* @@ -22,11 +22,11 @@ void SSL3_MAC::add_data(const byte input[], size_t length) */ void SSL3_MAC::final_result(byte mac[]) { - hash->final(mac); - hash->update(o_key); - hash->update(mac, output_length()); - hash->final(mac); - hash->update(i_key); + m_hash->final(mac); + m_hash->update(m_okey); + m_hash->update(mac, output_length()); + m_hash->final(mac); + m_hash->update(m_ikey); } /* @@ -34,22 +34,22 @@ void SSL3_MAC::final_result(byte mac[]) */ void SSL3_MAC::key_schedule(const byte key[], size_t length) { - hash->clear(); + m_hash->clear(); // Quirk to deal with specification bug const size_t inner_hash_length = - (hash->name() == "SHA-160") ? 60 : hash->hash_block_size(); + (m_hash->name() == "SHA-160") ? 60 : m_hash->hash_block_size(); - i_key.resize(inner_hash_length); - o_key.resize(inner_hash_length); + m_ikey.resize(inner_hash_length); + m_okey.resize(inner_hash_length); - std::fill(i_key.begin(), i_key.end(), 0x36); - std::fill(o_key.begin(), o_key.end(), 0x5C); + std::fill(m_ikey.begin(), m_ikey.end(), 0x36); + std::fill(m_okey.begin(), m_okey.end(), 0x5C); - copy_mem(&i_key[0], key, length); - copy_mem(&o_key[0], key, length); + copy_mem(&m_ikey[0], key, length); + copy_mem(&m_okey[0], key, length); - hash->update(i_key); + m_hash->update(m_ikey); } /* @@ -57,9 +57,9 @@ void SSL3_MAC::key_schedule(const byte key[], size_t length) */ void SSL3_MAC::clear() { - hash->clear(); - zap(i_key); - zap(o_key); + m_hash->clear(); + zap(m_ikey); + zap(m_okey); } /* @@ -67,7 +67,7 @@ void SSL3_MAC::clear() */ std::string SSL3_MAC::name() const { - return "SSL3-MAC(" + hash->name() + ")"; + return "SSL3-MAC(" + m_hash->name() + ")"; } /* @@ -75,16 +75,16 @@ std::string SSL3_MAC::name() const */ MessageAuthenticationCode* SSL3_MAC::clone() const { - return new SSL3_MAC(hash->clone()); + return new SSL3_MAC(m_hash->clone()); } /* * SSL3-MAC Constructor */ -SSL3_MAC::SSL3_MAC(HashFunction* hash_in) : hash(hash_in) +SSL3_MAC::SSL3_MAC(HashFunction* hash) : m_hash(hash) { - if(hash->hash_block_size() == 0) - throw Invalid_Argument("SSL3-MAC cannot be used with " + hash->name()); + if(m_hash->hash_block_size() == 0) + throw Invalid_Argument("SSL3-MAC cannot be used with " + m_hash->name()); } } diff --git a/src/lib/mac/ssl3mac/ssl3_mac.h b/src/lib/mac/ssl3mac/ssl3_mac.h index d23ac023c..8ddb13ce8 100644 --- a/src/lib/mac/ssl3mac/ssl3_mac.h +++ b/src/lib/mac/ssl3mac/ssl3_mac.h @@ -34,14 +34,13 @@ class BOTAN_DLL SSL3_MAC : public MessageAuthenticationCode * @param hash the underlying hash to use */ SSL3_MAC(HashFunction* hash); - ~SSL3_MAC() { delete hash; } private: void add_data(const byte[], size_t); void final_result(byte[]); void key_schedule(const byte[], size_t); - HashFunction* hash; - secure_vector i_key, o_key; + std::unique_ptr m_hash; + secure_vector m_ikey, m_okey; }; } diff --git a/src/lib/mac/x919_mac/info.txt b/src/lib/mac/x919_mac/info.txt index 63bf40790..90d849803 100644 --- a/src/lib/mac/x919_mac/info.txt +++ b/src/lib/mac/x919_mac/info.txt @@ -1,5 +1,5 @@ define ANSI_X919_MAC 20131128 -block +des diff --git a/src/lib/mac/x919_mac/x919_mac.cpp b/src/lib/mac/x919_mac/x919_mac.cpp index faf6138ef..1a6d03761 100644 --- a/src/lib/mac/x919_mac/x919_mac.cpp +++ b/src/lib/mac/x919_mac/x919_mac.cpp @@ -16,25 +16,25 @@ namespace Botan { */ void ANSI_X919_MAC::add_data(const byte input[], size_t length) { - size_t xored = std::min(8 - position, length); - xor_buf(&state[position], input, xored); - position += xored; + size_t xored = std::min(8 - m_position, length); + xor_buf(&m_state[m_position], input, xored); + m_position += xored; - if(position < 8) return; + if(m_position < 8) return; - e->encrypt(state); + m_des1->encrypt(m_state); input += xored; length -= xored; while(length >= 8) { - xor_buf(state, input, 8); - e->encrypt(state); + xor_buf(m_state, input, 8); + m_des1->encrypt(m_state); input += 8; length -= 8; } - xor_buf(state, input, length); - position = length; + xor_buf(m_state, input, length); + m_position = length; } /* @@ -42,12 +42,12 @@ void ANSI_X919_MAC::add_data(const byte input[], size_t length) */ void ANSI_X919_MAC::final_result(byte mac[]) { - if(position) - e->encrypt(state); - d->decrypt(&state[0], mac); - e->encrypt(mac); - zeroise(state); - position = 0; + if(m_position) + m_des1->encrypt(m_state); + m_des2->decrypt(&m_state[0], mac); + m_des1->encrypt(mac); + zeroise(m_state); + m_position = 0; } /* @@ -55,9 +55,12 @@ void ANSI_X919_MAC::final_result(byte mac[]) */ void ANSI_X919_MAC::key_schedule(const byte key[], size_t length) { - e->set_key(key, 8); - if(length == 8) d->set_key(key, 8); - else d->set_key(key + 8, 8); + m_des1->set_key(key, 8); + + if(length == 16) + key += 8; + + m_des2->set_key(key, 8); } /* @@ -65,10 +68,10 @@ void ANSI_X919_MAC::key_schedule(const byte key[], size_t length) */ void ANSI_X919_MAC::clear() { - e->clear(); - d->clear(); - zeroise(state); - position = 0; + m_des1->clear(); + m_des2->clear(); + zeroise(m_state); + m_position = 0; } std::string ANSI_X919_MAC::name() const @@ -78,26 +81,17 @@ std::string ANSI_X919_MAC::name() const MessageAuthenticationCode* ANSI_X919_MAC::clone() const { - return new ANSI_X919_MAC(e->clone()); + return new ANSI_X919_MAC(m_des1->clone()); } /* * ANSI X9.19 MAC Constructor */ -ANSI_X919_MAC::ANSI_X919_MAC(BlockCipher* e_in) : - e(e_in), d(e->clone()), state(e->block_size()), position(0) +ANSI_X919_MAC::ANSI_X919_MAC(BlockCipher* cipher) : + m_des1(cipher), m_des2(m_des1->clone()), m_state(8), m_position(0) { - if(e->name() != "DES") + if(cipher->name() != "DES") throw Invalid_Argument("ANSI X9.19 MAC only supports DES"); } -/* -* ANSI X9.19 MAC Destructor -le*/ -ANSI_X919_MAC::~ANSI_X919_MAC() - { - delete e; - delete d; - } - } diff --git a/src/lib/mac/x919_mac/x919_mac.h b/src/lib/mac/x919_mac/x919_mac.h index b7b7d685e..38993af62 100644 --- a/src/lib/mac/x919_mac/x919_mac.h +++ b/src/lib/mac/x919_mac/x919_mac.h @@ -10,6 +10,7 @@ #include #include +#include namespace Botan { @@ -21,7 +22,8 @@ class BOTAN_DLL ANSI_X919_MAC : public MessageAuthenticationCode public: void clear(); std::string name() const; - size_t output_length() const { return e->block_size(); } + size_t output_length() const { return 8; } + MessageAuthenticationCode* clone() const; Key_Length_Specification key_spec() const @@ -36,17 +38,14 @@ class BOTAN_DLL ANSI_X919_MAC : public MessageAuthenticationCode ANSI_X919_MAC(const ANSI_X919_MAC&) = delete; ANSI_X919_MAC& operator=(const ANSI_X919_MAC&) = delete; - - ~ANSI_X919_MAC(); private: void add_data(const byte[], size_t); void final_result(byte[]); void key_schedule(const byte[], size_t); - BlockCipher* e; - BlockCipher* d; - secure_vector state; - size_t position; + std::unique_ptr m_des1, m_des2; + secure_vector m_state; + size_t m_position; }; } diff --git a/src/lib/modes/aead/ocb/ocb.cpp b/src/lib/modes/aead/ocb/ocb.cpp index fd66bb2e9..2e337ba66 100644 --- a/src/lib/modes/aead/ocb/ocb.cpp +++ b/src/lib/modes/aead/ocb/ocb.cpp @@ -63,7 +63,7 @@ class L_computer secure_vector poly_double(const secure_vector& in) const { - return CMAC::poly_double(in, 0x87); + return CMAC::poly_double(in); } secure_vector m_L_dollar, m_L_star; diff --git a/src/lib/modes/aead/siv/siv.cpp b/src/lib/modes/aead/siv/siv.cpp index a89c3dd08..be998cdb0 100644 --- a/src/lib/modes/aead/siv/siv.cpp +++ b/src/lib/modes/aead/siv/siv.cpp @@ -104,19 +104,19 @@ secure_vector SIV_Mode::S2V(const byte* text, size_t text_len) for(size_t i = 0; i != m_ad_macs.size(); ++i) { - V = CMAC::poly_double(V, 0x87); + V = CMAC::poly_double(V); V ^= m_ad_macs[i]; } if(m_nonce.size()) { - V = CMAC::poly_double(V, 0x87); + V = CMAC::poly_double(V); V ^= m_nonce; } if(text_len < 16) { - V = CMAC::poly_double(V, 0x87); + V = CMAC::poly_double(V); xor_buf(&V[0], text, text_len); V[text_len] ^= 0x80; return cmac().process(V); -- cgit v1.2.3