1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
/*
* CBC-MAC
* (C) 1999-2007 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/
#include <botan/internal/mac_utils.h>
#include <botan/cbc_mac.h>
#include <botan/lookup.h>
namespace Botan {
CBC_MAC* CBC_MAC::make(const Spec& spec)
{
if(spec.arg_count() == 1)
{
if(auto bc = make_block_cipher(spec.arg(0)))
return new CBC_MAC(bc.release());
}
return nullptr;
}
/*
* Update an CBC-MAC Calculation
*/
void CBC_MAC::add_data(const byte input[], size_t length)
{
size_t xored = std::min(output_length() - m_position, length);
xor_buf(&m_state[m_position], input, xored);
m_position += xored;
if(m_position < output_length())
return;
m_cipher->encrypt(m_state);
input += xored;
length -= xored;
while(length >= output_length())
{
xor_buf(m_state, input, output_length());
m_cipher->encrypt(m_state);
input += output_length();
length -= output_length();
}
xor_buf(m_state, input, length);
m_position = length;
}
/*
* Finalize an CBC-MAC Calculation
*/
void CBC_MAC::final_result(byte mac[])
{
if(m_position)
m_cipher->encrypt(m_state);
copy_mem(mac, m_state.data(), m_state.size());
zeroise(m_state);
m_position = 0;
}
/*
* CBC-MAC Key Schedule
*/
void CBC_MAC::key_schedule(const byte key[], size_t length)
{
m_cipher->set_key(key, length);
}
/*
* Clear memory of sensitive data
*/
void CBC_MAC::clear()
{
m_cipher->clear();
zeroise(m_state);
m_position = 0;
}
/*
* Return the name of this type
*/
std::string CBC_MAC::name() const
{
return "CBC-MAC(" + m_cipher->name() + ")";
}
/*
* Return a clone of this object
*/
MessageAuthenticationCode* CBC_MAC::clone() const
{
return new CBC_MAC(m_cipher->clone());
}
/*
* CBC-MAC Constructor
*/
CBC_MAC::CBC_MAC(BlockCipher* cipher) :
m_cipher(cipher), m_state(cipher->block_size())
{
}
}
|
