twister-big.c

   1 /* twister-big.c */
   2
   3 #include <stdint.h>
   4 #include <string.h>
   5 #include "memxor.h"
   6 #include "twister.h"
   7 #include "twister-big.h"
   8
   9 #undef DEBUG
  10 #define DEBUG
  11
  12 #ifdef DEBUG
  13 #include <avr/pgmspace.h>
  14 #include "uart.h"
  15 void print_checksum(twister_big_ctx_t* ctx, PGM_P s){
  16         uint8_t i;
  17         uart_putstr_P(PSTR("\r\n"));
  18         uart_putstr_P(s);
  19         uart_putstr_P(PSTR("\r\n checksum:\r\n"));
  20         for(i=0; i<8; ++i){
  21                 uart_putstr_P(PSTR("  [ "));
  22                 uart_hexdump(&(ctx->checksum[i][0]), 8);
  23                 uart_putstr_P(PSTR("]\r\n"));
  24         }
  25 }
  26
  27 void print_matrix(void* m, PGM_P s){
  28         uint8_t i;
  29         uart_putstr_P(PSTR("\r\n"));
  30         uart_putstr_P(s);
  31         uart_putstr_P(PSTR("\r\n matrix:\r\n"));
  32         for(i=0; i<8; ++i){
  33                 uart_putstr_P(PSTR("  [ "));
  34                 uart_hexdump(((uint8_t*)m)+i*8, 8);
  35                 uart_putstr_P(PSTR("]\r\n"));
  36         }
  37 }
  38
  39 #define DEBUG_CHKSUM(a,s) print_checksum((a),PSTR(s))
  40 #else
  41 #define DEBUG_CHKSUM(a,s)
  42 #endif
  43
  44
  45 #ifdef DEBUG
  46 # define DEBUG_PRINT(ctx, msg) debug_print((ctx), PSTR(msg))
  47 #else
  48 # define DEBUG_PRINT(ctx, msg)
  49 #endif
  50
  51 #ifdef DEBUG
  52
  53 void print_twister_state(twister_state_t* ctx){
  54         uint8_t i;
  55         uart_putstr_P(PSTR("\r\nState:\r\n matrix:\r\n"));
  56         for(i=0; i<8; ++i){
  57                 uart_putstr_P(PSTR("\t[ "));
  58                 uart_hexdump(&(ctx->s[i][0]), 8);
  59                 uart_putstr_P(PSTR("]\r\n"));
  60         }
  61         uart_putstr_P(PSTR("counter: "));
  62         uart_hexdump(&(ctx->counter), 8);
  63
  64         uart_putstr_P(PSTR("\r\nlength_counter_b: "));
  65         uart_hexdump(&(ctx->length_counter_b), 8);
  66         uart_putstr_P(PSTR("\r\n"));
  67 }
  68
  69 void debug_print(twister_state_t* ctx, PGM_P msg){
  70         uart_putstr_P(PSTR("\r\n"));
  71         uart_putstr_P(msg);
  72         print_twister_state(ctx);
  73 }
  74
  75 #endif
  76
  77 void transp_matrix(void* dest, void* src){
  78         uint8_t i,j;
  79         for(i=0; i<8; i++){
  80                 for(j=0; j<8; ++j){
  81                         ((uint8_t*)dest)[i*8+j] = ((uint8_t*)src)[j*8+i];
  82                 }
  83         }
  84 }
  85
  86 static
  87 void checksum_update(twister_big_ctx_t* ctx, uint8_t col){
  88         uint8_t i, col2;
  89         uint8_t carry = 0;
  90         int sum = 0;
  91
  92         col2 = (col+1)%8;
  93
  94         for( i=0; i<8; i++ )
  95         {
  96                 sum =  (int) ctx->checksum[col2][7-i]
  97                      + (int) ctx->state.s[7-i][0] /* col or 0 ???*/
  98                      + carry;
  99                 ctx->checksum[col][7-i] ^= (uint8_t)sum;
 100                 carry = sum>>8;
 101
 102         }
 103 //      DEBUG_CHKSUM(ctx, "post run");
 104 }
 105
 106 void twister_big_init(twister_big_ctx_t* ctx, uint16_t hashsize_b){
 107         memset(ctx->state.s,  0, 64);
 108         memset(ctx->checksum, 0, 64);
 109         ctx->state.counter=0xffffffffffffffffLL;
 110         ctx->state.s[0][7] = hashsize_b>>8;
 111         ctx->state.s[1][7] = hashsize_b&0xff;
 112         ctx->state.length_counter_b = 0;
 113 }
 114
 115 void twister_big_nextBlock(twister_big_ctx_t* ctx, void* msg){
 116         uint8_t tmp[8][8];
 117
 118         /* 1st maxi round */
 119         memcpy(tmp, ctx->state.s, 64);
 120         checksum_update(ctx, 0);
 121         twister_mini_round(&(ctx->state), msg);
 122         msg = (uint8_t*)msg + 8;
 123
 124         checksum_update(ctx, 1);
 125         twister_mini_round(&(ctx->state), msg);
 126         msg = (uint8_t*)msg + 8;
 127
 128         checksum_update(ctx, 2);
 129         twister_mini_round(&(ctx->state), msg);
 130         msg = (uint8_t*)msg + 8;
 131         memxor(ctx->state.s, tmp, 64);
 132
 133         /* 2nd maxi round */
 134         memcpy(tmp, ctx->state.s, 64);
 135         checksum_update(ctx, 3);
 136         twister_mini_round(&(ctx->state), msg);
 137         msg = (uint8_t*)msg + 8;
 138
 139         twister_blank_round(&(ctx->state));
 140
 141         checksum_update(ctx, 4);
 142         twister_mini_round(&(ctx->state), msg);
 143         msg = (uint8_t*)msg + 8;
 144         memxor(ctx->state.s, tmp, 64);
 145
 146         /* 3rd maxi round */
 147         memcpy(tmp, ctx->state.s, 64);
 148         checksum_update(ctx, 5);
 149         twister_mini_round(&(ctx->state), msg);
 150         msg = (uint8_t*)msg + 8;
 151
 152         checksum_update(ctx, 6);
 153         twister_mini_round(&(ctx->state), msg);
 154         msg = (uint8_t*)msg + 8;
 155
 156         checksum_update(ctx, 7);
 157         twister_mini_round(&(ctx->state), msg);
 158
 159         twister_blank_round(&(ctx->state));
 160         memxor(ctx->state.s, tmp, 64);
 161         ctx->state.length_counter_b += 512;
 162 }
 163
 164 void twister_inject_chksum(twister_big_ctx_t* ctx, uint8_t col){
 165         *((uint64_t*)(&ctx->state.s[7][0])) ^= *((uint64_t*)(&ctx->checksum[col][0]));
 166         twister_blank_round(&ctx->state);
 167 }
 168
 169 void twister_big_lastBlock(twister_big_ctx_t* ctx, void* msg, uint16_t length_b){
 170         uint8_t tmp[64];
 171         while(length_b>512){
 172                 twister_big_nextBlock(ctx, msg);
 173                 msg = ((uint8_t*)msg)+64;
 174                 length_b -= 512;
 175         }
 176         memset(tmp, 0, 64);
 177         memcpy(tmp, msg, (length_b+7)/8);
 178         tmp[length_b/8] |= 0x80 >> (length_b&0x07);
 179         twister_big_nextBlock(ctx, tmp);
 180         ctx->state.length_counter_b -= 512 - length_b;
 181         twister_mini_round(&(ctx->state), &(ctx->state.length_counter_b));
 182
 183 //      DEBUG_PRINT(&(ctx->state), "pre check-round");
 184
 185         memcpy(tmp, ctx->state.s, 64);
 186         twister_inject_chksum(ctx, 0);
 187         twister_inject_chksum(ctx, 1);
 188         twister_inject_chksum(ctx, 2);
 189         memxor(ctx->state.s, tmp, 64);
 190
 191         memcpy(tmp, ctx->state.s, 64);
 192         twister_inject_chksum(ctx, 3);
 193         twister_inject_chksum(ctx, 4);
 194         twister_inject_chksum(ctx, 5);
 195         memxor(ctx->state.s, tmp, 64);
 196
 197         memcpy(tmp, ctx->state.s, 64);
 198         twister_inject_chksum(ctx, 6);
 199         twister_inject_chksum(ctx, 7);
 200         twister_blank_round(&(ctx->state));
 201         memxor(ctx->state.s, tmp, 64);
 202
 203
 204 //      DEBUG_PRINT(&(ctx->state), "post check-round");
 205 }
 206
 207 void twister_big_ctx2hash(void* dest, twister_big_ctx_t* ctx, uint16_t hashsize_b){
 208         twister_ctx2hash(dest, &(ctx->state), hashsize_b);
 209 }
 210
 211 /******************************************************************************/
 212 /******************************************************************************/
 213
 214 void twister384_init(twister384_ctx_t* ctx){
 215         twister_big_init(ctx, 384);
 216 }
 217
 218 void twister384_nextBlock(twister384_ctx_t* ctx, void* msg){
 219         twister_big_nextBlock(ctx, msg);
 220 }
 221
 222 void twister384_lastBlock(twister384_ctx_t* ctx, void* msg, uint16_t length_b){
 223         twister_big_lastBlock(ctx, msg, length_b);
 224 }
 225
 226 void twister384_ctx2hash(void* dest, twister384_ctx_t* ctx){
 227         twister_big_ctx2hash(dest, ctx, 384);
 228 }
 229
 230 void twister384(void* dest, void* msg, uint32_t msg_length_b){
 231         twister_big_ctx_t ctx;
 232         twister_big_init(&ctx, 384);
 233         while(msg_length_b >=512){
 234                 twister_big_nextBlock(&ctx, msg);
 235                 msg = (uint8_t*)msg + 512/8;
 236                 msg_length_b -= 512;
 237         }
 238         twister_big_lastBlock(&ctx, msg, msg_length_b);
 239         twister_big_ctx2hash(dest, &ctx, 384);
 240 }
 241
 242 /******************************************************************************/
 243
 244 void twister512_init(twister512_ctx_t* ctx){
 245         twister_big_init(ctx, 512);
 246 }
 247
 248 void twister512_nextBlock(twister512_ctx_t* ctx, void* msg){
 249         twister_big_nextBlock(ctx, msg);
 250 }
 251
 252 void twister512_lastBlock(twister512_ctx_t* ctx, void* msg, uint16_t length_b){
 253         twister_big_lastBlock(ctx, msg, length_b);
 254 }
 255
 256 void twister512_ctx2hash(void* dest, twister512_ctx_t* ctx){
 257         twister_big_ctx2hash(dest, ctx, 512);
 258 }
 259
 260 void twister512(void* dest, void* msg, uint32_t msg_length_b){
 261         twister_big_ctx_t ctx;
 262         twister_big_init(&ctx, 512);
 263         while(msg_length_b >=512){
 264                 twister_big_nextBlock(&ctx, msg);
 265                 msg = (uint8_t*)msg + 512/8;
 266                 msg_length_b -= 512;
 267         }
 268         twister_big_lastBlock(&ctx, msg, msg_length_b);
 269         twister_big_ctx2hash(dest, &ctx, 512);
 270 }
 271
 272
 273