Hide symbols in crypto.h

ok jsing@

diff --git a/lib/libcrypto/Symbols.namespace b/lib/libcrypto/Symbols.namespace
index 617fc06..89c4a06 100644 (file)
--- a/lib/libcrypto/Symbols.namespace
+++ b/lib/libcrypto/Symbols.namespace
@@ -2013,3 +2013,53 @@ _libre_BUF_MEM_free
 _libre_BUF_MEM_grow
 _libre_BUF_MEM_grow_clean
 _libre_ERR_load_BUF_strings
+_libre_OpenSSL_version
+_libre_OpenSSL_version_num
+_libre_SSLeay_version
+_libre_SSLeay
+_libre_CRYPTO_get_ex_data_implementation
+_libre_CRYPTO_set_ex_data_implementation
+_libre_CRYPTO_ex_data_new_class
+_libre_CRYPTO_get_ex_new_index
+_libre_CRYPTO_new_ex_data
+_libre_CRYPTO_dup_ex_data
+_libre_CRYPTO_free_ex_data
+_libre_CRYPTO_set_ex_data
+_libre_CRYPTO_get_ex_data
+_libre_CRYPTO_cleanup_all_ex_data
+_libre_CRYPTO_lock
+_libre_CRYPTO_add_lock
+_libre_CRYPTO_THREADID_current
+_libre_CRYPTO_THREADID_cmp
+_libre_CRYPTO_THREADID_cpy
+_libre_CRYPTO_THREADID_hash
+_libre_CRYPTO_set_mem_functions
+_libre_CRYPTO_set_locked_mem_functions
+_libre_CRYPTO_set_mem_ex_functions
+_libre_CRYPTO_set_locked_mem_ex_functions
+_libre_CRYPTO_set_mem_debug_functions
+_libre_CRYPTO_get_mem_functions
+_libre_CRYPTO_get_locked_mem_functions
+_libre_CRYPTO_get_mem_ex_functions
+_libre_CRYPTO_get_locked_mem_ex_functions
+_libre_CRYPTO_get_mem_debug_functions
+_libre_CRYPTO_realloc_clean
+_libre_CRYPTO_remalloc
+_libre_CRYPTO_set_mem_debug_options
+_libre_CRYPTO_get_mem_debug_options
+_libre_CRYPTO_push_info_
+_libre_CRYPTO_pop_info
+_libre_CRYPTO_remove_all_info
+_libre_CRYPTO_dbg_malloc
+_libre_CRYPTO_dbg_realloc
+_libre_CRYPTO_dbg_free
+_libre_CRYPTO_dbg_set_options
+_libre_CRYPTO_dbg_get_options
+_libre_CRYPTO_mem_leaks_fp
+_libre_CRYPTO_mem_leaks
+_libre_CRYPTO_mem_leaks_cb
+_libre_OpenSSLDie
+_libre_OPENSSL_cpu_caps
+_libre_OPENSSL_init_crypto
+_libre_OPENSSL_cleanup
+_libre_ERR_load_CRYPTO_strings

