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