Eric Lee / linux-smarc-t335x-v3.2

Download as
Browse Code ยป

Commit 18c0ebd2d8194cce4b3f67e2903fa01bea892cbc

Authored by Jarod Wilson
Committed by Herbert Xu
1 parent 2918aa8d1d
Exists in master and in 4 other branches v3.2_AM335xPSP_04.06.00.11, v3.2_NEWT335xPSP_04.06.00.11, v3.2_SBC_SMARTMEN, v3.2_SMARCT335xPSP_04.06.00.11

crypto: testmgr - mark ghash as fips_allowed 

A self-test failure in fips mode means a panic. Well, gcm(aes)
self-tests currently fail in fips mode, as gcm is dependent on ghash,
which semi-recently got self-test vectors added, but wasn't marked as a
fips_allowed algorithm. Because of gcm's dependence on what is now seen
as a non-fips_allowed algorithm, its self-tests refuse to run.
Previously, ghash got a pass in fips mode, due to the lack of any test
vectors at all, and thus gcm self-tests were able to run. After this
patch, a 'modprobe tcrypt mode=35' no longer panics in fips mode, and
successful self-test of gcm(aes) is reported.

Signed-off-by: Jarod Wilson <jarod@redhat.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

Showing 1 changed file with 1 additions and 0 deletions Inline Diff

