_libre_TS_CONF_set_tsa_name
_libre_TS_CONF_set_ess_cert_id_chain
_libre_ERR_load_TS_strings
+_libre_RC2_set_key
+_libre_RC2_ecb_encrypt
+_libre_RC2_encrypt
+_libre_RC2_decrypt
+_libre_RC2_cbc_encrypt
+_libre_RC2_cfb64_encrypt
+_libre_RC2_ofb64_encrypt
+_libre_PEM_get_EVP_CIPHER_INFO
+_libre_PEM_do_header
+_libre_PEM_read_bio
+_libre_PEM_write_bio
+_libre_PEM_bytes_read_bio
+_libre_PEM_ASN1_read_bio
+_libre_PEM_ASN1_write_bio
+_libre_PEM_X509_INFO_read_bio
+_libre_PEM_X509_INFO_write_bio
+_libre_PEM_read
+_libre_PEM_write
+_libre_PEM_ASN1_read
+_libre_PEM_ASN1_write
+_libre_PEM_X509_INFO_read
+_libre_PEM_SignInit
+_libre_PEM_SignUpdate
+_libre_PEM_SignFinal
+_libre_PEM_def_callback
+_libre_PEM_proc_type
+_libre_PEM_dek_info
+_libre_PEM_read_X509
+_libre_PEM_read_bio_X509
+_libre_PEM_write_X509
+_libre_PEM_write_bio_X509
+_libre_PEM_read_X509_AUX
+_libre_PEM_read_bio_X509_AUX
+_libre_PEM_write_X509_AUX
+_libre_PEM_write_bio_X509_AUX
+_libre_PEM_read_X509_REQ
+_libre_PEM_read_bio_X509_REQ
+_libre_PEM_write_X509_REQ
+_libre_PEM_write_bio_X509_REQ
+_libre_PEM_write_X509_REQ_NEW
+_libre_PEM_write_bio_X509_REQ_NEW
+_libre_PEM_read_X509_CRL
+_libre_PEM_read_bio_X509_CRL
+_libre_PEM_write_X509_CRL
+_libre_PEM_write_bio_X509_CRL
+_libre_PEM_read_PKCS7
+_libre_PEM_read_bio_PKCS7
+_libre_PEM_write_PKCS7
+_libre_PEM_write_bio_PKCS7
+_libre_PEM_read_PKCS8
+_libre_PEM_read_bio_PKCS8
+_libre_PEM_write_PKCS8
+_libre_PEM_write_bio_PKCS8
+_libre_PEM_read_PKCS8_PRIV_KEY_INFO
+_libre_PEM_read_bio_PKCS8_PRIV_KEY_INFO
+_libre_PEM_write_PKCS8_PRIV_KEY_INFO
+_libre_PEM_write_bio_PKCS8_PRIV_KEY_INFO
+_libre_PEM_read_RSAPrivateKey
+_libre_PEM_read_bio_RSAPrivateKey
+_libre_PEM_write_RSAPrivateKey
+_libre_PEM_write_bio_RSAPrivateKey
+_libre_PEM_read_RSAPublicKey
+_libre_PEM_read_bio_RSAPublicKey
+_libre_PEM_write_RSAPublicKey
+_libre_PEM_write_bio_RSAPublicKey
+_libre_PEM_read_RSA_PUBKEY
+_libre_PEM_read_bio_RSA_PUBKEY
+_libre_PEM_write_RSA_PUBKEY
+_libre_PEM_write_bio_RSA_PUBKEY
+_libre_PEM_read_DSAPrivateKey
+_libre_PEM_read_bio_DSAPrivateKey
+_libre_PEM_write_DSAPrivateKey
+_libre_PEM_write_bio_DSAPrivateKey
+_libre_PEM_read_DSA_PUBKEY
+_libre_PEM_read_bio_DSA_PUBKEY
+_libre_PEM_write_DSA_PUBKEY
+_libre_PEM_write_bio_DSA_PUBKEY
+_libre_PEM_read_DSAparams
+_libre_PEM_read_bio_DSAparams
+_libre_PEM_write_DSAparams
+_libre_PEM_write_bio_DSAparams
+_libre_PEM_read_ECPKParameters
+_libre_PEM_read_bio_ECPKParameters
+_libre_PEM_write_ECPKParameters
+_libre_PEM_write_bio_ECPKParameters
+_libre_PEM_read_ECPrivateKey
+_libre_PEM_read_bio_ECPrivateKey
+_libre_PEM_write_ECPrivateKey
+_libre_PEM_write_bio_ECPrivateKey
+_libre_PEM_read_EC_PUBKEY
+_libre_PEM_read_bio_EC_PUBKEY
+_libre_PEM_write_EC_PUBKEY
+_libre_PEM_write_bio_EC_PUBKEY
+_libre_PEM_read_DHparams
+_libre_PEM_read_bio_DHparams
+_libre_PEM_write_DHparams
+_libre_PEM_write_bio_DHparams
+_libre_PEM_read_PrivateKey
+_libre_PEM_read_bio_PrivateKey
+_libre_PEM_write_PrivateKey
+_libre_PEM_write_bio_PrivateKey
+_libre_PEM_read_PUBKEY
+_libre_PEM_read_bio_PUBKEY
+_libre_PEM_write_PUBKEY
+_libre_PEM_write_bio_PUBKEY
+_libre_PEM_write_bio_PrivateKey_traditional
+_libre_PEM_write_bio_PKCS8PrivateKey_nid
+_libre_PEM_write_bio_PKCS8PrivateKey
+_libre_i2d_PKCS8PrivateKey_bio
+_libre_i2d_PKCS8PrivateKey_nid_bio
+_libre_d2i_PKCS8PrivateKey_bio
+_libre_i2d_PKCS8PrivateKey_fp
+_libre_i2d_PKCS8PrivateKey_nid_fp
+_libre_PEM_write_PKCS8PrivateKey_nid
+_libre_d2i_PKCS8PrivateKey_fp
+_libre_PEM_write_PKCS8PrivateKey
+_libre_PEM_read_bio_Parameters
+_libre_PEM_write_bio_Parameters
+_libre_b2i_PrivateKey
+_libre_b2i_PublicKey
+_libre_b2i_PrivateKey_bio
+_libre_b2i_PublicKey_bio
+_libre_i2b_PrivateKey_bio
+_libre_i2b_PublicKey_bio
+_libre_b2i_PVK_bio
+_libre_i2b_PVK_bio
+_libre_ERR_load_PEM_strings
+_libre_lh_new
+_libre_lh_free
+_libre_lh_insert
+_libre_lh_delete
+_libre_lh_retrieve
+_libre_lh_doall
+_libre_lh_doall_arg
+_libre_lh_strhash
+_libre_lh_num_items
+_libre_lh_stats
+_libre_lh_node_stats
+_libre_lh_node_usage_stats
+_libre_lh_stats_bio
+_libre_lh_node_stats_bio
+_libre_lh_node_usage_stats_bio
--- /dev/null
+/* $OpenBSD: lhash.h,v 1.1 2023/07/07 13:40:44 beck Exp $ */
+/*
+ * Copyright (c) 2023 Bob Beck <beck@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef _LIBCRYPTO_LHASH_H
+#define _LIBCRYPTO_LHASH_H
+
+#ifndef _MSC_VER
+#include_next <openssl/lhash.h>
+#else
+#include "../include/openssl/lhash.h"
+#endif
+#include "crypto_namespace.h"
+
+LCRYPTO_USED(lh_new);
+LCRYPTO_USED(lh_free);
+LCRYPTO_USED(lh_insert);
+LCRYPTO_USED(lh_delete);
+LCRYPTO_USED(lh_retrieve);
+LCRYPTO_USED(lh_doall);
+LCRYPTO_USED(lh_doall_arg);
+LCRYPTO_USED(lh_strhash);
+LCRYPTO_USED(lh_num_items);
+LCRYPTO_USED(lh_stats);
+LCRYPTO_USED(lh_node_stats);
+LCRYPTO_USED(lh_node_usage_stats);
+LCRYPTO_USED(lh_stats_bio);
+LCRYPTO_USED(lh_node_stats_bio);
+LCRYPTO_USED(lh_node_usage_stats_bio);
+
+#endif /* _LIBCRYPTO_LHASH_H */
--- /dev/null
+/* $OpenBSD: pem.h,v 1.1 2023/07/07 13:40:44 beck Exp $ */
+/*
+ * Copyright (c) 2023 Bob Beck <beck@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef _LIBCRYPTO_PEM_H
+#define _LIBCRYPTO_PEM_H
+
+#ifndef _MSC_VER
+#include_next <openssl/pem.h>
+#else
+#include "../include/openssl/pem.h"
+#endif
+#include "crypto_namespace.h"
+
+LCRYPTO_USED(PEM_get_EVP_CIPHER_INFO);
+LCRYPTO_USED(PEM_do_header);
+LCRYPTO_USED(PEM_read_bio);
+LCRYPTO_USED(PEM_write_bio);
+LCRYPTO_USED(PEM_bytes_read_bio);
+LCRYPTO_USED(PEM_ASN1_read_bio);
+LCRYPTO_USED(PEM_ASN1_write_bio);
+LCRYPTO_USED(PEM_X509_INFO_read_bio);
+LCRYPTO_USED(PEM_X509_INFO_write_bio);
+LCRYPTO_USED(PEM_read);
+LCRYPTO_USED(PEM_write);
+LCRYPTO_USED(PEM_ASN1_read);
+LCRYPTO_USED(PEM_ASN1_write);
+LCRYPTO_USED(PEM_X509_INFO_read);
+LCRYPTO_USED(PEM_SignInit);
+LCRYPTO_USED(PEM_SignUpdate);
+LCRYPTO_USED(PEM_SignFinal);
+LCRYPTO_USED(PEM_def_callback);
+LCRYPTO_USED(PEM_proc_type);
+LCRYPTO_USED(PEM_dek_info);
+LCRYPTO_USED(PEM_read_X509);
+LCRYPTO_USED(PEM_read_bio_X509);
+LCRYPTO_USED(PEM_write_X509);
+LCRYPTO_USED(PEM_write_bio_X509);
+LCRYPTO_USED(PEM_read_X509_AUX);
+LCRYPTO_USED(PEM_read_bio_X509_AUX);
+LCRYPTO_USED(PEM_write_X509_AUX);
+LCRYPTO_USED(PEM_write_bio_X509_AUX);
+LCRYPTO_USED(PEM_read_X509_REQ);
+LCRYPTO_USED(PEM_read_bio_X509_REQ);
+LCRYPTO_USED(PEM_write_X509_REQ);
+LCRYPTO_USED(PEM_write_bio_X509_REQ);
+LCRYPTO_USED(PEM_write_X509_REQ_NEW);
+LCRYPTO_USED(PEM_write_bio_X509_REQ_NEW);
+LCRYPTO_USED(PEM_read_X509_CRL);
+LCRYPTO_USED(PEM_read_bio_X509_CRL);
+LCRYPTO_USED(PEM_write_X509_CRL);
+LCRYPTO_USED(PEM_write_bio_X509_CRL);
+LCRYPTO_USED(PEM_read_PKCS7);
+LCRYPTO_USED(PEM_read_bio_PKCS7);
+LCRYPTO_USED(PEM_write_PKCS7);
+LCRYPTO_USED(PEM_write_bio_PKCS7);
+LCRYPTO_USED(PEM_read_PKCS8);
+LCRYPTO_USED(PEM_read_bio_PKCS8);
+LCRYPTO_USED(PEM_write_PKCS8);
+LCRYPTO_USED(PEM_write_bio_PKCS8);
+LCRYPTO_USED(PEM_read_PKCS8_PRIV_KEY_INFO);
+LCRYPTO_USED(PEM_read_bio_PKCS8_PRIV_KEY_INFO);
+LCRYPTO_USED(PEM_write_PKCS8_PRIV_KEY_INFO);
+LCRYPTO_USED(PEM_write_bio_PKCS8_PRIV_KEY_INFO);
+LCRYPTO_USED(PEM_read_RSAPrivateKey);
+LCRYPTO_USED(PEM_read_bio_RSAPrivateKey);
+LCRYPTO_USED(PEM_write_RSAPrivateKey);
+LCRYPTO_USED(PEM_write_bio_RSAPrivateKey);
+LCRYPTO_USED(PEM_read_RSAPublicKey);
+LCRYPTO_USED(PEM_read_bio_RSAPublicKey);
+LCRYPTO_USED(PEM_write_RSAPublicKey);
+LCRYPTO_USED(PEM_write_bio_RSAPublicKey);
+LCRYPTO_USED(PEM_read_RSA_PUBKEY);
+LCRYPTO_USED(PEM_read_bio_RSA_PUBKEY);
+LCRYPTO_USED(PEM_write_RSA_PUBKEY);
+LCRYPTO_USED(PEM_write_bio_RSA_PUBKEY);
+LCRYPTO_USED(PEM_read_DSAPrivateKey);
+LCRYPTO_USED(PEM_read_bio_DSAPrivateKey);
+LCRYPTO_USED(PEM_write_DSAPrivateKey);
+LCRYPTO_USED(PEM_write_bio_DSAPrivateKey);
+LCRYPTO_USED(PEM_read_DSA_PUBKEY);
+LCRYPTO_USED(PEM_read_bio_DSA_PUBKEY);
+LCRYPTO_USED(PEM_write_DSA_PUBKEY);
+LCRYPTO_USED(PEM_write_bio_DSA_PUBKEY);
+LCRYPTO_USED(PEM_read_DSAparams);
+LCRYPTO_USED(PEM_read_bio_DSAparams);
+LCRYPTO_USED(PEM_write_DSAparams);
+LCRYPTO_USED(PEM_write_bio_DSAparams);
+LCRYPTO_USED(PEM_read_ECPKParameters);
+LCRYPTO_USED(PEM_read_bio_ECPKParameters);
+LCRYPTO_USED(PEM_write_ECPKParameters);
+LCRYPTO_USED(PEM_write_bio_ECPKParameters);
+LCRYPTO_USED(PEM_read_ECPrivateKey);
+LCRYPTO_USED(PEM_read_bio_ECPrivateKey);
+LCRYPTO_USED(PEM_write_ECPrivateKey);
+LCRYPTO_USED(PEM_write_bio_ECPrivateKey);
+LCRYPTO_USED(PEM_read_EC_PUBKEY);
+LCRYPTO_USED(PEM_read_bio_EC_PUBKEY);
+LCRYPTO_USED(PEM_write_EC_PUBKEY);
+LCRYPTO_USED(PEM_write_bio_EC_PUBKEY);
+LCRYPTO_USED(PEM_read_DHparams);
+LCRYPTO_USED(PEM_read_bio_DHparams);
+LCRYPTO_USED(PEM_write_DHparams);
+LCRYPTO_USED(PEM_write_bio_DHparams);
+LCRYPTO_USED(PEM_read_PrivateKey);
+LCRYPTO_USED(PEM_read_bio_PrivateKey);
+LCRYPTO_USED(PEM_write_PrivateKey);
+LCRYPTO_USED(PEM_write_bio_PrivateKey);
+LCRYPTO_USED(PEM_read_PUBKEY);
+LCRYPTO_USED(PEM_read_bio_PUBKEY);
+LCRYPTO_USED(PEM_write_PUBKEY);
+LCRYPTO_USED(PEM_write_bio_PUBKEY);
+LCRYPTO_USED(PEM_write_bio_PrivateKey_traditional);
+LCRYPTO_USED(PEM_write_bio_PKCS8PrivateKey_nid);
+LCRYPTO_USED(PEM_write_bio_PKCS8PrivateKey);
+LCRYPTO_USED(i2d_PKCS8PrivateKey_bio);
+LCRYPTO_USED(i2d_PKCS8PrivateKey_nid_bio);
+LCRYPTO_USED(d2i_PKCS8PrivateKey_bio);
+LCRYPTO_USED(i2d_PKCS8PrivateKey_fp);
+LCRYPTO_USED(i2d_PKCS8PrivateKey_nid_fp);
+LCRYPTO_USED(PEM_write_PKCS8PrivateKey_nid);
+LCRYPTO_USED(d2i_PKCS8PrivateKey_fp);
+LCRYPTO_USED(PEM_write_PKCS8PrivateKey);
+LCRYPTO_USED(PEM_read_bio_Parameters);
+LCRYPTO_USED(PEM_write_bio_Parameters);
+LCRYPTO_USED(b2i_PrivateKey);
+LCRYPTO_USED(b2i_PublicKey);
+LCRYPTO_USED(b2i_PrivateKey_bio);
+LCRYPTO_USED(b2i_PublicKey_bio);
+LCRYPTO_USED(i2b_PrivateKey_bio);
+LCRYPTO_USED(i2b_PublicKey_bio);
+LCRYPTO_USED(b2i_PVK_bio);
+LCRYPTO_USED(i2b_PVK_bio);
+LCRYPTO_USED(ERR_load_PEM_strings);
+
+#endif /* _LIBCRYPTO_PEM_H */
--- /dev/null
+/* $OpenBSD: rc2.h,v 1.1 2023/07/07 13:40:44 beck Exp $ */
+/*
+ * Copyright (c) 2023 Bob Beck <beck@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef _LIBCRYPTO_RC2_H
+#define _LIBCRYPTO_RC2_H
+
+#ifndef _MSC_VER
+#include_next <openssl/rc2.h>
+#else
+#include "../include/openssl/rc2.h"
+#endif
+#include "crypto_namespace.h"
+
+LCRYPTO_USED(RC2_set_key);
+LCRYPTO_USED(RC2_ecb_encrypt);
+LCRYPTO_USED(RC2_encrypt);
+LCRYPTO_USED(RC2_decrypt);
+LCRYPTO_USED(RC2_cbc_encrypt);
+LCRYPTO_USED(RC2_cfb64_encrypt);
+LCRYPTO_USED(RC2_ofb64_encrypt);
+
+#endif /* _LIBCRYPTO_RC2_H */
-/* $OpenBSD: lh_stats.c,v 1.12 2014/07/11 08:44:48 jsing Exp $ */
+/* $OpenBSD: lh_stats.c,v 1.13 2023/07/07 13:40:44 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
fprintf(out, "down_load = %lu\n", lh->down_load);
#endif
}
+LCRYPTO_ALIAS(lh_stats);
void
lh_node_stats(LHASH *lh, FILE *out)
fprintf(out, "node %6u -> %3u\n", i, num);
}
}
+LCRYPTO_ALIAS(lh_node_stats);
void
lh_node_usage_stats(LHASH *lh, FILE *out)
(int)(total / n_used),
(int)((total % n_used) * 100 / n_used));
}
+LCRYPTO_ALIAS(lh_node_usage_stats);
#else
BIO_free(bp);
end:;
}
+LCRYPTO_ALIAS(lh_stats);
void
lh_node_stats(const _LHASH *lh, FILE *fp)
BIO_free(bp);
end:;
}
+LCRYPTO_ALIAS(lh_node_stats);
void
lh_node_usage_stats(const _LHASH *lh, FILE *fp)
BIO_free(bp);
end:;
}
+LCRYPTO_ALIAS(lh_node_usage_stats);
void
BIO_printf(out, "down_load = %lu\n", lh->down_load);
#endif
}
+LCRYPTO_ALIAS(lh_stats_bio);
void
lh_node_stats_bio(const _LHASH *lh, BIO *out)
BIO_printf(out, "node %6u -> %3u\n", i, num);
}
}
+LCRYPTO_ALIAS(lh_node_stats_bio);
void
lh_node_usage_stats_bio(const _LHASH *lh, BIO *out)
(int)(total / n_used),
(int)((total % n_used) * 100 / n_used));
}
+LCRYPTO_ALIAS(lh_node_usage_stats_bio);
#endif
-/* $OpenBSD: lhash.c,v 1.19 2019/05/12 00:09:59 beck Exp $ */
+/* $OpenBSD: lhash.c,v 1.20 2023/07/07 13:40:44 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (ret);
}
+LCRYPTO_ALIAS(lh_new);
void
lh_free(_LHASH *lh)
free(lh->b);
free(lh);
}
+LCRYPTO_ALIAS(lh_free);
void *
lh_insert(_LHASH *lh, void *data)
}
return (ret);
}
+LCRYPTO_ALIAS(lh_insert);
void *
lh_delete(_LHASH *lh, const void *data)
return (ret);
}
+LCRYPTO_ALIAS(lh_delete);
void *
lh_retrieve(_LHASH *lh, const void *data)
}
return (ret);
}
+LCRYPTO_ALIAS(lh_retrieve);
static void
doall_util_fn(_LHASH *lh, int use_arg, LHASH_DOALL_FN_TYPE func,
{
doall_util_fn(lh, 0, func, (LHASH_DOALL_ARG_FN_TYPE)0, NULL);
}
+LCRYPTO_ALIAS(lh_doall);
void
lh_doall_arg(_LHASH *lh, LHASH_DOALL_ARG_FN_TYPE func, void *arg)
{
doall_util_fn(lh, 1, (LHASH_DOALL_FN_TYPE)0, func, arg);
}
+LCRYPTO_ALIAS(lh_doall_arg);
static void
expand(_LHASH *lh)
}
return (ret >> 16) ^ ret;
}
+LCRYPTO_ALIAS(lh_strhash);
unsigned long
lh_num_items(const _LHASH *lh)
{
return lh ? lh->num_items : 0;
}
+LCRYPTO_ALIAS(lh_num_items);
-/* $OpenBSD: pem_all.c,v 1.20 2023/04/25 17:51:36 tb Exp $ */
+/* $OpenBSD: pem_all.c,v 1.21 2023/07/07 13:40:44 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return PEM_ASN1_read((d2i_of_void *)d2i_X509_REQ, PEM_STRING_X509_REQ, fp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_X509_REQ);
int
PEM_write_X509_REQ(FILE *fp, X509_REQ *x)
return PEM_ASN1_write((i2d_of_void *)i2d_X509_REQ, PEM_STRING_X509_REQ, fp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_X509_REQ);
X509_REQ *
PEM_read_bio_X509_REQ(BIO *bp, X509_REQ **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read_bio((d2i_of_void *)d2i_X509_REQ, PEM_STRING_X509_REQ, bp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_bio_X509_REQ);
int
PEM_write_bio_X509_REQ(BIO *bp, X509_REQ *x)
return PEM_ASN1_write_bio((i2d_of_void *)i2d_X509_REQ, PEM_STRING_X509_REQ, bp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_bio_X509_REQ);
int
PEM_write_X509_REQ_NEW(FILE *fp, X509_REQ *x)
return PEM_ASN1_write((i2d_of_void *)i2d_X509_REQ, PEM_STRING_X509_REQ_OLD, fp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_X509_REQ_NEW);
int
PEM_write_bio_X509_REQ_NEW(BIO *bp, X509_REQ *x)
return PEM_ASN1_write_bio((i2d_of_void *)i2d_X509_REQ, PEM_STRING_X509_REQ_OLD, bp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_bio_X509_REQ_NEW);
X509_CRL *
PEM_read_X509_CRL(FILE *fp, X509_CRL **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read((d2i_of_void *)d2i_X509_CRL, PEM_STRING_X509_CRL, fp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_X509_CRL);
int
PEM_write_X509_CRL(FILE *fp, X509_CRL *x)
return PEM_ASN1_write((i2d_of_void *)i2d_X509_CRL, PEM_STRING_X509_CRL, fp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_X509_CRL);
X509_CRL *
PEM_read_bio_X509_CRL(BIO *bp, X509_CRL **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read_bio((d2i_of_void *)d2i_X509_CRL, PEM_STRING_X509_CRL, bp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_bio_X509_CRL);
int
PEM_write_bio_X509_CRL(BIO *bp, X509_CRL *x)
return PEM_ASN1_write_bio((i2d_of_void *)i2d_X509_CRL, PEM_STRING_X509_CRL, bp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_bio_X509_CRL);
PKCS7 *
PEM_read_PKCS7(FILE *fp, PKCS7 **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read((d2i_of_void *)d2i_PKCS7, PEM_STRING_PKCS7, fp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_PKCS7);
int
PEM_write_PKCS7(FILE *fp, PKCS7 *x)
return PEM_ASN1_write((i2d_of_void *)i2d_PKCS7, PEM_STRING_PKCS7, fp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_PKCS7);
PKCS7 *
PEM_read_bio_PKCS7(BIO *bp, PKCS7 **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read_bio((d2i_of_void *)d2i_PKCS7, PEM_STRING_PKCS7, bp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_bio_PKCS7);
int
PEM_write_bio_PKCS7(BIO *bp, PKCS7 *x)
return PEM_ASN1_write_bio((i2d_of_void *)i2d_PKCS7, PEM_STRING_PKCS7, bp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_bio_PKCS7);
#ifndef OPENSSL_NO_RSA
pktmp = PEM_read_PrivateKey(fp, NULL, cb, u);
return pkey_get_rsa(pktmp, rsa);
}
+LCRYPTO_ALIAS(PEM_read_RSAPrivateKey);
int
PEM_write_RSAPrivateKey(FILE *fp, RSA *x, const EVP_CIPHER *enc,
return PEM_ASN1_write((i2d_of_void *)i2d_RSAPrivateKey, PEM_STRING_RSA, fp,
x, enc, kstr, klen, cb, u);
}
+LCRYPTO_ALIAS(PEM_write_RSAPrivateKey);
RSA *
PEM_read_bio_RSAPrivateKey(BIO *bp, RSA **rsa, pem_password_cb *cb, void *u)
pktmp = PEM_read_bio_PrivateKey(bp, NULL, cb, u);
return pkey_get_rsa(pktmp, rsa);
}
+LCRYPTO_ALIAS(PEM_read_bio_RSAPrivateKey);
int
PEM_write_bio_RSAPrivateKey(BIO *bp, RSA *x,
return PEM_ASN1_write_bio((i2d_of_void *)i2d_RSAPrivateKey, PEM_STRING_RSA, bp,
x, enc, kstr, klen, cb, u);
}
+LCRYPTO_ALIAS(PEM_write_bio_RSAPrivateKey);
RSA *
PEM_read_RSAPublicKey(FILE *fp, RSA **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read((d2i_of_void *)d2i_RSAPublicKey, PEM_STRING_RSA_PUBLIC, fp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_RSAPublicKey);
int
PEM_write_RSAPublicKey(FILE *fp, const RSA *x)
return PEM_ASN1_write((i2d_of_void *)i2d_RSAPublicKey, PEM_STRING_RSA_PUBLIC, fp,
(void *)x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_RSAPublicKey);
RSA *
PEM_read_bio_RSAPublicKey(BIO *bp, RSA **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read_bio((d2i_of_void *)d2i_RSAPublicKey, PEM_STRING_RSA_PUBLIC, bp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_bio_RSAPublicKey);
int
PEM_write_bio_RSAPublicKey(BIO *bp, const RSA *x)
return PEM_ASN1_write_bio((i2d_of_void *)i2d_RSAPublicKey, PEM_STRING_RSA_PUBLIC, bp,
(void *)x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_bio_RSAPublicKey);
RSA *
PEM_read_RSA_PUBKEY(FILE *fp, RSA **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read((d2i_of_void *)d2i_RSA_PUBKEY, PEM_STRING_PUBLIC, fp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_RSA_PUBKEY);
int
PEM_write_RSA_PUBKEY(FILE *fp, RSA *x)
return PEM_ASN1_write((i2d_of_void *)i2d_RSA_PUBKEY, PEM_STRING_PUBLIC, fp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_RSA_PUBKEY);
RSA *
PEM_read_bio_RSA_PUBKEY(BIO *bp, RSA **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read_bio((d2i_of_void *)d2i_RSA_PUBKEY, PEM_STRING_PUBLIC, bp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_bio_RSA_PUBKEY);
int
PEM_write_bio_RSA_PUBKEY(BIO *bp, RSA *x)
return PEM_ASN1_write_bio((i2d_of_void *)i2d_RSA_PUBKEY, PEM_STRING_PUBLIC, bp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_bio_RSA_PUBKEY);
#endif
pktmp = PEM_read_PrivateKey(fp, NULL, cb, u);
return pkey_get_dsa(pktmp, dsa); /* will free pktmp */
}
+LCRYPTO_ALIAS(PEM_read_DSAPrivateKey);
int
PEM_write_DSAPrivateKey(FILE *fp, DSA *x, const EVP_CIPHER *enc,
return PEM_ASN1_write((i2d_of_void *)i2d_DSAPrivateKey, PEM_STRING_DSA, fp,
x, enc, kstr, klen, cb, u);
}
+LCRYPTO_ALIAS(PEM_write_DSAPrivateKey);
DSA *
PEM_read_bio_DSAPrivateKey(BIO *bp, DSA **dsa, pem_password_cb *cb, void *u)
pktmp = PEM_read_bio_PrivateKey(bp, NULL, cb, u);
return pkey_get_dsa(pktmp, dsa); /* will free pktmp */
}
+LCRYPTO_ALIAS(PEM_read_bio_DSAPrivateKey);
int
PEM_write_bio_DSAPrivateKey(BIO *bp, DSA *x,
return PEM_ASN1_write_bio((i2d_of_void *)i2d_DSAPrivateKey, PEM_STRING_DSA, bp,
x, enc, kstr, klen, cb, u);
}
+LCRYPTO_ALIAS(PEM_write_bio_DSAPrivateKey);
DSA *
PEM_read_DSA_PUBKEY(FILE *fp, DSA **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read((d2i_of_void *)d2i_DSA_PUBKEY, PEM_STRING_PUBLIC, fp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_DSA_PUBKEY);
int
PEM_write_DSA_PUBKEY(FILE *fp, DSA *x)
return PEM_ASN1_write((i2d_of_void *)i2d_DSA_PUBKEY, PEM_STRING_PUBLIC, fp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_DSA_PUBKEY);
int
PEM_write_bio_DSA_PUBKEY(BIO *bp, DSA *x)
return PEM_ASN1_write_bio((i2d_of_void *)i2d_DSA_PUBKEY, PEM_STRING_PUBLIC, bp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_bio_DSA_PUBKEY);
DSA *
PEM_read_bio_DSA_PUBKEY(BIO *bp, DSA **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read_bio((d2i_of_void *)d2i_DSA_PUBKEY, PEM_STRING_PUBLIC, bp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_bio_DSA_PUBKEY);
DSA *
PEM_read_DSAparams(FILE *fp, DSA **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read((d2i_of_void *)d2i_DSAparams, PEM_STRING_DSAPARAMS, fp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_DSAparams);
int
PEM_write_DSAparams(FILE *fp, const DSA *x)
return PEM_ASN1_write((i2d_of_void *)i2d_DSAparams, PEM_STRING_DSAPARAMS, fp,
(void *)x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_DSAparams);
DSA *
PEM_read_bio_DSAparams(BIO *bp, DSA **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read_bio((d2i_of_void *)d2i_DSAparams, PEM_STRING_DSAPARAMS, bp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_bio_DSAparams);
int
PEM_write_bio_DSAparams(BIO *bp, const DSA *x)
return PEM_ASN1_write_bio((i2d_of_void *)i2d_DSAparams, PEM_STRING_DSAPARAMS, bp,
(void *)x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_bio_DSAparams);
#endif
return PEM_ASN1_read((d2i_of_void *)d2i_ECPKParameters, PEM_STRING_ECPARAMETERS, fp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_ECPKParameters);
int
PEM_write_ECPKParameters(FILE *fp, const EC_GROUP *x)
return PEM_ASN1_write((i2d_of_void *)i2d_ECPKParameters, PEM_STRING_ECPARAMETERS, fp,
(void *)x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_ECPKParameters);
EC_GROUP *
PEM_read_bio_ECPKParameters(BIO *bp, EC_GROUP **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read_bio((d2i_of_void *)d2i_ECPKParameters, PEM_STRING_ECPARAMETERS, bp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_bio_ECPKParameters);
int
PEM_write_bio_ECPKParameters(BIO *bp, const EC_GROUP *x)
return PEM_ASN1_write_bio((i2d_of_void *)i2d_ECPKParameters, PEM_STRING_ECPARAMETERS, bp,
(void *)x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_bio_ECPKParameters);
EC_KEY *
PEM_read_ECPrivateKey(FILE *fp, EC_KEY **eckey, pem_password_cb *cb, void *u)
pktmp = PEM_read_PrivateKey(fp, NULL, cb, u);
return pkey_get_eckey(pktmp, eckey); /* will free pktmp */
}
+LCRYPTO_ALIAS(PEM_read_ECPrivateKey);
int
PEM_write_ECPrivateKey(FILE *fp, EC_KEY *x, const EVP_CIPHER *enc,
return PEM_ASN1_write((i2d_of_void *)i2d_ECPrivateKey, PEM_STRING_ECPRIVATEKEY, fp,
x, enc, kstr, klen, cb, u);
}
+LCRYPTO_ALIAS(PEM_write_ECPrivateKey);
EC_KEY *
PEM_read_bio_ECPrivateKey(BIO *bp, EC_KEY **key, pem_password_cb *cb, void *u)
pktmp = PEM_read_bio_PrivateKey(bp, NULL, cb, u);
return pkey_get_eckey(pktmp, key); /* will free pktmp */
}
+LCRYPTO_ALIAS(PEM_read_bio_ECPrivateKey);
int
PEM_write_bio_ECPrivateKey(BIO *bp, EC_KEY *x,
return PEM_ASN1_write_bio((i2d_of_void *)i2d_ECPrivateKey, PEM_STRING_ECPRIVATEKEY, bp,
x, enc, kstr, klen, cb, u);
}
+LCRYPTO_ALIAS(PEM_write_bio_ECPrivateKey);
EC_KEY *
PEM_read_EC_PUBKEY(FILE *fp, EC_KEY **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read((d2i_of_void *)d2i_EC_PUBKEY, PEM_STRING_PUBLIC, fp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_EC_PUBKEY);
int
PEM_write_EC_PUBKEY(FILE *fp, EC_KEY *x)
return PEM_ASN1_write((i2d_of_void *)i2d_EC_PUBKEY, PEM_STRING_PUBLIC, fp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_EC_PUBKEY);
EC_KEY *
PEM_read_bio_EC_PUBKEY(BIO *bp, EC_KEY **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read_bio((d2i_of_void *)d2i_EC_PUBKEY, PEM_STRING_PUBLIC, bp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_bio_EC_PUBKEY);
int
PEM_write_bio_EC_PUBKEY(BIO *bp, EC_KEY *x)
return PEM_ASN1_write_bio((i2d_of_void *)i2d_EC_PUBKEY, PEM_STRING_PUBLIC, bp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_bio_EC_PUBKEY);
#endif
return PEM_ASN1_read((d2i_of_void *)d2i_DHparams, PEM_STRING_DHPARAMS, fp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_DHparams);
int
PEM_write_DHparams(FILE *fp, const DH *x)
return PEM_ASN1_write((i2d_of_void *)i2d_DHparams, PEM_STRING_DHPARAMS, fp,
(void *)x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_DHparams);
DH *
PEM_read_bio_DHparams(BIO *bp, DH **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read_bio((d2i_of_void *)d2i_DHparams, PEM_STRING_DHPARAMS, bp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_bio_DHparams);
int
PEM_write_bio_DHparams(BIO *bp, const DH *x)
return PEM_ASN1_write_bio((i2d_of_void *)i2d_DHparams, PEM_STRING_DHPARAMS, bp,
(void *)x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_bio_DHparams);
#endif
return PEM_ASN1_read((d2i_of_void *)d2i_PUBKEY, PEM_STRING_PUBLIC, fp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_PUBKEY);
int
PEM_write_PUBKEY(FILE *fp, EVP_PKEY *x)
return PEM_ASN1_write((i2d_of_void *)i2d_PUBKEY, PEM_STRING_PUBLIC, fp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_PUBKEY);
EVP_PKEY *
PEM_read_bio_PUBKEY(BIO *bp, EVP_PKEY **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read_bio((d2i_of_void *)d2i_PUBKEY, PEM_STRING_PUBLIC, bp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_bio_PUBKEY);
int
PEM_write_bio_PUBKEY(BIO *bp, EVP_PKEY *x)
return PEM_ASN1_write_bio((i2d_of_void *)i2d_PUBKEY, PEM_STRING_PUBLIC, bp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_bio_PUBKEY);
-/* $OpenBSD: pem_err.c,v 1.13 2022/07/12 14:42:50 kn Exp $ */
+/* $OpenBSD: pem_err.c,v 1.14 2023/07/07 13:40:44 beck Exp $ */
/* ====================================================================
* Copyright (c) 1999-2007 The OpenSSL Project. All rights reserved.
*
}
#endif
}
+LCRYPTO_ALIAS(ERR_load_PEM_strings);
-/* $OpenBSD: pem_info.c,v 1.26 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: pem_info.c,v 1.27 2023/07/07 13:40:44 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
BIO_free(b);
return (ret);
}
+LCRYPTO_ALIAS(PEM_X509_INFO_read);
STACK_OF(X509_INFO) *
PEM_X509_INFO_read_bio(BIO *bp, STACK_OF(X509_INFO) *sk, pem_password_cb *cb,
return ret;
}
+LCRYPTO_ALIAS(PEM_X509_INFO_read_bio);
/* A TJH addition */
explicit_bzero(buf, PEM_BUFSIZE);
return (ret);
}
+LCRYPTO_ALIAS(PEM_X509_INFO_write_bio);
-/* $OpenBSD: pem_lib.c,v 1.52 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: pem_lib.c,v 1.53 2023/07/07 13:40:44 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
}
return (int)l;
}
+LCRYPTO_ALIAS(PEM_def_callback);
void
PEM_proc_type(char *buf, int type)
strlcat(buf, str, PEM_BUFSIZE);
strlcat(buf, "\n", PEM_BUFSIZE);
}
+LCRYPTO_ALIAS(PEM_proc_type);
void
PEM_dek_info(char *buf, const char *type, int len, char *str)
buf[j + i * 2] = '\n';
buf[j + i * 2 + 1] = '\0';
}
+LCRYPTO_ALIAS(PEM_dek_info);
void *
PEM_ASN1_read(d2i_of_void *d2i, const char *name, FILE *fp, void **x,
BIO_free(b);
return (ret);
}
+LCRYPTO_ALIAS(PEM_ASN1_read);
static int
check_pem(const char *nm, const char *name)
free(data);
return ret;
}
+LCRYPTO_ALIAS(PEM_bytes_read_bio);
int
PEM_ASN1_write(i2d_of_void *i2d, const char *name, FILE *fp, void *x,
BIO_free(b);
return (ret);
}
+LCRYPTO_ALIAS(PEM_ASN1_write);
int
PEM_ASN1_write_bio(i2d_of_void *i2d, const char *name, BIO *bp, void *x,
freezero(data, (unsigned int)dsize);
return (ret);
}
+LCRYPTO_ALIAS(PEM_ASN1_write_bio);
int
PEM_do_header(EVP_CIPHER_INFO *cipher, unsigned char *data, long *plen,
*plen = j + i;
return (1);
}
+LCRYPTO_ALIAS(PEM_do_header);
int
PEM_get_EVP_CIPHER_INFO(char *header, EVP_CIPHER_INFO *cipher)
return (1);
}
+LCRYPTO_ALIAS(PEM_get_EVP_CIPHER_INFO);
static int
load_iv(char **fromp, unsigned char *to, int num)
BIO_free(b);
return (ret);
}
+LCRYPTO_ALIAS(PEM_write);
int
PEM_write_bio(BIO *bp, const char *name, const char *header,
PEMerror(reason);
return (0);
}
+LCRYPTO_ALIAS(PEM_write_bio);
int
PEM_read(FILE *fp, char **name, char **header, unsigned char **data, long *len)
BIO_free(b);
return (ret);
}
+LCRYPTO_ALIAS(PEM_read);
int
PEM_read_bio(BIO *bp, char **name, char **header, unsigned char **data,
BUF_MEM_free(dataB);
return (0);
}
+LCRYPTO_ALIAS(PEM_read_bio);
/* Check pem string and return prefix length.
* If for example the pem_str == "RSA PRIVATE KEY" and suffix = "PRIVATE KEY"
-/* $OpenBSD: pem_oth.c,v 1.8 2017/01/29 17:49:23 beck Exp $ */
+/* $OpenBSD: pem_oth.c,v 1.9 2023/07/07 13:40:44 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
free(data);
return (ret);
}
+LCRYPTO_ALIAS(PEM_ASN1_read_bio);
-/* $OpenBSD: pem_pk8.c,v 1.13 2017/01/29 17:49:23 beck Exp $ */
+/* $OpenBSD: pem_pk8.c,v 1.14 2023/07/07 13:40:44 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
{
return do_pk8pkey(bp, x, 0, nid, NULL, kstr, klen, cb, u);
}
+LCRYPTO_ALIAS(PEM_write_bio_PKCS8PrivateKey_nid);
int
PEM_write_bio_PKCS8PrivateKey(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc,
{
return do_pk8pkey(bp, x, 0, -1, enc, kstr, klen, cb, u);
}
+LCRYPTO_ALIAS(PEM_write_bio_PKCS8PrivateKey);
int
i2d_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc,
{
return do_pk8pkey(bp, x, 1, -1, enc, kstr, klen, cb, u);
}
+LCRYPTO_ALIAS(i2d_PKCS8PrivateKey_bio);
int
i2d_PKCS8PrivateKey_nid_bio(BIO *bp, EVP_PKEY *x, int nid,
{
return do_pk8pkey(bp, x, 1, nid, NULL, kstr, klen, cb, u);
}
+LCRYPTO_ALIAS(i2d_PKCS8PrivateKey_nid_bio);
static int
do_pk8pkey(BIO *bp, EVP_PKEY *x, int isder, int nid, const EVP_CIPHER *enc,
}
return ret;
}
+LCRYPTO_ALIAS(d2i_PKCS8PrivateKey_bio);
int
{
return do_pk8pkey_fp(fp, x, 1, -1, enc, kstr, klen, cb, u);
}
+LCRYPTO_ALIAS(i2d_PKCS8PrivateKey_fp);
int
i2d_PKCS8PrivateKey_nid_fp(FILE *fp, EVP_PKEY *x, int nid, char *kstr,
{
return do_pk8pkey_fp(fp, x, 1, nid, NULL, kstr, klen, cb, u);
}
+LCRYPTO_ALIAS(i2d_PKCS8PrivateKey_nid_fp);
int
PEM_write_PKCS8PrivateKey_nid(FILE *fp, EVP_PKEY *x, int nid, char *kstr,
{
return do_pk8pkey_fp(fp, x, 0, nid, NULL, kstr, klen, cb, u);
}
+LCRYPTO_ALIAS(PEM_write_PKCS8PrivateKey_nid);
int
PEM_write_PKCS8PrivateKey(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc,
{
return do_pk8pkey_fp(fp, x, 0, -1, enc, kstr, klen, cb, u);
}
+LCRYPTO_ALIAS(PEM_write_PKCS8PrivateKey);
static int
do_pk8pkey_fp(FILE *fp, EVP_PKEY *x, int isder, int nid, const EVP_CIPHER *enc,
BIO_free(bp);
return ret;
}
+LCRYPTO_ALIAS(d2i_PKCS8PrivateKey_fp);
X509_SIG *
PEM_read_PKCS8(FILE *fp, X509_SIG **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read((d2i_of_void *)d2i_X509_SIG, PEM_STRING_PKCS8, fp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_PKCS8);
int
PEM_write_PKCS8(FILE *fp, X509_SIG *x)
return PEM_ASN1_write((i2d_of_void *)i2d_X509_SIG, PEM_STRING_PKCS8, fp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_PKCS8);
X509_SIG *
PEM_read_bio_PKCS8(BIO *bp, X509_SIG **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read_bio((d2i_of_void *)d2i_X509_SIG, PEM_STRING_PKCS8, bp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_bio_PKCS8);
int
PEM_write_bio_PKCS8(BIO *bp, X509_SIG *x)
return PEM_ASN1_write_bio((i2d_of_void *)i2d_X509_SIG, PEM_STRING_PKCS8, bp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_bio_PKCS8);
PKCS8_PRIV_KEY_INFO *
PEM_read_PKCS8_PRIV_KEY_INFO(FILE *fp, PKCS8_PRIV_KEY_INFO **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read((d2i_of_void *)d2i_PKCS8_PRIV_KEY_INFO, PEM_STRING_PKCS8INF, fp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_PKCS8_PRIV_KEY_INFO);
int
PEM_write_PKCS8_PRIV_KEY_INFO(FILE *fp, PKCS8_PRIV_KEY_INFO *x)
return PEM_ASN1_write((i2d_of_void *)i2d_PKCS8_PRIV_KEY_INFO, PEM_STRING_PKCS8INF, fp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_PKCS8_PRIV_KEY_INFO);
PKCS8_PRIV_KEY_INFO *
PEM_read_bio_PKCS8_PRIV_KEY_INFO(BIO *bp, PKCS8_PRIV_KEY_INFO **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read_bio((d2i_of_void *)d2i_PKCS8_PRIV_KEY_INFO, PEM_STRING_PKCS8INF, bp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_bio_PKCS8_PRIV_KEY_INFO);
int
PEM_write_bio_PKCS8_PRIV_KEY_INFO(BIO *bp, PKCS8_PRIV_KEY_INFO *x)
return PEM_ASN1_write_bio((i2d_of_void *)i2d_PKCS8_PRIV_KEY_INFO, PEM_STRING_PKCS8INF, bp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_bio_PKCS8_PRIV_KEY_INFO);
-/* $OpenBSD: pem_pkey.c,v 1.26 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: pem_pkey.c,v 1.27 2023/07/07 13:40:44 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
freezero(data, len);
return (ret);
}
+LCRYPTO_ALIAS(PEM_read_bio_PrivateKey);
int
PEM_write_bio_PrivateKey(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc,
return PEM_write_bio_PrivateKey_traditional(bp, x, enc, kstr, klen, cb,
u);
}
+LCRYPTO_ALIAS(PEM_write_bio_PrivateKey);
int
PEM_write_bio_PrivateKey_traditional(BIO *bp, EVP_PKEY *x,
return PEM_ASN1_write_bio((i2d_of_void *)i2d_PrivateKey,
pem_str, bp, x, enc, kstr, klen, cb, u);
}
+LCRYPTO_ALIAS(PEM_write_bio_PrivateKey_traditional);
EVP_PKEY *
PEM_read_bio_Parameters(BIO *bp, EVP_PKEY **x)
free(data);
return (ret);
}
+LCRYPTO_ALIAS(PEM_read_bio_Parameters);
int
PEM_write_bio_Parameters(BIO *bp, EVP_PKEY *x)
return PEM_ASN1_write_bio((i2d_of_void *)x->ameth->param_encode,
pem_str, bp, x, NULL, NULL, 0, 0, NULL);
}
+LCRYPTO_ALIAS(PEM_write_bio_Parameters);
EVP_PKEY *
PEM_read_PrivateKey(FILE *fp, EVP_PKEY **x, pem_password_cb *cb, void *u)
BIO_free(b);
return (ret);
}
+LCRYPTO_ALIAS(PEM_read_PrivateKey);
int
PEM_write_PrivateKey(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc,
BIO_free(b);
return ret;
}
-
+LCRYPTO_ALIAS(PEM_write_PrivateKey);
-/* $OpenBSD: pem_sign.c,v 1.14 2018/08/24 19:51:31 tb Exp $ */
+/* $OpenBSD: pem_sign.c,v 1.15 2023/07/07 13:40:44 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
{
return EVP_DigestInit_ex(ctx, type, NULL);
}
+LCRYPTO_ALIAS(PEM_SignInit);
int
PEM_SignUpdate(EVP_MD_CTX *ctx, unsigned char *data,
{
return EVP_DigestUpdate(ctx, data, count);
}
+LCRYPTO_ALIAS(PEM_SignUpdate);
int
PEM_SignFinal(EVP_MD_CTX *ctx, unsigned char *sigret, unsigned int *siglen,
free(m);
return (ret);
}
+LCRYPTO_ALIAS(PEM_SignFinal);
-/* $OpenBSD: pem_x509.c,v 1.8 2016/09/04 16:10:38 jsing Exp $ */
+/* $OpenBSD: pem_x509.c,v 1.9 2023/07/07 13:40:44 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2001.
*/
return PEM_ASN1_read((d2i_of_void *)d2i_X509, PEM_STRING_X509, fp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_X509);
int
PEM_write_X509(FILE *fp, X509 *x)
return PEM_ASN1_write((i2d_of_void *)i2d_X509, PEM_STRING_X509, fp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_X509);
X509 *
PEM_read_bio_X509(BIO *bp, X509 **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read_bio((d2i_of_void *)d2i_X509, PEM_STRING_X509, bp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_bio_X509);
int
PEM_write_bio_X509(BIO *bp, X509 *x)
return PEM_ASN1_write_bio((i2d_of_void *)i2d_X509, PEM_STRING_X509, bp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_bio_X509);
-/* $OpenBSD: pem_xaux.c,v 1.10 2021/10/31 16:28:50 tb Exp $ */
+/* $OpenBSD: pem_xaux.c,v 1.11 2023/07/07 13:40:44 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2001.
*/
return PEM_ASN1_read((d2i_of_void *)d2i_X509_AUX, PEM_STRING_X509_TRUSTED, fp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_X509_AUX);
int
PEM_write_X509_AUX(FILE *fp, X509 *x)
return PEM_ASN1_write((i2d_of_void *)i2d_X509_AUX, PEM_STRING_X509_TRUSTED, fp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_X509_AUX);
X509 *
PEM_read_bio_X509_AUX(BIO *bp, X509 **x, pem_password_cb *cb, void *u)
return PEM_ASN1_read_bio((d2i_of_void *)d2i_X509_AUX, PEM_STRING_X509_TRUSTED, bp,
(void **)x, cb, u);
}
+LCRYPTO_ALIAS(PEM_read_bio_X509_AUX);
int
PEM_write_bio_X509_AUX(BIO *bp, X509 *x)
return PEM_ASN1_write_bio((i2d_of_void *)i2d_X509_AUX, PEM_STRING_X509_TRUSTED, bp,
x, NULL, NULL, 0, NULL, NULL);
}
+LCRYPTO_ALIAS(PEM_write_bio_X509_AUX);
-/* $OpenBSD: pvkfmt.c,v 1.26 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: pvkfmt.c,v 1.27 2023/07/07 13:40:44 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2005.
*/
{
return do_b2i(in, length, 0);
}
+LCRYPTO_ALIAS(b2i_PrivateKey);
EVP_PKEY *
b2i_PublicKey(const unsigned char **in, long length)
{
return do_b2i(in, length, 1);
}
+LCRYPTO_ALIAS(b2i_PublicKey);
EVP_PKEY *
b2i_PrivateKey_bio(BIO *in)
{
return do_b2i_bio(in, 0);
}
+LCRYPTO_ALIAS(b2i_PrivateKey_bio);
EVP_PKEY *
b2i_PublicKey_bio(BIO *in)
{
return do_b2i_bio(in, 1);
}
+LCRYPTO_ALIAS(b2i_PublicKey_bio);
static void
write_ledword(unsigned char **out, unsigned int dw)
{
return do_i2b_bio(out, pk, 0);
}
+LCRYPTO_ALIAS(i2b_PrivateKey_bio);
int
i2b_PublicKey_bio(BIO *out, EVP_PKEY *pk)
{
return do_i2b_bio(out, pk, 1);
}
+LCRYPTO_ALIAS(i2b_PublicKey_bio);
#ifndef OPENSSL_NO_RC4
freezero(buf, buflen);
return ret;
}
+LCRYPTO_ALIAS(b2i_PVK_bio);
static int
i2b_PVK(unsigned char **out, EVP_PKEY*pk, int enclevel, pem_password_cb *cb,
}
return outlen;
}
+LCRYPTO_ALIAS(i2b_PVK_bio);
#endif
-/* $OpenBSD: rc2_cbc.c,v 1.7 2023/07/07 08:29:37 beck Exp $ */
+/* $OpenBSD: rc2_cbc.c,v 1.8 2023/07/07 13:40:44 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
tin0 = tin1 = tout0 = tout1 = xor0 = xor1 = 0;
tin[0] = tin[1] = 0;
}
+LCRYPTO_ALIAS(RC2_cbc_encrypt);
void
RC2_encrypt(unsigned long *d, RC2_KEY *key)
d[1] = (unsigned long)(x2 & 0xffff)|((unsigned long)(x3 & 0xffff) <<
16L);
}
+LCRYPTO_ALIAS(RC2_encrypt);
void
RC2_decrypt(unsigned long *d, RC2_KEY *key)
d[1] = (unsigned long)(x2 & 0xffff)|((unsigned long)(x3 & 0xffff) <<
16L);
}
+LCRYPTO_ALIAS(RC2_decrypt);
-/* $OpenBSD: rc2_ecb.c,v 1.8 2023/07/07 08:29:37 beck Exp $ */
+/* $OpenBSD: rc2_ecb.c,v 1.9 2023/07/07 13:40:44 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
l2c(l, out);
l = d[0] = d[1] = 0;
}
+LCRYPTO_ALIAS(RC2_ecb_encrypt);
-/* $OpenBSD: rc2_skey.c,v 1.14 2023/07/07 08:29:37 beck Exp $ */
+/* $OpenBSD: rc2_skey.c,v 1.15 2023/07/07 13:40:44 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
for (i = 127; i >= 0; i -= 2)
*(ki--) = ((k[i] << 8)|k[i - 1]) & 0xffff;
}
+LCRYPTO_ALIAS(RC2_set_key);
-/* $OpenBSD: rc2cfb64.c,v 1.7 2023/07/07 08:29:37 beck Exp $ */
+/* $OpenBSD: rc2cfb64.c,v 1.8 2023/07/07 13:40:44 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
v0 = v1 = ti[0] = ti[1] = t = c = cc = 0;
*num = n;
}
+LCRYPTO_ALIAS(RC2_cfb64_encrypt);
-/* $OpenBSD: rc2ofb64.c,v 1.7 2023/07/07 08:29:37 beck Exp $ */
+/* $OpenBSD: rc2ofb64.c,v 1.8 2023/07/07 13:40:44 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
t = v0 = v1 = ti[0] = ti[1] = 0;
*num = n;
}
+LCRYPTO_ALIAS(RC2_ofb64_encrypt);
projects / openbsd / commitdiff