From f9fcde20a6214da85e802190ccd3a2bf5f891559 Mon Sep 17 00:00:00 2001
From: beck <>
Date: Fri, 7 Jul 2023 13:54:46 +0000
Subject: Hide symbols in hkdf, evp, err, ecdsa, and ec

(part 2 of commit)

ok jsing@
---
 src/lib/libcrypto/ec/ec_asn1.c  | 25 +++++++++++++++++-
 src/lib/libcrypto/ec/ec_check.c |  3 ++-
 src/lib/libcrypto/ec/ec_curve.c |  6 ++++-
 src/lib/libcrypto/ec/ec_cvt.c   |  3 ++-
 src/lib/libcrypto/ec/ec_err.c   |  3 ++-
 src/lib/libcrypto/ec/ec_key.c   | 28 ++++++++++++++++++++-
 src/lib/libcrypto/ec/ec_kmeth.c | 20 ++++++++++++++-
 src/lib/libcrypto/ec/ec_lib.c   | 56 ++++++++++++++++++++++++++++++++++++++++-
 src/lib/libcrypto/ec/ec_oct.c   |  6 ++++-
 src/lib/libcrypto/ec/ec_print.c |  6 ++++-
 src/lib/libcrypto/ec/eck_prn.c  |  8 +++++-
 src/lib/libcrypto/ec/ecp_mont.c |  3 ++-
 src/lib/libcrypto/ec/ecp_smpl.c |  3 ++-
 13 files changed, 157 insertions(+), 13 deletions(-)

(limited to 'src/lib/libcrypto/ec')

diff --git a/src/lib/libcrypto/ec/ec_asn1.c b/src/lib/libcrypto/ec/ec_asn1.c
index 6aedab9774..0435f0a75f 100644
--- a/src/lib/libcrypto/ec/ec_asn1.c
+++ b/src/lib/libcrypto/ec/ec_asn1.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_asn1.c,v 1.46 2023/06/27 07:28:57 tb Exp $ */
+/* $OpenBSD: ec_asn1.c,v 1.47 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Written by Nils Larsch for the OpenSSL project.
  */
@@ -72,6 +72,7 @@ EC_GROUP_get_basis_type(const EC_GROUP *group)
 {
 	return 0;
 }
+LCRYPTO_ALIAS(EC_GROUP_get_basis_type);
 
 /* some structures needed for the asn1 encoding */
 typedef struct x9_62_pentanomial_st {
@@ -184,12 +185,14 @@ X9_62_PENTANOMIAL_new(void)
 {
 	return (X9_62_PENTANOMIAL*)ASN1_item_new(&X9_62_PENTANOMIAL_it);
 }
+LCRYPTO_ALIAS(X9_62_PENTANOMIAL_new);
 
 void
 X9_62_PENTANOMIAL_free(X9_62_PENTANOMIAL *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &X9_62_PENTANOMIAL_it);
 }
+LCRYPTO_ALIAS(X9_62_PENTANOMIAL_free);
 
 static const ASN1_TEMPLATE char_two_def_tt = {
 	.flags = 0,
@@ -284,12 +287,14 @@ X9_62_CHARACTERISTIC_TWO_new(void)
 {
 	return (X9_62_CHARACTERISTIC_TWO*)ASN1_item_new(&X9_62_CHARACTERISTIC_TWO_it);
 }
+LCRYPTO_ALIAS(X9_62_CHARACTERISTIC_TWO_new);
 
 void
 X9_62_CHARACTERISTIC_TWO_free(X9_62_CHARACTERISTIC_TWO *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &X9_62_CHARACTERISTIC_TWO_it);
 }
+LCRYPTO_ALIAS(X9_62_CHARACTERISTIC_TWO_free);
 
 static const ASN1_TEMPLATE fieldID_def_tt = {
 	.flags = 0,
@@ -455,12 +460,14 @@ ECPARAMETERS_new(void)
 {
 	return (ECPARAMETERS*)ASN1_item_new(&ECPARAMETERS_it);
 }
+LCRYPTO_ALIAS(ECPARAMETERS_new);
 
 void
 ECPARAMETERS_free(ECPARAMETERS *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &ECPARAMETERS_it);
 }
+LCRYPTO_ALIAS(ECPARAMETERS_free);
 
 static const ASN1_TEMPLATE ECPKPARAMETERS_ch_tt[] = {
 	{
@@ -507,24 +514,28 @@ d2i_ECPKPARAMETERS(ECPKPARAMETERS **a, const unsigned char **in, long len)
 	return (ECPKPARAMETERS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &ECPKPARAMETERS_it);
 }
+LCRYPTO_ALIAS(d2i_ECPKPARAMETERS);
 
 int
 i2d_ECPKPARAMETERS(const ECPKPARAMETERS *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &ECPKPARAMETERS_it);
 }
+LCRYPTO_ALIAS(i2d_ECPKPARAMETERS);
 
 ECPKPARAMETERS *
 ECPKPARAMETERS_new(void)
 {
 	return (ECPKPARAMETERS *)ASN1_item_new(&ECPKPARAMETERS_it);
 }
+LCRYPTO_ALIAS(ECPKPARAMETERS_new);
 
 void
 ECPKPARAMETERS_free(ECPKPARAMETERS *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &ECPKPARAMETERS_it);
 }
+LCRYPTO_ALIAS(ECPKPARAMETERS_free);
 
 static const ASN1_TEMPLATE EC_PRIVATEKEY_seq_tt[] = {
 	{
@@ -578,24 +589,28 @@ d2i_EC_PRIVATEKEY(EC_PRIVATEKEY **a, const unsigned char **in, long len)
 	return (EC_PRIVATEKEY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &EC_PRIVATEKEY_it);
 }
+LCRYPTO_ALIAS(d2i_EC_PRIVATEKEY);
 
 int
 i2d_EC_PRIVATEKEY(const EC_PRIVATEKEY *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &EC_PRIVATEKEY_it);
 }
