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 "xchg.h"
  33 #include <string.h>
  34 #include <stdint.h>
  35
  36 /*
  37 • Add    x_0jklm into    x_1jklm modulo 2**32 , for each (j, k, l, m).
  38 • Rotate x_0jklm upwards by 7 bits, for each (j, k, l, m).
  39 • Swap   x_00klm with    x_01klm , for each (k, l, m).
  40 • Xor    x_1jklm into    x_0jklm , for each (j, k, l, m).
  41 • Swap   x_1jk0m with    x_1jk1m , for each (j, k, m).
  42 • Add    x_0jklm into    x_1jklm modulo 2**32 , for each (j, k, l, m).
  43 • Rotate x_0jklm upwards by 11 bits, for each (j, k, l, m).
  44 • Swap   x_0j0lm with    x_0j1lm , for each (j, l, m).
  45 • Xor    x_1jklm into    x_0jklm , for each (j, k, l, m).
  46 • Swap   x_1jkl0 with    x_1jkl1 , for each (j, k, l).
  47 */
  48
  49 static void cubehash_round(cubehash_ctx_t *ctx){
  50         uint8_t i;
  51         uint32_t t, t2;
  52         for(i=0; i<16; ++i){
  53                 ctx->a[i+16] += t = ctx->a[i];
  54                 ctx->a[i] = rotate7left(t);
  55         }
  56         xchg32_array(&(ctx->a[0]), &(ctx->a[8]), 8);
  57         for(i=0; i<16; i+=4){
  58                 t = ctx->a[i+16];
  59                 t2 = ctx->a[i] ^= t;
  60                 ctx->a[i+16] = ctx->a[i+18] + t2;
  61                 ctx->a[i] = rotate11left(t2);
  62                 t2 = ctx->a[i+2] ^= ctx->a[i+18];
  63                 ctx->a[i+18] = t + t2;
  64                 ctx->a[i+2] = rotate11left(t2);
  65                 t = ctx->a[i+17];
  66                 t2 = ctx->a[i+1] ^= t;
  67                 ctx->a[i+17] = ctx->a[i+19] + t2;
  68                 ctx->a[i+1] = rotate11left(t2);
  69                 t2 = ctx->a[i+3] ^= ctx->a[i+19];
  70                 ctx->a[i+19] = t + t2;
  71                 ctx->a[i+3] = rotate11left(t2);
  72         }
  73         xchg32_array(&(ctx->a[0]), &(ctx->a[4]), 4);
  74         xchg32_array(&(ctx->a[8]), &(ctx->a[12]), 4);
  75         for(i=0; i<16; i+=2){
  76                 ctx->a[i] ^= t = ctx->a[i+16];
  77                 ctx->a[i+1] ^= ctx->a[i+16] = ctx->a[i+17];
  78                 ctx->a[i+17] = t;
  79         }
  80 }
  81
  82 void cubehash_init(uint8_t r, uint8_t b, uint16_t h, cubehash_ctx_t *ctx){
  83         memset(ctx->a, 0, 32*4);
  84         ctx->a[0] = h/8;
  85         ctx->a[1] = b;
  86         ctx->a[2] = r;
  87         ctx->rounds = r;
  88         ctx->blocksize_B = b;
  89         for(b=0; b<10*r; ++b){
  90                 cubehash_round(ctx);
  91         }
  92 }
  93
  94 void cubehash_nextBlock(cubehash_ctx_t *ctx, void *block){
  95         uint8_t i;
  96         memxor(ctx->a, block, ctx->blocksize_B);
  97         for(i=0; i<ctx->rounds; ++i){
  98                 cubehash_round(ctx);
  99         }
 100 }
 101
 102 void cubehash_lastBlock(cubehash_ctx_t *ctx, void *block, uint16_t length_b){
 103         while(length_b>=ctx->blocksize_B*8){
 104                 cubehash_nextBlock(ctx, block);
 105                 block = (uint8_t*)block + ctx->blocksize_B;
 106                 length_b -= ctx->blocksize_B*8;
 107         }
 108         uint8_t buffer[ctx->blocksize_B];
 109         uint8_t i;
 110         memset(buffer, 0, ctx->blocksize_B);
 111         memcpy(buffer, block, (length_b+7)/8);
 112         buffer[length_b/8] |= 0x80 >> (length_b&7);
 113         cubehash_nextBlock(ctx, buffer);
 114         ctx->a[31] ^= 1;
 115         for(i=0; i<10*(ctx->rounds); ++i){
 116                 cubehash_round(ctx);
 117         }
 118 }
 119
 120 void cubehash_ctx2hash(void *dest, uint16_t length_b, cubehash_ctx_t *ctx){
 121         memcpy(dest, ctx->a, (length_b+7)/8);
 122 }
 123
 124 /******************************************************************************/
 125
 126 void cubehash224_init(cubehash_ctx_t *ctx){
 127         cubehash_init(16, 32, 224, ctx);
 128 }
 129
 130 void cubehash224_ctx2hash(void *dest, cubehash_ctx_t *ctx){
 131         cubehash_ctx2hash(dest, 224, ctx);
 132 }
 133
 134 /******************************************************************************/
 135
 136 void cubehash256_init(cubehash_ctx_t *ctx){
 137         cubehash_init(16, 32, 256, ctx);
 138 }
 139
 140 void cubehash256_ctx2hash(void *dest, cubehash_ctx_t *ctx){
 141         cubehash_ctx2hash(dest, 256, ctx);
 142 }
 143
 144 /******************************************************************************/
 145
 146 void cubehash384_init(cubehash_ctx_t *ctx){
 147         cubehash_init(16, 32, 384, ctx);
 148 }
 149
 150 void cubehash384_ctx2hash(void *dest, cubehash_ctx_t *ctx){
 151         cubehash_ctx2hash(dest, 384, ctx);
 152 }
 153
 154 /******************************************************************************/
 155
 156 void cubehash512_init(cubehash_ctx_t *ctx){
 157         cubehash_init(16, 32, 512, ctx);
 158 }
 159
 160 void cubehash512_ctx2hash(void *dest, cubehash_ctx_t *ctx){
 161         cubehash_ctx2hash(dest, 512, ctx);
 162 }