Hide public symbols in libcrypto/x509 .c files

ok tb@

1 files changed, 53 insertions, 1 deletions

diff --git a/src/lib/libcrypto/x509/x509_vfy.c b/src/lib/libcrypto/x509/x509_vfy.c
index 11bf3d9292..09c0b8105e 100644
--- a/src/lib/libcrypto/x509/x509_vfy.c
+++ b/src/lib/libcrypto/x509/x509_vfy.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_vfy.c,v 1.104 2022/11/13 18:37:32 beck Exp $ */
+/* $OpenBSD: x509_vfy.c,v 1.105 2022/11/14 17:48:50 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -668,6 +668,7 @@ X509_verify_cert(X509_STORE_CTX *ctx)
         /* if we succeed we have a chain in ctx->chain */
         return (chain_count > 0 && ctx->chain != NULL);
 }
+LCRYPTO_ALIAS(X509_verify_cert)
 
 /* Given a STACK_OF(X509) find the issuer of cert (if any)
  */
@@ -2062,6 +2063,7 @@ X509_cmp_current_time(const ASN1_TIME *ctm)
 {
         return X509_cmp_time(ctm, NULL);
 }
+LCRYPTO_ALIAS(X509_cmp_current_time)
 
 /*
  * Compare a possibly unvalidated ASN1_TIME string against a time_t
@@ -2101,6 +2103,7 @@ X509_cmp_time(const ASN1_TIME *ctm, time_t *cmp_time)
 {
         return X509_cmp_time_internal(ctm, cmp_time, 0);
 }
+LCRYPTO_ALIAS(X509_cmp_time)
 
 
 ASN1_TIME *
@@ -2108,12 +2111,14 @@ X509_gmtime_adj(ASN1_TIME *s, long adj)
 {
         return X509_time_adj(s, adj, NULL);
 }
+LCRYPTO_ALIAS(X509_gmtime_adj)
 
 ASN1_TIME *
 X509_time_adj(ASN1_TIME *s, long offset_sec, time_t *in_time)
 {
         return X509_time_adj_ex(s, 0, offset_sec, in_time);
 }
+LCRYPTO_ALIAS(X509_time_adj)
 
 ASN1_TIME *
 X509_time_adj_ex(ASN1_TIME *s, int offset_day, long offset_sec, time_t *in_time)
@@ -2126,6 +2131,7 @@ X509_time_adj_ex(ASN1_TIME *s, int offset_day, long offset_sec, time_t *in_time)
 
         return ASN1_TIME_adj(s, t, offset_day, offset_sec);
 }
+LCRYPTO_ALIAS(X509_time_adj_ex)
 
 int
 X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK_OF(X509) *chain)
@@ -2165,6 +2171,7 @@ X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK_OF(X509) *chain)
                         return 0;
         return 1;
 }
+LCRYPTO_ALIAS(X509_get_pubkey_parameters)
 
 int
 X509_STORE_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
@@ -2175,66 +2182,77 @@ X509_STORE_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
         return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509_STORE_CTX,
             argl, argp, new_func, dup_func, free_func);
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get_ex_new_index)
 
 int
 X509_STORE_CTX_set_ex_data(X509_STORE_CTX *ctx, int idx, void *data)
 {
         return CRYPTO_set_ex_data(&ctx->ex_data, idx, data);
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_ex_data)
 
 void *
 X509_STORE_CTX_get_ex_data(X509_STORE_CTX *ctx, int idx)
 {
         return CRYPTO_get_ex_data(&ctx->ex_data, idx);
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get_ex_data)
 
 int
 X509_STORE_CTX_get_error(X509_STORE_CTX *ctx)
 {
         return ctx->error;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get_error)
 
 void
 X509_STORE_CTX_set_error(X509_STORE_CTX *ctx, int err)
 {
         ctx->error = err;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_error)
 
 int
 X509_STORE_CTX_get_error_depth(X509_STORE_CTX *ctx)
 {
         return ctx->error_depth;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get_error_depth)
 
 void
 X509_STORE_CTX_set_error_depth(X509_STORE_CTX *ctx, int depth)
 {
         ctx->error_depth = depth;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_error_depth)
 
 X509 *
 X509_STORE_CTX_get_current_cert(X509_STORE_CTX *ctx)
 {
         return ctx->current_cert;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get_current_cert)
 
 void
 X509_STORE_CTX_set_current_cert(X509_STORE_CTX *ctx, X509 *x)
 {
         ctx->current_cert = x;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_current_cert)
 
 STACK_OF(X509) *
 X509_STORE_CTX_get_chain(X509_STORE_CTX *ctx)
 {
         return ctx->chain;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get_chain)
 
 STACK_OF(X509) *
 X509_STORE_CTX_get0_chain(X509_STORE_CTX *xs)
 {
         return xs->chain;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_chain)
 
 STACK_OF(X509) *
 X509_STORE_CTX_get1_chain(X509_STORE_CTX *ctx)
@@ -2251,60 +2269,70 @@ X509_STORE_CTX_get1_chain(X509_STORE_CTX *ctx)
         }
         return chain;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get1_chain)
 
 X509 *
 X509_STORE_CTX_get0_current_issuer(X509_STORE_CTX *ctx)
 {
         return ctx->current_issuer;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_current_issuer)
 
 X509_CRL *
 X509_STORE_CTX_get0_current_crl(X509_STORE_CTX *ctx)
 {
         return ctx->current_crl;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_current_crl)
 
 X509_STORE_CTX *
 X509_STORE_CTX_get0_parent_ctx(X509_STORE_CTX *ctx)
 {
         return ctx->parent;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_parent_ctx)
 
 X509_STORE *
 X509_STORE_CTX_get0_store(X509_STORE_CTX *xs)
 {
         return xs->store;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_store)
 
 void
 X509_STORE_CTX_set_cert(X509_STORE_CTX *ctx, X509 *x)
 {
         ctx->cert = x;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_cert)
 
 void
 X509_STORE_CTX_set_chain(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
 {
         ctx->untrusted = sk;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_chain)
 
 void
 X509_STORE_CTX_set0_crls(X509_STORE_CTX *ctx, STACK_OF(X509_CRL) *sk)
 {
         ctx->crls = sk;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set0_crls)
 
 int
 X509_STORE_CTX_set_purpose(X509_STORE_CTX *ctx, int purpose)
 {
         return X509_STORE_CTX_purpose_inherit(ctx, 0, purpose, 0);
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_purpose)
 
 int
 X509_STORE_CTX_set_trust(X509_STORE_CTX *ctx, int trust)
 {
         return X509_STORE_CTX_purpose_inherit(ctx, 0, 0, trust);
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_trust)
 
 /* This function is used to set the X509_STORE_CTX purpose and trust
  * values. This is intended to be used when another structure has its
@@ -2360,6 +2388,7 @@ X509_STORE_CTX_purpose_inherit(X509_STORE_CTX *ctx, int def_purpose,
                 ctx->param->trust = trust;
         return 1;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_purpose_inherit)
 
 X509_STORE_CTX *
 X509_STORE_CTX_new(void)
@@ -2373,6 +2402,7 @@ X509_STORE_CTX_new(void)
         }
         return ctx;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_new)
 
 void
 X509_STORE_CTX_free(X509_STORE_CTX *ctx)
@@ -2383,6 +2413,7 @@ X509_STORE_CTX_free(X509_STORE_CTX *ctx)
         X509_STORE_CTX_cleanup(ctx);
         free(ctx);
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_free)
 
 int
 X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, X509 *x509,
@@ -2504,6 +2535,7 @@ X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, X509 *x509,
         }
         return 1;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_init)
 
 /* Set alternative lookup method: just a STACK of trusted certificates.
  * This avoids X509_STORE nastiness where it isn't needed.
@@ -2515,12 +2547,14 @@ X509_STORE_CTX_trusted_stack(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
         ctx->other_ctx = sk;
         ctx->get_issuer = get_issuer_sk;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_trusted_stack)
 
 void
 X509_STORE_CTX_set0_trusted_stack(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
 {
         X509_STORE_CTX_trusted_stack(ctx, sk);
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set0_trusted_stack)
 
 void
 X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx)
@@ -2544,30 +2578,35 @@ X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx)
             ctx, &(ctx->ex_data));
         memset(&ctx->ex_data, 0, sizeof(CRYPTO_EX_DATA));
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_cleanup)
 
 void
 X509_STORE_CTX_set_depth(X509_STORE_CTX *ctx, int depth)
 {
         X509_VERIFY_PARAM_set_depth(ctx->param, depth);
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_depth)
 
 void
 X509_STORE_CTX_set_flags(X509_STORE_CTX *ctx, unsigned long flags)
 {
         X509_VERIFY_PARAM_set_flags(ctx->param, flags);
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_flags)
 
 void
 X509_STORE_CTX_set_time(X509_STORE_CTX *ctx, unsigned long flags, time_t t)
 {
         X509_VERIFY_PARAM_set_time(ctx->param, t);
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_time)
 
 int
 (*X509_STORE_CTX_get_verify_cb(X509_STORE_CTX *ctx))(int, X509_STORE_CTX *)
 {
         return ctx->verify_cb;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get_verify_cb)
 
 void
 X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx,
@@ -2575,36 +2614,42 @@ X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx,
 {
         ctx->verify_cb = verify_cb;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_verify_cb)
 
 int
 (*X509_STORE_CTX_get_verify(X509_STORE_CTX *ctx))(X509_STORE_CTX *)
 {
         return ctx->verify;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get_verify)
 
 void
 X509_STORE_CTX_set_verify(X509_STORE_CTX *ctx, int (*verify)(X509_STORE_CTX *))
 {
         ctx->verify = verify;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_verify)
 
 X509 *
 X509_STORE_CTX_get0_cert(X509_STORE_CTX *ctx)
 {
         return ctx->cert;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_cert)
 
 STACK_OF(X509) *
 X509_STORE_CTX_get0_untrusted(X509_STORE_CTX *ctx)
 {
         return ctx->untrusted;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_untrusted)
 
 void
 X509_STORE_CTX_set0_untrusted(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
 {
         ctx->untrusted = sk;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set0_untrusted)
 
 void
 X509_STORE_CTX_set0_verified_chain(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
@@ -2612,24 +2657,28 @@ X509_STORE_CTX_set0_verified_chain(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
         sk_X509_pop_free(ctx->chain, X509_free);
         ctx->chain = sk;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set0_verified_chain)
 
 X509_POLICY_TREE *
 X509_STORE_CTX_get0_policy_tree(X509_STORE_CTX *ctx)
 {
         return ctx->tree;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_policy_tree)
 
 int
 X509_STORE_CTX_get_explicit_policy(X509_STORE_CTX *ctx)
 {
         return ctx->explicit_policy;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get_explicit_policy)
 
 int
 X509_STORE_CTX_get_num_untrusted(X509_STORE_CTX *ctx)
 {
         return ctx->num_untrusted;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get_num_untrusted)
 
 int
 X509_STORE_CTX_set_default(X509_STORE_CTX *ctx, const char *name)
@@ -2640,12 +2689,14 @@ X509_STORE_CTX_set_default(X509_STORE_CTX *ctx, const char *name)
                 return 0;
         return X509_VERIFY_PARAM_inherit(ctx->param, param);
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_default)
 
 X509_VERIFY_PARAM *
 X509_STORE_CTX_get0_param(X509_STORE_CTX *ctx)
 {
         return ctx->param;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_param)
 
 void
 X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param)
@@ -2654,6 +2705,7 @@ X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param)
                 X509_VERIFY_PARAM_free(ctx->param);
         ctx->param = param;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set0_param)
 
 /*
  * Check if |bits| are adequate for |security level|.