diff --git a/lib/libcrypto/cpt_err.c b/lib/libcrypto/cpt_err.c
index 718c726..ff4e5c4 100644 (file)
--- a/lib/libcrypto/cpt_err.c
+++ b/lib/libcrypto/cpt_err.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cpt_err.c,v 1.14 2022/07/12 14:42:48 kn Exp $ */
+/* $OpenBSD: cpt_err.c,v 1.15 2023/07/08 08:28:23 beck Exp $ */
 /* ====================================================================
  * Copyright (c) 1999-2011 The OpenSSL Project.  All rights reserved.
  *
@@ -97,3 +97,4 @@ ERR_load_CRYPTO_strings(void)
        }
 #endif
 }
+LCRYPTO_ALIAS(ERR_load_CRYPTO_strings);

diff --git a/lib/libcrypto/cryptlib.c b/lib/libcrypto/cryptlib.c
index 38d31e7..18f40e5 100644 (file)
--- a/lib/libcrypto/cryptlib.c
+++ b/lib/libcrypto/cryptlib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cryptlib.c,v 1.45 2019/01/26 11:30:32 deraadt Exp $ */
+/* $OpenBSD: cryptlib.c,v 1.46 2023/07/08 08:28:23 beck Exp $ */
 /* ====================================================================
  * Copyright (c) 1998-2006 The OpenSSL Project.  All rights reserved.
  *
@@ -281,24 +281,28 @@ CRYPTO_THREADID_current(CRYPTO_THREADID *id)
        memset(id, 0, sizeof(*id));
        id->val = (unsigned long)pthread_self();
 }
+LCRYPTO_ALIAS(CRYPTO_THREADID_current);
 
 int
 CRYPTO_THREADID_cmp(const CRYPTO_THREADID *a, const CRYPTO_THREADID *b)
 {
        return memcmp(a, b, sizeof(*a));
 }
+LCRYPTO_ALIAS(CRYPTO_THREADID_cmp);
 
 void
 CRYPTO_THREADID_cpy(CRYPTO_THREADID *dest, const CRYPTO_THREADID *src)
 {
        memcpy(dest, src, sizeof(*src));
 }
+LCRYPTO_ALIAS(CRYPTO_THREADID_cpy);
 
 unsigned long
 CRYPTO_THREADID_hash(const CRYPTO_THREADID *id)
 {
        return id->val;
 }
+LCRYPTO_ALIAS(CRYPTO_THREADID_hash);
 
 #if    defined(__i386)   || defined(__i386__)   || defined(_M_IX86) || \
        defined(__INTEL__) || \
@@ -311,6 +315,7 @@ OPENSSL_cpu_caps(void)
 {
        return OPENSSL_ia32cap_P;
 }
+LCRYPTO_ALIAS(OPENSSL_cpu_caps);
 
 #if defined(OPENSSL_CPUID_OBJ) && !defined(OPENSSL_NO_ASM)
 #define OPENSSL_CPUID_SETUP
@@ -333,6 +338,7 @@ OPENSSL_cpu_caps(void)
 {
        return 0;
 }
+LCRYPTO_ALIAS(OPENSSL_cpu_caps);
 #endif
 
 #if !defined(OPENSSL_CPUID_SETUP) && !defined(OPENSSL_CPUID_OBJ)
@@ -361,6 +367,7 @@ OpenSSLDie(const char *file, int line, const char *assertion)
            getuid(), getprogname(), file, line, assertion);
        _exit(1);
 }
+LCRYPTO_ALIAS(OpenSSLDie);
 
 int
 CRYPTO_memcmp(const void *in_a, const void *in_b, size_t len)

diff --git a/lib/libcrypto/crypto_init.c b/lib/libcrypto/crypto_init.c
index 361bef4..a2c1c78 100644 (file)
--- a/lib/libcrypto/crypto_init.c
+++ b/lib/libcrypto/crypto_init.c
@@ -1,4 +1,4 @@
-/*     $OpenBSD: crypto_init.c,v 1.10 2023/07/02 19:52:01 tb Exp $ */
+/*     $OpenBSD: crypto_init.c,v 1.11 2023/07/08 08:28:23 beck Exp $ */
 /*
  * Copyright (c) 2018 Bob Beck <beck@openbsd.org>
  *
@@ -75,6 +75,7 @@ OPENSSL_init_crypto(uint64_t opts, const void *settings)
 
        return 1;
 }
+LCRYPTO_ALIAS(OPENSSL_init_crypto);
 
 void
 OPENSSL_cleanup(void)
@@ -98,3 +99,4 @@ OPENSSL_cleanup(void)
 
        crypto_init_cleaned_up = 1;
 }
+LCRYPTO_ALIAS(OPENSSL_cleanup);

diff --git a/lib/libcrypto/crypto_lock.c b/lib/libcrypto/crypto_lock.c
index 6d9dbab..59c3933 100644 (file)
--- a/lib/libcrypto/crypto_lock.c
+++ b/lib/libcrypto/crypto_lock.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: crypto_lock.c,v 1.5 2023/06/04 17:28:35 tb Exp $ */
+/* $OpenBSD: crypto_lock.c,v 1.6 2023/07/08 08:28:23 beck Exp $ */
 /*
  * Copyright (c) 2018 Brent Cook <bcook@openbsd.org>
  *
@@ -78,6 +78,7 @@ CRYPTO_lock(int mode, int type, const char *file, int line)
        else if (mode & CRYPTO_UNLOCK)
                (void) pthread_mutex_unlock(&locks[type]);
 }
+LCRYPTO_ALIAS(CRYPTO_lock);
 
 int
 CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,
@@ -92,3 +93,4 @@ CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,
 
        return (ret);
 }
+LCRYPTO_ALIAS(CRYPTO_add_lock);

diff --git a/lib/libcrypto/cversion.c b/lib/libcrypto/cversion.c
index 2d4460d..acb7b70 100644 (file)
--- a/lib/libcrypto/cversion.c
+++ b/lib/libcrypto/cversion.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cversion.c,v 1.17 2018/02/17 06:56:12 jsing Exp $ */
+/* $OpenBSD: cversion.c,v 1.18 2023/07/08 08:28:23 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -78,12 +78,14 @@ SSLeay_version(int t)
        }
        return("not available");
 }
+LCRYPTO_ALIAS(SSLeay_version);
 
 unsigned long
 SSLeay(void)
 {
        return (SSLEAY_VERSION_NUMBER);
 }
+LCRYPTO_ALIAS(SSLeay);
 
 const char *
 OpenSSL_version(int t)
@@ -104,9 +106,11 @@ OpenSSL_version(int t)
        }
        return("not available");
 }
+LCRYPTO_ALIAS(OpenSSL_version);
 
 unsigned long
 OpenSSL_version_num(void)
 {
        return SSLeay();
 }
+LCRYPTO_ALIAS(OpenSSL_version_num);

diff --git a/lib/libcrypto/ex_data.c b/lib/libcrypto/ex_data.c
index 0a9c591..71b2fc3 100644 (file)
--- a/lib/libcrypto/ex_data.c
+++ b/lib/libcrypto/ex_data.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ex_data.c,v 1.21 2023/06/16 11:20:01 tb Exp $ */
+/* $OpenBSD: ex_data.c,v 1.22 2023/07/08 08:28:23 beck Exp $ */
 
 /*
  * Overhaul notes;
@@ -217,6 +217,7 @@ CRYPTO_get_ex_data_implementation(void)
        IMPL_CHECK
        return impl;
 }
+LCRYPTO_ALIAS(CRYPTO_get_ex_data_implementation);
 
 int
 CRYPTO_set_ex_data_implementation(const CRYPTO_EX_DATA_IMPL *i)
@@ -230,6 +231,7 @@ CRYPTO_set_ex_data_implementation(const CRYPTO_EX_DATA_IMPL *i)
        CRYPTO_w_unlock(CRYPTO_LOCK_EX_DATA);
        return toret;
 }
+LCRYPTO_ALIAS(CRYPTO_set_ex_data_implementation);
 
 /****************************************************************************/
 /* Interal (default) implementation of "ex_data" support. API functions are
@@ -547,6 +549,7 @@ CRYPTO_ex_data_new_class(void)
        IMPL_CHECK
        return EX_IMPL(new_class)();
 }
+LCRYPTO_ALIAS(CRYPTO_ex_data_new_class);
 
 /* Release all "ex_data" state to prevent memory leaks. This can't be made
  * thread-safe without overhauling a lot of stuff, and shouldn't really be
@@ -558,6 +561,7 @@ CRYPTO_cleanup_all_ex_data(void)
        IMPL_CHECK
        EX_IMPL(cleanup)();
 }
+LCRYPTO_ALIAS(CRYPTO_cleanup_all_ex_data);
 
 /* Inside an existing class, get/register a new index. */
 int
