cubehash/cubehash.c

   1 /* cubehash.c */
   2 /*
   3     This file is part of the AVR-Crypto-Lib.
   4     Copyright (C) 2008  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     cubehash.c
  21  * \email    daniel.otte@rub.de
  22  * \author   Daniel Otte
  23  * \date     2010-02-20
  24  * \license  GPLv3 or later
  25  *
  26  */
  27
  28
  29 #include "memxor.h"
  30 #include "cubehash.h"
  31 #include "cubehash_rotates.h"
  32 #include <string.h>
  33 #include <stdint.h>
  34
  35 /*
  36 • Add    x_0jklm into    x_1jklm modulo 232 , for each (j, k, l, m).
  37 • Rotate x_0jklm upwards by 7 bits, for each (j, k, l, m).
  38 • Swap   x_00klm with    x_01klm , for each (k, l, m).
  39 • Xor    x_1jklm into    x_0jklm , for each (j, k, l, m).
  40 • Swap   x_1jk0m with    x_1jk1m , for each (j, k, m).
  41 • Add    x_0jklm into    x_1jklm modulo 232 , for each (j, k, l, m).
  42 • Rotate x_0jklm upwards by 11 bits, for each (j, k, l, m).
  43 • Swap   x_0j0lm with    x_0j1lm , for each (j, l, m).
  44 • Xor    x_1jklm into    x_0jklm , for each (j, k, l, m).
  45 • Swap   x_1jkl0 with    x_1jkl1 , for each (j, k, l).
  46 */
  47
  48 static void cubehash_round(cubehash_ctx_t* ctx){
  49         uint8_t i;
  50         uint32_t t;
  51         for(i=0; i<16; ++i){
  52                 ctx->a[i+16] += ctx->a[i];
  53                 ctx->a[i] = rotate7left(ctx->a[i]);
  54         }
  55         for(i=0; i<8; ++i){
  56                 t = ctx->a[i];
  57                 ctx->a[i] = ctx->a[i+8];
  58                 ctx->a[i+8] = t;
  59         }
  60         for(i=16; i<4*4+16; i+=4){
  61                 t = ctx->a[i];
  62                 ctx->a[i-16] ^= t;
  63                 ctx->a[i] = ctx->a[i+2] + ctx->a[i-16];
  64                 ctx->a[i-16] = rotate11left(ctx->a[i-16]);
  65                 ctx->a[i-14] ^= ctx->a[i+2];
  66                 ctx->a[i+2] = t + ctx->a[i-14];
  67                 ctx->a[i-14] = rotate11left(ctx->a[i-14]);
  68                 t = ctx->a[i+1];
  69                 ctx->a[i-15] ^= t;
  70                 ctx->a[i+1] = ctx->a[i+3] + ctx->a[i-15];
  71                 ctx->a[i-15] = rotate11left(ctx->a[i-15]);
  72                 ctx->a[i-13] ^= ctx->a[i+3];
  73                 ctx->a[i+3] = t + ctx->a[i-13];
  74                 ctx->a[i-13] = rotate11left(ctx->a[i-13]);
  75         }
  76         for(i=0; i<4; ++i){
  77                 t = ctx->a[i];
  78                 ctx->a[i] = ctx->a[i+4];
  79                 ctx->a[i+4] = t;
  80         }
  81         for(i=8; i<4+8; ++i){
  82                 t = ctx->a[i];
  83                 ctx->a[i] = ctx->a[i+4];
  84                 ctx->a[i+4] = t;
  85         }
  86         for(i=16; i<16+16; i+=2){
  87                 ctx->a[i-16] ^= t = ctx->a[i];
  88                 ctx->a[i-15] ^= ctx->a[i] = ctx->a[i+1];
  89                 ctx->a[i+1] = t;
  90         }
  91 }
  92
  93 void cubehash_init(uint8_t r, uint8_t b, uint16_t h, cubehash_ctx_t* ctx){
  94         memset(ctx->a, 0, 32*4);
  95         ctx->a[0] = h/8;
  96         ctx->a[1] = b;
  97         ctx->a[2] = r;
  98         ctx->rounds = r;
  99         ctx->blocksize_B = b;
 100         for(b=0; b<10*r; ++b){
 101                 cubehash_round(ctx);
 102         }
 103 }
 104
 105 void cubehash_nextBlock(cubehash_ctx_t* ctx, void* block){
 106         uint8_t i;
 107         memxor(ctx->a, block, ctx->blocksize_B);
 108         for(i=0; i<ctx->rounds; ++i){
 109                 cubehash_round(ctx);
 110         }
 111 }
 112
 113 void cubehash_lastBlock(cubehash_ctx_t* ctx, void* block, uint16_t length_b){
 114         while(length_b>=ctx->blocksize_B*8){
 115                 cubehash_nextBlock(ctx, block);
 116                 block = (uint8_t*)block + ctx->blocksize_B;
 117                 length_b -= ctx->blocksize_B*8;
 118         }
 119         uint8_t buffer[ctx->blocksize_B];
 120         uint8_t i;
 121         memset(buffer, 0, ctx->blocksize_B);
 122         memcpy(buffer, block, (length_b+7)/8);
 123         buffer[length_b/8] |= 0x80 >> (length_b&7);
 124         cubehash_nextBlock(ctx, buffer);
 125         ctx->a[31] ^= 1;
 126         for(i=0; i<10*(ctx->rounds); ++i){
 127                 cubehash_round(ctx);
 128         }
 129 }
 130
 131 void cubehash_ctx2hash(void* dest, uint16_t length_b, cubehash_ctx_t* ctx){
 132         memcpy(dest, ctx->a, (length_b+7)/8);
 133 }
 134
 135 /******************************************************************************/
 136
 137 void cubehash224_init(cubehash_ctx_t* ctx){
 138         cubehash_init(16, 32, 224, ctx);
 139 }
 140
 141 void cubehash224_ctx2hash(void* dest, cubehash_ctx_t* ctx){
 142         cubehash_ctx2hash(dest, 224, ctx);
 143 }
 144
 145 /******************************************************************************/
 146
 147 void cubehash256_init(cubehash_ctx_t* ctx){
 148         cubehash_init(16, 32, 256, ctx);
 149 }
 150
 151 void cubehash256_ctx2hash(void* dest, cubehash_ctx_t* ctx){
 152         cubehash_ctx2hash(dest, 256, ctx);
 153 }
 154
 155 /******************************************************************************/
 156
 157 void cubehash384_init(cubehash_ctx_t* ctx){
 158         cubehash_init(16, 32, 384, ctx);
 159 }
 160
 161 void cubehash384_ctx2hash(void* dest, cubehash_ctx_t* ctx){
 162         cubehash_ctx2hash(dest, 384, ctx);
 163 }
 164
 165 /******************************************************************************/
 166
 167 void cubehash512_init(cubehash_ctx_t* ctx){
 168         cubehash_init(16, 32, 512, ctx);
 169 }
 170
 171 void cubehash512_ctx2hash(void* dest, cubehash_ctx_t* ctx){
 172         cubehash_ctx2hash(dest, 512, ctx);
 173 }