+LCRYPTO_ALIAS(i2d_EC_PRIVATEKEY);
 
 EC_PRIVATEKEY *
 EC_PRIVATEKEY_new(void)
 {
 	return (EC_PRIVATEKEY *)ASN1_item_new(&EC_PRIVATEKEY_it);
 }
+LCRYPTO_ALIAS(EC_PRIVATEKEY_new);
 
 void
 EC_PRIVATEKEY_free(EC_PRIVATEKEY *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &EC_PRIVATEKEY_it);
 }
+LCRYPTO_ALIAS(EC_PRIVATEKEY_free);
 
 /* some declarations of internal function */
 
@@ -1101,6 +1116,7 @@ d2i_ECPKParameters(EC_GROUP **a, const unsigned char **in, long len)
 	ECPKPARAMETERS_free(params);
 	return (group);
 }
+LCRYPTO_ALIAS(d2i_ECPKParameters);
 
 int
 i2d_ECPKParameters(const EC_GROUP *a, unsigned char **out)
@@ -1119,6 +1135,7 @@ i2d_ECPKParameters(const EC_GROUP *a, unsigned char **out)
 	ECPKPARAMETERS_free(tmp);
 	return (ret);
 }
+LCRYPTO_ALIAS(i2d_ECPKParameters);
 
 /* some EC_KEY functions */
 
@@ -1213,6 +1230,7 @@ d2i_ECPrivateKey(EC_KEY **a, const unsigned char **in, long len)
 
 	return (NULL);
 }
+LCRYPTO_ALIAS(d2i_ECPrivateKey);
 
 int
 i2d_ECPrivateKey(EC_KEY *a, unsigned char **out)
@@ -1297,6 +1315,7 @@ i2d_ECPrivateKey(EC_KEY *a, unsigned char **out)
 		EC_PRIVATEKEY_free(priv_key);
 	return (ok ? ret : 0);
 }
+LCRYPTO_ALIAS(i2d_ECPrivateKey);
 
 int
 i2d_ECParameters(EC_KEY *a, unsigned char **out)
@@ -1307,6 +1326,7 @@ i2d_ECParameters(EC_KEY *a, unsigned char **out)
 	}
 	return i2d_ECPKParameters(a->group, out);
 }
+LCRYPTO_ALIAS(i2d_ECParameters);
 
 EC_KEY *
 d2i_ECParameters(EC_KEY **a, const unsigned char **in, long len)
@@ -1336,6 +1356,7 @@ d2i_ECParameters(EC_KEY **a, const unsigned char **in, long len)
 		*a = ret;
 	return ret;
 }
+LCRYPTO_ALIAS(d2i_ECParameters);
 
 EC_KEY *
 o2i_ECPublicKey(EC_KEY **a, const unsigned char **in, long len)
@@ -1362,6 +1383,7 @@ o2i_ECPublicKey(EC_KEY **a, const unsigned char **in, long len)
 	*in += len;
 	return ret;
 }
+LCRYPTO_ALIAS(o2i_ECPublicKey);
 
 int
 i2o_ECPublicKey(const EC_KEY *a, unsigned char **out)
@@ -1400,3 +1422,4 @@ i2o_ECPublicKey(const EC_KEY *a, unsigned char **out)
 		*out += buf_len;
 	return buf_len;
 }
+LCRYPTO_ALIAS(i2o_ECPublicKey);
diff --git a/src/lib/libcrypto/ec/ec_check.c b/src/lib/libcrypto/ec/ec_check.c
index 4a38dec539..0f98ef613c 100644
--- a/src/lib/libcrypto/ec/ec_check.c
+++ b/src/lib/libcrypto/ec/ec_check.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_check.c,v 1.14 2023/07/03 09:29:55 tb Exp $ */
+/* $OpenBSD: ec_check.c,v 1.15 2023/07/07 13:54:45 beck Exp $ */
 /* ====================================================================
  * Copyright (c) 1998-2002 The OpenSSL Project.  All rights reserved.
  *
@@ -109,3 +109,4 @@ EC_GROUP_check(const EC_GROUP *group, BN_CTX *ctx_in)
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_GROUP_check);
diff --git a/src/lib/libcrypto/ec/ec_curve.c b/src/lib/libcrypto/ec/ec_curve.c
index a8a1e4d522..9d19628b3e 100644
--- a/src/lib/libcrypto/ec/ec_curve.c
+++ b/src/lib/libcrypto/ec/ec_curve.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_curve.c,v 1.41 2023/05/02 13:01:57 tb Exp $ */
+/* $OpenBSD: ec_curve.c,v 1.42 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Written by Nils Larsch for the OpenSSL project.
  */
@@ -3122,6 +3122,7 @@ EC_GROUP_new_by_curve_name(int nid)
 	ECerror(EC_R_UNKNOWN_GROUP);
 	return NULL;
 }
+LCRYPTO_ALIAS(EC_GROUP_new_by_curve_name);
 
 size_t
 EC_get_builtin_curves(EC_builtin_curve *r, size_t nitems)
@@ -3140,6 +3141,7 @@ EC_get_builtin_curves(EC_builtin_curve *r, size_t nitems)
 
 	return CURVE_LIST_LENGTH;
 }
+LCRYPTO_ALIAS(EC_get_builtin_curves);
 
 static const struct {
 	const char *name;
@@ -3174,6 +3176,7 @@ EC_curve_nid2nist(int nid)
 
 	return NULL;
 }
+LCRYPTO_ALIAS(EC_curve_nid2nist);
 
 int
 EC_curve_nist2nid(const char *name)
@@ -3187,3 +3190,4 @@ EC_curve_nist2nid(const char *name)
 
 	return NID_undef;
 }
