1 /* SPDX-License-Identifier: GPL-2.0 2 * 3 * Copyright (C) 2022 Red Hat, Inc. 4 * Author: Vladis Dronov <vdronoff@gmail.com> 5 */ 6 7 #include <asm/elf.h> 8 #include <asm/uaccess.h> 9 #include <asm/smp.h> 10 #include <crypto/skcipher.h> 11 #include <crypto/akcipher.h> 12 #include <crypto/acompress.h> 13 #include <crypto/rng.h> 14 #include <crypto/drbg.h> 15 #include <crypto/kpp.h> 16 #include <crypto/internal/simd.h> 17 #include <crypto/chacha.h> 18 #include <crypto/aead.h> 19 #include <crypto/hash.h> 20 #include <linux/crypto.h> 21 #include <linux/debugfs.h> 22 #include <linux/delay.h> 23 #include <linux/err.h> 24 #include <linux/fs.h> 25 #include <linux/fips.h> 26 #include <linux/kernel.h> 27 #include <linux/kthread.h> 28 #include <linux/module.h> 29 #include <linux/sched.h> 30 #include <linux/scatterlist.h> 31 #include <linux/time.h> 32 #include <linux/vmalloc.h> 33 #include <linux/zlib.h> 34 #include <linux/once.h> 35 #include <linux/random.h> 36 #include <linux/slab.h> 37 #include <linux/string.h> 38 39 static unsigned int data_size __read_mostly = 256; 40 static unsigned int debug __read_mostly = 0; 41 42 /* tie all skcipher structures together */ 43 struct skcipher_def { 44 struct scatterlist sginp, sgout; 45 struct crypto_skcipher *tfm; 46 struct skcipher_request *req; 47 struct crypto_wait wait; 48 }; 49 50 /* Perform cipher operations with the chacha lib */ 51 static int test_lib_chacha(u8 *revert, u8 *cipher, u8 *plain) 52 { 53 u32 chacha_state[CHACHA_STATE_WORDS]; 54 u8 iv[16], key[32]; 55 u64 start, end; 56 57 memset(key, 'X', sizeof(key)); 58 memset(iv, 'I', sizeof(iv)); 59 60 if (debug) { 61 print_hex_dump(KERN_INFO, "key: ", DUMP_PREFIX_OFFSET, 62 16, 1, key, 32, 1); 63 64 print_hex_dump(KERN_INFO, "iv: ", DUMP_PREFIX_OFFSET, 65 16, 1, iv, 16, 1); 66 } 67 68 /* Encrypt */ 69 chacha_init_arch(chacha_state, (u32*)key, iv); 70 71 start = ktime_get_ns(); 72 chacha_crypt_arch(chacha_state, cipher, plain, data_size, 20); 73 end = ktime_get_ns(); 74 75 76 if (debug) 77 print_hex_dump(KERN_INFO, "encr:", DUMP_PREFIX_OFFSET, 78 16, 1, cipher, 79 (data_size > 64 ? 64 : data_size), 1); 80 81 pr_info("lib encryption took: %lld nsec", end - start); 82 83 /* Decrypt */ 84 chacha_init_arch(chacha_state, (u32 *)key, iv); 85 86 start = ktime_get_ns(); 87 chacha_crypt_arch(chacha_state, revert, cipher, data_size, 20); 88 end = ktime_get_ns(); 89 90 if (debug) 91 print_hex_dump(KERN_INFO, "decr:", DUMP_PREFIX_OFFSET, 92 16, 1, revert, 93 (data_size > 64 ? 64 : data_size), 1); 94 95 pr_info("lib decryption took: %lld nsec", end - start); 96 97 return 0; 98 } 99 100 /* Perform cipher operations with skcipher */ 101 static unsigned int test_skcipher_encdec(struct skcipher_def *sk, 102 int enc) 103 { 104 int rc; 105 106 if (enc) { 107 rc = crypto_wait_req(crypto_skcipher_encrypt(sk->req), 108 &sk->wait); 109 if (rc) 110 pr_info("skcipher encrypt returned with result" 111 "%d\n", rc); 112 } 113 else 114 { 115 rc = crypto_wait_req(crypto_skcipher_decrypt(sk->req), 116 &sk->wait); 117 if (rc) 118 pr_info("skcipher decrypt returned with result" 119 "%d\n", rc); 120 } 121 122 return rc; 123 } 124 125 /* Initialize and trigger cipher operations */ 126 static int test_skcipher(char *name, u8 *revert, u8 *cipher, u8 *plain) 127 { 128 struct skcipher_def sk; 129 struct crypto_skcipher *skcipher = NULL; 130 struct skcipher_request *req = NULL; 131 u8 iv[16], key[32]; 132 u64 start, end; 133 int ret = -EFAULT; 134 135 skcipher = crypto_alloc_skcipher(name, 0, 0); 136 if (IS_ERR(skcipher)) { 137 pr_info("could not allocate skcipher %s handle\n", name); 138 return PTR_ERR(skcipher); 139 } 140 141 req = skcipher_request_alloc(skcipher, GFP_KERNEL); 142 if (!req) { 143 pr_info("could not allocate skcipher request\n"); 144 ret = -ENOMEM; 145 goto out; 146 } 147 148 skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 149 crypto_req_done, 150 &sk.wait); 151 152 memset(key, 'X', sizeof(key)); 153 memset(iv, 'I', sizeof(iv)); 154 155 if (crypto_skcipher_setkey(skcipher, key, 32)) { 156 pr_info("key could not be set\n"); 157 ret = -EAGAIN; 158 goto out; 159 } 160 161 if (debug) { 162 print_hex_dump(KERN_INFO, "key: ", DUMP_PREFIX_OFFSET, 163 16, 1, key, 32, 1); 164 165 print_hex_dump(KERN_INFO, "iv: ", DUMP_PREFIX_OFFSET, 166 16, 1, iv, 16, 1); 167 } 168 169 sk.tfm = skcipher; 170 sk.req = req; 171 172 /* Encrypt in one pass */ 173 sg_init_one(&sk.sginp, plain, data_size); 174 sg_init_one(&sk.sgout, cipher, data_size); 175 skcipher_request_set_crypt(req, &sk.sginp, &sk.sgout, 176 data_size, iv); 177 crypto_init_wait(&sk.wait); 178 179 /* Encrypt data */ 180 start = ktime_get_ns(); 181 ret = test_skcipher_encdec(&sk, 1); 182 end = ktime_get_ns(); 183 184 if (ret) 185 goto out; 186 187 pr_info("%s tfm encryption successful, took %lld nsec\n", name, end - start); 188 189 if (debug) 190 print_hex_dump(KERN_INFO, "encr:", DUMP_PREFIX_OFFSET, 191 16, 1, cipher, 192 (data_size > 64 ? 64 : data_size), 1); 193 194 /* Prepare for decryption */ 195 memset(iv, 'I', sizeof(iv)); 196 197 sg_init_one(&sk.sginp, cipher, data_size); 198 sg_init_one(&sk.sgout, revert, data_size); 199 skcipher_request_set_crypt(req, &sk.sginp, &sk.sgout, 200 data_size, iv); 201 crypto_init_wait(&sk.wait); 202 203 /* Decrypt data */ 204 start = ktime_get_ns(); 205 ret = test_skcipher_encdec(&sk, 0); 206 end = ktime_get_ns(); 207 208 if (ret) 209 goto out; 210 211 pr_info("%s tfm decryption successful, took %lld nsec\n", name, end - start); 212 213 if (debug) 214 print_hex_dump(KERN_INFO, "decr:", DUMP_PREFIX_OFFSET, 215 16, 1, revert, 216 (data_size > 64 ? 64 : data_size), 1); 217 218 /* Dump some internal skcipher data */ 219 if (debug) 220 pr_info("skcipher %s: cryptlen %d blksize %d stride %d " 221 "ivsize %d alignmask 0x%x\n", 222 name, sk.req->cryptlen, 223 crypto_skcipher_blocksize(sk.tfm), 224 crypto_skcipher_alg(sk.tfm)->walksize, 225 crypto_skcipher_ivsize(sk.tfm), 226 crypto_skcipher_alignmask(sk.tfm)); 227 228 out: 229 if (skcipher) 230 crypto_free_skcipher(skcipher); 231 if (req) 232 skcipher_request_free(req); 233 return ret; 234 } 235 236 static int __init chacha_s390_test_init(void) 237 { 238 u8 *plain = NULL, *revert = NULL; 239 u8 *cipher_generic = NULL, *cipher_s390 = NULL; 240 int ret = -1; 241 242 pr_info("s390 ChaCha20 test module: size=%d debug=%d\n", 243 data_size, debug); 244 245 /* Allocate and fill buffers */ 246 plain = vmalloc(data_size); 247 if (!plain) { 248 pr_info("could not allocate plain buffer\n"); 249 ret = -2; 250 goto out; 251 } 252 memset(plain, 'a', data_size); 253 get_random_bytes(plain, (data_size > 256 ? 256 : data_size)); 254 255 cipher_generic = vmalloc(data_size); 256 if (!cipher_generic) { 257 pr_info("could not allocate cipher_generic buffer\n"); 258 ret = -2; 259 goto out; 260 } 261 memset(cipher_generic, 0, data_size); 262 263 cipher_s390 = vmalloc(data_size); 264 if (!cipher_s390) { 265 pr_info("could not allocate cipher_s390 buffer\n"); 266 ret = -2; 267 goto out; 268 } 269 memset(cipher_s390, 0, data_size); 270 271 revert = vmalloc(data_size); 272 if (!revert) { 273 pr_info("could not allocate revert buffer\n"); 274 ret = -2; 275 goto out; 276 } 277 memset(revert, 0, data_size); 278 279 if (debug) 280 print_hex_dump(KERN_INFO, "src: ", DUMP_PREFIX_OFFSET, 281 16, 1, plain, 282 (data_size > 64 ? 64 : data_size), 1); 283 284 /* Use chacha20 generic */ 285 ret = test_skcipher("chacha20-generic", revert, cipher_generic, plain); 286 if (ret) 287 goto out; 288 289 if (memcmp(plain, revert, data_size)) { 290 pr_info("generic en/decryption check FAILED\n"); 291 ret = -2; 292 goto out; 293 } 294 else 295 pr_info("generic en/decryption check OK\n"); 296 297 memset(revert, 0, data_size); 298 299 /* Use chacha20 s390 */ 300 ret = test_skcipher("chacha20-s390", revert, cipher_s390, plain); 301 if (ret) 302 goto out; 303 304 if (memcmp(plain, revert, data_size)) { 305 pr_info("s390 en/decryption check FAILED\n"); 306 ret = -2; 307 goto out; 308 } 309 else 310 pr_info("s390 en/decryption check OK\n"); 311 312 if (memcmp(cipher_generic, cipher_s390, data_size)) { 313 pr_info("s390 vs generic check FAILED\n"); 314 ret = -2; 315 goto out; 316 } 317 else 318 pr_info("s390 vs generic check OK\n"); 319 320 memset(cipher_s390, 0, data_size); 321 memset(revert, 0, data_size); 322 323 /* Use chacha20 lib */ 324 test_lib_chacha(revert, cipher_s390, plain); 325 326 if (memcmp(plain, revert, data_size)) { 327 pr_info("lib en/decryption check FAILED\n"); 328 ret = -2; 329 goto out; 330 } 331 else 332 pr_info("lib en/decryption check OK\n"); 333 334 if (memcmp(cipher_generic, cipher_s390, data_size)) { 335 pr_info("lib vs generic check FAILED\n"); 336 ret = -2; 337 goto out; 338 } 339 else 340 pr_info("lib vs generic check OK\n"); 341 342 pr_info("--- chacha20 s390 test end ---\n"); 343 344 out: 345 if (plain) 346 vfree(plain); 347 if (cipher_generic) 348 vfree(cipher_generic); 349 if (cipher_s390) 350 vfree(cipher_s390); 351 if (revert) 352 vfree(revert); 353 354 return -1; 355 } 356 357 static void __exit chacha_s390_test_exit(void) 358 { 359 pr_info("s390 ChaCha20 test module exit\n"); 360 } 361 362 module_param_named(size, data_size, uint, 0660); 363 module_param(debug, int, 0660); 364 MODULE_PARM_DESC(size, "Size of a plaintext"); 365 MODULE_PARM_DESC(debug, "Debug level (0=off,1=on)"); 366 367 module_init(chacha_s390_test_init); 368 module_exit(chacha_s390_test_exit); 369 370 MODULE_DESCRIPTION("s390 ChaCha20 self-test"); 371 MODULE_AUTHOR("Vladis Dronov <vdronoff@gmail.com>"); 372 MODULE_LICENSE("GPL v2"); 373