8 #include <botan/sha3.h>
9 #include <botan/parsing.h>
10 #include <botan/exceptn.h>
17 static const uint64_t RC[24] = {
18 0x0000000000000001, 0x0000000000008082, 0x800000000000808A,
19 0x8000000080008000, 0x000000000000808B, 0x0000000080000001,
20 0x8000000080008081, 0x8000000000008009, 0x000000000000008A,
21 0x0000000000000088, 0x0000000080008009, 0x000000008000000A,
22 0x000000008000808B, 0x800000000000008B, 0x8000000000008089,
23 0x8000000000008003, 0x8000000000008002, 0x8000000000000080,
24 0x000000000000800A, 0x800000008000000A, 0x8000000080008081,
25 0x8000000000008080, 0x0000000080000001, 0x8000000080008008
28 for(
size_t i = 0; i != 24; ++i)
30 const uint64_t C0 = A[0] ^ A[5] ^ A[10] ^ A[15] ^ A[20];
31 const uint64_t C1 = A[1] ^ A[6] ^ A[11] ^ A[16] ^ A[21];
32 const uint64_t C2 = A[2] ^ A[7] ^ A[12] ^ A[17] ^ A[22];
33 const uint64_t C3 = A[3] ^ A[8] ^ A[13] ^ A[18] ^ A[23];
34 const uint64_t C4 = A[4] ^ A[9] ^ A[14] ^ A[19] ^ A[24];
42 const uint64_t B00 = A[ 0] ^ D1;
68 A[ 0] = B00 ^ (~B01 & B02);
69 A[ 1] = B01 ^ (~B02 & B03);
70 A[ 2] = B02 ^ (~B03 & B04);
71 A[ 3] = B03 ^ (~B04 & B00);
72 A[ 4] = B04 ^ (~B00 & B01);
73 A[ 5] = B05 ^ (~B06 & B07);
74 A[ 6] = B06 ^ (~B07 & B08);
75 A[ 7] = B07 ^ (~B08 & B09);
76 A[ 8] = B08 ^ (~B09 & B05);
77 A[ 9] = B09 ^ (~B05 & B06);
78 A[10] = B10 ^ (~B11 & B12);
79 A[11] = B11 ^ (~B12 & B13);
80 A[12] = B12 ^ (~B13 & B14);
81 A[13] = B13 ^ (~B14 & B10);
82 A[14] = B14 ^ (~B10 & B11);
83 A[15] = B15 ^ (~B16 & B17);
84 A[16] = B16 ^ (~B17 & B18);
85 A[17] = B17 ^ (~B18 & B19);
86 A[18] = B18 ^ (~B19 & B15);
87 A[19] = B19 ^ (~B15 & B16);
88 A[20] = B20 ^ (~B21 & B22);
89 A[21] = B21 ^ (~B22 & B23);
90 A[22] = B22 ^ (~B23 & B24);
91 A[23] = B23 ^ (~B24 & B20);
92 A[24] = B24 ^ (~B20 & B21);
99 m_output_bits(output_bits),
100 m_bitrate(1600 - 2*output_bits),
106 if(output_bits != 224 && output_bits != 256 &&
107 output_bits != 384 && output_bits != 512)
119 return new SHA_3(m_output_bits);
131 const uint8_t input[],
size_t length)
135 size_t to_take =
std::min(length, bitrate / 8 - S_pos);
139 while(to_take && S_pos % 8)
141 S[S_pos / 8] ^=
static_cast<uint64_t
>(input[0]) << (8 * (S_pos % 8));
148 while(to_take && to_take % 8 == 0)
158 S[S_pos / 8] ^=
static_cast<uint64_t
>(input[0]) << (8 * (S_pos % 8));
165 if(S_pos == bitrate / 8)
178 uint8_t output[],
size_t output_length)
188 if(i % (bitrate / 8) == 0)
199 output[i] =
get_byte(7 - (i % 8), S[Si]);
203 void SHA_3::add_data(
const uint8_t input[],
size_t length)
205 m_S_pos =
SHA_3::absorb(m_bitrate, m_S, m_S_pos, input, length);
208 void SHA_3::final_result(uint8_t output[])
210 std::vector<uint8_t> padding(m_bitrate / 8 - m_S_pos);
213 padding[padding.size()-1] |= 0x80;
215 add_data(padding.data(), padding.size());
221 for(
size_t i = 0; i != m_output_bits/8; ++i)
222 output[i] =
get_byte(7 - (i % 8), m_S[i/8]);
std::string name() const override
static void expand(size_t bitrate, secure_vector< uint64_t > &S, uint8_t output[], size_t output_length)
T rotate_left(T input, size_t rot)
std::string to_string(const BER_Object &obj)
static size_t absorb(size_t bitrate, secure_vector< uint64_t > &S, size_t S_pos, const uint8_t input[], size_t length)
HashFunction * clone() const override
std::vector< T, secure_allocator< T >> secure_vector
size_t output_length() const override
uint64_t load_le< uint64_t >(const uint8_t in[], size_t off)
static void permute(uint64_t A[25])
uint8_t get_byte(size_t byte_num, T input)
SHA_3(size_t output_bits)
#define BOTAN_ARG_CHECK(expr)
void zeroise(std::vector< T, Alloc > &vec)