+LCRYPTO_ALIAS(EC_curve_nist2nid);
diff --git a/src/lib/libcrypto/ec/ec_cvt.c b/src/lib/libcrypto/ec/ec_cvt.c
index 90e7400739..5b196dd671 100644
--- a/src/lib/libcrypto/ec/ec_cvt.c
+++ b/src/lib/libcrypto/ec/ec_cvt.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_cvt.c,v 1.11 2023/04/25 19:53:30 tb Exp $ */
+/* $OpenBSD: ec_cvt.c,v 1.12 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Originally written by Bodo Moeller for the OpenSSL project.
  */
@@ -100,3 +100,4 @@ EC_GROUP_new_curve_GFp(const BIGNUM *p, const BIGNUM *a, const BIGNUM *b,
 {
 	return ec_group_new_curve(EC_GFp_mont_method(), p, a, b, ctx);
 }
+LCRYPTO_ALIAS(EC_GROUP_new_curve_GFp);
diff --git a/src/lib/libcrypto/ec/ec_err.c b/src/lib/libcrypto/ec/ec_err.c
index d10b8e6f7d..d797b937c2 100644
--- a/src/lib/libcrypto/ec/ec_err.c
+++ b/src/lib/libcrypto/ec/ec_err.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_err.c,v 1.16 2023/07/05 17:10:10 tb Exp $ */
+/* $OpenBSD: ec_err.c,v 1.17 2023/07/07 13:54:45 beck Exp $ */
 /* ====================================================================
  * Copyright (c) 1999-2011 The OpenSSL Project.  All rights reserved.
  *
@@ -147,3 +147,4 @@ ERR_load_EC_strings(void)
 	}
 #endif
 }
+LCRYPTO_ALIAS(ERR_load_EC_strings);
diff --git a/src/lib/libcrypto/ec/ec_key.c b/src/lib/libcrypto/ec/ec_key.c
index a15d06b019..e5ff189803 100644
--- a/src/lib/libcrypto/ec/ec_key.c
+++ b/src/lib/libcrypto/ec/ec_key.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_key.c,v 1.35 2023/07/05 08:39:40 tb Exp $ */
+/* $OpenBSD: ec_key.c,v 1.36 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Written by Nils Larsch for the OpenSSL project.
  */
@@ -78,6 +78,7 @@ EC_KEY_new(void)
 {
 	return EC_KEY_new_method(NULL);
 }
+LCRYPTO_ALIAS(EC_KEY_new);
 
 EC_KEY *
 EC_KEY_new_by_curve_name(int nid)
@@ -97,6 +98,7 @@ EC_KEY_new_by_curve_name(int nid)
 	}
 	return ret;
 }
+LCRYPTO_ALIAS(EC_KEY_new_by_curve_name);
 
 void
 EC_KEY_free(EC_KEY *r)
@@ -124,6 +126,7 @@ EC_KEY_free(EC_KEY *r)
 
 	freezero(r, sizeof(EC_KEY));
 }
+LCRYPTO_ALIAS(EC_KEY_free);
 
 EC_KEY *
 EC_KEY_copy(EC_KEY *dest, const EC_KEY *src)
@@ -197,6 +200,7 @@ EC_KEY_copy(EC_KEY *dest, const EC_KEY *src)
 
 	return dest;
 }
+LCRYPTO_ALIAS(EC_KEY_copy);
 
 EC_KEY *
 EC_KEY_dup(const EC_KEY *ec_key)
@@ -211,6 +215,7 @@ EC_KEY_dup(const EC_KEY *ec_key)
 	}
 	return ret;
 }
+LCRYPTO_ALIAS(EC_KEY_dup);
 
 int
 EC_KEY_up_ref(EC_KEY *r)
@@ -218,18 +223,21 @@ EC_KEY_up_ref(EC_KEY *r)
 	int i = CRYPTO_add(&r->references, 1, CRYPTO_LOCK_EC);
 	return ((i > 1) ? 1 : 0);
 }
+LCRYPTO_ALIAS(EC_KEY_up_ref);
 
 int
 EC_KEY_set_ex_data(EC_KEY *r, int idx, void *arg)
 {
 	return CRYPTO_set_ex_data(&r->ex_data, idx, arg);
 }
+LCRYPTO_ALIAS(EC_KEY_set_ex_data);
 
 void *
 EC_KEY_get_ex_data(const EC_KEY *r, int idx)
 {
 	return CRYPTO_get_ex_data(&r->ex_data, idx);
 }
+LCRYPTO_ALIAS(EC_KEY_get_ex_data);
 
 int
 EC_KEY_generate_key(EC_KEY *eckey)
@@ -239,6 +247,7 @@ EC_KEY_generate_key(EC_KEY *eckey)
 	ECerror(EC_R_NOT_IMPLEMENTED);
 	return 0;
 }
+LCRYPTO_ALIAS(EC_KEY_generate_key);
 
 int
 ec_key_gen(EC_KEY *eckey)
@@ -355,6 +364,7 @@ EC_KEY_check_key(const EC_KEY *eckey)
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_KEY_check_key);
 
 int
 EC_KEY_set_public_key_affine_coordinates(EC_KEY *key, BIGNUM *x, BIGNUM *y)
@@ -409,12 +419,14 @@ EC_KEY_set_public_key_affine_coordinates(EC_KEY *key, BIGNUM *x, BIGNUM *y)
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_KEY_set_public_key_affine_coordinates);
 
 const EC_GROUP *
 EC_KEY_get0_group(const EC_KEY *key)
 {
 	return key->group;
 }
+LCRYPTO_ALIAS(EC_KEY_get0_group);
 
 int
 EC_KEY_set_group(EC_KEY *key, const EC_GROUP *group)
@@ -426,12 +438,14 @@ EC_KEY_set_group(EC_KEY *key, const EC_GROUP *group)
 	key->group = EC_GROUP_dup(group);
 	return (key->group == NULL) ? 0 : 1;
 }
