blake/blake_small.c

   1 /* blake_small.c */
   2 /*
   3     This file is part of the AVR-Crypto-Lib.
   4     Copyright (C) 2009  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 <avr/pgmspace.h>
  31 #include "memxor.h"
  32 #include "blake_small.h"
  33 #include "blake_common.h"
  34
  35 #define BUG_1 0 /* bug compatibility for zero length message */
  36 #define BUG_2 0 /* bug compatibility for messages of length%512=505...511 */
  37
  38
  39 uint32_t blake_c[] PROGMEM = {
  40    0x243F6A88, 0x85A308D3,
  41    0x13198A2E, 0x03707344,
  42    0xA4093822, 0x299F31D0,
  43    0x082EFA98, 0xEC4E6C89,
  44    0x452821E6, 0x38D01377,
  45    0xBE5466CF, 0x34E90C6C,
  46    0xC0AC29B7, 0xC97C50DD,
  47    0x3F84D5B5, 0xB5470917
  48 };
  49
  50 #define ROTL32(a, n) (((a)<<(n))|((a)>>(32-(n))))
  51 #define ROTR32(a, n) (((a)>>(n))|((a)<<(32-(n))))
  52 #define CHANGE_ENDIAN32(a) (((a)<<24)| \
  53                             ((0x0000ff00&(a))<<8)| \
  54                                                     ((0x00ff0000&(a))>>8)| \
  55                                                     (a)>>24 )
  56
  57 void blake_small_expand(uint32_t* v, const blake_small_ctx_t* ctx){
  58         uint8_t i;
  59         memcpy(v, ctx->h, 8*4);
  60         for(i=0; i<8; ++i){
  61                 v[8+i] = pgm_read_dword(&(blake_c[i]));
  62         }
  63         memxor((uint8_t*)v+8, ctx->s, 4*4);
  64
  65 }
  66
  67 void blake_small_changeendian(void* dest, const void* src){
  68         uint8_t i;
  69         for(i=0; i<16; ++i){
  70                 ((uint32_t*)dest)[i] = CHANGE_ENDIAN32(((uint32_t*)src)[i]);
  71         }
  72 }
  73
  74 void blake_small_compress(uint32_t* v,const void* m){
  75         uint8_t r,i;
  76         uint8_t a,b,c,d, s0, s1;
  77         uint32_t lv[4];
  78         for(r=0; r<10; ++r){
  79                 for(i=0; i<8; ++i){
  80                         a = pgm_read_byte(blake_index_lut+4*i+0);
  81                         b = pgm_read_byte(blake_index_lut+4*i+1);
  82                         c = pgm_read_byte(blake_index_lut+4*i+2);
  83                         d = pgm_read_byte(blake_index_lut+4*i+3);
  84                         s0 = pgm_read_byte(blake_sigma+16*r+2*i+0);
  85                         s1 = pgm_read_byte(blake_sigma+16*r+2*i+1);
  86
  87                         lv[0] = v[a];
  88                         lv[1] = v[b];
  89                         lv[2] = v[c];
  90                         lv[3] = v[d];
  91
  92                         lv[0] += lv[1] + (((uint32_t*)m)[s0] ^ pgm_read_dword(&(blake_c[s1])));
  93                         lv[3]  = ROTR32(lv[3]^lv[0], 16);
  94                         lv[2] += lv[3];
  95                         lv[1]  = ROTR32(lv[1]^lv[2], 12);
  96                         lv[0] += lv[1] + (((uint32_t*)m)[s1] ^ pgm_read_dword(&(blake_c[s0])));
  97                         lv[3]  = ROTR32(lv[3]^lv[0], 8);
  98                         lv[2] += lv[3];
  99                         lv[1]  = ROTR32(lv[1]^lv[2], 7);
 100
 101                         v[a] = lv[0];
 102                         v[b] = lv[1];
 103                         v[c] = lv[2];
 104                         v[d] = lv[3];
 105                 }
 106         }
 107 }
 108
 109 void blake_small_collapse(blake_small_ctx_t* ctx, uint32_t* v){
 110         uint8_t i;
 111         for(i=0; i<8; ++i){
 112                 ctx->h[i] ^= ctx->s[i%4] ^ v[i] ^ v[8+i];
 113         }
 114 }
 115
 116 void blake_small_nextBlock(blake_small_ctx_t* ctx, const void* msg){
 117         uint32_t v[16];
 118         uint32_t m[16];
 119         union {
 120                 uint64_t v64;
 121                 uint32_t v32[2];
 122         }ctr;
 123         blake_small_expand(v,ctx);
 124         ctx->counter++;
 125         ctr.v64 = ctx->counter*512;
 126         v[12] ^= ctr.v32[0];
 127         v[13] ^= ctr.v32[0];
 128         v[14] ^= ctr.v32[1];
 129         v[15] ^= ctr.v32[1];
 130         blake_small_changeendian(m, msg);
 131         blake_small_compress(v, m);
 132         blake_small_collapse(ctx, v);
 133 }
 134
 135 void blake_small_lastBlock(blake_small_ctx_t* ctx, const void* msg, uint16_t length_b){
 136         while(length_b>=BLAKE_SMALL_BLOCKSIZE){
 137                 blake_small_nextBlock(ctx, msg);
 138                 msg = (uint8_t*)msg + BLAKE_SMALL_BLOCKSIZE_B;
 139                 length_b -= BLAKE_SMALL_BLOCKSIZE;
 140         }
 141         uint8_t buffer[64];
 142         uint32_t v[16];
 143 #if BUG_2
 144         uint32_t tmp=0;
 145 #endif
 146         union {
 147                 uint64_t v64;
 148                 uint32_t v32[2];
 149         }ctr;
 150         ctr.v64 = ctx->counter*512+length_b;
 151 #if BUG_2
 152         if(length_b>=505){
 153                 tmp =ctr.v32[0];
 154                 ctr.v32[0] = ctx->counter*512;
 155                 ctr.v32[0] |= 0x40+length_b-504;
 156         }
 157 #endif
 158         memset(buffer, 0, 64);
 159         memcpy(buffer, msg, (length_b+7)/8);
 160         buffer[length_b/8] |= 0x80 >> (length_b&0x7);
 161         blake_small_changeendian(buffer, buffer);
 162         blake_small_expand(v, ctx);
 163 /*
 164 if(length_b<505 && length_b){
 165         v[12] ^= ctr.v32[0];
 166         v[13] ^= ctr.v32[0];
 167         v[14] ^= ctr.v32[1];
 168         v[15] ^= ctr.v32[1];
 169 }
 170 */
 171 #if BUG_2
 172         if(length_b>=505)
 173                 ctr.v32[0] = tmp;
 174 #endif
 175 #if BUG_1
 176         if(length_b==0 && ctx->counter==0){
 177                 v[14] ^= 1;
 178                 v[15] ^= 1;
 179         }
 180 #endif
 181         if(length_b>512-64-2){
 182                 v[12] ^= ctr.v32[0];
 183                 v[13] ^= ctr.v32[0];
 184                 v[14] ^= ctr.v32[1];
 185                 v[15] ^= ctr.v32[1];
 186                 blake_small_compress(v, buffer);
 187                 blake_small_collapse(ctx, v);
 188                 memset(buffer, 0, 64-8);
 189                 blake_small_expand(v, ctx);
 190         }else{
 191                 if(length_b){
 192                         v[12] ^= ctr.v32[0];
 193                         v[13] ^= ctr.v32[0];
 194                         v[14] ^= ctr.v32[1];
 195                         v[15] ^= ctr.v32[1];
 196                 }
 197         }
 198         if(ctx->appendone)
 199                 buffer[64-8-4] |= 0x01;
 200         *((uint32_t*)(&(buffer[64-8]))) = ctr.v32[1];
 201         *((uint32_t*)(&(buffer[64-4]))) = ctr.v32[0];
 202         blake_small_compress(v, buffer);
 203         blake_small_collapse(ctx, v);
 204
 205 }
 206
 207 uint32_t blake32_iv[] PROGMEM = {
 208         0x6A09E667L, 0xBB67AE85,
 209         0x3C6EF372L, 0xA54FF53A,
 210         0x510E527FL, 0x9B05688C,
 211         0x1F83D9ABL, 0x5BE0CD19
 212 };
 213
 214 void blake32_init(blake32_ctx_t* ctx){
 215         uint8_t i;
 216         for(i=0; i<8; ++i){
 217                 ctx->h[i] = pgm_read_dword(&(blake32_iv[i]));
 218         }
 219         memset(ctx->s, 0, 4*4);
 220         ctx->counter = 0;
 221         ctx->appendone = 1;
 222 }
 223
 224 uint32_t blake28_iv[] PROGMEM = {
 225         0xC1059ED8, 0x367CD507,
 226         0x3070DD17, 0xF70E5939,
 227         0xFFC00B31, 0x68581511,
 228         0x64F98FA7, 0xBEFA4FA4
 229 };
 230
 231 void blake28_init(blake28_ctx_t* ctx){
 232         uint8_t i;
 233         for(i=0; i<8; ++i){
 234                 ctx->h[i] = pgm_read_dword(&(blake28_iv[i]));
 235         }
 236         memset(ctx->s, 0, 4*4);
 237         ctx->counter = 0;
 238         ctx->appendone = 0;
 239 }
 240
 241 void blake32_ctx2hash(void* dest, const blake32_ctx_t* ctx){
 242         uint8_t i;
 243         for(i=0; i<8; ++i){
 244                 ((uint32_t*)dest)[i] = CHANGE_ENDIAN32(ctx->h[i]);
 245         }
 246 }
 247
 248 void blake28_ctx2hash(void* dest, const blake28_ctx_t* ctx){
 249         uint8_t i;
 250         for(i=0; i<7; ++i){
 251                 ((uint32_t*)dest)[i] = CHANGE_ENDIAN32(ctx->h[i]);
 252         }
 253 }
 254
 255 void blake32_nextBlock(blake32_ctx_t* ctx, const void* block){
 256         blake_small_nextBlock(ctx, block);
 257 }
 258
 259 void blake28_nextBlock(blake28_ctx_t* ctx, const void* block){
 260         blake_small_nextBlock(ctx, block);
 261 }
 262
 263 void blake32_lastBlock(blake32_ctx_t* ctx, const void* block, uint16_t length_b){
 264         blake_small_lastBlock(ctx, block, length_b);
 265 }
 266
 267 void blake28_lastBlock(blake28_ctx_t* ctx, const void* block, uint16_t length_b){
 268         blake_small_lastBlock(ctx, block, length_b);
 269 }
 270
 271 void blake32(void* dest, const void* msg, uint32_t length_b){
 272         blake_small_ctx_t ctx;
 273         blake32_init(&ctx);
 274         while(length_b>=BLAKE_SMALL_BLOCKSIZE){
 275                 blake_small_nextBlock(&ctx, msg);
 276                 msg = (uint8_t*)msg + BLAKE_SMALL_BLOCKSIZE_B;
 277                 length_b -= BLAKE_SMALL_BLOCKSIZE;
 278         }
 279         blake_small_lastBlock(&ctx, msg, length_b);
 280         blake32_ctx2hash(dest, &ctx);
 281 }
 282
 283 void blake28(void* dest, const void* msg, uint32_t length_b){
 284         blake_small_ctx_t ctx;
 285         blake28_init(&ctx);
 286         while(length_b>=BLAKE_SMALL_BLOCKSIZE){
 287                 blake_small_nextBlock(&ctx, msg);
 288                 msg = (uint8_t*)msg + BLAKE_SMALL_BLOCKSIZE_B;
 289                 length_b -= BLAKE_SMALL_BLOCKSIZE;
 290         }
 291         blake_small_lastBlock(&ctx, msg, length_b);
 292         blake28_ctx2hash(dest, &ctx);
 293 }