hide symbols in dsa

ok tb@

10 files changed, 232 insertions, 8 deletions

diff --git a/src/lib/libcrypto/Symbols.namespace b/src/lib/libcrypto/Symbols.namespace
index 3dc0c33921..7676e45f90 100644
--- a/src/lib/libcrypto/Symbols.namespace
+++ b/src/lib/libcrypto/Symbols.namespace
@@ -2566,3 +2566,68 @@ _libre_CMAC_Init
 _libre_CMAC_Update
 _libre_CMAC_Final
 _libre_CMAC_resume
+_libre_d2i_DSAparams_bio
+_libre_i2d_DSAparams_bio
+_libre_d2i_DSAparams_fp
+_libre_i2d_DSAparams_fp
+_libre_DSAparams_dup
+_libre_DSA_SIG_new
+_libre_DSA_SIG_free
+_libre_i2d_DSA_SIG
+_libre_d2i_DSA_SIG
+_libre_DSA_SIG_get0
+_libre_DSA_SIG_set0
+_libre_DSA_do_sign
+_libre_DSA_do_verify
+_libre_DSA_OpenSSL
+_libre_DSA_set_default_method
+_libre_DSA_get_default_method
+_libre_DSA_set_method
+_libre_DSA_new
+_libre_DSA_new_method
+_libre_DSA_free
+_libre_DSA_up_ref
+_libre_DSA_size
+_libre_DSA_bits
+_libre_DSA_sign_setup
+_libre_DSA_sign
+_libre_DSA_verify
+_libre_DSA_get_ex_new_index
+_libre_DSA_set_ex_data
+_libre_DSA_get_ex_data
+_libre_DSA_security_bits
+_libre_d2i_DSAPublicKey
+_libre_i2d_DSAPublicKey
+_libre_d2i_DSAPrivateKey
+_libre_i2d_DSAPrivateKey
+_libre_d2i_DSAparams
+_libre_i2d_DSAparams
+_libre_DSA_generate_parameters
+_libre_DSA_generate_parameters_ex
+_libre_DSA_generate_key
+_libre_DSAparams_print
+_libre_DSA_print
+_libre_DSAparams_print_fp
+_libre_DSA_print_fp
+_libre_DSA_dup_DH
+_libre_DSA_get0_pqg
+_libre_DSA_set0_pqg
+_libre_DSA_get0_key
+_libre_DSA_set0_key
+_libre_DSA_get0_p
+_libre_DSA_get0_q
+_libre_DSA_get0_g
+_libre_DSA_get0_pub_key
+_libre_DSA_get0_priv_key
+_libre_DSA_clear_flags
+_libre_DSA_test_flags
+_libre_DSA_set_flags
+_libre_DSA_get0_engine
+_libre_DSA_meth_new
+_libre_DSA_meth_free
+_libre_DSA_meth_dup
+_libre_DSA_meth_get0_name
+_libre_DSA_meth_set1_name
+_libre_DSA_meth_set_sign
+_libre_DSA_meth_set_finish
+_libre_ERR_load_DSA_strings
diff --git a/src/lib/libcrypto/dsa/dsa_asn1.c b/src/lib/libcrypto/dsa/dsa_asn1.c
index 70a826ca95..5e4f882cfc 100644
--- a/src/lib/libcrypto/dsa/dsa_asn1.c
+++ b/src/lib/libcrypto/dsa/dsa_asn1.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: dsa_asn1.c,v 1.30 2023/03/25 09:09:28 tb Exp $ */
+/* $OpenBSD: dsa_asn1.c,v 1.31 2023/07/08 14:28:15 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2000.
  */
@@ -126,12 +126,14 @@ d2i_DSA_SIG(DSA_SIG **a, const unsigned char **in, long len)
         return (DSA_SIG *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
             &DSA_SIG_it);
 }
+LCRYPTO_ALIAS(d2i_DSA_SIG);
 
 int
 i2d_DSA_SIG(const DSA_SIG *a, unsigned char **out)
 {
         return ASN1_item_i2d((ASN1_VALUE *)a, out, &DSA_SIG_it);
 }
+LCRYPTO_ALIAS(i2d_DSA_SIG);
 
 void
 DSA_SIG_get0(const DSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps)