+LCRYPTO_ALIAS(EC_KEY_set_group);
 
 const BIGNUM *
 EC_KEY_get0_private_key(const EC_KEY *key)
 {
 	return key->priv_key;
 }
+LCRYPTO_ALIAS(EC_KEY_get0_private_key);
 
 int
 EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *priv_key)
@@ -446,12 +460,14 @@ EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *priv_key)
 
 	return 1;
 }
+LCRYPTO_ALIAS(EC_KEY_set_private_key);
 
 const EC_POINT *
 EC_KEY_get0_public_key(const EC_KEY *key)
 {
 	return key->pub_key;
 }
+LCRYPTO_ALIAS(EC_KEY_get0_public_key);
 
 int
 EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub_key)
@@ -466,24 +482,28 @@ EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub_key)
 
 	return 1;
 }
+LCRYPTO_ALIAS(EC_KEY_set_public_key);
 
 unsigned int
 EC_KEY_get_enc_flags(const EC_KEY *key)
 {
 	return key->enc_flag;
 }
+LCRYPTO_ALIAS(EC_KEY_get_enc_flags);
 
 void
 EC_KEY_set_enc_flags(EC_KEY *key, unsigned int flags)
 {
 	key->enc_flag = flags;
 }
+LCRYPTO_ALIAS(EC_KEY_set_enc_flags);
 
 point_conversion_form_t
 EC_KEY_get_conv_form(const EC_KEY *key)
 {
 	return key->conv_form;
 }
+LCRYPTO_ALIAS(EC_KEY_get_conv_form);
 
 void
 EC_KEY_set_conv_form(EC_KEY *key, point_conversion_form_t cform)
@@ -492,6 +512,7 @@ EC_KEY_set_conv_form(EC_KEY *key, point_conversion_form_t cform)
 	if (key->group != NULL)
 		EC_GROUP_set_point_conversion_form(key->group, cform);
 }
+LCRYPTO_ALIAS(EC_KEY_set_conv_form);
 
 void
 EC_KEY_set_asn1_flag(EC_KEY *key, int flag)
@@ -499,6 +520,7 @@ EC_KEY_set_asn1_flag(EC_KEY *key, int flag)
 	if (key->group != NULL)
 		EC_GROUP_set_asn1_flag(key->group, flag);
 }
+LCRYPTO_ALIAS(EC_KEY_set_asn1_flag);
 
 int
 EC_KEY_precompute_mult(EC_KEY *key, BN_CTX *ctx)
@@ -507,21 +529,25 @@ EC_KEY_precompute_mult(EC_KEY *key, BN_CTX *ctx)
 		return 0;
 	return EC_GROUP_precompute_mult(key->group, ctx);
 }
+LCRYPTO_ALIAS(EC_KEY_precompute_mult);
 
 int
 EC_KEY_get_flags(const EC_KEY *key)
 {
 	return key->flags;
 }
+LCRYPTO_ALIAS(EC_KEY_get_flags);
 
 void
 EC_KEY_set_flags(EC_KEY *key, int flags)
 {
 	key->flags |= flags;
 }
+LCRYPTO_ALIAS(EC_KEY_set_flags);
 
 void
 EC_KEY_clear_flags(EC_KEY *key, int flags)
 {
 	key->flags &= ~flags;
 }
