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 485b2706a4SEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 495b2706a4SEric Biggers static bool noextratests; 505b2706a4SEric Biggers module_param(noextratests, bool, 0644); 515b2706a4SEric Biggers MODULE_PARM_DESC(noextratests, "disable expensive crypto self-tests"); 525b2706a4SEric Biggers 535b2706a4SEric Biggers static unsigned int fuzz_iterations = 100; 545b2706a4SEric Biggers module_param(fuzz_iterations, uint, 0644); 555b2706a4SEric Biggers MODULE_PARM_DESC(fuzz_iterations, "number of fuzz test iterations"); 56b55e1a39SEric Biggers 57b55e1a39SEric Biggers DEFINE_PER_CPU(bool, crypto_simd_disabled_for_test); 58b55e1a39SEric Biggers EXPORT_PER_CPU_SYMBOL_GPL(crypto_simd_disabled_for_test); 595b2706a4SEric Biggers #endif 605b2706a4SEric Biggers 61326a6346SHerbert Xu #ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS 620b767f96SAlexander Shishkin 630b767f96SAlexander Shishkin /* a perfect nop */ 640b767f96SAlexander Shishkin int alg_test(const char *driver, const char *alg, u32 type, u32 mask) 650b767f96SAlexander Shishkin { 660b767f96SAlexander Shishkin return 0; 670b767f96SAlexander Shishkin } 680b767f96SAlexander Shishkin 690b767f96SAlexander Shishkin #else 700b767f96SAlexander Shishkin 71da7f033dSHerbert Xu #include "testmgr.h" 72da7f033dSHerbert Xu 73da7f033dSHerbert Xu /* 74da7f033dSHerbert Xu * Need slab memory for testing (size in number of pages). 75da7f033dSHerbert Xu */ 76da7f033dSHerbert Xu #define XBUFSIZE 8 77da7f033dSHerbert Xu 78da7f033dSHerbert Xu /* 79da7f033dSHerbert Xu * Used by test_cipher() 80da7f033dSHerbert Xu */ 81da7f033dSHerbert Xu #define ENCRYPT 1 82da7f033dSHerbert Xu #define DECRYPT 0 83da7f033dSHerbert Xu 84da7f033dSHerbert Xu struct aead_test_suite { 85b13b1e0cSEric Biggers const struct aead_testvec *vecs; 86da7f033dSHerbert Xu unsigned int count; 87da7f033dSHerbert Xu }; 88da7f033dSHerbert Xu 89da7f033dSHerbert Xu struct cipher_test_suite { 90b13b1e0cSEric Biggers const struct cipher_testvec *vecs; 91da7f033dSHerbert Xu unsigned int count; 92da7f033dSHerbert Xu }; 93da7f033dSHerbert Xu 94da7f033dSHerbert Xu struct comp_test_suite { 95da7f033dSHerbert Xu struct { 96b13b1e0cSEric Biggers const struct comp_testvec *vecs; 97da7f033dSHerbert Xu unsigned int count; 98da7f033dSHerbert Xu } comp, decomp; 99da7f033dSHerbert Xu }; 100da7f033dSHerbert Xu 101da7f033dSHerbert Xu struct hash_test_suite { 102b13b1e0cSEric Biggers const struct hash_testvec *vecs; 103da7f033dSHerbert Xu unsigned int count; 104da7f033dSHerbert Xu }; 105da7f033dSHerbert Xu 1067647d6ceSJarod Wilson struct cprng_test_suite { 107b13b1e0cSEric Biggers const struct cprng_testvec *vecs; 1087647d6ceSJarod Wilson unsigned int count; 1097647d6ceSJarod Wilson }; 1107647d6ceSJarod Wilson 11164d1cdfbSStephan Mueller struct drbg_test_suite { 112b13b1e0cSEric Biggers const struct drbg_testvec *vecs; 11364d1cdfbSStephan Mueller unsigned int count; 11464d1cdfbSStephan Mueller }; 11564d1cdfbSStephan Mueller 116946cc463STadeusz Struk struct akcipher_test_suite { 117b13b1e0cSEric Biggers const struct akcipher_testvec *vecs; 118946cc463STadeusz Struk unsigned int count; 119946cc463STadeusz Struk }; 120946cc463STadeusz Struk 121802c7f1cSSalvatore Benedetto struct kpp_test_suite { 122b13b1e0cSEric Biggers const struct kpp_testvec *vecs; 123802c7f1cSSalvatore Benedetto unsigned int count; 124802c7f1cSSalvatore Benedetto }; 125802c7f1cSSalvatore Benedetto 126da7f033dSHerbert Xu struct alg_test_desc { 127da7f033dSHerbert Xu const char *alg; 128da7f033dSHerbert Xu int (*test)(const struct alg_test_desc *desc, const char *driver, 129da7f033dSHerbert Xu u32 type, u32 mask); 130a1915d51SJarod Wilson int fips_allowed; /* set if alg is allowed in fips mode */ 131da7f033dSHerbert Xu 132da7f033dSHerbert Xu union { 133da7f033dSHerbert Xu struct aead_test_suite aead; 134da7f033dSHerbert Xu struct cipher_test_suite cipher; 135da7f033dSHerbert Xu struct comp_test_suite comp; 136da7f033dSHerbert Xu struct hash_test_suite hash; 1377647d6ceSJarod Wilson struct cprng_test_suite cprng; 13864d1cdfbSStephan Mueller struct drbg_test_suite drbg; 139946cc463STadeusz Struk struct akcipher_test_suite akcipher; 140802c7f1cSSalvatore Benedetto struct kpp_test_suite kpp; 141da7f033dSHerbert Xu } suite; 142da7f033dSHerbert Xu }; 143da7f033dSHerbert Xu 144da7f033dSHerbert Xu static void hexdump(unsigned char *buf, unsigned int len) 145da7f033dSHerbert Xu { 146da7f033dSHerbert Xu print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET, 147da7f033dSHerbert Xu 16, 1, 148da7f033dSHerbert Xu buf, len, false); 149da7f033dSHerbert Xu } 150da7f033dSHerbert Xu 1513f47a03dSEric Biggers static int __testmgr_alloc_buf(char *buf[XBUFSIZE], int order) 152f8b0d4d0SHerbert Xu { 153f8b0d4d0SHerbert Xu int i; 154f8b0d4d0SHerbert Xu 155f8b0d4d0SHerbert Xu for (i = 0; i < XBUFSIZE; i++) { 1563f47a03dSEric Biggers buf[i] = (char *)__get_free_pages(GFP_KERNEL, order); 157f8b0d4d0SHerbert Xu if (!buf[i]) 158f8b0d4d0SHerbert Xu goto err_free_buf; 159f8b0d4d0SHerbert Xu } 160f8b0d4d0SHerbert Xu 161f8b0d4d0SHerbert Xu return 0; 162f8b0d4d0SHerbert Xu 163f8b0d4d0SHerbert Xu err_free_buf: 164f8b0d4d0SHerbert Xu while (i-- > 0) 1653f47a03dSEric Biggers free_pages((unsigned long)buf[i], order); 166f8b0d4d0SHerbert Xu 167f8b0d4d0SHerbert Xu return -ENOMEM; 168f8b0d4d0SHerbert Xu } 169f8b0d4d0SHerbert Xu 1703f47a03dSEric Biggers static int testmgr_alloc_buf(char *buf[XBUFSIZE]) 1713f47a03dSEric Biggers { 1723f47a03dSEric Biggers return __testmgr_alloc_buf(buf, 0); 1733f47a03dSEric Biggers } 1743f47a03dSEric Biggers 1753f47a03dSEric Biggers static void __testmgr_free_buf(char *buf[XBUFSIZE], int order) 176f8b0d4d0SHerbert Xu { 177f8b0d4d0SHerbert Xu int i; 178f8b0d4d0SHerbert Xu 179f8b0d4d0SHerbert Xu for (i = 0; i < XBUFSIZE; i++) 1803f47a03dSEric Biggers free_pages((unsigned long)buf[i], order); 1813f47a03dSEric Biggers } 1823f47a03dSEric Biggers 1833f47a03dSEric Biggers static void testmgr_free_buf(char *buf[XBUFSIZE]) 1843f47a03dSEric Biggers { 1853f47a03dSEric Biggers __testmgr_free_buf(buf, 0); 1863f47a03dSEric Biggers } 1873f47a03dSEric Biggers 1883f47a03dSEric Biggers #define TESTMGR_POISON_BYTE 0xfe 1893f47a03dSEric Biggers #define TESTMGR_POISON_LEN 16 1903f47a03dSEric Biggers 1913f47a03dSEric Biggers static inline void testmgr_poison(void *addr, size_t len) 1923f47a03dSEric Biggers { 1933f47a03dSEric Biggers memset(addr, TESTMGR_POISON_BYTE, len); 1943f47a03dSEric Biggers } 1953f47a03dSEric Biggers 1963f47a03dSEric Biggers /* Is the memory region still fully poisoned? */ 1973f47a03dSEric Biggers static inline bool testmgr_is_poison(const void *addr, size_t len) 1983f47a03dSEric Biggers { 1993f47a03dSEric Biggers return memchr_inv(addr, TESTMGR_POISON_BYTE, len) == NULL; 2003f47a03dSEric Biggers } 2013f47a03dSEric Biggers 2023f47a03dSEric Biggers /* flush type for hash algorithms */ 2033f47a03dSEric Biggers enum flush_type { 2043f47a03dSEric Biggers /* merge with update of previous buffer(s) */ 2053f47a03dSEric Biggers FLUSH_TYPE_NONE = 0, 2063f47a03dSEric Biggers 2073f47a03dSEric Biggers /* update with previous buffer(s) before doing this one */ 2083f47a03dSEric Biggers FLUSH_TYPE_FLUSH, 2093f47a03dSEric Biggers 2103f47a03dSEric Biggers /* likewise, but also export and re-import the intermediate state */ 2113f47a03dSEric Biggers FLUSH_TYPE_REIMPORT, 2123f47a03dSEric Biggers }; 2133f47a03dSEric Biggers 2143f47a03dSEric Biggers /* finalization function for hash algorithms */ 2153f47a03dSEric Biggers enum finalization_type { 2163f47a03dSEric Biggers FINALIZATION_TYPE_FINAL, /* use final() */ 2173f47a03dSEric Biggers FINALIZATION_TYPE_FINUP, /* use finup() */ 2183f47a03dSEric Biggers FINALIZATION_TYPE_DIGEST, /* use digest() */ 2193f47a03dSEric Biggers }; 2203f47a03dSEric Biggers 2213f47a03dSEric Biggers #define TEST_SG_TOTAL 10000 2223f47a03dSEric Biggers 2233f47a03dSEric Biggers /** 2243f47a03dSEric Biggers * struct test_sg_division - description of a scatterlist entry 2253f47a03dSEric Biggers * 2263f47a03dSEric Biggers * This struct describes one entry of a scatterlist being constructed to check a 2273f47a03dSEric Biggers * crypto test vector. 2283f47a03dSEric Biggers * 2293f47a03dSEric Biggers * @proportion_of_total: length of this chunk relative to the total length, 2303f47a03dSEric Biggers * given as a proportion out of TEST_SG_TOTAL so that it 2313f47a03dSEric Biggers * scales to fit any test vector 2323f47a03dSEric Biggers * @offset: byte offset into a 2-page buffer at which this chunk will start 2333f47a03dSEric Biggers * @offset_relative_to_alignmask: if true, add the algorithm's alignmask to the 2343f47a03dSEric Biggers * @offset 2353f47a03dSEric Biggers * @flush_type: for hashes, whether an update() should be done now vs. 2363f47a03dSEric Biggers * continuing to accumulate data 2373f47a03dSEric Biggers */ 2383f47a03dSEric Biggers struct test_sg_division { 2393f47a03dSEric Biggers unsigned int proportion_of_total; 2403f47a03dSEric Biggers unsigned int offset; 2413f47a03dSEric Biggers bool offset_relative_to_alignmask; 2423f47a03dSEric Biggers enum flush_type flush_type; 2433f47a03dSEric Biggers }; 2443f47a03dSEric Biggers 2453f47a03dSEric Biggers /** 2463f47a03dSEric Biggers * struct testvec_config - configuration for testing a crypto test vector 2473f47a03dSEric Biggers * 2483f47a03dSEric Biggers * This struct describes the data layout and other parameters with which each 2493f47a03dSEric Biggers * crypto test vector can be tested. 2503f47a03dSEric Biggers * 2513f47a03dSEric Biggers * @name: name of this config, logged for debugging purposes if a test fails 2523f47a03dSEric Biggers * @inplace: operate on the data in-place, if applicable for the algorithm type? 2533f47a03dSEric Biggers * @req_flags: extra request_flags, e.g. CRYPTO_TFM_REQ_MAY_SLEEP 2543f47a03dSEric Biggers * @src_divs: description of how to arrange the source scatterlist 2553f47a03dSEric Biggers * @dst_divs: description of how to arrange the dst scatterlist, if applicable 2563f47a03dSEric Biggers * for the algorithm type. Defaults to @src_divs if unset. 2573f47a03dSEric Biggers * @iv_offset: misalignment of the IV in the range [0..MAX_ALGAPI_ALIGNMASK+1], 2583f47a03dSEric Biggers * where 0 is aligned to a 2*(MAX_ALGAPI_ALIGNMASK+1) byte boundary 2593f47a03dSEric Biggers * @iv_offset_relative_to_alignmask: if true, add the algorithm's alignmask to 2603f47a03dSEric Biggers * the @iv_offset 2613f47a03dSEric Biggers * @finalization_type: what finalization function to use for hashes 2623f47a03dSEric Biggers */ 2633f47a03dSEric Biggers struct testvec_config { 2643f47a03dSEric Biggers const char *name; 2653f47a03dSEric Biggers bool inplace; 2663f47a03dSEric Biggers u32 req_flags; 2673f47a03dSEric Biggers struct test_sg_division src_divs[XBUFSIZE]; 2683f47a03dSEric Biggers struct test_sg_division dst_divs[XBUFSIZE]; 2693f47a03dSEric Biggers unsigned int iv_offset; 2703f47a03dSEric Biggers bool iv_offset_relative_to_alignmask; 2713f47a03dSEric Biggers enum finalization_type finalization_type; 2723f47a03dSEric Biggers }; 2733f47a03dSEric Biggers 2743f47a03dSEric Biggers #define TESTVEC_CONFIG_NAMELEN 192 2753f47a03dSEric Biggers 2764e7babbaSEric Biggers /* 2774e7babbaSEric Biggers * The following are the lists of testvec_configs to test for each algorithm 2784e7babbaSEric Biggers * type when the basic crypto self-tests are enabled, i.e. when 2794e7babbaSEric Biggers * CONFIG_CRYPTO_MANAGER_DISABLE_TESTS is unset. They aim to provide good test 2804e7babbaSEric Biggers * coverage, while keeping the test time much shorter than the full fuzz tests 2814e7babbaSEric Biggers * so that the basic tests can be enabled in a wider range of circumstances. 2824e7babbaSEric Biggers */ 2834e7babbaSEric Biggers 2844e7babbaSEric Biggers /* Configs for skciphers and aeads */ 2854e7babbaSEric Biggers static const struct testvec_config default_cipher_testvec_configs[] = { 2864e7babbaSEric Biggers { 2874e7babbaSEric Biggers .name = "in-place", 2884e7babbaSEric Biggers .inplace = true, 2894e7babbaSEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 2904e7babbaSEric Biggers }, { 2914e7babbaSEric Biggers .name = "out-of-place", 2924e7babbaSEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 2934e7babbaSEric Biggers }, { 2944e7babbaSEric Biggers .name = "unaligned buffer, offset=1", 2954e7babbaSEric Biggers .src_divs = { { .proportion_of_total = 10000, .offset = 1 } }, 2964e7babbaSEric Biggers .iv_offset = 1, 2974e7babbaSEric Biggers }, { 2984e7babbaSEric Biggers .name = "buffer aligned only to alignmask", 2994e7babbaSEric Biggers .src_divs = { 3004e7babbaSEric Biggers { 3014e7babbaSEric Biggers .proportion_of_total = 10000, 3024e7babbaSEric Biggers .offset = 1, 3034e7babbaSEric Biggers .offset_relative_to_alignmask = true, 3044e7babbaSEric Biggers }, 3054e7babbaSEric Biggers }, 3064e7babbaSEric Biggers .iv_offset = 1, 3074e7babbaSEric Biggers .iv_offset_relative_to_alignmask = true, 3084e7babbaSEric Biggers }, { 3094e7babbaSEric Biggers .name = "two even aligned splits", 3104e7babbaSEric Biggers .src_divs = { 3114e7babbaSEric Biggers { .proportion_of_total = 5000 }, 3124e7babbaSEric Biggers { .proportion_of_total = 5000 }, 3134e7babbaSEric Biggers }, 3144e7babbaSEric Biggers }, { 3154e7babbaSEric Biggers .name = "uneven misaligned splits, may sleep", 3164e7babbaSEric Biggers .req_flags = CRYPTO_TFM_REQ_MAY_SLEEP, 3174e7babbaSEric Biggers .src_divs = { 3184e7babbaSEric Biggers { .proportion_of_total = 1900, .offset = 33 }, 3194e7babbaSEric Biggers { .proportion_of_total = 3300, .offset = 7 }, 3204e7babbaSEric Biggers { .proportion_of_total = 4800, .offset = 18 }, 3214e7babbaSEric Biggers }, 3224e7babbaSEric Biggers .iv_offset = 3, 3234e7babbaSEric Biggers }, { 3244e7babbaSEric Biggers .name = "misaligned splits crossing pages, inplace", 3254e7babbaSEric Biggers .inplace = true, 3264e7babbaSEric Biggers .src_divs = { 3274e7babbaSEric Biggers { 3284e7babbaSEric Biggers .proportion_of_total = 7500, 3294e7babbaSEric Biggers .offset = PAGE_SIZE - 32 3304e7babbaSEric Biggers }, { 3314e7babbaSEric Biggers .proportion_of_total = 2500, 3324e7babbaSEric Biggers .offset = PAGE_SIZE - 7 3334e7babbaSEric Biggers }, 3344e7babbaSEric Biggers }, 3354e7babbaSEric Biggers } 3364e7babbaSEric Biggers }; 3374e7babbaSEric Biggers 3384cc2dcf9SEric Biggers static const struct testvec_config default_hash_testvec_configs[] = { 3394cc2dcf9SEric Biggers { 3404cc2dcf9SEric Biggers .name = "init+update+final aligned buffer", 3414cc2dcf9SEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 3424cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINAL, 3434cc2dcf9SEric Biggers }, { 3444cc2dcf9SEric Biggers .name = "init+finup aligned buffer", 3454cc2dcf9SEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 3464cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINUP, 3474cc2dcf9SEric Biggers }, { 3484cc2dcf9SEric Biggers .name = "digest aligned buffer", 3494cc2dcf9SEric Biggers .src_divs = { { .proportion_of_total = 10000 } }, 3504cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_DIGEST, 3514cc2dcf9SEric Biggers }, { 3524cc2dcf9SEric Biggers .name = "init+update+final misaligned buffer", 3534cc2dcf9SEric Biggers .src_divs = { { .proportion_of_total = 10000, .offset = 1 } }, 3544cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINAL, 3554cc2dcf9SEric Biggers }, { 3564cc2dcf9SEric Biggers .name = "digest buffer aligned only to alignmask", 3574cc2dcf9SEric Biggers .src_divs = { 3584cc2dcf9SEric Biggers { 3594cc2dcf9SEric Biggers .proportion_of_total = 10000, 3604cc2dcf9SEric Biggers .offset = 1, 3614cc2dcf9SEric Biggers .offset_relative_to_alignmask = true, 3624cc2dcf9SEric Biggers }, 3634cc2dcf9SEric Biggers }, 3644cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_DIGEST, 3654cc2dcf9SEric Biggers }, { 3664cc2dcf9SEric Biggers .name = "init+update+update+final two even splits", 3674cc2dcf9SEric Biggers .src_divs = { 3684cc2dcf9SEric Biggers { .proportion_of_total = 5000 }, 3694cc2dcf9SEric Biggers { 3704cc2dcf9SEric Biggers .proportion_of_total = 5000, 3714cc2dcf9SEric Biggers .flush_type = FLUSH_TYPE_FLUSH, 3724cc2dcf9SEric Biggers }, 3734cc2dcf9SEric Biggers }, 3744cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINAL, 3754cc2dcf9SEric Biggers }, { 3764cc2dcf9SEric Biggers .name = "digest uneven misaligned splits, may sleep", 3774cc2dcf9SEric Biggers .req_flags = CRYPTO_TFM_REQ_MAY_SLEEP, 3784cc2dcf9SEric Biggers .src_divs = { 3794cc2dcf9SEric Biggers { .proportion_of_total = 1900, .offset = 33 }, 3804cc2dcf9SEric Biggers { .proportion_of_total = 3300, .offset = 7 }, 3814cc2dcf9SEric Biggers { .proportion_of_total = 4800, .offset = 18 }, 3824cc2dcf9SEric Biggers }, 3834cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_DIGEST, 3844cc2dcf9SEric Biggers }, { 3854cc2dcf9SEric Biggers .name = "digest misaligned splits crossing pages", 3864cc2dcf9SEric Biggers .src_divs = { 3874cc2dcf9SEric Biggers { 3884cc2dcf9SEric Biggers .proportion_of_total = 7500, 3894cc2dcf9SEric Biggers .offset = PAGE_SIZE - 32, 3904cc2dcf9SEric Biggers }, { 3914cc2dcf9SEric Biggers .proportion_of_total = 2500, 3924cc2dcf9SEric Biggers .offset = PAGE_SIZE - 7, 3934cc2dcf9SEric Biggers }, 3944cc2dcf9SEric Biggers }, 3954cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_DIGEST, 3964cc2dcf9SEric Biggers }, { 3974cc2dcf9SEric Biggers .name = "import/export", 3984cc2dcf9SEric Biggers .src_divs = { 3994cc2dcf9SEric Biggers { 4004cc2dcf9SEric Biggers .proportion_of_total = 6500, 4014cc2dcf9SEric Biggers .flush_type = FLUSH_TYPE_REIMPORT, 4024cc2dcf9SEric Biggers }, { 4034cc2dcf9SEric Biggers .proportion_of_total = 3500, 4044cc2dcf9SEric Biggers .flush_type = FLUSH_TYPE_REIMPORT, 4054cc2dcf9SEric Biggers }, 4064cc2dcf9SEric Biggers }, 4074cc2dcf9SEric Biggers .finalization_type = FINALIZATION_TYPE_FINAL, 4084cc2dcf9SEric Biggers } 4094cc2dcf9SEric Biggers }; 4104cc2dcf9SEric Biggers 4113f47a03dSEric Biggers static unsigned int count_test_sg_divisions(const struct test_sg_division *divs) 4123f47a03dSEric Biggers { 4133f47a03dSEric Biggers unsigned int remaining = TEST_SG_TOTAL; 4143f47a03dSEric Biggers unsigned int ndivs = 0; 4153f47a03dSEric Biggers 4163f47a03dSEric Biggers do { 4173f47a03dSEric Biggers remaining -= divs[ndivs++].proportion_of_total; 4183f47a03dSEric Biggers } while (remaining); 4193f47a03dSEric Biggers 4203f47a03dSEric Biggers return ndivs; 4213f47a03dSEric Biggers } 4223f47a03dSEric Biggers 4233f47a03dSEric Biggers static bool valid_sg_divisions(const struct test_sg_division *divs, 4243f47a03dSEric Biggers unsigned int count, bool *any_flushes_ret) 4253f47a03dSEric Biggers { 4263f47a03dSEric Biggers unsigned int total = 0; 4273f47a03dSEric Biggers unsigned int i; 4283f47a03dSEric Biggers 4293f47a03dSEric Biggers for (i = 0; i < count && total != TEST_SG_TOTAL; i++) { 4303f47a03dSEric Biggers if (divs[i].proportion_of_total <= 0 || 4313f47a03dSEric Biggers divs[i].proportion_of_total > TEST_SG_TOTAL - total) 4323f47a03dSEric Biggers return false; 4333f47a03dSEric Biggers total += divs[i].proportion_of_total; 4343f47a03dSEric Biggers if (divs[i].flush_type != FLUSH_TYPE_NONE) 4353f47a03dSEric Biggers *any_flushes_ret = true; 4363f47a03dSEric Biggers } 4373f47a03dSEric Biggers return total == TEST_SG_TOTAL && 4383f47a03dSEric Biggers memchr_inv(&divs[i], 0, (count - i) * sizeof(divs[0])) == NULL; 4393f47a03dSEric Biggers } 4403f47a03dSEric Biggers 4413f47a03dSEric Biggers /* 4423f47a03dSEric Biggers * Check whether the given testvec_config is valid. This isn't strictly needed 4433f47a03dSEric Biggers * since every testvec_config should be valid, but check anyway so that people 4443f47a03dSEric Biggers * don't unknowingly add broken configs that don't do what they wanted. 4453f47a03dSEric Biggers */ 4463f47a03dSEric Biggers static bool valid_testvec_config(const struct testvec_config *cfg) 4473f47a03dSEric Biggers { 4483f47a03dSEric Biggers bool any_flushes = false; 4493f47a03dSEric Biggers 4503f47a03dSEric Biggers if (cfg->name == NULL) 4513f47a03dSEric Biggers return false; 4523f47a03dSEric Biggers 4533f47a03dSEric Biggers if (!valid_sg_divisions(cfg->src_divs, ARRAY_SIZE(cfg->src_divs), 4543f47a03dSEric Biggers &any_flushes)) 4553f47a03dSEric Biggers return false; 4563f47a03dSEric Biggers 4573f47a03dSEric Biggers if (cfg->dst_divs[0].proportion_of_total) { 4583f47a03dSEric Biggers if (!valid_sg_divisions(cfg->dst_divs, 4593f47a03dSEric Biggers ARRAY_SIZE(cfg->dst_divs), 4603f47a03dSEric Biggers &any_flushes)) 4613f47a03dSEric Biggers return false; 4623f47a03dSEric Biggers } else { 4633f47a03dSEric Biggers if (memchr_inv(cfg->dst_divs, 0, sizeof(cfg->dst_divs))) 4643f47a03dSEric Biggers return false; 4653f47a03dSEric Biggers /* defaults to dst_divs=src_divs */ 4663f47a03dSEric Biggers } 4673f47a03dSEric Biggers 4683f47a03dSEric Biggers if (cfg->iv_offset + 4693f47a03dSEric Biggers (cfg->iv_offset_relative_to_alignmask ? MAX_ALGAPI_ALIGNMASK : 0) > 4703f47a03dSEric Biggers MAX_ALGAPI_ALIGNMASK + 1) 4713f47a03dSEric Biggers return false; 4723f47a03dSEric Biggers 4733f47a03dSEric Biggers if (any_flushes && cfg->finalization_type == FINALIZATION_TYPE_DIGEST) 4743f47a03dSEric Biggers return false; 4753f47a03dSEric Biggers 4763f47a03dSEric Biggers return true; 4773f47a03dSEric Biggers } 4783f47a03dSEric Biggers 4793f47a03dSEric Biggers struct test_sglist { 4803f47a03dSEric Biggers char *bufs[XBUFSIZE]; 4813f47a03dSEric Biggers struct scatterlist sgl[XBUFSIZE]; 4823f47a03dSEric Biggers struct scatterlist sgl_saved[XBUFSIZE]; 4833f47a03dSEric Biggers struct scatterlist *sgl_ptr; 4843f47a03dSEric Biggers unsigned int nents; 4853f47a03dSEric Biggers }; 4863f47a03dSEric Biggers 4873f47a03dSEric Biggers static int init_test_sglist(struct test_sglist *tsgl) 4883f47a03dSEric Biggers { 4893f47a03dSEric Biggers return __testmgr_alloc_buf(tsgl->bufs, 1 /* two pages per buffer */); 4903f47a03dSEric Biggers } 4913f47a03dSEric Biggers 4923f47a03dSEric Biggers static void destroy_test_sglist(struct test_sglist *tsgl) 4933f47a03dSEric Biggers { 4943f47a03dSEric Biggers return __testmgr_free_buf(tsgl->bufs, 1 /* two pages per buffer */); 4953f47a03dSEric Biggers } 4963f47a03dSEric Biggers 4973f47a03dSEric Biggers /** 4983f47a03dSEric Biggers * build_test_sglist() - build a scatterlist for a crypto test 4993f47a03dSEric Biggers * 5003f47a03dSEric Biggers * @tsgl: the scatterlist to build. @tsgl->bufs[] contains an array of 2-page 5013f47a03dSEric Biggers * buffers which the scatterlist @tsgl->sgl[] will be made to point into. 5023f47a03dSEric Biggers * @divs: the layout specification on which the scatterlist will be based 5033f47a03dSEric Biggers * @alignmask: the algorithm's alignmask 5043f47a03dSEric Biggers * @total_len: the total length of the scatterlist to build in bytes 5053f47a03dSEric Biggers * @data: if non-NULL, the buffers will be filled with this data until it ends. 5063f47a03dSEric Biggers * Otherwise the buffers will be poisoned. In both cases, some bytes 5073f47a03dSEric Biggers * past the end of each buffer will be poisoned to help detect overruns. 5083f47a03dSEric Biggers * @out_divs: if non-NULL, the test_sg_division to which each scatterlist entry 5093f47a03dSEric Biggers * corresponds will be returned here. This will match @divs except 5103f47a03dSEric Biggers * that divisions resolving to a length of 0 are omitted as they are 5113f47a03dSEric Biggers * not included in the scatterlist. 5123f47a03dSEric Biggers * 5133f47a03dSEric Biggers * Return: 0 or a -errno value 5143f47a03dSEric Biggers */ 5153f47a03dSEric Biggers static int build_test_sglist(struct test_sglist *tsgl, 5163f47a03dSEric Biggers const struct test_sg_division *divs, 5173f47a03dSEric Biggers const unsigned int alignmask, 5183f47a03dSEric Biggers const unsigned int total_len, 5193f47a03dSEric Biggers struct iov_iter *data, 5203f47a03dSEric Biggers const struct test_sg_division *out_divs[XBUFSIZE]) 5213f47a03dSEric Biggers { 5223f47a03dSEric Biggers struct { 5233f47a03dSEric Biggers const struct test_sg_division *div; 5243f47a03dSEric Biggers size_t length; 5253f47a03dSEric Biggers } partitions[XBUFSIZE]; 5263f47a03dSEric Biggers const unsigned int ndivs = count_test_sg_divisions(divs); 5273f47a03dSEric Biggers unsigned int len_remaining = total_len; 5283f47a03dSEric Biggers unsigned int i; 5293f47a03dSEric Biggers 5303f47a03dSEric Biggers BUILD_BUG_ON(ARRAY_SIZE(partitions) != ARRAY_SIZE(tsgl->sgl)); 5313f47a03dSEric Biggers if (WARN_ON(ndivs > ARRAY_SIZE(partitions))) 5323f47a03dSEric Biggers return -EINVAL; 5333f47a03dSEric Biggers 5343f47a03dSEric Biggers /* Calculate the (div, length) pairs */ 5353f47a03dSEric Biggers tsgl->nents = 0; 5363f47a03dSEric Biggers for (i = 0; i < ndivs; i++) { 5373f47a03dSEric Biggers unsigned int len_this_sg = 5383f47a03dSEric Biggers min(len_remaining, 5393f47a03dSEric Biggers (total_len * divs[i].proportion_of_total + 5403f47a03dSEric Biggers TEST_SG_TOTAL / 2) / TEST_SG_TOTAL); 5413f47a03dSEric Biggers 5423f47a03dSEric Biggers if (len_this_sg != 0) { 5433f47a03dSEric Biggers partitions[tsgl->nents].div = &divs[i]; 5443f47a03dSEric Biggers partitions[tsgl->nents].length = len_this_sg; 5453f47a03dSEric Biggers tsgl->nents++; 5463f47a03dSEric Biggers len_remaining -= len_this_sg; 5473f47a03dSEric Biggers } 5483f47a03dSEric Biggers } 5493f47a03dSEric Biggers if (tsgl->nents == 0) { 5503f47a03dSEric Biggers partitions[tsgl->nents].div = &divs[0]; 5513f47a03dSEric Biggers partitions[tsgl->nents].length = 0; 5523f47a03dSEric Biggers tsgl->nents++; 5533f47a03dSEric Biggers } 5543f47a03dSEric Biggers partitions[tsgl->nents - 1].length += len_remaining; 5553f47a03dSEric Biggers 5563f47a03dSEric Biggers /* Set up the sgl entries and fill the data or poison */ 5573f47a03dSEric Biggers sg_init_table(tsgl->sgl, tsgl->nents); 5583f47a03dSEric Biggers for (i = 0; i < tsgl->nents; i++) { 5593f47a03dSEric Biggers unsigned int offset = partitions[i].div->offset; 5603f47a03dSEric Biggers void *addr; 5613f47a03dSEric Biggers 5623f47a03dSEric Biggers if (partitions[i].div->offset_relative_to_alignmask) 5633f47a03dSEric Biggers offset += alignmask; 5643f47a03dSEric Biggers 5653f47a03dSEric Biggers while (offset + partitions[i].length + TESTMGR_POISON_LEN > 5663f47a03dSEric Biggers 2 * PAGE_SIZE) { 5673f47a03dSEric Biggers if (WARN_ON(offset <= 0)) 5683f47a03dSEric Biggers return -EINVAL; 5693f47a03dSEric Biggers offset /= 2; 5703f47a03dSEric Biggers } 5713f47a03dSEric Biggers 5723f47a03dSEric Biggers addr = &tsgl->bufs[i][offset]; 5733f47a03dSEric Biggers sg_set_buf(&tsgl->sgl[i], addr, partitions[i].length); 5743f47a03dSEric Biggers 5753f47a03dSEric Biggers if (out_divs) 5763f47a03dSEric Biggers out_divs[i] = partitions[i].div; 5773f47a03dSEric Biggers 5783f47a03dSEric Biggers if (data) { 5793f47a03dSEric Biggers size_t copy_len, copied; 5803f47a03dSEric Biggers 5813f47a03dSEric Biggers copy_len = min(partitions[i].length, data->count); 5823f47a03dSEric Biggers copied = copy_from_iter(addr, copy_len, data); 5833f47a03dSEric Biggers if (WARN_ON(copied != copy_len)) 5843f47a03dSEric Biggers return -EINVAL; 5853f47a03dSEric Biggers testmgr_poison(addr + copy_len, partitions[i].length + 5863f47a03dSEric Biggers TESTMGR_POISON_LEN - copy_len); 5873f47a03dSEric Biggers } else { 5883f47a03dSEric Biggers testmgr_poison(addr, partitions[i].length + 5893f47a03dSEric Biggers TESTMGR_POISON_LEN); 5903f47a03dSEric Biggers } 5913f47a03dSEric Biggers } 5923f47a03dSEric Biggers 5933f47a03dSEric Biggers sg_mark_end(&tsgl->sgl[tsgl->nents - 1]); 5943f47a03dSEric Biggers tsgl->sgl_ptr = tsgl->sgl; 5953f47a03dSEric Biggers memcpy(tsgl->sgl_saved, tsgl->sgl, tsgl->nents * sizeof(tsgl->sgl[0])); 5963f47a03dSEric Biggers return 0; 5973f47a03dSEric Biggers } 5983f47a03dSEric Biggers 5993f47a03dSEric Biggers /* 6003f47a03dSEric Biggers * Verify that a scatterlist crypto operation produced the correct output. 6013f47a03dSEric Biggers * 6023f47a03dSEric Biggers * @tsgl: scatterlist containing the actual output 6033f47a03dSEric Biggers * @expected_output: buffer containing the expected output 6043f47a03dSEric Biggers * @len_to_check: length of @expected_output in bytes 6053f47a03dSEric Biggers * @unchecked_prefix_len: number of ignored bytes in @tsgl prior to real result 6063f47a03dSEric Biggers * @check_poison: verify that the poison bytes after each chunk are intact? 6073f47a03dSEric Biggers * 6083f47a03dSEric Biggers * Return: 0 if correct, -EINVAL if incorrect, -EOVERFLOW if buffer overrun. 6093f47a03dSEric Biggers */ 6103f47a03dSEric Biggers static int verify_correct_output(const struct test_sglist *tsgl, 6113f47a03dSEric Biggers const char *expected_output, 6123f47a03dSEric Biggers unsigned int len_to_check, 6133f47a03dSEric Biggers unsigned int unchecked_prefix_len, 6143f47a03dSEric Biggers bool check_poison) 6153f47a03dSEric Biggers { 6163f47a03dSEric Biggers unsigned int i; 6173f47a03dSEric Biggers 6183f47a03dSEric Biggers for (i = 0; i < tsgl->nents; i++) { 6193f47a03dSEric Biggers struct scatterlist *sg = &tsgl->sgl_ptr[i]; 6203f47a03dSEric Biggers unsigned int len = sg->length; 6213f47a03dSEric Biggers unsigned int offset = sg->offset; 6223f47a03dSEric Biggers const char *actual_output; 6233f47a03dSEric Biggers 6243f47a03dSEric Biggers if (unchecked_prefix_len) { 6253f47a03dSEric Biggers if (unchecked_prefix_len >= len) { 6263f47a03dSEric Biggers unchecked_prefix_len -= len; 6273f47a03dSEric Biggers continue; 6283f47a03dSEric Biggers } 6293f47a03dSEric Biggers offset += unchecked_prefix_len; 6303f47a03dSEric Biggers len -= unchecked_prefix_len; 6313f47a03dSEric Biggers unchecked_prefix_len = 0; 6323f47a03dSEric Biggers } 6333f47a03dSEric Biggers len = min(len, len_to_check); 6343f47a03dSEric Biggers actual_output = page_address(sg_page(sg)) + offset; 6353f47a03dSEric Biggers if (memcmp(expected_output, actual_output, len) != 0) 6363f47a03dSEric Biggers return -EINVAL; 6373f47a03dSEric Biggers if (check_poison && 6383f47a03dSEric Biggers !testmgr_is_poison(actual_output + len, TESTMGR_POISON_LEN)) 6393f47a03dSEric Biggers return -EOVERFLOW; 6403f47a03dSEric Biggers len_to_check -= len; 6413f47a03dSEric Biggers expected_output += len; 6423f47a03dSEric Biggers } 6433f47a03dSEric Biggers if (WARN_ON(len_to_check != 0)) 6443f47a03dSEric Biggers return -EINVAL; 6453f47a03dSEric Biggers return 0; 6463f47a03dSEric Biggers } 6473f47a03dSEric Biggers 6483f47a03dSEric Biggers static bool is_test_sglist_corrupted(const struct test_sglist *tsgl) 6493f47a03dSEric Biggers { 6503f47a03dSEric Biggers unsigned int i; 6513f47a03dSEric Biggers 6523f47a03dSEric Biggers for (i = 0; i < tsgl->nents; i++) { 6533f47a03dSEric Biggers if (tsgl->sgl[i].page_link != tsgl->sgl_saved[i].page_link) 6543f47a03dSEric Biggers return true; 6553f47a03dSEric Biggers if (tsgl->sgl[i].offset != tsgl->sgl_saved[i].offset) 6563f47a03dSEric Biggers return true; 6573f47a03dSEric Biggers if (tsgl->sgl[i].length != tsgl->sgl_saved[i].length) 6583f47a03dSEric Biggers return true; 6593f47a03dSEric Biggers } 6603f47a03dSEric Biggers return false; 6613f47a03dSEric Biggers } 6623f47a03dSEric Biggers 6633f47a03dSEric Biggers struct cipher_test_sglists { 6643f47a03dSEric Biggers struct test_sglist src; 6653f47a03dSEric Biggers struct test_sglist dst; 6663f47a03dSEric Biggers }; 6673f47a03dSEric Biggers 6683f47a03dSEric Biggers static struct cipher_test_sglists *alloc_cipher_test_sglists(void) 6693f47a03dSEric Biggers { 6703f47a03dSEric Biggers struct cipher_test_sglists *tsgls; 6713f47a03dSEric Biggers 6723f47a03dSEric Biggers tsgls = kmalloc(sizeof(*tsgls), GFP_KERNEL); 6733f47a03dSEric Biggers if (!tsgls) 6743f47a03dSEric Biggers return NULL; 6753f47a03dSEric Biggers 6763f47a03dSEric Biggers if (init_test_sglist(&tsgls->src) != 0) 6773f47a03dSEric Biggers goto fail_kfree; 6783f47a03dSEric Biggers if (init_test_sglist(&tsgls->dst) != 0) 6793f47a03dSEric Biggers goto fail_destroy_src; 6803f47a03dSEric Biggers 6813f47a03dSEric Biggers return tsgls; 6823f47a03dSEric Biggers 6833f47a03dSEric Biggers fail_destroy_src: 6843f47a03dSEric Biggers destroy_test_sglist(&tsgls->src); 6853f47a03dSEric Biggers fail_kfree: 6863f47a03dSEric Biggers kfree(tsgls); 6873f47a03dSEric Biggers return NULL; 6883f47a03dSEric Biggers } 6893f47a03dSEric Biggers 6903f47a03dSEric Biggers static void free_cipher_test_sglists(struct cipher_test_sglists *tsgls) 6913f47a03dSEric Biggers { 6923f47a03dSEric Biggers if (tsgls) { 6933f47a03dSEric Biggers destroy_test_sglist(&tsgls->src); 6943f47a03dSEric Biggers destroy_test_sglist(&tsgls->dst); 6953f47a03dSEric Biggers kfree(tsgls); 6963f47a03dSEric Biggers } 6973f47a03dSEric Biggers } 6983f47a03dSEric Biggers 6993f47a03dSEric Biggers /* Build the src and dst scatterlists for an skcipher or AEAD test */ 7003f47a03dSEric Biggers static int build_cipher_test_sglists(struct cipher_test_sglists *tsgls, 7013f47a03dSEric Biggers const struct testvec_config *cfg, 7023f47a03dSEric Biggers unsigned int alignmask, 7033f47a03dSEric Biggers unsigned int src_total_len, 7043f47a03dSEric Biggers unsigned int dst_total_len, 7053f47a03dSEric Biggers const struct kvec *inputs, 7063f47a03dSEric Biggers unsigned int nr_inputs) 7073f47a03dSEric Biggers { 7083f47a03dSEric Biggers struct iov_iter input; 7093f47a03dSEric Biggers int err; 7103f47a03dSEric Biggers 7113f47a03dSEric Biggers iov_iter_kvec(&input, WRITE, inputs, nr_inputs, src_total_len); 7123f47a03dSEric Biggers err = build_test_sglist(&tsgls->src, cfg->src_divs, alignmask, 7133f47a03dSEric Biggers cfg->inplace ? 7143f47a03dSEric Biggers max(dst_total_len, src_total_len) : 7153f47a03dSEric Biggers src_total_len, 7163f47a03dSEric Biggers &input, NULL); 7173f47a03dSEric Biggers if (err) 7183f47a03dSEric Biggers return err; 7193f47a03dSEric Biggers 7203f47a03dSEric Biggers if (cfg->inplace) { 7213f47a03dSEric Biggers tsgls->dst.sgl_ptr = tsgls->src.sgl; 7223f47a03dSEric Biggers tsgls->dst.nents = tsgls->src.nents; 7233f47a03dSEric Biggers return 0; 7243f47a03dSEric Biggers } 7253f47a03dSEric Biggers return build_test_sglist(&tsgls->dst, 7263f47a03dSEric Biggers cfg->dst_divs[0].proportion_of_total ? 7273f47a03dSEric Biggers cfg->dst_divs : cfg->src_divs, 7283f47a03dSEric Biggers alignmask, dst_total_len, NULL, NULL); 729f8b0d4d0SHerbert Xu } 730f8b0d4d0SHerbert Xu 73125f9dddbSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 73225f9dddbSEric Biggers static char *generate_random_sgl_divisions(struct test_sg_division *divs, 73325f9dddbSEric Biggers size_t max_divs, char *p, char *end, 73425f9dddbSEric Biggers bool gen_flushes) 73525f9dddbSEric Biggers { 73625f9dddbSEric Biggers struct test_sg_division *div = divs; 73725f9dddbSEric Biggers unsigned int remaining = TEST_SG_TOTAL; 73825f9dddbSEric Biggers 73925f9dddbSEric Biggers do { 74025f9dddbSEric Biggers unsigned int this_len; 74125f9dddbSEric Biggers 74225f9dddbSEric Biggers if (div == &divs[max_divs - 1] || prandom_u32() % 2 == 0) 74325f9dddbSEric Biggers this_len = remaining; 74425f9dddbSEric Biggers else 74525f9dddbSEric Biggers this_len = 1 + (prandom_u32() % remaining); 74625f9dddbSEric Biggers div->proportion_of_total = this_len; 74725f9dddbSEric Biggers 74825f9dddbSEric Biggers if (prandom_u32() % 4 == 0) 74925f9dddbSEric Biggers div->offset = (PAGE_SIZE - 128) + (prandom_u32() % 128); 75025f9dddbSEric Biggers else if (prandom_u32() % 2 == 0) 75125f9dddbSEric Biggers div->offset = prandom_u32() % 32; 75225f9dddbSEric Biggers else 75325f9dddbSEric Biggers div->offset = prandom_u32() % PAGE_SIZE; 75425f9dddbSEric Biggers if (prandom_u32() % 8 == 0) 75525f9dddbSEric Biggers div->offset_relative_to_alignmask = true; 75625f9dddbSEric Biggers 75725f9dddbSEric Biggers div->flush_type = FLUSH_TYPE_NONE; 75825f9dddbSEric Biggers if (gen_flushes) { 75925f9dddbSEric Biggers switch (prandom_u32() % 4) { 76025f9dddbSEric Biggers case 0: 76125f9dddbSEric Biggers div->flush_type = FLUSH_TYPE_REIMPORT; 76225f9dddbSEric Biggers break; 76325f9dddbSEric Biggers case 1: 76425f9dddbSEric Biggers div->flush_type = FLUSH_TYPE_FLUSH; 76525f9dddbSEric Biggers break; 76625f9dddbSEric Biggers } 76725f9dddbSEric Biggers } 76825f9dddbSEric Biggers 76925f9dddbSEric Biggers BUILD_BUG_ON(TEST_SG_TOTAL != 10000); /* for "%u.%u%%" */ 77025f9dddbSEric Biggers p += scnprintf(p, end - p, "%s%u.%u%%@%s+%u%s", 77125f9dddbSEric Biggers div->flush_type == FLUSH_TYPE_NONE ? "" : 77225f9dddbSEric Biggers div->flush_type == FLUSH_TYPE_FLUSH ? 77325f9dddbSEric Biggers "<flush> " : "<reimport> ", 77425f9dddbSEric Biggers this_len / 100, this_len % 100, 77525f9dddbSEric Biggers div->offset_relative_to_alignmask ? 77625f9dddbSEric Biggers "alignmask" : "", 77725f9dddbSEric Biggers div->offset, this_len == remaining ? "" : ", "); 77825f9dddbSEric Biggers remaining -= this_len; 77925f9dddbSEric Biggers div++; 78025f9dddbSEric Biggers } while (remaining); 78125f9dddbSEric Biggers 78225f9dddbSEric Biggers return p; 78325f9dddbSEric Biggers } 78425f9dddbSEric Biggers 78525f9dddbSEric Biggers /* Generate a random testvec_config for fuzz testing */ 78625f9dddbSEric Biggers static void generate_random_testvec_config(struct testvec_config *cfg, 78725f9dddbSEric Biggers char *name, size_t max_namelen) 78825f9dddbSEric Biggers { 78925f9dddbSEric Biggers char *p = name; 79025f9dddbSEric Biggers char * const end = name + max_namelen; 79125f9dddbSEric Biggers 79225f9dddbSEric Biggers memset(cfg, 0, sizeof(*cfg)); 79325f9dddbSEric Biggers 79425f9dddbSEric Biggers cfg->name = name; 79525f9dddbSEric Biggers 79625f9dddbSEric Biggers p += scnprintf(p, end - p, "random:"); 79725f9dddbSEric Biggers 79825f9dddbSEric Biggers if (prandom_u32() % 2 == 0) { 79925f9dddbSEric Biggers cfg->inplace = true; 80025f9dddbSEric Biggers p += scnprintf(p, end - p, " inplace"); 80125f9dddbSEric Biggers } 80225f9dddbSEric Biggers 80325f9dddbSEric Biggers if (prandom_u32() % 2 == 0) { 80425f9dddbSEric Biggers cfg->req_flags |= CRYPTO_TFM_REQ_MAY_SLEEP; 80525f9dddbSEric Biggers p += scnprintf(p, end - p, " may_sleep"); 80625f9dddbSEric Biggers } 80725f9dddbSEric Biggers 80825f9dddbSEric Biggers switch (prandom_u32() % 4) { 80925f9dddbSEric Biggers case 0: 81025f9dddbSEric Biggers cfg->finalization_type = FINALIZATION_TYPE_FINAL; 81125f9dddbSEric Biggers p += scnprintf(p, end - p, " use_final"); 81225f9dddbSEric Biggers break; 81325f9dddbSEric Biggers case 1: 81425f9dddbSEric Biggers cfg->finalization_type = FINALIZATION_TYPE_FINUP; 81525f9dddbSEric Biggers p += scnprintf(p, end - p, " use_finup"); 81625f9dddbSEric Biggers break; 81725f9dddbSEric Biggers default: 81825f9dddbSEric Biggers cfg->finalization_type = FINALIZATION_TYPE_DIGEST; 81925f9dddbSEric Biggers p += scnprintf(p, end - p, " use_digest"); 82025f9dddbSEric Biggers break; 82125f9dddbSEric Biggers } 82225f9dddbSEric Biggers 82325f9dddbSEric Biggers p += scnprintf(p, end - p, " src_divs=["); 82425f9dddbSEric Biggers p = generate_random_sgl_divisions(cfg->src_divs, 82525f9dddbSEric Biggers ARRAY_SIZE(cfg->src_divs), p, end, 82625f9dddbSEric Biggers (cfg->finalization_type != 82725f9dddbSEric Biggers FINALIZATION_TYPE_DIGEST)); 82825f9dddbSEric Biggers p += scnprintf(p, end - p, "]"); 82925f9dddbSEric Biggers 83025f9dddbSEric Biggers if (!cfg->inplace && prandom_u32() % 2 == 0) { 83125f9dddbSEric Biggers p += scnprintf(p, end - p, " dst_divs=["); 83225f9dddbSEric Biggers p = generate_random_sgl_divisions(cfg->dst_divs, 83325f9dddbSEric Biggers ARRAY_SIZE(cfg->dst_divs), 83425f9dddbSEric Biggers p, end, false); 83525f9dddbSEric Biggers p += scnprintf(p, end - p, "]"); 83625f9dddbSEric Biggers } 83725f9dddbSEric Biggers 83825f9dddbSEric Biggers if (prandom_u32() % 2 == 0) { 83925f9dddbSEric Biggers cfg->iv_offset = 1 + (prandom_u32() % MAX_ALGAPI_ALIGNMASK); 84025f9dddbSEric Biggers p += scnprintf(p, end - p, " iv_offset=%u", cfg->iv_offset); 84125f9dddbSEric Biggers } 84225f9dddbSEric Biggers 84325f9dddbSEric Biggers WARN_ON_ONCE(!valid_testvec_config(cfg)); 84425f9dddbSEric Biggers } 845b55e1a39SEric Biggers 846b55e1a39SEric Biggers static void crypto_disable_simd_for_test(void) 847b55e1a39SEric Biggers { 848b55e1a39SEric Biggers preempt_disable(); 849b55e1a39SEric Biggers __this_cpu_write(crypto_simd_disabled_for_test, true); 850b55e1a39SEric Biggers } 851b55e1a39SEric Biggers 852b55e1a39SEric Biggers static void crypto_reenable_simd_for_test(void) 853b55e1a39SEric Biggers { 854b55e1a39SEric Biggers __this_cpu_write(crypto_simd_disabled_for_test, false); 855b55e1a39SEric Biggers preempt_enable(); 856b55e1a39SEric Biggers } 857b55e1a39SEric Biggers #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 858b55e1a39SEric Biggers static void crypto_disable_simd_for_test(void) 859b55e1a39SEric Biggers { 860b55e1a39SEric Biggers } 861b55e1a39SEric Biggers 862b55e1a39SEric Biggers static void crypto_reenable_simd_for_test(void) 863b55e1a39SEric Biggers { 864b55e1a39SEric Biggers } 865b55e1a39SEric Biggers #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */ 86625f9dddbSEric Biggers 8674cc2dcf9SEric Biggers static int check_nonfinal_hash_op(const char *op, int err, 8684cc2dcf9SEric Biggers u8 *result, unsigned int digestsize, 8694cc2dcf9SEric Biggers const char *driver, unsigned int vec_num, 8704cc2dcf9SEric Biggers const struct testvec_config *cfg) 871466d7b9fSKamil Konieczny { 8724cc2dcf9SEric Biggers if (err) { 8734cc2dcf9SEric Biggers pr_err("alg: hash: %s %s() failed with err %d on test vector %u, cfg=\"%s\"\n", 8744cc2dcf9SEric Biggers driver, op, err, vec_num, cfg->name); 8754cc2dcf9SEric Biggers return err; 8764cc2dcf9SEric Biggers } 8774cc2dcf9SEric Biggers if (!testmgr_is_poison(result, digestsize)) { 8784cc2dcf9SEric Biggers pr_err("alg: hash: %s %s() used result buffer on test vector %u, cfg=\"%s\"\n", 8794cc2dcf9SEric Biggers driver, op, vec_num, cfg->name); 880466d7b9fSKamil Konieczny return -EINVAL; 881466d7b9fSKamil Konieczny } 882466d7b9fSKamil Konieczny return 0; 883466d7b9fSKamil Konieczny } 884466d7b9fSKamil Konieczny 8854cc2dcf9SEric Biggers static int test_hash_vec_cfg(const char *driver, 8864cc2dcf9SEric Biggers const struct hash_testvec *vec, 8874cc2dcf9SEric Biggers unsigned int vec_num, 8884cc2dcf9SEric Biggers const struct testvec_config *cfg, 8894cc2dcf9SEric Biggers struct ahash_request *req, 8904cc2dcf9SEric Biggers struct test_sglist *tsgl, 8914cc2dcf9SEric Biggers u8 *hashstate) 892018ba95cSWang, Rui Y { 8934cc2dcf9SEric Biggers struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 8944cc2dcf9SEric Biggers const unsigned int alignmask = crypto_ahash_alignmask(tfm); 8954cc2dcf9SEric Biggers const unsigned int digestsize = crypto_ahash_digestsize(tfm); 8964cc2dcf9SEric Biggers const unsigned int statesize = crypto_ahash_statesize(tfm); 8974cc2dcf9SEric Biggers const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags; 8984cc2dcf9SEric Biggers const struct test_sg_division *divs[XBUFSIZE]; 8994cc2dcf9SEric Biggers DECLARE_CRYPTO_WAIT(wait); 9004cc2dcf9SEric Biggers struct kvec _input; 9014cc2dcf9SEric Biggers struct iov_iter input; 9024cc2dcf9SEric Biggers unsigned int i; 9034cc2dcf9SEric Biggers struct scatterlist *pending_sgl; 9044cc2dcf9SEric Biggers unsigned int pending_len; 9054cc2dcf9SEric Biggers u8 result[HASH_MAX_DIGESTSIZE + TESTMGR_POISON_LEN]; 9064cc2dcf9SEric Biggers int err; 907018ba95cSWang, Rui Y 9084cc2dcf9SEric Biggers /* Set the key, if specified */ 9094cc2dcf9SEric Biggers if (vec->ksize) { 9104cc2dcf9SEric Biggers err = crypto_ahash_setkey(tfm, vec->key, vec->ksize); 9114cc2dcf9SEric Biggers if (err) { 9124cc2dcf9SEric Biggers pr_err("alg: hash: %s setkey failed with err %d on test vector %u; flags=%#x\n", 9134cc2dcf9SEric Biggers driver, err, vec_num, 9144cc2dcf9SEric Biggers crypto_ahash_get_flags(tfm)); 9154cc2dcf9SEric Biggers return err; 916da7f033dSHerbert Xu } 917da7f033dSHerbert Xu } 918da7f033dSHerbert Xu 9194cc2dcf9SEric Biggers /* Build the scatterlist for the source data */ 9204cc2dcf9SEric Biggers _input.iov_base = (void *)vec->plaintext; 9214cc2dcf9SEric Biggers _input.iov_len = vec->psize; 9224cc2dcf9SEric Biggers iov_iter_kvec(&input, WRITE, &_input, 1, vec->psize); 9234cc2dcf9SEric Biggers err = build_test_sglist(tsgl, cfg->src_divs, alignmask, vec->psize, 9244cc2dcf9SEric Biggers &input, divs); 9254cc2dcf9SEric Biggers if (err) { 9264cc2dcf9SEric Biggers pr_err("alg: hash: %s: error preparing scatterlist for test vector %u, cfg=\"%s\"\n", 9274cc2dcf9SEric Biggers driver, vec_num, cfg->name); 9284cc2dcf9SEric Biggers return err; 929a8f1a052SDavid S. Miller } 930da7f033dSHerbert Xu 9314cc2dcf9SEric Biggers /* Do the actual hashing */ 932da7f033dSHerbert Xu 9334cc2dcf9SEric Biggers testmgr_poison(req->__ctx, crypto_ahash_reqsize(tfm)); 9344cc2dcf9SEric Biggers testmgr_poison(result, digestsize + TESTMGR_POISON_LEN); 93576715095SGilad Ben-Yossef 9364cc2dcf9SEric Biggers if (cfg->finalization_type == FINALIZATION_TYPE_DIGEST) { 9374cc2dcf9SEric Biggers /* Just using digest() */ 9384cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, crypto_req_done, 9397f397136SGilad Ben-Yossef &wait); 9404cc2dcf9SEric Biggers ahash_request_set_crypt(req, tsgl->sgl, result, vec->psize); 9414cc2dcf9SEric Biggers err = crypto_wait_req(crypto_ahash_digest(req), &wait); 9424cc2dcf9SEric Biggers if (err) { 9434cc2dcf9SEric Biggers pr_err("alg: hash: %s digest() failed with err %d on test vector %u, cfg=\"%s\"\n", 9444cc2dcf9SEric Biggers driver, err, vec_num, cfg->name); 9454cc2dcf9SEric Biggers return err; 946018ba95cSWang, Rui Y } 9474cc2dcf9SEric Biggers goto result_ready; 948018ba95cSWang, Rui Y } 9494cc2dcf9SEric Biggers 9504cc2dcf9SEric Biggers /* Using init(), zero or more update(), then final() or finup() */ 9514cc2dcf9SEric Biggers 9524cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, crypto_req_done, &wait); 9534cc2dcf9SEric Biggers ahash_request_set_crypt(req, NULL, result, 0); 9544cc2dcf9SEric Biggers err = crypto_wait_req(crypto_ahash_init(req), &wait); 9554cc2dcf9SEric Biggers err = check_nonfinal_hash_op("init", err, result, digestsize, 9564cc2dcf9SEric Biggers driver, vec_num, cfg); 9574cc2dcf9SEric Biggers if (err) 9584cc2dcf9SEric Biggers return err; 9594cc2dcf9SEric Biggers 9604cc2dcf9SEric Biggers pending_sgl = NULL; 9614cc2dcf9SEric Biggers pending_len = 0; 9624cc2dcf9SEric Biggers for (i = 0; i < tsgl->nents; i++) { 9634cc2dcf9SEric Biggers if (divs[i]->flush_type != FLUSH_TYPE_NONE && 9644cc2dcf9SEric Biggers pending_sgl != NULL) { 9654cc2dcf9SEric Biggers /* update() with the pending data */ 9664cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, 9674cc2dcf9SEric Biggers crypto_req_done, &wait); 9684cc2dcf9SEric Biggers ahash_request_set_crypt(req, pending_sgl, result, 9694cc2dcf9SEric Biggers pending_len); 9704cc2dcf9SEric Biggers err = crypto_wait_req(crypto_ahash_update(req), &wait); 9714cc2dcf9SEric Biggers err = check_nonfinal_hash_op("update", err, 9724cc2dcf9SEric Biggers result, digestsize, 9734cc2dcf9SEric Biggers driver, vec_num, cfg); 9744cc2dcf9SEric Biggers if (err) 9754cc2dcf9SEric Biggers return err; 9764cc2dcf9SEric Biggers pending_sgl = NULL; 9774cc2dcf9SEric Biggers pending_len = 0; 978018ba95cSWang, Rui Y } 9794cc2dcf9SEric Biggers if (divs[i]->flush_type == FLUSH_TYPE_REIMPORT) { 9804cc2dcf9SEric Biggers /* Test ->export() and ->import() */ 9814cc2dcf9SEric Biggers testmgr_poison(hashstate + statesize, 9824cc2dcf9SEric Biggers TESTMGR_POISON_LEN); 9834cc2dcf9SEric Biggers err = crypto_ahash_export(req, hashstate); 9844cc2dcf9SEric Biggers err = check_nonfinal_hash_op("export", err, 9854cc2dcf9SEric Biggers result, digestsize, 9864cc2dcf9SEric Biggers driver, vec_num, cfg); 9874cc2dcf9SEric Biggers if (err) 9884cc2dcf9SEric Biggers return err; 9894cc2dcf9SEric Biggers if (!testmgr_is_poison(hashstate + statesize, 9904cc2dcf9SEric Biggers TESTMGR_POISON_LEN)) { 9914cc2dcf9SEric Biggers pr_err("alg: hash: %s export() overran state buffer on test vector %u, cfg=\"%s\"\n", 9924cc2dcf9SEric Biggers driver, vec_num, cfg->name); 9934cc2dcf9SEric Biggers return -EOVERFLOW; 9944cc2dcf9SEric Biggers } 9954cc2dcf9SEric Biggers 9964cc2dcf9SEric Biggers testmgr_poison(req->__ctx, crypto_ahash_reqsize(tfm)); 9974cc2dcf9SEric Biggers err = crypto_ahash_import(req, hashstate); 9984cc2dcf9SEric Biggers err = check_nonfinal_hash_op("import", err, 9994cc2dcf9SEric Biggers result, digestsize, 10004cc2dcf9SEric Biggers driver, vec_num, cfg); 10014cc2dcf9SEric Biggers if (err) 10024cc2dcf9SEric Biggers return err; 10034cc2dcf9SEric Biggers } 10044cc2dcf9SEric Biggers if (pending_sgl == NULL) 10054cc2dcf9SEric Biggers pending_sgl = &tsgl->sgl[i]; 10064cc2dcf9SEric Biggers pending_len += tsgl->sgl[i].length; 10074cc2dcf9SEric Biggers } 10084cc2dcf9SEric Biggers 10094cc2dcf9SEric Biggers ahash_request_set_callback(req, req_flags, crypto_req_done, &wait); 10104cc2dcf9SEric Biggers ahash_request_set_crypt(req, pending_sgl, result, pending_len); 10114cc2dcf9SEric Biggers if (cfg->finalization_type == FINALIZATION_TYPE_FINAL) { 10124cc2dcf9SEric Biggers /* finish with update() and final() */ 10134cc2dcf9SEric Biggers err = crypto_wait_req(crypto_ahash_update(req), &wait); 10144cc2dcf9SEric Biggers err = check_nonfinal_hash_op("update", err, result, digestsize, 10154cc2dcf9SEric Biggers driver, vec_num, cfg); 10164cc2dcf9SEric Biggers if (err) 10174cc2dcf9SEric Biggers return err; 10184cc2dcf9SEric Biggers err = crypto_wait_req(crypto_ahash_final(req), &wait); 10194cc2dcf9SEric Biggers if (err) { 10204cc2dcf9SEric Biggers pr_err("alg: hash: %s final() failed with err %d on test vector %u, cfg=\"%s\"\n", 10214cc2dcf9SEric Biggers driver, err, vec_num, cfg->name); 10224cc2dcf9SEric Biggers return err; 10234cc2dcf9SEric Biggers } 10244cc2dcf9SEric Biggers } else { 10254cc2dcf9SEric Biggers /* finish with finup() */ 10264cc2dcf9SEric Biggers err = crypto_wait_req(crypto_ahash_finup(req), &wait); 10274cc2dcf9SEric Biggers if (err) { 10284cc2dcf9SEric Biggers pr_err("alg: hash: %s finup() failed with err %d on test vector %u, cfg=\"%s\"\n", 10294cc2dcf9SEric Biggers driver, err, vec_num, cfg->name); 10304cc2dcf9SEric Biggers return err; 1031018ba95cSWang, Rui Y } 1032018ba95cSWang, Rui Y } 1033018ba95cSWang, Rui Y 10344cc2dcf9SEric Biggers result_ready: 10354cc2dcf9SEric Biggers /* Check that the algorithm produced the correct digest */ 10364cc2dcf9SEric Biggers if (memcmp(result, vec->digest, digestsize) != 0) { 10374cc2dcf9SEric Biggers pr_err("alg: hash: %s test failed (wrong result) on test vector %u, cfg=\"%s\"\n", 10384cc2dcf9SEric Biggers driver, vec_num, cfg->name); 10394cc2dcf9SEric Biggers return -EINVAL; 1040da7f033dSHerbert Xu } 10414cc2dcf9SEric Biggers if (!testmgr_is_poison(&result[digestsize], TESTMGR_POISON_LEN)) { 10424cc2dcf9SEric Biggers pr_err("alg: hash: %s overran result buffer on test vector %u, cfg=\"%s\"\n", 10434cc2dcf9SEric Biggers driver, vec_num, cfg->name); 10444cc2dcf9SEric Biggers return -EOVERFLOW; 1045da5ffe11SJussi Kivilinna } 1046da5ffe11SJussi Kivilinna 1047da5ffe11SJussi Kivilinna return 0; 1048da5ffe11SJussi Kivilinna } 1049da5ffe11SJussi Kivilinna 10504cc2dcf9SEric Biggers static int test_hash_vec(const char *driver, const struct hash_testvec *vec, 10514cc2dcf9SEric Biggers unsigned int vec_num, struct ahash_request *req, 10524cc2dcf9SEric Biggers struct test_sglist *tsgl, u8 *hashstate) 10534cc2dcf9SEric Biggers { 10544cc2dcf9SEric Biggers unsigned int i; 10554cc2dcf9SEric Biggers int err; 10564cc2dcf9SEric Biggers 10574cc2dcf9SEric Biggers for (i = 0; i < ARRAY_SIZE(default_hash_testvec_configs); i++) { 10584cc2dcf9SEric Biggers err = test_hash_vec_cfg(driver, vec, vec_num, 10594cc2dcf9SEric Biggers &default_hash_testvec_configs[i], 10604cc2dcf9SEric Biggers req, tsgl, hashstate); 10614cc2dcf9SEric Biggers if (err) 10624cc2dcf9SEric Biggers return err; 10634cc2dcf9SEric Biggers } 10644cc2dcf9SEric Biggers 10654cc2dcf9SEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 10664cc2dcf9SEric Biggers if (!noextratests) { 10674cc2dcf9SEric Biggers struct testvec_config cfg; 10684cc2dcf9SEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 10694cc2dcf9SEric Biggers 10704cc2dcf9SEric Biggers for (i = 0; i < fuzz_iterations; i++) { 10714cc2dcf9SEric Biggers generate_random_testvec_config(&cfg, cfgname, 10724cc2dcf9SEric Biggers sizeof(cfgname)); 10734cc2dcf9SEric Biggers err = test_hash_vec_cfg(driver, vec, vec_num, &cfg, 10744cc2dcf9SEric Biggers req, tsgl, hashstate); 10754cc2dcf9SEric Biggers if (err) 10764cc2dcf9SEric Biggers return err; 10774cc2dcf9SEric Biggers } 10784cc2dcf9SEric Biggers } 10794cc2dcf9SEric Biggers #endif 10804cc2dcf9SEric Biggers return 0; 10814cc2dcf9SEric Biggers } 10824cc2dcf9SEric Biggers 10834cc2dcf9SEric Biggers static int __alg_test_hash(const struct hash_testvec *vecs, 10844cc2dcf9SEric Biggers unsigned int num_vecs, const char *driver, 10854cc2dcf9SEric Biggers u32 type, u32 mask) 10864cc2dcf9SEric Biggers { 10874cc2dcf9SEric Biggers struct crypto_ahash *tfm; 10884cc2dcf9SEric Biggers struct ahash_request *req = NULL; 10894cc2dcf9SEric Biggers struct test_sglist *tsgl = NULL; 10904cc2dcf9SEric Biggers u8 *hashstate = NULL; 10914cc2dcf9SEric Biggers unsigned int i; 10924cc2dcf9SEric Biggers int err; 10934cc2dcf9SEric Biggers 10944cc2dcf9SEric Biggers tfm = crypto_alloc_ahash(driver, type, mask); 10954cc2dcf9SEric Biggers if (IS_ERR(tfm)) { 10964cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate transform for %s: %ld\n", 10974cc2dcf9SEric Biggers driver, PTR_ERR(tfm)); 10984cc2dcf9SEric Biggers return PTR_ERR(tfm); 10994cc2dcf9SEric Biggers } 11004cc2dcf9SEric Biggers 11014cc2dcf9SEric Biggers req = ahash_request_alloc(tfm, GFP_KERNEL); 11024cc2dcf9SEric Biggers if (!req) { 11034cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate request for %s\n", 11044cc2dcf9SEric Biggers driver); 11054cc2dcf9SEric Biggers err = -ENOMEM; 11064cc2dcf9SEric Biggers goto out; 11074cc2dcf9SEric Biggers } 11084cc2dcf9SEric Biggers 11094cc2dcf9SEric Biggers tsgl = kmalloc(sizeof(*tsgl), GFP_KERNEL); 11104cc2dcf9SEric Biggers if (!tsgl || init_test_sglist(tsgl) != 0) { 11114cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate test buffers for %s\n", 11124cc2dcf9SEric Biggers driver); 11134cc2dcf9SEric Biggers kfree(tsgl); 11144cc2dcf9SEric Biggers tsgl = NULL; 11154cc2dcf9SEric Biggers err = -ENOMEM; 11164cc2dcf9SEric Biggers goto out; 11174cc2dcf9SEric Biggers } 11184cc2dcf9SEric Biggers 11194cc2dcf9SEric Biggers hashstate = kmalloc(crypto_ahash_statesize(tfm) + TESTMGR_POISON_LEN, 11204cc2dcf9SEric Biggers GFP_KERNEL); 11214cc2dcf9SEric Biggers if (!hashstate) { 11224cc2dcf9SEric Biggers pr_err("alg: hash: failed to allocate hash state buffer for %s\n", 11234cc2dcf9SEric Biggers driver); 11244cc2dcf9SEric Biggers err = -ENOMEM; 11254cc2dcf9SEric Biggers goto out; 11264cc2dcf9SEric Biggers } 11274cc2dcf9SEric Biggers 11284cc2dcf9SEric Biggers for (i = 0; i < num_vecs; i++) { 11294cc2dcf9SEric Biggers err = test_hash_vec(driver, &vecs[i], i, req, tsgl, hashstate); 11304cc2dcf9SEric Biggers if (err) 11314cc2dcf9SEric Biggers goto out; 11324cc2dcf9SEric Biggers } 11334cc2dcf9SEric Biggers err = 0; 11344cc2dcf9SEric Biggers out: 11354cc2dcf9SEric Biggers kfree(hashstate); 11364cc2dcf9SEric Biggers if (tsgl) { 11374cc2dcf9SEric Biggers destroy_test_sglist(tsgl); 11384cc2dcf9SEric Biggers kfree(tsgl); 11394cc2dcf9SEric Biggers } 11404cc2dcf9SEric Biggers ahash_request_free(req); 11414cc2dcf9SEric Biggers crypto_free_ahash(tfm); 11424cc2dcf9SEric Biggers return err; 11434cc2dcf9SEric Biggers } 11444cc2dcf9SEric Biggers 11454cc2dcf9SEric Biggers static int alg_test_hash(const struct alg_test_desc *desc, const char *driver, 11464cc2dcf9SEric Biggers u32 type, u32 mask) 11474cc2dcf9SEric Biggers { 11484cc2dcf9SEric Biggers const struct hash_testvec *template = desc->suite.hash.vecs; 11494cc2dcf9SEric Biggers unsigned int tcount = desc->suite.hash.count; 11504cc2dcf9SEric Biggers unsigned int nr_unkeyed, nr_keyed; 11514cc2dcf9SEric Biggers int err; 11524cc2dcf9SEric Biggers 11534cc2dcf9SEric Biggers /* 11544cc2dcf9SEric Biggers * For OPTIONAL_KEY algorithms, we have to do all the unkeyed tests 11554cc2dcf9SEric Biggers * first, before setting a key on the tfm. To make this easier, we 11564cc2dcf9SEric Biggers * require that the unkeyed test vectors (if any) are listed first. 11574cc2dcf9SEric Biggers */ 11584cc2dcf9SEric Biggers 11594cc2dcf9SEric Biggers for (nr_unkeyed = 0; nr_unkeyed < tcount; nr_unkeyed++) { 11604cc2dcf9SEric Biggers if (template[nr_unkeyed].ksize) 11614cc2dcf9SEric Biggers break; 11624cc2dcf9SEric Biggers } 11634cc2dcf9SEric Biggers for (nr_keyed = 0; nr_unkeyed + nr_keyed < tcount; nr_keyed++) { 11644cc2dcf9SEric Biggers if (!template[nr_unkeyed + nr_keyed].ksize) { 11654cc2dcf9SEric Biggers pr_err("alg: hash: test vectors for %s out of order, " 11664cc2dcf9SEric Biggers "unkeyed ones must come first\n", desc->alg); 11674cc2dcf9SEric Biggers return -EINVAL; 11684cc2dcf9SEric Biggers } 11694cc2dcf9SEric Biggers } 11704cc2dcf9SEric Biggers 11714cc2dcf9SEric Biggers err = 0; 11724cc2dcf9SEric Biggers if (nr_unkeyed) { 11734cc2dcf9SEric Biggers err = __alg_test_hash(template, nr_unkeyed, driver, type, mask); 11744cc2dcf9SEric Biggers template += nr_unkeyed; 11754cc2dcf9SEric Biggers } 11764cc2dcf9SEric Biggers 11774cc2dcf9SEric Biggers if (!err && nr_keyed) 11784cc2dcf9SEric Biggers err = __alg_test_hash(template, nr_keyed, driver, type, mask); 11794cc2dcf9SEric Biggers 11804cc2dcf9SEric Biggers return err; 11814cc2dcf9SEric Biggers } 11824cc2dcf9SEric Biggers 1183ed96804fSEric Biggers static int test_aead_vec_cfg(const char *driver, int enc, 1184ed96804fSEric Biggers const struct aead_testvec *vec, 1185ed96804fSEric Biggers unsigned int vec_num, 1186ed96804fSEric Biggers const struct testvec_config *cfg, 1187ed96804fSEric Biggers struct aead_request *req, 1188ed96804fSEric Biggers struct cipher_test_sglists *tsgls) 1189da7f033dSHerbert Xu { 1190ed96804fSEric Biggers struct crypto_aead *tfm = crypto_aead_reqtfm(req); 1191ed96804fSEric Biggers const unsigned int alignmask = crypto_aead_alignmask(tfm); 1192ed96804fSEric Biggers const unsigned int ivsize = crypto_aead_ivsize(tfm); 1193ed96804fSEric Biggers const unsigned int authsize = vec->clen - vec->plen; 1194ed96804fSEric Biggers const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags; 1195ed96804fSEric Biggers const char *op = enc ? "encryption" : "decryption"; 1196ed96804fSEric Biggers DECLARE_CRYPTO_WAIT(wait); 1197ed96804fSEric Biggers u8 _iv[3 * (MAX_ALGAPI_ALIGNMASK + 1) + MAX_IVLEN]; 1198ed96804fSEric Biggers u8 *iv = PTR_ALIGN(&_iv[0], 2 * (MAX_ALGAPI_ALIGNMASK + 1)) + 1199ed96804fSEric Biggers cfg->iv_offset + 1200ed96804fSEric Biggers (cfg->iv_offset_relative_to_alignmask ? alignmask : 0); 1201ed96804fSEric Biggers struct kvec input[2]; 1202ed96804fSEric Biggers int err; 1203f8b0d4d0SHerbert Xu 1204ed96804fSEric Biggers /* Set the key */ 1205ed96804fSEric Biggers if (vec->wk) 1206ed96804fSEric Biggers crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 1207d8a32ac2SJussi Kivilinna else 1208ed96804fSEric Biggers crypto_aead_clear_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 1209ed96804fSEric Biggers err = crypto_aead_setkey(tfm, vec->key, vec->klen); 1210ed96804fSEric Biggers if (err) { 1211ed96804fSEric Biggers if (vec->fail) /* expectedly failed to set key? */ 1212ed96804fSEric Biggers return 0; 1213ed96804fSEric Biggers pr_err("alg: aead: %s setkey failed with err %d on test vector %u; flags=%#x\n", 1214ed96804fSEric Biggers driver, err, vec_num, crypto_aead_get_flags(tfm)); 1215ed96804fSEric Biggers return err; 1216ed96804fSEric Biggers } 1217ed96804fSEric Biggers if (vec->fail) { 1218ed96804fSEric Biggers pr_err("alg: aead: %s setkey unexpectedly succeeded on test vector %u\n", 1219ed96804fSEric Biggers driver, vec_num); 1220ed96804fSEric Biggers return -EINVAL; 1221ed96804fSEric Biggers } 1222d8a32ac2SJussi Kivilinna 1223ed96804fSEric Biggers /* Set the authentication tag size */ 1224ed96804fSEric Biggers err = crypto_aead_setauthsize(tfm, authsize); 1225ed96804fSEric Biggers if (err) { 1226ed96804fSEric Biggers pr_err("alg: aead: %s setauthsize failed with err %d on test vector %u\n", 1227ed96804fSEric Biggers driver, err, vec_num); 1228ed96804fSEric Biggers return err; 1229ed96804fSEric Biggers } 1230ed96804fSEric Biggers 1231ed96804fSEric Biggers /* The IV must be copied to a buffer, as the algorithm may modify it */ 1232ed96804fSEric Biggers if (WARN_ON(ivsize > MAX_IVLEN)) 1233ed96804fSEric Biggers return -EINVAL; 1234ed96804fSEric Biggers if (vec->iv) 1235ed96804fSEric Biggers memcpy(iv, vec->iv, ivsize); 1236da7f033dSHerbert Xu else 1237ed96804fSEric Biggers memset(iv, 0, ivsize); 1238da7f033dSHerbert Xu 1239ed96804fSEric Biggers /* Build the src/dst scatterlists */ 1240ed96804fSEric Biggers input[0].iov_base = (void *)vec->assoc; 1241ed96804fSEric Biggers input[0].iov_len = vec->alen; 1242ed96804fSEric Biggers input[1].iov_base = enc ? (void *)vec->ptext : (void *)vec->ctext; 1243ed96804fSEric Biggers input[1].iov_len = enc ? vec->plen : vec->clen; 1244ed96804fSEric Biggers err = build_cipher_test_sglists(tsgls, cfg, alignmask, 1245ed96804fSEric Biggers vec->alen + (enc ? vec->plen : 1246ed96804fSEric Biggers vec->clen), 1247ed96804fSEric Biggers vec->alen + (enc ? vec->clen : 1248ed96804fSEric Biggers vec->plen), 1249ed96804fSEric Biggers input, 2); 1250ed96804fSEric Biggers if (err) { 1251ed96804fSEric Biggers pr_err("alg: aead: %s %s: error preparing scatterlists for test vector %u, cfg=\"%s\"\n", 1252ed96804fSEric Biggers driver, op, vec_num, cfg->name); 1253ed96804fSEric Biggers return err; 1254da7f033dSHerbert Xu } 1255da7f033dSHerbert Xu 1256ed96804fSEric Biggers /* Do the actual encryption or decryption */ 1257ed96804fSEric Biggers testmgr_poison(req->__ctx, crypto_aead_reqsize(tfm)); 1258ed96804fSEric Biggers aead_request_set_callback(req, req_flags, crypto_req_done, &wait); 1259ed96804fSEric Biggers aead_request_set_crypt(req, tsgls->src.sgl_ptr, tsgls->dst.sgl_ptr, 1260ed96804fSEric Biggers enc ? vec->plen : vec->clen, iv); 1261ed96804fSEric Biggers aead_request_set_ad(req, vec->alen); 1262ed96804fSEric Biggers err = crypto_wait_req(enc ? crypto_aead_encrypt(req) : 1263ed96804fSEric Biggers crypto_aead_decrypt(req), &wait); 1264ed96804fSEric Biggers if (err) { 1265ed96804fSEric Biggers if (err == -EBADMSG && vec->novrfy) 1266ed96804fSEric Biggers return 0; 1267ed96804fSEric Biggers pr_err("alg: aead: %s %s failed with err %d on test vector %u, cfg=\"%s\"\n", 1268ed96804fSEric Biggers driver, op, err, vec_num, cfg->name); 1269ed96804fSEric Biggers return err; 1270ed96804fSEric Biggers } 1271ed96804fSEric Biggers if (vec->novrfy) { 1272ed96804fSEric Biggers pr_err("alg: aead: %s %s unexpectedly succeeded on test vector %u, cfg=\"%s\"\n", 1273ed96804fSEric Biggers driver, op, vec_num, cfg->name); 1274ed96804fSEric Biggers return -EINVAL; 1275a0d608eeSEric Biggers } 127605b1d338SCristian Stoica 1277a6e5ef9bSEric Biggers /* Check that the algorithm didn't overwrite things it shouldn't have */ 1278a6e5ef9bSEric Biggers if (req->cryptlen != (enc ? vec->plen : vec->clen) || 1279a6e5ef9bSEric Biggers req->assoclen != vec->alen || 1280a6e5ef9bSEric Biggers req->iv != iv || 1281a6e5ef9bSEric Biggers req->src != tsgls->src.sgl_ptr || 1282a6e5ef9bSEric Biggers req->dst != tsgls->dst.sgl_ptr || 1283a6e5ef9bSEric Biggers crypto_aead_reqtfm(req) != tfm || 1284a6e5ef9bSEric Biggers req->base.complete != crypto_req_done || 1285a6e5ef9bSEric Biggers req->base.flags != req_flags || 1286a6e5ef9bSEric Biggers req->base.data != &wait) { 1287a6e5ef9bSEric Biggers pr_err("alg: aead: %s %s corrupted request struct on test vector %u, cfg=\"%s\"\n", 1288a6e5ef9bSEric Biggers driver, op, vec_num, cfg->name); 1289a6e5ef9bSEric Biggers if (req->cryptlen != (enc ? vec->plen : vec->clen)) 1290a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->cryptlen'\n"); 1291a6e5ef9bSEric Biggers if (req->assoclen != vec->alen) 1292a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->assoclen'\n"); 1293a6e5ef9bSEric Biggers if (req->iv != iv) 1294a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->iv'\n"); 1295a6e5ef9bSEric Biggers if (req->src != tsgls->src.sgl_ptr) 1296a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->src'\n"); 1297a6e5ef9bSEric Biggers if (req->dst != tsgls->dst.sgl_ptr) 1298a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->dst'\n"); 1299a6e5ef9bSEric Biggers if (crypto_aead_reqtfm(req) != tfm) 1300a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.tfm'\n"); 1301a6e5ef9bSEric Biggers if (req->base.complete != crypto_req_done) 1302a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.complete'\n"); 1303a6e5ef9bSEric Biggers if (req->base.flags != req_flags) 1304a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.flags'\n"); 1305a6e5ef9bSEric Biggers if (req->base.data != &wait) 1306a6e5ef9bSEric Biggers pr_err("alg: aead: changed 'req->base.data'\n"); 1307a6e5ef9bSEric Biggers return -EINVAL; 1308a6e5ef9bSEric Biggers } 1309a6e5ef9bSEric Biggers if (is_test_sglist_corrupted(&tsgls->src)) { 1310a6e5ef9bSEric Biggers pr_err("alg: aead: %s %s corrupted src sgl on test vector %u, cfg=\"%s\"\n", 1311a6e5ef9bSEric Biggers driver, op, vec_num, cfg->name); 1312a6e5ef9bSEric Biggers return -EINVAL; 1313a6e5ef9bSEric Biggers } 1314a6e5ef9bSEric Biggers if (tsgls->dst.sgl_ptr != tsgls->src.sgl && 1315a6e5ef9bSEric Biggers is_test_sglist_corrupted(&tsgls->dst)) { 1316a6e5ef9bSEric Biggers pr_err("alg: aead: %s %s corrupted dst sgl on test vector %u, cfg=\"%s\"\n", 1317a6e5ef9bSEric Biggers driver, op, vec_num, cfg->name); 1318a6e5ef9bSEric Biggers return -EINVAL; 1319a6e5ef9bSEric Biggers } 1320a6e5ef9bSEric Biggers 1321ed96804fSEric Biggers /* Check for the correct output (ciphertext or plaintext) */ 1322ed96804fSEric Biggers err = verify_correct_output(&tsgls->dst, enc ? vec->ctext : vec->ptext, 1323ed96804fSEric Biggers enc ? vec->clen : vec->plen, 1324ed96804fSEric Biggers vec->alen, enc || !cfg->inplace); 1325ed96804fSEric Biggers if (err == -EOVERFLOW) { 1326ed96804fSEric Biggers pr_err("alg: aead: %s %s overran dst buffer on test vector %u, cfg=\"%s\"\n", 1327ed96804fSEric Biggers driver, op, vec_num, cfg->name); 1328ed96804fSEric Biggers return err; 132929b77e5dSHoria Geanta } 1330ed96804fSEric Biggers if (err) { 1331ed96804fSEric Biggers pr_err("alg: aead: %s %s test failed (wrong result) on test vector %u, cfg=\"%s\"\n", 1332ed96804fSEric Biggers driver, op, vec_num, cfg->name); 1333ed96804fSEric Biggers return err; 133458dcf548SJussi Kivilinna } 133558dcf548SJussi Kivilinna 133658dcf548SJussi Kivilinna return 0; 1337d8a32ac2SJussi Kivilinna } 1338d8a32ac2SJussi Kivilinna 1339ed96804fSEric Biggers static int test_aead_vec(const char *driver, int enc, 1340ed96804fSEric Biggers const struct aead_testvec *vec, unsigned int vec_num, 1341ed96804fSEric Biggers struct aead_request *req, 1342ed96804fSEric Biggers struct cipher_test_sglists *tsgls) 1343ed96804fSEric Biggers { 1344ed96804fSEric Biggers unsigned int i; 1345ed96804fSEric Biggers int err; 1346ed96804fSEric Biggers 1347ed96804fSEric Biggers if (enc && vec->novrfy) 1348ed96804fSEric Biggers return 0; 1349ed96804fSEric Biggers 1350ed96804fSEric Biggers for (i = 0; i < ARRAY_SIZE(default_cipher_testvec_configs); i++) { 1351ed96804fSEric Biggers err = test_aead_vec_cfg(driver, enc, vec, vec_num, 1352ed96804fSEric Biggers &default_cipher_testvec_configs[i], 1353ed96804fSEric Biggers req, tsgls); 1354ed96804fSEric Biggers if (err) 1355ed96804fSEric Biggers return err; 1356ed96804fSEric Biggers } 1357ed96804fSEric Biggers 1358ed96804fSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 1359ed96804fSEric Biggers if (!noextratests) { 1360ed96804fSEric Biggers struct testvec_config cfg; 1361ed96804fSEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 1362ed96804fSEric Biggers 1363ed96804fSEric Biggers for (i = 0; i < fuzz_iterations; i++) { 1364ed96804fSEric Biggers generate_random_testvec_config(&cfg, cfgname, 1365ed96804fSEric Biggers sizeof(cfgname)); 1366ed96804fSEric Biggers err = test_aead_vec_cfg(driver, enc, vec, vec_num, 1367ed96804fSEric Biggers &cfg, req, tsgls); 1368ed96804fSEric Biggers if (err) 1369ed96804fSEric Biggers return err; 1370ed96804fSEric Biggers } 1371ed96804fSEric Biggers } 1372ed96804fSEric Biggers #endif 1373ed96804fSEric Biggers return 0; 1374ed96804fSEric Biggers } 1375ed96804fSEric Biggers 1376ed96804fSEric Biggers static int test_aead(const char *driver, int enc, 1377ed96804fSEric Biggers const struct aead_test_suite *suite, 1378ed96804fSEric Biggers struct aead_request *req, 1379ed96804fSEric Biggers struct cipher_test_sglists *tsgls) 1380ed96804fSEric Biggers { 1381ed96804fSEric Biggers unsigned int i; 1382ed96804fSEric Biggers int err; 1383ed96804fSEric Biggers 1384ed96804fSEric Biggers for (i = 0; i < suite->count; i++) { 1385ed96804fSEric Biggers err = test_aead_vec(driver, enc, &suite->vecs[i], i, req, 1386ed96804fSEric Biggers tsgls); 1387ed96804fSEric Biggers if (err) 1388ed96804fSEric Biggers return err; 1389ed96804fSEric Biggers } 1390ed96804fSEric Biggers return 0; 1391ed96804fSEric Biggers } 1392ed96804fSEric Biggers 1393ed96804fSEric Biggers static int alg_test_aead(const struct alg_test_desc *desc, const char *driver, 1394ed96804fSEric Biggers u32 type, u32 mask) 1395ed96804fSEric Biggers { 1396ed96804fSEric Biggers const struct aead_test_suite *suite = &desc->suite.aead; 1397ed96804fSEric Biggers struct crypto_aead *tfm; 1398ed96804fSEric Biggers struct aead_request *req = NULL; 1399ed96804fSEric Biggers struct cipher_test_sglists *tsgls = NULL; 1400ed96804fSEric Biggers int err; 1401ed96804fSEric Biggers 1402ed96804fSEric Biggers if (suite->count <= 0) { 1403ed96804fSEric Biggers pr_err("alg: aead: empty test suite for %s\n", driver); 1404ed96804fSEric Biggers return -EINVAL; 1405ed96804fSEric Biggers } 1406ed96804fSEric Biggers 1407ed96804fSEric Biggers tfm = crypto_alloc_aead(driver, type, mask); 1408ed96804fSEric Biggers if (IS_ERR(tfm)) { 1409ed96804fSEric Biggers pr_err("alg: aead: failed to allocate transform for %s: %ld\n", 1410ed96804fSEric Biggers driver, PTR_ERR(tfm)); 1411ed96804fSEric Biggers return PTR_ERR(tfm); 1412ed96804fSEric Biggers } 1413ed96804fSEric Biggers 1414ed96804fSEric Biggers req = aead_request_alloc(tfm, GFP_KERNEL); 1415ed96804fSEric Biggers if (!req) { 1416ed96804fSEric Biggers pr_err("alg: aead: failed to allocate request for %s\n", 1417ed96804fSEric Biggers driver); 1418ed96804fSEric Biggers err = -ENOMEM; 1419ed96804fSEric Biggers goto out; 1420ed96804fSEric Biggers } 1421ed96804fSEric Biggers 1422ed96804fSEric Biggers tsgls = alloc_cipher_test_sglists(); 1423ed96804fSEric Biggers if (!tsgls) { 1424ed96804fSEric Biggers pr_err("alg: aead: failed to allocate test buffers for %s\n", 1425ed96804fSEric Biggers driver); 1426ed96804fSEric Biggers err = -ENOMEM; 1427ed96804fSEric Biggers goto out; 1428ed96804fSEric Biggers } 1429ed96804fSEric Biggers 1430ed96804fSEric Biggers err = test_aead(driver, ENCRYPT, suite, req, tsgls); 1431ed96804fSEric Biggers if (err) 1432ed96804fSEric Biggers goto out; 1433ed96804fSEric Biggers 1434ed96804fSEric Biggers err = test_aead(driver, DECRYPT, suite, req, tsgls); 1435ed96804fSEric Biggers out: 1436ed96804fSEric Biggers free_cipher_test_sglists(tsgls); 1437ed96804fSEric Biggers aead_request_free(req); 1438ed96804fSEric Biggers crypto_free_aead(tfm); 1439ed96804fSEric Biggers return err; 1440ed96804fSEric Biggers } 1441ed96804fSEric Biggers 14421aa4ecd9SHerbert Xu static int test_cipher(struct crypto_cipher *tfm, int enc, 1443b13b1e0cSEric Biggers const struct cipher_testvec *template, 1444b13b1e0cSEric Biggers unsigned int tcount) 14451aa4ecd9SHerbert Xu { 14461aa4ecd9SHerbert Xu const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm)); 14471aa4ecd9SHerbert Xu unsigned int i, j, k; 14481aa4ecd9SHerbert Xu char *q; 14491aa4ecd9SHerbert Xu const char *e; 145092a4c9feSEric Biggers const char *input, *result; 14511aa4ecd9SHerbert Xu void *data; 1452f8b0d4d0SHerbert Xu char *xbuf[XBUFSIZE]; 1453f8b0d4d0SHerbert Xu int ret = -ENOMEM; 1454f8b0d4d0SHerbert Xu 1455f8b0d4d0SHerbert Xu if (testmgr_alloc_buf(xbuf)) 1456f8b0d4d0SHerbert Xu goto out_nobuf; 14571aa4ecd9SHerbert Xu 14581aa4ecd9SHerbert Xu if (enc == ENCRYPT) 14591aa4ecd9SHerbert Xu e = "encryption"; 14601aa4ecd9SHerbert Xu else 14611aa4ecd9SHerbert Xu e = "decryption"; 14621aa4ecd9SHerbert Xu 14631aa4ecd9SHerbert Xu j = 0; 14641aa4ecd9SHerbert Xu for (i = 0; i < tcount; i++) { 14651aa4ecd9SHerbert Xu 146610faa8c0SStephan Mueller if (fips_enabled && template[i].fips_skip) 146710faa8c0SStephan Mueller continue; 146810faa8c0SStephan Mueller 146992a4c9feSEric Biggers input = enc ? template[i].ptext : template[i].ctext; 147092a4c9feSEric Biggers result = enc ? template[i].ctext : template[i].ptext; 14711aa4ecd9SHerbert Xu j++; 14721aa4ecd9SHerbert Xu 1473fd57f22aSHerbert Xu ret = -EINVAL; 147492a4c9feSEric Biggers if (WARN_ON(template[i].len > PAGE_SIZE)) 1475fd57f22aSHerbert Xu goto out; 1476fd57f22aSHerbert Xu 14771aa4ecd9SHerbert Xu data = xbuf[0]; 147892a4c9feSEric Biggers memcpy(data, input, template[i].len); 14791aa4ecd9SHerbert Xu 14801aa4ecd9SHerbert Xu crypto_cipher_clear_flags(tfm, ~0); 14811aa4ecd9SHerbert Xu if (template[i].wk) 1482231baecdSEric Biggers crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 14831aa4ecd9SHerbert Xu 14841aa4ecd9SHerbert Xu ret = crypto_cipher_setkey(tfm, template[i].key, 14851aa4ecd9SHerbert Xu template[i].klen); 14860fae0c1eSYanjiang Jin if (template[i].fail == !ret) { 14871aa4ecd9SHerbert Xu printk(KERN_ERR "alg: cipher: setkey failed " 14881aa4ecd9SHerbert Xu "on test %d for %s: flags=%x\n", j, 14891aa4ecd9SHerbert Xu algo, crypto_cipher_get_flags(tfm)); 14901aa4ecd9SHerbert Xu goto out; 14911aa4ecd9SHerbert Xu } else if (ret) 14921aa4ecd9SHerbert Xu continue; 14931aa4ecd9SHerbert Xu 149492a4c9feSEric Biggers for (k = 0; k < template[i].len; 14951aa4ecd9SHerbert Xu k += crypto_cipher_blocksize(tfm)) { 14961aa4ecd9SHerbert Xu if (enc) 14971aa4ecd9SHerbert Xu crypto_cipher_encrypt_one(tfm, data + k, 14981aa4ecd9SHerbert Xu data + k); 14991aa4ecd9SHerbert Xu else 15001aa4ecd9SHerbert Xu crypto_cipher_decrypt_one(tfm, data + k, 15011aa4ecd9SHerbert Xu data + k); 15021aa4ecd9SHerbert Xu } 15031aa4ecd9SHerbert Xu 15041aa4ecd9SHerbert Xu q = data; 150592a4c9feSEric Biggers if (memcmp(q, result, template[i].len)) { 15061aa4ecd9SHerbert Xu printk(KERN_ERR "alg: cipher: Test %d failed " 15071aa4ecd9SHerbert Xu "on %s for %s\n", j, e, algo); 150892a4c9feSEric Biggers hexdump(q, template[i].len); 15091aa4ecd9SHerbert Xu ret = -EINVAL; 15101aa4ecd9SHerbert Xu goto out; 15111aa4ecd9SHerbert Xu } 15121aa4ecd9SHerbert Xu } 15131aa4ecd9SHerbert Xu 15141aa4ecd9SHerbert Xu ret = 0; 15151aa4ecd9SHerbert Xu 15161aa4ecd9SHerbert Xu out: 1517f8b0d4d0SHerbert Xu testmgr_free_buf(xbuf); 1518f8b0d4d0SHerbert Xu out_nobuf: 15191aa4ecd9SHerbert Xu return ret; 15201aa4ecd9SHerbert Xu } 15211aa4ecd9SHerbert Xu 15224e7babbaSEric Biggers static int test_skcipher_vec_cfg(const char *driver, int enc, 15234e7babbaSEric Biggers const struct cipher_testvec *vec, 15244e7babbaSEric Biggers unsigned int vec_num, 15254e7babbaSEric Biggers const struct testvec_config *cfg, 15264e7babbaSEric Biggers struct skcipher_request *req, 15274e7babbaSEric Biggers struct cipher_test_sglists *tsgls) 1528da7f033dSHerbert Xu { 15294e7babbaSEric Biggers struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 15304e7babbaSEric Biggers const unsigned int alignmask = crypto_skcipher_alignmask(tfm); 15314e7babbaSEric Biggers const unsigned int ivsize = crypto_skcipher_ivsize(tfm); 15324e7babbaSEric Biggers const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags; 15334e7babbaSEric Biggers const char *op = enc ? "encryption" : "decryption"; 15344e7babbaSEric Biggers DECLARE_CRYPTO_WAIT(wait); 15354e7babbaSEric Biggers u8 _iv[3 * (MAX_ALGAPI_ALIGNMASK + 1) + MAX_IVLEN]; 15364e7babbaSEric Biggers u8 *iv = PTR_ALIGN(&_iv[0], 2 * (MAX_ALGAPI_ALIGNMASK + 1)) + 15374e7babbaSEric Biggers cfg->iv_offset + 15384e7babbaSEric Biggers (cfg->iv_offset_relative_to_alignmask ? alignmask : 0); 15394e7babbaSEric Biggers struct kvec input; 15404e7babbaSEric Biggers int err; 1541f8b0d4d0SHerbert Xu 15424e7babbaSEric Biggers /* Set the key */ 15434e7babbaSEric Biggers if (vec->wk) 1544231baecdSEric Biggers crypto_skcipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 1545da7f033dSHerbert Xu else 15464e7babbaSEric Biggers crypto_skcipher_clear_flags(tfm, 15474e7babbaSEric Biggers CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); 15484e7babbaSEric Biggers err = crypto_skcipher_setkey(tfm, vec->key, vec->klen); 15494e7babbaSEric Biggers if (err) { 15504e7babbaSEric Biggers if (vec->fail) /* expectedly failed to set key? */ 15514e7babbaSEric Biggers return 0; 15524e7babbaSEric Biggers pr_err("alg: skcipher: %s setkey failed with err %d on test vector %u; flags=%#x\n", 15534e7babbaSEric Biggers driver, err, vec_num, crypto_skcipher_get_flags(tfm)); 15544e7babbaSEric Biggers return err; 15554e7babbaSEric Biggers } 15564e7babbaSEric Biggers if (vec->fail) { 15574e7babbaSEric Biggers pr_err("alg: skcipher: %s setkey unexpectedly succeeded on test vector %u\n", 15584e7babbaSEric Biggers driver, vec_num); 15594e7babbaSEric Biggers return -EINVAL; 156008d6af8cSJussi Kivilinna } 1561da7f033dSHerbert Xu 15624e7babbaSEric Biggers /* The IV must be copied to a buffer, as the algorithm may modify it */ 15634e7babbaSEric Biggers if (ivsize) { 15644e7babbaSEric Biggers if (WARN_ON(ivsize > MAX_IVLEN)) 15654e7babbaSEric Biggers return -EINVAL; 15668efd972eSEric Biggers if (vec->generates_iv && !enc) 15678efd972eSEric Biggers memcpy(iv, vec->iv_out, ivsize); 15688efd972eSEric Biggers else if (vec->iv) 15694e7babbaSEric Biggers memcpy(iv, vec->iv, ivsize); 157008d6af8cSJussi Kivilinna else 15714e7babbaSEric Biggers memset(iv, 0, ivsize); 15724e7babbaSEric Biggers } else { 15734e7babbaSEric Biggers if (vec->generates_iv) { 15744e7babbaSEric Biggers pr_err("alg: skcipher: %s has ivsize=0 but test vector %u generates IV!\n", 15754e7babbaSEric Biggers driver, vec_num); 15764e7babbaSEric Biggers return -EINVAL; 15774e7babbaSEric Biggers } 15784e7babbaSEric Biggers iv = NULL; 1579da7f033dSHerbert Xu } 1580da7f033dSHerbert Xu 15814e7babbaSEric Biggers /* Build the src/dst scatterlists */ 15824e7babbaSEric Biggers input.iov_base = enc ? (void *)vec->ptext : (void *)vec->ctext; 15834e7babbaSEric Biggers input.iov_len = vec->len; 15844e7babbaSEric Biggers err = build_cipher_test_sglists(tsgls, cfg, alignmask, 15854e7babbaSEric Biggers vec->len, vec->len, &input, 1); 15864e7babbaSEric Biggers if (err) { 15874e7babbaSEric Biggers pr_err("alg: skcipher: %s %s: error preparing scatterlists for test vector %u, cfg=\"%s\"\n", 15884e7babbaSEric Biggers driver, op, vec_num, cfg->name); 15894e7babbaSEric Biggers return err; 1590da7f033dSHerbert Xu } 1591da7f033dSHerbert Xu 15924e7babbaSEric Biggers /* Do the actual encryption or decryption */ 15934e7babbaSEric Biggers testmgr_poison(req->__ctx, crypto_skcipher_reqsize(tfm)); 15944e7babbaSEric Biggers skcipher_request_set_callback(req, req_flags, crypto_req_done, &wait); 15954e7babbaSEric Biggers skcipher_request_set_crypt(req, tsgls->src.sgl_ptr, tsgls->dst.sgl_ptr, 15964e7babbaSEric Biggers vec->len, iv); 15974e7babbaSEric Biggers err = crypto_wait_req(enc ? crypto_skcipher_encrypt(req) : 15984e7babbaSEric Biggers crypto_skcipher_decrypt(req), &wait); 15994e7babbaSEric Biggers if (err) { 16004e7babbaSEric Biggers pr_err("alg: skcipher: %s %s failed with err %d on test vector %u, cfg=\"%s\"\n", 16014e7babbaSEric Biggers driver, op, err, vec_num, cfg->name); 16024e7babbaSEric Biggers return err; 1603da7f033dSHerbert Xu } 1604da7f033dSHerbert Xu 1605fa353c99SEric Biggers /* Check that the algorithm didn't overwrite things it shouldn't have */ 1606fa353c99SEric Biggers if (req->cryptlen != vec->len || 1607fa353c99SEric Biggers req->iv != iv || 1608fa353c99SEric Biggers req->src != tsgls->src.sgl_ptr || 1609fa353c99SEric Biggers req->dst != tsgls->dst.sgl_ptr || 1610fa353c99SEric Biggers crypto_skcipher_reqtfm(req) != tfm || 1611fa353c99SEric Biggers req->base.complete != crypto_req_done || 1612fa353c99SEric Biggers req->base.flags != req_flags || 1613fa353c99SEric Biggers req->base.data != &wait) { 1614fa353c99SEric Biggers pr_err("alg: skcipher: %s %s corrupted request struct on test vector %u, cfg=\"%s\"\n", 1615fa353c99SEric Biggers driver, op, vec_num, cfg->name); 1616fa353c99SEric Biggers if (req->cryptlen != vec->len) 1617fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->cryptlen'\n"); 1618fa353c99SEric Biggers if (req->iv != iv) 1619fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->iv'\n"); 1620fa353c99SEric Biggers if (req->src != tsgls->src.sgl_ptr) 1621fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->src'\n"); 1622fa353c99SEric Biggers if (req->dst != tsgls->dst.sgl_ptr) 1623fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->dst'\n"); 1624fa353c99SEric Biggers if (crypto_skcipher_reqtfm(req) != tfm) 1625fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.tfm'\n"); 1626fa353c99SEric Biggers if (req->base.complete != crypto_req_done) 1627fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.complete'\n"); 1628fa353c99SEric Biggers if (req->base.flags != req_flags) 1629fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.flags'\n"); 1630fa353c99SEric Biggers if (req->base.data != &wait) 1631fa353c99SEric Biggers pr_err("alg: skcipher: changed 'req->base.data'\n"); 1632fa353c99SEric Biggers return -EINVAL; 1633fa353c99SEric Biggers } 1634fa353c99SEric Biggers if (is_test_sglist_corrupted(&tsgls->src)) { 1635fa353c99SEric Biggers pr_err("alg: skcipher: %s %s corrupted src sgl on test vector %u, cfg=\"%s\"\n", 1636fa353c99SEric Biggers driver, op, vec_num, cfg->name); 1637fa353c99SEric Biggers return -EINVAL; 1638fa353c99SEric Biggers } 1639fa353c99SEric Biggers if (tsgls->dst.sgl_ptr != tsgls->src.sgl && 1640fa353c99SEric Biggers is_test_sglist_corrupted(&tsgls->dst)) { 1641fa353c99SEric Biggers pr_err("alg: skcipher: %s %s corrupted dst sgl on test vector %u, cfg=\"%s\"\n", 1642fa353c99SEric Biggers driver, op, vec_num, cfg->name); 1643fa353c99SEric Biggers return -EINVAL; 1644fa353c99SEric Biggers } 1645fa353c99SEric Biggers 16464e7babbaSEric Biggers /* Check for the correct output (ciphertext or plaintext) */ 16474e7babbaSEric Biggers err = verify_correct_output(&tsgls->dst, enc ? vec->ctext : vec->ptext, 16484e7babbaSEric Biggers vec->len, 0, true); 16494e7babbaSEric Biggers if (err == -EOVERFLOW) { 16504e7babbaSEric Biggers pr_err("alg: skcipher: %s %s overran dst buffer on test vector %u, cfg=\"%s\"\n", 16514e7babbaSEric Biggers driver, op, vec_num, cfg->name); 16524e7babbaSEric Biggers return err; 16534e7babbaSEric Biggers } 16544e7babbaSEric Biggers if (err) { 16554e7babbaSEric Biggers pr_err("alg: skcipher: %s %s test failed (wrong result) on test vector %u, cfg=\"%s\"\n", 16564e7babbaSEric Biggers driver, op, vec_num, cfg->name); 16574e7babbaSEric Biggers return err; 16584e7babbaSEric Biggers } 165908d6af8cSJussi Kivilinna 16604e7babbaSEric Biggers /* If applicable, check that the algorithm generated the correct IV */ 16618efd972eSEric Biggers if (vec->iv_out && memcmp(iv, vec->iv_out, ivsize) != 0) { 16624e7babbaSEric Biggers pr_err("alg: skcipher: %s %s test failed (wrong output IV) on test vector %u, cfg=\"%s\"\n", 16634e7babbaSEric Biggers driver, op, vec_num, cfg->name); 16644e7babbaSEric Biggers hexdump(iv, ivsize); 16654e7babbaSEric Biggers return -EINVAL; 16663a338f20SJussi Kivilinna } 16673a338f20SJussi Kivilinna 16683a338f20SJussi Kivilinna return 0; 166908d6af8cSJussi Kivilinna } 167008d6af8cSJussi Kivilinna 16714e7babbaSEric Biggers static int test_skcipher_vec(const char *driver, int enc, 16724e7babbaSEric Biggers const struct cipher_testvec *vec, 16734e7babbaSEric Biggers unsigned int vec_num, 16744e7babbaSEric Biggers struct skcipher_request *req, 16754e7babbaSEric Biggers struct cipher_test_sglists *tsgls) 16764e7babbaSEric Biggers { 16774e7babbaSEric Biggers unsigned int i; 16784e7babbaSEric Biggers int err; 16794e7babbaSEric Biggers 16804e7babbaSEric Biggers if (fips_enabled && vec->fips_skip) 16814e7babbaSEric Biggers return 0; 16824e7babbaSEric Biggers 16834e7babbaSEric Biggers for (i = 0; i < ARRAY_SIZE(default_cipher_testvec_configs); i++) { 16844e7babbaSEric Biggers err = test_skcipher_vec_cfg(driver, enc, vec, vec_num, 16854e7babbaSEric Biggers &default_cipher_testvec_configs[i], 16864e7babbaSEric Biggers req, tsgls); 16874e7babbaSEric Biggers if (err) 16884e7babbaSEric Biggers return err; 16894e7babbaSEric Biggers } 16904e7babbaSEric Biggers 16914e7babbaSEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 16924e7babbaSEric Biggers if (!noextratests) { 16934e7babbaSEric Biggers struct testvec_config cfg; 16944e7babbaSEric Biggers char cfgname[TESTVEC_CONFIG_NAMELEN]; 16954e7babbaSEric Biggers 16964e7babbaSEric Biggers for (i = 0; i < fuzz_iterations; i++) { 16974e7babbaSEric Biggers generate_random_testvec_config(&cfg, cfgname, 16984e7babbaSEric Biggers sizeof(cfgname)); 16994e7babbaSEric Biggers err = test_skcipher_vec_cfg(driver, enc, vec, vec_num, 17004e7babbaSEric Biggers &cfg, req, tsgls); 17014e7babbaSEric Biggers if (err) 17024e7babbaSEric Biggers return err; 17034e7babbaSEric Biggers } 17044e7babbaSEric Biggers } 17054e7babbaSEric Biggers #endif 17064e7babbaSEric Biggers return 0; 17074e7babbaSEric Biggers } 17084e7babbaSEric Biggers 17094e7babbaSEric Biggers static int test_skcipher(const char *driver, int enc, 17104e7babbaSEric Biggers const struct cipher_test_suite *suite, 17114e7babbaSEric Biggers struct skcipher_request *req, 17124e7babbaSEric Biggers struct cipher_test_sglists *tsgls) 17134e7babbaSEric Biggers { 17144e7babbaSEric Biggers unsigned int i; 17154e7babbaSEric Biggers int err; 17164e7babbaSEric Biggers 17174e7babbaSEric Biggers for (i = 0; i < suite->count; i++) { 17184e7babbaSEric Biggers err = test_skcipher_vec(driver, enc, &suite->vecs[i], i, req, 17194e7babbaSEric Biggers tsgls); 17204e7babbaSEric Biggers if (err) 17214e7babbaSEric Biggers return err; 17224e7babbaSEric Biggers } 17234e7babbaSEric Biggers return 0; 17244e7babbaSEric Biggers } 17254e7babbaSEric Biggers 17264e7babbaSEric Biggers static int alg_test_skcipher(const struct alg_test_desc *desc, 17274e7babbaSEric Biggers const char *driver, u32 type, u32 mask) 17284e7babbaSEric Biggers { 17294e7babbaSEric Biggers const struct cipher_test_suite *suite = &desc->suite.cipher; 17304e7babbaSEric Biggers struct crypto_skcipher *tfm; 17314e7babbaSEric Biggers struct skcipher_request *req = NULL; 17324e7babbaSEric Biggers struct cipher_test_sglists *tsgls = NULL; 17334e7babbaSEric Biggers int err; 17344e7babbaSEric Biggers 17354e7babbaSEric Biggers if (suite->count <= 0) { 17364e7babbaSEric Biggers pr_err("alg: skcipher: empty test suite for %s\n", driver); 17374e7babbaSEric Biggers return -EINVAL; 17384e7babbaSEric Biggers } 17394e7babbaSEric Biggers 17404e7babbaSEric Biggers tfm = crypto_alloc_skcipher(driver, type, mask); 17414e7babbaSEric Biggers if (IS_ERR(tfm)) { 17424e7babbaSEric Biggers pr_err("alg: skcipher: failed to allocate transform for %s: %ld\n", 17434e7babbaSEric Biggers driver, PTR_ERR(tfm)); 17444e7babbaSEric Biggers return PTR_ERR(tfm); 17454e7babbaSEric Biggers } 17464e7babbaSEric Biggers 17474e7babbaSEric Biggers req = skcipher_request_alloc(tfm, GFP_KERNEL); 17484e7babbaSEric Biggers if (!req) { 17494e7babbaSEric Biggers pr_err("alg: skcipher: failed to allocate request for %s\n", 17504e7babbaSEric Biggers driver); 17514e7babbaSEric Biggers err = -ENOMEM; 17524e7babbaSEric Biggers goto out; 17534e7babbaSEric Biggers } 17544e7babbaSEric Biggers 17554e7babbaSEric Biggers tsgls = alloc_cipher_test_sglists(); 17564e7babbaSEric Biggers if (!tsgls) { 17574e7babbaSEric Biggers pr_err("alg: skcipher: failed to allocate test buffers for %s\n", 17584e7babbaSEric Biggers driver); 17594e7babbaSEric Biggers err = -ENOMEM; 17604e7babbaSEric Biggers goto out; 17614e7babbaSEric Biggers } 17624e7babbaSEric Biggers 17634e7babbaSEric Biggers err = test_skcipher(driver, ENCRYPT, suite, req, tsgls); 17644e7babbaSEric Biggers if (err) 17654e7babbaSEric Biggers goto out; 17664e7babbaSEric Biggers 17674e7babbaSEric Biggers err = test_skcipher(driver, DECRYPT, suite, req, tsgls); 17684e7babbaSEric Biggers out: 17694e7babbaSEric Biggers free_cipher_test_sglists(tsgls); 17704e7babbaSEric Biggers skcipher_request_free(req); 17714e7babbaSEric Biggers crypto_free_skcipher(tfm); 17724e7babbaSEric Biggers return err; 17734e7babbaSEric Biggers } 17744e7babbaSEric Biggers 1775b13b1e0cSEric Biggers static int test_comp(struct crypto_comp *tfm, 1776b13b1e0cSEric Biggers const struct comp_testvec *ctemplate, 1777b13b1e0cSEric Biggers const struct comp_testvec *dtemplate, 1778b13b1e0cSEric Biggers int ctcount, int dtcount) 1779da7f033dSHerbert Xu { 1780da7f033dSHerbert Xu const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm)); 178133607384SMahipal Challa char *output, *decomp_output; 1782da7f033dSHerbert Xu unsigned int i; 1783da7f033dSHerbert Xu int ret; 1784da7f033dSHerbert Xu 178533607384SMahipal Challa output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 178633607384SMahipal Challa if (!output) 178733607384SMahipal Challa return -ENOMEM; 178833607384SMahipal Challa 178933607384SMahipal Challa decomp_output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 179033607384SMahipal Challa if (!decomp_output) { 179133607384SMahipal Challa kfree(output); 179233607384SMahipal Challa return -ENOMEM; 179333607384SMahipal Challa } 179433607384SMahipal Challa 1795da7f033dSHerbert Xu for (i = 0; i < ctcount; i++) { 1796c79cf910SGeert Uytterhoeven int ilen; 1797c79cf910SGeert Uytterhoeven unsigned int dlen = COMP_BUF_SIZE; 1798da7f033dSHerbert Xu 179922a8118dSMichael Schupikov memset(output, 0, COMP_BUF_SIZE); 180022a8118dSMichael Schupikov memset(decomp_output, 0, COMP_BUF_SIZE); 1801da7f033dSHerbert Xu 1802da7f033dSHerbert Xu ilen = ctemplate[i].inlen; 1803da7f033dSHerbert Xu ret = crypto_comp_compress(tfm, ctemplate[i].input, 180433607384SMahipal Challa ilen, output, &dlen); 1805da7f033dSHerbert Xu if (ret) { 1806da7f033dSHerbert Xu printk(KERN_ERR "alg: comp: compression failed " 1807da7f033dSHerbert Xu "on test %d for %s: ret=%d\n", i + 1, algo, 1808da7f033dSHerbert Xu -ret); 1809da7f033dSHerbert Xu goto out; 1810da7f033dSHerbert Xu } 1811da7f033dSHerbert Xu 181233607384SMahipal Challa ilen = dlen; 181333607384SMahipal Challa dlen = COMP_BUF_SIZE; 181433607384SMahipal Challa ret = crypto_comp_decompress(tfm, output, 181533607384SMahipal Challa ilen, decomp_output, &dlen); 181633607384SMahipal Challa if (ret) { 181733607384SMahipal Challa pr_err("alg: comp: compression failed: decompress: on test %d for %s failed: ret=%d\n", 181833607384SMahipal Challa i + 1, algo, -ret); 181933607384SMahipal Challa goto out; 182033607384SMahipal Challa } 182133607384SMahipal Challa 182233607384SMahipal Challa if (dlen != ctemplate[i].inlen) { 1823b812eb00SGeert Uytterhoeven printk(KERN_ERR "alg: comp: Compression test %d " 1824b812eb00SGeert Uytterhoeven "failed for %s: output len = %d\n", i + 1, algo, 1825b812eb00SGeert Uytterhoeven dlen); 1826b812eb00SGeert Uytterhoeven ret = -EINVAL; 1827b812eb00SGeert Uytterhoeven goto out; 1828b812eb00SGeert Uytterhoeven } 1829b812eb00SGeert Uytterhoeven 183033607384SMahipal Challa if (memcmp(decomp_output, ctemplate[i].input, 183133607384SMahipal Challa ctemplate[i].inlen)) { 183233607384SMahipal Challa pr_err("alg: comp: compression failed: output differs: on test %d for %s\n", 183333607384SMahipal Challa i + 1, algo); 183433607384SMahipal Challa hexdump(decomp_output, dlen); 1835da7f033dSHerbert Xu ret = -EINVAL; 1836da7f033dSHerbert Xu goto out; 1837da7f033dSHerbert Xu } 1838da7f033dSHerbert Xu } 1839da7f033dSHerbert Xu 1840da7f033dSHerbert Xu for (i = 0; i < dtcount; i++) { 1841c79cf910SGeert Uytterhoeven int ilen; 1842c79cf910SGeert Uytterhoeven unsigned int dlen = COMP_BUF_SIZE; 1843da7f033dSHerbert Xu 184422a8118dSMichael Schupikov memset(decomp_output, 0, COMP_BUF_SIZE); 1845da7f033dSHerbert Xu 1846da7f033dSHerbert Xu ilen = dtemplate[i].inlen; 1847da7f033dSHerbert Xu ret = crypto_comp_decompress(tfm, dtemplate[i].input, 184833607384SMahipal Challa ilen, decomp_output, &dlen); 1849da7f033dSHerbert Xu if (ret) { 1850da7f033dSHerbert Xu printk(KERN_ERR "alg: comp: decompression failed " 1851da7f033dSHerbert Xu "on test %d for %s: ret=%d\n", i + 1, algo, 1852da7f033dSHerbert Xu -ret); 1853da7f033dSHerbert Xu goto out; 1854da7f033dSHerbert Xu } 1855da7f033dSHerbert Xu 1856b812eb00SGeert Uytterhoeven if (dlen != dtemplate[i].outlen) { 1857b812eb00SGeert Uytterhoeven printk(KERN_ERR "alg: comp: Decompression test %d " 1858b812eb00SGeert Uytterhoeven "failed for %s: output len = %d\n", i + 1, algo, 1859b812eb00SGeert Uytterhoeven dlen); 1860b812eb00SGeert Uytterhoeven ret = -EINVAL; 1861b812eb00SGeert Uytterhoeven goto out; 1862b812eb00SGeert Uytterhoeven } 1863b812eb00SGeert Uytterhoeven 186433607384SMahipal Challa if (memcmp(decomp_output, dtemplate[i].output, dlen)) { 1865da7f033dSHerbert Xu printk(KERN_ERR "alg: comp: Decompression test %d " 1866da7f033dSHerbert Xu "failed for %s\n", i + 1, algo); 186733607384SMahipal Challa hexdump(decomp_output, dlen); 1868da7f033dSHerbert Xu ret = -EINVAL; 1869da7f033dSHerbert Xu goto out; 1870da7f033dSHerbert Xu } 1871da7f033dSHerbert Xu } 1872da7f033dSHerbert Xu 1873da7f033dSHerbert Xu ret = 0; 1874da7f033dSHerbert Xu 1875da7f033dSHerbert Xu out: 187633607384SMahipal Challa kfree(decomp_output); 187733607384SMahipal Challa kfree(output); 1878da7f033dSHerbert Xu return ret; 1879da7f033dSHerbert Xu } 1880da7f033dSHerbert Xu 1881b13b1e0cSEric Biggers static int test_acomp(struct crypto_acomp *tfm, 1882b13b1e0cSEric Biggers const struct comp_testvec *ctemplate, 1883b13b1e0cSEric Biggers const struct comp_testvec *dtemplate, 1884b13b1e0cSEric Biggers int ctcount, int dtcount) 1885d7db7a88SGiovanni Cabiddu { 1886d7db7a88SGiovanni Cabiddu const char *algo = crypto_tfm_alg_driver_name(crypto_acomp_tfm(tfm)); 1887d7db7a88SGiovanni Cabiddu unsigned int i; 1888a9943a0aSGiovanni Cabiddu char *output, *decomp_out; 1889d7db7a88SGiovanni Cabiddu int ret; 1890d7db7a88SGiovanni Cabiddu struct scatterlist src, dst; 1891d7db7a88SGiovanni Cabiddu struct acomp_req *req; 18927f397136SGilad Ben-Yossef struct crypto_wait wait; 1893d7db7a88SGiovanni Cabiddu 1894eb095593SEric Biggers output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 1895eb095593SEric Biggers if (!output) 1896eb095593SEric Biggers return -ENOMEM; 1897eb095593SEric Biggers 1898a9943a0aSGiovanni Cabiddu decomp_out = kmalloc(COMP_BUF_SIZE, GFP_KERNEL); 1899a9943a0aSGiovanni Cabiddu if (!decomp_out) { 1900a9943a0aSGiovanni Cabiddu kfree(output); 1901a9943a0aSGiovanni Cabiddu return -ENOMEM; 1902a9943a0aSGiovanni Cabiddu } 1903a9943a0aSGiovanni Cabiddu 1904d7db7a88SGiovanni Cabiddu for (i = 0; i < ctcount; i++) { 1905d7db7a88SGiovanni Cabiddu unsigned int dlen = COMP_BUF_SIZE; 1906d7db7a88SGiovanni Cabiddu int ilen = ctemplate[i].inlen; 190702608e02SLaura Abbott void *input_vec; 1908d7db7a88SGiovanni Cabiddu 1909d2110224SEric Biggers input_vec = kmemdup(ctemplate[i].input, ilen, GFP_KERNEL); 191002608e02SLaura Abbott if (!input_vec) { 191102608e02SLaura Abbott ret = -ENOMEM; 191202608e02SLaura Abbott goto out; 191302608e02SLaura Abbott } 191402608e02SLaura Abbott 1915eb095593SEric Biggers memset(output, 0, dlen); 19167f397136SGilad Ben-Yossef crypto_init_wait(&wait); 191702608e02SLaura Abbott sg_init_one(&src, input_vec, ilen); 1918d7db7a88SGiovanni Cabiddu sg_init_one(&dst, output, dlen); 1919d7db7a88SGiovanni Cabiddu 1920d7db7a88SGiovanni Cabiddu req = acomp_request_alloc(tfm); 1921d7db7a88SGiovanni Cabiddu if (!req) { 1922d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: request alloc failed for %s\n", 1923d7db7a88SGiovanni Cabiddu algo); 192402608e02SLaura Abbott kfree(input_vec); 1925d7db7a88SGiovanni Cabiddu ret = -ENOMEM; 1926d7db7a88SGiovanni Cabiddu goto out; 1927d7db7a88SGiovanni Cabiddu } 1928d7db7a88SGiovanni Cabiddu 1929d7db7a88SGiovanni Cabiddu acomp_request_set_params(req, &src, &dst, ilen, dlen); 1930d7db7a88SGiovanni Cabiddu acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 19317f397136SGilad Ben-Yossef crypto_req_done, &wait); 1932d7db7a88SGiovanni Cabiddu 19337f397136SGilad Ben-Yossef ret = crypto_wait_req(crypto_acomp_compress(req), &wait); 1934d7db7a88SGiovanni Cabiddu if (ret) { 1935d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n", 1936d7db7a88SGiovanni Cabiddu i + 1, algo, -ret); 193702608e02SLaura Abbott kfree(input_vec); 1938d7db7a88SGiovanni Cabiddu acomp_request_free(req); 1939d7db7a88SGiovanni Cabiddu goto out; 1940d7db7a88SGiovanni Cabiddu } 1941d7db7a88SGiovanni Cabiddu 1942a9943a0aSGiovanni Cabiddu ilen = req->dlen; 1943a9943a0aSGiovanni Cabiddu dlen = COMP_BUF_SIZE; 1944a9943a0aSGiovanni Cabiddu sg_init_one(&src, output, ilen); 1945a9943a0aSGiovanni Cabiddu sg_init_one(&dst, decomp_out, dlen); 19467f397136SGilad Ben-Yossef crypto_init_wait(&wait); 1947a9943a0aSGiovanni Cabiddu acomp_request_set_params(req, &src, &dst, ilen, dlen); 1948a9943a0aSGiovanni Cabiddu 19497f397136SGilad Ben-Yossef ret = crypto_wait_req(crypto_acomp_decompress(req), &wait); 1950a9943a0aSGiovanni Cabiddu if (ret) { 1951a9943a0aSGiovanni Cabiddu pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n", 1952a9943a0aSGiovanni Cabiddu i + 1, algo, -ret); 1953a9943a0aSGiovanni Cabiddu kfree(input_vec); 1954a9943a0aSGiovanni Cabiddu acomp_request_free(req); 1955a9943a0aSGiovanni Cabiddu goto out; 1956a9943a0aSGiovanni Cabiddu } 1957a9943a0aSGiovanni Cabiddu 1958a9943a0aSGiovanni Cabiddu if (req->dlen != ctemplate[i].inlen) { 1959d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Compression test %d failed for %s: output len = %d\n", 1960d7db7a88SGiovanni Cabiddu i + 1, algo, req->dlen); 1961d7db7a88SGiovanni Cabiddu ret = -EINVAL; 196202608e02SLaura Abbott kfree(input_vec); 1963d7db7a88SGiovanni Cabiddu acomp_request_free(req); 1964d7db7a88SGiovanni Cabiddu goto out; 1965d7db7a88SGiovanni Cabiddu } 1966d7db7a88SGiovanni Cabiddu 1967a9943a0aSGiovanni Cabiddu if (memcmp(input_vec, decomp_out, req->dlen)) { 1968d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Compression test %d failed for %s\n", 1969d7db7a88SGiovanni Cabiddu i + 1, algo); 1970d7db7a88SGiovanni Cabiddu hexdump(output, req->dlen); 1971d7db7a88SGiovanni Cabiddu ret = -EINVAL; 197202608e02SLaura Abbott kfree(input_vec); 1973d7db7a88SGiovanni Cabiddu acomp_request_free(req); 1974d7db7a88SGiovanni Cabiddu goto out; 1975d7db7a88SGiovanni Cabiddu } 1976d7db7a88SGiovanni Cabiddu 197702608e02SLaura Abbott kfree(input_vec); 1978d7db7a88SGiovanni Cabiddu acomp_request_free(req); 1979d7db7a88SGiovanni Cabiddu } 1980d7db7a88SGiovanni Cabiddu 1981d7db7a88SGiovanni Cabiddu for (i = 0; i < dtcount; i++) { 1982d7db7a88SGiovanni Cabiddu unsigned int dlen = COMP_BUF_SIZE; 1983d7db7a88SGiovanni Cabiddu int ilen = dtemplate[i].inlen; 198402608e02SLaura Abbott void *input_vec; 1985d7db7a88SGiovanni Cabiddu 1986d2110224SEric Biggers input_vec = kmemdup(dtemplate[i].input, ilen, GFP_KERNEL); 198702608e02SLaura Abbott if (!input_vec) { 198802608e02SLaura Abbott ret = -ENOMEM; 198902608e02SLaura Abbott goto out; 199002608e02SLaura Abbott } 199102608e02SLaura Abbott 1992eb095593SEric Biggers memset(output, 0, dlen); 19937f397136SGilad Ben-Yossef crypto_init_wait(&wait); 199402608e02SLaura Abbott sg_init_one(&src, input_vec, ilen); 1995d7db7a88SGiovanni Cabiddu sg_init_one(&dst, output, dlen); 1996d7db7a88SGiovanni Cabiddu 1997d7db7a88SGiovanni Cabiddu req = acomp_request_alloc(tfm); 1998d7db7a88SGiovanni Cabiddu if (!req) { 1999d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: request alloc failed for %s\n", 2000d7db7a88SGiovanni Cabiddu algo); 200102608e02SLaura Abbott kfree(input_vec); 2002d7db7a88SGiovanni Cabiddu ret = -ENOMEM; 2003d7db7a88SGiovanni Cabiddu goto out; 2004d7db7a88SGiovanni Cabiddu } 2005d7db7a88SGiovanni Cabiddu 2006d7db7a88SGiovanni Cabiddu acomp_request_set_params(req, &src, &dst, ilen, dlen); 2007d7db7a88SGiovanni Cabiddu acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 20087f397136SGilad Ben-Yossef crypto_req_done, &wait); 2009d7db7a88SGiovanni Cabiddu 20107f397136SGilad Ben-Yossef ret = crypto_wait_req(crypto_acomp_decompress(req), &wait); 2011d7db7a88SGiovanni Cabiddu if (ret) { 2012d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: decompression failed on test %d for %s: ret=%d\n", 2013d7db7a88SGiovanni Cabiddu i + 1, algo, -ret); 201402608e02SLaura Abbott kfree(input_vec); 2015d7db7a88SGiovanni Cabiddu acomp_request_free(req); 2016d7db7a88SGiovanni Cabiddu goto out; 2017d7db7a88SGiovanni Cabiddu } 2018d7db7a88SGiovanni Cabiddu 2019d7db7a88SGiovanni Cabiddu if (req->dlen != dtemplate[i].outlen) { 2020d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Decompression test %d failed for %s: output len = %d\n", 2021d7db7a88SGiovanni Cabiddu i + 1, algo, req->dlen); 2022d7db7a88SGiovanni Cabiddu ret = -EINVAL; 202302608e02SLaura Abbott kfree(input_vec); 2024d7db7a88SGiovanni Cabiddu acomp_request_free(req); 2025d7db7a88SGiovanni Cabiddu goto out; 2026d7db7a88SGiovanni Cabiddu } 2027d7db7a88SGiovanni Cabiddu 2028d7db7a88SGiovanni Cabiddu if (memcmp(output, dtemplate[i].output, req->dlen)) { 2029d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Decompression test %d failed for %s\n", 2030d7db7a88SGiovanni Cabiddu i + 1, algo); 2031d7db7a88SGiovanni Cabiddu hexdump(output, req->dlen); 2032d7db7a88SGiovanni Cabiddu ret = -EINVAL; 203302608e02SLaura Abbott kfree(input_vec); 2034d7db7a88SGiovanni Cabiddu acomp_request_free(req); 2035d7db7a88SGiovanni Cabiddu goto out; 2036d7db7a88SGiovanni Cabiddu } 2037d7db7a88SGiovanni Cabiddu 203802608e02SLaura Abbott kfree(input_vec); 2039d7db7a88SGiovanni Cabiddu acomp_request_free(req); 2040d7db7a88SGiovanni Cabiddu } 2041d7db7a88SGiovanni Cabiddu 2042d7db7a88SGiovanni Cabiddu ret = 0; 2043d7db7a88SGiovanni Cabiddu 2044d7db7a88SGiovanni Cabiddu out: 2045a9943a0aSGiovanni Cabiddu kfree(decomp_out); 2046eb095593SEric Biggers kfree(output); 2047d7db7a88SGiovanni Cabiddu return ret; 2048d7db7a88SGiovanni Cabiddu } 2049d7db7a88SGiovanni Cabiddu 2050b13b1e0cSEric Biggers static int test_cprng(struct crypto_rng *tfm, 2051b13b1e0cSEric Biggers const struct cprng_testvec *template, 20527647d6ceSJarod Wilson unsigned int tcount) 20537647d6ceSJarod Wilson { 20547647d6ceSJarod Wilson const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm)); 2055fa4ef8a6SFelipe Contreras int err = 0, i, j, seedsize; 20567647d6ceSJarod Wilson u8 *seed; 20577647d6ceSJarod Wilson char result[32]; 20587647d6ceSJarod Wilson 20597647d6ceSJarod Wilson seedsize = crypto_rng_seedsize(tfm); 20607647d6ceSJarod Wilson 20617647d6ceSJarod Wilson seed = kmalloc(seedsize, GFP_KERNEL); 20627647d6ceSJarod Wilson if (!seed) { 20637647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to allocate seed space " 20647647d6ceSJarod Wilson "for %s\n", algo); 20657647d6ceSJarod Wilson return -ENOMEM; 20667647d6ceSJarod Wilson } 20677647d6ceSJarod Wilson 20687647d6ceSJarod Wilson for (i = 0; i < tcount; i++) { 20697647d6ceSJarod Wilson memset(result, 0, 32); 20707647d6ceSJarod Wilson 20717647d6ceSJarod Wilson memcpy(seed, template[i].v, template[i].vlen); 20727647d6ceSJarod Wilson memcpy(seed + template[i].vlen, template[i].key, 20737647d6ceSJarod Wilson template[i].klen); 20747647d6ceSJarod Wilson memcpy(seed + template[i].vlen + template[i].klen, 20757647d6ceSJarod Wilson template[i].dt, template[i].dtlen); 20767647d6ceSJarod Wilson 20777647d6ceSJarod Wilson err = crypto_rng_reset(tfm, seed, seedsize); 20787647d6ceSJarod Wilson if (err) { 20797647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to reset rng " 20807647d6ceSJarod Wilson "for %s\n", algo); 20817647d6ceSJarod Wilson goto out; 20827647d6ceSJarod Wilson } 20837647d6ceSJarod Wilson 20847647d6ceSJarod Wilson for (j = 0; j < template[i].loops; j++) { 20857647d6ceSJarod Wilson err = crypto_rng_get_bytes(tfm, result, 20867647d6ceSJarod Wilson template[i].rlen); 208719e60e13SStephan Mueller if (err < 0) { 20887647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to obtain " 20897647d6ceSJarod Wilson "the correct amount of random data for " 209019e60e13SStephan Mueller "%s (requested %d)\n", algo, 209119e60e13SStephan Mueller template[i].rlen); 20927647d6ceSJarod Wilson goto out; 20937647d6ceSJarod Wilson } 20947647d6ceSJarod Wilson } 20957647d6ceSJarod Wilson 20967647d6ceSJarod Wilson err = memcmp(result, template[i].result, 20977647d6ceSJarod Wilson template[i].rlen); 20987647d6ceSJarod Wilson if (err) { 20997647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Test %d failed for %s\n", 21007647d6ceSJarod Wilson i, algo); 21017647d6ceSJarod Wilson hexdump(result, template[i].rlen); 21027647d6ceSJarod Wilson err = -EINVAL; 21037647d6ceSJarod Wilson goto out; 21047647d6ceSJarod Wilson } 21057647d6ceSJarod Wilson } 21067647d6ceSJarod Wilson 21077647d6ceSJarod Wilson out: 21087647d6ceSJarod Wilson kfree(seed); 21097647d6ceSJarod Wilson return err; 21107647d6ceSJarod Wilson } 21117647d6ceSJarod Wilson 2112da7f033dSHerbert Xu static int alg_test_cipher(const struct alg_test_desc *desc, 2113da7f033dSHerbert Xu const char *driver, u32 type, u32 mask) 2114da7f033dSHerbert Xu { 211592a4c9feSEric Biggers const struct cipher_test_suite *suite = &desc->suite.cipher; 21161aa4ecd9SHerbert Xu struct crypto_cipher *tfm; 211792a4c9feSEric Biggers int err; 2118da7f033dSHerbert Xu 2119eed93e0cSHerbert Xu tfm = crypto_alloc_cipher(driver, type, mask); 2120da7f033dSHerbert Xu if (IS_ERR(tfm)) { 2121da7f033dSHerbert Xu printk(KERN_ERR "alg: cipher: Failed to load transform for " 2122da7f033dSHerbert Xu "%s: %ld\n", driver, PTR_ERR(tfm)); 2123da7f033dSHerbert Xu return PTR_ERR(tfm); 2124da7f033dSHerbert Xu } 2125da7f033dSHerbert Xu 212692a4c9feSEric Biggers err = test_cipher(tfm, ENCRYPT, suite->vecs, suite->count); 212792a4c9feSEric Biggers if (!err) 212892a4c9feSEric Biggers err = test_cipher(tfm, DECRYPT, suite->vecs, suite->count); 2129da7f033dSHerbert Xu 21301aa4ecd9SHerbert Xu crypto_free_cipher(tfm); 21311aa4ecd9SHerbert Xu return err; 21321aa4ecd9SHerbert Xu } 21331aa4ecd9SHerbert Xu 2134da7f033dSHerbert Xu static int alg_test_comp(const struct alg_test_desc *desc, const char *driver, 2135da7f033dSHerbert Xu u32 type, u32 mask) 2136da7f033dSHerbert Xu { 2137d7db7a88SGiovanni Cabiddu struct crypto_comp *comp; 2138d7db7a88SGiovanni Cabiddu struct crypto_acomp *acomp; 2139da7f033dSHerbert Xu int err; 2140d7db7a88SGiovanni Cabiddu u32 algo_type = type & CRYPTO_ALG_TYPE_ACOMPRESS_MASK; 2141da7f033dSHerbert Xu 2142d7db7a88SGiovanni Cabiddu if (algo_type == CRYPTO_ALG_TYPE_ACOMPRESS) { 2143d7db7a88SGiovanni Cabiddu acomp = crypto_alloc_acomp(driver, type, mask); 2144d7db7a88SGiovanni Cabiddu if (IS_ERR(acomp)) { 2145d7db7a88SGiovanni Cabiddu pr_err("alg: acomp: Failed to load transform for %s: %ld\n", 2146d7db7a88SGiovanni Cabiddu driver, PTR_ERR(acomp)); 2147d7db7a88SGiovanni Cabiddu return PTR_ERR(acomp); 2148d7db7a88SGiovanni Cabiddu } 2149d7db7a88SGiovanni Cabiddu err = test_acomp(acomp, desc->suite.comp.comp.vecs, 2150d7db7a88SGiovanni Cabiddu desc->suite.comp.decomp.vecs, 2151d7db7a88SGiovanni Cabiddu desc->suite.comp.comp.count, 2152d7db7a88SGiovanni Cabiddu desc->suite.comp.decomp.count); 2153d7db7a88SGiovanni Cabiddu crypto_free_acomp(acomp); 2154d7db7a88SGiovanni Cabiddu } else { 2155d7db7a88SGiovanni Cabiddu comp = crypto_alloc_comp(driver, type, mask); 2156d7db7a88SGiovanni Cabiddu if (IS_ERR(comp)) { 2157d7db7a88SGiovanni Cabiddu pr_err("alg: comp: Failed to load transform for %s: %ld\n", 2158d7db7a88SGiovanni Cabiddu driver, PTR_ERR(comp)); 2159d7db7a88SGiovanni Cabiddu return PTR_ERR(comp); 2160da7f033dSHerbert Xu } 2161da7f033dSHerbert Xu 2162d7db7a88SGiovanni Cabiddu err = test_comp(comp, desc->suite.comp.comp.vecs, 2163da7f033dSHerbert Xu desc->suite.comp.decomp.vecs, 2164da7f033dSHerbert Xu desc->suite.comp.comp.count, 2165da7f033dSHerbert Xu desc->suite.comp.decomp.count); 2166da7f033dSHerbert Xu 2167d7db7a88SGiovanni Cabiddu crypto_free_comp(comp); 2168d7db7a88SGiovanni Cabiddu } 2169da7f033dSHerbert Xu return err; 2170da7f033dSHerbert Xu } 2171da7f033dSHerbert Xu 21728e3ee85eSHerbert Xu static int alg_test_crc32c(const struct alg_test_desc *desc, 21738e3ee85eSHerbert Xu const char *driver, u32 type, u32 mask) 21748e3ee85eSHerbert Xu { 21758e3ee85eSHerbert Xu struct crypto_shash *tfm; 2176cb9dde88SEric Biggers __le32 val; 21778e3ee85eSHerbert Xu int err; 21788e3ee85eSHerbert Xu 21798e3ee85eSHerbert Xu err = alg_test_hash(desc, driver, type, mask); 21808e3ee85eSHerbert Xu if (err) 2181eb5e6730SEric Biggers return err; 21828e3ee85eSHerbert Xu 2183eed93e0cSHerbert Xu tfm = crypto_alloc_shash(driver, type, mask); 21848e3ee85eSHerbert Xu if (IS_ERR(tfm)) { 2185eb5e6730SEric Biggers if (PTR_ERR(tfm) == -ENOENT) { 2186eb5e6730SEric Biggers /* 2187eb5e6730SEric Biggers * This crc32c implementation is only available through 2188eb5e6730SEric Biggers * ahash API, not the shash API, so the remaining part 2189eb5e6730SEric Biggers * of the test is not applicable to it. 2190eb5e6730SEric Biggers */ 2191eb5e6730SEric Biggers return 0; 2192eb5e6730SEric Biggers } 21938e3ee85eSHerbert Xu printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: " 21948e3ee85eSHerbert Xu "%ld\n", driver, PTR_ERR(tfm)); 2195eb5e6730SEric Biggers return PTR_ERR(tfm); 21968e3ee85eSHerbert Xu } 21978e3ee85eSHerbert Xu 21988e3ee85eSHerbert Xu do { 21994c5c3024SJan-Simon Möller SHASH_DESC_ON_STACK(shash, tfm); 22004c5c3024SJan-Simon Möller u32 *ctx = (u32 *)shash_desc_ctx(shash); 22018e3ee85eSHerbert Xu 22024c5c3024SJan-Simon Möller shash->tfm = tfm; 22034c5c3024SJan-Simon Möller shash->flags = 0; 22048e3ee85eSHerbert Xu 2205cb9dde88SEric Biggers *ctx = 420553207; 22064c5c3024SJan-Simon Möller err = crypto_shash_final(shash, (u8 *)&val); 22078e3ee85eSHerbert Xu if (err) { 22088e3ee85eSHerbert Xu printk(KERN_ERR "alg: crc32c: Operation failed for " 22098e3ee85eSHerbert Xu "%s: %d\n", driver, err); 22108e3ee85eSHerbert Xu break; 22118e3ee85eSHerbert Xu } 22128e3ee85eSHerbert Xu 2213cb9dde88SEric Biggers if (val != cpu_to_le32(~420553207)) { 2214cb9dde88SEric Biggers pr_err("alg: crc32c: Test failed for %s: %u\n", 2215cb9dde88SEric Biggers driver, le32_to_cpu(val)); 22168e3ee85eSHerbert Xu err = -EINVAL; 22178e3ee85eSHerbert Xu } 22188e3ee85eSHerbert Xu } while (0); 22198e3ee85eSHerbert Xu 22208e3ee85eSHerbert Xu crypto_free_shash(tfm); 22218e3ee85eSHerbert Xu 22228e3ee85eSHerbert Xu return err; 22238e3ee85eSHerbert Xu } 22248e3ee85eSHerbert Xu 22257647d6ceSJarod Wilson static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver, 22267647d6ceSJarod Wilson u32 type, u32 mask) 22277647d6ceSJarod Wilson { 22287647d6ceSJarod Wilson struct crypto_rng *rng; 22297647d6ceSJarod Wilson int err; 22307647d6ceSJarod Wilson 2231eed93e0cSHerbert Xu rng = crypto_alloc_rng(driver, type, mask); 22327647d6ceSJarod Wilson if (IS_ERR(rng)) { 22337647d6ceSJarod Wilson printk(KERN_ERR "alg: cprng: Failed to load transform for %s: " 22347647d6ceSJarod Wilson "%ld\n", driver, PTR_ERR(rng)); 22357647d6ceSJarod Wilson return PTR_ERR(rng); 22367647d6ceSJarod Wilson } 22377647d6ceSJarod Wilson 22387647d6ceSJarod Wilson err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count); 22397647d6ceSJarod Wilson 22407647d6ceSJarod Wilson crypto_free_rng(rng); 22417647d6ceSJarod Wilson 22427647d6ceSJarod Wilson return err; 22437647d6ceSJarod Wilson } 22447647d6ceSJarod Wilson 224564d1cdfbSStephan Mueller 2246b13b1e0cSEric Biggers static int drbg_cavs_test(const struct drbg_testvec *test, int pr, 224764d1cdfbSStephan Mueller const char *driver, u32 type, u32 mask) 224864d1cdfbSStephan Mueller { 224964d1cdfbSStephan Mueller int ret = -EAGAIN; 225064d1cdfbSStephan Mueller struct crypto_rng *drng; 225164d1cdfbSStephan Mueller struct drbg_test_data test_data; 225264d1cdfbSStephan Mueller struct drbg_string addtl, pers, testentropy; 225364d1cdfbSStephan Mueller unsigned char *buf = kzalloc(test->expectedlen, GFP_KERNEL); 225464d1cdfbSStephan Mueller 225564d1cdfbSStephan Mueller if (!buf) 225664d1cdfbSStephan Mueller return -ENOMEM; 225764d1cdfbSStephan Mueller 2258eed93e0cSHerbert Xu drng = crypto_alloc_rng(driver, type, mask); 225964d1cdfbSStephan Mueller if (IS_ERR(drng)) { 226064d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: could not allocate DRNG handle for " 226164d1cdfbSStephan Mueller "%s\n", driver); 226264d1cdfbSStephan Mueller kzfree(buf); 226364d1cdfbSStephan Mueller return -ENOMEM; 226464d1cdfbSStephan Mueller } 226564d1cdfbSStephan Mueller 226664d1cdfbSStephan Mueller test_data.testentropy = &testentropy; 226764d1cdfbSStephan Mueller drbg_string_fill(&testentropy, test->entropy, test->entropylen); 226864d1cdfbSStephan Mueller drbg_string_fill(&pers, test->pers, test->perslen); 226964d1cdfbSStephan Mueller ret = crypto_drbg_reset_test(drng, &pers, &test_data); 227064d1cdfbSStephan Mueller if (ret) { 227164d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: Failed to reset rng\n"); 227264d1cdfbSStephan Mueller goto outbuf; 227364d1cdfbSStephan Mueller } 227464d1cdfbSStephan Mueller 227564d1cdfbSStephan Mueller drbg_string_fill(&addtl, test->addtla, test->addtllen); 227664d1cdfbSStephan Mueller if (pr) { 227764d1cdfbSStephan Mueller drbg_string_fill(&testentropy, test->entpra, test->entprlen); 227864d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl_test(drng, 227964d1cdfbSStephan Mueller buf, test->expectedlen, &addtl, &test_data); 228064d1cdfbSStephan Mueller } else { 228164d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl(drng, 228264d1cdfbSStephan Mueller buf, test->expectedlen, &addtl); 228364d1cdfbSStephan Mueller } 228419e60e13SStephan Mueller if (ret < 0) { 228564d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: could not obtain random data for " 228664d1cdfbSStephan Mueller "driver %s\n", driver); 228764d1cdfbSStephan Mueller goto outbuf; 228864d1cdfbSStephan Mueller } 228964d1cdfbSStephan Mueller 229064d1cdfbSStephan Mueller drbg_string_fill(&addtl, test->addtlb, test->addtllen); 229164d1cdfbSStephan Mueller if (pr) { 229264d1cdfbSStephan Mueller drbg_string_fill(&testentropy, test->entprb, test->entprlen); 229364d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl_test(drng, 229464d1cdfbSStephan Mueller buf, test->expectedlen, &addtl, &test_data); 229564d1cdfbSStephan Mueller } else { 229664d1cdfbSStephan Mueller ret = crypto_drbg_get_bytes_addtl(drng, 229764d1cdfbSStephan Mueller buf, test->expectedlen, &addtl); 229864d1cdfbSStephan Mueller } 229919e60e13SStephan Mueller if (ret < 0) { 230064d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: could not obtain random data for " 230164d1cdfbSStephan Mueller "driver %s\n", driver); 230264d1cdfbSStephan Mueller goto outbuf; 230364d1cdfbSStephan Mueller } 230464d1cdfbSStephan Mueller 230564d1cdfbSStephan Mueller ret = memcmp(test->expected, buf, test->expectedlen); 230664d1cdfbSStephan Mueller 230764d1cdfbSStephan Mueller outbuf: 230864d1cdfbSStephan Mueller crypto_free_rng(drng); 230964d1cdfbSStephan Mueller kzfree(buf); 231064d1cdfbSStephan Mueller return ret; 231164d1cdfbSStephan Mueller } 231264d1cdfbSStephan Mueller 231364d1cdfbSStephan Mueller 231464d1cdfbSStephan Mueller static int alg_test_drbg(const struct alg_test_desc *desc, const char *driver, 231564d1cdfbSStephan Mueller u32 type, u32 mask) 231664d1cdfbSStephan Mueller { 231764d1cdfbSStephan Mueller int err = 0; 231864d1cdfbSStephan Mueller int pr = 0; 231964d1cdfbSStephan Mueller int i = 0; 2320b13b1e0cSEric Biggers const struct drbg_testvec *template = desc->suite.drbg.vecs; 232164d1cdfbSStephan Mueller unsigned int tcount = desc->suite.drbg.count; 232264d1cdfbSStephan Mueller 232364d1cdfbSStephan Mueller if (0 == memcmp(driver, "drbg_pr_", 8)) 232464d1cdfbSStephan Mueller pr = 1; 232564d1cdfbSStephan Mueller 232664d1cdfbSStephan Mueller for (i = 0; i < tcount; i++) { 232764d1cdfbSStephan Mueller err = drbg_cavs_test(&template[i], pr, driver, type, mask); 232864d1cdfbSStephan Mueller if (err) { 232964d1cdfbSStephan Mueller printk(KERN_ERR "alg: drbg: Test %d failed for %s\n", 233064d1cdfbSStephan Mueller i, driver); 233164d1cdfbSStephan Mueller err = -EINVAL; 233264d1cdfbSStephan Mueller break; 233364d1cdfbSStephan Mueller } 233464d1cdfbSStephan Mueller } 233564d1cdfbSStephan Mueller return err; 233664d1cdfbSStephan Mueller 233764d1cdfbSStephan Mueller } 233864d1cdfbSStephan Mueller 2339b13b1e0cSEric Biggers static int do_test_kpp(struct crypto_kpp *tfm, const struct kpp_testvec *vec, 2340802c7f1cSSalvatore Benedetto const char *alg) 2341802c7f1cSSalvatore Benedetto { 2342802c7f1cSSalvatore Benedetto struct kpp_request *req; 2343802c7f1cSSalvatore Benedetto void *input_buf = NULL; 2344802c7f1cSSalvatore Benedetto void *output_buf = NULL; 234547d3fd39STudor-Dan Ambarus void *a_public = NULL; 234647d3fd39STudor-Dan Ambarus void *a_ss = NULL; 234747d3fd39STudor-Dan Ambarus void *shared_secret = NULL; 23487f397136SGilad Ben-Yossef struct crypto_wait wait; 2349802c7f1cSSalvatore Benedetto unsigned int out_len_max; 2350802c7f1cSSalvatore Benedetto int err = -ENOMEM; 2351802c7f1cSSalvatore Benedetto struct scatterlist src, dst; 2352802c7f1cSSalvatore Benedetto 2353802c7f1cSSalvatore Benedetto req = kpp_request_alloc(tfm, GFP_KERNEL); 2354802c7f1cSSalvatore Benedetto if (!req) 2355802c7f1cSSalvatore Benedetto return err; 2356802c7f1cSSalvatore Benedetto 23577f397136SGilad Ben-Yossef crypto_init_wait(&wait); 2358802c7f1cSSalvatore Benedetto 2359802c7f1cSSalvatore Benedetto err = crypto_kpp_set_secret(tfm, vec->secret, vec->secret_size); 2360802c7f1cSSalvatore Benedetto if (err < 0) 2361802c7f1cSSalvatore Benedetto goto free_req; 2362802c7f1cSSalvatore Benedetto 2363802c7f1cSSalvatore Benedetto out_len_max = crypto_kpp_maxsize(tfm); 2364802c7f1cSSalvatore Benedetto output_buf = kzalloc(out_len_max, GFP_KERNEL); 2365802c7f1cSSalvatore Benedetto if (!output_buf) { 2366802c7f1cSSalvatore Benedetto err = -ENOMEM; 2367802c7f1cSSalvatore Benedetto goto free_req; 2368802c7f1cSSalvatore Benedetto } 2369802c7f1cSSalvatore Benedetto 2370802c7f1cSSalvatore Benedetto /* Use appropriate parameter as base */ 2371802c7f1cSSalvatore Benedetto kpp_request_set_input(req, NULL, 0); 2372802c7f1cSSalvatore Benedetto sg_init_one(&dst, output_buf, out_len_max); 2373802c7f1cSSalvatore Benedetto kpp_request_set_output(req, &dst, out_len_max); 2374802c7f1cSSalvatore Benedetto kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 23757f397136SGilad Ben-Yossef crypto_req_done, &wait); 2376802c7f1cSSalvatore Benedetto 237747d3fd39STudor-Dan Ambarus /* Compute party A's public key */ 23787f397136SGilad Ben-Yossef err = crypto_wait_req(crypto_kpp_generate_public_key(req), &wait); 2379802c7f1cSSalvatore Benedetto if (err) { 238047d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party A: generate public key test failed. err %d\n", 2381802c7f1cSSalvatore Benedetto alg, err); 2382802c7f1cSSalvatore Benedetto goto free_output; 2383802c7f1cSSalvatore Benedetto } 238447d3fd39STudor-Dan Ambarus 238547d3fd39STudor-Dan Ambarus if (vec->genkey) { 238647d3fd39STudor-Dan Ambarus /* Save party A's public key */ 2387e3d90e52SChristopher Diaz Riveros a_public = kmemdup(sg_virt(req->dst), out_len_max, GFP_KERNEL); 238847d3fd39STudor-Dan Ambarus if (!a_public) { 238947d3fd39STudor-Dan Ambarus err = -ENOMEM; 239047d3fd39STudor-Dan Ambarus goto free_output; 239147d3fd39STudor-Dan Ambarus } 239247d3fd39STudor-Dan Ambarus } else { 2393802c7f1cSSalvatore Benedetto /* Verify calculated public key */ 2394802c7f1cSSalvatore Benedetto if (memcmp(vec->expected_a_public, sg_virt(req->dst), 2395802c7f1cSSalvatore Benedetto vec->expected_a_public_size)) { 239647d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party A: generate public key test failed. Invalid output\n", 2397802c7f1cSSalvatore Benedetto alg); 2398802c7f1cSSalvatore Benedetto err = -EINVAL; 2399802c7f1cSSalvatore Benedetto goto free_output; 2400802c7f1cSSalvatore Benedetto } 240147d3fd39STudor-Dan Ambarus } 2402802c7f1cSSalvatore Benedetto 2403802c7f1cSSalvatore Benedetto /* Calculate shared secret key by using counter part (b) public key. */ 2404e3d90e52SChristopher Diaz Riveros input_buf = kmemdup(vec->b_public, vec->b_public_size, GFP_KERNEL); 2405802c7f1cSSalvatore Benedetto if (!input_buf) { 2406802c7f1cSSalvatore Benedetto err = -ENOMEM; 2407802c7f1cSSalvatore Benedetto goto free_output; 2408802c7f1cSSalvatore Benedetto } 2409802c7f1cSSalvatore Benedetto 2410802c7f1cSSalvatore Benedetto sg_init_one(&src, input_buf, vec->b_public_size); 2411802c7f1cSSalvatore Benedetto sg_init_one(&dst, output_buf, out_len_max); 2412802c7f1cSSalvatore Benedetto kpp_request_set_input(req, &src, vec->b_public_size); 2413802c7f1cSSalvatore Benedetto kpp_request_set_output(req, &dst, out_len_max); 2414802c7f1cSSalvatore Benedetto kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 24157f397136SGilad Ben-Yossef crypto_req_done, &wait); 24167f397136SGilad Ben-Yossef err = crypto_wait_req(crypto_kpp_compute_shared_secret(req), &wait); 2417802c7f1cSSalvatore Benedetto if (err) { 241847d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party A: compute shared secret test failed. err %d\n", 2419802c7f1cSSalvatore Benedetto alg, err); 2420802c7f1cSSalvatore Benedetto goto free_all; 2421802c7f1cSSalvatore Benedetto } 242247d3fd39STudor-Dan Ambarus 242347d3fd39STudor-Dan Ambarus if (vec->genkey) { 242447d3fd39STudor-Dan Ambarus /* Save the shared secret obtained by party A */ 2425e3d90e52SChristopher Diaz Riveros a_ss = kmemdup(sg_virt(req->dst), vec->expected_ss_size, GFP_KERNEL); 242647d3fd39STudor-Dan Ambarus if (!a_ss) { 242747d3fd39STudor-Dan Ambarus err = -ENOMEM; 242847d3fd39STudor-Dan Ambarus goto free_all; 242947d3fd39STudor-Dan Ambarus } 243047d3fd39STudor-Dan Ambarus 243147d3fd39STudor-Dan Ambarus /* 243247d3fd39STudor-Dan Ambarus * Calculate party B's shared secret by using party A's 243347d3fd39STudor-Dan Ambarus * public key. 243447d3fd39STudor-Dan Ambarus */ 243547d3fd39STudor-Dan Ambarus err = crypto_kpp_set_secret(tfm, vec->b_secret, 243647d3fd39STudor-Dan Ambarus vec->b_secret_size); 243747d3fd39STudor-Dan Ambarus if (err < 0) 243847d3fd39STudor-Dan Ambarus goto free_all; 243947d3fd39STudor-Dan Ambarus 244047d3fd39STudor-Dan Ambarus sg_init_one(&src, a_public, vec->expected_a_public_size); 244147d3fd39STudor-Dan Ambarus sg_init_one(&dst, output_buf, out_len_max); 244247d3fd39STudor-Dan Ambarus kpp_request_set_input(req, &src, vec->expected_a_public_size); 244347d3fd39STudor-Dan Ambarus kpp_request_set_output(req, &dst, out_len_max); 244447d3fd39STudor-Dan Ambarus kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 24457f397136SGilad Ben-Yossef crypto_req_done, &wait); 24467f397136SGilad Ben-Yossef err = crypto_wait_req(crypto_kpp_compute_shared_secret(req), 24477f397136SGilad Ben-Yossef &wait); 244847d3fd39STudor-Dan Ambarus if (err) { 244947d3fd39STudor-Dan Ambarus pr_err("alg: %s: Party B: compute shared secret failed. err %d\n", 245047d3fd39STudor-Dan Ambarus alg, err); 245147d3fd39STudor-Dan Ambarus goto free_all; 245247d3fd39STudor-Dan Ambarus } 245347d3fd39STudor-Dan Ambarus 245447d3fd39STudor-Dan Ambarus shared_secret = a_ss; 245547d3fd39STudor-Dan Ambarus } else { 245647d3fd39STudor-Dan Ambarus shared_secret = (void *)vec->expected_ss; 245747d3fd39STudor-Dan Ambarus } 245847d3fd39STudor-Dan Ambarus 2459802c7f1cSSalvatore Benedetto /* 2460802c7f1cSSalvatore Benedetto * verify shared secret from which the user will derive 2461802c7f1cSSalvatore Benedetto * secret key by executing whatever hash it has chosen 2462802c7f1cSSalvatore Benedetto */ 246347d3fd39STudor-Dan Ambarus if (memcmp(shared_secret, sg_virt(req->dst), 2464802c7f1cSSalvatore Benedetto vec->expected_ss_size)) { 2465802c7f1cSSalvatore Benedetto pr_err("alg: %s: compute shared secret test failed. Invalid output\n", 2466802c7f1cSSalvatore Benedetto alg); 2467802c7f1cSSalvatore Benedetto err = -EINVAL; 2468802c7f1cSSalvatore Benedetto } 2469802c7f1cSSalvatore Benedetto 2470802c7f1cSSalvatore Benedetto free_all: 247147d3fd39STudor-Dan Ambarus kfree(a_ss); 2472802c7f1cSSalvatore Benedetto kfree(input_buf); 2473802c7f1cSSalvatore Benedetto free_output: 247447d3fd39STudor-Dan Ambarus kfree(a_public); 2475802c7f1cSSalvatore Benedetto kfree(output_buf); 2476802c7f1cSSalvatore Benedetto free_req: 2477802c7f1cSSalvatore Benedetto kpp_request_free(req); 2478802c7f1cSSalvatore Benedetto return err; 2479802c7f1cSSalvatore Benedetto } 2480802c7f1cSSalvatore Benedetto 2481802c7f1cSSalvatore Benedetto static int test_kpp(struct crypto_kpp *tfm, const char *alg, 2482b13b1e0cSEric Biggers const struct kpp_testvec *vecs, unsigned int tcount) 2483802c7f1cSSalvatore Benedetto { 2484802c7f1cSSalvatore Benedetto int ret, i; 2485802c7f1cSSalvatore Benedetto 2486802c7f1cSSalvatore Benedetto for (i = 0; i < tcount; i++) { 2487802c7f1cSSalvatore Benedetto ret = do_test_kpp(tfm, vecs++, alg); 2488802c7f1cSSalvatore Benedetto if (ret) { 2489802c7f1cSSalvatore Benedetto pr_err("alg: %s: test failed on vector %d, err=%d\n", 2490802c7f1cSSalvatore Benedetto alg, i + 1, ret); 2491802c7f1cSSalvatore Benedetto return ret; 2492802c7f1cSSalvatore Benedetto } 2493802c7f1cSSalvatore Benedetto } 2494802c7f1cSSalvatore Benedetto return 0; 2495802c7f1cSSalvatore Benedetto } 2496802c7f1cSSalvatore Benedetto 2497802c7f1cSSalvatore Benedetto static int alg_test_kpp(const struct alg_test_desc *desc, const char *driver, 2498802c7f1cSSalvatore Benedetto u32 type, u32 mask) 2499802c7f1cSSalvatore Benedetto { 2500802c7f1cSSalvatore Benedetto struct crypto_kpp *tfm; 2501802c7f1cSSalvatore Benedetto int err = 0; 2502802c7f1cSSalvatore Benedetto 2503eed93e0cSHerbert Xu tfm = crypto_alloc_kpp(driver, type, mask); 2504802c7f1cSSalvatore Benedetto if (IS_ERR(tfm)) { 2505802c7f1cSSalvatore Benedetto pr_err("alg: kpp: Failed to load tfm for %s: %ld\n", 2506802c7f1cSSalvatore Benedetto driver, PTR_ERR(tfm)); 2507802c7f1cSSalvatore Benedetto return PTR_ERR(tfm); 2508802c7f1cSSalvatore Benedetto } 2509802c7f1cSSalvatore Benedetto if (desc->suite.kpp.vecs) 2510802c7f1cSSalvatore Benedetto err = test_kpp(tfm, desc->alg, desc->suite.kpp.vecs, 2511802c7f1cSSalvatore Benedetto desc->suite.kpp.count); 2512802c7f1cSSalvatore Benedetto 2513802c7f1cSSalvatore Benedetto crypto_free_kpp(tfm); 2514802c7f1cSSalvatore Benedetto return err; 2515802c7f1cSSalvatore Benedetto } 2516802c7f1cSSalvatore Benedetto 251750d2b643SHerbert Xu static int test_akcipher_one(struct crypto_akcipher *tfm, 2518b13b1e0cSEric Biggers const struct akcipher_testvec *vecs) 2519946cc463STadeusz Struk { 2520df27b26fSHerbert Xu char *xbuf[XBUFSIZE]; 2521946cc463STadeusz Struk struct akcipher_request *req; 2522946cc463STadeusz Struk void *outbuf_enc = NULL; 2523946cc463STadeusz Struk void *outbuf_dec = NULL; 25247f397136SGilad Ben-Yossef struct crypto_wait wait; 2525946cc463STadeusz Struk unsigned int out_len_max, out_len = 0; 2526946cc463STadeusz Struk int err = -ENOMEM; 252722287b0bSTadeusz Struk struct scatterlist src, dst, src_tab[2]; 25280507de94SVitaly Chikunov const char *m, *c; 25290507de94SVitaly Chikunov unsigned int m_size, c_size; 25300507de94SVitaly Chikunov const char *op; 2531946cc463STadeusz Struk 2532df27b26fSHerbert Xu if (testmgr_alloc_buf(xbuf)) 2533df27b26fSHerbert Xu return err; 2534df27b26fSHerbert Xu 2535946cc463STadeusz Struk req = akcipher_request_alloc(tfm, GFP_KERNEL); 2536946cc463STadeusz Struk if (!req) 2537df27b26fSHerbert Xu goto free_xbuf; 2538946cc463STadeusz Struk 25397f397136SGilad Ben-Yossef crypto_init_wait(&wait); 254022287b0bSTadeusz Struk 254122287b0bSTadeusz Struk if (vecs->public_key_vec) 254222287b0bSTadeusz Struk err = crypto_akcipher_set_pub_key(tfm, vecs->key, 254322287b0bSTadeusz Struk vecs->key_len); 254422287b0bSTadeusz Struk else 254522287b0bSTadeusz Struk err = crypto_akcipher_set_priv_key(tfm, vecs->key, 254622287b0bSTadeusz Struk vecs->key_len); 2547946cc463STadeusz Struk if (err) 2548946cc463STadeusz Struk goto free_req; 2549946cc463STadeusz Struk 255057763f5eSSalvatore Benedetto err = -ENOMEM; 255122287b0bSTadeusz Struk out_len_max = crypto_akcipher_maxsize(tfm); 25520507de94SVitaly Chikunov 25530507de94SVitaly Chikunov /* 25540507de94SVitaly Chikunov * First run test which do not require a private key, such as 25550507de94SVitaly Chikunov * encrypt or verify. 25560507de94SVitaly Chikunov */ 2557946cc463STadeusz Struk outbuf_enc = kzalloc(out_len_max, GFP_KERNEL); 2558946cc463STadeusz Struk if (!outbuf_enc) 2559946cc463STadeusz Struk goto free_req; 2560946cc463STadeusz Struk 25610507de94SVitaly Chikunov if (!vecs->siggen_sigver_test) { 25620507de94SVitaly Chikunov m = vecs->m; 25630507de94SVitaly Chikunov m_size = vecs->m_size; 25640507de94SVitaly Chikunov c = vecs->c; 25650507de94SVitaly Chikunov c_size = vecs->c_size; 25660507de94SVitaly Chikunov op = "encrypt"; 25670507de94SVitaly Chikunov } else { 25680507de94SVitaly Chikunov /* Swap args so we could keep plaintext (digest) 25690507de94SVitaly Chikunov * in vecs->m, and cooked signature in vecs->c. 25700507de94SVitaly Chikunov */ 25710507de94SVitaly Chikunov m = vecs->c; /* signature */ 25720507de94SVitaly Chikunov m_size = vecs->c_size; 25730507de94SVitaly Chikunov c = vecs->m; /* digest */ 25740507de94SVitaly Chikunov c_size = vecs->m_size; 25750507de94SVitaly Chikunov op = "verify"; 25760507de94SVitaly Chikunov } 2577df27b26fSHerbert Xu 25780507de94SVitaly Chikunov if (WARN_ON(m_size > PAGE_SIZE)) 25790507de94SVitaly Chikunov goto free_all; 25800507de94SVitaly Chikunov memcpy(xbuf[0], m, m_size); 2581df27b26fSHerbert Xu 258222287b0bSTadeusz Struk sg_init_table(src_tab, 2); 2583df27b26fSHerbert Xu sg_set_buf(&src_tab[0], xbuf[0], 8); 25840507de94SVitaly Chikunov sg_set_buf(&src_tab[1], xbuf[0] + 8, m_size - 8); 258522287b0bSTadeusz Struk sg_init_one(&dst, outbuf_enc, out_len_max); 25860507de94SVitaly Chikunov akcipher_request_set_crypt(req, src_tab, &dst, m_size, 258722287b0bSTadeusz Struk out_len_max); 2588946cc463STadeusz Struk akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 25897f397136SGilad Ben-Yossef crypto_req_done, &wait); 2590946cc463STadeusz Struk 25917f397136SGilad Ben-Yossef err = crypto_wait_req(vecs->siggen_sigver_test ? 25920507de94SVitaly Chikunov /* Run asymmetric signature verification */ 25930507de94SVitaly Chikunov crypto_akcipher_verify(req) : 25941207107cSStephan Mueller /* Run asymmetric encrypt */ 25957f397136SGilad Ben-Yossef crypto_akcipher_encrypt(req), &wait); 2596946cc463STadeusz Struk if (err) { 25970507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. err %d\n", op, err); 2598946cc463STadeusz Struk goto free_all; 2599946cc463STadeusz Struk } 26000507de94SVitaly Chikunov if (req->dst_len != c_size) { 26010507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output len\n", 26020507de94SVitaly Chikunov op); 2603946cc463STadeusz Struk err = -EINVAL; 2604946cc463STadeusz Struk goto free_all; 2605946cc463STadeusz Struk } 2606946cc463STadeusz Struk /* verify that encrypted message is equal to expected */ 26070507de94SVitaly Chikunov if (memcmp(c, outbuf_enc, c_size)) { 26080507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output\n", op); 26090507de94SVitaly Chikunov hexdump(outbuf_enc, c_size); 2610946cc463STadeusz Struk err = -EINVAL; 2611946cc463STadeusz Struk goto free_all; 2612946cc463STadeusz Struk } 26130507de94SVitaly Chikunov 26140507de94SVitaly Chikunov /* 26150507de94SVitaly Chikunov * Don't invoke (decrypt or sign) test which require a private key 26160507de94SVitaly Chikunov * for vectors with only a public key. 26170507de94SVitaly Chikunov */ 2618946cc463STadeusz Struk if (vecs->public_key_vec) { 2619946cc463STadeusz Struk err = 0; 2620946cc463STadeusz Struk goto free_all; 2621946cc463STadeusz Struk } 2622946cc463STadeusz Struk outbuf_dec = kzalloc(out_len_max, GFP_KERNEL); 2623946cc463STadeusz Struk if (!outbuf_dec) { 2624946cc463STadeusz Struk err = -ENOMEM; 2625946cc463STadeusz Struk goto free_all; 2626946cc463STadeusz Struk } 2627df27b26fSHerbert Xu 26280507de94SVitaly Chikunov op = vecs->siggen_sigver_test ? "sign" : "decrypt"; 26290507de94SVitaly Chikunov if (WARN_ON(c_size > PAGE_SIZE)) 2630df27b26fSHerbert Xu goto free_all; 26310507de94SVitaly Chikunov memcpy(xbuf[0], c, c_size); 2632df27b26fSHerbert Xu 26330507de94SVitaly Chikunov sg_init_one(&src, xbuf[0], c_size); 263422287b0bSTadeusz Struk sg_init_one(&dst, outbuf_dec, out_len_max); 26357f397136SGilad Ben-Yossef crypto_init_wait(&wait); 26360507de94SVitaly Chikunov akcipher_request_set_crypt(req, &src, &dst, c_size, out_len_max); 2637946cc463STadeusz Struk 26387f397136SGilad Ben-Yossef err = crypto_wait_req(vecs->siggen_sigver_test ? 26390507de94SVitaly Chikunov /* Run asymmetric signature generation */ 26400507de94SVitaly Chikunov crypto_akcipher_sign(req) : 26411207107cSStephan Mueller /* Run asymmetric decrypt */ 26427f397136SGilad Ben-Yossef crypto_akcipher_decrypt(req), &wait); 2643946cc463STadeusz Struk if (err) { 26440507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. err %d\n", op, err); 2645946cc463STadeusz Struk goto free_all; 2646946cc463STadeusz Struk } 2647946cc463STadeusz Struk out_len = req->dst_len; 26480507de94SVitaly Chikunov if (out_len < m_size) { 26490507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output len %u\n", 26500507de94SVitaly Chikunov op, out_len); 2651946cc463STadeusz Struk err = -EINVAL; 2652946cc463STadeusz Struk goto free_all; 2653946cc463STadeusz Struk } 2654946cc463STadeusz Struk /* verify that decrypted message is equal to the original msg */ 26550507de94SVitaly Chikunov if (memchr_inv(outbuf_dec, 0, out_len - m_size) || 26560507de94SVitaly Chikunov memcmp(m, outbuf_dec + out_len - m_size, m_size)) { 26570507de94SVitaly Chikunov pr_err("alg: akcipher: %s test failed. Invalid output\n", op); 265850d2b643SHerbert Xu hexdump(outbuf_dec, out_len); 2659946cc463STadeusz Struk err = -EINVAL; 2660946cc463STadeusz Struk } 2661946cc463STadeusz Struk free_all: 2662946cc463STadeusz Struk kfree(outbuf_dec); 2663946cc463STadeusz Struk kfree(outbuf_enc); 2664946cc463STadeusz Struk free_req: 2665946cc463STadeusz Struk akcipher_request_free(req); 2666df27b26fSHerbert Xu free_xbuf: 2667df27b26fSHerbert Xu testmgr_free_buf(xbuf); 2668946cc463STadeusz Struk return err; 2669946cc463STadeusz Struk } 2670946cc463STadeusz Struk 267150d2b643SHerbert Xu static int test_akcipher(struct crypto_akcipher *tfm, const char *alg, 2672b13b1e0cSEric Biggers const struct akcipher_testvec *vecs, 2673b13b1e0cSEric Biggers unsigned int tcount) 2674946cc463STadeusz Struk { 267515226e48SHerbert Xu const char *algo = 267615226e48SHerbert Xu crypto_tfm_alg_driver_name(crypto_akcipher_tfm(tfm)); 2677946cc463STadeusz Struk int ret, i; 2678946cc463STadeusz Struk 2679946cc463STadeusz Struk for (i = 0; i < tcount; i++) { 268050d2b643SHerbert Xu ret = test_akcipher_one(tfm, vecs++); 268150d2b643SHerbert Xu if (!ret) 268250d2b643SHerbert Xu continue; 268350d2b643SHerbert Xu 268415226e48SHerbert Xu pr_err("alg: akcipher: test %d failed for %s, err=%d\n", 268515226e48SHerbert Xu i + 1, algo, ret); 2686946cc463STadeusz Struk return ret; 2687946cc463STadeusz Struk } 2688946cc463STadeusz Struk return 0; 2689946cc463STadeusz Struk } 2690946cc463STadeusz Struk 2691946cc463STadeusz Struk static int alg_test_akcipher(const struct alg_test_desc *desc, 2692946cc463STadeusz Struk const char *driver, u32 type, u32 mask) 2693946cc463STadeusz Struk { 2694946cc463STadeusz Struk struct crypto_akcipher *tfm; 2695946cc463STadeusz Struk int err = 0; 2696946cc463STadeusz Struk 2697eed93e0cSHerbert Xu tfm = crypto_alloc_akcipher(driver, type, mask); 2698946cc463STadeusz Struk if (IS_ERR(tfm)) { 2699946cc463STadeusz Struk pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n", 2700946cc463STadeusz Struk driver, PTR_ERR(tfm)); 2701946cc463STadeusz Struk return PTR_ERR(tfm); 2702946cc463STadeusz Struk } 2703946cc463STadeusz Struk if (desc->suite.akcipher.vecs) 2704946cc463STadeusz Struk err = test_akcipher(tfm, desc->alg, desc->suite.akcipher.vecs, 2705946cc463STadeusz Struk desc->suite.akcipher.count); 2706946cc463STadeusz Struk 2707946cc463STadeusz Struk crypto_free_akcipher(tfm); 2708946cc463STadeusz Struk return err; 2709946cc463STadeusz Struk } 2710946cc463STadeusz Struk 2711863b557aSYouquan, Song static int alg_test_null(const struct alg_test_desc *desc, 2712863b557aSYouquan, Song const char *driver, u32 type, u32 mask) 2713863b557aSYouquan, Song { 2714863b557aSYouquan, Song return 0; 2715863b557aSYouquan, Song } 2716863b557aSYouquan, Song 271721c8e720SArd Biesheuvel #define __VECS(tv) { .vecs = tv, .count = ARRAY_SIZE(tv) } 271821c8e720SArd Biesheuvel 2719da7f033dSHerbert Xu /* Please keep this list sorted by algorithm name. */ 2720da7f033dSHerbert Xu static const struct alg_test_desc alg_test_descs[] = { 2721da7f033dSHerbert Xu { 2722059c2a4dSEric Biggers .alg = "adiantum(xchacha12,aes)", 2723059c2a4dSEric Biggers .test = alg_test_skcipher, 2724059c2a4dSEric Biggers .suite = { 2725059c2a4dSEric Biggers .cipher = __VECS(adiantum_xchacha12_aes_tv_template) 2726059c2a4dSEric Biggers }, 2727059c2a4dSEric Biggers }, { 2728059c2a4dSEric Biggers .alg = "adiantum(xchacha20,aes)", 2729059c2a4dSEric Biggers .test = alg_test_skcipher, 2730059c2a4dSEric Biggers .suite = { 2731059c2a4dSEric Biggers .cipher = __VECS(adiantum_xchacha20_aes_tv_template) 2732059c2a4dSEric Biggers }, 2733059c2a4dSEric Biggers }, { 2734b87dc203SOndrej Mosnacek .alg = "aegis128", 2735b87dc203SOndrej Mosnacek .test = alg_test_aead, 2736b87dc203SOndrej Mosnacek .suite = { 2737a0d608eeSEric Biggers .aead = __VECS(aegis128_tv_template) 2738b87dc203SOndrej Mosnacek } 2739b87dc203SOndrej Mosnacek }, { 2740b87dc203SOndrej Mosnacek .alg = "aegis128l", 2741b87dc203SOndrej Mosnacek .test = alg_test_aead, 2742b87dc203SOndrej Mosnacek .suite = { 2743a0d608eeSEric Biggers .aead = __VECS(aegis128l_tv_template) 2744b87dc203SOndrej Mosnacek } 2745b87dc203SOndrej Mosnacek }, { 2746b87dc203SOndrej Mosnacek .alg = "aegis256", 2747b87dc203SOndrej Mosnacek .test = alg_test_aead, 2748b87dc203SOndrej Mosnacek .suite = { 2749a0d608eeSEric Biggers .aead = __VECS(aegis256_tv_template) 2750b87dc203SOndrej Mosnacek } 2751b87dc203SOndrej Mosnacek }, { 2752e08ca2daSJarod Wilson .alg = "ansi_cprng", 2753e08ca2daSJarod Wilson .test = alg_test_cprng, 2754e08ca2daSJarod Wilson .suite = { 275521c8e720SArd Biesheuvel .cprng = __VECS(ansi_cprng_aes_tv_template) 2756e08ca2daSJarod Wilson } 2757e08ca2daSJarod Wilson }, { 2758bca4feb0SHoria Geanta .alg = "authenc(hmac(md5),ecb(cipher_null))", 2759bca4feb0SHoria Geanta .test = alg_test_aead, 2760bca4feb0SHoria Geanta .suite = { 2761a0d608eeSEric Biggers .aead = __VECS(hmac_md5_ecb_cipher_null_tv_template) 2762bca4feb0SHoria Geanta } 2763bca4feb0SHoria Geanta }, { 2764a4198fd4SHerbert Xu .alg = "authenc(hmac(sha1),cbc(aes))", 2765e46e9a46SHoria Geanta .test = alg_test_aead, 2766bcf741cbSHerbert Xu .fips_allowed = 1, 2767e46e9a46SHoria Geanta .suite = { 2768a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_aes_cbc_tv_temp) 27695208ed2cSNitesh Lal } 27705208ed2cSNitesh Lal }, { 2771a4198fd4SHerbert Xu .alg = "authenc(hmac(sha1),cbc(des))", 27725208ed2cSNitesh Lal .test = alg_test_aead, 27735208ed2cSNitesh Lal .suite = { 2774a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_des_cbc_tv_temp) 27755208ed2cSNitesh Lal } 27765208ed2cSNitesh Lal }, { 2777a4198fd4SHerbert Xu .alg = "authenc(hmac(sha1),cbc(des3_ede))", 27785208ed2cSNitesh Lal .test = alg_test_aead, 2779ed1afac9SMarcus Meissner .fips_allowed = 1, 27805208ed2cSNitesh Lal .suite = { 2781a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_des3_ede_cbc_tv_temp) 2782e46e9a46SHoria Geanta } 2783e46e9a46SHoria Geanta }, { 2784fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha1),ctr(aes))", 2785fb16abc2SMarcus Meissner .test = alg_test_null, 2786fb16abc2SMarcus Meissner .fips_allowed = 1, 2787fb16abc2SMarcus Meissner }, { 2788bca4feb0SHoria Geanta .alg = "authenc(hmac(sha1),ecb(cipher_null))", 2789bca4feb0SHoria Geanta .test = alg_test_aead, 2790bca4feb0SHoria Geanta .suite = { 2791a0d608eeSEric Biggers .aead = __VECS(hmac_sha1_ecb_cipher_null_tv_temp) 27925208ed2cSNitesh Lal } 27935208ed2cSNitesh Lal }, { 27948888690eSMarcus Meissner .alg = "authenc(hmac(sha1),rfc3686(ctr(aes)))", 27958888690eSMarcus Meissner .test = alg_test_null, 27968888690eSMarcus Meissner .fips_allowed = 1, 27978888690eSMarcus Meissner }, { 2798a4198fd4SHerbert Xu .alg = "authenc(hmac(sha224),cbc(des))", 27995208ed2cSNitesh Lal .test = alg_test_aead, 28005208ed2cSNitesh Lal .suite = { 2801a0d608eeSEric Biggers .aead = __VECS(hmac_sha224_des_cbc_tv_temp) 28025208ed2cSNitesh Lal } 28035208ed2cSNitesh Lal }, { 2804a4198fd4SHerbert Xu .alg = "authenc(hmac(sha224),cbc(des3_ede))", 28055208ed2cSNitesh Lal .test = alg_test_aead, 2806ed1afac9SMarcus Meissner .fips_allowed = 1, 28075208ed2cSNitesh Lal .suite = { 2808a0d608eeSEric Biggers .aead = __VECS(hmac_sha224_des3_ede_cbc_tv_temp) 2809bca4feb0SHoria Geanta } 2810bca4feb0SHoria Geanta }, { 2811a4198fd4SHerbert Xu .alg = "authenc(hmac(sha256),cbc(aes))", 2812e46e9a46SHoria Geanta .test = alg_test_aead, 2813ed1afac9SMarcus Meissner .fips_allowed = 1, 2814e46e9a46SHoria Geanta .suite = { 2815a0d608eeSEric Biggers .aead = __VECS(hmac_sha256_aes_cbc_tv_temp) 28165208ed2cSNitesh Lal } 28175208ed2cSNitesh Lal }, { 2818a4198fd4SHerbert Xu .alg = "authenc(hmac(sha256),cbc(des))", 28195208ed2cSNitesh Lal .test = alg_test_aead, 28205208ed2cSNitesh Lal .suite = { 2821a0d608eeSEric Biggers .aead = __VECS(hmac_sha256_des_cbc_tv_temp) 28225208ed2cSNitesh Lal } 28235208ed2cSNitesh Lal }, { 2824a4198fd4SHerbert Xu .alg = "authenc(hmac(sha256),cbc(des3_ede))", 28255208ed2cSNitesh Lal .test = alg_test_aead, 2826ed1afac9SMarcus Meissner .fips_allowed = 1, 28275208ed2cSNitesh Lal .suite = { 2828a0d608eeSEric Biggers .aead = __VECS(hmac_sha256_des3_ede_cbc_tv_temp) 28295208ed2cSNitesh Lal } 28305208ed2cSNitesh Lal }, { 2831fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha256),ctr(aes))", 2832fb16abc2SMarcus Meissner .test = alg_test_null, 2833fb16abc2SMarcus Meissner .fips_allowed = 1, 2834fb16abc2SMarcus Meissner }, { 28358888690eSMarcus Meissner .alg = "authenc(hmac(sha256),rfc3686(ctr(aes)))", 28368888690eSMarcus Meissner .test = alg_test_null, 28378888690eSMarcus Meissner .fips_allowed = 1, 28388888690eSMarcus Meissner }, { 2839a4198fd4SHerbert Xu .alg = "authenc(hmac(sha384),cbc(des))", 28405208ed2cSNitesh Lal .test = alg_test_aead, 28415208ed2cSNitesh Lal .suite = { 2842a0d608eeSEric Biggers .aead = __VECS(hmac_sha384_des_cbc_tv_temp) 28435208ed2cSNitesh Lal } 28445208ed2cSNitesh Lal }, { 2845a4198fd4SHerbert Xu .alg = "authenc(hmac(sha384),cbc(des3_ede))", 28465208ed2cSNitesh Lal .test = alg_test_aead, 2847ed1afac9SMarcus Meissner .fips_allowed = 1, 28485208ed2cSNitesh Lal .suite = { 2849a0d608eeSEric Biggers .aead = __VECS(hmac_sha384_des3_ede_cbc_tv_temp) 2850e46e9a46SHoria Geanta } 2851e46e9a46SHoria Geanta }, { 2852fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha384),ctr(aes))", 2853fb16abc2SMarcus Meissner .test = alg_test_null, 2854fb16abc2SMarcus Meissner .fips_allowed = 1, 2855fb16abc2SMarcus Meissner }, { 28568888690eSMarcus Meissner .alg = "authenc(hmac(sha384),rfc3686(ctr(aes)))", 28578888690eSMarcus Meissner .test = alg_test_null, 28588888690eSMarcus Meissner .fips_allowed = 1, 28598888690eSMarcus Meissner }, { 2860a4198fd4SHerbert Xu .alg = "authenc(hmac(sha512),cbc(aes))", 2861ed1afac9SMarcus Meissner .fips_allowed = 1, 2862e46e9a46SHoria Geanta .test = alg_test_aead, 2863e46e9a46SHoria Geanta .suite = { 2864a0d608eeSEric Biggers .aead = __VECS(hmac_sha512_aes_cbc_tv_temp) 28655208ed2cSNitesh Lal } 28665208ed2cSNitesh Lal }, { 2867a4198fd4SHerbert Xu .alg = "authenc(hmac(sha512),cbc(des))", 28685208ed2cSNitesh Lal .test = alg_test_aead, 28695208ed2cSNitesh Lal .suite = { 2870a0d608eeSEric Biggers .aead = __VECS(hmac_sha512_des_cbc_tv_temp) 28715208ed2cSNitesh Lal } 28725208ed2cSNitesh Lal }, { 2873a4198fd4SHerbert Xu .alg = "authenc(hmac(sha512),cbc(des3_ede))", 28745208ed2cSNitesh Lal .test = alg_test_aead, 2875ed1afac9SMarcus Meissner .fips_allowed = 1, 28765208ed2cSNitesh Lal .suite = { 2877a0d608eeSEric Biggers .aead = __VECS(hmac_sha512_des3_ede_cbc_tv_temp) 2878e46e9a46SHoria Geanta } 2879e46e9a46SHoria Geanta }, { 2880fb16abc2SMarcus Meissner .alg = "authenc(hmac(sha512),ctr(aes))", 2881fb16abc2SMarcus Meissner .test = alg_test_null, 2882fb16abc2SMarcus Meissner .fips_allowed = 1, 2883fb16abc2SMarcus Meissner }, { 28848888690eSMarcus Meissner .alg = "authenc(hmac(sha512),rfc3686(ctr(aes)))", 28858888690eSMarcus Meissner .test = alg_test_null, 28868888690eSMarcus Meissner .fips_allowed = 1, 28878888690eSMarcus Meissner }, { 2888da7f033dSHerbert Xu .alg = "cbc(aes)", 28891aa4ecd9SHerbert Xu .test = alg_test_skcipher, 2890a1915d51SJarod Wilson .fips_allowed = 1, 2891da7f033dSHerbert Xu .suite = { 289292a4c9feSEric Biggers .cipher = __VECS(aes_cbc_tv_template) 289392a4c9feSEric Biggers }, 2894da7f033dSHerbert Xu }, { 2895da7f033dSHerbert Xu .alg = "cbc(anubis)", 28961aa4ecd9SHerbert Xu .test = alg_test_skcipher, 2897da7f033dSHerbert Xu .suite = { 289892a4c9feSEric Biggers .cipher = __VECS(anubis_cbc_tv_template) 289992a4c9feSEric Biggers }, 2900da7f033dSHerbert Xu }, { 2901da7f033dSHerbert Xu .alg = "cbc(blowfish)", 29021aa4ecd9SHerbert Xu .test = alg_test_skcipher, 2903da7f033dSHerbert Xu .suite = { 290492a4c9feSEric Biggers .cipher = __VECS(bf_cbc_tv_template) 290592a4c9feSEric Biggers }, 2906da7f033dSHerbert Xu }, { 2907da7f033dSHerbert Xu .alg = "cbc(camellia)", 29081aa4ecd9SHerbert Xu .test = alg_test_skcipher, 2909da7f033dSHerbert Xu .suite = { 291092a4c9feSEric Biggers .cipher = __VECS(camellia_cbc_tv_template) 291192a4c9feSEric Biggers }, 2912da7f033dSHerbert Xu }, { 2913a2c58260SJohannes Goetzfried .alg = "cbc(cast5)", 2914a2c58260SJohannes Goetzfried .test = alg_test_skcipher, 2915a2c58260SJohannes Goetzfried .suite = { 291692a4c9feSEric Biggers .cipher = __VECS(cast5_cbc_tv_template) 291792a4c9feSEric Biggers }, 2918a2c58260SJohannes Goetzfried }, { 29199b8b0405SJohannes Goetzfried .alg = "cbc(cast6)", 29209b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 29219b8b0405SJohannes Goetzfried .suite = { 292292a4c9feSEric Biggers .cipher = __VECS(cast6_cbc_tv_template) 292392a4c9feSEric Biggers }, 29249b8b0405SJohannes Goetzfried }, { 2925da7f033dSHerbert Xu .alg = "cbc(des)", 29261aa4ecd9SHerbert Xu .test = alg_test_skcipher, 2927da7f033dSHerbert Xu .suite = { 292892a4c9feSEric Biggers .cipher = __VECS(des_cbc_tv_template) 292992a4c9feSEric Biggers }, 2930da7f033dSHerbert Xu }, { 2931da7f033dSHerbert Xu .alg = "cbc(des3_ede)", 29321aa4ecd9SHerbert Xu .test = alg_test_skcipher, 2933a1915d51SJarod Wilson .fips_allowed = 1, 2934da7f033dSHerbert Xu .suite = { 293592a4c9feSEric Biggers .cipher = __VECS(des3_ede_cbc_tv_template) 293692a4c9feSEric Biggers }, 2937da7f033dSHerbert Xu }, { 2938a794d8d8SGilad Ben-Yossef /* Same as cbc(aes) except the key is stored in 2939a794d8d8SGilad Ben-Yossef * hardware secure memory which we reference by index 2940a794d8d8SGilad Ben-Yossef */ 2941a794d8d8SGilad Ben-Yossef .alg = "cbc(paes)", 2942a794d8d8SGilad Ben-Yossef .test = alg_test_null, 2943a794d8d8SGilad Ben-Yossef .fips_allowed = 1, 2944a794d8d8SGilad Ben-Yossef }, { 29459d25917dSJussi Kivilinna .alg = "cbc(serpent)", 29469d25917dSJussi Kivilinna .test = alg_test_skcipher, 29479d25917dSJussi Kivilinna .suite = { 294892a4c9feSEric Biggers .cipher = __VECS(serpent_cbc_tv_template) 294992a4c9feSEric Biggers }, 29509d25917dSJussi Kivilinna }, { 295195ba5973SGilad Ben-Yossef .alg = "cbc(sm4)", 295295ba5973SGilad Ben-Yossef .test = alg_test_skcipher, 295395ba5973SGilad Ben-Yossef .suite = { 295495ba5973SGilad Ben-Yossef .cipher = __VECS(sm4_cbc_tv_template) 295595ba5973SGilad Ben-Yossef } 295695ba5973SGilad Ben-Yossef }, { 2957da7f033dSHerbert Xu .alg = "cbc(twofish)", 29581aa4ecd9SHerbert Xu .test = alg_test_skcipher, 2959da7f033dSHerbert Xu .suite = { 296092a4c9feSEric Biggers .cipher = __VECS(tf_cbc_tv_template) 296192a4c9feSEric Biggers }, 2962da7f033dSHerbert Xu }, { 2963092acf06SArd Biesheuvel .alg = "cbcmac(aes)", 2964092acf06SArd Biesheuvel .fips_allowed = 1, 2965092acf06SArd Biesheuvel .test = alg_test_hash, 2966092acf06SArd Biesheuvel .suite = { 2967092acf06SArd Biesheuvel .hash = __VECS(aes_cbcmac_tv_template) 2968092acf06SArd Biesheuvel } 2969092acf06SArd Biesheuvel }, { 2970da7f033dSHerbert Xu .alg = "ccm(aes)", 2971da7f033dSHerbert Xu .test = alg_test_aead, 2972a1915d51SJarod Wilson .fips_allowed = 1, 2973da7f033dSHerbert Xu .suite = { 2974a0d608eeSEric Biggers .aead = __VECS(aes_ccm_tv_template) 2975da7f033dSHerbert Xu } 2976da7f033dSHerbert Xu }, { 29777da66670SDmitry Eremin-Solenikov .alg = "cfb(aes)", 29787da66670SDmitry Eremin-Solenikov .test = alg_test_skcipher, 29797da66670SDmitry Eremin-Solenikov .fips_allowed = 1, 29807da66670SDmitry Eremin-Solenikov .suite = { 29817da66670SDmitry Eremin-Solenikov .cipher = __VECS(aes_cfb_tv_template) 29827da66670SDmitry Eremin-Solenikov }, 29837da66670SDmitry Eremin-Solenikov }, { 29843590ebf2SMartin Willi .alg = "chacha20", 29853590ebf2SMartin Willi .test = alg_test_skcipher, 29863590ebf2SMartin Willi .suite = { 298792a4c9feSEric Biggers .cipher = __VECS(chacha20_tv_template) 298892a4c9feSEric Biggers }, 29893590ebf2SMartin Willi }, { 299093b5e86aSJussi Kivilinna .alg = "cmac(aes)", 29918f183751SStephan Mueller .fips_allowed = 1, 299293b5e86aSJussi Kivilinna .test = alg_test_hash, 299393b5e86aSJussi Kivilinna .suite = { 299421c8e720SArd Biesheuvel .hash = __VECS(aes_cmac128_tv_template) 299593b5e86aSJussi Kivilinna } 299693b5e86aSJussi Kivilinna }, { 299793b5e86aSJussi Kivilinna .alg = "cmac(des3_ede)", 29988f183751SStephan Mueller .fips_allowed = 1, 299993b5e86aSJussi Kivilinna .test = alg_test_hash, 300093b5e86aSJussi Kivilinna .suite = { 300121c8e720SArd Biesheuvel .hash = __VECS(des3_ede_cmac64_tv_template) 300293b5e86aSJussi Kivilinna } 300393b5e86aSJussi Kivilinna }, { 3004e448370dSJussi Kivilinna .alg = "compress_null", 3005e448370dSJussi Kivilinna .test = alg_test_null, 3006e448370dSJussi Kivilinna }, { 3007ebb3472fSArd Biesheuvel .alg = "crc32", 3008ebb3472fSArd Biesheuvel .test = alg_test_hash, 3009a8a34416SMilan Broz .fips_allowed = 1, 3010ebb3472fSArd Biesheuvel .suite = { 301121c8e720SArd Biesheuvel .hash = __VECS(crc32_tv_template) 3012ebb3472fSArd Biesheuvel } 3013ebb3472fSArd Biesheuvel }, { 3014da7f033dSHerbert Xu .alg = "crc32c", 30158e3ee85eSHerbert Xu .test = alg_test_crc32c, 3016a1915d51SJarod Wilson .fips_allowed = 1, 3017da7f033dSHerbert Xu .suite = { 301821c8e720SArd Biesheuvel .hash = __VECS(crc32c_tv_template) 3019da7f033dSHerbert Xu } 3020da7f033dSHerbert Xu }, { 302168411521SHerbert Xu .alg = "crct10dif", 302268411521SHerbert Xu .test = alg_test_hash, 302368411521SHerbert Xu .fips_allowed = 1, 302468411521SHerbert Xu .suite = { 302521c8e720SArd Biesheuvel .hash = __VECS(crct10dif_tv_template) 302668411521SHerbert Xu } 302768411521SHerbert Xu }, { 3028f7cb80f2SJarod Wilson .alg = "ctr(aes)", 3029f7cb80f2SJarod Wilson .test = alg_test_skcipher, 3030a1915d51SJarod Wilson .fips_allowed = 1, 3031f7cb80f2SJarod Wilson .suite = { 303292a4c9feSEric Biggers .cipher = __VECS(aes_ctr_tv_template) 3033f7cb80f2SJarod Wilson } 3034f7cb80f2SJarod Wilson }, { 303585b63e34SJussi Kivilinna .alg = "ctr(blowfish)", 303685b63e34SJussi Kivilinna .test = alg_test_skcipher, 303785b63e34SJussi Kivilinna .suite = { 303892a4c9feSEric Biggers .cipher = __VECS(bf_ctr_tv_template) 303985b63e34SJussi Kivilinna } 304085b63e34SJussi Kivilinna }, { 30410840605eSJussi Kivilinna .alg = "ctr(camellia)", 30420840605eSJussi Kivilinna .test = alg_test_skcipher, 30430840605eSJussi Kivilinna .suite = { 304492a4c9feSEric Biggers .cipher = __VECS(camellia_ctr_tv_template) 30450840605eSJussi Kivilinna } 30460840605eSJussi Kivilinna }, { 3047a2c58260SJohannes Goetzfried .alg = "ctr(cast5)", 3048a2c58260SJohannes Goetzfried .test = alg_test_skcipher, 3049a2c58260SJohannes Goetzfried .suite = { 305092a4c9feSEric Biggers .cipher = __VECS(cast5_ctr_tv_template) 3051a2c58260SJohannes Goetzfried } 3052a2c58260SJohannes Goetzfried }, { 30539b8b0405SJohannes Goetzfried .alg = "ctr(cast6)", 30549b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 30559b8b0405SJohannes Goetzfried .suite = { 305692a4c9feSEric Biggers .cipher = __VECS(cast6_ctr_tv_template) 30579b8b0405SJohannes Goetzfried } 30589b8b0405SJohannes Goetzfried }, { 30598163fc30SJussi Kivilinna .alg = "ctr(des)", 30608163fc30SJussi Kivilinna .test = alg_test_skcipher, 30618163fc30SJussi Kivilinna .suite = { 306292a4c9feSEric Biggers .cipher = __VECS(des_ctr_tv_template) 30638163fc30SJussi Kivilinna } 30648163fc30SJussi Kivilinna }, { 3065e080b17aSJussi Kivilinna .alg = "ctr(des3_ede)", 3066e080b17aSJussi Kivilinna .test = alg_test_skcipher, 30670d8da104SMarcelo Cerri .fips_allowed = 1, 3068e080b17aSJussi Kivilinna .suite = { 306992a4c9feSEric Biggers .cipher = __VECS(des3_ede_ctr_tv_template) 3070e080b17aSJussi Kivilinna } 3071e080b17aSJussi Kivilinna }, { 3072a794d8d8SGilad Ben-Yossef /* Same as ctr(aes) except the key is stored in 3073a794d8d8SGilad Ben-Yossef * hardware secure memory which we reference by index 3074a794d8d8SGilad Ben-Yossef */ 3075a794d8d8SGilad Ben-Yossef .alg = "ctr(paes)", 3076a794d8d8SGilad Ben-Yossef .test = alg_test_null, 3077a794d8d8SGilad Ben-Yossef .fips_allowed = 1, 3078a794d8d8SGilad Ben-Yossef }, { 30799d25917dSJussi Kivilinna .alg = "ctr(serpent)", 30809d25917dSJussi Kivilinna .test = alg_test_skcipher, 30819d25917dSJussi Kivilinna .suite = { 308292a4c9feSEric Biggers .cipher = __VECS(serpent_ctr_tv_template) 30839d25917dSJussi Kivilinna } 30849d25917dSJussi Kivilinna }, { 308595ba5973SGilad Ben-Yossef .alg = "ctr(sm4)", 308695ba5973SGilad Ben-Yossef .test = alg_test_skcipher, 308795ba5973SGilad Ben-Yossef .suite = { 308895ba5973SGilad Ben-Yossef .cipher = __VECS(sm4_ctr_tv_template) 308995ba5973SGilad Ben-Yossef } 309095ba5973SGilad Ben-Yossef }, { 3091573da620SJussi Kivilinna .alg = "ctr(twofish)", 3092573da620SJussi Kivilinna .test = alg_test_skcipher, 3093573da620SJussi Kivilinna .suite = { 309492a4c9feSEric Biggers .cipher = __VECS(tf_ctr_tv_template) 3095573da620SJussi Kivilinna } 3096573da620SJussi Kivilinna }, { 3097da7f033dSHerbert Xu .alg = "cts(cbc(aes))", 30981aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3099196ad604SGilad Ben-Yossef .fips_allowed = 1, 3100da7f033dSHerbert Xu .suite = { 310192a4c9feSEric Biggers .cipher = __VECS(cts_mode_tv_template) 3102da7f033dSHerbert Xu } 3103da7f033dSHerbert Xu }, { 3104da7f033dSHerbert Xu .alg = "deflate", 3105da7f033dSHerbert Xu .test = alg_test_comp, 31060818904dSMilan Broz .fips_allowed = 1, 3107da7f033dSHerbert Xu .suite = { 3108da7f033dSHerbert Xu .comp = { 310921c8e720SArd Biesheuvel .comp = __VECS(deflate_comp_tv_template), 311021c8e720SArd Biesheuvel .decomp = __VECS(deflate_decomp_tv_template) 3111da7f033dSHerbert Xu } 3112da7f033dSHerbert Xu } 3113da7f033dSHerbert Xu }, { 3114802c7f1cSSalvatore Benedetto .alg = "dh", 3115802c7f1cSSalvatore Benedetto .test = alg_test_kpp, 3116802c7f1cSSalvatore Benedetto .fips_allowed = 1, 3117802c7f1cSSalvatore Benedetto .suite = { 311821c8e720SArd Biesheuvel .kpp = __VECS(dh_tv_template) 3119802c7f1cSSalvatore Benedetto } 3120802c7f1cSSalvatore Benedetto }, { 3121e448370dSJussi Kivilinna .alg = "digest_null", 3122e448370dSJussi Kivilinna .test = alg_test_null, 3123e448370dSJussi Kivilinna }, { 312464d1cdfbSStephan Mueller .alg = "drbg_nopr_ctr_aes128", 312564d1cdfbSStephan Mueller .test = alg_test_drbg, 312664d1cdfbSStephan Mueller .fips_allowed = 1, 312764d1cdfbSStephan Mueller .suite = { 312821c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_ctr_aes128_tv_template) 312964d1cdfbSStephan Mueller } 313064d1cdfbSStephan Mueller }, { 313164d1cdfbSStephan Mueller .alg = "drbg_nopr_ctr_aes192", 313264d1cdfbSStephan Mueller .test = alg_test_drbg, 313364d1cdfbSStephan Mueller .fips_allowed = 1, 313464d1cdfbSStephan Mueller .suite = { 313521c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_ctr_aes192_tv_template) 313664d1cdfbSStephan Mueller } 313764d1cdfbSStephan Mueller }, { 313864d1cdfbSStephan Mueller .alg = "drbg_nopr_ctr_aes256", 313964d1cdfbSStephan Mueller .test = alg_test_drbg, 314064d1cdfbSStephan Mueller .fips_allowed = 1, 314164d1cdfbSStephan Mueller .suite = { 314221c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_ctr_aes256_tv_template) 314364d1cdfbSStephan Mueller } 314464d1cdfbSStephan Mueller }, { 314564d1cdfbSStephan Mueller /* 314664d1cdfbSStephan Mueller * There is no need to specifically test the DRBG with every 314764d1cdfbSStephan Mueller * backend cipher -- covered by drbg_nopr_hmac_sha256 test 314864d1cdfbSStephan Mueller */ 314964d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha1", 315064d1cdfbSStephan Mueller .fips_allowed = 1, 315164d1cdfbSStephan Mueller .test = alg_test_null, 315264d1cdfbSStephan Mueller }, { 315364d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha256", 315464d1cdfbSStephan Mueller .test = alg_test_drbg, 315564d1cdfbSStephan Mueller .fips_allowed = 1, 315664d1cdfbSStephan Mueller .suite = { 315721c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_hmac_sha256_tv_template) 315864d1cdfbSStephan Mueller } 315964d1cdfbSStephan Mueller }, { 316064d1cdfbSStephan Mueller /* covered by drbg_nopr_hmac_sha256 test */ 316164d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha384", 316264d1cdfbSStephan Mueller .fips_allowed = 1, 316364d1cdfbSStephan Mueller .test = alg_test_null, 316464d1cdfbSStephan Mueller }, { 316564d1cdfbSStephan Mueller .alg = "drbg_nopr_hmac_sha512", 316664d1cdfbSStephan Mueller .test = alg_test_null, 316764d1cdfbSStephan Mueller .fips_allowed = 1, 316864d1cdfbSStephan Mueller }, { 316964d1cdfbSStephan Mueller .alg = "drbg_nopr_sha1", 317064d1cdfbSStephan Mueller .fips_allowed = 1, 317164d1cdfbSStephan Mueller .test = alg_test_null, 317264d1cdfbSStephan Mueller }, { 317364d1cdfbSStephan Mueller .alg = "drbg_nopr_sha256", 317464d1cdfbSStephan Mueller .test = alg_test_drbg, 317564d1cdfbSStephan Mueller .fips_allowed = 1, 317664d1cdfbSStephan Mueller .suite = { 317721c8e720SArd Biesheuvel .drbg = __VECS(drbg_nopr_sha256_tv_template) 317864d1cdfbSStephan Mueller } 317964d1cdfbSStephan Mueller }, { 318064d1cdfbSStephan Mueller /* covered by drbg_nopr_sha256 test */ 318164d1cdfbSStephan Mueller .alg = "drbg_nopr_sha384", 318264d1cdfbSStephan Mueller .fips_allowed = 1, 318364d1cdfbSStephan Mueller .test = alg_test_null, 318464d1cdfbSStephan Mueller }, { 318564d1cdfbSStephan Mueller .alg = "drbg_nopr_sha512", 318664d1cdfbSStephan Mueller .fips_allowed = 1, 318764d1cdfbSStephan Mueller .test = alg_test_null, 318864d1cdfbSStephan Mueller }, { 318964d1cdfbSStephan Mueller .alg = "drbg_pr_ctr_aes128", 319064d1cdfbSStephan Mueller .test = alg_test_drbg, 319164d1cdfbSStephan Mueller .fips_allowed = 1, 319264d1cdfbSStephan Mueller .suite = { 319321c8e720SArd Biesheuvel .drbg = __VECS(drbg_pr_ctr_aes128_tv_template) 319464d1cdfbSStephan Mueller } 319564d1cdfbSStephan Mueller }, { 319664d1cdfbSStephan Mueller /* covered by drbg_pr_ctr_aes128 test */ 319764d1cdfbSStephan Mueller .alg = "drbg_pr_ctr_aes192", 319864d1cdfbSStephan Mueller .fips_allowed = 1, 319964d1cdfbSStephan Mueller .test = alg_test_null, 320064d1cdfbSStephan Mueller }, { 320164d1cdfbSStephan Mueller .alg = "drbg_pr_ctr_aes256", 320264d1cdfbSStephan Mueller .fips_allowed = 1, 320364d1cdfbSStephan Mueller .test = alg_test_null, 320464d1cdfbSStephan Mueller }, { 320564d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha1", 320664d1cdfbSStephan Mueller .fips_allowed = 1, 320764d1cdfbSStephan Mueller .test = alg_test_null, 320864d1cdfbSStephan Mueller }, { 320964d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha256", 321064d1cdfbSStephan Mueller .test = alg_test_drbg, 321164d1cdfbSStephan Mueller .fips_allowed = 1, 321264d1cdfbSStephan Mueller .suite = { 321321c8e720SArd Biesheuvel .drbg = __VECS(drbg_pr_hmac_sha256_tv_template) 321464d1cdfbSStephan Mueller } 321564d1cdfbSStephan Mueller }, { 321664d1cdfbSStephan Mueller /* covered by drbg_pr_hmac_sha256 test */ 321764d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha384", 321864d1cdfbSStephan Mueller .fips_allowed = 1, 321964d1cdfbSStephan Mueller .test = alg_test_null, 322064d1cdfbSStephan Mueller }, { 322164d1cdfbSStephan Mueller .alg = "drbg_pr_hmac_sha512", 322264d1cdfbSStephan Mueller .test = alg_test_null, 322364d1cdfbSStephan Mueller .fips_allowed = 1, 322464d1cdfbSStephan Mueller }, { 322564d1cdfbSStephan Mueller .alg = "drbg_pr_sha1", 322664d1cdfbSStephan Mueller .fips_allowed = 1, 322764d1cdfbSStephan Mueller .test = alg_test_null, 322864d1cdfbSStephan Mueller }, { 322964d1cdfbSStephan Mueller .alg = "drbg_pr_sha256", 323064d1cdfbSStephan Mueller .test = alg_test_drbg, 323164d1cdfbSStephan Mueller .fips_allowed = 1, 323264d1cdfbSStephan Mueller .suite = { 323321c8e720SArd Biesheuvel .drbg = __VECS(drbg_pr_sha256_tv_template) 323464d1cdfbSStephan Mueller } 323564d1cdfbSStephan Mueller }, { 323664d1cdfbSStephan Mueller /* covered by drbg_pr_sha256 test */ 323764d1cdfbSStephan Mueller .alg = "drbg_pr_sha384", 323864d1cdfbSStephan Mueller .fips_allowed = 1, 323964d1cdfbSStephan Mueller .test = alg_test_null, 324064d1cdfbSStephan Mueller }, { 324164d1cdfbSStephan Mueller .alg = "drbg_pr_sha512", 324264d1cdfbSStephan Mueller .fips_allowed = 1, 324364d1cdfbSStephan Mueller .test = alg_test_null, 324464d1cdfbSStephan Mueller }, { 3245da7f033dSHerbert Xu .alg = "ecb(aes)", 32461aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3247a1915d51SJarod Wilson .fips_allowed = 1, 3248da7f033dSHerbert Xu .suite = { 324992a4c9feSEric Biggers .cipher = __VECS(aes_tv_template) 3250da7f033dSHerbert Xu } 3251da7f033dSHerbert Xu }, { 3252da7f033dSHerbert Xu .alg = "ecb(anubis)", 32531aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3254da7f033dSHerbert Xu .suite = { 325592a4c9feSEric Biggers .cipher = __VECS(anubis_tv_template) 3256da7f033dSHerbert Xu } 3257da7f033dSHerbert Xu }, { 3258da7f033dSHerbert Xu .alg = "ecb(arc4)", 32591aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3260da7f033dSHerbert Xu .suite = { 326192a4c9feSEric Biggers .cipher = __VECS(arc4_tv_template) 3262da7f033dSHerbert Xu } 3263da7f033dSHerbert Xu }, { 3264da7f033dSHerbert Xu .alg = "ecb(blowfish)", 32651aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3266da7f033dSHerbert Xu .suite = { 326792a4c9feSEric Biggers .cipher = __VECS(bf_tv_template) 3268da7f033dSHerbert Xu } 3269da7f033dSHerbert Xu }, { 3270da7f033dSHerbert Xu .alg = "ecb(camellia)", 32711aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3272da7f033dSHerbert Xu .suite = { 327392a4c9feSEric Biggers .cipher = __VECS(camellia_tv_template) 3274da7f033dSHerbert Xu } 3275da7f033dSHerbert Xu }, { 3276da7f033dSHerbert Xu .alg = "ecb(cast5)", 32771aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3278da7f033dSHerbert Xu .suite = { 327992a4c9feSEric Biggers .cipher = __VECS(cast5_tv_template) 3280da7f033dSHerbert Xu } 3281da7f033dSHerbert Xu }, { 3282da7f033dSHerbert Xu .alg = "ecb(cast6)", 32831aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3284da7f033dSHerbert Xu .suite = { 328592a4c9feSEric Biggers .cipher = __VECS(cast6_tv_template) 3286da7f033dSHerbert Xu } 3287da7f033dSHerbert Xu }, { 3288e448370dSJussi Kivilinna .alg = "ecb(cipher_null)", 3289e448370dSJussi Kivilinna .test = alg_test_null, 32906175ca2bSMilan Broz .fips_allowed = 1, 3291e448370dSJussi Kivilinna }, { 3292da7f033dSHerbert Xu .alg = "ecb(des)", 32931aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3294da7f033dSHerbert Xu .suite = { 329592a4c9feSEric Biggers .cipher = __VECS(des_tv_template) 3296da7f033dSHerbert Xu } 3297da7f033dSHerbert Xu }, { 3298da7f033dSHerbert Xu .alg = "ecb(des3_ede)", 32991aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3300a1915d51SJarod Wilson .fips_allowed = 1, 3301da7f033dSHerbert Xu .suite = { 330292a4c9feSEric Biggers .cipher = __VECS(des3_ede_tv_template) 3303da7f033dSHerbert Xu } 3304da7f033dSHerbert Xu }, { 330566e5bd00SJussi Kivilinna .alg = "ecb(fcrypt)", 330666e5bd00SJussi Kivilinna .test = alg_test_skcipher, 330766e5bd00SJussi Kivilinna .suite = { 330866e5bd00SJussi Kivilinna .cipher = { 330992a4c9feSEric Biggers .vecs = fcrypt_pcbc_tv_template, 331066e5bd00SJussi Kivilinna .count = 1 331166e5bd00SJussi Kivilinna } 331266e5bd00SJussi Kivilinna } 331366e5bd00SJussi Kivilinna }, { 3314da7f033dSHerbert Xu .alg = "ecb(khazad)", 33151aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3316da7f033dSHerbert Xu .suite = { 331792a4c9feSEric Biggers .cipher = __VECS(khazad_tv_template) 3318da7f033dSHerbert Xu } 3319da7f033dSHerbert Xu }, { 332015f47ce5SGilad Ben-Yossef /* Same as ecb(aes) except the key is stored in 332115f47ce5SGilad Ben-Yossef * hardware secure memory which we reference by index 332215f47ce5SGilad Ben-Yossef */ 332315f47ce5SGilad Ben-Yossef .alg = "ecb(paes)", 332415f47ce5SGilad Ben-Yossef .test = alg_test_null, 332515f47ce5SGilad Ben-Yossef .fips_allowed = 1, 332615f47ce5SGilad Ben-Yossef }, { 3327da7f033dSHerbert Xu .alg = "ecb(seed)", 33281aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3329da7f033dSHerbert Xu .suite = { 333092a4c9feSEric Biggers .cipher = __VECS(seed_tv_template) 3331da7f033dSHerbert Xu } 3332da7f033dSHerbert Xu }, { 3333da7f033dSHerbert Xu .alg = "ecb(serpent)", 33341aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3335da7f033dSHerbert Xu .suite = { 333692a4c9feSEric Biggers .cipher = __VECS(serpent_tv_template) 3337da7f033dSHerbert Xu } 3338da7f033dSHerbert Xu }, { 3339cd83a8a7SGilad Ben-Yossef .alg = "ecb(sm4)", 3340cd83a8a7SGilad Ben-Yossef .test = alg_test_skcipher, 3341cd83a8a7SGilad Ben-Yossef .suite = { 334292a4c9feSEric Biggers .cipher = __VECS(sm4_tv_template) 3343cd83a8a7SGilad Ben-Yossef } 3344cd83a8a7SGilad Ben-Yossef }, { 3345da7f033dSHerbert Xu .alg = "ecb(tea)", 33461aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3347da7f033dSHerbert Xu .suite = { 334892a4c9feSEric Biggers .cipher = __VECS(tea_tv_template) 3349da7f033dSHerbert Xu } 3350da7f033dSHerbert Xu }, { 3351da7f033dSHerbert Xu .alg = "ecb(tnepres)", 33521aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3353da7f033dSHerbert Xu .suite = { 335492a4c9feSEric Biggers .cipher = __VECS(tnepres_tv_template) 3355da7f033dSHerbert Xu } 3356da7f033dSHerbert Xu }, { 3357da7f033dSHerbert Xu .alg = "ecb(twofish)", 33581aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3359da7f033dSHerbert Xu .suite = { 336092a4c9feSEric Biggers .cipher = __VECS(tf_tv_template) 3361da7f033dSHerbert Xu } 3362da7f033dSHerbert Xu }, { 3363da7f033dSHerbert Xu .alg = "ecb(xeta)", 33641aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3365da7f033dSHerbert Xu .suite = { 336692a4c9feSEric Biggers .cipher = __VECS(xeta_tv_template) 3367da7f033dSHerbert Xu } 3368da7f033dSHerbert Xu }, { 3369da7f033dSHerbert Xu .alg = "ecb(xtea)", 33701aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3371da7f033dSHerbert Xu .suite = { 337292a4c9feSEric Biggers .cipher = __VECS(xtea_tv_template) 3373da7f033dSHerbert Xu } 3374da7f033dSHerbert Xu }, { 33753c4b2390SSalvatore Benedetto .alg = "ecdh", 33763c4b2390SSalvatore Benedetto .test = alg_test_kpp, 33773c4b2390SSalvatore Benedetto .fips_allowed = 1, 33783c4b2390SSalvatore Benedetto .suite = { 337921c8e720SArd Biesheuvel .kpp = __VECS(ecdh_tv_template) 33803c4b2390SSalvatore Benedetto } 33813c4b2390SSalvatore Benedetto }, { 3382da7f033dSHerbert Xu .alg = "gcm(aes)", 3383da7f033dSHerbert Xu .test = alg_test_aead, 3384a1915d51SJarod Wilson .fips_allowed = 1, 3385da7f033dSHerbert Xu .suite = { 3386a0d608eeSEric Biggers .aead = __VECS(aes_gcm_tv_template) 3387da7f033dSHerbert Xu } 3388da7f033dSHerbert Xu }, { 3389507069c9SYouquan, Song .alg = "ghash", 3390507069c9SYouquan, Song .test = alg_test_hash, 339118c0ebd2SJarod Wilson .fips_allowed = 1, 3392507069c9SYouquan, Song .suite = { 339321c8e720SArd Biesheuvel .hash = __VECS(ghash_tv_template) 3394507069c9SYouquan, Song } 3395507069c9SYouquan, Song }, { 3396da7f033dSHerbert Xu .alg = "hmac(md5)", 3397da7f033dSHerbert Xu .test = alg_test_hash, 3398da7f033dSHerbert Xu .suite = { 339921c8e720SArd Biesheuvel .hash = __VECS(hmac_md5_tv_template) 3400da7f033dSHerbert Xu } 3401da7f033dSHerbert Xu }, { 3402da7f033dSHerbert Xu .alg = "hmac(rmd128)", 3403da7f033dSHerbert Xu .test = alg_test_hash, 3404da7f033dSHerbert Xu .suite = { 340521c8e720SArd Biesheuvel .hash = __VECS(hmac_rmd128_tv_template) 3406da7f033dSHerbert Xu } 3407da7f033dSHerbert Xu }, { 3408da7f033dSHerbert Xu .alg = "hmac(rmd160)", 3409da7f033dSHerbert Xu .test = alg_test_hash, 3410da7f033dSHerbert Xu .suite = { 341121c8e720SArd Biesheuvel .hash = __VECS(hmac_rmd160_tv_template) 3412da7f033dSHerbert Xu } 3413da7f033dSHerbert Xu }, { 3414da7f033dSHerbert Xu .alg = "hmac(sha1)", 3415da7f033dSHerbert Xu .test = alg_test_hash, 3416a1915d51SJarod Wilson .fips_allowed = 1, 3417da7f033dSHerbert Xu .suite = { 341821c8e720SArd Biesheuvel .hash = __VECS(hmac_sha1_tv_template) 3419da7f033dSHerbert Xu } 3420da7f033dSHerbert Xu }, { 3421da7f033dSHerbert Xu .alg = "hmac(sha224)", 3422da7f033dSHerbert Xu .test = alg_test_hash, 3423a1915d51SJarod Wilson .fips_allowed = 1, 3424da7f033dSHerbert Xu .suite = { 342521c8e720SArd Biesheuvel .hash = __VECS(hmac_sha224_tv_template) 3426da7f033dSHerbert Xu } 3427da7f033dSHerbert Xu }, { 3428da7f033dSHerbert Xu .alg = "hmac(sha256)", 3429da7f033dSHerbert Xu .test = alg_test_hash, 3430a1915d51SJarod Wilson .fips_allowed = 1, 3431da7f033dSHerbert Xu .suite = { 343221c8e720SArd Biesheuvel .hash = __VECS(hmac_sha256_tv_template) 3433da7f033dSHerbert Xu } 3434da7f033dSHerbert Xu }, { 343598eca72fSraveendra padasalagi .alg = "hmac(sha3-224)", 343698eca72fSraveendra padasalagi .test = alg_test_hash, 343798eca72fSraveendra padasalagi .fips_allowed = 1, 343898eca72fSraveendra padasalagi .suite = { 343921c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_224_tv_template) 344098eca72fSraveendra padasalagi } 344198eca72fSraveendra padasalagi }, { 344298eca72fSraveendra padasalagi .alg = "hmac(sha3-256)", 344398eca72fSraveendra padasalagi .test = alg_test_hash, 344498eca72fSraveendra padasalagi .fips_allowed = 1, 344598eca72fSraveendra padasalagi .suite = { 344621c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_256_tv_template) 344798eca72fSraveendra padasalagi } 344898eca72fSraveendra padasalagi }, { 344998eca72fSraveendra padasalagi .alg = "hmac(sha3-384)", 345098eca72fSraveendra padasalagi .test = alg_test_hash, 345198eca72fSraveendra padasalagi .fips_allowed = 1, 345298eca72fSraveendra padasalagi .suite = { 345321c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_384_tv_template) 345498eca72fSraveendra padasalagi } 345598eca72fSraveendra padasalagi }, { 345698eca72fSraveendra padasalagi .alg = "hmac(sha3-512)", 345798eca72fSraveendra padasalagi .test = alg_test_hash, 345898eca72fSraveendra padasalagi .fips_allowed = 1, 345998eca72fSraveendra padasalagi .suite = { 346021c8e720SArd Biesheuvel .hash = __VECS(hmac_sha3_512_tv_template) 346198eca72fSraveendra padasalagi } 346298eca72fSraveendra padasalagi }, { 3463da7f033dSHerbert Xu .alg = "hmac(sha384)", 3464da7f033dSHerbert Xu .test = alg_test_hash, 3465a1915d51SJarod Wilson .fips_allowed = 1, 3466da7f033dSHerbert Xu .suite = { 346721c8e720SArd Biesheuvel .hash = __VECS(hmac_sha384_tv_template) 3468da7f033dSHerbert Xu } 3469da7f033dSHerbert Xu }, { 3470da7f033dSHerbert Xu .alg = "hmac(sha512)", 3471da7f033dSHerbert Xu .test = alg_test_hash, 3472a1915d51SJarod Wilson .fips_allowed = 1, 3473da7f033dSHerbert Xu .suite = { 347421c8e720SArd Biesheuvel .hash = __VECS(hmac_sha512_tv_template) 3475da7f033dSHerbert Xu } 3476da7f033dSHerbert Xu }, { 347725a0b9d4SVitaly Chikunov .alg = "hmac(streebog256)", 347825a0b9d4SVitaly Chikunov .test = alg_test_hash, 347925a0b9d4SVitaly Chikunov .suite = { 348025a0b9d4SVitaly Chikunov .hash = __VECS(hmac_streebog256_tv_template) 348125a0b9d4SVitaly Chikunov } 348225a0b9d4SVitaly Chikunov }, { 348325a0b9d4SVitaly Chikunov .alg = "hmac(streebog512)", 348425a0b9d4SVitaly Chikunov .test = alg_test_hash, 348525a0b9d4SVitaly Chikunov .suite = { 348625a0b9d4SVitaly Chikunov .hash = __VECS(hmac_streebog512_tv_template) 348725a0b9d4SVitaly Chikunov } 348825a0b9d4SVitaly Chikunov }, { 3489bb5530e4SStephan Mueller .alg = "jitterentropy_rng", 3490bb5530e4SStephan Mueller .fips_allowed = 1, 3491bb5530e4SStephan Mueller .test = alg_test_null, 3492bb5530e4SStephan Mueller }, { 349335351988SStephan Mueller .alg = "kw(aes)", 349435351988SStephan Mueller .test = alg_test_skcipher, 349535351988SStephan Mueller .fips_allowed = 1, 349635351988SStephan Mueller .suite = { 349792a4c9feSEric Biggers .cipher = __VECS(aes_kw_tv_template) 349835351988SStephan Mueller } 349935351988SStephan Mueller }, { 3500da7f033dSHerbert Xu .alg = "lrw(aes)", 35011aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3502da7f033dSHerbert Xu .suite = { 350392a4c9feSEric Biggers .cipher = __VECS(aes_lrw_tv_template) 3504da7f033dSHerbert Xu } 3505da7f033dSHerbert Xu }, { 35060840605eSJussi Kivilinna .alg = "lrw(camellia)", 35070840605eSJussi Kivilinna .test = alg_test_skcipher, 35080840605eSJussi Kivilinna .suite = { 350992a4c9feSEric Biggers .cipher = __VECS(camellia_lrw_tv_template) 35100840605eSJussi Kivilinna } 35110840605eSJussi Kivilinna }, { 35129b8b0405SJohannes Goetzfried .alg = "lrw(cast6)", 35139b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 35149b8b0405SJohannes Goetzfried .suite = { 351592a4c9feSEric Biggers .cipher = __VECS(cast6_lrw_tv_template) 35169b8b0405SJohannes Goetzfried } 35179b8b0405SJohannes Goetzfried }, { 3518d7bfc0faSJussi Kivilinna .alg = "lrw(serpent)", 3519d7bfc0faSJussi Kivilinna .test = alg_test_skcipher, 3520d7bfc0faSJussi Kivilinna .suite = { 352192a4c9feSEric Biggers .cipher = __VECS(serpent_lrw_tv_template) 3522d7bfc0faSJussi Kivilinna } 3523d7bfc0faSJussi Kivilinna }, { 35240b2a1551SJussi Kivilinna .alg = "lrw(twofish)", 35250b2a1551SJussi Kivilinna .test = alg_test_skcipher, 35260b2a1551SJussi Kivilinna .suite = { 352792a4c9feSEric Biggers .cipher = __VECS(tf_lrw_tv_template) 35280b2a1551SJussi Kivilinna } 35290b2a1551SJussi Kivilinna }, { 35301443cc9bSKOVACS Krisztian .alg = "lz4", 35311443cc9bSKOVACS Krisztian .test = alg_test_comp, 35321443cc9bSKOVACS Krisztian .fips_allowed = 1, 35331443cc9bSKOVACS Krisztian .suite = { 35341443cc9bSKOVACS Krisztian .comp = { 353521c8e720SArd Biesheuvel .comp = __VECS(lz4_comp_tv_template), 353621c8e720SArd Biesheuvel .decomp = __VECS(lz4_decomp_tv_template) 35371443cc9bSKOVACS Krisztian } 35381443cc9bSKOVACS Krisztian } 35391443cc9bSKOVACS Krisztian }, { 35401443cc9bSKOVACS Krisztian .alg = "lz4hc", 35411443cc9bSKOVACS Krisztian .test = alg_test_comp, 35421443cc9bSKOVACS Krisztian .fips_allowed = 1, 35431443cc9bSKOVACS Krisztian .suite = { 35441443cc9bSKOVACS Krisztian .comp = { 354521c8e720SArd Biesheuvel .comp = __VECS(lz4hc_comp_tv_template), 354621c8e720SArd Biesheuvel .decomp = __VECS(lz4hc_decomp_tv_template) 35471443cc9bSKOVACS Krisztian } 35481443cc9bSKOVACS Krisztian } 35491443cc9bSKOVACS Krisztian }, { 3550da7f033dSHerbert Xu .alg = "lzo", 3551da7f033dSHerbert Xu .test = alg_test_comp, 35520818904dSMilan Broz .fips_allowed = 1, 3553da7f033dSHerbert Xu .suite = { 3554da7f033dSHerbert Xu .comp = { 355521c8e720SArd Biesheuvel .comp = __VECS(lzo_comp_tv_template), 355621c8e720SArd Biesheuvel .decomp = __VECS(lzo_decomp_tv_template) 3557da7f033dSHerbert Xu } 3558da7f033dSHerbert Xu } 3559da7f033dSHerbert Xu }, { 3560da7f033dSHerbert Xu .alg = "md4", 3561da7f033dSHerbert Xu .test = alg_test_hash, 3562da7f033dSHerbert Xu .suite = { 356321c8e720SArd Biesheuvel .hash = __VECS(md4_tv_template) 3564da7f033dSHerbert Xu } 3565da7f033dSHerbert Xu }, { 3566da7f033dSHerbert Xu .alg = "md5", 3567da7f033dSHerbert Xu .test = alg_test_hash, 3568da7f033dSHerbert Xu .suite = { 356921c8e720SArd Biesheuvel .hash = __VECS(md5_tv_template) 3570da7f033dSHerbert Xu } 3571da7f033dSHerbert Xu }, { 3572da7f033dSHerbert Xu .alg = "michael_mic", 3573da7f033dSHerbert Xu .test = alg_test_hash, 3574da7f033dSHerbert Xu .suite = { 357521c8e720SArd Biesheuvel .hash = __VECS(michael_mic_tv_template) 3576da7f033dSHerbert Xu } 3577da7f033dSHerbert Xu }, { 35784feb4c59SOndrej Mosnacek .alg = "morus1280", 35794feb4c59SOndrej Mosnacek .test = alg_test_aead, 35804feb4c59SOndrej Mosnacek .suite = { 3581a0d608eeSEric Biggers .aead = __VECS(morus1280_tv_template) 35824feb4c59SOndrej Mosnacek } 35834feb4c59SOndrej Mosnacek }, { 35844feb4c59SOndrej Mosnacek .alg = "morus640", 35854feb4c59SOndrej Mosnacek .test = alg_test_aead, 35864feb4c59SOndrej Mosnacek .suite = { 3587a0d608eeSEric Biggers .aead = __VECS(morus640_tv_template) 35884feb4c59SOndrej Mosnacek } 35894feb4c59SOndrej Mosnacek }, { 359026609a21SEric Biggers .alg = "nhpoly1305", 359126609a21SEric Biggers .test = alg_test_hash, 359226609a21SEric Biggers .suite = { 359326609a21SEric Biggers .hash = __VECS(nhpoly1305_tv_template) 359426609a21SEric Biggers } 359526609a21SEric Biggers }, { 3596ba0e14acSPuneet Saxena .alg = "ofb(aes)", 3597ba0e14acSPuneet Saxena .test = alg_test_skcipher, 3598ba0e14acSPuneet Saxena .fips_allowed = 1, 3599ba0e14acSPuneet Saxena .suite = { 360092a4c9feSEric Biggers .cipher = __VECS(aes_ofb_tv_template) 3601ba0e14acSPuneet Saxena } 3602ba0e14acSPuneet Saxena }, { 3603a794d8d8SGilad Ben-Yossef /* Same as ofb(aes) except the key is stored in 3604a794d8d8SGilad Ben-Yossef * hardware secure memory which we reference by index 3605a794d8d8SGilad Ben-Yossef */ 3606a794d8d8SGilad Ben-Yossef .alg = "ofb(paes)", 3607a794d8d8SGilad Ben-Yossef .test = alg_test_null, 3608a794d8d8SGilad Ben-Yossef .fips_allowed = 1, 3609a794d8d8SGilad Ben-Yossef }, { 3610da7f033dSHerbert Xu .alg = "pcbc(fcrypt)", 36111aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3612da7f033dSHerbert Xu .suite = { 361392a4c9feSEric Biggers .cipher = __VECS(fcrypt_pcbc_tv_template) 3614da7f033dSHerbert Xu } 3615da7f033dSHerbert Xu }, { 36161207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha224)", 36171207107cSStephan Mueller .test = alg_test_null, 36181207107cSStephan Mueller .fips_allowed = 1, 36191207107cSStephan Mueller }, { 36201207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha256)", 36211207107cSStephan Mueller .test = alg_test_akcipher, 36221207107cSStephan Mueller .fips_allowed = 1, 36231207107cSStephan Mueller .suite = { 36241207107cSStephan Mueller .akcipher = __VECS(pkcs1pad_rsa_tv_template) 36251207107cSStephan Mueller } 36261207107cSStephan Mueller }, { 36271207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha384)", 36281207107cSStephan Mueller .test = alg_test_null, 36291207107cSStephan Mueller .fips_allowed = 1, 36301207107cSStephan Mueller }, { 36311207107cSStephan Mueller .alg = "pkcs1pad(rsa,sha512)", 36321207107cSStephan Mueller .test = alg_test_null, 36331207107cSStephan Mueller .fips_allowed = 1, 36341207107cSStephan Mueller }, { 3635eee9dc61SMartin Willi .alg = "poly1305", 3636eee9dc61SMartin Willi .test = alg_test_hash, 3637eee9dc61SMartin Willi .suite = { 363821c8e720SArd Biesheuvel .hash = __VECS(poly1305_tv_template) 3639eee9dc61SMartin Willi } 3640eee9dc61SMartin Willi }, { 3641da7f033dSHerbert Xu .alg = "rfc3686(ctr(aes))", 36421aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3643a1915d51SJarod Wilson .fips_allowed = 1, 3644da7f033dSHerbert Xu .suite = { 364592a4c9feSEric Biggers .cipher = __VECS(aes_ctr_rfc3686_tv_template) 3646da7f033dSHerbert Xu } 3647da7f033dSHerbert Xu }, { 36483f31a740SHerbert Xu .alg = "rfc4106(gcm(aes))", 364969435b94SAdrian Hoban .test = alg_test_aead, 3650db71f29aSJarod Wilson .fips_allowed = 1, 365169435b94SAdrian Hoban .suite = { 3652a0d608eeSEric Biggers .aead = __VECS(aes_gcm_rfc4106_tv_template) 365369435b94SAdrian Hoban } 365469435b94SAdrian Hoban }, { 3655544c436aSHerbert Xu .alg = "rfc4309(ccm(aes))", 36565d667322SJarod Wilson .test = alg_test_aead, 3657a1915d51SJarod Wilson .fips_allowed = 1, 36585d667322SJarod Wilson .suite = { 3659a0d608eeSEric Biggers .aead = __VECS(aes_ccm_rfc4309_tv_template) 36605d667322SJarod Wilson } 36615d667322SJarod Wilson }, { 3662bb68745eSHerbert Xu .alg = "rfc4543(gcm(aes))", 3663e9b7441aSJussi Kivilinna .test = alg_test_aead, 3664e9b7441aSJussi Kivilinna .suite = { 3665a0d608eeSEric Biggers .aead = __VECS(aes_gcm_rfc4543_tv_template) 3666e9b7441aSJussi Kivilinna } 3667e9b7441aSJussi Kivilinna }, { 3668af2b76b5SMartin Willi .alg = "rfc7539(chacha20,poly1305)", 3669af2b76b5SMartin Willi .test = alg_test_aead, 3670af2b76b5SMartin Willi .suite = { 3671a0d608eeSEric Biggers .aead = __VECS(rfc7539_tv_template) 3672af2b76b5SMartin Willi } 3673af2b76b5SMartin Willi }, { 36745900758dSMartin Willi .alg = "rfc7539esp(chacha20,poly1305)", 36755900758dSMartin Willi .test = alg_test_aead, 36765900758dSMartin Willi .suite = { 3677a0d608eeSEric Biggers .aead = __VECS(rfc7539esp_tv_template) 36785900758dSMartin Willi } 36795900758dSMartin Willi }, { 3680da7f033dSHerbert Xu .alg = "rmd128", 3681da7f033dSHerbert Xu .test = alg_test_hash, 3682da7f033dSHerbert Xu .suite = { 368321c8e720SArd Biesheuvel .hash = __VECS(rmd128_tv_template) 3684da7f033dSHerbert Xu } 3685da7f033dSHerbert Xu }, { 3686da7f033dSHerbert Xu .alg = "rmd160", 3687da7f033dSHerbert Xu .test = alg_test_hash, 3688da7f033dSHerbert Xu .suite = { 368921c8e720SArd Biesheuvel .hash = __VECS(rmd160_tv_template) 3690da7f033dSHerbert Xu } 3691da7f033dSHerbert Xu }, { 3692da7f033dSHerbert Xu .alg = "rmd256", 3693da7f033dSHerbert Xu .test = alg_test_hash, 3694da7f033dSHerbert Xu .suite = { 369521c8e720SArd Biesheuvel .hash = __VECS(rmd256_tv_template) 3696da7f033dSHerbert Xu } 3697da7f033dSHerbert Xu }, { 3698da7f033dSHerbert Xu .alg = "rmd320", 3699da7f033dSHerbert Xu .test = alg_test_hash, 3700da7f033dSHerbert Xu .suite = { 370121c8e720SArd Biesheuvel .hash = __VECS(rmd320_tv_template) 3702da7f033dSHerbert Xu } 3703da7f033dSHerbert Xu }, { 3704946cc463STadeusz Struk .alg = "rsa", 3705946cc463STadeusz Struk .test = alg_test_akcipher, 3706946cc463STadeusz Struk .fips_allowed = 1, 3707946cc463STadeusz Struk .suite = { 370821c8e720SArd Biesheuvel .akcipher = __VECS(rsa_tv_template) 3709946cc463STadeusz Struk } 3710946cc463STadeusz Struk }, { 3711da7f033dSHerbert Xu .alg = "salsa20", 37121aa4ecd9SHerbert Xu .test = alg_test_skcipher, 3713da7f033dSHerbert Xu .suite = { 371492a4c9feSEric Biggers .cipher = __VECS(salsa20_stream_tv_template) 3715da7f033dSHerbert Xu } 3716da7f033dSHerbert Xu }, { 3717da7f033dSHerbert Xu .alg = "sha1", 3718da7f033dSHerbert Xu .test = alg_test_hash, 3719a1915d51SJarod Wilson .fips_allowed = 1, 3720da7f033dSHerbert Xu .suite = { 372121c8e720SArd Biesheuvel .hash = __VECS(sha1_tv_template) 3722da7f033dSHerbert Xu } 3723da7f033dSHerbert Xu }, { 3724da7f033dSHerbert Xu .alg = "sha224", 3725da7f033dSHerbert Xu .test = alg_test_hash, 3726a1915d51SJarod Wilson .fips_allowed = 1, 3727da7f033dSHerbert Xu .suite = { 372821c8e720SArd Biesheuvel .hash = __VECS(sha224_tv_template) 3729da7f033dSHerbert Xu } 3730da7f033dSHerbert Xu }, { 3731da7f033dSHerbert Xu .alg = "sha256", 3732da7f033dSHerbert Xu .test = alg_test_hash, 3733a1915d51SJarod Wilson .fips_allowed = 1, 3734da7f033dSHerbert Xu .suite = { 373521c8e720SArd Biesheuvel .hash = __VECS(sha256_tv_template) 3736da7f033dSHerbert Xu } 3737da7f033dSHerbert Xu }, { 373879cc6ab8Sraveendra padasalagi .alg = "sha3-224", 373979cc6ab8Sraveendra padasalagi .test = alg_test_hash, 374079cc6ab8Sraveendra padasalagi .fips_allowed = 1, 374179cc6ab8Sraveendra padasalagi .suite = { 374221c8e720SArd Biesheuvel .hash = __VECS(sha3_224_tv_template) 374379cc6ab8Sraveendra padasalagi } 374479cc6ab8Sraveendra padasalagi }, { 374579cc6ab8Sraveendra padasalagi .alg = "sha3-256", 374679cc6ab8Sraveendra padasalagi .test = alg_test_hash, 374779cc6ab8Sraveendra padasalagi .fips_allowed = 1, 374879cc6ab8Sraveendra padasalagi .suite = { 374921c8e720SArd Biesheuvel .hash = __VECS(sha3_256_tv_template) 375079cc6ab8Sraveendra padasalagi } 375179cc6ab8Sraveendra padasalagi }, { 375279cc6ab8Sraveendra padasalagi .alg = "sha3-384", 375379cc6ab8Sraveendra padasalagi .test = alg_test_hash, 375479cc6ab8Sraveendra padasalagi .fips_allowed = 1, 375579cc6ab8Sraveendra padasalagi .suite = { 375621c8e720SArd Biesheuvel .hash = __VECS(sha3_384_tv_template) 375779cc6ab8Sraveendra padasalagi } 375879cc6ab8Sraveendra padasalagi }, { 375979cc6ab8Sraveendra padasalagi .alg = "sha3-512", 376079cc6ab8Sraveendra padasalagi .test = alg_test_hash, 376179cc6ab8Sraveendra padasalagi .fips_allowed = 1, 376279cc6ab8Sraveendra padasalagi .suite = { 376321c8e720SArd Biesheuvel .hash = __VECS(sha3_512_tv_template) 376479cc6ab8Sraveendra padasalagi } 376579cc6ab8Sraveendra padasalagi }, { 3766da7f033dSHerbert Xu .alg = "sha384", 3767da7f033dSHerbert Xu .test = alg_test_hash, 3768a1915d51SJarod Wilson .fips_allowed = 1, 3769da7f033dSHerbert Xu .suite = { 377021c8e720SArd Biesheuvel .hash = __VECS(sha384_tv_template) 3771da7f033dSHerbert Xu } 3772da7f033dSHerbert Xu }, { 3773da7f033dSHerbert Xu .alg = "sha512", 3774da7f033dSHerbert Xu .test = alg_test_hash, 3775a1915d51SJarod Wilson .fips_allowed = 1, 3776da7f033dSHerbert Xu .suite = { 377721c8e720SArd Biesheuvel .hash = __VECS(sha512_tv_template) 3778da7f033dSHerbert Xu } 3779da7f033dSHerbert Xu }, { 3780b7e27530SGilad Ben-Yossef .alg = "sm3", 3781b7e27530SGilad Ben-Yossef .test = alg_test_hash, 3782b7e27530SGilad Ben-Yossef .suite = { 3783b7e27530SGilad Ben-Yossef .hash = __VECS(sm3_tv_template) 3784b7e27530SGilad Ben-Yossef } 3785b7e27530SGilad Ben-Yossef }, { 378625a0b9d4SVitaly Chikunov .alg = "streebog256", 378725a0b9d4SVitaly Chikunov .test = alg_test_hash, 378825a0b9d4SVitaly Chikunov .suite = { 378925a0b9d4SVitaly Chikunov .hash = __VECS(streebog256_tv_template) 379025a0b9d4SVitaly Chikunov } 379125a0b9d4SVitaly Chikunov }, { 379225a0b9d4SVitaly Chikunov .alg = "streebog512", 379325a0b9d4SVitaly Chikunov .test = alg_test_hash, 379425a0b9d4SVitaly Chikunov .suite = { 379525a0b9d4SVitaly Chikunov .hash = __VECS(streebog512_tv_template) 379625a0b9d4SVitaly Chikunov } 379725a0b9d4SVitaly Chikunov }, { 3798da7f033dSHerbert Xu .alg = "tgr128", 3799da7f033dSHerbert Xu .test = alg_test_hash, 3800da7f033dSHerbert Xu .suite = { 380121c8e720SArd Biesheuvel .hash = __VECS(tgr128_tv_template) 3802da7f033dSHerbert Xu } 3803da7f033dSHerbert Xu }, { 3804da7f033dSHerbert Xu .alg = "tgr160", 3805da7f033dSHerbert Xu .test = alg_test_hash, 3806da7f033dSHerbert Xu .suite = { 380721c8e720SArd Biesheuvel .hash = __VECS(tgr160_tv_template) 3808da7f033dSHerbert Xu } 3809da7f033dSHerbert Xu }, { 3810da7f033dSHerbert Xu .alg = "tgr192", 3811da7f033dSHerbert Xu .test = alg_test_hash, 3812da7f033dSHerbert Xu .suite = { 381321c8e720SArd Biesheuvel .hash = __VECS(tgr192_tv_template) 3814da7f033dSHerbert Xu } 3815da7f033dSHerbert Xu }, { 3816ed331adaSEric Biggers .alg = "vmac64(aes)", 3817ed331adaSEric Biggers .test = alg_test_hash, 3818ed331adaSEric Biggers .suite = { 3819ed331adaSEric Biggers .hash = __VECS(vmac64_aes_tv_template) 3820ed331adaSEric Biggers } 3821ed331adaSEric Biggers }, { 3822da7f033dSHerbert Xu .alg = "wp256", 3823da7f033dSHerbert Xu .test = alg_test_hash, 3824da7f033dSHerbert Xu .suite = { 382521c8e720SArd Biesheuvel .hash = __VECS(wp256_tv_template) 3826da7f033dSHerbert Xu } 3827da7f033dSHerbert Xu }, { 3828da7f033dSHerbert Xu .alg = "wp384", 3829da7f033dSHerbert Xu .test = alg_test_hash, 3830da7f033dSHerbert Xu .suite = { 383121c8e720SArd Biesheuvel .hash = __VECS(wp384_tv_template) 3832da7f033dSHerbert Xu } 3833da7f033dSHerbert Xu }, { 3834da7f033dSHerbert Xu .alg = "wp512", 3835da7f033dSHerbert Xu .test = alg_test_hash, 3836da7f033dSHerbert Xu .suite = { 383721c8e720SArd Biesheuvel .hash = __VECS(wp512_tv_template) 3838da7f033dSHerbert Xu } 3839da7f033dSHerbert Xu }, { 3840da7f033dSHerbert Xu .alg = "xcbc(aes)", 3841da7f033dSHerbert Xu .test = alg_test_hash, 3842da7f033dSHerbert Xu .suite = { 384321c8e720SArd Biesheuvel .hash = __VECS(aes_xcbc128_tv_template) 3844da7f033dSHerbert Xu } 3845da7f033dSHerbert Xu }, { 3846aa762409SEric Biggers .alg = "xchacha12", 3847aa762409SEric Biggers .test = alg_test_skcipher, 3848aa762409SEric Biggers .suite = { 3849aa762409SEric Biggers .cipher = __VECS(xchacha12_tv_template) 3850aa762409SEric Biggers }, 3851aa762409SEric Biggers }, { 3852de61d7aeSEric Biggers .alg = "xchacha20", 3853de61d7aeSEric Biggers .test = alg_test_skcipher, 3854de61d7aeSEric Biggers .suite = { 3855de61d7aeSEric Biggers .cipher = __VECS(xchacha20_tv_template) 3856de61d7aeSEric Biggers }, 3857de61d7aeSEric Biggers }, { 3858da7f033dSHerbert Xu .alg = "xts(aes)", 38591aa4ecd9SHerbert Xu .test = alg_test_skcipher, 38602918aa8dSJarod Wilson .fips_allowed = 1, 3861da7f033dSHerbert Xu .suite = { 386292a4c9feSEric Biggers .cipher = __VECS(aes_xts_tv_template) 3863da7f033dSHerbert Xu } 38640c01aed5SGeert Uytterhoeven }, { 38650840605eSJussi Kivilinna .alg = "xts(camellia)", 38660840605eSJussi Kivilinna .test = alg_test_skcipher, 38670840605eSJussi Kivilinna .suite = { 386892a4c9feSEric Biggers .cipher = __VECS(camellia_xts_tv_template) 38690840605eSJussi Kivilinna } 38700840605eSJussi Kivilinna }, { 38719b8b0405SJohannes Goetzfried .alg = "xts(cast6)", 38729b8b0405SJohannes Goetzfried .test = alg_test_skcipher, 38739b8b0405SJohannes Goetzfried .suite = { 387492a4c9feSEric Biggers .cipher = __VECS(cast6_xts_tv_template) 38759b8b0405SJohannes Goetzfried } 38769b8b0405SJohannes Goetzfried }, { 387715f47ce5SGilad Ben-Yossef /* Same as xts(aes) except the key is stored in 387815f47ce5SGilad Ben-Yossef * hardware secure memory which we reference by index 387915f47ce5SGilad Ben-Yossef */ 388015f47ce5SGilad Ben-Yossef .alg = "xts(paes)", 388115f47ce5SGilad Ben-Yossef .test = alg_test_null, 388215f47ce5SGilad Ben-Yossef .fips_allowed = 1, 388315f47ce5SGilad Ben-Yossef }, { 388418be20b9SJussi Kivilinna .alg = "xts(serpent)", 388518be20b9SJussi Kivilinna .test = alg_test_skcipher, 388618be20b9SJussi Kivilinna .suite = { 388792a4c9feSEric Biggers .cipher = __VECS(serpent_xts_tv_template) 388818be20b9SJussi Kivilinna } 388918be20b9SJussi Kivilinna }, { 3890aed265b9SJussi Kivilinna .alg = "xts(twofish)", 3891aed265b9SJussi Kivilinna .test = alg_test_skcipher, 3892aed265b9SJussi Kivilinna .suite = { 389392a4c9feSEric Biggers .cipher = __VECS(tf_xts_tv_template) 3894aed265b9SJussi Kivilinna } 3895a368f43dSGiovanni Cabiddu }, { 389615f47ce5SGilad Ben-Yossef .alg = "xts4096(paes)", 389715f47ce5SGilad Ben-Yossef .test = alg_test_null, 389815f47ce5SGilad Ben-Yossef .fips_allowed = 1, 389915f47ce5SGilad Ben-Yossef }, { 390015f47ce5SGilad Ben-Yossef .alg = "xts512(paes)", 390115f47ce5SGilad Ben-Yossef .test = alg_test_null, 390215f47ce5SGilad Ben-Yossef .fips_allowed = 1, 390315f47ce5SGilad Ben-Yossef }, { 3904a368f43dSGiovanni Cabiddu .alg = "zlib-deflate", 3905a368f43dSGiovanni Cabiddu .test = alg_test_comp, 3906a368f43dSGiovanni Cabiddu .fips_allowed = 1, 3907a368f43dSGiovanni Cabiddu .suite = { 3908a368f43dSGiovanni Cabiddu .comp = { 3909a368f43dSGiovanni Cabiddu .comp = __VECS(zlib_deflate_comp_tv_template), 3910a368f43dSGiovanni Cabiddu .decomp = __VECS(zlib_deflate_decomp_tv_template) 3911a368f43dSGiovanni Cabiddu } 3912a368f43dSGiovanni Cabiddu } 3913d28fc3dbSNick Terrell }, { 3914d28fc3dbSNick Terrell .alg = "zstd", 3915d28fc3dbSNick Terrell .test = alg_test_comp, 3916d28fc3dbSNick Terrell .fips_allowed = 1, 3917d28fc3dbSNick Terrell .suite = { 3918d28fc3dbSNick Terrell .comp = { 3919d28fc3dbSNick Terrell .comp = __VECS(zstd_comp_tv_template), 3920d28fc3dbSNick Terrell .decomp = __VECS(zstd_decomp_tv_template) 3921d28fc3dbSNick Terrell } 3922d28fc3dbSNick Terrell } 3923da7f033dSHerbert Xu } 3924da7f033dSHerbert Xu }; 3925da7f033dSHerbert Xu 39263f47a03dSEric Biggers static void alg_check_test_descs_order(void) 39275714758bSJussi Kivilinna { 39285714758bSJussi Kivilinna int i; 39295714758bSJussi Kivilinna 39305714758bSJussi Kivilinna for (i = 1; i < ARRAY_SIZE(alg_test_descs); i++) { 39315714758bSJussi Kivilinna int diff = strcmp(alg_test_descs[i - 1].alg, 39325714758bSJussi Kivilinna alg_test_descs[i].alg); 39335714758bSJussi Kivilinna 39345714758bSJussi Kivilinna if (WARN_ON(diff > 0)) { 39355714758bSJussi Kivilinna pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n", 39365714758bSJussi Kivilinna alg_test_descs[i - 1].alg, 39375714758bSJussi Kivilinna alg_test_descs[i].alg); 39385714758bSJussi Kivilinna } 39395714758bSJussi Kivilinna 39405714758bSJussi Kivilinna if (WARN_ON(diff == 0)) { 39415714758bSJussi Kivilinna pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n", 39425714758bSJussi Kivilinna alg_test_descs[i].alg); 39435714758bSJussi Kivilinna } 39445714758bSJussi Kivilinna } 39455714758bSJussi Kivilinna } 39465714758bSJussi Kivilinna 39473f47a03dSEric Biggers static void alg_check_testvec_configs(void) 39483f47a03dSEric Biggers { 39494e7babbaSEric Biggers int i; 39504e7babbaSEric Biggers 39514e7babbaSEric Biggers for (i = 0; i < ARRAY_SIZE(default_cipher_testvec_configs); i++) 39524e7babbaSEric Biggers WARN_ON(!valid_testvec_config( 39534e7babbaSEric Biggers &default_cipher_testvec_configs[i])); 39544cc2dcf9SEric Biggers 39554cc2dcf9SEric Biggers for (i = 0; i < ARRAY_SIZE(default_hash_testvec_configs); i++) 39564cc2dcf9SEric Biggers WARN_ON(!valid_testvec_config( 39574cc2dcf9SEric Biggers &default_hash_testvec_configs[i])); 39583f47a03dSEric Biggers } 39593f47a03dSEric Biggers 39603f47a03dSEric Biggers static void testmgr_onetime_init(void) 39613f47a03dSEric Biggers { 39623f47a03dSEric Biggers alg_check_test_descs_order(); 39633f47a03dSEric Biggers alg_check_testvec_configs(); 39645b2706a4SEric Biggers 39655b2706a4SEric Biggers #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS 39665b2706a4SEric Biggers pr_warn("alg: extra crypto tests enabled. This is intended for developer use only.\n"); 39675b2706a4SEric Biggers #endif 39683f47a03dSEric Biggers } 39693f47a03dSEric Biggers 39701aa4ecd9SHerbert Xu static int alg_find_test(const char *alg) 3971da7f033dSHerbert Xu { 3972da7f033dSHerbert Xu int start = 0; 3973da7f033dSHerbert Xu int end = ARRAY_SIZE(alg_test_descs); 3974da7f033dSHerbert Xu 3975da7f033dSHerbert Xu while (start < end) { 3976da7f033dSHerbert Xu int i = (start + end) / 2; 3977da7f033dSHerbert Xu int diff = strcmp(alg_test_descs[i].alg, alg); 3978da7f033dSHerbert Xu 3979da7f033dSHerbert Xu if (diff > 0) { 3980da7f033dSHerbert Xu end = i; 3981da7f033dSHerbert Xu continue; 3982da7f033dSHerbert Xu } 3983da7f033dSHerbert Xu 3984da7f033dSHerbert Xu if (diff < 0) { 3985da7f033dSHerbert Xu start = i + 1; 3986da7f033dSHerbert Xu continue; 3987da7f033dSHerbert Xu } 3988da7f033dSHerbert Xu 39891aa4ecd9SHerbert Xu return i; 3990da7f033dSHerbert Xu } 3991da7f033dSHerbert Xu 39921aa4ecd9SHerbert Xu return -1; 39931aa4ecd9SHerbert Xu } 39941aa4ecd9SHerbert Xu 39951aa4ecd9SHerbert Xu int alg_test(const char *driver, const char *alg, u32 type, u32 mask) 39961aa4ecd9SHerbert Xu { 39971aa4ecd9SHerbert Xu int i; 3998a68f6610SHerbert Xu int j; 3999d12d6b6dSNeil Horman int rc; 40001aa4ecd9SHerbert Xu 40019e5c9fe4SRichard W.M. Jones if (!fips_enabled && notests) { 40029e5c9fe4SRichard W.M. Jones printk_once(KERN_INFO "alg: self-tests disabled\n"); 40039e5c9fe4SRichard W.M. Jones return 0; 40049e5c9fe4SRichard W.M. Jones } 40059e5c9fe4SRichard W.M. Jones 40063f47a03dSEric Biggers DO_ONCE(testmgr_onetime_init); 40075714758bSJussi Kivilinna 40081aa4ecd9SHerbert Xu if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) { 40091aa4ecd9SHerbert Xu char nalg[CRYPTO_MAX_ALG_NAME]; 40101aa4ecd9SHerbert Xu 40111aa4ecd9SHerbert Xu if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >= 40121aa4ecd9SHerbert Xu sizeof(nalg)) 40131aa4ecd9SHerbert Xu return -ENAMETOOLONG; 40141aa4ecd9SHerbert Xu 40151aa4ecd9SHerbert Xu i = alg_find_test(nalg); 40161aa4ecd9SHerbert Xu if (i < 0) 40171aa4ecd9SHerbert Xu goto notest; 40181aa4ecd9SHerbert Xu 4019a3bef3a3SJarod Wilson if (fips_enabled && !alg_test_descs[i].fips_allowed) 4020a3bef3a3SJarod Wilson goto non_fips_alg; 4021a3bef3a3SJarod Wilson 4022941fb328SJarod Wilson rc = alg_test_cipher(alg_test_descs + i, driver, type, mask); 4023941fb328SJarod Wilson goto test_done; 40241aa4ecd9SHerbert Xu } 40251aa4ecd9SHerbert Xu 40261aa4ecd9SHerbert Xu i = alg_find_test(alg); 4027a68f6610SHerbert Xu j = alg_find_test(driver); 4028a68f6610SHerbert Xu if (i < 0 && j < 0) 40291aa4ecd9SHerbert Xu goto notest; 40301aa4ecd9SHerbert Xu 4031a68f6610SHerbert Xu if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) || 4032a68f6610SHerbert Xu (j >= 0 && !alg_test_descs[j].fips_allowed))) 4033a3bef3a3SJarod Wilson goto non_fips_alg; 4034a3bef3a3SJarod Wilson 4035a68f6610SHerbert Xu rc = 0; 4036a68f6610SHerbert Xu if (i >= 0) 4037a68f6610SHerbert Xu rc |= alg_test_descs[i].test(alg_test_descs + i, driver, 40381aa4ecd9SHerbert Xu type, mask); 4039032c8cacSCristian Stoica if (j >= 0 && j != i) 4040a68f6610SHerbert Xu rc |= alg_test_descs[j].test(alg_test_descs + j, driver, 4041a68f6610SHerbert Xu type, mask); 4042a68f6610SHerbert Xu 4043941fb328SJarod Wilson test_done: 4044d12d6b6dSNeil Horman if (fips_enabled && rc) 4045d12d6b6dSNeil Horman panic("%s: %s alg self test failed in fips mode!\n", driver, alg); 4046d12d6b6dSNeil Horman 404729ecd4abSJarod Wilson if (fips_enabled && !rc) 40483e8cffd4SMasanari Iida pr_info("alg: self-tests for %s (%s) passed\n", driver, alg); 404929ecd4abSJarod Wilson 4050d12d6b6dSNeil Horman return rc; 40511aa4ecd9SHerbert Xu 40521aa4ecd9SHerbert Xu notest: 4053da7f033dSHerbert Xu printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver); 4054da7f033dSHerbert Xu return 0; 4055a3bef3a3SJarod Wilson non_fips_alg: 4056a3bef3a3SJarod Wilson return -EINVAL; 4057da7f033dSHerbert Xu } 40580b767f96SAlexander Shishkin 4059326a6346SHerbert Xu #endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */ 40600b767f96SAlexander Shishkin 4061da7f033dSHerbert Xu EXPORT_SYMBOL_GPL(alg_test); 4062