aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@ppc970.osdl.org>2005-06-23 02:11:50 -0400
committerLinus Torvalds <torvalds@ppc970.osdl.org>2005-06-23 02:11:50 -0400
commit060de20e82195d404f7dc6a914685730376fdc80 (patch)
treef7b8499beaae104016b46e7583b2dbc1d6d7f901
parentb7c84c6ada2be942eca6722edb2cfaad412cd5de (diff)
parent2c4ee8f907fc4a3c69273a958f853bf4b358eb49 (diff)
Merge rsync://rsync.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
Diffstat
-rw-r--r--crypto/tcrypt.c580
-rw-r--r--crypto/tcrypt.h449
-rw-r--r--drivers/net/appletalk/ltpc.c6
-rw-r--r--include/linux/netdevice.h4
-rw-r--r--include/linux/netfilter_ipv4/ipt_CLUSTERIP.h3
-rw-r--r--include/linux/netpoll.h34
-rw-r--r--include/linux/x25.h12
-rw-r--r--include/net/x25.h9
-rw-r--r--net/appletalk/aarp.c7
-rw-r--r--net/bridge/netfilter/ebtables.c21
-rw-r--r--net/core/netpoll.c80
-rw-r--r--net/ipv4/netfilter/ipt_CLUSTERIP.c2
-rw-r--r--net/ipv4/route.c8
-rw-r--r--net/socket.c3
-rw-r--r--net/x25/af_x25.c110
-rw-r--r--net/x25/x25_facilities.c34
-rw-r--r--net/x25/x25_subr.c41
17 files changed, 921 insertions, 482 deletions
diff --git a/crypto/tcrypt.c b/crypto/tcrypt.c
index 92b0352c8e92..bd7524cfff33 100644
--- a/crypto/tcrypt.c
+++ b/crypto/tcrypt.c
@@ -1,4 +1,4 @@
1/* 1/*
2 * Quick & dirty crypto testing module. 2 * Quick & dirty crypto testing module.
3 * 3 *
4 * This will only exist until we have a better testing mechanism 4 * This will only exist until we have a better testing mechanism
@@ -9,11 +9,12 @@
9 * 9 *
10 * This program is free software; you can redistribute it and/or modify it 10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the Free 11 * under the terms of the GNU General Public License as published by the Free
12 * Software Foundation; either version 2 of the License, or (at your option) 12 * Software Foundation; either version 2 of the License, or (at your option)
13 * any later version. 13 * any later version.
14 * 14 *
15 * 14 - 09 - 2003 15 * 2004-08-09 Added cipher speed tests (Reyk Floeter <reyk@vantronix.net>)
16 * Rewritten by Kartikey Mahendra Bhatt 16 * 2003-09-14 Rewritten by Kartikey Mahendra Bhatt
17 *
17 */ 18 */
18 19
19#include <linux/init.h> 20#include <linux/init.h>
@@ -25,12 +26,15 @@
25#include <linux/crypto.h> 26#include <linux/crypto.h>
26#include <linux/highmem.h> 27#include <linux/highmem.h>
27#include <linux/moduleparam.h> 28#include <linux/moduleparam.h>
29#include <linux/jiffies.h>
30#include <linux/timex.h>
31#include <linux/interrupt.h>
28#include "tcrypt.h" 32#include "tcrypt.h"
29 33
30/* 34/*
31 * Need to kmalloc() memory for testing kmap(). 35 * Need to kmalloc() memory for testing kmap().
32 */ 36 */
33#define TVMEMSIZE 4096 37#define TVMEMSIZE 16384
34#define XBUFSIZE 32768 38#define XBUFSIZE 32768
35 39
36/* 40/*
@@ -55,19 +59,23 @@
55 59
56static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 }; 60static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
57 61
62/*
63 * Used by test_cipher_speed()
64 */
65static unsigned int sec;
66
58static int mode; 67static int mode;
59static char *xbuf; 68static char *xbuf;
60static char *tvmem; 69static char *tvmem;
61 70
62static char *check[] = { 71static char *check[] = {
63 "des", "md5", "des3_ede", "rot13", "sha1", "sha256", "blowfish", 72 "des", "md5", "des3_ede", "rot13", "sha1", "sha256", "blowfish",
64 "twofish", "serpent", "sha384", "sha512", "md4", "aes", "cast6", 73 "twofish", "serpent", "sha384", "sha512", "md4", "aes", "cast6",
65 "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea", 74 "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
66 "khazad", "wp512", "wp384", "wp256", "tnepres", NULL 75 "khazad", "wp512", "wp384", "wp256", "tnepres", NULL
67}; 76};
68 77
69static void 78static void hexdump(unsigned char *buf, unsigned int len)
70hexdump(unsigned char *buf, unsigned int len)
71{ 79{
72 while (len--) 80 while (len--)
73 printk("%02x", *buf++); 81 printk("%02x", *buf++);
@@ -75,29 +83,29 @@ hexdump(unsigned char *buf, unsigned int len)
75 printk("\n"); 83 printk("\n");
76} 84}
77 85
78static void 86static void test_hash(char *algo, struct hash_testvec *template,
79test_hash (char * algo, struct hash_testvec * template, unsigned int tcount) 87 unsigned int tcount)
80{ 88{
81 char *p; 89 char *p;
82 unsigned int i, j, k, temp; 90 unsigned int i, j, k, temp;
83 struct scatterlist sg[8]; 91 struct scatterlist sg[8];
84 char result[64]; 92 char result[64];
85 struct crypto_tfm *tfm; 93 struct crypto_tfm *tfm;
86 struct hash_testvec *hash_tv; 94 struct hash_testvec *hash_tv;
87 unsigned int tsize; 95 unsigned int tsize;
88 96
89 printk("\ntesting %s\n", algo); 97 printk("\ntesting %s\n", algo);
90 98
91 tsize = sizeof (struct hash_testvec); 99 tsize = sizeof(struct hash_testvec);
92 tsize *= tcount; 100 tsize *= tcount;
93 101
94 if (tsize > TVMEMSIZE) { 102 if (tsize > TVMEMSIZE) {
95 printk("template (%u) too big for tvmem (%u)\n", tsize, TVMEMSIZE); 103 printk("template (%u) too big for tvmem (%u)\n", tsize, TVMEMSIZE);
96 return; 104 return;
97 } 105 }
98 106
99 memcpy(tvmem, template, tsize); 107 memcpy(tvmem, template, tsize);
100 hash_tv = (void *) tvmem; 108 hash_tv = (void *)tvmem;
101 tfm = crypto_alloc_tfm(algo, 0); 109 tfm = crypto_alloc_tfm(algo, 0);
102 if (tfm == NULL) { 110 if (tfm == NULL) {
103 printk("failed to load transform for %s\n", algo); 111 printk("failed to load transform for %s\n", algo);
@@ -105,70 +113,71 @@ test_hash (char * algo, struct hash_testvec * template, unsigned int tcount)
105 } 113 }
106 114
107 for (i = 0; i < tcount; i++) { 115 for (i = 0; i < tcount; i++) {
108 printk ("test %u:\n", i + 1); 116 printk("test %u:\n", i + 1);
109 memset (result, 0, 64); 117 memset(result, 0, 64);
110 118
111 p = hash_tv[i].plaintext; 119 p = hash_tv[i].plaintext;
112 sg[0].page = virt_to_page (p); 120 sg[0].page = virt_to_page(p);
113 sg[0].offset = offset_in_page (p); 121 sg[0].offset = offset_in_page(p);
114 sg[0].length = hash_tv[i].psize; 122 sg[0].length = hash_tv[i].psize;
115 123
116 crypto_digest_init (tfm); 124 crypto_digest_init(tfm);
117 if (tfm->crt_u.digest.dit_setkey) { 125 if (tfm->crt_u.digest.dit_setkey) {
118 crypto_digest_setkey (tfm, hash_tv[i].key, 126 crypto_digest_setkey(tfm, hash_tv[i].key,
119 hash_tv[i].ksize); 127 hash_tv[i].ksize);
120 } 128 }
121 crypto_digest_update (tfm, sg, 1); 129 crypto_digest_update(tfm, sg, 1);
122 crypto_digest_final (tfm, result); 130 crypto_digest_final(tfm, result);
123 131
124 hexdump (result, crypto_tfm_alg_digestsize (tfm)); 132 hexdump(result, crypto_tfm_alg_digestsize(tfm));
125 printk("%s\n", 133 printk("%s\n",
126 memcmp(result, hash_tv[i].digest, 134 memcmp(result, hash_tv[i].digest,
127 crypto_tfm_alg_digestsize(tfm)) ? "fail" : 135 crypto_tfm_alg_digestsize(tfm)) ?
128 "pass"); 136 "fail" : "pass");
129 } 137 }
130 138
131 printk ("testing %s across pages\n", algo); 139 printk("testing %s across pages\n", algo);
132 140
133 /* setup the dummy buffer first */ 141 /* setup the dummy buffer first */
134 memset(xbuf, 0, XBUFSIZE); 142 memset(xbuf, 0, XBUFSIZE);
135 143
136 j = 0; 144 j = 0;
137 for (i = 0; i < tcount; i++) { 145 for (i = 0; i < tcount; i++) {
138 if (hash_tv[i].np) { 146 if (hash_tv[i].np) {
139 j++; 147 j++;
140 printk ("test %u:\n", j); 148 printk("test %u:\n", j);
141 memset (result, 0, 64); 149 memset(result, 0, 64);
142 150
143 temp = 0; 151 temp = 0;
144 for (k = 0; k < hash_tv[i].np; k++) { 152 for (k = 0; k < hash_tv[i].np; k++) {
145 memcpy (&xbuf[IDX[k]], hash_tv[i].plaintext + temp, 153 memcpy(&xbuf[IDX[k]],
146 hash_tv[i].tap[k]); 154 hash_tv[i].plaintext + temp,
155 hash_tv[i].tap[k]);
147 temp += hash_tv[i].tap[k]; 156 temp += hash_tv[i].tap[k];
148 p = &xbuf[IDX[k]]; 157 p = &xbuf[IDX[k]];
149 sg[k].page = virt_to_page (p); 158 sg[k].page = virt_to_page(p);
150 sg[k].offset = offset_in_page (p); 159 sg[k].offset = offset_in_page(p);
151 sg[k].length = hash_tv[i].tap[k]; 160 sg[k].length = hash_tv[i].tap[k];
152 } 161 }
153 162
154 crypto_digest_digest (tfm, sg, hash_tv[i].np, result); 163 crypto_digest_digest(tfm, sg, hash_tv[i].np, result);
155 164
156 hexdump (result, crypto_tfm_alg_digestsize (tfm)); 165 hexdump(result, crypto_tfm_alg_digestsize(tfm));
157 printk("%s\n", 166 printk("%s\n",
158 memcmp(result, hash_tv[i].digest, 167 memcmp(result, hash_tv[i].digest,
159 crypto_tfm_alg_digestsize(tfm)) ? "fail" : 168 crypto_tfm_alg_digestsize(tfm)) ?
160 "pass"); 169 "fail" : "pass");
161 } 170 }
162 } 171 }
163 172
164 crypto_free_tfm (tfm); 173 crypto_free_tfm(tfm);
165} 174}
166 175
167 176
168#ifdef CONFIG_CRYPTO_HMAC 177#ifdef CONFIG_CRYPTO_HMAC
169 178
170static void 179static void test_hmac(char *algo, struct hmac_testvec *template,
171test_hmac(char *algo, struct hmac_testvec * template, unsigned int tcount) 180 unsigned int tcount)
172{ 181{
173 char *p; 182 char *p;
174 unsigned int i, j, k, temp; 183 unsigned int i, j, k, temp;
@@ -185,8 +194,8 @@ test_hmac(char *algo, struct hmac_testvec * template, unsigned int tcount)
185 } 194 }
186 195
187 printk("\ntesting hmac_%s\n", algo); 196 printk("\ntesting hmac_%s\n", algo);
188 197
189 tsize = sizeof (struct hmac_testvec); 198 tsize = sizeof(struct hmac_testvec);
190 tsize *= tcount; 199 tsize *= tcount;
191 if (tsize > TVMEMSIZE) { 200 if (tsize > TVMEMSIZE) {
192 printk("template (%u) too big for tvmem (%u)\n", tsize, 201 printk("template (%u) too big for tvmem (%u)\n", tsize,
@@ -195,7 +204,7 @@ test_hmac(char *algo, struct hmac_testvec * template, unsigned int tcount)
195 } 204 }
196 205
197 memcpy(tvmem, template, tsize); 206 memcpy(tvmem, template, tsize);
198 hmac_tv = (void *) tvmem; 207 hmac_tv = (void *)tvmem;
199 208
200 for (i = 0; i < tcount; i++) { 209 for (i = 0; i < tcount; i++) {
201 printk("test %u:\n", i + 1); 210 printk("test %u:\n", i + 1);
@@ -219,34 +228,35 @@ test_hmac(char *algo, struct hmac_testvec * template, unsigned int tcount)
219 printk("\ntesting hmac_%s across pages\n", algo); 228 printk("\ntesting hmac_%s across pages\n", algo);
220 229
221 memset(xbuf, 0, XBUFSIZE); 230 memset(xbuf, 0, XBUFSIZE);
222 231
223 j = 0; 232 j = 0;
224 for (i = 0; i < tcount; i++) { 233 for (i = 0; i < tcount; i++) {
225 if (hmac_tv[i].np) { 234 if (hmac_tv[i].np) {
226 j++; 235 j++;
227 printk ("test %u:\n",j); 236 printk("test %u:\n",j);
228 memset (result, 0, 64); 237 memset(result, 0, 64);
229 238
230 temp = 0; 239 temp = 0;
231 klen = hmac_tv[i].ksize; 240 klen = hmac_tv[i].ksize;
232 for (k = 0; k < hmac_tv[i].np; k++) { 241 for (k = 0; k < hmac_tv[i].np; k++) {
233 memcpy (&xbuf[IDX[k]], hmac_tv[i].plaintext + temp, 242 memcpy(&xbuf[IDX[k]],
234 hmac_tv[i].tap[k]); 243 hmac_tv[i].plaintext + temp,
244 hmac_tv[i].tap[k]);
235 temp += hmac_tv[i].tap[k]; 245 temp += hmac_tv[i].tap[k];
236 p = &xbuf[IDX[k]]; 246 p = &xbuf[IDX[k]];
237 sg[k].page = virt_to_page (p); 247 sg[k].page = virt_to_page(p);
238 sg[k].offset = offset_in_page (p); 248 sg[k].offset = offset_in_page(p);
239 sg[k].length = hmac_tv[i].tap[k]; 249 sg[k].length = hmac_tv[i].tap[k];
240 } 250 }
241 251
242 crypto_hmac(tfm, hmac_tv[i].key, &klen, sg, hmac_tv[i].np, 252 crypto_hmac(tfm, hmac_tv[i].key, &klen, sg,
243 result); 253 hmac_tv[i].np, result);
244 hexdump(result, crypto_tfm_alg_digestsize(tfm)); 254 hexdump(result, crypto_tfm_alg_digestsize(tfm));
245 255
246 printk("%s\n", 256 printk("%s\n",
247 memcmp(result, hmac_tv[i].digest, 257 memcmp(result, hmac_tv[i].digest,
248 crypto_tfm_alg_digestsize(tfm)) ? "fail" : 258 crypto_tfm_alg_digestsize(tfm)) ?
249 "pass"); 259 "fail" : "pass");
250 } 260 }
251 } 261 }
252out: 262out:
@@ -255,8 +265,8 @@ out:
255 265
256#endif /* CONFIG_CRYPTO_HMAC */ 266#endif /* CONFIG_CRYPTO_HMAC */
257 267
258static void 268static void test_cipher(char *algo, int mode, int enc,
259test_cipher(char * algo, int mode, int enc, struct cipher_testvec * template, unsigned int tcount) 269 struct cipher_testvec *template, unsigned int tcount)
260{ 270{
261 unsigned int ret, i, j, k, temp; 271 unsigned int ret, i, j, k, temp;
262 unsigned int tsize; 272 unsigned int tsize;
@@ -265,22 +275,22 @@ test_cipher(char * algo, int mode, int enc, struct cipher_testvec * template, un
265 char *key; 275 char *key;
266 struct cipher_testvec *cipher_tv; 276 struct cipher_testvec *cipher_tv;
267 struct scatterlist sg[8]; 277 struct scatterlist sg[8];
268 char e[11], m[4]; 278 const char *e, *m;
269 279
270 if (enc == ENCRYPT) 280 if (enc == ENCRYPT)
271 strncpy(e, "encryption", 11); 281 e = "encryption";
272 else 282 else
273 strncpy(e, "decryption", 11); 283 e = "decryption";
274 if (mode == MODE_ECB) 284 if (mode == MODE_ECB)
275 strncpy(m, "ECB", 4); 285 m = "ECB";
276 else 286 else
277 strncpy(m, "CBC", 4); 287 m = "CBC";
278 288
279 printk("\ntesting %s %s %s \n", algo, m, e); 289 printk("\ntesting %s %s %s\n", algo, m, e);
280 290
281 tsize = sizeof (struct cipher_testvec); 291 tsize = sizeof (struct cipher_testvec);
282 tsize *= tcount; 292 tsize *= tcount;
283 293
284 if (tsize > TVMEMSIZE) { 294 if (tsize > TVMEMSIZE) {
285 printk("template (%u) too big for tvmem (%u)\n", tsize, 295 printk("template (%u) too big for tvmem (%u)\n", tsize,
286 TVMEMSIZE); 296 TVMEMSIZE);
@@ -288,112 +298,113 @@ test_cipher(char * algo, int mode, int enc, struct cipher_testvec * template, un
288 } 298 }
289 299
290 memcpy(tvmem, template, tsize); 300 memcpy(tvmem, template, tsize);
291 cipher_tv = (void *) tvmem; 301 cipher_tv = (void *)tvmem;
302
303 if (mode)
304 tfm = crypto_alloc_tfm(algo, 0);
305 else
306 tfm = crypto_alloc_tfm(algo, CRYPTO_TFM_MODE_CBC);
292 307
293 if (mode)
294 tfm = crypto_alloc_tfm (algo, 0);
295 else
296 tfm = crypto_alloc_tfm (algo, CRYPTO_TFM_MODE_CBC);
297
298 if (tfm == NULL) { 308 if (tfm == NULL) {
299 printk("failed to load transform for %s %s\n", algo, m); 309 printk("failed to load transform for %s %s\n", algo, m);
300 return; 310 return;
301 } 311 }
302 312
303 j = 0; 313 j = 0;
304 for (i = 0; i < tcount; i++) { 314 for (i = 0; i < tcount; i++) {
305 if (!(cipher_tv[i].np)) { 315 if (!(cipher_tv[i].np)) {
306 j++; 316 j++;
307 printk("test %u (%d bit key):\n", 317 printk("test %u (%d bit key):\n",
308 j, cipher_tv[i].klen * 8); 318 j, cipher_tv[i].klen * 8);
309 319
310 tfm->crt_flags = 0; 320 tfm->crt_flags = 0;
311 if (cipher_tv[i].wk) 321 if (cipher_tv[i].wk)
312 tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY; 322 tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
313 key = cipher_tv[i].key; 323 key = cipher_tv[i].key;
314 324
315 ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen); 325 ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen);
316 if (ret) { 326 if (ret) {
317 printk("setkey() failed flags=%x\n", tfm->crt_flags); 327 printk("setkey() failed flags=%x\n", tfm->crt_flags);
318 328
319 if (!cipher_tv[i].fail) 329 if (!cipher_tv[i].fail)
320 goto out; 330 goto out;
321 } 331 }
322 332
323 p = cipher_tv[i].input; 333 p = cipher_tv[i].input;
324 sg[0].page = virt_to_page(p); 334 sg[0].page = virt_to_page(p);
325 sg[0].offset = offset_in_page(p); 335 sg[0].offset = offset_in_page(p);
326 sg[0].length = cipher_tv[i].ilen; 336 sg[0].length = cipher_tv[i].ilen;
327 337
328 if (!mode) { 338 if (!mode) {
329 crypto_cipher_set_iv(tfm, cipher_tv[i].iv, 339 crypto_cipher_set_iv(tfm, cipher_tv[i].iv,
330 crypto_tfm_alg_ivsize (tfm)); 340 crypto_tfm_alg_ivsize(tfm));
331 } 341 }
332 342
333 if (enc) 343 if (enc)
334 ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen); 344 ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen);
335 else 345 else
336 ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen); 346 ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen);
337 347
338 348
339 if (ret) { 349 if (ret) {
340 printk("%s () failed flags=%x\n", e, tfm->crt_flags); 350 printk("%s () failed flags=%x\n", e, tfm->crt_flags);
341 goto out; 351 goto out;
342 } 352 }
343 353
344 q = kmap(sg[0].page) + sg[0].offset; 354 q = kmap(sg[0].page) + sg[0].offset;
345 hexdump(q, cipher_tv[i].rlen); 355 hexdump(q, cipher_tv[i].rlen);
346 356
347 printk("%s\n", 357 printk("%s\n",
348 memcmp(q, cipher_tv[i].result, cipher_tv[i].rlen) ? "fail" : 358 memcmp(q, cipher_tv[i].result,
349 "pass"); 359 cipher_tv[i].rlen) ? "fail" : "pass");
350 } 360 }
351 } 361 }
352 362
353 printk("\ntesting %s %s %s across pages (chunking) \n", algo, m, e); 363 printk("\ntesting %s %s %s across pages (chunking)\n", algo, m, e);
354 memset(xbuf, 0, XBUFSIZE); 364 memset(xbuf, 0, XBUFSIZE);
355 365
356 j = 0; 366 j = 0;
357 for (i = 0; i < tcount; i++) { 367 for (i = 0; i < tcount; i++) {
358 if (cipher_tv[i].np) { 368 if (cipher_tv[i].np) {
359 j++; 369 j++;
360 printk("test %u (%d bit key):\n", 370 printk("test %u (%d bit key):\n",
361 j, cipher_tv[i].klen * 8); 371 j, cipher_tv[i].klen * 8);
362 372
363 tfm->crt_flags = 0; 373 tfm->crt_flags = 0;
364 if (cipher_tv[i].wk) 374 if (cipher_tv[i].wk)
365 tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY; 375 tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
366 key = cipher_tv[i].key; 376 key = cipher_tv[i].key;
367 377
368 ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen); 378 ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen);
369 if (ret) { 379 if (ret) {
370 printk("setkey() failed flags=%x\n", tfm->crt_flags); 380 printk("setkey() failed flags=%x\n", tfm->crt_flags);
371 381
372 if (!cipher_tv[i].fail) 382 if (!cipher_tv[i].fail)
373 goto out; 383 goto out;
374 } 384 }
375 385
376 temp = 0; 386 temp = 0;
377 for (k = 0; k < cipher_tv[i].np; k++) { 387 for (k = 0; k < cipher_tv[i].np; k++) {
378 memcpy (&xbuf[IDX[k]], cipher_tv[i].input + temp, 388 memcpy(&xbuf[IDX[k]],
379 cipher_tv[i].tap[k]); 389 cipher_tv[i].input + temp,
390 cipher_tv[i].tap[k]);
380 temp += cipher_tv[i].tap[k]; 391 temp += cipher_tv[i].tap[k];
381 p = &xbuf[IDX[k]]; 392 p = &xbuf[IDX[k]];
382 sg[k].page = virt_to_page (p); 393 sg[k].page = virt_to_page(p);
383 sg[k].offset = offset_in_page (p); 394 sg[k].offset = offset_in_page(p);
384 sg[k].length = cipher_tv[i].tap[k]; 395 sg[k].length = cipher_tv[i].tap[k];
385 } 396 }
386 397
387 if (!mode) { 398 if (!mode) {
388 crypto_cipher_set_iv(tfm, cipher_tv[i].iv, 399 crypto_cipher_set_iv(tfm, cipher_tv[i].iv,
389 crypto_tfm_alg_ivsize (tfm)); 400 crypto_tfm_alg_ivsize(tfm));
390 } 401 }
391 402
392 if (enc) 403 if (enc)
393 ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen); 404 ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen);
394 else 405 else
395 ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen); 406 ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen);
396 407
397 if (ret) { 408 if (ret) {
398 printk("%s () failed flags=%x\n", e, tfm->crt_flags); 409 printk("%s () failed flags=%x\n", e, tfm->crt_flags);
399 goto out; 410 goto out;
@@ -404,9 +415,9 @@ test_cipher(char * algo, int mode, int enc, struct cipher_testvec * template, un
404 printk("page %u\n", k); 415 printk("page %u\n", k);
405 q = kmap(sg[k].page) + sg[k].offset; 416 q = kmap(sg[k].page) + sg[k].offset;
406 hexdump(q, cipher_tv[i].tap[k]); 417 hexdump(q, cipher_tv[i].tap[k]);
407 printk("%s\n", 418 printk("%s\n",
408 memcmp(q, cipher_tv[i].result + temp, 419 memcmp(q, cipher_tv[i].result + temp,
409 cipher_tv[i].tap[k]) ? "fail" : 420 cipher_tv[i].tap[k]) ? "fail" :
410 "pass"); 421 "pass");
411 temp += cipher_tv[i].tap[k]; 422 temp += cipher_tv[i].tap[k];
412 } 423 }
@@ -417,8 +428,169 @@ out:
417 crypto_free_tfm(tfm); 428 crypto_free_tfm(tfm);
418} 429}
419 430
420static void 431static int test_cipher_jiffies(struct crypto_tfm *tfm, int enc, char *p,
421test_deflate(void) 432 int blen, int sec)
433{
434 struct scatterlist sg[8];
435 unsigned long start, end;
436 int bcount;
437 int ret;
438
439 sg[0].page = virt_to_page(p);
440 sg[0].offset = offset_in_page(p);
441 sg[0].length = blen;
442
443 for (start = jiffies, end = start + sec * HZ, bcount = 0;
444 time_before(jiffies, end); bcount++) {
445 if (enc)
446 ret = crypto_cipher_encrypt(tfm, sg, sg, blen);
447 else
448 ret = crypto_cipher_decrypt(tfm, sg, sg, blen);
449
450 if (ret)
451 return ret;
452 }
453
454 printk("%d operations in %d seconds (%ld bytes)\n",
455 bcount, sec, (long)bcount * blen);
456 return 0;
457}
458
459static int test_cipher_cycles(struct crypto_tfm *tfm, int enc, char *p,
460 int blen)
461{
462 struct scatterlist sg[8];
463 unsigned long cycles = 0;
464 int ret = 0;
465 int i;
466
467 sg[0].page = virt_to_page(p);
468 sg[0].offset = offset_in_page(p);
469 sg[0].length = blen;
470
471 local_bh_disable();
472 local_irq_disable();
473
474 /* Warm-up run. */
475 for (i = 0; i < 4; i++) {
476 if (enc)
477 ret = crypto_cipher_encrypt(tfm, sg, sg, blen);
478 else
479 ret = crypto_cipher_decrypt(tfm, sg, sg, blen);
480
481 if (ret)
482 goto out;
483 }
484
485 /* The real thing. */
486 for (i = 0; i < 8; i++) {
487 cycles_t start, end;
488
489 start = get_cycles();
490 if (enc)
491 ret = crypto_cipher_encrypt(tfm, sg, sg, blen);
492 else
493 ret = crypto_cipher_decrypt(tfm, sg, sg, blen);
494 end = get_cycles();
495
496 if (ret)
497 goto out;
498
499 cycles += end - start;
500 }
501
502out:
503 local_irq_enable();
504 local_bh_enable();
505
506 if (ret == 0)
507 printk("1 operation in %lu cycles (%d bytes)\n",
508 (cycles + 4) / 8, blen);
509
510 return ret;
511}
512
513static void test_cipher_speed(char *algo, int mode, int enc, unsigned int sec,
514 struct cipher_testvec *template,
515 unsigned int tcount, struct cipher_speed *speed)
516{
517 unsigned int ret, i, j, iv_len;
518 unsigned char *key, *p, iv[128];
519 struct crypto_tfm *tfm;
520 const char *e, *m;
521
522 if (enc == ENCRYPT)
523 e = "encryption";
524 else
525 e = "decryption";
526 if (mode == MODE_ECB)
527 m = "ECB";
528 else
529 m = "CBC";
530
531 printk("\ntesting speed of %s %s %s\n", algo, m, e);
532
533 if (mode)
534 tfm = crypto_alloc_tfm(algo, 0);
535 else
536 tfm = crypto_alloc_tfm(algo, CRYPTO_TFM_MODE_CBC);
537
538 if (tfm == NULL) {
539 printk("failed to load transform for %s %s\n", algo, m);
540 return;
541 }
542
543 for (i = 0; speed[i].klen != 0; i++) {
544 if ((speed[i].blen + speed[i].klen) > TVMEMSIZE) {
545 printk("template (%u) too big for tvmem (%u)\n",
546 speed[i].blen + speed[i].klen, TVMEMSIZE);
547 goto out;
548 }
549
550 printk("test %u (%d bit key, %d byte blocks): ", i,
551 speed[i].klen * 8, speed[i].blen);
552
553 memset(tvmem, 0xff, speed[i].klen + speed[i].blen);
554
555 /* set key, plain text and IV */
556 key = (unsigned char *)tvmem;
557 for (j = 0; j < tcount; j++) {
558 if (template[j].klen == speed[i].klen) {
559 key = template[j].key;
560 break;
561 }
562 }
563 p = (unsigned char *)tvmem + speed[i].klen;
564
565 ret = crypto_cipher_setkey(tfm, key, speed[i].klen);
566 if (ret) {
567 printk("setkey() failed flags=%x\n", tfm->crt_flags);
568 goto out;
569 }
570
571 if (!mode) {
572 iv_len = crypto_tfm_alg_ivsize(tfm);
573 memset(&iv, 0xff, iv_len);
574 crypto_cipher_set_iv(tfm, iv, iv_len);
575 }
576
577 if (sec)
578 ret = test_cipher_jiffies(tfm, enc, p, speed[i].blen,
579 sec);
580 else
581 ret = test_cipher_cycles(tfm, enc, p, speed[i].blen);
582
583 if (ret) {
584 printk("%s() failed flags=%x\n", e, tfm->crt_flags);
585 break;
586 }
587 }
588
589out:
590 crypto_free_tfm(tfm);
591}
592
593static void test_deflate(void)
422{ 594{
423 unsigned int i; 595 unsigned int i;
424 char result[COMP_BUF_SIZE]; 596 char result[COMP_BUF_SIZE];
@@ -436,7 +608,7 @@ test_deflate(void)
436 } 608 }
437 609
438 memcpy(tvmem, deflate_comp_tv_template, tsize); 610 memcpy(tvmem, deflate_comp_tv_template, tsize);
439 tv = (void *) tvmem; 611 tv = (void *)tvmem;
440 612
441 tfm = crypto_alloc_tfm("deflate", 0); 613 tfm = crypto_alloc_tfm("deflate", 0);
442 if (tfm == NULL) { 614 if (tfm == NULL) {
@@ -446,7 +618,7 @@ test_deflate(void)
446 618
447 for (i = 0; i < DEFLATE_COMP_TEST_VECTORS; i++) { 619 for (i = 0; i < DEFLATE_COMP_TEST_VECTORS; i++) {
448 int ilen, ret, dlen = COMP_BUF_SIZE; 620 int ilen, ret, dlen = COMP_BUF_SIZE;
449 621
450 printk("test %u:\n", i + 1); 622 printk("test %u:\n", i + 1);
451 memset(result, 0, sizeof (result)); 623 memset(result, 0, sizeof (result));
452 624
@@ -473,11 +645,11 @@ test_deflate(void)
473 } 645 }
474 646
475 memcpy(tvmem, deflate_decomp_tv_template, tsize); 647 memcpy(tvmem, deflate_decomp_tv_template, tsize);
476 tv = (void *) tvmem; 648 tv = (void *)tvmem;
477 649
478 for (i = 0; i < DEFLATE_DECOMP_TEST_VECTORS; i++) { 650 for (i = 0; i < DEFLATE_DECOMP_TEST_VECTORS; i++) {
479 int ilen, ret, dlen = COMP_BUF_SIZE; 651 int ilen, ret, dlen = COMP_BUF_SIZE;
480 652
481 printk("test %u:\n", i + 1); 653 printk("test %u:\n", i + 1);
482 memset(result, 0, sizeof (result)); 654 memset(result, 0, sizeof (result));
483 655
@@ -497,8 +669,7 @@ out:
497 crypto_free_tfm(tfm); 669 crypto_free_tfm(tfm);
498} 670}
499 671
500static void 672static void test_crc32c(void)
501test_crc32c(void)
502{ 673{
503#define NUMVEC 6 674#define NUMVEC 6
504#define VECSIZE 40 675#define VECSIZE 40
@@ -511,7 +682,7 @@ test_crc32c(void)
511 0xd579c862, 0xba979ad0, 0x2b29d913 682 0xd579c862, 0xba979ad0, 0x2b29d913
512 }; 683 };
513 static u32 tot_vec_results = 0x24c5d375; 684 static u32 tot_vec_results = 0x24c5d375;
514 685
515 struct scatterlist sg[NUMVEC]; 686 struct scatterlist sg[NUMVEC];
516 struct crypto_tfm *tfm; 687 struct crypto_tfm *tfm;
517 char *fmtdata = "testing crc32c initialized to %08x: %s\n"; 688 char *fmtdata = "testing crc32c initialized to %08x: %s\n";
@@ -525,18 +696,18 @@ test_crc32c(void)
525 printk("failed to load transform for crc32c\n"); 696 printk("failed to load transform for crc32c\n");
526 return; 697 return;
527 } 698 }
528 699
529 crypto_digest_init(tfm); 700 crypto_digest_init(tfm);
530 crypto_digest_final(tfm, (u8*)&crc); 701 crypto_digest_final(tfm, (u8*)&crc);
531 printk(fmtdata, crc, (crc == 0) ? "pass" : "ERROR"); 702 printk(fmtdata, crc, (crc == 0) ? "pass" : "ERROR");
532 703
533 /* 704 /*
534 * stuff test_vec with known values, simple incrementing 705 * stuff test_vec with known values, simple incrementing
535 * byte values. 706 * byte values.
536 */ 707 */
537 b = 0; 708 b = 0;
538 for (i = 0; i < NUMVEC; i++) { 709 for (i = 0; i < NUMVEC; i++) {
539 for (j = 0; j < VECSIZE; j++) 710 for (j = 0; j < VECSIZE; j++)
540 test_vec[i][j] = ++b; 711 test_vec[i][j] = ++b;
541 sg[i].page = virt_to_page(test_vec[i]); 712 sg[i].page = virt_to_page(test_vec[i]);
542 sg[i].offset = offset_in_page(test_vec[i]); 713 sg[i].offset = offset_in_page(test_vec[i]);
@@ -548,11 +719,11 @@ test_crc32c(void)
548 crypto_digest_final(tfm, (u8*)&crc); 719 crypto_digest_final(tfm, (u8*)&crc);
549 printk("testing crc32c setkey returns %08x : %s\n", crc, (crc == (SEEDTESTVAL ^ ~(u32)0)) ? 720 printk("testing crc32c setkey returns %08x : %s\n", crc, (crc == (SEEDTESTVAL ^ ~(u32)0)) ?
550 "pass" : "ERROR"); 721 "pass" : "ERROR");
551 722
552 printk("testing crc32c using update/final:\n"); 723 printk("testing crc32c using update/final:\n");
553 724
554 pass = 1; /* assume all is well */ 725 pass = 1; /* assume all is well */
555 726
556 for (i = 0; i < NUMVEC; i++) { 727 for (i = 0; i < NUMVEC; i++) {
557 seed = ~(u32)0; 728 seed = ~(u32)0;
558 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32)); 729 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
@@ -591,66 +762,64 @@ test_crc32c(void)
591 printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results); 762 printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results);
592 pass = 0; 763 pass = 0;
593 } 764 }
594 765
595 printk("\n%s\n", pass ? "pass" : "ERROR"); 766 printk("\n%s\n", pass ? "pass" : "ERROR");
596 767
597 crypto_free_tfm(tfm); 768 crypto_free_tfm(tfm);
598 printk("crc32c test complete\n"); 769 printk("crc32c test complete\n");
599} 770}
600 771
601static void 772static void test_available(void)
602test_available(void)
603{ 773{
604 char **name = check; 774 char **name = check;
605 775
606 while (*name) { 776 while (*name) {
607 printk("alg %s ", *name); 777 printk("alg %s ", *name);
608 printk((crypto_alg_available(*name, 0)) ? 778 printk((crypto_alg_available(*name, 0)) ?
609 "found\n" : "not found\n"); 779 "found\n" : "not found\n");
610 name++; 780 name++;
611 } 781 }
612} 782}
613 783
614static void 784static void do_test(void)
615do_test(void)
616{ 785{
617 switch (mode) { 786 switch (mode) {
618 787
619 case 0: 788 case 0:
620 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS); 789 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
621 790
622 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS); 791 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
623 792
624 //DES 793 //DES
625 test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS); 794 test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS);
626 test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS); 795 test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS);
627 test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS); 796 test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS);
628 test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS); 797 test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS);
629 798
630 //DES3_EDE 799 //DES3_EDE
631 test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS); 800 test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS);
632 test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS); 801 test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
633 802
634 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS); 803 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
635 804
636 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS); 805 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
637 806
638 //BLOWFISH 807 //BLOWFISH
639 test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS); 808 test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS);
640 test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS); 809 test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS);
641 test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS); 810 test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS);
642 test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS); 811 test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS);
643 812
644 //TWOFISH 813 //TWOFISH
645 test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS); 814 test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS);
646 test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS); 815 test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS);
647 test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS); 816 test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS);
648 test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS); 817 test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS);
649 818
650 //SERPENT 819 //SERPENT
651 test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS); 820 test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS);
652 test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS); 821 test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS);
653 822
654 //TNEPRES 823 //TNEPRES
655 test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS); 824 test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS);
656 test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS); 825 test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS);
@@ -662,7 +831,7 @@ do_test(void)
662 //CAST5 831 //CAST5
663 test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS); 832 test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS);
664 test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS); 833 test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS);
665 834
666 //CAST6 835 //CAST6
667 test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS); 836 test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS);
668 test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS); 837 test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS);
@@ -702,9 +871,9 @@ do_test(void)
702 test_crc32c(); 871 test_crc32c();
703#ifdef CONFIG_CRYPTO_HMAC 872#ifdef CONFIG_CRYPTO_HMAC
704 test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS); 873 test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS);
705 test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS); 874 test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);
706 test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS); 875 test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS);
707#endif 876#endif
708 877
709 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS); 878 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
710 break; 879 break;
@@ -726,17 +895,17 @@ do_test(void)
726 895
727 case 4: 896 case 4:
728 test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS); 897 test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS);
729 test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS); 898 test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
730 break; 899 break;
731 900
732 case 5: 901 case 5:
733 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS); 902 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
734 break; 903 break;
735 904
736 case 6: 905 case 6:
737 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS); 906 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
738 break; 907 break;
739 908
740 case 7: 909 case 7:
741 test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS); 910 test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS);
742 test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS); 911 test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS);
@@ -750,7 +919,7 @@ do_test(void)
750 test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS); 919 test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS);
751 test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS); 920 test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS);
752 break; 921 break;
753 922
754 case 9: 923 case 9:
755 test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS); 924 test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS);
756 test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS); 925 test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS);
@@ -758,13 +927,13 @@ do_test(void)
758 927
759 case 10: 928 case 10:
760 test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS); 929 test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS);
761 test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS); 930 test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS);
762 break; 931 break;
763 932
764 case 11: 933 case 11:
765 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS); 934 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
766 break; 935 break;
767 936
768 case 12: 937 case 12:
769 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS); 938 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
770 break; 939 break;
@@ -852,21 +1021,84 @@ do_test(void)
852 case 100: 1021 case 100:
853 test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS); 1022 test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS);
854 break; 1023 break;
855 1024
856 case 101: 1025 case 101:
857 test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS); 1026 test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);
858 break; 1027 break;
859 1028
860 case 102: 1029 case 102:
861 test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS); 1030 test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS);
862 break; 1031 break;
863 1032
864#endif 1033#endif
865 1034
1035 case 200:
1036 test_cipher_speed("aes", MODE_ECB, ENCRYPT, sec, NULL, 0,
1037 aes_speed_template);
1038 test_cipher_speed("aes", MODE_ECB, DECRYPT, sec, NULL, 0,
1039 aes_speed_template);
1040 test_cipher_speed("aes", MODE_CBC, ENCRYPT, sec, NULL, 0,
1041 aes_speed_template);
1042 test_cipher_speed("aes", MODE_CBC, DECRYPT, sec, NULL, 0,
1043 aes_speed_template);
1044 break;
1045
1046 case 201:
1047 test_cipher_speed("des3_ede", MODE_ECB, ENCRYPT, sec,
1048 des3_ede_enc_tv_template,
1049 DES3_EDE_ENC_TEST_VECTORS,
1050 des3_ede_speed_template);
1051 test_cipher_speed("des3_ede", MODE_ECB, DECRYPT, sec,
1052 des3_ede_dec_tv_template,
1053 DES3_EDE_DEC_TEST_VECTORS,
1054 des3_ede_speed_template);
1055 test_cipher_speed("des3_ede", MODE_CBC, ENCRYPT, sec,
1056 des3_ede_enc_tv_template,
1057 DES3_EDE_ENC_TEST_VECTORS,
1058 des3_ede_speed_template);
1059 test_cipher_speed("des3_ede", MODE_CBC, DECRYPT, sec,
1060 des3_ede_dec_tv_template,
1061 DES3_EDE_DEC_TEST_VECTORS,
1062 des3_ede_speed_template);
1063 break;
1064
1065 case 202:
1066 test_cipher_speed("twofish", MODE_ECB, ENCRYPT, sec, NULL, 0,
1067 twofish_speed_template);
1068 test_cipher_speed("twofish", MODE_ECB, DECRYPT, sec, NULL, 0,
1069 twofish_speed_template);
1070 test_cipher_speed("twofish", MODE_CBC, ENCRYPT, sec, NULL, 0,
1071 twofish_speed_template);
1072 test_cipher_speed("twofish", MODE_CBC, DECRYPT, sec, NULL, 0,
1073 twofish_speed_template);
1074 break;
1075
1076 case 203:
1077 test_cipher_speed("blowfish", MODE_ECB, ENCRYPT, sec, NULL, 0,
1078 blowfish_speed_template);
1079 test_cipher_speed("blowfish", MODE_ECB, DECRYPT, sec, NULL, 0,
1080 blowfish_speed_template);
1081 test_cipher_speed("blowfish", MODE_CBC, ENCRYPT, sec, NULL, 0,
1082 blowfish_speed_template);
1083 test_cipher_speed("blowfish", MODE_CBC, DECRYPT, sec, NULL, 0,
1084 blowfish_speed_template);
1085 break;
1086
1087 case 204:
1088 test_cipher_speed("des", MODE_ECB, ENCRYPT, sec, NULL, 0,
1089 des_speed_template);
1090 test_cipher_speed("des", MODE_ECB, DECRYPT, sec, NULL, 0,
1091 des_speed_template);
1092 test_cipher_speed("des", MODE_CBC, ENCRYPT, sec, NULL, 0,
1093 des_speed_template);
1094 test_cipher_speed("des", MODE_CBC, DECRYPT, sec, NULL, 0,
1095 des_speed_template);
1096 break;
1097
866 case 1000: 1098 case 1000:
867 test_available(); 1099 test_available();
868 break; 1100 break;
869 1101
870 default: 1102 default:
871 /* useful for debugging */ 1103 /* useful for debugging */
872 printk("not testing anything\n"); 1104 printk("not testing anything\n");
@@ -874,8 +1106,7 @@ do_test(void)
874 } 1106 }
875} 1107}
876 1108
877static int __init 1109static int __init init(void)
878init(void)
879{ 1110{
880 tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL); 1111 tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
881 if (tvmem == NULL) 1112 if (tvmem == NULL)
@@ -904,6 +1135,9 @@ module_init(init);
904module_exit(fini); 1135module_exit(fini);
905 1136
906module_param(mode, int, 0); 1137module_param(mode, int, 0);
1138module_param(sec, uint, 0);
1139MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
1140 "(defaults to zero which uses CPU cycles instead)");
907 1141
908MODULE_LICENSE("GPL"); 1142MODULE_LICENSE("GPL");
909MODULE_DESCRIPTION("Quick & dirty crypto testing module"); 1143MODULE_DESCRIPTION("Quick & dirty crypto testing module");
diff --git a/crypto/tcrypt.h b/crypto/tcrypt.h
index a3097afae593..c01a0ce9b40a 100644
--- a/crypto/tcrypt.h
+++ b/crypto/tcrypt.h
@@ -9,10 +9,11 @@
9 * 9 *
10 * This program is free software; you can redistribute it and/or modify it 10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the Free 11 * under the terms of the GNU General Public License as published by the Free
12 * Software Foundation; either version 2 of the License, or (at your option) 12 * Software Foundation; either version 2 of the License, or (at your option)
13 * any later version. 13 * any later version.
14 * 14 *
15 * 14 - 09 - 2003 Changes by Kartikey Mahendra Bhatt 15 * 2004-08-09 Cipher speed tests by Reyk Floeter <reyk@vantronix.net>
16 * 2003-09-14 Changes by Kartikey Mahendra Bhatt
16 * 17 *
17 */ 18 */
18#ifndef _CRYPTO_TCRYPT_H 19#ifndef _CRYPTO_TCRYPT_H
@@ -29,19 +30,19 @@ struct hash_testvec {
29 unsigned char psize; 30 unsigned char psize;
30 char digest[MAX_DIGEST_SIZE]; 31 char digest[MAX_DIGEST_SIZE];
31 unsigned char np; 32 unsigned char np;
32 unsigned char tap[MAX_TAP]; 33 unsigned char tap[MAX_TAP];
33 char key[128]; /* only used with keyed hash algorithms */ 34 char key[128]; /* only used with keyed hash algorithms */
34 unsigned char ksize; 35 unsigned char ksize;
35}; 36};
36 37
37struct hmac_testvec { 38struct hmac_testvec {
38 char key[128]; 39 char key[128];
39 unsigned char ksize; 40 unsigned char ksize;
40 char plaintext[128]; 41 char plaintext[128];
41 unsigned char psize; 42 unsigned char psize;
42 char digest[MAX_DIGEST_SIZE]; 43 char digest[MAX_DIGEST_SIZE];
43 unsigned char np; 44 unsigned char np;
44 unsigned char tap[MAX_TAP]; 45 unsigned char tap[MAX_TAP];
45}; 46};
46 47
47struct cipher_testvec { 48struct cipher_testvec {
@@ -55,7 +56,12 @@ struct cipher_testvec {
55 char result[48]; 56 char result[48];
56 unsigned char rlen; 57 unsigned char rlen;
57 int np; 58 int np;
58 unsigned char tap[MAX_TAP]; 59 unsigned char tap[MAX_TAP];
60};
61
62struct cipher_speed {
63 unsigned char klen;
64 unsigned int blen;
59}; 65};
60 66
61/* 67/*
@@ -155,7 +161,7 @@ static struct hash_testvec md5_tv_template[] = {
155#define SHA1_TEST_VECTORS 2 161#define SHA1_TEST_VECTORS 2
156 162
157static struct hash_testvec sha1_tv_template[] = { 163static struct hash_testvec sha1_tv_template[] = {
158 { 164 {
159 .plaintext = "abc", 165 .plaintext = "abc",
160 .psize = 3, 166 .psize = 3,
161 .digest = { 0xa9, 0x99, 0x3e, 0x36, 0x47, 0x06, 0x81, 0x6a, 0xba, 0x3e, 167 .digest = { 0xa9, 0x99, 0x3e, 0x36, 0x47, 0x06, 0x81, 0x6a, 0xba, 0x3e,
@@ -175,8 +181,8 @@ static struct hash_testvec sha1_tv_template[] = {
175 */ 181 */
176#define SHA256_TEST_VECTORS 2 182#define SHA256_TEST_VECTORS 2
177 183
178static struct hash_testvec sha256_tv_template[] = { 184static struct hash_testvec sha256_tv_template[] = {
179 { 185 {
180 .plaintext = "abc", 186 .plaintext = "abc",
181 .psize = 3, 187 .psize = 3,
182 .digest = { 0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea, 188 .digest = { 0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea,
@@ -201,7 +207,7 @@ static struct hash_testvec sha256_tv_template[] = {
201#define SHA384_TEST_VECTORS 4 207#define SHA384_TEST_VECTORS 4
202 208
203static struct hash_testvec sha384_tv_template[] = { 209static struct hash_testvec sha384_tv_template[] = {
204 { 210 {
205 .plaintext= "abc", 211 .plaintext= "abc",
206 .psize = 3, 212 .psize = 3,
207 .digest = { 0xcb, 0x00, 0x75, 0x3f, 0x45, 0xa3, 0x5e, 0x8b, 213 .digest = { 0xcb, 0x00, 0x75, 0x3f, 0x45, 0xa3, 0x5e, 0x8b,
@@ -221,7 +227,7 @@ static struct hash_testvec sha384_tv_template[] = {
221 0x5f, 0xe9, 0x5b, 0x1f, 0xe3, 0xc8, 0x45, 0x2b}, 227 0x5f, 0xe9, 0x5b, 0x1f, 0xe3, 0xc8, 0x45, 0x2b},
222 }, { 228 }, {
223 .plaintext = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn" 229 .plaintext = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
224 "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu", 230 "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
225 .psize = 112, 231 .psize = 112,
226 .digest = { 0x09, 0x33, 0x0c, 0x33, 0xf7, 0x11, 0x47, 0xe8, 232 .digest = { 0x09, 0x33, 0x0c, 0x33, 0xf7, 0x11, 0x47, 0xe8,
227 0x3d, 0x19, 0x2f, 0xc7, 0x82, 0xcd, 0x1b, 0x47, 233 0x3d, 0x19, 0x2f, 0xc7, 0x82, 0xcd, 0x1b, 0x47,
@@ -250,7 +256,7 @@ static struct hash_testvec sha384_tv_template[] = {
250#define SHA512_TEST_VECTORS 4 256#define SHA512_TEST_VECTORS 4
251 257
252static struct hash_testvec sha512_tv_template[] = { 258static struct hash_testvec sha512_tv_template[] = {
253 { 259 {
254 .plaintext = "abc", 260 .plaintext = "abc",
255 .psize = 3, 261 .psize = 3,
256 .digest = { 0xdd, 0xaf, 0x35, 0xa1, 0x93, 0x61, 0x7a, 0xba, 262 .digest = { 0xdd, 0xaf, 0x35, 0xa1, 0x93, 0x61, 0x7a, 0xba,
@@ -303,14 +309,14 @@ static struct hash_testvec sha512_tv_template[] = {
303 309
304 310
305/* 311/*
306 * WHIRLPOOL test vectors from Whirlpool package 312 * WHIRLPOOL test vectors from Whirlpool package
307 * by Vincent Rijmen and Paulo S. L. M. Barreto as part of the NESSIE 313 * by Vincent Rijmen and Paulo S. L. M. Barreto as part of the NESSIE
308 * submission 314 * submission
309 */ 315 */
310#define WP512_TEST_VECTORS 8 316#define WP512_TEST_VECTORS 8
311 317
312static struct hash_testvec wp512_tv_template[] = { 318static struct hash_testvec wp512_tv_template[] = {
313 { 319 {
314 .plaintext = "", 320 .plaintext = "",
315 .psize = 0, 321 .psize = 0,
316 .digest = { 0x19, 0xFA, 0x61, 0xD7, 0x55, 0x22, 0xA4, 0x66, 322 .digest = { 0x19, 0xFA, 0x61, 0xD7, 0x55, 0x22, 0xA4, 0x66,
@@ -348,13 +354,13 @@ static struct hash_testvec wp512_tv_template[] = {
348 }, { 354 }, {
349 .plaintext = "message digest", 355 .plaintext = "message digest",
350 .psize = 14, 356 .psize = 14,
351 .digest = { 0x37, 0x8C, 0x84, 0xA4, 0x12, 0x6E, 0x2D, 0xC6, 357 .digest = { 0x37, 0x8C, 0x84, 0xA4, 0x12, 0x6E, 0x2D, 0xC6,
352 0xE5, 0x6D, 0xCC, 0x74, 0x58, 0x37, 0x7A, 0xAC, 358 0xE5, 0x6D, 0xCC, 0x74, 0x58, 0x37, 0x7A, 0xAC,
353 0x83, 0x8D, 0x00, 0x03, 0x22, 0x30, 0xF5, 0x3C, 359 0x83, 0x8D, 0x00, 0x03, 0x22, 0x30, 0xF5, 0x3C,
354 0xE1, 0xF5, 0x70, 0x0C, 0x0F, 0xFB, 0x4D, 0x3B, 360 0xE1, 0xF5, 0x70, 0x0C, 0x0F, 0xFB, 0x4D, 0x3B,
355 0x84, 0x21, 0x55, 0x76, 0x59, 0xEF, 0x55, 0xC1, 361 0x84, 0x21, 0x55, 0x76, 0x59, 0xEF, 0x55, 0xC1,
356 0x06, 0xB4, 0xB5, 0x2A, 0xC5, 0xA4, 0xAA, 0xA6, 362 0x06, 0xB4, 0xB5, 0x2A, 0xC5, 0xA4, 0xAA, 0xA6,
357 0x92, 0xED, 0x92, 0x00, 0x52, 0x83, 0x8F, 0x33, 363 0x92, 0xED, 0x92, 0x00, 0x52, 0x83, 0x8F, 0x33,
358 0x62, 0xE8, 0x6D, 0xBD, 0x37, 0xA8, 0x90, 0x3E }, 364 0x62, 0xE8, 0x6D, 0xBD, 0x37, 0xA8, 0x90, 0x3E },
359 }, { 365 }, {
360 .plaintext = "abcdefghijklmnopqrstuvwxyz", 366 .plaintext = "abcdefghijklmnopqrstuvwxyz",
@@ -394,7 +400,7 @@ static struct hash_testvec wp512_tv_template[] = {
394 }, { 400 }, {
395 .plaintext = "abcdbcdecdefdefgefghfghighijhijk", 401 .plaintext = "abcdbcdecdefdefgefghfghighijhijk",
396 .psize = 32, 402 .psize = 32,
397 .digest = { 0x2A, 0x98, 0x7E, 0xA4, 0x0F, 0x91, 0x70, 0x61, 403 .digest = { 0x2A, 0x98, 0x7E, 0xA4, 0x0F, 0x91, 0x70, 0x61,
398 0xF5, 0xD6, 0xF0, 0xA0, 0xE4, 0x64, 0x4F, 0x48, 404 0xF5, 0xD6, 0xF0, 0xA0, 0xE4, 0x64, 0x4F, 0x48,
399 0x8A, 0x7A, 0x5A, 0x52, 0xDE, 0xEE, 0x65, 0x62, 405 0x8A, 0x7A, 0x5A, 0x52, 0xDE, 0xEE, 0x65, 0x62,
400 0x07, 0xC5, 0x62, 0xF9, 0x88, 0xE9, 0x5C, 0x69, 406 0x07, 0xC5, 0x62, 0xF9, 0x88, 0xE9, 0x5C, 0x69,
@@ -408,7 +414,7 @@ static struct hash_testvec wp512_tv_template[] = {
408#define WP384_TEST_VECTORS 8 414#define WP384_TEST_VECTORS 8
409 415
410static struct hash_testvec wp384_tv_template[] = { 416static struct hash_testvec wp384_tv_template[] = {
411 { 417 {
412 .plaintext = "", 418 .plaintext = "",
413 .psize = 0, 419 .psize = 0,
414 .digest = { 0x19, 0xFA, 0x61, 0xD7, 0x55, 0x22, 0xA4, 0x66, 420 .digest = { 0x19, 0xFA, 0x61, 0xD7, 0x55, 0x22, 0xA4, 0x66,
@@ -440,11 +446,11 @@ static struct hash_testvec wp384_tv_template[] = {
440 }, { 446 }, {
441 .plaintext = "message digest", 447 .plaintext = "message digest",
442 .psize = 14, 448 .psize = 14,
443 .digest = { 0x37, 0x8C, 0x84, 0xA4, 0x12, 0x6E, 0x2D, 0xC6, 449 .digest = { 0x37, 0x8C, 0x84, 0xA4, 0x12, 0x6E, 0x2D, 0xC6,
444 0xE5, 0x6D, 0xCC, 0x74, 0x58, 0x37, 0x7A, 0xAC, 450 0xE5, 0x6D, 0xCC, 0x74, 0x58, 0x37, 0x7A, 0xAC,
445 0x83, 0x8D, 0x00, 0x03, 0x22, 0x30, 0xF5, 0x3C, 451 0x83, 0x8D, 0x00, 0x03, 0x22, 0x30, 0xF5, 0x3C,
446 0xE1, 0xF5, 0x70, 0x0C, 0x0F, 0xFB, 0x4D, 0x3B, 452 0xE1, 0xF5, 0x70, 0x0C, 0x0F, 0xFB, 0x4D, 0x3B,
447 0x84, 0x21, 0x55, 0x76, 0x59, 0xEF, 0x55, 0xC1, 453 0x84, 0x21, 0x55, 0x76, 0x59, 0xEF, 0x55, 0xC1,
448 0x06, 0xB4, 0xB5, 0x2A, 0xC5, 0xA4, 0xAA, 0xA6 }, 454 0x06, 0xB4, 0xB5, 0x2A, 0xC5, 0xA4, 0xAA, 0xA6 },
449 }, { 455 }, {
450 .plaintext = "abcdefghijklmnopqrstuvwxyz", 456 .plaintext = "abcdefghijklmnopqrstuvwxyz",
@@ -478,7 +484,7 @@ static struct hash_testvec wp384_tv_template[] = {
478 }, { 484 }, {
479 .plaintext = "abcdbcdecdefdefgefghfghighijhijk", 485 .plaintext = "abcdbcdecdefdefgefghfghighijhijk",
480 .psize = 32, 486 .psize = 32,
481 .digest = { 0x2A, 0x98, 0x7E, 0xA4, 0x0F, 0x91, 0x70, 0x61, 487 .digest = { 0x2A, 0x98, 0x7E, 0xA4, 0x0F, 0x91, 0x70, 0x61,
482 0xF5, 0xD6, 0xF0, 0xA0, 0xE4, 0x64, 0x4F, 0x48, 488 0xF5, 0xD6, 0xF0, 0xA0, 0xE4, 0x64, 0x4F, 0x48,
483 0x8A, 0x7A, 0x5A, 0x52, 0xDE, 0xEE, 0x65, 0x62, 489 0x8A, 0x7A, 0x5A, 0x52, 0xDE, 0xEE, 0x65, 0x62,
484 0x07, 0xC5, 0x62, 0xF9, 0x88, 0xE9, 0x5C, 0x69, 490 0x07, 0xC5, 0x62, 0xF9, 0x88, 0xE9, 0x5C, 0x69,
@@ -490,7 +496,7 @@ static struct hash_testvec wp384_tv_template[] = {
490#define WP256_TEST_VECTORS 8 496#define WP256_TEST_VECTORS 8
491 497
492static struct hash_testvec wp256_tv_template[] = { 498static struct hash_testvec wp256_tv_template[] = {
493 { 499 {
494 .plaintext = "", 500 .plaintext = "",
495 .psize = 0, 501 .psize = 0,
496 .digest = { 0x19, 0xFA, 0x61, 0xD7, 0x55, 0x22, 0xA4, 0x66, 502 .digest = { 0x19, 0xFA, 0x61, 0xD7, 0x55, 0x22, 0xA4, 0x66,
@@ -516,9 +522,9 @@ static struct hash_testvec wp256_tv_template[] = {
516 }, { 522 }, {
517 .plaintext = "message digest", 523 .plaintext = "message digest",
518 .psize = 14, 524 .psize = 14,
519 .digest = { 0x37, 0x8C, 0x84, 0xA4, 0x12, 0x6E, 0x2D, 0xC6, 525 .digest = { 0x37, 0x8C, 0x84, 0xA4, 0x12, 0x6E, 0x2D, 0xC6,
520 0xE5, 0x6D, 0xCC, 0x74, 0x58, 0x37, 0x7A, 0xAC, 526 0xE5, 0x6D, 0xCC, 0x74, 0x58, 0x37, 0x7A, 0xAC,
521 0x83, 0x8D, 0x00, 0x03, 0x22, 0x30, 0xF5, 0x3C, 527 0x83, 0x8D, 0x00, 0x03, 0x22, 0x30, 0xF5, 0x3C,
522 0xE1, 0xF5, 0x70, 0x0C, 0x0F, 0xFB, 0x4D, 0x3B }, 528 0xE1, 0xF5, 0x70, 0x0C, 0x0F, 0xFB, 0x4D, 0x3B },
523 }, { 529 }, {
524 .plaintext = "abcdefghijklmnopqrstuvwxyz", 530 .plaintext = "abcdefghijklmnopqrstuvwxyz",
@@ -546,7 +552,7 @@ static struct hash_testvec wp256_tv_template[] = {
546 }, { 552 }, {
547 .plaintext = "abcdbcdecdefdefgefghfghighijhijk", 553 .plaintext = "abcdbcdecdefdefgefghfghighijhijk",
548 .psize = 32, 554 .psize = 32,
549 .digest = { 0x2A, 0x98, 0x7E, 0xA4, 0x0F, 0x91, 0x70, 0x61, 555 .digest = { 0x2A, 0x98, 0x7E, 0xA4, 0x0F, 0x91, 0x70, 0x61,
550 0xF5, 0xD6, 0xF0, 0xA0, 0xE4, 0x64, 0x4F, 0x48, 556 0xF5, 0xD6, 0xF0, 0xA0, 0xE4, 0x64, 0x4F, 0x48,
551 0x8A, 0x7A, 0x5A, 0x52, 0xDE, 0xEE, 0x65, 0x62, 557 0x8A, 0x7A, 0x5A, 0x52, 0xDE, 0xEE, 0x65, 0x62,
552 0x07, 0xC5, 0x62, 0xF9, 0x88, 0xE9, 0x5C, 0x69 }, 558 0x07, 0xC5, 0x62, 0xF9, 0x88, 0xE9, 0x5C, 0x69 },
@@ -554,7 +560,7 @@ static struct hash_testvec wp256_tv_template[] = {
554}; 560};
555 561
556/* 562/*
557 * TIGER test vectors from Tiger website 563 * TIGER test vectors from Tiger website
558 */ 564 */
559#define TGR192_TEST_VECTORS 6 565#define TGR192_TEST_VECTORS 6
560 566
@@ -693,7 +699,7 @@ static struct hash_testvec tgr128_tv_template[] = {
693#define HMAC_MD5_TEST_VECTORS 7 699#define HMAC_MD5_TEST_VECTORS 7
694 700
695static struct hmac_testvec hmac_md5_tv_template[] = 701static struct hmac_testvec hmac_md5_tv_template[] =
696{ 702{
697 { 703 {
698 .key = { [0 ... 15] = 0x0b }, 704 .key = { [0 ... 15] = 0x0b },
699 .ksize = 16, 705 .ksize = 16,
@@ -756,7 +762,7 @@ static struct hmac_testvec hmac_md5_tv_template[] =
756 */ 762 */
757#define HMAC_SHA1_TEST_VECTORS 7 763#define HMAC_SHA1_TEST_VECTORS 7
758 764
759static struct hmac_testvec hmac_sha1_tv_template[] = { 765static struct hmac_testvec hmac_sha1_tv_template[] = {
760 { 766 {
761 .key = { [0 ... 19] = 0x0b }, 767 .key = { [0 ... 19] = 0x0b },
762 .ksize = 20, 768 .ksize = 20,
@@ -766,11 +772,11 @@ static struct hmac_testvec hmac_sha1_tv_template[] = {
766 0xe2, 0x8b, 0xc0, 0xb6, 0xfb, 0x37, 0x8c, 0x8e, 0xf1, 772 0xe2, 0x8b, 0xc0, 0xb6, 0xfb, 0x37, 0x8c, 0x8e, 0xf1,
767 0x46, 0xbe }, 773 0x46, 0xbe },
768 }, { 774 }, {
769 .key = { 'J', 'e', 'f', 'e' }, 775 .key = { 'J', 'e', 'f', 'e' },
770 .ksize = 4, 776 .ksize = 4,
771 .plaintext = "what do ya want for nothing?", 777 .plaintext = "what do ya want for nothing?",
772 .psize = 28, 778 .psize = 28,
773 .digest = { 0xef, 0xfc, 0xdf, 0x6a, 0xe5, 0xeb, 0x2f, 0xa2, 0xd2, 0x74, 779 .digest = { 0xef, 0xfc, 0xdf, 0x6a, 0xe5, 0xeb, 0x2f, 0xa2, 0xd2, 0x74,
774 0x16, 0xd5, 0xf1, 0x84, 0xdf, 0x9c, 0x25, 0x9a, 0x7c, 0x79 }, 780 0x16, 0xd5, 0xf1, 0x84, 0xdf, 0x9c, 0x25, 0x9a, 0x7c, 0x79 },
775 .np = 2, 781 .np = 2,
776 .tap = { 14, 14 } 782 .tap = { 14, 14 }
@@ -779,30 +785,30 @@ static struct hmac_testvec hmac_sha1_tv_template[] = {
779 .ksize = 20, 785 .ksize = 20,
780 .plaintext = { [0 ... 49] = 0xdd }, 786 .plaintext = { [0 ... 49] = 0xdd },
781 .psize = 50, 787 .psize = 50,
782 .digest = { 0x12, 0x5d, 0x73, 0x42, 0xb9, 0xac, 0x11, 0xcd, 0x91, 0xa3, 788 .digest = { 0x12, 0x5d, 0x73, 0x42, 0xb9, 0xac, 0x11, 0xcd, 0x91, 0xa3,
783 0x9a, 0xf4, 0x8a, 0xa1, 0x7b, 0x4f, 0x63, 0xf1, 0x75, 0xd3 }, 789 0x9a, 0xf4, 0x8a, 0xa1, 0x7b, 0x4f, 0x63, 0xf1, 0x75, 0xd3 },
784 }, { 790 }, {
785 .key = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 791 .key = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
786 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 792 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
787 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19 }, 793 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19 },
788 .ksize = 25, 794 .ksize = 25,
789 .plaintext = { [0 ... 49] = 0xcd }, 795 .plaintext = { [0 ... 49] = 0xcd },
790 .psize = 50, 796 .psize = 50,
791 .digest = { 0x4c, 0x90, 0x07, 0xf4, 0x02, 0x62, 0x50, 0xc6, 0xbc, 0x84, 797 .digest = { 0x4c, 0x90, 0x07, 0xf4, 0x02, 0x62, 0x50, 0xc6, 0xbc, 0x84,
792 0x14, 0xf9, 0xbf, 0x50, 0xc8, 0x6c, 0x2d, 0x72, 0x35, 0xda }, 798 0x14, 0xf9, 0xbf, 0x50, 0xc8, 0x6c, 0x2d, 0x72, 0x35, 0xda },
793 }, { 799 }, {
794 .key = { [0 ... 19] = 0x0c }, 800 .key = { [0 ... 19] = 0x0c },
795 .ksize = 20, 801 .ksize = 20,
796 .plaintext = "Test With Truncation", 802 .plaintext = "Test With Truncation",
797 .psize = 20, 803 .psize = 20,
798 .digest = { 0x4c, 0x1a, 0x03, 0x42, 0x4b, 0x55, 0xe0, 0x7f, 0xe7, 0xf2, 804 .digest = { 0x4c, 0x1a, 0x03, 0x42, 0x4b, 0x55, 0xe0, 0x7f, 0xe7, 0xf2,
799 0x7b, 0xe1, 0xd5, 0x8b, 0xb9, 0x32, 0x4a, 0x9a, 0x5a, 0x04 }, 805 0x7b, 0xe1, 0xd5, 0x8b, 0xb9, 0x32, 0x4a, 0x9a, 0x5a, 0x04 },
800 }, { 806 }, {
801 .key = { [0 ... 79] = 0xaa }, 807 .key = { [0 ... 79] = 0xaa },
802 .ksize = 80, 808 .ksize = 80,
803 .plaintext = "Test Using Larger Than Block-Size Key - Hash Key First", 809 .plaintext = "Test Using Larger Than Block-Size Key - Hash Key First",
804 .psize = 54, 810 .psize = 54,
805 .digest = { 0xaa, 0x4a, 0xe5, 0xe1, 0x52, 0x72, 0xd0, 0x0e, 0x95, 0x70, 811 .digest = { 0xaa, 0x4a, 0xe5, 0xe1, 0x52, 0x72, 0xd0, 0x0e, 0x95, 0x70,
806 0x56, 0x37, 0xce, 0x8a, 0x3b, 0x55, 0xed, 0x40, 0x21, 0x12 }, 812 0x56, 0x37, 0xce, 0x8a, 0x3b, 0x55, 0xed, 0x40, 0x21, 0x12 },
807 }, { 813 }, {
808 .key = { [0 ... 79] = 0xaa }, 814 .key = { [0 ... 79] = 0xaa },
@@ -810,7 +816,7 @@ static struct hmac_testvec hmac_sha1_tv_template[] = {
810 .plaintext = "Test Using Larger Than Block-Size Key and Larger Than One " 816 .plaintext = "Test Using Larger Than Block-Size Key and Larger Than One "
811 "Block-Size Data", 817 "Block-Size Data",
812 .psize = 73, 818 .psize = 73,
813 .digest = { 0xe8, 0xe9, 0x9d, 0x0f, 0x45, 0x23, 0x7d, 0x78, 0x6d, 0x6b, 819 .digest = { 0xe8, 0xe9, 0x9d, 0x0f, 0x45, 0x23, 0x7d, 0x78, 0x6d, 0x6b,
814 0xba, 0xa7, 0x96, 0x5c, 0x78, 0x08, 0xbb, 0xff, 0x1a, 0x91 }, 820 0xba, 0xa7, 0x96, 0x5c, 0x78, 0x08, 0xbb, 0xff, 0x1a, 0x91 },
815 }, 821 },
816}; 822};
@@ -1011,7 +1017,7 @@ static struct cipher_testvec des_enc_tv_template[] = {
1011 0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b }, 1017 0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b },
1012 .rlen = 32, 1018 .rlen = 32,
1013 .np = 3, 1019 .np = 3,
1014 .tap = { 14, 10, 8 } 1020 .tap = { 14, 10, 8 }
1015 }, { 1021 }, {
1016 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef }, 1022 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1017 .klen = 8, 1023 .klen = 8,
@@ -1024,7 +1030,7 @@ static struct cipher_testvec des_enc_tv_template[] = {
1024 0xb4, 0x99, 0x26, 0xf7, 0x1f, 0xe1, 0xd4, 0x90 }, 1030 0xb4, 0x99, 0x26, 0xf7, 0x1f, 0xe1, 0xd4, 0x90 },
1025 .rlen = 24, 1031 .rlen = 24,
1026 .np = 4, 1032 .np = 4,
1027 .tap = { 2, 1, 3, 18 } 1033 .tap = { 2, 1, 3, 18 }
1028 }, { 1034 }, {
1029 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef }, 1035 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1030 .klen = 8, 1036 .klen = 8,
@@ -1035,7 +1041,7 @@ static struct cipher_testvec des_enc_tv_template[] = {
1035 0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b }, 1041 0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b },
1036 .rlen = 16, 1042 .rlen = 16,
1037 .np = 5, 1043 .np = 5,
1038 .tap = { 2, 2, 2, 2, 8 } 1044 .tap = { 2, 2, 2, 2, 8 }
1039 }, { 1045 }, {
1040 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef }, 1046 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1041 .klen = 8, 1047 .klen = 8,
@@ -1044,7 +1050,7 @@ static struct cipher_testvec des_enc_tv_template[] = {
1044 .result = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d }, 1050 .result = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d },
1045 .rlen = 8, 1051 .rlen = 8,
1046 .np = 8, 1052 .np = 8,
1047 .tap = { 1, 1, 1, 1, 1, 1, 1, 1 } 1053 .tap = { 1, 1, 1, 1, 1, 1, 1, 1 }
1048 }, 1054 },
1049}; 1055};
1050 1056
@@ -1057,7 +1063,7 @@ static struct cipher_testvec des_dec_tv_template[] = {
1057 .result = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7 }, 1063 .result = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7 },
1058 .rlen = 8, 1064 .rlen = 8,
1059 }, { /* Sbox test from NBS */ 1065 }, { /* Sbox test from NBS */
1060 .key = { 0x7c, 0xa1, 0x10, 0x45, 0x4a, 0x1a, 0x6e, 0x57 }, 1066 .key = { 0x7c, 0xa1, 0x10, 0x45, 0x4a, 0x1a, 0x6e, 0x57 },
1061 .klen = 8, 1067 .klen = 8,
1062 .input = { 0x69, 0x0f, 0x5b, 0x0d, 0x9a, 0x26, 0x93, 0x9b }, 1068 .input = { 0x69, 0x0f, 0x5b, 0x0d, 0x9a, 0x26, 0x93, 0x9b },
1063 .ilen = 8, 1069 .ilen = 8,
@@ -1092,19 +1098,19 @@ static struct cipher_testvec des_cbc_enc_tv_template[] = {
1092 { /* From OpenSSL */ 1098 { /* From OpenSSL */
1093 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef}, 1099 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
1094 .klen = 8, 1100 .klen = 8,
1095 .iv = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10}, 1101 .iv = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
1096 .input = { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20, 1102 .input = { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
1097 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74, 1103 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
1098 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20 }, 1104 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20 },
1099 .ilen = 24, 1105 .ilen = 24,
1100 .result = { 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4, 1106 .result = { 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4,
1101 0xac, 0xd8, 0xae, 0xfd, 0xdf, 0xd8, 0xa1, 0xeb, 1107 0xac, 0xd8, 0xae, 0xfd, 0xdf, 0xd8, 0xa1, 0xeb,
1102 0x46, 0x8e, 0x91, 0x15, 0x78, 0x88, 0xba, 0x68 }, 1108 0x46, 0x8e, 0x91, 0x15, 0x78, 0x88, 0xba, 0x68 },
1103 .rlen = 24, 1109 .rlen = 24,
1104 }, { /* FIPS Pub 81 */ 1110 }, { /* FIPS Pub 81 */
1105 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef }, 1111 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1106 .klen = 8, 1112 .klen = 8,
1107 .iv = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef }, 1113 .iv = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef },
1108 .input = { 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74 }, 1114 .input = { 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74 },
1109 .ilen = 8, 1115 .ilen = 8,
1110 .result = { 0xe5, 0xc7, 0xcd, 0xde, 0x87, 0x2b, 0xf2, 0x7c }, 1116 .result = { 0xe5, 0xc7, 0xcd, 0xde, 0x87, 0x2b, 0xf2, 0x7c },
@@ -1117,7 +1123,7 @@ static struct cipher_testvec des_cbc_enc_tv_template[] = {
1117 .ilen = 8, 1123 .ilen = 8,
1118 .result = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f }, 1124 .result = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
1119 .rlen = 8, 1125 .rlen = 8,
1120 }, { 1126 }, {
1121 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef }, 1127 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1122 .klen = 8, 1128 .klen = 8,
1123 .iv = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f }, 1129 .iv = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
@@ -1125,18 +1131,18 @@ static struct cipher_testvec des_cbc_enc_tv_template[] = {
1125 .ilen = 8, 1131 .ilen = 8,
1126 .result = { 0x68, 0x37, 0x88, 0x49, 0x9a, 0x7c, 0x05, 0xf6 }, 1132 .result = { 0x68, 0x37, 0x88, 0x49, 0x9a, 0x7c, 0x05, 0xf6 },
1127 .rlen = 8, 1133 .rlen = 8,
1128 }, { /* Copy of openssl vector for chunk testing */ 1134 }, { /* Copy of openssl vector for chunk testing */
1129 /* From OpenSSL */ 1135 /* From OpenSSL */
1130 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef}, 1136 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
1131 .klen = 8, 1137 .klen = 8,
1132 .iv = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10}, 1138 .iv = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
1133 .input = { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20, 1139 .input = { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
1134 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74, 1140 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
1135 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20 }, 1141 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20 },
1136 .ilen = 24, 1142 .ilen = 24,
1137 .result = { 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4, 1143 .result = { 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4,
1138 0xac, 0xd8, 0xae, 0xfd, 0xdf, 0xd8, 0xa1, 0xeb, 1144 0xac, 0xd8, 0xae, 0xfd, 0xdf, 0xd8, 0xa1, 0xeb,
1139 0x46, 0x8e, 0x91, 0x15, 0x78, 0x88, 0xba, 0x68 }, 1145 0x46, 0x8e, 0x91, 0x15, 0x78, 0x88, 0xba, 0x68 },
1140 .rlen = 24, 1146 .rlen = 24,
1141 .np = 2, 1147 .np = 2,
1142 .tap = { 13, 11 } 1148 .tap = { 13, 11 }
@@ -1155,24 +1161,24 @@ static struct cipher_testvec des_cbc_dec_tv_template[] = {
1155 }, { 1161 }, {
1156 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef }, 1162 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1157 .klen = 8, 1163 .klen = 8,
1158 .iv = { 0xe5, 0xc7, 0xcd, 0xde, 0x87, 0x2b, 0xf2, 0x7c }, 1164 .iv = { 0xe5, 0xc7, 0xcd, 0xde, 0x87, 0x2b, 0xf2, 0x7c },
1159 .input = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f }, 1165 .input = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
1160 .ilen = 8, 1166 .ilen = 8,
1161 .result = { 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20 }, 1167 .result = { 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20 },
1162 .rlen = 8, 1168 .rlen = 8,
1163 }, { 1169 }, {
1164 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef }, 1170 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1165 .klen = 8, 1171 .klen = 8,
1166 .iv = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f }, 1172 .iv = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
1167 .input = { 0x68, 0x37, 0x88, 0x49, 0x9a, 0x7c, 0x05, 0xf6 }, 1173 .input = { 0x68, 0x37, 0x88, 0x49, 0x9a, 0x7c, 0x05, 0xf6 },
1168 .ilen = 8, 1174 .ilen = 8,
1169 .result = { 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20 }, 1175 .result = { 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20 },
1170 .rlen = 8, 1176 .rlen = 8,
1171 }, { /* Copy of above, for chunk testing */ 1177 }, { /* Copy of above, for chunk testing */
1172 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef }, 1178 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1173 .klen = 8, 1179 .klen = 8,
1174 .iv = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f }, 1180 .iv = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
1175 .input = { 0x68, 0x37, 0x88, 0x49, 0x9a, 0x7c, 0x05, 0xf6 }, 1181 .input = { 0x68, 0x37, 0x88, 0x49, 0x9a, 0x7c, 0x05, 0xf6 },
1176 .ilen = 8, 1182 .ilen = 8,
1177 .result = { 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20 }, 1183 .result = { 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20 },
1178 .rlen = 8, 1184 .rlen = 8,
@@ -1276,7 +1282,7 @@ static struct cipher_testvec bf_enc_tv_template[] = {
1276 .ilen = 8, 1282 .ilen = 8,
1277 .result = { 0xe8, 0x7a, 0x24, 0x4e, 0x2c, 0xc8, 0x5e, 0x82 }, 1283 .result = { 0xe8, 0x7a, 0x24, 0x4e, 0x2c, 0xc8, 0x5e, 0x82 },
1278 .rlen = 8, 1284 .rlen = 8,
1279 }, { /* Vary the keylength... */ 1285 }, { /* Vary the keylength... */
1280 .key = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87, 1286 .key = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
1281 0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f }, 1287 0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f },
1282 .klen = 16, 1288 .klen = 16,
@@ -1297,9 +1303,9 @@ static struct cipher_testvec bf_enc_tv_template[] = {
1297 .key = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87, 1303 .key = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
1298 0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f, 1304 0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f,
1299 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 1305 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1300 0x04, 0x68, 0x91, 0x04, 0xc2, 0xfd, 0x3b, 0x2f, 1306 0x04, 0x68, 0x91, 0x04, 0xc2, 0xfd, 0x3b, 0x2f,
1301 0x58, 0x40, 0x23, 0x64, 0x1a, 0xba, 0x61, 0x76, 1307 0x58, 0x40, 0x23, 0x64, 0x1a, 0xba, 0x61, 0x76,
1302 0x1f, 0x1f, 0x1f, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e, 1308 0x1f, 0x1f, 0x1f, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e,
1303 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }, 1309 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff },
1304 .klen = 56, 1310 .klen = 56,
1305 .input = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 }, 1311 .input = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
@@ -1331,7 +1337,7 @@ static struct cipher_testvec bf_dec_tv_template[] = {
1331 .ilen = 8, 1337 .ilen = 8,
1332 .result = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 }, 1338 .result = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1333 .rlen = 8, 1339 .rlen = 8,
1334 }, { /* Vary the keylength... */ 1340 }, { /* Vary the keylength... */
1335 .key = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87, 1341 .key = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
1336 0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f }, 1342 0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f },
1337 .klen = 16, 1343 .klen = 16,
@@ -1352,9 +1358,9 @@ static struct cipher_testvec bf_dec_tv_template[] = {
1352 .key = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87, 1358 .key = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
1353 0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f, 1359 0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f,
1354 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 1360 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1355 0x04, 0x68, 0x91, 0x04, 0xc2, 0xfd, 0x3b, 0x2f, 1361 0x04, 0x68, 0x91, 0x04, 0xc2, 0xfd, 0x3b, 0x2f,
1356 0x58, 0x40, 0x23, 0x64, 0x1a, 0xba, 0x61, 0x76, 1362 0x58, 0x40, 0x23, 0x64, 0x1a, 0xba, 0x61, 0x76,
1357 0x1f, 0x1f, 0x1f, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e, 1363 0x1f, 0x1f, 0x1f, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e,
1358 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }, 1364 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff },
1359 .klen = 56, 1365 .klen = 56,
1360 .input = { 0xc0, 0x45, 0x04, 0x01, 0x2e, 0x4e, 0x1f, 0x53 }, 1366 .input = { 0xc0, 0x45, 0x04, 0x01, 0x2e, 0x4e, 0x1f, 0x53 },
@@ -1369,7 +1375,7 @@ static struct cipher_testvec bf_cbc_enc_tv_template[] = {
1369 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 1375 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
1370 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 }, 1376 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 },
1371 .klen = 16, 1377 .klen = 16,
1372 .iv = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 }, 1378 .iv = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1373 .input = { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20, 1379 .input = { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
1374 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74, 1380 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
1375 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 1381 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20,
@@ -1388,7 +1394,7 @@ static struct cipher_testvec bf_cbc_dec_tv_template[] = {
1388 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 1394 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
1389 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 }, 1395 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 },
1390 .klen = 16, 1396 .klen = 16,
1391 .iv = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 }, 1397 .iv = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1392 .input = { 0x6b, 0x77, 0xb4, 0xd6, 0x30, 0x06, 0xde, 0xe6, 1398 .input = { 0x6b, 0x77, 0xb4, 0xd6, 0x30, 0x06, 0xde, 0xe6,
1393 0x05, 0xb1, 0x56, 0xe2, 0x74, 0x03, 0x97, 0x93, 1399 0x05, 0xb1, 0x56, 0xe2, 0x74, 0x03, 0x97, 0x93,
1394 0x58, 0xde, 0xb9, 0xe7, 0x15, 0x46, 0x16, 0xd9, 1400 0x58, 0xde, 0xb9, 0xe7, 0x15, 0x46, 0x16, 0xd9,
@@ -1490,7 +1496,7 @@ static struct cipher_testvec tf_cbc_enc_tv_template[] = {
1490 .key = { [0 ... 15] = 0x00 }, 1496 .key = { [0 ... 15] = 0x00 },
1491 .klen = 16, 1497 .klen = 16,
1492 .iv = { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32, 1498 .iv = { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
1493 0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a }, 1499 0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a },
1494 .input = { [0 ... 15] = 0x00 }, 1500 .input = { [0 ... 15] = 0x00 },
1495 .ilen = 16, 1501 .ilen = 16,
1496 .result = { 0xd4, 0x91, 0xdb, 0x16, 0xe7, 0xb1, 0xc3, 0x9e, 1502 .result = { 0xd4, 0x91, 0xdb, 0x16, 0xe7, 0xb1, 0xc3, 0x9e,
@@ -1528,7 +1534,7 @@ static struct cipher_testvec tf_cbc_dec_tv_template[] = {
1528 .klen = 16, 1534 .klen = 16,
1529 .iv = { [0 ... 15] = 0x00 }, 1535 .iv = { [0 ... 15] = 0x00 },
1530 .input = { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32, 1536 .input = { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
1531 0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a }, 1537 0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a },
1532 .ilen = 16, 1538 .ilen = 16,
1533 .result = { [0 ... 15] = 0x00 }, 1539 .result = { [0 ... 15] = 0x00 },
1534 .rlen = 16, 1540 .rlen = 16,
@@ -1578,8 +1584,7 @@ static struct cipher_testvec tf_cbc_dec_tv_template[] = {
1578#define TNEPRES_ENC_TEST_VECTORS 4 1584#define TNEPRES_ENC_TEST_VECTORS 4
1579#define TNEPRES_DEC_TEST_VECTORS 4 1585#define TNEPRES_DEC_TEST_VECTORS 4
1580 1586
1581static struct cipher_testvec serpent_enc_tv_template[] = 1587static struct cipher_testvec serpent_enc_tv_template[] = {
1582{
1583 { 1588 {
1584 .input = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 1589 .input = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1585 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f }, 1590 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
@@ -1620,8 +1625,7 @@ static struct cipher_testvec serpent_enc_tv_template[] =
1620 }, 1625 },
1621}; 1626};
1622 1627
1623static struct cipher_testvec tnepres_enc_tv_template[] = 1628static struct cipher_testvec tnepres_enc_tv_template[] = {
1624{
1625 { /* KeySize=128, PT=0, I=1 */ 1629 { /* KeySize=128, PT=0, I=1 */
1626 .input = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1630 .input = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1627 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, 1631 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
@@ -1629,7 +1633,7 @@ static struct cipher_testvec tnepres_enc_tv_template[] =
1629 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, 1633 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1630 .klen = 16, 1634 .klen = 16,
1631 .ilen = 16, 1635 .ilen = 16,
1632 .result = { 0x49, 0xaf, 0xbf, 0xad, 0x9d, 0x5a, 0x34, 0x05, 1636 .result = { 0x49, 0xaf, 0xbf, 0xad, 0x9d, 0x5a, 0x34, 0x05,
1633 0x2c, 0xd8, 0xff, 0xa5, 0x98, 0x6b, 0xd2, 0xdd }, 1637 0x2c, 0xd8, 0xff, 0xa5, 0x98, 0x6b, 0xd2, 0xdd },
1634 .rlen = 16, 1638 .rlen = 16,
1635 }, { /* KeySize=192, PT=0, I=1 */ 1639 }, { /* KeySize=192, PT=0, I=1 */
@@ -1640,7 +1644,7 @@ static struct cipher_testvec tnepres_enc_tv_template[] =
1640 .input = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1644 .input = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1641 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, 1645 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1642 .ilen = 16, 1646 .ilen = 16,
1643 .result = { 0xe7, 0x8e, 0x54, 0x02, 0xc7, 0x19, 0x55, 0x68, 1647 .result = { 0xe7, 0x8e, 0x54, 0x02, 0xc7, 0x19, 0x55, 0x68,
1644 0xac, 0x36, 0x78, 0xf7, 0xa3, 0xf6, 0x0c, 0x66 }, 1648 0xac, 0x36, 0x78, 0xf7, 0xa3, 0xf6, 0x0c, 0x66 },
1645 .rlen = 16, 1649 .rlen = 16,
1646 }, { /* KeySize=256, PT=0, I=1 */ 1650 }, { /* KeySize=256, PT=0, I=1 */
@@ -1652,7 +1656,7 @@ static struct cipher_testvec tnepres_enc_tv_template[] =
1652 .input = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1656 .input = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1653 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, 1657 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1654 .ilen = 16, 1658 .ilen = 16,
1655 .result = { 0xab, 0xed, 0x96, 0xe7, 0x66, 0xbf, 0x28, 0xcb, 1659 .result = { 0xab, 0xed, 0x96, 0xe7, 0x66, 0xbf, 0x28, 0xcb,
1656 0xc0, 0xeb, 0xd2, 0x1a, 0x82, 0xef, 0x08, 0x19 }, 1660 0xc0, 0xeb, 0xd2, 0x1a, 0x82, 0xef, 0x08, 0x19 },
1657 .rlen = 16, 1661 .rlen = 16,
1658 }, { /* KeySize=256, I=257 */ 1662 }, { /* KeySize=256, I=257 */
@@ -1664,15 +1668,14 @@ static struct cipher_testvec tnepres_enc_tv_template[] =
1664 .input = { 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08, 1668 .input = { 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08,
1665 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00 }, 1669 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00 },
1666 .ilen = 16, 1670 .ilen = 16,
1667 .result = { 0x5c, 0xe7, 0x1c, 0x70, 0xd2, 0x88, 0x2e, 0x5b, 1671 .result = { 0x5c, 0xe7, 0x1c, 0x70, 0xd2, 0x88, 0x2e, 0x5b,
1668 0xb8, 0x32, 0xe4, 0x33, 0xf8, 0x9f, 0x26, 0xde }, 1672 0xb8, 0x32, 0xe4, 0x33, 0xf8, 0x9f, 0x26, 0xde },
1669 .rlen = 16, 1673 .rlen = 16,
1670 }, 1674 },
1671}; 1675};
1672 1676
1673 1677
1674static struct cipher_testvec serpent_dec_tv_template[] = 1678static struct cipher_testvec serpent_dec_tv_template[] = {
1675{
1676 { 1679 {
1677 .input = { 0x12, 0x07, 0xfc, 0xce, 0x9b, 0xd0, 0xd6, 0x47, 1680 .input = { 0x12, 0x07, 0xfc, 0xce, 0x9b, 0xd0, 0xd6, 0x47,
1678 0x6a, 0xe9, 0x8f, 0xbe, 0xd1, 0x43, 0xa0, 0xe2 }, 1681 0x6a, 0xe9, 0x8f, 0xbe, 0xd1, 0x43, 0xa0, 0xe2 },
@@ -1713,8 +1716,7 @@ static struct cipher_testvec serpent_dec_tv_template[] =
1713 }, 1716 },
1714}; 1717};
1715 1718
1716static struct cipher_testvec tnepres_dec_tv_template[] = 1719static struct cipher_testvec tnepres_dec_tv_template[] = {
1717{
1718 { 1720 {
1719 .input = { 0x41, 0xcc, 0x6b, 0x31, 0x59, 0x31, 0x45, 0x97, 1721 .input = { 0x41, 0xcc, 0x6b, 0x31, 0x59, 0x31, 0x45, 0x97,
1720 0x6d, 0x6f, 0xbb, 0x38, 0x4b, 0x37, 0x21, 0x28 }, 1722 0x6d, 0x6f, 0xbb, 0x38, 0x4b, 0x37, 0x21, 0x28 },
@@ -1726,7 +1728,7 @@ static struct cipher_testvec tnepres_dec_tv_template[] =
1726 .key = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 1728 .key = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1727 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f }, 1729 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1728 .klen = 16, 1730 .klen = 16,
1729 .input = { 0xea, 0xf4, 0xd7, 0xfc, 0xd8, 0x01, 0x34, 0x47, 1731 .input = { 0xea, 0xf4, 0xd7, 0xfc, 0xd8, 0x01, 0x34, 0x47,
1730 0x81, 0x45, 0x0b, 0xfa, 0x0c, 0xd6, 0xad, 0x6e }, 1732 0x81, 0x45, 0x0b, 0xfa, 0x0c, 0xd6, 0xad, 0x6e },
1731 .ilen = 16, 1733 .ilen = 16,
1732 .result = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 1734 .result = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
@@ -1738,7 +1740,7 @@ static struct cipher_testvec tnepres_dec_tv_template[] =
1738 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 1740 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1739 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f }, 1741 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
1740 .klen = 32, 1742 .klen = 32,
1741 .input = { 0x64, 0xa9, 0x1a, 0x37, 0xed, 0x9f, 0xe7, 0x49, 1743 .input = { 0x64, 0xa9, 0x1a, 0x37, 0xed, 0x9f, 0xe7, 0x49,
1742 0xa8, 0x4e, 0x76, 0xd6, 0xf5, 0x0d, 0x78, 0xee }, 1744 0xa8, 0x4e, 0x76, 0xd6, 0xf5, 0x0d, 0x78, 0xee },
1743 .ilen = 16, 1745 .ilen = 16,
1744 .result = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 1746 .result = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
@@ -1747,7 +1749,7 @@ static struct cipher_testvec tnepres_dec_tv_template[] =
1747 }, { /* KeySize=128, I=121 */ 1749 }, { /* KeySize=128, I=121 */
1748 .key = { [15] = 0x80 }, 1750 .key = { [15] = 0x80 },
1749 .klen = 16, 1751 .klen = 16,
1750 .input = { 0x3d, 0xda, 0xbf, 0xc0, 0x06, 0xda, 0xab, 0x06, 1752 .input = { 0x3d, 0xda, 0xbf, 0xc0, 0x06, 0xda, 0xab, 0x06,
1751 0x46, 0x2a, 0xf4, 0xef, 0x81, 0x54, 0x4e, 0x26 }, 1753 0x46, 0x2a, 0xf4, 0xef, 0x81, 0x54, 0x4e, 0x26 },
1752 .ilen = 16, 1754 .ilen = 16,
1753 .result = { [0 ... 15] = 0x00 }, 1755 .result = { [0 ... 15] = 0x00 },
@@ -1760,58 +1762,56 @@ static struct cipher_testvec tnepres_dec_tv_template[] =
1760#define CAST6_ENC_TEST_VECTORS 3 1762#define CAST6_ENC_TEST_VECTORS 3
1761#define CAST6_DEC_TEST_VECTORS 3 1763#define CAST6_DEC_TEST_VECTORS 3
1762 1764
1763static struct cipher_testvec cast6_enc_tv_template[] = 1765static struct cipher_testvec cast6_enc_tv_template[] = {
1764{
1765 { 1766 {
1766 .key = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c, 1767 .key = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
1767 0x0a, 0xf7, 0x56, 0x47, 0xf2, 0x9f, 0x61, 0x5d }, 1768 0x0a, 0xf7, 0x56, 0x47, 0xf2, 0x9f, 0x61, 0x5d },
1768 .klen = 16, 1769 .klen = 16,
1769 .input = { [0 ... 15] = 0x00 }, 1770 .input = { [0 ... 15] = 0x00 },
1770 .ilen = 16, 1771 .ilen = 16,
1771 .result = { 0xc8, 0x42, 0xa0, 0x89, 0x72, 0xb4, 0x3d, 0x20, 1772 .result = { 0xc8, 0x42, 0xa0, 0x89, 0x72, 0xb4, 0x3d, 0x20,
1772 0x83, 0x6c, 0x91, 0xd1, 0xb7, 0x53, 0x0f, 0x6b }, 1773 0x83, 0x6c, 0x91, 0xd1, 0xb7, 0x53, 0x0f, 0x6b },
1773 .rlen = 16, 1774 .rlen = 16,
1774 }, { 1775 }, {
1775 .key = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c, 1776 .key = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
1776 0xbe, 0xd0, 0xac, 0x83, 0x94, 0x0a, 0xc2, 0x98, 1777 0xbe, 0xd0, 0xac, 0x83, 0x94, 0x0a, 0xc2, 0x98,
1777 0xba, 0xc7, 0x7a, 0x77, 0x17, 0x94, 0x28, 0x63 }, 1778 0xba, 0xc7, 0x7a, 0x77, 0x17, 0x94, 0x28, 0x63 },
1778 .klen = 24, 1779 .klen = 24,
1779 .input = { [0 ... 15] = 0x00 }, 1780 .input = { [0 ... 15] = 0x00 },
1780 .ilen = 16, 1781 .ilen = 16,
1781 .result = { 0x1b, 0x38, 0x6c, 0x02, 0x10, 0xdc, 0xad, 0xcb, 1782 .result = { 0x1b, 0x38, 0x6c, 0x02, 0x10, 0xdc, 0xad, 0xcb,
1782 0xdd, 0x0e, 0x41, 0xaa, 0x08, 0xa7, 0xa7, 0xe8 }, 1783 0xdd, 0x0e, 0x41, 0xaa, 0x08, 0xa7, 0xa7, 0xe8 },
1783 .rlen = 16, 1784 .rlen = 16,
1784 }, { 1785 }, {
1785 .key = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c, 1786 .key = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
1786 0xbe, 0xd0, 0xac, 0x83, 0x94, 0x0a, 0xc2, 0x98, 1787 0xbe, 0xd0, 0xac, 0x83, 0x94, 0x0a, 0xc2, 0x98,
1787 0x8d, 0x7c, 0x47, 0xce, 0x26, 0x49, 0x08, 0x46, 1788 0x8d, 0x7c, 0x47, 0xce, 0x26, 0x49, 0x08, 0x46,
1788 0x1c, 0xc1, 0xb5, 0x13, 0x7a, 0xe6, 0xb6, 0x04 }, 1789 0x1c, 0xc1, 0xb5, 0x13, 0x7a, 0xe6, 0xb6, 0x04 },
1789 .klen = 32, 1790 .klen = 32,
1790 .input = { [0 ... 15] = 0x00 }, 1791 .input = { [0 ... 15] = 0x00 },
1791 .ilen = 16, 1792 .ilen = 16,
1792 .result = { 0x4f, 0x6a, 0x20, 0x38, 0x28, 0x68, 0x97, 0xb9, 1793 .result = { 0x4f, 0x6a, 0x20, 0x38, 0x28, 0x68, 0x97, 0xb9,
1793 0xc9, 0x87, 0x01, 0x36, 0x55, 0x33, 0x17, 0xfa }, 1794 0xc9, 0x87, 0x01, 0x36, 0x55, 0x33, 0x17, 0xfa },
1794 .rlen = 16, 1795 .rlen = 16,
1795 }, 1796 },
1796}; 1797};
1797 1798
1798static struct cipher_testvec cast6_dec_tv_template[] = 1799static struct cipher_testvec cast6_dec_tv_template[] = {
1799{
1800 { 1800 {
1801 .key = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c, 1801 .key = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
1802 0x0a, 0xf7, 0x56, 0x47, 0xf2, 0x9f, 0x61, 0x5d }, 1802 0x0a, 0xf7, 0x56, 0x47, 0xf2, 0x9f, 0x61, 0x5d },
1803 .klen = 16, 1803 .klen = 16,
1804 .input = { 0xc8, 0x42, 0xa0, 0x89, 0x72, 0xb4, 0x3d, 0x20, 1804 .input = { 0xc8, 0x42, 0xa0, 0x89, 0x72, 0xb4, 0x3d, 0x20,
1805 0x83, 0x6c, 0x91, 0xd1, 0xb7, 0x53, 0x0f, 0x6b }, 1805 0x83, 0x6c, 0x91, 0xd1, 0xb7, 0x53, 0x0f, 0x6b },
1806 .ilen = 16, 1806 .ilen = 16,
1807 .result = { [0 ... 15] = 0x00 }, 1807 .result = { [0 ... 15] = 0x00 },
1808 .rlen = 16, 1808 .rlen = 16,
1809 }, { 1809 }, {
1810 .key = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c, 1810 .key = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
1811 0xbe, 0xd0, 0xac, 0x83, 0x94, 0x0a, 0xc2, 0x98, 1811 0xbe, 0xd0, 0xac, 0x83, 0x94, 0x0a, 0xc2, 0x98,
1812 0xba, 0xc7, 0x7a, 0x77, 0x17, 0x94, 0x28, 0x63 }, 1812 0xba, 0xc7, 0x7a, 0x77, 0x17, 0x94, 0x28, 0x63 },
1813 .klen = 24, 1813 .klen = 24,
1814 .input = { 0x1b, 0x38, 0x6c, 0x02, 0x10, 0xdc, 0xad, 0xcb, 1814 .input = { 0x1b, 0x38, 0x6c, 0x02, 0x10, 0xdc, 0xad, 0xcb,
1815 0xdd, 0x0e, 0x41, 0xaa, 0x08, 0xa7, 0xa7, 0xe8 }, 1815 0xdd, 0x0e, 0x41, 0xaa, 0x08, 0xa7, 0xa7, 0xe8 },
1816 .ilen = 16, 1816 .ilen = 16,
1817 .result = { [0 ... 15] = 0x00 }, 1817 .result = { [0 ... 15] = 0x00 },
@@ -1820,9 +1820,9 @@ static struct cipher_testvec cast6_dec_tv_template[] =
1820 .key = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c, 1820 .key = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
1821 0xbe, 0xd0, 0xac, 0x83, 0x94, 0x0a, 0xc2, 0x98, 1821 0xbe, 0xd0, 0xac, 0x83, 0x94, 0x0a, 0xc2, 0x98,
1822 0x8d, 0x7c, 0x47, 0xce, 0x26, 0x49, 0x08, 0x46, 1822 0x8d, 0x7c, 0x47, 0xce, 0x26, 0x49, 0x08, 0x46,
1823 0x1c, 0xc1, 0xb5, 0x13, 0x7a, 0xe6, 0xb6, 0x04 }, 1823 0x1c, 0xc1, 0xb5, 0x13, 0x7a, 0xe6, 0xb6, 0x04 },
1824 .klen = 32, 1824 .klen = 32,
1825 .input = { 0x4f, 0x6a, 0x20, 0x38, 0x28, 0x68, 0x97, 0xb9, 1825 .input = { 0x4f, 0x6a, 0x20, 0x38, 0x28, 0x68, 0x97, 0xb9,
1826 0xc9, 0x87, 0x01, 0x36, 0x55, 0x33, 0x17, 0xfa }, 1826 0xc9, 0x87, 0x01, 0x36, 0x55, 0x33, 0x17, 0xfa },
1827 .ilen = 16, 1827 .ilen = 16,
1828 .result = { [0 ... 15] = 0x00 }, 1828 .result = { [0 ... 15] = 0x00 },
@@ -1837,9 +1837,9 @@ static struct cipher_testvec cast6_dec_tv_template[] =
1837#define AES_ENC_TEST_VECTORS 3 1837#define AES_ENC_TEST_VECTORS 3
1838#define AES_DEC_TEST_VECTORS 3 1838#define AES_DEC_TEST_VECTORS 3
1839 1839
1840static struct cipher_testvec aes_enc_tv_template[] = { 1840static struct cipher_testvec aes_enc_tv_template[] = {
1841 { /* From FIPS-197 */ 1841 { /* From FIPS-197 */
1842 .key = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 1842 .key = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1843 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f }, 1843 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1844 .klen = 16, 1844 .klen = 16,
1845 .input = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 1845 .input = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
@@ -1853,7 +1853,7 @@ static struct cipher_testvec aes_enc_tv_template[] = {
1853 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 1853 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
1854 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17 }, 1854 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17 },
1855 .klen = 24, 1855 .klen = 24,
1856 .input = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 1856 .input = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1857 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff }, 1857 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
1858 .ilen = 16, 1858 .ilen = 16,
1859 .result = { 0xdd, 0xa9, 0x7c, 0xa4, 0x86, 0x4c, 0xdf, 0xe0, 1859 .result = { 0xdd, 0xa9, 0x7c, 0xa4, 0x86, 0x4c, 0xdf, 0xe0,
@@ -1865,7 +1865,7 @@ static struct cipher_testvec aes_enc_tv_template[] = {
1865 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 1865 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1866 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f }, 1866 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
1867 .klen = 32, 1867 .klen = 32,
1868 .input = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 1868 .input = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1869 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff }, 1869 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
1870 .ilen = 16, 1870 .ilen = 16,
1871 .result = { 0x8e, 0xa2, 0xb7, 0xca, 0x51, 0x67, 0x45, 0xbf, 1871 .result = { 0x8e, 0xa2, 0xb7, 0xca, 0x51, 0x67, 0x45, 0xbf,
@@ -1874,9 +1874,9 @@ static struct cipher_testvec aes_enc_tv_template[] = {
1874 }, 1874 },
1875}; 1875};
1876 1876
1877static struct cipher_testvec aes_dec_tv_template[] = { 1877static struct cipher_testvec aes_dec_tv_template[] = {
1878 { /* From FIPS-197 */ 1878 { /* From FIPS-197 */
1879 .key = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 1879 .key = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1880 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f }, 1880 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1881 .klen = 16, 1881 .klen = 16,
1882 .input = { 0x69, 0xc4, 0xe0, 0xd8, 0x6a, 0x7b, 0x04, 0x30, 1882 .input = { 0x69, 0xc4, 0xe0, 0xd8, 0x6a, 0x7b, 0x04, 0x30,
@@ -1893,8 +1893,8 @@ static struct cipher_testvec aes_dec_tv_template[] = {
1893 .input = { 0xdd, 0xa9, 0x7c, 0xa4, 0x86, 0x4c, 0xdf, 0xe0, 1893 .input = { 0xdd, 0xa9, 0x7c, 0xa4, 0x86, 0x4c, 0xdf, 0xe0,
1894 0x6e, 0xaf, 0x70, 0xa0, 0xec, 0x0d, 0x71, 0x91 }, 1894 0x6e, 0xaf, 0x70, 0xa0, 0xec, 0x0d, 0x71, 0x91 },
1895 .ilen = 16, 1895 .ilen = 16,
1896 .result = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 1896 .result = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1897 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff }, 1897 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
1898 .rlen = 16, 1898 .rlen = 16,
1899 }, { 1899 }, {
1900 .key = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 1900 .key = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
@@ -1905,7 +1905,7 @@ static struct cipher_testvec aes_dec_tv_template[] = {
1905 .input = { 0x8e, 0xa2, 0xb7, 0xca, 0x51, 0x67, 0x45, 0xbf, 1905 .input = { 0x8e, 0xa2, 0xb7, 0xca, 0x51, 0x67, 0x45, 0xbf,
1906 0xea, 0xfc, 0x49, 0x90, 0x4b, 0x49, 0x60, 0x89 }, 1906 0xea, 0xfc, 0x49, 0x90, 0x4b, 0x49, 0x60, 0x89 },
1907 .ilen = 16, 1907 .ilen = 16,
1908 .result = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 1908 .result = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1909 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff }, 1909 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
1910 .rlen = 16, 1910 .rlen = 16,
1911 }, 1911 },
@@ -1915,8 +1915,7 @@ static struct cipher_testvec aes_dec_tv_template[] = {
1915#define CAST5_ENC_TEST_VECTORS 3 1915#define CAST5_ENC_TEST_VECTORS 3
1916#define CAST5_DEC_TEST_VECTORS 3 1916#define CAST5_DEC_TEST_VECTORS 3
1917 1917
1918static struct cipher_testvec cast5_enc_tv_template[] = 1918static struct cipher_testvec cast5_enc_tv_template[] = {
1919{
1920 { 1919 {
1921 .key = { 0x01, 0x23, 0x45, 0x67, 0x12, 0x34, 0x56, 0x78, 1920 .key = { 0x01, 0x23, 0x45, 0x67, 0x12, 0x34, 0x56, 0x78,
1922 0x23, 0x45, 0x67, 0x89, 0x34, 0x56, 0x78, 0x9a }, 1921 0x23, 0x45, 0x67, 0x89, 0x34, 0x56, 0x78, 0x9a },
@@ -1943,8 +1942,7 @@ static struct cipher_testvec cast5_enc_tv_template[] =
1943 }, 1942 },
1944}; 1943};
1945 1944
1946static struct cipher_testvec cast5_dec_tv_template[] = 1945static struct cipher_testvec cast5_dec_tv_template[] = {
1947{
1948 { 1946 {
1949 .key = { 0x01, 0x23, 0x45, 0x67, 0x12, 0x34, 0x56, 0x78, 1947 .key = { 0x01, 0x23, 0x45, 0x67, 0x12, 0x34, 0x56, 0x78,
1950 0x23, 0x45, 0x67, 0x89, 0x34, 0x56, 0x78, 0x9a }, 1948 0x23, 0x45, 0x67, 0x89, 0x34, 0x56, 0x78, 0x9a },
@@ -1971,14 +1969,13 @@ static struct cipher_testvec cast5_dec_tv_template[] =
1971 }, 1969 },
1972}; 1970};
1973 1971
1974/* 1972/*
1975 * ARC4 test vectors from OpenSSL 1973 * ARC4 test vectors from OpenSSL
1976 */ 1974 */
1977#define ARC4_ENC_TEST_VECTORS 7 1975#define ARC4_ENC_TEST_VECTORS 7
1978#define ARC4_DEC_TEST_VECTORS 7 1976#define ARC4_DEC_TEST_VECTORS 7
1979 1977
1980static struct cipher_testvec arc4_enc_tv_template[] = 1978static struct cipher_testvec arc4_enc_tv_template[] = {
1981{
1982 { 1979 {
1983 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef }, 1980 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1984 .klen = 8, 1981 .klen = 8,
@@ -2044,8 +2041,7 @@ static struct cipher_testvec arc4_enc_tv_template[] =
2044 }, 2041 },
2045}; 2042};
2046 2043
2047static struct cipher_testvec arc4_dec_tv_template[] = 2044static struct cipher_testvec arc4_dec_tv_template[] = {
2048{
2049 { 2045 {
2050 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef }, 2046 .key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
2051 .klen = 8, 2047 .klen = 8,
@@ -2111,14 +2107,13 @@ static struct cipher_testvec arc4_dec_tv_template[] =
2111 }, 2107 },
2112}; 2108};
2113 2109
2114/* 2110/*
2115 * TEA test vectors 2111 * TEA test vectors
2116 */ 2112 */
2117#define TEA_ENC_TEST_VECTORS 4 2113#define TEA_ENC_TEST_VECTORS 4
2118#define TEA_DEC_TEST_VECTORS 4 2114#define TEA_DEC_TEST_VECTORS 4
2119 2115
2120static struct cipher_testvec tea_enc_tv_template[] = 2116static struct cipher_testvec tea_enc_tv_template[] = {
2121{
2122 { 2117 {
2123 .key = { [0 ... 15] = 0x00 }, 2118 .key = { [0 ... 15] = 0x00 },
2124 .klen = 16, 2119 .klen = 16,
@@ -2138,31 +2133,30 @@ static struct cipher_testvec tea_enc_tv_template[] =
2138 .key = { 0x09, 0x65, 0x43, 0x11, 0x66, 0x44, 0x39, 0x25, 2133 .key = { 0x09, 0x65, 0x43, 0x11, 0x66, 0x44, 0x39, 0x25,
2139 0x51, 0x3a, 0x16, 0x10, 0x0a, 0x08, 0x12, 0x6e }, 2134 0x51, 0x3a, 0x16, 0x10, 0x0a, 0x08, 0x12, 0x6e },
2140 .klen = 16, 2135 .klen = 16,
2141 .input = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74, 2136 .input = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74,
2142 0x65, 0x73, 0x74, 0x5f, 0x76, 0x65, 0x63, 0x74 }, 2137 0x65, 0x73, 0x74, 0x5f, 0x76, 0x65, 0x63, 0x74 },
2143 .ilen = 16, 2138 .ilen = 16,
2144 .result = { 0xbe, 0x7a, 0xbb, 0x81, 0x95, 0x2d, 0x1f, 0x1e, 2139 .result = { 0xbe, 0x7a, 0xbb, 0x81, 0x95, 0x2d, 0x1f, 0x1e,
2145 0xdd, 0x89, 0xa1, 0x25, 0x04, 0x21, 0xdf, 0x95 }, 2140 0xdd, 0x89, 0xa1, 0x25, 0x04, 0x21, 0xdf, 0x95 },
2146 .rlen = 16, 2141 .rlen = 16,
2147 }, { 2142 }, {
2148 .key = { 0x4d, 0x76, 0x32, 0x17, 0x05, 0x3f, 0x75, 0x2c, 2143 .key = { 0x4d, 0x76, 0x32, 0x17, 0x05, 0x3f, 0x75, 0x2c,
2149 0x5d, 0x04, 0x16, 0x36, 0x15, 0x72, 0x63, 0x2f }, 2144 0x5d, 0x04, 0x16, 0x36, 0x15, 0x72, 0x63, 0x2f },
2150 .klen = 16, 2145 .klen = 16,
2151 .input = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67, 2146 .input = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67,
2152 0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 2147 0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20,
2153 0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72, 2148 0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72,
2154 0x65, 0x61, 0x6c, 0x6c, 0x79, 0x21, 0x21, 0x21 }, 2149 0x65, 0x61, 0x6c, 0x6c, 0x79, 0x21, 0x21, 0x21 },
2155 .ilen = 32, 2150 .ilen = 32,
2156 .result = { 0xe0, 0x4d, 0x5d, 0x3c, 0xb7, 0x8c, 0x36, 0x47, 2151 .result = { 0xe0, 0x4d, 0x5d, 0x3c, 0xb7, 0x8c, 0x36, 0x47,
2157 0x94, 0x18, 0x95, 0x91, 0xa9, 0xfc, 0x49, 0xf8, 2152 0x94, 0x18, 0x95, 0x91, 0xa9, 0xfc, 0x49, 0xf8,
2158 0x44, 0xd1, 0x2d, 0xc2, 0x99, 0xb8, 0x08, 0x2a, 2153 0x44, 0xd1, 0x2d, 0xc2, 0x99, 0xb8, 0x08, 0x2a,
2159 0x07, 0x89, 0x73, 0xc2, 0x45, 0x92, 0xc6, 0x90 }, 2154 0x07, 0x89, 0x73, 0xc2, 0x45, 0x92, 0xc6, 0x90 },
2160 .rlen = 32, 2155 .rlen = 32,
2161 } 2156 }
2162}; 2157};
2163 2158
2164static struct cipher_testvec tea_dec_tv_template[] = 2159static struct cipher_testvec tea_dec_tv_template[] = {
2165{
2166 { 2160 {
2167 .key = { [0 ... 15] = 0x00 }, 2161 .key = { [0 ... 15] = 0x00 },
2168 .klen = 16, 2162 .klen = 16,
@@ -2183,9 +2177,9 @@ static struct cipher_testvec tea_dec_tv_template[] =
2183 0x51, 0x3a, 0x16, 0x10, 0x0a, 0x08, 0x12, 0x6e }, 2177 0x51, 0x3a, 0x16, 0x10, 0x0a, 0x08, 0x12, 0x6e },
2184 .klen = 16, 2178 .klen = 16,
2185 .input = { 0xbe, 0x7a, 0xbb, 0x81, 0x95, 0x2d, 0x1f, 0x1e, 2179 .input = { 0xbe, 0x7a, 0xbb, 0x81, 0x95, 0x2d, 0x1f, 0x1e,
2186 0xdd, 0x89, 0xa1, 0x25, 0x04, 0x21, 0xdf, 0x95 }, 2180 0xdd, 0x89, 0xa1, 0x25, 0x04, 0x21, 0xdf, 0x95 },
2187 .ilen = 16, 2181 .ilen = 16,
2188 .result = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74, 2182 .result = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74,
2189 0x65, 0x73, 0x74, 0x5f, 0x76, 0x65, 0x63, 0x74 }, 2183 0x65, 0x73, 0x74, 0x5f, 0x76, 0x65, 0x63, 0x74 },
2190 .rlen = 16, 2184 .rlen = 16,
2191 }, { 2185 }, {
@@ -2193,26 +2187,25 @@ static struct cipher_testvec tea_dec_tv_template[] =
2193 0x5d, 0x04, 0x16, 0x36, 0x15, 0x72, 0x63, 0x2f }, 2187 0x5d, 0x04, 0x16, 0x36, 0x15, 0x72, 0x63, 0x2f },
2194 .klen = 16, 2188 .klen = 16,
2195 .input = { 0xe0, 0x4d, 0x5d, 0x3c, 0xb7, 0x8c, 0x36, 0x47, 2189 .input = { 0xe0, 0x4d, 0x5d, 0x3c, 0xb7, 0x8c, 0x36, 0x47,
2196 0x94, 0x18, 0x95, 0x91, 0xa9, 0xfc, 0x49, 0xf8, 2190 0x94, 0x18, 0x95, 0x91, 0xa9, 0xfc, 0x49, 0xf8,
2197 0x44, 0xd1, 0x2d, 0xc2, 0x99, 0xb8, 0x08, 0x2a, 2191 0x44, 0xd1, 0x2d, 0xc2, 0x99, 0xb8, 0x08, 0x2a,
2198 0x07, 0x89, 0x73, 0xc2, 0x45, 0x92, 0xc6, 0x90 }, 2192 0x07, 0x89, 0x73, 0xc2, 0x45, 0x92, 0xc6, 0x90 },
2199 .ilen = 32, 2193 .ilen = 32,
2200 .result = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67, 2194 .result = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67,
2201 0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 2195 0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20,
2202 0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72, 2196 0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72,
2203 0x65, 0x61, 0x6c, 0x6c, 0x79, 0x21, 0x21, 0x21 }, 2197 0x65, 0x61, 0x6c, 0x6c, 0x79, 0x21, 0x21, 0x21 },
2204 .rlen = 32, 2198 .rlen = 32,
2205 } 2199 }
2206}; 2200};
2207 2201
2208/* 2202/*
2209 * XTEA test vectors 2203 * XTEA test vectors
2210 */ 2204 */
2211#define XTEA_ENC_TEST_VECTORS 4 2205#define XTEA_ENC_TEST_VECTORS 4
2212#define XTEA_DEC_TEST_VECTORS 4 2206#define XTEA_DEC_TEST_VECTORS 4
2213 2207
2214static struct cipher_testvec xtea_enc_tv_template[] = 2208static struct cipher_testvec xtea_enc_tv_template[] = {
2215{
2216 { 2209 {
2217 .key = { [0 ... 15] = 0x00 }, 2210 .key = { [0 ... 15] = 0x00 },
2218 .klen = 16, 2211 .klen = 16,
@@ -2232,31 +2225,30 @@ static struct cipher_testvec xtea_enc_tv_template[] =
2232 .key = { 0x09, 0x65, 0x43, 0x11, 0x66, 0x44, 0x39, 0x25, 2225 .key = { 0x09, 0x65, 0x43, 0x11, 0x66, 0x44, 0x39, 0x25,
2233 0x51, 0x3a, 0x16, 0x10, 0x0a, 0x08, 0x12, 0x6e }, 2226 0x51, 0x3a, 0x16, 0x10, 0x0a, 0x08, 0x12, 0x6e },
2234 .klen = 16, 2227 .klen = 16,
2235 .input = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74, 2228 .input = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74,
2236 0x65, 0x73, 0x74, 0x5f, 0x76, 0x65, 0x63, 0x74 }, 2229 0x65, 0x73, 0x74, 0x5f, 0x76, 0x65, 0x63, 0x74 },
2237 .ilen = 16, 2230 .ilen = 16,
2238 .result = { 0xe2, 0x04, 0xdb, 0xf2, 0x89, 0x85, 0x9e, 0xea, 2231 .result = { 0xe2, 0x04, 0xdb, 0xf2, 0x89, 0x85, 0x9e, 0xea,
2239 0x61, 0x35, 0xaa, 0xed, 0xb5, 0xcb, 0x71, 0x2c }, 2232 0x61, 0x35, 0xaa, 0xed, 0xb5, 0xcb, 0x71, 0x2c },
2240 .rlen = 16, 2233 .rlen = 16,
2241 }, { 2234 }, {
2242 .key = { 0x4d, 0x76, 0x32, 0x17, 0x05, 0x3f, 0x75, 0x2c, 2235 .key = { 0x4d, 0x76, 0x32, 0x17, 0x05, 0x3f, 0x75, 0x2c,
2243 0x5d, 0x04, 0x16, 0x36, 0x15, 0x72, 0x63, 0x2f }, 2236 0x5d, 0x04, 0x16, 0x36, 0x15, 0x72, 0x63, 0x2f },
2244 .klen = 16, 2237 .klen = 16,
2245 .input = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67, 2238 .input = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67,
2246 0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 2239 0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20,
2247 0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72, 2240 0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72,
2248 0x65, 0x61, 0x6c, 0x6c, 0x79, 0x21, 0x21, 0x21 }, 2241 0x65, 0x61, 0x6c, 0x6c, 0x79, 0x21, 0x21, 0x21 },
2249 .ilen = 32, 2242 .ilen = 32,
2250 .result = { 0x0b, 0x03, 0xcd, 0x8a, 0xbe, 0x95, 0xfd, 0xb1, 2243 .result = { 0x0b, 0x03, 0xcd, 0x8a, 0xbe, 0x95, 0xfd, 0xb1,
2251 0xc1, 0x44, 0x91, 0x0b, 0xa5, 0xc9, 0x1b, 0xb4, 2244 0xc1, 0x44, 0x91, 0x0b, 0xa5, 0xc9, 0x1b, 0xb4,
2252 0xa9, 0xda, 0x1e, 0x9e, 0xb1, 0x3e, 0x2a, 0x8f, 2245 0xa9, 0xda, 0x1e, 0x9e, 0xb1, 0x3e, 0x2a, 0x8f,
2253 0xea, 0xa5, 0x6a, 0x85, 0xd1, 0xf4, 0xa8, 0xa5 }, 2246 0xea, 0xa5, 0x6a, 0x85, 0xd1, 0xf4, 0xa8, 0xa5 },
2254 .rlen = 32, 2247 .rlen = 32,
2255 } 2248 }
2256}; 2249};
2257 2250
2258static struct cipher_testvec xtea_dec_tv_template[] = 2251static struct cipher_testvec xtea_dec_tv_template[] = {
2259{
2260 { 2252 {
2261 .key = { [0 ... 15] = 0x00 }, 2253 .key = { [0 ... 15] = 0x00 },
2262 .klen = 16, 2254 .klen = 16,
@@ -2276,24 +2268,24 @@ static struct cipher_testvec xtea_dec_tv_template[] =
2276 .key = { 0x09, 0x65, 0x43, 0x11, 0x66, 0x44, 0x39, 0x25, 2268 .key = { 0x09, 0x65, 0x43, 0x11, 0x66, 0x44, 0x39, 0x25,
2277 0x51, 0x3a, 0x16, 0x10, 0x0a, 0x08, 0x12, 0x6e }, 2269 0x51, 0x3a, 0x16, 0x10, 0x0a, 0x08, 0x12, 0x6e },
2278 .klen = 16, 2270 .klen = 16,
2279 .input = { 0xe2, 0x04, 0xdb, 0xf2, 0x89, 0x85, 0x9e, 0xea, 2271 .input = { 0xe2, 0x04, 0xdb, 0xf2, 0x89, 0x85, 0x9e, 0xea,
2280 0x61, 0x35, 0xaa, 0xed, 0xb5, 0xcb, 0x71, 0x2c }, 2272 0x61, 0x35, 0xaa, 0xed, 0xb5, 0xcb, 0x71, 0x2c },
2281 .ilen = 16, 2273 .ilen = 16,
2282 .result = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74, 2274 .result = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74,
2283 0x65, 0x73, 0x74, 0x5f, 0x76, 0x65, 0x63, 0x74 }, 2275 0x65, 0x73, 0x74, 0x5f, 0x76, 0x65, 0x63, 0x74 },
2284 .rlen = 16, 2276 .rlen = 16,
2285 }, { 2277 }, {
2286 .key = { 0x4d, 0x76, 0x32, 0x17, 0x05, 0x3f, 0x75, 0x2c, 2278 .key = { 0x4d, 0x76, 0x32, 0x17, 0x05, 0x3f, 0x75, 0x2c,
2287 0x5d, 0x04, 0x16, 0x36, 0x15, 0x72, 0x63, 0x2f }, 2279 0x5d, 0x04, 0x16, 0x36, 0x15, 0x72, 0x63, 0x2f },
2288 .klen = 16, 2280 .klen = 16,
2289 .input = { 0x0b, 0x03, 0xcd, 0x8a, 0xbe, 0x95, 0xfd, 0xb1, 2281 .input = { 0x0b, 0x03, 0xcd, 0x8a, 0xbe, 0x95, 0xfd, 0xb1,
2290 0xc1, 0x44, 0x91, 0x0b, 0xa5, 0xc9, 0x1b, 0xb4, 2282 0xc1, 0x44, 0x91, 0x0b, 0xa5, 0xc9, 0x1b, 0xb4,
2291 0xa9, 0xda, 0x1e, 0x9e, 0xb1, 0x3e, 0x2a, 0x8f, 2283 0xa9, 0xda, 0x1e, 0x9e, 0xb1, 0x3e, 0x2a, 0x8f,
2292 0xea, 0xa5, 0x6a, 0x85, 0xd1, 0xf4, 0xa8, 0xa5 }, 2284 0xea, 0xa5, 0x6a, 0x85, 0xd1, 0xf4, 0xa8, 0xa5 },
2293 .ilen = 32, 2285 .ilen = 32,
2294 .result = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67, 2286 .result = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67,
2295 0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 2287 0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20,
2296 0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72, 2288 0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72,
2297 0x65, 0x61, 0x6c, 0x6c, 0x79, 0x21, 0x21, 0x21 }, 2289 0x65, 0x61, 0x6c, 0x6c, 0x79, 0x21, 0x21, 0x21 },
2298 .rlen = 32, 2290 .rlen = 32,
2299 } 2291 }
@@ -2305,9 +2297,9 @@ static struct cipher_testvec xtea_dec_tv_template[] =
2305#define KHAZAD_ENC_TEST_VECTORS 5 2297#define KHAZAD_ENC_TEST_VECTORS 5
2306#define KHAZAD_DEC_TEST_VECTORS 5 2298#define KHAZAD_DEC_TEST_VECTORS 5
2307 2299
2308static struct cipher_testvec khazad_enc_tv_template[] = { 2300static struct cipher_testvec khazad_enc_tv_template[] = {
2309 { 2301 {
2310 .key = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 2302 .key = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2311 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, 2303 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
2312 .klen = 16, 2304 .klen = 16,
2313 .input = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, 2305 .input = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
@@ -2351,9 +2343,9 @@ static struct cipher_testvec khazad_enc_tv_template[] = {
2351 }, 2343 },
2352}; 2344};
2353 2345
2354static struct cipher_testvec khazad_dec_tv_template[] = { 2346static struct cipher_testvec khazad_dec_tv_template[] = {
2355 { 2347 {
2356 .key = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 2348 .key = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, 2349 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
2358 .klen = 16, 2350 .klen = 16,
2359 .input = { 0X49, 0Xa4, 0Xce, 0X32, 0Xac, 0X19, 0X0e, 0X3f }, 2351 .input = { 0X49, 0Xa4, 0Xce, 0X32, 0Xac, 0X19, 0X0e, 0X3f },
@@ -2697,8 +2689,7 @@ static struct comp_testvec deflate_decomp_tv_template[] = {
2697 */ 2689 */
2698#define MICHAEL_MIC_TEST_VECTORS 6 2690#define MICHAEL_MIC_TEST_VECTORS 6
2699 2691
2700static struct hash_testvec michael_mic_tv_template[] = 2692static struct hash_testvec michael_mic_tv_template[] = {
2701{
2702 { 2693 {
2703 .key = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, 2694 .key = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
2704 .ksize = 8, 2695 .ksize = 8,
@@ -2743,4 +2734,88 @@ static struct hash_testvec michael_mic_tv_template[] =
2743 } 2734 }
2744}; 2735};
2745 2736
2737/*
2738 * Cipher speed tests
2739 */
2740static struct cipher_speed aes_speed_template[] = {
2741 { .klen = 16, .blen = 16, },
2742 { .klen = 16, .blen = 64, },
2743 { .klen = 16, .blen = 256, },
2744 { .klen = 16, .blen = 1024, },
2745 { .klen = 16, .blen = 8192, },
2746 { .klen = 24, .blen = 16, },
2747 { .klen = 24, .blen = 64, },
2748 { .klen = 24, .blen = 256, },
2749 { .klen = 24, .blen = 1024, },
2750 { .klen = 24, .blen = 8192, },
2751 { .klen = 32, .blen = 16, },
2752 { .klen = 32, .blen = 64, },
2753 { .klen = 32, .blen = 256, },
2754 { .klen = 32, .blen = 1024, },
2755 { .klen = 32, .blen = 8192, },
2756
2757 /* End marker */
2758 { .klen = 0, .blen = 0, }
2759};
2760
2761static struct cipher_speed des3_ede_speed_template[] = {
2762 { .klen = 24, .blen = 16, },
2763 { .klen = 24, .blen = 64, },
2764 { .klen = 24, .blen = 256, },
2765 { .klen = 24, .blen = 1024, },
2766 { .klen = 24, .blen = 8192, },
2767
2768 /* End marker */
2769 { .klen = 0, .blen = 0, }
2770};
2771
2772static struct cipher_speed twofish_speed_template[] = {
2773 { .klen = 16, .blen = 16, },
2774 { .klen = 16, .blen = 64, },
2775 { .klen = 16, .blen = 256, },
2776 { .klen = 16, .blen = 1024, },
2777 { .klen = 16, .blen = 8192, },
2778 { .klen = 24, .blen = 16, },
2779 { .klen = 24, .blen = 64, },
2780 { .klen = 24, .blen = 256, },
2781 { .klen = 24, .blen = 1024, },
2782 { .klen = 24, .blen = 8192, },
2783 { .klen = 32, .blen = 16, },
2784 { .klen = 32, .blen = 64, },
2785 { .klen = 32, .blen = 256, },
2786 { .klen = 32, .blen = 1024, },
2787 { .klen = 32, .blen = 8192, },
2788
2789 /* End marker */
2790 { .klen = 0, .blen = 0, }
2791};
2792
2793static struct cipher_speed blowfish_speed_template[] = {
2794 /* Don't support blowfish keys > 256 bit in this test */
2795 { .klen = 8, .blen = 16, },
2796 { .klen = 8, .blen = 64, },
2797 { .klen = 8, .blen = 256, },
2798 { .klen = 8, .blen = 1024, },
2799 { .klen = 8, .blen = 8192, },
2800 { .klen = 32, .blen = 16, },
2801 { .klen = 32, .blen = 64, },
2802 { .klen = 32, .blen = 256, },
2803 { .klen = 32, .blen = 1024, },
2804 { .klen = 32, .blen = 8192, },
2805
2806 /* End marker */
2807 { .klen = 0, .blen = 0, }
2808};
2809
2810static struct cipher_speed des_speed_template[] = {
2811 { .klen = 8, .blen = 16, },
2812 { .klen = 8, .blen = 64, },
2813 { .klen = 8, .blen = 256, },
2814 { .klen = 8, .blen = 1024, },
2815 { .klen = 8, .blen = 8192, },
2816
2817 /* End marker */
2818 { .klen = 0, .blen = 0, }
2819};
2820
2746#endif /* _CRYPTO_TCRYPT_H */ 2821#endif /* _CRYPTO_TCRYPT_H */
diff --git a/drivers/net/appletalk/ltpc.c b/drivers/net/appletalk/ltpc.c
index db4f369637b6..d5666c37cb0d 100644
--- a/drivers/net/appletalk/ltpc.c
+++ b/drivers/net/appletalk/ltpc.c
@@ -1109,8 +1109,7 @@ struct net_device * __init ltpc_probe(void)
1109 inb_p(io+1); 1109 inb_p(io+1);
1110 inb_p(io+3); 1110 inb_p(io+3);
1111 1111
1112 set_current_state(TASK_UNINTERRUPTIBLE); 1112 msleep(20);
1113 schedule_timeout(2*HZ/100);
1114 1113
1115 inb_p(io+0); 1114 inb_p(io+0);
1116 inb_p(io+2); 1115 inb_p(io+2);
@@ -1120,8 +1119,7 @@ struct net_device * __init ltpc_probe(void)
1120 inb_p(io+5); /* enable dma */ 1119 inb_p(io+5); /* enable dma */
1121 inb_p(io+6); /* tri-state interrupt line */ 1120 inb_p(io+6); /* tri-state interrupt line */
1122 1121
1123 set_current_state(TASK_UNINTERRUPTIBLE); 1122 ssleep(1);
1124 schedule_timeout(HZ);
1125 1123
1126 /* now, figure out which dma channel we're using, unless it's 1124 /* now, figure out which dma channel we're using, unless it's
1127 already been specified */ 1125 already been specified */
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index ba5d1236aa17..d6afd440cf7b 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -41,7 +41,7 @@
41struct divert_blk; 41struct divert_blk;
42struct vlan_group; 42struct vlan_group;
43struct ethtool_ops; 43struct ethtool_ops;
44struct netpoll; 44struct netpoll_info;
45 /* source back-compat hooks */ 45 /* source back-compat hooks */
46#define SET_ETHTOOL_OPS(netdev,ops) \ 46#define SET_ETHTOOL_OPS(netdev,ops) \
47 ( (netdev)->ethtool_ops = (ops) ) 47 ( (netdev)->ethtool_ops = (ops) )
@@ -468,7 +468,7 @@ struct net_device
468 unsigned char *haddr); 468 unsigned char *haddr);
469 int (*neigh_setup)(struct net_device *dev, struct neigh_parms *); 469 int (*neigh_setup)(struct net_device *dev, struct neigh_parms *);
470#ifdef CONFIG_NETPOLL 470#ifdef CONFIG_NETPOLL
471 struct netpoll *np; 471 struct netpoll_info *npinfo;
472#endif 472#endif
473#ifdef CONFIG_NET_POLL_CONTROLLER 473#ifdef CONFIG_NET_POLL_CONTROLLER
474 void (*poll_controller)(struct net_device *dev); 474 void (*poll_controller)(struct net_device *dev);
diff --git a/include/linux/netfilter_ipv4/ipt_CLUSTERIP.h b/include/linux/netfilter_ipv4/ipt_CLUSTERIP.h
index baa83e757156..d9bceedfb3dc 100644
--- a/include/linux/netfilter_ipv4/ipt_CLUSTERIP.h
+++ b/include/linux/netfilter_ipv4/ipt_CLUSTERIP.h
@@ -18,7 +18,6 @@ struct clusterip_config;
18struct ipt_clusterip_tgt_info { 18struct ipt_clusterip_tgt_info {
19 19
20 u_int32_t flags; 20 u_int32_t flags;
21 struct clusterip_config *config;
22 21
23 /* only relevant for new ones */ 22 /* only relevant for new ones */
24 u_int8_t clustermac[6]; 23 u_int8_t clustermac[6];
@@ -27,6 +26,8 @@ struct ipt_clusterip_tgt_info {
27 u_int16_t local_nodes[CLUSTERIP_MAX_NODES]; 26 u_int16_t local_nodes[CLUSTERIP_MAX_NODES];
28 enum clusterip_hashmode hash_mode; 27 enum clusterip_hashmode hash_mode;
29 u_int32_t hash_initval; 28 u_int32_t hash_initval;
29
30 struct clusterip_config *config;
30}; 31};
31 32
32#endif /*_IPT_CLUSTERIP_H_target*/ 33#endif /*_IPT_CLUSTERIP_H_target*/
diff --git a/include/linux/netpoll.h b/include/linux/netpoll.h
index c0d8b90c5202..bcd0ac33f592 100644
--- a/include/linux/netpoll.h
+++ b/include/linux/netpoll.h
@@ -16,14 +16,19 @@ struct netpoll;
16struct netpoll { 16struct netpoll {
17 struct net_device *dev; 17 struct net_device *dev;
18 char dev_name[16], *name; 18 char dev_name[16], *name;
19 int rx_flags;
20 void (*rx_hook)(struct netpoll *, int, char *, int); 19 void (*rx_hook)(struct netpoll *, int, char *, int);
21 void (*drop)(struct sk_buff *skb); 20 void (*drop)(struct sk_buff *skb);
22 u32 local_ip, remote_ip; 21 u32 local_ip, remote_ip;
23 u16 local_port, remote_port; 22 u16 local_port, remote_port;
24 unsigned char local_mac[6], remote_mac[6]; 23 unsigned char local_mac[6], remote_mac[6];
24};
25
26struct netpoll_info {
25 spinlock_t poll_lock; 27 spinlock_t poll_lock;
26 int poll_owner; 28 int poll_owner;
29 int rx_flags;
30 spinlock_t rx_lock;
31 struct netpoll *rx_np; /* netpoll that registered an rx_hook */
27}; 32};
28 33
29void netpoll_poll(struct netpoll *np); 34void netpoll_poll(struct netpoll *np);
@@ -39,22 +44,35 @@ void netpoll_queue(struct sk_buff *skb);
39#ifdef CONFIG_NETPOLL 44#ifdef CONFIG_NETPOLL
40static inline int netpoll_rx(struct sk_buff *skb) 45static inline int netpoll_rx(struct sk_buff *skb)
41{ 46{
42 return skb->dev->np && skb->dev->np->rx_flags && __netpoll_rx(skb); 47 struct netpoll_info *npinfo = skb->dev->npinfo;
48 unsigned long flags;
49 int ret = 0;
50
51 if (!npinfo || (!npinfo->rx_np && !npinfo->rx_flags))
52 return 0;
53
54 spin_lock_irqsave(&npinfo->rx_lock, flags);
55 /* check rx_flags again with the lock held */
56 if (npinfo->rx_flags && __netpoll_rx(skb))
57 ret = 1;
58 spin_unlock_irqrestore(&npinfo->rx_lock, flags);
59
60 return ret;
43} 61}
44 62
45static inline void netpoll_poll_lock(struct net_device *dev) 63static inline void netpoll_poll_lock(struct net_device *dev)
46{ 64{
47 if (dev->np) { 65 if (dev->npinfo) {
48 spin_lock(&dev->np->poll_lock); 66 spin_lock(&dev->npinfo->poll_lock);
49 dev->np->poll_owner = smp_processor_id(); 67 dev->npinfo->poll_owner = smp_processor_id();
50 } 68 }
51} 69}
52 70
53static inline void netpoll_poll_unlock(struct net_device *dev) 71static inline void netpoll_poll_unlock(struct net_device *dev)
54{ 72{
55 if (dev->np) { 73 if (dev->npinfo) {
56 spin_unlock(&dev->np->poll_lock); 74 dev->npinfo->poll_owner = -1;
57 dev->np->poll_owner = -1; 75 spin_unlock(&dev->npinfo->poll_lock);
58 } 76 }
59} 77}
60 78
diff --git a/include/linux/x25.h b/include/linux/x25.h
index 7531cfed5885..16d44931afa0 100644
--- a/include/linux/x25.h
+++ b/include/linux/x25.h
@@ -4,6 +4,8 @@
4 * History 4 * History
5 * mar/20/00 Daniela Squassoni Disabling/enabling of facilities 5 * mar/20/00 Daniela Squassoni Disabling/enabling of facilities
6 * negotiation. 6 * negotiation.
7 * apr/02/05 Shaun Pereira Selective sub address matching with
8 * call user data
7 */ 9 */
8 10
9#ifndef X25_KERNEL_H 11#ifndef X25_KERNEL_H
@@ -16,6 +18,9 @@
16#define SIOCX25GCALLUSERDATA (SIOCPROTOPRIVATE + 4) 18#define SIOCX25GCALLUSERDATA (SIOCPROTOPRIVATE + 4)
17#define SIOCX25SCALLUSERDATA (SIOCPROTOPRIVATE + 5) 19#define SIOCX25SCALLUSERDATA (SIOCPROTOPRIVATE + 5)
18#define SIOCX25GCAUSEDIAG (SIOCPROTOPRIVATE + 6) 20#define SIOCX25GCAUSEDIAG (SIOCPROTOPRIVATE + 6)
21#define SIOCX25SCUDMATCHLEN (SIOCPROTOPRIVATE + 7)
22#define SIOCX25CALLACCPTAPPRV (SIOCPROTOPRIVATE + 8)
23#define SIOCX25SENDCALLACCPT (SIOCPROTOPRIVATE + 9)
19 24
20/* 25/*
21 * Values for {get,set}sockopt. 26 * Values for {get,set}sockopt.
@@ -109,4 +114,11 @@ struct x25_causediag {
109 unsigned char diagnostic; 114 unsigned char diagnostic;
110}; 115};
111 116
117/*
118 * Further optional call user data match length selection
119 */
120struct x25_subaddr {
121 unsigned int cudmatchlength;
122};
123
112#endif 124#endif
diff --git a/include/net/x25.h b/include/net/x25.h
index 7a1ba5bbb868..8b39b98876e8 100644
--- a/include/net/x25.h
+++ b/include/net/x25.h
@@ -79,6 +79,8 @@ enum {
79#define X25_DEFAULT_PACKET_SIZE X25_PS128 /* Default Packet Size */ 79#define X25_DEFAULT_PACKET_SIZE X25_PS128 /* Default Packet Size */
80#define X25_DEFAULT_THROUGHPUT 0x0A /* Deafult Throughput */ 80#define X25_DEFAULT_THROUGHPUT 0x0A /* Deafult Throughput */
81#define X25_DEFAULT_REVERSE 0x00 /* Default Reverse Charging */ 81#define X25_DEFAULT_REVERSE 0x00 /* Default Reverse Charging */
82#define X25_DENY_ACCPT_APPRV 0x01 /* Default value */
83#define X25_ALLOW_ACCPT_APPRV 0x00 /* Control enabled */
82 84
83#define X25_SMODULUS 8 85#define X25_SMODULUS 8
84#define X25_EMODULUS 128 86#define X25_EMODULUS 128
@@ -94,7 +96,7 @@ enum {
94#define X25_FAC_CLASS_C 0x80 96#define X25_FAC_CLASS_C 0x80
95#define X25_FAC_CLASS_D 0xC0 97#define X25_FAC_CLASS_D 0xC0
96 98
97#define X25_FAC_REVERSE 0x01 99#define X25_FAC_REVERSE 0x01 /* also fast select */
98#define X25_FAC_THROUGHPUT 0x02 100#define X25_FAC_THROUGHPUT 0x02
99#define X25_FAC_PACKET_SIZE 0x42 101#define X25_FAC_PACKET_SIZE 0x42
100#define X25_FAC_WINDOW_SIZE 0x43 102#define X25_FAC_WINDOW_SIZE 0x43
@@ -134,8 +136,8 @@ struct x25_sock {
134 struct sock sk; 136 struct sock sk;
135 struct x25_address source_addr, dest_addr; 137 struct x25_address source_addr, dest_addr;
136 struct x25_neigh *neighbour; 138 struct x25_neigh *neighbour;
137 unsigned int lci; 139 unsigned int lci, cudmatchlength;
138 unsigned char state, condition, qbitincl, intflag; 140 unsigned char state, condition, qbitincl, intflag, accptapprv;
139 unsigned short vs, vr, va, vl; 141 unsigned short vs, vr, va, vl;
140 unsigned long t2, t21, t22, t23; 142 unsigned long t2, t21, t22, t23;
141 unsigned short fraglen; 143 unsigned short fraglen;
@@ -242,7 +244,6 @@ extern int x25_validate_nr(struct sock *, unsigned short);
242extern void x25_write_internal(struct sock *, int); 244extern void x25_write_internal(struct sock *, int);
243extern int x25_decode(struct sock *, struct sk_buff *, int *, int *, int *, int *, int *); 245extern int x25_decode(struct sock *, struct sk_buff *, int *, int *, int *, int *, int *);
244extern void x25_disconnect(struct sock *, int, unsigned char, unsigned char); 246extern void x25_disconnect(struct sock *, int, unsigned char, unsigned char);
245extern int x25_check_calluserdata(struct x25_calluserdata *,struct x25_calluserdata *);
246 247
247/* x25_timer.c */ 248/* x25_timer.c */
248extern void x25_start_heartbeat(struct sock *); 249extern void x25_start_heartbeat(struct sock *);
diff --git a/net/appletalk/aarp.c b/net/appletalk/aarp.c
index 10d040461021..c34614ea5fce 100644
--- a/net/appletalk/aarp.c
+++ b/net/appletalk/aarp.c
@@ -35,6 +35,7 @@
35#include <net/datalink.h> 35#include <net/datalink.h>
36#include <net/psnap.h> 36#include <net/psnap.h>
37#include <linux/atalk.h> 37#include <linux/atalk.h>
38#include <linux/delay.h>
38#include <linux/init.h> 39#include <linux/init.h>
39#include <linux/proc_fs.h> 40#include <linux/proc_fs.h>
40#include <linux/seq_file.h> 41#include <linux/seq_file.h>
@@ -462,8 +463,7 @@ void aarp_probe_network(struct atalk_iface *atif)
462 aarp_send_probe(atif->dev, &atif->address); 463 aarp_send_probe(atif->dev, &atif->address);
463 464
464 /* Defer 1/10th */ 465 /* Defer 1/10th */
465 current->state = TASK_INTERRUPTIBLE; 466 msleep(100);
466 schedule_timeout(HZ / 10);
467 467
468 if (atif->status & ATIF_PROBE_FAIL) 468 if (atif->status & ATIF_PROBE_FAIL)
469 break; 469 break;
@@ -510,9 +510,8 @@ int aarp_proxy_probe_network(struct atalk_iface *atif, struct atalk_addr *sa)
510 aarp_send_probe(atif->dev, sa); 510 aarp_send_probe(atif->dev, sa);
511 511
512 /* Defer 1/10th */ 512 /* Defer 1/10th */
513 current->state = TASK_INTERRUPTIBLE;
514 write_unlock_bh(&aarp_lock); 513 write_unlock_bh(&aarp_lock);
515 schedule_timeout(HZ / 10); 514 msleep(100);
516 write_lock_bh(&aarp_lock); 515 write_lock_bh(&aarp_lock);
517 516
518 if (entry->status & ATIF_PROBE_FAIL) 517 if (entry->status & ATIF_PROBE_FAIL)
diff --git a/net/bridge/netfilter/ebtables.c b/net/bridge/netfilter/ebtables.c
index 18ebc664769b..c4540144f0f4 100644
--- a/net/bridge/netfilter/ebtables.c
+++ b/net/bridge/netfilter/ebtables.c
@@ -859,8 +859,7 @@ static int translate_table(struct ebt_replace *repl,
859 if (repl->valid_hooks & (1 << i)) 859 if (repl->valid_hooks & (1 << i))
860 if (check_chainloops(newinfo->hook_entry[i], 860 if (check_chainloops(newinfo->hook_entry[i],
861 cl_s, udc_cnt, i, newinfo->entries)) { 861 cl_s, udc_cnt, i, newinfo->entries)) {
862 if (cl_s) 862 vfree(cl_s);
863 vfree(cl_s);
864 return -EINVAL; 863 return -EINVAL;
865 } 864 }
866 865
@@ -883,8 +882,7 @@ static int translate_table(struct ebt_replace *repl,
883 EBT_ENTRY_ITERATE(newinfo->entries, newinfo->entries_size, 882 EBT_ENTRY_ITERATE(newinfo->entries, newinfo->entries_size,
884 ebt_cleanup_entry, &i); 883 ebt_cleanup_entry, &i);
885 } 884 }
886 if (cl_s) 885 vfree(cl_s);
887 vfree(cl_s);
888 return ret; 886 return ret;
889} 887}
890 888
@@ -1030,8 +1028,7 @@ static int do_replace(void __user *user, unsigned int len)
1030 } 1028 }
1031 vfree(table); 1029 vfree(table);
1032 1030
1033 if (counterstmp) 1031 vfree(counterstmp);
1034 vfree(counterstmp);
1035 return ret; 1032 return ret;
1036 1033
1037free_unlock: 1034free_unlock:
@@ -1040,8 +1037,7 @@ free_iterate:
1040 EBT_ENTRY_ITERATE(newinfo->entries, newinfo->entries_size, 1037 EBT_ENTRY_ITERATE(newinfo->entries, newinfo->entries_size,
1041 ebt_cleanup_entry, NULL); 1038 ebt_cleanup_entry, NULL);
1042free_counterstmp: 1039free_counterstmp:
1043 if (counterstmp) 1040 vfree(counterstmp);
1044 vfree(counterstmp);
1045 /* can be initialized in translate_table() */ 1041 /* can be initialized in translate_table() */
1046 if (newinfo->chainstack) { 1042 if (newinfo->chainstack) {
1047 for (i = 0; i < num_possible_cpus(); i++) 1043 for (i = 0; i < num_possible_cpus(); i++)
@@ -1049,11 +1045,9 @@ free_counterstmp:
1049 vfree(newinfo->chainstack); 1045 vfree(newinfo->chainstack);
1050 } 1046 }
1051free_entries: 1047free_entries:
1052 if (newinfo->entries) 1048 vfree(newinfo->entries);
1053 vfree(newinfo->entries);
1054free_newinfo: 1049free_newinfo:
1055 if (newinfo) 1050 vfree(newinfo);
1056 vfree(newinfo);
1057 return ret; 1051 return ret;
1058} 1052}
1059 1053
@@ -1213,8 +1207,7 @@ void ebt_unregister_table(struct ebt_table *table)
1213 down(&ebt_mutex); 1207 down(&ebt_mutex);
1214 LIST_DELETE(&ebt_tables, table); 1208 LIST_DELETE(&ebt_tables, table);
1215 up(&ebt_mutex); 1209 up(&ebt_mutex);
1216 if (table->private->entries) 1210 vfree(table->private->entries);
1217 vfree(table->private->entries);
1218 if (table->private->chainstack) { 1211 if (table->private->chainstack) {
1219 for (i = 0; i < num_possible_cpus(); i++) 1212 for (i = 0; i < num_possible_cpus(); i++)
1220 vfree(table->private->chainstack[i]); 1213 vfree(table->private->chainstack[i]);
diff --git a/net/core/netpoll.c b/net/core/netpoll.c
index a119696d5521..c327c9edadc5 100644
--- a/net/core/netpoll.c
+++ b/net/core/netpoll.c
@@ -130,19 +130,20 @@ static int checksum_udp(struct sk_buff *skb, struct udphdr *uh,
130 */ 130 */
131static void poll_napi(struct netpoll *np) 131static void poll_napi(struct netpoll *np)
132{ 132{
133 struct netpoll_info *npinfo = np->dev->npinfo;
133 int budget = 16; 134 int budget = 16;
134 135
135 if (test_bit(__LINK_STATE_RX_SCHED, &np->dev->state) && 136 if (test_bit(__LINK_STATE_RX_SCHED, &np->dev->state) &&
136 np->poll_owner != smp_processor_id() && 137 npinfo->poll_owner != smp_processor_id() &&
137 spin_trylock(&np->poll_lock)) { 138 spin_trylock(&npinfo->poll_lock)) {
138 np->rx_flags |= NETPOLL_RX_DROP; 139 npinfo->rx_flags |= NETPOLL_RX_DROP;
139 atomic_inc(&trapped); 140 atomic_inc(&trapped);
140 141
141 np->dev->poll(np->dev, &budget); 142 np->dev->poll(np->dev, &budget);
142 143
143 atomic_dec(&trapped); 144 atomic_dec(&trapped);
144 np->rx_flags &= ~NETPOLL_RX_DROP; 145 npinfo->rx_flags &= ~NETPOLL_RX_DROP;
145 spin_unlock(&np->poll_lock); 146 spin_unlock(&npinfo->poll_lock);
146 } 147 }
147} 148}
148 149
@@ -245,6 +246,7 @@ repeat:
245static void netpoll_send_skb(struct netpoll *np, struct sk_buff *skb) 246static void netpoll_send_skb(struct netpoll *np, struct sk_buff *skb)
246{ 247{
247 int status; 248 int status;
249 struct netpoll_info *npinfo;
248 250
249repeat: 251repeat:
250 if(!np || !np->dev || !netif_running(np->dev)) { 252 if(!np || !np->dev || !netif_running(np->dev)) {
@@ -253,8 +255,9 @@ repeat:
253 } 255 }
254 256
255 /* avoid recursion */ 257 /* avoid recursion */
256 if(np->poll_owner == smp_processor_id() || 258 npinfo = np->dev->npinfo;
257 np->dev->xmit_lock_owner == smp_processor_id()) { 259 if (npinfo->poll_owner == smp_processor_id() ||
260 np->dev->xmit_lock_owner == smp_processor_id()) {
258 if (np->drop) 261 if (np->drop)
259 np->drop(skb); 262 np->drop(skb);
260 else 263 else
@@ -341,14 +344,22 @@ void netpoll_send_udp(struct netpoll *np, const char *msg, int len)
341 344
342static void arp_reply(struct sk_buff *skb) 345static void arp_reply(struct sk_buff *skb)
343{ 346{
347 struct netpoll_info *npinfo = skb->dev->npinfo;
344 struct arphdr *arp; 348 struct arphdr *arp;
345 unsigned char *arp_ptr; 349 unsigned char *arp_ptr;
346 int size, type = ARPOP_REPLY, ptype = ETH_P_ARP; 350 int size, type = ARPOP_REPLY, ptype = ETH_P_ARP;
347 u32 sip, tip; 351 u32 sip, tip;
352 unsigned long flags;
348 struct sk_buff *send_skb; 353 struct sk_buff *send_skb;
349 struct netpoll *np = skb->dev->np; 354 struct netpoll *np = NULL;
355
356 spin_lock_irqsave(&npinfo->rx_lock, flags);
357 if (npinfo->rx_np && npinfo->rx_np->dev == skb->dev)
358 np = npinfo->rx_np;
359 spin_unlock_irqrestore(&npinfo->rx_lock, flags);
350 360
351 if (!np) return; 361 if (!np)
362 return;
352 363
353 /* No arp on this interface */ 364 /* No arp on this interface */
354 if (skb->dev->flags & IFF_NOARP) 365 if (skb->dev->flags & IFF_NOARP)
@@ -429,9 +440,9 @@ int __netpoll_rx(struct sk_buff *skb)
429 int proto, len, ulen; 440 int proto, len, ulen;
430 struct iphdr *iph; 441 struct iphdr *iph;
431 struct udphdr *uh; 442 struct udphdr *uh;
432 struct netpoll *np = skb->dev->np; 443 struct netpoll *np = skb->dev->npinfo->rx_np;
433 444
434 if (!np->rx_hook) 445 if (!np)
435 goto out; 446 goto out;
436 if (skb->dev->type != ARPHRD_ETHER) 447 if (skb->dev->type != ARPHRD_ETHER)
437 goto out; 448 goto out;
@@ -611,9 +622,8 @@ int netpoll_setup(struct netpoll *np)
611{ 622{
612 struct net_device *ndev = NULL; 623 struct net_device *ndev = NULL;
613 struct in_device *in_dev; 624 struct in_device *in_dev;
614 625 struct netpoll_info *npinfo;
615 np->poll_lock = SPIN_LOCK_UNLOCKED; 626 unsigned long flags;
616 np->poll_owner = -1;
617 627
618 if (np->dev_name) 628 if (np->dev_name)
619 ndev = dev_get_by_name(np->dev_name); 629 ndev = dev_get_by_name(np->dev_name);
@@ -624,7 +634,17 @@ int netpoll_setup(struct netpoll *np)
624 } 634 }
625 635
626 np->dev = ndev; 636 np->dev = ndev;
627 ndev->np = np; 637 if (!ndev->npinfo) {
638 npinfo = kmalloc(sizeof(*npinfo), GFP_KERNEL);
639 if (!npinfo)
640 goto release;
641
642 npinfo->rx_np = NULL;
643 npinfo->poll_lock = SPIN_LOCK_UNLOCKED;
644 npinfo->poll_owner = -1;
645 npinfo->rx_lock = SPIN_LOCK_UNLOCKED;
646 } else
647 npinfo = ndev->npinfo;
628 648
629 if (!ndev->poll_controller) { 649 if (!ndev->poll_controller) {
630 printk(KERN_ERR "%s: %s doesn't support polling, aborting.\n", 650 printk(KERN_ERR "%s: %s doesn't support polling, aborting.\n",
@@ -692,13 +712,20 @@ int netpoll_setup(struct netpoll *np)
692 np->name, HIPQUAD(np->local_ip)); 712 np->name, HIPQUAD(np->local_ip));
693 } 713 }
694 714
695 if(np->rx_hook) 715 if (np->rx_hook) {
696 np->rx_flags = NETPOLL_RX_ENABLED; 716 spin_lock_irqsave(&npinfo->rx_lock, flags);
717 npinfo->rx_flags |= NETPOLL_RX_ENABLED;
718 npinfo->rx_np = np;
719 spin_unlock_irqrestore(&npinfo->rx_lock, flags);
720 }
721 /* last thing to do is link it to the net device structure */
722 ndev->npinfo = npinfo;
697 723
698 return 0; 724 return 0;
699 725
700 release: 726 release:
701 ndev->np = NULL; 727 if (!ndev->npinfo)
728 kfree(npinfo);
702 np->dev = NULL; 729 np->dev = NULL;
703 dev_put(ndev); 730 dev_put(ndev);
704 return -1; 731 return -1;
@@ -706,9 +733,20 @@ int netpoll_setup(struct netpoll *np)
706 733
707void netpoll_cleanup(struct netpoll *np) 734void netpoll_cleanup(struct netpoll *np)
708{ 735{
709 if (np->dev) 736 struct netpoll_info *npinfo;
710 np->dev->np = NULL; 737 unsigned long flags;
711 dev_put(np->dev); 738
739 if (np->dev) {
740 npinfo = np->dev->npinfo;
741 if (npinfo && npinfo->rx_np == np) {
742 spin_lock_irqsave(&npinfo->rx_lock, flags);
743 npinfo->rx_np = NULL;
744 npinfo->rx_flags &= ~NETPOLL_RX_ENABLED;
745 spin_unlock_irqrestore(&npinfo->rx_lock, flags);
746 }
747 dev_put(np->dev);
748 }
749
712 np->dev = NULL; 750 np->dev = NULL;
713} 751}
714 752
diff --git a/net/ipv4/netfilter/ipt_CLUSTERIP.c b/net/ipv4/netfilter/ipt_CLUSTERIP.c
index dc4362b57cfa..9cde8c61f525 100644
--- a/net/ipv4/netfilter/ipt_CLUSTERIP.c
+++ b/net/ipv4/netfilter/ipt_CLUSTERIP.c
@@ -339,7 +339,7 @@ target(struct sk_buff **pskb,
339 * error messages (RELATED) and information requests (see below) */ 339 * error messages (RELATED) and information requests (see below) */
340 if ((*pskb)->nh.iph->protocol == IPPROTO_ICMP 340 if ((*pskb)->nh.iph->protocol == IPPROTO_ICMP
341 && (ctinfo == IP_CT_RELATED 341 && (ctinfo == IP_CT_RELATED
342 || ctinfo == IP_CT_IS_REPLY+IP_CT_IS_REPLY)) 342 || ctinfo == IP_CT_RELATED+IP_CT_IS_REPLY))
343 return IPT_CONTINUE; 343 return IPT_CONTINUE;
344 344
345 /* ip_conntrack_icmp guarantees us that we only have ICMP_ECHO, 345 /* ip_conntrack_icmp guarantees us that we only have ICMP_ECHO,
diff --git a/net/ipv4/route.c b/net/ipv4/route.c
index f4d53c919869..80cf633d9f4a 100644
--- a/net/ipv4/route.c
+++ b/net/ipv4/route.c
@@ -1767,7 +1767,7 @@ static inline int ip_mkroute_input_def(struct sk_buff *skb,
1767 struct in_device *in_dev, 1767 struct in_device *in_dev,
1768 u32 daddr, u32 saddr, u32 tos) 1768 u32 daddr, u32 saddr, u32 tos)
1769{ 1769{
1770 struct rtable* rth; 1770 struct rtable* rth = NULL;
1771 int err; 1771 int err;
1772 unsigned hash; 1772 unsigned hash;
1773 1773
@@ -1794,7 +1794,7 @@ static inline int ip_mkroute_input(struct sk_buff *skb,
1794 u32 daddr, u32 saddr, u32 tos) 1794 u32 daddr, u32 saddr, u32 tos)
1795{ 1795{
1796#ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED 1796#ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
1797 struct rtable* rth; 1797 struct rtable* rth = NULL;
1798 unsigned char hop, hopcount, lasthop; 1798 unsigned char hop, hopcount, lasthop;
1799 int err = -EINVAL; 1799 int err = -EINVAL;
1800 unsigned int hash; 1800 unsigned int hash;
@@ -2239,7 +2239,7 @@ static inline int ip_mkroute_output_def(struct rtable **rp,
2239 struct net_device *dev_out, 2239 struct net_device *dev_out,
2240 unsigned flags) 2240 unsigned flags)
2241{ 2241{
2242 struct rtable *rth; 2242 struct rtable *rth = NULL;
2243 int err = __mkroute_output(&rth, res, fl, oldflp, dev_out, flags); 2243 int err = __mkroute_output(&rth, res, fl, oldflp, dev_out, flags);
2244 unsigned hash; 2244 unsigned hash;
2245 if (err == 0) { 2245 if (err == 0) {
@@ -2267,7 +2267,7 @@ static inline int ip_mkroute_output(struct rtable** rp,
2267 unsigned char hop; 2267 unsigned char hop;
2268 unsigned hash; 2268 unsigned hash;
2269 int err = -EINVAL; 2269 int err = -EINVAL;
2270 struct rtable *rth; 2270 struct rtable *rth = NULL;
2271 2271
2272 if (res->fi && res->fi->fib_nhs > 1) { 2272 if (res->fi && res->fi->fib_nhs > 1) {
2273 unsigned char hopcount = res->fi->fib_nhs; 2273 unsigned char hopcount = res->fi->fib_nhs;
diff --git a/net/socket.c b/net/socket.c
index 38729af09461..6f2a17881972 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -383,9 +383,8 @@ int sock_map_fd(struct socket *sock)
383 goto out; 383 goto out;
384 } 384 }
385 385
386 sprintf(name, "[%lu]", SOCK_INODE(sock)->i_ino); 386 this.len = sprintf(name, "[%lu]", SOCK_INODE(sock)->i_ino);
387 this.name = name; 387 this.name = name;
388 this.len = strlen(name);
389 this.hash = SOCK_INODE(sock)->i_ino; 388 this.hash = SOCK_INODE(sock)->i_ino;
390 389
391 file->f_dentry = d_alloc(sock_mnt->mnt_sb->s_root, &this); 390 file->f_dentry = d_alloc(sock_mnt->mnt_sb->s_root, &this);
diff --git a/net/x25/af_x25.c b/net/x25/af_x25.c
index 2a24b243b841..04bec047fa9a 100644
--- a/net/x25/af_x25.c
+++ b/net/x25/af_x25.c
@@ -29,6 +29,10 @@
29 * 2000-11-14 Henner Eisen Closing datalink from NETDEV_GOING_DOWN 29 * 2000-11-14 Henner Eisen Closing datalink from NETDEV_GOING_DOWN
30 * 2002-10-06 Arnaldo C. Melo Get rid of cli/sti, move proc stuff to 30 * 2002-10-06 Arnaldo C. Melo Get rid of cli/sti, move proc stuff to
31 * x25_proc.c, using seq_file 31 * x25_proc.c, using seq_file
32 * 2005-04-02 Shaun Pereira Selective sub address matching
33 * with call user data
34 * 2005-04-15 Shaun Pereira Fast select with no restriction on
35 * response
32 */ 36 */
33 37
34#include <linux/config.h> 38#include <linux/config.h>
@@ -219,7 +223,8 @@ static void x25_insert_socket(struct sock *sk)
219 * Note: if a listening socket has cud set it must only get calls 223 * Note: if a listening socket has cud set it must only get calls
220 * with matching cud. 224 * with matching cud.
221 */ 225 */
222static struct sock *x25_find_listener(struct x25_address *addr, struct x25_calluserdata *calluserdata) 226static struct sock *x25_find_listener(struct x25_address *addr,
227 struct sk_buff *skb)
223{ 228{
224 struct sock *s; 229 struct sock *s;
225 struct sock *next_best; 230 struct sock *next_best;
@@ -230,22 +235,23 @@ static struct sock *x25_find_listener(struct x25_address *addr, struct x25_callu
230 235
231 sk_for_each(s, node, &x25_list) 236 sk_for_each(s, node, &x25_list)
232 if ((!strcmp(addr->x25_addr, 237 if ((!strcmp(addr->x25_addr,
233 x25_sk(s)->source_addr.x25_addr) || 238 x25_sk(s)->source_addr.x25_addr) ||
234 !strcmp(addr->x25_addr, 239 !strcmp(addr->x25_addr,
235 null_x25_address.x25_addr)) && 240 null_x25_address.x25_addr)) &&
236 s->sk_state == TCP_LISTEN) { 241 s->sk_state == TCP_LISTEN) {
237
238 /* 242 /*
239 * Found a listening socket, now check the incoming 243 * Found a listening socket, now check the incoming
240 * call user data vs this sockets call user data 244 * call user data vs this sockets call user data
241 */ 245 */
242 if (x25_check_calluserdata(&x25_sk(s)->calluserdata, calluserdata)) { 246 if(skb->len > 0 && x25_sk(s)->cudmatchlength > 0) {
243 sock_hold(s); 247 if((memcmp(x25_sk(s)->calluserdata.cuddata,
244 goto found; 248 skb->data,
245 } 249 x25_sk(s)->cudmatchlength)) == 0) {
246 if (x25_sk(s)->calluserdata.cudlength == 0) { 250 sock_hold(s);
251 goto found;
252 }
253 } else
247 next_best = s; 254 next_best = s;
248 }
249 } 255 }
250 if (next_best) { 256 if (next_best) {
251 s = next_best; 257 s = next_best;
@@ -497,6 +503,9 @@ static int x25_create(struct socket *sock, int protocol)
497 x25->t23 = sysctl_x25_clear_request_timeout; 503 x25->t23 = sysctl_x25_clear_request_timeout;
498 x25->t2 = sysctl_x25_ack_holdback_timeout; 504 x25->t2 = sysctl_x25_ack_holdback_timeout;
499 x25->state = X25_STATE_0; 505 x25->state = X25_STATE_0;
506 x25->cudmatchlength = 0;
507 x25->accptapprv = X25_DENY_ACCPT_APPRV; /* normally no cud */
508 /* on call accept */
500 509
501 x25->facilities.winsize_in = X25_DEFAULT_WINDOW_SIZE; 510 x25->facilities.winsize_in = X25_DEFAULT_WINDOW_SIZE;
502 x25->facilities.winsize_out = X25_DEFAULT_WINDOW_SIZE; 511 x25->facilities.winsize_out = X25_DEFAULT_WINDOW_SIZE;
@@ -545,6 +554,8 @@ static struct sock *x25_make_new(struct sock *osk)
545 x25->t2 = ox25->t2; 554 x25->t2 = ox25->t2;
546 x25->facilities = ox25->facilities; 555 x25->facilities = ox25->facilities;
547 x25->qbitincl = ox25->qbitincl; 556 x25->qbitincl = ox25->qbitincl;
557 x25->cudmatchlength = ox25->cudmatchlength;
558 x25->accptapprv = ox25->accptapprv;
548 559
549 x25_init_timers(sk); 560 x25_init_timers(sk);
550out: 561out:
@@ -822,7 +833,6 @@ int x25_rx_call_request(struct sk_buff *skb, struct x25_neigh *nb,
822 struct x25_sock *makex25; 833 struct x25_sock *makex25;
823 struct x25_address source_addr, dest_addr; 834 struct x25_address source_addr, dest_addr;
824 struct x25_facilities facilities; 835 struct x25_facilities facilities;
825 struct x25_calluserdata calluserdata;
826 int len, rc; 836 int len, rc;
827 837
828 /* 838 /*
@@ -845,19 +855,10 @@ int x25_rx_call_request(struct sk_buff *skb, struct x25_neigh *nb,
845 skb_pull(skb,len); 855 skb_pull(skb,len);
846 856
847 /* 857 /*
848 * Incoming Call User Data.
849 */
850 if (skb->len >= 0) {
851 memcpy(calluserdata.cuddata, skb->data, skb->len);
852 calluserdata.cudlength = skb->len;
853 }
854
855 skb_push(skb,len);
856
857 /*
858 * Find a listener for the particular address/cud pair. 858 * Find a listener for the particular address/cud pair.
859 */ 859 */
860 sk = x25_find_listener(&source_addr,&calluserdata); 860 sk = x25_find_listener(&source_addr,skb);
861 skb_push(skb,len);
861 862
862 /* 863 /*
863 * We can't accept the Call Request. 864 * We can't accept the Call Request.
@@ -900,11 +901,23 @@ int x25_rx_call_request(struct sk_buff *skb, struct x25_neigh *nb,
900 makex25->neighbour = nb; 901 makex25->neighbour = nb;
901 makex25->facilities = facilities; 902 makex25->facilities = facilities;
902 makex25->vc_facil_mask = x25_sk(sk)->vc_facil_mask; 903 makex25->vc_facil_mask = x25_sk(sk)->vc_facil_mask;
903 makex25->calluserdata = calluserdata; 904 /* ensure no reverse facil on accept */
904 905 makex25->vc_facil_mask &= ~X25_MASK_REVERSE;
905 x25_write_internal(make, X25_CALL_ACCEPTED); 906 makex25->cudmatchlength = x25_sk(sk)->cudmatchlength;
907
908 /* Normally all calls are accepted immediatly */
909 if(makex25->accptapprv & X25_DENY_ACCPT_APPRV) {
910 x25_write_internal(make, X25_CALL_ACCEPTED);
911 makex25->state = X25_STATE_3;
912 }
906 913
907 makex25->state = X25_STATE_3; 914 /*
915 * Incoming Call User Data.
916 */
917 if (skb->len >= 0) {
918 memcpy(makex25->calluserdata.cuddata, skb->data, skb->len);
919 makex25->calluserdata.cudlength = skb->len;
920 }
908 921
909 sk->sk_ack_backlog++; 922 sk->sk_ack_backlog++;
910 923
@@ -1288,7 +1301,8 @@ static int x25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1288 if (facilities.throughput < 0x03 || 1301 if (facilities.throughput < 0x03 ||
1289 facilities.throughput > 0xDD) 1302 facilities.throughput > 0xDD)
1290 break; 1303 break;
1291 if (facilities.reverse && facilities.reverse != 1) 1304 if (facilities.reverse &&
1305 (facilities.reverse | 0x81)!= 0x81)
1292 break; 1306 break;
1293 x25->facilities = facilities; 1307 x25->facilities = facilities;
1294 rc = 0; 1308 rc = 0;
@@ -1325,6 +1339,44 @@ static int x25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1325 break; 1339 break;
1326 } 1340 }
1327 1341
1342 case SIOCX25SCUDMATCHLEN: {
1343 struct x25_subaddr sub_addr;
1344 rc = -EINVAL;
1345 if(sk->sk_state != TCP_CLOSE)
1346 break;
1347 rc = -EFAULT;
1348 if (copy_from_user(&sub_addr, argp,
1349 sizeof(sub_addr)))
1350 break;
1351 rc = -EINVAL;
1352 if(sub_addr.cudmatchlength > X25_MAX_CUD_LEN)
1353 break;
1354 x25->cudmatchlength = sub_addr.cudmatchlength;
1355 rc = 0;
1356 break;
1357 }
1358
1359 case SIOCX25CALLACCPTAPPRV: {
1360 rc = -EINVAL;
1361 if (sk->sk_state != TCP_CLOSE)
1362 break;
1363 x25->accptapprv = X25_ALLOW_ACCPT_APPRV;
1364 rc = 0;
1365 break;
1366 }
1367
1368 case SIOCX25SENDCALLACCPT: {
1369 rc = -EINVAL;
1370 if (sk->sk_state != TCP_ESTABLISHED)
1371 break;
1372 if (x25->accptapprv) /* must call accptapprv above */
1373 break;
1374 x25_write_internal(sk, X25_CALL_ACCEPTED);
1375 x25->state = X25_STATE_3;
1376 rc = 0;
1377 break;
1378 }
1379
1328 default: 1380 default:
1329 rc = dev_ioctl(cmd, argp); 1381 rc = dev_ioctl(cmd, argp);
1330 break; 1382 break;
diff --git a/net/x25/x25_facilities.c b/net/x25/x25_facilities.c
index a21bdb95f9a8..54278b962f4c 100644
--- a/net/x25/x25_facilities.c
+++ b/net/x25/x25_facilities.c
@@ -17,6 +17,8 @@
17 * X.25 001 Split from x25_subr.c 17 * X.25 001 Split from x25_subr.c
18 * mar/20/00 Daniela Squassoni Disabling/enabling of facilities 18 * mar/20/00 Daniela Squassoni Disabling/enabling of facilities
19 * negotiation. 19 * negotiation.
20 * apr/14/05 Shaun Pereira - Allow fast select with no restriction
21 * on response.
20 */ 22 */
21 23
22#include <linux/kernel.h> 24#include <linux/kernel.h>
@@ -43,9 +45,31 @@ int x25_parse_facilities(struct sk_buff *skb,
43 case X25_FAC_CLASS_A: 45 case X25_FAC_CLASS_A:
44 switch (*p) { 46 switch (*p) {
45 case X25_FAC_REVERSE: 47 case X25_FAC_REVERSE:
46 facilities->reverse = p[1] & 0x01; 48 if((p[1] & 0x81) == 0x81) {
47 *vc_fac_mask |= X25_MASK_REVERSE; 49 facilities->reverse = p[1] & 0x81;
48 break; 50 *vc_fac_mask |= X25_MASK_REVERSE;
51 break;
52 }
53
54 if((p[1] & 0x01) == 0x01) {
55 facilities->reverse = p[1] & 0x01;
56 *vc_fac_mask |= X25_MASK_REVERSE;
57 break;
58 }
59
60 if((p[1] & 0x80) == 0x80) {
61 facilities->reverse = p[1] & 0x80;
62 *vc_fac_mask |= X25_MASK_REVERSE;
63 break;
64 }
65
66 if(p[1] == 0x00) {
67 facilities->reverse
68 = X25_DEFAULT_REVERSE;
69 *vc_fac_mask |= X25_MASK_REVERSE;
70 break;
71 }
72
49 case X25_FAC_THROUGHPUT: 73 case X25_FAC_THROUGHPUT:
50 facilities->throughput = p[1]; 74 facilities->throughput = p[1];
51 *vc_fac_mask |= X25_MASK_THROUGHPUT; 75 *vc_fac_mask |= X25_MASK_THROUGHPUT;
@@ -122,7 +146,7 @@ int x25_create_facilities(unsigned char *buffer,
122 146
123 if (facilities->reverse && (facil_mask & X25_MASK_REVERSE)) { 147 if (facilities->reverse && (facil_mask & X25_MASK_REVERSE)) {
124 *p++ = X25_FAC_REVERSE; 148 *p++ = X25_FAC_REVERSE;
125 *p++ = !!facilities->reverse; 149 *p++ = facilities->reverse;
126 } 150 }
127 151
128 if (facilities->throughput && (facil_mask & X25_MASK_THROUGHPUT)) { 152 if (facilities->throughput && (facil_mask & X25_MASK_THROUGHPUT)) {
@@ -171,7 +195,7 @@ int x25_negotiate_facilities(struct sk_buff *skb, struct sock *sk,
171 /* 195 /*
172 * They want reverse charging, we won't accept it. 196 * They want reverse charging, we won't accept it.
173 */ 197 */
174 if (theirs.reverse && ours->reverse) { 198 if ((theirs.reverse & 0x01 ) && (ours->reverse & 0x01)) {
175 SOCK_DEBUG(sk, "X.25: rejecting reverse charging request"); 199 SOCK_DEBUG(sk, "X.25: rejecting reverse charging request");
176 return -1; 200 return -1;
177 } 201 }
diff --git a/net/x25/x25_subr.c b/net/x25/x25_subr.c
index 183fea3bba67..7fd872ad0c20 100644
--- a/net/x25/x25_subr.c
+++ b/net/x25/x25_subr.c
@@ -19,6 +19,8 @@
19 * mar/20/00 Daniela Squassoni Disabling/enabling of facilities 19 * mar/20/00 Daniela Squassoni Disabling/enabling of facilities
20 * negotiation. 20 * negotiation.
21 * jun/24/01 Arnaldo C. Melo use skb_queue_purge, cleanups 21 * jun/24/01 Arnaldo C. Melo use skb_queue_purge, cleanups
22 * apr/04/15 Shaun Pereira Fast select with no
23 * restriction on response.
22 */ 24 */
23 25
24#include <linux/kernel.h> 26#include <linux/kernel.h>
@@ -127,8 +129,12 @@ void x25_write_internal(struct sock *sk, int frametype)
127 len += 1 + X25_ADDR_LEN + X25_MAX_FAC_LEN + 129 len += 1 + X25_ADDR_LEN + X25_MAX_FAC_LEN +
128 X25_MAX_CUD_LEN; 130 X25_MAX_CUD_LEN;
129 break; 131 break;
130 case X25_CALL_ACCEPTED: 132 case X25_CALL_ACCEPTED: /* fast sel with no restr on resp */
131 len += 1 + X25_MAX_FAC_LEN + X25_MAX_CUD_LEN; 133 if(x25->facilities.reverse & 0x80) {
134 len += 1 + X25_MAX_FAC_LEN + X25_MAX_CUD_LEN;
135 } else {
136 len += 1 + X25_MAX_FAC_LEN;
137 }
132 break; 138 break;
133 case X25_CLEAR_REQUEST: 139 case X25_CLEAR_REQUEST:
134 case X25_RESET_REQUEST: 140 case X25_RESET_REQUEST:
@@ -203,9 +209,16 @@ void x25_write_internal(struct sock *sk, int frametype)
203 x25->vc_facil_mask); 209 x25->vc_facil_mask);
204 dptr = skb_put(skb, len); 210 dptr = skb_put(skb, len);
205 memcpy(dptr, facilities, len); 211 memcpy(dptr, facilities, len);
206 dptr = skb_put(skb, x25->calluserdata.cudlength); 212
207 memcpy(dptr, x25->calluserdata.cuddata, 213 /* fast select with no restriction on response
208 x25->calluserdata.cudlength); 214 allows call user data. Userland must
215 ensure it is ours and not theirs */
216 if(x25->facilities.reverse & 0x80) {
217 dptr = skb_put(skb,
218 x25->calluserdata.cudlength);
219 memcpy(dptr, x25->calluserdata.cuddata,
220 x25->calluserdata.cudlength);
221 }
209 x25->calluserdata.cudlength = 0; 222 x25->calluserdata.cudlength = 0;
210 break; 223 break;
211 224
@@ -354,21 +367,3 @@ void x25_check_rbuf(struct sock *sk)
354 } 367 }
355} 368}
356 369
357/*
358 * Compare 2 calluserdata structures, used to find correct listening sockets
359 * when call user data is used.
360 */
361int x25_check_calluserdata(struct x25_calluserdata *ours, struct x25_calluserdata *theirs)
362{
363 int i;
364 if (ours->cudlength != theirs->cudlength)
365 return 0;
366
367 for (i=0;i<ours->cudlength;i++) {
368 if (ours->cuddata[i] != theirs->cuddata[i]) {
369 return 0;
370 }
371 }
372 return 1;
373}
374
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-21 08:12:56 -0500