+LCRYPTO_ALIAS(EC_KEY_clear_flags);
diff --git a/src/lib/libcrypto/ec/ec_kmeth.c b/src/lib/libcrypto/ec/ec_kmeth.c
index ec45e679d9..3e997f8a5e 100644
--- a/src/lib/libcrypto/ec/ec_kmeth.c
+++ b/src/lib/libcrypto/ec/ec_kmeth.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: ec_kmeth.c,v 1.10 2023/07/05 11:37:46 tb Exp $	*/
+/*	$OpenBSD: ec_kmeth.c,v 1.11 2023/07/07 13:54:45 beck Exp $	*/
 /*
  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project.
@@ -92,12 +92,14 @@ EC_KEY_OpenSSL(void)
 {
 	return &openssl_ec_key_method;
 }
+LCRYPTO_ALIAS(EC_KEY_OpenSSL);
 
 const EC_KEY_METHOD *
 EC_KEY_get_default_method(void)
 {
 	return default_ec_key_meth;
 }
+LCRYPTO_ALIAS(EC_KEY_get_default_method);
 
 void
 EC_KEY_set_default_method(const EC_KEY_METHOD *meth)
@@ -107,12 +109,14 @@ EC_KEY_set_default_method(const EC_KEY_METHOD *meth)
 	else
 		default_ec_key_meth = meth;
 }
+LCRYPTO_ALIAS(EC_KEY_set_default_method);
 
 const EC_KEY_METHOD *
 EC_KEY_get_method(const EC_KEY *key)
 {
 	return key->meth;
 }
+LCRYPTO_ALIAS(EC_KEY_get_method);
 
 int
 EC_KEY_set_method(EC_KEY *key, const EC_KEY_METHOD *meth)
@@ -132,6 +136,7 @@ EC_KEY_set_method(EC_KEY *key, const EC_KEY_METHOD *meth)
 		return meth->init(key);
 	return 1;
 }
+LCRYPTO_ALIAS(EC_KEY_set_method);
 
 EC_KEY *
 EC_KEY_new_method(ENGINE *engine)
@@ -180,6 +185,7 @@ EC_KEY_new_method(ENGINE *engine)
 	EC_KEY_free(ret);
 	return NULL;
 }
+LCRYPTO_ALIAS(EC_KEY_new_method);
 
 EC_KEY_METHOD *
 EC_KEY_METHOD_new(const EC_KEY_METHOD *meth)
@@ -193,6 +199,7 @@ EC_KEY_METHOD_new(const EC_KEY_METHOD *meth)
 	ret->flags |= EC_KEY_METHOD_DYNAMIC;
 	return ret;
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_new);
 
 void
 EC_KEY_METHOD_free(EC_KEY_METHOD *meth)
@@ -202,6 +209,7 @@ EC_KEY_METHOD_free(EC_KEY_METHOD *meth)
 	if (meth->flags & EC_KEY_METHOD_DYNAMIC)
 		free(meth);
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_free);
 
 void
 EC_KEY_METHOD_set_init(EC_KEY_METHOD *meth,
@@ -219,12 +227,14 @@ EC_KEY_METHOD_set_init(EC_KEY_METHOD *meth,
 	meth->set_private = set_private;
 	meth->set_public = set_public;
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_set_init);
 
 void
 EC_KEY_METHOD_set_keygen(EC_KEY_METHOD *meth, int (*keygen)(EC_KEY *key))
 {
 	meth->keygen = keygen;
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_set_keygen);
 
 void
 EC_KEY_METHOD_set_compute_key(EC_KEY_METHOD *meth,
@@ -233,6 +243,7 @@ EC_KEY_METHOD_set_compute_key(EC_KEY_METHOD *meth,
 {
 	meth->compute_key = ckey;
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_set_compute_key);
 
 void
 EC_KEY_METHOD_set_sign(EC_KEY_METHOD *meth,
@@ -249,6 +260,7 @@ EC_KEY_METHOD_set_sign(EC_KEY_METHOD *meth,
 	meth->sign_setup = sign_setup;
 	meth->sign_sig = sign_sig;
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_set_sign);
 
 void
 EC_KEY_METHOD_set_verify(EC_KEY_METHOD *meth,
@@ -260,6 +272,7 @@ EC_KEY_METHOD_set_verify(EC_KEY_METHOD *meth,
 	meth->verify = verify;
 	meth->verify_sig = verify_sig;
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_set_verify);
 
 
 void
@@ -284,6 +297,7 @@ EC_KEY_METHOD_get_init(const EC_KEY_METHOD *meth,
 	if (pset_public != NULL)
 		*pset_public = meth->set_public;
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_get_init);
 
 void
 EC_KEY_METHOD_get_keygen(const EC_KEY_METHOD *meth,
@@ -292,6 +306,7 @@ EC_KEY_METHOD_get_keygen(const EC_KEY_METHOD *meth,
 	if (pkeygen != NULL)
 		*pkeygen = meth->keygen;
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_get_keygen);
 
 void
 EC_KEY_METHOD_get_compute_key(const EC_KEY_METHOD *meth,
@@ -301,6 +316,7 @@ EC_KEY_METHOD_get_compute_key(const EC_KEY_METHOD *meth,
 	if (pck != NULL)
 		*pck = meth->compute_key;
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_get_compute_key);
 
 void
 EC_KEY_METHOD_get_sign(const EC_KEY_METHOD *meth,
@@ -320,6 +336,7 @@ EC_KEY_METHOD_get_sign(const EC_KEY_METHOD *meth,
 	if (psign_sig != NULL)
 		*psign_sig = meth->sign_sig;
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_get_sign);
 
 void
 EC_KEY_METHOD_get_verify(const EC_KEY_METHOD *meth,
@@ -333,3 +350,4 @@ EC_KEY_METHOD_get_verify(const EC_KEY_METHOD *meth,
 	if (pverify_sig != NULL)
 		*pverify_sig = meth->verify_sig;
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_get_verify);
diff --git a/src/lib/libcrypto/ec/ec_lib.c b/src/lib/libcrypto/ec/ec_lib.c
index 8cea0bb95b..3db1ca2f07 100644
--- a/src/lib/libcrypto/ec/ec_lib.c
+++ b/src/lib/libcrypto/ec/ec_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_lib.c,v 1.62 2023/07/03 07:26:40 tb Exp $ */
+/* $OpenBSD: ec_lib.c,v 1.63 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Originally written by Bodo Moeller for the OpenSSL project.
  */
@@ -110,6 +110,7 @@ EC_GROUP_new(const EC_METHOD *meth)
 	}
 	return ret;
 }
+LCRYPTO_ALIAS(EC_GROUP_new);
 
 
 void
@@ -128,12 +129,14 @@ EC_GROUP_free(EC_GROUP *group)
 	freezero(group->seed, group->seed_len);
 	freezero(group, sizeof *group);
 }
+LCRYPTO_ALIAS(EC_GROUP_free);
 
 void
 EC_GROUP_clear_free(EC_GROUP *group)
 {
 	EC_GROUP_free(group);
 }
+LCRYPTO_ALIAS(EC_GROUP_clear_free);
 
 int
 EC_GROUP_copy(EC_GROUP *dest, const EC_GROUP *src)
@@ -188,6 +191,7 @@ EC_GROUP_copy(EC_GROUP *dest, const EC_GROUP *src)
 
 	return dest->meth->group_copy(dest, src);
 }
+LCRYPTO_ALIAS(EC_GROUP_copy);
 
 
 EC_GROUP *
@@ -202,6 +206,7 @@ EC_GROUP_dup(const EC_GROUP *a)
 	}
 	return t;
 }
+LCRYPTO_ALIAS(EC_GROUP_dup);
 
 
 const EC_METHOD *
@@ -209,6 +214,7 @@ EC_GROUP_method_of(const EC_GROUP *group)
 {
 	return group->meth;
 }
+LCRYPTO_ALIAS(EC_GROUP_method_of);
 
 
 int
@@ -216,6 +222,7 @@ EC_METHOD_get_field_type(const EC_METHOD *meth)
 {
 	return meth->field_type;
 }
