twister/twister-small-stub.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 #if 0
  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 #endif
  52 /*********************************************************************/
  53 #if 0
  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 void twister256_lastBlock(twister256_ctx_t *ctx, void *msg, uint16_t length_b){
  72         twister_small_lastBlock(ctx, msg, length_b);
  73 }
  74
  75
  76 void twister224_lastBlock(twister224_ctx_t *ctx, void *msg, uint16_t length_b){
  77         twister_small_lastBlock(ctx, msg, length_b);
  78 }
  79
  80 #endif
  81 #if 0
  82 /*********************************************************************/
  83
  84 void twister_small_ctx2hash(void *dest, twister_state_t *ctx, uint16_t hashsize_b){
  85         twister_ctx2hash(dest, ctx, hashsize_b);
  86 }
  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 /*********************************************************************/
  98
  99 void twister256_nextBlock(twister256_ctx_t *ctx, void *msg){
 100         twister_small_nextBlock(ctx, msg);
 101 }
 102
 103 /*********************************************************************/
 104
 105 /*********************************************************************/
 106
 107 void twister256_ctx2hash(void *dest, twister256_ctx_t *ctx){
 108         twister_ctx2hash(dest, ctx, 256);
 109 }
 110
 111 /*********************************************************************/
 112
 113 void twister256(void *dest, void *msg, uint32_t msg_length_b){
 114         twister_state_t ctx;
 115         twister_small_init(&ctx, 256);
 116         while(msg_length_b >=512){
 117                 twister_small_nextBlock(&ctx, msg);
 118                 msg = (uint8_t*)msg + 512/8;
 119                 msg_length_b -= 512;
 120         }
 121         twister_small_lastBlock(&ctx, msg, msg_length_b);
 122         twister_ctx2hash(dest, &ctx, 256);
 123 }
 124
 125 /*********************************************************************/
 126
 127 #endif
 128
 129 /*********************************************************************/
 130 /*********************************************************************/
 131
 132 #ifndef NO_TWISTER_224
 133
 134 void twister224_init(twister224_ctx_t *ctx){
 135         twister_small_init(ctx, 224);
 136 }
 137
 138 /*********************************************************************/
 139
 140 void twister224_nextBlock(twister224_ctx_t *ctx, void *msg){
 141         twister_small_nextBlock(ctx, msg);
 142 }
 143
 144 /*********************************************************************/
 145
 146 /*********************************************************************/
 147
 148 void twister224_ctx2hash(void *dest, twister224_ctx_t *ctx){
 149         twister_ctx2hash(dest, ctx, 224);
 150 }
 151
 152 /*********************************************************************/
 153
 154 void twister224(void *dest, void *msg, uint32_t msg_length_b){
 155         twister_state_t ctx;
 156         twister_small_init(&ctx, 224);
 157         while(msg_length_b >=512){
 158                 twister_small_nextBlock(&ctx, msg);
 159                 msg = (uint8_t*)msg + 512/8;
 160                 msg_length_b -= 512;
 161         }
 162         twister_small_lastBlock(&ctx, msg, msg_length_b);
 163         twister_ctx2hash(dest, &ctx, 224);
 164 }
 165
 166 #endif
 167 #endif