1 /*-
2 * Copyright (c) 2000-2015 Mark R V Murray
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer
10 * in this position and unchanged.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27 /*
28 Build this by going:
29
30 cc -g -O0 -pthread -DRANDOM_<alg> -I../.. -lstdthreads -Wall \
31 unit_test.c \
32 fortuna.c \
33 hash.c \
34 ../../crypto/rijndael/rijndael-api-fst.c \
35 ../../crypto/rijndael/rijndael-alg-fst.c \
36 ../../crypto/sha2/sha256c.c \
37 -lz \
38 -o unit_test
39 ./unit_test
40
41 Where <alg> is FORTUNA. The parameterisation is a leftover from
42 when Yarrow was an option, and remains to enable the testing of
43 possible future algorithms.
44 */
45
46 #include <sys/types.h>
47 #include <inttypes.h>
48 #include <stdbool.h>
49 #include <stdio.h>
50 #include <stdlib.h>
51 #include <threads.h>
52 #include <unistd.h>
53 #include <zlib.h>
54
55 #include "randomdev.h"
56 #include "unit_test.h"
57
58 #define NUM_THREADS 3
59 #define DEBUG
60
61 static volatile int stopseeding = 0;
62
63 static __inline void
check_err(int err,const char * func)64 check_err(int err, const char *func)
65 {
66 if (err != Z_OK) {
67 fprintf(stderr, "Compress error in %s: %d\n", func, err);
68 exit(0);
69 }
70 }
71
72 void *
myalloc(void * q,unsigned n,unsigned m)73 myalloc(void *q, unsigned n, unsigned m)
74 {
75 q = Z_NULL;
76 return (calloc(n, m));
77 }
78
myfree(void * q,void * p)79 void myfree(void *q, void *p)
80 {
81 q = Z_NULL;
82 free(p);
83 }
84
85 size_t
block_deflate(uint8_t * uncompr,uint8_t * compr,const size_t len)86 block_deflate(uint8_t *uncompr, uint8_t *compr, const size_t len)
87 {
88 z_stream c_stream;
89 int err;
90
91 if (len == 0)
92 return (0);
93
94 c_stream.zalloc = myalloc;
95 c_stream.zfree = myfree;
96 c_stream.opaque = NULL;
97
98 err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
99 check_err(err, "deflateInit");
100
101 c_stream.next_in = uncompr;
102 c_stream.next_out = compr;
103 c_stream.avail_in = len;
104 c_stream.avail_out = len*2u +512u;
105
106 while (c_stream.total_in != len && c_stream.total_out < (len*2u + 512u)) {
107 err = deflate(&c_stream, Z_NO_FLUSH);
108 #ifdef DEBUG
109 printf("deflate progress: len = %zd total_in = %lu total_out = %lu\n", len, c_stream.total_in, c_stream.total_out);
110 #endif
111 check_err(err, "deflate(..., Z_NO_FLUSH)");
112 }
113
114 for (;;) {
115 err = deflate(&c_stream, Z_FINISH);
116 #ifdef DEBUG
117 printf("deflate final: len = %zd total_in = %lu total_out = %lu\n", len, c_stream.total_in, c_stream.total_out);
118 #endif
119 if (err == Z_STREAM_END) break;
120 check_err(err, "deflate(..., Z_STREAM_END)");
121 }
122
123 err = deflateEnd(&c_stream);
124 check_err(err, "deflateEnd");
125
126 return ((size_t)c_stream.total_out);
127 }
128
129 void
randomdev_unblock(void)130 randomdev_unblock(void)
131 {
132
133 #if 0
134 if (mtx_trylock(&random_reseed_mtx) == thrd_busy)
135 printf("Mutex held. Good.\n");
136 else {
137 printf("Mutex not held. PANIC!!\n");
138 thrd_exit(0);
139 }
140 #endif
141 printf("random: unblocking device.\n");
142 }
143
144 static int
RunHarvester(void * arg __unused)145 RunHarvester(void *arg __unused)
146 {
147 int i, r;
148 struct harvest_event e;
149
150 for (i = 0; ; i++) {
151 if (stopseeding)
152 break;
153 if (i % 1000 == 0)
154 printf("Harvest: %d\n", i);
155 r = random()%10;
156 e.he_somecounter = i;
157 *((uint64_t *)e.he_entropy) = random();
158 e.he_size = 8;
159 e.he_destination = i;
160 e.he_source = (i + 3)%7;
161 e.he_next = NULL;
162 random_alg_context.ra_event_processor(&e);
163 usleep(r);
164 }
165
166 printf("Thread #0 ends\n");
167
168 thrd_exit(0);
169
170 return (0);
171 }
172
173 static int
ReadCSPRNG(void * threadid)174 ReadCSPRNG(void *threadid)
175 {
176 size_t tid, zsize;
177 u_int buffersize;
178 uint8_t *buf, *zbuf;
179 int i;
180 #ifdef DEBUG
181 int j;
182 #endif
183
184 tid = (size_t)threadid;
185 printf("Thread #%zd starts\n", tid);
186
187 while (!random_alg_context.ra_seeded())
188 {
189 random_alg_context.ra_pre_read();
190 usleep(100);
191 }
192
193 for (i = 0; i < 100000; i++) {
194 buffersize = i + RANDOM_BLOCKSIZE;
195 buffersize -= buffersize%RANDOM_BLOCKSIZE;
196 buf = malloc(buffersize);
197 zbuf = malloc(2*i + 1024);
198 if (i % 1000 == 0)
199 printf("Thread read %zd - %d\n", tid, i);
200 if (buf != NULL && zbuf != NULL) {
201 random_alg_context.ra_pre_read();
202 random_alg_context.ra_read(buf, buffersize);
203 zsize = block_deflate(buf, zbuf, i);
204 if (zsize < i)
205 printf("ERROR!! Compressible RNG output!\n");
206 #ifdef DEBUG
207 printf("RNG output:\n");
208 for (j = 0; j < i; j++) {
209 printf(" %02X", buf[j]);
210 if (j % 32 == 31 || j == i - 1)
211 printf("\n");
212 }
213 printf("Compressed output:\n");
214 for (j = 0; j < zsize; j++) {
215 printf(" %02X", zbuf[j]);
216 if (j % 32 == 31 || j == zsize - 1)
217 printf("\n");
218 }
219 #endif
220 free(zbuf);
221 free(buf);
222 }
223 usleep(100);
224 }
225
226 printf("Thread #%zd ends\n", tid);
227
228 thrd_exit(0);
229
230 return (0);
231 }
232
233 int
main(int argc,char * argv[])234 main(int argc, char *argv[])
235 {
236 thrd_t threads[NUM_THREADS];
237 int rc;
238 long t;
239
240 random_alg_context.ra_init_alg(NULL);
241
242 for (t = 0; t < NUM_THREADS; t++) {
243 printf("In main: creating thread %ld\n", t);
244 rc = thrd_create(&threads[t], (t == 0 ? RunHarvester : ReadCSPRNG), NULL);
245 if (rc != thrd_success) {
246 printf("ERROR; return code from thrd_create() is %d\n", rc);
247 exit(-1);
248 }
249 }
250
251 for (t = 2; t < NUM_THREADS; t++)
252 thrd_join(threads[t], &rc);
253
254 stopseeding = 1;
255
256 thrd_join(threads[1], &rc);
257 thrd_join(threads[0], &rc);
258
259 random_alg_context.ra_deinit_alg(NULL);
260
261 /* Last thing that main() should do */
262 thrd_exit(0);
263
264 return (0);
265 }
266