+LCRYPTO_ALIAS(EC_METHOD_get_field_type);
 
 /*
  * If there is a user-provided cofactor, sanity check and use it. Otherwise
@@ -349,6 +356,7 @@ EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator,
 
 	return 1;
 }
+LCRYPTO_ALIAS(EC_GROUP_set_generator);
 
 
 const EC_POINT *
@@ -356,6 +364,7 @@ EC_GROUP_get0_generator(const EC_GROUP *group)
 {
 	return group->generator;
 }
+LCRYPTO_ALIAS(EC_GROUP_get0_generator);
 
 int
 EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx)
@@ -365,6 +374,7 @@ EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx)
 
 	return !BN_is_zero(order);
 }
+LCRYPTO_ALIAS(EC_GROUP_get_order);
 
 const BIGNUM *
 EC_GROUP_get0_order(const EC_GROUP *group)
@@ -377,6 +387,7 @@ EC_GROUP_order_bits(const EC_GROUP *group)
 {
 	return group->meth->group_order_bits(group);
 }
+LCRYPTO_ALIAS(EC_GROUP_order_bits);
 
 int
 EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor, BN_CTX *ctx)
@@ -386,6 +397,7 @@ EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor, BN_CTX *ctx)
 
 	return !BN_is_zero(&group->cofactor);
 }
+LCRYPTO_ALIAS(EC_GROUP_get_cofactor);
 
 
 void
@@ -393,6 +405,7 @@ EC_GROUP_set_curve_name(EC_GROUP *group, int nid)
 {
 	group->curve_name = nid;
 }
+LCRYPTO_ALIAS(EC_GROUP_set_curve_name);
 
 
 int
@@ -400,6 +413,7 @@ EC_GROUP_get_curve_name(const EC_GROUP *group)
 {
 	return group->curve_name;
 }
+LCRYPTO_ALIAS(EC_GROUP_get_curve_name);
 
 
 void
@@ -407,6 +421,7 @@ EC_GROUP_set_asn1_flag(EC_GROUP *group, int flag)
 {
 	group->asn1_flag = flag;
 }
+LCRYPTO_ALIAS(EC_GROUP_set_asn1_flag);
 
 
 int
@@ -414,6 +429,7 @@ EC_GROUP_get_asn1_flag(const EC_GROUP *group)
 {
 	return group->asn1_flag;
 }
+LCRYPTO_ALIAS(EC_GROUP_get_asn1_flag);
 
 
 void
@@ -422,6 +438,7 @@ EC_GROUP_set_point_conversion_form(EC_GROUP *group,
 {
 	group->asn1_form = form;
 }
+LCRYPTO_ALIAS(EC_GROUP_set_point_conversion_form);
 
 
 point_conversion_form_t
@@ -429,6 +446,7 @@ EC_GROUP_get_point_conversion_form(const EC_GROUP *group)
 {
 	return group->asn1_form;
 }
+LCRYPTO_ALIAS(EC_GROUP_get_point_conversion_form);
 
 
 size_t
@@ -449,6 +467,7 @@ EC_GROUP_set_seed(EC_GROUP *group, const unsigned char *p, size_t len)
 
 	return len;
 }
+LCRYPTO_ALIAS(EC_GROUP_set_seed);
 
 
 unsigned char *
@@ -456,6 +475,7 @@ EC_GROUP_get0_seed(const EC_GROUP *group)
 {
 	return group->seed;
 }
+LCRYPTO_ALIAS(EC_GROUP_get0_seed);
 
 
 size_t
@@ -463,6 +483,7 @@ EC_GROUP_get_seed_len(const EC_GROUP *group)
 {
 	return group->seed_len;
 }
+LCRYPTO_ALIAS(EC_GROUP_get_seed_len);
 
 int
 EC_GROUP_set_curve(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a,
@@ -488,6 +509,7 @@ EC_GROUP_set_curve(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a,
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_GROUP_set_curve);
 
 int
 EC_GROUP_get_curve(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b,
@@ -513,6 +535,7 @@ EC_GROUP_get_curve(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b,
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_GROUP_get_curve);
 
 int
 EC_GROUP_set_curve_GFp(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a,
@@ -520,6 +543,7 @@ EC_GROUP_set_curve_GFp(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a,
 {
 	return EC_GROUP_set_curve(group, p, a, b, ctx);
 }
+LCRYPTO_ALIAS(EC_GROUP_set_curve_GFp);
 
 int
 EC_GROUP_get_curve_GFp(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b,
@@ -527,6 +551,7 @@ EC_GROUP_get_curve_GFp(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b,
 {
 	return EC_GROUP_get_curve(group, p, a, b, ctx);
 }
+LCRYPTO_ALIAS(EC_GROUP_get_curve_GFp);
 
 int
 EC_GROUP_get_degree(const EC_GROUP *group)
@@ -537,6 +562,7 @@ EC_GROUP_get_degree(const EC_GROUP *group)
 	}
 	return group->meth->group_get_degree(group);
 }
+LCRYPTO_ALIAS(EC_GROUP_get_degree);
 
 
 int
@@ -562,6 +588,7 @@ EC_GROUP_check_discriminant(const EC_GROUP *group, BN_CTX *ctx_in)
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_GROUP_check_discriminant);
 
 
 int
@@ -637,6 +664,7 @@ EC_GROUP_cmp(const EC_GROUP *a, const EC_GROUP *b, BN_CTX *ctx)
 		BN_CTX_free(ctx);
 	return -1;
 }
+LCRYPTO_ALIAS(EC_GROUP_cmp);
 
 /*
  * Coordinate blinding for EC_POINT.
@@ -682,6 +710,7 @@ EC_POINT_new(const EC_GROUP *group)
 	}
 	return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_new);
 
 void
 EC_POINT_free(EC_POINT *point)
@@ -694,12 +723,14 @@ EC_POINT_free(EC_POINT *point)
 
 	freezero(point, sizeof *point);
 }
+LCRYPTO_ALIAS(EC_POINT_free);
 
 void
 EC_POINT_clear_free(EC_POINT *point)
 {
 	EC_POINT_free(point);
 }
+LCRYPTO_ALIAS(EC_POINT_clear_free);
 
 int
 EC_POINT_copy(EC_POINT *dest, const EC_POINT *src)
@@ -716,6 +747,7 @@ EC_POINT_copy(EC_POINT *dest, const EC_POINT *src)
 		return 1;
 	return dest->meth->point_copy(dest, src);
 }
+LCRYPTO_ALIAS(EC_POINT_copy);
 
 EC_POINT *
 EC_POINT_dup(const EC_POINT *a, const EC_GROUP *group)
@@ -736,12 +768,14 @@ EC_POINT_dup(const EC_POINT *a, const EC_GROUP *group)
 	} else
 		return t;
 }
+LCRYPTO_ALIAS(EC_POINT_dup);
 
 const EC_METHOD *
 EC_POINT_method_of(const EC_POINT *point)
 {
 	return point->meth;
 }
+LCRYPTO_ALIAS(EC_POINT_method_of);
 
 int
 EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point)
@@ -756,6 +790,7 @@ EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point)
 	}
 	return group->meth->point_set_to_infinity(group, point);
 }
+LCRYPTO_ALIAS(EC_POINT_set_to_infinity);
 
 int
 EC_POINT_set_Jprojective_coordinates(const EC_GROUP *group, EC_POINT *point,
@@ -831,6 +866,7 @@ EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 {
 	return EC_POINT_set_Jprojective_coordinates(group, point, x, y, z, ctx);
 }
+LCRYPTO_ALIAS(EC_POINT_set_Jprojective_coordinates_GFp);
 
 int
 EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group,
@@ -838,6 +874,7 @@ EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group,
 {
 	return EC_POINT_get_Jprojective_coordinates(group, point, x, y, z, ctx);
 }
+LCRYPTO_ALIAS(EC_POINT_get_Jprojective_coordinates_GFp);
 
 int
 EC_POINT_set_affine_coordinates(const EC_GROUP *group, EC_POINT *point,
@@ -875,6 +912,7 @@ EC_POINT_set_affine_coordinates(const EC_GROUP *group, EC_POINT *point,
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_set_affine_coordinates);
 
 int
 EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
@@ -882,6 +920,7 @@ EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 {
 	return EC_POINT_set_affine_coordinates(group, point, x, y, ctx);
 }
+LCRYPTO_ALIAS(EC_POINT_set_affine_coordinates_GFp);
 
 int
 EC_POINT_get_affine_coordinates(const EC_GROUP *group, const EC_POINT *point,
@@ -911,6 +950,7 @@ EC_POINT_get_affine_coordinates(const EC_GROUP *group, const EC_POINT *point,
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_get_affine_coordinates);
 
 int
 EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point,
@@ -918,6 +958,7 @@ EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point
 {
 	return EC_POINT_get_affine_coordinates(group, point, x, y, ctx);
 }
+LCRYPTO_ALIAS(EC_POINT_get_affine_coordinates_GFp);
 
 int
 EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
@@ -948,6 +989,7 @@ EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_add);
 
 int
 EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
@@ -977,6 +1019,7 @@ EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_dbl);
 
 int
 EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx_in)
@@ -1005,6 +1048,7 @@ EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx_in)
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_invert);
 
 int
 EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *point)
@@ -1019,6 +1063,7 @@ EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *point)
 	}
 	return group->meth->is_at_infinity(group, point);
 }
+LCRYPTO_ALIAS(EC_POINT_is_at_infinity);
 
 int
 EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point,
@@ -1048,6 +1093,7 @@ EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point,
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_is_on_curve);
 
 int
 EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b,
@@ -1077,6 +1123,7 @@ EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b,
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_cmp);
 
 int
 EC_POINT_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx_in)
@@ -1105,6 +1152,7 @@ EC_POINT_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx_in)
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_make_affine);
 
 int
 EC_POINTs_make_affine(const EC_GROUP *group, size_t num, EC_POINT *points[],
@@ -1137,6 +1185,7 @@ EC_POINTs_make_affine(const EC_GROUP *group, size_t num, EC_POINT *points[],
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_POINTs_make_affine);
 
 int
 EC_POINTs_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
@@ -1178,6 +1227,7 @@ EC_POINTs_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_POINTs_mul);
 
 int
 EC_POINT_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *g_scalar,
@@ -1239,18 +1289,21 @@ EC_POINT_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *g_scalar,
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_mul);
 
 int
 EC_GROUP_precompute_mult(EC_GROUP *group, BN_CTX *ctx_in)
 {
 	return 1;
 }
+LCRYPTO_ALIAS(EC_GROUP_precompute_mult);
 
 int
 EC_GROUP_have_precompute_mult(const EC_GROUP *group)
 {
 	return 0;
 }
+LCRYPTO_ALIAS(EC_GROUP_have_precompute_mult);
 
 int
 ec_group_simple_order_bits(const EC_GROUP *group)
@@ -1283,3 +1336,4 @@ ECParameters_dup(EC_KEY *key)
 
 	return dup;
 }
+LCRYPTO_ALIAS(ECParameters_dup);
diff --git a/src/lib/libcrypto/ec/ec_oct.c b/src/lib/libcrypto/ec/ec_oct.c
index f9de2f13a1..b9bc62a4e3 100644
--- a/src/lib/libcrypto/ec/ec_oct.c
+++ b/src/lib/libcrypto/ec/ec_oct.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_oct.c,v 1.14 2023/05/04 06:45:51 tb Exp $ */
+/* $OpenBSD: ec_oct.c,v 1.15 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Originally written by Bodo Moeller for the OpenSSL project.
  */
