1
2
3
4
5
6
7
8
9#define KMSG_COMPONENT "prng"
10#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
11
12#include <linux/fs.h>
13#include <linux/fips.h>
14#include <linux/init.h>
15#include <linux/kernel.h>
16#include <linux/device.h>
17#include <linux/miscdevice.h>
18#include <linux/module.h>
19#include <linux/moduleparam.h>
20#include <linux/mutex.h>
21#include <linux/cpufeature.h>
22#include <linux/random.h>
23#include <linux/slab.h>
24#include <linux/sched/signal.h>
25
26#include <asm/debug.h>
27#include <linux/uaccess.h>
28#include <asm/timex.h>
29#include <asm/cpacf.h>
30
31MODULE_LICENSE("GPL");
32MODULE_AUTHOR("IBM Corporation");
33MODULE_DESCRIPTION("s390 PRNG interface");
34
35
36#define PRNG_MODE_AUTO 0
37#define PRNG_MODE_TDES 1
38#define PRNG_MODE_SHA512 2
39
40static unsigned int prng_mode = PRNG_MODE_AUTO;
41module_param_named(mode, prng_mode, int, 0);
42MODULE_PARM_DESC(prng_mode, "PRNG mode: 0 - auto, 1 - TDES, 2 - SHA512");
43
44
45#define PRNG_CHUNKSIZE_TDES_MIN 8
46#define PRNG_CHUNKSIZE_TDES_MAX (64*1024)
47#define PRNG_CHUNKSIZE_SHA512_MIN 64
48#define PRNG_CHUNKSIZE_SHA512_MAX (64*1024)
49
50static unsigned int prng_chunk_size = 256;
51module_param_named(chunksize, prng_chunk_size, int, 0);
52MODULE_PARM_DESC(prng_chunk_size, "PRNG read chunk size in bytes");
53
54
55#define PRNG_RESEED_LIMIT_TDES 4096
56#define PRNG_RESEED_LIMIT_TDES_LOWER 4096
57#define PRNG_RESEED_LIMIT_SHA512 100000
58#define PRNG_RESEED_LIMIT_SHA512_LOWER 10000
59
60static unsigned int prng_reseed_limit;
61module_param_named(reseed_limit, prng_reseed_limit, int, 0);
62MODULE_PARM_DESC(prng_reseed_limit, "PRNG reseed limit");
63
64static bool trng_available;
65
66
67
68
69
70
71static int prng_errorflag;
72
73#define PRNG_GEN_ENTROPY_FAILED 1
74#define PRNG_SELFTEST_FAILED 2
75#define PRNG_INSTANTIATE_FAILED 3
76#define PRNG_SEED_FAILED 4
77#define PRNG_RESEED_FAILED 5
78#define PRNG_GEN_FAILED 6
79
80struct prng_ws_s {
81 u8 parm_block[32];
82 u32 reseed_counter;
83 u64 byte_counter;
84};
85
86struct prno_ws_s {
87 u32 res;
88 u32 reseed_counter;
89 u64 stream_bytes;
90 u8 V[112];
91 u8 C[112];
92};
93
94struct prng_data_s {
95 struct mutex mutex;
96 union {
97 struct prng_ws_s prngws;
98 struct prno_ws_s prnows;
99 };
100 u8 *buf;
101 u32 rest;
102 u8 *prev;
103};
104
105static struct prng_data_s *prng_data;
106
107
108static const u8 initial_parm_block[32] __initconst = {
109 0x0F, 0x2B, 0x8E, 0x63, 0x8C, 0x8E, 0xD2, 0x52,
110 0x64, 0xB7, 0xA0, 0x7B, 0x75, 0x28, 0xB8, 0xF4,
111 0x75, 0x5F, 0xD2, 0xA6, 0x8D, 0x97, 0x11, 0xFF,
112 0x49, 0xD8, 0x23, 0xF3, 0x7E, 0x21, 0xEC, 0xA0 };
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135static int generate_entropy(u8 *ebuf, size_t nbytes)
136{
137 int n, ret = 0;
138 u8 *pg, pblock[80] = {
139
140 0x6A, 0x09, 0xE6, 0x67, 0xF3, 0xBC, 0xC9, 0x08,
141 0xBB, 0x67, 0xAE, 0x85, 0x84, 0xCA, 0xA7, 0x3B,
142 0x3C, 0x6E, 0xF3, 0x72, 0xFE, 0x94, 0xF8, 0x2B,
143 0xA5, 0x4F, 0xF5, 0x3A, 0x5F, 0x1D, 0x36, 0xF1,
144 0x51, 0x0E, 0x52, 0x7F, 0xAD, 0xE6, 0x82, 0xD1,
145 0x9B, 0x05, 0x68, 0x8C, 0x2B, 0x3E, 0x6C, 0x1F,
146 0x1F, 0x83, 0xD9, 0xAB, 0xFB, 0x41, 0xBD, 0x6B,
147 0x5B, 0xE0, 0xCD, 0x19, 0x13, 0x7E, 0x21, 0x79,
148
149 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
150 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00 };
151
152
153 pg = (u8 *) __get_free_page(GFP_KERNEL);
154 if (!pg) {
155 prng_errorflag = PRNG_GEN_ENTROPY_FAILED;
156 return -ENOMEM;
157 }
158
159
160 while (nbytes) {
161
162 get_random_bytes(pg, PAGE_SIZE / 2);
163
164 for (n = 0; n < 512; n++) {
165 int offset = (PAGE_SIZE / 2) + (n * 4) - 4;
166 u64 *p = (u64 *)(pg + offset);
167 *p ^= get_tod_clock_fast();
168 }
169
170 cpacf_klmd(CPACF_KLMD_SHA_512, pblock, pg, PAGE_SIZE);
171 n = (nbytes < 64) ? nbytes : 64;
172 memcpy(ebuf, pblock, n);
173 ret += n;
174 ebuf += n;
175 nbytes -= n;
176 }
177
178 memzero_explicit(pblock, sizeof(pblock));
179 memzero_explicit(pg, PAGE_SIZE);
180 free_page((unsigned long)pg);
181 return ret;
182}
183
184
185
186
187static void prng_tdes_add_entropy(void)
188{
189 __u64 entropy[4];
190 unsigned int i;
191
192 for (i = 0; i < 16; i++) {
193 cpacf_kmc(CPACF_KMC_PRNG, prng_data->prngws.parm_block,
194 (char *) entropy, (char *) entropy,
195 sizeof(entropy));
196 memcpy(prng_data->prngws.parm_block, entropy, sizeof(entropy));
197 }
198}
199
200
201static void prng_tdes_seed(int nbytes)
202{
203 char buf[16];
204 int i = 0;
205
206 BUG_ON(nbytes > sizeof(buf));
207
208 get_random_bytes(buf, nbytes);
209
210
211 while (nbytes >= 8) {
212 *((__u64 *)prng_data->prngws.parm_block) ^= *((__u64 *)(buf+i));
213 prng_tdes_add_entropy();
214 i += 8;
215 nbytes -= 8;
216 }
217 prng_tdes_add_entropy();
218 prng_data->prngws.reseed_counter = 0;
219}
220
221
222static int __init prng_tdes_instantiate(void)
223{
224 int datalen;
225
226 pr_debug("prng runs in TDES mode with "
227 "chunksize=%d and reseed_limit=%u\n",
228 prng_chunk_size, prng_reseed_limit);
229
230
231 datalen = sizeof(struct prng_data_s) + prng_chunk_size;
232 prng_data = kzalloc(datalen, GFP_KERNEL);
233 if (!prng_data) {
234 prng_errorflag = PRNG_INSTANTIATE_FAILED;
235 return -ENOMEM;
236 }
237 mutex_init(&prng_data->mutex);
238 prng_data->buf = ((u8 *)prng_data) + sizeof(struct prng_data_s);
239 memcpy(prng_data->prngws.parm_block, initial_parm_block, 32);
240
241
242 prng_tdes_seed(16);
243
244 return 0;
245}
246
247
248static void prng_tdes_deinstantiate(void)
249{
250 pr_debug("The prng module stopped "
251 "after running in triple DES mode\n");
252 kfree_sensitive(prng_data);
253}
254
255
256
257
258static int __init prng_sha512_selftest(void)
259{
260
261 static const u8 seed[] __initconst = {
262 0x6b, 0x50, 0xa7, 0xd8, 0xf8, 0xa5, 0x5d, 0x7a,
263 0x3d, 0xf8, 0xbb, 0x40, 0xbc, 0xc3, 0xb7, 0x22,
264 0xd8, 0x70, 0x8d, 0xe6, 0x7f, 0xda, 0x01, 0x0b,
265 0x03, 0xc4, 0xc8, 0x4d, 0x72, 0x09, 0x6f, 0x8c,
266 0x3e, 0xc6, 0x49, 0xcc, 0x62, 0x56, 0xd9, 0xfa,
267 0x31, 0xdb, 0x7a, 0x29, 0x04, 0xaa, 0xf0, 0x25 };
268 static const u8 V0[] __initconst = {
269 0x00, 0xad, 0xe3, 0x6f, 0x9a, 0x01, 0xc7, 0x76,
270 0x61, 0x34, 0x35, 0xf5, 0x4e, 0x24, 0x74, 0x22,
271 0x21, 0x9a, 0x29, 0x89, 0xc7, 0x93, 0x2e, 0x60,
272 0x1e, 0xe8, 0x14, 0x24, 0x8d, 0xd5, 0x03, 0xf1,
273 0x65, 0x5d, 0x08, 0x22, 0x72, 0xd5, 0xad, 0x95,
274 0xe1, 0x23, 0x1e, 0x8a, 0xa7, 0x13, 0xd9, 0x2b,
275 0x5e, 0xbc, 0xbb, 0x80, 0xab, 0x8d, 0xe5, 0x79,
276 0xab, 0x5b, 0x47, 0x4e, 0xdd, 0xee, 0x6b, 0x03,
277 0x8f, 0x0f, 0x5c, 0x5e, 0xa9, 0x1a, 0x83, 0xdd,
278 0xd3, 0x88, 0xb2, 0x75, 0x4b, 0xce, 0x83, 0x36,
279 0x57, 0x4b, 0xf1, 0x5c, 0xca, 0x7e, 0x09, 0xc0,
280 0xd3, 0x89, 0xc6, 0xe0, 0xda, 0xc4, 0x81, 0x7e,
281 0x5b, 0xf9, 0xe1, 0x01, 0xc1, 0x92, 0x05, 0xea,
282 0xf5, 0x2f, 0xc6, 0xc6, 0xc7, 0x8f, 0xbc, 0xf4 };
283 static const u8 C0[] __initconst = {
284 0x00, 0xf4, 0xa3, 0xe5, 0xa0, 0x72, 0x63, 0x95,
285 0xc6, 0x4f, 0x48, 0xd0, 0x8b, 0x5b, 0x5f, 0x8e,
286 0x6b, 0x96, 0x1f, 0x16, 0xed, 0xbc, 0x66, 0x94,
287 0x45, 0x31, 0xd7, 0x47, 0x73, 0x22, 0xa5, 0x86,
288 0xce, 0xc0, 0x4c, 0xac, 0x63, 0xb8, 0x39, 0x50,
289 0xbf, 0xe6, 0x59, 0x6c, 0x38, 0x58, 0x99, 0x1f,
290 0x27, 0xa7, 0x9d, 0x71, 0x2a, 0xb3, 0x7b, 0xf9,
291 0xfb, 0x17, 0x86, 0xaa, 0x99, 0x81, 0xaa, 0x43,
292 0xe4, 0x37, 0xd3, 0x1e, 0x6e, 0xe5, 0xe6, 0xee,
293 0xc2, 0xed, 0x95, 0x4f, 0x53, 0x0e, 0x46, 0x8a,
294 0xcc, 0x45, 0xa5, 0xdb, 0x69, 0x0d, 0x81, 0xc9,
295 0x32, 0x92, 0xbc, 0x8f, 0x33, 0xe6, 0xf6, 0x09,
296 0x7c, 0x8e, 0x05, 0x19, 0x0d, 0xf1, 0xb6, 0xcc,
297 0xf3, 0x02, 0x21, 0x90, 0x25, 0xec, 0xed, 0x0e };
298 static const u8 random[] __initconst = {
299 0x95, 0xb7, 0xf1, 0x7e, 0x98, 0x02, 0xd3, 0x57,
300 0x73, 0x92, 0xc6, 0xa9, 0xc0, 0x80, 0x83, 0xb6,
301 0x7d, 0xd1, 0x29, 0x22, 0x65, 0xb5, 0xf4, 0x2d,
302 0x23, 0x7f, 0x1c, 0x55, 0xbb, 0x9b, 0x10, 0xbf,
303 0xcf, 0xd8, 0x2c, 0x77, 0xa3, 0x78, 0xb8, 0x26,
304 0x6a, 0x00, 0x99, 0x14, 0x3b, 0x3c, 0x2d, 0x64,
305 0x61, 0x1e, 0xee, 0xb6, 0x9a, 0xcd, 0xc0, 0x55,
306 0x95, 0x7c, 0x13, 0x9e, 0x8b, 0x19, 0x0c, 0x7a,
307 0x06, 0x95, 0x5f, 0x2c, 0x79, 0x7c, 0x27, 0x78,
308 0xde, 0x94, 0x03, 0x96, 0xa5, 0x01, 0xf4, 0x0e,
309 0x91, 0x39, 0x6a, 0xcf, 0x8d, 0x7e, 0x45, 0xeb,
310 0xdb, 0xb5, 0x3b, 0xbf, 0x8c, 0x97, 0x52, 0x30,
311 0xd2, 0xf0, 0xff, 0x91, 0x06, 0xc7, 0x61, 0x19,
312 0xae, 0x49, 0x8e, 0x7f, 0xbc, 0x03, 0xd9, 0x0f,
313 0x8e, 0x4c, 0x51, 0x62, 0x7a, 0xed, 0x5c, 0x8d,
314 0x42, 0x63, 0xd5, 0xd2, 0xb9, 0x78, 0x87, 0x3a,
315 0x0d, 0xe5, 0x96, 0xee, 0x6d, 0xc7, 0xf7, 0xc2,
316 0x9e, 0x37, 0xee, 0xe8, 0xb3, 0x4c, 0x90, 0xdd,
317 0x1c, 0xf6, 0xa9, 0xdd, 0xb2, 0x2b, 0x4c, 0xbd,
318 0x08, 0x6b, 0x14, 0xb3, 0x5d, 0xe9, 0x3d, 0xa2,
319 0xd5, 0xcb, 0x18, 0x06, 0x69, 0x8c, 0xbd, 0x7b,
320 0xbb, 0x67, 0xbf, 0xe3, 0xd3, 0x1f, 0xd2, 0xd1,
321 0xdb, 0xd2, 0xa1, 0xe0, 0x58, 0xa3, 0xeb, 0x99,
322 0xd7, 0xe5, 0x1f, 0x1a, 0x93, 0x8e, 0xed, 0x5e,
323 0x1c, 0x1d, 0xe2, 0x3a, 0x6b, 0x43, 0x45, 0xd3,
324 0x19, 0x14, 0x09, 0xf9, 0x2f, 0x39, 0xb3, 0x67,
325 0x0d, 0x8d, 0xbf, 0xb6, 0x35, 0xd8, 0xe6, 0xa3,
326 0x69, 0x32, 0xd8, 0x10, 0x33, 0xd1, 0x44, 0x8d,
327 0x63, 0xb4, 0x03, 0xdd, 0xf8, 0x8e, 0x12, 0x1b,
328 0x6e, 0x81, 0x9a, 0xc3, 0x81, 0x22, 0x6c, 0x13,
329 0x21, 0xe4, 0xb0, 0x86, 0x44, 0xf6, 0x72, 0x7c,
330 0x36, 0x8c, 0x5a, 0x9f, 0x7a, 0x4b, 0x3e, 0xe2 };
331
332 u8 buf[sizeof(random)];
333 struct prno_ws_s ws;
334
335 memset(&ws, 0, sizeof(ws));
336
337
338 cpacf_prno(CPACF_PRNO_SHA512_DRNG_SEED,
339 &ws, NULL, 0, seed, sizeof(seed));
340
341
342 if (memcmp(ws.V, V0, sizeof(V0)) != 0
343 || memcmp(ws.C, C0, sizeof(C0)) != 0) {
344 pr_err("The prng self test state test "
345 "for the SHA-512 mode failed\n");
346 prng_errorflag = PRNG_SELFTEST_FAILED;
347 return -EIO;
348 }
349
350
351 cpacf_prno(CPACF_PRNO_SHA512_DRNG_GEN,
352 &ws, buf, sizeof(buf), NULL, 0);
353 cpacf_prno(CPACF_PRNO_SHA512_DRNG_GEN,
354 &ws, buf, sizeof(buf), NULL, 0);
355
356
357 if (memcmp(buf, random, sizeof(random)) != 0) {
358 pr_err("The prng self test data test "
359 "for the SHA-512 mode failed\n");
360 prng_errorflag = PRNG_SELFTEST_FAILED;
361 return -EIO;
362 }
363
364 return 0;
365}
366
367
368static int __init prng_sha512_instantiate(void)
369{
370 int ret, datalen, seedlen;
371 u8 seed[128 + 16];
372
373 pr_debug("prng runs in SHA-512 mode "
374 "with chunksize=%d and reseed_limit=%u\n",
375 prng_chunk_size, prng_reseed_limit);
376
377
378 datalen = sizeof(struct prng_data_s) + prng_chunk_size;
379 if (fips_enabled)
380 datalen += prng_chunk_size;
381 prng_data = kzalloc(datalen, GFP_KERNEL);
382 if (!prng_data) {
383 prng_errorflag = PRNG_INSTANTIATE_FAILED;
384 return -ENOMEM;
385 }
386 mutex_init(&prng_data->mutex);
387 prng_data->buf = ((u8 *)prng_data) + sizeof(struct prng_data_s);
388
389
390 ret = prng_sha512_selftest();
391 if (ret)
392 goto outfree;
393
394
395 if (trng_available) {
396
397
398
399
400
401 seedlen = 2 * 32;
402 cpacf_trng(NULL, 0, seed, seedlen);
403 } else {
404
405
406
407
408
409
410 seedlen = 2 * 64;
411 ret = generate_entropy(seed, seedlen);
412 if (ret != seedlen)
413 goto outfree;
414 }
415
416
417 store_tod_clock_ext((union tod_clock *)(seed + seedlen));
418 seedlen += 16;
419
420
421 cpacf_prno(CPACF_PRNO_SHA512_DRNG_SEED,
422 &prng_data->prnows, NULL, 0, seed, seedlen);
423 memzero_explicit(seed, sizeof(seed));
424
425
426
427 if (fips_enabled) {
428 prng_data->prev = prng_data->buf + prng_chunk_size;
429 cpacf_prno(CPACF_PRNO_SHA512_DRNG_GEN,
430 &prng_data->prnows,
431 prng_data->prev, prng_chunk_size, NULL, 0);
432 }
433
434 return 0;
435
436outfree:
437 kfree(prng_data);
438 return ret;
439}
440
441
442static void prng_sha512_deinstantiate(void)
443{
444 pr_debug("The prng module stopped after running in SHA-512 mode\n");
445 kfree_sensitive(prng_data);
446}
447
448
449static int prng_sha512_reseed(void)
450{
451 int ret, seedlen;
452 u8 seed[64];
453
454
455 if (trng_available) {
456
457 seedlen = 32;
458 cpacf_trng(NULL, 0, seed, seedlen);
459 } else {
460
461 seedlen = 64;
462 ret = generate_entropy(seed, seedlen);
463 if (ret != sizeof(seed))
464 return ret;
465 }
466
467
468 cpacf_prno(CPACF_PRNO_SHA512_DRNG_SEED,
469 &prng_data->prnows, NULL, 0, seed, seedlen);
470 memzero_explicit(seed, sizeof(seed));
471
472 return 0;
473}
474
475
476static int prng_sha512_generate(u8 *buf, size_t nbytes)
477{
478 int ret;
479
480
481 if (prng_data->prnows.reseed_counter > prng_reseed_limit) {
482 ret = prng_sha512_reseed();
483 if (ret)
484 return ret;
485 }
486
487
488 cpacf_prno(CPACF_PRNO_SHA512_DRNG_GEN,
489 &prng_data->prnows, buf, nbytes, NULL, 0);
490
491
492 if (fips_enabled) {
493 if (!memcmp(prng_data->prev, buf, nbytes)) {
494 prng_errorflag = PRNG_GEN_FAILED;
495 return -EILSEQ;
496 }
497 memcpy(prng_data->prev, buf, nbytes);
498 }
499
500 return nbytes;
501}
502
503
504
505
506static int prng_open(struct inode *inode, struct file *file)
507{
508 return nonseekable_open(inode, file);
509}
510
511
512static ssize_t prng_tdes_read(struct file *file, char __user *ubuf,
513 size_t nbytes, loff_t *ppos)
514{
515 int chunk, n, ret = 0;
516
517
518 if (mutex_lock_interruptible(&prng_data->mutex))
519 return -ERESTARTSYS;
520
521 while (nbytes) {
522 if (need_resched()) {
523 if (signal_pending(current)) {
524 if (ret == 0)
525 ret = -ERESTARTSYS;
526 break;
527 }
528
529 mutex_unlock(&prng_data->mutex);
530 schedule();
531
532 if (mutex_lock_interruptible(&prng_data->mutex)) {
533 if (ret == 0)
534 ret = -ERESTARTSYS;
535 return ret;
536 }
537 }
538
539
540
541
542
543 chunk = min_t(int, nbytes, prng_chunk_size);
544
545
546 n = (chunk + 7) & -8;
547
548 if (prng_data->prngws.reseed_counter > prng_reseed_limit)
549 prng_tdes_seed(8);
550
551
552 *((unsigned long long *)prng_data->buf) = get_tod_clock_fast();
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567 cpacf_kmc(CPACF_KMC_PRNG, prng_data->prngws.parm_block,
568 prng_data->buf, prng_data->buf, n);
569
570 prng_data->prngws.byte_counter += n;
571 prng_data->prngws.reseed_counter += n;
572
573 if (copy_to_user(ubuf, prng_data->buf, chunk)) {
574 ret = -EFAULT;
575 break;
576 }
577
578 nbytes -= chunk;
579 ret += chunk;
580 ubuf += chunk;
581 }
582
583
584 mutex_unlock(&prng_data->mutex);
585
586 return ret;
587}
588
589
590static ssize_t prng_sha512_read(struct file *file, char __user *ubuf,
591 size_t nbytes, loff_t *ppos)
592{
593 int n, ret = 0;
594 u8 *p;
595
596
597 if (prng_errorflag)
598 return -EPIPE;
599
600
601 if (mutex_lock_interruptible(&prng_data->mutex))
602 return -ERESTARTSYS;
603
604 while (nbytes) {
605 if (need_resched()) {
606 if (signal_pending(current)) {
607 if (ret == 0)
608 ret = -ERESTARTSYS;
609 break;
610 }
611
612 mutex_unlock(&prng_data->mutex);
613 schedule();
614
615 if (mutex_lock_interruptible(&prng_data->mutex)) {
616 if (ret == 0)
617 ret = -ERESTARTSYS;
618 return ret;
619 }
620 }
621 if (prng_data->rest) {
622
623 p = prng_data->buf + prng_chunk_size - prng_data->rest;
624 n = (nbytes < prng_data->rest) ?
625 nbytes : prng_data->rest;
626 prng_data->rest -= n;
627 } else {
628
629 p = prng_data->buf;
630 n = prng_sha512_generate(p, prng_chunk_size);
631 if (n < 0) {
632 ret = n;
633 break;
634 }
635 if (nbytes < prng_chunk_size) {
636 n = nbytes;
637 prng_data->rest = prng_chunk_size - n;
638 } else {
639 n = prng_chunk_size;
640 prng_data->rest = 0;
641 }
642 }
643 if (copy_to_user(ubuf, p, n)) {
644 ret = -EFAULT;
645 break;
646 }
647 memzero_explicit(p, n);
648 ubuf += n;
649 nbytes -= n;
650 ret += n;
651 }
652
653
654 mutex_unlock(&prng_data->mutex);
655
656 return ret;
657}
658
659
660
661
662static const struct file_operations prng_sha512_fops = {
663 .owner = THIS_MODULE,
664 .open = &prng_open,
665 .release = NULL,
666 .read = &prng_sha512_read,
667 .llseek = noop_llseek,
668};
669static const struct file_operations prng_tdes_fops = {
670 .owner = THIS_MODULE,
671 .open = &prng_open,
672 .release = NULL,
673 .read = &prng_tdes_read,
674 .llseek = noop_llseek,
675};
676
677
678static ssize_t prng_chunksize_show(struct device *dev,
679 struct device_attribute *attr,
680 char *buf)
681{
682 return scnprintf(buf, PAGE_SIZE, "%u\n", prng_chunk_size);
683}
684static DEVICE_ATTR(chunksize, 0444, prng_chunksize_show, NULL);
685
686
687static ssize_t prng_counter_show(struct device *dev,
688 struct device_attribute *attr,
689 char *buf)
690{
691 u64 counter;
692
693 if (mutex_lock_interruptible(&prng_data->mutex))
694 return -ERESTARTSYS;
695 if (prng_mode == PRNG_MODE_SHA512)
696 counter = prng_data->prnows.stream_bytes;
697 else
698 counter = prng_data->prngws.byte_counter;
699 mutex_unlock(&prng_data->mutex);
700
701 return scnprintf(buf, PAGE_SIZE, "%llu\n", counter);
702}
703static DEVICE_ATTR(byte_counter, 0444, prng_counter_show, NULL);
704
705
706static ssize_t prng_errorflag_show(struct device *dev,
707 struct device_attribute *attr,
708 char *buf)
709{
710 return scnprintf(buf, PAGE_SIZE, "%d\n", prng_errorflag);
711}
712static DEVICE_ATTR(errorflag, 0444, prng_errorflag_show, NULL);
713
714
715static ssize_t prng_mode_show(struct device *dev,
716 struct device_attribute *attr,
717 char *buf)
718{
719 if (prng_mode == PRNG_MODE_TDES)
720 return scnprintf(buf, PAGE_SIZE, "TDES\n");
721 else
722 return scnprintf(buf, PAGE_SIZE, "SHA512\n");
723}
724static DEVICE_ATTR(mode, 0444, prng_mode_show, NULL);
725
726
727static ssize_t prng_reseed_store(struct device *dev,
728 struct device_attribute *attr,
729 const char *buf, size_t count)
730{
731 if (mutex_lock_interruptible(&prng_data->mutex))
732 return -ERESTARTSYS;
733 prng_sha512_reseed();
734 mutex_unlock(&prng_data->mutex);
735
736 return count;
737}
738static DEVICE_ATTR(reseed, 0200, NULL, prng_reseed_store);
739
740
741static ssize_t prng_reseed_limit_show(struct device *dev,
742 struct device_attribute *attr,
743 char *buf)
744{
745 return scnprintf(buf, PAGE_SIZE, "%u\n", prng_reseed_limit);
746}
747static ssize_t prng_reseed_limit_store(struct device *dev,
748 struct device_attribute *attr,
749 const char *buf, size_t count)
750{
751 unsigned limit;
752
753 if (sscanf(buf, "%u\n", &limit) != 1)
754 return -EINVAL;
755
756 if (prng_mode == PRNG_MODE_SHA512) {
757 if (limit < PRNG_RESEED_LIMIT_SHA512_LOWER)
758 return -EINVAL;
759 } else {
760 if (limit < PRNG_RESEED_LIMIT_TDES_LOWER)
761 return -EINVAL;
762 }
763
764 prng_reseed_limit = limit;
765
766 return count;
767}
768static DEVICE_ATTR(reseed_limit, 0644,
769 prng_reseed_limit_show, prng_reseed_limit_store);
770
771
772static ssize_t prng_strength_show(struct device *dev,
773 struct device_attribute *attr,
774 char *buf)
775{
776 return scnprintf(buf, PAGE_SIZE, "256\n");
777}
778static DEVICE_ATTR(strength, 0444, prng_strength_show, NULL);
779
780static struct attribute *prng_sha512_dev_attrs[] = {
781 &dev_attr_errorflag.attr,
782 &dev_attr_chunksize.attr,
783 &dev_attr_byte_counter.attr,
784 &dev_attr_mode.attr,
785 &dev_attr_reseed.attr,
786 &dev_attr_reseed_limit.attr,
787 &dev_attr_strength.attr,
788 NULL
789};
790ATTRIBUTE_GROUPS(prng_sha512_dev);
791
792static struct attribute *prng_tdes_dev_attrs[] = {
793 &dev_attr_chunksize.attr,
794 &dev_attr_byte_counter.attr,
795 &dev_attr_mode.attr,
796 NULL
797};
798ATTRIBUTE_GROUPS(prng_tdes_dev);
799
800static struct miscdevice prng_sha512_dev = {
801 .name = "prandom",
802 .minor = MISC_DYNAMIC_MINOR,
803 .mode = 0644,
804 .fops = &prng_sha512_fops,
805 .groups = prng_sha512_dev_groups,
806};
807
808static struct miscdevice prng_tdes_dev = {
809 .name = "prandom",
810 .minor = MISC_DYNAMIC_MINOR,
811 .mode = 0644,
812 .fops = &prng_tdes_fops,
813 .groups = prng_tdes_dev_groups,
814};
815
816
817
818
819static int __init prng_init(void)
820{
821 int ret;
822
823
824 if (!cpacf_query_func(CPACF_KMC, CPACF_KMC_PRNG))
825 return -ENODEV;
826
827
828 if (cpacf_query_func(CPACF_PRNO, CPACF_PRNO_TRNG))
829 trng_available = true;
830
831
832 if (prng_mode != PRNG_MODE_TDES) {
833
834 if (!cpacf_query_func(CPACF_PRNO, CPACF_PRNO_SHA512_DRNG_GEN)) {
835 if (prng_mode == PRNG_MODE_SHA512) {
836 pr_err("The prng module cannot "
837 "start in SHA-512 mode\n");
838 return -ENODEV;
839 }
840 prng_mode = PRNG_MODE_TDES;
841 } else
842 prng_mode = PRNG_MODE_SHA512;
843 }
844
845 if (prng_mode == PRNG_MODE_SHA512) {
846
847
848
849 if (prng_chunk_size < PRNG_CHUNKSIZE_SHA512_MIN
850 || prng_chunk_size > PRNG_CHUNKSIZE_SHA512_MAX)
851 return -EINVAL;
852 prng_chunk_size = (prng_chunk_size + 0x3f) & ~0x3f;
853
854 if (prng_reseed_limit == 0)
855 prng_reseed_limit = PRNG_RESEED_LIMIT_SHA512;
856 else if (prng_reseed_limit < PRNG_RESEED_LIMIT_SHA512_LOWER)
857 return -EINVAL;
858
859 ret = prng_sha512_instantiate();
860 if (ret)
861 goto out;
862
863 ret = misc_register(&prng_sha512_dev);
864 if (ret) {
865 prng_sha512_deinstantiate();
866 goto out;
867 }
868
869 } else {
870
871
872
873 if (prng_chunk_size < PRNG_CHUNKSIZE_TDES_MIN
874 || prng_chunk_size > PRNG_CHUNKSIZE_TDES_MAX)
875 return -EINVAL;
876 prng_chunk_size = (prng_chunk_size + 0x07) & ~0x07;
877
878 if (prng_reseed_limit == 0)
879 prng_reseed_limit = PRNG_RESEED_LIMIT_TDES;
880 else if (prng_reseed_limit < PRNG_RESEED_LIMIT_TDES_LOWER)
881 return -EINVAL;
882
883 ret = prng_tdes_instantiate();
884 if (ret)
885 goto out;
886
887 ret = misc_register(&prng_tdes_dev);
888 if (ret) {
889 prng_tdes_deinstantiate();
890 goto out;
891 }
892 }
893
894out:
895 return ret;
896}
897
898
899static void __exit prng_exit(void)
900{
901 if (prng_mode == PRNG_MODE_SHA512) {
902 misc_deregister(&prng_sha512_dev);
903 prng_sha512_deinstantiate();
904 } else {
905 misc_deregister(&prng_tdes_dev);
906 prng_tdes_deinstantiate();
907 }
908}
909
910module_cpu_feature_match(MSA, prng_init);
911module_exit(prng_exit);
912