@@ -571,6 +575,7 @@ CRYPTO_get_ex_new_index(int class_index, long argl, void *argp,
            argl, argp, new_func, dup_func, free_func);
        return ret;
 }
+LCRYPTO_ALIAS(CRYPTO_get_ex_new_index);
 
 /* Initialise a new CRYPTO_EX_DATA for use in a particular class - including
  * calling new() callbacks for each index in the class used by this variable */
@@ -580,6 +585,7 @@ CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad)
        IMPL_CHECK
        return EX_IMPL(new_ex_data)(class_index, obj, ad);
 }
+LCRYPTO_ALIAS(CRYPTO_new_ex_data);
 
 /* Duplicate a CRYPTO_EX_DATA variable - including calling dup() callbacks for
  * each index in the class used by this variable */
@@ -589,6 +595,7 @@ CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA *to, CRYPTO_EX_DATA *from)
        IMPL_CHECK
        return EX_IMPL(dup_ex_data)(class_index, to, from);
 }
+LCRYPTO_ALIAS(CRYPTO_dup_ex_data);
 
 /* Cleanup a CRYPTO_EX_DATA variable - including calling free() callbacks for
  * each index in the class used by this variable */
@@ -598,6 +605,7 @@ CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad)
        IMPL_CHECK
        EX_IMPL(free_ex_data)(class_index, obj, ad);
 }