@@ -99,6 +99,7 @@ EC_POINT_set_compressed_coordinates(const EC_GROUP *group, EC_POINT *point,
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_set_compressed_coordinates);
 
 int
 EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
@@ -106,6 +107,7 @@ EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 {
 	return EC_POINT_set_compressed_coordinates(group, point, x, y_bit, ctx);
 }
+LCRYPTO_ALIAS(EC_POINT_set_compressed_coordinates_GFp);
 
 size_t
 EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *point,
@@ -136,6 +138,7 @@ EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *point,
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_point2oct);
 
 int
 EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *point,
@@ -165,3 +168,4 @@ EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *point,
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_oct2point);
diff --git a/src/lib/libcrypto/ec/ec_print.c b/src/lib/libcrypto/ec/ec_print.c
index da33c4eccd..312770f66c 100644
--- a/src/lib/libcrypto/ec/ec_print.c
+++ b/src/lib/libcrypto/ec/ec_print.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_print.c,v 1.12 2023/06/23 10:34:16 tb Exp $ */
+/* $OpenBSD: ec_print.c,v 1.13 2023/07/07 13:54:45 beck Exp $ */
 /* ====================================================================
  * Copyright (c) 1998-2002 The OpenSSL Project.  All rights reserved.
  *
@@ -81,6 +81,7 @@ EC_POINT_point2bn(const EC_GROUP *group, const EC_POINT *point,
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_point2bn);
 
 EC_POINT *
 EC_POINT_bn2point(const EC_GROUP *group,
@@ -117,6 +118,7 @@ EC_POINT_bn2point(const EC_GROUP *group,
 	free(buf);
 	return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_bn2point);
 
 static const char *HEX_DIGITS = "0123456789ABCDEF";
 
@@ -159,6 +161,7 @@ EC_POINT_point2hex(const EC_GROUP *group, const EC_POINT *point,
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_point2hex);
 
 EC_POINT *
 EC_POINT_hex2point(const EC_GROUP *group, const char *buf,
@@ -176,3 +179,4 @@ EC_POINT_hex2point(const EC_GROUP *group, const char *buf,
 
 	return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_hex2point);
diff --git a/src/lib/libcrypto/ec/eck_prn.c b/src/lib/libcrypto/ec/eck_prn.c
index f65b74518b..6e89bfa739 100644
--- a/src/lib/libcrypto/ec/eck_prn.c
+++ b/src/lib/libcrypto/ec/eck_prn.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: eck_prn.c,v 1.27 2023/07/06 15:18:02 tb Exp $ */
+/* $OpenBSD: eck_prn.c,v 1.28 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Written by Nils Larsch for the OpenSSL project.
  */
