Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 08d6af8c160b6bd9b21a3177e2b1bebc72a21041

Authored by Jussi Kivilinna
Committed by Herbert Xu
1 parent 549595a0c7
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

crypto: testmgr - make test_skcipher also test 'dst != src' code paths 

Currrently test_skcipher uses same buffer for destination and source. However
in any places, 'dst != src' take different path than 'dst == src' case.

Therefore make test_skcipher also run tests with destination buffer being
different than source buffer.

Signed-off-by: Jussi Kivilinna <jussi.kivilinna@mbnet.fi>
Acked-by: David S. Miller <davem@davemloft.net>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

Showing 1 changed file with 76 additions and 31 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 const bool diff_dst)
766 { 767 {
767 const char *algo = 768 const char *algo =
768 crypto_tfm_alg_driver_name(crypto_ablkcipher_tfm(tfm)); 769 crypto_tfm_alg_driver_name(crypto_ablkcipher_tfm(tfm));
769 unsigned int i, j, k, n, temp; 770 unsigned int i, j, k, n, temp;
770 char *q; 771 char *q;
771 struct ablkcipher_request *req; 772 struct ablkcipher_request *req;
772 struct scatterlist sg[8]; 773 struct scatterlist sg[8];
773 const char *e; 774 struct scatterlist sgout[8];
775 const char *e, *d;
774 struct tcrypt_result result; 776 struct tcrypt_result result;
775 void *data; 777 void *data;
776 char iv[MAX_IVLEN]; 778 char iv[MAX_IVLEN];
777 char *xbuf[XBUFSIZE]; 779 char *xbuf[XBUFSIZE];
780 char *xoutbuf[XBUFSIZE];
778 int ret = -ENOMEM; 781 int ret = -ENOMEM;
779 782
780 if (testmgr_alloc_buf(xbuf)) 783 if (testmgr_alloc_buf(xbuf))
781 goto out_nobuf; 784 goto out_nobuf;
782 785
786 if (diff_dst && testmgr_alloc_buf(xoutbuf))
787 goto out_nooutbuf;
788
789 if (diff_dst)
790 d = "-ddst";
791 else
792 d = "";
793
783 if (enc == ENCRYPT) 794 if (enc == ENCRYPT)
784 e = "encryption"; 795 e = "encryption";
785 else 796 else
786 e = "decryption"; 797 e = "decryption";
787 798
788 init_completion(&result.completion); 799 init_completion(&result.completion);
789 800
790 req = ablkcipher_request_alloc(tfm, GFP_KERNEL); 801 req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
791 if (!req) { 802 if (!req) {
792 printk(KERN_ERR "alg: skcipher: Failed to allocate request " 803 pr_err("alg: skcipher%s: Failed to allocate request for %s\n",
793 "for %s\n", algo); 804 d, algo);
794 goto out; 805 goto out;
795 } 806 }
796 807
797 ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 808 ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
798 tcrypt_complete, &result); 809 tcrypt_complete, &result);
799 810
800 j = 0; 811 j = 0;
801 for (i = 0; i < tcount; i++) { 812 for (i = 0; i < tcount; i++) {
802 if (template[i].iv) 813 if (template[i].iv)
803 memcpy(iv, template[i].iv, MAX_IVLEN); 814 memcpy(iv, template[i].iv, MAX_IVLEN);
804 else 815 else
805 memset(iv, 0, MAX_IVLEN); 816 memset(iv, 0, MAX_IVLEN);
806 817
807 if (!(template[i].np) || (template[i].also_non_np)) { 818 if (!(template[i].np) || (template[i].also_non_np)) {
808 j++; 819 j++;
809 820
810 ret = -EINVAL; 821 ret = -EINVAL;
811 if (WARN_ON(template[i].ilen > PAGE_SIZE)) 822 if (WARN_ON(template[i].ilen > PAGE_SIZE))
812 goto out; 823 goto out;
813 824
814 data = xbuf[0]; 825 data = xbuf[0];
815 memcpy(data, template[i].input, template[i].ilen); 826 memcpy(data, template[i].input, template[i].ilen);
816 827
817 crypto_ablkcipher_clear_flags(tfm, ~0); 828 crypto_ablkcipher_clear_flags(tfm, ~0);
818 if (template[i].wk) 829 if (template[i].wk)
819 crypto_ablkcipher_set_flags( 830 crypto_ablkcipher_set_flags(
820 tfm, CRYPTO_TFM_REQ_WEAK_KEY); 831 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
821 832
822 ret = crypto_ablkcipher_setkey(tfm, template[i].key, 833 ret = crypto_ablkcipher_setkey(tfm, template[i].key,
823 template[i].klen); 834 template[i].klen);
824 if (!ret == template[i].fail) { 835 if (!ret == template[i].fail) {
825 printk(KERN_ERR "alg: skcipher: setkey failed " 836 pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n",
826 "on test %d for %s: flags=%x\n", j, 837 d, j, algo,
827 algo, crypto_ablkcipher_get_flags(tfm)); 838 crypto_ablkcipher_get_flags(tfm));
828 goto out; 839 goto out;
829 } else if (ret) 840 } else if (ret)
830 continue; 841 continue;
831 842
832 sg_init_one(&sg[0], data, template[i].ilen); 843 sg_init_one(&sg[0], data, template[i].ilen);
844 if (diff_dst) {
845 data = xoutbuf[0];
846 sg_init_one(&sgout[0], data, template[i].ilen);
847 }
833 848
834 ablkcipher_request_set_crypt(req, sg, sg, 849 ablkcipher_request_set_crypt(req, sg,
850 (diff_dst) ? sgout : sg,
835 template[i].ilen, iv); 851 template[i].ilen, iv);
836 ret = enc ? 852 ret = enc ?
837 crypto_ablkcipher_encrypt(req) : 853 crypto_ablkcipher_encrypt(req) :
838 crypto_ablkcipher_decrypt(req); 854 crypto_ablkcipher_decrypt(req);
839 855
840 switch (ret) { 856 switch (ret) {
841 case 0: 857 case 0:
842 break; 858 break;
843 case -EINPROGRESS: 859 case -EINPROGRESS:
844 case -EBUSY: 860 case -EBUSY:
845 ret = wait_for_completion_interruptible( 861 ret = wait_for_completion_interruptible(
846 &result.completion); 862 &result.completion);
847 if (!ret && !((ret = result.err))) { 863 if (!ret && !((ret = result.err))) {
848 INIT_COMPLETION(result.completion); 864 INIT_COMPLETION(result.completion);
849 break; 865 break;
850 } 866 }
851 /* fall through */ 867 /* fall through */
852 default: 868 default:
853 printk(KERN_ERR "alg: skcipher: %s failed on " 869 pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n",
854 "test %d for %s: ret=%d\n", e, j, algo, 870 d, e, j, algo, -ret);
855 -ret);
856 goto out; 871 goto out;
857 } 872 }
858 873
859 q = data; 874 q = data;
860 if (memcmp(q, template[i].result, template[i].rlen)) { 875 if (memcmp(q, template[i].result, template[i].rlen)) {
861 printk(KERN_ERR "alg: skcipher: Test %d " 876 pr_err("alg: skcipher%s: Test %d failed on %s for %s\n",
862 "failed on %s for %s\n", j, e, algo); 877 d, j, e, algo);
863 hexdump(q, template[i].rlen); 878 hexdump(q, template[i].rlen);
864 ret = -EINVAL; 879 ret = -EINVAL;
865 goto out; 880 goto out;
866 } 881 }
867 } 882 }
868 } 883 }
869 884
870 j = 0; 885 j = 0;
871 for (i = 0; i < tcount; i++) { 886 for (i = 0; i < tcount; i++) {
872 887
873 if (template[i].iv) 888 if (template[i].iv)
874 memcpy(iv, template[i].iv, MAX_IVLEN); 889 memcpy(iv, template[i].iv, MAX_IVLEN);
875 else 890 else
876 memset(iv, 0, MAX_IVLEN); 891 memset(iv, 0, MAX_IVLEN);
877 892
878 if (template[i].np) { 893 if (template[i].np) {
879 j++; 894 j++;
880 895
881 crypto_ablkcipher_clear_flags(tfm, ~0); 896 crypto_ablkcipher_clear_flags(tfm, ~0);
882 if (template[i].wk) 897 if (template[i].wk)
883 crypto_ablkcipher_set_flags( 898 crypto_ablkcipher_set_flags(
884 tfm, CRYPTO_TFM_REQ_WEAK_KEY); 899 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
885 900
886 ret = crypto_ablkcipher_setkey(tfm, template[i].key, 901 ret = crypto_ablkcipher_setkey(tfm, template[i].key,
887 template[i].klen); 902 template[i].klen);
888 if (!ret == template[i].fail) { 903 if (!ret == template[i].fail) {
889 printk(KERN_ERR "alg: skcipher: setkey failed " 904 pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n",
890 "on chunk test %d for %s: flags=%x\n", 905 d, j, algo,
891 j, algo,
892 crypto_ablkcipher_get_flags(tfm)); 906 crypto_ablkcipher_get_flags(tfm));
893 goto out; 907 goto out;
894 } else if (ret) 908 } else if (ret)
895 continue; 909 continue;
896 910
897 temp = 0; 911 temp = 0;
898 ret = -EINVAL; 912 ret = -EINVAL;
899 sg_init_table(sg, template[i].np); 913 sg_init_table(sg, template[i].np);
914 if (diff_dst)
915 sg_init_table(sgout, template[i].np);
900 for (k = 0; k < template[i].np; k++) { 916 for (k = 0; k < template[i].np; k++) {
901 if (WARN_ON(offset_in_page(IDX[k]) + 917 if (WARN_ON(offset_in_page(IDX[k]) +
902 template[i].tap[k] > PAGE_SIZE)) 918 template[i].tap[k] > PAGE_SIZE))
903 goto out; 919 goto out;
904 920
905 q = xbuf[IDX[k] >> PAGE_SHIFT] + 921 q = xbuf[IDX[k] >> PAGE_SHIFT] +
906 offset_in_page(IDX[k]); 922 offset_in_page(IDX[k]);
907 923
908 memcpy(q, template[i].input + temp, 924 memcpy(q, template[i].input + temp,
909 template[i].tap[k]); 925 template[i].tap[k]);
910 926
911 if (offset_in_page(q) + template[i].tap[k] < 927 if (offset_in_page(q) + template[i].tap[k] <
912 PAGE_SIZE) 928 PAGE_SIZE)
913 q[template[i].tap[k]] = 0; 929 q[template[i].tap[k]] = 0;
914 930
915 sg_set_buf(&sg[k], q, template[i].tap[k]); 931 sg_set_buf(&sg[k], q, template[i].tap[k]);
932 if (diff_dst) {
933 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
934 offset_in_page(IDX[k]);
916 935
936 sg_set_buf(&sgout[k], q,
937 template[i].tap[k]);
938
939 memset(q, 0, template[i].tap[k]);
940 if (offset_in_page(q) +
941 template[i].tap[k] < PAGE_SIZE)
942 q[template[i].tap[k]] = 0;
943 }
944
917 temp += template[i].tap[k]; 945 temp += template[i].tap[k];
918 } 946 }
919 947
920 ablkcipher_request_set_crypt(req, sg, sg, 948 ablkcipher_request_set_crypt(req, sg,
949 (diff_dst) ? sgout : sg,
921 template[i].ilen, iv); 950 template[i].ilen, iv);
922 951
923 ret = enc ? 952 ret = enc ?
924 crypto_ablkcipher_encrypt(req) : 953 crypto_ablkcipher_encrypt(req) :
925 crypto_ablkcipher_decrypt(req); 954 crypto_ablkcipher_decrypt(req);
926 955
927 switch (ret) { 956 switch (ret) {
928 case 0: 957 case 0:
929 break; 958 break;
930 case -EINPROGRESS: 959 case -EINPROGRESS:
931 case -EBUSY: 960 case -EBUSY:
932 ret = wait_for_completion_interruptible( 961 ret = wait_for_completion_interruptible(
933 &result.completion); 962 &result.completion);
934 if (!ret && !((ret = result.err))) { 963 if (!ret && !((ret = result.err))) {
935 INIT_COMPLETION(result.completion); 964 INIT_COMPLETION(result.completion);
936 break; 965 break;
937 } 966 }
938 /* fall through */ 967 /* fall through */
939 default: 968 default:
940 printk(KERN_ERR "alg: skcipher: %s failed on " 969 pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n",
941 "chunk test %d for %s: ret=%d\n", e, j, 970 d, e, j, algo, -ret);
942 algo, -ret);
943 goto out; 971 goto out;
944 } 972 }
945 973
946 temp = 0; 974 temp = 0;
947 ret = -EINVAL; 975 ret = -EINVAL;
948 for (k = 0; k < template[i].np; k++) { 976 for (k = 0; k < template[i].np; k++) {
949 q = xbuf[IDX[k] >> PAGE_SHIFT] + 977 if (diff_dst)
950 offset_in_page(IDX[k]); 978 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
979 offset_in_page(IDX[k]);
980 else
981 q = xbuf[IDX[k] >> PAGE_SHIFT] +
982 offset_in_page(IDX[k]);
951 983
952 if (memcmp(q, template[i].result + temp, 984 if (memcmp(q, template[i].result + temp,
953 template[i].tap[k])) { 985 template[i].tap[k])) {
954 printk(KERN_ERR "alg: skcipher: Chunk " 986 pr_err("alg: skcipher%s: Chunk test %d failed on %s at page %u for %s\n",
955 "test %d failed on %s at page " 987 d, j, e, k, algo);
956 "%u for %s\n", j, e, k, algo);
957 hexdump(q, template[i].tap[k]); 988 hexdump(q, template[i].tap[k]);
958 goto out; 989 goto out;
959 } 990 }
960 991
961 q += template[i].tap[k]; 992 q += template[i].tap[k];
962 for (n = 0; offset_in_page(q + n) && q[n]; n++) 993 for (n = 0; offset_in_page(q + n) && q[n]; n++)
963 ; 994 ;
964 if (n) { 995 if (n) {
965 printk(KERN_ERR "alg: skcipher: " 996 pr_err("alg: skcipher%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
966 "Result buffer corruption in " 997 d, j, e, k, algo, n);
967 "chunk test %d on %s at page "
968 "%u for %s: %u bytes:\n", j, e,
969 k, algo, n);
970 hexdump(q, n); 998 hexdump(q, n);
971 goto out; 999 goto out;
972 } 1000 }
973 temp += template[i].tap[k]; 1001 temp += template[i].tap[k];
974 } 1002 }
975 } 1003 }
976 } 1004 }
977 1005
978 ret = 0; 1006 ret = 0;
979 1007
980 out: 1008 out:
981 ablkcipher_request_free(req); 1009 ablkcipher_request_free(req);
1010 if (diff_dst)
1011 testmgr_free_buf(xoutbuf);
1012 out_nooutbuf:
982 testmgr_free_buf(xbuf); 1013 testmgr_free_buf(xbuf);
983 out_nobuf: 1014 out_nobuf:
984 return ret; 1015 return ret;
1016 }
1017
1018 static int test_skcipher(struct crypto_ablkcipher *tfm, int enc,
1019 struct cipher_testvec *template, unsigned int tcount)
1020 {
1021 int ret;
1022
1023 /* test 'dst == src' case */
1024 ret = __test_skcipher(tfm, enc, template, tcount, false);
1025 if (ret)
1026 return ret;
1027
1028 /* test 'dst != src' case */
1029 return __test_skcipher(tfm, enc, template, tcount, true);
985 } 1030 }
986 1031
987 static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate, 1032 static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate,
988 struct comp_testvec *dtemplate, int ctcount, int dtcount) 1033 struct comp_testvec *dtemplate, int ctcount, int dtcount)
989 { 1034 {
990 const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm)); 1035 const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
991 unsigned int i; 1036 unsigned int i;
992 char result[COMP_BUF_SIZE]; 1037 char result[COMP_BUF_SIZE];
993 int ret; 1038 int ret;
994 1039
995 for (i = 0; i < ctcount; i++) { 1040 for (i = 0; i < ctcount; i++) {
996 int ilen; 1041 int ilen;
997 unsigned int dlen = COMP_BUF_SIZE; 1042 unsigned int dlen = COMP_BUF_SIZE;
998 1043
999 memset(result, 0, sizeof (result)); 1044 memset(result, 0, sizeof (result));
1000 1045
1001 ilen = ctemplate[i].inlen; 1046 ilen = ctemplate[i].inlen;
1002 ret = crypto_comp_compress(tfm, ctemplate[i].input, 1047 ret = crypto_comp_compress(tfm, ctemplate[i].input,
1003 ilen, result, &dlen); 1048 ilen, result, &dlen);
1004 if (ret) { 1049 if (ret) {
1005 printk(KERN_ERR "alg: comp: compression failed " 1050 printk(KERN_ERR "alg: comp: compression failed "
1006 "on test %d for %s: ret=%d\n", i + 1, algo, 1051 "on test %d for %s: ret=%d\n", i + 1, algo,
1007 -ret); 1052 -ret);
1008 goto out; 1053 goto out;
1009 } 1054 }
1010 1055
1011 if (dlen != ctemplate[i].outlen) { 1056 if (dlen != ctemplate[i].outlen) {
1012 printk(KERN_ERR "alg: comp: Compression test %d " 1057 printk(KERN_ERR "alg: comp: Compression test %d "
1013 "failed for %s: output len = %d\n", i + 1, algo, 1058 "failed for %s: output len = %d\n", i + 1, algo,
1014 dlen); 1059 dlen);
1015 ret = -EINVAL; 1060 ret = -EINVAL;
1016 goto out; 1061 goto out;
1017 } 1062 }
1018 1063
1019 if (memcmp(result, ctemplate[i].output, dlen)) { 1064 if (memcmp(result, ctemplate[i].output, dlen)) {
1020 printk(KERN_ERR "alg: comp: Compression test %d " 1065 printk(KERN_ERR "alg: comp: Compression test %d "
1021 "failed for %s\n", i + 1, algo); 1066 "failed for %s\n", i + 1, algo);
1022 hexdump(result, dlen); 1067 hexdump(result, dlen);
1023 ret = -EINVAL; 1068 ret = -EINVAL;
1024 goto out; 1069 goto out;
1025 } 1070 }
1026 } 1071 }
1027 1072
1028 for (i = 0; i < dtcount; i++) { 1073 for (i = 0; i < dtcount; i++) {
1029 int ilen; 1074 int ilen;
1030 unsigned int dlen = COMP_BUF_SIZE; 1075 unsigned int dlen = COMP_BUF_SIZE;
1031 1076
1032 memset(result, 0, sizeof (result)); 1077 memset(result, 0, sizeof (result));
1033 1078
1034 ilen = dtemplate[i].inlen; 1079 ilen = dtemplate[i].inlen;
1035 ret = crypto_comp_decompress(tfm, dtemplate[i].input, 1080 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
1036 ilen, result, &dlen); 1081 ilen, result, &dlen);
1037 if (ret) { 1082 if (ret) {
1038 printk(KERN_ERR "alg: comp: decompression failed " 1083 printk(KERN_ERR "alg: comp: decompression failed "
1039 "on test %d for %s: ret=%d\n", i + 1, algo, 1084 "on test %d for %s: ret=%d\n", i + 1, algo,
1040 -ret); 1085 -ret);
1041 goto out; 1086 goto out;
1042 } 1087 }
1043 1088
1044 if (dlen != dtemplate[i].outlen) { 1089 if (dlen != dtemplate[i].outlen) {
1045 printk(KERN_ERR "alg: comp: Decompression test %d " 1090 printk(KERN_ERR "alg: comp: Decompression test %d "
1046 "failed for %s: output len = %d\n", i + 1, algo, 1091 "failed for %s: output len = %d\n", i + 1, algo,
1047 dlen); 1092 dlen);
1048 ret = -EINVAL; 1093 ret = -EINVAL;
1049 goto out; 1094 goto out;
1050 } 1095 }
1051 1096
1052 if (memcmp(result, dtemplate[i].output, dlen)) { 1097 if (memcmp(result, dtemplate[i].output, dlen)) {
1053 printk(KERN_ERR "alg: comp: Decompression test %d " 1098 printk(KERN_ERR "alg: comp: Decompression test %d "
1054 "failed for %s\n", i + 1, algo); 1099 "failed for %s\n", i + 1, algo);
1055 hexdump(result, dlen); 1100 hexdump(result, dlen);
1056 ret = -EINVAL; 1101 ret = -EINVAL;
1057 goto out; 1102 goto out;
1058 } 1103 }
1059 } 1104 }
1060 1105
1061 ret = 0; 1106 ret = 0;
1062 1107
1063 out: 1108 out:
1064 return ret; 1109 return ret;
1065 } 1110 }
1066 1111
1067 static int test_pcomp(struct crypto_pcomp *tfm, 1112 static int test_pcomp(struct crypto_pcomp *tfm,
1068 struct pcomp_testvec *ctemplate, 1113 struct pcomp_testvec *ctemplate,
1069 struct pcomp_testvec *dtemplate, int ctcount, 1114 struct pcomp_testvec *dtemplate, int ctcount,
1070 int dtcount) 1115 int dtcount)
1071 { 1116 {
1072 const char *algo = crypto_tfm_alg_driver_name(crypto_pcomp_tfm(tfm)); 1117 const char *algo = crypto_tfm_alg_driver_name(crypto_pcomp_tfm(tfm));
1073 unsigned int i; 1118 unsigned int i;
1074 char result[COMP_BUF_SIZE]; 1119 char result[COMP_BUF_SIZE];
1075 int res; 1120 int res;
1076 1121
1077 for (i = 0; i < ctcount; i++) { 1122 for (i = 0; i < ctcount; i++) {
1078 struct comp_request req; 1123 struct comp_request req;
1079 unsigned int produced = 0; 1124 unsigned int produced = 0;
1080 1125
1081 res = crypto_compress_setup(tfm, ctemplate[i].params, 1126 res = crypto_compress_setup(tfm, ctemplate[i].params,
1082 ctemplate[i].paramsize); 1127 ctemplate[i].paramsize);
1083 if (res) { 1128 if (res) {
1084 pr_err("alg: pcomp: compression setup failed on test " 1129 pr_err("alg: pcomp: compression setup failed on test "
1085 "%d for %s: error=%d\n", i + 1, algo, res); 1130 "%d for %s: error=%d\n", i + 1, algo, res);
1086 return res; 1131 return res;
1087 } 1132 }
1088 1133
1089 res = crypto_compress_init(tfm); 1134 res = crypto_compress_init(tfm);
1090 if (res) { 1135 if (res) {
1091 pr_err("alg: pcomp: compression init failed on test " 1136 pr_err("alg: pcomp: compression init failed on test "
1092 "%d for %s: error=%d\n", i + 1, algo, res); 1137 "%d for %s: error=%d\n", i + 1, algo, res);
1093 return res; 1138 return res;
1094 } 1139 }
1095 1140
1096 memset(result, 0, sizeof(result)); 1141 memset(result, 0, sizeof(result));
1097 1142
1098 req.next_in = ctemplate[i].input; 1143 req.next_in = ctemplate[i].input;
1099 req.avail_in = ctemplate[i].inlen / 2; 1144 req.avail_in = ctemplate[i].inlen / 2;
1100 req.next_out = result; 1145 req.next_out = result;
1101 req.avail_out = ctemplate[i].outlen / 2; 1146 req.avail_out = ctemplate[i].outlen / 2;
1102 1147
1103 res = crypto_compress_update(tfm, &req); 1148 res = crypto_compress_update(tfm, &req);
1104 if (res < 0 && (res != -EAGAIN || req.avail_in)) { 1149 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1105 pr_err("alg: pcomp: compression update failed on test " 1150 pr_err("alg: pcomp: compression update failed on test "
1106 "%d for %s: error=%d\n", i + 1, algo, res); 1151 "%d for %s: error=%d\n", i + 1, algo, res);
1107 return res; 1152 return res;
1108 } 1153 }
1109 if (res > 0) 1154 if (res > 0)
1110 produced += res; 1155 produced += res;
1111 1156
1112 /* Add remaining input data */ 1157 /* Add remaining input data */
1113 req.avail_in += (ctemplate[i].inlen + 1) / 2; 1158 req.avail_in += (ctemplate[i].inlen + 1) / 2;
1114 1159
1115 res = crypto_compress_update(tfm, &req); 1160 res = crypto_compress_update(tfm, &req);
1116 if (res < 0 && (res != -EAGAIN || req.avail_in)) { 1161 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1117 pr_err("alg: pcomp: compression update failed on test " 1162 pr_err("alg: pcomp: compression update failed on test "
1118 "%d for %s: error=%d\n", i + 1, algo, res); 1163 "%d for %s: error=%d\n", i + 1, algo, res);
1119 return res; 1164 return res;
1120 } 1165 }
1121 if (res > 0) 1166 if (res > 0)
1122 produced += res; 1167 produced += res;
1123 1168
1124 /* Provide remaining output space */ 1169 /* Provide remaining output space */
1125 req.avail_out += COMP_BUF_SIZE - ctemplate[i].outlen / 2; 1170 req.avail_out += COMP_BUF_SIZE - ctemplate[i].outlen / 2;
1126 1171
1127 res = crypto_compress_final(tfm, &req); 1172 res = crypto_compress_final(tfm, &req);
1128 if (res < 0) { 1173 if (res < 0) {
1129 pr_err("alg: pcomp: compression final failed on test " 1174 pr_err("alg: pcomp: compression final failed on test "
1130 "%d for %s: error=%d\n", i + 1, algo, res); 1175 "%d for %s: error=%d\n", i + 1, algo, res);
1131 return res; 1176 return res;
1132 } 1177 }
1133 produced += res; 1178 produced += res;
1134 1179
1135 if (COMP_BUF_SIZE - req.avail_out != ctemplate[i].outlen) { 1180 if (COMP_BUF_SIZE - req.avail_out != ctemplate[i].outlen) {
1136 pr_err("alg: comp: Compression test %d failed for %s: " 1181 pr_err("alg: comp: Compression test %d failed for %s: "
1137 "output len = %d (expected %d)\n", i + 1, algo, 1182 "output len = %d (expected %d)\n", i + 1, algo,
1138 COMP_BUF_SIZE - req.avail_out, 1183 COMP_BUF_SIZE - req.avail_out,
1139 ctemplate[i].outlen); 1184 ctemplate[i].outlen);
1140 return -EINVAL; 1185 return -EINVAL;
1141 } 1186 }
1142 1187
1143 if (produced != ctemplate[i].outlen) { 1188 if (produced != ctemplate[i].outlen) {
1144 pr_err("alg: comp: Compression test %d failed for %s: " 1189 pr_err("alg: comp: Compression test %d failed for %s: "
1145 "returned len = %u (expected %d)\n", i + 1, 1190 "returned len = %u (expected %d)\n", i + 1,
1146 algo, produced, ctemplate[i].outlen); 1191 algo, produced, ctemplate[i].outlen);
1147 return -EINVAL; 1192 return -EINVAL;
1148 } 1193 }
1149 1194
1150 if (memcmp(result, ctemplate[i].output, ctemplate[i].outlen)) { 1195 if (memcmp(result, ctemplate[i].output, ctemplate[i].outlen)) {
1151 pr_err("alg: pcomp: Compression test %d failed for " 1196 pr_err("alg: pcomp: Compression test %d failed for "
1152 "%s\n", i + 1, algo); 1197 "%s\n", i + 1, algo);
1153 hexdump(result, ctemplate[i].outlen); 1198 hexdump(result, ctemplate[i].outlen);
1154 return -EINVAL; 1199 return -EINVAL;
1155 } 1200 }
1156 } 1201 }
1157 1202
1158 for (i = 0; i < dtcount; i++) { 1203 for (i = 0; i < dtcount; i++) {
1159 struct comp_request req; 1204 struct comp_request req;
1160 unsigned int produced = 0; 1205 unsigned int produced = 0;
1161 1206
1162 res = crypto_decompress_setup(tfm, dtemplate[i].params, 1207 res = crypto_decompress_setup(tfm, dtemplate[i].params,
1163 dtemplate[i].paramsize); 1208 dtemplate[i].paramsize);
1164 if (res) { 1209 if (res) {
1165 pr_err("alg: pcomp: decompression setup failed on " 1210 pr_err("alg: pcomp: decompression setup failed on "
1166 "test %d for %s: error=%d\n", i + 1, algo, res); 1211 "test %d for %s: error=%d\n", i + 1, algo, res);
1167 return res; 1212 return res;
1168 } 1213 }
1169 1214
1170 res = crypto_decompress_init(tfm); 1215 res = crypto_decompress_init(tfm);
1171 if (res) { 1216 if (res) {
1172 pr_err("alg: pcomp: decompression init failed on test " 1217 pr_err("alg: pcomp: decompression init failed on test "
1173 "%d for %s: error=%d\n", i + 1, algo, res); 1218 "%d for %s: error=%d\n", i + 1, algo, res);
1174 return res; 1219 return res;
1175 } 1220 }
1176 1221
1177 memset(result, 0, sizeof(result)); 1222 memset(result, 0, sizeof(result));
1178 1223
1179 req.next_in = dtemplate[i].input; 1224 req.next_in = dtemplate[i].input;
1180 req.avail_in = dtemplate[i].inlen / 2; 1225 req.avail_in = dtemplate[i].inlen / 2;
1181 req.next_out = result; 1226 req.next_out = result;
1182 req.avail_out = dtemplate[i].outlen / 2; 1227 req.avail_out = dtemplate[i].outlen / 2;
1183 1228
1184 res = crypto_decompress_update(tfm, &req); 1229 res = crypto_decompress_update(tfm, &req);
1185 if (res < 0 && (res != -EAGAIN || req.avail_in)) { 1230 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1186 pr_err("alg: pcomp: decompression update failed on " 1231 pr_err("alg: pcomp: decompression update failed on "
1187 "test %d for %s: error=%d\n", i + 1, algo, res); 1232 "test %d for %s: error=%d\n", i + 1, algo, res);
1188 return res; 1233 return res;
1189 } 1234 }
1190 if (res > 0) 1235 if (res > 0)
1191 produced += res; 1236 produced += res;
1192 1237
1193 /* Add remaining input data */ 1238 /* Add remaining input data */
1194 req.avail_in += (dtemplate[i].inlen + 1) / 2; 1239 req.avail_in += (dtemplate[i].inlen + 1) / 2;
1195 1240
1196 res = crypto_decompress_update(tfm, &req); 1241 res = crypto_decompress_update(tfm, &req);
1197 if (res < 0 && (res != -EAGAIN || req.avail_in)) { 1242 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1198 pr_err("alg: pcomp: decompression update failed on " 1243 pr_err("alg: pcomp: decompression update failed on "
1199 "test %d for %s: error=%d\n", i + 1, algo, res); 1244 "test %d for %s: error=%d\n", i + 1, algo, res);
1200 return res; 1245 return res;
1201 } 1246 }
1202 if (res > 0) 1247 if (res > 0)
1203 produced += res; 1248 produced += res;
1204 1249
1205 /* Provide remaining output space */ 1250 /* Provide remaining output space */
1206 req.avail_out += COMP_BUF_SIZE - dtemplate[i].outlen / 2; 1251 req.avail_out += COMP_BUF_SIZE - dtemplate[i].outlen / 2;
1207 1252
1208 res = crypto_decompress_final(tfm, &req); 1253 res = crypto_decompress_final(tfm, &req);
1209 if (res < 0 && (res != -EAGAIN || req.avail_in)) { 1254 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1210 pr_err("alg: pcomp: decompression final failed on " 1255 pr_err("alg: pcomp: decompression final failed on "
1211 "test %d for %s: error=%d\n", i + 1, algo, res); 1256 "test %d for %s: error=%d\n", i + 1, algo, res);
1212 return res; 1257 return res;
1213 } 1258 }
1214 if (res > 0) 1259 if (res > 0)
1215 produced += res; 1260 produced += res;
1216 1261
1217 if (COMP_BUF_SIZE - req.avail_out != dtemplate[i].outlen) { 1262 if (COMP_BUF_SIZE - req.avail_out != dtemplate[i].outlen) {
1218 pr_err("alg: comp: Decompression test %d failed for " 1263 pr_err("alg: comp: Decompression test %d failed for "
1219 "%s: output len = %d (expected %d)\n", i + 1, 1264 "%s: output len = %d (expected %d)\n", i + 1,
1220 algo, COMP_BUF_SIZE - req.avail_out, 1265 algo, COMP_BUF_SIZE - req.avail_out,
1221 dtemplate[i].outlen); 1266 dtemplate[i].outlen);
1222 return -EINVAL; 1267 return -EINVAL;
1223 } 1268 }
1224 1269
1225 if (produced != dtemplate[i].outlen) { 1270 if (produced != dtemplate[i].outlen) {
1226 pr_err("alg: comp: Decompression test %d failed for " 1271 pr_err("alg: comp: Decompression test %d failed for "
1227 "%s: returned len = %u (expected %d)\n", i + 1, 1272 "%s: returned len = %u (expected %d)\n", i + 1,
1228 algo, produced, dtemplate[i].outlen); 1273 algo, produced, dtemplate[i].outlen);
1229 return -EINVAL; 1274 return -EINVAL;
1230 } 1275 }
1231 1276
1232 if (memcmp(result, dtemplate[i].output, dtemplate[i].outlen)) { 1277 if (memcmp(result, dtemplate[i].output, dtemplate[i].outlen)) {
1233 pr_err("alg: pcomp: Decompression test %d failed for " 1278 pr_err("alg: pcomp: Decompression test %d failed for "
1234 "%s\n", i + 1, algo); 1279 "%s\n", i + 1, algo);
1235 hexdump(result, dtemplate[i].outlen); 1280 hexdump(result, dtemplate[i].outlen);
1236 return -EINVAL; 1281 return -EINVAL;
1237 } 1282 }
1238 } 1283 }
1239 1284
1240 return 0; 1285 return 0;
1241 } 1286 }
1242 1287
1243 1288
1244 static int test_cprng(struct crypto_rng *tfm, struct cprng_testvec *template, 1289 static int test_cprng(struct crypto_rng *tfm, struct cprng_testvec *template,
1245 unsigned int tcount) 1290 unsigned int tcount)
1246 { 1291 {
1247 const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm)); 1292 const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
1248 int err = 0, i, j, seedsize; 1293 int err = 0, i, j, seedsize;
1249 u8 *seed; 1294 u8 *seed;
1250 char result[32]; 1295 char result[32];
1251 1296
1252 seedsize = crypto_rng_seedsize(tfm); 1297 seedsize = crypto_rng_seedsize(tfm);
1253 1298
1254 seed = kmalloc(seedsize, GFP_KERNEL); 1299 seed = kmalloc(seedsize, GFP_KERNEL);
1255 if (!seed) { 1300 if (!seed) {
1256 printk(KERN_ERR "alg: cprng: Failed to allocate seed space " 1301 printk(KERN_ERR "alg: cprng: Failed to allocate seed space "
1257 "for %s\n", algo); 1302 "for %s\n", algo);
1258 return -ENOMEM; 1303 return -ENOMEM;
1259 } 1304 }
1260 1305
1261 for (i = 0; i < tcount; i++) { 1306 for (i = 0; i < tcount; i++) {
1262 memset(result, 0, 32); 1307 memset(result, 0, 32);
1263 1308
1264 memcpy(seed, template[i].v, template[i].vlen); 1309 memcpy(seed, template[i].v, template[i].vlen);
1265 memcpy(seed + template[i].vlen, template[i].key, 1310 memcpy(seed + template[i].vlen, template[i].key,
1266 template[i].klen); 1311 template[i].klen);
1267 memcpy(seed + template[i].vlen + template[i].klen, 1312 memcpy(seed + template[i].vlen + template[i].klen,
1268 template[i].dt, template[i].dtlen); 1313 template[i].dt, template[i].dtlen);
1269 1314
1270 err = crypto_rng_reset(tfm, seed, seedsize); 1315 err = crypto_rng_reset(tfm, seed, seedsize);
1271 if (err) { 1316 if (err) {
1272 printk(KERN_ERR "alg: cprng: Failed to reset rng " 1317 printk(KERN_ERR "alg: cprng: Failed to reset rng "
1273 "for %s\n", algo); 1318 "for %s\n", algo);
1274 goto out; 1319 goto out;
1275 } 1320 }
1276 1321
1277 for (j = 0; j < template[i].loops; j++) { 1322 for (j = 0; j < template[i].loops; j++) {
1278 err = crypto_rng_get_bytes(tfm, result, 1323 err = crypto_rng_get_bytes(tfm, result,
1279 template[i].rlen); 1324 template[i].rlen);
1280 if (err != template[i].rlen) { 1325 if (err != template[i].rlen) {
1281 printk(KERN_ERR "alg: cprng: Failed to obtain " 1326 printk(KERN_ERR "alg: cprng: Failed to obtain "
1282 "the correct amount of random data for " 1327 "the correct amount of random data for "
1283 "%s (requested %d, got %d)\n", algo, 1328 "%s (requested %d, got %d)\n", algo,
1284 template[i].rlen, err); 1329 template[i].rlen, err);
1285 goto out; 1330 goto out;
1286 } 1331 }
1287 } 1332 }
1288 1333
1289 err = memcmp(result, template[i].result, 1334 err = memcmp(result, template[i].result,
1290 template[i].rlen); 1335 template[i].rlen);
1291 if (err) { 1336 if (err) {
1292 printk(KERN_ERR "alg: cprng: Test %d failed for %s\n", 1337 printk(KERN_ERR "alg: cprng: Test %d failed for %s\n",
1293 i, algo); 1338 i, algo);
1294 hexdump(result, template[i].rlen); 1339 hexdump(result, template[i].rlen);
1295 err = -EINVAL; 1340 err = -EINVAL;
1296 goto out; 1341 goto out;
1297 } 1342 }
1298 } 1343 }
1299 1344
1300 out: 1345 out:
1301 kfree(seed); 1346 kfree(seed);
1302 return err; 1347 return err;
1303 } 1348 }
1304 1349
1305 static int alg_test_aead(const struct alg_test_desc *desc, const char *driver, 1350 static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
1306 u32 type, u32 mask) 1351 u32 type, u32 mask)
1307 { 1352 {
1308 struct crypto_aead *tfm; 1353 struct crypto_aead *tfm;
1309 int err = 0; 1354 int err = 0;
1310 1355
1311 tfm = crypto_alloc_aead(driver, type, mask); 1356 tfm = crypto_alloc_aead(driver, type, mask);
1312 if (IS_ERR(tfm)) { 1357 if (IS_ERR(tfm)) {
1313 printk(KERN_ERR "alg: aead: Failed to load transform for %s: " 1358 printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
1314 "%ld\n", driver, PTR_ERR(tfm)); 1359 "%ld\n", driver, PTR_ERR(tfm));
1315 return PTR_ERR(tfm); 1360 return PTR_ERR(tfm);
1316 } 1361 }
1317 1362
1318 if (desc->suite.aead.enc.vecs) { 1363 if (desc->suite.aead.enc.vecs) {
1319 err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs, 1364 err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs,
1320 desc->suite.aead.enc.count); 1365 desc->suite.aead.enc.count);
1321 if (err) 1366 if (err)
1322 goto out; 1367 goto out;
1323 } 1368 }
1324 1369
1325 if (!err && desc->suite.aead.dec.vecs) 1370 if (!err && desc->suite.aead.dec.vecs)
1326 err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs, 1371 err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs,
1327 desc->suite.aead.dec.count); 1372 desc->suite.aead.dec.count);
1328 1373
1329 out: 1374 out:
1330 crypto_free_aead(tfm); 1375 crypto_free_aead(tfm);
1331 return err; 1376 return err;
1332 } 1377 }
1333 1378
1334 static int alg_test_cipher(const struct alg_test_desc *desc, 1379 static int alg_test_cipher(const struct alg_test_desc *desc,
1335 const char *driver, u32 type, u32 mask) 1380 const char *driver, u32 type, u32 mask)
1336 { 1381 {
1337 struct crypto_cipher *tfm; 1382 struct crypto_cipher *tfm;
1338 int err = 0; 1383 int err = 0;
1339 1384
1340 tfm = crypto_alloc_cipher(driver, type, mask); 1385 tfm = crypto_alloc_cipher(driver, type, mask);
1341 if (IS_ERR(tfm)) { 1386 if (IS_ERR(tfm)) {
1342 printk(KERN_ERR "alg: cipher: Failed to load transform for " 1387 printk(KERN_ERR "alg: cipher: Failed to load transform for "
1343 "%s: %ld\n", driver, PTR_ERR(tfm)); 1388 "%s: %ld\n", driver, PTR_ERR(tfm));
1344 return PTR_ERR(tfm); 1389 return PTR_ERR(tfm);
1345 } 1390 }
1346 1391
1347 if (desc->suite.cipher.enc.vecs) { 1392 if (desc->suite.cipher.enc.vecs) {
1348 err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs, 1393 err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1349 desc->suite.cipher.enc.count); 1394 desc->suite.cipher.enc.count);
1350 if (err) 1395 if (err)
1351 goto out; 1396 goto out;
1352 } 1397 }
1353 1398
1354 if (desc->suite.cipher.dec.vecs) 1399 if (desc->suite.cipher.dec.vecs)
1355 err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs, 1400 err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1356 desc->suite.cipher.dec.count); 1401 desc->suite.cipher.dec.count);
1357 1402
1358 out: 1403 out:
1359 crypto_free_cipher(tfm); 1404 crypto_free_cipher(tfm);
1360 return err; 1405 return err;
1361 } 1406 }
1362 1407
1363 static int alg_test_skcipher(const struct alg_test_desc *desc, 1408 static int alg_test_skcipher(const struct alg_test_desc *desc,
1364 const char *driver, u32 type, u32 mask) 1409 const char *driver, u32 type, u32 mask)
1365 { 1410 {
1366 struct crypto_ablkcipher *tfm; 1411 struct crypto_ablkcipher *tfm;
1367 int err = 0; 1412 int err = 0;
1368 1413
1369 tfm = crypto_alloc_ablkcipher(driver, type, mask); 1414 tfm = crypto_alloc_ablkcipher(driver, type, mask);
1370 if (IS_ERR(tfm)) { 1415 if (IS_ERR(tfm)) {
1371 printk(KERN_ERR "alg: skcipher: Failed to load transform for " 1416 printk(KERN_ERR "alg: skcipher: Failed to load transform for "
1372 "%s: %ld\n", driver, PTR_ERR(tfm)); 1417 "%s: %ld\n", driver, PTR_ERR(tfm));
1373 return PTR_ERR(tfm); 1418 return PTR_ERR(tfm);
1374 } 1419 }
1375 1420
1376 if (desc->suite.cipher.enc.vecs) { 1421 if (desc->suite.cipher.enc.vecs) {
1377 err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs, 1422 err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1378 desc->suite.cipher.enc.count); 1423 desc->suite.cipher.enc.count);
1379 if (err) 1424 if (err)
1380 goto out; 1425 goto out;
1381 } 1426 }
1382 1427
1383 if (desc->suite.cipher.dec.vecs) 1428 if (desc->suite.cipher.dec.vecs)
1384 err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs, 1429 err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1385 desc->suite.cipher.dec.count); 1430 desc->suite.cipher.dec.count);
1386 1431
1387 out: 1432 out:
1388 crypto_free_ablkcipher(tfm); 1433 crypto_free_ablkcipher(tfm);
1389 return err; 1434 return err;
1390 } 1435 }
1391 1436
1392 static int alg_test_comp(const struct alg_test_desc *desc, const char *driver, 1437 static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
1393 u32 type, u32 mask) 1438 u32 type, u32 mask)
1394 { 1439 {
1395 struct crypto_comp *tfm; 1440 struct crypto_comp *tfm;
1396 int err; 1441 int err;
1397 1442
1398 tfm = crypto_alloc_comp(driver, type, mask); 1443 tfm = crypto_alloc_comp(driver, type, mask);
1399 if (IS_ERR(tfm)) { 1444 if (IS_ERR(tfm)) {
1400 printk(KERN_ERR "alg: comp: Failed to load transform for %s: " 1445 printk(KERN_ERR "alg: comp: Failed to load transform for %s: "
1401 "%ld\n", driver, PTR_ERR(tfm)); 1446 "%ld\n", driver, PTR_ERR(tfm));
1402 return PTR_ERR(tfm); 1447 return PTR_ERR(tfm);
1403 } 1448 }
1404 1449
1405 err = test_comp(tfm, desc->suite.comp.comp.vecs, 1450 err = test_comp(tfm, desc->suite.comp.comp.vecs,
1406 desc->suite.comp.decomp.vecs, 1451 desc->suite.comp.decomp.vecs,
1407 desc->suite.comp.comp.count, 1452 desc->suite.comp.comp.count,
1408 desc->suite.comp.decomp.count); 1453 desc->suite.comp.decomp.count);
1409 1454
1410 crypto_free_comp(tfm); 1455 crypto_free_comp(tfm);
1411 return err; 1456 return err;
1412 } 1457 }
1413 1458
1414 static int alg_test_pcomp(const struct alg_test_desc *desc, const char *driver, 1459 static int alg_test_pcomp(const struct alg_test_desc *desc, const char *driver,
1415 u32 type, u32 mask) 1460 u32 type, u32 mask)
1416 { 1461 {
1417 struct crypto_pcomp *tfm; 1462 struct crypto_pcomp *tfm;
1418 int err; 1463 int err;
1419 1464
1420 tfm = crypto_alloc_pcomp(driver, type, mask); 1465 tfm = crypto_alloc_pcomp(driver, type, mask);
1421 if (IS_ERR(tfm)) { 1466 if (IS_ERR(tfm)) {
1422 pr_err("alg: pcomp: Failed to load transform for %s: %ld\n", 1467 pr_err("alg: pcomp: Failed to load transform for %s: %ld\n",
1423 driver, PTR_ERR(tfm)); 1468 driver, PTR_ERR(tfm));
1424 return PTR_ERR(tfm); 1469 return PTR_ERR(tfm);
1425 } 1470 }
1426 1471
1427 err = test_pcomp(tfm, desc->suite.pcomp.comp.vecs, 1472 err = test_pcomp(tfm, desc->suite.pcomp.comp.vecs,
1428 desc->suite.pcomp.decomp.vecs, 1473 desc->suite.pcomp.decomp.vecs,
1429 desc->suite.pcomp.comp.count, 1474 desc->suite.pcomp.comp.count,
1430 desc->suite.pcomp.decomp.count); 1475 desc->suite.pcomp.decomp.count);
1431 1476
1432 crypto_free_pcomp(tfm); 1477 crypto_free_pcomp(tfm);
1433 return err; 1478 return err;
1434 } 1479 }
1435 1480
1436 static int alg_test_hash(const struct alg_test_desc *desc, const char *driver, 1481 static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
1437 u32 type, u32 mask) 1482 u32 type, u32 mask)
1438 { 1483 {
1439 struct crypto_ahash *tfm; 1484 struct crypto_ahash *tfm;
1440 int err; 1485 int err;
1441 1486
1442 tfm = crypto_alloc_ahash(driver, type, mask); 1487 tfm = crypto_alloc_ahash(driver, type, mask);
1443 if (IS_ERR(tfm)) { 1488 if (IS_ERR(tfm)) {
1444 printk(KERN_ERR "alg: hash: Failed to load transform for %s: " 1489 printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
1445 "%ld\n", driver, PTR_ERR(tfm)); 1490 "%ld\n", driver, PTR_ERR(tfm));
1446 return PTR_ERR(tfm); 1491 return PTR_ERR(tfm);
1447 } 1492 }
1448 1493
1449 err = test_hash(tfm, desc->suite.hash.vecs, 1494 err = test_hash(tfm, desc->suite.hash.vecs,
1450 desc->suite.hash.count, true); 1495 desc->suite.hash.count, true);
1451 if (!err) 1496 if (!err)
1452 err = test_hash(tfm, desc->suite.hash.vecs, 1497 err = test_hash(tfm, desc->suite.hash.vecs,
1453 desc->suite.hash.count, false); 1498 desc->suite.hash.count, false);
1454 1499
1455 crypto_free_ahash(tfm); 1500 crypto_free_ahash(tfm);
1456 return err; 1501 return err;
1457 } 1502 }
1458 1503
1459 static int alg_test_crc32c(const struct alg_test_desc *desc, 1504 static int alg_test_crc32c(const struct alg_test_desc *desc,
1460 const char *driver, u32 type, u32 mask) 1505 const char *driver, u32 type, u32 mask)
1461 { 1506 {
1462 struct crypto_shash *tfm; 1507 struct crypto_shash *tfm;
1463 u32 val; 1508 u32 val;
1464 int err; 1509 int err;
1465 1510
1466 err = alg_test_hash(desc, driver, type, mask); 1511 err = alg_test_hash(desc, driver, type, mask);
1467 if (err) 1512 if (err)
1468 goto out; 1513 goto out;
1469 1514
1470 tfm = crypto_alloc_shash(driver, type, mask); 1515 tfm = crypto_alloc_shash(driver, type, mask);
1471 if (IS_ERR(tfm)) { 1516 if (IS_ERR(tfm)) {
1472 printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: " 1517 printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: "
1473 "%ld\n", driver, PTR_ERR(tfm)); 1518 "%ld\n", driver, PTR_ERR(tfm));
1474 err = PTR_ERR(tfm); 1519 err = PTR_ERR(tfm);
1475 goto out; 1520 goto out;
1476 } 1521 }
1477 1522
1478 do { 1523 do {
1479 struct { 1524 struct {
1480 struct shash_desc shash; 1525 struct shash_desc shash;
1481 char ctx[crypto_shash_descsize(tfm)]; 1526 char ctx[crypto_shash_descsize(tfm)];
1482 } sdesc; 1527 } sdesc;
1483 1528
1484 sdesc.shash.tfm = tfm; 1529 sdesc.shash.tfm = tfm;
1485 sdesc.shash.flags = 0; 1530 sdesc.shash.flags = 0;
1486 1531
1487 *(u32 *)sdesc.ctx = le32_to_cpu(420553207); 1532 *(u32 *)sdesc.ctx = le32_to_cpu(420553207);
1488 err = crypto_shash_final(&sdesc.shash, (u8 *)&val); 1533 err = crypto_shash_final(&sdesc.shash, (u8 *)&val);
1489 if (err) { 1534 if (err) {
1490 printk(KERN_ERR "alg: crc32c: Operation failed for " 1535 printk(KERN_ERR "alg: crc32c: Operation failed for "
1491 "%s: %d\n", driver, err); 1536 "%s: %d\n", driver, err);
1492 break; 1537 break;
1493 } 1538 }
1494 1539
1495 if (val != ~420553207) { 1540 if (val != ~420553207) {
1496 printk(KERN_ERR "alg: crc32c: Test failed for %s: " 1541 printk(KERN_ERR "alg: crc32c: Test failed for %s: "
1497 "%d\n", driver, val); 1542 "%d\n", driver, val);
1498 err = -EINVAL; 1543 err = -EINVAL;
1499 } 1544 }
1500 } while (0); 1545 } while (0);
1501 1546
1502 crypto_free_shash(tfm); 1547 crypto_free_shash(tfm);
1503 1548
1504 out: 1549 out:
1505 return err; 1550 return err;
1506 } 1551 }
1507 1552
1508 static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver, 1553 static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
1509 u32 type, u32 mask) 1554 u32 type, u32 mask)
1510 { 1555 {
1511 struct crypto_rng *rng; 1556 struct crypto_rng *rng;
1512 int err; 1557 int err;
1513 1558
1514 rng = crypto_alloc_rng(driver, type, mask); 1559 rng = crypto_alloc_rng(driver, type, mask);
1515 if (IS_ERR(rng)) { 1560 if (IS_ERR(rng)) {
1516 printk(KERN_ERR "alg: cprng: Failed to load transform for %s: " 1561 printk(KERN_ERR "alg: cprng: Failed to load transform for %s: "
1517 "%ld\n", driver, PTR_ERR(rng)); 1562 "%ld\n", driver, PTR_ERR(rng));
1518 return PTR_ERR(rng); 1563 return PTR_ERR(rng);
1519 } 1564 }
1520 1565
1521 err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count); 1566 err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count);
1522 1567
1523 crypto_free_rng(rng); 1568 crypto_free_rng(rng);
1524 1569
1525 return err; 1570 return err;
1526 } 1571 }
1527 1572
1528 static int alg_test_null(const struct alg_test_desc *desc, 1573 static int alg_test_null(const struct alg_test_desc *desc,
1529 const char *driver, u32 type, u32 mask) 1574 const char *driver, u32 type, u32 mask)
1530 { 1575 {
1531 return 0; 1576 return 0;
1532 } 1577 }
1533 1578
1534 /* Please keep this list sorted by algorithm name. */ 1579 /* Please keep this list sorted by algorithm name. */
1535 static const struct alg_test_desc alg_test_descs[] = { 1580 static const struct alg_test_desc alg_test_descs[] = {
1536 { 1581 {
1537 .alg = "__cbc-cast5-avx", 1582 .alg = "__cbc-cast5-avx",
1538 .test = alg_test_null, 1583 .test = alg_test_null,
1539 .suite = { 1584 .suite = {
1540 .cipher = { 1585 .cipher = {
1541 .enc = { 1586 .enc = {
1542 .vecs = NULL, 1587 .vecs = NULL,
1543 .count = 0 1588 .count = 0
1544 }, 1589 },
1545 .dec = { 1590 .dec = {
1546 .vecs = NULL, 1591 .vecs = NULL,
1547 .count = 0 1592 .count = 0
1548 } 1593 }
1549 } 1594 }
1550 } 1595 }
1551 }, { 1596 }, {
1552 .alg = "__cbc-cast6-avx", 1597 .alg = "__cbc-cast6-avx",
1553 .test = alg_test_null, 1598 .test = alg_test_null,
1554 .suite = { 1599 .suite = {
1555 .cipher = { 1600 .cipher = {
1556 .enc = { 1601 .enc = {
1557 .vecs = NULL, 1602 .vecs = NULL,
1558 .count = 0 1603 .count = 0
1559 }, 1604 },
1560 .dec = { 1605 .dec = {
1561 .vecs = NULL, 1606 .vecs = NULL,
1562 .count = 0 1607 .count = 0
1563 } 1608 }
1564 } 1609 }
1565 } 1610 }
1566 }, { 1611 }, {
1567 .alg = "__cbc-serpent-avx", 1612 .alg = "__cbc-serpent-avx",
1568 .test = alg_test_null, 1613 .test = alg_test_null,
1569 .suite = { 1614 .suite = {
1570 .cipher = { 1615 .cipher = {
1571 .enc = { 1616 .enc = {
1572 .vecs = NULL, 1617 .vecs = NULL,
1573 .count = 0 1618 .count = 0
1574 }, 1619 },
1575 .dec = { 1620 .dec = {
1576 .vecs = NULL, 1621 .vecs = NULL,
1577 .count = 0 1622 .count = 0
1578 } 1623 }
1579 } 1624 }
1580 } 1625 }
1581 }, { 1626 }, {
1582 .alg = "__cbc-serpent-sse2", 1627 .alg = "__cbc-serpent-sse2",
1583 .test = alg_test_null, 1628 .test = alg_test_null,
1584 .suite = { 1629 .suite = {
1585 .cipher = { 1630 .cipher = {
1586 .enc = { 1631 .enc = {
1587 .vecs = NULL, 1632 .vecs = NULL,
1588 .count = 0 1633 .count = 0
1589 }, 1634 },
1590 .dec = { 1635 .dec = {
1591 .vecs = NULL, 1636 .vecs = NULL,
1592 .count = 0 1637 .count = 0
1593 } 1638 }
1594 } 1639 }
1595 } 1640 }
1596 }, { 1641 }, {
1597 .alg = "__cbc-twofish-avx", 1642 .alg = "__cbc-twofish-avx",
1598 .test = alg_test_null, 1643 .test = alg_test_null,
1599 .suite = { 1644 .suite = {
1600 .cipher = { 1645 .cipher = {
1601 .enc = { 1646 .enc = {
1602 .vecs = NULL, 1647 .vecs = NULL,
1603 .count = 0 1648 .count = 0
1604 }, 1649 },
1605 .dec = { 1650 .dec = {
1606 .vecs = NULL, 1651 .vecs = NULL,
1607 .count = 0 1652 .count = 0
1608 } 1653 }
1609 } 1654 }
1610 } 1655 }
1611 }, { 1656 }, {
1612 .alg = "__driver-cbc-aes-aesni", 1657 .alg = "__driver-cbc-aes-aesni",
1613 .test = alg_test_null, 1658 .test = alg_test_null,
1614 .fips_allowed = 1, 1659 .fips_allowed = 1,
1615 .suite = { 1660 .suite = {
1616 .cipher = { 1661 .cipher = {
1617 .enc = { 1662 .enc = {
1618 .vecs = NULL, 1663 .vecs = NULL,
1619 .count = 0 1664 .count = 0
1620 }, 1665 },
1621 .dec = { 1666 .dec = {
1622 .vecs = NULL, 1667 .vecs = NULL,
1623 .count = 0 1668 .count = 0
1624 } 1669 }
1625 } 1670 }
1626 } 1671 }
1627 }, { 1672 }, {
1628 .alg = "__driver-cbc-cast5-avx", 1673 .alg = "__driver-cbc-cast5-avx",
1629 .test = alg_test_null, 1674 .test = alg_test_null,
1630 .suite = { 1675 .suite = {
1631 .cipher = { 1676 .cipher = {
1632 .enc = { 1677 .enc = {
1633 .vecs = NULL, 1678 .vecs = NULL,
1634 .count = 0 1679 .count = 0
1635 }, 1680 },
1636 .dec = { 1681 .dec = {
1637 .vecs = NULL, 1682 .vecs = NULL,
1638 .count = 0 1683 .count = 0
1639 } 1684 }
1640 } 1685 }
1641 } 1686 }
1642 }, { 1687 }, {
1643 .alg = "__driver-cbc-cast6-avx", 1688 .alg = "__driver-cbc-cast6-avx",
1644 .test = alg_test_null, 1689 .test = alg_test_null,
1645 .suite = { 1690 .suite = {
1646 .cipher = { 1691 .cipher = {
1647 .enc = { 1692 .enc = {
1648 .vecs = NULL, 1693 .vecs = NULL,
1649 .count = 0 1694 .count = 0
1650 }, 1695 },
1651 .dec = { 1696 .dec = {
1652 .vecs = NULL, 1697 .vecs = NULL,
1653 .count = 0 1698 .count = 0
1654 } 1699 }
1655 } 1700 }
1656 } 1701 }
1657 }, { 1702 }, {
1658 .alg = "__driver-cbc-serpent-avx", 1703 .alg = "__driver-cbc-serpent-avx",
1659 .test = alg_test_null, 1704 .test = alg_test_null,
1660 .suite = { 1705 .suite = {
1661 .cipher = { 1706 .cipher = {
1662 .enc = { 1707 .enc = {
1663 .vecs = NULL, 1708 .vecs = NULL,
1664 .count = 0 1709 .count = 0
1665 }, 1710 },
1666 .dec = { 1711 .dec = {
1667 .vecs = NULL, 1712 .vecs = NULL,
1668 .count = 0 1713 .count = 0
1669 } 1714 }
1670 } 1715 }
1671 } 1716 }
1672 }, { 1717 }, {
1673 .alg = "__driver-cbc-serpent-sse2", 1718 .alg = "__driver-cbc-serpent-sse2",
1674 .test = alg_test_null, 1719 .test = alg_test_null,
1675 .suite = { 1720 .suite = {
1676 .cipher = { 1721 .cipher = {
1677 .enc = { 1722 .enc = {
1678 .vecs = NULL, 1723 .vecs = NULL,
1679 .count = 0 1724 .count = 0
1680 }, 1725 },
1681 .dec = { 1726 .dec = {
1682 .vecs = NULL, 1727 .vecs = NULL,
1683 .count = 0 1728 .count = 0
1684 } 1729 }
1685 } 1730 }
1686 } 1731 }
1687 }, { 1732 }, {
1688 .alg = "__driver-cbc-twofish-avx", 1733 .alg = "__driver-cbc-twofish-avx",
1689 .test = alg_test_null, 1734 .test = alg_test_null,
1690 .suite = { 1735 .suite = {
1691 .cipher = { 1736 .cipher = {
1692 .enc = { 1737 .enc = {
1693 .vecs = NULL, 1738 .vecs = NULL,
1694 .count = 0 1739 .count = 0
1695 }, 1740 },
1696 .dec = { 1741 .dec = {
1697 .vecs = NULL, 1742 .vecs = NULL,
1698 .count = 0 1743 .count = 0
1699 } 1744 }
1700 } 1745 }
1701 } 1746 }
1702 }, { 1747 }, {
1703 .alg = "__driver-ecb-aes-aesni", 1748 .alg = "__driver-ecb-aes-aesni",
1704 .test = alg_test_null, 1749 .test = alg_test_null,
1705 .fips_allowed = 1, 1750 .fips_allowed = 1,
1706 .suite = { 1751 .suite = {
1707 .cipher = { 1752 .cipher = {
1708 .enc = { 1753 .enc = {
1709 .vecs = NULL, 1754 .vecs = NULL,
1710 .count = 0 1755 .count = 0
1711 }, 1756 },
1712 .dec = { 1757 .dec = {
1713 .vecs = NULL, 1758 .vecs = NULL,
1714 .count = 0 1759 .count = 0
1715 } 1760 }
1716 } 1761 }
1717 } 1762 }
1718 }, { 1763 }, {
1719 .alg = "__driver-ecb-cast5-avx", 1764 .alg = "__driver-ecb-cast5-avx",
1720 .test = alg_test_null, 1765 .test = alg_test_null,
1721 .suite = { 1766 .suite = {
1722 .cipher = { 1767 .cipher = {
1723 .enc = { 1768 .enc = {
1724 .vecs = NULL, 1769 .vecs = NULL,
1725 .count = 0 1770 .count = 0
1726 }, 1771 },
1727 .dec = { 1772 .dec = {
1728 .vecs = NULL, 1773 .vecs = NULL,
1729 .count = 0 1774 .count = 0
1730 } 1775 }
1731 } 1776 }
1732 } 1777 }
1733 }, { 1778 }, {
1734 .alg = "__driver-ecb-cast6-avx", 1779 .alg = "__driver-ecb-cast6-avx",
1735 .test = alg_test_null, 1780 .test = alg_test_null,
1736 .suite = { 1781 .suite = {
1737 .cipher = { 1782 .cipher = {
1738 .enc = { 1783 .enc = {
1739 .vecs = NULL, 1784 .vecs = NULL,
1740 .count = 0 1785 .count = 0
1741 }, 1786 },
1742 .dec = { 1787 .dec = {
1743 .vecs = NULL, 1788 .vecs = NULL,
1744 .count = 0 1789 .count = 0
1745 } 1790 }
1746 } 1791 }
1747 } 1792 }
1748 }, { 1793 }, {
1749 .alg = "__driver-ecb-serpent-avx", 1794 .alg = "__driver-ecb-serpent-avx",
1750 .test = alg_test_null, 1795 .test = alg_test_null,
1751 .suite = { 1796 .suite = {
1752 .cipher = { 1797 .cipher = {
1753 .enc = { 1798 .enc = {
1754 .vecs = NULL, 1799 .vecs = NULL,
1755 .count = 0 1800 .count = 0
1756 }, 1801 },
1757 .dec = { 1802 .dec = {
1758 .vecs = NULL, 1803 .vecs = NULL,
1759 .count = 0 1804 .count = 0
1760 } 1805 }
1761 } 1806 }
1762 } 1807 }
1763 }, { 1808 }, {
1764 .alg = "__driver-ecb-serpent-sse2", 1809 .alg = "__driver-ecb-serpent-sse2",
1765 .test = alg_test_null, 1810 .test = alg_test_null,
1766 .suite = { 1811 .suite = {
1767 .cipher = { 1812 .cipher = {
1768 .enc = { 1813 .enc = {
1769 .vecs = NULL, 1814 .vecs = NULL,
1770 .count = 0 1815 .count = 0
1771 }, 1816 },
1772 .dec = { 1817 .dec = {
1773 .vecs = NULL, 1818 .vecs = NULL,
1774 .count = 0 1819 .count = 0
1775 } 1820 }
1776 } 1821 }
1777 } 1822 }
1778 }, { 1823 }, {
1779 .alg = "__driver-ecb-twofish-avx", 1824 .alg = "__driver-ecb-twofish-avx",
1780 .test = alg_test_null, 1825 .test = alg_test_null,
1781 .suite = { 1826 .suite = {
1782 .cipher = { 1827 .cipher = {
1783 .enc = { 1828 .enc = {
1784 .vecs = NULL, 1829 .vecs = NULL,
1785 .count = 0 1830 .count = 0
1786 }, 1831 },
1787 .dec = { 1832 .dec = {
1788 .vecs = NULL, 1833 .vecs = NULL,
1789 .count = 0 1834 .count = 0
1790 } 1835 }
1791 } 1836 }
1792 } 1837 }
1793 }, { 1838 }, {
1794 .alg = "__ghash-pclmulqdqni", 1839 .alg = "__ghash-pclmulqdqni",
1795 .test = alg_test_null, 1840 .test = alg_test_null,
1796 .fips_allowed = 1, 1841 .fips_allowed = 1,
1797 .suite = { 1842 .suite = {
1798 .hash = { 1843 .hash = {
1799 .vecs = NULL, 1844 .vecs = NULL,
1800 .count = 0 1845 .count = 0
1801 } 1846 }
1802 } 1847 }
1803 }, { 1848 }, {
1804 .alg = "ansi_cprng", 1849 .alg = "ansi_cprng",
1805 .test = alg_test_cprng, 1850 .test = alg_test_cprng,
1806 .fips_allowed = 1, 1851 .fips_allowed = 1,
1807 .suite = { 1852 .suite = {
1808 .cprng = { 1853 .cprng = {
1809 .vecs = ansi_cprng_aes_tv_template, 1854 .vecs = ansi_cprng_aes_tv_template,
1810 .count = ANSI_CPRNG_AES_TEST_VECTORS 1855 .count = ANSI_CPRNG_AES_TEST_VECTORS
1811 } 1856 }
1812 } 1857 }
1813 }, { 1858 }, {
1814 .alg = "authenc(hmac(sha1),cbc(aes))", 1859 .alg = "authenc(hmac(sha1),cbc(aes))",
1815 .test = alg_test_aead, 1860 .test = alg_test_aead,
1816 .fips_allowed = 1, 1861 .fips_allowed = 1,
1817 .suite = { 1862 .suite = {
1818 .aead = { 1863 .aead = {
1819 .enc = { 1864 .enc = {
1820 .vecs = hmac_sha1_aes_cbc_enc_tv_template, 1865 .vecs = hmac_sha1_aes_cbc_enc_tv_template,
1821 .count = HMAC_SHA1_AES_CBC_ENC_TEST_VECTORS 1866 .count = HMAC_SHA1_AES_CBC_ENC_TEST_VECTORS
1822 } 1867 }
1823 } 1868 }
1824 } 1869 }
1825 }, { 1870 }, {
1826 .alg = "authenc(hmac(sha256),cbc(aes))", 1871 .alg = "authenc(hmac(sha256),cbc(aes))",
1827 .test = alg_test_aead, 1872 .test = alg_test_aead,
1828 .fips_allowed = 1, 1873 .fips_allowed = 1,
1829 .suite = { 1874 .suite = {
1830 .aead = { 1875 .aead = {
1831 .enc = { 1876 .enc = {
1832 .vecs = hmac_sha256_aes_cbc_enc_tv_template, 1877 .vecs = hmac_sha256_aes_cbc_enc_tv_template,
1833 .count = HMAC_SHA256_AES_CBC_ENC_TEST_VECTORS 1878 .count = HMAC_SHA256_AES_CBC_ENC_TEST_VECTORS
1834 } 1879 }
1835 } 1880 }
1836 } 1881 }
1837 }, { 1882 }, {
1838 .alg = "authenc(hmac(sha512),cbc(aes))", 1883 .alg = "authenc(hmac(sha512),cbc(aes))",
1839 .test = alg_test_aead, 1884 .test = alg_test_aead,
1840 .fips_allowed = 1, 1885 .fips_allowed = 1,
1841 .suite = { 1886 .suite = {
1842 .aead = { 1887 .aead = {
1843 .enc = { 1888 .enc = {
1844 .vecs = hmac_sha512_aes_cbc_enc_tv_template, 1889 .vecs = hmac_sha512_aes_cbc_enc_tv_template,
1845 .count = HMAC_SHA512_AES_CBC_ENC_TEST_VECTORS 1890 .count = HMAC_SHA512_AES_CBC_ENC_TEST_VECTORS
1846 } 1891 }
1847 } 1892 }
1848 } 1893 }
1849 }, { 1894 }, {
1850 .alg = "cbc(aes)", 1895 .alg = "cbc(aes)",
1851 .test = alg_test_skcipher, 1896 .test = alg_test_skcipher,
1852 .fips_allowed = 1, 1897 .fips_allowed = 1,
1853 .suite = { 1898 .suite = {
1854 .cipher = { 1899 .cipher = {
1855 .enc = { 1900 .enc = {
1856 .vecs = aes_cbc_enc_tv_template, 1901 .vecs = aes_cbc_enc_tv_template,
1857 .count = AES_CBC_ENC_TEST_VECTORS 1902 .count = AES_CBC_ENC_TEST_VECTORS
1858 }, 1903 },
1859 .dec = { 1904 .dec = {
1860 .vecs = aes_cbc_dec_tv_template, 1905 .vecs = aes_cbc_dec_tv_template,
1861 .count = AES_CBC_DEC_TEST_VECTORS 1906 .count = AES_CBC_DEC_TEST_VECTORS
1862 } 1907 }
1863 } 1908 }
1864 } 1909 }
1865 }, { 1910 }, {
1866 .alg = "cbc(anubis)", 1911 .alg = "cbc(anubis)",
1867 .test = alg_test_skcipher, 1912 .test = alg_test_skcipher,
1868 .suite = { 1913 .suite = {
1869 .cipher = { 1914 .cipher = {
1870 .enc = { 1915 .enc = {
1871 .vecs = anubis_cbc_enc_tv_template, 1916 .vecs = anubis_cbc_enc_tv_template,
1872 .count = ANUBIS_CBC_ENC_TEST_VECTORS 1917 .count = ANUBIS_CBC_ENC_TEST_VECTORS
1873 }, 1918 },
1874 .dec = { 1919 .dec = {
1875 .vecs = anubis_cbc_dec_tv_template, 1920 .vecs = anubis_cbc_dec_tv_template,
1876 .count = ANUBIS_CBC_DEC_TEST_VECTORS 1921 .count = ANUBIS_CBC_DEC_TEST_VECTORS
1877 } 1922 }
1878 } 1923 }
1879 } 1924 }
1880 }, { 1925 }, {
1881 .alg = "cbc(blowfish)", 1926 .alg = "cbc(blowfish)",
1882 .test = alg_test_skcipher, 1927 .test = alg_test_skcipher,
1883 .suite = { 1928 .suite = {
1884 .cipher = { 1929 .cipher = {
1885 .enc = { 1930 .enc = {
1886 .vecs = bf_cbc_enc_tv_template, 1931 .vecs = bf_cbc_enc_tv_template,
1887 .count = BF_CBC_ENC_TEST_VECTORS 1932 .count = BF_CBC_ENC_TEST_VECTORS
1888 }, 1933 },
1889 .dec = { 1934 .dec = {
1890 .vecs = bf_cbc_dec_tv_template, 1935 .vecs = bf_cbc_dec_tv_template,
1891 .count = BF_CBC_DEC_TEST_VECTORS 1936 .count = BF_CBC_DEC_TEST_VECTORS
1892 } 1937 }
1893 } 1938 }
1894 } 1939 }
1895 }, { 1940 }, {
1896 .alg = "cbc(camellia)", 1941 .alg = "cbc(camellia)",
1897 .test = alg_test_skcipher, 1942 .test = alg_test_skcipher,
1898 .suite = { 1943 .suite = {
1899 .cipher = { 1944 .cipher = {
1900 .enc = { 1945 .enc = {
1901 .vecs = camellia_cbc_enc_tv_template, 1946 .vecs = camellia_cbc_enc_tv_template,
1902 .count = CAMELLIA_CBC_ENC_TEST_VECTORS 1947 .count = CAMELLIA_CBC_ENC_TEST_VECTORS
1903 }, 1948 },
1904 .dec = { 1949 .dec = {
1905 .vecs = camellia_cbc_dec_tv_template, 1950 .vecs = camellia_cbc_dec_tv_template,
1906 .count = CAMELLIA_CBC_DEC_TEST_VECTORS 1951 .count = CAMELLIA_CBC_DEC_TEST_VECTORS
1907 } 1952 }
1908 } 1953 }
1909 } 1954 }
1910 }, { 1955 }, {
1911 .alg = "cbc(cast5)", 1956 .alg = "cbc(cast5)",
1912 .test = alg_test_skcipher, 1957 .test = alg_test_skcipher,
1913 .suite = { 1958 .suite = {
1914 .cipher = { 1959 .cipher = {
1915 .enc = { 1960 .enc = {
1916 .vecs = cast5_cbc_enc_tv_template, 1961 .vecs = cast5_cbc_enc_tv_template,
1917 .count = CAST5_CBC_ENC_TEST_VECTORS 1962 .count = CAST5_CBC_ENC_TEST_VECTORS
1918 }, 1963 },
1919 .dec = { 1964 .dec = {
1920 .vecs = cast5_cbc_dec_tv_template, 1965 .vecs = cast5_cbc_dec_tv_template,
1921 .count = CAST5_CBC_DEC_TEST_VECTORS 1966 .count = CAST5_CBC_DEC_TEST_VECTORS
1922 } 1967 }
1923 } 1968 }
1924 } 1969 }
1925 }, { 1970 }, {
1926 .alg = "cbc(cast6)", 1971 .alg = "cbc(cast6)",
1927 .test = alg_test_skcipher, 1972 .test = alg_test_skcipher,
1928 .suite = { 1973 .suite = {
1929 .cipher = { 1974 .cipher = {
1930 .enc = { 1975 .enc = {
1931 .vecs = cast6_cbc_enc_tv_template, 1976 .vecs = cast6_cbc_enc_tv_template,
1932 .count = CAST6_CBC_ENC_TEST_VECTORS 1977 .count = CAST6_CBC_ENC_TEST_VECTORS
1933 }, 1978 },
1934 .dec = { 1979 .dec = {
1935 .vecs = cast6_cbc_dec_tv_template, 1980 .vecs = cast6_cbc_dec_tv_template,
1936 .count = CAST6_CBC_DEC_TEST_VECTORS 1981 .count = CAST6_CBC_DEC_TEST_VECTORS
1937 } 1982 }
1938 } 1983 }
1939 } 1984 }
1940 }, { 1985 }, {
1941 .alg = "cbc(des)", 1986 .alg = "cbc(des)",
1942 .test = alg_test_skcipher, 1987 .test = alg_test_skcipher,
1943 .suite = { 1988 .suite = {
1944 .cipher = { 1989 .cipher = {
1945 .enc = { 1990 .enc = {
1946 .vecs = des_cbc_enc_tv_template, 1991 .vecs = des_cbc_enc_tv_template,
1947 .count = DES_CBC_ENC_TEST_VECTORS 1992 .count = DES_CBC_ENC_TEST_VECTORS
1948 }, 1993 },
1949 .dec = { 1994 .dec = {
1950 .vecs = des_cbc_dec_tv_template, 1995 .vecs = des_cbc_dec_tv_template,
1951 .count = DES_CBC_DEC_TEST_VECTORS 1996 .count = DES_CBC_DEC_TEST_VECTORS
1952 } 1997 }
1953 } 1998 }
1954 } 1999 }
1955 }, { 2000 }, {
1956 .alg = "cbc(des3_ede)", 2001 .alg = "cbc(des3_ede)",
1957 .test = alg_test_skcipher, 2002 .test = alg_test_skcipher,
1958 .fips_allowed = 1, 2003 .fips_allowed = 1,
1959 .suite = { 2004 .suite = {
1960 .cipher = { 2005 .cipher = {
1961 .enc = { 2006 .enc = {
1962 .vecs = des3_ede_cbc_enc_tv_template, 2007 .vecs = des3_ede_cbc_enc_tv_template,
1963 .count = DES3_EDE_CBC_ENC_TEST_VECTORS 2008 .count = DES3_EDE_CBC_ENC_TEST_VECTORS
1964 }, 2009 },
1965 .dec = { 2010 .dec = {
1966 .vecs = des3_ede_cbc_dec_tv_template, 2011 .vecs = des3_ede_cbc_dec_tv_template,
1967 .count = DES3_EDE_CBC_DEC_TEST_VECTORS 2012 .count = DES3_EDE_CBC_DEC_TEST_VECTORS
1968 } 2013 }
1969 } 2014 }
1970 } 2015 }
1971 }, { 2016 }, {
1972 .alg = "cbc(serpent)", 2017 .alg = "cbc(serpent)",
1973 .test = alg_test_skcipher, 2018 .test = alg_test_skcipher,
1974 .suite = { 2019 .suite = {
1975 .cipher = { 2020 .cipher = {
1976 .enc = { 2021 .enc = {
1977 .vecs = serpent_cbc_enc_tv_template, 2022 .vecs = serpent_cbc_enc_tv_template,
1978 .count = SERPENT_CBC_ENC_TEST_VECTORS 2023 .count = SERPENT_CBC_ENC_TEST_VECTORS
1979 }, 2024 },
1980 .dec = { 2025 .dec = {
1981 .vecs = serpent_cbc_dec_tv_template, 2026 .vecs = serpent_cbc_dec_tv_template,
1982 .count = SERPENT_CBC_DEC_TEST_VECTORS 2027 .count = SERPENT_CBC_DEC_TEST_VECTORS
1983 } 2028 }
1984 } 2029 }
1985 } 2030 }
1986 }, { 2031 }, {
1987 .alg = "cbc(twofish)", 2032 .alg = "cbc(twofish)",
1988 .test = alg_test_skcipher, 2033 .test = alg_test_skcipher,
1989 .suite = { 2034 .suite = {
1990 .cipher = { 2035 .cipher = {
1991 .enc = { 2036 .enc = {
1992 .vecs = tf_cbc_enc_tv_template, 2037 .vecs = tf_cbc_enc_tv_template,
1993 .count = TF_CBC_ENC_TEST_VECTORS 2038 .count = TF_CBC_ENC_TEST_VECTORS
1994 }, 2039 },
1995 .dec = { 2040 .dec = {
1996 .vecs = tf_cbc_dec_tv_template, 2041 .vecs = tf_cbc_dec_tv_template,
1997 .count = TF_CBC_DEC_TEST_VECTORS 2042 .count = TF_CBC_DEC_TEST_VECTORS
1998 } 2043 }
1999 } 2044 }
2000 } 2045 }
2001 }, { 2046 }, {
2002 .alg = "ccm(aes)", 2047 .alg = "ccm(aes)",
2003 .test = alg_test_aead, 2048 .test = alg_test_aead,
2004 .fips_allowed = 1, 2049 .fips_allowed = 1,
2005 .suite = { 2050 .suite = {
2006 .aead = { 2051 .aead = {
2007 .enc = { 2052 .enc = {
2008 .vecs = aes_ccm_enc_tv_template, 2053 .vecs = aes_ccm_enc_tv_template,
2009 .count = AES_CCM_ENC_TEST_VECTORS 2054 .count = AES_CCM_ENC_TEST_VECTORS
2010 }, 2055 },
2011 .dec = { 2056 .dec = {
2012 .vecs = aes_ccm_dec_tv_template, 2057 .vecs = aes_ccm_dec_tv_template,
2013 .count = AES_CCM_DEC_TEST_VECTORS 2058 .count = AES_CCM_DEC_TEST_VECTORS
2014 } 2059 }
2015 } 2060 }
2016 } 2061 }
2017 }, { 2062 }, {
2018 .alg = "crc32c", 2063 .alg = "crc32c",
2019 .test = alg_test_crc32c, 2064 .test = alg_test_crc32c,
2020 .fips_allowed = 1, 2065 .fips_allowed = 1,
2021 .suite = { 2066 .suite = {
2022 .hash = { 2067 .hash = {
2023 .vecs = crc32c_tv_template, 2068 .vecs = crc32c_tv_template,
2024 .count = CRC32C_TEST_VECTORS 2069 .count = CRC32C_TEST_VECTORS
2025 } 2070 }
2026 } 2071 }
2027 }, { 2072 }, {
2028 .alg = "cryptd(__driver-cbc-aes-aesni)", 2073 .alg = "cryptd(__driver-cbc-aes-aesni)",
2029 .test = alg_test_null, 2074 .test = alg_test_null,
2030 .fips_allowed = 1, 2075 .fips_allowed = 1,
2031 .suite = { 2076 .suite = {
2032 .cipher = { 2077 .cipher = {
2033 .enc = { 2078 .enc = {
2034 .vecs = NULL, 2079 .vecs = NULL,
2035 .count = 0 2080 .count = 0
2036 }, 2081 },
2037 .dec = { 2082 .dec = {
2038 .vecs = NULL, 2083 .vecs = NULL,
2039 .count = 0 2084 .count = 0
2040 } 2085 }
2041 } 2086 }
2042 } 2087 }
2043 }, { 2088 }, {
2044 .alg = "cryptd(__driver-ecb-aes-aesni)", 2089 .alg = "cryptd(__driver-ecb-aes-aesni)",
2045 .test = alg_test_null, 2090 .test = alg_test_null,
2046 .fips_allowed = 1, 2091 .fips_allowed = 1,
2047 .suite = { 2092 .suite = {
2048 .cipher = { 2093 .cipher = {
2049 .enc = { 2094 .enc = {
2050 .vecs = NULL, 2095 .vecs = NULL,
2051 .count = 0 2096 .count = 0
2052 }, 2097 },
2053 .dec = { 2098 .dec = {
2054 .vecs = NULL, 2099 .vecs = NULL,
2055 .count = 0 2100 .count = 0
2056 } 2101 }
2057 } 2102 }
2058 } 2103 }
2059 }, { 2104 }, {
2060 .alg = "cryptd(__driver-ecb-cast5-avx)", 2105 .alg = "cryptd(__driver-ecb-cast5-avx)",
2061 .test = alg_test_null, 2106 .test = alg_test_null,
2062 .suite = { 2107 .suite = {
2063 .cipher = { 2108 .cipher = {
2064 .enc = { 2109 .enc = {
2065 .vecs = NULL, 2110 .vecs = NULL,
2066 .count = 0 2111 .count = 0
2067 }, 2112 },
2068 .dec = { 2113 .dec = {
2069 .vecs = NULL, 2114 .vecs = NULL,
2070 .count = 0 2115 .count = 0
2071 } 2116 }
2072 } 2117 }
2073 } 2118 }
2074 }, { 2119 }, {
2075 .alg = "cryptd(__driver-ecb-cast6-avx)", 2120 .alg = "cryptd(__driver-ecb-cast6-avx)",
2076 .test = alg_test_null, 2121 .test = alg_test_null,
2077 .suite = { 2122 .suite = {
2078 .cipher = { 2123 .cipher = {
2079 .enc = { 2124 .enc = {
2080 .vecs = NULL, 2125 .vecs = NULL,
2081 .count = 0 2126 .count = 0
2082 }, 2127 },
2083 .dec = { 2128 .dec = {
2084 .vecs = NULL, 2129 .vecs = NULL,
2085 .count = 0 2130 .count = 0
2086 } 2131 }
2087 } 2132 }
2088 } 2133 }
2089 }, { 2134 }, {
2090 .alg = "cryptd(__driver-ecb-serpent-avx)", 2135 .alg = "cryptd(__driver-ecb-serpent-avx)",
2091 .test = alg_test_null, 2136 .test = alg_test_null,
2092 .suite = { 2137 .suite = {
2093 .cipher = { 2138 .cipher = {
2094 .enc = { 2139 .enc = {
2095 .vecs = NULL, 2140 .vecs = NULL,
2096 .count = 0 2141 .count = 0
2097 }, 2142 },
2098 .dec = { 2143 .dec = {
2099 .vecs = NULL, 2144 .vecs = NULL,
2100 .count = 0 2145 .count = 0
2101 } 2146 }
2102 } 2147 }
2103 } 2148 }
2104 }, { 2149 }, {
2105 .alg = "cryptd(__driver-ecb-serpent-sse2)", 2150 .alg = "cryptd(__driver-ecb-serpent-sse2)",
2106 .test = alg_test_null, 2151 .test = alg_test_null,
2107 .suite = { 2152 .suite = {
2108 .cipher = { 2153 .cipher = {
2109 .enc = { 2154 .enc = {
2110 .vecs = NULL, 2155 .vecs = NULL,
2111 .count = 0 2156 .count = 0
2112 }, 2157 },
2113 .dec = { 2158 .dec = {
2114 .vecs = NULL, 2159 .vecs = NULL,
2115 .count = 0 2160 .count = 0
2116 } 2161 }
2117 } 2162 }
2118 } 2163 }
2119 }, { 2164 }, {
2120 .alg = "cryptd(__driver-ecb-twofish-avx)", 2165 .alg = "cryptd(__driver-ecb-twofish-avx)",
2121 .test = alg_test_null, 2166 .test = alg_test_null,
2122 .suite = { 2167 .suite = {
2123 .cipher = { 2168 .cipher = {
2124 .enc = { 2169 .enc = {
2125 .vecs = NULL, 2170 .vecs = NULL,
2126 .count = 0 2171 .count = 0
2127 }, 2172 },
2128 .dec = { 2173 .dec = {
2129 .vecs = NULL, 2174 .vecs = NULL,
2130 .count = 0 2175 .count = 0
2131 } 2176 }
2132 } 2177 }
2133 } 2178 }
2134 }, { 2179 }, {
2135 .alg = "cryptd(__driver-gcm-aes-aesni)", 2180 .alg = "cryptd(__driver-gcm-aes-aesni)",
2136 .test = alg_test_null, 2181 .test = alg_test_null,
2137 .fips_allowed = 1, 2182 .fips_allowed = 1,
2138 .suite = { 2183 .suite = {
2139 .cipher = { 2184 .cipher = {
2140 .enc = { 2185 .enc = {
2141 .vecs = NULL, 2186 .vecs = NULL,
2142 .count = 0 2187 .count = 0
2143 }, 2188 },
2144 .dec = { 2189 .dec = {
2145 .vecs = NULL, 2190 .vecs = NULL,
2146 .count = 0 2191 .count = 0
2147 } 2192 }
2148 } 2193 }
2149 } 2194 }
2150 }, { 2195 }, {
2151 .alg = "cryptd(__ghash-pclmulqdqni)", 2196 .alg = "cryptd(__ghash-pclmulqdqni)",
2152 .test = alg_test_null, 2197 .test = alg_test_null,
2153 .fips_allowed = 1, 2198 .fips_allowed = 1,
2154 .suite = { 2199 .suite = {
2155 .hash = { 2200 .hash = {
2156 .vecs = NULL, 2201 .vecs = NULL,
2157 .count = 0 2202 .count = 0
2158 } 2203 }
2159 } 2204 }
2160 }, { 2205 }, {
2161 .alg = "ctr(aes)", 2206 .alg = "ctr(aes)",
2162 .test = alg_test_skcipher, 2207 .test = alg_test_skcipher,
2163 .fips_allowed = 1, 2208 .fips_allowed = 1,
2164 .suite = { 2209 .suite = {
2165 .cipher = { 2210 .cipher = {
2166 .enc = { 2211 .enc = {
2167 .vecs = aes_ctr_enc_tv_template, 2212 .vecs = aes_ctr_enc_tv_template,
2168 .count = AES_CTR_ENC_TEST_VECTORS 2213 .count = AES_CTR_ENC_TEST_VECTORS
2169 }, 2214 },
2170 .dec = { 2215 .dec = {
2171 .vecs = aes_ctr_dec_tv_template, 2216 .vecs = aes_ctr_dec_tv_template,
2172 .count = AES_CTR_DEC_TEST_VECTORS 2217 .count = AES_CTR_DEC_TEST_VECTORS
2173 } 2218 }
2174 } 2219 }
2175 } 2220 }
2176 }, { 2221 }, {
2177 .alg = "ctr(blowfish)", 2222 .alg = "ctr(blowfish)",
2178 .test = alg_test_skcipher, 2223 .test = alg_test_skcipher,
2179 .suite = { 2224 .suite = {
2180 .cipher = { 2225 .cipher = {
2181 .enc = { 2226 .enc = {
2182 .vecs = bf_ctr_enc_tv_template, 2227 .vecs = bf_ctr_enc_tv_template,
2183 .count = BF_CTR_ENC_TEST_VECTORS 2228 .count = BF_CTR_ENC_TEST_VECTORS
2184 }, 2229 },
2185 .dec = { 2230 .dec = {
2186 .vecs = bf_ctr_dec_tv_template, 2231 .vecs = bf_ctr_dec_tv_template,
2187 .count = BF_CTR_DEC_TEST_VECTORS 2232 .count = BF_CTR_DEC_TEST_VECTORS
2188 } 2233 }
2189 } 2234 }
2190 } 2235 }
2191 }, { 2236 }, {
2192 .alg = "ctr(camellia)", 2237 .alg = "ctr(camellia)",
2193 .test = alg_test_skcipher, 2238 .test = alg_test_skcipher,
2194 .suite = { 2239 .suite = {
2195 .cipher = { 2240 .cipher = {
2196 .enc = { 2241 .enc = {
2197 .vecs = camellia_ctr_enc_tv_template, 2242 .vecs = camellia_ctr_enc_tv_template,
2198 .count = CAMELLIA_CTR_ENC_TEST_VECTORS 2243 .count = CAMELLIA_CTR_ENC_TEST_VECTORS
2199 }, 2244 },
2200 .dec = { 2245 .dec = {
2201 .vecs = camellia_ctr_dec_tv_template, 2246 .vecs = camellia_ctr_dec_tv_template,
2202 .count = CAMELLIA_CTR_DEC_TEST_VECTORS 2247 .count = CAMELLIA_CTR_DEC_TEST_VECTORS
2203 } 2248 }
2204 } 2249 }
2205 } 2250 }
2206 }, { 2251 }, {
2207 .alg = "ctr(cast5)", 2252 .alg = "ctr(cast5)",
2208 .test = alg_test_skcipher, 2253 .test = alg_test_skcipher,
2209 .suite = { 2254 .suite = {
2210 .cipher = { 2255 .cipher = {
2211 .enc = { 2256 .enc = {
2212 .vecs = cast5_ctr_enc_tv_template, 2257 .vecs = cast5_ctr_enc_tv_template,
2213 .count = CAST5_CTR_ENC_TEST_VECTORS 2258 .count = CAST5_CTR_ENC_TEST_VECTORS
2214 }, 2259 },
2215 .dec = { 2260 .dec = {
2216 .vecs = cast5_ctr_dec_tv_template, 2261 .vecs = cast5_ctr_dec_tv_template,
2217 .count = CAST5_CTR_DEC_TEST_VECTORS 2262 .count = CAST5_CTR_DEC_TEST_VECTORS
2218 } 2263 }
2219 } 2264 }
2220 } 2265 }
2221 }, { 2266 }, {
2222 .alg = "ctr(cast6)", 2267 .alg = "ctr(cast6)",
2223 .test = alg_test_skcipher, 2268 .test = alg_test_skcipher,
2224 .suite = { 2269 .suite = {
2225 .cipher = { 2270 .cipher = {
2226 .enc = { 2271 .enc = {
2227 .vecs = cast6_ctr_enc_tv_template, 2272 .vecs = cast6_ctr_enc_tv_template,
2228 .count = CAST6_CTR_ENC_TEST_VECTORS 2273 .count = CAST6_CTR_ENC_TEST_VECTORS
2229 }, 2274 },
2230 .dec = { 2275 .dec = {
2231 .vecs = cast6_ctr_dec_tv_template, 2276 .vecs = cast6_ctr_dec_tv_template,
2232 .count = CAST6_CTR_DEC_TEST_VECTORS 2277 .count = CAST6_CTR_DEC_TEST_VECTORS
2233 } 2278 }
2234 } 2279 }
2235 } 2280 }
2236 }, { 2281 }, {
2237 .alg = "ctr(serpent)", 2282 .alg = "ctr(serpent)",
2238 .test = alg_test_skcipher, 2283 .test = alg_test_skcipher,
2239 .suite = { 2284 .suite = {
2240 .cipher = { 2285 .cipher = {
2241 .enc = { 2286 .enc = {
2242 .vecs = serpent_ctr_enc_tv_template, 2287 .vecs = serpent_ctr_enc_tv_template,
2243 .count = SERPENT_CTR_ENC_TEST_VECTORS 2288 .count = SERPENT_CTR_ENC_TEST_VECTORS
2244 }, 2289 },
2245 .dec = { 2290 .dec = {
2246 .vecs = serpent_ctr_dec_tv_template, 2291 .vecs = serpent_ctr_dec_tv_template,
2247 .count = SERPENT_CTR_DEC_TEST_VECTORS 2292 .count = SERPENT_CTR_DEC_TEST_VECTORS
2248 } 2293 }
2249 } 2294 }
2250 } 2295 }
2251 }, { 2296 }, {
2252 .alg = "ctr(twofish)", 2297 .alg = "ctr(twofish)",
2253 .test = alg_test_skcipher, 2298 .test = alg_test_skcipher,
2254 .suite = { 2299 .suite = {
2255 .cipher = { 2300 .cipher = {
2256 .enc = { 2301 .enc = {
2257 .vecs = tf_ctr_enc_tv_template, 2302 .vecs = tf_ctr_enc_tv_template,
2258 .count = TF_CTR_ENC_TEST_VECTORS 2303 .count = TF_CTR_ENC_TEST_VECTORS
2259 }, 2304 },
2260 .dec = { 2305 .dec = {
2261 .vecs = tf_ctr_dec_tv_template, 2306 .vecs = tf_ctr_dec_tv_template,
2262 .count = TF_CTR_DEC_TEST_VECTORS 2307 .count = TF_CTR_DEC_TEST_VECTORS
2263 } 2308 }
2264 } 2309 }
2265 } 2310 }
2266 }, { 2311 }, {
2267 .alg = "cts(cbc(aes))", 2312 .alg = "cts(cbc(aes))",
2268 .test = alg_test_skcipher, 2313 .test = alg_test_skcipher,
2269 .suite = { 2314 .suite = {
2270 .cipher = { 2315 .cipher = {
2271 .enc = { 2316 .enc = {
2272 .vecs = cts_mode_enc_tv_template, 2317 .vecs = cts_mode_enc_tv_template,
2273 .count = CTS_MODE_ENC_TEST_VECTORS 2318 .count = CTS_MODE_ENC_TEST_VECTORS
2274 }, 2319 },
2275 .dec = { 2320 .dec = {
2276 .vecs = cts_mode_dec_tv_template, 2321 .vecs = cts_mode_dec_tv_template,
2277 .count = CTS_MODE_DEC_TEST_VECTORS 2322 .count = CTS_MODE_DEC_TEST_VECTORS
2278 } 2323 }
2279 } 2324 }
2280 } 2325 }
2281 }, { 2326 }, {
2282 .alg = "deflate", 2327 .alg = "deflate",
2283 .test = alg_test_comp, 2328 .test = alg_test_comp,
2284 .suite = { 2329 .suite = {
2285 .comp = { 2330 .comp = {
2286 .comp = { 2331 .comp = {
2287 .vecs = deflate_comp_tv_template, 2332 .vecs = deflate_comp_tv_template,
2288 .count = DEFLATE_COMP_TEST_VECTORS 2333 .count = DEFLATE_COMP_TEST_VECTORS
2289 }, 2334 },
2290 .decomp = { 2335 .decomp = {
2291 .vecs = deflate_decomp_tv_template, 2336 .vecs = deflate_decomp_tv_template,
2292 .count = DEFLATE_DECOMP_TEST_VECTORS 2337 .count = DEFLATE_DECOMP_TEST_VECTORS
2293 } 2338 }
2294 } 2339 }
2295 } 2340 }
2296 }, { 2341 }, {
2297 .alg = "ecb(__aes-aesni)", 2342 .alg = "ecb(__aes-aesni)",
2298 .test = alg_test_null, 2343 .test = alg_test_null,
2299 .fips_allowed = 1, 2344 .fips_allowed = 1,
2300 .suite = { 2345 .suite = {
2301 .cipher = { 2346 .cipher = {
2302 .enc = { 2347 .enc = {
2303 .vecs = NULL, 2348 .vecs = NULL,
2304 .count = 0 2349 .count = 0
2305 }, 2350 },
2306 .dec = { 2351 .dec = {
2307 .vecs = NULL, 2352 .vecs = NULL,
2308 .count = 0 2353 .count = 0
2309 } 2354 }
2310 } 2355 }
2311 } 2356 }
2312 }, { 2357 }, {
2313 .alg = "ecb(aes)", 2358 .alg = "ecb(aes)",
2314 .test = alg_test_skcipher, 2359 .test = alg_test_skcipher,
2315 .fips_allowed = 1, 2360 .fips_allowed = 1,
2316 .suite = { 2361 .suite = {
2317 .cipher = { 2362 .cipher = {
2318 .enc = { 2363 .enc = {
2319 .vecs = aes_enc_tv_template, 2364 .vecs = aes_enc_tv_template,
2320 .count = AES_ENC_TEST_VECTORS 2365 .count = AES_ENC_TEST_VECTORS
2321 }, 2366 },
2322 .dec = { 2367 .dec = {
2323 .vecs = aes_dec_tv_template, 2368 .vecs = aes_dec_tv_template,
2324 .count = AES_DEC_TEST_VECTORS 2369 .count = AES_DEC_TEST_VECTORS
2325 } 2370 }
2326 } 2371 }
2327 } 2372 }
2328 }, { 2373 }, {
2329 .alg = "ecb(anubis)", 2374 .alg = "ecb(anubis)",
2330 .test = alg_test_skcipher, 2375 .test = alg_test_skcipher,
2331 .suite = { 2376 .suite = {
2332 .cipher = { 2377 .cipher = {
2333 .enc = { 2378 .enc = {
2334 .vecs = anubis_enc_tv_template, 2379 .vecs = anubis_enc_tv_template,
2335 .count = ANUBIS_ENC_TEST_VECTORS 2380 .count = ANUBIS_ENC_TEST_VECTORS
2336 }, 2381 },
2337 .dec = { 2382 .dec = {
2338 .vecs = anubis_dec_tv_template, 2383 .vecs = anubis_dec_tv_template,
2339 .count = ANUBIS_DEC_TEST_VECTORS 2384 .count = ANUBIS_DEC_TEST_VECTORS
2340 } 2385 }
2341 } 2386 }
2342 } 2387 }
2343 }, { 2388 }, {
2344 .alg = "ecb(arc4)", 2389 .alg = "ecb(arc4)",
2345 .test = alg_test_skcipher, 2390 .test = alg_test_skcipher,
2346 .suite = { 2391 .suite = {
2347 .cipher = { 2392 .cipher = {
2348 .enc = { 2393 .enc = {
2349 .vecs = arc4_enc_tv_template, 2394 .vecs = arc4_enc_tv_template,
2350 .count = ARC4_ENC_TEST_VECTORS 2395 .count = ARC4_ENC_TEST_VECTORS
2351 }, 2396 },
2352 .dec = { 2397 .dec = {
2353 .vecs = arc4_dec_tv_template, 2398 .vecs = arc4_dec_tv_template,
2354 .count = ARC4_DEC_TEST_VECTORS 2399 .count = ARC4_DEC_TEST_VECTORS
2355 } 2400 }
2356 } 2401 }
2357 } 2402 }
2358 }, { 2403 }, {
2359 .alg = "ecb(blowfish)", 2404 .alg = "ecb(blowfish)",
2360 .test = alg_test_skcipher, 2405 .test = alg_test_skcipher,
2361 .suite = { 2406 .suite = {
2362 .cipher = { 2407 .cipher = {
2363 .enc = { 2408 .enc = {
2364 .vecs = bf_enc_tv_template, 2409 .vecs = bf_enc_tv_template,
2365 .count = BF_ENC_TEST_VECTORS 2410 .count = BF_ENC_TEST_VECTORS
2366 }, 2411 },
2367 .dec = { 2412 .dec = {
2368 .vecs = bf_dec_tv_template, 2413 .vecs = bf_dec_tv_template,
2369 .count = BF_DEC_TEST_VECTORS 2414 .count = BF_DEC_TEST_VECTORS
2370 } 2415 }
2371 } 2416 }
2372 } 2417 }
2373 }, { 2418 }, {
2374 .alg = "ecb(camellia)", 2419 .alg = "ecb(camellia)",
2375 .test = alg_test_skcipher, 2420 .test = alg_test_skcipher,
2376 .suite = { 2421 .suite = {
2377 .cipher = { 2422 .cipher = {
2378 .enc = { 2423 .enc = {
2379 .vecs = camellia_enc_tv_template, 2424 .vecs = camellia_enc_tv_template,
2380 .count = CAMELLIA_ENC_TEST_VECTORS 2425 .count = CAMELLIA_ENC_TEST_VECTORS
2381 }, 2426 },
2382 .dec = { 2427 .dec = {
2383 .vecs = camellia_dec_tv_template, 2428 .vecs = camellia_dec_tv_template,
2384 .count = CAMELLIA_DEC_TEST_VECTORS 2429 .count = CAMELLIA_DEC_TEST_VECTORS
2385 } 2430 }
2386 } 2431 }
2387 } 2432 }
2388 }, { 2433 }, {
2389 .alg = "ecb(cast5)", 2434 .alg = "ecb(cast5)",
2390 .test = alg_test_skcipher, 2435 .test = alg_test_skcipher,
2391 .suite = { 2436 .suite = {
2392 .cipher = { 2437 .cipher = {
2393 .enc = { 2438 .enc = {
2394 .vecs = cast5_enc_tv_template, 2439 .vecs = cast5_enc_tv_template,
2395 .count = CAST5_ENC_TEST_VECTORS 2440 .count = CAST5_ENC_TEST_VECTORS
2396 }, 2441 },
2397 .dec = { 2442 .dec = {
2398 .vecs = cast5_dec_tv_template, 2443 .vecs = cast5_dec_tv_template,
2399 .count = CAST5_DEC_TEST_VECTORS 2444 .count = CAST5_DEC_TEST_VECTORS
2400 } 2445 }
2401 } 2446 }
2402 } 2447 }
2403 }, { 2448 }, {
2404 .alg = "ecb(cast6)", 2449 .alg = "ecb(cast6)",
2405 .test = alg_test_skcipher, 2450 .test = alg_test_skcipher,
2406 .suite = { 2451 .suite = {
2407 .cipher = { 2452 .cipher = {
2408 .enc = { 2453 .enc = {
2409 .vecs = cast6_enc_tv_template, 2454 .vecs = cast6_enc_tv_template,
2410 .count = CAST6_ENC_TEST_VECTORS 2455 .count = CAST6_ENC_TEST_VECTORS
2411 }, 2456 },
2412 .dec = { 2457 .dec = {
2413 .vecs = cast6_dec_tv_template, 2458 .vecs = cast6_dec_tv_template,
2414 .count = CAST6_DEC_TEST_VECTORS 2459 .count = CAST6_DEC_TEST_VECTORS
2415 } 2460 }
2416 } 2461 }
2417 } 2462 }
2418 }, { 2463 }, {
2419 .alg = "ecb(des)", 2464 .alg = "ecb(des)",
2420 .test = alg_test_skcipher, 2465 .test = alg_test_skcipher,
2421 .fips_allowed = 1, 2466 .fips_allowed = 1,
2422 .suite = { 2467 .suite = {
2423 .cipher = { 2468 .cipher = {
2424 .enc = { 2469 .enc = {
2425 .vecs = des_enc_tv_template, 2470 .vecs = des_enc_tv_template,
2426 .count = DES_ENC_TEST_VECTORS 2471 .count = DES_ENC_TEST_VECTORS
2427 }, 2472 },
2428 .dec = { 2473 .dec = {
2429 .vecs = des_dec_tv_template, 2474 .vecs = des_dec_tv_template,
2430 .count = DES_DEC_TEST_VECTORS 2475 .count = DES_DEC_TEST_VECTORS
2431 } 2476 }
2432 } 2477 }
2433 } 2478 }
2434 }, { 2479 }, {
2435 .alg = "ecb(des3_ede)", 2480 .alg = "ecb(des3_ede)",
2436 .test = alg_test_skcipher, 2481 .test = alg_test_skcipher,
2437 .fips_allowed = 1, 2482 .fips_allowed = 1,
2438 .suite = { 2483 .suite = {
2439 .cipher = { 2484 .cipher = {
2440 .enc = { 2485 .enc = {
2441 .vecs = des3_ede_enc_tv_template, 2486 .vecs = des3_ede_enc_tv_template,
2442 .count = DES3_EDE_ENC_TEST_VECTORS 2487 .count = DES3_EDE_ENC_TEST_VECTORS
2443 }, 2488 },
2444 .dec = { 2489 .dec = {
2445 .vecs = des3_ede_dec_tv_template, 2490 .vecs = des3_ede_dec_tv_template,
2446 .count = DES3_EDE_DEC_TEST_VECTORS 2491 .count = DES3_EDE_DEC_TEST_VECTORS
2447 } 2492 }
2448 } 2493 }
2449 } 2494 }
2450 }, { 2495 }, {
2451 .alg = "ecb(khazad)", 2496 .alg = "ecb(khazad)",
2452 .test = alg_test_skcipher, 2497 .test = alg_test_skcipher,
2453 .suite = { 2498 .suite = {
2454 .cipher = { 2499 .cipher = {
2455 .enc = { 2500 .enc = {
2456 .vecs = khazad_enc_tv_template, 2501 .vecs = khazad_enc_tv_template,
2457 .count = KHAZAD_ENC_TEST_VECTORS 2502 .count = KHAZAD_ENC_TEST_VECTORS
2458 }, 2503 },
2459 .dec = { 2504 .dec = {
2460 .vecs = khazad_dec_tv_template, 2505 .vecs = khazad_dec_tv_template,
2461 .count = KHAZAD_DEC_TEST_VECTORS 2506 .count = KHAZAD_DEC_TEST_VECTORS
2462 } 2507 }
2463 } 2508 }
2464 } 2509 }
2465 }, { 2510 }, {
2466 .alg = "ecb(seed)", 2511 .alg = "ecb(seed)",
2467 .test = alg_test_skcipher, 2512 .test = alg_test_skcipher,
2468 .suite = { 2513 .suite = {
2469 .cipher = { 2514 .cipher = {
2470 .enc = { 2515 .enc = {
2471 .vecs = seed_enc_tv_template, 2516 .vecs = seed_enc_tv_template,
2472 .count = SEED_ENC_TEST_VECTORS 2517 .count = SEED_ENC_TEST_VECTORS
2473 }, 2518 },
2474 .dec = { 2519 .dec = {
2475 .vecs = seed_dec_tv_template, 2520 .vecs = seed_dec_tv_template,
2476 .count = SEED_DEC_TEST_VECTORS 2521 .count = SEED_DEC_TEST_VECTORS
2477 } 2522 }
2478 } 2523 }
2479 } 2524 }
2480 }, { 2525 }, {
2481 .alg = "ecb(serpent)", 2526 .alg = "ecb(serpent)",
2482 .test = alg_test_skcipher, 2527 .test = alg_test_skcipher,
2483 .suite = { 2528 .suite = {
2484 .cipher = { 2529 .cipher = {
2485 .enc = { 2530 .enc = {
2486 .vecs = serpent_enc_tv_template, 2531 .vecs = serpent_enc_tv_template,
2487 .count = SERPENT_ENC_TEST_VECTORS 2532 .count = SERPENT_ENC_TEST_VECTORS
2488 }, 2533 },
2489 .dec = { 2534 .dec = {
2490 .vecs = serpent_dec_tv_template, 2535 .vecs = serpent_dec_tv_template,
2491 .count = SERPENT_DEC_TEST_VECTORS 2536 .count = SERPENT_DEC_TEST_VECTORS
2492 } 2537 }
2493 } 2538 }
2494 } 2539 }
2495 }, { 2540 }, {
2496 .alg = "ecb(tea)", 2541 .alg = "ecb(tea)",
2497 .test = alg_test_skcipher, 2542 .test = alg_test_skcipher,
2498 .suite = { 2543 .suite = {
2499 .cipher = { 2544 .cipher = {
2500 .enc = { 2545 .enc = {
2501 .vecs = tea_enc_tv_template, 2546 .vecs = tea_enc_tv_template,
2502 .count = TEA_ENC_TEST_VECTORS 2547 .count = TEA_ENC_TEST_VECTORS
2503 }, 2548 },
2504 .dec = { 2549 .dec = {
2505 .vecs = tea_dec_tv_template, 2550 .vecs = tea_dec_tv_template,
2506 .count = TEA_DEC_TEST_VECTORS 2551 .count = TEA_DEC_TEST_VECTORS
2507 } 2552 }
2508 } 2553 }
2509 } 2554 }
2510 }, { 2555 }, {
2511 .alg = "ecb(tnepres)", 2556 .alg = "ecb(tnepres)",
2512 .test = alg_test_skcipher, 2557 .test = alg_test_skcipher,
2513 .suite = { 2558 .suite = {
2514 .cipher = { 2559 .cipher = {
2515 .enc = { 2560 .enc = {
2516 .vecs = tnepres_enc_tv_template, 2561 .vecs = tnepres_enc_tv_template,
2517 .count = TNEPRES_ENC_TEST_VECTORS 2562 .count = TNEPRES_ENC_TEST_VECTORS
2518 }, 2563 },
2519 .dec = { 2564 .dec = {
2520 .vecs = tnepres_dec_tv_template, 2565 .vecs = tnepres_dec_tv_template,
2521 .count = TNEPRES_DEC_TEST_VECTORS 2566 .count = TNEPRES_DEC_TEST_VECTORS
2522 } 2567 }
2523 } 2568 }
2524 } 2569 }
2525 }, { 2570 }, {
2526 .alg = "ecb(twofish)", 2571 .alg = "ecb(twofish)",
2527 .test = alg_test_skcipher, 2572 .test = alg_test_skcipher,
2528 .suite = { 2573 .suite = {
2529 .cipher = { 2574 .cipher = {
2530 .enc = { 2575 .enc = {
2531 .vecs = tf_enc_tv_template, 2576 .vecs = tf_enc_tv_template,
2532 .count = TF_ENC_TEST_VECTORS 2577 .count = TF_ENC_TEST_VECTORS
2533 }, 2578 },
2534 .dec = { 2579 .dec = {
2535 .vecs = tf_dec_tv_template, 2580 .vecs = tf_dec_tv_template,
2536 .count = TF_DEC_TEST_VECTORS 2581 .count = TF_DEC_TEST_VECTORS
2537 } 2582 }
2538 } 2583 }
2539 } 2584 }
2540 }, { 2585 }, {
2541 .alg = "ecb(xeta)", 2586 .alg = "ecb(xeta)",
2542 .test = alg_test_skcipher, 2587 .test = alg_test_skcipher,
2543 .suite = { 2588 .suite = {
2544 .cipher = { 2589 .cipher = {
2545 .enc = { 2590 .enc = {
2546 .vecs = xeta_enc_tv_template, 2591 .vecs = xeta_enc_tv_template,
2547 .count = XETA_ENC_TEST_VECTORS 2592 .count = XETA_ENC_TEST_VECTORS
2548 }, 2593 },
2549 .dec = { 2594 .dec = {
2550 .vecs = xeta_dec_tv_template, 2595 .vecs = xeta_dec_tv_template,
2551 .count = XETA_DEC_TEST_VECTORS 2596 .count = XETA_DEC_TEST_VECTORS
2552 } 2597 }
2553 } 2598 }
2554 } 2599 }
2555 }, { 2600 }, {
2556 .alg = "ecb(xtea)", 2601 .alg = "ecb(xtea)",
2557 .test = alg_test_skcipher, 2602 .test = alg_test_skcipher,
2558 .suite = { 2603 .suite = {
2559 .cipher = { 2604 .cipher = {
2560 .enc = { 2605 .enc = {
2561 .vecs = xtea_enc_tv_template, 2606 .vecs = xtea_enc_tv_template,
2562 .count = XTEA_ENC_TEST_VECTORS 2607 .count = XTEA_ENC_TEST_VECTORS
2563 }, 2608 },
2564 .dec = { 2609 .dec = {
2565 .vecs = xtea_dec_tv_template, 2610 .vecs = xtea_dec_tv_template,
2566 .count = XTEA_DEC_TEST_VECTORS 2611 .count = XTEA_DEC_TEST_VECTORS
2567 } 2612 }
2568 } 2613 }
2569 } 2614 }
2570 }, { 2615 }, {
2571 .alg = "gcm(aes)", 2616 .alg = "gcm(aes)",
2572 .test = alg_test_aead, 2617 .test = alg_test_aead,
2573 .fips_allowed = 1, 2618 .fips_allowed = 1,
2574 .suite = { 2619 .suite = {
2575 .aead = { 2620 .aead = {
2576 .enc = { 2621 .enc = {
2577 .vecs = aes_gcm_enc_tv_template, 2622 .vecs = aes_gcm_enc_tv_template,
2578 .count = AES_GCM_ENC_TEST_VECTORS 2623 .count = AES_GCM_ENC_TEST_VECTORS
2579 }, 2624 },
2580 .dec = { 2625 .dec = {
2581 .vecs = aes_gcm_dec_tv_template, 2626 .vecs = aes_gcm_dec_tv_template,
2582 .count = AES_GCM_DEC_TEST_VECTORS 2627 .count = AES_GCM_DEC_TEST_VECTORS
2583 } 2628 }
2584 } 2629 }
2585 } 2630 }
2586 }, { 2631 }, {
2587 .alg = "ghash", 2632 .alg = "ghash",
2588 .test = alg_test_hash, 2633 .test = alg_test_hash,
2589 .fips_allowed = 1, 2634 .fips_allowed = 1,
2590 .suite = { 2635 .suite = {
2591 .hash = { 2636 .hash = {
2592 .vecs = ghash_tv_template, 2637 .vecs = ghash_tv_template,
2593 .count = GHASH_TEST_VECTORS 2638 .count = GHASH_TEST_VECTORS
2594 } 2639 }
2595 } 2640 }
2596 }, { 2641 }, {
2597 .alg = "hmac(crc32)", 2642 .alg = "hmac(crc32)",
2598 .test = alg_test_hash, 2643 .test = alg_test_hash,
2599 .suite = { 2644 .suite = {
2600 .hash = { 2645 .hash = {
2601 .vecs = bfin_crc_tv_template, 2646 .vecs = bfin_crc_tv_template,
2602 .count = BFIN_CRC_TEST_VECTORS 2647 .count = BFIN_CRC_TEST_VECTORS
2603 } 2648 }
2604 } 2649 }
2605 }, { 2650 }, {
2606 .alg = "hmac(md5)", 2651 .alg = "hmac(md5)",
2607 .test = alg_test_hash, 2652 .test = alg_test_hash,
2608 .suite = { 2653 .suite = {
2609 .hash = { 2654 .hash = {
2610 .vecs = hmac_md5_tv_template, 2655 .vecs = hmac_md5_tv_template,
2611 .count = HMAC_MD5_TEST_VECTORS 2656 .count = HMAC_MD5_TEST_VECTORS
2612 } 2657 }
2613 } 2658 }
2614 }, { 2659 }, {
2615 .alg = "hmac(rmd128)", 2660 .alg = "hmac(rmd128)",
2616 .test = alg_test_hash, 2661 .test = alg_test_hash,
2617 .suite = { 2662 .suite = {
2618 .hash = { 2663 .hash = {
2619 .vecs = hmac_rmd128_tv_template, 2664 .vecs = hmac_rmd128_tv_template,
2620 .count = HMAC_RMD128_TEST_VECTORS 2665 .count = HMAC_RMD128_TEST_VECTORS
2621 } 2666 }
2622 } 2667 }
2623 }, { 2668 }, {
2624 .alg = "hmac(rmd160)", 2669 .alg = "hmac(rmd160)",
2625 .test = alg_test_hash, 2670 .test = alg_test_hash,
2626 .suite = { 2671 .suite = {
2627 .hash = { 2672 .hash = {
2628 .vecs = hmac_rmd160_tv_template, 2673 .vecs = hmac_rmd160_tv_template,
2629 .count = HMAC_RMD160_TEST_VECTORS 2674 .count = HMAC_RMD160_TEST_VECTORS
2630 } 2675 }
2631 } 2676 }
2632 }, { 2677 }, {
2633 .alg = "hmac(sha1)", 2678 .alg = "hmac(sha1)",
2634 .test = alg_test_hash, 2679 .test = alg_test_hash,
2635 .fips_allowed = 1, 2680 .fips_allowed = 1,
2636 .suite = { 2681 .suite = {
2637 .hash = { 2682 .hash = {
2638 .vecs = hmac_sha1_tv_template, 2683 .vecs = hmac_sha1_tv_template,
2639 .count = HMAC_SHA1_TEST_VECTORS 2684 .count = HMAC_SHA1_TEST_VECTORS
2640 } 2685 }
2641 } 2686 }
2642 }, { 2687 }, {
2643 .alg = "hmac(sha224)", 2688 .alg = "hmac(sha224)",
2644 .test = alg_test_hash, 2689 .test = alg_test_hash,
2645 .fips_allowed = 1, 2690 .fips_allowed = 1,
2646 .suite = { 2691 .suite = {
2647 .hash = { 2692 .hash = {
2648 .vecs = hmac_sha224_tv_template, 2693 .vecs = hmac_sha224_tv_template,
2649 .count = HMAC_SHA224_TEST_VECTORS 2694 .count = HMAC_SHA224_TEST_VECTORS
2650 } 2695 }
2651 } 2696 }
2652 }, { 2697 }, {
2653 .alg = "hmac(sha256)", 2698 .alg = "hmac(sha256)",
2654 .test = alg_test_hash, 2699 .test = alg_test_hash,
2655 .fips_allowed = 1, 2700 .fips_allowed = 1,
2656 .suite = { 2701 .suite = {
2657 .hash = { 2702 .hash = {
2658 .vecs = hmac_sha256_tv_template, 2703 .vecs = hmac_sha256_tv_template,
2659 .count = HMAC_SHA256_TEST_VECTORS 2704 .count = HMAC_SHA256_TEST_VECTORS
2660 } 2705 }
2661 } 2706 }
2662 }, { 2707 }, {
2663 .alg = "hmac(sha384)", 2708 .alg = "hmac(sha384)",
2664 .test = alg_test_hash, 2709 .test = alg_test_hash,
2665 .fips_allowed = 1, 2710 .fips_allowed = 1,
2666 .suite = { 2711 .suite = {
2667 .hash = { 2712 .hash = {
2668 .vecs = hmac_sha384_tv_template, 2713 .vecs = hmac_sha384_tv_template,
2669 .count = HMAC_SHA384_TEST_VECTORS 2714 .count = HMAC_SHA384_TEST_VECTORS
2670 } 2715 }
2671 } 2716 }
2672 }, { 2717 }, {
2673 .alg = "hmac(sha512)", 2718 .alg = "hmac(sha512)",
2674 .test = alg_test_hash, 2719 .test = alg_test_hash,
2675 .fips_allowed = 1, 2720 .fips_allowed = 1,
2676 .suite = { 2721 .suite = {
2677 .hash = { 2722 .hash = {
2678 .vecs = hmac_sha512_tv_template, 2723 .vecs = hmac_sha512_tv_template,
2679 .count = HMAC_SHA512_TEST_VECTORS 2724 .count = HMAC_SHA512_TEST_VECTORS
2680 } 2725 }
2681 } 2726 }
2682 }, { 2727 }, {
2683 .alg = "lrw(aes)", 2728 .alg = "lrw(aes)",
2684 .test = alg_test_skcipher, 2729 .test = alg_test_skcipher,
2685 .suite = { 2730 .suite = {
2686 .cipher = { 2731 .cipher = {
2687 .enc = { 2732 .enc = {
2688 .vecs = aes_lrw_enc_tv_template, 2733 .vecs = aes_lrw_enc_tv_template,
2689 .count = AES_LRW_ENC_TEST_VECTORS 2734 .count = AES_LRW_ENC_TEST_VECTORS
2690 }, 2735 },
2691 .dec = { 2736 .dec = {
2692 .vecs = aes_lrw_dec_tv_template, 2737 .vecs = aes_lrw_dec_tv_template,
2693 .count = AES_LRW_DEC_TEST_VECTORS 2738 .count = AES_LRW_DEC_TEST_VECTORS
2694 } 2739 }
2695 } 2740 }
2696 } 2741 }
2697 }, { 2742 }, {
2698 .alg = "lrw(camellia)", 2743 .alg = "lrw(camellia)",
2699 .test = alg_test_skcipher, 2744 .test = alg_test_skcipher,
2700 .suite = { 2745 .suite = {
2701 .cipher = { 2746 .cipher = {
2702 .enc = { 2747 .enc = {
2703 .vecs = camellia_lrw_enc_tv_template, 2748 .vecs = camellia_lrw_enc_tv_template,
2704 .count = CAMELLIA_LRW_ENC_TEST_VECTORS 2749 .count = CAMELLIA_LRW_ENC_TEST_VECTORS
2705 }, 2750 },
2706 .dec = { 2751 .dec = {
2707 .vecs = camellia_lrw_dec_tv_template, 2752 .vecs = camellia_lrw_dec_tv_template,
2708 .count = CAMELLIA_LRW_DEC_TEST_VECTORS 2753 .count = CAMELLIA_LRW_DEC_TEST_VECTORS
2709 } 2754 }
2710 } 2755 }
2711 } 2756 }
2712 }, { 2757 }, {
2713 .alg = "lrw(cast6)", 2758 .alg = "lrw(cast6)",
2714 .test = alg_test_skcipher, 2759 .test = alg_test_skcipher,
2715 .suite = { 2760 .suite = {
2716 .cipher = { 2761 .cipher = {
2717 .enc = { 2762 .enc = {
2718 .vecs = cast6_lrw_enc_tv_template, 2763 .vecs = cast6_lrw_enc_tv_template,
2719 .count = CAST6_LRW_ENC_TEST_VECTORS 2764 .count = CAST6_LRW_ENC_TEST_VECTORS
2720 }, 2765 },
2721 .dec = { 2766 .dec = {
2722 .vecs = cast6_lrw_dec_tv_template, 2767 .vecs = cast6_lrw_dec_tv_template,
2723 .count = CAST6_LRW_DEC_TEST_VECTORS 2768 .count = CAST6_LRW_DEC_TEST_VECTORS
2724 } 2769 }
2725 } 2770 }
2726 } 2771 }
2727 }, { 2772 }, {
2728 .alg = "lrw(serpent)", 2773 .alg = "lrw(serpent)",
2729 .test = alg_test_skcipher, 2774 .test = alg_test_skcipher,
2730 .suite = { 2775 .suite = {
2731 .cipher = { 2776 .cipher = {
2732 .enc = { 2777 .enc = {
2733 .vecs = serpent_lrw_enc_tv_template, 2778 .vecs = serpent_lrw_enc_tv_template,
2734 .count = SERPENT_LRW_ENC_TEST_VECTORS 2779 .count = SERPENT_LRW_ENC_TEST_VECTORS
2735 }, 2780 },
2736 .dec = { 2781 .dec = {
2737 .vecs = serpent_lrw_dec_tv_template, 2782 .vecs = serpent_lrw_dec_tv_template,
2738 .count = SERPENT_LRW_DEC_TEST_VECTORS 2783 .count = SERPENT_LRW_DEC_TEST_VECTORS
2739 } 2784 }
2740 } 2785 }
2741 } 2786 }
2742 }, { 2787 }, {
2743 .alg = "lrw(twofish)", 2788 .alg = "lrw(twofish)",
2744 .test = alg_test_skcipher, 2789 .test = alg_test_skcipher,
2745 .suite = { 2790 .suite = {
2746 .cipher = { 2791 .cipher = {
2747 .enc = { 2792 .enc = {
2748 .vecs = tf_lrw_enc_tv_template, 2793 .vecs = tf_lrw_enc_tv_template,
2749 .count = TF_LRW_ENC_TEST_VECTORS 2794 .count = TF_LRW_ENC_TEST_VECTORS
2750 }, 2795 },
2751 .dec = { 2796 .dec = {
2752 .vecs = tf_lrw_dec_tv_template, 2797 .vecs = tf_lrw_dec_tv_template,
2753 .count = TF_LRW_DEC_TEST_VECTORS 2798 .count = TF_LRW_DEC_TEST_VECTORS
2754 } 2799 }
2755 } 2800 }
2756 } 2801 }
2757 }, { 2802 }, {
2758 .alg = "lzo", 2803 .alg = "lzo",
2759 .test = alg_test_comp, 2804 .test = alg_test_comp,
2760 .suite = { 2805 .suite = {
2761 .comp = { 2806 .comp = {
2762 .comp = { 2807 .comp = {
2763 .vecs = lzo_comp_tv_template, 2808 .vecs = lzo_comp_tv_template,
2764 .count = LZO_COMP_TEST_VECTORS 2809 .count = LZO_COMP_TEST_VECTORS
2765 }, 2810 },
2766 .decomp = { 2811 .decomp = {
2767 .vecs = lzo_decomp_tv_template, 2812 .vecs = lzo_decomp_tv_template,
2768 .count = LZO_DECOMP_TEST_VECTORS 2813 .count = LZO_DECOMP_TEST_VECTORS
2769 } 2814 }
2770 } 2815 }
2771 } 2816 }
2772 }, { 2817 }, {
2773 .alg = "md4", 2818 .alg = "md4",
2774 .test = alg_test_hash, 2819 .test = alg_test_hash,
2775 .suite = { 2820 .suite = {
2776 .hash = { 2821 .hash = {
2777 .vecs = md4_tv_template, 2822 .vecs = md4_tv_template,
2778 .count = MD4_TEST_VECTORS 2823 .count = MD4_TEST_VECTORS
2779 } 2824 }
2780 } 2825 }
2781 }, { 2826 }, {
2782 .alg = "md5", 2827 .alg = "md5",
2783 .test = alg_test_hash, 2828 .test = alg_test_hash,
2784 .suite = { 2829 .suite = {
2785 .hash = { 2830 .hash = {
2786 .vecs = md5_tv_template, 2831 .vecs = md5_tv_template,
2787 .count = MD5_TEST_VECTORS 2832 .count = MD5_TEST_VECTORS
2788 } 2833 }
2789 } 2834 }
2790 }, { 2835 }, {
2791 .alg = "michael_mic", 2836 .alg = "michael_mic",
2792 .test = alg_test_hash, 2837 .test = alg_test_hash,
2793 .suite = { 2838 .suite = {
2794 .hash = { 2839 .hash = {
2795 .vecs = michael_mic_tv_template, 2840 .vecs = michael_mic_tv_template,
2796 .count = MICHAEL_MIC_TEST_VECTORS 2841 .count = MICHAEL_MIC_TEST_VECTORS
2797 } 2842 }
2798 } 2843 }
2799 }, { 2844 }, {
2800 .alg = "ofb(aes)", 2845 .alg = "ofb(aes)",
2801 .test = alg_test_skcipher, 2846 .test = alg_test_skcipher,
2802 .fips_allowed = 1, 2847 .fips_allowed = 1,
2803 .suite = { 2848 .suite = {
2804 .cipher = { 2849 .cipher = {
2805 .enc = { 2850 .enc = {
2806 .vecs = aes_ofb_enc_tv_template, 2851 .vecs = aes_ofb_enc_tv_template,
2807 .count = AES_OFB_ENC_TEST_VECTORS 2852 .count = AES_OFB_ENC_TEST_VECTORS
2808 }, 2853 },
2809 .dec = { 2854 .dec = {
2810 .vecs = aes_ofb_dec_tv_template, 2855 .vecs = aes_ofb_dec_tv_template,
2811 .count = AES_OFB_DEC_TEST_VECTORS 2856 .count = AES_OFB_DEC_TEST_VECTORS
2812 } 2857 }
2813 } 2858 }
2814 } 2859 }
2815 }, { 2860 }, {
2816 .alg = "pcbc(fcrypt)", 2861 .alg = "pcbc(fcrypt)",
2817 .test = alg_test_skcipher, 2862 .test = alg_test_skcipher,
2818 .suite = { 2863 .suite = {
2819 .cipher = { 2864 .cipher = {
2820 .enc = { 2865 .enc = {
2821 .vecs = fcrypt_pcbc_enc_tv_template, 2866 .vecs = fcrypt_pcbc_enc_tv_template,
2822 .count = FCRYPT_ENC_TEST_VECTORS 2867 .count = FCRYPT_ENC_TEST_VECTORS
2823 }, 2868 },
2824 .dec = { 2869 .dec = {
2825 .vecs = fcrypt_pcbc_dec_tv_template, 2870 .vecs = fcrypt_pcbc_dec_tv_template,
2826 .count = FCRYPT_DEC_TEST_VECTORS 2871 .count = FCRYPT_DEC_TEST_VECTORS
2827 } 2872 }
2828 } 2873 }
2829 } 2874 }
2830 }, { 2875 }, {
2831 .alg = "rfc3686(ctr(aes))", 2876 .alg = "rfc3686(ctr(aes))",
2832 .test = alg_test_skcipher, 2877 .test = alg_test_skcipher,
2833 .fips_allowed = 1, 2878 .fips_allowed = 1,
2834 .suite = { 2879 .suite = {
2835 .cipher = { 2880 .cipher = {
2836 .enc = { 2881 .enc = {
2837 .vecs = aes_ctr_rfc3686_enc_tv_template, 2882 .vecs = aes_ctr_rfc3686_enc_tv_template,
2838 .count = AES_CTR_3686_ENC_TEST_VECTORS 2883 .count = AES_CTR_3686_ENC_TEST_VECTORS
2839 }, 2884 },
2840 .dec = { 2885 .dec = {
2841 .vecs = aes_ctr_rfc3686_dec_tv_template, 2886 .vecs = aes_ctr_rfc3686_dec_tv_template,
2842 .count = AES_CTR_3686_DEC_TEST_VECTORS 2887 .count = AES_CTR_3686_DEC_TEST_VECTORS
2843 } 2888 }
2844 } 2889 }
2845 } 2890 }
2846 }, { 2891 }, {
2847 .alg = "rfc4106(gcm(aes))", 2892 .alg = "rfc4106(gcm(aes))",
2848 .test = alg_test_aead, 2893 .test = alg_test_aead,
2849 .suite = { 2894 .suite = {
2850 .aead = { 2895 .aead = {
2851 .enc = { 2896 .enc = {
2852 .vecs = aes_gcm_rfc4106_enc_tv_template, 2897 .vecs = aes_gcm_rfc4106_enc_tv_template,
2853 .count = AES_GCM_4106_ENC_TEST_VECTORS 2898 .count = AES_GCM_4106_ENC_TEST_VECTORS
2854 }, 2899 },
2855 .dec = { 2900 .dec = {
2856 .vecs = aes_gcm_rfc4106_dec_tv_template, 2901 .vecs = aes_gcm_rfc4106_dec_tv_template,
2857 .count = AES_GCM_4106_DEC_TEST_VECTORS 2902 .count = AES_GCM_4106_DEC_TEST_VECTORS
2858 } 2903 }
2859 } 2904 }
2860 } 2905 }
2861 }, { 2906 }, {
2862 2907
2863 2908
2864 .alg = "rfc4309(ccm(aes))", 2909 .alg = "rfc4309(ccm(aes))",
2865 .test = alg_test_aead, 2910 .test = alg_test_aead,
2866 .fips_allowed = 1, 2911 .fips_allowed = 1,
2867 .suite = { 2912 .suite = {
2868 .aead = { 2913 .aead = {
2869 .enc = { 2914 .enc = {
2870 .vecs = aes_ccm_rfc4309_enc_tv_template, 2915 .vecs = aes_ccm_rfc4309_enc_tv_template,
2871 .count = AES_CCM_4309_ENC_TEST_VECTORS 2916 .count = AES_CCM_4309_ENC_TEST_VECTORS
2872 }, 2917 },
2873 .dec = { 2918 .dec = {
2874 .vecs = aes_ccm_rfc4309_dec_tv_template, 2919 .vecs = aes_ccm_rfc4309_dec_tv_template,
2875 .count = AES_CCM_4309_DEC_TEST_VECTORS 2920 .count = AES_CCM_4309_DEC_TEST_VECTORS
2876 } 2921 }
2877 } 2922 }
2878 } 2923 }
2879 }, { 2924 }, {
2880 .alg = "rmd128", 2925 .alg = "rmd128",
2881 .test = alg_test_hash, 2926 .test = alg_test_hash,
2882 .suite = { 2927 .suite = {
2883 .hash = { 2928 .hash = {
2884 .vecs = rmd128_tv_template, 2929 .vecs = rmd128_tv_template,
2885 .count = RMD128_TEST_VECTORS 2930 .count = RMD128_TEST_VECTORS
2886 } 2931 }
2887 } 2932 }
2888 }, { 2933 }, {
2889 .alg = "rmd160", 2934 .alg = "rmd160",
2890 .test = alg_test_hash, 2935 .test = alg_test_hash,
2891 .suite = { 2936 .suite = {
2892 .hash = { 2937 .hash = {
2893 .vecs = rmd160_tv_template, 2938 .vecs = rmd160_tv_template,
2894 .count = RMD160_TEST_VECTORS 2939 .count = RMD160_TEST_VECTORS
2895 } 2940 }
2896 } 2941 }
2897 }, { 2942 }, {
2898 .alg = "rmd256", 2943 .alg = "rmd256",
2899 .test = alg_test_hash, 2944 .test = alg_test_hash,
2900 .suite = { 2945 .suite = {
2901 .hash = { 2946 .hash = {
2902 .vecs = rmd256_tv_template, 2947 .vecs = rmd256_tv_template,
2903 .count = RMD256_TEST_VECTORS 2948 .count = RMD256_TEST_VECTORS
2904 } 2949 }
2905 } 2950 }
2906 }, { 2951 }, {
2907 .alg = "rmd320", 2952 .alg = "rmd320",
2908 .test = alg_test_hash, 2953 .test = alg_test_hash,
2909 .suite = { 2954 .suite = {
2910 .hash = { 2955 .hash = {
2911 .vecs = rmd320_tv_template, 2956 .vecs = rmd320_tv_template,
2912 .count = RMD320_TEST_VECTORS 2957 .count = RMD320_TEST_VECTORS
2913 } 2958 }
2914 } 2959 }
2915 }, { 2960 }, {
2916 .alg = "salsa20", 2961 .alg = "salsa20",
2917 .test = alg_test_skcipher, 2962 .test = alg_test_skcipher,
2918 .suite = { 2963 .suite = {
2919 .cipher = { 2964 .cipher = {
2920 .enc = { 2965 .enc = {
2921 .vecs = salsa20_stream_enc_tv_template, 2966 .vecs = salsa20_stream_enc_tv_template,
2922 .count = SALSA20_STREAM_ENC_TEST_VECTORS 2967 .count = SALSA20_STREAM_ENC_TEST_VECTORS
2923 } 2968 }
2924 } 2969 }
2925 } 2970 }
2926 }, { 2971 }, {
2927 .alg = "sha1", 2972 .alg = "sha1",
2928 .test = alg_test_hash, 2973 .test = alg_test_hash,
2929 .fips_allowed = 1, 2974 .fips_allowed = 1,
2930 .suite = { 2975 .suite = {
2931 .hash = { 2976 .hash = {
2932 .vecs = sha1_tv_template, 2977 .vecs = sha1_tv_template,
2933 .count = SHA1_TEST_VECTORS 2978 .count = SHA1_TEST_VECTORS
2934 } 2979 }
2935 } 2980 }
2936 }, { 2981 }, {
2937 .alg = "sha224", 2982 .alg = "sha224",
2938 .test = alg_test_hash, 2983 .test = alg_test_hash,
2939 .fips_allowed = 1, 2984 .fips_allowed = 1,
2940 .suite = { 2985 .suite = {
2941 .hash = { 2986 .hash = {
2942 .vecs = sha224_tv_template, 2987 .vecs = sha224_tv_template,
2943 .count = SHA224_TEST_VECTORS 2988 .count = SHA224_TEST_VECTORS
2944 } 2989 }
2945 } 2990 }
2946 }, { 2991 }, {
2947 .alg = "sha256", 2992 .alg = "sha256",
2948 .test = alg_test_hash, 2993 .test = alg_test_hash,
2949 .fips_allowed = 1, 2994 .fips_allowed = 1,
2950 .suite = { 2995 .suite = {
2951 .hash = { 2996 .hash = {
2952 .vecs = sha256_tv_template, 2997 .vecs = sha256_tv_template,
2953 .count = SHA256_TEST_VECTORS 2998 .count = SHA256_TEST_VECTORS
2954 } 2999 }
2955 } 3000 }
2956 }, { 3001 }, {
2957 .alg = "sha384", 3002 .alg = "sha384",
2958 .test = alg_test_hash, 3003 .test = alg_test_hash,
2959 .fips_allowed = 1, 3004 .fips_allowed = 1,
2960 .suite = { 3005 .suite = {
2961 .hash = { 3006 .hash = {
2962 .vecs = sha384_tv_template, 3007 .vecs = sha384_tv_template,
2963 .count = SHA384_TEST_VECTORS 3008 .count = SHA384_TEST_VECTORS
2964 } 3009 }
2965 } 3010 }
2966 }, { 3011 }, {
2967 .alg = "sha512", 3012 .alg = "sha512",
2968 .test = alg_test_hash, 3013 .test = alg_test_hash,
2969 .fips_allowed = 1, 3014 .fips_allowed = 1,
2970 .suite = { 3015 .suite = {
2971 .hash = { 3016 .hash = {
2972 .vecs = sha512_tv_template, 3017 .vecs = sha512_tv_template,
2973 .count = SHA512_TEST_VECTORS 3018 .count = SHA512_TEST_VECTORS
2974 } 3019 }
2975 } 3020 }
2976 }, { 3021 }, {
2977 .alg = "tgr128", 3022 .alg = "tgr128",
2978 .test = alg_test_hash, 3023 .test = alg_test_hash,
2979 .suite = { 3024 .suite = {
2980 .hash = { 3025 .hash = {
2981 .vecs = tgr128_tv_template, 3026 .vecs = tgr128_tv_template,
2982 .count = TGR128_TEST_VECTORS 3027 .count = TGR128_TEST_VECTORS
2983 } 3028 }
2984 } 3029 }
2985 }, { 3030 }, {
2986 .alg = "tgr160", 3031 .alg = "tgr160",
2987 .test = alg_test_hash, 3032 .test = alg_test_hash,
2988 .suite = { 3033 .suite = {
2989 .hash = { 3034 .hash = {
2990 .vecs = tgr160_tv_template, 3035 .vecs = tgr160_tv_template,
2991 .count = TGR160_TEST_VECTORS 3036 .count = TGR160_TEST_VECTORS
2992 } 3037 }
2993 } 3038 }
2994 }, { 3039 }, {
2995 .alg = "tgr192", 3040 .alg = "tgr192",
2996 .test = alg_test_hash, 3041 .test = alg_test_hash,
2997 .suite = { 3042 .suite = {
2998 .hash = { 3043 .hash = {
2999 .vecs = tgr192_tv_template, 3044 .vecs = tgr192_tv_template,
3000 .count = TGR192_TEST_VECTORS 3045 .count = TGR192_TEST_VECTORS
3001 } 3046 }
3002 } 3047 }
3003 }, { 3048 }, {
3004 .alg = "vmac(aes)", 3049 .alg = "vmac(aes)",
3005 .test = alg_test_hash, 3050 .test = alg_test_hash,
3006 .suite = { 3051 .suite = {
3007 .hash = { 3052 .hash = {
3008 .vecs = aes_vmac128_tv_template, 3053 .vecs = aes_vmac128_tv_template,
3009 .count = VMAC_AES_TEST_VECTORS 3054 .count = VMAC_AES_TEST_VECTORS
3010 } 3055 }
3011 } 3056 }
3012 }, { 3057 }, {
3013 .alg = "wp256", 3058 .alg = "wp256",
3014 .test = alg_test_hash, 3059 .test = alg_test_hash,
3015 .suite = { 3060 .suite = {
3016 .hash = { 3061 .hash = {
3017 .vecs = wp256_tv_template, 3062 .vecs = wp256_tv_template,
3018 .count = WP256_TEST_VECTORS 3063 .count = WP256_TEST_VECTORS
3019 } 3064 }
3020 } 3065 }
3021 }, { 3066 }, {
3022 .alg = "wp384", 3067 .alg = "wp384",
3023 .test = alg_test_hash, 3068 .test = alg_test_hash,
3024 .suite = { 3069 .suite = {
3025 .hash = { 3070 .hash = {
3026 .vecs = wp384_tv_template, 3071 .vecs = wp384_tv_template,
3027 .count = WP384_TEST_VECTORS 3072 .count = WP384_TEST_VECTORS
3028 } 3073 }
3029 } 3074 }
3030 }, { 3075 }, {
3031 .alg = "wp512", 3076 .alg = "wp512",
3032 .test = alg_test_hash, 3077 .test = alg_test_hash,
3033 .suite = { 3078 .suite = {
3034 .hash = { 3079 .hash = {
3035 .vecs = wp512_tv_template, 3080 .vecs = wp512_tv_template,
3036 .count = WP512_TEST_VECTORS 3081 .count = WP512_TEST_VECTORS
3037 } 3082 }
3038 } 3083 }
3039 }, { 3084 }, {
3040 .alg = "xcbc(aes)", 3085 .alg = "xcbc(aes)",
3041 .test = alg_test_hash, 3086 .test = alg_test_hash,
3042 .suite = { 3087 .suite = {
3043 .hash = { 3088 .hash = {
3044 .vecs = aes_xcbc128_tv_template, 3089 .vecs = aes_xcbc128_tv_template,
3045 .count = XCBC_AES_TEST_VECTORS 3090 .count = XCBC_AES_TEST_VECTORS
3046 } 3091 }
3047 } 3092 }
3048 }, { 3093 }, {
3049 .alg = "xts(aes)", 3094 .alg = "xts(aes)",
3050 .test = alg_test_skcipher, 3095 .test = alg_test_skcipher,
3051 .fips_allowed = 1, 3096 .fips_allowed = 1,
3052 .suite = { 3097 .suite = {
3053 .cipher = { 3098 .cipher = {
3054 .enc = { 3099 .enc = {
3055 .vecs = aes_xts_enc_tv_template, 3100 .vecs = aes_xts_enc_tv_template,
3056 .count = AES_XTS_ENC_TEST_VECTORS 3101 .count = AES_XTS_ENC_TEST_VECTORS
3057 }, 3102 },
3058 .dec = { 3103 .dec = {
3059 .vecs = aes_xts_dec_tv_template, 3104 .vecs = aes_xts_dec_tv_template,
3060 .count = AES_XTS_DEC_TEST_VECTORS 3105 .count = AES_XTS_DEC_TEST_VECTORS
3061 } 3106 }
3062 } 3107 }
3063 } 3108 }
3064 }, { 3109 }, {
3065 .alg = "xts(camellia)", 3110 .alg = "xts(camellia)",
3066 .test = alg_test_skcipher, 3111 .test = alg_test_skcipher,
3067 .suite = { 3112 .suite = {
3068 .cipher = { 3113 .cipher = {
3069 .enc = { 3114 .enc = {
3070 .vecs = camellia_xts_enc_tv_template, 3115 .vecs = camellia_xts_enc_tv_template,
3071 .count = CAMELLIA_XTS_ENC_TEST_VECTORS 3116 .count = CAMELLIA_XTS_ENC_TEST_VECTORS
3072 }, 3117 },
3073 .dec = { 3118 .dec = {
3074 .vecs = camellia_xts_dec_tv_template, 3119 .vecs = camellia_xts_dec_tv_template,
3075 .count = CAMELLIA_XTS_DEC_TEST_VECTORS 3120 .count = CAMELLIA_XTS_DEC_TEST_VECTORS
3076 } 3121 }
3077 } 3122 }
3078 } 3123 }
3079 }, { 3124 }, {
3080 .alg = "xts(cast6)", 3125 .alg = "xts(cast6)",
3081 .test = alg_test_skcipher, 3126 .test = alg_test_skcipher,
3082 .suite = { 3127 .suite = {
3083 .cipher = { 3128 .cipher = {
3084 .enc = { 3129 .enc = {
3085 .vecs = cast6_xts_enc_tv_template, 3130 .vecs = cast6_xts_enc_tv_template,
3086 .count = CAST6_XTS_ENC_TEST_VECTORS 3131 .count = CAST6_XTS_ENC_TEST_VECTORS
3087 }, 3132 },
3088 .dec = { 3133 .dec = {
3089 .vecs = cast6_xts_dec_tv_template, 3134 .vecs = cast6_xts_dec_tv_template,
3090 .count = CAST6_XTS_DEC_TEST_VECTORS 3135 .count = CAST6_XTS_DEC_TEST_VECTORS
3091 } 3136 }
3092 } 3137 }
3093 } 3138 }
3094 }, { 3139 }, {
3095 .alg = "xts(serpent)", 3140 .alg = "xts(serpent)",
3096 .test = alg_test_skcipher, 3141 .test = alg_test_skcipher,
3097 .suite = { 3142 .suite = {
3098 .cipher = { 3143 .cipher = {
3099 .enc = { 3144 .enc = {
3100 .vecs = serpent_xts_enc_tv_template, 3145 .vecs = serpent_xts_enc_tv_template,
3101 .count = SERPENT_XTS_ENC_TEST_VECTORS 3146 .count = SERPENT_XTS_ENC_TEST_VECTORS
3102 }, 3147 },
3103 .dec = { 3148 .dec = {
3104 .vecs = serpent_xts_dec_tv_template, 3149 .vecs = serpent_xts_dec_tv_template,
3105 .count = SERPENT_XTS_DEC_TEST_VECTORS 3150 .count = SERPENT_XTS_DEC_TEST_VECTORS
3106 } 3151 }
3107 } 3152 }
3108 } 3153 }
3109 }, { 3154 }, {
3110 .alg = "xts(twofish)", 3155 .alg = "xts(twofish)",
3111 .test = alg_test_skcipher, 3156 .test = alg_test_skcipher,
3112 .suite = { 3157 .suite = {
3113 .cipher = { 3158 .cipher = {
3114 .enc = { 3159 .enc = {
3115 .vecs = tf_xts_enc_tv_template, 3160 .vecs = tf_xts_enc_tv_template,
3116 .count = TF_XTS_ENC_TEST_VECTORS 3161 .count = TF_XTS_ENC_TEST_VECTORS
3117 }, 3162 },
3118 .dec = { 3163 .dec = {
3119 .vecs = tf_xts_dec_tv_template, 3164 .vecs = tf_xts_dec_tv_template,
3120 .count = TF_XTS_DEC_TEST_VECTORS 3165 .count = TF_XTS_DEC_TEST_VECTORS
3121 } 3166 }
3122 } 3167 }
3123 } 3168 }
3124 }, { 3169 }, {
3125 .alg = "zlib", 3170 .alg = "zlib",
3126 .test = alg_test_pcomp, 3171 .test = alg_test_pcomp,
3127 .suite = { 3172 .suite = {
3128 .pcomp = { 3173 .pcomp = {
3129 .comp = { 3174 .comp = {
3130 .vecs = zlib_comp_tv_template, 3175 .vecs = zlib_comp_tv_template,
3131 .count = ZLIB_COMP_TEST_VECTORS 3176 .count = ZLIB_COMP_TEST_VECTORS
3132 }, 3177 },
3133 .decomp = { 3178 .decomp = {
3134 .vecs = zlib_decomp_tv_template, 3179 .vecs = zlib_decomp_tv_template,
3135 .count = ZLIB_DECOMP_TEST_VECTORS 3180 .count = ZLIB_DECOMP_TEST_VECTORS
3136 } 3181 }
3137 } 3182 }
3138 } 3183 }
3139 } 3184 }
3140 }; 3185 };
3141 3186
3142 static int alg_find_test(const char *alg) 3187 static int alg_find_test(const char *alg)
3143 { 3188 {
3144 int start = 0; 3189 int start = 0;
3145 int end = ARRAY_SIZE(alg_test_descs); 3190 int end = ARRAY_SIZE(alg_test_descs);
3146 3191
3147 while (start < end) { 3192 while (start < end) {
3148 int i = (start + end) / 2; 3193 int i = (start + end) / 2;
3149 int diff = strcmp(alg_test_descs[i].alg, alg); 3194 int diff = strcmp(alg_test_descs[i].alg, alg);
3150 3195
3151 if (diff > 0) { 3196 if (diff > 0) {
3152 end = i; 3197 end = i;
3153 continue; 3198 continue;
3154 } 3199 }
3155 3200
3156 if (diff < 0) { 3201 if (diff < 0) {
3157 start = i + 1; 3202 start = i + 1;
3158 continue; 3203 continue;
3159 } 3204 }
3160 3205
3161 return i; 3206 return i;
3162 } 3207 }
3163 3208
3164 return -1; 3209 return -1;
3165 } 3210 }
3166 3211
3167 int alg_test(const char *driver, const char *alg, u32 type, u32 mask) 3212 int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
3168 { 3213 {
3169 int i; 3214 int i;
3170 int j; 3215 int j;
3171 int rc; 3216 int rc;
3172 3217
3173 if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) { 3218 if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
3174 char nalg[CRYPTO_MAX_ALG_NAME]; 3219 char nalg[CRYPTO_MAX_ALG_NAME];
3175 3220
3176 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >= 3221 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
3177 sizeof(nalg)) 3222 sizeof(nalg))
3178 return -ENAMETOOLONG; 3223 return -ENAMETOOLONG;
3179 3224
3180 i = alg_find_test(nalg); 3225 i = alg_find_test(nalg);
3181 if (i < 0) 3226 if (i < 0)
3182 goto notest; 3227 goto notest;
3183 3228
3184 if (fips_enabled && !alg_test_descs[i].fips_allowed) 3229 if (fips_enabled && !alg_test_descs[i].fips_allowed)
3185 goto non_fips_alg; 3230 goto non_fips_alg;
3186 3231
3187 rc = alg_test_cipher(alg_test_descs + i, driver, type, mask); 3232 rc = alg_test_cipher(alg_test_descs + i, driver, type, mask);
3188 goto test_done; 3233 goto test_done;
3189 } 3234 }
3190 3235
3191 i = alg_find_test(alg); 3236 i = alg_find_test(alg);
3192 j = alg_find_test(driver); 3237 j = alg_find_test(driver);
3193 if (i < 0 && j < 0) 3238 if (i < 0 && j < 0)
3194 goto notest; 3239 goto notest;
3195 3240
3196 if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) || 3241 if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) ||
3197 (j >= 0 && !alg_test_descs[j].fips_allowed))) 3242 (j >= 0 && !alg_test_descs[j].fips_allowed)))
3198 goto non_fips_alg; 3243 goto non_fips_alg;
3199 3244
3200 rc = 0; 3245 rc = 0;
3201 if (i >= 0) 3246 if (i >= 0)
3202 rc |= alg_test_descs[i].test(alg_test_descs + i, driver, 3247 rc |= alg_test_descs[i].test(alg_test_descs + i, driver,
3203 type, mask); 3248 type, mask);
3204 if (j >= 0) 3249 if (j >= 0)
3205 rc |= alg_test_descs[j].test(alg_test_descs + j, driver, 3250 rc |= alg_test_descs[j].test(alg_test_descs + j, driver,
3206 type, mask); 3251 type, mask);
3207 3252
3208 test_done: 3253 test_done:
3209 if (fips_enabled && rc) 3254 if (fips_enabled && rc)
3210 panic("%s: %s alg self test failed in fips mode!\n", driver, alg); 3255 panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
3211 3256
3212 if (fips_enabled && !rc) 3257 if (fips_enabled && !rc)
3213 printk(KERN_INFO "alg: self-tests for %s (%s) passed\n", 3258 printk(KERN_INFO "alg: self-tests for %s (%s) passed\n",
3214 driver, alg); 3259 driver, alg);
3215 3260
3216 return rc; 3261 return rc;
3217 3262
3218 notest: 3263 notest:
3219 printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver); 3264 printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
3220 return 0; 3265 return 0;
3221 non_fips_alg: 3266 non_fips_alg: