]> git.cryptolib.org Git - avr-crypto-lib.git/blob - mugi/mugi.c
d196c6eecebb570d1eaf1f3841c08ab8510e14b3
[avr-crypto-lib.git] / mugi / mugi.c
1 /* mugi.c */
2 /*
3     This file is part of the AVR-Crypto-Lib.
4     Copyright (C) 2008  Daniel Otte (daniel.otte@rub.de)
5
6     This program is free software: you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation, either version 3 of the License, or
9     (at your option) any later version.
10
11     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License
17     along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19 /**
20  * \file        mugi.c
21  * \author      Daniel Otte 
22  * \email   daniel.otte@rub.de
23  * \date        2009-02-15
24  * \brief       implementation of the MUGI key stream generator
25  * \license     GPLv3 or later
26  */
27  
28 #include <stdint.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <avr/pgmspace.h>
32 #include "aes_sbox.h"
33 #include "mugi.h"
34 #include "gf256mul.h"
35
36 /*
37 #include "test_src/cli.h" / * only for debugging * /
38
39 void dump_mugi_ctx(mugi_ctx_t* ctx){
40         uint8_t i;
41         cli_putstr_P(PSTR("\r\n== MUGI CTX DUMP==\r\n a:"));
42         cli_hexdump(&(ctx->a[0]), 8);
43         cli_putc(' ');
44         cli_hexdump(&(ctx->a[1]), 8);
45         cli_putc(' ');
46         cli_hexdump(&(ctx->a[2]), 8);
47         cli_putstr_P(PSTR("\r\n b: "));
48         for(i=0; i<4; ++i){
49                 cli_putstr_P(PSTR("\r\n    "));
50                 cli_hexdump(&(ctx->b[i*4+0]), 8);
51                 cli_putc(' ');
52                 cli_hexdump(&(ctx->b[i*4+1]), 8);
53                 cli_putc(' ');
54                 cli_hexdump(&(ctx->b[i*4+2]), 8);
55                 cli_putc(' ');
56                 cli_hexdump(&(ctx->b[i*4+3]), 8);
57         }
58 }
59 */
60
61 #define C0 0x08c9bcf367e6096all
62 #define C1 0x3ba7ca8485ae67bbll
63 #define C2 0x2bf894fe72f36e3cll
64
65 #define GF256MUL_2(a) (gf256mul(2, (a), 0x1b))
66
67 uint64_t changeendian64(uint64_t a){
68         uint8_t r[8];
69         r[0] = ((uint8_t*)&a)[7];
70         r[1] = ((uint8_t*)&a)[6];
71         r[2] = ((uint8_t*)&a)[5];
72         r[3] = ((uint8_t*)&a)[4];
73         r[4] = ((uint8_t*)&a)[3];
74         r[5] = ((uint8_t*)&a)[2];
75         r[6] = ((uint8_t*)&a)[1];
76         r[7] = ((uint8_t*)&a)[0];
77         return *((uint64_t*)r);
78 }
79
80 static
81 uint64_t rotl64(uint64_t a, uint8_t i){
82         uint64_t r;
83         r=changeendian64(a);
84         r=(r<<i | r>>(64-i));
85         r=changeendian64(r);
86         return r;
87 }
88
89 static
90 uint64_t rotr64(uint64_t a, uint8_t i){
91         uint64_t r;
92         r=changeendian64(a);
93         r=(r>>i | r<<(64-i));
94         r=changeendian64(r);
95         return r;
96 }
97
98
99 #define T(x) (((uint8_t*)&t)[(x)])
100 #define D(y) (((uint8_t*)dest)[(y)])
101 static void mugi_f(uint64_t* dest, uint64_t* a, uint64_t* b){
102         uint64_t t;
103         uint8_t i,x;
104         t = (*a); 
105         if(b)
106                 t ^= (*b);
107         for(i=0; i<8; ++i)
108                 T(i) = pgm_read_byte(aes_sbox+T(i));
109         
110         x = T(0) ^ T(1) ^ T(2) ^ T(3);
111         D(4) =
112                   GF256MUL_2(T(0)^T(1))
113                 ^ T(0)
114                 ^ x;
115         D(5) =
116                   GF256MUL_2(T(1)^T(2))
117                 ^ T(1)
118                 ^ x;
119         D(2) =
120                   GF256MUL_2(T(2)^T(3))
121                 ^ T(2)
122                 ^ x;
123         D(3) =
124                   GF256MUL_2(T(3)^T(0))
125                 ^ T(3)
126                 ^ x;
127         x = T(4) ^ T(5) ^ T(6) ^ T(7);
128         D(0) =
129                   GF256MUL_2(T(4)^T(5))
130                 ^ T(4)
131                 ^ x;
132         D(1) =
133                   GF256MUL_2(T(5)^T(6))
134                 ^ T(5)
135                 ^ x;
136         D(6) =
137                   GF256MUL_2(T(6)^T(7))
138                 ^ T(6)
139                 ^ x;
140         D(7) =
141                   GF256MUL_2(T(7)^T(4))
142                 ^ T(7)
143                 ^ x;
144
145
146 static
147 void mugi_rho(mugi_ctx_t* ctx){
148         uint64_t t,bx;
149         t = ctx->a[1];
150         ctx->a[1] = ctx->a[2];
151         ctx->a[2] = ctx->a[0];
152         ctx->a[0] = t;
153         mugi_f(&t, &(ctx->a[0]), &(ctx->b[4]));
154         ctx->a[1] ^= t ^ C1;
155         bx = rotl64(ctx->b[10], 17);
156         mugi_f(&t, &(ctx->a[0]), &bx);
157         ctx->a[2] ^= t ^ C2;
158
159
160 static
161 void mugi_rho_init(uint64_t* a){
162         uint64_t t;
163         t = a[1];
164         a[1] = a[2];
165         a[2] = a[0];
166         a[0] = t;
167         mugi_f(&t, &(a[0]), NULL);
168         a[1] ^= t ^ C1;
169         mugi_f(&t, &(a[0]), NULL);
170         a[2] ^= t ^ C2;
171
172
173 static
174 void mugi_lambda(uint64_t* b, uint64_t *a){
175         uint8_t i;
176         uint64_t t;
177         t=b[15];
178         for(i=15; i!=0; --i){
179                 b[i]=b[i-1];
180         }
181         b[0]   = t ^ *a;
182         b[4]  ^= b[8];
183         b[10] ^= rotl64(b[14], 32);
184 }
185
186 void mugi_init(const void* key, const void* iv, mugi_ctx_t* ctx){
187         uint8_t i;
188         uint64_t a0;
189         memcpy(ctx->a, key, 128/8);
190         ctx->a[2] = rotl64(ctx->a[0], 7) ^ rotr64(ctx->a[1], 7) ^ C0;
191         for(i=0; i<16;i++){
192                 mugi_rho_init(ctx->a);
193                 ctx->b[15-i] = ctx->a[0];
194         }
195         ctx->a[0] ^= ((uint64_t*)iv)[0];
196         ctx->a[1] ^= ((uint64_t*)iv)[1];
197         ctx->a[2] ^= rotl64(((uint64_t*)iv)[0], 7) ^ rotr64(((uint64_t*)iv)[1], 7) ^ C0;
198         for(i=0; i<16;i++){
199                 mugi_rho_init(ctx->a);
200         }
201         for(i=0; i<15;i++){
202                 a0 = ctx->a[0];
203                 mugi_rho(ctx);
204                 mugi_lambda(ctx->b, &a0);
205         }
206         a0=0x00;
207 }
208
209 uint64_t mugi_gen(mugi_ctx_t* ctx){
210         uint64_t r;
211         r=ctx->a[0];
212         mugi_rho(ctx);
213         mugi_lambda(ctx->b, &r);
214         r=ctx->a[2];
215         return r;
216 }