@@ -86,6 +86,7 @@ ECPKParameters_print_fp(FILE *fp, const EC_GROUP *x, int off)
 	BIO_free(b);
 	return (ret);
 }
+LCRYPTO_ALIAS(ECPKParameters_print_fp);
 
 int
 EC_KEY_print_fp(FILE *fp, const EC_KEY *x, int off)
@@ -102,6 +103,7 @@ EC_KEY_print_fp(FILE *fp, const EC_KEY *x, int off)
 	BIO_free(b);
 	return (ret);
 }
+LCRYPTO_ALIAS(EC_KEY_print_fp);
 
 int
 ECParameters_print_fp(FILE *fp, const EC_KEY *x)
@@ -118,6 +120,7 @@ ECParameters_print_fp(FILE *fp, const EC_KEY *x)
 	BIO_free(b);
 	return (ret);
 }
+LCRYPTO_ALIAS(ECParameters_print_fp);
 
 int
 EC_KEY_print(BIO *bp, const EC_KEY *x, int off)
@@ -136,6 +139,7 @@ EC_KEY_print(BIO *bp, const EC_KEY *x, int off)
 	EVP_PKEY_free(pk);
 	return ret;
 }
+LCRYPTO_ALIAS(EC_KEY_print);
 
 int
 ECParameters_print(BIO *bp, const EC_KEY *x)
@@ -154,6 +158,7 @@ ECParameters_print(BIO *bp, const EC_KEY *x)
 	EVP_PKEY_free(pk);
 	return ret;
 }
+LCRYPTO_ALIAS(ECParameters_print);
 
 static int
 print_bin(BIO *fp, const char *str, const unsigned char *num,
@@ -310,6 +315,7 @@ ECPKParameters_print(BIO *bp, const EC_GROUP *group, int off)
 
 	return ecpk_print_explicit_parameters(bp, group, off);
 }
+LCRYPTO_ALIAS(ECPKParameters_print);
 
 static int
 print_bin(BIO *fp, const char *name, const unsigned char *buf,
diff --git a/src/lib/libcrypto/ec/ecp_mont.c b/src/lib/libcrypto/ec/ecp_mont.c
index b113855603..76d1f578ee 100644
--- a/src/lib/libcrypto/ec/ecp_mont.c
+++ b/src/lib/libcrypto/ec/ecp_mont.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ecp_mont.c,v 1.29 2023/04/11 18:58:20 jsing Exp $ */
+/* $OpenBSD: ecp_mont.c,v 1.30 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Originally written by Bodo Moeller for the OpenSSL project.
  */
@@ -269,3 +269,4 @@ EC_GFp_mont_method(void)
 {
 	return &ec_GFp_mont_method;
 }
+LCRYPTO_ALIAS(EC_GFp_mont_method);
diff --git a/src/lib/libcrypto/ec/ecp_smpl.c b/src/lib/libcrypto/ec/ecp_smpl.c
index d3ee9f5d92..9aa9af11f3 100644
--- a/src/lib/libcrypto/ec/ecp_smpl.c
+++ b/src/lib/libcrypto/ec/ecp_smpl.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ecp_smpl.c,v 1.45 2023/06/30 18:19:35 tb Exp $ */
+/* $OpenBSD: ecp_smpl.c,v 1.46 2023/07/07 13:54:45 beck Exp $ */
 /* Includes code written by Lenka Fibikova <fibikova@exp-math.uni-essen.de>
  * for the OpenSSL project.
  * Includes code written by Bodo Moeller for the OpenSSL project.
@@ -1604,3 +1604,4 @@ EC_GFp_simple_method(void)
 {
 	return &ec_GFp_simple_method;
 }
+LCRYPTO_ALIAS(EC_GFp_simple_method);
-- 
cgit v1.2.3-55-g6feb