summaryrefslogtreecommitdiff
path: root/system/libgcrypt/lock-error.patch
blob: 505907335dd1ed8a948e64898f067eea37ece5b2 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
diff --git a/random/rndjent.c b/random/rndjent.c
index 0c5a820..3740ddd 100644
--- a/random/rndjent.c
+++ b/random/rndjent.c
@@ -1,371 +1,372 @@
 /* rndjent.c  - Driver for the jitterentropy module.
  * Copyright (C) 2017 g10 Code GmbH
  * Copyright (C) 2017 Bundesamt für Sicherheit in der Informationstechnik
  * Copyright (C) 2013 Stephan Mueller <smueller@chronox.de>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, and the entire permission notice in its entirety,
  *    including the disclaimer of warranties.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. The name of the author may not be used to endorse or promote
  *    products derived from this software without specific prior
  *    written permission.
  *
  * ALTERNATIVELY, this product may be distributed under the terms of
  * the GNU General Public License, in which case the provisions of the GPL are
  * required INSTEAD OF the above restrictions.  (This clause is
  * necessary due to a potential bad interaction between the GPL and
  * the restrictions contained in a BSD-style copyright.)
  *
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
  * WHICH ARE HEREBY DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
  * DAMAGE.
  */
 
 #include <config.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
 #ifdef HAVE_STDINT_H
 # include <stdint.h>
 #endif
 
 #include "types.h"
 #include "g10lib.h"
 #include "../cipher/bithelp.h"
 #include "rand-internal.h"
 
 /*
  * Decide whether we can support jent at compile time.
  */
 #undef USE_JENT
 #define JENT_USES_RDTSC 1
 #define JENT_USES_GETTIME 2
 #define JENT_USES_READ_REAL_TIME 3
 #ifdef ENABLE_JENT_SUPPORT
 # if defined (__i386__) || defined(__x86_64__)
 #   define USE_JENT JENT_USES_RDTSC
 # elif defined (HAVE_CLOCK_GETTIME)
 #  if _AIX
 #   define USE_JENT JENT_USES_READ_REAL_TIME
 #  else
 #   define USE_JENT JENT_USES_GETTIME
 #  endif
 # endif
 #endif /*ENABLE_JENT_SUPPORT*/
 
 
 #ifdef USE_JENT
 
 #undef CONFIG_CRYPTO_CPU_JITTERENTROPY_STAT
 /* Uncomment the next line to build with statistics.  */
 /* #define CONFIG_CRYPTO_CPU_JITTERENTROPY_STAT 1 */
 
 
 /* Note that we source include the actual jitter entropy code.
  * Platform dependent code is indirectly included from our own
  * jitterentropy-user-base.h file.   */
 
 /* Tell jitterentropy* that all functions shall be static.  */
 #define JENT_PRIVATE_COMPILE 1
 
 #include "jitterentropy-base.c"
 
 
 /* This is the lock we use to serialize access to this RNG.  The extra
  * integer variable is only used to check the locking state; that is,
  * it is not meant to be thread-safe but merely as a failsafe feature
  * to assert proper locking.  */
 GPGRT_LOCK_DEFINE (jent_rng_lock);
 static int jent_rng_is_locked;
 
 /* This flag tracks whether the RNG has been initialized - either
  * with error or with success.  Protected by JENT_RNG_LOCK. */
 static int jent_rng_is_initialized;
 
 /* Our collector.  The RNG is in a working state if its value is not
  * NULL.  Protected by JENT_RNG_LOCK.  */
 struct rand_data *jent_rng_collector;
 
 /* The number of times the core entropy function has been called and
  * the number of random bytes retrieved.  */
 static unsigned long jent_rng_totalcalls;
 static unsigned long jent_rng_totalbytes;
 
 
 
 /* JENT statistic helper code.  */
 #ifdef CONFIG_CRYPTO_CPU_JITTERENTROPY_STAT
 
 static void
 jent_init_statistic (struct rand_data *rand_data)
 {
   /* int i; */
   /* struct entropy_stat *stat = &rand_data->entropy_stat; */
 
   /* for (i = 0; i < 64; i++) */
   /*   { */
   /*     stat->bitslot[i] = 0; */
   /*     stat->bitvar[i] = 0; */
   /*   } */
 
   /* jent_get_nstime (&stat->collection_begin); */
 }
 
 static void
 jent_bit_count (struct rand_data *rand_data, u64 prev_data)
 {
   /* int i; */
 
   /* if (!rand_data->entropy_stat.enable_bit_test) */
   /*   return; */
 
   /* for (i = 0; i < 64; i++) */
   /*   { */
   /*     /\* collect the count of set bits per bit position in the */
   /*      * current ->data field *\/ */
   /*     rand_data->entropy_stat.bitslot[i] += (rand_data->data & 1<<i) ? 1:0; */
 
   /*     /\* collect the count of bit changes between the current */
   /*      * and the previous random data value per bit position *\/ */
   /*     if ((rand_data->data & 1<<i) != (prev_data & 1<<i)) */
   /*       rand_data->entropy_stat.bitvar[i] += 1; */
   /*   } */
 }
 
 
 static void
 jent_statistic_copy_stat (struct entropy_stat *src, struct entropy_stat *dst)
 {
   /* /\* not copying bitslot and bitvar as they are not needed for */
   /*  * statistic printout *\/ */
   /* dst->collection_begin = src->collection_begin; */
   /* dst->collection_end	= src->collection_end; */
   /* dst->old_delta	= src->old_delta; */
   /* dst->setbits		= src->setbits; */
   /* dst->varbits		= src->varbits; */
   /* dst->obsbits		= src->obsbits; */
   /* dst->collection_loop_cnt= src->collection_loop_cnt; */
 }
 
 
 /*
  * Assessment of statistical behavior of the generated output and returning
  * the information to the caller by filling the target value.
  *
  * Details about the bit statistics are given in chapter 4 of the doc.
  * Chapter 5 documents the timer analysis and the resulting entropy.
  */
 static void
 jent_calc_statistic (struct rand_data *rand_data,
                      struct entropy_stat *target, unsigned int loop_cnt)
 {
   /* int i; */
   /* struct entropy_stat *stat = &rand_data->entropy_stat; */
 
   /* jent_get_nstime(&stat->collection_end); */
 
   /* stat->collection_loop_cnt = loop_cnt; */
 
   /* stat->setbits = 0; */
   /* stat->varbits = 0; */
   /* stat->obsbits = 0; */
 
   /* for (i = 0; i < DATA_SIZE_BITS; i++) */
   /*   { */
   /*     stat->setbits += stat->bitslot[i]; */
   /*     stat->varbits += stat->bitvar[i]; */
 
   /*     /\* This is the sum of set bits in the current observation */
   /*      * of the random data. *\/ */
   /*     stat->obsbits += (rand_data->data & 1<<i) ? 1:0; */
   /*   } */
 
   /* jent_statistic_copy_stat(stat, target); */
 
   /* stat->old_delta = (stat->collection_end - stat->collection_begin); */
 }
 
 #endif /*CONFIG_CRYPTO_CPU_JITTERENTROPY_STAT*/
 
 
 /* Acquire the jent_rng_lock.  */
 static void
 lock_rng (void)
 {
   gpg_err_code_t rc;
 
   rc = gpgrt_lock_lock (&jent_rng_lock);
   if (rc)
     log_fatal ("failed to acquire the Jent RNG lock: %s\n",
                gpg_strerror (rc));
   jent_rng_is_locked = 1;
 }
 
 
 /* Release the jent_rng_lock.  */
 static void
 unlock_rng (void)
 {
   gpg_err_code_t rc;
 
   jent_rng_is_locked = 0;
   rc = gpgrt_lock_unlock (&jent_rng_lock);
   if (rc)
     log_fatal ("failed to release the Jent RNG lock: %s\n",
                gpg_strerror (rc));
 }
 
 
 /* Return true if the JENT RNG code can be run.  It may not yet been
  * initialized, though.  */
 static int
 is_rng_available (void)
 {
 #if USE_JENT == JENT_USES_RDTSC
   return !!(_gcry_get_hw_features () & HWF_INTEL_RDTSC);
 #elif USE_JENT == JENT_USES_GETTIME
   return 2;
 #elif USE_JENT == JENT_USES_READ_REAL_TIME
   return 3;
 #else  /* Ooops  */
   return 0;
 #endif
 }
 
 #endif /* USE_JENT */
 
 
 /*
  * The API used by the high level code.
  */
 
 /* Read up to LENGTH bytes from a jitter RNG and return the number of
  * bytes actually read.  */
 size_t
 _gcry_rndjent_poll (void (*add)(const void*, size_t, enum random_origins),
                     enum random_origins origin, size_t length)
 {
   size_t nbytes = 0;
 
 #ifdef USE_JENT
   if ( is_rng_available () )
     {
       lock_rng ();
 
       if (!jent_rng_is_initialized)
         {
           /* Auto-initialize.  */
           jent_rng_is_initialized = 1;
           jent_entropy_collector_free (jent_rng_collector);
           jent_rng_collector = NULL;
           if ( !(_gcry_random_read_conf () & RANDOM_CONF_DISABLE_JENT))
             {
               if (!jent_entropy_init ())
                 jent_rng_collector = jent_entropy_collector_alloc (1, 0);
             }
         }
 
       if (jent_rng_collector && add)
         {
           /* We have a working JENT and it has not been disabled.  */
           char buffer[32];
 
           while (length)
             {
               int rc;
               size_t n = length < sizeof(buffer)? length : sizeof (buffer);
 
               jent_rng_totalcalls++;
               rc = jent_read_entropy (jent_rng_collector, buffer, n);
               if (rc < 0)
                 break;
               /* We need to hash the output to conform to the BSI
                * NTG.1 specs.  */
               _gcry_md_hash_buffer (GCRY_MD_SHA256, buffer, buffer, rc);
               n = rc < 32? rc : 32;
               (*add) (buffer, n, origin);
               length -= n;
               nbytes += n;
               jent_rng_totalbytes += n;
             }
           wipememory (buffer, sizeof buffer);
         }
 
       unlock_rng ();
     }
 
 #else
 
   (void)add;
   (void)origin;
 
 #endif
 
   return nbytes;
 }
 
 
 /* Return the version number of the JENT RNG.  If the RNG is not
  * initialized or usable 0 is returned.  If R_ACTIVE is not NULL the
  * jitter RNG will be initialized and true is stored at R_ACTIVE if
  * the initialization succeeded.  */
 unsigned int
 _gcry_rndjent_get_version (int *r_active)
 {
   if (r_active)
     *r_active = 0;
 #ifdef USE_JENT
   if ( is_rng_available () )
     {
       if (r_active)
         {
-          lock_rng ();
           /* Make sure the RNG is initialized.  */
           _gcry_rndjent_poll (NULL, 0, 0);
+
+          lock_rng ();
           /* To ease debugging we store 2 for a clock_gettime based
            * implementation and 1 for a rdtsc based code.  */
           *r_active = jent_rng_collector? is_rng_available () : 0;
           unlock_rng ();
         }
       return jent_version ();
     }
   else
     return 0;
 #else
   return 0;
 #endif
 }
 
 
 /* Log statistical informantion about the use of this module.  */
 void
 _gcry_rndjent_dump_stats (void)
 {
   /* In theory we would need to lock the stats here.  However this
    * function is usually called during cleanup and then we _might_ run
    * into problems.  */
 
 #ifdef USE_JENT
   if ( is_rng_available () )
     {
       log_info ("rndjent stat: collector=%p calls=%lu bytes=%lu\n",
                 jent_rng_collector, jent_rng_totalcalls, jent_rng_totalbytes);
 
     }
 #endif /*USE_JENT*/
 }