7 #include "twister-big.h"
9 /*********************************************************************/
12 void checksum_update(twister_big_ctx_t* ctx, uint8_t col){
21 sum = (int) ctx->checksum[col2][7-i]
22 + (int) ctx->state.s[7-i][0] /* col or 0 ???*/
24 ctx->checksum[col][7-i] ^= (uint8_t)sum;
30 /*********************************************************************/
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;
41 /*********************************************************************/
43 void twister_big_nextBlock(twister_big_ctx_t* ctx, void* msg){
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;
52 checksum_update(ctx, 1);
53 twister_mini_round(&(ctx->state), msg);
54 msg = (uint8_t*)msg + 8;
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);
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;
67 twister_blank_round(&(ctx->state));
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);
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;
80 checksum_update(ctx, 6);
81 twister_mini_round(&(ctx->state), msg);
82 msg = (uint8_t*)msg + 8;
84 checksum_update(ctx, 7);
85 twister_mini_round(&(ctx->state), msg);
87 twister_blank_round(&(ctx->state));
88 memxor(ctx->state.s, tmp, 64);
89 ctx->state.length_counter_b += 512;
92 /*********************************************************************/
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);
99 /*********************************************************************/
101 void twister_big_lastBlock(twister_big_ctx_t* ctx, void* msg, uint16_t length_b){
104 twister_big_nextBlock(ctx, msg);
105 msg = ((uint8_t*)msg)+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));
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);
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);
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);
135 /*********************************************************************/
137 void twister_big_ctx2hash(void* dest, twister_big_ctx_t* ctx, uint16_t hashsize_b){
138 twister_ctx2hash(dest, &(ctx->state), hashsize_b);
141 /*********************************************************************/
142 /*********************************************************************/
144 void twister384_init(twister384_ctx_t* ctx){
145 twister_big_init(ctx, 384);
148 /*********************************************************************/
150 void twister384_nextBlock(twister384_ctx_t* ctx, void* msg){
151 twister_big_nextBlock(ctx, msg);
154 /*********************************************************************/
156 void twister384_lastBlock(twister384_ctx_t* ctx, void* msg, uint16_t length_b){
157 twister_big_lastBlock(ctx, msg, length_b);
160 /*********************************************************************/
162 void twister384_ctx2hash(void* dest, twister384_ctx_t* ctx){
163 twister_big_ctx2hash(dest, ctx, 384);
166 /*********************************************************************/
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;
176 twister_big_lastBlock(&ctx, msg, msg_length_b);
177 twister_big_ctx2hash(dest, &ctx, 384);
180 /*********************************************************************/
181 /*********************************************************************/
184 void twister512_init(twister512_ctx_t* ctx){
185 twister_big_init(ctx, 512);
188 /*********************************************************************/
190 void twister512_nextBlock(twister512_ctx_t* ctx, void* msg){
191 twister_big_nextBlock(ctx, msg);
194 /*********************************************************************/
196 void twister512_lastBlock(twister512_ctx_t* ctx, void* msg, uint16_t length_b){
197 twister_big_lastBlock(ctx, msg, length_b);
200 /*********************************************************************/
202 void twister512_ctx2hash(void* dest, twister512_ctx_t* ctx){
203 twister_big_ctx2hash(dest, ctx, 512);
206 /*********************************************************************/
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;
216 twister_big_lastBlock(&ctx, msg, msg_length_b);
217 twister_big_ctx2hash(dest, &ctx, 512);