]> git.cryptolib.org Git - avr-crypto-lib.git/blob - seed/seed_C.c
fixing E-Mail-Address & Copyright
[avr-crypto-lib.git] / seed / seed_C.c
1 /* seed_C.c */
2 /*
3     This file is part of the AVR-Crypto-Lib.
4     Copyright (C) 2006-2015 Daniel Otte (bg@nerilex.org)
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        seed_C.c
21  * \author      Daniel Otte 
22  * \date        2007-06-1
23  * \brief       SEED parts in C for AVR
24  * \par License 
25  * GPL
26  * 
27  */
28 #include <stdint.h>
29 #include <avr/pgmspace.h>
30 #include <string.h>
31 #include "seed_sbox.h"
32 #include "cli.h"
33 #include "debug.h"
34
35
36 static
37 uint32_t g_function(uint32_t x);
38 /******************************************************************************/
39
40 static
41 void changeendian32(uint32_t * a){
42         *a = (*a & 0x000000FF) << 24 |
43                  (*a & 0x0000FF00) <<  8 |
44                  (*a & 0x00FF0000) >>  8 |
45                  (*a & 0xFF000000) >> 24;
46 }
47
48 /******************************************************************************/
49 static
50 uint32_t bigendian_sum32(uint32_t a, uint32_t b){
51         changeendian32(&a);
52         changeendian32(&b);
53         a += b;
54         changeendian32(&a);
55         return a;
56 }
57
58 /******************************************************************************/
59 static 
60 uint32_t bigendian_sub32(uint32_t a, uint32_t b){
61         changeendian32(&a);
62         changeendian32(&b);
63         a -= b;
64         changeendian32(&a);
65         return a;
66 }
67
68 /******************************************************************************/
69 static inline
70 uint64_t bigendian_rotl8_64(uint64_t a){
71         /*
72         changeendian64(&a);
73         a = (a<<8) | (a>>(64-8));
74         changeendian64(&a);
75         */
76         a = (a>>8) | (a<<(64-8));
77         return a;
78 }
79
80 /******************************************************************************/
81 static inline
82 uint64_t bigendian_rotr8_64(uint64_t a){
83         /*
84         changeendian64(&a);
85         a = (a>>8) | (a<<(64-8));
86         changeendian64(&a);
87         */
88         a = (a<<8) | (a>>(64-8));
89         return a;
90 }
91
92 /******************************************************************************/
93 static
94 uint64_t f_function(const uint64_t *a, uint32_t k0, uint32_t k1){
95         uint32_t c,d;
96
97         c = *a & 0x00000000FFFFFFFFLL;
98         d = (*a>>32) & 0x00000000FFFFFFFFLL;
99         
100         c ^= k0; d ^= k1;
101         d ^= c;
102         d = g_function(d);
103         c = bigendian_sum32(c,d);
104         c = g_function(c);
105         d = bigendian_sum32(c,d);
106         d = g_function(d);
107         c = bigendian_sum32(c,d);
108         return ((uint64_t)d << 32) | c;
109 }
110
111 /******************************************************************************/
112 #define M0 0xfc
113 #define M1 0xf3
114 #define M2 0xcf
115 #define M3 0x3f
116
117 #define X3 (((uint8_t*)(&x))[0])
118 #define X2 (((uint8_t*)(&x))[1])
119 #define X1 (((uint8_t*)(&x))[2])
120 #define X0 (((uint8_t*)(&x))[3])
121
122 #define Z3 (((uint8_t*)(&z))[0])
123 #define Z2 (((uint8_t*)(&z))[1])
124 #define Z1 (((uint8_t*)(&z))[2])
125 #define Z0 (((uint8_t*)(&z))[3])
126
127 static
128 uint32_t g_function(uint32_t x){
129         uint32_t z;
130         /* sbox substitution */
131         X3 = pgm_read_byte(&(seed_sbox2[X3]));
132         X2 = pgm_read_byte(&(seed_sbox1[X2]));
133         X1 = pgm_read_byte(&(seed_sbox2[X1]));
134         X0 = pgm_read_byte(&(seed_sbox1[X0]));
135         /* now the permutation */
136         Z0 = (X0 & M0) ^ (X1 & M1) ^ (X2 & M2) ^ (X3 & M3);
137         Z1 = (X0 & M1) ^ (X1 & M2) ^ (X2 & M3) ^ (X3 & M0);
138         Z2 = (X0 & M2) ^ (X1 & M3) ^ (X2 & M0) ^ (X3 & M1);
139         Z3 = (X0 & M3) ^ (X1 & M0) ^ (X2 & M1) ^ (X3 & M2);
140         return z;
141 }
142 /******************************************************************************/
143 typedef struct {
144         uint32_t k0, k1;
145 } keypair_t;
146
147 keypair_t getnextkeys(uint32_t *keystate, uint8_t curround){
148         keypair_t ret;
149         if (curround>15){
150                 /* ERROR */
151                 ret.k0 = ret.k1 = 0;
152         } else {
153         /*      ret.k0 = g_function(keystate[0] + keystate[2] - pgm_read_dword(&(seed_kc[curround])));
154                 ret.k1 = g_function(keystate[1] - keystate[3] + pgm_read_dword(&(seed_kc[curround]))); */
155                 ret.k0 = bigendian_sum32(keystate[0], keystate[2]);
156                 ret.k0 = bigendian_sub32(ret.k0, pgm_read_dword(&(seed_kc[curround])));
157                 ret.k0 = g_function(ret.k0);
158                 ret.k1 = bigendian_sub32(keystate[1], keystate[3]);
159                 ret.k1 = bigendian_sum32(ret.k1, pgm_read_dword(&(seed_kc[curround])));
160                 ret.k1 = g_function(ret.k1);
161                 
162                 if (curround & 1){
163                         /* odd round (1,3,5, ...) */
164                         ((uint64_t*)keystate)[1] = bigendian_rotl8_64( ((uint64_t*)keystate)[1] );
165                 } else {
166                         /* even round (0,2,4, ...) */
167                         ((uint64_t*)keystate)[0] = bigendian_rotr8_64(((uint64_t*)keystate)[0]);
168                 }
169         }
170         return ret;
171 }
172
173
174 /******************************************************************************/
175
176 keypair_t getprevkeys(uint32_t *keystate, uint8_t curround){
177         keypair_t ret;
178         if (curround>15){
179                 /* ERROR */
180                 ret.k0 = ret.k1 = 0;
181         } else {
182                 if (curround & 1){
183                         /* odd round (1,3,5, ..., 15) */
184                         ((uint64_t*)keystate)[1] = bigendian_rotr8_64( ((uint64_t*)keystate)[1] );
185                 } else {
186                         /* even round (0,2,4, ..., 14) */
187                         ((uint64_t*)keystate)[0] = bigendian_rotl8_64(((uint64_t*)keystate)[0]);
188                 }
189         /*      ret.k0 = g_function(keystate[0] + keystate[2] - pgm_read_dword(&(seed_kc[curround])));
190                 ret.k1 = g_function(keystate[1] - keystate[3] + pgm_read_dword(&(seed_kc[curround]))); */
191                 ret.k0 = bigendian_sum32(keystate[0], keystate[2]);
192                 ret.k0 = bigendian_sub32(ret.k0, pgm_read_dword(&(seed_kc[curround])));
193                 ret.k0 = g_function(ret.k0);
194                 ret.k1 = bigendian_sub32(keystate[1], keystate[3]);
195                 ret.k1 = bigendian_sum32(ret.k1, pgm_read_dword(&(seed_kc[curround])));
196                 ret.k1 = g_function(ret.k1);
197                 }
198         return ret;
199 }
200
201 /******************************************************************************/
202
203 typedef struct{
204         uint32_t k[4];
205 } seed_ctx_t;
206
207 /******************************************************************************/
208
209 void seed_init(const void * key, seed_ctx_t * ctx){
210         memcpy(ctx->k, key, 128/8);
211 }
212
213 /******************************************************************************/
214
215 #define L (((uint64_t*)buffer)[0])
216 #define R (((uint64_t*)buffer)[1])
217
218 void seed_enc(void * buffer, const seed_ctx_t * ctx){
219         uint8_t r;
220         keypair_t k;
221         for(r=0; r<8; ++r){
222                         k = getnextkeys(((seed_ctx_t*)ctx)->k, 2*r);
223 /*
224         DEBUG_S("\r\n\tDBG ka,0: "); cli_hexdump(&k.k0, 4);
225         DEBUG_S("\r\n\tDBG ka,1: "); cli_hexdump(&k.k1, 4);
226         DEBUG_S("\r\n\t DBG L: "); cli_hexdump((uint8_t*)buffer+0, 8);
227         DEBUG_S("\r\n\t DBG R: "); cli_hexdump((uint8_t*)buffer+8, 8);
228 */
229                         L ^= f_function(&R,k.k0,k.k1);
230                         
231                         k = getnextkeys(((seed_ctx_t*)ctx)->k, 2*r+1);
232 /*
233         DEBUG_S("\r\n\tDBG kb,0: "); cli_hexdump(&k.k0, 4);
234         DEBUG_S("\r\n\tDBG kb,1: "); cli_hexdump(&k.k1, 4);
235         DEBUG_S("\r\n\t DBG L: "); cli_hexdump((uint8_t*)buffer+8, 8);
236         DEBUG_S("\r\n\t DBG R: "); cli_hexdump((uint8_t*)buffer+0, 8);
237 */
238                         R ^= f_function(&L,k.k0,k.k1);
239         }
240         /* just an exchange without temp. variable */
241         L ^= R;
242         R ^= L;
243         L ^= R;
244 }
245
246 /******************************************************************************/
247
248 #define L (((uint64_t*)buffer)[0])
249 #define R (((uint64_t*)buffer)[1])
250
251 void seed_dec(void * buffer, seed_ctx_t * ctx){
252         int8_t r;
253         keypair_t k;
254         for(r=7; r>=0; --r){
255                         k = getprevkeys(((seed_ctx_t*)ctx)->k, 2*r+1);
256 /*
257         DEBUG_S("\r\n\tDBG ka,0: "); cli_hexdump(&k.k0, 4);
258         DEBUG_S("\r\n\tDBG ka,1: "); cli_hexdump(&k.k1, 4);
259         DEBUG_S("\r\n\t DBG L: "); cli_hexdump((uint8_t*)buffer+0, 8);
260         DEBUG_S("\r\n\t DBG R: "); cli_hexdump((uint8_t*)buffer+8, 8);
261 */
262                         L ^= f_function(&R,k.k0,k.k1);
263                         
264                         k = getprevkeys(((seed_ctx_t*)ctx)->k, 2*r+0);
265 /*
266         DEBUG_S("\r\n\tDBG kb,0: "); cli_hexdump(&k.k0, 4);
267         DEBUG_S("\r\n\tDBG kb,1: "); cli_hexdump(&k.k1, 4);
268         DEBUG_S("\r\n\t DBG L: "); cli_hexdump((uint8_t*)buffer+8, 8);
269         DEBUG_S("\r\n\t DBG R: "); cli_hexdump((uint8_t*)buffer+0, 8);
270 */
271                         R ^= f_function(&L,k.k0,k.k1);
272         }
273         /* just an exchange without temp. variable */
274         L ^= R;
275         R ^= L;
276         L ^= R;
277 }
278
279
280
281
282
283
284
285
286
287
288