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 10356570737cSEric Biggers static int do_ahash_op(int (*op)(struct ahash_request *req), 10366570737cSEric Biggers struct ahash_request *req, 10376570737cSEric Biggers struct crypto_wait *wait, bool nosimd) 10386570737cSEric Biggers { 10396570737cSEric Biggers int err; 10406570737cSEric Biggers 10416570737cSEric Biggers if (nosimd) 10426570737cSEric Biggers crypto_disable_simd_for_test(); 10436570737cSEric Biggers 10446570737cSEric Biggers err = op(req); 10456570737cSEric Biggers 10466570737cSEric Biggers if (nosimd) 10476570737cSEric Biggers crypto_reenable_simd_for_test(); 10486570737cSEric Biggers 10496570737cSEric Biggers return crypto_wait_req(err, wait); 10506570737cSEric Biggers } 10516570737cSEric Biggers 10524cc2dcf9SEric Biggers static int check_nonfinal_hash_op(const char *op, int err, 10534cc2dcf9SEric Biggers u8 *result, unsigned int digestsize, 1054951d1332SEric Biggers const char *driver, const char *vec_name, 10554cc2dcf9SEric Biggers const struct testvec_config *cfg) 1056466d7b9fSKamil Konieczny { 10574cc2dcf9SEric Biggers if (err) { 1058951d1332SEric Biggers pr_err("alg: hash: %s %s() failed with err %d on test vector %s, cfg=\"%s\"\n", 1059951d1332SEric Biggers driver, op, err, vec_name, cfg->name); 10604cc2dcf9SEric Biggers return err; 10614cc2dcf9SEric Biggers } 10624cc2dcf9SEric Biggers if (!testmgr_is_poison(result, digestsize)) { 1063951d1332SEric Biggers pr_err("alg: hash: %s %s() used result buffer on test vector %s, cfg=\"%s\"\n", 1064951d1332SEric Biggers driver, op, vec_name, cfg->name); 1065466d7b9fSKamil Konieczny return -EINVAL; 1066466d7b9fSKamil Konieczny } 1067466d7b9fSKamil Konieczny return 0; 1068466d7b9fSKamil Konieczny } 1069466d7b9fSKamil Konieczny 10704cc2dcf9SEric Biggers static int test_hash_vec_cfg(const char *driver, 10714cc2dcf9SEric Biggers const struct hash_testvec *vec, 1072951d1332SEric Biggers const char *vec_name, 10734cc2dcf9SEric Biggers const struct testvec_config *cfg, 10744cc2dcf9SEric Biggers struct ahash_request *req, 10754cc2dcf9SEric Biggers struct test_sglist *tsgl, 10764cc2dcf9SEric Biggers u8 *hashstate) 1077018ba95cSWang, Rui Y { 10784cc2dcf9SEric Biggers struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 10794cc2dcf9SEric Biggers const unsigned int alignmask = crypto_ahash_alignmask(tfm); 10804cc2dcf9SEric Biggers const unsigned int digestsize = crypto_ahash_digestsize(tfm); 10814cc2dcf9SEric Biggers const unsigned int statesize = crypto_ahash_statesize(tfm); 10824cc2dcf9SEric Biggers const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags; 10834cc2dcf9SEric Biggers const struct test_sg_division *divs[XBUFSIZE]; 10844cc2dcf9SEric Biggers DECLARE_CRYPTO_WAIT(wait); 10854cc2dcf9SEric Biggers struct kvec _input; 10864cc2dcf9SEric Biggers struct iov_iter input; 10874cc2dcf9SEric Biggers unsigned int i; 10884cc2dcf9SEric Biggers struct scatterlist *pending_sgl; 10894cc2dcf9SEric Biggers unsigned int pending_len; 10904cc2dcf9SEric Biggers u8 result[HASH_MAX_DIGESTSIZE + TESTMGR_POISON_LEN]; 10914cc2dcf9SEric Biggers int err; 1092018ba95cSWang, Rui Y 10934cc2dcf9SEric Biggers /* Set the key, if specified */ 10944cc2dcf9SEric Biggers if (vec->ksize) { 10954cc2dcf9SEric Biggers err = crypto_ahash_setkey(tfm, vec->key, vec->ksize); 10964cc2dcf9SEric Biggers if (err) { 10975283a8eeSEric Biggers if (err == vec->setkey_error) 10985283a8eeSEric Biggers return 0; 1099951d1332SEric Biggers pr_err("alg: hash: %s setkey failed on test vector %s; expected_error=%d, actual_error=%d, flags=%#x\n", 1100951d1332SEric Biggers driver, vec_name, vec->setkey_error, err, 11014cc2dcf9SEric Biggers crypto_ahash_get_flags(tfm)); 11024cc2dcf9SEric Biggers return err; 1103da7f033dSHerbert Xu } 11045283a8eeSEric Biggers if (vec->setkey_error) { 1105951d1332SEric Biggers pr_err("alg: hash: %s setkey unexpectedly succeeded on test vector %s; expected_error=%d\n", 1106951d1332SEric Biggers driver, vec_name, vec->setkey_error); 11075283a8eeSEric Biggers return -EINVAL; 11085283a8eeSEric Biggers } 1109da7f033dSHerbert Xu } 1110da7f033dSHerbert Xu 11114cc2dcf9SEric Biggers /* Build the scatterlist for the source data */ 11124cc2dcf9SEric Biggers _input.iov_base = (void *)vec->plaintext; 11134cc2dcf9SEric Biggers _input.iov_len = vec->psize; 11144cc2dcf9SEric Biggers iov_iter_kvec(&input, WRITE, &_input, 1, vec->psize); 11154cc2dcf9SEric Biggers err = build_test_sglist(tsgl, cfg->src_divs, alignmask, vec->psize, 11164cc2dcf9SEric Biggers &input, divs); 11174cc2dcf9SEric Biggers if (err) { 1118951d1332SEric Biggers pr_err("alg: hash: %s: error preparing scatterlist for test vector %s, cfg=\"%s\"\n", 1119951d1332SEric Biggers driver, vec_name, cfg->name); 11204cc2dcf9SEric Biggers return err; 1121a8f1a052SDavid S. Miller } 1122da7f033dSHerbert Xu 11234cc2dcf9SEric Biggers /* Do the actual hashing */ 1124da7f033dSHerbert Xu 11254cc2dcf9SEric Biggers testmgr_poison(req->__ctx, crypto_ahash_reqsize(tfm)); 11264cc2dcf9SEric Biggers testmgr_poison(result, digestsize + TESTMGR_POISON_LEN); 112776715095SGilad Ben-Yossef 11285283a8eeSEric Biggers if (cfg->finalization_type == FINALIZATION_TYPE_DIGEST || 11295283a8eeSEric Biggers vec->digest_error) { 11304cc2dcf9SEric Biggers /* Just using digest() */ 11314cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, crypto_req_done, 11327f397136SGilad Ben-Yossef &wait); 11334cc2dcf9SEric Biggers ahash_request_set_crypt(req, tsgl->sgl, result, vec->psize); 11346570737cSEric Biggers err = do_ahash_op(crypto_ahash_digest, req, &wait, cfg->nosimd); 11354cc2dcf9SEric Biggers if (err) { 11365283a8eeSEric Biggers if (err == vec->digest_error) 11375283a8eeSEric Biggers return 0; 1138951d1332SEric Biggers pr_err("alg: hash: %s digest() failed on test vector %s; expected_error=%d, actual_error=%d, cfg=\"%s\"\n", 1139951d1332SEric Biggers driver, vec_name, vec->digest_error, err, 11405283a8eeSEric Biggers cfg->name); 11414cc2dcf9SEric Biggers return err; 1142018ba95cSWang, Rui Y } 11435283a8eeSEric Biggers if (vec->digest_error) { 1144951d1332SEric Biggers pr_err("alg: hash: %s digest() unexpectedly succeeded on test vector %s; expected_error=%d, cfg=\"%s\"\n", 1145951d1332SEric Biggers driver, vec_name, vec->digest_error, cfg->name); 11465283a8eeSEric Biggers return -EINVAL; 11475283a8eeSEric Biggers } 11484cc2dcf9SEric Biggers goto result_ready; 1149018ba95cSWang, Rui Y } 11504cc2dcf9SEric Biggers 11514cc2dcf9SEric Biggers /* Using init(), zero or more update(), then final() or finup() */ 11524cc2dcf9SEric Biggers 11534cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, crypto_req_done, &wait); 11544cc2dcf9SEric Biggers ahash_request_set_crypt(req, NULL, result, 0); 11556570737cSEric Biggers err = do_ahash_op(crypto_ahash_init, req, &wait, cfg->nosimd); 11564cc2dcf9SEric Biggers err = check_nonfinal_hash_op("init", err, result, digestsize, 1157951d1332SEric Biggers driver, vec_name, cfg); 11584cc2dcf9SEric Biggers if (err) 11594cc2dcf9SEric Biggers return err; 11604cc2dcf9SEric Biggers 11614cc2dcf9SEric Biggers pending_sgl = NULL; 11624cc2dcf9SEric Biggers pending_len = 0; 11634cc2dcf9SEric Biggers for (i = 0; i < tsgl->nents; i++) { 11644cc2dcf9SEric Biggers if (divs[i]->flush_type != FLUSH_TYPE_NONE && 11654cc2dcf9SEric Biggers pending_sgl != NULL) { 11664cc2dcf9SEric Biggers /* update() with the pending data */ 11674cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, 11684cc2dcf9SEric Biggers crypto_req_done, &wait); 11694cc2dcf9SEric Biggers ahash_request_set_crypt(req, pending_sgl, result, 11704cc2dcf9SEric Biggers pending_len); 11716570737cSEric Biggers err = do_ahash_op(crypto_ahash_update, req, &wait, 11726570737cSEric Biggers divs[i]->nosimd); 11734cc2dcf9SEric Biggers err = check_nonfinal_hash_op("update", err, 11744cc2dcf9SEric Biggers result, digestsize, 1175951d1332SEric Biggers driver, vec_name, cfg); 11764cc2dcf9SEric Biggers if (err) 11774cc2dcf9SEric Biggers return err; 11784cc2dcf9SEric Biggers pending_sgl = NULL; 11794cc2dcf9SEric Biggers pending_len = 0; 1180018ba95cSWang, Rui Y } 11814cc2dcf9SEric Biggers if (divs[i]->flush_type == FLUSH_TYPE_REIMPORT) { 11824cc2dcf9SEric Biggers /* Test ->export() and ->import() */ 11834cc2dcf9SEric Biggers testmgr_poison(hashstate + statesize, 11844cc2dcf9SEric Biggers TESTMGR_POISON_LEN); 11854cc2dcf9SEric Biggers err = crypto_ahash_export(req, hashstate); 11864cc2dcf9SEric Biggers err = check_nonfinal_hash_op("export", err, 11874cc2dcf9SEric Biggers result, digestsize, 1188951d1332SEric Biggers driver, vec_name, cfg); 11894cc2dcf9SEric Biggers if (err) 11904cc2dcf9SEric Biggers return err; 11914cc2dcf9SEric Biggers if (!testmgr_is_poison(hashstate + statesize, 11924cc2dcf9SEric Biggers TESTMGR_POISON_LEN)) { 1193951d1332SEric Biggers pr_err("alg: hash: %s export() overran state buffer on test vector %s, cfg=\"%s\"\n", 1194951d1332SEric Biggers driver, vec_name, cfg->name); 11954cc2dcf9SEric Biggers return -EOVERFLOW; 11964cc2dcf9SEric Biggers } 11974cc2dcf9SEric Biggers 11984cc2dcf9SEric Biggers testmgr_poison(req->__ctx, crypto_ahash_reqsize(tfm)); 11994cc2dcf9SEric Biggers err = crypto_ahash_import(req, hashstate); 12004cc2dcf9SEric Biggers err = check_nonfinal_hash_op("import", err, 12014cc2dcf9SEric Biggers result, digestsize, 1202951d1332SEric Biggers driver, vec_name, cfg); 12034cc2dcf9SEric Biggers if (err) 12044cc2dcf9SEric Biggers return err; 12054cc2dcf9SEric Biggers } 12064cc2dcf9SEric Biggers if (pending_sgl == NULL) 12074cc2dcf9SEric Biggers pending_sgl = &tsgl->sgl[i]; 12084cc2dcf9SEric Biggers pending_len += tsgl->sgl[i].length; 12094cc2dcf9SEric Biggers } 12104cc2dcf9SEric Biggers 12114cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, crypto_req_done, &wait); 12124cc2dcf9SEric Biggers ahash_request_set_crypt(req, pending_sgl, result, pending_len); 12134cc2dcf9SEric Biggers if (cfg->finalization_type == FINALIZATION_TYPE_FINAL) { 12144cc2dcf9SEric Biggers /* finish with update() and final() */ 12156570737cSEric Biggers err = do_ahash_op(crypto_ahash_update, req, &wait, cfg->nosimd); 12164cc2dcf9SEric Biggers err = check_nonfinal_hash_op("update", err, result, digestsize, 1217951d1332SEric Biggers driver, vec_name, cfg); 12184cc2dcf9SEric Biggers if (err) 12194cc2dcf9SEric Biggers return err; 12206570737cSEric Biggers err = do_ahash_op(crypto_ahash_final, req, &wait, cfg->nosimd); 12214cc2dcf9SEric Biggers if (err) { 1222951d1332SEric Biggers pr_err("alg: hash: %s final() failed with err %d on test vector %s, cfg=\"%s\"\n", 1223951d1332SEric Biggers driver, err, vec_name, cfg->name); 12244cc2dcf9SEric Biggers return err; 12254cc2dcf9SEric Biggers } 12264cc2dcf9SEric Biggers } else { 12274cc2dcf9SEric Biggers /* finish with finup() */ 12286570737cSEric Biggers err = do_ahash_op(crypto_ahash_finup, req, &wait, cfg->nosimd); 12294cc2dcf9SEric Biggers if (err) { 1230951d1332SEric Biggers pr_err("alg: hash: %s finup() failed with err %d on test vector %s, cfg=\"%s\"\n", 1231951d1332SEric Biggers driver, err, vec_name, cfg->name); 12324cc2dcf9SEric Biggers return err; 1233018ba95cSWang, Rui Y } 1234018ba95cSWang, Rui Y } 1235018ba95cSWang, Rui Y 12364cc2dcf9SEric Biggers result_ready: 12374cc2dcf9SEric Biggers /* Check that the algorithm produced the correct digest */ 12384cc2dcf9SEric Biggers if (memcmp(result, vec->digest, digestsize) != 0) { 1239951d1332SEric Biggers pr_err("alg: hash: %s test failed (wrong result) on test vector %s, cfg=\"%s\"\n", 1240951d1332SEric Biggers driver, vec_name, cfg->name); 12414cc2dcf9SEric Biggers return -EINVAL; 1242da7f033dSHerbert Xu } 12434cc2dcf9SEric Biggers if (!testmgr_is_poison(&result[digestsize], TESTMGR_POISON_LEN)) { 1244951d1332SEric Biggers pr_err("alg: hash: %s overran result buffer on test vector %s, cfg=\"%s\"\n", 1245951d1332SEric Biggers driver, vec_name, cfg->name); 12464cc2dcf9SEric Biggers return -EOVERFLOW; 1247da5ffe11SJussi Kivilinna } 1248da5ffe11SJussi Kivilinna 1249da5ffe11SJussi Kivilinna return 0; 1250da5ffe11SJussi Kivilinna } 1251da5ffe11SJussi Kivilinna 12524cc2dcf9SEric Biggers static int test_hash_vec(const char *driver, const struct hash_testvec *vec, 12534cc2dcf9SEric Biggers unsigned int vec_num, struct ahash_request *req, 12544cc2dcf9SEric Biggers struct test_sglist *tsgl, u8 *hashstate) 12554cc2dcf9SEric Biggers { 1256951d1332SEric Biggers char vec_name[16]; 12574cc2dcf9SEric Biggers unsigned int i; 12584cc2dcf9SEric Biggers int err; 12594cc2dcf9SEric Biggers 1260951d1332SEric Biggers sprintf(vec_name, "%u", vec_num); 1261951d1332SEric Biggers 12624cc2dcf9SEric Biggers for (i = 0; i < ARRAY_SIZE(default_hash_testvec_configs); i++) { 1263951d1332SEric Biggers err = test_hash_vec_cfg(driver, vec, vec_name, 12644cc2dcf9SEric Biggers &default_hash_testvec_configs[i], 12654cc2dcf9SEric Biggers req, tsgl, hashstate); 12664cc2dcf9SEric Biggers if (err) 12674cc2dcf9SEric Biggers return err; 12684cc2dcf9SEric Biggers } 12694cc2dcf9SEric Biggers 12704cc2dcf9SEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 12714cc2dcf9SEric Biggers if (!noextratests) { 12724cc2dcf9SEric Biggers struct testvec_config cfg; 12734cc2dcf9SEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 12744cc2dcf9SEric Biggers 12754cc2dcf9SEric Biggers for (i = 0; i < fuzz_iterations; i++) { 12764cc2dcf9SEric Biggers generate_random_testvec_config(&cfg, cfgname, 12774cc2dcf9SEric Biggers sizeof(cfgname)); 1278951d1332SEric Biggers err = test_hash_vec_cfg(driver, vec, vec_name, &cfg, 12794cc2dcf9SEric Biggers req, tsgl, hashstate); 12804cc2dcf9SEric Biggers if (err) 12814cc2dcf9SEric Biggers return err; 12824cc2dcf9SEric Biggers } 12834cc2dcf9SEric Biggers } 12844cc2dcf9SEric Biggers #endif 12854cc2dcf9SEric Biggers return 0; 12864cc2dcf9SEric Biggers } 12874cc2dcf9SEric Biggers 12889a8a6b3fSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 12899a8a6b3fSEric Biggers /* 12909a8a6b3fSEric Biggers * Generate a hash test vector from the given implementation. 12919a8a6b3fSEric Biggers * Assumes the buffers in 'vec' were already allocated. 12929a8a6b3fSEric Biggers */ 12939a8a6b3fSEric Biggers static void generate_random_hash_testvec(struct crypto_shash *tfm, 12949a8a6b3fSEric Biggers struct hash_testvec *vec, 12959a8a6b3fSEric Biggers unsigned int maxkeysize, 12969a8a6b3fSEric Biggers unsigned int maxdatasize, 12979a8a6b3fSEric Biggers char *name, size_t max_namelen) 12989a8a6b3fSEric Biggers { 12999a8a6b3fSEric Biggers SHASH_DESC_ON_STACK(desc, tfm); 13009a8a6b3fSEric Biggers 13019a8a6b3fSEric Biggers /* Data */ 13029a8a6b3fSEric Biggers vec->psize = generate_random_length(maxdatasize); 13039a8a6b3fSEric Biggers generate_random_bytes((u8 *)vec->plaintext, vec->psize); 13049a8a6b3fSEric Biggers 13059a8a6b3fSEric Biggers /* 13069a8a6b3fSEric Biggers * Key: length in range [1, maxkeysize], but usually choose maxkeysize. 13079a8a6b3fSEric Biggers * If algorithm is unkeyed, then maxkeysize == 0 and set ksize = 0. 13089a8a6b3fSEric Biggers */ 13099a8a6b3fSEric Biggers vec->setkey_error = 0; 13109a8a6b3fSEric Biggers vec->ksize = 0; 13119a8a6b3fSEric Biggers if (maxkeysize) { 13129a8a6b3fSEric Biggers vec->ksize = maxkeysize; 13139a8a6b3fSEric Biggers if (prandom_u32() % 4 == 0) 13149a8a6b3fSEric Biggers vec->ksize = 1 + (prandom_u32() % maxkeysize); 13159a8a6b3fSEric Biggers generate_random_bytes((u8 *)vec->key, vec->ksize); 13169a8a6b3fSEric Biggers 13179a8a6b3fSEric Biggers vec->setkey_error = crypto_shash_setkey(tfm, vec->key, 13189a8a6b3fSEric Biggers vec->ksize); 13199a8a6b3fSEric Biggers /* If the key couldn't be set, no need to continue to digest. */ 13209a8a6b3fSEric Biggers if (vec->setkey_error) 13219a8a6b3fSEric Biggers goto done; 13229a8a6b3fSEric Biggers } 13239a8a6b3fSEric Biggers 13249a8a6b3fSEric Biggers /* Digest */ 13259a8a6b3fSEric Biggers desc->tfm = tfm; 13269a8a6b3fSEric Biggers vec->digest_error = crypto_shash_digest(desc, vec->plaintext, 13279a8a6b3fSEric Biggers vec->psize, (u8 *)vec->digest); 13289a8a6b3fSEric Biggers done: 13299a8a6b3fSEric Biggers snprintf(name, max_namelen, "\"random: psize=%u ksize=%u\"", 13309a8a6b3fSEric Biggers vec->psize, vec->ksize); 13319a8a6b3fSEric Biggers } 13329a8a6b3fSEric Biggers 13339a8a6b3fSEric Biggers /* 13349a8a6b3fSEric Biggers * Test the hash algorithm represented by @req against the corresponding generic 13359a8a6b3fSEric Biggers * implementation, if one is available. 13369a8a6b3fSEric Biggers */ 13379a8a6b3fSEric Biggers static int test_hash_vs_generic_impl(const char *driver, 13389a8a6b3fSEric Biggers const char *generic_driver, 13399a8a6b3fSEric Biggers unsigned int maxkeysize, 13409a8a6b3fSEric Biggers struct ahash_request *req, 13419a8a6b3fSEric Biggers struct test_sglist *tsgl, 13429a8a6b3fSEric Biggers u8 *hashstate) 13439a8a6b3fSEric Biggers { 13449a8a6b3fSEric Biggers struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 13459a8a6b3fSEric Biggers const unsigned int digestsize = crypto_ahash_digestsize(tfm); 13469a8a6b3fSEric Biggers const unsigned int blocksize = crypto_ahash_blocksize(tfm); 13479a8a6b3fSEric Biggers const unsigned int maxdatasize = (2 * PAGE_SIZE) - TESTMGR_POISON_LEN; 13489a8a6b3fSEric Biggers const char *algname = crypto_hash_alg_common(tfm)->base.cra_name; 13499a8a6b3fSEric Biggers char _generic_driver[CRYPTO_MAX_ALG_NAME]; 13509a8a6b3fSEric Biggers struct crypto_shash *generic_tfm = NULL; 13519a8a6b3fSEric Biggers unsigned int i; 13529a8a6b3fSEric Biggers struct hash_testvec vec = { 0 }; 13539a8a6b3fSEric Biggers char vec_name[64]; 13549a8a6b3fSEric Biggers struct testvec_config cfg; 13559a8a6b3fSEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 13569a8a6b3fSEric Biggers int err; 13579a8a6b3fSEric Biggers 13589a8a6b3fSEric Biggers if (noextratests) 13599a8a6b3fSEric Biggers return 0; 13609a8a6b3fSEric Biggers 13619a8a6b3fSEric Biggers if (!generic_driver) { /* Use default naming convention? */ 13629a8a6b3fSEric Biggers err = build_generic_driver_name(algname, _generic_driver); 13639a8a6b3fSEric Biggers if (err) 13649a8a6b3fSEric Biggers return err; 13659a8a6b3fSEric Biggers generic_driver = _generic_driver; 13669a8a6b3fSEric Biggers } 13679a8a6b3fSEric Biggers 13689a8a6b3fSEric Biggers if (strcmp(generic_driver, driver) == 0) /* Already the generic impl? */ 13699a8a6b3fSEric Biggers return 0; 13709a8a6b3fSEric Biggers 13719a8a6b3fSEric Biggers generic_tfm = crypto_alloc_shash(generic_driver, 0, 0); 13729a8a6b3fSEric Biggers if (IS_ERR(generic_tfm)) { 13739a8a6b3fSEric Biggers err = PTR_ERR(generic_tfm); 13749a8a6b3fSEric Biggers if (err == -ENOENT) { 13759a8a6b3fSEric Biggers pr_warn("alg: hash: skipping comparison tests for %s because %s is unavailable\n", 13769a8a6b3fSEric Biggers driver, generic_driver); 13779a8a6b3fSEric Biggers return 0; 13789a8a6b3fSEric Biggers } 13799a8a6b3fSEric Biggers pr_err("alg: hash: error allocating %s (generic impl of %s): %d\n", 13809a8a6b3fSEric Biggers generic_driver, algname, err); 13819a8a6b3fSEric Biggers return err; 13829a8a6b3fSEric Biggers } 13839a8a6b3fSEric Biggers 13849a8a6b3fSEric Biggers /* Check the algorithm properties for consistency. */ 13859a8a6b3fSEric Biggers 13869a8a6b3fSEric Biggers if (digestsize != crypto_shash_digestsize(generic_tfm)) { 13879a8a6b3fSEric Biggers pr_err("alg: hash: digestsize for %s (%u) doesn't match generic impl (%u)\n", 13889a8a6b3fSEric Biggers driver, digestsize, 13899a8a6b3fSEric Biggers crypto_shash_digestsize(generic_tfm)); 13909a8a6b3fSEric Biggers err = -EINVAL; 13919a8a6b3fSEric Biggers goto out; 13929a8a6b3fSEric Biggers } 13939a8a6b3fSEric Biggers 13949a8a6b3fSEric Biggers if (blocksize != crypto_shash_blocksize(generic_tfm)) { 13959a8a6b3fSEric Biggers pr_err("alg: hash: blocksize for %s (%u) doesn't match generic impl (%u)\n", 13969a8a6b3fSEric Biggers driver, blocksize, crypto_shash_blocksize(generic_tfm)); 13979a8a6b3fSEric Biggers err = -EINVAL; 13989a8a6b3fSEric Biggers goto out; 13999a8a6b3fSEric Biggers } 14009a8a6b3fSEric Biggers 14019a8a6b3fSEric Biggers /* 14029a8a6b3fSEric Biggers * Now generate test vectors using the generic implementation, and test 14039a8a6b3fSEric Biggers * the other implementation against them. 14049a8a6b3fSEric Biggers */ 14059a8a6b3fSEric Biggers 14069a8a6b3fSEric Biggers vec.key = kmalloc(maxkeysize, GFP_KERNEL); 14079a8a6b3fSEric Biggers vec.plaintext = kmalloc(maxdatasize, GFP_KERNEL); 14089a8a6b3fSEric Biggers vec.digest = kmalloc(digestsize, GFP_KERNEL); 14099a8a6b3fSEric Biggers if (!vec.key || !vec.plaintext || !vec.digest) { 14109a8a6b3fSEric Biggers err = -ENOMEM; 14119a8a6b3fSEric Biggers goto out; 14129a8a6b3fSEric Biggers } 14139a8a6b3fSEric Biggers 14149a8a6b3fSEric Biggers for (i = 0; i < fuzz_iterations * 8; i++) { 14159a8a6b3fSEric Biggers generate_random_hash_testvec(generic_tfm, &vec, 14169a8a6b3fSEric Biggers maxkeysize, maxdatasize, 14179a8a6b3fSEric Biggers vec_name, sizeof(vec_name)); 14189a8a6b3fSEric Biggers generate_random_testvec_config(&cfg, cfgname, sizeof(cfgname)); 14199a8a6b3fSEric Biggers 14209a8a6b3fSEric Biggers err = test_hash_vec_cfg(driver, &vec, vec_name, &cfg, 14219a8a6b3fSEric Biggers req, tsgl, hashstate); 14229a8a6b3fSEric Biggers if (err) 14239a8a6b3fSEric Biggers goto out; 14249a8a6b3fSEric Biggers cond_resched(); 14259a8a6b3fSEric Biggers } 14269a8a6b3fSEric Biggers err = 0; 14279a8a6b3fSEric Biggers out: 14289a8a6b3fSEric Biggers kfree(vec.key); 14299a8a6b3fSEric Biggers kfree(vec.plaintext); 14309a8a6b3fSEric Biggers kfree(vec.digest); 14319a8a6b3fSEric Biggers crypto_free_shash(generic_tfm); 14329a8a6b3fSEric Biggers return err; 14339a8a6b3fSEric Biggers } 14349a8a6b3fSEric Biggers #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 14359a8a6b3fSEric Biggers static int test_hash_vs_generic_impl(const char *driver, 14369a8a6b3fSEric Biggers const char *generic_driver, 14379a8a6b3fSEric Biggers unsigned int maxkeysize, 14389a8a6b3fSEric Biggers struct ahash_request *req, 14399a8a6b3fSEric Biggers struct test_sglist *tsgl, 14409a8a6b3fSEric Biggers u8 *hashstate) 14419a8a6b3fSEric Biggers { 14429a8a6b3fSEric Biggers return 0; 14439a8a6b3fSEric Biggers } 14449a8a6b3fSEric Biggers #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 14459a8a6b3fSEric Biggers 14464cc2dcf9SEric Biggers static int __alg_test_hash(const struct hash_testvec *vecs, 14474cc2dcf9SEric Biggers unsigned int num_vecs, const char *driver, 14489a8a6b3fSEric Biggers u32 type, u32 mask, 14499a8a6b3fSEric Biggers const char *generic_driver, unsigned int maxkeysize) 14504cc2dcf9SEric Biggers { 14514cc2dcf9SEric Biggers struct crypto_ahash *tfm; 14524cc2dcf9SEric Biggers struct ahash_request *req = NULL; 14534cc2dcf9SEric Biggers struct test_sglist *tsgl = NULL; 14544cc2dcf9SEric Biggers u8 *hashstate = NULL; 14554cc2dcf9SEric Biggers unsigned int i; 14564cc2dcf9SEric Biggers int err; 14574cc2dcf9SEric Biggers 14584cc2dcf9SEric Biggers tfm = crypto_alloc_ahash(driver, type, mask); 14594cc2dcf9SEric Biggers if (IS_ERR(tfm)) { 14604cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate transform for %s: %ld\n", 14614cc2dcf9SEric Biggers driver, PTR_ERR(tfm)); 14624cc2dcf9SEric Biggers return PTR_ERR(tfm); 14634cc2dcf9SEric Biggers } 14644cc2dcf9SEric Biggers 14654cc2dcf9SEric Biggers req = ahash_request_alloc(tfm, GFP_KERNEL); 14664cc2dcf9SEric Biggers if (!req) { 14674cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate request for %s\n", 14684cc2dcf9SEric Biggers driver); 14694cc2dcf9SEric Biggers err = -ENOMEM; 14704cc2dcf9SEric Biggers goto out; 14714cc2dcf9SEric Biggers } 14724cc2dcf9SEric Biggers 14734cc2dcf9SEric Biggers tsgl = kmalloc(sizeof(*tsgl), GFP_KERNEL); 14744cc2dcf9SEric Biggers if (!tsgl || init_test_sglist(tsgl) != 0) { 14754cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate test buffers for %s\n", 14764cc2dcf9SEric Biggers driver); 14774cc2dcf9SEric Biggers kfree(tsgl); 14784cc2dcf9SEric Biggers tsgl = NULL; 14794cc2dcf9SEric Biggers err = -ENOMEM; 14804cc2dcf9SEric Biggers goto out; 14814cc2dcf9SEric Biggers } 14824cc2dcf9SEric Biggers 14834cc2dcf9SEric Biggers hashstate = kmalloc(crypto_ahash_statesize(tfm) + TESTMGR_POISON_LEN, 14844cc2dcf9SEric Biggers GFP_KERNEL); 14854cc2dcf9SEric Biggers if (!hashstate) { 14864cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate hash state buffer for %s\n", 14874cc2dcf9SEric Biggers driver); 14884cc2dcf9SEric Biggers err = -ENOMEM; 14894cc2dcf9SEric Biggers goto out; 14904cc2dcf9SEric Biggers } 14914cc2dcf9SEric Biggers 14924cc2dcf9SEric Biggers for (i = 0; i < num_vecs; i++) { 14934cc2dcf9SEric Biggers err = test_hash_vec(driver, &vecs[i], i, req, tsgl, hashstate); 14944cc2dcf9SEric Biggers if (err) 14954cc2dcf9SEric Biggers goto out; 14964cc2dcf9SEric Biggers } 14979a8a6b3fSEric Biggers err = test_hash_vs_generic_impl(driver, generic_driver, maxkeysize, req, 14989a8a6b3fSEric Biggers tsgl, hashstate); 14994cc2dcf9SEric Biggers out: 15004cc2dcf9SEric Biggers kfree(hashstate); 15014cc2dcf9SEric Biggers if (tsgl) { 15024cc2dcf9SEric Biggers destroy_test_sglist(tsgl); 15034cc2dcf9SEric Biggers kfree(tsgl); 15044cc2dcf9SEric Biggers } 15054cc2dcf9SEric Biggers ahash_request_free(req); 15064cc2dcf9SEric Biggers crypto_free_ahash(tfm); 15074cc2dcf9SEric Biggers return err; 15084cc2dcf9SEric Biggers } 15094cc2dcf9SEric Biggers 15104cc2dcf9SEric Biggers static int alg_test_hash(const struct alg_test_desc *desc, const char *driver, 15114cc2dcf9SEric Biggers u32 type, u32 mask) 15124cc2dcf9SEric Biggers { 15134cc2dcf9SEric Biggers const struct hash_testvec *template = desc->suite.hash.vecs; 15144cc2dcf9SEric Biggers unsigned int tcount = desc->suite.hash.count; 15154cc2dcf9SEric Biggers unsigned int nr_unkeyed, nr_keyed; 15169a8a6b3fSEric Biggers unsigned int maxkeysize = 0; 15174cc2dcf9SEric Biggers int err; 15184cc2dcf9SEric Biggers 15194cc2dcf9SEric Biggers /* 15204cc2dcf9SEric Biggers * For OPTIONAL_KEY algorithms, we have to do all the unkeyed tests 15214cc2dcf9SEric Biggers * first, before setting a key on the tfm. To make this easier, we 15224cc2dcf9SEric Biggers * require that the unkeyed test vectors (if any) are listed first. 15234cc2dcf9SEric Biggers */ 15244cc2dcf9SEric Biggers 15254cc2dcf9SEric Biggers for (nr_unkeyed = 0; nr_unkeyed < tcount; nr_unkeyed++) { 15264cc2dcf9SEric Biggers if (template[nr_unkeyed].ksize) 15274cc2dcf9SEric Biggers break; 15284cc2dcf9SEric Biggers } 15294cc2dcf9SEric Biggers for (nr_keyed = 0; nr_unkeyed + nr_keyed < tcount; nr_keyed++) { 15304cc2dcf9SEric Biggers if (!template[nr_unkeyed + nr_keyed].ksize) { 15314cc2dcf9SEric Biggers pr_err("alg: hash: test vectors for %s out of order, " 15324cc2dcf9SEric Biggers "unkeyed ones must come first\n", desc->alg); 15334cc2dcf9SEric Biggers return -EINVAL; 15344cc2dcf9SEric Biggers } 15359a8a6b3fSEric Biggers maxkeysize = max_t(unsigned int, maxkeysize, 15369a8a6b3fSEric Biggers template[nr_unkeyed + nr_keyed].ksize); 15374cc2dcf9SEric Biggers } 15384cc2dcf9SEric Biggers 15394cc2dcf9SEric Biggers err = 0; 15404cc2dcf9SEric Biggers if (nr_unkeyed) { 15419a8a6b3fSEric Biggers err = __alg_test_hash(template, nr_unkeyed, driver, type, mask, 15429a8a6b3fSEric Biggers desc->generic_driver, maxkeysize); 15434cc2dcf9SEric Biggers template += nr_unkeyed; 15444cc2dcf9SEric Biggers } 15454cc2dcf9SEric Biggers 15464cc2dcf9SEric Biggers if (!err && nr_keyed) 15479a8a6b3fSEric Biggers err = __alg_test_hash(template, nr_keyed, driver, type, mask, 15489a8a6b3fSEric Biggers desc->generic_driver, maxkeysize); 15494cc2dcf9SEric Biggers 15504cc2dcf9SEric Biggers return err; 15514cc2dcf9SEric Biggers } 15524cc2dcf9SEric Biggers 1553ed96804fSEric Biggers static int test_aead_vec_cfg(const char *driver, int enc, 1554ed96804fSEric Biggers const struct aead_testvec *vec, 1555951d1332SEric Biggers const char *vec_name, 1556ed96804fSEric Biggers const struct testvec_config *cfg, 1557ed96804fSEric Biggers struct aead_request *req, 1558ed96804fSEric Biggers struct cipher_test_sglists *tsgls) 1559da7f033dSHerbert Xu { 1560ed96804fSEric Biggers struct crypto_aead *tfm = crypto_aead_reqtfm(req); 1561ed96804fSEric Biggers const unsigned int alignmask = crypto_aead_alignmask(tfm); 1562ed96804fSEric Biggers const unsigned int ivsize = crypto_aead_ivsize(tfm); 1563ed96804fSEric Biggers const unsigned int authsize = vec->clen - vec->plen; 1564ed96804fSEric Biggers const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags; 1565ed96804fSEric Biggers const char *op = enc ? "encryption" : "decryption"; 1566ed96804fSEric Biggers DECLARE_CRYPTO_WAIT(wait); 1567ed96804fSEric Biggers u8 _iv[3 * (MAX_ALGAPI_ALIGNMASK + 1) + MAX_IVLEN]; 1568ed96804fSEric Biggers u8 *iv = PTR_ALIGN(&_iv[0], 2 * (MAX_ALGAPI_ALIGNMASK + 1)) + 1569ed96804fSEric Biggers cfg->iv_offset + 1570ed96804fSEric Biggers (cfg->iv_offset_relative_to_alignmask ? alignmask : 0); 1571ed96804fSEric Biggers struct kvec input[2]; 15725283a8eeSEric Biggers int expected_error; 1573ed96804fSEric Biggers int err; 1574f8b0d4d0SHerbert Xu 1575ed96804fSEric Biggers /* Set the key */ 1576ed96804fSEric Biggers if (vec->wk) 1577ed96804fSEric Biggers crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 1578d8a32ac2SJussi Kivilinna else 1579ed96804fSEric Biggers crypto_aead_clear_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 1580ed96804fSEric Biggers err = crypto_aead_setkey(tfm, vec->key, vec->klen); 15815283a8eeSEric Biggers if (err && err != vec->setkey_error) { 1582951d1332SEric Biggers pr_err("alg: aead: %s setkey failed on test vector %s; expected_error=%d, actual_error=%d, flags=%#x\n", 1583951d1332SEric Biggers driver, vec_name, vec->setkey_error, err, 15845283a8eeSEric Biggers crypto_aead_get_flags(tfm)); 1585ed96804fSEric Biggers return err; 1586ed96804fSEric Biggers } 15875283a8eeSEric Biggers if (!err && vec->setkey_error) { 1588951d1332SEric Biggers pr_err("alg: aead: %s setkey unexpectedly succeeded on test vector %s; expected_error=%d\n", 1589951d1332SEric Biggers driver, vec_name, vec->setkey_error); 1590ed96804fSEric Biggers return -EINVAL; 1591ed96804fSEric Biggers } 1592d8a32ac2SJussi Kivilinna 1593ed96804fSEric Biggers /* Set the authentication tag size */ 1594ed96804fSEric Biggers err = crypto_aead_setauthsize(tfm, authsize); 15955283a8eeSEric Biggers if (err && err != vec->setauthsize_error) { 1596951d1332SEric Biggers pr_err("alg: aead: %s setauthsize failed on test vector %s; expected_error=%d, actual_error=%d\n", 1597951d1332SEric Biggers driver, vec_name, vec->setauthsize_error, err); 1598ed96804fSEric Biggers return err; 1599ed96804fSEric Biggers } 16005283a8eeSEric Biggers if (!err && vec->setauthsize_error) { 1601951d1332SEric Biggers pr_err("alg: aead: %s setauthsize unexpectedly succeeded on test vector %s; expected_error=%d\n", 1602951d1332SEric Biggers driver, vec_name, vec->setauthsize_error); 16035283a8eeSEric Biggers return -EINVAL; 16045283a8eeSEric Biggers } 16055283a8eeSEric Biggers 16065283a8eeSEric Biggers if (vec->setkey_error || vec->setauthsize_error) 16075283a8eeSEric Biggers return 0; 1608ed96804fSEric Biggers 1609ed96804fSEric Biggers /* The IV must be copied to a buffer, as the algorithm may modify it */ 1610ed96804fSEric Biggers if (WARN_ON(ivsize > MAX_IVLEN)) 1611ed96804fSEric Biggers return -EINVAL; 1612ed96804fSEric Biggers if (vec->iv) 1613ed96804fSEric Biggers memcpy(iv, vec->iv, ivsize); 1614da7f033dSHerbert Xu else 1615ed96804fSEric Biggers memset(iv, 0, ivsize); 1616da7f033dSHerbert Xu 1617ed96804fSEric Biggers /* Build the src/dst scatterlists */ 1618ed96804fSEric Biggers input[0].iov_base = (void *)vec->assoc; 1619ed96804fSEric Biggers input[0].iov_len = vec->alen; 1620ed96804fSEric Biggers input[1].iov_base = enc ? (void *)vec->ptext : (void *)vec->ctext; 1621ed96804fSEric Biggers input[1].iov_len = enc ? vec->plen : vec->clen; 1622ed96804fSEric Biggers err = build_cipher_test_sglists(tsgls, cfg, alignmask, 1623ed96804fSEric Biggers vec->alen + (enc ? vec->plen : 1624ed96804fSEric Biggers vec->clen), 1625ed96804fSEric Biggers vec->alen + (enc ? vec->clen : 1626ed96804fSEric Biggers vec->plen), 1627ed96804fSEric Biggers input, 2); 1628ed96804fSEric Biggers if (err) { 1629951d1332SEric Biggers pr_err("alg: aead: %s %s: error preparing scatterlists for test vector %s, cfg=\"%s\"\n", 1630951d1332SEric Biggers driver, op, vec_name, cfg->name); 1631ed96804fSEric Biggers return err; 1632da7f033dSHerbert Xu } 1633da7f033dSHerbert Xu 1634ed96804fSEric Biggers /* Do the actual encryption or decryption */ 1635ed96804fSEric Biggers testmgr_poison(req->__ctx, crypto_aead_reqsize(tfm)); 1636ed96804fSEric Biggers aead_request_set_callback(req, req_flags, crypto_req_done, &wait); 1637ed96804fSEric Biggers aead_request_set_crypt(req, tsgls->src.sgl_ptr, tsgls->dst.sgl_ptr, 1638ed96804fSEric Biggers enc ? vec->plen : vec->clen, iv); 1639ed96804fSEric Biggers aead_request_set_ad(req, vec->alen); 16406570737cSEric Biggers if (cfg->nosimd) 16416570737cSEric Biggers crypto_disable_simd_for_test(); 16426570737cSEric Biggers err = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req); 16436570737cSEric Biggers if (cfg->nosimd) 16446570737cSEric Biggers crypto_reenable_simd_for_test(); 16456570737cSEric Biggers err = crypto_wait_req(err, &wait); 164605b1d338SCristian Stoica 1647a6e5ef9bSEric Biggers /* Check that the algorithm didn't overwrite things it shouldn't have */ 1648a6e5ef9bSEric Biggers if (req->cryptlen != (enc ? vec->plen : vec->clen) || 1649a6e5ef9bSEric Biggers req->assoclen != vec->alen || 1650a6e5ef9bSEric Biggers req->iv != iv || 1651a6e5ef9bSEric Biggers req->src != tsgls->src.sgl_ptr || 1652a6e5ef9bSEric Biggers req->dst != tsgls->dst.sgl_ptr || 1653a6e5ef9bSEric Biggers crypto_aead_reqtfm(req) != tfm || 1654a6e5ef9bSEric Biggers req->base.complete != crypto_req_done || 1655a6e5ef9bSEric Biggers req->base.flags != req_flags || 1656a6e5ef9bSEric Biggers req->base.data != &wait) { 1657951d1332SEric Biggers pr_err("alg: aead: %s %s corrupted request struct on test vector %s, cfg=\"%s\"\n", 1658951d1332SEric Biggers driver, op, vec_name, cfg->name); 1659a6e5ef9bSEric Biggers if (req->cryptlen != (enc ? vec->plen : vec->clen)) 1660a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->cryptlen'\n"); 1661a6e5ef9bSEric Biggers if (req->assoclen != vec->alen) 1662a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->assoclen'\n"); 1663a6e5ef9bSEric Biggers if (req->iv != iv) 1664a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->iv'\n"); 1665a6e5ef9bSEric Biggers if (req->src != tsgls->src.sgl_ptr) 1666a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->src'\n"); 1667a6e5ef9bSEric Biggers if (req->dst != tsgls->dst.sgl_ptr) 1668a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->dst'\n"); 1669a6e5ef9bSEric Biggers if (crypto_aead_reqtfm(req) != tfm) 1670a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.tfm'\n"); 1671a6e5ef9bSEric Biggers if (req->base.complete != crypto_req_done) 1672a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.complete'\n"); 1673a6e5ef9bSEric Biggers if (req->base.flags != req_flags) 1674a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.flags'\n"); 1675a6e5ef9bSEric Biggers if (req->base.data != &wait) 1676a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.data'\n"); 1677a6e5ef9bSEric Biggers return -EINVAL; 1678a6e5ef9bSEric Biggers } 1679a6e5ef9bSEric Biggers if (is_test_sglist_corrupted(&tsgls->src)) { 1680951d1332SEric Biggers pr_err("alg: aead: %s %s corrupted src sgl on test vector %s, cfg=\"%s\"\n", 1681951d1332SEric Biggers driver, op, vec_name, cfg->name); 1682a6e5ef9bSEric Biggers return -EINVAL; 1683a6e5ef9bSEric Biggers } 1684a6e5ef9bSEric Biggers if (tsgls->dst.sgl_ptr != tsgls->src.sgl && 1685a6e5ef9bSEric Biggers is_test_sglist_corrupted(&tsgls->dst)) { 1686951d1332SEric Biggers pr_err("alg: aead: %s %s corrupted dst sgl on test vector %s, cfg=\"%s\"\n", 1687951d1332SEric Biggers driver, op, vec_name, cfg->name); 1688a6e5ef9bSEric Biggers return -EINVAL; 1689a6e5ef9bSEric Biggers } 1690a6e5ef9bSEric Biggers 16915283a8eeSEric Biggers /* Check for success or failure */ 16925283a8eeSEric Biggers expected_error = vec->novrfy ? -EBADMSG : vec->crypt_error; 16935283a8eeSEric Biggers if (err) { 16945283a8eeSEric Biggers if (err == expected_error) 16955283a8eeSEric Biggers return 0; 1696951d1332SEric Biggers pr_err("alg: aead: %s %s failed on test vector %s; expected_error=%d, actual_error=%d, cfg=\"%s\"\n", 1697951d1332SEric Biggers driver, op, vec_name, expected_error, err, cfg->name); 16985283a8eeSEric Biggers return err; 16995283a8eeSEric Biggers } 17005283a8eeSEric Biggers if (expected_error) { 1701951d1332SEric Biggers pr_err("alg: aead: %s %s unexpectedly succeeded on test vector %s; expected_error=%d, cfg=\"%s\"\n", 1702951d1332SEric Biggers driver, op, vec_name, expected_error, cfg->name); 17035283a8eeSEric Biggers return -EINVAL; 17045283a8eeSEric Biggers } 17055283a8eeSEric Biggers 1706ed96804fSEric Biggers /* Check for the correct output (ciphertext or plaintext) */ 1707ed96804fSEric Biggers err = verify_correct_output(&tsgls->dst, enc ? vec->ctext : vec->ptext, 1708ed96804fSEric Biggers enc ? vec->clen : vec->plen, 1709ed96804fSEric Biggers vec->alen, enc || !cfg->inplace); 1710ed96804fSEric Biggers if (err == -EOVERFLOW) { 1711951d1332SEric Biggers pr_err("alg: aead: %s %s overran dst buffer on test vector %s, cfg=\"%s\"\n", 1712951d1332SEric Biggers driver, op, vec_name, cfg->name); 1713ed96804fSEric Biggers return err; 171429b77e5dSHoria Geanta } 1715ed96804fSEric Biggers if (err) { 1716951d1332SEric Biggers pr_err("alg: aead: %s %s test failed (wrong result) on test vector %s, cfg=\"%s\"\n", 1717951d1332SEric Biggers driver, op, vec_name, cfg->name); 1718ed96804fSEric Biggers return err; 171958dcf548SJussi Kivilinna } 172058dcf548SJussi Kivilinna 172158dcf548SJussi Kivilinna return 0; 1722d8a32ac2SJussi Kivilinna } 1723d8a32ac2SJussi Kivilinna 1724ed96804fSEric Biggers static int test_aead_vec(const char *driver, int enc, 1725ed96804fSEric Biggers const struct aead_testvec *vec, unsigned int vec_num, 1726ed96804fSEric Biggers struct aead_request *req, 1727ed96804fSEric Biggers struct cipher_test_sglists *tsgls) 1728ed96804fSEric Biggers { 1729951d1332SEric Biggers char vec_name[16]; 1730ed96804fSEric Biggers unsigned int i; 1731ed96804fSEric Biggers int err; 1732ed96804fSEric Biggers 1733ed96804fSEric Biggers if (enc && vec->novrfy) 1734ed96804fSEric Biggers return 0; 1735ed96804fSEric Biggers 1736951d1332SEric Biggers sprintf(vec_name, "%u", vec_num); 1737951d1332SEric Biggers 1738ed96804fSEric Biggers for (i = 0; i < ARRAY_SIZE(default_cipher_testvec_configs); i++) { 1739951d1332SEric Biggers err = test_aead_vec_cfg(driver, enc, vec, vec_name, 1740ed96804fSEric Biggers &default_cipher_testvec_configs[i], 1741ed96804fSEric Biggers req, tsgls); 1742ed96804fSEric Biggers if (err) 1743ed96804fSEric Biggers return err; 1744ed96804fSEric Biggers } 1745ed96804fSEric Biggers 1746ed96804fSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 1747ed96804fSEric Biggers if (!noextratests) { 1748ed96804fSEric Biggers struct testvec_config cfg; 1749ed96804fSEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 1750ed96804fSEric Biggers 1751ed96804fSEric Biggers for (i = 0; i < fuzz_iterations; i++) { 1752ed96804fSEric Biggers generate_random_testvec_config(&cfg, cfgname, 1753ed96804fSEric Biggers sizeof(cfgname)); 1754951d1332SEric Biggers err = test_aead_vec_cfg(driver, enc, vec, vec_name, 1755ed96804fSEric Biggers &cfg, req, tsgls); 1756ed96804fSEric Biggers if (err) 1757ed96804fSEric Biggers return err; 1758ed96804fSEric Biggers } 1759ed96804fSEric Biggers } 1760ed96804fSEric Biggers #endif 1761ed96804fSEric Biggers return 0; 1762ed96804fSEric Biggers } 1763ed96804fSEric Biggers 176440153b10SEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 176540153b10SEric Biggers /* 176640153b10SEric Biggers * Generate an AEAD test vector from the given implementation. 176740153b10SEric Biggers * Assumes the buffers in 'vec' were already allocated. 176840153b10SEric Biggers */ 176940153b10SEric Biggers static void generate_random_aead_testvec(struct aead_request *req, 177040153b10SEric Biggers struct aead_testvec *vec, 177140153b10SEric Biggers unsigned int maxkeysize, 177240153b10SEric Biggers unsigned int maxdatasize, 177340153b10SEric Biggers char *name, size_t max_namelen) 177440153b10SEric Biggers { 177540153b10SEric Biggers struct crypto_aead *tfm = crypto_aead_reqtfm(req); 177640153b10SEric Biggers const unsigned int ivsize = crypto_aead_ivsize(tfm); 177740153b10SEric Biggers unsigned int maxauthsize = crypto_aead_alg(tfm)->maxauthsize; 177840153b10SEric Biggers unsigned int authsize; 177940153b10SEric Biggers unsigned int total_len; 178040153b10SEric Biggers int i; 178140153b10SEric Biggers struct scatterlist src[2], dst; 178240153b10SEric Biggers u8 iv[MAX_IVLEN]; 178340153b10SEric Biggers DECLARE_CRYPTO_WAIT(wait); 178440153b10SEric Biggers 178540153b10SEric Biggers /* Key: length in [0, maxkeysize], but usually choose maxkeysize */ 178640153b10SEric Biggers vec->klen = maxkeysize; 178740153b10SEric Biggers if (prandom_u32() % 4 == 0) 178840153b10SEric Biggers vec->klen = prandom_u32() % (maxkeysize + 1); 178940153b10SEric Biggers generate_random_bytes((u8 *)vec->key, vec->klen); 179040153b10SEric Biggers vec->setkey_error = crypto_aead_setkey(tfm, vec->key, vec->klen); 179140153b10SEric Biggers 179240153b10SEric Biggers /* IV */ 179340153b10SEric Biggers generate_random_bytes((u8 *)vec->iv, ivsize); 179440153b10SEric Biggers 179540153b10SEric Biggers /* Tag length: in [0, maxauthsize], but usually choose maxauthsize */ 179640153b10SEric Biggers authsize = maxauthsize; 179740153b10SEric Biggers if (prandom_u32() % 4 == 0) 179840153b10SEric Biggers authsize = prandom_u32() % (maxauthsize + 1); 179940153b10SEric Biggers if (WARN_ON(authsize > maxdatasize)) 180040153b10SEric Biggers authsize = maxdatasize; 180140153b10SEric Biggers maxdatasize -= authsize; 180240153b10SEric Biggers vec->setauthsize_error = crypto_aead_setauthsize(tfm, authsize); 180340153b10SEric Biggers 180440153b10SEric Biggers /* Plaintext and associated data */ 180540153b10SEric Biggers total_len = generate_random_length(maxdatasize); 180640153b10SEric Biggers if (prandom_u32() % 4 == 0) 180740153b10SEric Biggers vec->alen = 0; 180840153b10SEric Biggers else 180940153b10SEric Biggers vec->alen = generate_random_length(total_len); 181040153b10SEric Biggers vec->plen = total_len - vec->alen; 181140153b10SEric Biggers generate_random_bytes((u8 *)vec->assoc, vec->alen); 181240153b10SEric Biggers generate_random_bytes((u8 *)vec->ptext, vec->plen); 181340153b10SEric Biggers 181440153b10SEric Biggers vec->clen = vec->plen + authsize; 181540153b10SEric Biggers 181640153b10SEric Biggers /* 181740153b10SEric Biggers * If the key or authentication tag size couldn't be set, no need to 181840153b10SEric Biggers * continue to encrypt. 181940153b10SEric Biggers */ 182040153b10SEric Biggers if (vec->setkey_error || vec->setauthsize_error) 182140153b10SEric Biggers goto done; 182240153b10SEric Biggers 182340153b10SEric Biggers /* Ciphertext */ 182440153b10SEric Biggers sg_init_table(src, 2); 182540153b10SEric Biggers i = 0; 182640153b10SEric Biggers if (vec->alen) 182740153b10SEric Biggers sg_set_buf(&src[i++], vec->assoc, vec->alen); 182840153b10SEric Biggers if (vec->plen) 182940153b10SEric Biggers sg_set_buf(&src[i++], vec->ptext, vec->plen); 183040153b10SEric Biggers sg_init_one(&dst, vec->ctext, vec->alen + vec->clen); 183140153b10SEric Biggers memcpy(iv, vec->iv, ivsize); 183240153b10SEric Biggers aead_request_set_callback(req, 0, crypto_req_done, &wait); 183340153b10SEric Biggers aead_request_set_crypt(req, src, &dst, vec->plen, iv); 183440153b10SEric Biggers aead_request_set_ad(req, vec->alen); 183540153b10SEric Biggers vec->crypt_error = crypto_wait_req(crypto_aead_encrypt(req), &wait); 183640153b10SEric Biggers if (vec->crypt_error == 0) 183740153b10SEric Biggers memmove((u8 *)vec->ctext, vec->ctext + vec->alen, vec->clen); 183840153b10SEric Biggers done: 183940153b10SEric Biggers snprintf(name, max_namelen, 184040153b10SEric Biggers "\"random: alen=%u plen=%u authsize=%u klen=%u\"", 184140153b10SEric Biggers vec->alen, vec->plen, authsize, vec->klen); 184240153b10SEric Biggers } 184340153b10SEric Biggers 184440153b10SEric Biggers /* 184540153b10SEric Biggers * Test the AEAD algorithm represented by @req against the corresponding generic 184640153b10SEric Biggers * implementation, if one is available. 184740153b10SEric Biggers */ 184840153b10SEric Biggers static int test_aead_vs_generic_impl(const char *driver, 184940153b10SEric Biggers const struct alg_test_desc *test_desc, 185040153b10SEric Biggers struct aead_request *req, 185140153b10SEric Biggers struct cipher_test_sglists *tsgls) 185240153b10SEric Biggers { 185340153b10SEric Biggers struct crypto_aead *tfm = crypto_aead_reqtfm(req); 185440153b10SEric Biggers const unsigned int ivsize = crypto_aead_ivsize(tfm); 185540153b10SEric Biggers const unsigned int maxauthsize = crypto_aead_alg(tfm)->maxauthsize; 185640153b10SEric Biggers const unsigned int blocksize = crypto_aead_blocksize(tfm); 185740153b10SEric Biggers const unsigned int maxdatasize = (2 * PAGE_SIZE) - TESTMGR_POISON_LEN; 185840153b10SEric Biggers const char *algname = crypto_aead_alg(tfm)->base.cra_name; 185940153b10SEric Biggers const char *generic_driver = test_desc->generic_driver; 186040153b10SEric Biggers char _generic_driver[CRYPTO_MAX_ALG_NAME]; 186140153b10SEric Biggers struct crypto_aead *generic_tfm = NULL; 186240153b10SEric Biggers struct aead_request *generic_req = NULL; 186340153b10SEric Biggers unsigned int maxkeysize; 186440153b10SEric Biggers unsigned int i; 186540153b10SEric Biggers struct aead_testvec vec = { 0 }; 186640153b10SEric Biggers char vec_name[64]; 186740153b10SEric Biggers struct testvec_config cfg; 186840153b10SEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 186940153b10SEric Biggers int err; 187040153b10SEric Biggers 187140153b10SEric Biggers if (noextratests) 187240153b10SEric Biggers return 0; 187340153b10SEric Biggers 187440153b10SEric Biggers if (!generic_driver) { /* Use default naming convention? */ 187540153b10SEric Biggers err = build_generic_driver_name(algname, _generic_driver); 187640153b10SEric Biggers if (err) 187740153b10SEric Biggers return err; 187840153b10SEric Biggers generic_driver = _generic_driver; 187940153b10SEric Biggers } 188040153b10SEric Biggers 188140153b10SEric Biggers if (strcmp(generic_driver, driver) == 0) /* Already the generic impl? */ 188240153b10SEric Biggers return 0; 188340153b10SEric Biggers 188440153b10SEric Biggers generic_tfm = crypto_alloc_aead(generic_driver, 0, 0); 188540153b10SEric Biggers if (IS_ERR(generic_tfm)) { 188640153b10SEric Biggers err = PTR_ERR(generic_tfm); 188740153b10SEric Biggers if (err == -ENOENT) { 188840153b10SEric Biggers pr_warn("alg: aead: skipping comparison tests for %s because %s is unavailable\n", 188940153b10SEric Biggers driver, generic_driver); 189040153b10SEric Biggers return 0; 189140153b10SEric Biggers } 189240153b10SEric Biggers pr_err("alg: aead: error allocating %s (generic impl of %s): %d\n", 189340153b10SEric Biggers generic_driver, algname, err); 189440153b10SEric Biggers return err; 189540153b10SEric Biggers } 189640153b10SEric Biggers 189740153b10SEric Biggers generic_req = aead_request_alloc(generic_tfm, GFP_KERNEL); 189840153b10SEric Biggers if (!generic_req) { 189940153b10SEric Biggers err = -ENOMEM; 190040153b10SEric Biggers goto out; 190140153b10SEric Biggers } 190240153b10SEric Biggers 190340153b10SEric Biggers /* Check the algorithm properties for consistency. */ 190440153b10SEric Biggers 190540153b10SEric Biggers if (maxauthsize != crypto_aead_alg(generic_tfm)->maxauthsize) { 190640153b10SEric Biggers pr_err("alg: aead: maxauthsize for %s (%u) doesn't match generic impl (%u)\n", 190740153b10SEric Biggers driver, maxauthsize, 190840153b10SEric Biggers crypto_aead_alg(generic_tfm)->maxauthsize); 190940153b10SEric Biggers err = -EINVAL; 191040153b10SEric Biggers goto out; 191140153b10SEric Biggers } 191240153b10SEric Biggers 191340153b10SEric Biggers if (ivsize != crypto_aead_ivsize(generic_tfm)) { 191440153b10SEric Biggers pr_err("alg: aead: ivsize for %s (%u) doesn't match generic impl (%u)\n", 191540153b10SEric Biggers driver, ivsize, crypto_aead_ivsize(generic_tfm)); 191640153b10SEric Biggers err = -EINVAL; 191740153b10SEric Biggers goto out; 191840153b10SEric Biggers } 191940153b10SEric Biggers 192040153b10SEric Biggers if (blocksize != crypto_aead_blocksize(generic_tfm)) { 192140153b10SEric Biggers pr_err("alg: aead: blocksize for %s (%u) doesn't match generic impl (%u)\n", 192240153b10SEric Biggers driver, blocksize, crypto_aead_blocksize(generic_tfm)); 192340153b10SEric Biggers err = -EINVAL; 192440153b10SEric Biggers goto out; 192540153b10SEric Biggers } 192640153b10SEric Biggers 192740153b10SEric Biggers /* 192840153b10SEric Biggers * Now generate test vectors using the generic implementation, and test 192940153b10SEric Biggers * the other implementation against them. 193040153b10SEric Biggers */ 193140153b10SEric Biggers 193240153b10SEric Biggers maxkeysize = 0; 193340153b10SEric Biggers for (i = 0; i < test_desc->suite.aead.count; i++) 193440153b10SEric Biggers maxkeysize = max_t(unsigned int, maxkeysize, 193540153b10SEric Biggers test_desc->suite.aead.vecs[i].klen); 193640153b10SEric Biggers 193740153b10SEric Biggers vec.key = kmalloc(maxkeysize, GFP_KERNEL); 193840153b10SEric Biggers vec.iv = kmalloc(ivsize, GFP_KERNEL); 193940153b10SEric Biggers vec.assoc = kmalloc(maxdatasize, GFP_KERNEL); 194040153b10SEric Biggers vec.ptext = kmalloc(maxdatasize, GFP_KERNEL); 194140153b10SEric Biggers vec.ctext = kmalloc(maxdatasize, GFP_KERNEL); 194240153b10SEric Biggers if (!vec.key || !vec.iv || !vec.assoc || !vec.ptext || !vec.ctext) { 194340153b10SEric Biggers err = -ENOMEM; 194440153b10SEric Biggers goto out; 194540153b10SEric Biggers } 194640153b10SEric Biggers 194740153b10SEric Biggers for (i = 0; i < fuzz_iterations * 8; i++) { 194840153b10SEric Biggers generate_random_aead_testvec(generic_req, &vec, 194940153b10SEric Biggers maxkeysize, maxdatasize, 195040153b10SEric Biggers vec_name, sizeof(vec_name)); 195140153b10SEric Biggers generate_random_testvec_config(&cfg, cfgname, sizeof(cfgname)); 195240153b10SEric Biggers 195340153b10SEric Biggers err = test_aead_vec_cfg(driver, ENCRYPT, &vec, vec_name, &cfg, 195440153b10SEric Biggers req, tsgls); 195540153b10SEric Biggers if (err) 195640153b10SEric Biggers goto out; 195740153b10SEric Biggers err = test_aead_vec_cfg(driver, DECRYPT, &vec, vec_name, &cfg, 195840153b10SEric Biggers req, tsgls); 195940153b10SEric Biggers if (err) 196040153b10SEric Biggers goto out; 196140153b10SEric Biggers cond_resched(); 196240153b10SEric Biggers } 196340153b10SEric Biggers err = 0; 196440153b10SEric Biggers out: 196540153b10SEric Biggers kfree(vec.key); 196640153b10SEric Biggers kfree(vec.iv); 196740153b10SEric Biggers kfree(vec.assoc); 196840153b10SEric Biggers kfree(vec.ptext); 196940153b10SEric Biggers kfree(vec.ctext); 197040153b10SEric Biggers crypto_free_aead(generic_tfm); 197140153b10SEric Biggers aead_request_free(generic_req); 197240153b10SEric Biggers return err; 197340153b10SEric Biggers } 197440153b10SEric Biggers #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 197540153b10SEric Biggers static int test_aead_vs_generic_impl(const char *driver, 197640153b10SEric Biggers const struct alg_test_desc *test_desc, 197740153b10SEric Biggers struct aead_request *req, 197840153b10SEric Biggers struct cipher_test_sglists *tsgls) 197940153b10SEric Biggers { 198040153b10SEric Biggers return 0; 198140153b10SEric Biggers } 198240153b10SEric Biggers #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 198340153b10SEric Biggers 1984ed96804fSEric Biggers static int test_aead(const char *driver, int enc, 1985ed96804fSEric Biggers const struct aead_test_suite *suite, 1986ed96804fSEric Biggers struct aead_request *req, 1987ed96804fSEric Biggers struct cipher_test_sglists *tsgls) 1988ed96804fSEric Biggers { 1989ed96804fSEric Biggers unsigned int i; 1990ed96804fSEric Biggers int err; 1991ed96804fSEric Biggers 1992ed96804fSEric Biggers for (i = 0; i < suite->count; i++) { 1993ed96804fSEric Biggers err = test_aead_vec(driver, enc, &suite->vecs[i], i, req, 1994ed96804fSEric Biggers tsgls); 1995ed96804fSEric Biggers if (err) 1996ed96804fSEric Biggers return err; 1997ed96804fSEric Biggers } 1998ed96804fSEric Biggers return 0; 1999ed96804fSEric Biggers } 2000ed96804fSEric Biggers 2001ed96804fSEric Biggers static int alg_test_aead(const struct alg_test_desc *desc, const char *driver, 2002ed96804fSEric Biggers u32 type, u32 mask) 2003ed96804fSEric Biggers { 2004ed96804fSEric Biggers const struct aead_test_suite *suite = &desc->suite.aead; 2005ed96804fSEric Biggers struct crypto_aead *tfm; 2006ed96804fSEric Biggers struct aead_request *req = NULL; 2007ed96804fSEric Biggers struct cipher_test_sglists *tsgls = NULL; 2008ed96804fSEric Biggers int err; 2009ed96804fSEric Biggers 2010ed96804fSEric Biggers if (suite->count <= 0) { 2011ed96804fSEric Biggers pr_err("alg: aead: empty test suite for %s\n", driver); 2012ed96804fSEric Biggers return -EINVAL; 2013ed96804fSEric Biggers } 2014ed96804fSEric Biggers 2015ed96804fSEric Biggers tfm = crypto_alloc_aead(driver, type, mask); 2016ed96804fSEric Biggers if (IS_ERR(tfm)) { 2017ed96804fSEric Biggers pr_err("alg: aead: failed to allocate transform for %s: %ld\n", 2018ed96804fSEric Biggers driver, PTR_ERR(tfm)); 2019ed96804fSEric Biggers return PTR_ERR(tfm); 2020ed96804fSEric Biggers } 2021ed96804fSEric Biggers 2022ed96804fSEric Biggers req = aead_request_alloc(tfm, GFP_KERNEL); 2023ed96804fSEric Biggers if (!req) { 2024ed96804fSEric Biggers pr_err("alg: aead: failed to allocate request for %s\n", 2025ed96804fSEric Biggers driver); 2026ed96804fSEric Biggers err = -ENOMEM; 2027ed96804fSEric Biggers goto out; 2028ed96804fSEric Biggers } 2029ed96804fSEric Biggers 2030ed96804fSEric Biggers tsgls = alloc_cipher_test_sglists(); 2031ed96804fSEric Biggers if (!tsgls) { 2032ed96804fSEric Biggers pr_err("alg: aead: failed to allocate test buffers for %s\n", 2033ed96804fSEric Biggers driver); 2034ed96804fSEric Biggers err = -ENOMEM; 2035ed96804fSEric Biggers goto out; 2036ed96804fSEric Biggers } 2037ed96804fSEric Biggers 2038ed96804fSEric Biggers err = test_aead(driver, ENCRYPT, suite, req, tsgls); 2039ed96804fSEric Biggers if (err) 2040ed96804fSEric Biggers goto out; 2041ed96804fSEric Biggers 2042ed96804fSEric Biggers err = test_aead(driver, DECRYPT, suite, req, tsgls); 204340153b10SEric Biggers if (err) 204440153b10SEric Biggers goto out; 204540153b10SEric Biggers 204640153b10SEric Biggers err = test_aead_vs_generic_impl(driver, desc, req, tsgls); 2047ed96804fSEric Biggers out: 2048ed96804fSEric Biggers free_cipher_test_sglists(tsgls); 2049ed96804fSEric Biggers aead_request_free(req); 2050ed96804fSEric Biggers crypto_free_aead(tfm); 2051ed96804fSEric Biggers return err; 2052ed96804fSEric Biggers } 2053ed96804fSEric Biggers 20541aa4ecd9SHerbert Xu static int test_cipher(struct crypto_cipher *tfm, int enc, 2055b13b1e0cSEric Biggers const struct cipher_testvec *template, 2056b13b1e0cSEric Biggers unsigned int tcount) 20571aa4ecd9SHerbert Xu { 20581aa4ecd9SHerbert Xu const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm)); 20591aa4ecd9SHerbert Xu unsigned int i, j, k; 20601aa4ecd9SHerbert Xu char *q; 20611aa4ecd9SHerbert Xu const char *e; 206292a4c9feSEric Biggers const char *input, *result; 20631aa4ecd9SHerbert Xu void *data; 2064f8b0d4d0SHerbert Xu char *xbuf[XBUFSIZE]; 2065f8b0d4d0SHerbert Xu int ret = -ENOMEM; 2066f8b0d4d0SHerbert Xu 2067f8b0d4d0SHerbert Xu if (testmgr_alloc_buf(xbuf)) 2068f8b0d4d0SHerbert Xu goto out_nobuf; 20691aa4ecd9SHerbert Xu 20701aa4ecd9SHerbert Xu if (enc == ENCRYPT) 20711aa4ecd9SHerbert Xu e = "encryption"; 20721aa4ecd9SHerbert Xu else 20731aa4ecd9SHerbert Xu e = "decryption"; 20741aa4ecd9SHerbert Xu 20751aa4ecd9SHerbert Xu j = 0; 20761aa4ecd9SHerbert Xu for (i = 0; i < tcount; i++) { 20771aa4ecd9SHerbert Xu 207810faa8c0SStephan Mueller if (fips_enabled && template[i].fips_skip) 207910faa8c0SStephan Mueller continue; 208010faa8c0SStephan Mueller 208192a4c9feSEric Biggers input = enc ? template[i].ptext : template[i].ctext; 208292a4c9feSEric Biggers result = enc ? template[i].ctext : template[i].ptext; 20831aa4ecd9SHerbert Xu j++; 20841aa4ecd9SHerbert Xu 2085fd57f22aSHerbert Xu ret = -EINVAL; 208692a4c9feSEric Biggers if (WARN_ON(template[i].len > PAGE_SIZE)) 2087fd57f22aSHerbert Xu goto out; 2088fd57f22aSHerbert Xu 20891aa4ecd9SHerbert Xu data = xbuf[0]; 209092a4c9feSEric Biggers memcpy(data, input, template[i].len); 20911aa4ecd9SHerbert Xu 20921aa4ecd9SHerbert Xu crypto_cipher_clear_flags(tfm, ~0); 20931aa4ecd9SHerbert Xu if (template[i].wk) 2094231baecdSEric Biggers crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 20951aa4ecd9SHerbert Xu 20961aa4ecd9SHerbert Xu ret = crypto_cipher_setkey(tfm, template[i].key, 20971aa4ecd9SHerbert Xu template[i].klen); 20985283a8eeSEric Biggers if (ret) { 20995283a8eeSEric Biggers if (ret == template[i].setkey_error) 21001aa4ecd9SHerbert Xu continue; 21015283a8eeSEric Biggers pr_err("alg: cipher: %s setkey failed on test vector %u; expected_error=%d, actual_error=%d, flags=%#x\n", 21025283a8eeSEric Biggers algo, j, template[i].setkey_error, ret, 21035283a8eeSEric Biggers crypto_cipher_get_flags(tfm)); 21045283a8eeSEric Biggers goto out; 21055283a8eeSEric Biggers } 21065283a8eeSEric Biggers if (template[i].setkey_error) { 21075283a8eeSEric Biggers pr_err("alg: cipher: %s setkey unexpectedly succeeded on test vector %u; expected_error=%d\n", 21085283a8eeSEric Biggers algo, j, template[i].setkey_error); 21095283a8eeSEric Biggers ret = -EINVAL; 21105283a8eeSEric Biggers goto out; 21115283a8eeSEric Biggers } 21121aa4ecd9SHerbert Xu 211392a4c9feSEric Biggers for (k = 0; k < template[i].len; 21141aa4ecd9SHerbert Xu k += crypto_cipher_blocksize(tfm)) { 21151aa4ecd9SHerbert Xu if (enc) 21161aa4ecd9SHerbert Xu crypto_cipher_encrypt_one(tfm, data + k, 21171aa4ecd9SHerbert Xu data + k); 21181aa4ecd9SHerbert Xu else 21191aa4ecd9SHerbert Xu crypto_cipher_decrypt_one(tfm, data + k, 21201aa4ecd9SHerbert Xu data + k); 21211aa4ecd9SHerbert Xu } 21221aa4ecd9SHerbert Xu 21231aa4ecd9SHerbert Xu q = data; 212492a4c9feSEric Biggers if (memcmp(q, result, template[i].len)) { 21251aa4ecd9SHerbert Xu printk(KERN_ERR "alg: cipher: Test %d failed " 21261aa4ecd9SHerbert Xu "on %s for %s\n", j, e, algo); 212792a4c9feSEric Biggers hexdump(q, template[i].len); 21281aa4ecd9SHerbert Xu ret = -EINVAL; 21291aa4ecd9SHerbert Xu goto out; 21301aa4ecd9SHerbert Xu } 21311aa4ecd9SHerbert Xu } 21321aa4ecd9SHerbert Xu 21331aa4ecd9SHerbert Xu ret = 0; 21341aa4ecd9SHerbert Xu 21351aa4ecd9SHerbert Xu out: 2136f8b0d4d0SHerbert Xu testmgr_free_buf(xbuf); 2137f8b0d4d0SHerbert Xu out_nobuf: 21381aa4ecd9SHerbert Xu return ret; 21391aa4ecd9SHerbert Xu } 21401aa4ecd9SHerbert Xu 21414e7babbaSEric Biggers static int test_skcipher_vec_cfg(const char *driver, int enc, 21424e7babbaSEric Biggers const struct cipher_testvec *vec, 2143951d1332SEric Biggers const char *vec_name, 21444e7babbaSEric Biggers const struct testvec_config *cfg, 21454e7babbaSEric Biggers struct skcipher_request *req, 21464e7babbaSEric Biggers struct cipher_test_sglists *tsgls) 2147da7f033dSHerbert Xu { 21484e7babbaSEric Biggers struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 21494e7babbaSEric Biggers const unsigned int alignmask = crypto_skcipher_alignmask(tfm); 21504e7babbaSEric Biggers const unsigned int ivsize = crypto_skcipher_ivsize(tfm); 21514e7babbaSEric Biggers const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags; 21524e7babbaSEric Biggers const char *op = enc ? "encryption" : "decryption"; 21534e7babbaSEric Biggers DECLARE_CRYPTO_WAIT(wait); 21544e7babbaSEric Biggers u8 _iv[3 * (MAX_ALGAPI_ALIGNMASK + 1) + MAX_IVLEN]; 21554e7babbaSEric Biggers u8 *iv = PTR_ALIGN(&_iv[0], 2 * (MAX_ALGAPI_ALIGNMASK + 1)) + 21564e7babbaSEric Biggers cfg->iv_offset + 21574e7babbaSEric Biggers (cfg->iv_offset_relative_to_alignmask ? alignmask : 0); 21584e7babbaSEric Biggers struct kvec input; 21594e7babbaSEric Biggers int err; 2160f8b0d4d0SHerbert Xu 21614e7babbaSEric Biggers /* Set the key */ 21624e7babbaSEric Biggers if (vec->wk) 2163231baecdSEric Biggers crypto_skcipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 2164da7f033dSHerbert Xu else 21654e7babbaSEric Biggers crypto_skcipher_clear_flags(tfm, 21664e7babbaSEric Biggers CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 21674e7babbaSEric Biggers err = crypto_skcipher_setkey(tfm, vec->key, vec->klen); 21684e7babbaSEric Biggers if (err) { 21695283a8eeSEric Biggers if (err == vec->setkey_error) 21704e7babbaSEric Biggers return 0; 2171951d1332SEric Biggers pr_err("alg: skcipher: %s setkey failed on test vector %s; expected_error=%d, actual_error=%d, flags=%#x\n", 2172951d1332SEric Biggers driver, vec_name, vec->setkey_error, err, 21735283a8eeSEric Biggers crypto_skcipher_get_flags(tfm)); 21744e7babbaSEric Biggers return err; 21754e7babbaSEric Biggers } 21765283a8eeSEric Biggers if (vec->setkey_error) { 2177951d1332SEric Biggers pr_err("alg: skcipher: %s setkey unexpectedly succeeded on test vector %s; expected_error=%d\n", 2178951d1332SEric Biggers driver, vec_name, vec->setkey_error); 21794e7babbaSEric Biggers return -EINVAL; 218008d6af8cSJussi Kivilinna } 2181da7f033dSHerbert Xu 21824e7babbaSEric Biggers /* The IV must be copied to a buffer, as the algorithm may modify it */ 21834e7babbaSEric Biggers if (ivsize) { 21844e7babbaSEric Biggers if (WARN_ON(ivsize > MAX_IVLEN)) 21854e7babbaSEric Biggers return -EINVAL; 21868efd972eSEric Biggers if (vec->generates_iv && !enc) 21878efd972eSEric Biggers memcpy(iv, vec->iv_out, ivsize); 21888efd972eSEric Biggers else if (vec->iv) 21894e7babbaSEric Biggers memcpy(iv, vec->iv, ivsize); 219008d6af8cSJussi Kivilinna else 21914e7babbaSEric Biggers memset(iv, 0, ivsize); 21924e7babbaSEric Biggers } else { 21934e7babbaSEric Biggers if (vec->generates_iv) { 2194951d1332SEric Biggers pr_err("alg: skcipher: %s has ivsize=0 but test vector %s generates IV!\n", 2195951d1332SEric Biggers driver, vec_name); 21964e7babbaSEric Biggers return -EINVAL; 21974e7babbaSEric Biggers } 21984e7babbaSEric Biggers iv = NULL; 2199da7f033dSHerbert Xu } 2200da7f033dSHerbert Xu 22014e7babbaSEric Biggers /* Build the src/dst scatterlists */ 22024e7babbaSEric Biggers input.iov_base = enc ? (void *)vec->ptext : (void *)vec->ctext; 22034e7babbaSEric Biggers input.iov_len = vec->len; 22044e7babbaSEric Biggers err = build_cipher_test_sglists(tsgls, cfg, alignmask, 22054e7babbaSEric Biggers vec->len, vec->len, &input, 1); 22064e7babbaSEric Biggers if (err) { 2207951d1332SEric Biggers pr_err("alg: skcipher: %s %s: error preparing scatterlists for test vector %s, cfg=\"%s\"\n", 2208951d1332SEric Biggers driver, op, vec_name, cfg->name); 22094e7babbaSEric Biggers return err; 2210da7f033dSHerbert Xu } 2211da7f033dSHerbert Xu 22124e7babbaSEric Biggers /* Do the actual encryption or decryption */ 22134e7babbaSEric Biggers testmgr_poison(req->__ctx, crypto_skcipher_reqsize(tfm)); 22144e7babbaSEric Biggers skcipher_request_set_callback(req, req_flags, crypto_req_done, &wait); 22154e7babbaSEric Biggers skcipher_request_set_crypt(req, tsgls->src.sgl_ptr, tsgls->dst.sgl_ptr, 22164e7babbaSEric Biggers vec->len, iv); 22176570737cSEric Biggers if (cfg->nosimd) 22186570737cSEric Biggers crypto_disable_simd_for_test(); 22196570737cSEric Biggers err = enc ? crypto_skcipher_encrypt(req) : crypto_skcipher_decrypt(req); 22206570737cSEric Biggers if (cfg->nosimd) 22216570737cSEric Biggers crypto_reenable_simd_for_test(); 22226570737cSEric Biggers err = crypto_wait_req(err, &wait); 2223da7f033dSHerbert Xu 2224fa353c99SEric Biggers /* Check that the algorithm didn't overwrite things it shouldn't have */ 2225fa353c99SEric Biggers if (req->cryptlen != vec->len || 2226fa353c99SEric Biggers req->iv != iv || 2227fa353c99SEric Biggers req->src != tsgls->src.sgl_ptr || 2228fa353c99SEric Biggers req->dst != tsgls->dst.sgl_ptr || 2229fa353c99SEric Biggers crypto_skcipher_reqtfm(req) != tfm || 2230fa353c99SEric Biggers req->base.complete != crypto_req_done || 2231fa353c99SEric Biggers req->base.flags != req_flags || 2232fa353c99SEric Biggers req->base.data != &wait) { 2233951d1332SEric Biggers pr_err("alg: skcipher: %s %s corrupted request struct on test vector %s, cfg=\"%s\"\n", 2234951d1332SEric Biggers driver, op, vec_name, cfg->name); 2235fa353c99SEric Biggers if (req->cryptlen != vec->len) 2236fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->cryptlen'\n"); 2237fa353c99SEric Biggers if (req->iv != iv) 2238fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->iv'\n"); 2239fa353c99SEric Biggers if (req->src != tsgls->src.sgl_ptr) 2240fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->src'\n"); 2241fa353c99SEric Biggers if (req->dst != tsgls->dst.sgl_ptr) 2242fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->dst'\n"); 2243fa353c99SEric Biggers if (crypto_skcipher_reqtfm(req) != tfm) 2244fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.tfm'\n"); 2245fa353c99SEric Biggers if (req->base.complete != crypto_req_done) 2246fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.complete'\n"); 2247fa353c99SEric Biggers if (req->base.flags != req_flags) 2248fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.flags'\n"); 2249fa353c99SEric Biggers if (req->base.data != &wait) 2250fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.data'\n"); 2251fa353c99SEric Biggers return -EINVAL; 2252fa353c99SEric Biggers } 2253fa353c99SEric Biggers if (is_test_sglist_corrupted(&tsgls->src)) { 2254951d1332SEric Biggers pr_err("alg: skcipher: %s %s corrupted src sgl on test vector %s, cfg=\"%s\"\n", 2255951d1332SEric Biggers driver, op, vec_name, cfg->name); 2256fa353c99SEric Biggers return -EINVAL; 2257fa353c99SEric Biggers } 2258fa353c99SEric Biggers if (tsgls->dst.sgl_ptr != tsgls->src.sgl && 2259fa353c99SEric Biggers is_test_sglist_corrupted(&tsgls->dst)) { 2260951d1332SEric Biggers pr_err("alg: skcipher: %s %s corrupted dst sgl on test vector %s, cfg=\"%s\"\n", 2261951d1332SEric Biggers driver, op, vec_name, cfg->name); 2262fa353c99SEric Biggers return -EINVAL; 2263fa353c99SEric Biggers } 2264fa353c99SEric Biggers 22655283a8eeSEric Biggers /* Check for success or failure */ 22665283a8eeSEric Biggers if (err) { 22675283a8eeSEric Biggers if (err == vec->crypt_error) 22685283a8eeSEric Biggers return 0; 2269951d1332SEric Biggers pr_err("alg: skcipher: %s %s failed on test vector %s; expected_error=%d, actual_error=%d, cfg=\"%s\"\n", 2270951d1332SEric Biggers driver, op, vec_name, vec->crypt_error, err, cfg->name); 22715283a8eeSEric Biggers return err; 22725283a8eeSEric Biggers } 22735283a8eeSEric Biggers if (vec->crypt_error) { 2274951d1332SEric Biggers pr_err("alg: skcipher: %s %s unexpectedly succeeded on test vector %s; expected_error=%d, cfg=\"%s\"\n", 2275951d1332SEric Biggers driver, op, vec_name, vec->crypt_error, cfg->name); 22765283a8eeSEric Biggers return -EINVAL; 22775283a8eeSEric Biggers } 22785283a8eeSEric Biggers 22794e7babbaSEric Biggers /* Check for the correct output (ciphertext or plaintext) */ 22804e7babbaSEric Biggers err = verify_correct_output(&tsgls->dst, enc ? vec->ctext : vec->ptext, 22814e7babbaSEric Biggers vec->len, 0, true); 22824e7babbaSEric Biggers if (err == -EOVERFLOW) { 2283951d1332SEric Biggers pr_err("alg: skcipher: %s %s overran dst buffer on test vector %s, cfg=\"%s\"\n", 2284951d1332SEric Biggers driver, op, vec_name, cfg->name); 22854e7babbaSEric Biggers return err; 22864e7babbaSEric Biggers } 22874e7babbaSEric Biggers if (err) { 2288951d1332SEric Biggers pr_err("alg: skcipher: %s %s test failed (wrong result) on test vector %s, cfg=\"%s\"\n", 2289951d1332SEric Biggers driver, op, vec_name, cfg->name); 22904e7babbaSEric Biggers return err; 22914e7babbaSEric Biggers } 229208d6af8cSJussi Kivilinna 22934e7babbaSEric Biggers /* If applicable, check that the algorithm generated the correct IV */ 22948efd972eSEric Biggers if (vec->iv_out && memcmp(iv, vec->iv_out, ivsize) != 0) { 2295951d1332SEric Biggers pr_err("alg: skcipher: %s %s test failed (wrong output IV) on test vector %s, cfg=\"%s\"\n", 2296951d1332SEric Biggers driver, op, vec_name, cfg->name); 22974e7babbaSEric Biggers hexdump(iv, ivsize); 22984e7babbaSEric Biggers return -EINVAL; 22993a338f20SJussi Kivilinna } 23003a338f20SJussi Kivilinna 23013a338f20SJussi Kivilinna return 0; 230208d6af8cSJussi Kivilinna } 230308d6af8cSJussi Kivilinna 23044e7babbaSEric Biggers static int test_skcipher_vec(const char *driver, int enc, 23054e7babbaSEric Biggers const struct cipher_testvec *vec, 23064e7babbaSEric Biggers unsigned int vec_num, 23074e7babbaSEric Biggers struct skcipher_request *req, 23084e7babbaSEric Biggers struct cipher_test_sglists *tsgls) 23094e7babbaSEric Biggers { 2310951d1332SEric Biggers char vec_name[16]; 23114e7babbaSEric Biggers unsigned int i; 23124e7babbaSEric Biggers int err; 23134e7babbaSEric Biggers 23144e7babbaSEric Biggers if (fips_enabled && vec->fips_skip) 23154e7babbaSEric Biggers return 0; 23164e7babbaSEric Biggers 2317951d1332SEric Biggers sprintf(vec_name, "%u", vec_num); 2318951d1332SEric Biggers 23194e7babbaSEric Biggers for (i = 0; i < ARRAY_SIZE(default_cipher_testvec_configs); i++) { 2320951d1332SEric Biggers err = test_skcipher_vec_cfg(driver, enc, vec, vec_name, 23214e7babbaSEric Biggers &default_cipher_testvec_configs[i], 23224e7babbaSEric Biggers req, tsgls); 23234e7babbaSEric Biggers if (err) 23244e7babbaSEric Biggers return err; 23254e7babbaSEric Biggers } 23264e7babbaSEric Biggers 23274e7babbaSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 23284e7babbaSEric Biggers if (!noextratests) { 23294e7babbaSEric Biggers struct testvec_config cfg; 23304e7babbaSEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 23314e7babbaSEric Biggers 23324e7babbaSEric Biggers for (i = 0; i < fuzz_iterations; i++) { 23334e7babbaSEric Biggers generate_random_testvec_config(&cfg, cfgname, 23344e7babbaSEric Biggers sizeof(cfgname)); 2335951d1332SEric Biggers err = test_skcipher_vec_cfg(driver, enc, vec, vec_name, 23364e7babbaSEric Biggers &cfg, req, tsgls); 23374e7babbaSEric Biggers if (err) 23384e7babbaSEric Biggers return err; 23394e7babbaSEric Biggers } 23404e7babbaSEric Biggers } 23414e7babbaSEric Biggers #endif 23424e7babbaSEric Biggers return 0; 23434e7babbaSEric Biggers } 23444e7babbaSEric Biggers 2345d435e10eSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 2346d435e10eSEric Biggers /* 2347d435e10eSEric Biggers * Generate a symmetric cipher test vector from the given implementation. 2348d435e10eSEric Biggers * Assumes the buffers in 'vec' were already allocated. 2349d435e10eSEric Biggers */ 2350d435e10eSEric Biggers static void generate_random_cipher_testvec(struct skcipher_request *req, 2351d435e10eSEric Biggers struct cipher_testvec *vec, 2352d435e10eSEric Biggers unsigned int maxdatasize, 2353d435e10eSEric Biggers char *name, size_t max_namelen) 2354d435e10eSEric Biggers { 2355d435e10eSEric Biggers struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 2356d435e10eSEric Biggers const unsigned int maxkeysize = tfm->keysize; 2357d435e10eSEric Biggers const unsigned int ivsize = crypto_skcipher_ivsize(tfm); 2358d435e10eSEric Biggers struct scatterlist src, dst; 2359d435e10eSEric Biggers u8 iv[MAX_IVLEN]; 2360d435e10eSEric Biggers DECLARE_CRYPTO_WAIT(wait); 2361d435e10eSEric Biggers 2362d435e10eSEric Biggers /* Key: length in [0, maxkeysize], but usually choose maxkeysize */ 2363d435e10eSEric Biggers vec->klen = maxkeysize; 2364d435e10eSEric Biggers if (prandom_u32() % 4 == 0) 2365d435e10eSEric Biggers vec->klen = prandom_u32() % (maxkeysize + 1); 2366d435e10eSEric Biggers generate_random_bytes((u8 *)vec->key, vec->klen); 2367d435e10eSEric Biggers vec->setkey_error = crypto_skcipher_setkey(tfm, vec->key, vec->klen); 2368d435e10eSEric Biggers 2369d435e10eSEric Biggers /* IV */ 2370d435e10eSEric Biggers generate_random_bytes((u8 *)vec->iv, ivsize); 2371d435e10eSEric Biggers 2372d435e10eSEric Biggers /* Plaintext */ 2373d435e10eSEric Biggers vec->len = generate_random_length(maxdatasize); 2374d435e10eSEric Biggers generate_random_bytes((u8 *)vec->ptext, vec->len); 2375d435e10eSEric Biggers 2376d435e10eSEric Biggers /* If the key couldn't be set, no need to continue to encrypt. */ 2377d435e10eSEric Biggers if (vec->setkey_error) 2378d435e10eSEric Biggers goto done; 2379d435e10eSEric Biggers 2380d435e10eSEric Biggers /* Ciphertext */ 2381d435e10eSEric Biggers sg_init_one(&src, vec->ptext, vec->len); 2382d435e10eSEric Biggers sg_init_one(&dst, vec->ctext, vec->len); 2383d435e10eSEric Biggers memcpy(iv, vec->iv, ivsize); 2384d435e10eSEric Biggers skcipher_request_set_callback(req, 0, crypto_req_done, &wait); 2385d435e10eSEric Biggers skcipher_request_set_crypt(req, &src, &dst, vec->len, iv); 2386d435e10eSEric Biggers vec->crypt_error = crypto_wait_req(crypto_skcipher_encrypt(req), &wait); 2387d435e10eSEric Biggers done: 2388d435e10eSEric Biggers snprintf(name, max_namelen, "\"random: len=%u klen=%u\"", 2389d435e10eSEric Biggers vec->len, vec->klen); 2390d435e10eSEric Biggers } 2391d435e10eSEric Biggers 2392d435e10eSEric Biggers /* 2393d435e10eSEric Biggers * Test the skcipher algorithm represented by @req against the corresponding 2394d435e10eSEric Biggers * generic implementation, if one is available. 2395d435e10eSEric Biggers */ 2396d435e10eSEric Biggers static int test_skcipher_vs_generic_impl(const char *driver, 2397d435e10eSEric Biggers const char *generic_driver, 2398d435e10eSEric Biggers struct skcipher_request *req, 2399d435e10eSEric Biggers struct cipher_test_sglists *tsgls) 2400d435e10eSEric Biggers { 2401d435e10eSEric Biggers struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 2402d435e10eSEric Biggers const unsigned int ivsize = crypto_skcipher_ivsize(tfm); 2403d435e10eSEric Biggers const unsigned int blocksize = crypto_skcipher_blocksize(tfm); 2404d435e10eSEric Biggers const unsigned int maxdatasize = (2 * PAGE_SIZE) - TESTMGR_POISON_LEN; 2405d435e10eSEric Biggers const char *algname = crypto_skcipher_alg(tfm)->base.cra_name; 2406d435e10eSEric Biggers char _generic_driver[CRYPTO_MAX_ALG_NAME]; 2407d435e10eSEric Biggers struct crypto_skcipher *generic_tfm = NULL; 2408d435e10eSEric Biggers struct skcipher_request *generic_req = NULL; 2409d435e10eSEric Biggers unsigned int i; 2410d435e10eSEric Biggers struct cipher_testvec vec = { 0 }; 2411d435e10eSEric Biggers char vec_name[64]; 2412d435e10eSEric Biggers struct testvec_config cfg; 2413d435e10eSEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 2414d435e10eSEric Biggers int err; 2415d435e10eSEric Biggers 2416d435e10eSEric Biggers if (noextratests) 2417d435e10eSEric Biggers return 0; 2418d435e10eSEric Biggers 2419d435e10eSEric Biggers /* Keywrap isn't supported here yet as it handles its IV differently. */ 2420d435e10eSEric Biggers if (strncmp(algname, "kw(", 3) == 0) 2421d435e10eSEric Biggers return 0; 2422d435e10eSEric Biggers 2423d435e10eSEric Biggers if (!generic_driver) { /* Use default naming convention? */ 2424d435e10eSEric Biggers err = build_generic_driver_name(algname, _generic_driver); 2425d435e10eSEric Biggers if (err) 2426d435e10eSEric Biggers return err; 2427d435e10eSEric Biggers generic_driver = _generic_driver; 2428d435e10eSEric Biggers } 2429d435e10eSEric Biggers 2430d435e10eSEric Biggers if (strcmp(generic_driver, driver) == 0) /* Already the generic impl? */ 2431d435e10eSEric Biggers return 0; 2432d435e10eSEric Biggers 2433d435e10eSEric Biggers generic_tfm = crypto_alloc_skcipher(generic_driver, 0, 0); 2434d435e10eSEric Biggers if (IS_ERR(generic_tfm)) { 2435d435e10eSEric Biggers err = PTR_ERR(generic_tfm); 2436d435e10eSEric Biggers if (err == -ENOENT) { 2437d435e10eSEric Biggers pr_warn("alg: skcipher: skipping comparison tests for %s because %s is unavailable\n", 2438d435e10eSEric Biggers driver, generic_driver); 2439d435e10eSEric Biggers return 0; 2440d435e10eSEric Biggers } 2441d435e10eSEric Biggers pr_err("alg: skcipher: error allocating %s (generic impl of %s): %d\n", 2442d435e10eSEric Biggers generic_driver, algname, err); 2443d435e10eSEric Biggers return err; 2444d435e10eSEric Biggers } 2445d435e10eSEric Biggers 2446d435e10eSEric Biggers generic_req = skcipher_request_alloc(generic_tfm, GFP_KERNEL); 2447d435e10eSEric Biggers if (!generic_req) { 2448d435e10eSEric Biggers err = -ENOMEM; 2449d435e10eSEric Biggers goto out; 2450d435e10eSEric Biggers } 2451d435e10eSEric Biggers 2452d435e10eSEric Biggers /* Check the algorithm properties for consistency. */ 2453d435e10eSEric Biggers 2454d435e10eSEric Biggers if (tfm->keysize != generic_tfm->keysize) { 2455d435e10eSEric Biggers pr_err("alg: skcipher: max keysize for %s (%u) doesn't match generic impl (%u)\n", 2456d435e10eSEric Biggers driver, tfm->keysize, generic_tfm->keysize); 2457d435e10eSEric Biggers err = -EINVAL; 2458d435e10eSEric Biggers goto out; 2459d435e10eSEric Biggers } 2460d435e10eSEric Biggers 2461d435e10eSEric Biggers if (ivsize != crypto_skcipher_ivsize(generic_tfm)) { 2462d435e10eSEric Biggers pr_err("alg: skcipher: ivsize for %s (%u) doesn't match generic impl (%u)\n", 2463d435e10eSEric Biggers driver, ivsize, crypto_skcipher_ivsize(generic_tfm)); 2464d435e10eSEric Biggers err = -EINVAL; 2465d435e10eSEric Biggers goto out; 2466d435e10eSEric Biggers } 2467d435e10eSEric Biggers 2468d435e10eSEric Biggers if (blocksize != crypto_skcipher_blocksize(generic_tfm)) { 2469d435e10eSEric Biggers pr_err("alg: skcipher: blocksize for %s (%u) doesn't match generic impl (%u)\n", 2470d435e10eSEric Biggers driver, blocksize, 2471d435e10eSEric Biggers crypto_skcipher_blocksize(generic_tfm)); 2472d435e10eSEric Biggers err = -EINVAL; 2473d435e10eSEric Biggers goto out; 2474d435e10eSEric Biggers } 2475d435e10eSEric Biggers 2476d435e10eSEric Biggers /* 2477d435e10eSEric Biggers * Now generate test vectors using the generic implementation, and test 2478d435e10eSEric Biggers * the other implementation against them. 2479d435e10eSEric Biggers */ 2480d435e10eSEric Biggers 2481d435e10eSEric Biggers vec.key = kmalloc(tfm->keysize, GFP_KERNEL); 2482d435e10eSEric Biggers vec.iv = kmalloc(ivsize, GFP_KERNEL); 2483d435e10eSEric Biggers vec.ptext = kmalloc(maxdatasize, GFP_KERNEL); 2484d435e10eSEric Biggers vec.ctext = kmalloc(maxdatasize, GFP_KERNEL); 2485d435e10eSEric Biggers if (!vec.key || !vec.iv || !vec.ptext || !vec.ctext) { 2486d435e10eSEric Biggers err = -ENOMEM; 2487d435e10eSEric Biggers goto out; 2488d435e10eSEric Biggers } 2489d435e10eSEric Biggers 2490d435e10eSEric Biggers for (i = 0; i < fuzz_iterations * 8; i++) { 2491d435e10eSEric Biggers generate_random_cipher_testvec(generic_req, &vec, maxdatasize, 2492d435e10eSEric Biggers vec_name, sizeof(vec_name)); 2493d435e10eSEric Biggers generate_random_testvec_config(&cfg, cfgname, sizeof(cfgname)); 2494d435e10eSEric Biggers 2495d435e10eSEric Biggers err = test_skcipher_vec_cfg(driver, ENCRYPT, &vec, vec_name, 2496d435e10eSEric Biggers &cfg, req, tsgls); 2497d435e10eSEric Biggers if (err) 2498d435e10eSEric Biggers goto out; 2499d435e10eSEric Biggers err = test_skcipher_vec_cfg(driver, DECRYPT, &vec, vec_name, 2500d435e10eSEric Biggers &cfg, req, tsgls); 2501d435e10eSEric Biggers if (err) 2502d435e10eSEric Biggers goto out; 2503d435e10eSEric Biggers cond_resched(); 2504d435e10eSEric Biggers } 2505d435e10eSEric Biggers err = 0; 2506d435e10eSEric Biggers out: 2507d435e10eSEric Biggers kfree(vec.key); 2508d435e10eSEric Biggers kfree(vec.iv); 2509d435e10eSEric Biggers kfree(vec.ptext); 2510d435e10eSEric Biggers kfree(vec.ctext); 2511d435e10eSEric Biggers crypto_free_skcipher(generic_tfm); 2512d435e10eSEric Biggers skcipher_request_free(generic_req); 2513d435e10eSEric Biggers return err; 2514d435e10eSEric Biggers } 2515d435e10eSEric Biggers #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 2516d435e10eSEric Biggers static int test_skcipher_vs_generic_impl(const char *driver, 2517d435e10eSEric Biggers const char *generic_driver, 2518d435e10eSEric Biggers struct skcipher_request *req, 2519d435e10eSEric Biggers struct cipher_test_sglists *tsgls) 2520d435e10eSEric Biggers { 2521d435e10eSEric Biggers return 0; 2522d435e10eSEric Biggers } 2523d435e10eSEric Biggers #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 2524d435e10eSEric Biggers 25254e7babbaSEric Biggers static int test_skcipher(const char *driver, int enc, 25264e7babbaSEric Biggers const struct cipher_test_suite *suite, 25274e7babbaSEric Biggers struct skcipher_request *req, 25284e7babbaSEric Biggers struct cipher_test_sglists *tsgls) 25294e7babbaSEric Biggers { 25304e7babbaSEric Biggers unsigned int i; 25314e7babbaSEric Biggers int err; 25324e7babbaSEric Biggers 25334e7babbaSEric Biggers for (i = 0; i < suite->count; i++) { 25344e7babbaSEric Biggers err = test_skcipher_vec(driver, enc, &suite->vecs[i], i, req, 25354e7babbaSEric Biggers tsgls); 25364e7babbaSEric Biggers if (err) 25374e7babbaSEric Biggers return err; 25384e7babbaSEric Biggers } 25394e7babbaSEric Biggers return 0; 25404e7babbaSEric Biggers } 25414e7babbaSEric Biggers 25424e7babbaSEric Biggers static int alg_test_skcipher(const struct alg_test_desc *desc, 25434e7babbaSEric Biggers const char *driver, u32 type, u32 mask) 25444e7babbaSEric Biggers { 25454e7babbaSEric Biggers const struct cipher_test_suite *suite = &desc->suite.cipher; 25464e7babbaSEric Biggers struct crypto_skcipher *tfm; 25474e7babbaSEric Biggers struct skcipher_request *req = NULL; 25484e7babbaSEric Biggers struct cipher_test_sglists *tsgls = NULL; 25494e7babbaSEric Biggers int err; 25504e7babbaSEric Biggers 25514e7babbaSEric Biggers if (suite->count <= 0) { 25524e7babbaSEric Biggers pr_err("alg: skcipher: empty test suite for %s\n", driver); 25534e7babbaSEric Biggers return -EINVAL; 25544e7babbaSEric Biggers } 25554e7babbaSEric Biggers 25564e7babbaSEric Biggers tfm = crypto_alloc_skcipher(driver, type, mask); 25574e7babbaSEric Biggers if (IS_ERR(tfm)) { 25584e7babbaSEric Biggers pr_err("alg: skcipher: failed to allocate transform for %s: %ld\n", 25594e7babbaSEric Biggers driver, PTR_ERR(tfm)); 25604e7babbaSEric Biggers return PTR_ERR(tfm); 25614e7babbaSEric Biggers } 25624e7babbaSEric Biggers 25634e7babbaSEric Biggers req = skcipher_request_alloc(tfm, GFP_KERNEL); 25644e7babbaSEric Biggers if (!req) { 25654e7babbaSEric Biggers pr_err("alg: skcipher: failed to allocate request for %s\n", 25664e7babbaSEric Biggers driver); 25674e7babbaSEric Biggers err = -ENOMEM; 25684e7babbaSEric Biggers goto out; 25694e7babbaSEric Biggers } 25704e7babbaSEric Biggers 25714e7babbaSEric Biggers tsgls = alloc_cipher_test_sglists(); 25724e7babbaSEric Biggers if (!tsgls) { 25734e7babbaSEric Biggers pr_err("alg: skcipher: failed to allocate test buffers for %s\n", 25744e7babbaSEric Biggers driver); 25754e7babbaSEric Biggers err = -ENOMEM; 25764e7babbaSEric Biggers goto out; 25774e7babbaSEric Biggers } 25784e7babbaSEric Biggers 25794e7babbaSEric Biggers err = test_skcipher(driver, ENCRYPT, suite, req, tsgls); 25804e7babbaSEric Biggers if (err) 25814e7babbaSEric Biggers goto out; 25824e7babbaSEric Biggers 25834e7babbaSEric Biggers err = test_skcipher(driver, DECRYPT, suite, req, tsgls); 2584d435e10eSEric Biggers if (err) 2585d435e10eSEric Biggers goto out; 2586d435e10eSEric Biggers 2587d435e10eSEric Biggers err = test_skcipher_vs_generic_impl(driver, desc->generic_driver, req, 2588d435e10eSEric Biggers tsgls); 25894e7babbaSEric Biggers out: 25904e7babbaSEric Biggers free_cipher_test_sglists(tsgls); 25914e7babbaSEric Biggers skcipher_request_free(req); 25924e7babbaSEric Biggers crypto_free_skcipher(tfm); 25934e7babbaSEric Biggers return err; 25944e7babbaSEric Biggers } 25954e7babbaSEric Biggers 2596b13b1e0cSEric Biggers static int test_comp(struct crypto_comp *tfm, 2597b13b1e0cSEric Biggers const struct comp_testvec *ctemplate, 2598b13b1e0cSEric Biggers const struct comp_testvec *dtemplate, 2599b13b1e0cSEric Biggers int ctcount, int dtcount) 2600da7f033dSHerbert Xu { 2601da7f033dSHerbert Xu const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm)); 260233607384SMahipal Challa char *output, *decomp_output; 2603da7f033dSHerbert Xu unsigned int i; 2604da7f033dSHerbert Xu int ret; 2605da7f033dSHerbert Xu 260633607384SMahipal Challa output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 260733607384SMahipal Challa if (!output) 260833607384SMahipal Challa return -ENOMEM; 260933607384SMahipal Challa 261033607384SMahipal Challa decomp_output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 261133607384SMahipal Challa if (!decomp_output) { 261233607384SMahipal Challa kfree(output); 261333607384SMahipal Challa return -ENOMEM; 261433607384SMahipal Challa } 261533607384SMahipal Challa 2616da7f033dSHerbert Xu for (i = 0; i < ctcount; i++) { 2617c79cf910SGeert Uytterhoeven int ilen; 2618c79cf910SGeert Uytterhoeven unsigned int dlen = COMP_BUF_SIZE; 2619da7f033dSHerbert Xu 262022a8118dSMichael Schupikov memset(output, 0, COMP_BUF_SIZE); 262122a8118dSMichael Schupikov memset(decomp_output, 0, COMP_BUF_SIZE); 2622da7f033dSHerbert Xu 2623da7f033dSHerbert Xu ilen = ctemplate[i].inlen; 2624da7f033dSHerbert Xu ret = crypto_comp_compress(tfm, ctemplate[i].input, 262533607384SMahipal Challa ilen, output, &dlen); 2626da7f033dSHerbert Xu if (ret) { 2627da7f033dSHerbert Xu printk(KERN_ERR "alg: comp: compression failed " 2628da7f033dSHerbert Xu "on test %d for %s: ret=%d\n", i + 1, algo, 2629da7f033dSHerbert Xu -ret); 2630da7f033dSHerbert Xu goto out; 2631da7f033dSHerbert Xu } 2632da7f033dSHerbert Xu 263333607384SMahipal Challa ilen = dlen; 263433607384SMahipal Challa dlen = COMP_BUF_SIZE; 263533607384SMahipal Challa ret = crypto_comp_decompress(tfm, output, 263633607384SMahipal Challa ilen, decomp_output, &dlen); 263733607384SMahipal Challa if (ret) { 263833607384SMahipal Challa pr_err("alg: comp: compression failed: decompress: on test %d for %s failed: ret=%d\n", 263933607384SMahipal Challa i + 1, algo, -ret); 264033607384SMahipal Challa goto out; 264133607384SMahipal Challa } 264233607384SMahipal Challa 264333607384SMahipal Challa if (dlen != ctemplate[i].inlen) { 2644b812eb00SGeert Uytterhoeven printk(KERN_ERR "alg: comp: Compression test %d " 2645b812eb00SGeert Uytterhoeven "failed for %s: output len = %d\n", i + 1, algo, 2646b812eb00SGeert Uytterhoeven dlen); 2647b812eb00SGeert Uytterhoeven ret = -EINVAL; 2648b812eb00SGeert Uytterhoeven goto out; 2649b812eb00SGeert Uytterhoeven } 2650b812eb00SGeert Uytterhoeven 265133607384SMahipal Challa if (memcmp(decomp_output, ctemplate[i].input, 265233607384SMahipal Challa ctemplate[i].inlen)) { 265333607384SMahipal Challa pr_err("alg: comp: compression failed: output differs: on test %d for %s\n", 265433607384SMahipal Challa i + 1, algo); 265533607384SMahipal Challa hexdump(decomp_output, dlen); 2656da7f033dSHerbert Xu ret = -EINVAL; 2657da7f033dSHerbert Xu goto out; 2658da7f033dSHerbert Xu } 2659da7f033dSHerbert Xu } 2660da7f033dSHerbert Xu 2661da7f033dSHerbert Xu for (i = 0; i < dtcount; i++) { 2662c79cf910SGeert Uytterhoeven int ilen; 2663c79cf910SGeert Uytterhoeven unsigned int dlen = COMP_BUF_SIZE; 2664da7f033dSHerbert Xu 266522a8118dSMichael Schupikov memset(decomp_output, 0, COMP_BUF_SIZE); 2666da7f033dSHerbert Xu 2667da7f033dSHerbert Xu ilen = dtemplate[i].inlen; 2668da7f033dSHerbert Xu ret = crypto_comp_decompress(tfm, dtemplate[i].input, 266933607384SMahipal Challa ilen, decomp_output, &dlen); 2670da7f033dSHerbert Xu if (ret) { 2671da7f033dSHerbert Xu printk(KERN_ERR "alg: comp: decompression failed " 2672da7f033dSHerbert Xu "on test %d for %s: ret=%d\n", i + 1, algo, 2673da7f033dSHerbert Xu -ret); 2674da7f033dSHerbert Xu goto out; 2675da7f033dSHerbert Xu } 2676da7f033dSHerbert Xu 2677b812eb00SGeert Uytterhoeven if (dlen != dtemplate[i].outlen) { 2678b812eb00SGeert Uytterhoeven printk(KERN_ERR "alg: comp: Decompression test %d " 2679b812eb00SGeert Uytterhoeven "failed for %s: output len = %d\n", i + 1, algo, 2680b812eb00SGeert Uytterhoeven dlen); 2681b812eb00SGeert Uytterhoeven ret = -EINVAL; 2682b812eb00SGeert Uytterhoeven goto out; 2683b812eb00SGeert Uytterhoeven } 2684b812eb00SGeert Uytterhoeven 268533607384SMahipal Challa if (memcmp(decomp_output, dtemplate[i].output, dlen)) { 2686da7f033dSHerbert Xu printk(KERN_ERR "alg: comp: Decompression test %d " 2687da7f033dSHerbert Xu "failed for %s\n", i + 1, algo); 268833607384SMahipal Challa hexdump(decomp_output, dlen); 2689da7f033dSHerbert Xu ret = -EINVAL; 2690da7f033dSHerbert Xu goto out; 2691da7f033dSHerbert Xu } 2692da7f033dSHerbert Xu } 2693da7f033dSHerbert Xu 2694da7f033dSHerbert Xu ret = 0; 2695da7f033dSHerbert Xu 2696da7f033dSHerbert Xu out: 269733607384SMahipal Challa kfree(decomp_output); 269833607384SMahipal Challa kfree(output); 2699da7f033dSHerbert Xu return ret; 2700da7f033dSHerbert Xu } 2701da7f033dSHerbert Xu 2702b13b1e0cSEric Biggers static int test_acomp(struct crypto_acomp *tfm, 2703b13b1e0cSEric Biggers const struct comp_testvec *ctemplate, 2704b13b1e0cSEric Biggers const struct comp_testvec *dtemplate, 2705b13b1e0cSEric Biggers int ctcount, int dtcount) 2706d7db7a88SGiovanni Cabiddu { 2707d7db7a88SGiovanni Cabiddu const char *algo = crypto_tfm_alg_driver_name(crypto_acomp_tfm(tfm)); 2708d7db7a88SGiovanni Cabiddu unsigned int i; 2709a9943a0aSGiovanni Cabiddu char *output, *decomp_out; 2710d7db7a88SGiovanni Cabiddu int ret; 2711d7db7a88SGiovanni Cabiddu struct scatterlist src, dst; 2712d7db7a88SGiovanni Cabiddu struct acomp_req *req; 27137f397136SGilad Ben-Yossef struct crypto_wait wait; 2714d7db7a88SGiovanni Cabiddu 2715eb095593SEric Biggers output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 2716eb095593SEric Biggers if (!output) 2717eb095593SEric Biggers return -ENOMEM; 2718eb095593SEric Biggers 2719a9943a0aSGiovanni Cabiddu decomp_out = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 2720a9943a0aSGiovanni Cabiddu if (!decomp_out) { 2721a9943a0aSGiovanni Cabiddu kfree(output); 2722a9943a0aSGiovanni Cabiddu return -ENOMEM; 2723a9943a0aSGiovanni Cabiddu } 2724a9943a0aSGiovanni Cabiddu 2725d7db7a88SGiovanni Cabiddu for (i = 0; i < ctcount; i++) { 2726d7db7a88SGiovanni Cabiddu unsigned int dlen = COMP_BUF_SIZE; 2727d7db7a88SGiovanni Cabiddu int ilen = ctemplate[i].inlen; 272802608e02SLaura Abbott void *input_vec; 2729d7db7a88SGiovanni Cabiddu 2730d2110224SEric Biggers input_vec = kmemdup(ctemplate[i].input, ilen, GFP_KERNEL); 273102608e02SLaura Abbott if (!input_vec) { 273202608e02SLaura Abbott ret = -ENOMEM; 273302608e02SLaura Abbott goto out; 273402608e02SLaura Abbott } 273502608e02SLaura Abbott 2736eb095593SEric Biggers memset(output, 0, dlen); 27377f397136SGilad Ben-Yossef crypto_init_wait(&wait); 273802608e02SLaura Abbott sg_init_one(&src, input_vec, ilen); 2739d7db7a88SGiovanni Cabiddu sg_init_one(&dst, output, dlen); 2740d7db7a88SGiovanni Cabiddu 2741d7db7a88SGiovanni Cabiddu req = acomp_request_alloc(tfm); 2742d7db7a88SGiovanni Cabiddu if (!req) { 2743d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: request alloc failed for %s\n", 2744d7db7a88SGiovanni Cabiddu algo); 274502608e02SLaura Abbott kfree(input_vec); 2746d7db7a88SGiovanni Cabiddu ret = -ENOMEM; 2747d7db7a88SGiovanni Cabiddu goto out; 2748d7db7a88SGiovanni Cabiddu } 2749d7db7a88SGiovanni Cabiddu 2750d7db7a88SGiovanni Cabiddu acomp_request_set_params(req, &src, &dst, ilen, dlen); 2751d7db7a88SGiovanni Cabiddu acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 27527f397136SGilad Ben-Yossef crypto_req_done, &wait); 2753d7db7a88SGiovanni Cabiddu 27547f397136SGilad Ben-Yossef ret = crypto_wait_req(crypto_acomp_compress(req), &wait); 2755d7db7a88SGiovanni Cabiddu if (ret) { 2756d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n", 2757d7db7a88SGiovanni Cabiddu i + 1, algo, -ret); 275802608e02SLaura Abbott kfree(input_vec); 2759d7db7a88SGiovanni Cabiddu acomp_request_free(req); 2760d7db7a88SGiovanni Cabiddu goto out; 2761d7db7a88SGiovanni Cabiddu } 2762d7db7a88SGiovanni Cabiddu 2763a9943a0aSGiovanni Cabiddu ilen = req->dlen; 2764a9943a0aSGiovanni Cabiddu dlen = COMP_BUF_SIZE; 2765a9943a0aSGiovanni Cabiddu sg_init_one(&src, output, ilen); 2766a9943a0aSGiovanni Cabiddu sg_init_one(&dst, decomp_out, dlen); 27677f397136SGilad Ben-Yossef crypto_init_wait(&wait); 2768a9943a0aSGiovanni Cabiddu acomp_request_set_params(req, &src, &dst, ilen, dlen); 2769a9943a0aSGiovanni Cabiddu 27707f397136SGilad Ben-Yossef ret = crypto_wait_req(crypto_acomp_decompress(req), &wait); 2771a9943a0aSGiovanni Cabiddu if (ret) { 2772a9943a0aSGiovanni Cabiddu pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n", 2773a9943a0aSGiovanni Cabiddu i + 1, algo, -ret); 2774a9943a0aSGiovanni Cabiddu kfree(input_vec); 2775a9943a0aSGiovanni Cabiddu acomp_request_free(req); 2776a9943a0aSGiovanni Cabiddu goto out; 2777a9943a0aSGiovanni Cabiddu } 2778a9943a0aSGiovanni Cabiddu 2779a9943a0aSGiovanni Cabiddu if (req->dlen != ctemplate[i].inlen) { 2780d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Compression test %d failed for %s: output len = %d\n", 2781d7db7a88SGiovanni Cabiddu i + 1, algo, req->dlen); 2782d7db7a88SGiovanni Cabiddu ret = -EINVAL; 278302608e02SLaura Abbott kfree(input_vec); 2784d7db7a88SGiovanni Cabiddu acomp_request_free(req); 2785d7db7a88SGiovanni Cabiddu goto out; 2786d7db7a88SGiovanni Cabiddu } 2787d7db7a88SGiovanni Cabiddu 2788a9943a0aSGiovanni Cabiddu if (memcmp(input_vec, decomp_out, req->dlen)) { 2789d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Compression test %d failed for %s\n", 2790d7db7a88SGiovanni Cabiddu i + 1, algo); 2791d7db7a88SGiovanni Cabiddu hexdump(output, req->dlen); 2792d7db7a88SGiovanni Cabiddu ret = -EINVAL; 279302608e02SLaura Abbott kfree(input_vec); 2794d7db7a88SGiovanni Cabiddu acomp_request_free(req); 2795d7db7a88SGiovanni Cabiddu goto out; 2796d7db7a88SGiovanni Cabiddu } 2797d7db7a88SGiovanni Cabiddu 279802608e02SLaura Abbott kfree(input_vec); 2799d7db7a88SGiovanni Cabiddu acomp_request_free(req); 2800d7db7a88SGiovanni Cabiddu } 2801d7db7a88SGiovanni Cabiddu 2802d7db7a88SGiovanni Cabiddu for (i = 0; i < dtcount; i++) { 2803d7db7a88SGiovanni Cabiddu unsigned int dlen = COMP_BUF_SIZE; 2804d7db7a88SGiovanni Cabiddu int ilen = dtemplate[i].inlen; 280502608e02SLaura Abbott void *input_vec; 2806d7db7a88SGiovanni Cabiddu 2807d2110224SEric Biggers input_vec = kmemdup(dtemplate[i].input, ilen, GFP_KERNEL); 280802608e02SLaura Abbott if (!input_vec) { 280902608e02SLaura Abbott ret = -ENOMEM; 281002608e02SLaura Abbott goto out; 281102608e02SLaura Abbott } 281202608e02SLaura Abbott 2813eb095593SEric Biggers memset(output, 0, dlen); 28147f397136SGilad Ben-Yossef crypto_init_wait(&wait); 281502608e02SLaura Abbott sg_init_one(&src, input_vec, ilen); 2816d7db7a88SGiovanni Cabiddu sg_init_one(&dst, output, dlen); 2817d7db7a88SGiovanni Cabiddu 2818d7db7a88SGiovanni Cabiddu req = acomp_request_alloc(tfm); 2819d7db7a88SGiovanni Cabiddu if (!req) { 2820d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: request alloc failed for %s\n", 2821d7db7a88SGiovanni Cabiddu algo); 282202608e02SLaura Abbott kfree(input_vec); 2823d7db7a88SGiovanni Cabiddu ret = -ENOMEM; 2824d7db7a88SGiovanni Cabiddu goto out; 2825d7db7a88SGiovanni Cabiddu } 2826d7db7a88SGiovanni Cabiddu 2827d7db7a88SGiovanni Cabiddu acomp_request_set_params(req, &src, &dst, ilen, dlen); 2828d7db7a88SGiovanni Cabiddu acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 28297f397136SGilad Ben-Yossef crypto_req_done, &wait); 2830d7db7a88SGiovanni Cabiddu 28317f397136SGilad Ben-Yossef ret = crypto_wait_req(crypto_acomp_decompress(req), &wait); 2832d7db7a88SGiovanni Cabiddu if (ret) { 2833d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: decompression failed on test %d for %s: ret=%d\n", 2834d7db7a88SGiovanni Cabiddu i + 1, algo, -ret); 283502608e02SLaura Abbott kfree(input_vec); 2836d7db7a88SGiovanni Cabiddu acomp_request_free(req); 2837d7db7a88SGiovanni Cabiddu goto out; 2838d7db7a88SGiovanni Cabiddu } 2839d7db7a88SGiovanni Cabiddu 2840d7db7a88SGiovanni Cabiddu if (req->dlen != dtemplate[i].outlen) { 2841d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Decompression test %d failed for %s: output len = %d\n", 2842d7db7a88SGiovanni Cabiddu i + 1, algo, req->dlen); 2843d7db7a88SGiovanni Cabiddu ret = -EINVAL; 284402608e02SLaura Abbott kfree(input_vec); 2845d7db7a88SGiovanni Cabiddu acomp_request_free(req); 2846d7db7a88SGiovanni Cabiddu goto out; 2847d7db7a88SGiovanni Cabiddu } 2848d7db7a88SGiovanni Cabiddu 2849d7db7a88SGiovanni Cabiddu if (memcmp(output, dtemplate[i].output, req->dlen)) { 2850d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Decompression test %d failed for %s\n", 2851d7db7a88SGiovanni Cabiddu i + 1, algo); 2852d7db7a88SGiovanni Cabiddu hexdump(output, req->dlen); 2853d7db7a88SGiovanni Cabiddu ret = -EINVAL; 285402608e02SLaura Abbott kfree(input_vec); 2855d7db7a88SGiovanni Cabiddu acomp_request_free(req); 2856d7db7a88SGiovanni Cabiddu goto out; 2857d7db7a88SGiovanni Cabiddu } 2858d7db7a88SGiovanni Cabiddu 285902608e02SLaura Abbott kfree(input_vec); 2860d7db7a88SGiovanni Cabiddu acomp_request_free(req); 2861d7db7a88SGiovanni Cabiddu } 2862d7db7a88SGiovanni Cabiddu 2863d7db7a88SGiovanni Cabiddu ret = 0; 2864d7db7a88SGiovanni Cabiddu 2865d7db7a88SGiovanni Cabiddu out: 2866a9943a0aSGiovanni Cabiddu kfree(decomp_out); 2867eb095593SEric Biggers kfree(output); 2868d7db7a88SGiovanni Cabiddu return ret; 2869d7db7a88SGiovanni Cabiddu } 2870d7db7a88SGiovanni Cabiddu 2871b13b1e0cSEric Biggers static int test_cprng(struct crypto_rng *tfm, 2872b13b1e0cSEric Biggers const struct cprng_testvec *template, 28737647d6ceSJarod Wilson unsigned int tcount) 28747647d6ceSJarod Wilson { 28757647d6ceSJarod Wilson const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm)); 2876fa4ef8a6SFelipe Contreras int err = 0, i, j, seedsize; 28777647d6ceSJarod Wilson u8 *seed; 28787647d6ceSJarod Wilson char result[32]; 28797647d6ceSJarod Wilson 28807647d6ceSJarod Wilson seedsize = crypto_rng_seedsize(tfm); 28817647d6ceSJarod Wilson 28827647d6ceSJarod Wilson seed = kmalloc(seedsize, GFP_KERNEL); 28837647d6ceSJarod Wilson if (!seed) { 28847647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to allocate seed space " 28857647d6ceSJarod Wilson "for %s\n", algo); 28867647d6ceSJarod Wilson return -ENOMEM; 28877647d6ceSJarod Wilson } 28887647d6ceSJarod Wilson 28897647d6ceSJarod Wilson for (i = 0; i < tcount; i++) { 28907647d6ceSJarod Wilson memset(result, 0, 32); 28917647d6ceSJarod Wilson 28927647d6ceSJarod Wilson memcpy(seed, template[i].v, template[i].vlen); 28937647d6ceSJarod Wilson memcpy(seed + template[i].vlen, template[i].key, 28947647d6ceSJarod Wilson template[i].klen); 28957647d6ceSJarod Wilson memcpy(seed + template[i].vlen + template[i].klen, 28967647d6ceSJarod Wilson template[i].dt, template[i].dtlen); 28977647d6ceSJarod Wilson 28987647d6ceSJarod Wilson err = crypto_rng_reset(tfm, seed, seedsize); 28997647d6ceSJarod Wilson if (err) { 29007647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to reset rng " 29017647d6ceSJarod Wilson "for %s\n", algo); 29027647d6ceSJarod Wilson goto out; 29037647d6ceSJarod Wilson } 29047647d6ceSJarod Wilson 29057647d6ceSJarod Wilson for (j = 0; j < template[i].loops; j++) { 29067647d6ceSJarod Wilson err = crypto_rng_get_bytes(tfm, result, 29077647d6ceSJarod Wilson template[i].rlen); 290819e60e13SStephan Mueller if (err < 0) { 29097647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to obtain " 29107647d6ceSJarod Wilson "the correct amount of random data for " 291119e60e13SStephan Mueller "%s (requested %d)\n", algo, 291219e60e13SStephan Mueller template[i].rlen); 29137647d6ceSJarod Wilson goto out; 29147647d6ceSJarod Wilson } 29157647d6ceSJarod Wilson } 29167647d6ceSJarod Wilson 29177647d6ceSJarod Wilson err = memcmp(result, template[i].result, 29187647d6ceSJarod Wilson template[i].rlen); 29197647d6ceSJarod Wilson if (err) { 29207647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Test %d failed for %s\n", 29217647d6ceSJarod Wilson i, algo); 29227647d6ceSJarod Wilson hexdump(result, template[i].rlen); 29237647d6ceSJarod Wilson err = -EINVAL; 29247647d6ceSJarod Wilson goto out; 29257647d6ceSJarod Wilson } 29267647d6ceSJarod Wilson } 29277647d6ceSJarod Wilson 29287647d6ceSJarod Wilson out: 29297647d6ceSJarod Wilson kfree(seed); 29307647d6ceSJarod Wilson return err; 29317647d6ceSJarod Wilson } 29327647d6ceSJarod Wilson 2933da7f033dSHerbert Xu static int alg_test_cipher(const struct alg_test_desc *desc, 2934da7f033dSHerbert Xu const char *driver, u32 type, u32 mask) 2935da7f033dSHerbert Xu { 293692a4c9feSEric Biggers const struct cipher_test_suite *suite = &desc->suite.cipher; 29371aa4ecd9SHerbert Xu struct crypto_cipher *tfm; 293892a4c9feSEric Biggers int err; 2939da7f033dSHerbert Xu 2940eed93e0cSHerbert Xu tfm = crypto_alloc_cipher(driver, type, mask); 2941da7f033dSHerbert Xu if (IS_ERR(tfm)) { 2942da7f033dSHerbert Xu printk(KERN_ERR "alg: cipher: Failed to load transform for " 2943da7f033dSHerbert Xu "%s: %ld\n", driver, PTR_ERR(tfm)); 2944da7f033dSHerbert Xu return PTR_ERR(tfm); 2945da7f033dSHerbert Xu } 2946da7f033dSHerbert Xu 294792a4c9feSEric Biggers err = test_cipher(tfm, ENCRYPT, suite->vecs, suite->count); 294892a4c9feSEric Biggers if (!err) 294992a4c9feSEric Biggers err = test_cipher(tfm, DECRYPT, suite->vecs, suite->count); 2950da7f033dSHerbert Xu 29511aa4ecd9SHerbert Xu crypto_free_cipher(tfm); 29521aa4ecd9SHerbert Xu return err; 29531aa4ecd9SHerbert Xu } 29541aa4ecd9SHerbert Xu 2955da7f033dSHerbert Xu static int alg_test_comp(const struct alg_test_desc *desc, const char *driver, 2956da7f033dSHerbert Xu u32 type, u32 mask) 2957da7f033dSHerbert Xu { 2958d7db7a88SGiovanni Cabiddu struct crypto_comp *comp; 2959d7db7a88SGiovanni Cabiddu struct crypto_acomp *acomp; 2960da7f033dSHerbert Xu int err; 2961d7db7a88SGiovanni Cabiddu u32 algo_type = type & CRYPTO_ALG_TYPE_ACOMPRESS_MASK; 2962da7f033dSHerbert Xu 2963d7db7a88SGiovanni Cabiddu if (algo_type == CRYPTO_ALG_TYPE_ACOMPRESS) { 2964d7db7a88SGiovanni Cabiddu acomp = crypto_alloc_acomp(driver, type, mask); 2965d7db7a88SGiovanni Cabiddu if (IS_ERR(acomp)) { 2966d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Failed to load transform for %s: %ld\n", 2967d7db7a88SGiovanni Cabiddu driver, PTR_ERR(acomp)); 2968d7db7a88SGiovanni Cabiddu return PTR_ERR(acomp); 2969d7db7a88SGiovanni Cabiddu } 2970d7db7a88SGiovanni Cabiddu err = test_acomp(acomp, desc->suite.comp.comp.vecs, 2971d7db7a88SGiovanni Cabiddu desc->suite.comp.decomp.vecs, 2972d7db7a88SGiovanni Cabiddu desc->suite.comp.comp.count, 2973d7db7a88SGiovanni Cabiddu desc->suite.comp.decomp.count); 2974d7db7a88SGiovanni Cabiddu crypto_free_acomp(acomp); 2975d7db7a88SGiovanni Cabiddu } else { 2976d7db7a88SGiovanni Cabiddu comp = crypto_alloc_comp(driver, type, mask); 2977d7db7a88SGiovanni Cabiddu if (IS_ERR(comp)) { 2978d7db7a88SGiovanni Cabiddu pr_err("alg: comp: Failed to load transform for %s: %ld\n", 2979d7db7a88SGiovanni Cabiddu driver, PTR_ERR(comp)); 2980d7db7a88SGiovanni Cabiddu return PTR_ERR(comp); 2981da7f033dSHerbert Xu } 2982da7f033dSHerbert Xu 2983d7db7a88SGiovanni Cabiddu err = test_comp(comp, desc->suite.comp.comp.vecs, 2984da7f033dSHerbert Xu desc->suite.comp.decomp.vecs, 2985da7f033dSHerbert Xu desc->suite.comp.comp.count, 2986da7f033dSHerbert Xu desc->suite.comp.decomp.count); 2987da7f033dSHerbert Xu 2988d7db7a88SGiovanni Cabiddu crypto_free_comp(comp); 2989d7db7a88SGiovanni Cabiddu } 2990da7f033dSHerbert Xu return err; 2991da7f033dSHerbert Xu } 2992da7f033dSHerbert Xu 29938e3ee85eSHerbert Xu static int alg_test_crc32c(const struct alg_test_desc *desc, 29948e3ee85eSHerbert Xu const char *driver, u32 type, u32 mask) 29958e3ee85eSHerbert Xu { 29968e3ee85eSHerbert Xu struct crypto_shash *tfm; 2997cb9dde88SEric Biggers __le32 val; 29988e3ee85eSHerbert Xu int err; 29998e3ee85eSHerbert Xu 30008e3ee85eSHerbert Xu err = alg_test_hash(desc, driver, type, mask); 30018e3ee85eSHerbert Xu if (err) 3002eb5e6730SEric Biggers return err; 30038e3ee85eSHerbert Xu 3004eed93e0cSHerbert Xu tfm = crypto_alloc_shash(driver, type, mask); 30058e3ee85eSHerbert Xu if (IS_ERR(tfm)) { 3006eb5e6730SEric Biggers if (PTR_ERR(tfm) == -ENOENT) { 3007eb5e6730SEric Biggers /* 3008eb5e6730SEric Biggers * This crc32c implementation is only available through 3009eb5e6730SEric Biggers * ahash API, not the shash API, so the remaining part 3010eb5e6730SEric Biggers * of the test is not applicable to it. 3011eb5e6730SEric Biggers */ 3012eb5e6730SEric Biggers return 0; 3013eb5e6730SEric Biggers } 30148e3ee85eSHerbert Xu printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: " 30158e3ee85eSHerbert Xu "%ld\n", driver, PTR_ERR(tfm)); 3016eb5e6730SEric Biggers return PTR_ERR(tfm); 30178e3ee85eSHerbert Xu } 30188e3ee85eSHerbert Xu 30198e3ee85eSHerbert Xu do { 30204c5c3024SJan-Simon Möller SHASH_DESC_ON_STACK(shash, tfm); 30214c5c3024SJan-Simon Möller u32 *ctx = (u32 *)shash_desc_ctx(shash); 30228e3ee85eSHerbert Xu 30234c5c3024SJan-Simon Möller shash->tfm = tfm; 30248e3ee85eSHerbert Xu 3025cb9dde88SEric Biggers *ctx = 420553207; 30264c5c3024SJan-Simon Möller err = crypto_shash_final(shash, (u8 *)&val); 30278e3ee85eSHerbert Xu if (err) { 30288e3ee85eSHerbert Xu printk(KERN_ERR "alg: crc32c: Operation failed for " 30298e3ee85eSHerbert Xu "%s: %d\n", driver, err); 30308e3ee85eSHerbert Xu break; 30318e3ee85eSHerbert Xu } 30328e3ee85eSHerbert Xu 3033cb9dde88SEric Biggers if (val != cpu_to_le32(~420553207)) { 3034cb9dde88SEric Biggers pr_err("alg: crc32c: Test failed for %s: %u\n", 3035cb9dde88SEric Biggers driver, le32_to_cpu(val)); 30368e3ee85eSHerbert Xu err = -EINVAL; 30378e3ee85eSHerbert Xu } 30388e3ee85eSHerbert Xu } while (0); 30398e3ee85eSHerbert Xu 30408e3ee85eSHerbert Xu crypto_free_shash(tfm); 30418e3ee85eSHerbert Xu 30428e3ee85eSHerbert Xu return err; 30438e3ee85eSHerbert Xu } 30448e3ee85eSHerbert Xu 30457647d6ceSJarod Wilson static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver, 30467647d6ceSJarod Wilson u32 type, u32 mask) 30477647d6ceSJarod Wilson { 30487647d6ceSJarod Wilson struct crypto_rng *rng; 30497647d6ceSJarod Wilson int err; 30507647d6ceSJarod Wilson 3051eed93e0cSHerbert Xu rng = crypto_alloc_rng(driver, type, mask); 30527647d6ceSJarod Wilson if (IS_ERR(rng)) { 30537647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to load transform for %s: " 30547647d6ceSJarod Wilson "%ld\n", driver, PTR_ERR(rng)); 30557647d6ceSJarod Wilson return PTR_ERR(rng); 30567647d6ceSJarod Wilson } 30577647d6ceSJarod Wilson 30587647d6ceSJarod Wilson err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count); 30597647d6ceSJarod Wilson 30607647d6ceSJarod Wilson crypto_free_rng(rng); 30617647d6ceSJarod Wilson 30627647d6ceSJarod Wilson return err; 30637647d6ceSJarod Wilson } 30647647d6ceSJarod Wilson 306564d1cdfbSStephan Mueller 3066b13b1e0cSEric Biggers static int drbg_cavs_test(const struct drbg_testvec *test, int pr, 306764d1cdfbSStephan Mueller const char *driver, u32 type, u32 mask) 306864d1cdfbSStephan Mueller { 306964d1cdfbSStephan Mueller int ret = -EAGAIN; 307064d1cdfbSStephan Mueller struct crypto_rng *drng; 307164d1cdfbSStephan Mueller struct drbg_test_data test_data; 307264d1cdfbSStephan Mueller struct drbg_string addtl, pers, testentropy; 307364d1cdfbSStephan Mueller unsigned char *buf = kzalloc(test->expectedlen, GFP_KERNEL); 307464d1cdfbSStephan Mueller 307564d1cdfbSStephan Mueller if (!buf) 307664d1cdfbSStephan Mueller return -ENOMEM; 307764d1cdfbSStephan Mueller 3078eed93e0cSHerbert Xu drng = crypto_alloc_rng(driver, type, mask); 307964d1cdfbSStephan Mueller if (IS_ERR(drng)) { 308064d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: could not allocate DRNG handle for " 308164d1cdfbSStephan Mueller "%s\n", driver); 308264d1cdfbSStephan Mueller kzfree(buf); 308364d1cdfbSStephan Mueller return -ENOMEM; 308464d1cdfbSStephan Mueller } 308564d1cdfbSStephan Mueller 308664d1cdfbSStephan Mueller test_data.testentropy = &testentropy; 308764d1cdfbSStephan Mueller drbg_string_fill(&testentropy, test->entropy, test->entropylen); 308864d1cdfbSStephan Mueller drbg_string_fill(&pers, test->pers, test->perslen); 308964d1cdfbSStephan Mueller ret = crypto_drbg_reset_test(drng, &pers, &test_data); 309064d1cdfbSStephan Mueller if (ret) { 309164d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: Failed to reset rng\n"); 309264d1cdfbSStephan Mueller goto outbuf; 309364d1cdfbSStephan Mueller } 309464d1cdfbSStephan Mueller 309564d1cdfbSStephan Mueller drbg_string_fill(&addtl, test->addtla, test->addtllen); 309664d1cdfbSStephan Mueller if (pr) { 309764d1cdfbSStephan Mueller drbg_string_fill(&testentropy, test->entpra, test->entprlen); 309864d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl_test(drng, 309964d1cdfbSStephan Mueller buf, test->expectedlen, &addtl, &test_data); 310064d1cdfbSStephan Mueller } else { 310164d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl(drng, 310264d1cdfbSStephan Mueller buf, test->expectedlen, &addtl); 310364d1cdfbSStephan Mueller } 310419e60e13SStephan Mueller if (ret < 0) { 310564d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: could not obtain random data for " 310664d1cdfbSStephan Mueller "driver %s\n", driver); 310764d1cdfbSStephan Mueller goto outbuf; 310864d1cdfbSStephan Mueller } 310964d1cdfbSStephan Mueller 311064d1cdfbSStephan Mueller drbg_string_fill(&addtl, test->addtlb, test->addtllen); 311164d1cdfbSStephan Mueller if (pr) { 311264d1cdfbSStephan Mueller drbg_string_fill(&testentropy, test->entprb, test->entprlen); 311364d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl_test(drng, 311464d1cdfbSStephan Mueller buf, test->expectedlen, &addtl, &test_data); 311564d1cdfbSStephan Mueller } else { 311664d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl(drng, 311764d1cdfbSStephan Mueller buf, test->expectedlen, &addtl); 311864d1cdfbSStephan Mueller } 311919e60e13SStephan Mueller if (ret < 0) { 312064d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: could not obtain random data for " 312164d1cdfbSStephan Mueller "driver %s\n", driver); 312264d1cdfbSStephan Mueller goto outbuf; 312364d1cdfbSStephan Mueller } 312464d1cdfbSStephan Mueller 312564d1cdfbSStephan Mueller ret = memcmp(test->expected, buf, test->expectedlen); 312664d1cdfbSStephan Mueller 312764d1cdfbSStephan Mueller outbuf: 312864d1cdfbSStephan Mueller crypto_free_rng(drng); 312964d1cdfbSStephan Mueller kzfree(buf); 313064d1cdfbSStephan Mueller return ret; 313164d1cdfbSStephan Mueller } 313264d1cdfbSStephan Mueller 313364d1cdfbSStephan Mueller 313464d1cdfbSStephan Mueller static int alg_test_drbg(const struct alg_test_desc *desc, const char *driver, 313564d1cdfbSStephan Mueller u32 type, u32 mask) 313664d1cdfbSStephan Mueller { 313764d1cdfbSStephan Mueller int err = 0; 313864d1cdfbSStephan Mueller int pr = 0; 313964d1cdfbSStephan Mueller int i = 0; 3140b13b1e0cSEric Biggers const struct drbg_testvec *template = desc->suite.drbg.vecs; 314164d1cdfbSStephan Mueller unsigned int tcount = desc->suite.drbg.count; 314264d1cdfbSStephan Mueller 314364d1cdfbSStephan Mueller if (0 == memcmp(driver, "drbg_pr_", 8)) 314464d1cdfbSStephan Mueller pr = 1; 314564d1cdfbSStephan Mueller 314664d1cdfbSStephan Mueller for (i = 0; i < tcount; i++) { 314764d1cdfbSStephan Mueller err = drbg_cavs_test(&template[i], pr, driver, type, mask); 314864d1cdfbSStephan Mueller if (err) { 314964d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: Test %d failed for %s\n", 315064d1cdfbSStephan Mueller i, driver); 315164d1cdfbSStephan Mueller err = -EINVAL; 315264d1cdfbSStephan Mueller break; 315364d1cdfbSStephan Mueller } 315464d1cdfbSStephan Mueller } 315564d1cdfbSStephan Mueller return err; 315664d1cdfbSStephan Mueller 315764d1cdfbSStephan Mueller } 315864d1cdfbSStephan Mueller 3159b13b1e0cSEric Biggers static int do_test_kpp(struct crypto_kpp *tfm, const struct kpp_testvec *vec, 3160802c7f1cSSalvatore Benedetto const char *alg) 3161802c7f1cSSalvatore Benedetto { 3162802c7f1cSSalvatore Benedetto struct kpp_request *req; 3163802c7f1cSSalvatore Benedetto void *input_buf = NULL; 3164802c7f1cSSalvatore Benedetto void *output_buf = NULL; 316547d3fd39STudor-Dan Ambarus void *a_public = NULL; 316647d3fd39STudor-Dan Ambarus void *a_ss = NULL; 316747d3fd39STudor-Dan Ambarus void *shared_secret = NULL; 31687f397136SGilad Ben-Yossef struct crypto_wait wait; 3169802c7f1cSSalvatore Benedetto unsigned int out_len_max; 3170802c7f1cSSalvatore Benedetto int err = -ENOMEM; 3171802c7f1cSSalvatore Benedetto struct scatterlist src, dst; 3172802c7f1cSSalvatore Benedetto 3173802c7f1cSSalvatore Benedetto req = kpp_request_alloc(tfm, GFP_KERNEL); 3174802c7f1cSSalvatore Benedetto if (!req) 3175802c7f1cSSalvatore Benedetto return err; 3176802c7f1cSSalvatore Benedetto 31777f397136SGilad Ben-Yossef crypto_init_wait(&wait); 3178802c7f1cSSalvatore Benedetto 3179802c7f1cSSalvatore Benedetto err = crypto_kpp_set_secret(tfm, vec->secret, vec->secret_size); 3180802c7f1cSSalvatore Benedetto if (err < 0) 3181802c7f1cSSalvatore Benedetto goto free_req; 3182802c7f1cSSalvatore Benedetto 3183802c7f1cSSalvatore Benedetto out_len_max = crypto_kpp_maxsize(tfm); 3184802c7f1cSSalvatore Benedetto output_buf = kzalloc(out_len_max, GFP_KERNEL); 3185802c7f1cSSalvatore Benedetto if (!output_buf) { 3186802c7f1cSSalvatore Benedetto err = -ENOMEM; 3187802c7f1cSSalvatore Benedetto goto free_req; 3188802c7f1cSSalvatore Benedetto } 3189802c7f1cSSalvatore Benedetto 3190802c7f1cSSalvatore Benedetto /* Use appropriate parameter as base */ 3191802c7f1cSSalvatore Benedetto kpp_request_set_input(req, NULL, 0); 3192802c7f1cSSalvatore Benedetto sg_init_one(&dst, output_buf, out_len_max); 3193802c7f1cSSalvatore Benedetto kpp_request_set_output(req, &dst, out_len_max); 3194802c7f1cSSalvatore Benedetto kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 31957f397136SGilad Ben-Yossef crypto_req_done, &wait); 3196802c7f1cSSalvatore Benedetto 319747d3fd39STudor-Dan Ambarus /* Compute party A's public key */ 31987f397136SGilad Ben-Yossef err = crypto_wait_req(crypto_kpp_generate_public_key(req), &wait); 3199802c7f1cSSalvatore Benedetto if (err) { 320047d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party A: generate public key test failed. err %d\n", 3201802c7f1cSSalvatore Benedetto alg, err); 3202802c7f1cSSalvatore Benedetto goto free_output; 3203802c7f1cSSalvatore Benedetto } 320447d3fd39STudor-Dan Ambarus 320547d3fd39STudor-Dan Ambarus if (vec->genkey) { 320647d3fd39STudor-Dan Ambarus /* Save party A's public key */ 3207e3d90e52SChristopher Diaz Riveros a_public = kmemdup(sg_virt(req->dst), out_len_max, GFP_KERNEL); 320847d3fd39STudor-Dan Ambarus if (!a_public) { 320947d3fd39STudor-Dan Ambarus err = -ENOMEM; 321047d3fd39STudor-Dan Ambarus goto free_output; 321147d3fd39STudor-Dan Ambarus } 321247d3fd39STudor-Dan Ambarus } else { 3213802c7f1cSSalvatore Benedetto /* Verify calculated public key */ 3214802c7f1cSSalvatore Benedetto if (memcmp(vec->expected_a_public, sg_virt(req->dst), 3215802c7f1cSSalvatore Benedetto vec->expected_a_public_size)) { 321647d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party A: generate public key test failed. Invalid output\n", 3217802c7f1cSSalvatore Benedetto alg); 3218802c7f1cSSalvatore Benedetto err = -EINVAL; 3219802c7f1cSSalvatore Benedetto goto free_output; 3220802c7f1cSSalvatore Benedetto } 322147d3fd39STudor-Dan Ambarus } 3222802c7f1cSSalvatore Benedetto 3223802c7f1cSSalvatore Benedetto /* Calculate shared secret key by using counter part (b) public key. */ 3224e3d90e52SChristopher Diaz Riveros input_buf = kmemdup(vec->b_public, vec->b_public_size, GFP_KERNEL); 3225802c7f1cSSalvatore Benedetto if (!input_buf) { 3226802c7f1cSSalvatore Benedetto err = -ENOMEM; 3227802c7f1cSSalvatore Benedetto goto free_output; 3228802c7f1cSSalvatore Benedetto } 3229802c7f1cSSalvatore Benedetto 3230802c7f1cSSalvatore Benedetto sg_init_one(&src, input_buf, vec->b_public_size); 3231802c7f1cSSalvatore Benedetto sg_init_one(&dst, output_buf, out_len_max); 3232802c7f1cSSalvatore Benedetto kpp_request_set_input(req, &src, vec->b_public_size); 3233802c7f1cSSalvatore Benedetto kpp_request_set_output(req, &dst, out_len_max); 3234802c7f1cSSalvatore Benedetto kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 32357f397136SGilad Ben-Yossef crypto_req_done, &wait); 32367f397136SGilad Ben-Yossef err = crypto_wait_req(crypto_kpp_compute_shared_secret(req), &wait); 3237802c7f1cSSalvatore Benedetto if (err) { 323847d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party A: compute shared secret test failed. err %d\n", 3239802c7f1cSSalvatore Benedetto alg, err); 3240802c7f1cSSalvatore Benedetto goto free_all; 3241802c7f1cSSalvatore Benedetto } 324247d3fd39STudor-Dan Ambarus 324347d3fd39STudor-Dan Ambarus if (vec->genkey) { 324447d3fd39STudor-Dan Ambarus /* Save the shared secret obtained by party A */ 3245e3d90e52SChristopher Diaz Riveros a_ss = kmemdup(sg_virt(req->dst), vec->expected_ss_size, GFP_KERNEL); 324647d3fd39STudor-Dan Ambarus if (!a_ss) { 324747d3fd39STudor-Dan Ambarus err = -ENOMEM; 324847d3fd39STudor-Dan Ambarus goto free_all; 324947d3fd39STudor-Dan Ambarus } 325047d3fd39STudor-Dan Ambarus 325147d3fd39STudor-Dan Ambarus /* 325247d3fd39STudor-Dan Ambarus * Calculate party B's shared secret by using party A's 325347d3fd39STudor-Dan Ambarus * public key. 325447d3fd39STudor-Dan Ambarus */ 325547d3fd39STudor-Dan Ambarus err = crypto_kpp_set_secret(tfm, vec->b_secret, 325647d3fd39STudor-Dan Ambarus vec->b_secret_size); 325747d3fd39STudor-Dan Ambarus if (err < 0) 325847d3fd39STudor-Dan Ambarus goto free_all; 325947d3fd39STudor-Dan Ambarus 326047d3fd39STudor-Dan Ambarus sg_init_one(&src, a_public, vec->expected_a_public_size); 326147d3fd39STudor-Dan Ambarus sg_init_one(&dst, output_buf, out_len_max); 326247d3fd39STudor-Dan Ambarus kpp_request_set_input(req, &src, vec->expected_a_public_size); 326347d3fd39STudor-Dan Ambarus kpp_request_set_output(req, &dst, out_len_max); 326447d3fd39STudor-Dan Ambarus kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 32657f397136SGilad Ben-Yossef crypto_req_done, &wait); 32667f397136SGilad Ben-Yossef err = crypto_wait_req(crypto_kpp_compute_shared_secret(req), 32677f397136SGilad Ben-Yossef &wait); 326847d3fd39STudor-Dan Ambarus if (err) { 326947d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party B: compute shared secret failed. err %d\n", 327047d3fd39STudor-Dan Ambarus alg, err); 327147d3fd39STudor-Dan Ambarus goto free_all; 327247d3fd39STudor-Dan Ambarus } 327347d3fd39STudor-Dan Ambarus 327447d3fd39STudor-Dan Ambarus shared_secret = a_ss; 327547d3fd39STudor-Dan Ambarus } else { 327647d3fd39STudor-Dan Ambarus shared_secret = (void *)vec->expected_ss; 327747d3fd39STudor-Dan Ambarus } 327847d3fd39STudor-Dan Ambarus 3279802c7f1cSSalvatore Benedetto /* 3280802c7f1cSSalvatore Benedetto * verify shared secret from which the user will derive 3281802c7f1cSSalvatore Benedetto * secret key by executing whatever hash it has chosen 3282802c7f1cSSalvatore Benedetto */ 328347d3fd39STudor-Dan Ambarus if (memcmp(shared_secret, sg_virt(req->dst), 3284802c7f1cSSalvatore Benedetto vec->expected_ss_size)) { 3285802c7f1cSSalvatore Benedetto pr_err("alg: %s: compute shared secret test failed. Invalid output\n", 3286802c7f1cSSalvatore Benedetto alg); 3287802c7f1cSSalvatore Benedetto err = -EINVAL; 3288802c7f1cSSalvatore Benedetto } 3289802c7f1cSSalvatore Benedetto 3290802c7f1cSSalvatore Benedetto free_all: 329147d3fd39STudor-Dan Ambarus kfree(a_ss); 3292802c7f1cSSalvatore Benedetto kfree(input_buf); 3293802c7f1cSSalvatore Benedetto free_output: 329447d3fd39STudor-Dan Ambarus kfree(a_public); 3295802c7f1cSSalvatore Benedetto kfree(output_buf); 3296802c7f1cSSalvatore Benedetto free_req: 3297802c7f1cSSalvatore Benedetto kpp_request_free(req); 3298802c7f1cSSalvatore Benedetto return err; 3299802c7f1cSSalvatore Benedetto } 3300802c7f1cSSalvatore Benedetto 3301802c7f1cSSalvatore Benedetto static int test_kpp(struct crypto_kpp *tfm, const char *alg, 3302b13b1e0cSEric Biggers const struct kpp_testvec *vecs, unsigned int tcount) 3303802c7f1cSSalvatore Benedetto { 3304802c7f1cSSalvatore Benedetto int ret, i; 3305802c7f1cSSalvatore Benedetto 3306802c7f1cSSalvatore Benedetto for (i = 0; i < tcount; i++) { 3307802c7f1cSSalvatore Benedetto ret = do_test_kpp(tfm, vecs++, alg); 3308802c7f1cSSalvatore Benedetto if (ret) { 3309802c7f1cSSalvatore Benedetto pr_err("alg: %s: test failed on vector %d, err=%d\n", 3310802c7f1cSSalvatore Benedetto alg, i + 1, ret); 3311802c7f1cSSalvatore Benedetto return ret; 3312802c7f1cSSalvatore Benedetto } 3313802c7f1cSSalvatore Benedetto } 3314802c7f1cSSalvatore Benedetto return 0; 3315802c7f1cSSalvatore Benedetto } 3316802c7f1cSSalvatore Benedetto 3317802c7f1cSSalvatore Benedetto static int alg_test_kpp(const struct alg_test_desc *desc, const char *driver, 3318802c7f1cSSalvatore Benedetto u32 type, u32 mask) 3319802c7f1cSSalvatore Benedetto { 3320802c7f1cSSalvatore Benedetto struct crypto_kpp *tfm; 3321802c7f1cSSalvatore Benedetto int err = 0; 3322802c7f1cSSalvatore Benedetto 3323eed93e0cSHerbert Xu tfm = crypto_alloc_kpp(driver, type, mask); 3324802c7f1cSSalvatore Benedetto if (IS_ERR(tfm)) { 3325802c7f1cSSalvatore Benedetto pr_err("alg: kpp: Failed to load tfm for %s: %ld\n", 3326802c7f1cSSalvatore Benedetto driver, PTR_ERR(tfm)); 3327802c7f1cSSalvatore Benedetto return PTR_ERR(tfm); 3328802c7f1cSSalvatore Benedetto } 3329802c7f1cSSalvatore Benedetto if (desc->suite.kpp.vecs) 3330802c7f1cSSalvatore Benedetto err = test_kpp(tfm, desc->alg, desc->suite.kpp.vecs, 3331802c7f1cSSalvatore Benedetto desc->suite.kpp.count); 3332802c7f1cSSalvatore Benedetto 3333802c7f1cSSalvatore Benedetto crypto_free_kpp(tfm); 3334802c7f1cSSalvatore Benedetto return err; 3335802c7f1cSSalvatore Benedetto } 3336802c7f1cSSalvatore Benedetto 3337f1774cb8SVitaly Chikunov static u8 *test_pack_u32(u8 *dst, u32 val) 3338f1774cb8SVitaly Chikunov { 3339f1774cb8SVitaly Chikunov memcpy(dst, &val, sizeof(val)); 3340f1774cb8SVitaly Chikunov return dst + sizeof(val); 3341f1774cb8SVitaly Chikunov } 3342f1774cb8SVitaly Chikunov 334350d2b643SHerbert Xu static int test_akcipher_one(struct crypto_akcipher *tfm, 3344b13b1e0cSEric Biggers const struct akcipher_testvec *vecs) 3345946cc463STadeusz Struk { 3346df27b26fSHerbert Xu char *xbuf[XBUFSIZE]; 3347946cc463STadeusz Struk struct akcipher_request *req; 3348946cc463STadeusz Struk void *outbuf_enc = NULL; 3349946cc463STadeusz Struk void *outbuf_dec = NULL; 33507f397136SGilad Ben-Yossef struct crypto_wait wait; 3351946cc463STadeusz Struk unsigned int out_len_max, out_len = 0; 3352946cc463STadeusz Struk int err = -ENOMEM; 3353c7381b01SVitaly Chikunov struct scatterlist src, dst, src_tab[3]; 33540507de94SVitaly Chikunov const char *m, *c; 33550507de94SVitaly Chikunov unsigned int m_size, c_size; 33560507de94SVitaly Chikunov const char *op; 3357f1774cb8SVitaly Chikunov u8 *key, *ptr; 3358946cc463STadeusz Struk 3359df27b26fSHerbert Xu if (testmgr_alloc_buf(xbuf)) 3360df27b26fSHerbert Xu return err; 3361df27b26fSHerbert Xu 3362946cc463STadeusz Struk req = akcipher_request_alloc(tfm, GFP_KERNEL); 3363946cc463STadeusz Struk if (!req) 3364df27b26fSHerbert Xu goto free_xbuf; 3365946cc463STadeusz Struk 33667f397136SGilad Ben-Yossef crypto_init_wait(&wait); 336722287b0bSTadeusz Struk 3368f1774cb8SVitaly Chikunov key = kmalloc(vecs->key_len + sizeof(u32) * 2 + vecs->param_len, 3369f1774cb8SVitaly Chikunov GFP_KERNEL); 3370f1774cb8SVitaly Chikunov if (!key) 3371f1774cb8SVitaly Chikunov goto free_xbuf; 3372f1774cb8SVitaly Chikunov memcpy(key, vecs->key, vecs->key_len); 3373f1774cb8SVitaly Chikunov ptr = key + vecs->key_len; 3374f1774cb8SVitaly Chikunov ptr = test_pack_u32(ptr, vecs->algo); 3375f1774cb8SVitaly Chikunov ptr = test_pack_u32(ptr, vecs->param_len); 3376f1774cb8SVitaly Chikunov memcpy(ptr, vecs->params, vecs->param_len); 3377f1774cb8SVitaly Chikunov 337822287b0bSTadeusz Struk if (vecs->public_key_vec) 3379f1774cb8SVitaly Chikunov err = crypto_akcipher_set_pub_key(tfm, key, vecs->key_len); 338022287b0bSTadeusz Struk else 3381f1774cb8SVitaly Chikunov err = crypto_akcipher_set_priv_key(tfm, key, vecs->key_len); 3382946cc463STadeusz Struk if (err) 3383946cc463STadeusz Struk goto free_req; 3384946cc463STadeusz Struk 33850507de94SVitaly Chikunov /* 33860507de94SVitaly Chikunov * First run test which do not require a private key, such as 33870507de94SVitaly Chikunov * encrypt or verify. 33880507de94SVitaly Chikunov */ 3389c7381b01SVitaly Chikunov err = -ENOMEM; 3390c7381b01SVitaly Chikunov out_len_max = crypto_akcipher_maxsize(tfm); 3391946cc463STadeusz Struk outbuf_enc = kzalloc(out_len_max, GFP_KERNEL); 3392946cc463STadeusz Struk if (!outbuf_enc) 3393946cc463STadeusz Struk goto free_req; 3394946cc463STadeusz Struk 33950507de94SVitaly Chikunov if (!vecs->siggen_sigver_test) { 33960507de94SVitaly Chikunov m = vecs->m; 33970507de94SVitaly Chikunov m_size = vecs->m_size; 33980507de94SVitaly Chikunov c = vecs->c; 33990507de94SVitaly Chikunov c_size = vecs->c_size; 34000507de94SVitaly Chikunov op = "encrypt"; 34010507de94SVitaly Chikunov } else { 34020507de94SVitaly Chikunov /* Swap args so we could keep plaintext (digest) 34030507de94SVitaly Chikunov * in vecs->m, and cooked signature in vecs->c. 34040507de94SVitaly Chikunov */ 34050507de94SVitaly Chikunov m = vecs->c; /* signature */ 34060507de94SVitaly Chikunov m_size = vecs->c_size; 34070507de94SVitaly Chikunov c = vecs->m; /* digest */ 34080507de94SVitaly Chikunov c_size = vecs->m_size; 34090507de94SVitaly Chikunov op = "verify"; 34100507de94SVitaly Chikunov } 3411df27b26fSHerbert Xu 34120507de94SVitaly Chikunov if (WARN_ON(m_size > PAGE_SIZE)) 34130507de94SVitaly Chikunov goto free_all; 34140507de94SVitaly Chikunov memcpy(xbuf[0], m, m_size); 3415df27b26fSHerbert Xu 3416c7381b01SVitaly Chikunov sg_init_table(src_tab, 3); 3417df27b26fSHerbert Xu sg_set_buf(&src_tab[0], xbuf[0], 8); 34180507de94SVitaly Chikunov sg_set_buf(&src_tab[1], xbuf[0] + 8, m_size - 8); 3419c7381b01SVitaly Chikunov if (vecs->siggen_sigver_test) { 3420c7381b01SVitaly Chikunov if (WARN_ON(c_size > PAGE_SIZE)) 3421c7381b01SVitaly Chikunov goto free_all; 3422c7381b01SVitaly Chikunov memcpy(xbuf[1], c, c_size); 3423c7381b01SVitaly Chikunov sg_set_buf(&src_tab[2], xbuf[1], c_size); 3424c7381b01SVitaly Chikunov akcipher_request_set_crypt(req, src_tab, NULL, m_size, c_size); 3425c7381b01SVitaly Chikunov } else { 342622287b0bSTadeusz Struk sg_init_one(&dst, outbuf_enc, out_len_max); 34270507de94SVitaly Chikunov akcipher_request_set_crypt(req, src_tab, &dst, m_size, 342822287b0bSTadeusz Struk out_len_max); 3429c7381b01SVitaly Chikunov } 3430946cc463STadeusz Struk akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 34317f397136SGilad Ben-Yossef crypto_req_done, &wait); 3432946cc463STadeusz Struk 34337f397136SGilad Ben-Yossef err = crypto_wait_req(vecs->siggen_sigver_test ? 34340507de94SVitaly Chikunov /* Run asymmetric signature verification */ 34350507de94SVitaly Chikunov crypto_akcipher_verify(req) : 34361207107cSStephan Mueller /* Run asymmetric encrypt */ 34377f397136SGilad Ben-Yossef crypto_akcipher_encrypt(req), &wait); 3438946cc463STadeusz Struk if (err) { 34390507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. err %d\n", op, err); 3440946cc463STadeusz Struk goto free_all; 3441946cc463STadeusz Struk } 3442c7381b01SVitaly Chikunov if (!vecs->siggen_sigver_test) { 34430507de94SVitaly Chikunov if (req->dst_len != c_size) { 34440507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output len\n", 34450507de94SVitaly Chikunov op); 3446946cc463STadeusz Struk err = -EINVAL; 3447946cc463STadeusz Struk goto free_all; 3448946cc463STadeusz Struk } 3449946cc463STadeusz Struk /* verify that encrypted message is equal to expected */ 3450c7381b01SVitaly Chikunov if (memcmp(c, outbuf_enc, c_size) != 0) { 3451c7381b01SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output\n", 3452c7381b01SVitaly Chikunov op); 34530507de94SVitaly Chikunov hexdump(outbuf_enc, c_size); 3454946cc463STadeusz Struk err = -EINVAL; 3455946cc463STadeusz Struk goto free_all; 3456946cc463STadeusz Struk } 3457c7381b01SVitaly Chikunov } 34580507de94SVitaly Chikunov 34590507de94SVitaly Chikunov /* 34600507de94SVitaly Chikunov * Don't invoke (decrypt or sign) test which require a private key 34610507de94SVitaly Chikunov * for vectors with only a public key. 34620507de94SVitaly Chikunov */ 3463946cc463STadeusz Struk if (vecs->public_key_vec) { 3464946cc463STadeusz Struk err = 0; 3465946cc463STadeusz Struk goto free_all; 3466946cc463STadeusz Struk } 3467946cc463STadeusz Struk outbuf_dec = kzalloc(out_len_max, GFP_KERNEL); 3468946cc463STadeusz Struk if (!outbuf_dec) { 3469946cc463STadeusz Struk err = -ENOMEM; 3470946cc463STadeusz Struk goto free_all; 3471946cc463STadeusz Struk } 3472df27b26fSHerbert Xu 34730507de94SVitaly Chikunov op = vecs->siggen_sigver_test ? "sign" : "decrypt"; 34740507de94SVitaly Chikunov if (WARN_ON(c_size > PAGE_SIZE)) 3475df27b26fSHerbert Xu goto free_all; 34760507de94SVitaly Chikunov memcpy(xbuf[0], c, c_size); 3477df27b26fSHerbert Xu 34780507de94SVitaly Chikunov sg_init_one(&src, xbuf[0], c_size); 347922287b0bSTadeusz Struk sg_init_one(&dst, outbuf_dec, out_len_max); 34807f397136SGilad Ben-Yossef crypto_init_wait(&wait); 34810507de94SVitaly Chikunov akcipher_request_set_crypt(req, &src, &dst, c_size, out_len_max); 3482946cc463STadeusz Struk 34837f397136SGilad Ben-Yossef err = crypto_wait_req(vecs->siggen_sigver_test ? 34840507de94SVitaly Chikunov /* Run asymmetric signature generation */ 34850507de94SVitaly Chikunov crypto_akcipher_sign(req) : 34861207107cSStephan Mueller /* Run asymmetric decrypt */ 34877f397136SGilad Ben-Yossef crypto_akcipher_decrypt(req), &wait); 3488946cc463STadeusz Struk if (err) { 34890507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. err %d\n", op, err); 3490946cc463STadeusz Struk goto free_all; 3491946cc463STadeusz Struk } 3492946cc463STadeusz Struk out_len = req->dst_len; 34930507de94SVitaly Chikunov if (out_len < m_size) { 34940507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output len %u\n", 34950507de94SVitaly Chikunov op, out_len); 3496946cc463STadeusz Struk err = -EINVAL; 3497946cc463STadeusz Struk goto free_all; 3498946cc463STadeusz Struk } 3499946cc463STadeusz Struk /* verify that decrypted message is equal to the original msg */ 35000507de94SVitaly Chikunov if (memchr_inv(outbuf_dec, 0, out_len - m_size) || 35010507de94SVitaly Chikunov memcmp(m, outbuf_dec + out_len - m_size, m_size)) { 35020507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output\n", op); 350350d2b643SHerbert Xu hexdump(outbuf_dec, out_len); 3504946cc463STadeusz Struk err = -EINVAL; 3505946cc463STadeusz Struk } 3506946cc463STadeusz Struk free_all: 3507946cc463STadeusz Struk kfree(outbuf_dec); 3508946cc463STadeusz Struk kfree(outbuf_enc); 3509946cc463STadeusz Struk free_req: 3510946cc463STadeusz Struk akcipher_request_free(req); 3511f1774cb8SVitaly Chikunov kfree(key); 3512df27b26fSHerbert Xu free_xbuf: 3513df27b26fSHerbert Xu testmgr_free_buf(xbuf); 3514946cc463STadeusz Struk return err; 3515946cc463STadeusz Struk } 3516946cc463STadeusz Struk 351750d2b643SHerbert Xu static int test_akcipher(struct crypto_akcipher *tfm, const char *alg, 3518b13b1e0cSEric Biggers const struct akcipher_testvec *vecs, 3519b13b1e0cSEric Biggers unsigned int tcount) 3520946cc463STadeusz Struk { 352115226e48SHerbert Xu const char *algo = 352215226e48SHerbert Xu crypto_tfm_alg_driver_name(crypto_akcipher_tfm(tfm)); 3523946cc463STadeusz Struk int ret, i; 3524946cc463STadeusz Struk 3525946cc463STadeusz Struk for (i = 0; i < tcount; i++) { 352650d2b643SHerbert Xu ret = test_akcipher_one(tfm, vecs++); 352750d2b643SHerbert Xu if (!ret) 352850d2b643SHerbert Xu continue; 352950d2b643SHerbert Xu 353015226e48SHerbert Xu pr_err("alg: akcipher: test %d failed for %s, err=%d\n", 353115226e48SHerbert Xu i + 1, algo, ret); 3532946cc463STadeusz Struk return ret; 3533946cc463STadeusz Struk } 3534946cc463STadeusz Struk return 0; 3535946cc463STadeusz Struk } 3536946cc463STadeusz Struk 3537946cc463STadeusz Struk static int alg_test_akcipher(const struct alg_test_desc *desc, 3538946cc463STadeusz Struk const char *driver, u32 type, u32 mask) 3539946cc463STadeusz Struk { 3540946cc463STadeusz Struk struct crypto_akcipher *tfm; 3541946cc463STadeusz Struk int err = 0; 3542946cc463STadeusz Struk 3543eed93e0cSHerbert Xu tfm = crypto_alloc_akcipher(driver, type, mask); 3544946cc463STadeusz Struk if (IS_ERR(tfm)) { 3545946cc463STadeusz Struk pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n", 3546946cc463STadeusz Struk driver, PTR_ERR(tfm)); 3547946cc463STadeusz Struk return PTR_ERR(tfm); 3548946cc463STadeusz Struk } 3549946cc463STadeusz Struk if (desc->suite.akcipher.vecs) 3550946cc463STadeusz Struk err = test_akcipher(tfm, desc->alg, desc->suite.akcipher.vecs, 3551946cc463STadeusz Struk desc->suite.akcipher.count); 3552946cc463STadeusz Struk 3553946cc463STadeusz Struk crypto_free_akcipher(tfm); 3554946cc463STadeusz Struk return err; 3555946cc463STadeusz Struk } 3556946cc463STadeusz Struk 3557863b557aSYouquan, Song static int alg_test_null(const struct alg_test_desc *desc, 3558863b557aSYouquan, Song const char *driver, u32 type, u32 mask) 3559863b557aSYouquan, Song { 3560863b557aSYouquan, Song return 0; 3561863b557aSYouquan, Song } 3562863b557aSYouquan, Song 356321c8e720SArd Biesheuvel #define __VECS(tv) { .vecs = tv, .count = ARRAY_SIZE(tv) } 356421c8e720SArd Biesheuvel 3565da7f033dSHerbert Xu /* Please keep this list sorted by algorithm name. */ 3566da7f033dSHerbert Xu static const struct alg_test_desc alg_test_descs[] = { 3567da7f033dSHerbert Xu { 3568059c2a4dSEric Biggers .alg = "adiantum(xchacha12,aes)", 3569d435e10eSEric Biggers .generic_driver = "adiantum(xchacha12-generic,aes-generic,nhpoly1305-generic)", 3570059c2a4dSEric Biggers .test = alg_test_skcipher, 3571059c2a4dSEric Biggers .suite = { 3572059c2a4dSEric Biggers .cipher = __VECS(adiantum_xchacha12_aes_tv_template) 3573059c2a4dSEric Biggers }, 3574059c2a4dSEric Biggers }, { 3575059c2a4dSEric Biggers .alg = "adiantum(xchacha20,aes)", 3576d435e10eSEric Biggers .generic_driver = "adiantum(xchacha20-generic,aes-generic,nhpoly1305-generic)", 3577059c2a4dSEric Biggers .test = alg_test_skcipher, 3578059c2a4dSEric Biggers .suite = { 3579059c2a4dSEric Biggers .cipher = __VECS(adiantum_xchacha20_aes_tv_template) 3580059c2a4dSEric Biggers }, 3581059c2a4dSEric Biggers }, { 3582b87dc203SOndrej Mosnacek .alg = "aegis128", 3583b87dc203SOndrej Mosnacek .test = alg_test_aead, 3584b87dc203SOndrej Mosnacek .suite = { 3585a0d608eeSEric Biggers .aead = __VECS(aegis128_tv_template) 3586b87dc203SOndrej Mosnacek } 3587b87dc203SOndrej Mosnacek }, { 3588b87dc203SOndrej Mosnacek .alg = "aegis128l", 3589b87dc203SOndrej Mosnacek .test = alg_test_aead, 3590b87dc203SOndrej Mosnacek .suite = { 3591a0d608eeSEric Biggers .aead = __VECS(aegis128l_tv_template) 3592b87dc203SOndrej Mosnacek } 3593b87dc203SOndrej Mosnacek }, { 3594b87dc203SOndrej Mosnacek .alg = "aegis256", 3595b87dc203SOndrej Mosnacek .test = alg_test_aead, 3596b87dc203SOndrej Mosnacek .suite = { 3597a0d608eeSEric Biggers .aead = __VECS(aegis256_tv_template) 3598b87dc203SOndrej Mosnacek } 3599b87dc203SOndrej Mosnacek }, { 3600e08ca2daSJarod Wilson .alg = "ansi_cprng", 3601e08ca2daSJarod Wilson .test = alg_test_cprng, 3602e08ca2daSJarod Wilson .suite = { 360321c8e720SArd Biesheuvel .cprng = __VECS(ansi_cprng_aes_tv_template) 3604e08ca2daSJarod Wilson } 3605e08ca2daSJarod Wilson }, { 3606bca4feb0SHoria Geanta .alg = "authenc(hmac(md5),ecb(cipher_null))", 3607bca4feb0SHoria Geanta .test = alg_test_aead, 3608bca4feb0SHoria Geanta .suite = { 3609a0d608eeSEric Biggers .aead = __VECS(hmac_md5_ecb_cipher_null_tv_template) 3610bca4feb0SHoria Geanta } 3611bca4feb0SHoria Geanta }, { 3612a4198fd4SHerbert Xu .alg = "authenc(hmac(sha1),cbc(aes))", 3613e46e9a46SHoria Geanta .test = alg_test_aead, 3614bcf741cbSHerbert Xu .fips_allowed = 1, 3615e46e9a46SHoria Geanta .suite = { 3616a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_aes_cbc_tv_temp) 36175208ed2cSNitesh Lal } 36185208ed2cSNitesh Lal }, { 3619a4198fd4SHerbert Xu .alg = "authenc(hmac(sha1),cbc(des))", 36205208ed2cSNitesh Lal .test = alg_test_aead, 36215208ed2cSNitesh Lal .suite = { 3622a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_des_cbc_tv_temp) 36235208ed2cSNitesh Lal } 36245208ed2cSNitesh Lal }, { 3625a4198fd4SHerbert Xu .alg = "authenc(hmac(sha1),cbc(des3_ede))", 36265208ed2cSNitesh Lal .test = alg_test_aead, 3627ed1afac9SMarcus Meissner .fips_allowed = 1, 36285208ed2cSNitesh Lal .suite = { 3629a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_des3_ede_cbc_tv_temp) 3630e46e9a46SHoria Geanta } 3631e46e9a46SHoria Geanta }, { 3632fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha1),ctr(aes))", 3633fb16abc2SMarcus Meissner .test = alg_test_null, 3634fb16abc2SMarcus Meissner .fips_allowed = 1, 3635fb16abc2SMarcus Meissner }, { 3636bca4feb0SHoria Geanta .alg = "authenc(hmac(sha1),ecb(cipher_null))", 3637bca4feb0SHoria Geanta .test = alg_test_aead, 3638bca4feb0SHoria Geanta .suite = { 3639a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_ecb_cipher_null_tv_temp) 36405208ed2cSNitesh Lal } 36415208ed2cSNitesh Lal }, { 36428888690eSMarcus Meissner .alg = "authenc(hmac(sha1),rfc3686(ctr(aes)))", 36438888690eSMarcus Meissner .test = alg_test_null, 36448888690eSMarcus Meissner .fips_allowed = 1, 36458888690eSMarcus Meissner }, { 3646a4198fd4SHerbert Xu .alg = "authenc(hmac(sha224),cbc(des))", 36475208ed2cSNitesh Lal .test = alg_test_aead, 36485208ed2cSNitesh Lal .suite = { 3649a0d608eeSEric Biggers .aead = __VECS(hmac_sha224_des_cbc_tv_temp) 36505208ed2cSNitesh Lal } 36515208ed2cSNitesh Lal }, { 3652a4198fd4SHerbert Xu .alg = "authenc(hmac(sha224),cbc(des3_ede))", 36535208ed2cSNitesh Lal .test = alg_test_aead, 3654ed1afac9SMarcus Meissner .fips_allowed = 1, 36555208ed2cSNitesh Lal .suite = { 3656a0d608eeSEric Biggers .aead = __VECS(hmac_sha224_des3_ede_cbc_tv_temp) 3657bca4feb0SHoria Geanta } 3658bca4feb0SHoria Geanta }, { 3659a4198fd4SHerbert Xu .alg = "authenc(hmac(sha256),cbc(aes))", 3660e46e9a46SHoria Geanta .test = alg_test_aead, 3661ed1afac9SMarcus Meissner .fips_allowed = 1, 3662e46e9a46SHoria Geanta .suite = { 3663a0d608eeSEric Biggers .aead = __VECS(hmac_sha256_aes_cbc_tv_temp) 36645208ed2cSNitesh Lal } 36655208ed2cSNitesh Lal }, { 3666a4198fd4SHerbert Xu .alg = "authenc(hmac(sha256),cbc(des))", 36675208ed2cSNitesh Lal .test = alg_test_aead, 36685208ed2cSNitesh Lal .suite = { 3669a0d608eeSEric Biggers .aead = __VECS(hmac_sha256_des_cbc_tv_temp) 36705208ed2cSNitesh Lal } 36715208ed2cSNitesh Lal }, { 3672a4198fd4SHerbert Xu .alg = "authenc(hmac(sha256),cbc(des3_ede))", 36735208ed2cSNitesh Lal .test = alg_test_aead, 3674ed1afac9SMarcus Meissner .fips_allowed = 1, 36755208ed2cSNitesh Lal .suite = { 3676a0d608eeSEric Biggers .aead = __VECS(hmac_sha256_des3_ede_cbc_tv_temp) 36775208ed2cSNitesh Lal } 36785208ed2cSNitesh Lal }, { 3679fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha256),ctr(aes))", 3680fb16abc2SMarcus Meissner .test = alg_test_null, 3681fb16abc2SMarcus Meissner .fips_allowed = 1, 3682fb16abc2SMarcus Meissner }, { 36838888690eSMarcus Meissner .alg = "authenc(hmac(sha256),rfc3686(ctr(aes)))", 36848888690eSMarcus Meissner .test = alg_test_null, 36858888690eSMarcus Meissner .fips_allowed = 1, 36868888690eSMarcus Meissner }, { 3687a4198fd4SHerbert Xu .alg = "authenc(hmac(sha384),cbc(des))", 36885208ed2cSNitesh Lal .test = alg_test_aead, 36895208ed2cSNitesh Lal .suite = { 3690a0d608eeSEric Biggers .aead = __VECS(hmac_sha384_des_cbc_tv_temp) 36915208ed2cSNitesh Lal } 36925208ed2cSNitesh Lal }, { 3693a4198fd4SHerbert Xu .alg = "authenc(hmac(sha384),cbc(des3_ede))", 36945208ed2cSNitesh Lal .test = alg_test_aead, 3695ed1afac9SMarcus Meissner .fips_allowed = 1, 36965208ed2cSNitesh Lal .suite = { 3697a0d608eeSEric Biggers .aead = __VECS(hmac_sha384_des3_ede_cbc_tv_temp) 3698e46e9a46SHoria Geanta } 3699e46e9a46SHoria Geanta }, { 3700fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha384),ctr(aes))", 3701fb16abc2SMarcus Meissner .test = alg_test_null, 3702fb16abc2SMarcus Meissner .fips_allowed = 1, 3703fb16abc2SMarcus Meissner }, { 37048888690eSMarcus Meissner .alg = "authenc(hmac(sha384),rfc3686(ctr(aes)))", 37058888690eSMarcus Meissner .test = alg_test_null, 37068888690eSMarcus Meissner .fips_allowed = 1, 37078888690eSMarcus Meissner }, { 3708a4198fd4SHerbert Xu .alg = "authenc(hmac(sha512),cbc(aes))", 3709ed1afac9SMarcus Meissner .fips_allowed = 1, 3710e46e9a46SHoria Geanta .test = alg_test_aead, 3711e46e9a46SHoria Geanta .suite = { 3712a0d608eeSEric Biggers .aead = __VECS(hmac_sha512_aes_cbc_tv_temp) 37135208ed2cSNitesh Lal } 37145208ed2cSNitesh Lal }, { 3715a4198fd4SHerbert Xu .alg = "authenc(hmac(sha512),cbc(des))", 37165208ed2cSNitesh Lal .test = alg_test_aead, 37175208ed2cSNitesh Lal .suite = { 3718a0d608eeSEric Biggers .aead = __VECS(hmac_sha512_des_cbc_tv_temp) 37195208ed2cSNitesh Lal } 37205208ed2cSNitesh Lal }, { 3721a4198fd4SHerbert Xu .alg = "authenc(hmac(sha512),cbc(des3_ede))", 37225208ed2cSNitesh Lal .test = alg_test_aead, 3723ed1afac9SMarcus Meissner .fips_allowed = 1, 37245208ed2cSNitesh Lal .suite = { 3725a0d608eeSEric Biggers .aead = __VECS(hmac_sha512_des3_ede_cbc_tv_temp) 3726e46e9a46SHoria Geanta } 3727e46e9a46SHoria Geanta }, { 3728fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha512),ctr(aes))", 3729fb16abc2SMarcus Meissner .test = alg_test_null, 3730fb16abc2SMarcus Meissner .fips_allowed = 1, 3731fb16abc2SMarcus Meissner }, { 37328888690eSMarcus Meissner .alg = "authenc(hmac(sha512),rfc3686(ctr(aes)))", 37338888690eSMarcus Meissner .test = alg_test_null, 37348888690eSMarcus Meissner .fips_allowed = 1, 37358888690eSMarcus Meissner }, { 3736da7f033dSHerbert Xu .alg = "cbc(aes)", 37371aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3738a1915d51SJarod Wilson .fips_allowed = 1, 3739da7f033dSHerbert Xu .suite = { 374092a4c9feSEric Biggers .cipher = __VECS(aes_cbc_tv_template) 374192a4c9feSEric Biggers }, 3742da7f033dSHerbert Xu }, { 3743da7f033dSHerbert Xu .alg = "cbc(anubis)", 37441aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3745da7f033dSHerbert Xu .suite = { 374692a4c9feSEric Biggers .cipher = __VECS(anubis_cbc_tv_template) 374792a4c9feSEric Biggers }, 3748da7f033dSHerbert Xu }, { 3749da7f033dSHerbert Xu .alg = "cbc(blowfish)", 37501aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3751da7f033dSHerbert Xu .suite = { 375292a4c9feSEric Biggers .cipher = __VECS(bf_cbc_tv_template) 375392a4c9feSEric Biggers }, 3754da7f033dSHerbert Xu }, { 3755da7f033dSHerbert Xu .alg = "cbc(camellia)", 37561aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3757da7f033dSHerbert Xu .suite = { 375892a4c9feSEric Biggers .cipher = __VECS(camellia_cbc_tv_template) 375992a4c9feSEric Biggers }, 3760da7f033dSHerbert Xu }, { 3761a2c58260SJohannes Goetzfried .alg = "cbc(cast5)", 3762a2c58260SJohannes Goetzfried .test = alg_test_skcipher, 3763a2c58260SJohannes Goetzfried .suite = { 376492a4c9feSEric Biggers .cipher = __VECS(cast5_cbc_tv_template) 376592a4c9feSEric Biggers }, 3766a2c58260SJohannes Goetzfried }, { 37679b8b0405SJohannes Goetzfried .alg = "cbc(cast6)", 37689b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 37699b8b0405SJohannes Goetzfried .suite = { 377092a4c9feSEric Biggers .cipher = __VECS(cast6_cbc_tv_template) 377192a4c9feSEric Biggers }, 37729b8b0405SJohannes Goetzfried }, { 3773da7f033dSHerbert Xu .alg = "cbc(des)", 37741aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3775da7f033dSHerbert Xu .suite = { 377692a4c9feSEric Biggers .cipher = __VECS(des_cbc_tv_template) 377792a4c9feSEric Biggers }, 3778da7f033dSHerbert Xu }, { 3779da7f033dSHerbert Xu .alg = "cbc(des3_ede)", 37801aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3781a1915d51SJarod Wilson .fips_allowed = 1, 3782da7f033dSHerbert Xu .suite = { 378392a4c9feSEric Biggers .cipher = __VECS(des3_ede_cbc_tv_template) 378492a4c9feSEric Biggers }, 3785da7f033dSHerbert Xu }, { 3786a794d8d8SGilad Ben-Yossef /* Same as cbc(aes) except the key is stored in 3787a794d8d8SGilad Ben-Yossef * hardware secure memory which we reference by index 3788a794d8d8SGilad Ben-Yossef */ 3789a794d8d8SGilad Ben-Yossef .alg = "cbc(paes)", 3790a794d8d8SGilad Ben-Yossef .test = alg_test_null, 3791a794d8d8SGilad Ben-Yossef .fips_allowed = 1, 3792a794d8d8SGilad Ben-Yossef }, { 3793f0372c00SGilad Ben-Yossef /* Same as cbc(sm4) except the key is stored in 3794f0372c00SGilad Ben-Yossef * hardware secure memory which we reference by index 3795f0372c00SGilad Ben-Yossef */ 3796f0372c00SGilad Ben-Yossef .alg = "cbc(psm4)", 3797f0372c00SGilad Ben-Yossef .test = alg_test_null, 3798f0372c00SGilad Ben-Yossef }, { 37999d25917dSJussi Kivilinna .alg = "cbc(serpent)", 38009d25917dSJussi Kivilinna .test = alg_test_skcipher, 38019d25917dSJussi Kivilinna .suite = { 380292a4c9feSEric Biggers .cipher = __VECS(serpent_cbc_tv_template) 380392a4c9feSEric Biggers }, 38049d25917dSJussi Kivilinna }, { 380595ba5973SGilad Ben-Yossef .alg = "cbc(sm4)", 380695ba5973SGilad Ben-Yossef .test = alg_test_skcipher, 380795ba5973SGilad Ben-Yossef .suite = { 380895ba5973SGilad Ben-Yossef .cipher = __VECS(sm4_cbc_tv_template) 380995ba5973SGilad Ben-Yossef } 381095ba5973SGilad Ben-Yossef }, { 3811da7f033dSHerbert Xu .alg = "cbc(twofish)", 38121aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3813da7f033dSHerbert Xu .suite = { 381492a4c9feSEric Biggers .cipher = __VECS(tf_cbc_tv_template) 381592a4c9feSEric Biggers }, 3816da7f033dSHerbert Xu }, { 3817092acf06SArd Biesheuvel .alg = "cbcmac(aes)", 3818092acf06SArd Biesheuvel .fips_allowed = 1, 3819092acf06SArd Biesheuvel .test = alg_test_hash, 3820092acf06SArd Biesheuvel .suite = { 3821092acf06SArd Biesheuvel .hash = __VECS(aes_cbcmac_tv_template) 3822092acf06SArd Biesheuvel } 3823092acf06SArd Biesheuvel }, { 3824da7f033dSHerbert Xu .alg = "ccm(aes)", 382540153b10SEric Biggers .generic_driver = "ccm_base(ctr(aes-generic),cbcmac(aes-generic))", 3826da7f033dSHerbert Xu .test = alg_test_aead, 3827a1915d51SJarod Wilson .fips_allowed = 1, 3828da7f033dSHerbert Xu .suite = { 3829a0d608eeSEric Biggers .aead = __VECS(aes_ccm_tv_template) 3830da7f033dSHerbert Xu } 3831da7f033dSHerbert Xu }, { 38327da66670SDmitry Eremin-Solenikov .alg = "cfb(aes)", 38337da66670SDmitry Eremin-Solenikov .test = alg_test_skcipher, 38347da66670SDmitry Eremin-Solenikov .fips_allowed = 1, 38357da66670SDmitry Eremin-Solenikov .suite = { 38367da66670SDmitry Eremin-Solenikov .cipher = __VECS(aes_cfb_tv_template) 38377da66670SDmitry Eremin-Solenikov }, 38387da66670SDmitry Eremin-Solenikov }, { 38393590ebf2SMartin Willi .alg = "chacha20", 38403590ebf2SMartin Willi .test = alg_test_skcipher, 38413590ebf2SMartin Willi .suite = { 384292a4c9feSEric Biggers .cipher = __VECS(chacha20_tv_template) 384392a4c9feSEric Biggers }, 38443590ebf2SMartin Willi }, { 384593b5e86aSJussi Kivilinna .alg = "cmac(aes)", 38468f183751SStephan Mueller .fips_allowed = 1, 384793b5e86aSJussi Kivilinna .test = alg_test_hash, 384893b5e86aSJussi Kivilinna .suite = { 384921c8e720SArd Biesheuvel .hash = __VECS(aes_cmac128_tv_template) 385093b5e86aSJussi Kivilinna } 385193b5e86aSJussi Kivilinna }, { 385293b5e86aSJussi Kivilinna .alg = "cmac(des3_ede)", 38538f183751SStephan Mueller .fips_allowed = 1, 385493b5e86aSJussi Kivilinna .test = alg_test_hash, 385593b5e86aSJussi Kivilinna .suite = { 385621c8e720SArd Biesheuvel .hash = __VECS(des3_ede_cmac64_tv_template) 385793b5e86aSJussi Kivilinna } 385893b5e86aSJussi Kivilinna }, { 3859e448370dSJussi Kivilinna .alg = "compress_null", 3860e448370dSJussi Kivilinna .test = alg_test_null, 3861e448370dSJussi Kivilinna }, { 3862ebb3472fSArd Biesheuvel .alg = "crc32", 3863ebb3472fSArd Biesheuvel .test = alg_test_hash, 3864a8a34416SMilan Broz .fips_allowed = 1, 3865ebb3472fSArd Biesheuvel .suite = { 386621c8e720SArd Biesheuvel .hash = __VECS(crc32_tv_template) 3867ebb3472fSArd Biesheuvel } 3868ebb3472fSArd Biesheuvel }, { 3869da7f033dSHerbert Xu .alg = "crc32c", 38708e3ee85eSHerbert Xu .test = alg_test_crc32c, 3871a1915d51SJarod Wilson .fips_allowed = 1, 3872da7f033dSHerbert Xu .suite = { 387321c8e720SArd Biesheuvel .hash = __VECS(crc32c_tv_template) 3874da7f033dSHerbert Xu } 3875da7f033dSHerbert Xu }, { 387668411521SHerbert Xu .alg = "crct10dif", 387768411521SHerbert Xu .test = alg_test_hash, 387868411521SHerbert Xu .fips_allowed = 1, 387968411521SHerbert Xu .suite = { 388021c8e720SArd Biesheuvel .hash = __VECS(crct10dif_tv_template) 388168411521SHerbert Xu } 388268411521SHerbert Xu }, { 3883f7cb80f2SJarod Wilson .alg = "ctr(aes)", 3884f7cb80f2SJarod Wilson .test = alg_test_skcipher, 3885a1915d51SJarod Wilson .fips_allowed = 1, 3886f7cb80f2SJarod Wilson .suite = { 388792a4c9feSEric Biggers .cipher = __VECS(aes_ctr_tv_template) 3888f7cb80f2SJarod Wilson } 3889f7cb80f2SJarod Wilson }, { 389085b63e34SJussi Kivilinna .alg = "ctr(blowfish)", 389185b63e34SJussi Kivilinna .test = alg_test_skcipher, 389285b63e34SJussi Kivilinna .suite = { 389392a4c9feSEric Biggers .cipher = __VECS(bf_ctr_tv_template) 389485b63e34SJussi Kivilinna } 389585b63e34SJussi Kivilinna }, { 38960840605eSJussi Kivilinna .alg = "ctr(camellia)", 38970840605eSJussi Kivilinna .test = alg_test_skcipher, 38980840605eSJussi Kivilinna .suite = { 389992a4c9feSEric Biggers .cipher = __VECS(camellia_ctr_tv_template) 39000840605eSJussi Kivilinna } 39010840605eSJussi Kivilinna }, { 3902a2c58260SJohannes Goetzfried .alg = "ctr(cast5)", 3903a2c58260SJohannes Goetzfried .test = alg_test_skcipher, 3904a2c58260SJohannes Goetzfried .suite = { 390592a4c9feSEric Biggers .cipher = __VECS(cast5_ctr_tv_template) 3906a2c58260SJohannes Goetzfried } 3907a2c58260SJohannes Goetzfried }, { 39089b8b0405SJohannes Goetzfried .alg = "ctr(cast6)", 39099b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 39109b8b0405SJohannes Goetzfried .suite = { 391192a4c9feSEric Biggers .cipher = __VECS(cast6_ctr_tv_template) 39129b8b0405SJohannes Goetzfried } 39139b8b0405SJohannes Goetzfried }, { 39148163fc30SJussi Kivilinna .alg = "ctr(des)", 39158163fc30SJussi Kivilinna .test = alg_test_skcipher, 39168163fc30SJussi Kivilinna .suite = { 391792a4c9feSEric Biggers .cipher = __VECS(des_ctr_tv_template) 39188163fc30SJussi Kivilinna } 39198163fc30SJussi Kivilinna }, { 3920e080b17aSJussi Kivilinna .alg = "ctr(des3_ede)", 3921e080b17aSJussi Kivilinna .test = alg_test_skcipher, 39220d8da104SMarcelo Cerri .fips_allowed = 1, 3923e080b17aSJussi Kivilinna .suite = { 392492a4c9feSEric Biggers .cipher = __VECS(des3_ede_ctr_tv_template) 3925e080b17aSJussi Kivilinna } 3926e080b17aSJussi Kivilinna }, { 3927a794d8d8SGilad Ben-Yossef /* Same as ctr(aes) except the key is stored in 3928a794d8d8SGilad Ben-Yossef * hardware secure memory which we reference by index 3929a794d8d8SGilad Ben-Yossef */ 3930a794d8d8SGilad Ben-Yossef .alg = "ctr(paes)", 3931a794d8d8SGilad Ben-Yossef .test = alg_test_null, 3932a794d8d8SGilad Ben-Yossef .fips_allowed = 1, 3933a794d8d8SGilad Ben-Yossef }, { 3934f0372c00SGilad Ben-Yossef 3935f0372c00SGilad Ben-Yossef /* Same as ctr(sm4) except the key is stored in 3936f0372c00SGilad Ben-Yossef * hardware secure memory which we reference by index 3937f0372c00SGilad Ben-Yossef */ 3938f0372c00SGilad Ben-Yossef .alg = "ctr(psm4)", 3939f0372c00SGilad Ben-Yossef .test = alg_test_null, 3940f0372c00SGilad Ben-Yossef }, { 39419d25917dSJussi Kivilinna .alg = "ctr(serpent)", 39429d25917dSJussi Kivilinna .test = alg_test_skcipher, 39439d25917dSJussi Kivilinna .suite = { 394492a4c9feSEric Biggers .cipher = __VECS(serpent_ctr_tv_template) 39459d25917dSJussi Kivilinna } 39469d25917dSJussi Kivilinna }, { 394795ba5973SGilad Ben-Yossef .alg = "ctr(sm4)", 394895ba5973SGilad Ben-Yossef .test = alg_test_skcipher, 394995ba5973SGilad Ben-Yossef .suite = { 395095ba5973SGilad Ben-Yossef .cipher = __VECS(sm4_ctr_tv_template) 395195ba5973SGilad Ben-Yossef } 395295ba5973SGilad Ben-Yossef }, { 3953573da620SJussi Kivilinna .alg = "ctr(twofish)", 3954573da620SJussi Kivilinna .test = alg_test_skcipher, 3955573da620SJussi Kivilinna .suite = { 395692a4c9feSEric Biggers .cipher = __VECS(tf_ctr_tv_template) 3957573da620SJussi Kivilinna } 3958573da620SJussi Kivilinna }, { 3959da7f033dSHerbert Xu .alg = "cts(cbc(aes))", 39601aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3961196ad604SGilad Ben-Yossef .fips_allowed = 1, 3962da7f033dSHerbert Xu .suite = { 396392a4c9feSEric Biggers .cipher = __VECS(cts_mode_tv_template) 3964da7f033dSHerbert Xu } 3965da7f033dSHerbert Xu }, { 3966f0372c00SGilad Ben-Yossef /* Same as cts(cbc((aes)) except the key is stored in 3967f0372c00SGilad Ben-Yossef * hardware secure memory which we reference by index 3968f0372c00SGilad Ben-Yossef */ 3969f0372c00SGilad Ben-Yossef .alg = "cts(cbc(paes))", 3970f0372c00SGilad Ben-Yossef .test = alg_test_null, 3971f0372c00SGilad Ben-Yossef .fips_allowed = 1, 3972f0372c00SGilad Ben-Yossef }, { 3973da7f033dSHerbert Xu .alg = "deflate", 3974da7f033dSHerbert Xu .test = alg_test_comp, 39750818904dSMilan Broz .fips_allowed = 1, 3976da7f033dSHerbert Xu .suite = { 3977da7f033dSHerbert Xu .comp = { 397821c8e720SArd Biesheuvel .comp = __VECS(deflate_comp_tv_template), 397921c8e720SArd Biesheuvel .decomp = __VECS(deflate_decomp_tv_template) 3980da7f033dSHerbert Xu } 3981da7f033dSHerbert Xu } 3982da7f033dSHerbert Xu }, { 3983802c7f1cSSalvatore Benedetto .alg = "dh", 3984802c7f1cSSalvatore Benedetto .test = alg_test_kpp, 3985802c7f1cSSalvatore Benedetto .fips_allowed = 1, 3986802c7f1cSSalvatore Benedetto .suite = { 398721c8e720SArd Biesheuvel .kpp = __VECS(dh_tv_template) 3988802c7f1cSSalvatore Benedetto } 3989802c7f1cSSalvatore Benedetto }, { 3990e448370dSJussi Kivilinna .alg = "digest_null", 3991e448370dSJussi Kivilinna .test = alg_test_null, 3992e448370dSJussi Kivilinna }, { 399364d1cdfbSStephan Mueller .alg = "drbg_nopr_ctr_aes128", 399464d1cdfbSStephan Mueller .test = alg_test_drbg, 399564d1cdfbSStephan Mueller .fips_allowed = 1, 399664d1cdfbSStephan Mueller .suite = { 399721c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_ctr_aes128_tv_template) 399864d1cdfbSStephan Mueller } 399964d1cdfbSStephan Mueller }, { 400064d1cdfbSStephan Mueller .alg = "drbg_nopr_ctr_aes192", 400164d1cdfbSStephan Mueller .test = alg_test_drbg, 400264d1cdfbSStephan Mueller .fips_allowed = 1, 400364d1cdfbSStephan Mueller .suite = { 400421c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_ctr_aes192_tv_template) 400564d1cdfbSStephan Mueller } 400664d1cdfbSStephan Mueller }, { 400764d1cdfbSStephan Mueller .alg = "drbg_nopr_ctr_aes256", 400864d1cdfbSStephan Mueller .test = alg_test_drbg, 400964d1cdfbSStephan Mueller .fips_allowed = 1, 401064d1cdfbSStephan Mueller .suite = { 401121c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_ctr_aes256_tv_template) 401264d1cdfbSStephan Mueller } 401364d1cdfbSStephan Mueller }, { 401464d1cdfbSStephan Mueller /* 401564d1cdfbSStephan Mueller * There is no need to specifically test the DRBG with every 401664d1cdfbSStephan Mueller * backend cipher -- covered by drbg_nopr_hmac_sha256 test 401764d1cdfbSStephan Mueller */ 401864d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha1", 401964d1cdfbSStephan Mueller .fips_allowed = 1, 402064d1cdfbSStephan Mueller .test = alg_test_null, 402164d1cdfbSStephan Mueller }, { 402264d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha256", 402364d1cdfbSStephan Mueller .test = alg_test_drbg, 402464d1cdfbSStephan Mueller .fips_allowed = 1, 402564d1cdfbSStephan Mueller .suite = { 402621c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_hmac_sha256_tv_template) 402764d1cdfbSStephan Mueller } 402864d1cdfbSStephan Mueller }, { 402964d1cdfbSStephan Mueller /* covered by drbg_nopr_hmac_sha256 test */ 403064d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha384", 403164d1cdfbSStephan Mueller .fips_allowed = 1, 403264d1cdfbSStephan Mueller .test = alg_test_null, 403364d1cdfbSStephan Mueller }, { 403464d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha512", 403564d1cdfbSStephan Mueller .test = alg_test_null, 403664d1cdfbSStephan Mueller .fips_allowed = 1, 403764d1cdfbSStephan Mueller }, { 403864d1cdfbSStephan Mueller .alg = "drbg_nopr_sha1", 403964d1cdfbSStephan Mueller .fips_allowed = 1, 404064d1cdfbSStephan Mueller .test = alg_test_null, 404164d1cdfbSStephan Mueller }, { 404264d1cdfbSStephan Mueller .alg = "drbg_nopr_sha256", 404364d1cdfbSStephan Mueller .test = alg_test_drbg, 404464d1cdfbSStephan Mueller .fips_allowed = 1, 404564d1cdfbSStephan Mueller .suite = { 404621c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_sha256_tv_template) 404764d1cdfbSStephan Mueller } 404864d1cdfbSStephan Mueller }, { 404964d1cdfbSStephan Mueller /* covered by drbg_nopr_sha256 test */ 405064d1cdfbSStephan Mueller .alg = "drbg_nopr_sha384", 405164d1cdfbSStephan Mueller .fips_allowed = 1, 405264d1cdfbSStephan Mueller .test = alg_test_null, 405364d1cdfbSStephan Mueller }, { 405464d1cdfbSStephan Mueller .alg = "drbg_nopr_sha512", 405564d1cdfbSStephan Mueller .fips_allowed = 1, 405664d1cdfbSStephan Mueller .test = alg_test_null, 405764d1cdfbSStephan Mueller }, { 405864d1cdfbSStephan Mueller .alg = "drbg_pr_ctr_aes128", 405964d1cdfbSStephan Mueller .test = alg_test_drbg, 406064d1cdfbSStephan Mueller .fips_allowed = 1, 406164d1cdfbSStephan Mueller .suite = { 406221c8e720SArd Biesheuvel .drbg = __VECS(drbg_pr_ctr_aes128_tv_template) 406364d1cdfbSStephan Mueller } 406464d1cdfbSStephan Mueller }, { 406564d1cdfbSStephan Mueller /* covered by drbg_pr_ctr_aes128 test */ 406664d1cdfbSStephan Mueller .alg = "drbg_pr_ctr_aes192", 406764d1cdfbSStephan Mueller .fips_allowed = 1, 406864d1cdfbSStephan Mueller .test = alg_test_null, 406964d1cdfbSStephan Mueller }, { 407064d1cdfbSStephan Mueller .alg = "drbg_pr_ctr_aes256", 407164d1cdfbSStephan Mueller .fips_allowed = 1, 407264d1cdfbSStephan Mueller .test = alg_test_null, 407364d1cdfbSStephan Mueller }, { 407464d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha1", 407564d1cdfbSStephan Mueller .fips_allowed = 1, 407664d1cdfbSStephan Mueller .test = alg_test_null, 407764d1cdfbSStephan Mueller }, { 407864d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha256", 407964d1cdfbSStephan Mueller .test = alg_test_drbg, 408064d1cdfbSStephan Mueller .fips_allowed = 1, 408164d1cdfbSStephan Mueller .suite = { 408221c8e720SArd Biesheuvel .drbg = __VECS(drbg_pr_hmac_sha256_tv_template) 408364d1cdfbSStephan Mueller } 408464d1cdfbSStephan Mueller }, { 408564d1cdfbSStephan Mueller /* covered by drbg_pr_hmac_sha256 test */ 408664d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha384", 408764d1cdfbSStephan Mueller .fips_allowed = 1, 408864d1cdfbSStephan Mueller .test = alg_test_null, 408964d1cdfbSStephan Mueller }, { 409064d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha512", 409164d1cdfbSStephan Mueller .test = alg_test_null, 409264d1cdfbSStephan Mueller .fips_allowed = 1, 409364d1cdfbSStephan Mueller }, { 409464d1cdfbSStephan Mueller .alg = "drbg_pr_sha1", 409564d1cdfbSStephan Mueller .fips_allowed = 1, 409664d1cdfbSStephan Mueller .test = alg_test_null, 409764d1cdfbSStephan Mueller }, { 409864d1cdfbSStephan Mueller .alg = "drbg_pr_sha256", 409964d1cdfbSStephan Mueller .test = alg_test_drbg, 410064d1cdfbSStephan Mueller .fips_allowed = 1, 410164d1cdfbSStephan Mueller .suite = { 410221c8e720SArd Biesheuvel .drbg = __VECS(drbg_pr_sha256_tv_template) 410364d1cdfbSStephan Mueller } 410464d1cdfbSStephan Mueller }, { 410564d1cdfbSStephan Mueller /* covered by drbg_pr_sha256 test */ 410664d1cdfbSStephan Mueller .alg = "drbg_pr_sha384", 410764d1cdfbSStephan Mueller .fips_allowed = 1, 410864d1cdfbSStephan Mueller .test = alg_test_null, 410964d1cdfbSStephan Mueller }, { 411064d1cdfbSStephan Mueller .alg = "drbg_pr_sha512", 411164d1cdfbSStephan Mueller .fips_allowed = 1, 411264d1cdfbSStephan Mueller .test = alg_test_null, 411364d1cdfbSStephan Mueller }, { 4114da7f033dSHerbert Xu .alg = "ecb(aes)", 41151aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4116a1915d51SJarod Wilson .fips_allowed = 1, 4117da7f033dSHerbert Xu .suite = { 411892a4c9feSEric Biggers .cipher = __VECS(aes_tv_template) 4119da7f033dSHerbert Xu } 4120da7f033dSHerbert Xu }, { 4121da7f033dSHerbert Xu .alg = "ecb(anubis)", 41221aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4123da7f033dSHerbert Xu .suite = { 412492a4c9feSEric Biggers .cipher = __VECS(anubis_tv_template) 4125da7f033dSHerbert Xu } 4126da7f033dSHerbert Xu }, { 4127da7f033dSHerbert Xu .alg = "ecb(arc4)", 41281aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4129da7f033dSHerbert Xu .suite = { 413092a4c9feSEric Biggers .cipher = __VECS(arc4_tv_template) 4131da7f033dSHerbert Xu } 4132da7f033dSHerbert Xu }, { 4133da7f033dSHerbert Xu .alg = "ecb(blowfish)", 41341aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4135da7f033dSHerbert Xu .suite = { 413692a4c9feSEric Biggers .cipher = __VECS(bf_tv_template) 4137da7f033dSHerbert Xu } 4138da7f033dSHerbert Xu }, { 4139da7f033dSHerbert Xu .alg = "ecb(camellia)", 41401aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4141da7f033dSHerbert Xu .suite = { 414292a4c9feSEric Biggers .cipher = __VECS(camellia_tv_template) 4143da7f033dSHerbert Xu } 4144da7f033dSHerbert Xu }, { 4145da7f033dSHerbert Xu .alg = "ecb(cast5)", 41461aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4147da7f033dSHerbert Xu .suite = { 414892a4c9feSEric Biggers .cipher = __VECS(cast5_tv_template) 4149da7f033dSHerbert Xu } 4150da7f033dSHerbert Xu }, { 4151da7f033dSHerbert Xu .alg = "ecb(cast6)", 41521aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4153da7f033dSHerbert Xu .suite = { 415492a4c9feSEric Biggers .cipher = __VECS(cast6_tv_template) 4155da7f033dSHerbert Xu } 4156da7f033dSHerbert Xu }, { 4157e448370dSJussi Kivilinna .alg = "ecb(cipher_null)", 4158e448370dSJussi Kivilinna .test = alg_test_null, 41596175ca2bSMilan Broz .fips_allowed = 1, 4160e448370dSJussi Kivilinna }, { 4161da7f033dSHerbert Xu .alg = "ecb(des)", 41621aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4163da7f033dSHerbert Xu .suite = { 416492a4c9feSEric Biggers .cipher = __VECS(des_tv_template) 4165da7f033dSHerbert Xu } 4166da7f033dSHerbert Xu }, { 4167da7f033dSHerbert Xu .alg = "ecb(des3_ede)", 41681aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4169a1915d51SJarod Wilson .fips_allowed = 1, 4170da7f033dSHerbert Xu .suite = { 417192a4c9feSEric Biggers .cipher = __VECS(des3_ede_tv_template) 4172da7f033dSHerbert Xu } 4173da7f033dSHerbert Xu }, { 417466e5bd00SJussi Kivilinna .alg = "ecb(fcrypt)", 417566e5bd00SJussi Kivilinna .test = alg_test_skcipher, 417666e5bd00SJussi Kivilinna .suite = { 417766e5bd00SJussi Kivilinna .cipher = { 417892a4c9feSEric Biggers .vecs = fcrypt_pcbc_tv_template, 417966e5bd00SJussi Kivilinna .count = 1 418066e5bd00SJussi Kivilinna } 418166e5bd00SJussi Kivilinna } 418266e5bd00SJussi Kivilinna }, { 4183da7f033dSHerbert Xu .alg = "ecb(khazad)", 41841aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4185da7f033dSHerbert Xu .suite = { 418692a4c9feSEric Biggers .cipher = __VECS(khazad_tv_template) 4187da7f033dSHerbert Xu } 4188da7f033dSHerbert Xu }, { 418915f47ce5SGilad Ben-Yossef /* Same as ecb(aes) except the key is stored in 419015f47ce5SGilad Ben-Yossef * hardware secure memory which we reference by index 419115f47ce5SGilad Ben-Yossef */ 419215f47ce5SGilad Ben-Yossef .alg = "ecb(paes)", 419315f47ce5SGilad Ben-Yossef .test = alg_test_null, 419415f47ce5SGilad Ben-Yossef .fips_allowed = 1, 419515f47ce5SGilad Ben-Yossef }, { 4196da7f033dSHerbert Xu .alg = "ecb(seed)", 41971aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4198da7f033dSHerbert Xu .suite = { 419992a4c9feSEric Biggers .cipher = __VECS(seed_tv_template) 4200da7f033dSHerbert Xu } 4201da7f033dSHerbert Xu }, { 4202da7f033dSHerbert Xu .alg = "ecb(serpent)", 42031aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4204da7f033dSHerbert Xu .suite = { 420592a4c9feSEric Biggers .cipher = __VECS(serpent_tv_template) 4206da7f033dSHerbert Xu } 4207da7f033dSHerbert Xu }, { 4208cd83a8a7SGilad Ben-Yossef .alg = "ecb(sm4)", 4209cd83a8a7SGilad Ben-Yossef .test = alg_test_skcipher, 4210cd83a8a7SGilad Ben-Yossef .suite = { 421192a4c9feSEric Biggers .cipher = __VECS(sm4_tv_template) 4212cd83a8a7SGilad Ben-Yossef } 4213cd83a8a7SGilad Ben-Yossef }, { 4214da7f033dSHerbert Xu .alg = "ecb(tea)", 42151aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4216da7f033dSHerbert Xu .suite = { 421792a4c9feSEric Biggers .cipher = __VECS(tea_tv_template) 4218da7f033dSHerbert Xu } 4219da7f033dSHerbert Xu }, { 4220da7f033dSHerbert Xu .alg = "ecb(tnepres)", 42211aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4222da7f033dSHerbert Xu .suite = { 422392a4c9feSEric Biggers .cipher = __VECS(tnepres_tv_template) 4224da7f033dSHerbert Xu } 4225da7f033dSHerbert Xu }, { 4226da7f033dSHerbert Xu .alg = "ecb(twofish)", 42271aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4228da7f033dSHerbert Xu .suite = { 422992a4c9feSEric Biggers .cipher = __VECS(tf_tv_template) 4230da7f033dSHerbert Xu } 4231da7f033dSHerbert Xu }, { 4232da7f033dSHerbert Xu .alg = "ecb(xeta)", 42331aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4234da7f033dSHerbert Xu .suite = { 423592a4c9feSEric Biggers .cipher = __VECS(xeta_tv_template) 4236da7f033dSHerbert Xu } 4237da7f033dSHerbert Xu }, { 4238da7f033dSHerbert Xu .alg = "ecb(xtea)", 42391aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4240da7f033dSHerbert Xu .suite = { 424192a4c9feSEric Biggers .cipher = __VECS(xtea_tv_template) 4242da7f033dSHerbert Xu } 4243da7f033dSHerbert Xu }, { 42443c4b2390SSalvatore Benedetto .alg = "ecdh", 42453c4b2390SSalvatore Benedetto .test = alg_test_kpp, 42463c4b2390SSalvatore Benedetto .fips_allowed = 1, 42473c4b2390SSalvatore Benedetto .suite = { 424821c8e720SArd Biesheuvel .kpp = __VECS(ecdh_tv_template) 42493c4b2390SSalvatore Benedetto } 42503c4b2390SSalvatore Benedetto }, { 425132fbdbd3SVitaly Chikunov .alg = "ecrdsa", 425232fbdbd3SVitaly Chikunov .test = alg_test_akcipher, 425332fbdbd3SVitaly Chikunov .suite = { 425432fbdbd3SVitaly Chikunov .akcipher = __VECS(ecrdsa_tv_template) 425532fbdbd3SVitaly Chikunov } 425632fbdbd3SVitaly Chikunov }, { 4257da7f033dSHerbert Xu .alg = "gcm(aes)", 425840153b10SEric Biggers .generic_driver = "gcm_base(ctr(aes-generic),ghash-generic)", 4259da7f033dSHerbert Xu .test = alg_test_aead, 4260a1915d51SJarod Wilson .fips_allowed = 1, 4261da7f033dSHerbert Xu .suite = { 4262a0d608eeSEric Biggers .aead = __VECS(aes_gcm_tv_template) 4263da7f033dSHerbert Xu } 4264da7f033dSHerbert Xu }, { 4265507069c9SYouquan, Song .alg = "ghash", 4266507069c9SYouquan, Song .test = alg_test_hash, 426718c0ebd2SJarod Wilson .fips_allowed = 1, 4268507069c9SYouquan, Song .suite = { 426921c8e720SArd Biesheuvel .hash = __VECS(ghash_tv_template) 4270507069c9SYouquan, Song } 4271507069c9SYouquan, Song }, { 4272da7f033dSHerbert Xu .alg = "hmac(md5)", 4273da7f033dSHerbert Xu .test = alg_test_hash, 4274da7f033dSHerbert Xu .suite = { 427521c8e720SArd Biesheuvel .hash = __VECS(hmac_md5_tv_template) 4276da7f033dSHerbert Xu } 4277da7f033dSHerbert Xu }, { 4278da7f033dSHerbert Xu .alg = "hmac(rmd128)", 4279da7f033dSHerbert Xu .test = alg_test_hash, 4280da7f033dSHerbert Xu .suite = { 428121c8e720SArd Biesheuvel .hash = __VECS(hmac_rmd128_tv_template) 4282da7f033dSHerbert Xu } 4283da7f033dSHerbert Xu }, { 4284da7f033dSHerbert Xu .alg = "hmac(rmd160)", 4285da7f033dSHerbert Xu .test = alg_test_hash, 4286da7f033dSHerbert Xu .suite = { 428721c8e720SArd Biesheuvel .hash = __VECS(hmac_rmd160_tv_template) 4288da7f033dSHerbert Xu } 4289da7f033dSHerbert Xu }, { 4290da7f033dSHerbert Xu .alg = "hmac(sha1)", 4291da7f033dSHerbert Xu .test = alg_test_hash, 4292a1915d51SJarod Wilson .fips_allowed = 1, 4293da7f033dSHerbert Xu .suite = { 429421c8e720SArd Biesheuvel .hash = __VECS(hmac_sha1_tv_template) 4295da7f033dSHerbert Xu } 4296da7f033dSHerbert Xu }, { 4297da7f033dSHerbert Xu .alg = "hmac(sha224)", 4298da7f033dSHerbert Xu .test = alg_test_hash, 4299a1915d51SJarod Wilson .fips_allowed = 1, 4300da7f033dSHerbert Xu .suite = { 430121c8e720SArd Biesheuvel .hash = __VECS(hmac_sha224_tv_template) 4302da7f033dSHerbert Xu } 4303da7f033dSHerbert Xu }, { 4304da7f033dSHerbert Xu .alg = "hmac(sha256)", 4305da7f033dSHerbert Xu .test = alg_test_hash, 4306a1915d51SJarod Wilson .fips_allowed = 1, 4307da7f033dSHerbert Xu .suite = { 430821c8e720SArd Biesheuvel .hash = __VECS(hmac_sha256_tv_template) 4309da7f033dSHerbert Xu } 4310da7f033dSHerbert Xu }, { 431198eca72fSraveendra padasalagi .alg = "hmac(sha3-224)", 431298eca72fSraveendra padasalagi .test = alg_test_hash, 431398eca72fSraveendra padasalagi .fips_allowed = 1, 431498eca72fSraveendra padasalagi .suite = { 431521c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_224_tv_template) 431698eca72fSraveendra padasalagi } 431798eca72fSraveendra padasalagi }, { 431898eca72fSraveendra padasalagi .alg = "hmac(sha3-256)", 431998eca72fSraveendra padasalagi .test = alg_test_hash, 432098eca72fSraveendra padasalagi .fips_allowed = 1, 432198eca72fSraveendra padasalagi .suite = { 432221c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_256_tv_template) 432398eca72fSraveendra padasalagi } 432498eca72fSraveendra padasalagi }, { 432598eca72fSraveendra padasalagi .alg = "hmac(sha3-384)", 432698eca72fSraveendra padasalagi .test = alg_test_hash, 432798eca72fSraveendra padasalagi .fips_allowed = 1, 432898eca72fSraveendra padasalagi .suite = { 432921c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_384_tv_template) 433098eca72fSraveendra padasalagi } 433198eca72fSraveendra padasalagi }, { 433298eca72fSraveendra padasalagi .alg = "hmac(sha3-512)", 433398eca72fSraveendra padasalagi .test = alg_test_hash, 433498eca72fSraveendra padasalagi .fips_allowed = 1, 433598eca72fSraveendra padasalagi .suite = { 433621c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_512_tv_template) 433798eca72fSraveendra padasalagi } 433898eca72fSraveendra padasalagi }, { 4339da7f033dSHerbert Xu .alg = "hmac(sha384)", 4340da7f033dSHerbert Xu .test = alg_test_hash, 4341a1915d51SJarod Wilson .fips_allowed = 1, 4342da7f033dSHerbert Xu .suite = { 434321c8e720SArd Biesheuvel .hash = __VECS(hmac_sha384_tv_template) 4344da7f033dSHerbert Xu } 4345da7f033dSHerbert Xu }, { 4346da7f033dSHerbert Xu .alg = "hmac(sha512)", 4347da7f033dSHerbert Xu .test = alg_test_hash, 4348a1915d51SJarod Wilson .fips_allowed = 1, 4349da7f033dSHerbert Xu .suite = { 435021c8e720SArd Biesheuvel .hash = __VECS(hmac_sha512_tv_template) 4351da7f033dSHerbert Xu } 4352da7f033dSHerbert Xu }, { 435325a0b9d4SVitaly Chikunov .alg = "hmac(streebog256)", 435425a0b9d4SVitaly Chikunov .test = alg_test_hash, 435525a0b9d4SVitaly Chikunov .suite = { 435625a0b9d4SVitaly Chikunov .hash = __VECS(hmac_streebog256_tv_template) 435725a0b9d4SVitaly Chikunov } 435825a0b9d4SVitaly Chikunov }, { 435925a0b9d4SVitaly Chikunov .alg = "hmac(streebog512)", 436025a0b9d4SVitaly Chikunov .test = alg_test_hash, 436125a0b9d4SVitaly Chikunov .suite = { 436225a0b9d4SVitaly Chikunov .hash = __VECS(hmac_streebog512_tv_template) 436325a0b9d4SVitaly Chikunov } 436425a0b9d4SVitaly Chikunov }, { 4365bb5530e4SStephan Mueller .alg = "jitterentropy_rng", 4366bb5530e4SStephan Mueller .fips_allowed = 1, 4367bb5530e4SStephan Mueller .test = alg_test_null, 4368bb5530e4SStephan Mueller }, { 436935351988SStephan Mueller .alg = "kw(aes)", 437035351988SStephan Mueller .test = alg_test_skcipher, 437135351988SStephan Mueller .fips_allowed = 1, 437235351988SStephan Mueller .suite = { 437392a4c9feSEric Biggers .cipher = __VECS(aes_kw_tv_template) 437435351988SStephan Mueller } 437535351988SStephan Mueller }, { 4376da7f033dSHerbert Xu .alg = "lrw(aes)", 4377d435e10eSEric Biggers .generic_driver = "lrw(ecb(aes-generic))", 43781aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4379da7f033dSHerbert Xu .suite = { 438092a4c9feSEric Biggers .cipher = __VECS(aes_lrw_tv_template) 4381da7f033dSHerbert Xu } 4382da7f033dSHerbert Xu }, { 43830840605eSJussi Kivilinna .alg = "lrw(camellia)", 4384d435e10eSEric Biggers .generic_driver = "lrw(ecb(camellia-generic))", 43850840605eSJussi Kivilinna .test = alg_test_skcipher, 43860840605eSJussi Kivilinna .suite = { 438792a4c9feSEric Biggers .cipher = __VECS(camellia_lrw_tv_template) 43880840605eSJussi Kivilinna } 43890840605eSJussi Kivilinna }, { 43909b8b0405SJohannes Goetzfried .alg = "lrw(cast6)", 4391d435e10eSEric Biggers .generic_driver = "lrw(ecb(cast6-generic))", 43929b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 43939b8b0405SJohannes Goetzfried .suite = { 439492a4c9feSEric Biggers .cipher = __VECS(cast6_lrw_tv_template) 43959b8b0405SJohannes Goetzfried } 43969b8b0405SJohannes Goetzfried }, { 4397d7bfc0faSJussi Kivilinna .alg = "lrw(serpent)", 4398d435e10eSEric Biggers .generic_driver = "lrw(ecb(serpent-generic))", 4399d7bfc0faSJussi Kivilinna .test = alg_test_skcipher, 4400d7bfc0faSJussi Kivilinna .suite = { 440192a4c9feSEric Biggers .cipher = __VECS(serpent_lrw_tv_template) 4402d7bfc0faSJussi Kivilinna } 4403d7bfc0faSJussi Kivilinna }, { 44040b2a1551SJussi Kivilinna .alg = "lrw(twofish)", 4405d435e10eSEric Biggers .generic_driver = "lrw(ecb(twofish-generic))", 44060b2a1551SJussi Kivilinna .test = alg_test_skcipher, 44070b2a1551SJussi Kivilinna .suite = { 440892a4c9feSEric Biggers .cipher = __VECS(tf_lrw_tv_template) 44090b2a1551SJussi Kivilinna } 44100b2a1551SJussi Kivilinna }, { 44111443cc9bSKOVACS Krisztian .alg = "lz4", 44121443cc9bSKOVACS Krisztian .test = alg_test_comp, 44131443cc9bSKOVACS Krisztian .fips_allowed = 1, 44141443cc9bSKOVACS Krisztian .suite = { 44151443cc9bSKOVACS Krisztian .comp = { 441621c8e720SArd Biesheuvel .comp = __VECS(lz4_comp_tv_template), 441721c8e720SArd Biesheuvel .decomp = __VECS(lz4_decomp_tv_template) 44181443cc9bSKOVACS Krisztian } 44191443cc9bSKOVACS Krisztian } 44201443cc9bSKOVACS Krisztian }, { 44211443cc9bSKOVACS Krisztian .alg = "lz4hc", 44221443cc9bSKOVACS Krisztian .test = alg_test_comp, 44231443cc9bSKOVACS Krisztian .fips_allowed = 1, 44241443cc9bSKOVACS Krisztian .suite = { 44251443cc9bSKOVACS Krisztian .comp = { 442621c8e720SArd Biesheuvel .comp = __VECS(lz4hc_comp_tv_template), 442721c8e720SArd Biesheuvel .decomp = __VECS(lz4hc_decomp_tv_template) 44281443cc9bSKOVACS Krisztian } 44291443cc9bSKOVACS Krisztian } 44301443cc9bSKOVACS Krisztian }, { 4431da7f033dSHerbert Xu .alg = "lzo", 4432da7f033dSHerbert Xu .test = alg_test_comp, 44330818904dSMilan Broz .fips_allowed = 1, 4434da7f033dSHerbert Xu .suite = { 4435da7f033dSHerbert Xu .comp = { 443621c8e720SArd Biesheuvel .comp = __VECS(lzo_comp_tv_template), 443721c8e720SArd Biesheuvel .decomp = __VECS(lzo_decomp_tv_template) 4438da7f033dSHerbert Xu } 4439da7f033dSHerbert Xu } 4440da7f033dSHerbert Xu }, { 4441da7f033dSHerbert Xu .alg = "md4", 4442da7f033dSHerbert Xu .test = alg_test_hash, 4443da7f033dSHerbert Xu .suite = { 444421c8e720SArd Biesheuvel .hash = __VECS(md4_tv_template) 4445da7f033dSHerbert Xu } 4446da7f033dSHerbert Xu }, { 4447da7f033dSHerbert Xu .alg = "md5", 4448da7f033dSHerbert Xu .test = alg_test_hash, 4449da7f033dSHerbert Xu .suite = { 445021c8e720SArd Biesheuvel .hash = __VECS(md5_tv_template) 4451da7f033dSHerbert Xu } 4452da7f033dSHerbert Xu }, { 4453da7f033dSHerbert Xu .alg = "michael_mic", 4454da7f033dSHerbert Xu .test = alg_test_hash, 4455da7f033dSHerbert Xu .suite = { 445621c8e720SArd Biesheuvel .hash = __VECS(michael_mic_tv_template) 4457da7f033dSHerbert Xu } 4458da7f033dSHerbert Xu }, { 44594feb4c59SOndrej Mosnacek .alg = "morus1280", 44604feb4c59SOndrej Mosnacek .test = alg_test_aead, 44614feb4c59SOndrej Mosnacek .suite = { 4462a0d608eeSEric Biggers .aead = __VECS(morus1280_tv_template) 44634feb4c59SOndrej Mosnacek } 44644feb4c59SOndrej Mosnacek }, { 44654feb4c59SOndrej Mosnacek .alg = "morus640", 44664feb4c59SOndrej Mosnacek .test = alg_test_aead, 44674feb4c59SOndrej Mosnacek .suite = { 4468a0d608eeSEric Biggers .aead = __VECS(morus640_tv_template) 44694feb4c59SOndrej Mosnacek } 44704feb4c59SOndrej Mosnacek }, { 447126609a21SEric Biggers .alg = "nhpoly1305", 447226609a21SEric Biggers .test = alg_test_hash, 447326609a21SEric Biggers .suite = { 447426609a21SEric Biggers .hash = __VECS(nhpoly1305_tv_template) 447526609a21SEric Biggers } 447626609a21SEric Biggers }, { 4477ba0e14acSPuneet Saxena .alg = "ofb(aes)", 4478ba0e14acSPuneet Saxena .test = alg_test_skcipher, 4479ba0e14acSPuneet Saxena .fips_allowed = 1, 4480ba0e14acSPuneet Saxena .suite = { 448192a4c9feSEric Biggers .cipher = __VECS(aes_ofb_tv_template) 4482ba0e14acSPuneet Saxena } 4483ba0e14acSPuneet Saxena }, { 4484a794d8d8SGilad Ben-Yossef /* Same as ofb(aes) except the key is stored in 4485a794d8d8SGilad Ben-Yossef * hardware secure memory which we reference by index 4486a794d8d8SGilad Ben-Yossef */ 4487a794d8d8SGilad Ben-Yossef .alg = "ofb(paes)", 4488a794d8d8SGilad Ben-Yossef .test = alg_test_null, 4489a794d8d8SGilad Ben-Yossef .fips_allowed = 1, 4490a794d8d8SGilad Ben-Yossef }, { 4491da7f033dSHerbert Xu .alg = "pcbc(fcrypt)", 44921aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4493da7f033dSHerbert Xu .suite = { 449492a4c9feSEric Biggers .cipher = __VECS(fcrypt_pcbc_tv_template) 4495da7f033dSHerbert Xu } 4496da7f033dSHerbert Xu }, { 44971207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha224)", 44981207107cSStephan Mueller .test = alg_test_null, 44991207107cSStephan Mueller .fips_allowed = 1, 45001207107cSStephan Mueller }, { 45011207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha256)", 45021207107cSStephan Mueller .test = alg_test_akcipher, 45031207107cSStephan Mueller .fips_allowed = 1, 45041207107cSStephan Mueller .suite = { 45051207107cSStephan Mueller .akcipher = __VECS(pkcs1pad_rsa_tv_template) 45061207107cSStephan Mueller } 45071207107cSStephan Mueller }, { 45081207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha384)", 45091207107cSStephan Mueller .test = alg_test_null, 45101207107cSStephan Mueller .fips_allowed = 1, 45111207107cSStephan Mueller }, { 45121207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha512)", 45131207107cSStephan Mueller .test = alg_test_null, 45141207107cSStephan Mueller .fips_allowed = 1, 45151207107cSStephan Mueller }, { 4516eee9dc61SMartin Willi .alg = "poly1305", 4517eee9dc61SMartin Willi .test = alg_test_hash, 4518eee9dc61SMartin Willi .suite = { 451921c8e720SArd Biesheuvel .hash = __VECS(poly1305_tv_template) 4520eee9dc61SMartin Willi } 4521eee9dc61SMartin Willi }, { 4522da7f033dSHerbert Xu .alg = "rfc3686(ctr(aes))", 45231aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4524a1915d51SJarod Wilson .fips_allowed = 1, 4525da7f033dSHerbert Xu .suite = { 452692a4c9feSEric Biggers .cipher = __VECS(aes_ctr_rfc3686_tv_template) 4527da7f033dSHerbert Xu } 4528da7f033dSHerbert Xu }, { 45293f31a740SHerbert Xu .alg = "rfc4106(gcm(aes))", 453040153b10SEric Biggers .generic_driver = "rfc4106(gcm_base(ctr(aes-generic),ghash-generic))", 453169435b94SAdrian Hoban .test = alg_test_aead, 4532db71f29aSJarod Wilson .fips_allowed = 1, 453369435b94SAdrian Hoban .suite = { 4534a0d608eeSEric Biggers .aead = __VECS(aes_gcm_rfc4106_tv_template) 453569435b94SAdrian Hoban } 453669435b94SAdrian Hoban }, { 4537544c436aSHerbert Xu .alg = "rfc4309(ccm(aes))", 453840153b10SEric Biggers .generic_driver = "rfc4309(ccm_base(ctr(aes-generic),cbcmac(aes-generic)))", 45395d667322SJarod Wilson .test = alg_test_aead, 4540a1915d51SJarod Wilson .fips_allowed = 1, 45415d667322SJarod Wilson .suite = { 4542a0d608eeSEric Biggers .aead = __VECS(aes_ccm_rfc4309_tv_template) 45435d667322SJarod Wilson } 45445d667322SJarod Wilson }, { 4545bb68745eSHerbert Xu .alg = "rfc4543(gcm(aes))", 454640153b10SEric Biggers .generic_driver = "rfc4543(gcm_base(ctr(aes-generic),ghash-generic))", 4547e9b7441aSJussi Kivilinna .test = alg_test_aead, 4548e9b7441aSJussi Kivilinna .suite = { 4549a0d608eeSEric Biggers .aead = __VECS(aes_gcm_rfc4543_tv_template) 4550e9b7441aSJussi Kivilinna } 4551e9b7441aSJussi Kivilinna }, { 4552af2b76b5SMartin Willi .alg = "rfc7539(chacha20,poly1305)", 4553af2b76b5SMartin Willi .test = alg_test_aead, 4554af2b76b5SMartin Willi .suite = { 4555a0d608eeSEric Biggers .aead = __VECS(rfc7539_tv_template) 4556af2b76b5SMartin Willi } 4557af2b76b5SMartin Willi }, { 45585900758dSMartin Willi .alg = "rfc7539esp(chacha20,poly1305)", 45595900758dSMartin Willi .test = alg_test_aead, 45605900758dSMartin Willi .suite = { 4561a0d608eeSEric Biggers .aead = __VECS(rfc7539esp_tv_template) 45625900758dSMartin Willi } 45635900758dSMartin Willi }, { 4564da7f033dSHerbert Xu .alg = "rmd128", 4565da7f033dSHerbert Xu .test = alg_test_hash, 4566da7f033dSHerbert Xu .suite = { 456721c8e720SArd Biesheuvel .hash = __VECS(rmd128_tv_template) 4568da7f033dSHerbert Xu } 4569da7f033dSHerbert Xu }, { 4570da7f033dSHerbert Xu .alg = "rmd160", 4571da7f033dSHerbert Xu .test = alg_test_hash, 4572da7f033dSHerbert Xu .suite = { 457321c8e720SArd Biesheuvel .hash = __VECS(rmd160_tv_template) 4574da7f033dSHerbert Xu } 4575da7f033dSHerbert Xu }, { 4576da7f033dSHerbert Xu .alg = "rmd256", 4577da7f033dSHerbert Xu .test = alg_test_hash, 4578da7f033dSHerbert Xu .suite = { 457921c8e720SArd Biesheuvel .hash = __VECS(rmd256_tv_template) 4580da7f033dSHerbert Xu } 4581da7f033dSHerbert Xu }, { 4582da7f033dSHerbert Xu .alg = "rmd320", 4583da7f033dSHerbert Xu .test = alg_test_hash, 4584da7f033dSHerbert Xu .suite = { 458521c8e720SArd Biesheuvel .hash = __VECS(rmd320_tv_template) 4586da7f033dSHerbert Xu } 4587da7f033dSHerbert Xu }, { 4588946cc463STadeusz Struk .alg = "rsa", 4589946cc463STadeusz Struk .test = alg_test_akcipher, 4590946cc463STadeusz Struk .fips_allowed = 1, 4591946cc463STadeusz Struk .suite = { 459221c8e720SArd Biesheuvel .akcipher = __VECS(rsa_tv_template) 4593946cc463STadeusz Struk } 4594946cc463STadeusz Struk }, { 4595da7f033dSHerbert Xu .alg = "salsa20", 45961aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4597da7f033dSHerbert Xu .suite = { 459892a4c9feSEric Biggers .cipher = __VECS(salsa20_stream_tv_template) 4599da7f033dSHerbert Xu } 4600da7f033dSHerbert Xu }, { 4601da7f033dSHerbert Xu .alg = "sha1", 4602da7f033dSHerbert Xu .test = alg_test_hash, 4603a1915d51SJarod Wilson .fips_allowed = 1, 4604da7f033dSHerbert Xu .suite = { 460521c8e720SArd Biesheuvel .hash = __VECS(sha1_tv_template) 4606da7f033dSHerbert Xu } 4607da7f033dSHerbert Xu }, { 4608da7f033dSHerbert Xu .alg = "sha224", 4609da7f033dSHerbert Xu .test = alg_test_hash, 4610a1915d51SJarod Wilson .fips_allowed = 1, 4611da7f033dSHerbert Xu .suite = { 461221c8e720SArd Biesheuvel .hash = __VECS(sha224_tv_template) 4613da7f033dSHerbert Xu } 4614da7f033dSHerbert Xu }, { 4615da7f033dSHerbert Xu .alg = "sha256", 4616da7f033dSHerbert Xu .test = alg_test_hash, 4617a1915d51SJarod Wilson .fips_allowed = 1, 4618da7f033dSHerbert Xu .suite = { 461921c8e720SArd Biesheuvel .hash = __VECS(sha256_tv_template) 4620da7f033dSHerbert Xu } 4621da7f033dSHerbert Xu }, { 462279cc6ab8Sraveendra padasalagi .alg = "sha3-224", 462379cc6ab8Sraveendra padasalagi .test = alg_test_hash, 462479cc6ab8Sraveendra padasalagi .fips_allowed = 1, 462579cc6ab8Sraveendra padasalagi .suite = { 462621c8e720SArd Biesheuvel .hash = __VECS(sha3_224_tv_template) 462779cc6ab8Sraveendra padasalagi } 462879cc6ab8Sraveendra padasalagi }, { 462979cc6ab8Sraveendra padasalagi .alg = "sha3-256", 463079cc6ab8Sraveendra padasalagi .test = alg_test_hash, 463179cc6ab8Sraveendra padasalagi .fips_allowed = 1, 463279cc6ab8Sraveendra padasalagi .suite = { 463321c8e720SArd Biesheuvel .hash = __VECS(sha3_256_tv_template) 463479cc6ab8Sraveendra padasalagi } 463579cc6ab8Sraveendra padasalagi }, { 463679cc6ab8Sraveendra padasalagi .alg = "sha3-384", 463779cc6ab8Sraveendra padasalagi .test = alg_test_hash, 463879cc6ab8Sraveendra padasalagi .fips_allowed = 1, 463979cc6ab8Sraveendra padasalagi .suite = { 464021c8e720SArd Biesheuvel .hash = __VECS(sha3_384_tv_template) 464179cc6ab8Sraveendra padasalagi } 464279cc6ab8Sraveendra padasalagi }, { 464379cc6ab8Sraveendra padasalagi .alg = "sha3-512", 464479cc6ab8Sraveendra padasalagi .test = alg_test_hash, 464579cc6ab8Sraveendra padasalagi .fips_allowed = 1, 464679cc6ab8Sraveendra padasalagi .suite = { 464721c8e720SArd Biesheuvel .hash = __VECS(sha3_512_tv_template) 464879cc6ab8Sraveendra padasalagi } 464979cc6ab8Sraveendra padasalagi }, { 4650da7f033dSHerbert Xu .alg = "sha384", 4651da7f033dSHerbert Xu .test = alg_test_hash, 4652a1915d51SJarod Wilson .fips_allowed = 1, 4653da7f033dSHerbert Xu .suite = { 465421c8e720SArd Biesheuvel .hash = __VECS(sha384_tv_template) 4655da7f033dSHerbert Xu } 4656da7f033dSHerbert Xu }, { 4657da7f033dSHerbert Xu .alg = "sha512", 4658da7f033dSHerbert Xu .test = alg_test_hash, 4659a1915d51SJarod Wilson .fips_allowed = 1, 4660da7f033dSHerbert Xu .suite = { 466121c8e720SArd Biesheuvel .hash = __VECS(sha512_tv_template) 4662da7f033dSHerbert Xu } 4663da7f033dSHerbert Xu }, { 4664b7e27530SGilad Ben-Yossef .alg = "sm3", 4665b7e27530SGilad Ben-Yossef .test = alg_test_hash, 4666b7e27530SGilad Ben-Yossef .suite = { 4667b7e27530SGilad Ben-Yossef .hash = __VECS(sm3_tv_template) 4668b7e27530SGilad Ben-Yossef } 4669b7e27530SGilad Ben-Yossef }, { 467025a0b9d4SVitaly Chikunov .alg = "streebog256", 467125a0b9d4SVitaly Chikunov .test = alg_test_hash, 467225a0b9d4SVitaly Chikunov .suite = { 467325a0b9d4SVitaly Chikunov .hash = __VECS(streebog256_tv_template) 467425a0b9d4SVitaly Chikunov } 467525a0b9d4SVitaly Chikunov }, { 467625a0b9d4SVitaly Chikunov .alg = "streebog512", 467725a0b9d4SVitaly Chikunov .test = alg_test_hash, 467825a0b9d4SVitaly Chikunov .suite = { 467925a0b9d4SVitaly Chikunov .hash = __VECS(streebog512_tv_template) 468025a0b9d4SVitaly Chikunov } 468125a0b9d4SVitaly Chikunov }, { 4682da7f033dSHerbert Xu .alg = "tgr128", 4683da7f033dSHerbert Xu .test = alg_test_hash, 4684da7f033dSHerbert Xu .suite = { 468521c8e720SArd Biesheuvel .hash = __VECS(tgr128_tv_template) 4686da7f033dSHerbert Xu } 4687da7f033dSHerbert Xu }, { 4688da7f033dSHerbert Xu .alg = "tgr160", 4689da7f033dSHerbert Xu .test = alg_test_hash, 4690da7f033dSHerbert Xu .suite = { 469121c8e720SArd Biesheuvel .hash = __VECS(tgr160_tv_template) 4692da7f033dSHerbert Xu } 4693da7f033dSHerbert Xu }, { 4694da7f033dSHerbert Xu .alg = "tgr192", 4695da7f033dSHerbert Xu .test = alg_test_hash, 4696da7f033dSHerbert Xu .suite = { 469721c8e720SArd Biesheuvel .hash = __VECS(tgr192_tv_template) 4698da7f033dSHerbert Xu } 4699da7f033dSHerbert Xu }, { 4700ed331adaSEric Biggers .alg = "vmac64(aes)", 4701ed331adaSEric Biggers .test = alg_test_hash, 4702ed331adaSEric Biggers .suite = { 4703ed331adaSEric Biggers .hash = __VECS(vmac64_aes_tv_template) 4704ed331adaSEric Biggers } 4705ed331adaSEric Biggers }, { 4706da7f033dSHerbert Xu .alg = "wp256", 4707da7f033dSHerbert Xu .test = alg_test_hash, 4708da7f033dSHerbert Xu .suite = { 470921c8e720SArd Biesheuvel .hash = __VECS(wp256_tv_template) 4710da7f033dSHerbert Xu } 4711da7f033dSHerbert Xu }, { 4712da7f033dSHerbert Xu .alg = "wp384", 4713da7f033dSHerbert Xu .test = alg_test_hash, 4714da7f033dSHerbert Xu .suite = { 471521c8e720SArd Biesheuvel .hash = __VECS(wp384_tv_template) 4716da7f033dSHerbert Xu } 4717da7f033dSHerbert Xu }, { 4718da7f033dSHerbert Xu .alg = "wp512", 4719da7f033dSHerbert Xu .test = alg_test_hash, 4720da7f033dSHerbert Xu .suite = { 472121c8e720SArd Biesheuvel .hash = __VECS(wp512_tv_template) 4722da7f033dSHerbert Xu } 4723da7f033dSHerbert Xu }, { 4724da7f033dSHerbert Xu .alg = "xcbc(aes)", 4725da7f033dSHerbert Xu .test = alg_test_hash, 4726da7f033dSHerbert Xu .suite = { 472721c8e720SArd Biesheuvel .hash = __VECS(aes_xcbc128_tv_template) 4728da7f033dSHerbert Xu } 4729da7f033dSHerbert Xu }, { 4730aa762409SEric Biggers .alg = "xchacha12", 4731aa762409SEric Biggers .test = alg_test_skcipher, 4732aa762409SEric Biggers .suite = { 4733aa762409SEric Biggers .cipher = __VECS(xchacha12_tv_template) 4734aa762409SEric Biggers }, 4735aa762409SEric Biggers }, { 4736de61d7aeSEric Biggers .alg = "xchacha20", 4737de61d7aeSEric Biggers .test = alg_test_skcipher, 4738de61d7aeSEric Biggers .suite = { 4739de61d7aeSEric Biggers .cipher = __VECS(xchacha20_tv_template) 4740de61d7aeSEric Biggers }, 4741de61d7aeSEric Biggers }, { 4742da7f033dSHerbert Xu .alg = "xts(aes)", 4743d435e10eSEric Biggers .generic_driver = "xts(ecb(aes-generic))", 47441aa4ecd9SHerbert Xu .test = alg_test_skcipher, 47452918aa8dSJarod Wilson .fips_allowed = 1, 4746da7f033dSHerbert Xu .suite = { 474792a4c9feSEric Biggers .cipher = __VECS(aes_xts_tv_template) 4748da7f033dSHerbert Xu } 47490c01aed5SGeert Uytterhoeven }, { 47500840605eSJussi Kivilinna .alg = "xts(camellia)", 4751d435e10eSEric Biggers .generic_driver = "xts(ecb(camellia-generic))", 47520840605eSJussi Kivilinna .test = alg_test_skcipher, 47530840605eSJussi Kivilinna .suite = { 475492a4c9feSEric Biggers .cipher = __VECS(camellia_xts_tv_template) 47550840605eSJussi Kivilinna } 47560840605eSJussi Kivilinna }, { 47579b8b0405SJohannes Goetzfried .alg = "xts(cast6)", 4758d435e10eSEric Biggers .generic_driver = "xts(ecb(cast6-generic))", 47599b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 47609b8b0405SJohannes Goetzfried .suite = { 476192a4c9feSEric Biggers .cipher = __VECS(cast6_xts_tv_template) 47629b8b0405SJohannes Goetzfried } 47639b8b0405SJohannes Goetzfried }, { 476415f47ce5SGilad Ben-Yossef /* Same as xts(aes) except the key is stored in 476515f47ce5SGilad Ben-Yossef * hardware secure memory which we reference by index 476615f47ce5SGilad Ben-Yossef */ 476715f47ce5SGilad Ben-Yossef .alg = "xts(paes)", 476815f47ce5SGilad Ben-Yossef .test = alg_test_null, 476915f47ce5SGilad Ben-Yossef .fips_allowed = 1, 477015f47ce5SGilad Ben-Yossef }, { 477118be20b9SJussi Kivilinna .alg = "xts(serpent)", 4772d435e10eSEric Biggers .generic_driver = "xts(ecb(serpent-generic))", 477318be20b9SJussi Kivilinna .test = alg_test_skcipher, 477418be20b9SJussi Kivilinna .suite = { 477592a4c9feSEric Biggers .cipher = __VECS(serpent_xts_tv_template) 477618be20b9SJussi Kivilinna } 477718be20b9SJussi Kivilinna }, { 4778aed265b9SJussi Kivilinna .alg = "xts(twofish)", 4779d435e10eSEric Biggers .generic_driver = "xts(ecb(twofish-generic))", 4780aed265b9SJussi Kivilinna .test = alg_test_skcipher, 4781aed265b9SJussi Kivilinna .suite = { 478292a4c9feSEric Biggers .cipher = __VECS(tf_xts_tv_template) 4783aed265b9SJussi Kivilinna } 4784a368f43dSGiovanni Cabiddu }, { 478515f47ce5SGilad Ben-Yossef .alg = "xts4096(paes)", 478615f47ce5SGilad Ben-Yossef .test = alg_test_null, 478715f47ce5SGilad Ben-Yossef .fips_allowed = 1, 478815f47ce5SGilad Ben-Yossef }, { 478915f47ce5SGilad Ben-Yossef .alg = "xts512(paes)", 479015f47ce5SGilad Ben-Yossef .test = alg_test_null, 479115f47ce5SGilad Ben-Yossef .fips_allowed = 1, 479215f47ce5SGilad Ben-Yossef }, { 4793a368f43dSGiovanni Cabiddu .alg = "zlib-deflate", 4794a368f43dSGiovanni Cabiddu .test = alg_test_comp, 4795a368f43dSGiovanni Cabiddu .fips_allowed = 1, 4796a368f43dSGiovanni Cabiddu .suite = { 4797a368f43dSGiovanni Cabiddu .comp = { 4798a368f43dSGiovanni Cabiddu .comp = __VECS(zlib_deflate_comp_tv_template), 4799a368f43dSGiovanni Cabiddu .decomp = __VECS(zlib_deflate_decomp_tv_template) 4800a368f43dSGiovanni Cabiddu } 4801a368f43dSGiovanni Cabiddu } 4802d28fc3dbSNick Terrell }, { 4803d28fc3dbSNick Terrell .alg = "zstd", 4804d28fc3dbSNick Terrell .test = alg_test_comp, 4805d28fc3dbSNick Terrell .fips_allowed = 1, 4806d28fc3dbSNick Terrell .suite = { 4807d28fc3dbSNick Terrell .comp = { 4808d28fc3dbSNick Terrell .comp = __VECS(zstd_comp_tv_template), 4809d28fc3dbSNick Terrell .decomp = __VECS(zstd_decomp_tv_template) 4810d28fc3dbSNick Terrell } 4811d28fc3dbSNick Terrell } 4812da7f033dSHerbert Xu } 4813da7f033dSHerbert Xu }; 4814da7f033dSHerbert Xu 48153f47a03dSEric Biggers static void alg_check_test_descs_order(void) 48165714758bSJussi Kivilinna { 48175714758bSJussi Kivilinna int i; 48185714758bSJussi Kivilinna 48195714758bSJussi Kivilinna for (i = 1; i < ARRAY_SIZE(alg_test_descs); i++) { 48205714758bSJussi Kivilinna int diff = strcmp(alg_test_descs[i - 1].alg, 48215714758bSJussi Kivilinna alg_test_descs[i].alg); 48225714758bSJussi Kivilinna 48235714758bSJussi Kivilinna if (WARN_ON(diff > 0)) { 48245714758bSJussi Kivilinna pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n", 48255714758bSJussi Kivilinna alg_test_descs[i - 1].alg, 48265714758bSJussi Kivilinna alg_test_descs[i].alg); 48275714758bSJussi Kivilinna } 48285714758bSJussi Kivilinna 48295714758bSJussi Kivilinna if (WARN_ON(diff == 0)) { 48305714758bSJussi Kivilinna pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n", 48315714758bSJussi Kivilinna alg_test_descs[i].alg); 48325714758bSJussi Kivilinna } 48335714758bSJussi Kivilinna } 48345714758bSJussi Kivilinna } 48355714758bSJussi Kivilinna 48363f47a03dSEric Biggers static void alg_check_testvec_configs(void) 48373f47a03dSEric Biggers { 48384e7babbaSEric Biggers int i; 48394e7babbaSEric Biggers 48404e7babbaSEric Biggers for (i = 0; i < ARRAY_SIZE(default_cipher_testvec_configs); i++) 48414e7babbaSEric Biggers WARN_ON(!valid_testvec_config( 48424e7babbaSEric Biggers &default_cipher_testvec_configs[i])); 48434cc2dcf9SEric Biggers 48444cc2dcf9SEric Biggers for (i = 0; i < ARRAY_SIZE(default_hash_testvec_configs); i++) 48454cc2dcf9SEric Biggers WARN_ON(!valid_testvec_config( 48464cc2dcf9SEric Biggers &default_hash_testvec_configs[i])); 48473f47a03dSEric Biggers } 48483f47a03dSEric Biggers 48493f47a03dSEric Biggers static void testmgr_onetime_init(void) 48503f47a03dSEric Biggers { 48513f47a03dSEric Biggers alg_check_test_descs_order(); 48523f47a03dSEric Biggers alg_check_testvec_configs(); 48535b2706a4SEric Biggers 48545b2706a4SEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 48555b2706a4SEric Biggers pr_warn("alg: extra crypto tests enabled. This is intended for developer use only.\n"); 48565b2706a4SEric Biggers #endif 48573f47a03dSEric Biggers } 48583f47a03dSEric Biggers 48591aa4ecd9SHerbert Xu static int alg_find_test(const char *alg) 4860da7f033dSHerbert Xu { 4861da7f033dSHerbert Xu int start = 0; 4862da7f033dSHerbert Xu int end = ARRAY_SIZE(alg_test_descs); 4863da7f033dSHerbert Xu 4864da7f033dSHerbert Xu while (start < end) { 4865da7f033dSHerbert Xu int i = (start + end) / 2; 4866da7f033dSHerbert Xu int diff = strcmp(alg_test_descs[i].alg, alg); 4867da7f033dSHerbert Xu 4868da7f033dSHerbert Xu if (diff > 0) { 4869da7f033dSHerbert Xu end = i; 4870da7f033dSHerbert Xu continue; 4871da7f033dSHerbert Xu } 4872da7f033dSHerbert Xu 4873da7f033dSHerbert Xu if (diff < 0) { 4874da7f033dSHerbert Xu start = i + 1; 4875da7f033dSHerbert Xu continue; 4876da7f033dSHerbert Xu } 4877da7f033dSHerbert Xu 48781aa4ecd9SHerbert Xu return i; 4879da7f033dSHerbert Xu } 4880da7f033dSHerbert Xu 48811aa4ecd9SHerbert Xu return -1; 48821aa4ecd9SHerbert Xu } 48831aa4ecd9SHerbert Xu 48841aa4ecd9SHerbert Xu int alg_test(const char *driver, const char *alg, u32 type, u32 mask) 48851aa4ecd9SHerbert Xu { 48861aa4ecd9SHerbert Xu int i; 4887a68f6610SHerbert Xu int j; 4888d12d6b6dSNeil Horman int rc; 48891aa4ecd9SHerbert Xu 48909e5c9fe4SRichard W.M. Jones if (!fips_enabled && notests) { 48919e5c9fe4SRichard W.M. Jones printk_once(KERN_INFO "alg: self-tests disabled\n"); 48929e5c9fe4SRichard W.M. Jones return 0; 48939e5c9fe4SRichard W.M. Jones } 48949e5c9fe4SRichard W.M. Jones 48953f47a03dSEric Biggers DO_ONCE(testmgr_onetime_init); 48965714758bSJussi Kivilinna 48971aa4ecd9SHerbert Xu if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) { 48981aa4ecd9SHerbert Xu char nalg[CRYPTO_MAX_ALG_NAME]; 48991aa4ecd9SHerbert Xu 49001aa4ecd9SHerbert Xu if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >= 49011aa4ecd9SHerbert Xu sizeof(nalg)) 49021aa4ecd9SHerbert Xu return -ENAMETOOLONG; 49031aa4ecd9SHerbert Xu 49041aa4ecd9SHerbert Xu i = alg_find_test(nalg); 49051aa4ecd9SHerbert Xu if (i < 0) 49061aa4ecd9SHerbert Xu goto notest; 49071aa4ecd9SHerbert Xu 4908a3bef3a3SJarod Wilson if (fips_enabled && !alg_test_descs[i].fips_allowed) 4909a3bef3a3SJarod Wilson goto non_fips_alg; 4910a3bef3a3SJarod Wilson 4911941fb328SJarod Wilson rc = alg_test_cipher(alg_test_descs + i, driver, type, mask); 4912941fb328SJarod Wilson goto test_done; 49131aa4ecd9SHerbert Xu } 49141aa4ecd9SHerbert Xu 49151aa4ecd9SHerbert Xu i = alg_find_test(alg); 4916a68f6610SHerbert Xu j = alg_find_test(driver); 4917a68f6610SHerbert Xu if (i < 0 && j < 0) 49181aa4ecd9SHerbert Xu goto notest; 49191aa4ecd9SHerbert Xu 4920a68f6610SHerbert Xu if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) || 4921a68f6610SHerbert Xu (j >= 0 && !alg_test_descs[j].fips_allowed))) 4922a3bef3a3SJarod Wilson goto non_fips_alg; 4923a3bef3a3SJarod Wilson 4924a68f6610SHerbert Xu rc = 0; 4925a68f6610SHerbert Xu if (i >= 0) 4926a68f6610SHerbert Xu rc |= alg_test_descs[i].test(alg_test_descs + i, driver, 49271aa4ecd9SHerbert Xu type, mask); 4928032c8cacSCristian Stoica if (j >= 0 && j != i) 4929a68f6610SHerbert Xu rc |= alg_test_descs[j].test(alg_test_descs + j, driver, 4930a68f6610SHerbert Xu type, mask); 4931a68f6610SHerbert Xu 4932941fb328SJarod Wilson test_done: 4933eda69b0cSEric Biggers if (rc && (fips_enabled || panic_on_fail)) 4934eda69b0cSEric Biggers panic("alg: self-tests for %s (%s) failed in %s mode!\n", 4935eda69b0cSEric Biggers driver, alg, fips_enabled ? "fips" : "panic_on_fail"); 4936d12d6b6dSNeil Horman 493729ecd4abSJarod Wilson if (fips_enabled && !rc) 49383e8cffd4SMasanari Iida pr_info("alg: self-tests for %s (%s) passed\n", driver, alg); 493929ecd4abSJarod Wilson 4940d12d6b6dSNeil Horman return rc; 49411aa4ecd9SHerbert Xu 49421aa4ecd9SHerbert Xu notest: 4943da7f033dSHerbert Xu printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver); 4944da7f033dSHerbert Xu return 0; 4945a3bef3a3SJarod Wilson non_fips_alg: 4946a3bef3a3SJarod Wilson return -EINVAL; 4947da7f033dSHerbert Xu } 49480b767f96SAlexander Shishkin 4949326a6346SHerbert Xu #endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */ 49500b767f96SAlexander Shishkin 4951da7f033dSHerbert Xu EXPORT_SYMBOL_GPL(alg_test); 4952