@@ -141,6 +143,7 @@ DSA_SIG_get0(const DSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps)
         if (ps != NULL)
                 *ps = sig->s;
 }
+LCRYPTO_ALIAS(DSA_SIG_get0);
 
 int
 DSA_SIG_set0(DSA_SIG *sig, BIGNUM *r, BIGNUM *s)
@@ -155,6 +158,7 @@ DSA_SIG_set0(DSA_SIG *sig, BIGNUM *r, BIGNUM *s)
 
         return 1;
 }
+LCRYPTO_ALIAS(DSA_SIG_set0);
 
 /* Override the default free and new methods */
 static int
@@ -243,12 +247,14 @@ d2i_DSAPrivateKey(DSA **a, const unsigned char **in, long len)
         return (DSA *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
             &DSAPrivateKey_it);
 }
+LCRYPTO_ALIAS(d2i_DSAPrivateKey);
 
 int
 i2d_DSAPrivateKey(const DSA *a, unsigned char **out)
 {
         return ASN1_item_i2d((ASN1_VALUE *)a, out, &DSAPrivateKey_it);
 }
+LCRYPTO_ALIAS(i2d_DSAPrivateKey);
 
 static const ASN1_AUX DSAparams_aux = {
         .app_data = NULL,
@@ -299,36 +305,42 @@ d2i_DSAparams(DSA **a, const unsigned char **in, long len)
         return (DSA *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
             &DSAparams_it);
 }
+LCRYPTO_ALIAS(d2i_DSAparams);
 
 int
 i2d_DSAparams(const DSA *a, unsigned char **out)
 {
         return ASN1_item_i2d((ASN1_VALUE *)a, out, &DSAparams_it);
 }
+LCRYPTO_ALIAS(i2d_DSAparams);
 
 DSA *
 d2i_DSAparams_bio(BIO *bp, DSA **a)
 {
         return ASN1_item_d2i_bio(&DSAparams_it, bp, a);
 }
+LCRYPTO_ALIAS(d2i_DSAparams_bio);
 
 int
 i2d_DSAparams_bio(BIO *bp, DSA *a)
 {
         return ASN1_item_i2d_bio(&DSAparams_it, bp, a);
 }
+LCRYPTO_ALIAS(i2d_DSAparams_bio);
 
 DSA *
 d2i_DSAparams_fp(FILE *fp, DSA **a)
 {
         return ASN1_item_d2i_fp(&DSAparams_it, fp, a);
 }
+LCRYPTO_ALIAS(d2i_DSAparams_fp);
 
 int
 i2d_DSAparams_fp(FILE *fp, DSA *a)
 {
         return ASN1_item_i2d_fp(&DSAparams_it, fp, a);
 }
+LCRYPTO_ALIAS(i2d_DSAparams_fp);
 
 static const ASN1_AUX DSAPublicKey_aux = {
         .app_data = NULL,
@@ -385,18 +397,21 @@ d2i_DSAPublicKey(DSA **a, const unsigned char **in, long len)
         return (DSA *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
             &DSAPublicKey_it);
 }
+LCRYPTO_ALIAS(d2i_DSAPublicKey);
 
 int
 i2d_DSAPublicKey(const DSA *a, unsigned char **out)
 {
         return ASN1_item_i2d((ASN1_VALUE *)a, out, &DSAPublicKey_it);
 }
+LCRYPTO_ALIAS(i2d_DSAPublicKey);
 
 DSA *
 DSAparams_dup(DSA *dsa)
 {
         return ASN1_item_dup(&DSAparams_it, dsa);
 }
