_libre_EVP_AEAD_CTX_seal
_libre_EVP_AEAD_CTX_open
_libre_ERR_load_EVP_strings
+_libre_X509_CRL_get_signature_nid
+_libre_X509_CRL_get0_extensions
+_libre_X509_CRL_get_version
+_libre_X509_CRL_get0_lastUpdate
+_libre_X509_CRL_get0_nextUpdate
+_libre_X509_CRL_get_lastUpdate
+_libre_X509_CRL_get_nextUpdate
+_libre_X509_CRL_get_issuer
+_libre_X509_CRL_get_REVOKED
+_libre_X509_CRL_get0_signature
+_libre_X509_CRL_get0_tbs_sigalg
+_libre_X509_REQ_get_signature_nid
+_libre_X509_REQ_get0_signature
+_libre_X509_CRL_verify
+_libre_NETSCAPE_SPKI_print
+_libre_X509_signature_dump
+_libre_X509_signature_print
+_libre_d2i_RSA_PUBKEY_fp
+_libre_i2d_RSA_PUBKEY_fp
+_libre_d2i_DSA_PUBKEY_fp
+_libre_i2d_DSA_PUBKEY_fp
+_libre_d2i_EC_PUBKEY_fp
+_libre_i2d_EC_PUBKEY_fp
+_libre_i2d_PUBKEY_fp
+_libre_d2i_PUBKEY_fp
+_libre_d2i_RSA_PUBKEY_bio
+_libre_i2d_RSA_PUBKEY_bio
+_libre_d2i_DSA_PUBKEY_bio
+_libre_i2d_DSA_PUBKEY_bio
+_libre_d2i_EC_PUBKEY_bio
+_libre_i2d_EC_PUBKEY_bio
+_libre_i2d_PUBKEY_bio
+_libre_d2i_PUBKEY_bio
+_libre_X509_dup
+_libre_X509_ATTRIBUTE_dup
+_libre_X509_EXTENSION_dup
+_libre_X509_CRL_dup
+_libre_X509_REQ_dup
+_libre_X509_ALGOR_dup
+_libre_X509_ALGOR_set0
+_libre_X509_ALGOR_get0
+_libre_X509_ALGOR_cmp
+_libre_X509_NAME_dup
+_libre_X509_NAME_get0_der
+_libre_X509_NAME_ENTRY_dup
+_libre_X509_ALGOR_new
+_libre_X509_ALGOR_free
+_libre_d2i_X509_ALGOR
+_libre_i2d_X509_ALGOR
+_libre_d2i_X509_ALGORS
+_libre_i2d_X509_ALGORS
+_libre_X509_VAL_new
+_libre_X509_VAL_free
+_libre_d2i_X509_VAL
+_libre_i2d_X509_VAL
+_libre_X509_PUBKEY_new
+_libre_X509_PUBKEY_free
+_libre_d2i_X509_PUBKEY
+_libre_i2d_X509_PUBKEY
+_libre_X509_PUBKEY_set
+_libre_X509_PUBKEY_get
+_libre_X509_PUBKEY_get0
+_libre_i2d_PUBKEY
+_libre_d2i_PUBKEY
+_libre_i2d_RSA_PUBKEY
+_libre_d2i_RSA_PUBKEY
+_libre_i2d_DSA_PUBKEY
+_libre_d2i_DSA_PUBKEY
+_libre_i2d_EC_PUBKEY
+_libre_d2i_EC_PUBKEY
+_libre_X509_SIG_new
+_libre_X509_SIG_free
+_libre_d2i_X509_SIG
+_libre_i2d_X509_SIG
+_libre_X509_SIG_get0
+_libre_X509_SIG_getm
+_libre_X509_REQ_INFO_new
+_libre_X509_REQ_INFO_free
+_libre_d2i_X509_REQ_INFO
+_libre_i2d_X509_REQ_INFO
+_libre_X509_REQ_new
+_libre_X509_REQ_free
+_libre_d2i_X509_REQ
+_libre_i2d_X509_REQ
+_libre_X509_ATTRIBUTE_new
+_libre_X509_ATTRIBUTE_free
+_libre_d2i_X509_ATTRIBUTE
+_libre_i2d_X509_ATTRIBUTE
+_libre_X509_ATTRIBUTE_create
+_libre_X509_EXTENSION_new
+_libre_X509_EXTENSION_free
+_libre_d2i_X509_EXTENSION
+_libre_i2d_X509_EXTENSION
+_libre_d2i_X509_EXTENSIONS
+_libre_i2d_X509_EXTENSIONS
+_libre_X509_NAME_ENTRY_new
+_libre_X509_NAME_ENTRY_free
+_libre_d2i_X509_NAME_ENTRY
+_libre_i2d_X509_NAME_ENTRY
+_libre_X509_NAME_new
+_libre_X509_NAME_free
+_libre_d2i_X509_NAME
+_libre_i2d_X509_NAME
+_libre_X509_NAME_set
+_libre_X509_CINF_new
+_libre_X509_CINF_free
+_libre_d2i_X509_CINF
+_libre_i2d_X509_CINF
+_libre_X509_new
+_libre_X509_free
+_libre_d2i_X509
+_libre_i2d_X509
+_libre_X509_get_ex_new_index
+_libre_X509_set_ex_data
+_libre_X509_get_ex_data
+_libre_i2d_X509_AUX
+_libre_d2i_X509_AUX
+_libre_i2d_re_X509_tbs
+_libre_X509_get0_signature
+_libre_X509_get_signature_nid
+_libre_X509_alias_set1
+_libre_X509_keyid_set1
+_libre_X509_alias_get0
+_libre_X509_keyid_get0
+_libre_X509_add1_trust_object
+_libre_X509_add1_reject_object
+_libre_X509_trust_clear
+_libre_X509_reject_clear
+_libre_X509_REVOKED_new
+_libre_X509_REVOKED_free
+_libre_X509_REVOKED_dup
+_libre_d2i_X509_REVOKED
+_libre_i2d_X509_REVOKED
+_libre_X509_CRL_INFO_new
+_libre_X509_CRL_INFO_free
+_libre_d2i_X509_CRL_INFO
+_libre_i2d_X509_CRL_INFO
+_libre_X509_CRL_new
+_libre_X509_CRL_free
+_libre_d2i_X509_CRL
+_libre_i2d_X509_CRL
+_libre_X509_CRL_add0_revoked
+_libre_X509_CRL_get0_by_serial
+_libre_X509_CRL_get0_by_cert
+_libre_X509_PKEY_new
+_libre_X509_PKEY_free
+_libre_NETSCAPE_SPKI_new
+_libre_NETSCAPE_SPKI_free
+_libre_d2i_NETSCAPE_SPKI
+_libre_i2d_NETSCAPE_SPKI
+_libre_NETSCAPE_SPKAC_new
+_libre_NETSCAPE_SPKAC_free
+_libre_d2i_NETSCAPE_SPKAC
+_libre_i2d_NETSCAPE_SPKAC
+_libre_X509_INFO_new
+_libre_X509_INFO_free
+_libre_ASN1_item_digest
+_libre_ASN1_item_verify
+_libre_ASN1_item_sign
+_libre_ASN1_item_sign_ctx
+_libre_X509_print_ex_fp
+_libre_X509_print_fp
+_libre_X509_CRL_print_fp
+_libre_X509_REQ_print_fp
+_libre_X509_NAME_print_ex_fp
+_libre_X509_NAME_print
+_libre_X509_NAME_print_ex
+_libre_X509_print_ex
+_libre_X509_print
+_libre_X509_ocspid_print
+_libre_X509_CRL_print
+_libre_X509_REQ_print_ex
+_libre_X509_REQ_print
+_libre_EVP_PKEY_get_attr_count
+_libre_EVP_PKEY_get_attr_by_NID
+_libre_EVP_PKEY_get_attr_by_OBJ
+_libre_EVP_PKEY_get_attr
+_libre_EVP_PKEY_delete_attr
+_libre_EVP_PKEY_add1_attr
+_libre_EVP_PKEY_add1_attr_by_OBJ
+_libre_EVP_PKEY_add1_attr_by_NID
+_libre_EVP_PKEY_add1_attr_by_txt
+_libre_PKCS8_PRIV_KEY_INFO_new
+_libre_PKCS8_PRIV_KEY_INFO_free
+_libre_d2i_PKCS8_PRIV_KEY_INFO
+_libre_i2d_PKCS8_PRIV_KEY_INFO
+_libre_EVP_PKCS82PKEY
+_libre_EVP_PKEY2PKCS8
+_libre_PKCS8_pkey_set0
+_libre_PKCS8_pkey_get0
+_libre_PKCS8_pkey_get0_attrs
+_libre_PKCS8_pkey_add1_attr_by_NID
+_libre_X509_PUBKEY_set0_param
+_libre_X509_PUBKEY_get0_param
-/* $OpenBSD: a_strex.c,v 1.34 2023/07/07 19:37:52 beck Exp $ */
+/* $OpenBSD: a_strex.c,v 1.35 2024/04/09 13:55:02 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2000.
*/
return X509_NAME_print(out, nm, indent);
return do_name_ex(send_bio_chars, out, nm, indent, flags);
}
+LCRYPTO_ALIAS(X509_NAME_print_ex);
int
X509_NAME_print_ex_fp(FILE *fp, const X509_NAME *nm, int indent,
}
return do_name_ex(send_fp_chars, fp, nm, indent, flags);
}
+LCRYPTO_ALIAS(X509_NAME_print_ex_fp);
int
ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str, unsigned long flags)
-/* $OpenBSD: asn1_item.c,v 1.20 2024/01/28 14:43:48 joshua Exp $ */
+/* $OpenBSD: asn1_item.c,v 1.21 2024/04/09 13:55:02 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
free(str);
return (1);
}
+LCRYPTO_ALIAS(ASN1_item_digest);
/*
* ASN1_ITEM version of ASN1_dup(): follows the same model except there's no
return ret;
}
+LCRYPTO_ALIAS(ASN1_item_sign);
static int
asn1_item_set_algorithm_identifiers(EVP_MD_CTX *ctx, X509_ALGOR *algor1,
return ret;
}
+LCRYPTO_ALIAS(ASN1_item_sign_ctx);
int
ASN1_item_verify(const ASN1_ITEM *it, X509_ALGOR *a,
return ret;
}
+LCRYPTO_ALIAS(ASN1_item_verify);
#define HEADER_SIZE 8
#define ASN1_CHUNK_INITIAL_SIZE (16 * 1024)
-/* $OpenBSD: p8_pkey.c,v 1.23 2023/07/07 19:37:52 beck Exp $ */
+/* $OpenBSD: p8_pkey.c,v 1.24 2024/04/09 13:55:02 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
return (PKCS8_PRIV_KEY_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PKCS8_PRIV_KEY_INFO_it);
}
+LCRYPTO_ALIAS(d2i_PKCS8_PRIV_KEY_INFO);
int
i2d_PKCS8_PRIV_KEY_INFO(PKCS8_PRIV_KEY_INFO *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS8_PRIV_KEY_INFO_it);
}
+LCRYPTO_ALIAS(i2d_PKCS8_PRIV_KEY_INFO);
PKCS8_PRIV_KEY_INFO *
PKCS8_PRIV_KEY_INFO_new(void)
{
return (PKCS8_PRIV_KEY_INFO *)ASN1_item_new(&PKCS8_PRIV_KEY_INFO_it);
}
+LCRYPTO_ALIAS(PKCS8_PRIV_KEY_INFO_new);
void
PKCS8_PRIV_KEY_INFO_free(PKCS8_PRIV_KEY_INFO *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PKCS8_PRIV_KEY_INFO_it);
}
+LCRYPTO_ALIAS(PKCS8_PRIV_KEY_INFO_free);
int
PKCS8_pkey_set0(PKCS8_PRIV_KEY_INFO *priv, ASN1_OBJECT *aobj, int version,
ASN1_STRING_set0(priv->pkey, penc, penclen);
return 1;
}
+LCRYPTO_ALIAS(PKCS8_pkey_set0);
int
PKCS8_pkey_get0(const ASN1_OBJECT **ppkalg, const unsigned char **pk,
*pa = p8->pkeyalg;
return 1;
}
+LCRYPTO_ALIAS(PKCS8_pkey_get0);
const STACK_OF(X509_ATTRIBUTE) *
PKCS8_pkey_get0_attrs(const PKCS8_PRIV_KEY_INFO *p8)
{
return p8->attributes;
}
+LCRYPTO_ALIAS(PKCS8_pkey_get0_attrs);
int
PKCS8_pkey_add1_attr_by_NID(PKCS8_PRIV_KEY_INFO *p8, int nid, int type,
return 1;
return 0;
}
+LCRYPTO_ALIAS(PKCS8_pkey_add1_attr_by_NID);
-/* $OpenBSD: t_crl.c,v 1.23 2023/07/07 19:37:52 beck Exp $ */
+/* $OpenBSD: t_crl.c,v 1.24 2024/04/09 13:55:02 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
BIO_free(b);
return (ret);
}
+LCRYPTO_ALIAS(X509_CRL_print_fp);
int
X509_CRL_print(BIO *out, X509_CRL *x)
err:
return 0;
}
+LCRYPTO_ALIAS(X509_CRL_print);
-/* $OpenBSD: t_req.c,v 1.26 2023/07/07 19:37:52 beck Exp $ */
+/* $OpenBSD: t_req.c,v 1.27 2024/04/09 13:55:02 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
BIO_free(b);
return (ret);
}
+LCRYPTO_ALIAS(X509_REQ_print_fp);
int
X509_REQ_print_ex(BIO *bp, X509_REQ *x, unsigned long nmflags,
X509error(ERR_R_BUF_LIB);
return (0);
}
+LCRYPTO_ALIAS(X509_REQ_print_ex);
int
X509_REQ_print(BIO *bp, X509_REQ *x)
{
return X509_REQ_print_ex(bp, x, XN_FLAG_COMPAT, X509_FLAG_COMPAT);
}
+LCRYPTO_ALIAS(X509_REQ_print);
-/* $OpenBSD: t_spki.c,v 1.16 2023/07/07 19:37:52 beck Exp $ */
+/* $OpenBSD: t_spki.c,v 1.17 2024/04/09 13:55:02 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
BIO_write(out, "\n", 1);
return 1;
}
+LCRYPTO_ALIAS(NETSCAPE_SPKI_print);
-/* $OpenBSD: t_x509.c,v 1.44 2023/12/29 10:59:00 tb Exp $ */
+/* $OpenBSD: t_x509.c,v 1.45 2024/04/09 13:55:02 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
{
return X509_print_ex_fp(fp, x, XN_FLAG_COMPAT, X509_FLAG_COMPAT);
}
+LCRYPTO_ALIAS(X509_print_fp);
int
X509_print_ex_fp(FILE *fp, X509 *x, unsigned long nmflag, unsigned long cflag)
BIO_free(b);
return (ret);
}
+LCRYPTO_ALIAS(X509_print_ex_fp);
int
X509_print(BIO *bp, X509 *x)
{
return X509_print_ex(bp, x, XN_FLAG_COMPAT, X509_FLAG_COMPAT);
}
+LCRYPTO_ALIAS(X509_print);
int
X509_print_ex(BIO *bp, X509 *x, unsigned long nmflags, unsigned long cflag)
free(m);
return (ret);
}
+LCRYPTO_ALIAS(X509_print_ex);
int
X509_ocspid_print(BIO *bp, X509 *x)
free(der);
return (0);
}
+LCRYPTO_ALIAS(X509_ocspid_print);
int
X509_signature_dump(BIO *bp, const ASN1_STRING *sig, int indent)
return 1;
}
+LCRYPTO_ALIAS(X509_signature_dump);
int
X509_signature_print(BIO *bp, const X509_ALGOR *sigalg, const ASN1_STRING *sig)
return 0;
return 1;
}
+LCRYPTO_ALIAS(X509_signature_print);
int
ASN1_TIME_print(BIO *bp, const ASN1_TIME *tm)
free(b);
return (ret);
}
+LCRYPTO_ALIAS(X509_NAME_print);
-/* $OpenBSD: x_algor.c,v 1.39 2024/03/02 10:33:51 tb Exp $ */
+/* $OpenBSD: x_algor.c,v 1.40 2024/04/09 13:55:02 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2000.
*/
return (X509_ALGOR *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_ALGOR_it);
}
+LCRYPTO_ALIAS(d2i_X509_ALGOR);
int
i2d_X509_ALGOR(X509_ALGOR *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_ALGOR_it);
}
+LCRYPTO_ALIAS(i2d_X509_ALGOR);
X509_ALGOR *
X509_ALGOR_new(void)
{
return (X509_ALGOR *)ASN1_item_new(&X509_ALGOR_it);
}
+LCRYPTO_ALIAS(X509_ALGOR_new);
void
X509_ALGOR_free(X509_ALGOR *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_ALGOR_it);
}
+LCRYPTO_ALIAS(X509_ALGOR_free);
X509_ALGORS *
d2i_X509_ALGORS(X509_ALGORS **a, const unsigned char **in, long len)
return (X509_ALGORS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_ALGORS_it);
}
+LCRYPTO_ALIAS(d2i_X509_ALGORS);
int
i2d_X509_ALGORS(X509_ALGORS *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_ALGORS_it);
}
+LCRYPTO_ALIAS(i2d_X509_ALGORS);
X509_ALGOR *
X509_ALGOR_dup(X509_ALGOR *x)
{
return ASN1_item_dup(&X509_ALGOR_it, x);
}
+LCRYPTO_ALIAS(X509_ALGOR_dup);
static int
X509_ALGOR_set0_obj(X509_ALGOR *alg, ASN1_OBJECT *aobj)
return 1;
}
+LCRYPTO_ALIAS(X509_ALGOR_set0);
void
X509_ALGOR_get0(const ASN1_OBJECT **out_aobj, int *out_type,
if (out_value != NULL)
*out_value = value;
}
+LCRYPTO_ALIAS(X509_ALGOR_get0);
int
X509_ALGOR_set_evp_md(X509_ALGOR *alg, const EVP_MD *md)
return ASN1_TYPE_cmp(a->parameter, b->parameter);
}
+LCRYPTO_ALIAS(X509_ALGOR_cmp);
-/* $OpenBSD: x_attrib.c,v 1.21 2023/07/28 13:30:07 jsg Exp $ */
+/* $OpenBSD: x_attrib.c,v 1.22 2024/04/09 13:55:02 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (X509_ATTRIBUTE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_ATTRIBUTE_it);
}
+LCRYPTO_ALIAS(d2i_X509_ATTRIBUTE);
int
i2d_X509_ATTRIBUTE(X509_ATTRIBUTE *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_ATTRIBUTE_it);
}
+LCRYPTO_ALIAS(i2d_X509_ATTRIBUTE);
X509_ATTRIBUTE *
X509_ATTRIBUTE_new(void)
{
return (X509_ATTRIBUTE *)ASN1_item_new(&X509_ATTRIBUTE_it);
}
+LCRYPTO_ALIAS(X509_ATTRIBUTE_new);
void
X509_ATTRIBUTE_free(X509_ATTRIBUTE *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_ATTRIBUTE_it);
}
+LCRYPTO_ALIAS(X509_ATTRIBUTE_free);
X509_ATTRIBUTE *
X509_ATTRIBUTE_dup(X509_ATTRIBUTE *x)
{
return ASN1_item_dup(&X509_ATTRIBUTE_it, x);
}
+LCRYPTO_ALIAS(X509_ATTRIBUTE_dup);
X509_ATTRIBUTE *
X509_ATTRIBUTE_create(int nid, int atrtype, void *value)
ASN1_TYPE_free(val);
return (NULL);
}
+LCRYPTO_ALIAS(X509_ATTRIBUTE_create);
-/* $OpenBSD: x_crl.c,v 1.43 2024/03/02 10:59:41 tb Exp $ */
+/* $OpenBSD: x_crl.c,v 1.44 2024/04/09 13:55:02 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (X509_REVOKED *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_REVOKED_it);
}
+LCRYPTO_ALIAS(d2i_X509_REVOKED);
int
i2d_X509_REVOKED(X509_REVOKED *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_REVOKED_it);
}
+LCRYPTO_ALIAS(i2d_X509_REVOKED);
X509_REVOKED *
X509_REVOKED_new(void)
{
return (X509_REVOKED *)ASN1_item_new(&X509_REVOKED_it);
}
+LCRYPTO_ALIAS(X509_REVOKED_new);
void
X509_REVOKED_free(X509_REVOKED *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_REVOKED_it);
}
+LCRYPTO_ALIAS(X509_REVOKED_free);
X509_REVOKED *
X509_REVOKED_dup(X509_REVOKED *a)
{
return ASN1_item_dup(&X509_REVOKED_it, a);
}
+LCRYPTO_ALIAS(X509_REVOKED_dup);
X509_CRL_INFO *
d2i_X509_CRL_INFO(X509_CRL_INFO **a, const unsigned char **in, long len)
return (X509_CRL_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_CRL_INFO_it);
}
+LCRYPTO_ALIAS(d2i_X509_CRL_INFO);
int
i2d_X509_CRL_INFO(X509_CRL_INFO *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_CRL_INFO_it);
}
+LCRYPTO_ALIAS(i2d_X509_CRL_INFO);
X509_CRL_INFO *
X509_CRL_INFO_new(void)
{
return (X509_CRL_INFO *)ASN1_item_new(&X509_CRL_INFO_it);
}
+LCRYPTO_ALIAS(X509_CRL_INFO_new);
void
X509_CRL_INFO_free(X509_CRL_INFO *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_CRL_INFO_it);
}
+LCRYPTO_ALIAS(X509_CRL_INFO_free);
X509_CRL *
d2i_X509_CRL(X509_CRL **a, const unsigned char **in, long len)
return (X509_CRL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_CRL_it);
}
+LCRYPTO_ALIAS(d2i_X509_CRL);
int
i2d_X509_CRL(X509_CRL *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_CRL_it);
}
+LCRYPTO_ALIAS(i2d_X509_CRL);
X509_CRL *
X509_CRL_new(void)
{
return (X509_CRL *)ASN1_item_new(&X509_CRL_it);
}
+LCRYPTO_ALIAS(X509_CRL_new);
void
X509_CRL_free(X509_CRL *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_CRL_it);
}
+LCRYPTO_ALIAS(X509_CRL_free);
X509_CRL *
X509_CRL_dup(X509_CRL *x)
{
return ASN1_item_dup(&X509_CRL_it, x);
}
+LCRYPTO_ALIAS(X509_CRL_dup);
static int
X509_REVOKED_cmp(const X509_REVOKED * const *a, const X509_REVOKED * const *b)
inf->enc.modified = 1;
return 1;
}
+LCRYPTO_ALIAS(X509_CRL_add0_revoked);
int
X509_CRL_verify(X509_CRL *crl, EVP_PKEY *pkey)
return ASN1_item_verify(&X509_CRL_INFO_it, crl->sig_alg, crl->signature,
crl->crl, pkey);
}
+LCRYPTO_ALIAS(X509_CRL_verify);
static int
crl_revoked_issuer_match(X509_CRL *crl, X509_NAME *nm, X509_REVOKED *rev)
{
return crl_lookup(crl, ret, serial, NULL);
}
+LCRYPTO_ALIAS(X509_CRL_get0_by_serial);
int
X509_CRL_get0_by_cert(X509_CRL *crl, X509_REVOKED **ret, X509 *x)
return crl_lookup(crl, ret, X509_get_serialNumber(x),
X509_get_issuer_name(x));
}
+LCRYPTO_ALIAS(X509_CRL_get0_by_cert);
int
X509_CRL_get_signature_nid(const X509_CRL *crl)
{
return OBJ_obj2nid(crl->sig_alg->algorithm);
}
+LCRYPTO_ALIAS(X509_CRL_get_signature_nid);
const STACK_OF(X509_EXTENSION) *
X509_CRL_get0_extensions(const X509_CRL *crl)
{
return crl->crl->extensions;
}
+LCRYPTO_ALIAS(X509_CRL_get0_extensions);
long
X509_CRL_get_version(const X509_CRL *crl)
{
return ASN1_INTEGER_get(crl->crl->version);
}
+LCRYPTO_ALIAS(X509_CRL_get_version);
const ASN1_TIME *
X509_CRL_get0_lastUpdate(const X509_CRL *crl)
{
return crl->crl->lastUpdate;
}
+LCRYPTO_ALIAS(X509_CRL_get0_lastUpdate);
ASN1_TIME *
X509_CRL_get_lastUpdate(X509_CRL *crl)
{
return crl->crl->lastUpdate;
}
+LCRYPTO_ALIAS(X509_CRL_get_lastUpdate);
const ASN1_TIME *
X509_CRL_get0_nextUpdate(const X509_CRL *crl)
{
return crl->crl->nextUpdate;
}
+LCRYPTO_ALIAS(X509_CRL_get0_nextUpdate);
ASN1_TIME *
X509_CRL_get_nextUpdate(X509_CRL *crl)
{
return crl->crl->nextUpdate;
}
+LCRYPTO_ALIAS(X509_CRL_get_nextUpdate);
X509_NAME *
X509_CRL_get_issuer(const X509_CRL *crl)
{
return crl->crl->issuer;
}
+LCRYPTO_ALIAS(X509_CRL_get_issuer);
STACK_OF(X509_REVOKED) *
X509_CRL_get_REVOKED(X509_CRL *crl)
{
return crl->crl->revoked;
}
+LCRYPTO_ALIAS(X509_CRL_get_REVOKED);
void
X509_CRL_get0_signature(const X509_CRL *crl, const ASN1_BIT_STRING **psig,
if (palg != NULL)
*palg = crl->sig_alg;
}
+LCRYPTO_ALIAS(X509_CRL_get0_signature);
const X509_ALGOR *
X509_CRL_get0_tbs_sigalg(const X509_CRL *crl)
{
return crl->crl->sig_alg;
}
+LCRYPTO_ALIAS(X509_CRL_get0_tbs_sigalg);
-/* $OpenBSD: x_exten.c,v 1.20 2023/07/07 19:37:52 beck Exp $ */
+/* $OpenBSD: x_exten.c,v 1.21 2024/04/09 13:55:02 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2000.
*/
return (X509_EXTENSION *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_EXTENSION_it);
}
+LCRYPTO_ALIAS(d2i_X509_EXTENSION);
int
i2d_X509_EXTENSION(X509_EXTENSION *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_EXTENSION_it);
}
+LCRYPTO_ALIAS(i2d_X509_EXTENSION);
X509_EXTENSION *
X509_EXTENSION_new(void)
{
return (X509_EXTENSION *)ASN1_item_new(&X509_EXTENSION_it);
}
+LCRYPTO_ALIAS(X509_EXTENSION_new);
void
X509_EXTENSION_free(X509_EXTENSION *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_EXTENSION_it);
}
+LCRYPTO_ALIAS(X509_EXTENSION_free);
X509_EXTENSIONS *
d2i_X509_EXTENSIONS(X509_EXTENSIONS **a, const unsigned char **in, long len)
return (X509_EXTENSIONS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_EXTENSIONS_it);
}
+LCRYPTO_ALIAS(d2i_X509_EXTENSIONS);
int
i2d_X509_EXTENSIONS(X509_EXTENSIONS *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_EXTENSIONS_it);
}
+LCRYPTO_ALIAS(i2d_X509_EXTENSIONS);
X509_EXTENSION *
X509_EXTENSION_dup(X509_EXTENSION *x)
{
return ASN1_item_dup(&X509_EXTENSION_it, x);
}
+LCRYPTO_ALIAS(X509_EXTENSION_dup);
-/* $OpenBSD: x_info.c,v 1.20 2023/07/07 19:37:52 beck Exp $ */
+/* $OpenBSD: x_info.c,v 1.21 2024/04/09 13:55:02 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return ret;
}
+LCRYPTO_ALIAS(X509_INFO_new);
void
X509_INFO_free(X509_INFO *x)
free(x);
}
+LCRYPTO_ALIAS(X509_INFO_free);
-/* $OpenBSD: x_name.c,v 1.41 2023/07/24 06:56:54 tb Exp $ */
+/* $OpenBSD: x_name.c,v 1.42 2024/04/09 13:55:02 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (X509_NAME_ENTRY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_NAME_ENTRY_it);
}
+LCRYPTO_ALIAS(d2i_X509_NAME_ENTRY);
int
i2d_X509_NAME_ENTRY(X509_NAME_ENTRY *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_NAME_ENTRY_it);
}
+LCRYPTO_ALIAS(i2d_X509_NAME_ENTRY);
X509_NAME_ENTRY *
X509_NAME_ENTRY_new(void)
{
return (X509_NAME_ENTRY *)ASN1_item_new(&X509_NAME_ENTRY_it);
}
+LCRYPTO_ALIAS(X509_NAME_ENTRY_new);
void
X509_NAME_ENTRY_free(X509_NAME_ENTRY *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_NAME_ENTRY_it);
}
+LCRYPTO_ALIAS(X509_NAME_ENTRY_free);
X509_NAME_ENTRY *
X509_NAME_ENTRY_dup(X509_NAME_ENTRY *x)
{
return ASN1_item_dup(&X509_NAME_ENTRY_it, x);
}
+LCRYPTO_ALIAS(X509_NAME_ENTRY_dup);
/* For the "Name" type we need a SEQUENCE OF { SET OF X509_NAME_ENTRY }
* so declare two template wrappers for this
return (X509_NAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_NAME_it);
}
+LCRYPTO_ALIAS(d2i_X509_NAME);
int
i2d_X509_NAME(X509_NAME *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_NAME_it);
}
+LCRYPTO_ALIAS(i2d_X509_NAME);
X509_NAME *
X509_NAME_new(void)
{
return (X509_NAME *)ASN1_item_new(&X509_NAME_it);
}
+LCRYPTO_ALIAS(X509_NAME_new);
void
X509_NAME_free(X509_NAME *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_NAME_it);
}
+LCRYPTO_ALIAS(X509_NAME_free);
X509_NAME *
X509_NAME_dup(X509_NAME *x)
{
return ASN1_item_dup(&X509_NAME_it, x);
}
+LCRYPTO_ALIAS(X509_NAME_dup);
static int
x509_name_ex_new(ASN1_VALUE **val, const ASN1_ITEM *it)
*xn = name;
return 1;
}
+LCRYPTO_ALIAS(X509_NAME_set);
int
X509_NAME_get0_der(X509_NAME *nm, const unsigned char **pder, size_t *pderlen)
*pderlen = nm->bytes->length;
return 1;
}
+LCRYPTO_ALIAS(X509_NAME_get0_der);
-/* $OpenBSD: x_pkey.c,v 1.23 2023/07/07 19:37:53 beck Exp $ */
+/* $OpenBSD: x_pkey.c,v 1.24 2024/04/09 13:55:02 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
}
return NULL;
}
+LCRYPTO_ALIAS(X509_PKEY_new);
void
X509_PKEY_free(X509_PKEY *x)
free(x->key_data);
free(x);
}
+LCRYPTO_ALIAS(X509_PKEY_free);
-/* $OpenBSD: x_pubkey.c,v 1.35 2023/07/07 19:37:53 beck Exp $ */
+/* $OpenBSD: x_pubkey.c,v 1.36 2024/04/09 13:55:02 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (X509_PUBKEY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_PUBKEY_it);
}
+LCRYPTO_ALIAS(d2i_X509_PUBKEY);
int
i2d_X509_PUBKEY(X509_PUBKEY *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_PUBKEY_it);
}
+LCRYPTO_ALIAS(i2d_X509_PUBKEY);
X509_PUBKEY *
X509_PUBKEY_new(void)
{
return (X509_PUBKEY *)ASN1_item_new(&X509_PUBKEY_it);
}
+LCRYPTO_ALIAS(X509_PUBKEY_new);
void
X509_PUBKEY_free(X509_PUBKEY *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_PUBKEY_it);
}
+LCRYPTO_ALIAS(X509_PUBKEY_free);
int
X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey)
X509_PUBKEY_free(pk);
return 0;
}
+LCRYPTO_ALIAS(X509_PUBKEY_set);
EVP_PKEY *
X509_PUBKEY_get0(X509_PUBKEY *key)
EVP_PKEY_free(ret);
return (NULL);
}
+LCRYPTO_ALIAS(X509_PUBKEY_get0);
EVP_PKEY *
X509_PUBKEY_get(X509_PUBKEY *key)
return pkey;
}
+LCRYPTO_ALIAS(X509_PUBKEY_get);
/*
* Decode an X509_PUBKEY into the specified key type.
return (EVP_PKEY *)ASN1_item_d2i((ASN1_VALUE **)pkey, in, len,
&EVP_PKEY_PUBKEY_it);
}
+LCRYPTO_ALIAS(d2i_PUBKEY);
int
i2d_PUBKEY(EVP_PKEY *pkey, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)pkey, out, &EVP_PKEY_PUBKEY_it);
}
+LCRYPTO_ALIAS(i2d_PUBKEY);
EVP_PKEY *
d2i_PUBKEY_bio(BIO *bp, EVP_PKEY **pkey)
return (EVP_PKEY *)ASN1_item_d2i_bio(&EVP_PKEY_PUBKEY_it, bp,
(ASN1_VALUE **)pkey);
}
+LCRYPTO_ALIAS(d2i_PUBKEY_bio);
int
i2d_PUBKEY_bio(BIO *bp, EVP_PKEY *pkey)
{
return ASN1_item_i2d_bio(&EVP_PKEY_PUBKEY_it, bp, (ASN1_VALUE *)pkey);
}
+LCRYPTO_ALIAS(i2d_PUBKEY_bio);
EVP_PKEY *
d2i_PUBKEY_fp(FILE *fp, EVP_PKEY **pkey)
return (EVP_PKEY *)ASN1_item_d2i_fp(&EVP_PKEY_PUBKEY_it, fp,
(ASN1_VALUE **)pkey);
}
+LCRYPTO_ALIAS(d2i_PUBKEY_fp);
int
i2d_PUBKEY_fp(FILE *fp, EVP_PKEY *pkey)
{
return ASN1_item_i2d_fp(&EVP_PKEY_PUBKEY_it, fp, (ASN1_VALUE *)pkey);
}
+LCRYPTO_ALIAS(i2d_PUBKEY_fp);
/*
* The following are equivalents but which return RSA and DSA keys.
return (RSA *)ASN1_item_d2i((ASN1_VALUE **)rsa, in, len,
&RSA_PUBKEY_it);
}
+LCRYPTO_ALIAS(d2i_RSA_PUBKEY);
int
i2d_RSA_PUBKEY(RSA *rsa, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)rsa, out, &RSA_PUBKEY_it);
}
+LCRYPTO_ALIAS(i2d_RSA_PUBKEY);
RSA *
d2i_RSA_PUBKEY_bio(BIO *bp, RSA **rsa)
{
return (RSA *)ASN1_item_d2i_bio(&RSA_PUBKEY_it, bp, (ASN1_VALUE **)rsa);
}
+LCRYPTO_ALIAS(d2i_RSA_PUBKEY_bio);
int
i2d_RSA_PUBKEY_bio(BIO *bp, RSA *rsa)
{
return ASN1_item_i2d_bio(&RSA_PUBKEY_it, bp, (ASN1_VALUE *)rsa);
}
+LCRYPTO_ALIAS(i2d_RSA_PUBKEY_bio);
RSA *
d2i_RSA_PUBKEY_fp(FILE *fp, RSA **rsa)
{
return (RSA *)ASN1_item_d2i_fp(&RSA_PUBKEY_it, fp, (ASN1_VALUE **)rsa);
}
+LCRYPTO_ALIAS(d2i_RSA_PUBKEY_fp);
int
i2d_RSA_PUBKEY_fp(FILE *fp, RSA *rsa)
{
return ASN1_item_i2d_fp(&RSA_PUBKEY_it, fp, (ASN1_VALUE *)rsa);
}
+LCRYPTO_ALIAS(i2d_RSA_PUBKEY_fp);
#endif
#ifndef OPENSSL_NO_DSA
return (DSA *)ASN1_item_d2i((ASN1_VALUE **)dsa, in, len,
&DSA_PUBKEY_it);
}
+LCRYPTO_ALIAS(d2i_DSA_PUBKEY);
int
i2d_DSA_PUBKEY(DSA *dsa, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)dsa, out, &DSA_PUBKEY_it);
}
+LCRYPTO_ALIAS(i2d_DSA_PUBKEY);
DSA *
d2i_DSA_PUBKEY_bio(BIO *bp, DSA **dsa)
{
return (DSA *)ASN1_item_d2i_bio(&DSA_PUBKEY_it, bp, (ASN1_VALUE **)dsa);
}
+LCRYPTO_ALIAS(d2i_DSA_PUBKEY_bio);
int
i2d_DSA_PUBKEY_bio(BIO *bp, DSA *dsa)
{
return ASN1_item_i2d_bio(&DSA_PUBKEY_it, bp, (ASN1_VALUE *)dsa);
}
+LCRYPTO_ALIAS(i2d_DSA_PUBKEY_bio);
DSA *
d2i_DSA_PUBKEY_fp(FILE *fp, DSA **dsa)
{
return (DSA *)ASN1_item_d2i_fp(&DSA_PUBKEY_it, fp, (ASN1_VALUE **)dsa);
}
+LCRYPTO_ALIAS(d2i_DSA_PUBKEY_fp);
int
i2d_DSA_PUBKEY_fp(FILE *fp, DSA *dsa)
{
return ASN1_item_i2d_fp(&DSA_PUBKEY_it, fp, (ASN1_VALUE *)dsa);
}
+LCRYPTO_ALIAS(i2d_DSA_PUBKEY_fp);
#endif
return (EC_KEY *)ASN1_item_d2i((ASN1_VALUE **)ec, in, len,
&EC_PUBKEY_it);
}
+LCRYPTO_ALIAS(d2i_EC_PUBKEY);
int
i2d_EC_PUBKEY(EC_KEY *ec, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)ec, out, &EC_PUBKEY_it);
}
+LCRYPTO_ALIAS(i2d_EC_PUBKEY);
EC_KEY *
d2i_EC_PUBKEY_bio(BIO *bp, EC_KEY **ec)
{
return (EC_KEY *)ASN1_item_d2i_bio(&EC_PUBKEY_it, bp, (ASN1_VALUE **)ec);
}
+LCRYPTO_ALIAS(d2i_EC_PUBKEY_bio);
int
i2d_EC_PUBKEY_bio(BIO *bp, EC_KEY *ec)
{
return ASN1_item_i2d_bio(&EC_PUBKEY_it, bp, (ASN1_VALUE *)ec);
}
+LCRYPTO_ALIAS(i2d_EC_PUBKEY_bio);
EC_KEY *
d2i_EC_PUBKEY_fp(FILE *fp, EC_KEY **ec)
{
return (EC_KEY *)ASN1_item_d2i_fp(&EC_PUBKEY_it, fp, (ASN1_VALUE **)ec);
}
+LCRYPTO_ALIAS(d2i_EC_PUBKEY_fp);
int
i2d_EC_PUBKEY_fp(FILE *fp, EC_KEY *ec)
{
return ASN1_item_i2d_fp(&EC_PUBKEY_it, fp, (ASN1_VALUE *)ec);
}
+LCRYPTO_ALIAS(i2d_EC_PUBKEY_fp);
#endif
int
return asn1_abs_set_unused_bits(pub->public_key, 0);
}
+LCRYPTO_ALIAS(X509_PUBKEY_set0_param);
int
X509_PUBKEY_get0_param(ASN1_OBJECT **ppkalg, const unsigned char **pk,
*pa = pub->algor;
return 1;
}
+LCRYPTO_ALIAS(X509_PUBKEY_get0_param);
-/* $OpenBSD: x_req.c,v 1.21 2023/07/07 19:37:53 beck Exp $ */
+/* $OpenBSD: x_req.c,v 1.22 2024/04/09 13:55:02 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (X509_REQ_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_REQ_INFO_it);
}
+LCRYPTO_ALIAS(d2i_X509_REQ_INFO);
int
i2d_X509_REQ_INFO(X509_REQ_INFO *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_REQ_INFO_it);
}
+LCRYPTO_ALIAS(i2d_X509_REQ_INFO);
X509_REQ_INFO *
X509_REQ_INFO_new(void)
{
return (X509_REQ_INFO *)ASN1_item_new(&X509_REQ_INFO_it);
}
+LCRYPTO_ALIAS(X509_REQ_INFO_new);
void
X509_REQ_INFO_free(X509_REQ_INFO *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_REQ_INFO_it);
}
+LCRYPTO_ALIAS(X509_REQ_INFO_free);
static const ASN1_AUX X509_REQ_aux = {
.app_data = NULL,
return (X509_REQ *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_REQ_it);
}
+LCRYPTO_ALIAS(d2i_X509_REQ);
int
i2d_X509_REQ(X509_REQ *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_REQ_it);
}
+LCRYPTO_ALIAS(i2d_X509_REQ);
X509_REQ *
X509_REQ_new(void)
{
return (X509_REQ *)ASN1_item_new(&X509_REQ_it);
}
+LCRYPTO_ALIAS(X509_REQ_new);
void
X509_REQ_free(X509_REQ *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_REQ_it);
}
+LCRYPTO_ALIAS(X509_REQ_free);
X509_REQ *
X509_REQ_dup(X509_REQ *x)
{
return ASN1_item_dup(&X509_REQ_it, x);
}
+LCRYPTO_ALIAS(X509_REQ_dup);
int
X509_REQ_get_signature_nid(const X509_REQ *req)
{
return OBJ_obj2nid(req->sig_alg->algorithm);
}
+LCRYPTO_ALIAS(X509_REQ_get_signature_nid);
void
X509_REQ_get0_signature(const X509_REQ *req, const ASN1_BIT_STRING **psig,
if (palg != NULL)
*palg = req->sig_alg;
}
+LCRYPTO_ALIAS(X509_REQ_get0_signature);
-/* $OpenBSD: x_sig.c,v 1.16 2023/07/07 19:37:53 beck Exp $ */
+/* $OpenBSD: x_sig.c,v 1.17 2024/04/09 13:55:02 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (X509_SIG *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_SIG_it);
}
+LCRYPTO_ALIAS(d2i_X509_SIG);
int
i2d_X509_SIG(X509_SIG *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_SIG_it);
}
+LCRYPTO_ALIAS(i2d_X509_SIG);
X509_SIG *
X509_SIG_new(void)
{
return (X509_SIG *)ASN1_item_new(&X509_SIG_it);
}
+LCRYPTO_ALIAS(X509_SIG_new);
void
X509_SIG_free(X509_SIG *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_SIG_it);
}
+LCRYPTO_ALIAS(X509_SIG_free);
void
X509_SIG_get0(const X509_SIG *sig, const X509_ALGOR **palg,
if (pdigest != NULL)
*pdigest = sig->digest;
}
+LCRYPTO_ALIAS(X509_SIG_get0);
void
X509_SIG_getm(X509_SIG *sig, X509_ALGOR **palg, ASN1_OCTET_STRING **pdigest)
if (pdigest != NULL)
*pdigest = sig->digest;
}
+LCRYPTO_ALIAS(X509_SIG_getm);
-/* $OpenBSD: x_spki.c,v 1.13 2023/07/07 19:37:53 beck Exp $ */
+/* $OpenBSD: x_spki.c,v 1.14 2024/04/09 13:55:02 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (NETSCAPE_SPKAC *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&NETSCAPE_SPKAC_it);
}
+LCRYPTO_ALIAS(d2i_NETSCAPE_SPKAC);
int
i2d_NETSCAPE_SPKAC(NETSCAPE_SPKAC *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &NETSCAPE_SPKAC_it);
}
+LCRYPTO_ALIAS(i2d_NETSCAPE_SPKAC);
NETSCAPE_SPKAC *
NETSCAPE_SPKAC_new(void)
{
return (NETSCAPE_SPKAC *)ASN1_item_new(&NETSCAPE_SPKAC_it);
}
+LCRYPTO_ALIAS(NETSCAPE_SPKAC_new);
void
NETSCAPE_SPKAC_free(NETSCAPE_SPKAC *a)
{
ASN1_item_free((ASN1_VALUE *)a, &NETSCAPE_SPKAC_it);
}
+LCRYPTO_ALIAS(NETSCAPE_SPKAC_free);
static const ASN1_TEMPLATE NETSCAPE_SPKI_seq_tt[] = {
{
return (NETSCAPE_SPKI *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&NETSCAPE_SPKI_it);
}
+LCRYPTO_ALIAS(d2i_NETSCAPE_SPKI);
int
i2d_NETSCAPE_SPKI(NETSCAPE_SPKI *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &NETSCAPE_SPKI_it);
}
+LCRYPTO_ALIAS(i2d_NETSCAPE_SPKI);
NETSCAPE_SPKI *
NETSCAPE_SPKI_new(void)
{
return (NETSCAPE_SPKI *)ASN1_item_new(&NETSCAPE_SPKI_it);
}
+LCRYPTO_ALIAS(NETSCAPE_SPKI_new);
void
NETSCAPE_SPKI_free(NETSCAPE_SPKI *a)
{
ASN1_item_free((ASN1_VALUE *)a, &NETSCAPE_SPKI_it);
}
+LCRYPTO_ALIAS(NETSCAPE_SPKI_free);
-/* $OpenBSD: x_val.c,v 1.13 2023/07/07 19:37:53 beck Exp $ */
+/* $OpenBSD: x_val.c,v 1.14 2024/04/09 13:55:02 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (X509_VAL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_VAL_it);
}
+LCRYPTO_ALIAS(d2i_X509_VAL);
int
i2d_X509_VAL(X509_VAL *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_VAL_it);
}
+LCRYPTO_ALIAS(i2d_X509_VAL);
X509_VAL *
X509_VAL_new(void)
{
return (X509_VAL *)ASN1_item_new(&X509_VAL_it);
}
+LCRYPTO_ALIAS(X509_VAL_new);
void
X509_VAL_free(X509_VAL *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_VAL_it);
}
+LCRYPTO_ALIAS(X509_VAL_free);
-/* $OpenBSD: x_x509.c,v 1.37 2023/07/07 19:37:53 beck Exp $ */
+/* $OpenBSD: x_x509.c,v 1.38 2024/04/09 13:55:02 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (X509_CINF *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_CINF_it);
}
+LCRYPTO_ALIAS(d2i_X509_CINF);
int
i2d_X509_CINF(X509_CINF *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_CINF_it);
}
+LCRYPTO_ALIAS(i2d_X509_CINF);
X509_CINF *
X509_CINF_new(void)
{
return (X509_CINF *)ASN1_item_new(&X509_CINF_it);
}
+LCRYPTO_ALIAS(X509_CINF_new);
void
X509_CINF_free(X509_CINF *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_CINF_it);
}
+LCRYPTO_ALIAS(X509_CINF_free);
/* X509 top level structure needs a bit of customisation */
static int
return 1;
}
+LCRYPTO_ALIAS(d2i_X509_CINF);
static const ASN1_AUX X509_aux = {
.app_data = NULL,
return (X509 *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_it);
}
+LCRYPTO_ALIAS(d2i_X509);
int
i2d_X509(X509 *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_it);
}
+LCRYPTO_ALIAS(i2d_X509);
X509 *
X509_new(void)
{
return (X509 *)ASN1_item_new(&X509_it);
}
+LCRYPTO_ALIAS(X509_new);
void
X509_free(X509 *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_it);
}
+LCRYPTO_ALIAS(X509_free);
X509 *
X509_dup(X509 *x)
{
return ASN1_item_dup(&X509_it, x);
}
+LCRYPTO_ALIAS(X509_dup);
int
X509_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509, argl, argp,
new_func, dup_func, free_func);
}
+LCRYPTO_ALIAS(X509_get_ex_new_index);
int
X509_set_ex_data(X509 *r, int idx, void *arg)
{
return (CRYPTO_set_ex_data(&r->ex_data, idx, arg));
}
+LCRYPTO_ALIAS(X509_set_ex_data);
void *
X509_get_ex_data(X509 *r, int idx)
{
return (CRYPTO_get_ex_data(&r->ex_data, idx));
}
+LCRYPTO_ALIAS(X509_get_ex_data);
/* X509_AUX ASN1 routines. X509_AUX is the name given to
* a certificate with extra info tagged on the end. Since these
X509_free(ret);
return NULL;
}
+LCRYPTO_ALIAS(d2i_X509_AUX);
int
i2d_X509_AUX(X509 *a, unsigned char **pp)
length += i2d_X509_CERT_AUX(a->aux, pp);
return length;
}
+LCRYPTO_ALIAS(i2d_X509_AUX);
int
i2d_re_X509_tbs(X509 *x, unsigned char **pp)
x->cert_info->enc.modified = 1;
return i2d_X509_CINF(x->cert_info, pp);
}
+LCRYPTO_ALIAS(i2d_re_X509_tbs);
void
X509_get0_signature(const ASN1_BIT_STRING **psig, const X509_ALGOR **palg,
if (palg != NULL)
*palg = x->sig_alg;
}
+LCRYPTO_ALIAS(X509_get0_signature);
int
X509_get_signature_nid(const X509 *x)
{
return OBJ_obj2nid(x->sig_alg->algorithm);
}
+LCRYPTO_ALIAS(X509_get_signature_nid);
-/* $OpenBSD: x_x509a.c,v 1.21 2023/07/07 19:37:53 beck Exp $ */
+/* $OpenBSD: x_x509a.c,v 1.22 2024/04/09 13:55:02 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
return 0;
return ASN1_STRING_set(aux->alias, name, len);
}
+LCRYPTO_ALIAS(X509_alias_set1);
int
X509_keyid_set1(X509 *x, const unsigned char *id, int len)
return 0;
return ASN1_STRING_set(aux->keyid, id, len);
}
+LCRYPTO_ALIAS(X509_keyid_set1);
unsigned char *
X509_alias_get0(X509 *x, int *len)
*len = x->aux->alias->length;
return x->aux->alias->data;
}
+LCRYPTO_ALIAS(X509_alias_get0);
unsigned char *
X509_keyid_get0(X509 *x, int *len)
*len = x->aux->keyid->length;
return x->aux->keyid->data;
}
+LCRYPTO_ALIAS(X509_keyid_get0);
int
X509_add1_trust_object(X509 *x, const ASN1_OBJECT *obj)
ASN1_OBJECT_free(objtmp);
return 0;
}
+LCRYPTO_ALIAS(X509_add1_trust_object);
int
X509_add1_reject_object(X509 *x, const ASN1_OBJECT *obj)
ASN1_OBJECT_free(objtmp);
return 0;
}
+LCRYPTO_ALIAS(X509_add1_reject_object);
void
X509_trust_clear(X509 *x)
x->aux->trust = NULL;
}
}
+LCRYPTO_ALIAS(X509_trust_clear);
void
X509_reject_clear(X509 *x)
x->aux->reject = NULL;
}
}
+LCRYPTO_ALIAS(X509_reject_clear);
-/* $OpenBSD: evp_pkey.c,v 1.27 2023/07/07 19:37:53 beck Exp $ */
+/* $OpenBSD: evp_pkey.c,v 1.28 2024/04/09 13:55:02 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
EVP_PKEY_free(pkey);
return NULL;
}
+LCRYPTO_ALIAS(EVP_PKCS82PKEY);
/* Turn a private key into a PKCS8 structure */
PKCS8_PRIV_KEY_INFO_free(p8);
return NULL;
}
+LCRYPTO_ALIAS(EVP_PKEY2PKCS8);
/* EVP_PKEY attribute functions */
{
return X509at_get_attr_count(key->attributes);
}
+LCRYPTO_ALIAS(EVP_PKEY_get_attr_count);
int
EVP_PKEY_get_attr_by_NID(const EVP_PKEY *key, int nid, int lastpos)
{
return X509at_get_attr_by_NID(key->attributes, nid, lastpos);
}
+LCRYPTO_ALIAS(EVP_PKEY_get_attr_by_NID);
int
EVP_PKEY_get_attr_by_OBJ(const EVP_PKEY *key, const ASN1_OBJECT *obj,
{
return X509at_get_attr_by_OBJ(key->attributes, obj, lastpos);
}
+LCRYPTO_ALIAS(EVP_PKEY_get_attr_by_OBJ);
X509_ATTRIBUTE *
EVP_PKEY_get_attr(const EVP_PKEY *key, int loc)
{
return X509at_get_attr(key->attributes, loc);
}
+LCRYPTO_ALIAS(EVP_PKEY_get_attr);
X509_ATTRIBUTE *
EVP_PKEY_delete_attr(EVP_PKEY *key, int loc)
{
return X509at_delete_attr(key->attributes, loc);
}
+LCRYPTO_ALIAS(EVP_PKEY_delete_attr);
int
EVP_PKEY_add1_attr(EVP_PKEY *key, X509_ATTRIBUTE *attr)
return 1;
return 0;
}
+LCRYPTO_ALIAS(EVP_PKEY_add1_attr);
int
EVP_PKEY_add1_attr_by_OBJ(EVP_PKEY *key, const ASN1_OBJECT *obj, int type,
return 1;
return 0;
}
+LCRYPTO_ALIAS(EVP_PKEY_add1_attr_by_OBJ);
int
EVP_PKEY_add1_attr_by_NID(EVP_PKEY *key, int nid, int type,
return 1;
return 0;
}
+LCRYPTO_ALIAS(EVP_PKEY_add1_attr_by_NID);
int
EVP_PKEY_add1_attr_by_txt(EVP_PKEY *key, const char *attrname, int type,
return 1;
return 0;
}
+LCRYPTO_ALIAS(EVP_PKEY_add1_attr_by_txt);
-/* $OpenBSD: x509.h,v 1.4 2024/03/02 10:48:17 tb Exp $ */
+/* $OpenBSD: x509.h,v 1.5 2024/04/09 13:55:02 beck Exp $ */
/*
* Copyright (c) 2022 Bob Beck <beck@openbsd.org>
*
LCRYPTO_USED(X509_up_ref);
LCRYPTO_USED(X509_chain_up_ref);
LCRYPTO_USED(ERR_load_X509_strings);
+LCRYPTO_USED(X509_CRL_get_signature_nid);
+LCRYPTO_USED(X509_CRL_get0_extensions);
+LCRYPTO_USED(X509_CRL_get_version);
+LCRYPTO_USED(X509_CRL_get0_lastUpdate);
+LCRYPTO_USED(X509_CRL_get0_nextUpdate);
+LCRYPTO_USED(X509_CRL_get_lastUpdate);
+LCRYPTO_USED(X509_CRL_get_nextUpdate);
+LCRYPTO_USED(X509_CRL_get_issuer);
+LCRYPTO_USED(X509_CRL_get_REVOKED);
+LCRYPTO_USED(X509_CRL_get0_signature);
+LCRYPTO_USED(X509_CRL_get0_tbs_sigalg);
+LCRYPTO_USED(X509_REQ_get_signature_nid);
+LCRYPTO_USED(X509_REQ_get0_signature);
+LCRYPTO_USED(X509_CRL_verify);
+LCRYPTO_USED(NETSCAPE_SPKI_print);
+LCRYPTO_USED(X509_signature_dump);
+LCRYPTO_USED(X509_signature_print);
+LCRYPTO_USED(d2i_RSA_PUBKEY_fp);
+LCRYPTO_USED(i2d_RSA_PUBKEY_fp);
+LCRYPTO_USED(d2i_DSA_PUBKEY_fp);
+LCRYPTO_USED(i2d_DSA_PUBKEY_fp);
+LCRYPTO_USED(d2i_EC_PUBKEY_fp);
+LCRYPTO_USED(i2d_EC_PUBKEY_fp);
+LCRYPTO_USED(i2d_PUBKEY_fp);
+LCRYPTO_USED(d2i_PUBKEY_fp);
+LCRYPTO_USED(d2i_RSA_PUBKEY_bio);
+LCRYPTO_USED(i2d_RSA_PUBKEY_bio);
+LCRYPTO_USED(d2i_DSA_PUBKEY_bio);
+LCRYPTO_USED(i2d_DSA_PUBKEY_bio);
+LCRYPTO_USED(d2i_EC_PUBKEY_bio);
+LCRYPTO_USED(i2d_EC_PUBKEY_bio);
+LCRYPTO_USED(i2d_PUBKEY_bio);
+LCRYPTO_USED(d2i_PUBKEY_bio);
+LCRYPTO_USED(X509_dup);
+LCRYPTO_USED(X509_ATTRIBUTE_dup);
+LCRYPTO_USED(X509_EXTENSION_dup);
+LCRYPTO_USED(X509_CRL_dup);
+LCRYPTO_USED(X509_REQ_dup);
+LCRYPTO_USED(X509_ALGOR_dup);
+LCRYPTO_USED(X509_ALGOR_set0);
+LCRYPTO_USED(X509_ALGOR_get0);
+LCRYPTO_USED(X509_ALGOR_cmp);
+LCRYPTO_USED(X509_NAME_dup);
+LCRYPTO_USED(X509_NAME_get0_der);
+LCRYPTO_USED(X509_NAME_ENTRY_dup);
+LCRYPTO_USED(X509_ALGOR_new);
+LCRYPTO_USED(X509_ALGOR_free);
+LCRYPTO_USED(d2i_X509_ALGOR);
+LCRYPTO_USED(i2d_X509_ALGOR);
+LCRYPTO_USED(d2i_X509_ALGORS);
+LCRYPTO_USED(i2d_X509_ALGORS);
+LCRYPTO_USED(X509_VAL_new);
+LCRYPTO_USED(X509_VAL_free);
+LCRYPTO_USED(d2i_X509_VAL);
+LCRYPTO_USED(i2d_X509_VAL);
+LCRYPTO_USED(X509_PUBKEY_new);
+LCRYPTO_USED(X509_PUBKEY_free);
+LCRYPTO_USED(d2i_X509_PUBKEY);
+LCRYPTO_USED(i2d_X509_PUBKEY);
+LCRYPTO_USED(X509_PUBKEY_set);
+LCRYPTO_USED(X509_PUBKEY_get);
+LCRYPTO_USED(X509_PUBKEY_get0);
+LCRYPTO_USED(i2d_PUBKEY);
+LCRYPTO_USED(d2i_PUBKEY);
+LCRYPTO_USED(i2d_RSA_PUBKEY);
+LCRYPTO_USED(d2i_RSA_PUBKEY);
+LCRYPTO_USED(i2d_DSA_PUBKEY);
+LCRYPTO_USED(d2i_DSA_PUBKEY);
+LCRYPTO_USED(i2d_EC_PUBKEY);
+LCRYPTO_USED(d2i_EC_PUBKEY);
+LCRYPTO_USED(X509_SIG_new);
+LCRYPTO_USED(X509_SIG_free);
+LCRYPTO_USED(d2i_X509_SIG);
+LCRYPTO_USED(i2d_X509_SIG);
+LCRYPTO_USED(X509_SIG_get0);
+LCRYPTO_USED(X509_SIG_getm);
+LCRYPTO_USED(X509_REQ_INFO_new);
+LCRYPTO_USED(X509_REQ_INFO_free);
+LCRYPTO_USED(d2i_X509_REQ_INFO);
+LCRYPTO_USED(i2d_X509_REQ_INFO);
+LCRYPTO_USED(X509_REQ_new);
+LCRYPTO_USED(X509_REQ_free);
+LCRYPTO_USED(d2i_X509_REQ);
+LCRYPTO_USED(i2d_X509_REQ);
+LCRYPTO_USED(X509_ATTRIBUTE_new);
+LCRYPTO_USED(X509_ATTRIBUTE_free);
+LCRYPTO_USED(d2i_X509_ATTRIBUTE);
+LCRYPTO_USED(i2d_X509_ATTRIBUTE);
+LCRYPTO_USED(X509_ATTRIBUTE_create);
+LCRYPTO_USED(X509_EXTENSION_new);
+LCRYPTO_USED(X509_EXTENSION_free);
+LCRYPTO_USED(d2i_X509_EXTENSION);
+LCRYPTO_USED(i2d_X509_EXTENSION);
+LCRYPTO_USED(d2i_X509_EXTENSIONS);
+LCRYPTO_USED(i2d_X509_EXTENSIONS);
+LCRYPTO_USED(X509_NAME_ENTRY_new);
+LCRYPTO_USED(X509_NAME_ENTRY_free);
+LCRYPTO_USED(d2i_X509_NAME_ENTRY);
+LCRYPTO_USED(i2d_X509_NAME_ENTRY);
+LCRYPTO_USED(X509_NAME_new);
+LCRYPTO_USED(X509_NAME_free);
+LCRYPTO_USED(d2i_X509_NAME);
+LCRYPTO_USED(i2d_X509_NAME);
+LCRYPTO_USED(X509_NAME_set);
+LCRYPTO_USED(X509_CINF_new);
+LCRYPTO_USED(X509_CINF_free);
+LCRYPTO_USED(d2i_X509_CINF);
+LCRYPTO_USED(i2d_X509_CINF);
+LCRYPTO_USED(X509_new);
+LCRYPTO_USED(X509_free);
+LCRYPTO_USED(d2i_X509);
+LCRYPTO_USED(i2d_X509);
+LCRYPTO_USED(X509_get_ex_new_index);
+LCRYPTO_USED(X509_set_ex_data);
+LCRYPTO_USED(X509_get_ex_data);
+LCRYPTO_USED(i2d_X509_AUX);
+LCRYPTO_USED(d2i_X509_AUX);
+LCRYPTO_USED(i2d_re_X509_tbs);
+LCRYPTO_USED(X509_get0_signature);
+LCRYPTO_USED(X509_get_signature_nid);
+LCRYPTO_USED(X509_alias_set1);
+LCRYPTO_USED(X509_keyid_set1);
+LCRYPTO_USED(X509_alias_get0);
+LCRYPTO_USED(X509_keyid_get0);
+LCRYPTO_USED(X509_add1_trust_object);
+LCRYPTO_USED(X509_add1_reject_object);
+LCRYPTO_USED(X509_trust_clear);
+LCRYPTO_USED(X509_reject_clear);
+LCRYPTO_USED(X509_REVOKED_new);
+LCRYPTO_USED(X509_REVOKED_free);
+LCRYPTO_USED(X509_REVOKED_dup);
+LCRYPTO_USED(d2i_X509_REVOKED);
+LCRYPTO_USED(i2d_X509_REVOKED);
+LCRYPTO_USED(X509_CRL_INFO_new);
+LCRYPTO_USED(X509_CRL_INFO_free);
+LCRYPTO_USED(d2i_X509_CRL_INFO);
+LCRYPTO_USED(i2d_X509_CRL_INFO);
+LCRYPTO_USED(X509_CRL_new);
+LCRYPTO_USED(X509_CRL_free);
+LCRYPTO_USED(d2i_X509_CRL);
+LCRYPTO_USED(i2d_X509_CRL);
+LCRYPTO_USED(X509_CRL_add0_revoked);
+LCRYPTO_USED(X509_CRL_get0_by_serial);
+LCRYPTO_USED(X509_CRL_get0_by_cert);
+LCRYPTO_USED(X509_PKEY_new);
+LCRYPTO_USED(X509_PKEY_free);
+LCRYPTO_USED(NETSCAPE_SPKI_new);
+LCRYPTO_USED(NETSCAPE_SPKI_free);
+LCRYPTO_USED(d2i_NETSCAPE_SPKI);
+LCRYPTO_USED(i2d_NETSCAPE_SPKI);
+LCRYPTO_USED(NETSCAPE_SPKAC_new);
+LCRYPTO_USED(NETSCAPE_SPKAC_free);
+LCRYPTO_USED(d2i_NETSCAPE_SPKAC);
+LCRYPTO_USED(i2d_NETSCAPE_SPKAC);
+LCRYPTO_USED(X509_INFO_new);
+LCRYPTO_USED(X509_INFO_free);
+LCRYPTO_USED(ASN1_item_digest);
+LCRYPTO_USED(ASN1_item_verify);
+LCRYPTO_USED(ASN1_item_sign);
+LCRYPTO_USED(ASN1_item_sign_ctx);
+LCRYPTO_USED(X509_print_ex_fp);
+LCRYPTO_USED(X509_print_fp);
+LCRYPTO_USED(X509_CRL_print_fp);
+LCRYPTO_USED(X509_REQ_print_fp);
+LCRYPTO_USED(X509_NAME_print_ex_fp);
+LCRYPTO_USED(X509_NAME_print);
+LCRYPTO_USED(X509_NAME_print_ex);
+LCRYPTO_USED(X509_print_ex);
+LCRYPTO_USED(X509_print);
+LCRYPTO_USED(X509_ocspid_print);
+LCRYPTO_USED(X509_CRL_print);
+LCRYPTO_USED(X509_REQ_print_ex);
+LCRYPTO_USED(X509_REQ_print);
+LCRYPTO_USED(EVP_PKEY_get_attr_count);
+LCRYPTO_USED(EVP_PKEY_get_attr_by_NID);
+LCRYPTO_USED(EVP_PKEY_get_attr_by_OBJ);
+LCRYPTO_USED(EVP_PKEY_get_attr);
+LCRYPTO_USED(EVP_PKEY_delete_attr);
+LCRYPTO_USED(EVP_PKEY_add1_attr);
+LCRYPTO_USED(EVP_PKEY_add1_attr_by_OBJ);
+LCRYPTO_USED(EVP_PKEY_add1_attr_by_NID);
+LCRYPTO_USED(EVP_PKEY_add1_attr_by_txt);
+LCRYPTO_USED(PKCS8_PRIV_KEY_INFO_new);
+LCRYPTO_USED(PKCS8_PRIV_KEY_INFO_free);
+LCRYPTO_USED(d2i_PKCS8_PRIV_KEY_INFO);
+LCRYPTO_USED(i2d_PKCS8_PRIV_KEY_INFO);
+LCRYPTO_USED(EVP_PKCS82PKEY);
+LCRYPTO_USED(EVP_PKEY2PKCS8);
+LCRYPTO_USED(PKCS8_pkey_set0);
+LCRYPTO_USED(PKCS8_pkey_get0);
+LCRYPTO_USED(PKCS8_pkey_get0_attrs);
+LCRYPTO_USED(PKCS8_pkey_add1_attr_by_NID);
+LCRYPTO_USED(X509_PUBKEY_set0_param);
+LCRYPTO_USED(X509_PUBKEY_get0_param);
#endif /* _LIBCRYPTO_X509_H */
projects / openbsd / commitdiff