3 This file is part of the ARM-Crypto-Lib.
4 Copyright (C) 2006-2010 Daniel Otte (daniel.otte@rub.de)
6 This program is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
22 * \email daniel.otte@rub.de
24 * \license GPLv3 or later
30 #include "memxor/memxor.h"
31 #include "blake_small.h"
32 #include "blake_common.h"
35 uint32_t blake_c[] = {
36 0x243F6A88, 0x85A308D3,
37 0x13198A2E, 0x03707344,
38 0xA4093822, 0x299F31D0,
39 0x082EFA98, 0xEC4E6C89,
40 0x452821E6, 0x38D01377,
41 0xBE5466CF, 0x34E90C6C,
42 0xC0AC29B7, 0xC97C50DD,
43 0x3F84D5B5, 0xB5470917
46 #define ROTL32(a, n) (((a)<<(n))|((a)>>(32-(n))))
47 #define ROTR32(a, n) (((a)>>(n))|((a)<<(32-(n))))
48 #define CHANGE_ENDIAN32(a) (((a)<<24)| \
49 ((0x0000ff00&(a))<<8)| \
50 ((0x00ff0000&(a))>>8)| \
53 void blake_small_expand(uint32_t* v, const blake_small_ctx_t* ctx){
55 memcpy(v, ctx->h, 8*4);
59 memxor((uint8_t*)v+8, ctx->s, 4*4);
64 void blake_small_changeendian(void* dest, const void* src){
67 ((uint32_t*)dest)[i] = CHANGE_ENDIAN32(((uint32_t*)src)[i]);
71 #define A (v[idx.v8[0]])
72 #define B (v[idx.v8[1]])
73 #define C (v[idx.v8[2]])
74 #define D (v[idx.v8[3]])
77 void blake_small_compress(uint32_t* v,const void* m){
86 idx.v32 = ((uint32_t*)blake_index_lut)[i];
87 s0 = blake_sigma[16*r+2*i+0];
88 s1 = blake_sigma[16*r+2*i+1];
89 A += B + (((uint32_t*)m)[s0] ^ blake_c[s1]);
93 A += B + (((uint32_t*)m)[s1] ^ blake_c[s0]);
102 void blake_small_collapse(blake_small_ctx_t* ctx, uint32_t* v){
105 ctx->h[i] ^= ctx->s[i%4] ^ v[i] ^ v[8+i];
109 void blake_small_nextBlock(blake_small_ctx_t* ctx, const void* msg){
116 blake_small_expand(v,ctx);
118 ctr.v64 = ctx->counter*512;
123 blake_small_changeendian(m, msg);
124 blake_small_compress(v, m);
125 blake_small_collapse(ctx, v);
128 void blake_small_lastBlock(blake_small_ctx_t* ctx, const void* msg, uint16_t length_b){
129 while(length_b>=BLAKE_SMALL_BLOCKSIZE){
130 blake_small_nextBlock(ctx, msg);
131 msg = (uint8_t*)msg + BLAKE_SMALL_BLOCKSIZE_B;
132 length_b -= BLAKE_SMALL_BLOCKSIZE;
140 ctr.v64 = ctx->counter*512+length_b;
141 memset(buffer, 0, 64);
142 memcpy(buffer, msg, (length_b+7)/8);
143 buffer[length_b/8] |= 0x80 >> (length_b&0x7);
144 blake_small_changeendian(buffer, buffer);
145 blake_small_expand(v, ctx);
146 if(length_b>512-64-2){
151 blake_small_compress(v, buffer);
152 blake_small_collapse(ctx, v);
153 memset(buffer, 0, 64-8);
154 blake_small_expand(v, ctx);
164 buffer[64-8-4] |= 0x01;
165 *((uint32_t*)(&(buffer[64-8]))) = ctr.v32[1];
166 *((uint32_t*)(&(buffer[64-4]))) = ctr.v32[0];
167 blake_small_compress(v, buffer);
168 blake_small_collapse(ctx, v);
173 uint32_t blake32_iv[] = {
174 0x6A09E667L, 0xBB67AE85,
175 0x3C6EF372L, 0xA54FF53A,
176 0x510E527FL, 0x9B05688C,
177 0x1F83D9ABL, 0x5BE0CD19
180 void blake32_init(blake32_ctx_t* ctx){
183 ctx->h[i] = blake32_iv[i];
185 memset(ctx->s, 0, 4*4);
191 uint32_t blake28_iv[] = {
192 0xC1059ED8, 0x367CD507,
193 0x3070DD17, 0xF70E5939,
194 0xFFC00B31, 0x68581511,
195 0x64F98FA7, 0xBEFA4FA4
198 void blake28_init(blake28_ctx_t* ctx){
201 ctx->h[i] = blake28_iv[i];
203 memset(ctx->s, 0, 4*4);
208 void blake32_ctx2hash(void* dest, const blake32_ctx_t* ctx){
211 ((uint32_t*)dest)[i] = CHANGE_ENDIAN32(ctx->h[i]);
215 void blake28_ctx2hash(void* dest, const blake28_ctx_t* ctx){
218 ((uint32_t*)dest)[i] = CHANGE_ENDIAN32(ctx->h[i]);
222 void blake32_nextBlock(blake32_ctx_t* ctx, const void* block){
223 blake_small_nextBlock(ctx, block);
226 void blake28_nextBlock(blake28_ctx_t* ctx, const void* block){
227 blake_small_nextBlock(ctx, block);
230 void blake32_lastBlock(blake32_ctx_t* ctx, const void* block, uint16_t length_b){
231 blake_small_lastBlock(ctx, block, length_b);
234 void blake28_lastBlock(blake28_ctx_t* ctx, const void* block, uint16_t length_b){
235 blake_small_lastBlock(ctx, block, length_b);
238 void blake32(void* dest, const void* msg, uint32_t length_b){
239 blake_small_ctx_t ctx;
241 while(length_b>=BLAKE_SMALL_BLOCKSIZE){
242 blake_small_nextBlock(&ctx, msg);
243 msg = (uint8_t*)msg + BLAKE_SMALL_BLOCKSIZE_B;
244 length_b -= BLAKE_SMALL_BLOCKSIZE;
246 blake_small_lastBlock(&ctx, msg, length_b);
247 blake32_ctx2hash(dest, &ctx);
250 void blake28(void* dest, const void* msg, uint32_t length_b){
251 blake_small_ctx_t ctx;
253 while(length_b>=BLAKE_SMALL_BLOCKSIZE){
254 blake_small_nextBlock(&ctx, msg);
255 msg = (uint8_t*)msg + BLAKE_SMALL_BLOCKSIZE_B;
256 length_b -= BLAKE_SMALL_BLOCKSIZE;
258 blake_small_lastBlock(&ctx, msg, length_b);
259 blake28_ctx2hash(dest, &ctx);