+LCRYPTO_ALIAS(DSAparams_dup);
 
 int
 DSA_sign(int type, const unsigned char *dgst, int dlen, unsigned char *sig,
@@ -422,6 +437,7 @@ DSA_sign(int type, const unsigned char *dgst, int dlen, unsigned char *sig,
 
         return ret;
 }
+LCRYPTO_ALIAS(DSA_sign);
 
 /*
  * data has already been hashed (probably with SHA or SHA-1).
@@ -457,3 +473,4 @@ DSA_verify(int type, const unsigned char *dgst, int dgst_len,
 
         return ret;
 }
+LCRYPTO_ALIAS(DSA_verify);
diff --git a/src/lib/libcrypto/dsa/dsa_err.c b/src/lib/libcrypto/dsa/dsa_err.c
index 8f105a8759..6934fe14f0 100644
--- a/src/lib/libcrypto/dsa/dsa_err.c
+++ b/src/lib/libcrypto/dsa/dsa_err.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: dsa_err.c,v 1.18 2023/03/04 20:47:04 tb Exp $ */
+/* $OpenBSD: dsa_err.c,v 1.19 2023/07/08 14:28:15 beck Exp $ */
 /* ====================================================================
  * Copyright (c) 1999-2011 The OpenSSL Project.  All rights reserved.
  *
@@ -101,3 +101,4 @@ void ERR_load_DSA_strings(void)
                 }
 #endif
         }
+LCRYPTO_ALIAS(ERR_load_DSA_strings);
diff --git a/src/lib/libcrypto/dsa/dsa_gen.c b/src/lib/libcrypto/dsa/dsa_gen.c
index 4a16278b5a..490c7e51bb 100644
--- a/src/lib/libcrypto/dsa/dsa_gen.c
+++ b/src/lib/libcrypto/dsa/dsa_gen.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: dsa_gen.c,v 1.29 2023/04/13 14:58:27 tb Exp $ */
+/* $OpenBSD: dsa_gen.c,v 1.30 2023/07/08 14:28:15 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -94,6 +94,7 @@ DSA_generate_parameters_ex(DSA *ret, int bits, const unsigned char *seed_in,
                     seed_len, NULL, counter_ret, h_ret, cb);
         }
 }
+LCRYPTO_ALIAS(DSA_generate_parameters_ex);
 
 int
 dsa_builtin_paramgen(DSA *ret, size_t bits, size_t qbits, const EVP_MD *evpmd,
@@ -375,5 +376,6 @@ DSA_generate_parameters(int bits, unsigned char *seed_in, int seed_len,
         DSA_free(ret);
         return NULL;
 }
+LCRYPTO_ALIAS(DSA_generate_parameters);
 
 #endif
diff --git a/src/lib/libcrypto/dsa/dsa_key.c b/src/lib/libcrypto/dsa/dsa_key.c
index 890f991df9..c378707e36 100644
--- a/src/lib/libcrypto/dsa/dsa_key.c
+++ b/src/lib/libcrypto/dsa/dsa_key.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: dsa_key.c,v 1.33 2023/01/11 04:35:26 jsing Exp $ */
+/* $OpenBSD: dsa_key.c,v 1.34 2023/07/08 14:28:15 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -78,6 +78,7 @@ DSA_generate_key(DSA *dsa)
                 return dsa->meth->dsa_keygen(dsa);
         return dsa_builtin_keygen(dsa);
 }
+LCRYPTO_ALIAS(DSA_generate_key);
 
 static int
 dsa_builtin_keygen(DSA *dsa)
diff --git a/src/lib/libcrypto/dsa/dsa_lib.c b/src/lib/libcrypto/dsa/dsa_lib.c
index 6986f9ad6b..46a7dbcfbe 100644
--- a/src/lib/libcrypto/dsa/dsa_lib.c
+++ b/src/lib/libcrypto/dsa/dsa_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: dsa_lib.c,v 1.42 2023/03/11 15:29:03 tb Exp $ */
+/* $OpenBSD: dsa_lib.c,v 1.43 2023/07/08 14:28:15 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -84,6 +84,7 @@ DSA_set_default_method(const DSA_METHOD *meth)
 {
         default_DSA_method = meth;
 }
+LCRYPTO_ALIAS(DSA_set_default_method);
 
 const DSA_METHOD *
 DSA_get_default_method(void)
@@ -92,12 +93,14 @@ DSA_get_default_method(void)
                 default_DSA_method = DSA_OpenSSL();
         return default_DSA_method;
 }
+LCRYPTO_ALIAS(DSA_get_default_method);
 
 DSA *
 DSA_new(void)
 {
         return DSA_new_method(NULL);
 }
+LCRYPTO_ALIAS(DSA_new);
 
 int
 DSA_set_method(DSA *dsa, const DSA_METHOD *meth)
@@ -119,6 +122,7 @@ DSA_set_method(DSA *dsa, const DSA_METHOD *meth)
                 meth->init(dsa);
         return 1;
 }
+LCRYPTO_ALIAS(DSA_set_method);
 
 DSA *
 DSA_new_method(ENGINE *engine)
@@ -179,6 +183,7 @@ DSA_new_method(ENGINE *engine)
 
         return ret;
 }
+LCRYPTO_ALIAS(DSA_new_method);
 
 void
 DSA_free(DSA *r)
@@ -209,6 +214,7 @@ DSA_free(DSA *r)
         BN_free(r->r);
         free(r);
 }
+LCRYPTO_ALIAS(DSA_free);
 
 int
 DSA_up_ref(DSA *r)
@@ -216,6 +222,7 @@ DSA_up_ref(DSA *r)
         int i = CRYPTO_add(&r->references, 1, CRYPTO_LOCK_DSA);
         return i > 1 ? 1 : 0;
 }
+LCRYPTO_ALIAS(DSA_up_ref);
 
 int
 DSA_size(const DSA *r)
@@ -231,6 +238,7 @@ DSA_size(const DSA *r)
 
         return ret;
 }
+LCRYPTO_ALIAS(DSA_size);
 
 int
 DSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
@@ -239,18 +247,21 @@ DSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
         return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_DSA, argl, argp,
             new_func, dup_func, free_func);
 }
+LCRYPTO_ALIAS(DSA_get_ex_new_index);
 
 int
 DSA_set_ex_data(DSA *d, int idx, void *arg)
 {
         return CRYPTO_set_ex_data(&d->ex_data, idx, arg);
 }
+LCRYPTO_ALIAS(DSA_set_ex_data);
 
 void *
 DSA_get_ex_data(DSA *d, int idx)
 {
         return CRYPTO_get_ex_data(&d->ex_data, idx);
 }
+LCRYPTO_ALIAS(DSA_get_ex_data);
 
 int
 DSA_security_bits(const DSA *d)
@@ -260,6 +271,7 @@ DSA_security_bits(const DSA *d)
 
         return BN_security_bits(BN_num_bits(d->p), BN_num_bits(d->q));
 }
+LCRYPTO_ALIAS(DSA_security_bits);
 
 #ifndef OPENSSL_NO_DH
 DH *
@@ -301,6 +313,7 @@ err:
         DH_free(ret);
         return NULL;
 }
+LCRYPTO_ALIAS(DSA_dup_DH);
 #endif
 
 void
@@ -313,6 +326,7 @@ DSA_get0_pqg(const DSA *d, const BIGNUM **p, const BIGNUM **q, const BIGNUM **g)
         if (g != NULL)
                 *g = d->g;
 }
+LCRYPTO_ALIAS(DSA_get0_pqg);
 
 int
 DSA_set0_pqg(DSA *d, BIGNUM *p, BIGNUM *q, BIGNUM *g)
@@ -336,6 +350,7 @@ DSA_set0_pqg(DSA *d, BIGNUM *p, BIGNUM *q, BIGNUM *g)
 
         return 1;
 }
+LCRYPTO_ALIAS(DSA_set0_pqg);
 
 void
 DSA_get0_key(const DSA *d, const BIGNUM **pub_key, const BIGNUM **priv_key)
@@ -345,6 +360,7 @@ DSA_get0_key(const DSA *d, const BIGNUM **pub_key, const BIGNUM **priv_key)
         if (priv_key != NULL)
                 *priv_key = d->priv_key;
 }
+LCRYPTO_ALIAS(DSA_get0_key);
 
 int
 DSA_set0_key(DSA *d, BIGNUM *pub_key, BIGNUM *priv_key)
@@ -363,66 +379,77 @@ DSA_set0_key(DSA *d, BIGNUM *pub_key, BIGNUM *priv_key)
 
         return 1;
 }
+LCRYPTO_ALIAS(DSA_set0_key);
 
 const BIGNUM *
 DSA_get0_p(const DSA *d)
 {
         return d->p;
 }
+LCRYPTO_ALIAS(DSA_get0_p);
 
 const BIGNUM *
 DSA_get0_q(const DSA *d)
 {
         return d->q;
 }
+LCRYPTO_ALIAS(DSA_get0_q);
 
 const BIGNUM *
 DSA_get0_g(const DSA *d)
 {
         return d->g;
 }
+LCRYPTO_ALIAS(DSA_get0_g);
 
 const BIGNUM *
 DSA_get0_pub_key(const DSA *d)
 {
         return d->pub_key;
 }
+LCRYPTO_ALIAS(DSA_get0_pub_key);
 
 const BIGNUM *
 DSA_get0_priv_key(const DSA *d)
 {
         return d->priv_key;
 }
+LCRYPTO_ALIAS(DSA_get0_priv_key);
 
 void
 DSA_clear_flags(DSA *d, int flags)
 {
         d->flags &= ~flags;
 }
+LCRYPTO_ALIAS(DSA_clear_flags);
 
 int
 DSA_test_flags(const DSA *d, int flags)
 {
         return d->flags & flags;
 }
+LCRYPTO_ALIAS(DSA_test_flags);
 
 void
 DSA_set_flags(DSA *d, int flags)
 {
         d->flags |= flags;
 }
+LCRYPTO_ALIAS(DSA_set_flags);
 
 ENGINE *
 DSA_get0_engine(DSA *d)
 {
         return d->engine;
 }
+LCRYPTO_ALIAS(DSA_get0_engine);
 
 int
 DSA_bits(const DSA *dsa)
 {
         return BN_num_bits(dsa->p);
 }
+LCRYPTO_ALIAS(DSA_bits);
 
 int
 dsa_check_key(const DSA *dsa)
diff --git a/src/lib/libcrypto/dsa/dsa_meth.c b/src/lib/libcrypto/dsa/dsa_meth.c
index 392afb84df..c84b5287e1 100644
--- a/src/lib/libcrypto/dsa/dsa_meth.c
+++ b/src/lib/libcrypto/dsa/dsa_meth.c
@@ -1,4 +1,4 @@
-/*      $OpenBSD: dsa_meth.c,v 1.6 2022/11/26 16:08:52 tb Exp $ */
+/*      $OpenBSD: dsa_meth.c,v 1.7 2023/07/08 14:28:15 beck Exp $       */
 /*
  * Copyright (c) 2018 Theo Buehler <tb@openbsd.org>
  *
@@ -38,6 +38,7 @@ DSA_meth_new(const char *name, int flags)
 
         return meth;
 }
+LCRYPTO_ALIAS(DSA_meth_new);
 
 void
 DSA_meth_free(DSA_METHOD *meth)
@@ -48,6 +49,7 @@ DSA_meth_free(DSA_METHOD *meth)
         free(meth->name);
         free(meth);
 }
+LCRYPTO_ALIAS(DSA_meth_free);
 
 DSA_METHOD *
 DSA_meth_dup(const DSA_METHOD *meth)
@@ -64,12 +66,14 @@ DSA_meth_dup(const DSA_METHOD *meth)
 
         return copy;
 }
+LCRYPTO_ALIAS(DSA_meth_dup);
 
 const char *
 DSA_meth_get0_name(const DSA_METHOD *meth)
 {
         return meth->name;
 }
+LCRYPTO_ALIAS(DSA_meth_get0_name);
 
 int
 DSA_meth_set1_name(DSA_METHOD *meth, const char *name)
@@ -86,6 +90,7 @@ DSA_meth_set1_name(DSA_METHOD *meth, const char *name)
 
         return 1;
 }
+LCRYPTO_ALIAS(DSA_meth_set1_name);
 
 int
 DSA_meth_set_sign(DSA_METHOD *meth,
@@ -94,6 +99,7 @@ DSA_meth_set_sign(DSA_METHOD *meth,
         meth->dsa_do_sign = sign;
         return 1;
 }
+LCRYPTO_ALIAS(DSA_meth_set_sign);
 
 int
 DSA_meth_set_finish(DSA_METHOD *meth, int (*finish)(DSA *))
@@ -101,3 +107,4 @@ DSA_meth_set_finish(DSA_METHOD *meth, int (*finish)(DSA *))
         meth->finish = finish;
         return 1;
 }
+LCRYPTO_ALIAS(DSA_meth_set_finish);
diff --git a/src/lib/libcrypto/dsa/dsa_ossl.c b/src/lib/libcrypto/dsa/dsa_ossl.c
index b69cf1a03f..36b2a63462 100644
--- a/src/lib/libcrypto/dsa/dsa_ossl.c
+++ b/src/lib/libcrypto/dsa/dsa_ossl.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: dsa_ossl.c,v 1.51 2023/03/27 10:25:02 tb Exp $ */
+/* $OpenBSD: dsa_ossl.c,v 1.52 2023/07/08 14:28:15 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -91,6 +91,7 @@ DSA_OpenSSL(void)
 {
         return &openssl_dsa_meth;
 }
+LCRYPTO_ALIAS(DSA_OpenSSL);
 
 /*
  * Since DSA parameters are entirely arbitrary and checking them to be
@@ -440,6 +441,7 @@ DSA_SIG_new(void)
 {
         return calloc(1, sizeof(DSA_SIG));
 }
+LCRYPTO_ALIAS(DSA_SIG_new);
 
 void
 DSA_SIG_free(DSA_SIG *sig)
@@ -451,21 +453,25 @@ DSA_SIG_free(DSA_SIG *sig)
         BN_free(sig->s);
         free(sig);
 }
+LCRYPTO_ALIAS(DSA_SIG_free);
 
 int
 DSA_sign_setup(DSA *dsa, BN_CTX *ctx_in, BIGNUM **kinvp, BIGNUM **rp)
 {
         return dsa->meth->dsa_sign_setup(dsa, ctx_in, kinvp, rp);
 }
+LCRYPTO_ALIAS(DSA_sign_setup);
 
 DSA_SIG *
 DSA_do_sign(const unsigned char *dgst, int dlen, DSA *dsa)
 {
         return dsa->meth->dsa_do_sign(dgst, dlen, dsa);
 }
+LCRYPTO_ALIAS(DSA_do_sign);
 
 int
 DSA_do_verify(const unsigned char *dgst, int dgst_len, DSA_SIG *sig, DSA *dsa)
 {
         return dsa->meth->dsa_do_verify(dgst, dgst_len, sig, dsa);
 }
+LCRYPTO_ALIAS(DSA_do_verify);
diff --git a/src/lib/libcrypto/dsa/dsa_prn.c b/src/lib/libcrypto/dsa/dsa_prn.c
index 4ed656a04a..f276d82482 100644
--- a/src/lib/libcrypto/dsa/dsa_prn.c
+++ b/src/lib/libcrypto/dsa/dsa_prn.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: dsa_prn.c,v 1.9 2022/11/19 06:33:00 tb Exp $ */
+/* $OpenBSD: dsa_prn.c,v 1.10 2023/07/08 14:28:15 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2006.
  */
@@ -77,6 +77,7 @@ DSA_print_fp(FILE *fp, const DSA *x, int off)
         BIO_free(b);
         return ret;
 }
