Add support for using DRNG random number generator
[libgcrypt.git] / random / rndhw.c
1 /* rndhw.c  - Access to the external random daemon
2  * Copyright (C) 2007  Free Software Foundation, Inc.
3  * Copyright (C) 2012  Dmitry Kasatkin
4  *
5  * This file is part of Libgcrypt.
6  *
7  * Libgcrypt is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU Lesser General Public License as
9  * published by the Free Software Foundation; either version 2.1 of
10  * the License, or (at your option) any later version.
11  *
12  * Libgcrypt is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24
25 #include "types.h"
26 #include "g10lib.h"
27 #include "rand-internal.h"
28
29 #undef USE_PADLOCK
30 #ifdef ENABLE_PADLOCK_SUPPORT
31 # ifdef HAVE_GCC_ATTRIBUTE_ALIGNED
32 #  if (defined (__i386__) && SIZEOF_UNSIGNED_LONG == 4) || defined(__x86_64__)
33 #   define USE_PADLOCK 1
34 #  endif
35 # endif
36 #endif /*ENABLE_PADLOCK_SUPPORT*/
37
38 #undef USE_DRNG
39 #ifdef ENABLE_DRNG_SUPPORT
40 # ifdef HAVE_GCC_ATTRIBUTE_ALIGNED
41 #  if (defined (__i386__) && SIZEOF_UNSIGNED_LONG == 4) || defined(__x86_64__)
42 #   define USE_DRNG 1
43 #  endif
44 # endif
45 #endif /*ENABLE_RDRAND_SUPPORT*/
46
47 typedef void (*add_fn_t)(const void*, size_t, enum random_origins);
48
49 /* Keep track on whether the RNG has problems.  */
50 static volatile int rng_failed;
51
52
53 #ifdef USE_PADLOCK
54 static size_t
55 poll_padlock (void (*add)(const void*, size_t, enum random_origins),
56               enum random_origins origin, int fast)
57 {
58   volatile char buffer[64+8] __attribute__ ((aligned (8)));
59   volatile char *p;
60   unsigned int nbytes, status;
61
62   /* Peter Gutmann's cryptlib tests again whether the RNG is enabled
63      but we don't do so.  We would have to do this also for our AES
64      implementaion and that is definitely too time consuming.  There
65      would be a race condition anyway.  Thus we assume that the OS
66      does not change the Padlock initialization while a user process
67      is running.  */
68   p = buffer;
69   nbytes = 0;
70   while (nbytes < 64)
71     {
72 #ifdef __x86_64__
73       asm volatile
74         ("movq %1, %%rdi\n\t"         /* Set buffer.  */
75          "xorq %%rdx, %%rdx\n\t"      /* Request up to 8 bytes.  */
76          ".byte 0x0f, 0xa7, 0xc0\n\t" /* XSTORE RNG. */
77          : "=a" (status)
78          : "g" (p)
79          : "%rdx", "%rdi", "cc"
80          );
81 #else
82       asm volatile
83         ("movl %1, %%edi\n\t"         /* Set buffer.  */
84          "xorl %%edx, %%edx\n\t"      /* Request up to 8 bytes.  */
85          ".byte 0x0f, 0xa7, 0xc0\n\t" /* XSTORE RNG. */
86          : "=a" (status)
87          : "g" (p)
88          : "%edx", "%edi", "cc"
89          );
90 #endif
91       if ((status & (1<<6))         /* RNG still enabled.  */
92           && !(status & (1<<13))    /* von Neumann corrector is enabled.  */
93           && !(status & (1<<14))    /* String filter is disabled.  */
94           && !(status & 0x1c00)     /* BIAS voltage at default.  */
95           && (!(status & 0x1f) || (status & 0x1f) == 8) /* Sanity check.  */
96           )
97         {
98           nbytes += (status & 0x1f);
99           if (fast)
100             break; /* Don't get into the loop with the fast flag set.  */
101           p += (status & 0x1f);
102         }
103       else
104         {
105           /* If there was an error we need to break the loop and
106              record that there is something wrong with the padlock
107              RNG.  */
108           rng_failed = 1;
109           break;
110         }
111     }
112
113   if (nbytes)
114     {
115       (*add) ((void*)buffer, nbytes, origin);
116       wipememory (buffer, nbytes);
117     }
118   return nbytes;
119 }
120 #endif /*USE_PADLOCK*/
121
122
123 #ifdef USE_DRNG
124 # define RDRAND_RETRY_LOOPS     10
125 # define RDRAND_INT     ".byte 0x0f,0xc7,0xf0"
126 # ifdef __x86_64__
127 #  define RDRAND_LONG   ".byte 0x48,0x0f,0xc7,0xf0"
128 # else
129 #  define RDRAND_LONG   RDRAND_INT
130 # endif
131 static inline int
132 rdrand_long (unsigned long *v)
133 {
134   int ok;
135   asm volatile ("1: " RDRAND_LONG "\n\t"
136                 "jc 2f\n\t"
137                 "decl %0\n\t"
138                 "jnz 1b\n\t"
139                 "2:"
140                 : "=r" (ok), "=a" (*v)
141                 : "0" (RDRAND_RETRY_LOOPS));
142   return ok;
143 }
144
145
146 static inline int
147 rdrand_nlong (unsigned long *v, int count)
148 {
149   while (count--)
150     if (!rdrand_long(v++))
151       return 0;
152   return 1;
153 }
154
155
156 static size_t
157 poll_drng (add_fn_t add, enum random_origins origin, int fast)
158 {
159   volatile char buffer[64] __attribute__ ((aligned (8)));
160   unsigned int nbytes = sizeof (buffer);
161
162   (void)fast;
163
164   if (!rdrand_nlong ((unsigned long *)buffer, sizeof(buffer)/sizeof(long)))
165     return 0;
166   (*add)((void *)buffer, nbytes, origin);
167   return nbytes;
168 }
169 #endif /*USE_DRNG*/
170
171
172 int
173 _gcry_rndhw_failed_p (void)
174 {
175   return rng_failed;
176 }
177
178
179 /* Try to read random from a hardware RNG if a fast one is
180    available.  */
181 void
182 _gcry_rndhw_poll_fast (void (*add)(const void*, size_t, enum random_origins),
183                        enum random_origins origin)
184 {
185   (void)add;
186   (void)origin;
187
188 #ifdef USE_DRNG
189   if ((_gcry_get_hw_features () & HWF_INTEL_RDRAND))
190     poll_drng (add, origin, 1);
191 #endif
192 #ifdef USE_PADLOCK
193   if ((_gcry_get_hw_features () & HWF_PADLOCK_RNG))
194     poll_padlock (add, origin, 1);
195 #endif
196 }
197
198
199 /* Read 64 bytes from a hardware RNG and return the number of bytes
200    actually read.  */
201 size_t
202 _gcry_rndhw_poll_slow (void (*add)(const void*, size_t, enum random_origins),
203                        enum random_origins origin)
204 {
205   size_t nbytes = 0;
206
207   (void)add;
208   (void)origin;
209
210 #ifdef USE_DRNG
211   if ((_gcry_get_hw_features () & HWF_INTEL_RDRAND))
212     nbytes += poll_drng (add, origin, 0);
213 #endif
214 #ifdef USE_PADLOCK
215   if ((_gcry_get_hw_features () & HWF_PADLOCK_RNG))
216     nbytes += poll_padlock (add, origin, 0);
217 #endif
218
219   return nbytes;
220 }