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