+LCRYPTO_ALIAS(DSA_print_fp);
 
 int
 DSAparams_print_fp(FILE *fp, const DSA *x)
@@ -93,6 +94,7 @@ DSAparams_print_fp(FILE *fp, const DSA *x)
         BIO_free(b);
         return ret;
 }
+LCRYPTO_ALIAS(DSAparams_print_fp);
 
 int
 DSA_print(BIO *bp, const DSA *x, int off)
@@ -111,6 +113,7 @@ DSA_print(BIO *bp, const DSA *x, int off)
         EVP_PKEY_free(pk);
         return ret;
 }
+LCRYPTO_ALIAS(DSA_print);
 
 int
 DSAparams_print(BIO *bp, const DSA *x)
@@ -129,3 +132,4 @@ DSAparams_print(BIO *bp, const DSA *x)
         EVP_PKEY_free(pk);
         return ret;
 }
+LCRYPTO_ALIAS(DSAparams_print);
diff --git a/src/lib/libcrypto/hidden/openssl/dsa.h b/src/lib/libcrypto/hidden/openssl/dsa.h
new file mode 100644
index 0000000000..b2b0058cb9
--- /dev/null
+++ b/src/lib/libcrypto/hidden/openssl/dsa.h
@@ -0,0 +1,94 @@
+/* $OpenBSD: dsa.h,v 1.1 2023/07/08 14:28:15 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_DSA_H
+#define _LIBCRYPTO_DSA_H
+
+#ifndef _MSC_VER
+#include_next <openssl/dsa.h>
+#else
+#include "../include/openssl/dsa.h"
+#endif
+#include "crypto_namespace.h"
+
+LCRYPTO_USED(d2i_DSAparams_bio);
+LCRYPTO_USED(i2d_DSAparams_bio);
+LCRYPTO_USED(d2i_DSAparams_fp);
+LCRYPTO_USED(i2d_DSAparams_fp);
+LCRYPTO_USED(DSAparams_dup);
+LCRYPTO_USED(DSA_SIG_new);
+LCRYPTO_USED(DSA_SIG_free);
+LCRYPTO_USED(i2d_DSA_SIG);
+LCRYPTO_USED(d2i_DSA_SIG);
+LCRYPTO_USED(DSA_SIG_get0);
+LCRYPTO_USED(DSA_SIG_set0);
+LCRYPTO_USED(DSA_do_sign);
+LCRYPTO_USED(DSA_do_verify);
+LCRYPTO_USED(DSA_OpenSSL);
+LCRYPTO_USED(DSA_set_default_method);
+LCRYPTO_USED(DSA_get_default_method);
+LCRYPTO_USED(DSA_set_method);
+LCRYPTO_USED(DSA_new);
+LCRYPTO_USED(DSA_new_method);
+LCRYPTO_USED(DSA_free);
+LCRYPTO_USED(DSA_up_ref);
+LCRYPTO_USED(DSA_size);
+LCRYPTO_USED(DSA_bits);
+LCRYPTO_USED(DSA_sign_setup);
+LCRYPTO_USED(DSA_sign);
+LCRYPTO_USED(DSA_verify);
+LCRYPTO_USED(DSA_get_ex_new_index);
+LCRYPTO_USED(DSA_set_ex_data);
+LCRYPTO_USED(DSA_get_ex_data);
+LCRYPTO_USED(DSA_security_bits);
+LCRYPTO_USED(d2i_DSAPublicKey);
+LCRYPTO_USED(i2d_DSAPublicKey);
+LCRYPTO_USED(d2i_DSAPrivateKey);
+LCRYPTO_USED(i2d_DSAPrivateKey);
+LCRYPTO_USED(d2i_DSAparams);
+LCRYPTO_USED(i2d_DSAparams);
+LCRYPTO_USED(DSA_generate_parameters);
+LCRYPTO_USED(DSA_generate_parameters_ex);
+LCRYPTO_USED(DSA_generate_key);
+LCRYPTO_USED(DSAparams_print);
+LCRYPTO_USED(DSA_print);
+LCRYPTO_USED(DSAparams_print_fp);
+LCRYPTO_USED(DSA_print_fp);
+LCRYPTO_USED(DSA_dup_DH);
+LCRYPTO_USED(DSA_get0_pqg);
+LCRYPTO_USED(DSA_set0_pqg);
+LCRYPTO_USED(DSA_get0_key);
+LCRYPTO_USED(DSA_set0_key);
+LCRYPTO_USED(DSA_get0_p);
+LCRYPTO_USED(DSA_get0_q);
+LCRYPTO_USED(DSA_get0_g);
+LCRYPTO_USED(DSA_get0_pub_key);
+LCRYPTO_USED(DSA_get0_priv_key);
+LCRYPTO_USED(DSA_clear_flags);
+LCRYPTO_USED(DSA_test_flags);
+LCRYPTO_USED(DSA_set_flags);
+LCRYPTO_USED(DSA_get0_engine);
+LCRYPTO_USED(DSA_meth_new);
+LCRYPTO_USED(DSA_meth_free);
+LCRYPTO_USED(DSA_meth_dup);
+LCRYPTO_USED(DSA_meth_get0_name);
+LCRYPTO_USED(DSA_meth_set1_name);
+LCRYPTO_USED(DSA_meth_set_sign);
+LCRYPTO_USED(DSA_meth_set_finish);
+LCRYPTO_USED(ERR_load_DSA_strings);
+
+#endif /* _LIBCRYPTO_DSA_H */