twister-small.c

   1 /* twister-small.c */
   2
   3 #include <stdint.h>
   4 #include <string.h>
   5 #include "memxor.h"
   6 #include "twister-small.h"
   7
   8 static
   9 void maxi_round3(twister_state_t* ctx, void* msg, uint8_t last_null){
  10         mini_round(ctx, msg);
  11         msg = ((uint8_t*)msg) + 8;
  12         mini_round(ctx, msg);
  13         if(last_null){
  14                 blank_round(ctx);
  15         } else {
  16                 msg = ((uint8_t*)msg) + 8;
  17                 mini_round(ctx, msg);
  18         }
  19 }
  20
  21 void twister_small_nextBlock(twister_state_t* ctx, void* msg){
  22         uint8_t tmp[8][8];
  23         /* round 1 */
  24         memcpy(tmp, ctx->s, 64);
  25         maxi_round3(ctx, msg, 0);
  26         memxor(ctx->s, tmp, 64);
  27         msg = ((uint8_t*)msg) + 3*8;
  28         /* round 2 */
  29         memcpy(tmp, ctx->s, 64);
  30         maxi_round3(ctx, msg, 0);
  31         memxor(ctx->s, tmp, 64);
  32         msg = ((uint8_t*)msg) + 3*8;
  33         /* round 3 */
  34         memcpy(tmp, ctx->s, 64);
  35         maxi_round3(ctx, msg, 1);
  36         memxor(ctx->s, tmp, 64);
  37         ctx->length_counter_b += 512;
  38 }
  39
  40 void twister_small_init(twister_state_t* ctx, uint16_t hashsize_b){
  41         memset(ctx->s, 0, 64);
  42         ctx->counter=0xffffffffffffffffLL;
  43         ctx->s[0][7] = hashsize_b>>8;
  44         ctx->s[1][7] = hashsize_b&0xff;
  45         ctx->length_counter_b = 0;
  46 }
  47
  48 void twister_small_lastBlock(twister_state_t* ctx, void* msg, uint16_t length_b){
  49         uint8_t tmp[64];
  50         while(length_b>512){
  51                 twister_small_nextBlock(ctx, msg);
  52                 msg = ((uint8_t*)msg)+64;
  53                 length_b -= 512;
  54         }
  55         memset(tmp, 0, 64);
  56         memcpy(tmp, msg, (length_b+7)/8);
  57         tmp[length_b/8] |= 0x80 >> (length_b&0x07);
  58         twister_small_nextBlock(ctx, tmp);
  59         ctx->length_counter_b -= 512 - length_b;
  60         mini_round(ctx, &(ctx->length_counter_b));
  61         blank_round(ctx);
  62 }
  63
  64 void twister_small_ctx2hash(void* dest, twister_state_t* ctx, uint16_t hashsize_b){
  65         uint8_t tmp[8][8];
  66         uint8_t j;
  67         uint16_t i=hashsize_b;
  68         while(i>=64){
  69                 i-=64;
  70                 memcpy(tmp,ctx->s, 64);
  71                 blank_round(ctx);
  72                 memxor(ctx->s, tmp, 64);
  73                 blank_round(ctx);
  74                 for(j=0; j<8; ++j){
  75                         *((uint8_t*)dest) = ctx->s[7-j][0] ^ tmp[7-j][0];
  76                         dest = (uint8_t*)dest + 1;
  77                 }
  78         }
  79         if(i>=32){
  80                 memcpy(tmp,ctx->s, 64);
  81                 blank_round(ctx);
  82                 memxor(ctx->s, tmp, 64);
  83                 blank_round(ctx);
  84                 for(j=0; j<4; ++j){
  85                         *((uint8_t*)dest) = ctx->s[3-j][0] ^ tmp[3-j][0];
  86                         dest = (uint8_t*)dest + 1;
  87                 }
  88         }
  89 }
  90
  91 #ifndef NO_TWISTER_256
  92
  93 void twister256_init(twister256_ctx_t* ctx){
  94         twister_small_init(ctx, 256);
  95 }
  96
  97 void twister256_nextBlock(twister256_ctx_t* ctx, void* msg){
  98         twister_small_nextBlock(ctx, msg);
  99 }
 100
 101 void twister256_lastBlock(twister256_ctx_t* ctx, void* msg, uint16_t length_b){
 102         twister_small_lastBlock(ctx, msg, length_b);
 103 }
 104
 105 void twister256_ctx2hash(void* dest, twister256_ctx_t* ctx){
 106         twister_small_ctx2hash(dest, ctx, 256);
 107 }
 108
 109 void twister256(void* dest, void* msg, uint32_t msg_length_b){
 110         twister_state_t ctx;
 111         twister_small_init(&ctx, 256);
 112         while(msg_length_b >=512){
 113                 twister_small_nextBlock(&ctx, msg);
 114                 msg = (uint8_t*)msg + 512/8;
 115                 msg_length_b -= 512;
 116         }
 117         twister_small_lastBlock(&ctx, msg, msg_length_b);
 118         twister_small_ctx2hash(dest, &ctx, 256);
 119 }
 120
 121 #endif
 122
 123 #ifndef NO_TWISTER_224
 124
 125 void twister224_init(twister224_ctx_t* ctx){
 126         twister_small_init(ctx, 224);
 127 }
 128
 129 void twister224_nextBlock(twister224_ctx_t* ctx, void* msg){
 130         twister_small_nextBlock(ctx, msg);
 131 }
 132
 133 void twister224_lastBlock(twister224_ctx_t* ctx, void* msg, uint16_t length_b){
 134         twister_small_lastBlock(ctx, msg, length_b);
 135 }
 136
 137 void twister224_ctx2hash(void* dest, twister224_ctx_t* ctx){
 138         twister_small_ctx2hash(dest, ctx, 224);
 139 }
 140
 141 void twister224(void* dest, void* msg, uint32_t msg_length_b){
 142         twister_state_t ctx;
 143         twister_small_init(&ctx, 224);
 144         while(msg_length_b >=512){
 145                 twister_small_nextBlock(&ctx, msg);
 146                 msg = (uint8_t*)msg + 512/8;
 147                 msg_length_b -= 512;
 148         }
 149         twister_small_lastBlock(&ctx, msg, msg_length_b);
 150         twister_small_ctx2hash(dest, &ctx, 224);
 151 }
 152
 153 #endif
 154