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 static
  36 uint32_t blake_c[] PROGMEM = {
  37    0x243F6A88, 0x85A308D3,
  38    0x13198A2E, 0x03707344,
  39    0xA4093822, 0x299F31D0,
  40    0x082EFA98, 0xEC4E6C89,
  41    0x452821E6, 0x38D01377,
  42    0xBE5466CF, 0x34E90C6C,
  43    0xC0AC29B7, 0xC97C50DD,
  44    0x3F84D5B5, 0xB5470917
  45 };
  46
  47 #define ROTL32(a, n) (((a)<<(n))|((a)>>(32-(n))))
  48 #define ROTR32(a, n) (((a)>>(n))|((a)<<(32-(n))))
  49 #define CHANGE_ENDIAN32(a) (((a)<<24)| \
  50                             ((0x0000ff00&(a))<<8)| \
  51                                                     ((0x00ff0000&(a))>>8)| \
  52                                                     (a)>>24 )
  53 static
  54 void blake_small_expand(uint32_t* v, const blake_small_ctx_t* ctx){
  55         uint8_t i;
  56         memcpy(v, ctx->h, 8*4);
  57         for(i=0; i<8; ++i){
  58                 v[8+i] = pgm_read_dword(&(blake_c[i]));
  59         }
  60         memxor((uint8_t*)v+8, ctx->s, 4*4);
  61
  62 }
  63
  64 static
  65 void blake_small_changeendian(void* dest, const void* src){
  66         uint8_t i;
  67         for(i=0; i<16; ++i){
  68                 ((uint32_t*)dest)[i] = CHANGE_ENDIAN32(((uint32_t*)src)[i]);
  69         }
  70 }
  71
  72 static
  73 void blake_small_compress(uint32_t* v,const void* m){
  74         uint8_t r,i;
  75         uint8_t a,b,c,d, s0, s1, sigma_idx=0;
  76         uint32_t lv[4];
  77         for(r=0; r<14; ++r){
  78                 for(i=0; i<8; ++i){
  79                         a = pgm_read_byte(blake_index_lut+4*i+0);
  80                         b = pgm_read_byte(blake_index_lut+4*i+1);
  81                         c = pgm_read_byte(blake_index_lut+4*i+2);
  82                         d = pgm_read_byte(blake_index_lut+4*i+3);
  83                         s0 = pgm_read_byte(blake_sigma+sigma_idx);
  84                         s1 = s0&0xf;
  85                         s0 >>= 4;++sigma_idx;
  86                         if(sigma_idx>=80){
  87                                 sigma_idx-=80;
  88                         }
  89                         lv[0] = v[a];
  90                         lv[1] = v[b];
  91                         lv[2] = v[c];
  92                         lv[3] = v[d];
  93
  94                         lv[0] += lv[1] + (((uint32_t*)m)[s0] ^ pgm_read_dword(&(blake_c[s1])));
  95                         lv[3]  = ROTR32(lv[3]^lv[0], 16);
  96                         lv[2] += lv[3];
  97                         lv[1]  = ROTR32(lv[1]^lv[2], 12);
  98                         lv[0] += lv[1] + (((uint32_t*)m)[s1] ^ pgm_read_dword(&(blake_c[s0])));
  99                         lv[3]  = ROTR32(lv[3]^lv[0], 8);
 100                         lv[2] += lv[3];
 101                         lv[1]  = ROTR32(lv[1]^lv[2], 7);
 102
 103                         v[a] = lv[0];
 104                         v[b] = lv[1];
 105                         v[c] = lv[2];
 106                         v[d] = lv[3];
 107                 }
 108         }
 109 }
 110
 111 static
 112 void blake_small_collapse(blake_small_ctx_t* ctx, uint32_t* v){
 113         uint8_t i;
 114         for(i=0; i<8; ++i){
 115                 ctx->h[i] ^= ctx->s[i%4] ^ v[i] ^ v[8+i];
 116         }
 117 }
 118
 119 void blake_small_nextBlock(blake_small_ctx_t* ctx, const void* msg){
 120         uint32_t v[16];
 121         uint32_t m[16];
 122         union {
 123                 uint64_t v64;
 124                 uint32_t v32[2];
 125         }ctr;
 126         blake_small_expand(v,ctx);
 127         ctx->counter++;
 128         ctr.v64 = ctx->counter*512;
 129         v[12] ^= ctr.v32[0];
 130         v[13] ^= ctr.v32[0];
 131         v[14] ^= ctr.v32[1];
 132         v[15] ^= ctr.v32[1];
 133         blake_small_changeendian(m, msg);
 134         blake_small_compress(v, m);
 135         blake_small_collapse(ctx, v);
 136 }
 137
 138 void blake_small_lastBlock(blake_small_ctx_t* ctx, const void* msg, uint16_t length_b){
 139         while(length_b>=BLAKE_SMALL_BLOCKSIZE){
 140                 blake_small_nextBlock(ctx, msg);
 141                 msg = (uint8_t*)msg + BLAKE_SMALL_BLOCKSIZE_B;
 142                 length_b -= BLAKE_SMALL_BLOCKSIZE;
 143         }
 144         uint8_t buffer[64];
 145         uint32_t v[16];
 146         union {
 147                 uint64_t v64;
 148                 uint32_t v32[2];
 149         }ctr;
 150         ctr.v64 = ctx->counter*512+length_b;
 151         memset(buffer, 0, 64);
 152         memcpy(buffer, msg, (length_b+7)/8);
 153         buffer[length_b/8] |= 0x80 >> (length_b&0x7);
 154         blake_small_changeendian(buffer, buffer);
 155         blake_small_expand(v, ctx);
 156         if(length_b>512-64-2){
 157                 v[12] ^= ctr.v32[0];
 158                 v[13] ^= ctr.v32[0];
 159                 v[14] ^= ctr.v32[1];
 160                 v[15] ^= ctr.v32[1];
 161                 blake_small_compress(v, buffer);
 162                 blake_small_collapse(ctx, v);
 163                 memset(buffer, 0, 64-8);
 164                 blake_small_expand(v, ctx);
 165         }else{
 166                 if(length_b){
 167                         v[12] ^= ctr.v32[0];
 168                         v[13] ^= ctr.v32[0];
 169                         v[14] ^= ctr.v32[1];
 170                         v[15] ^= ctr.v32[1];
 171                 }
 172         }
 173         if(ctx->appendone)
 174                 buffer[64-8-4] |= 0x01;
 175         *((uint32_t*)(&(buffer[64-8]))) = ctr.v32[1];
 176         *((uint32_t*)(&(buffer[64-4]))) = ctr.v32[0];
 177         blake_small_compress(v, buffer);
 178         blake_small_collapse(ctx, v);
 179
 180 }
 181
 182 uint32_t blake256_iv[] PROGMEM = {
 183         0x6A09E667L, 0xBB67AE85,
 184         0x3C6EF372L, 0xA54FF53A,
 185         0x510E527FL, 0x9B05688C,
 186         0x1F83D9ABL, 0x5BE0CD19
 187 };
 188
 189 void blake256_init(blake256_ctx_t* ctx){
 190         uint8_t i;
 191         for(i=0; i<8; ++i){
 192                 ctx->h[i] = pgm_read_dword(&(blake256_iv[i]));
 193         }
 194         memset(ctx->s, 0, 4*4);
 195         ctx->counter = 0;
 196         ctx->appendone = 1;
 197 }
 198
 199 uint32_t blake224_iv[] PROGMEM = {
 200         0xC1059ED8, 0x367CD507,
 201         0x3070DD17, 0xF70E5939,
 202         0xFFC00B31, 0x68581511,
 203         0x64F98FA7, 0xBEFA4FA4
 204 };
 205
 206 void blake224_init(blake224_ctx_t* ctx){
 207         uint8_t i;
 208         for(i=0; i<8; ++i){
 209                 ctx->h[i] = pgm_read_dword(&(blake224_iv[i]));
 210         }
 211         memset(ctx->s, 0, 4*4);
 212         ctx->counter = 0;
 213         ctx->appendone = 0;
 214 }
 215
 216 void blake256_ctx2hash(void* dest, const blake256_ctx_t* ctx){
 217         uint8_t i;
 218         for(i=0; i<8; ++i){
 219                 ((uint32_t*)dest)[i] = CHANGE_ENDIAN32(ctx->h[i]);
 220         }
 221 }
 222
 223 void blake224_ctx2hash(void* dest, const blake224_ctx_t* ctx){
 224         uint8_t i;
 225         for(i=0; i<7; ++i){
 226                 ((uint32_t*)dest)[i] = CHANGE_ENDIAN32(ctx->h[i]);
 227         }
 228 }
 229
 230 void blake256_nextBlock(blake256_ctx_t* ctx, const void* block){
 231         blake_small_nextBlock(ctx, block);
 232 }
 233
 234 void blake224_nextBlock(blake224_ctx_t* ctx, const void* block){
 235         blake_small_nextBlock(ctx, block);
 236 }
 237
 238 void blake256_lastBlock(blake256_ctx_t* ctx, const void* block, uint16_t length_b){
 239         blake_small_lastBlock(ctx, block, length_b);
 240 }
 241
 242 void blake224_lastBlock(blake224_ctx_t* ctx, const void* block, uint16_t length_b){
 243         blake_small_lastBlock(ctx, block, length_b);
 244 }
 245
 246 void blake256(void* dest, const void* msg, uint32_t length_b){
 247         blake_small_ctx_t ctx;
 248         blake256_init(&ctx);
 249         while(length_b>=BLAKE_SMALL_BLOCKSIZE){
 250                 blake_small_nextBlock(&ctx, msg);
 251                 msg = (uint8_t*)msg + BLAKE_SMALL_BLOCKSIZE_B;
 252                 length_b -= BLAKE_SMALL_BLOCKSIZE;
 253         }
 254         blake_small_lastBlock(&ctx, msg, length_b);
 255         blake256_ctx2hash(dest, &ctx);
 256 }
 257
 258 void blake224(void* dest, const void* msg, uint32_t length_b){
 259         blake_small_ctx_t ctx;
 260         blake224_init(&ctx);
 261         while(length_b>=BLAKE_SMALL_BLOCKSIZE){
 262                 blake_small_nextBlock(&ctx, msg);
 263                 msg = (uint8_t*)msg + BLAKE_SMALL_BLOCKSIZE_B;
 264                 length_b -= BLAKE_SMALL_BLOCKSIZE;
 265         }
 266         blake_small_lastBlock(&ctx, msg, length_b);
 267         blake224_ctx2hash(dest, &ctx);
 268 }