1da7f033dSHerbert Xu /* 2da7f033dSHerbert Xu * Algorithm testing framework and tests. 3da7f033dSHerbert Xu * 4da7f033dSHerbert Xu * Copyright (c) 2002 James Morris <jmorris@intercode.com.au> 5da7f033dSHerbert Xu * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org> 6da7f033dSHerbert Xu * Copyright (c) 2007 Nokia Siemens Networks 7da7f033dSHerbert Xu * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au> 83f47a03dSEric Biggers * Copyright (c) 2019 Google LLC 9da7f033dSHerbert Xu * 1069435b94SAdrian Hoban * Updated RFC4106 AES-GCM testing. 1169435b94SAdrian Hoban * Authors: Aidan O'Mahony (aidan.o.mahony@intel.com) 1269435b94SAdrian Hoban * Adrian Hoban <adrian.hoban@intel.com> 1369435b94SAdrian Hoban * Gabriele Paoloni <gabriele.paoloni@intel.com> 1469435b94SAdrian Hoban * Tadeusz Struk (tadeusz.struk@intel.com) 1569435b94SAdrian Hoban * Copyright (c) 2010, Intel Corporation. 1669435b94SAdrian Hoban * 17da7f033dSHerbert Xu * This program is free software; you can redistribute it and/or modify it 18da7f033dSHerbert Xu * under the terms of the GNU General Public License as published by the Free 19da7f033dSHerbert Xu * Software Foundation; either version 2 of the License, or (at your option) 20da7f033dSHerbert Xu * any later version. 21da7f033dSHerbert Xu * 22da7f033dSHerbert Xu */ 23da7f033dSHerbert Xu 241ce33115SHerbert Xu #include <crypto/aead.h> 25da7f033dSHerbert Xu #include <crypto/hash.h> 2612773d93SHerbert Xu #include <crypto/skcipher.h> 27da7f033dSHerbert Xu #include <linux/err.h> 281c41b882SHerbert Xu #include <linux/fips.h> 29da7f033dSHerbert Xu #include <linux/module.h> 303f47a03dSEric Biggers #include <linux/once.h> 3125f9dddbSEric Biggers #include <linux/random.h> 32da7f033dSHerbert Xu #include <linux/scatterlist.h> 33da7f033dSHerbert Xu #include <linux/slab.h> 34da7f033dSHerbert Xu #include <linux/string.h> 357647d6ceSJarod Wilson #include <crypto/rng.h> 3664d1cdfbSStephan Mueller #include <crypto/drbg.h> 37946cc463STadeusz Struk #include <crypto/akcipher.h> 38802c7f1cSSalvatore Benedetto #include <crypto/kpp.h> 39d7db7a88SGiovanni Cabiddu #include <crypto/acompress.h> 40b55e1a39SEric Biggers #include <crypto/internal/simd.h> 41da7f033dSHerbert Xu 42da7f033dSHerbert Xu #include "internal.h" 430b767f96SAlexander Shishkin 449e5c9fe4SRichard W.M. Jones static bool notests; 459e5c9fe4SRichard W.M. Jones module_param(notests, bool, 0644); 469e5c9fe4SRichard W.M. Jones MODULE_PARM_DESC(notests, "disable crypto self-tests"); 479e5c9fe4SRichard W.M. Jones 48eda69b0cSEric Biggers static bool panic_on_fail; 49eda69b0cSEric Biggers module_param(panic_on_fail, bool, 0444); 50eda69b0cSEric Biggers 515b2706a4SEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 525b2706a4SEric Biggers static bool noextratests; 535b2706a4SEric Biggers module_param(noextratests, bool, 0644); 545b2706a4SEric Biggers MODULE_PARM_DESC(noextratests, "disable expensive crypto self-tests"); 555b2706a4SEric Biggers 565b2706a4SEric Biggers static unsigned int fuzz_iterations = 100; 575b2706a4SEric Biggers module_param(fuzz_iterations, uint, 0644); 585b2706a4SEric Biggers MODULE_PARM_DESC(fuzz_iterations, "number of fuzz test iterations"); 59b55e1a39SEric Biggers 60b55e1a39SEric Biggers DEFINE_PER_CPU(bool, crypto_simd_disabled_for_test); 61b55e1a39SEric Biggers EXPORT_PER_CPU_SYMBOL_GPL(crypto_simd_disabled_for_test); 625b2706a4SEric Biggers #endif 635b2706a4SEric Biggers 64326a6346SHerbert Xu #ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS 650b767f96SAlexander Shishkin 660b767f96SAlexander Shishkin /* a perfect nop */ 670b767f96SAlexander Shishkin int alg_test(const char *driver, const char *alg, u32 type, u32 mask) 680b767f96SAlexander Shishkin { 690b767f96SAlexander Shishkin return 0; 700b767f96SAlexander Shishkin } 710b767f96SAlexander Shishkin 720b767f96SAlexander Shishkin #else 730b767f96SAlexander Shishkin 74da7f033dSHerbert Xu #include "testmgr.h" 75da7f033dSHerbert Xu 76da7f033dSHerbert Xu /* 77da7f033dSHerbert Xu * Need slab memory for testing (size in number of pages). 78da7f033dSHerbert Xu */ 79da7f033dSHerbert Xu #define XBUFSIZE 8 80da7f033dSHerbert Xu 81da7f033dSHerbert Xu /* 82da7f033dSHerbert Xu * Used by test_cipher() 83da7f033dSHerbert Xu */ 84da7f033dSHerbert Xu #define ENCRYPT 1 85da7f033dSHerbert Xu #define DECRYPT 0 86da7f033dSHerbert Xu 87da7f033dSHerbert Xu struct aead_test_suite { 88b13b1e0cSEric Biggers const struct aead_testvec *vecs; 89da7f033dSHerbert Xu unsigned int count; 90da7f033dSHerbert Xu }; 91da7f033dSHerbert Xu 92da7f033dSHerbert Xu struct cipher_test_suite { 93b13b1e0cSEric Biggers const struct cipher_testvec *vecs; 94da7f033dSHerbert Xu unsigned int count; 95da7f033dSHerbert Xu }; 96da7f033dSHerbert Xu 97da7f033dSHerbert Xu struct comp_test_suite { 98da7f033dSHerbert Xu struct { 99b13b1e0cSEric Biggers const struct comp_testvec *vecs; 100da7f033dSHerbert Xu unsigned int count; 101da7f033dSHerbert Xu } comp, decomp; 102da7f033dSHerbert Xu }; 103da7f033dSHerbert Xu 104da7f033dSHerbert Xu struct hash_test_suite { 105b13b1e0cSEric Biggers const struct hash_testvec *vecs; 106da7f033dSHerbert Xu unsigned int count; 107da7f033dSHerbert Xu }; 108da7f033dSHerbert Xu 1097647d6ceSJarod Wilson struct cprng_test_suite { 110b13b1e0cSEric Biggers const struct cprng_testvec *vecs; 1117647d6ceSJarod Wilson unsigned int count; 1127647d6ceSJarod Wilson }; 1137647d6ceSJarod Wilson 11464d1cdfbSStephan Mueller struct drbg_test_suite { 115b13b1e0cSEric Biggers const struct drbg_testvec *vecs; 11664d1cdfbSStephan Mueller unsigned int count; 11764d1cdfbSStephan Mueller }; 11864d1cdfbSStephan Mueller 119946cc463STadeusz Struk struct akcipher_test_suite { 120b13b1e0cSEric Biggers const struct akcipher_testvec *vecs; 121946cc463STadeusz Struk unsigned int count; 122946cc463STadeusz Struk }; 123946cc463STadeusz Struk 124802c7f1cSSalvatore Benedetto struct kpp_test_suite { 125b13b1e0cSEric Biggers const struct kpp_testvec *vecs; 126802c7f1cSSalvatore Benedetto unsigned int count; 127802c7f1cSSalvatore Benedetto }; 128802c7f1cSSalvatore Benedetto 129da7f033dSHerbert Xu struct alg_test_desc { 130da7f033dSHerbert Xu const char *alg; 131f2bb770aSEric Biggers const char *generic_driver; 132da7f033dSHerbert Xu int (*test)(const struct alg_test_desc *desc, const char *driver, 133da7f033dSHerbert Xu u32 type, u32 mask); 134a1915d51SJarod Wilson int fips_allowed; /* set if alg is allowed in fips mode */ 135da7f033dSHerbert Xu 136da7f033dSHerbert Xu union { 137da7f033dSHerbert Xu struct aead_test_suite aead; 138da7f033dSHerbert Xu struct cipher_test_suite cipher; 139da7f033dSHerbert Xu struct comp_test_suite comp; 140da7f033dSHerbert Xu struct hash_test_suite hash; 1417647d6ceSJarod Wilson struct cprng_test_suite cprng; 14264d1cdfbSStephan Mueller struct drbg_test_suite drbg; 143946cc463STadeusz Struk struct akcipher_test_suite akcipher; 144802c7f1cSSalvatore Benedetto struct kpp_test_suite kpp; 145da7f033dSHerbert Xu } suite; 146da7f033dSHerbert Xu }; 147da7f033dSHerbert Xu 148da7f033dSHerbert Xu static void hexdump(unsigned char *buf, unsigned int len) 149da7f033dSHerbert Xu { 150da7f033dSHerbert Xu print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET, 151da7f033dSHerbert Xu 16, 1, 152da7f033dSHerbert Xu buf, len, false); 153da7f033dSHerbert Xu } 154da7f033dSHerbert Xu 1553f47a03dSEric Biggers static int __testmgr_alloc_buf(char *buf[XBUFSIZE], int order) 156f8b0d4d0SHerbert Xu { 157f8b0d4d0SHerbert Xu int i; 158f8b0d4d0SHerbert Xu 159f8b0d4d0SHerbert Xu for (i = 0; i < XBUFSIZE; i++) { 1603f47a03dSEric Biggers buf[i] = (char *)__get_free_pages(GFP_KERNEL, order); 161f8b0d4d0SHerbert Xu if (!buf[i]) 162f8b0d4d0SHerbert Xu goto err_free_buf; 163f8b0d4d0SHerbert Xu } 164f8b0d4d0SHerbert Xu 165f8b0d4d0SHerbert Xu return 0; 166f8b0d4d0SHerbert Xu 167f8b0d4d0SHerbert Xu err_free_buf: 168f8b0d4d0SHerbert Xu while (i-- > 0) 1693f47a03dSEric Biggers free_pages((unsigned long)buf[i], order); 170f8b0d4d0SHerbert Xu 171f8b0d4d0SHerbert Xu return -ENOMEM; 172f8b0d4d0SHerbert Xu } 173f8b0d4d0SHerbert Xu 1743f47a03dSEric Biggers static int testmgr_alloc_buf(char *buf[XBUFSIZE]) 1753f47a03dSEric Biggers { 1763f47a03dSEric Biggers return __testmgr_alloc_buf(buf, 0); 1773f47a03dSEric Biggers } 1783f47a03dSEric Biggers 1793f47a03dSEric Biggers static void __testmgr_free_buf(char *buf[XBUFSIZE], int order) 180f8b0d4d0SHerbert Xu { 181f8b0d4d0SHerbert Xu int i; 182f8b0d4d0SHerbert Xu 183f8b0d4d0SHerbert Xu for (i = 0; i < XBUFSIZE; i++) 1843f47a03dSEric Biggers free_pages((unsigned long)buf[i], order); 1853f47a03dSEric Biggers } 1863f47a03dSEric Biggers 1873f47a03dSEric Biggers static void testmgr_free_buf(char *buf[XBUFSIZE]) 1883f47a03dSEric Biggers { 1893f47a03dSEric Biggers __testmgr_free_buf(buf, 0); 1903f47a03dSEric Biggers } 1913f47a03dSEric Biggers 1923f47a03dSEric Biggers #define TESTMGR_POISON_BYTE 0xfe 1933f47a03dSEric Biggers #define TESTMGR_POISON_LEN 16 1943f47a03dSEric Biggers 1953f47a03dSEric Biggers static inline void testmgr_poison(void *addr, size_t len) 1963f47a03dSEric Biggers { 1973f47a03dSEric Biggers memset(addr, TESTMGR_POISON_BYTE, len); 1983f47a03dSEric Biggers } 1993f47a03dSEric Biggers 2003f47a03dSEric Biggers /* Is the memory region still fully poisoned? */ 2013f47a03dSEric Biggers static inline bool testmgr_is_poison(const void *addr, size_t len) 2023f47a03dSEric Biggers { 2033f47a03dSEric Biggers return memchr_inv(addr, TESTMGR_POISON_BYTE, len) == NULL; 2043f47a03dSEric Biggers } 2053f47a03dSEric Biggers 2063f47a03dSEric Biggers /* flush type for hash algorithms */ 2073f47a03dSEric Biggers enum flush_type { 2083f47a03dSEric Biggers /* merge with update of previous buffer(s) */ 2093f47a03dSEric Biggers FLUSH_TYPE_NONE = 0, 2103f47a03dSEric Biggers 2113f47a03dSEric Biggers /* update with previous buffer(s) before doing this one */ 2123f47a03dSEric Biggers FLUSH_TYPE_FLUSH, 2133f47a03dSEric Biggers 2143f47a03dSEric Biggers /* likewise, but also export and re-import the intermediate state */ 2153f47a03dSEric Biggers FLUSH_TYPE_REIMPORT, 2163f47a03dSEric Biggers }; 2173f47a03dSEric Biggers 2183f47a03dSEric Biggers /* finalization function for hash algorithms */ 2193f47a03dSEric Biggers enum finalization_type { 2203f47a03dSEric Biggers FINALIZATION_TYPE_FINAL, /* use final() */ 2213f47a03dSEric Biggers FINALIZATION_TYPE_FINUP, /* use finup() */ 2223f47a03dSEric Biggers FINALIZATION_TYPE_DIGEST, /* use digest() */ 2233f47a03dSEric Biggers }; 2243f47a03dSEric Biggers 2253f47a03dSEric Biggers #define TEST_SG_TOTAL 10000 2263f47a03dSEric Biggers 2273f47a03dSEric Biggers /** 2283f47a03dSEric Biggers * struct test_sg_division - description of a scatterlist entry 2293f47a03dSEric Biggers * 2303f47a03dSEric Biggers * This struct describes one entry of a scatterlist being constructed to check a 2313f47a03dSEric Biggers * crypto test vector. 2323f47a03dSEric Biggers * 2333f47a03dSEric Biggers * @proportion_of_total: length of this chunk relative to the total length, 2343f47a03dSEric Biggers * given as a proportion out of TEST_SG_TOTAL so that it 2353f47a03dSEric Biggers * scales to fit any test vector 2363f47a03dSEric Biggers * @offset: byte offset into a 2-page buffer at which this chunk will start 2373f47a03dSEric Biggers * @offset_relative_to_alignmask: if true, add the algorithm's alignmask to the 2383f47a03dSEric Biggers * @offset 2393f47a03dSEric Biggers * @flush_type: for hashes, whether an update() should be done now vs. 2403f47a03dSEric Biggers * continuing to accumulate data 2416570737cSEric Biggers * @nosimd: if doing the pending update(), do it with SIMD disabled? 2423f47a03dSEric Biggers */ 2433f47a03dSEric Biggers struct test_sg_division { 2443f47a03dSEric Biggers unsigned int proportion_of_total; 2453f47a03dSEric Biggers unsigned int offset; 2463f47a03dSEric Biggers bool offset_relative_to_alignmask; 2473f47a03dSEric Biggers enum flush_type flush_type; 2486570737cSEric Biggers bool nosimd; 2493f47a03dSEric Biggers }; 2503f47a03dSEric Biggers 2513f47a03dSEric Biggers /** 2523f47a03dSEric Biggers * struct testvec_config - configuration for testing a crypto test vector 2533f47a03dSEric Biggers * 2543f47a03dSEric Biggers * This struct describes the data layout and other parameters with which each 2553f47a03dSEric Biggers * crypto test vector can be tested. 2563f47a03dSEric Biggers * 2573f47a03dSEric Biggers * @name: name of this config, logged for debugging purposes if a test fails 2583f47a03dSEric Biggers * @inplace: operate on the data in-place, if applicable for the algorithm type? 2593f47a03dSEric Biggers * @req_flags: extra request_flags, e.g. CRYPTO_TFM_REQ_MAY_SLEEP 2603f47a03dSEric Biggers * @src_divs: description of how to arrange the source scatterlist 2613f47a03dSEric Biggers * @dst_divs: description of how to arrange the dst scatterlist, if applicable 2623f47a03dSEric Biggers * for the algorithm type. Defaults to @src_divs if unset. 2633f47a03dSEric Biggers * @iv_offset: misalignment of the IV in the range [0..MAX_ALGAPI_ALIGNMASK+1], 2643f47a03dSEric Biggers * where 0 is aligned to a 2*(MAX_ALGAPI_ALIGNMASK+1) byte boundary 2653f47a03dSEric Biggers * @iv_offset_relative_to_alignmask: if true, add the algorithm's alignmask to 2663f47a03dSEric Biggers * the @iv_offset 2673f47a03dSEric Biggers * @finalization_type: what finalization function to use for hashes 2686570737cSEric Biggers * @nosimd: execute with SIMD disabled? Requires !CRYPTO_TFM_REQ_MAY_SLEEP. 2693f47a03dSEric Biggers */ 2703f47a03dSEric Biggers struct testvec_config { 2713f47a03dSEric Biggers const char *name; 2723f47a03dSEric Biggers bool inplace; 2733f47a03dSEric Biggers u32 req_flags; 2743f47a03dSEric Biggers struct test_sg_division src_divs[XBUFSIZE]; 2753f47a03dSEric Biggers struct test_sg_division dst_divs[XBUFSIZE]; 2763f47a03dSEric Biggers unsigned int iv_offset; 2773f47a03dSEric Biggers bool iv_offset_relative_to_alignmask; 2783f47a03dSEric Biggers enum finalization_type finalization_type; 2796570737cSEric Biggers bool nosimd; 2803f47a03dSEric Biggers }; 2813f47a03dSEric Biggers 2823f47a03dSEric Biggers #define TESTVEC_CONFIG_NAMELEN 192 2833f47a03dSEric Biggers 2844e7babbaSEric Biggers /* 2854e7babbaSEric Biggers * The following are the lists of testvec_configs to test for each algorithm 2864e7babbaSEric Biggers * type when the basic crypto self-tests are enabled, i.e. when 2874e7babbaSEric Biggers * CONFIG_CRYPTO_MANAGER_DISABLE_TESTS is unset. They aim to provide good test 2884e7babbaSEric Biggers * coverage, while keeping the test time much shorter than the full fuzz tests 2894e7babbaSEric Biggers * so that the basic tests can be enabled in a wider range of circumstances. 2904e7babbaSEric Biggers */ 2914e7babbaSEric Biggers 2924e7babbaSEric Biggers /* Configs for skciphers and aeads */ 2934e7babbaSEric Biggers static const struct testvec_config default_cipher_testvec_configs[] = { 2944e7babbaSEric Biggers { 2954e7babbaSEric Biggers .name = "in-place", 2964e7babbaSEric Biggers .inplace = true, 2974e7babbaSEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 2984e7babbaSEric Biggers }, { 2994e7babbaSEric Biggers .name = "out-of-place", 3004e7babbaSEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 3014e7babbaSEric Biggers }, { 3024e7babbaSEric Biggers .name = "unaligned buffer, offset=1", 3034e7babbaSEric Biggers .src_divs = { { .proportion_of_total = 10000, .offset = 1 } }, 3044e7babbaSEric Biggers .iv_offset = 1, 3054e7babbaSEric Biggers }, { 3064e7babbaSEric Biggers .name = "buffer aligned only to alignmask", 3074e7babbaSEric Biggers .src_divs = { 3084e7babbaSEric Biggers { 3094e7babbaSEric Biggers .proportion_of_total = 10000, 3104e7babbaSEric Biggers .offset = 1, 3114e7babbaSEric Biggers .offset_relative_to_alignmask = true, 3124e7babbaSEric Biggers }, 3134e7babbaSEric Biggers }, 3144e7babbaSEric Biggers .iv_offset = 1, 3154e7babbaSEric Biggers .iv_offset_relative_to_alignmask = true, 3164e7babbaSEric Biggers }, { 3174e7babbaSEric Biggers .name = "two even aligned splits", 3184e7babbaSEric Biggers .src_divs = { 3194e7babbaSEric Biggers { .proportion_of_total = 5000 }, 3204e7babbaSEric Biggers { .proportion_of_total = 5000 }, 3214e7babbaSEric Biggers }, 3224e7babbaSEric Biggers }, { 3234e7babbaSEric Biggers .name = "uneven misaligned splits, may sleep", 3244e7babbaSEric Biggers .req_flags = CRYPTO_TFM_REQ_MAY_SLEEP, 3254e7babbaSEric Biggers .src_divs = { 3264e7babbaSEric Biggers { .proportion_of_total = 1900, .offset = 33 }, 3274e7babbaSEric Biggers { .proportion_of_total = 3300, .offset = 7 }, 3284e7babbaSEric Biggers { .proportion_of_total = 4800, .offset = 18 }, 3294e7babbaSEric Biggers }, 3304e7babbaSEric Biggers .iv_offset = 3, 3314e7babbaSEric Biggers }, { 3324e7babbaSEric Biggers .name = "misaligned splits crossing pages, inplace", 3334e7babbaSEric Biggers .inplace = true, 3344e7babbaSEric Biggers .src_divs = { 3354e7babbaSEric Biggers { 3364e7babbaSEric Biggers .proportion_of_total = 7500, 3374e7babbaSEric Biggers .offset = PAGE_SIZE - 32 3384e7babbaSEric Biggers }, { 3394e7babbaSEric Biggers .proportion_of_total = 2500, 3404e7babbaSEric Biggers .offset = PAGE_SIZE - 7 3414e7babbaSEric Biggers }, 3424e7babbaSEric Biggers }, 3434e7babbaSEric Biggers } 3444e7babbaSEric Biggers }; 3454e7babbaSEric Biggers 3464cc2dcf9SEric Biggers static const struct testvec_config default_hash_testvec_configs[] = { 3474cc2dcf9SEric Biggers { 3484cc2dcf9SEric Biggers .name = "init+update+final aligned buffer", 3494cc2dcf9SEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 3504cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINAL, 3514cc2dcf9SEric Biggers }, { 3524cc2dcf9SEric Biggers .name = "init+finup aligned buffer", 3534cc2dcf9SEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 3544cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINUP, 3554cc2dcf9SEric Biggers }, { 3564cc2dcf9SEric Biggers .name = "digest aligned buffer", 3574cc2dcf9SEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 3584cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_DIGEST, 3594cc2dcf9SEric Biggers }, { 3604cc2dcf9SEric Biggers .name = "init+update+final misaligned buffer", 3614cc2dcf9SEric Biggers .src_divs = { { .proportion_of_total = 10000, .offset = 1 } }, 3624cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINAL, 3634cc2dcf9SEric Biggers }, { 3644cc2dcf9SEric Biggers .name = "digest buffer aligned only to alignmask", 3654cc2dcf9SEric Biggers .src_divs = { 3664cc2dcf9SEric Biggers { 3674cc2dcf9SEric Biggers .proportion_of_total = 10000, 3684cc2dcf9SEric Biggers .offset = 1, 3694cc2dcf9SEric Biggers .offset_relative_to_alignmask = true, 3704cc2dcf9SEric Biggers }, 3714cc2dcf9SEric Biggers }, 3724cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_DIGEST, 3734cc2dcf9SEric Biggers }, { 3744cc2dcf9SEric Biggers .name = "init+update+update+final two even splits", 3754cc2dcf9SEric Biggers .src_divs = { 3764cc2dcf9SEric Biggers { .proportion_of_total = 5000 }, 3774cc2dcf9SEric Biggers { 3784cc2dcf9SEric Biggers .proportion_of_total = 5000, 3794cc2dcf9SEric Biggers .flush_type = FLUSH_TYPE_FLUSH, 3804cc2dcf9SEric Biggers }, 3814cc2dcf9SEric Biggers }, 3824cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINAL, 3834cc2dcf9SEric Biggers }, { 3844cc2dcf9SEric Biggers .name = "digest uneven misaligned splits, may sleep", 3854cc2dcf9SEric Biggers .req_flags = CRYPTO_TFM_REQ_MAY_SLEEP, 3864cc2dcf9SEric Biggers .src_divs = { 3874cc2dcf9SEric Biggers { .proportion_of_total = 1900, .offset = 33 }, 3884cc2dcf9SEric Biggers { .proportion_of_total = 3300, .offset = 7 }, 3894cc2dcf9SEric Biggers { .proportion_of_total = 4800, .offset = 18 }, 3904cc2dcf9SEric Biggers }, 3914cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_DIGEST, 3924cc2dcf9SEric Biggers }, { 3934cc2dcf9SEric Biggers .name = "digest misaligned splits crossing pages", 3944cc2dcf9SEric Biggers .src_divs = { 3954cc2dcf9SEric Biggers { 3964cc2dcf9SEric Biggers .proportion_of_total = 7500, 3974cc2dcf9SEric Biggers .offset = PAGE_SIZE - 32, 3984cc2dcf9SEric Biggers }, { 3994cc2dcf9SEric Biggers .proportion_of_total = 2500, 4004cc2dcf9SEric Biggers .offset = PAGE_SIZE - 7, 4014cc2dcf9SEric Biggers }, 4024cc2dcf9SEric Biggers }, 4034cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_DIGEST, 4044cc2dcf9SEric Biggers }, { 4054cc2dcf9SEric Biggers .name = "import/export", 4064cc2dcf9SEric Biggers .src_divs = { 4074cc2dcf9SEric Biggers { 4084cc2dcf9SEric Biggers .proportion_of_total = 6500, 4094cc2dcf9SEric Biggers .flush_type = FLUSH_TYPE_REIMPORT, 4104cc2dcf9SEric Biggers }, { 4114cc2dcf9SEric Biggers .proportion_of_total = 3500, 4124cc2dcf9SEric Biggers .flush_type = FLUSH_TYPE_REIMPORT, 4134cc2dcf9SEric Biggers }, 4144cc2dcf9SEric Biggers }, 4154cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINAL, 4164cc2dcf9SEric Biggers } 4174cc2dcf9SEric Biggers }; 4184cc2dcf9SEric Biggers 4193f47a03dSEric Biggers static unsigned int count_test_sg_divisions(const struct test_sg_division *divs) 4203f47a03dSEric Biggers { 4213f47a03dSEric Biggers unsigned int remaining = TEST_SG_TOTAL; 4223f47a03dSEric Biggers unsigned int ndivs = 0; 4233f47a03dSEric Biggers 4243f47a03dSEric Biggers do { 4253f47a03dSEric Biggers remaining -= divs[ndivs++].proportion_of_total; 4263f47a03dSEric Biggers } while (remaining); 4273f47a03dSEric Biggers 4283f47a03dSEric Biggers return ndivs; 4293f47a03dSEric Biggers } 4303f47a03dSEric Biggers 4316570737cSEric Biggers #define SGDIVS_HAVE_FLUSHES BIT(0) 4326570737cSEric Biggers #define SGDIVS_HAVE_NOSIMD BIT(1) 4336570737cSEric Biggers 4343f47a03dSEric Biggers static bool valid_sg_divisions(const struct test_sg_division *divs, 4356570737cSEric Biggers unsigned int count, int *flags_ret) 4363f47a03dSEric Biggers { 4373f47a03dSEric Biggers unsigned int total = 0; 4383f47a03dSEric Biggers unsigned int i; 4393f47a03dSEric Biggers 4403f47a03dSEric Biggers for (i = 0; i < count && total != TEST_SG_TOTAL; i++) { 4413f47a03dSEric Biggers if (divs[i].proportion_of_total <= 0 || 4423f47a03dSEric Biggers divs[i].proportion_of_total > TEST_SG_TOTAL - total) 4433f47a03dSEric Biggers return false; 4443f47a03dSEric Biggers total += divs[i].proportion_of_total; 4453f47a03dSEric Biggers if (divs[i].flush_type != FLUSH_TYPE_NONE) 4466570737cSEric Biggers *flags_ret |= SGDIVS_HAVE_FLUSHES; 4476570737cSEric Biggers if (divs[i].nosimd) 4486570737cSEric Biggers *flags_ret |= SGDIVS_HAVE_NOSIMD; 4493f47a03dSEric Biggers } 4503f47a03dSEric Biggers return total == TEST_SG_TOTAL && 4513f47a03dSEric Biggers memchr_inv(&divs[i], 0, (count - i) * sizeof(divs[0])) == NULL; 4523f47a03dSEric Biggers } 4533f47a03dSEric Biggers 4543f47a03dSEric Biggers /* 4553f47a03dSEric Biggers * Check whether the given testvec_config is valid. This isn't strictly needed 4563f47a03dSEric Biggers * since every testvec_config should be valid, but check anyway so that people 4573f47a03dSEric Biggers * don't unknowingly add broken configs that don't do what they wanted. 4583f47a03dSEric Biggers */ 4593f47a03dSEric Biggers static bool valid_testvec_config(const struct testvec_config *cfg) 4603f47a03dSEric Biggers { 4616570737cSEric Biggers int flags = 0; 4623f47a03dSEric Biggers 4633f47a03dSEric Biggers if (cfg->name == NULL) 4643f47a03dSEric Biggers return false; 4653f47a03dSEric Biggers 4663f47a03dSEric Biggers if (!valid_sg_divisions(cfg->src_divs, ARRAY_SIZE(cfg->src_divs), 4676570737cSEric Biggers &flags)) 4683f47a03dSEric Biggers return false; 4693f47a03dSEric Biggers 4703f47a03dSEric Biggers if (cfg->dst_divs[0].proportion_of_total) { 4713f47a03dSEric Biggers if (!valid_sg_divisions(cfg->dst_divs, 4726570737cSEric Biggers ARRAY_SIZE(cfg->dst_divs), &flags)) 4733f47a03dSEric Biggers return false; 4743f47a03dSEric Biggers } else { 4753f47a03dSEric Biggers if (memchr_inv(cfg->dst_divs, 0, sizeof(cfg->dst_divs))) 4763f47a03dSEric Biggers return false; 4773f47a03dSEric Biggers /* defaults to dst_divs=src_divs */ 4783f47a03dSEric Biggers } 4793f47a03dSEric Biggers 4803f47a03dSEric Biggers if (cfg->iv_offset + 4813f47a03dSEric Biggers (cfg->iv_offset_relative_to_alignmask ? MAX_ALGAPI_ALIGNMASK : 0) > 4823f47a03dSEric Biggers MAX_ALGAPI_ALIGNMASK + 1) 4833f47a03dSEric Biggers return false; 4843f47a03dSEric Biggers 4856570737cSEric Biggers if ((flags & (SGDIVS_HAVE_FLUSHES | SGDIVS_HAVE_NOSIMD)) && 4866570737cSEric Biggers cfg->finalization_type == FINALIZATION_TYPE_DIGEST) 4876570737cSEric Biggers return false; 4886570737cSEric Biggers 4896570737cSEric Biggers if ((cfg->nosimd || (flags & SGDIVS_HAVE_NOSIMD)) && 4906570737cSEric Biggers (cfg->req_flags & CRYPTO_TFM_REQ_MAY_SLEEP)) 4913f47a03dSEric Biggers return false; 4923f47a03dSEric Biggers 4933f47a03dSEric Biggers return true; 4943f47a03dSEric Biggers } 4953f47a03dSEric Biggers 4963f47a03dSEric Biggers struct test_sglist { 4973f47a03dSEric Biggers char *bufs[XBUFSIZE]; 4983f47a03dSEric Biggers struct scatterlist sgl[XBUFSIZE]; 4993f47a03dSEric Biggers struct scatterlist sgl_saved[XBUFSIZE]; 5003f47a03dSEric Biggers struct scatterlist *sgl_ptr; 5013f47a03dSEric Biggers unsigned int nents; 5023f47a03dSEric Biggers }; 5033f47a03dSEric Biggers 5043f47a03dSEric Biggers static int init_test_sglist(struct test_sglist *tsgl) 5053f47a03dSEric Biggers { 5063f47a03dSEric Biggers return __testmgr_alloc_buf(tsgl->bufs, 1 /* two pages per buffer */); 5073f47a03dSEric Biggers } 5083f47a03dSEric Biggers 5093f47a03dSEric Biggers static void destroy_test_sglist(struct test_sglist *tsgl) 5103f47a03dSEric Biggers { 5113f47a03dSEric Biggers return __testmgr_free_buf(tsgl->bufs, 1 /* two pages per buffer */); 5123f47a03dSEric Biggers } 5133f47a03dSEric Biggers 5143f47a03dSEric Biggers /** 5153f47a03dSEric Biggers * build_test_sglist() - build a scatterlist for a crypto test 5163f47a03dSEric Biggers * 5173f47a03dSEric Biggers * @tsgl: the scatterlist to build. @tsgl->bufs[] contains an array of 2-page 5183f47a03dSEric Biggers * buffers which the scatterlist @tsgl->sgl[] will be made to point into. 5193f47a03dSEric Biggers * @divs: the layout specification on which the scatterlist will be based 5203f47a03dSEric Biggers * @alignmask: the algorithm's alignmask 5213f47a03dSEric Biggers * @total_len: the total length of the scatterlist to build in bytes 5223f47a03dSEric Biggers * @data: if non-NULL, the buffers will be filled with this data until it ends. 5233f47a03dSEric Biggers * Otherwise the buffers will be poisoned. In both cases, some bytes 5243f47a03dSEric Biggers * past the end of each buffer will be poisoned to help detect overruns. 5253f47a03dSEric Biggers * @out_divs: if non-NULL, the test_sg_division to which each scatterlist entry 5263f47a03dSEric Biggers * corresponds will be returned here. This will match @divs except 5273f47a03dSEric Biggers * that divisions resolving to a length of 0 are omitted as they are 5283f47a03dSEric Biggers * not included in the scatterlist. 5293f47a03dSEric Biggers * 5303f47a03dSEric Biggers * Return: 0 or a -errno value 5313f47a03dSEric Biggers */ 5323f47a03dSEric Biggers static int build_test_sglist(struct test_sglist *tsgl, 5333f47a03dSEric Biggers const struct test_sg_division *divs, 5343f47a03dSEric Biggers const unsigned int alignmask, 5353f47a03dSEric Biggers const unsigned int total_len, 5363f47a03dSEric Biggers struct iov_iter *data, 5373f47a03dSEric Biggers const struct test_sg_division *out_divs[XBUFSIZE]) 5383f47a03dSEric Biggers { 5393f47a03dSEric Biggers struct { 5403f47a03dSEric Biggers const struct test_sg_division *div; 5413f47a03dSEric Biggers size_t length; 5423f47a03dSEric Biggers } partitions[XBUFSIZE]; 5433f47a03dSEric Biggers const unsigned int ndivs = count_test_sg_divisions(divs); 5443f47a03dSEric Biggers unsigned int len_remaining = total_len; 5453f47a03dSEric Biggers unsigned int i; 5463f47a03dSEric Biggers 5473f47a03dSEric Biggers BUILD_BUG_ON(ARRAY_SIZE(partitions) != ARRAY_SIZE(tsgl->sgl)); 5483f47a03dSEric Biggers if (WARN_ON(ndivs > ARRAY_SIZE(partitions))) 5493f47a03dSEric Biggers return -EINVAL; 5503f47a03dSEric Biggers 5513f47a03dSEric Biggers /* Calculate the (div, length) pairs */ 5523f47a03dSEric Biggers tsgl->nents = 0; 5533f47a03dSEric Biggers for (i = 0; i < ndivs; i++) { 5543f47a03dSEric Biggers unsigned int len_this_sg = 5553f47a03dSEric Biggers min(len_remaining, 5563f47a03dSEric Biggers (total_len * divs[i].proportion_of_total + 5573f47a03dSEric Biggers TEST_SG_TOTAL / 2) / TEST_SG_TOTAL); 5583f47a03dSEric Biggers 5593f47a03dSEric Biggers if (len_this_sg != 0) { 5603f47a03dSEric Biggers partitions[tsgl->nents].div = &divs[i]; 5613f47a03dSEric Biggers partitions[tsgl->nents].length = len_this_sg; 5623f47a03dSEric Biggers tsgl->nents++; 5633f47a03dSEric Biggers len_remaining -= len_this_sg; 5643f47a03dSEric Biggers } 5653f47a03dSEric Biggers } 5663f47a03dSEric Biggers if (tsgl->nents == 0) { 5673f47a03dSEric Biggers partitions[tsgl->nents].div = &divs[0]; 5683f47a03dSEric Biggers partitions[tsgl->nents].length = 0; 5693f47a03dSEric Biggers tsgl->nents++; 5703f47a03dSEric Biggers } 5713f47a03dSEric Biggers partitions[tsgl->nents - 1].length += len_remaining; 5723f47a03dSEric Biggers 5733f47a03dSEric Biggers /* Set up the sgl entries and fill the data or poison */ 5743f47a03dSEric Biggers sg_init_table(tsgl->sgl, tsgl->nents); 5753f47a03dSEric Biggers for (i = 0; i < tsgl->nents; i++) { 5763f47a03dSEric Biggers unsigned int offset = partitions[i].div->offset; 5773f47a03dSEric Biggers void *addr; 5783f47a03dSEric Biggers 5793f47a03dSEric Biggers if (partitions[i].div->offset_relative_to_alignmask) 5803f47a03dSEric Biggers offset += alignmask; 5813f47a03dSEric Biggers 5823f47a03dSEric Biggers while (offset + partitions[i].length + TESTMGR_POISON_LEN > 5833f47a03dSEric Biggers 2 * PAGE_SIZE) { 5843f47a03dSEric Biggers if (WARN_ON(offset <= 0)) 5853f47a03dSEric Biggers return -EINVAL; 5863f47a03dSEric Biggers offset /= 2; 5873f47a03dSEric Biggers } 5883f47a03dSEric Biggers 5893f47a03dSEric Biggers addr = &tsgl->bufs[i][offset]; 5903f47a03dSEric Biggers sg_set_buf(&tsgl->sgl[i], addr, partitions[i].length); 5913f47a03dSEric Biggers 5923f47a03dSEric Biggers if (out_divs) 5933f47a03dSEric Biggers out_divs[i] = partitions[i].div; 5943f47a03dSEric Biggers 5953f47a03dSEric Biggers if (data) { 5963f47a03dSEric Biggers size_t copy_len, copied; 5973f47a03dSEric Biggers 5983f47a03dSEric Biggers copy_len = min(partitions[i].length, data->count); 5993f47a03dSEric Biggers copied = copy_from_iter(addr, copy_len, data); 6003f47a03dSEric Biggers if (WARN_ON(copied != copy_len)) 6013f47a03dSEric Biggers return -EINVAL; 6023f47a03dSEric Biggers testmgr_poison(addr + copy_len, partitions[i].length + 6033f47a03dSEric Biggers TESTMGR_POISON_LEN - copy_len); 6043f47a03dSEric Biggers } else { 6053f47a03dSEric Biggers testmgr_poison(addr, partitions[i].length + 6063f47a03dSEric Biggers TESTMGR_POISON_LEN); 6073f47a03dSEric Biggers } 6083f47a03dSEric Biggers } 6093f47a03dSEric Biggers 6103f47a03dSEric Biggers sg_mark_end(&tsgl->sgl[tsgl->nents - 1]); 6113f47a03dSEric Biggers tsgl->sgl_ptr = tsgl->sgl; 6123f47a03dSEric Biggers memcpy(tsgl->sgl_saved, tsgl->sgl, tsgl->nents * sizeof(tsgl->sgl[0])); 6133f47a03dSEric Biggers return 0; 6143f47a03dSEric Biggers } 6153f47a03dSEric Biggers 6163f47a03dSEric Biggers /* 6173f47a03dSEric Biggers * Verify that a scatterlist crypto operation produced the correct output. 6183f47a03dSEric Biggers * 6193f47a03dSEric Biggers * @tsgl: scatterlist containing the actual output 6203f47a03dSEric Biggers * @expected_output: buffer containing the expected output 6213f47a03dSEric Biggers * @len_to_check: length of @expected_output in bytes 6223f47a03dSEric Biggers * @unchecked_prefix_len: number of ignored bytes in @tsgl prior to real result 6233f47a03dSEric Biggers * @check_poison: verify that the poison bytes after each chunk are intact? 6243f47a03dSEric Biggers * 6253f47a03dSEric Biggers * Return: 0 if correct, -EINVAL if incorrect, -EOVERFLOW if buffer overrun. 6263f47a03dSEric Biggers */ 6273f47a03dSEric Biggers static int verify_correct_output(const struct test_sglist *tsgl, 6283f47a03dSEric Biggers const char *expected_output, 6293f47a03dSEric Biggers unsigned int len_to_check, 6303f47a03dSEric Biggers unsigned int unchecked_prefix_len, 6313f47a03dSEric Biggers bool check_poison) 6323f47a03dSEric Biggers { 6333f47a03dSEric Biggers unsigned int i; 6343f47a03dSEric Biggers 6353f47a03dSEric Biggers for (i = 0; i < tsgl->nents; i++) { 6363f47a03dSEric Biggers struct scatterlist *sg = &tsgl->sgl_ptr[i]; 6373f47a03dSEric Biggers unsigned int len = sg->length; 6383f47a03dSEric Biggers unsigned int offset = sg->offset; 6393f47a03dSEric Biggers const char *actual_output; 6403f47a03dSEric Biggers 6413f47a03dSEric Biggers if (unchecked_prefix_len) { 6423f47a03dSEric Biggers if (unchecked_prefix_len >= len) { 6433f47a03dSEric Biggers unchecked_prefix_len -= len; 6443f47a03dSEric Biggers continue; 6453f47a03dSEric Biggers } 6463f47a03dSEric Biggers offset += unchecked_prefix_len; 6473f47a03dSEric Biggers len -= unchecked_prefix_len; 6483f47a03dSEric Biggers unchecked_prefix_len = 0; 6493f47a03dSEric Biggers } 6503f47a03dSEric Biggers len = min(len, len_to_check); 6513f47a03dSEric Biggers actual_output = page_address(sg_page(sg)) + offset; 6523f47a03dSEric Biggers if (memcmp(expected_output, actual_output, len) != 0) 6533f47a03dSEric Biggers return -EINVAL; 6543f47a03dSEric Biggers if (check_poison && 6553f47a03dSEric Biggers !testmgr_is_poison(actual_output + len, TESTMGR_POISON_LEN)) 6563f47a03dSEric Biggers return -EOVERFLOW; 6573f47a03dSEric Biggers len_to_check -= len; 6583f47a03dSEric Biggers expected_output += len; 6593f47a03dSEric Biggers } 6603f47a03dSEric Biggers if (WARN_ON(len_to_check != 0)) 6613f47a03dSEric Biggers return -EINVAL; 6623f47a03dSEric Biggers return 0; 6633f47a03dSEric Biggers } 6643f47a03dSEric Biggers 6653f47a03dSEric Biggers static bool is_test_sglist_corrupted(const struct test_sglist *tsgl) 6663f47a03dSEric Biggers { 6673f47a03dSEric Biggers unsigned int i; 6683f47a03dSEric Biggers 6693f47a03dSEric Biggers for (i = 0; i < tsgl->nents; i++) { 6703f47a03dSEric Biggers if (tsgl->sgl[i].page_link != tsgl->sgl_saved[i].page_link) 6713f47a03dSEric Biggers return true; 6723f47a03dSEric Biggers if (tsgl->sgl[i].offset != tsgl->sgl_saved[i].offset) 6733f47a03dSEric Biggers return true; 6743f47a03dSEric Biggers if (tsgl->sgl[i].length != tsgl->sgl_saved[i].length) 6753f47a03dSEric Biggers return true; 6763f47a03dSEric Biggers } 6773f47a03dSEric Biggers return false; 6783f47a03dSEric Biggers } 6793f47a03dSEric Biggers 6803f47a03dSEric Biggers struct cipher_test_sglists { 6813f47a03dSEric Biggers struct test_sglist src; 6823f47a03dSEric Biggers struct test_sglist dst; 6833f47a03dSEric Biggers }; 6843f47a03dSEric Biggers 6853f47a03dSEric Biggers static struct cipher_test_sglists *alloc_cipher_test_sglists(void) 6863f47a03dSEric Biggers { 6873f47a03dSEric Biggers struct cipher_test_sglists *tsgls; 6883f47a03dSEric Biggers 6893f47a03dSEric Biggers tsgls = kmalloc(sizeof(*tsgls), GFP_KERNEL); 6903f47a03dSEric Biggers if (!tsgls) 6913f47a03dSEric Biggers return NULL; 6923f47a03dSEric Biggers 6933f47a03dSEric Biggers if (init_test_sglist(&tsgls->src) != 0) 6943f47a03dSEric Biggers goto fail_kfree; 6953f47a03dSEric Biggers if (init_test_sglist(&tsgls->dst) != 0) 6963f47a03dSEric Biggers goto fail_destroy_src; 6973f47a03dSEric Biggers 6983f47a03dSEric Biggers return tsgls; 6993f47a03dSEric Biggers 7003f47a03dSEric Biggers fail_destroy_src: 7013f47a03dSEric Biggers destroy_test_sglist(&tsgls->src); 7023f47a03dSEric Biggers fail_kfree: 7033f47a03dSEric Biggers kfree(tsgls); 7043f47a03dSEric Biggers return NULL; 7053f47a03dSEric Biggers } 7063f47a03dSEric Biggers 7073f47a03dSEric Biggers static void free_cipher_test_sglists(struct cipher_test_sglists *tsgls) 7083f47a03dSEric Biggers { 7093f47a03dSEric Biggers if (tsgls) { 7103f47a03dSEric Biggers destroy_test_sglist(&tsgls->src); 7113f47a03dSEric Biggers destroy_test_sglist(&tsgls->dst); 7123f47a03dSEric Biggers kfree(tsgls); 7133f47a03dSEric Biggers } 7143f47a03dSEric Biggers } 7153f47a03dSEric Biggers 7163f47a03dSEric Biggers /* Build the src and dst scatterlists for an skcipher or AEAD test */ 7173f47a03dSEric Biggers static int build_cipher_test_sglists(struct cipher_test_sglists *tsgls, 7183f47a03dSEric Biggers const struct testvec_config *cfg, 7193f47a03dSEric Biggers unsigned int alignmask, 7203f47a03dSEric Biggers unsigned int src_total_len, 7213f47a03dSEric Biggers unsigned int dst_total_len, 7223f47a03dSEric Biggers const struct kvec *inputs, 7233f47a03dSEric Biggers unsigned int nr_inputs) 7243f47a03dSEric Biggers { 7253f47a03dSEric Biggers struct iov_iter input; 7263f47a03dSEric Biggers int err; 7273f47a03dSEric Biggers 7283f47a03dSEric Biggers iov_iter_kvec(&input, WRITE, inputs, nr_inputs, src_total_len); 7293f47a03dSEric Biggers err = build_test_sglist(&tsgls->src, cfg->src_divs, alignmask, 7303f47a03dSEric Biggers cfg->inplace ? 7313f47a03dSEric Biggers max(dst_total_len, src_total_len) : 7323f47a03dSEric Biggers src_total_len, 7333f47a03dSEric Biggers &input, NULL); 7343f47a03dSEric Biggers if (err) 7353f47a03dSEric Biggers return err; 7363f47a03dSEric Biggers 7373f47a03dSEric Biggers if (cfg->inplace) { 7383f47a03dSEric Biggers tsgls->dst.sgl_ptr = tsgls->src.sgl; 7393f47a03dSEric Biggers tsgls->dst.nents = tsgls->src.nents; 7403f47a03dSEric Biggers return 0; 7413f47a03dSEric Biggers } 7423f47a03dSEric Biggers return build_test_sglist(&tsgls->dst, 7433f47a03dSEric Biggers cfg->dst_divs[0].proportion_of_total ? 7443f47a03dSEric Biggers cfg->dst_divs : cfg->src_divs, 7453f47a03dSEric Biggers alignmask, dst_total_len, NULL, NULL); 746f8b0d4d0SHerbert Xu } 747f8b0d4d0SHerbert Xu 74825f9dddbSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 749f2bb770aSEric Biggers 750f2bb770aSEric Biggers /* Generate a random length in range [0, max_len], but prefer smaller values */ 751f2bb770aSEric Biggers static unsigned int generate_random_length(unsigned int max_len) 752f2bb770aSEric Biggers { 753f2bb770aSEric Biggers unsigned int len = prandom_u32() % (max_len + 1); 754f2bb770aSEric Biggers 755f2bb770aSEric Biggers switch (prandom_u32() % 4) { 756f2bb770aSEric Biggers case 0: 757f2bb770aSEric Biggers return len % 64; 758f2bb770aSEric Biggers case 1: 759f2bb770aSEric Biggers return len % 256; 760f2bb770aSEric Biggers case 2: 761f2bb770aSEric Biggers return len % 1024; 762f2bb770aSEric Biggers default: 763f2bb770aSEric Biggers return len; 764f2bb770aSEric Biggers } 765f2bb770aSEric Biggers } 766f2bb770aSEric Biggers 767f2bb770aSEric Biggers /* Sometimes make some random changes to the given data buffer */ 768f2bb770aSEric Biggers static void mutate_buffer(u8 *buf, size_t count) 769f2bb770aSEric Biggers { 770f2bb770aSEric Biggers size_t num_flips; 771f2bb770aSEric Biggers size_t i; 772f2bb770aSEric Biggers size_t pos; 773f2bb770aSEric Biggers 774f2bb770aSEric Biggers /* Sometimes flip some bits */ 775f2bb770aSEric Biggers if (prandom_u32() % 4 == 0) { 776f2bb770aSEric Biggers num_flips = min_t(size_t, 1 << (prandom_u32() % 8), count * 8); 777f2bb770aSEric Biggers for (i = 0; i < num_flips; i++) { 778f2bb770aSEric Biggers pos = prandom_u32() % (count * 8); 779f2bb770aSEric Biggers buf[pos / 8] ^= 1 << (pos % 8); 780f2bb770aSEric Biggers } 781f2bb770aSEric Biggers } 782f2bb770aSEric Biggers 783f2bb770aSEric Biggers /* Sometimes flip some bytes */ 784f2bb770aSEric Biggers if (prandom_u32() % 4 == 0) { 785f2bb770aSEric Biggers num_flips = min_t(size_t, 1 << (prandom_u32() % 8), count); 786f2bb770aSEric Biggers for (i = 0; i < num_flips; i++) 787f2bb770aSEric Biggers buf[prandom_u32() % count] ^= 0xff; 788f2bb770aSEric Biggers } 789f2bb770aSEric Biggers } 790f2bb770aSEric Biggers 791f2bb770aSEric Biggers /* Randomly generate 'count' bytes, but sometimes make them "interesting" */ 792f2bb770aSEric Biggers static void generate_random_bytes(u8 *buf, size_t count) 793f2bb770aSEric Biggers { 794f2bb770aSEric Biggers u8 b; 795f2bb770aSEric Biggers u8 increment; 796f2bb770aSEric Biggers size_t i; 797f2bb770aSEric Biggers 798f2bb770aSEric Biggers if (count == 0) 799f2bb770aSEric Biggers return; 800f2bb770aSEric Biggers 801f2bb770aSEric Biggers switch (prandom_u32() % 8) { /* Choose a generation strategy */ 802f2bb770aSEric Biggers case 0: 803f2bb770aSEric Biggers case 1: 804f2bb770aSEric Biggers /* All the same byte, plus optional mutations */ 805f2bb770aSEric Biggers switch (prandom_u32() % 4) { 806f2bb770aSEric Biggers case 0: 807f2bb770aSEric Biggers b = 0x00; 808f2bb770aSEric Biggers break; 809f2bb770aSEric Biggers case 1: 810f2bb770aSEric Biggers b = 0xff; 811f2bb770aSEric Biggers break; 812f2bb770aSEric Biggers default: 813f2bb770aSEric Biggers b = (u8)prandom_u32(); 814f2bb770aSEric Biggers break; 815f2bb770aSEric Biggers } 816f2bb770aSEric Biggers memset(buf, b, count); 817f2bb770aSEric Biggers mutate_buffer(buf, count); 818f2bb770aSEric Biggers break; 819f2bb770aSEric Biggers case 2: 820f2bb770aSEric Biggers /* Ascending or descending bytes, plus optional mutations */ 821f2bb770aSEric Biggers increment = (u8)prandom_u32(); 822f2bb770aSEric Biggers b = (u8)prandom_u32(); 823f2bb770aSEric Biggers for (i = 0; i < count; i++, b += increment) 824f2bb770aSEric Biggers buf[i] = b; 825f2bb770aSEric Biggers mutate_buffer(buf, count); 826f2bb770aSEric Biggers break; 827f2bb770aSEric Biggers default: 828f2bb770aSEric Biggers /* Fully random bytes */ 829f2bb770aSEric Biggers for (i = 0; i < count; i++) 830f2bb770aSEric Biggers buf[i] = (u8)prandom_u32(); 831f2bb770aSEric Biggers } 832f2bb770aSEric Biggers } 833f2bb770aSEric Biggers 83425f9dddbSEric Biggers static char *generate_random_sgl_divisions(struct test_sg_division *divs, 83525f9dddbSEric Biggers size_t max_divs, char *p, char *end, 8366570737cSEric Biggers bool gen_flushes, u32 req_flags) 83725f9dddbSEric Biggers { 83825f9dddbSEric Biggers struct test_sg_division *div = divs; 83925f9dddbSEric Biggers unsigned int remaining = TEST_SG_TOTAL; 84025f9dddbSEric Biggers 84125f9dddbSEric Biggers do { 84225f9dddbSEric Biggers unsigned int this_len; 8436570737cSEric Biggers const char *flushtype_str; 84425f9dddbSEric Biggers 84525f9dddbSEric Biggers if (div == &divs[max_divs - 1] || prandom_u32() % 2 == 0) 84625f9dddbSEric Biggers this_len = remaining; 84725f9dddbSEric Biggers else 84825f9dddbSEric Biggers this_len = 1 + (prandom_u32() % remaining); 84925f9dddbSEric Biggers div->proportion_of_total = this_len; 85025f9dddbSEric Biggers 85125f9dddbSEric Biggers if (prandom_u32() % 4 == 0) 85225f9dddbSEric Biggers div->offset = (PAGE_SIZE - 128) + (prandom_u32() % 128); 85325f9dddbSEric Biggers else if (prandom_u32() % 2 == 0) 85425f9dddbSEric Biggers div->offset = prandom_u32() % 32; 85525f9dddbSEric Biggers else 85625f9dddbSEric Biggers div->offset = prandom_u32() % PAGE_SIZE; 85725f9dddbSEric Biggers if (prandom_u32() % 8 == 0) 85825f9dddbSEric Biggers div->offset_relative_to_alignmask = true; 85925f9dddbSEric Biggers 86025f9dddbSEric Biggers div->flush_type = FLUSH_TYPE_NONE; 86125f9dddbSEric Biggers if (gen_flushes) { 86225f9dddbSEric Biggers switch (prandom_u32() % 4) { 86325f9dddbSEric Biggers case 0: 86425f9dddbSEric Biggers div->flush_type = FLUSH_TYPE_REIMPORT; 86525f9dddbSEric Biggers break; 86625f9dddbSEric Biggers case 1: 86725f9dddbSEric Biggers div->flush_type = FLUSH_TYPE_FLUSH; 86825f9dddbSEric Biggers break; 86925f9dddbSEric Biggers } 87025f9dddbSEric Biggers } 87125f9dddbSEric Biggers 8726570737cSEric Biggers if (div->flush_type != FLUSH_TYPE_NONE && 8736570737cSEric Biggers !(req_flags & CRYPTO_TFM_REQ_MAY_SLEEP) && 8746570737cSEric Biggers prandom_u32() % 2 == 0) 8756570737cSEric Biggers div->nosimd = true; 8766570737cSEric Biggers 8776570737cSEric Biggers switch (div->flush_type) { 8786570737cSEric Biggers case FLUSH_TYPE_FLUSH: 8796570737cSEric Biggers if (div->nosimd) 8806570737cSEric Biggers flushtype_str = "<flush,nosimd>"; 8816570737cSEric Biggers else 8826570737cSEric Biggers flushtype_str = "<flush>"; 8836570737cSEric Biggers break; 8846570737cSEric Biggers case FLUSH_TYPE_REIMPORT: 8856570737cSEric Biggers if (div->nosimd) 8866570737cSEric Biggers flushtype_str = "<reimport,nosimd>"; 8876570737cSEric Biggers else 8886570737cSEric Biggers flushtype_str = "<reimport>"; 8896570737cSEric Biggers break; 8906570737cSEric Biggers default: 8916570737cSEric Biggers flushtype_str = ""; 8926570737cSEric Biggers break; 8936570737cSEric Biggers } 8946570737cSEric Biggers 89525f9dddbSEric Biggers BUILD_BUG_ON(TEST_SG_TOTAL != 10000); /* for "%u.%u%%" */ 8966570737cSEric Biggers p += scnprintf(p, end - p, "%s%u.%u%%@%s+%u%s", flushtype_str, 89725f9dddbSEric Biggers this_len / 100, this_len % 100, 89825f9dddbSEric Biggers div->offset_relative_to_alignmask ? 89925f9dddbSEric Biggers "alignmask" : "", 90025f9dddbSEric Biggers div->offset, this_len == remaining ? "" : ", "); 90125f9dddbSEric Biggers remaining -= this_len; 90225f9dddbSEric Biggers div++; 90325f9dddbSEric Biggers } while (remaining); 90425f9dddbSEric Biggers 90525f9dddbSEric Biggers return p; 90625f9dddbSEric Biggers } 90725f9dddbSEric Biggers 90825f9dddbSEric Biggers /* Generate a random testvec_config for fuzz testing */ 90925f9dddbSEric Biggers static void generate_random_testvec_config(struct testvec_config *cfg, 91025f9dddbSEric Biggers char *name, size_t max_namelen) 91125f9dddbSEric Biggers { 91225f9dddbSEric Biggers char *p = name; 91325f9dddbSEric Biggers char * const end = name + max_namelen; 91425f9dddbSEric Biggers 91525f9dddbSEric Biggers memset(cfg, 0, sizeof(*cfg)); 91625f9dddbSEric Biggers 91725f9dddbSEric Biggers cfg->name = name; 91825f9dddbSEric Biggers 91925f9dddbSEric Biggers p += scnprintf(p, end - p, "random:"); 92025f9dddbSEric Biggers 92125f9dddbSEric Biggers if (prandom_u32() % 2 == 0) { 92225f9dddbSEric Biggers cfg->inplace = true; 92325f9dddbSEric Biggers p += scnprintf(p, end - p, " inplace"); 92425f9dddbSEric Biggers } 92525f9dddbSEric Biggers 92625f9dddbSEric Biggers if (prandom_u32() % 2 == 0) { 92725f9dddbSEric Biggers cfg->req_flags |= CRYPTO_TFM_REQ_MAY_SLEEP; 92825f9dddbSEric Biggers p += scnprintf(p, end - p, " may_sleep"); 92925f9dddbSEric Biggers } 93025f9dddbSEric Biggers 93125f9dddbSEric Biggers switch (prandom_u32() % 4) { 93225f9dddbSEric Biggers case 0: 93325f9dddbSEric Biggers cfg->finalization_type = FINALIZATION_TYPE_FINAL; 93425f9dddbSEric Biggers p += scnprintf(p, end - p, " use_final"); 93525f9dddbSEric Biggers break; 93625f9dddbSEric Biggers case 1: 93725f9dddbSEric Biggers cfg->finalization_type = FINALIZATION_TYPE_FINUP; 93825f9dddbSEric Biggers p += scnprintf(p, end - p, " use_finup"); 93925f9dddbSEric Biggers break; 94025f9dddbSEric Biggers default: 94125f9dddbSEric Biggers cfg->finalization_type = FINALIZATION_TYPE_DIGEST; 94225f9dddbSEric Biggers p += scnprintf(p, end - p, " use_digest"); 94325f9dddbSEric Biggers break; 94425f9dddbSEric Biggers } 94525f9dddbSEric Biggers 9466570737cSEric Biggers if (!(cfg->req_flags & CRYPTO_TFM_REQ_MAY_SLEEP) && 9476570737cSEric Biggers prandom_u32() % 2 == 0) { 9486570737cSEric Biggers cfg->nosimd = true; 9496570737cSEric Biggers p += scnprintf(p, end - p, " nosimd"); 9506570737cSEric Biggers } 9516570737cSEric Biggers 95225f9dddbSEric Biggers p += scnprintf(p, end - p, " src_divs=["); 95325f9dddbSEric Biggers p = generate_random_sgl_divisions(cfg->src_divs, 95425f9dddbSEric Biggers ARRAY_SIZE(cfg->src_divs), p, end, 95525f9dddbSEric Biggers (cfg->finalization_type != 9566570737cSEric Biggers FINALIZATION_TYPE_DIGEST), 9576570737cSEric Biggers cfg->req_flags); 95825f9dddbSEric Biggers p += scnprintf(p, end - p, "]"); 95925f9dddbSEric Biggers 96025f9dddbSEric Biggers if (!cfg->inplace && prandom_u32() % 2 == 0) { 96125f9dddbSEric Biggers p += scnprintf(p, end - p, " dst_divs=["); 96225f9dddbSEric Biggers p = generate_random_sgl_divisions(cfg->dst_divs, 96325f9dddbSEric Biggers ARRAY_SIZE(cfg->dst_divs), 9646570737cSEric Biggers p, end, false, 9656570737cSEric Biggers cfg->req_flags); 96625f9dddbSEric Biggers p += scnprintf(p, end - p, "]"); 96725f9dddbSEric Biggers } 96825f9dddbSEric Biggers 96925f9dddbSEric Biggers if (prandom_u32() % 2 == 0) { 97025f9dddbSEric Biggers cfg->iv_offset = 1 + (prandom_u32() % MAX_ALGAPI_ALIGNMASK); 97125f9dddbSEric Biggers p += scnprintf(p, end - p, " iv_offset=%u", cfg->iv_offset); 97225f9dddbSEric Biggers } 97325f9dddbSEric Biggers 97425f9dddbSEric Biggers WARN_ON_ONCE(!valid_testvec_config(cfg)); 97525f9dddbSEric Biggers } 976b55e1a39SEric Biggers 977b55e1a39SEric Biggers static void crypto_disable_simd_for_test(void) 978b55e1a39SEric Biggers { 979b55e1a39SEric Biggers preempt_disable(); 980b55e1a39SEric Biggers __this_cpu_write(crypto_simd_disabled_for_test, true); 981b55e1a39SEric Biggers } 982b55e1a39SEric Biggers 983b55e1a39SEric Biggers static void crypto_reenable_simd_for_test(void) 984b55e1a39SEric Biggers { 985b55e1a39SEric Biggers __this_cpu_write(crypto_simd_disabled_for_test, false); 986b55e1a39SEric Biggers preempt_enable(); 987b55e1a39SEric Biggers } 988f2bb770aSEric Biggers 989f2bb770aSEric Biggers /* 990f2bb770aSEric Biggers * Given an algorithm name, build the name of the generic implementation of that 991f2bb770aSEric Biggers * algorithm, assuming the usual naming convention. Specifically, this appends 992f2bb770aSEric Biggers * "-generic" to every part of the name that is not a template name. Examples: 993f2bb770aSEric Biggers * 994f2bb770aSEric Biggers * aes => aes-generic 995f2bb770aSEric Biggers * cbc(aes) => cbc(aes-generic) 996f2bb770aSEric Biggers * cts(cbc(aes)) => cts(cbc(aes-generic)) 997f2bb770aSEric Biggers * rfc7539(chacha20,poly1305) => rfc7539(chacha20-generic,poly1305-generic) 998f2bb770aSEric Biggers * 999f2bb770aSEric Biggers * Return: 0 on success, or -ENAMETOOLONG if the generic name would be too long 1000f2bb770aSEric Biggers */ 1001f2bb770aSEric Biggers static int build_generic_driver_name(const char *algname, 1002f2bb770aSEric Biggers char driver_name[CRYPTO_MAX_ALG_NAME]) 1003f2bb770aSEric Biggers { 1004f2bb770aSEric Biggers const char *in = algname; 1005f2bb770aSEric Biggers char *out = driver_name; 1006f2bb770aSEric Biggers size_t len = strlen(algname); 1007f2bb770aSEric Biggers 1008f2bb770aSEric Biggers if (len >= CRYPTO_MAX_ALG_NAME) 1009f2bb770aSEric Biggers goto too_long; 1010f2bb770aSEric Biggers do { 1011f2bb770aSEric Biggers const char *in_saved = in; 1012f2bb770aSEric Biggers 1013f2bb770aSEric Biggers while (*in && *in != '(' && *in != ')' && *in != ',') 1014f2bb770aSEric Biggers *out++ = *in++; 1015f2bb770aSEric Biggers if (*in != '(' && in > in_saved) { 1016f2bb770aSEric Biggers len += 8; 1017f2bb770aSEric Biggers if (len >= CRYPTO_MAX_ALG_NAME) 1018f2bb770aSEric Biggers goto too_long; 1019f2bb770aSEric Biggers memcpy(out, "-generic", 8); 1020f2bb770aSEric Biggers out += 8; 1021f2bb770aSEric Biggers } 1022f2bb770aSEric Biggers } while ((*out++ = *in++) != '\0'); 1023f2bb770aSEric Biggers return 0; 1024f2bb770aSEric Biggers 1025f2bb770aSEric Biggers too_long: 1026f2bb770aSEric Biggers pr_err("alg: generic driver name for \"%s\" would be too long\n", 1027f2bb770aSEric Biggers algname); 1028f2bb770aSEric Biggers return -ENAMETOOLONG; 1029f2bb770aSEric Biggers } 1030b55e1a39SEric Biggers #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 1031b55e1a39SEric Biggers static void crypto_disable_simd_for_test(void) 1032b55e1a39SEric Biggers { 1033b55e1a39SEric Biggers } 1034b55e1a39SEric Biggers 1035b55e1a39SEric Biggers static void crypto_reenable_simd_for_test(void) 1036b55e1a39SEric Biggers { 1037b55e1a39SEric Biggers } 1038b55e1a39SEric Biggers #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 103925f9dddbSEric Biggers 10406570737cSEric Biggers static int do_ahash_op(int (*op)(struct ahash_request *req), 10416570737cSEric Biggers struct ahash_request *req, 10426570737cSEric Biggers struct crypto_wait *wait, bool nosimd) 10436570737cSEric Biggers { 10446570737cSEric Biggers int err; 10456570737cSEric Biggers 10466570737cSEric Biggers if (nosimd) 10476570737cSEric Biggers crypto_disable_simd_for_test(); 10486570737cSEric Biggers 10496570737cSEric Biggers err = op(req); 10506570737cSEric Biggers 10516570737cSEric Biggers if (nosimd) 10526570737cSEric Biggers crypto_reenable_simd_for_test(); 10536570737cSEric Biggers 10546570737cSEric Biggers return crypto_wait_req(err, wait); 10556570737cSEric Biggers } 10566570737cSEric Biggers 10574cc2dcf9SEric Biggers static int check_nonfinal_hash_op(const char *op, int err, 10584cc2dcf9SEric Biggers u8 *result, unsigned int digestsize, 1059951d1332SEric Biggers const char *driver, const char *vec_name, 10604cc2dcf9SEric Biggers const struct testvec_config *cfg) 1061466d7b9fSKamil Konieczny { 10624cc2dcf9SEric Biggers if (err) { 1063951d1332SEric Biggers pr_err("alg: hash: %s %s() failed with err %d on test vector %s, cfg=\"%s\"\n", 1064951d1332SEric Biggers driver, op, err, vec_name, cfg->name); 10654cc2dcf9SEric Biggers return err; 10664cc2dcf9SEric Biggers } 10674cc2dcf9SEric Biggers if (!testmgr_is_poison(result, digestsize)) { 1068951d1332SEric Biggers pr_err("alg: hash: %s %s() used result buffer on test vector %s, cfg=\"%s\"\n", 1069951d1332SEric Biggers driver, op, vec_name, cfg->name); 1070466d7b9fSKamil Konieczny return -EINVAL; 1071466d7b9fSKamil Konieczny } 1072466d7b9fSKamil Konieczny return 0; 1073466d7b9fSKamil Konieczny } 1074466d7b9fSKamil Konieczny 10754cc2dcf9SEric Biggers static int test_hash_vec_cfg(const char *driver, 10764cc2dcf9SEric Biggers const struct hash_testvec *vec, 1077951d1332SEric Biggers const char *vec_name, 10784cc2dcf9SEric Biggers const struct testvec_config *cfg, 10794cc2dcf9SEric Biggers struct ahash_request *req, 10804cc2dcf9SEric Biggers struct test_sglist *tsgl, 10814cc2dcf9SEric Biggers u8 *hashstate) 1082018ba95cSWang, Rui Y { 10834cc2dcf9SEric Biggers struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 10844cc2dcf9SEric Biggers const unsigned int alignmask = crypto_ahash_alignmask(tfm); 10854cc2dcf9SEric Biggers const unsigned int digestsize = crypto_ahash_digestsize(tfm); 10864cc2dcf9SEric Biggers const unsigned int statesize = crypto_ahash_statesize(tfm); 10874cc2dcf9SEric Biggers const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags; 10884cc2dcf9SEric Biggers const struct test_sg_division *divs[XBUFSIZE]; 10894cc2dcf9SEric Biggers DECLARE_CRYPTO_WAIT(wait); 10904cc2dcf9SEric Biggers struct kvec _input; 10914cc2dcf9SEric Biggers struct iov_iter input; 10924cc2dcf9SEric Biggers unsigned int i; 10934cc2dcf9SEric Biggers struct scatterlist *pending_sgl; 10944cc2dcf9SEric Biggers unsigned int pending_len; 10954cc2dcf9SEric Biggers u8 result[HASH_MAX_DIGESTSIZE + TESTMGR_POISON_LEN]; 10964cc2dcf9SEric Biggers int err; 1097018ba95cSWang, Rui Y 10984cc2dcf9SEric Biggers /* Set the key, if specified */ 10994cc2dcf9SEric Biggers if (vec->ksize) { 11004cc2dcf9SEric Biggers err = crypto_ahash_setkey(tfm, vec->key, vec->ksize); 11014cc2dcf9SEric Biggers if (err) { 11025283a8eeSEric Biggers if (err == vec->setkey_error) 11035283a8eeSEric Biggers return 0; 1104951d1332SEric Biggers pr_err("alg: hash: %s setkey failed on test vector %s; expected_error=%d, actual_error=%d, flags=%#x\n", 1105951d1332SEric Biggers driver, vec_name, vec->setkey_error, err, 11064cc2dcf9SEric Biggers crypto_ahash_get_flags(tfm)); 11074cc2dcf9SEric Biggers return err; 1108da7f033dSHerbert Xu } 11095283a8eeSEric Biggers if (vec->setkey_error) { 1110951d1332SEric Biggers pr_err("alg: hash: %s setkey unexpectedly succeeded on test vector %s; expected_error=%d\n", 1111951d1332SEric Biggers driver, vec_name, vec->setkey_error); 11125283a8eeSEric Biggers return -EINVAL; 11135283a8eeSEric Biggers } 1114da7f033dSHerbert Xu } 1115da7f033dSHerbert Xu 11164cc2dcf9SEric Biggers /* Build the scatterlist for the source data */ 11174cc2dcf9SEric Biggers _input.iov_base = (void *)vec->plaintext; 11184cc2dcf9SEric Biggers _input.iov_len = vec->psize; 11194cc2dcf9SEric Biggers iov_iter_kvec(&input, WRITE, &_input, 1, vec->psize); 11204cc2dcf9SEric Biggers err = build_test_sglist(tsgl, cfg->src_divs, alignmask, vec->psize, 11214cc2dcf9SEric Biggers &input, divs); 11224cc2dcf9SEric Biggers if (err) { 1123951d1332SEric Biggers pr_err("alg: hash: %s: error preparing scatterlist for test vector %s, cfg=\"%s\"\n", 1124951d1332SEric Biggers driver, vec_name, cfg->name); 11254cc2dcf9SEric Biggers return err; 1126a8f1a052SDavid S. Miller } 1127da7f033dSHerbert Xu 11284cc2dcf9SEric Biggers /* Do the actual hashing */ 1129da7f033dSHerbert Xu 11304cc2dcf9SEric Biggers testmgr_poison(req->__ctx, crypto_ahash_reqsize(tfm)); 11314cc2dcf9SEric Biggers testmgr_poison(result, digestsize + TESTMGR_POISON_LEN); 113276715095SGilad Ben-Yossef 11335283a8eeSEric Biggers if (cfg->finalization_type == FINALIZATION_TYPE_DIGEST || 11345283a8eeSEric Biggers vec->digest_error) { 11354cc2dcf9SEric Biggers /* Just using digest() */ 11364cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, crypto_req_done, 11377f397136SGilad Ben-Yossef &wait); 11384cc2dcf9SEric Biggers ahash_request_set_crypt(req, tsgl->sgl, result, vec->psize); 11396570737cSEric Biggers err = do_ahash_op(crypto_ahash_digest, req, &wait, cfg->nosimd); 11404cc2dcf9SEric Biggers if (err) { 11415283a8eeSEric Biggers if (err == vec->digest_error) 11425283a8eeSEric Biggers return 0; 1143951d1332SEric Biggers pr_err("alg: hash: %s digest() failed on test vector %s; expected_error=%d, actual_error=%d, cfg=\"%s\"\n", 1144951d1332SEric Biggers driver, vec_name, vec->digest_error, err, 11455283a8eeSEric Biggers cfg->name); 11464cc2dcf9SEric Biggers return err; 1147018ba95cSWang, Rui Y } 11485283a8eeSEric Biggers if (vec->digest_error) { 1149951d1332SEric Biggers pr_err("alg: hash: %s digest() unexpectedly succeeded on test vector %s; expected_error=%d, cfg=\"%s\"\n", 1150951d1332SEric Biggers driver, vec_name, vec->digest_error, cfg->name); 11515283a8eeSEric Biggers return -EINVAL; 11525283a8eeSEric Biggers } 11534cc2dcf9SEric Biggers goto result_ready; 1154018ba95cSWang, Rui Y } 11554cc2dcf9SEric Biggers 11564cc2dcf9SEric Biggers /* Using init(), zero or more update(), then final() or finup() */ 11574cc2dcf9SEric Biggers 11584cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, crypto_req_done, &wait); 11594cc2dcf9SEric Biggers ahash_request_set_crypt(req, NULL, result, 0); 11606570737cSEric Biggers err = do_ahash_op(crypto_ahash_init, req, &wait, cfg->nosimd); 11614cc2dcf9SEric Biggers err = check_nonfinal_hash_op("init", err, result, digestsize, 1162951d1332SEric Biggers driver, vec_name, cfg); 11634cc2dcf9SEric Biggers if (err) 11644cc2dcf9SEric Biggers return err; 11654cc2dcf9SEric Biggers 11664cc2dcf9SEric Biggers pending_sgl = NULL; 11674cc2dcf9SEric Biggers pending_len = 0; 11684cc2dcf9SEric Biggers for (i = 0; i < tsgl->nents; i++) { 11694cc2dcf9SEric Biggers if (divs[i]->flush_type != FLUSH_TYPE_NONE && 11704cc2dcf9SEric Biggers pending_sgl != NULL) { 11714cc2dcf9SEric Biggers /* update() with the pending data */ 11724cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, 11734cc2dcf9SEric Biggers crypto_req_done, &wait); 11744cc2dcf9SEric Biggers ahash_request_set_crypt(req, pending_sgl, result, 11754cc2dcf9SEric Biggers pending_len); 11766570737cSEric Biggers err = do_ahash_op(crypto_ahash_update, req, &wait, 11776570737cSEric Biggers divs[i]->nosimd); 11784cc2dcf9SEric Biggers err = check_nonfinal_hash_op("update", err, 11794cc2dcf9SEric Biggers result, digestsize, 1180951d1332SEric Biggers driver, vec_name, cfg); 11814cc2dcf9SEric Biggers if (err) 11824cc2dcf9SEric Biggers return err; 11834cc2dcf9SEric Biggers pending_sgl = NULL; 11844cc2dcf9SEric Biggers pending_len = 0; 1185018ba95cSWang, Rui Y } 11864cc2dcf9SEric Biggers if (divs[i]->flush_type == FLUSH_TYPE_REIMPORT) { 11874cc2dcf9SEric Biggers /* Test ->export() and ->import() */ 11884cc2dcf9SEric Biggers testmgr_poison(hashstate + statesize, 11894cc2dcf9SEric Biggers TESTMGR_POISON_LEN); 11904cc2dcf9SEric Biggers err = crypto_ahash_export(req, hashstate); 11914cc2dcf9SEric Biggers err = check_nonfinal_hash_op("export", err, 11924cc2dcf9SEric Biggers result, digestsize, 1193951d1332SEric Biggers driver, vec_name, cfg); 11944cc2dcf9SEric Biggers if (err) 11954cc2dcf9SEric Biggers return err; 11964cc2dcf9SEric Biggers if (!testmgr_is_poison(hashstate + statesize, 11974cc2dcf9SEric Biggers TESTMGR_POISON_LEN)) { 1198951d1332SEric Biggers pr_err("alg: hash: %s export() overran state buffer on test vector %s, cfg=\"%s\"\n", 1199951d1332SEric Biggers driver, vec_name, cfg->name); 12004cc2dcf9SEric Biggers return -EOVERFLOW; 12014cc2dcf9SEric Biggers } 12024cc2dcf9SEric Biggers 12034cc2dcf9SEric Biggers testmgr_poison(req->__ctx, crypto_ahash_reqsize(tfm)); 12044cc2dcf9SEric Biggers err = crypto_ahash_import(req, hashstate); 12054cc2dcf9SEric Biggers err = check_nonfinal_hash_op("import", err, 12064cc2dcf9SEric Biggers result, digestsize, 1207951d1332SEric Biggers driver, vec_name, cfg); 12084cc2dcf9SEric Biggers if (err) 12094cc2dcf9SEric Biggers return err; 12104cc2dcf9SEric Biggers } 12114cc2dcf9SEric Biggers if (pending_sgl == NULL) 12124cc2dcf9SEric Biggers pending_sgl = &tsgl->sgl[i]; 12134cc2dcf9SEric Biggers pending_len += tsgl->sgl[i].length; 12144cc2dcf9SEric Biggers } 12154cc2dcf9SEric Biggers 12164cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, crypto_req_done, &wait); 12174cc2dcf9SEric Biggers ahash_request_set_crypt(req, pending_sgl, result, pending_len); 12184cc2dcf9SEric Biggers if (cfg->finalization_type == FINALIZATION_TYPE_FINAL) { 12194cc2dcf9SEric Biggers /* finish with update() and final() */ 12206570737cSEric Biggers err = do_ahash_op(crypto_ahash_update, req, &wait, cfg->nosimd); 12214cc2dcf9SEric Biggers err = check_nonfinal_hash_op("update", err, result, digestsize, 1222951d1332SEric Biggers driver, vec_name, cfg); 12234cc2dcf9SEric Biggers if (err) 12244cc2dcf9SEric Biggers return err; 12256570737cSEric Biggers err = do_ahash_op(crypto_ahash_final, req, &wait, cfg->nosimd); 12264cc2dcf9SEric Biggers if (err) { 1227951d1332SEric Biggers pr_err("alg: hash: %s final() failed with err %d on test vector %s, cfg=\"%s\"\n", 1228951d1332SEric Biggers driver, err, vec_name, cfg->name); 12294cc2dcf9SEric Biggers return err; 12304cc2dcf9SEric Biggers } 12314cc2dcf9SEric Biggers } else { 12324cc2dcf9SEric Biggers /* finish with finup() */ 12336570737cSEric Biggers err = do_ahash_op(crypto_ahash_finup, req, &wait, cfg->nosimd); 12344cc2dcf9SEric Biggers if (err) { 1235951d1332SEric Biggers pr_err("alg: hash: %s finup() failed with err %d on test vector %s, cfg=\"%s\"\n", 1236951d1332SEric Biggers driver, err, vec_name, cfg->name); 12374cc2dcf9SEric Biggers return err; 1238018ba95cSWang, Rui Y } 1239018ba95cSWang, Rui Y } 1240018ba95cSWang, Rui Y 12414cc2dcf9SEric Biggers result_ready: 12424cc2dcf9SEric Biggers /* Check that the algorithm produced the correct digest */ 12434cc2dcf9SEric Biggers if (memcmp(result, vec->digest, digestsize) != 0) { 1244951d1332SEric Biggers pr_err("alg: hash: %s test failed (wrong result) on test vector %s, cfg=\"%s\"\n", 1245951d1332SEric Biggers driver, vec_name, cfg->name); 12464cc2dcf9SEric Biggers return -EINVAL; 1247da7f033dSHerbert Xu } 12484cc2dcf9SEric Biggers if (!testmgr_is_poison(&result[digestsize], TESTMGR_POISON_LEN)) { 1249951d1332SEric Biggers pr_err("alg: hash: %s overran result buffer on test vector %s, cfg=\"%s\"\n", 1250951d1332SEric Biggers driver, vec_name, cfg->name); 12514cc2dcf9SEric Biggers return -EOVERFLOW; 1252da5ffe11SJussi Kivilinna } 1253da5ffe11SJussi Kivilinna 1254da5ffe11SJussi Kivilinna return 0; 1255da5ffe11SJussi Kivilinna } 1256da5ffe11SJussi Kivilinna 12574cc2dcf9SEric Biggers static int test_hash_vec(const char *driver, const struct hash_testvec *vec, 12584cc2dcf9SEric Biggers unsigned int vec_num, struct ahash_request *req, 12594cc2dcf9SEric Biggers struct test_sglist *tsgl, u8 *hashstate) 12604cc2dcf9SEric Biggers { 1261951d1332SEric Biggers char vec_name[16]; 12624cc2dcf9SEric Biggers unsigned int i; 12634cc2dcf9SEric Biggers int err; 12644cc2dcf9SEric Biggers 1265951d1332SEric Biggers sprintf(vec_name, "%u", vec_num); 1266951d1332SEric Biggers 12674cc2dcf9SEric Biggers for (i = 0; i < ARRAY_SIZE(default_hash_testvec_configs); i++) { 1268951d1332SEric Biggers err = test_hash_vec_cfg(driver, vec, vec_name, 12694cc2dcf9SEric Biggers &default_hash_testvec_configs[i], 12704cc2dcf9SEric Biggers req, tsgl, hashstate); 12714cc2dcf9SEric Biggers if (err) 12724cc2dcf9SEric Biggers return err; 12734cc2dcf9SEric Biggers } 12744cc2dcf9SEric Biggers 12754cc2dcf9SEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 12764cc2dcf9SEric Biggers if (!noextratests) { 12774cc2dcf9SEric Biggers struct testvec_config cfg; 12784cc2dcf9SEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 12794cc2dcf9SEric Biggers 12804cc2dcf9SEric Biggers for (i = 0; i < fuzz_iterations; i++) { 12814cc2dcf9SEric Biggers generate_random_testvec_config(&cfg, cfgname, 12824cc2dcf9SEric Biggers sizeof(cfgname)); 1283951d1332SEric Biggers err = test_hash_vec_cfg(driver, vec, vec_name, &cfg, 12844cc2dcf9SEric Biggers req, tsgl, hashstate); 12854cc2dcf9SEric Biggers if (err) 12864cc2dcf9SEric Biggers return err; 12874cc2dcf9SEric Biggers } 12884cc2dcf9SEric Biggers } 12894cc2dcf9SEric Biggers #endif 12904cc2dcf9SEric Biggers return 0; 12914cc2dcf9SEric Biggers } 12924cc2dcf9SEric Biggers 12939a8a6b3fSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 12949a8a6b3fSEric Biggers /* 12959a8a6b3fSEric Biggers * Generate a hash test vector from the given implementation. 12969a8a6b3fSEric Biggers * Assumes the buffers in 'vec' were already allocated. 12979a8a6b3fSEric Biggers */ 12989a8a6b3fSEric Biggers static void generate_random_hash_testvec(struct crypto_shash *tfm, 12999a8a6b3fSEric Biggers struct hash_testvec *vec, 13009a8a6b3fSEric Biggers unsigned int maxkeysize, 13019a8a6b3fSEric Biggers unsigned int maxdatasize, 13029a8a6b3fSEric Biggers char *name, size_t max_namelen) 13039a8a6b3fSEric Biggers { 13049a8a6b3fSEric Biggers SHASH_DESC_ON_STACK(desc, tfm); 13059a8a6b3fSEric Biggers 13069a8a6b3fSEric Biggers /* Data */ 13079a8a6b3fSEric Biggers vec->psize = generate_random_length(maxdatasize); 13089a8a6b3fSEric Biggers generate_random_bytes((u8 *)vec->plaintext, vec->psize); 13099a8a6b3fSEric Biggers 13109a8a6b3fSEric Biggers /* 13119a8a6b3fSEric Biggers * Key: length in range [1, maxkeysize], but usually choose maxkeysize. 13129a8a6b3fSEric Biggers * If algorithm is unkeyed, then maxkeysize == 0 and set ksize = 0. 13139a8a6b3fSEric Biggers */ 13149a8a6b3fSEric Biggers vec->setkey_error = 0; 13159a8a6b3fSEric Biggers vec->ksize = 0; 13169a8a6b3fSEric Biggers if (maxkeysize) { 13179a8a6b3fSEric Biggers vec->ksize = maxkeysize; 13189a8a6b3fSEric Biggers if (prandom_u32() % 4 == 0) 13199a8a6b3fSEric Biggers vec->ksize = 1 + (prandom_u32() % maxkeysize); 13209a8a6b3fSEric Biggers generate_random_bytes((u8 *)vec->key, vec->ksize); 13219a8a6b3fSEric Biggers 13229a8a6b3fSEric Biggers vec->setkey_error = crypto_shash_setkey(tfm, vec->key, 13239a8a6b3fSEric Biggers vec->ksize); 13249a8a6b3fSEric Biggers /* If the key couldn't be set, no need to continue to digest. */ 13259a8a6b3fSEric Biggers if (vec->setkey_error) 13269a8a6b3fSEric Biggers goto done; 13279a8a6b3fSEric Biggers } 13289a8a6b3fSEric Biggers 13299a8a6b3fSEric Biggers /* Digest */ 13309a8a6b3fSEric Biggers desc->tfm = tfm; 13319a8a6b3fSEric Biggers desc->flags = 0; 13329a8a6b3fSEric Biggers vec->digest_error = crypto_shash_digest(desc, vec->plaintext, 13339a8a6b3fSEric Biggers vec->psize, (u8 *)vec->digest); 13349a8a6b3fSEric Biggers done: 13359a8a6b3fSEric Biggers snprintf(name, max_namelen, "\"random: psize=%u ksize=%u\"", 13369a8a6b3fSEric Biggers vec->psize, vec->ksize); 13379a8a6b3fSEric Biggers } 13389a8a6b3fSEric Biggers 13399a8a6b3fSEric Biggers /* 13409a8a6b3fSEric Biggers * Test the hash algorithm represented by @req against the corresponding generic 13419a8a6b3fSEric Biggers * implementation, if one is available. 13429a8a6b3fSEric Biggers */ 13439a8a6b3fSEric Biggers static int test_hash_vs_generic_impl(const char *driver, 13449a8a6b3fSEric Biggers const char *generic_driver, 13459a8a6b3fSEric Biggers unsigned int maxkeysize, 13469a8a6b3fSEric Biggers struct ahash_request *req, 13479a8a6b3fSEric Biggers struct test_sglist *tsgl, 13489a8a6b3fSEric Biggers u8 *hashstate) 13499a8a6b3fSEric Biggers { 13509a8a6b3fSEric Biggers struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 13519a8a6b3fSEric Biggers const unsigned int digestsize = crypto_ahash_digestsize(tfm); 13529a8a6b3fSEric Biggers const unsigned int blocksize = crypto_ahash_blocksize(tfm); 13539a8a6b3fSEric Biggers const unsigned int maxdatasize = (2 * PAGE_SIZE) - TESTMGR_POISON_LEN; 13549a8a6b3fSEric Biggers const char *algname = crypto_hash_alg_common(tfm)->base.cra_name; 13559a8a6b3fSEric Biggers char _generic_driver[CRYPTO_MAX_ALG_NAME]; 13569a8a6b3fSEric Biggers struct crypto_shash *generic_tfm = NULL; 13579a8a6b3fSEric Biggers unsigned int i; 13589a8a6b3fSEric Biggers struct hash_testvec vec = { 0 }; 13599a8a6b3fSEric Biggers char vec_name[64]; 13609a8a6b3fSEric Biggers struct testvec_config cfg; 13619a8a6b3fSEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 13629a8a6b3fSEric Biggers int err; 13639a8a6b3fSEric Biggers 13649a8a6b3fSEric Biggers if (noextratests) 13659a8a6b3fSEric Biggers return 0; 13669a8a6b3fSEric Biggers 13679a8a6b3fSEric Biggers if (!generic_driver) { /* Use default naming convention? */ 13689a8a6b3fSEric Biggers err = build_generic_driver_name(algname, _generic_driver); 13699a8a6b3fSEric Biggers if (err) 13709a8a6b3fSEric Biggers return err; 13719a8a6b3fSEric Biggers generic_driver = _generic_driver; 13729a8a6b3fSEric Biggers } 13739a8a6b3fSEric Biggers 13749a8a6b3fSEric Biggers if (strcmp(generic_driver, driver) == 0) /* Already the generic impl? */ 13759a8a6b3fSEric Biggers return 0; 13769a8a6b3fSEric Biggers 13779a8a6b3fSEric Biggers generic_tfm = crypto_alloc_shash(generic_driver, 0, 0); 13789a8a6b3fSEric Biggers if (IS_ERR(generic_tfm)) { 13799a8a6b3fSEric Biggers err = PTR_ERR(generic_tfm); 13809a8a6b3fSEric Biggers if (err == -ENOENT) { 13819a8a6b3fSEric Biggers pr_warn("alg: hash: skipping comparison tests for %s because %s is unavailable\n", 13829a8a6b3fSEric Biggers driver, generic_driver); 13839a8a6b3fSEric Biggers return 0; 13849a8a6b3fSEric Biggers } 13859a8a6b3fSEric Biggers pr_err("alg: hash: error allocating %s (generic impl of %s): %d\n", 13869a8a6b3fSEric Biggers generic_driver, algname, err); 13879a8a6b3fSEric Biggers return err; 13889a8a6b3fSEric Biggers } 13899a8a6b3fSEric Biggers 13909a8a6b3fSEric Biggers /* Check the algorithm properties for consistency. */ 13919a8a6b3fSEric Biggers 13929a8a6b3fSEric Biggers if (digestsize != crypto_shash_digestsize(generic_tfm)) { 13939a8a6b3fSEric Biggers pr_err("alg: hash: digestsize for %s (%u) doesn't match generic impl (%u)\n", 13949a8a6b3fSEric Biggers driver, digestsize, 13959a8a6b3fSEric Biggers crypto_shash_digestsize(generic_tfm)); 13969a8a6b3fSEric Biggers err = -EINVAL; 13979a8a6b3fSEric Biggers goto out; 13989a8a6b3fSEric Biggers } 13999a8a6b3fSEric Biggers 14009a8a6b3fSEric Biggers if (blocksize != crypto_shash_blocksize(generic_tfm)) { 14019a8a6b3fSEric Biggers pr_err("alg: hash: blocksize for %s (%u) doesn't match generic impl (%u)\n", 14029a8a6b3fSEric Biggers driver, blocksize, crypto_shash_blocksize(generic_tfm)); 14039a8a6b3fSEric Biggers err = -EINVAL; 14049a8a6b3fSEric Biggers goto out; 14059a8a6b3fSEric Biggers } 14069a8a6b3fSEric Biggers 14079a8a6b3fSEric Biggers /* 14089a8a6b3fSEric Biggers * Now generate test vectors using the generic implementation, and test 14099a8a6b3fSEric Biggers * the other implementation against them. 14109a8a6b3fSEric Biggers */ 14119a8a6b3fSEric Biggers 14129a8a6b3fSEric Biggers vec.key = kmalloc(maxkeysize, GFP_KERNEL); 14139a8a6b3fSEric Biggers vec.plaintext = kmalloc(maxdatasize, GFP_KERNEL); 14149a8a6b3fSEric Biggers vec.digest = kmalloc(digestsize, GFP_KERNEL); 14159a8a6b3fSEric Biggers if (!vec.key || !vec.plaintext || !vec.digest) { 14169a8a6b3fSEric Biggers err = -ENOMEM; 14179a8a6b3fSEric Biggers goto out; 14189a8a6b3fSEric Biggers } 14199a8a6b3fSEric Biggers 14209a8a6b3fSEric Biggers for (i = 0; i < fuzz_iterations * 8; i++) { 14219a8a6b3fSEric Biggers generate_random_hash_testvec(generic_tfm, &vec, 14229a8a6b3fSEric Biggers maxkeysize, maxdatasize, 14239a8a6b3fSEric Biggers vec_name, sizeof(vec_name)); 14249a8a6b3fSEric Biggers generate_random_testvec_config(&cfg, cfgname, sizeof(cfgname)); 14259a8a6b3fSEric Biggers 14269a8a6b3fSEric Biggers err = test_hash_vec_cfg(driver, &vec, vec_name, &cfg, 14279a8a6b3fSEric Biggers req, tsgl, hashstate); 14289a8a6b3fSEric Biggers if (err) 14299a8a6b3fSEric Biggers goto out; 14309a8a6b3fSEric Biggers cond_resched(); 14319a8a6b3fSEric Biggers } 14329a8a6b3fSEric Biggers err = 0; 14339a8a6b3fSEric Biggers out: 14349a8a6b3fSEric Biggers kfree(vec.key); 14359a8a6b3fSEric Biggers kfree(vec.plaintext); 14369a8a6b3fSEric Biggers kfree(vec.digest); 14379a8a6b3fSEric Biggers crypto_free_shash(generic_tfm); 14389a8a6b3fSEric Biggers return err; 14399a8a6b3fSEric Biggers } 14409a8a6b3fSEric Biggers #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 14419a8a6b3fSEric Biggers static int test_hash_vs_generic_impl(const char *driver, 14429a8a6b3fSEric Biggers const char *generic_driver, 14439a8a6b3fSEric Biggers unsigned int maxkeysize, 14449a8a6b3fSEric Biggers struct ahash_request *req, 14459a8a6b3fSEric Biggers struct test_sglist *tsgl, 14469a8a6b3fSEric Biggers u8 *hashstate) 14479a8a6b3fSEric Biggers { 14489a8a6b3fSEric Biggers return 0; 14499a8a6b3fSEric Biggers } 14509a8a6b3fSEric Biggers #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 14519a8a6b3fSEric Biggers 14524cc2dcf9SEric Biggers static int __alg_test_hash(const struct hash_testvec *vecs, 14534cc2dcf9SEric Biggers unsigned int num_vecs, const char *driver, 14549a8a6b3fSEric Biggers u32 type, u32 mask, 14559a8a6b3fSEric Biggers const char *generic_driver, unsigned int maxkeysize) 14564cc2dcf9SEric Biggers { 14574cc2dcf9SEric Biggers struct crypto_ahash *tfm; 14584cc2dcf9SEric Biggers struct ahash_request *req = NULL; 14594cc2dcf9SEric Biggers struct test_sglist *tsgl = NULL; 14604cc2dcf9SEric Biggers u8 *hashstate = NULL; 14614cc2dcf9SEric Biggers unsigned int i; 14624cc2dcf9SEric Biggers int err; 14634cc2dcf9SEric Biggers 14644cc2dcf9SEric Biggers tfm = crypto_alloc_ahash(driver, type, mask); 14654cc2dcf9SEric Biggers if (IS_ERR(tfm)) { 14664cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate transform for %s: %ld\n", 14674cc2dcf9SEric Biggers driver, PTR_ERR(tfm)); 14684cc2dcf9SEric Biggers return PTR_ERR(tfm); 14694cc2dcf9SEric Biggers } 14704cc2dcf9SEric Biggers 14714cc2dcf9SEric Biggers req = ahash_request_alloc(tfm, GFP_KERNEL); 14724cc2dcf9SEric Biggers if (!req) { 14734cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate request for %s\n", 14744cc2dcf9SEric Biggers driver); 14754cc2dcf9SEric Biggers err = -ENOMEM; 14764cc2dcf9SEric Biggers goto out; 14774cc2dcf9SEric Biggers } 14784cc2dcf9SEric Biggers 14794cc2dcf9SEric Biggers tsgl = kmalloc(sizeof(*tsgl), GFP_KERNEL); 14804cc2dcf9SEric Biggers if (!tsgl || init_test_sglist(tsgl) != 0) { 14814cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate test buffers for %s\n", 14824cc2dcf9SEric Biggers driver); 14834cc2dcf9SEric Biggers kfree(tsgl); 14844cc2dcf9SEric Biggers tsgl = NULL; 14854cc2dcf9SEric Biggers err = -ENOMEM; 14864cc2dcf9SEric Biggers goto out; 14874cc2dcf9SEric Biggers } 14884cc2dcf9SEric Biggers 14894cc2dcf9SEric Biggers hashstate = kmalloc(crypto_ahash_statesize(tfm) + TESTMGR_POISON_LEN, 14904cc2dcf9SEric Biggers GFP_KERNEL); 14914cc2dcf9SEric Biggers if (!hashstate) { 14924cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate hash state buffer for %s\n", 14934cc2dcf9SEric Biggers driver); 14944cc2dcf9SEric Biggers err = -ENOMEM; 14954cc2dcf9SEric Biggers goto out; 14964cc2dcf9SEric Biggers } 14974cc2dcf9SEric Biggers 14984cc2dcf9SEric Biggers for (i = 0; i < num_vecs; i++) { 14994cc2dcf9SEric Biggers err = test_hash_vec(driver, &vecs[i], i, req, tsgl, hashstate); 15004cc2dcf9SEric Biggers if (err) 15014cc2dcf9SEric Biggers goto out; 15024cc2dcf9SEric Biggers } 15039a8a6b3fSEric Biggers err = test_hash_vs_generic_impl(driver, generic_driver, maxkeysize, req, 15049a8a6b3fSEric Biggers tsgl, hashstate); 15054cc2dcf9SEric Biggers out: 15064cc2dcf9SEric Biggers kfree(hashstate); 15074cc2dcf9SEric Biggers if (tsgl) { 15084cc2dcf9SEric Biggers destroy_test_sglist(tsgl); 15094cc2dcf9SEric Biggers kfree(tsgl); 15104cc2dcf9SEric Biggers } 15114cc2dcf9SEric Biggers ahash_request_free(req); 15124cc2dcf9SEric Biggers crypto_free_ahash(tfm); 15134cc2dcf9SEric Biggers return err; 15144cc2dcf9SEric Biggers } 15154cc2dcf9SEric Biggers 15164cc2dcf9SEric Biggers static int alg_test_hash(const struct alg_test_desc *desc, const char *driver, 15174cc2dcf9SEric Biggers u32 type, u32 mask) 15184cc2dcf9SEric Biggers { 15194cc2dcf9SEric Biggers const struct hash_testvec *template = desc->suite.hash.vecs; 15204cc2dcf9SEric Biggers unsigned int tcount = desc->suite.hash.count; 15214cc2dcf9SEric Biggers unsigned int nr_unkeyed, nr_keyed; 15229a8a6b3fSEric Biggers unsigned int maxkeysize = 0; 15234cc2dcf9SEric Biggers int err; 15244cc2dcf9SEric Biggers 15254cc2dcf9SEric Biggers /* 15264cc2dcf9SEric Biggers * For OPTIONAL_KEY algorithms, we have to do all the unkeyed tests 15274cc2dcf9SEric Biggers * first, before setting a key on the tfm. To make this easier, we 15284cc2dcf9SEric Biggers * require that the unkeyed test vectors (if any) are listed first. 15294cc2dcf9SEric Biggers */ 15304cc2dcf9SEric Biggers 15314cc2dcf9SEric Biggers for (nr_unkeyed = 0; nr_unkeyed < tcount; nr_unkeyed++) { 15324cc2dcf9SEric Biggers if (template[nr_unkeyed].ksize) 15334cc2dcf9SEric Biggers break; 15344cc2dcf9SEric Biggers } 15354cc2dcf9SEric Biggers for (nr_keyed = 0; nr_unkeyed + nr_keyed < tcount; nr_keyed++) { 15364cc2dcf9SEric Biggers if (!template[nr_unkeyed + nr_keyed].ksize) { 15374cc2dcf9SEric Biggers pr_err("alg: hash: test vectors for %s out of order, " 15384cc2dcf9SEric Biggers "unkeyed ones must come first\n", desc->alg); 15394cc2dcf9SEric Biggers return -EINVAL; 15404cc2dcf9SEric Biggers } 15419a8a6b3fSEric Biggers maxkeysize = max_t(unsigned int, maxkeysize, 15429a8a6b3fSEric Biggers template[nr_unkeyed + nr_keyed].ksize); 15434cc2dcf9SEric Biggers } 15444cc2dcf9SEric Biggers 15454cc2dcf9SEric Biggers err = 0; 15464cc2dcf9SEric Biggers if (nr_unkeyed) { 15479a8a6b3fSEric Biggers err = __alg_test_hash(template, nr_unkeyed, driver, type, mask, 15489a8a6b3fSEric Biggers desc->generic_driver, maxkeysize); 15494cc2dcf9SEric Biggers template += nr_unkeyed; 15504cc2dcf9SEric Biggers } 15514cc2dcf9SEric Biggers 15524cc2dcf9SEric Biggers if (!err && nr_keyed) 15539a8a6b3fSEric Biggers err = __alg_test_hash(template, nr_keyed, driver, type, mask, 15549a8a6b3fSEric Biggers desc->generic_driver, maxkeysize); 15554cc2dcf9SEric Biggers 15564cc2dcf9SEric Biggers return err; 15574cc2dcf9SEric Biggers } 15584cc2dcf9SEric Biggers 1559ed96804fSEric Biggers static int test_aead_vec_cfg(const char *driver, int enc, 1560ed96804fSEric Biggers const struct aead_testvec *vec, 1561951d1332SEric Biggers const char *vec_name, 1562ed96804fSEric Biggers const struct testvec_config *cfg, 1563ed96804fSEric Biggers struct aead_request *req, 1564ed96804fSEric Biggers struct cipher_test_sglists *tsgls) 1565da7f033dSHerbert Xu { 1566ed96804fSEric Biggers struct crypto_aead *tfm = crypto_aead_reqtfm(req); 1567ed96804fSEric Biggers const unsigned int alignmask = crypto_aead_alignmask(tfm); 1568ed96804fSEric Biggers const unsigned int ivsize = crypto_aead_ivsize(tfm); 1569ed96804fSEric Biggers const unsigned int authsize = vec->clen - vec->plen; 1570ed96804fSEric Biggers const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags; 1571ed96804fSEric Biggers const char *op = enc ? "encryption" : "decryption"; 1572ed96804fSEric Biggers DECLARE_CRYPTO_WAIT(wait); 1573ed96804fSEric Biggers u8 _iv[3 * (MAX_ALGAPI_ALIGNMASK + 1) + MAX_IVLEN]; 1574ed96804fSEric Biggers u8 *iv = PTR_ALIGN(&_iv[0], 2 * (MAX_ALGAPI_ALIGNMASK + 1)) + 1575ed96804fSEric Biggers cfg->iv_offset + 1576ed96804fSEric Biggers (cfg->iv_offset_relative_to_alignmask ? alignmask : 0); 1577ed96804fSEric Biggers struct kvec input[2]; 15785283a8eeSEric Biggers int expected_error; 1579ed96804fSEric Biggers int err; 1580f8b0d4d0SHerbert Xu 1581ed96804fSEric Biggers /* Set the key */ 1582ed96804fSEric Biggers if (vec->wk) 1583ed96804fSEric Biggers crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 1584d8a32ac2SJussi Kivilinna else 1585ed96804fSEric Biggers crypto_aead_clear_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 1586ed96804fSEric Biggers err = crypto_aead_setkey(tfm, vec->key, vec->klen); 15875283a8eeSEric Biggers if (err && err != vec->setkey_error) { 1588951d1332SEric Biggers pr_err("alg: aead: %s setkey failed on test vector %s; expected_error=%d, actual_error=%d, flags=%#x\n", 1589951d1332SEric Biggers driver, vec_name, vec->setkey_error, err, 15905283a8eeSEric Biggers crypto_aead_get_flags(tfm)); 1591ed96804fSEric Biggers return err; 1592ed96804fSEric Biggers } 15935283a8eeSEric Biggers if (!err && vec->setkey_error) { 1594951d1332SEric Biggers pr_err("alg: aead: %s setkey unexpectedly succeeded on test vector %s; expected_error=%d\n", 1595951d1332SEric Biggers driver, vec_name, vec->setkey_error); 1596ed96804fSEric Biggers return -EINVAL; 1597ed96804fSEric Biggers } 1598d8a32ac2SJussi Kivilinna 1599ed96804fSEric Biggers /* Set the authentication tag size */ 1600ed96804fSEric Biggers err = crypto_aead_setauthsize(tfm, authsize); 16015283a8eeSEric Biggers if (err && err != vec->setauthsize_error) { 1602951d1332SEric Biggers pr_err("alg: aead: %s setauthsize failed on test vector %s; expected_error=%d, actual_error=%d\n", 1603951d1332SEric Biggers driver, vec_name, vec->setauthsize_error, err); 1604ed96804fSEric Biggers return err; 1605ed96804fSEric Biggers } 16065283a8eeSEric Biggers if (!err && vec->setauthsize_error) { 1607951d1332SEric Biggers pr_err("alg: aead: %s setauthsize unexpectedly succeeded on test vector %s; expected_error=%d\n", 1608951d1332SEric Biggers driver, vec_name, vec->setauthsize_error); 16095283a8eeSEric Biggers return -EINVAL; 16105283a8eeSEric Biggers } 16115283a8eeSEric Biggers 16125283a8eeSEric Biggers if (vec->setkey_error || vec->setauthsize_error) 16135283a8eeSEric Biggers return 0; 1614ed96804fSEric Biggers 1615ed96804fSEric Biggers /* The IV must be copied to a buffer, as the algorithm may modify it */ 1616ed96804fSEric Biggers if (WARN_ON(ivsize > MAX_IVLEN)) 1617ed96804fSEric Biggers return -EINVAL; 1618ed96804fSEric Biggers if (vec->iv) 1619ed96804fSEric Biggers memcpy(iv, vec->iv, ivsize); 1620da7f033dSHerbert Xu else 1621ed96804fSEric Biggers memset(iv, 0, ivsize); 1622da7f033dSHerbert Xu 1623ed96804fSEric Biggers /* Build the src/dst scatterlists */ 1624ed96804fSEric Biggers input[0].iov_base = (void *)vec->assoc; 1625ed96804fSEric Biggers input[0].iov_len = vec->alen; 1626ed96804fSEric Biggers input[1].iov_base = enc ? (void *)vec->ptext : (void *)vec->ctext; 1627ed96804fSEric Biggers input[1].iov_len = enc ? vec->plen : vec->clen; 1628ed96804fSEric Biggers err = build_cipher_test_sglists(tsgls, cfg, alignmask, 1629ed96804fSEric Biggers vec->alen + (enc ? vec->plen : 1630ed96804fSEric Biggers vec->clen), 1631ed96804fSEric Biggers vec->alen + (enc ? vec->clen : 1632ed96804fSEric Biggers vec->plen), 1633ed96804fSEric Biggers input, 2); 1634ed96804fSEric Biggers if (err) { 1635951d1332SEric Biggers pr_err("alg: aead: %s %s: error preparing scatterlists for test vector %s, cfg=\"%s\"\n", 1636951d1332SEric Biggers driver, op, vec_name, cfg->name); 1637ed96804fSEric Biggers return err; 1638da7f033dSHerbert Xu } 1639da7f033dSHerbert Xu 1640ed96804fSEric Biggers /* Do the actual encryption or decryption */ 1641ed96804fSEric Biggers testmgr_poison(req->__ctx, crypto_aead_reqsize(tfm)); 1642ed96804fSEric Biggers aead_request_set_callback(req, req_flags, crypto_req_done, &wait); 1643ed96804fSEric Biggers aead_request_set_crypt(req, tsgls->src.sgl_ptr, tsgls->dst.sgl_ptr, 1644ed96804fSEric Biggers enc ? vec->plen : vec->clen, iv); 1645ed96804fSEric Biggers aead_request_set_ad(req, vec->alen); 16466570737cSEric Biggers if (cfg->nosimd) 16476570737cSEric Biggers crypto_disable_simd_for_test(); 16486570737cSEric Biggers err = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req); 16496570737cSEric Biggers if (cfg->nosimd) 16506570737cSEric Biggers crypto_reenable_simd_for_test(); 16516570737cSEric Biggers err = crypto_wait_req(err, &wait); 165205b1d338SCristian Stoica 1653a6e5ef9bSEric Biggers /* Check that the algorithm didn't overwrite things it shouldn't have */ 1654a6e5ef9bSEric Biggers if (req->cryptlen != (enc ? vec->plen : vec->clen) || 1655a6e5ef9bSEric Biggers req->assoclen != vec->alen || 1656a6e5ef9bSEric Biggers req->iv != iv || 1657a6e5ef9bSEric Biggers req->src != tsgls->src.sgl_ptr || 1658a6e5ef9bSEric Biggers req->dst != tsgls->dst.sgl_ptr || 1659a6e5ef9bSEric Biggers crypto_aead_reqtfm(req) != tfm || 1660a6e5ef9bSEric Biggers req->base.complete != crypto_req_done || 1661a6e5ef9bSEric Biggers req->base.flags != req_flags || 1662a6e5ef9bSEric Biggers req->base.data != &wait) { 1663951d1332SEric Biggers pr_err("alg: aead: %s %s corrupted request struct on test vector %s, cfg=\"%s\"\n", 1664951d1332SEric Biggers driver, op, vec_name, cfg->name); 1665a6e5ef9bSEric Biggers if (req->cryptlen != (enc ? vec->plen : vec->clen)) 1666a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->cryptlen'\n"); 1667a6e5ef9bSEric Biggers if (req->assoclen != vec->alen) 1668a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->assoclen'\n"); 1669a6e5ef9bSEric Biggers if (req->iv != iv) 1670a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->iv'\n"); 1671a6e5ef9bSEric Biggers if (req->src != tsgls->src.sgl_ptr) 1672a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->src'\n"); 1673a6e5ef9bSEric Biggers if (req->dst != tsgls->dst.sgl_ptr) 1674a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->dst'\n"); 1675a6e5ef9bSEric Biggers if (crypto_aead_reqtfm(req) != tfm) 1676a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.tfm'\n"); 1677a6e5ef9bSEric Biggers if (req->base.complete != crypto_req_done) 1678a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.complete'\n"); 1679a6e5ef9bSEric Biggers if (req->base.flags != req_flags) 1680a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.flags'\n"); 1681a6e5ef9bSEric Biggers if (req->base.data != &wait) 1682a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.data'\n"); 1683a6e5ef9bSEric Biggers return -EINVAL; 1684a6e5ef9bSEric Biggers } 1685a6e5ef9bSEric Biggers if (is_test_sglist_corrupted(&tsgls->src)) { 1686951d1332SEric Biggers pr_err("alg: aead: %s %s corrupted src sgl on test vector %s, cfg=\"%s\"\n", 1687951d1332SEric Biggers driver, op, vec_name, cfg->name); 1688a6e5ef9bSEric Biggers return -EINVAL; 1689a6e5ef9bSEric Biggers } 1690a6e5ef9bSEric Biggers if (tsgls->dst.sgl_ptr != tsgls->src.sgl && 1691a6e5ef9bSEric Biggers is_test_sglist_corrupted(&tsgls->dst)) { 1692951d1332SEric Biggers pr_err("alg: aead: %s %s corrupted dst sgl on test vector %s, cfg=\"%s\"\n", 1693951d1332SEric Biggers driver, op, vec_name, cfg->name); 1694a6e5ef9bSEric Biggers return -EINVAL; 1695a6e5ef9bSEric Biggers } 1696a6e5ef9bSEric Biggers 16975283a8eeSEric Biggers /* Check for success or failure */ 16985283a8eeSEric Biggers expected_error = vec->novrfy ? -EBADMSG : vec->crypt_error; 16995283a8eeSEric Biggers if (err) { 17005283a8eeSEric Biggers if (err == expected_error) 17015283a8eeSEric Biggers return 0; 1702951d1332SEric Biggers pr_err("alg: aead: %s %s failed on test vector %s; expected_error=%d, actual_error=%d, cfg=\"%s\"\n", 1703951d1332SEric Biggers driver, op, vec_name, expected_error, err, cfg->name); 17045283a8eeSEric Biggers return err; 17055283a8eeSEric Biggers } 17065283a8eeSEric Biggers if (expected_error) { 1707951d1332SEric Biggers pr_err("alg: aead: %s %s unexpectedly succeeded on test vector %s; expected_error=%d, cfg=\"%s\"\n", 1708951d1332SEric Biggers driver, op, vec_name, expected_error, cfg->name); 17095283a8eeSEric Biggers return -EINVAL; 17105283a8eeSEric Biggers } 17115283a8eeSEric Biggers 1712ed96804fSEric Biggers /* Check for the correct output (ciphertext or plaintext) */ 1713ed96804fSEric Biggers err = verify_correct_output(&tsgls->dst, enc ? vec->ctext : vec->ptext, 1714ed96804fSEric Biggers enc ? vec->clen : vec->plen, 1715ed96804fSEric Biggers vec->alen, enc || !cfg->inplace); 1716ed96804fSEric Biggers if (err == -EOVERFLOW) { 1717951d1332SEric Biggers pr_err("alg: aead: %s %s overran dst buffer on test vector %s, cfg=\"%s\"\n", 1718951d1332SEric Biggers driver, op, vec_name, cfg->name); 1719ed96804fSEric Biggers return err; 172029b77e5dSHoria Geanta } 1721ed96804fSEric Biggers if (err) { 1722951d1332SEric Biggers pr_err("alg: aead: %s %s test failed (wrong result) on test vector %s, cfg=\"%s\"\n", 1723951d1332SEric Biggers driver, op, vec_name, cfg->name); 1724ed96804fSEric Biggers return err; 172558dcf548SJussi Kivilinna } 172658dcf548SJussi Kivilinna 172758dcf548SJussi Kivilinna return 0; 1728d8a32ac2SJussi Kivilinna } 1729d8a32ac2SJussi Kivilinna 1730ed96804fSEric Biggers static int test_aead_vec(const char *driver, int enc, 1731ed96804fSEric Biggers const struct aead_testvec *vec, unsigned int vec_num, 1732ed96804fSEric Biggers struct aead_request *req, 1733ed96804fSEric Biggers struct cipher_test_sglists *tsgls) 1734ed96804fSEric Biggers { 1735951d1332SEric Biggers char vec_name[16]; 1736ed96804fSEric Biggers unsigned int i; 1737ed96804fSEric Biggers int err; 1738ed96804fSEric Biggers 1739ed96804fSEric Biggers if (enc && vec->novrfy) 1740ed96804fSEric Biggers return 0; 1741ed96804fSEric Biggers 1742951d1332SEric Biggers sprintf(vec_name, "%u", vec_num); 1743951d1332SEric Biggers 1744ed96804fSEric Biggers for (i = 0; i < ARRAY_SIZE(default_cipher_testvec_configs); i++) { 1745951d1332SEric Biggers err = test_aead_vec_cfg(driver, enc, vec, vec_name, 1746ed96804fSEric Biggers &default_cipher_testvec_configs[i], 1747ed96804fSEric Biggers req, tsgls); 1748ed96804fSEric Biggers if (err) 1749ed96804fSEric Biggers return err; 1750ed96804fSEric Biggers } 1751ed96804fSEric Biggers 1752ed96804fSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 1753ed96804fSEric Biggers if (!noextratests) { 1754ed96804fSEric Biggers struct testvec_config cfg; 1755ed96804fSEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 1756ed96804fSEric Biggers 1757ed96804fSEric Biggers for (i = 0; i < fuzz_iterations; i++) { 1758ed96804fSEric Biggers generate_random_testvec_config(&cfg, cfgname, 1759ed96804fSEric Biggers sizeof(cfgname)); 1760951d1332SEric Biggers err = test_aead_vec_cfg(driver, enc, vec, vec_name, 1761ed96804fSEric Biggers &cfg, req, tsgls); 1762ed96804fSEric Biggers if (err) 1763ed96804fSEric Biggers return err; 1764ed96804fSEric Biggers } 1765ed96804fSEric Biggers } 1766ed96804fSEric Biggers #endif 1767ed96804fSEric Biggers return 0; 1768ed96804fSEric Biggers } 1769ed96804fSEric Biggers 1770ed96804fSEric Biggers static int test_aead(const char *driver, int enc, 1771ed96804fSEric Biggers const struct aead_test_suite *suite, 1772ed96804fSEric Biggers struct aead_request *req, 1773ed96804fSEric Biggers struct cipher_test_sglists *tsgls) 1774ed96804fSEric Biggers { 1775ed96804fSEric Biggers unsigned int i; 1776ed96804fSEric Biggers int err; 1777ed96804fSEric Biggers 1778ed96804fSEric Biggers for (i = 0; i < suite->count; i++) { 1779ed96804fSEric Biggers err = test_aead_vec(driver, enc, &suite->vecs[i], i, req, 1780ed96804fSEric Biggers tsgls); 1781ed96804fSEric Biggers if (err) 1782ed96804fSEric Biggers return err; 1783ed96804fSEric Biggers } 1784ed96804fSEric Biggers return 0; 1785ed96804fSEric Biggers } 1786ed96804fSEric Biggers 1787ed96804fSEric Biggers static int alg_test_aead(const struct alg_test_desc *desc, const char *driver, 1788ed96804fSEric Biggers u32 type, u32 mask) 1789ed96804fSEric Biggers { 1790ed96804fSEric Biggers const struct aead_test_suite *suite = &desc->suite.aead; 1791ed96804fSEric Biggers struct crypto_aead *tfm; 1792ed96804fSEric Biggers struct aead_request *req = NULL; 1793ed96804fSEric Biggers struct cipher_test_sglists *tsgls = NULL; 1794ed96804fSEric Biggers int err; 1795ed96804fSEric Biggers 1796ed96804fSEric Biggers if (suite->count <= 0) { 1797ed96804fSEric Biggers pr_err("alg: aead: empty test suite for %s\n", driver); 1798ed96804fSEric Biggers return -EINVAL; 1799ed96804fSEric Biggers } 1800ed96804fSEric Biggers 1801ed96804fSEric Biggers tfm = crypto_alloc_aead(driver, type, mask); 1802ed96804fSEric Biggers if (IS_ERR(tfm)) { 1803ed96804fSEric Biggers pr_err("alg: aead: failed to allocate transform for %s: %ld\n", 1804ed96804fSEric Biggers driver, PTR_ERR(tfm)); 1805ed96804fSEric Biggers return PTR_ERR(tfm); 1806ed96804fSEric Biggers } 1807ed96804fSEric Biggers 1808ed96804fSEric Biggers req = aead_request_alloc(tfm, GFP_KERNEL); 1809ed96804fSEric Biggers if (!req) { 1810ed96804fSEric Biggers pr_err("alg: aead: failed to allocate request for %s\n", 1811ed96804fSEric Biggers driver); 1812ed96804fSEric Biggers err = -ENOMEM; 1813ed96804fSEric Biggers goto out; 1814ed96804fSEric Biggers } 1815ed96804fSEric Biggers 1816ed96804fSEric Biggers tsgls = alloc_cipher_test_sglists(); 1817ed96804fSEric Biggers if (!tsgls) { 1818ed96804fSEric Biggers pr_err("alg: aead: failed to allocate test buffers for %s\n", 1819ed96804fSEric Biggers driver); 1820ed96804fSEric Biggers err = -ENOMEM; 1821ed96804fSEric Biggers goto out; 1822ed96804fSEric Biggers } 1823ed96804fSEric Biggers 1824ed96804fSEric Biggers err = test_aead(driver, ENCRYPT, suite, req, tsgls); 1825ed96804fSEric Biggers if (err) 1826ed96804fSEric Biggers goto out; 1827ed96804fSEric Biggers 1828ed96804fSEric Biggers err = test_aead(driver, DECRYPT, suite, req, tsgls); 1829ed96804fSEric Biggers out: 1830ed96804fSEric Biggers free_cipher_test_sglists(tsgls); 1831ed96804fSEric Biggers aead_request_free(req); 1832ed96804fSEric Biggers crypto_free_aead(tfm); 1833ed96804fSEric Biggers return err; 1834ed96804fSEric Biggers } 1835ed96804fSEric Biggers 18361aa4ecd9SHerbert Xu static int test_cipher(struct crypto_cipher *tfm, int enc, 1837b13b1e0cSEric Biggers const struct cipher_testvec *template, 1838b13b1e0cSEric Biggers unsigned int tcount) 18391aa4ecd9SHerbert Xu { 18401aa4ecd9SHerbert Xu const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm)); 18411aa4ecd9SHerbert Xu unsigned int i, j, k; 18421aa4ecd9SHerbert Xu char *q; 18431aa4ecd9SHerbert Xu const char *e; 184492a4c9feSEric Biggers const char *input, *result; 18451aa4ecd9SHerbert Xu void *data; 1846f8b0d4d0SHerbert Xu char *xbuf[XBUFSIZE]; 1847f8b0d4d0SHerbert Xu int ret = -ENOMEM; 1848f8b0d4d0SHerbert Xu 1849f8b0d4d0SHerbert Xu if (testmgr_alloc_buf(xbuf)) 1850f8b0d4d0SHerbert Xu goto out_nobuf; 18511aa4ecd9SHerbert Xu 18521aa4ecd9SHerbert Xu if (enc == ENCRYPT) 18531aa4ecd9SHerbert Xu e = "encryption"; 18541aa4ecd9SHerbert Xu else 18551aa4ecd9SHerbert Xu e = "decryption"; 18561aa4ecd9SHerbert Xu 18571aa4ecd9SHerbert Xu j = 0; 18581aa4ecd9SHerbert Xu for (i = 0; i < tcount; i++) { 18591aa4ecd9SHerbert Xu 186010faa8c0SStephan Mueller if (fips_enabled && template[i].fips_skip) 186110faa8c0SStephan Mueller continue; 186210faa8c0SStephan Mueller 186392a4c9feSEric Biggers input = enc ? template[i].ptext : template[i].ctext; 186492a4c9feSEric Biggers result = enc ? template[i].ctext : template[i].ptext; 18651aa4ecd9SHerbert Xu j++; 18661aa4ecd9SHerbert Xu 1867fd57f22aSHerbert Xu ret = -EINVAL; 186892a4c9feSEric Biggers if (WARN_ON(template[i].len > PAGE_SIZE)) 1869fd57f22aSHerbert Xu goto out; 1870fd57f22aSHerbert Xu 18711aa4ecd9SHerbert Xu data = xbuf[0]; 187292a4c9feSEric Biggers memcpy(data, input, template[i].len); 18731aa4ecd9SHerbert Xu 18741aa4ecd9SHerbert Xu crypto_cipher_clear_flags(tfm, ~0); 18751aa4ecd9SHerbert Xu if (template[i].wk) 1876231baecdSEric Biggers crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 18771aa4ecd9SHerbert Xu 18781aa4ecd9SHerbert Xu ret = crypto_cipher_setkey(tfm, template[i].key, 18791aa4ecd9SHerbert Xu template[i].klen); 18805283a8eeSEric Biggers if (ret) { 18815283a8eeSEric Biggers if (ret == template[i].setkey_error) 18821aa4ecd9SHerbert Xu continue; 18835283a8eeSEric Biggers pr_err("alg: cipher: %s setkey failed on test vector %u; expected_error=%d, actual_error=%d, flags=%#x\n", 18845283a8eeSEric Biggers algo, j, template[i].setkey_error, ret, 18855283a8eeSEric Biggers crypto_cipher_get_flags(tfm)); 18865283a8eeSEric Biggers goto out; 18875283a8eeSEric Biggers } 18885283a8eeSEric Biggers if (template[i].setkey_error) { 18895283a8eeSEric Biggers pr_err("alg: cipher: %s setkey unexpectedly succeeded on test vector %u; expected_error=%d\n", 18905283a8eeSEric Biggers algo, j, template[i].setkey_error); 18915283a8eeSEric Biggers ret = -EINVAL; 18925283a8eeSEric Biggers goto out; 18935283a8eeSEric Biggers } 18941aa4ecd9SHerbert Xu 189592a4c9feSEric Biggers for (k = 0; k < template[i].len; 18961aa4ecd9SHerbert Xu k += crypto_cipher_blocksize(tfm)) { 18971aa4ecd9SHerbert Xu if (enc) 18981aa4ecd9SHerbert Xu crypto_cipher_encrypt_one(tfm, data + k, 18991aa4ecd9SHerbert Xu data + k); 19001aa4ecd9SHerbert Xu else 19011aa4ecd9SHerbert Xu crypto_cipher_decrypt_one(tfm, data + k, 19021aa4ecd9SHerbert Xu data + k); 19031aa4ecd9SHerbert Xu } 19041aa4ecd9SHerbert Xu 19051aa4ecd9SHerbert Xu q = data; 190692a4c9feSEric Biggers if (memcmp(q, result, template[i].len)) { 19071aa4ecd9SHerbert Xu printk(KERN_ERR "alg: cipher: Test %d failed " 19081aa4ecd9SHerbert Xu "on %s for %s\n", j, e, algo); 190992a4c9feSEric Biggers hexdump(q, template[i].len); 19101aa4ecd9SHerbert Xu ret = -EINVAL; 19111aa4ecd9SHerbert Xu goto out; 19121aa4ecd9SHerbert Xu } 19131aa4ecd9SHerbert Xu } 19141aa4ecd9SHerbert Xu 19151aa4ecd9SHerbert Xu ret = 0; 19161aa4ecd9SHerbert Xu 19171aa4ecd9SHerbert Xu out: 1918f8b0d4d0SHerbert Xu testmgr_free_buf(xbuf); 1919f8b0d4d0SHerbert Xu out_nobuf: 19201aa4ecd9SHerbert Xu return ret; 19211aa4ecd9SHerbert Xu } 19221aa4ecd9SHerbert Xu 19234e7babbaSEric Biggers static int test_skcipher_vec_cfg(const char *driver, int enc, 19244e7babbaSEric Biggers const struct cipher_testvec *vec, 1925951d1332SEric Biggers const char *vec_name, 19264e7babbaSEric Biggers const struct testvec_config *cfg, 19274e7babbaSEric Biggers struct skcipher_request *req, 19284e7babbaSEric Biggers struct cipher_test_sglists *tsgls) 1929da7f033dSHerbert Xu { 19304e7babbaSEric Biggers struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 19314e7babbaSEric Biggers const unsigned int alignmask = crypto_skcipher_alignmask(tfm); 19324e7babbaSEric Biggers const unsigned int ivsize = crypto_skcipher_ivsize(tfm); 19334e7babbaSEric Biggers const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags; 19344e7babbaSEric Biggers const char *op = enc ? "encryption" : "decryption"; 19354e7babbaSEric Biggers DECLARE_CRYPTO_WAIT(wait); 19364e7babbaSEric Biggers u8 _iv[3 * (MAX_ALGAPI_ALIGNMASK + 1) + MAX_IVLEN]; 19374e7babbaSEric Biggers u8 *iv = PTR_ALIGN(&_iv[0], 2 * (MAX_ALGAPI_ALIGNMASK + 1)) + 19384e7babbaSEric Biggers cfg->iv_offset + 19394e7babbaSEric Biggers (cfg->iv_offset_relative_to_alignmask ? alignmask : 0); 19404e7babbaSEric Biggers struct kvec input; 19414e7babbaSEric Biggers int err; 1942f8b0d4d0SHerbert Xu 19434e7babbaSEric Biggers /* Set the key */ 19444e7babbaSEric Biggers if (vec->wk) 1945231baecdSEric Biggers crypto_skcipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 1946da7f033dSHerbert Xu else 19474e7babbaSEric Biggers crypto_skcipher_clear_flags(tfm, 19484e7babbaSEric Biggers CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 19494e7babbaSEric Biggers err = crypto_skcipher_setkey(tfm, vec->key, vec->klen); 19504e7babbaSEric Biggers if (err) { 19515283a8eeSEric Biggers if (err == vec->setkey_error) 19524e7babbaSEric Biggers return 0; 1953951d1332SEric Biggers pr_err("alg: skcipher: %s setkey failed on test vector %s; expected_error=%d, actual_error=%d, flags=%#x\n", 1954951d1332SEric Biggers driver, vec_name, vec->setkey_error, err, 19555283a8eeSEric Biggers crypto_skcipher_get_flags(tfm)); 19564e7babbaSEric Biggers return err; 19574e7babbaSEric Biggers } 19585283a8eeSEric Biggers if (vec->setkey_error) { 1959951d1332SEric Biggers pr_err("alg: skcipher: %s setkey unexpectedly succeeded on test vector %s; expected_error=%d\n", 1960951d1332SEric Biggers driver, vec_name, vec->setkey_error); 19614e7babbaSEric Biggers return -EINVAL; 196208d6af8cSJussi Kivilinna } 1963da7f033dSHerbert Xu 19644e7babbaSEric Biggers /* The IV must be copied to a buffer, as the algorithm may modify it */ 19654e7babbaSEric Biggers if (ivsize) { 19664e7babbaSEric Biggers if (WARN_ON(ivsize > MAX_IVLEN)) 19674e7babbaSEric Biggers return -EINVAL; 19688efd972eSEric Biggers if (vec->generates_iv && !enc) 19698efd972eSEric Biggers memcpy(iv, vec->iv_out, ivsize); 19708efd972eSEric Biggers else if (vec->iv) 19714e7babbaSEric Biggers memcpy(iv, vec->iv, ivsize); 197208d6af8cSJussi Kivilinna else 19734e7babbaSEric Biggers memset(iv, 0, ivsize); 19744e7babbaSEric Biggers } else { 19754e7babbaSEric Biggers if (vec->generates_iv) { 1976951d1332SEric Biggers pr_err("alg: skcipher: %s has ivsize=0 but test vector %s generates IV!\n", 1977951d1332SEric Biggers driver, vec_name); 19784e7babbaSEric Biggers return -EINVAL; 19794e7babbaSEric Biggers } 19804e7babbaSEric Biggers iv = NULL; 1981da7f033dSHerbert Xu } 1982da7f033dSHerbert Xu 19834e7babbaSEric Biggers /* Build the src/dst scatterlists */ 19844e7babbaSEric Biggers input.iov_base = enc ? (void *)vec->ptext : (void *)vec->ctext; 19854e7babbaSEric Biggers input.iov_len = vec->len; 19864e7babbaSEric Biggers err = build_cipher_test_sglists(tsgls, cfg, alignmask, 19874e7babbaSEric Biggers vec->len, vec->len, &input, 1); 19884e7babbaSEric Biggers if (err) { 1989951d1332SEric Biggers pr_err("alg: skcipher: %s %s: error preparing scatterlists for test vector %s, cfg=\"%s\"\n", 1990951d1332SEric Biggers driver, op, vec_name, cfg->name); 19914e7babbaSEric Biggers return err; 1992da7f033dSHerbert Xu } 1993da7f033dSHerbert Xu 19944e7babbaSEric Biggers /* Do the actual encryption or decryption */ 19954e7babbaSEric Biggers testmgr_poison(req->__ctx, crypto_skcipher_reqsize(tfm)); 19964e7babbaSEric Biggers skcipher_request_set_callback(req, req_flags, crypto_req_done, &wait); 19974e7babbaSEric Biggers skcipher_request_set_crypt(req, tsgls->src.sgl_ptr, tsgls->dst.sgl_ptr, 19984e7babbaSEric Biggers vec->len, iv); 19996570737cSEric Biggers if (cfg->nosimd) 20006570737cSEric Biggers crypto_disable_simd_for_test(); 20016570737cSEric Biggers err = enc ? crypto_skcipher_encrypt(req) : crypto_skcipher_decrypt(req); 20026570737cSEric Biggers if (cfg->nosimd) 20036570737cSEric Biggers crypto_reenable_simd_for_test(); 20046570737cSEric Biggers err = crypto_wait_req(err, &wait); 2005da7f033dSHerbert Xu 2006fa353c99SEric Biggers /* Check that the algorithm didn't overwrite things it shouldn't have */ 2007fa353c99SEric Biggers if (req->cryptlen != vec->len || 2008fa353c99SEric Biggers req->iv != iv || 2009fa353c99SEric Biggers req->src != tsgls->src.sgl_ptr || 2010fa353c99SEric Biggers req->dst != tsgls->dst.sgl_ptr || 2011fa353c99SEric Biggers crypto_skcipher_reqtfm(req) != tfm || 2012fa353c99SEric Biggers req->base.complete != crypto_req_done || 2013fa353c99SEric Biggers req->base.flags != req_flags || 2014fa353c99SEric Biggers req->base.data != &wait) { 2015951d1332SEric Biggers pr_err("alg: skcipher: %s %s corrupted request struct on test vector %s, cfg=\"%s\"\n", 2016951d1332SEric Biggers driver, op, vec_name, cfg->name); 2017fa353c99SEric Biggers if (req->cryptlen != vec->len) 2018fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->cryptlen'\n"); 2019fa353c99SEric Biggers if (req->iv != iv) 2020fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->iv'\n"); 2021fa353c99SEric Biggers if (req->src != tsgls->src.sgl_ptr) 2022fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->src'\n"); 2023fa353c99SEric Biggers if (req->dst != tsgls->dst.sgl_ptr) 2024fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->dst'\n"); 2025fa353c99SEric Biggers if (crypto_skcipher_reqtfm(req) != tfm) 2026fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.tfm'\n"); 2027fa353c99SEric Biggers if (req->base.complete != crypto_req_done) 2028fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.complete'\n"); 2029fa353c99SEric Biggers if (req->base.flags != req_flags) 2030fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.flags'\n"); 2031fa353c99SEric Biggers if (req->base.data != &wait) 2032fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.data'\n"); 2033fa353c99SEric Biggers return -EINVAL; 2034fa353c99SEric Biggers } 2035fa353c99SEric Biggers if (is_test_sglist_corrupted(&tsgls->src)) { 2036951d1332SEric Biggers pr_err("alg: skcipher: %s %s corrupted src sgl on test vector %s, cfg=\"%s\"\n", 2037951d1332SEric Biggers driver, op, vec_name, cfg->name); 2038fa353c99SEric Biggers return -EINVAL; 2039fa353c99SEric Biggers } 2040fa353c99SEric Biggers if (tsgls->dst.sgl_ptr != tsgls->src.sgl && 2041fa353c99SEric Biggers is_test_sglist_corrupted(&tsgls->dst)) { 2042951d1332SEric Biggers pr_err("alg: skcipher: %s %s corrupted dst sgl on test vector %s, cfg=\"%s\"\n", 2043951d1332SEric Biggers driver, op, vec_name, cfg->name); 2044fa353c99SEric Biggers return -EINVAL; 2045fa353c99SEric Biggers } 2046fa353c99SEric Biggers 20475283a8eeSEric Biggers /* Check for success or failure */ 20485283a8eeSEric Biggers if (err) { 20495283a8eeSEric Biggers if (err == vec->crypt_error) 20505283a8eeSEric Biggers return 0; 2051951d1332SEric Biggers pr_err("alg: skcipher: %s %s failed on test vector %s; expected_error=%d, actual_error=%d, cfg=\"%s\"\n", 2052951d1332SEric Biggers driver, op, vec_name, vec->crypt_error, err, cfg->name); 20535283a8eeSEric Biggers return err; 20545283a8eeSEric Biggers } 20555283a8eeSEric Biggers if (vec->crypt_error) { 2056951d1332SEric Biggers pr_err("alg: skcipher: %s %s unexpectedly succeeded on test vector %s; expected_error=%d, cfg=\"%s\"\n", 2057951d1332SEric Biggers driver, op, vec_name, vec->crypt_error, cfg->name); 20585283a8eeSEric Biggers return -EINVAL; 20595283a8eeSEric Biggers } 20605283a8eeSEric Biggers 20614e7babbaSEric Biggers /* Check for the correct output (ciphertext or plaintext) */ 20624e7babbaSEric Biggers err = verify_correct_output(&tsgls->dst, enc ? vec->ctext : vec->ptext, 20634e7babbaSEric Biggers vec->len, 0, true); 20644e7babbaSEric Biggers if (err == -EOVERFLOW) { 2065951d1332SEric Biggers pr_err("alg: skcipher: %s %s overran dst buffer on test vector %s, cfg=\"%s\"\n", 2066951d1332SEric Biggers driver, op, vec_name, cfg->name); 20674e7babbaSEric Biggers return err; 20684e7babbaSEric Biggers } 20694e7babbaSEric Biggers if (err) { 2070951d1332SEric Biggers pr_err("alg: skcipher: %s %s test failed (wrong result) on test vector %s, cfg=\"%s\"\n", 2071951d1332SEric Biggers driver, op, vec_name, cfg->name); 20724e7babbaSEric Biggers return err; 20734e7babbaSEric Biggers } 207408d6af8cSJussi Kivilinna 20754e7babbaSEric Biggers /* If applicable, check that the algorithm generated the correct IV */ 20768efd972eSEric Biggers if (vec->iv_out && memcmp(iv, vec->iv_out, ivsize) != 0) { 2077951d1332SEric Biggers pr_err("alg: skcipher: %s %s test failed (wrong output IV) on test vector %s, cfg=\"%s\"\n", 2078951d1332SEric Biggers driver, op, vec_name, cfg->name); 20794e7babbaSEric Biggers hexdump(iv, ivsize); 20804e7babbaSEric Biggers return -EINVAL; 20813a338f20SJussi Kivilinna } 20823a338f20SJussi Kivilinna 20833a338f20SJussi Kivilinna return 0; 208408d6af8cSJussi Kivilinna } 208508d6af8cSJussi Kivilinna 20864e7babbaSEric Biggers static int test_skcipher_vec(const char *driver, int enc, 20874e7babbaSEric Biggers const struct cipher_testvec *vec, 20884e7babbaSEric Biggers unsigned int vec_num, 20894e7babbaSEric Biggers struct skcipher_request *req, 20904e7babbaSEric Biggers struct cipher_test_sglists *tsgls) 20914e7babbaSEric Biggers { 2092951d1332SEric Biggers char vec_name[16]; 20934e7babbaSEric Biggers unsigned int i; 20944e7babbaSEric Biggers int err; 20954e7babbaSEric Biggers 20964e7babbaSEric Biggers if (fips_enabled && vec->fips_skip) 20974e7babbaSEric Biggers return 0; 20984e7babbaSEric Biggers 2099951d1332SEric Biggers sprintf(vec_name, "%u", vec_num); 2100951d1332SEric Biggers 21014e7babbaSEric Biggers for (i = 0; i < ARRAY_SIZE(default_cipher_testvec_configs); i++) { 2102951d1332SEric Biggers err = test_skcipher_vec_cfg(driver, enc, vec, vec_name, 21034e7babbaSEric Biggers &default_cipher_testvec_configs[i], 21044e7babbaSEric Biggers req, tsgls); 21054e7babbaSEric Biggers if (err) 21064e7babbaSEric Biggers return err; 21074e7babbaSEric Biggers } 21084e7babbaSEric Biggers 21094e7babbaSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 21104e7babbaSEric Biggers if (!noextratests) { 21114e7babbaSEric Biggers struct testvec_config cfg; 21124e7babbaSEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 21134e7babbaSEric Biggers 21144e7babbaSEric Biggers for (i = 0; i < fuzz_iterations; i++) { 21154e7babbaSEric Biggers generate_random_testvec_config(&cfg, cfgname, 21164e7babbaSEric Biggers sizeof(cfgname)); 2117951d1332SEric Biggers err = test_skcipher_vec_cfg(driver, enc, vec, vec_name, 21184e7babbaSEric Biggers &cfg, req, tsgls); 21194e7babbaSEric Biggers if (err) 21204e7babbaSEric Biggers return err; 21214e7babbaSEric Biggers } 21224e7babbaSEric Biggers } 21234e7babbaSEric Biggers #endif 21244e7babbaSEric Biggers return 0; 21254e7babbaSEric Biggers } 21264e7babbaSEric Biggers 21274e7babbaSEric Biggers static int test_skcipher(const char *driver, int enc, 21284e7babbaSEric Biggers const struct cipher_test_suite *suite, 21294e7babbaSEric Biggers struct skcipher_request *req, 21304e7babbaSEric Biggers struct cipher_test_sglists *tsgls) 21314e7babbaSEric Biggers { 21324e7babbaSEric Biggers unsigned int i; 21334e7babbaSEric Biggers int err; 21344e7babbaSEric Biggers 21354e7babbaSEric Biggers for (i = 0; i < suite->count; i++) { 21364e7babbaSEric Biggers err = test_skcipher_vec(driver, enc, &suite->vecs[i], i, req, 21374e7babbaSEric Biggers tsgls); 21384e7babbaSEric Biggers if (err) 21394e7babbaSEric Biggers return err; 21404e7babbaSEric Biggers } 21414e7babbaSEric Biggers return 0; 21424e7babbaSEric Biggers } 21434e7babbaSEric Biggers 21444e7babbaSEric Biggers static int alg_test_skcipher(const struct alg_test_desc *desc, 21454e7babbaSEric Biggers const char *driver, u32 type, u32 mask) 21464e7babbaSEric Biggers { 21474e7babbaSEric Biggers const struct cipher_test_suite *suite = &desc->suite.cipher; 21484e7babbaSEric Biggers struct crypto_skcipher *tfm; 21494e7babbaSEric Biggers struct skcipher_request *req = NULL; 21504e7babbaSEric Biggers struct cipher_test_sglists *tsgls = NULL; 21514e7babbaSEric Biggers int err; 21524e7babbaSEric Biggers 21534e7babbaSEric Biggers if (suite->count <= 0) { 21544e7babbaSEric Biggers pr_err("alg: skcipher: empty test suite for %s\n", driver); 21554e7babbaSEric Biggers return -EINVAL; 21564e7babbaSEric Biggers } 21574e7babbaSEric Biggers 21584e7babbaSEric Biggers tfm = crypto_alloc_skcipher(driver, type, mask); 21594e7babbaSEric Biggers if (IS_ERR(tfm)) { 21604e7babbaSEric Biggers pr_err("alg: skcipher: failed to allocate transform for %s: %ld\n", 21614e7babbaSEric Biggers driver, PTR_ERR(tfm)); 21624e7babbaSEric Biggers return PTR_ERR(tfm); 21634e7babbaSEric Biggers } 21644e7babbaSEric Biggers 21654e7babbaSEric Biggers req = skcipher_request_alloc(tfm, GFP_KERNEL); 21664e7babbaSEric Biggers if (!req) { 21674e7babbaSEric Biggers pr_err("alg: skcipher: failed to allocate request for %s\n", 21684e7babbaSEric Biggers driver); 21694e7babbaSEric Biggers err = -ENOMEM; 21704e7babbaSEric Biggers goto out; 21714e7babbaSEric Biggers } 21724e7babbaSEric Biggers 21734e7babbaSEric Biggers tsgls = alloc_cipher_test_sglists(); 21744e7babbaSEric Biggers if (!tsgls) { 21754e7babbaSEric Biggers pr_err("alg: skcipher: failed to allocate test buffers for %s\n", 21764e7babbaSEric Biggers driver); 21774e7babbaSEric Biggers err = -ENOMEM; 21784e7babbaSEric Biggers goto out; 21794e7babbaSEric Biggers } 21804e7babbaSEric Biggers 21814e7babbaSEric Biggers err = test_skcipher(driver, ENCRYPT, suite, req, tsgls); 21824e7babbaSEric Biggers if (err) 21834e7babbaSEric Biggers goto out; 21844e7babbaSEric Biggers 21854e7babbaSEric Biggers err = test_skcipher(driver, DECRYPT, suite, req, tsgls); 21864e7babbaSEric Biggers out: 21874e7babbaSEric Biggers free_cipher_test_sglists(tsgls); 21884e7babbaSEric Biggers skcipher_request_free(req); 21894e7babbaSEric Biggers crypto_free_skcipher(tfm); 21904e7babbaSEric Biggers return err; 21914e7babbaSEric Biggers } 21924e7babbaSEric Biggers 2193b13b1e0cSEric Biggers static int test_comp(struct crypto_comp *tfm, 2194b13b1e0cSEric Biggers const struct comp_testvec *ctemplate, 2195b13b1e0cSEric Biggers const struct comp_testvec *dtemplate, 2196b13b1e0cSEric Biggers int ctcount, int dtcount) 2197da7f033dSHerbert Xu { 2198da7f033dSHerbert Xu const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm)); 219933607384SMahipal Challa char *output, *decomp_output; 2200da7f033dSHerbert Xu unsigned int i; 2201da7f033dSHerbert Xu int ret; 2202da7f033dSHerbert Xu 220333607384SMahipal Challa output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 220433607384SMahipal Challa if (!output) 220533607384SMahipal Challa return -ENOMEM; 220633607384SMahipal Challa 220733607384SMahipal Challa decomp_output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 220833607384SMahipal Challa if (!decomp_output) { 220933607384SMahipal Challa kfree(output); 221033607384SMahipal Challa return -ENOMEM; 221133607384SMahipal Challa } 221233607384SMahipal Challa 2213da7f033dSHerbert Xu for (i = 0; i < ctcount; i++) { 2214c79cf910SGeert Uytterhoeven int ilen; 2215c79cf910SGeert Uytterhoeven unsigned int dlen = COMP_BUF_SIZE; 2216da7f033dSHerbert Xu 221722a8118dSMichael Schupikov memset(output, 0, COMP_BUF_SIZE); 221822a8118dSMichael Schupikov memset(decomp_output, 0, COMP_BUF_SIZE); 2219da7f033dSHerbert Xu 2220da7f033dSHerbert Xu ilen = ctemplate[i].inlen; 2221da7f033dSHerbert Xu ret = crypto_comp_compress(tfm, ctemplate[i].input, 222233607384SMahipal Challa ilen, output, &dlen); 2223da7f033dSHerbert Xu if (ret) { 2224da7f033dSHerbert Xu printk(KERN_ERR "alg: comp: compression failed " 2225da7f033dSHerbert Xu "on test %d for %s: ret=%d\n", i + 1, algo, 2226da7f033dSHerbert Xu -ret); 2227da7f033dSHerbert Xu goto out; 2228da7f033dSHerbert Xu } 2229da7f033dSHerbert Xu 223033607384SMahipal Challa ilen = dlen; 223133607384SMahipal Challa dlen = COMP_BUF_SIZE; 223233607384SMahipal Challa ret = crypto_comp_decompress(tfm, output, 223333607384SMahipal Challa ilen, decomp_output, &dlen); 223433607384SMahipal Challa if (ret) { 223533607384SMahipal Challa pr_err("alg: comp: compression failed: decompress: on test %d for %s failed: ret=%d\n", 223633607384SMahipal Challa i + 1, algo, -ret); 223733607384SMahipal Challa goto out; 223833607384SMahipal Challa } 223933607384SMahipal Challa 224033607384SMahipal Challa if (dlen != ctemplate[i].inlen) { 2241b812eb00SGeert Uytterhoeven printk(KERN_ERR "alg: comp: Compression test %d " 2242b812eb00SGeert Uytterhoeven "failed for %s: output len = %d\n", i + 1, algo, 2243b812eb00SGeert Uytterhoeven dlen); 2244b812eb00SGeert Uytterhoeven ret = -EINVAL; 2245b812eb00SGeert Uytterhoeven goto out; 2246b812eb00SGeert Uytterhoeven } 2247b812eb00SGeert Uytterhoeven 224833607384SMahipal Challa if (memcmp(decomp_output, ctemplate[i].input, 224933607384SMahipal Challa ctemplate[i].inlen)) { 225033607384SMahipal Challa pr_err("alg: comp: compression failed: output differs: on test %d for %s\n", 225133607384SMahipal Challa i + 1, algo); 225233607384SMahipal Challa hexdump(decomp_output, dlen); 2253da7f033dSHerbert Xu ret = -EINVAL; 2254da7f033dSHerbert Xu goto out; 2255da7f033dSHerbert Xu } 2256da7f033dSHerbert Xu } 2257da7f033dSHerbert Xu 2258da7f033dSHerbert Xu for (i = 0; i < dtcount; i++) { 2259c79cf910SGeert Uytterhoeven int ilen; 2260c79cf910SGeert Uytterhoeven unsigned int dlen = COMP_BUF_SIZE; 2261da7f033dSHerbert Xu 226222a8118dSMichael Schupikov memset(decomp_output, 0, COMP_BUF_SIZE); 2263da7f033dSHerbert Xu 2264da7f033dSHerbert Xu ilen = dtemplate[i].inlen; 2265da7f033dSHerbert Xu ret = crypto_comp_decompress(tfm, dtemplate[i].input, 226633607384SMahipal Challa ilen, decomp_output, &dlen); 2267da7f033dSHerbert Xu if (ret) { 2268da7f033dSHerbert Xu printk(KERN_ERR "alg: comp: decompression failed " 2269da7f033dSHerbert Xu "on test %d for %s: ret=%d\n", i + 1, algo, 2270da7f033dSHerbert Xu -ret); 2271da7f033dSHerbert Xu goto out; 2272da7f033dSHerbert Xu } 2273da7f033dSHerbert Xu 2274b812eb00SGeert Uytterhoeven if (dlen != dtemplate[i].outlen) { 2275b812eb00SGeert Uytterhoeven printk(KERN_ERR "alg: comp: Decompression test %d " 2276b812eb00SGeert Uytterhoeven "failed for %s: output len = %d\n", i + 1, algo, 2277b812eb00SGeert Uytterhoeven dlen); 2278b812eb00SGeert Uytterhoeven ret = -EINVAL; 2279b812eb00SGeert Uytterhoeven goto out; 2280b812eb00SGeert Uytterhoeven } 2281b812eb00SGeert Uytterhoeven 228233607384SMahipal Challa if (memcmp(decomp_output, dtemplate[i].output, dlen)) { 2283da7f033dSHerbert Xu printk(KERN_ERR "alg: comp: Decompression test %d " 2284da7f033dSHerbert Xu "failed for %s\n", i + 1, algo); 228533607384SMahipal Challa hexdump(decomp_output, dlen); 2286da7f033dSHerbert Xu ret = -EINVAL; 2287da7f033dSHerbert Xu goto out; 2288da7f033dSHerbert Xu } 2289da7f033dSHerbert Xu } 2290da7f033dSHerbert Xu 2291da7f033dSHerbert Xu ret = 0; 2292da7f033dSHerbert Xu 2293da7f033dSHerbert Xu out: 229433607384SMahipal Challa kfree(decomp_output); 229533607384SMahipal Challa kfree(output); 2296da7f033dSHerbert Xu return ret; 2297da7f033dSHerbert Xu } 2298da7f033dSHerbert Xu 2299b13b1e0cSEric Biggers static int test_acomp(struct crypto_acomp *tfm, 2300b13b1e0cSEric Biggers const struct comp_testvec *ctemplate, 2301b13b1e0cSEric Biggers const struct comp_testvec *dtemplate, 2302b13b1e0cSEric Biggers int ctcount, int dtcount) 2303d7db7a88SGiovanni Cabiddu { 2304d7db7a88SGiovanni Cabiddu const char *algo = crypto_tfm_alg_driver_name(crypto_acomp_tfm(tfm)); 2305d7db7a88SGiovanni Cabiddu unsigned int i; 2306a9943a0aSGiovanni Cabiddu char *output, *decomp_out; 2307d7db7a88SGiovanni Cabiddu int ret; 2308d7db7a88SGiovanni Cabiddu struct scatterlist src, dst; 2309d7db7a88SGiovanni Cabiddu struct acomp_req *req; 23107f397136SGilad Ben-Yossef struct crypto_wait wait; 2311d7db7a88SGiovanni Cabiddu 2312eb095593SEric Biggers output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 2313eb095593SEric Biggers if (!output) 2314eb095593SEric Biggers return -ENOMEM; 2315eb095593SEric Biggers 2316a9943a0aSGiovanni Cabiddu decomp_out = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 2317a9943a0aSGiovanni Cabiddu if (!decomp_out) { 2318a9943a0aSGiovanni Cabiddu kfree(output); 2319a9943a0aSGiovanni Cabiddu return -ENOMEM; 2320a9943a0aSGiovanni Cabiddu } 2321a9943a0aSGiovanni Cabiddu 2322d7db7a88SGiovanni Cabiddu for (i = 0; i < ctcount; i++) { 2323d7db7a88SGiovanni Cabiddu unsigned int dlen = COMP_BUF_SIZE; 2324d7db7a88SGiovanni Cabiddu int ilen = ctemplate[i].inlen; 232502608e02SLaura Abbott void *input_vec; 2326d7db7a88SGiovanni Cabiddu 2327d2110224SEric Biggers input_vec = kmemdup(ctemplate[i].input, ilen, GFP_KERNEL); 232802608e02SLaura Abbott if (!input_vec) { 232902608e02SLaura Abbott ret = -ENOMEM; 233002608e02SLaura Abbott goto out; 233102608e02SLaura Abbott } 233202608e02SLaura Abbott 2333eb095593SEric Biggers memset(output, 0, dlen); 23347f397136SGilad Ben-Yossef crypto_init_wait(&wait); 233502608e02SLaura Abbott sg_init_one(&src, input_vec, ilen); 2336d7db7a88SGiovanni Cabiddu sg_init_one(&dst, output, dlen); 2337d7db7a88SGiovanni Cabiddu 2338d7db7a88SGiovanni Cabiddu req = acomp_request_alloc(tfm); 2339d7db7a88SGiovanni Cabiddu if (!req) { 2340d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: request alloc failed for %s\n", 2341d7db7a88SGiovanni Cabiddu algo); 234202608e02SLaura Abbott kfree(input_vec); 2343d7db7a88SGiovanni Cabiddu ret = -ENOMEM; 2344d7db7a88SGiovanni Cabiddu goto out; 2345d7db7a88SGiovanni Cabiddu } 2346d7db7a88SGiovanni Cabiddu 2347d7db7a88SGiovanni Cabiddu acomp_request_set_params(req, &src, &dst, ilen, dlen); 2348d7db7a88SGiovanni Cabiddu acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 23497f397136SGilad Ben-Yossef crypto_req_done, &wait); 2350d7db7a88SGiovanni Cabiddu 23517f397136SGilad Ben-Yossef ret = crypto_wait_req(crypto_acomp_compress(req), &wait); 2352d7db7a88SGiovanni Cabiddu if (ret) { 2353d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n", 2354d7db7a88SGiovanni Cabiddu i + 1, algo, -ret); 235502608e02SLaura Abbott kfree(input_vec); 2356d7db7a88SGiovanni Cabiddu acomp_request_free(req); 2357d7db7a88SGiovanni Cabiddu goto out; 2358d7db7a88SGiovanni Cabiddu } 2359d7db7a88SGiovanni Cabiddu 2360a9943a0aSGiovanni Cabiddu ilen = req->dlen; 2361a9943a0aSGiovanni Cabiddu dlen = COMP_BUF_SIZE; 2362a9943a0aSGiovanni Cabiddu sg_init_one(&src, output, ilen); 2363a9943a0aSGiovanni Cabiddu sg_init_one(&dst, decomp_out, dlen); 23647f397136SGilad Ben-Yossef crypto_init_wait(&wait); 2365a9943a0aSGiovanni Cabiddu acomp_request_set_params(req, &src, &dst, ilen, dlen); 2366a9943a0aSGiovanni Cabiddu 23677f397136SGilad Ben-Yossef ret = crypto_wait_req(crypto_acomp_decompress(req), &wait); 2368a9943a0aSGiovanni Cabiddu if (ret) { 2369a9943a0aSGiovanni Cabiddu pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n", 2370a9943a0aSGiovanni Cabiddu i + 1, algo, -ret); 2371a9943a0aSGiovanni Cabiddu kfree(input_vec); 2372a9943a0aSGiovanni Cabiddu acomp_request_free(req); 2373a9943a0aSGiovanni Cabiddu goto out; 2374a9943a0aSGiovanni Cabiddu } 2375a9943a0aSGiovanni Cabiddu 2376a9943a0aSGiovanni Cabiddu if (req->dlen != ctemplate[i].inlen) { 2377d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Compression test %d failed for %s: output len = %d\n", 2378d7db7a88SGiovanni Cabiddu i + 1, algo, req->dlen); 2379d7db7a88SGiovanni Cabiddu ret = -EINVAL; 238002608e02SLaura Abbott kfree(input_vec); 2381d7db7a88SGiovanni Cabiddu acomp_request_free(req); 2382d7db7a88SGiovanni Cabiddu goto out; 2383d7db7a88SGiovanni Cabiddu } 2384d7db7a88SGiovanni Cabiddu 2385a9943a0aSGiovanni Cabiddu if (memcmp(input_vec, decomp_out, req->dlen)) { 2386d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Compression test %d failed for %s\n", 2387d7db7a88SGiovanni Cabiddu i + 1, algo); 2388d7db7a88SGiovanni Cabiddu hexdump(output, req->dlen); 2389d7db7a88SGiovanni Cabiddu ret = -EINVAL; 239002608e02SLaura Abbott kfree(input_vec); 2391d7db7a88SGiovanni Cabiddu acomp_request_free(req); 2392d7db7a88SGiovanni Cabiddu goto out; 2393d7db7a88SGiovanni Cabiddu } 2394d7db7a88SGiovanni Cabiddu 239502608e02SLaura Abbott kfree(input_vec); 2396d7db7a88SGiovanni Cabiddu acomp_request_free(req); 2397d7db7a88SGiovanni Cabiddu } 2398d7db7a88SGiovanni Cabiddu 2399d7db7a88SGiovanni Cabiddu for (i = 0; i < dtcount; i++) { 2400d7db7a88SGiovanni Cabiddu unsigned int dlen = COMP_BUF_SIZE; 2401d7db7a88SGiovanni Cabiddu int ilen = dtemplate[i].inlen; 240202608e02SLaura Abbott void *input_vec; 2403d7db7a88SGiovanni Cabiddu 2404d2110224SEric Biggers input_vec = kmemdup(dtemplate[i].input, ilen, GFP_KERNEL); 240502608e02SLaura Abbott if (!input_vec) { 240602608e02SLaura Abbott ret = -ENOMEM; 240702608e02SLaura Abbott goto out; 240802608e02SLaura Abbott } 240902608e02SLaura Abbott 2410eb095593SEric Biggers memset(output, 0, dlen); 24117f397136SGilad Ben-Yossef crypto_init_wait(&wait); 241202608e02SLaura Abbott sg_init_one(&src, input_vec, ilen); 2413d7db7a88SGiovanni Cabiddu sg_init_one(&dst, output, dlen); 2414d7db7a88SGiovanni Cabiddu 2415d7db7a88SGiovanni Cabiddu req = acomp_request_alloc(tfm); 2416d7db7a88SGiovanni Cabiddu if (!req) { 2417d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: request alloc failed for %s\n", 2418d7db7a88SGiovanni Cabiddu algo); 241902608e02SLaura Abbott kfree(input_vec); 2420d7db7a88SGiovanni Cabiddu ret = -ENOMEM; 2421d7db7a88SGiovanni Cabiddu goto out; 2422d7db7a88SGiovanni Cabiddu } 2423d7db7a88SGiovanni Cabiddu 2424d7db7a88SGiovanni Cabiddu acomp_request_set_params(req, &src, &dst, ilen, dlen); 2425d7db7a88SGiovanni Cabiddu acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 24267f397136SGilad Ben-Yossef crypto_req_done, &wait); 2427d7db7a88SGiovanni Cabiddu 24287f397136SGilad Ben-Yossef ret = crypto_wait_req(crypto_acomp_decompress(req), &wait); 2429d7db7a88SGiovanni Cabiddu if (ret) { 2430d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: decompression failed on test %d for %s: ret=%d\n", 2431d7db7a88SGiovanni Cabiddu i + 1, algo, -ret); 243202608e02SLaura Abbott kfree(input_vec); 2433d7db7a88SGiovanni Cabiddu acomp_request_free(req); 2434d7db7a88SGiovanni Cabiddu goto out; 2435d7db7a88SGiovanni Cabiddu } 2436d7db7a88SGiovanni Cabiddu 2437d7db7a88SGiovanni Cabiddu if (req->dlen != dtemplate[i].outlen) { 2438d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Decompression test %d failed for %s: output len = %d\n", 2439d7db7a88SGiovanni Cabiddu i + 1, algo, req->dlen); 2440d7db7a88SGiovanni Cabiddu ret = -EINVAL; 244102608e02SLaura Abbott kfree(input_vec); 2442d7db7a88SGiovanni Cabiddu acomp_request_free(req); 2443d7db7a88SGiovanni Cabiddu goto out; 2444d7db7a88SGiovanni Cabiddu } 2445d7db7a88SGiovanni Cabiddu 2446d7db7a88SGiovanni Cabiddu if (memcmp(output, dtemplate[i].output, req->dlen)) { 2447d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Decompression test %d failed for %s\n", 2448d7db7a88SGiovanni Cabiddu i + 1, algo); 2449d7db7a88SGiovanni Cabiddu hexdump(output, req->dlen); 2450d7db7a88SGiovanni Cabiddu ret = -EINVAL; 245102608e02SLaura Abbott kfree(input_vec); 2452d7db7a88SGiovanni Cabiddu acomp_request_free(req); 2453d7db7a88SGiovanni Cabiddu goto out; 2454d7db7a88SGiovanni Cabiddu } 2455d7db7a88SGiovanni Cabiddu 245602608e02SLaura Abbott kfree(input_vec); 2457d7db7a88SGiovanni Cabiddu acomp_request_free(req); 2458d7db7a88SGiovanni Cabiddu } 2459d7db7a88SGiovanni Cabiddu 2460d7db7a88SGiovanni Cabiddu ret = 0; 2461d7db7a88SGiovanni Cabiddu 2462d7db7a88SGiovanni Cabiddu out: 2463a9943a0aSGiovanni Cabiddu kfree(decomp_out); 2464eb095593SEric Biggers kfree(output); 2465d7db7a88SGiovanni Cabiddu return ret; 2466d7db7a88SGiovanni Cabiddu } 2467d7db7a88SGiovanni Cabiddu 2468b13b1e0cSEric Biggers static int test_cprng(struct crypto_rng *tfm, 2469b13b1e0cSEric Biggers const struct cprng_testvec *template, 24707647d6ceSJarod Wilson unsigned int tcount) 24717647d6ceSJarod Wilson { 24727647d6ceSJarod Wilson const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm)); 2473fa4ef8a6SFelipe Contreras int err = 0, i, j, seedsize; 24747647d6ceSJarod Wilson u8 *seed; 24757647d6ceSJarod Wilson char result[32]; 24767647d6ceSJarod Wilson 24777647d6ceSJarod Wilson seedsize = crypto_rng_seedsize(tfm); 24787647d6ceSJarod Wilson 24797647d6ceSJarod Wilson seed = kmalloc(seedsize, GFP_KERNEL); 24807647d6ceSJarod Wilson if (!seed) { 24817647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to allocate seed space " 24827647d6ceSJarod Wilson "for %s\n", algo); 24837647d6ceSJarod Wilson return -ENOMEM; 24847647d6ceSJarod Wilson } 24857647d6ceSJarod Wilson 24867647d6ceSJarod Wilson for (i = 0; i < tcount; i++) { 24877647d6ceSJarod Wilson memset(result, 0, 32); 24887647d6ceSJarod Wilson 24897647d6ceSJarod Wilson memcpy(seed, template[i].v, template[i].vlen); 24907647d6ceSJarod Wilson memcpy(seed + template[i].vlen, template[i].key, 24917647d6ceSJarod Wilson template[i].klen); 24927647d6ceSJarod Wilson memcpy(seed + template[i].vlen + template[i].klen, 24937647d6ceSJarod Wilson template[i].dt, template[i].dtlen); 24947647d6ceSJarod Wilson 24957647d6ceSJarod Wilson err = crypto_rng_reset(tfm, seed, seedsize); 24967647d6ceSJarod Wilson if (err) { 24977647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to reset rng " 24987647d6ceSJarod Wilson "for %s\n", algo); 24997647d6ceSJarod Wilson goto out; 25007647d6ceSJarod Wilson } 25017647d6ceSJarod Wilson 25027647d6ceSJarod Wilson for (j = 0; j < template[i].loops; j++) { 25037647d6ceSJarod Wilson err = crypto_rng_get_bytes(tfm, result, 25047647d6ceSJarod Wilson template[i].rlen); 250519e60e13SStephan Mueller if (err < 0) { 25067647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to obtain " 25077647d6ceSJarod Wilson "the correct amount of random data for " 250819e60e13SStephan Mueller "%s (requested %d)\n", algo, 250919e60e13SStephan Mueller template[i].rlen); 25107647d6ceSJarod Wilson goto out; 25117647d6ceSJarod Wilson } 25127647d6ceSJarod Wilson } 25137647d6ceSJarod Wilson 25147647d6ceSJarod Wilson err = memcmp(result, template[i].result, 25157647d6ceSJarod Wilson template[i].rlen); 25167647d6ceSJarod Wilson if (err) { 25177647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Test %d failed for %s\n", 25187647d6ceSJarod Wilson i, algo); 25197647d6ceSJarod Wilson hexdump(result, template[i].rlen); 25207647d6ceSJarod Wilson err = -EINVAL; 25217647d6ceSJarod Wilson goto out; 25227647d6ceSJarod Wilson } 25237647d6ceSJarod Wilson } 25247647d6ceSJarod Wilson 25257647d6ceSJarod Wilson out: 25267647d6ceSJarod Wilson kfree(seed); 25277647d6ceSJarod Wilson return err; 25287647d6ceSJarod Wilson } 25297647d6ceSJarod Wilson 2530da7f033dSHerbert Xu static int alg_test_cipher(const struct alg_test_desc *desc, 2531da7f033dSHerbert Xu const char *driver, u32 type, u32 mask) 2532da7f033dSHerbert Xu { 253392a4c9feSEric Biggers const struct cipher_test_suite *suite = &desc->suite.cipher; 25341aa4ecd9SHerbert Xu struct crypto_cipher *tfm; 253592a4c9feSEric Biggers int err; 2536da7f033dSHerbert Xu 2537eed93e0cSHerbert Xu tfm = crypto_alloc_cipher(driver, type, mask); 2538da7f033dSHerbert Xu if (IS_ERR(tfm)) { 2539da7f033dSHerbert Xu printk(KERN_ERR "alg: cipher: Failed to load transform for " 2540da7f033dSHerbert Xu "%s: %ld\n", driver, PTR_ERR(tfm)); 2541da7f033dSHerbert Xu return PTR_ERR(tfm); 2542da7f033dSHerbert Xu } 2543da7f033dSHerbert Xu 254492a4c9feSEric Biggers err = test_cipher(tfm, ENCRYPT, suite->vecs, suite->count); 254592a4c9feSEric Biggers if (!err) 254692a4c9feSEric Biggers err = test_cipher(tfm, DECRYPT, suite->vecs, suite->count); 2547da7f033dSHerbert Xu 25481aa4ecd9SHerbert Xu crypto_free_cipher(tfm); 25491aa4ecd9SHerbert Xu return err; 25501aa4ecd9SHerbert Xu } 25511aa4ecd9SHerbert Xu 2552da7f033dSHerbert Xu static int alg_test_comp(const struct alg_test_desc *desc, const char *driver, 2553da7f033dSHerbert Xu u32 type, u32 mask) 2554da7f033dSHerbert Xu { 2555d7db7a88SGiovanni Cabiddu struct crypto_comp *comp; 2556d7db7a88SGiovanni Cabiddu struct crypto_acomp *acomp; 2557da7f033dSHerbert Xu int err; 2558d7db7a88SGiovanni Cabiddu u32 algo_type = type & CRYPTO_ALG_TYPE_ACOMPRESS_MASK; 2559da7f033dSHerbert Xu 2560d7db7a88SGiovanni Cabiddu if (algo_type == CRYPTO_ALG_TYPE_ACOMPRESS) { 2561d7db7a88SGiovanni Cabiddu acomp = crypto_alloc_acomp(driver, type, mask); 2562d7db7a88SGiovanni Cabiddu if (IS_ERR(acomp)) { 2563d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Failed to load transform for %s: %ld\n", 2564d7db7a88SGiovanni Cabiddu driver, PTR_ERR(acomp)); 2565d7db7a88SGiovanni Cabiddu return PTR_ERR(acomp); 2566d7db7a88SGiovanni Cabiddu } 2567d7db7a88SGiovanni Cabiddu err = test_acomp(acomp, desc->suite.comp.comp.vecs, 2568d7db7a88SGiovanni Cabiddu desc->suite.comp.decomp.vecs, 2569d7db7a88SGiovanni Cabiddu desc->suite.comp.comp.count, 2570d7db7a88SGiovanni Cabiddu desc->suite.comp.decomp.count); 2571d7db7a88SGiovanni Cabiddu crypto_free_acomp(acomp); 2572d7db7a88SGiovanni Cabiddu } else { 2573d7db7a88SGiovanni Cabiddu comp = crypto_alloc_comp(driver, type, mask); 2574d7db7a88SGiovanni Cabiddu if (IS_ERR(comp)) { 2575d7db7a88SGiovanni Cabiddu pr_err("alg: comp: Failed to load transform for %s: %ld\n", 2576d7db7a88SGiovanni Cabiddu driver, PTR_ERR(comp)); 2577d7db7a88SGiovanni Cabiddu return PTR_ERR(comp); 2578da7f033dSHerbert Xu } 2579da7f033dSHerbert Xu 2580d7db7a88SGiovanni Cabiddu err = test_comp(comp, desc->suite.comp.comp.vecs, 2581da7f033dSHerbert Xu desc->suite.comp.decomp.vecs, 2582da7f033dSHerbert Xu desc->suite.comp.comp.count, 2583da7f033dSHerbert Xu desc->suite.comp.decomp.count); 2584da7f033dSHerbert Xu 2585d7db7a88SGiovanni Cabiddu crypto_free_comp(comp); 2586d7db7a88SGiovanni Cabiddu } 2587da7f033dSHerbert Xu return err; 2588da7f033dSHerbert Xu } 2589da7f033dSHerbert Xu 25908e3ee85eSHerbert Xu static int alg_test_crc32c(const struct alg_test_desc *desc, 25918e3ee85eSHerbert Xu const char *driver, u32 type, u32 mask) 25928e3ee85eSHerbert Xu { 25938e3ee85eSHerbert Xu struct crypto_shash *tfm; 2594cb9dde88SEric Biggers __le32 val; 25958e3ee85eSHerbert Xu int err; 25968e3ee85eSHerbert Xu 25978e3ee85eSHerbert Xu err = alg_test_hash(desc, driver, type, mask); 25988e3ee85eSHerbert Xu if (err) 2599eb5e6730SEric Biggers return err; 26008e3ee85eSHerbert Xu 2601eed93e0cSHerbert Xu tfm = crypto_alloc_shash(driver, type, mask); 26028e3ee85eSHerbert Xu if (IS_ERR(tfm)) { 2603eb5e6730SEric Biggers if (PTR_ERR(tfm) == -ENOENT) { 2604eb5e6730SEric Biggers /* 2605eb5e6730SEric Biggers * This crc32c implementation is only available through 2606eb5e6730SEric Biggers * ahash API, not the shash API, so the remaining part 2607eb5e6730SEric Biggers * of the test is not applicable to it. 2608eb5e6730SEric Biggers */ 2609eb5e6730SEric Biggers return 0; 2610eb5e6730SEric Biggers } 26118e3ee85eSHerbert Xu printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: " 26128e3ee85eSHerbert Xu "%ld\n", driver, PTR_ERR(tfm)); 2613eb5e6730SEric Biggers return PTR_ERR(tfm); 26148e3ee85eSHerbert Xu } 26158e3ee85eSHerbert Xu 26168e3ee85eSHerbert Xu do { 26174c5c3024SJan-Simon Möller SHASH_DESC_ON_STACK(shash, tfm); 26184c5c3024SJan-Simon Möller u32 *ctx = (u32 *)shash_desc_ctx(shash); 26198e3ee85eSHerbert Xu 26204c5c3024SJan-Simon Möller shash->tfm = tfm; 26214c5c3024SJan-Simon Möller shash->flags = 0; 26228e3ee85eSHerbert Xu 2623cb9dde88SEric Biggers *ctx = 420553207; 26244c5c3024SJan-Simon Möller err = crypto_shash_final(shash, (u8 *)&val); 26258e3ee85eSHerbert Xu if (err) { 26268e3ee85eSHerbert Xu printk(KERN_ERR "alg: crc32c: Operation failed for " 26278e3ee85eSHerbert Xu "%s: %d\n", driver, err); 26288e3ee85eSHerbert Xu break; 26298e3ee85eSHerbert Xu } 26308e3ee85eSHerbert Xu 2631cb9dde88SEric Biggers if (val != cpu_to_le32(~420553207)) { 2632cb9dde88SEric Biggers pr_err("alg: crc32c: Test failed for %s: %u\n", 2633cb9dde88SEric Biggers driver, le32_to_cpu(val)); 26348e3ee85eSHerbert Xu err = -EINVAL; 26358e3ee85eSHerbert Xu } 26368e3ee85eSHerbert Xu } while (0); 26378e3ee85eSHerbert Xu 26388e3ee85eSHerbert Xu crypto_free_shash(tfm); 26398e3ee85eSHerbert Xu 26408e3ee85eSHerbert Xu return err; 26418e3ee85eSHerbert Xu } 26428e3ee85eSHerbert Xu 26437647d6ceSJarod Wilson static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver, 26447647d6ceSJarod Wilson u32 type, u32 mask) 26457647d6ceSJarod Wilson { 26467647d6ceSJarod Wilson struct crypto_rng *rng; 26477647d6ceSJarod Wilson int err; 26487647d6ceSJarod Wilson 2649eed93e0cSHerbert Xu rng = crypto_alloc_rng(driver, type, mask); 26507647d6ceSJarod Wilson if (IS_ERR(rng)) { 26517647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to load transform for %s: " 26527647d6ceSJarod Wilson "%ld\n", driver, PTR_ERR(rng)); 26537647d6ceSJarod Wilson return PTR_ERR(rng); 26547647d6ceSJarod Wilson } 26557647d6ceSJarod Wilson 26567647d6ceSJarod Wilson err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count); 26577647d6ceSJarod Wilson 26587647d6ceSJarod Wilson crypto_free_rng(rng); 26597647d6ceSJarod Wilson 26607647d6ceSJarod Wilson return err; 26617647d6ceSJarod Wilson } 26627647d6ceSJarod Wilson 266364d1cdfbSStephan Mueller 2664b13b1e0cSEric Biggers static int drbg_cavs_test(const struct drbg_testvec *test, int pr, 266564d1cdfbSStephan Mueller const char *driver, u32 type, u32 mask) 266664d1cdfbSStephan Mueller { 266764d1cdfbSStephan Mueller int ret = -EAGAIN; 266864d1cdfbSStephan Mueller struct crypto_rng *drng; 266964d1cdfbSStephan Mueller struct drbg_test_data test_data; 267064d1cdfbSStephan Mueller struct drbg_string addtl, pers, testentropy; 267164d1cdfbSStephan Mueller unsigned char *buf = kzalloc(test->expectedlen, GFP_KERNEL); 267264d1cdfbSStephan Mueller 267364d1cdfbSStephan Mueller if (!buf) 267464d1cdfbSStephan Mueller return -ENOMEM; 267564d1cdfbSStephan Mueller 2676eed93e0cSHerbert Xu drng = crypto_alloc_rng(driver, type, mask); 267764d1cdfbSStephan Mueller if (IS_ERR(drng)) { 267864d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: could not allocate DRNG handle for " 267964d1cdfbSStephan Mueller "%s\n", driver); 268064d1cdfbSStephan Mueller kzfree(buf); 268164d1cdfbSStephan Mueller return -ENOMEM; 268264d1cdfbSStephan Mueller } 268364d1cdfbSStephan Mueller 268464d1cdfbSStephan Mueller test_data.testentropy = &testentropy; 268564d1cdfbSStephan Mueller drbg_string_fill(&testentropy, test->entropy, test->entropylen); 268664d1cdfbSStephan Mueller drbg_string_fill(&pers, test->pers, test->perslen); 268764d1cdfbSStephan Mueller ret = crypto_drbg_reset_test(drng, &pers, &test_data); 268864d1cdfbSStephan Mueller if (ret) { 268964d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: Failed to reset rng\n"); 269064d1cdfbSStephan Mueller goto outbuf; 269164d1cdfbSStephan Mueller } 269264d1cdfbSStephan Mueller 269364d1cdfbSStephan Mueller drbg_string_fill(&addtl, test->addtla, test->addtllen); 269464d1cdfbSStephan Mueller if (pr) { 269564d1cdfbSStephan Mueller drbg_string_fill(&testentropy, test->entpra, test->entprlen); 269664d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl_test(drng, 269764d1cdfbSStephan Mueller buf, test->expectedlen, &addtl, &test_data); 269864d1cdfbSStephan Mueller } else { 269964d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl(drng, 270064d1cdfbSStephan Mueller buf, test->expectedlen, &addtl); 270164d1cdfbSStephan Mueller } 270219e60e13SStephan Mueller if (ret < 0) { 270364d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: could not obtain random data for " 270464d1cdfbSStephan Mueller "driver %s\n", driver); 270564d1cdfbSStephan Mueller goto outbuf; 270664d1cdfbSStephan Mueller } 270764d1cdfbSStephan Mueller 270864d1cdfbSStephan Mueller drbg_string_fill(&addtl, test->addtlb, test->addtllen); 270964d1cdfbSStephan Mueller if (pr) { 271064d1cdfbSStephan Mueller drbg_string_fill(&testentropy, test->entprb, test->entprlen); 271164d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl_test(drng, 271264d1cdfbSStephan Mueller buf, test->expectedlen, &addtl, &test_data); 271364d1cdfbSStephan Mueller } else { 271464d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl(drng, 271564d1cdfbSStephan Mueller buf, test->expectedlen, &addtl); 271664d1cdfbSStephan Mueller } 271719e60e13SStephan Mueller if (ret < 0) { 271864d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: could not obtain random data for " 271964d1cdfbSStephan Mueller "driver %s\n", driver); 272064d1cdfbSStephan Mueller goto outbuf; 272164d1cdfbSStephan Mueller } 272264d1cdfbSStephan Mueller 272364d1cdfbSStephan Mueller ret = memcmp(test->expected, buf, test->expectedlen); 272464d1cdfbSStephan Mueller 272564d1cdfbSStephan Mueller outbuf: 272664d1cdfbSStephan Mueller crypto_free_rng(drng); 272764d1cdfbSStephan Mueller kzfree(buf); 272864d1cdfbSStephan Mueller return ret; 272964d1cdfbSStephan Mueller } 273064d1cdfbSStephan Mueller 273164d1cdfbSStephan Mueller 273264d1cdfbSStephan Mueller static int alg_test_drbg(const struct alg_test_desc *desc, const char *driver, 273364d1cdfbSStephan Mueller u32 type, u32 mask) 273464d1cdfbSStephan Mueller { 273564d1cdfbSStephan Mueller int err = 0; 273664d1cdfbSStephan Mueller int pr = 0; 273764d1cdfbSStephan Mueller int i = 0; 2738b13b1e0cSEric Biggers const struct drbg_testvec *template = desc->suite.drbg.vecs; 273964d1cdfbSStephan Mueller unsigned int tcount = desc->suite.drbg.count; 274064d1cdfbSStephan Mueller 274164d1cdfbSStephan Mueller if (0 == memcmp(driver, "drbg_pr_", 8)) 274264d1cdfbSStephan Mueller pr = 1; 274364d1cdfbSStephan Mueller 274464d1cdfbSStephan Mueller for (i = 0; i < tcount; i++) { 274564d1cdfbSStephan Mueller err = drbg_cavs_test(&template[i], pr, driver, type, mask); 274664d1cdfbSStephan Mueller if (err) { 274764d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: Test %d failed for %s\n", 274864d1cdfbSStephan Mueller i, driver); 274964d1cdfbSStephan Mueller err = -EINVAL; 275064d1cdfbSStephan Mueller break; 275164d1cdfbSStephan Mueller } 275264d1cdfbSStephan Mueller } 275364d1cdfbSStephan Mueller return err; 275464d1cdfbSStephan Mueller 275564d1cdfbSStephan Mueller } 275664d1cdfbSStephan Mueller 2757b13b1e0cSEric Biggers static int do_test_kpp(struct crypto_kpp *tfm, const struct kpp_testvec *vec, 2758802c7f1cSSalvatore Benedetto const char *alg) 2759802c7f1cSSalvatore Benedetto { 2760802c7f1cSSalvatore Benedetto struct kpp_request *req; 2761802c7f1cSSalvatore Benedetto void *input_buf = NULL; 2762802c7f1cSSalvatore Benedetto void *output_buf = NULL; 276347d3fd39STudor-Dan Ambarus void *a_public = NULL; 276447d3fd39STudor-Dan Ambarus void *a_ss = NULL; 276547d3fd39STudor-Dan Ambarus void *shared_secret = NULL; 27667f397136SGilad Ben-Yossef struct crypto_wait wait; 2767802c7f1cSSalvatore Benedetto unsigned int out_len_max; 2768802c7f1cSSalvatore Benedetto int err = -ENOMEM; 2769802c7f1cSSalvatore Benedetto struct scatterlist src, dst; 2770802c7f1cSSalvatore Benedetto 2771802c7f1cSSalvatore Benedetto req = kpp_request_alloc(tfm, GFP_KERNEL); 2772802c7f1cSSalvatore Benedetto if (!req) 2773802c7f1cSSalvatore Benedetto return err; 2774802c7f1cSSalvatore Benedetto 27757f397136SGilad Ben-Yossef crypto_init_wait(&wait); 2776802c7f1cSSalvatore Benedetto 2777802c7f1cSSalvatore Benedetto err = crypto_kpp_set_secret(tfm, vec->secret, vec->secret_size); 2778802c7f1cSSalvatore Benedetto if (err < 0) 2779802c7f1cSSalvatore Benedetto goto free_req; 2780802c7f1cSSalvatore Benedetto 2781802c7f1cSSalvatore Benedetto out_len_max = crypto_kpp_maxsize(tfm); 2782802c7f1cSSalvatore Benedetto output_buf = kzalloc(out_len_max, GFP_KERNEL); 2783802c7f1cSSalvatore Benedetto if (!output_buf) { 2784802c7f1cSSalvatore Benedetto err = -ENOMEM; 2785802c7f1cSSalvatore Benedetto goto free_req; 2786802c7f1cSSalvatore Benedetto } 2787802c7f1cSSalvatore Benedetto 2788802c7f1cSSalvatore Benedetto /* Use appropriate parameter as base */ 2789802c7f1cSSalvatore Benedetto kpp_request_set_input(req, NULL, 0); 2790802c7f1cSSalvatore Benedetto sg_init_one(&dst, output_buf, out_len_max); 2791802c7f1cSSalvatore Benedetto kpp_request_set_output(req, &dst, out_len_max); 2792802c7f1cSSalvatore Benedetto kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 27937f397136SGilad Ben-Yossef crypto_req_done, &wait); 2794802c7f1cSSalvatore Benedetto 279547d3fd39STudor-Dan Ambarus /* Compute party A's public key */ 27967f397136SGilad Ben-Yossef err = crypto_wait_req(crypto_kpp_generate_public_key(req), &wait); 2797802c7f1cSSalvatore Benedetto if (err) { 279847d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party A: generate public key test failed. err %d\n", 2799802c7f1cSSalvatore Benedetto alg, err); 2800802c7f1cSSalvatore Benedetto goto free_output; 2801802c7f1cSSalvatore Benedetto } 280247d3fd39STudor-Dan Ambarus 280347d3fd39STudor-Dan Ambarus if (vec->genkey) { 280447d3fd39STudor-Dan Ambarus /* Save party A's public key */ 2805e3d90e52SChristopher Diaz Riveros a_public = kmemdup(sg_virt(req->dst), out_len_max, GFP_KERNEL); 280647d3fd39STudor-Dan Ambarus if (!a_public) { 280747d3fd39STudor-Dan Ambarus err = -ENOMEM; 280847d3fd39STudor-Dan Ambarus goto free_output; 280947d3fd39STudor-Dan Ambarus } 281047d3fd39STudor-Dan Ambarus } else { 2811802c7f1cSSalvatore Benedetto /* Verify calculated public key */ 2812802c7f1cSSalvatore Benedetto if (memcmp(vec->expected_a_public, sg_virt(req->dst), 2813802c7f1cSSalvatore Benedetto vec->expected_a_public_size)) { 281447d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party A: generate public key test failed. Invalid output\n", 2815802c7f1cSSalvatore Benedetto alg); 2816802c7f1cSSalvatore Benedetto err = -EINVAL; 2817802c7f1cSSalvatore Benedetto goto free_output; 2818802c7f1cSSalvatore Benedetto } 281947d3fd39STudor-Dan Ambarus } 2820802c7f1cSSalvatore Benedetto 2821802c7f1cSSalvatore Benedetto /* Calculate shared secret key by using counter part (b) public key. */ 2822e3d90e52SChristopher Diaz Riveros input_buf = kmemdup(vec->b_public, vec->b_public_size, GFP_KERNEL); 2823802c7f1cSSalvatore Benedetto if (!input_buf) { 2824802c7f1cSSalvatore Benedetto err = -ENOMEM; 2825802c7f1cSSalvatore Benedetto goto free_output; 2826802c7f1cSSalvatore Benedetto } 2827802c7f1cSSalvatore Benedetto 2828802c7f1cSSalvatore Benedetto sg_init_one(&src, input_buf, vec->b_public_size); 2829802c7f1cSSalvatore Benedetto sg_init_one(&dst, output_buf, out_len_max); 2830802c7f1cSSalvatore Benedetto kpp_request_set_input(req, &src, vec->b_public_size); 2831802c7f1cSSalvatore Benedetto kpp_request_set_output(req, &dst, out_len_max); 2832802c7f1cSSalvatore Benedetto kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 28337f397136SGilad Ben-Yossef crypto_req_done, &wait); 28347f397136SGilad Ben-Yossef err = crypto_wait_req(crypto_kpp_compute_shared_secret(req), &wait); 2835802c7f1cSSalvatore Benedetto if (err) { 283647d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party A: compute shared secret test failed. err %d\n", 2837802c7f1cSSalvatore Benedetto alg, err); 2838802c7f1cSSalvatore Benedetto goto free_all; 2839802c7f1cSSalvatore Benedetto } 284047d3fd39STudor-Dan Ambarus 284147d3fd39STudor-Dan Ambarus if (vec->genkey) { 284247d3fd39STudor-Dan Ambarus /* Save the shared secret obtained by party A */ 2843e3d90e52SChristopher Diaz Riveros a_ss = kmemdup(sg_virt(req->dst), vec->expected_ss_size, GFP_KERNEL); 284447d3fd39STudor-Dan Ambarus if (!a_ss) { 284547d3fd39STudor-Dan Ambarus err = -ENOMEM; 284647d3fd39STudor-Dan Ambarus goto free_all; 284747d3fd39STudor-Dan Ambarus } 284847d3fd39STudor-Dan Ambarus 284947d3fd39STudor-Dan Ambarus /* 285047d3fd39STudor-Dan Ambarus * Calculate party B's shared secret by using party A's 285147d3fd39STudor-Dan Ambarus * public key. 285247d3fd39STudor-Dan Ambarus */ 285347d3fd39STudor-Dan Ambarus err = crypto_kpp_set_secret(tfm, vec->b_secret, 285447d3fd39STudor-Dan Ambarus vec->b_secret_size); 285547d3fd39STudor-Dan Ambarus if (err < 0) 285647d3fd39STudor-Dan Ambarus goto free_all; 285747d3fd39STudor-Dan Ambarus 285847d3fd39STudor-Dan Ambarus sg_init_one(&src, a_public, vec->expected_a_public_size); 285947d3fd39STudor-Dan Ambarus sg_init_one(&dst, output_buf, out_len_max); 286047d3fd39STudor-Dan Ambarus kpp_request_set_input(req, &src, vec->expected_a_public_size); 286147d3fd39STudor-Dan Ambarus kpp_request_set_output(req, &dst, out_len_max); 286247d3fd39STudor-Dan Ambarus kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 28637f397136SGilad Ben-Yossef crypto_req_done, &wait); 28647f397136SGilad Ben-Yossef err = crypto_wait_req(crypto_kpp_compute_shared_secret(req), 28657f397136SGilad Ben-Yossef &wait); 286647d3fd39STudor-Dan Ambarus if (err) { 286747d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party B: compute shared secret failed. err %d\n", 286847d3fd39STudor-Dan Ambarus alg, err); 286947d3fd39STudor-Dan Ambarus goto free_all; 287047d3fd39STudor-Dan Ambarus } 287147d3fd39STudor-Dan Ambarus 287247d3fd39STudor-Dan Ambarus shared_secret = a_ss; 287347d3fd39STudor-Dan Ambarus } else { 287447d3fd39STudor-Dan Ambarus shared_secret = (void *)vec->expected_ss; 287547d3fd39STudor-Dan Ambarus } 287647d3fd39STudor-Dan Ambarus 2877802c7f1cSSalvatore Benedetto /* 2878802c7f1cSSalvatore Benedetto * verify shared secret from which the user will derive 2879802c7f1cSSalvatore Benedetto * secret key by executing whatever hash it has chosen 2880802c7f1cSSalvatore Benedetto */ 288147d3fd39STudor-Dan Ambarus if (memcmp(shared_secret, sg_virt(req->dst), 2882802c7f1cSSalvatore Benedetto vec->expected_ss_size)) { 2883802c7f1cSSalvatore Benedetto pr_err("alg: %s: compute shared secret test failed. Invalid output\n", 2884802c7f1cSSalvatore Benedetto alg); 2885802c7f1cSSalvatore Benedetto err = -EINVAL; 2886802c7f1cSSalvatore Benedetto } 2887802c7f1cSSalvatore Benedetto 2888802c7f1cSSalvatore Benedetto free_all: 288947d3fd39STudor-Dan Ambarus kfree(a_ss); 2890802c7f1cSSalvatore Benedetto kfree(input_buf); 2891802c7f1cSSalvatore Benedetto free_output: 289247d3fd39STudor-Dan Ambarus kfree(a_public); 2893802c7f1cSSalvatore Benedetto kfree(output_buf); 2894802c7f1cSSalvatore Benedetto free_req: 2895802c7f1cSSalvatore Benedetto kpp_request_free(req); 2896802c7f1cSSalvatore Benedetto return err; 2897802c7f1cSSalvatore Benedetto } 2898802c7f1cSSalvatore Benedetto 2899802c7f1cSSalvatore Benedetto static int test_kpp(struct crypto_kpp *tfm, const char *alg, 2900b13b1e0cSEric Biggers const struct kpp_testvec *vecs, unsigned int tcount) 2901802c7f1cSSalvatore Benedetto { 2902802c7f1cSSalvatore Benedetto int ret, i; 2903802c7f1cSSalvatore Benedetto 2904802c7f1cSSalvatore Benedetto for (i = 0; i < tcount; i++) { 2905802c7f1cSSalvatore Benedetto ret = do_test_kpp(tfm, vecs++, alg); 2906802c7f1cSSalvatore Benedetto if (ret) { 2907802c7f1cSSalvatore Benedetto pr_err("alg: %s: test failed on vector %d, err=%d\n", 2908802c7f1cSSalvatore Benedetto alg, i + 1, ret); 2909802c7f1cSSalvatore Benedetto return ret; 2910802c7f1cSSalvatore Benedetto } 2911802c7f1cSSalvatore Benedetto } 2912802c7f1cSSalvatore Benedetto return 0; 2913802c7f1cSSalvatore Benedetto } 2914802c7f1cSSalvatore Benedetto 2915802c7f1cSSalvatore Benedetto static int alg_test_kpp(const struct alg_test_desc *desc, const char *driver, 2916802c7f1cSSalvatore Benedetto u32 type, u32 mask) 2917802c7f1cSSalvatore Benedetto { 2918802c7f1cSSalvatore Benedetto struct crypto_kpp *tfm; 2919802c7f1cSSalvatore Benedetto int err = 0; 2920802c7f1cSSalvatore Benedetto 2921eed93e0cSHerbert Xu tfm = crypto_alloc_kpp(driver, type, mask); 2922802c7f1cSSalvatore Benedetto if (IS_ERR(tfm)) { 2923802c7f1cSSalvatore Benedetto pr_err("alg: kpp: Failed to load tfm for %s: %ld\n", 2924802c7f1cSSalvatore Benedetto driver, PTR_ERR(tfm)); 2925802c7f1cSSalvatore Benedetto return PTR_ERR(tfm); 2926802c7f1cSSalvatore Benedetto } 2927802c7f1cSSalvatore Benedetto if (desc->suite.kpp.vecs) 2928802c7f1cSSalvatore Benedetto err = test_kpp(tfm, desc->alg, desc->suite.kpp.vecs, 2929802c7f1cSSalvatore Benedetto desc->suite.kpp.count); 2930802c7f1cSSalvatore Benedetto 2931802c7f1cSSalvatore Benedetto crypto_free_kpp(tfm); 2932802c7f1cSSalvatore Benedetto return err; 2933802c7f1cSSalvatore Benedetto } 2934802c7f1cSSalvatore Benedetto 2935f1774cb8SVitaly Chikunov static u8 *test_pack_u32(u8 *dst, u32 val) 2936f1774cb8SVitaly Chikunov { 2937f1774cb8SVitaly Chikunov memcpy(dst, &val, sizeof(val)); 2938f1774cb8SVitaly Chikunov return dst + sizeof(val); 2939f1774cb8SVitaly Chikunov } 2940f1774cb8SVitaly Chikunov 294150d2b643SHerbert Xu static int test_akcipher_one(struct crypto_akcipher *tfm, 2942b13b1e0cSEric Biggers const struct akcipher_testvec *vecs) 2943946cc463STadeusz Struk { 2944df27b26fSHerbert Xu char *xbuf[XBUFSIZE]; 2945946cc463STadeusz Struk struct akcipher_request *req; 2946946cc463STadeusz Struk void *outbuf_enc = NULL; 2947946cc463STadeusz Struk void *outbuf_dec = NULL; 29487f397136SGilad Ben-Yossef struct crypto_wait wait; 2949946cc463STadeusz Struk unsigned int out_len_max, out_len = 0; 2950946cc463STadeusz Struk int err = -ENOMEM; 2951c7381b01SVitaly Chikunov struct scatterlist src, dst, src_tab[3]; 29520507de94SVitaly Chikunov const char *m, *c; 29530507de94SVitaly Chikunov unsigned int m_size, c_size; 29540507de94SVitaly Chikunov const char *op; 2955f1774cb8SVitaly Chikunov u8 *key, *ptr; 2956946cc463STadeusz Struk 2957df27b26fSHerbert Xu if (testmgr_alloc_buf(xbuf)) 2958df27b26fSHerbert Xu return err; 2959df27b26fSHerbert Xu 2960946cc463STadeusz Struk req = akcipher_request_alloc(tfm, GFP_KERNEL); 2961946cc463STadeusz Struk if (!req) 2962df27b26fSHerbert Xu goto free_xbuf; 2963946cc463STadeusz Struk 29647f397136SGilad Ben-Yossef crypto_init_wait(&wait); 296522287b0bSTadeusz Struk 2966f1774cb8SVitaly Chikunov key = kmalloc(vecs->key_len + sizeof(u32) * 2 + vecs->param_len, 2967f1774cb8SVitaly Chikunov GFP_KERNEL); 2968f1774cb8SVitaly Chikunov if (!key) 2969f1774cb8SVitaly Chikunov goto free_xbuf; 2970f1774cb8SVitaly Chikunov memcpy(key, vecs->key, vecs->key_len); 2971f1774cb8SVitaly Chikunov ptr = key + vecs->key_len; 2972f1774cb8SVitaly Chikunov ptr = test_pack_u32(ptr, vecs->algo); 2973f1774cb8SVitaly Chikunov ptr = test_pack_u32(ptr, vecs->param_len); 2974f1774cb8SVitaly Chikunov memcpy(ptr, vecs->params, vecs->param_len); 2975f1774cb8SVitaly Chikunov 297622287b0bSTadeusz Struk if (vecs->public_key_vec) 2977f1774cb8SVitaly Chikunov err = crypto_akcipher_set_pub_key(tfm, key, vecs->key_len); 297822287b0bSTadeusz Struk else 2979f1774cb8SVitaly Chikunov err = crypto_akcipher_set_priv_key(tfm, key, vecs->key_len); 2980946cc463STadeusz Struk if (err) 2981946cc463STadeusz Struk goto free_req; 2982946cc463STadeusz Struk 29830507de94SVitaly Chikunov /* 29840507de94SVitaly Chikunov * First run test which do not require a private key, such as 29850507de94SVitaly Chikunov * encrypt or verify. 29860507de94SVitaly Chikunov */ 2987c7381b01SVitaly Chikunov err = -ENOMEM; 2988c7381b01SVitaly Chikunov out_len_max = crypto_akcipher_maxsize(tfm); 2989946cc463STadeusz Struk outbuf_enc = kzalloc(out_len_max, GFP_KERNEL); 2990946cc463STadeusz Struk if (!outbuf_enc) 2991946cc463STadeusz Struk goto free_req; 2992946cc463STadeusz Struk 29930507de94SVitaly Chikunov if (!vecs->siggen_sigver_test) { 29940507de94SVitaly Chikunov m = vecs->m; 29950507de94SVitaly Chikunov m_size = vecs->m_size; 29960507de94SVitaly Chikunov c = vecs->c; 29970507de94SVitaly Chikunov c_size = vecs->c_size; 29980507de94SVitaly Chikunov op = "encrypt"; 29990507de94SVitaly Chikunov } else { 30000507de94SVitaly Chikunov /* Swap args so we could keep plaintext (digest) 30010507de94SVitaly Chikunov * in vecs->m, and cooked signature in vecs->c. 30020507de94SVitaly Chikunov */ 30030507de94SVitaly Chikunov m = vecs->c; /* signature */ 30040507de94SVitaly Chikunov m_size = vecs->c_size; 30050507de94SVitaly Chikunov c = vecs->m; /* digest */ 30060507de94SVitaly Chikunov c_size = vecs->m_size; 30070507de94SVitaly Chikunov op = "verify"; 30080507de94SVitaly Chikunov } 3009df27b26fSHerbert Xu 30100507de94SVitaly Chikunov if (WARN_ON(m_size > PAGE_SIZE)) 30110507de94SVitaly Chikunov goto free_all; 30120507de94SVitaly Chikunov memcpy(xbuf[0], m, m_size); 3013df27b26fSHerbert Xu 3014c7381b01SVitaly Chikunov sg_init_table(src_tab, 3); 3015df27b26fSHerbert Xu sg_set_buf(&src_tab[0], xbuf[0], 8); 30160507de94SVitaly Chikunov sg_set_buf(&src_tab[1], xbuf[0] + 8, m_size - 8); 3017c7381b01SVitaly Chikunov if (vecs->siggen_sigver_test) { 3018c7381b01SVitaly Chikunov if (WARN_ON(c_size > PAGE_SIZE)) 3019c7381b01SVitaly Chikunov goto free_all; 3020c7381b01SVitaly Chikunov memcpy(xbuf[1], c, c_size); 3021c7381b01SVitaly Chikunov sg_set_buf(&src_tab[2], xbuf[1], c_size); 3022c7381b01SVitaly Chikunov akcipher_request_set_crypt(req, src_tab, NULL, m_size, c_size); 3023c7381b01SVitaly Chikunov } else { 302422287b0bSTadeusz Struk sg_init_one(&dst, outbuf_enc, out_len_max); 30250507de94SVitaly Chikunov akcipher_request_set_crypt(req, src_tab, &dst, m_size, 302622287b0bSTadeusz Struk out_len_max); 3027c7381b01SVitaly Chikunov } 3028946cc463STadeusz Struk akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 30297f397136SGilad Ben-Yossef crypto_req_done, &wait); 3030946cc463STadeusz Struk 30317f397136SGilad Ben-Yossef err = crypto_wait_req(vecs->siggen_sigver_test ? 30320507de94SVitaly Chikunov /* Run asymmetric signature verification */ 30330507de94SVitaly Chikunov crypto_akcipher_verify(req) : 30341207107cSStephan Mueller /* Run asymmetric encrypt */ 30357f397136SGilad Ben-Yossef crypto_akcipher_encrypt(req), &wait); 3036946cc463STadeusz Struk if (err) { 30370507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. err %d\n", op, err); 3038946cc463STadeusz Struk goto free_all; 3039946cc463STadeusz Struk } 3040c7381b01SVitaly Chikunov if (!vecs->siggen_sigver_test) { 30410507de94SVitaly Chikunov if (req->dst_len != c_size) { 30420507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output len\n", 30430507de94SVitaly Chikunov op); 3044946cc463STadeusz Struk err = -EINVAL; 3045946cc463STadeusz Struk goto free_all; 3046946cc463STadeusz Struk } 3047946cc463STadeusz Struk /* verify that encrypted message is equal to expected */ 3048c7381b01SVitaly Chikunov if (memcmp(c, outbuf_enc, c_size) != 0) { 3049c7381b01SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output\n", 3050c7381b01SVitaly Chikunov op); 30510507de94SVitaly Chikunov hexdump(outbuf_enc, c_size); 3052946cc463STadeusz Struk err = -EINVAL; 3053946cc463STadeusz Struk goto free_all; 3054946cc463STadeusz Struk } 3055c7381b01SVitaly Chikunov } 30560507de94SVitaly Chikunov 30570507de94SVitaly Chikunov /* 30580507de94SVitaly Chikunov * Don't invoke (decrypt or sign) test which require a private key 30590507de94SVitaly Chikunov * for vectors with only a public key. 30600507de94SVitaly Chikunov */ 3061946cc463STadeusz Struk if (vecs->public_key_vec) { 3062946cc463STadeusz Struk err = 0; 3063946cc463STadeusz Struk goto free_all; 3064946cc463STadeusz Struk } 3065946cc463STadeusz Struk outbuf_dec = kzalloc(out_len_max, GFP_KERNEL); 3066946cc463STadeusz Struk if (!outbuf_dec) { 3067946cc463STadeusz Struk err = -ENOMEM; 3068946cc463STadeusz Struk goto free_all; 3069946cc463STadeusz Struk } 3070df27b26fSHerbert Xu 30710507de94SVitaly Chikunov op = vecs->siggen_sigver_test ? "sign" : "decrypt"; 30720507de94SVitaly Chikunov if (WARN_ON(c_size > PAGE_SIZE)) 3073df27b26fSHerbert Xu goto free_all; 30740507de94SVitaly Chikunov memcpy(xbuf[0], c, c_size); 3075df27b26fSHerbert Xu 30760507de94SVitaly Chikunov sg_init_one(&src, xbuf[0], c_size); 307722287b0bSTadeusz Struk sg_init_one(&dst, outbuf_dec, out_len_max); 30787f397136SGilad Ben-Yossef crypto_init_wait(&wait); 30790507de94SVitaly Chikunov akcipher_request_set_crypt(req, &src, &dst, c_size, out_len_max); 3080946cc463STadeusz Struk 30817f397136SGilad Ben-Yossef err = crypto_wait_req(vecs->siggen_sigver_test ? 30820507de94SVitaly Chikunov /* Run asymmetric signature generation */ 30830507de94SVitaly Chikunov crypto_akcipher_sign(req) : 30841207107cSStephan Mueller /* Run asymmetric decrypt */ 30857f397136SGilad Ben-Yossef crypto_akcipher_decrypt(req), &wait); 3086946cc463STadeusz Struk if (err) { 30870507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. err %d\n", op, err); 3088946cc463STadeusz Struk goto free_all; 3089946cc463STadeusz Struk } 3090946cc463STadeusz Struk out_len = req->dst_len; 30910507de94SVitaly Chikunov if (out_len < m_size) { 30920507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output len %u\n", 30930507de94SVitaly Chikunov op, out_len); 3094946cc463STadeusz Struk err = -EINVAL; 3095946cc463STadeusz Struk goto free_all; 3096946cc463STadeusz Struk } 3097946cc463STadeusz Struk /* verify that decrypted message is equal to the original msg */ 30980507de94SVitaly Chikunov if (memchr_inv(outbuf_dec, 0, out_len - m_size) || 30990507de94SVitaly Chikunov memcmp(m, outbuf_dec + out_len - m_size, m_size)) { 31000507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output\n", op); 310150d2b643SHerbert Xu hexdump(outbuf_dec, out_len); 3102946cc463STadeusz Struk err = -EINVAL; 3103946cc463STadeusz Struk } 3104946cc463STadeusz Struk free_all: 3105946cc463STadeusz Struk kfree(outbuf_dec); 3106946cc463STadeusz Struk kfree(outbuf_enc); 3107946cc463STadeusz Struk free_req: 3108946cc463STadeusz Struk akcipher_request_free(req); 3109f1774cb8SVitaly Chikunov kfree(key); 3110df27b26fSHerbert Xu free_xbuf: 3111df27b26fSHerbert Xu testmgr_free_buf(xbuf); 3112946cc463STadeusz Struk return err; 3113946cc463STadeusz Struk } 3114946cc463STadeusz Struk 311550d2b643SHerbert Xu static int test_akcipher(struct crypto_akcipher *tfm, const char *alg, 3116b13b1e0cSEric Biggers const struct akcipher_testvec *vecs, 3117b13b1e0cSEric Biggers unsigned int tcount) 3118946cc463STadeusz Struk { 311915226e48SHerbert Xu const char *algo = 312015226e48SHerbert Xu crypto_tfm_alg_driver_name(crypto_akcipher_tfm(tfm)); 3121946cc463STadeusz Struk int ret, i; 3122946cc463STadeusz Struk 3123946cc463STadeusz Struk for (i = 0; i < tcount; i++) { 312450d2b643SHerbert Xu ret = test_akcipher_one(tfm, vecs++); 312550d2b643SHerbert Xu if (!ret) 312650d2b643SHerbert Xu continue; 312750d2b643SHerbert Xu 312815226e48SHerbert Xu pr_err("alg: akcipher: test %d failed for %s, err=%d\n", 312915226e48SHerbert Xu i + 1, algo, ret); 3130946cc463STadeusz Struk return ret; 3131946cc463STadeusz Struk } 3132946cc463STadeusz Struk return 0; 3133946cc463STadeusz Struk } 3134946cc463STadeusz Struk 3135946cc463STadeusz Struk static int alg_test_akcipher(const struct alg_test_desc *desc, 3136946cc463STadeusz Struk const char *driver, u32 type, u32 mask) 3137946cc463STadeusz Struk { 3138946cc463STadeusz Struk struct crypto_akcipher *tfm; 3139946cc463STadeusz Struk int err = 0; 3140946cc463STadeusz Struk 3141eed93e0cSHerbert Xu tfm = crypto_alloc_akcipher(driver, type, mask); 3142946cc463STadeusz Struk if (IS_ERR(tfm)) { 3143946cc463STadeusz Struk pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n", 3144946cc463STadeusz Struk driver, PTR_ERR(tfm)); 3145946cc463STadeusz Struk return PTR_ERR(tfm); 3146946cc463STadeusz Struk } 3147946cc463STadeusz Struk if (desc->suite.akcipher.vecs) 3148946cc463STadeusz Struk err = test_akcipher(tfm, desc->alg, desc->suite.akcipher.vecs, 3149946cc463STadeusz Struk desc->suite.akcipher.count); 3150946cc463STadeusz Struk 3151946cc463STadeusz Struk crypto_free_akcipher(tfm); 3152946cc463STadeusz Struk return err; 3153946cc463STadeusz Struk } 3154946cc463STadeusz Struk 3155863b557aSYouquan, Song static int alg_test_null(const struct alg_test_desc *desc, 3156863b557aSYouquan, Song const char *driver, u32 type, u32 mask) 3157863b557aSYouquan, Song { 3158863b557aSYouquan, Song return 0; 3159863b557aSYouquan, Song } 3160863b557aSYouquan, Song 316121c8e720SArd Biesheuvel #define __VECS(tv) { .vecs = tv, .count = ARRAY_SIZE(tv) } 316221c8e720SArd Biesheuvel 3163da7f033dSHerbert Xu /* Please keep this list sorted by algorithm name. */ 3164da7f033dSHerbert Xu static const struct alg_test_desc alg_test_descs[] = { 3165da7f033dSHerbert Xu { 3166059c2a4dSEric Biggers .alg = "adiantum(xchacha12,aes)", 3167059c2a4dSEric Biggers .test = alg_test_skcipher, 3168059c2a4dSEric Biggers .suite = { 3169059c2a4dSEric Biggers .cipher = __VECS(adiantum_xchacha12_aes_tv_template) 3170059c2a4dSEric Biggers }, 3171059c2a4dSEric Biggers }, { 3172059c2a4dSEric Biggers .alg = "adiantum(xchacha20,aes)", 3173059c2a4dSEric Biggers .test = alg_test_skcipher, 3174059c2a4dSEric Biggers .suite = { 3175059c2a4dSEric Biggers .cipher = __VECS(adiantum_xchacha20_aes_tv_template) 3176059c2a4dSEric Biggers }, 3177059c2a4dSEric Biggers }, { 3178b87dc203SOndrej Mosnacek .alg = "aegis128", 3179b87dc203SOndrej Mosnacek .test = alg_test_aead, 3180b87dc203SOndrej Mosnacek .suite = { 3181a0d608eeSEric Biggers .aead = __VECS(aegis128_tv_template) 3182b87dc203SOndrej Mosnacek } 3183b87dc203SOndrej Mosnacek }, { 3184b87dc203SOndrej Mosnacek .alg = "aegis128l", 3185b87dc203SOndrej Mosnacek .test = alg_test_aead, 3186b87dc203SOndrej Mosnacek .suite = { 3187a0d608eeSEric Biggers .aead = __VECS(aegis128l_tv_template) 3188b87dc203SOndrej Mosnacek } 3189b87dc203SOndrej Mosnacek }, { 3190b87dc203SOndrej Mosnacek .alg = "aegis256", 3191b87dc203SOndrej Mosnacek .test = alg_test_aead, 3192b87dc203SOndrej Mosnacek .suite = { 3193a0d608eeSEric Biggers .aead = __VECS(aegis256_tv_template) 3194b87dc203SOndrej Mosnacek } 3195b87dc203SOndrej Mosnacek }, { 3196e08ca2daSJarod Wilson .alg = "ansi_cprng", 3197e08ca2daSJarod Wilson .test = alg_test_cprng, 3198e08ca2daSJarod Wilson .suite = { 319921c8e720SArd Biesheuvel .cprng = __VECS(ansi_cprng_aes_tv_template) 3200e08ca2daSJarod Wilson } 3201e08ca2daSJarod Wilson }, { 3202bca4feb0SHoria Geanta .alg = "authenc(hmac(md5),ecb(cipher_null))", 3203bca4feb0SHoria Geanta .test = alg_test_aead, 3204bca4feb0SHoria Geanta .suite = { 3205a0d608eeSEric Biggers .aead = __VECS(hmac_md5_ecb_cipher_null_tv_template) 3206bca4feb0SHoria Geanta } 3207bca4feb0SHoria Geanta }, { 3208a4198fd4SHerbert Xu .alg = "authenc(hmac(sha1),cbc(aes))", 3209e46e9a46SHoria Geanta .test = alg_test_aead, 3210bcf741cbSHerbert Xu .fips_allowed = 1, 3211e46e9a46SHoria Geanta .suite = { 3212a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_aes_cbc_tv_temp) 32135208ed2cSNitesh Lal } 32145208ed2cSNitesh Lal }, { 3215a4198fd4SHerbert Xu .alg = "authenc(hmac(sha1),cbc(des))", 32165208ed2cSNitesh Lal .test = alg_test_aead, 32175208ed2cSNitesh Lal .suite = { 3218a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_des_cbc_tv_temp) 32195208ed2cSNitesh Lal } 32205208ed2cSNitesh Lal }, { 3221a4198fd4SHerbert Xu .alg = "authenc(hmac(sha1),cbc(des3_ede))", 32225208ed2cSNitesh Lal .test = alg_test_aead, 3223ed1afac9SMarcus Meissner .fips_allowed = 1, 32245208ed2cSNitesh Lal .suite = { 3225a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_des3_ede_cbc_tv_temp) 3226e46e9a46SHoria Geanta } 3227e46e9a46SHoria Geanta }, { 3228fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha1),ctr(aes))", 3229fb16abc2SMarcus Meissner .test = alg_test_null, 3230fb16abc2SMarcus Meissner .fips_allowed = 1, 3231fb16abc2SMarcus Meissner }, { 3232bca4feb0SHoria Geanta .alg = "authenc(hmac(sha1),ecb(cipher_null))", 3233bca4feb0SHoria Geanta .test = alg_test_aead, 3234bca4feb0SHoria Geanta .suite = { 3235a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_ecb_cipher_null_tv_temp) 32365208ed2cSNitesh Lal } 32375208ed2cSNitesh Lal }, { 32388888690eSMarcus Meissner .alg = "authenc(hmac(sha1),rfc3686(ctr(aes)))", 32398888690eSMarcus Meissner .test = alg_test_null, 32408888690eSMarcus Meissner .fips_allowed = 1, 32418888690eSMarcus Meissner }, { 3242a4198fd4SHerbert Xu .alg = "authenc(hmac(sha224),cbc(des))", 32435208ed2cSNitesh Lal .test = alg_test_aead, 32445208ed2cSNitesh Lal .suite = { 3245a0d608eeSEric Biggers .aead = __VECS(hmac_sha224_des_cbc_tv_temp) 32465208ed2cSNitesh Lal } 32475208ed2cSNitesh Lal }, { 3248a4198fd4SHerbert Xu .alg = "authenc(hmac(sha224),cbc(des3_ede))", 32495208ed2cSNitesh Lal .test = alg_test_aead, 3250ed1afac9SMarcus Meissner .fips_allowed = 1, 32515208ed2cSNitesh Lal .suite = { 3252a0d608eeSEric Biggers .aead = __VECS(hmac_sha224_des3_ede_cbc_tv_temp) 3253bca4feb0SHoria Geanta } 3254bca4feb0SHoria Geanta }, { 3255a4198fd4SHerbert Xu .alg = "authenc(hmac(sha256),cbc(aes))", 3256e46e9a46SHoria Geanta .test = alg_test_aead, 3257ed1afac9SMarcus Meissner .fips_allowed = 1, 3258e46e9a46SHoria Geanta .suite = { 3259a0d608eeSEric Biggers .aead = __VECS(hmac_sha256_aes_cbc_tv_temp) 32605208ed2cSNitesh Lal } 32615208ed2cSNitesh Lal }, { 3262a4198fd4SHerbert Xu .alg = "authenc(hmac(sha256),cbc(des))", 32635208ed2cSNitesh Lal .test = alg_test_aead, 32645208ed2cSNitesh Lal .suite = { 3265a0d608eeSEric Biggers .aead = __VECS(hmac_sha256_des_cbc_tv_temp) 32665208ed2cSNitesh Lal } 32675208ed2cSNitesh Lal }, { 3268a4198fd4SHerbert Xu .alg = "authenc(hmac(sha256),cbc(des3_ede))", 32695208ed2cSNitesh Lal .test = alg_test_aead, 3270ed1afac9SMarcus Meissner .fips_allowed = 1, 32715208ed2cSNitesh Lal .suite = { 3272a0d608eeSEric Biggers .aead = __VECS(hmac_sha256_des3_ede_cbc_tv_temp) 32735208ed2cSNitesh Lal } 32745208ed2cSNitesh Lal }, { 3275fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha256),ctr(aes))", 3276fb16abc2SMarcus Meissner .test = alg_test_null, 3277fb16abc2SMarcus Meissner .fips_allowed = 1, 3278fb16abc2SMarcus Meissner }, { 32798888690eSMarcus Meissner .alg = "authenc(hmac(sha256),rfc3686(ctr(aes)))", 32808888690eSMarcus Meissner .test = alg_test_null, 32818888690eSMarcus Meissner .fips_allowed = 1, 32828888690eSMarcus Meissner }, { 3283a4198fd4SHerbert Xu .alg = "authenc(hmac(sha384),cbc(des))", 32845208ed2cSNitesh Lal .test = alg_test_aead, 32855208ed2cSNitesh Lal .suite = { 3286a0d608eeSEric Biggers .aead = __VECS(hmac_sha384_des_cbc_tv_temp) 32875208ed2cSNitesh Lal } 32885208ed2cSNitesh Lal }, { 3289a4198fd4SHerbert Xu .alg = "authenc(hmac(sha384),cbc(des3_ede))", 32905208ed2cSNitesh Lal .test = alg_test_aead, 3291ed1afac9SMarcus Meissner .fips_allowed = 1, 32925208ed2cSNitesh Lal .suite = { 3293a0d608eeSEric Biggers .aead = __VECS(hmac_sha384_des3_ede_cbc_tv_temp) 3294e46e9a46SHoria Geanta } 3295e46e9a46SHoria Geanta }, { 3296fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha384),ctr(aes))", 3297fb16abc2SMarcus Meissner .test = alg_test_null, 3298fb16abc2SMarcus Meissner .fips_allowed = 1, 3299fb16abc2SMarcus Meissner }, { 33008888690eSMarcus Meissner .alg = "authenc(hmac(sha384),rfc3686(ctr(aes)))", 33018888690eSMarcus Meissner .test = alg_test_null, 33028888690eSMarcus Meissner .fips_allowed = 1, 33038888690eSMarcus Meissner }, { 3304a4198fd4SHerbert Xu .alg = "authenc(hmac(sha512),cbc(aes))", 3305ed1afac9SMarcus Meissner .fips_allowed = 1, 3306e46e9a46SHoria Geanta .test = alg_test_aead, 3307e46e9a46SHoria Geanta .suite = { 3308a0d608eeSEric Biggers .aead = __VECS(hmac_sha512_aes_cbc_tv_temp) 33095208ed2cSNitesh Lal } 33105208ed2cSNitesh Lal }, { 3311a4198fd4SHerbert Xu .alg = "authenc(hmac(sha512),cbc(des))", 33125208ed2cSNitesh Lal .test = alg_test_aead, 33135208ed2cSNitesh Lal .suite = { 3314a0d608eeSEric Biggers .aead = __VECS(hmac_sha512_des_cbc_tv_temp) 33155208ed2cSNitesh Lal } 33165208ed2cSNitesh Lal }, { 3317a4198fd4SHerbert Xu .alg = "authenc(hmac(sha512),cbc(des3_ede))", 33185208ed2cSNitesh Lal .test = alg_test_aead, 3319ed1afac9SMarcus Meissner .fips_allowed = 1, 33205208ed2cSNitesh Lal .suite = { 3321a0d608eeSEric Biggers .aead = __VECS(hmac_sha512_des3_ede_cbc_tv_temp) 3322e46e9a46SHoria Geanta } 3323e46e9a46SHoria Geanta }, { 3324fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha512),ctr(aes))", 3325fb16abc2SMarcus Meissner .test = alg_test_null, 3326fb16abc2SMarcus Meissner .fips_allowed = 1, 3327fb16abc2SMarcus Meissner }, { 33288888690eSMarcus Meissner .alg = "authenc(hmac(sha512),rfc3686(ctr(aes)))", 33298888690eSMarcus Meissner .test = alg_test_null, 33308888690eSMarcus Meissner .fips_allowed = 1, 33318888690eSMarcus Meissner }, { 3332da7f033dSHerbert Xu .alg = "cbc(aes)", 33331aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3334a1915d51SJarod Wilson .fips_allowed = 1, 3335da7f033dSHerbert Xu .suite = { 333692a4c9feSEric Biggers .cipher = __VECS(aes_cbc_tv_template) 333792a4c9feSEric Biggers }, 3338da7f033dSHerbert Xu }, { 3339da7f033dSHerbert Xu .alg = "cbc(anubis)", 33401aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3341da7f033dSHerbert Xu .suite = { 334292a4c9feSEric Biggers .cipher = __VECS(anubis_cbc_tv_template) 334392a4c9feSEric Biggers }, 3344da7f033dSHerbert Xu }, { 3345da7f033dSHerbert Xu .alg = "cbc(blowfish)", 33461aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3347da7f033dSHerbert Xu .suite = { 334892a4c9feSEric Biggers .cipher = __VECS(bf_cbc_tv_template) 334992a4c9feSEric Biggers }, 3350da7f033dSHerbert Xu }, { 3351da7f033dSHerbert Xu .alg = "cbc(camellia)", 33521aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3353da7f033dSHerbert Xu .suite = { 335492a4c9feSEric Biggers .cipher = __VECS(camellia_cbc_tv_template) 335592a4c9feSEric Biggers }, 3356da7f033dSHerbert Xu }, { 3357a2c58260SJohannes Goetzfried .alg = "cbc(cast5)", 3358a2c58260SJohannes Goetzfried .test = alg_test_skcipher, 3359a2c58260SJohannes Goetzfried .suite = { 336092a4c9feSEric Biggers .cipher = __VECS(cast5_cbc_tv_template) 336192a4c9feSEric Biggers }, 3362a2c58260SJohannes Goetzfried }, { 33639b8b0405SJohannes Goetzfried .alg = "cbc(cast6)", 33649b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 33659b8b0405SJohannes Goetzfried .suite = { 336692a4c9feSEric Biggers .cipher = __VECS(cast6_cbc_tv_template) 336792a4c9feSEric Biggers }, 33689b8b0405SJohannes Goetzfried }, { 3369da7f033dSHerbert Xu .alg = "cbc(des)", 33701aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3371da7f033dSHerbert Xu .suite = { 337292a4c9feSEric Biggers .cipher = __VECS(des_cbc_tv_template) 337392a4c9feSEric Biggers }, 3374da7f033dSHerbert Xu }, { 3375da7f033dSHerbert Xu .alg = "cbc(des3_ede)", 33761aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3377a1915d51SJarod Wilson .fips_allowed = 1, 3378da7f033dSHerbert Xu .suite = { 337992a4c9feSEric Biggers .cipher = __VECS(des3_ede_cbc_tv_template) 338092a4c9feSEric Biggers }, 3381da7f033dSHerbert Xu }, { 3382a794d8d8SGilad Ben-Yossef /* Same as cbc(aes) except the key is stored in 3383a794d8d8SGilad Ben-Yossef * hardware secure memory which we reference by index 3384a794d8d8SGilad Ben-Yossef */ 3385a794d8d8SGilad Ben-Yossef .alg = "cbc(paes)", 3386a794d8d8SGilad Ben-Yossef .test = alg_test_null, 3387a794d8d8SGilad Ben-Yossef .fips_allowed = 1, 3388a794d8d8SGilad Ben-Yossef }, { 33899d25917dSJussi Kivilinna .alg = "cbc(serpent)", 33909d25917dSJussi Kivilinna .test = alg_test_skcipher, 33919d25917dSJussi Kivilinna .suite = { 339292a4c9feSEric Biggers .cipher = __VECS(serpent_cbc_tv_template) 339392a4c9feSEric Biggers }, 33949d25917dSJussi Kivilinna }, { 339595ba5973SGilad Ben-Yossef .alg = "cbc(sm4)", 339695ba5973SGilad Ben-Yossef .test = alg_test_skcipher, 339795ba5973SGilad Ben-Yossef .suite = { 339895ba5973SGilad Ben-Yossef .cipher = __VECS(sm4_cbc_tv_template) 339995ba5973SGilad Ben-Yossef } 340095ba5973SGilad Ben-Yossef }, { 3401da7f033dSHerbert Xu .alg = "cbc(twofish)", 34021aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3403da7f033dSHerbert Xu .suite = { 340492a4c9feSEric Biggers .cipher = __VECS(tf_cbc_tv_template) 340592a4c9feSEric Biggers }, 3406da7f033dSHerbert Xu }, { 3407092acf06SArd Biesheuvel .alg = "cbcmac(aes)", 3408092acf06SArd Biesheuvel .fips_allowed = 1, 3409092acf06SArd Biesheuvel .test = alg_test_hash, 3410092acf06SArd Biesheuvel .suite = { 3411092acf06SArd Biesheuvel .hash = __VECS(aes_cbcmac_tv_template) 3412092acf06SArd Biesheuvel } 3413092acf06SArd Biesheuvel }, { 3414da7f033dSHerbert Xu .alg = "ccm(aes)", 3415da7f033dSHerbert Xu .test = alg_test_aead, 3416a1915d51SJarod Wilson .fips_allowed = 1, 3417da7f033dSHerbert Xu .suite = { 3418a0d608eeSEric Biggers .aead = __VECS(aes_ccm_tv_template) 3419da7f033dSHerbert Xu } 3420da7f033dSHerbert Xu }, { 34217da66670SDmitry Eremin-Solenikov .alg = "cfb(aes)", 34227da66670SDmitry Eremin-Solenikov .test = alg_test_skcipher, 34237da66670SDmitry Eremin-Solenikov .fips_allowed = 1, 34247da66670SDmitry Eremin-Solenikov .suite = { 34257da66670SDmitry Eremin-Solenikov .cipher = __VECS(aes_cfb_tv_template) 34267da66670SDmitry Eremin-Solenikov }, 34277da66670SDmitry Eremin-Solenikov }, { 34283590ebf2SMartin Willi .alg = "chacha20", 34293590ebf2SMartin Willi .test = alg_test_skcipher, 34303590ebf2SMartin Willi .suite = { 343192a4c9feSEric Biggers .cipher = __VECS(chacha20_tv_template) 343292a4c9feSEric Biggers }, 34333590ebf2SMartin Willi }, { 343493b5e86aSJussi Kivilinna .alg = "cmac(aes)", 34358f183751SStephan Mueller .fips_allowed = 1, 343693b5e86aSJussi Kivilinna .test = alg_test_hash, 343793b5e86aSJussi Kivilinna .suite = { 343821c8e720SArd Biesheuvel .hash = __VECS(aes_cmac128_tv_template) 343993b5e86aSJussi Kivilinna } 344093b5e86aSJussi Kivilinna }, { 344193b5e86aSJussi Kivilinna .alg = "cmac(des3_ede)", 34428f183751SStephan Mueller .fips_allowed = 1, 344393b5e86aSJussi Kivilinna .test = alg_test_hash, 344493b5e86aSJussi Kivilinna .suite = { 344521c8e720SArd Biesheuvel .hash = __VECS(des3_ede_cmac64_tv_template) 344693b5e86aSJussi Kivilinna } 344793b5e86aSJussi Kivilinna }, { 3448e448370dSJussi Kivilinna .alg = "compress_null", 3449e448370dSJussi Kivilinna .test = alg_test_null, 3450e448370dSJussi Kivilinna }, { 3451ebb3472fSArd Biesheuvel .alg = "crc32", 3452ebb3472fSArd Biesheuvel .test = alg_test_hash, 3453a8a34416SMilan Broz .fips_allowed = 1, 3454ebb3472fSArd Biesheuvel .suite = { 345521c8e720SArd Biesheuvel .hash = __VECS(crc32_tv_template) 3456ebb3472fSArd Biesheuvel } 3457ebb3472fSArd Biesheuvel }, { 3458da7f033dSHerbert Xu .alg = "crc32c", 34598e3ee85eSHerbert Xu .test = alg_test_crc32c, 3460a1915d51SJarod Wilson .fips_allowed = 1, 3461da7f033dSHerbert Xu .suite = { 346221c8e720SArd Biesheuvel .hash = __VECS(crc32c_tv_template) 3463da7f033dSHerbert Xu } 3464da7f033dSHerbert Xu }, { 346568411521SHerbert Xu .alg = "crct10dif", 346668411521SHerbert Xu .test = alg_test_hash, 346768411521SHerbert Xu .fips_allowed = 1, 346868411521SHerbert Xu .suite = { 346921c8e720SArd Biesheuvel .hash = __VECS(crct10dif_tv_template) 347068411521SHerbert Xu } 347168411521SHerbert Xu }, { 3472f7cb80f2SJarod Wilson .alg = "ctr(aes)", 3473f7cb80f2SJarod Wilson .test = alg_test_skcipher, 3474a1915d51SJarod Wilson .fips_allowed = 1, 3475f7cb80f2SJarod Wilson .suite = { 347692a4c9feSEric Biggers .cipher = __VECS(aes_ctr_tv_template) 3477f7cb80f2SJarod Wilson } 3478f7cb80f2SJarod Wilson }, { 347985b63e34SJussi Kivilinna .alg = "ctr(blowfish)", 348085b63e34SJussi Kivilinna .test = alg_test_skcipher, 348185b63e34SJussi Kivilinna .suite = { 348292a4c9feSEric Biggers .cipher = __VECS(bf_ctr_tv_template) 348385b63e34SJussi Kivilinna } 348485b63e34SJussi Kivilinna }, { 34850840605eSJussi Kivilinna .alg = "ctr(camellia)", 34860840605eSJussi Kivilinna .test = alg_test_skcipher, 34870840605eSJussi Kivilinna .suite = { 348892a4c9feSEric Biggers .cipher = __VECS(camellia_ctr_tv_template) 34890840605eSJussi Kivilinna } 34900840605eSJussi Kivilinna }, { 3491a2c58260SJohannes Goetzfried .alg = "ctr(cast5)", 3492a2c58260SJohannes Goetzfried .test = alg_test_skcipher, 3493a2c58260SJohannes Goetzfried .suite = { 349492a4c9feSEric Biggers .cipher = __VECS(cast5_ctr_tv_template) 3495a2c58260SJohannes Goetzfried } 3496a2c58260SJohannes Goetzfried }, { 34979b8b0405SJohannes Goetzfried .alg = "ctr(cast6)", 34989b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 34999b8b0405SJohannes Goetzfried .suite = { 350092a4c9feSEric Biggers .cipher = __VECS(cast6_ctr_tv_template) 35019b8b0405SJohannes Goetzfried } 35029b8b0405SJohannes Goetzfried }, { 35038163fc30SJussi Kivilinna .alg = "ctr(des)", 35048163fc30SJussi Kivilinna .test = alg_test_skcipher, 35058163fc30SJussi Kivilinna .suite = { 350692a4c9feSEric Biggers .cipher = __VECS(des_ctr_tv_template) 35078163fc30SJussi Kivilinna } 35088163fc30SJussi Kivilinna }, { 3509e080b17aSJussi Kivilinna .alg = "ctr(des3_ede)", 3510e080b17aSJussi Kivilinna .test = alg_test_skcipher, 35110d8da104SMarcelo Cerri .fips_allowed = 1, 3512e080b17aSJussi Kivilinna .suite = { 351392a4c9feSEric Biggers .cipher = __VECS(des3_ede_ctr_tv_template) 3514e080b17aSJussi Kivilinna } 3515e080b17aSJussi Kivilinna }, { 3516a794d8d8SGilad Ben-Yossef /* Same as ctr(aes) except the key is stored in 3517a794d8d8SGilad Ben-Yossef * hardware secure memory which we reference by index 3518a794d8d8SGilad Ben-Yossef */ 3519a794d8d8SGilad Ben-Yossef .alg = "ctr(paes)", 3520a794d8d8SGilad Ben-Yossef .test = alg_test_null, 3521a794d8d8SGilad Ben-Yossef .fips_allowed = 1, 3522a794d8d8SGilad Ben-Yossef }, { 35239d25917dSJussi Kivilinna .alg = "ctr(serpent)", 35249d25917dSJussi Kivilinna .test = alg_test_skcipher, 35259d25917dSJussi Kivilinna .suite = { 352692a4c9feSEric Biggers .cipher = __VECS(serpent_ctr_tv_template) 35279d25917dSJussi Kivilinna } 35289d25917dSJussi Kivilinna }, { 352995ba5973SGilad Ben-Yossef .alg = "ctr(sm4)", 353095ba5973SGilad Ben-Yossef .test = alg_test_skcipher, 353195ba5973SGilad Ben-Yossef .suite = { 353295ba5973SGilad Ben-Yossef .cipher = __VECS(sm4_ctr_tv_template) 353395ba5973SGilad Ben-Yossef } 353495ba5973SGilad Ben-Yossef }, { 3535573da620SJussi Kivilinna .alg = "ctr(twofish)", 3536573da620SJussi Kivilinna .test = alg_test_skcipher, 3537573da620SJussi Kivilinna .suite = { 353892a4c9feSEric Biggers .cipher = __VECS(tf_ctr_tv_template) 3539573da620SJussi Kivilinna } 3540573da620SJussi Kivilinna }, { 3541da7f033dSHerbert Xu .alg = "cts(cbc(aes))", 35421aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3543196ad604SGilad Ben-Yossef .fips_allowed = 1, 3544da7f033dSHerbert Xu .suite = { 354592a4c9feSEric Biggers .cipher = __VECS(cts_mode_tv_template) 3546da7f033dSHerbert Xu } 3547da7f033dSHerbert Xu }, { 3548da7f033dSHerbert Xu .alg = "deflate", 3549da7f033dSHerbert Xu .test = alg_test_comp, 35500818904dSMilan Broz .fips_allowed = 1, 3551da7f033dSHerbert Xu .suite = { 3552da7f033dSHerbert Xu .comp = { 355321c8e720SArd Biesheuvel .comp = __VECS(deflate_comp_tv_template), 355421c8e720SArd Biesheuvel .decomp = __VECS(deflate_decomp_tv_template) 3555da7f033dSHerbert Xu } 3556da7f033dSHerbert Xu } 3557da7f033dSHerbert Xu }, { 3558802c7f1cSSalvatore Benedetto .alg = "dh", 3559802c7f1cSSalvatore Benedetto .test = alg_test_kpp, 3560802c7f1cSSalvatore Benedetto .fips_allowed = 1, 3561802c7f1cSSalvatore Benedetto .suite = { 356221c8e720SArd Biesheuvel .kpp = __VECS(dh_tv_template) 3563802c7f1cSSalvatore Benedetto } 3564802c7f1cSSalvatore Benedetto }, { 3565e448370dSJussi Kivilinna .alg = "digest_null", 3566e448370dSJussi Kivilinna .test = alg_test_null, 3567e448370dSJussi Kivilinna }, { 356864d1cdfbSStephan Mueller .alg = "drbg_nopr_ctr_aes128", 356964d1cdfbSStephan Mueller .test = alg_test_drbg, 357064d1cdfbSStephan Mueller .fips_allowed = 1, 357164d1cdfbSStephan Mueller .suite = { 357221c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_ctr_aes128_tv_template) 357364d1cdfbSStephan Mueller } 357464d1cdfbSStephan Mueller }, { 357564d1cdfbSStephan Mueller .alg = "drbg_nopr_ctr_aes192", 357664d1cdfbSStephan Mueller .test = alg_test_drbg, 357764d1cdfbSStephan Mueller .fips_allowed = 1, 357864d1cdfbSStephan Mueller .suite = { 357921c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_ctr_aes192_tv_template) 358064d1cdfbSStephan Mueller } 358164d1cdfbSStephan Mueller }, { 358264d1cdfbSStephan Mueller .alg = "drbg_nopr_ctr_aes256", 358364d1cdfbSStephan Mueller .test = alg_test_drbg, 358464d1cdfbSStephan Mueller .fips_allowed = 1, 358564d1cdfbSStephan Mueller .suite = { 358621c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_ctr_aes256_tv_template) 358764d1cdfbSStephan Mueller } 358864d1cdfbSStephan Mueller }, { 358964d1cdfbSStephan Mueller /* 359064d1cdfbSStephan Mueller * There is no need to specifically test the DRBG with every 359164d1cdfbSStephan Mueller * backend cipher -- covered by drbg_nopr_hmac_sha256 test 359264d1cdfbSStephan Mueller */ 359364d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha1", 359464d1cdfbSStephan Mueller .fips_allowed = 1, 359564d1cdfbSStephan Mueller .test = alg_test_null, 359664d1cdfbSStephan Mueller }, { 359764d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha256", 359864d1cdfbSStephan Mueller .test = alg_test_drbg, 359964d1cdfbSStephan Mueller .fips_allowed = 1, 360064d1cdfbSStephan Mueller .suite = { 360121c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_hmac_sha256_tv_template) 360264d1cdfbSStephan Mueller } 360364d1cdfbSStephan Mueller }, { 360464d1cdfbSStephan Mueller /* covered by drbg_nopr_hmac_sha256 test */ 360564d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha384", 360664d1cdfbSStephan Mueller .fips_allowed = 1, 360764d1cdfbSStephan Mueller .test = alg_test_null, 360864d1cdfbSStephan Mueller }, { 360964d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha512", 361064d1cdfbSStephan Mueller .test = alg_test_null, 361164d1cdfbSStephan Mueller .fips_allowed = 1, 361264d1cdfbSStephan Mueller }, { 361364d1cdfbSStephan Mueller .alg = "drbg_nopr_sha1", 361464d1cdfbSStephan Mueller .fips_allowed = 1, 361564d1cdfbSStephan Mueller .test = alg_test_null, 361664d1cdfbSStephan Mueller }, { 361764d1cdfbSStephan Mueller .alg = "drbg_nopr_sha256", 361864d1cdfbSStephan Mueller .test = alg_test_drbg, 361964d1cdfbSStephan Mueller .fips_allowed = 1, 362064d1cdfbSStephan Mueller .suite = { 362121c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_sha256_tv_template) 362264d1cdfbSStephan Mueller } 362364d1cdfbSStephan Mueller }, { 362464d1cdfbSStephan Mueller /* covered by drbg_nopr_sha256 test */ 362564d1cdfbSStephan Mueller .alg = "drbg_nopr_sha384", 362664d1cdfbSStephan Mueller .fips_allowed = 1, 362764d1cdfbSStephan Mueller .test = alg_test_null, 362864d1cdfbSStephan Mueller }, { 362964d1cdfbSStephan Mueller .alg = "drbg_nopr_sha512", 363064d1cdfbSStephan Mueller .fips_allowed = 1, 363164d1cdfbSStephan Mueller .test = alg_test_null, 363264d1cdfbSStephan Mueller }, { 363364d1cdfbSStephan Mueller .alg = "drbg_pr_ctr_aes128", 363464d1cdfbSStephan Mueller .test = alg_test_drbg, 363564d1cdfbSStephan Mueller .fips_allowed = 1, 363664d1cdfbSStephan Mueller .suite = { 363721c8e720SArd Biesheuvel .drbg = __VECS(drbg_pr_ctr_aes128_tv_template) 363864d1cdfbSStephan Mueller } 363964d1cdfbSStephan Mueller }, { 364064d1cdfbSStephan Mueller /* covered by drbg_pr_ctr_aes128 test */ 364164d1cdfbSStephan Mueller .alg = "drbg_pr_ctr_aes192", 364264d1cdfbSStephan Mueller .fips_allowed = 1, 364364d1cdfbSStephan Mueller .test = alg_test_null, 364464d1cdfbSStephan Mueller }, { 364564d1cdfbSStephan Mueller .alg = "drbg_pr_ctr_aes256", 364664d1cdfbSStephan Mueller .fips_allowed = 1, 364764d1cdfbSStephan Mueller .test = alg_test_null, 364864d1cdfbSStephan Mueller }, { 364964d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha1", 365064d1cdfbSStephan Mueller .fips_allowed = 1, 365164d1cdfbSStephan Mueller .test = alg_test_null, 365264d1cdfbSStephan Mueller }, { 365364d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha256", 365464d1cdfbSStephan Mueller .test = alg_test_drbg, 365564d1cdfbSStephan Mueller .fips_allowed = 1, 365664d1cdfbSStephan Mueller .suite = { 365721c8e720SArd Biesheuvel .drbg = __VECS(drbg_pr_hmac_sha256_tv_template) 365864d1cdfbSStephan Mueller } 365964d1cdfbSStephan Mueller }, { 366064d1cdfbSStephan Mueller /* covered by drbg_pr_hmac_sha256 test */ 366164d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha384", 366264d1cdfbSStephan Mueller .fips_allowed = 1, 366364d1cdfbSStephan Mueller .test = alg_test_null, 366464d1cdfbSStephan Mueller }, { 366564d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha512", 366664d1cdfbSStephan Mueller .test = alg_test_null, 366764d1cdfbSStephan Mueller .fips_allowed = 1, 366864d1cdfbSStephan Mueller }, { 366964d1cdfbSStephan Mueller .alg = "drbg_pr_sha1", 367064d1cdfbSStephan Mueller .fips_allowed = 1, 367164d1cdfbSStephan Mueller .test = alg_test_null, 367264d1cdfbSStephan Mueller }, { 367364d1cdfbSStephan Mueller .alg = "drbg_pr_sha256", 367464d1cdfbSStephan Mueller .test = alg_test_drbg, 367564d1cdfbSStephan Mueller .fips_allowed = 1, 367664d1cdfbSStephan Mueller .suite = { 367721c8e720SArd Biesheuvel .drbg = __VECS(drbg_pr_sha256_tv_template) 367864d1cdfbSStephan Mueller } 367964d1cdfbSStephan Mueller }, { 368064d1cdfbSStephan Mueller /* covered by drbg_pr_sha256 test */ 368164d1cdfbSStephan Mueller .alg = "drbg_pr_sha384", 368264d1cdfbSStephan Mueller .fips_allowed = 1, 368364d1cdfbSStephan Mueller .test = alg_test_null, 368464d1cdfbSStephan Mueller }, { 368564d1cdfbSStephan Mueller .alg = "drbg_pr_sha512", 368664d1cdfbSStephan Mueller .fips_allowed = 1, 368764d1cdfbSStephan Mueller .test = alg_test_null, 368864d1cdfbSStephan Mueller }, { 3689da7f033dSHerbert Xu .alg = "ecb(aes)", 36901aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3691a1915d51SJarod Wilson .fips_allowed = 1, 3692da7f033dSHerbert Xu .suite = { 369392a4c9feSEric Biggers .cipher = __VECS(aes_tv_template) 3694da7f033dSHerbert Xu } 3695da7f033dSHerbert Xu }, { 3696da7f033dSHerbert Xu .alg = "ecb(anubis)", 36971aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3698da7f033dSHerbert Xu .suite = { 369992a4c9feSEric Biggers .cipher = __VECS(anubis_tv_template) 3700da7f033dSHerbert Xu } 3701da7f033dSHerbert Xu }, { 3702da7f033dSHerbert Xu .alg = "ecb(arc4)", 37031aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3704da7f033dSHerbert Xu .suite = { 370592a4c9feSEric Biggers .cipher = __VECS(arc4_tv_template) 3706da7f033dSHerbert Xu } 3707da7f033dSHerbert Xu }, { 3708da7f033dSHerbert Xu .alg = "ecb(blowfish)", 37091aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3710da7f033dSHerbert Xu .suite = { 371192a4c9feSEric Biggers .cipher = __VECS(bf_tv_template) 3712da7f033dSHerbert Xu } 3713da7f033dSHerbert Xu }, { 3714da7f033dSHerbert Xu .alg = "ecb(camellia)", 37151aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3716da7f033dSHerbert Xu .suite = { 371792a4c9feSEric Biggers .cipher = __VECS(camellia_tv_template) 3718da7f033dSHerbert Xu } 3719da7f033dSHerbert Xu }, { 3720da7f033dSHerbert Xu .alg = "ecb(cast5)", 37211aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3722da7f033dSHerbert Xu .suite = { 372392a4c9feSEric Biggers .cipher = __VECS(cast5_tv_template) 3724da7f033dSHerbert Xu } 3725da7f033dSHerbert Xu }, { 3726da7f033dSHerbert Xu .alg = "ecb(cast6)", 37271aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3728da7f033dSHerbert Xu .suite = { 372992a4c9feSEric Biggers .cipher = __VECS(cast6_tv_template) 3730da7f033dSHerbert Xu } 3731da7f033dSHerbert Xu }, { 3732e448370dSJussi Kivilinna .alg = "ecb(cipher_null)", 3733e448370dSJussi Kivilinna .test = alg_test_null, 37346175ca2bSMilan Broz .fips_allowed = 1, 3735e448370dSJussi Kivilinna }, { 3736da7f033dSHerbert Xu .alg = "ecb(des)", 37371aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3738da7f033dSHerbert Xu .suite = { 373992a4c9feSEric Biggers .cipher = __VECS(des_tv_template) 3740da7f033dSHerbert Xu } 3741da7f033dSHerbert Xu }, { 3742da7f033dSHerbert Xu .alg = "ecb(des3_ede)", 37431aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3744a1915d51SJarod Wilson .fips_allowed = 1, 3745da7f033dSHerbert Xu .suite = { 374692a4c9feSEric Biggers .cipher = __VECS(des3_ede_tv_template) 3747da7f033dSHerbert Xu } 3748da7f033dSHerbert Xu }, { 374966e5bd00SJussi Kivilinna .alg = "ecb(fcrypt)", 375066e5bd00SJussi Kivilinna .test = alg_test_skcipher, 375166e5bd00SJussi Kivilinna .suite = { 375266e5bd00SJussi Kivilinna .cipher = { 375392a4c9feSEric Biggers .vecs = fcrypt_pcbc_tv_template, 375466e5bd00SJussi Kivilinna .count = 1 375566e5bd00SJussi Kivilinna } 375666e5bd00SJussi Kivilinna } 375766e5bd00SJussi Kivilinna }, { 3758da7f033dSHerbert Xu .alg = "ecb(khazad)", 37591aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3760da7f033dSHerbert Xu .suite = { 376192a4c9feSEric Biggers .cipher = __VECS(khazad_tv_template) 3762da7f033dSHerbert Xu } 3763da7f033dSHerbert Xu }, { 376415f47ce5SGilad Ben-Yossef /* Same as ecb(aes) except the key is stored in 376515f47ce5SGilad Ben-Yossef * hardware secure memory which we reference by index 376615f47ce5SGilad Ben-Yossef */ 376715f47ce5SGilad Ben-Yossef .alg = "ecb(paes)", 376815f47ce5SGilad Ben-Yossef .test = alg_test_null, 376915f47ce5SGilad Ben-Yossef .fips_allowed = 1, 377015f47ce5SGilad Ben-Yossef }, { 3771da7f033dSHerbert Xu .alg = "ecb(seed)", 37721aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3773da7f033dSHerbert Xu .suite = { 377492a4c9feSEric Biggers .cipher = __VECS(seed_tv_template) 3775da7f033dSHerbert Xu } 3776da7f033dSHerbert Xu }, { 3777da7f033dSHerbert Xu .alg = "ecb(serpent)", 37781aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3779da7f033dSHerbert Xu .suite = { 378092a4c9feSEric Biggers .cipher = __VECS(serpent_tv_template) 3781da7f033dSHerbert Xu } 3782da7f033dSHerbert Xu }, { 3783cd83a8a7SGilad Ben-Yossef .alg = "ecb(sm4)", 3784cd83a8a7SGilad Ben-Yossef .test = alg_test_skcipher, 3785cd83a8a7SGilad Ben-Yossef .suite = { 378692a4c9feSEric Biggers .cipher = __VECS(sm4_tv_template) 3787cd83a8a7SGilad Ben-Yossef } 3788cd83a8a7SGilad Ben-Yossef }, { 3789da7f033dSHerbert Xu .alg = "ecb(tea)", 37901aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3791da7f033dSHerbert Xu .suite = { 379292a4c9feSEric Biggers .cipher = __VECS(tea_tv_template) 3793da7f033dSHerbert Xu } 3794da7f033dSHerbert Xu }, { 3795da7f033dSHerbert Xu .alg = "ecb(tnepres)", 37961aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3797da7f033dSHerbert Xu .suite = { 379892a4c9feSEric Biggers .cipher = __VECS(tnepres_tv_template) 3799da7f033dSHerbert Xu } 3800da7f033dSHerbert Xu }, { 3801da7f033dSHerbert Xu .alg = "ecb(twofish)", 38021aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3803da7f033dSHerbert Xu .suite = { 380492a4c9feSEric Biggers .cipher = __VECS(tf_tv_template) 3805da7f033dSHerbert Xu } 3806da7f033dSHerbert Xu }, { 3807da7f033dSHerbert Xu .alg = "ecb(xeta)", 38081aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3809da7f033dSHerbert Xu .suite = { 381092a4c9feSEric Biggers .cipher = __VECS(xeta_tv_template) 3811da7f033dSHerbert Xu } 3812da7f033dSHerbert Xu }, { 3813da7f033dSHerbert Xu .alg = "ecb(xtea)", 38141aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3815da7f033dSHerbert Xu .suite = { 381692a4c9feSEric Biggers .cipher = __VECS(xtea_tv_template) 3817da7f033dSHerbert Xu } 3818da7f033dSHerbert Xu }, { 38193c4b2390SSalvatore Benedetto .alg = "ecdh", 38203c4b2390SSalvatore Benedetto .test = alg_test_kpp, 38213c4b2390SSalvatore Benedetto .fips_allowed = 1, 38223c4b2390SSalvatore Benedetto .suite = { 382321c8e720SArd Biesheuvel .kpp = __VECS(ecdh_tv_template) 38243c4b2390SSalvatore Benedetto } 38253c4b2390SSalvatore Benedetto }, { 382632fbdbd3SVitaly Chikunov .alg = "ecrdsa", 382732fbdbd3SVitaly Chikunov .test = alg_test_akcipher, 382832fbdbd3SVitaly Chikunov .suite = { 382932fbdbd3SVitaly Chikunov .akcipher = __VECS(ecrdsa_tv_template) 383032fbdbd3SVitaly Chikunov } 383132fbdbd3SVitaly Chikunov }, { 3832da7f033dSHerbert Xu .alg = "gcm(aes)", 3833da7f033dSHerbert Xu .test = alg_test_aead, 3834a1915d51SJarod Wilson .fips_allowed = 1, 3835da7f033dSHerbert Xu .suite = { 3836a0d608eeSEric Biggers .aead = __VECS(aes_gcm_tv_template) 3837da7f033dSHerbert Xu } 3838da7f033dSHerbert Xu }, { 3839507069c9SYouquan, Song .alg = "ghash", 3840507069c9SYouquan, Song .test = alg_test_hash, 384118c0ebd2SJarod Wilson .fips_allowed = 1, 3842507069c9SYouquan, Song .suite = { 384321c8e720SArd Biesheuvel .hash = __VECS(ghash_tv_template) 3844507069c9SYouquan, Song } 3845507069c9SYouquan, Song }, { 3846da7f033dSHerbert Xu .alg = "hmac(md5)", 3847da7f033dSHerbert Xu .test = alg_test_hash, 3848da7f033dSHerbert Xu .suite = { 384921c8e720SArd Biesheuvel .hash = __VECS(hmac_md5_tv_template) 3850da7f033dSHerbert Xu } 3851da7f033dSHerbert Xu }, { 3852da7f033dSHerbert Xu .alg = "hmac(rmd128)", 3853da7f033dSHerbert Xu .test = alg_test_hash, 3854da7f033dSHerbert Xu .suite = { 385521c8e720SArd Biesheuvel .hash = __VECS(hmac_rmd128_tv_template) 3856da7f033dSHerbert Xu } 3857da7f033dSHerbert Xu }, { 3858da7f033dSHerbert Xu .alg = "hmac(rmd160)", 3859da7f033dSHerbert Xu .test = alg_test_hash, 3860da7f033dSHerbert Xu .suite = { 386121c8e720SArd Biesheuvel .hash = __VECS(hmac_rmd160_tv_template) 3862da7f033dSHerbert Xu } 3863da7f033dSHerbert Xu }, { 3864da7f033dSHerbert Xu .alg = "hmac(sha1)", 3865da7f033dSHerbert Xu .test = alg_test_hash, 3866a1915d51SJarod Wilson .fips_allowed = 1, 3867da7f033dSHerbert Xu .suite = { 386821c8e720SArd Biesheuvel .hash = __VECS(hmac_sha1_tv_template) 3869da7f033dSHerbert Xu } 3870da7f033dSHerbert Xu }, { 3871da7f033dSHerbert Xu .alg = "hmac(sha224)", 3872da7f033dSHerbert Xu .test = alg_test_hash, 3873a1915d51SJarod Wilson .fips_allowed = 1, 3874da7f033dSHerbert Xu .suite = { 387521c8e720SArd Biesheuvel .hash = __VECS(hmac_sha224_tv_template) 3876da7f033dSHerbert Xu } 3877da7f033dSHerbert Xu }, { 3878da7f033dSHerbert Xu .alg = "hmac(sha256)", 3879da7f033dSHerbert Xu .test = alg_test_hash, 3880a1915d51SJarod Wilson .fips_allowed = 1, 3881da7f033dSHerbert Xu .suite = { 388221c8e720SArd Biesheuvel .hash = __VECS(hmac_sha256_tv_template) 3883da7f033dSHerbert Xu } 3884da7f033dSHerbert Xu }, { 388598eca72fSraveendra padasalagi .alg = "hmac(sha3-224)", 388698eca72fSraveendra padasalagi .test = alg_test_hash, 388798eca72fSraveendra padasalagi .fips_allowed = 1, 388898eca72fSraveendra padasalagi .suite = { 388921c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_224_tv_template) 389098eca72fSraveendra padasalagi } 389198eca72fSraveendra padasalagi }, { 389298eca72fSraveendra padasalagi .alg = "hmac(sha3-256)", 389398eca72fSraveendra padasalagi .test = alg_test_hash, 389498eca72fSraveendra padasalagi .fips_allowed = 1, 389598eca72fSraveendra padasalagi .suite = { 389621c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_256_tv_template) 389798eca72fSraveendra padasalagi } 389898eca72fSraveendra padasalagi }, { 389998eca72fSraveendra padasalagi .alg = "hmac(sha3-384)", 390098eca72fSraveendra padasalagi .test = alg_test_hash, 390198eca72fSraveendra padasalagi .fips_allowed = 1, 390298eca72fSraveendra padasalagi .suite = { 390321c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_384_tv_template) 390498eca72fSraveendra padasalagi } 390598eca72fSraveendra padasalagi }, { 390698eca72fSraveendra padasalagi .alg = "hmac(sha3-512)", 390798eca72fSraveendra padasalagi .test = alg_test_hash, 390898eca72fSraveendra padasalagi .fips_allowed = 1, 390998eca72fSraveendra padasalagi .suite = { 391021c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_512_tv_template) 391198eca72fSraveendra padasalagi } 391298eca72fSraveendra padasalagi }, { 3913da7f033dSHerbert Xu .alg = "hmac(sha384)", 3914da7f033dSHerbert Xu .test = alg_test_hash, 3915a1915d51SJarod Wilson .fips_allowed = 1, 3916da7f033dSHerbert Xu .suite = { 391721c8e720SArd Biesheuvel .hash = __VECS(hmac_sha384_tv_template) 3918da7f033dSHerbert Xu } 3919da7f033dSHerbert Xu }, { 3920da7f033dSHerbert Xu .alg = "hmac(sha512)", 3921da7f033dSHerbert Xu .test = alg_test_hash, 3922a1915d51SJarod Wilson .fips_allowed = 1, 3923da7f033dSHerbert Xu .suite = { 392421c8e720SArd Biesheuvel .hash = __VECS(hmac_sha512_tv_template) 3925da7f033dSHerbert Xu } 3926da7f033dSHerbert Xu }, { 392725a0b9d4SVitaly Chikunov .alg = "hmac(streebog256)", 392825a0b9d4SVitaly Chikunov .test = alg_test_hash, 392925a0b9d4SVitaly Chikunov .suite = { 393025a0b9d4SVitaly Chikunov .hash = __VECS(hmac_streebog256_tv_template) 393125a0b9d4SVitaly Chikunov } 393225a0b9d4SVitaly Chikunov }, { 393325a0b9d4SVitaly Chikunov .alg = "hmac(streebog512)", 393425a0b9d4SVitaly Chikunov .test = alg_test_hash, 393525a0b9d4SVitaly Chikunov .suite = { 393625a0b9d4SVitaly Chikunov .hash = __VECS(hmac_streebog512_tv_template) 393725a0b9d4SVitaly Chikunov } 393825a0b9d4SVitaly Chikunov }, { 3939bb5530e4SStephan Mueller .alg = "jitterentropy_rng", 3940bb5530e4SStephan Mueller .fips_allowed = 1, 3941bb5530e4SStephan Mueller .test = alg_test_null, 3942bb5530e4SStephan Mueller }, { 394335351988SStephan Mueller .alg = "kw(aes)", 394435351988SStephan Mueller .test = alg_test_skcipher, 394535351988SStephan Mueller .fips_allowed = 1, 394635351988SStephan Mueller .suite = { 394792a4c9feSEric Biggers .cipher = __VECS(aes_kw_tv_template) 394835351988SStephan Mueller } 394935351988SStephan Mueller }, { 3950da7f033dSHerbert Xu .alg = "lrw(aes)", 39511aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3952da7f033dSHerbert Xu .suite = { 395392a4c9feSEric Biggers .cipher = __VECS(aes_lrw_tv_template) 3954da7f033dSHerbert Xu } 3955da7f033dSHerbert Xu }, { 39560840605eSJussi Kivilinna .alg = "lrw(camellia)", 39570840605eSJussi Kivilinna .test = alg_test_skcipher, 39580840605eSJussi Kivilinna .suite = { 395992a4c9feSEric Biggers .cipher = __VECS(camellia_lrw_tv_template) 39600840605eSJussi Kivilinna } 39610840605eSJussi Kivilinna }, { 39629b8b0405SJohannes Goetzfried .alg = "lrw(cast6)", 39639b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 39649b8b0405SJohannes Goetzfried .suite = { 396592a4c9feSEric Biggers .cipher = __VECS(cast6_lrw_tv_template) 39669b8b0405SJohannes Goetzfried } 39679b8b0405SJohannes Goetzfried }, { 3968d7bfc0faSJussi Kivilinna .alg = "lrw(serpent)", 3969d7bfc0faSJussi Kivilinna .test = alg_test_skcipher, 3970d7bfc0faSJussi Kivilinna .suite = { 397192a4c9feSEric Biggers .cipher = __VECS(serpent_lrw_tv_template) 3972d7bfc0faSJussi Kivilinna } 3973d7bfc0faSJussi Kivilinna }, { 39740b2a1551SJussi Kivilinna .alg = "lrw(twofish)", 39750b2a1551SJussi Kivilinna .test = alg_test_skcipher, 39760b2a1551SJussi Kivilinna .suite = { 397792a4c9feSEric Biggers .cipher = __VECS(tf_lrw_tv_template) 39780b2a1551SJussi Kivilinna } 39790b2a1551SJussi Kivilinna }, { 39801443cc9bSKOVACS Krisztian .alg = "lz4", 39811443cc9bSKOVACS Krisztian .test = alg_test_comp, 39821443cc9bSKOVACS Krisztian .fips_allowed = 1, 39831443cc9bSKOVACS Krisztian .suite = { 39841443cc9bSKOVACS Krisztian .comp = { 398521c8e720SArd Biesheuvel .comp = __VECS(lz4_comp_tv_template), 398621c8e720SArd Biesheuvel .decomp = __VECS(lz4_decomp_tv_template) 39871443cc9bSKOVACS Krisztian } 39881443cc9bSKOVACS Krisztian } 39891443cc9bSKOVACS Krisztian }, { 39901443cc9bSKOVACS Krisztian .alg = "lz4hc", 39911443cc9bSKOVACS Krisztian .test = alg_test_comp, 39921443cc9bSKOVACS Krisztian .fips_allowed = 1, 39931443cc9bSKOVACS Krisztian .suite = { 39941443cc9bSKOVACS Krisztian .comp = { 399521c8e720SArd Biesheuvel .comp = __VECS(lz4hc_comp_tv_template), 399621c8e720SArd Biesheuvel .decomp = __VECS(lz4hc_decomp_tv_template) 39971443cc9bSKOVACS Krisztian } 39981443cc9bSKOVACS Krisztian } 39991443cc9bSKOVACS Krisztian }, { 4000da7f033dSHerbert Xu .alg = "lzo", 4001da7f033dSHerbert Xu .test = alg_test_comp, 40020818904dSMilan Broz .fips_allowed = 1, 4003da7f033dSHerbert Xu .suite = { 4004da7f033dSHerbert Xu .comp = { 400521c8e720SArd Biesheuvel .comp = __VECS(lzo_comp_tv_template), 400621c8e720SArd Biesheuvel .decomp = __VECS(lzo_decomp_tv_template) 4007da7f033dSHerbert Xu } 4008da7f033dSHerbert Xu } 4009da7f033dSHerbert Xu }, { 4010da7f033dSHerbert Xu .alg = "md4", 4011da7f033dSHerbert Xu .test = alg_test_hash, 4012da7f033dSHerbert Xu .suite = { 401321c8e720SArd Biesheuvel .hash = __VECS(md4_tv_template) 4014da7f033dSHerbert Xu } 4015da7f033dSHerbert Xu }, { 4016da7f033dSHerbert Xu .alg = "md5", 4017da7f033dSHerbert Xu .test = alg_test_hash, 4018da7f033dSHerbert Xu .suite = { 401921c8e720SArd Biesheuvel .hash = __VECS(md5_tv_template) 4020da7f033dSHerbert Xu } 4021da7f033dSHerbert Xu }, { 4022da7f033dSHerbert Xu .alg = "michael_mic", 4023da7f033dSHerbert Xu .test = alg_test_hash, 4024da7f033dSHerbert Xu .suite = { 402521c8e720SArd Biesheuvel .hash = __VECS(michael_mic_tv_template) 4026da7f033dSHerbert Xu } 4027da7f033dSHerbert Xu }, { 40284feb4c59SOndrej Mosnacek .alg = "morus1280", 40294feb4c59SOndrej Mosnacek .test = alg_test_aead, 40304feb4c59SOndrej Mosnacek .suite = { 4031a0d608eeSEric Biggers .aead = __VECS(morus1280_tv_template) 40324feb4c59SOndrej Mosnacek } 40334feb4c59SOndrej Mosnacek }, { 40344feb4c59SOndrej Mosnacek .alg = "morus640", 40354feb4c59SOndrej Mosnacek .test = alg_test_aead, 40364feb4c59SOndrej Mosnacek .suite = { 4037a0d608eeSEric Biggers .aead = __VECS(morus640_tv_template) 40384feb4c59SOndrej Mosnacek } 40394feb4c59SOndrej Mosnacek }, { 404026609a21SEric Biggers .alg = "nhpoly1305", 404126609a21SEric Biggers .test = alg_test_hash, 404226609a21SEric Biggers .suite = { 404326609a21SEric Biggers .hash = __VECS(nhpoly1305_tv_template) 404426609a21SEric Biggers } 404526609a21SEric Biggers }, { 4046ba0e14acSPuneet Saxena .alg = "ofb(aes)", 4047ba0e14acSPuneet Saxena .test = alg_test_skcipher, 4048ba0e14acSPuneet Saxena .fips_allowed = 1, 4049ba0e14acSPuneet Saxena .suite = { 405092a4c9feSEric Biggers .cipher = __VECS(aes_ofb_tv_template) 4051ba0e14acSPuneet Saxena } 4052ba0e14acSPuneet Saxena }, { 4053a794d8d8SGilad Ben-Yossef /* Same as ofb(aes) except the key is stored in 4054a794d8d8SGilad Ben-Yossef * hardware secure memory which we reference by index 4055a794d8d8SGilad Ben-Yossef */ 4056a794d8d8SGilad Ben-Yossef .alg = "ofb(paes)", 4057a794d8d8SGilad Ben-Yossef .test = alg_test_null, 4058a794d8d8SGilad Ben-Yossef .fips_allowed = 1, 4059a794d8d8SGilad Ben-Yossef }, { 4060da7f033dSHerbert Xu .alg = "pcbc(fcrypt)", 40611aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4062da7f033dSHerbert Xu .suite = { 406392a4c9feSEric Biggers .cipher = __VECS(fcrypt_pcbc_tv_template) 4064da7f033dSHerbert Xu } 4065da7f033dSHerbert Xu }, { 40661207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha224)", 40671207107cSStephan Mueller .test = alg_test_null, 40681207107cSStephan Mueller .fips_allowed = 1, 40691207107cSStephan Mueller }, { 40701207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha256)", 40711207107cSStephan Mueller .test = alg_test_akcipher, 40721207107cSStephan Mueller .fips_allowed = 1, 40731207107cSStephan Mueller .suite = { 40741207107cSStephan Mueller .akcipher = __VECS(pkcs1pad_rsa_tv_template) 40751207107cSStephan Mueller } 40761207107cSStephan Mueller }, { 40771207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha384)", 40781207107cSStephan Mueller .test = alg_test_null, 40791207107cSStephan Mueller .fips_allowed = 1, 40801207107cSStephan Mueller }, { 40811207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha512)", 40821207107cSStephan Mueller .test = alg_test_null, 40831207107cSStephan Mueller .fips_allowed = 1, 40841207107cSStephan Mueller }, { 4085eee9dc61SMartin Willi .alg = "poly1305", 4086eee9dc61SMartin Willi .test = alg_test_hash, 4087eee9dc61SMartin Willi .suite = { 408821c8e720SArd Biesheuvel .hash = __VECS(poly1305_tv_template) 4089eee9dc61SMartin Willi } 4090eee9dc61SMartin Willi }, { 4091da7f033dSHerbert Xu .alg = "rfc3686(ctr(aes))", 40921aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4093a1915d51SJarod Wilson .fips_allowed = 1, 4094da7f033dSHerbert Xu .suite = { 409592a4c9feSEric Biggers .cipher = __VECS(aes_ctr_rfc3686_tv_template) 4096da7f033dSHerbert Xu } 4097da7f033dSHerbert Xu }, { 40983f31a740SHerbert Xu .alg = "rfc4106(gcm(aes))", 409969435b94SAdrian Hoban .test = alg_test_aead, 4100db71f29aSJarod Wilson .fips_allowed = 1, 410169435b94SAdrian Hoban .suite = { 4102a0d608eeSEric Biggers .aead = __VECS(aes_gcm_rfc4106_tv_template) 410369435b94SAdrian Hoban } 410469435b94SAdrian Hoban }, { 4105544c436aSHerbert Xu .alg = "rfc4309(ccm(aes))", 41065d667322SJarod Wilson .test = alg_test_aead, 4107a1915d51SJarod Wilson .fips_allowed = 1, 41085d667322SJarod Wilson .suite = { 4109a0d608eeSEric Biggers .aead = __VECS(aes_ccm_rfc4309_tv_template) 41105d667322SJarod Wilson } 41115d667322SJarod Wilson }, { 4112bb68745eSHerbert Xu .alg = "rfc4543(gcm(aes))", 4113e9b7441aSJussi Kivilinna .test = alg_test_aead, 4114e9b7441aSJussi Kivilinna .suite = { 4115a0d608eeSEric Biggers .aead = __VECS(aes_gcm_rfc4543_tv_template) 4116e9b7441aSJussi Kivilinna } 4117e9b7441aSJussi Kivilinna }, { 4118af2b76b5SMartin Willi .alg = "rfc7539(chacha20,poly1305)", 4119af2b76b5SMartin Willi .test = alg_test_aead, 4120af2b76b5SMartin Willi .suite = { 4121a0d608eeSEric Biggers .aead = __VECS(rfc7539_tv_template) 4122af2b76b5SMartin Willi } 4123af2b76b5SMartin Willi }, { 41245900758dSMartin Willi .alg = "rfc7539esp(chacha20,poly1305)", 41255900758dSMartin Willi .test = alg_test_aead, 41265900758dSMartin Willi .suite = { 4127a0d608eeSEric Biggers .aead = __VECS(rfc7539esp_tv_template) 41285900758dSMartin Willi } 41295900758dSMartin Willi }, { 4130da7f033dSHerbert Xu .alg = "rmd128", 4131da7f033dSHerbert Xu .test = alg_test_hash, 4132da7f033dSHerbert Xu .suite = { 413321c8e720SArd Biesheuvel .hash = __VECS(rmd128_tv_template) 4134da7f033dSHerbert Xu } 4135da7f033dSHerbert Xu }, { 4136da7f033dSHerbert Xu .alg = "rmd160", 4137da7f033dSHerbert Xu .test = alg_test_hash, 4138da7f033dSHerbert Xu .suite = { 413921c8e720SArd Biesheuvel .hash = __VECS(rmd160_tv_template) 4140da7f033dSHerbert Xu } 4141da7f033dSHerbert Xu }, { 4142da7f033dSHerbert Xu .alg = "rmd256", 4143da7f033dSHerbert Xu .test = alg_test_hash, 4144da7f033dSHerbert Xu .suite = { 414521c8e720SArd Biesheuvel .hash = __VECS(rmd256_tv_template) 4146da7f033dSHerbert Xu } 4147da7f033dSHerbert Xu }, { 4148da7f033dSHerbert Xu .alg = "rmd320", 4149da7f033dSHerbert Xu .test = alg_test_hash, 4150da7f033dSHerbert Xu .suite = { 415121c8e720SArd Biesheuvel .hash = __VECS(rmd320_tv_template) 4152da7f033dSHerbert Xu } 4153da7f033dSHerbert Xu }, { 4154946cc463STadeusz Struk .alg = "rsa", 4155946cc463STadeusz Struk .test = alg_test_akcipher, 4156946cc463STadeusz Struk .fips_allowed = 1, 4157946cc463STadeusz Struk .suite = { 415821c8e720SArd Biesheuvel .akcipher = __VECS(rsa_tv_template) 4159946cc463STadeusz Struk } 4160946cc463STadeusz Struk }, { 4161da7f033dSHerbert Xu .alg = "salsa20", 41621aa4ecd9SHerbert Xu .test = alg_test_skcipher, 4163da7f033dSHerbert Xu .suite = { 416492a4c9feSEric Biggers .cipher = __VECS(salsa20_stream_tv_template) 4165da7f033dSHerbert Xu } 4166da7f033dSHerbert Xu }, { 4167da7f033dSHerbert Xu .alg = "sha1", 4168da7f033dSHerbert Xu .test = alg_test_hash, 4169a1915d51SJarod Wilson .fips_allowed = 1, 4170da7f033dSHerbert Xu .suite = { 417121c8e720SArd Biesheuvel .hash = __VECS(sha1_tv_template) 4172da7f033dSHerbert Xu } 4173da7f033dSHerbert Xu }, { 4174da7f033dSHerbert Xu .alg = "sha224", 4175da7f033dSHerbert Xu .test = alg_test_hash, 4176a1915d51SJarod Wilson .fips_allowed = 1, 4177da7f033dSHerbert Xu .suite = { 417821c8e720SArd Biesheuvel .hash = __VECS(sha224_tv_template) 4179da7f033dSHerbert Xu } 4180da7f033dSHerbert Xu }, { 4181da7f033dSHerbert Xu .alg = "sha256", 4182da7f033dSHerbert Xu .test = alg_test_hash, 4183a1915d51SJarod Wilson .fips_allowed = 1, 4184da7f033dSHerbert Xu .suite = { 418521c8e720SArd Biesheuvel .hash = __VECS(sha256_tv_template) 4186da7f033dSHerbert Xu } 4187da7f033dSHerbert Xu }, { 418879cc6ab8Sraveendra padasalagi .alg = "sha3-224", 418979cc6ab8Sraveendra padasalagi .test = alg_test_hash, 419079cc6ab8Sraveendra padasalagi .fips_allowed = 1, 419179cc6ab8Sraveendra padasalagi .suite = { 419221c8e720SArd Biesheuvel .hash = __VECS(sha3_224_tv_template) 419379cc6ab8Sraveendra padasalagi } 419479cc6ab8Sraveendra padasalagi }, { 419579cc6ab8Sraveendra padasalagi .alg = "sha3-256", 419679cc6ab8Sraveendra padasalagi .test = alg_test_hash, 419779cc6ab8Sraveendra padasalagi .fips_allowed = 1, 419879cc6ab8Sraveendra padasalagi .suite = { 419921c8e720SArd Biesheuvel .hash = __VECS(sha3_256_tv_template) 420079cc6ab8Sraveendra padasalagi } 420179cc6ab8Sraveendra padasalagi }, { 420279cc6ab8Sraveendra padasalagi .alg = "sha3-384", 420379cc6ab8Sraveendra padasalagi .test = alg_test_hash, 420479cc6ab8Sraveendra padasalagi .fips_allowed = 1, 420579cc6ab8Sraveendra padasalagi .suite = { 420621c8e720SArd Biesheuvel .hash = __VECS(sha3_384_tv_template) 420779cc6ab8Sraveendra padasalagi } 420879cc6ab8Sraveendra padasalagi }, { 420979cc6ab8Sraveendra padasalagi .alg = "sha3-512", 421079cc6ab8Sraveendra padasalagi .test = alg_test_hash, 421179cc6ab8Sraveendra padasalagi .fips_allowed = 1, 421279cc6ab8Sraveendra padasalagi .suite = { 421321c8e720SArd Biesheuvel .hash = __VECS(sha3_512_tv_template) 421479cc6ab8Sraveendra padasalagi } 421579cc6ab8Sraveendra padasalagi }, { 4216da7f033dSHerbert Xu .alg = "sha384", 4217da7f033dSHerbert Xu .test = alg_test_hash, 4218a1915d51SJarod Wilson .fips_allowed = 1, 4219da7f033dSHerbert Xu .suite = { 422021c8e720SArd Biesheuvel .hash = __VECS(sha384_tv_template) 4221da7f033dSHerbert Xu } 4222da7f033dSHerbert Xu }, { 4223da7f033dSHerbert Xu .alg = "sha512", 4224da7f033dSHerbert Xu .test = alg_test_hash, 4225a1915d51SJarod Wilson .fips_allowed = 1, 4226da7f033dSHerbert Xu .suite = { 422721c8e720SArd Biesheuvel .hash = __VECS(sha512_tv_template) 4228da7f033dSHerbert Xu } 4229da7f033dSHerbert Xu }, { 4230b7e27530SGilad Ben-Yossef .alg = "sm3", 4231b7e27530SGilad Ben-Yossef .test = alg_test_hash, 4232b7e27530SGilad Ben-Yossef .suite = { 4233b7e27530SGilad Ben-Yossef .hash = __VECS(sm3_tv_template) 4234b7e27530SGilad Ben-Yossef } 4235b7e27530SGilad Ben-Yossef }, { 423625a0b9d4SVitaly Chikunov .alg = "streebog256", 423725a0b9d4SVitaly Chikunov .test = alg_test_hash, 423825a0b9d4SVitaly Chikunov .suite = { 423925a0b9d4SVitaly Chikunov .hash = __VECS(streebog256_tv_template) 424025a0b9d4SVitaly Chikunov } 424125a0b9d4SVitaly Chikunov }, { 424225a0b9d4SVitaly Chikunov .alg = "streebog512", 424325a0b9d4SVitaly Chikunov .test = alg_test_hash, 424425a0b9d4SVitaly Chikunov .suite = { 424525a0b9d4SVitaly Chikunov .hash = __VECS(streebog512_tv_template) 424625a0b9d4SVitaly Chikunov } 424725a0b9d4SVitaly Chikunov }, { 4248da7f033dSHerbert Xu .alg = "tgr128", 4249da7f033dSHerbert Xu .test = alg_test_hash, 4250da7f033dSHerbert Xu .suite = { 425121c8e720SArd Biesheuvel .hash = __VECS(tgr128_tv_template) 4252da7f033dSHerbert Xu } 4253da7f033dSHerbert Xu }, { 4254da7f033dSHerbert Xu .alg = "tgr160", 4255da7f033dSHerbert Xu .test = alg_test_hash, 4256da7f033dSHerbert Xu .suite = { 425721c8e720SArd Biesheuvel .hash = __VECS(tgr160_tv_template) 4258da7f033dSHerbert Xu } 4259da7f033dSHerbert Xu }, { 4260da7f033dSHerbert Xu .alg = "tgr192", 4261da7f033dSHerbert Xu .test = alg_test_hash, 4262da7f033dSHerbert Xu .suite = { 426321c8e720SArd Biesheuvel .hash = __VECS(tgr192_tv_template) 4264da7f033dSHerbert Xu } 4265da7f033dSHerbert Xu }, { 4266ed331adaSEric Biggers .alg = "vmac64(aes)", 4267ed331adaSEric Biggers .test = alg_test_hash, 4268ed331adaSEric Biggers .suite = { 4269ed331adaSEric Biggers .hash = __VECS(vmac64_aes_tv_template) 4270ed331adaSEric Biggers } 4271ed331adaSEric Biggers }, { 4272da7f033dSHerbert Xu .alg = "wp256", 4273da7f033dSHerbert Xu .test = alg_test_hash, 4274da7f033dSHerbert Xu .suite = { 427521c8e720SArd Biesheuvel .hash = __VECS(wp256_tv_template) 4276da7f033dSHerbert Xu } 4277da7f033dSHerbert Xu }, { 4278da7f033dSHerbert Xu .alg = "wp384", 4279da7f033dSHerbert Xu .test = alg_test_hash, 4280da7f033dSHerbert Xu .suite = { 428121c8e720SArd Biesheuvel .hash = __VECS(wp384_tv_template) 4282da7f033dSHerbert Xu } 4283da7f033dSHerbert Xu }, { 4284da7f033dSHerbert Xu .alg = "wp512", 4285da7f033dSHerbert Xu .test = alg_test_hash, 4286da7f033dSHerbert Xu .suite = { 428721c8e720SArd Biesheuvel .hash = __VECS(wp512_tv_template) 4288da7f033dSHerbert Xu } 4289da7f033dSHerbert Xu }, { 4290da7f033dSHerbert Xu .alg = "xcbc(aes)", 4291da7f033dSHerbert Xu .test = alg_test_hash, 4292da7f033dSHerbert Xu .suite = { 429321c8e720SArd Biesheuvel .hash = __VECS(aes_xcbc128_tv_template) 4294da7f033dSHerbert Xu } 4295da7f033dSHerbert Xu }, { 4296aa762409SEric Biggers .alg = "xchacha12", 4297aa762409SEric Biggers .test = alg_test_skcipher, 4298aa762409SEric Biggers .suite = { 4299aa762409SEric Biggers .cipher = __VECS(xchacha12_tv_template) 4300aa762409SEric Biggers }, 4301aa762409SEric Biggers }, { 4302de61d7aeSEric Biggers .alg = "xchacha20", 4303de61d7aeSEric Biggers .test = alg_test_skcipher, 4304de61d7aeSEric Biggers .suite = { 4305de61d7aeSEric Biggers .cipher = __VECS(xchacha20_tv_template) 4306de61d7aeSEric Biggers }, 4307de61d7aeSEric Biggers }, { 4308da7f033dSHerbert Xu .alg = "xts(aes)", 43091aa4ecd9SHerbert Xu .test = alg_test_skcipher, 43102918aa8dSJarod Wilson .fips_allowed = 1, 4311da7f033dSHerbert Xu .suite = { 431292a4c9feSEric Biggers .cipher = __VECS(aes_xts_tv_template) 4313da7f033dSHerbert Xu } 43140c01aed5SGeert Uytterhoeven }, { 43150840605eSJussi Kivilinna .alg = "xts(camellia)", 43160840605eSJussi Kivilinna .test = alg_test_skcipher, 43170840605eSJussi Kivilinna .suite = { 431892a4c9feSEric Biggers .cipher = __VECS(camellia_xts_tv_template) 43190840605eSJussi Kivilinna } 43200840605eSJussi Kivilinna }, { 43219b8b0405SJohannes Goetzfried .alg = "xts(cast6)", 43229b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 43239b8b0405SJohannes Goetzfried .suite = { 432492a4c9feSEric Biggers .cipher = __VECS(cast6_xts_tv_template) 43259b8b0405SJohannes Goetzfried } 43269b8b0405SJohannes Goetzfried }, { 432715f47ce5SGilad Ben-Yossef /* Same as xts(aes) except the key is stored in 432815f47ce5SGilad Ben-Yossef * hardware secure memory which we reference by index 432915f47ce5SGilad Ben-Yossef */ 433015f47ce5SGilad Ben-Yossef .alg = "xts(paes)", 433115f47ce5SGilad Ben-Yossef .test = alg_test_null, 433215f47ce5SGilad Ben-Yossef .fips_allowed = 1, 433315f47ce5SGilad Ben-Yossef }, { 433418be20b9SJussi Kivilinna .alg = "xts(serpent)", 433518be20b9SJussi Kivilinna .test = alg_test_skcipher, 433618be20b9SJussi Kivilinna .suite = { 433792a4c9feSEric Biggers .cipher = __VECS(serpent_xts_tv_template) 433818be20b9SJussi Kivilinna } 433918be20b9SJussi Kivilinna }, { 4340aed265b9SJussi Kivilinna .alg = "xts(twofish)", 4341aed265b9SJussi Kivilinna .test = alg_test_skcipher, 4342aed265b9SJussi Kivilinna .suite = { 434392a4c9feSEric Biggers .cipher = __VECS(tf_xts_tv_template) 4344aed265b9SJussi Kivilinna } 4345a368f43dSGiovanni Cabiddu }, { 434615f47ce5SGilad Ben-Yossef .alg = "xts4096(paes)", 434715f47ce5SGilad Ben-Yossef .test = alg_test_null, 434815f47ce5SGilad Ben-Yossef .fips_allowed = 1, 434915f47ce5SGilad Ben-Yossef }, { 435015f47ce5SGilad Ben-Yossef .alg = "xts512(paes)", 435115f47ce5SGilad Ben-Yossef .test = alg_test_null, 435215f47ce5SGilad Ben-Yossef .fips_allowed = 1, 435315f47ce5SGilad Ben-Yossef }, { 4354a368f43dSGiovanni Cabiddu .alg = "zlib-deflate", 4355a368f43dSGiovanni Cabiddu .test = alg_test_comp, 4356a368f43dSGiovanni Cabiddu .fips_allowed = 1, 4357a368f43dSGiovanni Cabiddu .suite = { 4358a368f43dSGiovanni Cabiddu .comp = { 4359a368f43dSGiovanni Cabiddu .comp = __VECS(zlib_deflate_comp_tv_template), 4360a368f43dSGiovanni Cabiddu .decomp = __VECS(zlib_deflate_decomp_tv_template) 4361a368f43dSGiovanni Cabiddu } 4362a368f43dSGiovanni Cabiddu } 4363d28fc3dbSNick Terrell }, { 4364d28fc3dbSNick Terrell .alg = "zstd", 4365d28fc3dbSNick Terrell .test = alg_test_comp, 4366d28fc3dbSNick Terrell .fips_allowed = 1, 4367d28fc3dbSNick Terrell .suite = { 4368d28fc3dbSNick Terrell .comp = { 4369d28fc3dbSNick Terrell .comp = __VECS(zstd_comp_tv_template), 4370d28fc3dbSNick Terrell .decomp = __VECS(zstd_decomp_tv_template) 4371d28fc3dbSNick Terrell } 4372d28fc3dbSNick Terrell } 4373da7f033dSHerbert Xu } 4374da7f033dSHerbert Xu }; 4375da7f033dSHerbert Xu 43763f47a03dSEric Biggers static void alg_check_test_descs_order(void) 43775714758bSJussi Kivilinna { 43785714758bSJussi Kivilinna int i; 43795714758bSJussi Kivilinna 43805714758bSJussi Kivilinna for (i = 1; i < ARRAY_SIZE(alg_test_descs); i++) { 43815714758bSJussi Kivilinna int diff = strcmp(alg_test_descs[i - 1].alg, 43825714758bSJussi Kivilinna alg_test_descs[i].alg); 43835714758bSJussi Kivilinna 43845714758bSJussi Kivilinna if (WARN_ON(diff > 0)) { 43855714758bSJussi Kivilinna pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n", 43865714758bSJussi Kivilinna alg_test_descs[i - 1].alg, 43875714758bSJussi Kivilinna alg_test_descs[i].alg); 43885714758bSJussi Kivilinna } 43895714758bSJussi Kivilinna 43905714758bSJussi Kivilinna if (WARN_ON(diff == 0)) { 43915714758bSJussi Kivilinna pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n", 43925714758bSJussi Kivilinna alg_test_descs[i].alg); 43935714758bSJussi Kivilinna } 43945714758bSJussi Kivilinna } 43955714758bSJussi Kivilinna } 43965714758bSJussi Kivilinna 43973f47a03dSEric Biggers static void alg_check_testvec_configs(void) 43983f47a03dSEric Biggers { 43994e7babbaSEric Biggers int i; 44004e7babbaSEric Biggers 44014e7babbaSEric Biggers for (i = 0; i < ARRAY_SIZE(default_cipher_testvec_configs); i++) 44024e7babbaSEric Biggers WARN_ON(!valid_testvec_config( 44034e7babbaSEric Biggers &default_cipher_testvec_configs[i])); 44044cc2dcf9SEric Biggers 44054cc2dcf9SEric Biggers for (i = 0; i < ARRAY_SIZE(default_hash_testvec_configs); i++) 44064cc2dcf9SEric Biggers WARN_ON(!valid_testvec_config( 44074cc2dcf9SEric Biggers &default_hash_testvec_configs[i])); 44083f47a03dSEric Biggers } 44093f47a03dSEric Biggers 44103f47a03dSEric Biggers static void testmgr_onetime_init(void) 44113f47a03dSEric Biggers { 44123f47a03dSEric Biggers alg_check_test_descs_order(); 44133f47a03dSEric Biggers alg_check_testvec_configs(); 44145b2706a4SEric Biggers 44155b2706a4SEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 44165b2706a4SEric Biggers pr_warn("alg: extra crypto tests enabled. This is intended for developer use only.\n"); 44175b2706a4SEric Biggers #endif 44183f47a03dSEric Biggers } 44193f47a03dSEric Biggers 44201aa4ecd9SHerbert Xu static int alg_find_test(const char *alg) 4421da7f033dSHerbert Xu { 4422da7f033dSHerbert Xu int start = 0; 4423da7f033dSHerbert Xu int end = ARRAY_SIZE(alg_test_descs); 4424da7f033dSHerbert Xu 4425da7f033dSHerbert Xu while (start < end) { 4426da7f033dSHerbert Xu int i = (start + end) / 2; 4427da7f033dSHerbert Xu int diff = strcmp(alg_test_descs[i].alg, alg); 4428da7f033dSHerbert Xu 4429da7f033dSHerbert Xu if (diff > 0) { 4430da7f033dSHerbert Xu end = i; 4431da7f033dSHerbert Xu continue; 4432da7f033dSHerbert Xu } 4433da7f033dSHerbert Xu 4434da7f033dSHerbert Xu if (diff < 0) { 4435da7f033dSHerbert Xu start = i + 1; 4436da7f033dSHerbert Xu continue; 4437da7f033dSHerbert Xu } 4438da7f033dSHerbert Xu 44391aa4ecd9SHerbert Xu return i; 4440da7f033dSHerbert Xu } 4441da7f033dSHerbert Xu 44421aa4ecd9SHerbert Xu return -1; 44431aa4ecd9SHerbert Xu } 44441aa4ecd9SHerbert Xu 44451aa4ecd9SHerbert Xu int alg_test(const char *driver, const char *alg, u32 type, u32 mask) 44461aa4ecd9SHerbert Xu { 44471aa4ecd9SHerbert Xu int i; 4448a68f6610SHerbert Xu int j; 4449d12d6b6dSNeil Horman int rc; 44501aa4ecd9SHerbert Xu 44519e5c9fe4SRichard W.M. Jones if (!fips_enabled && notests) { 44529e5c9fe4SRichard W.M. Jones printk_once(KERN_INFO "alg: self-tests disabled\n"); 44539e5c9fe4SRichard W.M. Jones return 0; 44549e5c9fe4SRichard W.M. Jones } 44559e5c9fe4SRichard W.M. Jones 44563f47a03dSEric Biggers DO_ONCE(testmgr_onetime_init); 44575714758bSJussi Kivilinna 44581aa4ecd9SHerbert Xu if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) { 44591aa4ecd9SHerbert Xu char nalg[CRYPTO_MAX_ALG_NAME]; 44601aa4ecd9SHerbert Xu 44611aa4ecd9SHerbert Xu if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >= 44621aa4ecd9SHerbert Xu sizeof(nalg)) 44631aa4ecd9SHerbert Xu return -ENAMETOOLONG; 44641aa4ecd9SHerbert Xu 44651aa4ecd9SHerbert Xu i = alg_find_test(nalg); 44661aa4ecd9SHerbert Xu if (i < 0) 44671aa4ecd9SHerbert Xu goto notest; 44681aa4ecd9SHerbert Xu 4469a3bef3a3SJarod Wilson if (fips_enabled && !alg_test_descs[i].fips_allowed) 4470a3bef3a3SJarod Wilson goto non_fips_alg; 4471a3bef3a3SJarod Wilson 4472941fb328SJarod Wilson rc = alg_test_cipher(alg_test_descs + i, driver, type, mask); 4473941fb328SJarod Wilson goto test_done; 44741aa4ecd9SHerbert Xu } 44751aa4ecd9SHerbert Xu 44761aa4ecd9SHerbert Xu i = alg_find_test(alg); 4477a68f6610SHerbert Xu j = alg_find_test(driver); 4478a68f6610SHerbert Xu if (i < 0 && j < 0) 44791aa4ecd9SHerbert Xu goto notest; 44801aa4ecd9SHerbert Xu 4481a68f6610SHerbert Xu if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) || 4482a68f6610SHerbert Xu (j >= 0 && !alg_test_descs[j].fips_allowed))) 4483a3bef3a3SJarod Wilson goto non_fips_alg; 4484a3bef3a3SJarod Wilson 4485a68f6610SHerbert Xu rc = 0; 4486a68f6610SHerbert Xu if (i >= 0) 4487a68f6610SHerbert Xu rc |= alg_test_descs[i].test(alg_test_descs + i, driver, 44881aa4ecd9SHerbert Xu type, mask); 4489032c8cacSCristian Stoica if (j >= 0 && j != i) 4490a68f6610SHerbert Xu rc |= alg_test_descs[j].test(alg_test_descs + j, driver, 4491a68f6610SHerbert Xu type, mask); 4492a68f6610SHerbert Xu 4493941fb328SJarod Wilson test_done: 4494eda69b0cSEric Biggers if (rc && (fips_enabled || panic_on_fail)) 4495eda69b0cSEric Biggers panic("alg: self-tests for %s (%s) failed in %s mode!\n", 4496eda69b0cSEric Biggers driver, alg, fips_enabled ? "fips" : "panic_on_fail"); 4497d12d6b6dSNeil Horman 449829ecd4abSJarod Wilson if (fips_enabled && !rc) 44993e8cffd4SMasanari Iida pr_info("alg: self-tests for %s (%s) passed\n", driver, alg); 450029ecd4abSJarod Wilson 4501d12d6b6dSNeil Horman return rc; 45021aa4ecd9SHerbert Xu 45031aa4ecd9SHerbert Xu notest: 4504da7f033dSHerbert Xu printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver); 4505da7f033dSHerbert Xu return 0; 4506a3bef3a3SJarod Wilson non_fips_alg: 4507a3bef3a3SJarod Wilson return -EINVAL; 4508da7f033dSHerbert Xu } 45090b767f96SAlexander Shishkin 4510326a6346SHerbert Xu #endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */ 45110b767f96SAlexander Shishkin 4512da7f033dSHerbert Xu EXPORT_SYMBOL_GPL(alg_test); 4513