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 #include "memxor.h"
  29 #include "cubehash.h"
  30 #include "cubehash_rotates.h"
  31 #include "xchg.h"
  32 #include <string.h>
  33 #include <stdint.h>
  34
  35 /*
  36  • Add    x_0jklm into    x_1jklm modulo 2**32 , 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 2**32 , 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 {
  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 {
  84     memset(ctx->a, 0, 32 * 4);
  85     ctx->a[0] = h / 8;
  86     ctx->a[1] = b;
  87     ctx->a[2] = r;
  88     ctx->rounds = r;
  89     ctx->blocksize_B = b;
  90     for (b = 0; b < 10 * r; ++b) {
  91         cubehash_round(ctx);
  92     }
  93 }
  94
  95 void cubehash_nextBlock(cubehash_ctx_t *ctx, void *block)
  96 {
  97     uint8_t i;
  98     memxor(ctx->a, block, ctx->blocksize_B);
  99     for (i = 0; i < ctx->rounds; ++i) {
 100         cubehash_round(ctx);
 101     }
 102 }
 103
 104 void cubehash_lastBlock(cubehash_ctx_t *ctx, void *block, uint16_t length_b)
 105 {
 106     while (length_b >= ctx->blocksize_B * 8) {
 107         cubehash_nextBlock(ctx, block);
 108         block = (uint8_t*) block + ctx->blocksize_B;
 109         length_b -= ctx->blocksize_B * 8;
 110     }
 111     uint8_t buffer[ctx->blocksize_B];
 112     uint8_t i;
 113     memset(buffer, 0, ctx->blocksize_B);
 114     memcpy(buffer, block, (length_b + 7) / 8);
 115     buffer[length_b / 8] |= 0x80 >> (length_b & 7);
 116     cubehash_nextBlock(ctx, buffer);
 117     ctx->a[31] ^= 1;
 118     for (i = 0; i < 10 * (ctx->rounds); ++i) {
 119         cubehash_round(ctx);
 120     }
 121 }
 122
 123 void cubehash_ctx2hash(void *dest, uint16_t length_b, cubehash_ctx_t *ctx)
 124 {
 125     memcpy(dest, ctx->a, (length_b + 7) / 8);
 126 }
 127
 128 /******************************************************************************/
 129
 130 void cubehash224_init(cubehash_ctx_t *ctx)
 131 {
 132     cubehash_init(16, 32, 224, ctx);
 133 }
 134
 135 void cubehash224_ctx2hash(void *dest, cubehash_ctx_t *ctx)
 136 {
 137     cubehash_ctx2hash(dest, 224, ctx);
 138 }
 139
 140 /******************************************************************************/
 141
 142 void cubehash256_init(cubehash_ctx_t *ctx)
 143 {
 144     cubehash_init(16, 32, 256, ctx);
 145 }
 146
 147 void cubehash256_ctx2hash(void *dest, cubehash_ctx_t *ctx)
 148 {
 149     cubehash_ctx2hash(dest, 256, ctx);
 150 }
 151
 152 /******************************************************************************/
 153
 154 void cubehash384_init(cubehash_ctx_t *ctx)
 155 {
 156     cubehash_init(16, 32, 384, ctx);
 157 }
 158
 159 void cubehash384_ctx2hash(void *dest, cubehash_ctx_t *ctx)
 160 {
 161     cubehash_ctx2hash(dest, 384, ctx);
 162 }
 163
 164 /******************************************************************************/
 165
 166 void cubehash512_init(cubehash_ctx_t *ctx)
 167 {
 168     cubehash_init(16, 32, 512, ctx);
 169 }
 170
 171 void cubehash512_ctx2hash(void *dest, cubehash_ctx_t *ctx)
 172 {
 173     cubehash_ctx2hash(dest, 512, ctx);
 174 }