12874c5fdSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later 2da7f033dSHerbert Xu /* 3da7f033dSHerbert Xu * Algorithm testing framework and tests. 4da7f033dSHerbert Xu * 5da7f033dSHerbert Xu * Copyright (c) 2002 James Morris <jmorris@intercode.com.au> 6da7f033dSHerbert Xu * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org> 7da7f033dSHerbert Xu * Copyright (c) 2007 Nokia Siemens Networks 8da7f033dSHerbert Xu * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au> 93f47a03dSEric Biggers * Copyright (c) 2019 Google LLC 10da7f033dSHerbert Xu * 1169435b94SAdrian Hoban * Updated RFC4106 AES-GCM testing. 1269435b94SAdrian Hoban * Authors: Aidan O'Mahony (aidan.o.mahony@intel.com) 1369435b94SAdrian Hoban * Adrian Hoban <adrian.hoban@intel.com> 1469435b94SAdrian Hoban * Gabriele Paoloni <gabriele.paoloni@intel.com> 1569435b94SAdrian Hoban * Tadeusz Struk (tadeusz.struk@intel.com) 1669435b94SAdrian Hoban * Copyright (c) 2010, Intel Corporation. 17da7f033dSHerbert Xu */ 18da7f033dSHerbert Xu 191ce33115SHerbert Xu #include <crypto/aead.h> 20da7f033dSHerbert Xu #include <crypto/hash.h> 2112773d93SHerbert Xu #include <crypto/skcipher.h> 22da7f033dSHerbert Xu #include <linux/err.h> 231c41b882SHerbert Xu #include <linux/fips.h> 24da7f033dSHerbert Xu #include <linux/module.h> 253f47a03dSEric Biggers #include <linux/once.h> 2625f9dddbSEric Biggers #include <linux/random.h> 27da7f033dSHerbert Xu #include <linux/scatterlist.h> 28da7f033dSHerbert Xu #include <linux/slab.h> 29da7f033dSHerbert Xu #include <linux/string.h> 307647d6ceSJarod Wilson #include <crypto/rng.h> 3164d1cdfbSStephan Mueller #include <crypto/drbg.h> 32946cc463STadeusz Struk #include <crypto/akcipher.h> 33802c7f1cSSalvatore Benedetto #include <crypto/kpp.h> 34d7db7a88SGiovanni Cabiddu #include <crypto/acompress.h> 35b55e1a39SEric Biggers #include <crypto/internal/simd.h> 36da7f033dSHerbert Xu 37da7f033dSHerbert Xu #include "internal.h" 380b767f96SAlexander Shishkin 399e5c9fe4SRichard W.M. Jones static bool notests; 409e5c9fe4SRichard W.M. Jones module_param(notests, bool, 0644); 419e5c9fe4SRichard W.M. Jones MODULE_PARM_DESC(notests, "disable crypto self-tests"); 429e5c9fe4SRichard W.M. Jones 43eda69b0cSEric Biggers static bool panic_on_fail; 44eda69b0cSEric Biggers module_param(panic_on_fail, bool, 0444); 45eda69b0cSEric Biggers 465b2706a4SEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 475b2706a4SEric Biggers static bool noextratests; 485b2706a4SEric Biggers module_param(noextratests, bool, 0644); 495b2706a4SEric Biggers MODULE_PARM_DESC(noextratests, "disable expensive crypto self-tests"); 505b2706a4SEric Biggers 515b2706a4SEric Biggers static unsigned int fuzz_iterations = 100; 525b2706a4SEric Biggers module_param(fuzz_iterations, uint, 0644); 535b2706a4SEric Biggers MODULE_PARM_DESC(fuzz_iterations, "number of fuzz test iterations"); 54b55e1a39SEric Biggers 55b55e1a39SEric Biggers DEFINE_PER_CPU(bool, crypto_simd_disabled_for_test); 56b55e1a39SEric Biggers EXPORT_PER_CPU_SYMBOL_GPL(crypto_simd_disabled_for_test); 575b2706a4SEric Biggers #endif 585b2706a4SEric Biggers 59326a6346SHerbert Xu #ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS 600b767f96SAlexander Shishkin 610b767f96SAlexander Shishkin /* a perfect nop */ 620b767f96SAlexander Shishkin int alg_test(const char *driver, const char *alg, u32 type, u32 mask) 630b767f96SAlexander Shishkin { 640b767f96SAlexander Shishkin return 0; 650b767f96SAlexander Shishkin } 660b767f96SAlexander Shishkin 670b767f96SAlexander Shishkin #else 680b767f96SAlexander Shishkin 69da7f033dSHerbert Xu #include "testmgr.h" 70da7f033dSHerbert Xu 71da7f033dSHerbert Xu /* 72da7f033dSHerbert Xu * Need slab memory for testing (size in number of pages). 73da7f033dSHerbert Xu */ 74da7f033dSHerbert Xu #define XBUFSIZE 8 75da7f033dSHerbert Xu 76da7f033dSHerbert Xu /* 77da7f033dSHerbert Xu * Used by test_cipher() 78da7f033dSHerbert Xu */ 79da7f033dSHerbert Xu #define ENCRYPT 1 80da7f033dSHerbert Xu #define DECRYPT 0 81da7f033dSHerbert Xu 82da7f033dSHerbert Xu struct aead_test_suite { 83b13b1e0cSEric Biggers const struct aead_testvec *vecs; 84da7f033dSHerbert Xu unsigned int count; 85da7f033dSHerbert Xu }; 86da7f033dSHerbert Xu 87da7f033dSHerbert Xu struct cipher_test_suite { 88b13b1e0cSEric Biggers const struct cipher_testvec *vecs; 89da7f033dSHerbert Xu unsigned int count; 90da7f033dSHerbert Xu }; 91da7f033dSHerbert Xu 92da7f033dSHerbert Xu struct comp_test_suite { 93da7f033dSHerbert Xu struct { 94b13b1e0cSEric Biggers const struct comp_testvec *vecs; 95da7f033dSHerbert Xu unsigned int count; 96da7f033dSHerbert Xu } comp, decomp; 97da7f033dSHerbert Xu }; 98da7f033dSHerbert Xu 99da7f033dSHerbert Xu struct hash_test_suite { 100b13b1e0cSEric Biggers const struct hash_testvec *vecs; 101da7f033dSHerbert Xu unsigned int count; 102da7f033dSHerbert Xu }; 103da7f033dSHerbert Xu 1047647d6ceSJarod Wilson struct cprng_test_suite { 105b13b1e0cSEric Biggers const struct cprng_testvec *vecs; 1067647d6ceSJarod Wilson unsigned int count; 1077647d6ceSJarod Wilson }; 1087647d6ceSJarod Wilson 10964d1cdfbSStephan Mueller struct drbg_test_suite { 110b13b1e0cSEric Biggers const struct drbg_testvec *vecs; 11164d1cdfbSStephan Mueller unsigned int count; 11264d1cdfbSStephan Mueller }; 11364d1cdfbSStephan Mueller 114946cc463STadeusz Struk struct akcipher_test_suite { 115b13b1e0cSEric Biggers const struct akcipher_testvec *vecs; 116946cc463STadeusz Struk unsigned int count; 117946cc463STadeusz Struk }; 118946cc463STadeusz Struk 119802c7f1cSSalvatore Benedetto struct kpp_test_suite { 120b13b1e0cSEric Biggers const struct kpp_testvec *vecs; 121802c7f1cSSalvatore Benedetto unsigned int count; 122802c7f1cSSalvatore Benedetto }; 123802c7f1cSSalvatore Benedetto 124da7f033dSHerbert Xu struct alg_test_desc { 125da7f033dSHerbert Xu const char *alg; 126f2bb770aSEric Biggers const char *generic_driver; 127da7f033dSHerbert Xu int (*test)(const struct alg_test_desc *desc, const char *driver, 128da7f033dSHerbert Xu u32 type, u32 mask); 129a1915d51SJarod Wilson int fips_allowed; /* set if alg is allowed in fips mode */ 130da7f033dSHerbert Xu 131da7f033dSHerbert Xu union { 132da7f033dSHerbert Xu struct aead_test_suite aead; 133da7f033dSHerbert Xu struct cipher_test_suite cipher; 134da7f033dSHerbert Xu struct comp_test_suite comp; 135da7f033dSHerbert Xu struct hash_test_suite hash; 1367647d6ceSJarod Wilson struct cprng_test_suite cprng; 13764d1cdfbSStephan Mueller struct drbg_test_suite drbg; 138946cc463STadeusz Struk struct akcipher_test_suite akcipher; 139802c7f1cSSalvatore Benedetto struct kpp_test_suite kpp; 140da7f033dSHerbert Xu } suite; 141da7f033dSHerbert Xu }; 142da7f033dSHerbert Xu 143da7f033dSHerbert Xu static void hexdump(unsigned char *buf, unsigned int len) 144da7f033dSHerbert Xu { 145da7f033dSHerbert Xu print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET, 146da7f033dSHerbert Xu 16, 1, 147da7f033dSHerbert Xu buf, len, false); 148da7f033dSHerbert Xu } 149da7f033dSHerbert Xu 1503f47a03dSEric Biggers static int __testmgr_alloc_buf(char *buf[XBUFSIZE], int order) 151f8b0d4d0SHerbert Xu { 152f8b0d4d0SHerbert Xu int i; 153f8b0d4d0SHerbert Xu 154f8b0d4d0SHerbert Xu for (i = 0; i < XBUFSIZE; i++) { 1553f47a03dSEric Biggers buf[i] = (char *)__get_free_pages(GFP_KERNEL, order); 156f8b0d4d0SHerbert Xu if (!buf[i]) 157f8b0d4d0SHerbert Xu goto err_free_buf; 158f8b0d4d0SHerbert Xu } 159f8b0d4d0SHerbert Xu 160f8b0d4d0SHerbert Xu return 0; 161f8b0d4d0SHerbert Xu 162f8b0d4d0SHerbert Xu err_free_buf: 163f8b0d4d0SHerbert Xu while (i-- > 0) 1643f47a03dSEric Biggers free_pages((unsigned long)buf[i], order); 165f8b0d4d0SHerbert Xu 166f8b0d4d0SHerbert Xu return -ENOMEM; 167f8b0d4d0SHerbert Xu } 168f8b0d4d0SHerbert Xu 1693f47a03dSEric Biggers static int testmgr_alloc_buf(char *buf[XBUFSIZE]) 1703f47a03dSEric Biggers { 1713f47a03dSEric Biggers return __testmgr_alloc_buf(buf, 0); 1723f47a03dSEric Biggers } 1733f47a03dSEric Biggers 1743f47a03dSEric Biggers static void __testmgr_free_buf(char *buf[XBUFSIZE], int order) 175f8b0d4d0SHerbert Xu { 176f8b0d4d0SHerbert Xu int i; 177f8b0d4d0SHerbert Xu 178f8b0d4d0SHerbert Xu for (i = 0; i < XBUFSIZE; i++) 1793f47a03dSEric Biggers free_pages((unsigned long)buf[i], order); 1803f47a03dSEric Biggers } 1813f47a03dSEric Biggers 1823f47a03dSEric Biggers static void testmgr_free_buf(char *buf[XBUFSIZE]) 1833f47a03dSEric Biggers { 1843f47a03dSEric Biggers __testmgr_free_buf(buf, 0); 1853f47a03dSEric Biggers } 1863f47a03dSEric Biggers 1873f47a03dSEric Biggers #define TESTMGR_POISON_BYTE 0xfe 1883f47a03dSEric Biggers #define TESTMGR_POISON_LEN 16 1893f47a03dSEric Biggers 1903f47a03dSEric Biggers static inline void testmgr_poison(void *addr, size_t len) 1913f47a03dSEric Biggers { 1923f47a03dSEric Biggers memset(addr, TESTMGR_POISON_BYTE, len); 1933f47a03dSEric Biggers } 1943f47a03dSEric Biggers 1953f47a03dSEric Biggers /* Is the memory region still fully poisoned? */ 1963f47a03dSEric Biggers static inline bool testmgr_is_poison(const void *addr, size_t len) 1973f47a03dSEric Biggers { 1983f47a03dSEric Biggers return memchr_inv(addr, TESTMGR_POISON_BYTE, len) == NULL; 1993f47a03dSEric Biggers } 2003f47a03dSEric Biggers 2013f47a03dSEric Biggers /* flush type for hash algorithms */ 2023f47a03dSEric Biggers enum flush_type { 2033f47a03dSEric Biggers /* merge with update of previous buffer(s) */ 2043f47a03dSEric Biggers FLUSH_TYPE_NONE = 0, 2053f47a03dSEric Biggers 2063f47a03dSEric Biggers /* update with previous buffer(s) before doing this one */ 2073f47a03dSEric Biggers FLUSH_TYPE_FLUSH, 2083f47a03dSEric Biggers 2093f47a03dSEric Biggers /* likewise, but also export and re-import the intermediate state */ 2103f47a03dSEric Biggers FLUSH_TYPE_REIMPORT, 2113f47a03dSEric Biggers }; 2123f47a03dSEric Biggers 2133f47a03dSEric Biggers /* finalization function for hash algorithms */ 2143f47a03dSEric Biggers enum finalization_type { 2153f47a03dSEric Biggers FINALIZATION_TYPE_FINAL, /* use final() */ 2163f47a03dSEric Biggers FINALIZATION_TYPE_FINUP, /* use finup() */ 2173f47a03dSEric Biggers FINALIZATION_TYPE_DIGEST, /* use digest() */ 2183f47a03dSEric Biggers }; 2193f47a03dSEric Biggers 2203f47a03dSEric Biggers #define TEST_SG_TOTAL 10000 2213f47a03dSEric Biggers 2223f47a03dSEric Biggers /** 2233f47a03dSEric Biggers * struct test_sg_division - description of a scatterlist entry 2243f47a03dSEric Biggers * 2253f47a03dSEric Biggers * This struct describes one entry of a scatterlist being constructed to check a 2263f47a03dSEric Biggers * crypto test vector. 2273f47a03dSEric Biggers * 2283f47a03dSEric Biggers * @proportion_of_total: length of this chunk relative to the total length, 2293f47a03dSEric Biggers * given as a proportion out of TEST_SG_TOTAL so that it 2303f47a03dSEric Biggers * scales to fit any test vector 2313f47a03dSEric Biggers * @offset: byte offset into a 2-page buffer at which this chunk will start 2323f47a03dSEric Biggers * @offset_relative_to_alignmask: if true, add the algorithm's alignmask to the 2333f47a03dSEric Biggers * @offset 2343f47a03dSEric Biggers * @flush_type: for hashes, whether an update() should be done now vs. 2353f47a03dSEric Biggers * continuing to accumulate data 2366570737cSEric Biggers * @nosimd: if doing the pending update(), do it with SIMD disabled? 2373f47a03dSEric Biggers */ 2383f47a03dSEric Biggers struct test_sg_division { 2393f47a03dSEric Biggers unsigned int proportion_of_total; 2403f47a03dSEric Biggers unsigned int offset; 2413f47a03dSEric Biggers bool offset_relative_to_alignmask; 2423f47a03dSEric Biggers enum flush_type flush_type; 2436570737cSEric Biggers bool nosimd; 2443f47a03dSEric Biggers }; 2453f47a03dSEric Biggers 2463f47a03dSEric Biggers /** 2473f47a03dSEric Biggers * struct testvec_config - configuration for testing a crypto test vector 2483f47a03dSEric Biggers * 2493f47a03dSEric Biggers * This struct describes the data layout and other parameters with which each 2503f47a03dSEric Biggers * crypto test vector can be tested. 2513f47a03dSEric Biggers * 2523f47a03dSEric Biggers * @name: name of this config, logged for debugging purposes if a test fails 2533f47a03dSEric Biggers * @inplace: operate on the data in-place, if applicable for the algorithm type? 2543f47a03dSEric Biggers * @req_flags: extra request_flags, e.g. CRYPTO_TFM_REQ_MAY_SLEEP 2553f47a03dSEric Biggers * @src_divs: description of how to arrange the source scatterlist 2563f47a03dSEric Biggers * @dst_divs: description of how to arrange the dst scatterlist, if applicable 2573f47a03dSEric Biggers * for the algorithm type. Defaults to @src_divs if unset. 2583f47a03dSEric Biggers * @iv_offset: misalignment of the IV in the range [0..MAX_ALGAPI_ALIGNMASK+1], 2593f47a03dSEric Biggers * where 0 is aligned to a 2*(MAX_ALGAPI_ALIGNMASK+1) byte boundary 2603f47a03dSEric Biggers * @iv_offset_relative_to_alignmask: if true, add the algorithm's alignmask to 2613f47a03dSEric Biggers * the @iv_offset 2623f47a03dSEric Biggers * @finalization_type: what finalization function to use for hashes 2636570737cSEric Biggers * @nosimd: execute with SIMD disabled? Requires !CRYPTO_TFM_REQ_MAY_SLEEP. 2643f47a03dSEric Biggers */ 2653f47a03dSEric Biggers struct testvec_config { 2663f47a03dSEric Biggers const char *name; 2673f47a03dSEric Biggers bool inplace; 2683f47a03dSEric Biggers u32 req_flags; 2693f47a03dSEric Biggers struct test_sg_division src_divs[XBUFSIZE]; 2703f47a03dSEric Biggers struct test_sg_division dst_divs[XBUFSIZE]; 2713f47a03dSEric Biggers unsigned int iv_offset; 2723f47a03dSEric Biggers bool iv_offset_relative_to_alignmask; 2733f47a03dSEric Biggers enum finalization_type finalization_type; 2746570737cSEric Biggers bool nosimd; 2753f47a03dSEric Biggers }; 2763f47a03dSEric Biggers 2773f47a03dSEric Biggers #define TESTVEC_CONFIG_NAMELEN 192 2783f47a03dSEric Biggers 2794e7babbaSEric Biggers /* 2804e7babbaSEric Biggers * The following are the lists of testvec_configs to test for each algorithm 2814e7babbaSEric Biggers * type when the basic crypto self-tests are enabled, i.e. when 2824e7babbaSEric Biggers * CONFIG_CRYPTO_MANAGER_DISABLE_TESTS is unset. They aim to provide good test 2834e7babbaSEric Biggers * coverage, while keeping the test time much shorter than the full fuzz tests 2844e7babbaSEric Biggers * so that the basic tests can be enabled in a wider range of circumstances. 2854e7babbaSEric Biggers */ 2864e7babbaSEric Biggers 2874e7babbaSEric Biggers /* Configs for skciphers and aeads */ 2884e7babbaSEric Biggers static const struct testvec_config default_cipher_testvec_configs[] = { 2894e7babbaSEric Biggers { 2904e7babbaSEric Biggers .name = "in-place", 2914e7babbaSEric Biggers .inplace = true, 2924e7babbaSEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 2934e7babbaSEric Biggers }, { 2944e7babbaSEric Biggers .name = "out-of-place", 2954e7babbaSEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 2964e7babbaSEric Biggers }, { 2974e7babbaSEric Biggers .name = "unaligned buffer, offset=1", 2984e7babbaSEric Biggers .src_divs = { { .proportion_of_total = 10000, .offset = 1 } }, 2994e7babbaSEric Biggers .iv_offset = 1, 3004e7babbaSEric Biggers }, { 3014e7babbaSEric Biggers .name = "buffer aligned only to alignmask", 3024e7babbaSEric Biggers .src_divs = { 3034e7babbaSEric Biggers { 3044e7babbaSEric Biggers .proportion_of_total = 10000, 3054e7babbaSEric Biggers .offset = 1, 3064e7babbaSEric Biggers .offset_relative_to_alignmask = true, 3074e7babbaSEric Biggers }, 3084e7babbaSEric Biggers }, 3094e7babbaSEric Biggers .iv_offset = 1, 3104e7babbaSEric Biggers .iv_offset_relative_to_alignmask = true, 3114e7babbaSEric Biggers }, { 3124e7babbaSEric Biggers .name = "two even aligned splits", 3134e7babbaSEric Biggers .src_divs = { 3144e7babbaSEric Biggers { .proportion_of_total = 5000 }, 3154e7babbaSEric Biggers { .proportion_of_total = 5000 }, 3164e7babbaSEric Biggers }, 3174e7babbaSEric Biggers }, { 3184e7babbaSEric Biggers .name = "uneven misaligned splits, may sleep", 3194e7babbaSEric Biggers .req_flags = CRYPTO_TFM_REQ_MAY_SLEEP, 3204e7babbaSEric Biggers .src_divs = { 3214e7babbaSEric Biggers { .proportion_of_total = 1900, .offset = 33 }, 3224e7babbaSEric Biggers { .proportion_of_total = 3300, .offset = 7 }, 3234e7babbaSEric Biggers { .proportion_of_total = 4800, .offset = 18 }, 3244e7babbaSEric Biggers }, 3254e7babbaSEric Biggers .iv_offset = 3, 3264e7babbaSEric Biggers }, { 3274e7babbaSEric Biggers .name = "misaligned splits crossing pages, inplace", 3284e7babbaSEric Biggers .inplace = true, 3294e7babbaSEric Biggers .src_divs = { 3304e7babbaSEric Biggers { 3314e7babbaSEric Biggers .proportion_of_total = 7500, 3324e7babbaSEric Biggers .offset = PAGE_SIZE - 32 3334e7babbaSEric Biggers }, { 3344e7babbaSEric Biggers .proportion_of_total = 2500, 3354e7babbaSEric Biggers .offset = PAGE_SIZE - 7 3364e7babbaSEric Biggers }, 3374e7babbaSEric Biggers }, 3384e7babbaSEric Biggers } 3394e7babbaSEric Biggers }; 3404e7babbaSEric Biggers 3414cc2dcf9SEric Biggers static const struct testvec_config default_hash_testvec_configs[] = { 3424cc2dcf9SEric Biggers { 3434cc2dcf9SEric Biggers .name = "init+update+final aligned buffer", 3444cc2dcf9SEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 3454cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINAL, 3464cc2dcf9SEric Biggers }, { 3474cc2dcf9SEric Biggers .name = "init+finup aligned buffer", 3484cc2dcf9SEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 3494cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINUP, 3504cc2dcf9SEric Biggers }, { 3514cc2dcf9SEric Biggers .name = "digest aligned buffer", 3524cc2dcf9SEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 3534cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_DIGEST, 3544cc2dcf9SEric Biggers }, { 3554cc2dcf9SEric Biggers .name = "init+update+final misaligned buffer", 3564cc2dcf9SEric Biggers .src_divs = { { .proportion_of_total = 10000, .offset = 1 } }, 3574cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINAL, 3584cc2dcf9SEric Biggers }, { 3594cc2dcf9SEric Biggers .name = "digest buffer aligned only to alignmask", 3604cc2dcf9SEric Biggers .src_divs = { 3614cc2dcf9SEric Biggers { 3624cc2dcf9SEric Biggers .proportion_of_total = 10000, 3634cc2dcf9SEric Biggers .offset = 1, 3644cc2dcf9SEric Biggers .offset_relative_to_alignmask = true, 3654cc2dcf9SEric Biggers }, 3664cc2dcf9SEric Biggers }, 3674cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_DIGEST, 3684cc2dcf9SEric Biggers }, { 3694cc2dcf9SEric Biggers .name = "init+update+update+final two even splits", 3704cc2dcf9SEric Biggers .src_divs = { 3714cc2dcf9SEric Biggers { .proportion_of_total = 5000 }, 3724cc2dcf9SEric Biggers { 3734cc2dcf9SEric Biggers .proportion_of_total = 5000, 3744cc2dcf9SEric Biggers .flush_type = FLUSH_TYPE_FLUSH, 3754cc2dcf9SEric Biggers }, 3764cc2dcf9SEric Biggers }, 3774cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINAL, 3784cc2dcf9SEric Biggers }, { 3794cc2dcf9SEric Biggers .name = "digest uneven misaligned splits, may sleep", 3804cc2dcf9SEric Biggers .req_flags = CRYPTO_TFM_REQ_MAY_SLEEP, 3814cc2dcf9SEric Biggers .src_divs = { 3824cc2dcf9SEric Biggers { .proportion_of_total = 1900, .offset = 33 }, 3834cc2dcf9SEric Biggers { .proportion_of_total = 3300, .offset = 7 }, 3844cc2dcf9SEric Biggers { .proportion_of_total = 4800, .offset = 18 }, 3854cc2dcf9SEric Biggers }, 3864cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_DIGEST, 3874cc2dcf9SEric Biggers }, { 3884cc2dcf9SEric Biggers .name = "digest misaligned splits crossing pages", 3894cc2dcf9SEric Biggers .src_divs = { 3904cc2dcf9SEric Biggers { 3914cc2dcf9SEric Biggers .proportion_of_total = 7500, 3924cc2dcf9SEric Biggers .offset = PAGE_SIZE - 32, 3934cc2dcf9SEric Biggers }, { 3944cc2dcf9SEric Biggers .proportion_of_total = 2500, 3954cc2dcf9SEric Biggers .offset = PAGE_SIZE - 7, 3964cc2dcf9SEric Biggers }, 3974cc2dcf9SEric Biggers }, 3984cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_DIGEST, 3994cc2dcf9SEric Biggers }, { 4004cc2dcf9SEric Biggers .name = "import/export", 4014cc2dcf9SEric Biggers .src_divs = { 4024cc2dcf9SEric Biggers { 4034cc2dcf9SEric Biggers .proportion_of_total = 6500, 4044cc2dcf9SEric Biggers .flush_type = FLUSH_TYPE_REIMPORT, 4054cc2dcf9SEric Biggers }, { 4064cc2dcf9SEric Biggers .proportion_of_total = 3500, 4074cc2dcf9SEric Biggers .flush_type = FLUSH_TYPE_REIMPORT, 4084cc2dcf9SEric Biggers }, 4094cc2dcf9SEric Biggers }, 4104cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINAL, 4114cc2dcf9SEric Biggers } 4124cc2dcf9SEric Biggers }; 4134cc2dcf9SEric Biggers 4143f47a03dSEric Biggers static unsigned int count_test_sg_divisions(const struct test_sg_division *divs) 4153f47a03dSEric Biggers { 4163f47a03dSEric Biggers unsigned int remaining = TEST_SG_TOTAL; 4173f47a03dSEric Biggers unsigned int ndivs = 0; 4183f47a03dSEric Biggers 4193f47a03dSEric Biggers do { 4203f47a03dSEric Biggers remaining -= divs[ndivs++].proportion_of_total; 4213f47a03dSEric Biggers } while (remaining); 4223f47a03dSEric Biggers 4233f47a03dSEric Biggers return ndivs; 4243f47a03dSEric Biggers } 4253f47a03dSEric Biggers 4266570737cSEric Biggers #define SGDIVS_HAVE_FLUSHES BIT(0) 4276570737cSEric Biggers #define SGDIVS_HAVE_NOSIMD BIT(1) 4286570737cSEric Biggers 4293f47a03dSEric Biggers static bool valid_sg_divisions(const struct test_sg_division *divs, 4306570737cSEric Biggers unsigned int count, int *flags_ret) 4313f47a03dSEric Biggers { 4323f47a03dSEric Biggers unsigned int total = 0; 4333f47a03dSEric Biggers unsigned int i; 4343f47a03dSEric Biggers 4353f47a03dSEric Biggers for (i = 0; i < count && total != TEST_SG_TOTAL; i++) { 4363f47a03dSEric Biggers if (divs[i].proportion_of_total <= 0 || 4373f47a03dSEric Biggers divs[i].proportion_of_total > TEST_SG_TOTAL - total) 4383f47a03dSEric Biggers return false; 4393f47a03dSEric Biggers total += divs[i].proportion_of_total; 4403f47a03dSEric Biggers if (divs[i].flush_type != FLUSH_TYPE_NONE) 4416570737cSEric Biggers *flags_ret |= SGDIVS_HAVE_FLUSHES; 4426570737cSEric Biggers if (divs[i].nosimd) 4436570737cSEric Biggers *flags_ret |= SGDIVS_HAVE_NOSIMD; 4443f47a03dSEric Biggers } 4453f47a03dSEric Biggers return total == TEST_SG_TOTAL && 4463f47a03dSEric Biggers memchr_inv(&divs[i], 0, (count - i) * sizeof(divs[0])) == NULL; 4473f47a03dSEric Biggers } 4483f47a03dSEric Biggers 4493f47a03dSEric Biggers /* 4503f47a03dSEric Biggers * Check whether the given testvec_config is valid. This isn't strictly needed 4513f47a03dSEric Biggers * since every testvec_config should be valid, but check anyway so that people 4523f47a03dSEric Biggers * don't unknowingly add broken configs that don't do what they wanted. 4533f47a03dSEric Biggers */ 4543f47a03dSEric Biggers static bool valid_testvec_config(const struct testvec_config *cfg) 4553f47a03dSEric Biggers { 4566570737cSEric Biggers int flags = 0; 4573f47a03dSEric Biggers 4583f47a03dSEric Biggers if (cfg->name == NULL) 4593f47a03dSEric Biggers return false; 4603f47a03dSEric Biggers 4613f47a03dSEric Biggers if (!valid_sg_divisions(cfg->src_divs, ARRAY_SIZE(cfg->src_divs), 4626570737cSEric Biggers &flags)) 4633f47a03dSEric Biggers return false; 4643f47a03dSEric Biggers 4653f47a03dSEric Biggers if (cfg->dst_divs[0].proportion_of_total) { 4663f47a03dSEric Biggers if (!valid_sg_divisions(cfg->dst_divs, 4676570737cSEric Biggers ARRAY_SIZE(cfg->dst_divs), &flags)) 4683f47a03dSEric Biggers return false; 4693f47a03dSEric Biggers } else { 4703f47a03dSEric Biggers if (memchr_inv(cfg->dst_divs, 0, sizeof(cfg->dst_divs))) 4713f47a03dSEric Biggers return false; 4723f47a03dSEric Biggers /* defaults to dst_divs=src_divs */ 4733f47a03dSEric Biggers } 4743f47a03dSEric Biggers 4753f47a03dSEric Biggers if (cfg->iv_offset + 4763f47a03dSEric Biggers (cfg->iv_offset_relative_to_alignmask ? MAX_ALGAPI_ALIGNMASK : 0) > 4773f47a03dSEric Biggers MAX_ALGAPI_ALIGNMASK + 1) 4783f47a03dSEric Biggers return false; 4793f47a03dSEric Biggers 4806570737cSEric Biggers if ((flags & (SGDIVS_HAVE_FLUSHES | SGDIVS_HAVE_NOSIMD)) && 4816570737cSEric Biggers cfg->finalization_type == FINALIZATION_TYPE_DIGEST) 4826570737cSEric Biggers return false; 4836570737cSEric Biggers 4846570737cSEric Biggers if ((cfg->nosimd || (flags & SGDIVS_HAVE_NOSIMD)) && 4856570737cSEric Biggers (cfg->req_flags & CRYPTO_TFM_REQ_MAY_SLEEP)) 4863f47a03dSEric Biggers return false; 4873f47a03dSEric Biggers 4883f47a03dSEric Biggers return true; 4893f47a03dSEric Biggers } 4903f47a03dSEric Biggers 4913f47a03dSEric Biggers struct test_sglist { 4923f47a03dSEric Biggers char *bufs[XBUFSIZE]; 4933f47a03dSEric Biggers struct scatterlist sgl[XBUFSIZE]; 4943f47a03dSEric Biggers struct scatterlist sgl_saved[XBUFSIZE]; 4953f47a03dSEric Biggers struct scatterlist *sgl_ptr; 4963f47a03dSEric Biggers unsigned int nents; 4973f47a03dSEric Biggers }; 4983f47a03dSEric Biggers 4993f47a03dSEric Biggers static int init_test_sglist(struct test_sglist *tsgl) 5003f47a03dSEric Biggers { 5013f47a03dSEric Biggers return __testmgr_alloc_buf(tsgl->bufs, 1 /* two pages per buffer */); 5023f47a03dSEric Biggers } 5033f47a03dSEric Biggers 5043f47a03dSEric Biggers static void destroy_test_sglist(struct test_sglist *tsgl) 5053f47a03dSEric Biggers { 5063f47a03dSEric Biggers return __testmgr_free_buf(tsgl->bufs, 1 /* two pages per buffer */); 5073f47a03dSEric Biggers } 5083f47a03dSEric Biggers 5093f47a03dSEric Biggers /** 5103f47a03dSEric Biggers * build_test_sglist() - build a scatterlist for a crypto test 5113f47a03dSEric Biggers * 5123f47a03dSEric Biggers * @tsgl: the scatterlist to build. @tsgl->bufs[] contains an array of 2-page 5133f47a03dSEric Biggers * buffers which the scatterlist @tsgl->sgl[] will be made to point into. 5143f47a03dSEric Biggers * @divs: the layout specification on which the scatterlist will be based 5153f47a03dSEric Biggers * @alignmask: the algorithm's alignmask 5163f47a03dSEric Biggers * @total_len: the total length of the scatterlist to build in bytes 5173f47a03dSEric Biggers * @data: if non-NULL, the buffers will be filled with this data until it ends. 5183f47a03dSEric Biggers * Otherwise the buffers will be poisoned. In both cases, some bytes 5193f47a03dSEric Biggers * past the end of each buffer will be poisoned to help detect overruns. 5203f47a03dSEric Biggers * @out_divs: if non-NULL, the test_sg_division to which each scatterlist entry 5213f47a03dSEric Biggers * corresponds will be returned here. This will match @divs except 5223f47a03dSEric Biggers * that divisions resolving to a length of 0 are omitted as they are 5233f47a03dSEric Biggers * not included in the scatterlist. 5243f47a03dSEric Biggers * 5253f47a03dSEric Biggers * Return: 0 or a -errno value 5263f47a03dSEric Biggers */ 5273f47a03dSEric Biggers static int build_test_sglist(struct test_sglist *tsgl, 5283f47a03dSEric Biggers const struct test_sg_division *divs, 5293f47a03dSEric Biggers const unsigned int alignmask, 5303f47a03dSEric Biggers const unsigned int total_len, 5313f47a03dSEric Biggers struct iov_iter *data, 5323f47a03dSEric Biggers const struct test_sg_division *out_divs[XBUFSIZE]) 5333f47a03dSEric Biggers { 5343f47a03dSEric Biggers struct { 5353f47a03dSEric Biggers const struct test_sg_division *div; 5363f47a03dSEric Biggers size_t length; 5373f47a03dSEric Biggers } partitions[XBUFSIZE]; 5383f47a03dSEric Biggers const unsigned int ndivs = count_test_sg_divisions(divs); 5393f47a03dSEric Biggers unsigned int len_remaining = total_len; 5403f47a03dSEric Biggers unsigned int i; 5413f47a03dSEric Biggers 5423f47a03dSEric Biggers BUILD_BUG_ON(ARRAY_SIZE(partitions) != ARRAY_SIZE(tsgl->sgl)); 5433f47a03dSEric Biggers if (WARN_ON(ndivs > ARRAY_SIZE(partitions))) 5443f47a03dSEric Biggers return -EINVAL; 5453f47a03dSEric Biggers 5463f47a03dSEric Biggers /* Calculate the (div, length) pairs */ 5473f47a03dSEric Biggers tsgl->nents = 0; 5483f47a03dSEric Biggers for (i = 0; i < ndivs; i++) { 5493f47a03dSEric Biggers unsigned int len_this_sg = 5503f47a03dSEric Biggers min(len_remaining, 5513f47a03dSEric Biggers (total_len * divs[i].proportion_of_total + 5523f47a03dSEric Biggers TEST_SG_TOTAL / 2) / TEST_SG_TOTAL); 5533f47a03dSEric Biggers 5543f47a03dSEric Biggers if (len_this_sg != 0) { 5553f47a03dSEric Biggers partitions[tsgl->nents].div = &divs[i]; 5563f47a03dSEric Biggers partitions[tsgl->nents].length = len_this_sg; 5573f47a03dSEric Biggers tsgl->nents++; 5583f47a03dSEric Biggers len_remaining -= len_this_sg; 5593f47a03dSEric Biggers } 5603f47a03dSEric Biggers } 5613f47a03dSEric Biggers if (tsgl->nents == 0) { 5623f47a03dSEric Biggers partitions[tsgl->nents].div = &divs[0]; 5633f47a03dSEric Biggers partitions[tsgl->nents].length = 0; 5643f47a03dSEric Biggers tsgl->nents++; 5653f47a03dSEric Biggers } 5663f47a03dSEric Biggers partitions[tsgl->nents - 1].length += len_remaining; 5673f47a03dSEric Biggers 5683f47a03dSEric Biggers /* Set up the sgl entries and fill the data or poison */ 5693f47a03dSEric Biggers sg_init_table(tsgl->sgl, tsgl->nents); 5703f47a03dSEric Biggers for (i = 0; i < tsgl->nents; i++) { 5713f47a03dSEric Biggers unsigned int offset = partitions[i].div->offset; 5723f47a03dSEric Biggers void *addr; 5733f47a03dSEric Biggers 5743f47a03dSEric Biggers if (partitions[i].div->offset_relative_to_alignmask) 5753f47a03dSEric Biggers offset += alignmask; 5763f47a03dSEric Biggers 5773f47a03dSEric Biggers while (offset + partitions[i].length + TESTMGR_POISON_LEN > 5783f47a03dSEric Biggers 2 * PAGE_SIZE) { 5793f47a03dSEric Biggers if (WARN_ON(offset <= 0)) 5803f47a03dSEric Biggers return -EINVAL; 5813f47a03dSEric Biggers offset /= 2; 5823f47a03dSEric Biggers } 5833f47a03dSEric Biggers 5843f47a03dSEric Biggers addr = &tsgl->bufs[i][offset]; 5853f47a03dSEric Biggers sg_set_buf(&tsgl->sgl[i], addr, partitions[i].length); 5863f47a03dSEric Biggers 5873f47a03dSEric Biggers if (out_divs) 5883f47a03dSEric Biggers out_divs[i] = partitions[i].div; 5893f47a03dSEric Biggers 5903f47a03dSEric Biggers if (data) { 5913f47a03dSEric Biggers size_t copy_len, copied; 5923f47a03dSEric Biggers 5933f47a03dSEric Biggers copy_len = min(partitions[i].length, data->count); 5943f47a03dSEric Biggers copied = copy_from_iter(addr, copy_len, data); 5953f47a03dSEric Biggers if (WARN_ON(copied != copy_len)) 5963f47a03dSEric Biggers return -EINVAL; 5973f47a03dSEric Biggers testmgr_poison(addr + copy_len, partitions[i].length + 5983f47a03dSEric Biggers TESTMGR_POISON_LEN - copy_len); 5993f47a03dSEric Biggers } else { 6003f47a03dSEric Biggers testmgr_poison(addr, partitions[i].length + 6013f47a03dSEric Biggers TESTMGR_POISON_LEN); 6023f47a03dSEric Biggers } 6033f47a03dSEric Biggers } 6043f47a03dSEric Biggers 6053f47a03dSEric Biggers sg_mark_end(&tsgl->sgl[tsgl->nents - 1]); 6063f47a03dSEric Biggers tsgl->sgl_ptr = tsgl->sgl; 6073f47a03dSEric Biggers memcpy(tsgl->sgl_saved, tsgl->sgl, tsgl->nents * sizeof(tsgl->sgl[0])); 6083f47a03dSEric Biggers return 0; 6093f47a03dSEric Biggers } 6103f47a03dSEric Biggers 6113f47a03dSEric Biggers /* 6123f47a03dSEric Biggers * Verify that a scatterlist crypto operation produced the correct output. 6133f47a03dSEric Biggers * 6143f47a03dSEric Biggers * @tsgl: scatterlist containing the actual output 6153f47a03dSEric Biggers * @expected_output: buffer containing the expected output 6163f47a03dSEric Biggers * @len_to_check: length of @expected_output in bytes 6173f47a03dSEric Biggers * @unchecked_prefix_len: number of ignored bytes in @tsgl prior to real result 6183f47a03dSEric Biggers * @check_poison: verify that the poison bytes after each chunk are intact? 6193f47a03dSEric Biggers * 6203f47a03dSEric Biggers * Return: 0 if correct, -EINVAL if incorrect, -EOVERFLOW if buffer overrun. 6213f47a03dSEric Biggers */ 6223f47a03dSEric Biggers static int verify_correct_output(const struct test_sglist *tsgl, 6233f47a03dSEric Biggers const char *expected_output, 6243f47a03dSEric Biggers unsigned int len_to_check, 6253f47a03dSEric Biggers unsigned int unchecked_prefix_len, 6263f47a03dSEric Biggers bool check_poison) 6273f47a03dSEric Biggers { 6283f47a03dSEric Biggers unsigned int i; 6293f47a03dSEric Biggers 6303f47a03dSEric Biggers for (i = 0; i < tsgl->nents; i++) { 6313f47a03dSEric Biggers struct scatterlist *sg = &tsgl->sgl_ptr[i]; 6323f47a03dSEric Biggers unsigned int len = sg->length; 6333f47a03dSEric Biggers unsigned int offset = sg->offset; 6343f47a03dSEric Biggers const char *actual_output; 6353f47a03dSEric Biggers 6363f47a03dSEric Biggers if (unchecked_prefix_len) { 6373f47a03dSEric Biggers if (unchecked_prefix_len >= len) { 6383f47a03dSEric Biggers unchecked_prefix_len -= len; 6393f47a03dSEric Biggers continue; 6403f47a03dSEric Biggers } 6413f47a03dSEric Biggers offset += unchecked_prefix_len; 6423f47a03dSEric Biggers len -= unchecked_prefix_len; 6433f47a03dSEric Biggers unchecked_prefix_len = 0; 6443f47a03dSEric Biggers } 6453f47a03dSEric Biggers len = min(len, len_to_check); 6463f47a03dSEric Biggers actual_output = page_address(sg_page(sg)) + offset; 6473f47a03dSEric Biggers if (memcmp(expected_output, actual_output, len) != 0) 6483f47a03dSEric Biggers return -EINVAL; 6493f47a03dSEric Biggers if (check_poison && 6503f47a03dSEric Biggers !testmgr_is_poison(actual_output + len, TESTMGR_POISON_LEN)) 6513f47a03dSEric Biggers return -EOVERFLOW; 6523f47a03dSEric Biggers len_to_check -= len; 6533f47a03dSEric Biggers expected_output += len; 6543f47a03dSEric Biggers } 6553f47a03dSEric Biggers if (WARN_ON(len_to_check != 0)) 6563f47a03dSEric Biggers return -EINVAL; 6573f47a03dSEric Biggers return 0; 6583f47a03dSEric Biggers } 6593f47a03dSEric Biggers 6603f47a03dSEric Biggers static bool is_test_sglist_corrupted(const struct test_sglist *tsgl) 6613f47a03dSEric Biggers { 6623f47a03dSEric Biggers unsigned int i; 6633f47a03dSEric Biggers 6643f47a03dSEric Biggers for (i = 0; i < tsgl->nents; i++) { 6653f47a03dSEric Biggers if (tsgl->sgl[i].page_link != tsgl->sgl_saved[i].page_link) 6663f47a03dSEric Biggers return true; 6673f47a03dSEric Biggers if (tsgl->sgl[i].offset != tsgl->sgl_saved[i].offset) 6683f47a03dSEric Biggers return true; 6693f47a03dSEric Biggers if (tsgl->sgl[i].length != tsgl->sgl_saved[i].length) 6703f47a03dSEric Biggers return true; 6713f47a03dSEric Biggers } 6723f47a03dSEric Biggers return false; 6733f47a03dSEric Biggers } 6743f47a03dSEric Biggers 6753f47a03dSEric Biggers struct cipher_test_sglists { 6763f47a03dSEric Biggers struct test_sglist src; 6773f47a03dSEric Biggers struct test_sglist dst; 6783f47a03dSEric Biggers }; 6793f47a03dSEric Biggers 6803f47a03dSEric Biggers static struct cipher_test_sglists *alloc_cipher_test_sglists(void) 6813f47a03dSEric Biggers { 6823f47a03dSEric Biggers struct cipher_test_sglists *tsgls; 6833f47a03dSEric Biggers 6843f47a03dSEric Biggers tsgls = kmalloc(sizeof(*tsgls), GFP_KERNEL); 6853f47a03dSEric Biggers if (!tsgls) 6863f47a03dSEric Biggers return NULL; 6873f47a03dSEric Biggers 6883f47a03dSEric Biggers if (init_test_sglist(&tsgls->src) != 0) 6893f47a03dSEric Biggers goto fail_kfree; 6903f47a03dSEric Biggers if (init_test_sglist(&tsgls->dst) != 0) 6913f47a03dSEric Biggers goto fail_destroy_src; 6923f47a03dSEric Biggers 6933f47a03dSEric Biggers return tsgls; 6943f47a03dSEric Biggers 6953f47a03dSEric Biggers fail_destroy_src: 6963f47a03dSEric Biggers destroy_test_sglist(&tsgls->src); 6973f47a03dSEric Biggers fail_kfree: 6983f47a03dSEric Biggers kfree(tsgls); 6993f47a03dSEric Biggers return NULL; 7003f47a03dSEric Biggers } 7013f47a03dSEric Biggers 7023f47a03dSEric Biggers static void free_cipher_test_sglists(struct cipher_test_sglists *tsgls) 7033f47a03dSEric Biggers { 7043f47a03dSEric Biggers if (tsgls) { 7053f47a03dSEric Biggers destroy_test_sglist(&tsgls->src); 7063f47a03dSEric Biggers destroy_test_sglist(&tsgls->dst); 7073f47a03dSEric Biggers kfree(tsgls); 7083f47a03dSEric Biggers } 7093f47a03dSEric Biggers } 7103f47a03dSEric Biggers 7113f47a03dSEric Biggers /* Build the src and dst scatterlists for an skcipher or AEAD test */ 7123f47a03dSEric Biggers static int build_cipher_test_sglists(struct cipher_test_sglists *tsgls, 7133f47a03dSEric Biggers const struct testvec_config *cfg, 7143f47a03dSEric Biggers unsigned int alignmask, 7153f47a03dSEric Biggers unsigned int src_total_len, 7163f47a03dSEric Biggers unsigned int dst_total_len, 7173f47a03dSEric Biggers const struct kvec *inputs, 7183f47a03dSEric Biggers unsigned int nr_inputs) 7193f47a03dSEric Biggers { 7203f47a03dSEric Biggers struct iov_iter input; 7213f47a03dSEric Biggers int err; 7223f47a03dSEric Biggers 7233f47a03dSEric Biggers iov_iter_kvec(&input, WRITE, inputs, nr_inputs, src_total_len); 7243f47a03dSEric Biggers err = build_test_sglist(&tsgls->src, cfg->src_divs, alignmask, 7253f47a03dSEric Biggers cfg->inplace ? 7263f47a03dSEric Biggers max(dst_total_len, src_total_len) : 7273f47a03dSEric Biggers src_total_len, 7283f47a03dSEric Biggers &input, NULL); 7293f47a03dSEric Biggers if (err) 7303f47a03dSEric Biggers return err; 7313f47a03dSEric Biggers 7323f47a03dSEric Biggers if (cfg->inplace) { 7333f47a03dSEric Biggers tsgls->dst.sgl_ptr = tsgls->src.sgl; 7343f47a03dSEric Biggers tsgls->dst.nents = tsgls->src.nents; 7353f47a03dSEric Biggers return 0; 7363f47a03dSEric Biggers } 7373f47a03dSEric Biggers return build_test_sglist(&tsgls->dst, 7383f47a03dSEric Biggers cfg->dst_divs[0].proportion_of_total ? 7393f47a03dSEric Biggers cfg->dst_divs : cfg->src_divs, 7403f47a03dSEric Biggers alignmask, dst_total_len, NULL, NULL); 741f8b0d4d0SHerbert Xu } 742f8b0d4d0SHerbert Xu 74325f9dddbSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 744f2bb770aSEric Biggers 745f2bb770aSEric Biggers /* Generate a random length in range [0, max_len], but prefer smaller values */ 746f2bb770aSEric Biggers static unsigned int generate_random_length(unsigned int max_len) 747f2bb770aSEric Biggers { 748f2bb770aSEric Biggers unsigned int len = prandom_u32() % (max_len + 1); 749f2bb770aSEric Biggers 750f2bb770aSEric Biggers switch (prandom_u32() % 4) { 751f2bb770aSEric Biggers case 0: 752f2bb770aSEric Biggers return len % 64; 753f2bb770aSEric Biggers case 1: 754f2bb770aSEric Biggers return len % 256; 755f2bb770aSEric Biggers case 2: 756f2bb770aSEric Biggers return len % 1024; 757f2bb770aSEric Biggers default: 758f2bb770aSEric Biggers return len; 759f2bb770aSEric Biggers } 760f2bb770aSEric Biggers } 761f2bb770aSEric Biggers 762f2bb770aSEric Biggers /* Sometimes make some random changes to the given data buffer */ 763f2bb770aSEric Biggers static void mutate_buffer(u8 *buf, size_t count) 764f2bb770aSEric Biggers { 765f2bb770aSEric Biggers size_t num_flips; 766f2bb770aSEric Biggers size_t i; 767f2bb770aSEric Biggers size_t pos; 768f2bb770aSEric Biggers 769f2bb770aSEric Biggers /* Sometimes flip some bits */ 770f2bb770aSEric Biggers if (prandom_u32() % 4 == 0) { 771f2bb770aSEric Biggers num_flips = min_t(size_t, 1 << (prandom_u32() % 8), count * 8); 772f2bb770aSEric Biggers for (i = 0; i < num_flips; i++) { 773f2bb770aSEric Biggers pos = prandom_u32() % (count * 8); 774f2bb770aSEric Biggers buf[pos / 8] ^= 1 << (pos % 8); 775f2bb770aSEric Biggers } 776f2bb770aSEric Biggers } 777f2bb770aSEric Biggers 778f2bb770aSEric Biggers /* Sometimes flip some bytes */ 779f2bb770aSEric Biggers if (prandom_u32() % 4 == 0) { 780f2bb770aSEric Biggers num_flips = min_t(size_t, 1 << (prandom_u32() % 8), count); 781f2bb770aSEric Biggers for (i = 0; i < num_flips; i++) 782f2bb770aSEric Biggers buf[prandom_u32() % count] ^= 0xff; 783f2bb770aSEric Biggers } 784f2bb770aSEric Biggers } 785f2bb770aSEric Biggers 786f2bb770aSEric Biggers /* Randomly generate 'count' bytes, but sometimes make them "interesting" */ 787f2bb770aSEric Biggers static void generate_random_bytes(u8 *buf, size_t count) 788f2bb770aSEric Biggers { 789f2bb770aSEric Biggers u8 b; 790f2bb770aSEric Biggers u8 increment; 791f2bb770aSEric Biggers size_t i; 792f2bb770aSEric Biggers 793f2bb770aSEric Biggers if (count == 0) 794f2bb770aSEric Biggers return; 795f2bb770aSEric Biggers 796f2bb770aSEric Biggers switch (prandom_u32() % 8) { /* Choose a generation strategy */ 797f2bb770aSEric Biggers case 0: 798f2bb770aSEric Biggers case 1: 799f2bb770aSEric Biggers /* All the same byte, plus optional mutations */ 800f2bb770aSEric Biggers switch (prandom_u32() % 4) { 801f2bb770aSEric Biggers case 0: 802f2bb770aSEric Biggers b = 0x00; 803f2bb770aSEric Biggers break; 804f2bb770aSEric Biggers case 1: 805f2bb770aSEric Biggers b = 0xff; 806f2bb770aSEric Biggers break; 807f2bb770aSEric Biggers default: 808f2bb770aSEric Biggers b = (u8)prandom_u32(); 809f2bb770aSEric Biggers break; 810f2bb770aSEric Biggers } 811f2bb770aSEric Biggers memset(buf, b, count); 812f2bb770aSEric Biggers mutate_buffer(buf, count); 813f2bb770aSEric Biggers break; 814f2bb770aSEric Biggers case 2: 815f2bb770aSEric Biggers /* Ascending or descending bytes, plus optional mutations */ 816f2bb770aSEric Biggers increment = (u8)prandom_u32(); 817f2bb770aSEric Biggers b = (u8)prandom_u32(); 818f2bb770aSEric Biggers for (i = 0; i < count; i++, b += increment) 819f2bb770aSEric Biggers buf[i] = b; 820f2bb770aSEric Biggers mutate_buffer(buf, count); 821f2bb770aSEric Biggers break; 822f2bb770aSEric Biggers default: 823f2bb770aSEric Biggers /* Fully random bytes */ 824f2bb770aSEric Biggers for (i = 0; i < count; i++) 825f2bb770aSEric Biggers buf[i] = (u8)prandom_u32(); 826f2bb770aSEric Biggers } 827f2bb770aSEric Biggers } 828f2bb770aSEric Biggers 82925f9dddbSEric Biggers static char *generate_random_sgl_divisions(struct test_sg_division *divs, 83025f9dddbSEric Biggers size_t max_divs, char *p, char *end, 8316570737cSEric Biggers bool gen_flushes, u32 req_flags) 83225f9dddbSEric Biggers { 83325f9dddbSEric Biggers struct test_sg_division *div = divs; 83425f9dddbSEric Biggers unsigned int remaining = TEST_SG_TOTAL; 83525f9dddbSEric Biggers 83625f9dddbSEric Biggers do { 83725f9dddbSEric Biggers unsigned int this_len; 8386570737cSEric Biggers const char *flushtype_str; 83925f9dddbSEric Biggers 84025f9dddbSEric Biggers if (div == &divs[max_divs - 1] || prandom_u32() % 2 == 0) 84125f9dddbSEric Biggers this_len = remaining; 84225f9dddbSEric Biggers else 84325f9dddbSEric Biggers this_len = 1 + (prandom_u32() % remaining); 84425f9dddbSEric Biggers div->proportion_of_total = this_len; 84525f9dddbSEric Biggers 84625f9dddbSEric Biggers if (prandom_u32() % 4 == 0) 84725f9dddbSEric Biggers div->offset = (PAGE_SIZE - 128) + (prandom_u32() % 128); 84825f9dddbSEric Biggers else if (prandom_u32() % 2 == 0) 84925f9dddbSEric Biggers div->offset = prandom_u32() % 32; 85025f9dddbSEric Biggers else 85125f9dddbSEric Biggers div->offset = prandom_u32() % PAGE_SIZE; 85225f9dddbSEric Biggers if (prandom_u32() % 8 == 0) 85325f9dddbSEric Biggers div->offset_relative_to_alignmask = true; 85425f9dddbSEric Biggers 85525f9dddbSEric Biggers div->flush_type = FLUSH_TYPE_NONE; 85625f9dddbSEric Biggers if (gen_flushes) { 85725f9dddbSEric Biggers switch (prandom_u32() % 4) { 85825f9dddbSEric Biggers case 0: 85925f9dddbSEric Biggers div->flush_type = FLUSH_TYPE_REIMPORT; 86025f9dddbSEric Biggers break; 86125f9dddbSEric Biggers case 1: 86225f9dddbSEric Biggers div->flush_type = FLUSH_TYPE_FLUSH; 86325f9dddbSEric Biggers break; 86425f9dddbSEric Biggers } 86525f9dddbSEric Biggers } 86625f9dddbSEric Biggers 8676570737cSEric Biggers if (div->flush_type != FLUSH_TYPE_NONE && 8686570737cSEric Biggers !(req_flags & CRYPTO_TFM_REQ_MAY_SLEEP) && 8696570737cSEric Biggers prandom_u32() % 2 == 0) 8706570737cSEric Biggers div->nosimd = true; 8716570737cSEric Biggers 8726570737cSEric Biggers switch (div->flush_type) { 8736570737cSEric Biggers case FLUSH_TYPE_FLUSH: 8746570737cSEric Biggers if (div->nosimd) 8756570737cSEric Biggers flushtype_str = "<flush,nosimd>"; 8766570737cSEric Biggers else 8776570737cSEric Biggers flushtype_str = "<flush>"; 8786570737cSEric Biggers break; 8796570737cSEric Biggers case FLUSH_TYPE_REIMPORT: 8806570737cSEric Biggers if (div->nosimd) 8816570737cSEric Biggers flushtype_str = "<reimport,nosimd>"; 8826570737cSEric Biggers else 8836570737cSEric Biggers flushtype_str = "<reimport>"; 8846570737cSEric Biggers break; 8856570737cSEric Biggers default: 8866570737cSEric Biggers flushtype_str = ""; 8876570737cSEric Biggers break; 8886570737cSEric Biggers } 8896570737cSEric Biggers 89025f9dddbSEric Biggers BUILD_BUG_ON(TEST_SG_TOTAL != 10000); /* for "%u.%u%%" */ 8916570737cSEric Biggers p += scnprintf(p, end - p, "%s%u.%u%%@%s+%u%s", flushtype_str, 89225f9dddbSEric Biggers this_len / 100, this_len % 100, 89325f9dddbSEric Biggers div->offset_relative_to_alignmask ? 89425f9dddbSEric Biggers "alignmask" : "", 89525f9dddbSEric Biggers div->offset, this_len == remaining ? "" : ", "); 89625f9dddbSEric Biggers remaining -= this_len; 89725f9dddbSEric Biggers div++; 89825f9dddbSEric Biggers } while (remaining); 89925f9dddbSEric Biggers 90025f9dddbSEric Biggers return p; 90125f9dddbSEric Biggers } 90225f9dddbSEric Biggers 90325f9dddbSEric Biggers /* Generate a random testvec_config for fuzz testing */ 90425f9dddbSEric Biggers static void generate_random_testvec_config(struct testvec_config *cfg, 90525f9dddbSEric Biggers char *name, size_t max_namelen) 90625f9dddbSEric Biggers { 90725f9dddbSEric Biggers char *p = name; 90825f9dddbSEric Biggers char * const end = name + max_namelen; 90925f9dddbSEric Biggers 91025f9dddbSEric Biggers memset(cfg, 0, sizeof(*cfg)); 91125f9dddbSEric Biggers 91225f9dddbSEric Biggers cfg->name = name; 91325f9dddbSEric Biggers 91425f9dddbSEric Biggers p += scnprintf(p, end - p, "random:"); 91525f9dddbSEric Biggers 91625f9dddbSEric Biggers if (prandom_u32() % 2 == 0) { 91725f9dddbSEric Biggers cfg->inplace = true; 91825f9dddbSEric Biggers p += scnprintf(p, end - p, " inplace"); 91925f9dddbSEric Biggers } 92025f9dddbSEric Biggers 92125f9dddbSEric Biggers if (prandom_u32() % 2 == 0) { 92225f9dddbSEric Biggers cfg->req_flags |= CRYPTO_TFM_REQ_MAY_SLEEP; 92325f9dddbSEric Biggers p += scnprintf(p, end - p, " may_sleep"); 92425f9dddbSEric Biggers } 92525f9dddbSEric Biggers 92625f9dddbSEric Biggers switch (prandom_u32() % 4) { 92725f9dddbSEric Biggers case 0: 92825f9dddbSEric Biggers cfg->finalization_type = FINALIZATION_TYPE_FINAL; 92925f9dddbSEric Biggers p += scnprintf(p, end - p, " use_final"); 93025f9dddbSEric Biggers break; 93125f9dddbSEric Biggers case 1: 93225f9dddbSEric Biggers cfg->finalization_type = FINALIZATION_TYPE_FINUP; 93325f9dddbSEric Biggers p += scnprintf(p, end - p, " use_finup"); 93425f9dddbSEric Biggers break; 93525f9dddbSEric Biggers default: 93625f9dddbSEric Biggers cfg->finalization_type = FINALIZATION_TYPE_DIGEST; 93725f9dddbSEric Biggers p += scnprintf(p, end - p, " use_digest"); 93825f9dddbSEric Biggers break; 93925f9dddbSEric Biggers } 94025f9dddbSEric Biggers 9416570737cSEric Biggers if (!(cfg->req_flags & CRYPTO_TFM_REQ_MAY_SLEEP) && 9426570737cSEric Biggers prandom_u32() % 2 == 0) { 9436570737cSEric Biggers cfg->nosimd = true; 9446570737cSEric Biggers p += scnprintf(p, end - p, " nosimd"); 9456570737cSEric Biggers } 9466570737cSEric Biggers 94725f9dddbSEric Biggers p += scnprintf(p, end - p, " src_divs=["); 94825f9dddbSEric Biggers p = generate_random_sgl_divisions(cfg->src_divs, 94925f9dddbSEric Biggers ARRAY_SIZE(cfg->src_divs), p, end, 95025f9dddbSEric Biggers (cfg->finalization_type != 9516570737cSEric Biggers FINALIZATION_TYPE_DIGEST), 9526570737cSEric Biggers cfg->req_flags); 95325f9dddbSEric Biggers p += scnprintf(p, end - p, "]"); 95425f9dddbSEric Biggers 95525f9dddbSEric Biggers if (!cfg->inplace && prandom_u32() % 2 == 0) { 95625f9dddbSEric Biggers p += scnprintf(p, end - p, " dst_divs=["); 95725f9dddbSEric Biggers p = generate_random_sgl_divisions(cfg->dst_divs, 95825f9dddbSEric Biggers ARRAY_SIZE(cfg->dst_divs), 9596570737cSEric Biggers p, end, false, 9606570737cSEric Biggers cfg->req_flags); 96125f9dddbSEric Biggers p += scnprintf(p, end - p, "]"); 96225f9dddbSEric Biggers } 96325f9dddbSEric Biggers 96425f9dddbSEric Biggers if (prandom_u32() % 2 == 0) { 96525f9dddbSEric Biggers cfg->iv_offset = 1 + (prandom_u32() % MAX_ALGAPI_ALIGNMASK); 96625f9dddbSEric Biggers p += scnprintf(p, end - p, " iv_offset=%u", cfg->iv_offset); 96725f9dddbSEric Biggers } 96825f9dddbSEric Biggers 96925f9dddbSEric Biggers WARN_ON_ONCE(!valid_testvec_config(cfg)); 97025f9dddbSEric Biggers } 971b55e1a39SEric Biggers 972b55e1a39SEric Biggers static void crypto_disable_simd_for_test(void) 973b55e1a39SEric Biggers { 974b55e1a39SEric Biggers preempt_disable(); 975b55e1a39SEric Biggers __this_cpu_write(crypto_simd_disabled_for_test, true); 976b55e1a39SEric Biggers } 977b55e1a39SEric Biggers 978b55e1a39SEric Biggers static void crypto_reenable_simd_for_test(void) 979b55e1a39SEric Biggers { 980b55e1a39SEric Biggers __this_cpu_write(crypto_simd_disabled_for_test, false); 981b55e1a39SEric Biggers preempt_enable(); 982b55e1a39SEric Biggers } 983f2bb770aSEric Biggers 984f2bb770aSEric Biggers /* 985f2bb770aSEric Biggers * Given an algorithm name, build the name of the generic implementation of that 986f2bb770aSEric Biggers * algorithm, assuming the usual naming convention. Specifically, this appends 987f2bb770aSEric Biggers * "-generic" to every part of the name that is not a template name. Examples: 988f2bb770aSEric Biggers * 989f2bb770aSEric Biggers * aes => aes-generic 990f2bb770aSEric Biggers * cbc(aes) => cbc(aes-generic) 991f2bb770aSEric Biggers * cts(cbc(aes)) => cts(cbc(aes-generic)) 992f2bb770aSEric Biggers * rfc7539(chacha20,poly1305) => rfc7539(chacha20-generic,poly1305-generic) 993f2bb770aSEric Biggers * 994f2bb770aSEric Biggers * Return: 0 on success, or -ENAMETOOLONG if the generic name would be too long 995f2bb770aSEric Biggers */ 996f2bb770aSEric Biggers static int build_generic_driver_name(const char *algname, 997f2bb770aSEric Biggers char driver_name[CRYPTO_MAX_ALG_NAME]) 998f2bb770aSEric Biggers { 999f2bb770aSEric Biggers const char *in = algname; 1000f2bb770aSEric Biggers char *out = driver_name; 1001f2bb770aSEric Biggers size_t len = strlen(algname); 1002f2bb770aSEric Biggers 1003f2bb770aSEric Biggers if (len >= CRYPTO_MAX_ALG_NAME) 1004f2bb770aSEric Biggers goto too_long; 1005f2bb770aSEric Biggers do { 1006f2bb770aSEric Biggers const char *in_saved = in; 1007f2bb770aSEric Biggers 1008f2bb770aSEric Biggers while (*in && *in != '(' && *in != ')' && *in != ',') 1009f2bb770aSEric Biggers *out++ = *in++; 1010f2bb770aSEric Biggers if (*in != '(' && in > in_saved) { 1011f2bb770aSEric Biggers len += 8; 1012f2bb770aSEric Biggers if (len >= CRYPTO_MAX_ALG_NAME) 1013f2bb770aSEric Biggers goto too_long; 1014f2bb770aSEric Biggers memcpy(out, "-generic", 8); 1015f2bb770aSEric Biggers out += 8; 1016f2bb770aSEric Biggers } 1017f2bb770aSEric Biggers } while ((*out++ = *in++) != '\0'); 1018f2bb770aSEric Biggers return 0; 1019f2bb770aSEric Biggers 1020f2bb770aSEric Biggers too_long: 1021f2bb770aSEric Biggers pr_err("alg: generic driver name for \"%s\" would be too long\n", 1022f2bb770aSEric Biggers algname); 1023f2bb770aSEric Biggers return -ENAMETOOLONG; 1024f2bb770aSEric Biggers } 1025b55e1a39SEric Biggers #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 1026b55e1a39SEric Biggers static void crypto_disable_simd_for_test(void) 1027b55e1a39SEric Biggers { 1028b55e1a39SEric Biggers } 1029b55e1a39SEric Biggers 1030b55e1a39SEric Biggers static void crypto_reenable_simd_for_test(void) 1031b55e1a39SEric Biggers { 1032b55e1a39SEric Biggers } 1033b55e1a39SEric Biggers #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 103425f9dddbSEric Biggers 1035d8ea98aaSEric Biggers static int build_hash_sglist(struct test_sglist *tsgl, 1036d8ea98aaSEric Biggers const struct hash_testvec *vec, 1037d8ea98aaSEric Biggers const struct testvec_config *cfg, 1038d8ea98aaSEric Biggers unsigned int alignmask, 1039d8ea98aaSEric Biggers const struct test_sg_division *divs[XBUFSIZE]) 1040d8ea98aaSEric Biggers { 1041d8ea98aaSEric Biggers struct kvec kv; 1042d8ea98aaSEric Biggers struct iov_iter input; 1043d8ea98aaSEric Biggers 1044d8ea98aaSEric Biggers kv.iov_base = (void *)vec->plaintext; 1045d8ea98aaSEric Biggers kv.iov_len = vec->psize; 1046d8ea98aaSEric Biggers iov_iter_kvec(&input, WRITE, &kv, 1, vec->psize); 1047d8ea98aaSEric Biggers return build_test_sglist(tsgl, cfg->src_divs, alignmask, vec->psize, 1048d8ea98aaSEric Biggers &input, divs); 1049d8ea98aaSEric Biggers } 1050d8ea98aaSEric Biggers 1051d8ea98aaSEric Biggers static int check_hash_result(const char *type, 1052d8ea98aaSEric Biggers const u8 *result, unsigned int digestsize, 1053d8ea98aaSEric Biggers const struct hash_testvec *vec, 1054d8ea98aaSEric Biggers const char *vec_name, 1055d8ea98aaSEric Biggers const char *driver, 1056d8ea98aaSEric Biggers const struct testvec_config *cfg) 1057d8ea98aaSEric Biggers { 1058d8ea98aaSEric Biggers if (memcmp(result, vec->digest, digestsize) != 0) { 1059d8ea98aaSEric Biggers pr_err("alg: %s: %s test failed (wrong result) on test vector %s, cfg=\"%s\"\n", 1060d8ea98aaSEric Biggers type, driver, vec_name, cfg->name); 1061d8ea98aaSEric Biggers return -EINVAL; 1062d8ea98aaSEric Biggers } 1063d8ea98aaSEric Biggers if (!testmgr_is_poison(&result[digestsize], TESTMGR_POISON_LEN)) { 1064d8ea98aaSEric Biggers pr_err("alg: %s: %s overran result buffer on test vector %s, cfg=\"%s\"\n", 1065d8ea98aaSEric Biggers type, driver, vec_name, cfg->name); 1066d8ea98aaSEric Biggers return -EOVERFLOW; 1067d8ea98aaSEric Biggers } 1068d8ea98aaSEric Biggers return 0; 1069d8ea98aaSEric Biggers } 1070d8ea98aaSEric Biggers 1071d8ea98aaSEric Biggers static inline int check_shash_op(const char *op, int err, 1072d8ea98aaSEric Biggers const char *driver, const char *vec_name, 1073d8ea98aaSEric Biggers const struct testvec_config *cfg) 1074d8ea98aaSEric Biggers { 1075d8ea98aaSEric Biggers if (err) 1076d8ea98aaSEric Biggers pr_err("alg: shash: %s %s() failed with err %d on test vector %s, cfg=\"%s\"\n", 1077d8ea98aaSEric Biggers driver, op, err, vec_name, cfg->name); 1078d8ea98aaSEric Biggers return err; 1079d8ea98aaSEric Biggers } 1080d8ea98aaSEric Biggers 1081d8ea98aaSEric Biggers static inline const void *sg_data(struct scatterlist *sg) 1082d8ea98aaSEric Biggers { 1083d8ea98aaSEric Biggers return page_address(sg_page(sg)) + sg->offset; 1084d8ea98aaSEric Biggers } 1085d8ea98aaSEric Biggers 1086d8ea98aaSEric Biggers /* Test one hash test vector in one configuration, using the shash API */ 1087d8ea98aaSEric Biggers static int test_shash_vec_cfg(const char *driver, 1088d8ea98aaSEric Biggers const struct hash_testvec *vec, 1089d8ea98aaSEric Biggers const char *vec_name, 1090d8ea98aaSEric Biggers const struct testvec_config *cfg, 1091d8ea98aaSEric Biggers struct shash_desc *desc, 1092d8ea98aaSEric Biggers struct test_sglist *tsgl, 1093d8ea98aaSEric Biggers u8 *hashstate) 1094d8ea98aaSEric Biggers { 1095d8ea98aaSEric Biggers struct crypto_shash *tfm = desc->tfm; 1096d8ea98aaSEric Biggers const unsigned int alignmask = crypto_shash_alignmask(tfm); 1097d8ea98aaSEric Biggers const unsigned int digestsize = crypto_shash_digestsize(tfm); 1098d8ea98aaSEric Biggers const unsigned int statesize = crypto_shash_statesize(tfm); 1099d8ea98aaSEric Biggers const struct test_sg_division *divs[XBUFSIZE]; 1100d8ea98aaSEric Biggers unsigned int i; 1101d8ea98aaSEric Biggers u8 result[HASH_MAX_DIGESTSIZE + TESTMGR_POISON_LEN]; 1102d8ea98aaSEric Biggers int err; 1103d8ea98aaSEric Biggers 1104d8ea98aaSEric Biggers /* Set the key, if specified */ 1105d8ea98aaSEric Biggers if (vec->ksize) { 1106d8ea98aaSEric Biggers err = crypto_shash_setkey(tfm, vec->key, vec->ksize); 1107d8ea98aaSEric Biggers if (err) { 1108d8ea98aaSEric Biggers if (err == vec->setkey_error) 1109d8ea98aaSEric Biggers return 0; 1110d8ea98aaSEric Biggers pr_err("alg: shash: %s setkey failed on test vector %s; expected_error=%d, actual_error=%d, flags=%#x\n", 1111d8ea98aaSEric Biggers driver, vec_name, vec->setkey_error, err, 1112d8ea98aaSEric Biggers crypto_shash_get_flags(tfm)); 1113d8ea98aaSEric Biggers return err; 1114d8ea98aaSEric Biggers } 1115d8ea98aaSEric Biggers if (vec->setkey_error) { 1116d8ea98aaSEric Biggers pr_err("alg: shash: %s setkey unexpectedly succeeded on test vector %s; expected_error=%d\n", 1117d8ea98aaSEric Biggers driver, vec_name, vec->setkey_error); 1118d8ea98aaSEric Biggers return -EINVAL; 1119d8ea98aaSEric Biggers } 1120d8ea98aaSEric Biggers } 1121d8ea98aaSEric Biggers 1122d8ea98aaSEric Biggers /* Build the scatterlist for the source data */ 1123d8ea98aaSEric Biggers err = build_hash_sglist(tsgl, vec, cfg, alignmask, divs); 1124d8ea98aaSEric Biggers if (err) { 1125d8ea98aaSEric Biggers pr_err("alg: shash: %s: error preparing scatterlist for test vector %s, cfg=\"%s\"\n", 1126d8ea98aaSEric Biggers driver, vec_name, cfg->name); 1127d8ea98aaSEric Biggers return err; 1128d8ea98aaSEric Biggers } 1129d8ea98aaSEric Biggers 1130d8ea98aaSEric Biggers /* Do the actual hashing */ 1131d8ea98aaSEric Biggers 1132d8ea98aaSEric Biggers testmgr_poison(desc->__ctx, crypto_shash_descsize(tfm)); 1133d8ea98aaSEric Biggers testmgr_poison(result, digestsize + TESTMGR_POISON_LEN); 1134d8ea98aaSEric Biggers 1135d8ea98aaSEric Biggers if (cfg->finalization_type == FINALIZATION_TYPE_DIGEST || 1136d8ea98aaSEric Biggers vec->digest_error) { 1137d8ea98aaSEric Biggers /* Just using digest() */ 1138d8ea98aaSEric Biggers if (tsgl->nents != 1) 1139d8ea98aaSEric Biggers return 0; 1140d8ea98aaSEric Biggers if (cfg->nosimd) 1141d8ea98aaSEric Biggers crypto_disable_simd_for_test(); 1142d8ea98aaSEric Biggers err = crypto_shash_digest(desc, sg_data(&tsgl->sgl[0]), 1143d8ea98aaSEric Biggers tsgl->sgl[0].length, result); 1144d8ea98aaSEric Biggers if (cfg->nosimd) 1145d8ea98aaSEric Biggers crypto_reenable_simd_for_test(); 1146d8ea98aaSEric Biggers if (err) { 1147d8ea98aaSEric Biggers if (err == vec->digest_error) 1148d8ea98aaSEric Biggers return 0; 1149d8ea98aaSEric Biggers pr_err("alg: shash: %s digest() failed on test vector %s; expected_error=%d, actual_error=%d, cfg=\"%s\"\n", 1150d8ea98aaSEric Biggers driver, vec_name, vec->digest_error, err, 1151d8ea98aaSEric Biggers cfg->name); 1152d8ea98aaSEric Biggers return err; 1153d8ea98aaSEric Biggers } 1154d8ea98aaSEric Biggers if (vec->digest_error) { 1155d8ea98aaSEric Biggers pr_err("alg: shash: %s digest() unexpectedly succeeded on test vector %s; expected_error=%d, cfg=\"%s\"\n", 1156d8ea98aaSEric Biggers driver, vec_name, vec->digest_error, cfg->name); 1157d8ea98aaSEric Biggers return -EINVAL; 1158d8ea98aaSEric Biggers } 1159d8ea98aaSEric Biggers goto result_ready; 1160d8ea98aaSEric Biggers } 1161d8ea98aaSEric Biggers 1162d8ea98aaSEric Biggers /* Using init(), zero or more update(), then final() or finup() */ 1163d8ea98aaSEric Biggers 1164d8ea98aaSEric Biggers if (cfg->nosimd) 1165d8ea98aaSEric Biggers crypto_disable_simd_for_test(); 1166d8ea98aaSEric Biggers err = crypto_shash_init(desc); 1167d8ea98aaSEric Biggers if (cfg->nosimd) 1168d8ea98aaSEric Biggers crypto_reenable_simd_for_test(); 1169d8ea98aaSEric Biggers err = check_shash_op("init", err, driver, vec_name, cfg); 1170d8ea98aaSEric Biggers if (err) 1171d8ea98aaSEric Biggers return err; 1172d8ea98aaSEric Biggers 1173d8ea98aaSEric Biggers for (i = 0; i < tsgl->nents; i++) { 1174d8ea98aaSEric Biggers if (i + 1 == tsgl->nents && 1175d8ea98aaSEric Biggers cfg->finalization_type == FINALIZATION_TYPE_FINUP) { 1176d8ea98aaSEric Biggers if (divs[i]->nosimd) 1177d8ea98aaSEric Biggers crypto_disable_simd_for_test(); 1178d8ea98aaSEric Biggers err = crypto_shash_finup(desc, sg_data(&tsgl->sgl[i]), 1179d8ea98aaSEric Biggers tsgl->sgl[i].length, result); 1180d8ea98aaSEric Biggers if (divs[i]->nosimd) 1181d8ea98aaSEric Biggers crypto_reenable_simd_for_test(); 1182d8ea98aaSEric Biggers err = check_shash_op("finup", err, driver, vec_name, 1183d8ea98aaSEric Biggers cfg); 1184d8ea98aaSEric Biggers if (err) 1185d8ea98aaSEric Biggers return err; 1186d8ea98aaSEric Biggers goto result_ready; 1187d8ea98aaSEric Biggers } 1188d8ea98aaSEric Biggers if (divs[i]->nosimd) 1189d8ea98aaSEric Biggers crypto_disable_simd_for_test(); 1190d8ea98aaSEric Biggers err = crypto_shash_update(desc, sg_data(&tsgl->sgl[i]), 1191d8ea98aaSEric Biggers tsgl->sgl[i].length); 1192d8ea98aaSEric Biggers if (divs[i]->nosimd) 1193d8ea98aaSEric Biggers crypto_reenable_simd_for_test(); 1194d8ea98aaSEric Biggers err = check_shash_op("update", err, driver, vec_name, cfg); 1195d8ea98aaSEric Biggers if (err) 1196d8ea98aaSEric Biggers return err; 1197d8ea98aaSEric Biggers if (divs[i]->flush_type == FLUSH_TYPE_REIMPORT) { 1198d8ea98aaSEric Biggers /* Test ->export() and ->import() */ 1199d8ea98aaSEric Biggers testmgr_poison(hashstate + statesize, 1200d8ea98aaSEric Biggers TESTMGR_POISON_LEN); 1201d8ea98aaSEric Biggers err = crypto_shash_export(desc, hashstate); 1202d8ea98aaSEric Biggers err = check_shash_op("export", err, driver, vec_name, 1203d8ea98aaSEric Biggers cfg); 1204d8ea98aaSEric Biggers if (err) 1205d8ea98aaSEric Biggers return err; 1206d8ea98aaSEric Biggers if (!testmgr_is_poison(hashstate + statesize, 1207d8ea98aaSEric Biggers TESTMGR_POISON_LEN)) { 1208d8ea98aaSEric Biggers pr_err("alg: shash: %s export() overran state buffer on test vector %s, cfg=\"%s\"\n", 1209d8ea98aaSEric Biggers driver, vec_name, cfg->name); 1210d8ea98aaSEric Biggers return -EOVERFLOW; 1211d8ea98aaSEric Biggers } 1212d8ea98aaSEric Biggers testmgr_poison(desc->__ctx, crypto_shash_descsize(tfm)); 1213d8ea98aaSEric Biggers err = crypto_shash_import(desc, hashstate); 1214d8ea98aaSEric Biggers err = check_shash_op("import", err, driver, vec_name, 1215d8ea98aaSEric Biggers cfg); 1216d8ea98aaSEric Biggers if (err) 1217d8ea98aaSEric Biggers return err; 1218d8ea98aaSEric Biggers } 1219d8ea98aaSEric Biggers } 1220d8ea98aaSEric Biggers 1221d8ea98aaSEric Biggers if (cfg->nosimd) 1222d8ea98aaSEric Biggers crypto_disable_simd_for_test(); 1223d8ea98aaSEric Biggers err = crypto_shash_final(desc, result); 1224d8ea98aaSEric Biggers if (cfg->nosimd) 1225d8ea98aaSEric Biggers crypto_reenable_simd_for_test(); 1226d8ea98aaSEric Biggers err = check_shash_op("final", err, driver, vec_name, cfg); 1227d8ea98aaSEric Biggers if (err) 1228d8ea98aaSEric Biggers return err; 1229d8ea98aaSEric Biggers result_ready: 1230d8ea98aaSEric Biggers return check_hash_result("shash", result, digestsize, vec, vec_name, 1231d8ea98aaSEric Biggers driver, cfg); 1232d8ea98aaSEric Biggers } 1233d8ea98aaSEric Biggers 12346570737cSEric Biggers static int do_ahash_op(int (*op)(struct ahash_request *req), 12356570737cSEric Biggers struct ahash_request *req, 12366570737cSEric Biggers struct crypto_wait *wait, bool nosimd) 12376570737cSEric Biggers { 12386570737cSEric Biggers int err; 12396570737cSEric Biggers 12406570737cSEric Biggers if (nosimd) 12416570737cSEric Biggers crypto_disable_simd_for_test(); 12426570737cSEric Biggers 12436570737cSEric Biggers err = op(req); 12446570737cSEric Biggers 12456570737cSEric Biggers if (nosimd) 12466570737cSEric Biggers crypto_reenable_simd_for_test(); 12476570737cSEric Biggers 12486570737cSEric Biggers return crypto_wait_req(err, wait); 12496570737cSEric Biggers } 12506570737cSEric Biggers 1251d8ea98aaSEric Biggers static int check_nonfinal_ahash_op(const char *op, int err, 12524cc2dcf9SEric Biggers u8 *result, unsigned int digestsize, 1253951d1332SEric Biggers const char *driver, const char *vec_name, 12544cc2dcf9SEric Biggers const struct testvec_config *cfg) 1255466d7b9fSKamil Konieczny { 12564cc2dcf9SEric Biggers if (err) { 1257d8ea98aaSEric Biggers pr_err("alg: ahash: %s %s() failed with err %d on test vector %s, cfg=\"%s\"\n", 1258951d1332SEric Biggers driver, op, err, vec_name, cfg->name); 12594cc2dcf9SEric Biggers return err; 12604cc2dcf9SEric Biggers } 12614cc2dcf9SEric Biggers if (!testmgr_is_poison(result, digestsize)) { 1262d8ea98aaSEric Biggers pr_err("alg: ahash: %s %s() used result buffer on test vector %s, cfg=\"%s\"\n", 1263951d1332SEric Biggers driver, op, vec_name, cfg->name); 1264466d7b9fSKamil Konieczny return -EINVAL; 1265466d7b9fSKamil Konieczny } 1266466d7b9fSKamil Konieczny return 0; 1267466d7b9fSKamil Konieczny } 1268466d7b9fSKamil Konieczny 1269d8ea98aaSEric Biggers /* Test one hash test vector in one configuration, using the ahash API */ 1270d8ea98aaSEric Biggers static int test_ahash_vec_cfg(const char *driver, 12714cc2dcf9SEric Biggers const struct hash_testvec *vec, 1272951d1332SEric Biggers const char *vec_name, 12734cc2dcf9SEric Biggers const struct testvec_config *cfg, 12744cc2dcf9SEric Biggers struct ahash_request *req, 12754cc2dcf9SEric Biggers struct test_sglist *tsgl, 12764cc2dcf9SEric Biggers u8 *hashstate) 1277018ba95cSWang, Rui Y { 12784cc2dcf9SEric Biggers struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 12794cc2dcf9SEric Biggers const unsigned int alignmask = crypto_ahash_alignmask(tfm); 12804cc2dcf9SEric Biggers const unsigned int digestsize = crypto_ahash_digestsize(tfm); 12814cc2dcf9SEric Biggers const unsigned int statesize = crypto_ahash_statesize(tfm); 12824cc2dcf9SEric Biggers const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags; 12834cc2dcf9SEric Biggers const struct test_sg_division *divs[XBUFSIZE]; 12844cc2dcf9SEric Biggers DECLARE_CRYPTO_WAIT(wait); 12854cc2dcf9SEric Biggers unsigned int i; 12864cc2dcf9SEric Biggers struct scatterlist *pending_sgl; 12874cc2dcf9SEric Biggers unsigned int pending_len; 12884cc2dcf9SEric Biggers u8 result[HASH_MAX_DIGESTSIZE + TESTMGR_POISON_LEN]; 12894cc2dcf9SEric Biggers int err; 1290018ba95cSWang, Rui Y 12914cc2dcf9SEric Biggers /* Set the key, if specified */ 12924cc2dcf9SEric Biggers if (vec->ksize) { 12934cc2dcf9SEric Biggers err = crypto_ahash_setkey(tfm, vec->key, vec->ksize); 12944cc2dcf9SEric Biggers if (err) { 12955283a8eeSEric Biggers if (err == vec->setkey_error) 12965283a8eeSEric Biggers return 0; 1297d8ea98aaSEric Biggers pr_err("alg: ahash: %s setkey failed on test vector %s; expected_error=%d, actual_error=%d, flags=%#x\n", 1298951d1332SEric Biggers driver, vec_name, vec->setkey_error, err, 12994cc2dcf9SEric Biggers crypto_ahash_get_flags(tfm)); 13004cc2dcf9SEric Biggers return err; 1301da7f033dSHerbert Xu } 13025283a8eeSEric Biggers if (vec->setkey_error) { 1303d8ea98aaSEric Biggers pr_err("alg: ahash: %s setkey unexpectedly succeeded on test vector %s; expected_error=%d\n", 1304951d1332SEric Biggers driver, vec_name, vec->setkey_error); 13055283a8eeSEric Biggers return -EINVAL; 13065283a8eeSEric Biggers } 1307da7f033dSHerbert Xu } 1308da7f033dSHerbert Xu 13094cc2dcf9SEric Biggers /* Build the scatterlist for the source data */ 1310d8ea98aaSEric Biggers err = build_hash_sglist(tsgl, vec, cfg, alignmask, divs); 13114cc2dcf9SEric Biggers if (err) { 1312d8ea98aaSEric Biggers pr_err("alg: ahash: %s: error preparing scatterlist for test vector %s, cfg=\"%s\"\n", 1313951d1332SEric Biggers driver, vec_name, cfg->name); 13144cc2dcf9SEric Biggers return err; 1315a8f1a052SDavid S. Miller } 1316da7f033dSHerbert Xu 13174cc2dcf9SEric Biggers /* Do the actual hashing */ 1318da7f033dSHerbert Xu 13194cc2dcf9SEric Biggers testmgr_poison(req->__ctx, crypto_ahash_reqsize(tfm)); 13204cc2dcf9SEric Biggers testmgr_poison(result, digestsize + TESTMGR_POISON_LEN); 132176715095SGilad Ben-Yossef 13225283a8eeSEric Biggers if (cfg->finalization_type == FINALIZATION_TYPE_DIGEST || 13235283a8eeSEric Biggers vec->digest_error) { 13244cc2dcf9SEric Biggers /* Just using digest() */ 13254cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, crypto_req_done, 13267f397136SGilad Ben-Yossef &wait); 13274cc2dcf9SEric Biggers ahash_request_set_crypt(req, tsgl->sgl, result, vec->psize); 13286570737cSEric Biggers err = do_ahash_op(crypto_ahash_digest, req, &wait, cfg->nosimd); 13294cc2dcf9SEric Biggers if (err) { 13305283a8eeSEric Biggers if (err == vec->digest_error) 13315283a8eeSEric Biggers return 0; 1332d8ea98aaSEric Biggers pr_err("alg: ahash: %s digest() failed on test vector %s; expected_error=%d, actual_error=%d, cfg=\"%s\"\n", 1333951d1332SEric Biggers driver, vec_name, vec->digest_error, err, 13345283a8eeSEric Biggers cfg->name); 13354cc2dcf9SEric Biggers return err; 1336018ba95cSWang, Rui Y } 13375283a8eeSEric Biggers if (vec->digest_error) { 1338d8ea98aaSEric Biggers pr_err("alg: ahash: %s digest() unexpectedly succeeded on test vector %s; expected_error=%d, cfg=\"%s\"\n", 1339951d1332SEric Biggers driver, vec_name, vec->digest_error, cfg->name); 13405283a8eeSEric Biggers return -EINVAL; 13415283a8eeSEric Biggers } 13424cc2dcf9SEric Biggers goto result_ready; 1343018ba95cSWang, Rui Y } 13444cc2dcf9SEric Biggers 13454cc2dcf9SEric Biggers /* Using init(), zero or more update(), then final() or finup() */ 13464cc2dcf9SEric Biggers 13474cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, crypto_req_done, &wait); 13484cc2dcf9SEric Biggers ahash_request_set_crypt(req, NULL, result, 0); 13496570737cSEric Biggers err = do_ahash_op(crypto_ahash_init, req, &wait, cfg->nosimd); 1350d8ea98aaSEric Biggers err = check_nonfinal_ahash_op("init", err, result, digestsize, 1351951d1332SEric Biggers driver, vec_name, cfg); 13524cc2dcf9SEric Biggers if (err) 13534cc2dcf9SEric Biggers return err; 13544cc2dcf9SEric Biggers 13554cc2dcf9SEric Biggers pending_sgl = NULL; 13564cc2dcf9SEric Biggers pending_len = 0; 13574cc2dcf9SEric Biggers for (i = 0; i < tsgl->nents; i++) { 13584cc2dcf9SEric Biggers if (divs[i]->flush_type != FLUSH_TYPE_NONE && 13594cc2dcf9SEric Biggers pending_sgl != NULL) { 13604cc2dcf9SEric Biggers /* update() with the pending data */ 13614cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, 13624cc2dcf9SEric Biggers crypto_req_done, &wait); 13634cc2dcf9SEric Biggers ahash_request_set_crypt(req, pending_sgl, result, 13644cc2dcf9SEric Biggers pending_len); 13656570737cSEric Biggers err = do_ahash_op(crypto_ahash_update, req, &wait, 13666570737cSEric Biggers divs[i]->nosimd); 1367d8ea98aaSEric Biggers err = check_nonfinal_ahash_op("update", err, 13684cc2dcf9SEric Biggers result, digestsize, 1369951d1332SEric Biggers driver, vec_name, cfg); 13704cc2dcf9SEric Biggers if (err) 13714cc2dcf9SEric Biggers return err; 13724cc2dcf9SEric Biggers pending_sgl = NULL; 13734cc2dcf9SEric Biggers pending_len = 0; 1374018ba95cSWang, Rui Y } 13754cc2dcf9SEric Biggers if (divs[i]->flush_type == FLUSH_TYPE_REIMPORT) { 13764cc2dcf9SEric Biggers /* Test ->export() and ->import() */ 13774cc2dcf9SEric Biggers testmgr_poison(hashstate + statesize, 13784cc2dcf9SEric Biggers TESTMGR_POISON_LEN); 13794cc2dcf9SEric Biggers err = crypto_ahash_export(req, hashstate); 1380d8ea98aaSEric Biggers err = check_nonfinal_ahash_op("export", err, 13814cc2dcf9SEric Biggers result, digestsize, 1382951d1332SEric Biggers driver, vec_name, cfg); 13834cc2dcf9SEric Biggers if (err) 13844cc2dcf9SEric Biggers return err; 13854cc2dcf9SEric Biggers if (!testmgr_is_poison(hashstate + statesize, 13864cc2dcf9SEric Biggers TESTMGR_POISON_LEN)) { 1387d8ea98aaSEric Biggers pr_err("alg: ahash: %s export() overran state buffer on test vector %s, cfg=\"%s\"\n", 1388951d1332SEric Biggers driver, vec_name, cfg->name); 13894cc2dcf9SEric Biggers return -EOVERFLOW; 13904cc2dcf9SEric Biggers } 13914cc2dcf9SEric Biggers 13924cc2dcf9SEric Biggers testmgr_poison(req->__ctx, crypto_ahash_reqsize(tfm)); 13934cc2dcf9SEric Biggers err = crypto_ahash_import(req, hashstate); 1394d8ea98aaSEric Biggers err = check_nonfinal_ahash_op("import", err, 13954cc2dcf9SEric Biggers result, digestsize, 1396951d1332SEric Biggers driver, vec_name, cfg); 13974cc2dcf9SEric Biggers if (err) 13984cc2dcf9SEric Biggers return err; 13994cc2dcf9SEric Biggers } 14004cc2dcf9SEric Biggers if (pending_sgl == NULL) 14014cc2dcf9SEric Biggers pending_sgl = &tsgl->sgl[i]; 14024cc2dcf9SEric Biggers pending_len += tsgl->sgl[i].length; 14034cc2dcf9SEric Biggers } 14044cc2dcf9SEric Biggers 14054cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, crypto_req_done, &wait); 14064cc2dcf9SEric Biggers ahash_request_set_crypt(req, pending_sgl, result, pending_len); 14074cc2dcf9SEric Biggers if (cfg->finalization_type == FINALIZATION_TYPE_FINAL) { 14084cc2dcf9SEric Biggers /* finish with update() and final() */ 14096570737cSEric Biggers err = do_ahash_op(crypto_ahash_update, req, &wait, cfg->nosimd); 1410d8ea98aaSEric Biggers err = check_nonfinal_ahash_op("update", err, result, digestsize, 1411951d1332SEric Biggers driver, vec_name, cfg); 14124cc2dcf9SEric Biggers if (err) 14134cc2dcf9SEric Biggers return err; 14146570737cSEric Biggers err = do_ahash_op(crypto_ahash_final, req, &wait, cfg->nosimd); 14154cc2dcf9SEric Biggers if (err) { 1416d8ea98aaSEric Biggers pr_err("alg: ahash: %s final() failed with err %d on test vector %s, cfg=\"%s\"\n", 1417951d1332SEric Biggers driver, err, vec_name, cfg->name); 14184cc2dcf9SEric Biggers return err; 14194cc2dcf9SEric Biggers } 14204cc2dcf9SEric Biggers } else { 14214cc2dcf9SEric Biggers /* finish with finup() */ 14226570737cSEric Biggers err = do_ahash_op(crypto_ahash_finup, req, &wait, cfg->nosimd); 14234cc2dcf9SEric Biggers if (err) { 1424d8ea98aaSEric Biggers pr_err("alg: ahash: %s finup() failed with err %d on test vector %s, cfg=\"%s\"\n", 1425951d1332SEric Biggers driver, err, vec_name, cfg->name); 14264cc2dcf9SEric Biggers return err; 1427018ba95cSWang, Rui Y } 1428018ba95cSWang, Rui Y } 1429018ba95cSWang, Rui Y 14304cc2dcf9SEric Biggers result_ready: 1431d8ea98aaSEric Biggers return check_hash_result("ahash", result, digestsize, vec, vec_name, 1432d8ea98aaSEric Biggers driver, cfg); 1433da5ffe11SJussi Kivilinna } 1434da5ffe11SJussi Kivilinna 1435d8ea98aaSEric Biggers static int test_hash_vec_cfg(const char *driver, 1436d8ea98aaSEric Biggers const struct hash_testvec *vec, 1437d8ea98aaSEric Biggers const char *vec_name, 1438d8ea98aaSEric Biggers const struct testvec_config *cfg, 1439d8ea98aaSEric Biggers struct ahash_request *req, 1440d8ea98aaSEric Biggers struct shash_desc *desc, 1441d8ea98aaSEric Biggers struct test_sglist *tsgl, 1442d8ea98aaSEric Biggers u8 *hashstate) 1443d8ea98aaSEric Biggers { 1444d8ea98aaSEric Biggers int err; 1445d8ea98aaSEric Biggers 1446d8ea98aaSEric Biggers /* 1447d8ea98aaSEric Biggers * For algorithms implemented as "shash", most bugs will be detected by 1448d8ea98aaSEric Biggers * both the shash and ahash tests. Test the shash API first so that the 1449d8ea98aaSEric Biggers * failures involve less indirection, so are easier to debug. 1450d8ea98aaSEric Biggers */ 1451d8ea98aaSEric Biggers 1452d8ea98aaSEric Biggers if (desc) { 1453d8ea98aaSEric Biggers err = test_shash_vec_cfg(driver, vec, vec_name, cfg, desc, tsgl, 1454d8ea98aaSEric Biggers hashstate); 1455d8ea98aaSEric Biggers if (err) 1456d8ea98aaSEric Biggers return err; 1457d8ea98aaSEric Biggers } 1458d8ea98aaSEric Biggers 1459d8ea98aaSEric Biggers return test_ahash_vec_cfg(driver, vec, vec_name, cfg, req, tsgl, 1460d8ea98aaSEric Biggers hashstate); 1461da5ffe11SJussi Kivilinna } 1462da5ffe11SJussi Kivilinna 14634cc2dcf9SEric Biggers static int test_hash_vec(const char *driver, const struct hash_testvec *vec, 14644cc2dcf9SEric Biggers unsigned int vec_num, struct ahash_request *req, 1465d8ea98aaSEric Biggers struct shash_desc *desc, struct test_sglist *tsgl, 1466d8ea98aaSEric Biggers u8 *hashstate) 14674cc2dcf9SEric Biggers { 1468951d1332SEric Biggers char vec_name[16]; 14694cc2dcf9SEric Biggers unsigned int i; 14704cc2dcf9SEric Biggers int err; 14714cc2dcf9SEric Biggers 1472951d1332SEric Biggers sprintf(vec_name, "%u", vec_num); 1473951d1332SEric Biggers 14744cc2dcf9SEric Biggers for (i = 0; i < ARRAY_SIZE(default_hash_testvec_configs); i++) { 1475951d1332SEric Biggers err = test_hash_vec_cfg(driver, vec, vec_name, 14764cc2dcf9SEric Biggers &default_hash_testvec_configs[i], 1477d8ea98aaSEric Biggers req, desc, tsgl, hashstate); 14784cc2dcf9SEric Biggers if (err) 14794cc2dcf9SEric Biggers return err; 14804cc2dcf9SEric Biggers } 14814cc2dcf9SEric Biggers 14824cc2dcf9SEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 14834cc2dcf9SEric Biggers if (!noextratests) { 14844cc2dcf9SEric Biggers struct testvec_config cfg; 14854cc2dcf9SEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 14864cc2dcf9SEric Biggers 14874cc2dcf9SEric Biggers for (i = 0; i < fuzz_iterations; i++) { 14884cc2dcf9SEric Biggers generate_random_testvec_config(&cfg, cfgname, 14894cc2dcf9SEric Biggers sizeof(cfgname)); 1490951d1332SEric Biggers err = test_hash_vec_cfg(driver, vec, vec_name, &cfg, 1491d8ea98aaSEric Biggers req, desc, tsgl, hashstate); 14924cc2dcf9SEric Biggers if (err) 14934cc2dcf9SEric Biggers return err; 1494e63e1b0dSEric Biggers cond_resched(); 14954cc2dcf9SEric Biggers } 14964cc2dcf9SEric Biggers } 14974cc2dcf9SEric Biggers #endif 14984cc2dcf9SEric Biggers return 0; 14994cc2dcf9SEric Biggers } 15004cc2dcf9SEric Biggers 15019a8a6b3fSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 15029a8a6b3fSEric Biggers /* 15039a8a6b3fSEric Biggers * Generate a hash test vector from the given implementation. 15049a8a6b3fSEric Biggers * Assumes the buffers in 'vec' were already allocated. 15059a8a6b3fSEric Biggers */ 1506149c4e6eSArnd Bergmann static void generate_random_hash_testvec(struct shash_desc *desc, 15079a8a6b3fSEric Biggers struct hash_testvec *vec, 15089a8a6b3fSEric Biggers unsigned int maxkeysize, 15099a8a6b3fSEric Biggers unsigned int maxdatasize, 15109a8a6b3fSEric Biggers char *name, size_t max_namelen) 15119a8a6b3fSEric Biggers { 15129a8a6b3fSEric Biggers /* Data */ 15139a8a6b3fSEric Biggers vec->psize = generate_random_length(maxdatasize); 15149a8a6b3fSEric Biggers generate_random_bytes((u8 *)vec->plaintext, vec->psize); 15159a8a6b3fSEric Biggers 15169a8a6b3fSEric Biggers /* 15179a8a6b3fSEric Biggers * Key: length in range [1, maxkeysize], but usually choose maxkeysize. 15189a8a6b3fSEric Biggers * If algorithm is unkeyed, then maxkeysize == 0 and set ksize = 0. 15199a8a6b3fSEric Biggers */ 15209a8a6b3fSEric Biggers vec->setkey_error = 0; 15219a8a6b3fSEric Biggers vec->ksize = 0; 15229a8a6b3fSEric Biggers if (maxkeysize) { 15239a8a6b3fSEric Biggers vec->ksize = maxkeysize; 15249a8a6b3fSEric Biggers if (prandom_u32() % 4 == 0) 15259a8a6b3fSEric Biggers vec->ksize = 1 + (prandom_u32() % maxkeysize); 15269a8a6b3fSEric Biggers generate_random_bytes((u8 *)vec->key, vec->ksize); 15279a8a6b3fSEric Biggers 1528149c4e6eSArnd Bergmann vec->setkey_error = crypto_shash_setkey(desc->tfm, vec->key, 15299a8a6b3fSEric Biggers vec->ksize); 15309a8a6b3fSEric Biggers /* If the key couldn't be set, no need to continue to digest. */ 15319a8a6b3fSEric Biggers if (vec->setkey_error) 15329a8a6b3fSEric Biggers goto done; 15339a8a6b3fSEric Biggers } 15349a8a6b3fSEric Biggers 15359a8a6b3fSEric Biggers /* Digest */ 15369a8a6b3fSEric Biggers vec->digest_error = crypto_shash_digest(desc, vec->plaintext, 15379a8a6b3fSEric Biggers vec->psize, (u8 *)vec->digest); 15389a8a6b3fSEric Biggers done: 15399a8a6b3fSEric Biggers snprintf(name, max_namelen, "\"random: psize=%u ksize=%u\"", 15409a8a6b3fSEric Biggers vec->psize, vec->ksize); 15419a8a6b3fSEric Biggers } 15429a8a6b3fSEric Biggers 15439a8a6b3fSEric Biggers /* 15449a8a6b3fSEric Biggers * Test the hash algorithm represented by @req against the corresponding generic 15459a8a6b3fSEric Biggers * implementation, if one is available. 15469a8a6b3fSEric Biggers */ 15479a8a6b3fSEric Biggers static int test_hash_vs_generic_impl(const char *driver, 15489a8a6b3fSEric Biggers const char *generic_driver, 15499a8a6b3fSEric Biggers unsigned int maxkeysize, 15509a8a6b3fSEric Biggers struct ahash_request *req, 1551d8ea98aaSEric Biggers struct shash_desc *desc, 15529a8a6b3fSEric Biggers struct test_sglist *tsgl, 15539a8a6b3fSEric Biggers u8 *hashstate) 15549a8a6b3fSEric Biggers { 15559a8a6b3fSEric Biggers struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 15569a8a6b3fSEric Biggers const unsigned int digestsize = crypto_ahash_digestsize(tfm); 15579a8a6b3fSEric Biggers const unsigned int blocksize = crypto_ahash_blocksize(tfm); 15589a8a6b3fSEric Biggers const unsigned int maxdatasize = (2 * PAGE_SIZE) - TESTMGR_POISON_LEN; 15599a8a6b3fSEric Biggers const char *algname = crypto_hash_alg_common(tfm)->base.cra_name; 15609a8a6b3fSEric Biggers char _generic_driver[CRYPTO_MAX_ALG_NAME]; 15619a8a6b3fSEric Biggers struct crypto_shash *generic_tfm = NULL; 1562149c4e6eSArnd Bergmann struct shash_desc *generic_desc = NULL; 15639a8a6b3fSEric Biggers unsigned int i; 15649a8a6b3fSEric Biggers struct hash_testvec vec = { 0 }; 15659a8a6b3fSEric Biggers char vec_name[64]; 15666b5ca646SArnd Bergmann struct testvec_config *cfg; 15679a8a6b3fSEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 15689a8a6b3fSEric Biggers int err; 15699a8a6b3fSEric Biggers 15709a8a6b3fSEric Biggers if (noextratests) 15719a8a6b3fSEric Biggers return 0; 15729a8a6b3fSEric Biggers 15739a8a6b3fSEric Biggers if (!generic_driver) { /* Use default naming convention? */ 15749a8a6b3fSEric Biggers err = build_generic_driver_name(algname, _generic_driver); 15759a8a6b3fSEric Biggers if (err) 15769a8a6b3fSEric Biggers return err; 15779a8a6b3fSEric Biggers generic_driver = _generic_driver; 15789a8a6b3fSEric Biggers } 15799a8a6b3fSEric Biggers 15809a8a6b3fSEric Biggers if (strcmp(generic_driver, driver) == 0) /* Already the generic impl? */ 15819a8a6b3fSEric Biggers return 0; 15829a8a6b3fSEric Biggers 15839a8a6b3fSEric Biggers generic_tfm = crypto_alloc_shash(generic_driver, 0, 0); 15849a8a6b3fSEric Biggers if (IS_ERR(generic_tfm)) { 15859a8a6b3fSEric Biggers err = PTR_ERR(generic_tfm); 15869a8a6b3fSEric Biggers if (err == -ENOENT) { 15879a8a6b3fSEric Biggers pr_warn("alg: hash: skipping comparison tests for %s because %s is unavailable\n", 15889a8a6b3fSEric Biggers driver, generic_driver); 15899a8a6b3fSEric Biggers return 0; 15909a8a6b3fSEric Biggers } 15919a8a6b3fSEric Biggers pr_err("alg: hash: error allocating %s (generic impl of %s): %d\n", 15929a8a6b3fSEric Biggers generic_driver, algname, err); 15939a8a6b3fSEric Biggers return err; 15949a8a6b3fSEric Biggers } 15959a8a6b3fSEric Biggers 15966b5ca646SArnd Bergmann cfg = kzalloc(sizeof(*cfg), GFP_KERNEL); 15976b5ca646SArnd Bergmann if (!cfg) { 15986b5ca646SArnd Bergmann err = -ENOMEM; 15996b5ca646SArnd Bergmann goto out; 16006b5ca646SArnd Bergmann } 16016b5ca646SArnd Bergmann 1602149c4e6eSArnd Bergmann generic_desc = kzalloc(sizeof(*desc) + 1603149c4e6eSArnd Bergmann crypto_shash_descsize(generic_tfm), GFP_KERNEL); 1604149c4e6eSArnd Bergmann if (!generic_desc) { 1605149c4e6eSArnd Bergmann err = -ENOMEM; 1606149c4e6eSArnd Bergmann goto out; 1607149c4e6eSArnd Bergmann } 1608149c4e6eSArnd Bergmann generic_desc->tfm = generic_tfm; 1609149c4e6eSArnd Bergmann 16109a8a6b3fSEric Biggers /* Check the algorithm properties for consistency. */ 16119a8a6b3fSEric Biggers 16129a8a6b3fSEric Biggers if (digestsize != crypto_shash_digestsize(generic_tfm)) { 16139a8a6b3fSEric Biggers pr_err("alg: hash: digestsize for %s (%u) doesn't match generic impl (%u)\n", 16149a8a6b3fSEric Biggers driver, digestsize, 16159a8a6b3fSEric Biggers crypto_shash_digestsize(generic_tfm)); 16169a8a6b3fSEric Biggers err = -EINVAL; 16179a8a6b3fSEric Biggers goto out; 16189a8a6b3fSEric Biggers } 16199a8a6b3fSEric Biggers 16209a8a6b3fSEric Biggers if (blocksize != crypto_shash_blocksize(generic_tfm)) { 16219a8a6b3fSEric Biggers pr_err("alg: hash: blocksize for %s (%u) doesn't match generic impl (%u)\n", 16229a8a6b3fSEric Biggers driver, blocksize, crypto_shash_blocksize(generic_tfm)); 16239a8a6b3fSEric Biggers err = -EINVAL; 16249a8a6b3fSEric Biggers goto out; 16259a8a6b3fSEric Biggers } 16269a8a6b3fSEric Biggers 16279a8a6b3fSEric Biggers /* 16289a8a6b3fSEric Biggers * Now generate test vectors using the generic implementation, and test 16299a8a6b3fSEric Biggers * the other implementation against them. 16309a8a6b3fSEric Biggers */ 16319a8a6b3fSEric Biggers 16329a8a6b3fSEric Biggers vec.key = kmalloc(maxkeysize, GFP_KERNEL); 16339a8a6b3fSEric Biggers vec.plaintext = kmalloc(maxdatasize, GFP_KERNEL); 16349a8a6b3fSEric Biggers vec.digest = kmalloc(digestsize, GFP_KERNEL); 16359a8a6b3fSEric Biggers if (!vec.key || !vec.plaintext || !vec.digest) { 16369a8a6b3fSEric Biggers err = -ENOMEM; 16379a8a6b3fSEric Biggers goto out; 16389a8a6b3fSEric Biggers } 16399a8a6b3fSEric Biggers 16409a8a6b3fSEric Biggers for (i = 0; i < fuzz_iterations * 8; i++) { 1641149c4e6eSArnd Bergmann generate_random_hash_testvec(generic_desc, &vec, 16429a8a6b3fSEric Biggers maxkeysize, maxdatasize, 16439a8a6b3fSEric Biggers vec_name, sizeof(vec_name)); 16446b5ca646SArnd Bergmann generate_random_testvec_config(cfg, cfgname, sizeof(cfgname)); 16459a8a6b3fSEric Biggers 16466b5ca646SArnd Bergmann err = test_hash_vec_cfg(driver, &vec, vec_name, cfg, 1647d8ea98aaSEric Biggers req, desc, tsgl, hashstate); 16489a8a6b3fSEric Biggers if (err) 16499a8a6b3fSEric Biggers goto out; 16509a8a6b3fSEric Biggers cond_resched(); 16519a8a6b3fSEric Biggers } 16529a8a6b3fSEric Biggers err = 0; 16539a8a6b3fSEric Biggers out: 16546b5ca646SArnd Bergmann kfree(cfg); 16559a8a6b3fSEric Biggers kfree(vec.key); 16569a8a6b3fSEric Biggers kfree(vec.plaintext); 16579a8a6b3fSEric Biggers kfree(vec.digest); 16589a8a6b3fSEric Biggers crypto_free_shash(generic_tfm); 1659149c4e6eSArnd Bergmann kzfree(generic_desc); 16609a8a6b3fSEric Biggers return err; 16619a8a6b3fSEric Biggers } 16629a8a6b3fSEric Biggers #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 16639a8a6b3fSEric Biggers static int test_hash_vs_generic_impl(const char *driver, 16649a8a6b3fSEric Biggers const char *generic_driver, 16659a8a6b3fSEric Biggers unsigned int maxkeysize, 16669a8a6b3fSEric Biggers struct ahash_request *req, 1667d8ea98aaSEric Biggers struct shash_desc *desc, 16689a8a6b3fSEric Biggers struct test_sglist *tsgl, 16699a8a6b3fSEric Biggers u8 *hashstate) 16709a8a6b3fSEric Biggers { 16719a8a6b3fSEric Biggers return 0; 16729a8a6b3fSEric Biggers } 16739a8a6b3fSEric Biggers #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 16749a8a6b3fSEric Biggers 1675d8ea98aaSEric Biggers static int alloc_shash(const char *driver, u32 type, u32 mask, 1676d8ea98aaSEric Biggers struct crypto_shash **tfm_ret, 1677d8ea98aaSEric Biggers struct shash_desc **desc_ret) 1678d8ea98aaSEric Biggers { 1679d8ea98aaSEric Biggers struct crypto_shash *tfm; 1680d8ea98aaSEric Biggers struct shash_desc *desc; 1681d8ea98aaSEric Biggers 1682d8ea98aaSEric Biggers tfm = crypto_alloc_shash(driver, type, mask); 1683d8ea98aaSEric Biggers if (IS_ERR(tfm)) { 1684d8ea98aaSEric Biggers if (PTR_ERR(tfm) == -ENOENT) { 1685d8ea98aaSEric Biggers /* 1686d8ea98aaSEric Biggers * This algorithm is only available through the ahash 1687d8ea98aaSEric Biggers * API, not the shash API, so skip the shash tests. 1688d8ea98aaSEric Biggers */ 1689d8ea98aaSEric Biggers return 0; 1690d8ea98aaSEric Biggers } 1691d8ea98aaSEric Biggers pr_err("alg: hash: failed to allocate shash transform for %s: %ld\n", 1692d8ea98aaSEric Biggers driver, PTR_ERR(tfm)); 1693d8ea98aaSEric Biggers return PTR_ERR(tfm); 1694d8ea98aaSEric Biggers } 1695d8ea98aaSEric Biggers 1696d8ea98aaSEric Biggers desc = kmalloc(sizeof(*desc) + crypto_shash_descsize(tfm), GFP_KERNEL); 1697d8ea98aaSEric Biggers if (!desc) { 1698d8ea98aaSEric Biggers crypto_free_shash(tfm); 1699d8ea98aaSEric Biggers return -ENOMEM; 1700d8ea98aaSEric Biggers } 1701d8ea98aaSEric Biggers desc->tfm = tfm; 1702d8ea98aaSEric Biggers 1703d8ea98aaSEric Biggers *tfm_ret = tfm; 1704d8ea98aaSEric Biggers *desc_ret = desc; 1705d8ea98aaSEric Biggers return 0; 1706d8ea98aaSEric Biggers } 1707d8ea98aaSEric Biggers 17084cc2dcf9SEric Biggers static int __alg_test_hash(const struct hash_testvec *vecs, 17094cc2dcf9SEric Biggers unsigned int num_vecs, const char *driver, 17109a8a6b3fSEric Biggers u32 type, u32 mask, 17119a8a6b3fSEric Biggers const char *generic_driver, unsigned int maxkeysize) 17124cc2dcf9SEric Biggers { 1713d8ea98aaSEric Biggers struct crypto_ahash *atfm = NULL; 17144cc2dcf9SEric Biggers struct ahash_request *req = NULL; 1715d8ea98aaSEric Biggers struct crypto_shash *stfm = NULL; 1716d8ea98aaSEric Biggers struct shash_desc *desc = NULL; 17174cc2dcf9SEric Biggers struct test_sglist *tsgl = NULL; 17184cc2dcf9SEric Biggers u8 *hashstate = NULL; 1719d8ea98aaSEric Biggers unsigned int statesize; 17204cc2dcf9SEric Biggers unsigned int i; 17214cc2dcf9SEric Biggers int err; 17224cc2dcf9SEric Biggers 1723d8ea98aaSEric Biggers /* 1724d8ea98aaSEric Biggers * Always test the ahash API. This works regardless of whether the 1725d8ea98aaSEric Biggers * algorithm is implemented as ahash or shash. 1726d8ea98aaSEric Biggers */ 1727d8ea98aaSEric Biggers 1728d8ea98aaSEric Biggers atfm = crypto_alloc_ahash(driver, type, mask); 1729d8ea98aaSEric Biggers if (IS_ERR(atfm)) { 17304cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate transform for %s: %ld\n", 1731d8ea98aaSEric Biggers driver, PTR_ERR(atfm)); 1732d8ea98aaSEric Biggers return PTR_ERR(atfm); 17334cc2dcf9SEric Biggers } 17344cc2dcf9SEric Biggers 1735d8ea98aaSEric Biggers req = ahash_request_alloc(atfm, GFP_KERNEL); 17364cc2dcf9SEric Biggers if (!req) { 17374cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate request for %s\n", 17384cc2dcf9SEric Biggers driver); 17394cc2dcf9SEric Biggers err = -ENOMEM; 17404cc2dcf9SEric Biggers goto out; 17414cc2dcf9SEric Biggers } 17424cc2dcf9SEric Biggers 1743d8ea98aaSEric Biggers /* 1744d8ea98aaSEric Biggers * If available also test the shash API, to cover corner cases that may 1745d8ea98aaSEric Biggers * be missed by testing the ahash API only. 1746d8ea98aaSEric Biggers */ 1747d8ea98aaSEric Biggers err = alloc_shash(driver, type, mask, &stfm, &desc); 1748d8ea98aaSEric Biggers if (err) 1749d8ea98aaSEric Biggers goto out; 1750d8ea98aaSEric Biggers 17514cc2dcf9SEric Biggers tsgl = kmalloc(sizeof(*tsgl), GFP_KERNEL); 17524cc2dcf9SEric Biggers if (!tsgl || init_test_sglist(tsgl) != 0) { 17534cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate test buffers for %s\n", 17544cc2dcf9SEric Biggers driver); 17554cc2dcf9SEric Biggers kfree(tsgl); 17564cc2dcf9SEric Biggers tsgl = NULL; 17574cc2dcf9SEric Biggers err = -ENOMEM; 17584cc2dcf9SEric Biggers goto out; 17594cc2dcf9SEric Biggers } 17604cc2dcf9SEric Biggers 1761d8ea98aaSEric Biggers statesize = crypto_ahash_statesize(atfm); 1762d8ea98aaSEric Biggers if (stfm) 1763d8ea98aaSEric Biggers statesize = max(statesize, crypto_shash_statesize(stfm)); 1764d8ea98aaSEric Biggers hashstate = kmalloc(statesize + TESTMGR_POISON_LEN, GFP_KERNEL); 17654cc2dcf9SEric Biggers if (!hashstate) { 17664cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate hash state buffer for %s\n", 17674cc2dcf9SEric Biggers driver); 17684cc2dcf9SEric Biggers err = -ENOMEM; 17694cc2dcf9SEric Biggers goto out; 17704cc2dcf9SEric Biggers } 17714cc2dcf9SEric Biggers 17724cc2dcf9SEric Biggers for (i = 0; i < num_vecs; i++) { 1773d8ea98aaSEric Biggers err = test_hash_vec(driver, &vecs[i], i, req, desc, tsgl, 1774d8ea98aaSEric Biggers hashstate); 17754cc2dcf9SEric Biggers if (err) 17764cc2dcf9SEric Biggers goto out; 1777e63e1b0dSEric Biggers cond_resched(); 17784cc2dcf9SEric Biggers } 17799a8a6b3fSEric Biggers err = test_hash_vs_generic_impl(driver, generic_driver, maxkeysize, req, 1780d8ea98aaSEric Biggers desc, tsgl, hashstate); 17814cc2dcf9SEric Biggers out: 17824cc2dcf9SEric Biggers kfree(hashstate); 17834cc2dcf9SEric Biggers if (tsgl) { 17844cc2dcf9SEric Biggers destroy_test_sglist(tsgl); 17854cc2dcf9SEric Biggers kfree(tsgl); 17864cc2dcf9SEric Biggers } 1787d8ea98aaSEric Biggers kfree(desc); 1788d8ea98aaSEric Biggers crypto_free_shash(stfm); 17894cc2dcf9SEric Biggers ahash_request_free(req); 1790d8ea98aaSEric Biggers crypto_free_ahash(atfm); 17914cc2dcf9SEric Biggers return err; 17924cc2dcf9SEric Biggers } 17934cc2dcf9SEric Biggers 17944cc2dcf9SEric Biggers static int alg_test_hash(const struct alg_test_desc *desc, const char *driver, 17954cc2dcf9SEric Biggers u32 type, u32 mask) 17964cc2dcf9SEric Biggers { 17974cc2dcf9SEric Biggers const struct hash_testvec *template = desc->suite.hash.vecs; 17984cc2dcf9SEric Biggers unsigned int tcount = desc->suite.hash.count; 17994cc2dcf9SEric Biggers unsigned int nr_unkeyed, nr_keyed; 18009a8a6b3fSEric Biggers unsigned int maxkeysize = 0; 18014cc2dcf9SEric Biggers int err; 18024cc2dcf9SEric Biggers 18034cc2dcf9SEric Biggers /* 18044cc2dcf9SEric Biggers * For OPTIONAL_KEY algorithms, we have to do all the unkeyed tests 18054cc2dcf9SEric Biggers * first, before setting a key on the tfm. To make this easier, we 18064cc2dcf9SEric Biggers * require that the unkeyed test vectors (if any) are listed first. 18074cc2dcf9SEric Biggers */ 18084cc2dcf9SEric Biggers 18094cc2dcf9SEric Biggers for (nr_unkeyed = 0; nr_unkeyed < tcount; nr_unkeyed++) { 18104cc2dcf9SEric Biggers if (template[nr_unkeyed].ksize) 18114cc2dcf9SEric Biggers break; 18124cc2dcf9SEric Biggers } 18134cc2dcf9SEric Biggers for (nr_keyed = 0; nr_unkeyed + nr_keyed < tcount; nr_keyed++) { 18144cc2dcf9SEric Biggers if (!template[nr_unkeyed + nr_keyed].ksize) { 18154cc2dcf9SEric Biggers pr_err("alg: hash: test vectors for %s out of order, " 18164cc2dcf9SEric Biggers "unkeyed ones must come first\n", desc->alg); 18174cc2dcf9SEric Biggers return -EINVAL; 18184cc2dcf9SEric Biggers } 18199a8a6b3fSEric Biggers maxkeysize = max_t(unsigned int, maxkeysize, 18209a8a6b3fSEric Biggers template[nr_unkeyed + nr_keyed].ksize); 18214cc2dcf9SEric Biggers } 18224cc2dcf9SEric Biggers 18234cc2dcf9SEric Biggers err = 0; 18244cc2dcf9SEric Biggers if (nr_unkeyed) { 18259a8a6b3fSEric Biggers err = __alg_test_hash(template, nr_unkeyed, driver, type, mask, 18269a8a6b3fSEric Biggers desc->generic_driver, maxkeysize); 18274cc2dcf9SEric Biggers template += nr_unkeyed; 18284cc2dcf9SEric Biggers } 18294cc2dcf9SEric Biggers 18304cc2dcf9SEric Biggers if (!err && nr_keyed) 18319a8a6b3fSEric Biggers err = __alg_test_hash(template, nr_keyed, driver, type, mask, 18329a8a6b3fSEric Biggers desc->generic_driver, maxkeysize); 18334cc2dcf9SEric Biggers 18344cc2dcf9SEric Biggers return err; 18354cc2dcf9SEric Biggers } 18364cc2dcf9SEric Biggers 1837ed96804fSEric Biggers static int test_aead_vec_cfg(const char *driver, int enc, 1838ed96804fSEric Biggers const struct aead_testvec *vec, 1839951d1332SEric Biggers const char *vec_name, 1840ed96804fSEric Biggers const struct testvec_config *cfg, 1841ed96804fSEric Biggers struct aead_request *req, 1842ed96804fSEric Biggers struct cipher_test_sglists *tsgls) 1843da7f033dSHerbert Xu { 1844ed96804fSEric Biggers struct crypto_aead *tfm = crypto_aead_reqtfm(req); 1845ed96804fSEric Biggers const unsigned int alignmask = crypto_aead_alignmask(tfm); 1846ed96804fSEric Biggers const unsigned int ivsize = crypto_aead_ivsize(tfm); 1847ed96804fSEric Biggers const unsigned int authsize = vec->clen - vec->plen; 1848ed96804fSEric Biggers const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags; 1849ed96804fSEric Biggers const char *op = enc ? "encryption" : "decryption"; 1850ed96804fSEric Biggers DECLARE_CRYPTO_WAIT(wait); 1851ed96804fSEric Biggers u8 _iv[3 * (MAX_ALGAPI_ALIGNMASK + 1) + MAX_IVLEN]; 1852ed96804fSEric Biggers u8 *iv = PTR_ALIGN(&_iv[0], 2 * (MAX_ALGAPI_ALIGNMASK + 1)) + 1853ed96804fSEric Biggers cfg->iv_offset + 1854ed96804fSEric Biggers (cfg->iv_offset_relative_to_alignmask ? alignmask : 0); 1855ed96804fSEric Biggers struct kvec input[2]; 18565283a8eeSEric Biggers int expected_error; 1857ed96804fSEric Biggers int err; 1858f8b0d4d0SHerbert Xu 1859ed96804fSEric Biggers /* Set the key */ 1860ed96804fSEric Biggers if (vec->wk) 1861ed96804fSEric Biggers crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 1862d8a32ac2SJussi Kivilinna else 1863ed96804fSEric Biggers crypto_aead_clear_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 1864ed96804fSEric Biggers err = crypto_aead_setkey(tfm, vec->key, vec->klen); 18655283a8eeSEric Biggers if (err && err != vec->setkey_error) { 1866951d1332SEric Biggers pr_err("alg: aead: %s setkey failed on test vector %s; expected_error=%d, actual_error=%d, flags=%#x\n", 1867951d1332SEric Biggers driver, vec_name, vec->setkey_error, err, 18685283a8eeSEric Biggers crypto_aead_get_flags(tfm)); 1869ed96804fSEric Biggers return err; 1870ed96804fSEric Biggers } 18715283a8eeSEric Biggers if (!err && vec->setkey_error) { 1872951d1332SEric Biggers pr_err("alg: aead: %s setkey unexpectedly succeeded on test vector %s; expected_error=%d\n", 1873951d1332SEric Biggers driver, vec_name, vec->setkey_error); 1874ed96804fSEric Biggers return -EINVAL; 1875ed96804fSEric Biggers } 1876d8a32ac2SJussi Kivilinna 1877ed96804fSEric Biggers /* Set the authentication tag size */ 1878ed96804fSEric Biggers err = crypto_aead_setauthsize(tfm, authsize); 18795283a8eeSEric Biggers if (err && err != vec->setauthsize_error) { 1880951d1332SEric Biggers pr_err("alg: aead: %s setauthsize failed on test vector %s; expected_error=%d, actual_error=%d\n", 1881951d1332SEric Biggers driver, vec_name, vec->setauthsize_error, err); 1882ed96804fSEric Biggers return err; 1883ed96804fSEric Biggers } 18845283a8eeSEric Biggers if (!err && vec->setauthsize_error) { 1885951d1332SEric Biggers pr_err("alg: aead: %s setauthsize unexpectedly succeeded on test vector %s; expected_error=%d\n", 1886951d1332SEric Biggers driver, vec_name, vec->setauthsize_error); 18875283a8eeSEric Biggers return -EINVAL; 18885283a8eeSEric Biggers } 18895283a8eeSEric Biggers 18905283a8eeSEric Biggers if (vec->setkey_error || vec->setauthsize_error) 18915283a8eeSEric Biggers return 0; 1892ed96804fSEric Biggers 1893ed96804fSEric Biggers /* The IV must be copied to a buffer, as the algorithm may modify it */ 1894ed96804fSEric Biggers if (WARN_ON(ivsize > MAX_IVLEN)) 1895ed96804fSEric Biggers return -EINVAL; 1896ed96804fSEric Biggers if (vec->iv) 1897ed96804fSEric Biggers memcpy(iv, vec->iv, ivsize); 1898da7f033dSHerbert Xu else 1899ed96804fSEric Biggers memset(iv, 0, ivsize); 1900da7f033dSHerbert Xu 1901ed96804fSEric Biggers /* Build the src/dst scatterlists */ 1902ed96804fSEric Biggers input[0].iov_base = (void *)vec->assoc; 1903ed96804fSEric Biggers input[0].iov_len = vec->alen; 1904ed96804fSEric Biggers input[1].iov_base = enc ? (void *)vec->ptext : (void *)vec->ctext; 1905ed96804fSEric Biggers input[1].iov_len = enc ? vec->plen : vec->clen; 1906ed96804fSEric Biggers err = build_cipher_test_sglists(tsgls, cfg, alignmask, 1907ed96804fSEric Biggers vec->alen + (enc ? vec->plen : 1908ed96804fSEric Biggers vec->clen), 1909ed96804fSEric Biggers vec->alen + (enc ? vec->clen : 1910ed96804fSEric Biggers vec->plen), 1911ed96804fSEric Biggers input, 2); 1912ed96804fSEric Biggers if (err) { 1913951d1332SEric Biggers pr_err("alg: aead: %s %s: error preparing scatterlists for test vector %s, cfg=\"%s\"\n", 1914951d1332SEric Biggers driver, op, vec_name, cfg->name); 1915ed96804fSEric Biggers return err; 1916da7f033dSHerbert Xu } 1917da7f033dSHerbert Xu 1918ed96804fSEric Biggers /* Do the actual encryption or decryption */ 1919ed96804fSEric Biggers testmgr_poison(req->__ctx, crypto_aead_reqsize(tfm)); 1920ed96804fSEric Biggers aead_request_set_callback(req, req_flags, crypto_req_done, &wait); 1921ed96804fSEric Biggers aead_request_set_crypt(req, tsgls->src.sgl_ptr, tsgls->dst.sgl_ptr, 1922ed96804fSEric Biggers enc ? vec->plen : vec->clen, iv); 1923ed96804fSEric Biggers aead_request_set_ad(req, vec->alen); 19246570737cSEric Biggers if (cfg->nosimd) 19256570737cSEric Biggers crypto_disable_simd_for_test(); 19266570737cSEric Biggers err = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req); 19276570737cSEric Biggers if (cfg->nosimd) 19286570737cSEric Biggers crypto_reenable_simd_for_test(); 19296570737cSEric Biggers err = crypto_wait_req(err, &wait); 193005b1d338SCristian Stoica 1931a6e5ef9bSEric Biggers /* Check that the algorithm didn't overwrite things it shouldn't have */ 1932a6e5ef9bSEric Biggers if (req->cryptlen != (enc ? vec->plen : vec->clen) || 1933a6e5ef9bSEric Biggers req->assoclen != vec->alen || 1934a6e5ef9bSEric Biggers req->iv != iv || 1935a6e5ef9bSEric Biggers req->src != tsgls->src.sgl_ptr || 1936a6e5ef9bSEric Biggers req->dst != tsgls->dst.sgl_ptr || 1937a6e5ef9bSEric Biggers crypto_aead_reqtfm(req) != tfm || 1938a6e5ef9bSEric Biggers req->base.complete != crypto_req_done || 1939a6e5ef9bSEric Biggers req->base.flags != req_flags || 1940a6e5ef9bSEric Biggers req->base.data != &wait) { 1941951d1332SEric Biggers pr_err("alg: aead: %s %s corrupted request struct on test vector %s, cfg=\"%s\"\n", 1942951d1332SEric Biggers driver, op, vec_name, cfg->name); 1943a6e5ef9bSEric Biggers if (req->cryptlen != (enc ? vec->plen : vec->clen)) 1944a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->cryptlen'\n"); 1945a6e5ef9bSEric Biggers if (req->assoclen != vec->alen) 1946a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->assoclen'\n"); 1947a6e5ef9bSEric Biggers if (req->iv != iv) 1948a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->iv'\n"); 1949a6e5ef9bSEric Biggers if (req->src != tsgls->src.sgl_ptr) 1950a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->src'\n"); 1951a6e5ef9bSEric Biggers if (req->dst != tsgls->dst.sgl_ptr) 1952a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->dst'\n"); 1953a6e5ef9bSEric Biggers if (crypto_aead_reqtfm(req) != tfm) 1954a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.tfm'\n"); 1955a6e5ef9bSEric Biggers if (req->base.complete != crypto_req_done) 1956a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.complete'\n"); 1957a6e5ef9bSEric Biggers if (req->base.flags != req_flags) 1958a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.flags'\n"); 1959a6e5ef9bSEric Biggers if (req->base.data != &wait) 1960a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.data'\n"); 1961a6e5ef9bSEric Biggers return -EINVAL; 1962a6e5ef9bSEric Biggers } 1963a6e5ef9bSEric Biggers if (is_test_sglist_corrupted(&tsgls->src)) { 1964951d1332SEric Biggers pr_err("alg: aead: %s %s corrupted src sgl on test vector %s, cfg=\"%s\"\n", 1965951d1332SEric Biggers driver, op, vec_name, cfg->name); 1966a6e5ef9bSEric Biggers return -EINVAL; 1967a6e5ef9bSEric Biggers } 1968a6e5ef9bSEric Biggers if (tsgls->dst.sgl_ptr != tsgls->src.sgl && 1969a6e5ef9bSEric Biggers is_test_sglist_corrupted(&tsgls->dst)) { 1970951d1332SEric Biggers pr_err("alg: aead: %s %s corrupted dst sgl on test vector %s, cfg=\"%s\"\n", 1971951d1332SEric Biggers driver, op, vec_name, cfg->name); 1972a6e5ef9bSEric Biggers return -EINVAL; 1973a6e5ef9bSEric Biggers } 1974a6e5ef9bSEric Biggers 19755283a8eeSEric Biggers /* Check for success or failure */ 19765283a8eeSEric Biggers expected_error = vec->novrfy ? -EBADMSG : vec->crypt_error; 19775283a8eeSEric Biggers if (err) { 19785283a8eeSEric Biggers if (err == expected_error) 19795283a8eeSEric Biggers return 0; 1980951d1332SEric Biggers pr_err("alg: aead: %s %s failed on test vector %s; expected_error=%d, actual_error=%d, cfg=\"%s\"\n", 1981951d1332SEric Biggers driver, op, vec_name, expected_error, err, cfg->name); 19825283a8eeSEric Biggers return err; 19835283a8eeSEric Biggers } 19845283a8eeSEric Biggers if (expected_error) { 1985951d1332SEric Biggers pr_err("alg: aead: %s %s unexpectedly succeeded on test vector %s; expected_error=%d, cfg=\"%s\"\n", 1986951d1332SEric Biggers driver, op, vec_name, expected_error, cfg->name); 19875283a8eeSEric Biggers return -EINVAL; 19885283a8eeSEric Biggers } 19895283a8eeSEric Biggers 1990ed96804fSEric Biggers /* Check for the correct output (ciphertext or plaintext) */ 1991ed96804fSEric Biggers err = verify_correct_output(&tsgls->dst, enc ? vec->ctext : vec->ptext, 1992ed96804fSEric Biggers enc ? vec->clen : vec->plen, 1993ed96804fSEric Biggers vec->alen, enc || !cfg->inplace); 1994ed96804fSEric Biggers if (err == -EOVERFLOW) { 1995951d1332SEric Biggers pr_err("alg: aead: %s %s overran dst buffer on test vector %s, cfg=\"%s\"\n", 1996951d1332SEric Biggers driver, op, vec_name, cfg->name); 1997ed96804fSEric Biggers return err; 199829b77e5dSHoria Geanta } 1999ed96804fSEric Biggers if (err) { 2000951d1332SEric Biggers pr_err("alg: aead: %s %s test failed (wrong result) on test vector %s, cfg=\"%s\"\n", 2001951d1332SEric Biggers driver, op, vec_name, cfg->name); 2002ed96804fSEric Biggers return err; 200358dcf548SJussi Kivilinna } 200458dcf548SJussi Kivilinna 200558dcf548SJussi Kivilinna return 0; 2006d8a32ac2SJussi Kivilinna } 2007d8a32ac2SJussi Kivilinna 2008ed96804fSEric Biggers static int test_aead_vec(const char *driver, int enc, 2009ed96804fSEric Biggers const struct aead_testvec *vec, unsigned int vec_num, 2010ed96804fSEric Biggers struct aead_request *req, 2011ed96804fSEric Biggers struct cipher_test_sglists *tsgls) 2012ed96804fSEric Biggers { 2013951d1332SEric Biggers char vec_name[16]; 2014ed96804fSEric Biggers unsigned int i; 2015ed96804fSEric Biggers int err; 2016ed96804fSEric Biggers 2017ed96804fSEric Biggers if (enc && vec->novrfy) 2018ed96804fSEric Biggers return 0; 2019ed96804fSEric Biggers 2020951d1332SEric Biggers sprintf(vec_name, "%u", vec_num); 2021951d1332SEric Biggers 2022ed96804fSEric Biggers for (i = 0; i < ARRAY_SIZE(default_cipher_testvec_configs); i++) { 2023951d1332SEric Biggers err = test_aead_vec_cfg(driver, enc, vec, vec_name, 2024ed96804fSEric Biggers &default_cipher_testvec_configs[i], 2025ed96804fSEric Biggers req, tsgls); 2026ed96804fSEric Biggers if (err) 2027ed96804fSEric Biggers return err; 2028ed96804fSEric Biggers } 2029ed96804fSEric Biggers 2030ed96804fSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 2031ed96804fSEric Biggers if (!noextratests) { 2032ed96804fSEric Biggers struct testvec_config cfg; 2033ed96804fSEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 2034ed96804fSEric Biggers 2035ed96804fSEric Biggers for (i = 0; i < fuzz_iterations; i++) { 2036ed96804fSEric Biggers generate_random_testvec_config(&cfg, cfgname, 2037ed96804fSEric Biggers sizeof(cfgname)); 2038951d1332SEric Biggers err = test_aead_vec_cfg(driver, enc, vec, vec_name, 2039ed96804fSEric Biggers &cfg, req, tsgls); 2040ed96804fSEric Biggers if (err) 2041ed96804fSEric Biggers return err; 2042e63e1b0dSEric Biggers cond_resched(); 2043ed96804fSEric Biggers } 2044ed96804fSEric Biggers } 2045ed96804fSEric Biggers #endif 2046ed96804fSEric Biggers return 0; 2047ed96804fSEric Biggers } 2048ed96804fSEric Biggers 204940153b10SEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 205040153b10SEric Biggers /* 205140153b10SEric Biggers * Generate an AEAD test vector from the given implementation. 205240153b10SEric Biggers * Assumes the buffers in 'vec' were already allocated. 205340153b10SEric Biggers */ 205440153b10SEric Biggers static void generate_random_aead_testvec(struct aead_request *req, 205540153b10SEric Biggers struct aead_testvec *vec, 205640153b10SEric Biggers unsigned int maxkeysize, 205740153b10SEric Biggers unsigned int maxdatasize, 205840153b10SEric Biggers char *name, size_t max_namelen) 205940153b10SEric Biggers { 206040153b10SEric Biggers struct crypto_aead *tfm = crypto_aead_reqtfm(req); 206140153b10SEric Biggers const unsigned int ivsize = crypto_aead_ivsize(tfm); 206240153b10SEric Biggers unsigned int maxauthsize = crypto_aead_alg(tfm)->maxauthsize; 206340153b10SEric Biggers unsigned int authsize; 206440153b10SEric Biggers unsigned int total_len; 206540153b10SEric Biggers int i; 206640153b10SEric Biggers struct scatterlist src[2], dst; 206740153b10SEric Biggers u8 iv[MAX_IVLEN]; 206840153b10SEric Biggers DECLARE_CRYPTO_WAIT(wait); 206940153b10SEric Biggers 207040153b10SEric Biggers /* Key: length in [0, maxkeysize], but usually choose maxkeysize */ 207140153b10SEric Biggers vec->klen = maxkeysize; 207240153b10SEric Biggers if (prandom_u32() % 4 == 0) 207340153b10SEric Biggers vec->klen = prandom_u32() % (maxkeysize + 1); 207440153b10SEric Biggers generate_random_bytes((u8 *)vec->key, vec->klen); 207540153b10SEric Biggers vec->setkey_error = crypto_aead_setkey(tfm, vec->key, vec->klen); 207640153b10SEric Biggers 207740153b10SEric Biggers /* IV */ 207840153b10SEric Biggers generate_random_bytes((u8 *)vec->iv, ivsize); 207940153b10SEric Biggers 208040153b10SEric Biggers /* Tag length: in [0, maxauthsize], but usually choose maxauthsize */ 208140153b10SEric Biggers authsize = maxauthsize; 208240153b10SEric Biggers if (prandom_u32() % 4 == 0) 208340153b10SEric Biggers authsize = prandom_u32() % (maxauthsize + 1); 208440153b10SEric Biggers if (WARN_ON(authsize > maxdatasize)) 208540153b10SEric Biggers authsize = maxdatasize; 208640153b10SEric Biggers maxdatasize -= authsize; 208740153b10SEric Biggers vec->setauthsize_error = crypto_aead_setauthsize(tfm, authsize); 208840153b10SEric Biggers 208940153b10SEric Biggers /* Plaintext and associated data */ 209040153b10SEric Biggers total_len = generate_random_length(maxdatasize); 209140153b10SEric Biggers if (prandom_u32() % 4 == 0) 209240153b10SEric Biggers vec->alen = 0; 209340153b10SEric Biggers else 209440153b10SEric Biggers vec->alen = generate_random_length(total_len); 209540153b10SEric Biggers vec->plen = total_len - vec->alen; 209640153b10SEric Biggers generate_random_bytes((u8 *)vec->assoc, vec->alen); 209740153b10SEric Biggers generate_random_bytes((u8 *)vec->ptext, vec->plen); 209840153b10SEric Biggers 209940153b10SEric Biggers vec->clen = vec->plen + authsize; 210040153b10SEric Biggers 210140153b10SEric Biggers /* 210240153b10SEric Biggers * If the key or authentication tag size couldn't be set, no need to 210340153b10SEric Biggers * continue to encrypt. 210440153b10SEric Biggers */ 2105eb455dbdSEric Biggers vec->crypt_error = 0; 210640153b10SEric Biggers if (vec->setkey_error || vec->setauthsize_error) 210740153b10SEric Biggers goto done; 210840153b10SEric Biggers 210940153b10SEric Biggers /* Ciphertext */ 211040153b10SEric Biggers sg_init_table(src, 2); 211140153b10SEric Biggers i = 0; 211240153b10SEric Biggers if (vec->alen) 211340153b10SEric Biggers sg_set_buf(&src[i++], vec->assoc, vec->alen); 211440153b10SEric Biggers if (vec->plen) 211540153b10SEric Biggers sg_set_buf(&src[i++], vec->ptext, vec->plen); 211640153b10SEric Biggers sg_init_one(&dst, vec->ctext, vec->alen + vec->clen); 211740153b10SEric Biggers memcpy(iv, vec->iv, ivsize); 211840153b10SEric Biggers aead_request_set_callback(req, 0, crypto_req_done, &wait); 211940153b10SEric Biggers aead_request_set_crypt(req, src, &dst, vec->plen, iv); 212040153b10SEric Biggers aead_request_set_ad(req, vec->alen); 212140153b10SEric Biggers vec->crypt_error = crypto_wait_req(crypto_aead_encrypt(req), &wait); 212240153b10SEric Biggers if (vec->crypt_error == 0) 212340153b10SEric Biggers memmove((u8 *)vec->ctext, vec->ctext + vec->alen, vec->clen); 212440153b10SEric Biggers done: 212540153b10SEric Biggers snprintf(name, max_namelen, 212640153b10SEric Biggers "\"random: alen=%u plen=%u authsize=%u klen=%u\"", 212740153b10SEric Biggers vec->alen, vec->plen, authsize, vec->klen); 212840153b10SEric Biggers } 212940153b10SEric Biggers 213040153b10SEric Biggers /* 213140153b10SEric Biggers * Test the AEAD algorithm represented by @req against the corresponding generic 213240153b10SEric Biggers * implementation, if one is available. 213340153b10SEric Biggers */ 213440153b10SEric Biggers static int test_aead_vs_generic_impl(const char *driver, 213540153b10SEric Biggers const struct alg_test_desc *test_desc, 213640153b10SEric Biggers struct aead_request *req, 213740153b10SEric Biggers struct cipher_test_sglists *tsgls) 213840153b10SEric Biggers { 213940153b10SEric Biggers struct crypto_aead *tfm = crypto_aead_reqtfm(req); 214040153b10SEric Biggers const unsigned int ivsize = crypto_aead_ivsize(tfm); 214140153b10SEric Biggers const unsigned int maxauthsize = crypto_aead_alg(tfm)->maxauthsize; 214240153b10SEric Biggers const unsigned int blocksize = crypto_aead_blocksize(tfm); 214340153b10SEric Biggers const unsigned int maxdatasize = (2 * PAGE_SIZE) - TESTMGR_POISON_LEN; 214440153b10SEric Biggers const char *algname = crypto_aead_alg(tfm)->base.cra_name; 214540153b10SEric Biggers const char *generic_driver = test_desc->generic_driver; 214640153b10SEric Biggers char _generic_driver[CRYPTO_MAX_ALG_NAME]; 214740153b10SEric Biggers struct crypto_aead *generic_tfm = NULL; 214840153b10SEric Biggers struct aead_request *generic_req = NULL; 214940153b10SEric Biggers unsigned int maxkeysize; 215040153b10SEric Biggers unsigned int i; 215140153b10SEric Biggers struct aead_testvec vec = { 0 }; 215240153b10SEric Biggers char vec_name[64]; 21536b5ca646SArnd Bergmann struct testvec_config *cfg; 215440153b10SEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 215540153b10SEric Biggers int err; 215640153b10SEric Biggers 215740153b10SEric Biggers if (noextratests) 215840153b10SEric Biggers return 0; 215940153b10SEric Biggers 216040153b10SEric Biggers if (!generic_driver) { /* Use default naming convention? */ 216140153b10SEric Biggers err = build_generic_driver_name(algname, _generic_driver); 216240153b10SEric Biggers if (err) 216340153b10SEric Biggers return err; 216440153b10SEric Biggers generic_driver = _generic_driver; 216540153b10SEric Biggers } 216640153b10SEric Biggers 216740153b10SEric Biggers if (strcmp(generic_driver, driver) == 0) /* Already the generic impl? */ 216840153b10SEric Biggers return 0; 216940153b10SEric Biggers 217040153b10SEric Biggers generic_tfm = crypto_alloc_aead(generic_driver, 0, 0); 217140153b10SEric Biggers if (IS_ERR(generic_tfm)) { 217240153b10SEric Biggers err = PTR_ERR(generic_tfm); 217340153b10SEric Biggers if (err == -ENOENT) { 217440153b10SEric Biggers pr_warn("alg: aead: skipping comparison tests for %s because %s is unavailable\n", 217540153b10SEric Biggers driver, generic_driver); 217640153b10SEric Biggers return 0; 217740153b10SEric Biggers } 217840153b10SEric Biggers pr_err("alg: aead: error allocating %s (generic impl of %s): %d\n", 217940153b10SEric Biggers generic_driver, algname, err); 218040153b10SEric Biggers return err; 218140153b10SEric Biggers } 218240153b10SEric Biggers 21836b5ca646SArnd Bergmann cfg = kzalloc(sizeof(*cfg), GFP_KERNEL); 21846b5ca646SArnd Bergmann if (!cfg) { 21856b5ca646SArnd Bergmann err = -ENOMEM; 21866b5ca646SArnd Bergmann goto out; 21876b5ca646SArnd Bergmann } 21886b5ca646SArnd Bergmann 218940153b10SEric Biggers generic_req = aead_request_alloc(generic_tfm, GFP_KERNEL); 219040153b10SEric Biggers if (!generic_req) { 219140153b10SEric Biggers err = -ENOMEM; 219240153b10SEric Biggers goto out; 219340153b10SEric Biggers } 219440153b10SEric Biggers 219540153b10SEric Biggers /* Check the algorithm properties for consistency. */ 219640153b10SEric Biggers 219740153b10SEric Biggers if (maxauthsize != crypto_aead_alg(generic_tfm)->maxauthsize) { 219840153b10SEric Biggers pr_err("alg: aead: maxauthsize for %s (%u) doesn't match generic impl (%u)\n", 219940153b10SEric Biggers driver, maxauthsize, 220040153b10SEric Biggers crypto_aead_alg(generic_tfm)->maxauthsize); 220140153b10SEric Biggers err = -EINVAL; 220240153b10SEric Biggers goto out; 220340153b10SEric Biggers } 220440153b10SEric Biggers 220540153b10SEric Biggers if (ivsize != crypto_aead_ivsize(generic_tfm)) { 220640153b10SEric Biggers pr_err("alg: aead: ivsize for %s (%u) doesn't match generic impl (%u)\n", 220740153b10SEric Biggers driver, ivsize, crypto_aead_ivsize(generic_tfm)); 220840153b10SEric Biggers err = -EINVAL; 220940153b10SEric Biggers goto out; 221040153b10SEric Biggers } 221140153b10SEric Biggers 221240153b10SEric Biggers if (blocksize != crypto_aead_blocksize(generic_tfm)) { 221340153b10SEric Biggers pr_err("alg: aead: blocksize for %s (%u) doesn't match generic impl (%u)\n", 221440153b10SEric Biggers driver, blocksize, crypto_aead_blocksize(generic_tfm)); 221540153b10SEric Biggers err = -EINVAL; 221640153b10SEric Biggers goto out; 221740153b10SEric Biggers } 221840153b10SEric Biggers 221940153b10SEric Biggers /* 222040153b10SEric Biggers * Now generate test vectors using the generic implementation, and test 222140153b10SEric Biggers * the other implementation against them. 222240153b10SEric Biggers */ 222340153b10SEric Biggers 222440153b10SEric Biggers maxkeysize = 0; 222540153b10SEric Biggers for (i = 0; i < test_desc->suite.aead.count; i++) 222640153b10SEric Biggers maxkeysize = max_t(unsigned int, maxkeysize, 222740153b10SEric Biggers test_desc->suite.aead.vecs[i].klen); 222840153b10SEric Biggers 222940153b10SEric Biggers vec.key = kmalloc(maxkeysize, GFP_KERNEL); 223040153b10SEric Biggers vec.iv = kmalloc(ivsize, GFP_KERNEL); 223140153b10SEric Biggers vec.assoc = kmalloc(maxdatasize, GFP_KERNEL); 223240153b10SEric Biggers vec.ptext = kmalloc(maxdatasize, GFP_KERNEL); 223340153b10SEric Biggers vec.ctext = kmalloc(maxdatasize, GFP_KERNEL); 223440153b10SEric Biggers if (!vec.key || !vec.iv || !vec.assoc || !vec.ptext || !vec.ctext) { 223540153b10SEric Biggers err = -ENOMEM; 223640153b10SEric Biggers goto out; 223740153b10SEric Biggers } 223840153b10SEric Biggers 223940153b10SEric Biggers for (i = 0; i < fuzz_iterations * 8; i++) { 224040153b10SEric Biggers generate_random_aead_testvec(generic_req, &vec, 224140153b10SEric Biggers maxkeysize, maxdatasize, 224240153b10SEric Biggers vec_name, sizeof(vec_name)); 22436b5ca646SArnd Bergmann generate_random_testvec_config(cfg, cfgname, sizeof(cfgname)); 224440153b10SEric Biggers 22456b5ca646SArnd Bergmann err = test_aead_vec_cfg(driver, ENCRYPT, &vec, vec_name, cfg, 224640153b10SEric Biggers req, tsgls); 224740153b10SEric Biggers if (err) 224840153b10SEric Biggers goto out; 2249eb455dbdSEric Biggers if (vec.crypt_error == 0) { 2250eb455dbdSEric Biggers err = test_aead_vec_cfg(driver, DECRYPT, &vec, vec_name, 2251eb455dbdSEric Biggers cfg, req, tsgls); 225240153b10SEric Biggers if (err) 225340153b10SEric Biggers goto out; 2254eb455dbdSEric Biggers } 225540153b10SEric Biggers cond_resched(); 225640153b10SEric Biggers } 225740153b10SEric Biggers err = 0; 225840153b10SEric Biggers out: 22596b5ca646SArnd Bergmann kfree(cfg); 226040153b10SEric Biggers kfree(vec.key); 226140153b10SEric Biggers kfree(vec.iv); 226240153b10SEric Biggers kfree(vec.assoc); 226340153b10SEric Biggers kfree(vec.ptext); 226440153b10SEric Biggers kfree(vec.ctext); 226540153b10SEric Biggers crypto_free_aead(generic_tfm); 226640153b10SEric Biggers aead_request_free(generic_req); 226740153b10SEric Biggers return err; 226840153b10SEric Biggers } 226940153b10SEric Biggers #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 227040153b10SEric Biggers static int test_aead_vs_generic_impl(const char *driver, 227140153b10SEric Biggers const struct alg_test_desc *test_desc, 227240153b10SEric Biggers struct aead_request *req, 227340153b10SEric Biggers struct cipher_test_sglists *tsgls) 227440153b10SEric Biggers { 227540153b10SEric Biggers return 0; 227640153b10SEric Biggers } 227740153b10SEric Biggers #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 227840153b10SEric Biggers 2279ed96804fSEric Biggers static int test_aead(const char *driver, int enc, 2280ed96804fSEric Biggers const struct aead_test_suite *suite, 2281ed96804fSEric Biggers struct aead_request *req, 2282ed96804fSEric Biggers struct cipher_test_sglists *tsgls) 2283ed96804fSEric Biggers { 2284ed96804fSEric Biggers unsigned int i; 2285ed96804fSEric Biggers int err; 2286ed96804fSEric Biggers 2287ed96804fSEric Biggers for (i = 0; i < suite->count; i++) { 2288ed96804fSEric Biggers err = test_aead_vec(driver, enc, &suite->vecs[i], i, req, 2289ed96804fSEric Biggers tsgls); 2290ed96804fSEric Biggers if (err) 2291ed96804fSEric Biggers return err; 2292e63e1b0dSEric Biggers cond_resched(); 2293ed96804fSEric Biggers } 2294ed96804fSEric Biggers return 0; 2295ed96804fSEric Biggers } 2296ed96804fSEric Biggers 2297ed96804fSEric Biggers static int alg_test_aead(const struct alg_test_desc *desc, const char *driver, 2298ed96804fSEric Biggers u32 type, u32 mask) 2299ed96804fSEric Biggers { 2300ed96804fSEric Biggers const struct aead_test_suite *suite = &desc->suite.aead; 2301ed96804fSEric Biggers struct crypto_aead *tfm; 2302ed96804fSEric Biggers struct aead_request *req = NULL; 2303ed96804fSEric Biggers struct cipher_test_sglists *tsgls = NULL; 2304ed96804fSEric Biggers int err; 2305ed96804fSEric Biggers 2306ed96804fSEric Biggers if (suite->count <= 0) { 2307ed96804fSEric Biggers pr_err("alg: aead: empty test suite for %s\n", driver); 2308ed96804fSEric Biggers return -EINVAL; 2309ed96804fSEric Biggers } 2310ed96804fSEric Biggers 2311ed96804fSEric Biggers tfm = crypto_alloc_aead(driver, type, mask); 2312ed96804fSEric Biggers if (IS_ERR(tfm)) { 2313ed96804fSEric Biggers pr_err("alg: aead: failed to allocate transform for %s: %ld\n", 2314ed96804fSEric Biggers driver, PTR_ERR(tfm)); 2315ed96804fSEric Biggers return PTR_ERR(tfm); 2316ed96804fSEric Biggers } 2317ed96804fSEric Biggers 2318ed96804fSEric Biggers req = aead_request_alloc(tfm, GFP_KERNEL); 2319ed96804fSEric Biggers if (!req) { 2320ed96804fSEric Biggers pr_err("alg: aead: failed to allocate request for %s\n", 2321ed96804fSEric Biggers driver); 2322ed96804fSEric Biggers err = -ENOMEM; 2323ed96804fSEric Biggers goto out; 2324ed96804fSEric Biggers } 2325ed96804fSEric Biggers 2326ed96804fSEric Biggers tsgls = alloc_cipher_test_sglists(); 2327ed96804fSEric Biggers if (!tsgls) { 2328ed96804fSEric Biggers pr_err("alg: aead: failed to allocate test buffers for %s\n", 2329ed96804fSEric Biggers driver); 2330ed96804fSEric Biggers err = -ENOMEM; 2331ed96804fSEric Biggers goto out; 2332ed96804fSEric Biggers } 2333ed96804fSEric Biggers 2334ed96804fSEric Biggers err = test_aead(driver, ENCRYPT, suite, req, tsgls); 2335ed96804fSEric Biggers if (err) 2336ed96804fSEric Biggers goto out; 2337ed96804fSEric Biggers 2338ed96804fSEric Biggers err = test_aead(driver, DECRYPT, suite, req, tsgls); 233940153b10SEric Biggers if (err) 234040153b10SEric Biggers goto out; 234140153b10SEric Biggers 234240153b10SEric Biggers err = test_aead_vs_generic_impl(driver, desc, req, tsgls); 2343ed96804fSEric Biggers out: 2344ed96804fSEric Biggers free_cipher_test_sglists(tsgls); 2345ed96804fSEric Biggers aead_request_free(req); 2346ed96804fSEric Biggers crypto_free_aead(tfm); 2347ed96804fSEric Biggers return err; 2348ed96804fSEric Biggers } 2349ed96804fSEric Biggers 23501aa4ecd9SHerbert Xu static int test_cipher(struct crypto_cipher *tfm, int enc, 2351b13b1e0cSEric Biggers const struct cipher_testvec *template, 2352b13b1e0cSEric Biggers unsigned int tcount) 23531aa4ecd9SHerbert Xu { 23541aa4ecd9SHerbert Xu const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm)); 23551aa4ecd9SHerbert Xu unsigned int i, j, k; 23561aa4ecd9SHerbert Xu char *q; 23571aa4ecd9SHerbert Xu const char *e; 235892a4c9feSEric Biggers const char *input, *result; 23591aa4ecd9SHerbert Xu void *data; 2360f8b0d4d0SHerbert Xu char *xbuf[XBUFSIZE]; 2361f8b0d4d0SHerbert Xu int ret = -ENOMEM; 2362f8b0d4d0SHerbert Xu 2363f8b0d4d0SHerbert Xu if (testmgr_alloc_buf(xbuf)) 2364f8b0d4d0SHerbert Xu goto out_nobuf; 23651aa4ecd9SHerbert Xu 23661aa4ecd9SHerbert Xu if (enc == ENCRYPT) 23671aa4ecd9SHerbert Xu e = "encryption"; 23681aa4ecd9SHerbert Xu else 23691aa4ecd9SHerbert Xu e = "decryption"; 23701aa4ecd9SHerbert Xu 23711aa4ecd9SHerbert Xu j = 0; 23721aa4ecd9SHerbert Xu for (i = 0; i < tcount; i++) { 23731aa4ecd9SHerbert Xu 237410faa8c0SStephan Mueller if (fips_enabled && template[i].fips_skip) 237510faa8c0SStephan Mueller continue; 237610faa8c0SStephan Mueller 237792a4c9feSEric Biggers input = enc ? template[i].ptext : template[i].ctext; 237892a4c9feSEric Biggers result = enc ? template[i].ctext : template[i].ptext; 23791aa4ecd9SHerbert Xu j++; 23801aa4ecd9SHerbert Xu 2381fd57f22aSHerbert Xu ret = -EINVAL; 238292a4c9feSEric Biggers if (WARN_ON(template[i].len > PAGE_SIZE)) 2383fd57f22aSHerbert Xu goto out; 2384fd57f22aSHerbert Xu 23851aa4ecd9SHerbert Xu data = xbuf[0]; 238692a4c9feSEric Biggers memcpy(data, input, template[i].len); 23871aa4ecd9SHerbert Xu 23881aa4ecd9SHerbert Xu crypto_cipher_clear_flags(tfm, ~0); 23891aa4ecd9SHerbert Xu if (template[i].wk) 2390231baecdSEric Biggers crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 23911aa4ecd9SHerbert Xu 23921aa4ecd9SHerbert Xu ret = crypto_cipher_setkey(tfm, template[i].key, 23931aa4ecd9SHerbert Xu template[i].klen); 23945283a8eeSEric Biggers if (ret) { 23955283a8eeSEric Biggers if (ret == template[i].setkey_error) 23961aa4ecd9SHerbert Xu continue; 23975283a8eeSEric Biggers pr_err("alg: cipher: %s setkey failed on test vector %u; expected_error=%d, actual_error=%d, flags=%#x\n", 23985283a8eeSEric Biggers algo, j, template[i].setkey_error, ret, 23995283a8eeSEric Biggers crypto_cipher_get_flags(tfm)); 24005283a8eeSEric Biggers goto out; 24015283a8eeSEric Biggers } 24025283a8eeSEric Biggers if (template[i].setkey_error) { 24035283a8eeSEric Biggers pr_err("alg: cipher: %s setkey unexpectedly succeeded on test vector %u; expected_error=%d\n", 24045283a8eeSEric Biggers algo, j, template[i].setkey_error); 24055283a8eeSEric Biggers ret = -EINVAL; 24065283a8eeSEric Biggers goto out; 24075283a8eeSEric Biggers } 24081aa4ecd9SHerbert Xu 240992a4c9feSEric Biggers for (k = 0; k < template[i].len; 24101aa4ecd9SHerbert Xu k += crypto_cipher_blocksize(tfm)) { 24111aa4ecd9SHerbert Xu if (enc) 24121aa4ecd9SHerbert Xu crypto_cipher_encrypt_one(tfm, data + k, 24131aa4ecd9SHerbert Xu data + k); 24141aa4ecd9SHerbert Xu else 24151aa4ecd9SHerbert Xu crypto_cipher_decrypt_one(tfm, data + k, 24161aa4ecd9SHerbert Xu data + k); 24171aa4ecd9SHerbert Xu } 24181aa4ecd9SHerbert Xu 24191aa4ecd9SHerbert Xu q = data; 242092a4c9feSEric Biggers if (memcmp(q, result, template[i].len)) { 24211aa4ecd9SHerbert Xu printk(KERN_ERR "alg: cipher: Test %d failed " 24221aa4ecd9SHerbert Xu "on %s for %s\n", j, e, algo); 242392a4c9feSEric Biggers hexdump(q, template[i].len); 24241aa4ecd9SHerbert Xu ret = -EINVAL; 24251aa4ecd9SHerbert Xu goto out; 24261aa4ecd9SHerbert Xu } 24271aa4ecd9SHerbert Xu } 24281aa4ecd9SHerbert Xu 24291aa4ecd9SHerbert Xu ret = 0; 24301aa4ecd9SHerbert Xu 24311aa4ecd9SHerbert Xu out: 2432f8b0d4d0SHerbert Xu testmgr_free_buf(xbuf); 2433f8b0d4d0SHerbert Xu out_nobuf: 24341aa4ecd9SHerbert Xu return ret; 24351aa4ecd9SHerbert Xu } 24361aa4ecd9SHerbert Xu 24374e7babbaSEric Biggers static int test_skcipher_vec_cfg(const char *driver, int enc, 24384e7babbaSEric Biggers const struct cipher_testvec *vec, 2439951d1332SEric Biggers const char *vec_name, 24404e7babbaSEric Biggers const struct testvec_config *cfg, 24414e7babbaSEric Biggers struct skcipher_request *req, 24424e7babbaSEric Biggers struct cipher_test_sglists *tsgls) 2443da7f033dSHerbert Xu { 24444e7babbaSEric Biggers struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 24454e7babbaSEric Biggers const unsigned int alignmask = crypto_skcipher_alignmask(tfm); 24464e7babbaSEric Biggers const unsigned int ivsize = crypto_skcipher_ivsize(tfm); 24474e7babbaSEric Biggers const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags; 24484e7babbaSEric Biggers const char *op = enc ? "encryption" : "decryption"; 24494e7babbaSEric Biggers DECLARE_CRYPTO_WAIT(wait); 24504e7babbaSEric Biggers u8 _iv[3 * (MAX_ALGAPI_ALIGNMASK + 1) + MAX_IVLEN]; 24514e7babbaSEric Biggers u8 *iv = PTR_ALIGN(&_iv[0], 2 * (MAX_ALGAPI_ALIGNMASK + 1)) + 24524e7babbaSEric Biggers cfg->iv_offset + 24534e7babbaSEric Biggers (cfg->iv_offset_relative_to_alignmask ? alignmask : 0); 24544e7babbaSEric Biggers struct kvec input; 24554e7babbaSEric Biggers int err; 2456f8b0d4d0SHerbert Xu 24574e7babbaSEric Biggers /* Set the key */ 24584e7babbaSEric Biggers if (vec->wk) 2459231baecdSEric Biggers crypto_skcipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 2460da7f033dSHerbert Xu else 24614e7babbaSEric Biggers crypto_skcipher_clear_flags(tfm, 24624e7babbaSEric Biggers CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 24634e7babbaSEric Biggers err = crypto_skcipher_setkey(tfm, vec->key, vec->klen); 24644e7babbaSEric Biggers if (err) { 24655283a8eeSEric Biggers if (err == vec->setkey_error) 24664e7babbaSEric Biggers return 0; 2467951d1332SEric Biggers pr_err("alg: skcipher: %s setkey failed on test vector %s; expected_error=%d, actual_error=%d, flags=%#x\n", 2468951d1332SEric Biggers driver, vec_name, vec->setkey_error, err, 24695283a8eeSEric Biggers crypto_skcipher_get_flags(tfm)); 24704e7babbaSEric Biggers return err; 24714e7babbaSEric Biggers } 24725283a8eeSEric Biggers if (vec->setkey_error) { 2473951d1332SEric Biggers pr_err("alg: skcipher: %s setkey unexpectedly succeeded on test vector %s; expected_error=%d\n", 2474951d1332SEric Biggers driver, vec_name, vec->setkey_error); 24754e7babbaSEric Biggers return -EINVAL; 247608d6af8cSJussi Kivilinna } 2477da7f033dSHerbert Xu 24784e7babbaSEric Biggers /* The IV must be copied to a buffer, as the algorithm may modify it */ 24794e7babbaSEric Biggers if (ivsize) { 24804e7babbaSEric Biggers if (WARN_ON(ivsize > MAX_IVLEN)) 24814e7babbaSEric Biggers return -EINVAL; 24828efd972eSEric Biggers if (vec->generates_iv && !enc) 24838efd972eSEric Biggers memcpy(iv, vec->iv_out, ivsize); 24848efd972eSEric Biggers else if (vec->iv) 24854e7babbaSEric Biggers memcpy(iv, vec->iv, ivsize); 248608d6af8cSJussi Kivilinna else 24874e7babbaSEric Biggers memset(iv, 0, ivsize); 24884e7babbaSEric Biggers } else { 24894e7babbaSEric Biggers if (vec->generates_iv) { 2490951d1332SEric Biggers pr_err("alg: skcipher: %s has ivsize=0 but test vector %s generates IV!\n", 2491951d1332SEric Biggers driver, vec_name); 24924e7babbaSEric Biggers return -EINVAL; 24934e7babbaSEric Biggers } 24944e7babbaSEric Biggers iv = NULL; 2495da7f033dSHerbert Xu } 2496da7f033dSHerbert Xu 24974e7babbaSEric Biggers /* Build the src/dst scatterlists */ 24984e7babbaSEric Biggers input.iov_base = enc ? (void *)vec->ptext : (void *)vec->ctext; 24994e7babbaSEric Biggers input.iov_len = vec->len; 25004e7babbaSEric Biggers err = build_cipher_test_sglists(tsgls, cfg, alignmask, 25014e7babbaSEric Biggers vec->len, vec->len, &input, 1); 25024e7babbaSEric Biggers if (err) { 2503951d1332SEric Biggers pr_err("alg: skcipher: %s %s: error preparing scatterlists for test vector %s, cfg=\"%s\"\n", 2504951d1332SEric Biggers driver, op, vec_name, cfg->name); 25054e7babbaSEric Biggers return err; 2506da7f033dSHerbert Xu } 2507da7f033dSHerbert Xu 25084e7babbaSEric Biggers /* Do the actual encryption or decryption */ 25094e7babbaSEric Biggers testmgr_poison(req->__ctx, crypto_skcipher_reqsize(tfm)); 25104e7babbaSEric Biggers skcipher_request_set_callback(req, req_flags, crypto_req_done, &wait); 25114e7babbaSEric Biggers skcipher_request_set_crypt(req, tsgls->src.sgl_ptr, tsgls->dst.sgl_ptr, 25124e7babbaSEric Biggers vec->len, iv); 25136570737cSEric Biggers if (cfg->nosimd) 25146570737cSEric Biggers crypto_disable_simd_for_test(); 25156570737cSEric Biggers err = enc ? crypto_skcipher_encrypt(req) : crypto_skcipher_decrypt(req); 25166570737cSEric Biggers if (cfg->nosimd) 25176570737cSEric Biggers crypto_reenable_simd_for_test(); 25186570737cSEric Biggers err = crypto_wait_req(err, &wait); 2519da7f033dSHerbert Xu 2520fa353c99SEric Biggers /* Check that the algorithm didn't overwrite things it shouldn't have */ 2521fa353c99SEric Biggers if (req->cryptlen != vec->len || 2522fa353c99SEric Biggers req->iv != iv || 2523fa353c99SEric Biggers req->src != tsgls->src.sgl_ptr || 2524fa353c99SEric Biggers req->dst != tsgls->dst.sgl_ptr || 2525fa353c99SEric Biggers crypto_skcipher_reqtfm(req) != tfm || 2526fa353c99SEric Biggers req->base.complete != crypto_req_done || 2527fa353c99SEric Biggers req->base.flags != req_flags || 2528fa353c99SEric Biggers req->base.data != &wait) { 2529951d1332SEric Biggers pr_err("alg: skcipher: %s %s corrupted request struct on test vector %s, cfg=\"%s\"\n", 2530951d1332SEric Biggers driver, op, vec_name, cfg->name); 2531fa353c99SEric Biggers if (req->cryptlen != vec->len) 2532fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->cryptlen'\n"); 2533fa353c99SEric Biggers if (req->iv != iv) 2534fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->iv'\n"); 2535fa353c99SEric Biggers if (req->src != tsgls->src.sgl_ptr) 2536fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->src'\n"); 2537fa353c99SEric Biggers if (req->dst != tsgls->dst.sgl_ptr) 2538fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->dst'\n"); 2539fa353c99SEric Biggers if (crypto_skcipher_reqtfm(req) != tfm) 2540fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.tfm'\n"); 2541fa353c99SEric Biggers if (req->base.complete != crypto_req_done) 2542fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.complete'\n"); 2543fa353c99SEric Biggers if (req->base.flags != req_flags) 2544fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.flags'\n"); 2545fa353c99SEric Biggers if (req->base.data != &wait) 2546fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.data'\n"); 2547fa353c99SEric Biggers return -EINVAL; 2548fa353c99SEric Biggers } 2549fa353c99SEric Biggers if (is_test_sglist_corrupted(&tsgls->src)) { 2550951d1332SEric Biggers pr_err("alg: skcipher: %s %s corrupted src sgl on test vector %s, cfg=\"%s\"\n", 2551951d1332SEric Biggers driver, op, vec_name, cfg->name); 2552fa353c99SEric Biggers return -EINVAL; 2553fa353c99SEric Biggers } 2554fa353c99SEric Biggers if (tsgls->dst.sgl_ptr != tsgls->src.sgl && 2555fa353c99SEric Biggers is_test_sglist_corrupted(&tsgls->dst)) { 2556951d1332SEric Biggers pr_err("alg: skcipher: %s %s corrupted dst sgl on test vector %s, cfg=\"%s\"\n", 2557951d1332SEric Biggers driver, op, vec_name, cfg->name); 2558fa353c99SEric Biggers return -EINVAL; 2559fa353c99SEric Biggers } 2560fa353c99SEric Biggers 25615283a8eeSEric Biggers /* Check for success or failure */ 25625283a8eeSEric Biggers if (err) { 25635283a8eeSEric Biggers if (err == vec->crypt_error) 25645283a8eeSEric Biggers return 0; 2565951d1332SEric Biggers pr_err("alg: skcipher: %s %s failed on test vector %s; expected_error=%d, actual_error=%d, cfg=\"%s\"\n", 2566951d1332SEric Biggers driver, op, vec_name, vec->crypt_error, err, cfg->name); 25675283a8eeSEric Biggers return err; 25685283a8eeSEric Biggers } 25695283a8eeSEric Biggers if (vec->crypt_error) { 2570951d1332SEric Biggers pr_err("alg: skcipher: %s %s unexpectedly succeeded on test vector %s; expected_error=%d, cfg=\"%s\"\n", 2571951d1332SEric Biggers driver, op, vec_name, vec->crypt_error, cfg->name); 25725283a8eeSEric Biggers return -EINVAL; 25735283a8eeSEric Biggers } 25745283a8eeSEric Biggers 25754e7babbaSEric Biggers /* Check for the correct output (ciphertext or plaintext) */ 25764e7babbaSEric Biggers err = verify_correct_output(&tsgls->dst, enc ? vec->ctext : vec->ptext, 25774e7babbaSEric Biggers vec->len, 0, true); 25784e7babbaSEric Biggers if (err == -EOVERFLOW) { 2579951d1332SEric Biggers pr_err("alg: skcipher: %s %s overran dst buffer on test vector %s, cfg=\"%s\"\n", 2580951d1332SEric Biggers driver, op, vec_name, cfg->name); 25814e7babbaSEric Biggers return err; 25824e7babbaSEric Biggers } 25834e7babbaSEric Biggers if (err) { 2584951d1332SEric Biggers pr_err("alg: skcipher: %s %s test failed (wrong result) on test vector %s, cfg=\"%s\"\n", 2585951d1332SEric Biggers driver, op, vec_name, cfg->name); 25864e7babbaSEric Biggers return err; 25874e7babbaSEric Biggers } 258808d6af8cSJussi Kivilinna 25894e7babbaSEric Biggers /* If applicable, check that the algorithm generated the correct IV */ 25908efd972eSEric Biggers if (vec->iv_out && memcmp(iv, vec->iv_out, ivsize) != 0) { 2591951d1332SEric Biggers pr_err("alg: skcipher: %s %s test failed (wrong output IV) on test vector %s, cfg=\"%s\"\n", 2592951d1332SEric Biggers driver, op, vec_name, cfg->name); 25934e7babbaSEric Biggers hexdump(iv, ivsize); 25944e7babbaSEric Biggers return -EINVAL; 25953a338f20SJussi Kivilinna } 25963a338f20SJussi Kivilinna 25973a338f20SJussi Kivilinna return 0; 259808d6af8cSJussi Kivilinna } 259908d6af8cSJussi Kivilinna 26004e7babbaSEric Biggers static int test_skcipher_vec(const char *driver, int enc, 26014e7babbaSEric Biggers const struct cipher_testvec *vec, 26024e7babbaSEric Biggers unsigned int vec_num, 26034e7babbaSEric Biggers struct skcipher_request *req, 26044e7babbaSEric Biggers struct cipher_test_sglists *tsgls) 26054e7babbaSEric Biggers { 2606951d1332SEric Biggers char vec_name[16]; 26074e7babbaSEric Biggers unsigned int i; 26084e7babbaSEric Biggers int err; 26094e7babbaSEric Biggers 26104e7babbaSEric Biggers if (fips_enabled && vec->fips_skip) 26114e7babbaSEric Biggers return 0; 26124e7babbaSEric Biggers 2613951d1332SEric Biggers sprintf(vec_name, "%u", vec_num); 2614951d1332SEric Biggers 26154e7babbaSEric Biggers for (i = 0; i < ARRAY_SIZE(default_cipher_testvec_configs); i++) { 2616951d1332SEric Biggers err = test_skcipher_vec_cfg(driver, enc, vec, vec_name, 26174e7babbaSEric Biggers &default_cipher_testvec_configs[i], 26184e7babbaSEric Biggers req, tsgls); 26194e7babbaSEric Biggers if (err) 26204e7babbaSEric Biggers return err; 26214e7babbaSEric Biggers } 26224e7babbaSEric Biggers 26234e7babbaSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 26244e7babbaSEric Biggers if (!noextratests) { 26254e7babbaSEric Biggers struct testvec_config cfg; 26264e7babbaSEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 26274e7babbaSEric Biggers 26284e7babbaSEric Biggers for (i = 0; i < fuzz_iterations; i++) { 26294e7babbaSEric Biggers generate_random_testvec_config(&cfg, cfgname, 26304e7babbaSEric Biggers sizeof(cfgname)); 2631951d1332SEric Biggers err = test_skcipher_vec_cfg(driver, enc, vec, vec_name, 26324e7babbaSEric Biggers &cfg, req, tsgls); 26334e7babbaSEric Biggers if (err) 26344e7babbaSEric Biggers return err; 2635e63e1b0dSEric Biggers cond_resched(); 26364e7babbaSEric Biggers } 26374e7babbaSEric Biggers } 26384e7babbaSEric Biggers #endif 26394e7babbaSEric Biggers return 0; 26404e7babbaSEric Biggers } 26414e7babbaSEric Biggers 2642d435e10eSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 2643d435e10eSEric Biggers /* 2644d435e10eSEric Biggers * Generate a symmetric cipher test vector from the given implementation. 2645d435e10eSEric Biggers * Assumes the buffers in 'vec' were already allocated. 2646d435e10eSEric Biggers */ 2647d435e10eSEric Biggers static void generate_random_cipher_testvec(struct skcipher_request *req, 2648d435e10eSEric Biggers struct cipher_testvec *vec, 2649d435e10eSEric Biggers unsigned int maxdatasize, 2650d435e10eSEric Biggers char *name, size_t max_namelen) 2651d435e10eSEric Biggers { 2652d435e10eSEric Biggers struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 26539ac0d136SEric Biggers const unsigned int maxkeysize = crypto_skcipher_max_keysize(tfm); 2654d435e10eSEric Biggers const unsigned int ivsize = crypto_skcipher_ivsize(tfm); 2655d435e10eSEric Biggers struct scatterlist src, dst; 2656d435e10eSEric Biggers u8 iv[MAX_IVLEN]; 2657d435e10eSEric Biggers DECLARE_CRYPTO_WAIT(wait); 2658d435e10eSEric Biggers 2659d435e10eSEric Biggers /* Key: length in [0, maxkeysize], but usually choose maxkeysize */ 2660d435e10eSEric Biggers vec->klen = maxkeysize; 2661d435e10eSEric Biggers if (prandom_u32() % 4 == 0) 2662d435e10eSEric Biggers vec->klen = prandom_u32() % (maxkeysize + 1); 2663d435e10eSEric Biggers generate_random_bytes((u8 *)vec->key, vec->klen); 2664d435e10eSEric Biggers vec->setkey_error = crypto_skcipher_setkey(tfm, vec->key, vec->klen); 2665d435e10eSEric Biggers 2666d435e10eSEric Biggers /* IV */ 2667d435e10eSEric Biggers generate_random_bytes((u8 *)vec->iv, ivsize); 2668d435e10eSEric Biggers 2669d435e10eSEric Biggers /* Plaintext */ 2670d435e10eSEric Biggers vec->len = generate_random_length(maxdatasize); 2671d435e10eSEric Biggers generate_random_bytes((u8 *)vec->ptext, vec->len); 2672d435e10eSEric Biggers 2673d435e10eSEric Biggers /* If the key couldn't be set, no need to continue to encrypt. */ 2674d435e10eSEric Biggers if (vec->setkey_error) 2675d435e10eSEric Biggers goto done; 2676d435e10eSEric Biggers 2677d435e10eSEric Biggers /* Ciphertext */ 2678d435e10eSEric Biggers sg_init_one(&src, vec->ptext, vec->len); 2679d435e10eSEric Biggers sg_init_one(&dst, vec->ctext, vec->len); 2680d435e10eSEric Biggers memcpy(iv, vec->iv, ivsize); 2681d435e10eSEric Biggers skcipher_request_set_callback(req, 0, crypto_req_done, &wait); 2682d435e10eSEric Biggers skcipher_request_set_crypt(req, &src, &dst, vec->len, iv); 2683d435e10eSEric Biggers vec->crypt_error = crypto_wait_req(crypto_skcipher_encrypt(req), &wait); 2684eb455dbdSEric Biggers if (vec->crypt_error != 0) { 2685eb455dbdSEric Biggers /* 2686eb455dbdSEric Biggers * The only acceptable error here is for an invalid length, so 2687eb455dbdSEric Biggers * skcipher decryption should fail with the same error too. 2688eb455dbdSEric Biggers * We'll test for this. But to keep the API usage well-defined, 2689eb455dbdSEric Biggers * explicitly initialize the ciphertext buffer too. 2690eb455dbdSEric Biggers */ 2691eb455dbdSEric Biggers memset((u8 *)vec->ctext, 0, vec->len); 2692eb455dbdSEric Biggers } 2693d435e10eSEric Biggers done: 2694d435e10eSEric Biggers snprintf(name, max_namelen, "\"random: len=%u klen=%u\"", 2695d435e10eSEric Biggers vec->len, vec->klen); 2696d435e10eSEric Biggers } 2697d435e10eSEric Biggers 2698d435e10eSEric Biggers /* 2699d435e10eSEric Biggers * Test the skcipher algorithm represented by @req against the corresponding 2700d435e10eSEric Biggers * generic implementation, if one is available. 2701d435e10eSEric Biggers */ 2702d435e10eSEric Biggers static int test_skcipher_vs_generic_impl(const char *driver, 2703d435e10eSEric Biggers const char *generic_driver, 2704d435e10eSEric Biggers struct skcipher_request *req, 2705d435e10eSEric Biggers struct cipher_test_sglists *tsgls) 2706d435e10eSEric Biggers { 2707d435e10eSEric Biggers struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 27089ac0d136SEric Biggers const unsigned int maxkeysize = crypto_skcipher_max_keysize(tfm); 2709d435e10eSEric Biggers const unsigned int ivsize = crypto_skcipher_ivsize(tfm); 2710d435e10eSEric Biggers const unsigned int blocksize = crypto_skcipher_blocksize(tfm); 2711d435e10eSEric Biggers const unsigned int maxdatasize = (2 * PAGE_SIZE) - TESTMGR_POISON_LEN; 2712d435e10eSEric Biggers const char *algname = crypto_skcipher_alg(tfm)->base.cra_name; 2713d435e10eSEric Biggers char _generic_driver[CRYPTO_MAX_ALG_NAME]; 2714d435e10eSEric Biggers struct crypto_skcipher *generic_tfm = NULL; 2715d435e10eSEric Biggers struct skcipher_request *generic_req = NULL; 2716d435e10eSEric Biggers unsigned int i; 2717d435e10eSEric Biggers struct cipher_testvec vec = { 0 }; 2718d435e10eSEric Biggers char vec_name[64]; 27196b5ca646SArnd Bergmann struct testvec_config *cfg; 2720d435e10eSEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 2721d435e10eSEric Biggers int err; 2722d435e10eSEric Biggers 2723d435e10eSEric Biggers if (noextratests) 2724d435e10eSEric Biggers return 0; 2725d435e10eSEric Biggers 2726d435e10eSEric Biggers /* Keywrap isn't supported here yet as it handles its IV differently. */ 2727d435e10eSEric Biggers if (strncmp(algname, "kw(", 3) == 0) 2728d435e10eSEric Biggers return 0; 2729d435e10eSEric Biggers 2730d435e10eSEric Biggers if (!generic_driver) { /* Use default naming convention? */ 2731d435e10eSEric Biggers err = build_generic_driver_name(algname, _generic_driver); 2732d435e10eSEric Biggers if (err) 2733d435e10eSEric Biggers return err; 2734d435e10eSEric Biggers generic_driver = _generic_driver; 2735d435e10eSEric Biggers } 2736d435e10eSEric Biggers 2737d435e10eSEric Biggers if (strcmp(generic_driver, driver) == 0) /* Already the generic impl? */ 2738d435e10eSEric Biggers return 0; 2739d435e10eSEric Biggers 2740d435e10eSEric Biggers generic_tfm = crypto_alloc_skcipher(generic_driver, 0, 0); 2741d435e10eSEric Biggers if (IS_ERR(generic_tfm)) { 2742d435e10eSEric Biggers err = PTR_ERR(generic_tfm); 2743d435e10eSEric Biggers if (err == -ENOENT) { 2744d435e10eSEric Biggers pr_warn("alg: skcipher: skipping comparison tests for %s because %s is unavailable\n", 2745d435e10eSEric Biggers driver, generic_driver); 2746d435e10eSEric Biggers return 0; 2747d435e10eSEric Biggers } 2748d435e10eSEric Biggers pr_err("alg: skcipher: error allocating %s (generic impl of %s): %d\n", 2749d435e10eSEric Biggers generic_driver, algname, err); 2750d435e10eSEric Biggers return err; 2751d435e10eSEric Biggers } 2752d435e10eSEric Biggers 27536b5ca646SArnd Bergmann cfg = kzalloc(sizeof(*cfg), GFP_KERNEL); 27546b5ca646SArnd Bergmann if (!cfg) { 27556b5ca646SArnd Bergmann err = -ENOMEM; 27566b5ca646SArnd Bergmann goto out; 27576b5ca646SArnd Bergmann } 27586b5ca646SArnd Bergmann 2759d435e10eSEric Biggers generic_req = skcipher_request_alloc(generic_tfm, GFP_KERNEL); 2760d435e10eSEric Biggers if (!generic_req) { 2761d435e10eSEric Biggers err = -ENOMEM; 2762d435e10eSEric Biggers goto out; 2763d435e10eSEric Biggers } 2764d435e10eSEric Biggers 2765d435e10eSEric Biggers /* Check the algorithm properties for consistency. */ 2766d435e10eSEric Biggers 2767fd60f727SEric Biggers if (crypto_skcipher_min_keysize(tfm) != 2768fd60f727SEric Biggers crypto_skcipher_min_keysize(generic_tfm)) { 2769fd60f727SEric Biggers pr_err("alg: skcipher: min keysize for %s (%u) doesn't match generic impl (%u)\n", 2770fd60f727SEric Biggers driver, crypto_skcipher_min_keysize(tfm), 2771fd60f727SEric Biggers crypto_skcipher_min_keysize(generic_tfm)); 2772fd60f727SEric Biggers err = -EINVAL; 2773fd60f727SEric Biggers goto out; 2774fd60f727SEric Biggers } 2775fd60f727SEric Biggers 27769ac0d136SEric Biggers if (maxkeysize != crypto_skcipher_max_keysize(generic_tfm)) { 2777d435e10eSEric Biggers pr_err("alg: skcipher: max keysize for %s (%u) doesn't match generic impl (%u)\n", 27789ac0d136SEric Biggers driver, maxkeysize, 27799ac0d136SEric Biggers crypto_skcipher_max_keysize(generic_tfm)); 2780d435e10eSEric Biggers err = -EINVAL; 2781d435e10eSEric Biggers goto out; 2782d435e10eSEric Biggers } 2783d435e10eSEric Biggers 2784d435e10eSEric Biggers if (ivsize != crypto_skcipher_ivsize(generic_tfm)) { 2785d435e10eSEric Biggers pr_err("alg: skcipher: ivsize for %s (%u) doesn't match generic impl (%u)\n", 2786d435e10eSEric Biggers driver, ivsize, crypto_skcipher_ivsize(generic_tfm)); 2787d435e10eSEric Biggers err = -EINVAL; 2788d435e10eSEric Biggers goto out; 2789d435e10eSEric Biggers } 2790d435e10eSEric Biggers 2791d435e10eSEric Biggers if (blocksize != crypto_skcipher_blocksize(generic_tfm)) { 2792d435e10eSEric Biggers pr_err("alg: skcipher: blocksize for %s (%u) doesn't match generic impl (%u)\n", 2793d435e10eSEric Biggers driver, blocksize, 2794d435e10eSEric Biggers crypto_skcipher_blocksize(generic_tfm)); 2795d435e10eSEric Biggers err = -EINVAL; 2796d435e10eSEric Biggers goto out; 2797d435e10eSEric Biggers } 2798d435e10eSEric Biggers 2799d435e10eSEric Biggers /* 2800d435e10eSEric Biggers * Now generate test vectors using the generic implementation, and test 2801d435e10eSEric Biggers * the other implementation against them. 2802d435e10eSEric Biggers */ 2803d435e10eSEric Biggers 28049ac0d136SEric Biggers vec.key = kmalloc(maxkeysize, GFP_KERNEL); 2805d435e10eSEric Biggers vec.iv = kmalloc(ivsize, GFP_KERNEL); 2806d435e10eSEric Biggers vec.ptext = kmalloc(maxdatasize, GFP_KERNEL); 2807d435e10eSEric Biggers vec.ctext = kmalloc(maxdatasize, GFP_KERNEL); 2808d435e10eSEric Biggers if (!vec.key || !vec.iv || !vec.ptext || !vec.ctext) { 2809d435e10eSEric Biggers err = -ENOMEM; 2810d435e10eSEric Biggers goto out; 2811d435e10eSEric Biggers } 2812d435e10eSEric Biggers 2813d435e10eSEric Biggers for (i = 0; i < fuzz_iterations * 8; i++) { 2814d435e10eSEric Biggers generate_random_cipher_testvec(generic_req, &vec, maxdatasize, 2815d435e10eSEric Biggers vec_name, sizeof(vec_name)); 28166b5ca646SArnd Bergmann generate_random_testvec_config(cfg, cfgname, sizeof(cfgname)); 2817d435e10eSEric Biggers 2818d435e10eSEric Biggers err = test_skcipher_vec_cfg(driver, ENCRYPT, &vec, vec_name, 28196b5ca646SArnd Bergmann cfg, req, tsgls); 2820d435e10eSEric Biggers if (err) 2821d435e10eSEric Biggers goto out; 2822d435e10eSEric Biggers err = test_skcipher_vec_cfg(driver, DECRYPT, &vec, vec_name, 28236b5ca646SArnd Bergmann cfg, req, tsgls); 2824d435e10eSEric Biggers if (err) 2825d435e10eSEric Biggers goto out; 2826d435e10eSEric Biggers cond_resched(); 2827d435e10eSEric Biggers } 2828d435e10eSEric Biggers err = 0; 2829d435e10eSEric Biggers out: 28306b5ca646SArnd Bergmann kfree(cfg); 2831d435e10eSEric Biggers kfree(vec.key); 2832d435e10eSEric Biggers kfree(vec.iv); 2833d435e10eSEric Biggers kfree(vec.ptext); 2834d435e10eSEric Biggers kfree(vec.ctext); 2835d435e10eSEric Biggers crypto_free_skcipher(generic_tfm); 2836d435e10eSEric Biggers skcipher_request_free(generic_req); 2837d435e10eSEric Biggers return err; 2838d435e10eSEric Biggers } 2839d435e10eSEric Biggers #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 2840d435e10eSEric Biggers static int test_skcipher_vs_generic_impl(const char *driver, 2841d435e10eSEric Biggers const char *generic_driver, 2842d435e10eSEric Biggers struct skcipher_request *req, 2843d435e10eSEric Biggers struct cipher_test_sglists *tsgls) 2844d435e10eSEric Biggers { 2845d435e10eSEric Biggers return 0; 2846d435e10eSEric Biggers } 2847d435e10eSEric Biggers #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 2848d435e10eSEric Biggers 28494e7babbaSEric Biggers static int test_skcipher(const char *driver, int enc, 28504e7babbaSEric Biggers const struct cipher_test_suite *suite, 28514e7babbaSEric Biggers struct skcipher_request *req, 28524e7babbaSEric Biggers struct cipher_test_sglists *tsgls) 28534e7babbaSEric Biggers { 28544e7babbaSEric Biggers unsigned int i; 28554e7babbaSEric Biggers int err; 28564e7babbaSEric Biggers 28574e7babbaSEric Biggers for (i = 0; i < suite->count; i++) { 28584e7babbaSEric Biggers err = test_skcipher_vec(driver, enc, &suite->vecs[i], i, req, 28594e7babbaSEric Biggers tsgls); 28604e7babbaSEric Biggers if (err) 28614e7babbaSEric Biggers return err; 2862e63e1b0dSEric Biggers cond_resched(); 28634e7babbaSEric Biggers } 28644e7babbaSEric Biggers return 0; 28654e7babbaSEric Biggers } 28664e7babbaSEric Biggers 28674e7babbaSEric Biggers static int alg_test_skcipher(const struct alg_test_desc *desc, 28684e7babbaSEric Biggers const char *driver, u32 type, u32 mask) 28694e7babbaSEric Biggers { 28704e7babbaSEric Biggers const struct cipher_test_suite *suite = &desc->suite.cipher; 28714e7babbaSEric Biggers struct crypto_skcipher *tfm; 28724e7babbaSEric Biggers struct skcipher_request *req = NULL; 28734e7babbaSEric Biggers struct cipher_test_sglists *tsgls = NULL; 28744e7babbaSEric Biggers int err; 28754e7babbaSEric Biggers 28764e7babbaSEric Biggers if (suite->count <= 0) { 28774e7babbaSEric Biggers pr_err("alg: skcipher: empty test suite for %s\n", driver); 28784e7babbaSEric Biggers return -EINVAL; 28794e7babbaSEric Biggers } 28804e7babbaSEric Biggers 28814e7babbaSEric Biggers tfm = crypto_alloc_skcipher(driver, type, mask); 28824e7babbaSEric Biggers if (IS_ERR(tfm)) { 28834e7babbaSEric Biggers pr_err("alg: skcipher: failed to allocate transform for %s: %ld\n", 28844e7babbaSEric Biggers driver, PTR_ERR(tfm)); 28854e7babbaSEric Biggers return PTR_ERR(tfm); 28864e7babbaSEric Biggers } 28874e7babbaSEric Biggers 28884e7babbaSEric Biggers req = skcipher_request_alloc(tfm, GFP_KERNEL); 28894e7babbaSEric Biggers if (!req) { 28904e7babbaSEric Biggers pr_err("alg: skcipher: failed to allocate request for %s\n", 28914e7babbaSEric Biggers driver); 28924e7babbaSEric Biggers err = -ENOMEM; 28934e7babbaSEric Biggers goto out; 28944e7babbaSEric Biggers } 28954e7babbaSEric Biggers 28964e7babbaSEric Biggers tsgls = alloc_cipher_test_sglists(); 28974e7babbaSEric Biggers if (!tsgls) { 28984e7babbaSEric Biggers pr_err("alg: skcipher: failed to allocate test buffers for %s\n", 28994e7babbaSEric Biggers driver); 29004e7babbaSEric Biggers err = -ENOMEM; 29014e7babbaSEric Biggers goto out; 29024e7babbaSEric Biggers } 29034e7babbaSEric Biggers 29044e7babbaSEric Biggers err = test_skcipher(driver, ENCRYPT, suite, req, tsgls); 29054e7babbaSEric Biggers if (err) 29064e7babbaSEric Biggers goto out; 29074e7babbaSEric Biggers 29084e7babbaSEric Biggers err = test_skcipher(driver, DECRYPT, suite, req, tsgls); 2909d435e10eSEric Biggers if (err) 2910d435e10eSEric Biggers goto out; 2911d435e10eSEric Biggers 2912d435e10eSEric Biggers err = test_skcipher_vs_generic_impl(driver, desc->generic_driver, req, 2913d435e10eSEric Biggers tsgls); 29144e7babbaSEric Biggers out: 29154e7babbaSEric Biggers free_cipher_test_sglists(tsgls); 29164e7babbaSEric Biggers skcipher_request_free(req); 29174e7babbaSEric Biggers crypto_free_skcipher(tfm); 29184e7babbaSEric Biggers return err; 29194e7babbaSEric Biggers } 29204e7babbaSEric Biggers 2921b13b1e0cSEric Biggers static int test_comp(struct crypto_comp *tfm, 2922b13b1e0cSEric Biggers const struct comp_testvec *ctemplate, 2923b13b1e0cSEric Biggers const struct comp_testvec *dtemplate, 2924b13b1e0cSEric Biggers int ctcount, int dtcount) 2925da7f033dSHerbert Xu { 2926da7f033dSHerbert Xu const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm)); 292733607384SMahipal Challa char *output, *decomp_output; 2928da7f033dSHerbert Xu unsigned int i; 2929da7f033dSHerbert Xu int ret; 2930da7f033dSHerbert Xu 293133607384SMahipal Challa output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 293233607384SMahipal Challa if (!output) 293333607384SMahipal Challa return -ENOMEM; 293433607384SMahipal Challa 293533607384SMahipal Challa decomp_output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 293633607384SMahipal Challa if (!decomp_output) { 293733607384SMahipal Challa kfree(output); 293833607384SMahipal Challa return -ENOMEM; 293933607384SMahipal Challa } 294033607384SMahipal Challa 2941da7f033dSHerbert Xu for (i = 0; i < ctcount; i++) { 2942c79cf910SGeert Uytterhoeven int ilen; 2943c79cf910SGeert Uytterhoeven unsigned int dlen = COMP_BUF_SIZE; 2944da7f033dSHerbert Xu 294522a8118dSMichael Schupikov memset(output, 0, COMP_BUF_SIZE); 294622a8118dSMichael Schupikov memset(decomp_output, 0, COMP_BUF_SIZE); 2947da7f033dSHerbert Xu 2948da7f033dSHerbert Xu ilen = ctemplate[i].inlen; 2949da7f033dSHerbert Xu ret = crypto_comp_compress(tfm, ctemplate[i].input, 295033607384SMahipal Challa ilen, output, &dlen); 2951da7f033dSHerbert Xu if (ret) { 2952da7f033dSHerbert Xu printk(KERN_ERR "alg: comp: compression failed " 2953da7f033dSHerbert Xu "on test %d for %s: ret=%d\n", i + 1, algo, 2954da7f033dSHerbert Xu -ret); 2955da7f033dSHerbert Xu goto out; 2956da7f033dSHerbert Xu } 2957da7f033dSHerbert Xu 295833607384SMahipal Challa ilen = dlen; 295933607384SMahipal Challa dlen = COMP_BUF_SIZE; 296033607384SMahipal Challa ret = crypto_comp_decompress(tfm, output, 296133607384SMahipal Challa ilen, decomp_output, &dlen); 296233607384SMahipal Challa if (ret) { 296333607384SMahipal Challa pr_err("alg: comp: compression failed: decompress: on test %d for %s failed: ret=%d\n", 296433607384SMahipal Challa i + 1, algo, -ret); 296533607384SMahipal Challa goto out; 296633607384SMahipal Challa } 296733607384SMahipal Challa 296833607384SMahipal Challa if (dlen != ctemplate[i].inlen) { 2969b812eb00SGeert Uytterhoeven printk(KERN_ERR "alg: comp: Compression test %d " 2970b812eb00SGeert Uytterhoeven "failed for %s: output len = %d\n", i + 1, algo, 2971b812eb00SGeert Uytterhoeven dlen); 2972b812eb00SGeert Uytterhoeven ret = -EINVAL; 2973b812eb00SGeert Uytterhoeven goto out; 2974b812eb00SGeert Uytterhoeven } 2975b812eb00SGeert Uytterhoeven 297633607384SMahipal Challa if (memcmp(decomp_output, ctemplate[i].input, 297733607384SMahipal Challa ctemplate[i].inlen)) { 297833607384SMahipal Challa pr_err("alg: comp: compression failed: output differs: on test %d for %s\n", 297933607384SMahipal Challa i + 1, algo); 298033607384SMahipal Challa hexdump(decomp_output, dlen); 2981da7f033dSHerbert Xu ret = -EINVAL; 2982da7f033dSHerbert Xu goto out; 2983da7f033dSHerbert Xu } 2984da7f033dSHerbert Xu } 2985da7f033dSHerbert Xu 2986da7f033dSHerbert Xu for (i = 0; i < dtcount; i++) { 2987c79cf910SGeert Uytterhoeven int ilen; 2988c79cf910SGeert Uytterhoeven unsigned int dlen = COMP_BUF_SIZE; 2989da7f033dSHerbert Xu 299022a8118dSMichael Schupikov memset(decomp_output, 0, COMP_BUF_SIZE); 2991da7f033dSHerbert Xu 2992da7f033dSHerbert Xu ilen = dtemplate[i].inlen; 2993da7f033dSHerbert Xu ret = crypto_comp_decompress(tfm, dtemplate[i].input, 299433607384SMahipal Challa ilen, decomp_output, &dlen); 2995da7f033dSHerbert Xu if (ret) { 2996da7f033dSHerbert Xu printk(KERN_ERR "alg: comp: decompression failed " 2997da7f033dSHerbert Xu "on test %d for %s: ret=%d\n", i + 1, algo, 2998da7f033dSHerbert Xu -ret); 2999da7f033dSHerbert Xu goto out; 3000da7f033dSHerbert Xu } 3001da7f033dSHerbert Xu 3002b812eb00SGeert Uytterhoeven if (dlen != dtemplate[i].outlen) { 3003b812eb00SGeert Uytterhoeven printk(KERN_ERR "alg: comp: Decompression test %d " 3004b812eb00SGeert Uytterhoeven "failed for %s: output len = %d\n", i + 1, algo, 3005b812eb00SGeert Uytterhoeven dlen); 3006b812eb00SGeert Uytterhoeven ret = -EINVAL; 3007b812eb00SGeert Uytterhoeven goto out; 3008b812eb00SGeert Uytterhoeven } 3009b812eb00SGeert Uytterhoeven 301033607384SMahipal Challa if (memcmp(decomp_output, dtemplate[i].output, dlen)) { 3011da7f033dSHerbert Xu printk(KERN_ERR "alg: comp: Decompression test %d " 3012da7f033dSHerbert Xu "failed for %s\n", i + 1, algo); 301333607384SMahipal Challa hexdump(decomp_output, dlen); 3014da7f033dSHerbert Xu ret = -EINVAL; 3015da7f033dSHerbert Xu goto out; 3016da7f033dSHerbert Xu } 3017da7f033dSHerbert Xu } 3018da7f033dSHerbert Xu 3019da7f033dSHerbert Xu ret = 0; 3020da7f033dSHerbert Xu 3021da7f033dSHerbert Xu out: 302233607384SMahipal Challa kfree(decomp_output); 302333607384SMahipal Challa kfree(output); 3024da7f033dSHerbert Xu return ret; 3025da7f033dSHerbert Xu } 3026da7f033dSHerbert Xu 3027b13b1e0cSEric Biggers static int test_acomp(struct crypto_acomp *tfm, 3028b13b1e0cSEric Biggers const struct comp_testvec *ctemplate, 3029b13b1e0cSEric Biggers const struct comp_testvec *dtemplate, 3030b13b1e0cSEric Biggers int ctcount, int dtcount) 3031d7db7a88SGiovanni Cabiddu { 3032d7db7a88SGiovanni Cabiddu const char *algo = crypto_tfm_alg_driver_name(crypto_acomp_tfm(tfm)); 3033d7db7a88SGiovanni Cabiddu unsigned int i; 3034a9943a0aSGiovanni Cabiddu char *output, *decomp_out; 3035d7db7a88SGiovanni Cabiddu int ret; 3036d7db7a88SGiovanni Cabiddu struct scatterlist src, dst; 3037d7db7a88SGiovanni Cabiddu struct acomp_req *req; 30387f397136SGilad Ben-Yossef struct crypto_wait wait; 3039d7db7a88SGiovanni Cabiddu 3040eb095593SEric Biggers output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 3041eb095593SEric Biggers if (!output) 3042eb095593SEric Biggers return -ENOMEM; 3043eb095593SEric Biggers 3044a9943a0aSGiovanni Cabiddu decomp_out = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 3045a9943a0aSGiovanni Cabiddu if (!decomp_out) { 3046a9943a0aSGiovanni Cabiddu kfree(output); 3047a9943a0aSGiovanni Cabiddu return -ENOMEM; 3048a9943a0aSGiovanni Cabiddu } 3049a9943a0aSGiovanni Cabiddu 3050d7db7a88SGiovanni Cabiddu for (i = 0; i < ctcount; i++) { 3051d7db7a88SGiovanni Cabiddu unsigned int dlen = COMP_BUF_SIZE; 3052d7db7a88SGiovanni Cabiddu int ilen = ctemplate[i].inlen; 305302608e02SLaura Abbott void *input_vec; 3054d7db7a88SGiovanni Cabiddu 3055d2110224SEric Biggers input_vec = kmemdup(ctemplate[i].input, ilen, GFP_KERNEL); 305602608e02SLaura Abbott if (!input_vec) { 305702608e02SLaura Abbott ret = -ENOMEM; 305802608e02SLaura Abbott goto out; 305902608e02SLaura Abbott } 306002608e02SLaura Abbott 3061eb095593SEric Biggers memset(output, 0, dlen); 30627f397136SGilad Ben-Yossef crypto_init_wait(&wait); 306302608e02SLaura Abbott sg_init_one(&src, input_vec, ilen); 3064d7db7a88SGiovanni Cabiddu sg_init_one(&dst, output, dlen); 3065d7db7a88SGiovanni Cabiddu 3066d7db7a88SGiovanni Cabiddu req = acomp_request_alloc(tfm); 3067d7db7a88SGiovanni Cabiddu if (!req) { 3068d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: request alloc failed for %s\n", 3069d7db7a88SGiovanni Cabiddu algo); 307002608e02SLaura Abbott kfree(input_vec); 3071d7db7a88SGiovanni Cabiddu ret = -ENOMEM; 3072d7db7a88SGiovanni Cabiddu goto out; 3073d7db7a88SGiovanni Cabiddu } 3074d7db7a88SGiovanni Cabiddu 3075d7db7a88SGiovanni Cabiddu acomp_request_set_params(req, &src, &dst, ilen, dlen); 3076d7db7a88SGiovanni Cabiddu acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 30777f397136SGilad Ben-Yossef crypto_req_done, &wait); 3078d7db7a88SGiovanni Cabiddu 30797f397136SGilad Ben-Yossef ret = crypto_wait_req(crypto_acomp_compress(req), &wait); 3080d7db7a88SGiovanni Cabiddu if (ret) { 3081d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n", 3082d7db7a88SGiovanni Cabiddu i + 1, algo, -ret); 308302608e02SLaura Abbott kfree(input_vec); 3084d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3085d7db7a88SGiovanni Cabiddu goto out; 3086d7db7a88SGiovanni Cabiddu } 3087d7db7a88SGiovanni Cabiddu 3088a9943a0aSGiovanni Cabiddu ilen = req->dlen; 3089a9943a0aSGiovanni Cabiddu dlen = COMP_BUF_SIZE; 3090a9943a0aSGiovanni Cabiddu sg_init_one(&src, output, ilen); 3091a9943a0aSGiovanni Cabiddu sg_init_one(&dst, decomp_out, dlen); 30927f397136SGilad Ben-Yossef crypto_init_wait(&wait); 3093a9943a0aSGiovanni Cabiddu acomp_request_set_params(req, &src, &dst, ilen, dlen); 3094a9943a0aSGiovanni Cabiddu 30957f397136SGilad Ben-Yossef ret = crypto_wait_req(crypto_acomp_decompress(req), &wait); 3096a9943a0aSGiovanni Cabiddu if (ret) { 3097a9943a0aSGiovanni Cabiddu pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n", 3098a9943a0aSGiovanni Cabiddu i + 1, algo, -ret); 3099a9943a0aSGiovanni Cabiddu kfree(input_vec); 3100a9943a0aSGiovanni Cabiddu acomp_request_free(req); 3101a9943a0aSGiovanni Cabiddu goto out; 3102a9943a0aSGiovanni Cabiddu } 3103a9943a0aSGiovanni Cabiddu 3104a9943a0aSGiovanni Cabiddu if (req->dlen != ctemplate[i].inlen) { 3105d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Compression test %d failed for %s: output len = %d\n", 3106d7db7a88SGiovanni Cabiddu i + 1, algo, req->dlen); 3107d7db7a88SGiovanni Cabiddu ret = -EINVAL; 310802608e02SLaura Abbott kfree(input_vec); 3109d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3110d7db7a88SGiovanni Cabiddu goto out; 3111d7db7a88SGiovanni Cabiddu } 3112d7db7a88SGiovanni Cabiddu 3113a9943a0aSGiovanni Cabiddu if (memcmp(input_vec, decomp_out, req->dlen)) { 3114d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Compression test %d failed for %s\n", 3115d7db7a88SGiovanni Cabiddu i + 1, algo); 3116d7db7a88SGiovanni Cabiddu hexdump(output, req->dlen); 3117d7db7a88SGiovanni Cabiddu ret = -EINVAL; 311802608e02SLaura Abbott kfree(input_vec); 3119d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3120d7db7a88SGiovanni Cabiddu goto out; 3121d7db7a88SGiovanni Cabiddu } 3122d7db7a88SGiovanni Cabiddu 312302608e02SLaura Abbott kfree(input_vec); 3124d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3125d7db7a88SGiovanni Cabiddu } 3126d7db7a88SGiovanni Cabiddu 3127d7db7a88SGiovanni Cabiddu for (i = 0; i < dtcount; i++) { 3128d7db7a88SGiovanni Cabiddu unsigned int dlen = COMP_BUF_SIZE; 3129d7db7a88SGiovanni Cabiddu int ilen = dtemplate[i].inlen; 313002608e02SLaura Abbott void *input_vec; 3131d7db7a88SGiovanni Cabiddu 3132d2110224SEric Biggers input_vec = kmemdup(dtemplate[i].input, ilen, GFP_KERNEL); 313302608e02SLaura Abbott if (!input_vec) { 313402608e02SLaura Abbott ret = -ENOMEM; 313502608e02SLaura Abbott goto out; 313602608e02SLaura Abbott } 313702608e02SLaura Abbott 3138eb095593SEric Biggers memset(output, 0, dlen); 31397f397136SGilad Ben-Yossef crypto_init_wait(&wait); 314002608e02SLaura Abbott sg_init_one(&src, input_vec, ilen); 3141d7db7a88SGiovanni Cabiddu sg_init_one(&dst, output, dlen); 3142d7db7a88SGiovanni Cabiddu 3143d7db7a88SGiovanni Cabiddu req = acomp_request_alloc(tfm); 3144d7db7a88SGiovanni Cabiddu if (!req) { 3145d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: request alloc failed for %s\n", 3146d7db7a88SGiovanni Cabiddu algo); 314702608e02SLaura Abbott kfree(input_vec); 3148d7db7a88SGiovanni Cabiddu ret = -ENOMEM; 3149d7db7a88SGiovanni Cabiddu goto out; 3150d7db7a88SGiovanni Cabiddu } 3151d7db7a88SGiovanni Cabiddu 3152d7db7a88SGiovanni Cabiddu acomp_request_set_params(req, &src, &dst, ilen, dlen); 3153d7db7a88SGiovanni Cabiddu acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 31547f397136SGilad Ben-Yossef crypto_req_done, &wait); 3155d7db7a88SGiovanni Cabiddu 31567f397136SGilad Ben-Yossef ret = crypto_wait_req(crypto_acomp_decompress(req), &wait); 3157d7db7a88SGiovanni Cabiddu if (ret) { 3158d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: decompression failed on test %d for %s: ret=%d\n", 3159d7db7a88SGiovanni Cabiddu i + 1, algo, -ret); 316002608e02SLaura Abbott kfree(input_vec); 3161d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3162d7db7a88SGiovanni Cabiddu goto out; 3163d7db7a88SGiovanni Cabiddu } 3164d7db7a88SGiovanni Cabiddu 3165d7db7a88SGiovanni Cabiddu if (req->dlen != dtemplate[i].outlen) { 3166d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Decompression test %d failed for %s: output len = %d\n", 3167d7db7a88SGiovanni Cabiddu i + 1, algo, req->dlen); 3168d7db7a88SGiovanni Cabiddu ret = -EINVAL; 316902608e02SLaura Abbott kfree(input_vec); 3170d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3171d7db7a88SGiovanni Cabiddu goto out; 3172d7db7a88SGiovanni Cabiddu } 3173d7db7a88SGiovanni Cabiddu 3174d7db7a88SGiovanni Cabiddu if (memcmp(output, dtemplate[i].output, req->dlen)) { 3175d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Decompression test %d failed for %s\n", 3176d7db7a88SGiovanni Cabiddu i + 1, algo); 3177d7db7a88SGiovanni Cabiddu hexdump(output, req->dlen); 3178d7db7a88SGiovanni Cabiddu ret = -EINVAL; 317902608e02SLaura Abbott kfree(input_vec); 3180d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3181d7db7a88SGiovanni Cabiddu goto out; 3182d7db7a88SGiovanni Cabiddu } 3183d7db7a88SGiovanni Cabiddu 318402608e02SLaura Abbott kfree(input_vec); 3185d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3186d7db7a88SGiovanni Cabiddu } 3187d7db7a88SGiovanni Cabiddu 3188d7db7a88SGiovanni Cabiddu ret = 0; 3189d7db7a88SGiovanni Cabiddu 3190d7db7a88SGiovanni Cabiddu out: 3191a9943a0aSGiovanni Cabiddu kfree(decomp_out); 3192eb095593SEric Biggers kfree(output); 3193d7db7a88SGiovanni Cabiddu return ret; 3194d7db7a88SGiovanni Cabiddu } 3195d7db7a88SGiovanni Cabiddu 3196b13b1e0cSEric Biggers static int test_cprng(struct crypto_rng *tfm, 3197b13b1e0cSEric Biggers const struct cprng_testvec *template, 31987647d6ceSJarod Wilson unsigned int tcount) 31997647d6ceSJarod Wilson { 32007647d6ceSJarod Wilson const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm)); 3201fa4ef8a6SFelipe Contreras int err = 0, i, j, seedsize; 32027647d6ceSJarod Wilson u8 *seed; 32037647d6ceSJarod Wilson char result[32]; 32047647d6ceSJarod Wilson 32057647d6ceSJarod Wilson seedsize = crypto_rng_seedsize(tfm); 32067647d6ceSJarod Wilson 32077647d6ceSJarod Wilson seed = kmalloc(seedsize, GFP_KERNEL); 32087647d6ceSJarod Wilson if (!seed) { 32097647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to allocate seed space " 32107647d6ceSJarod Wilson "for %s\n", algo); 32117647d6ceSJarod Wilson return -ENOMEM; 32127647d6ceSJarod Wilson } 32137647d6ceSJarod Wilson 32147647d6ceSJarod Wilson for (i = 0; i < tcount; i++) { 32157647d6ceSJarod Wilson memset(result, 0, 32); 32167647d6ceSJarod Wilson 32177647d6ceSJarod Wilson memcpy(seed, template[i].v, template[i].vlen); 32187647d6ceSJarod Wilson memcpy(seed + template[i].vlen, template[i].key, 32197647d6ceSJarod Wilson template[i].klen); 32207647d6ceSJarod Wilson memcpy(seed + template[i].vlen + template[i].klen, 32217647d6ceSJarod Wilson template[i].dt, template[i].dtlen); 32227647d6ceSJarod Wilson 32237647d6ceSJarod Wilson err = crypto_rng_reset(tfm, seed, seedsize); 32247647d6ceSJarod Wilson if (err) { 32257647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to reset rng " 32267647d6ceSJarod Wilson "for %s\n", algo); 32277647d6ceSJarod Wilson goto out; 32287647d6ceSJarod Wilson } 32297647d6ceSJarod Wilson 32307647d6ceSJarod Wilson for (j = 0; j < template[i].loops; j++) { 32317647d6ceSJarod Wilson err = crypto_rng_get_bytes(tfm, result, 32327647d6ceSJarod Wilson template[i].rlen); 323319e60e13SStephan Mueller if (err < 0) { 32347647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to obtain " 32357647d6ceSJarod Wilson "the correct amount of random data for " 323619e60e13SStephan Mueller "%s (requested %d)\n", algo, 323719e60e13SStephan Mueller template[i].rlen); 32387647d6ceSJarod Wilson goto out; 32397647d6ceSJarod Wilson } 32407647d6ceSJarod Wilson } 32417647d6ceSJarod Wilson 32427647d6ceSJarod Wilson err = memcmp(result, template[i].result, 32437647d6ceSJarod Wilson template[i].rlen); 32447647d6ceSJarod Wilson if (err) { 32457647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Test %d failed for %s\n", 32467647d6ceSJarod Wilson i, algo); 32477647d6ceSJarod Wilson hexdump(result, template[i].rlen); 32487647d6ceSJarod Wilson err = -EINVAL; 32497647d6ceSJarod Wilson goto out; 32507647d6ceSJarod Wilson } 32517647d6ceSJarod Wilson } 32527647d6ceSJarod Wilson 32537647d6ceSJarod Wilson out: 32547647d6ceSJarod Wilson kfree(seed); 32557647d6ceSJarod Wilson return err; 32567647d6ceSJarod Wilson } 32577647d6ceSJarod Wilson 3258da7f033dSHerbert Xu static int alg_test_cipher(const struct alg_test_desc *desc, 3259da7f033dSHerbert Xu const char *driver, u32 type, u32 mask) 3260da7f033dSHerbert Xu { 326192a4c9feSEric Biggers const struct cipher_test_suite *suite = &desc->suite.cipher; 32621aa4ecd9SHerbert Xu struct crypto_cipher *tfm; 326392a4c9feSEric Biggers int err; 3264da7f033dSHerbert Xu 3265eed93e0cSHerbert Xu tfm = crypto_alloc_cipher(driver, type, mask); 3266da7f033dSHerbert Xu if (IS_ERR(tfm)) { 3267da7f033dSHerbert Xu printk(KERN_ERR "alg: cipher: Failed to load transform for " 3268da7f033dSHerbert Xu "%s: %ld\n", driver, PTR_ERR(tfm)); 3269da7f033dSHerbert Xu return PTR_ERR(tfm); 3270da7f033dSHerbert Xu } 3271da7f033dSHerbert Xu 327292a4c9feSEric Biggers err = test_cipher(tfm, ENCRYPT, suite->vecs, suite->count); 327392a4c9feSEric Biggers if (!err) 327492a4c9feSEric Biggers err = test_cipher(tfm, DECRYPT, suite->vecs, suite->count); 3275da7f033dSHerbert Xu 32761aa4ecd9SHerbert Xu crypto_free_cipher(tfm); 32771aa4ecd9SHerbert Xu return err; 32781aa4ecd9SHerbert Xu } 32791aa4ecd9SHerbert Xu 3280da7f033dSHerbert Xu static int alg_test_comp(const struct alg_test_desc *desc, const char *driver, 3281da7f033dSHerbert Xu u32 type, u32 mask) 3282da7f033dSHerbert Xu { 3283d7db7a88SGiovanni Cabiddu struct crypto_comp *comp; 3284d7db7a88SGiovanni Cabiddu struct crypto_acomp *acomp; 3285da7f033dSHerbert Xu int err; 3286d7db7a88SGiovanni Cabiddu u32 algo_type = type & CRYPTO_ALG_TYPE_ACOMPRESS_MASK; 3287da7f033dSHerbert Xu 3288d7db7a88SGiovanni Cabiddu if (algo_type == CRYPTO_ALG_TYPE_ACOMPRESS) { 3289d7db7a88SGiovanni Cabiddu acomp = crypto_alloc_acomp(driver, type, mask); 3290d7db7a88SGiovanni Cabiddu if (IS_ERR(acomp)) { 3291d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Failed to load transform for %s: %ld\n", 3292d7db7a88SGiovanni Cabiddu driver, PTR_ERR(acomp)); 3293d7db7a88SGiovanni Cabiddu return PTR_ERR(acomp); 3294d7db7a88SGiovanni Cabiddu } 3295d7db7a88SGiovanni Cabiddu err = test_acomp(acomp, desc->suite.comp.comp.vecs, 3296d7db7a88SGiovanni Cabiddu desc->suite.comp.decomp.vecs, 3297d7db7a88SGiovanni Cabiddu desc->suite.comp.comp.count, 3298d7db7a88SGiovanni Cabiddu desc->suite.comp.decomp.count); 3299d7db7a88SGiovanni Cabiddu crypto_free_acomp(acomp); 3300d7db7a88SGiovanni Cabiddu } else { 3301d7db7a88SGiovanni Cabiddu comp = crypto_alloc_comp(driver, type, mask); 3302d7db7a88SGiovanni Cabiddu if (IS_ERR(comp)) { 3303d7db7a88SGiovanni Cabiddu pr_err("alg: comp: Failed to load transform for %s: %ld\n", 3304d7db7a88SGiovanni Cabiddu driver, PTR_ERR(comp)); 3305d7db7a88SGiovanni Cabiddu return PTR_ERR(comp); 3306da7f033dSHerbert Xu } 3307da7f033dSHerbert Xu 3308d7db7a88SGiovanni Cabiddu err = test_comp(comp, desc->suite.comp.comp.vecs, 3309da7f033dSHerbert Xu desc->suite.comp.decomp.vecs, 3310da7f033dSHerbert Xu desc->suite.comp.comp.count, 3311da7f033dSHerbert Xu desc->suite.comp.decomp.count); 3312da7f033dSHerbert Xu 3313d7db7a88SGiovanni Cabiddu crypto_free_comp(comp); 3314d7db7a88SGiovanni Cabiddu } 3315da7f033dSHerbert Xu return err; 3316da7f033dSHerbert Xu } 3317da7f033dSHerbert Xu 33188e3ee85eSHerbert Xu static int alg_test_crc32c(const struct alg_test_desc *desc, 33198e3ee85eSHerbert Xu const char *driver, u32 type, u32 mask) 33208e3ee85eSHerbert Xu { 33218e3ee85eSHerbert Xu struct crypto_shash *tfm; 3322cb9dde88SEric Biggers __le32 val; 33238e3ee85eSHerbert Xu int err; 33248e3ee85eSHerbert Xu 33258e3ee85eSHerbert Xu err = alg_test_hash(desc, driver, type, mask); 33268e3ee85eSHerbert Xu if (err) 3327eb5e6730SEric Biggers return err; 33288e3ee85eSHerbert Xu 3329eed93e0cSHerbert Xu tfm = crypto_alloc_shash(driver, type, mask); 33308e3ee85eSHerbert Xu if (IS_ERR(tfm)) { 3331eb5e6730SEric Biggers if (PTR_ERR(tfm) == -ENOENT) { 3332eb5e6730SEric Biggers /* 3333eb5e6730SEric Biggers * This crc32c implementation is only available through 3334eb5e6730SEric Biggers * ahash API, not the shash API, so the remaining part 3335eb5e6730SEric Biggers * of the test is not applicable to it. 3336eb5e6730SEric Biggers */ 3337eb5e6730SEric Biggers return 0; 3338eb5e6730SEric Biggers } 33398e3ee85eSHerbert Xu printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: " 33408e3ee85eSHerbert Xu "%ld\n", driver, PTR_ERR(tfm)); 3341eb5e6730SEric Biggers return PTR_ERR(tfm); 33428e3ee85eSHerbert Xu } 33438e3ee85eSHerbert Xu 33448e3ee85eSHerbert Xu do { 33454c5c3024SJan-Simon Möller SHASH_DESC_ON_STACK(shash, tfm); 33464c5c3024SJan-Simon Möller u32 *ctx = (u32 *)shash_desc_ctx(shash); 33478e3ee85eSHerbert Xu 33484c5c3024SJan-Simon Möller shash->tfm = tfm; 33498e3ee85eSHerbert Xu 3350cb9dde88SEric Biggers *ctx = 420553207; 33514c5c3024SJan-Simon Möller err = crypto_shash_final(shash, (u8 *)&val); 33528e3ee85eSHerbert Xu if (err) { 33538e3ee85eSHerbert Xu printk(KERN_ERR "alg: crc32c: Operation failed for " 33548e3ee85eSHerbert Xu "%s: %d\n", driver, err); 33558e3ee85eSHerbert Xu break; 33568e3ee85eSHerbert Xu } 33578e3ee85eSHerbert Xu 3358cb9dde88SEric Biggers if (val != cpu_to_le32(~420553207)) { 3359cb9dde88SEric Biggers pr_err("alg: crc32c: Test failed for %s: %u\n", 3360cb9dde88SEric Biggers driver, le32_to_cpu(val)); 33618e3ee85eSHerbert Xu err = -EINVAL; 33628e3ee85eSHerbert Xu } 33638e3ee85eSHerbert Xu } while (0); 33648e3ee85eSHerbert Xu 33658e3ee85eSHerbert Xu crypto_free_shash(tfm); 33668e3ee85eSHerbert Xu 33678e3ee85eSHerbert Xu return err; 33688e3ee85eSHerbert Xu } 33698e3ee85eSHerbert Xu 33707647d6ceSJarod Wilson static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver, 33717647d6ceSJarod Wilson u32 type, u32 mask) 33727647d6ceSJarod Wilson { 33737647d6ceSJarod Wilson struct crypto_rng *rng; 33747647d6ceSJarod Wilson int err; 33757647d6ceSJarod Wilson 3376eed93e0cSHerbert Xu rng = crypto_alloc_rng(driver, type, mask); 33777647d6ceSJarod Wilson if (IS_ERR(rng)) { 33787647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to load transform for %s: " 33797647d6ceSJarod Wilson "%ld\n", driver, PTR_ERR(rng)); 33807647d6ceSJarod Wilson return PTR_ERR(rng); 33817647d6ceSJarod Wilson } 33827647d6ceSJarod Wilson 33837647d6ceSJarod Wilson err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count); 33847647d6ceSJarod Wilson 33857647d6ceSJarod Wilson crypto_free_rng(rng); 33867647d6ceSJarod Wilson 33877647d6ceSJarod Wilson return err; 33887647d6ceSJarod Wilson } 33897647d6ceSJarod Wilson 339064d1cdfbSStephan Mueller 3391b13b1e0cSEric Biggers static int drbg_cavs_test(const struct drbg_testvec *test, int pr, 339264d1cdfbSStephan Mueller const char *driver, u32 type, u32 mask) 339364d1cdfbSStephan Mueller { 339464d1cdfbSStephan Mueller int ret = -EAGAIN; 339564d1cdfbSStephan Mueller struct crypto_rng *drng; 339664d1cdfbSStephan Mueller struct drbg_test_data test_data; 339764d1cdfbSStephan Mueller struct drbg_string addtl, pers, testentropy; 339864d1cdfbSStephan Mueller unsigned char *buf = kzalloc(test->expectedlen, GFP_KERNEL); 339964d1cdfbSStephan Mueller 340064d1cdfbSStephan Mueller if (!buf) 340164d1cdfbSStephan Mueller return -ENOMEM; 340264d1cdfbSStephan Mueller 3403eed93e0cSHerbert Xu drng = crypto_alloc_rng(driver, type, mask); 340464d1cdfbSStephan Mueller if (IS_ERR(drng)) { 340564d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: could not allocate DRNG handle for " 340664d1cdfbSStephan Mueller "%s\n", driver); 340764d1cdfbSStephan Mueller kzfree(buf); 340864d1cdfbSStephan Mueller return -ENOMEM; 340964d1cdfbSStephan Mueller } 341064d1cdfbSStephan Mueller 341164d1cdfbSStephan Mueller test_data.testentropy = &testentropy; 341264d1cdfbSStephan Mueller drbg_string_fill(&testentropy, test->entropy, test->entropylen); 341364d1cdfbSStephan Mueller drbg_string_fill(&pers, test->pers, test->perslen); 341464d1cdfbSStephan Mueller ret = crypto_drbg_reset_test(drng, &pers, &test_data); 341564d1cdfbSStephan Mueller if (ret) { 341664d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: Failed to reset rng\n"); 341764d1cdfbSStephan Mueller goto outbuf; 341864d1cdfbSStephan Mueller } 341964d1cdfbSStephan Mueller 342064d1cdfbSStephan Mueller drbg_string_fill(&addtl, test->addtla, test->addtllen); 342164d1cdfbSStephan Mueller if (pr) { 342264d1cdfbSStephan Mueller drbg_string_fill(&testentropy, test->entpra, test->entprlen); 342364d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl_test(drng, 342464d1cdfbSStephan Mueller buf, test->expectedlen, &addtl, &test_data); 342564d1cdfbSStephan Mueller } else { 342664d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl(drng, 342764d1cdfbSStephan Mueller buf, test->expectedlen, &addtl); 342864d1cdfbSStephan Mueller } 342919e60e13SStephan Mueller if (ret < 0) { 343064d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: could not obtain random data for " 343164d1cdfbSStephan Mueller "driver %s\n", driver); 343264d1cdfbSStephan Mueller goto outbuf; 343364d1cdfbSStephan Mueller } 343464d1cdfbSStephan Mueller 343564d1cdfbSStephan Mueller drbg_string_fill(&addtl, test->addtlb, test->addtllen); 343664d1cdfbSStephan Mueller if (pr) { 343764d1cdfbSStephan Mueller drbg_string_fill(&testentropy, test->entprb, test->entprlen); 343864d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl_test(drng, 343964d1cdfbSStephan Mueller buf, test->expectedlen, &addtl, &test_data); 344064d1cdfbSStephan Mueller } else { 344164d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl(drng, 344264d1cdfbSStephan Mueller buf, test->expectedlen, &addtl); 344364d1cdfbSStephan Mueller } 344419e60e13SStephan Mueller if (ret < 0) { 344564d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: could not obtain random data for " 344664d1cdfbSStephan Mueller "driver %s\n", driver); 344764d1cdfbSStephan Mueller goto outbuf; 344864d1cdfbSStephan Mueller } 344964d1cdfbSStephan Mueller 345064d1cdfbSStephan Mueller ret = memcmp(test->expected, buf, test->expectedlen); 345164d1cdfbSStephan Mueller 345264d1cdfbSStephan Mueller outbuf: 345364d1cdfbSStephan Mueller crypto_free_rng(drng); 345464d1cdfbSStephan Mueller kzfree(buf); 345564d1cdfbSStephan Mueller return ret; 345664d1cdfbSStephan Mueller } 345764d1cdfbSStephan Mueller 345864d1cdfbSStephan Mueller 345964d1cdfbSStephan Mueller static int alg_test_drbg(const struct alg_test_desc *desc, const char *driver, 346064d1cdfbSStephan Mueller u32 type, u32 mask) 346164d1cdfbSStephan Mueller { 346264d1cdfbSStephan Mueller int err = 0; 346364d1cdfbSStephan Mueller int pr = 0; 346464d1cdfbSStephan Mueller int i = 0; 3465b13b1e0cSEric Biggers const struct drbg_testvec *template = desc->suite.drbg.vecs; 346664d1cdfbSStephan Mueller unsigned int tcount = desc->suite.drbg.count; 346764d1cdfbSStephan Mueller 346864d1cdfbSStephan Mueller if (0 == memcmp(driver, "drbg_pr_", 8)) 346964d1cdfbSStephan Mueller pr = 1; 347064d1cdfbSStephan Mueller 347164d1cdfbSStephan Mueller for (i = 0; i < tcount; i++) { 347264d1cdfbSStephan Mueller err = drbg_cavs_test(&template[i], pr, driver, type, mask); 347364d1cdfbSStephan Mueller if (err) { 347464d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: Test %d failed for %s\n", 347564d1cdfbSStephan Mueller i, driver); 347664d1cdfbSStephan Mueller err = -EINVAL; 347764d1cdfbSStephan Mueller break; 347864d1cdfbSStephan Mueller } 347964d1cdfbSStephan Mueller } 348064d1cdfbSStephan Mueller return err; 348164d1cdfbSStephan Mueller 348264d1cdfbSStephan Mueller } 348364d1cdfbSStephan Mueller 3484b13b1e0cSEric Biggers static int do_test_kpp(struct crypto_kpp *tfm, const struct kpp_testvec *vec, 3485802c7f1cSSalvatore Benedetto const char *alg) 3486802c7f1cSSalvatore Benedetto { 3487802c7f1cSSalvatore Benedetto struct kpp_request *req; 3488802c7f1cSSalvatore Benedetto void *input_buf = NULL; 3489802c7f1cSSalvatore Benedetto void *output_buf = NULL; 349047d3fd39STudor-Dan Ambarus void *a_public = NULL; 349147d3fd39STudor-Dan Ambarus void *a_ss = NULL; 349247d3fd39STudor-Dan Ambarus void *shared_secret = NULL; 34937f397136SGilad Ben-Yossef struct crypto_wait wait; 3494802c7f1cSSalvatore Benedetto unsigned int out_len_max; 3495802c7f1cSSalvatore Benedetto int err = -ENOMEM; 3496802c7f1cSSalvatore Benedetto struct scatterlist src, dst; 3497802c7f1cSSalvatore Benedetto 3498802c7f1cSSalvatore Benedetto req = kpp_request_alloc(tfm, GFP_KERNEL); 3499802c7f1cSSalvatore Benedetto if (!req) 3500802c7f1cSSalvatore Benedetto return err; 3501802c7f1cSSalvatore Benedetto 35027f397136SGilad Ben-Yossef crypto_init_wait(&wait); 3503802c7f1cSSalvatore Benedetto 3504802c7f1cSSalvatore Benedetto err = crypto_kpp_set_secret(tfm, vec->secret, vec->secret_size); 3505802c7f1cSSalvatore Benedetto if (err < 0) 3506802c7f1cSSalvatore Benedetto goto free_req; 3507802c7f1cSSalvatore Benedetto 3508802c7f1cSSalvatore Benedetto out_len_max = crypto_kpp_maxsize(tfm); 3509802c7f1cSSalvatore Benedetto output_buf = kzalloc(out_len_max, GFP_KERNEL); 3510802c7f1cSSalvatore Benedetto if (!output_buf) { 3511802c7f1cSSalvatore Benedetto err = -ENOMEM; 3512802c7f1cSSalvatore Benedetto goto free_req; 3513802c7f1cSSalvatore Benedetto } 3514802c7f1cSSalvatore Benedetto 3515802c7f1cSSalvatore Benedetto /* Use appropriate parameter as base */ 3516802c7f1cSSalvatore Benedetto kpp_request_set_input(req, NULL, 0); 3517802c7f1cSSalvatore Benedetto sg_init_one(&dst, output_buf, out_len_max); 3518802c7f1cSSalvatore Benedetto kpp_request_set_output(req, &dst, out_len_max); 3519802c7f1cSSalvatore Benedetto kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 35207f397136SGilad Ben-Yossef crypto_req_done, &wait); 3521802c7f1cSSalvatore Benedetto 352247d3fd39STudor-Dan Ambarus /* Compute party A's public key */ 35237f397136SGilad Ben-Yossef err = crypto_wait_req(crypto_kpp_generate_public_key(req), &wait); 3524802c7f1cSSalvatore Benedetto if (err) { 352547d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party A: generate public key test failed. err %d\n", 3526802c7f1cSSalvatore Benedetto alg, err); 3527802c7f1cSSalvatore Benedetto goto free_output; 3528802c7f1cSSalvatore Benedetto } 352947d3fd39STudor-Dan Ambarus 353047d3fd39STudor-Dan Ambarus if (vec->genkey) { 353147d3fd39STudor-Dan Ambarus /* Save party A's public key */ 3532e3d90e52SChristopher Diaz Riveros a_public = kmemdup(sg_virt(req->dst), out_len_max, GFP_KERNEL); 353347d3fd39STudor-Dan Ambarus if (!a_public) { 353447d3fd39STudor-Dan Ambarus err = -ENOMEM; 353547d3fd39STudor-Dan Ambarus goto free_output; 353647d3fd39STudor-Dan Ambarus } 353747d3fd39STudor-Dan Ambarus } else { 3538802c7f1cSSalvatore Benedetto /* Verify calculated public key */ 3539802c7f1cSSalvatore Benedetto if (memcmp(vec->expected_a_public, sg_virt(req->dst), 3540802c7f1cSSalvatore Benedetto vec->expected_a_public_size)) { 354147d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party A: generate public key test failed. Invalid output\n", 3542802c7f1cSSalvatore Benedetto alg); 3543802c7f1cSSalvatore Benedetto err = -EINVAL; 3544802c7f1cSSalvatore Benedetto goto free_output; 3545802c7f1cSSalvatore Benedetto } 354647d3fd39STudor-Dan Ambarus } 3547802c7f1cSSalvatore Benedetto 3548802c7f1cSSalvatore Benedetto /* Calculate shared secret key by using counter part (b) public key. */ 3549e3d90e52SChristopher Diaz Riveros input_buf = kmemdup(vec->b_public, vec->b_public_size, GFP_KERNEL); 3550802c7f1cSSalvatore Benedetto if (!input_buf) { 3551802c7f1cSSalvatore Benedetto err = -ENOMEM; 3552802c7f1cSSalvatore Benedetto goto free_output; 3553802c7f1cSSalvatore Benedetto } 3554802c7f1cSSalvatore Benedetto 3555802c7f1cSSalvatore Benedetto sg_init_one(&src, input_buf, vec->b_public_size); 3556802c7f1cSSalvatore Benedetto sg_init_one(&dst, output_buf, out_len_max); 3557802c7f1cSSalvatore Benedetto kpp_request_set_input(req, &src, vec->b_public_size); 3558802c7f1cSSalvatore Benedetto kpp_request_set_output(req, &dst, out_len_max); 3559802c7f1cSSalvatore Benedetto kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 35607f397136SGilad Ben-Yossef crypto_req_done, &wait); 35617f397136SGilad Ben-Yossef err = crypto_wait_req(crypto_kpp_compute_shared_secret(req), &wait); 3562802c7f1cSSalvatore Benedetto if (err) { 356347d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party A: compute shared secret test failed. err %d\n", 3564802c7f1cSSalvatore Benedetto alg, err); 3565802c7f1cSSalvatore Benedetto goto free_all; 3566802c7f1cSSalvatore Benedetto } 356747d3fd39STudor-Dan Ambarus 356847d3fd39STudor-Dan Ambarus if (vec->genkey) { 356947d3fd39STudor-Dan Ambarus /* Save the shared secret obtained by party A */ 3570e3d90e52SChristopher Diaz Riveros a_ss = kmemdup(sg_virt(req->dst), vec->expected_ss_size, GFP_KERNEL); 357147d3fd39STudor-Dan Ambarus if (!a_ss) { 357247d3fd39STudor-Dan Ambarus err = -ENOMEM; 357347d3fd39STudor-Dan Ambarus goto free_all; 357447d3fd39STudor-Dan Ambarus } 357547d3fd39STudor-Dan Ambarus 357647d3fd39STudor-Dan Ambarus /* 357747d3fd39STudor-Dan Ambarus * Calculate party B's shared secret by using party A's 357847d3fd39STudor-Dan Ambarus * public key. 357947d3fd39STudor-Dan Ambarus */ 358047d3fd39STudor-Dan Ambarus err = crypto_kpp_set_secret(tfm, vec->b_secret, 358147d3fd39STudor-Dan Ambarus vec->b_secret_size); 358247d3fd39STudor-Dan Ambarus if (err < 0) 358347d3fd39STudor-Dan Ambarus goto free_all; 358447d3fd39STudor-Dan Ambarus 358547d3fd39STudor-Dan Ambarus sg_init_one(&src, a_public, vec->expected_a_public_size); 358647d3fd39STudor-Dan Ambarus sg_init_one(&dst, output_buf, out_len_max); 358747d3fd39STudor-Dan Ambarus kpp_request_set_input(req, &src, vec->expected_a_public_size); 358847d3fd39STudor-Dan Ambarus kpp_request_set_output(req, &dst, out_len_max); 358947d3fd39STudor-Dan Ambarus kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 35907f397136SGilad Ben-Yossef crypto_req_done, &wait); 35917f397136SGilad Ben-Yossef err = crypto_wait_req(crypto_kpp_compute_shared_secret(req), 35927f397136SGilad Ben-Yossef &wait); 359347d3fd39STudor-Dan Ambarus if (err) { 359447d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party B: compute shared secret failed. err %d\n", 359547d3fd39STudor-Dan Ambarus alg, err); 359647d3fd39STudor-Dan Ambarus goto free_all; 359747d3fd39STudor-Dan Ambarus } 359847d3fd39STudor-Dan Ambarus 359947d3fd39STudor-Dan Ambarus shared_secret = a_ss; 360047d3fd39STudor-Dan Ambarus } else { 360147d3fd39STudor-Dan Ambarus shared_secret = (void *)vec->expected_ss; 360247d3fd39STudor-Dan Ambarus } 360347d3fd39STudor-Dan Ambarus 3604802c7f1cSSalvatore Benedetto /* 3605802c7f1cSSalvatore Benedetto * verify shared secret from which the user will derive 3606802c7f1cSSalvatore Benedetto * secret key by executing whatever hash it has chosen 3607802c7f1cSSalvatore Benedetto */ 360847d3fd39STudor-Dan Ambarus if (memcmp(shared_secret, sg_virt(req->dst), 3609802c7f1cSSalvatore Benedetto vec->expected_ss_size)) { 3610802c7f1cSSalvatore Benedetto pr_err("alg: %s: compute shared secret test failed. Invalid output\n", 3611802c7f1cSSalvatore Benedetto alg); 3612802c7f1cSSalvatore Benedetto err = -EINVAL; 3613802c7f1cSSalvatore Benedetto } 3614802c7f1cSSalvatore Benedetto 3615802c7f1cSSalvatore Benedetto free_all: 361647d3fd39STudor-Dan Ambarus kfree(a_ss); 3617802c7f1cSSalvatore Benedetto kfree(input_buf); 3618802c7f1cSSalvatore Benedetto free_output: 361947d3fd39STudor-Dan Ambarus kfree(a_public); 3620802c7f1cSSalvatore Benedetto kfree(output_buf); 3621802c7f1cSSalvatore Benedetto free_req: 3622802c7f1cSSalvatore Benedetto kpp_request_free(req); 3623802c7f1cSSalvatore Benedetto return err; 3624802c7f1cSSalvatore Benedetto } 3625802c7f1cSSalvatore Benedetto 3626802c7f1cSSalvatore Benedetto static int test_kpp(struct crypto_kpp *tfm, const char *alg, 3627b13b1e0cSEric Biggers const struct kpp_testvec *vecs, unsigned int tcount) 3628802c7f1cSSalvatore Benedetto { 3629802c7f1cSSalvatore Benedetto int ret, i; 3630802c7f1cSSalvatore Benedetto 3631802c7f1cSSalvatore Benedetto for (i = 0; i < tcount; i++) { 3632802c7f1cSSalvatore Benedetto ret = do_test_kpp(tfm, vecs++, alg); 3633802c7f1cSSalvatore Benedetto if (ret) { 3634802c7f1cSSalvatore Benedetto pr_err("alg: %s: test failed on vector %d, err=%d\n", 3635802c7f1cSSalvatore Benedetto alg, i + 1, ret); 3636802c7f1cSSalvatore Benedetto return ret; 3637802c7f1cSSalvatore Benedetto } 3638802c7f1cSSalvatore Benedetto } 3639802c7f1cSSalvatore Benedetto return 0; 3640802c7f1cSSalvatore Benedetto } 3641802c7f1cSSalvatore Benedetto 3642802c7f1cSSalvatore Benedetto static int alg_test_kpp(const struct alg_test_desc *desc, const char *driver, 3643802c7f1cSSalvatore Benedetto u32 type, u32 mask) 3644802c7f1cSSalvatore Benedetto { 3645802c7f1cSSalvatore Benedetto struct crypto_kpp *tfm; 3646802c7f1cSSalvatore Benedetto int err = 0; 3647802c7f1cSSalvatore Benedetto 3648eed93e0cSHerbert Xu tfm = crypto_alloc_kpp(driver, type, mask); 3649802c7f1cSSalvatore Benedetto if (IS_ERR(tfm)) { 3650802c7f1cSSalvatore Benedetto pr_err("alg: kpp: Failed to load tfm for %s: %ld\n", 3651802c7f1cSSalvatore Benedetto driver, PTR_ERR(tfm)); 3652802c7f1cSSalvatore Benedetto return PTR_ERR(tfm); 3653802c7f1cSSalvatore Benedetto } 3654802c7f1cSSalvatore Benedetto if (desc->suite.kpp.vecs) 3655802c7f1cSSalvatore Benedetto err = test_kpp(tfm, desc->alg, desc->suite.kpp.vecs, 3656802c7f1cSSalvatore Benedetto desc->suite.kpp.count); 3657802c7f1cSSalvatore Benedetto 3658802c7f1cSSalvatore Benedetto crypto_free_kpp(tfm); 3659802c7f1cSSalvatore Benedetto return err; 3660802c7f1cSSalvatore Benedetto } 3661802c7f1cSSalvatore Benedetto 3662f1774cb8SVitaly Chikunov static u8 *test_pack_u32(u8 *dst, u32 val) 3663f1774cb8SVitaly Chikunov { 3664f1774cb8SVitaly Chikunov memcpy(dst, &val, sizeof(val)); 3665f1774cb8SVitaly Chikunov return dst + sizeof(val); 3666f1774cb8SVitaly Chikunov } 3667f1774cb8SVitaly Chikunov 366850d2b643SHerbert Xu static int test_akcipher_one(struct crypto_akcipher *tfm, 3669b13b1e0cSEric Biggers const struct akcipher_testvec *vecs) 3670946cc463STadeusz Struk { 3671df27b26fSHerbert Xu char *xbuf[XBUFSIZE]; 3672946cc463STadeusz Struk struct akcipher_request *req; 3673946cc463STadeusz Struk void *outbuf_enc = NULL; 3674946cc463STadeusz Struk void *outbuf_dec = NULL; 36757f397136SGilad Ben-Yossef struct crypto_wait wait; 3676946cc463STadeusz Struk unsigned int out_len_max, out_len = 0; 3677946cc463STadeusz Struk int err = -ENOMEM; 3678c7381b01SVitaly Chikunov struct scatterlist src, dst, src_tab[3]; 36790507de94SVitaly Chikunov const char *m, *c; 36800507de94SVitaly Chikunov unsigned int m_size, c_size; 36810507de94SVitaly Chikunov const char *op; 3682f1774cb8SVitaly Chikunov u8 *key, *ptr; 3683946cc463STadeusz Struk 3684df27b26fSHerbert Xu if (testmgr_alloc_buf(xbuf)) 3685df27b26fSHerbert Xu return err; 3686df27b26fSHerbert Xu 3687946cc463STadeusz Struk req = akcipher_request_alloc(tfm, GFP_KERNEL); 3688946cc463STadeusz Struk if (!req) 3689df27b26fSHerbert Xu goto free_xbuf; 3690946cc463STadeusz Struk 36917f397136SGilad Ben-Yossef crypto_init_wait(&wait); 369222287b0bSTadeusz Struk 3693f1774cb8SVitaly Chikunov key = kmalloc(vecs->key_len + sizeof(u32) * 2 + vecs->param_len, 3694f1774cb8SVitaly Chikunov GFP_KERNEL); 3695f1774cb8SVitaly Chikunov if (!key) 3696f1774cb8SVitaly Chikunov goto free_xbuf; 3697f1774cb8SVitaly Chikunov memcpy(key, vecs->key, vecs->key_len); 3698f1774cb8SVitaly Chikunov ptr = key + vecs->key_len; 3699f1774cb8SVitaly Chikunov ptr = test_pack_u32(ptr, vecs->algo); 3700f1774cb8SVitaly Chikunov ptr = test_pack_u32(ptr, vecs->param_len); 3701f1774cb8SVitaly Chikunov memcpy(ptr, vecs->params, vecs->param_len); 3702f1774cb8SVitaly Chikunov 370322287b0bSTadeusz Struk if (vecs->public_key_vec) 3704f1774cb8SVitaly Chikunov err = crypto_akcipher_set_pub_key(tfm, key, vecs->key_len); 370522287b0bSTadeusz Struk else 3706f1774cb8SVitaly Chikunov err = crypto_akcipher_set_priv_key(tfm, key, vecs->key_len); 3707946cc463STadeusz Struk if (err) 3708946cc463STadeusz Struk goto free_req; 3709946cc463STadeusz Struk 37100507de94SVitaly Chikunov /* 37110507de94SVitaly Chikunov * First run test which do not require a private key, such as 37120507de94SVitaly Chikunov * encrypt or verify. 37130507de94SVitaly Chikunov */ 3714c7381b01SVitaly Chikunov err = -ENOMEM; 3715c7381b01SVitaly Chikunov out_len_max = crypto_akcipher_maxsize(tfm); 3716946cc463STadeusz Struk outbuf_enc = kzalloc(out_len_max, GFP_KERNEL); 3717946cc463STadeusz Struk if (!outbuf_enc) 3718946cc463STadeusz Struk goto free_req; 3719946cc463STadeusz Struk 37200507de94SVitaly Chikunov if (!vecs->siggen_sigver_test) { 37210507de94SVitaly Chikunov m = vecs->m; 37220507de94SVitaly Chikunov m_size = vecs->m_size; 37230507de94SVitaly Chikunov c = vecs->c; 37240507de94SVitaly Chikunov c_size = vecs->c_size; 37250507de94SVitaly Chikunov op = "encrypt"; 37260507de94SVitaly Chikunov } else { 37270507de94SVitaly Chikunov /* Swap args so we could keep plaintext (digest) 37280507de94SVitaly Chikunov * in vecs->m, and cooked signature in vecs->c. 37290507de94SVitaly Chikunov */ 37300507de94SVitaly Chikunov m = vecs->c; /* signature */ 37310507de94SVitaly Chikunov m_size = vecs->c_size; 37320507de94SVitaly Chikunov c = vecs->m; /* digest */ 37330507de94SVitaly Chikunov c_size = vecs->m_size; 37340507de94SVitaly Chikunov op = "verify"; 37350507de94SVitaly Chikunov } 3736df27b26fSHerbert Xu 37370507de94SVitaly Chikunov if (WARN_ON(m_size > PAGE_SIZE)) 37380507de94SVitaly Chikunov goto free_all; 37390507de94SVitaly Chikunov memcpy(xbuf[0], m, m_size); 3740df27b26fSHerbert Xu 3741c7381b01SVitaly Chikunov sg_init_table(src_tab, 3); 3742df27b26fSHerbert Xu sg_set_buf(&src_tab[0], xbuf[0], 8); 37430507de94SVitaly Chikunov sg_set_buf(&src_tab[1], xbuf[0] + 8, m_size - 8); 3744c7381b01SVitaly Chikunov if (vecs->siggen_sigver_test) { 3745c7381b01SVitaly Chikunov if (WARN_ON(c_size > PAGE_SIZE)) 3746c7381b01SVitaly Chikunov goto free_all; 3747c7381b01SVitaly Chikunov memcpy(xbuf[1], c, c_size); 3748c7381b01SVitaly Chikunov sg_set_buf(&src_tab[2], xbuf[1], c_size); 3749c7381b01SVitaly Chikunov akcipher_request_set_crypt(req, src_tab, NULL, m_size, c_size); 3750c7381b01SVitaly Chikunov } else { 375122287b0bSTadeusz Struk sg_init_one(&dst, outbuf_enc, out_len_max); 37520507de94SVitaly Chikunov akcipher_request_set_crypt(req, src_tab, &dst, m_size, 375322287b0bSTadeusz Struk out_len_max); 3754c7381b01SVitaly Chikunov } 3755946cc463STadeusz Struk akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 37567f397136SGilad Ben-Yossef crypto_req_done, &wait); 3757946cc463STadeusz Struk 37587f397136SGilad Ben-Yossef err = crypto_wait_req(vecs->siggen_sigver_test ? 37590507de94SVitaly Chikunov /* Run asymmetric signature verification */ 37600507de94SVitaly Chikunov crypto_akcipher_verify(req) : 37611207107cSStephan Mueller /* Run asymmetric encrypt */ 37627f397136SGilad Ben-Yossef crypto_akcipher_encrypt(req), &wait); 3763946cc463STadeusz Struk if (err) { 37640507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. err %d\n", op, err); 3765946cc463STadeusz Struk goto free_all; 3766946cc463STadeusz Struk } 3767c7381b01SVitaly Chikunov if (!vecs->siggen_sigver_test) { 37680507de94SVitaly Chikunov if (req->dst_len != c_size) { 37690507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output len\n", 37700507de94SVitaly Chikunov op); 3771946cc463STadeusz Struk err = -EINVAL; 3772946cc463STadeusz Struk goto free_all; 3773946cc463STadeusz Struk } 3774946cc463STadeusz Struk /* verify that encrypted message is equal to expected */ 3775c7381b01SVitaly Chikunov if (memcmp(c, outbuf_enc, c_size) != 0) { 3776c7381b01SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output\n", 3777c7381b01SVitaly Chikunov op); 37780507de94SVitaly Chikunov hexdump(outbuf_enc, c_size); 3779946cc463STadeusz Struk err = -EINVAL; 3780946cc463STadeusz Struk goto free_all; 3781946cc463STadeusz Struk } 3782c7381b01SVitaly Chikunov } 37830507de94SVitaly Chikunov 37840507de94SVitaly Chikunov /* 37850507de94SVitaly Chikunov * Don't invoke (decrypt or sign) test which require a private key 37860507de94SVitaly Chikunov * for vectors with only a public key. 37870507de94SVitaly Chikunov */ 3788946cc463STadeusz Struk if (vecs->public_key_vec) { 3789946cc463STadeusz Struk err = 0; 3790946cc463STadeusz Struk goto free_all; 3791946cc463STadeusz Struk } 3792946cc463STadeusz Struk outbuf_dec = kzalloc(out_len_max, GFP_KERNEL); 3793946cc463STadeusz Struk if (!outbuf_dec) { 3794946cc463STadeusz Struk err = -ENOMEM; 3795946cc463STadeusz Struk goto free_all; 3796946cc463STadeusz Struk } 3797df27b26fSHerbert Xu 37980507de94SVitaly Chikunov op = vecs->siggen_sigver_test ? "sign" : "decrypt"; 37990507de94SVitaly Chikunov if (WARN_ON(c_size > PAGE_SIZE)) 3800df27b26fSHerbert Xu goto free_all; 38010507de94SVitaly Chikunov memcpy(xbuf[0], c, c_size); 3802df27b26fSHerbert Xu 38030507de94SVitaly Chikunov sg_init_one(&src, xbuf[0], c_size); 380422287b0bSTadeusz Struk sg_init_one(&dst, outbuf_dec, out_len_max); 38057f397136SGilad Ben-Yossef crypto_init_wait(&wait); 38060507de94SVitaly Chikunov akcipher_request_set_crypt(req, &src, &dst, c_size, out_len_max); 3807946cc463STadeusz Struk 38087f397136SGilad Ben-Yossef err = crypto_wait_req(vecs->siggen_sigver_test ? 38090507de94SVitaly Chikunov /* Run asymmetric signature generation */ 38100507de94SVitaly Chikunov crypto_akcipher_sign(req) : 38111207107cSStephan Mueller /* Run asymmetric decrypt */ 38127f397136SGilad Ben-Yossef crypto_akcipher_decrypt(req), &wait); 3813946cc463STadeusz Struk if (err) { 38140507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. err %d\n", op, err); 3815946cc463STadeusz Struk goto free_all; 3816946cc463STadeusz Struk } 3817946cc463STadeusz Struk out_len = req->dst_len; 38180507de94SVitaly Chikunov if (out_len < m_size) { 38190507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output len %u\n", 38200507de94SVitaly Chikunov op, out_len); 3821946cc463STadeusz Struk err = -EINVAL; 3822946cc463STadeusz Struk goto free_all; 3823946cc463STadeusz Struk } 3824946cc463STadeusz Struk /* verify that decrypted message is equal to the original msg */ 38250507de94SVitaly Chikunov if (memchr_inv(outbuf_dec, 0, out_len - m_size) || 38260507de94SVitaly Chikunov memcmp(m, outbuf_dec + out_len - m_size, m_size)) { 38270507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output\n", op); 382850d2b643SHerbert Xu hexdump(outbuf_dec, out_len); 3829946cc463STadeusz Struk err = -EINVAL; 3830946cc463STadeusz Struk } 3831946cc463STadeusz Struk free_all: 3832946cc463STadeusz Struk kfree(outbuf_dec); 3833946cc463STadeusz Struk kfree(outbuf_enc); 3834946cc463STadeusz Struk free_req: 3835946cc463STadeusz Struk akcipher_request_free(req); 3836f1774cb8SVitaly Chikunov kfree(key); 3837df27b26fSHerbert Xu free_xbuf: 3838df27b26fSHerbert Xu testmgr_free_buf(xbuf); 3839946cc463STadeusz Struk return err; 3840946cc463STadeusz Struk } 3841946cc463STadeusz Struk 384250d2b643SHerbert Xu static int test_akcipher(struct crypto_akcipher *tfm, const char *alg, 3843b13b1e0cSEric Biggers const struct akcipher_testvec *vecs, 3844b13b1e0cSEric Biggers unsigned int tcount) 3845946cc463STadeusz Struk { 384615226e48SHerbert Xu const char *algo = 384715226e48SHerbert Xu crypto_tfm_alg_driver_name(crypto_akcipher_tfm(tfm)); 3848946cc463STadeusz Struk int ret, i; 3849946cc463STadeusz Struk 3850946cc463STadeusz Struk for (i = 0; i < tcount; i++) { 385150d2b643SHerbert Xu ret = test_akcipher_one(tfm, vecs++); 385250d2b643SHerbert Xu if (!ret) 385350d2b643SHerbert Xu continue; 385450d2b643SHerbert Xu 385515226e48SHerbert Xu pr_err("alg: akcipher: test %d failed for %s, err=%d\n", 385615226e48SHerbert Xu i + 1, algo, ret); 3857946cc463STadeusz Struk return ret; 3858946cc463STadeusz Struk } 3859946cc463STadeusz Struk return 0; 3860946cc463STadeusz Struk } 3861946cc463STadeusz Struk 3862946cc463STadeusz Struk static int alg_test_akcipher(const struct alg_test_desc *desc, 3863946cc463STadeusz Struk const char *driver, u32 type, u32 mask) 3864946cc463STadeusz Struk { 3865946cc463STadeusz Struk struct crypto_akcipher *tfm; 3866946cc463STadeusz Struk int err = 0; 3867946cc463STadeusz Struk 3868eed93e0cSHerbert Xu tfm = crypto_alloc_akcipher(driver, type, mask); 3869946cc463STadeusz Struk if (IS_ERR(tfm)) { 3870946cc463STadeusz Struk pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n", 3871946cc463STadeusz Struk driver, PTR_ERR(tfm)); 3872946cc463STadeusz Struk return PTR_ERR(tfm); 3873946cc463STadeusz Struk } 3874946cc463STadeusz Struk if (desc->suite.akcipher.vecs) 3875946cc463STadeusz Struk err = test_akcipher(tfm, desc->alg, desc->suite.akcipher.vecs, 3876946cc463STadeusz Struk desc->suite.akcipher.count); 3877946cc463STadeusz Struk 3878946cc463STadeusz Struk crypto_free_akcipher(tfm); 3879946cc463STadeusz Struk return err; 3880946cc463STadeusz Struk } 3881946cc463STadeusz Struk 3882863b557aSYouquan, Song static int alg_test_null(const struct alg_test_desc *desc, 3883863b557aSYouquan, Song const char *driver, u32 type, u32 mask) 3884863b557aSYouquan, Song { 3885863b557aSYouquan, Song return 0; 3886863b557aSYouquan, Song } 3887863b557aSYouquan, Song 388821c8e720SArd Biesheuvel #define __VECS(tv) { .vecs = tv, .count = ARRAY_SIZE(tv) } 388921c8e720SArd Biesheuvel 3890da7f033dSHerbert Xu /* Please keep this list sorted by algorithm name. */ 3891da7f033dSHerbert Xu static const struct alg_test_desc alg_test_descs[] = { 3892da7f033dSHerbert Xu { 3893059c2a4dSEric Biggers .alg = "adiantum(xchacha12,aes)", 3894d435e10eSEric Biggers .generic_driver = "adiantum(xchacha12-generic,aes-generic,nhpoly1305-generic)", 3895059c2a4dSEric Biggers .test = alg_test_skcipher, 3896059c2a4dSEric Biggers .suite = { 3897059c2a4dSEric Biggers .cipher = __VECS(adiantum_xchacha12_aes_tv_template) 3898059c2a4dSEric Biggers }, 3899059c2a4dSEric Biggers }, { 3900059c2a4dSEric Biggers .alg = "adiantum(xchacha20,aes)", 3901d435e10eSEric Biggers .generic_driver = "adiantum(xchacha20-generic,aes-generic,nhpoly1305-generic)", 3902059c2a4dSEric Biggers .test = alg_test_skcipher, 3903059c2a4dSEric Biggers .suite = { 3904059c2a4dSEric Biggers .cipher = __VECS(adiantum_xchacha20_aes_tv_template) 3905059c2a4dSEric Biggers }, 3906059c2a4dSEric Biggers }, { 3907b87dc203SOndrej Mosnacek .alg = "aegis128", 3908b87dc203SOndrej Mosnacek .test = alg_test_aead, 3909b87dc203SOndrej Mosnacek .suite = { 3910a0d608eeSEric Biggers .aead = __VECS(aegis128_tv_template) 3911b87dc203SOndrej Mosnacek } 3912b87dc203SOndrej Mosnacek }, { 3913e08ca2daSJarod Wilson .alg = "ansi_cprng", 3914e08ca2daSJarod Wilson .test = alg_test_cprng, 3915e08ca2daSJarod Wilson .suite = { 391621c8e720SArd Biesheuvel .cprng = __VECS(ansi_cprng_aes_tv_template) 3917e08ca2daSJarod Wilson } 3918e08ca2daSJarod Wilson }, { 3919bca4feb0SHoria Geanta .alg = "authenc(hmac(md5),ecb(cipher_null))", 3920bca4feb0SHoria Geanta .test = alg_test_aead, 3921bca4feb0SHoria Geanta .suite = { 3922a0d608eeSEric Biggers .aead = __VECS(hmac_md5_ecb_cipher_null_tv_template) 3923bca4feb0SHoria Geanta } 3924bca4feb0SHoria Geanta }, { 3925a4198fd4SHerbert Xu .alg = "authenc(hmac(sha1),cbc(aes))", 3926e46e9a46SHoria Geanta .test = alg_test_aead, 3927bcf741cbSHerbert Xu .fips_allowed = 1, 3928e46e9a46SHoria Geanta .suite = { 3929a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_aes_cbc_tv_temp) 39305208ed2cSNitesh Lal } 39315208ed2cSNitesh Lal }, { 3932a4198fd4SHerbert Xu .alg = "authenc(hmac(sha1),cbc(des))", 39335208ed2cSNitesh Lal .test = alg_test_aead, 39345208ed2cSNitesh Lal .suite = { 3935a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_des_cbc_tv_temp) 39365208ed2cSNitesh Lal } 39375208ed2cSNitesh Lal }, { 3938a4198fd4SHerbert Xu .alg = "authenc(hmac(sha1),cbc(des3_ede))", 39395208ed2cSNitesh Lal .test = alg_test_aead, 3940ed1afac9SMarcus Meissner .fips_allowed = 1, 39415208ed2cSNitesh Lal .suite = { 3942a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_des3_ede_cbc_tv_temp) 3943e46e9a46SHoria Geanta } 3944e46e9a46SHoria Geanta }, { 3945fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha1),ctr(aes))", 3946fb16abc2SMarcus Meissner .test = alg_test_null, 3947fb16abc2SMarcus Meissner .fips_allowed = 1, 3948fb16abc2SMarcus Meissner }, { 3949bca4feb0SHoria Geanta .alg = "authenc(hmac(sha1),ecb(cipher_null))", 3950bca4feb0SHoria Geanta .test = alg_test_aead, 3951bca4feb0SHoria Geanta .suite = { 3952a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_ecb_cipher_null_tv_temp) 39535208ed2cSNitesh Lal } 39545208ed2cSNitesh Lal }, { 39558888690eSMarcus Meissner .alg = "authenc(hmac(sha1),rfc3686(ctr(aes)))", 39568888690eSMarcus Meissner .test = alg_test_null, 39578888690eSMarcus Meissner .fips_allowed = 1, 39588888690eSMarcus Meissner }, { 3959a4198fd4SHerbert Xu .alg = "authenc(hmac(sha224),cbc(des))", 39605208ed2cSNitesh Lal .test = alg_test_aead, 39615208ed2cSNitesh Lal .suite = { 3962a0d608eeSEric Biggers .aead = __VECS(hmac_sha224_des_cbc_tv_temp) 39635208ed2cSNitesh Lal } 39645208ed2cSNitesh Lal }, { 3965a4198fd4SHerbert Xu .alg = "authenc(hmac(sha224),cbc(des3_ede))", 39665208ed2cSNitesh Lal .test = alg_test_aead, 3967ed1afac9SMarcus Meissner .fips_allowed = 1, 39685208ed2cSNitesh Lal .suite = { 3969a0d608eeSEric Biggers .aead = __VECS(hmac_sha224_des3_ede_cbc_tv_temp) 3970bca4feb0SHoria Geanta } 3971bca4feb0SHoria Geanta }, { 3972a4198fd4SHerbert Xu .alg = "authenc(hmac(sha256),cbc(aes))", 3973e46e9a46SHoria Geanta .test = alg_test_aead, 3974ed1afac9SMarcus Meissner .fips_allowed = 1, 3975e46e9a46SHoria Geanta .suite = { 3976a0d608eeSEric Biggers .aead = __VECS(hmac_sha256_aes_cbc_tv_temp) 39775208ed2cSNitesh Lal } 39785208ed2cSNitesh Lal }, { 3979a4198fd4SHerbert Xu .alg = "authenc(hmac(sha256),cbc(des))", 39805208ed2cSNitesh Lal .test = alg_test_aead, 39815208ed2cSNitesh Lal .suite = { 3982a0d608eeSEric Biggers .aead = __VECS(hmac_sha256_des_cbc_tv_temp) 39835208ed2cSNitesh Lal } 39845208ed2cSNitesh Lal }, { 3985a4198fd4SHerbert Xu .alg = "authenc(hmac(sha256),cbc(des3_ede))", 39865208ed2cSNitesh Lal .test = alg_test_aead, 3987ed1afac9SMarcus Meissner .fips_allowed = 1, 39885208ed2cSNitesh Lal .suite = { 3989a0d608eeSEric Biggers .aead = __VECS(hmac_sha256_des3_ede_cbc_tv_temp) 39905208ed2cSNitesh Lal } 39915208ed2cSNitesh Lal }, { 3992fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha256),ctr(aes))", 3993fb16abc2SMarcus Meissner .test = alg_test_null, 3994fb16abc2SMarcus Meissner .fips_allowed = 1, 3995fb16abc2SMarcus Meissner }, { 39968888690eSMarcus Meissner .alg = "authenc(hmac(sha256),rfc3686(ctr(aes)))", 39978888690eSMarcus Meissner .test = alg_test_null, 39988888690eSMarcus Meissner .fips_allowed = 1, 39998888690eSMarcus Meissner }, { 4000a4198fd4SHerbert Xu .alg = "authenc(hmac(sha384),cbc(des))", 40015208ed2cSNitesh Lal .test = alg_test_aead, 40025208ed2cSNitesh Lal .suite = { 4003a0d608eeSEric Biggers .aead = __VECS(hmac_sha384_des_cbc_tv_temp) 40045208ed2cSNitesh Lal } 40055208ed2cSNitesh Lal }, { 4006a4198fd4SHerbert Xu .alg = "authenc(hmac(sha384),cbc(des3_ede))", 40075208ed2cSNitesh Lal .test = alg_test_aead, 4008ed1afac9SMarcus Meissner .fips_allowed = 1, 40095208ed2cSNitesh Lal .suite = { 4010a0d608eeSEric Biggers .aead = __VECS(hmac_sha384_des3_ede_cbc_tv_temp) 4011e46e9a46SHoria Geanta } 4012e46e9a46SHoria Geanta }, { 4013fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha384),ctr(aes))", 4014fb16abc2SMarcus Meissner .test = alg_test_null, 4015fb16abc2SMarcus Meissner .fips_allowed = 1, 4016fb16abc2SMarcus Meissner }, { 40178888690eSMarcus Meissner .alg = "authenc(hmac(sha384),rfc3686(ctr(aes)))", 40188888690eSMarcus Meissner .test = alg_test_null, 40198888690eSMarcus Meissner .fips_allowed = 1, 40208888690eSMarcus Meissner }, { 4021a4198fd4SHerbert Xu .alg = "authenc(hmac(sha512),cbc(aes))", 4022ed1afac9SMarcus Meissner .fips_allowed = 1, 4023e46e9a46SHoria Geanta .test = alg_test_aead, 4024e46e9a46SHoria Geanta .suite = { 4025a0d608eeSEric Biggers .aead = __VECS(hmac_sha512_aes_cbc_tv_temp) 40265208ed2cSNitesh Lal } 40275208ed2cSNitesh Lal }, { 4028a4198fd4SHerbert Xu .alg = "authenc(hmac(sha512),cbc(des))", 40295208ed2cSNitesh Lal .test = alg_test_aead, 40305208ed2cSNitesh Lal .suite = { 4031a0d608eeSEric Biggers .aead = __VECS(hmac_sha512_des_cbc_tv_temp) 40325208ed2cSNitesh Lal } 40335208ed2cSNitesh Lal }, { 4034a4198fd4SHerbert Xu .alg = "authenc(hmac(sha512),cbc(des3_ede))", 40355208ed2cSNitesh Lal .test = alg_test_aead, 4036ed1afac9SMarcus Meissner .fips_allowed = 1, 40375208ed2cSNitesh Lal .suite = { 4038a0d608eeSEric Biggers .aead = __VECS(hmac_sha512_des3_ede_cbc_tv_temp) 4039e46e9a46SHoria Geanta } 4040e46e9a46SHoria Geanta }, { 4041fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha512),ctr(aes))", 4042fb16abc2SMarcus Meissner .test = alg_test_null, 4043fb16abc2SMarcus Meissner .fips_allowed = 1, 4044fb16abc2SMarcus Meissner }, { 40458888690eSMarcus Meissner .alg = "authenc(hmac(sha512),rfc3686(ctr(aes)))", 40468888690eSMarcus Meissner .test = alg_test_null, 40478888690eSMarcus Meissner .fips_allowed = 1, 40488888690eSMarcus Meissner }, { 4049a1afe274SDavid Sterba .alg = "blake2b-160", 4050a1afe274SDavid Sterba .test = alg_test_hash, 4051a1afe274SDavid Sterba .fips_allowed = 0, 4052a1afe274SDavid Sterba .suite = { 4053a1afe274SDavid Sterba .hash = __VECS(blake2b_160_tv_template) 4054a1afe274SDavid Sterba } 4055a1afe274SDavid Sterba }, { 4056a1afe274SDavid Sterba .alg = "blake2b-256", 4057a1afe274SDavid Sterba .test = alg_test_hash, 4058a1afe274SDavid Sterba .fips_allowed = 0, 4059a1afe274SDavid Sterba .suite = { 4060a1afe274SDavid Sterba .hash = __VECS(blake2b_256_tv_template) 4061a1afe274SDavid Sterba } 4062a1afe274SDavid Sterba }, { 4063a1afe274SDavid Sterba .alg = "blake2b-384", 4064a1afe274SDavid Sterba .test = alg_test_hash, 4065a1afe274SDavid Sterba .fips_allowed = 0, 4066a1afe274SDavid Sterba .suite = { 4067a1afe274SDavid Sterba .hash = __VECS(blake2b_384_tv_template) 4068a1afe274SDavid Sterba } 4069a1afe274SDavid Sterba }, { 4070a1afe274SDavid Sterba .alg = "blake2b-512", 4071a1afe274SDavid Sterba .test = alg_test_hash, 4072a1afe274SDavid Sterba .fips_allowed = 0, 4073a1afe274SDavid Sterba .suite = { 4074a1afe274SDavid Sterba .hash = __VECS(blake2b_512_tv_template) 4075a1afe274SDavid Sterba } 4076a1afe274SDavid Sterba }, { 407717e1df67SArd Biesheuvel .alg = "blake2s-128", 407817e1df67SArd Biesheuvel .test = alg_test_hash, 407917e1df67SArd Biesheuvel .suite = { 408017e1df67SArd Biesheuvel .hash = __VECS(blakes2s_128_tv_template) 408117e1df67SArd Biesheuvel } 408217e1df67SArd Biesheuvel }, { 408317e1df67SArd Biesheuvel .alg = "blake2s-160", 408417e1df67SArd Biesheuvel .test = alg_test_hash, 408517e1df67SArd Biesheuvel .suite = { 408617e1df67SArd Biesheuvel .hash = __VECS(blakes2s_160_tv_template) 408717e1df67SArd Biesheuvel } 408817e1df67SArd Biesheuvel }, { 408917e1df67SArd Biesheuvel .alg = "blake2s-224", 409017e1df67SArd Biesheuvel .test = alg_test_hash, 409117e1df67SArd Biesheuvel .suite = { 409217e1df67SArd Biesheuvel .hash = __VECS(blakes2s_224_tv_template) 409317e1df67SArd Biesheuvel } 409417e1df67SArd Biesheuvel }, { 409517e1df67SArd Biesheuvel .alg = "blake2s-256", 409617e1df67SArd Biesheuvel .test = alg_test_hash, 409717e1df67SArd Biesheuvel .suite = { 409817e1df67SArd Biesheuvel .hash = __VECS(blakes2s_256_tv_template) 409917e1df67SArd Biesheuvel } 410017e1df67SArd Biesheuvel }, { 4101da7f033dSHerbert Xu .alg = "cbc(aes)", 41021aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4103a1915d51SJarod Wilson .fips_allowed = 1, 4104da7f033dSHerbert Xu .suite = { 410592a4c9feSEric Biggers .cipher = __VECS(aes_cbc_tv_template) 410692a4c9feSEric Biggers }, 4107da7f033dSHerbert Xu }, { 4108da7f033dSHerbert Xu .alg = "cbc(anubis)", 41091aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4110da7f033dSHerbert Xu .suite = { 411192a4c9feSEric Biggers .cipher = __VECS(anubis_cbc_tv_template) 411292a4c9feSEric Biggers }, 4113da7f033dSHerbert Xu }, { 4114da7f033dSHerbert Xu .alg = "cbc(blowfish)", 41151aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4116da7f033dSHerbert Xu .suite = { 411792a4c9feSEric Biggers .cipher = __VECS(bf_cbc_tv_template) 411892a4c9feSEric Biggers }, 4119da7f033dSHerbert Xu }, { 4120da7f033dSHerbert Xu .alg = "cbc(camellia)", 41211aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4122da7f033dSHerbert Xu .suite = { 412392a4c9feSEric Biggers .cipher = __VECS(camellia_cbc_tv_template) 412492a4c9feSEric Biggers }, 4125da7f033dSHerbert Xu }, { 4126a2c58260SJohannes Goetzfried .alg = "cbc(cast5)", 4127a2c58260SJohannes Goetzfried .test = alg_test_skcipher, 4128a2c58260SJohannes Goetzfried .suite = { 412992a4c9feSEric Biggers .cipher = __VECS(cast5_cbc_tv_template) 413092a4c9feSEric Biggers }, 4131a2c58260SJohannes Goetzfried }, { 41329b8b0405SJohannes Goetzfried .alg = "cbc(cast6)", 41339b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 41349b8b0405SJohannes Goetzfried .suite = { 413592a4c9feSEric Biggers .cipher = __VECS(cast6_cbc_tv_template) 413692a4c9feSEric Biggers }, 41379b8b0405SJohannes Goetzfried }, { 4138da7f033dSHerbert Xu .alg = "cbc(des)", 41391aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4140da7f033dSHerbert Xu .suite = { 414192a4c9feSEric Biggers .cipher = __VECS(des_cbc_tv_template) 414292a4c9feSEric Biggers }, 4143da7f033dSHerbert Xu }, { 4144da7f033dSHerbert Xu .alg = "cbc(des3_ede)", 41451aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4146a1915d51SJarod Wilson .fips_allowed = 1, 4147da7f033dSHerbert Xu .suite = { 414892a4c9feSEric Biggers .cipher = __VECS(des3_ede_cbc_tv_template) 414992a4c9feSEric Biggers }, 4150da7f033dSHerbert Xu }, { 4151a794d8d8SGilad Ben-Yossef /* Same as cbc(aes) except the key is stored in 4152a794d8d8SGilad Ben-Yossef * hardware secure memory which we reference by index 4153a794d8d8SGilad Ben-Yossef */ 4154a794d8d8SGilad Ben-Yossef .alg = "cbc(paes)", 4155a794d8d8SGilad Ben-Yossef .test = alg_test_null, 4156a794d8d8SGilad Ben-Yossef .fips_allowed = 1, 4157a794d8d8SGilad Ben-Yossef }, { 4158f0372c00SGilad Ben-Yossef /* Same as cbc(sm4) except the key is stored in 4159f0372c00SGilad Ben-Yossef * hardware secure memory which we reference by index 4160f0372c00SGilad Ben-Yossef */ 4161f0372c00SGilad Ben-Yossef .alg = "cbc(psm4)", 4162f0372c00SGilad Ben-Yossef .test = alg_test_null, 4163f0372c00SGilad Ben-Yossef }, { 41649d25917dSJussi Kivilinna .alg = "cbc(serpent)", 41659d25917dSJussi Kivilinna .test = alg_test_skcipher, 41669d25917dSJussi Kivilinna .suite = { 416792a4c9feSEric Biggers .cipher = __VECS(serpent_cbc_tv_template) 416892a4c9feSEric Biggers }, 41699d25917dSJussi Kivilinna }, { 417095ba5973SGilad Ben-Yossef .alg = "cbc(sm4)", 417195ba5973SGilad Ben-Yossef .test = alg_test_skcipher, 417295ba5973SGilad Ben-Yossef .suite = { 417395ba5973SGilad Ben-Yossef .cipher = __VECS(sm4_cbc_tv_template) 417495ba5973SGilad Ben-Yossef } 417595ba5973SGilad Ben-Yossef }, { 4176da7f033dSHerbert Xu .alg = "cbc(twofish)", 41771aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4178da7f033dSHerbert Xu .suite = { 417992a4c9feSEric Biggers .cipher = __VECS(tf_cbc_tv_template) 418092a4c9feSEric Biggers }, 4181da7f033dSHerbert Xu }, { 4182092acf06SArd Biesheuvel .alg = "cbcmac(aes)", 4183092acf06SArd Biesheuvel .fips_allowed = 1, 4184092acf06SArd Biesheuvel .test = alg_test_hash, 4185092acf06SArd Biesheuvel .suite = { 4186092acf06SArd Biesheuvel .hash = __VECS(aes_cbcmac_tv_template) 4187092acf06SArd Biesheuvel } 4188092acf06SArd Biesheuvel }, { 4189da7f033dSHerbert Xu .alg = "ccm(aes)", 419040153b10SEric Biggers .generic_driver = "ccm_base(ctr(aes-generic),cbcmac(aes-generic))", 4191da7f033dSHerbert Xu .test = alg_test_aead, 4192a1915d51SJarod Wilson .fips_allowed = 1, 4193da7f033dSHerbert Xu .suite = { 4194a0d608eeSEric Biggers .aead = __VECS(aes_ccm_tv_template) 4195da7f033dSHerbert Xu } 4196da7f033dSHerbert Xu }, { 41977da66670SDmitry Eremin-Solenikov .alg = "cfb(aes)", 41987da66670SDmitry Eremin-Solenikov .test = alg_test_skcipher, 41997da66670SDmitry Eremin-Solenikov .fips_allowed = 1, 42007da66670SDmitry Eremin-Solenikov .suite = { 42017da66670SDmitry Eremin-Solenikov .cipher = __VECS(aes_cfb_tv_template) 42027da66670SDmitry Eremin-Solenikov }, 42037da66670SDmitry Eremin-Solenikov }, { 4204a06b15b2SPascal van Leeuwen .alg = "cfb(sm4)", 4205a06b15b2SPascal van Leeuwen .test = alg_test_skcipher, 4206a06b15b2SPascal van Leeuwen .suite = { 4207a06b15b2SPascal van Leeuwen .cipher = __VECS(sm4_cfb_tv_template) 4208a06b15b2SPascal van Leeuwen } 4209a06b15b2SPascal van Leeuwen }, { 42103590ebf2SMartin Willi .alg = "chacha20", 42113590ebf2SMartin Willi .test = alg_test_skcipher, 42123590ebf2SMartin Willi .suite = { 421392a4c9feSEric Biggers .cipher = __VECS(chacha20_tv_template) 421492a4c9feSEric Biggers }, 42153590ebf2SMartin Willi }, { 421693b5e86aSJussi Kivilinna .alg = "cmac(aes)", 42178f183751SStephan Mueller .fips_allowed = 1, 421893b5e86aSJussi Kivilinna .test = alg_test_hash, 421993b5e86aSJussi Kivilinna .suite = { 422021c8e720SArd Biesheuvel .hash = __VECS(aes_cmac128_tv_template) 422193b5e86aSJussi Kivilinna } 422293b5e86aSJussi Kivilinna }, { 422393b5e86aSJussi Kivilinna .alg = "cmac(des3_ede)", 42248f183751SStephan Mueller .fips_allowed = 1, 422593b5e86aSJussi Kivilinna .test = alg_test_hash, 422693b5e86aSJussi Kivilinna .suite = { 422721c8e720SArd Biesheuvel .hash = __VECS(des3_ede_cmac64_tv_template) 422893b5e86aSJussi Kivilinna } 422993b5e86aSJussi Kivilinna }, { 4230e448370dSJussi Kivilinna .alg = "compress_null", 4231e448370dSJussi Kivilinna .test = alg_test_null, 4232e448370dSJussi Kivilinna }, { 4233ebb3472fSArd Biesheuvel .alg = "crc32", 4234ebb3472fSArd Biesheuvel .test = alg_test_hash, 4235a8a34416SMilan Broz .fips_allowed = 1, 4236ebb3472fSArd Biesheuvel .suite = { 423721c8e720SArd Biesheuvel .hash = __VECS(crc32_tv_template) 4238ebb3472fSArd Biesheuvel } 4239ebb3472fSArd Biesheuvel }, { 4240da7f033dSHerbert Xu .alg = "crc32c", 42418e3ee85eSHerbert Xu .test = alg_test_crc32c, 4242a1915d51SJarod Wilson .fips_allowed = 1, 4243da7f033dSHerbert Xu .suite = { 424421c8e720SArd Biesheuvel .hash = __VECS(crc32c_tv_template) 4245da7f033dSHerbert Xu } 4246da7f033dSHerbert Xu }, { 424768411521SHerbert Xu .alg = "crct10dif", 424868411521SHerbert Xu .test = alg_test_hash, 424968411521SHerbert Xu .fips_allowed = 1, 425068411521SHerbert Xu .suite = { 425121c8e720SArd Biesheuvel .hash = __VECS(crct10dif_tv_template) 425268411521SHerbert Xu } 425368411521SHerbert Xu }, { 4254f7cb80f2SJarod Wilson .alg = "ctr(aes)", 4255f7cb80f2SJarod Wilson .test = alg_test_skcipher, 4256a1915d51SJarod Wilson .fips_allowed = 1, 4257f7cb80f2SJarod Wilson .suite = { 425892a4c9feSEric Biggers .cipher = __VECS(aes_ctr_tv_template) 4259f7cb80f2SJarod Wilson } 4260f7cb80f2SJarod Wilson }, { 426185b63e34SJussi Kivilinna .alg = "ctr(blowfish)", 426285b63e34SJussi Kivilinna .test = alg_test_skcipher, 426385b63e34SJussi Kivilinna .suite = { 426492a4c9feSEric Biggers .cipher = __VECS(bf_ctr_tv_template) 426585b63e34SJussi Kivilinna } 426685b63e34SJussi Kivilinna }, { 42670840605eSJussi Kivilinna .alg = "ctr(camellia)", 42680840605eSJussi Kivilinna .test = alg_test_skcipher, 42690840605eSJussi Kivilinna .suite = { 427092a4c9feSEric Biggers .cipher = __VECS(camellia_ctr_tv_template) 42710840605eSJussi Kivilinna } 42720840605eSJussi Kivilinna }, { 4273a2c58260SJohannes Goetzfried .alg = "ctr(cast5)", 4274a2c58260SJohannes Goetzfried .test = alg_test_skcipher, 4275a2c58260SJohannes Goetzfried .suite = { 427692a4c9feSEric Biggers .cipher = __VECS(cast5_ctr_tv_template) 4277a2c58260SJohannes Goetzfried } 4278a2c58260SJohannes Goetzfried }, { 42799b8b0405SJohannes Goetzfried .alg = "ctr(cast6)", 42809b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 42819b8b0405SJohannes Goetzfried .suite = { 428292a4c9feSEric Biggers .cipher = __VECS(cast6_ctr_tv_template) 42839b8b0405SJohannes Goetzfried } 42849b8b0405SJohannes Goetzfried }, { 42858163fc30SJussi Kivilinna .alg = "ctr(des)", 42868163fc30SJussi Kivilinna .test = alg_test_skcipher, 42878163fc30SJussi Kivilinna .suite = { 428892a4c9feSEric Biggers .cipher = __VECS(des_ctr_tv_template) 42898163fc30SJussi Kivilinna } 42908163fc30SJussi Kivilinna }, { 4291e080b17aSJussi Kivilinna .alg = "ctr(des3_ede)", 4292e080b17aSJussi Kivilinna .test = alg_test_skcipher, 42930d8da104SMarcelo Cerri .fips_allowed = 1, 4294e080b17aSJussi Kivilinna .suite = { 429592a4c9feSEric Biggers .cipher = __VECS(des3_ede_ctr_tv_template) 4296e080b17aSJussi Kivilinna } 4297e080b17aSJussi Kivilinna }, { 4298a794d8d8SGilad Ben-Yossef /* Same as ctr(aes) except the key is stored in 4299a794d8d8SGilad Ben-Yossef * hardware secure memory which we reference by index 4300a794d8d8SGilad Ben-Yossef */ 4301a794d8d8SGilad Ben-Yossef .alg = "ctr(paes)", 4302a794d8d8SGilad Ben-Yossef .test = alg_test_null, 4303a794d8d8SGilad Ben-Yossef .fips_allowed = 1, 4304a794d8d8SGilad Ben-Yossef }, { 4305f0372c00SGilad Ben-Yossef 4306f0372c00SGilad Ben-Yossef /* Same as ctr(sm4) except the key is stored in 4307f0372c00SGilad Ben-Yossef * hardware secure memory which we reference by index 4308f0372c00SGilad Ben-Yossef */ 4309f0372c00SGilad Ben-Yossef .alg = "ctr(psm4)", 4310f0372c00SGilad Ben-Yossef .test = alg_test_null, 4311f0372c00SGilad Ben-Yossef }, { 43129d25917dSJussi Kivilinna .alg = "ctr(serpent)", 43139d25917dSJussi Kivilinna .test = alg_test_skcipher, 43149d25917dSJussi Kivilinna .suite = { 431592a4c9feSEric Biggers .cipher = __VECS(serpent_ctr_tv_template) 43169d25917dSJussi Kivilinna } 43179d25917dSJussi Kivilinna }, { 431895ba5973SGilad Ben-Yossef .alg = "ctr(sm4)", 431995ba5973SGilad Ben-Yossef .test = alg_test_skcipher, 432095ba5973SGilad Ben-Yossef .suite = { 432195ba5973SGilad Ben-Yossef .cipher = __VECS(sm4_ctr_tv_template) 432295ba5973SGilad Ben-Yossef } 432395ba5973SGilad Ben-Yossef }, { 4324573da620SJussi Kivilinna .alg = "ctr(twofish)", 4325573da620SJussi Kivilinna .test = alg_test_skcipher, 4326573da620SJussi Kivilinna .suite = { 432792a4c9feSEric Biggers .cipher = __VECS(tf_ctr_tv_template) 4328573da620SJussi Kivilinna } 4329573da620SJussi Kivilinna }, { 4330da7f033dSHerbert Xu .alg = "cts(cbc(aes))", 43311aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4332196ad604SGilad Ben-Yossef .fips_allowed = 1, 4333da7f033dSHerbert Xu .suite = { 433492a4c9feSEric Biggers .cipher = __VECS(cts_mode_tv_template) 4335da7f033dSHerbert Xu } 4336da7f033dSHerbert Xu }, { 4337f0372c00SGilad Ben-Yossef /* Same as cts(cbc((aes)) except the key is stored in 4338f0372c00SGilad Ben-Yossef * hardware secure memory which we reference by index 4339f0372c00SGilad Ben-Yossef */ 4340f0372c00SGilad Ben-Yossef .alg = "cts(cbc(paes))", 4341f0372c00SGilad Ben-Yossef .test = alg_test_null, 4342f0372c00SGilad Ben-Yossef .fips_allowed = 1, 4343f0372c00SGilad Ben-Yossef }, { 4344f613457aSArd Biesheuvel .alg = "curve25519", 4345f613457aSArd Biesheuvel .test = alg_test_kpp, 4346f613457aSArd Biesheuvel .suite = { 4347f613457aSArd Biesheuvel .kpp = __VECS(curve25519_tv_template) 4348f613457aSArd Biesheuvel } 4349f613457aSArd Biesheuvel }, { 4350da7f033dSHerbert Xu .alg = "deflate", 4351da7f033dSHerbert Xu .test = alg_test_comp, 43520818904dSMilan Broz .fips_allowed = 1, 4353da7f033dSHerbert Xu .suite = { 4354da7f033dSHerbert Xu .comp = { 435521c8e720SArd Biesheuvel .comp = __VECS(deflate_comp_tv_template), 435621c8e720SArd Biesheuvel .decomp = __VECS(deflate_decomp_tv_template) 4357da7f033dSHerbert Xu } 4358da7f033dSHerbert Xu } 4359da7f033dSHerbert Xu }, { 4360802c7f1cSSalvatore Benedetto .alg = "dh", 4361802c7f1cSSalvatore Benedetto .test = alg_test_kpp, 4362802c7f1cSSalvatore Benedetto .fips_allowed = 1, 4363802c7f1cSSalvatore Benedetto .suite = { 436421c8e720SArd Biesheuvel .kpp = __VECS(dh_tv_template) 4365802c7f1cSSalvatore Benedetto } 4366802c7f1cSSalvatore Benedetto }, { 4367e448370dSJussi Kivilinna .alg = "digest_null", 4368e448370dSJussi Kivilinna .test = alg_test_null, 4369e448370dSJussi Kivilinna }, { 437064d1cdfbSStephan Mueller .alg = "drbg_nopr_ctr_aes128", 437164d1cdfbSStephan Mueller .test = alg_test_drbg, 437264d1cdfbSStephan Mueller .fips_allowed = 1, 437364d1cdfbSStephan Mueller .suite = { 437421c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_ctr_aes128_tv_template) 437564d1cdfbSStephan Mueller } 437664d1cdfbSStephan Mueller }, { 437764d1cdfbSStephan Mueller .alg = "drbg_nopr_ctr_aes192", 437864d1cdfbSStephan Mueller .test = alg_test_drbg, 437964d1cdfbSStephan Mueller .fips_allowed = 1, 438064d1cdfbSStephan Mueller .suite = { 438121c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_ctr_aes192_tv_template) 438264d1cdfbSStephan Mueller } 438364d1cdfbSStephan Mueller }, { 438464d1cdfbSStephan Mueller .alg = "drbg_nopr_ctr_aes256", 438564d1cdfbSStephan Mueller .test = alg_test_drbg, 438664d1cdfbSStephan Mueller .fips_allowed = 1, 438764d1cdfbSStephan Mueller .suite = { 438821c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_ctr_aes256_tv_template) 438964d1cdfbSStephan Mueller } 439064d1cdfbSStephan Mueller }, { 439164d1cdfbSStephan Mueller /* 439264d1cdfbSStephan Mueller * There is no need to specifically test the DRBG with every 439364d1cdfbSStephan Mueller * backend cipher -- covered by drbg_nopr_hmac_sha256 test 439464d1cdfbSStephan Mueller */ 439564d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha1", 439664d1cdfbSStephan Mueller .fips_allowed = 1, 439764d1cdfbSStephan Mueller .test = alg_test_null, 439864d1cdfbSStephan Mueller }, { 439964d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha256", 440064d1cdfbSStephan Mueller .test = alg_test_drbg, 440164d1cdfbSStephan Mueller .fips_allowed = 1, 440264d1cdfbSStephan Mueller .suite = { 440321c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_hmac_sha256_tv_template) 440464d1cdfbSStephan Mueller } 440564d1cdfbSStephan Mueller }, { 440664d1cdfbSStephan Mueller /* covered by drbg_nopr_hmac_sha256 test */ 440764d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha384", 440864d1cdfbSStephan Mueller .fips_allowed = 1, 440964d1cdfbSStephan Mueller .test = alg_test_null, 441064d1cdfbSStephan Mueller }, { 441164d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha512", 441264d1cdfbSStephan Mueller .test = alg_test_null, 441364d1cdfbSStephan Mueller .fips_allowed = 1, 441464d1cdfbSStephan Mueller }, { 441564d1cdfbSStephan Mueller .alg = "drbg_nopr_sha1", 441664d1cdfbSStephan Mueller .fips_allowed = 1, 441764d1cdfbSStephan Mueller .test = alg_test_null, 441864d1cdfbSStephan Mueller }, { 441964d1cdfbSStephan Mueller .alg = "drbg_nopr_sha256", 442064d1cdfbSStephan Mueller .test = alg_test_drbg, 442164d1cdfbSStephan Mueller .fips_allowed = 1, 442264d1cdfbSStephan Mueller .suite = { 442321c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_sha256_tv_template) 442464d1cdfbSStephan Mueller } 442564d1cdfbSStephan Mueller }, { 442664d1cdfbSStephan Mueller /* covered by drbg_nopr_sha256 test */ 442764d1cdfbSStephan Mueller .alg = "drbg_nopr_sha384", 442864d1cdfbSStephan Mueller .fips_allowed = 1, 442964d1cdfbSStephan Mueller .test = alg_test_null, 443064d1cdfbSStephan Mueller }, { 443164d1cdfbSStephan Mueller .alg = "drbg_nopr_sha512", 443264d1cdfbSStephan Mueller .fips_allowed = 1, 443364d1cdfbSStephan Mueller .test = alg_test_null, 443464d1cdfbSStephan Mueller }, { 443564d1cdfbSStephan Mueller .alg = "drbg_pr_ctr_aes128", 443664d1cdfbSStephan Mueller .test = alg_test_drbg, 443764d1cdfbSStephan Mueller .fips_allowed = 1, 443864d1cdfbSStephan Mueller .suite = { 443921c8e720SArd Biesheuvel .drbg = __VECS(drbg_pr_ctr_aes128_tv_template) 444064d1cdfbSStephan Mueller } 444164d1cdfbSStephan Mueller }, { 444264d1cdfbSStephan Mueller /* covered by drbg_pr_ctr_aes128 test */ 444364d1cdfbSStephan Mueller .alg = "drbg_pr_ctr_aes192", 444464d1cdfbSStephan Mueller .fips_allowed = 1, 444564d1cdfbSStephan Mueller .test = alg_test_null, 444664d1cdfbSStephan Mueller }, { 444764d1cdfbSStephan Mueller .alg = "drbg_pr_ctr_aes256", 444864d1cdfbSStephan Mueller .fips_allowed = 1, 444964d1cdfbSStephan Mueller .test = alg_test_null, 445064d1cdfbSStephan Mueller }, { 445164d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha1", 445264d1cdfbSStephan Mueller .fips_allowed = 1, 445364d1cdfbSStephan Mueller .test = alg_test_null, 445464d1cdfbSStephan Mueller }, { 445564d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha256", 445664d1cdfbSStephan Mueller .test = alg_test_drbg, 445764d1cdfbSStephan Mueller .fips_allowed = 1, 445864d1cdfbSStephan Mueller .suite = { 445921c8e720SArd Biesheuvel .drbg = __VECS(drbg_pr_hmac_sha256_tv_template) 446064d1cdfbSStephan Mueller } 446164d1cdfbSStephan Mueller }, { 446264d1cdfbSStephan Mueller /* covered by drbg_pr_hmac_sha256 test */ 446364d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha384", 446464d1cdfbSStephan Mueller .fips_allowed = 1, 446564d1cdfbSStephan Mueller .test = alg_test_null, 446664d1cdfbSStephan Mueller }, { 446764d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha512", 446864d1cdfbSStephan Mueller .test = alg_test_null, 446964d1cdfbSStephan Mueller .fips_allowed = 1, 447064d1cdfbSStephan Mueller }, { 447164d1cdfbSStephan Mueller .alg = "drbg_pr_sha1", 447264d1cdfbSStephan Mueller .fips_allowed = 1, 447364d1cdfbSStephan Mueller .test = alg_test_null, 447464d1cdfbSStephan Mueller }, { 447564d1cdfbSStephan Mueller .alg = "drbg_pr_sha256", 447664d1cdfbSStephan Mueller .test = alg_test_drbg, 447764d1cdfbSStephan Mueller .fips_allowed = 1, 447864d1cdfbSStephan Mueller .suite = { 447921c8e720SArd Biesheuvel .drbg = __VECS(drbg_pr_sha256_tv_template) 448064d1cdfbSStephan Mueller } 448164d1cdfbSStephan Mueller }, { 448264d1cdfbSStephan Mueller /* covered by drbg_pr_sha256 test */ 448364d1cdfbSStephan Mueller .alg = "drbg_pr_sha384", 448464d1cdfbSStephan Mueller .fips_allowed = 1, 448564d1cdfbSStephan Mueller .test = alg_test_null, 448664d1cdfbSStephan Mueller }, { 448764d1cdfbSStephan Mueller .alg = "drbg_pr_sha512", 448864d1cdfbSStephan Mueller .fips_allowed = 1, 448964d1cdfbSStephan Mueller .test = alg_test_null, 449064d1cdfbSStephan Mueller }, { 4491da7f033dSHerbert Xu .alg = "ecb(aes)", 44921aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4493a1915d51SJarod Wilson .fips_allowed = 1, 4494da7f033dSHerbert Xu .suite = { 449592a4c9feSEric Biggers .cipher = __VECS(aes_tv_template) 4496da7f033dSHerbert Xu } 4497da7f033dSHerbert Xu }, { 4498da7f033dSHerbert Xu .alg = "ecb(anubis)", 44991aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4500da7f033dSHerbert Xu .suite = { 450192a4c9feSEric Biggers .cipher = __VECS(anubis_tv_template) 4502da7f033dSHerbert Xu } 4503da7f033dSHerbert Xu }, { 4504da7f033dSHerbert Xu .alg = "ecb(arc4)", 4505611a23c2SArd Biesheuvel .generic_driver = "ecb(arc4)-generic", 45061aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4507da7f033dSHerbert Xu .suite = { 450892a4c9feSEric Biggers .cipher = __VECS(arc4_tv_template) 4509da7f033dSHerbert Xu } 4510da7f033dSHerbert Xu }, { 4511da7f033dSHerbert Xu .alg = "ecb(blowfish)", 45121aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4513da7f033dSHerbert Xu .suite = { 451492a4c9feSEric Biggers .cipher = __VECS(bf_tv_template) 4515da7f033dSHerbert Xu } 4516da7f033dSHerbert Xu }, { 4517da7f033dSHerbert Xu .alg = "ecb(camellia)", 45181aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4519da7f033dSHerbert Xu .suite = { 452092a4c9feSEric Biggers .cipher = __VECS(camellia_tv_template) 4521da7f033dSHerbert Xu } 4522da7f033dSHerbert Xu }, { 4523da7f033dSHerbert Xu .alg = "ecb(cast5)", 45241aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4525da7f033dSHerbert Xu .suite = { 452692a4c9feSEric Biggers .cipher = __VECS(cast5_tv_template) 4527da7f033dSHerbert Xu } 4528da7f033dSHerbert Xu }, { 4529da7f033dSHerbert Xu .alg = "ecb(cast6)", 45301aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4531da7f033dSHerbert Xu .suite = { 453292a4c9feSEric Biggers .cipher = __VECS(cast6_tv_template) 4533da7f033dSHerbert Xu } 4534da7f033dSHerbert Xu }, { 4535e448370dSJussi Kivilinna .alg = "ecb(cipher_null)", 4536e448370dSJussi Kivilinna .test = alg_test_null, 45376175ca2bSMilan Broz .fips_allowed = 1, 4538e448370dSJussi Kivilinna }, { 4539da7f033dSHerbert Xu .alg = "ecb(des)", 45401aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4541da7f033dSHerbert Xu .suite = { 454292a4c9feSEric Biggers .cipher = __VECS(des_tv_template) 4543da7f033dSHerbert Xu } 4544da7f033dSHerbert Xu }, { 4545da7f033dSHerbert Xu .alg = "ecb(des3_ede)", 45461aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4547a1915d51SJarod Wilson .fips_allowed = 1, 4548da7f033dSHerbert Xu .suite = { 454992a4c9feSEric Biggers .cipher = __VECS(des3_ede_tv_template) 4550da7f033dSHerbert Xu } 4551da7f033dSHerbert Xu }, { 455266e5bd00SJussi Kivilinna .alg = "ecb(fcrypt)", 455366e5bd00SJussi Kivilinna .test = alg_test_skcipher, 455466e5bd00SJussi Kivilinna .suite = { 455566e5bd00SJussi Kivilinna .cipher = { 455692a4c9feSEric Biggers .vecs = fcrypt_pcbc_tv_template, 455766e5bd00SJussi Kivilinna .count = 1 455866e5bd00SJussi Kivilinna } 455966e5bd00SJussi Kivilinna } 456066e5bd00SJussi Kivilinna }, { 4561da7f033dSHerbert Xu .alg = "ecb(khazad)", 45621aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4563da7f033dSHerbert Xu .suite = { 456492a4c9feSEric Biggers .cipher = __VECS(khazad_tv_template) 4565da7f033dSHerbert Xu } 4566da7f033dSHerbert Xu }, { 456715f47ce5SGilad Ben-Yossef /* Same as ecb(aes) except the key is stored in 456815f47ce5SGilad Ben-Yossef * hardware secure memory which we reference by index 456915f47ce5SGilad Ben-Yossef */ 457015f47ce5SGilad Ben-Yossef .alg = "ecb(paes)", 457115f47ce5SGilad Ben-Yossef .test = alg_test_null, 457215f47ce5SGilad Ben-Yossef .fips_allowed = 1, 457315f47ce5SGilad Ben-Yossef }, { 4574da7f033dSHerbert Xu .alg = "ecb(seed)", 45751aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4576da7f033dSHerbert Xu .suite = { 457792a4c9feSEric Biggers .cipher = __VECS(seed_tv_template) 4578da7f033dSHerbert Xu } 4579da7f033dSHerbert Xu }, { 4580da7f033dSHerbert Xu .alg = "ecb(serpent)", 45811aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4582da7f033dSHerbert Xu .suite = { 458392a4c9feSEric Biggers .cipher = __VECS(serpent_tv_template) 4584da7f033dSHerbert Xu } 4585da7f033dSHerbert Xu }, { 4586cd83a8a7SGilad Ben-Yossef .alg = "ecb(sm4)", 4587cd83a8a7SGilad Ben-Yossef .test = alg_test_skcipher, 4588cd83a8a7SGilad Ben-Yossef .suite = { 458992a4c9feSEric Biggers .cipher = __VECS(sm4_tv_template) 4590cd83a8a7SGilad Ben-Yossef } 4591cd83a8a7SGilad Ben-Yossef }, { 4592da7f033dSHerbert Xu .alg = "ecb(tea)", 45931aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4594da7f033dSHerbert Xu .suite = { 459592a4c9feSEric Biggers .cipher = __VECS(tea_tv_template) 4596da7f033dSHerbert Xu } 4597da7f033dSHerbert Xu }, { 4598da7f033dSHerbert Xu .alg = "ecb(tnepres)", 45991aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4600da7f033dSHerbert Xu .suite = { 460192a4c9feSEric Biggers .cipher = __VECS(tnepres_tv_template) 4602da7f033dSHerbert Xu } 4603da7f033dSHerbert Xu }, { 4604da7f033dSHerbert Xu .alg = "ecb(twofish)", 46051aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4606da7f033dSHerbert Xu .suite = { 460792a4c9feSEric Biggers .cipher = __VECS(tf_tv_template) 4608da7f033dSHerbert Xu } 4609da7f033dSHerbert Xu }, { 4610da7f033dSHerbert Xu .alg = "ecb(xeta)", 46111aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4612da7f033dSHerbert Xu .suite = { 461392a4c9feSEric Biggers .cipher = __VECS(xeta_tv_template) 4614da7f033dSHerbert Xu } 4615da7f033dSHerbert Xu }, { 4616da7f033dSHerbert Xu .alg = "ecb(xtea)", 46171aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4618da7f033dSHerbert Xu .suite = { 461992a4c9feSEric Biggers .cipher = __VECS(xtea_tv_template) 4620da7f033dSHerbert Xu } 4621da7f033dSHerbert Xu }, { 46223c4b2390SSalvatore Benedetto .alg = "ecdh", 46233c4b2390SSalvatore Benedetto .test = alg_test_kpp, 46243c4b2390SSalvatore Benedetto .fips_allowed = 1, 46253c4b2390SSalvatore Benedetto .suite = { 462621c8e720SArd Biesheuvel .kpp = __VECS(ecdh_tv_template) 46273c4b2390SSalvatore Benedetto } 46283c4b2390SSalvatore Benedetto }, { 462932fbdbd3SVitaly Chikunov .alg = "ecrdsa", 463032fbdbd3SVitaly Chikunov .test = alg_test_akcipher, 463132fbdbd3SVitaly Chikunov .suite = { 463232fbdbd3SVitaly Chikunov .akcipher = __VECS(ecrdsa_tv_template) 463332fbdbd3SVitaly Chikunov } 463432fbdbd3SVitaly Chikunov }, { 4635f975abb2SArd Biesheuvel .alg = "essiv(authenc(hmac(sha256),cbc(aes)),sha256)", 4636f975abb2SArd Biesheuvel .test = alg_test_aead, 4637f975abb2SArd Biesheuvel .fips_allowed = 1, 4638f975abb2SArd Biesheuvel .suite = { 4639f975abb2SArd Biesheuvel .aead = __VECS(essiv_hmac_sha256_aes_cbc_tv_temp) 4640f975abb2SArd Biesheuvel } 4641f975abb2SArd Biesheuvel }, { 4642f975abb2SArd Biesheuvel .alg = "essiv(cbc(aes),sha256)", 4643f975abb2SArd Biesheuvel .test = alg_test_skcipher, 4644f975abb2SArd Biesheuvel .fips_allowed = 1, 4645f975abb2SArd Biesheuvel .suite = { 4646f975abb2SArd Biesheuvel .cipher = __VECS(essiv_aes_cbc_tv_template) 4647f975abb2SArd Biesheuvel } 4648f975abb2SArd Biesheuvel }, { 4649da7f033dSHerbert Xu .alg = "gcm(aes)", 465040153b10SEric Biggers .generic_driver = "gcm_base(ctr(aes-generic),ghash-generic)", 4651da7f033dSHerbert Xu .test = alg_test_aead, 4652a1915d51SJarod Wilson .fips_allowed = 1, 4653da7f033dSHerbert Xu .suite = { 4654a0d608eeSEric Biggers .aead = __VECS(aes_gcm_tv_template) 4655da7f033dSHerbert Xu } 4656da7f033dSHerbert Xu }, { 4657507069c9SYouquan, Song .alg = "ghash", 4658507069c9SYouquan, Song .test = alg_test_hash, 465918c0ebd2SJarod Wilson .fips_allowed = 1, 4660507069c9SYouquan, Song .suite = { 466121c8e720SArd Biesheuvel .hash = __VECS(ghash_tv_template) 4662507069c9SYouquan, Song } 4663507069c9SYouquan, Song }, { 4664da7f033dSHerbert Xu .alg = "hmac(md5)", 4665da7f033dSHerbert Xu .test = alg_test_hash, 4666da7f033dSHerbert Xu .suite = { 466721c8e720SArd Biesheuvel .hash = __VECS(hmac_md5_tv_template) 4668da7f033dSHerbert Xu } 4669da7f033dSHerbert Xu }, { 4670da7f033dSHerbert Xu .alg = "hmac(rmd128)", 4671da7f033dSHerbert Xu .test = alg_test_hash, 4672da7f033dSHerbert Xu .suite = { 467321c8e720SArd Biesheuvel .hash = __VECS(hmac_rmd128_tv_template) 4674da7f033dSHerbert Xu } 4675da7f033dSHerbert Xu }, { 4676da7f033dSHerbert Xu .alg = "hmac(rmd160)", 4677da7f033dSHerbert Xu .test = alg_test_hash, 4678da7f033dSHerbert Xu .suite = { 467921c8e720SArd Biesheuvel .hash = __VECS(hmac_rmd160_tv_template) 4680da7f033dSHerbert Xu } 4681da7f033dSHerbert Xu }, { 4682da7f033dSHerbert Xu .alg = "hmac(sha1)", 4683da7f033dSHerbert Xu .test = alg_test_hash, 4684a1915d51SJarod Wilson .fips_allowed = 1, 4685da7f033dSHerbert Xu .suite = { 468621c8e720SArd Biesheuvel .hash = __VECS(hmac_sha1_tv_template) 4687da7f033dSHerbert Xu } 4688da7f033dSHerbert Xu }, { 4689da7f033dSHerbert Xu .alg = "hmac(sha224)", 4690da7f033dSHerbert Xu .test = alg_test_hash, 4691a1915d51SJarod Wilson .fips_allowed = 1, 4692da7f033dSHerbert Xu .suite = { 469321c8e720SArd Biesheuvel .hash = __VECS(hmac_sha224_tv_template) 4694da7f033dSHerbert Xu } 4695da7f033dSHerbert Xu }, { 4696da7f033dSHerbert Xu .alg = "hmac(sha256)", 4697da7f033dSHerbert Xu .test = alg_test_hash, 4698a1915d51SJarod Wilson .fips_allowed = 1, 4699da7f033dSHerbert Xu .suite = { 470021c8e720SArd Biesheuvel .hash = __VECS(hmac_sha256_tv_template) 4701da7f033dSHerbert Xu } 4702da7f033dSHerbert Xu }, { 470398eca72fSraveendra padasalagi .alg = "hmac(sha3-224)", 470498eca72fSraveendra padasalagi .test = alg_test_hash, 470598eca72fSraveendra padasalagi .fips_allowed = 1, 470698eca72fSraveendra padasalagi .suite = { 470721c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_224_tv_template) 470898eca72fSraveendra padasalagi } 470998eca72fSraveendra padasalagi }, { 471098eca72fSraveendra padasalagi .alg = "hmac(sha3-256)", 471198eca72fSraveendra padasalagi .test = alg_test_hash, 471298eca72fSraveendra padasalagi .fips_allowed = 1, 471398eca72fSraveendra padasalagi .suite = { 471421c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_256_tv_template) 471598eca72fSraveendra padasalagi } 471698eca72fSraveendra padasalagi }, { 471798eca72fSraveendra padasalagi .alg = "hmac(sha3-384)", 471898eca72fSraveendra padasalagi .test = alg_test_hash, 471998eca72fSraveendra padasalagi .fips_allowed = 1, 472098eca72fSraveendra padasalagi .suite = { 472121c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_384_tv_template) 472298eca72fSraveendra padasalagi } 472398eca72fSraveendra padasalagi }, { 472498eca72fSraveendra padasalagi .alg = "hmac(sha3-512)", 472598eca72fSraveendra padasalagi .test = alg_test_hash, 472698eca72fSraveendra padasalagi .fips_allowed = 1, 472798eca72fSraveendra padasalagi .suite = { 472821c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_512_tv_template) 472998eca72fSraveendra padasalagi } 473098eca72fSraveendra padasalagi }, { 4731da7f033dSHerbert Xu .alg = "hmac(sha384)", 4732da7f033dSHerbert Xu .test = alg_test_hash, 4733a1915d51SJarod Wilson .fips_allowed = 1, 4734da7f033dSHerbert Xu .suite = { 473521c8e720SArd Biesheuvel .hash = __VECS(hmac_sha384_tv_template) 4736da7f033dSHerbert Xu } 4737da7f033dSHerbert Xu }, { 4738da7f033dSHerbert Xu .alg = "hmac(sha512)", 4739da7f033dSHerbert Xu .test = alg_test_hash, 4740a1915d51SJarod Wilson .fips_allowed = 1, 4741da7f033dSHerbert Xu .suite = { 474221c8e720SArd Biesheuvel .hash = __VECS(hmac_sha512_tv_template) 4743da7f033dSHerbert Xu } 4744da7f033dSHerbert Xu }, { 47458194fd1dSPascal van Leeuwen .alg = "hmac(sm3)", 47468194fd1dSPascal van Leeuwen .test = alg_test_hash, 47478194fd1dSPascal van Leeuwen .suite = { 47488194fd1dSPascal van Leeuwen .hash = __VECS(hmac_sm3_tv_template) 47498194fd1dSPascal van Leeuwen } 47508194fd1dSPascal van Leeuwen }, { 475125a0b9d4SVitaly Chikunov .alg = "hmac(streebog256)", 475225a0b9d4SVitaly Chikunov .test = alg_test_hash, 475325a0b9d4SVitaly Chikunov .suite = { 475425a0b9d4SVitaly Chikunov .hash = __VECS(hmac_streebog256_tv_template) 475525a0b9d4SVitaly Chikunov } 475625a0b9d4SVitaly Chikunov }, { 475725a0b9d4SVitaly Chikunov .alg = "hmac(streebog512)", 475825a0b9d4SVitaly Chikunov .test = alg_test_hash, 475925a0b9d4SVitaly Chikunov .suite = { 476025a0b9d4SVitaly Chikunov .hash = __VECS(hmac_streebog512_tv_template) 476125a0b9d4SVitaly Chikunov } 476225a0b9d4SVitaly Chikunov }, { 4763bb5530e4SStephan Mueller .alg = "jitterentropy_rng", 4764bb5530e4SStephan Mueller .fips_allowed = 1, 4765bb5530e4SStephan Mueller .test = alg_test_null, 4766bb5530e4SStephan Mueller }, { 476735351988SStephan Mueller .alg = "kw(aes)", 476835351988SStephan Mueller .test = alg_test_skcipher, 476935351988SStephan Mueller .fips_allowed = 1, 477035351988SStephan Mueller .suite = { 477192a4c9feSEric Biggers .cipher = __VECS(aes_kw_tv_template) 477235351988SStephan Mueller } 477335351988SStephan Mueller }, { 4774da7f033dSHerbert Xu .alg = "lrw(aes)", 4775d435e10eSEric Biggers .generic_driver = "lrw(ecb(aes-generic))", 47761aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4777da7f033dSHerbert Xu .suite = { 477892a4c9feSEric Biggers .cipher = __VECS(aes_lrw_tv_template) 4779da7f033dSHerbert Xu } 4780da7f033dSHerbert Xu }, { 47810840605eSJussi Kivilinna .alg = "lrw(camellia)", 4782d435e10eSEric Biggers .generic_driver = "lrw(ecb(camellia-generic))", 47830840605eSJussi Kivilinna .test = alg_test_skcipher, 47840840605eSJussi Kivilinna .suite = { 478592a4c9feSEric Biggers .cipher = __VECS(camellia_lrw_tv_template) 47860840605eSJussi Kivilinna } 47870840605eSJussi Kivilinna }, { 47889b8b0405SJohannes Goetzfried .alg = "lrw(cast6)", 4789d435e10eSEric Biggers .generic_driver = "lrw(ecb(cast6-generic))", 47909b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 47919b8b0405SJohannes Goetzfried .suite = { 479292a4c9feSEric Biggers .cipher = __VECS(cast6_lrw_tv_template) 47939b8b0405SJohannes Goetzfried } 47949b8b0405SJohannes Goetzfried }, { 4795d7bfc0faSJussi Kivilinna .alg = "lrw(serpent)", 4796d435e10eSEric Biggers .generic_driver = "lrw(ecb(serpent-generic))", 4797d7bfc0faSJussi Kivilinna .test = alg_test_skcipher, 4798d7bfc0faSJussi Kivilinna .suite = { 479992a4c9feSEric Biggers .cipher = __VECS(serpent_lrw_tv_template) 4800d7bfc0faSJussi Kivilinna } 4801d7bfc0faSJussi Kivilinna }, { 48020b2a1551SJussi Kivilinna .alg = "lrw(twofish)", 4803d435e10eSEric Biggers .generic_driver = "lrw(ecb(twofish-generic))", 48040b2a1551SJussi Kivilinna .test = alg_test_skcipher, 48050b2a1551SJussi Kivilinna .suite = { 480692a4c9feSEric Biggers .cipher = __VECS(tf_lrw_tv_template) 48070b2a1551SJussi Kivilinna } 48080b2a1551SJussi Kivilinna }, { 48091443cc9bSKOVACS Krisztian .alg = "lz4", 48101443cc9bSKOVACS Krisztian .test = alg_test_comp, 48111443cc9bSKOVACS Krisztian .fips_allowed = 1, 48121443cc9bSKOVACS Krisztian .suite = { 48131443cc9bSKOVACS Krisztian .comp = { 481421c8e720SArd Biesheuvel .comp = __VECS(lz4_comp_tv_template), 481521c8e720SArd Biesheuvel .decomp = __VECS(lz4_decomp_tv_template) 48161443cc9bSKOVACS Krisztian } 48171443cc9bSKOVACS Krisztian } 48181443cc9bSKOVACS Krisztian }, { 48191443cc9bSKOVACS Krisztian .alg = "lz4hc", 48201443cc9bSKOVACS Krisztian .test = alg_test_comp, 48211443cc9bSKOVACS Krisztian .fips_allowed = 1, 48221443cc9bSKOVACS Krisztian .suite = { 48231443cc9bSKOVACS Krisztian .comp = { 482421c8e720SArd Biesheuvel .comp = __VECS(lz4hc_comp_tv_template), 482521c8e720SArd Biesheuvel .decomp = __VECS(lz4hc_decomp_tv_template) 48261443cc9bSKOVACS Krisztian } 48271443cc9bSKOVACS Krisztian } 48281443cc9bSKOVACS Krisztian }, { 4829da7f033dSHerbert Xu .alg = "lzo", 4830da7f033dSHerbert Xu .test = alg_test_comp, 48310818904dSMilan Broz .fips_allowed = 1, 4832da7f033dSHerbert Xu .suite = { 4833da7f033dSHerbert Xu .comp = { 483421c8e720SArd Biesheuvel .comp = __VECS(lzo_comp_tv_template), 483521c8e720SArd Biesheuvel .decomp = __VECS(lzo_decomp_tv_template) 4836da7f033dSHerbert Xu } 4837da7f033dSHerbert Xu } 4838da7f033dSHerbert Xu }, { 4839f248caf9SHannah Pan .alg = "lzo-rle", 4840f248caf9SHannah Pan .test = alg_test_comp, 4841f248caf9SHannah Pan .fips_allowed = 1, 4842f248caf9SHannah Pan .suite = { 4843f248caf9SHannah Pan .comp = { 4844f248caf9SHannah Pan .comp = __VECS(lzorle_comp_tv_template), 4845f248caf9SHannah Pan .decomp = __VECS(lzorle_decomp_tv_template) 4846f248caf9SHannah Pan } 4847f248caf9SHannah Pan } 4848f248caf9SHannah Pan }, { 4849da7f033dSHerbert Xu .alg = "md4", 4850da7f033dSHerbert Xu .test = alg_test_hash, 4851da7f033dSHerbert Xu .suite = { 485221c8e720SArd Biesheuvel .hash = __VECS(md4_tv_template) 4853da7f033dSHerbert Xu } 4854da7f033dSHerbert Xu }, { 4855da7f033dSHerbert Xu .alg = "md5", 4856da7f033dSHerbert Xu .test = alg_test_hash, 4857da7f033dSHerbert Xu .suite = { 485821c8e720SArd Biesheuvel .hash = __VECS(md5_tv_template) 4859da7f033dSHerbert Xu } 4860da7f033dSHerbert Xu }, { 4861da7f033dSHerbert Xu .alg = "michael_mic", 4862da7f033dSHerbert Xu .test = alg_test_hash, 4863da7f033dSHerbert Xu .suite = { 486421c8e720SArd Biesheuvel .hash = __VECS(michael_mic_tv_template) 4865da7f033dSHerbert Xu } 4866da7f033dSHerbert Xu }, { 486726609a21SEric Biggers .alg = "nhpoly1305", 486826609a21SEric Biggers .test = alg_test_hash, 486926609a21SEric Biggers .suite = { 487026609a21SEric Biggers .hash = __VECS(nhpoly1305_tv_template) 487126609a21SEric Biggers } 487226609a21SEric Biggers }, { 4873ba0e14acSPuneet Saxena .alg = "ofb(aes)", 4874ba0e14acSPuneet Saxena .test = alg_test_skcipher, 4875ba0e14acSPuneet Saxena .fips_allowed = 1, 4876ba0e14acSPuneet Saxena .suite = { 487792a4c9feSEric Biggers .cipher = __VECS(aes_ofb_tv_template) 4878ba0e14acSPuneet Saxena } 4879ba0e14acSPuneet Saxena }, { 4880a794d8d8SGilad Ben-Yossef /* Same as ofb(aes) except the key is stored in 4881a794d8d8SGilad Ben-Yossef * hardware secure memory which we reference by index 4882a794d8d8SGilad Ben-Yossef */ 4883a794d8d8SGilad Ben-Yossef .alg = "ofb(paes)", 4884a794d8d8SGilad Ben-Yossef .test = alg_test_null, 4885a794d8d8SGilad Ben-Yossef .fips_allowed = 1, 4886a794d8d8SGilad Ben-Yossef }, { 4887a06b15b2SPascal van Leeuwen .alg = "ofb(sm4)", 4888a06b15b2SPascal van Leeuwen .test = alg_test_skcipher, 4889a06b15b2SPascal van Leeuwen .suite = { 4890a06b15b2SPascal van Leeuwen .cipher = __VECS(sm4_ofb_tv_template) 4891a06b15b2SPascal van Leeuwen } 4892a06b15b2SPascal van Leeuwen }, { 4893da7f033dSHerbert Xu .alg = "pcbc(fcrypt)", 48941aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4895da7f033dSHerbert Xu .suite = { 489692a4c9feSEric Biggers .cipher = __VECS(fcrypt_pcbc_tv_template) 4897da7f033dSHerbert Xu } 4898da7f033dSHerbert Xu }, { 48991207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha224)", 49001207107cSStephan Mueller .test = alg_test_null, 49011207107cSStephan Mueller .fips_allowed = 1, 49021207107cSStephan Mueller }, { 49031207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha256)", 49041207107cSStephan Mueller .test = alg_test_akcipher, 49051207107cSStephan Mueller .fips_allowed = 1, 49061207107cSStephan Mueller .suite = { 49071207107cSStephan Mueller .akcipher = __VECS(pkcs1pad_rsa_tv_template) 49081207107cSStephan Mueller } 49091207107cSStephan Mueller }, { 49101207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha384)", 49111207107cSStephan Mueller .test = alg_test_null, 49121207107cSStephan Mueller .fips_allowed = 1, 49131207107cSStephan Mueller }, { 49141207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha512)", 49151207107cSStephan Mueller .test = alg_test_null, 49161207107cSStephan Mueller .fips_allowed = 1, 49171207107cSStephan Mueller }, { 4918eee9dc61SMartin Willi .alg = "poly1305", 4919eee9dc61SMartin Willi .test = alg_test_hash, 4920eee9dc61SMartin Willi .suite = { 492121c8e720SArd Biesheuvel .hash = __VECS(poly1305_tv_template) 4922eee9dc61SMartin Willi } 4923eee9dc61SMartin Willi }, { 4924da7f033dSHerbert Xu .alg = "rfc3686(ctr(aes))", 49251aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4926a1915d51SJarod Wilson .fips_allowed = 1, 4927da7f033dSHerbert Xu .suite = { 492892a4c9feSEric Biggers .cipher = __VECS(aes_ctr_rfc3686_tv_template) 4929da7f033dSHerbert Xu } 4930da7f033dSHerbert Xu }, { 4931e4886214SPascal van Leeuwen .alg = "rfc3686(ctr(sm4))", 4932e4886214SPascal van Leeuwen .test = alg_test_skcipher, 4933e4886214SPascal van Leeuwen .suite = { 4934e4886214SPascal van Leeuwen .cipher = __VECS(sm4_ctr_rfc3686_tv_template) 4935e4886214SPascal van Leeuwen } 4936e4886214SPascal van Leeuwen }, { 49373f31a740SHerbert Xu .alg = "rfc4106(gcm(aes))", 493840153b10SEric Biggers .generic_driver = "rfc4106(gcm_base(ctr(aes-generic),ghash-generic))", 493969435b94SAdrian Hoban .test = alg_test_aead, 4940db71f29aSJarod Wilson .fips_allowed = 1, 494169435b94SAdrian Hoban .suite = { 4942a0d608eeSEric Biggers .aead = __VECS(aes_gcm_rfc4106_tv_template) 494369435b94SAdrian Hoban } 494469435b94SAdrian Hoban }, { 4945544c436aSHerbert Xu .alg = "rfc4309(ccm(aes))", 494640153b10SEric Biggers .generic_driver = "rfc4309(ccm_base(ctr(aes-generic),cbcmac(aes-generic)))", 49475d667322SJarod Wilson .test = alg_test_aead, 4948a1915d51SJarod Wilson .fips_allowed = 1, 49495d667322SJarod Wilson .suite = { 4950a0d608eeSEric Biggers .aead = __VECS(aes_ccm_rfc4309_tv_template) 49515d667322SJarod Wilson } 49525d667322SJarod Wilson }, { 4953bb68745eSHerbert Xu .alg = "rfc4543(gcm(aes))", 495440153b10SEric Biggers .generic_driver = "rfc4543(gcm_base(ctr(aes-generic),ghash-generic))", 4955e9b7441aSJussi Kivilinna .test = alg_test_aead, 4956e9b7441aSJussi Kivilinna .suite = { 4957a0d608eeSEric Biggers .aead = __VECS(aes_gcm_rfc4543_tv_template) 4958e9b7441aSJussi Kivilinna } 4959e9b7441aSJussi Kivilinna }, { 4960af2b76b5SMartin Willi .alg = "rfc7539(chacha20,poly1305)", 4961af2b76b5SMartin Willi .test = alg_test_aead, 4962af2b76b5SMartin Willi .suite = { 4963a0d608eeSEric Biggers .aead = __VECS(rfc7539_tv_template) 4964af2b76b5SMartin Willi } 4965af2b76b5SMartin Willi }, { 49665900758dSMartin Willi .alg = "rfc7539esp(chacha20,poly1305)", 49675900758dSMartin Willi .test = alg_test_aead, 49685900758dSMartin Willi .suite = { 4969a0d608eeSEric Biggers .aead = __VECS(rfc7539esp_tv_template) 49705900758dSMartin Willi } 49715900758dSMartin Willi }, { 4972da7f033dSHerbert Xu .alg = "rmd128", 4973da7f033dSHerbert Xu .test = alg_test_hash, 4974da7f033dSHerbert Xu .suite = { 497521c8e720SArd Biesheuvel .hash = __VECS(rmd128_tv_template) 4976da7f033dSHerbert Xu } 4977da7f033dSHerbert Xu }, { 4978da7f033dSHerbert Xu .alg = "rmd160", 4979da7f033dSHerbert Xu .test = alg_test_hash, 4980da7f033dSHerbert Xu .suite = { 498121c8e720SArd Biesheuvel .hash = __VECS(rmd160_tv_template) 4982da7f033dSHerbert Xu } 4983da7f033dSHerbert Xu }, { 4984da7f033dSHerbert Xu .alg = "rmd256", 4985da7f033dSHerbert Xu .test = alg_test_hash, 4986da7f033dSHerbert Xu .suite = { 498721c8e720SArd Biesheuvel .hash = __VECS(rmd256_tv_template) 4988da7f033dSHerbert Xu } 4989da7f033dSHerbert Xu }, { 4990da7f033dSHerbert Xu .alg = "rmd320", 4991da7f033dSHerbert Xu .test = alg_test_hash, 4992da7f033dSHerbert Xu .suite = { 499321c8e720SArd Biesheuvel .hash = __VECS(rmd320_tv_template) 4994da7f033dSHerbert Xu } 4995da7f033dSHerbert Xu }, { 4996946cc463STadeusz Struk .alg = "rsa", 4997946cc463STadeusz Struk .test = alg_test_akcipher, 4998946cc463STadeusz Struk .fips_allowed = 1, 4999946cc463STadeusz Struk .suite = { 500021c8e720SArd Biesheuvel .akcipher = __VECS(rsa_tv_template) 5001946cc463STadeusz Struk } 5002946cc463STadeusz Struk }, { 5003da7f033dSHerbert Xu .alg = "salsa20", 50041aa4ecd9SHerbert Xu .test = alg_test_skcipher, 5005da7f033dSHerbert Xu .suite = { 500692a4c9feSEric Biggers .cipher = __VECS(salsa20_stream_tv_template) 5007da7f033dSHerbert Xu } 5008da7f033dSHerbert Xu }, { 5009da7f033dSHerbert Xu .alg = "sha1", 5010da7f033dSHerbert Xu .test = alg_test_hash, 5011a1915d51SJarod Wilson .fips_allowed = 1, 5012da7f033dSHerbert Xu .suite = { 501321c8e720SArd Biesheuvel .hash = __VECS(sha1_tv_template) 5014da7f033dSHerbert Xu } 5015da7f033dSHerbert Xu }, { 5016da7f033dSHerbert Xu .alg = "sha224", 5017da7f033dSHerbert Xu .test = alg_test_hash, 5018a1915d51SJarod Wilson .fips_allowed = 1, 5019da7f033dSHerbert Xu .suite = { 502021c8e720SArd Biesheuvel .hash = __VECS(sha224_tv_template) 5021da7f033dSHerbert Xu } 5022da7f033dSHerbert Xu }, { 5023da7f033dSHerbert Xu .alg = "sha256", 5024da7f033dSHerbert Xu .test = alg_test_hash, 5025a1915d51SJarod Wilson .fips_allowed = 1, 5026da7f033dSHerbert Xu .suite = { 502721c8e720SArd Biesheuvel .hash = __VECS(sha256_tv_template) 5028da7f033dSHerbert Xu } 5029da7f033dSHerbert Xu }, { 503079cc6ab8Sraveendra padasalagi .alg = "sha3-224", 503179cc6ab8Sraveendra padasalagi .test = alg_test_hash, 503279cc6ab8Sraveendra padasalagi .fips_allowed = 1, 503379cc6ab8Sraveendra padasalagi .suite = { 503421c8e720SArd Biesheuvel .hash = __VECS(sha3_224_tv_template) 503579cc6ab8Sraveendra padasalagi } 503679cc6ab8Sraveendra padasalagi }, { 503779cc6ab8Sraveendra padasalagi .alg = "sha3-256", 503879cc6ab8Sraveendra padasalagi .test = alg_test_hash, 503979cc6ab8Sraveendra padasalagi .fips_allowed = 1, 504079cc6ab8Sraveendra padasalagi .suite = { 504121c8e720SArd Biesheuvel .hash = __VECS(sha3_256_tv_template) 504279cc6ab8Sraveendra padasalagi } 504379cc6ab8Sraveendra padasalagi }, { 504479cc6ab8Sraveendra padasalagi .alg = "sha3-384", 504579cc6ab8Sraveendra padasalagi .test = alg_test_hash, 504679cc6ab8Sraveendra padasalagi .fips_allowed = 1, 504779cc6ab8Sraveendra padasalagi .suite = { 504821c8e720SArd Biesheuvel .hash = __VECS(sha3_384_tv_template) 504979cc6ab8Sraveendra padasalagi } 505079cc6ab8Sraveendra padasalagi }, { 505179cc6ab8Sraveendra padasalagi .alg = "sha3-512", 505279cc6ab8Sraveendra padasalagi .test = alg_test_hash, 505379cc6ab8Sraveendra padasalagi .fips_allowed = 1, 505479cc6ab8Sraveendra padasalagi .suite = { 505521c8e720SArd Biesheuvel .hash = __VECS(sha3_512_tv_template) 505679cc6ab8Sraveendra padasalagi } 505779cc6ab8Sraveendra padasalagi }, { 5058da7f033dSHerbert Xu .alg = "sha384", 5059da7f033dSHerbert Xu .test = alg_test_hash, 5060a1915d51SJarod Wilson .fips_allowed = 1, 5061da7f033dSHerbert Xu .suite = { 506221c8e720SArd Biesheuvel .hash = __VECS(sha384_tv_template) 5063da7f033dSHerbert Xu } 5064da7f033dSHerbert Xu }, { 5065da7f033dSHerbert Xu .alg = "sha512", 5066da7f033dSHerbert Xu .test = alg_test_hash, 5067a1915d51SJarod Wilson .fips_allowed = 1, 5068da7f033dSHerbert Xu .suite = { 506921c8e720SArd Biesheuvel .hash = __VECS(sha512_tv_template) 5070da7f033dSHerbert Xu } 5071da7f033dSHerbert Xu }, { 5072b7e27530SGilad Ben-Yossef .alg = "sm3", 5073b7e27530SGilad Ben-Yossef .test = alg_test_hash, 5074b7e27530SGilad Ben-Yossef .suite = { 5075b7e27530SGilad Ben-Yossef .hash = __VECS(sm3_tv_template) 5076b7e27530SGilad Ben-Yossef } 5077b7e27530SGilad Ben-Yossef }, { 507825a0b9d4SVitaly Chikunov .alg = "streebog256", 507925a0b9d4SVitaly Chikunov .test = alg_test_hash, 508025a0b9d4SVitaly Chikunov .suite = { 508125a0b9d4SVitaly Chikunov .hash = __VECS(streebog256_tv_template) 508225a0b9d4SVitaly Chikunov } 508325a0b9d4SVitaly Chikunov }, { 508425a0b9d4SVitaly Chikunov .alg = "streebog512", 508525a0b9d4SVitaly Chikunov .test = alg_test_hash, 508625a0b9d4SVitaly Chikunov .suite = { 508725a0b9d4SVitaly Chikunov .hash = __VECS(streebog512_tv_template) 508825a0b9d4SVitaly Chikunov } 508925a0b9d4SVitaly Chikunov }, { 5090da7f033dSHerbert Xu .alg = "tgr128", 5091da7f033dSHerbert Xu .test = alg_test_hash, 5092da7f033dSHerbert Xu .suite = { 509321c8e720SArd Biesheuvel .hash = __VECS(tgr128_tv_template) 5094da7f033dSHerbert Xu } 5095da7f033dSHerbert Xu }, { 5096da7f033dSHerbert Xu .alg = "tgr160", 5097da7f033dSHerbert Xu .test = alg_test_hash, 5098da7f033dSHerbert Xu .suite = { 509921c8e720SArd Biesheuvel .hash = __VECS(tgr160_tv_template) 5100da7f033dSHerbert Xu } 5101da7f033dSHerbert Xu }, { 5102da7f033dSHerbert Xu .alg = "tgr192", 5103da7f033dSHerbert Xu .test = alg_test_hash, 5104da7f033dSHerbert Xu .suite = { 510521c8e720SArd Biesheuvel .hash = __VECS(tgr192_tv_template) 5106da7f033dSHerbert Xu } 5107da7f033dSHerbert Xu }, { 5108ed331adaSEric Biggers .alg = "vmac64(aes)", 5109ed331adaSEric Biggers .test = alg_test_hash, 5110ed331adaSEric Biggers .suite = { 5111ed331adaSEric Biggers .hash = __VECS(vmac64_aes_tv_template) 5112ed331adaSEric Biggers } 5113ed331adaSEric Biggers }, { 5114da7f033dSHerbert Xu .alg = "wp256", 5115da7f033dSHerbert Xu .test = alg_test_hash, 5116da7f033dSHerbert Xu .suite = { 511721c8e720SArd Biesheuvel .hash = __VECS(wp256_tv_template) 5118da7f033dSHerbert Xu } 5119da7f033dSHerbert Xu }, { 5120da7f033dSHerbert Xu .alg = "wp384", 5121da7f033dSHerbert Xu .test = alg_test_hash, 5122da7f033dSHerbert Xu .suite = { 512321c8e720SArd Biesheuvel .hash = __VECS(wp384_tv_template) 5124da7f033dSHerbert Xu } 5125da7f033dSHerbert Xu }, { 5126da7f033dSHerbert Xu .alg = "wp512", 5127da7f033dSHerbert Xu .test = alg_test_hash, 5128da7f033dSHerbert Xu .suite = { 512921c8e720SArd Biesheuvel .hash = __VECS(wp512_tv_template) 5130da7f033dSHerbert Xu } 5131da7f033dSHerbert Xu }, { 5132da7f033dSHerbert Xu .alg = "xcbc(aes)", 5133da7f033dSHerbert Xu .test = alg_test_hash, 5134da7f033dSHerbert Xu .suite = { 513521c8e720SArd Biesheuvel .hash = __VECS(aes_xcbc128_tv_template) 5136da7f033dSHerbert Xu } 5137da7f033dSHerbert Xu }, { 5138aa762409SEric Biggers .alg = "xchacha12", 5139aa762409SEric Biggers .test = alg_test_skcipher, 5140aa762409SEric Biggers .suite = { 5141aa762409SEric Biggers .cipher = __VECS(xchacha12_tv_template) 5142aa762409SEric Biggers }, 5143aa762409SEric Biggers }, { 5144de61d7aeSEric Biggers .alg = "xchacha20", 5145de61d7aeSEric Biggers .test = alg_test_skcipher, 5146de61d7aeSEric Biggers .suite = { 5147de61d7aeSEric Biggers .cipher = __VECS(xchacha20_tv_template) 5148de61d7aeSEric Biggers }, 5149de61d7aeSEric Biggers }, { 5150da7f033dSHerbert Xu .alg = "xts(aes)", 5151d435e10eSEric Biggers .generic_driver = "xts(ecb(aes-generic))", 51521aa4ecd9SHerbert Xu .test = alg_test_skcipher, 51532918aa8dSJarod Wilson .fips_allowed = 1, 5154da7f033dSHerbert Xu .suite = { 515592a4c9feSEric Biggers .cipher = __VECS(aes_xts_tv_template) 5156da7f033dSHerbert Xu } 51570c01aed5SGeert Uytterhoeven }, { 51580840605eSJussi Kivilinna .alg = "xts(camellia)", 5159d435e10eSEric Biggers .generic_driver = "xts(ecb(camellia-generic))", 51600840605eSJussi Kivilinna .test = alg_test_skcipher, 51610840605eSJussi Kivilinna .suite = { 516292a4c9feSEric Biggers .cipher = __VECS(camellia_xts_tv_template) 51630840605eSJussi Kivilinna } 51640840605eSJussi Kivilinna }, { 51659b8b0405SJohannes Goetzfried .alg = "xts(cast6)", 5166d435e10eSEric Biggers .generic_driver = "xts(ecb(cast6-generic))", 51679b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 51689b8b0405SJohannes Goetzfried .suite = { 516992a4c9feSEric Biggers .cipher = __VECS(cast6_xts_tv_template) 51709b8b0405SJohannes Goetzfried } 51719b8b0405SJohannes Goetzfried }, { 517215f47ce5SGilad Ben-Yossef /* Same as xts(aes) except the key is stored in 517315f47ce5SGilad Ben-Yossef * hardware secure memory which we reference by index 517415f47ce5SGilad Ben-Yossef */ 517515f47ce5SGilad Ben-Yossef .alg = "xts(paes)", 517615f47ce5SGilad Ben-Yossef .test = alg_test_null, 517715f47ce5SGilad Ben-Yossef .fips_allowed = 1, 517815f47ce5SGilad Ben-Yossef }, { 517918be20b9SJussi Kivilinna .alg = "xts(serpent)", 5180d435e10eSEric Biggers .generic_driver = "xts(ecb(serpent-generic))", 518118be20b9SJussi Kivilinna .test = alg_test_skcipher, 518218be20b9SJussi Kivilinna .suite = { 518392a4c9feSEric Biggers .cipher = __VECS(serpent_xts_tv_template) 518418be20b9SJussi Kivilinna } 518518be20b9SJussi Kivilinna }, { 5186aed265b9SJussi Kivilinna .alg = "xts(twofish)", 5187d435e10eSEric Biggers .generic_driver = "xts(ecb(twofish-generic))", 5188aed265b9SJussi Kivilinna .test = alg_test_skcipher, 5189aed265b9SJussi Kivilinna .suite = { 519092a4c9feSEric Biggers .cipher = __VECS(tf_xts_tv_template) 5191aed265b9SJussi Kivilinna } 5192a368f43dSGiovanni Cabiddu }, { 519315f47ce5SGilad Ben-Yossef .alg = "xts4096(paes)", 519415f47ce5SGilad Ben-Yossef .test = alg_test_null, 519515f47ce5SGilad Ben-Yossef .fips_allowed = 1, 519615f47ce5SGilad Ben-Yossef }, { 519715f47ce5SGilad Ben-Yossef .alg = "xts512(paes)", 519815f47ce5SGilad Ben-Yossef .test = alg_test_null, 519915f47ce5SGilad Ben-Yossef .fips_allowed = 1, 520015f47ce5SGilad Ben-Yossef }, { 520167882e76SNikolay Borisov .alg = "xxhash64", 520267882e76SNikolay Borisov .test = alg_test_hash, 520367882e76SNikolay Borisov .fips_allowed = 1, 520467882e76SNikolay Borisov .suite = { 520567882e76SNikolay Borisov .hash = __VECS(xxhash64_tv_template) 520667882e76SNikolay Borisov } 520767882e76SNikolay Borisov }, { 5208a368f43dSGiovanni Cabiddu .alg = "zlib-deflate", 5209a368f43dSGiovanni Cabiddu .test = alg_test_comp, 5210a368f43dSGiovanni Cabiddu .fips_allowed = 1, 5211a368f43dSGiovanni Cabiddu .suite = { 5212a368f43dSGiovanni Cabiddu .comp = { 5213a368f43dSGiovanni Cabiddu .comp = __VECS(zlib_deflate_comp_tv_template), 5214a368f43dSGiovanni Cabiddu .decomp = __VECS(zlib_deflate_decomp_tv_template) 5215a368f43dSGiovanni Cabiddu } 5216a368f43dSGiovanni Cabiddu } 5217d28fc3dbSNick Terrell }, { 5218d28fc3dbSNick Terrell .alg = "zstd", 5219d28fc3dbSNick Terrell .test = alg_test_comp, 5220d28fc3dbSNick Terrell .fips_allowed = 1, 5221d28fc3dbSNick Terrell .suite = { 5222d28fc3dbSNick Terrell .comp = { 5223d28fc3dbSNick Terrell .comp = __VECS(zstd_comp_tv_template), 5224d28fc3dbSNick Terrell .decomp = __VECS(zstd_decomp_tv_template) 5225d28fc3dbSNick Terrell } 5226d28fc3dbSNick Terrell } 5227da7f033dSHerbert Xu } 5228da7f033dSHerbert Xu }; 5229da7f033dSHerbert Xu 52303f47a03dSEric Biggers static void alg_check_test_descs_order(void) 52315714758bSJussi Kivilinna { 52325714758bSJussi Kivilinna int i; 52335714758bSJussi Kivilinna 52345714758bSJussi Kivilinna for (i = 1; i < ARRAY_SIZE(alg_test_descs); i++) { 52355714758bSJussi Kivilinna int diff = strcmp(alg_test_descs[i - 1].alg, 52365714758bSJussi Kivilinna alg_test_descs[i].alg); 52375714758bSJussi Kivilinna 52385714758bSJussi Kivilinna if (WARN_ON(diff > 0)) { 52395714758bSJussi Kivilinna pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n", 52405714758bSJussi Kivilinna alg_test_descs[i - 1].alg, 52415714758bSJussi Kivilinna alg_test_descs[i].alg); 52425714758bSJussi Kivilinna } 52435714758bSJussi Kivilinna 52445714758bSJussi Kivilinna if (WARN_ON(diff == 0)) { 52455714758bSJussi Kivilinna pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n", 52465714758bSJussi Kivilinna alg_test_descs[i].alg); 52475714758bSJussi Kivilinna } 52485714758bSJussi Kivilinna } 52495714758bSJussi Kivilinna } 52505714758bSJussi Kivilinna 52513f47a03dSEric Biggers static void alg_check_testvec_configs(void) 52523f47a03dSEric Biggers { 52534e7babbaSEric Biggers int i; 52544e7babbaSEric Biggers 52554e7babbaSEric Biggers for (i = 0; i < ARRAY_SIZE(default_cipher_testvec_configs); i++) 52564e7babbaSEric Biggers WARN_ON(!valid_testvec_config( 52574e7babbaSEric Biggers &default_cipher_testvec_configs[i])); 52584cc2dcf9SEric Biggers 52594cc2dcf9SEric Biggers for (i = 0; i < ARRAY_SIZE(default_hash_testvec_configs); i++) 52604cc2dcf9SEric Biggers WARN_ON(!valid_testvec_config( 52614cc2dcf9SEric Biggers &default_hash_testvec_configs[i])); 52623f47a03dSEric Biggers } 52633f47a03dSEric Biggers 52643f47a03dSEric Biggers static void testmgr_onetime_init(void) 52653f47a03dSEric Biggers { 52663f47a03dSEric Biggers alg_check_test_descs_order(); 52673f47a03dSEric Biggers alg_check_testvec_configs(); 52685b2706a4SEric Biggers 52695b2706a4SEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 52705b2706a4SEric Biggers pr_warn("alg: extra crypto tests enabled. This is intended for developer use only.\n"); 52715b2706a4SEric Biggers #endif 52723f47a03dSEric Biggers } 52733f47a03dSEric Biggers 52741aa4ecd9SHerbert Xu static int alg_find_test(const char *alg) 5275da7f033dSHerbert Xu { 5276da7f033dSHerbert Xu int start = 0; 5277da7f033dSHerbert Xu int end = ARRAY_SIZE(alg_test_descs); 5278da7f033dSHerbert Xu 5279da7f033dSHerbert Xu while (start < end) { 5280da7f033dSHerbert Xu int i = (start + end) / 2; 5281da7f033dSHerbert Xu int diff = strcmp(alg_test_descs[i].alg, alg); 5282da7f033dSHerbert Xu 5283da7f033dSHerbert Xu if (diff > 0) { 5284da7f033dSHerbert Xu end = i; 5285da7f033dSHerbert Xu continue; 5286da7f033dSHerbert Xu } 5287da7f033dSHerbert Xu 5288da7f033dSHerbert Xu if (diff < 0) { 5289da7f033dSHerbert Xu start = i + 1; 5290da7f033dSHerbert Xu continue; 5291da7f033dSHerbert Xu } 5292da7f033dSHerbert Xu 52931aa4ecd9SHerbert Xu return i; 5294da7f033dSHerbert Xu } 5295da7f033dSHerbert Xu 52961aa4ecd9SHerbert Xu return -1; 52971aa4ecd9SHerbert Xu } 52981aa4ecd9SHerbert Xu 52991aa4ecd9SHerbert Xu int alg_test(const char *driver, const char *alg, u32 type, u32 mask) 53001aa4ecd9SHerbert Xu { 53011aa4ecd9SHerbert Xu int i; 5302a68f6610SHerbert Xu int j; 5303d12d6b6dSNeil Horman int rc; 53041aa4ecd9SHerbert Xu 53059e5c9fe4SRichard W.M. Jones if (!fips_enabled && notests) { 53069e5c9fe4SRichard W.M. Jones printk_once(KERN_INFO "alg: self-tests disabled\n"); 53079e5c9fe4SRichard W.M. Jones return 0; 53089e5c9fe4SRichard W.M. Jones } 53099e5c9fe4SRichard W.M. Jones 53103f47a03dSEric Biggers DO_ONCE(testmgr_onetime_init); 53115714758bSJussi Kivilinna 53121aa4ecd9SHerbert Xu if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) { 53131aa4ecd9SHerbert Xu char nalg[CRYPTO_MAX_ALG_NAME]; 53141aa4ecd9SHerbert Xu 53151aa4ecd9SHerbert Xu if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >= 53161aa4ecd9SHerbert Xu sizeof(nalg)) 53171aa4ecd9SHerbert Xu return -ENAMETOOLONG; 53181aa4ecd9SHerbert Xu 53191aa4ecd9SHerbert Xu i = alg_find_test(nalg); 53201aa4ecd9SHerbert Xu if (i < 0) 53211aa4ecd9SHerbert Xu goto notest; 53221aa4ecd9SHerbert Xu 5323a3bef3a3SJarod Wilson if (fips_enabled && !alg_test_descs[i].fips_allowed) 5324a3bef3a3SJarod Wilson goto non_fips_alg; 5325a3bef3a3SJarod Wilson 5326941fb328SJarod Wilson rc = alg_test_cipher(alg_test_descs + i, driver, type, mask); 5327941fb328SJarod Wilson goto test_done; 53281aa4ecd9SHerbert Xu } 53291aa4ecd9SHerbert Xu 53301aa4ecd9SHerbert Xu i = alg_find_test(alg); 5331a68f6610SHerbert Xu j = alg_find_test(driver); 5332a68f6610SHerbert Xu if (i < 0 && j < 0) 53331aa4ecd9SHerbert Xu goto notest; 53341aa4ecd9SHerbert Xu 5335a68f6610SHerbert Xu if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) || 5336a68f6610SHerbert Xu (j >= 0 && !alg_test_descs[j].fips_allowed))) 5337a3bef3a3SJarod Wilson goto non_fips_alg; 5338a3bef3a3SJarod Wilson 5339a68f6610SHerbert Xu rc = 0; 5340a68f6610SHerbert Xu if (i >= 0) 5341a68f6610SHerbert Xu rc |= alg_test_descs[i].test(alg_test_descs + i, driver, 53421aa4ecd9SHerbert Xu type, mask); 5343032c8cacSCristian Stoica if (j >= 0 && j != i) 5344a68f6610SHerbert Xu rc |= alg_test_descs[j].test(alg_test_descs + j, driver, 5345a68f6610SHerbert Xu type, mask); 5346a68f6610SHerbert Xu 5347941fb328SJarod Wilson test_done: 53489552389cSGilad Ben-Yossef if (rc && (fips_enabled || panic_on_fail)) { 53499552389cSGilad Ben-Yossef fips_fail_notify(); 5350eda69b0cSEric Biggers panic("alg: self-tests for %s (%s) failed in %s mode!\n", 5351eda69b0cSEric Biggers driver, alg, fips_enabled ? "fips" : "panic_on_fail"); 53529552389cSGilad Ben-Yossef } 5353d12d6b6dSNeil Horman 535429ecd4abSJarod Wilson if (fips_enabled && !rc) 53553e8cffd4SMasanari Iida pr_info("alg: self-tests for %s (%s) passed\n", driver, alg); 535629ecd4abSJarod Wilson 5357d12d6b6dSNeil Horman return rc; 53581aa4ecd9SHerbert Xu 53591aa4ecd9SHerbert Xu notest: 5360da7f033dSHerbert Xu printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver); 5361da7f033dSHerbert Xu return 0; 5362a3bef3a3SJarod Wilson non_fips_alg: 5363a3bef3a3SJarod Wilson return -EINVAL; 5364da7f033dSHerbert Xu } 53650b767f96SAlexander Shishkin 5366326a6346SHerbert Xu #endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */ 53670b767f96SAlexander Shishkin 5368da7f033dSHerbert Xu EXPORT_SYMBOL_GPL(alg_test); 5369