56c358586508c2a54617b27cc728f3e2c12c28dd
[openssl.git] / crypto / mem.c
1 /* crypto/mem.c */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  *
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to.  The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  *
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  *
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in the
30  *    documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  *    must display the following acknowledgement:
33  *    "This product includes cryptographic software written by
34  *     Eric Young (eay@cryptsoft.com)"
35  *    The word 'cryptographic' can be left out if the rouines from the library
36  *    being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from
38  *    the apps directory (application code) you must include an acknowledgement:
39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  *
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  *
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  */
58
59 #include <stdio.h>
60 #include <stdlib.h>
61 #include <openssl/crypto.h>
62 #include "internal/cryptlib.h"
63
64 static int allow_customize = 1; /* we provide flexible functions for */
65 static int allow_customize_debug = 1; /* exchanging memory-related functions
66                                        * at run-time, but this must be done
67                                        * before any blocks are actually
68                                        * allocated; or we'll run into huge
69                                        * problems when malloc/free pairs
70                                        * don't match etc. */
71
72 /*
73  * the following pointers may be changed as long as 'allow_customize' is set
74  */
75
76 static void *(*malloc_func) (size_t) = malloc;
77 static void *default_malloc_ex(size_t num, const char *file, int line)
78 {
79     return malloc_func(num);
80 }
81
82 static void *(*malloc_ex_func) (size_t, const char *file, int line)
83     = default_malloc_ex;
84
85 static void *(*realloc_func) (void *, size_t) = realloc;
86 static void *default_realloc_ex(void *str, size_t num,
87                                 const char *file, int line)
88 {
89     return realloc_func(str, num);
90 }
91
92 static void *(*realloc_ex_func) (void *, size_t, const char *file, int line)
93     = default_realloc_ex;
94
95 static void (*free_func) (void *) = free;
96
97 static void *(*malloc_secure_func)(size_t) = malloc;
98 static void *default_malloc_secure_ex(size_t num, const char *file, int line)
99 {
100     return malloc_secure_func(num);
101 }
102 static void *(*malloc_secure_ex_func)(size_t, const char *file, int line)
103     = default_malloc_secure_ex;
104 static void (*free_secure_func)(void *) = free;
105
106 static void *(*malloc_locked_func) (size_t) = malloc;
107 static void *default_malloc_locked_ex(size_t num, const char *file, int line)
108 {
109     return malloc_locked_func(num);
110 }
111
112 static void *(*malloc_locked_ex_func) (size_t, const char *file, int line)
113     = default_malloc_locked_ex;
114
115 static void (*free_locked_func) (void *) = free;
116
117 /* may be changed as long as 'allow_customize_debug' is set */
118 /* XXX use correct function pointer types */
119 #ifdef CRYPTO_MDEBUG
120 /* use default functions from mem_dbg.c */
121 static void (*malloc_debug_func) (void *, int, const char *, int, int)
122     = CRYPTO_dbg_malloc;
123 static void (*realloc_debug_func) (void *, void *, int, const char *, int,
124                                    int)
125     = CRYPTO_dbg_realloc;
126 static void (*free_debug_func) (void *, int) = CRYPTO_dbg_free;
127 static void (*set_debug_options_func) (long) = CRYPTO_dbg_set_options;
128 static long (*get_debug_options_func) (void) = CRYPTO_dbg_get_options;
129 #else
130 /*
131  * applications can use CRYPTO_malloc_debug_init() to select above case at
132  * run-time
133  */
134 static void (*malloc_debug_func) (void *, int, const char *, int, int) = NULL;
135 static void (*realloc_debug_func) (void *, void *, int, const char *, int,
136                                    int)
137     = NULL;
138 static void (*free_debug_func) (void *, int) = NULL;
139 static void (*set_debug_options_func) (long) = NULL;
140 static long (*get_debug_options_func) (void) = NULL;
141 #endif
142
143 int CRYPTO_set_mem_functions(void *(*m) (size_t), void *(*r) (void *, size_t),
144                              void (*f) (void *))
145 {
146     /* Dummy call just to ensure OPENSSL_init() gets linked in */
147     OPENSSL_init();
148     if (!allow_customize)
149         return 0;
150     if ((m == 0) || (r == 0) || (f == 0))
151         return 0;
152     malloc_func = m;
153     malloc_ex_func = default_malloc_ex;
154     realloc_func = r;
155     realloc_ex_func = default_realloc_ex;
156     free_func = f;
157     /* If user wants to intercept the secure or locked functions, do it
158      * after the basic functions. */
159     malloc_secure_func = m;
160     malloc_secure_ex_func = default_malloc_secure_ex;
161     free_secure_func = f;
162     malloc_locked_func = m;
163     malloc_locked_ex_func = default_malloc_locked_ex;
164     free_locked_func = f;
165     return 1;
166 }
167
168 int CRYPTO_set_mem_ex_functions(void *(*m) (size_t, const char *, int),
169                                 void *(*r) (void *, size_t, const char *,
170                                             int), void (*f) (void *))
171 {
172     if (!allow_customize)
173         return 0;
174     if ((m == 0) || (r == 0) || (f == 0))
175         return 0;
176     malloc_func = 0;
177     malloc_ex_func = m;
178     realloc_func = 0;
179     realloc_ex_func = r;
180     free_func = f;
181     malloc_secure_func = 0;
182     malloc_secure_ex_func = m;
183     free_secure_func = f;
184     malloc_locked_func = 0;
185     malloc_locked_ex_func = m;
186     free_locked_func = f;
187     return 1;
188 }
189
190 int CRYPTO_set_secure_mem_functions(void *(*m)(size_t), void (*f)(void *))
191 {
192     /* Dummy call just to ensure OPENSSL_init() gets linked in */
193     OPENSSL_init();
194     if (!allow_customize)
195         return 0;
196     if ((m == 0) || (f == 0))
197         return 0;
198     malloc_secure_func = m;
199     malloc_secure_ex_func = default_malloc_secure_ex;
200     free_secure_func = f;
201     /* If user wants to intercept the locked functions, do it after
202      * the secure functions. */
203     malloc_locked_func = m;
204     malloc_locked_ex_func = default_malloc_secure_ex;
205     free_locked_func = f;
206     return 1;
207 }
208
209 int CRYPTO_set_secure_mem_ex_functions(void *(*m)(size_t, const char *, int),
210                                        void (*f)(void *))
211 {
212     if (!allow_customize)
213         return 0;
214     if ((m == NULL) || (f == NULL))
215         return 0;
216     malloc_secure_func = 0;
217     malloc_secure_ex_func = m;
218     free_secure_func = f;
219     malloc_locked_func = 0;
220     malloc_locked_ex_func = m;
221     free_locked_func = f;
222     return 1;
223 }
224
225 int CRYPTO_set_locked_mem_functions(void *(*m) (size_t), void (*f) (void *))
226 {
227     if (!allow_customize)
228         return 0;
229     if ((m == NULL) || (f == NULL))
230         return 0;
231     malloc_locked_func = m;
232     malloc_locked_ex_func = default_malloc_locked_ex;
233     free_locked_func = f;
234     return 1;
235 }
236
237 int CRYPTO_set_locked_mem_ex_functions(void *(*m) (size_t, const char *, int),
238                                        void (*f) (void *))
239 {
240     if (!allow_customize)
241         return 0;
242     if ((m == NULL) || (f == NULL))
243         return 0;
244     malloc_locked_func = 0;
245     malloc_locked_ex_func = m;
246     free_locked_func = f;
247     return 1;
248 }
249
250 int CRYPTO_set_mem_debug_functions(void (*m)
251                                     (void *, int, const char *, int, int),
252                                    void (*r) (void *, void *, int,
253                                               const char *, int, int),
254                                    void (*f) (void *, int), void (*so) (long),
255                                    long (*go) (void))
256 {
257     if (!allow_customize_debug)
258         return 0;
259     malloc_debug_func = m;
260     realloc_debug_func = r;
261     free_debug_func = f;
262     set_debug_options_func = so;
263     get_debug_options_func = go;
264     return 1;
265 }
266
267 void CRYPTO_get_mem_functions(void *(**m) (size_t),
268                               void *(**r) (void *, size_t),
269                               void (**f) (void *))
270 {
271     if (m != NULL)
272         *m = (malloc_ex_func == default_malloc_ex) ? malloc_func : 0;
273     if (r != NULL)
274         *r = (realloc_ex_func == default_realloc_ex) ? realloc_func : 0;
275     if (f != NULL)
276         *f = free_func;
277 }
278
279 void CRYPTO_get_mem_ex_functions(void *(**m) (size_t, const char *, int),
280                                  void *(**r) (void *, size_t, const char *,
281                                               int), void (**f) (void *))
282 {
283     if (m != NULL)
284         *m = (malloc_ex_func != default_malloc_ex) ? malloc_ex_func : 0;
285     if (r != NULL)
286         *r = (realloc_ex_func != default_realloc_ex) ? realloc_ex_func : 0;
287     if (f != NULL)
288         *f = free_func;
289 }
290
291 void CRYPTO_get_secure_mem_functions(void *(**m)(size_t), void (**f)(void *))
292 {
293     if (m != NULL)
294         *m = (malloc_secure_ex_func == default_malloc_secure_ex) ?
295             malloc_secure_func : 0;
296     if (f != NULL)
297         *f=free_secure_func;
298         }
299
300 void CRYPTO_get_secure_mem_ex_functions(void *(**m)(size_t,const char *,int),
301                                         void (**f)(void *))
302 {
303     if (m != NULL)
304         *m = (malloc_secure_ex_func != default_malloc_secure_ex) ?
305             malloc_secure_ex_func : 0;
306     if (f != NULL)
307         *f=free_secure_func;
308 }
309
310 void CRYPTO_get_locked_mem_functions(void *(**m) (size_t),
311                                      void (**f) (void *))
312 {
313     if (m != NULL)
314         *m = (malloc_locked_ex_func == default_malloc_locked_ex) ?
315             malloc_locked_func : 0;
316     if (f != NULL)
317         *f = free_locked_func;
318 }
319
320 void CRYPTO_get_locked_mem_ex_functions(void
321                                         *(**m) (size_t, const char *, int),
322                                         void (**f) (void *))
323 {
324     if (m != NULL)
325         *m = (malloc_locked_ex_func != default_malloc_locked_ex) ?
326             malloc_locked_ex_func : 0;
327     if (f != NULL)
328         *f = free_locked_func;
329 }
330
331 void CRYPTO_get_mem_debug_functions(void (**m)
332                                      (void *, int, const char *, int, int),
333                                     void (**r) (void *, void *, int,
334                                                 const char *, int, int),
335                                     void (**f) (void *, int),
336                                     void (**so) (long), long (**go) (void))
337 {
338     if (m != NULL)
339         *m = malloc_debug_func;
340     if (r != NULL)
341         *r = realloc_debug_func;
342     if (f != NULL)
343         *f = free_debug_func;
344     if (so != NULL)
345         *so = set_debug_options_func;
346     if (go != NULL)
347         *go = get_debug_options_func;
348 }
349
350 void *CRYPTO_malloc_locked(int num, const char *file, int line)
351 {
352     void *ret = NULL;
353
354     if (num <= 0)
355         return NULL;
356
357     if (allow_customize)
358         allow_customize = 0;
359     if (malloc_debug_func != NULL) {
360         if (allow_customize_debug)
361             allow_customize_debug = 0;
362         malloc_debug_func(NULL, num, file, line, 0);
363     }
364     ret = malloc_locked_ex_func(num, file, line);
365 #ifdef LEVITTE_DEBUG_MEM
366     fprintf(stderr, "LEVITTE_DEBUG_MEM:         > 0x%p (%d)\n", ret, num);
367 #endif
368     if (malloc_debug_func != NULL)
369         malloc_debug_func(ret, num, file, line, 1);
370
371 #ifndef OPENSSL_CPUID_OBJ
372     /*
373      * Create a dependency on the value of 'cleanse_ctr' so our memory
374      * sanitisation function can't be optimised out. NB: We only do this for
375      * >2Kb so the overhead doesn't bother us.
376      */
377     if (ret && (num > 2048)) {
378         extern unsigned char cleanse_ctr;
379         ((unsigned char *)ret)[0] = cleanse_ctr;
380     }
381 #endif
382
383     return ret;
384 }
385
386 void CRYPTO_free_locked(void *str)
387 {
388     if (free_debug_func != NULL)
389         free_debug_func(str, 0);
390 #ifdef LEVITTE_DEBUG_MEM
391     fprintf(stderr, "LEVITTE_DEBUG_MEM:         < 0x%p\n", str);
392 #endif
393     free_locked_func(str);
394     if (free_debug_func != NULL)
395         free_debug_func(NULL, 1);
396 }
397
398 void *CRYPTO_malloc(int num, const char *file, int line)
399 {
400     void *ret = NULL;
401
402     if (num <= 0)
403         return NULL;
404
405     if (allow_customize)
406         allow_customize = 0;
407     if (malloc_debug_func != NULL) {
408         if (allow_customize_debug)
409             allow_customize_debug = 0;
410         malloc_debug_func(NULL, num, file, line, 0);
411     }
412     ret = malloc_ex_func(num, file, line);
413 #ifdef LEVITTE_DEBUG_MEM
414     fprintf(stderr, "LEVITTE_DEBUG_MEM:         > 0x%p (%d)\n", ret, num);
415 #endif
416     if (malloc_debug_func != NULL)
417         malloc_debug_func(ret, num, file, line, 1);
418
419 #ifndef OPENSSL_CPUID_OBJ
420     /*
421      * Create a dependency on the value of 'cleanse_ctr' so our memory
422      * sanitisation function can't be optimised out. NB: We only do this for
423      * >2Kb so the overhead doesn't bother us.
424      */
425     if (ret && (num > 2048)) {
426         extern unsigned char cleanse_ctr;
427         ((unsigned char *)ret)[0] = cleanse_ctr;
428     }
429 #endif
430
431     return ret;
432 }
433
434 char *CRYPTO_strdup(const char *str, const char *file, int line)
435 {
436     char *ret = CRYPTO_malloc(strlen(str) + 1, file, line);
437
438     if (ret == NULL)
439         return NULL;
440
441     strcpy(ret, str);
442     return ret;
443 }
444
445 void *CRYPTO_realloc(void *str, int num, const char *file, int line)
446 {
447     void *ret = NULL;
448
449     if (str == NULL)
450         return CRYPTO_malloc(num, file, line);
451
452     if (num <= 0)
453         return NULL;
454
455     if (realloc_debug_func != NULL)
456         realloc_debug_func(str, NULL, num, file, line, 0);
457     ret = realloc_ex_func(str, num, file, line);
458 #ifdef LEVITTE_DEBUG_MEM
459     fprintf(stderr, "LEVITTE_DEBUG_MEM:         | 0x%p -> 0x%p (%d)\n", str,
460             ret, num);
461 #endif
462     if (realloc_debug_func != NULL)
463         realloc_debug_func(str, ret, num, file, line, 1);
464
465     return ret;
466 }
467
468 void *CRYPTO_realloc_clean(void *str, int old_len, int num, const char *file,
469                            int line)
470 {
471     void *ret = NULL;
472
473     if (str == NULL)
474         return CRYPTO_malloc(num, file, line);
475
476     if (num <= 0)
477         return NULL;
478
479     /*
480      * We don't support shrinking the buffer. Note the memcpy that copies
481      * |old_len| bytes to the new buffer, below.
482      */
483     if (num < old_len)
484         return NULL;
485
486     if (realloc_debug_func != NULL)
487         realloc_debug_func(str, NULL, num, file, line, 0);
488     ret = malloc_ex_func(num, file, line);
489     if (ret) {
490         memcpy(ret, str, old_len);
491         OPENSSL_clear_free(str, old_len);
492     }
493 #ifdef LEVITTE_DEBUG_MEM
494     fprintf(stderr,
495             "LEVITTE_DEBUG_MEM:         | 0x%p -> 0x%p (%d)\n",
496             str, ret, num);
497 #endif
498     if (realloc_debug_func != NULL)
499         realloc_debug_func(str, ret, num, file, line, 1);
500
501     return ret;
502 }
503
504 void CRYPTO_free(void *str)
505 {
506     if (free_debug_func != NULL)
507         free_debug_func(str, 0);
508 #ifdef LEVITTE_DEBUG_MEM
509     fprintf(stderr, "LEVITTE_DEBUG_MEM:         < 0x%p\n", str);
510 #endif
511     free_func(str);
512     if (free_debug_func != NULL)
513         free_debug_func(NULL, 1);
514 }
515
516 void CRYPTO_clear_free(void *str, size_t num)
517 {
518     if (!str)
519         return;
520     if (num)
521         OPENSSL_cleanse(str, num);
522     CRYPTO_free(str);
523 }
524
525 void *CRYPTO_remalloc(void *a, int num, const char *file, int line)
526 {
527     OPENSSL_free(a);
528     a = OPENSSL_malloc(num);
529     return (a);
530 }
531
532 void CRYPTO_set_mem_debug_options(long bits)
533 {
534     if (set_debug_options_func != NULL)
535         set_debug_options_func(bits);
536 }
537
538 long CRYPTO_get_mem_debug_options(void)
539 {
540     if (get_debug_options_func != NULL)
541         return get_debug_options_func();
542     return 0;
543 }