[S390] Support for s390 Pseudo Random Number Generator
[linux-2.6.git] / arch / s390 / crypto / prng.c
1 /*
2  * Copyright IBM Corp. 2006,2007
3  * Author(s): Jan Glauber <jan.glauber@de.ibm.com>
4  * Driver for the s390 pseudo random number generator
5  */
6 #include <linux/fs.h>
7 #include <linux/init.h>
8 #include <linux/kernel.h>
9 #include <linux/miscdevice.h>
10 #include <linux/module.h>
11 #include <linux/moduleparam.h>
12 #include <linux/random.h>
13 #include <asm/debug.h>
14 #include <asm/uaccess.h>
15
16 #include "crypt_s390.h"
17
18 MODULE_LICENSE("GPL");
19 MODULE_AUTHOR("Jan Glauber <jan.glauber@de.ibm.com>");
20 MODULE_DESCRIPTION("s390 PRNG interface");
21
22 static int prng_chunk_size = 256;
23 module_param(prng_chunk_size, int, S_IRUSR | S_IRGRP | S_IROTH);
24 MODULE_PARM_DESC(prng_chunk_size, "PRNG read chunk size in bytes");
25
26 static int prng_entropy_limit = 4096;
27 module_param(prng_entropy_limit, int, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
28 MODULE_PARM_DESC(prng_entropy_limit,
29         "PRNG add entropy after that much bytes were produced");
30
31 /*
32  * Any one who considers arithmetical methods of producing random digits is,
33  * of course, in a state of sin. -- John von Neumann
34  */
35
36 struct s390_prng_data {
37         unsigned long count; /* how many bytes were produced */
38         char *buf;
39 };
40
41 static struct s390_prng_data *p;
42
43 /* copied from libica, use a non-zero initial parameter block */
44 static unsigned char parm_block[32] = {
45 0x0F,0x2B,0x8E,0x63,0x8C,0x8E,0xD2,0x52,0x64,0xB7,0xA0,0x7B,0x75,0x28,0xB8,0xF4,
46 0x75,0x5F,0xD2,0xA6,0x8D,0x97,0x11,0xFF,0x49,0xD8,0x23,0xF3,0x7E,0x21,0xEC,0xA0,
47 };
48
49 static int prng_open(struct inode *inode, struct file *file)
50 {
51         return nonseekable_open(inode, file);
52 }
53
54 static void prng_add_entropy(void)
55 {
56         __u64 entropy[4];
57         unsigned int i;
58         int ret;
59
60         for (i = 0; i < 16; i++) {
61                 ret = crypt_s390_kmc(KMC_PRNG, parm_block, (char *)entropy,
62                                      (char *)entropy, sizeof(entropy));
63                 BUG_ON(ret < 0 || ret != sizeof(entropy));
64                 memcpy(parm_block, entropy, sizeof(entropy));
65         }
66 }
67
68 static void prng_seed(int nbytes)
69 {
70         char buf[16];
71         int i = 0;
72
73         BUG_ON(nbytes > 16);
74         get_random_bytes(buf, nbytes);
75
76         /* Add the entropy */
77         while (nbytes >= 8) {
78                 *((__u64 *)parm_block) ^= *((__u64 *)buf+i*8);
79                 prng_add_entropy();
80                 i += 8;
81                 nbytes -= 8;
82         }
83         prng_add_entropy();
84 }
85
86 static ssize_t prng_read(struct file *file, char __user *ubuf, size_t nbytes,
87                          loff_t *ppos)
88 {
89         int chunk, n;
90         int ret = 0;
91         int tmp;
92
93         /* nbytes can be arbitrary long, we spilt it into chunks */
94         while (nbytes) {
95                 /* same as in extract_entropy_user in random.c */
96                 if (need_resched()) {
97                         if (signal_pending(current)) {
98                                 if (ret == 0)
99                                         ret = -ERESTARTSYS;
100                                 break;
101                         }
102                         schedule();
103                 }
104
105                 /*
106                  * we lose some random bytes if an attacker issues
107                  * reads < 8 bytes, but we don't care
108                  */
109                 chunk = min_t(int, nbytes, prng_chunk_size);
110
111                 /* PRNG only likes multiples of 8 bytes */
112                 n = (chunk + 7) & -8;
113
114                 if (p->count > prng_entropy_limit)
115                         prng_seed(8);
116
117                 /* if the CPU supports PRNG stckf is present too */
118                 asm volatile(".insn     s,0xb27c0000,%0"
119                              : "=m" (*((unsigned long long *)p->buf)) : : "cc");
120
121                 /*
122                  * Beside the STCKF the input for the TDES-EDE is the output
123                  * of the last operation. We differ here from X9.17 since we
124                  * only store one timestamp into the buffer. Padding the whole
125                  * buffer with timestamps does not improve security, since
126                  * successive stckf have nearly constant offsets.
127                  * If an attacker knows the first timestamp it would be
128                  * trivial to guess the additional values. One timestamp
129                  * is therefore enough and still guarantees unique input values.
130                  *
131                  * Note: you can still get strict X9.17 conformity by setting
132                  * prng_chunk_size to 8 bytes.
133                 */
134                 tmp = crypt_s390_kmc(KMC_PRNG, parm_block, p->buf, p->buf, n);
135                 BUG_ON((tmp < 0) || (tmp != n));
136
137                 p->count += n;
138
139                 if (copy_to_user(ubuf, p->buf, chunk))
140                         return -EFAULT;
141
142                 nbytes -= chunk;
143                 ret += chunk;
144                 ubuf += chunk;
145         }
146         return ret;
147 }
148
149 static struct file_operations prng_fops = {
150         .owner          = THIS_MODULE,
151         .open           = &prng_open,
152         .release        = NULL,
153         .read           = &prng_read,
154 };
155
156 static struct miscdevice prng_dev = {
157         .name   = "prandom",
158         .minor  = MISC_DYNAMIC_MINOR,
159         .fops   = &prng_fops,
160 };
161
162 static int __init prng_init(void)
163 {
164         int ret;
165
166         /* check if the CPU has a PRNG */
167         if (!crypt_s390_func_available(KMC_PRNG))
168                 return -EOPNOTSUPP;
169
170         if (prng_chunk_size < 8)
171                 return -EINVAL;
172
173         p = kmalloc(sizeof(struct s390_prng_data), GFP_KERNEL);
174         if (!p)
175                 return -ENOMEM;
176         p->count = 0;
177
178         p->buf = kmalloc(prng_chunk_size, GFP_KERNEL);
179         if (!p->buf) {
180                 ret = -ENOMEM;
181                 goto out_free;
182         }
183
184         /* initialize the PRNG, add 128 bits of entropy */
185         prng_seed(16);
186
187         ret = misc_register(&prng_dev);
188         if (ret) {
189                 printk(KERN_WARNING
190                        "Could not register misc device for PRNG.\n");
191                 goto out_buf;
192         }
193         return 0;
194
195 out_buf:
196         kfree(p->buf);
197 out_free:
198         kfree(p);
199         return ret;
200 }
201
202 static void __exit prng_exit(void)
203 {
204         /* wipe me */
205         memset(p->buf, 0, prng_chunk_size);
206         kfree(p->buf);
207         kfree(p);
208
209         misc_deregister(&prng_dev);
210 }
211
212 module_init(prng_init);
213 module_exit(prng_exit);