]> git.cryptolib.org Git - avr-crypto-lib.git/blob - mickey128/mickey128.c
syncing with bzr
[avr-crypto-lib.git] / mickey128 / mickey128.c
1 /**
2  * 
3  * author: Daniel Otte
4  * email:  daniel.otte@rub.de
5  * license: GPLv3
6  * 
7  * */
8
9 #include <stdint.h>
10 #include <string.h>
11 #include <avr/pgmspace.h>
12 #include "mickey128.h"
13 #include "cli.h"
14 /*
15 RTAPS = { 0,4,5,  8,10,11,14  ,16,20,  25,30,  32,35,36,38,
16          42,43,46,  50,51,53,54,55,  56,57,60,61,62,63,  
17          65,66,69,  73,74,76,79,  80,81,82,85,86,  90,91,92,95,  
18          97,100,101,  105,106,107,108,109,111,  112,113,115,116,117,
19          127,  128,129,130,131,133,135,  136,137,140,142,  145,148,150,  
20          152,153,154,156,157 }
21          
22          0011.0001  0100.1101  0001.0001  0100.0010  0101.1001
23          0100.1100  1110.1100  1111.0011 
24          0010.0110  1001.0110  0110.0111  1001.1100 
25          0011.0010  1011.1110  0011.1011
26          1000.0000  1010.1111  0101.0011  0101.0010
27          0011.0111
28           
29          1000110010110010100010000100001010011010001100100011011111001111011001
30          0001101001111001100011100101001100011111011101110000000001111101011100
31          101001001010111011
32           
33          1000.1100 1011.0010 1000.1000 0100.0010 1001.1010 0011.0010 
34          0011.0111 1100.1111 0110.0100 0110.1001 1110.0110 0011.1001
35          0100.1100 0111.1101 1101.1100 0000.0001 1111.0101 1100.1010
36          0100.1010 1110.11
37 */
38
39 const uint8_t rtaps[] PROGMEM = {
40         0x31, 0x4D, 0x11, 0x42,
41         0x59, 0x4C, 0xEC, 0xF3,
42         0x26, 0x96, 0x67, 0x9C,
43         0x32, 0xBE, 0x3B, 0x80, 
44         0xAF, 0x53, 0x52, 0x37
45 };
46         
47 static 
48 void memxor_P(void* d, PGM_VOID_P s, uint8_t length_B){
49         while(length_B--){
50                 *((uint8_t*)d) ^= pgm_read_byte(s);
51                 d = (uint8_t*)d +1;
52                 s = (uint8_t*)s +1;
53         }
54 }
55
56 #define SHL0(a) c1=((a)>>7); (a)=(((a)<<1)|c0)
57 #define SHL1(a) c0=((a)>>7); (a)=(((a)<<1)|c1)
58
59 #define SHLX0(a) c1=((a)>>7); (a)^=(((a)<<1)|c0)
60 #define SHLX1(a) c0=((a)>>7); (a)^=(((a)<<1)|c1)
61
62 static
63 void clock_r(uint8_t* r, uint8_t ibit, uint8_t cbit){
64         uint8_t i,c0=0,c1=0; /* carry */
65         ibit ^= ((r[159/8])>>(159%8))&1; /* ibit is now the same as feedback_bit */
66         if(cbit){
67                 for(i=0; i<10; ++i){
68                         SHLX0(r[2*i+0]);
69                         SHLX1(r[2*i+1]);
70                 }
71         } else {
72                 for(i=0; i<10; ++i){
73                         SHL0(r[2*i+0]);
74                         SHL1(r[2*i+1]);
75                 }
76         }
77         if(ibit){
78                 memxor_P(r, rtaps, 20);
79         }
80 }
81
82 /* comp0 (filling spaces with zero) (one at each side)
83  * 0101.1110 1111.0010 1101.0110 0101.1101 
84  * 0101.0101 0000.1001 0010.0110 0111.1001
85  * 0110.0010 0111.0000 0000.0000 0111.1001
86  * 0011.0001 1101.1001 1010.1111 0011.0111
87  * 1011.1110 0000.0110 1011.1110 0000.1111
88  * --
89  * 5E F2 D6 5D
90  * 55 09 26 79
91  * 62 70 00 79
92  * 31 D9 AF 37
93  * BE 06 BE 0F
94  */ 
95 const uint8_t comp0[] PROGMEM = {
96         0x5E, 0xF2, 0xD6, 0x5D,
97         0x55, 0x09, 0x26, 0x79,
98         0x62, 0x70, 0x00, 0x79, 
99         0x31, 0xD9, 0xAF, 0x37, 
100         0xBE, 0x06, 0xBE, 0x0F
101 };
102
103
104 /* comp1 (shifting one bit right to make calculation easier, so inserting two zeros)
105  * 0110.0000 0011.1110 0011.0010 1111.1010 
106  * 0011.0000 0111.1001 0110.1100 1111.1101
107  * 1100.0001 1000.0111 0000.0001 1111.1000
108  * 1000.1010 1100.0110 1100.0001 1100.1100
109  * 0110.1010 1011.0111 1110.1000 1111.1111
110  * --
111  * 60 3E 32 FA
112  * 30 79 6C FD
113  * C1 87 01 F8
114  * 8A C6 C1 CC
115  * 6A B7 E8 FF
116 */
117 /*
118 const uint8_t comp1[] PROGMEM = {
119         0x60, 0x3E, 0x32, 0xFA, 0x30, 0x79, 0x6C, 0xFD, 0xC1, 0x87, 
120         0x01, 0xF8, 0x8A, 0xC6, 0xC1, 0xCC, 0x6A, 0xB7, 0xE8, 0xFF
121 };
122 */
123 /* comp1
124  * 0000.1100 1111.1000 1001.1000 1011.1110
125  * 0001.1001 0011.1100 0110.1101 0111.1111
126  * 0000.0111 1100.0011 0000.0000 0011.1110
127  * 1010.0010 1100.0111 0000.0110 0110.0110
128  * 1010.1101 1101.1010 0010.1111 1111.1110
129  * --
130  * 0C F8 98 BE
131  * 19 3C 6D 7F
132  * 07 C3 00 3E
133  * A2 C7 06 66
134  * AD DA 2F FE
135 */
136 /*
137 const uint8_t comp1[] PROGMEM = {
138         0x0C, 0xF8, 0x98, 0xBE, 0x19, 0x3C, 0x6D, 0x7F, 0x07, 0xC3,
139         0x00, 0x3E, 0xA2, 0xC7, 0x06, 0x66, 0xAD, 0xDA, 0x2F, 0xFE
140 };
141 */
142 /* comp1
143  * 0011.0000 0001.1111 0001.1001 0111.1101
144  * 1001.1000 0011.1100 1011.0110 1111.1110
145  * 1110.0000 1100.0011 0000.0000 0111.1100
146  * 0100.0101 1110.0011 0110.0000 0110.0110
147  * 1011.0101 0101.1011 1111.0100 0111.1111
148  * --
149  * 30 1F 19 7D
150  * 98 3C B6 FE
151  * E0 C3 00 7C
152  * 45 E3 60 66
153  * B5 5B F4 7F
154 */
155
156 const uint8_t comp1[] PROGMEM = {
157         0x30, 0x1F, 0x19, 0x7D,
158         0x98, 0x3C, 0xB6, 0xFE, 
159         0xE0, 0xC3, 0x00, 0x7C, 
160         0x45, 0xE3, 0x60, 0x66, 
161         0xB5, 0x5B, 0xF4, 0x7F
162 };
163
164 /* fb0
165  * 1010.1111 0001.1111 0011.1100 1100.0100
166  * 0010.0010 1010.0011 0010.1111 0000.1110
167  * 1000.0001 0100.1101 1110.0101 0110.0110
168  * 1001.0001 0100.1011 0101.0100 1101.0100
169  * 1100.0001 0000.1011 0110.0011 1000.0011
170  * --
171  * AF 1F 3C C4
172  * 22 A3 2F 0E
173  * 81 4D E5 66
174  * 91 4B 54 D4
175  * C1 0B 63 83
176  */ 
177 const uint8_t fb0[] PROGMEM = { 
178         0xAF, 0x1F, 0x3C, 0xC4, 
179         0x22, 0xA3, 0x2F, 0x0E, 
180         0x81, 0x4D, 0xE5, 0x66, 
181         0x91, 0x4B, 0x54, 0xD4, 
182         0xC1, 0x0B, 0x63, 0x83
183 };
184
185 /* fb1
186  * 1010.1011 0111.0111 1111.0100 1001.1011 
187  * 1001.0000 1000.1100 0111.1001 0111.0000
188  * 1011.0110 0001.1000 1001.1010 0110.1111
189  * 1110.0111 0111.1110 0100.1011 0110.1100 
190  * 1110.1111 1000.0000 1010.0111 0001.0001
191  * --
192  * AB 77 F4 9B
193  * 90 8C 79 70
194  * B6 18 9A 6F
195  * E7 7E 4B 6C
196  * EF 80 A7 11
197  */ 
198 const uint8_t fb1[] PROGMEM = {
199         0xAB, 0x77, 0xF4, 0x9B, 
200         0x90, 0x8C, 0x79, 0x70, 
201         0xB6, 0x18, 0x9A, 0x6F, 
202         0xE7, 0x7E, 0x4B, 0x6C, 
203         0xEF, 0x80, 0xA7, 0x11
204 };
205
206 static
207 void clock_s(uint8_t* s, uint8_t ibit, uint8_t cbit){
208         uint8_t s0[20], s1[20];
209         uint8_t i,c=0, c2=0;
210         ibit ^= (s[19])>>7;
211         memcpy(s0,s,20);
212         memxor_P(s0, comp0, 20);
213         for(i=0; i<20; ++i){
214                 s1[19-i]= c|((s[19-i])>>1);
215                 c = (s[19-i])<<7;
216         }
217         memxor_P(s1, comp1, 20);
218         c=0;
219         for(i=0; i<20; ++i){
220                 c2=(s[i])>>7;
221                 s[i]=((s[i])<<1) ^ ((s0[i])&(s1[i])) ^ c;
222                 c=c2;
223         }
224         s[0] &= 0xFE;
225         if(ibit){
226                 memxor_P(s, cbit?fb1:fb0, 20);
227         }
228 }
229
230 static
231 void clock_kg(uint8_t* r, uint8_t* s, uint8_t mixing, uint8_t input){
232         uint8_t rb, sb;
233         rb = ((s[ 54/8])>>(( 54%8))) ^ ((r[106/8])>>(((106%8))));
234         sb = ((s[106/8])>>((106%8))) ^ ((r[ 53/8])>>((( 53%8))));
235         rb &= 1;
236         sb &= 1;
237         mixing = input ^ (mixing & ((s[80/8]>>((80%8))) & 1)); 
238         clock_r(r, mixing, rb);
239         clock_s(s, input, sb);
240 }
241
242 void mickey128_init(void* key, uint16_t keysize_b, 
243                     void* iv,  uint16_t ivsize_b, 
244                     mickey128_ctx_t* ctx){
245         uint16_t i;
246         memset(ctx->r, 0, 20);
247         memset(ctx->s, 0, 20);
248         for(i=0; i<ivsize_b; ++i){
249                 clock_kg(ctx->r, ctx->s, 1, 1&((((uint8_t*)iv)[i/8])>>(7-(i%8))));
250         }
251         for(i=0; i<keysize_b; ++i){
252                 clock_kg(ctx->r, ctx->s, 1, 1&((((uint8_t*)key)[i/8])>>(7-(i%8))));
253         }                  
254         for(i=0; i<160; ++i){
255                 clock_kg(ctx->r, ctx->s, 1, 0);
256         }                  
257
258
259 uint8_t mickey128_getbit(mickey128_ctx_t* ctx){
260         uint8_t ret;
261         ret = 1&(*(ctx->r) ^ *(ctx->s));
262         clock_kg(ctx->r, ctx->s, 0, 0);
263         return ret;
264 }
265
266 uint8_t mickey128_getbyte(mickey128_ctx_t* ctx){
267         uint8_t i,ret=0;
268         for(i=0; i<8; ++i){
269                 ret<<=1;
270                 ret |= 1&(((ctx->r)[0]) ^ ((ctx->s)[0]));
271                 clock_kg(ctx->r, ctx->s, 0, 0);
272         }
273         return ret;
274 }
275
276