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         while(length_b>512){
  57                 twister_small_nextBlock(ctx, msg);
  58                 msg = ((uint8_t*)msg)+64;
  59                 length_b -= 512;
  60         }
  61         memset(tmp, 0, 64);
  62         memcpy(tmp, msg, (length_b+7)/8);
  63         tmp[length_b/8] |= 0x80 >> (length_b&0x07);
  64         twister_small_nextBlock(ctx, tmp);
  65         ctx->length_counter_b -= 512 - length_b;
  66         twister_mini_round(ctx, &(ctx->length_counter_b));
  67         twister_blank_round(ctx);
  68 }
  69
  70 /*********************************************************************/
  71
  72 void twister_small_ctx2hash(void* dest, twister_state_t* ctx, uint16_t hashsize_b){
  73         twister_ctx2hash(dest, ctx, hashsize_b);
  74 }
  75
  76 /*********************************************************************/
  77 /*********************************************************************/
  78
  79 #ifndef NO_TWISTER_256
  80
  81 void twister256_init(twister256_ctx_t* ctx){
  82         twister_small_init(ctx, 256);
  83 }
  84
  85 /*********************************************************************/
  86
  87 void twister256_nextBlock(twister256_ctx_t* ctx, void* msg){
  88         twister_small_nextBlock(ctx, msg);
  89 }
  90
  91 /*********************************************************************/
  92
  93 void twister256_lastBlock(twister256_ctx_t* ctx, void* msg, uint16_t length_b){
  94         twister_small_lastBlock(ctx, msg, length_b);
  95 }
  96
  97 /*********************************************************************/
  98
  99 void twister256_ctx2hash(void* dest, twister256_ctx_t* ctx){
 100         twister_ctx2hash(dest, ctx, 256);
 101 }
 102
 103 /*********************************************************************/
 104
 105 void twister256(void* dest, void* msg, uint32_t msg_length_b){
 106         twister_state_t ctx;
 107         twister_small_init(&ctx, 256);
 108         while(msg_length_b >=512){
 109                 twister_small_nextBlock(&ctx, msg);
 110                 msg = (uint8_t*)msg + 512/8;
 111                 msg_length_b -= 512;
 112         }
 113         twister_small_lastBlock(&ctx, msg, msg_length_b);
 114         twister_ctx2hash(dest, &ctx, 256);
 115 }
 116
 117 /*********************************************************************/
 118
 119 #endif
 120
 121 /*********************************************************************/
 122 /*********************************************************************/
 123
 124 #ifndef NO_TWISTER_224
 125
 126 void twister224_init(twister224_ctx_t* ctx){
 127         twister_small_init(ctx, 224);
 128 }
 129
 130 /*********************************************************************/
 131
 132 void twister224_nextBlock(twister224_ctx_t* ctx, void* msg){
 133         twister_small_nextBlock(ctx, msg);
 134 }
 135
 136 /*********************************************************************/
 137
 138 void twister224_lastBlock(twister224_ctx_t* ctx, void* msg, uint16_t length_b){
 139         twister_small_lastBlock(ctx, msg, length_b);
 140 }
 141
 142 /*********************************************************************/
 143
 144 void twister224_ctx2hash(void* dest, twister224_ctx_t* ctx){
 145         twister_ctx2hash(dest, ctx, 224);
 146 }
 147
 148 /*********************************************************************/
 149
 150 void twister224(void* dest, void* msg, uint32_t msg_length_b){
 151         twister_state_t ctx;
 152         twister_small_init(&ctx, 224);
 153         while(msg_length_b >=512){
 154                 twister_small_nextBlock(&ctx, msg);
 155                 msg = (uint8_t*)msg + 512/8;
 156                 msg_length_b -= 512;
 157         }
 158         twister_small_lastBlock(&ctx, msg, msg_length_b);
 159         twister_ctx2hash(dest, &ctx, 224);
 160 }
 161
 162 #endif
 163