+LCRYPTO_ALIAS(CRYPTO_free_ex_data);
 
 /* For a given CRYPTO_EX_DATA variable, set the value corresponding to a
  * particular index in the class used by this variable */
@@ -624,6 +632,7 @@ CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val)
        sk_void_set(ad->sk, idx, val);
        return (1);
 }
+LCRYPTO_ALIAS(CRYPTO_set_ex_data);
 
 /* For a given CRYPTO_EX_DATA_ variable, get the value corresponding to a
  * particular index in the class used by this variable */
@@ -637,3 +646,4 @@ CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx)
        else
                return (sk_void_value(ad->sk, idx));
 }
+LCRYPTO_ALIAS(CRYPTO_get_ex_data);

diff --git a/lib/libcrypto/hidden/openssl/crypto.h b/lib/libcrypto/hidden/openssl/crypto.h
new file mode 100644 (file)
index 0000000..69ffa94
--- /dev/null
+++ b/lib/libcrypto/hidden/openssl/crypto.h
@@ -0,0 +1,79 @@
+/* $OpenBSD: crypto.h,v 1.1 2023/07/08 08:28:23 beck Exp $ */
+/*
+ * Copyright (c) 2023 Bob Beck <beck@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef _LIBCRYPTO_CRYPTO_H
+#define _LIBCRYPTO_CRYPTO_H
+
+#ifndef _MSC_VER
+#include_next <openssl/crypto.h>
+#else
+#include "../include/openssl/crypto.h"
+#endif
+#include "crypto_namespace.h"
+
+LCRYPTO_USED(OpenSSL_version);
+LCRYPTO_USED(OpenSSL_version_num);
+LCRYPTO_USED(SSLeay_version);
+LCRYPTO_USED(SSLeay);
+LCRYPTO_USED(CRYPTO_get_ex_data_implementation);
+LCRYPTO_USED(CRYPTO_set_ex_data_implementation);
+LCRYPTO_USED(CRYPTO_ex_data_new_class);
+LCRYPTO_USED(CRYPTO_get_ex_new_index);
+LCRYPTO_USED(CRYPTO_new_ex_data);
+LCRYPTO_USED(CRYPTO_dup_ex_data);
+LCRYPTO_USED(CRYPTO_free_ex_data);
+LCRYPTO_USED(CRYPTO_set_ex_data);
+LCRYPTO_USED(CRYPTO_get_ex_data);
+LCRYPTO_USED(CRYPTO_cleanup_all_ex_data);
+LCRYPTO_USED(CRYPTO_lock);
+LCRYPTO_USED(CRYPTO_add_lock);
+LCRYPTO_USED(CRYPTO_THREADID_current);
+LCRYPTO_USED(CRYPTO_THREADID_cmp);
+LCRYPTO_USED(CRYPTO_THREADID_cpy);
+LCRYPTO_USED(CRYPTO_THREADID_hash);
+LCRYPTO_USED(CRYPTO_set_mem_functions);
+LCRYPTO_USED(CRYPTO_set_locked_mem_functions);
+LCRYPTO_USED(CRYPTO_set_mem_ex_functions);
+LCRYPTO_USED(CRYPTO_set_locked_mem_ex_functions);
+LCRYPTO_USED(CRYPTO_set_mem_debug_functions);
+LCRYPTO_USED(CRYPTO_get_mem_functions);
+LCRYPTO_USED(CRYPTO_get_locked_mem_functions);
+LCRYPTO_USED(CRYPTO_get_mem_ex_functions);
+LCRYPTO_USED(CRYPTO_get_locked_mem_ex_functions);
+LCRYPTO_USED(CRYPTO_get_mem_debug_functions);
+LCRYPTO_USED(CRYPTO_realloc_clean);
+LCRYPTO_USED(CRYPTO_remalloc);
+LCRYPTO_USED(CRYPTO_set_mem_debug_options);
+LCRYPTO_USED(CRYPTO_get_mem_debug_options);
+LCRYPTO_USED(CRYPTO_push_info_);
+LCRYPTO_USED(CRYPTO_pop_info);
+LCRYPTO_USED(CRYPTO_remove_all_info);
+LCRYPTO_USED(CRYPTO_dbg_malloc);
+LCRYPTO_USED(CRYPTO_dbg_realloc);
+LCRYPTO_USED(CRYPTO_dbg_free);
+LCRYPTO_USED(CRYPTO_dbg_set_options);
+LCRYPTO_USED(CRYPTO_dbg_get_options);
+LCRYPTO_USED(CRYPTO_mem_leaks_fp);
+LCRYPTO_USED(CRYPTO_mem_leaks);
+LCRYPTO_USED(CRYPTO_mem_leaks_cb);
+LCRYPTO_USED(OpenSSLDie);
+LCRYPTO_USED(OPENSSL_cpu_caps);
+LCRYPTO_USED(OPENSSL_init_crypto);
+LCRYPTO_USED(OPENSSL_cleanup);
+LCRYPTO_USED(ERR_load_CRYPTO_strings);
+
+#endif /* _LIBCRYPTO_CRYPTO_H */

