]> git.cryptolib.org Git - arm-crypto-lib.git/blob - blake/blake_small.c
starting to make bigint more portable/32-bit efficient
[arm-crypto-lib.git] / blake / blake_small.c
1 /* blake_small.c */
2 /*
3     This file is part of the ARM-Crypto-Lib.
4     Copyright (C) 2006-2010  Daniel Otte (daniel.otte@rub.de)
5
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.
10
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.
15
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/>.
18 */
19 /*
20  * \file    blake_small.c
21  * \author  Daniel Otte
22  * \email   daniel.otte@rub.de
23  * \date    2009-05-04
24  * \license GPLv3 or later
25  *
26  */
27
28 #include <stdint.h>
29 #include <string.h>
30 #include "memxor.h"
31 #include "blake_small.h"
32 #include "blake_common.h"
33
34 static const
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
44 };
45
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)| \
51                                                     (a)>>24 )
52 static
53 void blake_small_expand(uint32_t* v, const blake_small_ctx_t* ctx){
54         uint8_t i;
55         memcpy(v, ctx->h, 8*4);
56         for(i=0; i<8; ++i){
57                 v[8+i] = blake_c[i];
58         }
59         memxor((uint8_t*)v+8, ctx->s, 4*4);
60
61 }
62
63 static
64 void blake_small_changeendian(void* dest, const void* src){
65         uint8_t i;
66         for(i=0; i<16; ++i){
67                 ((uint32_t*)dest)[i] = CHANGE_ENDIAN32(((uint32_t*)src)[i]);
68         }
69 }
70
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]])
75
76 static
77 void blake_small_compress(uint32_t* v,const void* m){
78         uint8_t r,i;
79         uint16_t s, *p=(uint16_t*)blake_sigma;
80         union {
81                 uint32_t v32;
82                 uint8_t v8[4];
83         } idx;
84         for(r=0; r<14; ++r){
85                 for(i=0; i<8; ++i){
86                         idx.v32 = ((uint32_t*)blake_index_lut)[i];
87                         s = *p++;
88                         if(p==(uint16_t*)(blake_sigma+160)){
89                                 p=(uint16_t*)blake_sigma;
90                         }
91                         A += B + (((uint32_t*)m)[s&0xff] ^ blake_c[s>>8]);
92                         D  = ROTR32(A^D, 16);
93                         C += D;
94                         B  = ROTR32(B^C, 12);
95                         A += B + (((uint32_t*)m)[s>>8] ^ blake_c[s&0xff]);
96                         D  = ROTR32(A^D, 8);
97                         C += D;
98                         B  = ROTR32(B^C, 7);
99                 }
100         }
101 }
102
103 static
104 void blake_small_collapse(blake_small_ctx_t* ctx, uint32_t* v){
105         uint8_t i;
106         for(i=0; i<8; ++i){
107                 ctx->h[i] ^= ctx->s[i%4] ^ v[i] ^ v[8+i];
108         }
109 }
110
111 void blake_small_nextBlock(blake_small_ctx_t* ctx, const void* msg){
112         uint32_t v[16];
113         uint32_t m[16];
114         union {
115                 uint64_t v64;
116                 uint32_t v32[2];
117         }ctr;
118         blake_small_expand(v,ctx);
119         ctx->counter++;
120         ctr.v64 = ctx->counter*512;
121         v[12] ^= ctr.v32[0];
122         v[13] ^= ctr.v32[0];
123         v[14] ^= ctr.v32[1];
124         v[15] ^= ctr.v32[1];
125         blake_small_changeendian(m, msg);
126         blake_small_compress(v, m);
127         blake_small_collapse(ctx, v);
128 }
129
130 void blake_small_lastBlock(blake_small_ctx_t* ctx, const void* msg, uint16_t length_b){
131         while(length_b>=BLAKE_SMALL_BLOCKSIZE){
132                 blake_small_nextBlock(ctx, msg);
133                 msg = (uint8_t*)msg + BLAKE_SMALL_BLOCKSIZE_B;
134                 length_b -= BLAKE_SMALL_BLOCKSIZE;
135         }
136         uint8_t buffer[64];
137         uint32_t v[16];
138         union {
139                 uint64_t v64;
140                 uint32_t v32[2];
141         }ctr;
142         ctr.v64 = ctx->counter*512+length_b;
143         memset(buffer, 0, 64);
144         memcpy(buffer, msg, (length_b+7)/8);
145         buffer[length_b/8] |= 0x80 >> (length_b&0x7);
146         blake_small_changeendian(buffer, buffer);
147         blake_small_expand(v, ctx);
148         if(length_b>512-64-2){
149                 v[12] ^= ctr.v32[0];
150                 v[13] ^= ctr.v32[0];
151                 v[14] ^= ctr.v32[1];
152                 v[15] ^= ctr.v32[1];
153                 blake_small_compress(v, buffer);
154                 blake_small_collapse(ctx, v);
155                 memset(buffer, 0, 64-8);
156                 blake_small_expand(v, ctx);
157         }else{
158                 if(length_b){
159                         v[12] ^= ctr.v32[0];
160                         v[13] ^= ctr.v32[0];
161                         v[14] ^= ctr.v32[1];
162                         v[15] ^= ctr.v32[1];
163                 }
164         }
165         if(ctx->appendone)
166                 buffer[64-8-4] |= 0x01;
167         *((uint32_t*)(&(buffer[64-8]))) = ctr.v32[1];
168         *((uint32_t*)(&(buffer[64-4]))) = ctr.v32[0];
169         blake_small_compress(v, buffer);
170         blake_small_collapse(ctx, v);
171
172 }
173
174 static const
175 uint32_t blake256_iv[] = {
176         0x6A09E667L, 0xBB67AE85,
177         0x3C6EF372L, 0xA54FF53A,
178         0x510E527FL, 0x9B05688C,
179         0x1F83D9ABL, 0x5BE0CD19
180 };
181
182 void blake256_init(blake256_ctx_t* ctx){
183         uint8_t i;
184         for(i=0; i<8; ++i){
185                 ctx->h[i] = blake256_iv[i];
186         }
187         memset(ctx->s, 0, 4*4);
188         ctx->counter = 0;
189         ctx->appendone = 1;
190 }
191
192 static const
193 uint32_t blake224_iv[] = {
194         0xC1059ED8, 0x367CD507,
195         0x3070DD17, 0xF70E5939,
196         0xFFC00B31, 0x68581511,
197         0x64F98FA7, 0xBEFA4FA4
198 };
199
200 void blake224_init(blake224_ctx_t* ctx){
201         uint8_t i;
202         for(i=0; i<8; ++i){
203                 ctx->h[i] = blake224_iv[i];
204         }
205         memset(ctx->s, 0, 4*4);
206         ctx->counter = 0;
207         ctx->appendone = 0;
208 }
209
210 void blake256_ctx2hash(void* dest, const blake256_ctx_t* ctx){
211         uint8_t i;
212         for(i=0; i<8; ++i){
213                 ((uint32_t*)dest)[i] = CHANGE_ENDIAN32(ctx->h[i]);
214         }
215 }
216
217 void blake224_ctx2hash(void* dest, const blake224_ctx_t* ctx){
218         uint8_t i;
219         for(i=0; i<7; ++i){
220                 ((uint32_t*)dest)[i] = CHANGE_ENDIAN32(ctx->h[i]);
221         }
222 }
223
224 void blake256_nextBlock(blake256_ctx_t* ctx, const void* block){
225         blake_small_nextBlock(ctx, block);
226 }
227
228 void blake224_nextBlock(blake224_ctx_t* ctx, const void* block){
229         blake_small_nextBlock(ctx, block);
230 }
231
232 void blake256_lastBlock(blake256_ctx_t* ctx, const void* block, uint16_t length_b){
233         blake_small_lastBlock(ctx, block, length_b);
234 }
235
236 void blake224_lastBlock(blake224_ctx_t* ctx, const void* block, uint16_t length_b){
237         blake_small_lastBlock(ctx, block, length_b);
238 }
239
240 void blake256(void* dest, const void* msg, uint32_t length_b){
241         blake_small_ctx_t ctx;
242         blake256_init(&ctx);
243         while(length_b>=BLAKE_SMALL_BLOCKSIZE){
244                 blake_small_nextBlock(&ctx, msg);
245                 msg = (uint8_t*)msg + BLAKE_SMALL_BLOCKSIZE_B;
246                 length_b -= BLAKE_SMALL_BLOCKSIZE;
247         }
248         blake_small_lastBlock(&ctx, msg, length_b);
249         blake256_ctx2hash(dest, &ctx);
250 }
251
252 void blake224(void* dest, const void* msg, uint32_t length_b){
253         blake_small_ctx_t ctx;
254         blake224_init(&ctx);
255         while(length_b>=BLAKE_SMALL_BLOCKSIZE){
256                 blake_small_nextBlock(&ctx, msg);
257                 msg = (uint8_t*)msg + BLAKE_SMALL_BLOCKSIZE_B;
258                 length_b -= BLAKE_SMALL_BLOCKSIZE;
259         }
260         blake_small_lastBlock(&ctx, msg, length_b);
261         blake224_ctx2hash(dest, &ctx);
262 }