7 #include "twister-big.h"
13 #include <avr/pgmspace.h>
15 void print_checksum(twister_big_ctx_t* ctx, PGM_P s){
17 uart_putstr_P(PSTR("\r\n"));
19 uart_putstr_P(PSTR("\r\n checksum:\r\n"));
21 uart_putstr_P(PSTR(" [ "));
22 uart_hexdump(&(ctx->checksum[i][0]), 8);
23 uart_putstr_P(PSTR("]\r\n"));
27 void print_matrix(void* m, PGM_P s){
29 uart_putstr_P(PSTR("\r\n"));
31 uart_putstr_P(PSTR("\r\n matrix:\r\n"));
33 uart_putstr_P(PSTR(" [ "));
34 uart_hexdump(((uint8_t*)m)+i*8, 8);
35 uart_putstr_P(PSTR("]\r\n"));
39 #define DEBUG_CHKSUM(a,s) print_checksum((a),PSTR(s))
41 #define DEBUG_CHKSUM(a,s)
46 # define DEBUG_PRINT(ctx, msg) debug_print((ctx), PSTR(msg))
48 # define DEBUG_PRINT(ctx, msg)
53 void print_twister_state(twister_state_t* ctx){
55 uart_putstr_P(PSTR("\r\nState:\r\n matrix:\r\n"));
57 uart_putstr_P(PSTR("\t[ "));
58 uart_hexdump(&(ctx->s[i][0]), 8);
59 uart_putstr_P(PSTR("]\r\n"));
61 uart_putstr_P(PSTR("counter: "));
62 uart_hexdump(&(ctx->counter), 8);
64 uart_putstr_P(PSTR("\r\nlength_counter_b: "));
65 uart_hexdump(&(ctx->length_counter_b), 8);
66 uart_putstr_P(PSTR("\r\n"));
69 void debug_print(twister_state_t* ctx, PGM_P msg){
70 uart_putstr_P(PSTR("\r\n"));
72 print_twister_state(ctx);
77 void transp_matrix(void* dest, void* src){
81 ((uint8_t*)dest)[i*8+j] = ((uint8_t*)src)[j*8+i];
87 void checksum_update(twister_big_ctx_t* ctx, uint8_t col){
96 sum = (int) ctx->checksum[col2][7-i]
97 + (int) ctx->state.s[7-i][0] /* col or 0 ???*/
99 ctx->checksum[col][7-i] ^= (uint8_t)sum;
103 // DEBUG_CHKSUM(ctx, "post run");
106 void twister_big_init(twister_big_ctx_t* ctx, uint16_t hashsize_b){
107 memset(ctx->state.s, 0, 64);
108 memset(ctx->checksum, 0, 64);
109 ctx->state.counter=0xffffffffffffffffLL;
110 ctx->state.s[0][7] = hashsize_b>>8;
111 ctx->state.s[1][7] = hashsize_b&0xff;
112 ctx->state.length_counter_b = 0;
115 void twister_big_nextBlock(twister_big_ctx_t* ctx, void* msg){
119 memcpy(tmp, ctx->state.s, 64);
120 checksum_update(ctx, 0);
121 twister_mini_round(&(ctx->state), msg);
122 msg = (uint8_t*)msg + 8;
124 checksum_update(ctx, 1);
125 twister_mini_round(&(ctx->state), msg);
126 msg = (uint8_t*)msg + 8;
128 checksum_update(ctx, 2);
129 twister_mini_round(&(ctx->state), msg);
130 msg = (uint8_t*)msg + 8;
131 memxor(ctx->state.s, tmp, 64);
134 memcpy(tmp, ctx->state.s, 64);
135 checksum_update(ctx, 3);
136 twister_mini_round(&(ctx->state), msg);
137 msg = (uint8_t*)msg + 8;
139 twister_blank_round(&(ctx->state));
141 checksum_update(ctx, 4);
142 twister_mini_round(&(ctx->state), msg);
143 msg = (uint8_t*)msg + 8;
144 memxor(ctx->state.s, tmp, 64);
147 memcpy(tmp, ctx->state.s, 64);
148 checksum_update(ctx, 5);
149 twister_mini_round(&(ctx->state), msg);
150 msg = (uint8_t*)msg + 8;
152 checksum_update(ctx, 6);
153 twister_mini_round(&(ctx->state), msg);
154 msg = (uint8_t*)msg + 8;
156 checksum_update(ctx, 7);
157 twister_mini_round(&(ctx->state), msg);
159 twister_blank_round(&(ctx->state));
160 memxor(ctx->state.s, tmp, 64);
161 ctx->state.length_counter_b += 512;
164 void twister_inject_chksum(twister_big_ctx_t* ctx, uint8_t col){
165 *((uint64_t*)(&ctx->state.s[7][0])) ^= *((uint64_t*)(&ctx->checksum[col][0]));
166 twister_blank_round(&ctx->state);
169 void twister_big_lastBlock(twister_big_ctx_t* ctx, void* msg, uint16_t length_b){
172 twister_big_nextBlock(ctx, msg);
173 msg = ((uint8_t*)msg)+64;
177 memcpy(tmp, msg, (length_b+7)/8);
178 tmp[length_b/8] |= 0x80 >> (length_b&0x07);
179 twister_big_nextBlock(ctx, tmp);
180 ctx->state.length_counter_b -= 512 - length_b;
181 twister_mini_round(&(ctx->state), &(ctx->state.length_counter_b));
183 // DEBUG_PRINT(&(ctx->state), "pre check-round");
185 memcpy(tmp, ctx->state.s, 64);
186 twister_inject_chksum(ctx, 0);
187 twister_inject_chksum(ctx, 1);
188 twister_inject_chksum(ctx, 2);
189 memxor(ctx->state.s, tmp, 64);
191 memcpy(tmp, ctx->state.s, 64);
192 twister_inject_chksum(ctx, 3);
193 twister_inject_chksum(ctx, 4);
194 twister_inject_chksum(ctx, 5);
195 memxor(ctx->state.s, tmp, 64);
197 memcpy(tmp, ctx->state.s, 64);
198 twister_inject_chksum(ctx, 6);
199 twister_inject_chksum(ctx, 7);
200 twister_blank_round(&(ctx->state));
201 memxor(ctx->state.s, tmp, 64);
204 // DEBUG_PRINT(&(ctx->state), "post check-round");
207 void twister_big_ctx2hash(void* dest, twister_big_ctx_t* ctx, uint16_t hashsize_b){
208 twister_ctx2hash(dest, &(ctx->state), hashsize_b);
211 /******************************************************************************/
212 /******************************************************************************/
214 void twister384_init(twister384_ctx_t* ctx){
215 twister_big_init(ctx, 384);
218 void twister384_nextBlock(twister384_ctx_t* ctx, void* msg){
219 twister_big_nextBlock(ctx, msg);
222 void twister384_lastBlock(twister384_ctx_t* ctx, void* msg, uint16_t length_b){
223 twister_big_lastBlock(ctx, msg, length_b);
226 void twister384_ctx2hash(void* dest, twister384_ctx_t* ctx){
227 twister_big_ctx2hash(dest, ctx, 384);
230 void twister384(void* dest, void* msg, uint32_t msg_length_b){
231 twister_big_ctx_t ctx;
232 twister_big_init(&ctx, 384);
233 while(msg_length_b >=512){
234 twister_big_nextBlock(&ctx, msg);
235 msg = (uint8_t*)msg + 512/8;
238 twister_big_lastBlock(&ctx, msg, msg_length_b);
239 twister_big_ctx2hash(dest, &ctx, 384);
242 /******************************************************************************/
244 void twister512_init(twister512_ctx_t* ctx){
245 twister_big_init(ctx, 512);
248 void twister512_nextBlock(twister512_ctx_t* ctx, void* msg){
249 twister_big_nextBlock(ctx, msg);
252 void twister512_lastBlock(twister512_ctx_t* ctx, void* msg, uint16_t length_b){
253 twister_big_lastBlock(ctx, msg, length_b);
256 void twister512_ctx2hash(void* dest, twister512_ctx_t* ctx){
257 twister_big_ctx2hash(dest, ctx, 512);
260 void twister512(void* dest, void* msg, uint32_t msg_length_b){
261 twister_big_ctx_t ctx;
262 twister_big_init(&ctx, 512);
263 while(msg_length_b >=512){
264 twister_big_nextBlock(&ctx, msg);
265 msg = (uint8_t*)msg + 512/8;
268 twister_big_lastBlock(&ctx, msg, msg_length_b);
269 twister_big_ctx2hash(dest, &ctx, 512);