Ignore mingw32-boost for now, because it doesn't work.
[fedora-mingw.git] / openssl / openssl-thread-test.c
1 /* Test program to verify that RSA signing is thread-safe in OpenSSL. */
2
3 #include <assert.h>
4 #include <errno.h>
5 #include <fcntl.h>
6 #include <limits.h>
7 #include <pthread.h>
8 #include <stdio.h>
9 #include <string.h>
10 #include <unistd.h>
11
12 #include <openssl/crypto.h>
13 #include <openssl/err.h>
14 #include <openssl/objects.h>
15 #include <openssl/rand.h>
16 #include <openssl/rsa.h>
17 #include <openssl/md5.h>
18 #include <openssl/ssl.h>
19
20 /* Just assume we want to do engine stuff if we're using 0.9.6b or
21  * higher. This assumption is only valid for versions bundled with RHL. */
22 #if OPENSSL_VERSION_NUMBER  >= 0x0090602fL
23 #include <openssl/engine.h>
24 #define USE_ENGINE
25 #endif
26
27 #define MAX_THREAD_COUNT        10000
28 #define ITERATION_COUNT         10
29 #define MAIN_COUNT              100
30
31 /* OpenSSL requires us to provide thread ID and locking primitives. */
32 pthread_mutex_t *mutex_locks = NULL;
33 static unsigned long
34 thread_id_cb(void)
35 {
36         return (unsigned long) pthread_self();
37 }
38 static void
39 lock_cb(int mode, int n, const char *file, int line)
40 {
41         if (mode & CRYPTO_LOCK) {
42                 pthread_mutex_lock(&mutex_locks[n]);
43         } else {
44                 pthread_mutex_unlock(&mutex_locks[n]);
45         }
46 }
47
48 struct thread_args {
49         RSA *rsa;
50         int digest_type;
51         unsigned char *digest;
52         unsigned int digest_len;
53         unsigned char *signature;
54         unsigned int signature_len;
55         pthread_t main_thread;
56 };
57
58 static int print = 0;
59
60 pthread_mutex_t sign_lock = PTHREAD_MUTEX_INITIALIZER;
61 static int locked_sign = 0;
62 static void SIGN_LOCK() {if (locked_sign) pthread_mutex_lock(&sign_lock);}
63 static void SIGN_UNLOCK() {if (locked_sign) pthread_mutex_unlock(&sign_lock);}
64
65 pthread_mutex_t verify_lock = PTHREAD_MUTEX_INITIALIZER;
66 static int locked_verify = 0;
67 static void VERIFY_LOCK() {if (locked_verify) pthread_mutex_lock(&verify_lock);}
68 static void VERIFY_UNLOCK() {if (locked_verify) pthread_mutex_unlock(&verify_lock);}
69
70 pthread_mutex_t failure_count_lock = PTHREAD_MUTEX_INITIALIZER;
71 long failure_count = 0;
72 static void
73 failure()
74 {
75         pthread_mutex_lock(&failure_count_lock);
76         failure_count++;
77         pthread_mutex_unlock(&failure_count_lock);
78 }
79
80 static void *
81 thread_main(void *argp)
82 {
83         struct thread_args *args = argp;
84         unsigned char *signature;
85         unsigned int signature_len, signature_alloc_len;
86         int ret, i;
87
88         signature_alloc_len = args->signature_len;
89         if (RSA_size(args->rsa) > signature_alloc_len) {
90                 signature_alloc_len = RSA_size(args->rsa);
91         }
92         signature = malloc(signature_alloc_len);
93         if (signature == NULL) {
94                 fprintf(stderr, "Skipping checks in thread %lu -- %s.\n",
95                         (unsigned long) pthread_self(), strerror(errno));
96                 pthread_exit(0);
97                 return NULL;
98         }
99         for (i = 0; i < ITERATION_COUNT; i++) {
100                 signature_len = signature_alloc_len;
101                 SIGN_LOCK();
102                 ret = RSA_check_key(args->rsa);
103                 ERR_print_errors_fp(stdout);
104                 if (ret != 1) {
105                         failure();
106                         break;
107                 }
108                 ret = RSA_sign(args->digest_type,
109                                args->digest,
110                                args->digest_len,
111                                signature, &signature_len,
112                                args->rsa);
113                 SIGN_UNLOCK();
114                 ERR_print_errors_fp(stdout);
115                 if (ret != 1) {
116                         failure();
117                         break;
118                 }
119
120                 VERIFY_LOCK();
121                 ret = RSA_verify(args->digest_type,
122                                  args->digest,
123                                  args->digest_len,
124                                  signature, signature_len,
125                                  args->rsa);
126                 VERIFY_UNLOCK();
127                 if (ret != 1) {
128                         fprintf(stderr,
129                                 "Signature from thread %lu(%d) fails "
130                                 "verification (passed in thread #%lu)!\n",
131                                 (long) pthread_self(), i,
132                                 (long) args->main_thread);
133                         ERR_print_errors_fp(stdout);
134                         failure();
135                         continue;
136                 }
137                 if (print) {
138                         fprintf(stderr, ">%d\n", i);
139                 }
140         }
141         free(signature);
142
143         pthread_exit(0);
144
145         return NULL;
146 }
147
148 unsigned char *
149 xmemdup(unsigned char *s, size_t len)
150 {
151         unsigned char *r;
152         r = malloc(len);
153         if (r == NULL) {
154                 fprintf(stderr, "Out of memory.\n");
155                 ERR_print_errors_fp(stdout);
156                 assert(r != NULL);
157         }
158         memcpy(r, s, len);
159         return r;
160 }
161
162 int
163 main(int argc, char **argv)
164 {
165         RSA *rsa;
166         MD5_CTX md5;
167         int fd, i;
168         pthread_t threads[MAX_THREAD_COUNT];
169         int thread_count = 1000;
170         unsigned char *message, *digest;
171         unsigned int message_len, digest_len;
172         unsigned char *correct_signature;
173         unsigned int correct_siglen, ret;
174         struct thread_args master_args, *args;
175         int sync = 0, seed = 0;
176         int again = 1;
177 #ifdef USE_ENGINE
178         char *engine = NULL;
179         ENGINE *e = NULL;
180 #endif
181
182         pthread_mutex_init(&failure_count_lock, NULL);
183
184         for (i = 1; i < argc; i++) {
185                 if (strcmp(argv[i], "--seed") == 0) {
186                         printf("Seeding PRNG.\n");
187                         seed++;
188                 } else
189                 if (strcmp(argv[i], "--sync") == 0) {
190                         printf("Running synchronized.\n");
191                         sync++;
192                 } else
193                 if ((strcmp(argv[i], "--threads") == 0) && (i < argc - 1)) {
194                         i++;
195                         thread_count = atol(argv[i]);
196                         if (thread_count > MAX_THREAD_COUNT) {
197                                 thread_count = MAX_THREAD_COUNT;
198                         }
199                         printf("Starting %d threads.\n", thread_count);
200                         sync++;
201                 } else
202                 if (strcmp(argv[i], "--sign") == 0) {
203                         printf("Locking signing.\n");
204                         locked_sign++;
205                 } else
206                 if (strcmp(argv[i], "--verify") == 0) {
207                         printf("Locking verifies.\n");
208                         locked_verify++;
209                 } else
210                 if (strcmp(argv[i], "--print") == 0) {
211                         printf("Tracing.\n");
212                         print++;
213 #ifdef USE_ENGINE
214                 } else
215                 if ((strcmp(argv[i], "--engine") == 0) && (i < argc - 1)) {
216                         printf("Using engine \"%s\".\n", argv[i + 1]);
217                         engine = argv[i + 1];
218                         i++;
219 #endif
220                 } else {
221                         printf("Bad argument: %s\n", argv[i]);
222                         return 1;
223                 }
224         }
225
226         /* Get some random data to sign. */
227         fd = open("/dev/urandom", O_RDONLY);
228         if (fd == -1) {
229                 fprintf(stderr, "Error opening /dev/urandom: %s\n",
230                         strerror(errno));
231         }
232
233         if (print) {
234                 fprintf(stderr, "Reading random data.\n");
235         }
236         message = malloc(message_len = 9371);
237         read(fd, message, message_len);
238         close(fd);
239
240         /* Initialize the SSL library and set up thread-safe locking. */
241         ERR_load_crypto_strings();
242         SSL_library_init();
243         mutex_locks = malloc(sizeof(pthread_mutex_t) * CRYPTO_num_locks());
244         for (i = 0; i < CRYPTO_num_locks(); i++) {
245                 pthread_mutex_init(&mutex_locks[i], NULL);
246         }
247         CRYPTO_set_id_callback(thread_id_cb);
248         CRYPTO_set_locking_callback(lock_cb);
249         ERR_print_errors_fp(stdout);
250
251         /* Seed the PRNG if we were asked to do so. */
252         if (seed) {
253                 if (print) {
254                         fprintf(stderr, "Seeding PRNG.\n");
255                 }
256                 RAND_add(message, message_len, message_len);
257                 ERR_print_errors_fp(stdout);
258         }
259
260         /* Turn on a hardware crypto device if asked to do so. */
261 #ifdef USE_ENGINE
262         if (engine) {
263 #if OPENSSL_VERSION_NUMBER  >= 0x0090700fL
264                 ENGINE_load_builtin_engines();
265 #endif
266                 if (print) {
267                         fprintf(stderr, "Initializing \"%s\" engine.\n",
268                                 engine);
269                 }
270                 e = ENGINE_by_id(engine);
271                 ERR_print_errors_fp(stdout);
272                 if (e) {
273                         i = ENGINE_init(e);
274                         ERR_print_errors_fp(stdout);
275                         i = ENGINE_set_default_RSA(e);
276                         ERR_print_errors_fp(stdout);
277                 }
278         }
279 #endif
280
281         /* Compute the digest for the signature. */
282         if (print) {
283                 fprintf(stderr, "Computing digest.\n");
284         }
285         digest = malloc(digest_len = MD5_DIGEST_LENGTH);
286         MD5_Init(&md5);
287         MD5_Update(&md5, message, message_len);
288         MD5_Final(digest, &md5);
289
290         /* Generate a signing key. */
291         if (print) {
292                 fprintf(stderr, "Generating key.\n");
293         }
294         rsa = RSA_generate_key(4096, 3, NULL, NULL);
295         ERR_print_errors_fp(stdout);
296         if (rsa == NULL) {
297                 _exit(1);
298         }
299
300         /* Sign the data. */
301         correct_siglen = RSA_size(rsa);
302         correct_signature = malloc(correct_siglen);
303         for (i = 0; i < MAIN_COUNT; i++) {
304                 if (print) {
305                         fprintf(stderr, "Signing data (%d).\n", i);
306                 }
307                 ret = RSA_check_key(rsa);
308                 ERR_print_errors_fp(stdout);
309                 if (ret != 1) {
310                         failure();
311                 }
312                 correct_siglen = RSA_size(rsa);
313                 ret = RSA_sign(NID_md5, digest, digest_len,
314                                correct_signature, &correct_siglen,
315                                rsa);
316                 ERR_print_errors_fp(stdout);
317                 if (ret != 1) {
318                         _exit(2);
319                 }
320                 if (print) {
321                         fprintf(stderr, "Verifying data (%d).\n", i);
322                 }
323                 ret = RSA_verify(NID_md5, digest, digest_len,
324                                  correct_signature, correct_siglen,
325                                  rsa);
326                 if (ret != 1) {
327                         _exit(2);
328                 }
329         }
330
331         /* Collect up the inforamtion which other threads will need for
332          * comparing their signature results with ours. */
333         master_args.rsa = rsa;
334         master_args.digest_type = NID_md5;
335         master_args.digest = digest;
336         master_args.digest_len = digest_len;
337         master_args.signature = correct_signature;
338         master_args.signature_len = correct_siglen;
339         master_args.main_thread = pthread_self();
340         
341         fprintf(stdout, "Performing %d signatures in each of %d threads "
342                 "(%d, %d).\n", ITERATION_COUNT, thread_count,
343                 digest_len, correct_siglen);
344         fflush(NULL);
345
346         /* Start up all of the threads. */
347         for (i = 0; i < thread_count; i++) {
348                 args = malloc(sizeof(struct thread_args));
349                 args->rsa = RSAPrivateKey_dup(master_args.rsa);
350                 args->digest_type = master_args.digest_type;
351                 args->digest_len = master_args.digest_len;
352                 args->digest = xmemdup(master_args.digest, args->digest_len);
353                 args->signature_len = master_args.signature_len;
354                 args->signature = xmemdup(master_args.signature,
355                                           args->signature_len);
356                 args->main_thread = pthread_self();
357                 ret = pthread_create(&threads[i], NULL, thread_main, args);
358                 while ((ret != 0) && (errno == EAGAIN)) {
359                         ret = pthread_create(&threads[i], NULL,
360                                              thread_main, &args);
361                         fprintf(stderr, "Thread limit hit at %d.\n", i);
362                 }
363                 if (ret != 0) {
364                         fprintf(stderr, "Unable to create thread %d: %s.\n",
365                                 i, strerror(errno));
366                         threads[i] = -1;
367                 } else {
368                         if (sync) {
369                                 ret = pthread_join(threads[i], NULL);
370                                 assert(ret == 0);
371                         }
372                         if (print) {
373                                 fprintf(stderr, "%d\n", i);
374                         }
375                 }
376         }
377
378         /* Wait for all threads to complete.  So long as we can find an
379          * unjoined thread, keep joining threads. */
380         do {
381                 again = 0;
382                 for (i = 0; i < thread_count; i++) {
383                         /* If we have an unterminated thread, join it. */
384                         if (threads[i] != -1) {
385                                 again = 1;
386                                 if (print) {
387                                         fprintf(stderr, "Joining thread %d.\n",
388                                                 i);
389                                 }
390                                 pthread_join(threads[i], NULL);
391                                 threads[i] = -1;
392                                 break;
393                         }
394                 }
395         } while (again == 1);
396
397         fprintf(stderr, "%ld failures\n", failure_count);
398
399         return (failure_count != 0);
400 }