25 #include "utility/EndianUtil.h"
26 #include "utility/RotateUtil.h"
27 #include "utility/ProgMemUtil.h"
100 #define BLAKE2s_IV0 0x6A09E667
101 #define BLAKE2s_IV1 0xBB67AE85
102 #define BLAKE2s_IV2 0x3C6EF372
103 #define BLAKE2s_IV3 0xA54FF53A
104 #define BLAKE2s_IV4 0x510E527F
105 #define BLAKE2s_IV5 0x9B05688C
106 #define BLAKE2s_IV6 0x1F83D9AB
107 #define BLAKE2s_IV7 0x5BE0CD19
111 state.h[0] = BLAKE2s_IV0 ^ 0x01010020;
112 state.h[1] = BLAKE2s_IV1;
113 state.h[2] = BLAKE2s_IV2;
114 state.h[3] = BLAKE2s_IV3;
115 state.h[4] = BLAKE2s_IV4;
116 state.h[5] = BLAKE2s_IV5;
117 state.h[6] = BLAKE2s_IV6;
118 state.h[7] = BLAKE2s_IV7;
132 if (outputLength < 1)
134 else if (outputLength > 32)
136 state.h[0] = BLAKE2s_IV0 ^ 0x01010000 ^ outputLength;
137 state.h[1] = BLAKE2s_IV1;
138 state.h[2] = BLAKE2s_IV2;
139 state.h[3] = BLAKE2s_IV3;
140 state.h[4] = BLAKE2s_IV4;
141 state.h[5] = BLAKE2s_IV5;
142 state.h[6] = BLAKE2s_IV6;
143 state.h[7] = BLAKE2s_IV7;
164 if (outputLength < 1)
166 else if (outputLength > 32)
168 state.h[0] = BLAKE2s_IV0 ^ 0x01010000 ^ (keyLen << 8) ^ outputLength;
169 state.h[1] = BLAKE2s_IV1;
170 state.h[2] = BLAKE2s_IV2;
171 state.h[3] = BLAKE2s_IV3;
172 state.h[4] = BLAKE2s_IV4;
173 state.h[5] = BLAKE2s_IV5;
174 state.h[6] = BLAKE2s_IV6;
175 state.h[7] = BLAKE2s_IV7;
178 memcpy(state.m, key, keyLen);
179 memset(((uint8_t *)state.m) + keyLen, 0, 64 - keyLen);
180 state.chunkSize = 64;
192 const uint8_t *d = (
const uint8_t *)data;
194 if (state.chunkSize == 64) {
200 uint8_t size = 64 - state.chunkSize;
203 memcpy(((uint8_t *)state.m) + state.chunkSize, d, size);
204 state.chunkSize += size;
205 state.length += size;
214 memset(((uint8_t *)state.m) + state.chunkSize, 0, 64 - state.chunkSize);
215 processChunk(0xFFFFFFFF);
218 for (uint8_t posn = 0; posn < 8; ++posn)
219 state.m[posn] = htole32(state.h[posn]);
224 memcpy(hash, state.m, len);
247 update(temp,
sizeof(temp));
253 static const uint8_t sigma[10][16] PROGMEM = {
254 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
255 {14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3},
256 {11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4},
257 { 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8},
258 { 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13},
259 { 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9},
260 {12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11},
261 {13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10},
262 { 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5},
263 {10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13 , 0}
267 #define quarterRound(a, b, c, d, i) \
270 uint32_t _a = (a) + _b + state.m[pgm_read_byte(&(sigma[index][2 * (i)]))]; \
271 uint32_t _d = rightRotate16((d) ^ _a); \
272 uint32_t _c = (c) + _d; \
273 _b = rightRotate12(_b ^ _c); \
274 _a += _b + state.m[pgm_read_byte(&(sigma[index][2 * (i) + 1]))]; \
275 (d) = _d = rightRotate8(_d ^ _a); \
278 (b) = rightRotate7(_b ^ _c); \
282 void BLAKE2s::processChunk(uint32_t f0)
288 #if !defined(CRYPTO_LITTLE_ENDIAN)
289 for (index = 0; index < 16; ++index)
290 state.m[index] = le32toh(state.m[index]);
294 memcpy(v, state.h,
sizeof(state.h));
299 v[12] = BLAKE2s_IV4 ^ (uint32_t)(state.length);
300 v[13] = BLAKE2s_IV5 ^ (uint32_t)(state.length >> 32);
301 v[14] = BLAKE2s_IV6 ^ f0;
305 for (index = 0; index < 10; ++index) {
307 quarterRound(v[0], v[4], v[8], v[12], 0);
308 quarterRound(v[1], v[5], v[9], v[13], 1);
309 quarterRound(v[2], v[6], v[10], v[14], 2);
310 quarterRound(v[3], v[7], v[11], v[15], 3);
313 quarterRound(v[0], v[5], v[10], v[15], 4);
314 quarterRound(v[1], v[6], v[11], v[12], 5);
315 quarterRound(v[2], v[7], v[8], v[13], 6);
316 quarterRound(v[3], v[4], v[9], v[14], 7);
320 for (index = 0; index < 8; ++index)
321 state.h[index] ^= (v[index] ^ v[index + 8]);
virtual ~BLAKE2s()
Destroys this BLAKE2s hash object after clearing sensitive information.
size_t hashSize() const
Size of the hash result from finalize().
void clear()
Clears the hash state, removing all sensitive data, and then resets the hash ready for a new hashing ...
void reset()
Resets the hash ready for a new hashing process.
size_t blockSize() const
Size of the internal block used by the hash algorithm.
void update(const void *data, size_t len)
Updates the hash with more data.
void resetHMAC(const void *key, size_t keyLen)
Resets the hash ready for a new HMAC hashing process.
void finalize(void *hash, size_t len)
Finalizes the hashing process and returns the hash.
void finalizeHMAC(const void *key, size_t keyLen, void *hash, size_t hashLen)
Finalizes the HMAC hashing process and returns the hash.
BLAKE2s()
Constructs a BLAKE2s hash object.
void formatHMACKey(void *block, const void *key, size_t len, uint8_t pad)
Formats a HMAC key into a block.