8b9c8c38051b9b95530c1e4a17bb9ed68efd0379
[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 /* may be changed as long as 'allow_customize_debug' is set */
107 /* XXX use correct function pointer types */
108 #ifdef CRYPTO_MDEBUG
109 /* use default functions from mem_dbg.c */
110 static void (*malloc_debug_func) (void *, int, const char *, int, int)
111     = CRYPTO_dbg_malloc;
112 static void (*realloc_debug_func) (void *, void *, int, const char *, int,
113                                    int)
114     = CRYPTO_dbg_realloc;
115 static void (*free_debug_func) (void *, int) = CRYPTO_dbg_free;
116 static void (*set_debug_options_func) (long) = CRYPTO_dbg_set_options;
117 static long (*get_debug_options_func) (void) = CRYPTO_dbg_get_options;
118 #else
119 /*
120  * applications can use CRYPTO_malloc_debug_init() to select above case at
121  * run-time
122  */
123 static void (*malloc_debug_func) (void *, int, const char *, int, int) = NULL;
124 static void (*realloc_debug_func) (void *, void *, int, const char *, int,
125                                    int)
126     = NULL;
127 static void (*free_debug_func) (void *, int) = NULL;
128 static void (*set_debug_options_func) (long) = NULL;
129 static long (*get_debug_options_func) (void) = NULL;
130 #endif
131
132 int CRYPTO_set_mem_functions(void *(*m) (size_t), void *(*r) (void *, size_t),
133                              void (*f) (void *))
134 {
135     /* Dummy call just to ensure OPENSSL_init() gets linked in */
136     OPENSSL_init();
137     if (!allow_customize)
138         return 0;
139     if ((m == 0) || (r == 0) || (f == 0))
140         return 0;
141     malloc_func = m;
142     malloc_ex_func = default_malloc_ex;
143     realloc_func = r;
144     realloc_ex_func = default_realloc_ex;
145     free_func = f;
146     /* If user wants to intercept the secure or locked functions, do it
147      * after the basic functions. */
148     malloc_secure_func = m;
149     malloc_secure_ex_func = default_malloc_secure_ex;
150     free_secure_func = f;
151     return 1;
152 }
153
154 int CRYPTO_set_mem_ex_functions(void *(*m) (size_t, const char *, int),
155                                 void *(*r) (void *, size_t, const char *,
156                                             int), void (*f) (void *))
157 {
158     if (!allow_customize)
159         return 0;
160     if ((m == 0) || (r == 0) || (f == 0))
161         return 0;
162     malloc_func = 0;
163     malloc_ex_func = m;
164     realloc_func = 0;
165     realloc_ex_func = r;
166     free_func = f;
167     malloc_secure_func = 0;
168     malloc_secure_ex_func = m;
169     free_secure_func = f;
170     return 1;
171 }
172
173 int CRYPTO_set_secure_mem_functions(void *(*m)(size_t), void (*f)(void *))
174 {
175     /* Dummy call just to ensure OPENSSL_init() gets linked in */
176     OPENSSL_init();
177     if (!allow_customize)
178         return 0;
179     if ((m == 0) || (f == 0))
180         return 0;
181     malloc_secure_func = m;
182     malloc_secure_ex_func = default_malloc_secure_ex;
183     free_secure_func = f;
184     return 1;
185 }
186
187 int CRYPTO_set_secure_mem_ex_functions(void *(*m)(size_t, const char *, int),
188                                        void (*f)(void *))
189 {
190     if (!allow_customize)
191         return 0;
192     if ((m == NULL) || (f == NULL))
193         return 0;
194     malloc_secure_func = 0;
195     malloc_secure_ex_func = m;
196     free_secure_func = f;
197     return 1;
198 }
199
200 int CRYPTO_set_mem_debug_functions(void (*m)
201                                     (void *, int, const char *, int, int),
202                                    void (*r) (void *, void *, int,
203                                               const char *, int, int),
204                                    void (*f) (void *, int), void (*so) (long),
205                                    long (*go) (void))
206 {
207     if (!allow_customize_debug)
208         return 0;
209     malloc_debug_func = m;
210     realloc_debug_func = r;
211     free_debug_func = f;
212     set_debug_options_func = so;
213     get_debug_options_func = go;
214     return 1;
215 }
216
217 void CRYPTO_get_mem_functions(void *(**m) (size_t),
218                               void *(**r) (void *, size_t),
219                               void (**f) (void *))
220 {
221     if (m != NULL)
222         *m = (malloc_ex_func == default_malloc_ex) ? malloc_func : 0;
223     if (r != NULL)
224         *r = (realloc_ex_func == default_realloc_ex) ? realloc_func : 0;
225     if (f != NULL)
226         *f = free_func;
227 }
228
229 void CRYPTO_get_mem_ex_functions(void *(**m) (size_t, const char *, int),
230                                  void *(**r) (void *, size_t, const char *,
231                                               int), void (**f) (void *))
232 {
233     if (m != NULL)
234         *m = (malloc_ex_func != default_malloc_ex) ? malloc_ex_func : 0;
235     if (r != NULL)
236         *r = (realloc_ex_func != default_realloc_ex) ? realloc_ex_func : 0;
237     if (f != NULL)
238         *f = free_func;
239 }
240
241 void CRYPTO_get_secure_mem_functions(void *(**m)(size_t), void (**f)(void *))
242 {
243     if (m != NULL)
244         *m = (malloc_secure_ex_func == default_malloc_secure_ex) ?
245             malloc_secure_func : 0;
246     if (f != NULL)
247         *f=free_secure_func;
248         }
249
250 void CRYPTO_get_secure_mem_ex_functions(void *(**m)(size_t,const char *,int),
251                                         void (**f)(void *))
252 {
253     if (m != NULL)
254         *m = (malloc_secure_ex_func != default_malloc_secure_ex) ?
255             malloc_secure_ex_func : 0;
256     if (f != NULL)
257         *f=free_secure_func;
258 }
259
260 void CRYPTO_get_mem_debug_functions(void (**m)
261                                      (void *, int, const char *, int, int),
262                                     void (**r) (void *, void *, int,
263                                                 const char *, int, int),
264                                     void (**f) (void *, int),
265                                     void (**so) (long), long (**go) (void))
266 {
267     if (m != NULL)
268         *m = malloc_debug_func;
269     if (r != NULL)
270         *r = realloc_debug_func;
271     if (f != NULL)
272         *f = free_debug_func;
273     if (so != NULL)
274         *so = set_debug_options_func;
275     if (go != NULL)
276         *go = get_debug_options_func;
277 }
278
279 void *CRYPTO_malloc(int num, const char *file, int line)
280 {
281     void *ret = NULL;
282
283     if (num <= 0)
284         return NULL;
285
286     if (allow_customize)
287         allow_customize = 0;
288     if (malloc_debug_func != NULL) {
289         if (allow_customize_debug)
290             allow_customize_debug = 0;
291         malloc_debug_func(NULL, num, file, line, 0);
292     }
293     ret = malloc_ex_func(num, file, line);
294 #ifdef LEVITTE_DEBUG_MEM
295     fprintf(stderr, "LEVITTE_DEBUG_MEM:         > 0x%p (%d)\n", ret, num);
296 #endif
297     if (malloc_debug_func != NULL)
298         malloc_debug_func(ret, num, file, line, 1);
299
300 #ifndef OPENSSL_CPUID_OBJ
301     /*
302      * Create a dependency on the value of 'cleanse_ctr' so our memory
303      * sanitisation function can't be optimised out. NB: We only do this for
304      * >2Kb so the overhead doesn't bother us.
305      */
306     if (ret && (num > 2048)) {
307         extern unsigned char cleanse_ctr;
308         ((unsigned char *)ret)[0] = cleanse_ctr;
309     }
310 #endif
311
312     return ret;
313 }
314
315 char *CRYPTO_strdup(const char *str, const char *file, int line)
316 {
317     char *ret = CRYPTO_malloc(strlen(str) + 1, file, line);
318
319     if (ret == NULL)
320         return NULL;
321
322     strcpy(ret, str);
323     return ret;
324 }
325
326 void *CRYPTO_realloc(void *str, int num, const char *file, int line)
327 {
328     void *ret = NULL;
329
330     if (str == NULL)
331         return CRYPTO_malloc(num, file, line);
332
333     if (num <= 0)
334         return NULL;
335
336     if (realloc_debug_func != NULL)
337         realloc_debug_func(str, NULL, num, file, line, 0);
338     ret = realloc_ex_func(str, num, file, line);
339 #ifdef LEVITTE_DEBUG_MEM
340     fprintf(stderr, "LEVITTE_DEBUG_MEM:         | 0x%p -> 0x%p (%d)\n", str,
341             ret, num);
342 #endif
343     if (realloc_debug_func != NULL)
344         realloc_debug_func(str, ret, num, file, line, 1);
345
346     return ret;
347 }
348
349 void *CRYPTO_realloc_clean(void *str, int old_len, int num, const char *file,
350                            int line)
351 {
352     void *ret = NULL;
353
354     if (str == NULL)
355         return CRYPTO_malloc(num, file, line);
356
357     if (num <= 0)
358         return NULL;
359
360     /*
361      * We don't support shrinking the buffer. Note the memcpy that copies
362      * |old_len| bytes to the new buffer, below.
363      */
364     if (num < old_len)
365         return NULL;
366
367     if (realloc_debug_func != NULL)
368         realloc_debug_func(str, NULL, num, file, line, 0);
369     ret = malloc_ex_func(num, file, line);
370     if (ret) {
371         memcpy(ret, str, old_len);
372         OPENSSL_clear_free(str, old_len);
373     }
374 #ifdef LEVITTE_DEBUG_MEM
375     fprintf(stderr,
376             "LEVITTE_DEBUG_MEM:         | 0x%p -> 0x%p (%d)\n",
377             str, ret, num);
378 #endif
379     if (realloc_debug_func != NULL)
380         realloc_debug_func(str, ret, num, file, line, 1);
381
382     return ret;
383 }
384
385 void CRYPTO_free(void *str)
386 {
387     if (free_debug_func != NULL)
388         free_debug_func(str, 0);
389 #ifdef LEVITTE_DEBUG_MEM
390     fprintf(stderr, "LEVITTE_DEBUG_MEM:         < 0x%p\n", str);
391 #endif
392     free_func(str);
393     if (free_debug_func != NULL)
394         free_debug_func(NULL, 1);
395 }
396
397 void CRYPTO_clear_free(void *str, size_t num)
398 {
399     if (!str)
400         return;
401     if (num)
402         OPENSSL_cleanse(str, num);
403     CRYPTO_free(str);
404 }
405
406 void *CRYPTO_remalloc(void *a, int num, const char *file, int line)
407 {
408     OPENSSL_free(a);
409     a = OPENSSL_malloc(num);
410     return (a);
411 }
412
413 void CRYPTO_set_mem_debug_options(long bits)
414 {
415     if (set_debug_options_func != NULL)
416         set_debug_options_func(bits);
417 }
418
419 long CRYPTO_get_mem_debug_options(void)
420 {
421     if (get_debug_options_func != NULL)
422         return get_debug_options_func();
423     return 0;
424 }