Mercurial > dropbear

comparison libtomcrypt/src/ciphers/skipjack.c @ 293:9d110777f345 contrib-blacklist

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
propagate from branch 'au.asn.ucc.matt.dropbear' (head 7ad1775ed65e75dbece27fe6b65bf1a234db386a) to branch 'au.asn.ucc.matt.dropbear.contrib.blacklist' (head 1d86a4f0a401cc68c2670d821a2f6366c37af143)
author Matt Johnston <matt@ucc.asn.au>
date Fri, 10 Mar 2006 06:31:29 +0000
parents 1b9e69c058d2
children 0cbe8f6dbf9e
comparison
equal deleted inserted replaced
247:c07de41b53d7 293:9d110777f345
1 /* LibTomCrypt, modular cryptographic library -- Tom St Denis
2 *
3 * LibTomCrypt is a library that provides various cryptographic
4 * algorithms in a highly modular and flexible manner.
5 *
6 * The library is free for all purposes without any express
7 * guarantee it works.
8 *
9 * Tom St Denis, [email protected], http://libtomcrypt.org
10 */
11
12 /**
13 @file skipjack.c
14 Skipjack Implementation by Tom St Denis
15 */
16 #include "tomcrypt.h"
17
18 #ifdef SKIPJACK
19
20 const struct ltc_cipher_descriptor skipjack_desc =
21 {
22 "skipjack",
23 17,
24 10, 10, 8, 32,
25 &skipjack_setup,
26 &skipjack_ecb_encrypt,
27 &skipjack_ecb_decrypt,
28 &skipjack_test,
29 &skipjack_done,
30 &skipjack_keysize,
31 NULL, NULL, NULL, NULL, NULL, NULL, NULL
32 };
33
34 static const unsigned char sbox[256] = {
35 0xa3,0xd7,0x09,0x83,0xf8,0x48,0xf6,0xf4,0xb3,0x21,0x15,0x78,0x99,0xb1,0xaf,0xf9,
36 0xe7,0x2d,0x4d,0x8a,0xce,0x4c,0xca,0x2e,0x52,0x95,0xd9,0x1e,0x4e,0x38,0x44,0x28,
37 0x0a,0xdf,0x02,0xa0,0x17,0xf1,0x60,0x68,0x12,0xb7,0x7a,0xc3,0xe9,0xfa,0x3d,0x53,
38 0x96,0x84,0x6b,0xba,0xf2,0x63,0x9a,0x19,0x7c,0xae,0xe5,0xf5,0xf7,0x16,0x6a,0xa2,
39 0x39,0xb6,0x7b,0x0f,0xc1,0x93,0x81,0x1b,0xee,0xb4,0x1a,0xea,0xd0,0x91,0x2f,0xb8,
40 0x55,0xb9,0xda,0x85,0x3f,0x41,0xbf,0xe0,0x5a,0x58,0x80,0x5f,0x66,0x0b,0xd8,0x90,
41 0x35,0xd5,0xc0,0xa7,0x33,0x06,0x65,0x69,0x45,0x00,0x94,0x56,0x6d,0x98,0x9b,0x76,
42 0x97,0xfc,0xb2,0xc2,0xb0,0xfe,0xdb,0x20,0xe1,0xeb,0xd6,0xe4,0xdd,0x47,0x4a,0x1d,
43 0x42,0xed,0x9e,0x6e,0x49,0x3c,0xcd,0x43,0x27,0xd2,0x07,0xd4,0xde,0xc7,0x67,0x18,
44 0x89,0xcb,0x30,0x1f,0x8d,0xc6,0x8f,0xaa,0xc8,0x74,0xdc,0xc9,0x5d,0x5c,0x31,0xa4,
45 0x70,0x88,0x61,0x2c,0x9f,0x0d,0x2b,0x87,0x50,0x82,0x54,0x64,0x26,0x7d,0x03,0x40,
46 0x34,0x4b,0x1c,0x73,0xd1,0xc4,0xfd,0x3b,0xcc,0xfb,0x7f,0xab,0xe6,0x3e,0x5b,0xa5,
47 0xad,0x04,0x23,0x9c,0x14,0x51,0x22,0xf0,0x29,0x79,0x71,0x7e,0xff,0x8c,0x0e,0xe2,
48 0x0c,0xef,0xbc,0x72,0x75,0x6f,0x37,0xa1,0xec,0xd3,0x8e,0x62,0x8b,0x86,0x10,0xe8,
49 0x08,0x77,0x11,0xbe,0x92,0x4f,0x24,0xc5,0x32,0x36,0x9d,0xcf,0xf3,0xa6,0xbb,0xac,
50 0x5e,0x6c,0xa9,0x13,0x57,0x25,0xb5,0xe3,0xbd,0xa8,0x3a,0x01,0x05,0x59,0x2a,0x46
51 };
52
53 /* simple x + 1 (mod 10) in one step. */
54 static const int keystep[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
55
56 /* simple x - 1 (mod 10) in one step */
57 static const int ikeystep[] = { 9, 0, 1, 2, 3, 4, 5, 6, 7, 8 };
58
59 /**
60 Initialize the Skipjack block cipher
61 @param key The symmetric key you wish to pass
62 @param keylen The key length in bytes
63 @param num_rounds The number of rounds desired (0 for default)
64 @param skey The key in as scheduled by this function.
65 @return CRYPT_OK if successful
66 */
67 int skipjack_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey)
68 {
69 int x;
70
71 LTC_ARGCHK(key != NULL);
72 LTC_ARGCHK(skey != NULL);
73
74 if (keylen != 10) {
75 return CRYPT_INVALID_KEYSIZE;
76 }
77
78 if (num_rounds != 32 && num_rounds != 0) {
79 return CRYPT_INVALID_ROUNDS;
80 }
81
82 /* make sure the key is in range for platforms where CHAR_BIT != 8 */
83 for (x = 0; x < 10; x++) {
84 skey->skipjack.key[x] = key[x] & 255;
85 }
86
87 return CRYPT_OK;
88 }
89
90 #define RULE_A \
91 tmp = g_func(w1, &kp, skey->skipjack.key); \
92 w1 = tmp ^ w4 ^ x; \
93 w4 = w3; w3 = w2; \
94 w2 = tmp;
95
96 #define RULE_B \
97 tmp = g_func(w1, &kp, skey->skipjack.key); \
98 tmp1 = w4; w4 = w3; \
99 w3 = w1 ^ w2 ^ x; \
100 w1 = tmp1; w2 = tmp;
101
102 #define RULE_A1 \
103 tmp = w1 ^ w2 ^ x; \
104 w1 = ig_func(w2, &kp, skey->skipjack.key); \
105 w2 = w3; w3 = w4; w4 = tmp;
106
107 #define RULE_B1 \
108 tmp = ig_func(w2, &kp, skey->skipjack.key); \
109 w2 = tmp ^ w3 ^ x; \
110 w3 = w4; w4 = w1; w1 = tmp;
111
112 static unsigned g_func(unsigned w, int *kp, unsigned char *key)
113 {
114 unsigned char g1,g2;
115
116 g1 = (w >> 8) & 255; g2 = w & 255;
117 g1 ^= sbox[g2^key[*kp]]; *kp = keystep[*kp];
118 g2 ^= sbox[g1^key[*kp]]; *kp = keystep[*kp];
119 g1 ^= sbox[g2^key[*kp]]; *kp = keystep[*kp];
120 g2 ^= sbox[g1^key[*kp]]; *kp = keystep[*kp];
121 return ((unsigned)g1<<8)|(unsigned)g2;
122 }
123
124 static unsigned ig_func(unsigned w, int *kp, unsigned char *key)
125 {
126 unsigned char g1,g2;
127
128 g1 = (w >> 8) & 255; g2 = w & 255;
129 *kp = ikeystep[*kp]; g2 ^= sbox[g1^key[*kp]];
130 *kp = ikeystep[*kp]; g1 ^= sbox[g2^key[*kp]];
131 *kp = ikeystep[*kp]; g2 ^= sbox[g1^key[*kp]];
132 *kp = ikeystep[*kp]; g1 ^= sbox[g2^key[*kp]];
133 return ((unsigned)g1<<8)|(unsigned)g2;
134 }
135
136 /**
137 Encrypts a block of text with Skipjack
138 @param pt The input plaintext (8 bytes)
139 @param ct The output ciphertext (8 bytes)
140 @param skey The key as scheduled
141 */
142 #ifdef LTC_CLEAN_STACK
143 static void _skipjack_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey)
144 #else
145 void skipjack_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey)
146 #endif
147 {
148 unsigned w1,w2,w3,w4,tmp,tmp1;
149 int x, kp;
150
151 LTC_ARGCHK(pt != NULL);
152 LTC_ARGCHK(ct != NULL);
153 LTC_ARGCHK(skey != NULL);
154
155 /* load block */
156 w1 = ((unsigned)pt[0]<<8)|pt[1];
157 w2 = ((unsigned)pt[2]<<8)|pt[3];
158 w3 = ((unsigned)pt[4]<<8)|pt[5];
159 w4 = ((unsigned)pt[6]<<8)|pt[7];
160
161 /* 8 rounds of RULE A */
162 for (x = 1, kp = 0; x < 9; x++) {
163 RULE_A;
164 }
165
166 /* 8 rounds of RULE B */
167 for (; x < 17; x++) {
168 RULE_B;
169 }
170
171 /* 8 rounds of RULE A */
172 for (; x < 25; x++) {
173 RULE_A;
174 }
175
176 /* 8 rounds of RULE B */
177 for (; x < 33; x++) {
178 RULE_B;
179 }
180
181 /* store block */
182 ct[0] = (w1>>8)&255; ct[1] = w1&255;
183 ct[2] = (w2>>8)&255; ct[3] = w2&255;
184 ct[4] = (w3>>8)&255; ct[5] = w3&255;
185 ct[6] = (w4>>8)&255; ct[7] = w4&255;
186 }
187
188 #ifdef LTC_CLEAN_STACK
189 void skipjack_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey)
190 {
191 _skipjack_ecb_encrypt(pt, ct, skey);
192 burn_stack(sizeof(unsigned) * 8 + sizeof(int) * 2);
193 }
194 #endif
195
196 /**
197 Decrypts a block of text with Skipjack
198 @param ct The input ciphertext (8 bytes)
199 @param pt The output plaintext (8 bytes)
200 @param skey The key as scheduled
201 */
202 #ifdef LTC_CLEAN_STACK
203 static void _skipjack_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey)
204 #else
205 void skipjack_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey)
206 #endif
207 {
208 unsigned w1,w2,w3,w4,tmp;
209 int x, kp;
210
211 LTC_ARGCHK(pt != NULL);
212 LTC_ARGCHK(ct != NULL);
213 LTC_ARGCHK(skey != NULL);
214
215 /* load block */
216 w1 = ((unsigned)ct[0]<<8)|ct[1];
217 w2 = ((unsigned)ct[2]<<8)|ct[3];
218 w3 = ((unsigned)ct[4]<<8)|ct[5];
219 w4 = ((unsigned)ct[6]<<8)|ct[7];
220
221 /* 8 rounds of RULE B^-1
222
223 Note the value "kp = 8" comes from "kp = (32 * 4) mod 10" where 32*4 is 128 which mod 10 is 8
224 */
225 for (x = 32, kp = 8; x > 24; x--) {
226 RULE_B1;
227 }
228
229 /* 8 rounds of RULE A^-1 */
230 for (; x > 16; x--) {
231 RULE_A1;
232 }
233
234
235 /* 8 rounds of RULE B^-1 */
236 for (; x > 8; x--) {
237 RULE_B1;
238 }
239
240 /* 8 rounds of RULE A^-1 */
241 for (; x > 0; x--) {
242 RULE_A1;
243 }
244
245 /* store block */
246 pt[0] = (w1>>8)&255; pt[1] = w1&255;
247 pt[2] = (w2>>8)&255; pt[3] = w2&255;
248 pt[4] = (w3>>8)&255; pt[5] = w3&255;
249 pt[6] = (w4>>8)&255; pt[7] = w4&255;
250 }
251
252 #ifdef LTC_CLEAN_STACK
253 void skipjack_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey)
254 {
255 _skipjack_ecb_decrypt(ct, pt, skey);
256 burn_stack(sizeof(unsigned) * 7 + sizeof(int) * 2);
257 }
258 #endif
259
260 /**
261 Performs a self-test of the Skipjack block cipher
262 @return CRYPT_OK if functional, CRYPT_NOP if self-test has been disabled
263 */
264 int skipjack_test(void)
265 {
266 #ifndef LTC_TEST
267 return CRYPT_NOP;
268 #else
269 static const struct {
270 unsigned char key[10], pt[8], ct[8];
271 } tests[] = {
272 {
273 { 0x00, 0x99, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11 },
274 { 0x33, 0x22, 0x11, 0x00, 0xdd, 0xcc, 0xbb, 0xaa },
275 { 0x25, 0x87, 0xca, 0xe2, 0x7a, 0x12, 0xd3, 0x00 }
276 }
277 };
278 unsigned char buf[2][8];
279 int x, y, err;
280 symmetric_key key;
281
282 for (x = 0; x < (int)(sizeof(tests) / sizeof(tests[0])); x++) {
283 /* setup key */
284 if ((err = skipjack_setup(tests[x].key, 10, 0, &key)) != CRYPT_OK) {
285 return err;
286 }
287
288 /* encrypt and decrypt */
289 skipjack_ecb_encrypt(tests[x].pt, buf[0], &key);
290 skipjack_ecb_decrypt(buf[0], buf[1], &key);
291
292 /* compare */
293 if (memcmp(buf[0], tests[x].ct, 8) != 0 || memcmp(buf[1], tests[x].pt, 8) != 0) {
294 return CRYPT_FAIL_TESTVECTOR;
295 }
296
297 /* now see if we can encrypt all zero bytes 1000 times, decrypt and come back where we started */
298 for (y = 0; y < 8; y++) buf[0][y] = 0;
299 for (y = 0; y < 1000; y++) skipjack_ecb_encrypt(buf[0], buf[0], &key);
300 for (y = 0; y < 1000; y++) skipjack_ecb_decrypt(buf[0], buf[0], &key);
301 for (y = 0; y < 8; y++) if (buf[0][y] != 0) return CRYPT_FAIL_TESTVECTOR;
302 }
303
304 return CRYPT_OK;
305 #endif
306 }
307
308 /** Terminate the context
309 @param skey The scheduled key
310 */
311 void skipjack_done(symmetric_key *skey)
312 {
313 }
314
315 /**
316 Gets suitable key size
317 @param keysize [in/out] The length of the recommended key (in bytes). This function will store the suitable size back in this variable.
318 @return CRYPT_OK if the input key size is acceptable.
319 */
320 int skipjack_keysize(int *keysize)
321 {
322 LTC_ARGCHK(keysize != NULL);
323 if (*keysize < 10) {
324 return CRYPT_INVALID_KEYSIZE;
325 } else if (*keysize > 10) {
326 *keysize = 10;
327 }
328 return CRYPT_OK;
329 }
330
331 #endif
332
333 /* $Source: /cvs/libtom/libtomcrypt/src/ciphers/skipjack.c,v $ */
334 /* $Revision: 1.7 $ */
335 /* $Date: 2005/05/05 14:35:58 $ */