1 files changed, 35 insertions, 1 deletions

diff --git a/src/lib/libcrypto/asn1/x_crl.c b/src/lib/libcrypto/asn1/x_crl.c
index f637bddd36..74e07da3b5 100644
--- a/src/lib/libcrypto/asn1/x_crl.c
+++ b/src/lib/libcrypto/asn1/x_crl.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x_crl.c,v 1.39 2022/12/26 16:00:36 tb Exp $ */
+/* $OpenBSD: x_crl.c,v 1.40 2023/07/05 21:23:37 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -442,30 +442,35 @@ d2i_X509_REVOKED(X509_REVOKED **a, const unsigned char **in, long len)
         return (X509_REVOKED *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
             &X509_REVOKED_it);
 }
+LCRYPTO_ALIAS(d2i_X509_REVOKED);
 
 int
 i2d_X509_REVOKED(X509_REVOKED *a, unsigned char **out)
 {
         return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_REVOKED_it);
 }
+LCRYPTO_ALIAS(i2d_X509_REVOKED);
 
 X509_REVOKED *
 X509_REVOKED_new(void)
 {
         return (X509_REVOKED *)ASN1_item_new(&X509_REVOKED_it);
 }
+LCRYPTO_ALIAS(X509_REVOKED_new);
 
 void
 X509_REVOKED_free(X509_REVOKED *a)
 {
         ASN1_item_free((ASN1_VALUE *)a, &X509_REVOKED_it);
 }
+LCRYPTO_ALIAS(X509_REVOKED_free);
 
 X509_REVOKED *
 X509_REVOKED_dup(X509_REVOKED *a)
 {
         return ASN1_item_dup(&X509_REVOKED_it, a);
 }
+LCRYPTO_ALIAS(X509_REVOKED_dup);
 
 X509_CRL_INFO *
 d2i_X509_CRL_INFO(X509_CRL_INFO **a, const unsigned char **in, long len)
@@ -473,24 +478,28 @@ d2i_X509_CRL_INFO(X509_CRL_INFO **a, const unsigned char **in, long len)
         return (X509_CRL_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
             &X509_CRL_INFO_it);
 }
+LCRYPTO_ALIAS(d2i_X509_CRL_INFO);
 
 int
 i2d_X509_CRL_INFO(X509_CRL_INFO *a, unsigned char **out)
 {
         return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_CRL_INFO_it);
 }
+LCRYPTO_ALIAS(i2d_X509_CRL_INFO);
 
 X509_CRL_INFO *
 X509_CRL_INFO_new(void)
 {
         return (X509_CRL_INFO *)ASN1_item_new(&X509_CRL_INFO_it);
 }
+LCRYPTO_ALIAS(X509_CRL_INFO_new);
 
 void
 X509_CRL_INFO_free(X509_CRL_INFO *a)
 {
         ASN1_item_free((ASN1_VALUE *)a, &X509_CRL_INFO_it);
 }
+LCRYPTO_ALIAS(X509_CRL_INFO_free);
 
 X509_CRL *
 d2i_X509_CRL(X509_CRL **a, const unsigned char **in, long len)
@@ -498,30 +507,35 @@ d2i_X509_CRL(X509_CRL **a, const unsigned char **in, long len)
         return (X509_CRL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
             &X509_CRL_it);
 }
+LCRYPTO_ALIAS(d2i_X509_CRL);
 
 int
 i2d_X509_CRL(X509_CRL *a, unsigned char **out)
 {
         return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_CRL_it);
 }
+LCRYPTO_ALIAS(i2d_X509_CRL);
 
 X509_CRL *
 X509_CRL_new(void)
 {
         return (X509_CRL *)ASN1_item_new(&X509_CRL_it);
 }
+LCRYPTO_ALIAS(X509_CRL_new);
 
 void
 X509_CRL_free(X509_CRL *a)
 {
         ASN1_item_free((ASN1_VALUE *)a, &X509_CRL_it);
 }
+LCRYPTO_ALIAS(X509_CRL_free);
 
 X509_CRL *
 X509_CRL_dup(X509_CRL *x)
 {
         return ASN1_item_dup(&X509_CRL_it, x);
 }
+LCRYPTO_ALIAS(X509_CRL_dup);
 
 static int
 X509_REVOKED_cmp(const X509_REVOKED * const *a, const X509_REVOKED * const *b)
@@ -544,6 +558,7 @@ X509_CRL_add0_revoked(X509_CRL *crl, X509_REVOKED *rev)
         inf->enc.modified = 1;
         return 1;
 }
+LCRYPTO_ALIAS(X509_CRL_add0_revoked);
 
 int
 X509_CRL_verify(X509_CRL *crl, EVP_PKEY *r)
@@ -552,6 +567,7 @@ X509_CRL_verify(X509_CRL *crl, EVP_PKEY *r)
                 return crl->meth->crl_verify(crl, r);
         return 0;
 }
+LCRYPTO_ALIAS(X509_CRL_verify);
 
 int
 X509_CRL_get0_by_serial(X509_CRL *crl, X509_REVOKED **ret,
@@ -561,6 +577,7 @@ X509_CRL_get0_by_serial(X509_CRL *crl, X509_REVOKED **ret,
                 return crl->meth->crl_lookup(crl, ret, serial, NULL);
         return 0;
 }
+LCRYPTO_ALIAS(X509_CRL_get0_by_serial);
 
 int
 X509_CRL_get0_by_cert(X509_CRL *crl, X509_REVOKED **ret, X509 *x)
@@ -570,6 +587,7 @@ X509_CRL_get0_by_cert(X509_CRL *crl, X509_REVOKED **ret, X509 *x)
                     X509_get_serialNumber(x), X509_get_issuer_name(x));
         return 0;
 }
+LCRYPTO_ALIAS(X509_CRL_get0_by_cert);
 
 static int
 def_crl_verify(X509_CRL *crl, EVP_PKEY *r)
@@ -648,6 +666,7 @@ X509_CRL_set_default_method(const X509_CRL_METHOD *meth)
         else
                 default_crl_method = meth;
 }
+LCRYPTO_ALIAS(X509_CRL_set_default_method);
 
 X509_CRL_METHOD *
 X509_CRL_METHOD_new(int (*crl_init)(X509_CRL *crl),
@@ -669,6 +688,7 @@ X509_CRL_METHOD_new(int (*crl_init)(X509_CRL *crl),
 
         return m;
 }
+LCRYPTO_ALIAS(X509_CRL_METHOD_new);
 
 void
 X509_CRL_METHOD_free(X509_CRL_METHOD *m)
@@ -679,72 +699,84 @@ X509_CRL_METHOD_free(X509_CRL_METHOD *m)
                 return;
         free(m);
 }
+LCRYPTO_ALIAS(X509_CRL_METHOD_free);
 
 void
 X509_CRL_set_meth_data(X509_CRL *crl, void *dat)
 {
         crl->meth_data = dat;
 }
+LCRYPTO_ALIAS(X509_CRL_set_meth_data);
 
 void *
 X509_CRL_get_meth_data(X509_CRL *crl)
 {
         return crl->meth_data;
 }
+LCRYPTO_ALIAS(X509_CRL_get_meth_data);
 
 int
 X509_CRL_get_signature_nid(const X509_CRL *crl)
 {
         return OBJ_obj2nid(crl->sig_alg->algorithm);
 }
+LCRYPTO_ALIAS(X509_CRL_get_signature_nid);
 
 const STACK_OF(X509_EXTENSION) *
 X509_CRL_get0_extensions(const X509_CRL *crl)
 {
         return crl->crl->extensions;
 }
+LCRYPTO_ALIAS(X509_CRL_get0_extensions);
 
 long
 X509_CRL_get_version(const X509_CRL *crl)
 {
         return ASN1_INTEGER_get(crl->crl->version);
 }
+LCRYPTO_ALIAS(X509_CRL_get_version);
 
 const ASN1_TIME *
 X509_CRL_get0_lastUpdate(const X509_CRL *crl)
 {
         return crl->crl->lastUpdate;
 }
+LCRYPTO_ALIAS(X509_CRL_get0_lastUpdate);
 
 ASN1_TIME *
 X509_CRL_get_lastUpdate(X509_CRL *crl)
 {
         return crl->crl->lastUpdate;
 }
+LCRYPTO_ALIAS(X509_CRL_get_lastUpdate);
 
 const ASN1_TIME *
 X509_CRL_get0_nextUpdate(const X509_CRL *crl)
 {
         return crl->crl->nextUpdate;
 }
+LCRYPTO_ALIAS(X509_CRL_get0_nextUpdate);
 
 ASN1_TIME *
 X509_CRL_get_nextUpdate(X509_CRL *crl)
 {
         return crl->crl->nextUpdate;
 }
+LCRYPTO_ALIAS(X509_CRL_get_nextUpdate);
 
 X509_NAME *
 X509_CRL_get_issuer(const X509_CRL *crl)
 {
         return crl->crl->issuer;
 }
+LCRYPTO_ALIAS(X509_CRL_get_issuer);
 
 STACK_OF(X509_REVOKED) *
 X509_CRL_get_REVOKED(X509_CRL *crl)
 {
         return crl->crl->revoked;
 }
+LCRYPTO_ALIAS(X509_CRL_get_REVOKED);
 
 void
 X509_CRL_get0_signature(const X509_CRL *crl, const ASN1_BIT_STRING **psig,
@@ -755,9 +787,11 @@ X509_CRL_get0_signature(const X509_CRL *crl, const ASN1_BIT_STRING **psig,
         if (palg != NULL)
                 *palg = crl->sig_alg;
 }
+LCRYPTO_ALIAS(X509_CRL_get0_signature);
 
 const X509_ALGOR *
 X509_CRL_get0_tbs_sigalg(const X509_CRL *crl)
 {
         return crl->crl->sig_alg;
 }
+LCRYPTO_ALIAS(X509_CRL_get0_tbs_sigalg);