2 * Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
4 * Licensed under the Apache License 2.0 (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
12 #include <openssl/core.h>
13 #include <openssl/core_numbers.h>
14 #include <openssl/core_names.h>
15 #include <openssl/params.h>
16 #include <openssl/err.h>
17 #include <openssl/evp.h>
18 #include <openssl/kdf.h>
20 /* TODO(3.0): Needed for dummy_evp_call(). To be removed */
21 #include <openssl/sha.h>
22 #include <openssl/rand_drbg.h>
23 #include <openssl/ec.h>
24 #include <openssl/fips_names.h>
26 #include "internal/cryptlib.h"
27 #include "internal/property.h"
28 #include "crypto/evp.h"
29 #include "prov/implementations.h"
30 #include "prov/provider_ctx.h"
31 #include "prov/providercommon.h"
34 extern OSSL_core_thread_start_fn *c_thread_start;
37 * TODO(3.0): Should these be stored in the provider side provctx? Could they
38 * ever be different from one init to the next? Unfortunately we can't do this
39 * at the moment because c_put_error/c_add_error_vdata do not provide
40 * us with the OPENSSL_CTX as a parameter.
43 static SELF_TEST_POST_PARAMS selftest_params;
45 /* Functions provided by the core */
46 static OSSL_core_gettable_params_fn *c_gettable_params;
47 static OSSL_core_get_params_fn *c_get_params;
48 OSSL_core_thread_start_fn *c_thread_start;
49 static OSSL_core_new_error_fn *c_new_error;
50 static OSSL_core_set_error_debug_fn *c_set_error_debug;
51 static OSSL_core_vset_error_fn *c_vset_error;
52 static OSSL_CRYPTO_malloc_fn *c_CRYPTO_malloc;
53 static OSSL_CRYPTO_zalloc_fn *c_CRYPTO_zalloc;
54 static OSSL_CRYPTO_free_fn *c_CRYPTO_free;
55 static OSSL_CRYPTO_clear_free_fn *c_CRYPTO_clear_free;
56 static OSSL_CRYPTO_realloc_fn *c_CRYPTO_realloc;
57 static OSSL_CRYPTO_clear_realloc_fn *c_CRYPTO_clear_realloc;
58 static OSSL_CRYPTO_secure_malloc_fn *c_CRYPTO_secure_malloc;
59 static OSSL_CRYPTO_secure_zalloc_fn *c_CRYPTO_secure_zalloc;
60 static OSSL_CRYPTO_secure_free_fn *c_CRYPTO_secure_free;
61 static OSSL_CRYPTO_secure_clear_free_fn *c_CRYPTO_secure_clear_free;
62 static OSSL_CRYPTO_secure_allocated_fn *c_CRYPTO_secure_allocated;
64 typedef struct fips_global_st {
65 const OSSL_PROVIDER *prov;
68 static void *fips_prov_ossl_ctx_new(OPENSSL_CTX *libctx)
70 FIPS_GLOBAL *fgbl = OPENSSL_zalloc(sizeof(*fgbl));
75 static void fips_prov_ossl_ctx_free(void *fgbl)
80 static const OPENSSL_CTX_METHOD fips_prov_ossl_ctx_method = {
81 fips_prov_ossl_ctx_new,
82 fips_prov_ossl_ctx_free,
86 /* Parameters we provide to the core */
87 static const OSSL_PARAM fips_param_types[] = {
88 OSSL_PARAM_DEFN(OSSL_PROV_PARAM_NAME, OSSL_PARAM_UTF8_PTR, NULL, 0),
89 OSSL_PARAM_DEFN(OSSL_PROV_PARAM_VERSION, OSSL_PARAM_UTF8_PTR, NULL, 0),
90 OSSL_PARAM_DEFN(OSSL_PROV_PARAM_BUILDINFO, OSSL_PARAM_UTF8_PTR, NULL, 0),
95 * Parameters to retrieve from the core provider - required for self testing.
96 * NOTE: inside core_get_params() these will be loaded from config items
97 * stored inside prov->parameters (except for OSSL_PROV_PARAM_MODULE_FILENAME).
99 static OSSL_PARAM core_params[] =
101 OSSL_PARAM_utf8_ptr(OSSL_PROV_PARAM_MODULE_FILENAME,
102 selftest_params.module_filename,
103 sizeof(selftest_params.module_filename)),
104 OSSL_PARAM_utf8_ptr(OSSL_PROV_FIPS_PARAM_MODULE_MAC,
105 selftest_params.module_checksum_data,
106 sizeof(selftest_params.module_checksum_data)),
107 OSSL_PARAM_utf8_ptr(OSSL_PROV_FIPS_PARAM_INSTALL_MAC,
108 selftest_params.indicator_checksum_data,
109 sizeof(selftest_params.indicator_checksum_data)),
110 OSSL_PARAM_utf8_ptr(OSSL_PROV_FIPS_PARAM_INSTALL_STATUS,
111 selftest_params.indicator_data,
112 sizeof(selftest_params.indicator_data)),
113 OSSL_PARAM_utf8_ptr(OSSL_PROV_FIPS_PARAM_INSTALL_VERSION,
114 selftest_params.indicator_version,
115 sizeof(selftest_params.indicator_version)),
119 /* TODO(3.0): To be removed */
120 static int dummy_evp_call(void *provctx)
122 OPENSSL_CTX *libctx = PROV_LIBRARY_CONTEXT_OF(provctx);
123 EVP_MD_CTX *ctx = EVP_MD_CTX_new();
124 EVP_MD *sha256 = EVP_MD_fetch(libctx, "SHA256", NULL);
125 EVP_KDF *kdf = EVP_KDF_fetch(libctx, OSSL_KDF_NAME_PBKDF2, NULL);
126 char msg[] = "Hello World!";
127 const unsigned char exptd[] = {
128 0x7f, 0x83, 0xb1, 0x65, 0x7f, 0xf1, 0xfc, 0x53, 0xb9, 0x2d, 0xc1, 0x81,
129 0x48, 0xa1, 0xd6, 0x5d, 0xfc, 0x2d, 0x4b, 0x1f, 0xa3, 0xd6, 0x77, 0x28,
130 0x4a, 0xdd, 0xd2, 0x00, 0x12, 0x6d, 0x90, 0x69
132 unsigned int dgstlen = 0;
133 unsigned char dgst[SHA256_DIGEST_LENGTH];
135 BN_CTX *bnctx = NULL;
136 BIGNUM *a = NULL, *b = NULL;
137 unsigned char randbuf[128];
138 RAND_DRBG *drbg = OPENSSL_CTX_get0_public_drbg(libctx);
139 #ifndef OPENSSL_NO_EC
143 if (ctx == NULL || sha256 == NULL || drbg == NULL || kdf == NULL)
146 if (!EVP_DigestInit_ex(ctx, sha256, NULL))
148 if (!EVP_DigestUpdate(ctx, msg, sizeof(msg) - 1))
150 if (!EVP_DigestFinal(ctx, dgst, &dgstlen))
152 if (dgstlen != sizeof(exptd) || memcmp(dgst, exptd, sizeof(exptd)) != 0)
155 bnctx = BN_CTX_new_ex(libctx);
159 a = BN_CTX_get(bnctx);
160 b = BN_CTX_get(bnctx);
166 || BN_cmp(a, b) != 0)
169 if (RAND_DRBG_bytes(drbg, randbuf, sizeof(randbuf)) <= 0)
172 if (!BN_rand_ex(a, 256, BN_RAND_TOP_ANY, BN_RAND_BOTTOM_ANY, bnctx))
175 #ifndef OPENSSL_NO_EC
176 /* Do some dummy EC calls */
177 key = EC_KEY_new_by_curve_name_ex(libctx, NID_X9_62_prime256v1);
181 if (!EC_KEY_generate_key(key))
191 EVP_MD_CTX_free(ctx);
194 #ifndef OPENSSL_NO_EC
200 static const OSSL_PARAM *fips_gettable_params(const OSSL_PROVIDER *prov)
202 return fips_param_types;
205 static int fips_get_params(const OSSL_PROVIDER *prov, OSSL_PARAM params[])
209 p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_NAME);
210 if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, "OpenSSL FIPS Provider"))
212 p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_VERSION);
213 if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, OPENSSL_VERSION_STR))
215 p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_BUILDINFO);
216 if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, OPENSSL_FULL_VERSION_STR))
222 /* FIPS specific version of the function of the same name in provlib.c */
223 const char *ossl_prov_util_nid_to_name(int nid)
225 /* We don't have OBJ_nid2n() in FIPS_MODE so we have an explicit list */
240 return "SHA-512/224";
242 return "SHA-512/256";
253 case NID_aes_256_ecb:
254 return "AES-256-ECB";
255 case NID_aes_192_ecb:
256 return "AES-192-ECB";
257 case NID_aes_128_ecb:
258 return "AES-128-ECB";
259 case NID_aes_256_cbc:
260 return "AES-256-CBC";
261 case NID_aes_192_cbc:
262 return "AES-192-CBC";
263 case NID_aes_128_cbc:
264 return "AES-128-CBC";
265 case NID_aes_256_ctr:
266 return "AES-256-CTR";
267 case NID_aes_192_ctr:
268 return "AES-192-CTR";
269 case NID_aes_128_ctr:
270 return "AES-128-CTR";
271 case NID_aes_256_xts:
272 return "AES-256-XTS";
273 case NID_aes_128_xts:
274 return "AES-128-XTS";
275 case NID_aes_256_gcm:
276 return "AES-256-GCM";
277 case NID_aes_192_gcm:
278 return "AES-192-GCM";
279 case NID_aes_128_gcm:
280 return "AES-128-GCM";
281 case NID_aes_256_ccm:
282 return "AES-256-CCM";
283 case NID_aes_192_ccm:
284 return "AES-192-CCM";
285 case NID_aes_128_ccm:
286 return "AES-128-CCM";
287 case NID_id_aes256_wrap:
288 return "AES-256-WRAP";
289 case NID_id_aes192_wrap:
290 return "AES-192-WRAP";
291 case NID_id_aes128_wrap:
292 return "AES-128-WRAP";
293 case NID_id_aes256_wrap_pad:
294 return "AES-256-WRAP-PAD";
295 case NID_id_aes192_wrap_pad:
296 return "AES-192-WRAP-PAD";
297 case NID_id_aes128_wrap_pad:
298 return "AES-128-WRAP-PAD";
299 case NID_des_ede3_ecb:
301 case NID_des_ede3_cbc:
302 return "DES-EDE3-CBC";
311 * For the algorithm names, we use the following formula for our primary
314 * ALGNAME[VERSION?][-SUBNAME[VERSION?]?][-SIZE?][-MODE?]
316 * VERSION is only present if there are multiple versions of
317 * an alg (MD2, MD4, MD5). It may be omitted if there is only
318 * one version (if a subsequent version is released in the future,
319 * we can always change the canonical name, and add the old name
322 * SUBNAME may be present where we are combining multiple
323 * algorithms together, e.g. MD5-SHA1.
325 * SIZE is only present if multiple versions of an algorithm exist
326 * with different sizes (e.g. AES-128-CBC, AES-256-CBC)
328 * MODE is only present where applicable.
330 * We add diverse other names where applicable, such as the names that
331 * NIST uses, or that are used for ASN.1 OBJECT IDENTIFIERs, or names
332 * we have used historically.
334 static const OSSL_ALGORITHM fips_digests[] = {
335 /* Our primary name:NiST name[:our older names] */
336 { "SHA1:SHA-1", "fips=yes", sha1_functions },
337 { "SHA2-224:SHA-224:SHA224", "fips=yes", sha224_functions },
338 { "SHA2-256:SHA-256:SHA256", "fips=yes", sha256_functions },
339 { "SHA2-384:SHA-384:SHA384", "fips=yes", sha384_functions },
340 { "SHA2-512:SHA-512:SHA512", "fips=yes", sha512_functions },
341 { "SHA2-512/224:SHA-512/224:SHA512-224", "fips=yes",
342 sha512_224_functions },
343 { "SHA2-512/256:SHA-512/256:SHA512-256", "fips=yes",
344 sha512_256_functions },
346 /* We agree with NIST here, so one name only */
347 { "SHA3-224", "fips=yes", sha3_224_functions },
348 { "SHA3-256", "fips=yes", sha3_256_functions },
349 { "SHA3-384", "fips=yes", sha3_384_functions },
350 { "SHA3-512", "fips=yes", sha3_512_functions },
352 * KECCAK_KMAC128 and KECCAK_KMAC256 as hashes are mostly useful for
353 * KMAC128 and KMAC256.
355 { "KECCAK_KMAC128", "fips=yes", keccak_kmac_128_functions },
356 { "KECCAK_KMAC256", "fips=yes", keccak_kmac_256_functions },
361 static const OSSL_ALGORITHM fips_ciphers[] = {
362 /* Our primary name[:ASN.1 OID name][:our older names] */
363 { "AES-256-ECB", "fips=yes", aes256ecb_functions },
364 { "AES-192-ECB", "fips=yes", aes192ecb_functions },
365 { "AES-128-ECB", "fips=yes", aes128ecb_functions },
366 { "AES-256-CBC", "fips=yes", aes256cbc_functions },
367 { "AES-192-CBC", "fips=yes", aes192cbc_functions },
368 { "AES-128-CBC", "fips=yes", aes128cbc_functions },
369 { "AES-256-CTR", "fips=yes", aes256ctr_functions },
370 { "AES-192-CTR", "fips=yes", aes192ctr_functions },
371 { "AES-128-CTR", "fips=yes", aes128ctr_functions },
372 { "AES-256-XTS", "fips=yes", aes256xts_functions },
373 { "AES-128-XTS", "fips=yes", aes128xts_functions },
374 { "AES-256-GCM:id-aes256-GCM", "fips=yes", aes256gcm_functions },
375 { "AES-192-GCM:id-aes192-GCM", "fips=yes", aes192gcm_functions },
376 { "AES-128-GCM:id-aes128-GCM", "fips=yes", aes128gcm_functions },
377 { "AES-256-CCM:id-aes256-CCM", "fips=yes", aes256ccm_functions },
378 { "AES-192-CCM:id-aes192-CCM", "fips=yes", aes192ccm_functions },
379 { "AES-128-CCM:id-aes128-CCM", "fips=yes", aes128ccm_functions },
380 { "AES-256-WRAP:id-aes256-wrap:AES256-WRAP", "fips=yes",
381 aes256wrap_functions },
382 { "AES-192-WRAP:id-aes192-wrap:AES192-WRAP", "fips=yes",
383 aes192wrap_functions },
384 { "AES-128-WRAP:id-aes128-wrap:AES128-WRAP", "fips=yes",
385 aes128wrap_functions },
386 { "AES-256-WRAP-PAD:id-aes256-wrap-pad:AES256-WRAP-PAD", "fips=yes",
387 aes256wrappad_functions },
388 { "AES-192-WRAP-PAD:id-aes192-wrap-pad:AES192-WRAP-PAD", "fips=yes",
389 aes192wrappad_functions },
390 { "AES-128-WRAP-PAD:id-aes128-wrap-pad:AES128-WRAP-PAD", "fips=yes",
391 aes128wrappad_functions },
392 #ifndef OPENSSL_NO_DES
393 { "DES-EDE3-ECB:DES-EDE3", "fips=yes", tdes_ede3_ecb_functions },
394 { "DES-EDE3-CBC:DES3", "fips=yes", tdes_ede3_cbc_functions },
395 #endif /* OPENSSL_NO_DES */
399 static const OSSL_ALGORITHM fips_macs[] = {
400 #ifndef OPENSSL_NO_CMAC
401 { "CMAC", "fips=yes", cmac_functions },
403 { "GMAC", "fips=yes", gmac_functions },
404 { "HMAC", "fips=yes", hmac_functions },
405 { "KMAC128", "fips=yes", kmac128_functions },
406 { "KMAC256", "fips=yes", kmac256_functions },
410 static const OSSL_ALGORITHM fips_kdfs[] = {
411 { OSSL_KDF_NAME_HKDF, "fips=yes", kdf_hkdf_functions },
412 { OSSL_KDF_NAME_SSKDF, "fips=yes", kdf_sskdf_functions },
413 { OSSL_KDF_NAME_PBKDF2, "fips=yes", kdf_pbkdf2_functions },
414 { OSSL_KDF_NAME_TLS1_PRF, "fips=yes", kdf_tls1_prf_functions },
415 { OSSL_KDF_NAME_KBKDF, "fips=yes", kdf_kbkdf_functions },
419 static const OSSL_ALGORITHM *fips_query(OSSL_PROVIDER *prov,
424 switch (operation_id) {
437 /* Functions we provide to the core */
438 static const OSSL_DISPATCH fips_dispatch_table[] = {
440 * To release our resources we just need to free the OPENSSL_CTX so we just
441 * use OPENSSL_CTX_free directly as our teardown function
443 { OSSL_FUNC_PROVIDER_TEARDOWN, (void (*)(void))OPENSSL_CTX_free },
444 { OSSL_FUNC_PROVIDER_GETTABLE_PARAMS, (void (*)(void))fips_gettable_params },
445 { OSSL_FUNC_PROVIDER_GET_PARAMS, (void (*)(void))fips_get_params },
446 { OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void (*)(void))fips_query },
450 /* Functions we provide to ourself */
451 static const OSSL_DISPATCH intern_dispatch_table[] = {
452 { OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void (*)(void))fips_query },
457 int OSSL_provider_init(const OSSL_PROVIDER *provider,
458 const OSSL_DISPATCH *in,
459 const OSSL_DISPATCH **out,
465 for (; in->function_id != 0; in++) {
466 switch (in->function_id) {
467 case OSSL_FUNC_CORE_GETTABLE_PARAMS:
468 c_gettable_params = OSSL_get_core_gettable_params(in);
470 case OSSL_FUNC_CORE_GET_PARAMS:
471 c_get_params = OSSL_get_core_get_params(in);
473 case OSSL_FUNC_CORE_THREAD_START:
474 c_thread_start = OSSL_get_core_thread_start(in);
476 case OSSL_FUNC_CORE_NEW_ERROR:
477 c_new_error = OSSL_get_core_new_error(in);
479 case OSSL_FUNC_CORE_SET_ERROR_DEBUG:
480 c_set_error_debug = OSSL_get_core_set_error_debug(in);
482 case OSSL_FUNC_CORE_VSET_ERROR:
483 c_vset_error = OSSL_get_core_vset_error(in);
485 case OSSL_FUNC_CRYPTO_MALLOC:
486 c_CRYPTO_malloc = OSSL_get_CRYPTO_malloc(in);
488 case OSSL_FUNC_CRYPTO_ZALLOC:
489 c_CRYPTO_zalloc = OSSL_get_CRYPTO_zalloc(in);
491 case OSSL_FUNC_CRYPTO_FREE:
492 c_CRYPTO_free = OSSL_get_CRYPTO_free(in);
494 case OSSL_FUNC_CRYPTO_CLEAR_FREE:
495 c_CRYPTO_clear_free = OSSL_get_CRYPTO_clear_free(in);
497 case OSSL_FUNC_CRYPTO_REALLOC:
498 c_CRYPTO_realloc = OSSL_get_CRYPTO_realloc(in);
500 case OSSL_FUNC_CRYPTO_CLEAR_REALLOC:
501 c_CRYPTO_clear_realloc = OSSL_get_CRYPTO_clear_realloc(in);
503 case OSSL_FUNC_CRYPTO_SECURE_MALLOC:
504 c_CRYPTO_secure_malloc = OSSL_get_CRYPTO_secure_malloc(in);
506 case OSSL_FUNC_CRYPTO_SECURE_ZALLOC:
507 c_CRYPTO_secure_zalloc = OSSL_get_CRYPTO_secure_zalloc(in);
509 case OSSL_FUNC_CRYPTO_SECURE_FREE:
510 c_CRYPTO_secure_free = OSSL_get_CRYPTO_secure_free(in);
512 case OSSL_FUNC_CRYPTO_SECURE_CLEAR_FREE:
513 c_CRYPTO_secure_clear_free = OSSL_get_CRYPTO_secure_clear_free(in);
515 case OSSL_FUNC_CRYPTO_SECURE_ALLOCATED:
516 c_CRYPTO_secure_allocated = OSSL_get_CRYPTO_secure_allocated(in);
518 case OSSL_FUNC_BIO_NEW_FILE:
519 selftest_params.bio_new_file_cb = OSSL_get_BIO_new_file(in);
521 case OSSL_FUNC_BIO_NEW_MEMBUF:
522 selftest_params.bio_new_buffer_cb = OSSL_get_BIO_new_membuf(in);
524 case OSSL_FUNC_BIO_READ_EX:
525 selftest_params.bio_read_ex_cb = OSSL_get_BIO_read_ex(in);
527 case OSSL_FUNC_BIO_FREE:
528 selftest_params.bio_free_cb = OSSL_get_BIO_free(in);
531 /* Just ignore anything we don't understand */
536 if (!c_get_params(provider, core_params))
539 /* Create a context. */
540 if ((ctx = OPENSSL_CTX_new()) == NULL)
542 if ((fgbl = openssl_ctx_get_data(ctx, OPENSSL_CTX_FIPS_PROV_INDEX,
543 &fips_prov_ossl_ctx_method)) == NULL) {
544 OPENSSL_CTX_free(ctx);
548 fgbl->prov = provider;
550 selftest_params.libctx = PROV_LIBRARY_CONTEXT_OF(ctx);
551 if (!SELF_TEST_post(&selftest_params)) {
552 OPENSSL_CTX_free(ctx);
556 *out = fips_dispatch_table;
560 * TODO(3.0): Remove me. This is just a dummy call to demonstrate making
561 * EVP calls from within the FIPS module.
563 if (!dummy_evp_call(*provctx)) {
564 OPENSSL_CTX_free(*provctx);
573 * The internal init function used when the FIPS module uses EVP to call
574 * another algorithm also in the FIPS module. This is a recursive call that has
575 * been made from within the FIPS module itself. To make this work, we populate
576 * the provider context of this inner instance with the same library context
577 * that was used in the EVP call that initiated this recursive call.
579 OSSL_provider_init_fn fips_intern_provider_init;
580 int fips_intern_provider_init(const OSSL_PROVIDER *provider,
581 const OSSL_DISPATCH *in,
582 const OSSL_DISPATCH **out,
585 OSSL_core_get_library_context_fn *c_get_libctx = NULL;
587 for (; in->function_id != 0; in++) {
588 switch (in->function_id) {
589 case OSSL_FUNC_CORE_GET_LIBRARY_CONTEXT:
590 c_get_libctx = OSSL_get_core_get_library_context(in);
597 if (c_get_libctx == NULL)
600 *provctx = c_get_libctx(provider);
603 * Safety measure... we should get the library context that was
604 * created up in OSSL_provider_init().
606 if (*provctx == NULL)
609 *out = intern_dispatch_table;
618 void ERR_set_debug(const char *file, int line, const char *func)
620 c_set_error_debug(NULL, file, line, func);
623 void ERR_set_error(int lib, int reason, const char *fmt, ...)
628 c_vset_error(NULL, ERR_PACK(lib, 0, reason), fmt, args);
632 void ERR_vset_error(int lib, int reason, const char *fmt, va_list args)
634 c_vset_error(NULL, ERR_PACK(lib, 0, reason), fmt, args);
637 const OSSL_PROVIDER *FIPS_get_provider(OPENSSL_CTX *ctx)
639 FIPS_GLOBAL *fgbl = openssl_ctx_get_data(ctx, OPENSSL_CTX_FIPS_PROV_INDEX,
640 &fips_prov_ossl_ctx_method);
648 void *CRYPTO_malloc(size_t num, const char *file, int line)
650 return c_CRYPTO_malloc(num, file, line);
653 void *CRYPTO_zalloc(size_t num, const char *file, int line)
655 return c_CRYPTO_zalloc(num, file, line);
658 void CRYPTO_free(void *ptr, const char *file, int line)
660 c_CRYPTO_free(ptr, file, line);
663 void CRYPTO_clear_free(void *ptr, size_t num, const char *file, int line)
665 c_CRYPTO_clear_free(ptr, num, file, line);
668 void *CRYPTO_realloc(void *addr, size_t num, const char *file, int line)
670 return c_CRYPTO_realloc(addr, num, file, line);
673 void *CRYPTO_clear_realloc(void *addr, size_t old_num, size_t num,
674 const char *file, int line)
676 return c_CRYPTO_clear_realloc(addr, old_num, num, file, line);
679 void *CRYPTO_secure_malloc(size_t num, const char *file, int line)
681 return c_CRYPTO_secure_malloc(num, file, line);
684 void *CRYPTO_secure_zalloc(size_t num, const char *file, int line)
686 return c_CRYPTO_secure_zalloc(num, file, line);
689 void CRYPTO_secure_free(void *ptr, const char *file, int line)
691 c_CRYPTO_secure_free(ptr, file, line);
694 void CRYPTO_secure_clear_free(void *ptr, size_t num, const char *file, int line)
696 c_CRYPTO_secure_clear_free(ptr, num, file, line);
699 int CRYPTO_secure_allocated(const void *ptr)
701 return c_CRYPTO_secure_allocated(ptr);