blob: 689482cd16c2f4a17876f4edf2390441bdc561e7 [file] [log] [blame]
Herbert Xuef2736f2005-06-22 13:26:03 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * Quick & dirty crypto testing module.
3 *
4 * This will only exist until we have a better testing mechanism
5 * (e.g. a char device).
6 *
7 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
8 * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
Mikko Herranene3a4ea42007-11-26 22:12:07 +08009 * Copyright (c) 2007 Nokia Siemens Networks
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 *
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the Free
Herbert Xuef2736f2005-06-22 13:26:03 -070013 * Software Foundation; either version 2 of the License, or (at your option)
Linus Torvalds1da177e2005-04-16 15:20:36 -070014 * any later version.
15 *
Mikko Herranen28db8e32007-11-26 22:24:11 +080016 * 2007-11-13 Added GCM tests
Mikko Herranene3a4ea42007-11-26 22:12:07 +080017 * 2007-11-13 Added AEAD support
Jonathan Lynchcd12fb92007-11-10 20:08:25 +080018 * 2007-11-06 Added SHA-224 and SHA-224-HMAC tests
Andrew Donofrioa28091a2006-12-10 12:10:20 +110019 * 2006-12-07 Added SHA384 HMAC and SHA512 HMAC tests
Harald Welteebfd9bc2005-06-22 13:27:23 -070020 * 2004-08-09 Added cipher speed tests (Reyk Floeter <reyk@vantronix.net>)
21 * 2003-09-14 Rewritten by Kartikey Mahendra Bhatt
22 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070023 */
24
Herbert Xucba83562006-08-13 08:26:09 +100025#include <linux/err.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/init.h>
27#include <linux/module.h>
28#include <linux/mm.h>
29#include <linux/slab.h>
David Hardeman378f0582005-09-17 17:55:31 +100030#include <linux/scatterlist.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <linux/string.h>
32#include <linux/crypto.h>
33#include <linux/highmem.h>
34#include <linux/moduleparam.h>
Harald Welteebfd9bc2005-06-22 13:27:23 -070035#include <linux/jiffies.h>
Herbert Xu6a179442005-06-22 13:29:03 -070036#include <linux/timex.h>
37#include <linux/interrupt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include "tcrypt.h"
39
40/*
41 * Need to kmalloc() memory for testing kmap().
42 */
Harald Welteebfd9bc2005-06-22 13:27:23 -070043#define TVMEMSIZE 16384
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#define XBUFSIZE 32768
45
46/*
47 * Indexes into the xbuf to simulate cross-page access.
48 */
49#define IDX1 37
50#define IDX2 32400
51#define IDX3 1
52#define IDX4 8193
53#define IDX5 22222
54#define IDX6 17101
55#define IDX7 27333
56#define IDX8 3000
57
58/*
59* Used by test_cipher()
60*/
61#define ENCRYPT 1
62#define DECRYPT 0
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
Herbert Xu6158efc2007-04-04 17:41:07 +100064struct tcrypt_result {
65 struct completion completion;
66 int err;
67};
68
Linus Torvalds1da177e2005-04-16 15:20:36 -070069static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
70
Harald Welteebfd9bc2005-06-22 13:27:23 -070071/*
72 * Used by test_cipher_speed()
73 */
Herbert Xu6a179442005-06-22 13:29:03 -070074static unsigned int sec;
Harald Welteebfd9bc2005-06-22 13:27:23 -070075
Linus Torvalds1da177e2005-04-16 15:20:36 -070076static int mode;
77static char *xbuf;
Mikko Herranene3a4ea42007-11-26 22:12:07 +080078static char *axbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -070079static char *tvmem;
80
81static char *check[] = {
Jonathan Lynchcd12fb92007-11-10 20:08:25 +080082 "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256",
83 "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes",
84 "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
David Howells90831632006-12-16 12:13:14 +110085 "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", "fcrypt",
Kevin Coffman76cb9522008-03-24 21:26:16 +080086 "camellia", "seed", "salsa20", "lzo", "cts", NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -070087};
88
Herbert Xuef2736f2005-06-22 13:26:03 -070089static void hexdump(unsigned char *buf, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -070090{
Denis Chenga10e1192007-11-30 16:59:30 +110091 print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
92 16, 1,
93 buf, len, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094}
95
Herbert Xu6158efc2007-04-04 17:41:07 +100096static void tcrypt_complete(struct crypto_async_request *req, int err)
97{
98 struct tcrypt_result *res = req->data;
99
100 if (err == -EINPROGRESS)
101 return;
102
103 res->err = err;
104 complete(&res->completion);
105}
106
Herbert Xuef2736f2005-06-22 13:26:03 -0700107static void test_hash(char *algo, struct hash_testvec *template,
108 unsigned int tcount)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109{
Herbert Xuef2736f2005-06-22 13:26:03 -0700110 unsigned int i, j, k, temp;
111 struct scatterlist sg[8];
112 char result[64];
Herbert Xue9d41162006-08-19 21:38:49 +1000113 struct crypto_hash *tfm;
114 struct hash_desc desc;
Herbert Xue9d41162006-08-19 21:38:49 +1000115 int ret;
Sebastian Siewior562954d2008-03-13 20:20:28 +0800116 void *hash_buff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
Herbert Xuef2736f2005-06-22 13:26:03 -0700118 printk("\ntesting %s\n", algo);
119
Herbert Xue9d41162006-08-19 21:38:49 +1000120 tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
121 if (IS_ERR(tfm)) {
122 printk("failed to load transform for %s: %ld\n", algo,
123 PTR_ERR(tfm));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 return;
125 }
126
Herbert Xue9d41162006-08-19 21:38:49 +1000127 desc.tfm = tfm;
128 desc.flags = 0;
129
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 for (i = 0; i < tcount; i++) {
Herbert Xuef2736f2005-06-22 13:26:03 -0700131 printk("test %u:\n", i + 1);
132 memset(result, 0, 64);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133
Sebastian Siewior562954d2008-03-13 20:20:28 +0800134 hash_buff = kzalloc(template[i].psize, GFP_KERNEL);
135 if (!hash_buff)
136 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137
Sebastian Siewior562954d2008-03-13 20:20:28 +0800138 memcpy(hash_buff, template[i].plaintext, template[i].psize);
139 sg_init_one(&sg[0], hash_buff, template[i].psize);
140
141 if (template[i].ksize) {
142 ret = crypto_hash_setkey(tfm, template[i].key,
143 template[i].ksize);
Herbert Xue9d41162006-08-19 21:38:49 +1000144 if (ret) {
145 printk("setkey() failed ret=%d\n", ret);
Sebastian Siewior562954d2008-03-13 20:20:28 +0800146 kfree(hash_buff);
Herbert Xue9d41162006-08-19 21:38:49 +1000147 goto out;
148 }
149 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150
Sebastian Siewior562954d2008-03-13 20:20:28 +0800151 ret = crypto_hash_digest(&desc, sg, template[i].psize, result);
Herbert Xue9d41162006-08-19 21:38:49 +1000152 if (ret) {
153 printk("digest () failed ret=%d\n", ret);
Sebastian Siewior562954d2008-03-13 20:20:28 +0800154 kfree(hash_buff);
Herbert Xue9d41162006-08-19 21:38:49 +1000155 goto out;
156 }
157
158 hexdump(result, crypto_hash_digestsize(tfm));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 printk("%s\n",
Sebastian Siewior562954d2008-03-13 20:20:28 +0800160 memcmp(result, template[i].digest,
Herbert Xue9d41162006-08-19 21:38:49 +1000161 crypto_hash_digestsize(tfm)) ?
Herbert Xuef2736f2005-06-22 13:26:03 -0700162 "fail" : "pass");
Sebastian Siewior562954d2008-03-13 20:20:28 +0800163 kfree(hash_buff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 }
165
Herbert Xuef2736f2005-06-22 13:26:03 -0700166 printk("testing %s across pages\n", algo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167
168 /* setup the dummy buffer first */
Herbert Xuef2736f2005-06-22 13:26:03 -0700169 memset(xbuf, 0, XBUFSIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
171 j = 0;
172 for (i = 0; i < tcount; i++) {
Sebastian Siewior562954d2008-03-13 20:20:28 +0800173 if (template[i].np) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 j++;
Herbert Xuef2736f2005-06-22 13:26:03 -0700175 printk("test %u:\n", j);
176 memset(result, 0, 64);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177
178 temp = 0;
Sebastian Siewior562954d2008-03-13 20:20:28 +0800179 sg_init_table(sg, template[i].np);
180 for (k = 0; k < template[i].np; k++) {
Herbert Xuef2736f2005-06-22 13:26:03 -0700181 memcpy(&xbuf[IDX[k]],
Sebastian Siewior562954d2008-03-13 20:20:28 +0800182 template[i].plaintext + temp,
183 template[i].tap[k]);
184 temp += template[i].tap[k];
David Hardeman378f0582005-09-17 17:55:31 +1000185 sg_set_buf(&sg[k], &xbuf[IDX[k]],
Sebastian Siewior562954d2008-03-13 20:20:28 +0800186 template[i].tap[k]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 }
188
Sebastian Siewior562954d2008-03-13 20:20:28 +0800189 if (template[i].ksize) {
190 ret = crypto_hash_setkey(tfm, template[i].key,
191 template[i].ksize);
Herbert Xuef2736f2005-06-22 13:26:03 -0700192
Herbert Xue9d41162006-08-19 21:38:49 +1000193 if (ret) {
194 printk("setkey() failed ret=%d\n", ret);
195 goto out;
196 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 }
198
Sebastian Siewior562954d2008-03-13 20:20:28 +0800199 ret = crypto_hash_digest(&desc, sg, template[i].psize,
Herbert Xue9d41162006-08-19 21:38:49 +1000200 result);
201 if (ret) {
202 printk("digest () failed ret=%d\n", ret);
203 goto out;
204 }
Herbert Xuef2736f2005-06-22 13:26:03 -0700205
Herbert Xue9d41162006-08-19 21:38:49 +1000206 hexdump(result, crypto_hash_digestsize(tfm));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 printk("%s\n",
Sebastian Siewior562954d2008-03-13 20:20:28 +0800208 memcmp(result, template[i].digest,
Herbert Xue9d41162006-08-19 21:38:49 +1000209 crypto_hash_digestsize(tfm)) ?
Herbert Xuef2736f2005-06-22 13:26:03 -0700210 "fail" : "pass");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 }
212 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
Herbert Xue9d41162006-08-19 21:38:49 +1000214out:
215 crypto_free_hash(tfm);
216}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800218static void test_aead(char *algo, int enc, struct aead_testvec *template,
219 unsigned int tcount)
220{
221 unsigned int ret, i, j, k, temp;
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800222 char *q;
223 struct crypto_aead *tfm;
224 char *key;
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800225 struct aead_request *req;
226 struct scatterlist sg[8];
227 struct scatterlist asg[8];
228 const char *e;
229 struct tcrypt_result result;
Herbert Xu6160b282007-12-04 19:17:50 +1100230 unsigned int authsize;
Sebastian Siewior562954d2008-03-13 20:20:28 +0800231 void *input;
232 void *assoc;
233 char iv[MAX_IVLEN];
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800234
235 if (enc == ENCRYPT)
236 e = "encryption";
237 else
238 e = "decryption";
239
240 printk(KERN_INFO "\ntesting %s %s\n", algo, e);
241
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800242 init_completion(&result.completion);
243
244 tfm = crypto_alloc_aead(algo, 0, 0);
245
246 if (IS_ERR(tfm)) {
247 printk(KERN_INFO "failed to load transform for %s: %ld\n",
248 algo, PTR_ERR(tfm));
249 return;
250 }
251
252 req = aead_request_alloc(tfm, GFP_KERNEL);
253 if (!req) {
254 printk(KERN_INFO "failed to allocate request for %s\n", algo);
255 goto out;
256 }
257
258 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
259 tcrypt_complete, &result);
260
261 for (i = 0, j = 0; i < tcount; i++) {
Sebastian Siewior562954d2008-03-13 20:20:28 +0800262 if (!template[i].np) {
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800263 printk(KERN_INFO "test %u (%d bit key):\n",
Sebastian Siewior562954d2008-03-13 20:20:28 +0800264 ++j, template[i].klen * 8);
265
266 /* some tepmplates have no input data but they will
267 * touch input
268 */
269 input = kzalloc(template[i].ilen + template[i].rlen, GFP_KERNEL);
270 if (!input)
271 continue;
272
273 assoc = kzalloc(template[i].alen, GFP_KERNEL);
274 if (!assoc) {
275 kfree(input);
276 continue;
277 }
278
279 memcpy(input, template[i].input, template[i].ilen);
280 memcpy(assoc, template[i].assoc, template[i].alen);
281 if (template[i].iv)
282 memcpy(iv, template[i].iv, MAX_IVLEN);
283 else
284 memset(iv, 0, MAX_IVLEN);
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800285
286 crypto_aead_clear_flags(tfm, ~0);
Sebastian Siewior562954d2008-03-13 20:20:28 +0800287 if (template[i].wk)
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800288 crypto_aead_set_flags(
289 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
Sebastian Siewior562954d2008-03-13 20:20:28 +0800290
291 if (template[i].key)
292 key = template[i].key;
293 else
294 key = kzalloc(template[i].klen, GFP_KERNEL);
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800295
296 ret = crypto_aead_setkey(tfm, key,
Sebastian Siewior562954d2008-03-13 20:20:28 +0800297 template[i].klen);
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800298 if (ret) {
299 printk(KERN_INFO "setkey() failed flags=%x\n",
300 crypto_aead_get_flags(tfm));
301
Sebastian Siewior562954d2008-03-13 20:20:28 +0800302 if (!template[i].fail)
303 goto next_one;
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800304 }
305
Sebastian Siewior562954d2008-03-13 20:20:28 +0800306 authsize = abs(template[i].rlen - template[i].ilen);
Joy Latten93cc74e2007-12-12 20:24:22 +0800307 ret = crypto_aead_setauthsize(tfm, authsize);
308 if (ret) {
309 printk(KERN_INFO
310 "failed to set authsize = %u\n",
311 authsize);
Sebastian Siewior562954d2008-03-13 20:20:28 +0800312 goto next_one;
Joy Latten93cc74e2007-12-12 20:24:22 +0800313 }
314
Sebastian Siewior562954d2008-03-13 20:20:28 +0800315 sg_init_one(&sg[0], input,
316 template[i].ilen + (enc ? authsize : 0));
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800317
Sebastian Siewior562954d2008-03-13 20:20:28 +0800318 sg_init_one(&asg[0], assoc, template[i].alen);
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800319
320 aead_request_set_crypt(req, sg, sg,
Sebastian Siewior562954d2008-03-13 20:20:28 +0800321 template[i].ilen, iv);
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800322
Sebastian Siewior562954d2008-03-13 20:20:28 +0800323 aead_request_set_assoc(req, asg, template[i].alen);
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800324
Herbert Xu6160b282007-12-04 19:17:50 +1100325 ret = enc ?
326 crypto_aead_encrypt(req) :
327 crypto_aead_decrypt(req);
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800328
329 switch (ret) {
330 case 0:
331 break;
332 case -EINPROGRESS:
333 case -EBUSY:
334 ret = wait_for_completion_interruptible(
335 &result.completion);
336 if (!ret && !(ret = result.err)) {
337 INIT_COMPLETION(result.completion);
338 break;
339 }
340 /* fall through */
341 default:
342 printk(KERN_INFO "%s () failed err=%d\n",
343 e, -ret);
Sebastian Siewior562954d2008-03-13 20:20:28 +0800344 goto next_one;
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800345 }
346
347 q = kmap(sg_page(&sg[0])) + sg[0].offset;
Sebastian Siewior562954d2008-03-13 20:20:28 +0800348 hexdump(q, template[i].rlen);
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800349
350 printk(KERN_INFO "enc/dec: %s\n",
Sebastian Siewior562954d2008-03-13 20:20:28 +0800351 memcmp(q, template[i].result,
352 template[i].rlen) ? "fail" : "pass");
353 kunmap(sg_page(&sg[0]));
354next_one:
355 if (!template[i].key)
356 kfree(key);
357 kfree(assoc);
358 kfree(input);
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800359 }
360 }
361
362 printk(KERN_INFO "\ntesting %s %s across pages (chunking)\n", algo, e);
363 memset(xbuf, 0, XBUFSIZE);
Herbert Xu2a999a32007-12-30 20:24:11 +1100364 memset(axbuf, 0, XBUFSIZE);
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800365
366 for (i = 0, j = 0; i < tcount; i++) {
Sebastian Siewior562954d2008-03-13 20:20:28 +0800367 if (template[i].np) {
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800368 printk(KERN_INFO "test %u (%d bit key):\n",
Sebastian Siewior562954d2008-03-13 20:20:28 +0800369 ++j, template[i].klen * 8);
370
371 if (template[i].iv)
372 memcpy(iv, template[i].iv, MAX_IVLEN);
373 else
374 memset(iv, 0, MAX_IVLEN);
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800375
376 crypto_aead_clear_flags(tfm, ~0);
Sebastian Siewior562954d2008-03-13 20:20:28 +0800377 if (template[i].wk)
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800378 crypto_aead_set_flags(
379 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
Sebastian Siewior562954d2008-03-13 20:20:28 +0800380 key = template[i].key;
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800381
Sebastian Siewior562954d2008-03-13 20:20:28 +0800382 ret = crypto_aead_setkey(tfm, key, template[i].klen);
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800383 if (ret) {
384 printk(KERN_INFO "setkey() failed flags=%x\n",
385 crypto_aead_get_flags(tfm));
386
Sebastian Siewior562954d2008-03-13 20:20:28 +0800387 if (!template[i].fail)
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800388 goto out;
389 }
390
Sebastian Siewior562954d2008-03-13 20:20:28 +0800391 sg_init_table(sg, template[i].np);
392 for (k = 0, temp = 0; k < template[i].np; k++) {
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800393 memcpy(&xbuf[IDX[k]],
Sebastian Siewior562954d2008-03-13 20:20:28 +0800394 template[i].input + temp,
395 template[i].tap[k]);
396 temp += template[i].tap[k];
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800397 sg_set_buf(&sg[k], &xbuf[IDX[k]],
Sebastian Siewior562954d2008-03-13 20:20:28 +0800398 template[i].tap[k]);
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800399 }
400
Sebastian Siewior562954d2008-03-13 20:20:28 +0800401 authsize = abs(template[i].rlen - template[i].ilen);
Joy Latten93cc74e2007-12-12 20:24:22 +0800402 ret = crypto_aead_setauthsize(tfm, authsize);
403 if (ret) {
404 printk(KERN_INFO
405 "failed to set authsize = %u\n",
406 authsize);
407 goto out;
408 }
409
Herbert Xu6160b282007-12-04 19:17:50 +1100410 if (enc)
411 sg[k - 1].length += authsize;
412
Sebastian Siewior562954d2008-03-13 20:20:28 +0800413 sg_init_table(asg, template[i].anp);
414 for (k = 0, temp = 0; k < template[i].anp; k++) {
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800415 memcpy(&axbuf[IDX[k]],
Sebastian Siewior562954d2008-03-13 20:20:28 +0800416 template[i].assoc + temp,
417 template[i].atap[k]);
418 temp += template[i].atap[k];
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800419 sg_set_buf(&asg[k], &axbuf[IDX[k]],
Sebastian Siewior562954d2008-03-13 20:20:28 +0800420 template[i].atap[k]);
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800421 }
422
423 aead_request_set_crypt(req, sg, sg,
Sebastian Siewior562954d2008-03-13 20:20:28 +0800424 template[i].ilen,
425 iv);
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800426
Sebastian Siewior562954d2008-03-13 20:20:28 +0800427 aead_request_set_assoc(req, asg, template[i].alen);
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800428
Herbert Xu6160b282007-12-04 19:17:50 +1100429 ret = enc ?
430 crypto_aead_encrypt(req) :
431 crypto_aead_decrypt(req);
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800432
433 switch (ret) {
434 case 0:
435 break;
436 case -EINPROGRESS:
437 case -EBUSY:
438 ret = wait_for_completion_interruptible(
439 &result.completion);
440 if (!ret && !(ret = result.err)) {
441 INIT_COMPLETION(result.completion);
442 break;
443 }
444 /* fall through */
445 default:
446 printk(KERN_INFO "%s () failed err=%d\n",
447 e, -ret);
448 goto out;
449 }
450
Sebastian Siewior562954d2008-03-13 20:20:28 +0800451 for (k = 0, temp = 0; k < template[i].np; k++) {
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800452 printk(KERN_INFO "page %u\n", k);
453 q = kmap(sg_page(&sg[k])) + sg[k].offset;
Sebastian Siewior562954d2008-03-13 20:20:28 +0800454 hexdump(q, template[i].tap[k]);
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800455 printk(KERN_INFO "%s\n",
Sebastian Siewior562954d2008-03-13 20:20:28 +0800456 memcmp(q, template[i].result + temp,
457 template[i].tap[k] -
458 (k < template[i].np - 1 || enc ?
Herbert Xu6160b282007-12-04 19:17:50 +1100459 0 : authsize)) ?
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800460 "fail" : "pass");
461
Sebastian Siewior562954d2008-03-13 20:20:28 +0800462 temp += template[i].tap[k];
463 kunmap(sg_page(&sg[k]));
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800464 }
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800465 }
466 }
467
468out:
469 crypto_free_aead(tfm);
470 aead_request_free(req);
471}
472
Herbert Xucba83562006-08-13 08:26:09 +1000473static void test_cipher(char *algo, int enc,
Herbert Xuef2736f2005-06-22 13:26:03 -0700474 struct cipher_testvec *template, unsigned int tcount)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475{
476 unsigned int ret, i, j, k, temp;
David Hardeman378f0582005-09-17 17:55:31 +1000477 char *q;
Herbert Xu6158efc2007-04-04 17:41:07 +1000478 struct crypto_ablkcipher *tfm;
Herbert Xu6158efc2007-04-04 17:41:07 +1000479 struct ablkcipher_request *req;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 struct scatterlist sg[8];
Herbert Xucba83562006-08-13 08:26:09 +1000481 const char *e;
Herbert Xu6158efc2007-04-04 17:41:07 +1000482 struct tcrypt_result result;
Sebastian Siewior562954d2008-03-13 20:20:28 +0800483 void *data;
484 char iv[MAX_IVLEN];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
486 if (enc == ENCRYPT)
Herbert Xu3cc38162005-06-22 13:26:36 -0700487 e = "encryption";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 else
Herbert Xu3cc38162005-06-22 13:26:36 -0700489 e = "decryption";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490
Herbert Xucba83562006-08-13 08:26:09 +1000491 printk("\ntesting %s %s\n", algo, e);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492
Herbert Xu6158efc2007-04-04 17:41:07 +1000493 init_completion(&result.completion);
Herbert Xu6158efc2007-04-04 17:41:07 +1000494 tfm = crypto_alloc_ablkcipher(algo, 0, 0);
Herbert Xuef2736f2005-06-22 13:26:03 -0700495
Herbert Xucba83562006-08-13 08:26:09 +1000496 if (IS_ERR(tfm)) {
497 printk("failed to load transform for %s: %ld\n", algo,
498 PTR_ERR(tfm));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 return;
500 }
Herbert Xu6158efc2007-04-04 17:41:07 +1000501
502 req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
503 if (!req) {
504 printk("failed to allocate request for %s\n", algo);
505 goto out;
506 }
507
508 ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
509 tcrypt_complete, &result);
Herbert Xuef2736f2005-06-22 13:26:03 -0700510
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 j = 0;
512 for (i = 0; i < tcount; i++) {
Sebastian Siewior562954d2008-03-13 20:20:28 +0800513
514 data = kzalloc(template[i].ilen, GFP_KERNEL);
515 if (!data)
516 continue;
517
518 memcpy(data, template[i].input, template[i].ilen);
519 if (template[i].iv)
520 memcpy(iv, template[i].iv, MAX_IVLEN);
521 else
522 memset(iv, 0, MAX_IVLEN);
523
524 if (!(template[i].np)) {
Herbert Xuef2736f2005-06-22 13:26:03 -0700525 j++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 printk("test %u (%d bit key):\n",
Sebastian Siewior562954d2008-03-13 20:20:28 +0800527 j, template[i].klen * 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
Herbert Xu6158efc2007-04-04 17:41:07 +1000529 crypto_ablkcipher_clear_flags(tfm, ~0);
Sebastian Siewior562954d2008-03-13 20:20:28 +0800530 if (template[i].wk)
Herbert Xu6158efc2007-04-04 17:41:07 +1000531 crypto_ablkcipher_set_flags(
Herbert Xucba83562006-08-13 08:26:09 +1000532 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
Herbert Xuef2736f2005-06-22 13:26:03 -0700533
Sebastian Siewior562954d2008-03-13 20:20:28 +0800534 ret = crypto_ablkcipher_setkey(tfm, template[i].key,
535 template[i].klen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 if (ret) {
Herbert Xucba83562006-08-13 08:26:09 +1000537 printk("setkey() failed flags=%x\n",
Herbert Xu6158efc2007-04-04 17:41:07 +1000538 crypto_ablkcipher_get_flags(tfm));
Herbert Xuef2736f2005-06-22 13:26:03 -0700539
Sebastian Siewior562954d2008-03-13 20:20:28 +0800540 if (!template[i].fail) {
541 kfree(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 goto out;
Sebastian Siewior562954d2008-03-13 20:20:28 +0800543 }
Herbert Xuef2736f2005-06-22 13:26:03 -0700544 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545
Sebastian Siewior562954d2008-03-13 20:20:28 +0800546 sg_init_one(&sg[0], data, template[i].ilen);
Herbert Xuef2736f2005-06-22 13:26:03 -0700547
Herbert Xu6158efc2007-04-04 17:41:07 +1000548 ablkcipher_request_set_crypt(req, sg, sg,
Sebastian Siewior562954d2008-03-13 20:20:28 +0800549 template[i].ilen, iv);
Herbert Xucba83562006-08-13 08:26:09 +1000550 ret = enc ?
Herbert Xu6158efc2007-04-04 17:41:07 +1000551 crypto_ablkcipher_encrypt(req) :
552 crypto_ablkcipher_decrypt(req);
Herbert Xuef2736f2005-06-22 13:26:03 -0700553
Herbert Xu6158efc2007-04-04 17:41:07 +1000554 switch (ret) {
555 case 0:
556 break;
557 case -EINPROGRESS:
558 case -EBUSY:
559 ret = wait_for_completion_interruptible(
560 &result.completion);
561 if (!ret && !((ret = result.err))) {
562 INIT_COMPLETION(result.completion);
563 break;
564 }
565 /* fall through */
566 default:
567 printk("%s () failed err=%d\n", e, -ret);
Sebastian Siewior562954d2008-03-13 20:20:28 +0800568 kfree(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 goto out;
Herbert Xuef2736f2005-06-22 13:26:03 -0700570 }
571
Jens Axboe78c2f0b2007-10-22 19:40:16 +0200572 q = kmap(sg_page(&sg[0])) + sg[0].offset;
Sebastian Siewior562954d2008-03-13 20:20:28 +0800573 hexdump(q, template[i].rlen);
Herbert Xuef2736f2005-06-22 13:26:03 -0700574
575 printk("%s\n",
Sebastian Siewior562954d2008-03-13 20:20:28 +0800576 memcmp(q, template[i].result,
577 template[i].rlen) ? "fail" : "pass");
578 kunmap(sg_page(&sg[0]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 }
Sebastian Siewior562954d2008-03-13 20:20:28 +0800580 kfree(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 }
Herbert Xuef2736f2005-06-22 13:26:03 -0700582
Herbert Xucba83562006-08-13 08:26:09 +1000583 printk("\ntesting %s %s across pages (chunking)\n", algo, e);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 memset(xbuf, 0, XBUFSIZE);
Herbert Xuef2736f2005-06-22 13:26:03 -0700585
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 j = 0;
587 for (i = 0; i < tcount; i++) {
Sebastian Siewior562954d2008-03-13 20:20:28 +0800588
589 data = kzalloc(template[i].ilen, GFP_KERNEL);
590 if (!data)
591 continue;
592
593 memcpy(data, template[i].input, template[i].ilen);
594
595 if (template[i].iv)
596 memcpy(iv, template[i].iv, MAX_IVLEN);
597 else
598 memset(iv, 0, MAX_IVLEN);
599
600 if (template[i].np) {
Herbert Xuef2736f2005-06-22 13:26:03 -0700601 j++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 printk("test %u (%d bit key):\n",
Sebastian Siewior562954d2008-03-13 20:20:28 +0800603 j, template[i].klen * 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604
Herbert Xu6158efc2007-04-04 17:41:07 +1000605 crypto_ablkcipher_clear_flags(tfm, ~0);
Sebastian Siewior562954d2008-03-13 20:20:28 +0800606 if (template[i].wk)
Herbert Xu6158efc2007-04-04 17:41:07 +1000607 crypto_ablkcipher_set_flags(
Herbert Xucba83562006-08-13 08:26:09 +1000608 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
Herbert Xuef2736f2005-06-22 13:26:03 -0700609
Sebastian Siewior562954d2008-03-13 20:20:28 +0800610 ret = crypto_ablkcipher_setkey(tfm, template[i].key,
611 template[i].klen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 if (ret) {
Herbert Xucba83562006-08-13 08:26:09 +1000613 printk("setkey() failed flags=%x\n",
Sebastian Siewior562954d2008-03-13 20:20:28 +0800614 crypto_ablkcipher_get_flags(tfm));
Herbert Xuef2736f2005-06-22 13:26:03 -0700615
Sebastian Siewior562954d2008-03-13 20:20:28 +0800616 if (!template[i].fail) {
617 kfree(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 goto out;
Sebastian Siewior562954d2008-03-13 20:20:28 +0800619 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 }
621
622 temp = 0;
Sebastian Siewior562954d2008-03-13 20:20:28 +0800623 sg_init_table(sg, template[i].np);
624 for (k = 0; k < template[i].np; k++) {
Herbert Xuef2736f2005-06-22 13:26:03 -0700625 memcpy(&xbuf[IDX[k]],
Sebastian Siewior562954d2008-03-13 20:20:28 +0800626 template[i].input + temp,
627 template[i].tap[k]);
628 temp += template[i].tap[k];
David Hardeman378f0582005-09-17 17:55:31 +1000629 sg_set_buf(&sg[k], &xbuf[IDX[k]],
Sebastian Siewior562954d2008-03-13 20:20:28 +0800630 template[i].tap[k]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 }
Herbert Xuef2736f2005-06-22 13:26:03 -0700632
Herbert Xu6158efc2007-04-04 17:41:07 +1000633 ablkcipher_request_set_crypt(req, sg, sg,
Sebastian Siewior562954d2008-03-13 20:20:28 +0800634 template[i].ilen, iv);
Herbert Xuef2736f2005-06-22 13:26:03 -0700635
Herbert Xucba83562006-08-13 08:26:09 +1000636 ret = enc ?
Herbert Xu6158efc2007-04-04 17:41:07 +1000637 crypto_ablkcipher_encrypt(req) :
638 crypto_ablkcipher_decrypt(req);
Herbert Xuef2736f2005-06-22 13:26:03 -0700639
Herbert Xu6158efc2007-04-04 17:41:07 +1000640 switch (ret) {
641 case 0:
642 break;
643 case -EINPROGRESS:
644 case -EBUSY:
645 ret = wait_for_completion_interruptible(
646 &result.completion);
647 if (!ret && !((ret = result.err))) {
648 INIT_COMPLETION(result.completion);
649 break;
650 }
651 /* fall through */
652 default:
653 printk("%s () failed err=%d\n", e, -ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 goto out;
655 }
656
657 temp = 0;
Sebastian Siewior562954d2008-03-13 20:20:28 +0800658 for (k = 0; k < template[i].np; k++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 printk("page %u\n", k);
Jens Axboe78c2f0b2007-10-22 19:40:16 +0200660 q = kmap(sg_page(&sg[k])) + sg[k].offset;
Sebastian Siewior562954d2008-03-13 20:20:28 +0800661 hexdump(q, template[i].tap[k]);
Herbert Xuef2736f2005-06-22 13:26:03 -0700662 printk("%s\n",
Sebastian Siewior562954d2008-03-13 20:20:28 +0800663 memcmp(q, template[i].result + temp,
664 template[i].tap[k]) ? "fail" :
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 "pass");
Sebastian Siewior562954d2008-03-13 20:20:28 +0800666 temp += template[i].tap[k];
667 kunmap(sg_page(&sg[k]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 }
669 }
670 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671out:
Herbert Xu6158efc2007-04-04 17:41:07 +1000672 crypto_free_ablkcipher(tfm);
673 ablkcipher_request_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674}
675
Herbert Xucba83562006-08-13 08:26:09 +1000676static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc, char *p,
Herbert Xu6a179442005-06-22 13:29:03 -0700677 int blen, int sec)
678{
Herbert Xu6df5b9f2005-09-19 22:30:11 +1000679 struct scatterlist sg[1];
Herbert Xu6a179442005-06-22 13:29:03 -0700680 unsigned long start, end;
681 int bcount;
682 int ret;
683
David S. Millerb7335882007-10-26 00:38:10 -0700684 sg_init_one(sg, p, blen);
Herbert Xu6a179442005-06-22 13:29:03 -0700685
686 for (start = jiffies, end = start + sec * HZ, bcount = 0;
687 time_before(jiffies, end); bcount++) {
688 if (enc)
Herbert Xucba83562006-08-13 08:26:09 +1000689 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
Herbert Xu6a179442005-06-22 13:29:03 -0700690 else
Herbert Xucba83562006-08-13 08:26:09 +1000691 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
Herbert Xu6a179442005-06-22 13:29:03 -0700692
693 if (ret)
694 return ret;
695 }
696
697 printk("%d operations in %d seconds (%ld bytes)\n",
698 bcount, sec, (long)bcount * blen);
699 return 0;
700}
701
Herbert Xucba83562006-08-13 08:26:09 +1000702static int test_cipher_cycles(struct blkcipher_desc *desc, int enc, char *p,
Herbert Xu6a179442005-06-22 13:29:03 -0700703 int blen)
704{
Herbert Xu6df5b9f2005-09-19 22:30:11 +1000705 struct scatterlist sg[1];
Herbert Xu6a179442005-06-22 13:29:03 -0700706 unsigned long cycles = 0;
707 int ret = 0;
708 int i;
709
David S. Millerb7335882007-10-26 00:38:10 -0700710 sg_init_one(sg, p, blen);
Herbert Xu6a179442005-06-22 13:29:03 -0700711
712 local_bh_disable();
713 local_irq_disable();
714
715 /* Warm-up run. */
716 for (i = 0; i < 4; i++) {
717 if (enc)
Herbert Xucba83562006-08-13 08:26:09 +1000718 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
Herbert Xu6a179442005-06-22 13:29:03 -0700719 else
Herbert Xucba83562006-08-13 08:26:09 +1000720 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
Herbert Xu6a179442005-06-22 13:29:03 -0700721
722 if (ret)
723 goto out;
724 }
725
726 /* The real thing. */
727 for (i = 0; i < 8; i++) {
728 cycles_t start, end;
729
730 start = get_cycles();
731 if (enc)
Herbert Xucba83562006-08-13 08:26:09 +1000732 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
Herbert Xu6a179442005-06-22 13:29:03 -0700733 else
Herbert Xucba83562006-08-13 08:26:09 +1000734 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
Herbert Xu6a179442005-06-22 13:29:03 -0700735 end = get_cycles();
736
737 if (ret)
738 goto out;
739
740 cycles += end - start;
741 }
742
743out:
744 local_irq_enable();
745 local_bh_enable();
746
747 if (ret == 0)
748 printk("1 operation in %lu cycles (%d bytes)\n",
749 (cycles + 4) / 8, blen);
750
751 return ret;
752}
753
Sebastian Siewiord5dc3922008-03-11 21:27:11 +0800754static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
755
Herbert Xucba83562006-08-13 08:26:09 +1000756static void test_cipher_speed(char *algo, int enc, unsigned int sec,
Herbert Xudce907c2005-06-22 13:27:51 -0700757 struct cipher_testvec *template,
Sebastian Siewiord5dc3922008-03-11 21:27:11 +0800758 unsigned int tcount, u8 *keysize)
Harald Welteebfd9bc2005-06-22 13:27:23 -0700759{
Herbert Xudce907c2005-06-22 13:27:51 -0700760 unsigned int ret, i, j, iv_len;
Harald Welteebfd9bc2005-06-22 13:27:23 -0700761 unsigned char *key, *p, iv[128];
Herbert Xucba83562006-08-13 08:26:09 +1000762 struct crypto_blkcipher *tfm;
763 struct blkcipher_desc desc;
764 const char *e;
Sebastian Siewiord5dc3922008-03-11 21:27:11 +0800765 u32 *b_size;
Harald Welteebfd9bc2005-06-22 13:27:23 -0700766
767 if (enc == ENCRYPT)
768 e = "encryption";
769 else
770 e = "decryption";
Harald Welteebfd9bc2005-06-22 13:27:23 -0700771
Herbert Xucba83562006-08-13 08:26:09 +1000772 printk("\ntesting speed of %s %s\n", algo, e);
Harald Welteebfd9bc2005-06-22 13:27:23 -0700773
Herbert Xucba83562006-08-13 08:26:09 +1000774 tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
Harald Welteebfd9bc2005-06-22 13:27:23 -0700775
Herbert Xucba83562006-08-13 08:26:09 +1000776 if (IS_ERR(tfm)) {
777 printk("failed to load transform for %s: %ld\n", algo,
778 PTR_ERR(tfm));
Harald Welteebfd9bc2005-06-22 13:27:23 -0700779 return;
780 }
Herbert Xucba83562006-08-13 08:26:09 +1000781 desc.tfm = tfm;
782 desc.flags = 0;
Harald Welteebfd9bc2005-06-22 13:27:23 -0700783
Sebastian Siewiord5dc3922008-03-11 21:27:11 +0800784 i = 0;
785 do {
Harald Welteebfd9bc2005-06-22 13:27:23 -0700786
Sebastian Siewiord5dc3922008-03-11 21:27:11 +0800787 b_size = block_sizes;
788 do {
Harald Welteebfd9bc2005-06-22 13:27:23 -0700789
Sebastian Siewiord5dc3922008-03-11 21:27:11 +0800790 if ((*keysize + *b_size) > TVMEMSIZE) {
791 printk("template (%u) too big for tvmem (%u)\n",
792 *keysize + *b_size, TVMEMSIZE);
793 goto out;
794 }
Harald Welteebfd9bc2005-06-22 13:27:23 -0700795
Sebastian Siewiord5dc3922008-03-11 21:27:11 +0800796 printk("test %u (%d bit key, %d byte blocks): ", i,
797 *keysize * 8, *b_size);
798
799 memset(tvmem, 0xff, *keysize + *b_size);
800
801 /* set key, plain text and IV */
802 key = (unsigned char *)tvmem;
803 for (j = 0; j < tcount; j++) {
804 if (template[j].klen == *keysize) {
805 key = template[j].key;
806 break;
807 }
808 }
809 p = (unsigned char *)tvmem + *keysize;
810
811 ret = crypto_blkcipher_setkey(tfm, key, *keysize);
812 if (ret) {
813 printk("setkey() failed flags=%x\n",
814 crypto_blkcipher_get_flags(tfm));
815 goto out;
816 }
817
818 iv_len = crypto_blkcipher_ivsize(tfm);
819 if (iv_len) {
820 memset(&iv, 0xff, iv_len);
821 crypto_blkcipher_set_iv(tfm, iv, iv_len);
822 }
823
824 if (sec)
825 ret = test_cipher_jiffies(&desc, enc, p, *b_size, sec);
826 else
827 ret = test_cipher_cycles(&desc, enc, p, *b_size);
828
829 if (ret) {
830 printk("%s() failed flags=%x\n", e, desc.flags);
Herbert Xudce907c2005-06-22 13:27:51 -0700831 break;
832 }
Sebastian Siewiord5dc3922008-03-11 21:27:11 +0800833 b_size++;
834 i++;
835 } while (*b_size);
836 keysize++;
837 } while (*keysize);
Harald Welteebfd9bc2005-06-22 13:27:23 -0700838
839out:
Herbert Xucba83562006-08-13 08:26:09 +1000840 crypto_free_blkcipher(tfm);
Harald Welteebfd9bc2005-06-22 13:27:23 -0700841}
842
Herbert Xue9d41162006-08-19 21:38:49 +1000843static int test_hash_jiffies_digest(struct hash_desc *desc, char *p, int blen,
844 char *out, int sec)
Michal Ludvige8057922006-05-30 22:04:19 +1000845{
846 struct scatterlist sg[1];
847 unsigned long start, end;
Herbert Xue9d41162006-08-19 21:38:49 +1000848 int bcount;
849 int ret;
Michal Ludvige8057922006-05-30 22:04:19 +1000850
Herbert Xua5a613a2007-10-27 00:51:21 -0700851 sg_init_table(sg, 1);
852
Michal Ludvige8057922006-05-30 22:04:19 +1000853 for (start = jiffies, end = start + sec * HZ, bcount = 0;
854 time_before(jiffies, end); bcount++) {
Herbert Xua5a613a2007-10-27 00:51:21 -0700855 sg_set_buf(sg, p, blen);
Herbert Xue9d41162006-08-19 21:38:49 +1000856 ret = crypto_hash_digest(desc, sg, blen, out);
857 if (ret)
858 return ret;
Michal Ludvige8057922006-05-30 22:04:19 +1000859 }
860
861 printk("%6u opers/sec, %9lu bytes/sec\n",
862 bcount / sec, ((long)bcount * blen) / sec);
863
Herbert Xue9d41162006-08-19 21:38:49 +1000864 return 0;
Michal Ludvige8057922006-05-30 22:04:19 +1000865}
866
Herbert Xue9d41162006-08-19 21:38:49 +1000867static int test_hash_jiffies(struct hash_desc *desc, char *p, int blen,
868 int plen, char *out, int sec)
869{
870 struct scatterlist sg[1];
871 unsigned long start, end;
872 int bcount, pcount;
873 int ret;
874
875 if (plen == blen)
876 return test_hash_jiffies_digest(desc, p, blen, out, sec);
877
Herbert Xua5a613a2007-10-27 00:51:21 -0700878 sg_init_table(sg, 1);
879
Herbert Xue9d41162006-08-19 21:38:49 +1000880 for (start = jiffies, end = start + sec * HZ, bcount = 0;
881 time_before(jiffies, end); bcount++) {
882 ret = crypto_hash_init(desc);
883 if (ret)
884 return ret;
885 for (pcount = 0; pcount < blen; pcount += plen) {
Herbert Xua5a613a2007-10-27 00:51:21 -0700886 sg_set_buf(sg, p + pcount, plen);
Herbert Xue9d41162006-08-19 21:38:49 +1000887 ret = crypto_hash_update(desc, sg, plen);
888 if (ret)
889 return ret;
890 }
891 /* we assume there is enough space in 'out' for the result */
892 ret = crypto_hash_final(desc, out);
893 if (ret)
894 return ret;
895 }
896
897 printk("%6u opers/sec, %9lu bytes/sec\n",
898 bcount / sec, ((long)bcount * blen) / sec);
899
900 return 0;
901}
902
903static int test_hash_cycles_digest(struct hash_desc *desc, char *p, int blen,
904 char *out)
Michal Ludvige8057922006-05-30 22:04:19 +1000905{
906 struct scatterlist sg[1];
907 unsigned long cycles = 0;
Herbert Xue9d41162006-08-19 21:38:49 +1000908 int i;
909 int ret;
Michal Ludvige8057922006-05-30 22:04:19 +1000910
Herbert Xua5a613a2007-10-27 00:51:21 -0700911 sg_init_table(sg, 1);
912
Michal Ludvige8057922006-05-30 22:04:19 +1000913 local_bh_disable();
914 local_irq_disable();
915
916 /* Warm-up run. */
917 for (i = 0; i < 4; i++) {
Herbert Xua5a613a2007-10-27 00:51:21 -0700918 sg_set_buf(sg, p, blen);
Herbert Xue9d41162006-08-19 21:38:49 +1000919 ret = crypto_hash_digest(desc, sg, blen, out);
920 if (ret)
921 goto out;
Michal Ludvige8057922006-05-30 22:04:19 +1000922 }
923
924 /* The real thing. */
925 for (i = 0; i < 8; i++) {
926 cycles_t start, end;
927
Michal Ludvige8057922006-05-30 22:04:19 +1000928 start = get_cycles();
929
Herbert Xua5a613a2007-10-27 00:51:21 -0700930 sg_set_buf(sg, p, blen);
Herbert Xue9d41162006-08-19 21:38:49 +1000931 ret = crypto_hash_digest(desc, sg, blen, out);
932 if (ret)
933 goto out;
Michal Ludvige8057922006-05-30 22:04:19 +1000934
935 end = get_cycles();
936
937 cycles += end - start;
938 }
939
Herbert Xue9d41162006-08-19 21:38:49 +1000940out:
Michal Ludvige8057922006-05-30 22:04:19 +1000941 local_irq_enable();
942 local_bh_enable();
943
Herbert Xue9d41162006-08-19 21:38:49 +1000944 if (ret)
945 return ret;
946
Michal Ludvige8057922006-05-30 22:04:19 +1000947 printk("%6lu cycles/operation, %4lu cycles/byte\n",
948 cycles / 8, cycles / (8 * blen));
949
Herbert Xue9d41162006-08-19 21:38:49 +1000950 return 0;
Michal Ludvige8057922006-05-30 22:04:19 +1000951}
952
Herbert Xue9d41162006-08-19 21:38:49 +1000953static int test_hash_cycles(struct hash_desc *desc, char *p, int blen,
954 int plen, char *out)
Michal Ludvige8057922006-05-30 22:04:19 +1000955{
Herbert Xue9d41162006-08-19 21:38:49 +1000956 struct scatterlist sg[1];
957 unsigned long cycles = 0;
958 int i, pcount;
959 int ret;
960
961 if (plen == blen)
962 return test_hash_cycles_digest(desc, p, blen, out);
963
Herbert Xua5a613a2007-10-27 00:51:21 -0700964 sg_init_table(sg, 1);
965
Herbert Xue9d41162006-08-19 21:38:49 +1000966 local_bh_disable();
967 local_irq_disable();
968
969 /* Warm-up run. */
970 for (i = 0; i < 4; i++) {
971 ret = crypto_hash_init(desc);
972 if (ret)
973 goto out;
974 for (pcount = 0; pcount < blen; pcount += plen) {
Herbert Xua5a613a2007-10-27 00:51:21 -0700975 sg_set_buf(sg, p + pcount, plen);
Herbert Xue9d41162006-08-19 21:38:49 +1000976 ret = crypto_hash_update(desc, sg, plen);
977 if (ret)
978 goto out;
979 }
Herbert Xu29059d12007-05-18 16:25:19 +1000980 ret = crypto_hash_final(desc, out);
Herbert Xue9d41162006-08-19 21:38:49 +1000981 if (ret)
982 goto out;
983 }
984
985 /* The real thing. */
986 for (i = 0; i < 8; i++) {
987 cycles_t start, end;
988
989 start = get_cycles();
990
991 ret = crypto_hash_init(desc);
992 if (ret)
993 goto out;
994 for (pcount = 0; pcount < blen; pcount += plen) {
Herbert Xua5a613a2007-10-27 00:51:21 -0700995 sg_set_buf(sg, p + pcount, plen);
Herbert Xue9d41162006-08-19 21:38:49 +1000996 ret = crypto_hash_update(desc, sg, plen);
997 if (ret)
998 goto out;
999 }
1000 ret = crypto_hash_final(desc, out);
1001 if (ret)
1002 goto out;
1003
1004 end = get_cycles();
1005
1006 cycles += end - start;
1007 }
1008
1009out:
1010 local_irq_enable();
1011 local_bh_enable();
1012
1013 if (ret)
1014 return ret;
1015
1016 printk("%6lu cycles/operation, %4lu cycles/byte\n",
1017 cycles / 8, cycles / (8 * blen));
1018
1019 return 0;
1020}
1021
1022static void test_hash_speed(char *algo, unsigned int sec,
1023 struct hash_speed *speed)
1024{
1025 struct crypto_hash *tfm;
1026 struct hash_desc desc;
Michal Ludvige8057922006-05-30 22:04:19 +10001027 char output[1024];
1028 int i;
Herbert Xue9d41162006-08-19 21:38:49 +10001029 int ret;
Michal Ludvige8057922006-05-30 22:04:19 +10001030
1031 printk("\ntesting speed of %s\n", algo);
1032
Herbert Xue9d41162006-08-19 21:38:49 +10001033 tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
Michal Ludvige8057922006-05-30 22:04:19 +10001034
Herbert Xue9d41162006-08-19 21:38:49 +10001035 if (IS_ERR(tfm)) {
1036 printk("failed to load transform for %s: %ld\n", algo,
1037 PTR_ERR(tfm));
Michal Ludvige8057922006-05-30 22:04:19 +10001038 return;
1039 }
1040
Herbert Xue9d41162006-08-19 21:38:49 +10001041 desc.tfm = tfm;
1042 desc.flags = 0;
1043
1044 if (crypto_hash_digestsize(tfm) > sizeof(output)) {
Michal Ludvige8057922006-05-30 22:04:19 +10001045 printk("digestsize(%u) > outputbuffer(%zu)\n",
Herbert Xue9d41162006-08-19 21:38:49 +10001046 crypto_hash_digestsize(tfm), sizeof(output));
Michal Ludvige8057922006-05-30 22:04:19 +10001047 goto out;
1048 }
1049
1050 for (i = 0; speed[i].blen != 0; i++) {
1051 if (speed[i].blen > TVMEMSIZE) {
1052 printk("template (%u) too big for tvmem (%u)\n",
1053 speed[i].blen, TVMEMSIZE);
1054 goto out;
1055 }
1056
1057 printk("test%3u (%5u byte blocks,%5u bytes per update,%4u updates): ",
1058 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
1059
1060 memset(tvmem, 0xff, speed[i].blen);
1061
1062 if (sec)
Herbert Xue9d41162006-08-19 21:38:49 +10001063 ret = test_hash_jiffies(&desc, tvmem, speed[i].blen,
1064 speed[i].plen, output, sec);
Michal Ludvige8057922006-05-30 22:04:19 +10001065 else
Herbert Xue9d41162006-08-19 21:38:49 +10001066 ret = test_hash_cycles(&desc, tvmem, speed[i].blen,
1067 speed[i].plen, output);
1068
1069 if (ret) {
1070 printk("hashing failed ret=%d\n", ret);
1071 break;
1072 }
Michal Ludvige8057922006-05-30 22:04:19 +10001073 }
1074
1075out:
Herbert Xue9d41162006-08-19 21:38:49 +10001076 crypto_free_hash(tfm);
Michal Ludvige8057922006-05-30 22:04:19 +10001077}
1078
Zoltan Sogor91755a92007-12-07 16:48:11 +08001079static void test_comp(char *algo, struct comp_testvec *ctemplate,
1080 struct comp_testvec *dtemplate, int ctcount, int dtcount)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081{
1082 unsigned int i;
1083 char result[COMP_BUF_SIZE];
Herbert Xue4d5b792006-08-26 18:12:40 +10001084 struct crypto_comp *tfm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 unsigned int tsize;
1086
Zoltan Sogor91755a92007-12-07 16:48:11 +08001087 printk("\ntesting %s compression\n", algo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088
Zoltan Sogor91755a92007-12-07 16:48:11 +08001089 tfm = crypto_alloc_comp(algo, 0, CRYPTO_ALG_ASYNC);
Sebastian Siewior7bc301e2007-03-21 08:58:43 +11001090 if (IS_ERR(tfm)) {
Zoltan Sogor91755a92007-12-07 16:48:11 +08001091 printk("failed to load transform for %s\n", algo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 return;
1093 }
1094
Zoltan Sogor91755a92007-12-07 16:48:11 +08001095 for (i = 0; i < ctcount; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 int ilen, ret, dlen = COMP_BUF_SIZE;
Herbert Xuef2736f2005-06-22 13:26:03 -07001097
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 printk("test %u:\n", i + 1);
1099 memset(result, 0, sizeof (result));
1100
Sebastian Siewior562954d2008-03-13 20:20:28 +08001101 ilen = ctemplate[i].inlen;
1102 ret = crypto_comp_compress(tfm, ctemplate[i].input,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 ilen, result, &dlen);
1104 if (ret) {
1105 printk("fail: ret=%d\n", ret);
1106 continue;
1107 }
1108 hexdump(result, dlen);
1109 printk("%s (ratio %d:%d)\n",
Sebastian Siewior562954d2008-03-13 20:20:28 +08001110 memcmp(result, ctemplate[i].output, dlen) ? "fail" : "pass",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 ilen, dlen);
1112 }
1113
Zoltan Sogor91755a92007-12-07 16:48:11 +08001114 printk("\ntesting %s decompression\n", algo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115
Zoltan Sogor91755a92007-12-07 16:48:11 +08001116 tsize = sizeof(struct comp_testvec);
1117 tsize *= dtcount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 if (tsize > TVMEMSIZE) {
1119 printk("template (%u) too big for tvmem (%u)\n", tsize,
1120 TVMEMSIZE);
1121 goto out;
1122 }
1123
Zoltan Sogor91755a92007-12-07 16:48:11 +08001124 for (i = 0; i < dtcount; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 int ilen, ret, dlen = COMP_BUF_SIZE;
Herbert Xuef2736f2005-06-22 13:26:03 -07001126
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 printk("test %u:\n", i + 1);
1128 memset(result, 0, sizeof (result));
1129
Sebastian Siewior562954d2008-03-13 20:20:28 +08001130 ilen = dtemplate[i].inlen;
1131 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 ilen, result, &dlen);
1133 if (ret) {
1134 printk("fail: ret=%d\n", ret);
1135 continue;
1136 }
1137 hexdump(result, dlen);
1138 printk("%s (ratio %d:%d)\n",
Sebastian Siewior562954d2008-03-13 20:20:28 +08001139 memcmp(result, dtemplate[i].output, dlen) ? "fail" : "pass",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 ilen, dlen);
1141 }
1142out:
Herbert Xue4d5b792006-08-26 18:12:40 +10001143 crypto_free_comp(tfm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144}
1145
Herbert Xuef2736f2005-06-22 13:26:03 -07001146static void test_available(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147{
1148 char **name = check;
Herbert Xuef2736f2005-06-22 13:26:03 -07001149
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 while (*name) {
1151 printk("alg %s ", *name);
Herbert Xu6158efc2007-04-04 17:41:07 +10001152 printk(crypto_has_alg(*name, 0, 0) ?
Herbert Xue4d5b792006-08-26 18:12:40 +10001153 "found\n" : "not found\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 name++;
Herbert Xuef2736f2005-06-22 13:26:03 -07001155 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156}
1157
Herbert Xuef2736f2005-06-22 13:26:03 -07001158static void do_test(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159{
1160 switch (mode) {
1161
1162 case 0:
1163 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
Herbert Xuef2736f2005-06-22 13:26:03 -07001164
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
Herbert Xuef2736f2005-06-22 13:26:03 -07001166
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 //DES
Herbert Xucba83562006-08-13 08:26:09 +10001168 test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template,
1169 DES_ENC_TEST_VECTORS);
1170 test_cipher("ecb(des)", DECRYPT, des_dec_tv_template,
1171 DES_DEC_TEST_VECTORS);
1172 test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template,
1173 DES_CBC_ENC_TEST_VECTORS);
1174 test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template,
1175 DES_CBC_DEC_TEST_VECTORS);
Herbert Xuef2736f2005-06-22 13:26:03 -07001176
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 //DES3_EDE
Herbert Xucba83562006-08-13 08:26:09 +10001178 test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template,
1179 DES3_EDE_ENC_TEST_VECTORS);
1180 test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template,
1181 DES3_EDE_DEC_TEST_VECTORS);
Herbert Xuef2736f2005-06-22 13:26:03 -07001182
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
Herbert Xuef2736f2005-06-22 13:26:03 -07001184
Jonathan Lynchcd12fb92007-11-10 20:08:25 +08001185 test_hash("sha224", sha224_tv_template, SHA224_TEST_VECTORS);
1186
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
Herbert Xuef2736f2005-06-22 13:26:03 -07001188
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 //BLOWFISH
Herbert Xucba83562006-08-13 08:26:09 +10001190 test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template,
1191 BF_ENC_TEST_VECTORS);
1192 test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template,
1193 BF_DEC_TEST_VECTORS);
1194 test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template,
1195 BF_CBC_ENC_TEST_VECTORS);
1196 test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template,
1197 BF_CBC_DEC_TEST_VECTORS);
Herbert Xuef2736f2005-06-22 13:26:03 -07001198
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 //TWOFISH
Herbert Xucba83562006-08-13 08:26:09 +10001200 test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template,
1201 TF_ENC_TEST_VECTORS);
1202 test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template,
1203 TF_DEC_TEST_VECTORS);
1204 test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template,
1205 TF_CBC_ENC_TEST_VECTORS);
1206 test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template,
1207 TF_CBC_DEC_TEST_VECTORS);
Herbert Xuef2736f2005-06-22 13:26:03 -07001208
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209 //SERPENT
Herbert Xucba83562006-08-13 08:26:09 +10001210 test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template,
1211 SERPENT_ENC_TEST_VECTORS);
1212 test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template,
1213 SERPENT_DEC_TEST_VECTORS);
Herbert Xuef2736f2005-06-22 13:26:03 -07001214
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 //TNEPRES
Herbert Xucba83562006-08-13 08:26:09 +10001216 test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template,
1217 TNEPRES_ENC_TEST_VECTORS);
1218 test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template,
1219 TNEPRES_DEC_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220
1221 //AES
Herbert Xucba83562006-08-13 08:26:09 +10001222 test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template,
1223 AES_ENC_TEST_VECTORS);
1224 test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template,
1225 AES_DEC_TEST_VECTORS);
1226 test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template,
1227 AES_CBC_ENC_TEST_VECTORS);
1228 test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template,
1229 AES_CBC_DEC_TEST_VECTORS);
Rik Snelf3d10442006-11-29 19:01:41 +11001230 test_cipher("lrw(aes)", ENCRYPT, aes_lrw_enc_tv_template,
1231 AES_LRW_ENC_TEST_VECTORS);
1232 test_cipher("lrw(aes)", DECRYPT, aes_lrw_dec_tv_template,
1233 AES_LRW_DEC_TEST_VECTORS);
Rik Snelf19f5112007-09-19 20:23:13 +08001234 test_cipher("xts(aes)", ENCRYPT, aes_xts_enc_tv_template,
1235 AES_XTS_ENC_TEST_VECTORS);
1236 test_cipher("xts(aes)", DECRYPT, aes_xts_dec_tv_template,
1237 AES_XTS_DEC_TEST_VECTORS);
Herbert Xu5311f242007-12-17 21:34:32 +08001238 test_cipher("rfc3686(ctr(aes))", ENCRYPT, aes_ctr_enc_tv_template,
Joy Latten23e353c2007-10-23 08:50:32 +08001239 AES_CTR_ENC_TEST_VECTORS);
Herbert Xu5311f242007-12-17 21:34:32 +08001240 test_cipher("rfc3686(ctr(aes))", DECRYPT, aes_ctr_dec_tv_template,
Joy Latten23e353c2007-10-23 08:50:32 +08001241 AES_CTR_DEC_TEST_VECTORS);
Mikko Herranen28db8e32007-11-26 22:24:11 +08001242 test_aead("gcm(aes)", ENCRYPT, aes_gcm_enc_tv_template,
1243 AES_GCM_ENC_TEST_VECTORS);
1244 test_aead("gcm(aes)", DECRYPT, aes_gcm_dec_tv_template,
1245 AES_GCM_DEC_TEST_VECTORS);
Joy Latten93cc74e2007-12-12 20:24:22 +08001246 test_aead("ccm(aes)", ENCRYPT, aes_ccm_enc_tv_template,
1247 AES_CCM_ENC_TEST_VECTORS);
1248 test_aead("ccm(aes)", DECRYPT, aes_ccm_dec_tv_template,
1249 AES_CCM_DEC_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250
1251 //CAST5
Herbert Xucba83562006-08-13 08:26:09 +10001252 test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template,
1253 CAST5_ENC_TEST_VECTORS);
1254 test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template,
1255 CAST5_DEC_TEST_VECTORS);
Herbert Xuef2736f2005-06-22 13:26:03 -07001256
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 //CAST6
Herbert Xucba83562006-08-13 08:26:09 +10001258 test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template,
1259 CAST6_ENC_TEST_VECTORS);
1260 test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template,
1261 CAST6_DEC_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262
1263 //ARC4
Herbert Xucba83562006-08-13 08:26:09 +10001264 test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template,
1265 ARC4_ENC_TEST_VECTORS);
1266 test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template,
1267 ARC4_DEC_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268
1269 //TEA
Herbert Xucba83562006-08-13 08:26:09 +10001270 test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template,
1271 TEA_ENC_TEST_VECTORS);
1272 test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template,
1273 TEA_DEC_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274
1275
1276 //XTEA
Herbert Xucba83562006-08-13 08:26:09 +10001277 test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template,
1278 XTEA_ENC_TEST_VECTORS);
1279 test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template,
1280 XTEA_DEC_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281
1282 //KHAZAD
Herbert Xucba83562006-08-13 08:26:09 +10001283 test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template,
1284 KHAZAD_ENC_TEST_VECTORS);
1285 test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template,
1286 KHAZAD_DEC_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287
1288 //ANUBIS
Herbert Xucba83562006-08-13 08:26:09 +10001289 test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template,
1290 ANUBIS_ENC_TEST_VECTORS);
1291 test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template,
1292 ANUBIS_DEC_TEST_VECTORS);
1293 test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template,
1294 ANUBIS_CBC_ENC_TEST_VECTORS);
1295 test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template,
1296 ANUBIS_CBC_ENC_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297
Aaron Grothefb4f10e2005-09-01 17:42:46 -07001298 //XETA
Herbert Xucba83562006-08-13 08:26:09 +10001299 test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template,
1300 XETA_ENC_TEST_VECTORS);
1301 test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template,
1302 XETA_DEC_TEST_VECTORS);
Aaron Grothefb4f10e2005-09-01 17:42:46 -07001303
David Howells90831632006-12-16 12:13:14 +11001304 //FCrypt
1305 test_cipher("pcbc(fcrypt)", ENCRYPT, fcrypt_pcbc_enc_tv_template,
1306 FCRYPT_ENC_TEST_VECTORS);
1307 test_cipher("pcbc(fcrypt)", DECRYPT, fcrypt_pcbc_dec_tv_template,
1308 FCRYPT_DEC_TEST_VECTORS);
1309
Noriaki TAKAMIYA02ab5a72007-01-24 21:48:19 +11001310 //CAMELLIA
1311 test_cipher("ecb(camellia)", ENCRYPT,
1312 camellia_enc_tv_template,
1313 CAMELLIA_ENC_TEST_VECTORS);
1314 test_cipher("ecb(camellia)", DECRYPT,
1315 camellia_dec_tv_template,
1316 CAMELLIA_DEC_TEST_VECTORS);
1317 test_cipher("cbc(camellia)", ENCRYPT,
1318 camellia_cbc_enc_tv_template,
1319 CAMELLIA_CBC_ENC_TEST_VECTORS);
1320 test_cipher("cbc(camellia)", DECRYPT,
1321 camellia_cbc_dec_tv_template,
1322 CAMELLIA_CBC_DEC_TEST_VECTORS);
1323
Hye-Shik Change2ee95b2007-08-21 20:01:03 +08001324 //SEED
1325 test_cipher("ecb(seed)", ENCRYPT, seed_enc_tv_template,
1326 SEED_ENC_TEST_VECTORS);
1327 test_cipher("ecb(seed)", DECRYPT, seed_dec_tv_template,
1328 SEED_DEC_TEST_VECTORS);
1329
Kevin Coffman76cb9522008-03-24 21:26:16 +08001330 //CTS
1331 test_cipher("cts(cbc(aes))", ENCRYPT, cts_mode_enc_tv_template,
1332 CTS_MODE_ENC_TEST_VECTORS);
1333 test_cipher("cts(cbc(aes))", DECRYPT, cts_mode_dec_tv_template,
1334 CTS_MODE_DEC_TEST_VECTORS);
1335
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
1337 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
1338 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
1339 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
1340 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
1341 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
1342 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
1343 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
Zoltan Sogor91755a92007-12-07 16:48:11 +08001344 test_comp("deflate", deflate_comp_tv_template,
1345 deflate_decomp_tv_template, DEFLATE_COMP_TEST_VECTORS,
1346 DEFLATE_DECOMP_TEST_VECTORS);
Zoltan Sogor0b77abb2007-12-07 16:53:23 +08001347 test_comp("lzo", lzo_comp_tv_template, lzo_decomp_tv_template,
1348 LZO_COMP_TEST_VECTORS, LZO_DECOMP_TEST_VECTORS);
Herbert Xuc907ee72006-08-21 22:04:03 +10001349 test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS);
Herbert Xue9d41162006-08-19 21:38:49 +10001350 test_hash("hmac(md5)", hmac_md5_tv_template,
1351 HMAC_MD5_TEST_VECTORS);
1352 test_hash("hmac(sha1)", hmac_sha1_tv_template,
1353 HMAC_SHA1_TEST_VECTORS);
Jonathan Lynchcd12fb92007-11-10 20:08:25 +08001354 test_hash("hmac(sha224)", hmac_sha224_tv_template,
1355 HMAC_SHA224_TEST_VECTORS);
Herbert Xue9d41162006-08-19 21:38:49 +10001356 test_hash("hmac(sha256)", hmac_sha256_tv_template,
1357 HMAC_SHA256_TEST_VECTORS);
Andrew Donofrioa28091a2006-12-10 12:10:20 +11001358 test_hash("hmac(sha384)", hmac_sha384_tv_template,
1359 HMAC_SHA384_TEST_VECTORS);
1360 test_hash("hmac(sha512)", hmac_sha512_tv_template,
1361 HMAC_SHA512_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362
Kazunori MIYAZAWA5b2becf2006-10-28 13:18:53 +10001363 test_hash("xcbc(aes)", aes_xcbc128_tv_template,
1364 XCBC_AES_TEST_VECTORS);
1365
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
1367 break;
1368
1369 case 1:
1370 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
1371 break;
1372
1373 case 2:
1374 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
1375 break;
1376
1377 case 3:
Herbert Xucba83562006-08-13 08:26:09 +10001378 test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template,
1379 DES_ENC_TEST_VECTORS);
1380 test_cipher("ecb(des)", DECRYPT, des_dec_tv_template,
1381 DES_DEC_TEST_VECTORS);
1382 test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template,
1383 DES_CBC_ENC_TEST_VECTORS);
1384 test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template,
1385 DES_CBC_DEC_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 break;
1387
1388 case 4:
Herbert Xucba83562006-08-13 08:26:09 +10001389 test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template,
1390 DES3_EDE_ENC_TEST_VECTORS);
1391 test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template,
1392 DES3_EDE_DEC_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 break;
1394
1395 case 5:
1396 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
1397 break;
Herbert Xuef2736f2005-06-22 13:26:03 -07001398
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 case 6:
1400 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
1401 break;
Herbert Xuef2736f2005-06-22 13:26:03 -07001402
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403 case 7:
Herbert Xucba83562006-08-13 08:26:09 +10001404 test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template,
1405 BF_ENC_TEST_VECTORS);
1406 test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template,
1407 BF_DEC_TEST_VECTORS);
1408 test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template,
1409 BF_CBC_ENC_TEST_VECTORS);
1410 test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template,
1411 BF_CBC_DEC_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 break;
1413
1414 case 8:
Herbert Xucba83562006-08-13 08:26:09 +10001415 test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template,
1416 TF_ENC_TEST_VECTORS);
1417 test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template,
1418 TF_DEC_TEST_VECTORS);
1419 test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template,
1420 TF_CBC_ENC_TEST_VECTORS);
1421 test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template,
1422 TF_CBC_DEC_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 break;
Herbert Xuef2736f2005-06-22 13:26:03 -07001424
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425 case 9:
Herbert Xucba83562006-08-13 08:26:09 +10001426 test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template,
1427 SERPENT_ENC_TEST_VECTORS);
1428 test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template,
1429 SERPENT_DEC_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 break;
1431
1432 case 10:
Herbert Xucba83562006-08-13 08:26:09 +10001433 test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template,
1434 AES_ENC_TEST_VECTORS);
1435 test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template,
1436 AES_DEC_TEST_VECTORS);
1437 test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template,
1438 AES_CBC_ENC_TEST_VECTORS);
1439 test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template,
1440 AES_CBC_DEC_TEST_VECTORS);
Rik Snelf3d10442006-11-29 19:01:41 +11001441 test_cipher("lrw(aes)", ENCRYPT, aes_lrw_enc_tv_template,
1442 AES_LRW_ENC_TEST_VECTORS);
1443 test_cipher("lrw(aes)", DECRYPT, aes_lrw_dec_tv_template,
1444 AES_LRW_DEC_TEST_VECTORS);
Rik Snelf19f5112007-09-19 20:23:13 +08001445 test_cipher("xts(aes)", ENCRYPT, aes_xts_enc_tv_template,
1446 AES_XTS_ENC_TEST_VECTORS);
1447 test_cipher("xts(aes)", DECRYPT, aes_xts_dec_tv_template,
1448 AES_XTS_DEC_TEST_VECTORS);
Herbert Xu5311f242007-12-17 21:34:32 +08001449 test_cipher("rfc3686(ctr(aes))", ENCRYPT, aes_ctr_enc_tv_template,
Joy Latten23e353c2007-10-23 08:50:32 +08001450 AES_CTR_ENC_TEST_VECTORS);
Herbert Xu5311f242007-12-17 21:34:32 +08001451 test_cipher("rfc3686(ctr(aes))", DECRYPT, aes_ctr_dec_tv_template,
Joy Latten23e353c2007-10-23 08:50:32 +08001452 AES_CTR_DEC_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 break;
1454
1455 case 11:
1456 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
1457 break;
Herbert Xuef2736f2005-06-22 13:26:03 -07001458
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 case 12:
1460 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
1461 break;
1462
1463 case 13:
Zoltan Sogor91755a92007-12-07 16:48:11 +08001464 test_comp("deflate", deflate_comp_tv_template,
1465 deflate_decomp_tv_template, DEFLATE_COMP_TEST_VECTORS,
1466 DEFLATE_DECOMP_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 break;
1468
1469 case 14:
Herbert Xucba83562006-08-13 08:26:09 +10001470 test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template,
1471 CAST5_ENC_TEST_VECTORS);
1472 test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template,
1473 CAST5_DEC_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 break;
1475
1476 case 15:
Herbert Xucba83562006-08-13 08:26:09 +10001477 test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template,
1478 CAST6_ENC_TEST_VECTORS);
1479 test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template,
1480 CAST6_DEC_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 break;
1482
1483 case 16:
Herbert Xucba83562006-08-13 08:26:09 +10001484 test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template,
1485 ARC4_ENC_TEST_VECTORS);
1486 test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template,
1487 ARC4_DEC_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488 break;
1489
1490 case 17:
1491 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
1492 break;
1493
1494 case 18:
Herbert Xuc907ee72006-08-21 22:04:03 +10001495 test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 break;
1497
1498 case 19:
Herbert Xucba83562006-08-13 08:26:09 +10001499 test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template,
1500 TEA_ENC_TEST_VECTORS);
1501 test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template,
1502 TEA_DEC_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 break;
1504
1505 case 20:
Herbert Xucba83562006-08-13 08:26:09 +10001506 test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template,
1507 XTEA_ENC_TEST_VECTORS);
1508 test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template,
1509 XTEA_DEC_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510 break;
1511
1512 case 21:
Herbert Xucba83562006-08-13 08:26:09 +10001513 test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template,
1514 KHAZAD_ENC_TEST_VECTORS);
1515 test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template,
1516 KHAZAD_DEC_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517 break;
1518
1519 case 22:
1520 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
1521 break;
1522
1523 case 23:
1524 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
1525 break;
1526
1527 case 24:
1528 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
1529 break;
1530
1531 case 25:
Herbert Xucba83562006-08-13 08:26:09 +10001532 test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template,
1533 TNEPRES_ENC_TEST_VECTORS);
1534 test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template,
1535 TNEPRES_DEC_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536 break;
1537
1538 case 26:
Herbert Xucba83562006-08-13 08:26:09 +10001539 test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template,
1540 ANUBIS_ENC_TEST_VECTORS);
1541 test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template,
1542 ANUBIS_DEC_TEST_VECTORS);
1543 test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template,
1544 ANUBIS_CBC_ENC_TEST_VECTORS);
1545 test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template,
1546 ANUBIS_CBC_ENC_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 break;
1548
1549 case 27:
1550 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
1551 break;
1552
1553 case 28:
1554
1555 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
1556 break;
1557
1558 case 29:
1559 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
1560 break;
Aaron Grothefb4f10e2005-09-01 17:42:46 -07001561
1562 case 30:
Herbert Xucba83562006-08-13 08:26:09 +10001563 test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template,
1564 XETA_ENC_TEST_VECTORS);
1565 test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template,
1566 XETA_DEC_TEST_VECTORS);
Aaron Grothefb4f10e2005-09-01 17:42:46 -07001567 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568
David Howells90831632006-12-16 12:13:14 +11001569 case 31:
1570 test_cipher("pcbc(fcrypt)", ENCRYPT, fcrypt_pcbc_enc_tv_template,
1571 FCRYPT_ENC_TEST_VECTORS);
1572 test_cipher("pcbc(fcrypt)", DECRYPT, fcrypt_pcbc_dec_tv_template,
1573 FCRYPT_DEC_TEST_VECTORS);
1574 break;
1575
Noriaki TAKAMIYA02ab5a72007-01-24 21:48:19 +11001576 case 32:
1577 test_cipher("ecb(camellia)", ENCRYPT,
1578 camellia_enc_tv_template,
1579 CAMELLIA_ENC_TEST_VECTORS);
1580 test_cipher("ecb(camellia)", DECRYPT,
1581 camellia_dec_tv_template,
1582 CAMELLIA_DEC_TEST_VECTORS);
1583 test_cipher("cbc(camellia)", ENCRYPT,
1584 camellia_cbc_enc_tv_template,
1585 CAMELLIA_CBC_ENC_TEST_VECTORS);
1586 test_cipher("cbc(camellia)", DECRYPT,
1587 camellia_cbc_dec_tv_template,
1588 CAMELLIA_CBC_DEC_TEST_VECTORS);
1589 break;
Jonathan Lynchcd12fb92007-11-10 20:08:25 +08001590 case 33:
1591 test_hash("sha224", sha224_tv_template, SHA224_TEST_VECTORS);
1592 break;
Noriaki TAKAMIYA02ab5a72007-01-24 21:48:19 +11001593
Tan Swee Heng2407d602007-11-23 19:45:00 +08001594 case 34:
1595 test_cipher("salsa20", ENCRYPT,
1596 salsa20_stream_enc_tv_template,
1597 SALSA20_STREAM_ENC_TEST_VECTORS);
1598 break;
1599
Herbert Xu8df213d2007-12-02 14:55:47 +11001600 case 35:
1601 test_aead("gcm(aes)", ENCRYPT, aes_gcm_enc_tv_template,
1602 AES_GCM_ENC_TEST_VECTORS);
1603 test_aead("gcm(aes)", DECRYPT, aes_gcm_dec_tv_template,
1604 AES_GCM_DEC_TEST_VECTORS);
1605 break;
1606
Zoltan Sogor0b77abb2007-12-07 16:53:23 +08001607 case 36:
1608 test_comp("lzo", lzo_comp_tv_template, lzo_decomp_tv_template,
1609 LZO_COMP_TEST_VECTORS, LZO_DECOMP_TEST_VECTORS);
1610 break;
1611
Joy Latten93cc74e2007-12-12 20:24:22 +08001612 case 37:
1613 test_aead("ccm(aes)", ENCRYPT, aes_ccm_enc_tv_template,
1614 AES_CCM_ENC_TEST_VECTORS);
1615 test_aead("ccm(aes)", DECRYPT, aes_ccm_dec_tv_template,
1616 AES_CCM_DEC_TEST_VECTORS);
1617 break;
1618
Kevin Coffman76cb9522008-03-24 21:26:16 +08001619 case 38:
1620 test_cipher("cts(cbc(aes))", ENCRYPT, cts_mode_enc_tv_template,
1621 CTS_MODE_ENC_TEST_VECTORS);
1622 test_cipher("cts(cbc(aes))", DECRYPT, cts_mode_dec_tv_template,
1623 CTS_MODE_DEC_TEST_VECTORS);
1624 break;
1625
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626 case 100:
Herbert Xue9d41162006-08-19 21:38:49 +10001627 test_hash("hmac(md5)", hmac_md5_tv_template,
1628 HMAC_MD5_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 break;
Herbert Xuef2736f2005-06-22 13:26:03 -07001630
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 case 101:
Herbert Xue9d41162006-08-19 21:38:49 +10001632 test_hash("hmac(sha1)", hmac_sha1_tv_template,
1633 HMAC_SHA1_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634 break;
Herbert Xuef2736f2005-06-22 13:26:03 -07001635
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 case 102:
Herbert Xue9d41162006-08-19 21:38:49 +10001637 test_hash("hmac(sha256)", hmac_sha256_tv_template,
1638 HMAC_SHA256_TEST_VECTORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639 break;
1640
Andrew Donofrioa28091a2006-12-10 12:10:20 +11001641 case 103:
1642 test_hash("hmac(sha384)", hmac_sha384_tv_template,
1643 HMAC_SHA384_TEST_VECTORS);
1644 break;
1645
1646 case 104:
1647 test_hash("hmac(sha512)", hmac_sha512_tv_template,
1648 HMAC_SHA512_TEST_VECTORS);
1649 break;
Herbert Xu38ed9ab2008-01-01 15:59:28 +11001650
Jonathan Lynchcd12fb92007-11-10 20:08:25 +08001651 case 105:
1652 test_hash("hmac(sha224)", hmac_sha224_tv_template,
1653 HMAC_SHA224_TEST_VECTORS);
1654 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655
Herbert Xu38ed9ab2008-01-01 15:59:28 +11001656 case 106:
1657 test_hash("xcbc(aes)", aes_xcbc128_tv_template,
1658 XCBC_AES_TEST_VECTORS);
1659 break;
1660
Harald Welteebfd9bc2005-06-22 13:27:23 -07001661 case 200:
Herbert Xucba83562006-08-13 08:26:09 +10001662 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001663 speed_template_16_24_32);
Herbert Xucba83562006-08-13 08:26:09 +10001664 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001665 speed_template_16_24_32);
Herbert Xucba83562006-08-13 08:26:09 +10001666 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001667 speed_template_16_24_32);
Herbert Xucba83562006-08-13 08:26:09 +10001668 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001669 speed_template_16_24_32);
Rik Snelf3d10442006-11-29 19:01:41 +11001670 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001671 speed_template_32_40_48);
Rik Snelf3d10442006-11-29 19:01:41 +11001672 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001673 speed_template_32_40_48);
Rik Snelf19f5112007-09-19 20:23:13 +08001674 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001675 speed_template_32_48_64);
Rik Snelf19f5112007-09-19 20:23:13 +08001676 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001677 speed_template_32_48_64);
Harald Welteebfd9bc2005-06-22 13:27:23 -07001678 break;
1679
1680 case 201:
Herbert Xucba83562006-08-13 08:26:09 +10001681 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001682 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1683 speed_template_24);
Herbert Xucba83562006-08-13 08:26:09 +10001684 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001685 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1686 speed_template_24);
Herbert Xucba83562006-08-13 08:26:09 +10001687 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001688 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1689 speed_template_24);
Herbert Xucba83562006-08-13 08:26:09 +10001690 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001691 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1692 speed_template_24);
Harald Welteebfd9bc2005-06-22 13:27:23 -07001693 break;
1694
1695 case 202:
Herbert Xucba83562006-08-13 08:26:09 +10001696 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001697 speed_template_16_24_32);
Herbert Xucba83562006-08-13 08:26:09 +10001698 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001699 speed_template_16_24_32);
Herbert Xucba83562006-08-13 08:26:09 +10001700 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001701 speed_template_16_24_32);
Herbert Xucba83562006-08-13 08:26:09 +10001702 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001703 speed_template_16_24_32);
Harald Welteebfd9bc2005-06-22 13:27:23 -07001704 break;
1705
1706 case 203:
Herbert Xucba83562006-08-13 08:26:09 +10001707 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001708 speed_template_8_32);
Herbert Xucba83562006-08-13 08:26:09 +10001709 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001710 speed_template_8_32);
Herbert Xucba83562006-08-13 08:26:09 +10001711 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001712 speed_template_8_32);
Herbert Xucba83562006-08-13 08:26:09 +10001713 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001714 speed_template_8_32);
Harald Welteebfd9bc2005-06-22 13:27:23 -07001715 break;
1716
1717 case 204:
Herbert Xucba83562006-08-13 08:26:09 +10001718 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001719 speed_template_8);
Herbert Xucba83562006-08-13 08:26:09 +10001720 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001721 speed_template_8);
Herbert Xucba83562006-08-13 08:26:09 +10001722 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001723 speed_template_8);
Herbert Xucba83562006-08-13 08:26:09 +10001724 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001725 speed_template_8);
Harald Welteebfd9bc2005-06-22 13:27:23 -07001726 break;
1727
Noriaki TAKAMIYA02ab5a72007-01-24 21:48:19 +11001728 case 205:
1729 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001730 speed_template_16_24_32);
Noriaki TAKAMIYA02ab5a72007-01-24 21:48:19 +11001731 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001732 speed_template_16_24_32);
Noriaki TAKAMIYA02ab5a72007-01-24 21:48:19 +11001733 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001734 speed_template_16_24_32);
Noriaki TAKAMIYA02ab5a72007-01-24 21:48:19 +11001735 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001736 speed_template_16_24_32);
Noriaki TAKAMIYA02ab5a72007-01-24 21:48:19 +11001737 break;
1738
Tan Swee Heng5de8f1b2007-12-07 17:17:43 +08001739 case 206:
1740 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +08001741 speed_template_16_32);
Tan Swee Heng5de8f1b2007-12-07 17:17:43 +08001742 break;
1743
Michal Ludvige8057922006-05-30 22:04:19 +10001744 case 300:
1745 /* fall through */
1746
1747 case 301:
Herbert Xue9d41162006-08-19 21:38:49 +10001748 test_hash_speed("md4", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +10001749 if (mode > 300 && mode < 400) break;
1750
1751 case 302:
Herbert Xue9d41162006-08-19 21:38:49 +10001752 test_hash_speed("md5", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +10001753 if (mode > 300 && mode < 400) break;
1754
1755 case 303:
Herbert Xue9d41162006-08-19 21:38:49 +10001756 test_hash_speed("sha1", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +10001757 if (mode > 300 && mode < 400) break;
1758
1759 case 304:
Herbert Xue9d41162006-08-19 21:38:49 +10001760 test_hash_speed("sha256", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +10001761 if (mode > 300 && mode < 400) break;
1762
1763 case 305:
Herbert Xue9d41162006-08-19 21:38:49 +10001764 test_hash_speed("sha384", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +10001765 if (mode > 300 && mode < 400) break;
1766
1767 case 306:
Herbert Xue9d41162006-08-19 21:38:49 +10001768 test_hash_speed("sha512", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +10001769 if (mode > 300 && mode < 400) break;
1770
1771 case 307:
Herbert Xue9d41162006-08-19 21:38:49 +10001772 test_hash_speed("wp256", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +10001773 if (mode > 300 && mode < 400) break;
1774
1775 case 308:
Herbert Xue9d41162006-08-19 21:38:49 +10001776 test_hash_speed("wp384", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +10001777 if (mode > 300 && mode < 400) break;
1778
1779 case 309:
Herbert Xue9d41162006-08-19 21:38:49 +10001780 test_hash_speed("wp512", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +10001781 if (mode > 300 && mode < 400) break;
1782
1783 case 310:
Herbert Xue9d41162006-08-19 21:38:49 +10001784 test_hash_speed("tgr128", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +10001785 if (mode > 300 && mode < 400) break;
1786
1787 case 311:
Herbert Xue9d41162006-08-19 21:38:49 +10001788 test_hash_speed("tgr160", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +10001789 if (mode > 300 && mode < 400) break;
1790
1791 case 312:
Herbert Xue9d41162006-08-19 21:38:49 +10001792 test_hash_speed("tgr192", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +10001793 if (mode > 300 && mode < 400) break;
1794
Jonathan Lynchcd12fb92007-11-10 20:08:25 +08001795 case 313:
1796 test_hash_speed("sha224", sec, generic_hash_speed_template);
1797 if (mode > 300 && mode < 400) break;
1798
Michal Ludvige8057922006-05-30 22:04:19 +10001799 case 399:
1800 break;
1801
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 case 1000:
1803 test_available();
1804 break;
Herbert Xuef2736f2005-06-22 13:26:03 -07001805
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806 default:
1807 /* useful for debugging */
1808 printk("not testing anything\n");
1809 break;
1810 }
1811}
1812
Herbert Xuef2736f2005-06-22 13:26:03 -07001813static int __init init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814{
Mikko Herranene3a4ea42007-11-26 22:12:07 +08001815 int err = -ENOMEM;
1816
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
1818 if (tvmem == NULL)
Mikko Herranene3a4ea42007-11-26 22:12:07 +08001819 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820
1821 xbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
Mikko Herranene3a4ea42007-11-26 22:12:07 +08001822 if (xbuf == NULL)
1823 goto err_free_tv;
1824
1825 axbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
1826 if (axbuf == NULL)
1827 goto err_free_xbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828
1829 do_test();
1830
Michal Ludvig14fdf472006-05-30 14:49:38 +10001831 /* We intentionaly return -EAGAIN to prevent keeping
1832 * the module. It does all its work from init()
1833 * and doesn't offer any runtime functionality
1834 * => we don't need it in the memory, do we?
1835 * -- mludvig
1836 */
Mikko Herranene3a4ea42007-11-26 22:12:07 +08001837 err = -EAGAIN;
1838
1839 kfree(axbuf);
1840 err_free_xbuf:
1841 kfree(xbuf);
1842 err_free_tv:
1843 kfree(tvmem);
1844
1845 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846}
1847
1848/*
1849 * If an init function is provided, an exit function must also be provided
1850 * to allow module unload.
1851 */
1852static void __exit fini(void) { }
1853
1854module_init(init);
1855module_exit(fini);
1856
1857module_param(mode, int, 0);
Harald Welteebfd9bc2005-06-22 13:27:23 -07001858module_param(sec, uint, 0);
Herbert Xu6a179442005-06-22 13:29:03 -07001859MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
1860 "(defaults to zero which uses CPU cycles instead)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861
1862MODULE_LICENSE("GPL");
1863MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1864MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");