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> 300c3dc787SHerbert Xu #include <linux/uio.h> 317647d6ceSJarod Wilson #include <crypto/rng.h> 3264d1cdfbSStephan Mueller #include <crypto/drbg.h> 33946cc463STadeusz Struk #include <crypto/akcipher.h> 34802c7f1cSSalvatore Benedetto #include <crypto/kpp.h> 35d7db7a88SGiovanni Cabiddu #include <crypto/acompress.h> 360eb76ba2SArd Biesheuvel #include <crypto/internal/cipher.h> 37b55e1a39SEric Biggers #include <crypto/internal/simd.h> 38da7f033dSHerbert Xu 39da7f033dSHerbert Xu #include "internal.h" 400b767f96SAlexander Shishkin 410eb76ba2SArd Biesheuvel MODULE_IMPORT_NS(CRYPTO_INTERNAL); 420eb76ba2SArd Biesheuvel 439e5c9fe4SRichard W.M. Jones static bool notests; 449e5c9fe4SRichard W.M. Jones module_param(notests, bool, 0644); 459e5c9fe4SRichard W.M. Jones MODULE_PARM_DESC(notests, "disable crypto self-tests"); 469e5c9fe4SRichard W.M. Jones 47eda69b0cSEric Biggers static bool panic_on_fail; 48eda69b0cSEric Biggers module_param(panic_on_fail, bool, 0444); 49eda69b0cSEric Biggers 505b2706a4SEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 515b2706a4SEric Biggers static bool noextratests; 525b2706a4SEric Biggers module_param(noextratests, bool, 0644); 535b2706a4SEric Biggers MODULE_PARM_DESC(noextratests, "disable expensive crypto self-tests"); 545b2706a4SEric Biggers 555b2706a4SEric Biggers static unsigned int fuzz_iterations = 100; 565b2706a4SEric Biggers module_param(fuzz_iterations, uint, 0644); 575b2706a4SEric Biggers MODULE_PARM_DESC(fuzz_iterations, "number of fuzz test iterations"); 58b55e1a39SEric Biggers 59b55e1a39SEric Biggers DEFINE_PER_CPU(bool, crypto_simd_disabled_for_test); 60b55e1a39SEric Biggers EXPORT_PER_CPU_SYMBOL_GPL(crypto_simd_disabled_for_test); 615b2706a4SEric Biggers #endif 625b2706a4SEric Biggers 63326a6346SHerbert Xu #ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS 640b767f96SAlexander Shishkin 650b767f96SAlexander Shishkin /* a perfect nop */ 660b767f96SAlexander Shishkin int alg_test(const char *driver, const char *alg, u32 type, u32 mask) 670b767f96SAlexander Shishkin { 680b767f96SAlexander Shishkin return 0; 690b767f96SAlexander Shishkin } 700b767f96SAlexander Shishkin 710b767f96SAlexander Shishkin #else 720b767f96SAlexander Shishkin 73da7f033dSHerbert Xu #include "testmgr.h" 74da7f033dSHerbert Xu 75da7f033dSHerbert Xu /* 76da7f033dSHerbert Xu * Need slab memory for testing (size in number of pages). 77da7f033dSHerbert Xu */ 78da7f033dSHerbert Xu #define XBUFSIZE 8 79da7f033dSHerbert Xu 80da7f033dSHerbert Xu /* 81da7f033dSHerbert Xu * Used by test_cipher() 82da7f033dSHerbert Xu */ 83da7f033dSHerbert Xu #define ENCRYPT 1 84da7f033dSHerbert Xu #define DECRYPT 0 85da7f033dSHerbert Xu 86da7f033dSHerbert Xu struct aead_test_suite { 87b13b1e0cSEric Biggers const struct aead_testvec *vecs; 88da7f033dSHerbert Xu unsigned int count; 8949763fc6SEric Biggers 9049763fc6SEric Biggers /* 9149763fc6SEric Biggers * Set if trying to decrypt an inauthentic ciphertext with this 9249763fc6SEric Biggers * algorithm might result in EINVAL rather than EBADMSG, due to other 9349763fc6SEric Biggers * validation the algorithm does on the inputs such as length checks. 9449763fc6SEric Biggers */ 9549763fc6SEric Biggers unsigned int einval_allowed : 1; 9649763fc6SEric Biggers 9749763fc6SEric Biggers /* 986f3a06d9SEric Biggers * Set if this algorithm requires that the IV be located at the end of 996f3a06d9SEric Biggers * the AAD buffer, in addition to being given in the normal way. The 1006f3a06d9SEric Biggers * behavior when the two IV copies differ is implementation-defined. 10149763fc6SEric Biggers */ 1026f3a06d9SEric Biggers unsigned int aad_iv : 1; 103da7f033dSHerbert Xu }; 104da7f033dSHerbert Xu 105da7f033dSHerbert Xu struct cipher_test_suite { 106b13b1e0cSEric Biggers const struct cipher_testvec *vecs; 107da7f033dSHerbert Xu unsigned int count; 108da7f033dSHerbert Xu }; 109da7f033dSHerbert Xu 110da7f033dSHerbert Xu struct comp_test_suite { 111da7f033dSHerbert Xu struct { 112b13b1e0cSEric Biggers const struct comp_testvec *vecs; 113da7f033dSHerbert Xu unsigned int count; 114da7f033dSHerbert Xu } comp, decomp; 115da7f033dSHerbert Xu }; 116da7f033dSHerbert Xu 117da7f033dSHerbert Xu struct hash_test_suite { 118b13b1e0cSEric Biggers const struct hash_testvec *vecs; 119da7f033dSHerbert Xu unsigned int count; 120da7f033dSHerbert Xu }; 121da7f033dSHerbert Xu 1227647d6ceSJarod Wilson struct cprng_test_suite { 123b13b1e0cSEric Biggers const struct cprng_testvec *vecs; 1247647d6ceSJarod Wilson unsigned int count; 1257647d6ceSJarod Wilson }; 1267647d6ceSJarod Wilson 12764d1cdfbSStephan Mueller struct drbg_test_suite { 128b13b1e0cSEric Biggers const struct drbg_testvec *vecs; 12964d1cdfbSStephan Mueller unsigned int count; 13064d1cdfbSStephan Mueller }; 13164d1cdfbSStephan Mueller 132946cc463STadeusz Struk struct akcipher_test_suite { 133b13b1e0cSEric Biggers const struct akcipher_testvec *vecs; 134946cc463STadeusz Struk unsigned int count; 135946cc463STadeusz Struk }; 136946cc463STadeusz Struk 137802c7f1cSSalvatore Benedetto struct kpp_test_suite { 138b13b1e0cSEric Biggers const struct kpp_testvec *vecs; 139802c7f1cSSalvatore Benedetto unsigned int count; 140802c7f1cSSalvatore Benedetto }; 141802c7f1cSSalvatore Benedetto 142da7f033dSHerbert Xu struct alg_test_desc { 143da7f033dSHerbert Xu const char *alg; 144f2bb770aSEric Biggers const char *generic_driver; 145da7f033dSHerbert Xu int (*test)(const struct alg_test_desc *desc, const char *driver, 146da7f033dSHerbert Xu u32 type, u32 mask); 147a1915d51SJarod Wilson int fips_allowed; /* set if alg is allowed in fips mode */ 148da7f033dSHerbert Xu 149da7f033dSHerbert Xu union { 150da7f033dSHerbert Xu struct aead_test_suite aead; 151da7f033dSHerbert Xu struct cipher_test_suite cipher; 152da7f033dSHerbert Xu struct comp_test_suite comp; 153da7f033dSHerbert Xu struct hash_test_suite hash; 1547647d6ceSJarod Wilson struct cprng_test_suite cprng; 15564d1cdfbSStephan Mueller struct drbg_test_suite drbg; 156946cc463STadeusz Struk struct akcipher_test_suite akcipher; 157802c7f1cSSalvatore Benedetto struct kpp_test_suite kpp; 158da7f033dSHerbert Xu } suite; 159da7f033dSHerbert Xu }; 160da7f033dSHerbert Xu 161da7f033dSHerbert Xu static void hexdump(unsigned char *buf, unsigned int len) 162da7f033dSHerbert Xu { 163da7f033dSHerbert Xu print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET, 164da7f033dSHerbert Xu 16, 1, 165da7f033dSHerbert Xu buf, len, false); 166da7f033dSHerbert Xu } 167da7f033dSHerbert Xu 1683f47a03dSEric Biggers static int __testmgr_alloc_buf(char *buf[XBUFSIZE], int order) 169f8b0d4d0SHerbert Xu { 170f8b0d4d0SHerbert Xu int i; 171f8b0d4d0SHerbert Xu 172f8b0d4d0SHerbert Xu for (i = 0; i < XBUFSIZE; i++) { 1733f47a03dSEric Biggers buf[i] = (char *)__get_free_pages(GFP_KERNEL, order); 174f8b0d4d0SHerbert Xu if (!buf[i]) 175f8b0d4d0SHerbert Xu goto err_free_buf; 176f8b0d4d0SHerbert Xu } 177f8b0d4d0SHerbert Xu 178f8b0d4d0SHerbert Xu return 0; 179f8b0d4d0SHerbert Xu 180f8b0d4d0SHerbert Xu err_free_buf: 181f8b0d4d0SHerbert Xu while (i-- > 0) 1823f47a03dSEric Biggers free_pages((unsigned long)buf[i], order); 183f8b0d4d0SHerbert Xu 184f8b0d4d0SHerbert Xu return -ENOMEM; 185f8b0d4d0SHerbert Xu } 186f8b0d4d0SHerbert Xu 1873f47a03dSEric Biggers static int testmgr_alloc_buf(char *buf[XBUFSIZE]) 1883f47a03dSEric Biggers { 1893f47a03dSEric Biggers return __testmgr_alloc_buf(buf, 0); 1903f47a03dSEric Biggers } 1913f47a03dSEric Biggers 1923f47a03dSEric Biggers static void __testmgr_free_buf(char *buf[XBUFSIZE], int order) 193f8b0d4d0SHerbert Xu { 194f8b0d4d0SHerbert Xu int i; 195f8b0d4d0SHerbert Xu 196f8b0d4d0SHerbert Xu for (i = 0; i < XBUFSIZE; i++) 1973f47a03dSEric Biggers free_pages((unsigned long)buf[i], order); 1983f47a03dSEric Biggers } 1993f47a03dSEric Biggers 2003f47a03dSEric Biggers static void testmgr_free_buf(char *buf[XBUFSIZE]) 2013f47a03dSEric Biggers { 2023f47a03dSEric Biggers __testmgr_free_buf(buf, 0); 2033f47a03dSEric Biggers } 2043f47a03dSEric Biggers 2053f47a03dSEric Biggers #define TESTMGR_POISON_BYTE 0xfe 2063f47a03dSEric Biggers #define TESTMGR_POISON_LEN 16 2073f47a03dSEric Biggers 2083f47a03dSEric Biggers static inline void testmgr_poison(void *addr, size_t len) 2093f47a03dSEric Biggers { 2103f47a03dSEric Biggers memset(addr, TESTMGR_POISON_BYTE, len); 2113f47a03dSEric Biggers } 2123f47a03dSEric Biggers 2133f47a03dSEric Biggers /* Is the memory region still fully poisoned? */ 2143f47a03dSEric Biggers static inline bool testmgr_is_poison(const void *addr, size_t len) 2153f47a03dSEric Biggers { 2163f47a03dSEric Biggers return memchr_inv(addr, TESTMGR_POISON_BYTE, len) == NULL; 2173f47a03dSEric Biggers } 2183f47a03dSEric Biggers 2193f47a03dSEric Biggers /* flush type for hash algorithms */ 2203f47a03dSEric Biggers enum flush_type { 2213f47a03dSEric Biggers /* merge with update of previous buffer(s) */ 2223f47a03dSEric Biggers FLUSH_TYPE_NONE = 0, 2233f47a03dSEric Biggers 2243f47a03dSEric Biggers /* update with previous buffer(s) before doing this one */ 2253f47a03dSEric Biggers FLUSH_TYPE_FLUSH, 2263f47a03dSEric Biggers 2273f47a03dSEric Biggers /* likewise, but also export and re-import the intermediate state */ 2283f47a03dSEric Biggers FLUSH_TYPE_REIMPORT, 2293f47a03dSEric Biggers }; 2303f47a03dSEric Biggers 2313f47a03dSEric Biggers /* finalization function for hash algorithms */ 2323f47a03dSEric Biggers enum finalization_type { 2333f47a03dSEric Biggers FINALIZATION_TYPE_FINAL, /* use final() */ 2343f47a03dSEric Biggers FINALIZATION_TYPE_FINUP, /* use finup() */ 2353f47a03dSEric Biggers FINALIZATION_TYPE_DIGEST, /* use digest() */ 2363f47a03dSEric Biggers }; 2373f47a03dSEric Biggers 2383f47a03dSEric Biggers #define TEST_SG_TOTAL 10000 2393f47a03dSEric Biggers 2403f47a03dSEric Biggers /** 2413f47a03dSEric Biggers * struct test_sg_division - description of a scatterlist entry 2423f47a03dSEric Biggers * 2433f47a03dSEric Biggers * This struct describes one entry of a scatterlist being constructed to check a 2443f47a03dSEric Biggers * crypto test vector. 2453f47a03dSEric Biggers * 2463f47a03dSEric Biggers * @proportion_of_total: length of this chunk relative to the total length, 2473f47a03dSEric Biggers * given as a proportion out of TEST_SG_TOTAL so that it 2483f47a03dSEric Biggers * scales to fit any test vector 2493f47a03dSEric Biggers * @offset: byte offset into a 2-page buffer at which this chunk will start 2503f47a03dSEric Biggers * @offset_relative_to_alignmask: if true, add the algorithm's alignmask to the 2513f47a03dSEric Biggers * @offset 2523f47a03dSEric Biggers * @flush_type: for hashes, whether an update() should be done now vs. 2533f47a03dSEric Biggers * continuing to accumulate data 2546570737cSEric Biggers * @nosimd: if doing the pending update(), do it with SIMD disabled? 2553f47a03dSEric Biggers */ 2563f47a03dSEric Biggers struct test_sg_division { 2573f47a03dSEric Biggers unsigned int proportion_of_total; 2583f47a03dSEric Biggers unsigned int offset; 2593f47a03dSEric Biggers bool offset_relative_to_alignmask; 2603f47a03dSEric Biggers enum flush_type flush_type; 2616570737cSEric Biggers bool nosimd; 2623f47a03dSEric Biggers }; 2633f47a03dSEric Biggers 2643f47a03dSEric Biggers /** 2653f47a03dSEric Biggers * struct testvec_config - configuration for testing a crypto test vector 2663f47a03dSEric Biggers * 2673f47a03dSEric Biggers * This struct describes the data layout and other parameters with which each 2683f47a03dSEric Biggers * crypto test vector can be tested. 2693f47a03dSEric Biggers * 2703f47a03dSEric Biggers * @name: name of this config, logged for debugging purposes if a test fails 2713f47a03dSEric Biggers * @inplace: operate on the data in-place, if applicable for the algorithm type? 2723f47a03dSEric Biggers * @req_flags: extra request_flags, e.g. CRYPTO_TFM_REQ_MAY_SLEEP 2733f47a03dSEric Biggers * @src_divs: description of how to arrange the source scatterlist 2743f47a03dSEric Biggers * @dst_divs: description of how to arrange the dst scatterlist, if applicable 2753f47a03dSEric Biggers * for the algorithm type. Defaults to @src_divs if unset. 2763f47a03dSEric Biggers * @iv_offset: misalignment of the IV in the range [0..MAX_ALGAPI_ALIGNMASK+1], 2773f47a03dSEric Biggers * where 0 is aligned to a 2*(MAX_ALGAPI_ALIGNMASK+1) byte boundary 2783f47a03dSEric Biggers * @iv_offset_relative_to_alignmask: if true, add the algorithm's alignmask to 2793f47a03dSEric Biggers * the @iv_offset 280fd8c37c7SEric Biggers * @key_offset: misalignment of the key, where 0 is default alignment 281fd8c37c7SEric Biggers * @key_offset_relative_to_alignmask: if true, add the algorithm's alignmask to 282fd8c37c7SEric Biggers * the @key_offset 2833f47a03dSEric Biggers * @finalization_type: what finalization function to use for hashes 2846570737cSEric Biggers * @nosimd: execute with SIMD disabled? Requires !CRYPTO_TFM_REQ_MAY_SLEEP. 2853f47a03dSEric Biggers */ 2863f47a03dSEric Biggers struct testvec_config { 2873f47a03dSEric Biggers const char *name; 2883f47a03dSEric Biggers bool inplace; 2893f47a03dSEric Biggers u32 req_flags; 2903f47a03dSEric Biggers struct test_sg_division src_divs[XBUFSIZE]; 2913f47a03dSEric Biggers struct test_sg_division dst_divs[XBUFSIZE]; 2923f47a03dSEric Biggers unsigned int iv_offset; 293fd8c37c7SEric Biggers unsigned int key_offset; 2943f47a03dSEric Biggers bool iv_offset_relative_to_alignmask; 295fd8c37c7SEric Biggers bool key_offset_relative_to_alignmask; 2963f47a03dSEric Biggers enum finalization_type finalization_type; 2976570737cSEric Biggers bool nosimd; 2983f47a03dSEric Biggers }; 2993f47a03dSEric Biggers 3003f47a03dSEric Biggers #define TESTVEC_CONFIG_NAMELEN 192 3013f47a03dSEric Biggers 3024e7babbaSEric Biggers /* 3034e7babbaSEric Biggers * The following are the lists of testvec_configs to test for each algorithm 3044e7babbaSEric Biggers * type when the basic crypto self-tests are enabled, i.e. when 3054e7babbaSEric Biggers * CONFIG_CRYPTO_MANAGER_DISABLE_TESTS is unset. They aim to provide good test 3064e7babbaSEric Biggers * coverage, while keeping the test time much shorter than the full fuzz tests 3074e7babbaSEric Biggers * so that the basic tests can be enabled in a wider range of circumstances. 3084e7babbaSEric Biggers */ 3094e7babbaSEric Biggers 3104e7babbaSEric Biggers /* Configs for skciphers and aeads */ 3114e7babbaSEric Biggers static const struct testvec_config default_cipher_testvec_configs[] = { 3124e7babbaSEric Biggers { 3134e7babbaSEric Biggers .name = "in-place", 3144e7babbaSEric Biggers .inplace = true, 3154e7babbaSEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 3164e7babbaSEric Biggers }, { 3174e7babbaSEric Biggers .name = "out-of-place", 3184e7babbaSEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 3194e7babbaSEric Biggers }, { 3204e7babbaSEric Biggers .name = "unaligned buffer, offset=1", 3214e7babbaSEric Biggers .src_divs = { { .proportion_of_total = 10000, .offset = 1 } }, 3224e7babbaSEric Biggers .iv_offset = 1, 323fd8c37c7SEric Biggers .key_offset = 1, 3244e7babbaSEric Biggers }, { 3254e7babbaSEric Biggers .name = "buffer aligned only to alignmask", 3264e7babbaSEric Biggers .src_divs = { 3274e7babbaSEric Biggers { 3284e7babbaSEric Biggers .proportion_of_total = 10000, 3294e7babbaSEric Biggers .offset = 1, 3304e7babbaSEric Biggers .offset_relative_to_alignmask = true, 3314e7babbaSEric Biggers }, 3324e7babbaSEric Biggers }, 3334e7babbaSEric Biggers .iv_offset = 1, 3344e7babbaSEric Biggers .iv_offset_relative_to_alignmask = true, 335fd8c37c7SEric Biggers .key_offset = 1, 336fd8c37c7SEric Biggers .key_offset_relative_to_alignmask = true, 3374e7babbaSEric Biggers }, { 3384e7babbaSEric Biggers .name = "two even aligned splits", 3394e7babbaSEric Biggers .src_divs = { 3404e7babbaSEric Biggers { .proportion_of_total = 5000 }, 3414e7babbaSEric Biggers { .proportion_of_total = 5000 }, 3424e7babbaSEric Biggers }, 3434e7babbaSEric Biggers }, { 3444e7babbaSEric Biggers .name = "uneven misaligned splits, may sleep", 3454e7babbaSEric Biggers .req_flags = CRYPTO_TFM_REQ_MAY_SLEEP, 3464e7babbaSEric Biggers .src_divs = { 3474e7babbaSEric Biggers { .proportion_of_total = 1900, .offset = 33 }, 3484e7babbaSEric Biggers { .proportion_of_total = 3300, .offset = 7 }, 3494e7babbaSEric Biggers { .proportion_of_total = 4800, .offset = 18 }, 3504e7babbaSEric Biggers }, 3514e7babbaSEric Biggers .iv_offset = 3, 352fd8c37c7SEric Biggers .key_offset = 3, 3534e7babbaSEric Biggers }, { 3544e7babbaSEric Biggers .name = "misaligned splits crossing pages, inplace", 3554e7babbaSEric Biggers .inplace = true, 3564e7babbaSEric Biggers .src_divs = { 3574e7babbaSEric Biggers { 3584e7babbaSEric Biggers .proportion_of_total = 7500, 3594e7babbaSEric Biggers .offset = PAGE_SIZE - 32 3604e7babbaSEric Biggers }, { 3614e7babbaSEric Biggers .proportion_of_total = 2500, 3624e7babbaSEric Biggers .offset = PAGE_SIZE - 7 3634e7babbaSEric Biggers }, 3644e7babbaSEric Biggers }, 3654e7babbaSEric Biggers } 3664e7babbaSEric Biggers }; 3674e7babbaSEric Biggers 3684cc2dcf9SEric Biggers static const struct testvec_config default_hash_testvec_configs[] = { 3694cc2dcf9SEric Biggers { 3704cc2dcf9SEric Biggers .name = "init+update+final aligned buffer", 3714cc2dcf9SEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 3724cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINAL, 3734cc2dcf9SEric Biggers }, { 3744cc2dcf9SEric Biggers .name = "init+finup aligned buffer", 3754cc2dcf9SEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 3764cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINUP, 3774cc2dcf9SEric Biggers }, { 3784cc2dcf9SEric Biggers .name = "digest aligned buffer", 3794cc2dcf9SEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 3804cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_DIGEST, 3814cc2dcf9SEric Biggers }, { 3824cc2dcf9SEric Biggers .name = "init+update+final misaligned buffer", 3834cc2dcf9SEric Biggers .src_divs = { { .proportion_of_total = 10000, .offset = 1 } }, 3844cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINAL, 385fd8c37c7SEric Biggers .key_offset = 1, 3864cc2dcf9SEric Biggers }, { 3874cc2dcf9SEric Biggers .name = "digest buffer aligned only to alignmask", 3884cc2dcf9SEric Biggers .src_divs = { 3894cc2dcf9SEric Biggers { 3904cc2dcf9SEric Biggers .proportion_of_total = 10000, 3914cc2dcf9SEric Biggers .offset = 1, 3924cc2dcf9SEric Biggers .offset_relative_to_alignmask = true, 3934cc2dcf9SEric Biggers }, 3944cc2dcf9SEric Biggers }, 3954cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_DIGEST, 396fd8c37c7SEric Biggers .key_offset = 1, 397fd8c37c7SEric Biggers .key_offset_relative_to_alignmask = true, 3984cc2dcf9SEric Biggers }, { 3994cc2dcf9SEric Biggers .name = "init+update+update+final two even splits", 4004cc2dcf9SEric Biggers .src_divs = { 4014cc2dcf9SEric Biggers { .proportion_of_total = 5000 }, 4024cc2dcf9SEric Biggers { 4034cc2dcf9SEric Biggers .proportion_of_total = 5000, 4044cc2dcf9SEric Biggers .flush_type = FLUSH_TYPE_FLUSH, 4054cc2dcf9SEric Biggers }, 4064cc2dcf9SEric Biggers }, 4074cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINAL, 4084cc2dcf9SEric Biggers }, { 4094cc2dcf9SEric Biggers .name = "digest uneven misaligned splits, may sleep", 4104cc2dcf9SEric Biggers .req_flags = CRYPTO_TFM_REQ_MAY_SLEEP, 4114cc2dcf9SEric Biggers .src_divs = { 4124cc2dcf9SEric Biggers { .proportion_of_total = 1900, .offset = 33 }, 4134cc2dcf9SEric Biggers { .proportion_of_total = 3300, .offset = 7 }, 4144cc2dcf9SEric Biggers { .proportion_of_total = 4800, .offset = 18 }, 4154cc2dcf9SEric Biggers }, 4164cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_DIGEST, 4174cc2dcf9SEric Biggers }, { 4184cc2dcf9SEric Biggers .name = "digest misaligned splits crossing pages", 4194cc2dcf9SEric Biggers .src_divs = { 4204cc2dcf9SEric Biggers { 4214cc2dcf9SEric Biggers .proportion_of_total = 7500, 4224cc2dcf9SEric Biggers .offset = PAGE_SIZE - 32, 4234cc2dcf9SEric Biggers }, { 4244cc2dcf9SEric Biggers .proportion_of_total = 2500, 4254cc2dcf9SEric Biggers .offset = PAGE_SIZE - 7, 4264cc2dcf9SEric Biggers }, 4274cc2dcf9SEric Biggers }, 4284cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_DIGEST, 4294cc2dcf9SEric Biggers }, { 4304cc2dcf9SEric Biggers .name = "import/export", 4314cc2dcf9SEric Biggers .src_divs = { 4324cc2dcf9SEric Biggers { 4334cc2dcf9SEric Biggers .proportion_of_total = 6500, 4344cc2dcf9SEric Biggers .flush_type = FLUSH_TYPE_REIMPORT, 4354cc2dcf9SEric Biggers }, { 4364cc2dcf9SEric Biggers .proportion_of_total = 3500, 4374cc2dcf9SEric Biggers .flush_type = FLUSH_TYPE_REIMPORT, 4384cc2dcf9SEric Biggers }, 4394cc2dcf9SEric Biggers }, 4404cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINAL, 4414cc2dcf9SEric Biggers } 4424cc2dcf9SEric Biggers }; 4434cc2dcf9SEric Biggers 4443f47a03dSEric Biggers static unsigned int count_test_sg_divisions(const struct test_sg_division *divs) 4453f47a03dSEric Biggers { 4463f47a03dSEric Biggers unsigned int remaining = TEST_SG_TOTAL; 4473f47a03dSEric Biggers unsigned int ndivs = 0; 4483f47a03dSEric Biggers 4493f47a03dSEric Biggers do { 4503f47a03dSEric Biggers remaining -= divs[ndivs++].proportion_of_total; 4513f47a03dSEric Biggers } while (remaining); 4523f47a03dSEric Biggers 4533f47a03dSEric Biggers return ndivs; 4543f47a03dSEric Biggers } 4553f47a03dSEric Biggers 4566570737cSEric Biggers #define SGDIVS_HAVE_FLUSHES BIT(0) 4576570737cSEric Biggers #define SGDIVS_HAVE_NOSIMD BIT(1) 4586570737cSEric Biggers 4593f47a03dSEric Biggers static bool valid_sg_divisions(const struct test_sg_division *divs, 4606570737cSEric Biggers unsigned int count, int *flags_ret) 4613f47a03dSEric Biggers { 4623f47a03dSEric Biggers unsigned int total = 0; 4633f47a03dSEric Biggers unsigned int i; 4643f47a03dSEric Biggers 4653f47a03dSEric Biggers for (i = 0; i < count && total != TEST_SG_TOTAL; i++) { 4663f47a03dSEric Biggers if (divs[i].proportion_of_total <= 0 || 4673f47a03dSEric Biggers divs[i].proportion_of_total > TEST_SG_TOTAL - total) 4683f47a03dSEric Biggers return false; 4693f47a03dSEric Biggers total += divs[i].proportion_of_total; 4703f47a03dSEric Biggers if (divs[i].flush_type != FLUSH_TYPE_NONE) 4716570737cSEric Biggers *flags_ret |= SGDIVS_HAVE_FLUSHES; 4726570737cSEric Biggers if (divs[i].nosimd) 4736570737cSEric Biggers *flags_ret |= SGDIVS_HAVE_NOSIMD; 4743f47a03dSEric Biggers } 4753f47a03dSEric Biggers return total == TEST_SG_TOTAL && 4763f47a03dSEric Biggers memchr_inv(&divs[i], 0, (count - i) * sizeof(divs[0])) == NULL; 4773f47a03dSEric Biggers } 4783f47a03dSEric Biggers 4793f47a03dSEric Biggers /* 4803f47a03dSEric Biggers * Check whether the given testvec_config is valid. This isn't strictly needed 4813f47a03dSEric Biggers * since every testvec_config should be valid, but check anyway so that people 4823f47a03dSEric Biggers * don't unknowingly add broken configs that don't do what they wanted. 4833f47a03dSEric Biggers */ 4843f47a03dSEric Biggers static bool valid_testvec_config(const struct testvec_config *cfg) 4853f47a03dSEric Biggers { 4866570737cSEric Biggers int flags = 0; 4873f47a03dSEric Biggers 4883f47a03dSEric Biggers if (cfg->name == NULL) 4893f47a03dSEric Biggers return false; 4903f47a03dSEric Biggers 4913f47a03dSEric Biggers if (!valid_sg_divisions(cfg->src_divs, ARRAY_SIZE(cfg->src_divs), 4926570737cSEric Biggers &flags)) 4933f47a03dSEric Biggers return false; 4943f47a03dSEric Biggers 4953f47a03dSEric Biggers if (cfg->dst_divs[0].proportion_of_total) { 4963f47a03dSEric Biggers if (!valid_sg_divisions(cfg->dst_divs, 4976570737cSEric Biggers ARRAY_SIZE(cfg->dst_divs), &flags)) 4983f47a03dSEric Biggers return false; 4993f47a03dSEric Biggers } else { 5003f47a03dSEric Biggers if (memchr_inv(cfg->dst_divs, 0, sizeof(cfg->dst_divs))) 5013f47a03dSEric Biggers return false; 5023f47a03dSEric Biggers /* defaults to dst_divs=src_divs */ 5033f47a03dSEric Biggers } 5043f47a03dSEric Biggers 5053f47a03dSEric Biggers if (cfg->iv_offset + 5063f47a03dSEric Biggers (cfg->iv_offset_relative_to_alignmask ? MAX_ALGAPI_ALIGNMASK : 0) > 5073f47a03dSEric Biggers MAX_ALGAPI_ALIGNMASK + 1) 5083f47a03dSEric Biggers return false; 5093f47a03dSEric Biggers 5106570737cSEric Biggers if ((flags & (SGDIVS_HAVE_FLUSHES | SGDIVS_HAVE_NOSIMD)) && 5116570737cSEric Biggers cfg->finalization_type == FINALIZATION_TYPE_DIGEST) 5126570737cSEric Biggers return false; 5136570737cSEric Biggers 5146570737cSEric Biggers if ((cfg->nosimd || (flags & SGDIVS_HAVE_NOSIMD)) && 5156570737cSEric Biggers (cfg->req_flags & CRYPTO_TFM_REQ_MAY_SLEEP)) 5163f47a03dSEric Biggers return false; 5173f47a03dSEric Biggers 5183f47a03dSEric Biggers return true; 5193f47a03dSEric Biggers } 5203f47a03dSEric Biggers 5213f47a03dSEric Biggers struct test_sglist { 5223f47a03dSEric Biggers char *bufs[XBUFSIZE]; 5233f47a03dSEric Biggers struct scatterlist sgl[XBUFSIZE]; 5243f47a03dSEric Biggers struct scatterlist sgl_saved[XBUFSIZE]; 5253f47a03dSEric Biggers struct scatterlist *sgl_ptr; 5263f47a03dSEric Biggers unsigned int nents; 5273f47a03dSEric Biggers }; 5283f47a03dSEric Biggers 5293f47a03dSEric Biggers static int init_test_sglist(struct test_sglist *tsgl) 5303f47a03dSEric Biggers { 5313f47a03dSEric Biggers return __testmgr_alloc_buf(tsgl->bufs, 1 /* two pages per buffer */); 5323f47a03dSEric Biggers } 5333f47a03dSEric Biggers 5343f47a03dSEric Biggers static void destroy_test_sglist(struct test_sglist *tsgl) 5353f47a03dSEric Biggers { 5363f47a03dSEric Biggers return __testmgr_free_buf(tsgl->bufs, 1 /* two pages per buffer */); 5373f47a03dSEric Biggers } 5383f47a03dSEric Biggers 5393f47a03dSEric Biggers /** 5403f47a03dSEric Biggers * build_test_sglist() - build a scatterlist for a crypto test 5413f47a03dSEric Biggers * 5423f47a03dSEric Biggers * @tsgl: the scatterlist to build. @tsgl->bufs[] contains an array of 2-page 5433f47a03dSEric Biggers * buffers which the scatterlist @tsgl->sgl[] will be made to point into. 5443f47a03dSEric Biggers * @divs: the layout specification on which the scatterlist will be based 5453f47a03dSEric Biggers * @alignmask: the algorithm's alignmask 5463f47a03dSEric Biggers * @total_len: the total length of the scatterlist to build in bytes 5473f47a03dSEric Biggers * @data: if non-NULL, the buffers will be filled with this data until it ends. 5483f47a03dSEric Biggers * Otherwise the buffers will be poisoned. In both cases, some bytes 5493f47a03dSEric Biggers * past the end of each buffer will be poisoned to help detect overruns. 5503f47a03dSEric Biggers * @out_divs: if non-NULL, the test_sg_division to which each scatterlist entry 5513f47a03dSEric Biggers * corresponds will be returned here. This will match @divs except 5523f47a03dSEric Biggers * that divisions resolving to a length of 0 are omitted as they are 5533f47a03dSEric Biggers * not included in the scatterlist. 5543f47a03dSEric Biggers * 5553f47a03dSEric Biggers * Return: 0 or a -errno value 5563f47a03dSEric Biggers */ 5573f47a03dSEric Biggers static int build_test_sglist(struct test_sglist *tsgl, 5583f47a03dSEric Biggers const struct test_sg_division *divs, 5593f47a03dSEric Biggers const unsigned int alignmask, 5603f47a03dSEric Biggers const unsigned int total_len, 5613f47a03dSEric Biggers struct iov_iter *data, 5623f47a03dSEric Biggers const struct test_sg_division *out_divs[XBUFSIZE]) 5633f47a03dSEric Biggers { 5643f47a03dSEric Biggers struct { 5653f47a03dSEric Biggers const struct test_sg_division *div; 5663f47a03dSEric Biggers size_t length; 5673f47a03dSEric Biggers } partitions[XBUFSIZE]; 5683f47a03dSEric Biggers const unsigned int ndivs = count_test_sg_divisions(divs); 5693f47a03dSEric Biggers unsigned int len_remaining = total_len; 5703f47a03dSEric Biggers unsigned int i; 5713f47a03dSEric Biggers 5723f47a03dSEric Biggers BUILD_BUG_ON(ARRAY_SIZE(partitions) != ARRAY_SIZE(tsgl->sgl)); 5733f47a03dSEric Biggers if (WARN_ON(ndivs > ARRAY_SIZE(partitions))) 5743f47a03dSEric Biggers return -EINVAL; 5753f47a03dSEric Biggers 5763f47a03dSEric Biggers /* Calculate the (div, length) pairs */ 5773f47a03dSEric Biggers tsgl->nents = 0; 5783f47a03dSEric Biggers for (i = 0; i < ndivs; i++) { 5793f47a03dSEric Biggers unsigned int len_this_sg = 5803f47a03dSEric Biggers min(len_remaining, 5813f47a03dSEric Biggers (total_len * divs[i].proportion_of_total + 5823f47a03dSEric Biggers TEST_SG_TOTAL / 2) / TEST_SG_TOTAL); 5833f47a03dSEric Biggers 5843f47a03dSEric Biggers if (len_this_sg != 0) { 5853f47a03dSEric Biggers partitions[tsgl->nents].div = &divs[i]; 5863f47a03dSEric Biggers partitions[tsgl->nents].length = len_this_sg; 5873f47a03dSEric Biggers tsgl->nents++; 5883f47a03dSEric Biggers len_remaining -= len_this_sg; 5893f47a03dSEric Biggers } 5903f47a03dSEric Biggers } 5913f47a03dSEric Biggers if (tsgl->nents == 0) { 5923f47a03dSEric Biggers partitions[tsgl->nents].div = &divs[0]; 5933f47a03dSEric Biggers partitions[tsgl->nents].length = 0; 5943f47a03dSEric Biggers tsgl->nents++; 5953f47a03dSEric Biggers } 5963f47a03dSEric Biggers partitions[tsgl->nents - 1].length += len_remaining; 5973f47a03dSEric Biggers 5983f47a03dSEric Biggers /* Set up the sgl entries and fill the data or poison */ 5993f47a03dSEric Biggers sg_init_table(tsgl->sgl, tsgl->nents); 6003f47a03dSEric Biggers for (i = 0; i < tsgl->nents; i++) { 6013f47a03dSEric Biggers unsigned int offset = partitions[i].div->offset; 6023f47a03dSEric Biggers void *addr; 6033f47a03dSEric Biggers 6043f47a03dSEric Biggers if (partitions[i].div->offset_relative_to_alignmask) 6053f47a03dSEric Biggers offset += alignmask; 6063f47a03dSEric Biggers 6073f47a03dSEric Biggers while (offset + partitions[i].length + TESTMGR_POISON_LEN > 6083f47a03dSEric Biggers 2 * PAGE_SIZE) { 6093f47a03dSEric Biggers if (WARN_ON(offset <= 0)) 6103f47a03dSEric Biggers return -EINVAL; 6113f47a03dSEric Biggers offset /= 2; 6123f47a03dSEric Biggers } 6133f47a03dSEric Biggers 6143f47a03dSEric Biggers addr = &tsgl->bufs[i][offset]; 6153f47a03dSEric Biggers sg_set_buf(&tsgl->sgl[i], addr, partitions[i].length); 6163f47a03dSEric Biggers 6173f47a03dSEric Biggers if (out_divs) 6183f47a03dSEric Biggers out_divs[i] = partitions[i].div; 6193f47a03dSEric Biggers 6203f47a03dSEric Biggers if (data) { 6213f47a03dSEric Biggers size_t copy_len, copied; 6223f47a03dSEric Biggers 6233f47a03dSEric Biggers copy_len = min(partitions[i].length, data->count); 6243f47a03dSEric Biggers copied = copy_from_iter(addr, copy_len, data); 6253f47a03dSEric Biggers if (WARN_ON(copied != copy_len)) 6263f47a03dSEric Biggers return -EINVAL; 6273f47a03dSEric Biggers testmgr_poison(addr + copy_len, partitions[i].length + 6283f47a03dSEric Biggers TESTMGR_POISON_LEN - copy_len); 6293f47a03dSEric Biggers } else { 6303f47a03dSEric Biggers testmgr_poison(addr, partitions[i].length + 6313f47a03dSEric Biggers TESTMGR_POISON_LEN); 6323f47a03dSEric Biggers } 6333f47a03dSEric Biggers } 6343f47a03dSEric Biggers 6353f47a03dSEric Biggers sg_mark_end(&tsgl->sgl[tsgl->nents - 1]); 6363f47a03dSEric Biggers tsgl->sgl_ptr = tsgl->sgl; 6373f47a03dSEric Biggers memcpy(tsgl->sgl_saved, tsgl->sgl, tsgl->nents * sizeof(tsgl->sgl[0])); 6383f47a03dSEric Biggers return 0; 6393f47a03dSEric Biggers } 6403f47a03dSEric Biggers 6413f47a03dSEric Biggers /* 6423f47a03dSEric Biggers * Verify that a scatterlist crypto operation produced the correct output. 6433f47a03dSEric Biggers * 6443f47a03dSEric Biggers * @tsgl: scatterlist containing the actual output 6453f47a03dSEric Biggers * @expected_output: buffer containing the expected output 6463f47a03dSEric Biggers * @len_to_check: length of @expected_output in bytes 6473f47a03dSEric Biggers * @unchecked_prefix_len: number of ignored bytes in @tsgl prior to real result 6483f47a03dSEric Biggers * @check_poison: verify that the poison bytes after each chunk are intact? 6493f47a03dSEric Biggers * 6503f47a03dSEric Biggers * Return: 0 if correct, -EINVAL if incorrect, -EOVERFLOW if buffer overrun. 6513f47a03dSEric Biggers */ 6523f47a03dSEric Biggers static int verify_correct_output(const struct test_sglist *tsgl, 6533f47a03dSEric Biggers const char *expected_output, 6543f47a03dSEric Biggers unsigned int len_to_check, 6553f47a03dSEric Biggers unsigned int unchecked_prefix_len, 6563f47a03dSEric Biggers bool check_poison) 6573f47a03dSEric Biggers { 6583f47a03dSEric Biggers unsigned int i; 6593f47a03dSEric Biggers 6603f47a03dSEric Biggers for (i = 0; i < tsgl->nents; i++) { 6613f47a03dSEric Biggers struct scatterlist *sg = &tsgl->sgl_ptr[i]; 6623f47a03dSEric Biggers unsigned int len = sg->length; 6633f47a03dSEric Biggers unsigned int offset = sg->offset; 6643f47a03dSEric Biggers const char *actual_output; 6653f47a03dSEric Biggers 6663f47a03dSEric Biggers if (unchecked_prefix_len) { 6673f47a03dSEric Biggers if (unchecked_prefix_len >= len) { 6683f47a03dSEric Biggers unchecked_prefix_len -= len; 6693f47a03dSEric Biggers continue; 6703f47a03dSEric Biggers } 6713f47a03dSEric Biggers offset += unchecked_prefix_len; 6723f47a03dSEric Biggers len -= unchecked_prefix_len; 6733f47a03dSEric Biggers unchecked_prefix_len = 0; 6743f47a03dSEric Biggers } 6753f47a03dSEric Biggers len = min(len, len_to_check); 6763f47a03dSEric Biggers actual_output = page_address(sg_page(sg)) + offset; 6773f47a03dSEric Biggers if (memcmp(expected_output, actual_output, len) != 0) 6783f47a03dSEric Biggers return -EINVAL; 6793f47a03dSEric Biggers if (check_poison && 6803f47a03dSEric Biggers !testmgr_is_poison(actual_output + len, TESTMGR_POISON_LEN)) 6813f47a03dSEric Biggers return -EOVERFLOW; 6823f47a03dSEric Biggers len_to_check -= len; 6833f47a03dSEric Biggers expected_output += len; 6843f47a03dSEric Biggers } 6853f47a03dSEric Biggers if (WARN_ON(len_to_check != 0)) 6863f47a03dSEric Biggers return -EINVAL; 6873f47a03dSEric Biggers return 0; 6883f47a03dSEric Biggers } 6893f47a03dSEric Biggers 6903f47a03dSEric Biggers static bool is_test_sglist_corrupted(const struct test_sglist *tsgl) 6913f47a03dSEric Biggers { 6923f47a03dSEric Biggers unsigned int i; 6933f47a03dSEric Biggers 6943f47a03dSEric Biggers for (i = 0; i < tsgl->nents; i++) { 6953f47a03dSEric Biggers if (tsgl->sgl[i].page_link != tsgl->sgl_saved[i].page_link) 6963f47a03dSEric Biggers return true; 6973f47a03dSEric Biggers if (tsgl->sgl[i].offset != tsgl->sgl_saved[i].offset) 6983f47a03dSEric Biggers return true; 6993f47a03dSEric Biggers if (tsgl->sgl[i].length != tsgl->sgl_saved[i].length) 7003f47a03dSEric Biggers return true; 7013f47a03dSEric Biggers } 7023f47a03dSEric Biggers return false; 7033f47a03dSEric Biggers } 7043f47a03dSEric Biggers 7053f47a03dSEric Biggers struct cipher_test_sglists { 7063f47a03dSEric Biggers struct test_sglist src; 7073f47a03dSEric Biggers struct test_sglist dst; 7083f47a03dSEric Biggers }; 7093f47a03dSEric Biggers 7103f47a03dSEric Biggers static struct cipher_test_sglists *alloc_cipher_test_sglists(void) 7113f47a03dSEric Biggers { 7123f47a03dSEric Biggers struct cipher_test_sglists *tsgls; 7133f47a03dSEric Biggers 7143f47a03dSEric Biggers tsgls = kmalloc(sizeof(*tsgls), GFP_KERNEL); 7153f47a03dSEric Biggers if (!tsgls) 7163f47a03dSEric Biggers return NULL; 7173f47a03dSEric Biggers 7183f47a03dSEric Biggers if (init_test_sglist(&tsgls->src) != 0) 7193f47a03dSEric Biggers goto fail_kfree; 7203f47a03dSEric Biggers if (init_test_sglist(&tsgls->dst) != 0) 7213f47a03dSEric Biggers goto fail_destroy_src; 7223f47a03dSEric Biggers 7233f47a03dSEric Biggers return tsgls; 7243f47a03dSEric Biggers 7253f47a03dSEric Biggers fail_destroy_src: 7263f47a03dSEric Biggers destroy_test_sglist(&tsgls->src); 7273f47a03dSEric Biggers fail_kfree: 7283f47a03dSEric Biggers kfree(tsgls); 7293f47a03dSEric Biggers return NULL; 7303f47a03dSEric Biggers } 7313f47a03dSEric Biggers 7323f47a03dSEric Biggers static void free_cipher_test_sglists(struct cipher_test_sglists *tsgls) 7333f47a03dSEric Biggers { 7343f47a03dSEric Biggers if (tsgls) { 7353f47a03dSEric Biggers destroy_test_sglist(&tsgls->src); 7363f47a03dSEric Biggers destroy_test_sglist(&tsgls->dst); 7373f47a03dSEric Biggers kfree(tsgls); 7383f47a03dSEric Biggers } 7393f47a03dSEric Biggers } 7403f47a03dSEric Biggers 7413f47a03dSEric Biggers /* Build the src and dst scatterlists for an skcipher or AEAD test */ 7423f47a03dSEric Biggers static int build_cipher_test_sglists(struct cipher_test_sglists *tsgls, 7433f47a03dSEric Biggers const struct testvec_config *cfg, 7443f47a03dSEric Biggers unsigned int alignmask, 7453f47a03dSEric Biggers unsigned int src_total_len, 7463f47a03dSEric Biggers unsigned int dst_total_len, 7473f47a03dSEric Biggers const struct kvec *inputs, 7483f47a03dSEric Biggers unsigned int nr_inputs) 7493f47a03dSEric Biggers { 7503f47a03dSEric Biggers struct iov_iter input; 7513f47a03dSEric Biggers int err; 7523f47a03dSEric Biggers 7533f47a03dSEric Biggers iov_iter_kvec(&input, WRITE, inputs, nr_inputs, src_total_len); 7543f47a03dSEric Biggers err = build_test_sglist(&tsgls->src, cfg->src_divs, alignmask, 7553f47a03dSEric Biggers cfg->inplace ? 7563f47a03dSEric Biggers max(dst_total_len, src_total_len) : 7573f47a03dSEric Biggers src_total_len, 7583f47a03dSEric Biggers &input, NULL); 7593f47a03dSEric Biggers if (err) 7603f47a03dSEric Biggers return err; 7613f47a03dSEric Biggers 7623f47a03dSEric Biggers if (cfg->inplace) { 7633f47a03dSEric Biggers tsgls->dst.sgl_ptr = tsgls->src.sgl; 7643f47a03dSEric Biggers tsgls->dst.nents = tsgls->src.nents; 7653f47a03dSEric Biggers return 0; 7663f47a03dSEric Biggers } 7673f47a03dSEric Biggers return build_test_sglist(&tsgls->dst, 7683f47a03dSEric Biggers cfg->dst_divs[0].proportion_of_total ? 7693f47a03dSEric Biggers cfg->dst_divs : cfg->src_divs, 7703f47a03dSEric Biggers alignmask, dst_total_len, NULL, NULL); 771f8b0d4d0SHerbert Xu } 772f8b0d4d0SHerbert Xu 773fd8c37c7SEric Biggers /* 774fd8c37c7SEric Biggers * Support for testing passing a misaligned key to setkey(): 775fd8c37c7SEric Biggers * 776fd8c37c7SEric Biggers * If cfg->key_offset is set, copy the key into a new buffer at that offset, 777fd8c37c7SEric Biggers * optionally adding alignmask. Else, just use the key directly. 778fd8c37c7SEric Biggers */ 779fd8c37c7SEric Biggers static int prepare_keybuf(const u8 *key, unsigned int ksize, 780fd8c37c7SEric Biggers const struct testvec_config *cfg, 781fd8c37c7SEric Biggers unsigned int alignmask, 782fd8c37c7SEric Biggers const u8 **keybuf_ret, const u8 **keyptr_ret) 783fd8c37c7SEric Biggers { 784fd8c37c7SEric Biggers unsigned int key_offset = cfg->key_offset; 785fd8c37c7SEric Biggers u8 *keybuf = NULL, *keyptr = (u8 *)key; 786fd8c37c7SEric Biggers 787fd8c37c7SEric Biggers if (key_offset != 0) { 788fd8c37c7SEric Biggers if (cfg->key_offset_relative_to_alignmask) 789fd8c37c7SEric Biggers key_offset += alignmask; 790fd8c37c7SEric Biggers keybuf = kmalloc(key_offset + ksize, GFP_KERNEL); 791fd8c37c7SEric Biggers if (!keybuf) 792fd8c37c7SEric Biggers return -ENOMEM; 793fd8c37c7SEric Biggers keyptr = keybuf + key_offset; 794fd8c37c7SEric Biggers memcpy(keyptr, key, ksize); 795fd8c37c7SEric Biggers } 796fd8c37c7SEric Biggers *keybuf_ret = keybuf; 797fd8c37c7SEric Biggers *keyptr_ret = keyptr; 798fd8c37c7SEric Biggers return 0; 799fd8c37c7SEric Biggers } 800fd8c37c7SEric Biggers 801fd8c37c7SEric Biggers /* Like setkey_f(tfm, key, ksize), but sometimes misalign the key */ 802fd8c37c7SEric Biggers #define do_setkey(setkey_f, tfm, key, ksize, cfg, alignmask) \ 803fd8c37c7SEric Biggers ({ \ 804fd8c37c7SEric Biggers const u8 *keybuf, *keyptr; \ 805fd8c37c7SEric Biggers int err; \ 806fd8c37c7SEric Biggers \ 807fd8c37c7SEric Biggers err = prepare_keybuf((key), (ksize), (cfg), (alignmask), \ 808fd8c37c7SEric Biggers &keybuf, &keyptr); \ 809fd8c37c7SEric Biggers if (err == 0) { \ 810fd8c37c7SEric Biggers err = setkey_f((tfm), keyptr, (ksize)); \ 811fd8c37c7SEric Biggers kfree(keybuf); \ 812fd8c37c7SEric Biggers } \ 813fd8c37c7SEric Biggers err; \ 814fd8c37c7SEric Biggers }) 815fd8c37c7SEric Biggers 81625f9dddbSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 817f2bb770aSEric Biggers 818f2bb770aSEric Biggers /* Generate a random length in range [0, max_len], but prefer smaller values */ 819f2bb770aSEric Biggers static unsigned int generate_random_length(unsigned int max_len) 820f2bb770aSEric Biggers { 821f2bb770aSEric Biggers unsigned int len = prandom_u32() % (max_len + 1); 822f2bb770aSEric Biggers 823f2bb770aSEric Biggers switch (prandom_u32() % 4) { 824f2bb770aSEric Biggers case 0: 825f2bb770aSEric Biggers return len % 64; 826f2bb770aSEric Biggers case 1: 827f2bb770aSEric Biggers return len % 256; 828f2bb770aSEric Biggers case 2: 829f2bb770aSEric Biggers return len % 1024; 830f2bb770aSEric Biggers default: 831f2bb770aSEric Biggers return len; 832f2bb770aSEric Biggers } 833f2bb770aSEric Biggers } 834f2bb770aSEric Biggers 83549763fc6SEric Biggers /* Flip a random bit in the given nonempty data buffer */ 83649763fc6SEric Biggers static void flip_random_bit(u8 *buf, size_t size) 83749763fc6SEric Biggers { 83849763fc6SEric Biggers size_t bitpos; 83949763fc6SEric Biggers 84049763fc6SEric Biggers bitpos = prandom_u32() % (size * 8); 84149763fc6SEric Biggers buf[bitpos / 8] ^= 1 << (bitpos % 8); 84249763fc6SEric Biggers } 84349763fc6SEric Biggers 84449763fc6SEric Biggers /* Flip a random byte in the given nonempty data buffer */ 84549763fc6SEric Biggers static void flip_random_byte(u8 *buf, size_t size) 84649763fc6SEric Biggers { 84749763fc6SEric Biggers buf[prandom_u32() % size] ^= 0xff; 84849763fc6SEric Biggers } 84949763fc6SEric Biggers 85049763fc6SEric Biggers /* Sometimes make some random changes to the given nonempty data buffer */ 85149763fc6SEric Biggers static void mutate_buffer(u8 *buf, size_t size) 852f2bb770aSEric Biggers { 853f2bb770aSEric Biggers size_t num_flips; 854f2bb770aSEric Biggers size_t i; 855f2bb770aSEric Biggers 856f2bb770aSEric Biggers /* Sometimes flip some bits */ 857f2bb770aSEric Biggers if (prandom_u32() % 4 == 0) { 85849763fc6SEric Biggers num_flips = min_t(size_t, 1 << (prandom_u32() % 8), size * 8); 85949763fc6SEric Biggers for (i = 0; i < num_flips; i++) 86049763fc6SEric Biggers flip_random_bit(buf, size); 861f2bb770aSEric Biggers } 862f2bb770aSEric Biggers 863f2bb770aSEric Biggers /* Sometimes flip some bytes */ 864f2bb770aSEric Biggers if (prandom_u32() % 4 == 0) { 86549763fc6SEric Biggers num_flips = min_t(size_t, 1 << (prandom_u32() % 8), size); 866f2bb770aSEric Biggers for (i = 0; i < num_flips; i++) 86749763fc6SEric Biggers flip_random_byte(buf, size); 868f2bb770aSEric Biggers } 869f2bb770aSEric Biggers } 870f2bb770aSEric Biggers 871f2bb770aSEric Biggers /* Randomly generate 'count' bytes, but sometimes make them "interesting" */ 872f2bb770aSEric Biggers static void generate_random_bytes(u8 *buf, size_t count) 873f2bb770aSEric Biggers { 874f2bb770aSEric Biggers u8 b; 875f2bb770aSEric Biggers u8 increment; 876f2bb770aSEric Biggers size_t i; 877f2bb770aSEric Biggers 878f2bb770aSEric Biggers if (count == 0) 879f2bb770aSEric Biggers return; 880f2bb770aSEric Biggers 881f2bb770aSEric Biggers switch (prandom_u32() % 8) { /* Choose a generation strategy */ 882f2bb770aSEric Biggers case 0: 883f2bb770aSEric Biggers case 1: 884f2bb770aSEric Biggers /* All the same byte, plus optional mutations */ 885f2bb770aSEric Biggers switch (prandom_u32() % 4) { 886f2bb770aSEric Biggers case 0: 887f2bb770aSEric Biggers b = 0x00; 888f2bb770aSEric Biggers break; 889f2bb770aSEric Biggers case 1: 890f2bb770aSEric Biggers b = 0xff; 891f2bb770aSEric Biggers break; 892f2bb770aSEric Biggers default: 893f2bb770aSEric Biggers b = (u8)prandom_u32(); 894f2bb770aSEric Biggers break; 895f2bb770aSEric Biggers } 896f2bb770aSEric Biggers memset(buf, b, count); 897f2bb770aSEric Biggers mutate_buffer(buf, count); 898f2bb770aSEric Biggers break; 899f2bb770aSEric Biggers case 2: 900f2bb770aSEric Biggers /* Ascending or descending bytes, plus optional mutations */ 901f2bb770aSEric Biggers increment = (u8)prandom_u32(); 902f2bb770aSEric Biggers b = (u8)prandom_u32(); 903f2bb770aSEric Biggers for (i = 0; i < count; i++, b += increment) 904f2bb770aSEric Biggers buf[i] = b; 905f2bb770aSEric Biggers mutate_buffer(buf, count); 906f2bb770aSEric Biggers break; 907f2bb770aSEric Biggers default: 908f2bb770aSEric Biggers /* Fully random bytes */ 909f2bb770aSEric Biggers for (i = 0; i < count; i++) 910f2bb770aSEric Biggers buf[i] = (u8)prandom_u32(); 911f2bb770aSEric Biggers } 912f2bb770aSEric Biggers } 913f2bb770aSEric Biggers 91425f9dddbSEric Biggers static char *generate_random_sgl_divisions(struct test_sg_division *divs, 91525f9dddbSEric Biggers size_t max_divs, char *p, char *end, 9166570737cSEric Biggers bool gen_flushes, u32 req_flags) 91725f9dddbSEric Biggers { 91825f9dddbSEric Biggers struct test_sg_division *div = divs; 91925f9dddbSEric Biggers unsigned int remaining = TEST_SG_TOTAL; 92025f9dddbSEric Biggers 92125f9dddbSEric Biggers do { 92225f9dddbSEric Biggers unsigned int this_len; 9236570737cSEric Biggers const char *flushtype_str; 92425f9dddbSEric Biggers 92525f9dddbSEric Biggers if (div == &divs[max_divs - 1] || prandom_u32() % 2 == 0) 92625f9dddbSEric Biggers this_len = remaining; 92725f9dddbSEric Biggers else 92825f9dddbSEric Biggers this_len = 1 + (prandom_u32() % remaining); 92925f9dddbSEric Biggers div->proportion_of_total = this_len; 93025f9dddbSEric Biggers 93125f9dddbSEric Biggers if (prandom_u32() % 4 == 0) 93225f9dddbSEric Biggers div->offset = (PAGE_SIZE - 128) + (prandom_u32() % 128); 93325f9dddbSEric Biggers else if (prandom_u32() % 2 == 0) 93425f9dddbSEric Biggers div->offset = prandom_u32() % 32; 93525f9dddbSEric Biggers else 93625f9dddbSEric Biggers div->offset = prandom_u32() % PAGE_SIZE; 93725f9dddbSEric Biggers if (prandom_u32() % 8 == 0) 93825f9dddbSEric Biggers div->offset_relative_to_alignmask = true; 93925f9dddbSEric Biggers 94025f9dddbSEric Biggers div->flush_type = FLUSH_TYPE_NONE; 94125f9dddbSEric Biggers if (gen_flushes) { 94225f9dddbSEric Biggers switch (prandom_u32() % 4) { 94325f9dddbSEric Biggers case 0: 94425f9dddbSEric Biggers div->flush_type = FLUSH_TYPE_REIMPORT; 94525f9dddbSEric Biggers break; 94625f9dddbSEric Biggers case 1: 94725f9dddbSEric Biggers div->flush_type = FLUSH_TYPE_FLUSH; 94825f9dddbSEric Biggers break; 94925f9dddbSEric Biggers } 95025f9dddbSEric Biggers } 95125f9dddbSEric Biggers 9526570737cSEric Biggers if (div->flush_type != FLUSH_TYPE_NONE && 9536570737cSEric Biggers !(req_flags & CRYPTO_TFM_REQ_MAY_SLEEP) && 9546570737cSEric Biggers prandom_u32() % 2 == 0) 9556570737cSEric Biggers div->nosimd = true; 9566570737cSEric Biggers 9576570737cSEric Biggers switch (div->flush_type) { 9586570737cSEric Biggers case FLUSH_TYPE_FLUSH: 9596570737cSEric Biggers if (div->nosimd) 9606570737cSEric Biggers flushtype_str = "<flush,nosimd>"; 9616570737cSEric Biggers else 9626570737cSEric Biggers flushtype_str = "<flush>"; 9636570737cSEric Biggers break; 9646570737cSEric Biggers case FLUSH_TYPE_REIMPORT: 9656570737cSEric Biggers if (div->nosimd) 9666570737cSEric Biggers flushtype_str = "<reimport,nosimd>"; 9676570737cSEric Biggers else 9686570737cSEric Biggers flushtype_str = "<reimport>"; 9696570737cSEric Biggers break; 9706570737cSEric Biggers default: 9716570737cSEric Biggers flushtype_str = ""; 9726570737cSEric Biggers break; 9736570737cSEric Biggers } 9746570737cSEric Biggers 97525f9dddbSEric Biggers BUILD_BUG_ON(TEST_SG_TOTAL != 10000); /* for "%u.%u%%" */ 9766570737cSEric Biggers p += scnprintf(p, end - p, "%s%u.%u%%@%s+%u%s", flushtype_str, 97725f9dddbSEric Biggers this_len / 100, this_len % 100, 97825f9dddbSEric Biggers div->offset_relative_to_alignmask ? 97925f9dddbSEric Biggers "alignmask" : "", 98025f9dddbSEric Biggers div->offset, this_len == remaining ? "" : ", "); 98125f9dddbSEric Biggers remaining -= this_len; 98225f9dddbSEric Biggers div++; 98325f9dddbSEric Biggers } while (remaining); 98425f9dddbSEric Biggers 98525f9dddbSEric Biggers return p; 98625f9dddbSEric Biggers } 98725f9dddbSEric Biggers 98825f9dddbSEric Biggers /* Generate a random testvec_config for fuzz testing */ 98925f9dddbSEric Biggers static void generate_random_testvec_config(struct testvec_config *cfg, 99025f9dddbSEric Biggers char *name, size_t max_namelen) 99125f9dddbSEric Biggers { 99225f9dddbSEric Biggers char *p = name; 99325f9dddbSEric Biggers char * const end = name + max_namelen; 99425f9dddbSEric Biggers 99525f9dddbSEric Biggers memset(cfg, 0, sizeof(*cfg)); 99625f9dddbSEric Biggers 99725f9dddbSEric Biggers cfg->name = name; 99825f9dddbSEric Biggers 99925f9dddbSEric Biggers p += scnprintf(p, end - p, "random:"); 100025f9dddbSEric Biggers 100125f9dddbSEric Biggers if (prandom_u32() % 2 == 0) { 100225f9dddbSEric Biggers cfg->inplace = true; 100325f9dddbSEric Biggers p += scnprintf(p, end - p, " inplace"); 100425f9dddbSEric Biggers } 100525f9dddbSEric Biggers 100625f9dddbSEric Biggers if (prandom_u32() % 2 == 0) { 100725f9dddbSEric Biggers cfg->req_flags |= CRYPTO_TFM_REQ_MAY_SLEEP; 100825f9dddbSEric Biggers p += scnprintf(p, end - p, " may_sleep"); 100925f9dddbSEric Biggers } 101025f9dddbSEric Biggers 101125f9dddbSEric Biggers switch (prandom_u32() % 4) { 101225f9dddbSEric Biggers case 0: 101325f9dddbSEric Biggers cfg->finalization_type = FINALIZATION_TYPE_FINAL; 101425f9dddbSEric Biggers p += scnprintf(p, end - p, " use_final"); 101525f9dddbSEric Biggers break; 101625f9dddbSEric Biggers case 1: 101725f9dddbSEric Biggers cfg->finalization_type = FINALIZATION_TYPE_FINUP; 101825f9dddbSEric Biggers p += scnprintf(p, end - p, " use_finup"); 101925f9dddbSEric Biggers break; 102025f9dddbSEric Biggers default: 102125f9dddbSEric Biggers cfg->finalization_type = FINALIZATION_TYPE_DIGEST; 102225f9dddbSEric Biggers p += scnprintf(p, end - p, " use_digest"); 102325f9dddbSEric Biggers break; 102425f9dddbSEric Biggers } 102525f9dddbSEric Biggers 10266570737cSEric Biggers if (!(cfg->req_flags & CRYPTO_TFM_REQ_MAY_SLEEP) && 10276570737cSEric Biggers prandom_u32() % 2 == 0) { 10286570737cSEric Biggers cfg->nosimd = true; 10296570737cSEric Biggers p += scnprintf(p, end - p, " nosimd"); 10306570737cSEric Biggers } 10316570737cSEric Biggers 103225f9dddbSEric Biggers p += scnprintf(p, end - p, " src_divs=["); 103325f9dddbSEric Biggers p = generate_random_sgl_divisions(cfg->src_divs, 103425f9dddbSEric Biggers ARRAY_SIZE(cfg->src_divs), p, end, 103525f9dddbSEric Biggers (cfg->finalization_type != 10366570737cSEric Biggers FINALIZATION_TYPE_DIGEST), 10376570737cSEric Biggers cfg->req_flags); 103825f9dddbSEric Biggers p += scnprintf(p, end - p, "]"); 103925f9dddbSEric Biggers 104025f9dddbSEric Biggers if (!cfg->inplace && prandom_u32() % 2 == 0) { 104125f9dddbSEric Biggers p += scnprintf(p, end - p, " dst_divs=["); 104225f9dddbSEric Biggers p = generate_random_sgl_divisions(cfg->dst_divs, 104325f9dddbSEric Biggers ARRAY_SIZE(cfg->dst_divs), 10446570737cSEric Biggers p, end, false, 10456570737cSEric Biggers cfg->req_flags); 104625f9dddbSEric Biggers p += scnprintf(p, end - p, "]"); 104725f9dddbSEric Biggers } 104825f9dddbSEric Biggers 104925f9dddbSEric Biggers if (prandom_u32() % 2 == 0) { 105025f9dddbSEric Biggers cfg->iv_offset = 1 + (prandom_u32() % MAX_ALGAPI_ALIGNMASK); 105125f9dddbSEric Biggers p += scnprintf(p, end - p, " iv_offset=%u", cfg->iv_offset); 105225f9dddbSEric Biggers } 105325f9dddbSEric Biggers 1054fd8c37c7SEric Biggers if (prandom_u32() % 2 == 0) { 1055fd8c37c7SEric Biggers cfg->key_offset = 1 + (prandom_u32() % MAX_ALGAPI_ALIGNMASK); 1056fd8c37c7SEric Biggers p += scnprintf(p, end - p, " key_offset=%u", cfg->key_offset); 1057fd8c37c7SEric Biggers } 1058fd8c37c7SEric Biggers 105925f9dddbSEric Biggers WARN_ON_ONCE(!valid_testvec_config(cfg)); 106025f9dddbSEric Biggers } 1061b55e1a39SEric Biggers 1062b55e1a39SEric Biggers static void crypto_disable_simd_for_test(void) 1063b55e1a39SEric Biggers { 1064b55e1a39SEric Biggers preempt_disable(); 1065b55e1a39SEric Biggers __this_cpu_write(crypto_simd_disabled_for_test, true); 1066b55e1a39SEric Biggers } 1067b55e1a39SEric Biggers 1068b55e1a39SEric Biggers static void crypto_reenable_simd_for_test(void) 1069b55e1a39SEric Biggers { 1070b55e1a39SEric Biggers __this_cpu_write(crypto_simd_disabled_for_test, false); 1071b55e1a39SEric Biggers preempt_enable(); 1072b55e1a39SEric Biggers } 1073f2bb770aSEric Biggers 1074f2bb770aSEric Biggers /* 1075f2bb770aSEric Biggers * Given an algorithm name, build the name of the generic implementation of that 1076f2bb770aSEric Biggers * algorithm, assuming the usual naming convention. Specifically, this appends 1077f2bb770aSEric Biggers * "-generic" to every part of the name that is not a template name. Examples: 1078f2bb770aSEric Biggers * 1079f2bb770aSEric Biggers * aes => aes-generic 1080f2bb770aSEric Biggers * cbc(aes) => cbc(aes-generic) 1081f2bb770aSEric Biggers * cts(cbc(aes)) => cts(cbc(aes-generic)) 1082f2bb770aSEric Biggers * rfc7539(chacha20,poly1305) => rfc7539(chacha20-generic,poly1305-generic) 1083f2bb770aSEric Biggers * 1084f2bb770aSEric Biggers * Return: 0 on success, or -ENAMETOOLONG if the generic name would be too long 1085f2bb770aSEric Biggers */ 1086f2bb770aSEric Biggers static int build_generic_driver_name(const char *algname, 1087f2bb770aSEric Biggers char driver_name[CRYPTO_MAX_ALG_NAME]) 1088f2bb770aSEric Biggers { 1089f2bb770aSEric Biggers const char *in = algname; 1090f2bb770aSEric Biggers char *out = driver_name; 1091f2bb770aSEric Biggers size_t len = strlen(algname); 1092f2bb770aSEric Biggers 1093f2bb770aSEric Biggers if (len >= CRYPTO_MAX_ALG_NAME) 1094f2bb770aSEric Biggers goto too_long; 1095f2bb770aSEric Biggers do { 1096f2bb770aSEric Biggers const char *in_saved = in; 1097f2bb770aSEric Biggers 1098f2bb770aSEric Biggers while (*in && *in != '(' && *in != ')' && *in != ',') 1099f2bb770aSEric Biggers *out++ = *in++; 1100f2bb770aSEric Biggers if (*in != '(' && in > in_saved) { 1101f2bb770aSEric Biggers len += 8; 1102f2bb770aSEric Biggers if (len >= CRYPTO_MAX_ALG_NAME) 1103f2bb770aSEric Biggers goto too_long; 1104f2bb770aSEric Biggers memcpy(out, "-generic", 8); 1105f2bb770aSEric Biggers out += 8; 1106f2bb770aSEric Biggers } 1107f2bb770aSEric Biggers } while ((*out++ = *in++) != '\0'); 1108f2bb770aSEric Biggers return 0; 1109f2bb770aSEric Biggers 1110f2bb770aSEric Biggers too_long: 1111f2bb770aSEric Biggers pr_err("alg: generic driver name for \"%s\" would be too long\n", 1112f2bb770aSEric Biggers algname); 1113f2bb770aSEric Biggers return -ENAMETOOLONG; 1114f2bb770aSEric Biggers } 1115b55e1a39SEric Biggers #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 1116b55e1a39SEric Biggers static void crypto_disable_simd_for_test(void) 1117b55e1a39SEric Biggers { 1118b55e1a39SEric Biggers } 1119b55e1a39SEric Biggers 1120b55e1a39SEric Biggers static void crypto_reenable_simd_for_test(void) 1121b55e1a39SEric Biggers { 1122b55e1a39SEric Biggers } 1123b55e1a39SEric Biggers #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 112425f9dddbSEric Biggers 1125d8ea98aaSEric Biggers static int build_hash_sglist(struct test_sglist *tsgl, 1126d8ea98aaSEric Biggers const struct hash_testvec *vec, 1127d8ea98aaSEric Biggers const struct testvec_config *cfg, 1128d8ea98aaSEric Biggers unsigned int alignmask, 1129d8ea98aaSEric Biggers const struct test_sg_division *divs[XBUFSIZE]) 1130d8ea98aaSEric Biggers { 1131d8ea98aaSEric Biggers struct kvec kv; 1132d8ea98aaSEric Biggers struct iov_iter input; 1133d8ea98aaSEric Biggers 1134d8ea98aaSEric Biggers kv.iov_base = (void *)vec->plaintext; 1135d8ea98aaSEric Biggers kv.iov_len = vec->psize; 1136d8ea98aaSEric Biggers iov_iter_kvec(&input, WRITE, &kv, 1, vec->psize); 1137d8ea98aaSEric Biggers return build_test_sglist(tsgl, cfg->src_divs, alignmask, vec->psize, 1138d8ea98aaSEric Biggers &input, divs); 1139d8ea98aaSEric Biggers } 1140d8ea98aaSEric Biggers 1141d8ea98aaSEric Biggers static int check_hash_result(const char *type, 1142d8ea98aaSEric Biggers const u8 *result, unsigned int digestsize, 1143d8ea98aaSEric Biggers const struct hash_testvec *vec, 1144d8ea98aaSEric Biggers const char *vec_name, 1145d8ea98aaSEric Biggers const char *driver, 1146d8ea98aaSEric Biggers const struct testvec_config *cfg) 1147d8ea98aaSEric Biggers { 1148d8ea98aaSEric Biggers if (memcmp(result, vec->digest, digestsize) != 0) { 1149d8ea98aaSEric Biggers pr_err("alg: %s: %s test failed (wrong result) on test vector %s, cfg=\"%s\"\n", 1150d8ea98aaSEric Biggers type, driver, vec_name, cfg->name); 1151d8ea98aaSEric Biggers return -EINVAL; 1152d8ea98aaSEric Biggers } 1153d8ea98aaSEric Biggers if (!testmgr_is_poison(&result[digestsize], TESTMGR_POISON_LEN)) { 1154d8ea98aaSEric Biggers pr_err("alg: %s: %s overran result buffer on test vector %s, cfg=\"%s\"\n", 1155d8ea98aaSEric Biggers type, driver, vec_name, cfg->name); 1156d8ea98aaSEric Biggers return -EOVERFLOW; 1157d8ea98aaSEric Biggers } 1158d8ea98aaSEric Biggers return 0; 1159d8ea98aaSEric Biggers } 1160d8ea98aaSEric Biggers 1161d8ea98aaSEric Biggers static inline int check_shash_op(const char *op, int err, 1162d8ea98aaSEric Biggers const char *driver, const char *vec_name, 1163d8ea98aaSEric Biggers const struct testvec_config *cfg) 1164d8ea98aaSEric Biggers { 1165d8ea98aaSEric Biggers if (err) 1166d8ea98aaSEric Biggers pr_err("alg: shash: %s %s() failed with err %d on test vector %s, cfg=\"%s\"\n", 1167d8ea98aaSEric Biggers driver, op, err, vec_name, cfg->name); 1168d8ea98aaSEric Biggers return err; 1169d8ea98aaSEric Biggers } 1170d8ea98aaSEric Biggers 1171d8ea98aaSEric Biggers /* Test one hash test vector in one configuration, using the shash API */ 117279cafe9aSEric Biggers static int test_shash_vec_cfg(const struct hash_testvec *vec, 1173d8ea98aaSEric Biggers const char *vec_name, 1174d8ea98aaSEric Biggers const struct testvec_config *cfg, 1175d8ea98aaSEric Biggers struct shash_desc *desc, 1176d8ea98aaSEric Biggers struct test_sglist *tsgl, 1177d8ea98aaSEric Biggers u8 *hashstate) 1178d8ea98aaSEric Biggers { 1179d8ea98aaSEric Biggers struct crypto_shash *tfm = desc->tfm; 1180d8ea98aaSEric Biggers const unsigned int alignmask = crypto_shash_alignmask(tfm); 1181d8ea98aaSEric Biggers const unsigned int digestsize = crypto_shash_digestsize(tfm); 1182d8ea98aaSEric Biggers const unsigned int statesize = crypto_shash_statesize(tfm); 118379cafe9aSEric Biggers const char *driver = crypto_shash_driver_name(tfm); 1184d8ea98aaSEric Biggers const struct test_sg_division *divs[XBUFSIZE]; 1185d8ea98aaSEric Biggers unsigned int i; 1186d8ea98aaSEric Biggers u8 result[HASH_MAX_DIGESTSIZE + TESTMGR_POISON_LEN]; 1187d8ea98aaSEric Biggers int err; 1188d8ea98aaSEric Biggers 1189d8ea98aaSEric Biggers /* Set the key, if specified */ 1190d8ea98aaSEric Biggers if (vec->ksize) { 1191fd8c37c7SEric Biggers err = do_setkey(crypto_shash_setkey, tfm, vec->key, vec->ksize, 1192fd8c37c7SEric Biggers cfg, alignmask); 1193d8ea98aaSEric Biggers if (err) { 1194d8ea98aaSEric Biggers if (err == vec->setkey_error) 1195d8ea98aaSEric Biggers return 0; 1196d8ea98aaSEric Biggers pr_err("alg: shash: %s setkey failed on test vector %s; expected_error=%d, actual_error=%d, flags=%#x\n", 1197d8ea98aaSEric Biggers driver, vec_name, vec->setkey_error, err, 1198d8ea98aaSEric Biggers crypto_shash_get_flags(tfm)); 1199d8ea98aaSEric Biggers return err; 1200d8ea98aaSEric Biggers } 1201d8ea98aaSEric Biggers if (vec->setkey_error) { 1202d8ea98aaSEric Biggers pr_err("alg: shash: %s setkey unexpectedly succeeded on test vector %s; expected_error=%d\n", 1203d8ea98aaSEric Biggers driver, vec_name, vec->setkey_error); 1204d8ea98aaSEric Biggers return -EINVAL; 1205d8ea98aaSEric Biggers } 1206d8ea98aaSEric Biggers } 1207d8ea98aaSEric Biggers 1208d8ea98aaSEric Biggers /* Build the scatterlist for the source data */ 1209d8ea98aaSEric Biggers err = build_hash_sglist(tsgl, vec, cfg, alignmask, divs); 1210d8ea98aaSEric Biggers if (err) { 1211d8ea98aaSEric Biggers pr_err("alg: shash: %s: error preparing scatterlist for test vector %s, cfg=\"%s\"\n", 1212d8ea98aaSEric Biggers driver, vec_name, cfg->name); 1213d8ea98aaSEric Biggers return err; 1214d8ea98aaSEric Biggers } 1215d8ea98aaSEric Biggers 1216d8ea98aaSEric Biggers /* Do the actual hashing */ 1217d8ea98aaSEric Biggers 1218d8ea98aaSEric Biggers testmgr_poison(desc->__ctx, crypto_shash_descsize(tfm)); 1219d8ea98aaSEric Biggers testmgr_poison(result, digestsize + TESTMGR_POISON_LEN); 1220d8ea98aaSEric Biggers 1221d8ea98aaSEric Biggers if (cfg->finalization_type == FINALIZATION_TYPE_DIGEST || 1222d8ea98aaSEric Biggers vec->digest_error) { 1223d8ea98aaSEric Biggers /* Just using digest() */ 1224d8ea98aaSEric Biggers if (tsgl->nents != 1) 1225d8ea98aaSEric Biggers return 0; 1226d8ea98aaSEric Biggers if (cfg->nosimd) 1227d8ea98aaSEric Biggers crypto_disable_simd_for_test(); 1228e40ff6f3SKai Ye err = crypto_shash_digest(desc, sg_virt(&tsgl->sgl[0]), 1229d8ea98aaSEric Biggers tsgl->sgl[0].length, result); 1230d8ea98aaSEric Biggers if (cfg->nosimd) 1231d8ea98aaSEric Biggers crypto_reenable_simd_for_test(); 1232d8ea98aaSEric Biggers if (err) { 1233d8ea98aaSEric Biggers if (err == vec->digest_error) 1234d8ea98aaSEric Biggers return 0; 1235d8ea98aaSEric Biggers pr_err("alg: shash: %s digest() failed on test vector %s; expected_error=%d, actual_error=%d, cfg=\"%s\"\n", 1236d8ea98aaSEric Biggers driver, vec_name, vec->digest_error, err, 1237d8ea98aaSEric Biggers cfg->name); 1238d8ea98aaSEric Biggers return err; 1239d8ea98aaSEric Biggers } 1240d8ea98aaSEric Biggers if (vec->digest_error) { 1241d8ea98aaSEric Biggers pr_err("alg: shash: %s digest() unexpectedly succeeded on test vector %s; expected_error=%d, cfg=\"%s\"\n", 1242d8ea98aaSEric Biggers driver, vec_name, vec->digest_error, cfg->name); 1243d8ea98aaSEric Biggers return -EINVAL; 1244d8ea98aaSEric Biggers } 1245d8ea98aaSEric Biggers goto result_ready; 1246d8ea98aaSEric Biggers } 1247d8ea98aaSEric Biggers 1248d8ea98aaSEric Biggers /* Using init(), zero or more update(), then final() or finup() */ 1249d8ea98aaSEric Biggers 1250d8ea98aaSEric Biggers if (cfg->nosimd) 1251d8ea98aaSEric Biggers crypto_disable_simd_for_test(); 1252d8ea98aaSEric Biggers err = crypto_shash_init(desc); 1253d8ea98aaSEric Biggers if (cfg->nosimd) 1254d8ea98aaSEric Biggers crypto_reenable_simd_for_test(); 1255d8ea98aaSEric Biggers err = check_shash_op("init", err, driver, vec_name, cfg); 1256d8ea98aaSEric Biggers if (err) 1257d8ea98aaSEric Biggers return err; 1258d8ea98aaSEric Biggers 1259d8ea98aaSEric Biggers for (i = 0; i < tsgl->nents; i++) { 1260d8ea98aaSEric Biggers if (i + 1 == tsgl->nents && 1261d8ea98aaSEric Biggers cfg->finalization_type == FINALIZATION_TYPE_FINUP) { 1262d8ea98aaSEric Biggers if (divs[i]->nosimd) 1263d8ea98aaSEric Biggers crypto_disable_simd_for_test(); 1264e40ff6f3SKai Ye err = crypto_shash_finup(desc, sg_virt(&tsgl->sgl[i]), 1265d8ea98aaSEric Biggers tsgl->sgl[i].length, result); 1266d8ea98aaSEric Biggers if (divs[i]->nosimd) 1267d8ea98aaSEric Biggers crypto_reenable_simd_for_test(); 1268d8ea98aaSEric Biggers err = check_shash_op("finup", err, driver, vec_name, 1269d8ea98aaSEric Biggers cfg); 1270d8ea98aaSEric Biggers if (err) 1271d8ea98aaSEric Biggers return err; 1272d8ea98aaSEric Biggers goto result_ready; 1273d8ea98aaSEric Biggers } 1274d8ea98aaSEric Biggers if (divs[i]->nosimd) 1275d8ea98aaSEric Biggers crypto_disable_simd_for_test(); 1276e40ff6f3SKai Ye err = crypto_shash_update(desc, sg_virt(&tsgl->sgl[i]), 1277d8ea98aaSEric Biggers tsgl->sgl[i].length); 1278d8ea98aaSEric Biggers if (divs[i]->nosimd) 1279d8ea98aaSEric Biggers crypto_reenable_simd_for_test(); 1280d8ea98aaSEric Biggers err = check_shash_op("update", err, driver, vec_name, cfg); 1281d8ea98aaSEric Biggers if (err) 1282d8ea98aaSEric Biggers return err; 1283d8ea98aaSEric Biggers if (divs[i]->flush_type == FLUSH_TYPE_REIMPORT) { 1284d8ea98aaSEric Biggers /* Test ->export() and ->import() */ 1285d8ea98aaSEric Biggers testmgr_poison(hashstate + statesize, 1286d8ea98aaSEric Biggers TESTMGR_POISON_LEN); 1287d8ea98aaSEric Biggers err = crypto_shash_export(desc, hashstate); 1288d8ea98aaSEric Biggers err = check_shash_op("export", err, driver, vec_name, 1289d8ea98aaSEric Biggers cfg); 1290d8ea98aaSEric Biggers if (err) 1291d8ea98aaSEric Biggers return err; 1292d8ea98aaSEric Biggers if (!testmgr_is_poison(hashstate + statesize, 1293d8ea98aaSEric Biggers TESTMGR_POISON_LEN)) { 1294d8ea98aaSEric Biggers pr_err("alg: shash: %s export() overran state buffer on test vector %s, cfg=\"%s\"\n", 1295d8ea98aaSEric Biggers driver, vec_name, cfg->name); 1296d8ea98aaSEric Biggers return -EOVERFLOW; 1297d8ea98aaSEric Biggers } 1298d8ea98aaSEric Biggers testmgr_poison(desc->__ctx, crypto_shash_descsize(tfm)); 1299d8ea98aaSEric Biggers err = crypto_shash_import(desc, hashstate); 1300d8ea98aaSEric Biggers err = check_shash_op("import", err, driver, vec_name, 1301d8ea98aaSEric Biggers cfg); 1302d8ea98aaSEric Biggers if (err) 1303d8ea98aaSEric Biggers return err; 1304d8ea98aaSEric Biggers } 1305d8ea98aaSEric Biggers } 1306d8ea98aaSEric Biggers 1307d8ea98aaSEric Biggers if (cfg->nosimd) 1308d8ea98aaSEric Biggers crypto_disable_simd_for_test(); 1309d8ea98aaSEric Biggers err = crypto_shash_final(desc, result); 1310d8ea98aaSEric Biggers if (cfg->nosimd) 1311d8ea98aaSEric Biggers crypto_reenable_simd_for_test(); 1312d8ea98aaSEric Biggers err = check_shash_op("final", err, driver, vec_name, cfg); 1313d8ea98aaSEric Biggers if (err) 1314d8ea98aaSEric Biggers return err; 1315d8ea98aaSEric Biggers result_ready: 1316d8ea98aaSEric Biggers return check_hash_result("shash", result, digestsize, vec, vec_name, 1317d8ea98aaSEric Biggers driver, cfg); 1318d8ea98aaSEric Biggers } 1319d8ea98aaSEric Biggers 13206570737cSEric Biggers static int do_ahash_op(int (*op)(struct ahash_request *req), 13216570737cSEric Biggers struct ahash_request *req, 13226570737cSEric Biggers struct crypto_wait *wait, bool nosimd) 13236570737cSEric Biggers { 13246570737cSEric Biggers int err; 13256570737cSEric Biggers 13266570737cSEric Biggers if (nosimd) 13276570737cSEric Biggers crypto_disable_simd_for_test(); 13286570737cSEric Biggers 13296570737cSEric Biggers err = op(req); 13306570737cSEric Biggers 13316570737cSEric Biggers if (nosimd) 13326570737cSEric Biggers crypto_reenable_simd_for_test(); 13336570737cSEric Biggers 13346570737cSEric Biggers return crypto_wait_req(err, wait); 13356570737cSEric Biggers } 13366570737cSEric Biggers 1337d8ea98aaSEric Biggers static int check_nonfinal_ahash_op(const char *op, int err, 13384cc2dcf9SEric Biggers u8 *result, unsigned int digestsize, 1339951d1332SEric Biggers const char *driver, const char *vec_name, 13404cc2dcf9SEric Biggers const struct testvec_config *cfg) 1341466d7b9fSKamil Konieczny { 13424cc2dcf9SEric Biggers if (err) { 1343d8ea98aaSEric Biggers pr_err("alg: ahash: %s %s() failed with err %d on test vector %s, cfg=\"%s\"\n", 1344951d1332SEric Biggers driver, op, err, vec_name, cfg->name); 13454cc2dcf9SEric Biggers return err; 13464cc2dcf9SEric Biggers } 13474cc2dcf9SEric Biggers if (!testmgr_is_poison(result, digestsize)) { 1348d8ea98aaSEric Biggers pr_err("alg: ahash: %s %s() used result buffer on test vector %s, cfg=\"%s\"\n", 1349951d1332SEric Biggers driver, op, vec_name, cfg->name); 1350466d7b9fSKamil Konieczny return -EINVAL; 1351466d7b9fSKamil Konieczny } 1352466d7b9fSKamil Konieczny return 0; 1353466d7b9fSKamil Konieczny } 1354466d7b9fSKamil Konieczny 1355d8ea98aaSEric Biggers /* Test one hash test vector in one configuration, using the ahash API */ 135679cafe9aSEric Biggers static int test_ahash_vec_cfg(const struct hash_testvec *vec, 1357951d1332SEric Biggers const char *vec_name, 13584cc2dcf9SEric Biggers const struct testvec_config *cfg, 13594cc2dcf9SEric Biggers struct ahash_request *req, 13604cc2dcf9SEric Biggers struct test_sglist *tsgl, 13614cc2dcf9SEric Biggers u8 *hashstate) 1362018ba95cSWang, Rui Y { 13634cc2dcf9SEric Biggers struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 13644cc2dcf9SEric Biggers const unsigned int alignmask = crypto_ahash_alignmask(tfm); 13654cc2dcf9SEric Biggers const unsigned int digestsize = crypto_ahash_digestsize(tfm); 13664cc2dcf9SEric Biggers const unsigned int statesize = crypto_ahash_statesize(tfm); 136779cafe9aSEric Biggers const char *driver = crypto_ahash_driver_name(tfm); 13684cc2dcf9SEric Biggers const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags; 13694cc2dcf9SEric Biggers const struct test_sg_division *divs[XBUFSIZE]; 13704cc2dcf9SEric Biggers DECLARE_CRYPTO_WAIT(wait); 13714cc2dcf9SEric Biggers unsigned int i; 13724cc2dcf9SEric Biggers struct scatterlist *pending_sgl; 13734cc2dcf9SEric Biggers unsigned int pending_len; 13744cc2dcf9SEric Biggers u8 result[HASH_MAX_DIGESTSIZE + TESTMGR_POISON_LEN]; 13754cc2dcf9SEric Biggers int err; 1376018ba95cSWang, Rui Y 13774cc2dcf9SEric Biggers /* Set the key, if specified */ 13784cc2dcf9SEric Biggers if (vec->ksize) { 1379fd8c37c7SEric Biggers err = do_setkey(crypto_ahash_setkey, tfm, vec->key, vec->ksize, 1380fd8c37c7SEric Biggers cfg, alignmask); 13814cc2dcf9SEric Biggers if (err) { 13825283a8eeSEric Biggers if (err == vec->setkey_error) 13835283a8eeSEric Biggers return 0; 1384d8ea98aaSEric Biggers pr_err("alg: ahash: %s setkey failed on test vector %s; expected_error=%d, actual_error=%d, flags=%#x\n", 1385951d1332SEric Biggers driver, vec_name, vec->setkey_error, err, 13864cc2dcf9SEric Biggers crypto_ahash_get_flags(tfm)); 13874cc2dcf9SEric Biggers return err; 1388da7f033dSHerbert Xu } 13895283a8eeSEric Biggers if (vec->setkey_error) { 1390d8ea98aaSEric Biggers pr_err("alg: ahash: %s setkey unexpectedly succeeded on test vector %s; expected_error=%d\n", 1391951d1332SEric Biggers driver, vec_name, vec->setkey_error); 13925283a8eeSEric Biggers return -EINVAL; 13935283a8eeSEric Biggers } 1394da7f033dSHerbert Xu } 1395da7f033dSHerbert Xu 13964cc2dcf9SEric Biggers /* Build the scatterlist for the source data */ 1397d8ea98aaSEric Biggers err = build_hash_sglist(tsgl, vec, cfg, alignmask, divs); 13984cc2dcf9SEric Biggers if (err) { 1399d8ea98aaSEric Biggers pr_err("alg: ahash: %s: error preparing scatterlist for test vector %s, cfg=\"%s\"\n", 1400951d1332SEric Biggers driver, vec_name, cfg->name); 14014cc2dcf9SEric Biggers return err; 1402a8f1a052SDavid S. Miller } 1403da7f033dSHerbert Xu 14044cc2dcf9SEric Biggers /* Do the actual hashing */ 1405da7f033dSHerbert Xu 14064cc2dcf9SEric Biggers testmgr_poison(req->__ctx, crypto_ahash_reqsize(tfm)); 14074cc2dcf9SEric Biggers testmgr_poison(result, digestsize + TESTMGR_POISON_LEN); 140876715095SGilad Ben-Yossef 14095283a8eeSEric Biggers if (cfg->finalization_type == FINALIZATION_TYPE_DIGEST || 14105283a8eeSEric Biggers vec->digest_error) { 14114cc2dcf9SEric Biggers /* Just using digest() */ 14124cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, crypto_req_done, 14137f397136SGilad Ben-Yossef &wait); 14144cc2dcf9SEric Biggers ahash_request_set_crypt(req, tsgl->sgl, result, vec->psize); 14156570737cSEric Biggers err = do_ahash_op(crypto_ahash_digest, req, &wait, cfg->nosimd); 14164cc2dcf9SEric Biggers if (err) { 14175283a8eeSEric Biggers if (err == vec->digest_error) 14185283a8eeSEric Biggers return 0; 1419d8ea98aaSEric Biggers pr_err("alg: ahash: %s digest() failed on test vector %s; expected_error=%d, actual_error=%d, cfg=\"%s\"\n", 1420951d1332SEric Biggers driver, vec_name, vec->digest_error, err, 14215283a8eeSEric Biggers cfg->name); 14224cc2dcf9SEric Biggers return err; 1423018ba95cSWang, Rui Y } 14245283a8eeSEric Biggers if (vec->digest_error) { 1425d8ea98aaSEric Biggers pr_err("alg: ahash: %s digest() unexpectedly succeeded on test vector %s; expected_error=%d, cfg=\"%s\"\n", 1426951d1332SEric Biggers driver, vec_name, vec->digest_error, cfg->name); 14275283a8eeSEric Biggers return -EINVAL; 14285283a8eeSEric Biggers } 14294cc2dcf9SEric Biggers goto result_ready; 1430018ba95cSWang, Rui Y } 14314cc2dcf9SEric Biggers 14324cc2dcf9SEric Biggers /* Using init(), zero or more update(), then final() or finup() */ 14334cc2dcf9SEric Biggers 14344cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, crypto_req_done, &wait); 14354cc2dcf9SEric Biggers ahash_request_set_crypt(req, NULL, result, 0); 14366570737cSEric Biggers err = do_ahash_op(crypto_ahash_init, req, &wait, cfg->nosimd); 1437d8ea98aaSEric Biggers err = check_nonfinal_ahash_op("init", err, result, digestsize, 1438951d1332SEric Biggers driver, vec_name, cfg); 14394cc2dcf9SEric Biggers if (err) 14404cc2dcf9SEric Biggers return err; 14414cc2dcf9SEric Biggers 14424cc2dcf9SEric Biggers pending_sgl = NULL; 14434cc2dcf9SEric Biggers pending_len = 0; 14444cc2dcf9SEric Biggers for (i = 0; i < tsgl->nents; i++) { 14454cc2dcf9SEric Biggers if (divs[i]->flush_type != FLUSH_TYPE_NONE && 14464cc2dcf9SEric Biggers pending_sgl != NULL) { 14474cc2dcf9SEric Biggers /* update() with the pending data */ 14484cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, 14494cc2dcf9SEric Biggers crypto_req_done, &wait); 14504cc2dcf9SEric Biggers ahash_request_set_crypt(req, pending_sgl, result, 14514cc2dcf9SEric Biggers pending_len); 14526570737cSEric Biggers err = do_ahash_op(crypto_ahash_update, req, &wait, 14536570737cSEric Biggers divs[i]->nosimd); 1454d8ea98aaSEric Biggers err = check_nonfinal_ahash_op("update", err, 14554cc2dcf9SEric Biggers result, digestsize, 1456951d1332SEric Biggers driver, vec_name, cfg); 14574cc2dcf9SEric Biggers if (err) 14584cc2dcf9SEric Biggers return err; 14594cc2dcf9SEric Biggers pending_sgl = NULL; 14604cc2dcf9SEric Biggers pending_len = 0; 1461018ba95cSWang, Rui Y } 14624cc2dcf9SEric Biggers if (divs[i]->flush_type == FLUSH_TYPE_REIMPORT) { 14634cc2dcf9SEric Biggers /* Test ->export() and ->import() */ 14644cc2dcf9SEric Biggers testmgr_poison(hashstate + statesize, 14654cc2dcf9SEric Biggers TESTMGR_POISON_LEN); 14664cc2dcf9SEric Biggers err = crypto_ahash_export(req, hashstate); 1467d8ea98aaSEric Biggers err = check_nonfinal_ahash_op("export", err, 14684cc2dcf9SEric Biggers result, digestsize, 1469951d1332SEric Biggers driver, vec_name, cfg); 14704cc2dcf9SEric Biggers if (err) 14714cc2dcf9SEric Biggers return err; 14724cc2dcf9SEric Biggers if (!testmgr_is_poison(hashstate + statesize, 14734cc2dcf9SEric Biggers TESTMGR_POISON_LEN)) { 1474d8ea98aaSEric Biggers pr_err("alg: ahash: %s export() overran state buffer on test vector %s, cfg=\"%s\"\n", 1475951d1332SEric Biggers driver, vec_name, cfg->name); 14764cc2dcf9SEric Biggers return -EOVERFLOW; 14774cc2dcf9SEric Biggers } 14784cc2dcf9SEric Biggers 14794cc2dcf9SEric Biggers testmgr_poison(req->__ctx, crypto_ahash_reqsize(tfm)); 14804cc2dcf9SEric Biggers err = crypto_ahash_import(req, hashstate); 1481d8ea98aaSEric Biggers err = check_nonfinal_ahash_op("import", err, 14824cc2dcf9SEric Biggers result, digestsize, 1483951d1332SEric Biggers driver, vec_name, cfg); 14844cc2dcf9SEric Biggers if (err) 14854cc2dcf9SEric Biggers return err; 14864cc2dcf9SEric Biggers } 14874cc2dcf9SEric Biggers if (pending_sgl == NULL) 14884cc2dcf9SEric Biggers pending_sgl = &tsgl->sgl[i]; 14894cc2dcf9SEric Biggers pending_len += tsgl->sgl[i].length; 14904cc2dcf9SEric Biggers } 14914cc2dcf9SEric Biggers 14924cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, crypto_req_done, &wait); 14934cc2dcf9SEric Biggers ahash_request_set_crypt(req, pending_sgl, result, pending_len); 14944cc2dcf9SEric Biggers if (cfg->finalization_type == FINALIZATION_TYPE_FINAL) { 14954cc2dcf9SEric Biggers /* finish with update() and final() */ 14966570737cSEric Biggers err = do_ahash_op(crypto_ahash_update, req, &wait, cfg->nosimd); 1497d8ea98aaSEric Biggers err = check_nonfinal_ahash_op("update", err, result, digestsize, 1498951d1332SEric Biggers driver, vec_name, cfg); 14994cc2dcf9SEric Biggers if (err) 15004cc2dcf9SEric Biggers return err; 15016570737cSEric Biggers err = do_ahash_op(crypto_ahash_final, req, &wait, cfg->nosimd); 15024cc2dcf9SEric Biggers if (err) { 1503d8ea98aaSEric Biggers pr_err("alg: ahash: %s final() failed with err %d on test vector %s, cfg=\"%s\"\n", 1504951d1332SEric Biggers driver, err, vec_name, cfg->name); 15054cc2dcf9SEric Biggers return err; 15064cc2dcf9SEric Biggers } 15074cc2dcf9SEric Biggers } else { 15084cc2dcf9SEric Biggers /* finish with finup() */ 15096570737cSEric Biggers err = do_ahash_op(crypto_ahash_finup, req, &wait, cfg->nosimd); 15104cc2dcf9SEric Biggers if (err) { 1511d8ea98aaSEric Biggers pr_err("alg: ahash: %s finup() failed with err %d on test vector %s, cfg=\"%s\"\n", 1512951d1332SEric Biggers driver, err, vec_name, cfg->name); 15134cc2dcf9SEric Biggers return err; 1514018ba95cSWang, Rui Y } 1515018ba95cSWang, Rui Y } 1516018ba95cSWang, Rui Y 15174cc2dcf9SEric Biggers result_ready: 1518d8ea98aaSEric Biggers return check_hash_result("ahash", result, digestsize, vec, vec_name, 1519d8ea98aaSEric Biggers driver, cfg); 1520da5ffe11SJussi Kivilinna } 1521da5ffe11SJussi Kivilinna 152279cafe9aSEric Biggers static int test_hash_vec_cfg(const struct hash_testvec *vec, 1523d8ea98aaSEric Biggers const char *vec_name, 1524d8ea98aaSEric Biggers const struct testvec_config *cfg, 1525d8ea98aaSEric Biggers struct ahash_request *req, 1526d8ea98aaSEric Biggers struct shash_desc *desc, 1527d8ea98aaSEric Biggers struct test_sglist *tsgl, 1528d8ea98aaSEric Biggers u8 *hashstate) 1529d8ea98aaSEric Biggers { 1530d8ea98aaSEric Biggers int err; 1531d8ea98aaSEric Biggers 1532d8ea98aaSEric Biggers /* 1533d8ea98aaSEric Biggers * For algorithms implemented as "shash", most bugs will be detected by 1534d8ea98aaSEric Biggers * both the shash and ahash tests. Test the shash API first so that the 1535d8ea98aaSEric Biggers * failures involve less indirection, so are easier to debug. 1536d8ea98aaSEric Biggers */ 1537d8ea98aaSEric Biggers 1538d8ea98aaSEric Biggers if (desc) { 153979cafe9aSEric Biggers err = test_shash_vec_cfg(vec, vec_name, cfg, desc, tsgl, 1540d8ea98aaSEric Biggers hashstate); 1541d8ea98aaSEric Biggers if (err) 1542d8ea98aaSEric Biggers return err; 1543d8ea98aaSEric Biggers } 1544d8ea98aaSEric Biggers 154579cafe9aSEric Biggers return test_ahash_vec_cfg(vec, vec_name, cfg, req, tsgl, hashstate); 1546da5ffe11SJussi Kivilinna } 1547da5ffe11SJussi Kivilinna 154879cafe9aSEric Biggers static int test_hash_vec(const struct hash_testvec *vec, unsigned int vec_num, 154979cafe9aSEric Biggers struct ahash_request *req, struct shash_desc *desc, 155079cafe9aSEric Biggers struct test_sglist *tsgl, u8 *hashstate) 15514cc2dcf9SEric Biggers { 1552951d1332SEric Biggers char vec_name[16]; 15534cc2dcf9SEric Biggers unsigned int i; 15544cc2dcf9SEric Biggers int err; 15554cc2dcf9SEric Biggers 1556951d1332SEric Biggers sprintf(vec_name, "%u", vec_num); 1557951d1332SEric Biggers 15584cc2dcf9SEric Biggers for (i = 0; i < ARRAY_SIZE(default_hash_testvec_configs); i++) { 155979cafe9aSEric Biggers err = test_hash_vec_cfg(vec, vec_name, 15604cc2dcf9SEric Biggers &default_hash_testvec_configs[i], 1561d8ea98aaSEric Biggers req, desc, tsgl, hashstate); 15624cc2dcf9SEric Biggers if (err) 15634cc2dcf9SEric Biggers return err; 15644cc2dcf9SEric Biggers } 15654cc2dcf9SEric Biggers 15664cc2dcf9SEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 15674cc2dcf9SEric Biggers if (!noextratests) { 15684cc2dcf9SEric Biggers struct testvec_config cfg; 15694cc2dcf9SEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 15704cc2dcf9SEric Biggers 15714cc2dcf9SEric Biggers for (i = 0; i < fuzz_iterations; i++) { 15724cc2dcf9SEric Biggers generate_random_testvec_config(&cfg, cfgname, 15734cc2dcf9SEric Biggers sizeof(cfgname)); 157479cafe9aSEric Biggers err = test_hash_vec_cfg(vec, vec_name, &cfg, 1575d8ea98aaSEric Biggers req, desc, tsgl, hashstate); 15764cc2dcf9SEric Biggers if (err) 15774cc2dcf9SEric Biggers return err; 1578e63e1b0dSEric Biggers cond_resched(); 15794cc2dcf9SEric Biggers } 15804cc2dcf9SEric Biggers } 15814cc2dcf9SEric Biggers #endif 15824cc2dcf9SEric Biggers return 0; 15834cc2dcf9SEric Biggers } 15844cc2dcf9SEric Biggers 15859a8a6b3fSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 15869a8a6b3fSEric Biggers /* 15879a8a6b3fSEric Biggers * Generate a hash test vector from the given implementation. 15889a8a6b3fSEric Biggers * Assumes the buffers in 'vec' were already allocated. 15899a8a6b3fSEric Biggers */ 1590149c4e6eSArnd Bergmann static void generate_random_hash_testvec(struct shash_desc *desc, 15919a8a6b3fSEric Biggers struct hash_testvec *vec, 15929a8a6b3fSEric Biggers unsigned int maxkeysize, 15939a8a6b3fSEric Biggers unsigned int maxdatasize, 15949a8a6b3fSEric Biggers char *name, size_t max_namelen) 15959a8a6b3fSEric Biggers { 15969a8a6b3fSEric Biggers /* Data */ 15979a8a6b3fSEric Biggers vec->psize = generate_random_length(maxdatasize); 15989a8a6b3fSEric Biggers generate_random_bytes((u8 *)vec->plaintext, vec->psize); 15999a8a6b3fSEric Biggers 16009a8a6b3fSEric Biggers /* 16019a8a6b3fSEric Biggers * Key: length in range [1, maxkeysize], but usually choose maxkeysize. 16029a8a6b3fSEric Biggers * If algorithm is unkeyed, then maxkeysize == 0 and set ksize = 0. 16039a8a6b3fSEric Biggers */ 16049a8a6b3fSEric Biggers vec->setkey_error = 0; 16059a8a6b3fSEric Biggers vec->ksize = 0; 16069a8a6b3fSEric Biggers if (maxkeysize) { 16079a8a6b3fSEric Biggers vec->ksize = maxkeysize; 16089a8a6b3fSEric Biggers if (prandom_u32() % 4 == 0) 16099a8a6b3fSEric Biggers vec->ksize = 1 + (prandom_u32() % maxkeysize); 16109a8a6b3fSEric Biggers generate_random_bytes((u8 *)vec->key, vec->ksize); 16119a8a6b3fSEric Biggers 1612149c4e6eSArnd Bergmann vec->setkey_error = crypto_shash_setkey(desc->tfm, vec->key, 16139a8a6b3fSEric Biggers vec->ksize); 16149a8a6b3fSEric Biggers /* If the key couldn't be set, no need to continue to digest. */ 16159a8a6b3fSEric Biggers if (vec->setkey_error) 16169a8a6b3fSEric Biggers goto done; 16179a8a6b3fSEric Biggers } 16189a8a6b3fSEric Biggers 16199a8a6b3fSEric Biggers /* Digest */ 16209a8a6b3fSEric Biggers vec->digest_error = crypto_shash_digest(desc, vec->plaintext, 16219a8a6b3fSEric Biggers vec->psize, (u8 *)vec->digest); 16229a8a6b3fSEric Biggers done: 16239a8a6b3fSEric Biggers snprintf(name, max_namelen, "\"random: psize=%u ksize=%u\"", 16249a8a6b3fSEric Biggers vec->psize, vec->ksize); 16259a8a6b3fSEric Biggers } 16269a8a6b3fSEric Biggers 16279a8a6b3fSEric Biggers /* 16289a8a6b3fSEric Biggers * Test the hash algorithm represented by @req against the corresponding generic 16299a8a6b3fSEric Biggers * implementation, if one is available. 16309a8a6b3fSEric Biggers */ 163179cafe9aSEric Biggers static int test_hash_vs_generic_impl(const char *generic_driver, 16329a8a6b3fSEric Biggers unsigned int maxkeysize, 16339a8a6b3fSEric Biggers struct ahash_request *req, 1634d8ea98aaSEric Biggers struct shash_desc *desc, 16359a8a6b3fSEric Biggers struct test_sglist *tsgl, 16369a8a6b3fSEric Biggers u8 *hashstate) 16379a8a6b3fSEric Biggers { 16389a8a6b3fSEric Biggers struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 16399a8a6b3fSEric Biggers const unsigned int digestsize = crypto_ahash_digestsize(tfm); 16409a8a6b3fSEric Biggers const unsigned int blocksize = crypto_ahash_blocksize(tfm); 16419a8a6b3fSEric Biggers const unsigned int maxdatasize = (2 * PAGE_SIZE) - TESTMGR_POISON_LEN; 16429a8a6b3fSEric Biggers const char *algname = crypto_hash_alg_common(tfm)->base.cra_name; 164379cafe9aSEric Biggers const char *driver = crypto_ahash_driver_name(tfm); 16449a8a6b3fSEric Biggers char _generic_driver[CRYPTO_MAX_ALG_NAME]; 16459a8a6b3fSEric Biggers struct crypto_shash *generic_tfm = NULL; 1646149c4e6eSArnd Bergmann struct shash_desc *generic_desc = NULL; 16479a8a6b3fSEric Biggers unsigned int i; 16489a8a6b3fSEric Biggers struct hash_testvec vec = { 0 }; 16499a8a6b3fSEric Biggers char vec_name[64]; 16506b5ca646SArnd Bergmann struct testvec_config *cfg; 16519a8a6b3fSEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 16529a8a6b3fSEric Biggers int err; 16539a8a6b3fSEric Biggers 16549a8a6b3fSEric Biggers if (noextratests) 16559a8a6b3fSEric Biggers return 0; 16569a8a6b3fSEric Biggers 16579a8a6b3fSEric Biggers if (!generic_driver) { /* Use default naming convention? */ 16589a8a6b3fSEric Biggers err = build_generic_driver_name(algname, _generic_driver); 16599a8a6b3fSEric Biggers if (err) 16609a8a6b3fSEric Biggers return err; 16619a8a6b3fSEric Biggers generic_driver = _generic_driver; 16629a8a6b3fSEric Biggers } 16639a8a6b3fSEric Biggers 16649a8a6b3fSEric Biggers if (strcmp(generic_driver, driver) == 0) /* Already the generic impl? */ 16659a8a6b3fSEric Biggers return 0; 16669a8a6b3fSEric Biggers 16679a8a6b3fSEric Biggers generic_tfm = crypto_alloc_shash(generic_driver, 0, 0); 16689a8a6b3fSEric Biggers if (IS_ERR(generic_tfm)) { 16699a8a6b3fSEric Biggers err = PTR_ERR(generic_tfm); 16709a8a6b3fSEric Biggers if (err == -ENOENT) { 16719a8a6b3fSEric Biggers pr_warn("alg: hash: skipping comparison tests for %s because %s is unavailable\n", 16729a8a6b3fSEric Biggers driver, generic_driver); 16739a8a6b3fSEric Biggers return 0; 16749a8a6b3fSEric Biggers } 16759a8a6b3fSEric Biggers pr_err("alg: hash: error allocating %s (generic impl of %s): %d\n", 16769a8a6b3fSEric Biggers generic_driver, algname, err); 16779a8a6b3fSEric Biggers return err; 16789a8a6b3fSEric Biggers } 16799a8a6b3fSEric Biggers 16806b5ca646SArnd Bergmann cfg = kzalloc(sizeof(*cfg), GFP_KERNEL); 16816b5ca646SArnd Bergmann if (!cfg) { 16826b5ca646SArnd Bergmann err = -ENOMEM; 16836b5ca646SArnd Bergmann goto out; 16846b5ca646SArnd Bergmann } 16856b5ca646SArnd Bergmann 1686149c4e6eSArnd Bergmann generic_desc = kzalloc(sizeof(*desc) + 1687149c4e6eSArnd Bergmann crypto_shash_descsize(generic_tfm), GFP_KERNEL); 1688149c4e6eSArnd Bergmann if (!generic_desc) { 1689149c4e6eSArnd Bergmann err = -ENOMEM; 1690149c4e6eSArnd Bergmann goto out; 1691149c4e6eSArnd Bergmann } 1692149c4e6eSArnd Bergmann generic_desc->tfm = generic_tfm; 1693149c4e6eSArnd Bergmann 16949a8a6b3fSEric Biggers /* Check the algorithm properties for consistency. */ 16959a8a6b3fSEric Biggers 16969a8a6b3fSEric Biggers if (digestsize != crypto_shash_digestsize(generic_tfm)) { 16979a8a6b3fSEric Biggers pr_err("alg: hash: digestsize for %s (%u) doesn't match generic impl (%u)\n", 16989a8a6b3fSEric Biggers driver, digestsize, 16999a8a6b3fSEric Biggers crypto_shash_digestsize(generic_tfm)); 17009a8a6b3fSEric Biggers err = -EINVAL; 17019a8a6b3fSEric Biggers goto out; 17029a8a6b3fSEric Biggers } 17039a8a6b3fSEric Biggers 17049a8a6b3fSEric Biggers if (blocksize != crypto_shash_blocksize(generic_tfm)) { 17059a8a6b3fSEric Biggers pr_err("alg: hash: blocksize for %s (%u) doesn't match generic impl (%u)\n", 17069a8a6b3fSEric Biggers driver, blocksize, crypto_shash_blocksize(generic_tfm)); 17079a8a6b3fSEric Biggers err = -EINVAL; 17089a8a6b3fSEric Biggers goto out; 17099a8a6b3fSEric Biggers } 17109a8a6b3fSEric Biggers 17119a8a6b3fSEric Biggers /* 17129a8a6b3fSEric Biggers * Now generate test vectors using the generic implementation, and test 17139a8a6b3fSEric Biggers * the other implementation against them. 17149a8a6b3fSEric Biggers */ 17159a8a6b3fSEric Biggers 17169a8a6b3fSEric Biggers vec.key = kmalloc(maxkeysize, GFP_KERNEL); 17179a8a6b3fSEric Biggers vec.plaintext = kmalloc(maxdatasize, GFP_KERNEL); 17189a8a6b3fSEric Biggers vec.digest = kmalloc(digestsize, GFP_KERNEL); 17199a8a6b3fSEric Biggers if (!vec.key || !vec.plaintext || !vec.digest) { 17209a8a6b3fSEric Biggers err = -ENOMEM; 17219a8a6b3fSEric Biggers goto out; 17229a8a6b3fSEric Biggers } 17239a8a6b3fSEric Biggers 17249a8a6b3fSEric Biggers for (i = 0; i < fuzz_iterations * 8; i++) { 1725149c4e6eSArnd Bergmann generate_random_hash_testvec(generic_desc, &vec, 17269a8a6b3fSEric Biggers maxkeysize, maxdatasize, 17279a8a6b3fSEric Biggers vec_name, sizeof(vec_name)); 17286b5ca646SArnd Bergmann generate_random_testvec_config(cfg, cfgname, sizeof(cfgname)); 17299a8a6b3fSEric Biggers 173079cafe9aSEric Biggers err = test_hash_vec_cfg(&vec, vec_name, cfg, 1731d8ea98aaSEric Biggers req, desc, tsgl, hashstate); 17329a8a6b3fSEric Biggers if (err) 17339a8a6b3fSEric Biggers goto out; 17349a8a6b3fSEric Biggers cond_resched(); 17359a8a6b3fSEric Biggers } 17369a8a6b3fSEric Biggers err = 0; 17379a8a6b3fSEric Biggers out: 17386b5ca646SArnd Bergmann kfree(cfg); 17399a8a6b3fSEric Biggers kfree(vec.key); 17409a8a6b3fSEric Biggers kfree(vec.plaintext); 17419a8a6b3fSEric Biggers kfree(vec.digest); 17429a8a6b3fSEric Biggers crypto_free_shash(generic_tfm); 1743453431a5SWaiman Long kfree_sensitive(generic_desc); 17449a8a6b3fSEric Biggers return err; 17459a8a6b3fSEric Biggers } 17469a8a6b3fSEric Biggers #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 174779cafe9aSEric Biggers static int test_hash_vs_generic_impl(const char *generic_driver, 17489a8a6b3fSEric Biggers unsigned int maxkeysize, 17499a8a6b3fSEric Biggers struct ahash_request *req, 1750d8ea98aaSEric Biggers struct shash_desc *desc, 17519a8a6b3fSEric Biggers struct test_sglist *tsgl, 17529a8a6b3fSEric Biggers u8 *hashstate) 17539a8a6b3fSEric Biggers { 17549a8a6b3fSEric Biggers return 0; 17559a8a6b3fSEric Biggers } 17569a8a6b3fSEric Biggers #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 17579a8a6b3fSEric Biggers 1758d8ea98aaSEric Biggers static int alloc_shash(const char *driver, u32 type, u32 mask, 1759d8ea98aaSEric Biggers struct crypto_shash **tfm_ret, 1760d8ea98aaSEric Biggers struct shash_desc **desc_ret) 1761d8ea98aaSEric Biggers { 1762d8ea98aaSEric Biggers struct crypto_shash *tfm; 1763d8ea98aaSEric Biggers struct shash_desc *desc; 1764d8ea98aaSEric Biggers 1765d8ea98aaSEric Biggers tfm = crypto_alloc_shash(driver, type, mask); 1766d8ea98aaSEric Biggers if (IS_ERR(tfm)) { 1767d8ea98aaSEric Biggers if (PTR_ERR(tfm) == -ENOENT) { 1768d8ea98aaSEric Biggers /* 1769d8ea98aaSEric Biggers * This algorithm is only available through the ahash 1770d8ea98aaSEric Biggers * API, not the shash API, so skip the shash tests. 1771d8ea98aaSEric Biggers */ 1772d8ea98aaSEric Biggers return 0; 1773d8ea98aaSEric Biggers } 1774d8ea98aaSEric Biggers pr_err("alg: hash: failed to allocate shash transform for %s: %ld\n", 1775d8ea98aaSEric Biggers driver, PTR_ERR(tfm)); 1776d8ea98aaSEric Biggers return PTR_ERR(tfm); 1777d8ea98aaSEric Biggers } 1778d8ea98aaSEric Biggers 1779d8ea98aaSEric Biggers desc = kmalloc(sizeof(*desc) + crypto_shash_descsize(tfm), GFP_KERNEL); 1780d8ea98aaSEric Biggers if (!desc) { 1781d8ea98aaSEric Biggers crypto_free_shash(tfm); 1782d8ea98aaSEric Biggers return -ENOMEM; 1783d8ea98aaSEric Biggers } 1784d8ea98aaSEric Biggers desc->tfm = tfm; 1785d8ea98aaSEric Biggers 1786d8ea98aaSEric Biggers *tfm_ret = tfm; 1787d8ea98aaSEric Biggers *desc_ret = desc; 1788d8ea98aaSEric Biggers return 0; 1789d8ea98aaSEric Biggers } 1790d8ea98aaSEric Biggers 17914cc2dcf9SEric Biggers static int __alg_test_hash(const struct hash_testvec *vecs, 17924cc2dcf9SEric Biggers unsigned int num_vecs, const char *driver, 17939a8a6b3fSEric Biggers u32 type, u32 mask, 17949a8a6b3fSEric Biggers const char *generic_driver, unsigned int maxkeysize) 17954cc2dcf9SEric Biggers { 1796d8ea98aaSEric Biggers struct crypto_ahash *atfm = NULL; 17974cc2dcf9SEric Biggers struct ahash_request *req = NULL; 1798d8ea98aaSEric Biggers struct crypto_shash *stfm = NULL; 1799d8ea98aaSEric Biggers struct shash_desc *desc = NULL; 18004cc2dcf9SEric Biggers struct test_sglist *tsgl = NULL; 18014cc2dcf9SEric Biggers u8 *hashstate = NULL; 1802d8ea98aaSEric Biggers unsigned int statesize; 18034cc2dcf9SEric Biggers unsigned int i; 18044cc2dcf9SEric Biggers int err; 18054cc2dcf9SEric Biggers 1806d8ea98aaSEric Biggers /* 1807d8ea98aaSEric Biggers * Always test the ahash API. This works regardless of whether the 1808d8ea98aaSEric Biggers * algorithm is implemented as ahash or shash. 1809d8ea98aaSEric Biggers */ 1810d8ea98aaSEric Biggers 1811d8ea98aaSEric Biggers atfm = crypto_alloc_ahash(driver, type, mask); 1812d8ea98aaSEric Biggers if (IS_ERR(atfm)) { 18134cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate transform for %s: %ld\n", 1814d8ea98aaSEric Biggers driver, PTR_ERR(atfm)); 1815d8ea98aaSEric Biggers return PTR_ERR(atfm); 18164cc2dcf9SEric Biggers } 181779cafe9aSEric Biggers driver = crypto_ahash_driver_name(atfm); 18184cc2dcf9SEric Biggers 1819d8ea98aaSEric Biggers req = ahash_request_alloc(atfm, GFP_KERNEL); 18204cc2dcf9SEric Biggers if (!req) { 18214cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate request for %s\n", 18224cc2dcf9SEric Biggers driver); 18234cc2dcf9SEric Biggers err = -ENOMEM; 18244cc2dcf9SEric Biggers goto out; 18254cc2dcf9SEric Biggers } 18264cc2dcf9SEric Biggers 1827d8ea98aaSEric Biggers /* 1828d8ea98aaSEric Biggers * If available also test the shash API, to cover corner cases that may 1829d8ea98aaSEric Biggers * be missed by testing the ahash API only. 1830d8ea98aaSEric Biggers */ 1831d8ea98aaSEric Biggers err = alloc_shash(driver, type, mask, &stfm, &desc); 1832d8ea98aaSEric Biggers if (err) 1833d8ea98aaSEric Biggers goto out; 1834d8ea98aaSEric Biggers 18354cc2dcf9SEric Biggers tsgl = kmalloc(sizeof(*tsgl), GFP_KERNEL); 18364cc2dcf9SEric Biggers if (!tsgl || init_test_sglist(tsgl) != 0) { 18374cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate test buffers for %s\n", 18384cc2dcf9SEric Biggers driver); 18394cc2dcf9SEric Biggers kfree(tsgl); 18404cc2dcf9SEric Biggers tsgl = NULL; 18414cc2dcf9SEric Biggers err = -ENOMEM; 18424cc2dcf9SEric Biggers goto out; 18434cc2dcf9SEric Biggers } 18444cc2dcf9SEric Biggers 1845d8ea98aaSEric Biggers statesize = crypto_ahash_statesize(atfm); 1846d8ea98aaSEric Biggers if (stfm) 1847d8ea98aaSEric Biggers statesize = max(statesize, crypto_shash_statesize(stfm)); 1848d8ea98aaSEric Biggers hashstate = kmalloc(statesize + TESTMGR_POISON_LEN, GFP_KERNEL); 18494cc2dcf9SEric Biggers if (!hashstate) { 18504cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate hash state buffer for %s\n", 18514cc2dcf9SEric Biggers driver); 18524cc2dcf9SEric Biggers err = -ENOMEM; 18534cc2dcf9SEric Biggers goto out; 18544cc2dcf9SEric Biggers } 18554cc2dcf9SEric Biggers 18564cc2dcf9SEric Biggers for (i = 0; i < num_vecs; i++) { 185779cafe9aSEric Biggers err = test_hash_vec(&vecs[i], i, req, desc, tsgl, hashstate); 18584cc2dcf9SEric Biggers if (err) 18594cc2dcf9SEric Biggers goto out; 1860e63e1b0dSEric Biggers cond_resched(); 18614cc2dcf9SEric Biggers } 186279cafe9aSEric Biggers err = test_hash_vs_generic_impl(generic_driver, maxkeysize, req, 1863d8ea98aaSEric Biggers desc, tsgl, hashstate); 18644cc2dcf9SEric Biggers out: 18654cc2dcf9SEric Biggers kfree(hashstate); 18664cc2dcf9SEric Biggers if (tsgl) { 18674cc2dcf9SEric Biggers destroy_test_sglist(tsgl); 18684cc2dcf9SEric Biggers kfree(tsgl); 18694cc2dcf9SEric Biggers } 1870d8ea98aaSEric Biggers kfree(desc); 1871d8ea98aaSEric Biggers crypto_free_shash(stfm); 18724cc2dcf9SEric Biggers ahash_request_free(req); 1873d8ea98aaSEric Biggers crypto_free_ahash(atfm); 18744cc2dcf9SEric Biggers return err; 18754cc2dcf9SEric Biggers } 18764cc2dcf9SEric Biggers 18774cc2dcf9SEric Biggers static int alg_test_hash(const struct alg_test_desc *desc, const char *driver, 18784cc2dcf9SEric Biggers u32 type, u32 mask) 18794cc2dcf9SEric Biggers { 18804cc2dcf9SEric Biggers const struct hash_testvec *template = desc->suite.hash.vecs; 18814cc2dcf9SEric Biggers unsigned int tcount = desc->suite.hash.count; 18824cc2dcf9SEric Biggers unsigned int nr_unkeyed, nr_keyed; 18839a8a6b3fSEric Biggers unsigned int maxkeysize = 0; 18844cc2dcf9SEric Biggers int err; 18854cc2dcf9SEric Biggers 18864cc2dcf9SEric Biggers /* 18874cc2dcf9SEric Biggers * For OPTIONAL_KEY algorithms, we have to do all the unkeyed tests 18884cc2dcf9SEric Biggers * first, before setting a key on the tfm. To make this easier, we 18894cc2dcf9SEric Biggers * require that the unkeyed test vectors (if any) are listed first. 18904cc2dcf9SEric Biggers */ 18914cc2dcf9SEric Biggers 18924cc2dcf9SEric Biggers for (nr_unkeyed = 0; nr_unkeyed < tcount; nr_unkeyed++) { 18934cc2dcf9SEric Biggers if (template[nr_unkeyed].ksize) 18944cc2dcf9SEric Biggers break; 18954cc2dcf9SEric Biggers } 18964cc2dcf9SEric Biggers for (nr_keyed = 0; nr_unkeyed + nr_keyed < tcount; nr_keyed++) { 18974cc2dcf9SEric Biggers if (!template[nr_unkeyed + nr_keyed].ksize) { 18984cc2dcf9SEric Biggers pr_err("alg: hash: test vectors for %s out of order, " 18994cc2dcf9SEric Biggers "unkeyed ones must come first\n", desc->alg); 19004cc2dcf9SEric Biggers return -EINVAL; 19014cc2dcf9SEric Biggers } 19029a8a6b3fSEric Biggers maxkeysize = max_t(unsigned int, maxkeysize, 19039a8a6b3fSEric Biggers template[nr_unkeyed + nr_keyed].ksize); 19044cc2dcf9SEric Biggers } 19054cc2dcf9SEric Biggers 19064cc2dcf9SEric Biggers err = 0; 19074cc2dcf9SEric Biggers if (nr_unkeyed) { 19089a8a6b3fSEric Biggers err = __alg_test_hash(template, nr_unkeyed, driver, type, mask, 19099a8a6b3fSEric Biggers desc->generic_driver, maxkeysize); 19104cc2dcf9SEric Biggers template += nr_unkeyed; 19114cc2dcf9SEric Biggers } 19124cc2dcf9SEric Biggers 19134cc2dcf9SEric Biggers if (!err && nr_keyed) 19149a8a6b3fSEric Biggers err = __alg_test_hash(template, nr_keyed, driver, type, mask, 19159a8a6b3fSEric Biggers desc->generic_driver, maxkeysize); 19164cc2dcf9SEric Biggers 19174cc2dcf9SEric Biggers return err; 19184cc2dcf9SEric Biggers } 19194cc2dcf9SEric Biggers 19202257f471SEric Biggers static int test_aead_vec_cfg(int enc, const struct aead_testvec *vec, 1921951d1332SEric Biggers const char *vec_name, 1922ed96804fSEric Biggers const struct testvec_config *cfg, 1923ed96804fSEric Biggers struct aead_request *req, 1924ed96804fSEric Biggers struct cipher_test_sglists *tsgls) 1925da7f033dSHerbert Xu { 1926ed96804fSEric Biggers struct crypto_aead *tfm = crypto_aead_reqtfm(req); 1927ed96804fSEric Biggers const unsigned int alignmask = crypto_aead_alignmask(tfm); 1928ed96804fSEric Biggers const unsigned int ivsize = crypto_aead_ivsize(tfm); 1929ed96804fSEric Biggers const unsigned int authsize = vec->clen - vec->plen; 19302257f471SEric Biggers const char *driver = crypto_aead_driver_name(tfm); 1931ed96804fSEric Biggers const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags; 1932ed96804fSEric Biggers const char *op = enc ? "encryption" : "decryption"; 1933ed96804fSEric Biggers DECLARE_CRYPTO_WAIT(wait); 1934ed96804fSEric Biggers u8 _iv[3 * (MAX_ALGAPI_ALIGNMASK + 1) + MAX_IVLEN]; 1935ed96804fSEric Biggers u8 *iv = PTR_ALIGN(&_iv[0], 2 * (MAX_ALGAPI_ALIGNMASK + 1)) + 1936ed96804fSEric Biggers cfg->iv_offset + 1937ed96804fSEric Biggers (cfg->iv_offset_relative_to_alignmask ? alignmask : 0); 1938ed96804fSEric Biggers struct kvec input[2]; 1939ed96804fSEric Biggers int err; 1940f8b0d4d0SHerbert Xu 1941ed96804fSEric Biggers /* Set the key */ 1942ed96804fSEric Biggers if (vec->wk) 1943ed96804fSEric Biggers crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 1944d8a32ac2SJussi Kivilinna else 1945ed96804fSEric Biggers crypto_aead_clear_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 1946fd8c37c7SEric Biggers 1947fd8c37c7SEric Biggers err = do_setkey(crypto_aead_setkey, tfm, vec->key, vec->klen, 1948fd8c37c7SEric Biggers cfg, alignmask); 19495283a8eeSEric Biggers if (err && err != vec->setkey_error) { 1950951d1332SEric Biggers pr_err("alg: aead: %s setkey failed on test vector %s; expected_error=%d, actual_error=%d, flags=%#x\n", 1951951d1332SEric Biggers driver, vec_name, vec->setkey_error, err, 19525283a8eeSEric Biggers crypto_aead_get_flags(tfm)); 1953ed96804fSEric Biggers return err; 1954ed96804fSEric Biggers } 19555283a8eeSEric Biggers if (!err && vec->setkey_error) { 1956951d1332SEric Biggers pr_err("alg: aead: %s setkey unexpectedly succeeded on test vector %s; expected_error=%d\n", 1957951d1332SEric Biggers driver, vec_name, vec->setkey_error); 1958ed96804fSEric Biggers return -EINVAL; 1959ed96804fSEric Biggers } 1960d8a32ac2SJussi Kivilinna 1961ed96804fSEric Biggers /* Set the authentication tag size */ 1962ed96804fSEric Biggers err = crypto_aead_setauthsize(tfm, authsize); 19635283a8eeSEric Biggers if (err && err != vec->setauthsize_error) { 1964951d1332SEric Biggers pr_err("alg: aead: %s setauthsize failed on test vector %s; expected_error=%d, actual_error=%d\n", 1965951d1332SEric Biggers driver, vec_name, vec->setauthsize_error, err); 1966ed96804fSEric Biggers return err; 1967ed96804fSEric Biggers } 19685283a8eeSEric Biggers if (!err && vec->setauthsize_error) { 1969951d1332SEric Biggers pr_err("alg: aead: %s setauthsize unexpectedly succeeded on test vector %s; expected_error=%d\n", 1970951d1332SEric Biggers driver, vec_name, vec->setauthsize_error); 19715283a8eeSEric Biggers return -EINVAL; 19725283a8eeSEric Biggers } 19735283a8eeSEric Biggers 19745283a8eeSEric Biggers if (vec->setkey_error || vec->setauthsize_error) 19755283a8eeSEric Biggers return 0; 1976ed96804fSEric Biggers 1977ed96804fSEric Biggers /* The IV must be copied to a buffer, as the algorithm may modify it */ 1978ed96804fSEric Biggers if (WARN_ON(ivsize > MAX_IVLEN)) 1979ed96804fSEric Biggers return -EINVAL; 1980ed96804fSEric Biggers if (vec->iv) 1981ed96804fSEric Biggers memcpy(iv, vec->iv, ivsize); 1982da7f033dSHerbert Xu else 1983ed96804fSEric Biggers memset(iv, 0, ivsize); 1984da7f033dSHerbert Xu 1985ed96804fSEric Biggers /* Build the src/dst scatterlists */ 1986ed96804fSEric Biggers input[0].iov_base = (void *)vec->assoc; 1987ed96804fSEric Biggers input[0].iov_len = vec->alen; 1988ed96804fSEric Biggers input[1].iov_base = enc ? (void *)vec->ptext : (void *)vec->ctext; 1989ed96804fSEric Biggers input[1].iov_len = enc ? vec->plen : vec->clen; 1990ed96804fSEric Biggers err = build_cipher_test_sglists(tsgls, cfg, alignmask, 1991ed96804fSEric Biggers vec->alen + (enc ? vec->plen : 1992ed96804fSEric Biggers vec->clen), 1993ed96804fSEric Biggers vec->alen + (enc ? vec->clen : 1994ed96804fSEric Biggers vec->plen), 1995ed96804fSEric Biggers input, 2); 1996ed96804fSEric Biggers if (err) { 1997951d1332SEric Biggers pr_err("alg: aead: %s %s: error preparing scatterlists for test vector %s, cfg=\"%s\"\n", 1998951d1332SEric Biggers driver, op, vec_name, cfg->name); 1999ed96804fSEric Biggers return err; 2000da7f033dSHerbert Xu } 2001da7f033dSHerbert Xu 2002ed96804fSEric Biggers /* Do the actual encryption or decryption */ 2003ed96804fSEric Biggers testmgr_poison(req->__ctx, crypto_aead_reqsize(tfm)); 2004ed96804fSEric Biggers aead_request_set_callback(req, req_flags, crypto_req_done, &wait); 2005ed96804fSEric Biggers aead_request_set_crypt(req, tsgls->src.sgl_ptr, tsgls->dst.sgl_ptr, 2006ed96804fSEric Biggers enc ? vec->plen : vec->clen, iv); 2007ed96804fSEric Biggers aead_request_set_ad(req, vec->alen); 20086570737cSEric Biggers if (cfg->nosimd) 20096570737cSEric Biggers crypto_disable_simd_for_test(); 20106570737cSEric Biggers err = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req); 20116570737cSEric Biggers if (cfg->nosimd) 20126570737cSEric Biggers crypto_reenable_simd_for_test(); 20136570737cSEric Biggers err = crypto_wait_req(err, &wait); 201405b1d338SCristian Stoica 2015a6e5ef9bSEric Biggers /* Check that the algorithm didn't overwrite things it shouldn't have */ 2016a6e5ef9bSEric Biggers if (req->cryptlen != (enc ? vec->plen : vec->clen) || 2017a6e5ef9bSEric Biggers req->assoclen != vec->alen || 2018a6e5ef9bSEric Biggers req->iv != iv || 2019a6e5ef9bSEric Biggers req->src != tsgls->src.sgl_ptr || 2020a6e5ef9bSEric Biggers req->dst != tsgls->dst.sgl_ptr || 2021a6e5ef9bSEric Biggers crypto_aead_reqtfm(req) != tfm || 2022a6e5ef9bSEric Biggers req->base.complete != crypto_req_done || 2023a6e5ef9bSEric Biggers req->base.flags != req_flags || 2024a6e5ef9bSEric Biggers req->base.data != &wait) { 2025951d1332SEric Biggers pr_err("alg: aead: %s %s corrupted request struct on test vector %s, cfg=\"%s\"\n", 2026951d1332SEric Biggers driver, op, vec_name, cfg->name); 2027a6e5ef9bSEric Biggers if (req->cryptlen != (enc ? vec->plen : vec->clen)) 2028a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->cryptlen'\n"); 2029a6e5ef9bSEric Biggers if (req->assoclen != vec->alen) 2030a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->assoclen'\n"); 2031a6e5ef9bSEric Biggers if (req->iv != iv) 2032a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->iv'\n"); 2033a6e5ef9bSEric Biggers if (req->src != tsgls->src.sgl_ptr) 2034a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->src'\n"); 2035a6e5ef9bSEric Biggers if (req->dst != tsgls->dst.sgl_ptr) 2036a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->dst'\n"); 2037a6e5ef9bSEric Biggers if (crypto_aead_reqtfm(req) != tfm) 2038a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.tfm'\n"); 2039a6e5ef9bSEric Biggers if (req->base.complete != crypto_req_done) 2040a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.complete'\n"); 2041a6e5ef9bSEric Biggers if (req->base.flags != req_flags) 2042a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.flags'\n"); 2043a6e5ef9bSEric Biggers if (req->base.data != &wait) 2044a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.data'\n"); 2045a6e5ef9bSEric Biggers return -EINVAL; 2046a6e5ef9bSEric Biggers } 2047a6e5ef9bSEric Biggers if (is_test_sglist_corrupted(&tsgls->src)) { 2048951d1332SEric Biggers pr_err("alg: aead: %s %s corrupted src sgl on test vector %s, cfg=\"%s\"\n", 2049951d1332SEric Biggers driver, op, vec_name, cfg->name); 2050a6e5ef9bSEric Biggers return -EINVAL; 2051a6e5ef9bSEric Biggers } 2052a6e5ef9bSEric Biggers if (tsgls->dst.sgl_ptr != tsgls->src.sgl && 2053a6e5ef9bSEric Biggers is_test_sglist_corrupted(&tsgls->dst)) { 2054951d1332SEric Biggers pr_err("alg: aead: %s %s corrupted dst sgl on test vector %s, cfg=\"%s\"\n", 2055951d1332SEric Biggers driver, op, vec_name, cfg->name); 2056a6e5ef9bSEric Biggers return -EINVAL; 2057a6e5ef9bSEric Biggers } 2058a6e5ef9bSEric Biggers 205949763fc6SEric Biggers /* Check for unexpected success or failure, or wrong error code */ 206049763fc6SEric Biggers if ((err == 0 && vec->novrfy) || 206149763fc6SEric Biggers (err != vec->crypt_error && !(err == -EBADMSG && vec->novrfy))) { 206249763fc6SEric Biggers char expected_error[32]; 206349763fc6SEric Biggers 206449763fc6SEric Biggers if (vec->novrfy && 206549763fc6SEric Biggers vec->crypt_error != 0 && vec->crypt_error != -EBADMSG) 206649763fc6SEric Biggers sprintf(expected_error, "-EBADMSG or %d", 206749763fc6SEric Biggers vec->crypt_error); 206849763fc6SEric Biggers else if (vec->novrfy) 206949763fc6SEric Biggers sprintf(expected_error, "-EBADMSG"); 207049763fc6SEric Biggers else 207149763fc6SEric Biggers sprintf(expected_error, "%d", vec->crypt_error); 20725283a8eeSEric Biggers if (err) { 207349763fc6SEric Biggers pr_err("alg: aead: %s %s failed on test vector %s; expected_error=%s, actual_error=%d, cfg=\"%s\"\n", 207449763fc6SEric Biggers driver, op, vec_name, expected_error, err, 207549763fc6SEric Biggers cfg->name); 20765283a8eeSEric Biggers return err; 20775283a8eeSEric Biggers } 207849763fc6SEric Biggers pr_err("alg: aead: %s %s unexpectedly succeeded on test vector %s; expected_error=%s, cfg=\"%s\"\n", 2079951d1332SEric Biggers driver, op, vec_name, expected_error, cfg->name); 20805283a8eeSEric Biggers return -EINVAL; 20815283a8eeSEric Biggers } 208249763fc6SEric Biggers if (err) /* Expectedly failed. */ 208349763fc6SEric Biggers return 0; 20845283a8eeSEric Biggers 2085ed96804fSEric Biggers /* Check for the correct output (ciphertext or plaintext) */ 2086ed96804fSEric Biggers err = verify_correct_output(&tsgls->dst, enc ? vec->ctext : vec->ptext, 2087ed96804fSEric Biggers enc ? vec->clen : vec->plen, 2088ed96804fSEric Biggers vec->alen, enc || !cfg->inplace); 2089ed96804fSEric Biggers if (err == -EOVERFLOW) { 2090951d1332SEric Biggers pr_err("alg: aead: %s %s overran dst buffer on test vector %s, cfg=\"%s\"\n", 2091951d1332SEric Biggers driver, op, vec_name, cfg->name); 2092ed96804fSEric Biggers return err; 209329b77e5dSHoria Geanta } 2094ed96804fSEric Biggers if (err) { 2095951d1332SEric Biggers pr_err("alg: aead: %s %s test failed (wrong result) on test vector %s, cfg=\"%s\"\n", 2096951d1332SEric Biggers driver, op, vec_name, cfg->name); 2097ed96804fSEric Biggers return err; 209858dcf548SJussi Kivilinna } 209958dcf548SJussi Kivilinna 210058dcf548SJussi Kivilinna return 0; 2101d8a32ac2SJussi Kivilinna } 2102d8a32ac2SJussi Kivilinna 21032257f471SEric Biggers static int test_aead_vec(int enc, const struct aead_testvec *vec, 21042257f471SEric Biggers unsigned int vec_num, struct aead_request *req, 2105ed96804fSEric Biggers struct cipher_test_sglists *tsgls) 2106ed96804fSEric Biggers { 2107951d1332SEric Biggers char vec_name[16]; 2108ed96804fSEric Biggers unsigned int i; 2109ed96804fSEric Biggers int err; 2110ed96804fSEric Biggers 2111ed96804fSEric Biggers if (enc && vec->novrfy) 2112ed96804fSEric Biggers return 0; 2113ed96804fSEric Biggers 2114951d1332SEric Biggers sprintf(vec_name, "%u", vec_num); 2115951d1332SEric Biggers 2116ed96804fSEric Biggers for (i = 0; i < ARRAY_SIZE(default_cipher_testvec_configs); i++) { 21172257f471SEric Biggers err = test_aead_vec_cfg(enc, vec, vec_name, 2118ed96804fSEric Biggers &default_cipher_testvec_configs[i], 2119ed96804fSEric Biggers req, tsgls); 2120ed96804fSEric Biggers if (err) 2121ed96804fSEric Biggers return err; 2122ed96804fSEric Biggers } 2123ed96804fSEric Biggers 2124ed96804fSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 2125ed96804fSEric Biggers if (!noextratests) { 2126ed96804fSEric Biggers struct testvec_config cfg; 2127ed96804fSEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 2128ed96804fSEric Biggers 2129ed96804fSEric Biggers for (i = 0; i < fuzz_iterations; i++) { 2130ed96804fSEric Biggers generate_random_testvec_config(&cfg, cfgname, 2131ed96804fSEric Biggers sizeof(cfgname)); 21322257f471SEric Biggers err = test_aead_vec_cfg(enc, vec, vec_name, 2133ed96804fSEric Biggers &cfg, req, tsgls); 2134ed96804fSEric Biggers if (err) 2135ed96804fSEric Biggers return err; 2136e63e1b0dSEric Biggers cond_resched(); 2137ed96804fSEric Biggers } 2138ed96804fSEric Biggers } 2139ed96804fSEric Biggers #endif 2140ed96804fSEric Biggers return 0; 2141ed96804fSEric Biggers } 2142ed96804fSEric Biggers 214340153b10SEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 21442ea91505SEric Biggers 21452ea91505SEric Biggers struct aead_extra_tests_ctx { 21462ea91505SEric Biggers struct aead_request *req; 21472ea91505SEric Biggers struct crypto_aead *tfm; 21482ea91505SEric Biggers const struct alg_test_desc *test_desc; 21492ea91505SEric Biggers struct cipher_test_sglists *tsgls; 21502ea91505SEric Biggers unsigned int maxdatasize; 21512ea91505SEric Biggers unsigned int maxkeysize; 21522ea91505SEric Biggers 21532ea91505SEric Biggers struct aead_testvec vec; 21542ea91505SEric Biggers char vec_name[64]; 21552ea91505SEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 21562ea91505SEric Biggers struct testvec_config cfg; 21572ea91505SEric Biggers }; 21582ea91505SEric Biggers 215940153b10SEric Biggers /* 216049763fc6SEric Biggers * Make at least one random change to a (ciphertext, AAD) pair. "Ciphertext" 216149763fc6SEric Biggers * here means the full ciphertext including the authentication tag. The 216249763fc6SEric Biggers * authentication tag (and hence also the ciphertext) is assumed to be nonempty. 216349763fc6SEric Biggers */ 21646f3a06d9SEric Biggers static void mutate_aead_message(struct aead_testvec *vec, bool aad_iv, 21656f3a06d9SEric Biggers unsigned int ivsize) 216649763fc6SEric Biggers { 21676f3a06d9SEric Biggers const unsigned int aad_tail_size = aad_iv ? ivsize : 0; 216849763fc6SEric Biggers const unsigned int authsize = vec->clen - vec->plen; 216949763fc6SEric Biggers 217049763fc6SEric Biggers if (prandom_u32() % 2 == 0 && vec->alen > aad_tail_size) { 217149763fc6SEric Biggers /* Mutate the AAD */ 217249763fc6SEric Biggers flip_random_bit((u8 *)vec->assoc, vec->alen - aad_tail_size); 217349763fc6SEric Biggers if (prandom_u32() % 2 == 0) 217449763fc6SEric Biggers return; 217549763fc6SEric Biggers } 217649763fc6SEric Biggers if (prandom_u32() % 2 == 0) { 217749763fc6SEric Biggers /* Mutate auth tag (assuming it's at the end of ciphertext) */ 217849763fc6SEric Biggers flip_random_bit((u8 *)vec->ctext + vec->plen, authsize); 217949763fc6SEric Biggers } else { 218049763fc6SEric Biggers /* Mutate any part of the ciphertext */ 218149763fc6SEric Biggers flip_random_bit((u8 *)vec->ctext, vec->clen); 218249763fc6SEric Biggers } 218349763fc6SEric Biggers } 218449763fc6SEric Biggers 218549763fc6SEric Biggers /* 218649763fc6SEric Biggers * Minimum authentication tag size in bytes at which we assume that we can 218749763fc6SEric Biggers * reliably generate inauthentic messages, i.e. not generate an authentic 218849763fc6SEric Biggers * message by chance. 218949763fc6SEric Biggers */ 219049763fc6SEric Biggers #define MIN_COLLISION_FREE_AUTHSIZE 8 219149763fc6SEric Biggers 219249763fc6SEric Biggers static void generate_aead_message(struct aead_request *req, 219349763fc6SEric Biggers const struct aead_test_suite *suite, 219449763fc6SEric Biggers struct aead_testvec *vec, 219549763fc6SEric Biggers bool prefer_inauthentic) 219649763fc6SEric Biggers { 219749763fc6SEric Biggers struct crypto_aead *tfm = crypto_aead_reqtfm(req); 219849763fc6SEric Biggers const unsigned int ivsize = crypto_aead_ivsize(tfm); 219949763fc6SEric Biggers const unsigned int authsize = vec->clen - vec->plen; 220049763fc6SEric Biggers const bool inauthentic = (authsize >= MIN_COLLISION_FREE_AUTHSIZE) && 220149763fc6SEric Biggers (prefer_inauthentic || prandom_u32() % 4 == 0); 220249763fc6SEric Biggers 220349763fc6SEric Biggers /* Generate the AAD. */ 220449763fc6SEric Biggers generate_random_bytes((u8 *)vec->assoc, vec->alen); 22056f3a06d9SEric Biggers if (suite->aad_iv && vec->alen >= ivsize) 22066f3a06d9SEric Biggers /* Avoid implementation-defined behavior. */ 22076f3a06d9SEric Biggers memcpy((u8 *)vec->assoc + vec->alen - ivsize, vec->iv, ivsize); 220849763fc6SEric Biggers 220949763fc6SEric Biggers if (inauthentic && prandom_u32() % 2 == 0) { 221049763fc6SEric Biggers /* Generate a random ciphertext. */ 221149763fc6SEric Biggers generate_random_bytes((u8 *)vec->ctext, vec->clen); 221249763fc6SEric Biggers } else { 221349763fc6SEric Biggers int i = 0; 221449763fc6SEric Biggers struct scatterlist src[2], dst; 221549763fc6SEric Biggers u8 iv[MAX_IVLEN]; 221649763fc6SEric Biggers DECLARE_CRYPTO_WAIT(wait); 221749763fc6SEric Biggers 221849763fc6SEric Biggers /* Generate a random plaintext and encrypt it. */ 221949763fc6SEric Biggers sg_init_table(src, 2); 222049763fc6SEric Biggers if (vec->alen) 222149763fc6SEric Biggers sg_set_buf(&src[i++], vec->assoc, vec->alen); 222249763fc6SEric Biggers if (vec->plen) { 222349763fc6SEric Biggers generate_random_bytes((u8 *)vec->ptext, vec->plen); 222449763fc6SEric Biggers sg_set_buf(&src[i++], vec->ptext, vec->plen); 222549763fc6SEric Biggers } 222649763fc6SEric Biggers sg_init_one(&dst, vec->ctext, vec->alen + vec->clen); 222749763fc6SEric Biggers memcpy(iv, vec->iv, ivsize); 222849763fc6SEric Biggers aead_request_set_callback(req, 0, crypto_req_done, &wait); 222949763fc6SEric Biggers aead_request_set_crypt(req, src, &dst, vec->plen, iv); 223049763fc6SEric Biggers aead_request_set_ad(req, vec->alen); 223149763fc6SEric Biggers vec->crypt_error = crypto_wait_req(crypto_aead_encrypt(req), 223249763fc6SEric Biggers &wait); 223349763fc6SEric Biggers /* If encryption failed, we're done. */ 223449763fc6SEric Biggers if (vec->crypt_error != 0) 223549763fc6SEric Biggers return; 223649763fc6SEric Biggers memmove((u8 *)vec->ctext, vec->ctext + vec->alen, vec->clen); 223749763fc6SEric Biggers if (!inauthentic) 223849763fc6SEric Biggers return; 223949763fc6SEric Biggers /* 224049763fc6SEric Biggers * Mutate the authentic (ciphertext, AAD) pair to get an 224149763fc6SEric Biggers * inauthentic one. 224249763fc6SEric Biggers */ 22436f3a06d9SEric Biggers mutate_aead_message(vec, suite->aad_iv, ivsize); 224449763fc6SEric Biggers } 224549763fc6SEric Biggers vec->novrfy = 1; 224649763fc6SEric Biggers if (suite->einval_allowed) 224749763fc6SEric Biggers vec->crypt_error = -EINVAL; 224849763fc6SEric Biggers } 224949763fc6SEric Biggers 225049763fc6SEric Biggers /* 225149763fc6SEric Biggers * Generate an AEAD test vector 'vec' using the implementation specified by 225249763fc6SEric Biggers * 'req'. The buffers in 'vec' must already be allocated. 225349763fc6SEric Biggers * 225449763fc6SEric Biggers * If 'prefer_inauthentic' is true, then this function will generate inauthentic 225549763fc6SEric Biggers * test vectors (i.e. vectors with 'vec->novrfy=1') more often. 225640153b10SEric Biggers */ 225740153b10SEric Biggers static void generate_random_aead_testvec(struct aead_request *req, 225840153b10SEric Biggers struct aead_testvec *vec, 225949763fc6SEric Biggers const struct aead_test_suite *suite, 226040153b10SEric Biggers unsigned int maxkeysize, 226140153b10SEric Biggers unsigned int maxdatasize, 226249763fc6SEric Biggers char *name, size_t max_namelen, 226349763fc6SEric Biggers bool prefer_inauthentic) 226440153b10SEric Biggers { 226540153b10SEric Biggers struct crypto_aead *tfm = crypto_aead_reqtfm(req); 226640153b10SEric Biggers const unsigned int ivsize = crypto_aead_ivsize(tfm); 22672ea91505SEric Biggers const unsigned int maxauthsize = crypto_aead_maxauthsize(tfm); 226840153b10SEric Biggers unsigned int authsize; 226940153b10SEric Biggers unsigned int total_len; 227040153b10SEric Biggers 227140153b10SEric Biggers /* Key: length in [0, maxkeysize], but usually choose maxkeysize */ 227240153b10SEric Biggers vec->klen = maxkeysize; 227340153b10SEric Biggers if (prandom_u32() % 4 == 0) 227440153b10SEric Biggers vec->klen = prandom_u32() % (maxkeysize + 1); 227540153b10SEric Biggers generate_random_bytes((u8 *)vec->key, vec->klen); 227640153b10SEric Biggers vec->setkey_error = crypto_aead_setkey(tfm, vec->key, vec->klen); 227740153b10SEric Biggers 227840153b10SEric Biggers /* IV */ 227940153b10SEric Biggers generate_random_bytes((u8 *)vec->iv, ivsize); 228040153b10SEric Biggers 228140153b10SEric Biggers /* Tag length: in [0, maxauthsize], but usually choose maxauthsize */ 228240153b10SEric Biggers authsize = maxauthsize; 228340153b10SEric Biggers if (prandom_u32() % 4 == 0) 228440153b10SEric Biggers authsize = prandom_u32() % (maxauthsize + 1); 228549763fc6SEric Biggers if (prefer_inauthentic && authsize < MIN_COLLISION_FREE_AUTHSIZE) 228649763fc6SEric Biggers authsize = MIN_COLLISION_FREE_AUTHSIZE; 228740153b10SEric Biggers if (WARN_ON(authsize > maxdatasize)) 228840153b10SEric Biggers authsize = maxdatasize; 228940153b10SEric Biggers maxdatasize -= authsize; 229040153b10SEric Biggers vec->setauthsize_error = crypto_aead_setauthsize(tfm, authsize); 229140153b10SEric Biggers 229249763fc6SEric Biggers /* AAD, plaintext, and ciphertext lengths */ 229340153b10SEric Biggers total_len = generate_random_length(maxdatasize); 229440153b10SEric Biggers if (prandom_u32() % 4 == 0) 229540153b10SEric Biggers vec->alen = 0; 229640153b10SEric Biggers else 229740153b10SEric Biggers vec->alen = generate_random_length(total_len); 229840153b10SEric Biggers vec->plen = total_len - vec->alen; 229940153b10SEric Biggers vec->clen = vec->plen + authsize; 230040153b10SEric Biggers 230140153b10SEric Biggers /* 230249763fc6SEric Biggers * Generate the AAD, plaintext, and ciphertext. Not applicable if the 230349763fc6SEric Biggers * key or the authentication tag size couldn't be set. 230440153b10SEric Biggers */ 230549763fc6SEric Biggers vec->novrfy = 0; 2306eb455dbdSEric Biggers vec->crypt_error = 0; 230749763fc6SEric Biggers if (vec->setkey_error == 0 && vec->setauthsize_error == 0) 230849763fc6SEric Biggers generate_aead_message(req, suite, vec, prefer_inauthentic); 230940153b10SEric Biggers snprintf(name, max_namelen, 231049763fc6SEric Biggers "\"random: alen=%u plen=%u authsize=%u klen=%u novrfy=%d\"", 231149763fc6SEric Biggers vec->alen, vec->plen, authsize, vec->klen, vec->novrfy); 231249763fc6SEric Biggers } 231349763fc6SEric Biggers 231449763fc6SEric Biggers static void try_to_generate_inauthentic_testvec( 231549763fc6SEric Biggers struct aead_extra_tests_ctx *ctx) 231649763fc6SEric Biggers { 231749763fc6SEric Biggers int i; 231849763fc6SEric Biggers 231949763fc6SEric Biggers for (i = 0; i < 10; i++) { 232049763fc6SEric Biggers generate_random_aead_testvec(ctx->req, &ctx->vec, 232149763fc6SEric Biggers &ctx->test_desc->suite.aead, 232249763fc6SEric Biggers ctx->maxkeysize, ctx->maxdatasize, 232349763fc6SEric Biggers ctx->vec_name, 232449763fc6SEric Biggers sizeof(ctx->vec_name), true); 232549763fc6SEric Biggers if (ctx->vec.novrfy) 232649763fc6SEric Biggers return; 232749763fc6SEric Biggers } 232849763fc6SEric Biggers } 232949763fc6SEric Biggers 233049763fc6SEric Biggers /* 233149763fc6SEric Biggers * Generate inauthentic test vectors (i.e. ciphertext, AAD pairs that aren't the 233249763fc6SEric Biggers * result of an encryption with the key) and verify that decryption fails. 233349763fc6SEric Biggers */ 233449763fc6SEric Biggers static int test_aead_inauthentic_inputs(struct aead_extra_tests_ctx *ctx) 233549763fc6SEric Biggers { 233649763fc6SEric Biggers unsigned int i; 233749763fc6SEric Biggers int err; 233849763fc6SEric Biggers 233949763fc6SEric Biggers for (i = 0; i < fuzz_iterations * 8; i++) { 234049763fc6SEric Biggers /* 234149763fc6SEric Biggers * Since this part of the tests isn't comparing the 234249763fc6SEric Biggers * implementation to another, there's no point in testing any 234349763fc6SEric Biggers * test vectors other than inauthentic ones (vec.novrfy=1) here. 234449763fc6SEric Biggers * 234549763fc6SEric Biggers * If we're having trouble generating such a test vector, e.g. 234649763fc6SEric Biggers * if the algorithm keeps rejecting the generated keys, don't 234749763fc6SEric Biggers * retry forever; just continue on. 234849763fc6SEric Biggers */ 234949763fc6SEric Biggers try_to_generate_inauthentic_testvec(ctx); 235049763fc6SEric Biggers if (ctx->vec.novrfy) { 235149763fc6SEric Biggers generate_random_testvec_config(&ctx->cfg, ctx->cfgname, 235249763fc6SEric Biggers sizeof(ctx->cfgname)); 23532257f471SEric Biggers err = test_aead_vec_cfg(DECRYPT, &ctx->vec, 235449763fc6SEric Biggers ctx->vec_name, &ctx->cfg, 235549763fc6SEric Biggers ctx->req, ctx->tsgls); 235649763fc6SEric Biggers if (err) 235749763fc6SEric Biggers return err; 235849763fc6SEric Biggers } 235949763fc6SEric Biggers cond_resched(); 236049763fc6SEric Biggers } 236149763fc6SEric Biggers return 0; 236240153b10SEric Biggers } 236340153b10SEric Biggers 236440153b10SEric Biggers /* 23652ea91505SEric Biggers * Test the AEAD algorithm against the corresponding generic implementation, if 23662ea91505SEric Biggers * one is available. 236740153b10SEric Biggers */ 23682ea91505SEric Biggers static int test_aead_vs_generic_impl(struct aead_extra_tests_ctx *ctx) 236940153b10SEric Biggers { 23702ea91505SEric Biggers struct crypto_aead *tfm = ctx->tfm; 237140153b10SEric Biggers const char *algname = crypto_aead_alg(tfm)->base.cra_name; 23722257f471SEric Biggers const char *driver = crypto_aead_driver_name(tfm); 23732ea91505SEric Biggers const char *generic_driver = ctx->test_desc->generic_driver; 237440153b10SEric Biggers char _generic_driver[CRYPTO_MAX_ALG_NAME]; 237540153b10SEric Biggers struct crypto_aead *generic_tfm = NULL; 237640153b10SEric Biggers struct aead_request *generic_req = NULL; 237740153b10SEric Biggers unsigned int i; 237840153b10SEric Biggers int err; 237940153b10SEric Biggers 238040153b10SEric Biggers if (!generic_driver) { /* Use default naming convention? */ 238140153b10SEric Biggers err = build_generic_driver_name(algname, _generic_driver); 238240153b10SEric Biggers if (err) 238340153b10SEric Biggers return err; 238440153b10SEric Biggers generic_driver = _generic_driver; 238540153b10SEric Biggers } 238640153b10SEric Biggers 238740153b10SEric Biggers if (strcmp(generic_driver, driver) == 0) /* Already the generic impl? */ 238840153b10SEric Biggers return 0; 238940153b10SEric Biggers 239040153b10SEric Biggers generic_tfm = crypto_alloc_aead(generic_driver, 0, 0); 239140153b10SEric Biggers if (IS_ERR(generic_tfm)) { 239240153b10SEric Biggers err = PTR_ERR(generic_tfm); 239340153b10SEric Biggers if (err == -ENOENT) { 239440153b10SEric Biggers pr_warn("alg: aead: skipping comparison tests for %s because %s is unavailable\n", 239540153b10SEric Biggers driver, generic_driver); 239640153b10SEric Biggers return 0; 239740153b10SEric Biggers } 239840153b10SEric Biggers pr_err("alg: aead: error allocating %s (generic impl of %s): %d\n", 239940153b10SEric Biggers generic_driver, algname, err); 240040153b10SEric Biggers return err; 240140153b10SEric Biggers } 240240153b10SEric Biggers 240340153b10SEric Biggers generic_req = aead_request_alloc(generic_tfm, GFP_KERNEL); 240440153b10SEric Biggers if (!generic_req) { 240540153b10SEric Biggers err = -ENOMEM; 240640153b10SEric Biggers goto out; 240740153b10SEric Biggers } 240840153b10SEric Biggers 240940153b10SEric Biggers /* Check the algorithm properties for consistency. */ 241040153b10SEric Biggers 24112ea91505SEric Biggers if (crypto_aead_maxauthsize(tfm) != 24122ea91505SEric Biggers crypto_aead_maxauthsize(generic_tfm)) { 241340153b10SEric Biggers pr_err("alg: aead: maxauthsize for %s (%u) doesn't match generic impl (%u)\n", 24142ea91505SEric Biggers driver, crypto_aead_maxauthsize(tfm), 24152ea91505SEric Biggers crypto_aead_maxauthsize(generic_tfm)); 241640153b10SEric Biggers err = -EINVAL; 241740153b10SEric Biggers goto out; 241840153b10SEric Biggers } 241940153b10SEric Biggers 24202ea91505SEric Biggers if (crypto_aead_ivsize(tfm) != crypto_aead_ivsize(generic_tfm)) { 242140153b10SEric Biggers pr_err("alg: aead: ivsize for %s (%u) doesn't match generic impl (%u)\n", 24222ea91505SEric Biggers driver, crypto_aead_ivsize(tfm), 24232ea91505SEric Biggers crypto_aead_ivsize(generic_tfm)); 242440153b10SEric Biggers err = -EINVAL; 242540153b10SEric Biggers goto out; 242640153b10SEric Biggers } 242740153b10SEric Biggers 24282ea91505SEric Biggers if (crypto_aead_blocksize(tfm) != crypto_aead_blocksize(generic_tfm)) { 242940153b10SEric Biggers pr_err("alg: aead: blocksize for %s (%u) doesn't match generic impl (%u)\n", 24302ea91505SEric Biggers driver, crypto_aead_blocksize(tfm), 24312ea91505SEric Biggers crypto_aead_blocksize(generic_tfm)); 243240153b10SEric Biggers err = -EINVAL; 243340153b10SEric Biggers goto out; 243440153b10SEric Biggers } 243540153b10SEric Biggers 243640153b10SEric Biggers /* 243740153b10SEric Biggers * Now generate test vectors using the generic implementation, and test 243840153b10SEric Biggers * the other implementation against them. 243940153b10SEric Biggers */ 244040153b10SEric Biggers for (i = 0; i < fuzz_iterations * 8; i++) { 24412ea91505SEric Biggers generate_random_aead_testvec(generic_req, &ctx->vec, 244249763fc6SEric Biggers &ctx->test_desc->suite.aead, 24432ea91505SEric Biggers ctx->maxkeysize, ctx->maxdatasize, 24442ea91505SEric Biggers ctx->vec_name, 244549763fc6SEric Biggers sizeof(ctx->vec_name), false); 24462ea91505SEric Biggers generate_random_testvec_config(&ctx->cfg, ctx->cfgname, 24472ea91505SEric Biggers sizeof(ctx->cfgname)); 244849763fc6SEric Biggers if (!ctx->vec.novrfy) { 24492257f471SEric Biggers err = test_aead_vec_cfg(ENCRYPT, &ctx->vec, 24502ea91505SEric Biggers ctx->vec_name, &ctx->cfg, 24512ea91505SEric Biggers ctx->req, ctx->tsgls); 245240153b10SEric Biggers if (err) 245340153b10SEric Biggers goto out; 245449763fc6SEric Biggers } 245549763fc6SEric Biggers if (ctx->vec.crypt_error == 0 || ctx->vec.novrfy) { 24562257f471SEric Biggers err = test_aead_vec_cfg(DECRYPT, &ctx->vec, 24572ea91505SEric Biggers ctx->vec_name, &ctx->cfg, 24582ea91505SEric Biggers ctx->req, ctx->tsgls); 245940153b10SEric Biggers if (err) 246040153b10SEric Biggers goto out; 2461eb455dbdSEric Biggers } 246240153b10SEric Biggers cond_resched(); 246340153b10SEric Biggers } 246440153b10SEric Biggers err = 0; 246540153b10SEric Biggers out: 246640153b10SEric Biggers crypto_free_aead(generic_tfm); 246740153b10SEric Biggers aead_request_free(generic_req); 246840153b10SEric Biggers return err; 246940153b10SEric Biggers } 24702ea91505SEric Biggers 24712257f471SEric Biggers static int test_aead_extra(const struct alg_test_desc *test_desc, 24722ea91505SEric Biggers struct aead_request *req, 24732ea91505SEric Biggers struct cipher_test_sglists *tsgls) 24742ea91505SEric Biggers { 24752ea91505SEric Biggers struct aead_extra_tests_ctx *ctx; 24762ea91505SEric Biggers unsigned int i; 24772ea91505SEric Biggers int err; 24782ea91505SEric Biggers 24792ea91505SEric Biggers if (noextratests) 24802ea91505SEric Biggers return 0; 24812ea91505SEric Biggers 24822ea91505SEric Biggers ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 24832ea91505SEric Biggers if (!ctx) 24842ea91505SEric Biggers return -ENOMEM; 24852ea91505SEric Biggers ctx->req = req; 24862ea91505SEric Biggers ctx->tfm = crypto_aead_reqtfm(req); 24872ea91505SEric Biggers ctx->test_desc = test_desc; 24882ea91505SEric Biggers ctx->tsgls = tsgls; 24892ea91505SEric Biggers ctx->maxdatasize = (2 * PAGE_SIZE) - TESTMGR_POISON_LEN; 24902ea91505SEric Biggers ctx->maxkeysize = 0; 24912ea91505SEric Biggers for (i = 0; i < test_desc->suite.aead.count; i++) 24922ea91505SEric Biggers ctx->maxkeysize = max_t(unsigned int, ctx->maxkeysize, 24932ea91505SEric Biggers test_desc->suite.aead.vecs[i].klen); 24942ea91505SEric Biggers 24952ea91505SEric Biggers ctx->vec.key = kmalloc(ctx->maxkeysize, GFP_KERNEL); 24962ea91505SEric Biggers ctx->vec.iv = kmalloc(crypto_aead_ivsize(ctx->tfm), GFP_KERNEL); 24972ea91505SEric Biggers ctx->vec.assoc = kmalloc(ctx->maxdatasize, GFP_KERNEL); 24982ea91505SEric Biggers ctx->vec.ptext = kmalloc(ctx->maxdatasize, GFP_KERNEL); 24992ea91505SEric Biggers ctx->vec.ctext = kmalloc(ctx->maxdatasize, GFP_KERNEL); 25002ea91505SEric Biggers if (!ctx->vec.key || !ctx->vec.iv || !ctx->vec.assoc || 25012ea91505SEric Biggers !ctx->vec.ptext || !ctx->vec.ctext) { 25022ea91505SEric Biggers err = -ENOMEM; 25032ea91505SEric Biggers goto out; 25042ea91505SEric Biggers } 25052ea91505SEric Biggers 25068ff357a9SEric Biggers err = test_aead_vs_generic_impl(ctx); 250749763fc6SEric Biggers if (err) 250849763fc6SEric Biggers goto out; 250949763fc6SEric Biggers 25108ff357a9SEric Biggers err = test_aead_inauthentic_inputs(ctx); 25112ea91505SEric Biggers out: 25122ea91505SEric Biggers kfree(ctx->vec.key); 25132ea91505SEric Biggers kfree(ctx->vec.iv); 25142ea91505SEric Biggers kfree(ctx->vec.assoc); 25152ea91505SEric Biggers kfree(ctx->vec.ptext); 25162ea91505SEric Biggers kfree(ctx->vec.ctext); 25172ea91505SEric Biggers kfree(ctx); 25182ea91505SEric Biggers return err; 25192ea91505SEric Biggers } 252040153b10SEric Biggers #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 25212257f471SEric Biggers static int test_aead_extra(const struct alg_test_desc *test_desc, 252240153b10SEric Biggers struct aead_request *req, 252340153b10SEric Biggers struct cipher_test_sglists *tsgls) 252440153b10SEric Biggers { 252540153b10SEric Biggers return 0; 252640153b10SEric Biggers } 252740153b10SEric Biggers #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 252840153b10SEric Biggers 25292257f471SEric Biggers static int test_aead(int enc, const struct aead_test_suite *suite, 2530ed96804fSEric Biggers struct aead_request *req, 2531ed96804fSEric Biggers struct cipher_test_sglists *tsgls) 2532ed96804fSEric Biggers { 2533ed96804fSEric Biggers unsigned int i; 2534ed96804fSEric Biggers int err; 2535ed96804fSEric Biggers 2536ed96804fSEric Biggers for (i = 0; i < suite->count; i++) { 25372257f471SEric Biggers err = test_aead_vec(enc, &suite->vecs[i], i, req, tsgls); 2538ed96804fSEric Biggers if (err) 2539ed96804fSEric Biggers return err; 2540e63e1b0dSEric Biggers cond_resched(); 2541ed96804fSEric Biggers } 2542ed96804fSEric Biggers return 0; 2543ed96804fSEric Biggers } 2544ed96804fSEric Biggers 2545ed96804fSEric Biggers static int alg_test_aead(const struct alg_test_desc *desc, const char *driver, 2546ed96804fSEric Biggers u32 type, u32 mask) 2547ed96804fSEric Biggers { 2548ed96804fSEric Biggers const struct aead_test_suite *suite = &desc->suite.aead; 2549ed96804fSEric Biggers struct crypto_aead *tfm; 2550ed96804fSEric Biggers struct aead_request *req = NULL; 2551ed96804fSEric Biggers struct cipher_test_sglists *tsgls = NULL; 2552ed96804fSEric Biggers int err; 2553ed96804fSEric Biggers 2554ed96804fSEric Biggers if (suite->count <= 0) { 2555ed96804fSEric Biggers pr_err("alg: aead: empty test suite for %s\n", driver); 2556ed96804fSEric Biggers return -EINVAL; 2557ed96804fSEric Biggers } 2558ed96804fSEric Biggers 2559ed96804fSEric Biggers tfm = crypto_alloc_aead(driver, type, mask); 2560ed96804fSEric Biggers if (IS_ERR(tfm)) { 2561ed96804fSEric Biggers pr_err("alg: aead: failed to allocate transform for %s: %ld\n", 2562ed96804fSEric Biggers driver, PTR_ERR(tfm)); 2563ed96804fSEric Biggers return PTR_ERR(tfm); 2564ed96804fSEric Biggers } 25652257f471SEric Biggers driver = crypto_aead_driver_name(tfm); 2566ed96804fSEric Biggers 2567ed96804fSEric Biggers req = aead_request_alloc(tfm, GFP_KERNEL); 2568ed96804fSEric Biggers if (!req) { 2569ed96804fSEric Biggers pr_err("alg: aead: failed to allocate request for %s\n", 2570ed96804fSEric Biggers driver); 2571ed96804fSEric Biggers err = -ENOMEM; 2572ed96804fSEric Biggers goto out; 2573ed96804fSEric Biggers } 2574ed96804fSEric Biggers 2575ed96804fSEric Biggers tsgls = alloc_cipher_test_sglists(); 2576ed96804fSEric Biggers if (!tsgls) { 2577ed96804fSEric Biggers pr_err("alg: aead: failed to allocate test buffers for %s\n", 2578ed96804fSEric Biggers driver); 2579ed96804fSEric Biggers err = -ENOMEM; 2580ed96804fSEric Biggers goto out; 2581ed96804fSEric Biggers } 2582ed96804fSEric Biggers 25832257f471SEric Biggers err = test_aead(ENCRYPT, suite, req, tsgls); 2584ed96804fSEric Biggers if (err) 2585ed96804fSEric Biggers goto out; 2586ed96804fSEric Biggers 25872257f471SEric Biggers err = test_aead(DECRYPT, suite, req, tsgls); 258840153b10SEric Biggers if (err) 258940153b10SEric Biggers goto out; 259040153b10SEric Biggers 25912257f471SEric Biggers err = test_aead_extra(desc, req, tsgls); 2592ed96804fSEric Biggers out: 2593ed96804fSEric Biggers free_cipher_test_sglists(tsgls); 2594ed96804fSEric Biggers aead_request_free(req); 2595ed96804fSEric Biggers crypto_free_aead(tfm); 2596ed96804fSEric Biggers return err; 2597ed96804fSEric Biggers } 2598ed96804fSEric Biggers 25991aa4ecd9SHerbert Xu static int test_cipher(struct crypto_cipher *tfm, int enc, 2600b13b1e0cSEric Biggers const struct cipher_testvec *template, 2601b13b1e0cSEric Biggers unsigned int tcount) 26021aa4ecd9SHerbert Xu { 26031aa4ecd9SHerbert Xu const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm)); 26041aa4ecd9SHerbert Xu unsigned int i, j, k; 26051aa4ecd9SHerbert Xu char *q; 26061aa4ecd9SHerbert Xu const char *e; 260792a4c9feSEric Biggers const char *input, *result; 26081aa4ecd9SHerbert Xu void *data; 2609f8b0d4d0SHerbert Xu char *xbuf[XBUFSIZE]; 2610f8b0d4d0SHerbert Xu int ret = -ENOMEM; 2611f8b0d4d0SHerbert Xu 2612f8b0d4d0SHerbert Xu if (testmgr_alloc_buf(xbuf)) 2613f8b0d4d0SHerbert Xu goto out_nobuf; 26141aa4ecd9SHerbert Xu 26151aa4ecd9SHerbert Xu if (enc == ENCRYPT) 26161aa4ecd9SHerbert Xu e = "encryption"; 26171aa4ecd9SHerbert Xu else 26181aa4ecd9SHerbert Xu e = "decryption"; 26191aa4ecd9SHerbert Xu 26201aa4ecd9SHerbert Xu j = 0; 26211aa4ecd9SHerbert Xu for (i = 0; i < tcount; i++) { 26221aa4ecd9SHerbert Xu 262310faa8c0SStephan Mueller if (fips_enabled && template[i].fips_skip) 262410faa8c0SStephan Mueller continue; 262510faa8c0SStephan Mueller 262692a4c9feSEric Biggers input = enc ? template[i].ptext : template[i].ctext; 262792a4c9feSEric Biggers result = enc ? template[i].ctext : template[i].ptext; 26281aa4ecd9SHerbert Xu j++; 26291aa4ecd9SHerbert Xu 2630fd57f22aSHerbert Xu ret = -EINVAL; 263192a4c9feSEric Biggers if (WARN_ON(template[i].len > PAGE_SIZE)) 2632fd57f22aSHerbert Xu goto out; 2633fd57f22aSHerbert Xu 26341aa4ecd9SHerbert Xu data = xbuf[0]; 263592a4c9feSEric Biggers memcpy(data, input, template[i].len); 26361aa4ecd9SHerbert Xu 26371aa4ecd9SHerbert Xu crypto_cipher_clear_flags(tfm, ~0); 26381aa4ecd9SHerbert Xu if (template[i].wk) 2639231baecdSEric Biggers crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 26401aa4ecd9SHerbert Xu 26411aa4ecd9SHerbert Xu ret = crypto_cipher_setkey(tfm, template[i].key, 26421aa4ecd9SHerbert Xu template[i].klen); 26435283a8eeSEric Biggers if (ret) { 26445283a8eeSEric Biggers if (ret == template[i].setkey_error) 26451aa4ecd9SHerbert Xu continue; 26465283a8eeSEric Biggers pr_err("alg: cipher: %s setkey failed on test vector %u; expected_error=%d, actual_error=%d, flags=%#x\n", 26475283a8eeSEric Biggers algo, j, template[i].setkey_error, ret, 26485283a8eeSEric Biggers crypto_cipher_get_flags(tfm)); 26495283a8eeSEric Biggers goto out; 26505283a8eeSEric Biggers } 26515283a8eeSEric Biggers if (template[i].setkey_error) { 26525283a8eeSEric Biggers pr_err("alg: cipher: %s setkey unexpectedly succeeded on test vector %u; expected_error=%d\n", 26535283a8eeSEric Biggers algo, j, template[i].setkey_error); 26545283a8eeSEric Biggers ret = -EINVAL; 26555283a8eeSEric Biggers goto out; 26565283a8eeSEric Biggers } 26571aa4ecd9SHerbert Xu 265892a4c9feSEric Biggers for (k = 0; k < template[i].len; 26591aa4ecd9SHerbert Xu k += crypto_cipher_blocksize(tfm)) { 26601aa4ecd9SHerbert Xu if (enc) 26611aa4ecd9SHerbert Xu crypto_cipher_encrypt_one(tfm, data + k, 26621aa4ecd9SHerbert Xu data + k); 26631aa4ecd9SHerbert Xu else 26641aa4ecd9SHerbert Xu crypto_cipher_decrypt_one(tfm, data + k, 26651aa4ecd9SHerbert Xu data + k); 26661aa4ecd9SHerbert Xu } 26671aa4ecd9SHerbert Xu 26681aa4ecd9SHerbert Xu q = data; 266992a4c9feSEric Biggers if (memcmp(q, result, template[i].len)) { 26701aa4ecd9SHerbert Xu printk(KERN_ERR "alg: cipher: Test %d failed " 26711aa4ecd9SHerbert Xu "on %s for %s\n", j, e, algo); 267292a4c9feSEric Biggers hexdump(q, template[i].len); 26731aa4ecd9SHerbert Xu ret = -EINVAL; 26741aa4ecd9SHerbert Xu goto out; 26751aa4ecd9SHerbert Xu } 26761aa4ecd9SHerbert Xu } 26771aa4ecd9SHerbert Xu 26781aa4ecd9SHerbert Xu ret = 0; 26791aa4ecd9SHerbert Xu 26801aa4ecd9SHerbert Xu out: 2681f8b0d4d0SHerbert Xu testmgr_free_buf(xbuf); 2682f8b0d4d0SHerbert Xu out_nobuf: 26831aa4ecd9SHerbert Xu return ret; 26841aa4ecd9SHerbert Xu } 26851aa4ecd9SHerbert Xu 26866e5972faSEric Biggers static int test_skcipher_vec_cfg(int enc, const struct cipher_testvec *vec, 2687951d1332SEric Biggers const char *vec_name, 26884e7babbaSEric Biggers const struct testvec_config *cfg, 26894e7babbaSEric Biggers struct skcipher_request *req, 26904e7babbaSEric Biggers struct cipher_test_sglists *tsgls) 2691da7f033dSHerbert Xu { 26924e7babbaSEric Biggers struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 26934e7babbaSEric Biggers const unsigned int alignmask = crypto_skcipher_alignmask(tfm); 26944e7babbaSEric Biggers const unsigned int ivsize = crypto_skcipher_ivsize(tfm); 26956e5972faSEric Biggers const char *driver = crypto_skcipher_driver_name(tfm); 26964e7babbaSEric Biggers const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags; 26974e7babbaSEric Biggers const char *op = enc ? "encryption" : "decryption"; 26984e7babbaSEric Biggers DECLARE_CRYPTO_WAIT(wait); 26994e7babbaSEric Biggers u8 _iv[3 * (MAX_ALGAPI_ALIGNMASK + 1) + MAX_IVLEN]; 27004e7babbaSEric Biggers u8 *iv = PTR_ALIGN(&_iv[0], 2 * (MAX_ALGAPI_ALIGNMASK + 1)) + 27014e7babbaSEric Biggers cfg->iv_offset + 27024e7babbaSEric Biggers (cfg->iv_offset_relative_to_alignmask ? alignmask : 0); 27034e7babbaSEric Biggers struct kvec input; 27044e7babbaSEric Biggers int err; 2705f8b0d4d0SHerbert Xu 27064e7babbaSEric Biggers /* Set the key */ 27074e7babbaSEric Biggers if (vec->wk) 2708231baecdSEric Biggers crypto_skcipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 2709da7f033dSHerbert Xu else 27104e7babbaSEric Biggers crypto_skcipher_clear_flags(tfm, 27114e7babbaSEric Biggers CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 2712fd8c37c7SEric Biggers err = do_setkey(crypto_skcipher_setkey, tfm, vec->key, vec->klen, 2713fd8c37c7SEric Biggers cfg, alignmask); 27144e7babbaSEric Biggers if (err) { 27155283a8eeSEric Biggers if (err == vec->setkey_error) 27164e7babbaSEric Biggers return 0; 2717951d1332SEric Biggers pr_err("alg: skcipher: %s setkey failed on test vector %s; expected_error=%d, actual_error=%d, flags=%#x\n", 2718951d1332SEric Biggers driver, vec_name, vec->setkey_error, err, 27195283a8eeSEric Biggers crypto_skcipher_get_flags(tfm)); 27204e7babbaSEric Biggers return err; 27214e7babbaSEric Biggers } 27225283a8eeSEric Biggers if (vec->setkey_error) { 2723951d1332SEric Biggers pr_err("alg: skcipher: %s setkey unexpectedly succeeded on test vector %s; expected_error=%d\n", 2724951d1332SEric Biggers driver, vec_name, vec->setkey_error); 27254e7babbaSEric Biggers return -EINVAL; 272608d6af8cSJussi Kivilinna } 2727da7f033dSHerbert Xu 27284e7babbaSEric Biggers /* The IV must be copied to a buffer, as the algorithm may modify it */ 27294e7babbaSEric Biggers if (ivsize) { 27304e7babbaSEric Biggers if (WARN_ON(ivsize > MAX_IVLEN)) 27314e7babbaSEric Biggers return -EINVAL; 27328efd972eSEric Biggers if (vec->generates_iv && !enc) 27338efd972eSEric Biggers memcpy(iv, vec->iv_out, ivsize); 27348efd972eSEric Biggers else if (vec->iv) 27354e7babbaSEric Biggers memcpy(iv, vec->iv, ivsize); 273608d6af8cSJussi Kivilinna else 27374e7babbaSEric Biggers memset(iv, 0, ivsize); 27384e7babbaSEric Biggers } else { 27394e7babbaSEric Biggers if (vec->generates_iv) { 2740951d1332SEric Biggers pr_err("alg: skcipher: %s has ivsize=0 but test vector %s generates IV!\n", 2741951d1332SEric Biggers driver, vec_name); 27424e7babbaSEric Biggers return -EINVAL; 27434e7babbaSEric Biggers } 27444e7babbaSEric Biggers iv = NULL; 2745da7f033dSHerbert Xu } 2746da7f033dSHerbert Xu 27474e7babbaSEric Biggers /* Build the src/dst scatterlists */ 27484e7babbaSEric Biggers input.iov_base = enc ? (void *)vec->ptext : (void *)vec->ctext; 27494e7babbaSEric Biggers input.iov_len = vec->len; 27504e7babbaSEric Biggers err = build_cipher_test_sglists(tsgls, cfg, alignmask, 27514e7babbaSEric Biggers vec->len, vec->len, &input, 1); 27524e7babbaSEric Biggers if (err) { 2753951d1332SEric Biggers pr_err("alg: skcipher: %s %s: error preparing scatterlists for test vector %s, cfg=\"%s\"\n", 2754951d1332SEric Biggers driver, op, vec_name, cfg->name); 27554e7babbaSEric Biggers return err; 2756da7f033dSHerbert Xu } 2757da7f033dSHerbert Xu 27584e7babbaSEric Biggers /* Do the actual encryption or decryption */ 27594e7babbaSEric Biggers testmgr_poison(req->__ctx, crypto_skcipher_reqsize(tfm)); 27604e7babbaSEric Biggers skcipher_request_set_callback(req, req_flags, crypto_req_done, &wait); 27614e7babbaSEric Biggers skcipher_request_set_crypt(req, tsgls->src.sgl_ptr, tsgls->dst.sgl_ptr, 27624e7babbaSEric Biggers vec->len, iv); 27636570737cSEric Biggers if (cfg->nosimd) 27646570737cSEric Biggers crypto_disable_simd_for_test(); 27656570737cSEric Biggers err = enc ? crypto_skcipher_encrypt(req) : crypto_skcipher_decrypt(req); 27666570737cSEric Biggers if (cfg->nosimd) 27676570737cSEric Biggers crypto_reenable_simd_for_test(); 27686570737cSEric Biggers err = crypto_wait_req(err, &wait); 2769da7f033dSHerbert Xu 2770fa353c99SEric Biggers /* Check that the algorithm didn't overwrite things it shouldn't have */ 2771fa353c99SEric Biggers if (req->cryptlen != vec->len || 2772fa353c99SEric Biggers req->iv != iv || 2773fa353c99SEric Biggers req->src != tsgls->src.sgl_ptr || 2774fa353c99SEric Biggers req->dst != tsgls->dst.sgl_ptr || 2775fa353c99SEric Biggers crypto_skcipher_reqtfm(req) != tfm || 2776fa353c99SEric Biggers req->base.complete != crypto_req_done || 2777fa353c99SEric Biggers req->base.flags != req_flags || 2778fa353c99SEric Biggers req->base.data != &wait) { 2779951d1332SEric Biggers pr_err("alg: skcipher: %s %s corrupted request struct on test vector %s, cfg=\"%s\"\n", 2780951d1332SEric Biggers driver, op, vec_name, cfg->name); 2781fa353c99SEric Biggers if (req->cryptlen != vec->len) 2782fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->cryptlen'\n"); 2783fa353c99SEric Biggers if (req->iv != iv) 2784fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->iv'\n"); 2785fa353c99SEric Biggers if (req->src != tsgls->src.sgl_ptr) 2786fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->src'\n"); 2787fa353c99SEric Biggers if (req->dst != tsgls->dst.sgl_ptr) 2788fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->dst'\n"); 2789fa353c99SEric Biggers if (crypto_skcipher_reqtfm(req) != tfm) 2790fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.tfm'\n"); 2791fa353c99SEric Biggers if (req->base.complete != crypto_req_done) 2792fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.complete'\n"); 2793fa353c99SEric Biggers if (req->base.flags != req_flags) 2794fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.flags'\n"); 2795fa353c99SEric Biggers if (req->base.data != &wait) 2796fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.data'\n"); 2797fa353c99SEric Biggers return -EINVAL; 2798fa353c99SEric Biggers } 2799fa353c99SEric Biggers if (is_test_sglist_corrupted(&tsgls->src)) { 2800951d1332SEric Biggers pr_err("alg: skcipher: %s %s corrupted src sgl on test vector %s, cfg=\"%s\"\n", 2801951d1332SEric Biggers driver, op, vec_name, cfg->name); 2802fa353c99SEric Biggers return -EINVAL; 2803fa353c99SEric Biggers } 2804fa353c99SEric Biggers if (tsgls->dst.sgl_ptr != tsgls->src.sgl && 2805fa353c99SEric Biggers is_test_sglist_corrupted(&tsgls->dst)) { 2806951d1332SEric Biggers pr_err("alg: skcipher: %s %s corrupted dst sgl on test vector %s, cfg=\"%s\"\n", 2807951d1332SEric Biggers driver, op, vec_name, cfg->name); 2808fa353c99SEric Biggers return -EINVAL; 2809fa353c99SEric Biggers } 2810fa353c99SEric Biggers 28115283a8eeSEric Biggers /* Check for success or failure */ 28125283a8eeSEric Biggers if (err) { 28135283a8eeSEric Biggers if (err == vec->crypt_error) 28145283a8eeSEric Biggers return 0; 2815951d1332SEric Biggers pr_err("alg: skcipher: %s %s failed on test vector %s; expected_error=%d, actual_error=%d, cfg=\"%s\"\n", 2816951d1332SEric Biggers driver, op, vec_name, vec->crypt_error, err, cfg->name); 28175283a8eeSEric Biggers return err; 28185283a8eeSEric Biggers } 28195283a8eeSEric Biggers if (vec->crypt_error) { 2820951d1332SEric Biggers pr_err("alg: skcipher: %s %s unexpectedly succeeded on test vector %s; expected_error=%d, cfg=\"%s\"\n", 2821951d1332SEric Biggers driver, op, vec_name, vec->crypt_error, cfg->name); 28225283a8eeSEric Biggers return -EINVAL; 28235283a8eeSEric Biggers } 28245283a8eeSEric Biggers 28254e7babbaSEric Biggers /* Check for the correct output (ciphertext or plaintext) */ 28264e7babbaSEric Biggers err = verify_correct_output(&tsgls->dst, enc ? vec->ctext : vec->ptext, 28274e7babbaSEric Biggers vec->len, 0, true); 28284e7babbaSEric Biggers if (err == -EOVERFLOW) { 2829951d1332SEric Biggers pr_err("alg: skcipher: %s %s overran dst buffer on test vector %s, cfg=\"%s\"\n", 2830951d1332SEric Biggers driver, op, vec_name, cfg->name); 28314e7babbaSEric Biggers return err; 28324e7babbaSEric Biggers } 28334e7babbaSEric Biggers if (err) { 2834951d1332SEric Biggers pr_err("alg: skcipher: %s %s test failed (wrong result) on test vector %s, cfg=\"%s\"\n", 2835951d1332SEric Biggers driver, op, vec_name, cfg->name); 28364e7babbaSEric Biggers return err; 28374e7babbaSEric Biggers } 283808d6af8cSJussi Kivilinna 28394e7babbaSEric Biggers /* If applicable, check that the algorithm generated the correct IV */ 28408efd972eSEric Biggers if (vec->iv_out && memcmp(iv, vec->iv_out, ivsize) != 0) { 2841951d1332SEric Biggers pr_err("alg: skcipher: %s %s test failed (wrong output IV) on test vector %s, cfg=\"%s\"\n", 2842951d1332SEric Biggers driver, op, vec_name, cfg->name); 28434e7babbaSEric Biggers hexdump(iv, ivsize); 28444e7babbaSEric Biggers return -EINVAL; 28453a338f20SJussi Kivilinna } 28463a338f20SJussi Kivilinna 28473a338f20SJussi Kivilinna return 0; 284808d6af8cSJussi Kivilinna } 284908d6af8cSJussi Kivilinna 28506e5972faSEric Biggers static int test_skcipher_vec(int enc, const struct cipher_testvec *vec, 28514e7babbaSEric Biggers unsigned int vec_num, 28524e7babbaSEric Biggers struct skcipher_request *req, 28534e7babbaSEric Biggers struct cipher_test_sglists *tsgls) 28544e7babbaSEric Biggers { 2855951d1332SEric Biggers char vec_name[16]; 28564e7babbaSEric Biggers unsigned int i; 28574e7babbaSEric Biggers int err; 28584e7babbaSEric Biggers 28594e7babbaSEric Biggers if (fips_enabled && vec->fips_skip) 28604e7babbaSEric Biggers return 0; 28614e7babbaSEric Biggers 2862951d1332SEric Biggers sprintf(vec_name, "%u", vec_num); 2863951d1332SEric Biggers 28644e7babbaSEric Biggers for (i = 0; i < ARRAY_SIZE(default_cipher_testvec_configs); i++) { 28656e5972faSEric Biggers err = test_skcipher_vec_cfg(enc, vec, vec_name, 28664e7babbaSEric Biggers &default_cipher_testvec_configs[i], 28674e7babbaSEric Biggers req, tsgls); 28684e7babbaSEric Biggers if (err) 28694e7babbaSEric Biggers return err; 28704e7babbaSEric Biggers } 28714e7babbaSEric Biggers 28724e7babbaSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 28734e7babbaSEric Biggers if (!noextratests) { 28744e7babbaSEric Biggers struct testvec_config cfg; 28754e7babbaSEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 28764e7babbaSEric Biggers 28774e7babbaSEric Biggers for (i = 0; i < fuzz_iterations; i++) { 28784e7babbaSEric Biggers generate_random_testvec_config(&cfg, cfgname, 28794e7babbaSEric Biggers sizeof(cfgname)); 28806e5972faSEric Biggers err = test_skcipher_vec_cfg(enc, vec, vec_name, 28814e7babbaSEric Biggers &cfg, req, tsgls); 28824e7babbaSEric Biggers if (err) 28834e7babbaSEric Biggers return err; 2884e63e1b0dSEric Biggers cond_resched(); 28854e7babbaSEric Biggers } 28864e7babbaSEric Biggers } 28874e7babbaSEric Biggers #endif 28884e7babbaSEric Biggers return 0; 28894e7babbaSEric Biggers } 28904e7babbaSEric Biggers 2891d435e10eSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 2892d435e10eSEric Biggers /* 2893d435e10eSEric Biggers * Generate a symmetric cipher test vector from the given implementation. 2894d435e10eSEric Biggers * Assumes the buffers in 'vec' were already allocated. 2895d435e10eSEric Biggers */ 2896d435e10eSEric Biggers static void generate_random_cipher_testvec(struct skcipher_request *req, 2897d435e10eSEric Biggers struct cipher_testvec *vec, 2898d435e10eSEric Biggers unsigned int maxdatasize, 2899d435e10eSEric Biggers char *name, size_t max_namelen) 2900d435e10eSEric Biggers { 2901d435e10eSEric Biggers struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 29029ac0d136SEric Biggers const unsigned int maxkeysize = crypto_skcipher_max_keysize(tfm); 2903d435e10eSEric Biggers const unsigned int ivsize = crypto_skcipher_ivsize(tfm); 2904d435e10eSEric Biggers struct scatterlist src, dst; 2905d435e10eSEric Biggers u8 iv[MAX_IVLEN]; 2906d435e10eSEric Biggers DECLARE_CRYPTO_WAIT(wait); 2907d435e10eSEric Biggers 2908d435e10eSEric Biggers /* Key: length in [0, maxkeysize], but usually choose maxkeysize */ 2909d435e10eSEric Biggers vec->klen = maxkeysize; 2910d435e10eSEric Biggers if (prandom_u32() % 4 == 0) 2911d435e10eSEric Biggers vec->klen = prandom_u32() % (maxkeysize + 1); 2912d435e10eSEric Biggers generate_random_bytes((u8 *)vec->key, vec->klen); 2913d435e10eSEric Biggers vec->setkey_error = crypto_skcipher_setkey(tfm, vec->key, vec->klen); 2914d435e10eSEric Biggers 2915d435e10eSEric Biggers /* IV */ 2916d435e10eSEric Biggers generate_random_bytes((u8 *)vec->iv, ivsize); 2917d435e10eSEric Biggers 2918d435e10eSEric Biggers /* Plaintext */ 2919d435e10eSEric Biggers vec->len = generate_random_length(maxdatasize); 2920d435e10eSEric Biggers generate_random_bytes((u8 *)vec->ptext, vec->len); 2921d435e10eSEric Biggers 2922d435e10eSEric Biggers /* If the key couldn't be set, no need to continue to encrypt. */ 2923d435e10eSEric Biggers if (vec->setkey_error) 2924d435e10eSEric Biggers goto done; 2925d435e10eSEric Biggers 2926d435e10eSEric Biggers /* Ciphertext */ 2927d435e10eSEric Biggers sg_init_one(&src, vec->ptext, vec->len); 2928d435e10eSEric Biggers sg_init_one(&dst, vec->ctext, vec->len); 2929d435e10eSEric Biggers memcpy(iv, vec->iv, ivsize); 2930d435e10eSEric Biggers skcipher_request_set_callback(req, 0, crypto_req_done, &wait); 2931d435e10eSEric Biggers skcipher_request_set_crypt(req, &src, &dst, vec->len, iv); 2932d435e10eSEric Biggers vec->crypt_error = crypto_wait_req(crypto_skcipher_encrypt(req), &wait); 2933eb455dbdSEric Biggers if (vec->crypt_error != 0) { 2934eb455dbdSEric Biggers /* 2935eb455dbdSEric Biggers * The only acceptable error here is for an invalid length, so 2936eb455dbdSEric Biggers * skcipher decryption should fail with the same error too. 2937eb455dbdSEric Biggers * We'll test for this. But to keep the API usage well-defined, 2938eb455dbdSEric Biggers * explicitly initialize the ciphertext buffer too. 2939eb455dbdSEric Biggers */ 2940eb455dbdSEric Biggers memset((u8 *)vec->ctext, 0, vec->len); 2941eb455dbdSEric Biggers } 2942d435e10eSEric Biggers done: 2943d435e10eSEric Biggers snprintf(name, max_namelen, "\"random: len=%u klen=%u\"", 2944d435e10eSEric Biggers vec->len, vec->klen); 2945d435e10eSEric Biggers } 2946d435e10eSEric Biggers 2947d435e10eSEric Biggers /* 2948d435e10eSEric Biggers * Test the skcipher algorithm represented by @req against the corresponding 2949d435e10eSEric Biggers * generic implementation, if one is available. 2950d435e10eSEric Biggers */ 29516e5972faSEric Biggers static int test_skcipher_vs_generic_impl(const char *generic_driver, 2952d435e10eSEric Biggers struct skcipher_request *req, 2953d435e10eSEric Biggers struct cipher_test_sglists *tsgls) 2954d435e10eSEric Biggers { 2955d435e10eSEric Biggers struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 29569ac0d136SEric Biggers const unsigned int maxkeysize = crypto_skcipher_max_keysize(tfm); 2957d435e10eSEric Biggers const unsigned int ivsize = crypto_skcipher_ivsize(tfm); 2958d435e10eSEric Biggers const unsigned int blocksize = crypto_skcipher_blocksize(tfm); 2959d435e10eSEric Biggers const unsigned int maxdatasize = (2 * PAGE_SIZE) - TESTMGR_POISON_LEN; 2960d435e10eSEric Biggers const char *algname = crypto_skcipher_alg(tfm)->base.cra_name; 29616e5972faSEric Biggers const char *driver = crypto_skcipher_driver_name(tfm); 2962d435e10eSEric Biggers char _generic_driver[CRYPTO_MAX_ALG_NAME]; 2963d435e10eSEric Biggers struct crypto_skcipher *generic_tfm = NULL; 2964d435e10eSEric Biggers struct skcipher_request *generic_req = NULL; 2965d435e10eSEric Biggers unsigned int i; 2966d435e10eSEric Biggers struct cipher_testvec vec = { 0 }; 2967d435e10eSEric Biggers char vec_name[64]; 29686b5ca646SArnd Bergmann struct testvec_config *cfg; 2969d435e10eSEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 2970d435e10eSEric Biggers int err; 2971d435e10eSEric Biggers 2972d435e10eSEric Biggers if (noextratests) 2973d435e10eSEric Biggers return 0; 2974d435e10eSEric Biggers 2975d435e10eSEric Biggers /* Keywrap isn't supported here yet as it handles its IV differently. */ 2976d435e10eSEric Biggers if (strncmp(algname, "kw(", 3) == 0) 2977d435e10eSEric Biggers return 0; 2978d435e10eSEric Biggers 2979d435e10eSEric Biggers if (!generic_driver) { /* Use default naming convention? */ 2980d435e10eSEric Biggers err = build_generic_driver_name(algname, _generic_driver); 2981d435e10eSEric Biggers if (err) 2982d435e10eSEric Biggers return err; 2983d435e10eSEric Biggers generic_driver = _generic_driver; 2984d435e10eSEric Biggers } 2985d435e10eSEric Biggers 2986d435e10eSEric Biggers if (strcmp(generic_driver, driver) == 0) /* Already the generic impl? */ 2987d435e10eSEric Biggers return 0; 2988d435e10eSEric Biggers 2989d435e10eSEric Biggers generic_tfm = crypto_alloc_skcipher(generic_driver, 0, 0); 2990d435e10eSEric Biggers if (IS_ERR(generic_tfm)) { 2991d435e10eSEric Biggers err = PTR_ERR(generic_tfm); 2992d435e10eSEric Biggers if (err == -ENOENT) { 2993d435e10eSEric Biggers pr_warn("alg: skcipher: skipping comparison tests for %s because %s is unavailable\n", 2994d435e10eSEric Biggers driver, generic_driver); 2995d435e10eSEric Biggers return 0; 2996d435e10eSEric Biggers } 2997d435e10eSEric Biggers pr_err("alg: skcipher: error allocating %s (generic impl of %s): %d\n", 2998d435e10eSEric Biggers generic_driver, algname, err); 2999d435e10eSEric Biggers return err; 3000d435e10eSEric Biggers } 3001d435e10eSEric Biggers 30026b5ca646SArnd Bergmann cfg = kzalloc(sizeof(*cfg), GFP_KERNEL); 30036b5ca646SArnd Bergmann if (!cfg) { 30046b5ca646SArnd Bergmann err = -ENOMEM; 30056b5ca646SArnd Bergmann goto out; 30066b5ca646SArnd Bergmann } 30076b5ca646SArnd Bergmann 3008d435e10eSEric Biggers generic_req = skcipher_request_alloc(generic_tfm, GFP_KERNEL); 3009d435e10eSEric Biggers if (!generic_req) { 3010d435e10eSEric Biggers err = -ENOMEM; 3011d435e10eSEric Biggers goto out; 3012d435e10eSEric Biggers } 3013d435e10eSEric Biggers 3014d435e10eSEric Biggers /* Check the algorithm properties for consistency. */ 3015d435e10eSEric Biggers 3016fd60f727SEric Biggers if (crypto_skcipher_min_keysize(tfm) != 3017fd60f727SEric Biggers crypto_skcipher_min_keysize(generic_tfm)) { 3018fd60f727SEric Biggers pr_err("alg: skcipher: min keysize for %s (%u) doesn't match generic impl (%u)\n", 3019fd60f727SEric Biggers driver, crypto_skcipher_min_keysize(tfm), 3020fd60f727SEric Biggers crypto_skcipher_min_keysize(generic_tfm)); 3021fd60f727SEric Biggers err = -EINVAL; 3022fd60f727SEric Biggers goto out; 3023fd60f727SEric Biggers } 3024fd60f727SEric Biggers 30259ac0d136SEric Biggers if (maxkeysize != crypto_skcipher_max_keysize(generic_tfm)) { 3026d435e10eSEric Biggers pr_err("alg: skcipher: max keysize for %s (%u) doesn't match generic impl (%u)\n", 30279ac0d136SEric Biggers driver, maxkeysize, 30289ac0d136SEric Biggers crypto_skcipher_max_keysize(generic_tfm)); 3029d435e10eSEric Biggers err = -EINVAL; 3030d435e10eSEric Biggers goto out; 3031d435e10eSEric Biggers } 3032d435e10eSEric Biggers 3033d435e10eSEric Biggers if (ivsize != crypto_skcipher_ivsize(generic_tfm)) { 3034d435e10eSEric Biggers pr_err("alg: skcipher: ivsize for %s (%u) doesn't match generic impl (%u)\n", 3035d435e10eSEric Biggers driver, ivsize, crypto_skcipher_ivsize(generic_tfm)); 3036d435e10eSEric Biggers err = -EINVAL; 3037d435e10eSEric Biggers goto out; 3038d435e10eSEric Biggers } 3039d435e10eSEric Biggers 3040d435e10eSEric Biggers if (blocksize != crypto_skcipher_blocksize(generic_tfm)) { 3041d435e10eSEric Biggers pr_err("alg: skcipher: blocksize for %s (%u) doesn't match generic impl (%u)\n", 3042d435e10eSEric Biggers driver, blocksize, 3043d435e10eSEric Biggers crypto_skcipher_blocksize(generic_tfm)); 3044d435e10eSEric Biggers err = -EINVAL; 3045d435e10eSEric Biggers goto out; 3046d435e10eSEric Biggers } 3047d435e10eSEric Biggers 3048d435e10eSEric Biggers /* 3049d435e10eSEric Biggers * Now generate test vectors using the generic implementation, and test 3050d435e10eSEric Biggers * the other implementation against them. 3051d435e10eSEric Biggers */ 3052d435e10eSEric Biggers 30539ac0d136SEric Biggers vec.key = kmalloc(maxkeysize, GFP_KERNEL); 3054d435e10eSEric Biggers vec.iv = kmalloc(ivsize, GFP_KERNEL); 3055d435e10eSEric Biggers vec.ptext = kmalloc(maxdatasize, GFP_KERNEL); 3056d435e10eSEric Biggers vec.ctext = kmalloc(maxdatasize, GFP_KERNEL); 3057d435e10eSEric Biggers if (!vec.key || !vec.iv || !vec.ptext || !vec.ctext) { 3058d435e10eSEric Biggers err = -ENOMEM; 3059d435e10eSEric Biggers goto out; 3060d435e10eSEric Biggers } 3061d435e10eSEric Biggers 3062d435e10eSEric Biggers for (i = 0; i < fuzz_iterations * 8; i++) { 3063d435e10eSEric Biggers generate_random_cipher_testvec(generic_req, &vec, maxdatasize, 3064d435e10eSEric Biggers vec_name, sizeof(vec_name)); 30656b5ca646SArnd Bergmann generate_random_testvec_config(cfg, cfgname, sizeof(cfgname)); 3066d435e10eSEric Biggers 30676e5972faSEric Biggers err = test_skcipher_vec_cfg(ENCRYPT, &vec, vec_name, 30686b5ca646SArnd Bergmann cfg, req, tsgls); 3069d435e10eSEric Biggers if (err) 3070d435e10eSEric Biggers goto out; 30716e5972faSEric Biggers err = test_skcipher_vec_cfg(DECRYPT, &vec, vec_name, 30726b5ca646SArnd Bergmann cfg, req, tsgls); 3073d435e10eSEric Biggers if (err) 3074d435e10eSEric Biggers goto out; 3075d435e10eSEric Biggers cond_resched(); 3076d435e10eSEric Biggers } 3077d435e10eSEric Biggers err = 0; 3078d435e10eSEric Biggers out: 30796b5ca646SArnd Bergmann kfree(cfg); 3080d435e10eSEric Biggers kfree(vec.key); 3081d435e10eSEric Biggers kfree(vec.iv); 3082d435e10eSEric Biggers kfree(vec.ptext); 3083d435e10eSEric Biggers kfree(vec.ctext); 3084d435e10eSEric Biggers crypto_free_skcipher(generic_tfm); 3085d435e10eSEric Biggers skcipher_request_free(generic_req); 3086d435e10eSEric Biggers return err; 3087d435e10eSEric Biggers } 3088d435e10eSEric Biggers #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 30896e5972faSEric Biggers static int test_skcipher_vs_generic_impl(const char *generic_driver, 3090d435e10eSEric Biggers struct skcipher_request *req, 3091d435e10eSEric Biggers struct cipher_test_sglists *tsgls) 3092d435e10eSEric Biggers { 3093d435e10eSEric Biggers return 0; 3094d435e10eSEric Biggers } 3095d435e10eSEric Biggers #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 3096d435e10eSEric Biggers 30976e5972faSEric Biggers static int test_skcipher(int enc, const struct cipher_test_suite *suite, 30984e7babbaSEric Biggers struct skcipher_request *req, 30994e7babbaSEric Biggers struct cipher_test_sglists *tsgls) 31004e7babbaSEric Biggers { 31014e7babbaSEric Biggers unsigned int i; 31024e7babbaSEric Biggers int err; 31034e7babbaSEric Biggers 31044e7babbaSEric Biggers for (i = 0; i < suite->count; i++) { 31056e5972faSEric Biggers err = test_skcipher_vec(enc, &suite->vecs[i], i, req, tsgls); 31064e7babbaSEric Biggers if (err) 31074e7babbaSEric Biggers return err; 3108e63e1b0dSEric Biggers cond_resched(); 31094e7babbaSEric Biggers } 31104e7babbaSEric Biggers return 0; 31114e7babbaSEric Biggers } 31124e7babbaSEric Biggers 31134e7babbaSEric Biggers static int alg_test_skcipher(const struct alg_test_desc *desc, 31144e7babbaSEric Biggers const char *driver, u32 type, u32 mask) 31154e7babbaSEric Biggers { 31164e7babbaSEric Biggers const struct cipher_test_suite *suite = &desc->suite.cipher; 31174e7babbaSEric Biggers struct crypto_skcipher *tfm; 31184e7babbaSEric Biggers struct skcipher_request *req = NULL; 31194e7babbaSEric Biggers struct cipher_test_sglists *tsgls = NULL; 31204e7babbaSEric Biggers int err; 31214e7babbaSEric Biggers 31224e7babbaSEric Biggers if (suite->count <= 0) { 31234e7babbaSEric Biggers pr_err("alg: skcipher: empty test suite for %s\n", driver); 31244e7babbaSEric Biggers return -EINVAL; 31254e7babbaSEric Biggers } 31264e7babbaSEric Biggers 31274e7babbaSEric Biggers tfm = crypto_alloc_skcipher(driver, type, mask); 31284e7babbaSEric Biggers if (IS_ERR(tfm)) { 31294e7babbaSEric Biggers pr_err("alg: skcipher: failed to allocate transform for %s: %ld\n", 31304e7babbaSEric Biggers driver, PTR_ERR(tfm)); 31314e7babbaSEric Biggers return PTR_ERR(tfm); 31324e7babbaSEric Biggers } 31336e5972faSEric Biggers driver = crypto_skcipher_driver_name(tfm); 31344e7babbaSEric Biggers 31354e7babbaSEric Biggers req = skcipher_request_alloc(tfm, GFP_KERNEL); 31364e7babbaSEric Biggers if (!req) { 31374e7babbaSEric Biggers pr_err("alg: skcipher: failed to allocate request for %s\n", 31384e7babbaSEric Biggers driver); 31394e7babbaSEric Biggers err = -ENOMEM; 31404e7babbaSEric Biggers goto out; 31414e7babbaSEric Biggers } 31424e7babbaSEric Biggers 31434e7babbaSEric Biggers tsgls = alloc_cipher_test_sglists(); 31444e7babbaSEric Biggers if (!tsgls) { 31454e7babbaSEric Biggers pr_err("alg: skcipher: failed to allocate test buffers for %s\n", 31464e7babbaSEric Biggers driver); 31474e7babbaSEric Biggers err = -ENOMEM; 31484e7babbaSEric Biggers goto out; 31494e7babbaSEric Biggers } 31504e7babbaSEric Biggers 31516e5972faSEric Biggers err = test_skcipher(ENCRYPT, suite, req, tsgls); 31524e7babbaSEric Biggers if (err) 31534e7babbaSEric Biggers goto out; 31544e7babbaSEric Biggers 31556e5972faSEric Biggers err = test_skcipher(DECRYPT, suite, req, tsgls); 3156d435e10eSEric Biggers if (err) 3157d435e10eSEric Biggers goto out; 3158d435e10eSEric Biggers 31596e5972faSEric Biggers err = test_skcipher_vs_generic_impl(desc->generic_driver, req, tsgls); 31604e7babbaSEric Biggers out: 31614e7babbaSEric Biggers free_cipher_test_sglists(tsgls); 31624e7babbaSEric Biggers skcipher_request_free(req); 31634e7babbaSEric Biggers crypto_free_skcipher(tfm); 31644e7babbaSEric Biggers return err; 31654e7babbaSEric Biggers } 31664e7babbaSEric Biggers 3167b13b1e0cSEric Biggers static int test_comp(struct crypto_comp *tfm, 3168b13b1e0cSEric Biggers const struct comp_testvec *ctemplate, 3169b13b1e0cSEric Biggers const struct comp_testvec *dtemplate, 3170b13b1e0cSEric Biggers int ctcount, int dtcount) 3171da7f033dSHerbert Xu { 3172da7f033dSHerbert Xu const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm)); 317333607384SMahipal Challa char *output, *decomp_output; 3174da7f033dSHerbert Xu unsigned int i; 3175da7f033dSHerbert Xu int ret; 3176da7f033dSHerbert Xu 317733607384SMahipal Challa output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 317833607384SMahipal Challa if (!output) 317933607384SMahipal Challa return -ENOMEM; 318033607384SMahipal Challa 318133607384SMahipal Challa decomp_output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 318233607384SMahipal Challa if (!decomp_output) { 318333607384SMahipal Challa kfree(output); 318433607384SMahipal Challa return -ENOMEM; 318533607384SMahipal Challa } 318633607384SMahipal Challa 3187da7f033dSHerbert Xu for (i = 0; i < ctcount; i++) { 3188c79cf910SGeert Uytterhoeven int ilen; 3189c79cf910SGeert Uytterhoeven unsigned int dlen = COMP_BUF_SIZE; 3190da7f033dSHerbert Xu 319122a8118dSMichael Schupikov memset(output, 0, COMP_BUF_SIZE); 319222a8118dSMichael Schupikov memset(decomp_output, 0, COMP_BUF_SIZE); 3193da7f033dSHerbert Xu 3194da7f033dSHerbert Xu ilen = ctemplate[i].inlen; 3195da7f033dSHerbert Xu ret = crypto_comp_compress(tfm, ctemplate[i].input, 319633607384SMahipal Challa ilen, output, &dlen); 3197da7f033dSHerbert Xu if (ret) { 3198da7f033dSHerbert Xu printk(KERN_ERR "alg: comp: compression failed " 3199da7f033dSHerbert Xu "on test %d for %s: ret=%d\n", i + 1, algo, 3200da7f033dSHerbert Xu -ret); 3201da7f033dSHerbert Xu goto out; 3202da7f033dSHerbert Xu } 3203da7f033dSHerbert Xu 320433607384SMahipal Challa ilen = dlen; 320533607384SMahipal Challa dlen = COMP_BUF_SIZE; 320633607384SMahipal Challa ret = crypto_comp_decompress(tfm, output, 320733607384SMahipal Challa ilen, decomp_output, &dlen); 320833607384SMahipal Challa if (ret) { 320933607384SMahipal Challa pr_err("alg: comp: compression failed: decompress: on test %d for %s failed: ret=%d\n", 321033607384SMahipal Challa i + 1, algo, -ret); 321133607384SMahipal Challa goto out; 321233607384SMahipal Challa } 321333607384SMahipal Challa 321433607384SMahipal Challa if (dlen != ctemplate[i].inlen) { 3215b812eb00SGeert Uytterhoeven printk(KERN_ERR "alg: comp: Compression test %d " 3216b812eb00SGeert Uytterhoeven "failed for %s: output len = %d\n", i + 1, algo, 3217b812eb00SGeert Uytterhoeven dlen); 3218b812eb00SGeert Uytterhoeven ret = -EINVAL; 3219b812eb00SGeert Uytterhoeven goto out; 3220b812eb00SGeert Uytterhoeven } 3221b812eb00SGeert Uytterhoeven 322233607384SMahipal Challa if (memcmp(decomp_output, ctemplate[i].input, 322333607384SMahipal Challa ctemplate[i].inlen)) { 322433607384SMahipal Challa pr_err("alg: comp: compression failed: output differs: on test %d for %s\n", 322533607384SMahipal Challa i + 1, algo); 322633607384SMahipal Challa hexdump(decomp_output, dlen); 3227da7f033dSHerbert Xu ret = -EINVAL; 3228da7f033dSHerbert Xu goto out; 3229da7f033dSHerbert Xu } 3230da7f033dSHerbert Xu } 3231da7f033dSHerbert Xu 3232da7f033dSHerbert Xu for (i = 0; i < dtcount; i++) { 3233c79cf910SGeert Uytterhoeven int ilen; 3234c79cf910SGeert Uytterhoeven unsigned int dlen = COMP_BUF_SIZE; 3235da7f033dSHerbert Xu 323622a8118dSMichael Schupikov memset(decomp_output, 0, COMP_BUF_SIZE); 3237da7f033dSHerbert Xu 3238da7f033dSHerbert Xu ilen = dtemplate[i].inlen; 3239da7f033dSHerbert Xu ret = crypto_comp_decompress(tfm, dtemplate[i].input, 324033607384SMahipal Challa ilen, decomp_output, &dlen); 3241da7f033dSHerbert Xu if (ret) { 3242da7f033dSHerbert Xu printk(KERN_ERR "alg: comp: decompression failed " 3243da7f033dSHerbert Xu "on test %d for %s: ret=%d\n", i + 1, algo, 3244da7f033dSHerbert Xu -ret); 3245da7f033dSHerbert Xu goto out; 3246da7f033dSHerbert Xu } 3247da7f033dSHerbert Xu 3248b812eb00SGeert Uytterhoeven if (dlen != dtemplate[i].outlen) { 3249b812eb00SGeert Uytterhoeven printk(KERN_ERR "alg: comp: Decompression test %d " 3250b812eb00SGeert Uytterhoeven "failed for %s: output len = %d\n", i + 1, algo, 3251b812eb00SGeert Uytterhoeven dlen); 3252b812eb00SGeert Uytterhoeven ret = -EINVAL; 3253b812eb00SGeert Uytterhoeven goto out; 3254b812eb00SGeert Uytterhoeven } 3255b812eb00SGeert Uytterhoeven 325633607384SMahipal Challa if (memcmp(decomp_output, dtemplate[i].output, dlen)) { 3257da7f033dSHerbert Xu printk(KERN_ERR "alg: comp: Decompression test %d " 3258da7f033dSHerbert Xu "failed for %s\n", i + 1, algo); 325933607384SMahipal Challa hexdump(decomp_output, dlen); 3260da7f033dSHerbert Xu ret = -EINVAL; 3261da7f033dSHerbert Xu goto out; 3262da7f033dSHerbert Xu } 3263da7f033dSHerbert Xu } 3264da7f033dSHerbert Xu 3265da7f033dSHerbert Xu ret = 0; 3266da7f033dSHerbert Xu 3267da7f033dSHerbert Xu out: 326833607384SMahipal Challa kfree(decomp_output); 326933607384SMahipal Challa kfree(output); 3270da7f033dSHerbert Xu return ret; 3271da7f033dSHerbert Xu } 3272da7f033dSHerbert Xu 3273b13b1e0cSEric Biggers static int test_acomp(struct crypto_acomp *tfm, 3274b13b1e0cSEric Biggers const struct comp_testvec *ctemplate, 3275b13b1e0cSEric Biggers const struct comp_testvec *dtemplate, 3276b13b1e0cSEric Biggers int ctcount, int dtcount) 3277d7db7a88SGiovanni Cabiddu { 3278d7db7a88SGiovanni Cabiddu const char *algo = crypto_tfm_alg_driver_name(crypto_acomp_tfm(tfm)); 3279d7db7a88SGiovanni Cabiddu unsigned int i; 3280a9943a0aSGiovanni Cabiddu char *output, *decomp_out; 3281d7db7a88SGiovanni Cabiddu int ret; 3282d7db7a88SGiovanni Cabiddu struct scatterlist src, dst; 3283d7db7a88SGiovanni Cabiddu struct acomp_req *req; 32847f397136SGilad Ben-Yossef struct crypto_wait wait; 3285d7db7a88SGiovanni Cabiddu 3286eb095593SEric Biggers output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 3287eb095593SEric Biggers if (!output) 3288eb095593SEric Biggers return -ENOMEM; 3289eb095593SEric Biggers 3290a9943a0aSGiovanni Cabiddu decomp_out = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 3291a9943a0aSGiovanni Cabiddu if (!decomp_out) { 3292a9943a0aSGiovanni Cabiddu kfree(output); 3293a9943a0aSGiovanni Cabiddu return -ENOMEM; 3294a9943a0aSGiovanni Cabiddu } 3295a9943a0aSGiovanni Cabiddu 3296d7db7a88SGiovanni Cabiddu for (i = 0; i < ctcount; i++) { 3297d7db7a88SGiovanni Cabiddu unsigned int dlen = COMP_BUF_SIZE; 3298d7db7a88SGiovanni Cabiddu int ilen = ctemplate[i].inlen; 329902608e02SLaura Abbott void *input_vec; 3300d7db7a88SGiovanni Cabiddu 3301d2110224SEric Biggers input_vec = kmemdup(ctemplate[i].input, ilen, GFP_KERNEL); 330202608e02SLaura Abbott if (!input_vec) { 330302608e02SLaura Abbott ret = -ENOMEM; 330402608e02SLaura Abbott goto out; 330502608e02SLaura Abbott } 330602608e02SLaura Abbott 3307eb095593SEric Biggers memset(output, 0, dlen); 33087f397136SGilad Ben-Yossef crypto_init_wait(&wait); 330902608e02SLaura Abbott sg_init_one(&src, input_vec, ilen); 3310d7db7a88SGiovanni Cabiddu sg_init_one(&dst, output, dlen); 3311d7db7a88SGiovanni Cabiddu 3312d7db7a88SGiovanni Cabiddu req = acomp_request_alloc(tfm); 3313d7db7a88SGiovanni Cabiddu if (!req) { 3314d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: request alloc failed for %s\n", 3315d7db7a88SGiovanni Cabiddu algo); 331602608e02SLaura Abbott kfree(input_vec); 3317d7db7a88SGiovanni Cabiddu ret = -ENOMEM; 3318d7db7a88SGiovanni Cabiddu goto out; 3319d7db7a88SGiovanni Cabiddu } 3320d7db7a88SGiovanni Cabiddu 3321d7db7a88SGiovanni Cabiddu acomp_request_set_params(req, &src, &dst, ilen, dlen); 3322d7db7a88SGiovanni Cabiddu acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 33237f397136SGilad Ben-Yossef crypto_req_done, &wait); 3324d7db7a88SGiovanni Cabiddu 33257f397136SGilad Ben-Yossef ret = crypto_wait_req(crypto_acomp_compress(req), &wait); 3326d7db7a88SGiovanni Cabiddu if (ret) { 3327d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n", 3328d7db7a88SGiovanni Cabiddu i + 1, algo, -ret); 332902608e02SLaura Abbott kfree(input_vec); 3330d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3331d7db7a88SGiovanni Cabiddu goto out; 3332d7db7a88SGiovanni Cabiddu } 3333d7db7a88SGiovanni Cabiddu 3334a9943a0aSGiovanni Cabiddu ilen = req->dlen; 3335a9943a0aSGiovanni Cabiddu dlen = COMP_BUF_SIZE; 3336a9943a0aSGiovanni Cabiddu sg_init_one(&src, output, ilen); 3337a9943a0aSGiovanni Cabiddu sg_init_one(&dst, decomp_out, dlen); 33387f397136SGilad Ben-Yossef crypto_init_wait(&wait); 3339a9943a0aSGiovanni Cabiddu acomp_request_set_params(req, &src, &dst, ilen, dlen); 3340a9943a0aSGiovanni Cabiddu 33417f397136SGilad Ben-Yossef ret = crypto_wait_req(crypto_acomp_decompress(req), &wait); 3342a9943a0aSGiovanni Cabiddu if (ret) { 3343a9943a0aSGiovanni Cabiddu pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n", 3344a9943a0aSGiovanni Cabiddu i + 1, algo, -ret); 3345a9943a0aSGiovanni Cabiddu kfree(input_vec); 3346a9943a0aSGiovanni Cabiddu acomp_request_free(req); 3347a9943a0aSGiovanni Cabiddu goto out; 3348a9943a0aSGiovanni Cabiddu } 3349a9943a0aSGiovanni Cabiddu 3350a9943a0aSGiovanni Cabiddu if (req->dlen != ctemplate[i].inlen) { 3351d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Compression test %d failed for %s: output len = %d\n", 3352d7db7a88SGiovanni Cabiddu i + 1, algo, req->dlen); 3353d7db7a88SGiovanni Cabiddu ret = -EINVAL; 335402608e02SLaura Abbott kfree(input_vec); 3355d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3356d7db7a88SGiovanni Cabiddu goto out; 3357d7db7a88SGiovanni Cabiddu } 3358d7db7a88SGiovanni Cabiddu 3359a9943a0aSGiovanni Cabiddu if (memcmp(input_vec, decomp_out, req->dlen)) { 3360d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Compression test %d failed for %s\n", 3361d7db7a88SGiovanni Cabiddu i + 1, algo); 3362d7db7a88SGiovanni Cabiddu hexdump(output, req->dlen); 3363d7db7a88SGiovanni Cabiddu ret = -EINVAL; 336402608e02SLaura Abbott kfree(input_vec); 3365d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3366d7db7a88SGiovanni Cabiddu goto out; 3367d7db7a88SGiovanni Cabiddu } 3368d7db7a88SGiovanni Cabiddu 336902608e02SLaura Abbott kfree(input_vec); 3370d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3371d7db7a88SGiovanni Cabiddu } 3372d7db7a88SGiovanni Cabiddu 3373d7db7a88SGiovanni Cabiddu for (i = 0; i < dtcount; i++) { 3374d7db7a88SGiovanni Cabiddu unsigned int dlen = COMP_BUF_SIZE; 3375d7db7a88SGiovanni Cabiddu int ilen = dtemplate[i].inlen; 337602608e02SLaura Abbott void *input_vec; 3377d7db7a88SGiovanni Cabiddu 3378d2110224SEric Biggers input_vec = kmemdup(dtemplate[i].input, ilen, GFP_KERNEL); 337902608e02SLaura Abbott if (!input_vec) { 338002608e02SLaura Abbott ret = -ENOMEM; 338102608e02SLaura Abbott goto out; 338202608e02SLaura Abbott } 338302608e02SLaura Abbott 3384eb095593SEric Biggers memset(output, 0, dlen); 33857f397136SGilad Ben-Yossef crypto_init_wait(&wait); 338602608e02SLaura Abbott sg_init_one(&src, input_vec, ilen); 3387d7db7a88SGiovanni Cabiddu sg_init_one(&dst, output, dlen); 3388d7db7a88SGiovanni Cabiddu 3389d7db7a88SGiovanni Cabiddu req = acomp_request_alloc(tfm); 3390d7db7a88SGiovanni Cabiddu if (!req) { 3391d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: request alloc failed for %s\n", 3392d7db7a88SGiovanni Cabiddu algo); 339302608e02SLaura Abbott kfree(input_vec); 3394d7db7a88SGiovanni Cabiddu ret = -ENOMEM; 3395d7db7a88SGiovanni Cabiddu goto out; 3396d7db7a88SGiovanni Cabiddu } 3397d7db7a88SGiovanni Cabiddu 3398d7db7a88SGiovanni Cabiddu acomp_request_set_params(req, &src, &dst, ilen, dlen); 3399d7db7a88SGiovanni Cabiddu acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 34007f397136SGilad Ben-Yossef crypto_req_done, &wait); 3401d7db7a88SGiovanni Cabiddu 34027f397136SGilad Ben-Yossef ret = crypto_wait_req(crypto_acomp_decompress(req), &wait); 3403d7db7a88SGiovanni Cabiddu if (ret) { 3404d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: decompression failed on test %d for %s: ret=%d\n", 3405d7db7a88SGiovanni Cabiddu i + 1, algo, -ret); 340602608e02SLaura Abbott kfree(input_vec); 3407d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3408d7db7a88SGiovanni Cabiddu goto out; 3409d7db7a88SGiovanni Cabiddu } 3410d7db7a88SGiovanni Cabiddu 3411d7db7a88SGiovanni Cabiddu if (req->dlen != dtemplate[i].outlen) { 3412d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Decompression test %d failed for %s: output len = %d\n", 3413d7db7a88SGiovanni Cabiddu i + 1, algo, req->dlen); 3414d7db7a88SGiovanni Cabiddu ret = -EINVAL; 341502608e02SLaura Abbott kfree(input_vec); 3416d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3417d7db7a88SGiovanni Cabiddu goto out; 3418d7db7a88SGiovanni Cabiddu } 3419d7db7a88SGiovanni Cabiddu 3420d7db7a88SGiovanni Cabiddu if (memcmp(output, dtemplate[i].output, req->dlen)) { 3421d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Decompression test %d failed for %s\n", 3422d7db7a88SGiovanni Cabiddu i + 1, algo); 3423d7db7a88SGiovanni Cabiddu hexdump(output, req->dlen); 3424d7db7a88SGiovanni Cabiddu ret = -EINVAL; 342502608e02SLaura Abbott kfree(input_vec); 3426d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3427d7db7a88SGiovanni Cabiddu goto out; 3428d7db7a88SGiovanni Cabiddu } 3429d7db7a88SGiovanni Cabiddu 343002608e02SLaura Abbott kfree(input_vec); 3431d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3432d7db7a88SGiovanni Cabiddu } 3433d7db7a88SGiovanni Cabiddu 3434d7db7a88SGiovanni Cabiddu ret = 0; 3435d7db7a88SGiovanni Cabiddu 3436d7db7a88SGiovanni Cabiddu out: 3437a9943a0aSGiovanni Cabiddu kfree(decomp_out); 3438eb095593SEric Biggers kfree(output); 3439d7db7a88SGiovanni Cabiddu return ret; 3440d7db7a88SGiovanni Cabiddu } 3441d7db7a88SGiovanni Cabiddu 3442b13b1e0cSEric Biggers static int test_cprng(struct crypto_rng *tfm, 3443b13b1e0cSEric Biggers const struct cprng_testvec *template, 34447647d6ceSJarod Wilson unsigned int tcount) 34457647d6ceSJarod Wilson { 34467647d6ceSJarod Wilson const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm)); 3447fa4ef8a6SFelipe Contreras int err = 0, i, j, seedsize; 34487647d6ceSJarod Wilson u8 *seed; 34497647d6ceSJarod Wilson char result[32]; 34507647d6ceSJarod Wilson 34517647d6ceSJarod Wilson seedsize = crypto_rng_seedsize(tfm); 34527647d6ceSJarod Wilson 34537647d6ceSJarod Wilson seed = kmalloc(seedsize, GFP_KERNEL); 34547647d6ceSJarod Wilson if (!seed) { 34557647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to allocate seed space " 34567647d6ceSJarod Wilson "for %s\n", algo); 34577647d6ceSJarod Wilson return -ENOMEM; 34587647d6ceSJarod Wilson } 34597647d6ceSJarod Wilson 34607647d6ceSJarod Wilson for (i = 0; i < tcount; i++) { 34617647d6ceSJarod Wilson memset(result, 0, 32); 34627647d6ceSJarod Wilson 34637647d6ceSJarod Wilson memcpy(seed, template[i].v, template[i].vlen); 34647647d6ceSJarod Wilson memcpy(seed + template[i].vlen, template[i].key, 34657647d6ceSJarod Wilson template[i].klen); 34667647d6ceSJarod Wilson memcpy(seed + template[i].vlen + template[i].klen, 34677647d6ceSJarod Wilson template[i].dt, template[i].dtlen); 34687647d6ceSJarod Wilson 34697647d6ceSJarod Wilson err = crypto_rng_reset(tfm, seed, seedsize); 34707647d6ceSJarod Wilson if (err) { 34717647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to reset rng " 34727647d6ceSJarod Wilson "for %s\n", algo); 34737647d6ceSJarod Wilson goto out; 34747647d6ceSJarod Wilson } 34757647d6ceSJarod Wilson 34767647d6ceSJarod Wilson for (j = 0; j < template[i].loops; j++) { 34777647d6ceSJarod Wilson err = crypto_rng_get_bytes(tfm, result, 34787647d6ceSJarod Wilson template[i].rlen); 347919e60e13SStephan Mueller if (err < 0) { 34807647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to obtain " 34817647d6ceSJarod Wilson "the correct amount of random data for " 348219e60e13SStephan Mueller "%s (requested %d)\n", algo, 348319e60e13SStephan Mueller template[i].rlen); 34847647d6ceSJarod Wilson goto out; 34857647d6ceSJarod Wilson } 34867647d6ceSJarod Wilson } 34877647d6ceSJarod Wilson 34887647d6ceSJarod Wilson err = memcmp(result, template[i].result, 34897647d6ceSJarod Wilson template[i].rlen); 34907647d6ceSJarod Wilson if (err) { 34917647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Test %d failed for %s\n", 34927647d6ceSJarod Wilson i, algo); 34937647d6ceSJarod Wilson hexdump(result, template[i].rlen); 34947647d6ceSJarod Wilson err = -EINVAL; 34957647d6ceSJarod Wilson goto out; 34967647d6ceSJarod Wilson } 34977647d6ceSJarod Wilson } 34987647d6ceSJarod Wilson 34997647d6ceSJarod Wilson out: 35007647d6ceSJarod Wilson kfree(seed); 35017647d6ceSJarod Wilson return err; 35027647d6ceSJarod Wilson } 35037647d6ceSJarod Wilson 3504da7f033dSHerbert Xu static int alg_test_cipher(const struct alg_test_desc *desc, 3505da7f033dSHerbert Xu const char *driver, u32 type, u32 mask) 3506da7f033dSHerbert Xu { 350792a4c9feSEric Biggers const struct cipher_test_suite *suite = &desc->suite.cipher; 35081aa4ecd9SHerbert Xu struct crypto_cipher *tfm; 350992a4c9feSEric Biggers int err; 3510da7f033dSHerbert Xu 3511eed93e0cSHerbert Xu tfm = crypto_alloc_cipher(driver, type, mask); 3512da7f033dSHerbert Xu if (IS_ERR(tfm)) { 3513da7f033dSHerbert Xu printk(KERN_ERR "alg: cipher: Failed to load transform for " 3514da7f033dSHerbert Xu "%s: %ld\n", driver, PTR_ERR(tfm)); 3515da7f033dSHerbert Xu return PTR_ERR(tfm); 3516da7f033dSHerbert Xu } 3517da7f033dSHerbert Xu 351892a4c9feSEric Biggers err = test_cipher(tfm, ENCRYPT, suite->vecs, suite->count); 351992a4c9feSEric Biggers if (!err) 352092a4c9feSEric Biggers err = test_cipher(tfm, DECRYPT, suite->vecs, suite->count); 3521da7f033dSHerbert Xu 35221aa4ecd9SHerbert Xu crypto_free_cipher(tfm); 35231aa4ecd9SHerbert Xu return err; 35241aa4ecd9SHerbert Xu } 35251aa4ecd9SHerbert Xu 3526da7f033dSHerbert Xu static int alg_test_comp(const struct alg_test_desc *desc, const char *driver, 3527da7f033dSHerbert Xu u32 type, u32 mask) 3528da7f033dSHerbert Xu { 3529d7db7a88SGiovanni Cabiddu struct crypto_comp *comp; 3530d7db7a88SGiovanni Cabiddu struct crypto_acomp *acomp; 3531da7f033dSHerbert Xu int err; 3532d7db7a88SGiovanni Cabiddu u32 algo_type = type & CRYPTO_ALG_TYPE_ACOMPRESS_MASK; 3533da7f033dSHerbert Xu 3534d7db7a88SGiovanni Cabiddu if (algo_type == CRYPTO_ALG_TYPE_ACOMPRESS) { 3535d7db7a88SGiovanni Cabiddu acomp = crypto_alloc_acomp(driver, type, mask); 3536d7db7a88SGiovanni Cabiddu if (IS_ERR(acomp)) { 3537d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Failed to load transform for %s: %ld\n", 3538d7db7a88SGiovanni Cabiddu driver, PTR_ERR(acomp)); 3539d7db7a88SGiovanni Cabiddu return PTR_ERR(acomp); 3540d7db7a88SGiovanni Cabiddu } 3541d7db7a88SGiovanni Cabiddu err = test_acomp(acomp, desc->suite.comp.comp.vecs, 3542d7db7a88SGiovanni Cabiddu desc->suite.comp.decomp.vecs, 3543d7db7a88SGiovanni Cabiddu desc->suite.comp.comp.count, 3544d7db7a88SGiovanni Cabiddu desc->suite.comp.decomp.count); 3545d7db7a88SGiovanni Cabiddu crypto_free_acomp(acomp); 3546d7db7a88SGiovanni Cabiddu } else { 3547d7db7a88SGiovanni Cabiddu comp = crypto_alloc_comp(driver, type, mask); 3548d7db7a88SGiovanni Cabiddu if (IS_ERR(comp)) { 3549d7db7a88SGiovanni Cabiddu pr_err("alg: comp: Failed to load transform for %s: %ld\n", 3550d7db7a88SGiovanni Cabiddu driver, PTR_ERR(comp)); 3551d7db7a88SGiovanni Cabiddu return PTR_ERR(comp); 3552da7f033dSHerbert Xu } 3553da7f033dSHerbert Xu 3554d7db7a88SGiovanni Cabiddu err = test_comp(comp, desc->suite.comp.comp.vecs, 3555da7f033dSHerbert Xu desc->suite.comp.decomp.vecs, 3556da7f033dSHerbert Xu desc->suite.comp.comp.count, 3557da7f033dSHerbert Xu desc->suite.comp.decomp.count); 3558da7f033dSHerbert Xu 3559d7db7a88SGiovanni Cabiddu crypto_free_comp(comp); 3560d7db7a88SGiovanni Cabiddu } 3561da7f033dSHerbert Xu return err; 3562da7f033dSHerbert Xu } 3563da7f033dSHerbert Xu 35648e3ee85eSHerbert Xu static int alg_test_crc32c(const struct alg_test_desc *desc, 35658e3ee85eSHerbert Xu const char *driver, u32 type, u32 mask) 35668e3ee85eSHerbert Xu { 35678e3ee85eSHerbert Xu struct crypto_shash *tfm; 3568cb9dde88SEric Biggers __le32 val; 35698e3ee85eSHerbert Xu int err; 35708e3ee85eSHerbert Xu 35718e3ee85eSHerbert Xu err = alg_test_hash(desc, driver, type, mask); 35728e3ee85eSHerbert Xu if (err) 3573eb5e6730SEric Biggers return err; 35748e3ee85eSHerbert Xu 3575eed93e0cSHerbert Xu tfm = crypto_alloc_shash(driver, type, mask); 35768e3ee85eSHerbert Xu if (IS_ERR(tfm)) { 3577eb5e6730SEric Biggers if (PTR_ERR(tfm) == -ENOENT) { 3578eb5e6730SEric Biggers /* 3579eb5e6730SEric Biggers * This crc32c implementation is only available through 3580eb5e6730SEric Biggers * ahash API, not the shash API, so the remaining part 3581eb5e6730SEric Biggers * of the test is not applicable to it. 3582eb5e6730SEric Biggers */ 3583eb5e6730SEric Biggers return 0; 3584eb5e6730SEric Biggers } 35858e3ee85eSHerbert Xu printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: " 35868e3ee85eSHerbert Xu "%ld\n", driver, PTR_ERR(tfm)); 3587eb5e6730SEric Biggers return PTR_ERR(tfm); 35888e3ee85eSHerbert Xu } 358979cafe9aSEric Biggers driver = crypto_shash_driver_name(tfm); 35908e3ee85eSHerbert Xu 35918e3ee85eSHerbert Xu do { 35924c5c3024SJan-Simon Möller SHASH_DESC_ON_STACK(shash, tfm); 35934c5c3024SJan-Simon Möller u32 *ctx = (u32 *)shash_desc_ctx(shash); 35948e3ee85eSHerbert Xu 35954c5c3024SJan-Simon Möller shash->tfm = tfm; 35968e3ee85eSHerbert Xu 3597cb9dde88SEric Biggers *ctx = 420553207; 35984c5c3024SJan-Simon Möller err = crypto_shash_final(shash, (u8 *)&val); 35998e3ee85eSHerbert Xu if (err) { 36008e3ee85eSHerbert Xu printk(KERN_ERR "alg: crc32c: Operation failed for " 36018e3ee85eSHerbert Xu "%s: %d\n", driver, err); 36028e3ee85eSHerbert Xu break; 36038e3ee85eSHerbert Xu } 36048e3ee85eSHerbert Xu 3605cb9dde88SEric Biggers if (val != cpu_to_le32(~420553207)) { 3606cb9dde88SEric Biggers pr_err("alg: crc32c: Test failed for %s: %u\n", 3607cb9dde88SEric Biggers driver, le32_to_cpu(val)); 36088e3ee85eSHerbert Xu err = -EINVAL; 36098e3ee85eSHerbert Xu } 36108e3ee85eSHerbert Xu } while (0); 36118e3ee85eSHerbert Xu 36128e3ee85eSHerbert Xu crypto_free_shash(tfm); 36138e3ee85eSHerbert Xu 36148e3ee85eSHerbert Xu return err; 36158e3ee85eSHerbert Xu } 36168e3ee85eSHerbert Xu 36177647d6ceSJarod Wilson static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver, 36187647d6ceSJarod Wilson u32 type, u32 mask) 36197647d6ceSJarod Wilson { 36207647d6ceSJarod Wilson struct crypto_rng *rng; 36217647d6ceSJarod Wilson int err; 36227647d6ceSJarod Wilson 3623eed93e0cSHerbert Xu rng = crypto_alloc_rng(driver, type, mask); 36247647d6ceSJarod Wilson if (IS_ERR(rng)) { 36257647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to load transform for %s: " 36267647d6ceSJarod Wilson "%ld\n", driver, PTR_ERR(rng)); 36277647d6ceSJarod Wilson return PTR_ERR(rng); 36287647d6ceSJarod Wilson } 36297647d6ceSJarod Wilson 36307647d6ceSJarod Wilson err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count); 36317647d6ceSJarod Wilson 36327647d6ceSJarod Wilson crypto_free_rng(rng); 36337647d6ceSJarod Wilson 36347647d6ceSJarod Wilson return err; 36357647d6ceSJarod Wilson } 36367647d6ceSJarod Wilson 363764d1cdfbSStephan Mueller 3638b13b1e0cSEric Biggers static int drbg_cavs_test(const struct drbg_testvec *test, int pr, 363964d1cdfbSStephan Mueller const char *driver, u32 type, u32 mask) 364064d1cdfbSStephan Mueller { 364164d1cdfbSStephan Mueller int ret = -EAGAIN; 364264d1cdfbSStephan Mueller struct crypto_rng *drng; 364364d1cdfbSStephan Mueller struct drbg_test_data test_data; 364464d1cdfbSStephan Mueller struct drbg_string addtl, pers, testentropy; 364564d1cdfbSStephan Mueller unsigned char *buf = kzalloc(test->expectedlen, GFP_KERNEL); 364664d1cdfbSStephan Mueller 364764d1cdfbSStephan Mueller if (!buf) 364864d1cdfbSStephan Mueller return -ENOMEM; 364964d1cdfbSStephan Mueller 3650eed93e0cSHerbert Xu drng = crypto_alloc_rng(driver, type, mask); 365164d1cdfbSStephan Mueller if (IS_ERR(drng)) { 365264d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: could not allocate DRNG handle for " 365364d1cdfbSStephan Mueller "%s\n", driver); 3654453431a5SWaiman Long kfree_sensitive(buf); 365564d1cdfbSStephan Mueller return -ENOMEM; 365664d1cdfbSStephan Mueller } 365764d1cdfbSStephan Mueller 365864d1cdfbSStephan Mueller test_data.testentropy = &testentropy; 365964d1cdfbSStephan Mueller drbg_string_fill(&testentropy, test->entropy, test->entropylen); 366064d1cdfbSStephan Mueller drbg_string_fill(&pers, test->pers, test->perslen); 366164d1cdfbSStephan Mueller ret = crypto_drbg_reset_test(drng, &pers, &test_data); 366264d1cdfbSStephan Mueller if (ret) { 366364d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: Failed to reset rng\n"); 366464d1cdfbSStephan Mueller goto outbuf; 366564d1cdfbSStephan Mueller } 366664d1cdfbSStephan Mueller 366764d1cdfbSStephan Mueller drbg_string_fill(&addtl, test->addtla, test->addtllen); 366864d1cdfbSStephan Mueller if (pr) { 366964d1cdfbSStephan Mueller drbg_string_fill(&testentropy, test->entpra, test->entprlen); 367064d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl_test(drng, 367164d1cdfbSStephan Mueller buf, test->expectedlen, &addtl, &test_data); 367264d1cdfbSStephan Mueller } else { 367364d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl(drng, 367464d1cdfbSStephan Mueller buf, test->expectedlen, &addtl); 367564d1cdfbSStephan Mueller } 367619e60e13SStephan Mueller if (ret < 0) { 367764d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: could not obtain random data for " 367864d1cdfbSStephan Mueller "driver %s\n", driver); 367964d1cdfbSStephan Mueller goto outbuf; 368064d1cdfbSStephan Mueller } 368164d1cdfbSStephan Mueller 368264d1cdfbSStephan Mueller drbg_string_fill(&addtl, test->addtlb, test->addtllen); 368364d1cdfbSStephan Mueller if (pr) { 368464d1cdfbSStephan Mueller drbg_string_fill(&testentropy, test->entprb, test->entprlen); 368564d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl_test(drng, 368664d1cdfbSStephan Mueller buf, test->expectedlen, &addtl, &test_data); 368764d1cdfbSStephan Mueller } else { 368864d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl(drng, 368964d1cdfbSStephan Mueller buf, test->expectedlen, &addtl); 369064d1cdfbSStephan Mueller } 369119e60e13SStephan Mueller if (ret < 0) { 369264d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: could not obtain random data for " 369364d1cdfbSStephan Mueller "driver %s\n", driver); 369464d1cdfbSStephan Mueller goto outbuf; 369564d1cdfbSStephan Mueller } 369664d1cdfbSStephan Mueller 369764d1cdfbSStephan Mueller ret = memcmp(test->expected, buf, test->expectedlen); 369864d1cdfbSStephan Mueller 369964d1cdfbSStephan Mueller outbuf: 370064d1cdfbSStephan Mueller crypto_free_rng(drng); 3701453431a5SWaiman Long kfree_sensitive(buf); 370264d1cdfbSStephan Mueller return ret; 370364d1cdfbSStephan Mueller } 370464d1cdfbSStephan Mueller 370564d1cdfbSStephan Mueller 370664d1cdfbSStephan Mueller static int alg_test_drbg(const struct alg_test_desc *desc, const char *driver, 370764d1cdfbSStephan Mueller u32 type, u32 mask) 370864d1cdfbSStephan Mueller { 370964d1cdfbSStephan Mueller int err = 0; 371064d1cdfbSStephan Mueller int pr = 0; 371164d1cdfbSStephan Mueller int i = 0; 3712b13b1e0cSEric Biggers const struct drbg_testvec *template = desc->suite.drbg.vecs; 371364d1cdfbSStephan Mueller unsigned int tcount = desc->suite.drbg.count; 371464d1cdfbSStephan Mueller 371564d1cdfbSStephan Mueller if (0 == memcmp(driver, "drbg_pr_", 8)) 371664d1cdfbSStephan Mueller pr = 1; 371764d1cdfbSStephan Mueller 371864d1cdfbSStephan Mueller for (i = 0; i < tcount; i++) { 371964d1cdfbSStephan Mueller err = drbg_cavs_test(&template[i], pr, driver, type, mask); 372064d1cdfbSStephan Mueller if (err) { 372164d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: Test %d failed for %s\n", 372264d1cdfbSStephan Mueller i, driver); 372364d1cdfbSStephan Mueller err = -EINVAL; 372464d1cdfbSStephan Mueller break; 372564d1cdfbSStephan Mueller } 372664d1cdfbSStephan Mueller } 372764d1cdfbSStephan Mueller return err; 372864d1cdfbSStephan Mueller 372964d1cdfbSStephan Mueller } 373064d1cdfbSStephan Mueller 3731b13b1e0cSEric Biggers static int do_test_kpp(struct crypto_kpp *tfm, const struct kpp_testvec *vec, 3732802c7f1cSSalvatore Benedetto const char *alg) 3733802c7f1cSSalvatore Benedetto { 3734802c7f1cSSalvatore Benedetto struct kpp_request *req; 3735802c7f1cSSalvatore Benedetto void *input_buf = NULL; 3736802c7f1cSSalvatore Benedetto void *output_buf = NULL; 373747d3fd39STudor-Dan Ambarus void *a_public = NULL; 373847d3fd39STudor-Dan Ambarus void *a_ss = NULL; 373947d3fd39STudor-Dan Ambarus void *shared_secret = NULL; 37407f397136SGilad Ben-Yossef struct crypto_wait wait; 3741802c7f1cSSalvatore Benedetto unsigned int out_len_max; 3742802c7f1cSSalvatore Benedetto int err = -ENOMEM; 3743802c7f1cSSalvatore Benedetto struct scatterlist src, dst; 3744802c7f1cSSalvatore Benedetto 3745802c7f1cSSalvatore Benedetto req = kpp_request_alloc(tfm, GFP_KERNEL); 3746802c7f1cSSalvatore Benedetto if (!req) 3747802c7f1cSSalvatore Benedetto return err; 3748802c7f1cSSalvatore Benedetto 37497f397136SGilad Ben-Yossef crypto_init_wait(&wait); 3750802c7f1cSSalvatore Benedetto 3751802c7f1cSSalvatore Benedetto err = crypto_kpp_set_secret(tfm, vec->secret, vec->secret_size); 3752802c7f1cSSalvatore Benedetto if (err < 0) 3753802c7f1cSSalvatore Benedetto goto free_req; 3754802c7f1cSSalvatore Benedetto 3755802c7f1cSSalvatore Benedetto out_len_max = crypto_kpp_maxsize(tfm); 3756802c7f1cSSalvatore Benedetto output_buf = kzalloc(out_len_max, GFP_KERNEL); 3757802c7f1cSSalvatore Benedetto if (!output_buf) { 3758802c7f1cSSalvatore Benedetto err = -ENOMEM; 3759802c7f1cSSalvatore Benedetto goto free_req; 3760802c7f1cSSalvatore Benedetto } 3761802c7f1cSSalvatore Benedetto 3762802c7f1cSSalvatore Benedetto /* Use appropriate parameter as base */ 3763802c7f1cSSalvatore Benedetto kpp_request_set_input(req, NULL, 0); 3764802c7f1cSSalvatore Benedetto sg_init_one(&dst, output_buf, out_len_max); 3765802c7f1cSSalvatore Benedetto kpp_request_set_output(req, &dst, out_len_max); 3766802c7f1cSSalvatore Benedetto kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 37677f397136SGilad Ben-Yossef crypto_req_done, &wait); 3768802c7f1cSSalvatore Benedetto 376947d3fd39STudor-Dan Ambarus /* Compute party A's public key */ 37707f397136SGilad Ben-Yossef err = crypto_wait_req(crypto_kpp_generate_public_key(req), &wait); 3771802c7f1cSSalvatore Benedetto if (err) { 377247d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party A: generate public key test failed. err %d\n", 3773802c7f1cSSalvatore Benedetto alg, err); 3774802c7f1cSSalvatore Benedetto goto free_output; 3775802c7f1cSSalvatore Benedetto } 377647d3fd39STudor-Dan Ambarus 377747d3fd39STudor-Dan Ambarus if (vec->genkey) { 377847d3fd39STudor-Dan Ambarus /* Save party A's public key */ 3779e3d90e52SChristopher Diaz Riveros a_public = kmemdup(sg_virt(req->dst), out_len_max, GFP_KERNEL); 378047d3fd39STudor-Dan Ambarus if (!a_public) { 378147d3fd39STudor-Dan Ambarus err = -ENOMEM; 378247d3fd39STudor-Dan Ambarus goto free_output; 378347d3fd39STudor-Dan Ambarus } 378447d3fd39STudor-Dan Ambarus } else { 3785802c7f1cSSalvatore Benedetto /* Verify calculated public key */ 3786802c7f1cSSalvatore Benedetto if (memcmp(vec->expected_a_public, sg_virt(req->dst), 3787802c7f1cSSalvatore Benedetto vec->expected_a_public_size)) { 378847d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party A: generate public key test failed. Invalid output\n", 3789802c7f1cSSalvatore Benedetto alg); 3790802c7f1cSSalvatore Benedetto err = -EINVAL; 3791802c7f1cSSalvatore Benedetto goto free_output; 3792802c7f1cSSalvatore Benedetto } 379347d3fd39STudor-Dan Ambarus } 3794802c7f1cSSalvatore Benedetto 3795802c7f1cSSalvatore Benedetto /* Calculate shared secret key by using counter part (b) public key. */ 3796e3d90e52SChristopher Diaz Riveros input_buf = kmemdup(vec->b_public, vec->b_public_size, GFP_KERNEL); 3797802c7f1cSSalvatore Benedetto if (!input_buf) { 3798802c7f1cSSalvatore Benedetto err = -ENOMEM; 3799802c7f1cSSalvatore Benedetto goto free_output; 3800802c7f1cSSalvatore Benedetto } 3801802c7f1cSSalvatore Benedetto 3802802c7f1cSSalvatore Benedetto sg_init_one(&src, input_buf, vec->b_public_size); 3803802c7f1cSSalvatore Benedetto sg_init_one(&dst, output_buf, out_len_max); 3804802c7f1cSSalvatore Benedetto kpp_request_set_input(req, &src, vec->b_public_size); 3805802c7f1cSSalvatore Benedetto kpp_request_set_output(req, &dst, out_len_max); 3806802c7f1cSSalvatore Benedetto kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 38077f397136SGilad Ben-Yossef crypto_req_done, &wait); 38087f397136SGilad Ben-Yossef err = crypto_wait_req(crypto_kpp_compute_shared_secret(req), &wait); 3809802c7f1cSSalvatore Benedetto if (err) { 381047d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party A: compute shared secret test failed. err %d\n", 3811802c7f1cSSalvatore Benedetto alg, err); 3812802c7f1cSSalvatore Benedetto goto free_all; 3813802c7f1cSSalvatore Benedetto } 381447d3fd39STudor-Dan Ambarus 381547d3fd39STudor-Dan Ambarus if (vec->genkey) { 381647d3fd39STudor-Dan Ambarus /* Save the shared secret obtained by party A */ 3817e3d90e52SChristopher Diaz Riveros a_ss = kmemdup(sg_virt(req->dst), vec->expected_ss_size, GFP_KERNEL); 381847d3fd39STudor-Dan Ambarus if (!a_ss) { 381947d3fd39STudor-Dan Ambarus err = -ENOMEM; 382047d3fd39STudor-Dan Ambarus goto free_all; 382147d3fd39STudor-Dan Ambarus } 382247d3fd39STudor-Dan Ambarus 382347d3fd39STudor-Dan Ambarus /* 382447d3fd39STudor-Dan Ambarus * Calculate party B's shared secret by using party A's 382547d3fd39STudor-Dan Ambarus * public key. 382647d3fd39STudor-Dan Ambarus */ 382747d3fd39STudor-Dan Ambarus err = crypto_kpp_set_secret(tfm, vec->b_secret, 382847d3fd39STudor-Dan Ambarus vec->b_secret_size); 382947d3fd39STudor-Dan Ambarus if (err < 0) 383047d3fd39STudor-Dan Ambarus goto free_all; 383147d3fd39STudor-Dan Ambarus 383247d3fd39STudor-Dan Ambarus sg_init_one(&src, a_public, vec->expected_a_public_size); 383347d3fd39STudor-Dan Ambarus sg_init_one(&dst, output_buf, out_len_max); 383447d3fd39STudor-Dan Ambarus kpp_request_set_input(req, &src, vec->expected_a_public_size); 383547d3fd39STudor-Dan Ambarus kpp_request_set_output(req, &dst, out_len_max); 383647d3fd39STudor-Dan Ambarus kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 38377f397136SGilad Ben-Yossef crypto_req_done, &wait); 38387f397136SGilad Ben-Yossef err = crypto_wait_req(crypto_kpp_compute_shared_secret(req), 38397f397136SGilad Ben-Yossef &wait); 384047d3fd39STudor-Dan Ambarus if (err) { 384147d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party B: compute shared secret failed. err %d\n", 384247d3fd39STudor-Dan Ambarus alg, err); 384347d3fd39STudor-Dan Ambarus goto free_all; 384447d3fd39STudor-Dan Ambarus } 384547d3fd39STudor-Dan Ambarus 384647d3fd39STudor-Dan Ambarus shared_secret = a_ss; 384747d3fd39STudor-Dan Ambarus } else { 384847d3fd39STudor-Dan Ambarus shared_secret = (void *)vec->expected_ss; 384947d3fd39STudor-Dan Ambarus } 385047d3fd39STudor-Dan Ambarus 3851802c7f1cSSalvatore Benedetto /* 3852802c7f1cSSalvatore Benedetto * verify shared secret from which the user will derive 3853802c7f1cSSalvatore Benedetto * secret key by executing whatever hash it has chosen 3854802c7f1cSSalvatore Benedetto */ 385547d3fd39STudor-Dan Ambarus if (memcmp(shared_secret, sg_virt(req->dst), 3856802c7f1cSSalvatore Benedetto vec->expected_ss_size)) { 3857802c7f1cSSalvatore Benedetto pr_err("alg: %s: compute shared secret test failed. Invalid output\n", 3858802c7f1cSSalvatore Benedetto alg); 3859802c7f1cSSalvatore Benedetto err = -EINVAL; 3860802c7f1cSSalvatore Benedetto } 3861802c7f1cSSalvatore Benedetto 3862802c7f1cSSalvatore Benedetto free_all: 386347d3fd39STudor-Dan Ambarus kfree(a_ss); 3864802c7f1cSSalvatore Benedetto kfree(input_buf); 3865802c7f1cSSalvatore Benedetto free_output: 386647d3fd39STudor-Dan Ambarus kfree(a_public); 3867802c7f1cSSalvatore Benedetto kfree(output_buf); 3868802c7f1cSSalvatore Benedetto free_req: 3869802c7f1cSSalvatore Benedetto kpp_request_free(req); 3870802c7f1cSSalvatore Benedetto return err; 3871802c7f1cSSalvatore Benedetto } 3872802c7f1cSSalvatore Benedetto 3873802c7f1cSSalvatore Benedetto static int test_kpp(struct crypto_kpp *tfm, const char *alg, 3874b13b1e0cSEric Biggers const struct kpp_testvec *vecs, unsigned int tcount) 3875802c7f1cSSalvatore Benedetto { 3876802c7f1cSSalvatore Benedetto int ret, i; 3877802c7f1cSSalvatore Benedetto 3878802c7f1cSSalvatore Benedetto for (i = 0; i < tcount; i++) { 3879802c7f1cSSalvatore Benedetto ret = do_test_kpp(tfm, vecs++, alg); 3880802c7f1cSSalvatore Benedetto if (ret) { 3881802c7f1cSSalvatore Benedetto pr_err("alg: %s: test failed on vector %d, err=%d\n", 3882802c7f1cSSalvatore Benedetto alg, i + 1, ret); 3883802c7f1cSSalvatore Benedetto return ret; 3884802c7f1cSSalvatore Benedetto } 3885802c7f1cSSalvatore Benedetto } 3886802c7f1cSSalvatore Benedetto return 0; 3887802c7f1cSSalvatore Benedetto } 3888802c7f1cSSalvatore Benedetto 3889802c7f1cSSalvatore Benedetto static int alg_test_kpp(const struct alg_test_desc *desc, const char *driver, 3890802c7f1cSSalvatore Benedetto u32 type, u32 mask) 3891802c7f1cSSalvatore Benedetto { 3892802c7f1cSSalvatore Benedetto struct crypto_kpp *tfm; 3893802c7f1cSSalvatore Benedetto int err = 0; 3894802c7f1cSSalvatore Benedetto 3895eed93e0cSHerbert Xu tfm = crypto_alloc_kpp(driver, type, mask); 3896802c7f1cSSalvatore Benedetto if (IS_ERR(tfm)) { 3897802c7f1cSSalvatore Benedetto pr_err("alg: kpp: Failed to load tfm for %s: %ld\n", 3898802c7f1cSSalvatore Benedetto driver, PTR_ERR(tfm)); 3899802c7f1cSSalvatore Benedetto return PTR_ERR(tfm); 3900802c7f1cSSalvatore Benedetto } 3901802c7f1cSSalvatore Benedetto if (desc->suite.kpp.vecs) 3902802c7f1cSSalvatore Benedetto err = test_kpp(tfm, desc->alg, desc->suite.kpp.vecs, 3903802c7f1cSSalvatore Benedetto desc->suite.kpp.count); 3904802c7f1cSSalvatore Benedetto 3905802c7f1cSSalvatore Benedetto crypto_free_kpp(tfm); 3906802c7f1cSSalvatore Benedetto return err; 3907802c7f1cSSalvatore Benedetto } 3908802c7f1cSSalvatore Benedetto 3909f1774cb8SVitaly Chikunov static u8 *test_pack_u32(u8 *dst, u32 val) 3910f1774cb8SVitaly Chikunov { 3911f1774cb8SVitaly Chikunov memcpy(dst, &val, sizeof(val)); 3912f1774cb8SVitaly Chikunov return dst + sizeof(val); 3913f1774cb8SVitaly Chikunov } 3914f1774cb8SVitaly Chikunov 391550d2b643SHerbert Xu static int test_akcipher_one(struct crypto_akcipher *tfm, 3916b13b1e0cSEric Biggers const struct akcipher_testvec *vecs) 3917946cc463STadeusz Struk { 3918df27b26fSHerbert Xu char *xbuf[XBUFSIZE]; 3919946cc463STadeusz Struk struct akcipher_request *req; 3920946cc463STadeusz Struk void *outbuf_enc = NULL; 3921946cc463STadeusz Struk void *outbuf_dec = NULL; 39227f397136SGilad Ben-Yossef struct crypto_wait wait; 3923946cc463STadeusz Struk unsigned int out_len_max, out_len = 0; 3924946cc463STadeusz Struk int err = -ENOMEM; 3925c7381b01SVitaly Chikunov struct scatterlist src, dst, src_tab[3]; 39260507de94SVitaly Chikunov const char *m, *c; 39270507de94SVitaly Chikunov unsigned int m_size, c_size; 39280507de94SVitaly Chikunov const char *op; 3929f1774cb8SVitaly Chikunov u8 *key, *ptr; 3930946cc463STadeusz Struk 3931df27b26fSHerbert Xu if (testmgr_alloc_buf(xbuf)) 3932df27b26fSHerbert Xu return err; 3933df27b26fSHerbert Xu 3934946cc463STadeusz Struk req = akcipher_request_alloc(tfm, GFP_KERNEL); 3935946cc463STadeusz Struk if (!req) 3936df27b26fSHerbert Xu goto free_xbuf; 3937946cc463STadeusz Struk 39387f397136SGilad Ben-Yossef crypto_init_wait(&wait); 393922287b0bSTadeusz Struk 3940f1774cb8SVitaly Chikunov key = kmalloc(vecs->key_len + sizeof(u32) * 2 + vecs->param_len, 3941f1774cb8SVitaly Chikunov GFP_KERNEL); 3942f1774cb8SVitaly Chikunov if (!key) 39432b403867STianjia Zhang goto free_req; 3944f1774cb8SVitaly Chikunov memcpy(key, vecs->key, vecs->key_len); 3945f1774cb8SVitaly Chikunov ptr = key + vecs->key_len; 3946f1774cb8SVitaly Chikunov ptr = test_pack_u32(ptr, vecs->algo); 3947f1774cb8SVitaly Chikunov ptr = test_pack_u32(ptr, vecs->param_len); 3948f1774cb8SVitaly Chikunov memcpy(ptr, vecs->params, vecs->param_len); 3949f1774cb8SVitaly Chikunov 395022287b0bSTadeusz Struk if (vecs->public_key_vec) 3951f1774cb8SVitaly Chikunov err = crypto_akcipher_set_pub_key(tfm, key, vecs->key_len); 395222287b0bSTadeusz Struk else 3953f1774cb8SVitaly Chikunov err = crypto_akcipher_set_priv_key(tfm, key, vecs->key_len); 3954946cc463STadeusz Struk if (err) 39552b403867STianjia Zhang goto free_key; 3956946cc463STadeusz Struk 39570507de94SVitaly Chikunov /* 39580507de94SVitaly Chikunov * First run test which do not require a private key, such as 39590507de94SVitaly Chikunov * encrypt or verify. 39600507de94SVitaly Chikunov */ 3961c7381b01SVitaly Chikunov err = -ENOMEM; 3962c7381b01SVitaly Chikunov out_len_max = crypto_akcipher_maxsize(tfm); 3963946cc463STadeusz Struk outbuf_enc = kzalloc(out_len_max, GFP_KERNEL); 3964946cc463STadeusz Struk if (!outbuf_enc) 39652b403867STianjia Zhang goto free_key; 3966946cc463STadeusz Struk 39670507de94SVitaly Chikunov if (!vecs->siggen_sigver_test) { 39680507de94SVitaly Chikunov m = vecs->m; 39690507de94SVitaly Chikunov m_size = vecs->m_size; 39700507de94SVitaly Chikunov c = vecs->c; 39710507de94SVitaly Chikunov c_size = vecs->c_size; 39720507de94SVitaly Chikunov op = "encrypt"; 39730507de94SVitaly Chikunov } else { 39740507de94SVitaly Chikunov /* Swap args so we could keep plaintext (digest) 39750507de94SVitaly Chikunov * in vecs->m, and cooked signature in vecs->c. 39760507de94SVitaly Chikunov */ 39770507de94SVitaly Chikunov m = vecs->c; /* signature */ 39780507de94SVitaly Chikunov m_size = vecs->c_size; 39790507de94SVitaly Chikunov c = vecs->m; /* digest */ 39800507de94SVitaly Chikunov c_size = vecs->m_size; 39810507de94SVitaly Chikunov op = "verify"; 39820507de94SVitaly Chikunov } 3983df27b26fSHerbert Xu 39842b403867STianjia Zhang err = -E2BIG; 39850507de94SVitaly Chikunov if (WARN_ON(m_size > PAGE_SIZE)) 39860507de94SVitaly Chikunov goto free_all; 39870507de94SVitaly Chikunov memcpy(xbuf[0], m, m_size); 3988df27b26fSHerbert Xu 3989c7381b01SVitaly Chikunov sg_init_table(src_tab, 3); 3990df27b26fSHerbert Xu sg_set_buf(&src_tab[0], xbuf[0], 8); 39910507de94SVitaly Chikunov sg_set_buf(&src_tab[1], xbuf[0] + 8, m_size - 8); 3992c7381b01SVitaly Chikunov if (vecs->siggen_sigver_test) { 3993c7381b01SVitaly Chikunov if (WARN_ON(c_size > PAGE_SIZE)) 3994c7381b01SVitaly Chikunov goto free_all; 3995c7381b01SVitaly Chikunov memcpy(xbuf[1], c, c_size); 3996c7381b01SVitaly Chikunov sg_set_buf(&src_tab[2], xbuf[1], c_size); 3997c7381b01SVitaly Chikunov akcipher_request_set_crypt(req, src_tab, NULL, m_size, c_size); 3998c7381b01SVitaly Chikunov } else { 399922287b0bSTadeusz Struk sg_init_one(&dst, outbuf_enc, out_len_max); 40000507de94SVitaly Chikunov akcipher_request_set_crypt(req, src_tab, &dst, m_size, 400122287b0bSTadeusz Struk out_len_max); 4002c7381b01SVitaly Chikunov } 4003946cc463STadeusz Struk akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 40047f397136SGilad Ben-Yossef crypto_req_done, &wait); 4005946cc463STadeusz Struk 40067f397136SGilad Ben-Yossef err = crypto_wait_req(vecs->siggen_sigver_test ? 40070507de94SVitaly Chikunov /* Run asymmetric signature verification */ 40080507de94SVitaly Chikunov crypto_akcipher_verify(req) : 40091207107cSStephan Mueller /* Run asymmetric encrypt */ 40107f397136SGilad Ben-Yossef crypto_akcipher_encrypt(req), &wait); 4011946cc463STadeusz Struk if (err) { 40120507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. err %d\n", op, err); 4013946cc463STadeusz Struk goto free_all; 4014946cc463STadeusz Struk } 4015a1f62c21STianjia Zhang if (!vecs->siggen_sigver_test && c) { 40160507de94SVitaly Chikunov if (req->dst_len != c_size) { 40170507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output len\n", 40180507de94SVitaly Chikunov op); 4019946cc463STadeusz Struk err = -EINVAL; 4020946cc463STadeusz Struk goto free_all; 4021946cc463STadeusz Struk } 4022946cc463STadeusz Struk /* verify that encrypted message is equal to expected */ 4023c7381b01SVitaly Chikunov if (memcmp(c, outbuf_enc, c_size) != 0) { 4024c7381b01SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output\n", 4025c7381b01SVitaly Chikunov op); 40260507de94SVitaly Chikunov hexdump(outbuf_enc, c_size); 4027946cc463STadeusz Struk err = -EINVAL; 4028946cc463STadeusz Struk goto free_all; 4029946cc463STadeusz Struk } 4030c7381b01SVitaly Chikunov } 40310507de94SVitaly Chikunov 40320507de94SVitaly Chikunov /* 40330507de94SVitaly Chikunov * Don't invoke (decrypt or sign) test which require a private key 40340507de94SVitaly Chikunov * for vectors with only a public key. 40350507de94SVitaly Chikunov */ 4036946cc463STadeusz Struk if (vecs->public_key_vec) { 4037946cc463STadeusz Struk err = 0; 4038946cc463STadeusz Struk goto free_all; 4039946cc463STadeusz Struk } 4040946cc463STadeusz Struk outbuf_dec = kzalloc(out_len_max, GFP_KERNEL); 4041946cc463STadeusz Struk if (!outbuf_dec) { 4042946cc463STadeusz Struk err = -ENOMEM; 4043946cc463STadeusz Struk goto free_all; 4044946cc463STadeusz Struk } 4045df27b26fSHerbert Xu 4046a1f62c21STianjia Zhang if (!vecs->siggen_sigver_test && !c) { 4047a1f62c21STianjia Zhang c = outbuf_enc; 4048a1f62c21STianjia Zhang c_size = req->dst_len; 4049a1f62c21STianjia Zhang } 4050a1f62c21STianjia Zhang 40512b403867STianjia Zhang err = -E2BIG; 40520507de94SVitaly Chikunov op = vecs->siggen_sigver_test ? "sign" : "decrypt"; 40530507de94SVitaly Chikunov if (WARN_ON(c_size > PAGE_SIZE)) 4054df27b26fSHerbert Xu goto free_all; 40550507de94SVitaly Chikunov memcpy(xbuf[0], c, c_size); 4056df27b26fSHerbert Xu 40570507de94SVitaly Chikunov sg_init_one(&src, xbuf[0], c_size); 405822287b0bSTadeusz Struk sg_init_one(&dst, outbuf_dec, out_len_max); 40597f397136SGilad Ben-Yossef crypto_init_wait(&wait); 40600507de94SVitaly Chikunov akcipher_request_set_crypt(req, &src, &dst, c_size, out_len_max); 4061946cc463STadeusz Struk 40627f397136SGilad Ben-Yossef err = crypto_wait_req(vecs->siggen_sigver_test ? 40630507de94SVitaly Chikunov /* Run asymmetric signature generation */ 40640507de94SVitaly Chikunov crypto_akcipher_sign(req) : 40651207107cSStephan Mueller /* Run asymmetric decrypt */ 40667f397136SGilad Ben-Yossef crypto_akcipher_decrypt(req), &wait); 4067946cc463STadeusz Struk if (err) { 40680507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. err %d\n", op, err); 4069946cc463STadeusz Struk goto free_all; 4070946cc463STadeusz Struk } 4071946cc463STadeusz Struk out_len = req->dst_len; 40720507de94SVitaly Chikunov if (out_len < m_size) { 40730507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output len %u\n", 40740507de94SVitaly Chikunov op, out_len); 4075946cc463STadeusz Struk err = -EINVAL; 4076946cc463STadeusz Struk goto free_all; 4077946cc463STadeusz Struk } 4078946cc463STadeusz Struk /* verify that decrypted message is equal to the original msg */ 40790507de94SVitaly Chikunov if (memchr_inv(outbuf_dec, 0, out_len - m_size) || 40800507de94SVitaly Chikunov memcmp(m, outbuf_dec + out_len - m_size, m_size)) { 40810507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output\n", op); 408250d2b643SHerbert Xu hexdump(outbuf_dec, out_len); 4083946cc463STadeusz Struk err = -EINVAL; 4084946cc463STadeusz Struk } 4085946cc463STadeusz Struk free_all: 4086946cc463STadeusz Struk kfree(outbuf_dec); 4087946cc463STadeusz Struk kfree(outbuf_enc); 40882b403867STianjia Zhang free_key: 40892b403867STianjia Zhang kfree(key); 4090946cc463STadeusz Struk free_req: 4091946cc463STadeusz Struk akcipher_request_free(req); 4092df27b26fSHerbert Xu free_xbuf: 4093df27b26fSHerbert Xu testmgr_free_buf(xbuf); 4094946cc463STadeusz Struk return err; 4095946cc463STadeusz Struk } 4096946cc463STadeusz Struk 409750d2b643SHerbert Xu static int test_akcipher(struct crypto_akcipher *tfm, const char *alg, 4098b13b1e0cSEric Biggers const struct akcipher_testvec *vecs, 4099b13b1e0cSEric Biggers unsigned int tcount) 4100946cc463STadeusz Struk { 410115226e48SHerbert Xu const char *algo = 410215226e48SHerbert Xu crypto_tfm_alg_driver_name(crypto_akcipher_tfm(tfm)); 4103946cc463STadeusz Struk int ret, i; 4104946cc463STadeusz Struk 4105946cc463STadeusz Struk for (i = 0; i < tcount; i++) { 410650d2b643SHerbert Xu ret = test_akcipher_one(tfm, vecs++); 410750d2b643SHerbert Xu if (!ret) 410850d2b643SHerbert Xu continue; 410950d2b643SHerbert Xu 411015226e48SHerbert Xu pr_err("alg: akcipher: test %d failed for %s, err=%d\n", 411115226e48SHerbert Xu i + 1, algo, ret); 4112946cc463STadeusz Struk return ret; 4113946cc463STadeusz Struk } 4114946cc463STadeusz Struk return 0; 4115946cc463STadeusz Struk } 4116946cc463STadeusz Struk 4117946cc463STadeusz Struk static int alg_test_akcipher(const struct alg_test_desc *desc, 4118946cc463STadeusz Struk const char *driver, u32 type, u32 mask) 4119946cc463STadeusz Struk { 4120946cc463STadeusz Struk struct crypto_akcipher *tfm; 4121946cc463STadeusz Struk int err = 0; 4122946cc463STadeusz Struk 4123eed93e0cSHerbert Xu tfm = crypto_alloc_akcipher(driver, type, mask); 4124946cc463STadeusz Struk if (IS_ERR(tfm)) { 4125946cc463STadeusz Struk pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n", 4126946cc463STadeusz Struk driver, PTR_ERR(tfm)); 4127946cc463STadeusz Struk return PTR_ERR(tfm); 4128946cc463STadeusz Struk } 4129946cc463STadeusz Struk if (desc->suite.akcipher.vecs) 4130946cc463STadeusz Struk err = test_akcipher(tfm, desc->alg, desc->suite.akcipher.vecs, 4131946cc463STadeusz Struk desc->suite.akcipher.count); 4132946cc463STadeusz Struk 4133946cc463STadeusz Struk crypto_free_akcipher(tfm); 4134946cc463STadeusz Struk return err; 4135946cc463STadeusz Struk } 4136946cc463STadeusz Struk 4137863b557aSYouquan, Song static int alg_test_null(const struct alg_test_desc *desc, 4138863b557aSYouquan, Song const char *driver, u32 type, u32 mask) 4139863b557aSYouquan, Song { 4140863b557aSYouquan, Song return 0; 4141863b557aSYouquan, Song } 4142863b557aSYouquan, Song 414349763fc6SEric Biggers #define ____VECS(tv) .vecs = tv, .count = ARRAY_SIZE(tv) 414449763fc6SEric Biggers #define __VECS(tv) { ____VECS(tv) } 414521c8e720SArd Biesheuvel 4146da7f033dSHerbert Xu /* Please keep this list sorted by algorithm name. */ 4147da7f033dSHerbert Xu static const struct alg_test_desc alg_test_descs[] = { 4148da7f033dSHerbert Xu { 4149059c2a4dSEric Biggers .alg = "adiantum(xchacha12,aes)", 4150d435e10eSEric Biggers .generic_driver = "adiantum(xchacha12-generic,aes-generic,nhpoly1305-generic)", 4151059c2a4dSEric Biggers .test = alg_test_skcipher, 4152059c2a4dSEric Biggers .suite = { 4153059c2a4dSEric Biggers .cipher = __VECS(adiantum_xchacha12_aes_tv_template) 4154059c2a4dSEric Biggers }, 4155059c2a4dSEric Biggers }, { 4156059c2a4dSEric Biggers .alg = "adiantum(xchacha20,aes)", 4157d435e10eSEric Biggers .generic_driver = "adiantum(xchacha20-generic,aes-generic,nhpoly1305-generic)", 4158059c2a4dSEric Biggers .test = alg_test_skcipher, 4159059c2a4dSEric Biggers .suite = { 4160059c2a4dSEric Biggers .cipher = __VECS(adiantum_xchacha20_aes_tv_template) 4161059c2a4dSEric Biggers }, 4162059c2a4dSEric Biggers }, { 4163b87dc203SOndrej Mosnacek .alg = "aegis128", 4164b87dc203SOndrej Mosnacek .test = alg_test_aead, 4165b87dc203SOndrej Mosnacek .suite = { 4166a0d608eeSEric Biggers .aead = __VECS(aegis128_tv_template) 4167b87dc203SOndrej Mosnacek } 4168b87dc203SOndrej Mosnacek }, { 4169e08ca2daSJarod Wilson .alg = "ansi_cprng", 4170e08ca2daSJarod Wilson .test = alg_test_cprng, 4171e08ca2daSJarod Wilson .suite = { 417221c8e720SArd Biesheuvel .cprng = __VECS(ansi_cprng_aes_tv_template) 4173e08ca2daSJarod Wilson } 4174e08ca2daSJarod Wilson }, { 4175bca4feb0SHoria Geanta .alg = "authenc(hmac(md5),ecb(cipher_null))", 4176bca4feb0SHoria Geanta .test = alg_test_aead, 4177bca4feb0SHoria Geanta .suite = { 4178a0d608eeSEric Biggers .aead = __VECS(hmac_md5_ecb_cipher_null_tv_template) 4179bca4feb0SHoria Geanta } 4180bca4feb0SHoria Geanta }, { 4181a4198fd4SHerbert Xu .alg = "authenc(hmac(sha1),cbc(aes))", 4182e46e9a46SHoria Geanta .test = alg_test_aead, 4183bcf741cbSHerbert Xu .fips_allowed = 1, 4184e46e9a46SHoria Geanta .suite = { 4185a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_aes_cbc_tv_temp) 41865208ed2cSNitesh Lal } 41875208ed2cSNitesh Lal }, { 4188a4198fd4SHerbert Xu .alg = "authenc(hmac(sha1),cbc(des))", 41895208ed2cSNitesh Lal .test = alg_test_aead, 41905208ed2cSNitesh Lal .suite = { 4191a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_des_cbc_tv_temp) 41925208ed2cSNitesh Lal } 41935208ed2cSNitesh Lal }, { 4194a4198fd4SHerbert Xu .alg = "authenc(hmac(sha1),cbc(des3_ede))", 41955208ed2cSNitesh Lal .test = alg_test_aead, 4196ed1afac9SMarcus Meissner .fips_allowed = 1, 41975208ed2cSNitesh Lal .suite = { 4198a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_des3_ede_cbc_tv_temp) 4199e46e9a46SHoria Geanta } 4200e46e9a46SHoria Geanta }, { 4201fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha1),ctr(aes))", 4202fb16abc2SMarcus Meissner .test = alg_test_null, 4203fb16abc2SMarcus Meissner .fips_allowed = 1, 4204fb16abc2SMarcus Meissner }, { 4205bca4feb0SHoria Geanta .alg = "authenc(hmac(sha1),ecb(cipher_null))", 4206bca4feb0SHoria Geanta .test = alg_test_aead, 4207bca4feb0SHoria Geanta .suite = { 4208a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_ecb_cipher_null_tv_temp) 42095208ed2cSNitesh Lal } 42105208ed2cSNitesh Lal }, { 42118888690eSMarcus Meissner .alg = "authenc(hmac(sha1),rfc3686(ctr(aes)))", 42128888690eSMarcus Meissner .test = alg_test_null, 42138888690eSMarcus Meissner .fips_allowed = 1, 42148888690eSMarcus Meissner }, { 4215a4198fd4SHerbert Xu .alg = "authenc(hmac(sha224),cbc(des))", 42165208ed2cSNitesh Lal .test = alg_test_aead, 42175208ed2cSNitesh Lal .suite = { 4218a0d608eeSEric Biggers .aead = __VECS(hmac_sha224_des_cbc_tv_temp) 42195208ed2cSNitesh Lal } 42205208ed2cSNitesh Lal }, { 4221a4198fd4SHerbert Xu .alg = "authenc(hmac(sha224),cbc(des3_ede))", 42225208ed2cSNitesh Lal .test = alg_test_aead, 4223ed1afac9SMarcus Meissner .fips_allowed = 1, 42245208ed2cSNitesh Lal .suite = { 4225a0d608eeSEric Biggers .aead = __VECS(hmac_sha224_des3_ede_cbc_tv_temp) 4226bca4feb0SHoria Geanta } 4227bca4feb0SHoria Geanta }, { 4228a4198fd4SHerbert Xu .alg = "authenc(hmac(sha256),cbc(aes))", 4229e46e9a46SHoria Geanta .test = alg_test_aead, 4230ed1afac9SMarcus Meissner .fips_allowed = 1, 4231e46e9a46SHoria Geanta .suite = { 4232a0d608eeSEric Biggers .aead = __VECS(hmac_sha256_aes_cbc_tv_temp) 42335208ed2cSNitesh Lal } 42345208ed2cSNitesh Lal }, { 4235a4198fd4SHerbert Xu .alg = "authenc(hmac(sha256),cbc(des))", 42365208ed2cSNitesh Lal .test = alg_test_aead, 42375208ed2cSNitesh Lal .suite = { 4238a0d608eeSEric Biggers .aead = __VECS(hmac_sha256_des_cbc_tv_temp) 42395208ed2cSNitesh Lal } 42405208ed2cSNitesh Lal }, { 4241a4198fd4SHerbert Xu .alg = "authenc(hmac(sha256),cbc(des3_ede))", 42425208ed2cSNitesh Lal .test = alg_test_aead, 4243ed1afac9SMarcus Meissner .fips_allowed = 1, 42445208ed2cSNitesh Lal .suite = { 4245a0d608eeSEric Biggers .aead = __VECS(hmac_sha256_des3_ede_cbc_tv_temp) 42465208ed2cSNitesh Lal } 42475208ed2cSNitesh Lal }, { 4248fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha256),ctr(aes))", 4249fb16abc2SMarcus Meissner .test = alg_test_null, 4250fb16abc2SMarcus Meissner .fips_allowed = 1, 4251fb16abc2SMarcus Meissner }, { 42528888690eSMarcus Meissner .alg = "authenc(hmac(sha256),rfc3686(ctr(aes)))", 42538888690eSMarcus Meissner .test = alg_test_null, 42548888690eSMarcus Meissner .fips_allowed = 1, 42558888690eSMarcus Meissner }, { 4256a4198fd4SHerbert Xu .alg = "authenc(hmac(sha384),cbc(des))", 42575208ed2cSNitesh Lal .test = alg_test_aead, 42585208ed2cSNitesh Lal .suite = { 4259a0d608eeSEric Biggers .aead = __VECS(hmac_sha384_des_cbc_tv_temp) 42605208ed2cSNitesh Lal } 42615208ed2cSNitesh Lal }, { 4262a4198fd4SHerbert Xu .alg = "authenc(hmac(sha384),cbc(des3_ede))", 42635208ed2cSNitesh Lal .test = alg_test_aead, 4264ed1afac9SMarcus Meissner .fips_allowed = 1, 42655208ed2cSNitesh Lal .suite = { 4266a0d608eeSEric Biggers .aead = __VECS(hmac_sha384_des3_ede_cbc_tv_temp) 4267e46e9a46SHoria Geanta } 4268e46e9a46SHoria Geanta }, { 4269fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha384),ctr(aes))", 4270fb16abc2SMarcus Meissner .test = alg_test_null, 4271fb16abc2SMarcus Meissner .fips_allowed = 1, 4272fb16abc2SMarcus Meissner }, { 42738888690eSMarcus Meissner .alg = "authenc(hmac(sha384),rfc3686(ctr(aes)))", 42748888690eSMarcus Meissner .test = alg_test_null, 42758888690eSMarcus Meissner .fips_allowed = 1, 42768888690eSMarcus Meissner }, { 4277a4198fd4SHerbert Xu .alg = "authenc(hmac(sha512),cbc(aes))", 4278ed1afac9SMarcus Meissner .fips_allowed = 1, 4279e46e9a46SHoria Geanta .test = alg_test_aead, 4280e46e9a46SHoria Geanta .suite = { 4281a0d608eeSEric Biggers .aead = __VECS(hmac_sha512_aes_cbc_tv_temp) 42825208ed2cSNitesh Lal } 42835208ed2cSNitesh Lal }, { 4284a4198fd4SHerbert Xu .alg = "authenc(hmac(sha512),cbc(des))", 42855208ed2cSNitesh Lal .test = alg_test_aead, 42865208ed2cSNitesh Lal .suite = { 4287a0d608eeSEric Biggers .aead = __VECS(hmac_sha512_des_cbc_tv_temp) 42885208ed2cSNitesh Lal } 42895208ed2cSNitesh Lal }, { 4290a4198fd4SHerbert Xu .alg = "authenc(hmac(sha512),cbc(des3_ede))", 42915208ed2cSNitesh Lal .test = alg_test_aead, 4292ed1afac9SMarcus Meissner .fips_allowed = 1, 42935208ed2cSNitesh Lal .suite = { 4294a0d608eeSEric Biggers .aead = __VECS(hmac_sha512_des3_ede_cbc_tv_temp) 4295e46e9a46SHoria Geanta } 4296e46e9a46SHoria Geanta }, { 4297fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha512),ctr(aes))", 4298fb16abc2SMarcus Meissner .test = alg_test_null, 4299fb16abc2SMarcus Meissner .fips_allowed = 1, 4300fb16abc2SMarcus Meissner }, { 43018888690eSMarcus Meissner .alg = "authenc(hmac(sha512),rfc3686(ctr(aes)))", 43028888690eSMarcus Meissner .test = alg_test_null, 43038888690eSMarcus Meissner .fips_allowed = 1, 43048888690eSMarcus Meissner }, { 4305a1afe274SDavid Sterba .alg = "blake2b-160", 4306a1afe274SDavid Sterba .test = alg_test_hash, 4307a1afe274SDavid Sterba .fips_allowed = 0, 4308a1afe274SDavid Sterba .suite = { 4309a1afe274SDavid Sterba .hash = __VECS(blake2b_160_tv_template) 4310a1afe274SDavid Sterba } 4311a1afe274SDavid Sterba }, { 4312a1afe274SDavid Sterba .alg = "blake2b-256", 4313a1afe274SDavid Sterba .test = alg_test_hash, 4314a1afe274SDavid Sterba .fips_allowed = 0, 4315a1afe274SDavid Sterba .suite = { 4316a1afe274SDavid Sterba .hash = __VECS(blake2b_256_tv_template) 4317a1afe274SDavid Sterba } 4318a1afe274SDavid Sterba }, { 4319a1afe274SDavid Sterba .alg = "blake2b-384", 4320a1afe274SDavid Sterba .test = alg_test_hash, 4321a1afe274SDavid Sterba .fips_allowed = 0, 4322a1afe274SDavid Sterba .suite = { 4323a1afe274SDavid Sterba .hash = __VECS(blake2b_384_tv_template) 4324a1afe274SDavid Sterba } 4325a1afe274SDavid Sterba }, { 4326a1afe274SDavid Sterba .alg = "blake2b-512", 4327a1afe274SDavid Sterba .test = alg_test_hash, 4328a1afe274SDavid Sterba .fips_allowed = 0, 4329a1afe274SDavid Sterba .suite = { 4330a1afe274SDavid Sterba .hash = __VECS(blake2b_512_tv_template) 4331a1afe274SDavid Sterba } 4332a1afe274SDavid Sterba }, { 433317e1df67SArd Biesheuvel .alg = "blake2s-128", 433417e1df67SArd Biesheuvel .test = alg_test_hash, 433517e1df67SArd Biesheuvel .suite = { 433617e1df67SArd Biesheuvel .hash = __VECS(blakes2s_128_tv_template) 433717e1df67SArd Biesheuvel } 433817e1df67SArd Biesheuvel }, { 433917e1df67SArd Biesheuvel .alg = "blake2s-160", 434017e1df67SArd Biesheuvel .test = alg_test_hash, 434117e1df67SArd Biesheuvel .suite = { 434217e1df67SArd Biesheuvel .hash = __VECS(blakes2s_160_tv_template) 434317e1df67SArd Biesheuvel } 434417e1df67SArd Biesheuvel }, { 434517e1df67SArd Biesheuvel .alg = "blake2s-224", 434617e1df67SArd Biesheuvel .test = alg_test_hash, 434717e1df67SArd Biesheuvel .suite = { 434817e1df67SArd Biesheuvel .hash = __VECS(blakes2s_224_tv_template) 434917e1df67SArd Biesheuvel } 435017e1df67SArd Biesheuvel }, { 435117e1df67SArd Biesheuvel .alg = "blake2s-256", 435217e1df67SArd Biesheuvel .test = alg_test_hash, 435317e1df67SArd Biesheuvel .suite = { 435417e1df67SArd Biesheuvel .hash = __VECS(blakes2s_256_tv_template) 435517e1df67SArd Biesheuvel } 435617e1df67SArd Biesheuvel }, { 4357da7f033dSHerbert Xu .alg = "cbc(aes)", 43581aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4359a1915d51SJarod Wilson .fips_allowed = 1, 4360da7f033dSHerbert Xu .suite = { 436192a4c9feSEric Biggers .cipher = __VECS(aes_cbc_tv_template) 436292a4c9feSEric Biggers }, 4363da7f033dSHerbert Xu }, { 4364da7f033dSHerbert Xu .alg = "cbc(anubis)", 43651aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4366da7f033dSHerbert Xu .suite = { 436792a4c9feSEric Biggers .cipher = __VECS(anubis_cbc_tv_template) 436892a4c9feSEric Biggers }, 4369da7f033dSHerbert Xu }, { 4370da7f033dSHerbert Xu .alg = "cbc(blowfish)", 43711aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4372da7f033dSHerbert Xu .suite = { 437392a4c9feSEric Biggers .cipher = __VECS(bf_cbc_tv_template) 437492a4c9feSEric Biggers }, 4375da7f033dSHerbert Xu }, { 4376da7f033dSHerbert Xu .alg = "cbc(camellia)", 43771aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4378da7f033dSHerbert Xu .suite = { 437992a4c9feSEric Biggers .cipher = __VECS(camellia_cbc_tv_template) 438092a4c9feSEric Biggers }, 4381da7f033dSHerbert Xu }, { 4382a2c58260SJohannes Goetzfried .alg = "cbc(cast5)", 4383a2c58260SJohannes Goetzfried .test = alg_test_skcipher, 4384a2c58260SJohannes Goetzfried .suite = { 438592a4c9feSEric Biggers .cipher = __VECS(cast5_cbc_tv_template) 438692a4c9feSEric Biggers }, 4387a2c58260SJohannes Goetzfried }, { 43889b8b0405SJohannes Goetzfried .alg = "cbc(cast6)", 43899b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 43909b8b0405SJohannes Goetzfried .suite = { 439192a4c9feSEric Biggers .cipher = __VECS(cast6_cbc_tv_template) 439292a4c9feSEric Biggers }, 43939b8b0405SJohannes Goetzfried }, { 4394da7f033dSHerbert Xu .alg = "cbc(des)", 43951aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4396da7f033dSHerbert Xu .suite = { 439792a4c9feSEric Biggers .cipher = __VECS(des_cbc_tv_template) 439892a4c9feSEric Biggers }, 4399da7f033dSHerbert Xu }, { 4400da7f033dSHerbert Xu .alg = "cbc(des3_ede)", 44011aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4402a1915d51SJarod Wilson .fips_allowed = 1, 4403da7f033dSHerbert Xu .suite = { 440492a4c9feSEric Biggers .cipher = __VECS(des3_ede_cbc_tv_template) 440592a4c9feSEric Biggers }, 4406da7f033dSHerbert Xu }, { 4407a794d8d8SGilad Ben-Yossef /* Same as cbc(aes) except the key is stored in 4408a794d8d8SGilad Ben-Yossef * hardware secure memory which we reference by index 4409a794d8d8SGilad Ben-Yossef */ 4410a794d8d8SGilad Ben-Yossef .alg = "cbc(paes)", 4411a794d8d8SGilad Ben-Yossef .test = alg_test_null, 4412a794d8d8SGilad Ben-Yossef .fips_allowed = 1, 4413a794d8d8SGilad Ben-Yossef }, { 4414f0372c00SGilad Ben-Yossef /* Same as cbc(sm4) except the key is stored in 4415f0372c00SGilad Ben-Yossef * hardware secure memory which we reference by index 4416f0372c00SGilad Ben-Yossef */ 4417f0372c00SGilad Ben-Yossef .alg = "cbc(psm4)", 4418f0372c00SGilad Ben-Yossef .test = alg_test_null, 4419f0372c00SGilad Ben-Yossef }, { 44209d25917dSJussi Kivilinna .alg = "cbc(serpent)", 44219d25917dSJussi Kivilinna .test = alg_test_skcipher, 44229d25917dSJussi Kivilinna .suite = { 442392a4c9feSEric Biggers .cipher = __VECS(serpent_cbc_tv_template) 442492a4c9feSEric Biggers }, 44259d25917dSJussi Kivilinna }, { 442695ba5973SGilad Ben-Yossef .alg = "cbc(sm4)", 442795ba5973SGilad Ben-Yossef .test = alg_test_skcipher, 442895ba5973SGilad Ben-Yossef .suite = { 442995ba5973SGilad Ben-Yossef .cipher = __VECS(sm4_cbc_tv_template) 443095ba5973SGilad Ben-Yossef } 443195ba5973SGilad Ben-Yossef }, { 4432da7f033dSHerbert Xu .alg = "cbc(twofish)", 44331aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4434da7f033dSHerbert Xu .suite = { 443592a4c9feSEric Biggers .cipher = __VECS(tf_cbc_tv_template) 443692a4c9feSEric Biggers }, 4437da7f033dSHerbert Xu }, { 4438c7ff8573SHarald Freudenberger #if IS_ENABLED(CONFIG_CRYPTO_PAES_S390) 4439c7ff8573SHarald Freudenberger .alg = "cbc-paes-s390", 4440c7ff8573SHarald Freudenberger .fips_allowed = 1, 4441c7ff8573SHarald Freudenberger .test = alg_test_skcipher, 4442c7ff8573SHarald Freudenberger .suite = { 4443c7ff8573SHarald Freudenberger .cipher = __VECS(aes_cbc_tv_template) 4444c7ff8573SHarald Freudenberger } 4445c7ff8573SHarald Freudenberger }, { 4446c7ff8573SHarald Freudenberger #endif 4447092acf06SArd Biesheuvel .alg = "cbcmac(aes)", 4448092acf06SArd Biesheuvel .fips_allowed = 1, 4449092acf06SArd Biesheuvel .test = alg_test_hash, 4450092acf06SArd Biesheuvel .suite = { 4451092acf06SArd Biesheuvel .hash = __VECS(aes_cbcmac_tv_template) 4452092acf06SArd Biesheuvel } 4453092acf06SArd Biesheuvel }, { 4454*68039d60STianjia Zhang .alg = "cbcmac(sm4)", 4455*68039d60STianjia Zhang .test = alg_test_hash, 4456*68039d60STianjia Zhang .suite = { 4457*68039d60STianjia Zhang .hash = __VECS(sm4_cbcmac_tv_template) 4458*68039d60STianjia Zhang } 4459*68039d60STianjia Zhang }, { 4460da7f033dSHerbert Xu .alg = "ccm(aes)", 446140153b10SEric Biggers .generic_driver = "ccm_base(ctr(aes-generic),cbcmac(aes-generic))", 4462da7f033dSHerbert Xu .test = alg_test_aead, 4463a1915d51SJarod Wilson .fips_allowed = 1, 4464da7f033dSHerbert Xu .suite = { 446549763fc6SEric Biggers .aead = { 446649763fc6SEric Biggers ____VECS(aes_ccm_tv_template), 446749763fc6SEric Biggers .einval_allowed = 1, 446849763fc6SEric Biggers } 4469da7f033dSHerbert Xu } 4470da7f033dSHerbert Xu }, { 4471*68039d60STianjia Zhang .alg = "ccm(sm4)", 4472*68039d60STianjia Zhang .generic_driver = "ccm_base(ctr(sm4-generic),cbcmac(sm4-generic))", 4473*68039d60STianjia Zhang .test = alg_test_aead, 4474*68039d60STianjia Zhang .suite = { 4475*68039d60STianjia Zhang .aead = { 4476*68039d60STianjia Zhang ____VECS(sm4_ccm_tv_template), 4477*68039d60STianjia Zhang .einval_allowed = 1, 4478*68039d60STianjia Zhang } 4479*68039d60STianjia Zhang } 4480*68039d60STianjia Zhang }, { 44817da66670SDmitry Eremin-Solenikov .alg = "cfb(aes)", 44827da66670SDmitry Eremin-Solenikov .test = alg_test_skcipher, 44837da66670SDmitry Eremin-Solenikov .fips_allowed = 1, 44847da66670SDmitry Eremin-Solenikov .suite = { 44857da66670SDmitry Eremin-Solenikov .cipher = __VECS(aes_cfb_tv_template) 44867da66670SDmitry Eremin-Solenikov }, 44877da66670SDmitry Eremin-Solenikov }, { 4488a06b15b2SPascal van Leeuwen .alg = "cfb(sm4)", 4489a06b15b2SPascal van Leeuwen .test = alg_test_skcipher, 4490a06b15b2SPascal van Leeuwen .suite = { 4491a06b15b2SPascal van Leeuwen .cipher = __VECS(sm4_cfb_tv_template) 4492a06b15b2SPascal van Leeuwen } 4493a06b15b2SPascal van Leeuwen }, { 44943590ebf2SMartin Willi .alg = "chacha20", 44953590ebf2SMartin Willi .test = alg_test_skcipher, 44963590ebf2SMartin Willi .suite = { 449792a4c9feSEric Biggers .cipher = __VECS(chacha20_tv_template) 449892a4c9feSEric Biggers }, 44993590ebf2SMartin Willi }, { 450093b5e86aSJussi Kivilinna .alg = "cmac(aes)", 45018f183751SStephan Mueller .fips_allowed = 1, 450293b5e86aSJussi Kivilinna .test = alg_test_hash, 450393b5e86aSJussi Kivilinna .suite = { 450421c8e720SArd Biesheuvel .hash = __VECS(aes_cmac128_tv_template) 450593b5e86aSJussi Kivilinna } 450693b5e86aSJussi Kivilinna }, { 450793b5e86aSJussi Kivilinna .alg = "cmac(des3_ede)", 45088f183751SStephan Mueller .fips_allowed = 1, 450993b5e86aSJussi Kivilinna .test = alg_test_hash, 451093b5e86aSJussi Kivilinna .suite = { 451121c8e720SArd Biesheuvel .hash = __VECS(des3_ede_cmac64_tv_template) 451293b5e86aSJussi Kivilinna } 451393b5e86aSJussi Kivilinna }, { 4514*68039d60STianjia Zhang .alg = "cmac(sm4)", 4515*68039d60STianjia Zhang .test = alg_test_hash, 4516*68039d60STianjia Zhang .suite = { 4517*68039d60STianjia Zhang .hash = __VECS(sm4_cmac128_tv_template) 4518*68039d60STianjia Zhang } 4519*68039d60STianjia Zhang }, { 4520e448370dSJussi Kivilinna .alg = "compress_null", 4521e448370dSJussi Kivilinna .test = alg_test_null, 4522e448370dSJussi Kivilinna }, { 4523ebb3472fSArd Biesheuvel .alg = "crc32", 4524ebb3472fSArd Biesheuvel .test = alg_test_hash, 4525a8a34416SMilan Broz .fips_allowed = 1, 4526ebb3472fSArd Biesheuvel .suite = { 452721c8e720SArd Biesheuvel .hash = __VECS(crc32_tv_template) 4528ebb3472fSArd Biesheuvel } 4529ebb3472fSArd Biesheuvel }, { 4530da7f033dSHerbert Xu .alg = "crc32c", 45318e3ee85eSHerbert Xu .test = alg_test_crc32c, 4532a1915d51SJarod Wilson .fips_allowed = 1, 4533da7f033dSHerbert Xu .suite = { 453421c8e720SArd Biesheuvel .hash = __VECS(crc32c_tv_template) 4535da7f033dSHerbert Xu } 4536da7f033dSHerbert Xu }, { 453768411521SHerbert Xu .alg = "crct10dif", 453868411521SHerbert Xu .test = alg_test_hash, 453968411521SHerbert Xu .fips_allowed = 1, 454068411521SHerbert Xu .suite = { 454121c8e720SArd Biesheuvel .hash = __VECS(crct10dif_tv_template) 454268411521SHerbert Xu } 454368411521SHerbert Xu }, { 4544f7cb80f2SJarod Wilson .alg = "ctr(aes)", 4545f7cb80f2SJarod Wilson .test = alg_test_skcipher, 4546a1915d51SJarod Wilson .fips_allowed = 1, 4547f7cb80f2SJarod Wilson .suite = { 454892a4c9feSEric Biggers .cipher = __VECS(aes_ctr_tv_template) 4549f7cb80f2SJarod Wilson } 4550f7cb80f2SJarod Wilson }, { 455185b63e34SJussi Kivilinna .alg = "ctr(blowfish)", 455285b63e34SJussi Kivilinna .test = alg_test_skcipher, 455385b63e34SJussi Kivilinna .suite = { 455492a4c9feSEric Biggers .cipher = __VECS(bf_ctr_tv_template) 455585b63e34SJussi Kivilinna } 455685b63e34SJussi Kivilinna }, { 45570840605eSJussi Kivilinna .alg = "ctr(camellia)", 45580840605eSJussi Kivilinna .test = alg_test_skcipher, 45590840605eSJussi Kivilinna .suite = { 456092a4c9feSEric Biggers .cipher = __VECS(camellia_ctr_tv_template) 45610840605eSJussi Kivilinna } 45620840605eSJussi Kivilinna }, { 4563a2c58260SJohannes Goetzfried .alg = "ctr(cast5)", 4564a2c58260SJohannes Goetzfried .test = alg_test_skcipher, 4565a2c58260SJohannes Goetzfried .suite = { 456692a4c9feSEric Biggers .cipher = __VECS(cast5_ctr_tv_template) 4567a2c58260SJohannes Goetzfried } 4568a2c58260SJohannes Goetzfried }, { 45699b8b0405SJohannes Goetzfried .alg = "ctr(cast6)", 45709b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 45719b8b0405SJohannes Goetzfried .suite = { 457292a4c9feSEric Biggers .cipher = __VECS(cast6_ctr_tv_template) 45739b8b0405SJohannes Goetzfried } 45749b8b0405SJohannes Goetzfried }, { 45758163fc30SJussi Kivilinna .alg = "ctr(des)", 45768163fc30SJussi Kivilinna .test = alg_test_skcipher, 45778163fc30SJussi Kivilinna .suite = { 457892a4c9feSEric Biggers .cipher = __VECS(des_ctr_tv_template) 45798163fc30SJussi Kivilinna } 45808163fc30SJussi Kivilinna }, { 4581e080b17aSJussi Kivilinna .alg = "ctr(des3_ede)", 4582e080b17aSJussi Kivilinna .test = alg_test_skcipher, 45830d8da104SMarcelo Cerri .fips_allowed = 1, 4584e080b17aSJussi Kivilinna .suite = { 458592a4c9feSEric Biggers .cipher = __VECS(des3_ede_ctr_tv_template) 4586e080b17aSJussi Kivilinna } 4587e080b17aSJussi Kivilinna }, { 4588a794d8d8SGilad Ben-Yossef /* Same as ctr(aes) except the key is stored in 4589a794d8d8SGilad Ben-Yossef * hardware secure memory which we reference by index 4590a794d8d8SGilad Ben-Yossef */ 4591a794d8d8SGilad Ben-Yossef .alg = "ctr(paes)", 4592a794d8d8SGilad Ben-Yossef .test = alg_test_null, 4593a794d8d8SGilad Ben-Yossef .fips_allowed = 1, 4594a794d8d8SGilad Ben-Yossef }, { 4595f0372c00SGilad Ben-Yossef 4596f0372c00SGilad Ben-Yossef /* Same as ctr(sm4) except the key is stored in 4597f0372c00SGilad Ben-Yossef * hardware secure memory which we reference by index 4598f0372c00SGilad Ben-Yossef */ 4599f0372c00SGilad Ben-Yossef .alg = "ctr(psm4)", 4600f0372c00SGilad Ben-Yossef .test = alg_test_null, 4601f0372c00SGilad Ben-Yossef }, { 46029d25917dSJussi Kivilinna .alg = "ctr(serpent)", 46039d25917dSJussi Kivilinna .test = alg_test_skcipher, 46049d25917dSJussi Kivilinna .suite = { 460592a4c9feSEric Biggers .cipher = __VECS(serpent_ctr_tv_template) 46069d25917dSJussi Kivilinna } 46079d25917dSJussi Kivilinna }, { 460895ba5973SGilad Ben-Yossef .alg = "ctr(sm4)", 460995ba5973SGilad Ben-Yossef .test = alg_test_skcipher, 461095ba5973SGilad Ben-Yossef .suite = { 461195ba5973SGilad Ben-Yossef .cipher = __VECS(sm4_ctr_tv_template) 461295ba5973SGilad Ben-Yossef } 461395ba5973SGilad Ben-Yossef }, { 4614573da620SJussi Kivilinna .alg = "ctr(twofish)", 4615573da620SJussi Kivilinna .test = alg_test_skcipher, 4616573da620SJussi Kivilinna .suite = { 461792a4c9feSEric Biggers .cipher = __VECS(tf_ctr_tv_template) 4618573da620SJussi Kivilinna } 4619573da620SJussi Kivilinna }, { 4620c7ff8573SHarald Freudenberger #if IS_ENABLED(CONFIG_CRYPTO_PAES_S390) 4621c7ff8573SHarald Freudenberger .alg = "ctr-paes-s390", 4622c7ff8573SHarald Freudenberger .fips_allowed = 1, 4623c7ff8573SHarald Freudenberger .test = alg_test_skcipher, 4624c7ff8573SHarald Freudenberger .suite = { 4625c7ff8573SHarald Freudenberger .cipher = __VECS(aes_ctr_tv_template) 4626c7ff8573SHarald Freudenberger } 4627c7ff8573SHarald Freudenberger }, { 4628c7ff8573SHarald Freudenberger #endif 4629da7f033dSHerbert Xu .alg = "cts(cbc(aes))", 46301aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4631196ad604SGilad Ben-Yossef .fips_allowed = 1, 4632da7f033dSHerbert Xu .suite = { 463392a4c9feSEric Biggers .cipher = __VECS(cts_mode_tv_template) 4634da7f033dSHerbert Xu } 4635da7f033dSHerbert Xu }, { 4636f0372c00SGilad Ben-Yossef /* Same as cts(cbc((aes)) except the key is stored in 4637f0372c00SGilad Ben-Yossef * hardware secure memory which we reference by index 4638f0372c00SGilad Ben-Yossef */ 4639f0372c00SGilad Ben-Yossef .alg = "cts(cbc(paes))", 4640f0372c00SGilad Ben-Yossef .test = alg_test_null, 4641f0372c00SGilad Ben-Yossef .fips_allowed = 1, 4642f0372c00SGilad Ben-Yossef }, { 4643f613457aSArd Biesheuvel .alg = "curve25519", 4644f613457aSArd Biesheuvel .test = alg_test_kpp, 4645f613457aSArd Biesheuvel .suite = { 4646f613457aSArd Biesheuvel .kpp = __VECS(curve25519_tv_template) 4647f613457aSArd Biesheuvel } 4648f613457aSArd Biesheuvel }, { 4649da7f033dSHerbert Xu .alg = "deflate", 4650da7f033dSHerbert Xu .test = alg_test_comp, 46510818904dSMilan Broz .fips_allowed = 1, 4652da7f033dSHerbert Xu .suite = { 4653da7f033dSHerbert Xu .comp = { 465421c8e720SArd Biesheuvel .comp = __VECS(deflate_comp_tv_template), 465521c8e720SArd Biesheuvel .decomp = __VECS(deflate_decomp_tv_template) 4656da7f033dSHerbert Xu } 4657da7f033dSHerbert Xu } 4658da7f033dSHerbert Xu }, { 4659802c7f1cSSalvatore Benedetto .alg = "dh", 4660802c7f1cSSalvatore Benedetto .test = alg_test_kpp, 4661802c7f1cSSalvatore Benedetto .fips_allowed = 1, 4662802c7f1cSSalvatore Benedetto .suite = { 466321c8e720SArd Biesheuvel .kpp = __VECS(dh_tv_template) 4664802c7f1cSSalvatore Benedetto } 4665802c7f1cSSalvatore Benedetto }, { 4666e448370dSJussi Kivilinna .alg = "digest_null", 4667e448370dSJussi Kivilinna .test = alg_test_null, 4668e448370dSJussi Kivilinna }, { 466964d1cdfbSStephan Mueller .alg = "drbg_nopr_ctr_aes128", 467064d1cdfbSStephan Mueller .test = alg_test_drbg, 467164d1cdfbSStephan Mueller .fips_allowed = 1, 467264d1cdfbSStephan Mueller .suite = { 467321c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_ctr_aes128_tv_template) 467464d1cdfbSStephan Mueller } 467564d1cdfbSStephan Mueller }, { 467664d1cdfbSStephan Mueller .alg = "drbg_nopr_ctr_aes192", 467764d1cdfbSStephan Mueller .test = alg_test_drbg, 467864d1cdfbSStephan Mueller .fips_allowed = 1, 467964d1cdfbSStephan Mueller .suite = { 468021c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_ctr_aes192_tv_template) 468164d1cdfbSStephan Mueller } 468264d1cdfbSStephan Mueller }, { 468364d1cdfbSStephan Mueller .alg = "drbg_nopr_ctr_aes256", 468464d1cdfbSStephan Mueller .test = alg_test_drbg, 468564d1cdfbSStephan Mueller .fips_allowed = 1, 468664d1cdfbSStephan Mueller .suite = { 468721c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_ctr_aes256_tv_template) 468864d1cdfbSStephan Mueller } 468964d1cdfbSStephan Mueller }, { 469064d1cdfbSStephan Mueller /* 469164d1cdfbSStephan Mueller * There is no need to specifically test the DRBG with every 469264d1cdfbSStephan Mueller * backend cipher -- covered by drbg_nopr_hmac_sha256 test 469364d1cdfbSStephan Mueller */ 469464d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha1", 469564d1cdfbSStephan Mueller .fips_allowed = 1, 469664d1cdfbSStephan Mueller .test = alg_test_null, 469764d1cdfbSStephan Mueller }, { 469864d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha256", 469964d1cdfbSStephan Mueller .test = alg_test_drbg, 470064d1cdfbSStephan Mueller .fips_allowed = 1, 470164d1cdfbSStephan Mueller .suite = { 470221c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_hmac_sha256_tv_template) 470364d1cdfbSStephan Mueller } 470464d1cdfbSStephan Mueller }, { 470564d1cdfbSStephan Mueller /* covered by drbg_nopr_hmac_sha256 test */ 470664d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha384", 470764d1cdfbSStephan Mueller .fips_allowed = 1, 470864d1cdfbSStephan Mueller .test = alg_test_null, 470964d1cdfbSStephan Mueller }, { 471064d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha512", 47118833272dSStephan Müller .test = alg_test_drbg, 471264d1cdfbSStephan Mueller .fips_allowed = 1, 47138833272dSStephan Müller .suite = { 47148833272dSStephan Müller .drbg = __VECS(drbg_nopr_hmac_sha512_tv_template) 47158833272dSStephan Müller } 471664d1cdfbSStephan Mueller }, { 471764d1cdfbSStephan Mueller .alg = "drbg_nopr_sha1", 471864d1cdfbSStephan Mueller .fips_allowed = 1, 471964d1cdfbSStephan Mueller .test = alg_test_null, 472064d1cdfbSStephan Mueller }, { 472164d1cdfbSStephan Mueller .alg = "drbg_nopr_sha256", 472264d1cdfbSStephan Mueller .test = alg_test_drbg, 472364d1cdfbSStephan Mueller .fips_allowed = 1, 472464d1cdfbSStephan Mueller .suite = { 472521c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_sha256_tv_template) 472664d1cdfbSStephan Mueller } 472764d1cdfbSStephan Mueller }, { 472864d1cdfbSStephan Mueller /* covered by drbg_nopr_sha256 test */ 472964d1cdfbSStephan Mueller .alg = "drbg_nopr_sha384", 473064d1cdfbSStephan Mueller .fips_allowed = 1, 473164d1cdfbSStephan Mueller .test = alg_test_null, 473264d1cdfbSStephan Mueller }, { 473364d1cdfbSStephan Mueller .alg = "drbg_nopr_sha512", 473464d1cdfbSStephan Mueller .fips_allowed = 1, 473564d1cdfbSStephan Mueller .test = alg_test_null, 473664d1cdfbSStephan Mueller }, { 473764d1cdfbSStephan Mueller .alg = "drbg_pr_ctr_aes128", 473864d1cdfbSStephan Mueller .test = alg_test_drbg, 473964d1cdfbSStephan Mueller .fips_allowed = 1, 474064d1cdfbSStephan Mueller .suite = { 474121c8e720SArd Biesheuvel .drbg = __VECS(drbg_pr_ctr_aes128_tv_template) 474264d1cdfbSStephan Mueller } 474364d1cdfbSStephan Mueller }, { 474464d1cdfbSStephan Mueller /* covered by drbg_pr_ctr_aes128 test */ 474564d1cdfbSStephan Mueller .alg = "drbg_pr_ctr_aes192", 474664d1cdfbSStephan Mueller .fips_allowed = 1, 474764d1cdfbSStephan Mueller .test = alg_test_null, 474864d1cdfbSStephan Mueller }, { 474964d1cdfbSStephan Mueller .alg = "drbg_pr_ctr_aes256", 475064d1cdfbSStephan Mueller .fips_allowed = 1, 475164d1cdfbSStephan Mueller .test = alg_test_null, 475264d1cdfbSStephan Mueller }, { 475364d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha1", 475464d1cdfbSStephan Mueller .fips_allowed = 1, 475564d1cdfbSStephan Mueller .test = alg_test_null, 475664d1cdfbSStephan Mueller }, { 475764d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha256", 475864d1cdfbSStephan Mueller .test = alg_test_drbg, 475964d1cdfbSStephan Mueller .fips_allowed = 1, 476064d1cdfbSStephan Mueller .suite = { 476121c8e720SArd Biesheuvel .drbg = __VECS(drbg_pr_hmac_sha256_tv_template) 476264d1cdfbSStephan Mueller } 476364d1cdfbSStephan Mueller }, { 476464d1cdfbSStephan Mueller /* covered by drbg_pr_hmac_sha256 test */ 476564d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha384", 476664d1cdfbSStephan Mueller .fips_allowed = 1, 476764d1cdfbSStephan Mueller .test = alg_test_null, 476864d1cdfbSStephan Mueller }, { 476964d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha512", 477064d1cdfbSStephan Mueller .test = alg_test_null, 477164d1cdfbSStephan Mueller .fips_allowed = 1, 477264d1cdfbSStephan Mueller }, { 477364d1cdfbSStephan Mueller .alg = "drbg_pr_sha1", 477464d1cdfbSStephan Mueller .fips_allowed = 1, 477564d1cdfbSStephan Mueller .test = alg_test_null, 477664d1cdfbSStephan Mueller }, { 477764d1cdfbSStephan Mueller .alg = "drbg_pr_sha256", 477864d1cdfbSStephan Mueller .test = alg_test_drbg, 477964d1cdfbSStephan Mueller .fips_allowed = 1, 478064d1cdfbSStephan Mueller .suite = { 478121c8e720SArd Biesheuvel .drbg = __VECS(drbg_pr_sha256_tv_template) 478264d1cdfbSStephan Mueller } 478364d1cdfbSStephan Mueller }, { 478464d1cdfbSStephan Mueller /* covered by drbg_pr_sha256 test */ 478564d1cdfbSStephan Mueller .alg = "drbg_pr_sha384", 478664d1cdfbSStephan Mueller .fips_allowed = 1, 478764d1cdfbSStephan Mueller .test = alg_test_null, 478864d1cdfbSStephan Mueller }, { 478964d1cdfbSStephan Mueller .alg = "drbg_pr_sha512", 479064d1cdfbSStephan Mueller .fips_allowed = 1, 479164d1cdfbSStephan Mueller .test = alg_test_null, 479264d1cdfbSStephan Mueller }, { 4793da7f033dSHerbert Xu .alg = "ecb(aes)", 47941aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4795a1915d51SJarod Wilson .fips_allowed = 1, 4796da7f033dSHerbert Xu .suite = { 479792a4c9feSEric Biggers .cipher = __VECS(aes_tv_template) 4798da7f033dSHerbert Xu } 4799da7f033dSHerbert Xu }, { 4800da7f033dSHerbert Xu .alg = "ecb(anubis)", 48011aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4802da7f033dSHerbert Xu .suite = { 480392a4c9feSEric Biggers .cipher = __VECS(anubis_tv_template) 4804da7f033dSHerbert Xu } 4805da7f033dSHerbert Xu }, { 4806da7f033dSHerbert Xu .alg = "ecb(arc4)", 4807611a23c2SArd Biesheuvel .generic_driver = "ecb(arc4)-generic", 48081aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4809da7f033dSHerbert Xu .suite = { 481092a4c9feSEric Biggers .cipher = __VECS(arc4_tv_template) 4811da7f033dSHerbert Xu } 4812da7f033dSHerbert Xu }, { 4813da7f033dSHerbert Xu .alg = "ecb(blowfish)", 48141aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4815da7f033dSHerbert Xu .suite = { 481692a4c9feSEric Biggers .cipher = __VECS(bf_tv_template) 4817da7f033dSHerbert Xu } 4818da7f033dSHerbert Xu }, { 4819da7f033dSHerbert Xu .alg = "ecb(camellia)", 48201aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4821da7f033dSHerbert Xu .suite = { 482292a4c9feSEric Biggers .cipher = __VECS(camellia_tv_template) 4823da7f033dSHerbert Xu } 4824da7f033dSHerbert Xu }, { 4825da7f033dSHerbert Xu .alg = "ecb(cast5)", 48261aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4827da7f033dSHerbert Xu .suite = { 482892a4c9feSEric Biggers .cipher = __VECS(cast5_tv_template) 4829da7f033dSHerbert Xu } 4830da7f033dSHerbert Xu }, { 4831da7f033dSHerbert Xu .alg = "ecb(cast6)", 48321aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4833da7f033dSHerbert Xu .suite = { 483492a4c9feSEric Biggers .cipher = __VECS(cast6_tv_template) 4835da7f033dSHerbert Xu } 4836da7f033dSHerbert Xu }, { 4837e448370dSJussi Kivilinna .alg = "ecb(cipher_null)", 4838e448370dSJussi Kivilinna .test = alg_test_null, 48396175ca2bSMilan Broz .fips_allowed = 1, 4840e448370dSJussi Kivilinna }, { 4841da7f033dSHerbert Xu .alg = "ecb(des)", 48421aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4843da7f033dSHerbert Xu .suite = { 484492a4c9feSEric Biggers .cipher = __VECS(des_tv_template) 4845da7f033dSHerbert Xu } 4846da7f033dSHerbert Xu }, { 4847da7f033dSHerbert Xu .alg = "ecb(des3_ede)", 48481aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4849a1915d51SJarod Wilson .fips_allowed = 1, 4850da7f033dSHerbert Xu .suite = { 485192a4c9feSEric Biggers .cipher = __VECS(des3_ede_tv_template) 4852da7f033dSHerbert Xu } 4853da7f033dSHerbert Xu }, { 485466e5bd00SJussi Kivilinna .alg = "ecb(fcrypt)", 485566e5bd00SJussi Kivilinna .test = alg_test_skcipher, 485666e5bd00SJussi Kivilinna .suite = { 485766e5bd00SJussi Kivilinna .cipher = { 485892a4c9feSEric Biggers .vecs = fcrypt_pcbc_tv_template, 485966e5bd00SJussi Kivilinna .count = 1 486066e5bd00SJussi Kivilinna } 486166e5bd00SJussi Kivilinna } 486266e5bd00SJussi Kivilinna }, { 4863da7f033dSHerbert Xu .alg = "ecb(khazad)", 48641aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4865da7f033dSHerbert Xu .suite = { 486692a4c9feSEric Biggers .cipher = __VECS(khazad_tv_template) 4867da7f033dSHerbert Xu } 4868da7f033dSHerbert Xu }, { 486915f47ce5SGilad Ben-Yossef /* Same as ecb(aes) except the key is stored in 487015f47ce5SGilad Ben-Yossef * hardware secure memory which we reference by index 487115f47ce5SGilad Ben-Yossef */ 487215f47ce5SGilad Ben-Yossef .alg = "ecb(paes)", 487315f47ce5SGilad Ben-Yossef .test = alg_test_null, 487415f47ce5SGilad Ben-Yossef .fips_allowed = 1, 487515f47ce5SGilad Ben-Yossef }, { 4876da7f033dSHerbert Xu .alg = "ecb(seed)", 48771aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4878da7f033dSHerbert Xu .suite = { 487992a4c9feSEric Biggers .cipher = __VECS(seed_tv_template) 4880da7f033dSHerbert Xu } 4881da7f033dSHerbert Xu }, { 4882da7f033dSHerbert Xu .alg = "ecb(serpent)", 48831aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4884da7f033dSHerbert Xu .suite = { 488592a4c9feSEric Biggers .cipher = __VECS(serpent_tv_template) 4886da7f033dSHerbert Xu } 4887da7f033dSHerbert Xu }, { 4888cd83a8a7SGilad Ben-Yossef .alg = "ecb(sm4)", 4889cd83a8a7SGilad Ben-Yossef .test = alg_test_skcipher, 4890cd83a8a7SGilad Ben-Yossef .suite = { 489192a4c9feSEric Biggers .cipher = __VECS(sm4_tv_template) 4892cd83a8a7SGilad Ben-Yossef } 4893cd83a8a7SGilad Ben-Yossef }, { 4894da7f033dSHerbert Xu .alg = "ecb(tea)", 48951aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4896da7f033dSHerbert Xu .suite = { 489792a4c9feSEric Biggers .cipher = __VECS(tea_tv_template) 4898da7f033dSHerbert Xu } 4899da7f033dSHerbert Xu }, { 4900da7f033dSHerbert Xu .alg = "ecb(twofish)", 49011aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4902da7f033dSHerbert Xu .suite = { 490392a4c9feSEric Biggers .cipher = __VECS(tf_tv_template) 4904da7f033dSHerbert Xu } 4905da7f033dSHerbert Xu }, { 4906da7f033dSHerbert Xu .alg = "ecb(xeta)", 49071aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4908da7f033dSHerbert Xu .suite = { 490992a4c9feSEric Biggers .cipher = __VECS(xeta_tv_template) 4910da7f033dSHerbert Xu } 4911da7f033dSHerbert Xu }, { 4912da7f033dSHerbert Xu .alg = "ecb(xtea)", 49131aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4914da7f033dSHerbert Xu .suite = { 491592a4c9feSEric Biggers .cipher = __VECS(xtea_tv_template) 4916da7f033dSHerbert Xu } 4917da7f033dSHerbert Xu }, { 4918c7ff8573SHarald Freudenberger #if IS_ENABLED(CONFIG_CRYPTO_PAES_S390) 4919c7ff8573SHarald Freudenberger .alg = "ecb-paes-s390", 4920c7ff8573SHarald Freudenberger .fips_allowed = 1, 4921c7ff8573SHarald Freudenberger .test = alg_test_skcipher, 4922c7ff8573SHarald Freudenberger .suite = { 4923c7ff8573SHarald Freudenberger .cipher = __VECS(aes_tv_template) 4924c7ff8573SHarald Freudenberger } 4925c7ff8573SHarald Freudenberger }, { 4926c7ff8573SHarald Freudenberger #endif 49276763f5eaSMeng Yu .alg = "ecdh-nist-p192", 49283c4b2390SSalvatore Benedetto .test = alg_test_kpp, 49293c4b2390SSalvatore Benedetto .suite = { 49306763f5eaSMeng Yu .kpp = __VECS(ecdh_p192_tv_template) 49316763f5eaSMeng Yu } 49326763f5eaSMeng Yu }, { 49336763f5eaSMeng Yu .alg = "ecdh-nist-p256", 49346763f5eaSMeng Yu .test = alg_test_kpp, 49356763f5eaSMeng Yu .fips_allowed = 1, 49366763f5eaSMeng Yu .suite = { 49376763f5eaSMeng Yu .kpp = __VECS(ecdh_p256_tv_template) 49383c4b2390SSalvatore Benedetto } 49393c4b2390SSalvatore Benedetto }, { 49408e568fc2SHui Tang .alg = "ecdh-nist-p384", 49418e568fc2SHui Tang .test = alg_test_kpp, 49428e568fc2SHui Tang .fips_allowed = 1, 49438e568fc2SHui Tang .suite = { 49448e568fc2SHui Tang .kpp = __VECS(ecdh_p384_tv_template) 49458e568fc2SHui Tang } 49468e568fc2SHui Tang }, { 49474e660291SStefan Berger .alg = "ecdsa-nist-p192", 49484e660291SStefan Berger .test = alg_test_akcipher, 49494e660291SStefan Berger .suite = { 49504e660291SStefan Berger .akcipher = __VECS(ecdsa_nist_p192_tv_template) 49514e660291SStefan Berger } 49524e660291SStefan Berger }, { 49534e660291SStefan Berger .alg = "ecdsa-nist-p256", 49544e660291SStefan Berger .test = alg_test_akcipher, 49554e660291SStefan Berger .suite = { 49564e660291SStefan Berger .akcipher = __VECS(ecdsa_nist_p256_tv_template) 49574e660291SStefan Berger } 49584e660291SStefan Berger }, { 4959c12d448bSSaulo Alessandre .alg = "ecdsa-nist-p384", 4960c12d448bSSaulo Alessandre .test = alg_test_akcipher, 4961c12d448bSSaulo Alessandre .suite = { 4962c12d448bSSaulo Alessandre .akcipher = __VECS(ecdsa_nist_p384_tv_template) 4963c12d448bSSaulo Alessandre } 4964c12d448bSSaulo Alessandre }, { 496532fbdbd3SVitaly Chikunov .alg = "ecrdsa", 496632fbdbd3SVitaly Chikunov .test = alg_test_akcipher, 496732fbdbd3SVitaly Chikunov .suite = { 496832fbdbd3SVitaly Chikunov .akcipher = __VECS(ecrdsa_tv_template) 496932fbdbd3SVitaly Chikunov } 497032fbdbd3SVitaly Chikunov }, { 4971f975abb2SArd Biesheuvel .alg = "essiv(authenc(hmac(sha256),cbc(aes)),sha256)", 4972f975abb2SArd Biesheuvel .test = alg_test_aead, 4973f975abb2SArd Biesheuvel .fips_allowed = 1, 4974f975abb2SArd Biesheuvel .suite = { 4975f975abb2SArd Biesheuvel .aead = __VECS(essiv_hmac_sha256_aes_cbc_tv_temp) 4976f975abb2SArd Biesheuvel } 4977f975abb2SArd Biesheuvel }, { 4978f975abb2SArd Biesheuvel .alg = "essiv(cbc(aes),sha256)", 4979f975abb2SArd Biesheuvel .test = alg_test_skcipher, 4980f975abb2SArd Biesheuvel .fips_allowed = 1, 4981f975abb2SArd Biesheuvel .suite = { 4982f975abb2SArd Biesheuvel .cipher = __VECS(essiv_aes_cbc_tv_template) 4983f975abb2SArd Biesheuvel } 4984f975abb2SArd Biesheuvel }, { 4985da7f033dSHerbert Xu .alg = "gcm(aes)", 498640153b10SEric Biggers .generic_driver = "gcm_base(ctr(aes-generic),ghash-generic)", 4987da7f033dSHerbert Xu .test = alg_test_aead, 4988a1915d51SJarod Wilson .fips_allowed = 1, 4989da7f033dSHerbert Xu .suite = { 4990a0d608eeSEric Biggers .aead = __VECS(aes_gcm_tv_template) 4991da7f033dSHerbert Xu } 4992da7f033dSHerbert Xu }, { 4993*68039d60STianjia Zhang .alg = "gcm(sm4)", 4994*68039d60STianjia Zhang .generic_driver = "gcm_base(ctr(sm4-generic),ghash-generic)", 4995*68039d60STianjia Zhang .test = alg_test_aead, 4996*68039d60STianjia Zhang .suite = { 4997*68039d60STianjia Zhang .aead = __VECS(sm4_gcm_tv_template) 4998*68039d60STianjia Zhang } 4999*68039d60STianjia Zhang }, { 5000507069c9SYouquan, Song .alg = "ghash", 5001507069c9SYouquan, Song .test = alg_test_hash, 500218c0ebd2SJarod Wilson .fips_allowed = 1, 5003507069c9SYouquan, Song .suite = { 500421c8e720SArd Biesheuvel .hash = __VECS(ghash_tv_template) 5005507069c9SYouquan, Song } 5006507069c9SYouquan, Song }, { 5007da7f033dSHerbert Xu .alg = "hmac(md5)", 5008da7f033dSHerbert Xu .test = alg_test_hash, 5009da7f033dSHerbert Xu .suite = { 501021c8e720SArd Biesheuvel .hash = __VECS(hmac_md5_tv_template) 5011da7f033dSHerbert Xu } 5012da7f033dSHerbert Xu }, { 5013da7f033dSHerbert Xu .alg = "hmac(rmd160)", 5014da7f033dSHerbert Xu .test = alg_test_hash, 5015da7f033dSHerbert Xu .suite = { 501621c8e720SArd Biesheuvel .hash = __VECS(hmac_rmd160_tv_template) 5017da7f033dSHerbert Xu } 5018da7f033dSHerbert Xu }, { 5019da7f033dSHerbert Xu .alg = "hmac(sha1)", 5020da7f033dSHerbert Xu .test = alg_test_hash, 5021a1915d51SJarod Wilson .fips_allowed = 1, 5022da7f033dSHerbert Xu .suite = { 502321c8e720SArd Biesheuvel .hash = __VECS(hmac_sha1_tv_template) 5024da7f033dSHerbert Xu } 5025da7f033dSHerbert Xu }, { 5026da7f033dSHerbert Xu .alg = "hmac(sha224)", 5027da7f033dSHerbert Xu .test = alg_test_hash, 5028a1915d51SJarod Wilson .fips_allowed = 1, 5029da7f033dSHerbert Xu .suite = { 503021c8e720SArd Biesheuvel .hash = __VECS(hmac_sha224_tv_template) 5031da7f033dSHerbert Xu } 5032da7f033dSHerbert Xu }, { 5033da7f033dSHerbert Xu .alg = "hmac(sha256)", 5034da7f033dSHerbert Xu .test = alg_test_hash, 5035a1915d51SJarod Wilson .fips_allowed = 1, 5036da7f033dSHerbert Xu .suite = { 503721c8e720SArd Biesheuvel .hash = __VECS(hmac_sha256_tv_template) 5038da7f033dSHerbert Xu } 5039da7f033dSHerbert Xu }, { 504098eca72fSraveendra padasalagi .alg = "hmac(sha3-224)", 504198eca72fSraveendra padasalagi .test = alg_test_hash, 504298eca72fSraveendra padasalagi .fips_allowed = 1, 504398eca72fSraveendra padasalagi .suite = { 504421c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_224_tv_template) 504598eca72fSraveendra padasalagi } 504698eca72fSraveendra padasalagi }, { 504798eca72fSraveendra padasalagi .alg = "hmac(sha3-256)", 504898eca72fSraveendra padasalagi .test = alg_test_hash, 504998eca72fSraveendra padasalagi .fips_allowed = 1, 505098eca72fSraveendra padasalagi .suite = { 505121c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_256_tv_template) 505298eca72fSraveendra padasalagi } 505398eca72fSraveendra padasalagi }, { 505498eca72fSraveendra padasalagi .alg = "hmac(sha3-384)", 505598eca72fSraveendra padasalagi .test = alg_test_hash, 505698eca72fSraveendra padasalagi .fips_allowed = 1, 505798eca72fSraveendra padasalagi .suite = { 505821c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_384_tv_template) 505998eca72fSraveendra padasalagi } 506098eca72fSraveendra padasalagi }, { 506198eca72fSraveendra padasalagi .alg = "hmac(sha3-512)", 506298eca72fSraveendra padasalagi .test = alg_test_hash, 506398eca72fSraveendra padasalagi .fips_allowed = 1, 506498eca72fSraveendra padasalagi .suite = { 506521c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_512_tv_template) 506698eca72fSraveendra padasalagi } 506798eca72fSraveendra padasalagi }, { 5068da7f033dSHerbert Xu .alg = "hmac(sha384)", 5069da7f033dSHerbert Xu .test = alg_test_hash, 5070a1915d51SJarod Wilson .fips_allowed = 1, 5071da7f033dSHerbert Xu .suite = { 507221c8e720SArd Biesheuvel .hash = __VECS(hmac_sha384_tv_template) 5073da7f033dSHerbert Xu } 5074da7f033dSHerbert Xu }, { 5075da7f033dSHerbert Xu .alg = "hmac(sha512)", 5076da7f033dSHerbert Xu .test = alg_test_hash, 5077a1915d51SJarod Wilson .fips_allowed = 1, 5078da7f033dSHerbert Xu .suite = { 507921c8e720SArd Biesheuvel .hash = __VECS(hmac_sha512_tv_template) 5080da7f033dSHerbert Xu } 5081da7f033dSHerbert Xu }, { 50828194fd1dSPascal van Leeuwen .alg = "hmac(sm3)", 50838194fd1dSPascal van Leeuwen .test = alg_test_hash, 50848194fd1dSPascal van Leeuwen .suite = { 50858194fd1dSPascal van Leeuwen .hash = __VECS(hmac_sm3_tv_template) 50868194fd1dSPascal van Leeuwen } 50878194fd1dSPascal van Leeuwen }, { 508825a0b9d4SVitaly Chikunov .alg = "hmac(streebog256)", 508925a0b9d4SVitaly Chikunov .test = alg_test_hash, 509025a0b9d4SVitaly Chikunov .suite = { 509125a0b9d4SVitaly Chikunov .hash = __VECS(hmac_streebog256_tv_template) 509225a0b9d4SVitaly Chikunov } 509325a0b9d4SVitaly Chikunov }, { 509425a0b9d4SVitaly Chikunov .alg = "hmac(streebog512)", 509525a0b9d4SVitaly Chikunov .test = alg_test_hash, 509625a0b9d4SVitaly Chikunov .suite = { 509725a0b9d4SVitaly Chikunov .hash = __VECS(hmac_streebog512_tv_template) 509825a0b9d4SVitaly Chikunov } 509925a0b9d4SVitaly Chikunov }, { 5100bb5530e4SStephan Mueller .alg = "jitterentropy_rng", 5101bb5530e4SStephan Mueller .fips_allowed = 1, 5102bb5530e4SStephan Mueller .test = alg_test_null, 5103bb5530e4SStephan Mueller }, { 510435351988SStephan Mueller .alg = "kw(aes)", 510535351988SStephan Mueller .test = alg_test_skcipher, 510635351988SStephan Mueller .fips_allowed = 1, 510735351988SStephan Mueller .suite = { 510892a4c9feSEric Biggers .cipher = __VECS(aes_kw_tv_template) 510935351988SStephan Mueller } 511035351988SStephan Mueller }, { 5111da7f033dSHerbert Xu .alg = "lrw(aes)", 5112d435e10eSEric Biggers .generic_driver = "lrw(ecb(aes-generic))", 51131aa4ecd9SHerbert Xu .test = alg_test_skcipher, 5114da7f033dSHerbert Xu .suite = { 511592a4c9feSEric Biggers .cipher = __VECS(aes_lrw_tv_template) 5116da7f033dSHerbert Xu } 5117da7f033dSHerbert Xu }, { 51180840605eSJussi Kivilinna .alg = "lrw(camellia)", 5119d435e10eSEric Biggers .generic_driver = "lrw(ecb(camellia-generic))", 51200840605eSJussi Kivilinna .test = alg_test_skcipher, 51210840605eSJussi Kivilinna .suite = { 512292a4c9feSEric Biggers .cipher = __VECS(camellia_lrw_tv_template) 51230840605eSJussi Kivilinna } 51240840605eSJussi Kivilinna }, { 51259b8b0405SJohannes Goetzfried .alg = "lrw(cast6)", 5126d435e10eSEric Biggers .generic_driver = "lrw(ecb(cast6-generic))", 51279b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 51289b8b0405SJohannes Goetzfried .suite = { 512992a4c9feSEric Biggers .cipher = __VECS(cast6_lrw_tv_template) 51309b8b0405SJohannes Goetzfried } 51319b8b0405SJohannes Goetzfried }, { 5132d7bfc0faSJussi Kivilinna .alg = "lrw(serpent)", 5133d435e10eSEric Biggers .generic_driver = "lrw(ecb(serpent-generic))", 5134d7bfc0faSJussi Kivilinna .test = alg_test_skcipher, 5135d7bfc0faSJussi Kivilinna .suite = { 513692a4c9feSEric Biggers .cipher = __VECS(serpent_lrw_tv_template) 5137d7bfc0faSJussi Kivilinna } 5138d7bfc0faSJussi Kivilinna }, { 51390b2a1551SJussi Kivilinna .alg = "lrw(twofish)", 5140d435e10eSEric Biggers .generic_driver = "lrw(ecb(twofish-generic))", 51410b2a1551SJussi Kivilinna .test = alg_test_skcipher, 51420b2a1551SJussi Kivilinna .suite = { 514392a4c9feSEric Biggers .cipher = __VECS(tf_lrw_tv_template) 51440b2a1551SJussi Kivilinna } 51450b2a1551SJussi Kivilinna }, { 51461443cc9bSKOVACS Krisztian .alg = "lz4", 51471443cc9bSKOVACS Krisztian .test = alg_test_comp, 51481443cc9bSKOVACS Krisztian .fips_allowed = 1, 51491443cc9bSKOVACS Krisztian .suite = { 51501443cc9bSKOVACS Krisztian .comp = { 515121c8e720SArd Biesheuvel .comp = __VECS(lz4_comp_tv_template), 515221c8e720SArd Biesheuvel .decomp = __VECS(lz4_decomp_tv_template) 51531443cc9bSKOVACS Krisztian } 51541443cc9bSKOVACS Krisztian } 51551443cc9bSKOVACS Krisztian }, { 51561443cc9bSKOVACS Krisztian .alg = "lz4hc", 51571443cc9bSKOVACS Krisztian .test = alg_test_comp, 51581443cc9bSKOVACS Krisztian .fips_allowed = 1, 51591443cc9bSKOVACS Krisztian .suite = { 51601443cc9bSKOVACS Krisztian .comp = { 516121c8e720SArd Biesheuvel .comp = __VECS(lz4hc_comp_tv_template), 516221c8e720SArd Biesheuvel .decomp = __VECS(lz4hc_decomp_tv_template) 51631443cc9bSKOVACS Krisztian } 51641443cc9bSKOVACS Krisztian } 51651443cc9bSKOVACS Krisztian }, { 5166da7f033dSHerbert Xu .alg = "lzo", 5167da7f033dSHerbert Xu .test = alg_test_comp, 51680818904dSMilan Broz .fips_allowed = 1, 5169da7f033dSHerbert Xu .suite = { 5170da7f033dSHerbert Xu .comp = { 517121c8e720SArd Biesheuvel .comp = __VECS(lzo_comp_tv_template), 517221c8e720SArd Biesheuvel .decomp = __VECS(lzo_decomp_tv_template) 5173da7f033dSHerbert Xu } 5174da7f033dSHerbert Xu } 5175da7f033dSHerbert Xu }, { 5176f248caf9SHannah Pan .alg = "lzo-rle", 5177f248caf9SHannah Pan .test = alg_test_comp, 5178f248caf9SHannah Pan .fips_allowed = 1, 5179f248caf9SHannah Pan .suite = { 5180f248caf9SHannah Pan .comp = { 5181f248caf9SHannah Pan .comp = __VECS(lzorle_comp_tv_template), 5182f248caf9SHannah Pan .decomp = __VECS(lzorle_decomp_tv_template) 5183f248caf9SHannah Pan } 5184f248caf9SHannah Pan } 5185f248caf9SHannah Pan }, { 5186da7f033dSHerbert Xu .alg = "md4", 5187da7f033dSHerbert Xu .test = alg_test_hash, 5188da7f033dSHerbert Xu .suite = { 518921c8e720SArd Biesheuvel .hash = __VECS(md4_tv_template) 5190da7f033dSHerbert Xu } 5191da7f033dSHerbert Xu }, { 5192da7f033dSHerbert Xu .alg = "md5", 5193da7f033dSHerbert Xu .test = alg_test_hash, 5194da7f033dSHerbert Xu .suite = { 519521c8e720SArd Biesheuvel .hash = __VECS(md5_tv_template) 5196da7f033dSHerbert Xu } 5197da7f033dSHerbert Xu }, { 5198da7f033dSHerbert Xu .alg = "michael_mic", 5199da7f033dSHerbert Xu .test = alg_test_hash, 5200da7f033dSHerbert Xu .suite = { 520121c8e720SArd Biesheuvel .hash = __VECS(michael_mic_tv_template) 5202da7f033dSHerbert Xu } 5203da7f033dSHerbert Xu }, { 520426609a21SEric Biggers .alg = "nhpoly1305", 520526609a21SEric Biggers .test = alg_test_hash, 520626609a21SEric Biggers .suite = { 520726609a21SEric Biggers .hash = __VECS(nhpoly1305_tv_template) 520826609a21SEric Biggers } 520926609a21SEric Biggers }, { 5210ba0e14acSPuneet Saxena .alg = "ofb(aes)", 5211ba0e14acSPuneet Saxena .test = alg_test_skcipher, 5212ba0e14acSPuneet Saxena .fips_allowed = 1, 5213ba0e14acSPuneet Saxena .suite = { 521492a4c9feSEric Biggers .cipher = __VECS(aes_ofb_tv_template) 5215ba0e14acSPuneet Saxena } 5216ba0e14acSPuneet Saxena }, { 5217a794d8d8SGilad Ben-Yossef /* Same as ofb(aes) except the key is stored in 5218a794d8d8SGilad Ben-Yossef * hardware secure memory which we reference by index 5219a794d8d8SGilad Ben-Yossef */ 5220a794d8d8SGilad Ben-Yossef .alg = "ofb(paes)", 5221a794d8d8SGilad Ben-Yossef .test = alg_test_null, 5222a794d8d8SGilad Ben-Yossef .fips_allowed = 1, 5223a794d8d8SGilad Ben-Yossef }, { 5224a06b15b2SPascal van Leeuwen .alg = "ofb(sm4)", 5225a06b15b2SPascal van Leeuwen .test = alg_test_skcipher, 5226a06b15b2SPascal van Leeuwen .suite = { 5227a06b15b2SPascal van Leeuwen .cipher = __VECS(sm4_ofb_tv_template) 5228a06b15b2SPascal van Leeuwen } 5229a06b15b2SPascal van Leeuwen }, { 5230da7f033dSHerbert Xu .alg = "pcbc(fcrypt)", 52311aa4ecd9SHerbert Xu .test = alg_test_skcipher, 5232da7f033dSHerbert Xu .suite = { 523392a4c9feSEric Biggers .cipher = __VECS(fcrypt_pcbc_tv_template) 5234da7f033dSHerbert Xu } 5235da7f033dSHerbert Xu }, { 52361207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha224)", 52371207107cSStephan Mueller .test = alg_test_null, 52381207107cSStephan Mueller .fips_allowed = 1, 52391207107cSStephan Mueller }, { 52401207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha256)", 52411207107cSStephan Mueller .test = alg_test_akcipher, 52421207107cSStephan Mueller .fips_allowed = 1, 52431207107cSStephan Mueller .suite = { 52441207107cSStephan Mueller .akcipher = __VECS(pkcs1pad_rsa_tv_template) 52451207107cSStephan Mueller } 52461207107cSStephan Mueller }, { 52471207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha384)", 52481207107cSStephan Mueller .test = alg_test_null, 52491207107cSStephan Mueller .fips_allowed = 1, 52501207107cSStephan Mueller }, { 52511207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha512)", 52521207107cSStephan Mueller .test = alg_test_null, 52531207107cSStephan Mueller .fips_allowed = 1, 52541207107cSStephan Mueller }, { 5255eee9dc61SMartin Willi .alg = "poly1305", 5256eee9dc61SMartin Willi .test = alg_test_hash, 5257eee9dc61SMartin Willi .suite = { 525821c8e720SArd Biesheuvel .hash = __VECS(poly1305_tv_template) 5259eee9dc61SMartin Willi } 5260eee9dc61SMartin Willi }, { 5261da7f033dSHerbert Xu .alg = "rfc3686(ctr(aes))", 52621aa4ecd9SHerbert Xu .test = alg_test_skcipher, 5263a1915d51SJarod Wilson .fips_allowed = 1, 5264da7f033dSHerbert Xu .suite = { 526592a4c9feSEric Biggers .cipher = __VECS(aes_ctr_rfc3686_tv_template) 5266da7f033dSHerbert Xu } 5267da7f033dSHerbert Xu }, { 5268e4886214SPascal van Leeuwen .alg = "rfc3686(ctr(sm4))", 5269e4886214SPascal van Leeuwen .test = alg_test_skcipher, 5270e4886214SPascal van Leeuwen .suite = { 5271e4886214SPascal van Leeuwen .cipher = __VECS(sm4_ctr_rfc3686_tv_template) 5272e4886214SPascal van Leeuwen } 5273e4886214SPascal van Leeuwen }, { 52743f31a740SHerbert Xu .alg = "rfc4106(gcm(aes))", 527540153b10SEric Biggers .generic_driver = "rfc4106(gcm_base(ctr(aes-generic),ghash-generic))", 527669435b94SAdrian Hoban .test = alg_test_aead, 5277db71f29aSJarod Wilson .fips_allowed = 1, 527869435b94SAdrian Hoban .suite = { 527949763fc6SEric Biggers .aead = { 528049763fc6SEric Biggers ____VECS(aes_gcm_rfc4106_tv_template), 528149763fc6SEric Biggers .einval_allowed = 1, 52826f3a06d9SEric Biggers .aad_iv = 1, 528349763fc6SEric Biggers } 528469435b94SAdrian Hoban } 528569435b94SAdrian Hoban }, { 5286544c436aSHerbert Xu .alg = "rfc4309(ccm(aes))", 528740153b10SEric Biggers .generic_driver = "rfc4309(ccm_base(ctr(aes-generic),cbcmac(aes-generic)))", 52885d667322SJarod Wilson .test = alg_test_aead, 5289a1915d51SJarod Wilson .fips_allowed = 1, 52905d667322SJarod Wilson .suite = { 529149763fc6SEric Biggers .aead = { 529249763fc6SEric Biggers ____VECS(aes_ccm_rfc4309_tv_template), 529349763fc6SEric Biggers .einval_allowed = 1, 52946f3a06d9SEric Biggers .aad_iv = 1, 529549763fc6SEric Biggers } 52965d667322SJarod Wilson } 52975d667322SJarod Wilson }, { 5298bb68745eSHerbert Xu .alg = "rfc4543(gcm(aes))", 529940153b10SEric Biggers .generic_driver = "rfc4543(gcm_base(ctr(aes-generic),ghash-generic))", 5300e9b7441aSJussi Kivilinna .test = alg_test_aead, 5301e9b7441aSJussi Kivilinna .suite = { 530249763fc6SEric Biggers .aead = { 530349763fc6SEric Biggers ____VECS(aes_gcm_rfc4543_tv_template), 530449763fc6SEric Biggers .einval_allowed = 1, 53056f3a06d9SEric Biggers .aad_iv = 1, 530649763fc6SEric Biggers } 5307e9b7441aSJussi Kivilinna } 5308e9b7441aSJussi Kivilinna }, { 5309af2b76b5SMartin Willi .alg = "rfc7539(chacha20,poly1305)", 5310af2b76b5SMartin Willi .test = alg_test_aead, 5311af2b76b5SMartin Willi .suite = { 5312a0d608eeSEric Biggers .aead = __VECS(rfc7539_tv_template) 5313af2b76b5SMartin Willi } 5314af2b76b5SMartin Willi }, { 53155900758dSMartin Willi .alg = "rfc7539esp(chacha20,poly1305)", 53165900758dSMartin Willi .test = alg_test_aead, 53175900758dSMartin Willi .suite = { 531849763fc6SEric Biggers .aead = { 531949763fc6SEric Biggers ____VECS(rfc7539esp_tv_template), 532049763fc6SEric Biggers .einval_allowed = 1, 53216f3a06d9SEric Biggers .aad_iv = 1, 532249763fc6SEric Biggers } 53235900758dSMartin Willi } 53245900758dSMartin Willi }, { 5325da7f033dSHerbert Xu .alg = "rmd160", 5326da7f033dSHerbert Xu .test = alg_test_hash, 5327da7f033dSHerbert Xu .suite = { 532821c8e720SArd Biesheuvel .hash = __VECS(rmd160_tv_template) 5329da7f033dSHerbert Xu } 5330da7f033dSHerbert Xu }, { 5331946cc463STadeusz Struk .alg = "rsa", 5332946cc463STadeusz Struk .test = alg_test_akcipher, 5333946cc463STadeusz Struk .fips_allowed = 1, 5334946cc463STadeusz Struk .suite = { 533521c8e720SArd Biesheuvel .akcipher = __VECS(rsa_tv_template) 5336946cc463STadeusz Struk } 5337946cc463STadeusz Struk }, { 5338da7f033dSHerbert Xu .alg = "sha1", 5339da7f033dSHerbert Xu .test = alg_test_hash, 5340a1915d51SJarod Wilson .fips_allowed = 1, 5341da7f033dSHerbert Xu .suite = { 534221c8e720SArd Biesheuvel .hash = __VECS(sha1_tv_template) 5343da7f033dSHerbert Xu } 5344da7f033dSHerbert Xu }, { 5345da7f033dSHerbert Xu .alg = "sha224", 5346da7f033dSHerbert Xu .test = alg_test_hash, 5347a1915d51SJarod Wilson .fips_allowed = 1, 5348da7f033dSHerbert Xu .suite = { 534921c8e720SArd Biesheuvel .hash = __VECS(sha224_tv_template) 5350da7f033dSHerbert Xu } 5351da7f033dSHerbert Xu }, { 5352da7f033dSHerbert Xu .alg = "sha256", 5353da7f033dSHerbert Xu .test = alg_test_hash, 5354a1915d51SJarod Wilson .fips_allowed = 1, 5355da7f033dSHerbert Xu .suite = { 535621c8e720SArd Biesheuvel .hash = __VECS(sha256_tv_template) 5357da7f033dSHerbert Xu } 5358da7f033dSHerbert Xu }, { 535979cc6ab8Sraveendra padasalagi .alg = "sha3-224", 536079cc6ab8Sraveendra padasalagi .test = alg_test_hash, 536179cc6ab8Sraveendra padasalagi .fips_allowed = 1, 536279cc6ab8Sraveendra padasalagi .suite = { 536321c8e720SArd Biesheuvel .hash = __VECS(sha3_224_tv_template) 536479cc6ab8Sraveendra padasalagi } 536579cc6ab8Sraveendra padasalagi }, { 536679cc6ab8Sraveendra padasalagi .alg = "sha3-256", 536779cc6ab8Sraveendra padasalagi .test = alg_test_hash, 536879cc6ab8Sraveendra padasalagi .fips_allowed = 1, 536979cc6ab8Sraveendra padasalagi .suite = { 537021c8e720SArd Biesheuvel .hash = __VECS(sha3_256_tv_template) 537179cc6ab8Sraveendra padasalagi } 537279cc6ab8Sraveendra padasalagi }, { 537379cc6ab8Sraveendra padasalagi .alg = "sha3-384", 537479cc6ab8Sraveendra padasalagi .test = alg_test_hash, 537579cc6ab8Sraveendra padasalagi .fips_allowed = 1, 537679cc6ab8Sraveendra padasalagi .suite = { 537721c8e720SArd Biesheuvel .hash = __VECS(sha3_384_tv_template) 537879cc6ab8Sraveendra padasalagi } 537979cc6ab8Sraveendra padasalagi }, { 538079cc6ab8Sraveendra padasalagi .alg = "sha3-512", 538179cc6ab8Sraveendra padasalagi .test = alg_test_hash, 538279cc6ab8Sraveendra padasalagi .fips_allowed = 1, 538379cc6ab8Sraveendra padasalagi .suite = { 538421c8e720SArd Biesheuvel .hash = __VECS(sha3_512_tv_template) 538579cc6ab8Sraveendra padasalagi } 538679cc6ab8Sraveendra padasalagi }, { 5387da7f033dSHerbert Xu .alg = "sha384", 5388da7f033dSHerbert Xu .test = alg_test_hash, 5389a1915d51SJarod Wilson .fips_allowed = 1, 5390da7f033dSHerbert Xu .suite = { 539121c8e720SArd Biesheuvel .hash = __VECS(sha384_tv_template) 5392da7f033dSHerbert Xu } 5393da7f033dSHerbert Xu }, { 5394da7f033dSHerbert Xu .alg = "sha512", 5395da7f033dSHerbert Xu .test = alg_test_hash, 5396a1915d51SJarod Wilson .fips_allowed = 1, 5397da7f033dSHerbert Xu .suite = { 539821c8e720SArd Biesheuvel .hash = __VECS(sha512_tv_template) 5399da7f033dSHerbert Xu } 5400da7f033dSHerbert Xu }, { 54018b805b97STianjia Zhang .alg = "sm2", 54028b805b97STianjia Zhang .test = alg_test_akcipher, 54038b805b97STianjia Zhang .suite = { 54048b805b97STianjia Zhang .akcipher = __VECS(sm2_tv_template) 54058b805b97STianjia Zhang } 54068b805b97STianjia Zhang }, { 5407b7e27530SGilad Ben-Yossef .alg = "sm3", 5408b7e27530SGilad Ben-Yossef .test = alg_test_hash, 5409b7e27530SGilad Ben-Yossef .suite = { 5410b7e27530SGilad Ben-Yossef .hash = __VECS(sm3_tv_template) 5411b7e27530SGilad Ben-Yossef } 5412b7e27530SGilad Ben-Yossef }, { 541325a0b9d4SVitaly Chikunov .alg = "streebog256", 541425a0b9d4SVitaly Chikunov .test = alg_test_hash, 541525a0b9d4SVitaly Chikunov .suite = { 541625a0b9d4SVitaly Chikunov .hash = __VECS(streebog256_tv_template) 541725a0b9d4SVitaly Chikunov } 541825a0b9d4SVitaly Chikunov }, { 541925a0b9d4SVitaly Chikunov .alg = "streebog512", 542025a0b9d4SVitaly Chikunov .test = alg_test_hash, 542125a0b9d4SVitaly Chikunov .suite = { 542225a0b9d4SVitaly Chikunov .hash = __VECS(streebog512_tv_template) 542325a0b9d4SVitaly Chikunov } 542425a0b9d4SVitaly Chikunov }, { 5425ed331adaSEric Biggers .alg = "vmac64(aes)", 5426ed331adaSEric Biggers .test = alg_test_hash, 5427ed331adaSEric Biggers .suite = { 5428ed331adaSEric Biggers .hash = __VECS(vmac64_aes_tv_template) 5429ed331adaSEric Biggers } 5430ed331adaSEric Biggers }, { 5431da7f033dSHerbert Xu .alg = "wp256", 5432da7f033dSHerbert Xu .test = alg_test_hash, 5433da7f033dSHerbert Xu .suite = { 543421c8e720SArd Biesheuvel .hash = __VECS(wp256_tv_template) 5435da7f033dSHerbert Xu } 5436da7f033dSHerbert Xu }, { 5437da7f033dSHerbert Xu .alg = "wp384", 5438da7f033dSHerbert Xu .test = alg_test_hash, 5439da7f033dSHerbert Xu .suite = { 544021c8e720SArd Biesheuvel .hash = __VECS(wp384_tv_template) 5441da7f033dSHerbert Xu } 5442da7f033dSHerbert Xu }, { 5443da7f033dSHerbert Xu .alg = "wp512", 5444da7f033dSHerbert Xu .test = alg_test_hash, 5445da7f033dSHerbert Xu .suite = { 544621c8e720SArd Biesheuvel .hash = __VECS(wp512_tv_template) 5447da7f033dSHerbert Xu } 5448da7f033dSHerbert Xu }, { 5449da7f033dSHerbert Xu .alg = "xcbc(aes)", 5450da7f033dSHerbert Xu .test = alg_test_hash, 5451da7f033dSHerbert Xu .suite = { 545221c8e720SArd Biesheuvel .hash = __VECS(aes_xcbc128_tv_template) 5453da7f033dSHerbert Xu } 5454da7f033dSHerbert Xu }, { 5455aa762409SEric Biggers .alg = "xchacha12", 5456aa762409SEric Biggers .test = alg_test_skcipher, 5457aa762409SEric Biggers .suite = { 5458aa762409SEric Biggers .cipher = __VECS(xchacha12_tv_template) 5459aa762409SEric Biggers }, 5460aa762409SEric Biggers }, { 5461de61d7aeSEric Biggers .alg = "xchacha20", 5462de61d7aeSEric Biggers .test = alg_test_skcipher, 5463de61d7aeSEric Biggers .suite = { 5464de61d7aeSEric Biggers .cipher = __VECS(xchacha20_tv_template) 5465de61d7aeSEric Biggers }, 5466de61d7aeSEric Biggers }, { 5467da7f033dSHerbert Xu .alg = "xts(aes)", 5468d435e10eSEric Biggers .generic_driver = "xts(ecb(aes-generic))", 54691aa4ecd9SHerbert Xu .test = alg_test_skcipher, 54702918aa8dSJarod Wilson .fips_allowed = 1, 5471da7f033dSHerbert Xu .suite = { 547292a4c9feSEric Biggers .cipher = __VECS(aes_xts_tv_template) 5473da7f033dSHerbert Xu } 54740c01aed5SGeert Uytterhoeven }, { 54750840605eSJussi Kivilinna .alg = "xts(camellia)", 5476d435e10eSEric Biggers .generic_driver = "xts(ecb(camellia-generic))", 54770840605eSJussi Kivilinna .test = alg_test_skcipher, 54780840605eSJussi Kivilinna .suite = { 547992a4c9feSEric Biggers .cipher = __VECS(camellia_xts_tv_template) 54800840605eSJussi Kivilinna } 54810840605eSJussi Kivilinna }, { 54829b8b0405SJohannes Goetzfried .alg = "xts(cast6)", 5483d435e10eSEric Biggers .generic_driver = "xts(ecb(cast6-generic))", 54849b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 54859b8b0405SJohannes Goetzfried .suite = { 548692a4c9feSEric Biggers .cipher = __VECS(cast6_xts_tv_template) 54879b8b0405SJohannes Goetzfried } 54889b8b0405SJohannes Goetzfried }, { 548915f47ce5SGilad Ben-Yossef /* Same as xts(aes) except the key is stored in 549015f47ce5SGilad Ben-Yossef * hardware secure memory which we reference by index 549115f47ce5SGilad Ben-Yossef */ 549215f47ce5SGilad Ben-Yossef .alg = "xts(paes)", 549315f47ce5SGilad Ben-Yossef .test = alg_test_null, 549415f47ce5SGilad Ben-Yossef .fips_allowed = 1, 549515f47ce5SGilad Ben-Yossef }, { 549618be20b9SJussi Kivilinna .alg = "xts(serpent)", 5497d435e10eSEric Biggers .generic_driver = "xts(ecb(serpent-generic))", 549818be20b9SJussi Kivilinna .test = alg_test_skcipher, 549918be20b9SJussi Kivilinna .suite = { 550092a4c9feSEric Biggers .cipher = __VECS(serpent_xts_tv_template) 550118be20b9SJussi Kivilinna } 550218be20b9SJussi Kivilinna }, { 5503aed265b9SJussi Kivilinna .alg = "xts(twofish)", 5504d435e10eSEric Biggers .generic_driver = "xts(ecb(twofish-generic))", 5505aed265b9SJussi Kivilinna .test = alg_test_skcipher, 5506aed265b9SJussi Kivilinna .suite = { 550792a4c9feSEric Biggers .cipher = __VECS(tf_xts_tv_template) 5508aed265b9SJussi Kivilinna } 5509a368f43dSGiovanni Cabiddu }, { 5510c7ff8573SHarald Freudenberger #if IS_ENABLED(CONFIG_CRYPTO_PAES_S390) 5511c7ff8573SHarald Freudenberger .alg = "xts-paes-s390", 5512c7ff8573SHarald Freudenberger .fips_allowed = 1, 5513c7ff8573SHarald Freudenberger .test = alg_test_skcipher, 5514c7ff8573SHarald Freudenberger .suite = { 5515c7ff8573SHarald Freudenberger .cipher = __VECS(aes_xts_tv_template) 5516c7ff8573SHarald Freudenberger } 5517c7ff8573SHarald Freudenberger }, { 5518c7ff8573SHarald Freudenberger #endif 551915f47ce5SGilad Ben-Yossef .alg = "xts4096(paes)", 552015f47ce5SGilad Ben-Yossef .test = alg_test_null, 552115f47ce5SGilad Ben-Yossef .fips_allowed = 1, 552215f47ce5SGilad Ben-Yossef }, { 552315f47ce5SGilad Ben-Yossef .alg = "xts512(paes)", 552415f47ce5SGilad Ben-Yossef .test = alg_test_null, 552515f47ce5SGilad Ben-Yossef .fips_allowed = 1, 552615f47ce5SGilad Ben-Yossef }, { 552767882e76SNikolay Borisov .alg = "xxhash64", 552867882e76SNikolay Borisov .test = alg_test_hash, 552967882e76SNikolay Borisov .fips_allowed = 1, 553067882e76SNikolay Borisov .suite = { 553167882e76SNikolay Borisov .hash = __VECS(xxhash64_tv_template) 553267882e76SNikolay Borisov } 553367882e76SNikolay Borisov }, { 5534a368f43dSGiovanni Cabiddu .alg = "zlib-deflate", 5535a368f43dSGiovanni Cabiddu .test = alg_test_comp, 5536a368f43dSGiovanni Cabiddu .fips_allowed = 1, 5537a368f43dSGiovanni Cabiddu .suite = { 5538a368f43dSGiovanni Cabiddu .comp = { 5539a368f43dSGiovanni Cabiddu .comp = __VECS(zlib_deflate_comp_tv_template), 5540a368f43dSGiovanni Cabiddu .decomp = __VECS(zlib_deflate_decomp_tv_template) 5541a368f43dSGiovanni Cabiddu } 5542a368f43dSGiovanni Cabiddu } 5543d28fc3dbSNick Terrell }, { 5544d28fc3dbSNick Terrell .alg = "zstd", 5545d28fc3dbSNick Terrell .test = alg_test_comp, 5546d28fc3dbSNick Terrell .fips_allowed = 1, 5547d28fc3dbSNick Terrell .suite = { 5548d28fc3dbSNick Terrell .comp = { 5549d28fc3dbSNick Terrell .comp = __VECS(zstd_comp_tv_template), 5550d28fc3dbSNick Terrell .decomp = __VECS(zstd_decomp_tv_template) 5551d28fc3dbSNick Terrell } 5552d28fc3dbSNick Terrell } 5553da7f033dSHerbert Xu } 5554da7f033dSHerbert Xu }; 5555da7f033dSHerbert Xu 55563f47a03dSEric Biggers static void alg_check_test_descs_order(void) 55575714758bSJussi Kivilinna { 55585714758bSJussi Kivilinna int i; 55595714758bSJussi Kivilinna 55605714758bSJussi Kivilinna for (i = 1; i < ARRAY_SIZE(alg_test_descs); i++) { 55615714758bSJussi Kivilinna int diff = strcmp(alg_test_descs[i - 1].alg, 55625714758bSJussi Kivilinna alg_test_descs[i].alg); 55635714758bSJussi Kivilinna 55645714758bSJussi Kivilinna if (WARN_ON(diff > 0)) { 55655714758bSJussi Kivilinna pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n", 55665714758bSJussi Kivilinna alg_test_descs[i - 1].alg, 55675714758bSJussi Kivilinna alg_test_descs[i].alg); 55685714758bSJussi Kivilinna } 55695714758bSJussi Kivilinna 55705714758bSJussi Kivilinna if (WARN_ON(diff == 0)) { 55715714758bSJussi Kivilinna pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n", 55725714758bSJussi Kivilinna alg_test_descs[i].alg); 55735714758bSJussi Kivilinna } 55745714758bSJussi Kivilinna } 55755714758bSJussi Kivilinna } 55765714758bSJussi Kivilinna 55773f47a03dSEric Biggers static void alg_check_testvec_configs(void) 55783f47a03dSEric Biggers { 55794e7babbaSEric Biggers int i; 55804e7babbaSEric Biggers 55814e7babbaSEric Biggers for (i = 0; i < ARRAY_SIZE(default_cipher_testvec_configs); i++) 55824e7babbaSEric Biggers WARN_ON(!valid_testvec_config( 55834e7babbaSEric Biggers &default_cipher_testvec_configs[i])); 55844cc2dcf9SEric Biggers 55854cc2dcf9SEric Biggers for (i = 0; i < ARRAY_SIZE(default_hash_testvec_configs); i++) 55864cc2dcf9SEric Biggers WARN_ON(!valid_testvec_config( 55874cc2dcf9SEric Biggers &default_hash_testvec_configs[i])); 55883f47a03dSEric Biggers } 55893f47a03dSEric Biggers 55903f47a03dSEric Biggers static void testmgr_onetime_init(void) 55913f47a03dSEric Biggers { 55923f47a03dSEric Biggers alg_check_test_descs_order(); 55933f47a03dSEric Biggers alg_check_testvec_configs(); 55945b2706a4SEric Biggers 55955b2706a4SEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 55965b2706a4SEric Biggers pr_warn("alg: extra crypto tests enabled. This is intended for developer use only.\n"); 55975b2706a4SEric Biggers #endif 55983f47a03dSEric Biggers } 55993f47a03dSEric Biggers 56001aa4ecd9SHerbert Xu static int alg_find_test(const char *alg) 5601da7f033dSHerbert Xu { 5602da7f033dSHerbert Xu int start = 0; 5603da7f033dSHerbert Xu int end = ARRAY_SIZE(alg_test_descs); 5604da7f033dSHerbert Xu 5605da7f033dSHerbert Xu while (start < end) { 5606da7f033dSHerbert Xu int i = (start + end) / 2; 5607da7f033dSHerbert Xu int diff = strcmp(alg_test_descs[i].alg, alg); 5608da7f033dSHerbert Xu 5609da7f033dSHerbert Xu if (diff > 0) { 5610da7f033dSHerbert Xu end = i; 5611da7f033dSHerbert Xu continue; 5612da7f033dSHerbert Xu } 5613da7f033dSHerbert Xu 5614da7f033dSHerbert Xu if (diff < 0) { 5615da7f033dSHerbert Xu start = i + 1; 5616da7f033dSHerbert Xu continue; 5617da7f033dSHerbert Xu } 5618da7f033dSHerbert Xu 56191aa4ecd9SHerbert Xu return i; 5620da7f033dSHerbert Xu } 5621da7f033dSHerbert Xu 56221aa4ecd9SHerbert Xu return -1; 56231aa4ecd9SHerbert Xu } 56241aa4ecd9SHerbert Xu 56251aa4ecd9SHerbert Xu int alg_test(const char *driver, const char *alg, u32 type, u32 mask) 56261aa4ecd9SHerbert Xu { 56271aa4ecd9SHerbert Xu int i; 5628a68f6610SHerbert Xu int j; 5629d12d6b6dSNeil Horman int rc; 56301aa4ecd9SHerbert Xu 56319e5c9fe4SRichard W.M. Jones if (!fips_enabled && notests) { 56329e5c9fe4SRichard W.M. Jones printk_once(KERN_INFO "alg: self-tests disabled\n"); 56339e5c9fe4SRichard W.M. Jones return 0; 56349e5c9fe4SRichard W.M. Jones } 56359e5c9fe4SRichard W.M. Jones 56363f47a03dSEric Biggers DO_ONCE(testmgr_onetime_init); 56375714758bSJussi Kivilinna 56381aa4ecd9SHerbert Xu if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) { 56391aa4ecd9SHerbert Xu char nalg[CRYPTO_MAX_ALG_NAME]; 56401aa4ecd9SHerbert Xu 56411aa4ecd9SHerbert Xu if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >= 56421aa4ecd9SHerbert Xu sizeof(nalg)) 56431aa4ecd9SHerbert Xu return -ENAMETOOLONG; 56441aa4ecd9SHerbert Xu 56451aa4ecd9SHerbert Xu i = alg_find_test(nalg); 56461aa4ecd9SHerbert Xu if (i < 0) 56471aa4ecd9SHerbert Xu goto notest; 56481aa4ecd9SHerbert Xu 5649a3bef3a3SJarod Wilson if (fips_enabled && !alg_test_descs[i].fips_allowed) 5650a3bef3a3SJarod Wilson goto non_fips_alg; 5651a3bef3a3SJarod Wilson 5652941fb328SJarod Wilson rc = alg_test_cipher(alg_test_descs + i, driver, type, mask); 5653941fb328SJarod Wilson goto test_done; 56541aa4ecd9SHerbert Xu } 56551aa4ecd9SHerbert Xu 56561aa4ecd9SHerbert Xu i = alg_find_test(alg); 5657a68f6610SHerbert Xu j = alg_find_test(driver); 5658a68f6610SHerbert Xu if (i < 0 && j < 0) 56591aa4ecd9SHerbert Xu goto notest; 56601aa4ecd9SHerbert Xu 5661a68f6610SHerbert Xu if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) || 5662a68f6610SHerbert Xu (j >= 0 && !alg_test_descs[j].fips_allowed))) 5663a3bef3a3SJarod Wilson goto non_fips_alg; 5664a3bef3a3SJarod Wilson 5665a68f6610SHerbert Xu rc = 0; 5666a68f6610SHerbert Xu if (i >= 0) 5667a68f6610SHerbert Xu rc |= alg_test_descs[i].test(alg_test_descs + i, driver, 56681aa4ecd9SHerbert Xu type, mask); 5669032c8cacSCristian Stoica if (j >= 0 && j != i) 5670a68f6610SHerbert Xu rc |= alg_test_descs[j].test(alg_test_descs + j, driver, 5671a68f6610SHerbert Xu type, mask); 5672a68f6610SHerbert Xu 5673941fb328SJarod Wilson test_done: 567409a5ef96SEric Biggers if (rc) { 567509a5ef96SEric Biggers if (fips_enabled || panic_on_fail) { 56769552389cSGilad Ben-Yossef fips_fail_notify(); 5677eda69b0cSEric Biggers panic("alg: self-tests for %s (%s) failed in %s mode!\n", 567809a5ef96SEric Biggers driver, alg, 567909a5ef96SEric Biggers fips_enabled ? "fips" : "panic_on_fail"); 56809552389cSGilad Ben-Yossef } 568109a5ef96SEric Biggers WARN(1, "alg: self-tests for %s (%s) failed (rc=%d)", 568209a5ef96SEric Biggers driver, alg, rc); 568309a5ef96SEric Biggers } else { 568409a5ef96SEric Biggers if (fips_enabled) 568509a5ef96SEric Biggers pr_info("alg: self-tests for %s (%s) passed\n", 568609a5ef96SEric Biggers driver, alg); 568709a5ef96SEric Biggers } 568829ecd4abSJarod Wilson 5689d12d6b6dSNeil Horman return rc; 56901aa4ecd9SHerbert Xu 56911aa4ecd9SHerbert Xu notest: 5692da7f033dSHerbert Xu printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver); 5693da7f033dSHerbert Xu return 0; 5694a3bef3a3SJarod Wilson non_fips_alg: 5695a3bef3a3SJarod Wilson return -EINVAL; 5696da7f033dSHerbert Xu } 56970b767f96SAlexander Shishkin 5698326a6346SHerbert Xu #endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */ 56990b767f96SAlexander Shishkin 5700da7f033dSHerbert Xu EXPORT_SYMBOL_GPL(alg_test); 5701