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
39static unsigned int data_size __read_mostly = 256;
40static unsigned int debug __read_mostly = 0;
41
42/* tie all skcipher structures together */
43struct 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 */
51static int test_lib_chacha(u8 *revert, u8 *cipher, u8 *plain)
52{
53 struct chacha_state chacha_state;
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, prefix_str: "key: ", prefix_type: DUMP_PREFIX_OFFSET,
62 rowsize: 16, groupsize: 1, buf: key, len: 32, ascii: 1);
63
64 print_hex_dump(KERN_INFO, prefix_str: "iv: ", prefix_type: DUMP_PREFIX_OFFSET,
65 rowsize: 16, groupsize: 1, buf: iv, len: 16, ascii: 1);
66 }
67
68 /* Encrypt */
69 chacha_init(state: &chacha_state, key: (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, prefix_str: "encr:", prefix_type: DUMP_PREFIX_OFFSET,
78 rowsize: 16, groupsize: 1, buf: cipher,
79 len: (data_size > 64 ? 64 : data_size), ascii: 1);
80
81 pr_info("lib encryption took: %lld nsec", end - start);
82
83 /* Decrypt */
84 chacha_init(state: &chacha_state, key: (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, prefix_str: "decr:", prefix_type: DUMP_PREFIX_OFFSET,
92 rowsize: 16, groupsize: 1, buf: revert,
93 len: (data_size > 64 ? 64 : data_size), ascii: 1);
94
95 pr_info("lib decryption took: %lld nsec", end - start);
96
97 return 0;
98}
99
100/* Perform cipher operations with skcipher */
101static 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(err: crypto_skcipher_encrypt(req: sk->req),
108 wait: &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(err: crypto_skcipher_decrypt(req: sk->req),
116 wait: &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 */
126static 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(alg_name: name, type: 0, mask: 0);
136 if (IS_ERR(ptr: skcipher)) {
137 pr_info("could not allocate skcipher %s handle\n", name);
138 return PTR_ERR(ptr: 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 compl: crypto_req_done,
150 data: &sk.wait);
151
152 memset(key, 'X', sizeof(key));
153 memset(iv, 'I', sizeof(iv));
154
155 if (crypto_skcipher_setkey(tfm: skcipher, key, keylen: 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, prefix_str: "key: ", prefix_type: DUMP_PREFIX_OFFSET,
163 rowsize: 16, groupsize: 1, buf: key, len: 32, ascii: 1);
164
165 print_hex_dump(KERN_INFO, prefix_str: "iv: ", prefix_type: DUMP_PREFIX_OFFSET,
166 rowsize: 16, groupsize: 1, buf: iv, len: 16, ascii: 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, src: &sk.sginp, dst: &sk.sgout,
176 cryptlen: data_size, iv);
177 crypto_init_wait(wait: &sk.wait);
178
179 /* Encrypt data */
180 start = ktime_get_ns();
181 ret = test_skcipher_encdec(sk: &sk, enc: 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, prefix_str: "encr:", prefix_type: DUMP_PREFIX_OFFSET,
191 rowsize: 16, groupsize: 1, buf: cipher,
192 len: (data_size > 64 ? 64 : data_size), ascii: 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, src: &sk.sginp, dst: &sk.sgout,
200 cryptlen: data_size, iv);
201 crypto_init_wait(wait: &sk.wait);
202
203 /* Decrypt data */
204 start = ktime_get_ns();
205 ret = test_skcipher_encdec(sk: &sk, enc: 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, prefix_str: "decr:", prefix_type: DUMP_PREFIX_OFFSET,
215 rowsize: 16, groupsize: 1, buf: revert,
216 len: (data_size > 64 ? 64 : data_size), ascii: 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
228out:
229 if (skcipher)
230 crypto_free_skcipher(tfm: skcipher);
231 if (req)
232 skcipher_request_free(req);
233 return ret;
234}
235
236static 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(buf: plain, len: (data_size > 256 ? 256 : data_size));
254
255 cipher_generic = vzalloc(data_size);
256 if (!cipher_generic) {
257 pr_info("could not allocate cipher_generic buffer\n");
258 ret = -2;
259 goto out;
260 }
261
262 cipher_s390 = vzalloc(data_size);
263 if (!cipher_s390) {
264 pr_info("could not allocate cipher_s390 buffer\n");
265 ret = -2;
266 goto out;
267 }
268
269 revert = vzalloc(data_size);
270 if (!revert) {
271 pr_info("could not allocate revert buffer\n");
272 ret = -2;
273 goto out;
274 }
275
276 if (debug)
277 print_hex_dump(KERN_INFO, prefix_str: "src: ", prefix_type: DUMP_PREFIX_OFFSET,
278 rowsize: 16, groupsize: 1, buf: plain,
279 len: (data_size > 64 ? 64 : data_size), ascii: 1);
280
281 /* Use chacha20 generic */
282 ret = test_skcipher(name: "chacha20-generic", revert, cipher: cipher_generic, plain);
283 if (ret)
284 goto out;
285
286 if (memcmp(p: plain, q: revert, size: data_size)) {
287 pr_info("generic en/decryption check FAILED\n");
288 ret = -2;
289 goto out;
290 }
291 else
292 pr_info("generic en/decryption check OK\n");
293
294 memset(revert, 0, data_size);
295
296 /* Use chacha20 s390 */
297 ret = test_skcipher(name: "chacha20-s390", revert, cipher: cipher_s390, plain);
298 if (ret)
299 goto out;
300
301 if (memcmp(p: plain, q: revert, size: data_size)) {
302 pr_info("s390 en/decryption check FAILED\n");
303 ret = -2;
304 goto out;
305 }
306 else
307 pr_info("s390 en/decryption check OK\n");
308
309 if (memcmp(p: cipher_generic, q: cipher_s390, size: data_size)) {
310 pr_info("s390 vs generic check FAILED\n");
311 ret = -2;
312 goto out;
313 }
314 else
315 pr_info("s390 vs generic check OK\n");
316
317 memset(cipher_s390, 0, data_size);
318 memset(revert, 0, data_size);
319
320 /* Use chacha20 lib */
321 test_lib_chacha(revert, cipher: cipher_s390, plain);
322
323 if (memcmp(p: plain, q: revert, size: data_size)) {
324 pr_info("lib en/decryption check FAILED\n");
325 ret = -2;
326 goto out;
327 }
328 else
329 pr_info("lib en/decryption check OK\n");
330
331 if (memcmp(p: cipher_generic, q: cipher_s390, size: data_size)) {
332 pr_info("lib vs generic check FAILED\n");
333 ret = -2;
334 goto out;
335 }
336 else
337 pr_info("lib vs generic check OK\n");
338
339 pr_info("--- chacha20 s390 test end ---\n");
340
341out:
342 if (plain)
343 vfree(addr: plain);
344 if (cipher_generic)
345 vfree(addr: cipher_generic);
346 if (cipher_s390)
347 vfree(addr: cipher_s390);
348 if (revert)
349 vfree(addr: revert);
350
351 return -1;
352}
353
354static void __exit chacha_s390_test_exit(void)
355{
356 pr_info("s390 ChaCha20 test module exit\n");
357}
358
359module_param_named(size, data_size, uint, 0660);
360module_param(debug, int, 0660);
361MODULE_PARM_DESC(size, "Size of a plaintext");
362MODULE_PARM_DESC(debug, "Debug level (0=off,1=on)");
363
364module_init(chacha_s390_test_init);
365module_exit(chacha_s390_test_exit);
366
367MODULE_DESCRIPTION("s390 ChaCha20 self-test");
368MODULE_AUTHOR("Vladis Dronov <vdronoff@gmail.com>");
369MODULE_LICENSE("GPL v2");
370

source code of linux/tools/testing/crypto/chacha20-s390/test-cipher.c