| /* |
| * Algorithm testing framework and tests. |
| * |
| * Copyright (c) 2002 James Morris <jmorris@intercode.com.au> |
| * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org> |
| * Copyright (c) 2007 Nokia Siemens Networks |
| * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au> |
| * Copyright (c) 2019 Google LLC |
| * |
| * Updated RFC4106 AES-GCM testing. |
| * Authors: Aidan O'Mahony (aidan.o.mahony@intel.com) |
| * Adrian Hoban <adrian.hoban@intel.com> |
| * Gabriele Paoloni <gabriele.paoloni@intel.com> |
| * Tadeusz Struk (tadeusz.struk@intel.com) |
| * Copyright (c) 2010, Intel Corporation. |
| * |
| * This program is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License as published by the Free |
| * Software Foundation; either version 2 of the License, or (at your option) |
| * any later version. |
| * |
| */ |
| |
| #include <crypto/aead.h> |
| #include <crypto/hash.h> |
| #include <crypto/skcipher.h> |
| #include <linux/err.h> |
| #include <linux/fips.h> |
| #include <linux/module.h> |
| #include <linux/once.h> |
| #include <linux/random.h> |
| #include <linux/scatterlist.h> |
| #include <linux/slab.h> |
| #include <linux/string.h> |
| #include <crypto/rng.h> |
| #include <crypto/drbg.h> |
| #include <crypto/akcipher.h> |
| #include <crypto/kpp.h> |
| #include <crypto/acompress.h> |
| |
| #include "internal.h" |
| |
| static bool notests; |
| module_param(notests, bool, 0644); |
| MODULE_PARM_DESC(notests, "disable crypto self-tests"); |
| |
| #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS |
| static bool noextratests; |
| module_param(noextratests, bool, 0644); |
| MODULE_PARM_DESC(noextratests, "disable expensive crypto self-tests"); |
| |
| static unsigned int fuzz_iterations = 100; |
| module_param(fuzz_iterations, uint, 0644); |
| MODULE_PARM_DESC(fuzz_iterations, "number of fuzz test iterations"); |
| #endif |
| |
| #ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS |
| |
| /* a perfect nop */ |
| int alg_test(const char *driver, const char *alg, u32 type, u32 mask) |
| { |
| return 0; |
| } |
| |
| #else |
| |
| #include "testmgr.h" |
| |
| /* |
| * Need slab memory for testing (size in number of pages). |
| */ |
| #define XBUFSIZE 8 |
| |
| /* |
| * Used by test_cipher() |
| */ |
| #define ENCRYPT 1 |
| #define DECRYPT 0 |
| |
| struct aead_test_suite { |
| const struct aead_testvec *vecs; |
| unsigned int count; |
| }; |
| |
| struct cipher_test_suite { |
| const struct cipher_testvec *vecs; |
| unsigned int count; |
| }; |
| |
| struct comp_test_suite { |
| struct { |
| const struct comp_testvec *vecs; |
| unsigned int count; |
| } comp, decomp; |
| }; |
| |
| struct hash_test_suite { |
| const struct hash_testvec *vecs; |
| unsigned int count; |
| }; |
| |
| struct cprng_test_suite { |
| const struct cprng_testvec *vecs; |
| unsigned int count; |
| }; |
| |
| struct drbg_test_suite { |
| const struct drbg_testvec *vecs; |
| unsigned int count; |
| }; |
| |
| struct akcipher_test_suite { |
| const struct akcipher_testvec *vecs; |
| unsigned int count; |
| }; |
| |
| struct kpp_test_suite { |
| const struct kpp_testvec *vecs; |
| unsigned int count; |
| }; |
| |
| struct alg_test_desc { |
| const char *alg; |
| int (*test)(const struct alg_test_desc *desc, const char *driver, |
| u32 type, u32 mask); |
| int fips_allowed; /* set if alg is allowed in fips mode */ |
| |
| union { |
| struct aead_test_suite aead; |
| struct cipher_test_suite cipher; |
| struct comp_test_suite comp; |
| struct hash_test_suite hash; |
| struct cprng_test_suite cprng; |
| struct drbg_test_suite drbg; |
| struct akcipher_test_suite akcipher; |
| struct kpp_test_suite kpp; |
| } suite; |
| }; |
| |
| static void hexdump(unsigned char *buf, unsigned int len) |
| { |
| print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET, |
| 16, 1, |
| buf, len, false); |
| } |
| |
| static int __testmgr_alloc_buf(char *buf[XBUFSIZE], int order) |
| { |
| int i; |
| |
| for (i = 0; i < XBUFSIZE; i++) { |
| buf[i] = (char *)__get_free_pages(GFP_KERNEL, order); |
| if (!buf[i]) |
| goto err_free_buf; |
| } |
| |
| return 0; |
| |
| err_free_buf: |
| while (i-- > 0) |
| free_pages((unsigned long)buf[i], order); |
| |
| return -ENOMEM; |
| } |
| |
| static int testmgr_alloc_buf(char *buf[XBUFSIZE]) |
| { |
| return __testmgr_alloc_buf(buf, 0); |
| } |
| |
| static void __testmgr_free_buf(char *buf[XBUFSIZE], int order) |
| { |
| int i; |
| |
| for (i = 0; i < XBUFSIZE; i++) |
| free_pages((unsigned long)buf[i], order); |
| } |
| |
| static void testmgr_free_buf(char *buf[XBUFSIZE]) |
| { |
| __testmgr_free_buf(buf, 0); |
| } |
| |
| #define TESTMGR_POISON_BYTE 0xfe |
| #define TESTMGR_POISON_LEN 16 |
| |
| static inline void testmgr_poison(void *addr, size_t len) |
| { |
| memset(addr, TESTMGR_POISON_BYTE, len); |
| } |
| |
| /* Is the memory region still fully poisoned? */ |
| static inline bool testmgr_is_poison(const void *addr, size_t len) |
| { |
| return memchr_inv(addr, TESTMGR_POISON_BYTE, len) == NULL; |
| } |
| |
| /* flush type for hash algorithms */ |
| enum flush_type { |
| /* merge with update of previous buffer(s) */ |
| FLUSH_TYPE_NONE = 0, |
| |
| /* update with previous buffer(s) before doing this one */ |
| FLUSH_TYPE_FLUSH, |
| |
| /* likewise, but also export and re-import the intermediate state */ |
| FLUSH_TYPE_REIMPORT, |
| }; |
| |
| /* finalization function for hash algorithms */ |
| enum finalization_type { |
| FINALIZATION_TYPE_FINAL, /* use final() */ |
| FINALIZATION_TYPE_FINUP, /* use finup() */ |
| FINALIZATION_TYPE_DIGEST, /* use digest() */ |
| }; |
| |
| #define TEST_SG_TOTAL 10000 |
| |
| /** |
| * struct test_sg_division - description of a scatterlist entry |
| * |
| * This struct describes one entry of a scatterlist being constructed to check a |
| * crypto test vector. |
| * |
| * @proportion_of_total: length of this chunk relative to the total length, |
| * given as a proportion out of TEST_SG_TOTAL so that it |
| * scales to fit any test vector |
| * @offset: byte offset into a 2-page buffer at which this chunk will start |
| * @offset_relative_to_alignmask: if true, add the algorithm's alignmask to the |
| * @offset |
| * @flush_type: for hashes, whether an update() should be done now vs. |
| * continuing to accumulate data |
| */ |
| struct test_sg_division { |
| unsigned int proportion_of_total; |
| unsigned int offset; |
| bool offset_relative_to_alignmask; |
| enum flush_type flush_type; |
| }; |
| |
| /** |
| * struct testvec_config - configuration for testing a crypto test vector |
| * |
| * This struct describes the data layout and other parameters with which each |
| * crypto test vector can be tested. |
| * |
| * @name: name of this config, logged for debugging purposes if a test fails |
| * @inplace: operate on the data in-place, if applicable for the algorithm type? |
| * @req_flags: extra request_flags, e.g. CRYPTO_TFM_REQ_MAY_SLEEP |
| * @src_divs: description of how to arrange the source scatterlist |
| * @dst_divs: description of how to arrange the dst scatterlist, if applicable |
| * for the algorithm type. Defaults to @src_divs if unset. |
| * @iv_offset: misalignment of the IV in the range [0..MAX_ALGAPI_ALIGNMASK+1], |
| * where 0 is aligned to a 2*(MAX_ALGAPI_ALIGNMASK+1) byte boundary |
| * @iv_offset_relative_to_alignmask: if true, add the algorithm's alignmask to |
| * the @iv_offset |
| * @finalization_type: what finalization function to use for hashes |
| */ |
| struct testvec_config { |
| const char *name; |
| bool inplace; |
| u32 req_flags; |
| struct test_sg_division src_divs[XBUFSIZE]; |
| struct test_sg_division dst_divs[XBUFSIZE]; |
| unsigned int iv_offset; |
| bool iv_offset_relative_to_alignmask; |
| enum finalization_type finalization_type; |
| }; |
| |
| #define TESTVEC_CONFIG_NAMELEN 192 |
| |
| /* |
| * The following are the lists of testvec_configs to test for each algorithm |
| * type when the basic crypto self-tests are enabled, i.e. when |
| * CONFIG_CRYPTO_MANAGER_DISABLE_TESTS is unset. They aim to provide good test |
| * coverage, while keeping the test time much shorter than the full fuzz tests |
| * so that the basic tests can be enabled in a wider range of circumstances. |
| */ |
| |
| /* Configs for skciphers and aeads */ |
| static const struct testvec_config default_cipher_testvec_configs[] = { |
| { |
| .name = "in-place", |
| .inplace = true, |
| .src_divs = { { .proportion_of_total = 10000 } }, |
| }, { |
| .name = "out-of-place", |
| .src_divs = { { .proportion_of_total = 10000 } }, |
| }, { |
| .name = "unaligned buffer, offset=1", |
| .src_divs = { { .proportion_of_total = 10000, .offset = 1 } }, |
| .iv_offset = 1, |
| }, { |
| .name = "buffer aligned only to alignmask", |
| .src_divs = { |
| { |
| .proportion_of_total = 10000, |
| .offset = 1, |
| .offset_relative_to_alignmask = true, |
| }, |
| }, |
| .iv_offset = 1, |
| .iv_offset_relative_to_alignmask = true, |
| }, { |
| .name = "two even aligned splits", |
| .src_divs = { |
| { .proportion_of_total = 5000 }, |
| { .proportion_of_total = 5000 }, |
| }, |
| }, { |
| .name = "uneven misaligned splits, may sleep", |
| .req_flags = CRYPTO_TFM_REQ_MAY_SLEEP, |
| .src_divs = { |
| { .proportion_of_total = 1900, .offset = 33 }, |
| { .proportion_of_total = 3300, .offset = 7 }, |
| { .proportion_of_total = 4800, .offset = 18 }, |
| }, |
| .iv_offset = 3, |
| }, { |
| .name = "misaligned splits crossing pages, inplace", |
| .inplace = true, |
| .src_divs = { |
| { |
| .proportion_of_total = 7500, |
| .offset = PAGE_SIZE - 32 |
| }, { |
| .proportion_of_total = 2500, |
| .offset = PAGE_SIZE - 7 |
| }, |
| }, |
| } |
| }; |
| |
| static const struct testvec_config default_hash_testvec_configs[] = { |
| { |
| .name = "init+update+final aligned buffer", |
| .src_divs = { { .proportion_of_total = 10000 } }, |
| .finalization_type = FINALIZATION_TYPE_FINAL, |
| }, { |
| .name = "init+finup aligned buffer", |
| .src_divs = { { .proportion_of_total = 10000 } }, |
| .finalization_type = FINALIZATION_TYPE_FINUP, |
| }, { |
| .name = "digest aligned buffer", |
| .src_divs = { { .proportion_of_total = 10000 } }, |
| .finalization_type = FINALIZATION_TYPE_DIGEST, |
| }, { |
| .name = "init+update+final misaligned buffer", |
| .src_divs = { { .proportion_of_total = 10000, .offset = 1 } }, |
| .finalization_type = FINALIZATION_TYPE_FINAL, |
| }, { |
| .name = "digest buffer aligned only to alignmask", |
| .src_divs = { |
| { |
| .proportion_of_total = 10000, |
| .offset = 1, |
| .offset_relative_to_alignmask = true, |
| }, |
| }, |
| .finalization_type = FINALIZATION_TYPE_DIGEST, |
| }, { |
| .name = "init+update+update+final two even splits", |
| .src_divs = { |
| { .proportion_of_total = 5000 }, |
| { |
| .proportion_of_total = 5000, |
| .flush_type = FLUSH_TYPE_FLUSH, |
| }, |
| }, |
| .finalization_type = FINALIZATION_TYPE_FINAL, |
| }, { |
| .name = "digest uneven misaligned splits, may sleep", |
| .req_flags = CRYPTO_TFM_REQ_MAY_SLEEP, |
| .src_divs = { |
| { .proportion_of_total = 1900, .offset = 33 }, |
| { .proportion_of_total = 3300, .offset = 7 }, |
| { .proportion_of_total = 4800, .offset = 18 }, |
| }, |
| .finalization_type = FINALIZATION_TYPE_DIGEST, |
| }, { |
| .name = "digest misaligned splits crossing pages", |
| .src_divs = { |
| { |
| .proportion_of_total = 7500, |
| .offset = PAGE_SIZE - 32, |
| }, { |
| .proportion_of_total = 2500, |
| .offset = PAGE_SIZE - 7, |
| }, |
| }, |
| .finalization_type = FINALIZATION_TYPE_DIGEST, |
| }, { |
| .name = "import/export", |
| .src_divs = { |
| { |
| .proportion_of_total = 6500, |
| .flush_type = FLUSH_TYPE_REIMPORT, |
| }, { |
| .proportion_of_total = 3500, |
| .flush_type = FLUSH_TYPE_REIMPORT, |
| }, |
| }, |
| .finalization_type = FINALIZATION_TYPE_FINAL, |
| } |
| }; |
| |
| static unsigned int count_test_sg_divisions(const struct test_sg_division *divs) |
| { |
| unsigned int remaining = TEST_SG_TOTAL; |
| unsigned int ndivs = 0; |
| |
| do { |
| remaining -= divs[ndivs++].proportion_of_total; |
| } while (remaining); |
| |
| return ndivs; |
| } |
| |
| static bool valid_sg_divisions(const struct test_sg_division *divs, |
| unsigned int count, bool *any_flushes_ret) |
| { |
| unsigned int total = 0; |
| unsigned int i; |
| |
| for (i = 0; i < count && total != TEST_SG_TOTAL; i++) { |
| if (divs[i].proportion_of_total <= 0 || |
| divs[i].proportion_of_total > TEST_SG_TOTAL - total) |
| return false; |
| total += divs[i].proportion_of_total; |
| if (divs[i].flush_type != FLUSH_TYPE_NONE) |
| *any_flushes_ret = true; |
| } |
| return total == TEST_SG_TOTAL && |
| memchr_inv(&divs[i], 0, (count - i) * sizeof(divs[0])) == NULL; |
| } |
| |
| /* |
| * Check whether the given testvec_config is valid. This isn't strictly needed |
| * since every testvec_config should be valid, but check anyway so that people |
| * don't unknowingly add broken configs that don't do what they wanted. |
| */ |
| static bool valid_testvec_config(const struct testvec_config *cfg) |
| { |
| bool any_flushes = false; |
| |
| if (cfg->name == NULL) |
| return false; |
| |
| if (!valid_sg_divisions(cfg->src_divs, ARRAY_SIZE(cfg->src_divs), |
| &any_flushes)) |
| return false; |
| |
| if (cfg->dst_divs[0].proportion_of_total) { |
| if (!valid_sg_divisions(cfg->dst_divs, |
| ARRAY_SIZE(cfg->dst_divs), |
| &any_flushes)) |
| return false; |
| } else { |
| if (memchr_inv(cfg->dst_divs, 0, sizeof(cfg->dst_divs))) |
| return false; |
| /* defaults to dst_divs=src_divs */ |
| } |
| |
| if (cfg->iv_offset + |
| (cfg->iv_offset_relative_to_alignmask ? MAX_ALGAPI_ALIGNMASK : 0) > |
| MAX_ALGAPI_ALIGNMASK + 1) |
| return false; |
| |
| if (any_flushes && cfg->finalization_type == FINALIZATION_TYPE_DIGEST) |
| return false; |
| |
| return true; |
| } |
| |
| struct test_sglist { |
| char *bufs[XBUFSIZE]; |
| struct scatterlist sgl[XBUFSIZE]; |
| struct scatterlist sgl_saved[XBUFSIZE]; |
| struct scatterlist *sgl_ptr; |
| unsigned int nents; |
| }; |
| |
| static int init_test_sglist(struct test_sglist *tsgl) |
| { |
| return __testmgr_alloc_buf(tsgl->bufs, 1 /* two pages per buffer */); |
| } |
| |
| static void destroy_test_sglist(struct test_sglist *tsgl) |
| { |
| return __testmgr_free_buf(tsgl->bufs, 1 /* two pages per buffer */); |
| } |
| |
| /** |
| * build_test_sglist() - build a scatterlist for a crypto test |
| * |
| * @tsgl: the scatterlist to build. @tsgl->bufs[] contains an array of 2-page |
| * buffers which the scatterlist @tsgl->sgl[] will be made to point into. |
| * @divs: the layout specification on which the scatterlist will be based |
| * @alignmask: the algorithm's alignmask |
| * @total_len: the total length of the scatterlist to build in bytes |
| * @data: if non-NULL, the buffers will be filled with this data until it ends. |
| * Otherwise the buffers will be poisoned. In both cases, some bytes |
| * past the end of each buffer will be poisoned to help detect overruns. |
| * @out_divs: if non-NULL, the test_sg_division to which each scatterlist entry |
| * corresponds will be returned here. This will match @divs except |
| * that divisions resolving to a length of 0 are omitted as they are |
| * not included in the scatterlist. |
| * |
| * Return: 0 or a -errno value |
| */ |
| static int build_test_sglist(struct test_sglist *tsgl, |
| const struct test_sg_division *divs, |
| const unsigned int alignmask, |
| const unsigned int total_len, |
| struct iov_iter *data, |
| const struct test_sg_division *out_divs[XBUFSIZE]) |
| { |
| struct { |
| const struct test_sg_division *div; |
| size_t length; |
| } partitions[XBUFSIZE]; |
| const unsigned int ndivs = count_test_sg_divisions(divs); |
| unsigned int len_remaining = total_len; |
| unsigned int i; |
| |
| BUILD_BUG_ON(ARRAY_SIZE(partitions) != ARRAY_SIZE(tsgl->sgl)); |
| if (WARN_ON(ndivs > ARRAY_SIZE(partitions))) |
| return -EINVAL; |
| |
| /* Calculate the (div, length) pairs */ |
| tsgl->nents = 0; |
| for (i = 0; i < ndivs; i++) { |
| unsigned int len_this_sg = |
| min(len_remaining, |
| (total_len * divs[i].proportion_of_total + |
| TEST_SG_TOTAL / 2) / TEST_SG_TOTAL); |
| |
| if (len_this_sg != 0) { |
| partitions[tsgl->nents].div = &divs[i]; |
| partitions[tsgl->nents].length = len_this_sg; |
| tsgl->nents++; |
| len_remaining -= len_this_sg; |
| } |
| } |
| if (tsgl->nents == 0) { |
| partitions[tsgl->nents].div = &divs[0]; |
| partitions[tsgl->nents].length = 0; |
| tsgl->nents++; |
| } |
| partitions[tsgl->nents - 1].length += len_remaining; |
| |
| /* Set up the sgl entries and fill the data or poison */ |
| sg_init_table(tsgl->sgl, tsgl->nents); |
| for (i = 0; i < tsgl->nents; i++) { |
| unsigned int offset = partitions[i].div->offset; |
| void *addr; |
| |
| if (partitions[i].div->offset_relative_to_alignmask) |
| offset += alignmask; |
| |
| while (offset + partitions[i].length + TESTMGR_POISON_LEN > |
| 2 * PAGE_SIZE) { |
| if (WARN_ON(offset <= 0)) |
| return -EINVAL; |
| offset /= 2; |
| } |
| |
| addr = &tsgl->bufs[i][offset]; |
| sg_set_buf(&tsgl->sgl[i], addr, partitions[i].length); |
| |
| if (out_divs) |
| out_divs[i] = partitions[i].div; |
| |
| if (data) { |
| size_t copy_len, copied; |
| |
| copy_len = min(partitions[i].length, data->count); |
| copied = copy_from_iter(addr, copy_len, data); |
| if (WARN_ON(copied != copy_len)) |
| return -EINVAL; |
| testmgr_poison(addr + copy_len, partitions[i].length + |
| TESTMGR_POISON_LEN - copy_len); |
| } else { |
| testmgr_poison(addr, partitions[i].length + |
| TESTMGR_POISON_LEN); |
| } |
| } |
| |
| sg_mark_end(&tsgl->sgl[tsgl->nents - 1]); |
| tsgl->sgl_ptr = tsgl->sgl; |
| memcpy(tsgl->sgl_saved, tsgl->sgl, tsgl->nents * sizeof(tsgl->sgl[0])); |
| return 0; |
| } |
| |
| /* |
| * Verify that a scatterlist crypto operation produced the correct output. |
| * |
| * @tsgl: scatterlist containing the actual output |
| * @expected_output: buffer containing the expected output |
| * @len_to_check: length of @expected_output in bytes |
| * @unchecked_prefix_len: number of ignored bytes in @tsgl prior to real result |
| * @check_poison: verify that the poison bytes after each chunk are intact? |
| * |
| * Return: 0 if correct, -EINVAL if incorrect, -EOVERFLOW if buffer overrun. |
| */ |
| static int verify_correct_output(const struct test_sglist *tsgl, |
| const char *expected_output, |
| unsigned int len_to_check, |
| unsigned int unchecked_prefix_len, |
| bool check_poison) |
| { |
| unsigned int i; |
| |
| for (i = 0; i < tsgl->nents; i++) { |
| struct scatterlist *sg = &tsgl->sgl_ptr[i]; |
| unsigned int len = sg->length; |
| unsigned int offset = sg->offset; |
| const char *actual_output; |
| |
| if (unchecked_prefix_len) { |
| if (unchecked_prefix_len >= len) { |
| unchecked_prefix_len -= len; |
| continue; |
| } |
| offset += unchecked_prefix_len; |
| len -= unchecked_prefix_len; |
| unchecked_prefix_len = 0; |
| } |
| len = min(len, len_to_check); |
| actual_output = page_address(sg_page(sg)) + offset; |
| if (memcmp(expected_output, actual_output, len) != 0) |
| return -EINVAL; |
| if (check_poison && |
| !testmgr_is_poison(actual_output + len, TESTMGR_POISON_LEN)) |
| return -EOVERFLOW; |
| len_to_check -= len; |
| expected_output += len; |
| } |
| if (WARN_ON(len_to_check != 0)) |
| return -EINVAL; |
| return 0; |
| } |
| |
| static bool is_test_sglist_corrupted(const struct test_sglist *tsgl) |
| { |
| unsigned int i; |
| |
| for (i = 0; i < tsgl->nents; i++) { |
| if (tsgl->sgl[i].page_link != tsgl->sgl_saved[i].page_link) |
| return true; |
| if (tsgl->sgl[i].offset != tsgl->sgl_saved[i].offset) |
| return true; |
| if (tsgl->sgl[i].length != tsgl->sgl_saved[i].length) |
| return true; |
| } |
| return false; |
| } |
| |
| struct cipher_test_sglists { |
| struct test_sglist src; |
| struct test_sglist dst; |
| }; |
| |
| static struct cipher_test_sglists *alloc_cipher_test_sglists(void) |
| { |
| struct cipher_test_sglists *tsgls; |
| |
| tsgls = kmalloc(sizeof(*tsgls), GFP_KERNEL); |
| if (!tsgls) |
| return NULL; |
| |
| if (init_test_sglist(&tsgls->src) != 0) |
| goto fail_kfree; |
| if (init_test_sglist(&tsgls->dst) != 0) |
| goto fail_destroy_src; |
| |
| return tsgls; |
| |
| fail_destroy_src: |
| destroy_test_sglist(&tsgls->src); |
| fail_kfree: |
| kfree(tsgls); |
| return NULL; |
| } |
| |
| static void free_cipher_test_sglists(struct cipher_test_sglists *tsgls) |
| { |
| if (tsgls) { |
| destroy_test_sglist(&tsgls->src); |
| destroy_test_sglist(&tsgls->dst); |
| kfree(tsgls); |
| } |
| } |
| |
| /* Build the src and dst scatterlists for an skcipher or AEAD test */ |
| static int build_cipher_test_sglists(struct cipher_test_sglists *tsgls, |
| const struct testvec_config *cfg, |
| unsigned int alignmask, |
| unsigned int src_total_len, |
| unsigned int dst_total_len, |
| const struct kvec *inputs, |
| unsigned int nr_inputs) |
| { |
| struct iov_iter input; |
| int err; |
| |
| iov_iter_kvec(&input, WRITE, inputs, nr_inputs, src_total_len); |
| err = build_test_sglist(&tsgls->src, cfg->src_divs, alignmask, |
| cfg->inplace ? |
| max(dst_total_len, src_total_len) : |
| src_total_len, |
| &input, NULL); |
| if (err) |
| return err; |
| |
| if (cfg->inplace) { |
| tsgls->dst.sgl_ptr = tsgls->src.sgl; |
| tsgls->dst.nents = tsgls->src.nents; |
| return 0; |
| } |
| return build_test_sglist(&tsgls->dst, |
| cfg->dst_divs[0].proportion_of_total ? |
| cfg->dst_divs : cfg->src_divs, |
| alignmask, dst_total_len, NULL, NULL); |
| } |
| |
| #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS |
| static char *generate_random_sgl_divisions(struct test_sg_division *divs, |
| size_t max_divs, char *p, char *end, |
| bool gen_flushes) |
| { |
| struct test_sg_division *div = divs; |
| unsigned int remaining = TEST_SG_TOTAL; |
| |
| do { |
| unsigned int this_len; |
| |
| if (div == &divs[max_divs - 1] || prandom_u32() % 2 == 0) |
| this_len = remaining; |
| else |
| this_len = 1 + (prandom_u32() % remaining); |
| div->proportion_of_total = this_len; |
| |
| if (prandom_u32() % 4 == 0) |
| div->offset = (PAGE_SIZE - 128) + (prandom_u32() % 128); |
| else if (prandom_u32() % 2 == 0) |
| div->offset = prandom_u32() % 32; |
| else |
| div->offset = prandom_u32() % PAGE_SIZE; |
| if (prandom_u32() % 8 == 0) |
| div->offset_relative_to_alignmask = true; |
| |
| div->flush_type = FLUSH_TYPE_NONE; |
| if (gen_flushes) { |
| switch (prandom_u32() % 4) { |
| case 0: |
| div->flush_type = FLUSH_TYPE_REIMPORT; |
| break; |
| case 1: |
| div->flush_type = FLUSH_TYPE_FLUSH; |
| break; |
| } |
| } |
| |
| BUILD_BUG_ON(TEST_SG_TOTAL != 10000); /* for "%u.%u%%" */ |
| p += scnprintf(p, end - p, "%s%u.%u%%@%s+%u%s", |
| div->flush_type == FLUSH_TYPE_NONE ? "" : |
| div->flush_type == FLUSH_TYPE_FLUSH ? |
| "<flush> " : "<reimport> ", |
| this_len / 100, this_len % 100, |
| div->offset_relative_to_alignmask ? |
| "alignmask" : "", |
| div->offset, this_len == remaining ? "" : ", "); |
| remaining -= this_len; |
| div++; |
| } while (remaining); |
| |
| return p; |
| } |
| |
| /* Generate a random testvec_config for fuzz testing */ |
| static void generate_random_testvec_config(struct testvec_config *cfg, |
| char *name, size_t max_namelen) |
| { |
| char *p = name; |
| char * const end = name + max_namelen; |
| |
| memset(cfg, 0, sizeof(*cfg)); |
| |
| cfg->name = name; |
| |
| p += scnprintf(p, end - p, "random:"); |
| |
| if (prandom_u32() % 2 == 0) { |
| cfg->inplace = true; |
| p += scnprintf(p, end - p, " inplace"); |
| } |
| |
| if (prandom_u32() % 2 == 0) { |
| cfg->req_flags |= CRYPTO_TFM_REQ_MAY_SLEEP; |
| p += scnprintf(p, end - p, " may_sleep"); |
| } |
| |
| switch (prandom_u32() % 4) { |
| case 0: |
| cfg->finalization_type = FINALIZATION_TYPE_FINAL; |
| p += scnprintf(p, end - p, " use_final"); |
| break; |
| case 1: |
| cfg->finalization_type = FINALIZATION_TYPE_FINUP; |
| p += scnprintf(p, end - p, " use_finup"); |
| break; |
| default: |
| cfg->finalization_type = FINALIZATION_TYPE_DIGEST; |
| p += scnprintf(p, end - p, " use_digest"); |
| break; |
| } |
| |
| p += scnprintf(p, end - p, " src_divs=["); |
| p = generate_random_sgl_divisions(cfg->src_divs, |
| ARRAY_SIZE(cfg->src_divs), p, end, |
| (cfg->finalization_type != |
| FINALIZATION_TYPE_DIGEST)); |
| p += scnprintf(p, end - p, "]"); |
| |
| if (!cfg->inplace && prandom_u32() % 2 == 0) { |
| p += scnprintf(p, end - p, " dst_divs=["); |
| p = generate_random_sgl_divisions(cfg->dst_divs, |
| ARRAY_SIZE(cfg->dst_divs), |
| p, end, false); |
| p += scnprintf(p, end - p, "]"); |
| } |
| |
| if (prandom_u32() % 2 == 0) { |
| cfg->iv_offset = 1 + (prandom_u32() % MAX_ALGAPI_ALIGNMASK); |
| p += scnprintf(p, end - p, " iv_offset=%u", cfg->iv_offset); |
| } |
| |
| WARN_ON_ONCE(!valid_testvec_config(cfg)); |
| } |
| #endif /* CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ |
| |
| static int check_nonfinal_hash_op(const char *op, int err, |
| u8 *result, unsigned int digestsize, |
| const char *driver, unsigned int vec_num, |
| const struct testvec_config *cfg) |
| { |
| if (err) { |
| pr_err("alg: hash: %s %s() failed with err %d on test vector %u, cfg=\"%s\"\n", |
| driver, op, err, vec_num, cfg->name); |
| return err; |
| } |
| if (!testmgr_is_poison(result, digestsize)) { |
| pr_err("alg: hash: %s %s() used result buffer on test vector %u, cfg=\"%s\"\n", |
| driver, op, vec_num, cfg->name); |
| return -EINVAL; |
| } |
| return 0; |
| } |
| |
| static int test_hash_vec_cfg(const char *driver, |
| const struct hash_testvec *vec, |
| unsigned int vec_num, |
| const struct testvec_config *cfg, |
| struct ahash_request *req, |
| struct test_sglist *tsgl, |
| u8 *hashstate) |
| { |
| struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); |
| const unsigned int alignmask = crypto_ahash_alignmask(tfm); |
| const unsigned int digestsize = crypto_ahash_digestsize(tfm); |
| const unsigned int statesize = crypto_ahash_statesize(tfm); |
| const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags; |
| const struct test_sg_division *divs[XBUFSIZE]; |
| DECLARE_CRYPTO_WAIT(wait); |
| struct kvec _input; |
| struct iov_iter input; |
| unsigned int i; |
| struct scatterlist *pending_sgl; |
| unsigned int pending_len; |
| u8 result[HASH_MAX_DIGESTSIZE + TESTMGR_POISON_LEN]; |
| int err; |
| |
| /* Set the key, if specified */ |
| if (vec->ksize) { |
| err = crypto_ahash_setkey(tfm, vec->key, vec->ksize); |
| if (err) { |
| pr_err("alg: hash: %s setkey failed with err %d on test vector %u; flags=%#x\n", |
| driver, err, vec_num, |
| crypto_ahash_get_flags(tfm)); |
| return err; |
| } |
| } |
| |
| /* Build the scatterlist for the source data */ |
| _input.iov_base = (void *)vec->plaintext; |
| _input.iov_len = vec->psize; |
| iov_iter_kvec(&input, WRITE, &_input, 1, vec->psize); |
| err = build_test_sglist(tsgl, cfg->src_divs, alignmask, vec->psize, |
| &input, divs); |
| if (err) { |
| pr_err("alg: hash: %s: error preparing scatterlist for test vector %u, cfg=\"%s\"\n", |
| driver, vec_num, cfg->name); |
| return err; |
| } |
| |
| /* Do the actual hashing */ |
| |
| testmgr_poison(req->__ctx, crypto_ahash_reqsize(tfm)); |
| testmgr_poison(result, digestsize + TESTMGR_POISON_LEN); |
| |
| if (cfg->finalization_type == FINALIZATION_TYPE_DIGEST) { |
| /* Just using digest() */ |
| ahash_request_set_callback(req, req_flags, crypto_req_done, |
| &wait); |
| ahash_request_set_crypt(req, tsgl->sgl, result, vec->psize); |
| err = crypto_wait_req(crypto_ahash_digest(req), &wait); |
| if (err) { |
| pr_err("alg: hash: %s digest() failed with err %d on test vector %u, cfg=\"%s\"\n", |
| driver, err, vec_num, cfg->name); |
| return err; |
| } |
| goto result_ready; |
| } |
| |
| /* Using init(), zero or more update(), then final() or finup() */ |
| |
| ahash_request_set_callback(req, req_flags, crypto_req_done, &wait); |
| ahash_request_set_crypt(req, NULL, result, 0); |
| err = crypto_wait_req(crypto_ahash_init(req), &wait); |
| err = check_nonfinal_hash_op("init", err, result, digestsize, |
| driver, vec_num, cfg); |
| if (err) |
| return err; |
| |
| pending_sgl = NULL; |
| pending_len = 0; |
| for (i = 0; i < tsgl->nents; i++) { |
| if (divs[i]->flush_type != FLUSH_TYPE_NONE && |
| pending_sgl != NULL) { |
| /* update() with the pending data */ |
| ahash_request_set_callback(req, req_flags, |
| crypto_req_done, &wait); |
| ahash_request_set_crypt(req, pending_sgl, result, |
| pending_len); |
| err = crypto_wait_req(crypto_ahash_update(req), &wait); |
| err = check_nonfinal_hash_op("update", err, |
| result, digestsize, |
| driver, vec_num, cfg); |
| if (err) |
| return err; |
| pending_sgl = NULL; |
| pending_len = 0; |
| } |
| if (divs[i]->flush_type == FLUSH_TYPE_REIMPORT) { |
| /* Test ->export() and ->import() */ |
| testmgr_poison(hashstate + statesize, |
| TESTMGR_POISON_LEN); |
| err = crypto_ahash_export(req, hashstate); |
| err = check_nonfinal_hash_op("export", err, |
| result, digestsize, |
| driver, vec_num, cfg); |
| if (err) |
| return err; |
| if (!testmgr_is_poison(hashstate + statesize, |
| TESTMGR_POISON_LEN)) { |
| pr_err("alg: hash: %s export() overran state buffer on test vector %u, cfg=\"%s\"\n", |
| driver, vec_num, cfg->name); |
| return -EOVERFLOW; |
| } |
| |
| testmgr_poison(req->__ctx, crypto_ahash_reqsize(tfm)); |
| err = crypto_ahash_import(req, hashstate); |
| err = check_nonfinal_hash_op("import", err, |
| result, digestsize, |
| driver, vec_num, cfg); |
| if (err) |
| return err; |
| } |
| if (pending_sgl == NULL) |
| pending_sgl = &tsgl->sgl[i]; |
| pending_len += tsgl->sgl[i].length; |
| } |
| |
| ahash_request_set_callback(req, req_flags, crypto_req_done, &wait); |
| ahash_request_set_crypt(req, pending_sgl, result, pending_len); |
| if (cfg->finalization_type == FINALIZATION_TYPE_FINAL) { |
| /* finish with update() and final() */ |
| err = crypto_wait_req(crypto_ahash_update(req), &wait); |
| err = check_nonfinal_hash_op("update", err, result, digestsize, |
| driver, vec_num, cfg); |
| if (err) |
| return err; |
| err = crypto_wait_req(crypto_ahash_final(req), &wait); |
| if (err) { |
| pr_err("alg: hash: %s final() failed with err %d on test vector %u, cfg=\"%s\"\n", |
| driver, err, vec_num, cfg->name); |
| return err; |
| } |
| } else { |
| /* finish with finup() */ |
| err = crypto_wait_req(crypto_ahash_finup(req), &wait); |
| if (err) { |
| pr_err("alg: hash: %s finup() failed with err %d on test vector %u, cfg=\"%s\"\n", |
| driver, err, vec_num, cfg->name); |
| return err; |
| } |
| } |
| |
| result_ready: |
| /* Check that the algorithm produced the correct digest */ |
| if (memcmp(result, vec->digest, digestsize) != 0) { |
| pr_err("alg: hash: %s test failed (wrong result) on test vector %u, cfg=\"%s\"\n", |
| driver, vec_num, cfg->name); |
| return -EINVAL; |
| } |
| if (!testmgr_is_poison(&result[digestsize], TESTMGR_POISON_LEN)) { |
| pr_err("alg: hash: %s overran result buffer on test vector %u, cfg=\"%s\"\n", |
| driver, vec_num, cfg->name); |
| return -EOVERFLOW; |
| } |
| |
| return 0; |
| } |
| |
| static int test_hash_vec(const char *driver, const struct hash_testvec *vec, |
| unsigned int vec_num, struct ahash_request *req, |
| struct test_sglist *tsgl, u8 *hashstate) |
| { |
| unsigned int i; |
| int err; |
| |
| for (i = 0; i < ARRAY_SIZE(default_hash_testvec_configs); i++) { |
| err = test_hash_vec_cfg(driver, vec, vec_num, |
| &default_hash_testvec_configs[i], |
| req, tsgl, hashstate); |
| if (err) |
| return err; |
| } |
| |
| #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS |
| if (!noextratests) { |
| struct testvec_config cfg; |
| char cfgname[TESTVEC_CONFIG_NAMELEN]; |
| |
| for (i = 0; i < fuzz_iterations; i++) { |
| generate_random_testvec_config(&cfg, cfgname, |
| sizeof(cfgname)); |
| err = test_hash_vec_cfg(driver, vec, vec_num, &cfg, |
| req, tsgl, hashstate); |
| if (err) |
| return err; |
| } |
| } |
| #endif |
| return 0; |
| } |
| |
| static int __alg_test_hash(const struct hash_testvec *vecs, |
| unsigned int num_vecs, const char *driver, |
| u32 type, u32 mask) |
| { |
| struct crypto_ahash *tfm; |
| struct ahash_request *req = NULL; |
| struct test_sglist *tsgl = NULL; |
| u8 *hashstate = NULL; |
| unsigned int i; |
| int err; |
| |
| tfm = crypto_alloc_ahash(driver, type, mask); |
| if (IS_ERR(tfm)) { |
| pr_err("alg: hash: failed to allocate transform for %s: %ld\n", |
| driver, PTR_ERR(tfm)); |
| return PTR_ERR(tfm); |
| } |
| |
| req = ahash_request_alloc(tfm, GFP_KERNEL); |
| if (!req) { |
| pr_err("alg: hash: failed to allocate request for %s\n", |
| driver); |
| err = -ENOMEM; |
| goto out; |
| } |
| |
| tsgl = kmalloc(sizeof(*tsgl), GFP_KERNEL); |
| if (!tsgl || init_test_sglist(tsgl) != 0) { |
| pr_err("alg: hash: failed to allocate test buffers for %s\n", |
| driver); |
| kfree(tsgl); |
| tsgl = NULL; |
| err = -ENOMEM; |
| goto out; |
| } |
| |
| hashstate = kmalloc(crypto_ahash_statesize(tfm) + TESTMGR_POISON_LEN, |
| GFP_KERNEL); |
| if (!hashstate) { |
| pr_err("alg: hash: failed to allocate hash state buffer for %s\n", |
| driver); |
| err = -ENOMEM; |
| goto out; |
| } |
| |
| for (i = 0; i < num_vecs; i++) { |
| err = test_hash_vec(driver, &vecs[i], i, req, tsgl, hashstate); |
| if (err) |
| goto out; |
| } |
| err = 0; |
| out: |
| kfree(hashstate); |
| if (tsgl) { |
| destroy_test_sglist(tsgl); |
| kfree(tsgl); |
| } |
| ahash_request_free(req); |
| crypto_free_ahash(tfm); |
| return err; |
| } |
| |
| static int alg_test_hash(const struct alg_test_desc *desc, const char *driver, |
| u32 type, u32 mask) |
| { |
| const struct hash_testvec *template = desc->suite.hash.vecs; |
| unsigned int tcount = desc->suite.hash.count; |
| unsigned int nr_unkeyed, nr_keyed; |
| int err; |
| |
| /* |
| * For OPTIONAL_KEY algorithms, we have to do all the unkeyed tests |
| * first, before setting a key on the tfm. To make this easier, we |
| * require that the unkeyed test vectors (if any) are listed first. |
| */ |
| |
| for (nr_unkeyed = 0; nr_unkeyed < tcount; nr_unkeyed++) { |
| if (template[nr_unkeyed].ksize) |
| break; |
| } |
| for (nr_keyed = 0; nr_unkeyed + nr_keyed < tcount; nr_keyed++) { |
| if (!template[nr_unkeyed + nr_keyed].ksize) { |
| pr_err("alg: hash: test vectors for %s out of order, " |
| "unkeyed ones must come first\n", desc->alg); |
| return -EINVAL; |
| } |
| } |
| |
| err = 0; |
| if (nr_unkeyed) { |
| err = __alg_test_hash(template, nr_unkeyed, driver, type, mask); |
| template += nr_unkeyed; |
| } |
| |
| if (!err && nr_keyed) |
| err = __alg_test_hash(template, nr_keyed, driver, type, mask); |
| |
| return err; |
| } |
| |
| static int test_aead_vec_cfg(const char *driver, int enc, |
| const struct aead_testvec *vec, |
| unsigned int vec_num, |
| const struct testvec_config *cfg, |
| struct aead_request *req, |
| struct cipher_test_sglists *tsgls) |
| { |
| struct crypto_aead *tfm = crypto_aead_reqtfm(req); |
| const unsigned int alignmask = crypto_aead_alignmask(tfm); |
| const unsigned int ivsize = crypto_aead_ivsize(tfm); |
| const unsigned int authsize = vec->clen - vec->plen; |
| const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags; |
| const char *op = enc ? "encryption" : "decryption"; |
| DECLARE_CRYPTO_WAIT(wait); |
| u8 _iv[3 * (MAX_ALGAPI_ALIGNMASK + 1) + MAX_IVLEN]; |
| u8 *iv = PTR_ALIGN(&_iv[0], 2 * (MAX_ALGAPI_ALIGNMASK + 1)) + |
| cfg->iv_offset + |
| (cfg->iv_offset_relative_to_alignmask ? alignmask : 0); |
| struct kvec input[2]; |
| int err; |
| |
| /* Set the key */ |
| if (vec->wk) |
| crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); |
| else |
| crypto_aead_clear_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); |
| err = crypto_aead_setkey(tfm, vec->key, vec->klen); |
| if (err) { |
| if (vec->fail) /* expectedly failed to set key? */ |
| return 0; |
| pr_err("alg: aead: %s setkey failed with err %d on test vector %u; flags=%#x\n", |
| driver, err, vec_num, crypto_aead_get_flags(tfm)); |
| return err; |
| } |
| if (vec->fail) { |
| pr_err("alg: aead: %s setkey unexpectedly succeeded on test vector %u\n", |
| driver, vec_num); |
| return -EINVAL; |
| } |
| |
| /* Set the authentication tag size */ |
| err = crypto_aead_setauthsize(tfm, authsize); |
| if (err) { |
| pr_err("alg: aead: %s setauthsize failed with err %d on test vector %u\n", |
| driver, err, vec_num); |
| return err; |
| } |
| |
| /* The IV must be copied to a buffer, as the algorithm may modify it */ |
| if (WARN_ON(ivsize > MAX_IVLEN)) |
| return -EINVAL; |
| if (vec->iv) |
| memcpy(iv, vec->iv, ivsize); |
| else |
| memset(iv, 0, ivsize); |
| |
| /* Build the src/dst scatterlists */ |
| input[0].iov_base = (void *)vec->assoc; |
| input[0].iov_len = vec->alen; |
| input[1].iov_base = enc ? (void *)vec->ptext : (void *)vec->ctext; |
| input[1].iov_len = enc ? vec->plen : vec->clen; |
| err = build_cipher_test_sglists(tsgls, cfg, alignmask, |
| vec->alen + (enc ? vec->plen : |
| vec->clen), |
| vec->alen + (enc ? vec->clen : |
| vec->plen), |
| input, 2); |
| if (err) { |
| pr_err("alg: aead: %s %s: error preparing scatterlists for test vector %u, cfg=\"%s\"\n", |
| driver, op, vec_num, cfg->name); |
| return err; |
| } |
| |
| /* Do the actual encryption or decryption */ |
| testmgr_poison(req->__ctx, crypto_aead_reqsize(tfm)); |
| aead_request_set_callback(req, req_flags, crypto_req_done, &wait); |
| aead_request_set_crypt(req, tsgls->src.sgl_ptr, tsgls->dst.sgl_ptr, |
| enc ? vec->plen : vec->clen, iv); |
| aead_request_set_ad(req, vec->alen); |
| err = crypto_wait_req(enc ? crypto_aead_encrypt(req) : |
| crypto_aead_decrypt(req), &wait); |
| |
| aead_request_set_tfm(req, tfm); /* TODO: get rid of this */ |
| |
| if (err) { |
| if (err == -EBADMSG && vec->novrfy) |
| return 0; |
| pr_err("alg: aead: %s %s failed with err %d on test vector %u, cfg=\"%s\"\n", |
| driver, op, err, vec_num, cfg->name); |
| return err; |
| } |
| if (vec->novrfy) { |
| pr_err("alg: aead: %s %s unexpectedly succeeded on test vector %u, cfg=\"%s\"\n", |
| driver, op, vec_num, cfg->name); |
| return -EINVAL; |
| } |
| |
| /* Check that the algorithm didn't overwrite things it shouldn't have */ |
| if (req->cryptlen != (enc ? vec->plen : vec->clen) || |
| req->assoclen != vec->alen || |
| req->iv != iv || |
| req->src != tsgls->src.sgl_ptr || |
| req->dst != tsgls->dst.sgl_ptr || |
| crypto_aead_reqtfm(req) != tfm || |
| req->base.complete != crypto_req_done || |
| req->base.flags != req_flags || |
| req->base.data != &wait) { |
| pr_err("alg: aead: %s %s corrupted request struct on test vector %u, cfg=\"%s\"\n", |
| driver, op, vec_num, cfg->name); |
| if (req->cryptlen != (enc ? vec->plen : vec->clen)) |
| pr_err("alg: aead: changed 'req->cryptlen'\n"); |
| if (req->assoclen != vec->alen) |
| pr_err("alg: aead: changed 'req->assoclen'\n"); |
| if (req->iv != iv) |
| pr_err("alg: aead: changed 'req->iv'\n"); |
| if (req->src != tsgls->src.sgl_ptr) |
| pr_err("alg: aead: changed 'req->src'\n"); |
| if (req->dst != tsgls->dst.sgl_ptr) |
| pr_err("alg: aead: changed 'req->dst'\n"); |
| if (crypto_aead_reqtfm(req) != tfm) |
| pr_err("alg: aead: changed 'req->base.tfm'\n"); |
| if (req->base.complete != crypto_req_done) |
| pr_err("alg: aead: changed 'req->base.complete'\n"); |
| if (req->base.flags != req_flags) |
| pr_err("alg: aead: changed 'req->base.flags'\n"); |
| if (req->base.data != &wait) |
| pr_err("alg: aead: changed 'req->base.data'\n"); |
| return -EINVAL; |
| } |
| if (is_test_sglist_corrupted(&tsgls->src)) { |
| pr_err("alg: aead: %s %s corrupted src sgl on test vector %u, cfg=\"%s\"\n", |
| driver, op, vec_num, cfg->name); |
| return -EINVAL; |
| } |
| if (tsgls->dst.sgl_ptr != tsgls->src.sgl && |
| is_test_sglist_corrupted(&tsgls->dst)) { |
| pr_err("alg: aead: %s %s corrupted dst sgl on test vector %u, cfg=\"%s\"\n", |
| driver, op, vec_num, cfg->name); |
| return -EINVAL; |
| } |
| |
| /* Check for the correct output (ciphertext or plaintext) */ |
| err = verify_correct_output(&tsgls->dst, enc ? vec->ctext : vec->ptext, |
| enc ? vec->clen : vec->plen, |
| vec->alen, enc || !cfg->inplace); |
| if (err == -EOVERFLOW) { |
| pr_err("alg: aead: %s %s overran dst buffer on test vector %u, cfg=\"%s\"\n", |
| driver, op, vec_num, cfg->name); |
| return err; |
| } |
| if (err) { |
| pr_err("alg: aead: %s %s test failed (wrong result) on test vector %u, cfg=\"%s\"\n", |
| driver, op, vec_num, cfg->name); |
| return err; |
| } |
| |
| return 0; |
| } |
| |
| static int test_aead_vec(const char *driver, int enc, |
| const struct aead_testvec *vec, unsigned int vec_num, |
| struct aead_request *req, |
| struct cipher_test_sglists *tsgls) |
| { |
| unsigned int i; |
| int err; |
| |
| if (enc && vec->novrfy) |
| return 0; |
| |
| for (i = 0; i < ARRAY_SIZE(default_cipher_testvec_configs); i++) { |
| err = test_aead_vec_cfg(driver, enc, vec, vec_num, |
| &default_cipher_testvec_configs[i], |
| req, tsgls); |
| if (err) |
| return err; |
| } |
| |
| #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS |
| if (!noextratests) { |
| struct testvec_config cfg; |
| char cfgname[TESTVEC_CONFIG_NAMELEN]; |
| |
| for (i = 0; i < fuzz_iterations; i++) { |
| generate_random_testvec_config(&cfg, cfgname, |
| sizeof(cfgname)); |
| err = test_aead_vec_cfg(driver, enc, vec, vec_num, |
| &cfg, req, tsgls); |
| if (err) |
| return err; |
| } |
| } |
| #endif |
| return 0; |
| } |
| |
| static int test_aead(const char *driver, int enc, |
| const struct aead_test_suite *suite, |
| struct aead_request *req, |
| struct cipher_test_sglists *tsgls) |
| { |
| unsigned int i; |
| int err; |
| |
| for (i = 0; i < suite->count; i++) { |
| err = test_aead_vec(driver, enc, &suite->vecs[i], i, req, |
| tsgls); |
| if (err) |
| return err; |
| } |
| return 0; |
| } |
| |
| static int alg_test_aead(const struct alg_test_desc *desc, const char *driver, |
| u32 type, u32 mask) |
| { |
| const struct aead_test_suite *suite = &desc->suite.aead; |
| struct crypto_aead *tfm; |
| struct aead_request *req = NULL; |
| struct cipher_test_sglists *tsgls = NULL; |
| int err; |
| |
| if (suite->count <= 0) { |
| pr_err("alg: aead: empty test suite for %s\n", driver); |
| return -EINVAL; |
| } |
| |
| tfm = crypto_alloc_aead(driver, type, mask); |
| if (IS_ERR(tfm)) { |
| pr_err("alg: aead: failed to allocate transform for %s: %ld\n", |
| driver, PTR_ERR(tfm)); |
| return PTR_ERR(tfm); |
| } |
| |
| req = aead_request_alloc(tfm, GFP_KERNEL); |
| if (!req) { |
| pr_err("alg: aead: failed to allocate request for %s\n", |
| driver); |
| err = -ENOMEM; |
| goto out; |
| } |
| |
| tsgls = alloc_cipher_test_sglists(); |
| if (!tsgls) { |
| pr_err("alg: aead: failed to allocate test buffers for %s\n", |
| driver); |
| err = -ENOMEM; |
| goto out; |
| } |
| |
| err = test_aead(driver, ENCRYPT, suite, req, tsgls); |
| if (err) |
| goto out; |
| |
| err = test_aead(driver, DECRYPT, suite, req, tsgls); |
| out: |
| free_cipher_test_sglists(tsgls); |
| aead_request_free(req); |
| crypto_free_aead(tfm); |
| return err; |
| } |
| |
| static int test_cipher(struct crypto_cipher *tfm, int enc, |
| const struct cipher_testvec *template, |
| unsigned int tcount) |
| { |
| const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm)); |
| unsigned int i, j, k; |
| char *q; |
| const char *e; |
| const char *input, *result; |
| void *data; |
| char *xbuf[XBUFSIZE]; |
| int ret = -ENOMEM; |
| |
| if (testmgr_alloc_buf(xbuf)) |
| goto out_nobuf; |
| |
| if (enc == ENCRYPT) |
| e = "encryption"; |
| else |
| e = "decryption"; |
| |
| j = 0; |
| for (i = 0; i < tcount; i++) { |
| |
| if (fips_enabled && template[i].fips_skip) |
| continue; |
| |
| input = enc ? template[i].ptext : template[i].ctext; |
| result = enc ? template[i].ctext : template[i].ptext; |
| j++; |
| |
| ret = -EINVAL; |
| if (WARN_ON(template[i].len > PAGE_SIZE)) |
| goto out; |
| |
| data = xbuf[0]; |
| memcpy(data, input, template[i].len); |
| |
| crypto_cipher_clear_flags(tfm, ~0); |
| if (template[i].wk) |
| crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); |
| |
| ret = crypto_cipher_setkey(tfm, template[i].key, |
| template[i].klen); |
| if (template[i].fail == !ret) { |
| printk(KERN_ERR "alg: cipher: setkey failed " |
| "on test %d for %s: flags=%x\n", j, |
| algo, crypto_cipher_get_flags(tfm)); |
| goto out; |
| } else if (ret) |
| continue; |
| |
| for (k = 0; k < template[i].len; |
| k += crypto_cipher_blocksize(tfm)) { |
| if (enc) |
| crypto_cipher_encrypt_one(tfm, data + k, |
| data + k); |
| else |
| crypto_cipher_decrypt_one(tfm, data + k, |
| data + k); |
| } |
| |
| q = data; |
| if (memcmp(q, result, template[i].len)) { |
| printk(KERN_ERR "alg: cipher: Test %d failed " |
| "on %s for %s\n", j, e, algo); |
| hexdump(q, template[i].len); |
| ret = -EINVAL; |
| goto out; |
| } |
| } |
| |
| ret = 0; |
| |
| out: |
| testmgr_free_buf(xbuf); |
| out_nobuf: |
| return ret; |
| } |
| |
| static int test_skcipher_vec_cfg(const char *driver, int enc, |
| const struct cipher_testvec *vec, |
| unsigned int vec_num, |
| const struct testvec_config *cfg, |
| struct skcipher_request *req, |
| struct cipher_test_sglists *tsgls) |
| { |
| struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); |
| const unsigned int alignmask = crypto_skcipher_alignmask(tfm); |
| const unsigned int ivsize = crypto_skcipher_ivsize(tfm); |
| const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags; |
| const char *op = enc ? "encryption" : "decryption"; |
| DECLARE_CRYPTO_WAIT(wait); |
| u8 _iv[3 * (MAX_ALGAPI_ALIGNMASK + 1) + MAX_IVLEN]; |
| u8 *iv = PTR_ALIGN(&_iv[0], 2 * (MAX_ALGAPI_ALIGNMASK + 1)) + |
| cfg->iv_offset + |
| (cfg->iv_offset_relative_to_alignmask ? alignmask : 0); |
| struct kvec input; |
| int err; |
| |
| /* Set the key */ |
| if (vec->wk) |
| crypto_skcipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); |
| else |
| crypto_skcipher_clear_flags(tfm, |
| CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); |
| err = crypto_skcipher_setkey(tfm, vec->key, vec->klen); |
| if (err) { |
| if (vec->fail) /* expectedly failed to set key? */ |
| return 0; |
| pr_err("alg: skcipher: %s setkey failed with err %d on test vector %u; flags=%#x\n", |
| driver, err, vec_num, crypto_skcipher_get_flags(tfm)); |
| return err; |
| } |
| if (vec->fail) { |
| pr_err("alg: skcipher: %s setkey unexpectedly succeeded on test vector %u\n", |
| driver, vec_num); |
| return -EINVAL; |
| } |
| |
| /* The IV must be copied to a buffer, as the algorithm may modify it */ |
| if (ivsize) { |
| if (WARN_ON(ivsize > MAX_IVLEN)) |
| return -EINVAL; |
| if (vec->generates_iv && !enc) |
| memcpy(iv, vec->iv_out, ivsize); |
| else if (vec->iv) |
| memcpy(iv, vec->iv, ivsize); |
| else |
| memset(iv, 0, ivsize); |
| } else { |
| if (vec->generates_iv) { |
| pr_err("alg: skcipher: %s has ivsize=0 but test vector %u generates IV!\n", |
| driver, vec_num); |
| return -EINVAL; |
| } |
| iv = NULL; |
| } |
| |
| /* Build the src/dst scatterlists */ |
| input.iov_base = enc ? (void *)vec->ptext : (void *)vec->ctext; |
| input.iov_len = vec->len; |
| err = build_cipher_test_sglists(tsgls, cfg, alignmask, |
| vec->len, vec->len, &input, 1); |
| if (err) { |
| pr_err("alg: skcipher: %s %s: error preparing scatterlists for test vector %u, cfg=\"%s\"\n", |
| driver, op, vec_num, cfg->name); |
| return err; |
| } |
| |
| /* Do the actual encryption or decryption */ |
| testmgr_poison(req->__ctx, crypto_skcipher_reqsize(tfm)); |
| skcipher_request_set_callback(req, req_flags, crypto_req_done, &wait); |
| skcipher_request_set_crypt(req, tsgls->src.sgl_ptr, tsgls->dst.sgl_ptr, |
| vec->len, iv); |
| err = crypto_wait_req(enc ? crypto_skcipher_encrypt(req) : |
| crypto_skcipher_decrypt(req), &wait); |
| if (err) { |
| pr_err("alg: skcipher: %s %s failed with err %d on test vector %u, cfg=\"%s\"\n", |
| driver, op, err, vec_num, cfg->name); |
| return err; |
| } |
| |
| /* Check that the algorithm didn't overwrite things it shouldn't have */ |
| if (req->cryptlen != vec->len || |
| req->iv != iv || |
| req->src != tsgls->src.sgl_ptr || |
| req->dst != tsgls->dst.sgl_ptr || |
| crypto_skcipher_reqtfm(req) != tfm || |
| req->base.complete != crypto_req_done || |
| req->base.flags != req_flags || |
| req->base.data != &wait) { |
| pr_err("alg: skcipher: %s %s corrupted request struct on test vector %u, cfg=\"%s\"\n", |
| driver, op, vec_num, cfg->name); |
| if (req->cryptlen != vec->len) |
| pr_err("alg: skcipher: changed 'req->cryptlen'\n"); |
| if (req->iv != iv) |
| pr_err("alg: skcipher: changed 'req->iv'\n"); |
| if (req->src != tsgls->src.sgl_ptr) |
| pr_err("alg: skcipher: changed 'req->src'\n"); |
| if (req->dst != tsgls->dst.sgl_ptr) |
| pr_err("alg: skcipher: changed 'req->dst'\n"); |
| if (crypto_skcipher_reqtfm(req) != tfm) |
| pr_err("alg: skcipher: changed 'req->base.tfm'\n"); |
| if (req->base.complete != crypto_req_done) |
| pr_err("alg: skcipher: changed 'req->base.complete'\n"); |
| if (req->base.flags != req_flags) |
| pr_err("alg: skcipher: changed 'req->base.flags'\n"); |
| if (req->base.data != &wait) |
| pr_err("alg: skcipher: changed 'req->base.data'\n"); |
| return -EINVAL; |
| } |
| if (is_test_sglist_corrupted(&tsgls->src)) { |
| pr_err("alg: skcipher: %s %s corrupted src sgl on test vector %u, cfg=\"%s\"\n", |
| driver, op, vec_num, cfg->name); |
| return -EINVAL; |
| } |
| if (tsgls->dst.sgl_ptr != tsgls->src.sgl && |
| is_test_sglist_corrupted(&tsgls->dst)) { |
| pr_err("alg: skcipher: %s %s corrupted dst sgl on test vector %u, cfg=\"%s\"\n", |
| driver, op, vec_num, cfg->name); |
| return -EINVAL; |
| } |
| |
| /* Check for the correct output (ciphertext or plaintext) */ |
| err = verify_correct_output(&tsgls->dst, enc ? vec->ctext : vec->ptext, |
| vec->len, 0, true); |
| if (err == -EOVERFLOW) { |
| pr_err("alg: skcipher: %s %s overran dst buffer on test vector %u, cfg=\"%s\"\n", |
| driver, op, vec_num, cfg->name); |
| return err; |
| } |
| if (err) { |
| pr_err("alg: skcipher: %s %s test failed (wrong result) on test vector %u, cfg=\"%s\"\n", |
| driver, op, vec_num, cfg->name); |
| return err; |
| } |
| |
| /* If applicable, check that the algorithm generated the correct IV */ |
| if (vec->iv_out && memcmp(iv, vec->iv_out, ivsize) != 0) { |
| pr_err("alg: skcipher: %s %s test failed (wrong output IV) on test vector %u, cfg=\"%s\"\n", |
| driver, op, vec_num, cfg->name); |
| hexdump(iv, ivsize); |
| return -EINVAL; |
| } |
| |
| return 0; |
| } |
| |
| static int test_skcipher_vec(const char *driver, int enc, |
| const struct cipher_testvec *vec, |
| unsigned int vec_num, |
| struct skcipher_request *req, |
| struct cipher_test_sglists *tsgls) |
| { |
| unsigned int i; |
| int err; |
| |
| if (fips_enabled && vec->fips_skip) |
| return 0; |
| |
| for (i = 0; i < ARRAY_SIZE(default_cipher_testvec_configs); i++) { |
| err = test_skcipher_vec_cfg(driver, enc, vec, vec_num, |
| &default_cipher_testvec_configs[i], |
| req, tsgls); |
| if (err) |
| return err; |
| } |
| |
| #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS |
| if (!noextratests) { |
| struct testvec_config cfg; |
| char cfgname[TESTVEC_CONFIG_NAMELEN]; |
| |
| for (i = 0; i < fuzz_iterations; i++) { |
| generate_random_testvec_config(&cfg, cfgname, |
| sizeof(cfgname)); |
| err = test_skcipher_vec_cfg(driver, enc, vec, vec_num, |
| &cfg, req, tsgls); |
| if (err) |
| return err; |
| } |
| } |
| #endif |
| return 0; |
| } |
| |
| static int test_skcipher(const char *driver, int enc, |
| const struct cipher_test_suite *suite, |
| struct skcipher_request *req, |
| struct cipher_test_sglists *tsgls) |
| { |
| unsigned int i; |
| int err; |
| |
| for (i = 0; i < suite->count; i++) { |
| err = test_skcipher_vec(driver, enc, &suite->vecs[i], i, req, |
| tsgls); |
| if (err) |
| return err; |
| } |
| return 0; |
| } |
| |
| static int alg_test_skcipher(const struct alg_test_desc *desc, |
| const char *driver, u32 type, u32 mask) |
| { |
| const struct cipher_test_suite *suite = &desc->suite.cipher; |
| struct crypto_skcipher *tfm; |
| struct skcipher_request *req = NULL; |
| struct cipher_test_sglists *tsgls = NULL; |
| int err; |
| |
| if (suite->count <= 0) { |
| pr_err("alg: skcipher: empty test suite for %s\n", driver); |
| return -EINVAL; |
| } |
| |
| tfm = crypto_alloc_skcipher(driver, type, mask); |
| if (IS_ERR(tfm)) { |
| pr_err("alg: skcipher: failed to allocate transform for %s: %ld\n", |
| driver, PTR_ERR(tfm)); |
| return PTR_ERR(tfm); |
| } |
| |
| req = skcipher_request_alloc(tfm, GFP_KERNEL); |
| if (!req) { |
| pr_err("alg: skcipher: failed to allocate request for %s\n", |
| driver); |
| err = -ENOMEM; |
| goto out; |
| } |
| |
| tsgls = alloc_cipher_test_sglists(); |
| if (!tsgls) { |
| pr_err("alg: skcipher: failed to allocate test buffers for %s\n", |
| driver); |
| err = -ENOMEM; |
| goto out; |
| } |
| |
| err = test_skcipher(driver, ENCRYPT, suite, req, tsgls); |
| if (err) |
| goto out; |
| |
| err = test_skcipher(driver, DECRYPT, suite, req, tsgls); |
| out: |
| free_cipher_test_sglists(tsgls); |
| skcipher_request_free(req); |
| crypto_free_skcipher(tfm); |
| return err; |
| } |
| |
| static int test_comp(struct crypto_comp *tfm, |
| const struct comp_testvec *ctemplate, |
| const struct comp_testvec *dtemplate, |
| int ctcount, int dtcount) |
| { |
| const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm)); |
| char *output, *decomp_output; |
| unsigned int i; |
| int ret; |
| |
| output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); |
| if (!output) |
| return -ENOMEM; |
| |
| decomp_output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); |
| if (!decomp_output) { |
| kfree(output); |
| return -ENOMEM; |
| } |
| |
| for (i = 0; i < ctcount; i++) { |
| int ilen; |
| unsigned int dlen = COMP_BUF_SIZE; |
| |
| memset(output, 0, COMP_BUF_SIZE); |
| memset(decomp_output, 0, COMP_BUF_SIZE); |
| |
| ilen = ctemplate[i].inlen; |
| ret = crypto_comp_compress(tfm, ctemplate[i].input, |
| ilen, output, &dlen); |
| if (ret) { |
| printk(KERN_ERR "alg: comp: compression failed " |
| "on test %d for %s: ret=%d\n", i + 1, algo, |
| -ret); |
| goto out; |
| } |
| |
| ilen = dlen; |
| dlen = COMP_BUF_SIZE; |
| ret = crypto_comp_decompress(tfm, output, |
| ilen, decomp_output, &dlen); |
| if (ret) { |
| pr_err("alg: comp: compression failed: decompress: on test %d for %s failed: ret=%d\n", |
| i + 1, algo, -ret); |
| goto out; |
| } |
| |
| if (dlen != ctemplate[i].inlen) { |
| printk(KERN_ERR "alg: comp: Compression test %d " |
| "failed for %s: output len = %d\n", i + 1, algo, |
| dlen); |
| ret = -EINVAL; |
| goto out; |
| } |
| |
| if (memcmp(decomp_output, ctemplate[i].input, |
| ctemplate[i].inlen)) { |
| pr_err("alg: comp: compression failed: output differs: on test %d for %s\n", |
| i + 1, algo); |
| hexdump(decomp_output, dlen); |
| ret = -EINVAL; |
| goto out; |
| } |
| } |
| |
| for (i = 0; i < dtcount; i++) { |
| int ilen; |
| unsigned int dlen = COMP_BUF_SIZE; |
| |
| memset(decomp_output, 0, COMP_BUF_SIZE); |
| |
| ilen = dtemplate[i].inlen; |
| ret = crypto_comp_decompress(tfm, dtemplate[i].input, |
| ilen, decomp_output, &dlen); |
| if (ret) { |
| printk(KERN_ERR "alg: comp: decompression failed " |
| "on test %d for %s: ret=%d\n", i + 1, algo, |
| -ret); |
| goto out; |
| } |
| |
| if (dlen != dtemplate[i].outlen) { |
| printk(KERN_ERR "alg: comp: Decompression test %d " |
| "failed for %s: output len = %d\n", i + 1, algo, |
| dlen); |
| ret = -EINVAL; |
| goto out; |
| } |
| |
| if (memcmp(decomp_output, dtemplate[i].output, dlen)) { |
| printk(KERN_ERR "alg: comp: Decompression test %d " |
| "failed for %s\n", i + 1, algo); |
| hexdump(decomp_output, dlen); |
| ret = -EINVAL; |
| goto out; |
| } |
| } |
| |
| ret = 0; |
| |
| out: |
| kfree(decomp_output); |
| kfree(output); |
| return ret; |
| } |
| |
| static int test_acomp(struct crypto_acomp *tfm, |
| const struct comp_testvec *ctemplate, |
| const struct comp_testvec *dtemplate, |
| int ctcount, int dtcount) |
| { |
| const char *algo = crypto_tfm_alg_driver_name(crypto_acomp_tfm(tfm)); |
| unsigned int i; |
| char *output, *decomp_out; |
| int ret; |
| struct scatterlist src, dst; |
| struct acomp_req *req; |
| struct crypto_wait wait; |
| |
| output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); |
| if (!output) |
| return -ENOMEM; |
| |
| decomp_out = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); |
| if (!decomp_out) { |
| kfree(output); |
| return -ENOMEM; |
| } |
| |
| for (i = 0; i < ctcount; i++) { |
| unsigned int dlen = COMP_BUF_SIZE; |
| int ilen = ctemplate[i].inlen; |
| void *input_vec; |
| |
| input_vec = kmemdup(ctemplate[i].input, ilen, GFP_KERNEL); |
| if (!input_vec) { |
| ret = -ENOMEM; |
| goto out; |
| } |
| |
| memset(output, 0, dlen); |
| crypto_init_wait(&wait); |
| sg_init_one(&src, input_vec, ilen); |
| sg_init_one(&dst, output, dlen); |
| |
| req = acomp_request_alloc(tfm); |
| if (!req) { |
| pr_err("alg: acomp: request alloc failed for %s\n", |
| algo); |
| kfree(input_vec); |
| ret = -ENOMEM; |
| goto out; |
| } |
| |
| acomp_request_set_params(req, &src, &dst, ilen, dlen); |
| acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, |
| crypto_req_done, &wait); |
| |
| ret = crypto_wait_req(crypto_acomp_compress(req), &wait); |
| if (ret) { |
| pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n", |
| i + 1, algo, -ret); |
| kfree(input_vec); |
| acomp_request_free(req); |
| goto out; |
| } |
| |
| ilen = req->dlen; |
| dlen = COMP_BUF_SIZE; |
| sg_init_one(&src, output, ilen); |
| sg_init_one(&dst, decomp_out, dlen); |
| crypto_init_wait(&wait); |
| acomp_request_set_params(req, &src, &dst, ilen, dlen); |
| |
| ret = crypto_wait_req(crypto_acomp_decompress(req), &wait); |
| if (ret) { |
| pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n", |
| i + 1, algo, -ret); |
| kfree(input_vec); |
| acomp_request_free(req); |
| goto out; |
| } |
| |
| if (req->dlen != ctemplate[i].inlen) { |
| pr_err("alg: acomp: Compression test %d failed for %s: output len = %d\n", |
| i + 1, algo, req->dlen); |
| ret = -EINVAL; |
| kfree(input_vec); |
| acomp_request_free(req); |
| goto out; |
| } |
| |
| if (memcmp(input_vec, decomp_out, req->dlen)) { |
| pr_err("alg: acomp: Compression test %d failed for %s\n", |
| i + 1, algo); |
| hexdump(output, req->dlen); |
| ret = -EINVAL; |
| kfree(input_vec); |
| acomp_request_free(req); |
| goto out; |
| } |
| |
| kfree(input_vec); |
| acomp_request_free(req); |
| } |
| |
| for (i = 0; i < dtcount; i++) { |
| unsigned int dlen = COMP_BUF_SIZE; |
| int ilen = dtemplate[i].inlen; |
| void *input_vec; |
| |
| input_vec = kmemdup(dtemplate[i].input, ilen, GFP_KERNEL); |
| if (!input_vec) { |
| ret = -ENOMEM; |
| goto out; |
| } |
| |
| memset(output, 0, dlen); |
| crypto_init_wait(&wait); |
| sg_init_one(&src, input_vec, ilen); |
| sg_init_one(&dst, output, dlen); |
| |
| req = acomp_request_alloc(tfm); |
| if (!req) { |
| pr_err("alg: acomp: request alloc failed for %s\n", |
| algo); |
| kfree(input_vec); |
| ret = -ENOMEM; |
| goto out; |
| } |
| |
| acomp_request_set_params(req, &src, &dst, ilen, dlen); |
| acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, |
| crypto_req_done, &wait); |
| |
| ret = crypto_wait_req(crypto_acomp_decompress(req), &wait); |
| if (ret) { |
| pr_err("alg: acomp: decompression failed on test %d for %s: ret=%d\n", |
| i + 1, algo, -ret); |
| kfree(input_vec); |
| acomp_request_free(req); |
| goto out; |
| } |
| |
| if (req->dlen != dtemplate[i].outlen) { |
| pr_err("alg: acomp: Decompression test %d failed for %s: output len = %d\n", |
| i + 1, algo, req->dlen); |
| ret = -EINVAL; |
| kfree(input_vec); |
| acomp_request_free(req); |
| goto out; |
| } |
| |
| if (memcmp(output, dtemplate[i].output, req->dlen)) { |
| pr_err("alg: acomp: Decompression test %d failed for %s\n", |
| i + 1, algo); |
| hexdump(output, req->dlen); |
| ret = -EINVAL; |
| kfree(input_vec); |
| acomp_request_free(req); |
| goto out; |
| } |
| |
| kfree(input_vec); |
| acomp_request_free(req); |
| } |
| |
| ret = 0; |
| |
| out: |
| kfree(decomp_out); |
| kfree(output); |
| return ret; |
| } |
| |
| static int test_cprng(struct crypto_rng *tfm, |
| const struct cprng_testvec *template, |
| unsigned int tcount) |
| { |
| const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm)); |
| int err = 0, i, j, seedsize; |
| u8 *seed; |
| char result[32]; |
| |
| seedsize = crypto_rng_seedsize(tfm); |
| |
| seed = kmalloc(seedsize, GFP_KERNEL); |
| if (!seed) { |
| printk(KERN_ERR "alg: cprng: Failed to allocate seed space " |
| "for %s\n", algo); |
| return -ENOMEM; |
| } |
| |
| for (i = 0; i < tcount; i++) { |
| memset(result, 0, 32); |
| |
| memcpy(seed, template[i].v, template[i].vlen); |
| memcpy(seed + template[i].vlen, template[i].key, |
| template[i].klen); |
| memcpy(seed + template[i].vlen + template[i].klen, |
| template[i].dt, template[i].dtlen); |
| |
| err = crypto_rng_reset(tfm, seed, seedsize); |
| if (err) { |
| printk(KERN_ERR "alg: cprng: Failed to reset rng " |
| "for %s\n", algo); |
| goto out; |
| } |
| |
| for (j = 0; j < template[i].loops; j++) { |
| err = crypto_rng_get_bytes(tfm, result, |
| template[i].rlen); |
| if (err < 0) { |
| printk(KERN_ERR "alg: cprng: Failed to obtain " |
| "the correct amount of random data for " |
| "%s (requested %d)\n", algo, |
| template[i].rlen); |
| goto out; |
| } |
| } |
| |
| err = memcmp(result, template[i].result, |
| template[i].rlen); |
| if (err) { |
| printk(KERN_ERR "alg: cprng: Test %d failed for %s\n", |
| i, algo); |
| hexdump(result, template[i].rlen); |
| err = -EINVAL; |
| goto out; |
| } |
| } |
| |
| out: |
| kfree(seed); |
| return err; |
| } |
| |
| static int alg_test_cipher(const struct alg_test_desc *desc, |
| const char *driver, u32 type, u32 mask) |
| { |
| const struct cipher_test_suite *suite = &desc->suite.cipher; |
| struct crypto_cipher *tfm; |
| int err; |
| |
| tfm = crypto_alloc_cipher(driver, type, mask); |
| if (IS_ERR(tfm)) { |
| printk(KERN_ERR "alg: cipher: Failed to load transform for " |
| "%s: %ld\n", driver, PTR_ERR(tfm)); |
| return PTR_ERR(tfm); |
| } |
| |
| err = test_cipher(tfm, ENCRYPT, suite->vecs, suite->count); |
| if (!err) |
| err = test_cipher(tfm, DECRYPT, suite->vecs, suite->count); |
| |
| crypto_free_cipher(tfm); |
| return err; |
| } |
| |
| static int alg_test_comp(const struct alg_test_desc *desc, const char *driver, |
| u32 type, u32 mask) |
| { |
| struct crypto_comp *comp; |
| struct crypto_acomp *acomp; |
| int err; |
| u32 algo_type = type & CRYPTO_ALG_TYPE_ACOMPRESS_MASK; |
| |
| if (algo_type == CRYPTO_ALG_TYPE_ACOMPRESS) { |
| acomp = crypto_alloc_acomp(driver, type, mask); |
| if (IS_ERR(acomp)) { |
| pr_err("alg: acomp: Failed to load transform for %s: %ld\n", |
| driver, PTR_ERR(acomp)); |
| return PTR_ERR(acomp); |
| } |
| err = test_acomp(acomp, desc->suite.comp.comp.vecs, |
| desc->suite.comp.decomp.vecs, |
| desc->suite.comp.comp.count, |
| desc->suite.comp.decomp.count); |
| crypto_free_acomp(acomp); |
| } else { |
| comp = crypto_alloc_comp(driver, type, mask); |
| if (IS_ERR(comp)) { |
| pr_err("alg: comp: Failed to load transform for %s: %ld\n", |
| driver, PTR_ERR(comp)); |
| return PTR_ERR(comp); |
| } |
| |
| err = test_comp(comp, desc->suite.comp.comp.vecs, |
| desc->suite.comp.decomp.vecs, |
| desc->suite.comp.comp.count, |
| desc->suite.comp.decomp.count); |
| |
| crypto_free_comp(comp); |
| } |
| return err; |
| } |
| |
| static int alg_test_crc32c(const struct alg_test_desc *desc, |
| const char *driver, u32 type, u32 mask) |
| { |
| struct crypto_shash *tfm; |
| __le32 val; |
| int err; |
| |
| err = alg_test_hash(desc, driver, type, mask); |
| if (err) |
| return err; |
| |
| tfm = crypto_alloc_shash(driver, type, mask); |
| if (IS_ERR(tfm)) { |
| if (PTR_ERR(tfm) == -ENOENT) { |
| /* |
| * This crc32c implementation is only available through |
| * ahash API, not the shash API, so the remaining part |
| * of the test is not applicable to it. |
| */ |
| return 0; |
| } |
| printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: " |
| "%ld\n", driver, PTR_ERR(tfm)); |
| return PTR_ERR(tfm); |
| } |
| |
| do { |
| SHASH_DESC_ON_STACK(shash, tfm); |
| u32 *ctx = (u32 *)shash_desc_ctx(shash); |
| |
| shash->tfm = tfm; |
| shash->flags = 0; |
| |
| *ctx = 420553207; |
| err = crypto_shash_final(shash, (u8 *)&val); |
| if (err) { |
| printk(KERN_ERR "alg: crc32c: Operation failed for " |
| "%s: %d\n", driver, err); |
| break; |
| } |
| |
| if (val != cpu_to_le32(~420553207)) { |
| pr_err("alg: crc32c: Test failed for %s: %u\n", |
| driver, le32_to_cpu(val)); |
| err = -EINVAL; |
| } |
| } while (0); |
| |
| crypto_free_shash(tfm); |
| |
| return err; |
| } |
| |
| static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver, |
| u32 type, u32 mask) |
| { |
| struct crypto_rng *rng; |
| int err; |
| |
| rng = crypto_alloc_rng(driver, type, mask); |
| if (IS_ERR(rng)) { |
| printk(KERN_ERR "alg: cprng: Failed to load transform for %s: " |
| "%ld\n", driver, PTR_ERR(rng)); |
| return PTR_ERR(rng); |
| } |
| |
| err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count); |
| |
| crypto_free_rng(rng); |
| |
| return err; |
| } |
| |
| |
| static int drbg_cavs_test(const struct drbg_testvec *test, int pr, |
| const char *driver, u32 type, u32 mask) |
| { |
| int ret = -EAGAIN; |
| struct crypto_rng *drng; |
| struct drbg_test_data test_data; |
| struct drbg_string addtl, pers, testentropy; |
| unsigned char *buf = kzalloc(test->expectedlen, GFP_KERNEL); |
| |
| if (!buf) |
| return -ENOMEM; |
| |
| drng = crypto_alloc_rng(driver, type, mask); |
| if (IS_ERR(drng)) { |
| printk(KERN_ERR "alg: drbg: could not allocate DRNG handle for " |
| "%s\n", driver); |
| kzfree(buf); |
| return -ENOMEM; |
| } |
| |
| test_data.testentropy = &testentropy; |
| drbg_string_fill(&testentropy, test->entropy, test->entropylen); |
| drbg_string_fill(&pers, test->pers, test->perslen); |
| ret = crypto_drbg_reset_test(drng, &pers, &test_data); |
| if (ret) { |
| printk(KERN_ERR "alg: drbg: Failed to reset rng\n"); |
| goto outbuf; |
| } |
| |
| drbg_string_fill(&addtl, test->addtla, test->addtllen); |
| if (pr) { |
| drbg_string_fill(&testentropy, test->entpra, test->entprlen); |
| ret = crypto_drbg_get_bytes_addtl_test(drng, |
| buf, test->expectedlen, &addtl, &test_data); |
| } else { |
| ret = crypto_drbg_get_bytes_addtl(drng, |
| buf, test->expectedlen, &addtl); |
| } |
| if (ret < 0) { |
| printk(KERN_ERR "alg: drbg: could not obtain random data for " |
| "driver %s\n", driver); |
| goto outbuf; |
| } |
| |
| drbg_string_fill(&addtl, test->addtlb, test->addtllen); |
| if (pr) { |
| drbg_string_fill(&testentropy, test->entprb, test->entprlen); |
| ret = crypto_drbg_get_bytes_addtl_test(drng, |
| buf, test->expectedlen, &addtl, &test_data); |
| } else { |
| ret = crypto_drbg_get_bytes_addtl(drng, |
| buf, test->expectedlen, &addtl); |
| } |
| if (ret < 0) { |
| printk(KERN_ERR "alg: drbg: could not obtain random data for " |
| "driver %s\n", driver); |
| goto outbuf; |
| } |
| |
| ret = memcmp(test->expected, buf, test->expectedlen); |
| |
| outbuf: |
| crypto_free_rng(drng); |
| kzfree(buf); |
| return ret; |
| } |
| |
| |
| static int alg_test_drbg(const struct alg_test_desc *desc, const char *driver, |
| u32 type, u32 mask) |
| { |
| int err = 0; |
| int pr = 0; |
| int i = 0; |
| const struct drbg_testvec *template = desc->suite.drbg.vecs; |
| unsigned int tcount = desc->suite.drbg.count; |
| |
| if (0 == memcmp(driver, "drbg_pr_", 8)) |
| pr = 1; |
| |
| for (i = 0; i < tcount; i++) { |
| err = drbg_cavs_test(&template[i], pr, driver, type, mask); |
| if (err) { |
| printk(KERN_ERR "alg: drbg: Test %d failed for %s\n", |
| i, driver); |
| err = -EINVAL; |
| break; |
| } |
| } |
| return err; |
| |
| } |
| |
| static int do_test_kpp(struct crypto_kpp *tfm, const struct kpp_testvec *vec, |
| const char *alg) |
| { |
| struct kpp_request *req; |
| void *input_buf = NULL; |
| void *output_buf = NULL; |
| void *a_public = NULL; |
| void *a_ss = NULL; |
| void *shared_secret = NULL; |
| struct crypto_wait wait; |
| unsigned int out_len_max; |
| int err = -ENOMEM; |
| struct scatterlist src, dst; |
| |
| req = kpp_request_alloc(tfm, GFP_KERNEL); |
| if (!req) |
| return err; |
| |
| crypto_init_wait(&wait); |
| |
| err = crypto_kpp_set_secret(tfm, vec->secret, vec->secret_size); |
| if (err < 0) |
| goto free_req; |
| |
| out_len_max = crypto_kpp_maxsize(tfm); |
| output_buf = kzalloc(out_len_max, GFP_KERNEL); |
| if (!output_buf) { |
| err = -ENOMEM; |
| goto free_req; |
| } |
| |
| /* Use appropriate parameter as base */ |
| kpp_request_set_input(req, NULL, 0); |
| sg_init_one(&dst, output_buf, out_len_max); |
| kpp_request_set_output(req, &dst, out_len_max); |
| kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, |
| crypto_req_done, &wait); |
| |
| /* Compute party A's public key */ |
| err = crypto_wait_req(crypto_kpp_generate_public_key(req), &wait); |
| if (err) { |
| pr_err("alg: %s: Party A: generate public key test failed. err %d\n", |
| alg, err); |
| goto free_output; |
| } |
| |
| if (vec->genkey) { |
| /* Save party A's public key */ |
| a_public = kmemdup(sg_virt(req->dst), out_len_max, GFP_KERNEL); |
| if (!a_public) { |
| err = -ENOMEM; |
| goto free_output; |
| } |
| } else { |
| /* Verify calculated public key */ |
| if (memcmp(vec->expected_a_public, sg_virt(req->dst), |
| vec->expected_a_public_size)) { |
| pr_err("alg: %s: Party A: generate public key test failed. Invalid output\n", |
| alg); |
| err = -EINVAL; |
| goto free_output; |
| } |
| } |
| |
| /* Calculate shared secret key by using counter part (b) public key. */ |
| input_buf = kmemdup(vec->b_public, vec->b_public_size, GFP_KERNEL); |
| if (!input_buf) { |
| err = -ENOMEM; |
| goto free_output; |
| } |
| |
| sg_init_one(&src, input_buf, vec->b_public_size); |
| sg_init_one(&dst, output_buf, out_len_max); |
| kpp_request_set_input(req, &src, vec->b_public_size); |
| kpp_request_set_output(req, &dst, out_len_max); |
| kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, |
| crypto_req_done, &wait); |
| err = crypto_wait_req(crypto_kpp_compute_shared_secret(req), &wait); |
| if (err) { |
| pr_err("alg: %s: Party A: compute shared secret test failed. err %d\n", |
| alg, err); |
| goto free_all; |
| } |
| |
| if (vec->genkey) { |
| /* Save the shared secret obtained by party A */ |
| a_ss = kmemdup(sg_virt(req->dst), vec->expected_ss_size, GFP_KERNEL); |
| if (!a_ss) { |
| err = -ENOMEM; |
| goto free_all; |
| } |
| |
| /* |
| * Calculate party B's shared secret by using party A's |
| * public key. |
| */ |
| err = crypto_kpp_set_secret(tfm, vec->b_secret, |
| vec->b_secret_size); |
| if (err < 0) |
| goto free_all; |
| |
| sg_init_one(&src, a_public, vec->expected_a_public_size); |
| sg_init_one(&dst, output_buf, out_len_max); |
| kpp_request_set_input(req, &src, vec->expected_a_public_size); |
| kpp_request_set_output(req, &dst, out_len_max); |
| kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, |
| crypto_req_done, &wait); |
| err = crypto_wait_req(crypto_kpp_compute_shared_secret(req), |
| &wait); |
| if (err) { |
| pr_err("alg: %s: Party B: compute shared secret failed. err %d\n", |
| alg, err); |
| goto free_all; |
| } |
| |
| shared_secret = a_ss; |
| } else { |
| shared_secret = (void *)vec->expected_ss; |
| } |
| |
| /* |
| * verify shared secret from which the user will derive |
| * secret key by executing whatever hash it has chosen |
| */ |
| if (memcmp(shared_secret, sg_virt(req->dst), |
| vec->expected_ss_size)) { |
| pr_err("alg: %s: compute shared secret test failed. Invalid output\n", |
| alg); |
| err = -EINVAL; |
| } |
| |
| free_all: |
| kfree(a_ss); |
| kfree(input_buf); |
| free_output: |
| kfree(a_public); |
| kfree(output_buf); |
| free_req: |
| kpp_request_free(req); |
| return err; |
| } |
| |
| static int test_kpp(struct crypto_kpp *tfm, const char *alg, |
| const struct kpp_testvec *vecs, unsigned int tcount) |
| { |
| int ret, i; |
| |
| for (i = 0; i < tcount; i++) { |
| ret = do_test_kpp(tfm, vecs++, alg); |
| if (ret) { |
| pr_err("alg: %s: test failed on vector %d, err=%d\n", |
| alg, i + 1, ret); |
| return ret; |
| } |
| } |
| return 0; |
| } |
| |
| static int alg_test_kpp(const struct alg_test_desc *desc, const char *driver, |
| u32 type, u32 mask) |
| { |
| struct crypto_kpp *tfm; |
| int err = 0; |
| |
| tfm = crypto_alloc_kpp(driver, type, mask); |
| if (IS_ERR(tfm)) { |
| pr_err("alg: kpp: Failed to load tfm for %s: %ld\n", |
| driver, PTR_ERR(tfm)); |
| return PTR_ERR(tfm); |
| } |
| if (desc->suite.kpp.vecs) |
| err = test_kpp(tfm, desc->alg, desc->suite.kpp.vecs, |
| desc->suite.kpp.count); |
| |
| crypto_free_kpp(tfm); |
| return err; |
| } |
| |
| static int test_akcipher_one(struct crypto_akcipher *tfm, |
| const struct akcipher_testvec *vecs) |
| { |
| char *xbuf[XBUFSIZE]; |
| struct akcipher_request *req; |
| void *outbuf_enc = NULL; |
| void *outbuf_dec = NULL; |
| struct crypto_wait wait; |
| unsigned int out_len_max, out_len = 0; |
| int err = -ENOMEM; |
| struct scatterlist src, dst, src_tab[2]; |
| const char *m, *c; |
| unsigned int m_size, c_size; |
| const char *op; |
| |
| if (testmgr_alloc_buf(xbuf)) |
| return err; |
| |
| req = akcipher_request_alloc(tfm, GFP_KERNEL); |
| if (!req) |
| goto free_xbuf; |
| |
| crypto_init_wait(&wait); |
| |
| if (vecs->public_key_vec) |
| err = crypto_akcipher_set_pub_key(tfm, vecs->key, |
| vecs->key_len); |
| else |
| err = crypto_akcipher_set_priv_key(tfm, vecs->key, |
| vecs->key_len); |
| if (err) |
| goto free_req; |
| |
| err = -ENOMEM; |
| out_len_max = crypto_akcipher_maxsize(tfm); |
| |
| /* |
| * First run test which do not require a private key, such as |
| * encrypt or verify. |
| */ |
| outbuf_enc = kzalloc(out_len_max, GFP_KERNEL); |
| if (!outbuf_enc) |
| goto free_req; |
| |
| if (!vecs->siggen_sigver_test) { |
| m = vecs->m; |
| m_size = vecs->m_size; |
| c = vecs->c; |
| c_size = vecs->c_size; |
| op = "encrypt"; |
| } else { |
| /* Swap args so we could keep plaintext (digest) |
| * in vecs->m, and cooked signature in vecs->c. |
| */ |
| m = vecs->c; /* signature */ |
| m_size = vecs->c_size; |
| c = vecs->m; /* digest */ |
| c_size = vecs->m_size; |
| op = "verify"; |
| } |
| |
| if (WARN_ON(m_size > PAGE_SIZE)) |
| goto free_all; |
| memcpy(xbuf[0], m, m_size); |
| |
| sg_init_table(src_tab, 2); |
| sg_set_buf(&src_tab[0], xbuf[0], 8); |
| sg_set_buf(&src_tab[1], xbuf[0] + 8, m_size - 8); |
| sg_init_one(&dst, outbuf_enc, out_len_max); |
| akcipher_request_set_crypt(req, src_tab, &dst, m_size, |
| out_len_max); |
| akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, |
| crypto_req_done, &wait); |
| |
| err = crypto_wait_req(vecs->siggen_sigver_test ? |
| /* Run asymmetric signature verification */ |
| crypto_akcipher_verify(req) : |
| /* Run asymmetric encrypt */ |
| crypto_akcipher_encrypt(req), &wait); |
| if (err) { |
| pr_err("alg: akcipher: %s test failed. err %d\n", op, err); |
| goto free_all; |
| } |
| if (req->dst_len != c_size) { |
| pr_err("alg: akcipher: %s test failed. Invalid output len\n", |
| op); |
| err = -EINVAL; |
| goto free_all; |
| } |
| /* verify that encrypted message is equal to expected */ |
| if (memcmp(c, outbuf_enc, c_size)) { |
| pr_err("alg: akcipher: %s test failed. Invalid output\n", op); |
| hexdump(outbuf_enc, c_size); |
| err = -EINVAL; |
| goto free_all; |
| } |
| |
| /* |
| * Don't invoke (decrypt or sign) test which require a private key |
| * for vectors with only a public key. |
| */ |
| if (vecs->public_key_vec) { |
| err = 0; |
| goto free_all; |
| } |
| outbuf_dec = kzalloc(out_len_max, GFP_KERNEL); |
| if (!outbuf_dec) { |
| err = -ENOMEM; |
| goto free_all; |
| } |
| |
| op = vecs->siggen_sigver_test ? "sign" : "decrypt"; |
| if (WARN_ON(c_size > PAGE_SIZE)) |
| goto free_all; |
| memcpy(xbuf[0], c, c_size); |
| |
| sg_init_one(&src, xbuf[0], c_size); |
| sg_init_one(&dst, outbuf_dec, out_len_max); |
| crypto_init_wait(&wait); |
| akcipher_request_set_crypt(req, &src, &dst, c_size, out_len_max); |
| |
| err = crypto_wait_req(vecs->siggen_sigver_test ? |
| /* Run asymmetric signature generation */ |
| crypto_akcipher_sign(req) : |
| /* Run asymmetric decrypt */ |
| crypto_akcipher_decrypt(req), &wait); |
| if (err) { |
| pr_err("alg: akcipher: %s test failed. err %d\n", op, err); |
| goto free_all; |
| } |
| out_len = req->dst_len; |
| if (out_len < m_size) { |
| pr_err("alg: akcipher: %s test failed. Invalid output len %u\n", |
| op, out_len); |
| err = -EINVAL; |
| goto free_all; |
| } |
| /* verify that decrypted message is equal to the original msg */ |
| if (memchr_inv(outbuf_dec, 0, out_len - m_size) || |
| memcmp(m, outbuf_dec + out_len - m_size, m_size)) { |
| pr_err("alg: akcipher: %s test failed. Invalid output\n", op); |
| hexdump(outbuf_dec, out_len); |
| err = -EINVAL; |
| } |
| free_all: |
| kfree(outbuf_dec); |
| kfree(outbuf_enc); |
| free_req: |
| akcipher_request_free(req); |
| free_xbuf: |
| testmgr_free_buf(xbuf); |
| return err; |
| } |
| |
| static int test_akcipher(struct crypto_akcipher *tfm, const char *alg, |
| const struct akcipher_testvec *vecs, |
| unsigned int tcount) |
| { |
| const char *algo = |
| crypto_tfm_alg_driver_name(crypto_akcipher_tfm(tfm)); |
| int ret, i; |
| |
| for (i = 0; i < tcount; i++) { |
| ret = test_akcipher_one(tfm, vecs++); |
| if (!ret) |
| continue; |
| |
| pr_err("alg: akcipher: test %d failed for %s, err=%d\n", |
| i + 1, algo, ret); |
| return ret; |
| } |
| return 0; |
| } |
| |
| static int alg_test_akcipher(const struct alg_test_desc *desc, |
| const char *driver, u32 type, u32 mask) |
| { |
| struct crypto_akcipher *tfm; |
| int err = 0; |
| |
| tfm = crypto_alloc_akcipher(driver, type, mask); |
| if (IS_ERR(tfm)) { |
| pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n", |
| driver, PTR_ERR(tfm)); |
| return PTR_ERR(tfm); |
| } |
| if (desc->suite.akcipher.vecs) |
| err = test_akcipher(tfm, desc->alg, desc->suite.akcipher.vecs, |
| desc->suite.akcipher.count); |
| |
| crypto_free_akcipher(tfm); |
| return err; |
| } |
| |
| static int alg_test_null(const struct alg_test_desc *desc, |
| const char *driver, u32 type, u32 mask) |
| { |
| return 0; |
| } |
| |
| #define __VECS(tv) { .vecs = tv, .count = ARRAY_SIZE(tv) } |
| |
| /* Please keep this list sorted by algorithm name. */ |
| static const struct alg_test_desc alg_test_descs[] = { |
| { |
| .alg = "adiantum(xchacha12,aes)", |
| .test = alg_test_skcipher, |
| .suite = { |
| .cipher = __VECS(adiantum_xchacha12_aes_tv_template) |
| }, |
| }, { |
| .alg = "adiantum(xchacha20,aes)", |
| .test = alg_test_skcipher, |
| .suite = { |
| .cipher = __VECS(adiantum_xchacha20_aes_tv_template) |
| }, |
| }, { |
| .alg = "aegis128", |
| .test = alg_test_aead, |
| .suite = { |
| .aead = __VECS(aegis128_tv_template) |
| } |
| }, { |
| .alg = "aegis128l", |
| .test = alg_test_aead, |
| .suite = { |
| .aead = __VECS(aegis128l_tv_template) |
| } |
| }, { |
| .alg = "aegis256", |
| .test = alg_test_aead, |
| .suite = { |
| .aead = __VECS(aegis256_tv_template) |
| } |
| }, { |
| .alg = "ansi_cprng", |
| .test = alg_test_cprng, |
| .suite = { |
| .cprng = __VECS(ansi_cprng_aes_tv_template) |
| } |
| }, { |
| .alg = "authenc(hmac(md5),ecb(cipher_null))", |
| .test = alg_test_aead, |
| .suite = { |
| .aead = __VECS(hmac_md5_ecb_cipher_null_tv_template) |
| } |
| }, { |
| .alg = "authenc(hmac(sha1),cbc(aes))", |
| .test = alg_test_aead, |
| .fips_allowed = 1, |
| .suite = { |
| .aead = __VECS(hmac_sha1_aes_cbc_tv_temp) |
| } |
| }, { |
| .alg = "authenc(hmac(sha1),cbc(des))", |
| .test = alg_test_aead, |
| .suite = { |
| .aead = __VECS(hmac_sha1_des_cbc_tv_temp) |
| } |
| }, { |
| .alg = "authenc(hmac(sha1),cbc(des3_ede))", |
| .test = alg_test_aead, |
| .fips_allowed = 1, |
| .suite = { |
| .aead = __VECS(hmac_sha1_des3_ede_cbc_tv_temp) |
| } |
| }, { |
| .alg = "authenc(hmac(sha1),ctr(aes))", |
| .test = alg_test_null, |
| .fips_allowed = 1, |
| }, { |
| .alg = "authenc(hmac(sha1),ecb(cipher_null))", |
| .test = alg_test_aead, |
| .suite = { |
| .aead = __VECS(hmac_sha1_ecb_cipher_null_tv_temp) |
| } |
| }, { |
| .alg = "authenc(hmac(sha1),rfc3686(ctr(aes)))", |
| .test = alg_test_null, |
| .fips_allowed = 1, |
| }, { |
| .alg = "authenc(hmac(sha224),cbc(des))", |
| .test = alg_test_aead, |
| .suite = { |
| .aead = __VECS(hmac_sha224_des_cbc_tv_temp) |
| } |
| }, { |
| .alg = "authenc(hmac(sha224),cbc(des3_ede))", |
| .test = alg_test_aead, |
| .fips_allowed = 1, |
| .suite = { |
| .aead = __VECS(hmac_sha224_des3_ede_cbc_tv_temp) |
| } |
| }, { |
| .alg = "authenc(hmac(sha256),cbc(aes))", |
| .test = alg_test_aead, |
| .fips_allowed = 1, |
| .suite = { |
| .aead = __VECS(hmac_sha256_aes_cbc_tv_temp) |
| } |
| }, { |
| .alg = "authenc(hmac(sha256),cbc(des))", |
| .test = alg_test_aead, |
| .suite = { |
| .aead = __VECS(hmac_sha256_des_cbc_tv_temp) |
| } |
| }, { |
| .alg = "authenc(hmac(sha256),cbc(des3_ede))", |
| .test = alg_test_aead, |
| .fips_allowed = 1, |
| .suite = { |
| .aead = __VECS(hmac_sha256_des3_ede_cbc_tv_temp) |
| } |
| }, { |
| .alg = "authenc(hmac(sha256),ctr(aes))", |
| .test = alg_test_null, |
| .fips_allowed = 1, |
| }, { |
| .alg = "authenc(hmac(sha256),rfc3686(ctr(aes)))", |
| .test = alg_test_null, |
| .fips_allowed = 1, |
| }, { |
| .alg = "authenc(hmac(sha384),cbc(des))", |
| .test = alg_test_aead, |
| .suite = { |
| .aead = __VECS(hmac_sha384_des_cbc_tv_temp) |
| } |
| }, { |
| .alg = "authenc(hmac(sha384),cbc(des3_ede))", |
| .test = alg_test_aead, |
| .fips_allowed = 1, |
| .suite = { |
| .aead = __VECS(hmac_sha384_des3_ede_cbc_tv_temp) |
| } |
| }, { |
| .alg = "authenc(hmac(sha384),ctr(aes))", |
| .test = alg_test_null, |
| .fips_allowed = 1, |
| }, { |
| .alg = "authenc(hmac(sha384),rfc3686(ctr(aes)))", |
| .test = alg_test_null, |
| .fips_allowed = 1, |
| }, { |
| .alg = "authenc(hmac(sha512),cbc(aes))", |
| .fips_allowed = 1, |
| .test = alg_test_aead, |
| .suite = { |
| .aead = __VECS(hmac_sha512_aes_cbc_tv_temp) |
| } |
| }, { |
| .alg = "authenc(hmac(sha512),cbc(des))", |
| .test = alg_test_aead, |
| .suite = { |
| .aead = __VECS(hmac_sha512_des_cbc_tv_temp) |
| } |
| }, { |
| .alg = "authenc(hmac(sha512),cbc(des3_ede))", |
| .test = alg_test_aead, |
| .fips_allowed = 1, |
| .suite = { |
| .aead = __VECS(hmac_sha512_des3_ede_cbc_tv_temp) |
| } |
| }, { |
| .alg = "authenc(hmac(sha512),ctr(aes))", |
| .test = alg_test_null, |
| .fips_allowed = 1, |
| }, { |
| .alg = "authenc(hmac(sha512),rfc3686(ctr(aes)))", |
| .test = alg_test_null, |
| .fips_allowed = 1, |
| }, { |
| .alg = "cbc(aes)", |
| .test = alg_test_skcipher, |
| .fips_allowed = 1, |
| .suite = { |
| .cipher = __VECS(aes_cbc_tv_template) |
| }, |
| }, { |
| .alg = "cbc(anubis)", |
| .test = alg_test_skcipher, |
| .suite = { |
| .cipher = __VECS(anubis_cbc_tv_template) |
| }, |
| }, { |
| .alg = "cbc(blowfish)", |
| .test = alg_test_skcipher, |
| .suite = { |
| .cipher = __VECS(bf_cbc_tv_template) |
| }, |
| }, { |
| .alg = "cbc(camellia)", |
| .test = alg_test_skcipher, |
| .suite = { |
| .cipher = __VECS(camellia_cbc_tv_template) |
| }, |
| }, { |
| .alg = "cbc(cast5)", |
| .test = alg_test_skcipher, |
| .suite = { |
| .cipher = __VECS(cast5_cbc_tv_template) |
| }, |
| }, { |
| .alg = "cbc(cast6)", |
| .test = alg_test_skcipher, |
| .suite = { |
| .cipher = __VECS(cast6_cbc_tv_template) |
| }, |
| }, { |
| .alg = "cbc(des)", |
| .test = alg_test_skcipher, |
| .suite = { |
| .cipher = __VECS(des_cbc_tv_template) |
| }, |
| }, { |
| .alg = "cbc(des3_ede)", |
| .test = alg_test_skcipher, |
| .fips_allowed = 1, |
| .suite = { |
| .cipher = __VECS(des3_ede_cbc_tv_template) |
| }, |
| }, { |
| /* Same as cbc(aes) except the key is stored in |
| * hardware secure memory which we reference by index |
| */ |
| .alg = "cbc(paes)", |
| .test = alg_test_null, |
| .fips_allowed = 1, |
| }, { |
| .alg = "cbc(serpent)", |
| .test = alg_test_skcipher, |
| .suite = { |
| |