diff --git a/lib/libcrypto/malloc-wrapper.c b/lib/libcrypto/malloc-wrapper.c
index cb9a311..4d57f00 100644 (file)
--- a/lib/libcrypto/malloc-wrapper.c
+++ b/lib/libcrypto/malloc-wrapper.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: malloc-wrapper.c,v 1.7 2018/05/13 13:49:04 jsing Exp $ */
+/* $OpenBSD: malloc-wrapper.c,v 1.8 2023/07/08 08:28:23 beck Exp $ */
 /*
  * Copyright (c) 2014 Bob Beck
  *
@@ -18,12 +18,15 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <openssl/crypto.h>
+
 int
 CRYPTO_set_mem_functions(void *(*m)(size_t), void *(*r)(void *, size_t),
     void (*f)(void *))
 {
        return 0;
 }
+LCRYPTO_ALIAS(CRYPTO_set_mem_functions);
 
 int
 CRYPTO_set_mem_ex_functions(void *(*m)(size_t, const char *, int),
@@ -31,12 +34,14 @@ CRYPTO_set_mem_ex_functions(void *(*m)(size_t, const char *, int),
 {
        return 0;
 }
+LCRYPTO_ALIAS(CRYPTO_set_mem_ex_functions);
 
 int
 CRYPTO_set_locked_mem_functions(void *(*m)(size_t), void (*f)(void *))
 {
        return 0;
 }
+LCRYPTO_ALIAS(CRYPTO_set_locked_mem_functions);
 
 int
 CRYPTO_set_locked_mem_ex_functions(void *(*m)(size_t, const char *, int),
@@ -44,6 +49,7 @@ CRYPTO_set_locked_mem_ex_functions(void *(*m)(size_t, const char *, int),
 {
        return 0;
 }
+LCRYPTO_ALIAS(CRYPTO_set_locked_mem_ex_functions);
 
 int
 CRYPTO_set_mem_debug_functions(void (*m)(void *, int, const char *, int, int),
@@ -52,6 +58,7 @@ CRYPTO_set_mem_debug_functions(void (*m)(void *, int, const char *, int, int),
 {
        return 0;
 }
+LCRYPTO_ALIAS(CRYPTO_set_mem_debug_functions);
 
 
 void
@@ -65,6 +72,7 @@ CRYPTO_get_mem_functions(void *(**m)(size_t), void *(**r)(void *, size_t),
        if (f != NULL)
                *f = free;
 }
+LCRYPTO_ALIAS(CRYPTO_get_mem_functions);
 
 void
 CRYPTO_get_mem_ex_functions(void *(**m)(size_t, const char *, int),
@@ -77,6 +85,7 @@ CRYPTO_get_mem_ex_functions(void *(**m)(size_t, const char *, int),
        if (f != NULL)
                *f = free;
 }
+LCRYPTO_ALIAS(CRYPTO_get_mem_ex_functions);
 
 void
 CRYPTO_get_locked_mem_functions(void *(**m)(size_t), void (**f)(void *))
@@ -86,6 +95,7 @@ CRYPTO_get_locked_mem_functions(void *(**m)(size_t), void (**f)(void *))
        if (f != NULL)
                *f = free;
 }
+LCRYPTO_ALIAS(CRYPTO_get_locked_mem_functions);
 
 void
 CRYPTO_get_locked_mem_ex_functions(void *(**m)(size_t, const char *, int),
@@ -96,6 +106,7 @@ CRYPTO_get_locked_mem_ex_functions(void *(**m)(size_t, const char *, int),
        if (f != NULL)
                *f = free;
 }
+LCRYPTO_ALIAS(CRYPTO_get_locked_mem_ex_functions);
 
 void
 CRYPTO_get_mem_debug_functions(void (**m)(void *, int, const char *, int, int),
@@ -113,6 +124,7 @@ CRYPTO_get_mem_debug_functions(void (**m)(void *, int, const char *, int, int),
        if (go != NULL)
                *go = NULL;
 }
+LCRYPTO_ALIAS(CRYPTO_get_mem_debug_functions);
 
 
 void *
@@ -162,6 +174,7 @@ CRYPTO_realloc_clean(void *ptr, int old_len, int num, const char *file,
                return NULL;
        return recallocarray(ptr, old_len, num, 1);
 }
+LCRYPTO_ALIAS(CRYPTO_realloc_clean);
 
 void
 CRYPTO_free(void *ptr)
@@ -175,15 +188,18 @@ CRYPTO_remalloc(void *a, int num, const char *file, int line)
        free(a);
        return malloc(num);
 }
+LCRYPTO_ALIAS(CRYPTO_remalloc);
 
 void
 CRYPTO_set_mem_debug_options(long bits)
 {
        return;
 }
+LCRYPTO_ALIAS(CRYPTO_set_mem_debug_options);
 
 long
 CRYPTO_get_mem_debug_options(void)
 {
        return 0;
 }
+LCRYPTO_ALIAS(CRYPTO_get_mem_debug_options);

diff --git a/lib/libcrypto/mem_dbg.c b/lib/libcrypto/mem_dbg.c
index 602b139..e2eaceb 100644 (file)
--- a/lib/libcrypto/mem_dbg.c
+++ b/lib/libcrypto/mem_dbg.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: mem_dbg.c,v 1.24 2019/01/29 14:40:54 deraadt Exp $ */
+/* $OpenBSD: mem_dbg.c,v 1.25 2023/07/08 08:28:23 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -133,30 +133,35 @@ CRYPTO_dbg_set_options(long bits)
 {
        return;
 }
+LCRYPTO_ALIAS(CRYPTO_dbg_set_options);
 
 long
 CRYPTO_dbg_get_options(void)
 {
        return (0);
 }
+LCRYPTO_ALIAS(CRYPTO_dbg_get_options);
 
 int
 CRYPTO_push_info_(const char *info, const char *file, int line)
 {
        return (0);
 }
+LCRYPTO_ALIAS(CRYPTO_push_info_);
 
 int
 CRYPTO_pop_info(void)
 {
        return (0);
 }
+LCRYPTO_ALIAS(CRYPTO_pop_info);
 
 int
 CRYPTO_remove_all_info(void)
 {
        return (0);
 }
+LCRYPTO_ALIAS(CRYPTO_remove_all_info);
 
 void
 CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line,
@@ -164,12 +169,14 @@ CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line,
 {
        OPENSSL_assert("CRYPTO_dbg_malloc is no longer permitted");
 }
+LCRYPTO_ALIAS(CRYPTO_dbg_malloc);
 
 void
 CRYPTO_dbg_free(void *addr, int before_p)
 {
        OPENSSL_assert("CRYPTO_dbg_free is no longer permitted");
 }
+LCRYPTO_ALIAS(CRYPTO_dbg_free);
 
 void
 CRYPTO_dbg_realloc(void *addr1, void *addr2, int num,
@@ -177,18 +184,21 @@ CRYPTO_dbg_realloc(void *addr1, void *addr2, int num,
 {
        OPENSSL_assert("CRYPTO_dbg_realloc is no longer permitted");
 }
+LCRYPTO_ALIAS(CRYPTO_dbg_realloc);
 
 int
 CRYPTO_mem_leaks(BIO *b)
 {
        return -1;
 }
+LCRYPTO_ALIAS(CRYPTO_mem_leaks);
 
 int
 CRYPTO_mem_leaks_fp(FILE *fp)
 {
        return -1;
 }
+LCRYPTO_ALIAS(CRYPTO_mem_leaks_fp);
 
 
 int
@@ -196,3 +206,4 @@ CRYPTO_mem_leaks_cb(CRYPTO_MEM_LEAK_CB *cb)
 {
        return -1;
 }
+LCRYPTO_ALIAS(CRYPTO_mem_leaks_cb);