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         uint8_t s0, s1;
  80         union {
  81                 uint32_t v32;
  82                 uint8_t v8[4];
  83         } idx;
  84         for(r=0; r<10; ++r){
  85                 for(i=0; i<8; ++i){
  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]);
  90                         D  = ROTR32(A^D, 16);
  91                         C += D;
  92                         B  = ROTR32(B^C, 12);
  93                         A += B + (((uint32_t*)m)[s1] ^ blake_c[s0]);
  94                         D  = ROTR32(A^D, 8);
  95                         C += D;
  96                         B  = ROTR32(B^C, 7);
  97                 }
  98         }
  99 }
 100
 101 static
 102 void blake_small_collapse(blake_small_ctx_t* ctx, uint32_t* v){
 103         uint8_t i;
 104         for(i=0; i<8; ++i){
 105                 ctx->h[i] ^= ctx->s[i%4] ^ v[i] ^ v[8+i];
 106         }
 107 }
 108
 109 void blake_small_nextBlock(blake_small_ctx_t* ctx, const void* msg){
 110         uint32_t v[16];
 111         uint32_t m[16];
 112         union {
 113                 uint64_t v64;
 114                 uint32_t v32[2];
 115         }ctr;
 116         blake_small_expand(v,ctx);
 117         ctx->counter++;
 118         ctr.v64 = ctx->counter*512;
 119         v[12] ^= ctr.v32[0];
 120         v[13] ^= ctr.v32[0];
 121         v[14] ^= ctr.v32[1];
 122         v[15] ^= ctr.v32[1];
 123         blake_small_changeendian(m, msg);
 124         blake_small_compress(v, m);
 125         blake_small_collapse(ctx, v);
 126 }
 127
 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;
 133         }
 134         uint8_t buffer[64];
 135         uint32_t v[16];
 136         union {
 137                 uint64_t v64;
 138                 uint32_t v32[2];
 139         }ctr;
 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){
 147                 v[12] ^= ctr.v32[0];
 148                 v[13] ^= ctr.v32[0];
 149                 v[14] ^= ctr.v32[1];
 150                 v[15] ^= ctr.v32[1];
 151                 blake_small_compress(v, buffer);
 152                 blake_small_collapse(ctx, v);
 153                 memset(buffer, 0, 64-8);
 154                 blake_small_expand(v, ctx);
 155         }else{
 156                 if(length_b){
 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                 }
 162         }
 163         if(ctx->appendone)
 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);
 169
 170 }
 171
 172 static const
 173 uint32_t blake32_iv[] = {
 174         0x6A09E667L, 0xBB67AE85,
 175         0x3C6EF372L, 0xA54FF53A,
 176         0x510E527FL, 0x9B05688C,
 177         0x1F83D9ABL, 0x5BE0CD19
 178 };
 179
 180 void blake32_init(blake32_ctx_t* ctx){
 181         uint8_t i;
 182         for(i=0; i<8; ++i){
 183                 ctx->h[i] = blake32_iv[i];
 184         }
 185         memset(ctx->s, 0, 4*4);
 186         ctx->counter = 0;
 187         ctx->appendone = 1;
 188 }
 189
 190 static const
 191 uint32_t blake28_iv[] = {
 192         0xC1059ED8, 0x367CD507,
 193         0x3070DD17, 0xF70E5939,
 194         0xFFC00B31, 0x68581511,
 195         0x64F98FA7, 0xBEFA4FA4
 196 };
 197
 198 void blake28_init(blake28_ctx_t* ctx){
 199         uint8_t i;
 200         for(i=0; i<8; ++i){
 201                 ctx->h[i] = blake28_iv[i];
 202         }
 203         memset(ctx->s, 0, 4*4);
 204         ctx->counter = 0;
 205         ctx->appendone = 0;
 206 }
 207
 208 void blake32_ctx2hash(void* dest, const blake32_ctx_t* ctx){
 209         uint8_t i;
 210         for(i=0; i<8; ++i){
 211                 ((uint32_t*)dest)[i] = CHANGE_ENDIAN32(ctx->h[i]);
 212         }
 213 }
 214
 215 void blake28_ctx2hash(void* dest, const blake28_ctx_t* ctx){
 216         uint8_t i;
 217         for(i=0; i<7; ++i){
 218                 ((uint32_t*)dest)[i] = CHANGE_ENDIAN32(ctx->h[i]);
 219         }
 220 }
 221
 222 void blake32_nextBlock(blake32_ctx_t* ctx, const void* block){
 223         blake_small_nextBlock(ctx, block);
 224 }
 225
 226 void blake28_nextBlock(blake28_ctx_t* ctx, const void* block){
 227         blake_small_nextBlock(ctx, block);
 228 }
 229
 230 void blake32_lastBlock(blake32_ctx_t* ctx, const void* block, uint16_t length_b){
 231         blake_small_lastBlock(ctx, block, length_b);
 232 }
 233
 234 void blake28_lastBlock(blake28_ctx_t* ctx, const void* block, uint16_t length_b){
 235         blake_small_lastBlock(ctx, block, length_b);
 236 }
 237
 238 void blake32(void* dest, const void* msg, uint32_t length_b){
 239         blake_small_ctx_t ctx;
 240         blake32_init(&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;
 245         }
 246         blake_small_lastBlock(&ctx, msg, length_b);
 247         blake32_ctx2hash(dest, &ctx);
 248 }
 249
 250 void blake28(void* dest, const void* msg, uint32_t length_b){
 251         blake_small_ctx_t ctx;
 252         blake28_init(&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;
 257         }
 258         blake_small_lastBlock(&ctx, msg, length_b);
 259         blake28_ctx2hash(dest, &ctx);
 260 }