Make DRBG uninstantiate() and instantiate() methods inverse to each other
[openssl.git] / crypto / mem_dbg.c
1 /*
2  * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <time.h>
13 #include "internal/cryptlib.h"
14 #include "internal/thread_once.h"
15 #include <openssl/crypto.h>
16 #include <openssl/buffer.h>
17 #include "internal/bio.h"
18 #include <openssl/lhash.h>
19
20 #ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
21 # include <execinfo.h>
22 #endif
23
24 /*
25  * The state changes to CRYPTO_MEM_CHECK_ON | CRYPTO_MEM_CHECK_ENABLE when
26  * the application asks for it (usually after library initialisation for
27  * which no book-keeping is desired). State CRYPTO_MEM_CHECK_ON exists only
28  * temporarily when the library thinks that certain allocations should not be
29  * checked (e.g. the data structures used for memory checking).  It is not
30  * suitable as an initial state: the library will unexpectedly enable memory
31  * checking when it executes one of those sections that want to disable
32  * checking temporarily. State CRYPTO_MEM_CHECK_ENABLE without ..._ON makes
33  * no sense whatsoever.
34  */
35 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
36 static int mh_mode = CRYPTO_MEM_CHECK_OFF;
37 #endif
38
39 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
40 static unsigned long order = 0; /* number of memory requests */
41
42 /*-
43  * For application-defined information (static C-string `info')
44  * to be displayed in memory leak list.
45  * Each thread has its own stack.  For applications, there is
46  *   OPENSSL_mem_debug_push("...")     to push an entry,
47  *   OPENSSL_mem_debug_pop()     to pop an entry,
48  */
49 struct app_mem_info_st {
50     CRYPTO_THREAD_ID threadid;
51     const char *file;
52     int line;
53     const char *info;
54     struct app_mem_info_st *next; /* tail of thread's stack */
55     int references;
56 };
57
58 static CRYPTO_ONCE memdbg_init = CRYPTO_ONCE_STATIC_INIT;
59 CRYPTO_RWLOCK *memdbg_lock;
60 static CRYPTO_RWLOCK *long_memdbg_lock;
61 static CRYPTO_THREAD_LOCAL appinfokey;
62
63 /* memory-block description */
64 struct mem_st {
65     void *addr;
66     int num;
67     const char *file;
68     int line;
69     CRYPTO_THREAD_ID threadid;
70     unsigned long order;
71     time_t time;
72     APP_INFO *app_info;
73 #ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
74     void *array[30];
75     size_t array_siz;
76 #endif
77 };
78
79 /*
80  * hash-table of memory requests (address as * key); access requires
81  * long_memdbg_lock lock
82  */
83 static LHASH_OF(MEM) *mh = NULL;
84
85 /* num_disable > 0 iff mh_mode == CRYPTO_MEM_CHECK_ON (w/o ..._ENABLE) */
86 static unsigned int num_disable = 0;
87
88 /*
89  * Valid iff num_disable > 0.  long_memdbg_lock is locked exactly in this
90  * case (by the thread named in disabling_thread).
91  */
92 static CRYPTO_THREAD_ID disabling_threadid;
93
94 DEFINE_RUN_ONCE_STATIC(do_memdbg_init)
95 {
96     memdbg_lock = CRYPTO_THREAD_glock_new("malloc");
97     long_memdbg_lock = CRYPTO_THREAD_glock_new("long_malloc");
98     if (memdbg_lock == NULL
99             || long_memdbg_lock == NULL
100             || !CRYPTO_THREAD_init_local(&appinfokey, NULL)) {
101         CRYPTO_THREAD_lock_free(memdbg_lock);
102         memdbg_lock = NULL;
103         CRYPTO_THREAD_lock_free(long_memdbg_lock);
104         long_memdbg_lock = NULL;
105         return 0;
106     }
107     return 1;
108 }
109
110 static void app_info_free(APP_INFO *inf)
111 {
112     if (inf == NULL)
113         return;
114     if (--(inf->references) <= 0) {
115         app_info_free(inf->next);
116         OPENSSL_free(inf);
117     }
118 }
119 #endif
120
121 int CRYPTO_mem_ctrl(int mode)
122 {
123 #ifdef OPENSSL_NO_CRYPTO_MDEBUG
124     return mode - mode;
125 #else
126     int ret = mh_mode;
127
128     if (!RUN_ONCE(&memdbg_init, do_memdbg_init))
129         return -1;
130
131     CRYPTO_THREAD_write_lock(memdbg_lock);
132     switch (mode) {
133     default:
134         break;
135
136     case CRYPTO_MEM_CHECK_ON:
137         mh_mode = CRYPTO_MEM_CHECK_ON | CRYPTO_MEM_CHECK_ENABLE;
138         num_disable = 0;
139         break;
140
141     case CRYPTO_MEM_CHECK_OFF:
142         mh_mode = 0;
143         num_disable = 0;
144         break;
145
146     /* switch off temporarily (for library-internal use): */
147     case CRYPTO_MEM_CHECK_DISABLE:
148         if (mh_mode & CRYPTO_MEM_CHECK_ON) {
149             CRYPTO_THREAD_ID cur = CRYPTO_THREAD_get_current_id();
150             /* see if we don't have long_memdbg_lock already */
151             if (!num_disable
152                 || !CRYPTO_THREAD_compare_id(disabling_threadid, cur)) {
153                 /*
154                  * Long-time lock long_memdbg_lock must not be claimed
155                  * while we're holding memdbg_lock, or we'll deadlock
156                  * if somebody else holds long_memdbg_lock (and cannot
157                  * release it because we block entry to this function). Give
158                  * them a chance, first, and then claim the locks in
159                  * appropriate order (long-time lock first).
160                  */
161                 CRYPTO_THREAD_unlock(memdbg_lock);
162                 /*
163                  * Note that after we have waited for long_memdbg_lock and
164                  * memdbg_lock, we'll still be in the right "case" and
165                  * "if" branch because MemCheck_start and MemCheck_stop may
166                  * never be used while there are multiple OpenSSL threads.
167                  */
168                 CRYPTO_THREAD_write_lock(long_memdbg_lock);
169                 CRYPTO_THREAD_write_lock(memdbg_lock);
170                 mh_mode &= ~CRYPTO_MEM_CHECK_ENABLE;
171                 disabling_threadid = cur;
172             }
173             num_disable++;
174         }
175         break;
176
177     case CRYPTO_MEM_CHECK_ENABLE:
178         if (mh_mode & CRYPTO_MEM_CHECK_ON) {
179             if (num_disable) {  /* always true, or something is going wrong */
180                 num_disable--;
181                 if (num_disable == 0) {
182                     mh_mode |= CRYPTO_MEM_CHECK_ENABLE;
183                     CRYPTO_THREAD_unlock(long_memdbg_lock);
184                 }
185             }
186         }
187         break;
188     }
189     CRYPTO_THREAD_unlock(memdbg_lock);
190     return ret;
191 #endif
192 }
193
194 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
195
196 static int mem_check_on(void)
197 {
198     int ret = 0;
199     CRYPTO_THREAD_ID cur;
200
201     if (mh_mode & CRYPTO_MEM_CHECK_ON) {
202         if (!RUN_ONCE(&memdbg_init, do_memdbg_init))
203             return 0;
204
205         cur = CRYPTO_THREAD_get_current_id();
206         CRYPTO_THREAD_read_lock(memdbg_lock);
207
208         ret = (mh_mode & CRYPTO_MEM_CHECK_ENABLE)
209             || !CRYPTO_THREAD_compare_id(disabling_threadid, cur);
210
211         CRYPTO_THREAD_unlock(memdbg_lock);
212     }
213     return ret;
214 }
215
216 static int mem_cmp(const MEM *a, const MEM *b)
217 {
218 #ifdef _WIN64
219     const char *ap = (const char *)a->addr, *bp = (const char *)b->addr;
220     if (ap == bp)
221         return 0;
222     else if (ap > bp)
223         return 1;
224     else
225         return -1;
226 #else
227     return (const char *)a->addr - (const char *)b->addr;
228 #endif
229 }
230
231 static unsigned long mem_hash(const MEM *a)
232 {
233     size_t ret;
234
235     ret = (size_t)a->addr;
236
237     ret = ret * 17851 + (ret >> 14) * 7 + (ret >> 4) * 251;
238     return ret;
239 }
240
241 /* returns 1 if there was an info to pop, 0 if the stack was empty. */
242 static int pop_info(void)
243 {
244     APP_INFO *current = NULL;
245
246     if (!RUN_ONCE(&memdbg_init, do_memdbg_init))
247         return 0;
248
249     current = (APP_INFO *)CRYPTO_THREAD_get_local(&appinfokey);
250     if (current != NULL) {
251         APP_INFO *next = current->next;
252
253         if (next != NULL) {
254             next->references++;
255             CRYPTO_THREAD_set_local(&appinfokey, next);
256         } else {
257             CRYPTO_THREAD_set_local(&appinfokey, NULL);
258         }
259         if (--(current->references) <= 0) {
260             current->next = NULL;
261             if (next != NULL)
262                 next->references--;
263             OPENSSL_free(current);
264         }
265         return 1;
266     }
267     return 0;
268 }
269
270 int CRYPTO_mem_debug_push(const char *info, const char *file, int line)
271 {
272     APP_INFO *ami, *amim;
273     int ret = 0;
274
275     if (mem_check_on()) {
276         CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
277
278         if (!RUN_ONCE(&memdbg_init, do_memdbg_init)
279             || (ami = OPENSSL_malloc(sizeof(*ami))) == NULL)
280             goto err;
281
282         ami->threadid = CRYPTO_THREAD_get_current_id();
283         ami->file = file;
284         ami->line = line;
285         ami->info = info;
286         ami->references = 1;
287         ami->next = NULL;
288
289         amim = (APP_INFO *)CRYPTO_THREAD_get_local(&appinfokey);
290         CRYPTO_THREAD_set_local(&appinfokey, ami);
291
292         if (amim != NULL)
293             ami->next = amim;
294         ret = 1;
295  err:
296         CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
297     }
298
299     return ret;
300 }
301
302 int CRYPTO_mem_debug_pop(void)
303 {
304     int ret = 0;
305
306     if (mem_check_on()) {
307         CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
308         ret = pop_info();
309         CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
310     }
311     return ret;
312 }
313
314 static unsigned long break_order_num = 0;
315
316 void CRYPTO_mem_debug_malloc(void *addr, size_t num, int before_p,
317                              const char *file, int line)
318 {
319     MEM *m, *mm;
320     APP_INFO *amim;
321
322     switch (before_p & 127) {
323     case 0:
324         break;
325     case 1:
326         if (addr == NULL)
327             break;
328
329         if (mem_check_on()) {
330             CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
331
332             if (!RUN_ONCE(&memdbg_init, do_memdbg_init)
333                 || (m = OPENSSL_malloc(sizeof(*m))) == NULL) {
334                 OPENSSL_free(addr);
335                 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
336                 return;
337             }
338             if (mh == NULL) {
339                 if ((mh = lh_MEM_new(mem_hash, mem_cmp)) == NULL) {
340                     OPENSSL_free(addr);
341                     OPENSSL_free(m);
342                     addr = NULL;
343                     goto err;
344                 }
345             }
346
347             m->addr = addr;
348             m->file = file;
349             m->line = line;
350             m->num = num;
351             m->threadid = CRYPTO_THREAD_get_current_id();
352
353             if (order == break_order_num) {
354                 /* BREAK HERE */
355                 m->order = order;
356             }
357             m->order = order++;
358 # ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
359             m->array_siz = backtrace(m->array, OSSL_NELEM(m->array));
360 # endif
361             m->time = time(NULL);
362
363             amim = (APP_INFO *)CRYPTO_THREAD_get_local(&appinfokey);
364             m->app_info = amim;
365             if (amim != NULL)
366                 amim->references++;
367
368             if ((mm = lh_MEM_insert(mh, m)) != NULL) {
369                 /* Not good, but don't sweat it */
370                 if (mm->app_info != NULL) {
371                     mm->app_info->references--;
372                 }
373                 OPENSSL_free(mm);
374             }
375  err:
376             CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
377         }
378         break;
379     }
380     return;
381 }
382
383 void CRYPTO_mem_debug_free(void *addr, int before_p,
384         const char *file, int line)
385 {
386     MEM m, *mp;
387
388     switch (before_p) {
389     case 0:
390         if (addr == NULL)
391             break;
392
393         if (mem_check_on() && (mh != NULL)) {
394             CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
395
396             m.addr = addr;
397             mp = lh_MEM_delete(mh, &m);
398             if (mp != NULL) {
399                 app_info_free(mp->app_info);
400                 OPENSSL_free(mp);
401             }
402
403             CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
404         }
405         break;
406     case 1:
407         break;
408     }
409 }
410
411 void CRYPTO_mem_debug_realloc(void *addr1, void *addr2, size_t num,
412                               int before_p, const char *file, int line)
413 {
414     MEM m, *mp;
415
416     switch (before_p) {
417     case 0:
418         break;
419     case 1:
420         if (addr2 == NULL)
421             break;
422
423         if (addr1 == NULL) {
424             CRYPTO_mem_debug_malloc(addr2, num, 128 | before_p, file, line);
425             break;
426         }
427
428         if (mem_check_on()) {
429             CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
430
431             m.addr = addr1;
432             mp = lh_MEM_delete(mh, &m);
433             if (mp != NULL) {
434                 mp->addr = addr2;
435                 mp->num = num;
436 #ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
437                 mp->array_siz = backtrace(mp->array, OSSL_NELEM(mp->array));
438 #endif
439                 (void)lh_MEM_insert(mh, mp);
440             }
441
442             CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
443         }
444         break;
445     }
446     return;
447 }
448
449 typedef struct mem_leak_st {
450     int (*print_cb) (const char *str, size_t len, void *u);
451     void *print_cb_arg;
452     int chunks;
453     long bytes;
454 } MEM_LEAK;
455
456 static void print_leak(const MEM *m, MEM_LEAK *l)
457 {
458     char buf[1024];
459     char *bufp = buf;
460     size_t len = sizeof(buf), ami_cnt;
461     APP_INFO *amip;
462     int n;
463     struct tm *lcl = NULL;
464     /*
465      * Convert between CRYPTO_THREAD_ID (which could be anything at all) and
466      * a long. This may not be meaningful depending on what CRYPTO_THREAD_ID is
467      * but hopefully should give something sensible on most platforms
468      */
469     union {
470         CRYPTO_THREAD_ID tid;
471         unsigned long ltid;
472     } tid;
473     CRYPTO_THREAD_ID ti;
474
475     lcl = localtime(&m->time);
476     n = BIO_snprintf(bufp, len, "[%02d:%02d:%02d] ",
477                      lcl->tm_hour, lcl->tm_min, lcl->tm_sec);
478     if (n <= 0) {
479         bufp[0] = '\0';
480         return;
481     }
482     bufp += n;
483     len -= n;
484
485     n = BIO_snprintf(bufp, len, "%5lu file=%s, line=%d, ",
486                      m->order, m->file, m->line);
487     if (n <= 0)
488         return;
489     bufp += n;
490     len -= n;
491
492     tid.ltid = 0;
493     tid.tid = m->threadid;
494     n = BIO_snprintf(bufp, len, "thread=%lu, ", tid.ltid);
495     if (n <= 0)
496         return;
497     bufp += n;
498     len -= n;
499
500     n = BIO_snprintf(bufp, len, "number=%d, address=%p\n", m->num, m->addr);
501     if (n <= 0)
502         return;
503     bufp += n;
504     len -= n;
505
506     l->print_cb(buf, (size_t)(bufp - buf), l->print_cb_arg);
507
508     l->chunks++;
509     l->bytes += m->num;
510
511     amip = m->app_info;
512     ami_cnt = 0;
513
514     if (amip) {
515         ti = amip->threadid;
516
517         do {
518             int buf_len;
519             int info_len;
520
521             ami_cnt++;
522             if (ami_cnt >= sizeof(buf) - 1)
523                 break;
524             memset(buf, '>', ami_cnt);
525             buf[ami_cnt] = '\0';
526             tid.ltid = 0;
527             tid.tid = amip->threadid;
528             n = BIO_snprintf(buf + ami_cnt, sizeof(buf) - ami_cnt,
529                              " thread=%lu, file=%s, line=%d, info=\"",
530                              tid.ltid, amip->file, amip->line);
531             if (n <= 0)
532                 break;
533             buf_len = ami_cnt + n;
534             info_len = strlen(amip->info);
535             if (128 - buf_len - 3 < info_len) {
536                 memcpy(buf + buf_len, amip->info, 128 - buf_len - 3);
537                 buf_len = 128 - 3;
538             } else {
539                 n = BIO_snprintf(buf + buf_len, sizeof(buf) - buf_len, "%s",
540                                  amip->info);
541                 if (n < 0)
542                     break;
543                 buf_len += n;
544             }
545             n = BIO_snprintf(buf + buf_len, sizeof(buf) - buf_len, "\"\n");
546             if (n <= 0)
547                 break;
548
549             l->print_cb(buf, buf_len + n, l->print_cb_arg);
550
551             amip = amip->next;
552         }
553         while (amip && CRYPTO_THREAD_compare_id(amip->threadid, ti));
554     }
555
556 #ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
557     {
558         size_t i;
559         char **strings = backtrace_symbols(m->array, m->array_siz);
560
561         for (i = 0; i < m->array_siz; i++)
562             fprintf(stderr, "##> %s\n", strings[i]);
563         free(strings);
564     }
565 #endif
566 }
567
568 IMPLEMENT_LHASH_DOALL_ARG_CONST(MEM, MEM_LEAK);
569
570 int CRYPTO_mem_leaks_cb(int (*cb) (const char *str, size_t len, void *u),
571                         void *u)
572 {
573     MEM_LEAK ml;
574
575     /* Ensure all resources are released */
576     OPENSSL_cleanup();
577
578     if (!RUN_ONCE(&memdbg_init, do_memdbg_init))
579         return -1;
580
581     CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
582
583     ml.print_cb = cb;
584     ml.print_cb_arg = u;
585     ml.bytes = 0;
586     ml.chunks = 0;
587     if (mh != NULL)
588         lh_MEM_doall_MEM_LEAK(mh, print_leak, &ml);
589
590     if (ml.chunks != 0) {
591         char buf[256];
592
593         BIO_snprintf(buf, sizeof(buf), "%ld bytes leaked in %d chunks\n",
594                      ml.bytes, ml.chunks);
595         cb(buf, strlen(buf), u);
596     } else {
597         /*
598          * Make sure that, if we found no leaks, memory-leak debugging itself
599          * does not introduce memory leaks (which might irritate external
600          * debugging tools). (When someone enables leak checking, but does not
601          * call this function, we declare it to be their fault.)
602          */
603         int old_mh_mode;
604
605         CRYPTO_THREAD_write_lock(memdbg_lock);
606
607         /*
608          * avoid deadlock when lh_free() uses CRYPTO_mem_debug_free(), which uses
609          * mem_check_on
610          */
611         old_mh_mode = mh_mode;
612         mh_mode = CRYPTO_MEM_CHECK_OFF;
613
614         lh_MEM_free(mh);
615         mh = NULL;
616
617         mh_mode = old_mh_mode;
618         CRYPTO_THREAD_unlock(memdbg_lock);
619     }
620     CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_OFF);
621
622     /* Clean up locks etc */
623     CRYPTO_THREAD_cleanup_local(&appinfokey);
624     CRYPTO_THREAD_lock_free(memdbg_lock);
625     CRYPTO_THREAD_lock_free(long_memdbg_lock);
626     memdbg_lock = NULL;
627     long_memdbg_lock = NULL;
628
629     return ml.chunks == 0 ? 1 : 0;
630 }
631
632 static int print_bio(const char *str, size_t len, void *b)
633 {
634     return BIO_write((BIO *)b, str, len);
635 }
636
637 int CRYPTO_mem_leaks(BIO *b)
638 {
639     /*
640      * OPENSSL_cleanup() will free the ex_data locks so we can't have any
641      * ex_data hanging around
642      */
643     bio_free_ex_data(b);
644
645     return CRYPTO_mem_leaks_cb(print_bio, b);
646 }
647
648 # ifndef OPENSSL_NO_STDIO
649 int CRYPTO_mem_leaks_fp(FILE *fp)
650 {
651     BIO *b;
652     int ret;
653
654     /*
655      * Need to turn off memory checking when allocated BIOs ... especially as
656      * we're creating them at a time when we're trying to check we've not
657      * left anything un-free()'d!!
658      */
659     CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
660     b = BIO_new(BIO_s_file());
661     CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
662     if (b == NULL)
663         return -1;
664     BIO_set_fp(b, fp, BIO_NOCLOSE);
665     ret = CRYPTO_mem_leaks_cb(print_bio, b);
666     BIO_free(b);
667     return ret;
668 }
669 # endif
670
671 #endif