mem.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459
  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. #include <stdio.h>
  59. #include <stdlib.h>
  60. #include <openssl/crypto.h>
  61. #include "cryptlib.h"
  62. static int allow_customize = 1; /* we provide flexible functions for */
  63. static int allow_customize_debug = 1; /* exchanging memory-related functions
  64. * at run-time, but this must be done
  65. * before any blocks are actually
  66. * allocated; or we'll run into huge
  67. * problems when malloc/free pairs
  68. * don't match etc. */
  69. /*
  70. * the following pointers may be changed as long as 'allow_customize' is set
  71. */
  72. static void *(*malloc_func) (size_t) = malloc;
  73. static void *default_malloc_ex(size_t num, const char *file, int line)
  74. {
  75. return malloc_func(num);
  76. }
  77. static void *(*malloc_ex_func) (size_t, const char *file, int line)
  78. = default_malloc_ex;
  79. #ifdef OPENSSL_SYS_VMS
  80. # if __INITIAL_POINTER_SIZE == 64
  81. # define realloc _realloc64
  82. # elif __INITIAL_POINTER_SIZE == 32
  83. # define realloc _realloc32
  84. # endif
  85. #endif
  86. static void *(*realloc_func) (void *, size_t) = realloc;
  87. static void *default_realloc_ex(void *str, size_t num,
  88. const char *file, int line)
  89. {
  90. return realloc_func(str, num);
  91. }
  92. static void *(*realloc_ex_func) (void *, size_t, const char *file, int line)
  93. = default_realloc_ex;
  94. #ifdef OPENSSL_SYS_VMS
  95. static void (*free_func) (__void_ptr64) = free;
  96. #else
  97. static void (*free_func) (void *) = free;
  98. #endif
  99. static void *(*malloc_locked_func) (size_t) = malloc;
  100. static void *default_malloc_locked_ex(size_t num, const char *file, int line)
  101. {
  102. return malloc_locked_func(num);
  103. }
  104. static void *(*malloc_locked_ex_func) (size_t, const char *file, int line)
  105. = default_malloc_locked_ex;
  106. #ifdef OPENSSL_SYS_VMS
  107. static void (*free_locked_func) (__void_ptr64) = free;
  108. #else
  109. static void (*free_locked_func) (void *) = free;
  110. #endif
  111. /* may be changed as long as 'allow_customize_debug' is set */
  112. /* XXX use correct function pointer types */
  113. #ifdef CRYPTO_MDEBUG
  114. /* use default functions from mem_dbg.c */
  115. static void (*malloc_debug_func) (void *, int, const char *, int, int)
  116. = CRYPTO_dbg_malloc;
  117. static void (*realloc_debug_func) (void *, void *, int, const char *, int,
  118. int)
  119. = CRYPTO_dbg_realloc;
  120. static void (*free_debug_func) (void *, int) = CRYPTO_dbg_free;
  121. static void (*set_debug_options_func) (long) = CRYPTO_dbg_set_options;
  122. static long (*get_debug_options_func) (void) = CRYPTO_dbg_get_options;
  123. #else
  124. /*
  125. * applications can use CRYPTO_malloc_debug_init() to select above case at
  126. * run-time
  127. */
  128. static void (*malloc_debug_func) (void *, int, const char *, int, int) = NULL;
  129. static void (*realloc_debug_func) (void *, void *, int, const char *, int,
  130. int)
  131. = NULL;
  132. static void (*free_debug_func) (void *, int) = NULL;
  133. static void (*set_debug_options_func) (long) = NULL;
  134. static long (*get_debug_options_func) (void) = NULL;
  135. #endif
  136. int CRYPTO_set_mem_functions(void *(*m) (size_t), void *(*r) (void *, size_t),
  137. void (*f) (void *))
  138. {
  139. if (!allow_customize)
  140. return 0;
  141. if ((m == 0) || (r == 0) || (f == 0))
  142. return 0;
  143. /* Dummy call just to ensure OPENSSL_init() gets linked in */
  144. OPENSSL_init();
  145. malloc_func = m;
  146. malloc_ex_func = default_malloc_ex;
  147. realloc_func = r;
  148. realloc_ex_func = default_realloc_ex;
  149. free_func = f;
  150. malloc_locked_func = m;
  151. malloc_locked_ex_func = default_malloc_locked_ex;
  152. free_locked_func = f;
  153. return 1;
  154. }
  155. int CRYPTO_set_mem_ex_functions(void *(*m) (size_t, const char *, int),
  156. void *(*r) (void *, size_t, const char *,
  157. int), void (*f) (void *))
  158. {
  159. if (!allow_customize)
  160. return 0;
  161. if ((m == 0) || (r == 0) || (f == 0))
  162. return 0;
  163. malloc_func = 0;
  164. malloc_ex_func = m;
  165. realloc_func = 0;
  166. realloc_ex_func = r;
  167. free_func = f;
  168. malloc_locked_func = 0;
  169. malloc_locked_ex_func = m;
  170. free_locked_func = f;
  171. return 1;
  172. }
  173. int CRYPTO_set_locked_mem_functions(void *(*m) (size_t), void (*f) (void *))
  174. {
  175. if (!allow_customize)
  176. return 0;
  177. if ((m == NULL) || (f == NULL))
  178. return 0;
  179. malloc_locked_func = m;
  180. malloc_locked_ex_func = default_malloc_locked_ex;
  181. free_locked_func = f;
  182. return 1;
  183. }
  184. int CRYPTO_set_locked_mem_ex_functions(void *(*m) (size_t, const char *, int),
  185. void (*f) (void *))
  186. {
  187. if (!allow_customize)
  188. return 0;
  189. if ((m == NULL) || (f == NULL))
  190. return 0;
  191. malloc_locked_func = 0;
  192. malloc_locked_ex_func = m;
  193. free_func = f;
  194. return 1;
  195. }
  196. int CRYPTO_set_mem_debug_functions(void (*m)
  197. (void *, int, const char *, int, int),
  198. void (*r) (void *, void *, int,
  199. const char *, int, int),
  200. void (*f) (void *, int), void (*so) (long),
  201. long (*go) (void))
  202. {
  203. if (!allow_customize_debug)
  204. return 0;
  205. OPENSSL_init();
  206. malloc_debug_func = m;
  207. realloc_debug_func = r;
  208. free_debug_func = f;
  209. set_debug_options_func = so;
  210. get_debug_options_func = go;
  211. return 1;
  212. }
  213. void CRYPTO_get_mem_functions(void *(**m) (size_t),
  214. void *(**r) (void *, size_t),
  215. void (**f) (void *))
  216. {
  217. if (m != NULL)
  218. *m = (malloc_ex_func == default_malloc_ex) ? malloc_func : 0;
  219. if (r != NULL)
  220. *r = (realloc_ex_func == default_realloc_ex) ? realloc_func : 0;
  221. if (f != NULL)
  222. *f = free_func;
  223. }
  224. void CRYPTO_get_mem_ex_functions(void *(**m) (size_t, const char *, int),
  225. void *(**r) (void *, size_t, const char *,
  226. int), void (**f) (void *))
  227. {
  228. if (m != NULL)
  229. *m = (malloc_ex_func != default_malloc_ex) ? malloc_ex_func : 0;
  230. if (r != NULL)
  231. *r = (realloc_ex_func != default_realloc_ex) ? realloc_ex_func : 0;
  232. if (f != NULL)
  233. *f = free_func;
  234. }
  235. void CRYPTO_get_locked_mem_functions(void *(**m) (size_t),
  236. void (**f) (void *))
  237. {
  238. if (m != NULL)
  239. *m = (malloc_locked_ex_func == default_malloc_locked_ex) ?
  240. malloc_locked_func : 0;
  241. if (f != NULL)
  242. *f = free_locked_func;
  243. }
  244. void CRYPTO_get_locked_mem_ex_functions(void
  245. *(**m) (size_t, const char *, int),
  246. void (**f) (void *))
  247. {
  248. if (m != NULL)
  249. *m = (malloc_locked_ex_func != default_malloc_locked_ex) ?
  250. malloc_locked_ex_func : 0;
  251. if (f != NULL)
  252. *f = free_locked_func;
  253. }
  254. void CRYPTO_get_mem_debug_functions(void (**m)
  255. (void *, int, const char *, int, int),
  256. void (**r) (void *, void *, int,
  257. const char *, int, int),
  258. void (**f) (void *, int),
  259. void (**so) (long), long (**go) (void))
  260. {
  261. if (m != NULL)
  262. *m = malloc_debug_func;
  263. if (r != NULL)
  264. *r = realloc_debug_func;
  265. if (f != NULL)
  266. *f = free_debug_func;
  267. if (so != NULL)
  268. *so = set_debug_options_func;
  269. if (go != NULL)
  270. *go = get_debug_options_func;
  271. }
  272. void *CRYPTO_malloc_locked(int num, const char *file, int line)
  273. {
  274. void *ret = NULL;
  275. if (num <= 0)
  276. return NULL;
  277. if (allow_customize)
  278. allow_customize = 0;
  279. if (malloc_debug_func != NULL) {
  280. if (allow_customize_debug)
  281. allow_customize_debug = 0;
  282. malloc_debug_func(NULL, num, file, line, 0);
  283. }
  284. ret = malloc_locked_ex_func(num, file, line);
  285. #ifdef LEVITTE_DEBUG_MEM
  286. fprintf(stderr, "LEVITTE_DEBUG_MEM: > 0x%p (%d)\n", ret, num);
  287. #endif
  288. if (malloc_debug_func != NULL)
  289. malloc_debug_func(ret, num, file, line, 1);
  290. return ret;
  291. }
  292. void CRYPTO_free_locked(void *str)
  293. {
  294. if (free_debug_func != NULL)
  295. free_debug_func(str, 0);
  296. #ifdef LEVITTE_DEBUG_MEM
  297. fprintf(stderr, "LEVITTE_DEBUG_MEM: < 0x%p\n", str);
  298. #endif
  299. free_locked_func(str);
  300. if (free_debug_func != NULL)
  301. free_debug_func(NULL, 1);
  302. }
  303. void *CRYPTO_malloc(int num, const char *file, int line)
  304. {
  305. void *ret = NULL;
  306. if (num <= 0)
  307. return NULL;
  308. if (allow_customize)
  309. allow_customize = 0;
  310. if (malloc_debug_func != NULL) {
  311. if (allow_customize_debug)
  312. allow_customize_debug = 0;
  313. malloc_debug_func(NULL, num, file, line, 0);
  314. }
  315. ret = malloc_ex_func(num, file, line);
  316. #ifdef LEVITTE_DEBUG_MEM
  317. fprintf(stderr, "LEVITTE_DEBUG_MEM: > 0x%p (%d)\n", ret, num);
  318. #endif
  319. if (malloc_debug_func != NULL)
  320. malloc_debug_func(ret, num, file, line, 1);
  321. return ret;
  322. }
  323. char *CRYPTO_strdup(const char *str, const char *file, int line)
  324. {
  325. char *ret = CRYPTO_malloc(strlen(str) + 1, file, line);
  326. if (ret == NULL)
  327. return NULL;
  328. strcpy(ret, str);
  329. return ret;
  330. }
  331. void *CRYPTO_realloc(void *str, int num, const char *file, int line)
  332. {
  333. void *ret = NULL;
  334. if (str == NULL)
  335. return CRYPTO_malloc(num, file, line);
  336. if (num <= 0)
  337. return NULL;
  338. if (realloc_debug_func != NULL)
  339. realloc_debug_func(str, NULL, num, file, line, 0);
  340. ret = realloc_ex_func(str, num, file, line);
  341. #ifdef LEVITTE_DEBUG_MEM
  342. fprintf(stderr, "LEVITTE_DEBUG_MEM: | 0x%p -> 0x%p (%d)\n", str,
  343. ret, num);
  344. #endif
  345. if (realloc_debug_func != NULL)
  346. realloc_debug_func(str, ret, num, file, line, 1);
  347. return ret;
  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. if (str == NULL)
  354. return CRYPTO_malloc(num, file, line);
  355. if (num <= 0)
  356. return NULL;
  357. /*
  358. * We don't support shrinking the buffer. Note the memcpy that copies
  359. * |old_len| bytes to the new buffer, below.
  360. */
  361. if (num < old_len)
  362. return NULL;
  363. if (realloc_debug_func != NULL)
  364. realloc_debug_func(str, NULL, num, file, line, 0);
  365. ret = malloc_ex_func(num, file, line);
  366. if (ret) {
  367. memcpy(ret, str, old_len);
  368. OPENSSL_cleanse(str, old_len);
  369. free_func(str);
  370. }
  371. #ifdef LEVITTE_DEBUG_MEM
  372. fprintf(stderr,
  373. "LEVITTE_DEBUG_MEM: | 0x%p -> 0x%p (%d)\n",
  374. str, ret, num);
  375. #endif
  376. if (realloc_debug_func != NULL)
  377. realloc_debug_func(str, ret, num, file, line, 1);
  378. return ret;
  379. }
  380. void CRYPTO_free(void *str)
  381. {
  382. if (free_debug_func != NULL)
  383. free_debug_func(str, 0);
  384. #ifdef LEVITTE_DEBUG_MEM
  385. fprintf(stderr, "LEVITTE_DEBUG_MEM: < 0x%p\n", str);
  386. #endif
  387. free_func(str);
  388. if (free_debug_func != NULL)
  389. free_debug_func(NULL, 1);
  390. }
  391. void *CRYPTO_remalloc(void *a, int num, const char *file, int line)
  392. {
  393. if (a != NULL)
  394. OPENSSL_free(a);
  395. a = (char *)OPENSSL_malloc(num);
  396. return (a);
  397. }
  398. void CRYPTO_set_mem_debug_options(long bits)
  399. {
  400. if (set_debug_options_func != NULL)
  401. set_debug_options_func(bits);
  402. }
  403. long CRYPTO_get_mem_debug_options(void)
  404. {
  405. if (get_debug_options_func != NULL)
  406. return get_debug_options_func();
  407. return 0;
  408. }