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