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 /*********************************************************************/
  10
  11 static
  12 void checksum_update(twister_big_ctx_t* ctx, uint8_t col){
  13         uint8_t i, col2;
  14         uint8_t carry = 0;
  15         int sum = 0;
  16
  17         col2 = (col+1)%8;
  18
  19         for( i=0; i<8; i++ )
  20         {
  21                 sum =  (int) ctx->checksum[col2][7-i]
  22                      + (int) ctx->state.s[7-i][0] /* col or 0 ???*/
  23                      + carry;
  24                 ctx->checksum[col][7-i] ^= (uint8_t)sum;
  25                 carry = sum>>8;
  26
  27         }
  28 }
  29
  30 /*********************************************************************/
  31
  32 void twister_big_init(twister_big_ctx_t* ctx, uint16_t hashsize_b){
  33         memset(ctx->state.s,  0, 64);
  34         memset(ctx->checksum, 0, 64);
  35         ctx->state.counter=0xffffffffffffffffLL;
  36         ctx->state.s[0][7] = hashsize_b>>8;
  37         ctx->state.s[1][7] = hashsize_b&0xff;
  38         ctx->state.length_counter_b = 0;
  39 }
  40
  41 /*********************************************************************/
  42
  43 void twister_big_nextBlock(twister_big_ctx_t* ctx, void* msg){
  44         uint8_t tmp[8][8];
  45
  46         /* 1st maxi round */
  47         memcpy(tmp, ctx->state.s, 64);
  48         checksum_update(ctx, 0);
  49         twister_mini_round(&(ctx->state), msg);
  50         msg = (uint8_t*)msg + 8;
  51
  52         checksum_update(ctx, 1);
  53         twister_mini_round(&(ctx->state), msg);
  54         msg = (uint8_t*)msg + 8;
  55
  56         checksum_update(ctx, 2);
  57         twister_mini_round(&(ctx->state), msg);
  58         msg = (uint8_t*)msg + 8;
  59         memxor(ctx->state.s, tmp, 64);
  60
  61         /* 2nd maxi round */
  62         memcpy(tmp, ctx->state.s, 64);
  63         checksum_update(ctx, 3);
  64         twister_mini_round(&(ctx->state), msg);
  65         msg = (uint8_t*)msg + 8;
  66
  67         twister_blank_round(&(ctx->state));
  68
  69         checksum_update(ctx, 4);
  70         twister_mini_round(&(ctx->state), msg);
  71         msg = (uint8_t*)msg + 8;
  72         memxor(ctx->state.s, tmp, 64);
  73
  74         /* 3rd maxi round */
  75         memcpy(tmp, ctx->state.s, 64);
  76         checksum_update(ctx, 5);
  77         twister_mini_round(&(ctx->state), msg);
  78         msg = (uint8_t*)msg + 8;
  79
  80         checksum_update(ctx, 6);
  81         twister_mini_round(&(ctx->state), msg);
  82         msg = (uint8_t*)msg + 8;
  83
  84         checksum_update(ctx, 7);
  85         twister_mini_round(&(ctx->state), msg);
  86
  87         twister_blank_round(&(ctx->state));
  88         memxor(ctx->state.s, tmp, 64);
  89         ctx->state.length_counter_b += 512;
  90 }
  91
  92 /*********************************************************************/
  93
  94 void twister_inject_chksum(twister_big_ctx_t* ctx, uint8_t col){
  95         *((uint64_t*)(&ctx->state.s[7][0])) ^= *((uint64_t*)(&ctx->checksum[col][0]));
  96         twister_blank_round(&ctx->state);
  97 }
  98
  99 /*********************************************************************/
 100
 101 void twister_big_lastBlock(twister_big_ctx_t* ctx, void* msg, uint16_t length_b){
 102         uint8_t tmp[64];
 103         while(length_b>512){
 104                 twister_big_nextBlock(ctx, msg);
 105                 msg = ((uint8_t*)msg)+64;
 106                 length_b -= 512;
 107         }
 108         memset(tmp, 0, 64);
 109         memcpy(tmp, msg, (length_b+7)/8);
 110         tmp[length_b/8] |= 0x80 >> (length_b&0x07);
 111         twister_big_nextBlock(ctx, tmp);
 112         ctx->state.length_counter_b -= 512 - length_b;
 113         twister_mini_round(&(ctx->state), &(ctx->state.length_counter_b));
 114
 115         memcpy(tmp, ctx->state.s, 64);
 116         twister_inject_chksum(ctx, 0);
 117         twister_inject_chksum(ctx, 1);
 118         twister_inject_chksum(ctx, 2);
 119         memxor(ctx->state.s, tmp, 64);
 120
 121         memcpy(tmp, ctx->state.s, 64);
 122         twister_inject_chksum(ctx, 3);
 123         twister_inject_chksum(ctx, 4);
 124         twister_inject_chksum(ctx, 5);
 125         memxor(ctx->state.s, tmp, 64);
 126
 127         memcpy(tmp, ctx->state.s, 64);
 128         twister_inject_chksum(ctx, 6);
 129         twister_inject_chksum(ctx, 7);
 130         twister_blank_round(&(ctx->state));
 131         memxor(ctx->state.s, tmp, 64);
 132
 133 }
 134
 135 /*********************************************************************/
 136
 137 void twister_big_ctx2hash(void* dest, twister_big_ctx_t* ctx, uint16_t hashsize_b){
 138         twister_ctx2hash(dest, &(ctx->state), hashsize_b);
 139 }
 140
 141 /*********************************************************************/
 142 /*********************************************************************/
 143
 144 void twister384_init(twister384_ctx_t* ctx){
 145         twister_big_init(ctx, 384);
 146 }
 147
 148 /*********************************************************************/
 149
 150 void twister384_nextBlock(twister384_ctx_t* ctx, void* msg){
 151         twister_big_nextBlock(ctx, msg);
 152 }
 153
 154 /*********************************************************************/
 155
 156 void twister384_lastBlock(twister384_ctx_t* ctx, void* msg, uint16_t length_b){
 157         twister_big_lastBlock(ctx, msg, length_b);
 158 }
 159
 160 /*********************************************************************/
 161
 162 void twister384_ctx2hash(void* dest, twister384_ctx_t* ctx){
 163         twister_big_ctx2hash(dest, ctx, 384);
 164 }
 165
 166 /*********************************************************************/
 167
 168 void twister384(void* dest, void* msg, uint32_t msg_length_b){
 169         twister_big_ctx_t ctx;
 170         twister_big_init(&ctx, 384);
 171         while(msg_length_b >=512){
 172                 twister_big_nextBlock(&ctx, msg);
 173                 msg = (uint8_t*)msg + 512/8;
 174                 msg_length_b -= 512;
 175         }
 176         twister_big_lastBlock(&ctx, msg, msg_length_b);
 177         twister_big_ctx2hash(dest, &ctx, 384);
 178 }
 179
 180 /*********************************************************************/
 181 /*********************************************************************/
 182
 183
 184 void twister512_init(twister512_ctx_t* ctx){
 185         twister_big_init(ctx, 512);
 186 }
 187
 188 /*********************************************************************/
 189
 190 void twister512_nextBlock(twister512_ctx_t* ctx, void* msg){
 191         twister_big_nextBlock(ctx, msg);
 192 }
 193
 194 /*********************************************************************/
 195
 196 void twister512_lastBlock(twister512_ctx_t* ctx, void* msg, uint16_t length_b){
 197         twister_big_lastBlock(ctx, msg, length_b);
 198 }
 199
 200 /*********************************************************************/
 201
 202 void twister512_ctx2hash(void* dest, twister512_ctx_t* ctx){
 203         twister_big_ctx2hash(dest, ctx, 512);
 204 }
 205
 206 /*********************************************************************/
 207
 208 void twister512(void* dest, void* msg, uint32_t msg_length_b){
 209         twister_big_ctx_t ctx;
 210         twister_big_init(&ctx, 512);
 211         while(msg_length_b >=512){
 212                 twister_big_nextBlock(&ctx, msg);
 213                 msg = (uint8_t*)msg + 512/8;
 214                 msg_length_b -= 512;
 215         }
 216         twister_big_lastBlock(&ctx, msg, msg_length_b);
 217         twister_big_ctx2hash(dest, &ctx, 512);
 218 }
 219
 220
 221