From cedac4184d41cfc52c913dbb6c371cdbae931594 Mon Sep 17 00:00:00 2001 From: tb Date: Thu, 16 Feb 2023 08:38:17 +0000 Subject: [PATCH] libressl *_namespace.h: adjust *_ALIAS() to require a semicolon LCRYPTO_ALIAS() and LSSL_ALIAS() contained a trailing semicolon. This does not conform to style(9), breaks editors and ctags and (most importantly) my workflow. Fix this by neutering them with asm("") so that -Wpedantic doesn't complain. There's precedent in libc's namespace.h fix suggested by & ok jsing --- lib/libcrypto/hidden/crypto_namespace.h | 6 +- lib/libcrypto/hmac/hmac.c | 20 ++-- lib/libcrypto/pkcs12/p12_add.c | 18 ++-- lib/libcrypto/pkcs12/p12_asn.c | 34 +++---- lib/libcrypto/pkcs12/p12_attr.c | 18 ++-- lib/libcrypto/pkcs12/p12_crpt.c | 6 +- lib/libcrypto/pkcs12/p12_crt.c | 12 +-- lib/libcrypto/pkcs12/p12_decr.c | 8 +- lib/libcrypto/pkcs12/p12_init.c | 4 +- lib/libcrypto/pkcs12/p12_key.c | 6 +- lib/libcrypto/pkcs12/p12_kiss.c | 4 +- lib/libcrypto/pkcs12/p12_mutl.c | 14 +-- lib/libcrypto/pkcs12/p12_npas.c | 4 +- lib/libcrypto/pkcs12/p12_p8d.c | 4 +- lib/libcrypto/pkcs12/p12_p8e.c | 4 +- lib/libcrypto/pkcs12/p12_sbag.c | 32 +++---- lib/libcrypto/pkcs12/p12_utl.c | 14 +-- lib/libcrypto/pkcs12/pk12err.c | 4 +- lib/libcrypto/pkcs7/bio_pk7.c | 4 +- lib/libcrypto/pkcs7/pk7_asn1.c | 98 ++++++++++---------- lib/libcrypto/pkcs7/pk7_attr.c | 14 +-- lib/libcrypto/pkcs7/pk7_doit.c | 30 +++--- lib/libcrypto/pkcs7/pk7_lib.c | 42 ++++----- lib/libcrypto/pkcs7/pk7_mime.c | 10 +- lib/libcrypto/pkcs7/pk7_smime.c | 16 ++-- lib/libcrypto/pkcs7/pkcs7err.c | 4 +- lib/libcrypto/stack/stack.c | 44 ++++----- lib/libcrypto/ui/ui_err.c | 4 +- lib/libcrypto/ui/ui_lib.c | 100 ++++++++++---------- lib/libcrypto/ui/ui_null.c | 4 +- lib/libcrypto/ui/ui_openssl.c | 4 +- lib/libcrypto/ui/ui_util.c | 6 +- lib/libcrypto/x509/by_dir.c | 4 +- lib/libcrypto/x509/by_file.c | 10 +- lib/libcrypto/x509/by_mem.c | 4 +- lib/libcrypto/x509/pcy_lib.c | 20 ++-- lib/libcrypto/x509/pcy_tree.c | 6 +- lib/libcrypto/x509/x509_addr.c | 56 +++++------ lib/libcrypto/x509/x509_akeya.c | 10 +- lib/libcrypto/x509/x509_alt.c | 16 ++-- lib/libcrypto/x509/x509_asid.c | 50 +++++----- lib/libcrypto/x509/x509_att.c | 40 ++++---- lib/libcrypto/x509/x509_bcons.c | 10 +- lib/libcrypto/x509/x509_bitst.c | 6 +- lib/libcrypto/x509/x509_cmp.c | 52 +++++------ lib/libcrypto/x509/x509_conf.c | 40 ++++---- lib/libcrypto/x509/x509_cpols.c | 44 ++++----- lib/libcrypto/x509/x509_crld.c | 36 ++++---- lib/libcrypto/x509/x509_d2.c | 8 +- lib/libcrypto/x509/x509_def.c | 14 +-- lib/libcrypto/x509/x509_enum.c | 4 +- lib/libcrypto/x509/x509_err.c | 6 +- lib/libcrypto/x509/x509_ext.c | 56 +++++------ lib/libcrypto/x509/x509_extku.c | 10 +- lib/libcrypto/x509/x509_genn.c | 48 +++++----- lib/libcrypto/x509/x509_info.c | 20 ++-- lib/libcrypto/x509/x509_lib.c | 22 ++--- lib/libcrypto/x509/x509_lu.c | 86 ++++++++--------- lib/libcrypto/x509/x509_ncons.c | 12 +-- lib/libcrypto/x509/x509_obj.c | 4 +- lib/libcrypto/x509/x509_pcia.c | 18 ++-- lib/libcrypto/x509/x509_pcons.c | 6 +- lib/libcrypto/x509/x509_pku.c | 10 +- lib/libcrypto/x509/x509_pmaps.c | 6 +- lib/libcrypto/x509/x509_prn.c | 10 +- lib/libcrypto/x509/x509_purp.c | 40 ++++---- lib/libcrypto/x509/x509_r2x.c | 4 +- lib/libcrypto/x509/x509_req.c | 42 ++++----- lib/libcrypto/x509/x509_set.c | 38 ++++---- lib/libcrypto/x509/x509_skey.c | 6 +- lib/libcrypto/x509/x509_sxnet.c | 30 +++--- lib/libcrypto/x509/x509_trs.c | 24 ++--- lib/libcrypto/x509/x509_txt.c | 4 +- lib/libcrypto/x509/x509_utl.c | 54 +++++------ lib/libcrypto/x509/x509_v3.c | 32 +++---- lib/libcrypto/x509/x509_vfy.c | 112 +++++++++++----------- lib/libcrypto/x509/x509_vpm.c | 62 ++++++------- lib/libcrypto/x509/x509cset.c | 30 +++--- lib/libcrypto/x509/x509name.c | 40 ++++---- lib/libcrypto/x509/x509rset.c | 12 +-- lib/libcrypto/x509/x509spki.c | 10 +- lib/libcrypto/x509/x509type.c | 4 +- lib/libcrypto/x509/x_all.c | 118 ++++++++++++------------ lib/libssl/bio_ssl.c | 8 +- lib/libssl/hidden/ssl_namespace.h | 6 +- 85 files changed, 1006 insertions(+), 1006 deletions(-) diff --git a/lib/libcrypto/hidden/crypto_namespace.h b/lib/libcrypto/hidden/crypto_namespace.h index 6ceef26e2d8..5bf9b4d4da7 100644 --- a/lib/libcrypto/hidden/crypto_namespace.h +++ b/lib/libcrypto/hidden/crypto_namespace.h @@ -1,4 +1,4 @@ -/* $OpenBSD: crypto_namespace.h,v 1.1 2022/11/11 11:25:18 beck Exp $ */ +/* $OpenBSD: crypto_namespace.h,v 1.2 2023/02/16 08:38:17 tb Exp $ */ /* * Copyright (c) 2016 Philip Guenther * @@ -30,7 +30,7 @@ # define LCRYPTO_USED(x) __attribute__((visibility("hidden"))) \ typeof(x) x asm("_lcry_"#x) # define LCRYPTO_ALIAS1(pre,x) asm(".global "#pre#x"; "#pre#x" = _lcry_"#x) -# define LCRYPTO_ALIAS(x) LCRYPTO_ALIAS1(,x); LCRYPTO_ALIAS1(_libre_,x); +# define LCRYPTO_ALIAS(x) LCRYPTO_ALIAS1(,x); LCRYPTO_ALIAS1(_libre_,x) #else # define LCRYPTO_USED(x) typeof(x) x asm("_libre_"#x) #endif @@ -38,7 +38,7 @@ # define LCRYPTO_UNUSED(x) # define LCRYPTO_USED(x) # define LCRYPTO_ALIAS1(pre,x) -# define LCRYPTO_ALIAS(x) +# define LCRYPTO_ALIAS(x) asm("") #endif #endif /* _LIBCRYPTO_CRYPTO_NAMESPACE_H_ */ diff --git a/lib/libcrypto/hmac/hmac.c b/lib/libcrypto/hmac/hmac.c index 047b67b9ea2..ea3a1b4a45f 100644 --- a/lib/libcrypto/hmac/hmac.c +++ b/lib/libcrypto/hmac/hmac.c @@ -1,4 +1,4 @@ -/* $OpenBSD: hmac.c,v 1.30 2022/11/26 16:08:53 tb Exp $ */ +/* $OpenBSD: hmac.c,v 1.31 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -134,7 +134,7 @@ HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len, const EVP_MD *md, err: return 0; } -LCRYPTO_ALIAS(HMAC_Init_ex) +LCRYPTO_ALIAS(HMAC_Init_ex); int HMAC_Init(HMAC_CTX *ctx, const void *key, int len, const EVP_MD *md) @@ -152,7 +152,7 @@ HMAC_Update(HMAC_CTX *ctx, const unsigned char *data, size_t len) return EVP_DigestUpdate(&ctx->md_ctx, data, len); } -LCRYPTO_ALIAS(HMAC_Update) +LCRYPTO_ALIAS(HMAC_Update); int HMAC_Final(HMAC_CTX *ctx, unsigned char *md, unsigned int *len) @@ -175,7 +175,7 @@ HMAC_Final(HMAC_CTX *ctx, unsigned char *md, unsigned int *len) err: return 0; } -LCRYPTO_ALIAS(HMAC_Final) +LCRYPTO_ALIAS(HMAC_Final); HMAC_CTX * HMAC_CTX_new(void) @@ -189,7 +189,7 @@ HMAC_CTX_new(void) return ctx; } -LCRYPTO_ALIAS(HMAC_CTX_new) +LCRYPTO_ALIAS(HMAC_CTX_new); void HMAC_CTX_free(HMAC_CTX *ctx) @@ -201,7 +201,7 @@ HMAC_CTX_free(HMAC_CTX *ctx) free(ctx); } -LCRYPTO_ALIAS(HMAC_CTX_free) +LCRYPTO_ALIAS(HMAC_CTX_free); int HMAC_CTX_reset(HMAC_CTX *ctx) @@ -236,7 +236,7 @@ HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx) err: return 0; } -LCRYPTO_ALIAS(HMAC_CTX_copy) +LCRYPTO_ALIAS(HMAC_CTX_copy); void HMAC_CTX_cleanup(HMAC_CTX *ctx) @@ -254,14 +254,14 @@ HMAC_CTX_set_flags(HMAC_CTX *ctx, unsigned long flags) EVP_MD_CTX_set_flags(&ctx->o_ctx, flags); EVP_MD_CTX_set_flags(&ctx->md_ctx, flags); } -LCRYPTO_ALIAS(HMAC_CTX_set_flags) +LCRYPTO_ALIAS(HMAC_CTX_set_flags); const EVP_MD * HMAC_CTX_get_md(const HMAC_CTX *ctx) { return ctx->md; } -LCRYPTO_ALIAS(HMAC_CTX_get_md) +LCRYPTO_ALIAS(HMAC_CTX_get_md); unsigned char * HMAC(const EVP_MD *evp_md, const void *key, int key_len, const unsigned char *d, @@ -290,4 +290,4 @@ err: HMAC_CTX_cleanup(&c); return NULL; } -LCRYPTO_ALIAS(HMAC) +LCRYPTO_ALIAS(HMAC); diff --git a/lib/libcrypto/pkcs12/p12_add.c b/lib/libcrypto/pkcs12/p12_add.c index 66cb95b1dbf..93c7c7221e1 100644 --- a/lib/libcrypto/pkcs12/p12_add.c +++ b/lib/libcrypto/pkcs12/p12_add.c @@ -1,4 +1,4 @@ -/* $OpenBSD: p12_add.c,v 1.21 2022/11/12 13:03:28 beck Exp $ */ +/* $OpenBSD: p12_add.c,v 1.22 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -90,7 +90,7 @@ PKCS12_item_pack_safebag(void *obj, const ASN1_ITEM *it, int nid1, int nid2) safebag->type = OBJ_nid2obj(nid2); return safebag; } -LCRYPTO_ALIAS(PKCS12_item_pack_safebag) +LCRYPTO_ALIAS(PKCS12_item_pack_safebag); /* Turn a stack of SAFEBAGS into a PKCS#7 data Contentinfo */ PKCS7 * @@ -118,7 +118,7 @@ err: PKCS7_free(p7); return NULL; } -LCRYPTO_ALIAS(PKCS12_pack_p7data) +LCRYPTO_ALIAS(PKCS12_pack_p7data); /* Unpack SAFEBAGS from PKCS#7 data ContentInfo */ STACK_OF(PKCS12_SAFEBAG) * @@ -130,7 +130,7 @@ PKCS12_unpack_p7data(PKCS7 *p7) } return ASN1_item_unpack(p7->d.data, &PKCS12_SAFEBAGS_it); } -LCRYPTO_ALIAS(PKCS12_unpack_p7data) +LCRYPTO_ALIAS(PKCS12_unpack_p7data); /* Turn a stack of SAFEBAGS into a PKCS#7 encrypted data ContentInfo */ @@ -177,7 +177,7 @@ err: PKCS7_free(p7); return NULL; } -LCRYPTO_ALIAS(PKCS12_pack_p7encdata) +LCRYPTO_ALIAS(PKCS12_pack_p7encdata); STACK_OF(PKCS12_SAFEBAG) * PKCS12_unpack_p7encdata(PKCS7 *p7, const char *pass, int passlen) @@ -188,14 +188,14 @@ PKCS12_unpack_p7encdata(PKCS7 *p7, const char *pass, int passlen) &PKCS12_SAFEBAGS_it, pass, passlen, p7->d.encrypted->enc_data->enc_data, 1); } -LCRYPTO_ALIAS(PKCS12_unpack_p7encdata) +LCRYPTO_ALIAS(PKCS12_unpack_p7encdata); PKCS8_PRIV_KEY_INFO * PKCS12_decrypt_skey(const PKCS12_SAFEBAG *bag, const char *pass, int passlen) { return PKCS8_decrypt(bag->value.shkeybag, pass, passlen); } -LCRYPTO_ALIAS(PKCS12_decrypt_skey) +LCRYPTO_ALIAS(PKCS12_decrypt_skey); int PKCS12_pack_authsafes(PKCS12 *p12, STACK_OF(PKCS7) *safes) @@ -205,7 +205,7 @@ PKCS12_pack_authsafes(PKCS12 *p12, STACK_OF(PKCS7) *safes) return 1; return 0; } -LCRYPTO_ALIAS(PKCS12_pack_authsafes) +LCRYPTO_ALIAS(PKCS12_pack_authsafes); STACK_OF(PKCS7) * PKCS12_unpack_authsafes(const PKCS12 *p12) @@ -217,4 +217,4 @@ PKCS12_unpack_authsafes(const PKCS12 *p12) return ASN1_item_unpack(p12->authsafes->d.data, &PKCS12_AUTHSAFES_it); } -LCRYPTO_ALIAS(PKCS12_unpack_authsafes) +LCRYPTO_ALIAS(PKCS12_unpack_authsafes); diff --git a/lib/libcrypto/pkcs12/p12_asn.c b/lib/libcrypto/pkcs12/p12_asn.c index c45482d5f13..a9decccb5b3 100644 --- a/lib/libcrypto/pkcs12/p12_asn.c +++ b/lib/libcrypto/pkcs12/p12_asn.c @@ -1,4 +1,4 @@ -/* $OpenBSD: p12_asn.c,v 1.13 2022/11/12 13:03:28 beck Exp $ */ +/* $OpenBSD: p12_asn.c,v 1.14 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -106,28 +106,28 @@ d2i_PKCS12(PKCS12 **a, const unsigned char **in, long len) return (PKCS12 *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &PKCS12_it); } -LCRYPTO_ALIAS(d2i_PKCS12) +LCRYPTO_ALIAS(d2i_PKCS12); int i2d_PKCS12(PKCS12 *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_it); } -LCRYPTO_ALIAS(i2d_PKCS12) +LCRYPTO_ALIAS(i2d_PKCS12); PKCS12 * PKCS12_new(void) { return (PKCS12 *)ASN1_item_new(&PKCS12_it); } -LCRYPTO_ALIAS(PKCS12_new) +LCRYPTO_ALIAS(PKCS12_new); void PKCS12_free(PKCS12 *a) { ASN1_item_free((ASN1_VALUE *)a, &PKCS12_it); } -LCRYPTO_ALIAS(PKCS12_free) +LCRYPTO_ALIAS(PKCS12_free); static const ASN1_TEMPLATE PKCS12_MAC_DATA_seq_tt[] = { { @@ -170,28 +170,28 @@ d2i_PKCS12_MAC_DATA(PKCS12_MAC_DATA **a, const unsigned char **in, long len) return (PKCS12_MAC_DATA *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &PKCS12_MAC_DATA_it); } -LCRYPTO_ALIAS(d2i_PKCS12_MAC_DATA) +LCRYPTO_ALIAS(d2i_PKCS12_MAC_DATA); int i2d_PKCS12_MAC_DATA(PKCS12_MAC_DATA *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_MAC_DATA_it); } -LCRYPTO_ALIAS(i2d_PKCS12_MAC_DATA) +LCRYPTO_ALIAS(i2d_PKCS12_MAC_DATA); PKCS12_MAC_DATA * PKCS12_MAC_DATA_new(void) { return (PKCS12_MAC_DATA *)ASN1_item_new(&PKCS12_MAC_DATA_it); } -LCRYPTO_ALIAS(PKCS12_MAC_DATA_new) +LCRYPTO_ALIAS(PKCS12_MAC_DATA_new); void PKCS12_MAC_DATA_free(PKCS12_MAC_DATA *a) { ASN1_item_free((ASN1_VALUE *)a, &PKCS12_MAC_DATA_it); } -LCRYPTO_ALIAS(PKCS12_MAC_DATA_free) +LCRYPTO_ALIAS(PKCS12_MAC_DATA_free); static const ASN1_TEMPLATE bag_default_tt = { .flags = ASN1_TFLG_EXPLICIT, @@ -280,28 +280,28 @@ d2i_PKCS12_BAGS(PKCS12_BAGS **a, const unsigned char **in, long len) return (PKCS12_BAGS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &PKCS12_BAGS_it); } -LCRYPTO_ALIAS(d2i_PKCS12_BAGS) +LCRYPTO_ALIAS(d2i_PKCS12_BAGS); int i2d_PKCS12_BAGS(PKCS12_BAGS *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_BAGS_it); } -LCRYPTO_ALIAS(i2d_PKCS12_BAGS) +LCRYPTO_ALIAS(i2d_PKCS12_BAGS); PKCS12_BAGS * PKCS12_BAGS_new(void) { return (PKCS12_BAGS *)ASN1_item_new(&PKCS12_BAGS_it); } -LCRYPTO_ALIAS(PKCS12_BAGS_new) +LCRYPTO_ALIAS(PKCS12_BAGS_new); void PKCS12_BAGS_free(PKCS12_BAGS *a) { ASN1_item_free((ASN1_VALUE *)a, &PKCS12_BAGS_it); } -LCRYPTO_ALIAS(PKCS12_BAGS_free) +LCRYPTO_ALIAS(PKCS12_BAGS_free); static const ASN1_TEMPLATE safebag_default_tt = { .flags = ASN1_TFLG_EXPLICIT, @@ -429,28 +429,28 @@ d2i_PKCS12_SAFEBAG(PKCS12_SAFEBAG **a, const unsigned char **in, long len) return (PKCS12_SAFEBAG *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &PKCS12_SAFEBAG_it); } -LCRYPTO_ALIAS(d2i_PKCS12_SAFEBAG) +LCRYPTO_ALIAS(d2i_PKCS12_SAFEBAG); int i2d_PKCS12_SAFEBAG(PKCS12_SAFEBAG *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_SAFEBAG_it); } -LCRYPTO_ALIAS(i2d_PKCS12_SAFEBAG) +LCRYPTO_ALIAS(i2d_PKCS12_SAFEBAG); PKCS12_SAFEBAG * PKCS12_SAFEBAG_new(void) { return (PKCS12_SAFEBAG *)ASN1_item_new(&PKCS12_SAFEBAG_it); } -LCRYPTO_ALIAS(PKCS12_SAFEBAG_new) +LCRYPTO_ALIAS(PKCS12_SAFEBAG_new); void PKCS12_SAFEBAG_free(PKCS12_SAFEBAG *a) { ASN1_item_free((ASN1_VALUE *)a, &PKCS12_SAFEBAG_it); } -LCRYPTO_ALIAS(PKCS12_SAFEBAG_free) +LCRYPTO_ALIAS(PKCS12_SAFEBAG_free); /* SEQUENCE OF SafeBag */ static const ASN1_TEMPLATE PKCS12_SAFEBAGS_item_tt = { diff --git a/lib/libcrypto/pkcs12/p12_attr.c b/lib/libcrypto/pkcs12/p12_attr.c index e1635ea038a..d43b205a07f 100644 --- a/lib/libcrypto/pkcs12/p12_attr.c +++ b/lib/libcrypto/pkcs12/p12_attr.c @@ -1,4 +1,4 @@ -/* $OpenBSD: p12_attr.c,v 1.19 2022/11/26 16:08:53 tb Exp $ */ +/* $OpenBSD: p12_attr.c,v 1.20 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -74,7 +74,7 @@ PKCS12_add_localkeyid(PKCS12_SAFEBAG *bag, unsigned char *name, int namelen) else return 0; } -LCRYPTO_ALIAS(PKCS12_add_localkeyid) +LCRYPTO_ALIAS(PKCS12_add_localkeyid); /* Add key usage to PKCS#8 structure */ @@ -86,7 +86,7 @@ PKCS8_add_keyusage(PKCS8_PRIV_KEY_INFO *p8, int usage) return PKCS8_pkey_add1_attr_by_NID(p8, NID_key_usage, V_ASN1_BIT_STRING, &us_val, 1); } -LCRYPTO_ALIAS(PKCS8_add_keyusage) +LCRYPTO_ALIAS(PKCS8_add_keyusage); /* Add a friendlyname to a safebag */ @@ -99,7 +99,7 @@ PKCS12_add_friendlyname_asc(PKCS12_SAFEBAG *bag, const char *name, int namelen) else return 0; } -LCRYPTO_ALIAS(PKCS12_add_friendlyname_asc) +LCRYPTO_ALIAS(PKCS12_add_friendlyname_asc); int @@ -112,7 +112,7 @@ PKCS12_add_friendlyname_uni(PKCS12_SAFEBAG *bag, const unsigned char *name, else return 0; } -LCRYPTO_ALIAS(PKCS12_add_friendlyname_uni) +LCRYPTO_ALIAS(PKCS12_add_friendlyname_uni); int PKCS12_add_CSPName_asc(PKCS12_SAFEBAG *bag, const char *name, int namelen) @@ -123,7 +123,7 @@ PKCS12_add_CSPName_asc(PKCS12_SAFEBAG *bag, const char *name, int namelen) else return 0; } -LCRYPTO_ALIAS(PKCS12_add_CSPName_asc) +LCRYPTO_ALIAS(PKCS12_add_CSPName_asc); ASN1_TYPE * PKCS12_get_attr_gen(const STACK_OF(X509_ATTRIBUTE) *attrs, int attr_nid) @@ -140,7 +140,7 @@ PKCS12_get_attr_gen(const STACK_OF(X509_ATTRIBUTE) *attrs, int attr_nid) } return NULL; } -LCRYPTO_ALIAS(PKCS12_get_attr_gen) +LCRYPTO_ALIAS(PKCS12_get_attr_gen); char * PKCS12_get_friendlyname(PKCS12_SAFEBAG *bag) @@ -154,11 +154,11 @@ PKCS12_get_friendlyname(PKCS12_SAFEBAG *bag) return OPENSSL_uni2asc(atype->value.bmpstring->data, atype->value.bmpstring->length); } -LCRYPTO_ALIAS(PKCS12_get_friendlyname) +LCRYPTO_ALIAS(PKCS12_get_friendlyname); const STACK_OF(X509_ATTRIBUTE) * PKCS12_SAFEBAG_get0_attrs(const PKCS12_SAFEBAG *bag) { return bag->attrib; } -LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_attrs) +LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_attrs); diff --git a/lib/libcrypto/pkcs12/p12_crpt.c b/lib/libcrypto/pkcs12/p12_crpt.c index 63474621cb7..e7d30101c36 100644 --- a/lib/libcrypto/pkcs12/p12_crpt.c +++ b/lib/libcrypto/pkcs12/p12_crpt.c @@ -1,4 +1,4 @@ -/* $OpenBSD: p12_crpt.c,v 1.16 2022/11/12 13:03:28 beck Exp $ */ +/* $OpenBSD: p12_crpt.c,v 1.17 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -68,7 +68,7 @@ void PKCS12_PBE_add(void) { } -LCRYPTO_ALIAS(PKCS12_PBE_add) +LCRYPTO_ALIAS(PKCS12_PBE_add); int PKCS12_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen, @@ -120,4 +120,4 @@ PKCS12_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen, explicit_bzero(iv, EVP_MAX_IV_LENGTH); return ret; } -LCRYPTO_ALIAS(PKCS12_PBE_keyivgen) +LCRYPTO_ALIAS(PKCS12_PBE_keyivgen); diff --git a/lib/libcrypto/pkcs12/p12_crt.c b/lib/libcrypto/pkcs12/p12_crt.c index 8655be108ef..90a0cbe555d 100644 --- a/lib/libcrypto/pkcs12/p12_crt.c +++ b/lib/libcrypto/pkcs12/p12_crt.c @@ -1,4 +1,4 @@ -/* $OpenBSD: p12_crt.c,v 1.22 2023/01/24 09:48:57 job Exp $ */ +/* $OpenBSD: p12_crt.c,v 1.23 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project. */ @@ -184,7 +184,7 @@ err: sk_PKCS12_SAFEBAG_pop_free(bags, PKCS12_SAFEBAG_free); return NULL; } -LCRYPTO_ALIAS(PKCS12_create) +LCRYPTO_ALIAS(PKCS12_create); PKCS12_SAFEBAG * PKCS12_add_cert(STACK_OF(PKCS12_SAFEBAG) **pbags, X509 *cert) @@ -222,7 +222,7 @@ err: return NULL; } -LCRYPTO_ALIAS(PKCS12_add_cert) +LCRYPTO_ALIAS(PKCS12_add_cert); PKCS12_SAFEBAG * PKCS12_add_key(STACK_OF(PKCS12_SAFEBAG) **pbags, EVP_PKEY *key, int key_usage, @@ -263,7 +263,7 @@ err: return NULL; } -LCRYPTO_ALIAS(PKCS12_add_key) +LCRYPTO_ALIAS(PKCS12_add_key); int PKCS12_add_safe(STACK_OF(PKCS7) **psafes, STACK_OF(PKCS12_SAFEBAG) *bags, @@ -307,7 +307,7 @@ err: return 0; } -LCRYPTO_ALIAS(PKCS12_add_safe) +LCRYPTO_ALIAS(PKCS12_add_safe); static int pkcs12_add_bag(STACK_OF(PKCS12_SAFEBAG) **pbags, PKCS12_SAFEBAG *bag) @@ -354,4 +354,4 @@ PKCS12_add_safes(STACK_OF(PKCS7) *safes, int nid_p7) return p12; } -LCRYPTO_ALIAS(PKCS12_add_safes) +LCRYPTO_ALIAS(PKCS12_add_safes); diff --git a/lib/libcrypto/pkcs12/p12_decr.c b/lib/libcrypto/pkcs12/p12_decr.c index 2d3d284a53d..ea7f6a5ffa2 100644 --- a/lib/libcrypto/pkcs12/p12_decr.c +++ b/lib/libcrypto/pkcs12/p12_decr.c @@ -1,4 +1,4 @@ -/* $OpenBSD: p12_decr.c,v 1.23 2022/11/26 16:08:53 tb Exp $ */ +/* $OpenBSD: p12_decr.c,v 1.24 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -116,7 +116,7 @@ err: return out; } -LCRYPTO_ALIAS(PKCS12_pbe_crypt) +LCRYPTO_ALIAS(PKCS12_pbe_crypt); /* Decrypt an OCTET STRING and decode ASN1 structure * if zbuf set zero buffer after use. @@ -145,7 +145,7 @@ PKCS12_item_decrypt_d2i(const X509_ALGOR *algor, const ASN1_ITEM *it, free(out); return ret; } -LCRYPTO_ALIAS(PKCS12_item_decrypt_d2i) +LCRYPTO_ALIAS(PKCS12_item_decrypt_d2i); /* Encode ASN1 structure and encrypt, return OCTET STRING * if zbuf set zero encoding. @@ -184,6 +184,6 @@ err: ASN1_OCTET_STRING_free(oct); return NULL; } -LCRYPTO_ALIAS(PKCS12_item_i2d_encrypt) +LCRYPTO_ALIAS(PKCS12_item_i2d_encrypt); IMPLEMENT_PKCS12_STACK_OF(PKCS7) diff --git a/lib/libcrypto/pkcs12/p12_init.c b/lib/libcrypto/pkcs12/p12_init.c index b865017c8d2..09ff0d5593b 100644 --- a/lib/libcrypto/pkcs12/p12_init.c +++ b/lib/libcrypto/pkcs12/p12_init.c @@ -1,4 +1,4 @@ -/* $OpenBSD: p12_init.c,v 1.15 2022/11/12 13:03:28 beck Exp $ */ +/* $OpenBSD: p12_init.c,v 1.16 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -98,4 +98,4 @@ err: PKCS12_free(pkcs12); return NULL; } -LCRYPTO_ALIAS(PKCS12_init) +LCRYPTO_ALIAS(PKCS12_init); diff --git a/lib/libcrypto/pkcs12/p12_key.c b/lib/libcrypto/pkcs12/p12_key.c index 57cfd8b0775..8812f1c06a8 100644 --- a/lib/libcrypto/pkcs12/p12_key.c +++ b/lib/libcrypto/pkcs12/p12_key.c @@ -1,4 +1,4 @@ -/* $OpenBSD: p12_key.c,v 1.33 2022/11/26 16:08:53 tb Exp $ */ +/* $OpenBSD: p12_key.c,v 1.34 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -93,7 +93,7 @@ PKCS12_key_gen_asc(const char *pass, int passlen, unsigned char *salt, freezero(unipass, uniplen); return ret; } -LCRYPTO_ALIAS(PKCS12_key_gen_asc) +LCRYPTO_ALIAS(PKCS12_key_gen_asc); int PKCS12_key_gen_uni(unsigned char *pass, int passlen, unsigned char *salt, @@ -194,4 +194,4 @@ PKCS12_key_gen_uni(unsigned char *pass, int passlen, unsigned char *salt, return ret; } -LCRYPTO_ALIAS(PKCS12_key_gen_uni) +LCRYPTO_ALIAS(PKCS12_key_gen_uni); diff --git a/lib/libcrypto/pkcs12/p12_kiss.c b/lib/libcrypto/pkcs12/p12_kiss.c index 1cf2fa7d495..48bbd137c6a 100644 --- a/lib/libcrypto/pkcs12/p12_kiss.c +++ b/lib/libcrypto/pkcs12/p12_kiss.c @@ -1,4 +1,4 @@ -/* $OpenBSD: p12_kiss.c,v 1.26 2022/11/12 13:03:28 beck Exp $ */ +/* $OpenBSD: p12_kiss.c,v 1.27 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -168,7 +168,7 @@ err: return 0; } -LCRYPTO_ALIAS(PKCS12_parse) +LCRYPTO_ALIAS(PKCS12_parse); /* Parse the outer PKCS#12 structure */ diff --git a/lib/libcrypto/pkcs12/p12_mutl.c b/lib/libcrypto/pkcs12/p12_mutl.c index abfd9dd4b74..f0e6df9eb6e 100644 --- a/lib/libcrypto/pkcs12/p12_mutl.c +++ b/lib/libcrypto/pkcs12/p12_mutl.c @@ -1,4 +1,4 @@ -/* $OpenBSD: p12_mutl.c,v 1.34 2022/11/26 16:08:53 tb Exp $ */ +/* $OpenBSD: p12_mutl.c,v 1.35 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -78,7 +78,7 @@ PKCS12_mac_present(const PKCS12 *p12) { return p12->mac != NULL; } -LCRYPTO_ALIAS(PKCS12_mac_present) +LCRYPTO_ALIAS(PKCS12_mac_present); void PKCS12_get0_mac(const ASN1_OCTET_STRING **pmac, const X509_ALGOR **pmacalg, @@ -106,7 +106,7 @@ PKCS12_get0_mac(const ASN1_OCTET_STRING **pmac, const X509_ALGOR **pmacalg, if (piter != NULL) *piter = p12->mac->iter; } -LCRYPTO_ALIAS(PKCS12_get0_mac) +LCRYPTO_ALIAS(PKCS12_get0_mac); /* Generate a MAC */ int @@ -169,7 +169,7 @@ PKCS12_gen_mac(PKCS12 *p12, const char *pass, int passlen, return ret; } -LCRYPTO_ALIAS(PKCS12_gen_mac) +LCRYPTO_ALIAS(PKCS12_gen_mac); /* Verify the mac */ int @@ -191,7 +191,7 @@ PKCS12_verify_mac(PKCS12 *p12, const char *pass, int passlen) return 0; return 1; } -LCRYPTO_ALIAS(PKCS12_verify_mac) +LCRYPTO_ALIAS(PKCS12_verify_mac); /* Set a mac */ @@ -219,7 +219,7 @@ PKCS12_set_mac(PKCS12 *p12, const char *pass, int passlen, unsigned char *salt, } return 1; } -LCRYPTO_ALIAS(PKCS12_set_mac) +LCRYPTO_ALIAS(PKCS12_set_mac); /* Set up a mac structure */ int @@ -259,5 +259,5 @@ PKCS12_setup_mac(PKCS12 *p12, int iter, unsigned char *salt, int saltlen, return 1; } -LCRYPTO_ALIAS(PKCS12_setup_mac) +LCRYPTO_ALIAS(PKCS12_setup_mac); #endif diff --git a/lib/libcrypto/pkcs12/p12_npas.c b/lib/libcrypto/pkcs12/p12_npas.c index 1e2538717e0..30dd2ef8c40 100644 --- a/lib/libcrypto/pkcs12/p12_npas.c +++ b/lib/libcrypto/pkcs12/p12_npas.c @@ -1,4 +1,4 @@ -/* $OpenBSD: p12_npas.c,v 1.17 2022/11/26 16:08:53 tb Exp $ */ +/* $OpenBSD: p12_npas.c,v 1.18 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -103,7 +103,7 @@ PKCS12_newpass(PKCS12 *p12, const char *oldpass, const char *newpass) return 1; } -LCRYPTO_ALIAS(PKCS12_newpass) +LCRYPTO_ALIAS(PKCS12_newpass); /* Parse the outer PKCS#12 structure */ diff --git a/lib/libcrypto/pkcs12/p12_p8d.c b/lib/libcrypto/pkcs12/p12_p8d.c index 53942a1d702..dd5e8d9875c 100644 --- a/lib/libcrypto/pkcs12/p12_p8d.c +++ b/lib/libcrypto/pkcs12/p12_p8d.c @@ -1,4 +1,4 @@ -/* $OpenBSD: p12_p8d.c,v 1.10 2022/11/26 16:08:53 tb Exp $ */ +/* $OpenBSD: p12_p8d.c,v 1.11 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 2001. */ @@ -68,4 +68,4 @@ PKCS8_decrypt(const X509_SIG *p8, const char *pass, int passlen) return PKCS12_item_decrypt_d2i(p8->algor, &PKCS8_PRIV_KEY_INFO_it, pass, passlen, p8->digest, 1); } -LCRYPTO_ALIAS(PKCS8_decrypt) +LCRYPTO_ALIAS(PKCS8_decrypt); diff --git a/lib/libcrypto/pkcs12/p12_p8e.c b/lib/libcrypto/pkcs12/p12_p8e.c index 147d207cc87..87c4be56a31 100644 --- a/lib/libcrypto/pkcs12/p12_p8e.c +++ b/lib/libcrypto/pkcs12/p12_p8e.c @@ -1,4 +1,4 @@ -/* $OpenBSD: p12_p8e.c,v 1.11 2022/11/26 16:08:53 tb Exp $ */ +/* $OpenBSD: p12_p8e.c,v 1.12 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 2001. */ @@ -100,4 +100,4 @@ err: X509_SIG_free(p8); return NULL; } -LCRYPTO_ALIAS(PKCS8_encrypt) +LCRYPTO_ALIAS(PKCS8_encrypt); diff --git a/lib/libcrypto/pkcs12/p12_sbag.c b/lib/libcrypto/pkcs12/p12_sbag.c index 16ada0eeb1e..b7772b67b8a 100644 --- a/lib/libcrypto/pkcs12/p12_sbag.c +++ b/lib/libcrypto/pkcs12/p12_sbag.c @@ -1,4 +1,4 @@ -/* $OpenBSD: p12_sbag.c,v 1.7 2022/11/26 16:08:53 tb Exp $ */ +/* $OpenBSD: p12_sbag.c,v 1.8 2023/02/16 08:38:17 tb Exp $ */ /* * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project * 1999-2018. @@ -70,14 +70,14 @@ PKCS12_SAFEBAG_get0_attr(const PKCS12_SAFEBAG *bag, int attr_nid) { return PKCS12_get_attr_gen(bag->attrib, attr_nid); } -LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_attr) +LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_attr); ASN1_TYPE * PKCS8_get_attr(PKCS8_PRIV_KEY_INFO *p8, int attr_nid) { return PKCS12_get_attr_gen(p8->attributes, attr_nid); } -LCRYPTO_ALIAS(PKCS8_get_attr) +LCRYPTO_ALIAS(PKCS8_get_attr); const PKCS8_PRIV_KEY_INFO * PKCS12_SAFEBAG_get0_p8inf(const PKCS12_SAFEBAG *bag) @@ -87,7 +87,7 @@ PKCS12_SAFEBAG_get0_p8inf(const PKCS12_SAFEBAG *bag) return bag->value.keybag; } -LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_p8inf) +LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_p8inf); const X509_SIG * PKCS12_SAFEBAG_get0_pkcs8(const PKCS12_SAFEBAG *bag) @@ -97,7 +97,7 @@ PKCS12_SAFEBAG_get0_pkcs8(const PKCS12_SAFEBAG *bag) return bag->value.shkeybag; } -LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_pkcs8) +LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_pkcs8); const STACK_OF(PKCS12_SAFEBAG) * PKCS12_SAFEBAG_get0_safes(const PKCS12_SAFEBAG *bag) @@ -107,21 +107,21 @@ PKCS12_SAFEBAG_get0_safes(const PKCS12_SAFEBAG *bag) return bag->value.safes; } -LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_safes) +LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_safes); const ASN1_OBJECT * PKCS12_SAFEBAG_get0_type(const PKCS12_SAFEBAG *bag) { return bag->type; } -LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_type) +LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_type); int PKCS12_SAFEBAG_get_nid(const PKCS12_SAFEBAG *bag) { return OBJ_obj2nid(bag->type); } -LCRYPTO_ALIAS(PKCS12_SAFEBAG_get_nid) +LCRYPTO_ALIAS(PKCS12_SAFEBAG_get_nid); int PKCS12_SAFEBAG_get_bag_nid(const PKCS12_SAFEBAG *bag) @@ -136,7 +136,7 @@ PKCS12_SAFEBAG_get_bag_nid(const PKCS12_SAFEBAG *bag) return -1; } -LCRYPTO_ALIAS(PKCS12_SAFEBAG_get_bag_nid) +LCRYPTO_ALIAS(PKCS12_SAFEBAG_get_bag_nid); X509 * PKCS12_SAFEBAG_get1_cert(const PKCS12_SAFEBAG *bag) @@ -147,7 +147,7 @@ PKCS12_SAFEBAG_get1_cert(const PKCS12_SAFEBAG *bag) return NULL; return ASN1_item_unpack(bag->value.bag->value.octet, &X509_it); } -LCRYPTO_ALIAS(PKCS12_SAFEBAG_get1_cert) +LCRYPTO_ALIAS(PKCS12_SAFEBAG_get1_cert); X509_CRL * PKCS12_SAFEBAG_get1_crl(const PKCS12_SAFEBAG *bag) @@ -158,7 +158,7 @@ PKCS12_SAFEBAG_get1_crl(const PKCS12_SAFEBAG *bag) return NULL; return ASN1_item_unpack(bag->value.bag->value.octet, &X509_CRL_it); } -LCRYPTO_ALIAS(PKCS12_SAFEBAG_get1_crl) +LCRYPTO_ALIAS(PKCS12_SAFEBAG_get1_crl); PKCS12_SAFEBAG * PKCS12_SAFEBAG_create_cert(X509 *x509) @@ -166,7 +166,7 @@ PKCS12_SAFEBAG_create_cert(X509 *x509) return PKCS12_item_pack_safebag(x509, &X509_it, NID_x509Certificate, NID_certBag); } -LCRYPTO_ALIAS(PKCS12_SAFEBAG_create_cert) +LCRYPTO_ALIAS(PKCS12_SAFEBAG_create_cert); PKCS12_SAFEBAG * PKCS12_SAFEBAG_create_crl(X509_CRL *crl) @@ -174,7 +174,7 @@ PKCS12_SAFEBAG_create_crl(X509_CRL *crl) return PKCS12_item_pack_safebag(crl, &X509_CRL_it, NID_x509Crl, NID_crlBag); } -LCRYPTO_ALIAS(PKCS12_SAFEBAG_create_crl) +LCRYPTO_ALIAS(PKCS12_SAFEBAG_create_crl); /* Turn PKCS8 object into a keybag */ @@ -193,7 +193,7 @@ PKCS12_SAFEBAG_create0_p8inf(PKCS8_PRIV_KEY_INFO *p8) return bag; } -LCRYPTO_ALIAS(PKCS12_SAFEBAG_create0_p8inf) +LCRYPTO_ALIAS(PKCS12_SAFEBAG_create0_p8inf); /* Turn PKCS8 object into a shrouded keybag */ @@ -213,7 +213,7 @@ PKCS12_SAFEBAG_create0_pkcs8(X509_SIG *p8) return bag; } -LCRYPTO_ALIAS(PKCS12_SAFEBAG_create0_pkcs8) +LCRYPTO_ALIAS(PKCS12_SAFEBAG_create0_pkcs8); PKCS12_SAFEBAG * PKCS12_SAFEBAG_create_pkcs8_encrypt(int pbe_nid, const char *pass, int passlen, @@ -237,4 +237,4 @@ PKCS12_SAFEBAG_create_pkcs8_encrypt(int pbe_nid, const char *pass, int passlen, return bag; } -LCRYPTO_ALIAS(PKCS12_SAFEBAG_create_pkcs8_encrypt) +LCRYPTO_ALIAS(PKCS12_SAFEBAG_create_pkcs8_encrypt); diff --git a/lib/libcrypto/pkcs12/p12_utl.c b/lib/libcrypto/pkcs12/p12_utl.c index 0758e875ae7..72692a9eae9 100644 --- a/lib/libcrypto/pkcs12/p12_utl.c +++ b/lib/libcrypto/pkcs12/p12_utl.c @@ -1,4 +1,4 @@ -/* $OpenBSD: p12_utl.c,v 1.20 2022/11/12 13:03:28 beck Exp $ */ +/* $OpenBSD: p12_utl.c,v 1.21 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -100,7 +100,7 @@ OPENSSL_asc2uni(const char *asc, int asclen, unsigned char **uni, int *unilen) *uni = unitmp; return unitmp; } -LCRYPTO_ALIAS(OPENSSL_asc2uni) +LCRYPTO_ALIAS(OPENSSL_asc2uni); char * OPENSSL_uni2asc(const unsigned char *uni, int unilen) @@ -126,32 +126,32 @@ OPENSSL_uni2asc(const unsigned char *uni, int unilen) asctmp[asclen - 1] = '\0'; return asctmp; } -LCRYPTO_ALIAS(OPENSSL_uni2asc) +LCRYPTO_ALIAS(OPENSSL_uni2asc); int i2d_PKCS12_bio(BIO *bp, PKCS12 *p12) { return ASN1_item_i2d_bio(&PKCS12_it, bp, p12); } -LCRYPTO_ALIAS(i2d_PKCS12_bio) +LCRYPTO_ALIAS(i2d_PKCS12_bio); int i2d_PKCS12_fp(FILE *fp, PKCS12 *p12) { return ASN1_item_i2d_fp(&PKCS12_it, fp, p12); } -LCRYPTO_ALIAS(i2d_PKCS12_fp) +LCRYPTO_ALIAS(i2d_PKCS12_fp); PKCS12 * d2i_PKCS12_bio(BIO *bp, PKCS12 **p12) { return ASN1_item_d2i_bio(&PKCS12_it, bp, p12); } -LCRYPTO_ALIAS(d2i_PKCS12_bio) +LCRYPTO_ALIAS(d2i_PKCS12_bio); PKCS12 * d2i_PKCS12_fp(FILE *fp, PKCS12 **p12) { return ASN1_item_d2i_fp(&PKCS12_it, fp, p12); } -LCRYPTO_ALIAS(d2i_PKCS12_fp) +LCRYPTO_ALIAS(d2i_PKCS12_fp); diff --git a/lib/libcrypto/pkcs12/pk12err.c b/lib/libcrypto/pkcs12/pk12err.c index 7e9149288d7..3af03528a23 100644 --- a/lib/libcrypto/pkcs12/pk12err.c +++ b/lib/libcrypto/pkcs12/pk12err.c @@ -1,4 +1,4 @@ -/* $OpenBSD: pk12err.c,v 1.13 2022/11/12 13:03:28 beck Exp $ */ +/* $OpenBSD: pk12err.c,v 1.14 2023/02/16 08:38:17 tb Exp $ */ /* ==================================================================== * Copyright (c) 1999-2006 The OpenSSL Project. All rights reserved. * @@ -108,4 +108,4 @@ ERR_load_PKCS12_strings(void) } #endif } -LCRYPTO_ALIAS(ERR_load_PKCS12_strings) +LCRYPTO_ALIAS(ERR_load_PKCS12_strings); diff --git a/lib/libcrypto/pkcs7/bio_pk7.c b/lib/libcrypto/pkcs7/bio_pk7.c index 5f02535484d..83cf70fd877 100644 --- a/lib/libcrypto/pkcs7/bio_pk7.c +++ b/lib/libcrypto/pkcs7/bio_pk7.c @@ -1,4 +1,4 @@ -/* $OpenBSD: bio_pk7.c,v 1.6 2022/11/12 12:11:14 beck Exp $ */ +/* $OpenBSD: bio_pk7.c,v 1.7 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project. */ @@ -64,4 +64,4 @@ BIO_new_PKCS7(BIO *out, PKCS7 *p7) { return BIO_new_NDEF(out, (ASN1_VALUE *)p7, &PKCS7_it); } -LCRYPTO_ALIAS(BIO_new_PKCS7) +LCRYPTO_ALIAS(BIO_new_PKCS7); diff --git a/lib/libcrypto/pkcs7/pk7_asn1.c b/lib/libcrypto/pkcs7/pk7_asn1.c index b0c4ee8016c..e5366ca45e8 100644 --- a/lib/libcrypto/pkcs7/pk7_asn1.c +++ b/lib/libcrypto/pkcs7/pk7_asn1.c @@ -1,4 +1,4 @@ -/* $OpenBSD: pk7_asn1.c,v 1.14 2022/11/12 12:11:14 beck Exp $ */ +/* $OpenBSD: pk7_asn1.c,v 1.15 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 2000. */ @@ -221,42 +221,42 @@ d2i_PKCS7(PKCS7 **a, const unsigned char **in, long len) return (PKCS7 *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &PKCS7_it); } -LCRYPTO_ALIAS(d2i_PKCS7) +LCRYPTO_ALIAS(d2i_PKCS7); int i2d_PKCS7(PKCS7 *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_it); } -LCRYPTO_ALIAS(i2d_PKCS7) +LCRYPTO_ALIAS(i2d_PKCS7); PKCS7 * PKCS7_new(void) { return (PKCS7 *)ASN1_item_new(&PKCS7_it); } -LCRYPTO_ALIAS(PKCS7_new) +LCRYPTO_ALIAS(PKCS7_new); void PKCS7_free(PKCS7 *a) { ASN1_item_free((ASN1_VALUE *)a, &PKCS7_it); } -LCRYPTO_ALIAS(PKCS7_free) +LCRYPTO_ALIAS(PKCS7_free); int i2d_PKCS7_NDEF(PKCS7 *a, unsigned char **out) { return ASN1_item_ndef_i2d((ASN1_VALUE *)a, out, &PKCS7_it); } -LCRYPTO_ALIAS(i2d_PKCS7_NDEF) +LCRYPTO_ALIAS(i2d_PKCS7_NDEF); PKCS7 * PKCS7_dup(PKCS7 *x) { return ASN1_item_dup(&PKCS7_it, x); } -LCRYPTO_ALIAS(PKCS7_dup) +LCRYPTO_ALIAS(PKCS7_dup); static const ASN1_TEMPLATE PKCS7_SIGNED_seq_tt[] = { { @@ -320,28 +320,28 @@ d2i_PKCS7_SIGNED(PKCS7_SIGNED **a, const unsigned char **in, long len) return (PKCS7_SIGNED *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &PKCS7_SIGNED_it); } -LCRYPTO_ALIAS(d2i_PKCS7_SIGNED) +LCRYPTO_ALIAS(d2i_PKCS7_SIGNED); int i2d_PKCS7_SIGNED(PKCS7_SIGNED *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_SIGNED_it); } -LCRYPTO_ALIAS(i2d_PKCS7_SIGNED) +LCRYPTO_ALIAS(i2d_PKCS7_SIGNED); PKCS7_SIGNED * PKCS7_SIGNED_new(void) { return (PKCS7_SIGNED *)ASN1_item_new(&PKCS7_SIGNED_it); } -LCRYPTO_ALIAS(PKCS7_SIGNED_new) +LCRYPTO_ALIAS(PKCS7_SIGNED_new); void PKCS7_SIGNED_free(PKCS7_SIGNED *a) { ASN1_item_free((ASN1_VALUE *)a, &PKCS7_SIGNED_it); } -LCRYPTO_ALIAS(PKCS7_SIGNED_free) +LCRYPTO_ALIAS(PKCS7_SIGNED_free); /* Minor tweak to operation: free up EVP_PKEY */ static int @@ -436,28 +436,28 @@ d2i_PKCS7_SIGNER_INFO(PKCS7_SIGNER_INFO **a, const unsigned char **in, long len) return (PKCS7_SIGNER_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &PKCS7_SIGNER_INFO_it); } -LCRYPTO_ALIAS(d2i_PKCS7_SIGNER_INFO) +LCRYPTO_ALIAS(d2i_PKCS7_SIGNER_INFO); int i2d_PKCS7_SIGNER_INFO(PKCS7_SIGNER_INFO *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_SIGNER_INFO_it); } -LCRYPTO_ALIAS(i2d_PKCS7_SIGNER_INFO) +LCRYPTO_ALIAS(i2d_PKCS7_SIGNER_INFO); PKCS7_SIGNER_INFO * PKCS7_SIGNER_INFO_new(void) { return (PKCS7_SIGNER_INFO *)ASN1_item_new(&PKCS7_SIGNER_INFO_it); } -LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_new) +LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_new); void PKCS7_SIGNER_INFO_free(PKCS7_SIGNER_INFO *a) { ASN1_item_free((ASN1_VALUE *)a, &PKCS7_SIGNER_INFO_it); } -LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_free) +LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_free); static const ASN1_TEMPLATE PKCS7_ISSUER_AND_SERIAL_seq_tt[] = { { @@ -493,28 +493,28 @@ d2i_PKCS7_ISSUER_AND_SERIAL(PKCS7_ISSUER_AND_SERIAL **a, const unsigned char **i return (PKCS7_ISSUER_AND_SERIAL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &PKCS7_ISSUER_AND_SERIAL_it); } -LCRYPTO_ALIAS(d2i_PKCS7_ISSUER_AND_SERIAL) +LCRYPTO_ALIAS(d2i_PKCS7_ISSUER_AND_SERIAL); int i2d_PKCS7_ISSUER_AND_SERIAL(PKCS7_ISSUER_AND_SERIAL *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_ISSUER_AND_SERIAL_it); } -LCRYPTO_ALIAS(i2d_PKCS7_ISSUER_AND_SERIAL) +LCRYPTO_ALIAS(i2d_PKCS7_ISSUER_AND_SERIAL); PKCS7_ISSUER_AND_SERIAL * PKCS7_ISSUER_AND_SERIAL_new(void) { return (PKCS7_ISSUER_AND_SERIAL *)ASN1_item_new(&PKCS7_ISSUER_AND_SERIAL_it); } -LCRYPTO_ALIAS(PKCS7_ISSUER_AND_SERIAL_new) +LCRYPTO_ALIAS(PKCS7_ISSUER_AND_SERIAL_new); void PKCS7_ISSUER_AND_SERIAL_free(PKCS7_ISSUER_AND_SERIAL *a) { ASN1_item_free((ASN1_VALUE *)a, &PKCS7_ISSUER_AND_SERIAL_it); } -LCRYPTO_ALIAS(PKCS7_ISSUER_AND_SERIAL_free) +LCRYPTO_ALIAS(PKCS7_ISSUER_AND_SERIAL_free); static const ASN1_TEMPLATE PKCS7_ENVELOPE_seq_tt[] = { { @@ -557,28 +557,28 @@ d2i_PKCS7_ENVELOPE(PKCS7_ENVELOPE **a, const unsigned char **in, long len) return (PKCS7_ENVELOPE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &PKCS7_ENVELOPE_it); } -LCRYPTO_ALIAS(d2i_PKCS7_ENVELOPE) +LCRYPTO_ALIAS(d2i_PKCS7_ENVELOPE); int i2d_PKCS7_ENVELOPE(PKCS7_ENVELOPE *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_ENVELOPE_it); } -LCRYPTO_ALIAS(i2d_PKCS7_ENVELOPE) +LCRYPTO_ALIAS(i2d_PKCS7_ENVELOPE); PKCS7_ENVELOPE * PKCS7_ENVELOPE_new(void) { return (PKCS7_ENVELOPE *)ASN1_item_new(&PKCS7_ENVELOPE_it); } -LCRYPTO_ALIAS(PKCS7_ENVELOPE_new) +LCRYPTO_ALIAS(PKCS7_ENVELOPE_new); void PKCS7_ENVELOPE_free(PKCS7_ENVELOPE *a) { ASN1_item_free((ASN1_VALUE *)a, &PKCS7_ENVELOPE_it); } -LCRYPTO_ALIAS(PKCS7_ENVELOPE_free) +LCRYPTO_ALIAS(PKCS7_ENVELOPE_free); /* Minor tweak to operation: free up X509 */ static int @@ -647,28 +647,28 @@ d2i_PKCS7_RECIP_INFO(PKCS7_RECIP_INFO **a, const unsigned char **in, long len) return (PKCS7_RECIP_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &PKCS7_RECIP_INFO_it); } -LCRYPTO_ALIAS(d2i_PKCS7_RECIP_INFO) +LCRYPTO_ALIAS(d2i_PKCS7_RECIP_INFO); int i2d_PKCS7_RECIP_INFO(PKCS7_RECIP_INFO *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_RECIP_INFO_it); } -LCRYPTO_ALIAS(i2d_PKCS7_RECIP_INFO) +LCRYPTO_ALIAS(i2d_PKCS7_RECIP_INFO); PKCS7_RECIP_INFO * PKCS7_RECIP_INFO_new(void) { return (PKCS7_RECIP_INFO *)ASN1_item_new(&PKCS7_RECIP_INFO_it); } -LCRYPTO_ALIAS(PKCS7_RECIP_INFO_new) +LCRYPTO_ALIAS(PKCS7_RECIP_INFO_new); void PKCS7_RECIP_INFO_free(PKCS7_RECIP_INFO *a) { ASN1_item_free((ASN1_VALUE *)a, &PKCS7_RECIP_INFO_it); } -LCRYPTO_ALIAS(PKCS7_RECIP_INFO_free) +LCRYPTO_ALIAS(PKCS7_RECIP_INFO_free); static const ASN1_TEMPLATE PKCS7_ENC_CONTENT_seq_tt[] = { { @@ -711,28 +711,28 @@ d2i_PKCS7_ENC_CONTENT(PKCS7_ENC_CONTENT **a, const unsigned char **in, long len) return (PKCS7_ENC_CONTENT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &PKCS7_ENC_CONTENT_it); } -LCRYPTO_ALIAS(d2i_PKCS7_ENC_CONTENT) +LCRYPTO_ALIAS(d2i_PKCS7_ENC_CONTENT); int i2d_PKCS7_ENC_CONTENT(PKCS7_ENC_CONTENT *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_ENC_CONTENT_it); } -LCRYPTO_ALIAS(i2d_PKCS7_ENC_CONTENT) +LCRYPTO_ALIAS(i2d_PKCS7_ENC_CONTENT); PKCS7_ENC_CONTENT * PKCS7_ENC_CONTENT_new(void) { return (PKCS7_ENC_CONTENT *)ASN1_item_new(&PKCS7_ENC_CONTENT_it); } -LCRYPTO_ALIAS(PKCS7_ENC_CONTENT_new) +LCRYPTO_ALIAS(PKCS7_ENC_CONTENT_new); void PKCS7_ENC_CONTENT_free(PKCS7_ENC_CONTENT *a) { ASN1_item_free((ASN1_VALUE *)a, &PKCS7_ENC_CONTENT_it); } -LCRYPTO_ALIAS(PKCS7_ENC_CONTENT_free) +LCRYPTO_ALIAS(PKCS7_ENC_CONTENT_free); static const ASN1_TEMPLATE PKCS7_SIGN_ENVELOPE_seq_tt[] = { { @@ -803,28 +803,28 @@ d2i_PKCS7_SIGN_ENVELOPE(PKCS7_SIGN_ENVELOPE **a, const unsigned char **in, long return (PKCS7_SIGN_ENVELOPE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &PKCS7_SIGN_ENVELOPE_it); } -LCRYPTO_ALIAS(d2i_PKCS7_SIGN_ENVELOPE) +LCRYPTO_ALIAS(d2i_PKCS7_SIGN_ENVELOPE); int i2d_PKCS7_SIGN_ENVELOPE(PKCS7_SIGN_ENVELOPE *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_SIGN_ENVELOPE_it); } -LCRYPTO_ALIAS(i2d_PKCS7_SIGN_ENVELOPE) +LCRYPTO_ALIAS(i2d_PKCS7_SIGN_ENVELOPE); PKCS7_SIGN_ENVELOPE * PKCS7_SIGN_ENVELOPE_new(void) { return (PKCS7_SIGN_ENVELOPE *)ASN1_item_new(&PKCS7_SIGN_ENVELOPE_it); } -LCRYPTO_ALIAS(PKCS7_SIGN_ENVELOPE_new) +LCRYPTO_ALIAS(PKCS7_SIGN_ENVELOPE_new); void PKCS7_SIGN_ENVELOPE_free(PKCS7_SIGN_ENVELOPE *a) { ASN1_item_free((ASN1_VALUE *)a, &PKCS7_SIGN_ENVELOPE_it); } -LCRYPTO_ALIAS(PKCS7_SIGN_ENVELOPE_free) +LCRYPTO_ALIAS(PKCS7_SIGN_ENVELOPE_free); static const ASN1_TEMPLATE PKCS7_ENCRYPT_seq_tt[] = { { @@ -860,28 +860,28 @@ d2i_PKCS7_ENCRYPT(PKCS7_ENCRYPT **a, const unsigned char **in, long len) return (PKCS7_ENCRYPT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &PKCS7_ENCRYPT_it); } -LCRYPTO_ALIAS(d2i_PKCS7_ENCRYPT) +LCRYPTO_ALIAS(d2i_PKCS7_ENCRYPT); int i2d_PKCS7_ENCRYPT(PKCS7_ENCRYPT *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_ENCRYPT_it); } -LCRYPTO_ALIAS(i2d_PKCS7_ENCRYPT) +LCRYPTO_ALIAS(i2d_PKCS7_ENCRYPT); PKCS7_ENCRYPT * PKCS7_ENCRYPT_new(void) { return (PKCS7_ENCRYPT *)ASN1_item_new(&PKCS7_ENCRYPT_it); } -LCRYPTO_ALIAS(PKCS7_ENCRYPT_new) +LCRYPTO_ALIAS(PKCS7_ENCRYPT_new); void PKCS7_ENCRYPT_free(PKCS7_ENCRYPT *a) { ASN1_item_free((ASN1_VALUE *)a, &PKCS7_ENCRYPT_it); } -LCRYPTO_ALIAS(PKCS7_ENCRYPT_free) +LCRYPTO_ALIAS(PKCS7_ENCRYPT_free); static const ASN1_TEMPLATE PKCS7_DIGEST_seq_tt[] = { { @@ -931,28 +931,28 @@ d2i_PKCS7_DIGEST(PKCS7_DIGEST **a, const unsigned char **in, long len) return (PKCS7_DIGEST *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &PKCS7_DIGEST_it); } -LCRYPTO_ALIAS(d2i_PKCS7_DIGEST) +LCRYPTO_ALIAS(d2i_PKCS7_DIGEST); int i2d_PKCS7_DIGEST(PKCS7_DIGEST *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_DIGEST_it); } -LCRYPTO_ALIAS(i2d_PKCS7_DIGEST) +LCRYPTO_ALIAS(i2d_PKCS7_DIGEST); PKCS7_DIGEST * PKCS7_DIGEST_new(void) { return (PKCS7_DIGEST *)ASN1_item_new(&PKCS7_DIGEST_it); } -LCRYPTO_ALIAS(PKCS7_DIGEST_new) +LCRYPTO_ALIAS(PKCS7_DIGEST_new); void PKCS7_DIGEST_free(PKCS7_DIGEST *a) { ASN1_item_free((ASN1_VALUE *)a, &PKCS7_DIGEST_it); } -LCRYPTO_ALIAS(PKCS7_DIGEST_free) +LCRYPTO_ALIAS(PKCS7_DIGEST_free); /* Specials for authenticated attributes */ @@ -1007,35 +1007,35 @@ PKCS7_print_ctx(BIO *out, PKCS7 *x, int indent, const ASN1_PCTX *pctx) return ASN1_item_print(out, (ASN1_VALUE *)x, indent, &PKCS7_it, pctx); } -LCRYPTO_ALIAS(PKCS7_print_ctx) +LCRYPTO_ALIAS(PKCS7_print_ctx); PKCS7 * d2i_PKCS7_bio(BIO *bp, PKCS7 **p7) { return ASN1_item_d2i_bio(&PKCS7_it, bp, p7); } -LCRYPTO_ALIAS(d2i_PKCS7_bio) +LCRYPTO_ALIAS(d2i_PKCS7_bio); int i2d_PKCS7_bio(BIO *bp, PKCS7 *p7) { return ASN1_item_i2d_bio(&PKCS7_it, bp, p7); } -LCRYPTO_ALIAS(i2d_PKCS7_bio) +LCRYPTO_ALIAS(i2d_PKCS7_bio); PKCS7 * d2i_PKCS7_fp(FILE *fp, PKCS7 **p7) { return ASN1_item_d2i_fp(&PKCS7_it, fp, p7); } -LCRYPTO_ALIAS(d2i_PKCS7_fp) +LCRYPTO_ALIAS(d2i_PKCS7_fp); int i2d_PKCS7_fp(FILE *fp, PKCS7 *p7) { return ASN1_item_i2d_fp(&PKCS7_it, fp, p7); } -LCRYPTO_ALIAS(i2d_PKCS7_fp) +LCRYPTO_ALIAS(i2d_PKCS7_fp); int PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data, @@ -1044,4 +1044,4 @@ PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data, return(ASN1_item_digest(&PKCS7_ISSUER_AND_SERIAL_it, type, (char *)data, md, len)); } -LCRYPTO_ALIAS(PKCS7_ISSUER_AND_SERIAL_digest) +LCRYPTO_ALIAS(PKCS7_ISSUER_AND_SERIAL_digest); diff --git a/lib/libcrypto/pkcs7/pk7_attr.c b/lib/libcrypto/pkcs7/pk7_attr.c index 1a5dc06dc57..5eff5241ef7 100644 --- a/lib/libcrypto/pkcs7/pk7_attr.c +++ b/lib/libcrypto/pkcs7/pk7_attr.c @@ -1,4 +1,4 @@ -/* $OpenBSD: pk7_attr.c,v 1.13 2022/11/12 12:11:14 beck Exp $ */ +/* $OpenBSD: pk7_attr.c,v 1.14 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 2001. */ @@ -79,7 +79,7 @@ PKCS7_add_attrib_smimecap(PKCS7_SIGNER_INFO *si, STACK_OF(X509_ALGOR) *cap) return PKCS7_add_signed_attribute(si, NID_SMIMECapabilities, V_ASN1_SEQUENCE, seq); } -LCRYPTO_ALIAS(PKCS7_add_attrib_smimecap) +LCRYPTO_ALIAS(PKCS7_add_attrib_smimecap); STACK_OF(X509_ALGOR) * PKCS7_get_smimecap(PKCS7_SIGNER_INFO *si) @@ -95,7 +95,7 @@ PKCS7_get_smimecap(PKCS7_SIGNER_INFO *si) ASN1_item_d2i(NULL, &p, cap->value.sequence->length, &X509_ALGORS_it); } -LCRYPTO_ALIAS(PKCS7_get_smimecap) +LCRYPTO_ALIAS(PKCS7_get_smimecap); /* Basic smime-capabilities OID and optional integer arg */ int @@ -132,7 +132,7 @@ err: X509_ALGOR_free(alg); return 0; } -LCRYPTO_ALIAS(PKCS7_simple_smimecap) +LCRYPTO_ALIAS(PKCS7_simple_smimecap); int PKCS7_add_attrib_content_type(PKCS7_SIGNER_INFO *si, ASN1_OBJECT *coid) @@ -144,7 +144,7 @@ PKCS7_add_attrib_content_type(PKCS7_SIGNER_INFO *si, ASN1_OBJECT *coid) return PKCS7_add_signed_attribute(si, NID_pkcs9_contentType, V_ASN1_OBJECT, coid); } -LCRYPTO_ALIAS(PKCS7_add_attrib_content_type) +LCRYPTO_ALIAS(PKCS7_add_attrib_content_type); int PKCS7_add0_attrib_signing_time(PKCS7_SIGNER_INFO *si, ASN1_TIME *t) @@ -156,7 +156,7 @@ PKCS7_add0_attrib_signing_time(PKCS7_SIGNER_INFO *si, ASN1_TIME *t) return PKCS7_add_signed_attribute(si, NID_pkcs9_signingTime, V_ASN1_UTCTIME, t); } -LCRYPTO_ALIAS(PKCS7_add0_attrib_signing_time) +LCRYPTO_ALIAS(PKCS7_add0_attrib_signing_time); int PKCS7_add1_attrib_digest(PKCS7_SIGNER_INFO *si, const unsigned char *md, @@ -175,4 +175,4 @@ PKCS7_add1_attrib_digest(PKCS7_SIGNER_INFO *si, const unsigned char *md, } return 1; } -LCRYPTO_ALIAS(PKCS7_add1_attrib_digest) +LCRYPTO_ALIAS(PKCS7_add1_attrib_digest); diff --git a/lib/libcrypto/pkcs7/pk7_doit.c b/lib/libcrypto/pkcs7/pk7_doit.c index 3e2d4c2119e..1fcc37a983f 100644 --- a/lib/libcrypto/pkcs7/pk7_doit.c +++ b/lib/libcrypto/pkcs7/pk7_doit.c @@ -1,4 +1,4 @@ -/* $OpenBSD: pk7_doit.c,v 1.50 2022/12/26 07:18:52 jmc Exp $ */ +/* $OpenBSD: pk7_doit.c,v 1.51 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -404,7 +404,7 @@ err: } return (out); } -LCRYPTO_ALIAS(PKCS7_dataInit) +LCRYPTO_ALIAS(PKCS7_dataInit); static int pkcs7_cmp_ri(PKCS7_RECIP_INFO *ri, X509 *pcert) @@ -630,7 +630,7 @@ err: } return (out); } -LCRYPTO_ALIAS(PKCS7_dataDecode) +LCRYPTO_ALIAS(PKCS7_dataDecode); static BIO * PKCS7_find_digest(EVP_MD_CTX **pmd, BIO *bio, int nid) @@ -859,7 +859,7 @@ err: EVP_MD_CTX_cleanup(&ctx_tmp); return (ret); } -LCRYPTO_ALIAS(PKCS7_dataFinal) +LCRYPTO_ALIAS(PKCS7_dataFinal); int PKCS7_SIGNER_INFO_sign(PKCS7_SIGNER_INFO *si) @@ -918,7 +918,7 @@ err: EVP_MD_CTX_cleanup(&mctx); return 0; } -LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_sign) +LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_sign); int PKCS7_dataVerify(X509_STORE *cert_store, X509_STORE_CTX *ctx, BIO *bio, @@ -980,7 +980,7 @@ err: return ret; } -LCRYPTO_ALIAS(PKCS7_dataVerify) +LCRYPTO_ALIAS(PKCS7_dataVerify); int PKCS7_signatureVerify(BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si, X509 *x509) @@ -1087,7 +1087,7 @@ err: EVP_MD_CTX_cleanup(&mdc_tmp); return (ret); } -LCRYPTO_ALIAS(PKCS7_signatureVerify) +LCRYPTO_ALIAS(PKCS7_signatureVerify); PKCS7_ISSUER_AND_SERIAL * PKCS7_get_issuer_and_serial(PKCS7 *p7, int idx) @@ -1110,21 +1110,21 @@ PKCS7_get_issuer_and_serial(PKCS7 *p7, int idx) ri = sk_PKCS7_RECIP_INFO_value(rsk, idx); return (ri->issuer_and_serial); } -LCRYPTO_ALIAS(PKCS7_get_issuer_and_serial) +LCRYPTO_ALIAS(PKCS7_get_issuer_and_serial); ASN1_TYPE * PKCS7_get_signed_attribute(PKCS7_SIGNER_INFO *si, int nid) { return (get_attribute(si->auth_attr, nid)); } -LCRYPTO_ALIAS(PKCS7_get_signed_attribute) +LCRYPTO_ALIAS(PKCS7_get_signed_attribute); ASN1_TYPE * PKCS7_get_attribute(PKCS7_SIGNER_INFO *si, int nid) { return (get_attribute(si->unauth_attr, nid)); } -LCRYPTO_ALIAS(PKCS7_get_attribute) +LCRYPTO_ALIAS(PKCS7_get_attribute); static ASN1_TYPE * get_attribute(STACK_OF(X509_ATTRIBUTE) *sk, int nid) @@ -1155,7 +1155,7 @@ PKCS7_digest_from_attributes(STACK_OF(X509_ATTRIBUTE) *sk) return NULL; return astype->value.octet_string; } -LCRYPTO_ALIAS(PKCS7_digest_from_attributes) +LCRYPTO_ALIAS(PKCS7_digest_from_attributes); int PKCS7_set_signed_attributes(PKCS7_SIGNER_INFO *p7si, @@ -1177,7 +1177,7 @@ PKCS7_set_signed_attributes(PKCS7_SIGNER_INFO *p7si, } return (1); } -LCRYPTO_ALIAS(PKCS7_set_signed_attributes) +LCRYPTO_ALIAS(PKCS7_set_signed_attributes); int PKCS7_set_attributes(PKCS7_SIGNER_INFO *p7si, STACK_OF(X509_ATTRIBUTE) *sk) @@ -1198,7 +1198,7 @@ PKCS7_set_attributes(PKCS7_SIGNER_INFO *p7si, STACK_OF(X509_ATTRIBUTE) *sk) } return (1); } -LCRYPTO_ALIAS(PKCS7_set_attributes) +LCRYPTO_ALIAS(PKCS7_set_attributes); int PKCS7_add_signed_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype, @@ -1206,14 +1206,14 @@ PKCS7_add_signed_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype, { return (add_attribute(&(p7si->auth_attr), nid, atrtype, value)); } -LCRYPTO_ALIAS(PKCS7_add_signed_attribute) +LCRYPTO_ALIAS(PKCS7_add_signed_attribute); int PKCS7_add_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype, void *value) { return (add_attribute(&(p7si->unauth_attr), nid, atrtype, value)); } -LCRYPTO_ALIAS(PKCS7_add_attribute) +LCRYPTO_ALIAS(PKCS7_add_attribute); static int add_attribute(STACK_OF(X509_ATTRIBUTE) **sk, int nid, int atrtype, void *value) diff --git a/lib/libcrypto/pkcs7/pk7_lib.c b/lib/libcrypto/pkcs7/pk7_lib.c index efb6343f546..6eda698c94a 100644 --- a/lib/libcrypto/pkcs7/pk7_lib.c +++ b/lib/libcrypto/pkcs7/pk7_lib.c @@ -1,4 +1,4 @@ -/* $OpenBSD: pk7_lib.c,v 1.25 2022/11/26 16:08:54 tb Exp $ */ +/* $OpenBSD: pk7_lib.c,v 1.26 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -109,7 +109,7 @@ PKCS7_ctrl(PKCS7 *p7, int cmd, long larg, char *parg) } return (ret); } -LCRYPTO_ALIAS(PKCS7_ctrl) +LCRYPTO_ALIAS(PKCS7_ctrl); int PKCS7_content_new(PKCS7 *p7, int type) @@ -129,7 +129,7 @@ err: PKCS7_free(ret); return (0); } -LCRYPTO_ALIAS(PKCS7_content_new) +LCRYPTO_ALIAS(PKCS7_content_new); int PKCS7_set_content(PKCS7 *p7, PKCS7 *p7_data) @@ -160,7 +160,7 @@ PKCS7_set_content(PKCS7 *p7, PKCS7 *p7_data) err: return (0); } -LCRYPTO_ALIAS(PKCS7_set_content) +LCRYPTO_ALIAS(PKCS7_set_content); int PKCS7_set_type(PKCS7 *p7, int type) @@ -230,7 +230,7 @@ PKCS7_set_type(PKCS7 *p7, int type) err: return (0); } -LCRYPTO_ALIAS(PKCS7_set_type) +LCRYPTO_ALIAS(PKCS7_set_type); int PKCS7_set0_type_other(PKCS7 *p7, int type, ASN1_TYPE *other) @@ -239,7 +239,7 @@ PKCS7_set0_type_other(PKCS7 *p7, int type, ASN1_TYPE *other) p7->d.other = other; return 1; } -LCRYPTO_ALIAS(PKCS7_set0_type_other) +LCRYPTO_ALIAS(PKCS7_set0_type_other); int PKCS7_add_signer(PKCS7 *p7, PKCS7_SIGNER_INFO *psi) @@ -295,7 +295,7 @@ PKCS7_add_signer(PKCS7 *p7, PKCS7_SIGNER_INFO *psi) return 0; return (1); } -LCRYPTO_ALIAS(PKCS7_add_signer) +LCRYPTO_ALIAS(PKCS7_add_signer); int PKCS7_add_certificate(PKCS7 *p7, X509 *x509) @@ -329,7 +329,7 @@ PKCS7_add_certificate(PKCS7 *p7, X509 *x509) } return (1); } -LCRYPTO_ALIAS(PKCS7_add_certificate) +LCRYPTO_ALIAS(PKCS7_add_certificate); int PKCS7_add_crl(PKCS7 *p7, X509_CRL *crl) @@ -364,7 +364,7 @@ PKCS7_add_crl(PKCS7 *p7, X509_CRL *crl) } return (1); } -LCRYPTO_ALIAS(PKCS7_add_crl) +LCRYPTO_ALIAS(PKCS7_add_crl); int PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO *p7i, X509 *x509, EVP_PKEY *pkey, @@ -409,7 +409,7 @@ PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO *p7i, X509 *x509, EVP_PKEY *pkey, err: return 0; } -LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_set) +LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_set); PKCS7_SIGNER_INFO * PKCS7_add_signature(PKCS7 *p7, X509 *x509, EVP_PKEY *pkey, const EVP_MD *dgst) @@ -439,7 +439,7 @@ err: PKCS7_SIGNER_INFO_free(si); return (NULL); } -LCRYPTO_ALIAS(PKCS7_add_signature) +LCRYPTO_ALIAS(PKCS7_add_signature); int PKCS7_set_digest(PKCS7 *p7, const EVP_MD *md) @@ -457,7 +457,7 @@ PKCS7_set_digest(PKCS7 *p7, const EVP_MD *md) PKCS7error(PKCS7_R_WRONG_CONTENT_TYPE); return 1; } -LCRYPTO_ALIAS(PKCS7_set_digest) +LCRYPTO_ALIAS(PKCS7_set_digest); STACK_OF(PKCS7_SIGNER_INFO) * PKCS7_get_signer_info(PKCS7 *p7) @@ -471,7 +471,7 @@ PKCS7_get_signer_info(PKCS7 *p7) } else return (NULL); } -LCRYPTO_ALIAS(PKCS7_get_signer_info) +LCRYPTO_ALIAS(PKCS7_get_signer_info); void PKCS7_SIGNER_INFO_get0_algs(PKCS7_SIGNER_INFO *si, EVP_PKEY **pk, @@ -484,7 +484,7 @@ PKCS7_SIGNER_INFO_get0_algs(PKCS7_SIGNER_INFO *si, EVP_PKEY **pk, if (psig) *psig = si->digest_enc_alg; } -LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_get0_algs) +LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_get0_algs); void PKCS7_RECIP_INFO_get0_alg(PKCS7_RECIP_INFO *ri, X509_ALGOR **penc) @@ -492,7 +492,7 @@ PKCS7_RECIP_INFO_get0_alg(PKCS7_RECIP_INFO *ri, X509_ALGOR **penc) if (penc) *penc = ri->key_enc_algor; } -LCRYPTO_ALIAS(PKCS7_RECIP_INFO_get0_alg) +LCRYPTO_ALIAS(PKCS7_RECIP_INFO_get0_alg); PKCS7_RECIP_INFO * PKCS7_add_recipient(PKCS7 *p7, X509 *x509) @@ -511,7 +511,7 @@ err: PKCS7_RECIP_INFO_free(ri); return NULL; } -LCRYPTO_ALIAS(PKCS7_add_recipient) +LCRYPTO_ALIAS(PKCS7_add_recipient); int PKCS7_add_recipient_info(PKCS7 *p7, PKCS7_RECIP_INFO *ri) @@ -536,7 +536,7 @@ PKCS7_add_recipient_info(PKCS7 *p7, PKCS7_RECIP_INFO *ri) return 0; return (1); } -LCRYPTO_ALIAS(PKCS7_add_recipient_info) +LCRYPTO_ALIAS(PKCS7_add_recipient_info); int PKCS7_RECIP_INFO_set(PKCS7_RECIP_INFO *p7i, X509 *x509) @@ -583,7 +583,7 @@ err: EVP_PKEY_free(pkey); return 0; } -LCRYPTO_ALIAS(PKCS7_RECIP_INFO_set) +LCRYPTO_ALIAS(PKCS7_RECIP_INFO_set); X509 * PKCS7_cert_from_signer_info(PKCS7 *p7, PKCS7_SIGNER_INFO *si) @@ -595,7 +595,7 @@ PKCS7_cert_from_signer_info(PKCS7 *p7, PKCS7_SIGNER_INFO *si) else return (NULL); } -LCRYPTO_ALIAS(PKCS7_cert_from_signer_info) +LCRYPTO_ALIAS(PKCS7_cert_from_signer_info); int PKCS7_set_cipher(PKCS7 *p7, const EVP_CIPHER *cipher) @@ -626,7 +626,7 @@ PKCS7_set_cipher(PKCS7 *p7, const EVP_CIPHER *cipher) ec->cipher = cipher; return 1; } -LCRYPTO_ALIAS(PKCS7_set_cipher) +LCRYPTO_ALIAS(PKCS7_set_cipher); int PKCS7_stream(unsigned char ***boundary, PKCS7 *p7) @@ -671,4 +671,4 @@ PKCS7_stream(unsigned char ***boundary, PKCS7 *p7) return 1; } -LCRYPTO_ALIAS(PKCS7_stream) +LCRYPTO_ALIAS(PKCS7_stream); diff --git a/lib/libcrypto/pkcs7/pk7_mime.c b/lib/libcrypto/pkcs7/pk7_mime.c index bf7d94584b3..d5bc031e694 100644 --- a/lib/libcrypto/pkcs7/pk7_mime.c +++ b/lib/libcrypto/pkcs7/pk7_mime.c @@ -1,4 +1,4 @@ -/* $OpenBSD: pk7_mime.c,v 1.14 2022/11/12 12:11:14 beck Exp $ */ +/* $OpenBSD: pk7_mime.c,v 1.15 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project. */ @@ -66,7 +66,7 @@ i2d_PKCS7_bio_stream(BIO *out, PKCS7 *p7, BIO *in, int flags) return i2d_ASN1_bio_stream(out, (ASN1_VALUE *)p7, in, flags, &PKCS7_it); } -LCRYPTO_ALIAS(i2d_PKCS7_bio_stream) +LCRYPTO_ALIAS(i2d_PKCS7_bio_stream); int PEM_write_bio_PKCS7_stream(BIO *out, PKCS7 *p7, BIO *in, int flags) @@ -74,7 +74,7 @@ PEM_write_bio_PKCS7_stream(BIO *out, PKCS7 *p7, BIO *in, int flags) return PEM_write_bio_ASN1_stream(out, (ASN1_VALUE *) p7, in, flags, "PKCS7", &PKCS7_it); } -LCRYPTO_ALIAS(PEM_write_bio_PKCS7_stream) +LCRYPTO_ALIAS(PEM_write_bio_PKCS7_stream); int SMIME_write_PKCS7(BIO *bio, PKCS7 *p7, BIO *data, int flags) @@ -92,11 +92,11 @@ SMIME_write_PKCS7(BIO *bio, PKCS7 *p7, BIO *data, int flags) return SMIME_write_ASN1(bio, (ASN1_VALUE *)p7, data, flags, ctype_nid, NID_undef, mdalgs, &PKCS7_it); } -LCRYPTO_ALIAS(SMIME_write_PKCS7) +LCRYPTO_ALIAS(SMIME_write_PKCS7); PKCS7 * SMIME_read_PKCS7(BIO *bio, BIO **bcont) { return (PKCS7 *)SMIME_read_ASN1(bio, bcont, &PKCS7_it); } -LCRYPTO_ALIAS(SMIME_read_PKCS7) +LCRYPTO_ALIAS(SMIME_read_PKCS7); diff --git a/lib/libcrypto/pkcs7/pk7_smime.c b/lib/libcrypto/pkcs7/pk7_smime.c index 4324cf384bf..c113ac39540 100644 --- a/lib/libcrypto/pkcs7/pk7_smime.c +++ b/lib/libcrypto/pkcs7/pk7_smime.c @@ -1,4 +1,4 @@ -/* $OpenBSD: pk7_smime.c,v 1.25 2022/11/26 16:08:54 tb Exp $ */ +/* $OpenBSD: pk7_smime.c,v 1.26 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project. */ @@ -111,7 +111,7 @@ err: PKCS7_free(p7); return NULL; } -LCRYPTO_ALIAS(PKCS7_sign) +LCRYPTO_ALIAS(PKCS7_sign); int PKCS7_final(PKCS7 *p7, BIO *data, int flags) @@ -140,7 +140,7 @@ err: return ret; } -LCRYPTO_ALIAS(PKCS7_final) +LCRYPTO_ALIAS(PKCS7_final); /* Check to see if a cipher exists and if so add S/MIME capabilities */ @@ -223,7 +223,7 @@ err: sk_X509_ALGOR_pop_free(smcap, X509_ALGOR_free); return NULL; } -LCRYPTO_ALIAS(PKCS7_sign_add_signer) +LCRYPTO_ALIAS(PKCS7_sign_add_signer); /* Search for a digest matching SignerInfo digest type and if found * copy across. @@ -426,7 +426,7 @@ err: return ret; } -LCRYPTO_ALIAS(PKCS7_verify) +LCRYPTO_ALIAS(PKCS7_verify); STACK_OF(X509) * PKCS7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs, int flags) @@ -485,7 +485,7 @@ PKCS7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs, int flags) } return signers; } -LCRYPTO_ALIAS(PKCS7_get0_signers) +LCRYPTO_ALIAS(PKCS7_get0_signers); /* Build a complete PKCS#7 enveloped data */ @@ -529,7 +529,7 @@ err: PKCS7_free(p7); return NULL; } -LCRYPTO_ALIAS(PKCS7_encrypt) +LCRYPTO_ALIAS(PKCS7_encrypt); int PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data, int flags) @@ -596,4 +596,4 @@ PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data, int flags) return ret; } } -LCRYPTO_ALIAS(PKCS7_decrypt) +LCRYPTO_ALIAS(PKCS7_decrypt); diff --git a/lib/libcrypto/pkcs7/pkcs7err.c b/lib/libcrypto/pkcs7/pkcs7err.c index d2eab2d7f6e..d3ca0ec6dfa 100644 --- a/lib/libcrypto/pkcs7/pkcs7err.c +++ b/lib/libcrypto/pkcs7/pkcs7err.c @@ -1,4 +1,4 @@ -/* $OpenBSD: pkcs7err.c,v 1.14 2022/11/12 12:11:14 beck Exp $ */ +/* $OpenBSD: pkcs7err.c,v 1.15 2023/02/16 08:38:17 tb Exp $ */ /* ==================================================================== * Copyright (c) 1999-2007 The OpenSSL Project. All rights reserved. * @@ -140,4 +140,4 @@ ERR_load_PKCS7_strings(void) } #endif } -LCRYPTO_ALIAS(ERR_load_PKCS7_strings) +LCRYPTO_ALIAS(ERR_load_PKCS7_strings); diff --git a/lib/libcrypto/stack/stack.c b/lib/libcrypto/stack/stack.c index c99941aa46f..bc5b2f6e837 100644 --- a/lib/libcrypto/stack/stack.c +++ b/lib/libcrypto/stack/stack.c @@ -1,4 +1,4 @@ -/* $OpenBSD: stack.c,v 1.21 2022/11/11 19:18:55 beck Exp $ */ +/* $OpenBSD: stack.c,v 1.22 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -79,7 +79,7 @@ int return old; } -LCRYPTO_ALIAS(sk_set_cmp_func) +LCRYPTO_ALIAS(sk_set_cmp_func); _STACK * sk_dup(_STACK *sk) @@ -106,14 +106,14 @@ err: sk_free(ret); return (NULL); } -LCRYPTO_ALIAS(sk_dup) +LCRYPTO_ALIAS(sk_dup); _STACK * sk_new_null(void) { return sk_new((int (*)(const void *, const void *))0); } -LCRYPTO_ALIAS(sk_new_null) +LCRYPTO_ALIAS(sk_new_null); _STACK * sk_new(int (*c)(const void *, const void *)) @@ -137,7 +137,7 @@ err: free(ret); return (NULL); } -LCRYPTO_ALIAS(sk_new) +LCRYPTO_ALIAS(sk_new); int sk_insert(_STACK *st, void *data, int loc) @@ -164,7 +164,7 @@ sk_insert(_STACK *st, void *data, int loc) st->sorted = 0; return (st->num); } -LCRYPTO_ALIAS(sk_insert) +LCRYPTO_ALIAS(sk_insert); void * sk_delete_ptr(_STACK *st, void *p) @@ -176,7 +176,7 @@ sk_delete_ptr(_STACK *st, void *p) return (sk_delete(st, i)); return (NULL); } -LCRYPTO_ALIAS(sk_delete_ptr) +LCRYPTO_ALIAS(sk_delete_ptr); void * sk_delete(_STACK *st, int loc) @@ -194,7 +194,7 @@ sk_delete(_STACK *st, int loc) st->num--; return (ret); } -LCRYPTO_ALIAS(sk_delete) +LCRYPTO_ALIAS(sk_delete); static int internal_find(_STACK *st, void *data, int ret_val_options) @@ -226,28 +226,28 @@ sk_find(_STACK *st, void *data) { return internal_find(st, data, OBJ_BSEARCH_FIRST_VALUE_ON_MATCH); } -LCRYPTO_ALIAS(sk_find) +LCRYPTO_ALIAS(sk_find); int sk_find_ex(_STACK *st, void *data) { return internal_find(st, data, OBJ_BSEARCH_VALUE_ON_NOMATCH); } -LCRYPTO_ALIAS(sk_find_ex) +LCRYPTO_ALIAS(sk_find_ex); int sk_push(_STACK *st, void *data) { return (sk_insert(st, data, st->num)); } -LCRYPTO_ALIAS(sk_push) +LCRYPTO_ALIAS(sk_push); int sk_unshift(_STACK *st, void *data) { return (sk_insert(st, data, 0)); } -LCRYPTO_ALIAS(sk_unshift) +LCRYPTO_ALIAS(sk_unshift); void * sk_shift(_STACK *st) @@ -258,7 +258,7 @@ sk_shift(_STACK *st) return (NULL); return (sk_delete(st, 0)); } -LCRYPTO_ALIAS(sk_shift) +LCRYPTO_ALIAS(sk_shift); void * sk_pop(_STACK *st) @@ -269,7 +269,7 @@ sk_pop(_STACK *st) return (NULL); return (sk_delete(st, st->num - 1)); } -LCRYPTO_ALIAS(sk_pop) +LCRYPTO_ALIAS(sk_pop); void sk_zero(_STACK *st) @@ -281,7 +281,7 @@ sk_zero(_STACK *st) memset(st->data, 0, sizeof(st->data)*st->num); st->num = 0; } -LCRYPTO_ALIAS(sk_zero) +LCRYPTO_ALIAS(sk_zero); void sk_pop_free(_STACK *st, void (*func)(void *)) @@ -295,7 +295,7 @@ sk_pop_free(_STACK *st, void (*func)(void *)) func(st->data[i]); sk_free(st); } -LCRYPTO_ALIAS(sk_pop_free) +LCRYPTO_ALIAS(sk_pop_free); void sk_free(_STACK *st) @@ -305,7 +305,7 @@ sk_free(_STACK *st) free(st->data); free(st); } -LCRYPTO_ALIAS(sk_free) +LCRYPTO_ALIAS(sk_free); int sk_num(const _STACK *st) @@ -314,7 +314,7 @@ sk_num(const _STACK *st) return -1; return st->num; } -LCRYPTO_ALIAS(sk_num) +LCRYPTO_ALIAS(sk_num); void * sk_value(const _STACK *st, int i) @@ -323,7 +323,7 @@ sk_value(const _STACK *st, int i) return NULL; return st->data[i]; } -LCRYPTO_ALIAS(sk_value) +LCRYPTO_ALIAS(sk_value); void * sk_set(_STACK *st, int i, void *value) @@ -333,7 +333,7 @@ sk_set(_STACK *st, int i, void *value) st->sorted = 0; return (st->data[i] = value); } -LCRYPTO_ALIAS(sk_set) +LCRYPTO_ALIAS(sk_set); void sk_sort(_STACK *st) @@ -351,7 +351,7 @@ sk_sort(_STACK *st) st->sorted = 1; } } -LCRYPTO_ALIAS(sk_sort) +LCRYPTO_ALIAS(sk_sort); int sk_is_sorted(const _STACK *st) @@ -360,4 +360,4 @@ sk_is_sorted(const _STACK *st) return 1; return st->sorted; } -LCRYPTO_ALIAS(sk_is_sorted) +LCRYPTO_ALIAS(sk_is_sorted); diff --git a/lib/libcrypto/ui/ui_err.c b/lib/libcrypto/ui/ui_err.c index a1207fb0c38..3f875da7767 100644 --- a/lib/libcrypto/ui/ui_err.c +++ b/lib/libcrypto/ui/ui_err.c @@ -1,4 +1,4 @@ -/* $OpenBSD: ui_err.c,v 1.11 2022/11/12 13:16:10 beck Exp $ */ +/* $OpenBSD: ui_err.c,v 1.12 2023/02/16 08:38:17 tb Exp $ */ /* ==================================================================== * Copyright (c) 1999-2006 The OpenSSL Project. All rights reserved. * @@ -93,4 +93,4 @@ ERR_load_UI_strings(void) } #endif } -LCRYPTO_ALIAS(ERR_load_UI_strings) +LCRYPTO_ALIAS(ERR_load_UI_strings); diff --git a/lib/libcrypto/ui/ui_lib.c b/lib/libcrypto/ui/ui_lib.c index 546540ad83e..73d899afcce 100644 --- a/lib/libcrypto/ui/ui_lib.c +++ b/lib/libcrypto/ui/ui_lib.c @@ -1,4 +1,4 @@ -/* $OpenBSD: ui_lib.c,v 1.50 2022/12/23 02:31:56 jsing Exp $ */ +/* $OpenBSD: ui_lib.c,v 1.51 2023/02/16 08:38:17 tb Exp $ */ /* Written by Richard Levitte (richard@levitte.org) for the OpenSSL * project 2001. */ @@ -73,7 +73,7 @@ UI_new(void) { return (UI_new_method(NULL)); } -LCRYPTO_ALIAS(UI_new) +LCRYPTO_ALIAS(UI_new); UI * UI_new_method(const UI_METHOD *method) @@ -90,7 +90,7 @@ UI_new_method(const UI_METHOD *method) return ret; } -LCRYPTO_ALIAS(UI_new_method) +LCRYPTO_ALIAS(UI_new_method); static void free_string(UI_STRING *uis) @@ -122,7 +122,7 @@ UI_free(UI *ui) CRYPTO_free_ex_data(CRYPTO_EX_INDEX_UI, ui, &ui->ex_data); free(ui); } -LCRYPTO_ALIAS(UI_free) +LCRYPTO_ALIAS(UI_free); static int allocate_string_stack(UI *ui) @@ -269,7 +269,7 @@ UI_add_input_string(UI *ui, const char *prompt, int flags, char *result_buf, return general_allocate_string(ui, prompt, 0, UIT_PROMPT, flags, result_buf, minsize, maxsize, NULL); } -LCRYPTO_ALIAS(UI_add_input_string) +LCRYPTO_ALIAS(UI_add_input_string); /* Same as UI_add_input_string(), excepts it takes a copy of the prompt. */ int @@ -279,7 +279,7 @@ UI_dup_input_string(UI *ui, const char *prompt, int flags, char *result_buf, return general_allocate_string(ui, prompt, 1, UIT_PROMPT, flags, result_buf, minsize, maxsize, NULL); } -LCRYPTO_ALIAS(UI_dup_input_string) +LCRYPTO_ALIAS(UI_dup_input_string); int UI_add_verify_string(UI *ui, const char *prompt, int flags, char *result_buf, @@ -288,7 +288,7 @@ UI_add_verify_string(UI *ui, const char *prompt, int flags, char *result_buf, return general_allocate_string(ui, prompt, 0, UIT_VERIFY, flags, result_buf, minsize, maxsize, test_buf); } -LCRYPTO_ALIAS(UI_add_verify_string) +LCRYPTO_ALIAS(UI_add_verify_string); int UI_dup_verify_string(UI *ui, const char *prompt, int flags, @@ -297,7 +297,7 @@ UI_dup_verify_string(UI *ui, const char *prompt, int flags, return general_allocate_string(ui, prompt, 1, UIT_VERIFY, flags, result_buf, minsize, maxsize, test_buf); } -LCRYPTO_ALIAS(UI_dup_verify_string) +LCRYPTO_ALIAS(UI_dup_verify_string); int UI_add_input_boolean(UI *ui, const char *prompt, const char *action_desc, @@ -306,7 +306,7 @@ UI_add_input_boolean(UI *ui, const char *prompt, const char *action_desc, return general_allocate_boolean(ui, prompt, action_desc, ok_chars, cancel_chars, 0, UIT_BOOLEAN, flags, result_buf); } -LCRYPTO_ALIAS(UI_add_input_boolean) +LCRYPTO_ALIAS(UI_add_input_boolean); int UI_dup_input_boolean(UI *ui, const char *prompt, const char *action_desc, @@ -315,7 +315,7 @@ UI_dup_input_boolean(UI *ui, const char *prompt, const char *action_desc, return general_allocate_boolean(ui, prompt, action_desc, ok_chars, cancel_chars, 1, UIT_BOOLEAN, flags, result_buf); } -LCRYPTO_ALIAS(UI_dup_input_boolean) +LCRYPTO_ALIAS(UI_dup_input_boolean); int UI_add_info_string(UI *ui, const char *text) @@ -323,7 +323,7 @@ UI_add_info_string(UI *ui, const char *text) return general_allocate_string(ui, text, 0, UIT_INFO, 0, NULL, 0, 0, NULL); } -LCRYPTO_ALIAS(UI_add_info_string) +LCRYPTO_ALIAS(UI_add_info_string); int UI_dup_info_string(UI *ui, const char *text) @@ -331,7 +331,7 @@ UI_dup_info_string(UI *ui, const char *text) return general_allocate_string(ui, text, 1, UIT_INFO, 0, NULL, 0, 0, NULL); } -LCRYPTO_ALIAS(UI_dup_info_string) +LCRYPTO_ALIAS(UI_dup_info_string); int UI_add_error_string(UI *ui, const char *text) @@ -339,7 +339,7 @@ UI_add_error_string(UI *ui, const char *text) return general_allocate_string(ui, text, 0, UIT_ERROR, 0, NULL, 0, 0, NULL); } -LCRYPTO_ALIAS(UI_add_error_string) +LCRYPTO_ALIAS(UI_add_error_string); int UI_dup_error_string(UI *ui, const char *text) @@ -347,7 +347,7 @@ UI_dup_error_string(UI *ui, const char *text) return general_allocate_string(ui, text, 1, UIT_ERROR, 0, NULL, 0, 0, NULL); } -LCRYPTO_ALIAS(UI_dup_error_string) +LCRYPTO_ALIAS(UI_dup_error_string); char * UI_construct_prompt(UI *ui, const char *object_desc, const char *object_name) @@ -372,7 +372,7 @@ UI_construct_prompt(UI *ui, const char *object_desc, const char *object_name) return prompt; } -LCRYPTO_ALIAS(UI_construct_prompt) +LCRYPTO_ALIAS(UI_construct_prompt); void * UI_add_user_data(UI *ui, void *user_data) @@ -383,14 +383,14 @@ UI_add_user_data(UI *ui, void *user_data) return old_data; } -LCRYPTO_ALIAS(UI_add_user_data) +LCRYPTO_ALIAS(UI_add_user_data); void * UI_get0_user_data(UI *ui) { return ui->user_data; } -LCRYPTO_ALIAS(UI_get0_user_data) +LCRYPTO_ALIAS(UI_get0_user_data); const char * UI_get0_result(UI *ui, int i) @@ -405,7 +405,7 @@ UI_get0_result(UI *ui, int i) } return UI_get0_result_string(sk_UI_STRING_value(ui->strings, i)); } -LCRYPTO_ALIAS(UI_get0_result) +LCRYPTO_ALIAS(UI_get0_result); static int print_error(const char *str, size_t len, void *arg) @@ -479,7 +479,7 @@ UI_process(UI *ui) return -1; return ok; } -LCRYPTO_ALIAS(UI_process) +LCRYPTO_ALIAS(UI_process); int UI_ctrl(UI *ui, int cmd, long i, void *p, void (*f) (void)) @@ -507,7 +507,7 @@ UI_ctrl(UI *ui, int cmd, long i, void *p, void (*f) (void)) UIerror(UI_R_UNKNOWN_CONTROL_COMMAND); return -1; } -LCRYPTO_ALIAS(UI_ctrl) +LCRYPTO_ALIAS(UI_ctrl); int UI_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, @@ -516,28 +516,28 @@ UI_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_UI, argl, argp, new_func, dup_func, free_func); } -LCRYPTO_ALIAS(UI_get_ex_new_index) +LCRYPTO_ALIAS(UI_get_ex_new_index); int UI_set_ex_data(UI *r, int idx, void *arg) { return (CRYPTO_set_ex_data(&r->ex_data, idx, arg)); } -LCRYPTO_ALIAS(UI_set_ex_data) +LCRYPTO_ALIAS(UI_set_ex_data); void * UI_get_ex_data(UI *r, int idx) { return (CRYPTO_get_ex_data(&r->ex_data, idx)); } -LCRYPTO_ALIAS(UI_get_ex_data) +LCRYPTO_ALIAS(UI_get_ex_data); void UI_set_default_method(const UI_METHOD *method) { default_UI_meth = method; } -LCRYPTO_ALIAS(UI_set_default_method) +LCRYPTO_ALIAS(UI_set_default_method); const UI_METHOD * UI_get_default_method(void) @@ -547,14 +547,14 @@ UI_get_default_method(void) return default_UI_meth; } -LCRYPTO_ALIAS(UI_get_default_method) +LCRYPTO_ALIAS(UI_get_default_method); const UI_METHOD * UI_get_method(UI *ui) { return ui->meth; } -LCRYPTO_ALIAS(UI_get_method) +LCRYPTO_ALIAS(UI_get_method); const UI_METHOD * UI_set_method(UI *ui, const UI_METHOD *method) @@ -563,7 +563,7 @@ UI_set_method(UI *ui, const UI_METHOD *method) return ui->meth; } -LCRYPTO_ALIAS(UI_set_method) +LCRYPTO_ALIAS(UI_set_method); UI_METHOD * UI_create_method(const char *name) @@ -585,7 +585,7 @@ UI_create_method(const char *name) return NULL; } -LCRYPTO_ALIAS(UI_create_method) +LCRYPTO_ALIAS(UI_create_method); void UI_destroy_method(UI_METHOD *method) @@ -596,7 +596,7 @@ UI_destroy_method(UI_METHOD *method) free(method->name); free(method); } -LCRYPTO_ALIAS(UI_destroy_method) +LCRYPTO_ALIAS(UI_destroy_method); int UI_method_set_opener(UI_METHOD *method, int (*opener)(UI *ui)) @@ -608,7 +608,7 @@ UI_method_set_opener(UI_METHOD *method, int (*opener)(UI *ui)) return 0; } -LCRYPTO_ALIAS(UI_method_set_opener) +LCRYPTO_ALIAS(UI_method_set_opener); int UI_method_set_writer(UI_METHOD *method, int (*writer)(UI *ui, UI_STRING *uis)) @@ -620,7 +620,7 @@ UI_method_set_writer(UI_METHOD *method, int (*writer)(UI *ui, UI_STRING *uis)) return 0; } -LCRYPTO_ALIAS(UI_method_set_writer) +LCRYPTO_ALIAS(UI_method_set_writer); int UI_method_set_flusher(UI_METHOD *method, int (*flusher)(UI *ui)) @@ -632,7 +632,7 @@ UI_method_set_flusher(UI_METHOD *method, int (*flusher)(UI *ui)) return 0; } -LCRYPTO_ALIAS(UI_method_set_flusher) +LCRYPTO_ALIAS(UI_method_set_flusher); int UI_method_set_reader(UI_METHOD *method, int (*reader)(UI *ui, UI_STRING *uis)) @@ -644,7 +644,7 @@ UI_method_set_reader(UI_METHOD *method, int (*reader)(UI *ui, UI_STRING *uis)) return 0; } -LCRYPTO_ALIAS(UI_method_set_reader) +LCRYPTO_ALIAS(UI_method_set_reader); int UI_method_set_closer(UI_METHOD *method, int (*closer)(UI *ui)) @@ -656,7 +656,7 @@ UI_method_set_closer(UI_METHOD *method, int (*closer)(UI *ui)) return 0; } -LCRYPTO_ALIAS(UI_method_set_closer) +LCRYPTO_ALIAS(UI_method_set_closer); int UI_method_set_prompt_constructor(UI_METHOD *method, @@ -670,7 +670,7 @@ UI_method_set_prompt_constructor(UI_METHOD *method, return 0; } -LCRYPTO_ALIAS(UI_method_set_prompt_constructor) +LCRYPTO_ALIAS(UI_method_set_prompt_constructor); int (*UI_method_get_opener(const UI_METHOD * method))(UI *) @@ -680,7 +680,7 @@ int return method->ui_open_session; } -LCRYPTO_ALIAS(UI_method_get_opener) +LCRYPTO_ALIAS(UI_method_get_opener); int (*UI_method_get_writer(const UI_METHOD *method))(UI *, UI_STRING *) @@ -690,7 +690,7 @@ int return method->ui_write_string; } -LCRYPTO_ALIAS(UI_method_get_writer) +LCRYPTO_ALIAS(UI_method_get_writer); int (*UI_method_get_flusher(const UI_METHOD *method)) (UI *) @@ -700,7 +700,7 @@ int return method->ui_flush; } -LCRYPTO_ALIAS(UI_method_get_flusher) +LCRYPTO_ALIAS(UI_method_get_flusher); int (*UI_method_get_reader(const UI_METHOD *method))(UI *, UI_STRING *) @@ -710,7 +710,7 @@ int return method->ui_read_string; } -LCRYPTO_ALIAS(UI_method_get_reader) +LCRYPTO_ALIAS(UI_method_get_reader); int (*UI_method_get_closer(const UI_METHOD *method))(UI *) @@ -720,7 +720,7 @@ int return method->ui_close_session; } -LCRYPTO_ALIAS(UI_method_get_closer) +LCRYPTO_ALIAS(UI_method_get_closer); char * (*UI_method_get_prompt_constructor(const UI_METHOD *method))(UI *, const char *, @@ -731,7 +731,7 @@ char * return method->ui_construct_prompt; } -LCRYPTO_ALIAS(UI_method_get_prompt_constructor) +LCRYPTO_ALIAS(UI_method_get_prompt_constructor); enum UI_string_types UI_get_string_type(UI_STRING *uis) @@ -741,7 +741,7 @@ UI_get_string_type(UI_STRING *uis) return uis->type; } -LCRYPTO_ALIAS(UI_get_string_type) +LCRYPTO_ALIAS(UI_get_string_type); int UI_get_input_flags(UI_STRING *uis) @@ -751,7 +751,7 @@ UI_get_input_flags(UI_STRING *uis) return uis->input_flags; } -LCRYPTO_ALIAS(UI_get_input_flags) +LCRYPTO_ALIAS(UI_get_input_flags); const char * UI_get0_output_string(UI_STRING *uis) @@ -761,7 +761,7 @@ UI_get0_output_string(UI_STRING *uis) return uis->out_string; } -LCRYPTO_ALIAS(UI_get0_output_string) +LCRYPTO_ALIAS(UI_get0_output_string); const char * UI_get0_action_string(UI_STRING *uis) @@ -777,7 +777,7 @@ UI_get0_action_string(UI_STRING *uis) return NULL; } } -LCRYPTO_ALIAS(UI_get0_action_string) +LCRYPTO_ALIAS(UI_get0_action_string); const char * UI_get0_result_string(UI_STRING *uis) @@ -793,7 +793,7 @@ UI_get0_result_string(UI_STRING *uis) return NULL; } } -LCRYPTO_ALIAS(UI_get0_result_string) +LCRYPTO_ALIAS(UI_get0_result_string); const char * UI_get0_test_string(UI_STRING *uis) @@ -808,7 +808,7 @@ UI_get0_test_string(UI_STRING *uis) return NULL; } } -LCRYPTO_ALIAS(UI_get0_test_string) +LCRYPTO_ALIAS(UI_get0_test_string); int UI_get_result_minsize(UI_STRING *uis) @@ -824,7 +824,7 @@ UI_get_result_minsize(UI_STRING *uis) return -1; } } -LCRYPTO_ALIAS(UI_get_result_minsize) +LCRYPTO_ALIAS(UI_get_result_minsize); int UI_get_result_maxsize(UI_STRING *uis) @@ -840,7 +840,7 @@ UI_get_result_maxsize(UI_STRING *uis) return -1; } } -LCRYPTO_ALIAS(UI_get_result_maxsize) +LCRYPTO_ALIAS(UI_get_result_maxsize); int UI_set_result(UI *ui, UI_STRING *uis, const char *result) @@ -904,4 +904,4 @@ UI_set_result(UI *ui, UI_STRING *uis, const char *result) } return 0; } -LCRYPTO_ALIAS(UI_set_result) +LCRYPTO_ALIAS(UI_set_result); diff --git a/lib/libcrypto/ui/ui_null.c b/lib/libcrypto/ui/ui_null.c index 7bb7a90b2fb..cbc9a5025bf 100644 --- a/lib/libcrypto/ui/ui_null.c +++ b/lib/libcrypto/ui/ui_null.c @@ -1,4 +1,4 @@ -/* $OpenBSD: ui_null.c,v 1.1 2022/12/17 21:59:39 tb Exp $ */ +/* $OpenBSD: ui_null.c,v 1.2 2023/02/16 08:38:17 tb Exp $ */ /* * Written by Theo Buehler. Public domain. @@ -15,4 +15,4 @@ UI_null(void) { return &ui_null; } -LCRYPTO_ALIAS(UI_null) +LCRYPTO_ALIAS(UI_null); diff --git a/lib/libcrypto/ui/ui_openssl.c b/lib/libcrypto/ui/ui_openssl.c index 0d2e6f1ac86..0b91700571a 100644 --- a/lib/libcrypto/ui/ui_openssl.c +++ b/lib/libcrypto/ui/ui_openssl.c @@ -1,4 +1,4 @@ -/* $OpenBSD: ui_openssl.c,v 1.27 2022/11/26 16:08:54 tb Exp $ */ +/* $OpenBSD: ui_openssl.c,v 1.28 2023/02/16 08:38:17 tb Exp $ */ /* Written by Richard Levitte (richard@levitte.org) and others * for the OpenSSL project 2001. */ @@ -167,7 +167,7 @@ UI_OpenSSL(void) { return &ui_openssl; } -LCRYPTO_ALIAS(UI_OpenSSL) +LCRYPTO_ALIAS(UI_OpenSSL); /* The following function makes sure that info and error strings are printed before any prompt. */ diff --git a/lib/libcrypto/ui/ui_util.c b/lib/libcrypto/ui/ui_util.c index 5e7048531cc..4fa4058cd46 100644 --- a/lib/libcrypto/ui/ui_util.c +++ b/lib/libcrypto/ui/ui_util.c @@ -1,4 +1,4 @@ -/* $OpenBSD: ui_util.c,v 1.13 2022/12/23 02:20:28 jsing Exp $ */ +/* $OpenBSD: ui_util.c,v 1.14 2023/02/16 08:38:17 tb Exp $ */ /* ==================================================================== * Copyright (c) 2001-2002 The OpenSSL Project. All rights reserved. * @@ -70,7 +70,7 @@ UI_UTIL_read_pw_string(char *buf, int length, const char *prompt, int verify) explicit_bzero(buff, BUFSIZ); return (ret); } -LCRYPTO_ALIAS(UI_UTIL_read_pw_string) +LCRYPTO_ALIAS(UI_UTIL_read_pw_string); int UI_UTIL_read_pw(char *buf, char *buff, int size, const char *prompt, int verify) @@ -95,4 +95,4 @@ UI_UTIL_read_pw(char *buf, char *buff, int size, const char *prompt, int verify) ok = 0; return (ok); } -LCRYPTO_ALIAS(UI_UTIL_read_pw) +LCRYPTO_ALIAS(UI_UTIL_read_pw); diff --git a/lib/libcrypto/x509/by_dir.c b/lib/libcrypto/x509/by_dir.c index 341c252ea94..9fa6a100480 100644 --- a/lib/libcrypto/x509/by_dir.c +++ b/lib/libcrypto/x509/by_dir.c @@ -1,4 +1,4 @@ -/* $OpenBSD: by_dir.c,v 1.43 2022/11/26 16:08:54 tb Exp $ */ +/* $OpenBSD: by_dir.c,v 1.44 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -117,7 +117,7 @@ X509_LOOKUP_hash_dir(void) { return &x509_dir_lookup; } -LCRYPTO_ALIAS(X509_LOOKUP_hash_dir) +LCRYPTO_ALIAS(X509_LOOKUP_hash_dir); static int dir_ctrl(X509_LOOKUP *ctx, int cmd, const char *argp, long argl, diff --git a/lib/libcrypto/x509/by_file.c b/lib/libcrypto/x509/by_file.c index 70a2a62a97a..606f4c8d0c9 100644 --- a/lib/libcrypto/x509/by_file.c +++ b/lib/libcrypto/x509/by_file.c @@ -1,4 +1,4 @@ -/* $OpenBSD: by_file.c,v 1.27 2022/11/26 16:08:54 tb Exp $ */ +/* $OpenBSD: by_file.c,v 1.28 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -89,7 +89,7 @@ X509_LOOKUP_file(void) { return &x509_file_lookup; } -LCRYPTO_ALIAS(X509_LOOKUP_file) +LCRYPTO_ALIAS(X509_LOOKUP_file); static int by_file_ctrl(X509_LOOKUP *ctx, int cmd, const char *argp, long argl, @@ -174,7 +174,7 @@ err: BIO_free(in); return ret; } -LCRYPTO_ALIAS(X509_load_cert_file) +LCRYPTO_ALIAS(X509_load_cert_file); int X509_load_crl_file(X509_LOOKUP *ctx, const char *file, int type) @@ -231,7 +231,7 @@ err: BIO_free(in); return ret; } -LCRYPTO_ALIAS(X509_load_crl_file) +LCRYPTO_ALIAS(X509_load_crl_file); int X509_load_cert_crl_file(X509_LOOKUP *ctx, const char *file, int type) @@ -270,4 +270,4 @@ X509_load_cert_crl_file(X509_LOOKUP *ctx, const char *file, int type) sk_X509_INFO_pop_free(inf, X509_INFO_free); return count; } -LCRYPTO_ALIAS(X509_load_cert_crl_file) +LCRYPTO_ALIAS(X509_load_cert_crl_file); diff --git a/lib/libcrypto/x509/by_mem.c b/lib/libcrypto/x509/by_mem.c index 8f0a93fce3e..579eecd36de 100644 --- a/lib/libcrypto/x509/by_mem.c +++ b/lib/libcrypto/x509/by_mem.c @@ -1,4 +1,4 @@ -/* $OpenBSD: by_mem.c,v 1.7 2022/11/26 16:08:54 tb Exp $ */ +/* $OpenBSD: by_mem.c,v 1.8 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -90,7 +90,7 @@ X509_LOOKUP_mem(void) { return (&x509_mem_lookup); } -LCRYPTO_ALIAS(X509_LOOKUP_mem) +LCRYPTO_ALIAS(X509_LOOKUP_mem); static int by_mem_ctrl(X509_LOOKUP *lu, int cmd, const char *buf, diff --git a/lib/libcrypto/x509/pcy_lib.c b/lib/libcrypto/x509/pcy_lib.c index e4b06e988bc..e4d3fd9fa84 100644 --- a/lib/libcrypto/x509/pcy_lib.c +++ b/lib/libcrypto/x509/pcy_lib.c @@ -1,4 +1,4 @@ -/* $OpenBSD: pcy_lib.c,v 1.2 2022/11/14 17:48:49 beck Exp $ */ +/* $OpenBSD: pcy_lib.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 2004. */ @@ -72,7 +72,7 @@ X509_policy_tree_level_count(const X509_POLICY_TREE *tree) return 0; return tree->nlevel; } -LCRYPTO_ALIAS(X509_policy_tree_level_count) +LCRYPTO_ALIAS(X509_policy_tree_level_count); X509_POLICY_LEVEL * X509_policy_tree_get0_level(const X509_POLICY_TREE *tree, int i) @@ -81,7 +81,7 @@ X509_policy_tree_get0_level(const X509_POLICY_TREE *tree, int i) return NULL; return tree->levels + i; } -LCRYPTO_ALIAS(X509_policy_tree_get0_level) +LCRYPTO_ALIAS(X509_policy_tree_get0_level); STACK_OF(X509_POLICY_NODE) * X509_policy_tree_get0_policies(const X509_POLICY_TREE *tree) @@ -90,7 +90,7 @@ X509_policy_tree_get0_policies(const X509_POLICY_TREE *tree) return NULL; return tree->auth_policies; } -LCRYPTO_ALIAS(X509_policy_tree_get0_policies) +LCRYPTO_ALIAS(X509_policy_tree_get0_policies); STACK_OF(X509_POLICY_NODE) * X509_policy_tree_get0_user_policies(const X509_POLICY_TREE *tree) @@ -102,7 +102,7 @@ X509_policy_tree_get0_user_policies(const X509_POLICY_TREE *tree) else return tree->user_policies; } -LCRYPTO_ALIAS(X509_policy_tree_get0_user_policies) +LCRYPTO_ALIAS(X509_policy_tree_get0_user_policies); /* X509_POLICY_LEVEL stuff */ @@ -120,7 +120,7 @@ X509_policy_level_node_count(X509_POLICY_LEVEL *level) n += sk_X509_POLICY_NODE_num(level->nodes); return n; } -LCRYPTO_ALIAS(X509_policy_level_node_count) +LCRYPTO_ALIAS(X509_policy_level_node_count); X509_POLICY_NODE * X509_policy_level_get0_node(X509_POLICY_LEVEL *level, int i) @@ -134,7 +134,7 @@ X509_policy_level_get0_node(X509_POLICY_LEVEL *level, int i) } return sk_X509_POLICY_NODE_value(level->nodes, i); } -LCRYPTO_ALIAS(X509_policy_level_get0_node) +LCRYPTO_ALIAS(X509_policy_level_get0_node); /* X509_POLICY_NODE stuff */ @@ -145,7 +145,7 @@ X509_policy_node_get0_policy(const X509_POLICY_NODE *node) return NULL; return node->data->valid_policy; } -LCRYPTO_ALIAS(X509_policy_node_get0_policy) +LCRYPTO_ALIAS(X509_policy_node_get0_policy); STACK_OF(POLICYQUALINFO) * X509_policy_node_get0_qualifiers(const X509_POLICY_NODE *node) @@ -154,7 +154,7 @@ X509_policy_node_get0_qualifiers(const X509_POLICY_NODE *node) return NULL; return node->data->qualifier_set; } -LCRYPTO_ALIAS(X509_policy_node_get0_qualifiers) +LCRYPTO_ALIAS(X509_policy_node_get0_qualifiers); const X509_POLICY_NODE * X509_policy_node_get0_parent(const X509_POLICY_NODE *node) @@ -163,4 +163,4 @@ X509_policy_node_get0_parent(const X509_POLICY_NODE *node) return NULL; return node->parent; } -LCRYPTO_ALIAS(X509_policy_node_get0_parent) +LCRYPTO_ALIAS(X509_policy_node_get0_parent); diff --git a/lib/libcrypto/x509/pcy_tree.c b/lib/libcrypto/x509/pcy_tree.c index 050503bdf3f..56e05910cd6 100644 --- a/lib/libcrypto/x509/pcy_tree.c +++ b/lib/libcrypto/x509/pcy_tree.c @@ -1,4 +1,4 @@ -/* $OpenBSD: pcy_tree.c,v 1.5 2022/12/26 07:18:53 jmc Exp $ */ +/* $OpenBSD: pcy_tree.c,v 1.6 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 2004. */ @@ -657,7 +657,7 @@ X509_policy_tree_free(X509_POLICY_TREE *tree) free(tree->levels); free(tree); } -LCRYPTO_ALIAS(X509_policy_tree_free) +LCRYPTO_ALIAS(X509_policy_tree_free); /* Application policy checking function. * Return codes: @@ -770,4 +770,4 @@ error: return 0; } -LCRYPTO_ALIAS(X509_policy_check) +LCRYPTO_ALIAS(X509_policy_check); diff --git a/lib/libcrypto/x509/x509_addr.c b/lib/libcrypto/x509/x509_addr.c index 510ea4e697f..2d8cc0b3180 100644 --- a/lib/libcrypto/x509/x509_addr.c +++ b/lib/libcrypto/x509/x509_addr.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_addr.c,v 1.85 2022/11/26 16:08:54 tb Exp $ */ +/* $OpenBSD: x509_addr.c,v 1.86 2023/02/16 08:38:17 tb Exp $ */ /* * Contributed to the OpenSSL Project by the American Registry for * Internet Numbers ("ARIN"). @@ -215,28 +215,28 @@ d2i_IPAddressRange(IPAddressRange **a, const unsigned char **in, long len) return (IPAddressRange *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &IPAddressRange_it); } -LCRYPTO_ALIAS(d2i_IPAddressRange) +LCRYPTO_ALIAS(d2i_IPAddressRange); int i2d_IPAddressRange(IPAddressRange *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &IPAddressRange_it); } -LCRYPTO_ALIAS(i2d_IPAddressRange) +LCRYPTO_ALIAS(i2d_IPAddressRange); IPAddressRange * IPAddressRange_new(void) { return (IPAddressRange *)ASN1_item_new(&IPAddressRange_it); } -LCRYPTO_ALIAS(IPAddressRange_new) +LCRYPTO_ALIAS(IPAddressRange_new); void IPAddressRange_free(IPAddressRange *a) { ASN1_item_free((ASN1_VALUE *)a, &IPAddressRange_it); } -LCRYPTO_ALIAS(IPAddressRange_free) +LCRYPTO_ALIAS(IPAddressRange_free); IPAddressOrRange * d2i_IPAddressOrRange(IPAddressOrRange **a, const unsigned char **in, long len) @@ -244,28 +244,28 @@ d2i_IPAddressOrRange(IPAddressOrRange **a, const unsigned char **in, long len) return (IPAddressOrRange *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &IPAddressOrRange_it); } -LCRYPTO_ALIAS(d2i_IPAddressOrRange) +LCRYPTO_ALIAS(d2i_IPAddressOrRange); int i2d_IPAddressOrRange(IPAddressOrRange *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &IPAddressOrRange_it); } -LCRYPTO_ALIAS(i2d_IPAddressOrRange) +LCRYPTO_ALIAS(i2d_IPAddressOrRange); IPAddressOrRange * IPAddressOrRange_new(void) { return (IPAddressOrRange *)ASN1_item_new(&IPAddressOrRange_it); } -LCRYPTO_ALIAS(IPAddressOrRange_new) +LCRYPTO_ALIAS(IPAddressOrRange_new); void IPAddressOrRange_free(IPAddressOrRange *a) { ASN1_item_free((ASN1_VALUE *)a, &IPAddressOrRange_it); } -LCRYPTO_ALIAS(IPAddressOrRange_free) +LCRYPTO_ALIAS(IPAddressOrRange_free); IPAddressChoice * d2i_IPAddressChoice(IPAddressChoice **a, const unsigned char **in, long len) @@ -273,28 +273,28 @@ d2i_IPAddressChoice(IPAddressChoice **a, const unsigned char **in, long len) return (IPAddressChoice *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &IPAddressChoice_it); } -LCRYPTO_ALIAS(d2i_IPAddressChoice) +LCRYPTO_ALIAS(d2i_IPAddressChoice); int i2d_IPAddressChoice(IPAddressChoice *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &IPAddressChoice_it); } -LCRYPTO_ALIAS(i2d_IPAddressChoice) +LCRYPTO_ALIAS(i2d_IPAddressChoice); IPAddressChoice * IPAddressChoice_new(void) { return (IPAddressChoice *)ASN1_item_new(&IPAddressChoice_it); } -LCRYPTO_ALIAS(IPAddressChoice_new) +LCRYPTO_ALIAS(IPAddressChoice_new); void IPAddressChoice_free(IPAddressChoice *a) { ASN1_item_free((ASN1_VALUE *)a, &IPAddressChoice_it); } -LCRYPTO_ALIAS(IPAddressChoice_free) +LCRYPTO_ALIAS(IPAddressChoice_free); IPAddressFamily * d2i_IPAddressFamily(IPAddressFamily **a, const unsigned char **in, long len) @@ -302,28 +302,28 @@ d2i_IPAddressFamily(IPAddressFamily **a, const unsigned char **in, long len) return (IPAddressFamily *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &IPAddressFamily_it); } -LCRYPTO_ALIAS(d2i_IPAddressFamily) +LCRYPTO_ALIAS(d2i_IPAddressFamily); int i2d_IPAddressFamily(IPAddressFamily *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &IPAddressFamily_it); } -LCRYPTO_ALIAS(i2d_IPAddressFamily) +LCRYPTO_ALIAS(i2d_IPAddressFamily); IPAddressFamily * IPAddressFamily_new(void) { return (IPAddressFamily *)ASN1_item_new(&IPAddressFamily_it); } -LCRYPTO_ALIAS(IPAddressFamily_new) +LCRYPTO_ALIAS(IPAddressFamily_new); void IPAddressFamily_free(IPAddressFamily *a) { ASN1_item_free((ASN1_VALUE *)a, &IPAddressFamily_it); } -LCRYPTO_ALIAS(IPAddressFamily_free) +LCRYPTO_ALIAS(IPAddressFamily_free); /* * Convenience accessors for IPAddressFamily. @@ -534,7 +534,7 @@ X509v3_addr_get_afi(const IPAddressFamily *af) return afi; } -LCRYPTO_ALIAS(X509v3_addr_get_afi) +LCRYPTO_ALIAS(X509v3_addr_get_afi); /* * Expand the bitstring form (RFC 3779, section 2.1.2) of an address into @@ -1110,7 +1110,7 @@ X509v3_addr_add_inherit(IPAddrBlocks *addr, const unsigned afi, return IPAddressFamily_set_inheritance(af); } -LCRYPTO_ALIAS(X509v3_addr_add_inherit) +LCRYPTO_ALIAS(X509v3_addr_add_inherit); /* * Construct an IPAddressOrRange sequence, or return an existing one. @@ -1174,7 +1174,7 @@ X509v3_addr_add_prefix(IPAddrBlocks *addr, const unsigned afi, return 1; } -LCRYPTO_ALIAS(X509v3_addr_add_prefix) +LCRYPTO_ALIAS(X509v3_addr_add_prefix); /* * Add a range. @@ -1202,7 +1202,7 @@ X509v3_addr_add_range(IPAddrBlocks *addr, const unsigned afi, return 1; } -LCRYPTO_ALIAS(X509v3_addr_add_range) +LCRYPTO_ALIAS(X509v3_addr_add_range); static int extract_min_max_bitstr(IPAddressOrRange *aor, ASN1_BIT_STRING **out_min, @@ -1262,7 +1262,7 @@ X509v3_addr_get_range(IPAddressOrRange *aor, const unsigned afi, return afi_len; } -LCRYPTO_ALIAS(X509v3_addr_get_range) +LCRYPTO_ALIAS(X509v3_addr_get_range); /* * Check whether an IPAddrBLocks is in canonical form. @@ -1381,7 +1381,7 @@ X509v3_addr_is_canonical(IPAddrBlocks *addr) */ return 1; } -LCRYPTO_ALIAS(X509v3_addr_is_canonical) +LCRYPTO_ALIAS(X509v3_addr_is_canonical); /* * Whack an IPAddressOrRanges into canonical form. @@ -1488,7 +1488,7 @@ X509v3_addr_canonize(IPAddrBlocks *addr) return X509v3_addr_is_canonical(addr); } -LCRYPTO_ALIAS(X509v3_addr_canonize) +LCRYPTO_ALIAS(X509v3_addr_canonize); /* * v2i handler for the IPAddrBlocks extension. @@ -1732,7 +1732,7 @@ X509v3_addr_inherits(IPAddrBlocks *addr) return 0; } -LCRYPTO_ALIAS(X509v3_addr_inherits) +LCRYPTO_ALIAS(X509v3_addr_inherits); /* * Figure out whether parent contains child. @@ -1816,7 +1816,7 @@ X509v3_addr_subset(IPAddrBlocks *child, IPAddrBlocks *parent) } return 1; } -LCRYPTO_ALIAS(X509v3_addr_subset) +LCRYPTO_ALIAS(X509v3_addr_subset); static int verify_error(X509_STORE_CTX *ctx, X509 *cert, int error, int depth) @@ -2022,7 +2022,7 @@ X509v3_addr_validate_path(X509_STORE_CTX *ctx) } return addr_validate_path_internal(ctx, ctx->chain, NULL); } -LCRYPTO_ALIAS(X509v3_addr_validate_path) +LCRYPTO_ALIAS(X509v3_addr_validate_path); /* * RFC 3779 2.3 path validation of an extension. @@ -2040,6 +2040,6 @@ X509v3_addr_validate_resource_set(STACK_OF(X509) *chain, IPAddrBlocks *ext, return 0; return addr_validate_path_internal(NULL, chain, ext); } -LCRYPTO_ALIAS(X509v3_addr_validate_resource_set) +LCRYPTO_ALIAS(X509v3_addr_validate_resource_set); #endif /* OPENSSL_NO_RFC3779 */ diff --git a/lib/libcrypto/x509/x509_akeya.c b/lib/libcrypto/x509/x509_akeya.c index 969cad1c3e1..52eca42cffd 100644 --- a/lib/libcrypto/x509/x509_akeya.c +++ b/lib/libcrypto/x509/x509_akeya.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_akeya.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */ +/* $OpenBSD: x509_akeya.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -104,25 +104,25 @@ d2i_AUTHORITY_KEYID(AUTHORITY_KEYID **a, const unsigned char **in, long len) return (AUTHORITY_KEYID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &AUTHORITY_KEYID_it); } -LCRYPTO_ALIAS(d2i_AUTHORITY_KEYID) +LCRYPTO_ALIAS(d2i_AUTHORITY_KEYID); int i2d_AUTHORITY_KEYID(AUTHORITY_KEYID *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &AUTHORITY_KEYID_it); } -LCRYPTO_ALIAS(i2d_AUTHORITY_KEYID) +LCRYPTO_ALIAS(i2d_AUTHORITY_KEYID); AUTHORITY_KEYID * AUTHORITY_KEYID_new(void) { return (AUTHORITY_KEYID *)ASN1_item_new(&AUTHORITY_KEYID_it); } -LCRYPTO_ALIAS(AUTHORITY_KEYID_new) +LCRYPTO_ALIAS(AUTHORITY_KEYID_new); void AUTHORITY_KEYID_free(AUTHORITY_KEYID *a) { ASN1_item_free((ASN1_VALUE *)a, &AUTHORITY_KEYID_it); } -LCRYPTO_ALIAS(AUTHORITY_KEYID_free) +LCRYPTO_ALIAS(AUTHORITY_KEYID_free); diff --git a/lib/libcrypto/x509/x509_alt.c b/lib/libcrypto/x509/x509_alt.c index 137a1c1c11e..c4c5fcabe74 100644 --- a/lib/libcrypto/x509/x509_alt.c +++ b/lib/libcrypto/x509/x509_alt.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_alt.c,v 1.14 2022/11/14 17:48:50 beck Exp $ */ +/* $OpenBSD: x509_alt.c,v 1.15 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project. */ @@ -152,7 +152,7 @@ i2v_GENERAL_NAMES(X509V3_EXT_METHOD *method, GENERAL_NAMES *gens, return NULL; } -LCRYPTO_ALIAS(i2v_GENERAL_NAMES) +LCRYPTO_ALIAS(i2v_GENERAL_NAMES); STACK_OF(CONF_VALUE) * i2v_GENERAL_NAME(X509V3_EXT_METHOD *method, GENERAL_NAME *gen, @@ -245,7 +245,7 @@ i2v_GENERAL_NAME(X509V3_EXT_METHOD *method, GENERAL_NAME *gen, return NULL; } -LCRYPTO_ALIAS(i2v_GENERAL_NAME) +LCRYPTO_ALIAS(i2v_GENERAL_NAME); int GENERAL_NAME_print(BIO *out, GENERAL_NAME *gen) @@ -312,7 +312,7 @@ GENERAL_NAME_print(BIO *out, GENERAL_NAME *gen) } return 1; } -LCRYPTO_ALIAS(GENERAL_NAME_print) +LCRYPTO_ALIAS(GENERAL_NAME_print); static GENERAL_NAMES * v2i_issuer_alt(X509V3_EXT_METHOD *method, X509V3_CTX *ctx, @@ -515,7 +515,7 @@ err: sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free); return NULL; } -LCRYPTO_ALIAS(v2i_GENERAL_NAMES) +LCRYPTO_ALIAS(v2i_GENERAL_NAMES); GENERAL_NAME * v2i_GENERAL_NAME(const X509V3_EXT_METHOD *method, X509V3_CTX *ctx, @@ -523,7 +523,7 @@ v2i_GENERAL_NAME(const X509V3_EXT_METHOD *method, X509V3_CTX *ctx, { return v2i_GENERAL_NAME_ex(NULL, method, ctx, cnf, 0); } -LCRYPTO_ALIAS(v2i_GENERAL_NAME) +LCRYPTO_ALIAS(v2i_GENERAL_NAME); GENERAL_NAME * a2i_GENERAL_NAME(GENERAL_NAME *out, const X509V3_EXT_METHOD *method, @@ -614,7 +614,7 @@ err: GENERAL_NAME_free(gen); return NULL; } -LCRYPTO_ALIAS(a2i_GENERAL_NAME) +LCRYPTO_ALIAS(a2i_GENERAL_NAME); GENERAL_NAME * v2i_GENERAL_NAME_ex(GENERAL_NAME *out, const X509V3_EXT_METHOD *method, @@ -718,7 +718,7 @@ v2i_GENERAL_NAME_ex(GENERAL_NAME *out, const X509V3_EXT_METHOD *method, GENERAL_NAME_free(ret); return NULL; } -LCRYPTO_ALIAS(v2i_GENERAL_NAME_ex) +LCRYPTO_ALIAS(v2i_GENERAL_NAME_ex); static int do_othername(GENERAL_NAME *gen, const char *value, X509V3_CTX *ctx) diff --git a/lib/libcrypto/x509/x509_asid.c b/lib/libcrypto/x509/x509_asid.c index 3a37b002f2b..cc36cc1a566 100644 --- a/lib/libcrypto/x509/x509_asid.c +++ b/lib/libcrypto/x509/x509_asid.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_asid.c,v 1.38 2022/11/26 16:08:54 tb Exp $ */ +/* $OpenBSD: x509_asid.c,v 1.39 2023/02/16 08:38:17 tb Exp $ */ /* * Contributed to the OpenSSL Project by the American Registry for * Internet Numbers ("ARIN"). @@ -191,28 +191,28 @@ d2i_ASRange(ASRange **a, const unsigned char **in, long len) return (ASRange *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &ASRange_it); } -LCRYPTO_ALIAS(d2i_ASRange) +LCRYPTO_ALIAS(d2i_ASRange); int i2d_ASRange(ASRange *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASRange_it); } -LCRYPTO_ALIAS(i2d_ASRange) +LCRYPTO_ALIAS(i2d_ASRange); ASRange * ASRange_new(void) { return (ASRange *)ASN1_item_new(&ASRange_it); } -LCRYPTO_ALIAS(ASRange_new) +LCRYPTO_ALIAS(ASRange_new); void ASRange_free(ASRange *a) { ASN1_item_free((ASN1_VALUE *)a, &ASRange_it); } -LCRYPTO_ALIAS(ASRange_free) +LCRYPTO_ALIAS(ASRange_free); ASIdOrRange * d2i_ASIdOrRange(ASIdOrRange **a, const unsigned char **in, long len) @@ -220,28 +220,28 @@ d2i_ASIdOrRange(ASIdOrRange **a, const unsigned char **in, long len) return (ASIdOrRange *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &ASIdOrRange_it); } -LCRYPTO_ALIAS(d2i_ASIdOrRange) +LCRYPTO_ALIAS(d2i_ASIdOrRange); int i2d_ASIdOrRange(ASIdOrRange *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASIdOrRange_it); } -LCRYPTO_ALIAS(i2d_ASIdOrRange) +LCRYPTO_ALIAS(i2d_ASIdOrRange); ASIdOrRange * ASIdOrRange_new(void) { return (ASIdOrRange *)ASN1_item_new(&ASIdOrRange_it); } -LCRYPTO_ALIAS(ASIdOrRange_new) +LCRYPTO_ALIAS(ASIdOrRange_new); void ASIdOrRange_free(ASIdOrRange *a) { ASN1_item_free((ASN1_VALUE *)a, &ASIdOrRange_it); } -LCRYPTO_ALIAS(ASIdOrRange_free) +LCRYPTO_ALIAS(ASIdOrRange_free); ASIdentifierChoice * d2i_ASIdentifierChoice(ASIdentifierChoice **a, const unsigned char **in, @@ -250,28 +250,28 @@ d2i_ASIdentifierChoice(ASIdentifierChoice **a, const unsigned char **in, return (ASIdentifierChoice *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &ASIdentifierChoice_it); } -LCRYPTO_ALIAS(d2i_ASIdentifierChoice) +LCRYPTO_ALIAS(d2i_ASIdentifierChoice); int i2d_ASIdentifierChoice(ASIdentifierChoice *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASIdentifierChoice_it); } -LCRYPTO_ALIAS(i2d_ASIdentifierChoice) +LCRYPTO_ALIAS(i2d_ASIdentifierChoice); ASIdentifierChoice * ASIdentifierChoice_new(void) { return (ASIdentifierChoice *)ASN1_item_new(&ASIdentifierChoice_it); } -LCRYPTO_ALIAS(ASIdentifierChoice_new) +LCRYPTO_ALIAS(ASIdentifierChoice_new); void ASIdentifierChoice_free(ASIdentifierChoice *a) { ASN1_item_free((ASN1_VALUE *)a, &ASIdentifierChoice_it); } -LCRYPTO_ALIAS(ASIdentifierChoice_free) +LCRYPTO_ALIAS(ASIdentifierChoice_free); ASIdentifiers * d2i_ASIdentifiers(ASIdentifiers **a, const unsigned char **in, long len) @@ -279,28 +279,28 @@ d2i_ASIdentifiers(ASIdentifiers **a, const unsigned char **in, long len) return (ASIdentifiers *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &ASIdentifiers_it); } -LCRYPTO_ALIAS(d2i_ASIdentifiers) +LCRYPTO_ALIAS(d2i_ASIdentifiers); int i2d_ASIdentifiers(ASIdentifiers *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASIdentifiers_it); } -LCRYPTO_ALIAS(i2d_ASIdentifiers) +LCRYPTO_ALIAS(i2d_ASIdentifiers); ASIdentifiers * ASIdentifiers_new(void) { return (ASIdentifiers *)ASN1_item_new(&ASIdentifiers_it); } -LCRYPTO_ALIAS(ASIdentifiers_new) +LCRYPTO_ALIAS(ASIdentifiers_new); void ASIdentifiers_free(ASIdentifiers *a) { ASN1_item_free((ASN1_VALUE *)a, &ASIdentifiers_it); } -LCRYPTO_ALIAS(ASIdentifiers_free) +LCRYPTO_ALIAS(ASIdentifiers_free); /* * i2r method for an ASIdentifierChoice. @@ -428,7 +428,7 @@ X509v3_asid_add_inherit(ASIdentifiers *asid, int which) } return (*choice)->type == ASIdentifierChoice_inherit; } -LCRYPTO_ALIAS(X509v3_asid_add_inherit) +LCRYPTO_ALIAS(X509v3_asid_add_inherit); /* * Add an ID or range to an ASIdentifierChoice. @@ -483,7 +483,7 @@ X509v3_asid_add_id_or_range(ASIdentifiers *asid, int which, ASN1_INTEGER *min, ASIdOrRange_free(aor); return 0; } -LCRYPTO_ALIAS(X509v3_asid_add_id_or_range) +LCRYPTO_ALIAS(X509v3_asid_add_id_or_range); /* * Extract min and max values from an ASIdOrRange. @@ -612,7 +612,7 @@ X509v3_asid_is_canonical(ASIdentifiers *asid) (ASIdentifierChoice_is_canonical(asid->asnum) && ASIdentifierChoice_is_canonical(asid->rdi))); } -LCRYPTO_ALIAS(X509v3_asid_is_canonical) +LCRYPTO_ALIAS(X509v3_asid_is_canonical); /* * Whack an ASIdentifierChoice into canonical form. @@ -780,7 +780,7 @@ X509v3_asid_canonize(ASIdentifiers *asid) return ASIdentifierChoice_canonize(asid->rdi); } -LCRYPTO_ALIAS(X509v3_asid_canonize) +LCRYPTO_ALIAS(X509v3_asid_canonize); /* * v2i method for an ASIdentifier extension. @@ -939,7 +939,7 @@ X509v3_asid_inherits(ASIdentifiers *asid) return 0; } -LCRYPTO_ALIAS(X509v3_asid_inherits) +LCRYPTO_ALIAS(X509v3_asid_inherits); /* * Figure out whether parent contains child. @@ -1013,7 +1013,7 @@ X509v3_asid_subset(ASIdentifiers *child, ASIdentifiers *parent) return 1; } -LCRYPTO_ALIAS(X509v3_asid_subset) +LCRYPTO_ALIAS(X509v3_asid_subset); /* * Validation error handling via callback. @@ -1181,7 +1181,7 @@ X509v3_asid_validate_path(X509_STORE_CTX *ctx) } return asid_validate_path_internal(ctx, ctx->chain, NULL); } -LCRYPTO_ALIAS(X509v3_asid_validate_path) +LCRYPTO_ALIAS(X509v3_asid_validate_path); /* * RFC 3779 3.3 path validation of an extension. @@ -1199,6 +1199,6 @@ X509v3_asid_validate_resource_set(STACK_OF(X509) *chain, ASIdentifiers *ext, return 0; return asid_validate_path_internal(NULL, chain, ext); } -LCRYPTO_ALIAS(X509v3_asid_validate_resource_set) +LCRYPTO_ALIAS(X509v3_asid_validate_resource_set); #endif /* OPENSSL_NO_RFC3779 */ diff --git a/lib/libcrypto/x509/x509_att.c b/lib/libcrypto/x509/x509_att.c index e769418fd3e..0c9d55f74f5 100644 --- a/lib/libcrypto/x509/x509_att.c +++ b/lib/libcrypto/x509/x509_att.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_att.c,v 1.21 2022/11/26 16:08:54 tb Exp $ */ +/* $OpenBSD: x509_att.c,v 1.22 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -73,7 +73,7 @@ X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x) { return sk_X509_ATTRIBUTE_num(x); } -LCRYPTO_ALIAS(X509at_get_attr_count) +LCRYPTO_ALIAS(X509at_get_attr_count); int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid, int lastpos) @@ -85,7 +85,7 @@ X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid, int lastpos) return (-2); return (X509at_get_attr_by_OBJ(x, obj, lastpos)); } -LCRYPTO_ALIAS(X509at_get_attr_by_NID) +LCRYPTO_ALIAS(X509at_get_attr_by_NID); int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk, @@ -107,7 +107,7 @@ X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk, } return (-1); } -LCRYPTO_ALIAS(X509at_get_attr_by_OBJ) +LCRYPTO_ALIAS(X509at_get_attr_by_OBJ); X509_ATTRIBUTE * X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc) @@ -117,7 +117,7 @@ X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc) else return sk_X509_ATTRIBUTE_value(x, loc); } -LCRYPTO_ALIAS(X509at_get_attr) +LCRYPTO_ALIAS(X509at_get_attr); X509_ATTRIBUTE * X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc) @@ -129,7 +129,7 @@ X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc) ret = sk_X509_ATTRIBUTE_delete(x, loc); return (ret); } -LCRYPTO_ALIAS(X509at_delete_attr) +LCRYPTO_ALIAS(X509at_delete_attr); STACK_OF(X509_ATTRIBUTE) * X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x, X509_ATTRIBUTE *attr) @@ -165,7 +165,7 @@ err2: sk_X509_ATTRIBUTE_free(sk); return (NULL); } -LCRYPTO_ALIAS(X509at_add1_attr) +LCRYPTO_ALIAS(X509at_add1_attr); STACK_OF(X509_ATTRIBUTE) * X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE) **x, const ASN1_OBJECT *obj, @@ -181,7 +181,7 @@ X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE) **x, const ASN1_OBJECT *obj, X509_ATTRIBUTE_free(attr); return ret; } -LCRYPTO_ALIAS(X509at_add1_attr_by_OBJ) +LCRYPTO_ALIAS(X509at_add1_attr_by_OBJ); STACK_OF(X509_ATTRIBUTE) * X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE) **x, int nid, int type, @@ -197,7 +197,7 @@ X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE) **x, int nid, int type, X509_ATTRIBUTE_free(attr); return ret; } -LCRYPTO_ALIAS(X509at_add1_attr_by_NID) +LCRYPTO_ALIAS(X509at_add1_attr_by_NID); STACK_OF(X509_ATTRIBUTE) * X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE) **x, const char *attrname, @@ -213,7 +213,7 @@ X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE) **x, const char *attrname, X509_ATTRIBUTE_free(attr); return ret; } -LCRYPTO_ALIAS(X509at_add1_attr_by_txt) +LCRYPTO_ALIAS(X509at_add1_attr_by_txt); void * X509at_get0_data_by_OBJ(STACK_OF(X509_ATTRIBUTE) *x, const ASN1_OBJECT *obj, @@ -232,7 +232,7 @@ X509at_get0_data_by_OBJ(STACK_OF(X509_ATTRIBUTE) *x, const ASN1_OBJECT *obj, return NULL; return X509_ATTRIBUTE_get0_data(at, 0, type, NULL); } -LCRYPTO_ALIAS(X509at_get0_data_by_OBJ) +LCRYPTO_ALIAS(X509at_get0_data_by_OBJ); X509_ATTRIBUTE * X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid, int atrtype, @@ -251,7 +251,7 @@ X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid, int atrtype, ASN1_OBJECT_free(obj); return (ret); } -LCRYPTO_ALIAS(X509_ATTRIBUTE_create_by_NID) +LCRYPTO_ALIAS(X509_ATTRIBUTE_create_by_NID); X509_ATTRIBUTE * X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr, const ASN1_OBJECT *obj, @@ -281,7 +281,7 @@ err: X509_ATTRIBUTE_free(ret); return (NULL); } -LCRYPTO_ALIAS(X509_ATTRIBUTE_create_by_OBJ) +LCRYPTO_ALIAS(X509_ATTRIBUTE_create_by_OBJ); X509_ATTRIBUTE * X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr, const char *atrname, @@ -300,7 +300,7 @@ X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr, const char *atrname, ASN1_OBJECT_free(obj); return nattr; } -LCRYPTO_ALIAS(X509_ATTRIBUTE_create_by_txt) +LCRYPTO_ALIAS(X509_ATTRIBUTE_create_by_txt); int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj) @@ -311,7 +311,7 @@ X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj) attr->object = OBJ_dup(obj); return attr->object != NULL; } -LCRYPTO_ALIAS(X509_ATTRIBUTE_set1_object) +LCRYPTO_ALIAS(X509_ATTRIBUTE_set1_object); int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype, const void *data, @@ -365,7 +365,7 @@ err: X509error(ERR_R_MALLOC_FAILURE); return 0; } -LCRYPTO_ALIAS(X509_ATTRIBUTE_set1_data) +LCRYPTO_ALIAS(X509_ATTRIBUTE_set1_data); int X509_ATTRIBUTE_count(const X509_ATTRIBUTE *attr) @@ -375,7 +375,7 @@ X509_ATTRIBUTE_count(const X509_ATTRIBUTE *attr) return sk_ASN1_TYPE_num(attr->set); } -LCRYPTO_ALIAS(X509_ATTRIBUTE_count) +LCRYPTO_ALIAS(X509_ATTRIBUTE_count); ASN1_OBJECT * X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr) @@ -384,7 +384,7 @@ X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr) return (NULL); return (attr->object); } -LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_object) +LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_object); void * X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx, int atrtype, void *data) @@ -400,7 +400,7 @@ X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx, int atrtype, void *data) } return ttmp->value.ptr; } -LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_data) +LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_data); ASN1_TYPE * X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx) @@ -410,4 +410,4 @@ X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx) return sk_ASN1_TYPE_value(attr->set, idx); } -LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_type) +LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_type); diff --git a/lib/libcrypto/x509/x509_bcons.c b/lib/libcrypto/x509/x509_bcons.c index 8a9c1e419ac..a39ae0aae0b 100644 --- a/lib/libcrypto/x509/x509_bcons.c +++ b/lib/libcrypto/x509/x509_bcons.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_bcons.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */ +/* $OpenBSD: x509_bcons.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -121,28 +121,28 @@ d2i_BASIC_CONSTRAINTS(BASIC_CONSTRAINTS **a, const unsigned char **in, long len) return (BASIC_CONSTRAINTS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &BASIC_CONSTRAINTS_it); } -LCRYPTO_ALIAS(d2i_BASIC_CONSTRAINTS) +LCRYPTO_ALIAS(d2i_BASIC_CONSTRAINTS); int i2d_BASIC_CONSTRAINTS(BASIC_CONSTRAINTS *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &BASIC_CONSTRAINTS_it); } -LCRYPTO_ALIAS(i2d_BASIC_CONSTRAINTS) +LCRYPTO_ALIAS(i2d_BASIC_CONSTRAINTS); BASIC_CONSTRAINTS * BASIC_CONSTRAINTS_new(void) { return (BASIC_CONSTRAINTS *)ASN1_item_new(&BASIC_CONSTRAINTS_it); } -LCRYPTO_ALIAS(BASIC_CONSTRAINTS_new) +LCRYPTO_ALIAS(BASIC_CONSTRAINTS_new); void BASIC_CONSTRAINTS_free(BASIC_CONSTRAINTS *a) { ASN1_item_free((ASN1_VALUE *)a, &BASIC_CONSTRAINTS_it); } -LCRYPTO_ALIAS(BASIC_CONSTRAINTS_free) +LCRYPTO_ALIAS(BASIC_CONSTRAINTS_free); static STACK_OF(CONF_VALUE) * diff --git a/lib/libcrypto/x509/x509_bitst.c b/lib/libcrypto/x509/x509_bitst.c index bea089e31c8..cacbe8efe7c 100644 --- a/lib/libcrypto/x509/x509_bitst.c +++ b/lib/libcrypto/x509/x509_bitst.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_bitst.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */ +/* $OpenBSD: x509_bitst.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -148,7 +148,7 @@ i2v_ASN1_BIT_STRING(X509V3_EXT_METHOD *method, ASN1_BIT_STRING *bits, return NULL; } -LCRYPTO_ALIAS(i2v_ASN1_BIT_STRING) +LCRYPTO_ALIAS(i2v_ASN1_BIT_STRING); ASN1_BIT_STRING * v2i_ASN1_BIT_STRING(X509V3_EXT_METHOD *method, X509V3_CTX *ctx, @@ -186,4 +186,4 @@ v2i_ASN1_BIT_STRING(X509V3_EXT_METHOD *method, X509V3_CTX *ctx, } return bs; } -LCRYPTO_ALIAS(v2i_ASN1_BIT_STRING) +LCRYPTO_ALIAS(v2i_ASN1_BIT_STRING); diff --git a/lib/libcrypto/x509/x509_cmp.c b/lib/libcrypto/x509/x509_cmp.c index b76c9ea6601..3ee4fd4a5da 100644 --- a/lib/libcrypto/x509/x509_cmp.c +++ b/lib/libcrypto/x509/x509_cmp.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_cmp.c,v 1.41 2022/11/26 16:08:54 tb Exp $ */ +/* $OpenBSD: x509_cmp.c,v 1.42 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -84,7 +84,7 @@ X509_issuer_and_serial_cmp(const X509 *a, const X509 *b) return (i); return (X509_NAME_cmp(ai->issuer, bi->issuer)); } -LCRYPTO_ALIAS(X509_issuer_and_serial_cmp) +LCRYPTO_ALIAS(X509_issuer_and_serial_cmp); #ifndef OPENSSL_NO_MD5 unsigned long @@ -120,7 +120,7 @@ err: free(f); return (ret); } -LCRYPTO_ALIAS(X509_issuer_and_serial_hash) +LCRYPTO_ALIAS(X509_issuer_and_serial_hash); #endif int @@ -128,21 +128,21 @@ X509_issuer_name_cmp(const X509 *a, const X509 *b) { return (X509_NAME_cmp(a->cert_info->issuer, b->cert_info->issuer)); } -LCRYPTO_ALIAS(X509_issuer_name_cmp) +LCRYPTO_ALIAS(X509_issuer_name_cmp); int X509_subject_name_cmp(const X509 *a, const X509 *b) { return (X509_NAME_cmp(a->cert_info->subject, b->cert_info->subject)); } -LCRYPTO_ALIAS(X509_subject_name_cmp) +LCRYPTO_ALIAS(X509_subject_name_cmp); int X509_CRL_cmp(const X509_CRL *a, const X509_CRL *b) { return (X509_NAME_cmp(a->crl->issuer, b->crl->issuer)); } -LCRYPTO_ALIAS(X509_CRL_cmp) +LCRYPTO_ALIAS(X509_CRL_cmp); #ifndef OPENSSL_NO_SHA int @@ -150,7 +150,7 @@ X509_CRL_match(const X509_CRL *a, const X509_CRL *b) { return memcmp(a->hash, b->hash, X509_CRL_HASH_LEN); } -LCRYPTO_ALIAS(X509_CRL_match) +LCRYPTO_ALIAS(X509_CRL_match); #endif X509_NAME * @@ -158,14 +158,14 @@ X509_get_issuer_name(const X509 *a) { return (a->cert_info->issuer); } -LCRYPTO_ALIAS(X509_get_issuer_name) +LCRYPTO_ALIAS(X509_get_issuer_name); unsigned long X509_issuer_name_hash(X509 *x) { return (X509_NAME_hash(x->cert_info->issuer)); } -LCRYPTO_ALIAS(X509_issuer_name_hash) +LCRYPTO_ALIAS(X509_issuer_name_hash); #ifndef OPENSSL_NO_MD5 unsigned long @@ -173,7 +173,7 @@ X509_issuer_name_hash_old(X509 *x) { return (X509_NAME_hash_old(x->cert_info->issuer)); } -LCRYPTO_ALIAS(X509_issuer_name_hash_old) +LCRYPTO_ALIAS(X509_issuer_name_hash_old); #endif X509_NAME * @@ -181,28 +181,28 @@ X509_get_subject_name(const X509 *a) { return (a->cert_info->subject); } -LCRYPTO_ALIAS(X509_get_subject_name) +LCRYPTO_ALIAS(X509_get_subject_name); ASN1_INTEGER * X509_get_serialNumber(X509 *a) { return (a->cert_info->serialNumber); } -LCRYPTO_ALIAS(X509_get_serialNumber) +LCRYPTO_ALIAS(X509_get_serialNumber); const ASN1_INTEGER * X509_get0_serialNumber(const X509 *a) { return (a->cert_info->serialNumber); } -LCRYPTO_ALIAS(X509_get0_serialNumber) +LCRYPTO_ALIAS(X509_get0_serialNumber); unsigned long X509_subject_name_hash(X509 *x) { return (X509_NAME_hash(x->cert_info->subject)); } -LCRYPTO_ALIAS(X509_subject_name_hash) +LCRYPTO_ALIAS(X509_subject_name_hash); #ifndef OPENSSL_NO_MD5 unsigned long @@ -210,7 +210,7 @@ X509_subject_name_hash_old(X509 *x) { return (X509_NAME_hash_old(x->cert_info->subject)); } -LCRYPTO_ALIAS(X509_subject_name_hash_old) +LCRYPTO_ALIAS(X509_subject_name_hash_old); #endif #ifndef OPENSSL_NO_SHA @@ -232,7 +232,7 @@ X509_cmp(const X509 *a, const X509 *b) return memcmp(a->hash, b->hash, X509_CERT_HASH_LEN); } -LCRYPTO_ALIAS(X509_cmp) +LCRYPTO_ALIAS(X509_cmp); #endif int @@ -256,7 +256,7 @@ X509_NAME_cmp(const X509_NAME *a, const X509_NAME *b) return ret; return memcmp(a->canon_enc, b->canon_enc, a->canon_enclen); } -LCRYPTO_ALIAS(X509_NAME_cmp) +LCRYPTO_ALIAS(X509_NAME_cmp); unsigned long X509_NAME_hash(X509_NAME *x) @@ -275,7 +275,7 @@ X509_NAME_hash(X509_NAME *x) 0xffffffffL; return (ret); } -LCRYPTO_ALIAS(X509_NAME_hash) +LCRYPTO_ALIAS(X509_NAME_hash); #ifndef OPENSSL_NO_MD5 @@ -304,7 +304,7 @@ X509_NAME_hash_old(X509_NAME *x) return (ret); } -LCRYPTO_ALIAS(X509_NAME_hash_old) +LCRYPTO_ALIAS(X509_NAME_hash_old); #endif /* Search a stack of X509 for a match */ @@ -330,7 +330,7 @@ X509_find_by_issuer_and_serial(STACK_OF(X509) *sk, X509_NAME *name, } return (NULL); } -LCRYPTO_ALIAS(X509_find_by_issuer_and_serial) +LCRYPTO_ALIAS(X509_find_by_issuer_and_serial); X509 * X509_find_by_subject(STACK_OF(X509) *sk, X509_NAME *name) @@ -345,7 +345,7 @@ X509_find_by_subject(STACK_OF(X509) *sk, X509_NAME *name) } return (NULL); } -LCRYPTO_ALIAS(X509_find_by_subject) +LCRYPTO_ALIAS(X509_find_by_subject); EVP_PKEY * X509_get_pubkey(X509 *x) @@ -354,7 +354,7 @@ X509_get_pubkey(X509 *x) return (NULL); return (X509_PUBKEY_get(x->cert_info->key)); } -LCRYPTO_ALIAS(X509_get_pubkey) +LCRYPTO_ALIAS(X509_get_pubkey); EVP_PKEY * X509_get0_pubkey(const X509 *x) @@ -363,7 +363,7 @@ X509_get0_pubkey(const X509 *x) return (NULL); return (X509_PUBKEY_get0(x->cert_info->key)); } -LCRYPTO_ALIAS(X509_get0_pubkey) +LCRYPTO_ALIAS(X509_get0_pubkey); ASN1_BIT_STRING * X509_get0_pubkey_bitstr(const X509 *x) @@ -372,7 +372,7 @@ X509_get0_pubkey_bitstr(const X509 *x) return NULL; return x->cert_info->key->public_key; } -LCRYPTO_ALIAS(X509_get0_pubkey_bitstr) +LCRYPTO_ALIAS(X509_get0_pubkey_bitstr); int X509_check_private_key(const X509 *x, const EVP_PKEY *k) @@ -403,7 +403,7 @@ X509_check_private_key(const X509 *x, const EVP_PKEY *k) return 1; return 0; } -LCRYPTO_ALIAS(X509_check_private_key) +LCRYPTO_ALIAS(X509_check_private_key); /* * Not strictly speaking an "up_ref" as a STACK doesn't have a reference @@ -422,4 +422,4 @@ X509_chain_up_ref(STACK_OF(X509) *chain) return ret; } -LCRYPTO_ALIAS(X509_chain_up_ref) +LCRYPTO_ALIAS(X509_chain_up_ref); diff --git a/lib/libcrypto/x509/x509_conf.c b/lib/libcrypto/x509/x509_conf.c index 2b3274d04d5..189bf644054 100644 --- a/lib/libcrypto/x509/x509_conf.c +++ b/lib/libcrypto/x509/x509_conf.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_conf.c,v 1.4 2022/11/26 16:08:54 tb Exp $ */ +/* $OpenBSD: x509_conf.c,v 1.5 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -104,7 +104,7 @@ X509V3_EXT_nconf(CONF *conf, X509V3_CTX *ctx, const char *name, } return ret; } -LCRYPTO_ALIAS(X509V3_EXT_nconf) +LCRYPTO_ALIAS(X509V3_EXT_nconf); /* CONF *conf: Config file */ /* char *value: Value */ @@ -121,7 +121,7 @@ X509V3_EXT_nconf_nid(CONF *conf, X509V3_CTX *ctx, int ext_nid, value, crit, ext_type, ctx); return do_ext_nconf(conf, ctx, ext_nid, crit, value); } -LCRYPTO_ALIAS(X509V3_EXT_nconf_nid) +LCRYPTO_ALIAS(X509V3_EXT_nconf_nid); /* CONF *conf: Config file */ /* char *value: Value */ @@ -240,7 +240,7 @@ X509V3_EXT_i2d(int ext_nid, int crit, void *ext_struc) } return do_ext_i2d(method, ext_nid, crit, ext_struc); } -LCRYPTO_ALIAS(X509V3_EXT_i2d) +LCRYPTO_ALIAS(X509V3_EXT_i2d); /* Check the extension string for critical flag */ static int @@ -367,7 +367,7 @@ X509V3_EXT_add_nconf_sk(CONF *conf, X509V3_CTX *ctx, const char *section, } return 1; } -LCRYPTO_ALIAS(X509V3_EXT_add_nconf_sk) +LCRYPTO_ALIAS(X509V3_EXT_add_nconf_sk); /* Convenience functions to add extensions to a certificate, CRL and request */ @@ -381,7 +381,7 @@ X509V3_EXT_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section, sk = &cert->cert_info->extensions; return X509V3_EXT_add_nconf_sk(conf, ctx, section, sk); } -LCRYPTO_ALIAS(X509V3_EXT_add_nconf) +LCRYPTO_ALIAS(X509V3_EXT_add_nconf); /* Same as above but for a CRL */ @@ -395,7 +395,7 @@ X509V3_EXT_CRL_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section, sk = &crl->crl->extensions; return X509V3_EXT_add_nconf_sk(conf, ctx, section, sk); } -LCRYPTO_ALIAS(X509V3_EXT_CRL_add_nconf) +LCRYPTO_ALIAS(X509V3_EXT_CRL_add_nconf); /* Add extensions to certificate request */ @@ -415,7 +415,7 @@ X509V3_EXT_REQ_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section, sk_X509_EXTENSION_pop_free(extlist, X509_EXTENSION_free); return i; } -LCRYPTO_ALIAS(X509V3_EXT_REQ_add_nconf) +LCRYPTO_ALIAS(X509V3_EXT_REQ_add_nconf); /* Config database functions */ @@ -428,7 +428,7 @@ X509V3_get_string(X509V3_CTX *ctx, const char *name, const char *section) } return ctx->db_meth->get_string(ctx->db, name, section); } -LCRYPTO_ALIAS(X509V3_get_string) +LCRYPTO_ALIAS(X509V3_get_string); STACK_OF(CONF_VALUE) * X509V3_get_section(X509V3_CTX *ctx, const char *section) @@ -439,7 +439,7 @@ X509V3_get_section(X509V3_CTX *ctx, const char *section) } return ctx->db_meth->get_section(ctx->db, section); } -LCRYPTO_ALIAS(X509V3_get_section) +LCRYPTO_ALIAS(X509V3_get_section); void X509V3_string_free(X509V3_CTX *ctx, char *str) @@ -449,7 +449,7 @@ X509V3_string_free(X509V3_CTX *ctx, char *str) if (ctx->db_meth->free_string) ctx->db_meth->free_string(ctx->db, str); } -LCRYPTO_ALIAS(X509V3_string_free) +LCRYPTO_ALIAS(X509V3_string_free); void X509V3_section_free(X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *section) @@ -459,7 +459,7 @@ X509V3_section_free(X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *section) if (ctx->db_meth->free_section) ctx->db_meth->free_section(ctx->db, section); } -LCRYPTO_ALIAS(X509V3_section_free) +LCRYPTO_ALIAS(X509V3_section_free); static char * nconf_get_string(void *db, const char *section, const char *value) @@ -486,7 +486,7 @@ X509V3_set_nconf(X509V3_CTX *ctx, CONF *conf) ctx->db_meth = &nconf_method; ctx->db = conf; } -LCRYPTO_ALIAS(X509V3_set_nconf) +LCRYPTO_ALIAS(X509V3_set_nconf); void X509V3_set_ctx(X509V3_CTX *ctx, X509 *issuer, X509 *subj, X509_REQ *req, @@ -498,7 +498,7 @@ X509V3_set_ctx(X509V3_CTX *ctx, X509 *issuer, X509 *subj, X509_REQ *req, ctx->subject_req = req; ctx->flags = flags; } -LCRYPTO_ALIAS(X509V3_set_ctx) +LCRYPTO_ALIAS(X509V3_set_ctx); /* Old conf compatibility functions */ @@ -511,7 +511,7 @@ X509V3_EXT_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx, const char *name, CONF_set_nconf(&ctmp, conf); return X509V3_EXT_nconf(&ctmp, ctx, name, value); } -LCRYPTO_ALIAS(X509V3_EXT_conf) +LCRYPTO_ALIAS(X509V3_EXT_conf); /* LHASH *conf: Config file */ /* char *value: Value */ @@ -524,7 +524,7 @@ X509V3_EXT_conf_nid(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx, int ext_nid, CONF_set_nconf(&ctmp, conf); return X509V3_EXT_nconf_nid(&ctmp, ctx, ext_nid, value); } -LCRYPTO_ALIAS(X509V3_EXT_conf_nid) +LCRYPTO_ALIAS(X509V3_EXT_conf_nid); static char * conf_lhash_get_string(void *db, const char *section, const char *value) @@ -551,7 +551,7 @@ X509V3_set_conf_lhash(X509V3_CTX *ctx, LHASH_OF(CONF_VALUE) *lhash) ctx->db_meth = &conf_lhash_method; ctx->db = lhash; } -LCRYPTO_ALIAS(X509V3_set_conf_lhash) +LCRYPTO_ALIAS(X509V3_set_conf_lhash); int X509V3_EXT_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx, @@ -562,7 +562,7 @@ X509V3_EXT_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx, CONF_set_nconf(&ctmp, conf); return X509V3_EXT_add_nconf(&ctmp, ctx, section, cert); } -LCRYPTO_ALIAS(X509V3_EXT_add_conf) +LCRYPTO_ALIAS(X509V3_EXT_add_conf); /* Same as above but for a CRL */ @@ -575,7 +575,7 @@ X509V3_EXT_CRL_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx, CONF_set_nconf(&ctmp, conf); return X509V3_EXT_CRL_add_nconf(&ctmp, ctx, section, crl); } -LCRYPTO_ALIAS(X509V3_EXT_CRL_add_conf) +LCRYPTO_ALIAS(X509V3_EXT_CRL_add_conf); /* Add extensions to certificate request */ @@ -588,4 +588,4 @@ X509V3_EXT_REQ_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx, CONF_set_nconf(&ctmp, conf); return X509V3_EXT_REQ_add_nconf(&ctmp, ctx, section, req); } -LCRYPTO_ALIAS(X509V3_EXT_REQ_add_conf) +LCRYPTO_ALIAS(X509V3_EXT_REQ_add_conf); diff --git a/lib/libcrypto/x509/x509_cpols.c b/lib/libcrypto/x509/x509_cpols.c index 12e4a55c473..3f106c691de 100644 --- a/lib/libcrypto/x509/x509_cpols.c +++ b/lib/libcrypto/x509/x509_cpols.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_cpols.c,v 1.6 2022/11/26 16:08:54 tb Exp $ */ +/* $OpenBSD: x509_cpols.c,v 1.7 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -125,28 +125,28 @@ d2i_CERTIFICATEPOLICIES(CERTIFICATEPOLICIES **a, const unsigned char **in, long return (CERTIFICATEPOLICIES *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &CERTIFICATEPOLICIES_it); } -LCRYPTO_ALIAS(d2i_CERTIFICATEPOLICIES) +LCRYPTO_ALIAS(d2i_CERTIFICATEPOLICIES); int i2d_CERTIFICATEPOLICIES(CERTIFICATEPOLICIES *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &CERTIFICATEPOLICIES_it); } -LCRYPTO_ALIAS(i2d_CERTIFICATEPOLICIES) +LCRYPTO_ALIAS(i2d_CERTIFICATEPOLICIES); CERTIFICATEPOLICIES * CERTIFICATEPOLICIES_new(void) { return (CERTIFICATEPOLICIES *)ASN1_item_new(&CERTIFICATEPOLICIES_it); } -LCRYPTO_ALIAS(CERTIFICATEPOLICIES_new) +LCRYPTO_ALIAS(CERTIFICATEPOLICIES_new); void CERTIFICATEPOLICIES_free(CERTIFICATEPOLICIES *a) { ASN1_item_free((ASN1_VALUE *)a, &CERTIFICATEPOLICIES_it); } -LCRYPTO_ALIAS(CERTIFICATEPOLICIES_free) +LCRYPTO_ALIAS(CERTIFICATEPOLICIES_free); static const ASN1_TEMPLATE POLICYINFO_seq_tt[] = { { @@ -182,28 +182,28 @@ d2i_POLICYINFO(POLICYINFO **a, const unsigned char **in, long len) return (POLICYINFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &POLICYINFO_it); } -LCRYPTO_ALIAS(d2i_POLICYINFO) +LCRYPTO_ALIAS(d2i_POLICYINFO); int i2d_POLICYINFO(POLICYINFO *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &POLICYINFO_it); } -LCRYPTO_ALIAS(i2d_POLICYINFO) +LCRYPTO_ALIAS(i2d_POLICYINFO); POLICYINFO * POLICYINFO_new(void) { return (POLICYINFO *)ASN1_item_new(&POLICYINFO_it); } -LCRYPTO_ALIAS(POLICYINFO_new) +LCRYPTO_ALIAS(POLICYINFO_new); void POLICYINFO_free(POLICYINFO *a) { ASN1_item_free((ASN1_VALUE *)a, &POLICYINFO_it); } -LCRYPTO_ALIAS(POLICYINFO_free) +LCRYPTO_ALIAS(POLICYINFO_free); static const ASN1_TEMPLATE policydefault_tt = { .flags = 0, @@ -281,28 +281,28 @@ d2i_POLICYQUALINFO(POLICYQUALINFO **a, const unsigned char **in, long len) return (POLICYQUALINFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &POLICYQUALINFO_it); } -LCRYPTO_ALIAS(d2i_POLICYQUALINFO) +LCRYPTO_ALIAS(d2i_POLICYQUALINFO); int i2d_POLICYQUALINFO(POLICYQUALINFO *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &POLICYQUALINFO_it); } -LCRYPTO_ALIAS(i2d_POLICYQUALINFO) +LCRYPTO_ALIAS(i2d_POLICYQUALINFO); POLICYQUALINFO * POLICYQUALINFO_new(void) { return (POLICYQUALINFO *)ASN1_item_new(&POLICYQUALINFO_it); } -LCRYPTO_ALIAS(POLICYQUALINFO_new) +LCRYPTO_ALIAS(POLICYQUALINFO_new); void POLICYQUALINFO_free(POLICYQUALINFO *a) { ASN1_item_free((ASN1_VALUE *)a, &POLICYQUALINFO_it); } -LCRYPTO_ALIAS(POLICYQUALINFO_free) +LCRYPTO_ALIAS(POLICYQUALINFO_free); static const ASN1_TEMPLATE USERNOTICE_seq_tt[] = { { @@ -338,28 +338,28 @@ d2i_USERNOTICE(USERNOTICE **a, const unsigned char **in, long len) return (USERNOTICE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &USERNOTICE_it); } -LCRYPTO_ALIAS(d2i_USERNOTICE) +LCRYPTO_ALIAS(d2i_USERNOTICE); int i2d_USERNOTICE(USERNOTICE *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &USERNOTICE_it); } -LCRYPTO_ALIAS(i2d_USERNOTICE) +LCRYPTO_ALIAS(i2d_USERNOTICE); USERNOTICE * USERNOTICE_new(void) { return (USERNOTICE *)ASN1_item_new(&USERNOTICE_it); } -LCRYPTO_ALIAS(USERNOTICE_new) +LCRYPTO_ALIAS(USERNOTICE_new); void USERNOTICE_free(USERNOTICE *a) { ASN1_item_free((ASN1_VALUE *)a, &USERNOTICE_it); } -LCRYPTO_ALIAS(USERNOTICE_free) +LCRYPTO_ALIAS(USERNOTICE_free); static const ASN1_TEMPLATE NOTICEREF_seq_tt[] = { { @@ -395,28 +395,28 @@ d2i_NOTICEREF(NOTICEREF **a, const unsigned char **in, long len) return (NOTICEREF *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &NOTICEREF_it); } -LCRYPTO_ALIAS(d2i_NOTICEREF) +LCRYPTO_ALIAS(d2i_NOTICEREF); int i2d_NOTICEREF(NOTICEREF *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &NOTICEREF_it); } -LCRYPTO_ALIAS(i2d_NOTICEREF) +LCRYPTO_ALIAS(i2d_NOTICEREF); NOTICEREF * NOTICEREF_new(void) { return (NOTICEREF *)ASN1_item_new(&NOTICEREF_it); } -LCRYPTO_ALIAS(NOTICEREF_new) +LCRYPTO_ALIAS(NOTICEREF_new); void NOTICEREF_free(NOTICEREF *a) { ASN1_item_free((ASN1_VALUE *)a, &NOTICEREF_it); } -LCRYPTO_ALIAS(NOTICEREF_free) +LCRYPTO_ALIAS(NOTICEREF_free); static STACK_OF(POLICYINFO) * r2i_certpol(X509V3_EXT_METHOD *method, X509V3_CTX *ctx, char *value) @@ -782,4 +782,4 @@ X509_POLICY_NODE_print(BIO *out, X509_POLICY_NODE *node, int indent) else BIO_printf(out, "%*sNo Qualifiers\n", indent + 2, ""); } -LCRYPTO_ALIAS(X509_POLICY_NODE_print) +LCRYPTO_ALIAS(X509_POLICY_NODE_print); diff --git a/lib/libcrypto/x509/x509_crld.c b/lib/libcrypto/x509/x509_crld.c index ef9c82bb3f2..7887ccd644e 100644 --- a/lib/libcrypto/x509/x509_crld.c +++ b/lib/libcrypto/x509/x509_crld.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_crld.c,v 1.4 2022/11/26 16:08:54 tb Exp $ */ +/* $OpenBSD: x509_crld.c,v 1.5 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -426,28 +426,28 @@ d2i_DIST_POINT_NAME(DIST_POINT_NAME **a, const unsigned char **in, long len) return (DIST_POINT_NAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &DIST_POINT_NAME_it); } -LCRYPTO_ALIAS(d2i_DIST_POINT_NAME) +LCRYPTO_ALIAS(d2i_DIST_POINT_NAME); int i2d_DIST_POINT_NAME(DIST_POINT_NAME *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &DIST_POINT_NAME_it); } -LCRYPTO_ALIAS(i2d_DIST_POINT_NAME) +LCRYPTO_ALIAS(i2d_DIST_POINT_NAME); DIST_POINT_NAME * DIST_POINT_NAME_new(void) { return (DIST_POINT_NAME *)ASN1_item_new(&DIST_POINT_NAME_it); } -LCRYPTO_ALIAS(DIST_POINT_NAME_new) +LCRYPTO_ALIAS(DIST_POINT_NAME_new); void DIST_POINT_NAME_free(DIST_POINT_NAME *a) { ASN1_item_free((ASN1_VALUE *)a, &DIST_POINT_NAME_it); } -LCRYPTO_ALIAS(DIST_POINT_NAME_free) +LCRYPTO_ALIAS(DIST_POINT_NAME_free); static const ASN1_TEMPLATE DIST_POINT_seq_tt[] = { { @@ -490,28 +490,28 @@ d2i_DIST_POINT(DIST_POINT **a, const unsigned char **in, long len) return (DIST_POINT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &DIST_POINT_it); } -LCRYPTO_ALIAS(d2i_DIST_POINT) +LCRYPTO_ALIAS(d2i_DIST_POINT); int i2d_DIST_POINT(DIST_POINT *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &DIST_POINT_it); } -LCRYPTO_ALIAS(i2d_DIST_POINT) +LCRYPTO_ALIAS(i2d_DIST_POINT); DIST_POINT * DIST_POINT_new(void) { return (DIST_POINT *)ASN1_item_new(&DIST_POINT_it); } -LCRYPTO_ALIAS(DIST_POINT_new) +LCRYPTO_ALIAS(DIST_POINT_new); void DIST_POINT_free(DIST_POINT *a) { ASN1_item_free((ASN1_VALUE *)a, &DIST_POINT_it); } -LCRYPTO_ALIAS(DIST_POINT_free) +LCRYPTO_ALIAS(DIST_POINT_free); static const ASN1_TEMPLATE CRL_DIST_POINTS_item_tt = { .flags = ASN1_TFLG_SEQUENCE_OF, @@ -538,28 +538,28 @@ d2i_CRL_DIST_POINTS(CRL_DIST_POINTS **a, const unsigned char **in, long len) return (CRL_DIST_POINTS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &CRL_DIST_POINTS_it); } -LCRYPTO_ALIAS(d2i_CRL_DIST_POINTS) +LCRYPTO_ALIAS(d2i_CRL_DIST_POINTS); int i2d_CRL_DIST_POINTS(CRL_DIST_POINTS *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &CRL_DIST_POINTS_it); } -LCRYPTO_ALIAS(i2d_CRL_DIST_POINTS) +LCRYPTO_ALIAS(i2d_CRL_DIST_POINTS); CRL_DIST_POINTS * CRL_DIST_POINTS_new(void) { return (CRL_DIST_POINTS *)ASN1_item_new(&CRL_DIST_POINTS_it); } -LCRYPTO_ALIAS(CRL_DIST_POINTS_new) +LCRYPTO_ALIAS(CRL_DIST_POINTS_new); void CRL_DIST_POINTS_free(CRL_DIST_POINTS *a) { ASN1_item_free((ASN1_VALUE *)a, &CRL_DIST_POINTS_it); } -LCRYPTO_ALIAS(CRL_DIST_POINTS_free) +LCRYPTO_ALIAS(CRL_DIST_POINTS_free); static const ASN1_TEMPLATE ISSUING_DIST_POINT_seq_tt[] = { { @@ -623,28 +623,28 @@ d2i_ISSUING_DIST_POINT(ISSUING_DIST_POINT **a, const unsigned char **in, long le return (ISSUING_DIST_POINT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &ISSUING_DIST_POINT_it); } -LCRYPTO_ALIAS(d2i_ISSUING_DIST_POINT) +LCRYPTO_ALIAS(d2i_ISSUING_DIST_POINT); int i2d_ISSUING_DIST_POINT(ISSUING_DIST_POINT *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &ISSUING_DIST_POINT_it); } -LCRYPTO_ALIAS(i2d_ISSUING_DIST_POINT) +LCRYPTO_ALIAS(i2d_ISSUING_DIST_POINT); ISSUING_DIST_POINT * ISSUING_DIST_POINT_new(void) { return (ISSUING_DIST_POINT *)ASN1_item_new(&ISSUING_DIST_POINT_it); } -LCRYPTO_ALIAS(ISSUING_DIST_POINT_new) +LCRYPTO_ALIAS(ISSUING_DIST_POINT_new); void ISSUING_DIST_POINT_free(ISSUING_DIST_POINT *a) { ASN1_item_free((ASN1_VALUE *)a, &ISSUING_DIST_POINT_it); } -LCRYPTO_ALIAS(ISSUING_DIST_POINT_free) +LCRYPTO_ALIAS(ISSUING_DIST_POINT_free); static int i2r_idp(const X509V3_EXT_METHOD *method, void *pidp, BIO *out, int indent); @@ -825,4 +825,4 @@ DIST_POINT_set_dpname(DIST_POINT_NAME *dpn, X509_NAME *iname) } return 1; } -LCRYPTO_ALIAS(DIST_POINT_set_dpname) +LCRYPTO_ALIAS(DIST_POINT_set_dpname); diff --git a/lib/libcrypto/x509/x509_d2.c b/lib/libcrypto/x509/x509_d2.c index 522062a694b..bf358ec2997 100644 --- a/lib/libcrypto/x509/x509_d2.c +++ b/lib/libcrypto/x509/x509_d2.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_d2.c,v 1.11 2022/11/14 17:48:50 beck Exp $ */ +/* $OpenBSD: x509_d2.c,v 1.12 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -83,7 +83,7 @@ X509_STORE_set_default_paths(X509_STORE *ctx) return (1); } -LCRYPTO_ALIAS(X509_STORE_set_default_paths) +LCRYPTO_ALIAS(X509_STORE_set_default_paths); int X509_STORE_load_locations(X509_STORE *ctx, const char *file, const char *path) @@ -108,7 +108,7 @@ X509_STORE_load_locations(X509_STORE *ctx, const char *file, const char *path) return (0); return (1); } -LCRYPTO_ALIAS(X509_STORE_load_locations) +LCRYPTO_ALIAS(X509_STORE_load_locations); int X509_STORE_load_mem(X509_STORE *ctx, void *buf, int len) @@ -128,4 +128,4 @@ X509_STORE_load_mem(X509_STORE *ctx, void *buf, int len) return (1); } -LCRYPTO_ALIAS(X509_STORE_load_mem) +LCRYPTO_ALIAS(X509_STORE_load_mem); diff --git a/lib/libcrypto/x509/x509_def.c b/lib/libcrypto/x509/x509_def.c index 0d8900a5266..f85781afdd8 100644 --- a/lib/libcrypto/x509/x509_def.c +++ b/lib/libcrypto/x509/x509_def.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_def.c,v 1.6 2022/11/14 17:48:50 beck Exp $ */ +/* $OpenBSD: x509_def.c,v 1.7 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -66,39 +66,39 @@ X509_get_default_private_dir(void) { return (X509_PRIVATE_DIR); } -LCRYPTO_ALIAS(X509_get_default_private_dir) +LCRYPTO_ALIAS(X509_get_default_private_dir); const char * X509_get_default_cert_area(void) { return (X509_CERT_AREA); } -LCRYPTO_ALIAS(X509_get_default_cert_area) +LCRYPTO_ALIAS(X509_get_default_cert_area); const char * X509_get_default_cert_dir(void) { return (X509_CERT_DIR); } -LCRYPTO_ALIAS(X509_get_default_cert_dir) +LCRYPTO_ALIAS(X509_get_default_cert_dir); const char * X509_get_default_cert_file(void) { return (X509_CERT_FILE); } -LCRYPTO_ALIAS(X509_get_default_cert_file) +LCRYPTO_ALIAS(X509_get_default_cert_file); const char * X509_get_default_cert_dir_env(void) { return (X509_CERT_DIR_EVP); } -LCRYPTO_ALIAS(X509_get_default_cert_dir_env) +LCRYPTO_ALIAS(X509_get_default_cert_dir_env); const char * X509_get_default_cert_file_env(void) { return (X509_CERT_FILE_EVP); } -LCRYPTO_ALIAS(X509_get_default_cert_file_env) +LCRYPTO_ALIAS(X509_get_default_cert_file_env); diff --git a/lib/libcrypto/x509/x509_enum.c b/lib/libcrypto/x509/x509_enum.c index f0ab60a4b01..432239e0fe7 100644 --- a/lib/libcrypto/x509/x509_enum.c +++ b/lib/libcrypto/x509/x509_enum.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_enum.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */ +/* $OpenBSD: x509_enum.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -105,4 +105,4 @@ i2s_ASN1_ENUMERATED_TABLE(X509V3_EXT_METHOD *method, const ASN1_ENUMERATED *e) } return i2s_ASN1_ENUMERATED(method, e); } -LCRYPTO_ALIAS(i2s_ASN1_ENUMERATED_TABLE) +LCRYPTO_ALIAS(i2s_ASN1_ENUMERATED_TABLE); diff --git a/lib/libcrypto/x509/x509_err.c b/lib/libcrypto/x509/x509_err.c index c83655046aa..272d2894d86 100644 --- a/lib/libcrypto/x509/x509_err.c +++ b/lib/libcrypto/x509/x509_err.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_err.c,v 1.18 2022/11/14 17:48:50 beck Exp $ */ +/* $OpenBSD: x509_err.c,v 1.19 2023/02/16 08:38:17 tb Exp $ */ /* ==================================================================== * Copyright (c) 1999-2006 The OpenSSL Project. All rights reserved. * @@ -191,7 +191,7 @@ ERR_load_X509_strings(void) } #endif } -LCRYPTO_ALIAS(ERR_load_X509_strings) +LCRYPTO_ALIAS(ERR_load_X509_strings); void @@ -204,4 +204,4 @@ ERR_load_X509V3_strings(void) } #endif } -LCRYPTO_ALIAS(ERR_load_X509V3_strings) +LCRYPTO_ALIAS(ERR_load_X509V3_strings); diff --git a/lib/libcrypto/x509/x509_ext.c b/lib/libcrypto/x509/x509_ext.c index c173b7c687c..ce316d25bd5 100644 --- a/lib/libcrypto/x509/x509_ext.c +++ b/lib/libcrypto/x509/x509_ext.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_ext.c,v 1.15 2022/11/26 16:08:54 tb Exp $ */ +/* $OpenBSD: x509_ext.c,v 1.16 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -72,49 +72,49 @@ X509_CRL_get_ext_count(const X509_CRL *x) { return (X509v3_get_ext_count(x->crl->extensions)); } -LCRYPTO_ALIAS(X509_CRL_get_ext_count) +LCRYPTO_ALIAS(X509_CRL_get_ext_count); int X509_CRL_get_ext_by_NID(const X509_CRL *x, int nid, int lastpos) { return (X509v3_get_ext_by_NID(x->crl->extensions, nid, lastpos)); } -LCRYPTO_ALIAS(X509_CRL_get_ext_by_NID) +LCRYPTO_ALIAS(X509_CRL_get_ext_by_NID); int X509_CRL_get_ext_by_OBJ(const X509_CRL *x, const ASN1_OBJECT *obj, int lastpos) { return (X509v3_get_ext_by_OBJ(x->crl->extensions, obj, lastpos)); } -LCRYPTO_ALIAS(X509_CRL_get_ext_by_OBJ) +LCRYPTO_ALIAS(X509_CRL_get_ext_by_OBJ); int X509_CRL_get_ext_by_critical(const X509_CRL *x, int crit, int lastpos) { return (X509v3_get_ext_by_critical(x->crl->extensions, crit, lastpos)); } -LCRYPTO_ALIAS(X509_CRL_get_ext_by_critical) +LCRYPTO_ALIAS(X509_CRL_get_ext_by_critical); X509_EXTENSION * X509_CRL_get_ext(const X509_CRL *x, int loc) { return (X509v3_get_ext(x->crl->extensions, loc)); } -LCRYPTO_ALIAS(X509_CRL_get_ext) +LCRYPTO_ALIAS(X509_CRL_get_ext); X509_EXTENSION * X509_CRL_delete_ext(X509_CRL *x, int loc) { return (X509v3_delete_ext(x->crl->extensions, loc)); } -LCRYPTO_ALIAS(X509_CRL_delete_ext) +LCRYPTO_ALIAS(X509_CRL_delete_ext); void * X509_CRL_get_ext_d2i(const X509_CRL *x, int nid, int *crit, int *idx) { return X509V3_get_d2i(x->crl->extensions, nid, crit, idx); } -LCRYPTO_ALIAS(X509_CRL_get_ext_d2i) +LCRYPTO_ALIAS(X509_CRL_get_ext_d2i); int X509_CRL_add1_ext_i2d(X509_CRL *x, int nid, void *value, int crit, @@ -122,35 +122,35 @@ X509_CRL_add1_ext_i2d(X509_CRL *x, int nid, void *value, int crit, { return X509V3_add1_i2d(&x->crl->extensions, nid, value, crit, flags); } -LCRYPTO_ALIAS(X509_CRL_add1_ext_i2d) +LCRYPTO_ALIAS(X509_CRL_add1_ext_i2d); int X509_CRL_add_ext(X509_CRL *x, X509_EXTENSION *ex, int loc) { return (X509v3_add_ext(&(x->crl->extensions), ex, loc) != NULL); } -LCRYPTO_ALIAS(X509_CRL_add_ext) +LCRYPTO_ALIAS(X509_CRL_add_ext); int X509_get_ext_count(const X509 *x) { return (X509v3_get_ext_count(x->cert_info->extensions)); } -LCRYPTO_ALIAS(X509_get_ext_count) +LCRYPTO_ALIAS(X509_get_ext_count); int X509_get_ext_by_NID(const X509 *x, int nid, int lastpos) { return (X509v3_get_ext_by_NID(x->cert_info->extensions, nid, lastpos)); } -LCRYPTO_ALIAS(X509_get_ext_by_NID) +LCRYPTO_ALIAS(X509_get_ext_by_NID); int X509_get_ext_by_OBJ(const X509 *x, const ASN1_OBJECT *obj, int lastpos) { return (X509v3_get_ext_by_OBJ(x->cert_info->extensions, obj, lastpos)); } -LCRYPTO_ALIAS(X509_get_ext_by_OBJ) +LCRYPTO_ALIAS(X509_get_ext_by_OBJ); int X509_get_ext_by_critical(const X509 *x, int crit, int lastpos) @@ -158,35 +158,35 @@ X509_get_ext_by_critical(const X509 *x, int crit, int lastpos) return (X509v3_get_ext_by_critical(x->cert_info->extensions, crit, lastpos)); } -LCRYPTO_ALIAS(X509_get_ext_by_critical) +LCRYPTO_ALIAS(X509_get_ext_by_critical); X509_EXTENSION * X509_get_ext(const X509 *x, int loc) { return (X509v3_get_ext(x->cert_info->extensions, loc)); } -LCRYPTO_ALIAS(X509_get_ext) +LCRYPTO_ALIAS(X509_get_ext); X509_EXTENSION * X509_delete_ext(X509 *x, int loc) { return (X509v3_delete_ext(x->cert_info->extensions, loc)); } -LCRYPTO_ALIAS(X509_delete_ext) +LCRYPTO_ALIAS(X509_delete_ext); int X509_add_ext(X509 *x, X509_EXTENSION *ex, int loc) { return (X509v3_add_ext(&(x->cert_info->extensions), ex, loc) != NULL); } -LCRYPTO_ALIAS(X509_add_ext) +LCRYPTO_ALIAS(X509_add_ext); void * X509_get_ext_d2i(const X509 *x, int nid, int *crit, int *idx) { return X509V3_get_d2i(x->cert_info->extensions, nid, crit, idx); } -LCRYPTO_ALIAS(X509_get_ext_d2i) +LCRYPTO_ALIAS(X509_get_ext_d2i); int X509_add1_ext_i2d(X509 *x, int nid, void *value, int crit, unsigned long flags) @@ -194,21 +194,21 @@ X509_add1_ext_i2d(X509 *x, int nid, void *value, int crit, unsigned long flags) return X509V3_add1_i2d(&x->cert_info->extensions, nid, value, crit, flags); } -LCRYPTO_ALIAS(X509_add1_ext_i2d) +LCRYPTO_ALIAS(X509_add1_ext_i2d); int X509_REVOKED_get_ext_count(const X509_REVOKED *x) { return (X509v3_get_ext_count(x->extensions)); } -LCRYPTO_ALIAS(X509_REVOKED_get_ext_count) +LCRYPTO_ALIAS(X509_REVOKED_get_ext_count); int X509_REVOKED_get_ext_by_NID(const X509_REVOKED *x, int nid, int lastpos) { return (X509v3_get_ext_by_NID(x->extensions, nid, lastpos)); } -LCRYPTO_ALIAS(X509_REVOKED_get_ext_by_NID) +LCRYPTO_ALIAS(X509_REVOKED_get_ext_by_NID); int X509_REVOKED_get_ext_by_OBJ(const X509_REVOKED *x, const ASN1_OBJECT *obj, @@ -216,42 +216,42 @@ X509_REVOKED_get_ext_by_OBJ(const X509_REVOKED *x, const ASN1_OBJECT *obj, { return (X509v3_get_ext_by_OBJ(x->extensions, obj, lastpos)); } -LCRYPTO_ALIAS(X509_REVOKED_get_ext_by_OBJ) +LCRYPTO_ALIAS(X509_REVOKED_get_ext_by_OBJ); int X509_REVOKED_get_ext_by_critical(const X509_REVOKED *x, int crit, int lastpos) { return (X509v3_get_ext_by_critical(x->extensions, crit, lastpos)); } -LCRYPTO_ALIAS(X509_REVOKED_get_ext_by_critical) +LCRYPTO_ALIAS(X509_REVOKED_get_ext_by_critical); X509_EXTENSION * X509_REVOKED_get_ext(const X509_REVOKED *x, int loc) { return (X509v3_get_ext(x->extensions, loc)); } -LCRYPTO_ALIAS(X509_REVOKED_get_ext) +LCRYPTO_ALIAS(X509_REVOKED_get_ext); X509_EXTENSION * X509_REVOKED_delete_ext(X509_REVOKED *x, int loc) { return (X509v3_delete_ext(x->extensions, loc)); } -LCRYPTO_ALIAS(X509_REVOKED_delete_ext) +LCRYPTO_ALIAS(X509_REVOKED_delete_ext); int X509_REVOKED_add_ext(X509_REVOKED *x, X509_EXTENSION *ex, int loc) { return (X509v3_add_ext(&(x->extensions), ex, loc) != NULL); } -LCRYPTO_ALIAS(X509_REVOKED_add_ext) +LCRYPTO_ALIAS(X509_REVOKED_add_ext); void * X509_REVOKED_get_ext_d2i(const X509_REVOKED *x, int nid, int *crit, int *idx) { return X509V3_get_d2i(x->extensions, nid, crit, idx); } -LCRYPTO_ALIAS(X509_REVOKED_get_ext_d2i) +LCRYPTO_ALIAS(X509_REVOKED_get_ext_d2i); int X509_REVOKED_add1_ext_i2d(X509_REVOKED *x, int nid, void *value, int crit, @@ -259,4 +259,4 @@ X509_REVOKED_add1_ext_i2d(X509_REVOKED *x, int nid, void *value, int crit, { return X509V3_add1_i2d(&x->extensions, nid, value, crit, flags); } -LCRYPTO_ALIAS(X509_REVOKED_add1_ext_i2d) +LCRYPTO_ALIAS(X509_REVOKED_add1_ext_i2d); diff --git a/lib/libcrypto/x509/x509_extku.c b/lib/libcrypto/x509/x509_extku.c index cfdb23df75e..94032f624e7 100644 --- a/lib/libcrypto/x509/x509_extku.c +++ b/lib/libcrypto/x509/x509_extku.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_extku.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */ +/* $OpenBSD: x509_extku.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -128,28 +128,28 @@ d2i_EXTENDED_KEY_USAGE(EXTENDED_KEY_USAGE **a, const unsigned char **in, long le return (EXTENDED_KEY_USAGE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &EXTENDED_KEY_USAGE_it); } -LCRYPTO_ALIAS(d2i_EXTENDED_KEY_USAGE) +LCRYPTO_ALIAS(d2i_EXTENDED_KEY_USAGE); int i2d_EXTENDED_KEY_USAGE(EXTENDED_KEY_USAGE *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &EXTENDED_KEY_USAGE_it); } -LCRYPTO_ALIAS(i2d_EXTENDED_KEY_USAGE) +LCRYPTO_ALIAS(i2d_EXTENDED_KEY_USAGE); EXTENDED_KEY_USAGE * EXTENDED_KEY_USAGE_new(void) { return (EXTENDED_KEY_USAGE *)ASN1_item_new(&EXTENDED_KEY_USAGE_it); } -LCRYPTO_ALIAS(EXTENDED_KEY_USAGE_new) +LCRYPTO_ALIAS(EXTENDED_KEY_USAGE_new); void EXTENDED_KEY_USAGE_free(EXTENDED_KEY_USAGE *a) { ASN1_item_free((ASN1_VALUE *)a, &EXTENDED_KEY_USAGE_it); } -LCRYPTO_ALIAS(EXTENDED_KEY_USAGE_free) +LCRYPTO_ALIAS(EXTENDED_KEY_USAGE_free); static STACK_OF(CONF_VALUE) * i2v_EXTENDED_KEY_USAGE(const X509V3_EXT_METHOD *method, void *a, diff --git a/lib/libcrypto/x509/x509_genn.c b/lib/libcrypto/x509/x509_genn.c index 395d487f8f5..0c03396e0d2 100644 --- a/lib/libcrypto/x509/x509_genn.c +++ b/lib/libcrypto/x509/x509_genn.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_genn.c,v 1.4 2023/02/07 15:46:58 tb Exp $ */ +/* $OpenBSD: x509_genn.c,v 1.5 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -98,28 +98,28 @@ d2i_OTHERNAME(OTHERNAME **a, const unsigned char **in, long len) return (OTHERNAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &OTHERNAME_it); } -LCRYPTO_ALIAS(d2i_OTHERNAME) +LCRYPTO_ALIAS(d2i_OTHERNAME); int i2d_OTHERNAME(OTHERNAME *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &OTHERNAME_it); } -LCRYPTO_ALIAS(i2d_OTHERNAME) +LCRYPTO_ALIAS(i2d_OTHERNAME); OTHERNAME * OTHERNAME_new(void) { return (OTHERNAME *)ASN1_item_new(&OTHERNAME_it); } -LCRYPTO_ALIAS(OTHERNAME_new) +LCRYPTO_ALIAS(OTHERNAME_new); void OTHERNAME_free(OTHERNAME *a) { ASN1_item_free((ASN1_VALUE *)a, &OTHERNAME_it); } -LCRYPTO_ALIAS(OTHERNAME_free) +LCRYPTO_ALIAS(OTHERNAME_free); /* Uses explicit tagging since DIRECTORYSTRING is a CHOICE type */ static const ASN1_TEMPLATE EDIPARTYNAME_seq_tt[] = { @@ -156,28 +156,28 @@ d2i_EDIPARTYNAME(EDIPARTYNAME **a, const unsigned char **in, long len) return (EDIPARTYNAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &EDIPARTYNAME_it); } -LCRYPTO_ALIAS(d2i_EDIPARTYNAME) +LCRYPTO_ALIAS(d2i_EDIPARTYNAME); int i2d_EDIPARTYNAME(EDIPARTYNAME *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &EDIPARTYNAME_it); } -LCRYPTO_ALIAS(i2d_EDIPARTYNAME) +LCRYPTO_ALIAS(i2d_EDIPARTYNAME); EDIPARTYNAME * EDIPARTYNAME_new(void) { return (EDIPARTYNAME *)ASN1_item_new(&EDIPARTYNAME_it); } -LCRYPTO_ALIAS(EDIPARTYNAME_new) +LCRYPTO_ALIAS(EDIPARTYNAME_new); void EDIPARTYNAME_free(EDIPARTYNAME *a) { ASN1_item_free((ASN1_VALUE *)a, &EDIPARTYNAME_it); } -LCRYPTO_ALIAS(EDIPARTYNAME_free) +LCRYPTO_ALIAS(EDIPARTYNAME_free); static const ASN1_TEMPLATE GENERAL_NAME_ch_tt[] = { { @@ -264,28 +264,28 @@ d2i_GENERAL_NAME(GENERAL_NAME **a, const unsigned char **in, long len) return (GENERAL_NAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &GENERAL_NAME_it); } -LCRYPTO_ALIAS(d2i_GENERAL_NAME) +LCRYPTO_ALIAS(d2i_GENERAL_NAME); int i2d_GENERAL_NAME(GENERAL_NAME *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &GENERAL_NAME_it); } -LCRYPTO_ALIAS(i2d_GENERAL_NAME) +LCRYPTO_ALIAS(i2d_GENERAL_NAME); GENERAL_NAME * GENERAL_NAME_new(void) { return (GENERAL_NAME *)ASN1_item_new(&GENERAL_NAME_it); } -LCRYPTO_ALIAS(GENERAL_NAME_new) +LCRYPTO_ALIAS(GENERAL_NAME_new); void GENERAL_NAME_free(GENERAL_NAME *a) { ASN1_item_free((ASN1_VALUE *)a, &GENERAL_NAME_it); } -LCRYPTO_ALIAS(GENERAL_NAME_free) +LCRYPTO_ALIAS(GENERAL_NAME_free); static const ASN1_TEMPLATE GENERAL_NAMES_item_tt = { .flags = ASN1_TFLG_SEQUENCE_OF, @@ -312,35 +312,35 @@ d2i_GENERAL_NAMES(GENERAL_NAMES **a, const unsigned char **in, long len) return (GENERAL_NAMES *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &GENERAL_NAMES_it); } -LCRYPTO_ALIAS(d2i_GENERAL_NAMES) +LCRYPTO_ALIAS(d2i_GENERAL_NAMES); int i2d_GENERAL_NAMES(GENERAL_NAMES *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &GENERAL_NAMES_it); } -LCRYPTO_ALIAS(i2d_GENERAL_NAMES) +LCRYPTO_ALIAS(i2d_GENERAL_NAMES); GENERAL_NAMES * GENERAL_NAMES_new(void) { return (GENERAL_NAMES *)ASN1_item_new(&GENERAL_NAMES_it); } -LCRYPTO_ALIAS(GENERAL_NAMES_new) +LCRYPTO_ALIAS(GENERAL_NAMES_new); void GENERAL_NAMES_free(GENERAL_NAMES *a) { ASN1_item_free((ASN1_VALUE *)a, &GENERAL_NAMES_it); } -LCRYPTO_ALIAS(GENERAL_NAMES_free) +LCRYPTO_ALIAS(GENERAL_NAMES_free); GENERAL_NAME * GENERAL_NAME_dup(GENERAL_NAME *a) { return ASN1_item_dup(&GENERAL_NAME_it, a); } -LCRYPTO_ALIAS(GENERAL_NAME_dup) +LCRYPTO_ALIAS(GENERAL_NAME_dup); static int EDIPARTYNAME_cmp(const EDIPARTYNAME *a, const EDIPARTYNAME *b) @@ -415,7 +415,7 @@ GENERAL_NAME_cmp(GENERAL_NAME *a, GENERAL_NAME *b) } return result; } -LCRYPTO_ALIAS(GENERAL_NAME_cmp) +LCRYPTO_ALIAS(GENERAL_NAME_cmp); /* Returns 0 if they are equal, != 0 otherwise. */ int @@ -432,7 +432,7 @@ OTHERNAME_cmp(OTHERNAME *a, OTHERNAME *b) result = ASN1_TYPE_cmp(a->value, b->value); return result; } -LCRYPTO_ALIAS(OTHERNAME_cmp) +LCRYPTO_ALIAS(OTHERNAME_cmp); void GENERAL_NAME_set0_value(GENERAL_NAME *a, int type, void *value) @@ -470,7 +470,7 @@ GENERAL_NAME_set0_value(GENERAL_NAME *a, int type, void *value) } a->type = type; } -LCRYPTO_ALIAS(GENERAL_NAME_set0_value) +LCRYPTO_ALIAS(GENERAL_NAME_set0_value); void * GENERAL_NAME_get0_value(GENERAL_NAME *a, int *ptype) @@ -505,7 +505,7 @@ GENERAL_NAME_get0_value(GENERAL_NAME *a, int *ptype) return NULL; } } -LCRYPTO_ALIAS(GENERAL_NAME_get0_value) +LCRYPTO_ALIAS(GENERAL_NAME_get0_value); int GENERAL_NAME_set0_othername(GENERAL_NAME *gen, ASN1_OBJECT *oid, @@ -521,7 +521,7 @@ GENERAL_NAME_set0_othername(GENERAL_NAME *gen, ASN1_OBJECT *oid, GENERAL_NAME_set0_value(gen, GEN_OTHERNAME, oth); return 1; } -LCRYPTO_ALIAS(GENERAL_NAME_set0_othername) +LCRYPTO_ALIAS(GENERAL_NAME_set0_othername); int GENERAL_NAME_get0_otherName(GENERAL_NAME *gen, ASN1_OBJECT **poid, @@ -535,4 +535,4 @@ GENERAL_NAME_get0_otherName(GENERAL_NAME *gen, ASN1_OBJECT **poid, *pvalue = gen->d.otherName->value; return 1; } -LCRYPTO_ALIAS(GENERAL_NAME_get0_otherName) +LCRYPTO_ALIAS(GENERAL_NAME_get0_otherName); diff --git a/lib/libcrypto/x509/x509_info.c b/lib/libcrypto/x509/x509_info.c index 6c7fd13601e..a3d4d1bcc7b 100644 --- a/lib/libcrypto/x509/x509_info.c +++ b/lib/libcrypto/x509/x509_info.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_info.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */ +/* $OpenBSD: x509_info.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -139,28 +139,28 @@ d2i_ACCESS_DESCRIPTION(ACCESS_DESCRIPTION **a, const unsigned char **in, long le return (ACCESS_DESCRIPTION *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &ACCESS_DESCRIPTION_it); } -LCRYPTO_ALIAS(d2i_ACCESS_DESCRIPTION) +LCRYPTO_ALIAS(d2i_ACCESS_DESCRIPTION); int i2d_ACCESS_DESCRIPTION(ACCESS_DESCRIPTION *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &ACCESS_DESCRIPTION_it); } -LCRYPTO_ALIAS(i2d_ACCESS_DESCRIPTION) +LCRYPTO_ALIAS(i2d_ACCESS_DESCRIPTION); ACCESS_DESCRIPTION * ACCESS_DESCRIPTION_new(void) { return (ACCESS_DESCRIPTION *)ASN1_item_new(&ACCESS_DESCRIPTION_it); } -LCRYPTO_ALIAS(ACCESS_DESCRIPTION_new) +LCRYPTO_ALIAS(ACCESS_DESCRIPTION_new); void ACCESS_DESCRIPTION_free(ACCESS_DESCRIPTION *a) { ASN1_item_free((ASN1_VALUE *)a, &ACCESS_DESCRIPTION_it); } -LCRYPTO_ALIAS(ACCESS_DESCRIPTION_free) +LCRYPTO_ALIAS(ACCESS_DESCRIPTION_free); static const ASN1_TEMPLATE AUTHORITY_INFO_ACCESS_item_tt = { .flags = ASN1_TFLG_SEQUENCE_OF, @@ -187,28 +187,28 @@ d2i_AUTHORITY_INFO_ACCESS(AUTHORITY_INFO_ACCESS **a, const unsigned char **in, l return (AUTHORITY_INFO_ACCESS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &AUTHORITY_INFO_ACCESS_it); } -LCRYPTO_ALIAS(d2i_AUTHORITY_INFO_ACCESS) +LCRYPTO_ALIAS(d2i_AUTHORITY_INFO_ACCESS); int i2d_AUTHORITY_INFO_ACCESS(AUTHORITY_INFO_ACCESS *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &AUTHORITY_INFO_ACCESS_it); } -LCRYPTO_ALIAS(i2d_AUTHORITY_INFO_ACCESS) +LCRYPTO_ALIAS(i2d_AUTHORITY_INFO_ACCESS); AUTHORITY_INFO_ACCESS * AUTHORITY_INFO_ACCESS_new(void) { return (AUTHORITY_INFO_ACCESS *)ASN1_item_new(&AUTHORITY_INFO_ACCESS_it); } -LCRYPTO_ALIAS(AUTHORITY_INFO_ACCESS_new) +LCRYPTO_ALIAS(AUTHORITY_INFO_ACCESS_new); void AUTHORITY_INFO_ACCESS_free(AUTHORITY_INFO_ACCESS *a) { ASN1_item_free((ASN1_VALUE *)a, &AUTHORITY_INFO_ACCESS_it); } -LCRYPTO_ALIAS(AUTHORITY_INFO_ACCESS_free) +LCRYPTO_ALIAS(AUTHORITY_INFO_ACCESS_free); static STACK_OF(CONF_VALUE) * i2v_AUTHORITY_INFO_ACCESS(X509V3_EXT_METHOD *method, @@ -314,4 +314,4 @@ i2a_ACCESS_DESCRIPTION(BIO *bp, const ACCESS_DESCRIPTION* a) i2a_ASN1_OBJECT(bp, a->method); return 2; } -LCRYPTO_ALIAS(i2a_ACCESS_DESCRIPTION) +LCRYPTO_ALIAS(i2a_ACCESS_DESCRIPTION); diff --git a/lib/libcrypto/x509/x509_lib.c b/lib/libcrypto/x509/x509_lib.c index f27e3315aaa..97d54edd3f4 100644 --- a/lib/libcrypto/x509/x509_lib.c +++ b/lib/libcrypto/x509/x509_lib.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_lib.c,v 1.6 2022/11/26 16:08:54 tb Exp $ */ +/* $OpenBSD: x509_lib.c,v 1.7 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -85,7 +85,7 @@ X509V3_EXT_add(X509V3_EXT_METHOD *ext) } return 1; } -LCRYPTO_ALIAS(X509V3_EXT_add) +LCRYPTO_ALIAS(X509V3_EXT_add); static int ext_cmp(const X509V3_EXT_METHOD * const *a, const X509V3_EXT_METHOD * const *b) @@ -133,7 +133,7 @@ X509V3_EXT_get_nid(int nid) return NULL; return sk_X509V3_EXT_METHOD_value(ext_list, idx); } -LCRYPTO_ALIAS(X509V3_EXT_get_nid) +LCRYPTO_ALIAS(X509V3_EXT_get_nid); const X509V3_EXT_METHOD * X509V3_EXT_get(X509_EXTENSION *ext) @@ -144,7 +144,7 @@ X509V3_EXT_get(X509_EXTENSION *ext) return NULL; return X509V3_EXT_get_nid(nid); } -LCRYPTO_ALIAS(X509V3_EXT_get) +LCRYPTO_ALIAS(X509V3_EXT_get); int X509V3_EXT_add_list(X509V3_EXT_METHOD *extlist) @@ -154,7 +154,7 @@ X509V3_EXT_add_list(X509V3_EXT_METHOD *extlist) return 0; return 1; } -LCRYPTO_ALIAS(X509V3_EXT_add_list) +LCRYPTO_ALIAS(X509V3_EXT_add_list); int X509V3_EXT_add_alias(int nid_to, int nid_from) @@ -179,7 +179,7 @@ X509V3_EXT_add_alias(int nid_to, int nid_from) } return 1; } -LCRYPTO_ALIAS(X509V3_EXT_add_alias) +LCRYPTO_ALIAS(X509V3_EXT_add_alias); void X509V3_EXT_cleanup(void) @@ -187,7 +187,7 @@ X509V3_EXT_cleanup(void) sk_X509V3_EXT_METHOD_pop_free(ext_list, ext_list_free); ext_list = NULL; } -LCRYPTO_ALIAS(X509V3_EXT_cleanup) +LCRYPTO_ALIAS(X509V3_EXT_cleanup); static void ext_list_free(X509V3_EXT_METHOD *ext) @@ -205,7 +205,7 @@ X509V3_add_standard_extensions(void) { return 1; } -LCRYPTO_ALIAS(X509V3_add_standard_extensions) +LCRYPTO_ALIAS(X509V3_add_standard_extensions); /* Return an extension internal structure */ @@ -223,7 +223,7 @@ X509V3_EXT_d2i(X509_EXTENSION *ext) method->it); return method->d2i(NULL, &p, ext->value->length); } -LCRYPTO_ALIAS(X509V3_EXT_d2i) +LCRYPTO_ALIAS(X509V3_EXT_d2i); /* Get critical flag and decoded version of extension from a NID. * The "idx" variable returns the last found extension and can @@ -289,7 +289,7 @@ X509V3_get_d2i(const STACK_OF(X509_EXTENSION) *x, int nid, int *crit, int *idx) *crit = -1; return NULL; } -LCRYPTO_ALIAS(X509V3_get_d2i) +LCRYPTO_ALIAS(X509V3_get_d2i); /* This function is a general extension append, replace and delete utility. * The precise operation is governed by the 'flags' value. The 'crit' and @@ -371,4 +371,4 @@ err: X509V3error(errcode); return 0; } -LCRYPTO_ALIAS(X509V3_add1_i2d) +LCRYPTO_ALIAS(X509V3_add1_i2d); diff --git a/lib/libcrypto/x509/x509_lu.c b/lib/libcrypto/x509/x509_lu.c index 28cb85035b2..65d11d91079 100644 --- a/lib/libcrypto/x509/x509_lu.c +++ b/lib/libcrypto/x509/x509_lu.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_lu.c,v 1.57 2022/11/26 16:08:54 tb Exp $ */ +/* $OpenBSD: x509_lu.c,v 1.58 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -84,7 +84,7 @@ X509_LOOKUP_new(X509_LOOKUP_METHOD *method) return lu; } -LCRYPTO_ALIAS(X509_LOOKUP_new) +LCRYPTO_ALIAS(X509_LOOKUP_new); void X509_LOOKUP_free(X509_LOOKUP *ctx) @@ -95,7 +95,7 @@ X509_LOOKUP_free(X509_LOOKUP *ctx) ctx->method->free(ctx); free(ctx); } -LCRYPTO_ALIAS(X509_LOOKUP_free) +LCRYPTO_ALIAS(X509_LOOKUP_free); int X509_LOOKUP_init(X509_LOOKUP *ctx) @@ -106,7 +106,7 @@ X509_LOOKUP_init(X509_LOOKUP *ctx) return 1; return ctx->method->init(ctx); } -LCRYPTO_ALIAS(X509_LOOKUP_init) +LCRYPTO_ALIAS(X509_LOOKUP_init); int X509_LOOKUP_shutdown(X509_LOOKUP *ctx) @@ -117,7 +117,7 @@ X509_LOOKUP_shutdown(X509_LOOKUP *ctx) return 1; return ctx->method->shutdown(ctx); } -LCRYPTO_ALIAS(X509_LOOKUP_shutdown) +LCRYPTO_ALIAS(X509_LOOKUP_shutdown); int X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc, long argl, @@ -129,7 +129,7 @@ X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc, long argl, return 1; return ctx->method->ctrl(ctx, cmd, argc, argl, ret); } -LCRYPTO_ALIAS(X509_LOOKUP_ctrl) +LCRYPTO_ALIAS(X509_LOOKUP_ctrl); int X509_LOOKUP_by_subject(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, X509_NAME *name, @@ -139,7 +139,7 @@ X509_LOOKUP_by_subject(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, X509_NAME *name, return 0; return ctx->method->get_by_subject(ctx, type, name, ret); } -LCRYPTO_ALIAS(X509_LOOKUP_by_subject) +LCRYPTO_ALIAS(X509_LOOKUP_by_subject); int X509_LOOKUP_by_issuer_serial(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, @@ -149,7 +149,7 @@ X509_LOOKUP_by_issuer_serial(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, return 0; return ctx->method->get_by_issuer_serial(ctx, type, name, serial, ret); } -LCRYPTO_ALIAS(X509_LOOKUP_by_issuer_serial) +LCRYPTO_ALIAS(X509_LOOKUP_by_issuer_serial); int X509_LOOKUP_by_fingerprint(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, @@ -159,7 +159,7 @@ X509_LOOKUP_by_fingerprint(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, return 0; return ctx->method->get_by_fingerprint(ctx, type, bytes, len, ret); } -LCRYPTO_ALIAS(X509_LOOKUP_by_fingerprint) +LCRYPTO_ALIAS(X509_LOOKUP_by_fingerprint); int X509_LOOKUP_by_alias(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, const char *str, @@ -169,7 +169,7 @@ X509_LOOKUP_by_alias(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, const char *str, return 0; return ctx->method->get_by_alias(ctx, type, str, len, ret); } -LCRYPTO_ALIAS(X509_LOOKUP_by_alias) +LCRYPTO_ALIAS(X509_LOOKUP_by_alias); static int x509_object_cmp(const X509_OBJECT * const *a, const X509_OBJECT * const *b) @@ -217,7 +217,7 @@ X509_STORE_new(void) return NULL; } -LCRYPTO_ALIAS(X509_STORE_new) +LCRYPTO_ALIAS(X509_STORE_new); X509_OBJECT * X509_OBJECT_new(void) @@ -233,7 +233,7 @@ X509_OBJECT_new(void) return obj; } -LCRYPTO_ALIAS(X509_OBJECT_new) +LCRYPTO_ALIAS(X509_OBJECT_new); void X509_OBJECT_free(X509_OBJECT *a) @@ -252,7 +252,7 @@ X509_OBJECT_free(X509_OBJECT *a) free(a); } -LCRYPTO_ALIAS(X509_OBJECT_free) +LCRYPTO_ALIAS(X509_OBJECT_free); void X509_STORE_free(X509_STORE *store) @@ -280,14 +280,14 @@ X509_STORE_free(X509_STORE *store) X509_VERIFY_PARAM_free(store->param); free(store); } -LCRYPTO_ALIAS(X509_STORE_free) +LCRYPTO_ALIAS(X509_STORE_free); int X509_STORE_up_ref(X509_STORE *store) { return CRYPTO_add(&store->references, 1, CRYPTO_LOCK_X509_STORE) > 1; } -LCRYPTO_ALIAS(X509_STORE_up_ref) +LCRYPTO_ALIAS(X509_STORE_up_ref); X509_LOOKUP * X509_STORE_add_lookup(X509_STORE *store, X509_LOOKUP_METHOD *method) @@ -316,7 +316,7 @@ X509_STORE_add_lookup(X509_STORE *store, X509_LOOKUP_METHOD *method) return lu; } -LCRYPTO_ALIAS(X509_STORE_add_lookup) +LCRYPTO_ALIAS(X509_STORE_add_lookup); X509_OBJECT * X509_STORE_CTX_get_obj_by_subject(X509_STORE_CTX *vs, X509_LOOKUP_TYPE type, @@ -333,7 +333,7 @@ X509_STORE_CTX_get_obj_by_subject(X509_STORE_CTX *vs, X509_LOOKUP_TYPE type, return obj; } -LCRYPTO_ALIAS(X509_STORE_CTX_get_obj_by_subject) +LCRYPTO_ALIAS(X509_STORE_CTX_get_obj_by_subject); int X509_STORE_CTX_get_by_subject(X509_STORE_CTX *vs, X509_LOOKUP_TYPE type, @@ -372,7 +372,7 @@ X509_STORE_CTX_get_by_subject(X509_STORE_CTX *vs, X509_LOOKUP_TYPE type, return 1; } -LCRYPTO_ALIAS(X509_STORE_CTX_get_by_subject) +LCRYPTO_ALIAS(X509_STORE_CTX_get_by_subject); /* Add obj to the store. Takes ownership of obj. */ static int @@ -424,7 +424,7 @@ X509_STORE_add_cert(X509_STORE *store, X509 *x) return X509_STORE_add_object(store, obj); } -LCRYPTO_ALIAS(X509_STORE_add_cert) +LCRYPTO_ALIAS(X509_STORE_add_cert); int X509_STORE_add_crl(X509_STORE *store, X509_CRL *x) @@ -447,7 +447,7 @@ X509_STORE_add_crl(X509_STORE *store, X509_CRL *x) return X509_STORE_add_object(store, obj); } -LCRYPTO_ALIAS(X509_STORE_add_crl) +LCRYPTO_ALIAS(X509_STORE_add_crl); int X509_OBJECT_up_ref_count(X509_OBJECT *a) @@ -460,14 +460,14 @@ X509_OBJECT_up_ref_count(X509_OBJECT *a) } return 1; } -LCRYPTO_ALIAS(X509_OBJECT_up_ref_count) +LCRYPTO_ALIAS(X509_OBJECT_up_ref_count); X509_LOOKUP_TYPE X509_OBJECT_get_type(const X509_OBJECT *a) { return a->type; } -LCRYPTO_ALIAS(X509_OBJECT_get_type) +LCRYPTO_ALIAS(X509_OBJECT_get_type); static int x509_object_idx_cnt(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type, @@ -519,7 +519,7 @@ X509_OBJECT_idx_by_subject(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type, { return x509_object_idx_cnt(h, type, name, NULL); } -LCRYPTO_ALIAS(X509_OBJECT_idx_by_subject) +LCRYPTO_ALIAS(X509_OBJECT_idx_by_subject); X509_OBJECT * X509_OBJECT_retrieve_by_subject(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type, @@ -532,7 +532,7 @@ X509_OBJECT_retrieve_by_subject(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type, return NULL; return sk_X509_OBJECT_value(h, idx); } -LCRYPTO_ALIAS(X509_OBJECT_retrieve_by_subject) +LCRYPTO_ALIAS(X509_OBJECT_retrieve_by_subject); X509 * X509_OBJECT_get0_X509(const X509_OBJECT *xo) @@ -541,7 +541,7 @@ X509_OBJECT_get0_X509(const X509_OBJECT *xo) return xo->data.x509; return NULL; } -LCRYPTO_ALIAS(X509_OBJECT_get0_X509) +LCRYPTO_ALIAS(X509_OBJECT_get0_X509); X509_CRL * X509_OBJECT_get0_X509_CRL(X509_OBJECT *xo) @@ -550,7 +550,7 @@ X509_OBJECT_get0_X509_CRL(X509_OBJECT *xo) return xo->data.crl; return NULL; } -LCRYPTO_ALIAS(X509_OBJECT_get0_X509_CRL) +LCRYPTO_ALIAS(X509_OBJECT_get0_X509_CRL); static STACK_OF(X509) * X509_get1_certs_from_cache(X509_STORE *store, X509_NAME *name) @@ -614,7 +614,7 @@ X509_STORE_get1_certs(X509_STORE_CTX *ctx, X509_NAME *name) return X509_get1_certs_from_cache(store, name); } -LCRYPTO_ALIAS(X509_STORE_get1_certs) +LCRYPTO_ALIAS(X509_STORE_get1_certs); STACK_OF(X509_CRL) * X509_STORE_get1_crls(X509_STORE_CTX *ctx, X509_NAME *name) @@ -665,7 +665,7 @@ X509_STORE_get1_crls(X509_STORE_CTX *ctx, X509_NAME *name) sk_X509_CRL_pop_free(sk, X509_CRL_free); return NULL; } -LCRYPTO_ALIAS(X509_STORE_get1_crls) +LCRYPTO_ALIAS(X509_STORE_get1_crls); X509_OBJECT * X509_OBJECT_retrieve_match(STACK_OF(X509_OBJECT) *h, X509_OBJECT *x) @@ -694,7 +694,7 @@ X509_OBJECT_retrieve_match(STACK_OF(X509_OBJECT) *h, X509_OBJECT *x) } return NULL; } -LCRYPTO_ALIAS(X509_OBJECT_retrieve_match) +LCRYPTO_ALIAS(X509_OBJECT_retrieve_match); /* Try to get issuer certificate from store. Due to limitations * of the API this can only retrieve a single certificate matching @@ -785,35 +785,35 @@ X509_STORE_CTX_get1_issuer(X509 **out_issuer, X509_STORE_CTX *ctx, X509 *x) CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE); return ret; } -LCRYPTO_ALIAS(X509_STORE_CTX_get1_issuer) +LCRYPTO_ALIAS(X509_STORE_CTX_get1_issuer); STACK_OF(X509_OBJECT) * X509_STORE_get0_objects(X509_STORE *xs) { return xs->objs; } -LCRYPTO_ALIAS(X509_STORE_get0_objects) +LCRYPTO_ALIAS(X509_STORE_get0_objects); void * X509_STORE_get_ex_data(X509_STORE *xs, int idx) { return CRYPTO_get_ex_data(&xs->ex_data, idx); } -LCRYPTO_ALIAS(X509_STORE_get_ex_data) +LCRYPTO_ALIAS(X509_STORE_get_ex_data); int X509_STORE_set_ex_data(X509_STORE *xs, int idx, void *data) { return CRYPTO_set_ex_data(&xs->ex_data, idx, data); } -LCRYPTO_ALIAS(X509_STORE_set_ex_data) +LCRYPTO_ALIAS(X509_STORE_set_ex_data); int X509_STORE_set_flags(X509_STORE *ctx, unsigned long flags) { return X509_VERIFY_PARAM_set_flags(ctx->param, flags); } -LCRYPTO_ALIAS(X509_STORE_set_flags) +LCRYPTO_ALIAS(X509_STORE_set_flags); int X509_STORE_set_depth(X509_STORE *ctx, int depth) @@ -821,60 +821,60 @@ X509_STORE_set_depth(X509_STORE *ctx, int depth) X509_VERIFY_PARAM_set_depth(ctx->param, depth); return 1; } -LCRYPTO_ALIAS(X509_STORE_set_depth) +LCRYPTO_ALIAS(X509_STORE_set_depth); int X509_STORE_set_purpose(X509_STORE *ctx, int purpose) { return X509_VERIFY_PARAM_set_purpose(ctx->param, purpose); } -LCRYPTO_ALIAS(X509_STORE_set_purpose) +LCRYPTO_ALIAS(X509_STORE_set_purpose); int X509_STORE_set_trust(X509_STORE *ctx, int trust) { return X509_VERIFY_PARAM_set_trust(ctx->param, trust); } -LCRYPTO_ALIAS(X509_STORE_set_trust) +LCRYPTO_ALIAS(X509_STORE_set_trust); int X509_STORE_set1_param(X509_STORE *ctx, X509_VERIFY_PARAM *param) { return X509_VERIFY_PARAM_set1(ctx->param, param); } -LCRYPTO_ALIAS(X509_STORE_set1_param) +LCRYPTO_ALIAS(X509_STORE_set1_param); X509_VERIFY_PARAM * X509_STORE_get0_param(X509_STORE *ctx) { return ctx->param; } -LCRYPTO_ALIAS(X509_STORE_get0_param) +LCRYPTO_ALIAS(X509_STORE_get0_param); void X509_STORE_set_verify(X509_STORE *store, X509_STORE_CTX_verify_fn verify) { store->verify = verify; } -LCRYPTO_ALIAS(X509_STORE_set_verify) +LCRYPTO_ALIAS(X509_STORE_set_verify); X509_STORE_CTX_verify_fn X509_STORE_get_verify(X509_STORE *store) { return store->verify; } -LCRYPTO_ALIAS(X509_STORE_get_verify) +LCRYPTO_ALIAS(X509_STORE_get_verify); void X509_STORE_set_verify_cb(X509_STORE *store, X509_STORE_CTX_verify_cb verify_cb) { store->verify_cb = verify_cb; } -LCRYPTO_ALIAS(X509_STORE_set_verify_cb) +LCRYPTO_ALIAS(X509_STORE_set_verify_cb); X509_STORE_CTX_verify_cb X509_STORE_get_verify_cb(X509_STORE *store) { return store->verify_cb; } -LCRYPTO_ALIAS(X509_STORE_get_verify_cb) +LCRYPTO_ALIAS(X509_STORE_get_verify_cb); diff --git a/lib/libcrypto/x509/x509_ncons.c b/lib/libcrypto/x509/x509_ncons.c index c7e4e6ed9f5..159e3c25636 100644 --- a/lib/libcrypto/x509/x509_ncons.c +++ b/lib/libcrypto/x509/x509_ncons.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_ncons.c,v 1.8 2022/12/26 07:18:53 jmc Exp $ */ +/* $OpenBSD: x509_ncons.c,v 1.9 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project. */ @@ -165,28 +165,28 @@ GENERAL_SUBTREE_new(void) { return (GENERAL_SUBTREE*)ASN1_item_new(&GENERAL_SUBTREE_it); } -LCRYPTO_ALIAS(GENERAL_SUBTREE_new) +LCRYPTO_ALIAS(GENERAL_SUBTREE_new); void GENERAL_SUBTREE_free(GENERAL_SUBTREE *a) { ASN1_item_free((ASN1_VALUE *)a, &GENERAL_SUBTREE_it); } -LCRYPTO_ALIAS(GENERAL_SUBTREE_free) +LCRYPTO_ALIAS(GENERAL_SUBTREE_free); NAME_CONSTRAINTS * NAME_CONSTRAINTS_new(void) { return (NAME_CONSTRAINTS*)ASN1_item_new(&NAME_CONSTRAINTS_it); } -LCRYPTO_ALIAS(NAME_CONSTRAINTS_new) +LCRYPTO_ALIAS(NAME_CONSTRAINTS_new); void NAME_CONSTRAINTS_free(NAME_CONSTRAINTS *a) { ASN1_item_free((ASN1_VALUE *)a, &NAME_CONSTRAINTS_it); } -LCRYPTO_ALIAS(NAME_CONSTRAINTS_free) +LCRYPTO_ALIAS(NAME_CONSTRAINTS_free); static void * v2i_NAME_CONSTRAINTS(const X509V3_EXT_METHOD *method, X509V3_CTX *ctx, @@ -353,7 +353,7 @@ NAME_CONSTRAINTS_check(X509 *x, NAME_CONSTRAINTS *nc) } return X509_V_OK; } -LCRYPTO_ALIAS(NAME_CONSTRAINTS_check) +LCRYPTO_ALIAS(NAME_CONSTRAINTS_check); static int nc_match(GENERAL_NAME *gen, NAME_CONSTRAINTS *nc) { diff --git a/lib/libcrypto/x509/x509_obj.c b/lib/libcrypto/x509/x509_obj.c index f9323cf5bc6..ea4ae6b98aa 100644 --- a/lib/libcrypto/x509/x509_obj.c +++ b/lib/libcrypto/x509/x509_obj.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_obj.c,v 1.21 2022/11/26 16:08:55 tb Exp $ */ +/* $OpenBSD: x509_obj.c,v 1.22 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -179,4 +179,4 @@ err: BUF_MEM_free(b); return (NULL); } -LCRYPTO_ALIAS(X509_NAME_oneline) +LCRYPTO_ALIAS(X509_NAME_oneline); diff --git a/lib/libcrypto/x509/x509_pcia.c b/lib/libcrypto/x509/x509_pcia.c index fb14384e995..ec8d03a86b9 100644 --- a/lib/libcrypto/x509/x509_pcia.c +++ b/lib/libcrypto/x509/x509_pcia.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_pcia.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */ +/* $OpenBSD: x509_pcia.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */ /* Contributed to the OpenSSL Project 2004 * by Richard Levitte (richard@levitte.org) */ @@ -72,28 +72,28 @@ d2i_PROXY_POLICY(PROXY_POLICY **a, const unsigned char **in, long len) return (PROXY_POLICY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &PROXY_POLICY_it); } -LCRYPTO_ALIAS(d2i_PROXY_POLICY) +LCRYPTO_ALIAS(d2i_PROXY_POLICY); int i2d_PROXY_POLICY(PROXY_POLICY *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &PROXY_POLICY_it); } -LCRYPTO_ALIAS(i2d_PROXY_POLICY) +LCRYPTO_ALIAS(i2d_PROXY_POLICY); PROXY_POLICY * PROXY_POLICY_new(void) { return (PROXY_POLICY *)ASN1_item_new(&PROXY_POLICY_it); } -LCRYPTO_ALIAS(PROXY_POLICY_new) +LCRYPTO_ALIAS(PROXY_POLICY_new); void PROXY_POLICY_free(PROXY_POLICY *a) { ASN1_item_free((ASN1_VALUE *)a, &PROXY_POLICY_it); } -LCRYPTO_ALIAS(PROXY_POLICY_free) +LCRYPTO_ALIAS(PROXY_POLICY_free); static const ASN1_TEMPLATE PROXY_CERT_INFO_EXTENSION_seq_tt[] = { { @@ -129,25 +129,25 @@ d2i_PROXY_CERT_INFO_EXTENSION(PROXY_CERT_INFO_EXTENSION **a, const unsigned char return (PROXY_CERT_INFO_EXTENSION *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &PROXY_CERT_INFO_EXTENSION_it); } -LCRYPTO_ALIAS(d2i_PROXY_CERT_INFO_EXTENSION) +LCRYPTO_ALIAS(d2i_PROXY_CERT_INFO_EXTENSION); int i2d_PROXY_CERT_INFO_EXTENSION(PROXY_CERT_INFO_EXTENSION *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &PROXY_CERT_INFO_EXTENSION_it); } -LCRYPTO_ALIAS(i2d_PROXY_CERT_INFO_EXTENSION) +LCRYPTO_ALIAS(i2d_PROXY_CERT_INFO_EXTENSION); PROXY_CERT_INFO_EXTENSION * PROXY_CERT_INFO_EXTENSION_new(void) { return (PROXY_CERT_INFO_EXTENSION *)ASN1_item_new(&PROXY_CERT_INFO_EXTENSION_it); } -LCRYPTO_ALIAS(PROXY_CERT_INFO_EXTENSION_new) +LCRYPTO_ALIAS(PROXY_CERT_INFO_EXTENSION_new); void PROXY_CERT_INFO_EXTENSION_free(PROXY_CERT_INFO_EXTENSION *a) { ASN1_item_free((ASN1_VALUE *)a, &PROXY_CERT_INFO_EXTENSION_it); } -LCRYPTO_ALIAS(PROXY_CERT_INFO_EXTENSION_free) +LCRYPTO_ALIAS(PROXY_CERT_INFO_EXTENSION_free); diff --git a/lib/libcrypto/x509/x509_pcons.c b/lib/libcrypto/x509/x509_pcons.c index 2448147fdb7..0ee935540f8 100644 --- a/lib/libcrypto/x509/x509_pcons.c +++ b/lib/libcrypto/x509/x509_pcons.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_pcons.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */ +/* $OpenBSD: x509_pcons.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project. */ @@ -121,14 +121,14 @@ POLICY_CONSTRAINTS_new(void) { return (POLICY_CONSTRAINTS*)ASN1_item_new(&POLICY_CONSTRAINTS_it); } -LCRYPTO_ALIAS(POLICY_CONSTRAINTS_new) +LCRYPTO_ALIAS(POLICY_CONSTRAINTS_new); void POLICY_CONSTRAINTS_free(POLICY_CONSTRAINTS *a) { ASN1_item_free((ASN1_VALUE *)a, &POLICY_CONSTRAINTS_it); } -LCRYPTO_ALIAS(POLICY_CONSTRAINTS_free) +LCRYPTO_ALIAS(POLICY_CONSTRAINTS_free); static STACK_OF(CONF_VALUE) * i2v_POLICY_CONSTRAINTS(const X509V3_EXT_METHOD *method, void *a, diff --git a/lib/libcrypto/x509/x509_pku.c b/lib/libcrypto/x509/x509_pku.c index f65d0dfc697..dd28077de10 100644 --- a/lib/libcrypto/x509/x509_pku.c +++ b/lib/libcrypto/x509/x509_pku.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_pku.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */ +/* $OpenBSD: x509_pku.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -116,28 +116,28 @@ d2i_PKEY_USAGE_PERIOD(PKEY_USAGE_PERIOD **a, const unsigned char **in, long len) return (PKEY_USAGE_PERIOD *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &PKEY_USAGE_PERIOD_it); } -LCRYPTO_ALIAS(d2i_PKEY_USAGE_PERIOD) +LCRYPTO_ALIAS(d2i_PKEY_USAGE_PERIOD); int i2d_PKEY_USAGE_PERIOD(PKEY_USAGE_PERIOD *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKEY_USAGE_PERIOD_it); } -LCRYPTO_ALIAS(i2d_PKEY_USAGE_PERIOD) +LCRYPTO_ALIAS(i2d_PKEY_USAGE_PERIOD); PKEY_USAGE_PERIOD * PKEY_USAGE_PERIOD_new(void) { return (PKEY_USAGE_PERIOD *)ASN1_item_new(&PKEY_USAGE_PERIOD_it); } -LCRYPTO_ALIAS(PKEY_USAGE_PERIOD_new) +LCRYPTO_ALIAS(PKEY_USAGE_PERIOD_new); void PKEY_USAGE_PERIOD_free(PKEY_USAGE_PERIOD *a) { ASN1_item_free((ASN1_VALUE *)a, &PKEY_USAGE_PERIOD_it); } -LCRYPTO_ALIAS(PKEY_USAGE_PERIOD_free) +LCRYPTO_ALIAS(PKEY_USAGE_PERIOD_free); static int i2r_PKEY_USAGE_PERIOD(X509V3_EXT_METHOD *method, PKEY_USAGE_PERIOD *usage, diff --git a/lib/libcrypto/x509/x509_pmaps.c b/lib/libcrypto/x509/x509_pmaps.c index 3bc4b9d6379..39aebfee866 100644 --- a/lib/libcrypto/x509/x509_pmaps.c +++ b/lib/libcrypto/x509/x509_pmaps.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_pmaps.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */ +/* $OpenBSD: x509_pmaps.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project. */ @@ -137,14 +137,14 @@ POLICY_MAPPING_new(void) { return (POLICY_MAPPING*)ASN1_item_new(&POLICY_MAPPING_it); } -LCRYPTO_ALIAS(POLICY_MAPPING_new) +LCRYPTO_ALIAS(POLICY_MAPPING_new); void POLICY_MAPPING_free(POLICY_MAPPING *a) { ASN1_item_free((ASN1_VALUE *)a, &POLICY_MAPPING_it); } -LCRYPTO_ALIAS(POLICY_MAPPING_free) +LCRYPTO_ALIAS(POLICY_MAPPING_free); static STACK_OF(CONF_VALUE) * i2v_POLICY_MAPPINGS(const X509V3_EXT_METHOD *method, void *a, diff --git a/lib/libcrypto/x509/x509_prn.c b/lib/libcrypto/x509/x509_prn.c index 89cd555fc58..2d7afb9fcc4 100644 --- a/lib/libcrypto/x509/x509_prn.c +++ b/lib/libcrypto/x509/x509_prn.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_prn.c,v 1.4 2022/11/26 16:08:55 tb Exp $ */ +/* $OpenBSD: x509_prn.c,v 1.5 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -99,7 +99,7 @@ X509V3_EXT_val_prn(BIO *out, STACK_OF(CONF_VALUE) *val, int indent, int ml) BIO_puts(out, "\n"); } } -LCRYPTO_ALIAS(X509V3_EXT_val_prn) +LCRYPTO_ALIAS(X509V3_EXT_val_prn); /* Main routine: print out a general extension */ @@ -153,7 +153,7 @@ err: method->ext_free(ext_str); return ok; } -LCRYPTO_ALIAS(X509V3_EXT_print) +LCRYPTO_ALIAS(X509V3_EXT_print); int X509V3_extensions_print(BIO *bp, const char *title, @@ -189,7 +189,7 @@ X509V3_extensions_print(BIO *bp, const char *title, } return 1; } -LCRYPTO_ALIAS(X509V3_extensions_print) +LCRYPTO_ALIAS(X509V3_extensions_print); static int unknown_ext_print(BIO *out, X509_EXTENSION *ext, unsigned long flag, @@ -228,4 +228,4 @@ X509V3_EXT_print_fp(FILE *fp, X509_EXTENSION *ext, int flag, int indent) BIO_free(bio_tmp); return ret; } -LCRYPTO_ALIAS(X509V3_EXT_print_fp) +LCRYPTO_ALIAS(X509V3_EXT_print_fp); diff --git a/lib/libcrypto/x509/x509_purp.c b/lib/libcrypto/x509/x509_purp.c index 7ec986062fd..63d1df2961f 100644 --- a/lib/libcrypto/x509/x509_purp.c +++ b/lib/libcrypto/x509/x509_purp.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_purp.c,v 1.19 2023/01/20 22:00:47 job Exp $ */ +/* $OpenBSD: x509_purp.c,v 1.20 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 2001. */ @@ -140,7 +140,7 @@ X509_check_purpose(X509 *x, int id, int ca) pt = X509_PURPOSE_get0(idx); return pt->check_purpose(pt, x, ca); } -LCRYPTO_ALIAS(X509_check_purpose) +LCRYPTO_ALIAS(X509_check_purpose); int X509_PURPOSE_set(int *p, int purpose) @@ -152,7 +152,7 @@ X509_PURPOSE_set(int *p, int purpose) *p = purpose; return 1; } -LCRYPTO_ALIAS(X509_PURPOSE_set) +LCRYPTO_ALIAS(X509_PURPOSE_set); int X509_PURPOSE_get_count(void) @@ -161,7 +161,7 @@ X509_PURPOSE_get_count(void) return X509_PURPOSE_COUNT; return sk_X509_PURPOSE_num(xptable) + X509_PURPOSE_COUNT; } -LCRYPTO_ALIAS(X509_PURPOSE_get_count) +LCRYPTO_ALIAS(X509_PURPOSE_get_count); X509_PURPOSE * X509_PURPOSE_get0(int idx) @@ -172,7 +172,7 @@ X509_PURPOSE_get0(int idx) return xstandard + idx; return sk_X509_PURPOSE_value(xptable, idx - X509_PURPOSE_COUNT); } -LCRYPTO_ALIAS(X509_PURPOSE_get0) +LCRYPTO_ALIAS(X509_PURPOSE_get0); int X509_PURPOSE_get_by_sname(const char *sname) @@ -187,7 +187,7 @@ X509_PURPOSE_get_by_sname(const char *sname) } return -1; } -LCRYPTO_ALIAS(X509_PURPOSE_get_by_sname) +LCRYPTO_ALIAS(X509_PURPOSE_get_by_sname); int X509_PURPOSE_get_by_id(int purpose) @@ -205,7 +205,7 @@ X509_PURPOSE_get_by_id(int purpose) return -1; return idx + X509_PURPOSE_COUNT; } -LCRYPTO_ALIAS(X509_PURPOSE_get_by_id) +LCRYPTO_ALIAS(X509_PURPOSE_get_by_id); int X509_PURPOSE_add(int id, int trust, int flags, @@ -280,7 +280,7 @@ err: X509V3error(ERR_R_MALLOC_FAILURE); return 0; } -LCRYPTO_ALIAS(X509_PURPOSE_add) +LCRYPTO_ALIAS(X509_PURPOSE_add); static void xptable_free(X509_PURPOSE *p) @@ -302,35 +302,35 @@ X509_PURPOSE_cleanup(void) sk_X509_PURPOSE_pop_free(xptable, xptable_free); xptable = NULL; } -LCRYPTO_ALIAS(X509_PURPOSE_cleanup) +LCRYPTO_ALIAS(X509_PURPOSE_cleanup); int X509_PURPOSE_get_id(const X509_PURPOSE *xp) { return xp->purpose; } -LCRYPTO_ALIAS(X509_PURPOSE_get_id) +LCRYPTO_ALIAS(X509_PURPOSE_get_id); char * X509_PURPOSE_get0_name(const X509_PURPOSE *xp) { return xp->name; } -LCRYPTO_ALIAS(X509_PURPOSE_get0_name) +LCRYPTO_ALIAS(X509_PURPOSE_get0_name); char * X509_PURPOSE_get0_sname(const X509_PURPOSE *xp) { return xp->sname; } -LCRYPTO_ALIAS(X509_PURPOSE_get0_sname) +LCRYPTO_ALIAS(X509_PURPOSE_get0_sname); int X509_PURPOSE_get_trust(const X509_PURPOSE *xp) { return xp->trust; } -LCRYPTO_ALIAS(X509_PURPOSE_get_trust) +LCRYPTO_ALIAS(X509_PURPOSE_get_trust); static int nid_cmp(const int *a, const int *b) @@ -396,7 +396,7 @@ X509_supported_extension(X509_EXTENSION *ex) return 1; return 0; } -LCRYPTO_ALIAS(X509_supported_extension) +LCRYPTO_ALIAS(X509_supported_extension); static void setup_dp(X509 *x, DIST_POINT *dp) @@ -690,7 +690,7 @@ X509_check_ca(X509 *x) return check_ca(x); } -LCRYPTO_ALIAS(X509_check_ca) +LCRYPTO_ALIAS(X509_check_ca); /* Check SSL CA: common checks for SSL client and server */ static int @@ -916,7 +916,7 @@ X509_check_issued(X509 *issuer, X509 *subject) return X509_V_ERR_KEYUSAGE_NO_CERTSIGN; return X509_V_OK; } -LCRYPTO_ALIAS(X509_check_issued) +LCRYPTO_ALIAS(X509_check_issued); int X509_check_akid(X509 *issuer, AUTHORITY_KEYID *akid) @@ -956,7 +956,7 @@ X509_check_akid(X509 *issuer, AUTHORITY_KEYID *akid) } return X509_V_OK; } -LCRYPTO_ALIAS(X509_check_akid) +LCRYPTO_ALIAS(X509_check_akid); uint32_t X509_get_extension_flags(X509 *x) @@ -967,7 +967,7 @@ X509_get_extension_flags(X509 *x) return x->ex_flags; } -LCRYPTO_ALIAS(X509_get_extension_flags) +LCRYPTO_ALIAS(X509_get_extension_flags); uint32_t X509_get_key_usage(X509 *x) @@ -981,7 +981,7 @@ X509_get_key_usage(X509 *x) return UINT32_MAX; } -LCRYPTO_ALIAS(X509_get_key_usage) +LCRYPTO_ALIAS(X509_get_key_usage); uint32_t X509_get_extended_key_usage(X509 *x) @@ -995,4 +995,4 @@ X509_get_extended_key_usage(X509 *x) return UINT32_MAX; } -LCRYPTO_ALIAS(X509_get_extended_key_usage) +LCRYPTO_ALIAS(X509_get_extended_key_usage); diff --git a/lib/libcrypto/x509/x509_r2x.c b/lib/libcrypto/x509/x509_r2x.c index a8ffbdc65bb..99c423d8c99 100644 --- a/lib/libcrypto/x509/x509_r2x.c +++ b/lib/libcrypto/x509/x509_r2x.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_r2x.c,v 1.15 2022/11/26 16:08:55 tb Exp $ */ +/* $OpenBSD: x509_r2x.c,v 1.16 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -116,4 +116,4 @@ err: X509_free(ret); return NULL; } -LCRYPTO_ALIAS(X509_REQ_to_X509) +LCRYPTO_ALIAS(X509_REQ_to_X509); diff --git a/lib/libcrypto/x509/x509_req.c b/lib/libcrypto/x509/x509_req.c index 32415979e9f..0fea7e68b43 100644 --- a/lib/libcrypto/x509/x509_req.c +++ b/lib/libcrypto/x509/x509_req.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_req.c,v 1.31 2022/11/26 16:08:55 tb Exp $ */ +/* $OpenBSD: x509_req.c,v 1.32 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -115,7 +115,7 @@ err: X509_REQ_free(ret); return (NULL); } -LCRYPTO_ALIAS(X509_to_X509_REQ) +LCRYPTO_ALIAS(X509_to_X509_REQ); EVP_PKEY * X509_REQ_get_pubkey(X509_REQ *req) @@ -124,7 +124,7 @@ X509_REQ_get_pubkey(X509_REQ *req) return (NULL); return (X509_PUBKEY_get(req->req_info->pubkey)); } -LCRYPTO_ALIAS(X509_REQ_get_pubkey) +LCRYPTO_ALIAS(X509_REQ_get_pubkey); EVP_PKEY * X509_REQ_get0_pubkey(X509_REQ *req) @@ -133,7 +133,7 @@ X509_REQ_get0_pubkey(X509_REQ *req) return NULL; return X509_PUBKEY_get0(req->req_info->pubkey); } -LCRYPTO_ALIAS(X509_REQ_get0_pubkey) +LCRYPTO_ALIAS(X509_REQ_get0_pubkey); int X509_REQ_check_private_key(X509_REQ *x, EVP_PKEY *k) @@ -173,7 +173,7 @@ X509_REQ_check_private_key(X509_REQ *x, EVP_PKEY *k) return (ok); } -LCRYPTO_ALIAS(X509_REQ_check_private_key) +LCRYPTO_ALIAS(X509_REQ_check_private_key); /* It seems several organisations had the same idea of including a list of * extensions in a certificate request. There are at least two OIDs that are @@ -197,21 +197,21 @@ X509_REQ_extension_nid(int req_nid) return 1; } } -LCRYPTO_ALIAS(X509_REQ_extension_nid) +LCRYPTO_ALIAS(X509_REQ_extension_nid); int * X509_REQ_get_extension_nids(void) { return ext_nids; } -LCRYPTO_ALIAS(X509_REQ_get_extension_nids) +LCRYPTO_ALIAS(X509_REQ_get_extension_nids); void X509_REQ_set_extension_nids(int *nids) { ext_nids = nids; } -LCRYPTO_ALIAS(X509_REQ_set_extension_nids) +LCRYPTO_ALIAS(X509_REQ_set_extension_nids); STACK_OF(X509_EXTENSION) * X509_REQ_get_extensions(X509_REQ *req) @@ -238,7 +238,7 @@ X509_REQ_get_extensions(X509_REQ *req) p = ext->value.sequence->data; return d2i_X509_EXTENSIONS(NULL, &p, ext->value.sequence->length); } -LCRYPTO_ALIAS(X509_REQ_get_extensions) +LCRYPTO_ALIAS(X509_REQ_get_extensions); /* * Add a STACK_OF extensions to a certificate request: allow alternative OIDs @@ -262,7 +262,7 @@ X509_REQ_add_extensions_nid(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts, return rv; } -LCRYPTO_ALIAS(X509_REQ_add_extensions_nid) +LCRYPTO_ALIAS(X509_REQ_add_extensions_nid); /* This is the normal usage: use the "official" OID */ int @@ -270,7 +270,7 @@ X509_REQ_add_extensions(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts) { return X509_REQ_add_extensions_nid(req, exts, NID_ext_req); } -LCRYPTO_ALIAS(X509_REQ_add_extensions) +LCRYPTO_ALIAS(X509_REQ_add_extensions); /* Request attribute functions */ @@ -279,14 +279,14 @@ X509_REQ_get_attr_count(const X509_REQ *req) { return X509at_get_attr_count(req->req_info->attributes); } -LCRYPTO_ALIAS(X509_REQ_get_attr_count) +LCRYPTO_ALIAS(X509_REQ_get_attr_count); int X509_REQ_get_attr_by_NID(const X509_REQ *req, int nid, int lastpos) { return X509at_get_attr_by_NID(req->req_info->attributes, nid, lastpos); } -LCRYPTO_ALIAS(X509_REQ_get_attr_by_NID) +LCRYPTO_ALIAS(X509_REQ_get_attr_by_NID); int X509_REQ_get_attr_by_OBJ(const X509_REQ *req, const ASN1_OBJECT *obj, @@ -294,21 +294,21 @@ X509_REQ_get_attr_by_OBJ(const X509_REQ *req, const ASN1_OBJECT *obj, { return X509at_get_attr_by_OBJ(req->req_info->attributes, obj, lastpos); } -LCRYPTO_ALIAS(X509_REQ_get_attr_by_OBJ) +LCRYPTO_ALIAS(X509_REQ_get_attr_by_OBJ); X509_ATTRIBUTE * X509_REQ_get_attr(const X509_REQ *req, int loc) { return X509at_get_attr(req->req_info->attributes, loc); } -LCRYPTO_ALIAS(X509_REQ_get_attr) +LCRYPTO_ALIAS(X509_REQ_get_attr); X509_ATTRIBUTE * X509_REQ_delete_attr(X509_REQ *req, int loc) { return X509at_delete_attr(req->req_info->attributes, loc); } -LCRYPTO_ALIAS(X509_REQ_delete_attr) +LCRYPTO_ALIAS(X509_REQ_delete_attr); int X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr) @@ -317,7 +317,7 @@ X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr) return 1; return 0; } -LCRYPTO_ALIAS(X509_REQ_add1_attr) +LCRYPTO_ALIAS(X509_REQ_add1_attr); int X509_REQ_add1_attr_by_OBJ(X509_REQ *req, const ASN1_OBJECT *obj, int type, @@ -328,7 +328,7 @@ X509_REQ_add1_attr_by_OBJ(X509_REQ *req, const ASN1_OBJECT *obj, int type, return 1; return 0; } -LCRYPTO_ALIAS(X509_REQ_add1_attr_by_OBJ) +LCRYPTO_ALIAS(X509_REQ_add1_attr_by_OBJ); int X509_REQ_add1_attr_by_NID(X509_REQ *req, int nid, int type, @@ -339,7 +339,7 @@ X509_REQ_add1_attr_by_NID(X509_REQ *req, int nid, int type, return 1; return 0; } -LCRYPTO_ALIAS(X509_REQ_add1_attr_by_NID) +LCRYPTO_ALIAS(X509_REQ_add1_attr_by_NID); int X509_REQ_add1_attr_by_txt(X509_REQ *req, const char *attrname, int type, @@ -350,7 +350,7 @@ X509_REQ_add1_attr_by_txt(X509_REQ *req, const char *attrname, int type, return 1; return 0; } -LCRYPTO_ALIAS(X509_REQ_add1_attr_by_txt) +LCRYPTO_ALIAS(X509_REQ_add1_attr_by_txt); int i2d_re_X509_REQ_tbs(X509_REQ *req, unsigned char **pp) @@ -358,4 +358,4 @@ i2d_re_X509_REQ_tbs(X509_REQ *req, unsigned char **pp) req->req_info->enc.modified = 1; return i2d_X509_REQ_INFO(req->req_info, pp); } -LCRYPTO_ALIAS(i2d_re_X509_REQ_tbs) +LCRYPTO_ALIAS(i2d_re_X509_REQ_tbs); diff --git a/lib/libcrypto/x509/x509_set.c b/lib/libcrypto/x509/x509_set.c index f07f0ec5f25..e65ffb3b4de 100644 --- a/lib/libcrypto/x509/x509_set.c +++ b/lib/libcrypto/x509/x509_set.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_set.c,v 1.22 2022/11/26 16:08:55 tb Exp $ */ +/* $OpenBSD: x509_set.c,v 1.23 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -70,14 +70,14 @@ X509_get0_extensions(const X509 *x) { return x->cert_info->extensions; } -LCRYPTO_ALIAS(X509_get0_extensions) +LCRYPTO_ALIAS(X509_get0_extensions); const X509_ALGOR * X509_get0_tbs_sigalg(const X509 *x) { return x->cert_info->signature; } -LCRYPTO_ALIAS(X509_get0_tbs_sigalg) +LCRYPTO_ALIAS(X509_get0_tbs_sigalg); int X509_set_version(X509 *x, long version) @@ -90,14 +90,14 @@ X509_set_version(X509 *x, long version) } return (ASN1_INTEGER_set(x->cert_info->version, version)); } -LCRYPTO_ALIAS(X509_set_version) +LCRYPTO_ALIAS(X509_set_version); long X509_get_version(const X509 *x) { return ASN1_INTEGER_get(x->cert_info->version); } -LCRYPTO_ALIAS(X509_get_version) +LCRYPTO_ALIAS(X509_get_version); int X509_set_serialNumber(X509 *x, ASN1_INTEGER *serial) @@ -116,7 +116,7 @@ X509_set_serialNumber(X509 *x, ASN1_INTEGER *serial) } return (in != NULL); } -LCRYPTO_ALIAS(X509_set_serialNumber) +LCRYPTO_ALIAS(X509_set_serialNumber); int X509_set_issuer_name(X509 *x, X509_NAME *name) @@ -125,7 +125,7 @@ X509_set_issuer_name(X509 *x, X509_NAME *name) return (0); return (X509_NAME_set(&x->cert_info->issuer, name)); } -LCRYPTO_ALIAS(X509_set_issuer_name) +LCRYPTO_ALIAS(X509_set_issuer_name); int X509_set_subject_name(X509 *x, X509_NAME *name) @@ -134,14 +134,14 @@ X509_set_subject_name(X509 *x, X509_NAME *name) return (0); return (X509_NAME_set(&x->cert_info->subject, name)); } -LCRYPTO_ALIAS(X509_set_subject_name) +LCRYPTO_ALIAS(X509_set_subject_name); const ASN1_TIME * X509_get0_notBefore(const X509 *x) { return X509_getm_notBefore(x); } -LCRYPTO_ALIAS(X509_get0_notBefore) +LCRYPTO_ALIAS(X509_get0_notBefore); ASN1_TIME * X509_getm_notBefore(const X509 *x) @@ -150,7 +150,7 @@ X509_getm_notBefore(const X509 *x) return (NULL); return x->cert_info->validity->notBefore; } -LCRYPTO_ALIAS(X509_getm_notBefore) +LCRYPTO_ALIAS(X509_getm_notBefore); int X509_set_notBefore(X509 *x, const ASN1_TIME *tm) @@ -169,21 +169,21 @@ X509_set_notBefore(X509 *x, const ASN1_TIME *tm) } return (in != NULL); } -LCRYPTO_ALIAS(X509_set_notBefore) +LCRYPTO_ALIAS(X509_set_notBefore); int X509_set1_notBefore(X509 *x, const ASN1_TIME *tm) { return X509_set_notBefore(x, tm); } -LCRYPTO_ALIAS(X509_set1_notBefore) +LCRYPTO_ALIAS(X509_set1_notBefore); const ASN1_TIME * X509_get0_notAfter(const X509 *x) { return X509_getm_notAfter(x); } -LCRYPTO_ALIAS(X509_get0_notAfter) +LCRYPTO_ALIAS(X509_get0_notAfter); ASN1_TIME * X509_getm_notAfter(const X509 *x) @@ -192,7 +192,7 @@ X509_getm_notAfter(const X509 *x) return (NULL); return x->cert_info->validity->notAfter; } -LCRYPTO_ALIAS(X509_getm_notAfter) +LCRYPTO_ALIAS(X509_getm_notAfter); int X509_set_notAfter(X509 *x, const ASN1_TIME *tm) @@ -211,14 +211,14 @@ X509_set_notAfter(X509 *x, const ASN1_TIME *tm) } return (in != NULL); } -LCRYPTO_ALIAS(X509_set_notAfter) +LCRYPTO_ALIAS(X509_set_notAfter); int X509_set1_notAfter(X509 *x, const ASN1_TIME *tm) { return X509_set_notAfter(x, tm); } -LCRYPTO_ALIAS(X509_set1_notAfter) +LCRYPTO_ALIAS(X509_set1_notAfter); int X509_set_pubkey(X509 *x, EVP_PKEY *pkey) @@ -227,18 +227,18 @@ X509_set_pubkey(X509 *x, EVP_PKEY *pkey) return (0); return (X509_PUBKEY_set(&(x->cert_info->key), pkey)); } -LCRYPTO_ALIAS(X509_set_pubkey) +LCRYPTO_ALIAS(X509_set_pubkey); int X509_get_signature_type(const X509 *x) { return EVP_PKEY_type(OBJ_obj2nid(x->sig_alg->algorithm)); } -LCRYPTO_ALIAS(X509_get_signature_type) +LCRYPTO_ALIAS(X509_get_signature_type); X509_PUBKEY * X509_get_X509_PUBKEY(const X509 *x) { return x->cert_info->key; } -LCRYPTO_ALIAS(X509_get_X509_PUBKEY) +LCRYPTO_ALIAS(X509_get_X509_PUBKEY); diff --git a/lib/libcrypto/x509/x509_skey.c b/lib/libcrypto/x509/x509_skey.c index d4212a64a15..245ba515866 100644 --- a/lib/libcrypto/x509/x509_skey.c +++ b/lib/libcrypto/x509/x509_skey.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_skey.c,v 1.4 2022/11/26 16:08:55 tb Exp $ */ +/* $OpenBSD: x509_skey.c,v 1.5 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -89,7 +89,7 @@ i2s_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method, const ASN1_OCTET_STRING *oct) { return hex_to_string(oct->data, oct->length); } -LCRYPTO_ALIAS(i2s_ASN1_OCTET_STRING) +LCRYPTO_ALIAS(i2s_ASN1_OCTET_STRING); ASN1_OCTET_STRING * s2i_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method, X509V3_CTX *ctx, @@ -112,7 +112,7 @@ s2i_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method, X509V3_CTX *ctx, return oct; } -LCRYPTO_ALIAS(s2i_ASN1_OCTET_STRING) +LCRYPTO_ALIAS(s2i_ASN1_OCTET_STRING); static ASN1_OCTET_STRING * s2i_skey_id(X509V3_EXT_METHOD *method, X509V3_CTX *ctx, char *str) diff --git a/lib/libcrypto/x509/x509_sxnet.c b/lib/libcrypto/x509/x509_sxnet.c index 9c66a6b7692..77c792d2270 100644 --- a/lib/libcrypto/x509/x509_sxnet.c +++ b/lib/libcrypto/x509/x509_sxnet.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_sxnet.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */ +/* $OpenBSD: x509_sxnet.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -131,28 +131,28 @@ d2i_SXNETID(SXNETID **a, const unsigned char **in, long len) return (SXNETID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &SXNETID_it); } -LCRYPTO_ALIAS(d2i_SXNETID) +LCRYPTO_ALIAS(d2i_SXNETID); int i2d_SXNETID(SXNETID *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &SXNETID_it); } -LCRYPTO_ALIAS(i2d_SXNETID) +LCRYPTO_ALIAS(i2d_SXNETID); SXNETID * SXNETID_new(void) { return (SXNETID *)ASN1_item_new(&SXNETID_it); } -LCRYPTO_ALIAS(SXNETID_new) +LCRYPTO_ALIAS(SXNETID_new); void SXNETID_free(SXNETID *a) { ASN1_item_free((ASN1_VALUE *)a, &SXNETID_it); } -LCRYPTO_ALIAS(SXNETID_free) +LCRYPTO_ALIAS(SXNETID_free); static const ASN1_TEMPLATE SXNET_seq_tt[] = { { @@ -188,28 +188,28 @@ d2i_SXNET(SXNET **a, const unsigned char **in, long len) return (SXNET *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &SXNET_it); } -LCRYPTO_ALIAS(d2i_SXNET) +LCRYPTO_ALIAS(d2i_SXNET); int i2d_SXNET(SXNET *a, unsigned char **out) { return ASN1_item_i2d((ASN1_VALUE *)a, out, &SXNET_it); } -LCRYPTO_ALIAS(i2d_SXNET) +LCRYPTO_ALIAS(i2d_SXNET); SXNET * SXNET_new(void) { return (SXNET *)ASN1_item_new(&SXNET_it); } -LCRYPTO_ALIAS(SXNET_new) +LCRYPTO_ALIAS(SXNET_new); void SXNET_free(SXNET *a) { ASN1_item_free((ASN1_VALUE *)a, &SXNET_it); } -LCRYPTO_ALIAS(SXNET_free) +LCRYPTO_ALIAS(SXNET_free); static int sxnet_i2r(X509V3_EXT_METHOD *method, SXNET *sx, BIO *out, int indent) @@ -271,7 +271,7 @@ SXNET_add_id_asc(SXNET **psx, const char *zone, const char *user, int userlen) } return SXNET_add_id_INTEGER(psx, izone, user, userlen); } -LCRYPTO_ALIAS(SXNET_add_id_asc) +LCRYPTO_ALIAS(SXNET_add_id_asc); /* Add an id given the zone as an unsigned long */ @@ -289,7 +289,7 @@ SXNET_add_id_ulong(SXNET **psx, unsigned long lzone, const char *user, } return SXNET_add_id_INTEGER(psx, izone, user, userlen); } -LCRYPTO_ALIAS(SXNET_add_id_ulong) +LCRYPTO_ALIAS(SXNET_add_id_ulong); /* Add an id given the zone as an ASN1_INTEGER. * Note this version uses the passed integer and doesn't make a copy so don't @@ -345,7 +345,7 @@ err: *psx = NULL; return 0; } -LCRYPTO_ALIAS(SXNET_add_id_INTEGER) +LCRYPTO_ALIAS(SXNET_add_id_INTEGER); ASN1_OCTET_STRING * SXNET_get_id_asc(SXNET *sx, const char *zone) @@ -361,7 +361,7 @@ SXNET_get_id_asc(SXNET *sx, const char *zone) ASN1_INTEGER_free(izone); return oct; } -LCRYPTO_ALIAS(SXNET_get_id_asc) +LCRYPTO_ALIAS(SXNET_get_id_asc); ASN1_OCTET_STRING * SXNET_get_id_ulong(SXNET *sx, unsigned long lzone) @@ -379,7 +379,7 @@ SXNET_get_id_ulong(SXNET *sx, unsigned long lzone) ASN1_INTEGER_free(izone); return oct; } -LCRYPTO_ALIAS(SXNET_get_id_ulong) +LCRYPTO_ALIAS(SXNET_get_id_ulong); ASN1_OCTET_STRING * SXNET_get_id_INTEGER(SXNET *sx, ASN1_INTEGER *zone) @@ -394,4 +394,4 @@ SXNET_get_id_INTEGER(SXNET *sx, ASN1_INTEGER *zone) } return NULL; } -LCRYPTO_ALIAS(SXNET_get_id_INTEGER) +LCRYPTO_ALIAS(SXNET_get_id_INTEGER); diff --git a/lib/libcrypto/x509/x509_trs.c b/lib/libcrypto/x509/x509_trs.c index 10995801b18..e3265918a43 100644 --- a/lib/libcrypto/x509/x509_trs.c +++ b/lib/libcrypto/x509/x509_trs.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_trs.c,v 1.30 2022/11/26 16:08:55 tb Exp $ */ +/* $OpenBSD: x509_trs.c,v 1.31 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -109,7 +109,7 @@ int default_trust = trust; return oldtrust; } -LCRYPTO_ALIAS(X509_TRUST_set_default) +LCRYPTO_ALIAS(X509_TRUST_set_default); int X509_check_trust(X509 *x, int id, int flags) @@ -141,7 +141,7 @@ X509_check_trust(X509 *x, int id, int flags) pt = X509_TRUST_get0(idx); return pt->check_trust(pt, x, flags); } -LCRYPTO_ALIAS(X509_check_trust) +LCRYPTO_ALIAS(X509_check_trust); int X509_TRUST_get_count(void) @@ -150,7 +150,7 @@ X509_TRUST_get_count(void) return X509_TRUST_COUNT; return sk_X509_TRUST_num(trtable) + X509_TRUST_COUNT; } -LCRYPTO_ALIAS(X509_TRUST_get_count) +LCRYPTO_ALIAS(X509_TRUST_get_count); X509_TRUST * X509_TRUST_get0(int idx) @@ -161,7 +161,7 @@ X509_TRUST_get0(int idx) return trstandard + idx; return sk_X509_TRUST_value(trtable, idx - X509_TRUST_COUNT); } -LCRYPTO_ALIAS(X509_TRUST_get0) +LCRYPTO_ALIAS(X509_TRUST_get0); int X509_TRUST_get_by_id(int id) @@ -179,7 +179,7 @@ X509_TRUST_get_by_id(int id) return -1; return idx + X509_TRUST_COUNT; } -LCRYPTO_ALIAS(X509_TRUST_get_by_id) +LCRYPTO_ALIAS(X509_TRUST_get_by_id); int X509_TRUST_set(int *t, int trust) @@ -191,7 +191,7 @@ X509_TRUST_set(int *t, int trust) *t = trust; return 1; } -LCRYPTO_ALIAS(X509_TRUST_set) +LCRYPTO_ALIAS(X509_TRUST_set); int X509_TRUST_add(int id, int flags, int (*ck)(X509_TRUST *, X509 *, int), @@ -257,7 +257,7 @@ err: X509error(ERR_R_MALLOC_FAILURE); return 0; } -LCRYPTO_ALIAS(X509_TRUST_add) +LCRYPTO_ALIAS(X509_TRUST_add); static void trtable_free(X509_TRUST *p) @@ -277,28 +277,28 @@ X509_TRUST_cleanup(void) sk_X509_TRUST_pop_free(trtable, trtable_free); trtable = NULL; } -LCRYPTO_ALIAS(X509_TRUST_cleanup) +LCRYPTO_ALIAS(X509_TRUST_cleanup); int X509_TRUST_get_flags(const X509_TRUST *xp) { return xp->flags; } -LCRYPTO_ALIAS(X509_TRUST_get_flags) +LCRYPTO_ALIAS(X509_TRUST_get_flags); char * X509_TRUST_get0_name(const X509_TRUST *xp) { return xp->name; } -LCRYPTO_ALIAS(X509_TRUST_get0_name) +LCRYPTO_ALIAS(X509_TRUST_get0_name); int X509_TRUST_get_trust(const X509_TRUST *xp) { return xp->trust; } -LCRYPTO_ALIAS(X509_TRUST_get_trust) +LCRYPTO_ALIAS(X509_TRUST_get_trust); static int trust_1oidany(X509_TRUST *trust, X509 *x, int flags) diff --git a/lib/libcrypto/x509/x509_txt.c b/lib/libcrypto/x509/x509_txt.c index fb33fd7dc2f..5f5bc5ae84b 100644 --- a/lib/libcrypto/x509/x509_txt.c +++ b/lib/libcrypto/x509/x509_txt.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_txt.c,v 1.27 2022/11/29 12:23:43 tb Exp $ */ +/* $OpenBSD: x509_txt.c,v 1.28 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -193,4 +193,4 @@ X509_verify_cert_error_string(long n) return "Unknown certificate verification error"; } } -LCRYPTO_ALIAS(X509_verify_cert_error_string) +LCRYPTO_ALIAS(X509_verify_cert_error_string); diff --git a/lib/libcrypto/x509/x509_utl.c b/lib/libcrypto/x509/x509_utl.c index aa18efe2c55..ec67ae093cf 100644 --- a/lib/libcrypto/x509/x509_utl.c +++ b/lib/libcrypto/x509/x509_utl.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_utl.c,v 1.5 2022/12/26 07:18:53 jmc Exp $ */ +/* $OpenBSD: x509_utl.c,v 1.6 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project. */ @@ -117,7 +117,7 @@ X509V3_add_value(const char *name, const char *value, } return 0; } -LCRYPTO_ALIAS(X509V3_add_value) +LCRYPTO_ALIAS(X509V3_add_value); int X509V3_add_value_uchar(const char *name, const unsigned char *value, @@ -125,7 +125,7 @@ X509V3_add_value_uchar(const char *name, const unsigned char *value, { return X509V3_add_value(name, (const char *)value, extlist); } -LCRYPTO_ALIAS(X509V3_add_value_uchar) +LCRYPTO_ALIAS(X509V3_add_value_uchar); /* Free function for STACK_OF(CONF_VALUE) */ @@ -139,7 +139,7 @@ X509V3_conf_free(CONF_VALUE *conf) free(conf->section); free(conf); } -LCRYPTO_ALIAS(X509V3_conf_free) +LCRYPTO_ALIAS(X509V3_conf_free); int X509V3_add_value_bool(const char *name, int asn1_bool, @@ -149,7 +149,7 @@ X509V3_add_value_bool(const char *name, int asn1_bool, return X509V3_add_value(name, "TRUE", extlist); return X509V3_add_value(name, "FALSE", extlist); } -LCRYPTO_ALIAS(X509V3_add_value_bool) +LCRYPTO_ALIAS(X509V3_add_value_bool); int X509V3_add_value_bool_nf(const char *name, int asn1_bool, @@ -159,7 +159,7 @@ X509V3_add_value_bool_nf(const char *name, int asn1_bool, return X509V3_add_value(name, "TRUE", extlist); return 1; } -LCRYPTO_ALIAS(X509V3_add_value_bool_nf) +LCRYPTO_ALIAS(X509V3_add_value_bool_nf); char * bn_to_string(const BIGNUM *bn) @@ -202,7 +202,7 @@ i2s_ASN1_ENUMERATED(X509V3_EXT_METHOD *method, const ASN1_ENUMERATED *a) BN_free(bntmp); return strtmp; } -LCRYPTO_ALIAS(i2s_ASN1_ENUMERATED) +LCRYPTO_ALIAS(i2s_ASN1_ENUMERATED); char * i2s_ASN1_INTEGER(X509V3_EXT_METHOD *method, const ASN1_INTEGER *a) @@ -218,7 +218,7 @@ i2s_ASN1_INTEGER(X509V3_EXT_METHOD *method, const ASN1_INTEGER *a) BN_free(bntmp); return strtmp; } -LCRYPTO_ALIAS(i2s_ASN1_INTEGER) +LCRYPTO_ALIAS(i2s_ASN1_INTEGER); ASN1_INTEGER * s2i_ASN1_INTEGER(X509V3_EXT_METHOD *method, const char *value) @@ -269,7 +269,7 @@ s2i_ASN1_INTEGER(X509V3_EXT_METHOD *method, const char *value) aint->type |= V_ASN1_NEG; return aint; } -LCRYPTO_ALIAS(s2i_ASN1_INTEGER) +LCRYPTO_ALIAS(s2i_ASN1_INTEGER); int X509V3_add_value_int(const char *name, const ASN1_INTEGER *aint, @@ -286,7 +286,7 @@ X509V3_add_value_int(const char *name, const ASN1_INTEGER *aint, free(strtmp); return ret; } -LCRYPTO_ALIAS(X509V3_add_value_int) +LCRYPTO_ALIAS(X509V3_add_value_int); int X509V3_get_value_bool(const CONF_VALUE *value, int *asn1_bool) @@ -312,7 +312,7 @@ X509V3_get_value_bool(const CONF_VALUE *value, int *asn1_bool) X509V3_conf_err(value); return 0; } -LCRYPTO_ALIAS(X509V3_get_value_bool) +LCRYPTO_ALIAS(X509V3_get_value_bool); int X509V3_get_value_int(const CONF_VALUE *value, ASN1_INTEGER **aint) @@ -326,7 +326,7 @@ X509V3_get_value_int(const CONF_VALUE *value, ASN1_INTEGER **aint) *aint = itmp; return 1; } -LCRYPTO_ALIAS(X509V3_get_value_int) +LCRYPTO_ALIAS(X509V3_get_value_int); #define HDR_NAME 1 #define HDR_VALUE 2 @@ -418,7 +418,7 @@ X509V3_parse_list(const char *line) return NULL; } -LCRYPTO_ALIAS(X509V3_parse_list) +LCRYPTO_ALIAS(X509V3_parse_list); /* Delete leading and trailing spaces from a string */ static char * @@ -470,7 +470,7 @@ hex_to_string(const unsigned char *buffer, long len) q[-1] = 0; return tmp; } -LCRYPTO_ALIAS(hex_to_string) +LCRYPTO_ALIAS(hex_to_string); /* Give a string of hex digits convert to * a buffer @@ -532,7 +532,7 @@ string_to_hex(const char *str, long *len) X509V3error(X509V3_R_ILLEGAL_HEX_DIGIT); return NULL; } -LCRYPTO_ALIAS(string_to_hex) +LCRYPTO_ALIAS(string_to_hex); /* V2I name comparison function: returns zero if 'name' matches * cmp or cmp.* @@ -570,7 +570,7 @@ X509_get1_email(X509 *x) sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free); return ret; } -LCRYPTO_ALIAS(X509_get1_email) +LCRYPTO_ALIAS(X509_get1_email); STACK_OF(OPENSSL_STRING) * X509_get1_ocsp(X509 *x) @@ -595,7 +595,7 @@ X509_get1_ocsp(X509 *x) AUTHORITY_INFO_ACCESS_free(info); return ret; } -LCRYPTO_ALIAS(X509_get1_ocsp) +LCRYPTO_ALIAS(X509_get1_ocsp); STACK_OF(OPENSSL_STRING) * X509_REQ_get1_email(X509_REQ *x) @@ -611,7 +611,7 @@ X509_REQ_get1_email(X509_REQ *x) sk_X509_EXTENSION_pop_free(exts, X509_EXTENSION_free); return ret; } -LCRYPTO_ALIAS(X509_REQ_get1_email) +LCRYPTO_ALIAS(X509_REQ_get1_email); static STACK_OF(OPENSSL_STRING) * @@ -681,7 +681,7 @@ X509_email_free(STACK_OF(OPENSSL_STRING) *sk) { sk_OPENSSL_STRING_pop_free(sk, str_free); } -LCRYPTO_ALIAS(X509_email_free) +LCRYPTO_ALIAS(X509_email_free); typedef int (*equal_fn)(const unsigned char *pattern, size_t pattern_len, const unsigned char *subject, size_t subject_len, unsigned int flags); @@ -1083,7 +1083,7 @@ X509_check_host(X509 *x, const char *chk, size_t chklen, unsigned int flags, return -2; return do_x509_check(x, chk, chklen, flags, GEN_DNS, peername); } -LCRYPTO_ALIAS(X509_check_host) +LCRYPTO_ALIAS(X509_check_host); int X509_check_email(X509 *x, const char *chk, size_t chklen, unsigned int flags) @@ -1096,7 +1096,7 @@ X509_check_email(X509 *x, const char *chk, size_t chklen, unsigned int flags) return -2; return do_x509_check(x, chk, chklen, flags, GEN_EMAIL, NULL); } -LCRYPTO_ALIAS(X509_check_email) +LCRYPTO_ALIAS(X509_check_email); int X509_check_ip(X509 *x, const unsigned char *chk, size_t chklen, @@ -1106,7 +1106,7 @@ X509_check_ip(X509 *x, const unsigned char *chk, size_t chklen, return -2; return do_x509_check(x, (char *)chk, chklen, flags, GEN_IPADD, NULL); } -LCRYPTO_ALIAS(X509_check_ip) +LCRYPTO_ALIAS(X509_check_ip); int X509_check_ip_asc(X509 *x, const char *ipasc, unsigned int flags) @@ -1121,7 +1121,7 @@ X509_check_ip_asc(X509 *x, const char *ipasc, unsigned int flags) return -2; return do_x509_check(x, (char *)ipout, iplen, flags, GEN_IPADD, NULL); } -LCRYPTO_ALIAS(X509_check_ip_asc) +LCRYPTO_ALIAS(X509_check_ip_asc); /* Convert IP addresses both IPv4 and IPv6 into an * OCTET STRING compatible with RFC3280. @@ -1150,7 +1150,7 @@ a2i_IPADDRESS(const char *ipasc) } return ret; } -LCRYPTO_ALIAS(a2i_IPADDRESS) +LCRYPTO_ALIAS(a2i_IPADDRESS); ASN1_OCTET_STRING * a2i_IPADDRESS_NC(const char *ipasc) @@ -1196,7 +1196,7 @@ a2i_IPADDRESS_NC(const char *ipasc) ASN1_OCTET_STRING_free(ret); return NULL; } -LCRYPTO_ALIAS(a2i_IPADDRESS_NC) +LCRYPTO_ALIAS(a2i_IPADDRESS_NC); int @@ -1214,7 +1214,7 @@ a2i_ipadd(unsigned char *ipout, const char *ipasc) return 4; } } -LCRYPTO_ALIAS(a2i_ipadd) +LCRYPTO_ALIAS(a2i_ipadd); static int ipv4_from_asc(unsigned char *v4, const char *in) @@ -1411,4 +1411,4 @@ X509V3_NAME_from_section(X509_NAME *nm, STACK_OF(CONF_VALUE)*dn_sk, } return 1; } -LCRYPTO_ALIAS(X509V3_NAME_from_section) +LCRYPTO_ALIAS(X509V3_NAME_from_section); diff --git a/lib/libcrypto/x509/x509_v3.c b/lib/libcrypto/x509/x509_v3.c index 27f670c450f..8dddb463ce0 100644 --- a/lib/libcrypto/x509/x509_v3.c +++ b/lib/libcrypto/x509/x509_v3.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_v3.c,v 1.20 2022/11/26 16:08:55 tb Exp $ */ +/* $OpenBSD: x509_v3.c,v 1.21 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -75,7 +75,7 @@ X509v3_get_ext_count(const STACK_OF(X509_EXTENSION) *x) return (0); return (sk_X509_EXTENSION_num(x)); } -LCRYPTO_ALIAS(X509v3_get_ext_count) +LCRYPTO_ALIAS(X509v3_get_ext_count); int X509v3_get_ext_by_NID(const STACK_OF(X509_EXTENSION) *x, int nid, int lastpos) @@ -87,7 +87,7 @@ X509v3_get_ext_by_NID(const STACK_OF(X509_EXTENSION) *x, int nid, int lastpos) return (-2); return (X509v3_get_ext_by_OBJ(x, obj, lastpos)); } -LCRYPTO_ALIAS(X509v3_get_ext_by_NID) +LCRYPTO_ALIAS(X509v3_get_ext_by_NID); int X509v3_get_ext_by_OBJ(const STACK_OF(X509_EXTENSION) *sk, @@ -109,7 +109,7 @@ X509v3_get_ext_by_OBJ(const STACK_OF(X509_EXTENSION) *sk, } return (-1); } -LCRYPTO_ALIAS(X509v3_get_ext_by_OBJ) +LCRYPTO_ALIAS(X509v3_get_ext_by_OBJ); int X509v3_get_ext_by_critical(const STACK_OF(X509_EXTENSION) *sk, int crit, @@ -132,7 +132,7 @@ X509v3_get_ext_by_critical(const STACK_OF(X509_EXTENSION) *sk, int crit, } return (-1); } -LCRYPTO_ALIAS(X509v3_get_ext_by_critical) +LCRYPTO_ALIAS(X509v3_get_ext_by_critical); X509_EXTENSION * X509v3_get_ext(const STACK_OF(X509_EXTENSION) *x, int loc) @@ -142,7 +142,7 @@ X509v3_get_ext(const STACK_OF(X509_EXTENSION) *x, int loc) else return sk_X509_EXTENSION_value(x, loc); } -LCRYPTO_ALIAS(X509v3_get_ext) +LCRYPTO_ALIAS(X509v3_get_ext); X509_EXTENSION * X509v3_delete_ext(STACK_OF(X509_EXTENSION) *x, int loc) @@ -154,7 +154,7 @@ X509v3_delete_ext(STACK_OF(X509_EXTENSION) *x, int loc) ret = sk_X509_EXTENSION_delete(x, loc); return (ret); } -LCRYPTO_ALIAS(X509v3_delete_ext) +LCRYPTO_ALIAS(X509v3_delete_ext); STACK_OF(X509_EXTENSION) * X509v3_add_ext(STACK_OF(X509_EXTENSION) **x, X509_EXTENSION *ex, int loc) @@ -197,7 +197,7 @@ err2: sk_X509_EXTENSION_free(sk); return (NULL); } -LCRYPTO_ALIAS(X509v3_add_ext) +LCRYPTO_ALIAS(X509v3_add_ext); X509_EXTENSION * X509_EXTENSION_create_by_NID(X509_EXTENSION **ex, int nid, int crit, @@ -216,7 +216,7 @@ X509_EXTENSION_create_by_NID(X509_EXTENSION **ex, int nid, int crit, ASN1_OBJECT_free(obj); return (ret); } -LCRYPTO_ALIAS(X509_EXTENSION_create_by_NID) +LCRYPTO_ALIAS(X509_EXTENSION_create_by_NID); X509_EXTENSION * X509_EXTENSION_create_by_OBJ(X509_EXTENSION **ex, const ASN1_OBJECT *obj, @@ -248,7 +248,7 @@ err: X509_EXTENSION_free(ret); return (NULL); } -LCRYPTO_ALIAS(X509_EXTENSION_create_by_OBJ) +LCRYPTO_ALIAS(X509_EXTENSION_create_by_OBJ); int X509_EXTENSION_set_object(X509_EXTENSION *ex, const ASN1_OBJECT *obj) @@ -259,7 +259,7 @@ X509_EXTENSION_set_object(X509_EXTENSION *ex, const ASN1_OBJECT *obj) ex->object = OBJ_dup(obj); return ex->object != NULL; } -LCRYPTO_ALIAS(X509_EXTENSION_set_object) +LCRYPTO_ALIAS(X509_EXTENSION_set_object); int X509_EXTENSION_set_critical(X509_EXTENSION *ex, int crit) @@ -269,7 +269,7 @@ X509_EXTENSION_set_critical(X509_EXTENSION *ex, int crit) ex->critical = (crit) ? 0xFF : -1; return (1); } -LCRYPTO_ALIAS(X509_EXTENSION_set_critical) +LCRYPTO_ALIAS(X509_EXTENSION_set_critical); int X509_EXTENSION_set_data(X509_EXTENSION *ex, ASN1_OCTET_STRING *data) @@ -283,7 +283,7 @@ X509_EXTENSION_set_data(X509_EXTENSION *ex, ASN1_OCTET_STRING *data) return (0); return (1); } -LCRYPTO_ALIAS(X509_EXTENSION_set_data) +LCRYPTO_ALIAS(X509_EXTENSION_set_data); ASN1_OBJECT * X509_EXTENSION_get_object(X509_EXTENSION *ex) @@ -292,7 +292,7 @@ X509_EXTENSION_get_object(X509_EXTENSION *ex) return (NULL); return (ex->object); } -LCRYPTO_ALIAS(X509_EXTENSION_get_object) +LCRYPTO_ALIAS(X509_EXTENSION_get_object); ASN1_OCTET_STRING * X509_EXTENSION_get_data(X509_EXTENSION *ex) @@ -301,7 +301,7 @@ X509_EXTENSION_get_data(X509_EXTENSION *ex) return (NULL); return (ex->value); } -LCRYPTO_ALIAS(X509_EXTENSION_get_data) +LCRYPTO_ALIAS(X509_EXTENSION_get_data); int X509_EXTENSION_get_critical(const X509_EXTENSION *ex) @@ -312,4 +312,4 @@ X509_EXTENSION_get_critical(const X509_EXTENSION *ex) return 1; return 0; } -LCRYPTO_ALIAS(X509_EXTENSION_get_critical) +LCRYPTO_ALIAS(X509_EXTENSION_get_critical); diff --git a/lib/libcrypto/x509/x509_vfy.c b/lib/libcrypto/x509/x509_vfy.c index f6c7c21f5f6..8bba7961981 100644 --- a/lib/libcrypto/x509/x509_vfy.c +++ b/lib/libcrypto/x509/x509_vfy.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_vfy.c,v 1.110 2022/12/26 07:18:53 jmc Exp $ */ +/* $OpenBSD: x509_vfy.c,v 1.111 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -668,7 +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) +LCRYPTO_ALIAS(X509_verify_cert); /* Given a STACK_OF(X509) find the issuer of cert (if any) */ @@ -2012,7 +2012,7 @@ X509_cmp_current_time(const ASN1_TIME *ctm) { return X509_cmp_time(ctm, NULL); } -LCRYPTO_ALIAS(X509_cmp_current_time) +LCRYPTO_ALIAS(X509_cmp_current_time); /* * Compare a possibly unvalidated ASN1_TIME string against a time_t @@ -2052,7 +2052,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) +LCRYPTO_ALIAS(X509_cmp_time); ASN1_TIME * @@ -2060,14 +2060,14 @@ X509_gmtime_adj(ASN1_TIME *s, long adj) { return X509_time_adj(s, adj, NULL); } -LCRYPTO_ALIAS(X509_gmtime_adj) +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) +LCRYPTO_ALIAS(X509_time_adj); ASN1_TIME * X509_time_adj_ex(ASN1_TIME *s, int offset_day, long offset_sec, time_t *in_time) @@ -2080,7 +2080,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) +LCRYPTO_ALIAS(X509_time_adj_ex); int X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK_OF(X509) *chain) @@ -2120,7 +2120,7 @@ X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK_OF(X509) *chain) return 0; return 1; } -LCRYPTO_ALIAS(X509_get_pubkey_parameters) +LCRYPTO_ALIAS(X509_get_pubkey_parameters); int X509_STORE_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, @@ -2131,77 +2131,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) +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) +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) +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) +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) +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) +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) +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) +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) +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) +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) +LCRYPTO_ALIAS(X509_STORE_CTX_get0_chain); STACK_OF(X509) * X509_STORE_CTX_get1_chain(X509_STORE_CTX *ctx) @@ -2218,70 +2218,70 @@ X509_STORE_CTX_get1_chain(X509_STORE_CTX *ctx) } return chain; } -LCRYPTO_ALIAS(X509_STORE_CTX_get1_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) +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) +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) +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) +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) +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) +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) +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) +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) +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 @@ -2337,7 +2337,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) +LCRYPTO_ALIAS(X509_STORE_CTX_purpose_inherit); X509_STORE_CTX * X509_STORE_CTX_new(void) @@ -2351,7 +2351,7 @@ X509_STORE_CTX_new(void) } return ctx; } -LCRYPTO_ALIAS(X509_STORE_CTX_new) +LCRYPTO_ALIAS(X509_STORE_CTX_new); void X509_STORE_CTX_free(X509_STORE_CTX *ctx) @@ -2362,7 +2362,7 @@ X509_STORE_CTX_free(X509_STORE_CTX *ctx) X509_STORE_CTX_cleanup(ctx); free(ctx); } -LCRYPTO_ALIAS(X509_STORE_CTX_free) +LCRYPTO_ALIAS(X509_STORE_CTX_free); int X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, X509 *x509, @@ -2484,7 +2484,7 @@ X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, X509 *x509, } return 1; } -LCRYPTO_ALIAS(X509_STORE_CTX_init) +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. @@ -2496,14 +2496,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) +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) +LCRYPTO_ALIAS(X509_STORE_CTX_set0_trusted_stack); void X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx) @@ -2527,35 +2527,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) +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) +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) +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) +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) +LCRYPTO_ALIAS(X509_STORE_CTX_get_verify_cb); void X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx, @@ -2563,28 +2563,28 @@ X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx, { ctx->verify_cb = verify_cb; } -LCRYPTO_ALIAS(X509_STORE_CTX_set_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) +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) +LCRYPTO_ALIAS(X509_STORE_CTX_set_verify); X509_STORE_CTX_check_issued_fn X509_STORE_get_check_issued(X509_STORE *store) { return store->check_issued; } -LCRYPTO_ALIAS(X509_STORE_get_check_issued) +LCRYPTO_ALIAS(X509_STORE_get_check_issued); void X509_STORE_set_check_issued(X509_STORE *store, @@ -2592,35 +2592,35 @@ X509_STORE_set_check_issued(X509_STORE *store, { store->check_issued = check_issued; } -LCRYPTO_ALIAS(X509_STORE_set_check_issued) +LCRYPTO_ALIAS(X509_STORE_set_check_issued); X509_STORE_CTX_check_issued_fn X509_STORE_CTX_get_check_issued(X509_STORE_CTX *ctx) { return ctx->check_issued; } -LCRYPTO_ALIAS(X509_STORE_CTX_get_check_issued) +LCRYPTO_ALIAS(X509_STORE_CTX_get_check_issued); X509 * X509_STORE_CTX_get0_cert(X509_STORE_CTX *ctx) { return ctx->cert; } -LCRYPTO_ALIAS(X509_STORE_CTX_get0_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) +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) +LCRYPTO_ALIAS(X509_STORE_CTX_set0_untrusted); void X509_STORE_CTX_set0_verified_chain(X509_STORE_CTX *ctx, STACK_OF(X509) *sk) @@ -2628,28 +2628,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) +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) +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) +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) +LCRYPTO_ALIAS(X509_STORE_CTX_get_num_untrusted); int X509_STORE_CTX_set_default(X509_STORE_CTX *ctx, const char *name) @@ -2660,14 +2660,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) +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) +LCRYPTO_ALIAS(X509_STORE_CTX_get0_param); void X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param) @@ -2676,7 +2676,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) +LCRYPTO_ALIAS(X509_STORE_CTX_set0_param); /* * Check if |bits| are adequate for |security level|. diff --git a/lib/libcrypto/x509/x509_vpm.c b/lib/libcrypto/x509/x509_vpm.c index 724a28fc1b7..cb13267b753 100644 --- a/lib/libcrypto/x509/x509_vpm.c +++ b/lib/libcrypto/x509/x509_vpm.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509_vpm.c,v 1.32 2022/11/26 16:08:55 tb Exp $ */ +/* $OpenBSD: x509_vpm.c,v 1.33 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 2004. */ @@ -218,7 +218,7 @@ X509_VERIFY_PARAM_new(void) x509_verify_param_zero(param); return param; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_new) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_new); void X509_VERIFY_PARAM_free(X509_VERIFY_PARAM *param) @@ -229,7 +229,7 @@ X509_VERIFY_PARAM_free(X509_VERIFY_PARAM *param) free(param->id); free(param); } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_free) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_free); /* * This function determines how parameters are "inherited" from one structure @@ -358,7 +358,7 @@ X509_VERIFY_PARAM_inherit(X509_VERIFY_PARAM *dest, const X509_VERIFY_PARAM *src) return 1; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_inherit) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_inherit); int X509_VERIFY_PARAM_set1(X509_VERIFY_PARAM *to, const X509_VERIFY_PARAM *from) @@ -371,7 +371,7 @@ X509_VERIFY_PARAM_set1(X509_VERIFY_PARAM *to, const X509_VERIFY_PARAM *from) to->inh_flags = save_flags; return ret; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1); static int x509_param_set1_internal(char **pdest, size_t *pdestlen, const char *src, @@ -416,7 +416,7 @@ X509_VERIFY_PARAM_set1_name(X509_VERIFY_PARAM *param, const char *name) return 1; return 0; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_name) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_name); int X509_VERIFY_PARAM_set_flags(X509_VERIFY_PARAM *param, unsigned long flags) @@ -426,7 +426,7 @@ X509_VERIFY_PARAM_set_flags(X509_VERIFY_PARAM *param, unsigned long flags) param->flags |= X509_V_FLAG_POLICY_CHECK; return 1; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_flags) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_flags); int X509_VERIFY_PARAM_clear_flags(X509_VERIFY_PARAM *param, unsigned long flags) @@ -434,49 +434,49 @@ X509_VERIFY_PARAM_clear_flags(X509_VERIFY_PARAM *param, unsigned long flags) param->flags &= ~flags; return 1; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_clear_flags) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_clear_flags); unsigned long X509_VERIFY_PARAM_get_flags(X509_VERIFY_PARAM *param) { return param->flags; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_flags) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_flags); int X509_VERIFY_PARAM_set_purpose(X509_VERIFY_PARAM *param, int purpose) { return X509_PURPOSE_set(¶m->purpose, purpose); } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_purpose) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_purpose); int X509_VERIFY_PARAM_set_trust(X509_VERIFY_PARAM *param, int trust) { return X509_TRUST_set(¶m->trust, trust); } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_trust) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_trust); void X509_VERIFY_PARAM_set_depth(X509_VERIFY_PARAM *param, int depth) { param->depth = depth; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_depth) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_depth); void X509_VERIFY_PARAM_set_auth_level(X509_VERIFY_PARAM *param, int auth_level) { param->security_level = auth_level; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_auth_level) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_auth_level); time_t X509_VERIFY_PARAM_get_time(const X509_VERIFY_PARAM *param) { return param->check_time; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_time) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_time); void X509_VERIFY_PARAM_set_time(X509_VERIFY_PARAM *param, time_t t) @@ -484,7 +484,7 @@ X509_VERIFY_PARAM_set_time(X509_VERIFY_PARAM *param, time_t t) param->check_time = t; param->flags |= X509_V_FLAG_USE_CHECK_TIME; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_time) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_time); int X509_VERIFY_PARAM_add0_policy(X509_VERIFY_PARAM *param, ASN1_OBJECT *policy) @@ -498,7 +498,7 @@ X509_VERIFY_PARAM_add0_policy(X509_VERIFY_PARAM *param, ASN1_OBJECT *policy) return 0; return 1; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_add0_policy) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_add0_policy); int X509_VERIFY_PARAM_set1_policies(X509_VERIFY_PARAM *param, @@ -534,7 +534,7 @@ X509_VERIFY_PARAM_set1_policies(X509_VERIFY_PARAM *param, param->flags |= X509_V_FLAG_POLICY_CHECK; return 1; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_policies) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_policies); int X509_VERIFY_PARAM_set1_host(X509_VERIFY_PARAM *param, @@ -545,7 +545,7 @@ X509_VERIFY_PARAM_set1_host(X509_VERIFY_PARAM *param, param->id->poisoned = 1; return 0; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_host) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_host); int X509_VERIFY_PARAM_add1_host(X509_VERIFY_PARAM *param, @@ -556,21 +556,21 @@ X509_VERIFY_PARAM_add1_host(X509_VERIFY_PARAM *param, param->id->poisoned = 1; return 0; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_add1_host) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_add1_host); void X509_VERIFY_PARAM_set_hostflags(X509_VERIFY_PARAM *param, unsigned int flags) { param->id->hostflags = flags; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_hostflags) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_hostflags); char * X509_VERIFY_PARAM_get0_peername(X509_VERIFY_PARAM *param) { return param->id->peername; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_get0_peername) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_get0_peername); int X509_VERIFY_PARAM_set1_email(X509_VERIFY_PARAM *param, const char *email, @@ -582,7 +582,7 @@ X509_VERIFY_PARAM_set1_email(X509_VERIFY_PARAM *param, const char *email, param->id->poisoned = 1; return 0; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_email) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_email); int X509_VERIFY_PARAM_set1_ip(X509_VERIFY_PARAM *param, const unsigned char *ip, @@ -597,7 +597,7 @@ X509_VERIFY_PARAM_set1_ip(X509_VERIFY_PARAM *param, const unsigned char *ip, param->id->poisoned = 1; return 0; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_ip) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_ip); int X509_VERIFY_PARAM_set1_ip_asc(X509_VERIFY_PARAM *param, const char *ipasc) @@ -608,21 +608,21 @@ X509_VERIFY_PARAM_set1_ip_asc(X509_VERIFY_PARAM *param, const char *ipasc) iplen = (size_t)a2i_ipadd(ipout, ipasc); return X509_VERIFY_PARAM_set1_ip(param, ipout, iplen); } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_ip_asc) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_ip_asc); int X509_VERIFY_PARAM_get_depth(const X509_VERIFY_PARAM *param) { return param->depth; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_depth) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_depth); const char * X509_VERIFY_PARAM_get0_name(const X509_VERIFY_PARAM *param) { return param->name; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_get0_name) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_get0_name); static const X509_VERIFY_PARAM_ID _empty_id = { NULL }; @@ -704,7 +704,7 @@ X509_VERIFY_PARAM_add0_table(X509_VERIFY_PARAM *param) return 0; return 1; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_add0_table) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_add0_table); int X509_VERIFY_PARAM_get_count(void) @@ -714,7 +714,7 @@ X509_VERIFY_PARAM_get_count(void) num += sk_X509_VERIFY_PARAM_num(param_table); return num; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_count) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_count); const X509_VERIFY_PARAM * X509_VERIFY_PARAM_get0(int id) @@ -724,7 +724,7 @@ X509_VERIFY_PARAM_get0(int id) return default_table + id; return sk_X509_VERIFY_PARAM_value(param_table, id - num); } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_get0) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_get0); const X509_VERIFY_PARAM * X509_VERIFY_PARAM_lookup(const char *name) @@ -747,7 +747,7 @@ X509_VERIFY_PARAM_lookup(const char *name) } return NULL; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_lookup) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_lookup); void X509_VERIFY_PARAM_table_cleanup(void) @@ -757,4 +757,4 @@ X509_VERIFY_PARAM_table_cleanup(void) X509_VERIFY_PARAM_free); param_table = NULL; } -LCRYPTO_ALIAS(X509_VERIFY_PARAM_table_cleanup) +LCRYPTO_ALIAS(X509_VERIFY_PARAM_table_cleanup); diff --git a/lib/libcrypto/x509/x509cset.c b/lib/libcrypto/x509/x509cset.c index a75a63b03b4..7904a7d6700 100644 --- a/lib/libcrypto/x509/x509cset.c +++ b/lib/libcrypto/x509/x509cset.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509cset.c,v 1.18 2022/11/26 16:08:55 tb Exp $ */ +/* $OpenBSD: x509cset.c,v 1.19 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 2001. */ @@ -71,7 +71,7 @@ X509_CRL_up_ref(X509_CRL *x) int refs = CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509_CRL); return (refs > 1) ? 1 : 0; } -LCRYPTO_ALIAS(X509_CRL_up_ref) +LCRYPTO_ALIAS(X509_CRL_up_ref); int X509_CRL_set_version(X509_CRL *x, long version) @@ -84,7 +84,7 @@ X509_CRL_set_version(X509_CRL *x, long version) } return (ASN1_INTEGER_set(x->crl->version, version)); } -LCRYPTO_ALIAS(X509_CRL_set_version) +LCRYPTO_ALIAS(X509_CRL_set_version); int X509_CRL_set_issuer_name(X509_CRL *x, X509_NAME *name) @@ -93,7 +93,7 @@ X509_CRL_set_issuer_name(X509_CRL *x, X509_NAME *name) return (0); return (X509_NAME_set(&x->crl->issuer, name)); } -LCRYPTO_ALIAS(X509_CRL_set_issuer_name) +LCRYPTO_ALIAS(X509_CRL_set_issuer_name); int X509_CRL_set_lastUpdate(X509_CRL *x, const ASN1_TIME *tm) @@ -112,14 +112,14 @@ X509_CRL_set_lastUpdate(X509_CRL *x, const ASN1_TIME *tm) } return (in != NULL); } -LCRYPTO_ALIAS(X509_CRL_set_lastUpdate) +LCRYPTO_ALIAS(X509_CRL_set_lastUpdate); int X509_CRL_set1_lastUpdate(X509_CRL *x, const ASN1_TIME *tm) { return X509_CRL_set_lastUpdate(x, tm); } -LCRYPTO_ALIAS(X509_CRL_set1_lastUpdate) +LCRYPTO_ALIAS(X509_CRL_set1_lastUpdate); int X509_CRL_set_nextUpdate(X509_CRL *x, const ASN1_TIME *tm) @@ -138,14 +138,14 @@ X509_CRL_set_nextUpdate(X509_CRL *x, const ASN1_TIME *tm) } return (in != NULL); } -LCRYPTO_ALIAS(X509_CRL_set_nextUpdate) +LCRYPTO_ALIAS(X509_CRL_set_nextUpdate); int X509_CRL_set1_nextUpdate(X509_CRL *x, const ASN1_TIME *tm) { return X509_CRL_set_nextUpdate(x, tm); } -LCRYPTO_ALIAS(X509_CRL_set1_nextUpdate) +LCRYPTO_ALIAS(X509_CRL_set1_nextUpdate); int X509_CRL_sort(X509_CRL *c) @@ -163,28 +163,28 @@ X509_CRL_sort(X509_CRL *c) c->crl->enc.modified = 1; return 1; } -LCRYPTO_ALIAS(X509_CRL_sort) +LCRYPTO_ALIAS(X509_CRL_sort); const STACK_OF(X509_EXTENSION) * X509_REVOKED_get0_extensions(const X509_REVOKED *x) { return x->extensions; } -LCRYPTO_ALIAS(X509_REVOKED_get0_extensions) +LCRYPTO_ALIAS(X509_REVOKED_get0_extensions); const ASN1_TIME * X509_REVOKED_get0_revocationDate(const X509_REVOKED *x) { return x->revocationDate; } -LCRYPTO_ALIAS(X509_REVOKED_get0_revocationDate) +LCRYPTO_ALIAS(X509_REVOKED_get0_revocationDate); const ASN1_INTEGER * X509_REVOKED_get0_serialNumber(const X509_REVOKED *x) { return x->serialNumber; } -LCRYPTO_ALIAS(X509_REVOKED_get0_serialNumber) +LCRYPTO_ALIAS(X509_REVOKED_get0_serialNumber); int X509_REVOKED_set_revocationDate(X509_REVOKED *x, ASN1_TIME *tm) @@ -203,7 +203,7 @@ X509_REVOKED_set_revocationDate(X509_REVOKED *x, ASN1_TIME *tm) } return (in != NULL); } -LCRYPTO_ALIAS(X509_REVOKED_set_revocationDate) +LCRYPTO_ALIAS(X509_REVOKED_set_revocationDate); int X509_REVOKED_set_serialNumber(X509_REVOKED *x, ASN1_INTEGER *serial) @@ -222,7 +222,7 @@ X509_REVOKED_set_serialNumber(X509_REVOKED *x, ASN1_INTEGER *serial) } return (in != NULL); } -LCRYPTO_ALIAS(X509_REVOKED_set_serialNumber) +LCRYPTO_ALIAS(X509_REVOKED_set_serialNumber); int i2d_re_X509_CRL_tbs(X509_CRL *crl, unsigned char **pp) @@ -230,4 +230,4 @@ i2d_re_X509_CRL_tbs(X509_CRL *crl, unsigned char **pp) crl->crl->enc.modified = 1; return i2d_X509_CRL_INFO(crl->crl, pp); } -LCRYPTO_ALIAS(i2d_re_X509_CRL_tbs) +LCRYPTO_ALIAS(i2d_re_X509_CRL_tbs); diff --git a/lib/libcrypto/x509/x509name.c b/lib/libcrypto/x509/x509name.c index 19a253da4da..a6e4dbef89b 100644 --- a/lib/libcrypto/x509/x509name.c +++ b/lib/libcrypto/x509/x509name.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509name.c,v 1.30 2022/12/26 07:18:53 jmc Exp $ */ +/* $OpenBSD: x509name.c,v 1.31 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -78,7 +78,7 @@ X509_NAME_get_text_by_NID(X509_NAME *name, int nid, char *buf, int len) return (-1); return (X509_NAME_get_text_by_OBJ(name, obj, buf, len)); } -LCRYPTO_ALIAS(X509_NAME_get_text_by_NID) +LCRYPTO_ALIAS(X509_NAME_get_text_by_NID); int X509_NAME_get_text_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, char *buf, @@ -100,7 +100,7 @@ X509_NAME_get_text_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, char *buf, } return (i); } -LCRYPTO_ALIAS(X509_NAME_get_text_by_OBJ) +LCRYPTO_ALIAS(X509_NAME_get_text_by_OBJ); int X509_NAME_entry_count(const X509_NAME *name) @@ -109,7 +109,7 @@ X509_NAME_entry_count(const X509_NAME *name) return (0); return (sk_X509_NAME_ENTRY_num(name->entries)); } -LCRYPTO_ALIAS(X509_NAME_entry_count) +LCRYPTO_ALIAS(X509_NAME_entry_count); int X509_NAME_get_index_by_NID(const X509_NAME *name, int nid, int lastpos) @@ -121,7 +121,7 @@ X509_NAME_get_index_by_NID(const X509_NAME *name, int nid, int lastpos) return (-2); return (X509_NAME_get_index_by_OBJ(name, obj, lastpos)); } -LCRYPTO_ALIAS(X509_NAME_get_index_by_NID) +LCRYPTO_ALIAS(X509_NAME_get_index_by_NID); /* NOTE: you should be passing -1, not 0 as lastpos */ int @@ -145,7 +145,7 @@ X509_NAME_get_index_by_OBJ(const X509_NAME *name, const ASN1_OBJECT *obj, } return (-1); } -LCRYPTO_ALIAS(X509_NAME_get_index_by_OBJ) +LCRYPTO_ALIAS(X509_NAME_get_index_by_OBJ); X509_NAME_ENTRY * X509_NAME_get_entry(const X509_NAME *name, int loc) @@ -156,7 +156,7 @@ X509_NAME_get_entry(const X509_NAME *name, int loc) else return (sk_X509_NAME_ENTRY_value(name->entries, loc)); } -LCRYPTO_ALIAS(X509_NAME_get_entry) +LCRYPTO_ALIAS(X509_NAME_get_entry); X509_NAME_ENTRY * X509_NAME_delete_entry(X509_NAME *name, int loc) @@ -195,7 +195,7 @@ X509_NAME_delete_entry(X509_NAME *name, int loc) sk_X509_NAME_ENTRY_value(sk, i)->set--; return (ret); } -LCRYPTO_ALIAS(X509_NAME_delete_entry) +LCRYPTO_ALIAS(X509_NAME_delete_entry); int X509_NAME_add_entry_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, int type, @@ -211,7 +211,7 @@ X509_NAME_add_entry_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, int type, X509_NAME_ENTRY_free(ne); return ret; } -LCRYPTO_ALIAS(X509_NAME_add_entry_by_OBJ) +LCRYPTO_ALIAS(X509_NAME_add_entry_by_OBJ); int X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type, @@ -227,7 +227,7 @@ X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type, X509_NAME_ENTRY_free(ne); return ret; } -LCRYPTO_ALIAS(X509_NAME_add_entry_by_NID) +LCRYPTO_ALIAS(X509_NAME_add_entry_by_NID); int X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type, @@ -243,7 +243,7 @@ X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type, X509_NAME_ENTRY_free(ne); return ret; } -LCRYPTO_ALIAS(X509_NAME_add_entry_by_txt) +LCRYPTO_ALIAS(X509_NAME_add_entry_by_txt); /* if set is -1, append to previous set, 0 'a new one', and 1, * prepend to the guy we are about to stomp on. */ @@ -302,7 +302,7 @@ err: X509_NAME_ENTRY_free(new_name); return (0); } -LCRYPTO_ALIAS(X509_NAME_add_entry) +LCRYPTO_ALIAS(X509_NAME_add_entry); X509_NAME_ENTRY * X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY **ne, @@ -321,7 +321,7 @@ X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY **ne, ASN1_OBJECT_free(obj); return nentry; } -LCRYPTO_ALIAS(X509_NAME_ENTRY_create_by_txt) +LCRYPTO_ALIAS(X509_NAME_ENTRY_create_by_txt); X509_NAME_ENTRY * X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid, int type, @@ -339,7 +339,7 @@ X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid, int type, ASN1_OBJECT_free(obj); return nentry; } -LCRYPTO_ALIAS(X509_NAME_ENTRY_create_by_NID) +LCRYPTO_ALIAS(X509_NAME_ENTRY_create_by_NID); X509_NAME_ENTRY * X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY **ne, const ASN1_OBJECT *obj, @@ -367,7 +367,7 @@ err: X509_NAME_ENTRY_free(ret); return (NULL); } -LCRYPTO_ALIAS(X509_NAME_ENTRY_create_by_OBJ) +LCRYPTO_ALIAS(X509_NAME_ENTRY_create_by_OBJ); int X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne, const ASN1_OBJECT *obj) @@ -380,7 +380,7 @@ X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne, const ASN1_OBJECT *obj) ne->object = OBJ_dup(obj); return ((ne->object == NULL) ? 0 : 1); } -LCRYPTO_ALIAS(X509_NAME_ENTRY_set_object) +LCRYPTO_ALIAS(X509_NAME_ENTRY_set_object); int X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type, @@ -406,7 +406,7 @@ X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type, } return (1); } -LCRYPTO_ALIAS(X509_NAME_ENTRY_set_data) +LCRYPTO_ALIAS(X509_NAME_ENTRY_set_data); ASN1_OBJECT * X509_NAME_ENTRY_get_object(const X509_NAME_ENTRY *ne) @@ -415,7 +415,7 @@ X509_NAME_ENTRY_get_object(const X509_NAME_ENTRY *ne) return (NULL); return (ne->object); } -LCRYPTO_ALIAS(X509_NAME_ENTRY_get_object) +LCRYPTO_ALIAS(X509_NAME_ENTRY_get_object); ASN1_STRING * X509_NAME_ENTRY_get_data(const X509_NAME_ENTRY *ne) @@ -424,11 +424,11 @@ X509_NAME_ENTRY_get_data(const X509_NAME_ENTRY *ne) return (NULL); return (ne->value); } -LCRYPTO_ALIAS(X509_NAME_ENTRY_get_data) +LCRYPTO_ALIAS(X509_NAME_ENTRY_get_data); int X509_NAME_ENTRY_set(const X509_NAME_ENTRY *ne) { return (ne->set); } -LCRYPTO_ALIAS(X509_NAME_ENTRY_set) +LCRYPTO_ALIAS(X509_NAME_ENTRY_set); diff --git a/lib/libcrypto/x509/x509rset.c b/lib/libcrypto/x509/x509rset.c index 640a850800b..f097a379fb8 100644 --- a/lib/libcrypto/x509/x509rset.c +++ b/lib/libcrypto/x509/x509rset.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509rset.c,v 1.11 2022/11/26 16:08:55 tb Exp $ */ +/* $OpenBSD: x509rset.c,v 1.12 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -73,14 +73,14 @@ X509_REQ_set_version(X509_REQ *x, long version) x->req_info->enc.modified = 1; return (ASN1_INTEGER_set(x->req_info->version, version)); } -LCRYPTO_ALIAS(X509_REQ_set_version) +LCRYPTO_ALIAS(X509_REQ_set_version); long X509_REQ_get_version(const X509_REQ *x) { return ASN1_INTEGER_get(x->req_info->version); } -LCRYPTO_ALIAS(X509_REQ_get_version) +LCRYPTO_ALIAS(X509_REQ_get_version); int X509_REQ_set_subject_name(X509_REQ *x, X509_NAME *name) @@ -90,14 +90,14 @@ X509_REQ_set_subject_name(X509_REQ *x, X509_NAME *name) x->req_info->enc.modified = 1; return (X509_NAME_set(&x->req_info->subject, name)); } -LCRYPTO_ALIAS(X509_REQ_set_subject_name) +LCRYPTO_ALIAS(X509_REQ_set_subject_name); X509_NAME * X509_REQ_get_subject_name(const X509_REQ *x) { return x->req_info->subject; } -LCRYPTO_ALIAS(X509_REQ_get_subject_name) +LCRYPTO_ALIAS(X509_REQ_get_subject_name); int X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey) @@ -107,4 +107,4 @@ X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey) x->req_info->enc.modified = 1; return (X509_PUBKEY_set(&x->req_info->pubkey, pkey)); } -LCRYPTO_ALIAS(X509_REQ_set_pubkey) +LCRYPTO_ALIAS(X509_REQ_set_pubkey); diff --git a/lib/libcrypto/x509/x509spki.c b/lib/libcrypto/x509/x509spki.c index 2c1b506dcdc..04c9a6f01b0 100644 --- a/lib/libcrypto/x509/x509spki.c +++ b/lib/libcrypto/x509/x509spki.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509spki.c,v 1.15 2022/11/14 17:48:50 beck Exp $ */ +/* $OpenBSD: x509spki.c,v 1.16 2023/02/16 08:38:17 tb Exp $ */ /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project 1999. */ @@ -70,7 +70,7 @@ NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI *x, EVP_PKEY *pkey) return (0); return (X509_PUBKEY_set(&(x->spkac->pubkey), pkey)); } -LCRYPTO_ALIAS(NETSCAPE_SPKI_set_pubkey) +LCRYPTO_ALIAS(NETSCAPE_SPKI_set_pubkey); EVP_PKEY * NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI *x) @@ -79,7 +79,7 @@ NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI *x) return (NULL); return (X509_PUBKEY_get(x->spkac->pubkey)); } -LCRYPTO_ALIAS(NETSCAPE_SPKI_get_pubkey) +LCRYPTO_ALIAS(NETSCAPE_SPKI_get_pubkey); /* Load a Netscape SPKI from a base64 encoded string */ @@ -108,7 +108,7 @@ NETSCAPE_SPKI_b64_decode(const char *str, int len) free(spki_der); return spki; } -LCRYPTO_ALIAS(NETSCAPE_SPKI_b64_decode) +LCRYPTO_ALIAS(NETSCAPE_SPKI_b64_decode); /* Generate a base64 encoded string from an SPKI */ @@ -133,4 +133,4 @@ NETSCAPE_SPKI_b64_encode(NETSCAPE_SPKI *spki) free(der_spki); return b64_str; } -LCRYPTO_ALIAS(NETSCAPE_SPKI_b64_encode) +LCRYPTO_ALIAS(NETSCAPE_SPKI_b64_encode); diff --git a/lib/libcrypto/x509/x509type.c b/lib/libcrypto/x509/x509type.c index 7e10fb540d8..ebc02c59297 100644 --- a/lib/libcrypto/x509/x509type.c +++ b/lib/libcrypto/x509/x509type.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x509type.c,v 1.17 2022/11/26 16:08:55 tb Exp $ */ +/* $OpenBSD: x509type.c,v 1.18 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -124,4 +124,4 @@ X509_certificate_type(const X509 *x, const EVP_PKEY *pkey) ret |= EVP_PKT_EXP; return (ret); } -LCRYPTO_ALIAS(X509_certificate_type) +LCRYPTO_ALIAS(X509_certificate_type); diff --git a/lib/libcrypto/x509/x_all.c b/lib/libcrypto/x509/x_all.c index 819162dc31d..cd6da9f409e 100644 --- a/lib/libcrypto/x509/x_all.c +++ b/lib/libcrypto/x509/x_all.c @@ -1,4 +1,4 @@ -/* $OpenBSD: x_all.c,v 1.29 2022/11/26 16:08:55 tb Exp $ */ +/* $OpenBSD: x_all.c,v 1.30 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -80,84 +80,84 @@ d2i_X509_bio(BIO *bp, X509 **x509) { return ASN1_item_d2i_bio(&X509_it, bp, x509); } -LCRYPTO_ALIAS(d2i_X509_bio) +LCRYPTO_ALIAS(d2i_X509_bio); int i2d_X509_bio(BIO *bp, X509 *x509) { return ASN1_item_i2d_bio(&X509_it, bp, x509); } -LCRYPTO_ALIAS(i2d_X509_bio) +LCRYPTO_ALIAS(i2d_X509_bio); X509 * d2i_X509_fp(FILE *fp, X509 **x509) { return ASN1_item_d2i_fp(&X509_it, fp, x509); } -LCRYPTO_ALIAS(d2i_X509_fp) +LCRYPTO_ALIAS(d2i_X509_fp); int i2d_X509_fp(FILE *fp, X509 *x509) { return ASN1_item_i2d_fp(&X509_it, fp, x509); } -LCRYPTO_ALIAS(i2d_X509_fp) +LCRYPTO_ALIAS(i2d_X509_fp); X509_CRL * d2i_X509_CRL_bio(BIO *bp, X509_CRL **crl) { return ASN1_item_d2i_bio(&X509_CRL_it, bp, crl); } -LCRYPTO_ALIAS(d2i_X509_CRL_bio) +LCRYPTO_ALIAS(d2i_X509_CRL_bio); int i2d_X509_CRL_bio(BIO *bp, X509_CRL *crl) { return ASN1_item_i2d_bio(&X509_CRL_it, bp, crl); } -LCRYPTO_ALIAS(i2d_X509_CRL_bio) +LCRYPTO_ALIAS(i2d_X509_CRL_bio); X509_CRL * d2i_X509_CRL_fp(FILE *fp, X509_CRL **crl) { return ASN1_item_d2i_fp(&X509_CRL_it, fp, crl); } -LCRYPTO_ALIAS(d2i_X509_CRL_fp) +LCRYPTO_ALIAS(d2i_X509_CRL_fp); int i2d_X509_CRL_fp(FILE *fp, X509_CRL *crl) { return ASN1_item_i2d_fp(&X509_CRL_it, fp, crl); } -LCRYPTO_ALIAS(i2d_X509_CRL_fp) +LCRYPTO_ALIAS(i2d_X509_CRL_fp); X509_REQ * d2i_X509_REQ_bio(BIO *bp, X509_REQ **req) { return ASN1_item_d2i_bio(&X509_REQ_it, bp, req); } -LCRYPTO_ALIAS(d2i_X509_REQ_bio) +LCRYPTO_ALIAS(d2i_X509_REQ_bio); int i2d_X509_REQ_bio(BIO *bp, X509_REQ *req) { return ASN1_item_i2d_bio(&X509_REQ_it, bp, req); } -LCRYPTO_ALIAS(i2d_X509_REQ_bio) +LCRYPTO_ALIAS(i2d_X509_REQ_bio); X509_REQ * d2i_X509_REQ_fp(FILE *fp, X509_REQ **req) { return ASN1_item_d2i_fp(&X509_REQ_it, fp, req); } -LCRYPTO_ALIAS(d2i_X509_REQ_fp) +LCRYPTO_ALIAS(d2i_X509_REQ_fp); int i2d_X509_REQ_fp(FILE *fp, X509_REQ *req) { return ASN1_item_i2d_fp(&X509_REQ_it, fp, req); } -LCRYPTO_ALIAS(i2d_X509_REQ_fp) +LCRYPTO_ALIAS(i2d_X509_REQ_fp); #ifndef OPENSSL_NO_RSA RSA * @@ -165,56 +165,56 @@ d2i_RSAPrivateKey_bio(BIO *bp, RSA **rsa) { return ASN1_item_d2i_bio(&RSAPrivateKey_it, bp, rsa); } -LCRYPTO_ALIAS(d2i_RSAPrivateKey_bio) +LCRYPTO_ALIAS(d2i_RSAPrivateKey_bio); int i2d_RSAPrivateKey_bio(BIO *bp, RSA *rsa) { return ASN1_item_i2d_bio(&RSAPrivateKey_it, bp, rsa); } -LCRYPTO_ALIAS(i2d_RSAPrivateKey_bio) +LCRYPTO_ALIAS(i2d_RSAPrivateKey_bio); RSA * d2i_RSAPrivateKey_fp(FILE *fp, RSA **rsa) { return ASN1_item_d2i_fp(&RSAPrivateKey_it, fp, rsa); } -LCRYPTO_ALIAS(d2i_RSAPrivateKey_fp) +LCRYPTO_ALIAS(d2i_RSAPrivateKey_fp); int i2d_RSAPrivateKey_fp(FILE *fp, RSA *rsa) { return ASN1_item_i2d_fp(&RSAPrivateKey_it, fp, rsa); } -LCRYPTO_ALIAS(i2d_RSAPrivateKey_fp) +LCRYPTO_ALIAS(i2d_RSAPrivateKey_fp); RSA * d2i_RSAPublicKey_bio(BIO *bp, RSA **rsa) { return ASN1_item_d2i_bio(&RSAPublicKey_it, bp, rsa); } -LCRYPTO_ALIAS(d2i_RSAPublicKey_bio) +LCRYPTO_ALIAS(d2i_RSAPublicKey_bio); int i2d_RSAPublicKey_bio(BIO *bp, RSA *rsa) { return ASN1_item_i2d_bio(&RSAPublicKey_it, bp, rsa); } -LCRYPTO_ALIAS(i2d_RSAPublicKey_bio) +LCRYPTO_ALIAS(i2d_RSAPublicKey_bio); RSA * d2i_RSAPublicKey_fp(FILE *fp, RSA **rsa) { return ASN1_item_d2i_fp(&RSAPublicKey_it, fp, rsa); } -LCRYPTO_ALIAS(d2i_RSAPublicKey_fp) +LCRYPTO_ALIAS(d2i_RSAPublicKey_fp); int i2d_RSAPublicKey_fp(FILE *fp, RSA *rsa) { return ASN1_item_i2d_fp(&RSAPublicKey_it, fp, rsa); } -LCRYPTO_ALIAS(i2d_RSAPublicKey_fp) +LCRYPTO_ALIAS(i2d_RSAPublicKey_fp); #endif #ifndef OPENSSL_NO_DSA @@ -223,28 +223,28 @@ d2i_DSAPrivateKey_bio(BIO *bp, DSA **dsa) { return ASN1_item_d2i_bio(&DSAPrivateKey_it, bp, dsa); } -LCRYPTO_ALIAS(d2i_DSAPrivateKey_bio) +LCRYPTO_ALIAS(d2i_DSAPrivateKey_bio); int i2d_DSAPrivateKey_bio(BIO *bp, DSA *dsa) { return ASN1_item_i2d_bio(&DSAPrivateKey_it, bp, dsa); } -LCRYPTO_ALIAS(i2d_DSAPrivateKey_bio) +LCRYPTO_ALIAS(i2d_DSAPrivateKey_bio); DSA * d2i_DSAPrivateKey_fp(FILE *fp, DSA **dsa) { return ASN1_item_d2i_fp(&DSAPrivateKey_it, fp, dsa); } -LCRYPTO_ALIAS(d2i_DSAPrivateKey_fp) +LCRYPTO_ALIAS(d2i_DSAPrivateKey_fp); int i2d_DSAPrivateKey_fp(FILE *fp, DSA *dsa) { return ASN1_item_i2d_fp(&DSAPrivateKey_it, fp, dsa); } -LCRYPTO_ALIAS(i2d_DSAPrivateKey_fp) +LCRYPTO_ALIAS(i2d_DSAPrivateKey_fp); #endif #ifndef OPENSSL_NO_EC @@ -253,28 +253,28 @@ d2i_ECPrivateKey_bio(BIO *bp, EC_KEY **eckey) { return ASN1_d2i_bio_of(EC_KEY, EC_KEY_new, d2i_ECPrivateKey, bp, eckey); } -LCRYPTO_ALIAS(d2i_ECPrivateKey_bio) +LCRYPTO_ALIAS(d2i_ECPrivateKey_bio); int i2d_ECPrivateKey_bio(BIO *bp, EC_KEY *eckey) { return ASN1_i2d_bio_of(EC_KEY, i2d_ECPrivateKey, bp, eckey); } -LCRYPTO_ALIAS(i2d_ECPrivateKey_bio) +LCRYPTO_ALIAS(i2d_ECPrivateKey_bio); EC_KEY * d2i_ECPrivateKey_fp(FILE *fp, EC_KEY **eckey) { return ASN1_d2i_fp_of(EC_KEY, EC_KEY_new, d2i_ECPrivateKey, fp, eckey); } -LCRYPTO_ALIAS(d2i_ECPrivateKey_fp) +LCRYPTO_ALIAS(d2i_ECPrivateKey_fp); int i2d_ECPrivateKey_fp(FILE *fp, EC_KEY *eckey) { return ASN1_i2d_fp_of(EC_KEY, i2d_ECPrivateKey, fp, eckey); } -LCRYPTO_ALIAS(i2d_ECPrivateKey_fp) +LCRYPTO_ALIAS(i2d_ECPrivateKey_fp); #endif X509_SIG * @@ -282,28 +282,28 @@ d2i_PKCS8_bio(BIO *bp, X509_SIG **p8) { return ASN1_item_d2i_bio(&X509_SIG_it, bp, p8); } -LCRYPTO_ALIAS(d2i_PKCS8_bio) +LCRYPTO_ALIAS(d2i_PKCS8_bio); int i2d_PKCS8_bio(BIO *bp, X509_SIG *p8) { return ASN1_item_i2d_bio(&X509_SIG_it, bp, p8); } -LCRYPTO_ALIAS(i2d_PKCS8_bio) +LCRYPTO_ALIAS(i2d_PKCS8_bio); X509_SIG * d2i_PKCS8_fp(FILE *fp, X509_SIG **p8) { return ASN1_item_d2i_fp(&X509_SIG_it, fp, p8); } -LCRYPTO_ALIAS(d2i_PKCS8_fp) +LCRYPTO_ALIAS(d2i_PKCS8_fp); int i2d_PKCS8_fp(FILE *fp, X509_SIG *p8) { return ASN1_item_i2d_fp(&X509_SIG_it, fp, p8); } -LCRYPTO_ALIAS(i2d_PKCS8_fp) +LCRYPTO_ALIAS(i2d_PKCS8_fp); PKCS8_PRIV_KEY_INFO * d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO **p8inf) @@ -311,7 +311,7 @@ d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO **p8inf) return ASN1_item_d2i_bio(&PKCS8_PRIV_KEY_INFO_it, bp, p8inf); } -LCRYPTO_ALIAS(d2i_PKCS8_PRIV_KEY_INFO_bio) +LCRYPTO_ALIAS(d2i_PKCS8_PRIV_KEY_INFO_bio); int i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO *p8inf) @@ -319,7 +319,7 @@ i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO *p8inf) return ASN1_item_i2d_bio(&PKCS8_PRIV_KEY_INFO_it, bp, p8inf); } -LCRYPTO_ALIAS(i2d_PKCS8_PRIV_KEY_INFO_bio) +LCRYPTO_ALIAS(i2d_PKCS8_PRIV_KEY_INFO_bio); PKCS8_PRIV_KEY_INFO * d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO **p8inf) @@ -327,7 +327,7 @@ d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO **p8inf) return ASN1_item_d2i_fp(&PKCS8_PRIV_KEY_INFO_it, fp, p8inf); } -LCRYPTO_ALIAS(d2i_PKCS8_PRIV_KEY_INFO_fp) +LCRYPTO_ALIAS(d2i_PKCS8_PRIV_KEY_INFO_fp); int i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO *p8inf) @@ -335,7 +335,7 @@ i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO *p8inf) return ASN1_item_i2d_fp(&PKCS8_PRIV_KEY_INFO_it, fp, p8inf); } -LCRYPTO_ALIAS(i2d_PKCS8_PRIV_KEY_INFO_fp) +LCRYPTO_ALIAS(i2d_PKCS8_PRIV_KEY_INFO_fp); EVP_PKEY * d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a) @@ -343,14 +343,14 @@ d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a) return ASN1_d2i_bio_of(EVP_PKEY, EVP_PKEY_new, d2i_AutoPrivateKey, bp, a); } -LCRYPTO_ALIAS(d2i_PrivateKey_bio) +LCRYPTO_ALIAS(d2i_PrivateKey_bio); int i2d_PrivateKey_bio(BIO *bp, EVP_PKEY *pkey) { return ASN1_i2d_bio_of(EVP_PKEY, i2d_PrivateKey, bp, pkey); } -LCRYPTO_ALIAS(i2d_PrivateKey_bio) +LCRYPTO_ALIAS(i2d_PrivateKey_bio); EVP_PKEY * d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a) @@ -358,14 +358,14 @@ d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a) return ASN1_d2i_fp_of(EVP_PKEY, EVP_PKEY_new, d2i_AutoPrivateKey, fp, a); } -LCRYPTO_ALIAS(d2i_PrivateKey_fp) +LCRYPTO_ALIAS(d2i_PrivateKey_fp); int i2d_PrivateKey_fp(FILE *fp, EVP_PKEY *pkey) { return ASN1_i2d_fp_of(EVP_PKEY, i2d_PrivateKey, fp, pkey); } -LCRYPTO_ALIAS(i2d_PrivateKey_fp) +LCRYPTO_ALIAS(i2d_PrivateKey_fp); int i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, EVP_PKEY *key) @@ -380,7 +380,7 @@ i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, EVP_PKEY *key) PKCS8_PRIV_KEY_INFO_free(p8inf); return ret; } -LCRYPTO_ALIAS(i2d_PKCS8PrivateKeyInfo_bio) +LCRYPTO_ALIAS(i2d_PKCS8PrivateKeyInfo_bio); int i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, EVP_PKEY *key) @@ -394,7 +394,7 @@ i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, EVP_PKEY *key) PKCS8_PRIV_KEY_INFO_free(p8inf); return ret; } -LCRYPTO_ALIAS(i2d_PKCS8PrivateKeyInfo_fp) +LCRYPTO_ALIAS(i2d_PKCS8PrivateKeyInfo_fp); int X509_verify(X509 *a, EVP_PKEY *r) @@ -404,7 +404,7 @@ X509_verify(X509 *a, EVP_PKEY *r) return (ASN1_item_verify(&X509_CINF_it, a->sig_alg, a->signature, a->cert_info, r)); } -LCRYPTO_ALIAS(X509_verify) +LCRYPTO_ALIAS(X509_verify); int X509_REQ_verify(X509_REQ *a, EVP_PKEY *r) @@ -412,7 +412,7 @@ X509_REQ_verify(X509_REQ *a, EVP_PKEY *r) return (ASN1_item_verify(&X509_REQ_INFO_it, a->sig_alg, a->signature, a->req_info, r)); } -LCRYPTO_ALIAS(X509_REQ_verify) +LCRYPTO_ALIAS(X509_REQ_verify); int NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r) @@ -420,7 +420,7 @@ NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r) return (ASN1_item_verify(&NETSCAPE_SPKAC_it, a->sig_algor, a->signature, a->spkac, r)); } -LCRYPTO_ALIAS(NETSCAPE_SPKI_verify) +LCRYPTO_ALIAS(NETSCAPE_SPKI_verify); int X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md) @@ -430,7 +430,7 @@ X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md) x->cert_info->signature, x->sig_alg, x->signature, x->cert_info, pkey, md)); } -LCRYPTO_ALIAS(X509_sign) +LCRYPTO_ALIAS(X509_sign); int X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx) @@ -440,7 +440,7 @@ X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx) x->cert_info->signature, x->sig_alg, x->signature, x->cert_info, ctx); } -LCRYPTO_ALIAS(X509_sign_ctx) +LCRYPTO_ALIAS(X509_sign_ctx); int X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md) @@ -448,7 +448,7 @@ X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md) return (ASN1_item_sign(&X509_REQ_INFO_it, x->sig_alg, NULL, x->signature, x->req_info, pkey, md)); } -LCRYPTO_ALIAS(X509_REQ_sign) +LCRYPTO_ALIAS(X509_REQ_sign); int X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx) @@ -456,7 +456,7 @@ X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx) return ASN1_item_sign_ctx(&X509_REQ_INFO_it, x->sig_alg, NULL, x->signature, x->req_info, ctx); } -LCRYPTO_ALIAS(X509_REQ_sign_ctx) +LCRYPTO_ALIAS(X509_REQ_sign_ctx); int X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md) @@ -465,7 +465,7 @@ X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md) return(ASN1_item_sign(&X509_CRL_INFO_it, x->crl->sig_alg, x->sig_alg, x->signature, x->crl, pkey, md)); } -LCRYPTO_ALIAS(X509_CRL_sign) +LCRYPTO_ALIAS(X509_CRL_sign); int X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx) @@ -474,7 +474,7 @@ X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx) return ASN1_item_sign_ctx(&X509_CRL_INFO_it, x->crl->sig_alg, x->sig_alg, x->signature, x->crl, ctx); } -LCRYPTO_ALIAS(X509_CRL_sign_ctx) +LCRYPTO_ALIAS(X509_CRL_sign_ctx); int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md) @@ -482,7 +482,7 @@ NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md) return (ASN1_item_sign(&NETSCAPE_SPKAC_it, x->sig_algor, NULL, x->signature, x->spkac, pkey, md)); } -LCRYPTO_ALIAS(NETSCAPE_SPKI_sign) +LCRYPTO_ALIAS(NETSCAPE_SPKI_sign); int X509_pubkey_digest(const X509 *data, const EVP_MD *type, unsigned char *md, @@ -494,7 +494,7 @@ X509_pubkey_digest(const X509 *data, const EVP_MD *type, unsigned char *md, return 0; return EVP_Digest(key->data, key->length, md, len, type, NULL); } -LCRYPTO_ALIAS(X509_pubkey_digest) +LCRYPTO_ALIAS(X509_pubkey_digest); int X509_digest(const X509 *data, const EVP_MD *type, unsigned char *md, @@ -503,7 +503,7 @@ X509_digest(const X509 *data, const EVP_MD *type, unsigned char *md, return (ASN1_item_digest(&X509_it, type, (char *)data, md, len)); } -LCRYPTO_ALIAS(X509_digest) +LCRYPTO_ALIAS(X509_digest); int X509_CRL_digest(const X509_CRL *data, const EVP_MD *type, unsigned char *md, @@ -512,7 +512,7 @@ X509_CRL_digest(const X509_CRL *data, const EVP_MD *type, unsigned char *md, return (ASN1_item_digest(&X509_CRL_it, type, (char *)data, md, len)); } -LCRYPTO_ALIAS(X509_CRL_digest) +LCRYPTO_ALIAS(X509_CRL_digest); int X509_REQ_digest(const X509_REQ *data, const EVP_MD *type, unsigned char *md, @@ -521,7 +521,7 @@ X509_REQ_digest(const X509_REQ *data, const EVP_MD *type, unsigned char *md, return (ASN1_item_digest(&X509_REQ_it, type, (char *)data, md, len)); } -LCRYPTO_ALIAS(X509_REQ_digest) +LCRYPTO_ALIAS(X509_REQ_digest); int X509_NAME_digest(const X509_NAME *data, const EVP_MD *type, unsigned char *md, @@ -530,7 +530,7 @@ X509_NAME_digest(const X509_NAME *data, const EVP_MD *type, unsigned char *md, return (ASN1_item_digest(&X509_NAME_it, type, (char *)data, md, len)); } -LCRYPTO_ALIAS(X509_NAME_digest) +LCRYPTO_ALIAS(X509_NAME_digest); int X509_up_ref(X509 *x) @@ -538,4 +538,4 @@ X509_up_ref(X509 *x) int i = CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509); return i > 1 ? 1 : 0; } -LCRYPTO_ALIAS(X509_up_ref) +LCRYPTO_ALIAS(X509_up_ref); diff --git a/lib/libssl/bio_ssl.c b/lib/libssl/bio_ssl.c index 98a730d1106..1a8cda84d65 100644 --- a/lib/libssl/bio_ssl.c +++ b/lib/libssl/bio_ssl.c @@ -1,4 +1,4 @@ -/* $OpenBSD: bio_ssl.c,v 1.37 2022/11/26 16:08:55 tb Exp $ */ +/* $OpenBSD: bio_ssl.c,v 1.38 2023/02/16 08:38:17 tb Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -103,7 +103,7 @@ BIO_f_ssl(void) { return (&methods_sslp); } -LSSL_ALIAS(BIO_f_ssl) +LSSL_ALIAS(BIO_f_ssl); static int ssl_new(BIO *bi) @@ -533,7 +533,7 @@ BIO_new_ssl_connect(SSL_CTX *ctx) BIO_free(ssl); return (NULL); } -LSSL_ALIAS(BIO_new_ssl_connect) +LSSL_ALIAS(BIO_new_ssl_connect); BIO * BIO_new_ssl(SSL_CTX *ctx, int client) @@ -558,7 +558,7 @@ BIO_new_ssl(SSL_CTX *ctx, int client) BIO_free(ret); return (NULL); } -LSSL_ALIAS(BIO_new_ssl) +LSSL_ALIAS(BIO_new_ssl); int BIO_ssl_copy_session_id(BIO *t, BIO *f) diff --git a/lib/libssl/hidden/ssl_namespace.h b/lib/libssl/hidden/ssl_namespace.h index 803f3e66bed..7a941a0e109 100644 --- a/lib/libssl/hidden/ssl_namespace.h +++ b/lib/libssl/hidden/ssl_namespace.h @@ -1,4 +1,4 @@ -/* $OpenBSD: ssl_namespace.h,v 1.1 2022/11/11 11:25:18 beck Exp $ */ +/* $OpenBSD: ssl_namespace.h,v 1.2 2023/02/16 08:38:17 tb Exp $ */ /* * Copyright (c) 2016 Philip Guenther * @@ -27,11 +27,11 @@ #define LSSL_UNUSED(x) typeof(x) x __attribute__((deprecated)) #define LSSL_USED(x) __attribute__((visibility("hidden"))) \ typeof(x) x asm("_lssl_"#x) -#define LSSL_ALIAS(x) asm(".global "#x"; "#x" = _lssl_"#x); +#define LSSL_ALIAS(x) asm(".global "#x"; "#x" = _lssl_"#x) #else #define LSSL_UNUSED(x) #define LSSL_USED(x) -#define LSSL_ALIAS(x) +#define LSSL_ALIAS(x) asm("") #endif #endif /* _LIBSSL_SSL_NAMESPACE_H_ */ -- 2.20.1