1 /* 1 /*
2 * Algorithm testing framework and tests. 2 * Algorithm testing framework and tests.
3 * 3 *
4 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au> 4 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
5 * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org> 5 * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
6 * Copyright (c) 2007 Nokia Siemens Networks 6 * Copyright (c) 2007 Nokia Siemens Networks
7 * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au> 7 * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
8 * 8 *
9 * Updated RFC4106 AES-GCM testing. 9 * Updated RFC4106 AES-GCM testing.
10 * Authors: Aidan O'Mahony (aidan.o.mahony@intel.com) 10 * Authors: Aidan O'Mahony (aidan.o.mahony@intel.com)
11 * Adrian Hoban <adrian.hoban@intel.com> 11 * Adrian Hoban <adrian.hoban@intel.com>
12 * Gabriele Paoloni <gabriele.paoloni@intel.com> 12 * Gabriele Paoloni <gabriele.paoloni@intel.com>
13 * Tadeusz Struk (tadeusz.struk@intel.com) 13 * Tadeusz Struk (tadeusz.struk@intel.com)
14 * Copyright (c) 2010, Intel Corporation. 14 * Copyright (c) 2010, Intel Corporation.
15 * 15 *
16 * This program is free software; you can redistribute it and/or modify it 16 * This program is free software; you can redistribute it and/or modify it
17 * under the terms of the GNU General Public License as published by the Free 17 * under the terms of the GNU General Public License as published by the Free
18 * Software Foundation; either version 2 of the License, or (at your option) 18 * Software Foundation; either version 2 of the License, or (at your option)
19 * any later version. 19 * any later version.
20 * 20 *
21 */ 21 */
22 22
23 #include <crypto/hash.h> 23 #include <crypto/hash.h>
24 #include <linux/err.h> 24 #include <linux/err.h>
25 #include <linux/module.h> 25 #include <linux/module.h>
26 #include <linux/scatterlist.h> 26 #include <linux/scatterlist.h>
27 #include <linux/slab.h> 27 #include <linux/slab.h>
28 #include <linux/string.h> 28 #include <linux/string.h>
29 #include <crypto/rng.h> 29 #include <crypto/rng.h>
30 30
31 #include "internal.h" 31 #include "internal.h"
32 32
33 #ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS 33 #ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
34 34
35 /* a perfect nop */ 35 /* a perfect nop */
36 int alg_test(const char *driver, const char *alg, u32 type, u32 mask) 36 int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
37 { 37 {
38 return 0; 38 return 0;
39 } 39 }
40 40
41 #else 41 #else
42 42
43 #include "testmgr.h" 43 #include "testmgr.h"
44 44
45 /* 45 /*
46 * Need slab memory for testing (size in number of pages). 46 * Need slab memory for testing (size in number of pages).
47 */ 47 */
48 #define XBUFSIZE 8 48 #define XBUFSIZE 8
49 49
50 /* 50 /*
51 * Indexes into the xbuf to simulate cross-page access. 51 * Indexes into the xbuf to simulate cross-page access.
52 */ 52 */
53 #define IDX1 32 53 #define IDX1 32
54 #define IDX2 32400 54 #define IDX2 32400
55 #define IDX3 1 55 #define IDX3 1
56 #define IDX4 8193 56 #define IDX4 8193
57 #define IDX5 22222 57 #define IDX5 22222
58 #define IDX6 17101 58 #define IDX6 17101
59 #define IDX7 27333 59 #define IDX7 27333
60 #define IDX8 3000 60 #define IDX8 3000
61 61
62 /* 62 /*
63 * Used by test_cipher() 63 * Used by test_cipher()
64 */ 64 */
65 #define ENCRYPT 1 65 #define ENCRYPT 1
66 #define DECRYPT 0 66 #define DECRYPT 0
67 67
68 struct tcrypt_result { 68 struct tcrypt_result {
69 struct completion completion; 69 struct completion completion;
70 int err; 70 int err;
71 }; 71 };
72 72
73 struct aead_test_suite { 73 struct aead_test_suite {
74 struct { 74 struct {
75 struct aead_testvec *vecs; 75 struct aead_testvec *vecs;
76 unsigned int count; 76 unsigned int count;
77 } enc, dec; 77 } enc, dec;
78 }; 78 };
79 79
80 struct cipher_test_suite { 80 struct cipher_test_suite {
81 struct { 81 struct {
82 struct cipher_testvec *vecs; 82 struct cipher_testvec *vecs;
83 unsigned int count; 83 unsigned int count;
84 } enc, dec; 84 } enc, dec;
85 }; 85 };
86 86
87 struct comp_test_suite { 87 struct comp_test_suite {
88 struct { 88 struct {
89 struct comp_testvec *vecs; 89 struct comp_testvec *vecs;
90 unsigned int count; 90 unsigned int count;
91 } comp, decomp; 91 } comp, decomp;
92 }; 92 };
93 93
94 struct pcomp_test_suite { 94 struct pcomp_test_suite {
95 struct { 95 struct {
96 struct pcomp_testvec *vecs; 96 struct pcomp_testvec *vecs;
97 unsigned int count; 97 unsigned int count;
98 } comp, decomp; 98 } comp, decomp;
99 }; 99 };
100 100
101 struct hash_test_suite { 101 struct hash_test_suite {
102 struct hash_testvec *vecs; 102 struct hash_testvec *vecs;
103 unsigned int count; 103 unsigned int count;
104 }; 104 };
105 105
106 struct cprng_test_suite { 106 struct cprng_test_suite {
107 struct cprng_testvec *vecs; 107 struct cprng_testvec *vecs;
108 unsigned int count; 108 unsigned int count;
109 }; 109 };
110 110
111 struct alg_test_desc { 111 struct alg_test_desc {
112 const char *alg; 112 const char *alg;
113 int (*test)(const struct alg_test_desc *desc, const char *driver, 113 int (*test)(const struct alg_test_desc *desc, const char *driver,
114 u32 type, u32 mask); 114 u32 type, u32 mask);
115 int fips_allowed; /* set if alg is allowed in fips mode */ 115 int fips_allowed; /* set if alg is allowed in fips mode */
116 116
117 union { 117 union {
118 struct aead_test_suite aead; 118 struct aead_test_suite aead;
119 struct cipher_test_suite cipher; 119 struct cipher_test_suite cipher;
120 struct comp_test_suite comp; 120 struct comp_test_suite comp;
121 struct pcomp_test_suite pcomp; 121 struct pcomp_test_suite pcomp;
122 struct hash_test_suite hash; 122 struct hash_test_suite hash;
123 struct cprng_test_suite cprng; 123 struct cprng_test_suite cprng;
124 } suite; 124 } suite;
125 }; 125 };
126 126
127 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 }; 127 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
128 128
129 static void hexdump(unsigned char *buf, unsigned int len) 129 static void hexdump(unsigned char *buf, unsigned int len)
130 { 130 {
131 print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET, 131 print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
132 16, 1, 132 16, 1,
133 buf, len, false); 133 buf, len, false);
134 } 134 }
135 135
136 static void tcrypt_complete(struct crypto_async_request *req, int err) 136 static void tcrypt_complete(struct crypto_async_request *req, int err)
137 { 137 {
138 struct tcrypt_result *res = req->data; 138 struct tcrypt_result *res = req->data;
139 139
140 if (err == -EINPROGRESS) 140 if (err == -EINPROGRESS)
141 return; 141 return;
142 142
143 res->err = err; 143 res->err = err;
144 complete(&res->completion); 144 complete(&res->completion);
145 } 145 }
146 146
147 static int testmgr_alloc_buf(char *buf[XBUFSIZE]) 147 static int testmgr_alloc_buf(char *buf[XBUFSIZE])
148 { 148 {
149 int i; 149 int i;
150 150
151 for (i = 0; i < XBUFSIZE; i++) { 151 for (i = 0; i < XBUFSIZE; i++) {
152 buf[i] = (void *)__get_free_page(GFP_KERNEL); 152 buf[i] = (void *)__get_free_page(GFP_KERNEL);
153 if (!buf[i]) 153 if (!buf[i])
154 goto err_free_buf; 154 goto err_free_buf;
155 } 155 }
156 156
157 return 0; 157 return 0;
158 158
159 err_free_buf: 159 err_free_buf:
160 while (i-- > 0) 160 while (i-- > 0)
161 free_page((unsigned long)buf[i]); 161 free_page((unsigned long)buf[i]);
162 162
163 return -ENOMEM; 163 return -ENOMEM;
164 } 164 }
165 165
166 static void testmgr_free_buf(char *buf[XBUFSIZE]) 166 static void testmgr_free_buf(char *buf[XBUFSIZE])
167 { 167 {
168 int i; 168 int i;
169 169
170 for (i = 0; i < XBUFSIZE; i++) 170 for (i = 0; i < XBUFSIZE; i++)
171 free_page((unsigned long)buf[i]); 171 free_page((unsigned long)buf[i]);
172 } 172 }
173 173
174 static int do_one_async_hash_op(struct ahash_request *req, 174 static int do_one_async_hash_op(struct ahash_request *req,
175 struct tcrypt_result *tr, 175 struct tcrypt_result *tr,
176 int ret) 176 int ret)
177 { 177 {
178 if (ret == -EINPROGRESS || ret == -EBUSY) { 178 if (ret == -EINPROGRESS || ret == -EBUSY) {
179 ret = wait_for_completion_interruptible(&tr->completion); 179 ret = wait_for_completion_interruptible(&tr->completion);
180 if (!ret) 180 if (!ret)
181 ret = tr->err; 181 ret = tr->err;
182 INIT_COMPLETION(tr->completion); 182 INIT_COMPLETION(tr->completion);
183 } 183 }
184 return ret; 184 return ret;
185 } 185 }
186 186
187 static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template, 187 static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
188 unsigned int tcount, bool use_digest) 188 unsigned int tcount, bool use_digest)
189 { 189 {
190 const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm)); 190 const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
191 unsigned int i, j, k, temp; 191 unsigned int i, j, k, temp;
192 struct scatterlist sg[8]; 192 struct scatterlist sg[8];
193 char result[64]; 193 char result[64];
194 struct ahash_request *req; 194 struct ahash_request *req;
195 struct tcrypt_result tresult; 195 struct tcrypt_result tresult;
196 void *hash_buff; 196 void *hash_buff;
197 char *xbuf[XBUFSIZE]; 197 char *xbuf[XBUFSIZE];
198 int ret = -ENOMEM; 198 int ret = -ENOMEM;
199 199
200 if (testmgr_alloc_buf(xbuf)) 200 if (testmgr_alloc_buf(xbuf))
201 goto out_nobuf; 201 goto out_nobuf;
202 202
203 init_completion(&tresult.completion); 203 init_completion(&tresult.completion);
204 204
205 req = ahash_request_alloc(tfm, GFP_KERNEL); 205 req = ahash_request_alloc(tfm, GFP_KERNEL);
206 if (!req) { 206 if (!req) {
207 printk(KERN_ERR "alg: hash: Failed to allocate request for " 207 printk(KERN_ERR "alg: hash: Failed to allocate request for "
208 "%s\n", algo); 208 "%s\n", algo);
209 goto out_noreq; 209 goto out_noreq;
210 } 210 }
211 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 211 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
212 tcrypt_complete, &tresult); 212 tcrypt_complete, &tresult);
213 213
214 j = 0; 214 j = 0;
215 for (i = 0; i < tcount; i++) { 215 for (i = 0; i < tcount; i++) {
216 if (template[i].np) 216 if (template[i].np)
217 continue; 217 continue;
218 218
219 j++; 219 j++;
220 memset(result, 0, 64); 220 memset(result, 0, 64);
221 221
222 hash_buff = xbuf[0]; 222 hash_buff = xbuf[0];
223 223
224 memcpy(hash_buff, template[i].plaintext, template[i].psize); 224 memcpy(hash_buff, template[i].plaintext, template[i].psize);
225 sg_init_one(&sg[0], hash_buff, template[i].psize); 225 sg_init_one(&sg[0], hash_buff, template[i].psize);
226 226
227 if (template[i].ksize) { 227 if (template[i].ksize) {
228 crypto_ahash_clear_flags(tfm, ~0); 228 crypto_ahash_clear_flags(tfm, ~0);
229 ret = crypto_ahash_setkey(tfm, template[i].key, 229 ret = crypto_ahash_setkey(tfm, template[i].key,
230 template[i].ksize); 230 template[i].ksize);
231 if (ret) { 231 if (ret) {
232 printk(KERN_ERR "alg: hash: setkey failed on " 232 printk(KERN_ERR "alg: hash: setkey failed on "
233 "test %d for %s: ret=%d\n", j, algo, 233 "test %d for %s: ret=%d\n", j, algo,
234 -ret); 234 -ret);
235 goto out; 235 goto out;
236 } 236 }
237 } 237 }
238 238
239 ahash_request_set_crypt(req, sg, result, template[i].psize); 239 ahash_request_set_crypt(req, sg, result, template[i].psize);
240 if (use_digest) { 240 if (use_digest) {
241 ret = do_one_async_hash_op(req, &tresult, 241 ret = do_one_async_hash_op(req, &tresult,
242 crypto_ahash_digest(req)); 242 crypto_ahash_digest(req));
243 if (ret) { 243 if (ret) {
244 pr_err("alg: hash: digest failed on test %d " 244 pr_err("alg: hash: digest failed on test %d "
245 "for %s: ret=%d\n", j, algo, -ret); 245 "for %s: ret=%d\n", j, algo, -ret);
246 goto out; 246 goto out;
247 } 247 }
248 } else { 248 } else {
249 ret = do_one_async_hash_op(req, &tresult, 249 ret = do_one_async_hash_op(req, &tresult,
250 crypto_ahash_init(req)); 250 crypto_ahash_init(req));
251 if (ret) { 251 if (ret) {
252 pr_err("alt: hash: init failed on test %d " 252 pr_err("alt: hash: init failed on test %d "
253 "for %s: ret=%d\n", j, algo, -ret); 253 "for %s: ret=%d\n", j, algo, -ret);
254 goto out; 254 goto out;
255 } 255 }
256 ret = do_one_async_hash_op(req, &tresult, 256 ret = do_one_async_hash_op(req, &tresult,
257 crypto_ahash_update(req)); 257 crypto_ahash_update(req));
258 if (ret) { 258 if (ret) {
259 pr_err("alt: hash: update failed on test %d " 259 pr_err("alt: hash: update failed on test %d "
260 "for %s: ret=%d\n", j, algo, -ret); 260 "for %s: ret=%d\n", j, algo, -ret);
261 goto out; 261 goto out;
262 } 262 }
263 ret = do_one_async_hash_op(req, &tresult, 263 ret = do_one_async_hash_op(req, &tresult,
264 crypto_ahash_final(req)); 264 crypto_ahash_final(req));
265 if (ret) { 265 if (ret) {
266 pr_err("alt: hash: final failed on test %d " 266 pr_err("alt: hash: final failed on test %d "
267 "for %s: ret=%d\n", j, algo, -ret); 267 "for %s: ret=%d\n", j, algo, -ret);
268 goto out; 268 goto out;
269 } 269 }
270 } 270 }
271 271
272 if (memcmp(result, template[i].digest, 272 if (memcmp(result, template[i].digest,
273 crypto_ahash_digestsize(tfm))) { 273 crypto_ahash_digestsize(tfm))) {
274 printk(KERN_ERR "alg: hash: Test %d failed for %s\n", 274 printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
275 j, algo); 275 j, algo);
276 hexdump(result, crypto_ahash_digestsize(tfm)); 276 hexdump(result, crypto_ahash_digestsize(tfm));
277 ret = -EINVAL; 277 ret = -EINVAL;
278 goto out; 278 goto out;
279 } 279 }
280 } 280 }
281 281
282 j = 0; 282 j = 0;
283 for (i = 0; i < tcount; i++) { 283 for (i = 0; i < tcount; i++) {
284 if (template[i].np) { 284 if (template[i].np) {
285 j++; 285 j++;
286 memset(result, 0, 64); 286 memset(result, 0, 64);
287 287
288 temp = 0; 288 temp = 0;
289 sg_init_table(sg, template[i].np); 289 sg_init_table(sg, template[i].np);
290 ret = -EINVAL; 290 ret = -EINVAL;
291 for (k = 0; k < template[i].np; k++) { 291 for (k = 0; k < template[i].np; k++) {
292 if (WARN_ON(offset_in_page(IDX[k]) + 292 if (WARN_ON(offset_in_page(IDX[k]) +
293 template[i].tap[k] > PAGE_SIZE)) 293 template[i].tap[k] > PAGE_SIZE))
294 goto out; 294 goto out;
295 sg_set_buf(&sg[k], 295 sg_set_buf(&sg[k],
296 memcpy(xbuf[IDX[k] >> PAGE_SHIFT] + 296 memcpy(xbuf[IDX[k] >> PAGE_SHIFT] +
297 offset_in_page(IDX[k]), 297 offset_in_page(IDX[k]),
298 template[i].plaintext + temp, 298 template[i].plaintext + temp,
299 template[i].tap[k]), 299 template[i].tap[k]),
300 template[i].tap[k]); 300 template[i].tap[k]);
301 temp += template[i].tap[k]; 301 temp += template[i].tap[k];
302 } 302 }
303 303
304 if (template[i].ksize) { 304 if (template[i].ksize) {
305 crypto_ahash_clear_flags(tfm, ~0); 305 crypto_ahash_clear_flags(tfm, ~0);
306 ret = crypto_ahash_setkey(tfm, template[i].key, 306 ret = crypto_ahash_setkey(tfm, template[i].key,
307 template[i].ksize); 307 template[i].ksize);
308 308
309 if (ret) { 309 if (ret) {
310 printk(KERN_ERR "alg: hash: setkey " 310 printk(KERN_ERR "alg: hash: setkey "
311 "failed on chunking test %d " 311 "failed on chunking test %d "
312 "for %s: ret=%d\n", j, algo, 312 "for %s: ret=%d\n", j, algo,
313 -ret); 313 -ret);
314 goto out; 314 goto out;
315 } 315 }
316 } 316 }
317 317
318 ahash_request_set_crypt(req, sg, result, 318 ahash_request_set_crypt(req, sg, result,
319 template[i].psize); 319 template[i].psize);
320 ret = crypto_ahash_digest(req); 320 ret = crypto_ahash_digest(req);
321 switch (ret) { 321 switch (ret) {
322 case 0: 322 case 0:
323 break; 323 break;
324 case -EINPROGRESS: 324 case -EINPROGRESS:
325 case -EBUSY: 325 case -EBUSY:
326 ret = wait_for_completion_interruptible( 326 ret = wait_for_completion_interruptible(
327 &tresult.completion); 327 &tresult.completion);
328 if (!ret && !(ret = tresult.err)) { 328 if (!ret && !(ret = tresult.err)) {
329 INIT_COMPLETION(tresult.completion); 329 INIT_COMPLETION(tresult.completion);
330 break; 330 break;
331 } 331 }
332 /* fall through */ 332 /* fall through */
333 default: 333 default:
334 printk(KERN_ERR "alg: hash: digest failed " 334 printk(KERN_ERR "alg: hash: digest failed "
335 "on chunking test %d for %s: " 335 "on chunking test %d for %s: "
336 "ret=%d\n", j, algo, -ret); 336 "ret=%d\n", j, algo, -ret);
337 goto out; 337 goto out;
338 } 338 }
339 339
340 if (memcmp(result, template[i].digest, 340 if (memcmp(result, template[i].digest,
341 crypto_ahash_digestsize(tfm))) { 341 crypto_ahash_digestsize(tfm))) {
342 printk(KERN_ERR "alg: hash: Chunking test %d " 342 printk(KERN_ERR "alg: hash: Chunking test %d "
343 "failed for %s\n", j, algo); 343 "failed for %s\n", j, algo);
344 hexdump(result, crypto_ahash_digestsize(tfm)); 344 hexdump(result, crypto_ahash_digestsize(tfm));
345 ret = -EINVAL; 345 ret = -EINVAL;
346 goto out; 346 goto out;
347 } 347 }
348 } 348 }
349 } 349 }
350 350
351 ret = 0; 351 ret = 0;
352 352
353 out: 353 out:
354 ahash_request_free(req); 354 ahash_request_free(req);
355 out_noreq: 355 out_noreq:
356 testmgr_free_buf(xbuf); 356 testmgr_free_buf(xbuf);
357 out_nobuf: 357 out_nobuf:
358 return ret; 358 return ret;
359 } 359 }
360 360
361 static int test_aead(struct crypto_aead *tfm, int enc, 361 static int test_aead(struct crypto_aead *tfm, int enc,
362 struct aead_testvec *template, unsigned int tcount) 362 struct aead_testvec *template, unsigned int tcount)
363 { 363 {
364 const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm)); 364 const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm));
365 unsigned int i, j, k, n, temp; 365 unsigned int i, j, k, n, temp;
366 int ret = -ENOMEM; 366 int ret = -ENOMEM;
367 char *q; 367 char *q;
368 char *key; 368 char *key;
369 struct aead_request *req; 369 struct aead_request *req;
370 struct scatterlist sg[8]; 370 struct scatterlist sg[8];
371 struct scatterlist asg[8]; 371 struct scatterlist asg[8];
372 const char *e; 372 const char *e;
373 struct tcrypt_result result; 373 struct tcrypt_result result;
374 unsigned int authsize; 374 unsigned int authsize;
375 void *input; 375 void *input;
376 void *assoc; 376 void *assoc;
377 char iv[MAX_IVLEN]; 377 char iv[MAX_IVLEN];
378 char *xbuf[XBUFSIZE]; 378 char *xbuf[XBUFSIZE];
379 char *axbuf[XBUFSIZE]; 379 char *axbuf[XBUFSIZE];
380 380
381 if (testmgr_alloc_buf(xbuf)) 381 if (testmgr_alloc_buf(xbuf))
382 goto out_noxbuf; 382 goto out_noxbuf;
383 if (testmgr_alloc_buf(axbuf)) 383 if (testmgr_alloc_buf(axbuf))
384 goto out_noaxbuf; 384 goto out_noaxbuf;
385 385
386 if (enc == ENCRYPT) 386 if (enc == ENCRYPT)
387 e = "encryption"; 387 e = "encryption";
388 else 388 else
389 e = "decryption"; 389 e = "decryption";
390 390
391 init_completion(&result.completion); 391 init_completion(&result.completion);
392 392
393 req = aead_request_alloc(tfm, GFP_KERNEL); 393 req = aead_request_alloc(tfm, GFP_KERNEL);
394 if (!req) { 394 if (!req) {
395 printk(KERN_ERR "alg: aead: Failed to allocate request for " 395 printk(KERN_ERR "alg: aead: Failed to allocate request for "
396 "%s\n", algo); 396 "%s\n", algo);
397 goto out; 397 goto out;
398 } 398 }
399 399
400 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 400 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
401 tcrypt_complete, &result); 401 tcrypt_complete, &result);
402 402
403 for (i = 0, j = 0; i < tcount; i++) { 403 for (i = 0, j = 0; i < tcount; i++) {
404 if (!template[i].np) { 404 if (!template[i].np) {
405 j++; 405 j++;
406 406
407 /* some tepmplates have no input data but they will 407 /* some tepmplates have no input data but they will
408 * touch input 408 * touch input
409 */ 409 */
410 input = xbuf[0]; 410 input = xbuf[0];
411 assoc = axbuf[0]; 411 assoc = axbuf[0];
412 412
413 ret = -EINVAL; 413 ret = -EINVAL;
414 if (WARN_ON(template[i].ilen > PAGE_SIZE || 414 if (WARN_ON(template[i].ilen > PAGE_SIZE ||
415 template[i].alen > PAGE_SIZE)) 415 template[i].alen > PAGE_SIZE))
416 goto out; 416 goto out;
417 417
418 memcpy(input, template[i].input, template[i].ilen); 418 memcpy(input, template[i].input, template[i].ilen);
419 memcpy(assoc, template[i].assoc, template[i].alen); 419 memcpy(assoc, template[i].assoc, template[i].alen);
420 if (template[i].iv) 420 if (template[i].iv)
421 memcpy(iv, template[i].iv, MAX_IVLEN); 421 memcpy(iv, template[i].iv, MAX_IVLEN);
422 else 422 else
423 memset(iv, 0, MAX_IVLEN); 423 memset(iv, 0, MAX_IVLEN);
424 424
425 crypto_aead_clear_flags(tfm, ~0); 425 crypto_aead_clear_flags(tfm, ~0);
426 if (template[i].wk) 426 if (template[i].wk)
427 crypto_aead_set_flags( 427 crypto_aead_set_flags(
428 tfm, CRYPTO_TFM_REQ_WEAK_KEY); 428 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
429 429
430 key = template[i].key; 430 key = template[i].key;
431 431
432 ret = crypto_aead_setkey(tfm, key, 432 ret = crypto_aead_setkey(tfm, key,
433 template[i].klen); 433 template[i].klen);
434 if (!ret == template[i].fail) { 434 if (!ret == template[i].fail) {
435 printk(KERN_ERR "alg: aead: setkey failed on " 435 printk(KERN_ERR "alg: aead: setkey failed on "
436 "test %d for %s: flags=%x\n", j, algo, 436 "test %d for %s: flags=%x\n", j, algo,
437 crypto_aead_get_flags(tfm)); 437 crypto_aead_get_flags(tfm));
438 goto out; 438 goto out;
439 } else if (ret) 439 } else if (ret)
440 continue; 440 continue;
441 441
442 authsize = abs(template[i].rlen - template[i].ilen); 442 authsize = abs(template[i].rlen - template[i].ilen);
443 ret = crypto_aead_setauthsize(tfm, authsize); 443 ret = crypto_aead_setauthsize(tfm, authsize);
444 if (ret) { 444 if (ret) {
445 printk(KERN_ERR "alg: aead: Failed to set " 445 printk(KERN_ERR "alg: aead: Failed to set "
446 "authsize to %u on test %d for %s\n", 446 "authsize to %u on test %d for %s\n",
447 authsize, j, algo); 447 authsize, j, algo);
448 goto out; 448 goto out;
449 } 449 }
450 450
451 sg_init_one(&sg[0], input, 451 sg_init_one(&sg[0], input,
452 template[i].ilen + (enc ? authsize : 0)); 452 template[i].ilen + (enc ? authsize : 0));
453 453
454 sg_init_one(&asg[0], assoc, template[i].alen); 454 sg_init_one(&asg[0], assoc, template[i].alen);
455 455
456 aead_request_set_crypt(req, sg, sg, 456 aead_request_set_crypt(req, sg, sg,
457 template[i].ilen, iv); 457 template[i].ilen, iv);
458 458
459 aead_request_set_assoc(req, asg, template[i].alen); 459 aead_request_set_assoc(req, asg, template[i].alen);
460 460
461 ret = enc ? 461 ret = enc ?
462 crypto_aead_encrypt(req) : 462 crypto_aead_encrypt(req) :
463 crypto_aead_decrypt(req); 463 crypto_aead_decrypt(req);
464 464
465 switch (ret) { 465 switch (ret) {
466 case 0: 466 case 0:
467 if (template[i].novrfy) { 467 if (template[i].novrfy) {
468 /* verification was supposed to fail */ 468 /* verification was supposed to fail */
469 printk(KERN_ERR "alg: aead: %s failed " 469 printk(KERN_ERR "alg: aead: %s failed "
470 "on test %d for %s: ret was 0, " 470 "on test %d for %s: ret was 0, "
471 "expected -EBADMSG\n", 471 "expected -EBADMSG\n",
472 e, j, algo); 472 e, j, algo);
473 /* so really, we got a bad message */ 473 /* so really, we got a bad message */
474 ret = -EBADMSG; 474 ret = -EBADMSG;
475 goto out; 475 goto out;
476 } 476 }
477 break; 477 break;
478 case -EINPROGRESS: 478 case -EINPROGRESS:
479 case -EBUSY: 479 case -EBUSY:
480 ret = wait_for_completion_interruptible( 480 ret = wait_for_completion_interruptible(
481 &result.completion); 481 &result.completion);
482 if (!ret && !(ret = result.err)) { 482 if (!ret && !(ret = result.err)) {
483 INIT_COMPLETION(result.completion); 483 INIT_COMPLETION(result.completion);
484 break; 484 break;
485 } 485 }
486 case -EBADMSG: 486 case -EBADMSG:
487 if (template[i].novrfy) 487 if (template[i].novrfy)
488 /* verification failure was expected */ 488 /* verification failure was expected */
489 continue; 489 continue;
490 /* fall through */ 490 /* fall through */
491 default: 491 default:
492 printk(KERN_ERR "alg: aead: %s failed on test " 492 printk(KERN_ERR "alg: aead: %s failed on test "
493 "%d for %s: ret=%d\n", e, j, algo, -ret); 493 "%d for %s: ret=%d\n", e, j, algo, -ret);
494 goto out; 494 goto out;
495 } 495 }
496 496
497 q = input; 497 q = input;
498 if (memcmp(q, template[i].result, template[i].rlen)) { 498 if (memcmp(q, template[i].result, template[i].rlen)) {
499 printk(KERN_ERR "alg: aead: Test %d failed on " 499 printk(KERN_ERR "alg: aead: Test %d failed on "
500 "%s for %s\n", j, e, algo); 500 "%s for %s\n", j, e, algo);
501 hexdump(q, template[i].rlen); 501 hexdump(q, template[i].rlen);
502 ret = -EINVAL; 502 ret = -EINVAL;
503 goto out; 503 goto out;
504 } 504 }
505 } 505 }
506 } 506 }
507 507
508 for (i = 0, j = 0; i < tcount; i++) { 508 for (i = 0, j = 0; i < tcount; i++) {
509 if (template[i].np) { 509 if (template[i].np) {
510 j++; 510 j++;
511 511
512 if (template[i].iv) 512 if (template[i].iv)
513 memcpy(iv, template[i].iv, MAX_IVLEN); 513 memcpy(iv, template[i].iv, MAX_IVLEN);
514 else 514 else
515 memset(iv, 0, MAX_IVLEN); 515 memset(iv, 0, MAX_IVLEN);
516 516
517 crypto_aead_clear_flags(tfm, ~0); 517 crypto_aead_clear_flags(tfm, ~0);
518 if (template[i].wk) 518 if (template[i].wk)
519 crypto_aead_set_flags( 519 crypto_aead_set_flags(
520 tfm, CRYPTO_TFM_REQ_WEAK_KEY); 520 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
521 key = template[i].key; 521 key = template[i].key;
522 522
523 ret = crypto_aead_setkey(tfm, key, template[i].klen); 523 ret = crypto_aead_setkey(tfm, key, template[i].klen);
524 if (!ret == template[i].fail) { 524 if (!ret == template[i].fail) {
525 printk(KERN_ERR "alg: aead: setkey failed on " 525 printk(KERN_ERR "alg: aead: setkey failed on "
526 "chunk test %d for %s: flags=%x\n", j, 526 "chunk test %d for %s: flags=%x\n", j,
527 algo, crypto_aead_get_flags(tfm)); 527 algo, crypto_aead_get_flags(tfm));
528 goto out; 528 goto out;
529 } else if (ret) 529 } else if (ret)
530 continue; 530 continue;
531 531
532 authsize = abs(template[i].rlen - template[i].ilen); 532 authsize = abs(template[i].rlen - template[i].ilen);
533 533
534 ret = -EINVAL; 534 ret = -EINVAL;
535 sg_init_table(sg, template[i].np); 535 sg_init_table(sg, template[i].np);
536 for (k = 0, temp = 0; k < template[i].np; k++) { 536 for (k = 0, temp = 0; k < template[i].np; k++) {
537 if (WARN_ON(offset_in_page(IDX[k]) + 537 if (WARN_ON(offset_in_page(IDX[k]) +
538 template[i].tap[k] > PAGE_SIZE)) 538 template[i].tap[k] > PAGE_SIZE))
539 goto out; 539 goto out;
540 540
541 q = xbuf[IDX[k] >> PAGE_SHIFT] + 541 q = xbuf[IDX[k] >> PAGE_SHIFT] +
542 offset_in_page(IDX[k]); 542 offset_in_page(IDX[k]);
543 543
544 memcpy(q, template[i].input + temp, 544 memcpy(q, template[i].input + temp,
545 template[i].tap[k]); 545 template[i].tap[k]);
546 546
547 n = template[i].tap[k]; 547 n = template[i].tap[k];
548 if (k == template[i].np - 1 && enc) 548 if (k == template[i].np - 1 && enc)
549 n += authsize; 549 n += authsize;
550 if (offset_in_page(q) + n < PAGE_SIZE) 550 if (offset_in_page(q) + n < PAGE_SIZE)
551 q[n] = 0; 551 q[n] = 0;
552 552
553 sg_set_buf(&sg[k], q, template[i].tap[k]); 553 sg_set_buf(&sg[k], q, template[i].tap[k]);
554 temp += template[i].tap[k]; 554 temp += template[i].tap[k];
555 } 555 }
556 556
557 ret = crypto_aead_setauthsize(tfm, authsize); 557 ret = crypto_aead_setauthsize(tfm, authsize);
558 if (ret) { 558 if (ret) {
559 printk(KERN_ERR "alg: aead: Failed to set " 559 printk(KERN_ERR "alg: aead: Failed to set "
560 "authsize to %u on chunk test %d for " 560 "authsize to %u on chunk test %d for "
561 "%s\n", authsize, j, algo); 561 "%s\n", authsize, j, algo);
562 goto out; 562 goto out;
563 } 563 }
564 564
565 if (enc) { 565 if (enc) {
566 if (WARN_ON(sg[k - 1].offset + 566 if (WARN_ON(sg[k - 1].offset +
567 sg[k - 1].length + authsize > 567 sg[k - 1].length + authsize >
568 PAGE_SIZE)) { 568 PAGE_SIZE)) {
569 ret = -EINVAL; 569 ret = -EINVAL;
570 goto out; 570 goto out;
571 } 571 }
572 572
573 sg[k - 1].length += authsize; 573 sg[k - 1].length += authsize;
574 } 574 }
575 575
576 sg_init_table(asg, template[i].anp); 576 sg_init_table(asg, template[i].anp);
577 ret = -EINVAL; 577 ret = -EINVAL;
578 for (k = 0, temp = 0; k < template[i].anp; k++) { 578 for (k = 0, temp = 0; k < template[i].anp; k++) {
579 if (WARN_ON(offset_in_page(IDX[k]) + 579 if (WARN_ON(offset_in_page(IDX[k]) +
580 template[i].atap[k] > PAGE_SIZE)) 580 template[i].atap[k] > PAGE_SIZE))
581 goto out; 581 goto out;
582 sg_set_buf(&asg[k], 582 sg_set_buf(&asg[k],
583 memcpy(axbuf[IDX[k] >> PAGE_SHIFT] + 583 memcpy(axbuf[IDX[k] >> PAGE_SHIFT] +
584 offset_in_page(IDX[k]), 584 offset_in_page(IDX[k]),
585 template[i].assoc + temp, 585 template[i].assoc + temp,
586 template[i].atap[k]), 586 template[i].atap[k]),
587 template[i].atap[k]); 587 template[i].atap[k]);
588 temp += template[i].atap[k]; 588 temp += template[i].atap[k];
589 } 589 }
590 590
591 aead_request_set_crypt(req, sg, sg, 591 aead_request_set_crypt(req, sg, sg,
592 template[i].ilen, 592 template[i].ilen,
593 iv); 593 iv);
594 594
595 aead_request_set_assoc(req, asg, template[i].alen); 595 aead_request_set_assoc(req, asg, template[i].alen);
596 596
597 ret = enc ? 597 ret = enc ?
598 crypto_aead_encrypt(req) : 598 crypto_aead_encrypt(req) :
599 crypto_aead_decrypt(req); 599 crypto_aead_decrypt(req);
600 600
601 switch (ret) { 601 switch (ret) {
602 case 0: 602 case 0:
603 if (template[i].novrfy) { 603 if (template[i].novrfy) {
604 /* verification was supposed to fail */ 604 /* verification was supposed to fail */
605 printk(KERN_ERR "alg: aead: %s failed " 605 printk(KERN_ERR "alg: aead: %s failed "
606 "on chunk test %d for %s: ret " 606 "on chunk test %d for %s: ret "
607 "was 0, expected -EBADMSG\n", 607 "was 0, expected -EBADMSG\n",
608 e, j, algo); 608 e, j, algo);
609 /* so really, we got a bad message */ 609 /* so really, we got a bad message */
610 ret = -EBADMSG; 610 ret = -EBADMSG;
611 goto out; 611 goto out;
612 } 612 }
613 break; 613 break;
614 case -EINPROGRESS: 614 case -EINPROGRESS:
615 case -EBUSY: 615 case -EBUSY:
616 ret = wait_for_completion_interruptible( 616 ret = wait_for_completion_interruptible(
617 &result.completion); 617 &result.completion);
618 if (!ret && !(ret = result.err)) { 618 if (!ret && !(ret = result.err)) {
619 INIT_COMPLETION(result.completion); 619 INIT_COMPLETION(result.completion);
620 break; 620 break;
621 } 621 }
622 case -EBADMSG: 622 case -EBADMSG:
623 if (template[i].novrfy) 623 if (template[i].novrfy)
624 /* verification failure was expected */ 624 /* verification failure was expected */
625 continue; 625 continue;
626 /* fall through */ 626 /* fall through */
627 default: 627 default:
628 printk(KERN_ERR "alg: aead: %s failed on " 628 printk(KERN_ERR "alg: aead: %s failed on "
629 "chunk test %d for %s: ret=%d\n", e, j, 629 "chunk test %d for %s: ret=%d\n", e, j,
630 algo, -ret); 630 algo, -ret);
631 goto out; 631 goto out;
632 } 632 }
633 633
634 ret = -EINVAL; 634 ret = -EINVAL;
635 for (k = 0, temp = 0; k < template[i].np; k++) { 635 for (k = 0, temp = 0; k < template[i].np; k++) {
636 q = xbuf[IDX[k] >> PAGE_SHIFT] + 636 q = xbuf[IDX[k] >> PAGE_SHIFT] +
637 offset_in_page(IDX[k]); 637 offset_in_page(IDX[k]);
638 638
639 n = template[i].tap[k]; 639 n = template[i].tap[k];
640 if (k == template[i].np - 1) 640 if (k == template[i].np - 1)
641 n += enc ? authsize : -authsize; 641 n += enc ? authsize : -authsize;
642 642
643 if (memcmp(q, template[i].result + temp, n)) { 643 if (memcmp(q, template[i].result + temp, n)) {
644 printk(KERN_ERR "alg: aead: Chunk " 644 printk(KERN_ERR "alg: aead: Chunk "
645 "test %d failed on %s at page " 645 "test %d failed on %s at page "
646 "%u for %s\n", j, e, k, algo); 646 "%u for %s\n", j, e, k, algo);
647 hexdump(q, n); 647 hexdump(q, n);
648 goto out; 648 goto out;
649 } 649 }
650 650
651 q += n; 651 q += n;
652 if (k == template[i].np - 1 && !enc) { 652 if (k == template[i].np - 1 && !enc) {
653 if (memcmp(q, template[i].input + 653 if (memcmp(q, template[i].input +
654 temp + n, authsize)) 654 temp + n, authsize))
655 n = authsize; 655 n = authsize;
656 else 656 else
657 n = 0; 657 n = 0;
658 } else { 658 } else {
659 for (n = 0; offset_in_page(q + n) && 659 for (n = 0; offset_in_page(q + n) &&
660 q[n]; n++) 660 q[n]; n++)
661 ; 661 ;
662 } 662 }
663 if (n) { 663 if (n) {
664 printk(KERN_ERR "alg: aead: Result " 664 printk(KERN_ERR "alg: aead: Result "
665 "buffer corruption in chunk " 665 "buffer corruption in chunk "
666 "test %d on %s at page %u for " 666 "test %d on %s at page %u for "
667 "%s: %u bytes:\n", j, e, k, 667 "%s: %u bytes:\n", j, e, k,
668 algo, n); 668 algo, n);
669 hexdump(q, n); 669 hexdump(q, n);
670 goto out; 670 goto out;
671 } 671 }
672 672
673 temp += template[i].tap[k]; 673 temp += template[i].tap[k];
674 } 674 }
675 } 675 }
676 } 676 }
677 677
678 ret = 0; 678 ret = 0;
679 679
680 out: 680 out:
681 aead_request_free(req); 681 aead_request_free(req);
682 testmgr_free_buf(axbuf); 682 testmgr_free_buf(axbuf);
683 out_noaxbuf: 683 out_noaxbuf:
684 testmgr_free_buf(xbuf); 684 testmgr_free_buf(xbuf);
685 out_noxbuf: 685 out_noxbuf:
686 return ret; 686 return ret;
687 } 687 }
688 688
689 static int test_cipher(struct crypto_cipher *tfm, int enc, 689 static int test_cipher(struct crypto_cipher *tfm, int enc,
690 struct cipher_testvec *template, unsigned int tcount) 690 struct cipher_testvec *template, unsigned int tcount)
691 { 691 {
692 const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm)); 692 const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
693 unsigned int i, j, k; 693 unsigned int i, j, k;
694 char *q; 694 char *q;
695 const char *e; 695 const char *e;
696 void *data; 696 void *data;
697 char *xbuf[XBUFSIZE]; 697 char *xbuf[XBUFSIZE];
698 int ret = -ENOMEM; 698 int ret = -ENOMEM;
699 699
700 if (testmgr_alloc_buf(xbuf)) 700 if (testmgr_alloc_buf(xbuf))
701 goto out_nobuf; 701 goto out_nobuf;
702 702
703 if (enc == ENCRYPT) 703 if (enc == ENCRYPT)
704 e = "encryption"; 704 e = "encryption";
705 else 705 else
706 e = "decryption"; 706 e = "decryption";
707 707
708 j = 0; 708 j = 0;
709 for (i = 0; i < tcount; i++) { 709 for (i = 0; i < tcount; i++) {
710 if (template[i].np) 710 if (template[i].np)
711 continue; 711 continue;
712 712
713 j++; 713 j++;
714 714
715 ret = -EINVAL; 715 ret = -EINVAL;
716 if (WARN_ON(template[i].ilen > PAGE_SIZE)) 716 if (WARN_ON(template[i].ilen > PAGE_SIZE))
717 goto out; 717 goto out;
718 718
719 data = xbuf[0]; 719 data = xbuf[0];
720 memcpy(data, template[i].input, template[i].ilen); 720 memcpy(data, template[i].input, template[i].ilen);
721 721
722 crypto_cipher_clear_flags(tfm, ~0); 722 crypto_cipher_clear_flags(tfm, ~0);
723 if (template[i].wk) 723 if (template[i].wk)
724 crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY); 724 crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
725 725
726 ret = crypto_cipher_setkey(tfm, template[i].key, 726 ret = crypto_cipher_setkey(tfm, template[i].key,
727 template[i].klen); 727 template[i].klen);
728 if (!ret == template[i].fail) { 728 if (!ret == template[i].fail) {
729 printk(KERN_ERR "alg: cipher: setkey failed " 729 printk(KERN_ERR "alg: cipher: setkey failed "
730 "on test %d for %s: flags=%x\n", j, 730 "on test %d for %s: flags=%x\n", j,
731 algo, crypto_cipher_get_flags(tfm)); 731 algo, crypto_cipher_get_flags(tfm));
732 goto out; 732 goto out;
733 } else if (ret) 733 } else if (ret)
734 continue; 734 continue;
735 735
736 for (k = 0; k < template[i].ilen; 736 for (k = 0; k < template[i].ilen;
737 k += crypto_cipher_blocksize(tfm)) { 737 k += crypto_cipher_blocksize(tfm)) {
738 if (enc) 738 if (enc)
739 crypto_cipher_encrypt_one(tfm, data + k, 739 crypto_cipher_encrypt_one(tfm, data + k,
740 data + k); 740 data + k);
741 else 741 else
742 crypto_cipher_decrypt_one(tfm, data + k, 742 crypto_cipher_decrypt_one(tfm, data + k,
743 data + k); 743 data + k);
744 } 744 }
745 745
746 q = data; 746 q = data;
747 if (memcmp(q, template[i].result, template[i].rlen)) { 747 if (memcmp(q, template[i].result, template[i].rlen)) {
748 printk(KERN_ERR "alg: cipher: Test %d failed " 748 printk(KERN_ERR "alg: cipher: Test %d failed "
749 "on %s for %s\n", j, e, algo); 749 "on %s for %s\n", j, e, algo);
750 hexdump(q, template[i].rlen); 750 hexdump(q, template[i].rlen);
751 ret = -EINVAL; 751 ret = -EINVAL;
752 goto out; 752 goto out;
753 } 753 }
754 } 754 }
755 755
756 ret = 0; 756 ret = 0;
757 757
758 out: 758 out:
759 testmgr_free_buf(xbuf); 759 testmgr_free_buf(xbuf);
760 out_nobuf: 760 out_nobuf:
761 return ret; 761 return ret;
762 } 762 }
763 763
764 static int test_skcipher(struct crypto_ablkcipher *tfm, int enc, 764 static int test_skcipher(struct crypto_ablkcipher *tfm, int enc,
765 struct cipher_testvec *template, unsigned int tcount) 765 struct cipher_testvec *template, unsigned int tcount)
766 { 766 {
767 const char *algo = 767 const char *algo =
768 crypto_tfm_alg_driver_name(crypto_ablkcipher_tfm(tfm)); 768 crypto_tfm_alg_driver_name(crypto_ablkcipher_tfm(tfm));
769 unsigned int i, j, k, n, temp; 769 unsigned int i, j, k, n, temp;
770 char *q; 770 char *q;
771 struct ablkcipher_request *req; 771 struct ablkcipher_request *req;
772 struct scatterlist sg[8]; 772 struct scatterlist sg[8];
773 const char *e; 773 const char *e;
774 struct tcrypt_result result; 774 struct tcrypt_result result;
775 void *data; 775 void *data;
776 char iv[MAX_IVLEN]; 776 char iv[MAX_IVLEN];
777 char *xbuf[XBUFSIZE]; 777 char *xbuf[XBUFSIZE];
778 int ret = -ENOMEM; 778 int ret = -ENOMEM;
779 779
780 if (testmgr_alloc_buf(xbuf)) 780 if (testmgr_alloc_buf(xbuf))
781 goto out_nobuf; 781 goto out_nobuf;
782 782
783 if (enc == ENCRYPT) 783 if (enc == ENCRYPT)
784 e = "encryption"; 784 e = "encryption";
785 else 785 else
786 e = "decryption"; 786 e = "decryption";
787 787
788 init_completion(&result.completion); 788 init_completion(&result.completion);
789 789
790 req = ablkcipher_request_alloc(tfm, GFP_KERNEL); 790 req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
791 if (!req) { 791 if (!req) {
792 printk(KERN_ERR "alg: skcipher: Failed to allocate request " 792 printk(KERN_ERR "alg: skcipher: Failed to allocate request "
793 "for %s\n", algo); 793 "for %s\n", algo);
794 goto out; 794 goto out;
795 } 795 }
796 796
797 ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 797 ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
798 tcrypt_complete, &result); 798 tcrypt_complete, &result);
799 799
800 j = 0; 800 j = 0;
801 for (i = 0; i < tcount; i++) { 801 for (i = 0; i < tcount; i++) {
802 if (template[i].iv) 802 if (template[i].iv)
803 memcpy(iv, template[i].iv, MAX_IVLEN); 803 memcpy(iv, template[i].iv, MAX_IVLEN);
804 else 804 else
805 memset(iv, 0, MAX_IVLEN); 805 memset(iv, 0, MAX_IVLEN);
806 806
807 if (!(template[i].np)) { 807 if (!(template[i].np)) {
808 j++; 808 j++;
809 809
810 ret = -EINVAL; 810 ret = -EINVAL;
811 if (WARN_ON(template[i].ilen > PAGE_SIZE)) 811 if (WARN_ON(template[i].ilen > PAGE_SIZE))
812 goto out; 812 goto out;
813 813
814 data = xbuf[0]; 814 data = xbuf[0];
815 memcpy(data, template[i].input, template[i].ilen); 815 memcpy(data, template[i].input, template[i].ilen);
816 816
817 crypto_ablkcipher_clear_flags(tfm, ~0); 817 crypto_ablkcipher_clear_flags(tfm, ~0);
818 if (template[i].wk) 818 if (template[i].wk)
819 crypto_ablkcipher_set_flags( 819 crypto_ablkcipher_set_flags(
820 tfm, CRYPTO_TFM_REQ_WEAK_KEY); 820 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
821 821
822 ret = crypto_ablkcipher_setkey(tfm, template[i].key, 822 ret = crypto_ablkcipher_setkey(tfm, template[i].key,
823 template[i].klen); 823 template[i].klen);
824 if (!ret == template[i].fail) { 824 if (!ret == template[i].fail) {
825 printk(KERN_ERR "alg: skcipher: setkey failed " 825 printk(KERN_ERR "alg: skcipher: setkey failed "
826 "on test %d for %s: flags=%x\n", j, 826 "on test %d for %s: flags=%x\n", j,
827 algo, crypto_ablkcipher_get_flags(tfm)); 827 algo, crypto_ablkcipher_get_flags(tfm));
828 goto out; 828 goto out;
829 } else if (ret) 829 } else if (ret)
830 continue; 830 continue;
831 831
832 sg_init_one(&sg[0], data, template[i].ilen); 832 sg_init_one(&sg[0], data, template[i].ilen);
833 833
834 ablkcipher_request_set_crypt(req, sg, sg, 834 ablkcipher_request_set_crypt(req, sg, sg,
835 template[i].ilen, iv); 835 template[i].ilen, iv);
836 ret = enc ? 836 ret = enc ?
837 crypto_ablkcipher_encrypt(req) : 837 crypto_ablkcipher_encrypt(req) :
838 crypto_ablkcipher_decrypt(req); 838 crypto_ablkcipher_decrypt(req);
839 839
840 switch (ret) { 840 switch (ret) {
841 case 0: 841 case 0:
842 break; 842 break;
843 case -EINPROGRESS: 843 case -EINPROGRESS:
844 case -EBUSY: 844 case -EBUSY:
845 ret = wait_for_completion_interruptible( 845 ret = wait_for_completion_interruptible(
846 &result.completion); 846 &result.completion);
847 if (!ret && !((ret = result.err))) { 847 if (!ret && !((ret = result.err))) {
848 INIT_COMPLETION(result.completion); 848 INIT_COMPLETION(result.completion);
849 break; 849 break;
850 } 850 }
851 /* fall through */ 851 /* fall through */
852 default: 852 default:
853 printk(KERN_ERR "alg: skcipher: %s failed on " 853 printk(KERN_ERR "alg: skcipher: %s failed on "
854 "test %d for %s: ret=%d\n", e, j, algo, 854 "test %d for %s: ret=%d\n", e, j, algo,
855 -ret); 855 -ret);
856 goto out; 856 goto out;
857 } 857 }
858 858
859 q = data; 859 q = data;
860 if (memcmp(q, template[i].result, template[i].rlen)) { 860 if (memcmp(q, template[i].result, template[i].rlen)) {
861 printk(KERN_ERR "alg: skcipher: Test %d " 861 printk(KERN_ERR "alg: skcipher: Test %d "
862 "failed on %s for %s\n", j, e, algo); 862 "failed on %s for %s\n", j, e, algo);
863 hexdump(q, template[i].rlen); 863 hexdump(q, template[i].rlen);
864 ret = -EINVAL; 864 ret = -EINVAL;
865 goto out; 865 goto out;
866 } 866 }
867 } 867 }
868 } 868 }
869 869
870 j = 0; 870 j = 0;
871 for (i = 0; i < tcount; i++) { 871 for (i = 0; i < tcount; i++) {
872 872
873 if (template[i].iv) 873 if (template[i].iv)
874 memcpy(iv, template[i].iv, MAX_IVLEN); 874 memcpy(iv, template[i].iv, MAX_IVLEN);
875 else 875 else
876 memset(iv, 0, MAX_IVLEN); 876 memset(iv, 0, MAX_IVLEN);
877 877
878 if (template[i].np) { 878 if (template[i].np) {
879 j++; 879 j++;
880 880
881 crypto_ablkcipher_clear_flags(tfm, ~0); 881 crypto_ablkcipher_clear_flags(tfm, ~0);
882 if (template[i].wk) 882 if (template[i].wk)
883 crypto_ablkcipher_set_flags( 883 crypto_ablkcipher_set_flags(
884 tfm, CRYPTO_TFM_REQ_WEAK_KEY); 884 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
885 885
886 ret = crypto_ablkcipher_setkey(tfm, template[i].key, 886 ret = crypto_ablkcipher_setkey(tfm, template[i].key,
887 template[i].klen); 887 template[i].klen);
888 if (!ret == template[i].fail) { 888 if (!ret == template[i].fail) {
889 printk(KERN_ERR "alg: skcipher: setkey failed " 889 printk(KERN_ERR "alg: skcipher: setkey failed "
890 "on chunk test %d for %s: flags=%x\n", 890 "on chunk test %d for %s: flags=%x\n",
891 j, algo, 891 j, algo,
892 crypto_ablkcipher_get_flags(tfm)); 892 crypto_ablkcipher_get_flags(tfm));
893 goto out; 893 goto out;
894 } else if (ret) 894 } else if (ret)
895 continue; 895 continue;
896 896
897 temp = 0; 897 temp = 0;
898 ret = -EINVAL; 898 ret = -EINVAL;
899 sg_init_table(sg, template[i].np); 899 sg_init_table(sg, template[i].np);
900 for (k = 0; k < template[i].np; k++) { 900 for (k = 0; k < template[i].np; k++) {
901 if (WARN_ON(offset_in_page(IDX[k]) + 901 if (WARN_ON(offset_in_page(IDX[k]) +
902 template[i].tap[k] > PAGE_SIZE)) 902 template[i].tap[k] > PAGE_SIZE))
903 goto out; 903 goto out;
904 904
905 q = xbuf[IDX[k] >> PAGE_SHIFT] + 905 q = xbuf[IDX[k] >> PAGE_SHIFT] +
906 offset_in_page(IDX[k]); 906 offset_in_page(IDX[k]);
907 907
908 memcpy(q, template[i].input + temp, 908 memcpy(q, template[i].input + temp,
909 template[i].tap[k]); 909 template[i].tap[k]);
910 910
911 if (offset_in_page(q) + template[i].tap[k] < 911 if (offset_in_page(q) + template[i].tap[k] <
912 PAGE_SIZE) 912 PAGE_SIZE)
913 q[template[i].tap[k]] = 0; 913 q[template[i].tap[k]] = 0;
914 914
915 sg_set_buf(&sg[k], q, template[i].tap[k]); 915 sg_set_buf(&sg[k], q, template[i].tap[k]);
916 916
917 temp += template[i].tap[k]; 917 temp += template[i].tap[k];
918 } 918 }
919 919
920 ablkcipher_request_set_crypt(req, sg, sg, 920 ablkcipher_request_set_crypt(req, sg, sg,
921 template[i].ilen, iv); 921 template[i].ilen, iv);
922 922
923 ret = enc ? 923 ret = enc ?
924 crypto_ablkcipher_encrypt(req) : 924 crypto_ablkcipher_encrypt(req) :
925 crypto_ablkcipher_decrypt(req); 925 crypto_ablkcipher_decrypt(req);
926 926
927 switch (ret) { 927 switch (ret) {
928 case 0: 928 case 0:
929 break; 929 break;
930 case -EINPROGRESS: 930 case -EINPROGRESS:
931 case -EBUSY: 931 case -EBUSY:
932 ret = wait_for_completion_interruptible( 932 ret = wait_for_completion_interruptible(
933 &result.completion); 933 &result.completion);
934 if (!ret && !((ret = result.err))) { 934 if (!ret && !((ret = result.err))) {
935 INIT_COMPLETION(result.completion); 935 INIT_COMPLETION(result.completion);
936 break; 936 break;
937 } 937 }
938 /* fall through */ 938 /* fall through */
939 default: 939 default:
940 printk(KERN_ERR "alg: skcipher: %s failed on " 940 printk(KERN_ERR "alg: skcipher: %s failed on "
941 "chunk test %d for %s: ret=%d\n", e, j, 941 "chunk test %d for %s: ret=%d\n", e, j,
942 algo, -ret); 942 algo, -ret);
943 goto out; 943 goto out;
944 } 944 }
945 945
946 temp = 0; 946 temp = 0;
947 ret = -EINVAL; 947 ret = -EINVAL;
948 for (k = 0; k < template[i].np; k++) { 948 for (k = 0; k < template[i].np; k++) {
949 q = xbuf[IDX[k] >> PAGE_SHIFT] + 949 q = xbuf[IDX[k] >> PAGE_SHIFT] +
950 offset_in_page(IDX[k]); 950 offset_in_page(IDX[k]);
951 951
952 if (memcmp(q, template[i].result + temp, 952 if (memcmp(q, template[i].result + temp,
953 template[i].tap[k])) { 953 template[i].tap[k])) {
954 printk(KERN_ERR "alg: skcipher: Chunk " 954 printk(KERN_ERR "alg: skcipher: Chunk "
955 "test %d failed on %s at page " 955 "test %d failed on %s at page "
956 "%u for %s\n", j, e, k, algo); 956 "%u for %s\n", j, e, k, algo);
957 hexdump(q, template[i].tap[k]); 957 hexdump(q, template[i].tap[k]);
958 goto out; 958 goto out;
959 } 959 }
960 960
961 q += template[i].tap[k]; 961 q += template[i].tap[k];
962 for (n = 0; offset_in_page(q + n) && q[n]; n++) 962 for (n = 0; offset_in_page(q + n) && q[n]; n++)
963 ; 963 ;
964 if (n) { 964 if (n) {
965 printk(KERN_ERR "alg: skcipher: " 965 printk(KERN_ERR "alg: skcipher: "
966 "Result buffer corruption in " 966 "Result buffer corruption in "
967 "chunk test %d on %s at page " 967 "chunk test %d on %s at page "
968 "%u for %s: %u bytes:\n", j, e, 968 "%u for %s: %u bytes:\n", j, e,
969 k, algo, n); 969 k, algo, n);
970 hexdump(q, n); 970 hexdump(q, n);
971 goto out; 971 goto out;
972 } 972 }
973 temp += template[i].tap[k]; 973 temp += template[i].tap[k];
974 } 974 }
975 } 975 }
976 } 976 }
977 977
978 ret = 0; 978 ret = 0;
979 979
980 out: 980 out:
981 ablkcipher_request_free(req); 981 ablkcipher_request_free(req);
982 testmgr_free_buf(xbuf); 982 testmgr_free_buf(xbuf);
983 out_nobuf: 983 out_nobuf:
984 return ret; 984 return ret;
985 } 985 }
986 986
987 static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate, 987 static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate,
988 struct comp_testvec *dtemplate, int ctcount, int dtcount) 988 struct comp_testvec *dtemplate, int ctcount, int dtcount)
989 { 989 {
990 const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm)); 990 const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
991 unsigned int i; 991 unsigned int i;
992 char result[COMP_BUF_SIZE]; 992 char result[COMP_BUF_SIZE];
993 int ret; 993 int ret;
994 994
995 for (i = 0; i < ctcount; i++) { 995 for (i = 0; i < ctcount; i++) {
996 int ilen; 996 int ilen;
997 unsigned int dlen = COMP_BUF_SIZE; 997 unsigned int dlen = COMP_BUF_SIZE;
998 998
999 memset(result, 0, sizeof (result)); 999 memset(result, 0, sizeof (result));
1000 1000
1001 ilen = ctemplate[i].inlen; 1001 ilen = ctemplate[i].inlen;
1002 ret = crypto_comp_compress(tfm, ctemplate[i].input, 1002 ret = crypto_comp_compress(tfm, ctemplate[i].input,
1003 ilen, result, &dlen); 1003 ilen, result, &dlen);
1004 if (ret) { 1004 if (ret) {
1005 printk(KERN_ERR "alg: comp: compression failed " 1005 printk(KERN_ERR "alg: comp: compression failed "
1006 "on test %d for %s: ret=%d\n", i + 1, algo, 1006 "on test %d for %s: ret=%d\n", i + 1, algo,
1007 -ret); 1007 -ret);
1008 goto out; 1008 goto out;
1009 } 1009 }
1010 1010
1011 if (dlen != ctemplate[i].outlen) { 1011 if (dlen != ctemplate[i].outlen) {
1012 printk(KERN_ERR "alg: comp: Compression test %d " 1012 printk(KERN_ERR "alg: comp: Compression test %d "
1013 "failed for %s: output len = %d\n", i + 1, algo, 1013 "failed for %s: output len = %d\n", i + 1, algo,
1014 dlen); 1014 dlen);
1015 ret = -EINVAL; 1015 ret = -EINVAL;
1016 goto out; 1016 goto out;
1017 } 1017 }
1018 1018
1019 if (memcmp(result, ctemplate[i].output, dlen)) { 1019 if (memcmp(result, ctemplate[i].output, dlen)) {
1020 printk(KERN_ERR "alg: comp: Compression test %d " 1020 printk(KERN_ERR "alg: comp: Compression test %d "
1021 "failed for %s\n", i + 1, algo); 1021 "failed for %s\n", i + 1, algo);
1022 hexdump(result, dlen); 1022 hexdump(result, dlen);
1023 ret = -EINVAL; 1023 ret = -EINVAL;
1024 goto out; 1024 goto out;
1025 } 1025 }
1026 } 1026 }
1027 1027
1028 for (i = 0; i < dtcount; i++) { 1028 for (i = 0; i < dtcount; i++) {
1029 int ilen; 1029 int ilen;
1030 unsigned int dlen = COMP_BUF_SIZE; 1030 unsigned int dlen = COMP_BUF_SIZE;
1031 1031
1032 memset(result, 0, sizeof (result)); 1032 memset(result, 0, sizeof (result));
1033 1033
1034 ilen = dtemplate[i].inlen; 1034 ilen = dtemplate[i].inlen;
1035 ret = crypto_comp_decompress(tfm, dtemplate[i].input, 1035 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
1036 ilen, result, &dlen); 1036 ilen, result, &dlen);
1037 if (ret) { 1037 if (ret) {
1038 printk(KERN_ERR "alg: comp: decompression failed " 1038 printk(KERN_ERR "alg: comp: decompression failed "
1039 "on test %d for %s: ret=%d\n", i + 1, algo, 1039 "on test %d for %s: ret=%d\n", i + 1, algo,
1040 -ret); 1040 -ret);
1041 goto out; 1041 goto out;
1042 } 1042 }
1043 1043
1044 if (dlen != dtemplate[i].outlen) { 1044 if (dlen != dtemplate[i].outlen) {
1045 printk(KERN_ERR "alg: comp: Decompression test %d " 1045 printk(KERN_ERR "alg: comp: Decompression test %d "
1046 "failed for %s: output len = %d\n", i + 1, algo, 1046 "failed for %s: output len = %d\n", i + 1, algo,
1047 dlen); 1047 dlen);
1048 ret = -EINVAL; 1048 ret = -EINVAL;
1049 goto out; 1049 goto out;
1050 } 1050 }
1051 1051
1052 if (memcmp(result, dtemplate[i].output, dlen)) { 1052 if (memcmp(result, dtemplate[i].output, dlen)) {
1053 printk(KERN_ERR "alg: comp: Decompression test %d " 1053 printk(KERN_ERR "alg: comp: Decompression test %d "
1054 "failed for %s\n", i + 1, algo); 1054 "failed for %s\n", i + 1, algo);
1055 hexdump(result, dlen); 1055 hexdump(result, dlen);
1056 ret = -EINVAL; 1056 ret = -EINVAL;
1057 goto out; 1057 goto out;
1058 } 1058 }
1059 } 1059 }
1060 1060
1061 ret = 0; 1061 ret = 0;
1062 1062
1063 out: 1063 out:
1064 return ret; 1064 return ret;
1065 } 1065 }
1066 1066
1067 static int test_pcomp(struct crypto_pcomp *tfm, 1067 static int test_pcomp(struct crypto_pcomp *tfm,
1068 struct pcomp_testvec *ctemplate, 1068 struct pcomp_testvec *ctemplate,
1069 struct pcomp_testvec *dtemplate, int ctcount, 1069 struct pcomp_testvec *dtemplate, int ctcount,
1070 int dtcount) 1070 int dtcount)
1071 { 1071 {
1072 const char *algo = crypto_tfm_alg_driver_name(crypto_pcomp_tfm(tfm)); 1072 const char *algo = crypto_tfm_alg_driver_name(crypto_pcomp_tfm(tfm));
1073 unsigned int i; 1073 unsigned int i;
1074 char result[COMP_BUF_SIZE]; 1074 char result[COMP_BUF_SIZE];
1075 int res; 1075 int res;
1076 1076
1077 for (i = 0; i < ctcount; i++) { 1077 for (i = 0; i < ctcount; i++) {
1078 struct comp_request req; 1078 struct comp_request req;
1079 unsigned int produced = 0; 1079 unsigned int produced = 0;
1080 1080
1081 res = crypto_compress_setup(tfm, ctemplate[i].params, 1081 res = crypto_compress_setup(tfm, ctemplate[i].params,
1082 ctemplate[i].paramsize); 1082 ctemplate[i].paramsize);
1083 if (res) { 1083 if (res) {
1084 pr_err("alg: pcomp: compression setup failed on test " 1084 pr_err("alg: pcomp: compression setup failed on test "
1085 "%d for %s: error=%d\n", i + 1, algo, res); 1085 "%d for %s: error=%d\n", i + 1, algo, res);
1086 return res; 1086 return res;
1087 } 1087 }
1088 1088
1089 res = crypto_compress_init(tfm); 1089 res = crypto_compress_init(tfm);
1090 if (res) { 1090 if (res) {
1091 pr_err("alg: pcomp: compression init failed on test " 1091 pr_err("alg: pcomp: compression init failed on test "
1092 "%d for %s: error=%d\n", i + 1, algo, res); 1092 "%d for %s: error=%d\n", i + 1, algo, res);
1093 return res; 1093 return res;
1094 } 1094 }
1095 1095
1096 memset(result, 0, sizeof(result)); 1096 memset(result, 0, sizeof(result));
1097 1097
1098 req.next_in = ctemplate[i].input; 1098 req.next_in = ctemplate[i].input;
1099 req.avail_in = ctemplate[i].inlen / 2; 1099 req.avail_in = ctemplate[i].inlen / 2;
1100 req.next_out = result; 1100 req.next_out = result;
1101 req.avail_out = ctemplate[i].outlen / 2; 1101 req.avail_out = ctemplate[i].outlen / 2;
1102 1102
1103 res = crypto_compress_update(tfm, &req); 1103 res = crypto_compress_update(tfm, &req);
1104 if (res < 0 && (res != -EAGAIN || req.avail_in)) { 1104 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1105 pr_err("alg: pcomp: compression update failed on test " 1105 pr_err("alg: pcomp: compression update failed on test "
1106 "%d for %s: error=%d\n", i + 1, algo, res); 1106 "%d for %s: error=%d\n", i + 1, algo, res);
1107 return res; 1107 return res;
1108 } 1108 }
1109 if (res > 0) 1109 if (res > 0)
1110 produced += res; 1110 produced += res;
1111 1111
1112 /* Add remaining input data */ 1112 /* Add remaining input data */
1113 req.avail_in += (ctemplate[i].inlen + 1) / 2; 1113 req.avail_in += (ctemplate[i].inlen + 1) / 2;
1114 1114
1115 res = crypto_compress_update(tfm, &req); 1115 res = crypto_compress_update(tfm, &req);
1116 if (res < 0 && (res != -EAGAIN || req.avail_in)) { 1116 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1117 pr_err("alg: pcomp: compression update failed on test " 1117 pr_err("alg: pcomp: compression update failed on test "
1118 "%d for %s: error=%d\n", i + 1, algo, res); 1118 "%d for %s: error=%d\n", i + 1, algo, res);
1119 return res; 1119 return res;
1120 } 1120 }
1121 if (res > 0) 1121 if (res > 0)
1122 produced += res; 1122 produced += res;
1123 1123
1124 /* Provide remaining output space */ 1124 /* Provide remaining output space */
1125 req.avail_out += COMP_BUF_SIZE - ctemplate[i].outlen / 2; 1125 req.avail_out += COMP_BUF_SIZE - ctemplate[i].outlen / 2;
1126 1126
1127 res = crypto_compress_final(tfm, &req); 1127 res = crypto_compress_final(tfm, &req);
1128 if (res < 0) { 1128 if (res < 0) {
1129 pr_err("alg: pcomp: compression final failed on test " 1129 pr_err("alg: pcomp: compression final failed on test "
1130 "%d for %s: error=%d\n", i + 1, algo, res); 1130 "%d for %s: error=%d\n", i + 1, algo, res);
1131 return res; 1131 return res;
1132 } 1132 }
1133 produced += res; 1133 produced += res;
1134 1134
1135 if (COMP_BUF_SIZE - req.avail_out != ctemplate[i].outlen) { 1135 if (COMP_BUF_SIZE - req.avail_out != ctemplate[i].outlen) {
1136 pr_err("alg: comp: Compression test %d failed for %s: " 1136 pr_err("alg: comp: Compression test %d failed for %s: "
1137 "output len = %d (expected %d)\n", i + 1, algo, 1137 "output len = %d (expected %d)\n", i + 1, algo,
1138 COMP_BUF_SIZE - req.avail_out, 1138 COMP_BUF_SIZE - req.avail_out,
1139 ctemplate[i].outlen); 1139 ctemplate[i].outlen);
1140 return -EINVAL; 1140 return -EINVAL;
1141 } 1141 }
1142 1142
1143 if (produced != ctemplate[i].outlen) { 1143 if (produced != ctemplate[i].outlen) {
1144 pr_err("alg: comp: Compression test %d failed for %s: " 1144 pr_err("alg: comp: Compression test %d failed for %s: "
1145 "returned len = %u (expected %d)\n", i + 1, 1145 "returned len = %u (expected %d)\n", i + 1,
1146 algo, produced, ctemplate[i].outlen); 1146 algo, produced, ctemplate[i].outlen);
1147 return -EINVAL; 1147 return -EINVAL;
1148 } 1148 }
1149 1149
1150 if (memcmp(result, ctemplate[i].output, ctemplate[i].outlen)) { 1150 if (memcmp(result, ctemplate[i].output, ctemplate[i].outlen)) {
1151 pr_err("alg: pcomp: Compression test %d failed for " 1151 pr_err("alg: pcomp: Compression test %d failed for "
1152 "%s\n", i + 1, algo); 1152 "%s\n", i + 1, algo);
1153 hexdump(result, ctemplate[i].outlen); 1153 hexdump(result, ctemplate[i].outlen);
1154 return -EINVAL; 1154 return -EINVAL;
1155 } 1155 }
1156 } 1156 }
1157 1157
1158 for (i = 0; i < dtcount; i++) { 1158 for (i = 0; i < dtcount; i++) {
1159 struct comp_request req; 1159 struct comp_request req;
1160 unsigned int produced = 0; 1160 unsigned int produced = 0;
1161 1161
1162 res = crypto_decompress_setup(tfm, dtemplate[i].params, 1162 res = crypto_decompress_setup(tfm, dtemplate[i].params,
1163 dtemplate[i].paramsize); 1163 dtemplate[i].paramsize);
1164 if (res) { 1164 if (res) {
1165 pr_err("alg: pcomp: decompression setup failed on " 1165 pr_err("alg: pcomp: decompression setup failed on "
1166 "test %d for %s: error=%d\n", i + 1, algo, res); 1166 "test %d for %s: error=%d\n", i + 1, algo, res);
1167 return res; 1167 return res;
1168 } 1168 }
1169 1169
1170 res = crypto_decompress_init(tfm); 1170 res = crypto_decompress_init(tfm);
1171 if (res) { 1171 if (res) {
1172 pr_err("alg: pcomp: decompression init failed on test " 1172 pr_err("alg: pcomp: decompression init failed on test "
1173 "%d for %s: error=%d\n", i + 1, algo, res); 1173 "%d for %s: error=%d\n", i + 1, algo, res);
1174 return res; 1174 return res;
1175 } 1175 }
1176 1176
1177 memset(result, 0, sizeof(result)); 1177 memset(result, 0, sizeof(result));
1178 1178
1179 req.next_in = dtemplate[i].input; 1179 req.next_in = dtemplate[i].input;
1180 req.avail_in = dtemplate[i].inlen / 2; 1180 req.avail_in = dtemplate[i].inlen / 2;
1181 req.next_out = result; 1181 req.next_out = result;
1182 req.avail_out = dtemplate[i].outlen / 2; 1182 req.avail_out = dtemplate[i].outlen / 2;
1183 1183
1184 res = crypto_decompress_update(tfm, &req); 1184 res = crypto_decompress_update(tfm, &req);
1185 if (res < 0 && (res != -EAGAIN || req.avail_in)) { 1185 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1186 pr_err("alg: pcomp: decompression update failed on " 1186 pr_err("alg: pcomp: decompression update failed on "
1187 "test %d for %s: error=%d\n", i + 1, algo, res); 1187 "test %d for %s: error=%d\n", i + 1, algo, res);
1188 return res; 1188 return res;
1189 } 1189 }
1190 if (res > 0) 1190 if (res > 0)
1191 produced += res; 1191 produced += res;
1192 1192
1193 /* Add remaining input data */ 1193 /* Add remaining input data */
1194 req.avail_in += (dtemplate[i].inlen + 1) / 2; 1194 req.avail_in += (dtemplate[i].inlen + 1) / 2;
1195 1195
1196 res = crypto_decompress_update(tfm, &req); 1196 res = crypto_decompress_update(tfm, &req);
1197 if (res < 0 && (res != -EAGAIN || req.avail_in)) { 1197 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1198 pr_err("alg: pcomp: decompression update failed on " 1198 pr_err("alg: pcomp: decompression update failed on "
1199 "test %d for %s: error=%d\n", i + 1, algo, res); 1199 "test %d for %s: error=%d\n", i + 1, algo, res);
1200 return res; 1200 return res;
1201 } 1201 }
1202 if (res > 0) 1202 if (res > 0)
1203 produced += res; 1203 produced += res;
1204 1204
1205 /* Provide remaining output space */ 1205 /* Provide remaining output space */
1206 req.avail_out += COMP_BUF_SIZE - dtemplate[i].outlen / 2; 1206 req.avail_out += COMP_BUF_SIZE - dtemplate[i].outlen / 2;
1207 1207
1208 res = crypto_decompress_final(tfm, &req); 1208 res = crypto_decompress_final(tfm, &req);
1209 if (res < 0 && (res != -EAGAIN || req.avail_in)) { 1209 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1210 pr_err("alg: pcomp: decompression final failed on " 1210 pr_err("alg: pcomp: decompression final failed on "
1211 "test %d for %s: error=%d\n", i + 1, algo, res); 1211 "test %d for %s: error=%d\n", i + 1, algo, res);
1212 return res; 1212 return res;
1213 } 1213 }
1214 if (res > 0) 1214 if (res > 0)
1215 produced += res; 1215 produced += res;
1216 1216
1217 if (COMP_BUF_SIZE - req.avail_out != dtemplate[i].outlen) { 1217 if (COMP_BUF_SIZE - req.avail_out != dtemplate[i].outlen) {
1218 pr_err("alg: comp: Decompression test %d failed for " 1218 pr_err("alg: comp: Decompression test %d failed for "
1219 "%s: output len = %d (expected %d)\n", i + 1, 1219 "%s: output len = %d (expected %d)\n", i + 1,
1220 algo, COMP_BUF_SIZE - req.avail_out, 1220 algo, COMP_BUF_SIZE - req.avail_out,
1221 dtemplate[i].outlen); 1221 dtemplate[i].outlen);
1222 return -EINVAL; 1222 return -EINVAL;
1223 } 1223 }
1224 1224
1225 if (produced != dtemplate[i].outlen) { 1225 if (produced != dtemplate[i].outlen) {
1226 pr_err("alg: comp: Decompression test %d failed for " 1226 pr_err("alg: comp: Decompression test %d failed for "
1227 "%s: returned len = %u (expected %d)\n", i + 1, 1227 "%s: returned len = %u (expected %d)\n", i + 1,
1228 algo, produced, dtemplate[i].outlen); 1228 algo, produced, dtemplate[i].outlen);
1229 return -EINVAL; 1229 return -EINVAL;
1230 } 1230 }
1231 1231
1232 if (memcmp(result, dtemplate[i].output, dtemplate[i].outlen)) { 1232 if (memcmp(result, dtemplate[i].output, dtemplate[i].outlen)) {
1233 pr_err("alg: pcomp: Decompression test %d failed for " 1233 pr_err("alg: pcomp: Decompression test %d failed for "
1234 "%s\n", i + 1, algo); 1234 "%s\n", i + 1, algo);
1235 hexdump(result, dtemplate[i].outlen); 1235 hexdump(result, dtemplate[i].outlen);
1236 return -EINVAL; 1236 return -EINVAL;
1237 } 1237 }
1238 } 1238 }
1239 1239
1240 return 0; 1240 return 0;
1241 } 1241 }
1242 1242
1243 1243
1244 static int test_cprng(struct crypto_rng *tfm, struct cprng_testvec *template, 1244 static int test_cprng(struct crypto_rng *tfm, struct cprng_testvec *template,
1245 unsigned int tcount) 1245 unsigned int tcount)
1246 { 1246 {
1247 const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm)); 1247 const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
1248 int err = 0, i, j, seedsize; 1248 int err = 0, i, j, seedsize;
1249 u8 *seed; 1249 u8 *seed;
1250 char result[32]; 1250 char result[32];
1251 1251
1252 seedsize = crypto_rng_seedsize(tfm); 1252 seedsize = crypto_rng_seedsize(tfm);
1253 1253
1254 seed = kmalloc(seedsize, GFP_KERNEL); 1254 seed = kmalloc(seedsize, GFP_KERNEL);
1255 if (!seed) { 1255 if (!seed) {
1256 printk(KERN_ERR "alg: cprng: Failed to allocate seed space " 1256 printk(KERN_ERR "alg: cprng: Failed to allocate seed space "
1257 "for %s\n", algo); 1257 "for %s\n", algo);
1258 return -ENOMEM; 1258 return -ENOMEM;
1259 } 1259 }
1260 1260
1261 for (i = 0; i < tcount; i++) { 1261 for (i = 0; i < tcount; i++) {
1262 memset(result, 0, 32); 1262 memset(result, 0, 32);
1263 1263
1264 memcpy(seed, template[i].v, template[i].vlen); 1264 memcpy(seed, template[i].v, template[i].vlen);
1265 memcpy(seed + template[i].vlen, template[i].key, 1265 memcpy(seed + template[i].vlen, template[i].key,
1266 template[i].klen); 1266 template[i].klen);
1267 memcpy(seed + template[i].vlen + template[i].klen, 1267 memcpy(seed + template[i].vlen + template[i].klen,
1268 template[i].dt, template[i].dtlen); 1268 template[i].dt, template[i].dtlen);
1269 1269
1270 err = crypto_rng_reset(tfm, seed, seedsize); 1270 err = crypto_rng_reset(tfm, seed, seedsize);
1271 if (err) { 1271 if (err) {
1272 printk(KERN_ERR "alg: cprng: Failed to reset rng " 1272 printk(KERN_ERR "alg: cprng: Failed to reset rng "
1273 "for %s\n", algo); 1273 "for %s\n", algo);
1274 goto out; 1274 goto out;
1275 } 1275 }
1276 1276
1277 for (j = 0; j < template[i].loops; j++) { 1277 for (j = 0; j < template[i].loops; j++) {
1278 err = crypto_rng_get_bytes(tfm, result, 1278 err = crypto_rng_get_bytes(tfm, result,
1279 template[i].rlen); 1279 template[i].rlen);
1280 if (err != template[i].rlen) { 1280 if (err != template[i].rlen) {
1281 printk(KERN_ERR "alg: cprng: Failed to obtain " 1281 printk(KERN_ERR "alg: cprng: Failed to obtain "
1282 "the correct amount of random data for " 1282 "the correct amount of random data for "
1283 "%s (requested %d, got %d)\n", algo, 1283 "%s (requested %d, got %d)\n", algo,
1284 template[i].rlen, err); 1284 template[i].rlen, err);
1285 goto out; 1285 goto out;
1286 } 1286 }
1287 } 1287 }
1288 1288
1289 err = memcmp(result, template[i].result, 1289 err = memcmp(result, template[i].result,
1290 template[i].rlen); 1290 template[i].rlen);
1291 if (err) { 1291 if (err) {
1292 printk(KERN_ERR "alg: cprng: Test %d failed for %s\n", 1292 printk(KERN_ERR "alg: cprng: Test %d failed for %s\n",
1293 i, algo); 1293 i, algo);
1294 hexdump(result, template[i].rlen); 1294 hexdump(result, template[i].rlen);
1295 err = -EINVAL; 1295 err = -EINVAL;
1296 goto out; 1296 goto out;
1297 } 1297 }
1298 } 1298 }
1299 1299
1300 out: 1300 out:
1301 kfree(seed); 1301 kfree(seed);
1302 return err; 1302 return err;
1303 } 1303 }
1304 1304
1305 static int alg_test_aead(const struct alg_test_desc *desc, const char *driver, 1305 static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
1306 u32 type, u32 mask) 1306 u32 type, u32 mask)
1307 { 1307 {
1308 struct crypto_aead *tfm; 1308 struct crypto_aead *tfm;
1309 int err = 0; 1309 int err = 0;
1310 1310
1311 tfm = crypto_alloc_aead(driver, type, mask); 1311 tfm = crypto_alloc_aead(driver, type, mask);
1312 if (IS_ERR(tfm)) { 1312 if (IS_ERR(tfm)) {
1313 printk(KERN_ERR "alg: aead: Failed to load transform for %s: " 1313 printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
1314 "%ld\n", driver, PTR_ERR(tfm)); 1314 "%ld\n", driver, PTR_ERR(tfm));
1315 return PTR_ERR(tfm); 1315 return PTR_ERR(tfm);
1316 } 1316 }
1317 1317
1318 if (desc->suite.aead.enc.vecs) { 1318 if (desc->suite.aead.enc.vecs) {
1319 err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs, 1319 err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs,
1320 desc->suite.aead.enc.count); 1320 desc->suite.aead.enc.count);
1321 if (err) 1321 if (err)
1322 goto out; 1322 goto out;
1323 } 1323 }
1324 1324
1325 if (!err && desc->suite.aead.dec.vecs) 1325 if (!err && desc->suite.aead.dec.vecs)
1326 err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs, 1326 err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs,
1327 desc->suite.aead.dec.count); 1327 desc->suite.aead.dec.count);
1328 1328
1329 out: 1329 out:
1330 crypto_free_aead(tfm); 1330 crypto_free_aead(tfm);
1331 return err; 1331 return err;
1332 } 1332 }
1333 1333
1334 static int alg_test_cipher(const struct alg_test_desc *desc, 1334 static int alg_test_cipher(const struct alg_test_desc *desc,
1335 const char *driver, u32 type, u32 mask) 1335 const char *driver, u32 type, u32 mask)
1336 { 1336 {
1337 struct crypto_cipher *tfm; 1337 struct crypto_cipher *tfm;
1338 int err = 0; 1338 int err = 0;
1339 1339
1340 tfm = crypto_alloc_cipher(driver, type, mask); 1340 tfm = crypto_alloc_cipher(driver, type, mask);
1341 if (IS_ERR(tfm)) { 1341 if (IS_ERR(tfm)) {
1342 printk(KERN_ERR "alg: cipher: Failed to load transform for " 1342 printk(KERN_ERR "alg: cipher: Failed to load transform for "
1343 "%s: %ld\n", driver, PTR_ERR(tfm)); 1343 "%s: %ld\n", driver, PTR_ERR(tfm));
1344 return PTR_ERR(tfm); 1344 return PTR_ERR(tfm);
1345 } 1345 }
1346 1346
1347 if (desc->suite.cipher.enc.vecs) { 1347 if (desc->suite.cipher.enc.vecs) {
1348 err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs, 1348 err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1349 desc->suite.cipher.enc.count); 1349 desc->suite.cipher.enc.count);
1350 if (err) 1350 if (err)
1351 goto out; 1351 goto out;
1352 } 1352 }
1353 1353
1354 if (desc->suite.cipher.dec.vecs) 1354 if (desc->suite.cipher.dec.vecs)
1355 err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs, 1355 err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1356 desc->suite.cipher.dec.count); 1356 desc->suite.cipher.dec.count);
1357 1357
1358 out: 1358 out:
1359 crypto_free_cipher(tfm); 1359 crypto_free_cipher(tfm);
1360 return err; 1360 return err;
1361 } 1361 }
1362 1362
1363 static int alg_test_skcipher(const struct alg_test_desc *desc, 1363 static int alg_test_skcipher(const struct alg_test_desc *desc,
1364 const char *driver, u32 type, u32 mask) 1364 const char *driver, u32 type, u32 mask)
1365 { 1365 {
1366 struct crypto_ablkcipher *tfm; 1366 struct crypto_ablkcipher *tfm;
1367 int err = 0; 1367 int err = 0;
1368 1368
1369 tfm = crypto_alloc_ablkcipher(driver, type, mask); 1369 tfm = crypto_alloc_ablkcipher(driver, type, mask);
1370 if (IS_ERR(tfm)) { 1370 if (IS_ERR(tfm)) {
1371 printk(KERN_ERR "alg: skcipher: Failed to load transform for " 1371 printk(KERN_ERR "alg: skcipher: Failed to load transform for "
1372 "%s: %ld\n", driver, PTR_ERR(tfm)); 1372 "%s: %ld\n", driver, PTR_ERR(tfm));
1373 return PTR_ERR(tfm); 1373 return PTR_ERR(tfm);
1374 } 1374 }
1375 1375
1376 if (desc->suite.cipher.enc.vecs) { 1376 if (desc->suite.cipher.enc.vecs) {
1377 err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs, 1377 err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1378 desc->suite.cipher.enc.count); 1378 desc->suite.cipher.enc.count);
1379 if (err) 1379 if (err)
1380 goto out; 1380 goto out;
1381 } 1381 }
1382 1382
1383 if (desc->suite.cipher.dec.vecs) 1383 if (desc->suite.cipher.dec.vecs)
1384 err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs, 1384 err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1385 desc->suite.cipher.dec.count); 1385 desc->suite.cipher.dec.count);
1386 1386
1387 out: 1387 out:
1388 crypto_free_ablkcipher(tfm); 1388 crypto_free_ablkcipher(tfm);
1389 return err; 1389 return err;
1390 } 1390 }
1391 1391
1392 static int alg_test_comp(const struct alg_test_desc *desc, const char *driver, 1392 static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
1393 u32 type, u32 mask) 1393 u32 type, u32 mask)
1394 { 1394 {
1395 struct crypto_comp *tfm; 1395 struct crypto_comp *tfm;
1396 int err; 1396 int err;
1397 1397
1398 tfm = crypto_alloc_comp(driver, type, mask); 1398 tfm = crypto_alloc_comp(driver, type, mask);
1399 if (IS_ERR(tfm)) { 1399 if (IS_ERR(tfm)) {
1400 printk(KERN_ERR "alg: comp: Failed to load transform for %s: " 1400 printk(KERN_ERR "alg: comp: Failed to load transform for %s: "
1401 "%ld\n", driver, PTR_ERR(tfm)); 1401 "%ld\n", driver, PTR_ERR(tfm));
1402 return PTR_ERR(tfm); 1402 return PTR_ERR(tfm);
1403 } 1403 }
1404 1404
1405 err = test_comp(tfm, desc->suite.comp.comp.vecs, 1405 err = test_comp(tfm, desc->suite.comp.comp.vecs,
1406 desc->suite.comp.decomp.vecs, 1406 desc->suite.comp.decomp.vecs,
1407 desc->suite.comp.comp.count, 1407 desc->suite.comp.comp.count,
1408 desc->suite.comp.decomp.count); 1408 desc->suite.comp.decomp.count);
1409 1409
1410 crypto_free_comp(tfm); 1410 crypto_free_comp(tfm);
1411 return err; 1411 return err;
1412 } 1412 }
1413 1413
1414 static int alg_test_pcomp(const struct alg_test_desc *desc, const char *driver, 1414 static int alg_test_pcomp(const struct alg_test_desc *desc, const char *driver,
1415 u32 type, u32 mask) 1415 u32 type, u32 mask)
1416 { 1416 {
1417 struct crypto_pcomp *tfm; 1417 struct crypto_pcomp *tfm;
1418 int err; 1418 int err;
1419 1419
1420 tfm = crypto_alloc_pcomp(driver, type, mask); 1420 tfm = crypto_alloc_pcomp(driver, type, mask);
1421 if (IS_ERR(tfm)) { 1421 if (IS_ERR(tfm)) {
1422 pr_err("alg: pcomp: Failed to load transform for %s: %ld\n", 1422 pr_err("alg: pcomp: Failed to load transform for %s: %ld\n",
1423 driver, PTR_ERR(tfm)); 1423 driver, PTR_ERR(tfm));
1424 return PTR_ERR(tfm); 1424 return PTR_ERR(tfm);
1425 } 1425 }
1426 1426
1427 err = test_pcomp(tfm, desc->suite.pcomp.comp.vecs, 1427 err = test_pcomp(tfm, desc->suite.pcomp.comp.vecs,
1428 desc->suite.pcomp.decomp.vecs, 1428 desc->suite.pcomp.decomp.vecs,
1429 desc->suite.pcomp.comp.count, 1429 desc->suite.pcomp.comp.count,
1430 desc->suite.pcomp.decomp.count); 1430 desc->suite.pcomp.decomp.count);
1431 1431
1432 crypto_free_pcomp(tfm); 1432 crypto_free_pcomp(tfm);
1433 return err; 1433 return err;
1434 } 1434 }
1435 1435
1436 static int alg_test_hash(const struct alg_test_desc *desc, const char *driver, 1436 static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
1437 u32 type, u32 mask) 1437 u32 type, u32 mask)
1438 { 1438 {
1439 struct crypto_ahash *tfm; 1439 struct crypto_ahash *tfm;
1440 int err; 1440 int err;
1441 1441
1442 tfm = crypto_alloc_ahash(driver, type, mask); 1442 tfm = crypto_alloc_ahash(driver, type, mask);
1443 if (IS_ERR(tfm)) { 1443 if (IS_ERR(tfm)) {
1444 printk(KERN_ERR "alg: hash: Failed to load transform for %s: " 1444 printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
1445 "%ld\n", driver, PTR_ERR(tfm)); 1445 "%ld\n", driver, PTR_ERR(tfm));
1446 return PTR_ERR(tfm); 1446 return PTR_ERR(tfm);
1447 } 1447 }
1448 1448
1449 err = test_hash(tfm, desc->suite.hash.vecs, 1449 err = test_hash(tfm, desc->suite.hash.vecs,
1450 desc->suite.hash.count, true); 1450 desc->suite.hash.count, true);
1451 if (!err) 1451 if (!err)
1452 err = test_hash(tfm, desc->suite.hash.vecs, 1452 err = test_hash(tfm, desc->suite.hash.vecs,
1453 desc->suite.hash.count, false); 1453 desc->suite.hash.count, false);
1454 1454
1455 crypto_free_ahash(tfm); 1455 crypto_free_ahash(tfm);
1456 return err; 1456 return err;
1457 } 1457 }
1458 1458
1459 static int alg_test_crc32c(const struct alg_test_desc *desc, 1459 static int alg_test_crc32c(const struct alg_test_desc *desc,
1460 const char *driver, u32 type, u32 mask) 1460 const char *driver, u32 type, u32 mask)
1461 { 1461 {
1462 struct crypto_shash *tfm; 1462 struct crypto_shash *tfm;
1463 u32 val; 1463 u32 val;
1464 int err; 1464 int err;
1465 1465
1466 err = alg_test_hash(desc, driver, type, mask); 1466 err = alg_test_hash(desc, driver, type, mask);
1467 if (err) 1467 if (err)
1468 goto out; 1468 goto out;
1469 1469
1470 tfm = crypto_alloc_shash(driver, type, mask); 1470 tfm = crypto_alloc_shash(driver, type, mask);
1471 if (IS_ERR(tfm)) { 1471 if (IS_ERR(tfm)) {
1472 printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: " 1472 printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: "
1473 "%ld\n", driver, PTR_ERR(tfm)); 1473 "%ld\n", driver, PTR_ERR(tfm));
1474 err = PTR_ERR(tfm); 1474 err = PTR_ERR(tfm);
1475 goto out; 1475 goto out;
1476 } 1476 }
1477 1477
1478 do { 1478 do {
1479 struct { 1479 struct {
1480 struct shash_desc shash; 1480 struct shash_desc shash;
1481 char ctx[crypto_shash_descsize(tfm)]; 1481 char ctx[crypto_shash_descsize(tfm)];
1482 } sdesc; 1482 } sdesc;
1483 1483
1484 sdesc.shash.tfm = tfm; 1484 sdesc.shash.tfm = tfm;
1485 sdesc.shash.flags = 0; 1485 sdesc.shash.flags = 0;
1486 1486
1487 *(u32 *)sdesc.ctx = le32_to_cpu(420553207); 1487 *(u32 *)sdesc.ctx = le32_to_cpu(420553207);
1488 err = crypto_shash_final(&sdesc.shash, (u8 *)&val); 1488 err = crypto_shash_final(&sdesc.shash, (u8 *)&val);
1489 if (err) { 1489 if (err) {
1490 printk(KERN_ERR "alg: crc32c: Operation failed for " 1490 printk(KERN_ERR "alg: crc32c: Operation failed for "
1491 "%s: %d\n", driver, err); 1491 "%s: %d\n", driver, err);
1492 break; 1492 break;
1493 } 1493 }
1494 1494
1495 if (val != ~420553207) { 1495 if (val != ~420553207) {
1496 printk(KERN_ERR "alg: crc32c: Test failed for %s: " 1496 printk(KERN_ERR "alg: crc32c: Test failed for %s: "
1497 "%d\n", driver, val); 1497 "%d\n", driver, val);
1498 err = -EINVAL; 1498 err = -EINVAL;
1499 } 1499 }
1500 } while (0); 1500 } while (0);
1501 1501
1502 crypto_free_shash(tfm); 1502 crypto_free_shash(tfm);
1503 1503
1504 out: 1504 out:
1505 return err; 1505 return err;
1506 } 1506 }
1507 1507
1508 static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver, 1508 static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
1509 u32 type, u32 mask) 1509 u32 type, u32 mask)
1510 { 1510 {
1511 struct crypto_rng *rng; 1511 struct crypto_rng *rng;
1512 int err; 1512 int err;
1513 1513
1514 rng = crypto_alloc_rng(driver, type, mask); 1514 rng = crypto_alloc_rng(driver, type, mask);
1515 if (IS_ERR(rng)) { 1515 if (IS_ERR(rng)) {
1516 printk(KERN_ERR "alg: cprng: Failed to load transform for %s: " 1516 printk(KERN_ERR "alg: cprng: Failed to load transform for %s: "
1517 "%ld\n", driver, PTR_ERR(rng)); 1517 "%ld\n", driver, PTR_ERR(rng));
1518 return PTR_ERR(rng); 1518 return PTR_ERR(rng);
1519 } 1519 }
1520 1520
1521 err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count); 1521 err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count);
1522 1522
1523 crypto_free_rng(rng); 1523 crypto_free_rng(rng);
1524 1524
1525 return err; 1525 return err;
1526 } 1526 }
1527 1527
1528 static int alg_test_null(const struct alg_test_desc *desc, 1528 static int alg_test_null(const struct alg_test_desc *desc,
1529 const char *driver, u32 type, u32 mask) 1529 const char *driver, u32 type, u32 mask)
1530 { 1530 {
1531 return 0; 1531 return 0;
1532 } 1532 }
1533 1533
1534 /* Please keep this list sorted by algorithm name. */ 1534 /* Please keep this list sorted by algorithm name. */
1535 static const struct alg_test_desc alg_test_descs[] = { 1535 static const struct alg_test_desc alg_test_descs[] = {
1536 { 1536 {
1537 .alg = "__driver-cbc-aes-aesni", 1537 .alg = "__driver-cbc-aes-aesni",
1538 .test = alg_test_null, 1538 .test = alg_test_null,
1539 .suite = { 1539 .suite = {
1540 .cipher = { 1540 .cipher = {
1541 .enc = { 1541 .enc = {
1542 .vecs = NULL, 1542 .vecs = NULL,
1543 .count = 0 1543 .count = 0
1544 }, 1544 },
1545 .dec = { 1545 .dec = {
1546 .vecs = NULL, 1546 .vecs = NULL,
1547 .count = 0 1547 .count = 0
1548 } 1548 }
1549 } 1549 }
1550 } 1550 }
1551 }, { 1551 }, {
1552 .alg = "__driver-ecb-aes-aesni", 1552 .alg = "__driver-ecb-aes-aesni",
1553 .test = alg_test_null, 1553 .test = alg_test_null,
1554 .suite = { 1554 .suite = {
1555 .cipher = { 1555 .cipher = {
1556 .enc = { 1556 .enc = {
1557 .vecs = NULL, 1557 .vecs = NULL,
1558 .count = 0 1558 .count = 0
1559 }, 1559 },
1560 .dec = { 1560 .dec = {
1561 .vecs = NULL, 1561 .vecs = NULL,
1562 .count = 0 1562 .count = 0
1563 } 1563 }
1564 } 1564 }
1565 } 1565 }
1566 }, { 1566 }, {
1567 .alg = "__ghash-pclmulqdqni", 1567 .alg = "__ghash-pclmulqdqni",
1568 .test = alg_test_null, 1568 .test = alg_test_null,
1569 .suite = { 1569 .suite = {
1570 .hash = { 1570 .hash = {
1571 .vecs = NULL, 1571 .vecs = NULL,
1572 .count = 0 1572 .count = 0
1573 } 1573 }
1574 } 1574 }
1575 }, { 1575 }, {
1576 .alg = "ansi_cprng", 1576 .alg = "ansi_cprng",
1577 .test = alg_test_cprng, 1577 .test = alg_test_cprng,
1578 .fips_allowed = 1, 1578 .fips_allowed = 1,
1579 .suite = { 1579 .suite = {
1580 .cprng = { 1580 .cprng = {
1581 .vecs = ansi_cprng_aes_tv_template, 1581 .vecs = ansi_cprng_aes_tv_template,
1582 .count = ANSI_CPRNG_AES_TEST_VECTORS 1582 .count = ANSI_CPRNG_AES_TEST_VECTORS
1583 } 1583 }
1584 } 1584 }
1585 }, { 1585 }, {
1586 .alg = "cbc(aes)", 1586 .alg = "cbc(aes)",
1587 .test = alg_test_skcipher, 1587 .test = alg_test_skcipher,
1588 .fips_allowed = 1, 1588 .fips_allowed = 1,
1589 .suite = { 1589 .suite = {
1590 .cipher = { 1590 .cipher = {
1591 .enc = { 1591 .enc = {
1592 .vecs = aes_cbc_enc_tv_template, 1592 .vecs = aes_cbc_enc_tv_template,
1593 .count = AES_CBC_ENC_TEST_VECTORS 1593 .count = AES_CBC_ENC_TEST_VECTORS
1594 }, 1594 },
1595 .dec = { 1595 .dec = {
1596 .vecs = aes_cbc_dec_tv_template, 1596 .vecs = aes_cbc_dec_tv_template,
1597 .count = AES_CBC_DEC_TEST_VECTORS 1597 .count = AES_CBC_DEC_TEST_VECTORS
1598 } 1598 }
1599 } 1599 }
1600 } 1600 }
1601 }, { 1601 }, {
1602 .alg = "cbc(anubis)", 1602 .alg = "cbc(anubis)",
1603 .test = alg_test_skcipher, 1603 .test = alg_test_skcipher,
1604 .suite = { 1604 .suite = {
1605 .cipher = { 1605 .cipher = {
1606 .enc = { 1606 .enc = {
1607 .vecs = anubis_cbc_enc_tv_template, 1607 .vecs = anubis_cbc_enc_tv_template,
1608 .count = ANUBIS_CBC_ENC_TEST_VECTORS 1608 .count = ANUBIS_CBC_ENC_TEST_VECTORS
1609 }, 1609 },
1610 .dec = { 1610 .dec = {
1611 .vecs = anubis_cbc_dec_tv_template, 1611 .vecs = anubis_cbc_dec_tv_template,
1612 .count = ANUBIS_CBC_DEC_TEST_VECTORS 1612 .count = ANUBIS_CBC_DEC_TEST_VECTORS
1613 } 1613 }
1614 } 1614 }
1615 } 1615 }
1616 }, { 1616 }, {
1617 .alg = "cbc(blowfish)", 1617 .alg = "cbc(blowfish)",
1618 .test = alg_test_skcipher, 1618 .test = alg_test_skcipher,
1619 .suite = { 1619 .suite = {
1620 .cipher = { 1620 .cipher = {
1621 .enc = { 1621 .enc = {
1622 .vecs = bf_cbc_enc_tv_template, 1622 .vecs = bf_cbc_enc_tv_template,
1623 .count = BF_CBC_ENC_TEST_VECTORS 1623 .count = BF_CBC_ENC_TEST_VECTORS
1624 }, 1624 },
1625 .dec = { 1625 .dec = {
1626 .vecs = bf_cbc_dec_tv_template, 1626 .vecs = bf_cbc_dec_tv_template,
1627 .count = BF_CBC_DEC_TEST_VECTORS 1627 .count = BF_CBC_DEC_TEST_VECTORS
1628 } 1628 }
1629 } 1629 }
1630 } 1630 }
1631 }, { 1631 }, {
1632 .alg = "cbc(camellia)", 1632 .alg = "cbc(camellia)",
1633 .test = alg_test_skcipher, 1633 .test = alg_test_skcipher,
1634 .suite = { 1634 .suite = {
1635 .cipher = { 1635 .cipher = {
1636 .enc = { 1636 .enc = {
1637 .vecs = camellia_cbc_enc_tv_template, 1637 .vecs = camellia_cbc_enc_tv_template,
1638 .count = CAMELLIA_CBC_ENC_TEST_VECTORS 1638 .count = CAMELLIA_CBC_ENC_TEST_VECTORS
1639 }, 1639 },
1640 .dec = { 1640 .dec = {
1641 .vecs = camellia_cbc_dec_tv_template, 1641 .vecs = camellia_cbc_dec_tv_template,
1642 .count = CAMELLIA_CBC_DEC_TEST_VECTORS 1642 .count = CAMELLIA_CBC_DEC_TEST_VECTORS
1643 } 1643 }
1644 } 1644 }
1645 } 1645 }
1646 }, { 1646 }, {
1647 .alg = "cbc(des)", 1647 .alg = "cbc(des)",
1648 .test = alg_test_skcipher, 1648 .test = alg_test_skcipher,
1649 .suite = { 1649 .suite = {
1650 .cipher = { 1650 .cipher = {
1651 .enc = { 1651 .enc = {
1652 .vecs = des_cbc_enc_tv_template, 1652 .vecs = des_cbc_enc_tv_template,
1653 .count = DES_CBC_ENC_TEST_VECTORS 1653 .count = DES_CBC_ENC_TEST_VECTORS
1654 }, 1654 },
1655 .dec = { 1655 .dec = {
1656 .vecs = des_cbc_dec_tv_template, 1656 .vecs = des_cbc_dec_tv_template,
1657 .count = DES_CBC_DEC_TEST_VECTORS 1657 .count = DES_CBC_DEC_TEST_VECTORS
1658 } 1658 }
1659 } 1659 }
1660 } 1660 }
1661 }, { 1661 }, {
1662 .alg = "cbc(des3_ede)", 1662 .alg = "cbc(des3_ede)",
1663 .test = alg_test_skcipher, 1663 .test = alg_test_skcipher,
1664 .fips_allowed = 1, 1664 .fips_allowed = 1,
1665 .suite = { 1665 .suite = {
1666 .cipher = { 1666 .cipher = {
1667 .enc = { 1667 .enc = {
1668 .vecs = des3_ede_cbc_enc_tv_template, 1668 .vecs = des3_ede_cbc_enc_tv_template,
1669 .count = DES3_EDE_CBC_ENC_TEST_VECTORS 1669 .count = DES3_EDE_CBC_ENC_TEST_VECTORS
1670 }, 1670 },
1671 .dec = { 1671 .dec = {
1672 .vecs = des3_ede_cbc_dec_tv_template, 1672 .vecs = des3_ede_cbc_dec_tv_template,
1673 .count = DES3_EDE_CBC_DEC_TEST_VECTORS 1673 .count = DES3_EDE_CBC_DEC_TEST_VECTORS
1674 } 1674 }
1675 } 1675 }
1676 } 1676 }
1677 }, { 1677 }, {
1678 .alg = "cbc(twofish)", 1678 .alg = "cbc(twofish)",
1679 .test = alg_test_skcipher, 1679 .test = alg_test_skcipher,
1680 .suite = { 1680 .suite = {
1681 .cipher = { 1681 .cipher = {
1682 .enc = { 1682 .enc = {
1683 .vecs = tf_cbc_enc_tv_template, 1683 .vecs = tf_cbc_enc_tv_template,
1684 .count = TF_CBC_ENC_TEST_VECTORS 1684 .count = TF_CBC_ENC_TEST_VECTORS
1685 }, 1685 },
1686 .dec = { 1686 .dec = {
1687 .vecs = tf_cbc_dec_tv_template, 1687 .vecs = tf_cbc_dec_tv_template,
1688 .count = TF_CBC_DEC_TEST_VECTORS 1688 .count = TF_CBC_DEC_TEST_VECTORS
1689 } 1689 }
1690 } 1690 }
1691 } 1691 }
1692 }, { 1692 }, {
1693 .alg = "ccm(aes)", 1693 .alg = "ccm(aes)",
1694 .test = alg_test_aead, 1694 .test = alg_test_aead,
1695 .fips_allowed = 1, 1695 .fips_allowed = 1,
1696 .suite = { 1696 .suite = {
1697 .aead = { 1697 .aead = {
1698 .enc = { 1698 .enc = {
1699 .vecs = aes_ccm_enc_tv_template, 1699 .vecs = aes_ccm_enc_tv_template,
1700 .count = AES_CCM_ENC_TEST_VECTORS 1700 .count = AES_CCM_ENC_TEST_VECTORS
1701 }, 1701 },
1702 .dec = { 1702 .dec = {
1703 .vecs = aes_ccm_dec_tv_template, 1703 .vecs = aes_ccm_dec_tv_template,
1704 .count = AES_CCM_DEC_TEST_VECTORS 1704 .count = AES_CCM_DEC_TEST_VECTORS
1705 } 1705 }
1706 } 1706 }
1707 } 1707 }
1708 }, { 1708 }, {
1709 .alg = "crc32c", 1709 .alg = "crc32c",
1710 .test = alg_test_crc32c, 1710 .test = alg_test_crc32c,
1711 .fips_allowed = 1, 1711 .fips_allowed = 1,
1712 .suite = { 1712 .suite = {
1713 .hash = { 1713 .hash = {
1714 .vecs = crc32c_tv_template, 1714 .vecs = crc32c_tv_template,
1715 .count = CRC32C_TEST_VECTORS 1715 .count = CRC32C_TEST_VECTORS
1716 } 1716 }
1717 } 1717 }
1718 }, { 1718 }, {
1719 .alg = "cryptd(__driver-ecb-aes-aesni)", 1719 .alg = "cryptd(__driver-ecb-aes-aesni)",
1720 .test = alg_test_null, 1720 .test = alg_test_null,
1721 .suite = { 1721 .suite = {
1722 .cipher = { 1722 .cipher = {
1723 .enc = { 1723 .enc = {
1724 .vecs = NULL, 1724 .vecs = NULL,
1725 .count = 0 1725 .count = 0
1726 }, 1726 },
1727 .dec = { 1727 .dec = {
1728 .vecs = NULL, 1728 .vecs = NULL,
1729 .count = 0 1729 .count = 0
1730 } 1730 }
1731 } 1731 }
1732 } 1732 }
1733 }, { 1733 }, {
1734 .alg = "cryptd(__ghash-pclmulqdqni)", 1734 .alg = "cryptd(__ghash-pclmulqdqni)",
1735 .test = alg_test_null, 1735 .test = alg_test_null,
1736 .suite = { 1736 .suite = {
1737 .hash = { 1737 .hash = {
1738 .vecs = NULL, 1738 .vecs = NULL,
1739 .count = 0 1739 .count = 0
1740 } 1740 }
1741 } 1741 }
1742 }, { 1742 }, {
1743 .alg = "ctr(aes)", 1743 .alg = "ctr(aes)",
1744 .test = alg_test_skcipher, 1744 .test = alg_test_skcipher,
1745 .fips_allowed = 1, 1745 .fips_allowed = 1,
1746 .suite = { 1746 .suite = {
1747 .cipher = { 1747 .cipher = {
1748 .enc = { 1748 .enc = {
1749 .vecs = aes_ctr_enc_tv_template, 1749 .vecs = aes_ctr_enc_tv_template,
1750 .count = AES_CTR_ENC_TEST_VECTORS 1750 .count = AES_CTR_ENC_TEST_VECTORS
1751 }, 1751 },
1752 .dec = { 1752 .dec = {
1753 .vecs = aes_ctr_dec_tv_template, 1753 .vecs = aes_ctr_dec_tv_template,
1754 .count = AES_CTR_DEC_TEST_VECTORS 1754 .count = AES_CTR_DEC_TEST_VECTORS
1755 } 1755 }
1756 } 1756 }
1757 } 1757 }
1758 }, { 1758 }, {
1759 .alg = "cts(cbc(aes))", 1759 .alg = "cts(cbc(aes))",
1760 .test = alg_test_skcipher, 1760 .test = alg_test_skcipher,
1761 .suite = { 1761 .suite = {
1762 .cipher = { 1762 .cipher = {
1763 .enc = { 1763 .enc = {
1764 .vecs = cts_mode_enc_tv_template, 1764 .vecs = cts_mode_enc_tv_template,
1765 .count = CTS_MODE_ENC_TEST_VECTORS 1765 .count = CTS_MODE_ENC_TEST_VECTORS
1766 }, 1766 },
1767 .dec = { 1767 .dec = {
1768 .vecs = cts_mode_dec_tv_template, 1768 .vecs = cts_mode_dec_tv_template,
1769 .count = CTS_MODE_DEC_TEST_VECTORS 1769 .count = CTS_MODE_DEC_TEST_VECTORS
1770 } 1770 }
1771 } 1771 }
1772 } 1772 }
1773 }, { 1773 }, {
1774 .alg = "deflate", 1774 .alg = "deflate",
1775 .test = alg_test_comp, 1775 .test = alg_test_comp,
1776 .suite = { 1776 .suite = {
1777 .comp = { 1777 .comp = {
1778 .comp = { 1778 .comp = {
1779 .vecs = deflate_comp_tv_template, 1779 .vecs = deflate_comp_tv_template,
1780 .count = DEFLATE_COMP_TEST_VECTORS 1780 .count = DEFLATE_COMP_TEST_VECTORS
1781 }, 1781 },
1782 .decomp = { 1782 .decomp = {
1783 .vecs = deflate_decomp_tv_template, 1783 .vecs = deflate_decomp_tv_template,
1784 .count = DEFLATE_DECOMP_TEST_VECTORS 1784 .count = DEFLATE_DECOMP_TEST_VECTORS
1785 } 1785 }
1786 } 1786 }
1787 } 1787 }
1788 }, { 1788 }, {
1789 .alg = "ecb(__aes-aesni)", 1789 .alg = "ecb(__aes-aesni)",
1790 .test = alg_test_null, 1790 .test = alg_test_null,
1791 .suite = { 1791 .suite = {
1792 .cipher = { 1792 .cipher = {
1793 .enc = { 1793 .enc = {
1794 .vecs = NULL, 1794 .vecs = NULL,
1795 .count = 0 1795 .count = 0
1796 }, 1796 },
1797 .dec = { 1797 .dec = {
1798 .vecs = NULL, 1798 .vecs = NULL,
1799 .count = 0 1799 .count = 0
1800 } 1800 }
1801 } 1801 }
1802 } 1802 }
1803 }, { 1803 }, {
1804 .alg = "ecb(aes)", 1804 .alg = "ecb(aes)",
1805 .test = alg_test_skcipher, 1805 .test = alg_test_skcipher,
1806 .fips_allowed = 1, 1806 .fips_allowed = 1,
1807 .suite = { 1807 .suite = {
1808 .cipher = { 1808 .cipher = {
1809 .enc = { 1809 .enc = {
1810 .vecs = aes_enc_tv_template, 1810 .vecs = aes_enc_tv_template,
1811 .count = AES_ENC_TEST_VECTORS 1811 .count = AES_ENC_TEST_VECTORS
1812 }, 1812 },
1813 .dec = { 1813 .dec = {
1814 .vecs = aes_dec_tv_template, 1814 .vecs = aes_dec_tv_template,
1815 .count = AES_DEC_TEST_VECTORS 1815 .count = AES_DEC_TEST_VECTORS
1816 } 1816 }
1817 } 1817 }
1818 } 1818 }
1819 }, { 1819 }, {
1820 .alg = "ecb(anubis)", 1820 .alg = "ecb(anubis)",
1821 .test = alg_test_skcipher, 1821 .test = alg_test_skcipher,
1822 .suite = { 1822 .suite = {
1823 .cipher = { 1823 .cipher = {
1824 .enc = { 1824 .enc = {
1825 .vecs = anubis_enc_tv_template, 1825 .vecs = anubis_enc_tv_template,
1826 .count = ANUBIS_ENC_TEST_VECTORS 1826 .count = ANUBIS_ENC_TEST_VECTORS
1827 }, 1827 },
1828 .dec = { 1828 .dec = {
1829 .vecs = anubis_dec_tv_template, 1829 .vecs = anubis_dec_tv_template,
1830 .count = ANUBIS_DEC_TEST_VECTORS 1830 .count = ANUBIS_DEC_TEST_VECTORS
1831 } 1831 }
1832 } 1832 }
1833 } 1833 }
1834 }, { 1834 }, {
1835 .alg = "ecb(arc4)", 1835 .alg = "ecb(arc4)",
1836 .test = alg_test_skcipher, 1836 .test = alg_test_skcipher,
1837 .suite = { 1837 .suite = {
1838 .cipher = { 1838 .cipher = {
1839 .enc = { 1839 .enc = {
1840 .vecs = arc4_enc_tv_template, 1840 .vecs = arc4_enc_tv_template,
1841 .count = ARC4_ENC_TEST_VECTORS 1841 .count = ARC4_ENC_TEST_VECTORS
1842 }, 1842 },
1843 .dec = { 1843 .dec = {
1844 .vecs = arc4_dec_tv_template, 1844 .vecs = arc4_dec_tv_template,
1845 .count = ARC4_DEC_TEST_VECTORS 1845 .count = ARC4_DEC_TEST_VECTORS
1846 } 1846 }
1847 } 1847 }
1848 } 1848 }
1849 }, { 1849 }, {
1850 .alg = "ecb(blowfish)", 1850 .alg = "ecb(blowfish)",
1851 .test = alg_test_skcipher, 1851 .test = alg_test_skcipher,
1852 .suite = { 1852 .suite = {
1853 .cipher = { 1853 .cipher = {
1854 .enc = { 1854 .enc = {
1855 .vecs = bf_enc_tv_template, 1855 .vecs = bf_enc_tv_template,
1856 .count = BF_ENC_TEST_VECTORS 1856 .count = BF_ENC_TEST_VECTORS
1857 }, 1857 },
1858 .dec = { 1858 .dec = {
1859 .vecs = bf_dec_tv_template, 1859 .vecs = bf_dec_tv_template,
1860 .count = BF_DEC_TEST_VECTORS 1860 .count = BF_DEC_TEST_VECTORS
1861 } 1861 }
1862 } 1862 }
1863 } 1863 }
1864 }, { 1864 }, {
1865 .alg = "ecb(camellia)", 1865 .alg = "ecb(camellia)",
1866 .test = alg_test_skcipher, 1866 .test = alg_test_skcipher,
1867 .suite = { 1867 .suite = {
1868 .cipher = { 1868 .cipher = {
1869 .enc = { 1869 .enc = {
1870 .vecs = camellia_enc_tv_template, 1870 .vecs = camellia_enc_tv_template,
1871 .count = CAMELLIA_ENC_TEST_VECTORS 1871 .count = CAMELLIA_ENC_TEST_VECTORS
1872 }, 1872 },
1873 .dec = { 1873 .dec = {
1874 .vecs = camellia_dec_tv_template, 1874 .vecs = camellia_dec_tv_template,
1875 .count = CAMELLIA_DEC_TEST_VECTORS 1875 .count = CAMELLIA_DEC_TEST_VECTORS
1876 } 1876 }
1877 } 1877 }
1878 } 1878 }
1879 }, { 1879 }, {
1880 .alg = "ecb(cast5)", 1880 .alg = "ecb(cast5)",
1881 .test = alg_test_skcipher, 1881 .test = alg_test_skcipher,
1882 .suite = { 1882 .suite = {
1883 .cipher = { 1883 .cipher = {
1884 .enc = { 1884 .enc = {
1885 .vecs = cast5_enc_tv_template, 1885 .vecs = cast5_enc_tv_template,
1886 .count = CAST5_ENC_TEST_VECTORS 1886 .count = CAST5_ENC_TEST_VECTORS
1887 }, 1887 },
1888 .dec = { 1888 .dec = {
1889 .vecs = cast5_dec_tv_template, 1889 .vecs = cast5_dec_tv_template,
1890 .count = CAST5_DEC_TEST_VECTORS 1890 .count = CAST5_DEC_TEST_VECTORS
1891 } 1891 }
1892 } 1892 }
1893 } 1893 }
1894 }, { 1894 }, {
1895 .alg = "ecb(cast6)", 1895 .alg = "ecb(cast6)",
1896 .test = alg_test_skcipher, 1896 .test = alg_test_skcipher,
1897 .suite = { 1897 .suite = {
1898 .cipher = { 1898 .cipher = {
1899 .enc = { 1899 .enc = {
1900 .vecs = cast6_enc_tv_template, 1900 .vecs = cast6_enc_tv_template,
1901 .count = CAST6_ENC_TEST_VECTORS 1901 .count = CAST6_ENC_TEST_VECTORS
1902 }, 1902 },
1903 .dec = { 1903 .dec = {
1904 .vecs = cast6_dec_tv_template, 1904 .vecs = cast6_dec_tv_template,
1905 .count = CAST6_DEC_TEST_VECTORS 1905 .count = CAST6_DEC_TEST_VECTORS
1906 } 1906 }
1907 } 1907 }
1908 } 1908 }
1909 }, { 1909 }, {
1910 .alg = "ecb(des)", 1910 .alg = "ecb(des)",
1911 .test = alg_test_skcipher, 1911 .test = alg_test_skcipher,
1912 .fips_allowed = 1, 1912 .fips_allowed = 1,
1913 .suite = { 1913 .suite = {
1914 .cipher = { 1914 .cipher = {
1915 .enc = { 1915 .enc = {
1916 .vecs = des_enc_tv_template, 1916 .vecs = des_enc_tv_template,
1917 .count = DES_ENC_TEST_VECTORS 1917 .count = DES_ENC_TEST_VECTORS
1918 }, 1918 },
1919 .dec = { 1919 .dec = {
1920 .vecs = des_dec_tv_template, 1920 .vecs = des_dec_tv_template,
1921 .count = DES_DEC_TEST_VECTORS 1921 .count = DES_DEC_TEST_VECTORS
1922 } 1922 }
1923 } 1923 }
1924 } 1924 }
1925 }, { 1925 }, {
1926 .alg = "ecb(des3_ede)", 1926 .alg = "ecb(des3_ede)",
1927 .test = alg_test_skcipher, 1927 .test = alg_test_skcipher,
1928 .fips_allowed = 1, 1928 .fips_allowed = 1,
1929 .suite = { 1929 .suite = {
1930 .cipher = { 1930 .cipher = {
1931 .enc = { 1931 .enc = {
1932 .vecs = des3_ede_enc_tv_template, 1932 .vecs = des3_ede_enc_tv_template,
1933 .count = DES3_EDE_ENC_TEST_VECTORS 1933 .count = DES3_EDE_ENC_TEST_VECTORS
1934 }, 1934 },
1935 .dec = { 1935 .dec = {
1936 .vecs = des3_ede_dec_tv_template, 1936 .vecs = des3_ede_dec_tv_template,
1937 .count = DES3_EDE_DEC_TEST_VECTORS 1937 .count = DES3_EDE_DEC_TEST_VECTORS
1938 } 1938 }
1939 } 1939 }
1940 } 1940 }
1941 }, { 1941 }, {
1942 .alg = "ecb(khazad)", 1942 .alg = "ecb(khazad)",
1943 .test = alg_test_skcipher, 1943 .test = alg_test_skcipher,
1944 .suite = { 1944 .suite = {
1945 .cipher = { 1945 .cipher = {
1946 .enc = { 1946 .enc = {
1947 .vecs = khazad_enc_tv_template, 1947 .vecs = khazad_enc_tv_template,
1948 .count = KHAZAD_ENC_TEST_VECTORS 1948 .count = KHAZAD_ENC_TEST_VECTORS
1949 }, 1949 },
1950 .dec = { 1950 .dec = {
1951 .vecs = khazad_dec_tv_template, 1951 .vecs = khazad_dec_tv_template,
1952 .count = KHAZAD_DEC_TEST_VECTORS 1952 .count = KHAZAD_DEC_TEST_VECTORS
1953 } 1953 }
1954 } 1954 }
1955 } 1955 }
1956 }, { 1956 }, {
1957 .alg = "ecb(seed)", 1957 .alg = "ecb(seed)",
1958 .test = alg_test_skcipher, 1958 .test = alg_test_skcipher,
1959 .suite = { 1959 .suite = {
1960 .cipher = { 1960 .cipher = {
1961 .enc = { 1961 .enc = {
1962 .vecs = seed_enc_tv_template, 1962 .vecs = seed_enc_tv_template,
1963 .count = SEED_ENC_TEST_VECTORS 1963 .count = SEED_ENC_TEST_VECTORS
1964 }, 1964 },
1965 .dec = { 1965 .dec = {
1966 .vecs = seed_dec_tv_template, 1966 .vecs = seed_dec_tv_template,
1967 .count = SEED_DEC_TEST_VECTORS 1967 .count = SEED_DEC_TEST_VECTORS
1968 } 1968 }
1969 } 1969 }
1970 } 1970 }
1971 }, { 1971 }, {
1972 .alg = "ecb(serpent)", 1972 .alg = "ecb(serpent)",
1973 .test = alg_test_skcipher, 1973 .test = alg_test_skcipher,
1974 .suite = { 1974 .suite = {
1975 .cipher = { 1975 .cipher = {
1976 .enc = { 1976 .enc = {
1977 .vecs = serpent_enc_tv_template, 1977 .vecs = serpent_enc_tv_template,
1978 .count = SERPENT_ENC_TEST_VECTORS 1978 .count = SERPENT_ENC_TEST_VECTORS
1979 }, 1979 },
1980 .dec = { 1980 .dec = {
1981 .vecs = serpent_dec_tv_template, 1981 .vecs = serpent_dec_tv_template,
1982 .count = SERPENT_DEC_TEST_VECTORS 1982 .count = SERPENT_DEC_TEST_VECTORS
1983 } 1983 }
1984 } 1984 }
1985 } 1985 }
1986 }, { 1986 }, {
1987 .alg = "ecb(tea)", 1987 .alg = "ecb(tea)",
1988 .test = alg_test_skcipher, 1988 .test = alg_test_skcipher,
1989 .suite = { 1989 .suite = {
1990 .cipher = { 1990 .cipher = {
1991 .enc = { 1991 .enc = {
1992 .vecs = tea_enc_tv_template, 1992 .vecs = tea_enc_tv_template,
1993 .count = TEA_ENC_TEST_VECTORS 1993 .count = TEA_ENC_TEST_VECTORS
1994 }, 1994 },
1995 .dec = { 1995 .dec = {
1996 .vecs = tea_dec_tv_template, 1996 .vecs = tea_dec_tv_template,
1997 .count = TEA_DEC_TEST_VECTORS 1997 .count = TEA_DEC_TEST_VECTORS
1998 } 1998 }
1999 } 1999 }
2000 } 2000 }
2001 }, { 2001 }, {
2002 .alg = "ecb(tnepres)", 2002 .alg = "ecb(tnepres)",
2003 .test = alg_test_skcipher, 2003 .test = alg_test_skcipher,
2004 .suite = { 2004 .suite = {
2005 .cipher = { 2005 .cipher = {
2006 .enc = { 2006 .enc = {
2007 .vecs = tnepres_enc_tv_template, 2007 .vecs = tnepres_enc_tv_template,
2008 .count = TNEPRES_ENC_TEST_VECTORS 2008 .count = TNEPRES_ENC_TEST_VECTORS
2009 }, 2009 },
2010 .dec = { 2010 .dec = {
2011 .vecs = tnepres_dec_tv_template, 2011 .vecs = tnepres_dec_tv_template,
2012 .count = TNEPRES_DEC_TEST_VECTORS 2012 .count = TNEPRES_DEC_TEST_VECTORS
2013 } 2013 }
2014 } 2014 }
2015 } 2015 }
2016 }, { 2016 }, {
2017 .alg = "ecb(twofish)", 2017 .alg = "ecb(twofish)",
2018 .test = alg_test_skcipher, 2018 .test = alg_test_skcipher,
2019 .suite = { 2019 .suite = {
2020 .cipher = { 2020 .cipher = {
2021 .enc = { 2021 .enc = {
2022 .vecs = tf_enc_tv_template, 2022 .vecs = tf_enc_tv_template,
2023 .count = TF_ENC_TEST_VECTORS 2023 .count = TF_ENC_TEST_VECTORS
2024 }, 2024 },
2025 .dec = { 2025 .dec = {
2026 .vecs = tf_dec_tv_template, 2026 .vecs = tf_dec_tv_template,
2027 .count = TF_DEC_TEST_VECTORS 2027 .count = TF_DEC_TEST_VECTORS
2028 } 2028 }
2029 } 2029 }
2030 } 2030 }
2031 }, { 2031 }, {
2032 .alg = "ecb(xeta)", 2032 .alg = "ecb(xeta)",
2033 .test = alg_test_skcipher, 2033 .test = alg_test_skcipher,
2034 .suite = { 2034 .suite = {
2035 .cipher = { 2035 .cipher = {
2036 .enc = { 2036 .enc = {
2037 .vecs = xeta_enc_tv_template, 2037 .vecs = xeta_enc_tv_template,
2038 .count = XETA_ENC_TEST_VECTORS 2038 .count = XETA_ENC_TEST_VECTORS
2039 }, 2039 },
2040 .dec = { 2040 .dec = {
2041 .vecs = xeta_dec_tv_template, 2041 .vecs = xeta_dec_tv_template,
2042 .count = XETA_DEC_TEST_VECTORS 2042 .count = XETA_DEC_TEST_VECTORS
2043 } 2043 }
2044 } 2044 }
2045 } 2045 }
2046 }, { 2046 }, {
2047 .alg = "ecb(xtea)", 2047 .alg = "ecb(xtea)",
2048 .test = alg_test_skcipher, 2048 .test = alg_test_skcipher,
2049 .suite = { 2049 .suite = {
2050 .cipher = { 2050 .cipher = {
2051 .enc = { 2051 .enc = {
2052 .vecs = xtea_enc_tv_template, 2052 .vecs = xtea_enc_tv_template,
2053 .count = XTEA_ENC_TEST_VECTORS 2053 .count = XTEA_ENC_TEST_VECTORS
2054 }, 2054 },
2055 .dec = { 2055 .dec = {
2056 .vecs = xtea_dec_tv_template, 2056 .vecs = xtea_dec_tv_template,
2057 .count = XTEA_DEC_TEST_VECTORS 2057 .count = XTEA_DEC_TEST_VECTORS
2058 } 2058 }
2059 } 2059 }
2060 } 2060 }
2061 }, { 2061 }, {
2062 .alg = "gcm(aes)", 2062 .alg = "gcm(aes)",
2063 .test = alg_test_aead, 2063 .test = alg_test_aead,
2064 .fips_allowed = 1, 2064 .fips_allowed = 1,
2065 .suite = { 2065 .suite = {
2066 .aead = { 2066 .aead = {
2067 .enc = { 2067 .enc = {
2068 .vecs = aes_gcm_enc_tv_template, 2068 .vecs = aes_gcm_enc_tv_template,
2069 .count = AES_GCM_ENC_TEST_VECTORS 2069 .count = AES_GCM_ENC_TEST_VECTORS
2070 }, 2070 },
2071 .dec = { 2071 .dec = {
2072 .vecs = aes_gcm_dec_tv_template, 2072 .vecs = aes_gcm_dec_tv_template,
2073 .count = AES_GCM_DEC_TEST_VECTORS 2073 .count = AES_GCM_DEC_TEST_VECTORS
2074 } 2074 }
2075 } 2075 }
2076 } 2076 }
2077 }, { 2077 }, {
2078 .alg = "ghash", 2078 .alg = "ghash",
2079 .test = alg_test_hash, 2079 .test = alg_test_hash,
2080 .fips_allowed = 1,
2080 .suite = { 2081 .suite = {
2081 .hash = { 2082 .hash = {
2082 .vecs = ghash_tv_template, 2083 .vecs = ghash_tv_template,
2083 .count = GHASH_TEST_VECTORS 2084 .count = GHASH_TEST_VECTORS
2084 } 2085 }
2085 } 2086 }
2086 }, { 2087 }, {
2087 .alg = "hmac(md5)", 2088 .alg = "hmac(md5)",
2088 .test = alg_test_hash, 2089 .test = alg_test_hash,
2089 .suite = { 2090 .suite = {
2090 .hash = { 2091 .hash = {
2091 .vecs = hmac_md5_tv_template, 2092 .vecs = hmac_md5_tv_template,
2092 .count = HMAC_MD5_TEST_VECTORS 2093 .count = HMAC_MD5_TEST_VECTORS
2093 } 2094 }
2094 } 2095 }
2095 }, { 2096 }, {
2096 .alg = "hmac(rmd128)", 2097 .alg = "hmac(rmd128)",
2097 .test = alg_test_hash, 2098 .test = alg_test_hash,
2098 .suite = { 2099 .suite = {
2099 .hash = { 2100 .hash = {
2100 .vecs = hmac_rmd128_tv_template, 2101 .vecs = hmac_rmd128_tv_template,
2101 .count = HMAC_RMD128_TEST_VECTORS 2102 .count = HMAC_RMD128_TEST_VECTORS
2102 } 2103 }
2103 } 2104 }
2104 }, { 2105 }, {
2105 .alg = "hmac(rmd160)", 2106 .alg = "hmac(rmd160)",
2106 .test = alg_test_hash, 2107 .test = alg_test_hash,
2107 .suite = { 2108 .suite = {
2108 .hash = { 2109 .hash = {
2109 .vecs = hmac_rmd160_tv_template, 2110 .vecs = hmac_rmd160_tv_template,
2110 .count = HMAC_RMD160_TEST_VECTORS 2111 .count = HMAC_RMD160_TEST_VECTORS
2111 } 2112 }
2112 } 2113 }
2113 }, { 2114 }, {
2114 .alg = "hmac(sha1)", 2115 .alg = "hmac(sha1)",
2115 .test = alg_test_hash, 2116 .test = alg_test_hash,
2116 .fips_allowed = 1, 2117 .fips_allowed = 1,
2117 .suite = { 2118 .suite = {
2118 .hash = { 2119 .hash = {
2119 .vecs = hmac_sha1_tv_template, 2120 .vecs = hmac_sha1_tv_template,
2120 .count = HMAC_SHA1_TEST_VECTORS 2121 .count = HMAC_SHA1_TEST_VECTORS
2121 } 2122 }
2122 } 2123 }
2123 }, { 2124 }, {
2124 .alg = "hmac(sha224)", 2125 .alg = "hmac(sha224)",
2125 .test = alg_test_hash, 2126 .test = alg_test_hash,
2126 .fips_allowed = 1, 2127 .fips_allowed = 1,
2127 .suite = { 2128 .suite = {
2128 .hash = { 2129 .hash = {
2129 .vecs = hmac_sha224_tv_template, 2130 .vecs = hmac_sha224_tv_template,
2130 .count = HMAC_SHA224_TEST_VECTORS 2131 .count = HMAC_SHA224_TEST_VECTORS
2131 } 2132 }
2132 } 2133 }
2133 }, { 2134 }, {
2134 .alg = "hmac(sha256)", 2135 .alg = "hmac(sha256)",
2135 .test = alg_test_hash, 2136 .test = alg_test_hash,
2136 .fips_allowed = 1, 2137 .fips_allowed = 1,
2137 .suite = { 2138 .suite = {
2138 .hash = { 2139 .hash = {
2139 .vecs = hmac_sha256_tv_template, 2140 .vecs = hmac_sha256_tv_template,
2140 .count = HMAC_SHA256_TEST_VECTORS 2141 .count = HMAC_SHA256_TEST_VECTORS
2141 } 2142 }
2142 } 2143 }
2143 }, { 2144 }, {
2144 .alg = "hmac(sha384)", 2145 .alg = "hmac(sha384)",
2145 .test = alg_test_hash, 2146 .test = alg_test_hash,
2146 .fips_allowed = 1, 2147 .fips_allowed = 1,
2147 .suite = { 2148 .suite = {
2148 .hash = { 2149 .hash = {
2149 .vecs = hmac_sha384_tv_template, 2150 .vecs = hmac_sha384_tv_template,
2150 .count = HMAC_SHA384_TEST_VECTORS 2151 .count = HMAC_SHA384_TEST_VECTORS
2151 } 2152 }
2152 } 2153 }
2153 }, { 2154 }, {
2154 .alg = "hmac(sha512)", 2155 .alg = "hmac(sha512)",
2155 .test = alg_test_hash, 2156 .test = alg_test_hash,
2156 .fips_allowed = 1, 2157 .fips_allowed = 1,
2157 .suite = { 2158 .suite = {
2158 .hash = { 2159 .hash = {
2159 .vecs = hmac_sha512_tv_template, 2160 .vecs = hmac_sha512_tv_template,
2160 .count = HMAC_SHA512_TEST_VECTORS 2161 .count = HMAC_SHA512_TEST_VECTORS
2161 } 2162 }
2162 } 2163 }
2163 }, { 2164 }, {
2164 .alg = "lrw(aes)", 2165 .alg = "lrw(aes)",
2165 .test = alg_test_skcipher, 2166 .test = alg_test_skcipher,
2166 .suite = { 2167 .suite = {
2167 .cipher = { 2168 .cipher = {
2168 .enc = { 2169 .enc = {
2169 .vecs = aes_lrw_enc_tv_template, 2170 .vecs = aes_lrw_enc_tv_template,
2170 .count = AES_LRW_ENC_TEST_VECTORS 2171 .count = AES_LRW_ENC_TEST_VECTORS
2171 }, 2172 },
2172 .dec = { 2173 .dec = {
2173 .vecs = aes_lrw_dec_tv_template, 2174 .vecs = aes_lrw_dec_tv_template,
2174 .count = AES_LRW_DEC_TEST_VECTORS 2175 .count = AES_LRW_DEC_TEST_VECTORS
2175 } 2176 }
2176 } 2177 }
2177 } 2178 }
2178 }, { 2179 }, {
2179 .alg = "lzo", 2180 .alg = "lzo",
2180 .test = alg_test_comp, 2181 .test = alg_test_comp,
2181 .suite = { 2182 .suite = {
2182 .comp = { 2183 .comp = {
2183 .comp = { 2184 .comp = {
2184 .vecs = lzo_comp_tv_template, 2185 .vecs = lzo_comp_tv_template,
2185 .count = LZO_COMP_TEST_VECTORS 2186 .count = LZO_COMP_TEST_VECTORS
2186 }, 2187 },
2187 .decomp = { 2188 .decomp = {
2188 .vecs = lzo_decomp_tv_template, 2189 .vecs = lzo_decomp_tv_template,
2189 .count = LZO_DECOMP_TEST_VECTORS 2190 .count = LZO_DECOMP_TEST_VECTORS
2190 } 2191 }
2191 } 2192 }
2192 } 2193 }
2193 }, { 2194 }, {
2194 .alg = "md4", 2195 .alg = "md4",
2195 .test = alg_test_hash, 2196 .test = alg_test_hash,
2196 .suite = { 2197 .suite = {
2197 .hash = { 2198 .hash = {
2198 .vecs = md4_tv_template, 2199 .vecs = md4_tv_template,
2199 .count = MD4_TEST_VECTORS 2200 .count = MD4_TEST_VECTORS
2200 } 2201 }
2201 } 2202 }
2202 }, { 2203 }, {
2203 .alg = "md5", 2204 .alg = "md5",
2204 .test = alg_test_hash, 2205 .test = alg_test_hash,
2205 .suite = { 2206 .suite = {
2206 .hash = { 2207 .hash = {
2207 .vecs = md5_tv_template, 2208 .vecs = md5_tv_template,
2208 .count = MD5_TEST_VECTORS 2209 .count = MD5_TEST_VECTORS
2209 } 2210 }
2210 } 2211 }
2211 }, { 2212 }, {
2212 .alg = "michael_mic", 2213 .alg = "michael_mic",
2213 .test = alg_test_hash, 2214 .test = alg_test_hash,
2214 .suite = { 2215 .suite = {
2215 .hash = { 2216 .hash = {
2216 .vecs = michael_mic_tv_template, 2217 .vecs = michael_mic_tv_template,
2217 .count = MICHAEL_MIC_TEST_VECTORS 2218 .count = MICHAEL_MIC_TEST_VECTORS
2218 } 2219 }
2219 } 2220 }
2220 }, { 2221 }, {
2221 .alg = "pcbc(fcrypt)", 2222 .alg = "pcbc(fcrypt)",
2222 .test = alg_test_skcipher, 2223 .test = alg_test_skcipher,
2223 .suite = { 2224 .suite = {
2224 .cipher = { 2225 .cipher = {
2225 .enc = { 2226 .enc = {
2226 .vecs = fcrypt_pcbc_enc_tv_template, 2227 .vecs = fcrypt_pcbc_enc_tv_template,
2227 .count = FCRYPT_ENC_TEST_VECTORS 2228 .count = FCRYPT_ENC_TEST_VECTORS
2228 }, 2229 },
2229 .dec = { 2230 .dec = {
2230 .vecs = fcrypt_pcbc_dec_tv_template, 2231 .vecs = fcrypt_pcbc_dec_tv_template,
2231 .count = FCRYPT_DEC_TEST_VECTORS 2232 .count = FCRYPT_DEC_TEST_VECTORS
2232 } 2233 }
2233 } 2234 }
2234 } 2235 }
2235 }, { 2236 }, {
2236 .alg = "rfc3686(ctr(aes))", 2237 .alg = "rfc3686(ctr(aes))",
2237 .test = alg_test_skcipher, 2238 .test = alg_test_skcipher,
2238 .fips_allowed = 1, 2239 .fips_allowed = 1,
2239 .suite = { 2240 .suite = {
2240 .cipher = { 2241 .cipher = {
2241 .enc = { 2242 .enc = {
2242 .vecs = aes_ctr_rfc3686_enc_tv_template, 2243 .vecs = aes_ctr_rfc3686_enc_tv_template,
2243 .count = AES_CTR_3686_ENC_TEST_VECTORS 2244 .count = AES_CTR_3686_ENC_TEST_VECTORS
2244 }, 2245 },
2245 .dec = { 2246 .dec = {
2246 .vecs = aes_ctr_rfc3686_dec_tv_template, 2247 .vecs = aes_ctr_rfc3686_dec_tv_template,
2247 .count = AES_CTR_3686_DEC_TEST_VECTORS 2248 .count = AES_CTR_3686_DEC_TEST_VECTORS
2248 } 2249 }
2249 } 2250 }
2250 } 2251 }
2251 }, { 2252 }, {
2252 .alg = "rfc4106(gcm(aes))", 2253 .alg = "rfc4106(gcm(aes))",
2253 .test = alg_test_aead, 2254 .test = alg_test_aead,
2254 .suite = { 2255 .suite = {
2255 .aead = { 2256 .aead = {
2256 .enc = { 2257 .enc = {
2257 .vecs = aes_gcm_rfc4106_enc_tv_template, 2258 .vecs = aes_gcm_rfc4106_enc_tv_template,
2258 .count = AES_GCM_4106_ENC_TEST_VECTORS 2259 .count = AES_GCM_4106_ENC_TEST_VECTORS
2259 }, 2260 },
2260 .dec = { 2261 .dec = {
2261 .vecs = aes_gcm_rfc4106_dec_tv_template, 2262 .vecs = aes_gcm_rfc4106_dec_tv_template,
2262 .count = AES_GCM_4106_DEC_TEST_VECTORS 2263 .count = AES_GCM_4106_DEC_TEST_VECTORS
2263 } 2264 }
2264 } 2265 }
2265 } 2266 }
2266 }, { 2267 }, {
2267 2268
2268 2269
2269 .alg = "rfc4309(ccm(aes))", 2270 .alg = "rfc4309(ccm(aes))",
2270 .test = alg_test_aead, 2271 .test = alg_test_aead,
2271 .fips_allowed = 1, 2272 .fips_allowed = 1,
2272 .suite = { 2273 .suite = {
2273 .aead = { 2274 .aead = {
2274 .enc = { 2275 .enc = {
2275 .vecs = aes_ccm_rfc4309_enc_tv_template, 2276 .vecs = aes_ccm_rfc4309_enc_tv_template,
2276 .count = AES_CCM_4309_ENC_TEST_VECTORS 2277 .count = AES_CCM_4309_ENC_TEST_VECTORS
2277 }, 2278 },
2278 .dec = { 2279 .dec = {
2279 .vecs = aes_ccm_rfc4309_dec_tv_template, 2280 .vecs = aes_ccm_rfc4309_dec_tv_template,
2280 .count = AES_CCM_4309_DEC_TEST_VECTORS 2281 .count = AES_CCM_4309_DEC_TEST_VECTORS
2281 } 2282 }
2282 } 2283 }
2283 } 2284 }
2284 }, { 2285 }, {
2285 .alg = "rmd128", 2286 .alg = "rmd128",
2286 .test = alg_test_hash, 2287 .test = alg_test_hash,
2287 .suite = { 2288 .suite = {
2288 .hash = { 2289 .hash = {
2289 .vecs = rmd128_tv_template, 2290 .vecs = rmd128_tv_template,
2290 .count = RMD128_TEST_VECTORS 2291 .count = RMD128_TEST_VECTORS
2291 } 2292 }
2292 } 2293 }
2293 }, { 2294 }, {
2294 .alg = "rmd160", 2295 .alg = "rmd160",
2295 .test = alg_test_hash, 2296 .test = alg_test_hash,
2296 .suite = { 2297 .suite = {
2297 .hash = { 2298 .hash = {
2298 .vecs = rmd160_tv_template, 2299 .vecs = rmd160_tv_template,
2299 .count = RMD160_TEST_VECTORS 2300 .count = RMD160_TEST_VECTORS
2300 } 2301 }
2301 } 2302 }
2302 }, { 2303 }, {
2303 .alg = "rmd256", 2304 .alg = "rmd256",
2304 .test = alg_test_hash, 2305 .test = alg_test_hash,
2305 .suite = { 2306 .suite = {
2306 .hash = { 2307 .hash = {
2307 .vecs = rmd256_tv_template, 2308 .vecs = rmd256_tv_template,
2308 .count = RMD256_TEST_VECTORS 2309 .count = RMD256_TEST_VECTORS
2309 } 2310 }
2310 } 2311 }
2311 }, { 2312 }, {
2312 .alg = "rmd320", 2313 .alg = "rmd320",
2313 .test = alg_test_hash, 2314 .test = alg_test_hash,
2314 .suite = { 2315 .suite = {
2315 .hash = { 2316 .hash = {
2316 .vecs = rmd320_tv_template, 2317 .vecs = rmd320_tv_template,
2317 .count = RMD320_TEST_VECTORS 2318 .count = RMD320_TEST_VECTORS
2318 } 2319 }
2319 } 2320 }
2320 }, { 2321 }, {
2321 .alg = "salsa20", 2322 .alg = "salsa20",
2322 .test = alg_test_skcipher, 2323 .test = alg_test_skcipher,
2323 .suite = { 2324 .suite = {
2324 .cipher = { 2325 .cipher = {
2325 .enc = { 2326 .enc = {
2326 .vecs = salsa20_stream_enc_tv_template, 2327 .vecs = salsa20_stream_enc_tv_template,
2327 .count = SALSA20_STREAM_ENC_TEST_VECTORS 2328 .count = SALSA20_STREAM_ENC_TEST_VECTORS
2328 } 2329 }
2329 } 2330 }
2330 } 2331 }
2331 }, { 2332 }, {
2332 .alg = "sha1", 2333 .alg = "sha1",
2333 .test = alg_test_hash, 2334 .test = alg_test_hash,
2334 .fips_allowed = 1, 2335 .fips_allowed = 1,
2335 .suite = { 2336 .suite = {
2336 .hash = { 2337 .hash = {
2337 .vecs = sha1_tv_template, 2338 .vecs = sha1_tv_template,
2338 .count = SHA1_TEST_VECTORS 2339 .count = SHA1_TEST_VECTORS
2339 } 2340 }
2340 } 2341 }
2341 }, { 2342 }, {
2342 .alg = "sha224", 2343 .alg = "sha224",
2343 .test = alg_test_hash, 2344 .test = alg_test_hash,
2344 .fips_allowed = 1, 2345 .fips_allowed = 1,
2345 .suite = { 2346 .suite = {
2346 .hash = { 2347 .hash = {
2347 .vecs = sha224_tv_template, 2348 .vecs = sha224_tv_template,
2348 .count = SHA224_TEST_VECTORS 2349 .count = SHA224_TEST_VECTORS
2349 } 2350 }
2350 } 2351 }
2351 }, { 2352 }, {
2352 .alg = "sha256", 2353 .alg = "sha256",
2353 .test = alg_test_hash, 2354 .test = alg_test_hash,
2354 .fips_allowed = 1, 2355 .fips_allowed = 1,
2355 .suite = { 2356 .suite = {
2356 .hash = { 2357 .hash = {
2357 .vecs = sha256_tv_template, 2358 .vecs = sha256_tv_template,
2358 .count = SHA256_TEST_VECTORS 2359 .count = SHA256_TEST_VECTORS
2359 } 2360 }
2360 } 2361 }
2361 }, { 2362 }, {
2362 .alg = "sha384", 2363 .alg = "sha384",
2363 .test = alg_test_hash, 2364 .test = alg_test_hash,
2364 .fips_allowed = 1, 2365 .fips_allowed = 1,
2365 .suite = { 2366 .suite = {
2366 .hash = { 2367 .hash = {
2367 .vecs = sha384_tv_template, 2368 .vecs = sha384_tv_template,
2368 .count = SHA384_TEST_VECTORS 2369 .count = SHA384_TEST_VECTORS
2369 } 2370 }
2370 } 2371 }
2371 }, { 2372 }, {
2372 .alg = "sha512", 2373 .alg = "sha512",
2373 .test = alg_test_hash, 2374 .test = alg_test_hash,
2374 .fips_allowed = 1, 2375 .fips_allowed = 1,
2375 .suite = { 2376 .suite = {
2376 .hash = { 2377 .hash = {
2377 .vecs = sha512_tv_template, 2378 .vecs = sha512_tv_template,
2378 .count = SHA512_TEST_VECTORS 2379 .count = SHA512_TEST_VECTORS
2379 } 2380 }
2380 } 2381 }
2381 }, { 2382 }, {
2382 .alg = "tgr128", 2383 .alg = "tgr128",
2383 .test = alg_test_hash, 2384 .test = alg_test_hash,
2384 .suite = { 2385 .suite = {
2385 .hash = { 2386 .hash = {
2386 .vecs = tgr128_tv_template, 2387 .vecs = tgr128_tv_template,
2387 .count = TGR128_TEST_VECTORS 2388 .count = TGR128_TEST_VECTORS
2388 } 2389 }
2389 } 2390 }
2390 }, { 2391 }, {
2391 .alg = "tgr160", 2392 .alg = "tgr160",
2392 .test = alg_test_hash, 2393 .test = alg_test_hash,
2393 .suite = { 2394 .suite = {
2394 .hash = { 2395 .hash = {
2395 .vecs = tgr160_tv_template, 2396 .vecs = tgr160_tv_template,
2396 .count = TGR160_TEST_VECTORS 2397 .count = TGR160_TEST_VECTORS
2397 } 2398 }
2398 } 2399 }
2399 }, { 2400 }, {
2400 .alg = "tgr192", 2401 .alg = "tgr192",
2401 .test = alg_test_hash, 2402 .test = alg_test_hash,
2402 .suite = { 2403 .suite = {
2403 .hash = { 2404 .hash = {
2404 .vecs = tgr192_tv_template, 2405 .vecs = tgr192_tv_template,
2405 .count = TGR192_TEST_VECTORS 2406 .count = TGR192_TEST_VECTORS
2406 } 2407 }
2407 } 2408 }
2408 }, { 2409 }, {
2409 .alg = "vmac(aes)", 2410 .alg = "vmac(aes)",
2410 .test = alg_test_hash, 2411 .test = alg_test_hash,
2411 .suite = { 2412 .suite = {
2412 .hash = { 2413 .hash = {
2413 .vecs = aes_vmac128_tv_template, 2414 .vecs = aes_vmac128_tv_template,
2414 .count = VMAC_AES_TEST_VECTORS 2415 .count = VMAC_AES_TEST_VECTORS
2415 } 2416 }
2416 } 2417 }
2417 }, { 2418 }, {
2418 .alg = "wp256", 2419 .alg = "wp256",
2419 .test = alg_test_hash, 2420 .test = alg_test_hash,
2420 .suite = { 2421 .suite = {
2421 .hash = { 2422 .hash = {
2422 .vecs = wp256_tv_template, 2423 .vecs = wp256_tv_template,
2423 .count = WP256_TEST_VECTORS 2424 .count = WP256_TEST_VECTORS
2424 } 2425 }
2425 } 2426 }
2426 }, { 2427 }, {
2427 .alg = "wp384", 2428 .alg = "wp384",
2428 .test = alg_test_hash, 2429 .test = alg_test_hash,
2429 .suite = { 2430 .suite = {
2430 .hash = { 2431 .hash = {
2431 .vecs = wp384_tv_template, 2432 .vecs = wp384_tv_template,
2432 .count = WP384_TEST_VECTORS 2433 .count = WP384_TEST_VECTORS
2433 } 2434 }
2434 } 2435 }
2435 }, { 2436 }, {
2436 .alg = "wp512", 2437 .alg = "wp512",
2437 .test = alg_test_hash, 2438 .test = alg_test_hash,
2438 .suite = { 2439 .suite = {
2439 .hash = { 2440 .hash = {
2440 .vecs = wp512_tv_template, 2441 .vecs = wp512_tv_template,
2441 .count = WP512_TEST_VECTORS 2442 .count = WP512_TEST_VECTORS
2442 } 2443 }
2443 } 2444 }
2444 }, { 2445 }, {
2445 .alg = "xcbc(aes)", 2446 .alg = "xcbc(aes)",
2446 .test = alg_test_hash, 2447 .test = alg_test_hash,
2447 .suite = { 2448 .suite = {
2448 .hash = { 2449 .hash = {
2449 .vecs = aes_xcbc128_tv_template, 2450 .vecs = aes_xcbc128_tv_template,
2450 .count = XCBC_AES_TEST_VECTORS 2451 .count = XCBC_AES_TEST_VECTORS
2451 } 2452 }
2452 } 2453 }
2453 }, { 2454 }, {
2454 .alg = "xts(aes)", 2455 .alg = "xts(aes)",
2455 .test = alg_test_skcipher, 2456 .test = alg_test_skcipher,
2456 .fips_allowed = 1, 2457 .fips_allowed = 1,
2457 .suite = { 2458 .suite = {
2458 .cipher = { 2459 .cipher = {
2459 .enc = { 2460 .enc = {
2460 .vecs = aes_xts_enc_tv_template, 2461 .vecs = aes_xts_enc_tv_template,
2461 .count = AES_XTS_ENC_TEST_VECTORS 2462 .count = AES_XTS_ENC_TEST_VECTORS
2462 }, 2463 },
2463 .dec = { 2464 .dec = {
2464 .vecs = aes_xts_dec_tv_template, 2465 .vecs = aes_xts_dec_tv_template,
2465 .count = AES_XTS_DEC_TEST_VECTORS 2466 .count = AES_XTS_DEC_TEST_VECTORS
2466 } 2467 }
2467 } 2468 }
2468 } 2469 }
2469 }, { 2470 }, {
2470 .alg = "zlib", 2471 .alg = "zlib",
2471 .test = alg_test_pcomp, 2472 .test = alg_test_pcomp,
2472 .suite = { 2473 .suite = {
2473 .pcomp = { 2474 .pcomp = {
2474 .comp = { 2475 .comp = {
2475 .vecs = zlib_comp_tv_template, 2476 .vecs = zlib_comp_tv_template,
2476 .count = ZLIB_COMP_TEST_VECTORS 2477 .count = ZLIB_COMP_TEST_VECTORS
2477 }, 2478 },
2478 .decomp = { 2479 .decomp = {
2479 .vecs = zlib_decomp_tv_template, 2480 .vecs = zlib_decomp_tv_template,
2480 .count = ZLIB_DECOMP_TEST_VECTORS 2481 .count = ZLIB_DECOMP_TEST_VECTORS
2481 } 2482 }
2482 } 2483 }
2483 } 2484 }
2484 } 2485 }
2485 }; 2486 };
2486 2487
2487 static int alg_find_test(const char *alg) 2488 static int alg_find_test(const char *alg)
2488 { 2489 {
2489 int start = 0; 2490 int start = 0;
2490 int end = ARRAY_SIZE(alg_test_descs); 2491 int end = ARRAY_SIZE(alg_test_descs);
2491 2492
2492 while (start < end) { 2493 while (start < end) {
2493 int i = (start + end) / 2; 2494 int i = (start + end) / 2;
2494 int diff = strcmp(alg_test_descs[i].alg, alg); 2495 int diff = strcmp(alg_test_descs[i].alg, alg);
2495 2496
2496 if (diff > 0) { 2497 if (diff > 0) {
2497 end = i; 2498 end = i;
2498 continue; 2499 continue;
2499 } 2500 }
2500 2501
2501 if (diff < 0) { 2502 if (diff < 0) {
2502 start = i + 1; 2503 start = i + 1;
2503 continue; 2504 continue;
2504 } 2505 }
2505 2506
2506 return i; 2507 return i;
2507 } 2508 }
2508 2509
2509 return -1; 2510 return -1;
2510 } 2511 }
2511 2512
2512 int alg_test(const char *driver, const char *alg, u32 type, u32 mask) 2513 int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
2513 { 2514 {
2514 int i; 2515 int i;
2515 int j; 2516 int j;
2516 int rc; 2517 int rc;
2517 2518
2518 if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) { 2519 if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
2519 char nalg[CRYPTO_MAX_ALG_NAME]; 2520 char nalg[CRYPTO_MAX_ALG_NAME];
2520 2521
2521 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >= 2522 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
2522 sizeof(nalg)) 2523 sizeof(nalg))
2523 return -ENAMETOOLONG; 2524 return -ENAMETOOLONG;
2524 2525
2525 i = alg_find_test(nalg); 2526 i = alg_find_test(nalg);
2526 if (i < 0) 2527 if (i < 0)
2527 goto notest; 2528 goto notest;
2528 2529
2529 if (fips_enabled && !alg_test_descs[i].fips_allowed) 2530 if (fips_enabled && !alg_test_descs[i].fips_allowed)
2530 goto non_fips_alg; 2531 goto non_fips_alg;
2531 2532
2532 rc = alg_test_cipher(alg_test_descs + i, driver, type, mask); 2533 rc = alg_test_cipher(alg_test_descs + i, driver, type, mask);
2533 goto test_done; 2534 goto test_done;
2534 } 2535 }
2535 2536
2536 i = alg_find_test(alg); 2537 i = alg_find_test(alg);
2537 j = alg_find_test(driver); 2538 j = alg_find_test(driver);
2538 if (i < 0 && j < 0) 2539 if (i < 0 && j < 0)
2539 goto notest; 2540 goto notest;
2540 2541
2541 if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) || 2542 if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) ||
2542 (j >= 0 && !alg_test_descs[j].fips_allowed))) 2543 (j >= 0 && !alg_test_descs[j].fips_allowed)))
2543 goto non_fips_alg; 2544 goto non_fips_alg;
2544 2545
2545 rc = 0; 2546 rc = 0;
2546 if (i >= 0) 2547 if (i >= 0)
2547 rc |= alg_test_descs[i].test(alg_test_descs + i, driver, 2548 rc |= alg_test_descs[i].test(alg_test_descs + i, driver,
2548 type, mask); 2549 type, mask);
2549 if (j >= 0) 2550 if (j >= 0)
2550 rc |= alg_test_descs[j].test(alg_test_descs + j, driver, 2551 rc |= alg_test_descs[j].test(alg_test_descs + j, driver,
2551 type, mask); 2552 type, mask);
2552 2553
2553 test_done: 2554 test_done:
2554 if (fips_enabled && rc) 2555 if (fips_enabled && rc)
2555 panic("%s: %s alg self test failed in fips mode!\n", driver, alg); 2556 panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
2556 2557
2557 if (fips_enabled && !rc) 2558 if (fips_enabled && !rc)
2558 printk(KERN_INFO "alg: self-tests for %s (%s) passed\n", 2559 printk(KERN_INFO "alg: self-tests for %s (%s) passed\n",
2559 driver, alg); 2560 driver, alg);
2560 2561
2561 return rc; 2562 return rc;
2562 2563
2563 notest: 2564 notest:
2564 printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver); 2565 printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
2565 return 0; 2566 return 0;
2566 non_fips_alg: 2567 non_fips_alg:
2567 return -EINVAL; 2568 return -EINVAL;
2568 } 2569 }
2569 2570
2570 #endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */ 2571 #endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */
2571 2572
2572 EXPORT_SYMBOL_GPL(alg_test); 2573 EXPORT_SYMBOL_GPL(alg_test);
2573 2574