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"); 585b2706a4SEric Biggers #endif 595b2706a4SEric Biggers 60326a6346SHerbert Xu #ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS 610b767f96SAlexander Shishkin 620b767f96SAlexander Shishkin /* a perfect nop */ 630b767f96SAlexander Shishkin int alg_test(const char *driver, const char *alg, u32 type, u32 mask) 640b767f96SAlexander Shishkin { 650b767f96SAlexander Shishkin return 0; 660b767f96SAlexander Shishkin } 670b767f96SAlexander Shishkin 680b767f96SAlexander Shishkin #else 690b767f96SAlexander Shishkin 70da7f033dSHerbert Xu #include "testmgr.h" 71da7f033dSHerbert Xu 72da7f033dSHerbert Xu /* 73da7f033dSHerbert Xu * Need slab memory for testing (size in number of pages). 74da7f033dSHerbert Xu */ 75da7f033dSHerbert Xu #define XBUFSIZE 8 76da7f033dSHerbert Xu 77da7f033dSHerbert Xu /* 78da7f033dSHerbert Xu * Used by test_cipher() 79da7f033dSHerbert Xu */ 80da7f033dSHerbert Xu #define ENCRYPT 1 81da7f033dSHerbert Xu #define DECRYPT 0 82da7f033dSHerbert Xu 83da7f033dSHerbert Xu struct aead_test_suite { 84b13b1e0cSEric Biggers const struct aead_testvec *vecs; 85da7f033dSHerbert Xu unsigned int count; 8649763fc6SEric Biggers 8749763fc6SEric Biggers /* 8849763fc6SEric Biggers * Set if trying to decrypt an inauthentic ciphertext with this 8949763fc6SEric Biggers * algorithm might result in EINVAL rather than EBADMSG, due to other 9049763fc6SEric Biggers * validation the algorithm does on the inputs such as length checks. 9149763fc6SEric Biggers */ 9249763fc6SEric Biggers unsigned int einval_allowed : 1; 9349763fc6SEric Biggers 9449763fc6SEric Biggers /* 956f3a06d9SEric Biggers * Set if this algorithm requires that the IV be located at the end of 966f3a06d9SEric Biggers * the AAD buffer, in addition to being given in the normal way. The 976f3a06d9SEric Biggers * behavior when the two IV copies differ is implementation-defined. 9849763fc6SEric Biggers */ 996f3a06d9SEric Biggers unsigned int aad_iv : 1; 100da7f033dSHerbert Xu }; 101da7f033dSHerbert Xu 102da7f033dSHerbert Xu struct cipher_test_suite { 103b13b1e0cSEric Biggers const struct cipher_testvec *vecs; 104da7f033dSHerbert Xu unsigned int count; 105da7f033dSHerbert Xu }; 106da7f033dSHerbert Xu 107da7f033dSHerbert Xu struct comp_test_suite { 108da7f033dSHerbert Xu struct { 109b13b1e0cSEric Biggers const struct comp_testvec *vecs; 110da7f033dSHerbert Xu unsigned int count; 111da7f033dSHerbert Xu } comp, decomp; 112da7f033dSHerbert Xu }; 113da7f033dSHerbert Xu 114da7f033dSHerbert Xu struct hash_test_suite { 115b13b1e0cSEric Biggers const struct hash_testvec *vecs; 116da7f033dSHerbert Xu unsigned int count; 117da7f033dSHerbert Xu }; 118da7f033dSHerbert Xu 1197647d6ceSJarod Wilson struct cprng_test_suite { 120b13b1e0cSEric Biggers const struct cprng_testvec *vecs; 1217647d6ceSJarod Wilson unsigned int count; 1227647d6ceSJarod Wilson }; 1237647d6ceSJarod Wilson 12464d1cdfbSStephan Mueller struct drbg_test_suite { 125b13b1e0cSEric Biggers const struct drbg_testvec *vecs; 12664d1cdfbSStephan Mueller unsigned int count; 12764d1cdfbSStephan Mueller }; 12864d1cdfbSStephan Mueller 129946cc463STadeusz Struk struct akcipher_test_suite { 130b13b1e0cSEric Biggers const struct akcipher_testvec *vecs; 131946cc463STadeusz Struk unsigned int count; 132946cc463STadeusz Struk }; 133946cc463STadeusz Struk 134802c7f1cSSalvatore Benedetto struct kpp_test_suite { 135b13b1e0cSEric Biggers const struct kpp_testvec *vecs; 136802c7f1cSSalvatore Benedetto unsigned int count; 137802c7f1cSSalvatore Benedetto }; 138802c7f1cSSalvatore Benedetto 139da7f033dSHerbert Xu struct alg_test_desc { 140da7f033dSHerbert Xu const char *alg; 141f2bb770aSEric Biggers const char *generic_driver; 142da7f033dSHerbert Xu int (*test)(const struct alg_test_desc *desc, const char *driver, 143da7f033dSHerbert Xu u32 type, u32 mask); 144a1915d51SJarod Wilson int fips_allowed; /* set if alg is allowed in fips mode */ 145da7f033dSHerbert Xu 146da7f033dSHerbert Xu union { 147da7f033dSHerbert Xu struct aead_test_suite aead; 148da7f033dSHerbert Xu struct cipher_test_suite cipher; 149da7f033dSHerbert Xu struct comp_test_suite comp; 150da7f033dSHerbert Xu struct hash_test_suite hash; 1517647d6ceSJarod Wilson struct cprng_test_suite cprng; 15264d1cdfbSStephan Mueller struct drbg_test_suite drbg; 153946cc463STadeusz Struk struct akcipher_test_suite akcipher; 154802c7f1cSSalvatore Benedetto struct kpp_test_suite kpp; 155da7f033dSHerbert Xu } suite; 156da7f033dSHerbert Xu }; 157da7f033dSHerbert Xu 158da7f033dSHerbert Xu static void hexdump(unsigned char *buf, unsigned int len) 159da7f033dSHerbert Xu { 160da7f033dSHerbert Xu print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET, 161da7f033dSHerbert Xu 16, 1, 162da7f033dSHerbert Xu buf, len, false); 163da7f033dSHerbert Xu } 164da7f033dSHerbert Xu 1653f47a03dSEric Biggers static int __testmgr_alloc_buf(char *buf[XBUFSIZE], int order) 166f8b0d4d0SHerbert Xu { 167f8b0d4d0SHerbert Xu int i; 168f8b0d4d0SHerbert Xu 169f8b0d4d0SHerbert Xu for (i = 0; i < XBUFSIZE; i++) { 1703f47a03dSEric Biggers buf[i] = (char *)__get_free_pages(GFP_KERNEL, order); 171f8b0d4d0SHerbert Xu if (!buf[i]) 172f8b0d4d0SHerbert Xu goto err_free_buf; 173f8b0d4d0SHerbert Xu } 174f8b0d4d0SHerbert Xu 175f8b0d4d0SHerbert Xu return 0; 176f8b0d4d0SHerbert Xu 177f8b0d4d0SHerbert Xu err_free_buf: 178f8b0d4d0SHerbert Xu while (i-- > 0) 1793f47a03dSEric Biggers free_pages((unsigned long)buf[i], order); 180f8b0d4d0SHerbert Xu 181f8b0d4d0SHerbert Xu return -ENOMEM; 182f8b0d4d0SHerbert Xu } 183f8b0d4d0SHerbert Xu 1843f47a03dSEric Biggers static int testmgr_alloc_buf(char *buf[XBUFSIZE]) 1853f47a03dSEric Biggers { 1863f47a03dSEric Biggers return __testmgr_alloc_buf(buf, 0); 1873f47a03dSEric Biggers } 1883f47a03dSEric Biggers 1893f47a03dSEric Biggers static void __testmgr_free_buf(char *buf[XBUFSIZE], int order) 190f8b0d4d0SHerbert Xu { 191f8b0d4d0SHerbert Xu int i; 192f8b0d4d0SHerbert Xu 193f8b0d4d0SHerbert Xu for (i = 0; i < XBUFSIZE; i++) 1943f47a03dSEric Biggers free_pages((unsigned long)buf[i], order); 1953f47a03dSEric Biggers } 1963f47a03dSEric Biggers 1973f47a03dSEric Biggers static void testmgr_free_buf(char *buf[XBUFSIZE]) 1983f47a03dSEric Biggers { 1993f47a03dSEric Biggers __testmgr_free_buf(buf, 0); 2003f47a03dSEric Biggers } 2013f47a03dSEric Biggers 2023f47a03dSEric Biggers #define TESTMGR_POISON_BYTE 0xfe 2033f47a03dSEric Biggers #define TESTMGR_POISON_LEN 16 2043f47a03dSEric Biggers 2053f47a03dSEric Biggers static inline void testmgr_poison(void *addr, size_t len) 2063f47a03dSEric Biggers { 2073f47a03dSEric Biggers memset(addr, TESTMGR_POISON_BYTE, len); 2083f47a03dSEric Biggers } 2093f47a03dSEric Biggers 2103f47a03dSEric Biggers /* Is the memory region still fully poisoned? */ 2113f47a03dSEric Biggers static inline bool testmgr_is_poison(const void *addr, size_t len) 2123f47a03dSEric Biggers { 2133f47a03dSEric Biggers return memchr_inv(addr, TESTMGR_POISON_BYTE, len) == NULL; 2143f47a03dSEric Biggers } 2153f47a03dSEric Biggers 2163f47a03dSEric Biggers /* flush type for hash algorithms */ 2173f47a03dSEric Biggers enum flush_type { 2183f47a03dSEric Biggers /* merge with update of previous buffer(s) */ 2193f47a03dSEric Biggers FLUSH_TYPE_NONE = 0, 2203f47a03dSEric Biggers 2213f47a03dSEric Biggers /* update with previous buffer(s) before doing this one */ 2223f47a03dSEric Biggers FLUSH_TYPE_FLUSH, 2233f47a03dSEric Biggers 2243f47a03dSEric Biggers /* likewise, but also export and re-import the intermediate state */ 2253f47a03dSEric Biggers FLUSH_TYPE_REIMPORT, 2263f47a03dSEric Biggers }; 2273f47a03dSEric Biggers 2283f47a03dSEric Biggers /* finalization function for hash algorithms */ 2293f47a03dSEric Biggers enum finalization_type { 2303f47a03dSEric Biggers FINALIZATION_TYPE_FINAL, /* use final() */ 2313f47a03dSEric Biggers FINALIZATION_TYPE_FINUP, /* use finup() */ 2323f47a03dSEric Biggers FINALIZATION_TYPE_DIGEST, /* use digest() */ 2333f47a03dSEric Biggers }; 2343f47a03dSEric Biggers 235f17f9e90SEric Biggers /* 236f17f9e90SEric Biggers * Whether the crypto operation will occur in-place, and if so whether the 237f17f9e90SEric Biggers * source and destination scatterlist pointers will coincide (req->src == 238f17f9e90SEric Biggers * req->dst), or whether they'll merely point to two separate scatterlists 239f17f9e90SEric Biggers * (req->src != req->dst) that reference the same underlying memory. 240f17f9e90SEric Biggers * 241f17f9e90SEric Biggers * This is only relevant for algorithm types that support in-place operation. 242f17f9e90SEric Biggers */ 243f17f9e90SEric Biggers enum inplace_mode { 244f17f9e90SEric Biggers OUT_OF_PLACE, 245f17f9e90SEric Biggers INPLACE_ONE_SGLIST, 246f17f9e90SEric Biggers INPLACE_TWO_SGLISTS, 247f17f9e90SEric Biggers }; 248f17f9e90SEric Biggers 2493f47a03dSEric Biggers #define TEST_SG_TOTAL 10000 2503f47a03dSEric Biggers 2513f47a03dSEric Biggers /** 2523f47a03dSEric Biggers * struct test_sg_division - description of a scatterlist entry 2533f47a03dSEric Biggers * 2543f47a03dSEric Biggers * This struct describes one entry of a scatterlist being constructed to check a 2553f47a03dSEric Biggers * crypto test vector. 2563f47a03dSEric Biggers * 2573f47a03dSEric Biggers * @proportion_of_total: length of this chunk relative to the total length, 2583f47a03dSEric Biggers * given as a proportion out of TEST_SG_TOTAL so that it 2593f47a03dSEric Biggers * scales to fit any test vector 2603f47a03dSEric Biggers * @offset: byte offset into a 2-page buffer at which this chunk will start 2613f47a03dSEric Biggers * @offset_relative_to_alignmask: if true, add the algorithm's alignmask to the 2623f47a03dSEric Biggers * @offset 2633f47a03dSEric Biggers * @flush_type: for hashes, whether an update() should be done now vs. 2643f47a03dSEric Biggers * continuing to accumulate data 2656570737cSEric Biggers * @nosimd: if doing the pending update(), do it with SIMD disabled? 2663f47a03dSEric Biggers */ 2673f47a03dSEric Biggers struct test_sg_division { 2683f47a03dSEric Biggers unsigned int proportion_of_total; 2693f47a03dSEric Biggers unsigned int offset; 2703f47a03dSEric Biggers bool offset_relative_to_alignmask; 2713f47a03dSEric Biggers enum flush_type flush_type; 2726570737cSEric Biggers bool nosimd; 2733f47a03dSEric Biggers }; 2743f47a03dSEric Biggers 2753f47a03dSEric Biggers /** 2763f47a03dSEric Biggers * struct testvec_config - configuration for testing a crypto test vector 2773f47a03dSEric Biggers * 2783f47a03dSEric Biggers * This struct describes the data layout and other parameters with which each 2793f47a03dSEric Biggers * crypto test vector can be tested. 2803f47a03dSEric Biggers * 2813f47a03dSEric Biggers * @name: name of this config, logged for debugging purposes if a test fails 282f17f9e90SEric Biggers * @inplace_mode: whether and how to operate on the data in-place, if applicable 2833f47a03dSEric Biggers * @req_flags: extra request_flags, e.g. CRYPTO_TFM_REQ_MAY_SLEEP 2843f47a03dSEric Biggers * @src_divs: description of how to arrange the source scatterlist 2853f47a03dSEric Biggers * @dst_divs: description of how to arrange the dst scatterlist, if applicable 2863f47a03dSEric Biggers * for the algorithm type. Defaults to @src_divs if unset. 2873f47a03dSEric Biggers * @iv_offset: misalignment of the IV in the range [0..MAX_ALGAPI_ALIGNMASK+1], 2883f47a03dSEric Biggers * where 0 is aligned to a 2*(MAX_ALGAPI_ALIGNMASK+1) byte boundary 2893f47a03dSEric Biggers * @iv_offset_relative_to_alignmask: if true, add the algorithm's alignmask to 2903f47a03dSEric Biggers * the @iv_offset 291fd8c37c7SEric Biggers * @key_offset: misalignment of the key, where 0 is default alignment 292fd8c37c7SEric Biggers * @key_offset_relative_to_alignmask: if true, add the algorithm's alignmask to 293fd8c37c7SEric Biggers * the @key_offset 2943f47a03dSEric Biggers * @finalization_type: what finalization function to use for hashes 2956570737cSEric Biggers * @nosimd: execute with SIMD disabled? Requires !CRYPTO_TFM_REQ_MAY_SLEEP. 2963f47a03dSEric Biggers */ 2973f47a03dSEric Biggers struct testvec_config { 2983f47a03dSEric Biggers const char *name; 299f17f9e90SEric Biggers enum inplace_mode inplace_mode; 3003f47a03dSEric Biggers u32 req_flags; 3013f47a03dSEric Biggers struct test_sg_division src_divs[XBUFSIZE]; 3023f47a03dSEric Biggers struct test_sg_division dst_divs[XBUFSIZE]; 3033f47a03dSEric Biggers unsigned int iv_offset; 304fd8c37c7SEric Biggers unsigned int key_offset; 3053f47a03dSEric Biggers bool iv_offset_relative_to_alignmask; 306fd8c37c7SEric Biggers bool key_offset_relative_to_alignmask; 3073f47a03dSEric Biggers enum finalization_type finalization_type; 3086570737cSEric Biggers bool nosimd; 3093f47a03dSEric Biggers }; 3103f47a03dSEric Biggers 3113f47a03dSEric Biggers #define TESTVEC_CONFIG_NAMELEN 192 3123f47a03dSEric Biggers 3134e7babbaSEric Biggers /* 3144e7babbaSEric Biggers * The following are the lists of testvec_configs to test for each algorithm 3154e7babbaSEric Biggers * type when the basic crypto self-tests are enabled, i.e. when 3164e7babbaSEric Biggers * CONFIG_CRYPTO_MANAGER_DISABLE_TESTS is unset. They aim to provide good test 3174e7babbaSEric Biggers * coverage, while keeping the test time much shorter than the full fuzz tests 3184e7babbaSEric Biggers * so that the basic tests can be enabled in a wider range of circumstances. 3194e7babbaSEric Biggers */ 3204e7babbaSEric Biggers 3214e7babbaSEric Biggers /* Configs for skciphers and aeads */ 3224e7babbaSEric Biggers static const struct testvec_config default_cipher_testvec_configs[] = { 3234e7babbaSEric Biggers { 324f17f9e90SEric Biggers .name = "in-place (one sglist)", 325f17f9e90SEric Biggers .inplace_mode = INPLACE_ONE_SGLIST, 326f17f9e90SEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 327f17f9e90SEric Biggers }, { 328f17f9e90SEric Biggers .name = "in-place (two sglists)", 329f17f9e90SEric Biggers .inplace_mode = INPLACE_TWO_SGLISTS, 3304e7babbaSEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 3314e7babbaSEric Biggers }, { 3324e7babbaSEric Biggers .name = "out-of-place", 333f17f9e90SEric Biggers .inplace_mode = OUT_OF_PLACE, 3344e7babbaSEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 3354e7babbaSEric Biggers }, { 3364e7babbaSEric Biggers .name = "unaligned buffer, offset=1", 3374e7babbaSEric Biggers .src_divs = { { .proportion_of_total = 10000, .offset = 1 } }, 3384e7babbaSEric Biggers .iv_offset = 1, 339fd8c37c7SEric Biggers .key_offset = 1, 3404e7babbaSEric Biggers }, { 3414e7babbaSEric Biggers .name = "buffer aligned only to alignmask", 3424e7babbaSEric Biggers .src_divs = { 3434e7babbaSEric Biggers { 3444e7babbaSEric Biggers .proportion_of_total = 10000, 3454e7babbaSEric Biggers .offset = 1, 3464e7babbaSEric Biggers .offset_relative_to_alignmask = true, 3474e7babbaSEric Biggers }, 3484e7babbaSEric Biggers }, 3494e7babbaSEric Biggers .iv_offset = 1, 3504e7babbaSEric Biggers .iv_offset_relative_to_alignmask = true, 351fd8c37c7SEric Biggers .key_offset = 1, 352fd8c37c7SEric Biggers .key_offset_relative_to_alignmask = true, 3534e7babbaSEric Biggers }, { 3544e7babbaSEric Biggers .name = "two even aligned splits", 3554e7babbaSEric Biggers .src_divs = { 3564e7babbaSEric Biggers { .proportion_of_total = 5000 }, 3574e7babbaSEric Biggers { .proportion_of_total = 5000 }, 3584e7babbaSEric Biggers }, 3594e7babbaSEric Biggers }, { 3604e7babbaSEric Biggers .name = "uneven misaligned splits, may sleep", 3614e7babbaSEric Biggers .req_flags = CRYPTO_TFM_REQ_MAY_SLEEP, 3624e7babbaSEric Biggers .src_divs = { 3634e7babbaSEric Biggers { .proportion_of_total = 1900, .offset = 33 }, 3644e7babbaSEric Biggers { .proportion_of_total = 3300, .offset = 7 }, 3654e7babbaSEric Biggers { .proportion_of_total = 4800, .offset = 18 }, 3664e7babbaSEric Biggers }, 3674e7babbaSEric Biggers .iv_offset = 3, 368fd8c37c7SEric Biggers .key_offset = 3, 3694e7babbaSEric Biggers }, { 3704e7babbaSEric Biggers .name = "misaligned splits crossing pages, inplace", 371f17f9e90SEric Biggers .inplace_mode = INPLACE_ONE_SGLIST, 3724e7babbaSEric Biggers .src_divs = { 3734e7babbaSEric Biggers { 3744e7babbaSEric Biggers .proportion_of_total = 7500, 3754e7babbaSEric Biggers .offset = PAGE_SIZE - 32 3764e7babbaSEric Biggers }, { 3774e7babbaSEric Biggers .proportion_of_total = 2500, 3784e7babbaSEric Biggers .offset = PAGE_SIZE - 7 3794e7babbaSEric Biggers }, 3804e7babbaSEric Biggers }, 3814e7babbaSEric Biggers } 3824e7babbaSEric Biggers }; 3834e7babbaSEric Biggers 3844cc2dcf9SEric Biggers static const struct testvec_config default_hash_testvec_configs[] = { 3854cc2dcf9SEric Biggers { 3864cc2dcf9SEric Biggers .name = "init+update+final aligned buffer", 3874cc2dcf9SEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 3884cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINAL, 3894cc2dcf9SEric Biggers }, { 3904cc2dcf9SEric Biggers .name = "init+finup aligned buffer", 3914cc2dcf9SEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 3924cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINUP, 3934cc2dcf9SEric Biggers }, { 3944cc2dcf9SEric Biggers .name = "digest aligned buffer", 3954cc2dcf9SEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 3964cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_DIGEST, 3974cc2dcf9SEric Biggers }, { 3984cc2dcf9SEric Biggers .name = "init+update+final misaligned buffer", 3994cc2dcf9SEric Biggers .src_divs = { { .proportion_of_total = 10000, .offset = 1 } }, 4004cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINAL, 401fd8c37c7SEric Biggers .key_offset = 1, 4024cc2dcf9SEric Biggers }, { 4034cc2dcf9SEric Biggers .name = "digest buffer aligned only to alignmask", 4044cc2dcf9SEric Biggers .src_divs = { 4054cc2dcf9SEric Biggers { 4064cc2dcf9SEric Biggers .proportion_of_total = 10000, 4074cc2dcf9SEric Biggers .offset = 1, 4084cc2dcf9SEric Biggers .offset_relative_to_alignmask = true, 4094cc2dcf9SEric Biggers }, 4104cc2dcf9SEric Biggers }, 4114cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_DIGEST, 412fd8c37c7SEric Biggers .key_offset = 1, 413fd8c37c7SEric Biggers .key_offset_relative_to_alignmask = true, 4144cc2dcf9SEric Biggers }, { 4154cc2dcf9SEric Biggers .name = "init+update+update+final two even splits", 4164cc2dcf9SEric Biggers .src_divs = { 4174cc2dcf9SEric Biggers { .proportion_of_total = 5000 }, 4184cc2dcf9SEric Biggers { 4194cc2dcf9SEric Biggers .proportion_of_total = 5000, 4204cc2dcf9SEric Biggers .flush_type = FLUSH_TYPE_FLUSH, 4214cc2dcf9SEric Biggers }, 4224cc2dcf9SEric Biggers }, 4234cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINAL, 4244cc2dcf9SEric Biggers }, { 4254cc2dcf9SEric Biggers .name = "digest uneven misaligned splits, may sleep", 4264cc2dcf9SEric Biggers .req_flags = CRYPTO_TFM_REQ_MAY_SLEEP, 4274cc2dcf9SEric Biggers .src_divs = { 4284cc2dcf9SEric Biggers { .proportion_of_total = 1900, .offset = 33 }, 4294cc2dcf9SEric Biggers { .proportion_of_total = 3300, .offset = 7 }, 4304cc2dcf9SEric Biggers { .proportion_of_total = 4800, .offset = 18 }, 4314cc2dcf9SEric Biggers }, 4324cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_DIGEST, 4334cc2dcf9SEric Biggers }, { 4344cc2dcf9SEric Biggers .name = "digest misaligned splits crossing pages", 4354cc2dcf9SEric Biggers .src_divs = { 4364cc2dcf9SEric Biggers { 4374cc2dcf9SEric Biggers .proportion_of_total = 7500, 4384cc2dcf9SEric Biggers .offset = PAGE_SIZE - 32, 4394cc2dcf9SEric Biggers }, { 4404cc2dcf9SEric Biggers .proportion_of_total = 2500, 4414cc2dcf9SEric Biggers .offset = PAGE_SIZE - 7, 4424cc2dcf9SEric Biggers }, 4434cc2dcf9SEric Biggers }, 4444cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_DIGEST, 4454cc2dcf9SEric Biggers }, { 4464cc2dcf9SEric Biggers .name = "import/export", 4474cc2dcf9SEric Biggers .src_divs = { 4484cc2dcf9SEric Biggers { 4494cc2dcf9SEric Biggers .proportion_of_total = 6500, 4504cc2dcf9SEric Biggers .flush_type = FLUSH_TYPE_REIMPORT, 4514cc2dcf9SEric Biggers }, { 4524cc2dcf9SEric Biggers .proportion_of_total = 3500, 4534cc2dcf9SEric Biggers .flush_type = FLUSH_TYPE_REIMPORT, 4544cc2dcf9SEric Biggers }, 4554cc2dcf9SEric Biggers }, 4564cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINAL, 4574cc2dcf9SEric Biggers } 4584cc2dcf9SEric Biggers }; 4594cc2dcf9SEric Biggers 4603f47a03dSEric Biggers static unsigned int count_test_sg_divisions(const struct test_sg_division *divs) 4613f47a03dSEric Biggers { 4623f47a03dSEric Biggers unsigned int remaining = TEST_SG_TOTAL; 4633f47a03dSEric Biggers unsigned int ndivs = 0; 4643f47a03dSEric Biggers 4653f47a03dSEric Biggers do { 4663f47a03dSEric Biggers remaining -= divs[ndivs++].proportion_of_total; 4673f47a03dSEric Biggers } while (remaining); 4683f47a03dSEric Biggers 4693f47a03dSEric Biggers return ndivs; 4703f47a03dSEric Biggers } 4713f47a03dSEric Biggers 4726570737cSEric Biggers #define SGDIVS_HAVE_FLUSHES BIT(0) 4736570737cSEric Biggers #define SGDIVS_HAVE_NOSIMD BIT(1) 4746570737cSEric Biggers 4753f47a03dSEric Biggers static bool valid_sg_divisions(const struct test_sg_division *divs, 4766570737cSEric Biggers unsigned int count, int *flags_ret) 4773f47a03dSEric Biggers { 4783f47a03dSEric Biggers unsigned int total = 0; 4793f47a03dSEric Biggers unsigned int i; 4803f47a03dSEric Biggers 4813f47a03dSEric Biggers for (i = 0; i < count && total != TEST_SG_TOTAL; i++) { 4823f47a03dSEric Biggers if (divs[i].proportion_of_total <= 0 || 4833f47a03dSEric Biggers divs[i].proportion_of_total > TEST_SG_TOTAL - total) 4843f47a03dSEric Biggers return false; 4853f47a03dSEric Biggers total += divs[i].proportion_of_total; 4863f47a03dSEric Biggers if (divs[i].flush_type != FLUSH_TYPE_NONE) 4876570737cSEric Biggers *flags_ret |= SGDIVS_HAVE_FLUSHES; 4886570737cSEric Biggers if (divs[i].nosimd) 4896570737cSEric Biggers *flags_ret |= SGDIVS_HAVE_NOSIMD; 4903f47a03dSEric Biggers } 4913f47a03dSEric Biggers return total == TEST_SG_TOTAL && 4923f47a03dSEric Biggers memchr_inv(&divs[i], 0, (count - i) * sizeof(divs[0])) == NULL; 4933f47a03dSEric Biggers } 4943f47a03dSEric Biggers 4953f47a03dSEric Biggers /* 4963f47a03dSEric Biggers * Check whether the given testvec_config is valid. This isn't strictly needed 4973f47a03dSEric Biggers * since every testvec_config should be valid, but check anyway so that people 4983f47a03dSEric Biggers * don't unknowingly add broken configs that don't do what they wanted. 4993f47a03dSEric Biggers */ 5003f47a03dSEric Biggers static bool valid_testvec_config(const struct testvec_config *cfg) 5013f47a03dSEric Biggers { 5026570737cSEric Biggers int flags = 0; 5033f47a03dSEric Biggers 5043f47a03dSEric Biggers if (cfg->name == NULL) 5053f47a03dSEric Biggers return false; 5063f47a03dSEric Biggers 5073f47a03dSEric Biggers if (!valid_sg_divisions(cfg->src_divs, ARRAY_SIZE(cfg->src_divs), 5086570737cSEric Biggers &flags)) 5093f47a03dSEric Biggers return false; 5103f47a03dSEric Biggers 5113f47a03dSEric Biggers if (cfg->dst_divs[0].proportion_of_total) { 5123f47a03dSEric Biggers if (!valid_sg_divisions(cfg->dst_divs, 5136570737cSEric Biggers ARRAY_SIZE(cfg->dst_divs), &flags)) 5143f47a03dSEric Biggers return false; 5153f47a03dSEric Biggers } else { 5163f47a03dSEric Biggers if (memchr_inv(cfg->dst_divs, 0, sizeof(cfg->dst_divs))) 5173f47a03dSEric Biggers return false; 5183f47a03dSEric Biggers /* defaults to dst_divs=src_divs */ 5193f47a03dSEric Biggers } 5203f47a03dSEric Biggers 5213f47a03dSEric Biggers if (cfg->iv_offset + 5223f47a03dSEric Biggers (cfg->iv_offset_relative_to_alignmask ? MAX_ALGAPI_ALIGNMASK : 0) > 5233f47a03dSEric Biggers MAX_ALGAPI_ALIGNMASK + 1) 5243f47a03dSEric Biggers return false; 5253f47a03dSEric Biggers 5266570737cSEric Biggers if ((flags & (SGDIVS_HAVE_FLUSHES | SGDIVS_HAVE_NOSIMD)) && 5276570737cSEric Biggers cfg->finalization_type == FINALIZATION_TYPE_DIGEST) 5286570737cSEric Biggers return false; 5296570737cSEric Biggers 5306570737cSEric Biggers if ((cfg->nosimd || (flags & SGDIVS_HAVE_NOSIMD)) && 5316570737cSEric Biggers (cfg->req_flags & CRYPTO_TFM_REQ_MAY_SLEEP)) 5323f47a03dSEric Biggers return false; 5333f47a03dSEric Biggers 5343f47a03dSEric Biggers return true; 5353f47a03dSEric Biggers } 5363f47a03dSEric Biggers 5373f47a03dSEric Biggers struct test_sglist { 5383f47a03dSEric Biggers char *bufs[XBUFSIZE]; 5393f47a03dSEric Biggers struct scatterlist sgl[XBUFSIZE]; 5403f47a03dSEric Biggers struct scatterlist sgl_saved[XBUFSIZE]; 5413f47a03dSEric Biggers struct scatterlist *sgl_ptr; 5423f47a03dSEric Biggers unsigned int nents; 5433f47a03dSEric Biggers }; 5443f47a03dSEric Biggers 5453f47a03dSEric Biggers static int init_test_sglist(struct test_sglist *tsgl) 5463f47a03dSEric Biggers { 5473f47a03dSEric Biggers return __testmgr_alloc_buf(tsgl->bufs, 1 /* two pages per buffer */); 5483f47a03dSEric Biggers } 5493f47a03dSEric Biggers 5503f47a03dSEric Biggers static void destroy_test_sglist(struct test_sglist *tsgl) 5513f47a03dSEric Biggers { 5523f47a03dSEric Biggers return __testmgr_free_buf(tsgl->bufs, 1 /* two pages per buffer */); 5533f47a03dSEric Biggers } 5543f47a03dSEric Biggers 5553f47a03dSEric Biggers /** 5563f47a03dSEric Biggers * build_test_sglist() - build a scatterlist for a crypto test 5573f47a03dSEric Biggers * 5583f47a03dSEric Biggers * @tsgl: the scatterlist to build. @tsgl->bufs[] contains an array of 2-page 5593f47a03dSEric Biggers * buffers which the scatterlist @tsgl->sgl[] will be made to point into. 5603f47a03dSEric Biggers * @divs: the layout specification on which the scatterlist will be based 5613f47a03dSEric Biggers * @alignmask: the algorithm's alignmask 5623f47a03dSEric Biggers * @total_len: the total length of the scatterlist to build in bytes 5633f47a03dSEric Biggers * @data: if non-NULL, the buffers will be filled with this data until it ends. 5643f47a03dSEric Biggers * Otherwise the buffers will be poisoned. In both cases, some bytes 5653f47a03dSEric Biggers * past the end of each buffer will be poisoned to help detect overruns. 5663f47a03dSEric Biggers * @out_divs: if non-NULL, the test_sg_division to which each scatterlist entry 5673f47a03dSEric Biggers * corresponds will be returned here. This will match @divs except 5683f47a03dSEric Biggers * that divisions resolving to a length of 0 are omitted as they are 5693f47a03dSEric Biggers * not included in the scatterlist. 5703f47a03dSEric Biggers * 5713f47a03dSEric Biggers * Return: 0 or a -errno value 5723f47a03dSEric Biggers */ 5733f47a03dSEric Biggers static int build_test_sglist(struct test_sglist *tsgl, 5743f47a03dSEric Biggers const struct test_sg_division *divs, 5753f47a03dSEric Biggers const unsigned int alignmask, 5763f47a03dSEric Biggers const unsigned int total_len, 5773f47a03dSEric Biggers struct iov_iter *data, 5783f47a03dSEric Biggers const struct test_sg_division *out_divs[XBUFSIZE]) 5793f47a03dSEric Biggers { 5803f47a03dSEric Biggers struct { 5813f47a03dSEric Biggers const struct test_sg_division *div; 5823f47a03dSEric Biggers size_t length; 5833f47a03dSEric Biggers } partitions[XBUFSIZE]; 5843f47a03dSEric Biggers const unsigned int ndivs = count_test_sg_divisions(divs); 5853f47a03dSEric Biggers unsigned int len_remaining = total_len; 5863f47a03dSEric Biggers unsigned int i; 5873f47a03dSEric Biggers 5883f47a03dSEric Biggers BUILD_BUG_ON(ARRAY_SIZE(partitions) != ARRAY_SIZE(tsgl->sgl)); 5893f47a03dSEric Biggers if (WARN_ON(ndivs > ARRAY_SIZE(partitions))) 5903f47a03dSEric Biggers return -EINVAL; 5913f47a03dSEric Biggers 5923f47a03dSEric Biggers /* Calculate the (div, length) pairs */ 5933f47a03dSEric Biggers tsgl->nents = 0; 5943f47a03dSEric Biggers for (i = 0; i < ndivs; i++) { 5953f47a03dSEric Biggers unsigned int len_this_sg = 5963f47a03dSEric Biggers min(len_remaining, 5973f47a03dSEric Biggers (total_len * divs[i].proportion_of_total + 5983f47a03dSEric Biggers TEST_SG_TOTAL / 2) / TEST_SG_TOTAL); 5993f47a03dSEric Biggers 6003f47a03dSEric Biggers if (len_this_sg != 0) { 6013f47a03dSEric Biggers partitions[tsgl->nents].div = &divs[i]; 6023f47a03dSEric Biggers partitions[tsgl->nents].length = len_this_sg; 6033f47a03dSEric Biggers tsgl->nents++; 6043f47a03dSEric Biggers len_remaining -= len_this_sg; 6053f47a03dSEric Biggers } 6063f47a03dSEric Biggers } 6073f47a03dSEric Biggers if (tsgl->nents == 0) { 6083f47a03dSEric Biggers partitions[tsgl->nents].div = &divs[0]; 6093f47a03dSEric Biggers partitions[tsgl->nents].length = 0; 6103f47a03dSEric Biggers tsgl->nents++; 6113f47a03dSEric Biggers } 6123f47a03dSEric Biggers partitions[tsgl->nents - 1].length += len_remaining; 6133f47a03dSEric Biggers 6143f47a03dSEric Biggers /* Set up the sgl entries and fill the data or poison */ 6153f47a03dSEric Biggers sg_init_table(tsgl->sgl, tsgl->nents); 6163f47a03dSEric Biggers for (i = 0; i < tsgl->nents; i++) { 6173f47a03dSEric Biggers unsigned int offset = partitions[i].div->offset; 6183f47a03dSEric Biggers void *addr; 6193f47a03dSEric Biggers 6203f47a03dSEric Biggers if (partitions[i].div->offset_relative_to_alignmask) 6213f47a03dSEric Biggers offset += alignmask; 6223f47a03dSEric Biggers 6233f47a03dSEric Biggers while (offset + partitions[i].length + TESTMGR_POISON_LEN > 6243f47a03dSEric Biggers 2 * PAGE_SIZE) { 6253f47a03dSEric Biggers if (WARN_ON(offset <= 0)) 6263f47a03dSEric Biggers return -EINVAL; 6273f47a03dSEric Biggers offset /= 2; 6283f47a03dSEric Biggers } 6293f47a03dSEric Biggers 6303f47a03dSEric Biggers addr = &tsgl->bufs[i][offset]; 6313f47a03dSEric Biggers sg_set_buf(&tsgl->sgl[i], addr, partitions[i].length); 6323f47a03dSEric Biggers 6333f47a03dSEric Biggers if (out_divs) 6343f47a03dSEric Biggers out_divs[i] = partitions[i].div; 6353f47a03dSEric Biggers 6363f47a03dSEric Biggers if (data) { 6373f47a03dSEric Biggers size_t copy_len, copied; 6383f47a03dSEric Biggers 6393f47a03dSEric Biggers copy_len = min(partitions[i].length, data->count); 6403f47a03dSEric Biggers copied = copy_from_iter(addr, copy_len, data); 6413f47a03dSEric Biggers if (WARN_ON(copied != copy_len)) 6423f47a03dSEric Biggers return -EINVAL; 6433f47a03dSEric Biggers testmgr_poison(addr + copy_len, partitions[i].length + 6443f47a03dSEric Biggers TESTMGR_POISON_LEN - copy_len); 6453f47a03dSEric Biggers } else { 6463f47a03dSEric Biggers testmgr_poison(addr, partitions[i].length + 6473f47a03dSEric Biggers TESTMGR_POISON_LEN); 6483f47a03dSEric Biggers } 6493f47a03dSEric Biggers } 6503f47a03dSEric Biggers 6513f47a03dSEric Biggers sg_mark_end(&tsgl->sgl[tsgl->nents - 1]); 6523f47a03dSEric Biggers tsgl->sgl_ptr = tsgl->sgl; 6533f47a03dSEric Biggers memcpy(tsgl->sgl_saved, tsgl->sgl, tsgl->nents * sizeof(tsgl->sgl[0])); 6543f47a03dSEric Biggers return 0; 6553f47a03dSEric Biggers } 6563f47a03dSEric Biggers 6573f47a03dSEric Biggers /* 6583f47a03dSEric Biggers * Verify that a scatterlist crypto operation produced the correct output. 6593f47a03dSEric Biggers * 6603f47a03dSEric Biggers * @tsgl: scatterlist containing the actual output 6613f47a03dSEric Biggers * @expected_output: buffer containing the expected output 6623f47a03dSEric Biggers * @len_to_check: length of @expected_output in bytes 6633f47a03dSEric Biggers * @unchecked_prefix_len: number of ignored bytes in @tsgl prior to real result 6643f47a03dSEric Biggers * @check_poison: verify that the poison bytes after each chunk are intact? 6653f47a03dSEric Biggers * 6663f47a03dSEric Biggers * Return: 0 if correct, -EINVAL if incorrect, -EOVERFLOW if buffer overrun. 6673f47a03dSEric Biggers */ 6683f47a03dSEric Biggers static int verify_correct_output(const struct test_sglist *tsgl, 6693f47a03dSEric Biggers const char *expected_output, 6703f47a03dSEric Biggers unsigned int len_to_check, 6713f47a03dSEric Biggers unsigned int unchecked_prefix_len, 6723f47a03dSEric Biggers bool check_poison) 6733f47a03dSEric Biggers { 6743f47a03dSEric Biggers unsigned int i; 6753f47a03dSEric Biggers 6763f47a03dSEric Biggers for (i = 0; i < tsgl->nents; i++) { 6773f47a03dSEric Biggers struct scatterlist *sg = &tsgl->sgl_ptr[i]; 6783f47a03dSEric Biggers unsigned int len = sg->length; 6793f47a03dSEric Biggers unsigned int offset = sg->offset; 6803f47a03dSEric Biggers const char *actual_output; 6813f47a03dSEric Biggers 6823f47a03dSEric Biggers if (unchecked_prefix_len) { 6833f47a03dSEric Biggers if (unchecked_prefix_len >= len) { 6843f47a03dSEric Biggers unchecked_prefix_len -= len; 6853f47a03dSEric Biggers continue; 6863f47a03dSEric Biggers } 6873f47a03dSEric Biggers offset += unchecked_prefix_len; 6883f47a03dSEric Biggers len -= unchecked_prefix_len; 6893f47a03dSEric Biggers unchecked_prefix_len = 0; 6903f47a03dSEric Biggers } 6913f47a03dSEric Biggers len = min(len, len_to_check); 6923f47a03dSEric Biggers actual_output = page_address(sg_page(sg)) + offset; 6933f47a03dSEric Biggers if (memcmp(expected_output, actual_output, len) != 0) 6943f47a03dSEric Biggers return -EINVAL; 6953f47a03dSEric Biggers if (check_poison && 6963f47a03dSEric Biggers !testmgr_is_poison(actual_output + len, TESTMGR_POISON_LEN)) 6973f47a03dSEric Biggers return -EOVERFLOW; 6983f47a03dSEric Biggers len_to_check -= len; 6993f47a03dSEric Biggers expected_output += len; 7003f47a03dSEric Biggers } 7013f47a03dSEric Biggers if (WARN_ON(len_to_check != 0)) 7023f47a03dSEric Biggers return -EINVAL; 7033f47a03dSEric Biggers return 0; 7043f47a03dSEric Biggers } 7053f47a03dSEric Biggers 7063f47a03dSEric Biggers static bool is_test_sglist_corrupted(const struct test_sglist *tsgl) 7073f47a03dSEric Biggers { 7083f47a03dSEric Biggers unsigned int i; 7093f47a03dSEric Biggers 7103f47a03dSEric Biggers for (i = 0; i < tsgl->nents; i++) { 7113f47a03dSEric Biggers if (tsgl->sgl[i].page_link != tsgl->sgl_saved[i].page_link) 7123f47a03dSEric Biggers return true; 7133f47a03dSEric Biggers if (tsgl->sgl[i].offset != tsgl->sgl_saved[i].offset) 7143f47a03dSEric Biggers return true; 7153f47a03dSEric Biggers if (tsgl->sgl[i].length != tsgl->sgl_saved[i].length) 7163f47a03dSEric Biggers return true; 7173f47a03dSEric Biggers } 7183f47a03dSEric Biggers return false; 7193f47a03dSEric Biggers } 7203f47a03dSEric Biggers 7213f47a03dSEric Biggers struct cipher_test_sglists { 7223f47a03dSEric Biggers struct test_sglist src; 7233f47a03dSEric Biggers struct test_sglist dst; 7243f47a03dSEric Biggers }; 7253f47a03dSEric Biggers 7263f47a03dSEric Biggers static struct cipher_test_sglists *alloc_cipher_test_sglists(void) 7273f47a03dSEric Biggers { 7283f47a03dSEric Biggers struct cipher_test_sglists *tsgls; 7293f47a03dSEric Biggers 7303f47a03dSEric Biggers tsgls = kmalloc(sizeof(*tsgls), GFP_KERNEL); 7313f47a03dSEric Biggers if (!tsgls) 7323f47a03dSEric Biggers return NULL; 7333f47a03dSEric Biggers 7343f47a03dSEric Biggers if (init_test_sglist(&tsgls->src) != 0) 7353f47a03dSEric Biggers goto fail_kfree; 7363f47a03dSEric Biggers if (init_test_sglist(&tsgls->dst) != 0) 7373f47a03dSEric Biggers goto fail_destroy_src; 7383f47a03dSEric Biggers 7393f47a03dSEric Biggers return tsgls; 7403f47a03dSEric Biggers 7413f47a03dSEric Biggers fail_destroy_src: 7423f47a03dSEric Biggers destroy_test_sglist(&tsgls->src); 7433f47a03dSEric Biggers fail_kfree: 7443f47a03dSEric Biggers kfree(tsgls); 7453f47a03dSEric Biggers return NULL; 7463f47a03dSEric Biggers } 7473f47a03dSEric Biggers 7483f47a03dSEric Biggers static void free_cipher_test_sglists(struct cipher_test_sglists *tsgls) 7493f47a03dSEric Biggers { 7503f47a03dSEric Biggers if (tsgls) { 7513f47a03dSEric Biggers destroy_test_sglist(&tsgls->src); 7523f47a03dSEric Biggers destroy_test_sglist(&tsgls->dst); 7533f47a03dSEric Biggers kfree(tsgls); 7543f47a03dSEric Biggers } 7553f47a03dSEric Biggers } 7563f47a03dSEric Biggers 7573f47a03dSEric Biggers /* Build the src and dst scatterlists for an skcipher or AEAD test */ 7583f47a03dSEric Biggers static int build_cipher_test_sglists(struct cipher_test_sglists *tsgls, 7593f47a03dSEric Biggers const struct testvec_config *cfg, 7603f47a03dSEric Biggers unsigned int alignmask, 7613f47a03dSEric Biggers unsigned int src_total_len, 7623f47a03dSEric Biggers unsigned int dst_total_len, 7633f47a03dSEric Biggers const struct kvec *inputs, 7643f47a03dSEric Biggers unsigned int nr_inputs) 7653f47a03dSEric Biggers { 7663f47a03dSEric Biggers struct iov_iter input; 7673f47a03dSEric Biggers int err; 7683f47a03dSEric Biggers 769*de4eda9dSAl Viro iov_iter_kvec(&input, ITER_SOURCE, inputs, nr_inputs, src_total_len); 7703f47a03dSEric Biggers err = build_test_sglist(&tsgls->src, cfg->src_divs, alignmask, 771f17f9e90SEric Biggers cfg->inplace_mode != OUT_OF_PLACE ? 7723f47a03dSEric Biggers max(dst_total_len, src_total_len) : 7733f47a03dSEric Biggers src_total_len, 7743f47a03dSEric Biggers &input, NULL); 7753f47a03dSEric Biggers if (err) 7763f47a03dSEric Biggers return err; 7773f47a03dSEric Biggers 778f17f9e90SEric Biggers /* 779f17f9e90SEric Biggers * In-place crypto operations can use the same scatterlist for both the 780f17f9e90SEric Biggers * source and destination (req->src == req->dst), or can use separate 781f17f9e90SEric Biggers * scatterlists (req->src != req->dst) which point to the same 782f17f9e90SEric Biggers * underlying memory. Make sure to test both cases. 783f17f9e90SEric Biggers */ 784f17f9e90SEric Biggers if (cfg->inplace_mode == INPLACE_ONE_SGLIST) { 7853f47a03dSEric Biggers tsgls->dst.sgl_ptr = tsgls->src.sgl; 7863f47a03dSEric Biggers tsgls->dst.nents = tsgls->src.nents; 7873f47a03dSEric Biggers return 0; 7883f47a03dSEric Biggers } 789f17f9e90SEric Biggers if (cfg->inplace_mode == INPLACE_TWO_SGLISTS) { 790f17f9e90SEric Biggers /* 791f17f9e90SEric Biggers * For now we keep it simple and only test the case where the 792f17f9e90SEric Biggers * two scatterlists have identical entries, rather than 793f17f9e90SEric Biggers * different entries that split up the same memory differently. 794f17f9e90SEric Biggers */ 795f17f9e90SEric Biggers memcpy(tsgls->dst.sgl, tsgls->src.sgl, 796f17f9e90SEric Biggers tsgls->src.nents * sizeof(tsgls->src.sgl[0])); 797f17f9e90SEric Biggers memcpy(tsgls->dst.sgl_saved, tsgls->src.sgl, 798f17f9e90SEric Biggers tsgls->src.nents * sizeof(tsgls->src.sgl[0])); 799f17f9e90SEric Biggers tsgls->dst.sgl_ptr = tsgls->dst.sgl; 800f17f9e90SEric Biggers tsgls->dst.nents = tsgls->src.nents; 801f17f9e90SEric Biggers return 0; 802f17f9e90SEric Biggers } 803f17f9e90SEric Biggers /* Out of place */ 8043f47a03dSEric Biggers return build_test_sglist(&tsgls->dst, 8053f47a03dSEric Biggers cfg->dst_divs[0].proportion_of_total ? 8063f47a03dSEric Biggers cfg->dst_divs : cfg->src_divs, 8073f47a03dSEric Biggers alignmask, dst_total_len, NULL, NULL); 808f8b0d4d0SHerbert Xu } 809f8b0d4d0SHerbert Xu 810fd8c37c7SEric Biggers /* 811fd8c37c7SEric Biggers * Support for testing passing a misaligned key to setkey(): 812fd8c37c7SEric Biggers * 813fd8c37c7SEric Biggers * If cfg->key_offset is set, copy the key into a new buffer at that offset, 814fd8c37c7SEric Biggers * optionally adding alignmask. Else, just use the key directly. 815fd8c37c7SEric Biggers */ 816fd8c37c7SEric Biggers static int prepare_keybuf(const u8 *key, unsigned int ksize, 817fd8c37c7SEric Biggers const struct testvec_config *cfg, 818fd8c37c7SEric Biggers unsigned int alignmask, 819fd8c37c7SEric Biggers const u8 **keybuf_ret, const u8 **keyptr_ret) 820fd8c37c7SEric Biggers { 821fd8c37c7SEric Biggers unsigned int key_offset = cfg->key_offset; 822fd8c37c7SEric Biggers u8 *keybuf = NULL, *keyptr = (u8 *)key; 823fd8c37c7SEric Biggers 824fd8c37c7SEric Biggers if (key_offset != 0) { 825fd8c37c7SEric Biggers if (cfg->key_offset_relative_to_alignmask) 826fd8c37c7SEric Biggers key_offset += alignmask; 827fd8c37c7SEric Biggers keybuf = kmalloc(key_offset + ksize, GFP_KERNEL); 828fd8c37c7SEric Biggers if (!keybuf) 829fd8c37c7SEric Biggers return -ENOMEM; 830fd8c37c7SEric Biggers keyptr = keybuf + key_offset; 831fd8c37c7SEric Biggers memcpy(keyptr, key, ksize); 832fd8c37c7SEric Biggers } 833fd8c37c7SEric Biggers *keybuf_ret = keybuf; 834fd8c37c7SEric Biggers *keyptr_ret = keyptr; 835fd8c37c7SEric Biggers return 0; 836fd8c37c7SEric Biggers } 837fd8c37c7SEric Biggers 838fd8c37c7SEric Biggers /* Like setkey_f(tfm, key, ksize), but sometimes misalign the key */ 839fd8c37c7SEric Biggers #define do_setkey(setkey_f, tfm, key, ksize, cfg, alignmask) \ 840fd8c37c7SEric Biggers ({ \ 841fd8c37c7SEric Biggers const u8 *keybuf, *keyptr; \ 842fd8c37c7SEric Biggers int err; \ 843fd8c37c7SEric Biggers \ 844fd8c37c7SEric Biggers err = prepare_keybuf((key), (ksize), (cfg), (alignmask), \ 845fd8c37c7SEric Biggers &keybuf, &keyptr); \ 846fd8c37c7SEric Biggers if (err == 0) { \ 847fd8c37c7SEric Biggers err = setkey_f((tfm), keyptr, (ksize)); \ 848fd8c37c7SEric Biggers kfree(keybuf); \ 849fd8c37c7SEric Biggers } \ 850fd8c37c7SEric Biggers err; \ 851fd8c37c7SEric Biggers }) 852fd8c37c7SEric Biggers 85325f9dddbSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 854f2bb770aSEric Biggers 855f2bb770aSEric Biggers /* Generate a random length in range [0, max_len], but prefer smaller values */ 856f2bb770aSEric Biggers static unsigned int generate_random_length(unsigned int max_len) 857f2bb770aSEric Biggers { 85881895a65SJason A. Donenfeld unsigned int len = prandom_u32_max(max_len + 1); 859f2bb770aSEric Biggers 86081895a65SJason A. Donenfeld switch (prandom_u32_max(4)) { 861f2bb770aSEric Biggers case 0: 862f2bb770aSEric Biggers return len % 64; 863f2bb770aSEric Biggers case 1: 864f2bb770aSEric Biggers return len % 256; 865f2bb770aSEric Biggers case 2: 866f2bb770aSEric Biggers return len % 1024; 867f2bb770aSEric Biggers default: 868f2bb770aSEric Biggers return len; 869f2bb770aSEric Biggers } 870f2bb770aSEric Biggers } 871f2bb770aSEric Biggers 87249763fc6SEric Biggers /* Flip a random bit in the given nonempty data buffer */ 87349763fc6SEric Biggers static void flip_random_bit(u8 *buf, size_t size) 87449763fc6SEric Biggers { 87549763fc6SEric Biggers size_t bitpos; 87649763fc6SEric Biggers 87781895a65SJason A. Donenfeld bitpos = prandom_u32_max(size * 8); 87849763fc6SEric Biggers buf[bitpos / 8] ^= 1 << (bitpos % 8); 87949763fc6SEric Biggers } 88049763fc6SEric Biggers 88149763fc6SEric Biggers /* Flip a random byte in the given nonempty data buffer */ 88249763fc6SEric Biggers static void flip_random_byte(u8 *buf, size_t size) 88349763fc6SEric Biggers { 88481895a65SJason A. Donenfeld buf[prandom_u32_max(size)] ^= 0xff; 88549763fc6SEric Biggers } 88649763fc6SEric Biggers 88749763fc6SEric Biggers /* Sometimes make some random changes to the given nonempty data buffer */ 88849763fc6SEric Biggers static void mutate_buffer(u8 *buf, size_t size) 889f2bb770aSEric Biggers { 890f2bb770aSEric Biggers size_t num_flips; 891f2bb770aSEric Biggers size_t i; 892f2bb770aSEric Biggers 893f2bb770aSEric Biggers /* Sometimes flip some bits */ 89481895a65SJason A. Donenfeld if (prandom_u32_max(4) == 0) { 89581895a65SJason A. Donenfeld num_flips = min_t(size_t, 1 << prandom_u32_max(8), size * 8); 89649763fc6SEric Biggers for (i = 0; i < num_flips; i++) 89749763fc6SEric Biggers flip_random_bit(buf, size); 898f2bb770aSEric Biggers } 899f2bb770aSEric Biggers 900f2bb770aSEric Biggers /* Sometimes flip some bytes */ 90181895a65SJason A. Donenfeld if (prandom_u32_max(4) == 0) { 90281895a65SJason A. Donenfeld num_flips = min_t(size_t, 1 << prandom_u32_max(8), size); 903f2bb770aSEric Biggers for (i = 0; i < num_flips; i++) 90449763fc6SEric Biggers flip_random_byte(buf, size); 905f2bb770aSEric Biggers } 906f2bb770aSEric Biggers } 907f2bb770aSEric Biggers 908f2bb770aSEric Biggers /* Randomly generate 'count' bytes, but sometimes make them "interesting" */ 909f2bb770aSEric Biggers static void generate_random_bytes(u8 *buf, size_t count) 910f2bb770aSEric Biggers { 911f2bb770aSEric Biggers u8 b; 912f2bb770aSEric Biggers u8 increment; 913f2bb770aSEric Biggers size_t i; 914f2bb770aSEric Biggers 915f2bb770aSEric Biggers if (count == 0) 916f2bb770aSEric Biggers return; 917f2bb770aSEric Biggers 91881895a65SJason A. Donenfeld switch (prandom_u32_max(8)) { /* Choose a generation strategy */ 919f2bb770aSEric Biggers case 0: 920f2bb770aSEric Biggers case 1: 921f2bb770aSEric Biggers /* All the same byte, plus optional mutations */ 92281895a65SJason A. Donenfeld switch (prandom_u32_max(4)) { 923f2bb770aSEric Biggers case 0: 924f2bb770aSEric Biggers b = 0x00; 925f2bb770aSEric Biggers break; 926f2bb770aSEric Biggers case 1: 927f2bb770aSEric Biggers b = 0xff; 928f2bb770aSEric Biggers break; 929f2bb770aSEric Biggers default: 9307e3cf084SJason A. Donenfeld b = get_random_u8(); 931f2bb770aSEric Biggers break; 932f2bb770aSEric Biggers } 933f2bb770aSEric Biggers memset(buf, b, count); 934f2bb770aSEric Biggers mutate_buffer(buf, count); 935f2bb770aSEric Biggers break; 936f2bb770aSEric Biggers case 2: 937f2bb770aSEric Biggers /* Ascending or descending bytes, plus optional mutations */ 9387e3cf084SJason A. Donenfeld increment = get_random_u8(); 9397e3cf084SJason A. Donenfeld b = get_random_u8(); 940f2bb770aSEric Biggers for (i = 0; i < count; i++, b += increment) 941f2bb770aSEric Biggers buf[i] = b; 942f2bb770aSEric Biggers mutate_buffer(buf, count); 943f2bb770aSEric Biggers break; 944f2bb770aSEric Biggers default: 945f2bb770aSEric Biggers /* Fully random bytes */ 946f2bb770aSEric Biggers for (i = 0; i < count; i++) 9477e3cf084SJason A. Donenfeld buf[i] = get_random_u8(); 948f2bb770aSEric Biggers } 949f2bb770aSEric Biggers } 950f2bb770aSEric Biggers 95125f9dddbSEric Biggers static char *generate_random_sgl_divisions(struct test_sg_division *divs, 95225f9dddbSEric Biggers size_t max_divs, char *p, char *end, 9536570737cSEric Biggers bool gen_flushes, u32 req_flags) 95425f9dddbSEric Biggers { 95525f9dddbSEric Biggers struct test_sg_division *div = divs; 95625f9dddbSEric Biggers unsigned int remaining = TEST_SG_TOTAL; 95725f9dddbSEric Biggers 95825f9dddbSEric Biggers do { 95925f9dddbSEric Biggers unsigned int this_len; 9606570737cSEric Biggers const char *flushtype_str; 96125f9dddbSEric Biggers 96281895a65SJason A. Donenfeld if (div == &divs[max_divs - 1] || prandom_u32_max(2) == 0) 96325f9dddbSEric Biggers this_len = remaining; 96425f9dddbSEric Biggers else 96581895a65SJason A. Donenfeld this_len = 1 + prandom_u32_max(remaining); 96625f9dddbSEric Biggers div->proportion_of_total = this_len; 96725f9dddbSEric Biggers 96881895a65SJason A. Donenfeld if (prandom_u32_max(4) == 0) 96981895a65SJason A. Donenfeld div->offset = (PAGE_SIZE - 128) + prandom_u32_max(128); 97081895a65SJason A. Donenfeld else if (prandom_u32_max(2) == 0) 97181895a65SJason A. Donenfeld div->offset = prandom_u32_max(32); 97225f9dddbSEric Biggers else 97381895a65SJason A. Donenfeld div->offset = prandom_u32_max(PAGE_SIZE); 97481895a65SJason A. Donenfeld if (prandom_u32_max(8) == 0) 97525f9dddbSEric Biggers div->offset_relative_to_alignmask = true; 97625f9dddbSEric Biggers 97725f9dddbSEric Biggers div->flush_type = FLUSH_TYPE_NONE; 97825f9dddbSEric Biggers if (gen_flushes) { 97981895a65SJason A. Donenfeld switch (prandom_u32_max(4)) { 98025f9dddbSEric Biggers case 0: 98125f9dddbSEric Biggers div->flush_type = FLUSH_TYPE_REIMPORT; 98225f9dddbSEric Biggers break; 98325f9dddbSEric Biggers case 1: 98425f9dddbSEric Biggers div->flush_type = FLUSH_TYPE_FLUSH; 98525f9dddbSEric Biggers break; 98625f9dddbSEric Biggers } 98725f9dddbSEric Biggers } 98825f9dddbSEric Biggers 9896570737cSEric Biggers if (div->flush_type != FLUSH_TYPE_NONE && 9906570737cSEric Biggers !(req_flags & CRYPTO_TFM_REQ_MAY_SLEEP) && 99181895a65SJason A. Donenfeld prandom_u32_max(2) == 0) 9926570737cSEric Biggers div->nosimd = true; 9936570737cSEric Biggers 9946570737cSEric Biggers switch (div->flush_type) { 9956570737cSEric Biggers case FLUSH_TYPE_FLUSH: 9966570737cSEric Biggers if (div->nosimd) 9976570737cSEric Biggers flushtype_str = "<flush,nosimd>"; 9986570737cSEric Biggers else 9996570737cSEric Biggers flushtype_str = "<flush>"; 10006570737cSEric Biggers break; 10016570737cSEric Biggers case FLUSH_TYPE_REIMPORT: 10026570737cSEric Biggers if (div->nosimd) 10036570737cSEric Biggers flushtype_str = "<reimport,nosimd>"; 10046570737cSEric Biggers else 10056570737cSEric Biggers flushtype_str = "<reimport>"; 10066570737cSEric Biggers break; 10076570737cSEric Biggers default: 10086570737cSEric Biggers flushtype_str = ""; 10096570737cSEric Biggers break; 10106570737cSEric Biggers } 10116570737cSEric Biggers 101225f9dddbSEric Biggers BUILD_BUG_ON(TEST_SG_TOTAL != 10000); /* for "%u.%u%%" */ 10136570737cSEric Biggers p += scnprintf(p, end - p, "%s%u.%u%%@%s+%u%s", flushtype_str, 101425f9dddbSEric Biggers this_len / 100, this_len % 100, 101525f9dddbSEric Biggers div->offset_relative_to_alignmask ? 101625f9dddbSEric Biggers "alignmask" : "", 101725f9dddbSEric Biggers div->offset, this_len == remaining ? "" : ", "); 101825f9dddbSEric Biggers remaining -= this_len; 101925f9dddbSEric Biggers div++; 102025f9dddbSEric Biggers } while (remaining); 102125f9dddbSEric Biggers 102225f9dddbSEric Biggers return p; 102325f9dddbSEric Biggers } 102425f9dddbSEric Biggers 102525f9dddbSEric Biggers /* Generate a random testvec_config for fuzz testing */ 102625f9dddbSEric Biggers static void generate_random_testvec_config(struct testvec_config *cfg, 102725f9dddbSEric Biggers char *name, size_t max_namelen) 102825f9dddbSEric Biggers { 102925f9dddbSEric Biggers char *p = name; 103025f9dddbSEric Biggers char * const end = name + max_namelen; 103125f9dddbSEric Biggers 103225f9dddbSEric Biggers memset(cfg, 0, sizeof(*cfg)); 103325f9dddbSEric Biggers 103425f9dddbSEric Biggers cfg->name = name; 103525f9dddbSEric Biggers 103625f9dddbSEric Biggers p += scnprintf(p, end - p, "random:"); 103725f9dddbSEric Biggers 103881895a65SJason A. Donenfeld switch (prandom_u32_max(4)) { 1039f17f9e90SEric Biggers case 0: 1040f17f9e90SEric Biggers case 1: 1041f17f9e90SEric Biggers cfg->inplace_mode = OUT_OF_PLACE; 1042f17f9e90SEric Biggers break; 1043f17f9e90SEric Biggers case 2: 1044f17f9e90SEric Biggers cfg->inplace_mode = INPLACE_ONE_SGLIST; 1045f17f9e90SEric Biggers p += scnprintf(p, end - p, " inplace_one_sglist"); 1046f17f9e90SEric Biggers break; 1047f17f9e90SEric Biggers default: 1048f17f9e90SEric Biggers cfg->inplace_mode = INPLACE_TWO_SGLISTS; 1049f17f9e90SEric Biggers p += scnprintf(p, end - p, " inplace_two_sglists"); 1050f17f9e90SEric Biggers break; 105125f9dddbSEric Biggers } 105225f9dddbSEric Biggers 105381895a65SJason A. Donenfeld if (prandom_u32_max(2) == 0) { 105425f9dddbSEric Biggers cfg->req_flags |= CRYPTO_TFM_REQ_MAY_SLEEP; 105525f9dddbSEric Biggers p += scnprintf(p, end - p, " may_sleep"); 105625f9dddbSEric Biggers } 105725f9dddbSEric Biggers 105881895a65SJason A. Donenfeld switch (prandom_u32_max(4)) { 105925f9dddbSEric Biggers case 0: 106025f9dddbSEric Biggers cfg->finalization_type = FINALIZATION_TYPE_FINAL; 106125f9dddbSEric Biggers p += scnprintf(p, end - p, " use_final"); 106225f9dddbSEric Biggers break; 106325f9dddbSEric Biggers case 1: 106425f9dddbSEric Biggers cfg->finalization_type = FINALIZATION_TYPE_FINUP; 106525f9dddbSEric Biggers p += scnprintf(p, end - p, " use_finup"); 106625f9dddbSEric Biggers break; 106725f9dddbSEric Biggers default: 106825f9dddbSEric Biggers cfg->finalization_type = FINALIZATION_TYPE_DIGEST; 106925f9dddbSEric Biggers p += scnprintf(p, end - p, " use_digest"); 107025f9dddbSEric Biggers break; 107125f9dddbSEric Biggers } 107225f9dddbSEric Biggers 10736570737cSEric Biggers if (!(cfg->req_flags & CRYPTO_TFM_REQ_MAY_SLEEP) && 107481895a65SJason A. Donenfeld prandom_u32_max(2) == 0) { 10756570737cSEric Biggers cfg->nosimd = true; 10766570737cSEric Biggers p += scnprintf(p, end - p, " nosimd"); 10776570737cSEric Biggers } 10786570737cSEric Biggers 107925f9dddbSEric Biggers p += scnprintf(p, end - p, " src_divs=["); 108025f9dddbSEric Biggers p = generate_random_sgl_divisions(cfg->src_divs, 108125f9dddbSEric Biggers ARRAY_SIZE(cfg->src_divs), p, end, 108225f9dddbSEric Biggers (cfg->finalization_type != 10836570737cSEric Biggers FINALIZATION_TYPE_DIGEST), 10846570737cSEric Biggers cfg->req_flags); 108525f9dddbSEric Biggers p += scnprintf(p, end - p, "]"); 108625f9dddbSEric Biggers 108781895a65SJason A. Donenfeld if (cfg->inplace_mode == OUT_OF_PLACE && prandom_u32_max(2) == 0) { 108825f9dddbSEric Biggers p += scnprintf(p, end - p, " dst_divs=["); 108925f9dddbSEric Biggers p = generate_random_sgl_divisions(cfg->dst_divs, 109025f9dddbSEric Biggers ARRAY_SIZE(cfg->dst_divs), 10916570737cSEric Biggers p, end, false, 10926570737cSEric Biggers cfg->req_flags); 109325f9dddbSEric Biggers p += scnprintf(p, end - p, "]"); 109425f9dddbSEric Biggers } 109525f9dddbSEric Biggers 109681895a65SJason A. Donenfeld if (prandom_u32_max(2) == 0) { 109781895a65SJason A. Donenfeld cfg->iv_offset = 1 + prandom_u32_max(MAX_ALGAPI_ALIGNMASK); 109825f9dddbSEric Biggers p += scnprintf(p, end - p, " iv_offset=%u", cfg->iv_offset); 109925f9dddbSEric Biggers } 110025f9dddbSEric Biggers 110181895a65SJason A. Donenfeld if (prandom_u32_max(2) == 0) { 110281895a65SJason A. Donenfeld cfg->key_offset = 1 + prandom_u32_max(MAX_ALGAPI_ALIGNMASK); 1103fd8c37c7SEric Biggers p += scnprintf(p, end - p, " key_offset=%u", cfg->key_offset); 1104fd8c37c7SEric Biggers } 1105fd8c37c7SEric Biggers 110625f9dddbSEric Biggers WARN_ON_ONCE(!valid_testvec_config(cfg)); 110725f9dddbSEric Biggers } 1108b55e1a39SEric Biggers 1109b55e1a39SEric Biggers static void crypto_disable_simd_for_test(void) 1110b55e1a39SEric Biggers { 111182e269adSSebastian Andrzej Siewior migrate_disable(); 1112b55e1a39SEric Biggers __this_cpu_write(crypto_simd_disabled_for_test, true); 1113b55e1a39SEric Biggers } 1114b55e1a39SEric Biggers 1115b55e1a39SEric Biggers static void crypto_reenable_simd_for_test(void) 1116b55e1a39SEric Biggers { 1117b55e1a39SEric Biggers __this_cpu_write(crypto_simd_disabled_for_test, false); 111882e269adSSebastian Andrzej Siewior migrate_enable(); 1119b55e1a39SEric Biggers } 1120f2bb770aSEric Biggers 1121f2bb770aSEric Biggers /* 1122f2bb770aSEric Biggers * Given an algorithm name, build the name of the generic implementation of that 1123f2bb770aSEric Biggers * algorithm, assuming the usual naming convention. Specifically, this appends 1124f2bb770aSEric Biggers * "-generic" to every part of the name that is not a template name. Examples: 1125f2bb770aSEric Biggers * 1126f2bb770aSEric Biggers * aes => aes-generic 1127f2bb770aSEric Biggers * cbc(aes) => cbc(aes-generic) 1128f2bb770aSEric Biggers * cts(cbc(aes)) => cts(cbc(aes-generic)) 1129f2bb770aSEric Biggers * rfc7539(chacha20,poly1305) => rfc7539(chacha20-generic,poly1305-generic) 1130f2bb770aSEric Biggers * 1131f2bb770aSEric Biggers * Return: 0 on success, or -ENAMETOOLONG if the generic name would be too long 1132f2bb770aSEric Biggers */ 1133f2bb770aSEric Biggers static int build_generic_driver_name(const char *algname, 1134f2bb770aSEric Biggers char driver_name[CRYPTO_MAX_ALG_NAME]) 1135f2bb770aSEric Biggers { 1136f2bb770aSEric Biggers const char *in = algname; 1137f2bb770aSEric Biggers char *out = driver_name; 1138f2bb770aSEric Biggers size_t len = strlen(algname); 1139f2bb770aSEric Biggers 1140f2bb770aSEric Biggers if (len >= CRYPTO_MAX_ALG_NAME) 1141f2bb770aSEric Biggers goto too_long; 1142f2bb770aSEric Biggers do { 1143f2bb770aSEric Biggers const char *in_saved = in; 1144f2bb770aSEric Biggers 1145f2bb770aSEric Biggers while (*in && *in != '(' && *in != ')' && *in != ',') 1146f2bb770aSEric Biggers *out++ = *in++; 1147f2bb770aSEric Biggers if (*in != '(' && in > in_saved) { 1148f2bb770aSEric Biggers len += 8; 1149f2bb770aSEric Biggers if (len >= CRYPTO_MAX_ALG_NAME) 1150f2bb770aSEric Biggers goto too_long; 1151f2bb770aSEric Biggers memcpy(out, "-generic", 8); 1152f2bb770aSEric Biggers out += 8; 1153f2bb770aSEric Biggers } 1154f2bb770aSEric Biggers } while ((*out++ = *in++) != '\0'); 1155f2bb770aSEric Biggers return 0; 1156f2bb770aSEric Biggers 1157f2bb770aSEric Biggers too_long: 1158f2bb770aSEric Biggers pr_err("alg: generic driver name for \"%s\" would be too long\n", 1159f2bb770aSEric Biggers algname); 1160f2bb770aSEric Biggers return -ENAMETOOLONG; 1161f2bb770aSEric Biggers } 1162b55e1a39SEric Biggers #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 1163b55e1a39SEric Biggers static void crypto_disable_simd_for_test(void) 1164b55e1a39SEric Biggers { 1165b55e1a39SEric Biggers } 1166b55e1a39SEric Biggers 1167b55e1a39SEric Biggers static void crypto_reenable_simd_for_test(void) 1168b55e1a39SEric Biggers { 1169b55e1a39SEric Biggers } 1170b55e1a39SEric Biggers #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 117125f9dddbSEric Biggers 1172d8ea98aaSEric Biggers static int build_hash_sglist(struct test_sglist *tsgl, 1173d8ea98aaSEric Biggers const struct hash_testvec *vec, 1174d8ea98aaSEric Biggers const struct testvec_config *cfg, 1175d8ea98aaSEric Biggers unsigned int alignmask, 1176d8ea98aaSEric Biggers const struct test_sg_division *divs[XBUFSIZE]) 1177d8ea98aaSEric Biggers { 1178d8ea98aaSEric Biggers struct kvec kv; 1179d8ea98aaSEric Biggers struct iov_iter input; 1180d8ea98aaSEric Biggers 1181d8ea98aaSEric Biggers kv.iov_base = (void *)vec->plaintext; 1182d8ea98aaSEric Biggers kv.iov_len = vec->psize; 1183*de4eda9dSAl Viro iov_iter_kvec(&input, ITER_SOURCE, &kv, 1, vec->psize); 1184d8ea98aaSEric Biggers return build_test_sglist(tsgl, cfg->src_divs, alignmask, vec->psize, 1185d8ea98aaSEric Biggers &input, divs); 1186d8ea98aaSEric Biggers } 1187d8ea98aaSEric Biggers 1188d8ea98aaSEric Biggers static int check_hash_result(const char *type, 1189d8ea98aaSEric Biggers const u8 *result, unsigned int digestsize, 1190d8ea98aaSEric Biggers const struct hash_testvec *vec, 1191d8ea98aaSEric Biggers const char *vec_name, 1192d8ea98aaSEric Biggers const char *driver, 1193d8ea98aaSEric Biggers const struct testvec_config *cfg) 1194d8ea98aaSEric Biggers { 1195d8ea98aaSEric Biggers if (memcmp(result, vec->digest, digestsize) != 0) { 1196d8ea98aaSEric Biggers pr_err("alg: %s: %s test failed (wrong result) on test vector %s, cfg=\"%s\"\n", 1197d8ea98aaSEric Biggers type, driver, vec_name, cfg->name); 1198d8ea98aaSEric Biggers return -EINVAL; 1199d8ea98aaSEric Biggers } 1200d8ea98aaSEric Biggers if (!testmgr_is_poison(&result[digestsize], TESTMGR_POISON_LEN)) { 1201d8ea98aaSEric Biggers pr_err("alg: %s: %s overran result buffer on test vector %s, cfg=\"%s\"\n", 1202d8ea98aaSEric Biggers type, driver, vec_name, cfg->name); 1203d8ea98aaSEric Biggers return -EOVERFLOW; 1204d8ea98aaSEric Biggers } 1205d8ea98aaSEric Biggers return 0; 1206d8ea98aaSEric Biggers } 1207d8ea98aaSEric Biggers 1208d8ea98aaSEric Biggers static inline int check_shash_op(const char *op, int err, 1209d8ea98aaSEric Biggers const char *driver, const char *vec_name, 1210d8ea98aaSEric Biggers const struct testvec_config *cfg) 1211d8ea98aaSEric Biggers { 1212d8ea98aaSEric Biggers if (err) 1213d8ea98aaSEric Biggers pr_err("alg: shash: %s %s() failed with err %d on test vector %s, cfg=\"%s\"\n", 1214d8ea98aaSEric Biggers driver, op, err, vec_name, cfg->name); 1215d8ea98aaSEric Biggers return err; 1216d8ea98aaSEric Biggers } 1217d8ea98aaSEric Biggers 1218d8ea98aaSEric Biggers /* Test one hash test vector in one configuration, using the shash API */ 121979cafe9aSEric Biggers static int test_shash_vec_cfg(const struct hash_testvec *vec, 1220d8ea98aaSEric Biggers const char *vec_name, 1221d8ea98aaSEric Biggers const struct testvec_config *cfg, 1222d8ea98aaSEric Biggers struct shash_desc *desc, 1223d8ea98aaSEric Biggers struct test_sglist *tsgl, 1224d8ea98aaSEric Biggers u8 *hashstate) 1225d8ea98aaSEric Biggers { 1226d8ea98aaSEric Biggers struct crypto_shash *tfm = desc->tfm; 1227d8ea98aaSEric Biggers const unsigned int alignmask = crypto_shash_alignmask(tfm); 1228d8ea98aaSEric Biggers const unsigned int digestsize = crypto_shash_digestsize(tfm); 1229d8ea98aaSEric Biggers const unsigned int statesize = crypto_shash_statesize(tfm); 123079cafe9aSEric Biggers const char *driver = crypto_shash_driver_name(tfm); 1231d8ea98aaSEric Biggers const struct test_sg_division *divs[XBUFSIZE]; 1232d8ea98aaSEric Biggers unsigned int i; 1233d8ea98aaSEric Biggers u8 result[HASH_MAX_DIGESTSIZE + TESTMGR_POISON_LEN]; 1234d8ea98aaSEric Biggers int err; 1235d8ea98aaSEric Biggers 1236d8ea98aaSEric Biggers /* Set the key, if specified */ 1237d8ea98aaSEric Biggers if (vec->ksize) { 1238fd8c37c7SEric Biggers err = do_setkey(crypto_shash_setkey, tfm, vec->key, vec->ksize, 1239fd8c37c7SEric Biggers cfg, alignmask); 1240d8ea98aaSEric Biggers if (err) { 1241d8ea98aaSEric Biggers if (err == vec->setkey_error) 1242d8ea98aaSEric Biggers return 0; 1243d8ea98aaSEric Biggers pr_err("alg: shash: %s setkey failed on test vector %s; expected_error=%d, actual_error=%d, flags=%#x\n", 1244d8ea98aaSEric Biggers driver, vec_name, vec->setkey_error, err, 1245d8ea98aaSEric Biggers crypto_shash_get_flags(tfm)); 1246d8ea98aaSEric Biggers return err; 1247d8ea98aaSEric Biggers } 1248d8ea98aaSEric Biggers if (vec->setkey_error) { 1249d8ea98aaSEric Biggers pr_err("alg: shash: %s setkey unexpectedly succeeded on test vector %s; expected_error=%d\n", 1250d8ea98aaSEric Biggers driver, vec_name, vec->setkey_error); 1251d8ea98aaSEric Biggers return -EINVAL; 1252d8ea98aaSEric Biggers } 1253d8ea98aaSEric Biggers } 1254d8ea98aaSEric Biggers 1255d8ea98aaSEric Biggers /* Build the scatterlist for the source data */ 1256d8ea98aaSEric Biggers err = build_hash_sglist(tsgl, vec, cfg, alignmask, divs); 1257d8ea98aaSEric Biggers if (err) { 1258d8ea98aaSEric Biggers pr_err("alg: shash: %s: error preparing scatterlist for test vector %s, cfg=\"%s\"\n", 1259d8ea98aaSEric Biggers driver, vec_name, cfg->name); 1260d8ea98aaSEric Biggers return err; 1261d8ea98aaSEric Biggers } 1262d8ea98aaSEric Biggers 1263d8ea98aaSEric Biggers /* Do the actual hashing */ 1264d8ea98aaSEric Biggers 1265d8ea98aaSEric Biggers testmgr_poison(desc->__ctx, crypto_shash_descsize(tfm)); 1266d8ea98aaSEric Biggers testmgr_poison(result, digestsize + TESTMGR_POISON_LEN); 1267d8ea98aaSEric Biggers 1268d8ea98aaSEric Biggers if (cfg->finalization_type == FINALIZATION_TYPE_DIGEST || 1269d8ea98aaSEric Biggers vec->digest_error) { 1270d8ea98aaSEric Biggers /* Just using digest() */ 1271d8ea98aaSEric Biggers if (tsgl->nents != 1) 1272d8ea98aaSEric Biggers return 0; 1273d8ea98aaSEric Biggers if (cfg->nosimd) 1274d8ea98aaSEric Biggers crypto_disable_simd_for_test(); 1275e40ff6f3SKai Ye err = crypto_shash_digest(desc, sg_virt(&tsgl->sgl[0]), 1276d8ea98aaSEric Biggers tsgl->sgl[0].length, result); 1277d8ea98aaSEric Biggers if (cfg->nosimd) 1278d8ea98aaSEric Biggers crypto_reenable_simd_for_test(); 1279d8ea98aaSEric Biggers if (err) { 1280d8ea98aaSEric Biggers if (err == vec->digest_error) 1281d8ea98aaSEric Biggers return 0; 1282d8ea98aaSEric Biggers pr_err("alg: shash: %s digest() failed on test vector %s; expected_error=%d, actual_error=%d, cfg=\"%s\"\n", 1283d8ea98aaSEric Biggers driver, vec_name, vec->digest_error, err, 1284d8ea98aaSEric Biggers cfg->name); 1285d8ea98aaSEric Biggers return err; 1286d8ea98aaSEric Biggers } 1287d8ea98aaSEric Biggers if (vec->digest_error) { 1288d8ea98aaSEric Biggers pr_err("alg: shash: %s digest() unexpectedly succeeded on test vector %s; expected_error=%d, cfg=\"%s\"\n", 1289d8ea98aaSEric Biggers driver, vec_name, vec->digest_error, cfg->name); 1290d8ea98aaSEric Biggers return -EINVAL; 1291d8ea98aaSEric Biggers } 1292d8ea98aaSEric Biggers goto result_ready; 1293d8ea98aaSEric Biggers } 1294d8ea98aaSEric Biggers 1295d8ea98aaSEric Biggers /* Using init(), zero or more update(), then final() or finup() */ 1296d8ea98aaSEric Biggers 1297d8ea98aaSEric Biggers if (cfg->nosimd) 1298d8ea98aaSEric Biggers crypto_disable_simd_for_test(); 1299d8ea98aaSEric Biggers err = crypto_shash_init(desc); 1300d8ea98aaSEric Biggers if (cfg->nosimd) 1301d8ea98aaSEric Biggers crypto_reenable_simd_for_test(); 1302d8ea98aaSEric Biggers err = check_shash_op("init", err, driver, vec_name, cfg); 1303d8ea98aaSEric Biggers if (err) 1304d8ea98aaSEric Biggers return err; 1305d8ea98aaSEric Biggers 1306d8ea98aaSEric Biggers for (i = 0; i < tsgl->nents; i++) { 1307d8ea98aaSEric Biggers if (i + 1 == tsgl->nents && 1308d8ea98aaSEric Biggers cfg->finalization_type == FINALIZATION_TYPE_FINUP) { 1309d8ea98aaSEric Biggers if (divs[i]->nosimd) 1310d8ea98aaSEric Biggers crypto_disable_simd_for_test(); 1311e40ff6f3SKai Ye err = crypto_shash_finup(desc, sg_virt(&tsgl->sgl[i]), 1312d8ea98aaSEric Biggers tsgl->sgl[i].length, result); 1313d8ea98aaSEric Biggers if (divs[i]->nosimd) 1314d8ea98aaSEric Biggers crypto_reenable_simd_for_test(); 1315d8ea98aaSEric Biggers err = check_shash_op("finup", err, driver, vec_name, 1316d8ea98aaSEric Biggers cfg); 1317d8ea98aaSEric Biggers if (err) 1318d8ea98aaSEric Biggers return err; 1319d8ea98aaSEric Biggers goto result_ready; 1320d8ea98aaSEric Biggers } 1321d8ea98aaSEric Biggers if (divs[i]->nosimd) 1322d8ea98aaSEric Biggers crypto_disable_simd_for_test(); 1323e40ff6f3SKai Ye err = crypto_shash_update(desc, sg_virt(&tsgl->sgl[i]), 1324d8ea98aaSEric Biggers tsgl->sgl[i].length); 1325d8ea98aaSEric Biggers if (divs[i]->nosimd) 1326d8ea98aaSEric Biggers crypto_reenable_simd_for_test(); 1327d8ea98aaSEric Biggers err = check_shash_op("update", err, driver, vec_name, cfg); 1328d8ea98aaSEric Biggers if (err) 1329d8ea98aaSEric Biggers return err; 1330d8ea98aaSEric Biggers if (divs[i]->flush_type == FLUSH_TYPE_REIMPORT) { 1331d8ea98aaSEric Biggers /* Test ->export() and ->import() */ 1332d8ea98aaSEric Biggers testmgr_poison(hashstate + statesize, 1333d8ea98aaSEric Biggers TESTMGR_POISON_LEN); 1334d8ea98aaSEric Biggers err = crypto_shash_export(desc, hashstate); 1335d8ea98aaSEric Biggers err = check_shash_op("export", err, driver, vec_name, 1336d8ea98aaSEric Biggers cfg); 1337d8ea98aaSEric Biggers if (err) 1338d8ea98aaSEric Biggers return err; 1339d8ea98aaSEric Biggers if (!testmgr_is_poison(hashstate + statesize, 1340d8ea98aaSEric Biggers TESTMGR_POISON_LEN)) { 1341d8ea98aaSEric Biggers pr_err("alg: shash: %s export() overran state buffer on test vector %s, cfg=\"%s\"\n", 1342d8ea98aaSEric Biggers driver, vec_name, cfg->name); 1343d8ea98aaSEric Biggers return -EOVERFLOW; 1344d8ea98aaSEric Biggers } 1345d8ea98aaSEric Biggers testmgr_poison(desc->__ctx, crypto_shash_descsize(tfm)); 1346d8ea98aaSEric Biggers err = crypto_shash_import(desc, hashstate); 1347d8ea98aaSEric Biggers err = check_shash_op("import", err, driver, vec_name, 1348d8ea98aaSEric Biggers cfg); 1349d8ea98aaSEric Biggers if (err) 1350d8ea98aaSEric Biggers return err; 1351d8ea98aaSEric Biggers } 1352d8ea98aaSEric Biggers } 1353d8ea98aaSEric Biggers 1354d8ea98aaSEric Biggers if (cfg->nosimd) 1355d8ea98aaSEric Biggers crypto_disable_simd_for_test(); 1356d8ea98aaSEric Biggers err = crypto_shash_final(desc, result); 1357d8ea98aaSEric Biggers if (cfg->nosimd) 1358d8ea98aaSEric Biggers crypto_reenable_simd_for_test(); 1359d8ea98aaSEric Biggers err = check_shash_op("final", err, driver, vec_name, cfg); 1360d8ea98aaSEric Biggers if (err) 1361d8ea98aaSEric Biggers return err; 1362d8ea98aaSEric Biggers result_ready: 1363d8ea98aaSEric Biggers return check_hash_result("shash", result, digestsize, vec, vec_name, 1364d8ea98aaSEric Biggers driver, cfg); 1365d8ea98aaSEric Biggers } 1366d8ea98aaSEric Biggers 13676570737cSEric Biggers static int do_ahash_op(int (*op)(struct ahash_request *req), 13686570737cSEric Biggers struct ahash_request *req, 13696570737cSEric Biggers struct crypto_wait *wait, bool nosimd) 13706570737cSEric Biggers { 13716570737cSEric Biggers int err; 13726570737cSEric Biggers 13736570737cSEric Biggers if (nosimd) 13746570737cSEric Biggers crypto_disable_simd_for_test(); 13756570737cSEric Biggers 13766570737cSEric Biggers err = op(req); 13776570737cSEric Biggers 13786570737cSEric Biggers if (nosimd) 13796570737cSEric Biggers crypto_reenable_simd_for_test(); 13806570737cSEric Biggers 13816570737cSEric Biggers return crypto_wait_req(err, wait); 13826570737cSEric Biggers } 13836570737cSEric Biggers 1384d8ea98aaSEric Biggers static int check_nonfinal_ahash_op(const char *op, int err, 13854cc2dcf9SEric Biggers u8 *result, unsigned int digestsize, 1386951d1332SEric Biggers const char *driver, const char *vec_name, 13874cc2dcf9SEric Biggers const struct testvec_config *cfg) 1388466d7b9fSKamil Konieczny { 13894cc2dcf9SEric Biggers if (err) { 1390d8ea98aaSEric Biggers pr_err("alg: ahash: %s %s() failed with err %d on test vector %s, cfg=\"%s\"\n", 1391951d1332SEric Biggers driver, op, err, vec_name, cfg->name); 13924cc2dcf9SEric Biggers return err; 13934cc2dcf9SEric Biggers } 13944cc2dcf9SEric Biggers if (!testmgr_is_poison(result, digestsize)) { 1395d8ea98aaSEric Biggers pr_err("alg: ahash: %s %s() used result buffer on test vector %s, cfg=\"%s\"\n", 1396951d1332SEric Biggers driver, op, vec_name, cfg->name); 1397466d7b9fSKamil Konieczny return -EINVAL; 1398466d7b9fSKamil Konieczny } 1399466d7b9fSKamil Konieczny return 0; 1400466d7b9fSKamil Konieczny } 1401466d7b9fSKamil Konieczny 1402d8ea98aaSEric Biggers /* Test one hash test vector in one configuration, using the ahash API */ 140379cafe9aSEric Biggers static int test_ahash_vec_cfg(const struct hash_testvec *vec, 1404951d1332SEric Biggers const char *vec_name, 14054cc2dcf9SEric Biggers const struct testvec_config *cfg, 14064cc2dcf9SEric Biggers struct ahash_request *req, 14074cc2dcf9SEric Biggers struct test_sglist *tsgl, 14084cc2dcf9SEric Biggers u8 *hashstate) 1409018ba95cSWang, Rui Y { 14104cc2dcf9SEric Biggers struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 14114cc2dcf9SEric Biggers const unsigned int alignmask = crypto_ahash_alignmask(tfm); 14124cc2dcf9SEric Biggers const unsigned int digestsize = crypto_ahash_digestsize(tfm); 14134cc2dcf9SEric Biggers const unsigned int statesize = crypto_ahash_statesize(tfm); 141479cafe9aSEric Biggers const char *driver = crypto_ahash_driver_name(tfm); 14154cc2dcf9SEric Biggers const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags; 14164cc2dcf9SEric Biggers const struct test_sg_division *divs[XBUFSIZE]; 14174cc2dcf9SEric Biggers DECLARE_CRYPTO_WAIT(wait); 14184cc2dcf9SEric Biggers unsigned int i; 14194cc2dcf9SEric Biggers struct scatterlist *pending_sgl; 14204cc2dcf9SEric Biggers unsigned int pending_len; 14214cc2dcf9SEric Biggers u8 result[HASH_MAX_DIGESTSIZE + TESTMGR_POISON_LEN]; 14224cc2dcf9SEric Biggers int err; 1423018ba95cSWang, Rui Y 14244cc2dcf9SEric Biggers /* Set the key, if specified */ 14254cc2dcf9SEric Biggers if (vec->ksize) { 1426fd8c37c7SEric Biggers err = do_setkey(crypto_ahash_setkey, tfm, vec->key, vec->ksize, 1427fd8c37c7SEric Biggers cfg, alignmask); 14284cc2dcf9SEric Biggers if (err) { 14295283a8eeSEric Biggers if (err == vec->setkey_error) 14305283a8eeSEric Biggers return 0; 1431d8ea98aaSEric Biggers pr_err("alg: ahash: %s setkey failed on test vector %s; expected_error=%d, actual_error=%d, flags=%#x\n", 1432951d1332SEric Biggers driver, vec_name, vec->setkey_error, err, 14334cc2dcf9SEric Biggers crypto_ahash_get_flags(tfm)); 14344cc2dcf9SEric Biggers return err; 1435da7f033dSHerbert Xu } 14365283a8eeSEric Biggers if (vec->setkey_error) { 1437d8ea98aaSEric Biggers pr_err("alg: ahash: %s setkey unexpectedly succeeded on test vector %s; expected_error=%d\n", 1438951d1332SEric Biggers driver, vec_name, vec->setkey_error); 14395283a8eeSEric Biggers return -EINVAL; 14405283a8eeSEric Biggers } 1441da7f033dSHerbert Xu } 1442da7f033dSHerbert Xu 14434cc2dcf9SEric Biggers /* Build the scatterlist for the source data */ 1444d8ea98aaSEric Biggers err = build_hash_sglist(tsgl, vec, cfg, alignmask, divs); 14454cc2dcf9SEric Biggers if (err) { 1446d8ea98aaSEric Biggers pr_err("alg: ahash: %s: error preparing scatterlist for test vector %s, cfg=\"%s\"\n", 1447951d1332SEric Biggers driver, vec_name, cfg->name); 14484cc2dcf9SEric Biggers return err; 1449a8f1a052SDavid S. Miller } 1450da7f033dSHerbert Xu 14514cc2dcf9SEric Biggers /* Do the actual hashing */ 1452da7f033dSHerbert Xu 14534cc2dcf9SEric Biggers testmgr_poison(req->__ctx, crypto_ahash_reqsize(tfm)); 14544cc2dcf9SEric Biggers testmgr_poison(result, digestsize + TESTMGR_POISON_LEN); 145576715095SGilad Ben-Yossef 14565283a8eeSEric Biggers if (cfg->finalization_type == FINALIZATION_TYPE_DIGEST || 14575283a8eeSEric Biggers vec->digest_error) { 14584cc2dcf9SEric Biggers /* Just using digest() */ 14594cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, crypto_req_done, 14607f397136SGilad Ben-Yossef &wait); 14614cc2dcf9SEric Biggers ahash_request_set_crypt(req, tsgl->sgl, result, vec->psize); 14626570737cSEric Biggers err = do_ahash_op(crypto_ahash_digest, req, &wait, cfg->nosimd); 14634cc2dcf9SEric Biggers if (err) { 14645283a8eeSEric Biggers if (err == vec->digest_error) 14655283a8eeSEric Biggers return 0; 1466d8ea98aaSEric Biggers pr_err("alg: ahash: %s digest() failed on test vector %s; expected_error=%d, actual_error=%d, cfg=\"%s\"\n", 1467951d1332SEric Biggers driver, vec_name, vec->digest_error, err, 14685283a8eeSEric Biggers cfg->name); 14694cc2dcf9SEric Biggers return err; 1470018ba95cSWang, Rui Y } 14715283a8eeSEric Biggers if (vec->digest_error) { 1472d8ea98aaSEric Biggers pr_err("alg: ahash: %s digest() unexpectedly succeeded on test vector %s; expected_error=%d, cfg=\"%s\"\n", 1473951d1332SEric Biggers driver, vec_name, vec->digest_error, cfg->name); 14745283a8eeSEric Biggers return -EINVAL; 14755283a8eeSEric Biggers } 14764cc2dcf9SEric Biggers goto result_ready; 1477018ba95cSWang, Rui Y } 14784cc2dcf9SEric Biggers 14794cc2dcf9SEric Biggers /* Using init(), zero or more update(), then final() or finup() */ 14804cc2dcf9SEric Biggers 14814cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, crypto_req_done, &wait); 14824cc2dcf9SEric Biggers ahash_request_set_crypt(req, NULL, result, 0); 14836570737cSEric Biggers err = do_ahash_op(crypto_ahash_init, req, &wait, cfg->nosimd); 1484d8ea98aaSEric Biggers err = check_nonfinal_ahash_op("init", err, result, digestsize, 1485951d1332SEric Biggers driver, vec_name, cfg); 14864cc2dcf9SEric Biggers if (err) 14874cc2dcf9SEric Biggers return err; 14884cc2dcf9SEric Biggers 14894cc2dcf9SEric Biggers pending_sgl = NULL; 14904cc2dcf9SEric Biggers pending_len = 0; 14914cc2dcf9SEric Biggers for (i = 0; i < tsgl->nents; i++) { 14924cc2dcf9SEric Biggers if (divs[i]->flush_type != FLUSH_TYPE_NONE && 14934cc2dcf9SEric Biggers pending_sgl != NULL) { 14944cc2dcf9SEric Biggers /* update() with the pending data */ 14954cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, 14964cc2dcf9SEric Biggers crypto_req_done, &wait); 14974cc2dcf9SEric Biggers ahash_request_set_crypt(req, pending_sgl, result, 14984cc2dcf9SEric Biggers pending_len); 14996570737cSEric Biggers err = do_ahash_op(crypto_ahash_update, req, &wait, 15006570737cSEric Biggers divs[i]->nosimd); 1501d8ea98aaSEric Biggers err = check_nonfinal_ahash_op("update", err, 15024cc2dcf9SEric Biggers result, digestsize, 1503951d1332SEric Biggers driver, vec_name, cfg); 15044cc2dcf9SEric Biggers if (err) 15054cc2dcf9SEric Biggers return err; 15064cc2dcf9SEric Biggers pending_sgl = NULL; 15074cc2dcf9SEric Biggers pending_len = 0; 1508018ba95cSWang, Rui Y } 15094cc2dcf9SEric Biggers if (divs[i]->flush_type == FLUSH_TYPE_REIMPORT) { 15104cc2dcf9SEric Biggers /* Test ->export() and ->import() */ 15114cc2dcf9SEric Biggers testmgr_poison(hashstate + statesize, 15124cc2dcf9SEric Biggers TESTMGR_POISON_LEN); 15134cc2dcf9SEric Biggers err = crypto_ahash_export(req, hashstate); 1514d8ea98aaSEric Biggers err = check_nonfinal_ahash_op("export", err, 15154cc2dcf9SEric Biggers result, digestsize, 1516951d1332SEric Biggers driver, vec_name, cfg); 15174cc2dcf9SEric Biggers if (err) 15184cc2dcf9SEric Biggers return err; 15194cc2dcf9SEric Biggers if (!testmgr_is_poison(hashstate + statesize, 15204cc2dcf9SEric Biggers TESTMGR_POISON_LEN)) { 1521d8ea98aaSEric Biggers pr_err("alg: ahash: %s export() overran state buffer on test vector %s, cfg=\"%s\"\n", 1522951d1332SEric Biggers driver, vec_name, cfg->name); 15234cc2dcf9SEric Biggers return -EOVERFLOW; 15244cc2dcf9SEric Biggers } 15254cc2dcf9SEric Biggers 15264cc2dcf9SEric Biggers testmgr_poison(req->__ctx, crypto_ahash_reqsize(tfm)); 15274cc2dcf9SEric Biggers err = crypto_ahash_import(req, hashstate); 1528d8ea98aaSEric Biggers err = check_nonfinal_ahash_op("import", err, 15294cc2dcf9SEric Biggers result, digestsize, 1530951d1332SEric Biggers driver, vec_name, cfg); 15314cc2dcf9SEric Biggers if (err) 15324cc2dcf9SEric Biggers return err; 15334cc2dcf9SEric Biggers } 15344cc2dcf9SEric Biggers if (pending_sgl == NULL) 15354cc2dcf9SEric Biggers pending_sgl = &tsgl->sgl[i]; 15364cc2dcf9SEric Biggers pending_len += tsgl->sgl[i].length; 15374cc2dcf9SEric Biggers } 15384cc2dcf9SEric Biggers 15394cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, crypto_req_done, &wait); 15404cc2dcf9SEric Biggers ahash_request_set_crypt(req, pending_sgl, result, pending_len); 15414cc2dcf9SEric Biggers if (cfg->finalization_type == FINALIZATION_TYPE_FINAL) { 15424cc2dcf9SEric Biggers /* finish with update() and final() */ 15436570737cSEric Biggers err = do_ahash_op(crypto_ahash_update, req, &wait, cfg->nosimd); 1544d8ea98aaSEric Biggers err = check_nonfinal_ahash_op("update", err, result, digestsize, 1545951d1332SEric Biggers driver, vec_name, cfg); 15464cc2dcf9SEric Biggers if (err) 15474cc2dcf9SEric Biggers return err; 15486570737cSEric Biggers err = do_ahash_op(crypto_ahash_final, req, &wait, cfg->nosimd); 15494cc2dcf9SEric Biggers if (err) { 1550d8ea98aaSEric Biggers pr_err("alg: ahash: %s final() failed with err %d on test vector %s, cfg=\"%s\"\n", 1551951d1332SEric Biggers driver, err, vec_name, cfg->name); 15524cc2dcf9SEric Biggers return err; 15534cc2dcf9SEric Biggers } 15544cc2dcf9SEric Biggers } else { 15554cc2dcf9SEric Biggers /* finish with finup() */ 15566570737cSEric Biggers err = do_ahash_op(crypto_ahash_finup, req, &wait, cfg->nosimd); 15574cc2dcf9SEric Biggers if (err) { 1558d8ea98aaSEric Biggers pr_err("alg: ahash: %s finup() failed with err %d on test vector %s, cfg=\"%s\"\n", 1559951d1332SEric Biggers driver, err, vec_name, cfg->name); 15604cc2dcf9SEric Biggers return err; 1561018ba95cSWang, Rui Y } 1562018ba95cSWang, Rui Y } 1563018ba95cSWang, Rui Y 15644cc2dcf9SEric Biggers result_ready: 1565d8ea98aaSEric Biggers return check_hash_result("ahash", result, digestsize, vec, vec_name, 1566d8ea98aaSEric Biggers driver, cfg); 1567da5ffe11SJussi Kivilinna } 1568da5ffe11SJussi Kivilinna 156979cafe9aSEric Biggers static int test_hash_vec_cfg(const struct hash_testvec *vec, 1570d8ea98aaSEric Biggers const char *vec_name, 1571d8ea98aaSEric Biggers const struct testvec_config *cfg, 1572d8ea98aaSEric Biggers struct ahash_request *req, 1573d8ea98aaSEric Biggers struct shash_desc *desc, 1574d8ea98aaSEric Biggers struct test_sglist *tsgl, 1575d8ea98aaSEric Biggers u8 *hashstate) 1576d8ea98aaSEric Biggers { 1577d8ea98aaSEric Biggers int err; 1578d8ea98aaSEric Biggers 1579d8ea98aaSEric Biggers /* 1580d8ea98aaSEric Biggers * For algorithms implemented as "shash", most bugs will be detected by 1581d8ea98aaSEric Biggers * both the shash and ahash tests. Test the shash API first so that the 1582d8ea98aaSEric Biggers * failures involve less indirection, so are easier to debug. 1583d8ea98aaSEric Biggers */ 1584d8ea98aaSEric Biggers 1585d8ea98aaSEric Biggers if (desc) { 158679cafe9aSEric Biggers err = test_shash_vec_cfg(vec, vec_name, cfg, desc, tsgl, 1587d8ea98aaSEric Biggers hashstate); 1588d8ea98aaSEric Biggers if (err) 1589d8ea98aaSEric Biggers return err; 1590d8ea98aaSEric Biggers } 1591d8ea98aaSEric Biggers 159279cafe9aSEric Biggers return test_ahash_vec_cfg(vec, vec_name, cfg, req, tsgl, hashstate); 1593da5ffe11SJussi Kivilinna } 1594da5ffe11SJussi Kivilinna 159579cafe9aSEric Biggers static int test_hash_vec(const struct hash_testvec *vec, unsigned int vec_num, 159679cafe9aSEric Biggers struct ahash_request *req, struct shash_desc *desc, 159779cafe9aSEric Biggers struct test_sglist *tsgl, u8 *hashstate) 15984cc2dcf9SEric Biggers { 1599951d1332SEric Biggers char vec_name[16]; 16004cc2dcf9SEric Biggers unsigned int i; 16014cc2dcf9SEric Biggers int err; 16024cc2dcf9SEric Biggers 1603951d1332SEric Biggers sprintf(vec_name, "%u", vec_num); 1604951d1332SEric Biggers 16054cc2dcf9SEric Biggers for (i = 0; i < ARRAY_SIZE(default_hash_testvec_configs); i++) { 160679cafe9aSEric Biggers err = test_hash_vec_cfg(vec, vec_name, 16074cc2dcf9SEric Biggers &default_hash_testvec_configs[i], 1608d8ea98aaSEric Biggers req, desc, tsgl, hashstate); 16094cc2dcf9SEric Biggers if (err) 16104cc2dcf9SEric Biggers return err; 16114cc2dcf9SEric Biggers } 16124cc2dcf9SEric Biggers 16134cc2dcf9SEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 16144cc2dcf9SEric Biggers if (!noextratests) { 16154cc2dcf9SEric Biggers struct testvec_config cfg; 16164cc2dcf9SEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 16174cc2dcf9SEric Biggers 16184cc2dcf9SEric Biggers for (i = 0; i < fuzz_iterations; i++) { 16194cc2dcf9SEric Biggers generate_random_testvec_config(&cfg, cfgname, 16204cc2dcf9SEric Biggers sizeof(cfgname)); 162179cafe9aSEric Biggers err = test_hash_vec_cfg(vec, vec_name, &cfg, 1622d8ea98aaSEric Biggers req, desc, tsgl, hashstate); 16234cc2dcf9SEric Biggers if (err) 16244cc2dcf9SEric Biggers return err; 1625e63e1b0dSEric Biggers cond_resched(); 16264cc2dcf9SEric Biggers } 16274cc2dcf9SEric Biggers } 16284cc2dcf9SEric Biggers #endif 16294cc2dcf9SEric Biggers return 0; 16304cc2dcf9SEric Biggers } 16314cc2dcf9SEric Biggers 16329a8a6b3fSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 16339a8a6b3fSEric Biggers /* 16349a8a6b3fSEric Biggers * Generate a hash test vector from the given implementation. 16359a8a6b3fSEric Biggers * Assumes the buffers in 'vec' were already allocated. 16369a8a6b3fSEric Biggers */ 1637149c4e6eSArnd Bergmann static void generate_random_hash_testvec(struct shash_desc *desc, 16389a8a6b3fSEric Biggers struct hash_testvec *vec, 16399a8a6b3fSEric Biggers unsigned int maxkeysize, 16409a8a6b3fSEric Biggers unsigned int maxdatasize, 16419a8a6b3fSEric Biggers char *name, size_t max_namelen) 16429a8a6b3fSEric Biggers { 16439a8a6b3fSEric Biggers /* Data */ 16449a8a6b3fSEric Biggers vec->psize = generate_random_length(maxdatasize); 16459a8a6b3fSEric Biggers generate_random_bytes((u8 *)vec->plaintext, vec->psize); 16469a8a6b3fSEric Biggers 16479a8a6b3fSEric Biggers /* 16489a8a6b3fSEric Biggers * Key: length in range [1, maxkeysize], but usually choose maxkeysize. 16499a8a6b3fSEric Biggers * If algorithm is unkeyed, then maxkeysize == 0 and set ksize = 0. 16509a8a6b3fSEric Biggers */ 16519a8a6b3fSEric Biggers vec->setkey_error = 0; 16529a8a6b3fSEric Biggers vec->ksize = 0; 16539a8a6b3fSEric Biggers if (maxkeysize) { 16549a8a6b3fSEric Biggers vec->ksize = maxkeysize; 165581895a65SJason A. Donenfeld if (prandom_u32_max(4) == 0) 165681895a65SJason A. Donenfeld vec->ksize = 1 + prandom_u32_max(maxkeysize); 16579a8a6b3fSEric Biggers generate_random_bytes((u8 *)vec->key, vec->ksize); 16589a8a6b3fSEric Biggers 1659149c4e6eSArnd Bergmann vec->setkey_error = crypto_shash_setkey(desc->tfm, vec->key, 16609a8a6b3fSEric Biggers vec->ksize); 16619a8a6b3fSEric Biggers /* If the key couldn't be set, no need to continue to digest. */ 16629a8a6b3fSEric Biggers if (vec->setkey_error) 16639a8a6b3fSEric Biggers goto done; 16649a8a6b3fSEric Biggers } 16659a8a6b3fSEric Biggers 16669a8a6b3fSEric Biggers /* Digest */ 16679a8a6b3fSEric Biggers vec->digest_error = crypto_shash_digest(desc, vec->plaintext, 16689a8a6b3fSEric Biggers vec->psize, (u8 *)vec->digest); 16699a8a6b3fSEric Biggers done: 16709a8a6b3fSEric Biggers snprintf(name, max_namelen, "\"random: psize=%u ksize=%u\"", 16719a8a6b3fSEric Biggers vec->psize, vec->ksize); 16729a8a6b3fSEric Biggers } 16739a8a6b3fSEric Biggers 16749a8a6b3fSEric Biggers /* 16759a8a6b3fSEric Biggers * Test the hash algorithm represented by @req against the corresponding generic 16769a8a6b3fSEric Biggers * implementation, if one is available. 16779a8a6b3fSEric Biggers */ 167879cafe9aSEric Biggers static int test_hash_vs_generic_impl(const char *generic_driver, 16799a8a6b3fSEric Biggers unsigned int maxkeysize, 16809a8a6b3fSEric Biggers struct ahash_request *req, 1681d8ea98aaSEric Biggers struct shash_desc *desc, 16829a8a6b3fSEric Biggers struct test_sglist *tsgl, 16839a8a6b3fSEric Biggers u8 *hashstate) 16849a8a6b3fSEric Biggers { 16859a8a6b3fSEric Biggers struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 16869a8a6b3fSEric Biggers const unsigned int digestsize = crypto_ahash_digestsize(tfm); 16879a8a6b3fSEric Biggers const unsigned int blocksize = crypto_ahash_blocksize(tfm); 16889a8a6b3fSEric Biggers const unsigned int maxdatasize = (2 * PAGE_SIZE) - TESTMGR_POISON_LEN; 16899a8a6b3fSEric Biggers const char *algname = crypto_hash_alg_common(tfm)->base.cra_name; 169079cafe9aSEric Biggers const char *driver = crypto_ahash_driver_name(tfm); 16919a8a6b3fSEric Biggers char _generic_driver[CRYPTO_MAX_ALG_NAME]; 16929a8a6b3fSEric Biggers struct crypto_shash *generic_tfm = NULL; 1693149c4e6eSArnd Bergmann struct shash_desc *generic_desc = NULL; 16949a8a6b3fSEric Biggers unsigned int i; 16959a8a6b3fSEric Biggers struct hash_testvec vec = { 0 }; 16969a8a6b3fSEric Biggers char vec_name[64]; 16976b5ca646SArnd Bergmann struct testvec_config *cfg; 16989a8a6b3fSEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 16999a8a6b3fSEric Biggers int err; 17009a8a6b3fSEric Biggers 17019a8a6b3fSEric Biggers if (noextratests) 17029a8a6b3fSEric Biggers return 0; 17039a8a6b3fSEric Biggers 17049a8a6b3fSEric Biggers if (!generic_driver) { /* Use default naming convention? */ 17059a8a6b3fSEric Biggers err = build_generic_driver_name(algname, _generic_driver); 17069a8a6b3fSEric Biggers if (err) 17079a8a6b3fSEric Biggers return err; 17089a8a6b3fSEric Biggers generic_driver = _generic_driver; 17099a8a6b3fSEric Biggers } 17109a8a6b3fSEric Biggers 17119a8a6b3fSEric Biggers if (strcmp(generic_driver, driver) == 0) /* Already the generic impl? */ 17129a8a6b3fSEric Biggers return 0; 17139a8a6b3fSEric Biggers 17149a8a6b3fSEric Biggers generic_tfm = crypto_alloc_shash(generic_driver, 0, 0); 17159a8a6b3fSEric Biggers if (IS_ERR(generic_tfm)) { 17169a8a6b3fSEric Biggers err = PTR_ERR(generic_tfm); 17179a8a6b3fSEric Biggers if (err == -ENOENT) { 17189a8a6b3fSEric Biggers pr_warn("alg: hash: skipping comparison tests for %s because %s is unavailable\n", 17199a8a6b3fSEric Biggers driver, generic_driver); 17209a8a6b3fSEric Biggers return 0; 17219a8a6b3fSEric Biggers } 17229a8a6b3fSEric Biggers pr_err("alg: hash: error allocating %s (generic impl of %s): %d\n", 17239a8a6b3fSEric Biggers generic_driver, algname, err); 17249a8a6b3fSEric Biggers return err; 17259a8a6b3fSEric Biggers } 17269a8a6b3fSEric Biggers 17276b5ca646SArnd Bergmann cfg = kzalloc(sizeof(*cfg), GFP_KERNEL); 17286b5ca646SArnd Bergmann if (!cfg) { 17296b5ca646SArnd Bergmann err = -ENOMEM; 17306b5ca646SArnd Bergmann goto out; 17316b5ca646SArnd Bergmann } 17326b5ca646SArnd Bergmann 1733149c4e6eSArnd Bergmann generic_desc = kzalloc(sizeof(*desc) + 1734149c4e6eSArnd Bergmann crypto_shash_descsize(generic_tfm), GFP_KERNEL); 1735149c4e6eSArnd Bergmann if (!generic_desc) { 1736149c4e6eSArnd Bergmann err = -ENOMEM; 1737149c4e6eSArnd Bergmann goto out; 1738149c4e6eSArnd Bergmann } 1739149c4e6eSArnd Bergmann generic_desc->tfm = generic_tfm; 1740149c4e6eSArnd Bergmann 17419a8a6b3fSEric Biggers /* Check the algorithm properties for consistency. */ 17429a8a6b3fSEric Biggers 17439a8a6b3fSEric Biggers if (digestsize != crypto_shash_digestsize(generic_tfm)) { 17449a8a6b3fSEric Biggers pr_err("alg: hash: digestsize for %s (%u) doesn't match generic impl (%u)\n", 17459a8a6b3fSEric Biggers driver, digestsize, 17469a8a6b3fSEric Biggers crypto_shash_digestsize(generic_tfm)); 17479a8a6b3fSEric Biggers err = -EINVAL; 17489a8a6b3fSEric Biggers goto out; 17499a8a6b3fSEric Biggers } 17509a8a6b3fSEric Biggers 17519a8a6b3fSEric Biggers if (blocksize != crypto_shash_blocksize(generic_tfm)) { 17529a8a6b3fSEric Biggers pr_err("alg: hash: blocksize for %s (%u) doesn't match generic impl (%u)\n", 17539a8a6b3fSEric Biggers driver, blocksize, crypto_shash_blocksize(generic_tfm)); 17549a8a6b3fSEric Biggers err = -EINVAL; 17559a8a6b3fSEric Biggers goto out; 17569a8a6b3fSEric Biggers } 17579a8a6b3fSEric Biggers 17589a8a6b3fSEric Biggers /* 17599a8a6b3fSEric Biggers * Now generate test vectors using the generic implementation, and test 17609a8a6b3fSEric Biggers * the other implementation against them. 17619a8a6b3fSEric Biggers */ 17629a8a6b3fSEric Biggers 17639a8a6b3fSEric Biggers vec.key = kmalloc(maxkeysize, GFP_KERNEL); 17649a8a6b3fSEric Biggers vec.plaintext = kmalloc(maxdatasize, GFP_KERNEL); 17659a8a6b3fSEric Biggers vec.digest = kmalloc(digestsize, GFP_KERNEL); 17669a8a6b3fSEric Biggers if (!vec.key || !vec.plaintext || !vec.digest) { 17679a8a6b3fSEric Biggers err = -ENOMEM; 17689a8a6b3fSEric Biggers goto out; 17699a8a6b3fSEric Biggers } 17709a8a6b3fSEric Biggers 17719a8a6b3fSEric Biggers for (i = 0; i < fuzz_iterations * 8; i++) { 1772149c4e6eSArnd Bergmann generate_random_hash_testvec(generic_desc, &vec, 17739a8a6b3fSEric Biggers maxkeysize, maxdatasize, 17749a8a6b3fSEric Biggers vec_name, sizeof(vec_name)); 17756b5ca646SArnd Bergmann generate_random_testvec_config(cfg, cfgname, sizeof(cfgname)); 17769a8a6b3fSEric Biggers 177779cafe9aSEric Biggers err = test_hash_vec_cfg(&vec, vec_name, cfg, 1778d8ea98aaSEric Biggers req, desc, tsgl, hashstate); 17799a8a6b3fSEric Biggers if (err) 17809a8a6b3fSEric Biggers goto out; 17819a8a6b3fSEric Biggers cond_resched(); 17829a8a6b3fSEric Biggers } 17839a8a6b3fSEric Biggers err = 0; 17849a8a6b3fSEric Biggers out: 17856b5ca646SArnd Bergmann kfree(cfg); 17869a8a6b3fSEric Biggers kfree(vec.key); 17879a8a6b3fSEric Biggers kfree(vec.plaintext); 17889a8a6b3fSEric Biggers kfree(vec.digest); 17899a8a6b3fSEric Biggers crypto_free_shash(generic_tfm); 1790453431a5SWaiman Long kfree_sensitive(generic_desc); 17919a8a6b3fSEric Biggers return err; 17929a8a6b3fSEric Biggers } 17939a8a6b3fSEric Biggers #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 179479cafe9aSEric Biggers static int test_hash_vs_generic_impl(const char *generic_driver, 17959a8a6b3fSEric Biggers unsigned int maxkeysize, 17969a8a6b3fSEric Biggers struct ahash_request *req, 1797d8ea98aaSEric Biggers struct shash_desc *desc, 17989a8a6b3fSEric Biggers struct test_sglist *tsgl, 17999a8a6b3fSEric Biggers u8 *hashstate) 18009a8a6b3fSEric Biggers { 18019a8a6b3fSEric Biggers return 0; 18029a8a6b3fSEric Biggers } 18039a8a6b3fSEric Biggers #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 18049a8a6b3fSEric Biggers 1805d8ea98aaSEric Biggers static int alloc_shash(const char *driver, u32 type, u32 mask, 1806d8ea98aaSEric Biggers struct crypto_shash **tfm_ret, 1807d8ea98aaSEric Biggers struct shash_desc **desc_ret) 1808d8ea98aaSEric Biggers { 1809d8ea98aaSEric Biggers struct crypto_shash *tfm; 1810d8ea98aaSEric Biggers struct shash_desc *desc; 1811d8ea98aaSEric Biggers 1812d8ea98aaSEric Biggers tfm = crypto_alloc_shash(driver, type, mask); 1813d8ea98aaSEric Biggers if (IS_ERR(tfm)) { 1814d8ea98aaSEric Biggers if (PTR_ERR(tfm) == -ENOENT) { 1815d8ea98aaSEric Biggers /* 1816d8ea98aaSEric Biggers * This algorithm is only available through the ahash 1817d8ea98aaSEric Biggers * API, not the shash API, so skip the shash tests. 1818d8ea98aaSEric Biggers */ 1819d8ea98aaSEric Biggers return 0; 1820d8ea98aaSEric Biggers } 1821d8ea98aaSEric Biggers pr_err("alg: hash: failed to allocate shash transform for %s: %ld\n", 1822d8ea98aaSEric Biggers driver, PTR_ERR(tfm)); 1823d8ea98aaSEric Biggers return PTR_ERR(tfm); 1824d8ea98aaSEric Biggers } 1825d8ea98aaSEric Biggers 1826d8ea98aaSEric Biggers desc = kmalloc(sizeof(*desc) + crypto_shash_descsize(tfm), GFP_KERNEL); 1827d8ea98aaSEric Biggers if (!desc) { 1828d8ea98aaSEric Biggers crypto_free_shash(tfm); 1829d8ea98aaSEric Biggers return -ENOMEM; 1830d8ea98aaSEric Biggers } 1831d8ea98aaSEric Biggers desc->tfm = tfm; 1832d8ea98aaSEric Biggers 1833d8ea98aaSEric Biggers *tfm_ret = tfm; 1834d8ea98aaSEric Biggers *desc_ret = desc; 1835d8ea98aaSEric Biggers return 0; 1836d8ea98aaSEric Biggers } 1837d8ea98aaSEric Biggers 18384cc2dcf9SEric Biggers static int __alg_test_hash(const struct hash_testvec *vecs, 18394cc2dcf9SEric Biggers unsigned int num_vecs, const char *driver, 18409a8a6b3fSEric Biggers u32 type, u32 mask, 18419a8a6b3fSEric Biggers const char *generic_driver, unsigned int maxkeysize) 18424cc2dcf9SEric Biggers { 1843d8ea98aaSEric Biggers struct crypto_ahash *atfm = NULL; 18444cc2dcf9SEric Biggers struct ahash_request *req = NULL; 1845d8ea98aaSEric Biggers struct crypto_shash *stfm = NULL; 1846d8ea98aaSEric Biggers struct shash_desc *desc = NULL; 18474cc2dcf9SEric Biggers struct test_sglist *tsgl = NULL; 18484cc2dcf9SEric Biggers u8 *hashstate = NULL; 1849d8ea98aaSEric Biggers unsigned int statesize; 18504cc2dcf9SEric Biggers unsigned int i; 18514cc2dcf9SEric Biggers int err; 18524cc2dcf9SEric Biggers 1853d8ea98aaSEric Biggers /* 1854d8ea98aaSEric Biggers * Always test the ahash API. This works regardless of whether the 1855d8ea98aaSEric Biggers * algorithm is implemented as ahash or shash. 1856d8ea98aaSEric Biggers */ 1857d8ea98aaSEric Biggers 1858d8ea98aaSEric Biggers atfm = crypto_alloc_ahash(driver, type, mask); 1859d8ea98aaSEric Biggers if (IS_ERR(atfm)) { 18604cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate transform for %s: %ld\n", 1861d8ea98aaSEric Biggers driver, PTR_ERR(atfm)); 1862d8ea98aaSEric Biggers return PTR_ERR(atfm); 18634cc2dcf9SEric Biggers } 186479cafe9aSEric Biggers driver = crypto_ahash_driver_name(atfm); 18654cc2dcf9SEric Biggers 1866d8ea98aaSEric Biggers req = ahash_request_alloc(atfm, GFP_KERNEL); 18674cc2dcf9SEric Biggers if (!req) { 18684cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate request for %s\n", 18694cc2dcf9SEric Biggers driver); 18704cc2dcf9SEric Biggers err = -ENOMEM; 18714cc2dcf9SEric Biggers goto out; 18724cc2dcf9SEric Biggers } 18734cc2dcf9SEric Biggers 1874d8ea98aaSEric Biggers /* 1875d8ea98aaSEric Biggers * If available also test the shash API, to cover corner cases that may 1876d8ea98aaSEric Biggers * be missed by testing the ahash API only. 1877d8ea98aaSEric Biggers */ 1878d8ea98aaSEric Biggers err = alloc_shash(driver, type, mask, &stfm, &desc); 1879d8ea98aaSEric Biggers if (err) 1880d8ea98aaSEric Biggers goto out; 1881d8ea98aaSEric Biggers 18824cc2dcf9SEric Biggers tsgl = kmalloc(sizeof(*tsgl), GFP_KERNEL); 18834cc2dcf9SEric Biggers if (!tsgl || init_test_sglist(tsgl) != 0) { 18844cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate test buffers for %s\n", 18854cc2dcf9SEric Biggers driver); 18864cc2dcf9SEric Biggers kfree(tsgl); 18874cc2dcf9SEric Biggers tsgl = NULL; 18884cc2dcf9SEric Biggers err = -ENOMEM; 18894cc2dcf9SEric Biggers goto out; 18904cc2dcf9SEric Biggers } 18914cc2dcf9SEric Biggers 1892d8ea98aaSEric Biggers statesize = crypto_ahash_statesize(atfm); 1893d8ea98aaSEric Biggers if (stfm) 1894d8ea98aaSEric Biggers statesize = max(statesize, crypto_shash_statesize(stfm)); 1895d8ea98aaSEric Biggers hashstate = kmalloc(statesize + TESTMGR_POISON_LEN, GFP_KERNEL); 18964cc2dcf9SEric Biggers if (!hashstate) { 18974cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate hash state buffer for %s\n", 18984cc2dcf9SEric Biggers driver); 18994cc2dcf9SEric Biggers err = -ENOMEM; 19004cc2dcf9SEric Biggers goto out; 19014cc2dcf9SEric Biggers } 19024cc2dcf9SEric Biggers 19034cc2dcf9SEric Biggers for (i = 0; i < num_vecs; i++) { 1904c9c28ed0SStephan Müller if (fips_enabled && vecs[i].fips_skip) 1905c9c28ed0SStephan Müller continue; 1906c9c28ed0SStephan Müller 190779cafe9aSEric Biggers err = test_hash_vec(&vecs[i], i, req, desc, tsgl, hashstate); 19084cc2dcf9SEric Biggers if (err) 19094cc2dcf9SEric Biggers goto out; 1910e63e1b0dSEric Biggers cond_resched(); 19114cc2dcf9SEric Biggers } 191279cafe9aSEric Biggers err = test_hash_vs_generic_impl(generic_driver, maxkeysize, req, 1913d8ea98aaSEric Biggers desc, tsgl, hashstate); 19144cc2dcf9SEric Biggers out: 19154cc2dcf9SEric Biggers kfree(hashstate); 19164cc2dcf9SEric Biggers if (tsgl) { 19174cc2dcf9SEric Biggers destroy_test_sglist(tsgl); 19184cc2dcf9SEric Biggers kfree(tsgl); 19194cc2dcf9SEric Biggers } 1920d8ea98aaSEric Biggers kfree(desc); 1921d8ea98aaSEric Biggers crypto_free_shash(stfm); 19224cc2dcf9SEric Biggers ahash_request_free(req); 1923d8ea98aaSEric Biggers crypto_free_ahash(atfm); 19244cc2dcf9SEric Biggers return err; 19254cc2dcf9SEric Biggers } 19264cc2dcf9SEric Biggers 19274cc2dcf9SEric Biggers static int alg_test_hash(const struct alg_test_desc *desc, const char *driver, 19284cc2dcf9SEric Biggers u32 type, u32 mask) 19294cc2dcf9SEric Biggers { 19304cc2dcf9SEric Biggers const struct hash_testvec *template = desc->suite.hash.vecs; 19314cc2dcf9SEric Biggers unsigned int tcount = desc->suite.hash.count; 19324cc2dcf9SEric Biggers unsigned int nr_unkeyed, nr_keyed; 19339a8a6b3fSEric Biggers unsigned int maxkeysize = 0; 19344cc2dcf9SEric Biggers int err; 19354cc2dcf9SEric Biggers 19364cc2dcf9SEric Biggers /* 19374cc2dcf9SEric Biggers * For OPTIONAL_KEY algorithms, we have to do all the unkeyed tests 19384cc2dcf9SEric Biggers * first, before setting a key on the tfm. To make this easier, we 19394cc2dcf9SEric Biggers * require that the unkeyed test vectors (if any) are listed first. 19404cc2dcf9SEric Biggers */ 19414cc2dcf9SEric Biggers 19424cc2dcf9SEric Biggers for (nr_unkeyed = 0; nr_unkeyed < tcount; nr_unkeyed++) { 19434cc2dcf9SEric Biggers if (template[nr_unkeyed].ksize) 19444cc2dcf9SEric Biggers break; 19454cc2dcf9SEric Biggers } 19464cc2dcf9SEric Biggers for (nr_keyed = 0; nr_unkeyed + nr_keyed < tcount; nr_keyed++) { 19474cc2dcf9SEric Biggers if (!template[nr_unkeyed + nr_keyed].ksize) { 19484cc2dcf9SEric Biggers pr_err("alg: hash: test vectors for %s out of order, " 19494cc2dcf9SEric Biggers "unkeyed ones must come first\n", desc->alg); 19504cc2dcf9SEric Biggers return -EINVAL; 19514cc2dcf9SEric Biggers } 19529a8a6b3fSEric Biggers maxkeysize = max_t(unsigned int, maxkeysize, 19539a8a6b3fSEric Biggers template[nr_unkeyed + nr_keyed].ksize); 19544cc2dcf9SEric Biggers } 19554cc2dcf9SEric Biggers 19564cc2dcf9SEric Biggers err = 0; 19574cc2dcf9SEric Biggers if (nr_unkeyed) { 19589a8a6b3fSEric Biggers err = __alg_test_hash(template, nr_unkeyed, driver, type, mask, 19599a8a6b3fSEric Biggers desc->generic_driver, maxkeysize); 19604cc2dcf9SEric Biggers template += nr_unkeyed; 19614cc2dcf9SEric Biggers } 19624cc2dcf9SEric Biggers 19634cc2dcf9SEric Biggers if (!err && nr_keyed) 19649a8a6b3fSEric Biggers err = __alg_test_hash(template, nr_keyed, driver, type, mask, 19659a8a6b3fSEric Biggers desc->generic_driver, maxkeysize); 19664cc2dcf9SEric Biggers 19674cc2dcf9SEric Biggers return err; 19684cc2dcf9SEric Biggers } 19694cc2dcf9SEric Biggers 19702257f471SEric Biggers static int test_aead_vec_cfg(int enc, const struct aead_testvec *vec, 1971951d1332SEric Biggers const char *vec_name, 1972ed96804fSEric Biggers const struct testvec_config *cfg, 1973ed96804fSEric Biggers struct aead_request *req, 1974ed96804fSEric Biggers struct cipher_test_sglists *tsgls) 1975da7f033dSHerbert Xu { 1976ed96804fSEric Biggers struct crypto_aead *tfm = crypto_aead_reqtfm(req); 1977ed96804fSEric Biggers const unsigned int alignmask = crypto_aead_alignmask(tfm); 1978ed96804fSEric Biggers const unsigned int ivsize = crypto_aead_ivsize(tfm); 1979ed96804fSEric Biggers const unsigned int authsize = vec->clen - vec->plen; 19802257f471SEric Biggers const char *driver = crypto_aead_driver_name(tfm); 1981ed96804fSEric Biggers const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags; 1982ed96804fSEric Biggers const char *op = enc ? "encryption" : "decryption"; 1983ed96804fSEric Biggers DECLARE_CRYPTO_WAIT(wait); 1984ed96804fSEric Biggers u8 _iv[3 * (MAX_ALGAPI_ALIGNMASK + 1) + MAX_IVLEN]; 1985ed96804fSEric Biggers u8 *iv = PTR_ALIGN(&_iv[0], 2 * (MAX_ALGAPI_ALIGNMASK + 1)) + 1986ed96804fSEric Biggers cfg->iv_offset + 1987ed96804fSEric Biggers (cfg->iv_offset_relative_to_alignmask ? alignmask : 0); 1988ed96804fSEric Biggers struct kvec input[2]; 1989ed96804fSEric Biggers int err; 1990f8b0d4d0SHerbert Xu 1991ed96804fSEric Biggers /* Set the key */ 1992ed96804fSEric Biggers if (vec->wk) 1993ed96804fSEric Biggers crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 1994d8a32ac2SJussi Kivilinna else 1995ed96804fSEric Biggers crypto_aead_clear_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 1996fd8c37c7SEric Biggers 1997fd8c37c7SEric Biggers err = do_setkey(crypto_aead_setkey, tfm, vec->key, vec->klen, 1998fd8c37c7SEric Biggers cfg, alignmask); 19995283a8eeSEric Biggers if (err && err != vec->setkey_error) { 2000951d1332SEric Biggers pr_err("alg: aead: %s setkey failed on test vector %s; expected_error=%d, actual_error=%d, flags=%#x\n", 2001951d1332SEric Biggers driver, vec_name, vec->setkey_error, err, 20025283a8eeSEric Biggers crypto_aead_get_flags(tfm)); 2003ed96804fSEric Biggers return err; 2004ed96804fSEric Biggers } 20055283a8eeSEric Biggers if (!err && vec->setkey_error) { 2006951d1332SEric Biggers pr_err("alg: aead: %s setkey unexpectedly succeeded on test vector %s; expected_error=%d\n", 2007951d1332SEric Biggers driver, vec_name, vec->setkey_error); 2008ed96804fSEric Biggers return -EINVAL; 2009ed96804fSEric Biggers } 2010d8a32ac2SJussi Kivilinna 2011ed96804fSEric Biggers /* Set the authentication tag size */ 2012ed96804fSEric Biggers err = crypto_aead_setauthsize(tfm, authsize); 20135283a8eeSEric Biggers if (err && err != vec->setauthsize_error) { 2014951d1332SEric Biggers pr_err("alg: aead: %s setauthsize failed on test vector %s; expected_error=%d, actual_error=%d\n", 2015951d1332SEric Biggers driver, vec_name, vec->setauthsize_error, err); 2016ed96804fSEric Biggers return err; 2017ed96804fSEric Biggers } 20185283a8eeSEric Biggers if (!err && vec->setauthsize_error) { 2019951d1332SEric Biggers pr_err("alg: aead: %s setauthsize unexpectedly succeeded on test vector %s; expected_error=%d\n", 2020951d1332SEric Biggers driver, vec_name, vec->setauthsize_error); 20215283a8eeSEric Biggers return -EINVAL; 20225283a8eeSEric Biggers } 20235283a8eeSEric Biggers 20245283a8eeSEric Biggers if (vec->setkey_error || vec->setauthsize_error) 20255283a8eeSEric Biggers return 0; 2026ed96804fSEric Biggers 2027ed96804fSEric Biggers /* The IV must be copied to a buffer, as the algorithm may modify it */ 2028ed96804fSEric Biggers if (WARN_ON(ivsize > MAX_IVLEN)) 2029ed96804fSEric Biggers return -EINVAL; 2030ed96804fSEric Biggers if (vec->iv) 2031ed96804fSEric Biggers memcpy(iv, vec->iv, ivsize); 2032da7f033dSHerbert Xu else 2033ed96804fSEric Biggers memset(iv, 0, ivsize); 2034da7f033dSHerbert Xu 2035ed96804fSEric Biggers /* Build the src/dst scatterlists */ 2036ed96804fSEric Biggers input[0].iov_base = (void *)vec->assoc; 2037ed96804fSEric Biggers input[0].iov_len = vec->alen; 2038ed96804fSEric Biggers input[1].iov_base = enc ? (void *)vec->ptext : (void *)vec->ctext; 2039ed96804fSEric Biggers input[1].iov_len = enc ? vec->plen : vec->clen; 2040ed96804fSEric Biggers err = build_cipher_test_sglists(tsgls, cfg, alignmask, 2041ed96804fSEric Biggers vec->alen + (enc ? vec->plen : 2042ed96804fSEric Biggers vec->clen), 2043ed96804fSEric Biggers vec->alen + (enc ? vec->clen : 2044ed96804fSEric Biggers vec->plen), 2045ed96804fSEric Biggers input, 2); 2046ed96804fSEric Biggers if (err) { 2047951d1332SEric Biggers pr_err("alg: aead: %s %s: error preparing scatterlists for test vector %s, cfg=\"%s\"\n", 2048951d1332SEric Biggers driver, op, vec_name, cfg->name); 2049ed96804fSEric Biggers return err; 2050da7f033dSHerbert Xu } 2051da7f033dSHerbert Xu 2052ed96804fSEric Biggers /* Do the actual encryption or decryption */ 2053ed96804fSEric Biggers testmgr_poison(req->__ctx, crypto_aead_reqsize(tfm)); 2054ed96804fSEric Biggers aead_request_set_callback(req, req_flags, crypto_req_done, &wait); 2055ed96804fSEric Biggers aead_request_set_crypt(req, tsgls->src.sgl_ptr, tsgls->dst.sgl_ptr, 2056ed96804fSEric Biggers enc ? vec->plen : vec->clen, iv); 2057ed96804fSEric Biggers aead_request_set_ad(req, vec->alen); 20586570737cSEric Biggers if (cfg->nosimd) 20596570737cSEric Biggers crypto_disable_simd_for_test(); 20606570737cSEric Biggers err = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req); 20616570737cSEric Biggers if (cfg->nosimd) 20626570737cSEric Biggers crypto_reenable_simd_for_test(); 20636570737cSEric Biggers err = crypto_wait_req(err, &wait); 206405b1d338SCristian Stoica 2065a6e5ef9bSEric Biggers /* Check that the algorithm didn't overwrite things it shouldn't have */ 2066a6e5ef9bSEric Biggers if (req->cryptlen != (enc ? vec->plen : vec->clen) || 2067a6e5ef9bSEric Biggers req->assoclen != vec->alen || 2068a6e5ef9bSEric Biggers req->iv != iv || 2069a6e5ef9bSEric Biggers req->src != tsgls->src.sgl_ptr || 2070a6e5ef9bSEric Biggers req->dst != tsgls->dst.sgl_ptr || 2071a6e5ef9bSEric Biggers crypto_aead_reqtfm(req) != tfm || 2072a6e5ef9bSEric Biggers req->base.complete != crypto_req_done || 2073a6e5ef9bSEric Biggers req->base.flags != req_flags || 2074a6e5ef9bSEric Biggers req->base.data != &wait) { 2075951d1332SEric Biggers pr_err("alg: aead: %s %s corrupted request struct on test vector %s, cfg=\"%s\"\n", 2076951d1332SEric Biggers driver, op, vec_name, cfg->name); 2077a6e5ef9bSEric Biggers if (req->cryptlen != (enc ? vec->plen : vec->clen)) 2078a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->cryptlen'\n"); 2079a6e5ef9bSEric Biggers if (req->assoclen != vec->alen) 2080a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->assoclen'\n"); 2081a6e5ef9bSEric Biggers if (req->iv != iv) 2082a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->iv'\n"); 2083a6e5ef9bSEric Biggers if (req->src != tsgls->src.sgl_ptr) 2084a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->src'\n"); 2085a6e5ef9bSEric Biggers if (req->dst != tsgls->dst.sgl_ptr) 2086a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->dst'\n"); 2087a6e5ef9bSEric Biggers if (crypto_aead_reqtfm(req) != tfm) 2088a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.tfm'\n"); 2089a6e5ef9bSEric Biggers if (req->base.complete != crypto_req_done) 2090a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.complete'\n"); 2091a6e5ef9bSEric Biggers if (req->base.flags != req_flags) 2092a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.flags'\n"); 2093a6e5ef9bSEric Biggers if (req->base.data != &wait) 2094a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.data'\n"); 2095a6e5ef9bSEric Biggers return -EINVAL; 2096a6e5ef9bSEric Biggers } 2097a6e5ef9bSEric Biggers if (is_test_sglist_corrupted(&tsgls->src)) { 2098951d1332SEric Biggers pr_err("alg: aead: %s %s corrupted src sgl on test vector %s, cfg=\"%s\"\n", 2099951d1332SEric Biggers driver, op, vec_name, cfg->name); 2100a6e5ef9bSEric Biggers return -EINVAL; 2101a6e5ef9bSEric Biggers } 2102a6e5ef9bSEric Biggers if (tsgls->dst.sgl_ptr != tsgls->src.sgl && 2103a6e5ef9bSEric Biggers is_test_sglist_corrupted(&tsgls->dst)) { 2104951d1332SEric Biggers pr_err("alg: aead: %s %s corrupted dst sgl on test vector %s, cfg=\"%s\"\n", 2105951d1332SEric Biggers driver, op, vec_name, cfg->name); 2106a6e5ef9bSEric Biggers return -EINVAL; 2107a6e5ef9bSEric Biggers } 2108a6e5ef9bSEric Biggers 210949763fc6SEric Biggers /* Check for unexpected success or failure, or wrong error code */ 211049763fc6SEric Biggers if ((err == 0 && vec->novrfy) || 211149763fc6SEric Biggers (err != vec->crypt_error && !(err == -EBADMSG && vec->novrfy))) { 211249763fc6SEric Biggers char expected_error[32]; 211349763fc6SEric Biggers 211449763fc6SEric Biggers if (vec->novrfy && 211549763fc6SEric Biggers vec->crypt_error != 0 && vec->crypt_error != -EBADMSG) 211649763fc6SEric Biggers sprintf(expected_error, "-EBADMSG or %d", 211749763fc6SEric Biggers vec->crypt_error); 211849763fc6SEric Biggers else if (vec->novrfy) 211949763fc6SEric Biggers sprintf(expected_error, "-EBADMSG"); 212049763fc6SEric Biggers else 212149763fc6SEric Biggers sprintf(expected_error, "%d", vec->crypt_error); 21225283a8eeSEric Biggers if (err) { 212349763fc6SEric Biggers pr_err("alg: aead: %s %s failed on test vector %s; expected_error=%s, actual_error=%d, cfg=\"%s\"\n", 212449763fc6SEric Biggers driver, op, vec_name, expected_error, err, 212549763fc6SEric Biggers cfg->name); 21265283a8eeSEric Biggers return err; 21275283a8eeSEric Biggers } 212849763fc6SEric Biggers pr_err("alg: aead: %s %s unexpectedly succeeded on test vector %s; expected_error=%s, cfg=\"%s\"\n", 2129951d1332SEric Biggers driver, op, vec_name, expected_error, cfg->name); 21305283a8eeSEric Biggers return -EINVAL; 21315283a8eeSEric Biggers } 213249763fc6SEric Biggers if (err) /* Expectedly failed. */ 213349763fc6SEric Biggers return 0; 21345283a8eeSEric Biggers 2135ed96804fSEric Biggers /* Check for the correct output (ciphertext or plaintext) */ 2136ed96804fSEric Biggers err = verify_correct_output(&tsgls->dst, enc ? vec->ctext : vec->ptext, 2137ed96804fSEric Biggers enc ? vec->clen : vec->plen, 2138f17f9e90SEric Biggers vec->alen, 2139f17f9e90SEric Biggers enc || cfg->inplace_mode == OUT_OF_PLACE); 2140ed96804fSEric Biggers if (err == -EOVERFLOW) { 2141951d1332SEric Biggers pr_err("alg: aead: %s %s overran dst buffer on test vector %s, cfg=\"%s\"\n", 2142951d1332SEric Biggers driver, op, vec_name, cfg->name); 2143ed96804fSEric Biggers return err; 214429b77e5dSHoria Geanta } 2145ed96804fSEric Biggers if (err) { 2146951d1332SEric Biggers pr_err("alg: aead: %s %s test failed (wrong result) on test vector %s, cfg=\"%s\"\n", 2147951d1332SEric Biggers driver, op, vec_name, cfg->name); 2148ed96804fSEric Biggers return err; 214958dcf548SJussi Kivilinna } 215058dcf548SJussi Kivilinna 215158dcf548SJussi Kivilinna return 0; 2152d8a32ac2SJussi Kivilinna } 2153d8a32ac2SJussi Kivilinna 21542257f471SEric Biggers static int test_aead_vec(int enc, const struct aead_testvec *vec, 21552257f471SEric Biggers unsigned int vec_num, struct aead_request *req, 2156ed96804fSEric Biggers struct cipher_test_sglists *tsgls) 2157ed96804fSEric Biggers { 2158951d1332SEric Biggers char vec_name[16]; 2159ed96804fSEric Biggers unsigned int i; 2160ed96804fSEric Biggers int err; 2161ed96804fSEric Biggers 2162ed96804fSEric Biggers if (enc && vec->novrfy) 2163ed96804fSEric Biggers return 0; 2164ed96804fSEric Biggers 2165951d1332SEric Biggers sprintf(vec_name, "%u", vec_num); 2166951d1332SEric Biggers 2167ed96804fSEric Biggers for (i = 0; i < ARRAY_SIZE(default_cipher_testvec_configs); i++) { 21682257f471SEric Biggers err = test_aead_vec_cfg(enc, vec, vec_name, 2169ed96804fSEric Biggers &default_cipher_testvec_configs[i], 2170ed96804fSEric Biggers req, tsgls); 2171ed96804fSEric Biggers if (err) 2172ed96804fSEric Biggers return err; 2173ed96804fSEric Biggers } 2174ed96804fSEric Biggers 2175ed96804fSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 2176ed96804fSEric Biggers if (!noextratests) { 2177ed96804fSEric Biggers struct testvec_config cfg; 2178ed96804fSEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 2179ed96804fSEric Biggers 2180ed96804fSEric Biggers for (i = 0; i < fuzz_iterations; i++) { 2181ed96804fSEric Biggers generate_random_testvec_config(&cfg, cfgname, 2182ed96804fSEric Biggers sizeof(cfgname)); 21832257f471SEric Biggers err = test_aead_vec_cfg(enc, vec, vec_name, 2184ed96804fSEric Biggers &cfg, req, tsgls); 2185ed96804fSEric Biggers if (err) 2186ed96804fSEric Biggers return err; 2187e63e1b0dSEric Biggers cond_resched(); 2188ed96804fSEric Biggers } 2189ed96804fSEric Biggers } 2190ed96804fSEric Biggers #endif 2191ed96804fSEric Biggers return 0; 2192ed96804fSEric Biggers } 2193ed96804fSEric Biggers 219440153b10SEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 21952ea91505SEric Biggers 21962ea91505SEric Biggers struct aead_extra_tests_ctx { 21972ea91505SEric Biggers struct aead_request *req; 21982ea91505SEric Biggers struct crypto_aead *tfm; 21992ea91505SEric Biggers const struct alg_test_desc *test_desc; 22002ea91505SEric Biggers struct cipher_test_sglists *tsgls; 22012ea91505SEric Biggers unsigned int maxdatasize; 22022ea91505SEric Biggers unsigned int maxkeysize; 22032ea91505SEric Biggers 22042ea91505SEric Biggers struct aead_testvec vec; 22052ea91505SEric Biggers char vec_name[64]; 22062ea91505SEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 22072ea91505SEric Biggers struct testvec_config cfg; 22082ea91505SEric Biggers }; 22092ea91505SEric Biggers 221040153b10SEric Biggers /* 221149763fc6SEric Biggers * Make at least one random change to a (ciphertext, AAD) pair. "Ciphertext" 221249763fc6SEric Biggers * here means the full ciphertext including the authentication tag. The 221349763fc6SEric Biggers * authentication tag (and hence also the ciphertext) is assumed to be nonempty. 221449763fc6SEric Biggers */ 22156f3a06d9SEric Biggers static void mutate_aead_message(struct aead_testvec *vec, bool aad_iv, 22166f3a06d9SEric Biggers unsigned int ivsize) 221749763fc6SEric Biggers { 22186f3a06d9SEric Biggers const unsigned int aad_tail_size = aad_iv ? ivsize : 0; 221949763fc6SEric Biggers const unsigned int authsize = vec->clen - vec->plen; 222049763fc6SEric Biggers 222181895a65SJason A. Donenfeld if (prandom_u32_max(2) == 0 && vec->alen > aad_tail_size) { 222249763fc6SEric Biggers /* Mutate the AAD */ 222349763fc6SEric Biggers flip_random_bit((u8 *)vec->assoc, vec->alen - aad_tail_size); 222481895a65SJason A. Donenfeld if (prandom_u32_max(2) == 0) 222549763fc6SEric Biggers return; 222649763fc6SEric Biggers } 222781895a65SJason A. Donenfeld if (prandom_u32_max(2) == 0) { 222849763fc6SEric Biggers /* Mutate auth tag (assuming it's at the end of ciphertext) */ 222949763fc6SEric Biggers flip_random_bit((u8 *)vec->ctext + vec->plen, authsize); 223049763fc6SEric Biggers } else { 223149763fc6SEric Biggers /* Mutate any part of the ciphertext */ 223249763fc6SEric Biggers flip_random_bit((u8 *)vec->ctext, vec->clen); 223349763fc6SEric Biggers } 223449763fc6SEric Biggers } 223549763fc6SEric Biggers 223649763fc6SEric Biggers /* 223749763fc6SEric Biggers * Minimum authentication tag size in bytes at which we assume that we can 223849763fc6SEric Biggers * reliably generate inauthentic messages, i.e. not generate an authentic 223949763fc6SEric Biggers * message by chance. 224049763fc6SEric Biggers */ 224149763fc6SEric Biggers #define MIN_COLLISION_FREE_AUTHSIZE 8 224249763fc6SEric Biggers 224349763fc6SEric Biggers static void generate_aead_message(struct aead_request *req, 224449763fc6SEric Biggers const struct aead_test_suite *suite, 224549763fc6SEric Biggers struct aead_testvec *vec, 224649763fc6SEric Biggers bool prefer_inauthentic) 224749763fc6SEric Biggers { 224849763fc6SEric Biggers struct crypto_aead *tfm = crypto_aead_reqtfm(req); 224949763fc6SEric Biggers const unsigned int ivsize = crypto_aead_ivsize(tfm); 225049763fc6SEric Biggers const unsigned int authsize = vec->clen - vec->plen; 225149763fc6SEric Biggers const bool inauthentic = (authsize >= MIN_COLLISION_FREE_AUTHSIZE) && 225281895a65SJason A. Donenfeld (prefer_inauthentic || prandom_u32_max(4) == 0); 225349763fc6SEric Biggers 225449763fc6SEric Biggers /* Generate the AAD. */ 225549763fc6SEric Biggers generate_random_bytes((u8 *)vec->assoc, vec->alen); 22566f3a06d9SEric Biggers if (suite->aad_iv && vec->alen >= ivsize) 22576f3a06d9SEric Biggers /* Avoid implementation-defined behavior. */ 22586f3a06d9SEric Biggers memcpy((u8 *)vec->assoc + vec->alen - ivsize, vec->iv, ivsize); 225949763fc6SEric Biggers 226081895a65SJason A. Donenfeld if (inauthentic && prandom_u32_max(2) == 0) { 226149763fc6SEric Biggers /* Generate a random ciphertext. */ 226249763fc6SEric Biggers generate_random_bytes((u8 *)vec->ctext, vec->clen); 226349763fc6SEric Biggers } else { 226449763fc6SEric Biggers int i = 0; 226549763fc6SEric Biggers struct scatterlist src[2], dst; 226649763fc6SEric Biggers u8 iv[MAX_IVLEN]; 226749763fc6SEric Biggers DECLARE_CRYPTO_WAIT(wait); 226849763fc6SEric Biggers 226949763fc6SEric Biggers /* Generate a random plaintext and encrypt it. */ 227049763fc6SEric Biggers sg_init_table(src, 2); 227149763fc6SEric Biggers if (vec->alen) 227249763fc6SEric Biggers sg_set_buf(&src[i++], vec->assoc, vec->alen); 227349763fc6SEric Biggers if (vec->plen) { 227449763fc6SEric Biggers generate_random_bytes((u8 *)vec->ptext, vec->plen); 227549763fc6SEric Biggers sg_set_buf(&src[i++], vec->ptext, vec->plen); 227649763fc6SEric Biggers } 227749763fc6SEric Biggers sg_init_one(&dst, vec->ctext, vec->alen + vec->clen); 227849763fc6SEric Biggers memcpy(iv, vec->iv, ivsize); 227949763fc6SEric Biggers aead_request_set_callback(req, 0, crypto_req_done, &wait); 228049763fc6SEric Biggers aead_request_set_crypt(req, src, &dst, vec->plen, iv); 228149763fc6SEric Biggers aead_request_set_ad(req, vec->alen); 228249763fc6SEric Biggers vec->crypt_error = crypto_wait_req(crypto_aead_encrypt(req), 228349763fc6SEric Biggers &wait); 228449763fc6SEric Biggers /* If encryption failed, we're done. */ 228549763fc6SEric Biggers if (vec->crypt_error != 0) 228649763fc6SEric Biggers return; 228749763fc6SEric Biggers memmove((u8 *)vec->ctext, vec->ctext + vec->alen, vec->clen); 228849763fc6SEric Biggers if (!inauthentic) 228949763fc6SEric Biggers return; 229049763fc6SEric Biggers /* 229149763fc6SEric Biggers * Mutate the authentic (ciphertext, AAD) pair to get an 229249763fc6SEric Biggers * inauthentic one. 229349763fc6SEric Biggers */ 22946f3a06d9SEric Biggers mutate_aead_message(vec, suite->aad_iv, ivsize); 229549763fc6SEric Biggers } 229649763fc6SEric Biggers vec->novrfy = 1; 229749763fc6SEric Biggers if (suite->einval_allowed) 229849763fc6SEric Biggers vec->crypt_error = -EINVAL; 229949763fc6SEric Biggers } 230049763fc6SEric Biggers 230149763fc6SEric Biggers /* 230249763fc6SEric Biggers * Generate an AEAD test vector 'vec' using the implementation specified by 230349763fc6SEric Biggers * 'req'. The buffers in 'vec' must already be allocated. 230449763fc6SEric Biggers * 230549763fc6SEric Biggers * If 'prefer_inauthentic' is true, then this function will generate inauthentic 230649763fc6SEric Biggers * test vectors (i.e. vectors with 'vec->novrfy=1') more often. 230740153b10SEric Biggers */ 230840153b10SEric Biggers static void generate_random_aead_testvec(struct aead_request *req, 230940153b10SEric Biggers struct aead_testvec *vec, 231049763fc6SEric Biggers const struct aead_test_suite *suite, 231140153b10SEric Biggers unsigned int maxkeysize, 231240153b10SEric Biggers unsigned int maxdatasize, 231349763fc6SEric Biggers char *name, size_t max_namelen, 231449763fc6SEric Biggers bool prefer_inauthentic) 231540153b10SEric Biggers { 231640153b10SEric Biggers struct crypto_aead *tfm = crypto_aead_reqtfm(req); 231740153b10SEric Biggers const unsigned int ivsize = crypto_aead_ivsize(tfm); 23182ea91505SEric Biggers const unsigned int maxauthsize = crypto_aead_maxauthsize(tfm); 231940153b10SEric Biggers unsigned int authsize; 232040153b10SEric Biggers unsigned int total_len; 232140153b10SEric Biggers 232240153b10SEric Biggers /* Key: length in [0, maxkeysize], but usually choose maxkeysize */ 232340153b10SEric Biggers vec->klen = maxkeysize; 232481895a65SJason A. Donenfeld if (prandom_u32_max(4) == 0) 232581895a65SJason A. Donenfeld vec->klen = prandom_u32_max(maxkeysize + 1); 232640153b10SEric Biggers generate_random_bytes((u8 *)vec->key, vec->klen); 232740153b10SEric Biggers vec->setkey_error = crypto_aead_setkey(tfm, vec->key, vec->klen); 232840153b10SEric Biggers 232940153b10SEric Biggers /* IV */ 233040153b10SEric Biggers generate_random_bytes((u8 *)vec->iv, ivsize); 233140153b10SEric Biggers 233240153b10SEric Biggers /* Tag length: in [0, maxauthsize], but usually choose maxauthsize */ 233340153b10SEric Biggers authsize = maxauthsize; 233481895a65SJason A. Donenfeld if (prandom_u32_max(4) == 0) 233581895a65SJason A. Donenfeld authsize = prandom_u32_max(maxauthsize + 1); 233649763fc6SEric Biggers if (prefer_inauthentic && authsize < MIN_COLLISION_FREE_AUTHSIZE) 233749763fc6SEric Biggers authsize = MIN_COLLISION_FREE_AUTHSIZE; 233840153b10SEric Biggers if (WARN_ON(authsize > maxdatasize)) 233940153b10SEric Biggers authsize = maxdatasize; 234040153b10SEric Biggers maxdatasize -= authsize; 234140153b10SEric Biggers vec->setauthsize_error = crypto_aead_setauthsize(tfm, authsize); 234240153b10SEric Biggers 234349763fc6SEric Biggers /* AAD, plaintext, and ciphertext lengths */ 234440153b10SEric Biggers total_len = generate_random_length(maxdatasize); 234581895a65SJason A. Donenfeld if (prandom_u32_max(4) == 0) 234640153b10SEric Biggers vec->alen = 0; 234740153b10SEric Biggers else 234840153b10SEric Biggers vec->alen = generate_random_length(total_len); 234940153b10SEric Biggers vec->plen = total_len - vec->alen; 235040153b10SEric Biggers vec->clen = vec->plen + authsize; 235140153b10SEric Biggers 235240153b10SEric Biggers /* 235349763fc6SEric Biggers * Generate the AAD, plaintext, and ciphertext. Not applicable if the 235449763fc6SEric Biggers * key or the authentication tag size couldn't be set. 235540153b10SEric Biggers */ 235649763fc6SEric Biggers vec->novrfy = 0; 2357eb455dbdSEric Biggers vec->crypt_error = 0; 235849763fc6SEric Biggers if (vec->setkey_error == 0 && vec->setauthsize_error == 0) 235949763fc6SEric Biggers generate_aead_message(req, suite, vec, prefer_inauthentic); 236040153b10SEric Biggers snprintf(name, max_namelen, 236149763fc6SEric Biggers "\"random: alen=%u plen=%u authsize=%u klen=%u novrfy=%d\"", 236249763fc6SEric Biggers vec->alen, vec->plen, authsize, vec->klen, vec->novrfy); 236349763fc6SEric Biggers } 236449763fc6SEric Biggers 236549763fc6SEric Biggers static void try_to_generate_inauthentic_testvec( 236649763fc6SEric Biggers struct aead_extra_tests_ctx *ctx) 236749763fc6SEric Biggers { 236849763fc6SEric Biggers int i; 236949763fc6SEric Biggers 237049763fc6SEric Biggers for (i = 0; i < 10; i++) { 237149763fc6SEric Biggers generate_random_aead_testvec(ctx->req, &ctx->vec, 237249763fc6SEric Biggers &ctx->test_desc->suite.aead, 237349763fc6SEric Biggers ctx->maxkeysize, ctx->maxdatasize, 237449763fc6SEric Biggers ctx->vec_name, 237549763fc6SEric Biggers sizeof(ctx->vec_name), true); 237649763fc6SEric Biggers if (ctx->vec.novrfy) 237749763fc6SEric Biggers return; 237849763fc6SEric Biggers } 237949763fc6SEric Biggers } 238049763fc6SEric Biggers 238149763fc6SEric Biggers /* 238249763fc6SEric Biggers * Generate inauthentic test vectors (i.e. ciphertext, AAD pairs that aren't the 238349763fc6SEric Biggers * result of an encryption with the key) and verify that decryption fails. 238449763fc6SEric Biggers */ 238549763fc6SEric Biggers static int test_aead_inauthentic_inputs(struct aead_extra_tests_ctx *ctx) 238649763fc6SEric Biggers { 238749763fc6SEric Biggers unsigned int i; 238849763fc6SEric Biggers int err; 238949763fc6SEric Biggers 239049763fc6SEric Biggers for (i = 0; i < fuzz_iterations * 8; i++) { 239149763fc6SEric Biggers /* 239249763fc6SEric Biggers * Since this part of the tests isn't comparing the 239349763fc6SEric Biggers * implementation to another, there's no point in testing any 239449763fc6SEric Biggers * test vectors other than inauthentic ones (vec.novrfy=1) here. 239549763fc6SEric Biggers * 239649763fc6SEric Biggers * If we're having trouble generating such a test vector, e.g. 239749763fc6SEric Biggers * if the algorithm keeps rejecting the generated keys, don't 239849763fc6SEric Biggers * retry forever; just continue on. 239949763fc6SEric Biggers */ 240049763fc6SEric Biggers try_to_generate_inauthentic_testvec(ctx); 240149763fc6SEric Biggers if (ctx->vec.novrfy) { 240249763fc6SEric Biggers generate_random_testvec_config(&ctx->cfg, ctx->cfgname, 240349763fc6SEric Biggers sizeof(ctx->cfgname)); 24042257f471SEric Biggers err = test_aead_vec_cfg(DECRYPT, &ctx->vec, 240549763fc6SEric Biggers ctx->vec_name, &ctx->cfg, 240649763fc6SEric Biggers ctx->req, ctx->tsgls); 240749763fc6SEric Biggers if (err) 240849763fc6SEric Biggers return err; 240949763fc6SEric Biggers } 241049763fc6SEric Biggers cond_resched(); 241149763fc6SEric Biggers } 241249763fc6SEric Biggers return 0; 241340153b10SEric Biggers } 241440153b10SEric Biggers 241540153b10SEric Biggers /* 24162ea91505SEric Biggers * Test the AEAD algorithm against the corresponding generic implementation, if 24172ea91505SEric Biggers * one is available. 241840153b10SEric Biggers */ 24192ea91505SEric Biggers static int test_aead_vs_generic_impl(struct aead_extra_tests_ctx *ctx) 242040153b10SEric Biggers { 24212ea91505SEric Biggers struct crypto_aead *tfm = ctx->tfm; 242240153b10SEric Biggers const char *algname = crypto_aead_alg(tfm)->base.cra_name; 24232257f471SEric Biggers const char *driver = crypto_aead_driver_name(tfm); 24242ea91505SEric Biggers const char *generic_driver = ctx->test_desc->generic_driver; 242540153b10SEric Biggers char _generic_driver[CRYPTO_MAX_ALG_NAME]; 242640153b10SEric Biggers struct crypto_aead *generic_tfm = NULL; 242740153b10SEric Biggers struct aead_request *generic_req = NULL; 242840153b10SEric Biggers unsigned int i; 242940153b10SEric Biggers int err; 243040153b10SEric Biggers 243140153b10SEric Biggers if (!generic_driver) { /* Use default naming convention? */ 243240153b10SEric Biggers err = build_generic_driver_name(algname, _generic_driver); 243340153b10SEric Biggers if (err) 243440153b10SEric Biggers return err; 243540153b10SEric Biggers generic_driver = _generic_driver; 243640153b10SEric Biggers } 243740153b10SEric Biggers 243840153b10SEric Biggers if (strcmp(generic_driver, driver) == 0) /* Already the generic impl? */ 243940153b10SEric Biggers return 0; 244040153b10SEric Biggers 244140153b10SEric Biggers generic_tfm = crypto_alloc_aead(generic_driver, 0, 0); 244240153b10SEric Biggers if (IS_ERR(generic_tfm)) { 244340153b10SEric Biggers err = PTR_ERR(generic_tfm); 244440153b10SEric Biggers if (err == -ENOENT) { 244540153b10SEric Biggers pr_warn("alg: aead: skipping comparison tests for %s because %s is unavailable\n", 244640153b10SEric Biggers driver, generic_driver); 244740153b10SEric Biggers return 0; 244840153b10SEric Biggers } 244940153b10SEric Biggers pr_err("alg: aead: error allocating %s (generic impl of %s): %d\n", 245040153b10SEric Biggers generic_driver, algname, err); 245140153b10SEric Biggers return err; 245240153b10SEric Biggers } 245340153b10SEric Biggers 245440153b10SEric Biggers generic_req = aead_request_alloc(generic_tfm, GFP_KERNEL); 245540153b10SEric Biggers if (!generic_req) { 245640153b10SEric Biggers err = -ENOMEM; 245740153b10SEric Biggers goto out; 245840153b10SEric Biggers } 245940153b10SEric Biggers 246040153b10SEric Biggers /* Check the algorithm properties for consistency. */ 246140153b10SEric Biggers 24622ea91505SEric Biggers if (crypto_aead_maxauthsize(tfm) != 24632ea91505SEric Biggers crypto_aead_maxauthsize(generic_tfm)) { 246440153b10SEric Biggers pr_err("alg: aead: maxauthsize for %s (%u) doesn't match generic impl (%u)\n", 24652ea91505SEric Biggers driver, crypto_aead_maxauthsize(tfm), 24662ea91505SEric Biggers crypto_aead_maxauthsize(generic_tfm)); 246740153b10SEric Biggers err = -EINVAL; 246840153b10SEric Biggers goto out; 246940153b10SEric Biggers } 247040153b10SEric Biggers 24712ea91505SEric Biggers if (crypto_aead_ivsize(tfm) != crypto_aead_ivsize(generic_tfm)) { 247240153b10SEric Biggers pr_err("alg: aead: ivsize for %s (%u) doesn't match generic impl (%u)\n", 24732ea91505SEric Biggers driver, crypto_aead_ivsize(tfm), 24742ea91505SEric Biggers crypto_aead_ivsize(generic_tfm)); 247540153b10SEric Biggers err = -EINVAL; 247640153b10SEric Biggers goto out; 247740153b10SEric Biggers } 247840153b10SEric Biggers 24792ea91505SEric Biggers if (crypto_aead_blocksize(tfm) != crypto_aead_blocksize(generic_tfm)) { 248040153b10SEric Biggers pr_err("alg: aead: blocksize for %s (%u) doesn't match generic impl (%u)\n", 24812ea91505SEric Biggers driver, crypto_aead_blocksize(tfm), 24822ea91505SEric Biggers crypto_aead_blocksize(generic_tfm)); 248340153b10SEric Biggers err = -EINVAL; 248440153b10SEric Biggers goto out; 248540153b10SEric Biggers } 248640153b10SEric Biggers 248740153b10SEric Biggers /* 248840153b10SEric Biggers * Now generate test vectors using the generic implementation, and test 248940153b10SEric Biggers * the other implementation against them. 249040153b10SEric Biggers */ 249140153b10SEric Biggers for (i = 0; i < fuzz_iterations * 8; i++) { 24922ea91505SEric Biggers generate_random_aead_testvec(generic_req, &ctx->vec, 249349763fc6SEric Biggers &ctx->test_desc->suite.aead, 24942ea91505SEric Biggers ctx->maxkeysize, ctx->maxdatasize, 24952ea91505SEric Biggers ctx->vec_name, 249649763fc6SEric Biggers sizeof(ctx->vec_name), false); 24972ea91505SEric Biggers generate_random_testvec_config(&ctx->cfg, ctx->cfgname, 24982ea91505SEric Biggers sizeof(ctx->cfgname)); 249949763fc6SEric Biggers if (!ctx->vec.novrfy) { 25002257f471SEric Biggers err = test_aead_vec_cfg(ENCRYPT, &ctx->vec, 25012ea91505SEric Biggers ctx->vec_name, &ctx->cfg, 25022ea91505SEric Biggers ctx->req, ctx->tsgls); 250340153b10SEric Biggers if (err) 250440153b10SEric Biggers goto out; 250549763fc6SEric Biggers } 250649763fc6SEric Biggers if (ctx->vec.crypt_error == 0 || ctx->vec.novrfy) { 25072257f471SEric Biggers err = test_aead_vec_cfg(DECRYPT, &ctx->vec, 25082ea91505SEric Biggers ctx->vec_name, &ctx->cfg, 25092ea91505SEric Biggers ctx->req, ctx->tsgls); 251040153b10SEric Biggers if (err) 251140153b10SEric Biggers goto out; 2512eb455dbdSEric Biggers } 251340153b10SEric Biggers cond_resched(); 251440153b10SEric Biggers } 251540153b10SEric Biggers err = 0; 251640153b10SEric Biggers out: 251740153b10SEric Biggers crypto_free_aead(generic_tfm); 251840153b10SEric Biggers aead_request_free(generic_req); 251940153b10SEric Biggers return err; 252040153b10SEric Biggers } 25212ea91505SEric Biggers 25222257f471SEric Biggers static int test_aead_extra(const struct alg_test_desc *test_desc, 25232ea91505SEric Biggers struct aead_request *req, 25242ea91505SEric Biggers struct cipher_test_sglists *tsgls) 25252ea91505SEric Biggers { 25262ea91505SEric Biggers struct aead_extra_tests_ctx *ctx; 25272ea91505SEric Biggers unsigned int i; 25282ea91505SEric Biggers int err; 25292ea91505SEric Biggers 25302ea91505SEric Biggers if (noextratests) 25312ea91505SEric Biggers return 0; 25322ea91505SEric Biggers 25332ea91505SEric Biggers ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 25342ea91505SEric Biggers if (!ctx) 25352ea91505SEric Biggers return -ENOMEM; 25362ea91505SEric Biggers ctx->req = req; 25372ea91505SEric Biggers ctx->tfm = crypto_aead_reqtfm(req); 25382ea91505SEric Biggers ctx->test_desc = test_desc; 25392ea91505SEric Biggers ctx->tsgls = tsgls; 25402ea91505SEric Biggers ctx->maxdatasize = (2 * PAGE_SIZE) - TESTMGR_POISON_LEN; 25412ea91505SEric Biggers ctx->maxkeysize = 0; 25422ea91505SEric Biggers for (i = 0; i < test_desc->suite.aead.count; i++) 25432ea91505SEric Biggers ctx->maxkeysize = max_t(unsigned int, ctx->maxkeysize, 25442ea91505SEric Biggers test_desc->suite.aead.vecs[i].klen); 25452ea91505SEric Biggers 25462ea91505SEric Biggers ctx->vec.key = kmalloc(ctx->maxkeysize, GFP_KERNEL); 25472ea91505SEric Biggers ctx->vec.iv = kmalloc(crypto_aead_ivsize(ctx->tfm), GFP_KERNEL); 25482ea91505SEric Biggers ctx->vec.assoc = kmalloc(ctx->maxdatasize, GFP_KERNEL); 25492ea91505SEric Biggers ctx->vec.ptext = kmalloc(ctx->maxdatasize, GFP_KERNEL); 25502ea91505SEric Biggers ctx->vec.ctext = kmalloc(ctx->maxdatasize, GFP_KERNEL); 25512ea91505SEric Biggers if (!ctx->vec.key || !ctx->vec.iv || !ctx->vec.assoc || 25522ea91505SEric Biggers !ctx->vec.ptext || !ctx->vec.ctext) { 25532ea91505SEric Biggers err = -ENOMEM; 25542ea91505SEric Biggers goto out; 25552ea91505SEric Biggers } 25562ea91505SEric Biggers 25578ff357a9SEric Biggers err = test_aead_vs_generic_impl(ctx); 255849763fc6SEric Biggers if (err) 255949763fc6SEric Biggers goto out; 256049763fc6SEric Biggers 25618ff357a9SEric Biggers err = test_aead_inauthentic_inputs(ctx); 25622ea91505SEric Biggers out: 25632ea91505SEric Biggers kfree(ctx->vec.key); 25642ea91505SEric Biggers kfree(ctx->vec.iv); 25652ea91505SEric Biggers kfree(ctx->vec.assoc); 25662ea91505SEric Biggers kfree(ctx->vec.ptext); 25672ea91505SEric Biggers kfree(ctx->vec.ctext); 25682ea91505SEric Biggers kfree(ctx); 25692ea91505SEric Biggers return err; 25702ea91505SEric Biggers } 257140153b10SEric Biggers #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 25722257f471SEric Biggers static int test_aead_extra(const struct alg_test_desc *test_desc, 257340153b10SEric Biggers struct aead_request *req, 257440153b10SEric Biggers struct cipher_test_sglists *tsgls) 257540153b10SEric Biggers { 257640153b10SEric Biggers return 0; 257740153b10SEric Biggers } 257840153b10SEric Biggers #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 257940153b10SEric Biggers 25802257f471SEric Biggers static int test_aead(int enc, const struct aead_test_suite *suite, 2581ed96804fSEric Biggers struct aead_request *req, 2582ed96804fSEric Biggers struct cipher_test_sglists *tsgls) 2583ed96804fSEric Biggers { 2584ed96804fSEric Biggers unsigned int i; 2585ed96804fSEric Biggers int err; 2586ed96804fSEric Biggers 2587ed96804fSEric Biggers for (i = 0; i < suite->count; i++) { 25882257f471SEric Biggers err = test_aead_vec(enc, &suite->vecs[i], i, req, tsgls); 2589ed96804fSEric Biggers if (err) 2590ed96804fSEric Biggers return err; 2591e63e1b0dSEric Biggers cond_resched(); 2592ed96804fSEric Biggers } 2593ed96804fSEric Biggers return 0; 2594ed96804fSEric Biggers } 2595ed96804fSEric Biggers 2596ed96804fSEric Biggers static int alg_test_aead(const struct alg_test_desc *desc, const char *driver, 2597ed96804fSEric Biggers u32 type, u32 mask) 2598ed96804fSEric Biggers { 2599ed96804fSEric Biggers const struct aead_test_suite *suite = &desc->suite.aead; 2600ed96804fSEric Biggers struct crypto_aead *tfm; 2601ed96804fSEric Biggers struct aead_request *req = NULL; 2602ed96804fSEric Biggers struct cipher_test_sglists *tsgls = NULL; 2603ed96804fSEric Biggers int err; 2604ed96804fSEric Biggers 2605ed96804fSEric Biggers if (suite->count <= 0) { 2606ed96804fSEric Biggers pr_err("alg: aead: empty test suite for %s\n", driver); 2607ed96804fSEric Biggers return -EINVAL; 2608ed96804fSEric Biggers } 2609ed96804fSEric Biggers 2610ed96804fSEric Biggers tfm = crypto_alloc_aead(driver, type, mask); 2611ed96804fSEric Biggers if (IS_ERR(tfm)) { 2612ed96804fSEric Biggers pr_err("alg: aead: failed to allocate transform for %s: %ld\n", 2613ed96804fSEric Biggers driver, PTR_ERR(tfm)); 2614ed96804fSEric Biggers return PTR_ERR(tfm); 2615ed96804fSEric Biggers } 26162257f471SEric Biggers driver = crypto_aead_driver_name(tfm); 2617ed96804fSEric Biggers 2618ed96804fSEric Biggers req = aead_request_alloc(tfm, GFP_KERNEL); 2619ed96804fSEric Biggers if (!req) { 2620ed96804fSEric Biggers pr_err("alg: aead: failed to allocate request for %s\n", 2621ed96804fSEric Biggers driver); 2622ed96804fSEric Biggers err = -ENOMEM; 2623ed96804fSEric Biggers goto out; 2624ed96804fSEric Biggers } 2625ed96804fSEric Biggers 2626ed96804fSEric Biggers tsgls = alloc_cipher_test_sglists(); 2627ed96804fSEric Biggers if (!tsgls) { 2628ed96804fSEric Biggers pr_err("alg: aead: failed to allocate test buffers for %s\n", 2629ed96804fSEric Biggers driver); 2630ed96804fSEric Biggers err = -ENOMEM; 2631ed96804fSEric Biggers goto out; 2632ed96804fSEric Biggers } 2633ed96804fSEric Biggers 26342257f471SEric Biggers err = test_aead(ENCRYPT, suite, req, tsgls); 2635ed96804fSEric Biggers if (err) 2636ed96804fSEric Biggers goto out; 2637ed96804fSEric Biggers 26382257f471SEric Biggers err = test_aead(DECRYPT, suite, req, tsgls); 263940153b10SEric Biggers if (err) 264040153b10SEric Biggers goto out; 264140153b10SEric Biggers 26422257f471SEric Biggers err = test_aead_extra(desc, req, tsgls); 2643ed96804fSEric Biggers out: 2644ed96804fSEric Biggers free_cipher_test_sglists(tsgls); 2645ed96804fSEric Biggers aead_request_free(req); 2646ed96804fSEric Biggers crypto_free_aead(tfm); 2647ed96804fSEric Biggers return err; 2648ed96804fSEric Biggers } 2649ed96804fSEric Biggers 26501aa4ecd9SHerbert Xu static int test_cipher(struct crypto_cipher *tfm, int enc, 2651b13b1e0cSEric Biggers const struct cipher_testvec *template, 2652b13b1e0cSEric Biggers unsigned int tcount) 26531aa4ecd9SHerbert Xu { 26541aa4ecd9SHerbert Xu const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm)); 26551aa4ecd9SHerbert Xu unsigned int i, j, k; 26561aa4ecd9SHerbert Xu char *q; 26571aa4ecd9SHerbert Xu const char *e; 265892a4c9feSEric Biggers const char *input, *result; 26591aa4ecd9SHerbert Xu void *data; 2660f8b0d4d0SHerbert Xu char *xbuf[XBUFSIZE]; 2661f8b0d4d0SHerbert Xu int ret = -ENOMEM; 2662f8b0d4d0SHerbert Xu 2663f8b0d4d0SHerbert Xu if (testmgr_alloc_buf(xbuf)) 2664f8b0d4d0SHerbert Xu goto out_nobuf; 26651aa4ecd9SHerbert Xu 26661aa4ecd9SHerbert Xu if (enc == ENCRYPT) 26671aa4ecd9SHerbert Xu e = "encryption"; 26681aa4ecd9SHerbert Xu else 26691aa4ecd9SHerbert Xu e = "decryption"; 26701aa4ecd9SHerbert Xu 26711aa4ecd9SHerbert Xu j = 0; 26721aa4ecd9SHerbert Xu for (i = 0; i < tcount; i++) { 26731aa4ecd9SHerbert Xu 267410faa8c0SStephan Mueller if (fips_enabled && template[i].fips_skip) 267510faa8c0SStephan Mueller continue; 267610faa8c0SStephan Mueller 267792a4c9feSEric Biggers input = enc ? template[i].ptext : template[i].ctext; 267892a4c9feSEric Biggers result = enc ? template[i].ctext : template[i].ptext; 26791aa4ecd9SHerbert Xu j++; 26801aa4ecd9SHerbert Xu 2681fd57f22aSHerbert Xu ret = -EINVAL; 268292a4c9feSEric Biggers if (WARN_ON(template[i].len > PAGE_SIZE)) 2683fd57f22aSHerbert Xu goto out; 2684fd57f22aSHerbert Xu 26851aa4ecd9SHerbert Xu data = xbuf[0]; 268692a4c9feSEric Biggers memcpy(data, input, template[i].len); 26871aa4ecd9SHerbert Xu 26881aa4ecd9SHerbert Xu crypto_cipher_clear_flags(tfm, ~0); 26891aa4ecd9SHerbert Xu if (template[i].wk) 2690231baecdSEric Biggers crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 26911aa4ecd9SHerbert Xu 26921aa4ecd9SHerbert Xu ret = crypto_cipher_setkey(tfm, template[i].key, 26931aa4ecd9SHerbert Xu template[i].klen); 26945283a8eeSEric Biggers if (ret) { 26955283a8eeSEric Biggers if (ret == template[i].setkey_error) 26961aa4ecd9SHerbert Xu continue; 26975283a8eeSEric Biggers pr_err("alg: cipher: %s setkey failed on test vector %u; expected_error=%d, actual_error=%d, flags=%#x\n", 26985283a8eeSEric Biggers algo, j, template[i].setkey_error, ret, 26995283a8eeSEric Biggers crypto_cipher_get_flags(tfm)); 27005283a8eeSEric Biggers goto out; 27015283a8eeSEric Biggers } 27025283a8eeSEric Biggers if (template[i].setkey_error) { 27035283a8eeSEric Biggers pr_err("alg: cipher: %s setkey unexpectedly succeeded on test vector %u; expected_error=%d\n", 27045283a8eeSEric Biggers algo, j, template[i].setkey_error); 27055283a8eeSEric Biggers ret = -EINVAL; 27065283a8eeSEric Biggers goto out; 27075283a8eeSEric Biggers } 27081aa4ecd9SHerbert Xu 270992a4c9feSEric Biggers for (k = 0; k < template[i].len; 27101aa4ecd9SHerbert Xu k += crypto_cipher_blocksize(tfm)) { 27111aa4ecd9SHerbert Xu if (enc) 27121aa4ecd9SHerbert Xu crypto_cipher_encrypt_one(tfm, data + k, 27131aa4ecd9SHerbert Xu data + k); 27141aa4ecd9SHerbert Xu else 27151aa4ecd9SHerbert Xu crypto_cipher_decrypt_one(tfm, data + k, 27161aa4ecd9SHerbert Xu data + k); 27171aa4ecd9SHerbert Xu } 27181aa4ecd9SHerbert Xu 27191aa4ecd9SHerbert Xu q = data; 272092a4c9feSEric Biggers if (memcmp(q, result, template[i].len)) { 27211aa4ecd9SHerbert Xu printk(KERN_ERR "alg: cipher: Test %d failed " 27221aa4ecd9SHerbert Xu "on %s for %s\n", j, e, algo); 272392a4c9feSEric Biggers hexdump(q, template[i].len); 27241aa4ecd9SHerbert Xu ret = -EINVAL; 27251aa4ecd9SHerbert Xu goto out; 27261aa4ecd9SHerbert Xu } 27271aa4ecd9SHerbert Xu } 27281aa4ecd9SHerbert Xu 27291aa4ecd9SHerbert Xu ret = 0; 27301aa4ecd9SHerbert Xu 27311aa4ecd9SHerbert Xu out: 2732f8b0d4d0SHerbert Xu testmgr_free_buf(xbuf); 2733f8b0d4d0SHerbert Xu out_nobuf: 27341aa4ecd9SHerbert Xu return ret; 27351aa4ecd9SHerbert Xu } 27361aa4ecd9SHerbert Xu 27376e5972faSEric Biggers static int test_skcipher_vec_cfg(int enc, const struct cipher_testvec *vec, 2738951d1332SEric Biggers const char *vec_name, 27394e7babbaSEric Biggers const struct testvec_config *cfg, 27404e7babbaSEric Biggers struct skcipher_request *req, 27414e7babbaSEric Biggers struct cipher_test_sglists *tsgls) 2742da7f033dSHerbert Xu { 27434e7babbaSEric Biggers struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 27444e7babbaSEric Biggers const unsigned int alignmask = crypto_skcipher_alignmask(tfm); 27454e7babbaSEric Biggers const unsigned int ivsize = crypto_skcipher_ivsize(tfm); 27466e5972faSEric Biggers const char *driver = crypto_skcipher_driver_name(tfm); 27474e7babbaSEric Biggers const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags; 27484e7babbaSEric Biggers const char *op = enc ? "encryption" : "decryption"; 27494e7babbaSEric Biggers DECLARE_CRYPTO_WAIT(wait); 27504e7babbaSEric Biggers u8 _iv[3 * (MAX_ALGAPI_ALIGNMASK + 1) + MAX_IVLEN]; 27514e7babbaSEric Biggers u8 *iv = PTR_ALIGN(&_iv[0], 2 * (MAX_ALGAPI_ALIGNMASK + 1)) + 27524e7babbaSEric Biggers cfg->iv_offset + 27534e7babbaSEric Biggers (cfg->iv_offset_relative_to_alignmask ? alignmask : 0); 27544e7babbaSEric Biggers struct kvec input; 27554e7babbaSEric Biggers int err; 2756f8b0d4d0SHerbert Xu 27574e7babbaSEric Biggers /* Set the key */ 27584e7babbaSEric Biggers if (vec->wk) 2759231baecdSEric Biggers crypto_skcipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 2760da7f033dSHerbert Xu else 27614e7babbaSEric Biggers crypto_skcipher_clear_flags(tfm, 27624e7babbaSEric Biggers CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 2763fd8c37c7SEric Biggers err = do_setkey(crypto_skcipher_setkey, tfm, vec->key, vec->klen, 2764fd8c37c7SEric Biggers cfg, alignmask); 27654e7babbaSEric Biggers if (err) { 27665283a8eeSEric Biggers if (err == vec->setkey_error) 27674e7babbaSEric Biggers return 0; 2768951d1332SEric Biggers pr_err("alg: skcipher: %s setkey failed on test vector %s; expected_error=%d, actual_error=%d, flags=%#x\n", 2769951d1332SEric Biggers driver, vec_name, vec->setkey_error, err, 27705283a8eeSEric Biggers crypto_skcipher_get_flags(tfm)); 27714e7babbaSEric Biggers return err; 27724e7babbaSEric Biggers } 27735283a8eeSEric Biggers if (vec->setkey_error) { 2774951d1332SEric Biggers pr_err("alg: skcipher: %s setkey unexpectedly succeeded on test vector %s; expected_error=%d\n", 2775951d1332SEric Biggers driver, vec_name, vec->setkey_error); 27764e7babbaSEric Biggers return -EINVAL; 277708d6af8cSJussi Kivilinna } 2778da7f033dSHerbert Xu 27794e7babbaSEric Biggers /* The IV must be copied to a buffer, as the algorithm may modify it */ 27804e7babbaSEric Biggers if (ivsize) { 27814e7babbaSEric Biggers if (WARN_ON(ivsize > MAX_IVLEN)) 27824e7babbaSEric Biggers return -EINVAL; 27838efd972eSEric Biggers if (vec->generates_iv && !enc) 27848efd972eSEric Biggers memcpy(iv, vec->iv_out, ivsize); 27858efd972eSEric Biggers else if (vec->iv) 27864e7babbaSEric Biggers memcpy(iv, vec->iv, ivsize); 278708d6af8cSJussi Kivilinna else 27884e7babbaSEric Biggers memset(iv, 0, ivsize); 27894e7babbaSEric Biggers } else { 27904e7babbaSEric Biggers if (vec->generates_iv) { 2791951d1332SEric Biggers pr_err("alg: skcipher: %s has ivsize=0 but test vector %s generates IV!\n", 2792951d1332SEric Biggers driver, vec_name); 27934e7babbaSEric Biggers return -EINVAL; 27944e7babbaSEric Biggers } 27954e7babbaSEric Biggers iv = NULL; 2796da7f033dSHerbert Xu } 2797da7f033dSHerbert Xu 27984e7babbaSEric Biggers /* Build the src/dst scatterlists */ 27994e7babbaSEric Biggers input.iov_base = enc ? (void *)vec->ptext : (void *)vec->ctext; 28004e7babbaSEric Biggers input.iov_len = vec->len; 28014e7babbaSEric Biggers err = build_cipher_test_sglists(tsgls, cfg, alignmask, 28024e7babbaSEric Biggers vec->len, vec->len, &input, 1); 28034e7babbaSEric Biggers if (err) { 2804951d1332SEric Biggers pr_err("alg: skcipher: %s %s: error preparing scatterlists for test vector %s, cfg=\"%s\"\n", 2805951d1332SEric Biggers driver, op, vec_name, cfg->name); 28064e7babbaSEric Biggers return err; 2807da7f033dSHerbert Xu } 2808da7f033dSHerbert Xu 28094e7babbaSEric Biggers /* Do the actual encryption or decryption */ 28104e7babbaSEric Biggers testmgr_poison(req->__ctx, crypto_skcipher_reqsize(tfm)); 28114e7babbaSEric Biggers skcipher_request_set_callback(req, req_flags, crypto_req_done, &wait); 28124e7babbaSEric Biggers skcipher_request_set_crypt(req, tsgls->src.sgl_ptr, tsgls->dst.sgl_ptr, 28134e7babbaSEric Biggers vec->len, iv); 28146570737cSEric Biggers if (cfg->nosimd) 28156570737cSEric Biggers crypto_disable_simd_for_test(); 28166570737cSEric Biggers err = enc ? crypto_skcipher_encrypt(req) : crypto_skcipher_decrypt(req); 28176570737cSEric Biggers if (cfg->nosimd) 28186570737cSEric Biggers crypto_reenable_simd_for_test(); 28196570737cSEric Biggers err = crypto_wait_req(err, &wait); 2820da7f033dSHerbert Xu 2821fa353c99SEric Biggers /* Check that the algorithm didn't overwrite things it shouldn't have */ 2822fa353c99SEric Biggers if (req->cryptlen != vec->len || 2823fa353c99SEric Biggers req->iv != iv || 2824fa353c99SEric Biggers req->src != tsgls->src.sgl_ptr || 2825fa353c99SEric Biggers req->dst != tsgls->dst.sgl_ptr || 2826fa353c99SEric Biggers crypto_skcipher_reqtfm(req) != tfm || 2827fa353c99SEric Biggers req->base.complete != crypto_req_done || 2828fa353c99SEric Biggers req->base.flags != req_flags || 2829fa353c99SEric Biggers req->base.data != &wait) { 2830951d1332SEric Biggers pr_err("alg: skcipher: %s %s corrupted request struct on test vector %s, cfg=\"%s\"\n", 2831951d1332SEric Biggers driver, op, vec_name, cfg->name); 2832fa353c99SEric Biggers if (req->cryptlen != vec->len) 2833fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->cryptlen'\n"); 2834fa353c99SEric Biggers if (req->iv != iv) 2835fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->iv'\n"); 2836fa353c99SEric Biggers if (req->src != tsgls->src.sgl_ptr) 2837fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->src'\n"); 2838fa353c99SEric Biggers if (req->dst != tsgls->dst.sgl_ptr) 2839fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->dst'\n"); 2840fa353c99SEric Biggers if (crypto_skcipher_reqtfm(req) != tfm) 2841fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.tfm'\n"); 2842fa353c99SEric Biggers if (req->base.complete != crypto_req_done) 2843fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.complete'\n"); 2844fa353c99SEric Biggers if (req->base.flags != req_flags) 2845fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.flags'\n"); 2846fa353c99SEric Biggers if (req->base.data != &wait) 2847fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.data'\n"); 2848fa353c99SEric Biggers return -EINVAL; 2849fa353c99SEric Biggers } 2850fa353c99SEric Biggers if (is_test_sglist_corrupted(&tsgls->src)) { 2851951d1332SEric Biggers pr_err("alg: skcipher: %s %s corrupted src sgl on test vector %s, cfg=\"%s\"\n", 2852951d1332SEric Biggers driver, op, vec_name, cfg->name); 2853fa353c99SEric Biggers return -EINVAL; 2854fa353c99SEric Biggers } 2855fa353c99SEric Biggers if (tsgls->dst.sgl_ptr != tsgls->src.sgl && 2856fa353c99SEric Biggers is_test_sglist_corrupted(&tsgls->dst)) { 2857951d1332SEric Biggers pr_err("alg: skcipher: %s %s corrupted dst sgl on test vector %s, cfg=\"%s\"\n", 2858951d1332SEric Biggers driver, op, vec_name, cfg->name); 2859fa353c99SEric Biggers return -EINVAL; 2860fa353c99SEric Biggers } 2861fa353c99SEric Biggers 28625283a8eeSEric Biggers /* Check for success or failure */ 28635283a8eeSEric Biggers if (err) { 28645283a8eeSEric Biggers if (err == vec->crypt_error) 28655283a8eeSEric Biggers return 0; 2866951d1332SEric Biggers pr_err("alg: skcipher: %s %s failed on test vector %s; expected_error=%d, actual_error=%d, cfg=\"%s\"\n", 2867951d1332SEric Biggers driver, op, vec_name, vec->crypt_error, err, cfg->name); 28685283a8eeSEric Biggers return err; 28695283a8eeSEric Biggers } 28705283a8eeSEric Biggers if (vec->crypt_error) { 2871951d1332SEric Biggers pr_err("alg: skcipher: %s %s unexpectedly succeeded on test vector %s; expected_error=%d, cfg=\"%s\"\n", 2872951d1332SEric Biggers driver, op, vec_name, vec->crypt_error, cfg->name); 28735283a8eeSEric Biggers return -EINVAL; 28745283a8eeSEric Biggers } 28755283a8eeSEric Biggers 28764e7babbaSEric Biggers /* Check for the correct output (ciphertext or plaintext) */ 28774e7babbaSEric Biggers err = verify_correct_output(&tsgls->dst, enc ? vec->ctext : vec->ptext, 28784e7babbaSEric Biggers vec->len, 0, true); 28794e7babbaSEric Biggers if (err == -EOVERFLOW) { 2880951d1332SEric Biggers pr_err("alg: skcipher: %s %s overran dst buffer on test vector %s, cfg=\"%s\"\n", 2881951d1332SEric Biggers driver, op, vec_name, cfg->name); 28824e7babbaSEric Biggers return err; 28834e7babbaSEric Biggers } 28844e7babbaSEric Biggers if (err) { 2885951d1332SEric Biggers pr_err("alg: skcipher: %s %s test failed (wrong result) on test vector %s, cfg=\"%s\"\n", 2886951d1332SEric Biggers driver, op, vec_name, cfg->name); 28874e7babbaSEric Biggers return err; 28884e7babbaSEric Biggers } 288908d6af8cSJussi Kivilinna 28904e7babbaSEric Biggers /* If applicable, check that the algorithm generated the correct IV */ 28918efd972eSEric Biggers if (vec->iv_out && memcmp(iv, vec->iv_out, ivsize) != 0) { 2892951d1332SEric Biggers pr_err("alg: skcipher: %s %s test failed (wrong output IV) on test vector %s, cfg=\"%s\"\n", 2893951d1332SEric Biggers driver, op, vec_name, cfg->name); 28944e7babbaSEric Biggers hexdump(iv, ivsize); 28954e7babbaSEric Biggers return -EINVAL; 28963a338f20SJussi Kivilinna } 28973a338f20SJussi Kivilinna 28983a338f20SJussi Kivilinna return 0; 289908d6af8cSJussi Kivilinna } 290008d6af8cSJussi Kivilinna 29016e5972faSEric Biggers static int test_skcipher_vec(int enc, const struct cipher_testvec *vec, 29024e7babbaSEric Biggers unsigned int vec_num, 29034e7babbaSEric Biggers struct skcipher_request *req, 29044e7babbaSEric Biggers struct cipher_test_sglists *tsgls) 29054e7babbaSEric Biggers { 2906951d1332SEric Biggers char vec_name[16]; 29074e7babbaSEric Biggers unsigned int i; 29084e7babbaSEric Biggers int err; 29094e7babbaSEric Biggers 29104e7babbaSEric Biggers if (fips_enabled && vec->fips_skip) 29114e7babbaSEric Biggers return 0; 29124e7babbaSEric Biggers 2913951d1332SEric Biggers sprintf(vec_name, "%u", vec_num); 2914951d1332SEric Biggers 29154e7babbaSEric Biggers for (i = 0; i < ARRAY_SIZE(default_cipher_testvec_configs); i++) { 29166e5972faSEric Biggers err = test_skcipher_vec_cfg(enc, vec, vec_name, 29174e7babbaSEric Biggers &default_cipher_testvec_configs[i], 29184e7babbaSEric Biggers req, tsgls); 29194e7babbaSEric Biggers if (err) 29204e7babbaSEric Biggers return err; 29214e7babbaSEric Biggers } 29224e7babbaSEric Biggers 29234e7babbaSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 29244e7babbaSEric Biggers if (!noextratests) { 29254e7babbaSEric Biggers struct testvec_config cfg; 29264e7babbaSEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 29274e7babbaSEric Biggers 29284e7babbaSEric Biggers for (i = 0; i < fuzz_iterations; i++) { 29294e7babbaSEric Biggers generate_random_testvec_config(&cfg, cfgname, 29304e7babbaSEric Biggers sizeof(cfgname)); 29316e5972faSEric Biggers err = test_skcipher_vec_cfg(enc, vec, vec_name, 29324e7babbaSEric Biggers &cfg, req, tsgls); 29334e7babbaSEric Biggers if (err) 29344e7babbaSEric Biggers return err; 2935e63e1b0dSEric Biggers cond_resched(); 29364e7babbaSEric Biggers } 29374e7babbaSEric Biggers } 29384e7babbaSEric Biggers #endif 29394e7babbaSEric Biggers return 0; 29404e7babbaSEric Biggers } 29414e7babbaSEric Biggers 2942d435e10eSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 2943d435e10eSEric Biggers /* 2944d435e10eSEric Biggers * Generate a symmetric cipher test vector from the given implementation. 2945d435e10eSEric Biggers * Assumes the buffers in 'vec' were already allocated. 2946d435e10eSEric Biggers */ 2947d435e10eSEric Biggers static void generate_random_cipher_testvec(struct skcipher_request *req, 2948d435e10eSEric Biggers struct cipher_testvec *vec, 2949d435e10eSEric Biggers unsigned int maxdatasize, 2950d435e10eSEric Biggers char *name, size_t max_namelen) 2951d435e10eSEric Biggers { 2952d435e10eSEric Biggers struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 29539ac0d136SEric Biggers const unsigned int maxkeysize = crypto_skcipher_max_keysize(tfm); 2954d435e10eSEric Biggers const unsigned int ivsize = crypto_skcipher_ivsize(tfm); 2955d435e10eSEric Biggers struct scatterlist src, dst; 2956d435e10eSEric Biggers u8 iv[MAX_IVLEN]; 2957d435e10eSEric Biggers DECLARE_CRYPTO_WAIT(wait); 2958d435e10eSEric Biggers 2959d435e10eSEric Biggers /* Key: length in [0, maxkeysize], but usually choose maxkeysize */ 2960d435e10eSEric Biggers vec->klen = maxkeysize; 296181895a65SJason A. Donenfeld if (prandom_u32_max(4) == 0) 296281895a65SJason A. Donenfeld vec->klen = prandom_u32_max(maxkeysize + 1); 2963d435e10eSEric Biggers generate_random_bytes((u8 *)vec->key, vec->klen); 2964d435e10eSEric Biggers vec->setkey_error = crypto_skcipher_setkey(tfm, vec->key, vec->klen); 2965d435e10eSEric Biggers 2966d435e10eSEric Biggers /* IV */ 2967d435e10eSEric Biggers generate_random_bytes((u8 *)vec->iv, ivsize); 2968d435e10eSEric Biggers 2969d435e10eSEric Biggers /* Plaintext */ 2970d435e10eSEric Biggers vec->len = generate_random_length(maxdatasize); 2971d435e10eSEric Biggers generate_random_bytes((u8 *)vec->ptext, vec->len); 2972d435e10eSEric Biggers 2973d435e10eSEric Biggers /* If the key couldn't be set, no need to continue to encrypt. */ 2974d435e10eSEric Biggers if (vec->setkey_error) 2975d435e10eSEric Biggers goto done; 2976d435e10eSEric Biggers 2977d435e10eSEric Biggers /* Ciphertext */ 2978d435e10eSEric Biggers sg_init_one(&src, vec->ptext, vec->len); 2979d435e10eSEric Biggers sg_init_one(&dst, vec->ctext, vec->len); 2980d435e10eSEric Biggers memcpy(iv, vec->iv, ivsize); 2981d435e10eSEric Biggers skcipher_request_set_callback(req, 0, crypto_req_done, &wait); 2982d435e10eSEric Biggers skcipher_request_set_crypt(req, &src, &dst, vec->len, iv); 2983d435e10eSEric Biggers vec->crypt_error = crypto_wait_req(crypto_skcipher_encrypt(req), &wait); 2984eb455dbdSEric Biggers if (vec->crypt_error != 0) { 2985eb455dbdSEric Biggers /* 2986eb455dbdSEric Biggers * The only acceptable error here is for an invalid length, so 2987eb455dbdSEric Biggers * skcipher decryption should fail with the same error too. 2988eb455dbdSEric Biggers * We'll test for this. But to keep the API usage well-defined, 2989eb455dbdSEric Biggers * explicitly initialize the ciphertext buffer too. 2990eb455dbdSEric Biggers */ 2991eb455dbdSEric Biggers memset((u8 *)vec->ctext, 0, vec->len); 2992eb455dbdSEric Biggers } 2993d435e10eSEric Biggers done: 2994d435e10eSEric Biggers snprintf(name, max_namelen, "\"random: len=%u klen=%u\"", 2995d435e10eSEric Biggers vec->len, vec->klen); 2996d435e10eSEric Biggers } 2997d435e10eSEric Biggers 2998d435e10eSEric Biggers /* 2999d435e10eSEric Biggers * Test the skcipher algorithm represented by @req against the corresponding 3000d435e10eSEric Biggers * generic implementation, if one is available. 3001d435e10eSEric Biggers */ 30026e5972faSEric Biggers static int test_skcipher_vs_generic_impl(const char *generic_driver, 3003d435e10eSEric Biggers struct skcipher_request *req, 3004d435e10eSEric Biggers struct cipher_test_sglists *tsgls) 3005d435e10eSEric Biggers { 3006d435e10eSEric Biggers struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 30079ac0d136SEric Biggers const unsigned int maxkeysize = crypto_skcipher_max_keysize(tfm); 3008d435e10eSEric Biggers const unsigned int ivsize = crypto_skcipher_ivsize(tfm); 3009d435e10eSEric Biggers const unsigned int blocksize = crypto_skcipher_blocksize(tfm); 3010d435e10eSEric Biggers const unsigned int maxdatasize = (2 * PAGE_SIZE) - TESTMGR_POISON_LEN; 3011d435e10eSEric Biggers const char *algname = crypto_skcipher_alg(tfm)->base.cra_name; 30126e5972faSEric Biggers const char *driver = crypto_skcipher_driver_name(tfm); 3013d435e10eSEric Biggers char _generic_driver[CRYPTO_MAX_ALG_NAME]; 3014d435e10eSEric Biggers struct crypto_skcipher *generic_tfm = NULL; 3015d435e10eSEric Biggers struct skcipher_request *generic_req = NULL; 3016d435e10eSEric Biggers unsigned int i; 3017d435e10eSEric Biggers struct cipher_testvec vec = { 0 }; 3018d435e10eSEric Biggers char vec_name[64]; 30196b5ca646SArnd Bergmann struct testvec_config *cfg; 3020d435e10eSEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 3021d435e10eSEric Biggers int err; 3022d435e10eSEric Biggers 3023d435e10eSEric Biggers if (noextratests) 3024d435e10eSEric Biggers return 0; 3025d435e10eSEric Biggers 3026d435e10eSEric Biggers /* Keywrap isn't supported here yet as it handles its IV differently. */ 3027d435e10eSEric Biggers if (strncmp(algname, "kw(", 3) == 0) 3028d435e10eSEric Biggers return 0; 3029d435e10eSEric Biggers 3030d435e10eSEric Biggers if (!generic_driver) { /* Use default naming convention? */ 3031d435e10eSEric Biggers err = build_generic_driver_name(algname, _generic_driver); 3032d435e10eSEric Biggers if (err) 3033d435e10eSEric Biggers return err; 3034d435e10eSEric Biggers generic_driver = _generic_driver; 3035d435e10eSEric Biggers } 3036d435e10eSEric Biggers 3037d435e10eSEric Biggers if (strcmp(generic_driver, driver) == 0) /* Already the generic impl? */ 3038d435e10eSEric Biggers return 0; 3039d435e10eSEric Biggers 3040d435e10eSEric Biggers generic_tfm = crypto_alloc_skcipher(generic_driver, 0, 0); 3041d435e10eSEric Biggers if (IS_ERR(generic_tfm)) { 3042d435e10eSEric Biggers err = PTR_ERR(generic_tfm); 3043d435e10eSEric Biggers if (err == -ENOENT) { 3044d435e10eSEric Biggers pr_warn("alg: skcipher: skipping comparison tests for %s because %s is unavailable\n", 3045d435e10eSEric Biggers driver, generic_driver); 3046d435e10eSEric Biggers return 0; 3047d435e10eSEric Biggers } 3048d435e10eSEric Biggers pr_err("alg: skcipher: error allocating %s (generic impl of %s): %d\n", 3049d435e10eSEric Biggers generic_driver, algname, err); 3050d435e10eSEric Biggers return err; 3051d435e10eSEric Biggers } 3052d435e10eSEric Biggers 30536b5ca646SArnd Bergmann cfg = kzalloc(sizeof(*cfg), GFP_KERNEL); 30546b5ca646SArnd Bergmann if (!cfg) { 30556b5ca646SArnd Bergmann err = -ENOMEM; 30566b5ca646SArnd Bergmann goto out; 30576b5ca646SArnd Bergmann } 30586b5ca646SArnd Bergmann 3059d435e10eSEric Biggers generic_req = skcipher_request_alloc(generic_tfm, GFP_KERNEL); 3060d435e10eSEric Biggers if (!generic_req) { 3061d435e10eSEric Biggers err = -ENOMEM; 3062d435e10eSEric Biggers goto out; 3063d435e10eSEric Biggers } 3064d435e10eSEric Biggers 3065d435e10eSEric Biggers /* Check the algorithm properties for consistency. */ 3066d435e10eSEric Biggers 3067fd60f727SEric Biggers if (crypto_skcipher_min_keysize(tfm) != 3068fd60f727SEric Biggers crypto_skcipher_min_keysize(generic_tfm)) { 3069fd60f727SEric Biggers pr_err("alg: skcipher: min keysize for %s (%u) doesn't match generic impl (%u)\n", 3070fd60f727SEric Biggers driver, crypto_skcipher_min_keysize(tfm), 3071fd60f727SEric Biggers crypto_skcipher_min_keysize(generic_tfm)); 3072fd60f727SEric Biggers err = -EINVAL; 3073fd60f727SEric Biggers goto out; 3074fd60f727SEric Biggers } 3075fd60f727SEric Biggers 30769ac0d136SEric Biggers if (maxkeysize != crypto_skcipher_max_keysize(generic_tfm)) { 3077d435e10eSEric Biggers pr_err("alg: skcipher: max keysize for %s (%u) doesn't match generic impl (%u)\n", 30789ac0d136SEric Biggers driver, maxkeysize, 30799ac0d136SEric Biggers crypto_skcipher_max_keysize(generic_tfm)); 3080d435e10eSEric Biggers err = -EINVAL; 3081d435e10eSEric Biggers goto out; 3082d435e10eSEric Biggers } 3083d435e10eSEric Biggers 3084d435e10eSEric Biggers if (ivsize != crypto_skcipher_ivsize(generic_tfm)) { 3085d435e10eSEric Biggers pr_err("alg: skcipher: ivsize for %s (%u) doesn't match generic impl (%u)\n", 3086d435e10eSEric Biggers driver, ivsize, crypto_skcipher_ivsize(generic_tfm)); 3087d435e10eSEric Biggers err = -EINVAL; 3088d435e10eSEric Biggers goto out; 3089d435e10eSEric Biggers } 3090d435e10eSEric Biggers 3091d435e10eSEric Biggers if (blocksize != crypto_skcipher_blocksize(generic_tfm)) { 3092d435e10eSEric Biggers pr_err("alg: skcipher: blocksize for %s (%u) doesn't match generic impl (%u)\n", 3093d435e10eSEric Biggers driver, blocksize, 3094d435e10eSEric Biggers crypto_skcipher_blocksize(generic_tfm)); 3095d435e10eSEric Biggers err = -EINVAL; 3096d435e10eSEric Biggers goto out; 3097d435e10eSEric Biggers } 3098d435e10eSEric Biggers 3099d435e10eSEric Biggers /* 3100d435e10eSEric Biggers * Now generate test vectors using the generic implementation, and test 3101d435e10eSEric Biggers * the other implementation against them. 3102d435e10eSEric Biggers */ 3103d435e10eSEric Biggers 31049ac0d136SEric Biggers vec.key = kmalloc(maxkeysize, GFP_KERNEL); 3105d435e10eSEric Biggers vec.iv = kmalloc(ivsize, GFP_KERNEL); 3106d435e10eSEric Biggers vec.ptext = kmalloc(maxdatasize, GFP_KERNEL); 3107d435e10eSEric Biggers vec.ctext = kmalloc(maxdatasize, GFP_KERNEL); 3108d435e10eSEric Biggers if (!vec.key || !vec.iv || !vec.ptext || !vec.ctext) { 3109d435e10eSEric Biggers err = -ENOMEM; 3110d435e10eSEric Biggers goto out; 3111d435e10eSEric Biggers } 3112d435e10eSEric Biggers 3113d435e10eSEric Biggers for (i = 0; i < fuzz_iterations * 8; i++) { 3114d435e10eSEric Biggers generate_random_cipher_testvec(generic_req, &vec, maxdatasize, 3115d435e10eSEric Biggers vec_name, sizeof(vec_name)); 31166b5ca646SArnd Bergmann generate_random_testvec_config(cfg, cfgname, sizeof(cfgname)); 3117d435e10eSEric Biggers 31186e5972faSEric Biggers err = test_skcipher_vec_cfg(ENCRYPT, &vec, vec_name, 31196b5ca646SArnd Bergmann cfg, req, tsgls); 3120d435e10eSEric Biggers if (err) 3121d435e10eSEric Biggers goto out; 31226e5972faSEric Biggers err = test_skcipher_vec_cfg(DECRYPT, &vec, vec_name, 31236b5ca646SArnd Bergmann cfg, req, tsgls); 3124d435e10eSEric Biggers if (err) 3125d435e10eSEric Biggers goto out; 3126d435e10eSEric Biggers cond_resched(); 3127d435e10eSEric Biggers } 3128d435e10eSEric Biggers err = 0; 3129d435e10eSEric Biggers out: 31306b5ca646SArnd Bergmann kfree(cfg); 3131d435e10eSEric Biggers kfree(vec.key); 3132d435e10eSEric Biggers kfree(vec.iv); 3133d435e10eSEric Biggers kfree(vec.ptext); 3134d435e10eSEric Biggers kfree(vec.ctext); 3135d435e10eSEric Biggers crypto_free_skcipher(generic_tfm); 3136d435e10eSEric Biggers skcipher_request_free(generic_req); 3137d435e10eSEric Biggers return err; 3138d435e10eSEric Biggers } 3139d435e10eSEric Biggers #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 31406e5972faSEric Biggers static int test_skcipher_vs_generic_impl(const char *generic_driver, 3141d435e10eSEric Biggers struct skcipher_request *req, 3142d435e10eSEric Biggers struct cipher_test_sglists *tsgls) 3143d435e10eSEric Biggers { 3144d435e10eSEric Biggers return 0; 3145d435e10eSEric Biggers } 3146d435e10eSEric Biggers #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 3147d435e10eSEric Biggers 31486e5972faSEric Biggers static int test_skcipher(int enc, const struct cipher_test_suite *suite, 31494e7babbaSEric Biggers struct skcipher_request *req, 31504e7babbaSEric Biggers struct cipher_test_sglists *tsgls) 31514e7babbaSEric Biggers { 31524e7babbaSEric Biggers unsigned int i; 31534e7babbaSEric Biggers int err; 31544e7babbaSEric Biggers 31554e7babbaSEric Biggers for (i = 0; i < suite->count; i++) { 31566e5972faSEric Biggers err = test_skcipher_vec(enc, &suite->vecs[i], i, req, tsgls); 31574e7babbaSEric Biggers if (err) 31584e7babbaSEric Biggers return err; 3159e63e1b0dSEric Biggers cond_resched(); 31604e7babbaSEric Biggers } 31614e7babbaSEric Biggers return 0; 31624e7babbaSEric Biggers } 31634e7babbaSEric Biggers 31644e7babbaSEric Biggers static int alg_test_skcipher(const struct alg_test_desc *desc, 31654e7babbaSEric Biggers const char *driver, u32 type, u32 mask) 31664e7babbaSEric Biggers { 31674e7babbaSEric Biggers const struct cipher_test_suite *suite = &desc->suite.cipher; 31684e7babbaSEric Biggers struct crypto_skcipher *tfm; 31694e7babbaSEric Biggers struct skcipher_request *req = NULL; 31704e7babbaSEric Biggers struct cipher_test_sglists *tsgls = NULL; 31714e7babbaSEric Biggers int err; 31724e7babbaSEric Biggers 31734e7babbaSEric Biggers if (suite->count <= 0) { 31744e7babbaSEric Biggers pr_err("alg: skcipher: empty test suite for %s\n", driver); 31754e7babbaSEric Biggers return -EINVAL; 31764e7babbaSEric Biggers } 31774e7babbaSEric Biggers 31784e7babbaSEric Biggers tfm = crypto_alloc_skcipher(driver, type, mask); 31794e7babbaSEric Biggers if (IS_ERR(tfm)) { 31804e7babbaSEric Biggers pr_err("alg: skcipher: failed to allocate transform for %s: %ld\n", 31814e7babbaSEric Biggers driver, PTR_ERR(tfm)); 31824e7babbaSEric Biggers return PTR_ERR(tfm); 31834e7babbaSEric Biggers } 31846e5972faSEric Biggers driver = crypto_skcipher_driver_name(tfm); 31854e7babbaSEric Biggers 31864e7babbaSEric Biggers req = skcipher_request_alloc(tfm, GFP_KERNEL); 31874e7babbaSEric Biggers if (!req) { 31884e7babbaSEric Biggers pr_err("alg: skcipher: failed to allocate request for %s\n", 31894e7babbaSEric Biggers driver); 31904e7babbaSEric Biggers err = -ENOMEM; 31914e7babbaSEric Biggers goto out; 31924e7babbaSEric Biggers } 31934e7babbaSEric Biggers 31944e7babbaSEric Biggers tsgls = alloc_cipher_test_sglists(); 31954e7babbaSEric Biggers if (!tsgls) { 31964e7babbaSEric Biggers pr_err("alg: skcipher: failed to allocate test buffers for %s\n", 31974e7babbaSEric Biggers driver); 31984e7babbaSEric Biggers err = -ENOMEM; 31994e7babbaSEric Biggers goto out; 32004e7babbaSEric Biggers } 32014e7babbaSEric Biggers 32026e5972faSEric Biggers err = test_skcipher(ENCRYPT, suite, req, tsgls); 32034e7babbaSEric Biggers if (err) 32044e7babbaSEric Biggers goto out; 32054e7babbaSEric Biggers 32066e5972faSEric Biggers err = test_skcipher(DECRYPT, suite, req, tsgls); 3207d435e10eSEric Biggers if (err) 3208d435e10eSEric Biggers goto out; 3209d435e10eSEric Biggers 32106e5972faSEric Biggers err = test_skcipher_vs_generic_impl(desc->generic_driver, req, tsgls); 32114e7babbaSEric Biggers out: 32124e7babbaSEric Biggers free_cipher_test_sglists(tsgls); 32134e7babbaSEric Biggers skcipher_request_free(req); 32144e7babbaSEric Biggers crypto_free_skcipher(tfm); 32154e7babbaSEric Biggers return err; 32164e7babbaSEric Biggers } 32174e7babbaSEric Biggers 3218b13b1e0cSEric Biggers static int test_comp(struct crypto_comp *tfm, 3219b13b1e0cSEric Biggers const struct comp_testvec *ctemplate, 3220b13b1e0cSEric Biggers const struct comp_testvec *dtemplate, 3221b13b1e0cSEric Biggers int ctcount, int dtcount) 3222da7f033dSHerbert Xu { 3223da7f033dSHerbert Xu const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm)); 322433607384SMahipal Challa char *output, *decomp_output; 3225da7f033dSHerbert Xu unsigned int i; 3226da7f033dSHerbert Xu int ret; 3227da7f033dSHerbert Xu 322833607384SMahipal Challa output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 322933607384SMahipal Challa if (!output) 323033607384SMahipal Challa return -ENOMEM; 323133607384SMahipal Challa 323233607384SMahipal Challa decomp_output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 323333607384SMahipal Challa if (!decomp_output) { 323433607384SMahipal Challa kfree(output); 323533607384SMahipal Challa return -ENOMEM; 323633607384SMahipal Challa } 323733607384SMahipal Challa 3238da7f033dSHerbert Xu for (i = 0; i < ctcount; i++) { 3239c79cf910SGeert Uytterhoeven int ilen; 3240c79cf910SGeert Uytterhoeven unsigned int dlen = COMP_BUF_SIZE; 3241da7f033dSHerbert Xu 324222a8118dSMichael Schupikov memset(output, 0, COMP_BUF_SIZE); 324322a8118dSMichael Schupikov memset(decomp_output, 0, COMP_BUF_SIZE); 3244da7f033dSHerbert Xu 3245da7f033dSHerbert Xu ilen = ctemplate[i].inlen; 3246da7f033dSHerbert Xu ret = crypto_comp_compress(tfm, ctemplate[i].input, 324733607384SMahipal Challa ilen, output, &dlen); 3248da7f033dSHerbert Xu if (ret) { 3249da7f033dSHerbert Xu printk(KERN_ERR "alg: comp: compression failed " 3250da7f033dSHerbert Xu "on test %d for %s: ret=%d\n", i + 1, algo, 3251da7f033dSHerbert Xu -ret); 3252da7f033dSHerbert Xu goto out; 3253da7f033dSHerbert Xu } 3254da7f033dSHerbert Xu 325533607384SMahipal Challa ilen = dlen; 325633607384SMahipal Challa dlen = COMP_BUF_SIZE; 325733607384SMahipal Challa ret = crypto_comp_decompress(tfm, output, 325833607384SMahipal Challa ilen, decomp_output, &dlen); 325933607384SMahipal Challa if (ret) { 326033607384SMahipal Challa pr_err("alg: comp: compression failed: decompress: on test %d for %s failed: ret=%d\n", 326133607384SMahipal Challa i + 1, algo, -ret); 326233607384SMahipal Challa goto out; 326333607384SMahipal Challa } 326433607384SMahipal Challa 326533607384SMahipal Challa if (dlen != ctemplate[i].inlen) { 3266b812eb00SGeert Uytterhoeven printk(KERN_ERR "alg: comp: Compression test %d " 3267b812eb00SGeert Uytterhoeven "failed for %s: output len = %d\n", i + 1, algo, 3268b812eb00SGeert Uytterhoeven dlen); 3269b812eb00SGeert Uytterhoeven ret = -EINVAL; 3270b812eb00SGeert Uytterhoeven goto out; 3271b812eb00SGeert Uytterhoeven } 3272b812eb00SGeert Uytterhoeven 327333607384SMahipal Challa if (memcmp(decomp_output, ctemplate[i].input, 327433607384SMahipal Challa ctemplate[i].inlen)) { 327533607384SMahipal Challa pr_err("alg: comp: compression failed: output differs: on test %d for %s\n", 327633607384SMahipal Challa i + 1, algo); 327733607384SMahipal Challa hexdump(decomp_output, dlen); 3278da7f033dSHerbert Xu ret = -EINVAL; 3279da7f033dSHerbert Xu goto out; 3280da7f033dSHerbert Xu } 3281da7f033dSHerbert Xu } 3282da7f033dSHerbert Xu 3283da7f033dSHerbert Xu for (i = 0; i < dtcount; i++) { 3284c79cf910SGeert Uytterhoeven int ilen; 3285c79cf910SGeert Uytterhoeven unsigned int dlen = COMP_BUF_SIZE; 3286da7f033dSHerbert Xu 328722a8118dSMichael Schupikov memset(decomp_output, 0, COMP_BUF_SIZE); 3288da7f033dSHerbert Xu 3289da7f033dSHerbert Xu ilen = dtemplate[i].inlen; 3290da7f033dSHerbert Xu ret = crypto_comp_decompress(tfm, dtemplate[i].input, 329133607384SMahipal Challa ilen, decomp_output, &dlen); 3292da7f033dSHerbert Xu if (ret) { 3293da7f033dSHerbert Xu printk(KERN_ERR "alg: comp: decompression failed " 3294da7f033dSHerbert Xu "on test %d for %s: ret=%d\n", i + 1, algo, 3295da7f033dSHerbert Xu -ret); 3296da7f033dSHerbert Xu goto out; 3297da7f033dSHerbert Xu } 3298da7f033dSHerbert Xu 3299b812eb00SGeert Uytterhoeven if (dlen != dtemplate[i].outlen) { 3300b812eb00SGeert Uytterhoeven printk(KERN_ERR "alg: comp: Decompression test %d " 3301b812eb00SGeert Uytterhoeven "failed for %s: output len = %d\n", i + 1, algo, 3302b812eb00SGeert Uytterhoeven dlen); 3303b812eb00SGeert Uytterhoeven ret = -EINVAL; 3304b812eb00SGeert Uytterhoeven goto out; 3305b812eb00SGeert Uytterhoeven } 3306b812eb00SGeert Uytterhoeven 330733607384SMahipal Challa if (memcmp(decomp_output, dtemplate[i].output, dlen)) { 3308da7f033dSHerbert Xu printk(KERN_ERR "alg: comp: Decompression test %d " 3309da7f033dSHerbert Xu "failed for %s\n", i + 1, algo); 331033607384SMahipal Challa hexdump(decomp_output, dlen); 3311da7f033dSHerbert Xu ret = -EINVAL; 3312da7f033dSHerbert Xu goto out; 3313da7f033dSHerbert Xu } 3314da7f033dSHerbert Xu } 3315da7f033dSHerbert Xu 3316da7f033dSHerbert Xu ret = 0; 3317da7f033dSHerbert Xu 3318da7f033dSHerbert Xu out: 331933607384SMahipal Challa kfree(decomp_output); 332033607384SMahipal Challa kfree(output); 3321da7f033dSHerbert Xu return ret; 3322da7f033dSHerbert Xu } 3323da7f033dSHerbert Xu 3324b13b1e0cSEric Biggers static int test_acomp(struct crypto_acomp *tfm, 3325b13b1e0cSEric Biggers const struct comp_testvec *ctemplate, 3326b13b1e0cSEric Biggers const struct comp_testvec *dtemplate, 3327b13b1e0cSEric Biggers int ctcount, int dtcount) 3328d7db7a88SGiovanni Cabiddu { 3329d7db7a88SGiovanni Cabiddu const char *algo = crypto_tfm_alg_driver_name(crypto_acomp_tfm(tfm)); 3330d7db7a88SGiovanni Cabiddu unsigned int i; 3331a9943a0aSGiovanni Cabiddu char *output, *decomp_out; 3332d7db7a88SGiovanni Cabiddu int ret; 3333d7db7a88SGiovanni Cabiddu struct scatterlist src, dst; 3334d7db7a88SGiovanni Cabiddu struct acomp_req *req; 33357f397136SGilad Ben-Yossef struct crypto_wait wait; 3336d7db7a88SGiovanni Cabiddu 3337eb095593SEric Biggers output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 3338eb095593SEric Biggers if (!output) 3339eb095593SEric Biggers return -ENOMEM; 3340eb095593SEric Biggers 3341a9943a0aSGiovanni Cabiddu decomp_out = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 3342a9943a0aSGiovanni Cabiddu if (!decomp_out) { 3343a9943a0aSGiovanni Cabiddu kfree(output); 3344a9943a0aSGiovanni Cabiddu return -ENOMEM; 3345a9943a0aSGiovanni Cabiddu } 3346a9943a0aSGiovanni Cabiddu 3347d7db7a88SGiovanni Cabiddu for (i = 0; i < ctcount; i++) { 3348d7db7a88SGiovanni Cabiddu unsigned int dlen = COMP_BUF_SIZE; 3349d7db7a88SGiovanni Cabiddu int ilen = ctemplate[i].inlen; 335002608e02SLaura Abbott void *input_vec; 3351d7db7a88SGiovanni Cabiddu 3352d2110224SEric Biggers input_vec = kmemdup(ctemplate[i].input, ilen, GFP_KERNEL); 335302608e02SLaura Abbott if (!input_vec) { 335402608e02SLaura Abbott ret = -ENOMEM; 335502608e02SLaura Abbott goto out; 335602608e02SLaura Abbott } 335702608e02SLaura Abbott 3358eb095593SEric Biggers memset(output, 0, dlen); 33597f397136SGilad Ben-Yossef crypto_init_wait(&wait); 336002608e02SLaura Abbott sg_init_one(&src, input_vec, ilen); 3361d7db7a88SGiovanni Cabiddu sg_init_one(&dst, output, dlen); 3362d7db7a88SGiovanni Cabiddu 3363d7db7a88SGiovanni Cabiddu req = acomp_request_alloc(tfm); 3364d7db7a88SGiovanni Cabiddu if (!req) { 3365d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: request alloc failed for %s\n", 3366d7db7a88SGiovanni Cabiddu algo); 336702608e02SLaura Abbott kfree(input_vec); 3368d7db7a88SGiovanni Cabiddu ret = -ENOMEM; 3369d7db7a88SGiovanni Cabiddu goto out; 3370d7db7a88SGiovanni Cabiddu } 3371d7db7a88SGiovanni Cabiddu 3372d7db7a88SGiovanni Cabiddu acomp_request_set_params(req, &src, &dst, ilen, dlen); 3373d7db7a88SGiovanni Cabiddu acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 33747f397136SGilad Ben-Yossef crypto_req_done, &wait); 3375d7db7a88SGiovanni Cabiddu 33767f397136SGilad Ben-Yossef ret = crypto_wait_req(crypto_acomp_compress(req), &wait); 3377d7db7a88SGiovanni Cabiddu if (ret) { 3378d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n", 3379d7db7a88SGiovanni Cabiddu i + 1, algo, -ret); 338002608e02SLaura Abbott kfree(input_vec); 3381d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3382d7db7a88SGiovanni Cabiddu goto out; 3383d7db7a88SGiovanni Cabiddu } 3384d7db7a88SGiovanni Cabiddu 3385a9943a0aSGiovanni Cabiddu ilen = req->dlen; 3386a9943a0aSGiovanni Cabiddu dlen = COMP_BUF_SIZE; 3387a9943a0aSGiovanni Cabiddu sg_init_one(&src, output, ilen); 3388a9943a0aSGiovanni Cabiddu sg_init_one(&dst, decomp_out, dlen); 33897f397136SGilad Ben-Yossef crypto_init_wait(&wait); 3390a9943a0aSGiovanni Cabiddu acomp_request_set_params(req, &src, &dst, ilen, dlen); 3391a9943a0aSGiovanni Cabiddu 33927f397136SGilad Ben-Yossef ret = crypto_wait_req(crypto_acomp_decompress(req), &wait); 3393a9943a0aSGiovanni Cabiddu if (ret) { 3394a9943a0aSGiovanni Cabiddu pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n", 3395a9943a0aSGiovanni Cabiddu i + 1, algo, -ret); 3396a9943a0aSGiovanni Cabiddu kfree(input_vec); 3397a9943a0aSGiovanni Cabiddu acomp_request_free(req); 3398a9943a0aSGiovanni Cabiddu goto out; 3399a9943a0aSGiovanni Cabiddu } 3400a9943a0aSGiovanni Cabiddu 3401a9943a0aSGiovanni Cabiddu if (req->dlen != ctemplate[i].inlen) { 3402d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Compression test %d failed for %s: output len = %d\n", 3403d7db7a88SGiovanni Cabiddu i + 1, algo, req->dlen); 3404d7db7a88SGiovanni Cabiddu ret = -EINVAL; 340502608e02SLaura Abbott kfree(input_vec); 3406d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3407d7db7a88SGiovanni Cabiddu goto out; 3408d7db7a88SGiovanni Cabiddu } 3409d7db7a88SGiovanni Cabiddu 3410a9943a0aSGiovanni Cabiddu if (memcmp(input_vec, decomp_out, req->dlen)) { 3411d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Compression test %d failed for %s\n", 3412d7db7a88SGiovanni Cabiddu i + 1, algo); 3413d7db7a88SGiovanni Cabiddu hexdump(output, 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 34205a4c2936SLucas Segarra Fernandez #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 34215a4c2936SLucas Segarra Fernandez crypto_init_wait(&wait); 34225a4c2936SLucas Segarra Fernandez sg_init_one(&src, input_vec, ilen); 34235a4c2936SLucas Segarra Fernandez acomp_request_set_params(req, &src, NULL, ilen, 0); 34245a4c2936SLucas Segarra Fernandez 34255a4c2936SLucas Segarra Fernandez ret = crypto_wait_req(crypto_acomp_compress(req), &wait); 34265a4c2936SLucas Segarra Fernandez if (ret) { 34275a4c2936SLucas Segarra Fernandez pr_err("alg: acomp: compression failed on NULL dst buffer test %d for %s: ret=%d\n", 34285a4c2936SLucas Segarra Fernandez i + 1, algo, -ret); 34295a4c2936SLucas Segarra Fernandez kfree(input_vec); 34305a4c2936SLucas Segarra Fernandez acomp_request_free(req); 34315a4c2936SLucas Segarra Fernandez goto out; 34325a4c2936SLucas Segarra Fernandez } 34335a4c2936SLucas Segarra Fernandez #endif 34345a4c2936SLucas Segarra Fernandez 343502608e02SLaura Abbott kfree(input_vec); 3436d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3437d7db7a88SGiovanni Cabiddu } 3438d7db7a88SGiovanni Cabiddu 3439d7db7a88SGiovanni Cabiddu for (i = 0; i < dtcount; i++) { 3440d7db7a88SGiovanni Cabiddu unsigned int dlen = COMP_BUF_SIZE; 3441d7db7a88SGiovanni Cabiddu int ilen = dtemplate[i].inlen; 344202608e02SLaura Abbott void *input_vec; 3443d7db7a88SGiovanni Cabiddu 3444d2110224SEric Biggers input_vec = kmemdup(dtemplate[i].input, ilen, GFP_KERNEL); 344502608e02SLaura Abbott if (!input_vec) { 344602608e02SLaura Abbott ret = -ENOMEM; 344702608e02SLaura Abbott goto out; 344802608e02SLaura Abbott } 344902608e02SLaura Abbott 3450eb095593SEric Biggers memset(output, 0, dlen); 34517f397136SGilad Ben-Yossef crypto_init_wait(&wait); 345202608e02SLaura Abbott sg_init_one(&src, input_vec, ilen); 3453d7db7a88SGiovanni Cabiddu sg_init_one(&dst, output, dlen); 3454d7db7a88SGiovanni Cabiddu 3455d7db7a88SGiovanni Cabiddu req = acomp_request_alloc(tfm); 3456d7db7a88SGiovanni Cabiddu if (!req) { 3457d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: request alloc failed for %s\n", 3458d7db7a88SGiovanni Cabiddu algo); 345902608e02SLaura Abbott kfree(input_vec); 3460d7db7a88SGiovanni Cabiddu ret = -ENOMEM; 3461d7db7a88SGiovanni Cabiddu goto out; 3462d7db7a88SGiovanni Cabiddu } 3463d7db7a88SGiovanni Cabiddu 3464d7db7a88SGiovanni Cabiddu acomp_request_set_params(req, &src, &dst, ilen, dlen); 3465d7db7a88SGiovanni Cabiddu acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 34667f397136SGilad Ben-Yossef crypto_req_done, &wait); 3467d7db7a88SGiovanni Cabiddu 34687f397136SGilad Ben-Yossef ret = crypto_wait_req(crypto_acomp_decompress(req), &wait); 3469d7db7a88SGiovanni Cabiddu if (ret) { 3470d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: decompression failed on test %d for %s: ret=%d\n", 3471d7db7a88SGiovanni Cabiddu i + 1, algo, -ret); 347202608e02SLaura Abbott kfree(input_vec); 3473d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3474d7db7a88SGiovanni Cabiddu goto out; 3475d7db7a88SGiovanni Cabiddu } 3476d7db7a88SGiovanni Cabiddu 3477d7db7a88SGiovanni Cabiddu if (req->dlen != dtemplate[i].outlen) { 3478d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Decompression test %d failed for %s: output len = %d\n", 3479d7db7a88SGiovanni Cabiddu i + 1, algo, req->dlen); 3480d7db7a88SGiovanni Cabiddu ret = -EINVAL; 348102608e02SLaura Abbott kfree(input_vec); 3482d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3483d7db7a88SGiovanni Cabiddu goto out; 3484d7db7a88SGiovanni Cabiddu } 3485d7db7a88SGiovanni Cabiddu 3486d7db7a88SGiovanni Cabiddu if (memcmp(output, dtemplate[i].output, req->dlen)) { 3487d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Decompression test %d failed for %s\n", 3488d7db7a88SGiovanni Cabiddu i + 1, algo); 3489d7db7a88SGiovanni Cabiddu hexdump(output, req->dlen); 3490d7db7a88SGiovanni Cabiddu ret = -EINVAL; 349102608e02SLaura Abbott kfree(input_vec); 3492d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3493d7db7a88SGiovanni Cabiddu goto out; 3494d7db7a88SGiovanni Cabiddu } 3495d7db7a88SGiovanni Cabiddu 34965a4c2936SLucas Segarra Fernandez #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 34975a4c2936SLucas Segarra Fernandez crypto_init_wait(&wait); 34985a4c2936SLucas Segarra Fernandez acomp_request_set_params(req, &src, NULL, ilen, 0); 34995a4c2936SLucas Segarra Fernandez 35005a4c2936SLucas Segarra Fernandez ret = crypto_wait_req(crypto_acomp_decompress(req), &wait); 35015a4c2936SLucas Segarra Fernandez if (ret) { 35025a4c2936SLucas Segarra Fernandez pr_err("alg: acomp: decompression failed on NULL dst buffer test %d for %s: ret=%d\n", 35035a4c2936SLucas Segarra Fernandez i + 1, algo, -ret); 35045a4c2936SLucas Segarra Fernandez kfree(input_vec); 35055a4c2936SLucas Segarra Fernandez acomp_request_free(req); 35065a4c2936SLucas Segarra Fernandez goto out; 35075a4c2936SLucas Segarra Fernandez } 35085a4c2936SLucas Segarra Fernandez #endif 35095a4c2936SLucas Segarra Fernandez 351002608e02SLaura Abbott kfree(input_vec); 3511d7db7a88SGiovanni Cabiddu acomp_request_free(req); 3512d7db7a88SGiovanni Cabiddu } 3513d7db7a88SGiovanni Cabiddu 3514d7db7a88SGiovanni Cabiddu ret = 0; 3515d7db7a88SGiovanni Cabiddu 3516d7db7a88SGiovanni Cabiddu out: 3517a9943a0aSGiovanni Cabiddu kfree(decomp_out); 3518eb095593SEric Biggers kfree(output); 3519d7db7a88SGiovanni Cabiddu return ret; 3520d7db7a88SGiovanni Cabiddu } 3521d7db7a88SGiovanni Cabiddu 3522b13b1e0cSEric Biggers static int test_cprng(struct crypto_rng *tfm, 3523b13b1e0cSEric Biggers const struct cprng_testvec *template, 35247647d6ceSJarod Wilson unsigned int tcount) 35257647d6ceSJarod Wilson { 35267647d6ceSJarod Wilson const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm)); 3527fa4ef8a6SFelipe Contreras int err = 0, i, j, seedsize; 35287647d6ceSJarod Wilson u8 *seed; 35297647d6ceSJarod Wilson char result[32]; 35307647d6ceSJarod Wilson 35317647d6ceSJarod Wilson seedsize = crypto_rng_seedsize(tfm); 35327647d6ceSJarod Wilson 35337647d6ceSJarod Wilson seed = kmalloc(seedsize, GFP_KERNEL); 35347647d6ceSJarod Wilson if (!seed) { 35357647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to allocate seed space " 35367647d6ceSJarod Wilson "for %s\n", algo); 35377647d6ceSJarod Wilson return -ENOMEM; 35387647d6ceSJarod Wilson } 35397647d6ceSJarod Wilson 35407647d6ceSJarod Wilson for (i = 0; i < tcount; i++) { 35417647d6ceSJarod Wilson memset(result, 0, 32); 35427647d6ceSJarod Wilson 35437647d6ceSJarod Wilson memcpy(seed, template[i].v, template[i].vlen); 35447647d6ceSJarod Wilson memcpy(seed + template[i].vlen, template[i].key, 35457647d6ceSJarod Wilson template[i].klen); 35467647d6ceSJarod Wilson memcpy(seed + template[i].vlen + template[i].klen, 35477647d6ceSJarod Wilson template[i].dt, template[i].dtlen); 35487647d6ceSJarod Wilson 35497647d6ceSJarod Wilson err = crypto_rng_reset(tfm, seed, seedsize); 35507647d6ceSJarod Wilson if (err) { 35517647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to reset rng " 35527647d6ceSJarod Wilson "for %s\n", algo); 35537647d6ceSJarod Wilson goto out; 35547647d6ceSJarod Wilson } 35557647d6ceSJarod Wilson 35567647d6ceSJarod Wilson for (j = 0; j < template[i].loops; j++) { 35577647d6ceSJarod Wilson err = crypto_rng_get_bytes(tfm, result, 35587647d6ceSJarod Wilson template[i].rlen); 355919e60e13SStephan Mueller if (err < 0) { 35607647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to obtain " 35617647d6ceSJarod Wilson "the correct amount of random data for " 356219e60e13SStephan Mueller "%s (requested %d)\n", algo, 356319e60e13SStephan Mueller template[i].rlen); 35647647d6ceSJarod Wilson goto out; 35657647d6ceSJarod Wilson } 35667647d6ceSJarod Wilson } 35677647d6ceSJarod Wilson 35687647d6ceSJarod Wilson err = memcmp(result, template[i].result, 35697647d6ceSJarod Wilson template[i].rlen); 35707647d6ceSJarod Wilson if (err) { 35717647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Test %d failed for %s\n", 35727647d6ceSJarod Wilson i, algo); 35737647d6ceSJarod Wilson hexdump(result, template[i].rlen); 35747647d6ceSJarod Wilson err = -EINVAL; 35757647d6ceSJarod Wilson goto out; 35767647d6ceSJarod Wilson } 35777647d6ceSJarod Wilson } 35787647d6ceSJarod Wilson 35797647d6ceSJarod Wilson out: 35807647d6ceSJarod Wilson kfree(seed); 35817647d6ceSJarod Wilson return err; 35827647d6ceSJarod Wilson } 35837647d6ceSJarod Wilson 3584da7f033dSHerbert Xu static int alg_test_cipher(const struct alg_test_desc *desc, 3585da7f033dSHerbert Xu const char *driver, u32 type, u32 mask) 3586da7f033dSHerbert Xu { 358792a4c9feSEric Biggers const struct cipher_test_suite *suite = &desc->suite.cipher; 35881aa4ecd9SHerbert Xu struct crypto_cipher *tfm; 358992a4c9feSEric Biggers int err; 3590da7f033dSHerbert Xu 3591eed93e0cSHerbert Xu tfm = crypto_alloc_cipher(driver, type, mask); 3592da7f033dSHerbert Xu if (IS_ERR(tfm)) { 3593da7f033dSHerbert Xu printk(KERN_ERR "alg: cipher: Failed to load transform for " 3594da7f033dSHerbert Xu "%s: %ld\n", driver, PTR_ERR(tfm)); 3595da7f033dSHerbert Xu return PTR_ERR(tfm); 3596da7f033dSHerbert Xu } 3597da7f033dSHerbert Xu 359892a4c9feSEric Biggers err = test_cipher(tfm, ENCRYPT, suite->vecs, suite->count); 359992a4c9feSEric Biggers if (!err) 360092a4c9feSEric Biggers err = test_cipher(tfm, DECRYPT, suite->vecs, suite->count); 3601da7f033dSHerbert Xu 36021aa4ecd9SHerbert Xu crypto_free_cipher(tfm); 36031aa4ecd9SHerbert Xu return err; 36041aa4ecd9SHerbert Xu } 36051aa4ecd9SHerbert Xu 3606da7f033dSHerbert Xu static int alg_test_comp(const struct alg_test_desc *desc, const char *driver, 3607da7f033dSHerbert Xu u32 type, u32 mask) 3608da7f033dSHerbert Xu { 3609d7db7a88SGiovanni Cabiddu struct crypto_comp *comp; 3610d7db7a88SGiovanni Cabiddu struct crypto_acomp *acomp; 3611da7f033dSHerbert Xu int err; 3612d7db7a88SGiovanni Cabiddu u32 algo_type = type & CRYPTO_ALG_TYPE_ACOMPRESS_MASK; 3613da7f033dSHerbert Xu 3614d7db7a88SGiovanni Cabiddu if (algo_type == CRYPTO_ALG_TYPE_ACOMPRESS) { 3615d7db7a88SGiovanni Cabiddu acomp = crypto_alloc_acomp(driver, type, mask); 3616d7db7a88SGiovanni Cabiddu if (IS_ERR(acomp)) { 3617d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Failed to load transform for %s: %ld\n", 3618d7db7a88SGiovanni Cabiddu driver, PTR_ERR(acomp)); 3619d7db7a88SGiovanni Cabiddu return PTR_ERR(acomp); 3620d7db7a88SGiovanni Cabiddu } 3621d7db7a88SGiovanni Cabiddu err = test_acomp(acomp, desc->suite.comp.comp.vecs, 3622d7db7a88SGiovanni Cabiddu desc->suite.comp.decomp.vecs, 3623d7db7a88SGiovanni Cabiddu desc->suite.comp.comp.count, 3624d7db7a88SGiovanni Cabiddu desc->suite.comp.decomp.count); 3625d7db7a88SGiovanni Cabiddu crypto_free_acomp(acomp); 3626d7db7a88SGiovanni Cabiddu } else { 3627d7db7a88SGiovanni Cabiddu comp = crypto_alloc_comp(driver, type, mask); 3628d7db7a88SGiovanni Cabiddu if (IS_ERR(comp)) { 3629d7db7a88SGiovanni Cabiddu pr_err("alg: comp: Failed to load transform for %s: %ld\n", 3630d7db7a88SGiovanni Cabiddu driver, PTR_ERR(comp)); 3631d7db7a88SGiovanni Cabiddu return PTR_ERR(comp); 3632da7f033dSHerbert Xu } 3633da7f033dSHerbert Xu 3634d7db7a88SGiovanni Cabiddu err = test_comp(comp, desc->suite.comp.comp.vecs, 3635da7f033dSHerbert Xu desc->suite.comp.decomp.vecs, 3636da7f033dSHerbert Xu desc->suite.comp.comp.count, 3637da7f033dSHerbert Xu desc->suite.comp.decomp.count); 3638da7f033dSHerbert Xu 3639d7db7a88SGiovanni Cabiddu crypto_free_comp(comp); 3640d7db7a88SGiovanni Cabiddu } 3641da7f033dSHerbert Xu return err; 3642da7f033dSHerbert Xu } 3643da7f033dSHerbert Xu 36448e3ee85eSHerbert Xu static int alg_test_crc32c(const struct alg_test_desc *desc, 36458e3ee85eSHerbert Xu const char *driver, u32 type, u32 mask) 36468e3ee85eSHerbert Xu { 36478e3ee85eSHerbert Xu struct crypto_shash *tfm; 3648cb9dde88SEric Biggers __le32 val; 36498e3ee85eSHerbert Xu int err; 36508e3ee85eSHerbert Xu 36518e3ee85eSHerbert Xu err = alg_test_hash(desc, driver, type, mask); 36528e3ee85eSHerbert Xu if (err) 3653eb5e6730SEric Biggers return err; 36548e3ee85eSHerbert Xu 3655eed93e0cSHerbert Xu tfm = crypto_alloc_shash(driver, type, mask); 36568e3ee85eSHerbert Xu if (IS_ERR(tfm)) { 3657eb5e6730SEric Biggers if (PTR_ERR(tfm) == -ENOENT) { 3658eb5e6730SEric Biggers /* 3659eb5e6730SEric Biggers * This crc32c implementation is only available through 3660eb5e6730SEric Biggers * ahash API, not the shash API, so the remaining part 3661eb5e6730SEric Biggers * of the test is not applicable to it. 3662eb5e6730SEric Biggers */ 3663eb5e6730SEric Biggers return 0; 3664eb5e6730SEric Biggers } 36658e3ee85eSHerbert Xu printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: " 36668e3ee85eSHerbert Xu "%ld\n", driver, PTR_ERR(tfm)); 3667eb5e6730SEric Biggers return PTR_ERR(tfm); 36688e3ee85eSHerbert Xu } 366979cafe9aSEric Biggers driver = crypto_shash_driver_name(tfm); 36708e3ee85eSHerbert Xu 36718e3ee85eSHerbert Xu do { 36724c5c3024SJan-Simon Möller SHASH_DESC_ON_STACK(shash, tfm); 36734c5c3024SJan-Simon Möller u32 *ctx = (u32 *)shash_desc_ctx(shash); 36748e3ee85eSHerbert Xu 36754c5c3024SJan-Simon Möller shash->tfm = tfm; 36768e3ee85eSHerbert Xu 3677cb9dde88SEric Biggers *ctx = 420553207; 36784c5c3024SJan-Simon Möller err = crypto_shash_final(shash, (u8 *)&val); 36798e3ee85eSHerbert Xu if (err) { 36808e3ee85eSHerbert Xu printk(KERN_ERR "alg: crc32c: Operation failed for " 36818e3ee85eSHerbert Xu "%s: %d\n", driver, err); 36828e3ee85eSHerbert Xu break; 36838e3ee85eSHerbert Xu } 36848e3ee85eSHerbert Xu 3685cb9dde88SEric Biggers if (val != cpu_to_le32(~420553207)) { 3686cb9dde88SEric Biggers pr_err("alg: crc32c: Test failed for %s: %u\n", 3687cb9dde88SEric Biggers driver, le32_to_cpu(val)); 36888e3ee85eSHerbert Xu err = -EINVAL; 36898e3ee85eSHerbert Xu } 36908e3ee85eSHerbert Xu } while (0); 36918e3ee85eSHerbert Xu 36928e3ee85eSHerbert Xu crypto_free_shash(tfm); 36938e3ee85eSHerbert Xu 36948e3ee85eSHerbert Xu return err; 36958e3ee85eSHerbert Xu } 36968e3ee85eSHerbert Xu 36977647d6ceSJarod Wilson static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver, 36987647d6ceSJarod Wilson u32 type, u32 mask) 36997647d6ceSJarod Wilson { 37007647d6ceSJarod Wilson struct crypto_rng *rng; 37017647d6ceSJarod Wilson int err; 37027647d6ceSJarod Wilson 3703eed93e0cSHerbert Xu rng = crypto_alloc_rng(driver, type, mask); 37047647d6ceSJarod Wilson if (IS_ERR(rng)) { 37057647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to load transform for %s: " 37067647d6ceSJarod Wilson "%ld\n", driver, PTR_ERR(rng)); 37077647d6ceSJarod Wilson return PTR_ERR(rng); 37087647d6ceSJarod Wilson } 37097647d6ceSJarod Wilson 37107647d6ceSJarod Wilson err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count); 37117647d6ceSJarod Wilson 37127647d6ceSJarod Wilson crypto_free_rng(rng); 37137647d6ceSJarod Wilson 37147647d6ceSJarod Wilson return err; 37157647d6ceSJarod Wilson } 37167647d6ceSJarod Wilson 371764d1cdfbSStephan Mueller 3718b13b1e0cSEric Biggers static int drbg_cavs_test(const struct drbg_testvec *test, int pr, 371964d1cdfbSStephan Mueller const char *driver, u32 type, u32 mask) 372064d1cdfbSStephan Mueller { 372164d1cdfbSStephan Mueller int ret = -EAGAIN; 372264d1cdfbSStephan Mueller struct crypto_rng *drng; 372364d1cdfbSStephan Mueller struct drbg_test_data test_data; 372464d1cdfbSStephan Mueller struct drbg_string addtl, pers, testentropy; 372564d1cdfbSStephan Mueller unsigned char *buf = kzalloc(test->expectedlen, GFP_KERNEL); 372664d1cdfbSStephan Mueller 372764d1cdfbSStephan Mueller if (!buf) 372864d1cdfbSStephan Mueller return -ENOMEM; 372964d1cdfbSStephan Mueller 3730eed93e0cSHerbert Xu drng = crypto_alloc_rng(driver, type, mask); 373164d1cdfbSStephan Mueller if (IS_ERR(drng)) { 373264d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: could not allocate DRNG handle for " 373364d1cdfbSStephan Mueller "%s\n", driver); 3734453431a5SWaiman Long kfree_sensitive(buf); 373564d1cdfbSStephan Mueller return -ENOMEM; 373664d1cdfbSStephan Mueller } 373764d1cdfbSStephan Mueller 373864d1cdfbSStephan Mueller test_data.testentropy = &testentropy; 373964d1cdfbSStephan Mueller drbg_string_fill(&testentropy, test->entropy, test->entropylen); 374064d1cdfbSStephan Mueller drbg_string_fill(&pers, test->pers, test->perslen); 374164d1cdfbSStephan Mueller ret = crypto_drbg_reset_test(drng, &pers, &test_data); 374264d1cdfbSStephan Mueller if (ret) { 374364d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: Failed to reset rng\n"); 374464d1cdfbSStephan Mueller goto outbuf; 374564d1cdfbSStephan Mueller } 374664d1cdfbSStephan Mueller 374764d1cdfbSStephan Mueller drbg_string_fill(&addtl, test->addtla, test->addtllen); 374864d1cdfbSStephan Mueller if (pr) { 374964d1cdfbSStephan Mueller drbg_string_fill(&testentropy, test->entpra, test->entprlen); 375064d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl_test(drng, 375164d1cdfbSStephan Mueller buf, test->expectedlen, &addtl, &test_data); 375264d1cdfbSStephan Mueller } else { 375364d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl(drng, 375464d1cdfbSStephan Mueller buf, test->expectedlen, &addtl); 375564d1cdfbSStephan Mueller } 375619e60e13SStephan Mueller if (ret < 0) { 375764d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: could not obtain random data for " 375864d1cdfbSStephan Mueller "driver %s\n", driver); 375964d1cdfbSStephan Mueller goto outbuf; 376064d1cdfbSStephan Mueller } 376164d1cdfbSStephan Mueller 376264d1cdfbSStephan Mueller drbg_string_fill(&addtl, test->addtlb, test->addtllen); 376364d1cdfbSStephan Mueller if (pr) { 376464d1cdfbSStephan Mueller drbg_string_fill(&testentropy, test->entprb, test->entprlen); 376564d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl_test(drng, 376664d1cdfbSStephan Mueller buf, test->expectedlen, &addtl, &test_data); 376764d1cdfbSStephan Mueller } else { 376864d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl(drng, 376964d1cdfbSStephan Mueller buf, test->expectedlen, &addtl); 377064d1cdfbSStephan Mueller } 377119e60e13SStephan Mueller if (ret < 0) { 377264d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: could not obtain random data for " 377364d1cdfbSStephan Mueller "driver %s\n", driver); 377464d1cdfbSStephan Mueller goto outbuf; 377564d1cdfbSStephan Mueller } 377664d1cdfbSStephan Mueller 377764d1cdfbSStephan Mueller ret = memcmp(test->expected, buf, test->expectedlen); 377864d1cdfbSStephan Mueller 377964d1cdfbSStephan Mueller outbuf: 378064d1cdfbSStephan Mueller crypto_free_rng(drng); 3781453431a5SWaiman Long kfree_sensitive(buf); 378264d1cdfbSStephan Mueller return ret; 378364d1cdfbSStephan Mueller } 378464d1cdfbSStephan Mueller 378564d1cdfbSStephan Mueller 378664d1cdfbSStephan Mueller static int alg_test_drbg(const struct alg_test_desc *desc, const char *driver, 378764d1cdfbSStephan Mueller u32 type, u32 mask) 378864d1cdfbSStephan Mueller { 378964d1cdfbSStephan Mueller int err = 0; 379064d1cdfbSStephan Mueller int pr = 0; 379164d1cdfbSStephan Mueller int i = 0; 3792b13b1e0cSEric Biggers const struct drbg_testvec *template = desc->suite.drbg.vecs; 379364d1cdfbSStephan Mueller unsigned int tcount = desc->suite.drbg.count; 379464d1cdfbSStephan Mueller 379564d1cdfbSStephan Mueller if (0 == memcmp(driver, "drbg_pr_", 8)) 379664d1cdfbSStephan Mueller pr = 1; 379764d1cdfbSStephan Mueller 379864d1cdfbSStephan Mueller for (i = 0; i < tcount; i++) { 379964d1cdfbSStephan Mueller err = drbg_cavs_test(&template[i], pr, driver, type, mask); 380064d1cdfbSStephan Mueller if (err) { 380164d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: Test %d failed for %s\n", 380264d1cdfbSStephan Mueller i, driver); 380364d1cdfbSStephan Mueller err = -EINVAL; 380464d1cdfbSStephan Mueller break; 380564d1cdfbSStephan Mueller } 380664d1cdfbSStephan Mueller } 380764d1cdfbSStephan Mueller return err; 380864d1cdfbSStephan Mueller 380964d1cdfbSStephan Mueller } 381064d1cdfbSStephan Mueller 3811b13b1e0cSEric Biggers static int do_test_kpp(struct crypto_kpp *tfm, const struct kpp_testvec *vec, 3812802c7f1cSSalvatore Benedetto const char *alg) 3813802c7f1cSSalvatore Benedetto { 3814802c7f1cSSalvatore Benedetto struct kpp_request *req; 3815802c7f1cSSalvatore Benedetto void *input_buf = NULL; 3816802c7f1cSSalvatore Benedetto void *output_buf = NULL; 381747d3fd39STudor-Dan Ambarus void *a_public = NULL; 381847d3fd39STudor-Dan Ambarus void *a_ss = NULL; 381947d3fd39STudor-Dan Ambarus void *shared_secret = NULL; 38207f397136SGilad Ben-Yossef struct crypto_wait wait; 3821802c7f1cSSalvatore Benedetto unsigned int out_len_max; 3822802c7f1cSSalvatore Benedetto int err = -ENOMEM; 3823802c7f1cSSalvatore Benedetto struct scatterlist src, dst; 3824802c7f1cSSalvatore Benedetto 3825802c7f1cSSalvatore Benedetto req = kpp_request_alloc(tfm, GFP_KERNEL); 3826802c7f1cSSalvatore Benedetto if (!req) 3827802c7f1cSSalvatore Benedetto return err; 3828802c7f1cSSalvatore Benedetto 38297f397136SGilad Ben-Yossef crypto_init_wait(&wait); 3830802c7f1cSSalvatore Benedetto 3831802c7f1cSSalvatore Benedetto err = crypto_kpp_set_secret(tfm, vec->secret, vec->secret_size); 3832802c7f1cSSalvatore Benedetto if (err < 0) 3833802c7f1cSSalvatore Benedetto goto free_req; 3834802c7f1cSSalvatore Benedetto 3835802c7f1cSSalvatore Benedetto out_len_max = crypto_kpp_maxsize(tfm); 3836802c7f1cSSalvatore Benedetto output_buf = kzalloc(out_len_max, GFP_KERNEL); 3837802c7f1cSSalvatore Benedetto if (!output_buf) { 3838802c7f1cSSalvatore Benedetto err = -ENOMEM; 3839802c7f1cSSalvatore Benedetto goto free_req; 3840802c7f1cSSalvatore Benedetto } 3841802c7f1cSSalvatore Benedetto 3842802c7f1cSSalvatore Benedetto /* Use appropriate parameter as base */ 3843802c7f1cSSalvatore Benedetto kpp_request_set_input(req, NULL, 0); 3844802c7f1cSSalvatore Benedetto sg_init_one(&dst, output_buf, out_len_max); 3845802c7f1cSSalvatore Benedetto kpp_request_set_output(req, &dst, out_len_max); 3846802c7f1cSSalvatore Benedetto kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 38477f397136SGilad Ben-Yossef crypto_req_done, &wait); 3848802c7f1cSSalvatore Benedetto 384947d3fd39STudor-Dan Ambarus /* Compute party A's public key */ 38507f397136SGilad Ben-Yossef err = crypto_wait_req(crypto_kpp_generate_public_key(req), &wait); 3851802c7f1cSSalvatore Benedetto if (err) { 385247d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party A: generate public key test failed. err %d\n", 3853802c7f1cSSalvatore Benedetto alg, err); 3854802c7f1cSSalvatore Benedetto goto free_output; 3855802c7f1cSSalvatore Benedetto } 385647d3fd39STudor-Dan Ambarus 385747d3fd39STudor-Dan Ambarus if (vec->genkey) { 385847d3fd39STudor-Dan Ambarus /* Save party A's public key */ 3859e3d90e52SChristopher Diaz Riveros a_public = kmemdup(sg_virt(req->dst), out_len_max, GFP_KERNEL); 386047d3fd39STudor-Dan Ambarus if (!a_public) { 386147d3fd39STudor-Dan Ambarus err = -ENOMEM; 386247d3fd39STudor-Dan Ambarus goto free_output; 386347d3fd39STudor-Dan Ambarus } 386447d3fd39STudor-Dan Ambarus } else { 3865802c7f1cSSalvatore Benedetto /* Verify calculated public key */ 3866802c7f1cSSalvatore Benedetto if (memcmp(vec->expected_a_public, sg_virt(req->dst), 3867802c7f1cSSalvatore Benedetto vec->expected_a_public_size)) { 386847d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party A: generate public key test failed. Invalid output\n", 3869802c7f1cSSalvatore Benedetto alg); 3870802c7f1cSSalvatore Benedetto err = -EINVAL; 3871802c7f1cSSalvatore Benedetto goto free_output; 3872802c7f1cSSalvatore Benedetto } 387347d3fd39STudor-Dan Ambarus } 3874802c7f1cSSalvatore Benedetto 3875802c7f1cSSalvatore Benedetto /* Calculate shared secret key by using counter part (b) public key. */ 3876e3d90e52SChristopher Diaz Riveros input_buf = kmemdup(vec->b_public, vec->b_public_size, GFP_KERNEL); 3877802c7f1cSSalvatore Benedetto if (!input_buf) { 3878802c7f1cSSalvatore Benedetto err = -ENOMEM; 3879802c7f1cSSalvatore Benedetto goto free_output; 3880802c7f1cSSalvatore Benedetto } 3881802c7f1cSSalvatore Benedetto 3882802c7f1cSSalvatore Benedetto sg_init_one(&src, input_buf, vec->b_public_size); 3883802c7f1cSSalvatore Benedetto sg_init_one(&dst, output_buf, out_len_max); 3884802c7f1cSSalvatore Benedetto kpp_request_set_input(req, &src, vec->b_public_size); 3885802c7f1cSSalvatore Benedetto kpp_request_set_output(req, &dst, out_len_max); 3886802c7f1cSSalvatore Benedetto kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 38877f397136SGilad Ben-Yossef crypto_req_done, &wait); 38887f397136SGilad Ben-Yossef err = crypto_wait_req(crypto_kpp_compute_shared_secret(req), &wait); 3889802c7f1cSSalvatore Benedetto if (err) { 389047d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party A: compute shared secret test failed. err %d\n", 3891802c7f1cSSalvatore Benedetto alg, err); 3892802c7f1cSSalvatore Benedetto goto free_all; 3893802c7f1cSSalvatore Benedetto } 389447d3fd39STudor-Dan Ambarus 389547d3fd39STudor-Dan Ambarus if (vec->genkey) { 389647d3fd39STudor-Dan Ambarus /* Save the shared secret obtained by party A */ 3897e3d90e52SChristopher Diaz Riveros a_ss = kmemdup(sg_virt(req->dst), vec->expected_ss_size, GFP_KERNEL); 389847d3fd39STudor-Dan Ambarus if (!a_ss) { 389947d3fd39STudor-Dan Ambarus err = -ENOMEM; 390047d3fd39STudor-Dan Ambarus goto free_all; 390147d3fd39STudor-Dan Ambarus } 390247d3fd39STudor-Dan Ambarus 390347d3fd39STudor-Dan Ambarus /* 390447d3fd39STudor-Dan Ambarus * Calculate party B's shared secret by using party A's 390547d3fd39STudor-Dan Ambarus * public key. 390647d3fd39STudor-Dan Ambarus */ 390747d3fd39STudor-Dan Ambarus err = crypto_kpp_set_secret(tfm, vec->b_secret, 390847d3fd39STudor-Dan Ambarus vec->b_secret_size); 390947d3fd39STudor-Dan Ambarus if (err < 0) 391047d3fd39STudor-Dan Ambarus goto free_all; 391147d3fd39STudor-Dan Ambarus 391247d3fd39STudor-Dan Ambarus sg_init_one(&src, a_public, vec->expected_a_public_size); 391347d3fd39STudor-Dan Ambarus sg_init_one(&dst, output_buf, out_len_max); 391447d3fd39STudor-Dan Ambarus kpp_request_set_input(req, &src, vec->expected_a_public_size); 391547d3fd39STudor-Dan Ambarus kpp_request_set_output(req, &dst, out_len_max); 391647d3fd39STudor-Dan Ambarus kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 39177f397136SGilad Ben-Yossef crypto_req_done, &wait); 39187f397136SGilad Ben-Yossef err = crypto_wait_req(crypto_kpp_compute_shared_secret(req), 39197f397136SGilad Ben-Yossef &wait); 392047d3fd39STudor-Dan Ambarus if (err) { 392147d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party B: compute shared secret failed. err %d\n", 392247d3fd39STudor-Dan Ambarus alg, err); 392347d3fd39STudor-Dan Ambarus goto free_all; 392447d3fd39STudor-Dan Ambarus } 392547d3fd39STudor-Dan Ambarus 392647d3fd39STudor-Dan Ambarus shared_secret = a_ss; 392747d3fd39STudor-Dan Ambarus } else { 392847d3fd39STudor-Dan Ambarus shared_secret = (void *)vec->expected_ss; 392947d3fd39STudor-Dan Ambarus } 393047d3fd39STudor-Dan Ambarus 3931802c7f1cSSalvatore Benedetto /* 3932802c7f1cSSalvatore Benedetto * verify shared secret from which the user will derive 3933802c7f1cSSalvatore Benedetto * secret key by executing whatever hash it has chosen 3934802c7f1cSSalvatore Benedetto */ 393547d3fd39STudor-Dan Ambarus if (memcmp(shared_secret, sg_virt(req->dst), 3936802c7f1cSSalvatore Benedetto vec->expected_ss_size)) { 3937802c7f1cSSalvatore Benedetto pr_err("alg: %s: compute shared secret test failed. Invalid output\n", 3938802c7f1cSSalvatore Benedetto alg); 3939802c7f1cSSalvatore Benedetto err = -EINVAL; 3940802c7f1cSSalvatore Benedetto } 3941802c7f1cSSalvatore Benedetto 3942802c7f1cSSalvatore Benedetto free_all: 394347d3fd39STudor-Dan Ambarus kfree(a_ss); 3944802c7f1cSSalvatore Benedetto kfree(input_buf); 3945802c7f1cSSalvatore Benedetto free_output: 394647d3fd39STudor-Dan Ambarus kfree(a_public); 3947802c7f1cSSalvatore Benedetto kfree(output_buf); 3948802c7f1cSSalvatore Benedetto free_req: 3949802c7f1cSSalvatore Benedetto kpp_request_free(req); 3950802c7f1cSSalvatore Benedetto return err; 3951802c7f1cSSalvatore Benedetto } 3952802c7f1cSSalvatore Benedetto 3953802c7f1cSSalvatore Benedetto static int test_kpp(struct crypto_kpp *tfm, const char *alg, 3954b13b1e0cSEric Biggers const struct kpp_testvec *vecs, unsigned int tcount) 3955802c7f1cSSalvatore Benedetto { 3956802c7f1cSSalvatore Benedetto int ret, i; 3957802c7f1cSSalvatore Benedetto 3958802c7f1cSSalvatore Benedetto for (i = 0; i < tcount; i++) { 3959802c7f1cSSalvatore Benedetto ret = do_test_kpp(tfm, vecs++, alg); 3960802c7f1cSSalvatore Benedetto if (ret) { 3961802c7f1cSSalvatore Benedetto pr_err("alg: %s: test failed on vector %d, err=%d\n", 3962802c7f1cSSalvatore Benedetto alg, i + 1, ret); 3963802c7f1cSSalvatore Benedetto return ret; 3964802c7f1cSSalvatore Benedetto } 3965802c7f1cSSalvatore Benedetto } 3966802c7f1cSSalvatore Benedetto return 0; 3967802c7f1cSSalvatore Benedetto } 3968802c7f1cSSalvatore Benedetto 3969802c7f1cSSalvatore Benedetto static int alg_test_kpp(const struct alg_test_desc *desc, const char *driver, 3970802c7f1cSSalvatore Benedetto u32 type, u32 mask) 3971802c7f1cSSalvatore Benedetto { 3972802c7f1cSSalvatore Benedetto struct crypto_kpp *tfm; 3973802c7f1cSSalvatore Benedetto int err = 0; 3974802c7f1cSSalvatore Benedetto 3975eed93e0cSHerbert Xu tfm = crypto_alloc_kpp(driver, type, mask); 3976802c7f1cSSalvatore Benedetto if (IS_ERR(tfm)) { 3977802c7f1cSSalvatore Benedetto pr_err("alg: kpp: Failed to load tfm for %s: %ld\n", 3978802c7f1cSSalvatore Benedetto driver, PTR_ERR(tfm)); 3979802c7f1cSSalvatore Benedetto return PTR_ERR(tfm); 3980802c7f1cSSalvatore Benedetto } 3981802c7f1cSSalvatore Benedetto if (desc->suite.kpp.vecs) 3982802c7f1cSSalvatore Benedetto err = test_kpp(tfm, desc->alg, desc->suite.kpp.vecs, 3983802c7f1cSSalvatore Benedetto desc->suite.kpp.count); 3984802c7f1cSSalvatore Benedetto 3985802c7f1cSSalvatore Benedetto crypto_free_kpp(tfm); 3986802c7f1cSSalvatore Benedetto return err; 3987802c7f1cSSalvatore Benedetto } 3988802c7f1cSSalvatore Benedetto 3989f1774cb8SVitaly Chikunov static u8 *test_pack_u32(u8 *dst, u32 val) 3990f1774cb8SVitaly Chikunov { 3991f1774cb8SVitaly Chikunov memcpy(dst, &val, sizeof(val)); 3992f1774cb8SVitaly Chikunov return dst + sizeof(val); 3993f1774cb8SVitaly Chikunov } 3994f1774cb8SVitaly Chikunov 399550d2b643SHerbert Xu static int test_akcipher_one(struct crypto_akcipher *tfm, 3996b13b1e0cSEric Biggers const struct akcipher_testvec *vecs) 3997946cc463STadeusz Struk { 3998df27b26fSHerbert Xu char *xbuf[XBUFSIZE]; 3999946cc463STadeusz Struk struct akcipher_request *req; 4000946cc463STadeusz Struk void *outbuf_enc = NULL; 4001946cc463STadeusz Struk void *outbuf_dec = NULL; 40027f397136SGilad Ben-Yossef struct crypto_wait wait; 4003946cc463STadeusz Struk unsigned int out_len_max, out_len = 0; 4004946cc463STadeusz Struk int err = -ENOMEM; 4005c7381b01SVitaly Chikunov struct scatterlist src, dst, src_tab[3]; 40060507de94SVitaly Chikunov const char *m, *c; 40070507de94SVitaly Chikunov unsigned int m_size, c_size; 40080507de94SVitaly Chikunov const char *op; 4009f1774cb8SVitaly Chikunov u8 *key, *ptr; 4010946cc463STadeusz Struk 4011df27b26fSHerbert Xu if (testmgr_alloc_buf(xbuf)) 4012df27b26fSHerbert Xu return err; 4013df27b26fSHerbert Xu 4014946cc463STadeusz Struk req = akcipher_request_alloc(tfm, GFP_KERNEL); 4015946cc463STadeusz Struk if (!req) 4016df27b26fSHerbert Xu goto free_xbuf; 4017946cc463STadeusz Struk 40187f397136SGilad Ben-Yossef crypto_init_wait(&wait); 401922287b0bSTadeusz Struk 4020f1774cb8SVitaly Chikunov key = kmalloc(vecs->key_len + sizeof(u32) * 2 + vecs->param_len, 4021f1774cb8SVitaly Chikunov GFP_KERNEL); 4022f1774cb8SVitaly Chikunov if (!key) 40232b403867STianjia Zhang goto free_req; 4024f1774cb8SVitaly Chikunov memcpy(key, vecs->key, vecs->key_len); 4025f1774cb8SVitaly Chikunov ptr = key + vecs->key_len; 4026f1774cb8SVitaly Chikunov ptr = test_pack_u32(ptr, vecs->algo); 4027f1774cb8SVitaly Chikunov ptr = test_pack_u32(ptr, vecs->param_len); 4028f1774cb8SVitaly Chikunov memcpy(ptr, vecs->params, vecs->param_len); 4029f1774cb8SVitaly Chikunov 403022287b0bSTadeusz Struk if (vecs->public_key_vec) 4031f1774cb8SVitaly Chikunov err = crypto_akcipher_set_pub_key(tfm, key, vecs->key_len); 403222287b0bSTadeusz Struk else 4033f1774cb8SVitaly Chikunov err = crypto_akcipher_set_priv_key(tfm, key, vecs->key_len); 4034946cc463STadeusz Struk if (err) 40352b403867STianjia Zhang goto free_key; 4036946cc463STadeusz Struk 40370507de94SVitaly Chikunov /* 40380507de94SVitaly Chikunov * First run test which do not require a private key, such as 40390507de94SVitaly Chikunov * encrypt or verify. 40400507de94SVitaly Chikunov */ 4041c7381b01SVitaly Chikunov err = -ENOMEM; 4042c7381b01SVitaly Chikunov out_len_max = crypto_akcipher_maxsize(tfm); 4043946cc463STadeusz Struk outbuf_enc = kzalloc(out_len_max, GFP_KERNEL); 4044946cc463STadeusz Struk if (!outbuf_enc) 40452b403867STianjia Zhang goto free_key; 4046946cc463STadeusz Struk 40470507de94SVitaly Chikunov if (!vecs->siggen_sigver_test) { 40480507de94SVitaly Chikunov m = vecs->m; 40490507de94SVitaly Chikunov m_size = vecs->m_size; 40500507de94SVitaly Chikunov c = vecs->c; 40510507de94SVitaly Chikunov c_size = vecs->c_size; 40520507de94SVitaly Chikunov op = "encrypt"; 40530507de94SVitaly Chikunov } else { 40540507de94SVitaly Chikunov /* Swap args so we could keep plaintext (digest) 40550507de94SVitaly Chikunov * in vecs->m, and cooked signature in vecs->c. 40560507de94SVitaly Chikunov */ 40570507de94SVitaly Chikunov m = vecs->c; /* signature */ 40580507de94SVitaly Chikunov m_size = vecs->c_size; 40590507de94SVitaly Chikunov c = vecs->m; /* digest */ 40600507de94SVitaly Chikunov c_size = vecs->m_size; 40610507de94SVitaly Chikunov op = "verify"; 40620507de94SVitaly Chikunov } 4063df27b26fSHerbert Xu 40642b403867STianjia Zhang err = -E2BIG; 40650507de94SVitaly Chikunov if (WARN_ON(m_size > PAGE_SIZE)) 40660507de94SVitaly Chikunov goto free_all; 40670507de94SVitaly Chikunov memcpy(xbuf[0], m, m_size); 4068df27b26fSHerbert Xu 4069c7381b01SVitaly Chikunov sg_init_table(src_tab, 3); 4070df27b26fSHerbert Xu sg_set_buf(&src_tab[0], xbuf[0], 8); 40710507de94SVitaly Chikunov sg_set_buf(&src_tab[1], xbuf[0] + 8, m_size - 8); 4072c7381b01SVitaly Chikunov if (vecs->siggen_sigver_test) { 4073c7381b01SVitaly Chikunov if (WARN_ON(c_size > PAGE_SIZE)) 4074c7381b01SVitaly Chikunov goto free_all; 4075c7381b01SVitaly Chikunov memcpy(xbuf[1], c, c_size); 4076c7381b01SVitaly Chikunov sg_set_buf(&src_tab[2], xbuf[1], c_size); 4077c7381b01SVitaly Chikunov akcipher_request_set_crypt(req, src_tab, NULL, m_size, c_size); 4078c7381b01SVitaly Chikunov } else { 407922287b0bSTadeusz Struk sg_init_one(&dst, outbuf_enc, out_len_max); 40800507de94SVitaly Chikunov akcipher_request_set_crypt(req, src_tab, &dst, m_size, 408122287b0bSTadeusz Struk out_len_max); 4082c7381b01SVitaly Chikunov } 4083946cc463STadeusz Struk akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 40847f397136SGilad Ben-Yossef crypto_req_done, &wait); 4085946cc463STadeusz Struk 40867f397136SGilad Ben-Yossef err = crypto_wait_req(vecs->siggen_sigver_test ? 40870507de94SVitaly Chikunov /* Run asymmetric signature verification */ 40880507de94SVitaly Chikunov crypto_akcipher_verify(req) : 40891207107cSStephan Mueller /* Run asymmetric encrypt */ 40907f397136SGilad Ben-Yossef crypto_akcipher_encrypt(req), &wait); 4091946cc463STadeusz Struk if (err) { 40920507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. err %d\n", op, err); 4093946cc463STadeusz Struk goto free_all; 4094946cc463STadeusz Struk } 4095a1f62c21STianjia Zhang if (!vecs->siggen_sigver_test && c) { 40960507de94SVitaly Chikunov if (req->dst_len != c_size) { 40970507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output len\n", 40980507de94SVitaly Chikunov op); 4099946cc463STadeusz Struk err = -EINVAL; 4100946cc463STadeusz Struk goto free_all; 4101946cc463STadeusz Struk } 4102946cc463STadeusz Struk /* verify that encrypted message is equal to expected */ 4103c7381b01SVitaly Chikunov if (memcmp(c, outbuf_enc, c_size) != 0) { 4104c7381b01SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output\n", 4105c7381b01SVitaly Chikunov op); 41060507de94SVitaly Chikunov hexdump(outbuf_enc, c_size); 4107946cc463STadeusz Struk err = -EINVAL; 4108946cc463STadeusz Struk goto free_all; 4109946cc463STadeusz Struk } 4110c7381b01SVitaly Chikunov } 41110507de94SVitaly Chikunov 41120507de94SVitaly Chikunov /* 41130507de94SVitaly Chikunov * Don't invoke (decrypt or sign) test which require a private key 41140507de94SVitaly Chikunov * for vectors with only a public key. 41150507de94SVitaly Chikunov */ 4116946cc463STadeusz Struk if (vecs->public_key_vec) { 4117946cc463STadeusz Struk err = 0; 4118946cc463STadeusz Struk goto free_all; 4119946cc463STadeusz Struk } 4120946cc463STadeusz Struk outbuf_dec = kzalloc(out_len_max, GFP_KERNEL); 4121946cc463STadeusz Struk if (!outbuf_dec) { 4122946cc463STadeusz Struk err = -ENOMEM; 4123946cc463STadeusz Struk goto free_all; 4124946cc463STadeusz Struk } 4125df27b26fSHerbert Xu 4126a1f62c21STianjia Zhang if (!vecs->siggen_sigver_test && !c) { 4127a1f62c21STianjia Zhang c = outbuf_enc; 4128a1f62c21STianjia Zhang c_size = req->dst_len; 4129a1f62c21STianjia Zhang } 4130a1f62c21STianjia Zhang 41312b403867STianjia Zhang err = -E2BIG; 41320507de94SVitaly Chikunov op = vecs->siggen_sigver_test ? "sign" : "decrypt"; 41330507de94SVitaly Chikunov if (WARN_ON(c_size > PAGE_SIZE)) 4134df27b26fSHerbert Xu goto free_all; 41350507de94SVitaly Chikunov memcpy(xbuf[0], c, c_size); 4136df27b26fSHerbert Xu 41370507de94SVitaly Chikunov sg_init_one(&src, xbuf[0], c_size); 413822287b0bSTadeusz Struk sg_init_one(&dst, outbuf_dec, out_len_max); 41397f397136SGilad Ben-Yossef crypto_init_wait(&wait); 41400507de94SVitaly Chikunov akcipher_request_set_crypt(req, &src, &dst, c_size, out_len_max); 4141946cc463STadeusz Struk 41427f397136SGilad Ben-Yossef err = crypto_wait_req(vecs->siggen_sigver_test ? 41430507de94SVitaly Chikunov /* Run asymmetric signature generation */ 41440507de94SVitaly Chikunov crypto_akcipher_sign(req) : 41451207107cSStephan Mueller /* Run asymmetric decrypt */ 41467f397136SGilad Ben-Yossef crypto_akcipher_decrypt(req), &wait); 4147946cc463STadeusz Struk if (err) { 41480507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. err %d\n", op, err); 4149946cc463STadeusz Struk goto free_all; 4150946cc463STadeusz Struk } 4151946cc463STadeusz Struk out_len = req->dst_len; 41520507de94SVitaly Chikunov if (out_len < m_size) { 41530507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output len %u\n", 41540507de94SVitaly Chikunov op, out_len); 4155946cc463STadeusz Struk err = -EINVAL; 4156946cc463STadeusz Struk goto free_all; 4157946cc463STadeusz Struk } 4158946cc463STadeusz Struk /* verify that decrypted message is equal to the original msg */ 41590507de94SVitaly Chikunov if (memchr_inv(outbuf_dec, 0, out_len - m_size) || 41600507de94SVitaly Chikunov memcmp(m, outbuf_dec + out_len - m_size, m_size)) { 41610507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output\n", op); 416250d2b643SHerbert Xu hexdump(outbuf_dec, out_len); 4163946cc463STadeusz Struk err = -EINVAL; 4164946cc463STadeusz Struk } 4165946cc463STadeusz Struk free_all: 4166946cc463STadeusz Struk kfree(outbuf_dec); 4167946cc463STadeusz Struk kfree(outbuf_enc); 41682b403867STianjia Zhang free_key: 41692b403867STianjia Zhang kfree(key); 4170946cc463STadeusz Struk free_req: 4171946cc463STadeusz Struk akcipher_request_free(req); 4172df27b26fSHerbert Xu free_xbuf: 4173df27b26fSHerbert Xu testmgr_free_buf(xbuf); 4174946cc463STadeusz Struk return err; 4175946cc463STadeusz Struk } 4176946cc463STadeusz Struk 417750d2b643SHerbert Xu static int test_akcipher(struct crypto_akcipher *tfm, const char *alg, 4178b13b1e0cSEric Biggers const struct akcipher_testvec *vecs, 4179b13b1e0cSEric Biggers unsigned int tcount) 4180946cc463STadeusz Struk { 418115226e48SHerbert Xu const char *algo = 418215226e48SHerbert Xu crypto_tfm_alg_driver_name(crypto_akcipher_tfm(tfm)); 4183946cc463STadeusz Struk int ret, i; 4184946cc463STadeusz Struk 4185946cc463STadeusz Struk for (i = 0; i < tcount; i++) { 418650d2b643SHerbert Xu ret = test_akcipher_one(tfm, vecs++); 418750d2b643SHerbert Xu if (!ret) 418850d2b643SHerbert Xu continue; 418950d2b643SHerbert Xu 419015226e48SHerbert Xu pr_err("alg: akcipher: test %d failed for %s, err=%d\n", 419115226e48SHerbert Xu i + 1, algo, ret); 4192946cc463STadeusz Struk return ret; 4193946cc463STadeusz Struk } 4194946cc463STadeusz Struk return 0; 4195946cc463STadeusz Struk } 4196946cc463STadeusz Struk 4197946cc463STadeusz Struk static int alg_test_akcipher(const struct alg_test_desc *desc, 4198946cc463STadeusz Struk const char *driver, u32 type, u32 mask) 4199946cc463STadeusz Struk { 4200946cc463STadeusz Struk struct crypto_akcipher *tfm; 4201946cc463STadeusz Struk int err = 0; 4202946cc463STadeusz Struk 4203eed93e0cSHerbert Xu tfm = crypto_alloc_akcipher(driver, type, mask); 4204946cc463STadeusz Struk if (IS_ERR(tfm)) { 4205946cc463STadeusz Struk pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n", 4206946cc463STadeusz Struk driver, PTR_ERR(tfm)); 4207946cc463STadeusz Struk return PTR_ERR(tfm); 4208946cc463STadeusz Struk } 4209946cc463STadeusz Struk if (desc->suite.akcipher.vecs) 4210946cc463STadeusz Struk err = test_akcipher(tfm, desc->alg, desc->suite.akcipher.vecs, 4211946cc463STadeusz Struk desc->suite.akcipher.count); 4212946cc463STadeusz Struk 4213946cc463STadeusz Struk crypto_free_akcipher(tfm); 4214946cc463STadeusz Struk return err; 4215946cc463STadeusz Struk } 4216946cc463STadeusz Struk 4217863b557aSYouquan, Song static int alg_test_null(const struct alg_test_desc *desc, 4218863b557aSYouquan, Song const char *driver, u32 type, u32 mask) 4219863b557aSYouquan, Song { 4220863b557aSYouquan, Song return 0; 4221863b557aSYouquan, Song } 4222863b557aSYouquan, Song 422349763fc6SEric Biggers #define ____VECS(tv) .vecs = tv, .count = ARRAY_SIZE(tv) 422449763fc6SEric Biggers #define __VECS(tv) { ____VECS(tv) } 422521c8e720SArd Biesheuvel 4226da7f033dSHerbert Xu /* Please keep this list sorted by algorithm name. */ 4227da7f033dSHerbert Xu static const struct alg_test_desc alg_test_descs[] = { 4228da7f033dSHerbert Xu { 4229059c2a4dSEric Biggers .alg = "adiantum(xchacha12,aes)", 4230d435e10eSEric Biggers .generic_driver = "adiantum(xchacha12-generic,aes-generic,nhpoly1305-generic)", 4231059c2a4dSEric Biggers .test = alg_test_skcipher, 4232059c2a4dSEric Biggers .suite = { 4233059c2a4dSEric Biggers .cipher = __VECS(adiantum_xchacha12_aes_tv_template) 4234059c2a4dSEric Biggers }, 4235059c2a4dSEric Biggers }, { 4236059c2a4dSEric Biggers .alg = "adiantum(xchacha20,aes)", 4237d435e10eSEric Biggers .generic_driver = "adiantum(xchacha20-generic,aes-generic,nhpoly1305-generic)", 4238059c2a4dSEric Biggers .test = alg_test_skcipher, 4239059c2a4dSEric Biggers .suite = { 4240059c2a4dSEric Biggers .cipher = __VECS(adiantum_xchacha20_aes_tv_template) 4241059c2a4dSEric Biggers }, 4242059c2a4dSEric Biggers }, { 4243b87dc203SOndrej Mosnacek .alg = "aegis128", 4244b87dc203SOndrej Mosnacek .test = alg_test_aead, 4245b87dc203SOndrej Mosnacek .suite = { 4246a0d608eeSEric Biggers .aead = __VECS(aegis128_tv_template) 4247b87dc203SOndrej Mosnacek } 4248b87dc203SOndrej Mosnacek }, { 4249e08ca2daSJarod Wilson .alg = "ansi_cprng", 4250e08ca2daSJarod Wilson .test = alg_test_cprng, 4251e08ca2daSJarod Wilson .suite = { 425221c8e720SArd Biesheuvel .cprng = __VECS(ansi_cprng_aes_tv_template) 4253e08ca2daSJarod Wilson } 4254e08ca2daSJarod Wilson }, { 4255bca4feb0SHoria Geanta .alg = "authenc(hmac(md5),ecb(cipher_null))", 4256bca4feb0SHoria Geanta .test = alg_test_aead, 4257bca4feb0SHoria Geanta .suite = { 4258a0d608eeSEric Biggers .aead = __VECS(hmac_md5_ecb_cipher_null_tv_template) 4259bca4feb0SHoria Geanta } 4260bca4feb0SHoria Geanta }, { 4261a4198fd4SHerbert Xu .alg = "authenc(hmac(sha1),cbc(aes))", 4262e46e9a46SHoria Geanta .test = alg_test_aead, 4263bcf741cbSHerbert Xu .fips_allowed = 1, 4264e46e9a46SHoria Geanta .suite = { 4265a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_aes_cbc_tv_temp) 42665208ed2cSNitesh Lal } 42675208ed2cSNitesh Lal }, { 4268a4198fd4SHerbert Xu .alg = "authenc(hmac(sha1),cbc(des))", 42695208ed2cSNitesh Lal .test = alg_test_aead, 42705208ed2cSNitesh Lal .suite = { 4271a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_des_cbc_tv_temp) 42725208ed2cSNitesh Lal } 42735208ed2cSNitesh Lal }, { 4274a4198fd4SHerbert Xu .alg = "authenc(hmac(sha1),cbc(des3_ede))", 42755208ed2cSNitesh Lal .test = alg_test_aead, 42765208ed2cSNitesh Lal .suite = { 4277a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_des3_ede_cbc_tv_temp) 4278e46e9a46SHoria Geanta } 4279e46e9a46SHoria Geanta }, { 4280fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha1),ctr(aes))", 4281fb16abc2SMarcus Meissner .test = alg_test_null, 4282fb16abc2SMarcus Meissner .fips_allowed = 1, 4283fb16abc2SMarcus Meissner }, { 4284bca4feb0SHoria Geanta .alg = "authenc(hmac(sha1),ecb(cipher_null))", 4285bca4feb0SHoria Geanta .test = alg_test_aead, 4286bca4feb0SHoria Geanta .suite = { 4287a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_ecb_cipher_null_tv_temp) 42885208ed2cSNitesh Lal } 42895208ed2cSNitesh Lal }, { 42908888690eSMarcus Meissner .alg = "authenc(hmac(sha1),rfc3686(ctr(aes)))", 42918888690eSMarcus Meissner .test = alg_test_null, 42928888690eSMarcus Meissner .fips_allowed = 1, 42938888690eSMarcus Meissner }, { 4294a4198fd4SHerbert Xu .alg = "authenc(hmac(sha224),cbc(des))", 42955208ed2cSNitesh Lal .test = alg_test_aead, 42965208ed2cSNitesh Lal .suite = { 4297a0d608eeSEric Biggers .aead = __VECS(hmac_sha224_des_cbc_tv_temp) 42985208ed2cSNitesh Lal } 42995208ed2cSNitesh Lal }, { 4300a4198fd4SHerbert Xu .alg = "authenc(hmac(sha224),cbc(des3_ede))", 43015208ed2cSNitesh Lal .test = alg_test_aead, 43025208ed2cSNitesh Lal .suite = { 4303a0d608eeSEric Biggers .aead = __VECS(hmac_sha224_des3_ede_cbc_tv_temp) 4304bca4feb0SHoria Geanta } 4305bca4feb0SHoria Geanta }, { 4306a4198fd4SHerbert Xu .alg = "authenc(hmac(sha256),cbc(aes))", 4307e46e9a46SHoria Geanta .test = alg_test_aead, 4308ed1afac9SMarcus Meissner .fips_allowed = 1, 4309e46e9a46SHoria Geanta .suite = { 4310a0d608eeSEric Biggers .aead = __VECS(hmac_sha256_aes_cbc_tv_temp) 43115208ed2cSNitesh Lal } 43125208ed2cSNitesh Lal }, { 4313a4198fd4SHerbert Xu .alg = "authenc(hmac(sha256),cbc(des))", 43145208ed2cSNitesh Lal .test = alg_test_aead, 43155208ed2cSNitesh Lal .suite = { 4316a0d608eeSEric Biggers .aead = __VECS(hmac_sha256_des_cbc_tv_temp) 43175208ed2cSNitesh Lal } 43185208ed2cSNitesh Lal }, { 4319a4198fd4SHerbert Xu .alg = "authenc(hmac(sha256),cbc(des3_ede))", 43205208ed2cSNitesh Lal .test = alg_test_aead, 43215208ed2cSNitesh Lal .suite = { 4322a0d608eeSEric Biggers .aead = __VECS(hmac_sha256_des3_ede_cbc_tv_temp) 43235208ed2cSNitesh Lal } 43245208ed2cSNitesh Lal }, { 4325fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha256),ctr(aes))", 4326fb16abc2SMarcus Meissner .test = alg_test_null, 4327fb16abc2SMarcus Meissner .fips_allowed = 1, 4328fb16abc2SMarcus Meissner }, { 43298888690eSMarcus Meissner .alg = "authenc(hmac(sha256),rfc3686(ctr(aes)))", 43308888690eSMarcus Meissner .test = alg_test_null, 43318888690eSMarcus Meissner .fips_allowed = 1, 43328888690eSMarcus Meissner }, { 4333a4198fd4SHerbert Xu .alg = "authenc(hmac(sha384),cbc(des))", 43345208ed2cSNitesh Lal .test = alg_test_aead, 43355208ed2cSNitesh Lal .suite = { 4336a0d608eeSEric Biggers .aead = __VECS(hmac_sha384_des_cbc_tv_temp) 43375208ed2cSNitesh Lal } 43385208ed2cSNitesh Lal }, { 4339a4198fd4SHerbert Xu .alg = "authenc(hmac(sha384),cbc(des3_ede))", 43405208ed2cSNitesh Lal .test = alg_test_aead, 43415208ed2cSNitesh Lal .suite = { 4342a0d608eeSEric Biggers .aead = __VECS(hmac_sha384_des3_ede_cbc_tv_temp) 4343e46e9a46SHoria Geanta } 4344e46e9a46SHoria Geanta }, { 4345fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha384),ctr(aes))", 4346fb16abc2SMarcus Meissner .test = alg_test_null, 4347fb16abc2SMarcus Meissner .fips_allowed = 1, 4348fb16abc2SMarcus Meissner }, { 43498888690eSMarcus Meissner .alg = "authenc(hmac(sha384),rfc3686(ctr(aes)))", 43508888690eSMarcus Meissner .test = alg_test_null, 43518888690eSMarcus Meissner .fips_allowed = 1, 43528888690eSMarcus Meissner }, { 4353a4198fd4SHerbert Xu .alg = "authenc(hmac(sha512),cbc(aes))", 4354ed1afac9SMarcus Meissner .fips_allowed = 1, 4355e46e9a46SHoria Geanta .test = alg_test_aead, 4356e46e9a46SHoria Geanta .suite = { 4357a0d608eeSEric Biggers .aead = __VECS(hmac_sha512_aes_cbc_tv_temp) 43585208ed2cSNitesh Lal } 43595208ed2cSNitesh Lal }, { 4360a4198fd4SHerbert Xu .alg = "authenc(hmac(sha512),cbc(des))", 43615208ed2cSNitesh Lal .test = alg_test_aead, 43625208ed2cSNitesh Lal .suite = { 4363a0d608eeSEric Biggers .aead = __VECS(hmac_sha512_des_cbc_tv_temp) 43645208ed2cSNitesh Lal } 43655208ed2cSNitesh Lal }, { 4366a4198fd4SHerbert Xu .alg = "authenc(hmac(sha512),cbc(des3_ede))", 43675208ed2cSNitesh Lal .test = alg_test_aead, 43685208ed2cSNitesh Lal .suite = { 4369a0d608eeSEric Biggers .aead = __VECS(hmac_sha512_des3_ede_cbc_tv_temp) 4370e46e9a46SHoria Geanta } 4371e46e9a46SHoria Geanta }, { 4372fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha512),ctr(aes))", 4373fb16abc2SMarcus Meissner .test = alg_test_null, 4374fb16abc2SMarcus Meissner .fips_allowed = 1, 4375fb16abc2SMarcus Meissner }, { 43768888690eSMarcus Meissner .alg = "authenc(hmac(sha512),rfc3686(ctr(aes)))", 43778888690eSMarcus Meissner .test = alg_test_null, 43788888690eSMarcus Meissner .fips_allowed = 1, 43798888690eSMarcus Meissner }, { 4380a1afe274SDavid Sterba .alg = "blake2b-160", 4381a1afe274SDavid Sterba .test = alg_test_hash, 4382a1afe274SDavid Sterba .fips_allowed = 0, 4383a1afe274SDavid Sterba .suite = { 4384a1afe274SDavid Sterba .hash = __VECS(blake2b_160_tv_template) 4385a1afe274SDavid Sterba } 4386a1afe274SDavid Sterba }, { 4387a1afe274SDavid Sterba .alg = "blake2b-256", 4388a1afe274SDavid Sterba .test = alg_test_hash, 4389a1afe274SDavid Sterba .fips_allowed = 0, 4390a1afe274SDavid Sterba .suite = { 4391a1afe274SDavid Sterba .hash = __VECS(blake2b_256_tv_template) 4392a1afe274SDavid Sterba } 4393a1afe274SDavid Sterba }, { 4394a1afe274SDavid Sterba .alg = "blake2b-384", 4395a1afe274SDavid Sterba .test = alg_test_hash, 4396a1afe274SDavid Sterba .fips_allowed = 0, 4397a1afe274SDavid Sterba .suite = { 4398a1afe274SDavid Sterba .hash = __VECS(blake2b_384_tv_template) 4399a1afe274SDavid Sterba } 4400a1afe274SDavid Sterba }, { 4401a1afe274SDavid Sterba .alg = "blake2b-512", 4402a1afe274SDavid Sterba .test = alg_test_hash, 4403a1afe274SDavid Sterba .fips_allowed = 0, 4404a1afe274SDavid Sterba .suite = { 4405a1afe274SDavid Sterba .hash = __VECS(blake2b_512_tv_template) 4406a1afe274SDavid Sterba } 4407a1afe274SDavid Sterba }, { 4408da7f033dSHerbert Xu .alg = "cbc(aes)", 44091aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4410a1915d51SJarod Wilson .fips_allowed = 1, 4411da7f033dSHerbert Xu .suite = { 441292a4c9feSEric Biggers .cipher = __VECS(aes_cbc_tv_template) 441392a4c9feSEric Biggers }, 4414da7f033dSHerbert Xu }, { 4415da7f033dSHerbert Xu .alg = "cbc(anubis)", 44161aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4417da7f033dSHerbert Xu .suite = { 441892a4c9feSEric Biggers .cipher = __VECS(anubis_cbc_tv_template) 441992a4c9feSEric Biggers }, 4420da7f033dSHerbert Xu }, { 442101ce31deSTaehee Yoo .alg = "cbc(aria)", 442201ce31deSTaehee Yoo .test = alg_test_skcipher, 442301ce31deSTaehee Yoo .suite = { 442401ce31deSTaehee Yoo .cipher = __VECS(aria_cbc_tv_template) 442501ce31deSTaehee Yoo }, 442601ce31deSTaehee Yoo }, { 4427da7f033dSHerbert Xu .alg = "cbc(blowfish)", 44281aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4429da7f033dSHerbert Xu .suite = { 443092a4c9feSEric Biggers .cipher = __VECS(bf_cbc_tv_template) 443192a4c9feSEric Biggers }, 4432da7f033dSHerbert Xu }, { 4433da7f033dSHerbert Xu .alg = "cbc(camellia)", 44341aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4435da7f033dSHerbert Xu .suite = { 443692a4c9feSEric Biggers .cipher = __VECS(camellia_cbc_tv_template) 443792a4c9feSEric Biggers }, 4438da7f033dSHerbert Xu }, { 4439a2c58260SJohannes Goetzfried .alg = "cbc(cast5)", 4440a2c58260SJohannes Goetzfried .test = alg_test_skcipher, 4441a2c58260SJohannes Goetzfried .suite = { 444292a4c9feSEric Biggers .cipher = __VECS(cast5_cbc_tv_template) 444392a4c9feSEric Biggers }, 4444a2c58260SJohannes Goetzfried }, { 44459b8b0405SJohannes Goetzfried .alg = "cbc(cast6)", 44469b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 44479b8b0405SJohannes Goetzfried .suite = { 444892a4c9feSEric Biggers .cipher = __VECS(cast6_cbc_tv_template) 444992a4c9feSEric Biggers }, 44509b8b0405SJohannes Goetzfried }, { 4451da7f033dSHerbert Xu .alg = "cbc(des)", 44521aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4453da7f033dSHerbert Xu .suite = { 445492a4c9feSEric Biggers .cipher = __VECS(des_cbc_tv_template) 445592a4c9feSEric Biggers }, 4456da7f033dSHerbert Xu }, { 4457da7f033dSHerbert Xu .alg = "cbc(des3_ede)", 44581aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4459da7f033dSHerbert Xu .suite = { 446092a4c9feSEric Biggers .cipher = __VECS(des3_ede_cbc_tv_template) 446192a4c9feSEric Biggers }, 4462da7f033dSHerbert Xu }, { 4463a794d8d8SGilad Ben-Yossef /* Same as cbc(aes) except the key is stored in 4464a794d8d8SGilad Ben-Yossef * hardware secure memory which we reference by index 4465a794d8d8SGilad Ben-Yossef */ 4466a794d8d8SGilad Ben-Yossef .alg = "cbc(paes)", 4467a794d8d8SGilad Ben-Yossef .test = alg_test_null, 4468a794d8d8SGilad Ben-Yossef .fips_allowed = 1, 4469a794d8d8SGilad Ben-Yossef }, { 4470f0372c00SGilad Ben-Yossef /* Same as cbc(sm4) except the key is stored in 4471f0372c00SGilad Ben-Yossef * hardware secure memory which we reference by index 4472f0372c00SGilad Ben-Yossef */ 4473f0372c00SGilad Ben-Yossef .alg = "cbc(psm4)", 4474f0372c00SGilad Ben-Yossef .test = alg_test_null, 4475f0372c00SGilad Ben-Yossef }, { 44769d25917dSJussi Kivilinna .alg = "cbc(serpent)", 44779d25917dSJussi Kivilinna .test = alg_test_skcipher, 44789d25917dSJussi Kivilinna .suite = { 447992a4c9feSEric Biggers .cipher = __VECS(serpent_cbc_tv_template) 448092a4c9feSEric Biggers }, 44819d25917dSJussi Kivilinna }, { 448295ba5973SGilad Ben-Yossef .alg = "cbc(sm4)", 448395ba5973SGilad Ben-Yossef .test = alg_test_skcipher, 448495ba5973SGilad Ben-Yossef .suite = { 448595ba5973SGilad Ben-Yossef .cipher = __VECS(sm4_cbc_tv_template) 448695ba5973SGilad Ben-Yossef } 448795ba5973SGilad Ben-Yossef }, { 4488da7f033dSHerbert Xu .alg = "cbc(twofish)", 44891aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4490da7f033dSHerbert Xu .suite = { 449192a4c9feSEric Biggers .cipher = __VECS(tf_cbc_tv_template) 449292a4c9feSEric Biggers }, 4493da7f033dSHerbert Xu }, { 4494c7ff8573SHarald Freudenberger #if IS_ENABLED(CONFIG_CRYPTO_PAES_S390) 4495c7ff8573SHarald Freudenberger .alg = "cbc-paes-s390", 4496c7ff8573SHarald Freudenberger .fips_allowed = 1, 4497c7ff8573SHarald Freudenberger .test = alg_test_skcipher, 4498c7ff8573SHarald Freudenberger .suite = { 4499c7ff8573SHarald Freudenberger .cipher = __VECS(aes_cbc_tv_template) 4500c7ff8573SHarald Freudenberger } 4501c7ff8573SHarald Freudenberger }, { 4502c7ff8573SHarald Freudenberger #endif 4503092acf06SArd Biesheuvel .alg = "cbcmac(aes)", 4504092acf06SArd Biesheuvel .fips_allowed = 1, 4505092acf06SArd Biesheuvel .test = alg_test_hash, 4506092acf06SArd Biesheuvel .suite = { 4507092acf06SArd Biesheuvel .hash = __VECS(aes_cbcmac_tv_template) 4508092acf06SArd Biesheuvel } 4509092acf06SArd Biesheuvel }, { 451068039d60STianjia Zhang .alg = "cbcmac(sm4)", 451168039d60STianjia Zhang .test = alg_test_hash, 451268039d60STianjia Zhang .suite = { 451368039d60STianjia Zhang .hash = __VECS(sm4_cbcmac_tv_template) 451468039d60STianjia Zhang } 451568039d60STianjia Zhang }, { 4516da7f033dSHerbert Xu .alg = "ccm(aes)", 451740153b10SEric Biggers .generic_driver = "ccm_base(ctr(aes-generic),cbcmac(aes-generic))", 4518da7f033dSHerbert Xu .test = alg_test_aead, 4519a1915d51SJarod Wilson .fips_allowed = 1, 4520da7f033dSHerbert Xu .suite = { 452149763fc6SEric Biggers .aead = { 452249763fc6SEric Biggers ____VECS(aes_ccm_tv_template), 452349763fc6SEric Biggers .einval_allowed = 1, 452449763fc6SEric Biggers } 4525da7f033dSHerbert Xu } 4526da7f033dSHerbert Xu }, { 452768039d60STianjia Zhang .alg = "ccm(sm4)", 452868039d60STianjia Zhang .generic_driver = "ccm_base(ctr(sm4-generic),cbcmac(sm4-generic))", 452968039d60STianjia Zhang .test = alg_test_aead, 453068039d60STianjia Zhang .suite = { 453168039d60STianjia Zhang .aead = { 453268039d60STianjia Zhang ____VECS(sm4_ccm_tv_template), 453368039d60STianjia Zhang .einval_allowed = 1, 453468039d60STianjia Zhang } 453568039d60STianjia Zhang } 453668039d60STianjia Zhang }, { 45377da66670SDmitry Eremin-Solenikov .alg = "cfb(aes)", 45387da66670SDmitry Eremin-Solenikov .test = alg_test_skcipher, 45397da66670SDmitry Eremin-Solenikov .fips_allowed = 1, 45407da66670SDmitry Eremin-Solenikov .suite = { 45417da66670SDmitry Eremin-Solenikov .cipher = __VECS(aes_cfb_tv_template) 45427da66670SDmitry Eremin-Solenikov }, 45437da66670SDmitry Eremin-Solenikov }, { 454401ce31deSTaehee Yoo .alg = "cfb(aria)", 454501ce31deSTaehee Yoo .test = alg_test_skcipher, 454601ce31deSTaehee Yoo .suite = { 454701ce31deSTaehee Yoo .cipher = __VECS(aria_cfb_tv_template) 454801ce31deSTaehee Yoo }, 454901ce31deSTaehee Yoo }, { 4550a06b15b2SPascal van Leeuwen .alg = "cfb(sm4)", 4551a06b15b2SPascal van Leeuwen .test = alg_test_skcipher, 4552a06b15b2SPascal van Leeuwen .suite = { 4553a06b15b2SPascal van Leeuwen .cipher = __VECS(sm4_cfb_tv_template) 4554a06b15b2SPascal van Leeuwen } 4555a06b15b2SPascal van Leeuwen }, { 45563590ebf2SMartin Willi .alg = "chacha20", 45573590ebf2SMartin Willi .test = alg_test_skcipher, 45583590ebf2SMartin Willi .suite = { 455992a4c9feSEric Biggers .cipher = __VECS(chacha20_tv_template) 456092a4c9feSEric Biggers }, 45613590ebf2SMartin Willi }, { 456293b5e86aSJussi Kivilinna .alg = "cmac(aes)", 45638f183751SStephan Mueller .fips_allowed = 1, 456493b5e86aSJussi Kivilinna .test = alg_test_hash, 456593b5e86aSJussi Kivilinna .suite = { 456621c8e720SArd Biesheuvel .hash = __VECS(aes_cmac128_tv_template) 456793b5e86aSJussi Kivilinna } 456893b5e86aSJussi Kivilinna }, { 456993b5e86aSJussi Kivilinna .alg = "cmac(des3_ede)", 457093b5e86aSJussi Kivilinna .test = alg_test_hash, 457193b5e86aSJussi Kivilinna .suite = { 457221c8e720SArd Biesheuvel .hash = __VECS(des3_ede_cmac64_tv_template) 457393b5e86aSJussi Kivilinna } 457493b5e86aSJussi Kivilinna }, { 457568039d60STianjia Zhang .alg = "cmac(sm4)", 457668039d60STianjia Zhang .test = alg_test_hash, 457768039d60STianjia Zhang .suite = { 457868039d60STianjia Zhang .hash = __VECS(sm4_cmac128_tv_template) 457968039d60STianjia Zhang } 458068039d60STianjia Zhang }, { 4581e448370dSJussi Kivilinna .alg = "compress_null", 4582e448370dSJussi Kivilinna .test = alg_test_null, 4583e448370dSJussi Kivilinna }, { 4584ebb3472fSArd Biesheuvel .alg = "crc32", 4585ebb3472fSArd Biesheuvel .test = alg_test_hash, 4586a8a34416SMilan Broz .fips_allowed = 1, 4587ebb3472fSArd Biesheuvel .suite = { 458821c8e720SArd Biesheuvel .hash = __VECS(crc32_tv_template) 4589ebb3472fSArd Biesheuvel } 4590ebb3472fSArd Biesheuvel }, { 4591da7f033dSHerbert Xu .alg = "crc32c", 45928e3ee85eSHerbert Xu .test = alg_test_crc32c, 4593a1915d51SJarod Wilson .fips_allowed = 1, 4594da7f033dSHerbert Xu .suite = { 459521c8e720SArd Biesheuvel .hash = __VECS(crc32c_tv_template) 4596da7f033dSHerbert Xu } 4597da7f033dSHerbert Xu }, { 4598f3813f4bSKeith Busch .alg = "crc64-rocksoft", 4599f3813f4bSKeith Busch .test = alg_test_hash, 4600f3813f4bSKeith Busch .fips_allowed = 1, 4601f3813f4bSKeith Busch .suite = { 4602f3813f4bSKeith Busch .hash = __VECS(crc64_rocksoft_tv_template) 4603f3813f4bSKeith Busch } 4604f3813f4bSKeith Busch }, { 460568411521SHerbert Xu .alg = "crct10dif", 460668411521SHerbert Xu .test = alg_test_hash, 460768411521SHerbert Xu .fips_allowed = 1, 460868411521SHerbert Xu .suite = { 460921c8e720SArd Biesheuvel .hash = __VECS(crct10dif_tv_template) 461068411521SHerbert Xu } 461168411521SHerbert Xu }, { 4612f7cb80f2SJarod Wilson .alg = "ctr(aes)", 4613f7cb80f2SJarod Wilson .test = alg_test_skcipher, 4614a1915d51SJarod Wilson .fips_allowed = 1, 4615f7cb80f2SJarod Wilson .suite = { 461692a4c9feSEric Biggers .cipher = __VECS(aes_ctr_tv_template) 4617f7cb80f2SJarod Wilson } 4618f7cb80f2SJarod Wilson }, { 461901ce31deSTaehee Yoo .alg = "ctr(aria)", 462001ce31deSTaehee Yoo .test = alg_test_skcipher, 462101ce31deSTaehee Yoo .suite = { 462201ce31deSTaehee Yoo .cipher = __VECS(aria_ctr_tv_template) 462301ce31deSTaehee Yoo } 462401ce31deSTaehee Yoo }, { 462585b63e34SJussi Kivilinna .alg = "ctr(blowfish)", 462685b63e34SJussi Kivilinna .test = alg_test_skcipher, 462785b63e34SJussi Kivilinna .suite = { 462892a4c9feSEric Biggers .cipher = __VECS(bf_ctr_tv_template) 462985b63e34SJussi Kivilinna } 463085b63e34SJussi Kivilinna }, { 46310840605eSJussi Kivilinna .alg = "ctr(camellia)", 46320840605eSJussi Kivilinna .test = alg_test_skcipher, 46330840605eSJussi Kivilinna .suite = { 463492a4c9feSEric Biggers .cipher = __VECS(camellia_ctr_tv_template) 46350840605eSJussi Kivilinna } 46360840605eSJussi Kivilinna }, { 4637a2c58260SJohannes Goetzfried .alg = "ctr(cast5)", 4638a2c58260SJohannes Goetzfried .test = alg_test_skcipher, 4639a2c58260SJohannes Goetzfried .suite = { 464092a4c9feSEric Biggers .cipher = __VECS(cast5_ctr_tv_template) 4641a2c58260SJohannes Goetzfried } 4642a2c58260SJohannes Goetzfried }, { 46439b8b0405SJohannes Goetzfried .alg = "ctr(cast6)", 46449b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 46459b8b0405SJohannes Goetzfried .suite = { 464692a4c9feSEric Biggers .cipher = __VECS(cast6_ctr_tv_template) 46479b8b0405SJohannes Goetzfried } 46489b8b0405SJohannes Goetzfried }, { 46498163fc30SJussi Kivilinna .alg = "ctr(des)", 46508163fc30SJussi Kivilinna .test = alg_test_skcipher, 46518163fc30SJussi Kivilinna .suite = { 465292a4c9feSEric Biggers .cipher = __VECS(des_ctr_tv_template) 46538163fc30SJussi Kivilinna } 46548163fc30SJussi Kivilinna }, { 4655e080b17aSJussi Kivilinna .alg = "ctr(des3_ede)", 4656e080b17aSJussi Kivilinna .test = alg_test_skcipher, 4657e080b17aSJussi Kivilinna .suite = { 465892a4c9feSEric Biggers .cipher = __VECS(des3_ede_ctr_tv_template) 4659e080b17aSJussi Kivilinna } 4660e080b17aSJussi Kivilinna }, { 4661a794d8d8SGilad Ben-Yossef /* Same as ctr(aes) except the key is stored in 4662a794d8d8SGilad Ben-Yossef * hardware secure memory which we reference by index 4663a794d8d8SGilad Ben-Yossef */ 4664a794d8d8SGilad Ben-Yossef .alg = "ctr(paes)", 4665a794d8d8SGilad Ben-Yossef .test = alg_test_null, 4666a794d8d8SGilad Ben-Yossef .fips_allowed = 1, 4667a794d8d8SGilad Ben-Yossef }, { 4668f0372c00SGilad Ben-Yossef 4669f0372c00SGilad Ben-Yossef /* Same as ctr(sm4) except the key is stored in 4670f0372c00SGilad Ben-Yossef * hardware secure memory which we reference by index 4671f0372c00SGilad Ben-Yossef */ 4672f0372c00SGilad Ben-Yossef .alg = "ctr(psm4)", 4673f0372c00SGilad Ben-Yossef .test = alg_test_null, 4674f0372c00SGilad Ben-Yossef }, { 46759d25917dSJussi Kivilinna .alg = "ctr(serpent)", 46769d25917dSJussi Kivilinna .test = alg_test_skcipher, 46779d25917dSJussi Kivilinna .suite = { 467892a4c9feSEric Biggers .cipher = __VECS(serpent_ctr_tv_template) 46799d25917dSJussi Kivilinna } 46809d25917dSJussi Kivilinna }, { 468195ba5973SGilad Ben-Yossef .alg = "ctr(sm4)", 468295ba5973SGilad Ben-Yossef .test = alg_test_skcipher, 468395ba5973SGilad Ben-Yossef .suite = { 468495ba5973SGilad Ben-Yossef .cipher = __VECS(sm4_ctr_tv_template) 468595ba5973SGilad Ben-Yossef } 468695ba5973SGilad Ben-Yossef }, { 4687573da620SJussi Kivilinna .alg = "ctr(twofish)", 4688573da620SJussi Kivilinna .test = alg_test_skcipher, 4689573da620SJussi Kivilinna .suite = { 469092a4c9feSEric Biggers .cipher = __VECS(tf_ctr_tv_template) 4691573da620SJussi Kivilinna } 4692573da620SJussi Kivilinna }, { 4693c7ff8573SHarald Freudenberger #if IS_ENABLED(CONFIG_CRYPTO_PAES_S390) 4694c7ff8573SHarald Freudenberger .alg = "ctr-paes-s390", 4695c7ff8573SHarald Freudenberger .fips_allowed = 1, 4696c7ff8573SHarald Freudenberger .test = alg_test_skcipher, 4697c7ff8573SHarald Freudenberger .suite = { 4698c7ff8573SHarald Freudenberger .cipher = __VECS(aes_ctr_tv_template) 4699c7ff8573SHarald Freudenberger } 4700c7ff8573SHarald Freudenberger }, { 4701c7ff8573SHarald Freudenberger #endif 4702da7f033dSHerbert Xu .alg = "cts(cbc(aes))", 47031aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4704196ad604SGilad Ben-Yossef .fips_allowed = 1, 4705da7f033dSHerbert Xu .suite = { 470692a4c9feSEric Biggers .cipher = __VECS(cts_mode_tv_template) 4707da7f033dSHerbert Xu } 4708da7f033dSHerbert Xu }, { 4709f0372c00SGilad Ben-Yossef /* Same as cts(cbc((aes)) except the key is stored in 4710f0372c00SGilad Ben-Yossef * hardware secure memory which we reference by index 4711f0372c00SGilad Ben-Yossef */ 4712f0372c00SGilad Ben-Yossef .alg = "cts(cbc(paes))", 4713f0372c00SGilad Ben-Yossef .test = alg_test_null, 4714f0372c00SGilad Ben-Yossef .fips_allowed = 1, 4715f0372c00SGilad Ben-Yossef }, { 4716f613457aSArd Biesheuvel .alg = "curve25519", 4717f613457aSArd Biesheuvel .test = alg_test_kpp, 4718f613457aSArd Biesheuvel .suite = { 4719f613457aSArd Biesheuvel .kpp = __VECS(curve25519_tv_template) 4720f613457aSArd Biesheuvel } 4721f613457aSArd Biesheuvel }, { 4722da7f033dSHerbert Xu .alg = "deflate", 4723da7f033dSHerbert Xu .test = alg_test_comp, 47240818904dSMilan Broz .fips_allowed = 1, 4725da7f033dSHerbert Xu .suite = { 4726da7f033dSHerbert Xu .comp = { 472721c8e720SArd Biesheuvel .comp = __VECS(deflate_comp_tv_template), 472821c8e720SArd Biesheuvel .decomp = __VECS(deflate_decomp_tv_template) 4729da7f033dSHerbert Xu } 4730da7f033dSHerbert Xu } 4731da7f033dSHerbert Xu }, { 4732802c7f1cSSalvatore Benedetto .alg = "dh", 4733802c7f1cSSalvatore Benedetto .test = alg_test_kpp, 4734802c7f1cSSalvatore Benedetto .suite = { 473521c8e720SArd Biesheuvel .kpp = __VECS(dh_tv_template) 4736802c7f1cSSalvatore Benedetto } 4737802c7f1cSSalvatore Benedetto }, { 4738e448370dSJussi Kivilinna .alg = "digest_null", 4739e448370dSJussi Kivilinna .test = alg_test_null, 4740e448370dSJussi Kivilinna }, { 474164d1cdfbSStephan Mueller .alg = "drbg_nopr_ctr_aes128", 474264d1cdfbSStephan Mueller .test = alg_test_drbg, 474364d1cdfbSStephan Mueller .fips_allowed = 1, 474464d1cdfbSStephan Mueller .suite = { 474521c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_ctr_aes128_tv_template) 474664d1cdfbSStephan Mueller } 474764d1cdfbSStephan Mueller }, { 474864d1cdfbSStephan Mueller .alg = "drbg_nopr_ctr_aes192", 474964d1cdfbSStephan Mueller .test = alg_test_drbg, 475064d1cdfbSStephan Mueller .fips_allowed = 1, 475164d1cdfbSStephan Mueller .suite = { 475221c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_ctr_aes192_tv_template) 475364d1cdfbSStephan Mueller } 475464d1cdfbSStephan Mueller }, { 475564d1cdfbSStephan Mueller .alg = "drbg_nopr_ctr_aes256", 475664d1cdfbSStephan Mueller .test = alg_test_drbg, 475764d1cdfbSStephan Mueller .fips_allowed = 1, 475864d1cdfbSStephan Mueller .suite = { 475921c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_ctr_aes256_tv_template) 476064d1cdfbSStephan Mueller } 476164d1cdfbSStephan Mueller }, { 476264d1cdfbSStephan Mueller /* 476364d1cdfbSStephan Mueller * There is no need to specifically test the DRBG with every 476464d1cdfbSStephan Mueller * backend cipher -- covered by drbg_nopr_hmac_sha256 test 476564d1cdfbSStephan Mueller */ 476664d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha1", 476764d1cdfbSStephan Mueller .fips_allowed = 1, 476864d1cdfbSStephan Mueller .test = alg_test_null, 476964d1cdfbSStephan Mueller }, { 477064d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha256", 477164d1cdfbSStephan Mueller .test = alg_test_drbg, 477264d1cdfbSStephan Mueller .fips_allowed = 1, 477364d1cdfbSStephan Mueller .suite = { 477421c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_hmac_sha256_tv_template) 477564d1cdfbSStephan Mueller } 477664d1cdfbSStephan Mueller }, { 477764d1cdfbSStephan Mueller /* covered by drbg_nopr_hmac_sha256 test */ 477864d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha384", 477964d1cdfbSStephan Mueller .fips_allowed = 1, 478064d1cdfbSStephan Mueller .test = alg_test_null, 478164d1cdfbSStephan Mueller }, { 478264d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha512", 47838833272dSStephan Müller .test = alg_test_drbg, 478464d1cdfbSStephan Mueller .fips_allowed = 1, 47858833272dSStephan Müller .suite = { 47868833272dSStephan Müller .drbg = __VECS(drbg_nopr_hmac_sha512_tv_template) 47878833272dSStephan Müller } 478864d1cdfbSStephan Mueller }, { 478964d1cdfbSStephan Mueller .alg = "drbg_nopr_sha1", 479064d1cdfbSStephan Mueller .fips_allowed = 1, 479164d1cdfbSStephan Mueller .test = alg_test_null, 479264d1cdfbSStephan Mueller }, { 479364d1cdfbSStephan Mueller .alg = "drbg_nopr_sha256", 479464d1cdfbSStephan Mueller .test = alg_test_drbg, 479564d1cdfbSStephan Mueller .fips_allowed = 1, 479664d1cdfbSStephan Mueller .suite = { 479721c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_sha256_tv_template) 479864d1cdfbSStephan Mueller } 479964d1cdfbSStephan Mueller }, { 480064d1cdfbSStephan Mueller /* covered by drbg_nopr_sha256 test */ 480164d1cdfbSStephan Mueller .alg = "drbg_nopr_sha384", 480264d1cdfbSStephan Mueller .fips_allowed = 1, 480364d1cdfbSStephan Mueller .test = alg_test_null, 480464d1cdfbSStephan Mueller }, { 480564d1cdfbSStephan Mueller .alg = "drbg_nopr_sha512", 480664d1cdfbSStephan Mueller .fips_allowed = 1, 480764d1cdfbSStephan Mueller .test = alg_test_null, 480864d1cdfbSStephan Mueller }, { 480964d1cdfbSStephan Mueller .alg = "drbg_pr_ctr_aes128", 481064d1cdfbSStephan Mueller .test = alg_test_drbg, 481164d1cdfbSStephan Mueller .fips_allowed = 1, 481264d1cdfbSStephan Mueller .suite = { 481321c8e720SArd Biesheuvel .drbg = __VECS(drbg_pr_ctr_aes128_tv_template) 481464d1cdfbSStephan Mueller } 481564d1cdfbSStephan Mueller }, { 481664d1cdfbSStephan Mueller /* covered by drbg_pr_ctr_aes128 test */ 481764d1cdfbSStephan Mueller .alg = "drbg_pr_ctr_aes192", 481864d1cdfbSStephan Mueller .fips_allowed = 1, 481964d1cdfbSStephan Mueller .test = alg_test_null, 482064d1cdfbSStephan Mueller }, { 482164d1cdfbSStephan Mueller .alg = "drbg_pr_ctr_aes256", 482264d1cdfbSStephan Mueller .fips_allowed = 1, 482364d1cdfbSStephan Mueller .test = alg_test_null, 482464d1cdfbSStephan Mueller }, { 482564d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha1", 482664d1cdfbSStephan Mueller .fips_allowed = 1, 482764d1cdfbSStephan Mueller .test = alg_test_null, 482864d1cdfbSStephan Mueller }, { 482964d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha256", 483064d1cdfbSStephan Mueller .test = alg_test_drbg, 483164d1cdfbSStephan Mueller .fips_allowed = 1, 483264d1cdfbSStephan Mueller .suite = { 483321c8e720SArd Biesheuvel .drbg = __VECS(drbg_pr_hmac_sha256_tv_template) 483464d1cdfbSStephan Mueller } 483564d1cdfbSStephan Mueller }, { 483664d1cdfbSStephan Mueller /* covered by drbg_pr_hmac_sha256 test */ 483764d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha384", 483864d1cdfbSStephan Mueller .fips_allowed = 1, 483964d1cdfbSStephan Mueller .test = alg_test_null, 484064d1cdfbSStephan Mueller }, { 484164d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha512", 484264d1cdfbSStephan Mueller .test = alg_test_null, 484364d1cdfbSStephan Mueller .fips_allowed = 1, 484464d1cdfbSStephan Mueller }, { 484564d1cdfbSStephan Mueller .alg = "drbg_pr_sha1", 484664d1cdfbSStephan Mueller .fips_allowed = 1, 484764d1cdfbSStephan Mueller .test = alg_test_null, 484864d1cdfbSStephan Mueller }, { 484964d1cdfbSStephan Mueller .alg = "drbg_pr_sha256", 485064d1cdfbSStephan Mueller .test = alg_test_drbg, 485164d1cdfbSStephan Mueller .fips_allowed = 1, 485264d1cdfbSStephan Mueller .suite = { 485321c8e720SArd Biesheuvel .drbg = __VECS(drbg_pr_sha256_tv_template) 485464d1cdfbSStephan Mueller } 485564d1cdfbSStephan Mueller }, { 485664d1cdfbSStephan Mueller /* covered by drbg_pr_sha256 test */ 485764d1cdfbSStephan Mueller .alg = "drbg_pr_sha384", 485864d1cdfbSStephan Mueller .fips_allowed = 1, 485964d1cdfbSStephan Mueller .test = alg_test_null, 486064d1cdfbSStephan Mueller }, { 486164d1cdfbSStephan Mueller .alg = "drbg_pr_sha512", 486264d1cdfbSStephan Mueller .fips_allowed = 1, 486364d1cdfbSStephan Mueller .test = alg_test_null, 486464d1cdfbSStephan Mueller }, { 4865da7f033dSHerbert Xu .alg = "ecb(aes)", 48661aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4867a1915d51SJarod Wilson .fips_allowed = 1, 4868da7f033dSHerbert Xu .suite = { 486992a4c9feSEric Biggers .cipher = __VECS(aes_tv_template) 4870da7f033dSHerbert Xu } 4871da7f033dSHerbert Xu }, { 4872da7f033dSHerbert Xu .alg = "ecb(anubis)", 48731aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4874da7f033dSHerbert Xu .suite = { 487592a4c9feSEric Biggers .cipher = __VECS(anubis_tv_template) 4876da7f033dSHerbert Xu } 4877da7f033dSHerbert Xu }, { 4878da7f033dSHerbert Xu .alg = "ecb(arc4)", 4879611a23c2SArd Biesheuvel .generic_driver = "ecb(arc4)-generic", 48801aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4881da7f033dSHerbert Xu .suite = { 488292a4c9feSEric Biggers .cipher = __VECS(arc4_tv_template) 4883da7f033dSHerbert Xu } 4884da7f033dSHerbert Xu }, { 488501ce31deSTaehee Yoo .alg = "ecb(aria)", 488601ce31deSTaehee Yoo .test = alg_test_skcipher, 488701ce31deSTaehee Yoo .suite = { 488801ce31deSTaehee Yoo .cipher = __VECS(aria_tv_template) 488901ce31deSTaehee Yoo } 489001ce31deSTaehee Yoo }, { 4891da7f033dSHerbert Xu .alg = "ecb(blowfish)", 48921aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4893da7f033dSHerbert Xu .suite = { 489492a4c9feSEric Biggers .cipher = __VECS(bf_tv_template) 4895da7f033dSHerbert Xu } 4896da7f033dSHerbert Xu }, { 4897da7f033dSHerbert Xu .alg = "ecb(camellia)", 48981aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4899da7f033dSHerbert Xu .suite = { 490092a4c9feSEric Biggers .cipher = __VECS(camellia_tv_template) 4901da7f033dSHerbert Xu } 4902da7f033dSHerbert Xu }, { 4903da7f033dSHerbert Xu .alg = "ecb(cast5)", 49041aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4905da7f033dSHerbert Xu .suite = { 490692a4c9feSEric Biggers .cipher = __VECS(cast5_tv_template) 4907da7f033dSHerbert Xu } 4908da7f033dSHerbert Xu }, { 4909da7f033dSHerbert Xu .alg = "ecb(cast6)", 49101aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4911da7f033dSHerbert Xu .suite = { 491292a4c9feSEric Biggers .cipher = __VECS(cast6_tv_template) 4913da7f033dSHerbert Xu } 4914da7f033dSHerbert Xu }, { 4915e448370dSJussi Kivilinna .alg = "ecb(cipher_null)", 4916e448370dSJussi Kivilinna .test = alg_test_null, 49176175ca2bSMilan Broz .fips_allowed = 1, 4918e448370dSJussi Kivilinna }, { 4919da7f033dSHerbert Xu .alg = "ecb(des)", 49201aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4921da7f033dSHerbert Xu .suite = { 492292a4c9feSEric Biggers .cipher = __VECS(des_tv_template) 4923da7f033dSHerbert Xu } 4924da7f033dSHerbert Xu }, { 4925da7f033dSHerbert Xu .alg = "ecb(des3_ede)", 49261aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4927da7f033dSHerbert Xu .suite = { 492892a4c9feSEric Biggers .cipher = __VECS(des3_ede_tv_template) 4929da7f033dSHerbert Xu } 4930da7f033dSHerbert Xu }, { 493166e5bd00SJussi Kivilinna .alg = "ecb(fcrypt)", 493266e5bd00SJussi Kivilinna .test = alg_test_skcipher, 493366e5bd00SJussi Kivilinna .suite = { 493466e5bd00SJussi Kivilinna .cipher = { 493592a4c9feSEric Biggers .vecs = fcrypt_pcbc_tv_template, 493666e5bd00SJussi Kivilinna .count = 1 493766e5bd00SJussi Kivilinna } 493866e5bd00SJussi Kivilinna } 493966e5bd00SJussi Kivilinna }, { 4940da7f033dSHerbert Xu .alg = "ecb(khazad)", 49411aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4942da7f033dSHerbert Xu .suite = { 494392a4c9feSEric Biggers .cipher = __VECS(khazad_tv_template) 4944da7f033dSHerbert Xu } 4945da7f033dSHerbert Xu }, { 494615f47ce5SGilad Ben-Yossef /* Same as ecb(aes) except the key is stored in 494715f47ce5SGilad Ben-Yossef * hardware secure memory which we reference by index 494815f47ce5SGilad Ben-Yossef */ 494915f47ce5SGilad Ben-Yossef .alg = "ecb(paes)", 495015f47ce5SGilad Ben-Yossef .test = alg_test_null, 495115f47ce5SGilad Ben-Yossef .fips_allowed = 1, 495215f47ce5SGilad Ben-Yossef }, { 4953da7f033dSHerbert Xu .alg = "ecb(seed)", 49541aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4955da7f033dSHerbert Xu .suite = { 495692a4c9feSEric Biggers .cipher = __VECS(seed_tv_template) 4957da7f033dSHerbert Xu } 4958da7f033dSHerbert Xu }, { 4959da7f033dSHerbert Xu .alg = "ecb(serpent)", 49601aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4961da7f033dSHerbert Xu .suite = { 496292a4c9feSEric Biggers .cipher = __VECS(serpent_tv_template) 4963da7f033dSHerbert Xu } 4964da7f033dSHerbert Xu }, { 4965cd83a8a7SGilad Ben-Yossef .alg = "ecb(sm4)", 4966cd83a8a7SGilad Ben-Yossef .test = alg_test_skcipher, 4967cd83a8a7SGilad Ben-Yossef .suite = { 496892a4c9feSEric Biggers .cipher = __VECS(sm4_tv_template) 4969cd83a8a7SGilad Ben-Yossef } 4970cd83a8a7SGilad Ben-Yossef }, { 4971da7f033dSHerbert Xu .alg = "ecb(tea)", 49721aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4973da7f033dSHerbert Xu .suite = { 497492a4c9feSEric Biggers .cipher = __VECS(tea_tv_template) 4975da7f033dSHerbert Xu } 4976da7f033dSHerbert Xu }, { 4977da7f033dSHerbert Xu .alg = "ecb(twofish)", 49781aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4979da7f033dSHerbert Xu .suite = { 498092a4c9feSEric Biggers .cipher = __VECS(tf_tv_template) 4981da7f033dSHerbert Xu } 4982da7f033dSHerbert Xu }, { 4983da7f033dSHerbert Xu .alg = "ecb(xeta)", 49841aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4985da7f033dSHerbert Xu .suite = { 498692a4c9feSEric Biggers .cipher = __VECS(xeta_tv_template) 4987da7f033dSHerbert Xu } 4988da7f033dSHerbert Xu }, { 4989da7f033dSHerbert Xu .alg = "ecb(xtea)", 49901aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4991da7f033dSHerbert Xu .suite = { 499292a4c9feSEric Biggers .cipher = __VECS(xtea_tv_template) 4993da7f033dSHerbert Xu } 4994da7f033dSHerbert Xu }, { 4995c7ff8573SHarald Freudenberger #if IS_ENABLED(CONFIG_CRYPTO_PAES_S390) 4996c7ff8573SHarald Freudenberger .alg = "ecb-paes-s390", 4997c7ff8573SHarald Freudenberger .fips_allowed = 1, 4998c7ff8573SHarald Freudenberger .test = alg_test_skcipher, 4999c7ff8573SHarald Freudenberger .suite = { 5000c7ff8573SHarald Freudenberger .cipher = __VECS(aes_tv_template) 5001c7ff8573SHarald Freudenberger } 5002c7ff8573SHarald Freudenberger }, { 5003c7ff8573SHarald Freudenberger #endif 50046763f5eaSMeng Yu .alg = "ecdh-nist-p192", 50053c4b2390SSalvatore Benedetto .test = alg_test_kpp, 50063c4b2390SSalvatore Benedetto .suite = { 50076763f5eaSMeng Yu .kpp = __VECS(ecdh_p192_tv_template) 50086763f5eaSMeng Yu } 50096763f5eaSMeng Yu }, { 50106763f5eaSMeng Yu .alg = "ecdh-nist-p256", 50116763f5eaSMeng Yu .test = alg_test_kpp, 50126763f5eaSMeng Yu .fips_allowed = 1, 50136763f5eaSMeng Yu .suite = { 50146763f5eaSMeng Yu .kpp = __VECS(ecdh_p256_tv_template) 50153c4b2390SSalvatore Benedetto } 50163c4b2390SSalvatore Benedetto }, { 50178e568fc2SHui Tang .alg = "ecdh-nist-p384", 50188e568fc2SHui Tang .test = alg_test_kpp, 50198e568fc2SHui Tang .fips_allowed = 1, 50208e568fc2SHui Tang .suite = { 50218e568fc2SHui Tang .kpp = __VECS(ecdh_p384_tv_template) 50228e568fc2SHui Tang } 50238e568fc2SHui Tang }, { 50244e660291SStefan Berger .alg = "ecdsa-nist-p192", 50254e660291SStefan Berger .test = alg_test_akcipher, 50264e660291SStefan Berger .suite = { 50274e660291SStefan Berger .akcipher = __VECS(ecdsa_nist_p192_tv_template) 50284e660291SStefan Berger } 50294e660291SStefan Berger }, { 50304e660291SStefan Berger .alg = "ecdsa-nist-p256", 50314e660291SStefan Berger .test = alg_test_akcipher, 50324e660291SStefan Berger .suite = { 50334e660291SStefan Berger .akcipher = __VECS(ecdsa_nist_p256_tv_template) 50344e660291SStefan Berger } 50354e660291SStefan Berger }, { 5036c12d448bSSaulo Alessandre .alg = "ecdsa-nist-p384", 5037c12d448bSSaulo Alessandre .test = alg_test_akcipher, 5038c12d448bSSaulo Alessandre .suite = { 5039c12d448bSSaulo Alessandre .akcipher = __VECS(ecdsa_nist_p384_tv_template) 5040c12d448bSSaulo Alessandre } 5041c12d448bSSaulo Alessandre }, { 504232fbdbd3SVitaly Chikunov .alg = "ecrdsa", 504332fbdbd3SVitaly Chikunov .test = alg_test_akcipher, 504432fbdbd3SVitaly Chikunov .suite = { 504532fbdbd3SVitaly Chikunov .akcipher = __VECS(ecrdsa_tv_template) 504632fbdbd3SVitaly Chikunov } 504732fbdbd3SVitaly Chikunov }, { 5048f975abb2SArd Biesheuvel .alg = "essiv(authenc(hmac(sha256),cbc(aes)),sha256)", 5049f975abb2SArd Biesheuvel .test = alg_test_aead, 5050f975abb2SArd Biesheuvel .fips_allowed = 1, 5051f975abb2SArd Biesheuvel .suite = { 5052f975abb2SArd Biesheuvel .aead = __VECS(essiv_hmac_sha256_aes_cbc_tv_temp) 5053f975abb2SArd Biesheuvel } 5054f975abb2SArd Biesheuvel }, { 5055f975abb2SArd Biesheuvel .alg = "essiv(cbc(aes),sha256)", 5056f975abb2SArd Biesheuvel .test = alg_test_skcipher, 5057f975abb2SArd Biesheuvel .fips_allowed = 1, 5058f975abb2SArd Biesheuvel .suite = { 5059f975abb2SArd Biesheuvel .cipher = __VECS(essiv_aes_cbc_tv_template) 5060f975abb2SArd Biesheuvel } 5061f975abb2SArd Biesheuvel }, { 506260a273e9SNicolai Stange #if IS_ENABLED(CONFIG_CRYPTO_DH_RFC7919_GROUPS) 506360a273e9SNicolai Stange .alg = "ffdhe2048(dh)", 506460a273e9SNicolai Stange .test = alg_test_kpp, 506560a273e9SNicolai Stange .fips_allowed = 1, 506660a273e9SNicolai Stange .suite = { 506760a273e9SNicolai Stange .kpp = __VECS(ffdhe2048_dh_tv_template) 506860a273e9SNicolai Stange } 506960a273e9SNicolai Stange }, { 507060a273e9SNicolai Stange .alg = "ffdhe3072(dh)", 507160a273e9SNicolai Stange .test = alg_test_kpp, 507260a273e9SNicolai Stange .fips_allowed = 1, 507360a273e9SNicolai Stange .suite = { 507460a273e9SNicolai Stange .kpp = __VECS(ffdhe3072_dh_tv_template) 507560a273e9SNicolai Stange } 507660a273e9SNicolai Stange }, { 507760a273e9SNicolai Stange .alg = "ffdhe4096(dh)", 507860a273e9SNicolai Stange .test = alg_test_kpp, 507960a273e9SNicolai Stange .fips_allowed = 1, 508060a273e9SNicolai Stange .suite = { 508160a273e9SNicolai Stange .kpp = __VECS(ffdhe4096_dh_tv_template) 508260a273e9SNicolai Stange } 508360a273e9SNicolai Stange }, { 508460a273e9SNicolai Stange .alg = "ffdhe6144(dh)", 508560a273e9SNicolai Stange .test = alg_test_kpp, 508660a273e9SNicolai Stange .fips_allowed = 1, 508760a273e9SNicolai Stange .suite = { 508860a273e9SNicolai Stange .kpp = __VECS(ffdhe6144_dh_tv_template) 508960a273e9SNicolai Stange } 509060a273e9SNicolai Stange }, { 509160a273e9SNicolai Stange .alg = "ffdhe8192(dh)", 509260a273e9SNicolai Stange .test = alg_test_kpp, 509360a273e9SNicolai Stange .fips_allowed = 1, 509460a273e9SNicolai Stange .suite = { 509560a273e9SNicolai Stange .kpp = __VECS(ffdhe8192_dh_tv_template) 509660a273e9SNicolai Stange } 509760a273e9SNicolai Stange }, { 509860a273e9SNicolai Stange #endif /* CONFIG_CRYPTO_DH_RFC7919_GROUPS */ 5099da7f033dSHerbert Xu .alg = "gcm(aes)", 510040153b10SEric Biggers .generic_driver = "gcm_base(ctr(aes-generic),ghash-generic)", 5101da7f033dSHerbert Xu .test = alg_test_aead, 5102a1915d51SJarod Wilson .fips_allowed = 1, 5103da7f033dSHerbert Xu .suite = { 5104a0d608eeSEric Biggers .aead = __VECS(aes_gcm_tv_template) 5105da7f033dSHerbert Xu } 5106da7f033dSHerbert Xu }, { 510701ce31deSTaehee Yoo .alg = "gcm(aria)", 510801ce31deSTaehee Yoo .generic_driver = "gcm_base(ctr(aria-generic),ghash-generic)", 510901ce31deSTaehee Yoo .test = alg_test_aead, 511001ce31deSTaehee Yoo .suite = { 511101ce31deSTaehee Yoo .aead = __VECS(aria_gcm_tv_template) 511201ce31deSTaehee Yoo } 511301ce31deSTaehee Yoo }, { 511468039d60STianjia Zhang .alg = "gcm(sm4)", 511568039d60STianjia Zhang .generic_driver = "gcm_base(ctr(sm4-generic),ghash-generic)", 511668039d60STianjia Zhang .test = alg_test_aead, 511768039d60STianjia Zhang .suite = { 511868039d60STianjia Zhang .aead = __VECS(sm4_gcm_tv_template) 511968039d60STianjia Zhang } 512068039d60STianjia Zhang }, { 5121507069c9SYouquan, Song .alg = "ghash", 5122507069c9SYouquan, Song .test = alg_test_hash, 512318c0ebd2SJarod Wilson .fips_allowed = 1, 5124507069c9SYouquan, Song .suite = { 512521c8e720SArd Biesheuvel .hash = __VECS(ghash_tv_template) 5126507069c9SYouquan, Song } 5127507069c9SYouquan, Song }, { 51287ff554ceSNathan Huckleberry .alg = "hctr2(aes)", 51297ff554ceSNathan Huckleberry .generic_driver = 51307ff554ceSNathan Huckleberry "hctr2_base(xctr(aes-generic),polyval-generic)", 51317ff554ceSNathan Huckleberry .test = alg_test_skcipher, 51327ff554ceSNathan Huckleberry .suite = { 51337ff554ceSNathan Huckleberry .cipher = __VECS(aes_hctr2_tv_template) 51347ff554ceSNathan Huckleberry } 51357ff554ceSNathan Huckleberry }, { 5136da7f033dSHerbert Xu .alg = "hmac(md5)", 5137da7f033dSHerbert Xu .test = alg_test_hash, 5138da7f033dSHerbert Xu .suite = { 513921c8e720SArd Biesheuvel .hash = __VECS(hmac_md5_tv_template) 5140da7f033dSHerbert Xu } 5141da7f033dSHerbert Xu }, { 5142da7f033dSHerbert Xu .alg = "hmac(rmd160)", 5143da7f033dSHerbert Xu .test = alg_test_hash, 5144da7f033dSHerbert Xu .suite = { 514521c8e720SArd Biesheuvel .hash = __VECS(hmac_rmd160_tv_template) 5146da7f033dSHerbert Xu } 5147da7f033dSHerbert Xu }, { 5148da7f033dSHerbert Xu .alg = "hmac(sha1)", 5149da7f033dSHerbert Xu .test = alg_test_hash, 5150a1915d51SJarod Wilson .fips_allowed = 1, 5151da7f033dSHerbert Xu .suite = { 515221c8e720SArd Biesheuvel .hash = __VECS(hmac_sha1_tv_template) 5153da7f033dSHerbert Xu } 5154da7f033dSHerbert Xu }, { 5155da7f033dSHerbert Xu .alg = "hmac(sha224)", 5156da7f033dSHerbert Xu .test = alg_test_hash, 5157a1915d51SJarod Wilson .fips_allowed = 1, 5158da7f033dSHerbert Xu .suite = { 515921c8e720SArd Biesheuvel .hash = __VECS(hmac_sha224_tv_template) 5160da7f033dSHerbert Xu } 5161da7f033dSHerbert Xu }, { 5162da7f033dSHerbert Xu .alg = "hmac(sha256)", 5163da7f033dSHerbert Xu .test = alg_test_hash, 5164a1915d51SJarod Wilson .fips_allowed = 1, 5165da7f033dSHerbert Xu .suite = { 516621c8e720SArd Biesheuvel .hash = __VECS(hmac_sha256_tv_template) 5167da7f033dSHerbert Xu } 5168da7f033dSHerbert Xu }, { 516998eca72fSraveendra padasalagi .alg = "hmac(sha3-224)", 517098eca72fSraveendra padasalagi .test = alg_test_hash, 517198eca72fSraveendra padasalagi .fips_allowed = 1, 517298eca72fSraveendra padasalagi .suite = { 517321c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_224_tv_template) 517498eca72fSraveendra padasalagi } 517598eca72fSraveendra padasalagi }, { 517698eca72fSraveendra padasalagi .alg = "hmac(sha3-256)", 517798eca72fSraveendra padasalagi .test = alg_test_hash, 517898eca72fSraveendra padasalagi .fips_allowed = 1, 517998eca72fSraveendra padasalagi .suite = { 518021c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_256_tv_template) 518198eca72fSraveendra padasalagi } 518298eca72fSraveendra padasalagi }, { 518398eca72fSraveendra padasalagi .alg = "hmac(sha3-384)", 518498eca72fSraveendra padasalagi .test = alg_test_hash, 518598eca72fSraveendra padasalagi .fips_allowed = 1, 518698eca72fSraveendra padasalagi .suite = { 518721c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_384_tv_template) 518898eca72fSraveendra padasalagi } 518998eca72fSraveendra padasalagi }, { 519098eca72fSraveendra padasalagi .alg = "hmac(sha3-512)", 519198eca72fSraveendra padasalagi .test = alg_test_hash, 519298eca72fSraveendra padasalagi .fips_allowed = 1, 519398eca72fSraveendra padasalagi .suite = { 519421c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_512_tv_template) 519598eca72fSraveendra padasalagi } 519698eca72fSraveendra padasalagi }, { 5197da7f033dSHerbert Xu .alg = "hmac(sha384)", 5198da7f033dSHerbert Xu .test = alg_test_hash, 5199a1915d51SJarod Wilson .fips_allowed = 1, 5200da7f033dSHerbert Xu .suite = { 520121c8e720SArd Biesheuvel .hash = __VECS(hmac_sha384_tv_template) 5202da7f033dSHerbert Xu } 5203da7f033dSHerbert Xu }, { 5204da7f033dSHerbert Xu .alg = "hmac(sha512)", 5205da7f033dSHerbert Xu .test = alg_test_hash, 5206a1915d51SJarod Wilson .fips_allowed = 1, 5207da7f033dSHerbert Xu .suite = { 520821c8e720SArd Biesheuvel .hash = __VECS(hmac_sha512_tv_template) 5209da7f033dSHerbert Xu } 5210da7f033dSHerbert Xu }, { 52118194fd1dSPascal van Leeuwen .alg = "hmac(sm3)", 52128194fd1dSPascal van Leeuwen .test = alg_test_hash, 52138194fd1dSPascal van Leeuwen .suite = { 52148194fd1dSPascal van Leeuwen .hash = __VECS(hmac_sm3_tv_template) 52158194fd1dSPascal van Leeuwen } 52168194fd1dSPascal van Leeuwen }, { 521725a0b9d4SVitaly Chikunov .alg = "hmac(streebog256)", 521825a0b9d4SVitaly Chikunov .test = alg_test_hash, 521925a0b9d4SVitaly Chikunov .suite = { 522025a0b9d4SVitaly Chikunov .hash = __VECS(hmac_streebog256_tv_template) 522125a0b9d4SVitaly Chikunov } 522225a0b9d4SVitaly Chikunov }, { 522325a0b9d4SVitaly Chikunov .alg = "hmac(streebog512)", 522425a0b9d4SVitaly Chikunov .test = alg_test_hash, 522525a0b9d4SVitaly Chikunov .suite = { 522625a0b9d4SVitaly Chikunov .hash = __VECS(hmac_streebog512_tv_template) 522725a0b9d4SVitaly Chikunov } 522825a0b9d4SVitaly Chikunov }, { 5229bb5530e4SStephan Mueller .alg = "jitterentropy_rng", 5230bb5530e4SStephan Mueller .fips_allowed = 1, 5231bb5530e4SStephan Mueller .test = alg_test_null, 5232bb5530e4SStephan Mueller }, { 523335351988SStephan Mueller .alg = "kw(aes)", 523435351988SStephan Mueller .test = alg_test_skcipher, 523535351988SStephan Mueller .fips_allowed = 1, 523635351988SStephan Mueller .suite = { 523792a4c9feSEric Biggers .cipher = __VECS(aes_kw_tv_template) 523835351988SStephan Mueller } 523935351988SStephan Mueller }, { 5240da7f033dSHerbert Xu .alg = "lrw(aes)", 5241d435e10eSEric Biggers .generic_driver = "lrw(ecb(aes-generic))", 52421aa4ecd9SHerbert Xu .test = alg_test_skcipher, 5243da7f033dSHerbert Xu .suite = { 524492a4c9feSEric Biggers .cipher = __VECS(aes_lrw_tv_template) 5245da7f033dSHerbert Xu } 5246da7f033dSHerbert Xu }, { 52470840605eSJussi Kivilinna .alg = "lrw(camellia)", 5248d435e10eSEric Biggers .generic_driver = "lrw(ecb(camellia-generic))", 52490840605eSJussi Kivilinna .test = alg_test_skcipher, 52500840605eSJussi Kivilinna .suite = { 525192a4c9feSEric Biggers .cipher = __VECS(camellia_lrw_tv_template) 52520840605eSJussi Kivilinna } 52530840605eSJussi Kivilinna }, { 52549b8b0405SJohannes Goetzfried .alg = "lrw(cast6)", 5255d435e10eSEric Biggers .generic_driver = "lrw(ecb(cast6-generic))", 52569b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 52579b8b0405SJohannes Goetzfried .suite = { 525892a4c9feSEric Biggers .cipher = __VECS(cast6_lrw_tv_template) 52599b8b0405SJohannes Goetzfried } 52609b8b0405SJohannes Goetzfried }, { 5261d7bfc0faSJussi Kivilinna .alg = "lrw(serpent)", 5262d435e10eSEric Biggers .generic_driver = "lrw(ecb(serpent-generic))", 5263d7bfc0faSJussi Kivilinna .test = alg_test_skcipher, 5264d7bfc0faSJussi Kivilinna .suite = { 526592a4c9feSEric Biggers .cipher = __VECS(serpent_lrw_tv_template) 5266d7bfc0faSJussi Kivilinna } 5267d7bfc0faSJussi Kivilinna }, { 52680b2a1551SJussi Kivilinna .alg = "lrw(twofish)", 5269d435e10eSEric Biggers .generic_driver = "lrw(ecb(twofish-generic))", 52700b2a1551SJussi Kivilinna .test = alg_test_skcipher, 52710b2a1551SJussi Kivilinna .suite = { 527292a4c9feSEric Biggers .cipher = __VECS(tf_lrw_tv_template) 52730b2a1551SJussi Kivilinna } 52740b2a1551SJussi Kivilinna }, { 52751443cc9bSKOVACS Krisztian .alg = "lz4", 52761443cc9bSKOVACS Krisztian .test = alg_test_comp, 52771443cc9bSKOVACS Krisztian .fips_allowed = 1, 52781443cc9bSKOVACS Krisztian .suite = { 52791443cc9bSKOVACS Krisztian .comp = { 528021c8e720SArd Biesheuvel .comp = __VECS(lz4_comp_tv_template), 528121c8e720SArd Biesheuvel .decomp = __VECS(lz4_decomp_tv_template) 52821443cc9bSKOVACS Krisztian } 52831443cc9bSKOVACS Krisztian } 52841443cc9bSKOVACS Krisztian }, { 52851443cc9bSKOVACS Krisztian .alg = "lz4hc", 52861443cc9bSKOVACS Krisztian .test = alg_test_comp, 52871443cc9bSKOVACS Krisztian .fips_allowed = 1, 52881443cc9bSKOVACS Krisztian .suite = { 52891443cc9bSKOVACS Krisztian .comp = { 529021c8e720SArd Biesheuvel .comp = __VECS(lz4hc_comp_tv_template), 529121c8e720SArd Biesheuvel .decomp = __VECS(lz4hc_decomp_tv_template) 52921443cc9bSKOVACS Krisztian } 52931443cc9bSKOVACS Krisztian } 52941443cc9bSKOVACS Krisztian }, { 5295da7f033dSHerbert Xu .alg = "lzo", 5296da7f033dSHerbert Xu .test = alg_test_comp, 52970818904dSMilan Broz .fips_allowed = 1, 5298da7f033dSHerbert Xu .suite = { 5299da7f033dSHerbert Xu .comp = { 530021c8e720SArd Biesheuvel .comp = __VECS(lzo_comp_tv_template), 530121c8e720SArd Biesheuvel .decomp = __VECS(lzo_decomp_tv_template) 5302da7f033dSHerbert Xu } 5303da7f033dSHerbert Xu } 5304da7f033dSHerbert Xu }, { 5305f248caf9SHannah Pan .alg = "lzo-rle", 5306f248caf9SHannah Pan .test = alg_test_comp, 5307f248caf9SHannah Pan .fips_allowed = 1, 5308f248caf9SHannah Pan .suite = { 5309f248caf9SHannah Pan .comp = { 5310f248caf9SHannah Pan .comp = __VECS(lzorle_comp_tv_template), 5311f248caf9SHannah Pan .decomp = __VECS(lzorle_decomp_tv_template) 5312f248caf9SHannah Pan } 5313f248caf9SHannah Pan } 5314f248caf9SHannah Pan }, { 5315da7f033dSHerbert Xu .alg = "md4", 5316da7f033dSHerbert Xu .test = alg_test_hash, 5317da7f033dSHerbert Xu .suite = { 531821c8e720SArd Biesheuvel .hash = __VECS(md4_tv_template) 5319da7f033dSHerbert Xu } 5320da7f033dSHerbert Xu }, { 5321da7f033dSHerbert Xu .alg = "md5", 5322da7f033dSHerbert Xu .test = alg_test_hash, 5323da7f033dSHerbert Xu .suite = { 532421c8e720SArd Biesheuvel .hash = __VECS(md5_tv_template) 5325da7f033dSHerbert Xu } 5326da7f033dSHerbert Xu }, { 5327da7f033dSHerbert Xu .alg = "michael_mic", 5328da7f033dSHerbert Xu .test = alg_test_hash, 5329da7f033dSHerbert Xu .suite = { 533021c8e720SArd Biesheuvel .hash = __VECS(michael_mic_tv_template) 5331da7f033dSHerbert Xu } 5332da7f033dSHerbert Xu }, { 533326609a21SEric Biggers .alg = "nhpoly1305", 533426609a21SEric Biggers .test = alg_test_hash, 533526609a21SEric Biggers .suite = { 533626609a21SEric Biggers .hash = __VECS(nhpoly1305_tv_template) 533726609a21SEric Biggers } 533826609a21SEric Biggers }, { 5339ba0e14acSPuneet Saxena .alg = "ofb(aes)", 5340ba0e14acSPuneet Saxena .test = alg_test_skcipher, 5341ba0e14acSPuneet Saxena .fips_allowed = 1, 5342ba0e14acSPuneet Saxena .suite = { 534392a4c9feSEric Biggers .cipher = __VECS(aes_ofb_tv_template) 5344ba0e14acSPuneet Saxena } 5345ba0e14acSPuneet Saxena }, { 5346a794d8d8SGilad Ben-Yossef /* Same as ofb(aes) except the key is stored in 5347a794d8d8SGilad Ben-Yossef * hardware secure memory which we reference by index 5348a794d8d8SGilad Ben-Yossef */ 5349a794d8d8SGilad Ben-Yossef .alg = "ofb(paes)", 5350a794d8d8SGilad Ben-Yossef .test = alg_test_null, 5351a794d8d8SGilad Ben-Yossef .fips_allowed = 1, 5352a794d8d8SGilad Ben-Yossef }, { 5353a06b15b2SPascal van Leeuwen .alg = "ofb(sm4)", 5354a06b15b2SPascal van Leeuwen .test = alg_test_skcipher, 5355a06b15b2SPascal van Leeuwen .suite = { 5356a06b15b2SPascal van Leeuwen .cipher = __VECS(sm4_ofb_tv_template) 5357a06b15b2SPascal van Leeuwen } 5358a06b15b2SPascal van Leeuwen }, { 5359da7f033dSHerbert Xu .alg = "pcbc(fcrypt)", 53601aa4ecd9SHerbert Xu .test = alg_test_skcipher, 5361da7f033dSHerbert Xu .suite = { 536292a4c9feSEric Biggers .cipher = __VECS(fcrypt_pcbc_tv_template) 5363da7f033dSHerbert Xu } 5364da7f033dSHerbert Xu }, { 53651207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha224)", 53661207107cSStephan Mueller .test = alg_test_null, 53671207107cSStephan Mueller .fips_allowed = 1, 53681207107cSStephan Mueller }, { 53691207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha256)", 53701207107cSStephan Mueller .test = alg_test_akcipher, 53711207107cSStephan Mueller .fips_allowed = 1, 53721207107cSStephan Mueller .suite = { 53731207107cSStephan Mueller .akcipher = __VECS(pkcs1pad_rsa_tv_template) 53741207107cSStephan Mueller } 53751207107cSStephan Mueller }, { 53761207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha384)", 53771207107cSStephan Mueller .test = alg_test_null, 53781207107cSStephan Mueller .fips_allowed = 1, 53791207107cSStephan Mueller }, { 53801207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha512)", 53811207107cSStephan Mueller .test = alg_test_null, 53821207107cSStephan Mueller .fips_allowed = 1, 53831207107cSStephan Mueller }, { 5384eee9dc61SMartin Willi .alg = "poly1305", 5385eee9dc61SMartin Willi .test = alg_test_hash, 5386eee9dc61SMartin Willi .suite = { 538721c8e720SArd Biesheuvel .hash = __VECS(poly1305_tv_template) 5388eee9dc61SMartin Willi } 5389eee9dc61SMartin Willi }, { 5390f3c923a0SNathan Huckleberry .alg = "polyval", 5391f3c923a0SNathan Huckleberry .test = alg_test_hash, 5392f3c923a0SNathan Huckleberry .suite = { 5393f3c923a0SNathan Huckleberry .hash = __VECS(polyval_tv_template) 5394f3c923a0SNathan Huckleberry } 5395f3c923a0SNathan Huckleberry }, { 5396da7f033dSHerbert Xu .alg = "rfc3686(ctr(aes))", 53971aa4ecd9SHerbert Xu .test = alg_test_skcipher, 5398a1915d51SJarod Wilson .fips_allowed = 1, 5399da7f033dSHerbert Xu .suite = { 540092a4c9feSEric Biggers .cipher = __VECS(aes_ctr_rfc3686_tv_template) 5401da7f033dSHerbert Xu } 5402da7f033dSHerbert Xu }, { 5403e4886214SPascal van Leeuwen .alg = "rfc3686(ctr(sm4))", 5404e4886214SPascal van Leeuwen .test = alg_test_skcipher, 5405e4886214SPascal van Leeuwen .suite = { 5406e4886214SPascal van Leeuwen .cipher = __VECS(sm4_ctr_rfc3686_tv_template) 5407e4886214SPascal van Leeuwen } 5408e4886214SPascal van Leeuwen }, { 54093f31a740SHerbert Xu .alg = "rfc4106(gcm(aes))", 541040153b10SEric Biggers .generic_driver = "rfc4106(gcm_base(ctr(aes-generic),ghash-generic))", 541169435b94SAdrian Hoban .test = alg_test_aead, 5412db71f29aSJarod Wilson .fips_allowed = 1, 541369435b94SAdrian Hoban .suite = { 541449763fc6SEric Biggers .aead = { 541549763fc6SEric Biggers ____VECS(aes_gcm_rfc4106_tv_template), 541649763fc6SEric Biggers .einval_allowed = 1, 54176f3a06d9SEric Biggers .aad_iv = 1, 541849763fc6SEric Biggers } 541969435b94SAdrian Hoban } 542069435b94SAdrian Hoban }, { 5421544c436aSHerbert Xu .alg = "rfc4309(ccm(aes))", 542240153b10SEric Biggers .generic_driver = "rfc4309(ccm_base(ctr(aes-generic),cbcmac(aes-generic)))", 54235d667322SJarod Wilson .test = alg_test_aead, 5424a1915d51SJarod Wilson .fips_allowed = 1, 54255d667322SJarod Wilson .suite = { 542649763fc6SEric Biggers .aead = { 542749763fc6SEric Biggers ____VECS(aes_ccm_rfc4309_tv_template), 542849763fc6SEric Biggers .einval_allowed = 1, 54296f3a06d9SEric Biggers .aad_iv = 1, 543049763fc6SEric Biggers } 54315d667322SJarod Wilson } 54325d667322SJarod Wilson }, { 5433bb68745eSHerbert Xu .alg = "rfc4543(gcm(aes))", 543440153b10SEric Biggers .generic_driver = "rfc4543(gcm_base(ctr(aes-generic),ghash-generic))", 5435e9b7441aSJussi Kivilinna .test = alg_test_aead, 5436e9b7441aSJussi Kivilinna .suite = { 543749763fc6SEric Biggers .aead = { 543849763fc6SEric Biggers ____VECS(aes_gcm_rfc4543_tv_template), 543949763fc6SEric Biggers .einval_allowed = 1, 54406f3a06d9SEric Biggers .aad_iv = 1, 544149763fc6SEric Biggers } 5442e9b7441aSJussi Kivilinna } 5443e9b7441aSJussi Kivilinna }, { 5444af2b76b5SMartin Willi .alg = "rfc7539(chacha20,poly1305)", 5445af2b76b5SMartin Willi .test = alg_test_aead, 5446af2b76b5SMartin Willi .suite = { 5447a0d608eeSEric Biggers .aead = __VECS(rfc7539_tv_template) 5448af2b76b5SMartin Willi } 5449af2b76b5SMartin Willi }, { 54505900758dSMartin Willi .alg = "rfc7539esp(chacha20,poly1305)", 54515900758dSMartin Willi .test = alg_test_aead, 54525900758dSMartin Willi .suite = { 545349763fc6SEric Biggers .aead = { 545449763fc6SEric Biggers ____VECS(rfc7539esp_tv_template), 545549763fc6SEric Biggers .einval_allowed = 1, 54566f3a06d9SEric Biggers .aad_iv = 1, 545749763fc6SEric Biggers } 54585900758dSMartin Willi } 54595900758dSMartin Willi }, { 5460da7f033dSHerbert Xu .alg = "rmd160", 5461da7f033dSHerbert Xu .test = alg_test_hash, 5462da7f033dSHerbert Xu .suite = { 546321c8e720SArd Biesheuvel .hash = __VECS(rmd160_tv_template) 5464da7f033dSHerbert Xu } 5465da7f033dSHerbert Xu }, { 5466946cc463STadeusz Struk .alg = "rsa", 5467946cc463STadeusz Struk .test = alg_test_akcipher, 5468946cc463STadeusz Struk .fips_allowed = 1, 5469946cc463STadeusz Struk .suite = { 547021c8e720SArd Biesheuvel .akcipher = __VECS(rsa_tv_template) 5471946cc463STadeusz Struk } 5472946cc463STadeusz Struk }, { 5473da7f033dSHerbert Xu .alg = "sha1", 5474da7f033dSHerbert Xu .test = alg_test_hash, 5475a1915d51SJarod Wilson .fips_allowed = 1, 5476da7f033dSHerbert Xu .suite = { 547721c8e720SArd Biesheuvel .hash = __VECS(sha1_tv_template) 5478da7f033dSHerbert Xu } 5479da7f033dSHerbert Xu }, { 5480da7f033dSHerbert Xu .alg = "sha224", 5481da7f033dSHerbert Xu .test = alg_test_hash, 5482a1915d51SJarod Wilson .fips_allowed = 1, 5483da7f033dSHerbert Xu .suite = { 548421c8e720SArd Biesheuvel .hash = __VECS(sha224_tv_template) 5485da7f033dSHerbert Xu } 5486da7f033dSHerbert Xu }, { 5487da7f033dSHerbert Xu .alg = "sha256", 5488da7f033dSHerbert Xu .test = alg_test_hash, 5489a1915d51SJarod Wilson .fips_allowed = 1, 5490da7f033dSHerbert Xu .suite = { 549121c8e720SArd Biesheuvel .hash = __VECS(sha256_tv_template) 5492da7f033dSHerbert Xu } 5493da7f033dSHerbert Xu }, { 549479cc6ab8Sraveendra padasalagi .alg = "sha3-224", 549579cc6ab8Sraveendra padasalagi .test = alg_test_hash, 549679cc6ab8Sraveendra padasalagi .fips_allowed = 1, 549779cc6ab8Sraveendra padasalagi .suite = { 549821c8e720SArd Biesheuvel .hash = __VECS(sha3_224_tv_template) 549979cc6ab8Sraveendra padasalagi } 550079cc6ab8Sraveendra padasalagi }, { 550179cc6ab8Sraveendra padasalagi .alg = "sha3-256", 550279cc6ab8Sraveendra padasalagi .test = alg_test_hash, 550379cc6ab8Sraveendra padasalagi .fips_allowed = 1, 550479cc6ab8Sraveendra padasalagi .suite = { 550521c8e720SArd Biesheuvel .hash = __VECS(sha3_256_tv_template) 550679cc6ab8Sraveendra padasalagi } 550779cc6ab8Sraveendra padasalagi }, { 550879cc6ab8Sraveendra padasalagi .alg = "sha3-384", 550979cc6ab8Sraveendra padasalagi .test = alg_test_hash, 551079cc6ab8Sraveendra padasalagi .fips_allowed = 1, 551179cc6ab8Sraveendra padasalagi .suite = { 551221c8e720SArd Biesheuvel .hash = __VECS(sha3_384_tv_template) 551379cc6ab8Sraveendra padasalagi } 551479cc6ab8Sraveendra padasalagi }, { 551579cc6ab8Sraveendra padasalagi .alg = "sha3-512", 551679cc6ab8Sraveendra padasalagi .test = alg_test_hash, 551779cc6ab8Sraveendra padasalagi .fips_allowed = 1, 551879cc6ab8Sraveendra padasalagi .suite = { 551921c8e720SArd Biesheuvel .hash = __VECS(sha3_512_tv_template) 552079cc6ab8Sraveendra padasalagi } 552179cc6ab8Sraveendra padasalagi }, { 5522da7f033dSHerbert Xu .alg = "sha384", 5523da7f033dSHerbert Xu .test = alg_test_hash, 5524a1915d51SJarod Wilson .fips_allowed = 1, 5525da7f033dSHerbert Xu .suite = { 552621c8e720SArd Biesheuvel .hash = __VECS(sha384_tv_template) 5527da7f033dSHerbert Xu } 5528da7f033dSHerbert Xu }, { 5529da7f033dSHerbert Xu .alg = "sha512", 5530da7f033dSHerbert Xu .test = alg_test_hash, 5531a1915d51SJarod Wilson .fips_allowed = 1, 5532da7f033dSHerbert Xu .suite = { 553321c8e720SArd Biesheuvel .hash = __VECS(sha512_tv_template) 5534da7f033dSHerbert Xu } 5535da7f033dSHerbert Xu }, { 55368b805b97STianjia Zhang .alg = "sm2", 55378b805b97STianjia Zhang .test = alg_test_akcipher, 55388b805b97STianjia Zhang .suite = { 55398b805b97STianjia Zhang .akcipher = __VECS(sm2_tv_template) 55408b805b97STianjia Zhang } 55418b805b97STianjia Zhang }, { 5542b7e27530SGilad Ben-Yossef .alg = "sm3", 5543b7e27530SGilad Ben-Yossef .test = alg_test_hash, 5544b7e27530SGilad Ben-Yossef .suite = { 5545b7e27530SGilad Ben-Yossef .hash = __VECS(sm3_tv_template) 5546b7e27530SGilad Ben-Yossef } 5547b7e27530SGilad Ben-Yossef }, { 554825a0b9d4SVitaly Chikunov .alg = "streebog256", 554925a0b9d4SVitaly Chikunov .test = alg_test_hash, 555025a0b9d4SVitaly Chikunov .suite = { 555125a0b9d4SVitaly Chikunov .hash = __VECS(streebog256_tv_template) 555225a0b9d4SVitaly Chikunov } 555325a0b9d4SVitaly Chikunov }, { 555425a0b9d4SVitaly Chikunov .alg = "streebog512", 555525a0b9d4SVitaly Chikunov .test = alg_test_hash, 555625a0b9d4SVitaly Chikunov .suite = { 555725a0b9d4SVitaly Chikunov .hash = __VECS(streebog512_tv_template) 555825a0b9d4SVitaly Chikunov } 555925a0b9d4SVitaly Chikunov }, { 5560ed331adaSEric Biggers .alg = "vmac64(aes)", 5561ed331adaSEric Biggers .test = alg_test_hash, 5562ed331adaSEric Biggers .suite = { 5563ed331adaSEric Biggers .hash = __VECS(vmac64_aes_tv_template) 5564ed331adaSEric Biggers } 5565ed331adaSEric Biggers }, { 5566da7f033dSHerbert Xu .alg = "wp256", 5567da7f033dSHerbert Xu .test = alg_test_hash, 5568da7f033dSHerbert Xu .suite = { 556921c8e720SArd Biesheuvel .hash = __VECS(wp256_tv_template) 5570da7f033dSHerbert Xu } 5571da7f033dSHerbert Xu }, { 5572da7f033dSHerbert Xu .alg = "wp384", 5573da7f033dSHerbert Xu .test = alg_test_hash, 5574da7f033dSHerbert Xu .suite = { 557521c8e720SArd Biesheuvel .hash = __VECS(wp384_tv_template) 5576da7f033dSHerbert Xu } 5577da7f033dSHerbert Xu }, { 5578da7f033dSHerbert Xu .alg = "wp512", 5579da7f033dSHerbert Xu .test = alg_test_hash, 5580da7f033dSHerbert Xu .suite = { 558121c8e720SArd Biesheuvel .hash = __VECS(wp512_tv_template) 5582da7f033dSHerbert Xu } 5583da7f033dSHerbert Xu }, { 5584da7f033dSHerbert Xu .alg = "xcbc(aes)", 5585da7f033dSHerbert Xu .test = alg_test_hash, 5586da7f033dSHerbert Xu .suite = { 558721c8e720SArd Biesheuvel .hash = __VECS(aes_xcbc128_tv_template) 5588da7f033dSHerbert Xu } 5589da7f033dSHerbert Xu }, { 5590aa762409SEric Biggers .alg = "xchacha12", 5591aa762409SEric Biggers .test = alg_test_skcipher, 5592aa762409SEric Biggers .suite = { 5593aa762409SEric Biggers .cipher = __VECS(xchacha12_tv_template) 5594aa762409SEric Biggers }, 5595aa762409SEric Biggers }, { 5596de61d7aeSEric Biggers .alg = "xchacha20", 5597de61d7aeSEric Biggers .test = alg_test_skcipher, 5598de61d7aeSEric Biggers .suite = { 5599de61d7aeSEric Biggers .cipher = __VECS(xchacha20_tv_template) 5600de61d7aeSEric Biggers }, 5601de61d7aeSEric Biggers }, { 560217fee07aSNathan Huckleberry .alg = "xctr(aes)", 560317fee07aSNathan Huckleberry .test = alg_test_skcipher, 560417fee07aSNathan Huckleberry .suite = { 560517fee07aSNathan Huckleberry .cipher = __VECS(aes_xctr_tv_template) 560617fee07aSNathan Huckleberry } 560717fee07aSNathan Huckleberry }, { 5608da7f033dSHerbert Xu .alg = "xts(aes)", 5609d435e10eSEric Biggers .generic_driver = "xts(ecb(aes-generic))", 56101aa4ecd9SHerbert Xu .test = alg_test_skcipher, 56112918aa8dSJarod Wilson .fips_allowed = 1, 5612da7f033dSHerbert Xu .suite = { 561392a4c9feSEric Biggers .cipher = __VECS(aes_xts_tv_template) 5614da7f033dSHerbert Xu } 56150c01aed5SGeert Uytterhoeven }, { 56160840605eSJussi Kivilinna .alg = "xts(camellia)", 5617d435e10eSEric Biggers .generic_driver = "xts(ecb(camellia-generic))", 56180840605eSJussi Kivilinna .test = alg_test_skcipher, 56190840605eSJussi Kivilinna .suite = { 562092a4c9feSEric Biggers .cipher = __VECS(camellia_xts_tv_template) 56210840605eSJussi Kivilinna } 56220840605eSJussi Kivilinna }, { 56239b8b0405SJohannes Goetzfried .alg = "xts(cast6)", 5624d435e10eSEric Biggers .generic_driver = "xts(ecb(cast6-generic))", 56259b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 56269b8b0405SJohannes Goetzfried .suite = { 562792a4c9feSEric Biggers .cipher = __VECS(cast6_xts_tv_template) 56289b8b0405SJohannes Goetzfried } 56299b8b0405SJohannes Goetzfried }, { 563015f47ce5SGilad Ben-Yossef /* Same as xts(aes) except the key is stored in 563115f47ce5SGilad Ben-Yossef * hardware secure memory which we reference by index 563215f47ce5SGilad Ben-Yossef */ 563315f47ce5SGilad Ben-Yossef .alg = "xts(paes)", 563415f47ce5SGilad Ben-Yossef .test = alg_test_null, 563515f47ce5SGilad Ben-Yossef .fips_allowed = 1, 563615f47ce5SGilad Ben-Yossef }, { 563718be20b9SJussi Kivilinna .alg = "xts(serpent)", 5638d435e10eSEric Biggers .generic_driver = "xts(ecb(serpent-generic))", 563918be20b9SJussi Kivilinna .test = alg_test_skcipher, 564018be20b9SJussi Kivilinna .suite = { 564192a4c9feSEric Biggers .cipher = __VECS(serpent_xts_tv_template) 564218be20b9SJussi Kivilinna } 564318be20b9SJussi Kivilinna }, { 5644aed265b9SJussi Kivilinna .alg = "xts(twofish)", 5645d435e10eSEric Biggers .generic_driver = "xts(ecb(twofish-generic))", 5646aed265b9SJussi Kivilinna .test = alg_test_skcipher, 5647aed265b9SJussi Kivilinna .suite = { 564892a4c9feSEric Biggers .cipher = __VECS(tf_xts_tv_template) 5649aed265b9SJussi Kivilinna } 5650a368f43dSGiovanni Cabiddu }, { 5651c7ff8573SHarald Freudenberger #if IS_ENABLED(CONFIG_CRYPTO_PAES_S390) 5652c7ff8573SHarald Freudenberger .alg = "xts-paes-s390", 5653c7ff8573SHarald Freudenberger .fips_allowed = 1, 5654c7ff8573SHarald Freudenberger .test = alg_test_skcipher, 5655c7ff8573SHarald Freudenberger .suite = { 5656c7ff8573SHarald Freudenberger .cipher = __VECS(aes_xts_tv_template) 5657c7ff8573SHarald Freudenberger } 5658c7ff8573SHarald Freudenberger }, { 5659c7ff8573SHarald Freudenberger #endif 566015f47ce5SGilad Ben-Yossef .alg = "xts4096(paes)", 566115f47ce5SGilad Ben-Yossef .test = alg_test_null, 566215f47ce5SGilad Ben-Yossef .fips_allowed = 1, 566315f47ce5SGilad Ben-Yossef }, { 566415f47ce5SGilad Ben-Yossef .alg = "xts512(paes)", 566515f47ce5SGilad Ben-Yossef .test = alg_test_null, 566615f47ce5SGilad Ben-Yossef .fips_allowed = 1, 566715f47ce5SGilad Ben-Yossef }, { 566867882e76SNikolay Borisov .alg = "xxhash64", 566967882e76SNikolay Borisov .test = alg_test_hash, 567067882e76SNikolay Borisov .fips_allowed = 1, 567167882e76SNikolay Borisov .suite = { 567267882e76SNikolay Borisov .hash = __VECS(xxhash64_tv_template) 567367882e76SNikolay Borisov } 567467882e76SNikolay Borisov }, { 5675a368f43dSGiovanni Cabiddu .alg = "zlib-deflate", 5676a368f43dSGiovanni Cabiddu .test = alg_test_comp, 5677a368f43dSGiovanni Cabiddu .fips_allowed = 1, 5678a368f43dSGiovanni Cabiddu .suite = { 5679a368f43dSGiovanni Cabiddu .comp = { 5680a368f43dSGiovanni Cabiddu .comp = __VECS(zlib_deflate_comp_tv_template), 5681a368f43dSGiovanni Cabiddu .decomp = __VECS(zlib_deflate_decomp_tv_template) 5682a368f43dSGiovanni Cabiddu } 5683a368f43dSGiovanni Cabiddu } 5684d28fc3dbSNick Terrell }, { 5685d28fc3dbSNick Terrell .alg = "zstd", 5686d28fc3dbSNick Terrell .test = alg_test_comp, 5687d28fc3dbSNick Terrell .fips_allowed = 1, 5688d28fc3dbSNick Terrell .suite = { 5689d28fc3dbSNick Terrell .comp = { 5690d28fc3dbSNick Terrell .comp = __VECS(zstd_comp_tv_template), 5691d28fc3dbSNick Terrell .decomp = __VECS(zstd_decomp_tv_template) 5692d28fc3dbSNick Terrell } 5693d28fc3dbSNick Terrell } 5694da7f033dSHerbert Xu } 5695da7f033dSHerbert Xu }; 5696da7f033dSHerbert Xu 56973f47a03dSEric Biggers static void alg_check_test_descs_order(void) 56985714758bSJussi Kivilinna { 56995714758bSJussi Kivilinna int i; 57005714758bSJussi Kivilinna 57015714758bSJussi Kivilinna for (i = 1; i < ARRAY_SIZE(alg_test_descs); i++) { 57025714758bSJussi Kivilinna int diff = strcmp(alg_test_descs[i - 1].alg, 57035714758bSJussi Kivilinna alg_test_descs[i].alg); 57045714758bSJussi Kivilinna 57055714758bSJussi Kivilinna if (WARN_ON(diff > 0)) { 57065714758bSJussi Kivilinna pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n", 57075714758bSJussi Kivilinna alg_test_descs[i - 1].alg, 57085714758bSJussi Kivilinna alg_test_descs[i].alg); 57095714758bSJussi Kivilinna } 57105714758bSJussi Kivilinna 57115714758bSJussi Kivilinna if (WARN_ON(diff == 0)) { 57125714758bSJussi Kivilinna pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n", 57135714758bSJussi Kivilinna alg_test_descs[i].alg); 57145714758bSJussi Kivilinna } 57155714758bSJussi Kivilinna } 57165714758bSJussi Kivilinna } 57175714758bSJussi Kivilinna 57183f47a03dSEric Biggers static void alg_check_testvec_configs(void) 57193f47a03dSEric Biggers { 57204e7babbaSEric Biggers int i; 57214e7babbaSEric Biggers 57224e7babbaSEric Biggers for (i = 0; i < ARRAY_SIZE(default_cipher_testvec_configs); i++) 57234e7babbaSEric Biggers WARN_ON(!valid_testvec_config( 57244e7babbaSEric Biggers &default_cipher_testvec_configs[i])); 57254cc2dcf9SEric Biggers 57264cc2dcf9SEric Biggers for (i = 0; i < ARRAY_SIZE(default_hash_testvec_configs); i++) 57274cc2dcf9SEric Biggers WARN_ON(!valid_testvec_config( 57284cc2dcf9SEric Biggers &default_hash_testvec_configs[i])); 57293f47a03dSEric Biggers } 57303f47a03dSEric Biggers 57313f47a03dSEric Biggers static void testmgr_onetime_init(void) 57323f47a03dSEric Biggers { 57333f47a03dSEric Biggers alg_check_test_descs_order(); 57343f47a03dSEric Biggers alg_check_testvec_configs(); 57355b2706a4SEric Biggers 57365b2706a4SEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 57375b2706a4SEric Biggers pr_warn("alg: extra crypto tests enabled. This is intended for developer use only.\n"); 57385b2706a4SEric Biggers #endif 57393f47a03dSEric Biggers } 57403f47a03dSEric Biggers 57411aa4ecd9SHerbert Xu static int alg_find_test(const char *alg) 5742da7f033dSHerbert Xu { 5743da7f033dSHerbert Xu int start = 0; 5744da7f033dSHerbert Xu int end = ARRAY_SIZE(alg_test_descs); 5745da7f033dSHerbert Xu 5746da7f033dSHerbert Xu while (start < end) { 5747da7f033dSHerbert Xu int i = (start + end) / 2; 5748da7f033dSHerbert Xu int diff = strcmp(alg_test_descs[i].alg, alg); 5749da7f033dSHerbert Xu 5750da7f033dSHerbert Xu if (diff > 0) { 5751da7f033dSHerbert Xu end = i; 5752da7f033dSHerbert Xu continue; 5753da7f033dSHerbert Xu } 5754da7f033dSHerbert Xu 5755da7f033dSHerbert Xu if (diff < 0) { 5756da7f033dSHerbert Xu start = i + 1; 5757da7f033dSHerbert Xu continue; 5758da7f033dSHerbert Xu } 5759da7f033dSHerbert Xu 57601aa4ecd9SHerbert Xu return i; 5761da7f033dSHerbert Xu } 5762da7f033dSHerbert Xu 57631aa4ecd9SHerbert Xu return -1; 57641aa4ecd9SHerbert Xu } 57651aa4ecd9SHerbert Xu 5766d6097b8dSNicolai Stange static int alg_fips_disabled(const char *driver, const char *alg) 5767d6097b8dSNicolai Stange { 5768d6097b8dSNicolai Stange pr_info("alg: %s (%s) is disabled due to FIPS\n", alg, driver); 5769d6097b8dSNicolai Stange 5770d6097b8dSNicolai Stange return -ECANCELED; 5771d6097b8dSNicolai Stange } 5772d6097b8dSNicolai Stange 57731aa4ecd9SHerbert Xu int alg_test(const char *driver, const char *alg, u32 type, u32 mask) 57741aa4ecd9SHerbert Xu { 57751aa4ecd9SHerbert Xu int i; 5776a68f6610SHerbert Xu int j; 5777d12d6b6dSNeil Horman int rc; 57781aa4ecd9SHerbert Xu 57799e5c9fe4SRichard W.M. Jones if (!fips_enabled && notests) { 57809e5c9fe4SRichard W.M. Jones printk_once(KERN_INFO "alg: self-tests disabled\n"); 57819e5c9fe4SRichard W.M. Jones return 0; 57829e5c9fe4SRichard W.M. Jones } 57839e5c9fe4SRichard W.M. Jones 57843f47a03dSEric Biggers DO_ONCE(testmgr_onetime_init); 57855714758bSJussi Kivilinna 57861aa4ecd9SHerbert Xu if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) { 57871aa4ecd9SHerbert Xu char nalg[CRYPTO_MAX_ALG_NAME]; 57881aa4ecd9SHerbert Xu 57891aa4ecd9SHerbert Xu if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >= 57901aa4ecd9SHerbert Xu sizeof(nalg)) 57911aa4ecd9SHerbert Xu return -ENAMETOOLONG; 57921aa4ecd9SHerbert Xu 57931aa4ecd9SHerbert Xu i = alg_find_test(nalg); 57941aa4ecd9SHerbert Xu if (i < 0) 57951aa4ecd9SHerbert Xu goto notest; 57961aa4ecd9SHerbert Xu 5797a3bef3a3SJarod Wilson if (fips_enabled && !alg_test_descs[i].fips_allowed) 5798a3bef3a3SJarod Wilson goto non_fips_alg; 5799a3bef3a3SJarod Wilson 5800941fb328SJarod Wilson rc = alg_test_cipher(alg_test_descs + i, driver, type, mask); 5801941fb328SJarod Wilson goto test_done; 58021aa4ecd9SHerbert Xu } 58031aa4ecd9SHerbert Xu 58041aa4ecd9SHerbert Xu i = alg_find_test(alg); 5805a68f6610SHerbert Xu j = alg_find_test(driver); 5806a68f6610SHerbert Xu if (i < 0 && j < 0) 58071aa4ecd9SHerbert Xu goto notest; 58081aa4ecd9SHerbert Xu 5809d6097b8dSNicolai Stange if (fips_enabled) { 5810d6097b8dSNicolai Stange if (j >= 0 && !alg_test_descs[j].fips_allowed) 5811d6097b8dSNicolai Stange return -EINVAL; 5812d6097b8dSNicolai Stange 5813d6097b8dSNicolai Stange if (i >= 0 && !alg_test_descs[i].fips_allowed) 5814a3bef3a3SJarod Wilson goto non_fips_alg; 5815d6097b8dSNicolai Stange } 5816a3bef3a3SJarod Wilson 5817a68f6610SHerbert Xu rc = 0; 5818a68f6610SHerbert Xu if (i >= 0) 5819a68f6610SHerbert Xu rc |= alg_test_descs[i].test(alg_test_descs + i, driver, 58201aa4ecd9SHerbert Xu type, mask); 5821032c8cacSCristian Stoica if (j >= 0 && j != i) 5822a68f6610SHerbert Xu rc |= alg_test_descs[j].test(alg_test_descs + j, driver, 5823a68f6610SHerbert Xu type, mask); 5824a68f6610SHerbert Xu 5825941fb328SJarod Wilson test_done: 582609a5ef96SEric Biggers if (rc) { 582709a5ef96SEric Biggers if (fips_enabled || panic_on_fail) { 58289552389cSGilad Ben-Yossef fips_fail_notify(); 5829eda69b0cSEric Biggers panic("alg: self-tests for %s (%s) failed in %s mode!\n", 583009a5ef96SEric Biggers driver, alg, 583109a5ef96SEric Biggers fips_enabled ? "fips" : "panic_on_fail"); 58329552389cSGilad Ben-Yossef } 5833a76bd86aSRobert Elliott pr_warn("alg: self-tests for %s using %s failed (rc=%d)", 5834a76bd86aSRobert Elliott alg, driver, rc); 5835a76bd86aSRobert Elliott WARN(rc != -ENOENT, 5836a76bd86aSRobert Elliott "alg: self-tests for %s using %s failed (rc=%d)", 5837a76bd86aSRobert Elliott alg, driver, rc); 583809a5ef96SEric Biggers } else { 583909a5ef96SEric Biggers if (fips_enabled) 584009a5ef96SEric Biggers pr_info("alg: self-tests for %s (%s) passed\n", 584109a5ef96SEric Biggers driver, alg); 584209a5ef96SEric Biggers } 584329ecd4abSJarod Wilson 5844d12d6b6dSNeil Horman return rc; 58451aa4ecd9SHerbert Xu 58461aa4ecd9SHerbert Xu notest: 5847da7f033dSHerbert Xu printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver); 5848d6097b8dSNicolai Stange 5849d6097b8dSNicolai Stange if (type & CRYPTO_ALG_FIPS_INTERNAL) 5850d6097b8dSNicolai Stange return alg_fips_disabled(driver, alg); 5851d6097b8dSNicolai Stange 5852da7f033dSHerbert Xu return 0; 5853a3bef3a3SJarod Wilson non_fips_alg: 5854d6097b8dSNicolai Stange return alg_fips_disabled(driver, alg); 5855da7f033dSHerbert Xu } 58560b767f96SAlexander Shishkin 5857326a6346SHerbert Xu #endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */ 58580b767f96SAlexander Shishkin 5859da7f033dSHerbert Xu EXPORT_SYMBOL_GPL(alg_test); 5860