factotum/libressl-portable
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

check in v3.8.2 source

Browse Source
This commit is contained in:
torque
2023-11-06 23:46:37 -08:00
parent e2db88c634
commit 2b68369a2b
1216 changed files with 563118 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

253
crypto/hidden/openssl/asn1.h Normal file
View File

@@ -0,0 +1,253 @@
/* $OpenBSD: asn1.h,v 1.6 2023/07/28 10:33:13 tb 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_ASN1_H
#define _LIBCRYPTO_ASN1_H
#ifndef _MSC_VER
#include_next <openssl/asn1.h>
#else
#include "../include/openssl/asn1.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(d2i_ASN1_SEQUENCE_ANY);
LCRYPTO_USED(i2d_ASN1_SEQUENCE_ANY);
LCRYPTO_USED(d2i_ASN1_SET_ANY);
LCRYPTO_USED(i2d_ASN1_SET_ANY);
LCRYPTO_USED(ASN1_TYPE_new);
LCRYPTO_USED(ASN1_TYPE_free);
LCRYPTO_USED(d2i_ASN1_TYPE);
LCRYPTO_USED(i2d_ASN1_TYPE);
LCRYPTO_USED(ASN1_TYPE_get);
LCRYPTO_USED(ASN1_TYPE_set);
LCRYPTO_USED(ASN1_TYPE_set1);
LCRYPTO_USED(ASN1_TYPE_cmp);
LCRYPTO_USED(ASN1_OBJECT_new);
LCRYPTO_USED(ASN1_OBJECT_free);
LCRYPTO_USED(i2d_ASN1_OBJECT);
LCRYPTO_USED(d2i_ASN1_OBJECT);
LCRYPTO_USED(ASN1_STRING_new);
LCRYPTO_USED(ASN1_STRING_free);
LCRYPTO_USED(ASN1_STRING_copy);
LCRYPTO_USED(ASN1_STRING_dup);
LCRYPTO_USED(ASN1_STRING_type_new);
LCRYPTO_USED(ASN1_STRING_cmp);
LCRYPTO_USED(ASN1_STRING_set);
LCRYPTO_USED(ASN1_STRING_set0);
LCRYPTO_USED(ASN1_STRING_length);
LCRYPTO_USED(ASN1_STRING_length_set);
LCRYPTO_USED(ASN1_STRING_type);
LCRYPTO_USED(ASN1_STRING_data);
LCRYPTO_USED(ASN1_STRING_get0_data);
LCRYPTO_USED(ASN1_BIT_STRING_new);
LCRYPTO_USED(ASN1_BIT_STRING_free);
LCRYPTO_USED(d2i_ASN1_BIT_STRING);
LCRYPTO_USED(i2d_ASN1_BIT_STRING);
LCRYPTO_USED(ASN1_BIT_STRING_set);
LCRYPTO_USED(ASN1_BIT_STRING_set_bit);
LCRYPTO_USED(ASN1_BIT_STRING_get_bit);
LCRYPTO_USED(ASN1_INTEGER_new);
LCRYPTO_USED(ASN1_INTEGER_free);
LCRYPTO_USED(d2i_ASN1_INTEGER);
LCRYPTO_USED(i2d_ASN1_INTEGER);
LCRYPTO_USED(d2i_ASN1_UINTEGER);
LCRYPTO_USED(ASN1_INTEGER_dup);
LCRYPTO_USED(ASN1_INTEGER_cmp);
LCRYPTO_USED(ASN1_ENUMERATED_new);
LCRYPTO_USED(ASN1_ENUMERATED_free);
LCRYPTO_USED(d2i_ASN1_ENUMERATED);
LCRYPTO_USED(i2d_ASN1_ENUMERATED);
LCRYPTO_USED(ASN1_UTCTIME_check);
LCRYPTO_USED(ASN1_UTCTIME_set);
LCRYPTO_USED(ASN1_UTCTIME_adj);
LCRYPTO_USED(ASN1_UTCTIME_set_string);
LCRYPTO_USED(ASN1_GENERALIZEDTIME_check);
LCRYPTO_USED(ASN1_GENERALIZEDTIME_set);
LCRYPTO_USED(ASN1_GENERALIZEDTIME_adj);
LCRYPTO_USED(ASN1_GENERALIZEDTIME_set_string);
LCRYPTO_USED(ASN1_OCTET_STRING_new);
LCRYPTO_USED(ASN1_OCTET_STRING_free);
LCRYPTO_USED(d2i_ASN1_OCTET_STRING);
LCRYPTO_USED(i2d_ASN1_OCTET_STRING);
LCRYPTO_USED(ASN1_OCTET_STRING_dup);
LCRYPTO_USED(ASN1_OCTET_STRING_cmp);
LCRYPTO_USED(ASN1_OCTET_STRING_set);
LCRYPTO_USED(ASN1_VISIBLESTRING_new);
LCRYPTO_USED(ASN1_VISIBLESTRING_free);
LCRYPTO_USED(d2i_ASN1_VISIBLESTRING);
LCRYPTO_USED(i2d_ASN1_VISIBLESTRING);
LCRYPTO_USED(ASN1_UNIVERSALSTRING_new);
LCRYPTO_USED(ASN1_UNIVERSALSTRING_free);
LCRYPTO_USED(d2i_ASN1_UNIVERSALSTRING);
LCRYPTO_USED(i2d_ASN1_UNIVERSALSTRING);
LCRYPTO_USED(ASN1_UTF8STRING_new);
LCRYPTO_USED(ASN1_UTF8STRING_free);
LCRYPTO_USED(d2i_ASN1_UTF8STRING);
LCRYPTO_USED(i2d_ASN1_UTF8STRING);
LCRYPTO_USED(ASN1_NULL_new);
LCRYPTO_USED(ASN1_NULL_free);
LCRYPTO_USED(d2i_ASN1_NULL);
LCRYPTO_USED(i2d_ASN1_NULL);
LCRYPTO_USED(ASN1_BMPSTRING_new);
LCRYPTO_USED(ASN1_BMPSTRING_free);
LCRYPTO_USED(d2i_ASN1_BMPSTRING);
LCRYPTO_USED(i2d_ASN1_BMPSTRING);
LCRYPTO_USED(ASN1_PRINTABLE_new);
LCRYPTO_USED(ASN1_PRINTABLE_free);
LCRYPTO_USED(d2i_ASN1_PRINTABLE);
LCRYPTO_USED(i2d_ASN1_PRINTABLE);
LCRYPTO_USED(DIRECTORYSTRING_new);
LCRYPTO_USED(DIRECTORYSTRING_free);
LCRYPTO_USED(d2i_DIRECTORYSTRING);
LCRYPTO_USED(i2d_DIRECTORYSTRING);
LCRYPTO_USED(DISPLAYTEXT_new);
LCRYPTO_USED(DISPLAYTEXT_free);
LCRYPTO_USED(d2i_DISPLAYTEXT);
LCRYPTO_USED(i2d_DISPLAYTEXT);
LCRYPTO_USED(ASN1_PRINTABLESTRING_new);
LCRYPTO_USED(ASN1_PRINTABLESTRING_free);
LCRYPTO_USED(d2i_ASN1_PRINTABLESTRING);
LCRYPTO_USED(i2d_ASN1_PRINTABLESTRING);
LCRYPTO_USED(ASN1_T61STRING_new);
LCRYPTO_USED(ASN1_T61STRING_free);
LCRYPTO_USED(d2i_ASN1_T61STRING);
LCRYPTO_USED(i2d_ASN1_T61STRING);
LCRYPTO_USED(ASN1_IA5STRING_new);
LCRYPTO_USED(ASN1_IA5STRING_free);
LCRYPTO_USED(d2i_ASN1_IA5STRING);
LCRYPTO_USED(i2d_ASN1_IA5STRING);
LCRYPTO_USED(ASN1_GENERALSTRING_new);
LCRYPTO_USED(ASN1_GENERALSTRING_free);
LCRYPTO_USED(d2i_ASN1_GENERALSTRING);
LCRYPTO_USED(i2d_ASN1_GENERALSTRING);
LCRYPTO_USED(ASN1_UTCTIME_new);
LCRYPTO_USED(ASN1_UTCTIME_free);
LCRYPTO_USED(d2i_ASN1_UTCTIME);
LCRYPTO_USED(i2d_ASN1_UTCTIME);
LCRYPTO_USED(ASN1_GENERALIZEDTIME_new);
LCRYPTO_USED(ASN1_GENERALIZEDTIME_free);
LCRYPTO_USED(d2i_ASN1_GENERALIZEDTIME);
LCRYPTO_USED(i2d_ASN1_GENERALIZEDTIME);
LCRYPTO_USED(ASN1_TIME_new);
LCRYPTO_USED(ASN1_TIME_free);
LCRYPTO_USED(d2i_ASN1_TIME);
LCRYPTO_USED(i2d_ASN1_TIME);
LCRYPTO_USED(ASN1_TIME_to_tm);
LCRYPTO_USED(ASN1_TIME_compare);
LCRYPTO_USED(ASN1_TIME_cmp_time_t);
LCRYPTO_USED(ASN1_TIME_normalize);
LCRYPTO_USED(ASN1_TIME_set_string_X509);
LCRYPTO_USED(ASN1_TIME_diff);
LCRYPTO_USED(ASN1_TIME_set);
LCRYPTO_USED(ASN1_TIME_set_tm);
LCRYPTO_USED(ASN1_TIME_adj);
LCRYPTO_USED(ASN1_TIME_check);
LCRYPTO_USED(ASN1_TIME_to_generalizedtime);
LCRYPTO_USED(ASN1_TIME_set_string);
LCRYPTO_USED(i2a_ASN1_INTEGER);
LCRYPTO_USED(a2i_ASN1_INTEGER);
LCRYPTO_USED(i2a_ASN1_ENUMERATED);
LCRYPTO_USED(a2i_ASN1_ENUMERATED);
LCRYPTO_USED(i2a_ASN1_OBJECT);
LCRYPTO_USED(a2i_ASN1_STRING);
LCRYPTO_USED(i2a_ASN1_STRING);
LCRYPTO_USED(i2t_ASN1_OBJECT);
LCRYPTO_USED(a2d_ASN1_OBJECT);
LCRYPTO_USED(ASN1_OBJECT_create);
LCRYPTO_USED(ASN1_INTEGER_get_uint64);
LCRYPTO_USED(ASN1_INTEGER_set_uint64);
LCRYPTO_USED(ASN1_INTEGER_get_int64);
LCRYPTO_USED(ASN1_INTEGER_set_int64);
LCRYPTO_USED(ASN1_INTEGER_set);
LCRYPTO_USED(ASN1_INTEGER_get);
LCRYPTO_USED(BN_to_ASN1_INTEGER);
LCRYPTO_USED(ASN1_INTEGER_to_BN);
LCRYPTO_USED(ASN1_ENUMERATED_get_int64);
LCRYPTO_USED(ASN1_ENUMERATED_set_int64);
LCRYPTO_USED(ASN1_ENUMERATED_set);
LCRYPTO_USED(ASN1_ENUMERATED_get);
LCRYPTO_USED(BN_to_ASN1_ENUMERATED);
LCRYPTO_USED(ASN1_ENUMERATED_to_BN);
LCRYPTO_USED(ASN1_PRINTABLE_type);
LCRYPTO_USED(ASN1_get_object);
LCRYPTO_USED(ASN1_put_object);
LCRYPTO_USED(ASN1_put_eoc);
LCRYPTO_USED(ASN1_object_size);
LCRYPTO_USED(ASN1_item_dup);
LCRYPTO_USED(ASN1_d2i_fp);
LCRYPTO_USED(ASN1_item_d2i_fp);
LCRYPTO_USED(ASN1_i2d_fp);
LCRYPTO_USED(ASN1_item_i2d_fp);
LCRYPTO_USED(ASN1_STRING_print_ex_fp);
LCRYPTO_USED(ASN1_STRING_to_UTF8);
LCRYPTO_USED(ASN1_d2i_bio);
LCRYPTO_USED(ASN1_item_d2i_bio);
LCRYPTO_USED(ASN1_i2d_bio);
LCRYPTO_USED(ASN1_item_i2d_bio);
LCRYPTO_USED(ASN1_UTCTIME_print);
LCRYPTO_USED(ASN1_GENERALIZEDTIME_print);
LCRYPTO_USED(ASN1_TIME_print);
LCRYPTO_USED(ASN1_STRING_print);
LCRYPTO_USED(ASN1_STRING_print_ex);
LCRYPTO_USED(ASN1_parse);
LCRYPTO_USED(ASN1_parse_dump);
LCRYPTO_USED(ASN1_tag2bit);
LCRYPTO_USED(ASN1_tag2str);
LCRYPTO_USED(ASN1_UNIVERSALSTRING_to_string);
LCRYPTO_USED(ASN1_TYPE_set_octetstring);
LCRYPTO_USED(ASN1_TYPE_get_octetstring);
LCRYPTO_USED(ASN1_TYPE_set_int_octetstring);
LCRYPTO_USED(ASN1_TYPE_get_int_octetstring);
LCRYPTO_USED(ASN1_item_pack);
LCRYPTO_USED(ASN1_item_unpack);
LCRYPTO_USED(ASN1_STRING_set_default_mask);
LCRYPTO_USED(ASN1_STRING_set_default_mask_asc);
LCRYPTO_USED(ASN1_STRING_get_default_mask);
LCRYPTO_USED(ASN1_mbstring_copy);
LCRYPTO_USED(ASN1_mbstring_ncopy);
LCRYPTO_USED(ASN1_STRING_set_by_NID);
LCRYPTO_USED(ASN1_STRING_TABLE_get);
LCRYPTO_USED(ASN1_STRING_TABLE_add);
LCRYPTO_USED(ASN1_STRING_TABLE_cleanup);
LCRYPTO_USED(ASN1_item_new);
LCRYPTO_USED(ASN1_item_free);
LCRYPTO_USED(ASN1_item_d2i);
LCRYPTO_USED(ASN1_item_i2d);
LCRYPTO_USED(ASN1_add_oid_module);
LCRYPTO_USED(ASN1_generate_nconf);
LCRYPTO_USED(ASN1_generate_v3);
LCRYPTO_USED(ASN1_item_print);
LCRYPTO_USED(ASN1_PCTX_new);
LCRYPTO_USED(ASN1_PCTX_free);
LCRYPTO_USED(ASN1_PCTX_get_flags);
LCRYPTO_USED(ASN1_PCTX_set_flags);
LCRYPTO_USED(ASN1_PCTX_get_nm_flags);
LCRYPTO_USED(ASN1_PCTX_set_nm_flags);
LCRYPTO_USED(ASN1_PCTX_get_cert_flags);
LCRYPTO_USED(ASN1_PCTX_set_cert_flags);
LCRYPTO_USED(ASN1_PCTX_get_oid_flags);
LCRYPTO_USED(ASN1_PCTX_set_oid_flags);
LCRYPTO_USED(ASN1_PCTX_get_str_flags);
LCRYPTO_USED(ASN1_PCTX_set_str_flags);
LCRYPTO_USED(SMIME_crlf_copy);
LCRYPTO_USED(SMIME_text);
LCRYPTO_USED(ERR_load_ASN1_strings);
LCRYPTO_USED(ASN1_time_parse);
LCRYPTO_USED(ASN1_time_tm_cmp);
#endif /* _LIBCRYPTO_ASN1_H */

33
crypto/hidden/openssl/asn1t.h Normal file
View File

@@ -0,0 +1,33 @@
/* $OpenBSD: asn1t.h,v 1.3 2023/07/28 10:00:10 tb 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_ASN1T_H
#define _LIBCRYPTO_ASN1T_H
#ifndef _MSC_VER
#include_next <openssl/asn1t.h>
#else
#include "../include/openssl/asn1t.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(ASN1_item_ex_new);
LCRYPTO_USED(ASN1_item_ex_free);
LCRYPTO_USED(ASN1_item_ex_d2i);
LCRYPTO_USED(ASN1_item_ex_i2d);
#endif /* _LIBCRYPTO_ASN1T_H */

146
crypto/hidden/openssl/bio.h Normal file
View File

@@ -0,0 +1,146 @@
/* $OpenBSD: bio.h,v 1.4 2023/07/28 10:13:50 tb 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_BIO_H
#define _LIBCRYPTO_BIO_H
#ifndef _MSC_VER
#include_next <openssl/bio.h>
#else
#include "../include/openssl/bio.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(BIO_set_flags);
LCRYPTO_USED(BIO_test_flags);
LCRYPTO_USED(BIO_clear_flags);
LCRYPTO_USED(BIO_get_callback);
LCRYPTO_USED(BIO_set_callback);
LCRYPTO_USED(BIO_get_callback_ex);
LCRYPTO_USED(BIO_set_callback_ex);
LCRYPTO_USED(BIO_get_callback_arg);
LCRYPTO_USED(BIO_set_callback_arg);
LCRYPTO_USED(BIO_method_name);
LCRYPTO_USED(BIO_method_type);
LCRYPTO_USED(BIO_meth_new);
LCRYPTO_USED(BIO_meth_free);
LCRYPTO_USED(BIO_meth_get_write);
LCRYPTO_USED(BIO_meth_set_write);
LCRYPTO_USED(BIO_meth_get_read);
LCRYPTO_USED(BIO_meth_set_read);
LCRYPTO_USED(BIO_meth_get_puts);
LCRYPTO_USED(BIO_meth_set_puts);
LCRYPTO_USED(BIO_meth_get_gets);
LCRYPTO_USED(BIO_meth_set_gets);
LCRYPTO_USED(BIO_meth_get_ctrl);
LCRYPTO_USED(BIO_meth_set_ctrl);
LCRYPTO_USED(BIO_meth_get_create);
LCRYPTO_USED(BIO_meth_set_create);
LCRYPTO_USED(BIO_meth_get_destroy);
LCRYPTO_USED(BIO_meth_set_destroy);
LCRYPTO_USED(BIO_meth_get_callback_ctrl);
LCRYPTO_USED(BIO_meth_set_callback_ctrl);
LCRYPTO_USED(BIO_ctrl_pending);
LCRYPTO_USED(BIO_ctrl_wpending);
LCRYPTO_USED(BIO_ctrl_get_write_guarantee);
LCRYPTO_USED(BIO_ctrl_get_read_request);
LCRYPTO_USED(BIO_ctrl_reset_read_request);
LCRYPTO_USED(BIO_set_ex_data);
LCRYPTO_USED(BIO_get_ex_data);
LCRYPTO_USED(BIO_number_read);
LCRYPTO_USED(BIO_number_written);
LCRYPTO_USED(BIO_get_new_index);
LCRYPTO_USED(BIO_s_file);
LCRYPTO_USED(BIO_new_file);
LCRYPTO_USED(BIO_new_fp);
LCRYPTO_USED(BIO_new);
LCRYPTO_USED(BIO_set);
LCRYPTO_USED(BIO_free);
LCRYPTO_USED(BIO_up_ref);
LCRYPTO_USED(BIO_get_data);
LCRYPTO_USED(BIO_set_data);
LCRYPTO_USED(BIO_get_init);
LCRYPTO_USED(BIO_set_init);
LCRYPTO_USED(BIO_get_shutdown);
LCRYPTO_USED(BIO_set_shutdown);
LCRYPTO_USED(BIO_vfree);
LCRYPTO_USED(BIO_read);
LCRYPTO_USED(BIO_gets);
LCRYPTO_USED(BIO_write);
LCRYPTO_USED(BIO_puts);
LCRYPTO_USED(BIO_indent);
LCRYPTO_USED(BIO_ctrl);
LCRYPTO_USED(BIO_callback_ctrl);
LCRYPTO_USED(BIO_ptr_ctrl);
LCRYPTO_USED(BIO_int_ctrl);
LCRYPTO_USED(BIO_push);
LCRYPTO_USED(BIO_pop);
LCRYPTO_USED(BIO_free_all);
LCRYPTO_USED(BIO_find_type);
LCRYPTO_USED(BIO_next);
LCRYPTO_USED(BIO_set_next);
LCRYPTO_USED(BIO_get_retry_BIO);
LCRYPTO_USED(BIO_get_retry_reason);
LCRYPTO_USED(BIO_set_retry_reason);
LCRYPTO_USED(BIO_dup_chain);
LCRYPTO_USED(BIO_debug_callback);
LCRYPTO_USED(BIO_s_mem);
LCRYPTO_USED(BIO_new_mem_buf);
LCRYPTO_USED(BIO_s_socket);
LCRYPTO_USED(BIO_s_connect);
LCRYPTO_USED(BIO_s_accept);
LCRYPTO_USED(BIO_s_fd);
LCRYPTO_USED(BIO_s_log);
LCRYPTO_USED(BIO_s_bio);
LCRYPTO_USED(BIO_s_null);
LCRYPTO_USED(BIO_f_null);
LCRYPTO_USED(BIO_f_buffer);
LCRYPTO_USED(BIO_f_nbio_test);
LCRYPTO_USED(BIO_s_datagram);
LCRYPTO_USED(BIO_sock_should_retry);
LCRYPTO_USED(BIO_sock_non_fatal_error);
LCRYPTO_USED(BIO_dgram_non_fatal_error);
LCRYPTO_USED(BIO_fd_should_retry);
LCRYPTO_USED(BIO_fd_non_fatal_error);
LCRYPTO_USED(BIO_dump);
LCRYPTO_USED(BIO_dump_indent);
LCRYPTO_USED(BIO_dump_fp);
LCRYPTO_USED(BIO_dump_indent_fp);
LCRYPTO_USED(BIO_gethostbyname);
LCRYPTO_USED(BIO_sock_error);
LCRYPTO_USED(BIO_socket_ioctl);
LCRYPTO_USED(BIO_socket_nbio);
LCRYPTO_USED(BIO_get_port);
LCRYPTO_USED(BIO_get_host_ip);
LCRYPTO_USED(BIO_get_accept_socket);
LCRYPTO_USED(BIO_accept);
LCRYPTO_USED(BIO_sock_init);
LCRYPTO_USED(BIO_sock_cleanup);
LCRYPTO_USED(BIO_set_tcp_ndelay);
LCRYPTO_USED(BIO_new_socket);
LCRYPTO_USED(BIO_new_dgram);
LCRYPTO_USED(BIO_new_fd);
LCRYPTO_USED(BIO_new_connect);
LCRYPTO_USED(BIO_new_accept);
LCRYPTO_USED(BIO_copy_next_retry);
LCRYPTO_USED(BIO_printf);
LCRYPTO_USED(BIO_vprintf);
LCRYPTO_USED(BIO_snprintf);
LCRYPTO_USED(BIO_vsnprintf);
LCRYPTO_USED(ERR_load_BIO_strings);
#endif /* _LIBCRYPTO_BIO_H */

143
crypto/hidden/openssl/bn.h Normal file
View File

@@ -0,0 +1,143 @@
/* $OpenBSD: bn.h,v 1.4 2023/07/29 03:13:38 tb 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_BN_H
#define _LIBCRYPTO_BN_H
#ifndef _MSC_VER
#include_next <openssl/bn.h>
#else
#include "../include/openssl/bn.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(BN_set_flags);
LCRYPTO_USED(BN_get_flags);
LCRYPTO_USED(BN_with_flags);
LCRYPTO_USED(BN_GENCB_new);
LCRYPTO_USED(BN_GENCB_free);
LCRYPTO_USED(BN_GENCB_call);
LCRYPTO_USED(BN_GENCB_set_old);
LCRYPTO_USED(BN_GENCB_set);
LCRYPTO_USED(BN_GENCB_get_arg);
LCRYPTO_USED(BN_abs_is_word);
LCRYPTO_USED(BN_is_zero);
LCRYPTO_USED(BN_is_one);
LCRYPTO_USED(BN_is_word);
LCRYPTO_USED(BN_is_odd);
LCRYPTO_USED(BN_zero);
LCRYPTO_USED(BN_one);
LCRYPTO_USED(BN_value_one);
LCRYPTO_USED(BN_CTX_new);
LCRYPTO_USED(BN_CTX_free);
LCRYPTO_USED(BN_CTX_start);
LCRYPTO_USED(BN_CTX_get);
LCRYPTO_USED(BN_CTX_end);
LCRYPTO_USED(BN_rand);
LCRYPTO_USED(BN_pseudo_rand);
LCRYPTO_USED(BN_rand_range);
LCRYPTO_USED(BN_pseudo_rand_range);
LCRYPTO_USED(BN_num_bits);
LCRYPTO_USED(BN_num_bits_word);
LCRYPTO_USED(BN_new);
LCRYPTO_USED(BN_clear_free);
LCRYPTO_USED(BN_copy);
LCRYPTO_USED(BN_swap);
LCRYPTO_USED(BN_bin2bn);
LCRYPTO_USED(BN_bn2bin);
LCRYPTO_USED(BN_bn2binpad);
LCRYPTO_USED(BN_lebin2bn);
LCRYPTO_USED(BN_bn2lebinpad);
LCRYPTO_USED(BN_mpi2bn);
LCRYPTO_USED(BN_bn2mpi);
LCRYPTO_USED(BN_sub);
LCRYPTO_USED(BN_usub);
LCRYPTO_USED(BN_uadd);
LCRYPTO_USED(BN_add);
LCRYPTO_USED(BN_mul);
LCRYPTO_USED(BN_sqr);
LCRYPTO_USED(BN_set_negative);
LCRYPTO_USED(BN_is_negative);
LCRYPTO_USED(BN_nnmod);
LCRYPTO_USED(BN_mod_add);
LCRYPTO_USED(BN_mod_add_quick);
LCRYPTO_USED(BN_mod_sub);
LCRYPTO_USED(BN_mod_sub_quick);
LCRYPTO_USED(BN_mod_mul);
LCRYPTO_USED(BN_mod_sqr);
LCRYPTO_USED(BN_mod_lshift1);
LCRYPTO_USED(BN_mod_lshift1_quick);
LCRYPTO_USED(BN_mod_lshift);
LCRYPTO_USED(BN_mod_lshift_quick);
LCRYPTO_USED(BN_mod_word);
LCRYPTO_USED(BN_div_word);
LCRYPTO_USED(BN_mul_word);
LCRYPTO_USED(BN_add_word);
LCRYPTO_USED(BN_sub_word);
LCRYPTO_USED(BN_set_word);
LCRYPTO_USED(BN_get_word);
LCRYPTO_USED(BN_cmp);
LCRYPTO_USED(BN_free);
LCRYPTO_USED(BN_is_bit_set);
LCRYPTO_USED(BN_lshift);
LCRYPTO_USED(BN_lshift1);
LCRYPTO_USED(BN_exp);
LCRYPTO_USED(BN_mod_exp_mont_consttime);
LCRYPTO_USED(BN_mod_exp_mont_word);
LCRYPTO_USED(BN_mod_exp2_mont);
LCRYPTO_USED(BN_mod_exp_simple);
LCRYPTO_USED(BN_mask_bits);
LCRYPTO_USED(BN_print_fp);
LCRYPTO_USED(BN_print);
LCRYPTO_USED(BN_rshift);
LCRYPTO_USED(BN_rshift1);
LCRYPTO_USED(BN_clear);
LCRYPTO_USED(BN_dup);
LCRYPTO_USED(BN_ucmp);
LCRYPTO_USED(BN_set_bit);
LCRYPTO_USED(BN_clear_bit);
LCRYPTO_USED(BN_bn2hex);
LCRYPTO_USED(BN_bn2dec);
LCRYPTO_USED(BN_hex2bn);
LCRYPTO_USED(BN_dec2bn);
LCRYPTO_USED(BN_asc2bn);
LCRYPTO_USED(BN_kronecker);
LCRYPTO_USED(BN_mod_sqrt);
LCRYPTO_USED(BN_consttime_swap);
LCRYPTO_USED(BN_security_bits);
LCRYPTO_USED(BN_generate_prime_ex);
LCRYPTO_USED(BN_is_prime_ex);
LCRYPTO_USED(BN_is_prime_fasttest_ex);
LCRYPTO_USED(BN_MONT_CTX_new);
LCRYPTO_USED(BN_mod_mul_montgomery);
LCRYPTO_USED(BN_to_montgomery);
LCRYPTO_USED(BN_from_montgomery);
LCRYPTO_USED(BN_MONT_CTX_free);
LCRYPTO_USED(BN_MONT_CTX_set);
LCRYPTO_USED(BN_MONT_CTX_copy);
LCRYPTO_USED(BN_MONT_CTX_set_locked);
LCRYPTO_USED(BN_get_rfc2409_prime_768);
LCRYPTO_USED(BN_get_rfc2409_prime_1024);
LCRYPTO_USED(BN_get_rfc3526_prime_1536);
LCRYPTO_USED(BN_get_rfc3526_prime_2048);
LCRYPTO_USED(BN_get_rfc3526_prime_3072);
LCRYPTO_USED(BN_get_rfc3526_prime_4096);
LCRYPTO_USED(BN_get_rfc3526_prime_6144);
LCRYPTO_USED(BN_get_rfc3526_prime_8192);
LCRYPTO_USED(ERR_load_BN_strings);
#endif /* _LIBCRYPTO_BN_H */

34
crypto/hidden/openssl/buffer.h Normal file
View File

@@ -0,0 +1,34 @@
/* $OpenBSD: buffer.h,v 1.1 2023/07/08 08:26:26 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_BUFFER_H
#define _LIBCRYPTO_BUFFER_H
#ifndef _MSC_VER
#include_next <openssl/buffer.h>
#else
#include "../include/openssl/buffer.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(BUF_MEM_new);
LCRYPTO_USED(BUF_MEM_free);
LCRYPTO_USED(BUF_MEM_grow);
LCRYPTO_USED(BUF_MEM_grow_clean);
LCRYPTO_USED(ERR_load_BUF_strings);
#endif /* _LIBCRYPTO_BUFFER_H */

36
crypto/hidden/openssl/cast.h Normal file
View File

@@ -0,0 +1,36 @@
/* $OpenBSD: cast.h,v 1.1 2023/07/08 10:44:00 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_CAST_H
#define _LIBCRYPTO_CAST_H
#ifndef _MSC_VER
#include_next <openssl/cast.h>
#else
#include "../include/openssl/cast.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(CAST_set_key);
LCRYPTO_USED(CAST_ecb_encrypt);
LCRYPTO_USED(CAST_encrypt);
LCRYPTO_USED(CAST_decrypt);
LCRYPTO_USED(CAST_cbc_encrypt);
LCRYPTO_USED(CAST_cfb64_encrypt);
LCRYPTO_USED(CAST_ofb64_encrypt);
#endif /* _LIBCRYPTO_CAST_H */

35
crypto/hidden/openssl/chacha.h Normal file
View File

@@ -0,0 +1,35 @@
/* $OpenBSD: chacha.h,v 1.3 2023/07/07 19:37:54 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_CHACHA_H
#define _LIBCRYPTO_CHACHA_H
#ifndef _MSC_VER
#include_next <openssl/chacha.h>
#else
#include "../include/openssl/chacha.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(ChaCha_set_key);
LCRYPTO_USED(ChaCha_set_iv);
LCRYPTO_USED(ChaCha);
LCRYPTO_USED(CRYPTO_chacha_20);
LCRYPTO_USED(CRYPTO_xchacha_20);
LCRYPTO_USED(CRYPTO_hchacha_20);
#endif /* _LIBCRYPTO_CHACHA_H */

38
crypto/hidden/openssl/cmac.h Normal file
View File

@@ -0,0 +1,38 @@
/* $OpenBSD: cmac.h,v 1.1 2023/07/08 14:27:14 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_CMAC_H
#define _LIBCRYPTO_CMAC_H
#ifndef _MSC_VER
#include_next <openssl/cmac.h>
#else
#include "../include/openssl/cmac.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(CMAC_CTX_new);
LCRYPTO_USED(CMAC_CTX_cleanup);
LCRYPTO_USED(CMAC_CTX_free);
LCRYPTO_USED(CMAC_CTX_get0_cipher_ctx);
LCRYPTO_USED(CMAC_CTX_copy);
LCRYPTO_USED(CMAC_Init);
LCRYPTO_USED(CMAC_Update);
LCRYPTO_USED(CMAC_Final);
LCRYPTO_USED(CMAC_resume);
#endif /* _LIBCRYPTO_CMAC_H */

148
crypto/hidden/openssl/cms.h Normal file
View File

@@ -0,0 +1,148 @@
/* $OpenBSD: cms.h,v 1.2 2023/07/28 10:28:02 tb 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_CMS_H
#define _LIBCRYPTO_CMS_H
#ifndef _MSC_VER
#include_next <openssl/cms.h>
#else
#include "../include/openssl/cms.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(CMS_ContentInfo_new);
LCRYPTO_USED(CMS_ContentInfo_free);
LCRYPTO_USED(d2i_CMS_ContentInfo);
LCRYPTO_USED(i2d_CMS_ContentInfo);
LCRYPTO_USED(CMS_ReceiptRequest_new);
LCRYPTO_USED(CMS_ReceiptRequest_free);
LCRYPTO_USED(d2i_CMS_ReceiptRequest);
LCRYPTO_USED(i2d_CMS_ReceiptRequest);
LCRYPTO_USED(CMS_ContentInfo_print_ctx);
LCRYPTO_USED(CMS_get0_type);
LCRYPTO_USED(CMS_get_version);
LCRYPTO_USED(CMS_SignerInfo_get_version);
LCRYPTO_USED(CMS_dataInit);
LCRYPTO_USED(CMS_dataFinal);
LCRYPTO_USED(CMS_is_detached);
LCRYPTO_USED(CMS_set_detached);
LCRYPTO_USED(CMS_stream);
LCRYPTO_USED(d2i_CMS_bio);
LCRYPTO_USED(i2d_CMS_bio);
LCRYPTO_USED(BIO_new_CMS);
LCRYPTO_USED(i2d_CMS_bio_stream);
LCRYPTO_USED(PEM_write_bio_CMS_stream);
LCRYPTO_USED(SMIME_read_CMS);
LCRYPTO_USED(SMIME_write_CMS);
LCRYPTO_USED(CMS_final);
LCRYPTO_USED(CMS_sign);
LCRYPTO_USED(CMS_sign_receipt);
LCRYPTO_USED(CMS_data);
LCRYPTO_USED(CMS_data_create);
LCRYPTO_USED(CMS_digest_verify);
LCRYPTO_USED(CMS_digest_create);
LCRYPTO_USED(CMS_EncryptedData_decrypt);
LCRYPTO_USED(CMS_EncryptedData_encrypt);
LCRYPTO_USED(CMS_EncryptedData_set1_key);
LCRYPTO_USED(CMS_verify);
LCRYPTO_USED(CMS_verify_receipt);
LCRYPTO_USED(CMS_get0_signers);
LCRYPTO_USED(CMS_encrypt);
LCRYPTO_USED(CMS_decrypt);
LCRYPTO_USED(CMS_decrypt_set1_pkey);
LCRYPTO_USED(CMS_decrypt_set1_key);
LCRYPTO_USED(CMS_decrypt_set1_password);
LCRYPTO_USED(CMS_get0_RecipientInfos);
LCRYPTO_USED(CMS_RecipientInfo_type);
LCRYPTO_USED(CMS_RecipientInfo_get0_pkey_ctx);
LCRYPTO_USED(CMS_EnvelopedData_create);
LCRYPTO_USED(CMS_add1_recipient_cert);
LCRYPTO_USED(CMS_RecipientInfo_set0_pkey);
LCRYPTO_USED(CMS_RecipientInfo_ktri_cert_cmp);
LCRYPTO_USED(CMS_RecipientInfo_ktri_get0_algs);
LCRYPTO_USED(CMS_RecipientInfo_ktri_get0_signer_id);
LCRYPTO_USED(CMS_add0_recipient_key);
LCRYPTO_USED(CMS_RecipientInfo_kekri_get0_id);
LCRYPTO_USED(CMS_RecipientInfo_set0_key);
LCRYPTO_USED(CMS_RecipientInfo_kekri_id_cmp);
LCRYPTO_USED(CMS_RecipientInfo_set0_password);
LCRYPTO_USED(CMS_add0_recipient_password);
LCRYPTO_USED(CMS_RecipientInfo_decrypt);
LCRYPTO_USED(CMS_RecipientInfo_encrypt);
LCRYPTO_USED(CMS_uncompress);
LCRYPTO_USED(CMS_compress);
LCRYPTO_USED(CMS_set1_eContentType);
LCRYPTO_USED(CMS_get0_eContentType);
LCRYPTO_USED(CMS_add0_CertificateChoices);
LCRYPTO_USED(CMS_add0_cert);
LCRYPTO_USED(CMS_add1_cert);
LCRYPTO_USED(CMS_get1_certs);
LCRYPTO_USED(CMS_add0_RevocationInfoChoice);
LCRYPTO_USED(CMS_add0_crl);
LCRYPTO_USED(CMS_add1_crl);
LCRYPTO_USED(CMS_get1_crls);
LCRYPTO_USED(CMS_SignedData_init);
LCRYPTO_USED(CMS_add1_signer);
LCRYPTO_USED(CMS_SignerInfo_get0_pkey_ctx);
LCRYPTO_USED(CMS_SignerInfo_get0_md_ctx);
LCRYPTO_USED(CMS_get0_SignerInfos);
LCRYPTO_USED(CMS_SignerInfo_set1_signer_cert);
LCRYPTO_USED(CMS_SignerInfo_get0_signer_id);
LCRYPTO_USED(CMS_SignerInfo_cert_cmp);
LCRYPTO_USED(CMS_set1_signers_certs);
LCRYPTO_USED(CMS_SignerInfo_get0_algs);
LCRYPTO_USED(CMS_SignerInfo_get0_signature);
LCRYPTO_USED(CMS_SignerInfo_sign);
LCRYPTO_USED(CMS_SignerInfo_verify);
LCRYPTO_USED(CMS_SignerInfo_verify_content);
LCRYPTO_USED(CMS_add_smimecap);
LCRYPTO_USED(CMS_add_simple_smimecap);
LCRYPTO_USED(CMS_add_standard_smimecap);
LCRYPTO_USED(CMS_signed_get_attr_count);
LCRYPTO_USED(CMS_signed_get_attr_by_NID);
LCRYPTO_USED(CMS_signed_get_attr_by_OBJ);
LCRYPTO_USED(CMS_signed_get_attr);
LCRYPTO_USED(CMS_signed_delete_attr);
LCRYPTO_USED(CMS_signed_add1_attr);
LCRYPTO_USED(CMS_signed_add1_attr_by_OBJ);
LCRYPTO_USED(CMS_signed_add1_attr_by_NID);
LCRYPTO_USED(CMS_signed_add1_attr_by_txt);
LCRYPTO_USED(CMS_signed_get0_data_by_OBJ);
LCRYPTO_USED(CMS_unsigned_get_attr_count);
LCRYPTO_USED(CMS_unsigned_get_attr_by_NID);
LCRYPTO_USED(CMS_unsigned_get_attr_by_OBJ);
LCRYPTO_USED(CMS_unsigned_get_attr);
LCRYPTO_USED(CMS_unsigned_delete_attr);
LCRYPTO_USED(CMS_unsigned_add1_attr);
LCRYPTO_USED(CMS_unsigned_add1_attr_by_OBJ);
LCRYPTO_USED(CMS_unsigned_add1_attr_by_NID);
LCRYPTO_USED(CMS_unsigned_add1_attr_by_txt);
LCRYPTO_USED(CMS_unsigned_get0_data_by_OBJ);
LCRYPTO_USED(CMS_RecipientInfo_kari_get0_alg);
LCRYPTO_USED(CMS_RecipientInfo_kari_get0_reks);
LCRYPTO_USED(CMS_RecipientInfo_kari_get0_orig_id);
LCRYPTO_USED(CMS_RecipientInfo_kari_orig_id_cmp);
LCRYPTO_USED(CMS_RecipientEncryptedKey_get0_id);
LCRYPTO_USED(CMS_RecipientEncryptedKey_cert_cmp);
LCRYPTO_USED(CMS_RecipientInfo_kari_set0_pkey);
LCRYPTO_USED(CMS_RecipientInfo_kari_get0_ctx);
LCRYPTO_USED(CMS_RecipientInfo_kari_decrypt);
LCRYPTO_USED(CMS_SharedInfo_encode);
LCRYPTO_USED(ERR_load_CMS_strings);
#endif /* _LIBCRYPTO_CMS_H */

36
crypto/hidden/openssl/conf_api.h Normal file
View File

@@ -0,0 +1,36 @@
/* $OpenBSD: conf_api.h,v 1.1 2023/07/08 08:26:26 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_CONF_API_H
#define _LIBCRYPTO_CONF_API_H
#ifndef _MSC_VER
#include_next <openssl/conf_api.h>
#else
#include "../include/openssl/conf_api.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(_CONF_new_section);
LCRYPTO_USED(_CONF_get_section);
LCRYPTO_USED(_CONF_get_section_values);
LCRYPTO_USED(_CONF_add_string);
LCRYPTO_USED(_CONF_get_string);
LCRYPTO_USED(_CONF_new_data);
LCRYPTO_USED(_CONF_free_data);
#endif /* _LIBCRYPTO_CONF_API_H */

76
crypto/hidden/openssl/crypto.h Normal file
View File

@@ -0,0 +1,76 @@
/* $OpenBSD: crypto.h,v 1.2 2023/07/28 10:19:20 tb 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_CRYPTO_H
#define _LIBCRYPTO_CRYPTO_H
#ifndef _MSC_VER
#include_next <openssl/crypto.h>
#else
#include "../include/openssl/crypto.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(OpenSSL_version);
LCRYPTO_USED(OpenSSL_version_num);
LCRYPTO_USED(SSLeay_version);
LCRYPTO_USED(SSLeay);
LCRYPTO_USED(CRYPTO_get_ex_new_index);
LCRYPTO_USED(CRYPTO_new_ex_data);
LCRYPTO_USED(CRYPTO_dup_ex_data);
LCRYPTO_USED(CRYPTO_free_ex_data);
LCRYPTO_USED(CRYPTO_set_ex_data);
LCRYPTO_USED(CRYPTO_get_ex_data);
LCRYPTO_USED(CRYPTO_cleanup_all_ex_data);
LCRYPTO_USED(CRYPTO_lock);
LCRYPTO_USED(CRYPTO_add_lock);
LCRYPTO_USED(CRYPTO_THREADID_current);
LCRYPTO_USED(CRYPTO_THREADID_cmp);
LCRYPTO_USED(CRYPTO_THREADID_cpy);
LCRYPTO_USED(CRYPTO_THREADID_hash);
LCRYPTO_USED(CRYPTO_set_mem_functions);
LCRYPTO_USED(CRYPTO_set_locked_mem_functions);
LCRYPTO_USED(CRYPTO_set_mem_ex_functions);
LCRYPTO_USED(CRYPTO_set_locked_mem_ex_functions);
LCRYPTO_USED(CRYPTO_set_mem_debug_functions);
LCRYPTO_USED(CRYPTO_get_mem_functions);
LCRYPTO_USED(CRYPTO_get_locked_mem_functions);
LCRYPTO_USED(CRYPTO_get_mem_ex_functions);
LCRYPTO_USED(CRYPTO_get_locked_mem_ex_functions);
LCRYPTO_USED(CRYPTO_get_mem_debug_functions);
LCRYPTO_USED(CRYPTO_realloc_clean);
LCRYPTO_USED(CRYPTO_remalloc);
LCRYPTO_USED(CRYPTO_set_mem_debug_options);
LCRYPTO_USED(CRYPTO_get_mem_debug_options);
LCRYPTO_USED(CRYPTO_push_info_);
LCRYPTO_USED(CRYPTO_pop_info);
LCRYPTO_USED(CRYPTO_remove_all_info);
LCRYPTO_USED(CRYPTO_dbg_malloc);
LCRYPTO_USED(CRYPTO_dbg_realloc);
LCRYPTO_USED(CRYPTO_dbg_free);
LCRYPTO_USED(CRYPTO_dbg_set_options);
LCRYPTO_USED(CRYPTO_dbg_get_options);
LCRYPTO_USED(CRYPTO_mem_leaks_fp);
LCRYPTO_USED(CRYPTO_mem_leaks);
LCRYPTO_USED(CRYPTO_mem_leaks_cb);
LCRYPTO_USED(OpenSSLDie);
LCRYPTO_USED(OPENSSL_cpu_caps);
LCRYPTO_USED(OPENSSL_init_crypto);
LCRYPTO_USED(OPENSSL_cleanup);
LCRYPTO_USED(ERR_load_CRYPTO_strings);
#endif /* _LIBCRYPTO_CRYPTO_H */

85
crypto/hidden/openssl/ct.h Normal file
View File

@@ -0,0 +1,85 @@
/* $OpenBSD: ct.h,v 1.1 2023/07/08 07:22:58 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_CT_H
#define _LIBCRYPTO_CT_H
#ifndef _MSC_VER
#include_next <openssl/ct.h>
#else
#include "../include/openssl/ct.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(CT_POLICY_EVAL_CTX_new);
LCRYPTO_USED(CT_POLICY_EVAL_CTX_free);
LCRYPTO_USED(CT_POLICY_EVAL_CTX_get0_cert);
LCRYPTO_USED(CT_POLICY_EVAL_CTX_set1_cert);
LCRYPTO_USED(CT_POLICY_EVAL_CTX_get0_issuer);
LCRYPTO_USED(CT_POLICY_EVAL_CTX_set1_issuer);
LCRYPTO_USED(CT_POLICY_EVAL_CTX_get0_log_store);
LCRYPTO_USED(CT_POLICY_EVAL_CTX_set_shared_CTLOG_STORE);
LCRYPTO_USED(CT_POLICY_EVAL_CTX_get_time);
LCRYPTO_USED(CT_POLICY_EVAL_CTX_set_time);
LCRYPTO_USED(SCT_new);
LCRYPTO_USED(SCT_new_from_base64);
LCRYPTO_USED(SCT_free);
LCRYPTO_USED(SCT_LIST_free);
LCRYPTO_USED(SCT_get_version);
LCRYPTO_USED(SCT_set_version);
LCRYPTO_USED(SCT_get_log_entry_type);
LCRYPTO_USED(SCT_set_log_entry_type);
LCRYPTO_USED(SCT_get0_log_id);
LCRYPTO_USED(SCT_set0_log_id);
LCRYPTO_USED(SCT_set1_log_id);
LCRYPTO_USED(SCT_get_timestamp);
LCRYPTO_USED(SCT_set_timestamp);
LCRYPTO_USED(SCT_get_signature_nid);
LCRYPTO_USED(SCT_set_signature_nid);
LCRYPTO_USED(SCT_get0_extensions);
LCRYPTO_USED(SCT_set0_extensions);
LCRYPTO_USED(SCT_set1_extensions);
LCRYPTO_USED(SCT_get0_signature);
LCRYPTO_USED(SCT_set0_signature);
LCRYPTO_USED(SCT_set1_signature);
LCRYPTO_USED(SCT_get_source);
LCRYPTO_USED(SCT_set_source);
LCRYPTO_USED(SCT_validation_status_string);
LCRYPTO_USED(SCT_print);
LCRYPTO_USED(SCT_LIST_print);
LCRYPTO_USED(SCT_get_validation_status);
LCRYPTO_USED(SCT_validate);
LCRYPTO_USED(SCT_LIST_validate);
LCRYPTO_USED(i2o_SCT_LIST);
LCRYPTO_USED(o2i_SCT_LIST);
LCRYPTO_USED(i2d_SCT_LIST);
LCRYPTO_USED(d2i_SCT_LIST);
LCRYPTO_USED(i2o_SCT);
LCRYPTO_USED(o2i_SCT);
LCRYPTO_USED(CTLOG_new);
LCRYPTO_USED(CTLOG_new_from_base64);
LCRYPTO_USED(CTLOG_free);
LCRYPTO_USED(CTLOG_get0_name);
LCRYPTO_USED(CTLOG_get0_log_id);
LCRYPTO_USED(CTLOG_get0_public_key);
LCRYPTO_USED(CTLOG_STORE_new);
LCRYPTO_USED(CTLOG_STORE_free);
LCRYPTO_USED(CTLOG_STORE_get0_log_by_id);
LCRYPTO_USED(CTLOG_STORE_load_file);
LCRYPTO_USED(CTLOG_STORE_load_default_file);
#endif /* _LIBCRYPTO_CT_H */

34
crypto/hidden/openssl/curve25519.h Normal file
View File

@@ -0,0 +1,34 @@
/* $OpenBSD: curve25519.h,v 1.1 2023/07/08 15:12:49 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_CURVE25519_H
#define _LIBCRYPTO_CURVE25519_H
#ifndef _MSC_VER
#include_next <openssl/curve25519.h>
#else
#include "../include/openssl/curve25519.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(X25519_keypair);
LCRYPTO_USED(X25519);
LCRYPTO_USED(ED25519_keypair);
LCRYPTO_USED(ED25519_sign);
LCRYPTO_USED(ED25519_verify);
#endif /* _LIBCRYPTO_CURVE25519_H */

74
crypto/hidden/openssl/dh.h Normal file
View File

@@ -0,0 +1,74 @@
/* $OpenBSD: dh.h,v 1.1 2023/07/08 15:29:04 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_DH_H
#define _LIBCRYPTO_DH_H
#ifndef _MSC_VER
#include_next <openssl/dh.h>
#else
#include "../include/openssl/dh.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(d2i_DHparams_bio);
LCRYPTO_USED(i2d_DHparams_bio);
LCRYPTO_USED(d2i_DHparams_fp);
LCRYPTO_USED(i2d_DHparams_fp);
LCRYPTO_USED(DHparams_dup);
LCRYPTO_USED(DH_OpenSSL);
LCRYPTO_USED(DH_set_default_method);
LCRYPTO_USED(DH_get_default_method);
LCRYPTO_USED(DH_set_method);
LCRYPTO_USED(DH_new_method);
LCRYPTO_USED(DH_new);
LCRYPTO_USED(DH_free);
LCRYPTO_USED(DH_up_ref);
LCRYPTO_USED(DH_size);
LCRYPTO_USED(DH_bits);
LCRYPTO_USED(DH_get_ex_new_index);
LCRYPTO_USED(DH_set_ex_data);
LCRYPTO_USED(DH_get_ex_data);
LCRYPTO_USED(DH_security_bits);
LCRYPTO_USED(DH_get0_engine);
LCRYPTO_USED(DH_get0_pqg);
LCRYPTO_USED(DH_set0_pqg);
LCRYPTO_USED(DH_get0_key);
LCRYPTO_USED(DH_set0_key);
LCRYPTO_USED(DH_get0_p);
LCRYPTO_USED(DH_get0_q);
LCRYPTO_USED(DH_get0_g);
LCRYPTO_USED(DH_get0_priv_key);
LCRYPTO_USED(DH_get0_pub_key);
LCRYPTO_USED(DH_clear_flags);
LCRYPTO_USED(DH_test_flags);
LCRYPTO_USED(DH_set_flags);
LCRYPTO_USED(DH_get_length);
LCRYPTO_USED(DH_set_length);
LCRYPTO_USED(DH_generate_parameters);
LCRYPTO_USED(DH_generate_parameters_ex);
LCRYPTO_USED(DH_check);
LCRYPTO_USED(DH_check_pub_key);
LCRYPTO_USED(DH_generate_key);
LCRYPTO_USED(DH_compute_key);
LCRYPTO_USED(d2i_DHparams);
LCRYPTO_USED(i2d_DHparams);
LCRYPTO_USED(DHparams_print_fp);
LCRYPTO_USED(DHparams_print);
LCRYPTO_USED(ERR_load_DH_strings);
#endif /* _LIBCRYPTO_DH_H */

94
crypto/hidden/openssl/dsa.h Normal file
View File

@@ -0,0 +1,94 @@
/* $OpenBSD: dsa.h,v 1.1 2023/07/08 14:28:15 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_DSA_H
#define _LIBCRYPTO_DSA_H
#ifndef _MSC_VER
#include_next <openssl/dsa.h>
#else
#include "../include/openssl/dsa.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(d2i_DSAparams_bio);
LCRYPTO_USED(i2d_DSAparams_bio);
LCRYPTO_USED(d2i_DSAparams_fp);
LCRYPTO_USED(i2d_DSAparams_fp);
LCRYPTO_USED(DSAparams_dup);
LCRYPTO_USED(DSA_SIG_new);
LCRYPTO_USED(DSA_SIG_free);
LCRYPTO_USED(i2d_DSA_SIG);
LCRYPTO_USED(d2i_DSA_SIG);
LCRYPTO_USED(DSA_SIG_get0);
LCRYPTO_USED(DSA_SIG_set0);
LCRYPTO_USED(DSA_do_sign);
LCRYPTO_USED(DSA_do_verify);
LCRYPTO_USED(DSA_OpenSSL);
LCRYPTO_USED(DSA_set_default_method);
LCRYPTO_USED(DSA_get_default_method);
LCRYPTO_USED(DSA_set_method);
LCRYPTO_USED(DSA_new);
LCRYPTO_USED(DSA_new_method);
LCRYPTO_USED(DSA_free);
LCRYPTO_USED(DSA_up_ref);
LCRYPTO_USED(DSA_size);
LCRYPTO_USED(DSA_bits);
LCRYPTO_USED(DSA_sign_setup);
LCRYPTO_USED(DSA_sign);
LCRYPTO_USED(DSA_verify);
LCRYPTO_USED(DSA_get_ex_new_index);
LCRYPTO_USED(DSA_set_ex_data);
LCRYPTO_USED(DSA_get_ex_data);
LCRYPTO_USED(DSA_security_bits);
LCRYPTO_USED(d2i_DSAPublicKey);
LCRYPTO_USED(i2d_DSAPublicKey);
LCRYPTO_USED(d2i_DSAPrivateKey);
LCRYPTO_USED(i2d_DSAPrivateKey);
LCRYPTO_USED(d2i_DSAparams);
LCRYPTO_USED(i2d_DSAparams);
LCRYPTO_USED(DSA_generate_parameters);
LCRYPTO_USED(DSA_generate_parameters_ex);
LCRYPTO_USED(DSA_generate_key);
LCRYPTO_USED(DSAparams_print);
LCRYPTO_USED(DSA_print);
LCRYPTO_USED(DSAparams_print_fp);
LCRYPTO_USED(DSA_print_fp);
LCRYPTO_USED(DSA_dup_DH);
LCRYPTO_USED(DSA_get0_pqg);
LCRYPTO_USED(DSA_set0_pqg);
LCRYPTO_USED(DSA_get0_key);
LCRYPTO_USED(DSA_set0_key);
LCRYPTO_USED(DSA_get0_p);
LCRYPTO_USED(DSA_get0_q);
LCRYPTO_USED(DSA_get0_g);
LCRYPTO_USED(DSA_get0_pub_key);
LCRYPTO_USED(DSA_get0_priv_key);
LCRYPTO_USED(DSA_clear_flags);
LCRYPTO_USED(DSA_test_flags);
LCRYPTO_USED(DSA_set_flags);
LCRYPTO_USED(DSA_get0_engine);
LCRYPTO_USED(DSA_meth_new);
LCRYPTO_USED(DSA_meth_free);
LCRYPTO_USED(DSA_meth_dup);
LCRYPTO_USED(DSA_meth_get0_name);
LCRYPTO_USED(DSA_meth_set1_name);
LCRYPTO_USED(DSA_meth_set_sign);
LCRYPTO_USED(DSA_meth_set_finish);
LCRYPTO_USED(ERR_load_DSA_strings);
#endif /* _LIBCRYPTO_DSA_H */

165
crypto/hidden/openssl/ec.h Normal file
View File

@@ -0,0 +1,165 @@
/* $OpenBSD: ec.h,v 1.4 2023/07/28 09:25:12 tb 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_EC_H
#define _LIBCRYPTO_EC_H
#ifndef _MSC_VER
#include_next <openssl/ec.h>
#else
#include "../include/openssl/ec.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(EC_GFp_simple_method);
LCRYPTO_USED(EC_GFp_mont_method);
LCRYPTO_USED(EC_GROUP_new);
LCRYPTO_USED(EC_GROUP_free);
LCRYPTO_USED(EC_GROUP_copy);
LCRYPTO_USED(EC_GROUP_dup);
LCRYPTO_USED(EC_GROUP_method_of);
LCRYPTO_USED(EC_METHOD_get_field_type);
LCRYPTO_USED(EC_GROUP_set_generator);
LCRYPTO_USED(EC_GROUP_get0_generator);
LCRYPTO_USED(EC_GROUP_get_order);
LCRYPTO_USED(EC_GROUP_order_bits);
LCRYPTO_USED(EC_GROUP_get_cofactor);
LCRYPTO_USED(EC_GROUP_set_curve_name);
LCRYPTO_USED(EC_GROUP_get_curve_name);
LCRYPTO_USED(EC_GROUP_set_asn1_flag);
LCRYPTO_USED(EC_GROUP_get_asn1_flag);
LCRYPTO_USED(EC_GROUP_set_point_conversion_form);
LCRYPTO_USED(EC_GROUP_get_point_conversion_form);
LCRYPTO_USED(EC_GROUP_get0_seed);
LCRYPTO_USED(EC_GROUP_get_seed_len);
LCRYPTO_USED(EC_GROUP_set_seed);
LCRYPTO_USED(EC_GROUP_set_curve);
LCRYPTO_USED(EC_GROUP_get_curve);
LCRYPTO_USED(EC_GROUP_get_degree);
LCRYPTO_USED(EC_GROUP_check);
LCRYPTO_USED(EC_GROUP_check_discriminant);
LCRYPTO_USED(EC_GROUP_cmp);
LCRYPTO_USED(EC_GROUP_new_curve_GFp);
LCRYPTO_USED(EC_GROUP_new_by_curve_name);
LCRYPTO_USED(EC_get_builtin_curves);
LCRYPTO_USED(EC_curve_nid2nist);
LCRYPTO_USED(EC_curve_nist2nid);
LCRYPTO_USED(EC_POINT_new);
LCRYPTO_USED(EC_POINT_free);
LCRYPTO_USED(EC_POINT_copy);
LCRYPTO_USED(EC_POINT_dup);
LCRYPTO_USED(EC_POINT_method_of);
LCRYPTO_USED(EC_POINT_set_to_infinity);
LCRYPTO_USED(EC_POINT_set_affine_coordinates);
LCRYPTO_USED(EC_POINT_get_affine_coordinates);
LCRYPTO_USED(EC_POINT_set_compressed_coordinates);
LCRYPTO_USED(EC_POINT_point2oct);
LCRYPTO_USED(EC_POINT_oct2point);
LCRYPTO_USED(EC_POINT_point2bn);
LCRYPTO_USED(EC_POINT_bn2point);
LCRYPTO_USED(EC_POINT_point2hex);
LCRYPTO_USED(EC_POINT_hex2point);
LCRYPTO_USED(EC_POINT_add);
LCRYPTO_USED(EC_POINT_dbl);
LCRYPTO_USED(EC_POINT_invert);
LCRYPTO_USED(EC_POINT_is_at_infinity);
LCRYPTO_USED(EC_POINT_is_on_curve);
LCRYPTO_USED(EC_POINT_cmp);
LCRYPTO_USED(EC_POINT_make_affine);
LCRYPTO_USED(EC_POINTs_make_affine);
LCRYPTO_USED(EC_POINTs_mul);
LCRYPTO_USED(EC_POINT_mul);
LCRYPTO_USED(EC_GROUP_precompute_mult);
LCRYPTO_USED(EC_GROUP_have_precompute_mult);
LCRYPTO_USED(EC_GROUP_get_basis_type);
LCRYPTO_USED(d2i_ECPKParameters);
LCRYPTO_USED(i2d_ECPKParameters);
LCRYPTO_USED(ECPKParameters_print);
LCRYPTO_USED(ECPKParameters_print_fp);
LCRYPTO_USED(EC_KEY_new);
LCRYPTO_USED(EC_KEY_get_flags);
LCRYPTO_USED(EC_KEY_set_flags);
LCRYPTO_USED(EC_KEY_clear_flags);
LCRYPTO_USED(EC_KEY_new_by_curve_name);
LCRYPTO_USED(EC_KEY_free);
LCRYPTO_USED(EC_KEY_copy);
LCRYPTO_USED(EC_KEY_dup);
LCRYPTO_USED(EC_KEY_up_ref);
LCRYPTO_USED(EC_KEY_get0_group);
LCRYPTO_USED(EC_KEY_set_group);
LCRYPTO_USED(EC_KEY_get0_private_key);
LCRYPTO_USED(EC_KEY_set_private_key);
LCRYPTO_USED(EC_KEY_get0_public_key);
LCRYPTO_USED(EC_KEY_set_public_key);
LCRYPTO_USED(EC_KEY_get_enc_flags);
LCRYPTO_USED(EC_KEY_set_enc_flags);
LCRYPTO_USED(EC_KEY_get_conv_form);
LCRYPTO_USED(EC_KEY_set_conv_form);
LCRYPTO_USED(EC_KEY_set_asn1_flag);
LCRYPTO_USED(EC_KEY_precompute_mult);
LCRYPTO_USED(EC_KEY_generate_key);
LCRYPTO_USED(EC_KEY_check_key);
LCRYPTO_USED(EC_KEY_set_public_key_affine_coordinates);
LCRYPTO_USED(d2i_ECPrivateKey);
LCRYPTO_USED(i2d_ECPrivateKey);
LCRYPTO_USED(d2i_ECParameters);
LCRYPTO_USED(i2d_ECParameters);
LCRYPTO_USED(o2i_ECPublicKey);
LCRYPTO_USED(i2o_ECPublicKey);
LCRYPTO_USED(ECParameters_print);
LCRYPTO_USED(EC_KEY_print);
LCRYPTO_USED(ECParameters_print_fp);
LCRYPTO_USED(EC_KEY_print_fp);
LCRYPTO_USED(EC_KEY_set_ex_data);
LCRYPTO_USED(EC_KEY_get_ex_data);
LCRYPTO_USED(EC_KEY_OpenSSL);
LCRYPTO_USED(EC_KEY_get_default_method);
LCRYPTO_USED(EC_KEY_set_default_method);
LCRYPTO_USED(EC_KEY_get_method);
LCRYPTO_USED(EC_KEY_set_method);
LCRYPTO_USED(EC_KEY_new_method);
LCRYPTO_USED(ECDH_size);
LCRYPTO_USED(ECDH_compute_key);
LCRYPTO_USED(ECDSA_SIG_new);
LCRYPTO_USED(ECDSA_SIG_free);
LCRYPTO_USED(i2d_ECDSA_SIG);
LCRYPTO_USED(d2i_ECDSA_SIG);
LCRYPTO_USED(ECDSA_SIG_get0_r);
LCRYPTO_USED(ECDSA_SIG_get0_s);
LCRYPTO_USED(ECDSA_SIG_get0);
LCRYPTO_USED(ECDSA_SIG_set0);
LCRYPTO_USED(ECDSA_size);
LCRYPTO_USED(ECDSA_do_sign);
LCRYPTO_USED(ECDSA_do_verify);
LCRYPTO_USED(ECDSA_sign);
LCRYPTO_USED(ECDSA_verify);
LCRYPTO_USED(EC_KEY_METHOD_new);
LCRYPTO_USED(EC_KEY_METHOD_free);
LCRYPTO_USED(EC_KEY_METHOD_set_init);
LCRYPTO_USED(EC_KEY_METHOD_set_keygen);
LCRYPTO_USED(EC_KEY_METHOD_set_compute_key);
LCRYPTO_USED(EC_KEY_METHOD_set_sign);
LCRYPTO_USED(EC_KEY_METHOD_set_verify);
LCRYPTO_USED(EC_KEY_METHOD_get_init);
LCRYPTO_USED(EC_KEY_METHOD_get_keygen);
LCRYPTO_USED(EC_KEY_METHOD_get_compute_key);
LCRYPTO_USED(EC_KEY_METHOD_get_sign);
LCRYPTO_USED(EC_KEY_METHOD_get_verify);
LCRYPTO_USED(ECParameters_dup);
LCRYPTO_USED(ERR_load_EC_strings);
#endif /* _LIBCRYPTO_EC_H */

61
crypto/hidden/openssl/err.h Normal file
View File

@@ -0,0 +1,61 @@
/* $OpenBSD: err.h,v 1.4 2023/07/28 10:23:19 tb 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_ERR_H
#define _LIBCRYPTO_ERR_H
#ifndef _MSC_VER
#include_next <openssl/err.h>
#else
#include "../include/openssl/err.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(ERR_put_error);
LCRYPTO_USED(ERR_set_error_data);
LCRYPTO_USED(ERR_get_error);
LCRYPTO_USED(ERR_get_error_line);
LCRYPTO_USED(ERR_get_error_line_data);
LCRYPTO_USED(ERR_peek_error);
LCRYPTO_USED(ERR_peek_error_line);
LCRYPTO_USED(ERR_peek_error_line_data);
LCRYPTO_USED(ERR_peek_last_error);
LCRYPTO_USED(ERR_peek_last_error_line);
LCRYPTO_USED(ERR_peek_last_error_line_data);
LCRYPTO_USED(ERR_clear_error);
LCRYPTO_USED(ERR_error_string);
LCRYPTO_USED(ERR_error_string_n);
LCRYPTO_USED(ERR_lib_error_string);
LCRYPTO_USED(ERR_func_error_string);
LCRYPTO_USED(ERR_reason_error_string);
LCRYPTO_USED(ERR_print_errors_cb);
LCRYPTO_USED(ERR_print_errors_fp);
LCRYPTO_USED(ERR_print_errors);
LCRYPTO_USED(ERR_asprintf_error_data);
LCRYPTO_USED(ERR_load_strings);
LCRYPTO_USED(ERR_unload_strings);
LCRYPTO_USED(ERR_load_ERR_strings);
LCRYPTO_USED(ERR_load_crypto_strings);
LCRYPTO_USED(ERR_free_strings);
LCRYPTO_USED(ERR_remove_thread_state);
LCRYPTO_USED(ERR_remove_state);
LCRYPTO_USED(ERR_get_state);
LCRYPTO_USED(ERR_get_next_error_library);
LCRYPTO_USED(ERR_set_mark);
LCRYPTO_USED(ERR_pop_to_mark);
#endif /* _LIBCRYPTO_ERR_H */

71
crypto/hidden/openssl/gost.h Normal file
View File

@@ -0,0 +1,71 @@
/* $OpenBSD: gost.h,v 1.1 2023/07/08 14:30: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_GOST_H
#define _LIBCRYPTO_GOST_H
#ifndef _MSC_VER
#include_next <openssl/gost.h>
#else
#include "../include/openssl/gost.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(Gost2814789_set_sbox);
LCRYPTO_USED(Gost2814789_set_key);
LCRYPTO_USED(Gost2814789_ecb_encrypt);
LCRYPTO_USED(Gost2814789_cfb64_encrypt);
LCRYPTO_USED(Gost2814789_cnt_encrypt);
LCRYPTO_USED(GOST_CIPHER_PARAMS_new);
LCRYPTO_USED(GOST_CIPHER_PARAMS_free);
LCRYPTO_USED(d2i_GOST_CIPHER_PARAMS);
LCRYPTO_USED(i2d_GOST_CIPHER_PARAMS);
LCRYPTO_USED(GOST2814789IMIT_Init);
LCRYPTO_USED(GOST2814789IMIT_Update);
LCRYPTO_USED(GOST2814789IMIT_Final);
LCRYPTO_USED(GOST2814789IMIT_Transform);
LCRYPTO_USED(GOST2814789IMIT);
LCRYPTO_USED(GOSTR341194_Init);
LCRYPTO_USED(GOSTR341194_Update);
LCRYPTO_USED(GOSTR341194_Final);
LCRYPTO_USED(GOSTR341194_Transform);
LCRYPTO_USED(GOSTR341194);
LCRYPTO_USED(STREEBOG256_Init);
LCRYPTO_USED(STREEBOG256_Update);
LCRYPTO_USED(STREEBOG256_Final);
LCRYPTO_USED(STREEBOG256);
LCRYPTO_USED(STREEBOG512_Init);
LCRYPTO_USED(STREEBOG512_Update);
LCRYPTO_USED(STREEBOG512_Final);
LCRYPTO_USED(STREEBOG512_Transform);
LCRYPTO_USED(STREEBOG512);
LCRYPTO_USED(GOST_KEY_new);
LCRYPTO_USED(GOST_KEY_free);
LCRYPTO_USED(GOST_KEY_check_key);
LCRYPTO_USED(GOST_KEY_set_public_key_affine_coordinates);
LCRYPTO_USED(GOST_KEY_get0_group);
LCRYPTO_USED(GOST_KEY_set_group);
LCRYPTO_USED(GOST_KEY_get_digest);
LCRYPTO_USED(GOST_KEY_set_digest);
LCRYPTO_USED(GOST_KEY_get0_private_key);
LCRYPTO_USED(GOST_KEY_set_private_key);
LCRYPTO_USED(GOST_KEY_get0_public_key);
LCRYPTO_USED(GOST_KEY_set_public_key);
LCRYPTO_USED(GOST_KEY_get_size);
LCRYPTO_USED(ERR_load_GOST_strings);
#endif /* _LIBCRYPTO_GOST_H */

32
crypto/hidden/openssl/hkdf.h Normal file
View File

@@ -0,0 +1,32 @@
/* $OpenBSD: hkdf.h,v 1.2 2023/07/07 19:37:54 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_HKDF_H
#define _LIBCRYPTO_HKDF_H
#ifndef _MSC_VER
#include_next <openssl/hkdf.h>
#else
#include "../include/openssl/hkdf.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(HKDF);
LCRYPTO_USED(HKDF_extract);
LCRYPTO_USED(HKDF_expand);
#endif /* _LIBCRYPTO_HKDF_H */

40
crypto/hidden/openssl/hmac.h Normal file
View File

@@ -0,0 +1,40 @@
/* $OpenBSD: hmac.h,v 1.2 2023/07/05 21:14:54 bcook Exp $ */
/*
* Copyright (c) 2016 Philip Guenther <guenther@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_HMAC_H_
#define _LIBCRYPTO_HMAC_H_
#ifndef _MSC_VER
#include_next <openssl/hmac.h>
#else
#include "../include/openssl/hmac.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(HMAC_CTX_new);
LCRYPTO_USED(HMAC_CTX_free);
LCRYPTO_UNUSED(HMAC_CTX_reset);
LCRYPTO_UNUSED(HMAC_Init);
LCRYPTO_USED(HMAC_Init_ex);
LCRYPTO_USED(HMAC_Update);
LCRYPTO_USED(HMAC_Final);
LCRYPTO_USED(HMAC);
LCRYPTO_USED(HMAC_CTX_copy);
LCRYPTO_USED(HMAC_CTX_set_flags);
LCRYPTO_USED(HMAC_CTX_get_md);
#endif /* _LIBCRYPTO_HMAC_H_ */

36
crypto/hidden/openssl/idea.h Normal file
View File

@@ -0,0 +1,36 @@
/* $OpenBSD: idea.h,v 1.2 2023/07/29 03:13:38 tb 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_IDEA_H
#define _LIBCRYPTO_IDEA_H
#ifndef _MSC_VER
#include_next <openssl/idea.h>
#else
#include "../include/openssl/idea.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(idea_ecb_encrypt);
LCRYPTO_USED(idea_set_encrypt_key);
LCRYPTO_USED(idea_set_decrypt_key);
LCRYPTO_USED(idea_cbc_encrypt);
LCRYPTO_USED(idea_cfb64_encrypt);
LCRYPTO_USED(idea_ofb64_encrypt);
LCRYPTO_USED(idea_encrypt);
#endif /* _LIBCRYPTO_IDEA_H */

44
crypto/hidden/openssl/lhash.h Normal file
View File

@@ -0,0 +1,44 @@
/* $OpenBSD: lhash.h,v 1.2 2023/07/07 19:37:54 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 */

34
crypto/hidden/openssl/md4.h Normal file
View File

@@ -0,0 +1,34 @@
/* $OpenBSD: md4.h,v 1.1 2023/07/08 10:45:57 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_MD4_H
#define _LIBCRYPTO_MD4_H
#ifndef _MSC_VER
#include_next <openssl/md4.h>
#else
#include "../include/openssl/md4.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(MD4_Init);
LCRYPTO_USED(MD4_Update);
LCRYPTO_USED(MD4_Final);
LCRYPTO_USED(MD4);
LCRYPTO_USED(MD4_Transform);
#endif /* _LIBCRYPTO_MD4_H */

34
crypto/hidden/openssl/md5.h Normal file
View File

@@ -0,0 +1,34 @@
/* $OpenBSD: md5.h,v 1.1 2023/07/08 10:45:57 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_MD5_H
#define _LIBCRYPTO_MD5_H
#ifndef _MSC_VER
#include_next <openssl/md5.h>
#else
#include "../include/openssl/md5.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(MD5_Init);
LCRYPTO_USED(MD5_Update);
LCRYPTO_USED(MD5_Final);
LCRYPTO_USED(MD5);
LCRYPTO_USED(MD5_Transform);
#endif /* _LIBCRYPTO_MD5_H */

57
crypto/hidden/openssl/modes.h Normal file
View File

@@ -0,0 +1,57 @@
/* $OpenBSD: modes.h,v 1.1 2023/07/08 14:56:54 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_MODES_H
#define _LIBCRYPTO_MODES_H
#ifndef _MSC_VER
#include_next <openssl/modes.h>
#else
#include "../include/openssl/modes.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(CRYPTO_cbc128_encrypt);
LCRYPTO_USED(CRYPTO_cbc128_decrypt);
LCRYPTO_USED(CRYPTO_ctr128_encrypt);
LCRYPTO_USED(CRYPTO_ctr128_encrypt_ctr32);
LCRYPTO_USED(CRYPTO_ofb128_encrypt);
LCRYPTO_USED(CRYPTO_cfb128_encrypt);
LCRYPTO_USED(CRYPTO_cfb128_8_encrypt);
LCRYPTO_USED(CRYPTO_cfb128_1_encrypt);
LCRYPTO_USED(CRYPTO_gcm128_new);
LCRYPTO_USED(CRYPTO_gcm128_init);
LCRYPTO_USED(CRYPTO_gcm128_setiv);
LCRYPTO_USED(CRYPTO_gcm128_aad);
LCRYPTO_USED(CRYPTO_gcm128_encrypt);
LCRYPTO_USED(CRYPTO_gcm128_decrypt);
LCRYPTO_USED(CRYPTO_gcm128_encrypt_ctr32);
LCRYPTO_USED(CRYPTO_gcm128_decrypt_ctr32);
LCRYPTO_USED(CRYPTO_gcm128_finish);
LCRYPTO_USED(CRYPTO_gcm128_tag);
LCRYPTO_USED(CRYPTO_gcm128_release);
LCRYPTO_USED(CRYPTO_ccm128_init);
LCRYPTO_USED(CRYPTO_ccm128_setiv);
LCRYPTO_USED(CRYPTO_ccm128_aad);
LCRYPTO_USED(CRYPTO_ccm128_encrypt);
LCRYPTO_USED(CRYPTO_ccm128_decrypt);
LCRYPTO_USED(CRYPTO_ccm128_encrypt_ccm64);
LCRYPTO_USED(CRYPTO_ccm128_decrypt_ccm64);
LCRYPTO_USED(CRYPTO_ccm128_tag);
LCRYPTO_USED(CRYPTO_xts128_encrypt);
#endif /* _LIBCRYPTO_MODES_H */

59
crypto/hidden/openssl/objects.h Normal file
View File

@@ -0,0 +1,59 @@
/* $OpenBSD: objects.h,v 1.2 2023/07/28 10:25:05 tb 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_OBJECTS_H
#define _LIBCRYPTO_OBJECTS_H
#ifndef _MSC_VER
#include_next <openssl/objects.h>
#else
#include "../include/openssl/objects.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(OBJ_NAME_init);
LCRYPTO_USED(OBJ_NAME_new_index);
LCRYPTO_USED(OBJ_NAME_get);
LCRYPTO_USED(OBJ_NAME_add);
LCRYPTO_USED(OBJ_NAME_remove);
LCRYPTO_USED(OBJ_NAME_cleanup);
LCRYPTO_USED(OBJ_NAME_do_all);
LCRYPTO_USED(OBJ_NAME_do_all_sorted);
LCRYPTO_USED(OBJ_dup);
LCRYPTO_USED(OBJ_nid2obj);
LCRYPTO_USED(OBJ_nid2ln);
LCRYPTO_USED(OBJ_nid2sn);
LCRYPTO_USED(OBJ_obj2nid);
LCRYPTO_USED(OBJ_txt2obj);
LCRYPTO_USED(OBJ_obj2txt);
LCRYPTO_USED(OBJ_txt2nid);
LCRYPTO_USED(OBJ_ln2nid);
LCRYPTO_USED(OBJ_sn2nid);
LCRYPTO_USED(OBJ_cmp);
LCRYPTO_USED(OBJ_bsearch_);
LCRYPTO_USED(OBJ_new_nid);
LCRYPTO_USED(OBJ_add_object);
LCRYPTO_USED(OBJ_create);
LCRYPTO_USED(OBJ_cleanup);
LCRYPTO_USED(OBJ_create_objects);
LCRYPTO_USED(OBJ_length);
LCRYPTO_USED(OBJ_get0_data);
LCRYPTO_USED(OBJ_find_sigid_algs);
LCRYPTO_USED(OBJ_find_sigid_by_algs);
LCRYPTO_USED(ERR_load_OBJ_strings);
#endif /* _LIBCRYPTO_OBJECTS_H */

190
crypto/hidden/openssl/ocsp.h Normal file
View File

@@ -0,0 +1,190 @@
/* $OpenBSD: ocsp.h,v 1.1 2023/07/08 10:44:00 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_OCSP_H
#define _LIBCRYPTO_OCSP_H
#ifndef _MSC_VER
#include_next <openssl/ocsp.h>
#else
#include "../include/openssl/ocsp.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(OCSP_RESPID_new);
LCRYPTO_USED(OCSP_RESPID_free);
LCRYPTO_USED(d2i_OCSP_RESPID);
LCRYPTO_USED(i2d_OCSP_RESPID);
LCRYPTO_USED(OCSP_CERTID_dup);
LCRYPTO_USED(OCSP_sendreq_bio);
LCRYPTO_USED(OCSP_sendreq_new);
LCRYPTO_USED(OCSP_sendreq_nbio);
LCRYPTO_USED(OCSP_REQ_CTX_free);
LCRYPTO_USED(OCSP_REQ_CTX_set1_req);
LCRYPTO_USED(OCSP_REQ_CTX_add1_header);
LCRYPTO_USED(OCSP_cert_to_id);
LCRYPTO_USED(OCSP_cert_id_new);
LCRYPTO_USED(OCSP_request_add0_id);
LCRYPTO_USED(OCSP_request_add1_nonce);
LCRYPTO_USED(OCSP_basic_add1_nonce);
LCRYPTO_USED(OCSP_check_nonce);
LCRYPTO_USED(OCSP_copy_nonce);
LCRYPTO_USED(OCSP_request_set1_name);
LCRYPTO_USED(OCSP_request_add1_cert);
LCRYPTO_USED(OCSP_request_sign);
LCRYPTO_USED(OCSP_response_status);
LCRYPTO_USED(OCSP_response_get1_basic);
LCRYPTO_USED(OCSP_resp_get0_signature);
LCRYPTO_USED(OCSP_resp_get0_tbs_sigalg);
LCRYPTO_USED(OCSP_resp_get0_respdata);
LCRYPTO_USED(OCSP_resp_get0_signer);
LCRYPTO_USED(OCSP_resp_count);
LCRYPTO_USED(OCSP_resp_get0);
LCRYPTO_USED(OCSP_resp_get0_produced_at);
LCRYPTO_USED(OCSP_resp_get0_certs);
LCRYPTO_USED(OCSP_resp_get0_id);
LCRYPTO_USED(OCSP_resp_find);
LCRYPTO_USED(OCSP_single_get0_status);
LCRYPTO_USED(OCSP_resp_find_status);
LCRYPTO_USED(OCSP_check_validity);
LCRYPTO_USED(OCSP_request_verify);
LCRYPTO_USED(OCSP_parse_url);
LCRYPTO_USED(OCSP_id_issuer_cmp);
LCRYPTO_USED(OCSP_id_cmp);
LCRYPTO_USED(OCSP_request_onereq_count);
LCRYPTO_USED(OCSP_request_onereq_get0);
LCRYPTO_USED(OCSP_onereq_get0_id);
LCRYPTO_USED(OCSP_id_get0_info);
LCRYPTO_USED(OCSP_request_is_signed);
LCRYPTO_USED(OCSP_response_create);
LCRYPTO_USED(OCSP_basic_add1_status);
LCRYPTO_USED(OCSP_basic_add1_cert);
LCRYPTO_USED(OCSP_basic_sign);
LCRYPTO_USED(OCSP_crlID_new);
LCRYPTO_USED(OCSP_accept_responses_new);
LCRYPTO_USED(OCSP_archive_cutoff_new);
LCRYPTO_USED(OCSP_url_svcloc_new);
LCRYPTO_USED(OCSP_REQUEST_get_ext_count);
LCRYPTO_USED(OCSP_REQUEST_get_ext_by_NID);
LCRYPTO_USED(OCSP_REQUEST_get_ext_by_OBJ);
LCRYPTO_USED(OCSP_REQUEST_get_ext_by_critical);
LCRYPTO_USED(OCSP_REQUEST_get_ext);
LCRYPTO_USED(OCSP_REQUEST_delete_ext);
LCRYPTO_USED(OCSP_REQUEST_get1_ext_d2i);
LCRYPTO_USED(OCSP_REQUEST_add1_ext_i2d);
LCRYPTO_USED(OCSP_REQUEST_add_ext);
LCRYPTO_USED(OCSP_ONEREQ_get_ext_count);
LCRYPTO_USED(OCSP_ONEREQ_get_ext_by_NID);
LCRYPTO_USED(OCSP_ONEREQ_get_ext_by_OBJ);
LCRYPTO_USED(OCSP_ONEREQ_get_ext_by_critical);
LCRYPTO_USED(OCSP_ONEREQ_get_ext);
LCRYPTO_USED(OCSP_ONEREQ_delete_ext);
LCRYPTO_USED(OCSP_ONEREQ_get1_ext_d2i);
LCRYPTO_USED(OCSP_ONEREQ_add1_ext_i2d);
LCRYPTO_USED(OCSP_ONEREQ_add_ext);
LCRYPTO_USED(OCSP_BASICRESP_get_ext_count);
LCRYPTO_USED(OCSP_BASICRESP_get_ext_by_NID);
LCRYPTO_USED(OCSP_BASICRESP_get_ext_by_OBJ);
LCRYPTO_USED(OCSP_BASICRESP_get_ext_by_critical);
LCRYPTO_USED(OCSP_BASICRESP_get_ext);
LCRYPTO_USED(OCSP_BASICRESP_delete_ext);
LCRYPTO_USED(OCSP_BASICRESP_get1_ext_d2i);
LCRYPTO_USED(OCSP_BASICRESP_add1_ext_i2d);
LCRYPTO_USED(OCSP_BASICRESP_add_ext);
LCRYPTO_USED(OCSP_SINGLERESP_get_ext_count);
LCRYPTO_USED(OCSP_SINGLERESP_get_ext_by_NID);
LCRYPTO_USED(OCSP_SINGLERESP_get_ext_by_OBJ);
LCRYPTO_USED(OCSP_SINGLERESP_get_ext_by_critical);
LCRYPTO_USED(OCSP_SINGLERESP_get_ext);
LCRYPTO_USED(OCSP_SINGLERESP_delete_ext);
LCRYPTO_USED(OCSP_SINGLERESP_get1_ext_d2i);
LCRYPTO_USED(OCSP_SINGLERESP_add1_ext_i2d);
LCRYPTO_USED(OCSP_SINGLERESP_add_ext);
LCRYPTO_USED(OCSP_SINGLERESP_get0_id);
LCRYPTO_USED(OCSP_SINGLERESP_new);
LCRYPTO_USED(OCSP_SINGLERESP_free);
LCRYPTO_USED(d2i_OCSP_SINGLERESP);
LCRYPTO_USED(i2d_OCSP_SINGLERESP);
LCRYPTO_USED(OCSP_CERTSTATUS_new);
LCRYPTO_USED(OCSP_CERTSTATUS_free);
LCRYPTO_USED(d2i_OCSP_CERTSTATUS);
LCRYPTO_USED(i2d_OCSP_CERTSTATUS);
LCRYPTO_USED(OCSP_REVOKEDINFO_new);
LCRYPTO_USED(OCSP_REVOKEDINFO_free);
LCRYPTO_USED(d2i_OCSP_REVOKEDINFO);
LCRYPTO_USED(i2d_OCSP_REVOKEDINFO);
LCRYPTO_USED(OCSP_BASICRESP_new);
LCRYPTO_USED(OCSP_BASICRESP_free);
LCRYPTO_USED(d2i_OCSP_BASICRESP);
LCRYPTO_USED(i2d_OCSP_BASICRESP);
LCRYPTO_USED(OCSP_RESPDATA_new);
LCRYPTO_USED(OCSP_RESPDATA_free);
LCRYPTO_USED(d2i_OCSP_RESPDATA);
LCRYPTO_USED(i2d_OCSP_RESPDATA);
LCRYPTO_USED(OCSP_RESPID_new);
LCRYPTO_USED(OCSP_RESPID_free);
LCRYPTO_USED(d2i_OCSP_RESPID);
LCRYPTO_USED(i2d_OCSP_RESPID);
LCRYPTO_USED(OCSP_RESPONSE_new);
LCRYPTO_USED(OCSP_RESPONSE_free);
LCRYPTO_USED(d2i_OCSP_RESPONSE);
LCRYPTO_USED(i2d_OCSP_RESPONSE);
LCRYPTO_USED(d2i_OCSP_RESPONSE_bio);
LCRYPTO_USED(i2d_OCSP_RESPONSE_bio);
LCRYPTO_USED(OCSP_RESPBYTES_new);
LCRYPTO_USED(OCSP_RESPBYTES_free);
LCRYPTO_USED(d2i_OCSP_RESPBYTES);
LCRYPTO_USED(i2d_OCSP_RESPBYTES);
LCRYPTO_USED(OCSP_ONEREQ_new);
LCRYPTO_USED(OCSP_ONEREQ_free);
LCRYPTO_USED(d2i_OCSP_ONEREQ);
LCRYPTO_USED(i2d_OCSP_ONEREQ);
LCRYPTO_USED(OCSP_CERTID_new);
LCRYPTO_USED(OCSP_CERTID_free);
LCRYPTO_USED(d2i_OCSP_CERTID);
LCRYPTO_USED(i2d_OCSP_CERTID);
LCRYPTO_USED(OCSP_REQUEST_new);
LCRYPTO_USED(OCSP_REQUEST_free);
LCRYPTO_USED(d2i_OCSP_REQUEST);
LCRYPTO_USED(i2d_OCSP_REQUEST);
LCRYPTO_USED(d2i_OCSP_REQUEST_bio);
LCRYPTO_USED(i2d_OCSP_REQUEST_bio);
LCRYPTO_USED(OCSP_SIGNATURE_new);
LCRYPTO_USED(OCSP_SIGNATURE_free);
LCRYPTO_USED(d2i_OCSP_SIGNATURE);
LCRYPTO_USED(i2d_OCSP_SIGNATURE);
LCRYPTO_USED(OCSP_REQINFO_new);
LCRYPTO_USED(OCSP_REQINFO_free);
LCRYPTO_USED(d2i_OCSP_REQINFO);
LCRYPTO_USED(i2d_OCSP_REQINFO);
LCRYPTO_USED(OCSP_CRLID_new);
LCRYPTO_USED(OCSP_CRLID_free);
LCRYPTO_USED(d2i_OCSP_CRLID);
LCRYPTO_USED(i2d_OCSP_CRLID);
LCRYPTO_USED(OCSP_SERVICELOC_new);
LCRYPTO_USED(OCSP_SERVICELOC_free);
LCRYPTO_USED(d2i_OCSP_SERVICELOC);
LCRYPTO_USED(i2d_OCSP_SERVICELOC);
LCRYPTO_USED(OCSP_response_status_str);
LCRYPTO_USED(OCSP_cert_status_str);
LCRYPTO_USED(OCSP_crl_reason_str);
LCRYPTO_USED(OCSP_REQUEST_print);
LCRYPTO_USED(OCSP_RESPONSE_print);
LCRYPTO_USED(OCSP_basic_verify);
LCRYPTO_USED(ERR_load_OCSP_strings);
#endif /* _LIBCRYPTO_OCSP_H */

149
crypto/hidden/openssl/pem.h Normal file
View File

@@ -0,0 +1,149 @@
/* $OpenBSD: pem.h,v 1.2 2023/07/07 19:37:54 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 */

106
crypto/hidden/openssl/pkcs12.h Normal file
View File

@@ -0,0 +1,106 @@
/* $OpenBSD: pkcs12.h,v 1.2 2023/07/05 21:14:54 bcook Exp $ */
/*
* Copyright (c) 2022 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_PKCS12_H
#define _LIBCRYPTO_PKCS12_H
#ifndef _MSC_VER
#include_next <openssl/pkcs12.h>
#else
#include "../include/openssl/pkcs12.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(PKCS12_SAFEBAG_get0_attr);
LCRYPTO_USED(PKCS12_SAFEBAG_get0_attrs);
LCRYPTO_USED(PKCS12_SAFEBAG_get_nid);
LCRYPTO_USED(PKCS12_SAFEBAG_get_bag_nid);
LCRYPTO_USED(PKCS12_SAFEBAG_get1_cert);
LCRYPTO_USED(PKCS12_SAFEBAG_get1_crl);
LCRYPTO_USED(PKCS8_get_attr);
LCRYPTO_USED(PKCS12_mac_present);
LCRYPTO_USED(PKCS12_get0_mac);
LCRYPTO_USED(PKCS12_SAFEBAG_create_cert);
LCRYPTO_USED(PKCS12_SAFEBAG_create_crl);
LCRYPTO_USED(PKCS12_SAFEBAG_create0_p8inf);
LCRYPTO_USED(PKCS12_SAFEBAG_create0_pkcs8);
LCRYPTO_USED(PKCS12_SAFEBAG_create_pkcs8_encrypt);
LCRYPTO_USED(PKCS12_SAFEBAG_get0_p8inf);
LCRYPTO_USED(PKCS12_SAFEBAG_get0_pkcs8);
LCRYPTO_USED(PKCS12_SAFEBAG_get0_safes);
LCRYPTO_USED(PKCS12_SAFEBAG_get0_type);
LCRYPTO_USED(PKCS12_item_pack_safebag);
LCRYPTO_USED(PKCS8_decrypt);
LCRYPTO_USED(PKCS12_decrypt_skey);
LCRYPTO_USED(PKCS8_encrypt);
LCRYPTO_USED(PKCS12_pack_p7data);
LCRYPTO_USED(PKCS12_unpack_p7data);
LCRYPTO_USED(PKCS12_pack_p7encdata);
LCRYPTO_USED(PKCS12_unpack_p7encdata);
LCRYPTO_USED(PKCS12_pack_authsafes);
LCRYPTO_USED(PKCS12_unpack_authsafes);
LCRYPTO_USED(PKCS12_add_localkeyid);
LCRYPTO_USED(PKCS12_add_friendlyname_asc);
LCRYPTO_USED(PKCS12_add_CSPName_asc);
LCRYPTO_USED(PKCS12_add_friendlyname_uni);
LCRYPTO_USED(PKCS8_add_keyusage);
LCRYPTO_USED(PKCS12_get_attr_gen);
LCRYPTO_USED(PKCS12_get_friendlyname);
LCRYPTO_USED(PKCS12_pbe_crypt);
LCRYPTO_USED(PKCS12_item_decrypt_d2i);
LCRYPTO_USED(PKCS12_item_i2d_encrypt);
LCRYPTO_USED(PKCS12_init);
LCRYPTO_USED(PKCS12_key_gen_asc);
LCRYPTO_USED(PKCS12_key_gen_uni);
LCRYPTO_USED(PKCS12_PBE_keyivgen);
LCRYPTO_USED(PKCS12_gen_mac);
LCRYPTO_USED(PKCS12_verify_mac);
LCRYPTO_USED(PKCS12_set_mac);
LCRYPTO_USED(PKCS12_setup_mac);
LCRYPTO_USED(OPENSSL_asc2uni);
LCRYPTO_USED(OPENSSL_uni2asc);
LCRYPTO_USED(PKCS12_new);
LCRYPTO_USED(PKCS12_free);
LCRYPTO_USED(d2i_PKCS12);
LCRYPTO_USED(i2d_PKCS12);
LCRYPTO_USED(PKCS12_MAC_DATA_new);
LCRYPTO_USED(PKCS12_MAC_DATA_free);
LCRYPTO_USED(d2i_PKCS12_MAC_DATA);
LCRYPTO_USED(i2d_PKCS12_MAC_DATA);
LCRYPTO_USED(PKCS12_SAFEBAG_new);
LCRYPTO_USED(PKCS12_SAFEBAG_free);
LCRYPTO_USED(d2i_PKCS12_SAFEBAG);
LCRYPTO_USED(i2d_PKCS12_SAFEBAG);
LCRYPTO_USED(PKCS12_BAGS_new);
LCRYPTO_USED(PKCS12_BAGS_free);
LCRYPTO_USED(d2i_PKCS12_BAGS);
LCRYPTO_USED(i2d_PKCS12_BAGS);
LCRYPTO_USED(PKCS12_PBE_add);
LCRYPTO_USED(PKCS12_parse);
LCRYPTO_USED(PKCS12_create);
LCRYPTO_USED(PKCS12_add_cert);
LCRYPTO_USED(PKCS12_add_key);
LCRYPTO_USED(PKCS12_add_safe);
LCRYPTO_USED(PKCS12_add_safes);
LCRYPTO_USED(i2d_PKCS12_bio);
LCRYPTO_USED(i2d_PKCS12_fp);
LCRYPTO_USED(d2i_PKCS12_bio);
LCRYPTO_USED(d2i_PKCS12_fp);
LCRYPTO_USED(PKCS12_newpass);
LCRYPTO_USED(ERR_load_PKCS12_strings);
#endif /* _LIBCRYPTO_PKCS12_H */

129
crypto/hidden/openssl/pkcs7.h Normal file
View File

@@ -0,0 +1,129 @@
/* $OpenBSD: pkcs7.h,v 1.3 2023/07/05 21:14:54 bcook Exp $ */
/*
* Copyright (c) 2022 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_PKCS7_H
#define _LIBCRYPTO_PKCS7_H
#ifndef _MSC_VER
#include_next <openssl/pkcs7.h>
#else
#include "../include/openssl/pkcs7.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(PKCS7_ISSUER_AND_SERIAL_new);
LCRYPTO_USED(PKCS7_ISSUER_AND_SERIAL_free);
LCRYPTO_USED(d2i_PKCS7_ISSUER_AND_SERIAL);
LCRYPTO_USED(i2d_PKCS7_ISSUER_AND_SERIAL);
LCRYPTO_USED(PKCS7_ISSUER_AND_SERIAL_digest);
LCRYPTO_USED(d2i_PKCS7_fp);
LCRYPTO_USED(i2d_PKCS7_fp);
LCRYPTO_USED(PKCS7_dup);
LCRYPTO_USED(d2i_PKCS7_bio);
LCRYPTO_USED(i2d_PKCS7_bio);
LCRYPTO_USED(i2d_PKCS7_bio_stream);
LCRYPTO_USED(PEM_write_bio_PKCS7_stream);
LCRYPTO_USED(PKCS7_SIGNER_INFO_new);
LCRYPTO_USED(PKCS7_SIGNER_INFO_free);
LCRYPTO_USED(d2i_PKCS7_SIGNER_INFO);
LCRYPTO_USED(i2d_PKCS7_SIGNER_INFO);
LCRYPTO_USED(PKCS7_RECIP_INFO_new);
LCRYPTO_USED(PKCS7_RECIP_INFO_free);
LCRYPTO_USED(d2i_PKCS7_RECIP_INFO);
LCRYPTO_USED(i2d_PKCS7_RECIP_INFO);
LCRYPTO_USED(PKCS7_SIGNED_new);
LCRYPTO_USED(PKCS7_SIGNED_free);
LCRYPTO_USED(d2i_PKCS7_SIGNED);
LCRYPTO_USED(i2d_PKCS7_SIGNED);
LCRYPTO_USED(PKCS7_ENC_CONTENT_new);
LCRYPTO_USED(PKCS7_ENC_CONTENT_free);
LCRYPTO_USED(d2i_PKCS7_ENC_CONTENT);
LCRYPTO_USED(i2d_PKCS7_ENC_CONTENT);
LCRYPTO_USED(PKCS7_ENVELOPE_new);
LCRYPTO_USED(PKCS7_ENVELOPE_free);
LCRYPTO_USED(d2i_PKCS7_ENVELOPE);
LCRYPTO_USED(i2d_PKCS7_ENVELOPE);
LCRYPTO_USED(PKCS7_SIGN_ENVELOPE_new);
LCRYPTO_USED(PKCS7_SIGN_ENVELOPE_free);
LCRYPTO_USED(d2i_PKCS7_SIGN_ENVELOPE);
LCRYPTO_USED(i2d_PKCS7_SIGN_ENVELOPE);
LCRYPTO_USED(PKCS7_DIGEST_new);
LCRYPTO_USED(PKCS7_DIGEST_free);
LCRYPTO_USED(d2i_PKCS7_DIGEST);
LCRYPTO_USED(i2d_PKCS7_DIGEST);
LCRYPTO_USED(PKCS7_ENCRYPT_new);
LCRYPTO_USED(PKCS7_ENCRYPT_free);
LCRYPTO_USED(d2i_PKCS7_ENCRYPT);
LCRYPTO_USED(i2d_PKCS7_ENCRYPT);
LCRYPTO_USED(PKCS7_new);
LCRYPTO_USED(PKCS7_free);
LCRYPTO_USED(d2i_PKCS7);
LCRYPTO_USED(i2d_PKCS7);
LCRYPTO_USED(PKCS7_print_ctx);
LCRYPTO_USED(PKCS7_ctrl);
LCRYPTO_USED(PKCS7_set_type);
LCRYPTO_USED(PKCS7_set0_type_other);
LCRYPTO_USED(PKCS7_set_content);
LCRYPTO_USED(PKCS7_SIGNER_INFO_set);
LCRYPTO_USED(PKCS7_SIGNER_INFO_sign);
LCRYPTO_USED(PKCS7_add_signer);
LCRYPTO_USED(PKCS7_add_certificate);
LCRYPTO_USED(PKCS7_add_crl);
LCRYPTO_USED(PKCS7_content_new);
LCRYPTO_USED(PKCS7_dataVerify);
LCRYPTO_USED(PKCS7_signatureVerify);
LCRYPTO_USED(PKCS7_dataInit);
LCRYPTO_USED(PKCS7_dataFinal);
LCRYPTO_USED(PKCS7_dataDecode);
LCRYPTO_USED(PKCS7_add_signature);
LCRYPTO_USED(PKCS7_cert_from_signer_info);
LCRYPTO_USED(PKCS7_set_digest);
LCRYPTO_USED(PKCS7_get_signer_info);
LCRYPTO_USED(PKCS7_add_recipient);
LCRYPTO_USED(PKCS7_SIGNER_INFO_get0_algs);
LCRYPTO_USED(PKCS7_RECIP_INFO_get0_alg);
LCRYPTO_USED(PKCS7_add_recipient_info);
LCRYPTO_USED(PKCS7_RECIP_INFO_set);
LCRYPTO_USED(PKCS7_set_cipher);
LCRYPTO_USED(PKCS7_stream);
LCRYPTO_USED(PKCS7_get_issuer_and_serial);
LCRYPTO_USED(PKCS7_digest_from_attributes);
LCRYPTO_USED(PKCS7_add_signed_attribute);
LCRYPTO_USED(PKCS7_add_attribute);
LCRYPTO_USED(PKCS7_get_attribute);
LCRYPTO_USED(PKCS7_get_signed_attribute);
LCRYPTO_USED(PKCS7_set_signed_attributes);
LCRYPTO_USED(PKCS7_set_attributes);
LCRYPTO_USED(PKCS7_sign);
LCRYPTO_USED(PKCS7_sign_add_signer);
LCRYPTO_USED(PKCS7_final);
LCRYPTO_USED(PKCS7_verify);
LCRYPTO_USED(PKCS7_get0_signers);
LCRYPTO_USED(PKCS7_encrypt);
LCRYPTO_USED(PKCS7_decrypt);
LCRYPTO_USED(PKCS7_add_attrib_smimecap);
LCRYPTO_USED(PKCS7_get_smimecap);
LCRYPTO_USED(PKCS7_simple_smimecap);
LCRYPTO_USED(PKCS7_add_attrib_content_type);
LCRYPTO_USED(PKCS7_add0_attrib_signing_time);
LCRYPTO_USED(PKCS7_add1_attrib_digest);
LCRYPTO_USED(SMIME_write_PKCS7);
LCRYPTO_USED(SMIME_read_PKCS7);
LCRYPTO_USED(BIO_new_PKCS7);
LCRYPTO_USED(ERR_load_PKCS7_strings);
#endif /* _LIBCRYPTO_PKCS7_H */

32
crypto/hidden/openssl/poly1305.h Normal file
View File

@@ -0,0 +1,32 @@
/* $OpenBSD: poly1305.h,v 1.2 2023/07/07 19:37:54 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_POLY1305_H
#define _LIBCRYPTO_POLY1305_H
#ifndef _MSC_VER
#include_next <openssl/poly1305.h>
#else
#include "../include/openssl/poly1305.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(CRYPTO_poly1305_init);
LCRYPTO_USED(CRYPTO_poly1305_update);
LCRYPTO_USED(CRYPTO_poly1305_finish);
#endif /* _LIBCRYPTO_POLY1305_H */

33
crypto/hidden/openssl/rand.h Normal file
View File

@@ -0,0 +1,33 @@
/* $OpenBSD: rand.h,v 1.3 2023/07/28 09:53:55 tb 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_RAND_H
#define _LIBCRYPTO_RAND_H
#ifndef _MSC_VER
#include_next <openssl/rand.h>
#else
#include "../include/openssl/rand.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(RAND_set_rand_method);
LCRYPTO_USED(RAND_get_rand_method);
LCRYPTO_USED(RAND_SSLeay);
LCRYPTO_USED(ERR_load_RAND_strings);
#endif /* _LIBCRYPTO_RAND_H */

36
crypto/hidden/openssl/rc2.h Normal file
View File

@@ -0,0 +1,36 @@
/* $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 */

141
crypto/hidden/openssl/rsa.h Normal file
View File

@@ -0,0 +1,141 @@
/* $OpenBSD: rsa.h,v 1.2 2023/07/28 10:05:16 tb 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_RSA_H
#define _LIBCRYPTO_RSA_H
#ifndef _MSC_VER
#include_next <openssl/rsa.h>
#else
#include "../include/openssl/rsa.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(RSA_new);
LCRYPTO_USED(RSA_new_method);
LCRYPTO_USED(RSA_bits);
LCRYPTO_USED(RSA_size);
LCRYPTO_USED(RSA_generate_key);
LCRYPTO_USED(RSA_generate_key_ex);
LCRYPTO_USED(RSA_check_key);
LCRYPTO_USED(RSA_public_encrypt);
LCRYPTO_USED(RSA_private_encrypt);
LCRYPTO_USED(RSA_public_decrypt);
LCRYPTO_USED(RSA_private_decrypt);
LCRYPTO_USED(RSA_free);
LCRYPTO_USED(RSA_up_ref);
LCRYPTO_USED(RSA_flags);
LCRYPTO_USED(RSA_set_default_method);
LCRYPTO_USED(RSA_get_default_method);
LCRYPTO_USED(RSA_get_method);
LCRYPTO_USED(RSA_set_method);
LCRYPTO_USED(RSA_PKCS1_OpenSSL);
LCRYPTO_USED(RSA_PKCS1_SSLeay);
LCRYPTO_USED(RSA_pkey_ctx_ctrl);
LCRYPTO_USED(d2i_RSAPublicKey);
LCRYPTO_USED(i2d_RSAPublicKey);
LCRYPTO_USED(d2i_RSAPrivateKey);
LCRYPTO_USED(i2d_RSAPrivateKey);
LCRYPTO_USED(RSA_PSS_PARAMS_new);
LCRYPTO_USED(RSA_PSS_PARAMS_free);
LCRYPTO_USED(d2i_RSA_PSS_PARAMS);
LCRYPTO_USED(i2d_RSA_PSS_PARAMS);
LCRYPTO_USED(RSA_OAEP_PARAMS_new);
LCRYPTO_USED(RSA_OAEP_PARAMS_free);
LCRYPTO_USED(d2i_RSA_OAEP_PARAMS);
LCRYPTO_USED(i2d_RSA_OAEP_PARAMS);
LCRYPTO_USED(RSA_print_fp);
LCRYPTO_USED(RSA_print);
LCRYPTO_USED(RSA_sign);
LCRYPTO_USED(RSA_verify);
LCRYPTO_USED(RSA_sign_ASN1_OCTET_STRING);
LCRYPTO_USED(RSA_verify_ASN1_OCTET_STRING);
LCRYPTO_USED(RSA_blinding_on);
LCRYPTO_USED(RSA_blinding_off);
LCRYPTO_USED(RSA_padding_add_PKCS1_type_1);
LCRYPTO_USED(RSA_padding_check_PKCS1_type_1);
LCRYPTO_USED(RSA_padding_add_PKCS1_type_2);
LCRYPTO_USED(RSA_padding_check_PKCS1_type_2);
LCRYPTO_USED(PKCS1_MGF1);
LCRYPTO_USED(RSA_padding_add_PKCS1_OAEP);
LCRYPTO_USED(RSA_padding_check_PKCS1_OAEP);
LCRYPTO_USED(RSA_padding_add_PKCS1_OAEP_mgf1);
LCRYPTO_USED(RSA_padding_check_PKCS1_OAEP_mgf1);
LCRYPTO_USED(RSA_padding_add_none);
LCRYPTO_USED(RSA_padding_check_none);
LCRYPTO_USED(RSA_verify_PKCS1_PSS);
LCRYPTO_USED(RSA_padding_add_PKCS1_PSS);
LCRYPTO_USED(RSA_verify_PKCS1_PSS_mgf1);
LCRYPTO_USED(RSA_padding_add_PKCS1_PSS_mgf1);
LCRYPTO_USED(RSA_get_ex_new_index);
LCRYPTO_USED(RSA_set_ex_data);
LCRYPTO_USED(RSA_get_ex_data);
LCRYPTO_USED(RSA_security_bits);
LCRYPTO_USED(RSA_get0_key);
LCRYPTO_USED(RSA_set0_key);
LCRYPTO_USED(RSA_get0_crt_params);
LCRYPTO_USED(RSA_set0_crt_params);
LCRYPTO_USED(RSA_get0_factors);
LCRYPTO_USED(RSA_set0_factors);
LCRYPTO_USED(RSA_get0_n);
LCRYPTO_USED(RSA_get0_e);
LCRYPTO_USED(RSA_get0_d);
LCRYPTO_USED(RSA_get0_p);
LCRYPTO_USED(RSA_get0_q);
LCRYPTO_USED(RSA_get0_dmp1);
LCRYPTO_USED(RSA_get0_dmq1);
LCRYPTO_USED(RSA_get0_iqmp);
LCRYPTO_USED(RSA_get0_pss_params);
LCRYPTO_USED(RSA_clear_flags);
LCRYPTO_USED(RSA_test_flags);
LCRYPTO_USED(RSA_set_flags);
LCRYPTO_USED(RSAPublicKey_dup);
LCRYPTO_USED(RSAPrivateKey_dup);
LCRYPTO_USED(RSA_meth_new);
LCRYPTO_USED(RSA_meth_free);
LCRYPTO_USED(RSA_meth_dup);
LCRYPTO_USED(RSA_meth_set1_name);
LCRYPTO_USED(RSA_meth_set_priv_enc);
LCRYPTO_USED(RSA_meth_set_priv_dec);
LCRYPTO_USED(RSA_meth_get_finish);
LCRYPTO_USED(RSA_meth_set_finish);
LCRYPTO_USED(RSA_meth_set_pub_enc);
LCRYPTO_USED(RSA_meth_set_pub_dec);
LCRYPTO_USED(RSA_meth_set_mod_exp);
LCRYPTO_USED(RSA_meth_set_bn_mod_exp);
LCRYPTO_USED(RSA_meth_set_init);
LCRYPTO_USED(RSA_meth_set_keygen);
LCRYPTO_USED(RSA_meth_set_flags);
LCRYPTO_USED(RSA_meth_set0_app_data);
LCRYPTO_USED(RSA_meth_get0_name);
LCRYPTO_USED(RSA_meth_get_pub_enc);
LCRYPTO_USED(RSA_meth_get_pub_dec);
LCRYPTO_USED(RSA_meth_get_priv_enc);
LCRYPTO_USED(RSA_meth_get_priv_dec);
LCRYPTO_USED(RSA_meth_get_mod_exp);
LCRYPTO_USED(RSA_meth_get_bn_mod_exp);
LCRYPTO_USED(RSA_meth_get_init);
LCRYPTO_USED(RSA_meth_get_keygen);
LCRYPTO_USED(RSA_meth_get_flags);
LCRYPTO_USED(RSA_meth_get0_app_data);
LCRYPTO_USED(RSA_meth_get_sign);
LCRYPTO_USED(RSA_meth_set_sign);
LCRYPTO_USED(RSA_meth_get_verify);
LCRYPTO_USED(RSA_meth_set_verify);
LCRYPTO_USED(ERR_load_RSA_strings);
#endif /* _LIBCRYPTO_RSA_H */

52
crypto/hidden/openssl/sha.h Normal file
View File

@@ -0,0 +1,52 @@
/* $OpenBSD: sha.h,v 1.1 2023/07/08 12:24:10 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_SHA_H
#define _LIBCRYPTO_SHA_H
#ifndef _MSC_VER
#include_next <openssl/sha.h>
#else
#include "../include/openssl/sha.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(SHA1_Init);
LCRYPTO_USED(SHA1_Update);
LCRYPTO_USED(SHA1_Final);
LCRYPTO_USED(SHA1);
LCRYPTO_USED(SHA1_Transform);
LCRYPTO_USED(SHA224_Init);
LCRYPTO_USED(SHA224_Update);
LCRYPTO_USED(SHA224_Final);
LCRYPTO_USED(SHA224);
LCRYPTO_USED(SHA256_Init);
LCRYPTO_USED(SHA256_Update);
LCRYPTO_USED(SHA256_Final);
LCRYPTO_USED(SHA256);
LCRYPTO_USED(SHA256_Transform);
LCRYPTO_USED(SHA384_Init);
LCRYPTO_USED(SHA384_Update);
LCRYPTO_USED(SHA384_Final);
LCRYPTO_USED(SHA384);
LCRYPTO_USED(SHA512_Init);
LCRYPTO_USED(SHA512_Update);
LCRYPTO_USED(SHA512_Final);
LCRYPTO_USED(SHA512);
LCRYPTO_USED(SHA512_Transform);
#endif /* _LIBCRYPTO_SHA_H */

32
crypto/hidden/openssl/sm3.h Normal file
View File

@@ -0,0 +1,32 @@
/* $OpenBSD: sm3.h,v 1.3 2023/07/08 06:13:08 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_SM3_H
#define _LIBCRYPTO_SM3_H
#ifndef _MSC_VER
#include_next <openssl/sm3.h>
#else
#include "../include/openssl/sm3.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(SM3_Init);
LCRYPTO_USED(SM3_Update);
LCRYPTO_USED(SM3_Final);
#endif /* _LIBCRYPTO_SM3_H */

32
crypto/hidden/openssl/sm4.h Normal file
View File

@@ -0,0 +1,32 @@
/* $OpenBSD: sm4.h,v 1.2 2023/07/07 19:37:54 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_SM4_H
#define _LIBCRYPTO_SM4_H
#ifndef _MSC_VER
#include_next <openssl/sm4.h>
#else
#include "../include/openssl/sm4.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(SM4_set_key);
LCRYPTO_USED(SM4_decrypt);
LCRYPTO_USED(SM4_encrypt);
#endif /* _LIBCRYPTO_SM4_H */

50
crypto/hidden/openssl/stack.h Normal file
View File

@@ -0,0 +1,50 @@
/* $OpenBSD: stack.h,v 1.2 2023/07/05 21:14:54 bcook Exp $ */
/*
* Copyright (c) 2022 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_STACK_H
#define _LIBCRYPTO_STACK_H
#ifndef _MSC_VER
#include_next <openssl/stack.h>
#else
#include "../include/openssl/stack.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(sk_num);
LCRYPTO_USED(sk_value);
LCRYPTO_USED(sk_set);
LCRYPTO_USED(sk_new);
LCRYPTO_USED(sk_new_null);
LCRYPTO_USED(sk_free);
LCRYPTO_USED(sk_pop_free);
LCRYPTO_USED(sk_insert);
LCRYPTO_USED(sk_delete);
LCRYPTO_USED(sk_delete_ptr);
LCRYPTO_USED(sk_find);
LCRYPTO_USED(sk_find_ex);
LCRYPTO_USED(sk_push);
LCRYPTO_USED(sk_unshift);
LCRYPTO_USED(sk_shift);
LCRYPTO_USED(sk_pop);
LCRYPTO_USED(sk_zero);
LCRYPTO_USED(sk_set_cmp_func);
LCRYPTO_USED(sk_dup);
LCRYPTO_USED(sk_sort);
LCRYPTO_USED(sk_is_sorted);
#endif /* _LIBCRYPTO_STACK_H */

217
crypto/hidden/openssl/ts.h Normal file
View File

@@ -0,0 +1,217 @@
/* $OpenBSD: ts.h,v 1.3 2023/07/28 09:53:55 tb 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_TS_H
#define _LIBCRYPTO_TS_H
#ifndef _MSC_VER
#include_next <openssl/ts.h>
#else
#include "../include/openssl/ts.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(TS_REQ_new);
LCRYPTO_USED(TS_REQ_free);
LCRYPTO_USED(i2d_TS_REQ);
LCRYPTO_USED(d2i_TS_REQ);
LCRYPTO_USED(TS_REQ_dup);
LCRYPTO_USED(d2i_TS_REQ_fp);
LCRYPTO_USED(i2d_TS_REQ_fp);
LCRYPTO_USED(d2i_TS_REQ_bio);
LCRYPTO_USED(i2d_TS_REQ_bio);
LCRYPTO_USED(TS_MSG_IMPRINT_new);
LCRYPTO_USED(TS_MSG_IMPRINT_free);
LCRYPTO_USED(i2d_TS_MSG_IMPRINT);
LCRYPTO_USED(d2i_TS_MSG_IMPRINT);
LCRYPTO_USED(TS_MSG_IMPRINT_dup);
LCRYPTO_USED(d2i_TS_MSG_IMPRINT_fp);
LCRYPTO_USED(i2d_TS_MSG_IMPRINT_fp);
LCRYPTO_USED(d2i_TS_MSG_IMPRINT_bio);
LCRYPTO_USED(i2d_TS_MSG_IMPRINT_bio);
LCRYPTO_USED(TS_RESP_new);
LCRYPTO_USED(TS_RESP_free);
LCRYPTO_USED(i2d_TS_RESP);
LCRYPTO_USED(d2i_TS_RESP);
LCRYPTO_USED(PKCS7_to_TS_TST_INFO);
LCRYPTO_USED(TS_RESP_dup);
LCRYPTO_USED(d2i_TS_RESP_fp);
LCRYPTO_USED(i2d_TS_RESP_fp);
LCRYPTO_USED(d2i_TS_RESP_bio);
LCRYPTO_USED(i2d_TS_RESP_bio);
LCRYPTO_USED(TS_STATUS_INFO_new);
LCRYPTO_USED(TS_STATUS_INFO_free);
LCRYPTO_USED(i2d_TS_STATUS_INFO);
LCRYPTO_USED(d2i_TS_STATUS_INFO);
LCRYPTO_USED(TS_STATUS_INFO_dup);
LCRYPTO_USED(TS_TST_INFO_new);
LCRYPTO_USED(TS_TST_INFO_free);
LCRYPTO_USED(i2d_TS_TST_INFO);
LCRYPTO_USED(d2i_TS_TST_INFO);
LCRYPTO_USED(TS_TST_INFO_dup);
LCRYPTO_USED(d2i_TS_TST_INFO_fp);
LCRYPTO_USED(i2d_TS_TST_INFO_fp);
LCRYPTO_USED(d2i_TS_TST_INFO_bio);
LCRYPTO_USED(i2d_TS_TST_INFO_bio);
LCRYPTO_USED(TS_ACCURACY_new);
LCRYPTO_USED(TS_ACCURACY_free);
LCRYPTO_USED(i2d_TS_ACCURACY);
LCRYPTO_USED(d2i_TS_ACCURACY);
LCRYPTO_USED(TS_ACCURACY_dup);
LCRYPTO_USED(ESS_ISSUER_SERIAL_new);
LCRYPTO_USED(ESS_ISSUER_SERIAL_free);
LCRYPTO_USED(i2d_ESS_ISSUER_SERIAL);
LCRYPTO_USED(d2i_ESS_ISSUER_SERIAL);
LCRYPTO_USED(ESS_ISSUER_SERIAL_dup);
LCRYPTO_USED(ESS_CERT_ID_new);
LCRYPTO_USED(ESS_CERT_ID_free);
LCRYPTO_USED(i2d_ESS_CERT_ID);
LCRYPTO_USED(d2i_ESS_CERT_ID);
LCRYPTO_USED(ESS_CERT_ID_dup);
LCRYPTO_USED(ESS_SIGNING_CERT_new);
LCRYPTO_USED(ESS_SIGNING_CERT_free);
LCRYPTO_USED(i2d_ESS_SIGNING_CERT);
LCRYPTO_USED(d2i_ESS_SIGNING_CERT);
LCRYPTO_USED(ESS_SIGNING_CERT_dup);
LCRYPTO_USED(TS_REQ_set_version);
LCRYPTO_USED(TS_REQ_get_version);
LCRYPTO_USED(TS_REQ_set_msg_imprint);
LCRYPTO_USED(TS_REQ_get_msg_imprint);
LCRYPTO_USED(TS_MSG_IMPRINT_set_algo);
LCRYPTO_USED(TS_MSG_IMPRINT_get_algo);
LCRYPTO_USED(TS_MSG_IMPRINT_set_msg);
LCRYPTO_USED(TS_MSG_IMPRINT_get_msg);
LCRYPTO_USED(TS_REQ_set_policy_id);
LCRYPTO_USED(TS_REQ_get_policy_id);
LCRYPTO_USED(TS_REQ_set_nonce);
LCRYPTO_USED(TS_REQ_get_nonce);
LCRYPTO_USED(TS_REQ_set_cert_req);
LCRYPTO_USED(TS_REQ_get_cert_req);
LCRYPTO_USED(TS_REQ_get_exts);
LCRYPTO_USED(TS_REQ_ext_free);
LCRYPTO_USED(TS_REQ_get_ext_count);
LCRYPTO_USED(TS_REQ_get_ext_by_NID);
LCRYPTO_USED(TS_REQ_get_ext_by_OBJ);
LCRYPTO_USED(TS_REQ_get_ext_by_critical);
LCRYPTO_USED(TS_REQ_get_ext);
LCRYPTO_USED(TS_REQ_delete_ext);
LCRYPTO_USED(TS_REQ_add_ext);
LCRYPTO_USED(TS_REQ_get_ext_d2i);
LCRYPTO_USED(TS_REQ_print_bio);
LCRYPTO_USED(TS_RESP_set_status_info);
LCRYPTO_USED(TS_RESP_get_status_info);
LCRYPTO_USED(TS_STATUS_INFO_get0_failure_info);
LCRYPTO_USED(TS_STATUS_INFO_get0_text);
LCRYPTO_USED(TS_STATUS_INFO_get0_status);
LCRYPTO_USED(TS_STATUS_INFO_set_status);
LCRYPTO_USED(TS_RESP_set_tst_info);
LCRYPTO_USED(TS_RESP_get_token);
LCRYPTO_USED(TS_RESP_get_tst_info);
LCRYPTO_USED(TS_TST_INFO_set_version);
LCRYPTO_USED(TS_TST_INFO_get_version);
LCRYPTO_USED(TS_TST_INFO_set_policy_id);
LCRYPTO_USED(TS_TST_INFO_get_policy_id);
LCRYPTO_USED(TS_TST_INFO_set_msg_imprint);
LCRYPTO_USED(TS_TST_INFO_get_msg_imprint);
LCRYPTO_USED(TS_TST_INFO_set_serial);
LCRYPTO_USED(TS_TST_INFO_get_serial);
LCRYPTO_USED(TS_TST_INFO_set_time);
LCRYPTO_USED(TS_TST_INFO_get_time);
LCRYPTO_USED(TS_TST_INFO_set_accuracy);
LCRYPTO_USED(TS_TST_INFO_get_accuracy);
LCRYPTO_USED(TS_ACCURACY_set_seconds);
LCRYPTO_USED(TS_ACCURACY_get_seconds);
LCRYPTO_USED(TS_ACCURACY_set_millis);
LCRYPTO_USED(TS_ACCURACY_get_millis);
LCRYPTO_USED(TS_ACCURACY_set_micros);
LCRYPTO_USED(TS_ACCURACY_get_micros);
LCRYPTO_USED(TS_TST_INFO_set_ordering);
LCRYPTO_USED(TS_TST_INFO_get_ordering);
LCRYPTO_USED(TS_TST_INFO_set_nonce);
LCRYPTO_USED(TS_TST_INFO_get_nonce);
LCRYPTO_USED(TS_TST_INFO_set_tsa);
LCRYPTO_USED(TS_TST_INFO_get_tsa);
LCRYPTO_USED(TS_TST_INFO_get_exts);
LCRYPTO_USED(TS_TST_INFO_ext_free);
LCRYPTO_USED(TS_TST_INFO_get_ext_count);
LCRYPTO_USED(TS_TST_INFO_get_ext_by_NID);
LCRYPTO_USED(TS_TST_INFO_get_ext_by_OBJ);
LCRYPTO_USED(TS_TST_INFO_get_ext_by_critical);
LCRYPTO_USED(TS_TST_INFO_get_ext);
LCRYPTO_USED(TS_TST_INFO_delete_ext);
LCRYPTO_USED(TS_TST_INFO_add_ext);
LCRYPTO_USED(TS_TST_INFO_get_ext_d2i);
LCRYPTO_USED(TS_RESP_CTX_new);
LCRYPTO_USED(TS_RESP_CTX_free);
LCRYPTO_USED(TS_RESP_CTX_set_signer_cert);
LCRYPTO_USED(TS_RESP_CTX_set_signer_key);
LCRYPTO_USED(TS_RESP_CTX_set_def_policy);
LCRYPTO_USED(TS_RESP_CTX_set_certs);
LCRYPTO_USED(TS_RESP_CTX_add_policy);
LCRYPTO_USED(TS_RESP_CTX_add_md);
LCRYPTO_USED(TS_RESP_CTX_set_accuracy);
LCRYPTO_USED(TS_RESP_CTX_set_clock_precision_digits);
LCRYPTO_USED(TS_RESP_CTX_add_flags);
LCRYPTO_USED(TS_RESP_CTX_set_serial_cb);
LCRYPTO_USED(TS_RESP_CTX_set_time_cb);
LCRYPTO_USED(TS_RESP_CTX_set_extension_cb);
LCRYPTO_USED(TS_RESP_CTX_set_status_info);
LCRYPTO_USED(TS_RESP_CTX_set_status_info_cond);
LCRYPTO_USED(TS_RESP_CTX_add_failure_info);
LCRYPTO_USED(TS_RESP_CTX_get_request);
LCRYPTO_USED(TS_RESP_CTX_get_tst_info);
LCRYPTO_USED(TS_RESP_create_response);
LCRYPTO_USED(TS_RESP_verify_signature);
LCRYPTO_USED(TS_RESP_verify_response);
LCRYPTO_USED(TS_RESP_verify_token);
LCRYPTO_USED(TS_VERIFY_CTX_new);
LCRYPTO_USED(TS_VERIFY_CTX_free);
LCRYPTO_USED(TS_VERIFY_CTX_cleanup);
LCRYPTO_USED(TS_VERIFY_CTX_add_flags);
LCRYPTO_USED(TS_VERIFY_CTX_set_flags);
LCRYPTO_USED(TS_VERIFY_CTX_set_data);
LCRYPTO_USED(TS_VERIFY_CTX_set_store);
LCRYPTO_USED(TS_VERIFY_CTX_set_certs);
LCRYPTO_USED(TS_VERIFY_CTX_set_imprint);
LCRYPTO_USED(TS_REQ_to_TS_VERIFY_CTX);
LCRYPTO_USED(TS_RESP_print_bio);
LCRYPTO_USED(TS_STATUS_INFO_print_bio);
LCRYPTO_USED(TS_TST_INFO_print_bio);
LCRYPTO_USED(TS_ASN1_INTEGER_print_bio);
LCRYPTO_USED(TS_OBJ_print_bio);
LCRYPTO_USED(TS_ext_print_bio);
LCRYPTO_USED(TS_X509_ALGOR_print_bio);
LCRYPTO_USED(TS_MSG_IMPRINT_print_bio);
LCRYPTO_USED(TS_CONF_load_cert);
LCRYPTO_USED(TS_CONF_load_certs);
LCRYPTO_USED(TS_CONF_load_key);
LCRYPTO_USED(TS_CONF_get_tsa_section);
LCRYPTO_USED(TS_CONF_set_serial);
LCRYPTO_USED(TS_CONF_set_signer_cert);
LCRYPTO_USED(TS_CONF_set_certs);
LCRYPTO_USED(TS_CONF_set_signer_key);
LCRYPTO_USED(TS_CONF_set_def_policy);
LCRYPTO_USED(TS_CONF_set_policies);
LCRYPTO_USED(TS_CONF_set_digests);
LCRYPTO_USED(TS_CONF_set_accuracy);
LCRYPTO_USED(TS_CONF_set_clock_precision_digits);
LCRYPTO_USED(TS_CONF_set_ordering);
LCRYPTO_USED(TS_CONF_set_tsa_name);
LCRYPTO_USED(TS_CONF_set_ess_cert_id_chain);
LCRYPTO_USED(ERR_load_TS_strings);
#endif /* _LIBCRYPTO_TS_H */

35
crypto/hidden/openssl/txt_db.h Normal file
View File

@@ -0,0 +1,35 @@
/* $OpenBSD: txt_db.h,v 1.1 2023/07/08 11:28:03 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_TXT_DB_H
#define _LIBCRYPTO_TXT_DB_H
#ifndef _MSC_VER
#include_next <openssl/txt_db.h>
#else
#include "../include/openssl/txt_db.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(TXT_DB_read);
LCRYPTO_USED(TXT_DB_write);
LCRYPTO_USED(TXT_DB_create_index);
LCRYPTO_USED(TXT_DB_free);
LCRYPTO_USED(TXT_DB_get_by_index);
LCRYPTO_USED(TXT_DB_insert);
#endif /* _LIBCRYPTO_TXT_DB_H */

83
crypto/hidden/openssl/ui.h Normal file
View File

@@ -0,0 +1,83 @@
/* $OpenBSD: ui.h,v 1.3 2023/07/05 21:14:54 bcook Exp $ */
/*
* Copyright (c) 2022 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_UI_H
#define _LIBCRYPTO_UI_H
#ifndef _MSC_VER
#include_next <openssl/ui.h>
#else
#include "../include/openssl/ui.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(UI_new);
LCRYPTO_USED(UI_new_method);
LCRYPTO_USED(UI_free);
LCRYPTO_USED(UI_add_input_string);
LCRYPTO_USED(UI_dup_input_string);
LCRYPTO_USED(UI_add_verify_string);
LCRYPTO_USED(UI_dup_verify_string);
LCRYPTO_USED(UI_add_input_boolean);
LCRYPTO_USED(UI_dup_input_boolean);
LCRYPTO_USED(UI_add_info_string);
LCRYPTO_USED(UI_dup_info_string);
LCRYPTO_USED(UI_add_error_string);
LCRYPTO_USED(UI_dup_error_string);
LCRYPTO_USED(UI_construct_prompt);
LCRYPTO_USED(UI_add_user_data);
LCRYPTO_USED(UI_get0_user_data);
LCRYPTO_USED(UI_get0_result);
LCRYPTO_USED(UI_process);
LCRYPTO_USED(UI_ctrl);
LCRYPTO_USED(UI_get_ex_new_index);
LCRYPTO_USED(UI_set_ex_data);
LCRYPTO_USED(UI_get_ex_data);
LCRYPTO_USED(UI_set_default_method);
LCRYPTO_USED(UI_get_default_method);
LCRYPTO_USED(UI_get_method);
LCRYPTO_USED(UI_set_method);
LCRYPTO_USED(UI_OpenSSL);
LCRYPTO_USED(UI_null);
LCRYPTO_USED(UI_create_method);
LCRYPTO_USED(UI_destroy_method);
LCRYPTO_USED(UI_method_set_opener);
LCRYPTO_USED(UI_method_set_writer);
LCRYPTO_USED(UI_method_set_flusher);
LCRYPTO_USED(UI_method_set_reader);
LCRYPTO_USED(UI_method_set_closer);
LCRYPTO_USED(UI_method_set_prompt_constructor);
LCRYPTO_USED(UI_method_get_opener);
LCRYPTO_USED(UI_method_get_writer);
LCRYPTO_USED(UI_method_get_flusher);
LCRYPTO_USED(UI_method_get_reader);
LCRYPTO_USED(UI_method_get_closer);
LCRYPTO_USED(UI_get_string_type);
LCRYPTO_USED(UI_get_input_flags);
LCRYPTO_USED(UI_get0_output_string);
LCRYPTO_USED(UI_get0_action_string);
LCRYPTO_USED(UI_get0_result_string);
LCRYPTO_USED(UI_get0_test_string);
LCRYPTO_USED(UI_get_result_minsize);
LCRYPTO_USED(UI_get_result_maxsize);
LCRYPTO_USED(UI_set_result);
LCRYPTO_USED(UI_UTIL_read_pw_string);
LCRYPTO_USED(UI_UTIL_read_pw);
LCRYPTO_USED(ERR_load_UI_strings);
LCRYPTO_USED(UI_method_get_prompt_constructor);
#endif /* _LIBCRYPTO_UI_H */

283
crypto/hidden/openssl/x509.h Normal file
View File

@@ -0,0 +1,283 @@
/* $OpenBSD: x509.h,v 1.3 2023/07/05 21:14:54 bcook Exp $ */
/*
* Copyright (c) 2022 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_X509_H
#define _LIBCRYPTO_X509_H
#ifndef _MSC_VER
#include_next <openssl/x509.h>
#else
#include "../include/openssl/x509.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(X509_CRL_up_ref);
LCRYPTO_USED(i2d_re_X509_CRL_tbs);
LCRYPTO_USED(X509_get_X509_PUBKEY);
LCRYPTO_USED(X509_verify_cert_error_string);
LCRYPTO_USED(X509_verify);
LCRYPTO_USED(X509_REQ_verify);
LCRYPTO_USED(NETSCAPE_SPKI_verify);
LCRYPTO_USED(NETSCAPE_SPKI_b64_decode);
LCRYPTO_USED(NETSCAPE_SPKI_b64_encode);
LCRYPTO_USED(NETSCAPE_SPKI_get_pubkey);
LCRYPTO_USED(NETSCAPE_SPKI_set_pubkey);
LCRYPTO_USED(X509_sign);
LCRYPTO_USED(X509_sign_ctx);
LCRYPTO_USED(X509_REQ_sign);
LCRYPTO_USED(X509_REQ_sign_ctx);
LCRYPTO_USED(X509_CRL_sign);
LCRYPTO_USED(X509_CRL_sign_ctx);
LCRYPTO_USED(NETSCAPE_SPKI_sign);
LCRYPTO_USED(X509_pubkey_digest);
LCRYPTO_USED(X509_digest);
LCRYPTO_USED(X509_CRL_digest);
LCRYPTO_USED(X509_REQ_digest);
LCRYPTO_USED(X509_NAME_digest);
LCRYPTO_USED(d2i_X509_fp);
LCRYPTO_USED(i2d_X509_fp);
LCRYPTO_USED(d2i_X509_CRL_fp);
LCRYPTO_USED(i2d_X509_CRL_fp);
LCRYPTO_USED(d2i_X509_REQ_fp);
LCRYPTO_USED(i2d_X509_REQ_fp);
LCRYPTO_USED(d2i_RSAPrivateKey_fp);
LCRYPTO_USED(i2d_RSAPrivateKey_fp);
LCRYPTO_USED(d2i_RSAPublicKey_fp);
LCRYPTO_USED(i2d_RSAPublicKey_fp);
LCRYPTO_USED(d2i_DSAPrivateKey_fp);
LCRYPTO_USED(i2d_DSAPrivateKey_fp);
LCRYPTO_USED(d2i_ECPrivateKey_fp);
LCRYPTO_USED(i2d_ECPrivateKey_fp);
LCRYPTO_USED(d2i_PKCS8_fp);
LCRYPTO_USED(i2d_PKCS8_fp);
LCRYPTO_USED(d2i_PKCS8_PRIV_KEY_INFO_fp);
LCRYPTO_USED(i2d_PKCS8_PRIV_KEY_INFO_fp);
LCRYPTO_USED(i2d_PKCS8PrivateKeyInfo_fp);
LCRYPTO_USED(i2d_PrivateKey_fp);
LCRYPTO_USED(d2i_PrivateKey_fp);
LCRYPTO_USED(d2i_X509_bio);
LCRYPTO_USED(i2d_X509_bio);
LCRYPTO_USED(d2i_X509_CRL_bio);
LCRYPTO_USED(i2d_X509_CRL_bio);
LCRYPTO_USED(d2i_X509_REQ_bio);
LCRYPTO_USED(i2d_X509_REQ_bio);
LCRYPTO_USED(d2i_RSAPrivateKey_bio);
LCRYPTO_USED(i2d_RSAPrivateKey_bio);
LCRYPTO_USED(d2i_RSAPublicKey_bio);
LCRYPTO_USED(i2d_RSAPublicKey_bio);
LCRYPTO_USED(d2i_DSAPrivateKey_bio);
LCRYPTO_USED(i2d_DSAPrivateKey_bio);
LCRYPTO_USED(d2i_ECPrivateKey_bio);
LCRYPTO_USED(i2d_ECPrivateKey_bio);
LCRYPTO_USED(d2i_PKCS8_bio);
LCRYPTO_USED(i2d_PKCS8_bio);
LCRYPTO_USED(d2i_PKCS8_PRIV_KEY_INFO_bio);
LCRYPTO_USED(i2d_PKCS8_PRIV_KEY_INFO_bio);
LCRYPTO_USED(i2d_PKCS8PrivateKeyInfo_bio);
LCRYPTO_USED(i2d_PrivateKey_bio);
LCRYPTO_USED(d2i_PrivateKey_bio);
LCRYPTO_USED(X509_cmp_time);
LCRYPTO_USED(X509_cmp_current_time);
LCRYPTO_USED(X509_time_adj);
LCRYPTO_USED(X509_time_adj_ex);
LCRYPTO_USED(X509_gmtime_adj);
LCRYPTO_USED(X509_get_default_cert_area);
LCRYPTO_USED(X509_get_default_cert_dir);
LCRYPTO_USED(X509_get_default_cert_file);
LCRYPTO_USED(X509_get_default_cert_dir_env);
LCRYPTO_USED(X509_get_default_cert_file_env);
LCRYPTO_USED(X509_get_default_private_dir);
LCRYPTO_USED(X509_to_X509_REQ);
LCRYPTO_USED(X509_REQ_to_X509);
LCRYPTO_USED(X509_get_pubkey_parameters);
LCRYPTO_USED(X509_TRUST_set_default);
LCRYPTO_USED(X509_TRUST_set);
LCRYPTO_USED(X509_NAME_oneline);
LCRYPTO_USED(X509_get0_extensions);
LCRYPTO_USED(X509_get0_tbs_sigalg);
LCRYPTO_USED(X509_get0_uids);
LCRYPTO_USED(X509_set_version);
LCRYPTO_USED(X509_get_version);
LCRYPTO_USED(X509_set_serialNumber);
LCRYPTO_USED(X509_get_serialNumber);
LCRYPTO_USED(X509_get0_serialNumber);
LCRYPTO_USED(X509_set_issuer_name);
LCRYPTO_USED(X509_get_issuer_name);
LCRYPTO_USED(X509_set_subject_name);
LCRYPTO_USED(X509_get_subject_name);
LCRYPTO_USED(X509_set_notBefore);
LCRYPTO_USED(X509_set1_notBefore);
LCRYPTO_USED(X509_set_notAfter);
LCRYPTO_USED(X509_set1_notAfter);
LCRYPTO_USED(X509_get0_notBefore);
LCRYPTO_USED(X509_getm_notBefore);
LCRYPTO_USED(X509_get0_notAfter);
LCRYPTO_USED(X509_getm_notAfter);
LCRYPTO_USED(X509_set_pubkey);
LCRYPTO_USED(X509_get_pubkey);
LCRYPTO_USED(X509_get0_pubkey);
LCRYPTO_USED(X509_get0_pubkey_bitstr);
LCRYPTO_USED(X509_certificate_type);
LCRYPTO_USED(X509_get_signature_type);
LCRYPTO_USED(X509_REQ_set_version);
LCRYPTO_USED(X509_REQ_get_version);
LCRYPTO_USED(X509_REQ_set_subject_name);
LCRYPTO_USED(X509_REQ_get_subject_name);
LCRYPTO_USED(X509_REQ_set_pubkey);
LCRYPTO_USED(X509_REQ_get_pubkey);
LCRYPTO_USED(i2d_re_X509_REQ_tbs);
LCRYPTO_USED(X509_REQ_get0_pubkey);
LCRYPTO_USED(X509_REQ_extension_nid);
LCRYPTO_USED(X509_REQ_get_extension_nids);
LCRYPTO_USED(X509_REQ_set_extension_nids);
LCRYPTO_USED(X509_REQ_get_extensions);
LCRYPTO_USED(X509_REQ_add_extensions_nid);
LCRYPTO_USED(X509_REQ_add_extensions);
LCRYPTO_USED(X509_REQ_get_attr_count);
LCRYPTO_USED(X509_REQ_get_attr_by_NID);
LCRYPTO_USED(X509_REQ_get_attr_by_OBJ);
LCRYPTO_USED(X509_REQ_get_attr);
LCRYPTO_USED(X509_REQ_delete_attr);
LCRYPTO_USED(X509_REQ_add1_attr);
LCRYPTO_USED(X509_REQ_add1_attr_by_OBJ);
LCRYPTO_USED(X509_REQ_add1_attr_by_NID);
LCRYPTO_USED(X509_REQ_add1_attr_by_txt);
LCRYPTO_USED(X509_CRL_set_version);
LCRYPTO_USED(X509_CRL_set_issuer_name);
LCRYPTO_USED(X509_CRL_set_lastUpdate);
LCRYPTO_USED(X509_CRL_set1_lastUpdate);
LCRYPTO_USED(X509_CRL_set_nextUpdate);
LCRYPTO_USED(X509_CRL_set1_nextUpdate);
LCRYPTO_USED(X509_CRL_sort);
LCRYPTO_USED(X509_REVOKED_get0_extensions);
LCRYPTO_USED(X509_REVOKED_get0_revocationDate);
LCRYPTO_USED(X509_REVOKED_get0_serialNumber);
LCRYPTO_USED(X509_REVOKED_set_revocationDate);
LCRYPTO_USED(X509_REVOKED_set_serialNumber);
LCRYPTO_USED(X509_REQ_check_private_key);
LCRYPTO_USED(X509_check_private_key);
LCRYPTO_USED(X509_issuer_and_serial_cmp);
LCRYPTO_USED(X509_issuer_and_serial_hash);
LCRYPTO_USED(X509_issuer_name_cmp);
LCRYPTO_USED(X509_issuer_name_hash);
LCRYPTO_USED(X509_subject_name_cmp);
LCRYPTO_USED(X509_subject_name_hash);
LCRYPTO_USED(X509_issuer_name_hash_old);
LCRYPTO_USED(X509_subject_name_hash_old);
LCRYPTO_USED(X509_cmp);
LCRYPTO_USED(X509_NAME_cmp);
LCRYPTO_USED(X509_NAME_hash);
LCRYPTO_USED(X509_NAME_hash_old);
LCRYPTO_USED(X509_CRL_cmp);
LCRYPTO_USED(X509_CRL_match);
LCRYPTO_USED(X509_NAME_entry_count);
LCRYPTO_USED(X509_NAME_get_text_by_NID);
LCRYPTO_USED(X509_NAME_get_text_by_OBJ);
LCRYPTO_USED(X509_NAME_get_index_by_NID);
LCRYPTO_USED(X509_NAME_get_index_by_OBJ);
LCRYPTO_USED(X509_NAME_get_entry);
LCRYPTO_USED(X509_NAME_delete_entry);
LCRYPTO_USED(X509_NAME_add_entry);
LCRYPTO_USED(X509_NAME_add_entry_by_OBJ);
LCRYPTO_USED(X509_NAME_add_entry_by_NID);
LCRYPTO_USED(X509_NAME_ENTRY_create_by_txt);
LCRYPTO_USED(X509_NAME_ENTRY_create_by_NID);
LCRYPTO_USED(X509_NAME_add_entry_by_txt);
LCRYPTO_USED(X509_NAME_ENTRY_create_by_OBJ);
LCRYPTO_USED(X509_NAME_ENTRY_set_object);
LCRYPTO_USED(X509_NAME_ENTRY_set_data);
LCRYPTO_USED(X509_NAME_ENTRY_get_object);
LCRYPTO_USED(X509_NAME_ENTRY_get_data);
LCRYPTO_USED(X509_NAME_ENTRY_set);
LCRYPTO_USED(X509v3_get_ext_count);
LCRYPTO_USED(X509v3_get_ext_by_NID);
LCRYPTO_USED(X509v3_get_ext_by_OBJ);
LCRYPTO_USED(X509v3_get_ext_by_critical);
LCRYPTO_USED(X509v3_get_ext);
LCRYPTO_USED(X509v3_delete_ext);
LCRYPTO_USED(X509v3_add_ext);
LCRYPTO_USED(X509_get_ext_count);
LCRYPTO_USED(X509_get_ext_by_NID);
LCRYPTO_USED(X509_get_ext_by_OBJ);
LCRYPTO_USED(X509_get_ext_by_critical);
LCRYPTO_USED(X509_get_ext);
LCRYPTO_USED(X509_delete_ext);
LCRYPTO_USED(X509_add_ext);
LCRYPTO_USED(X509_get_ext_d2i);
LCRYPTO_USED(X509_add1_ext_i2d);
LCRYPTO_USED(X509_CRL_get_ext_count);
LCRYPTO_USED(X509_CRL_get_ext_by_NID);
LCRYPTO_USED(X509_CRL_get_ext_by_OBJ);
LCRYPTO_USED(X509_CRL_get_ext_by_critical);
LCRYPTO_USED(X509_CRL_get_ext);
LCRYPTO_USED(X509_CRL_delete_ext);
LCRYPTO_USED(X509_CRL_add_ext);
LCRYPTO_USED(X509_CRL_get_ext_d2i);
LCRYPTO_USED(X509_CRL_add1_ext_i2d);
LCRYPTO_USED(X509_REVOKED_get_ext_count);
LCRYPTO_USED(X509_REVOKED_get_ext_by_NID);
LCRYPTO_USED(X509_REVOKED_get_ext_by_OBJ);
LCRYPTO_USED(X509_REVOKED_get_ext_by_critical);
LCRYPTO_USED(X509_REVOKED_get_ext);
LCRYPTO_USED(X509_REVOKED_delete_ext);
LCRYPTO_USED(X509_REVOKED_add_ext);
LCRYPTO_USED(X509_REVOKED_get_ext_d2i);
LCRYPTO_USED(X509_REVOKED_add1_ext_i2d);
LCRYPTO_USED(X509_EXTENSION_create_by_NID);
LCRYPTO_USED(X509_EXTENSION_create_by_OBJ);
LCRYPTO_USED(X509_EXTENSION_set_object);
LCRYPTO_USED(X509_EXTENSION_set_critical);
LCRYPTO_USED(X509_EXTENSION_set_data);
LCRYPTO_USED(X509_EXTENSION_get_object);
LCRYPTO_USED(X509_EXTENSION_get_data);
LCRYPTO_USED(X509_EXTENSION_get_critical);
LCRYPTO_USED(X509at_get_attr_count);
LCRYPTO_USED(X509at_get_attr_by_NID);
LCRYPTO_USED(X509at_get_attr_by_OBJ);
LCRYPTO_USED(X509at_get_attr);
LCRYPTO_USED(X509at_delete_attr);
LCRYPTO_USED(X509at_add1_attr);
LCRYPTO_USED(X509at_add1_attr_by_OBJ);
LCRYPTO_USED(X509at_add1_attr_by_NID);
LCRYPTO_USED(X509at_add1_attr_by_txt);
LCRYPTO_USED(X509at_get0_data_by_OBJ);
LCRYPTO_USED(X509_ATTRIBUTE_create_by_NID);
LCRYPTO_USED(X509_ATTRIBUTE_create_by_OBJ);
LCRYPTO_USED(X509_ATTRIBUTE_create_by_txt);
LCRYPTO_USED(X509_ATTRIBUTE_set1_object);
LCRYPTO_USED(X509_ATTRIBUTE_set1_data);
LCRYPTO_USED(X509_ATTRIBUTE_get0_data);
LCRYPTO_USED(X509_ATTRIBUTE_count);
LCRYPTO_USED(X509_ATTRIBUTE_get0_object);
LCRYPTO_USED(X509_ATTRIBUTE_get0_type);
LCRYPTO_USED(X509_verify_cert);
LCRYPTO_USED(X509_find_by_issuer_and_serial);
LCRYPTO_USED(X509_find_by_subject);
LCRYPTO_USED(X509_check_trust);
LCRYPTO_USED(X509_TRUST_get_count);
LCRYPTO_USED(X509_TRUST_get0);
LCRYPTO_USED(X509_TRUST_get_by_id);
LCRYPTO_USED(X509_TRUST_add);
LCRYPTO_USED(X509_TRUST_cleanup);
LCRYPTO_USED(X509_TRUST_get_flags);
LCRYPTO_USED(X509_TRUST_get0_name);
LCRYPTO_USED(X509_TRUST_get_trust);
LCRYPTO_USED(X509_up_ref);
LCRYPTO_USED(X509_chain_up_ref);
LCRYPTO_USED(ERR_load_X509_strings);
#endif /* _LIBCRYPTO_X509_H */

156
crypto/hidden/openssl/x509_vfy.h Normal file
View File

@@ -0,0 +1,156 @@
/* $OpenBSD: x509_vfy.h,v 1.6 2023/07/05 21:14:54 bcook Exp $ */
/*
* Copyright (c) 2022 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_X509_VFY_H
#define _LIBCRYPTO_X509_VFY_H
#ifndef _MSC_VER
#include_next <openssl/x509_vfy.h>
#else
#include "../include/openssl/x509_vfy.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(X509_STORE_set_depth);
LCRYPTO_USED(X509_STORE_CTX_set_depth);
LCRYPTO_USED(X509_OBJECT_new);
LCRYPTO_USED(X509_OBJECT_free);
LCRYPTO_USED(X509_OBJECT_idx_by_subject);
LCRYPTO_USED(X509_OBJECT_retrieve_by_subject);
LCRYPTO_USED(X509_OBJECT_retrieve_match);
LCRYPTO_USED(X509_OBJECT_up_ref_count);
LCRYPTO_USED(X509_OBJECT_get_type);
LCRYPTO_USED(X509_OBJECT_get0_X509);
LCRYPTO_USED(X509_OBJECT_get0_X509_CRL);
LCRYPTO_USED(X509_STORE_new);
LCRYPTO_USED(X509_STORE_free);
LCRYPTO_USED(X509_STORE_up_ref);
LCRYPTO_USED(X509_STORE_get0_objects);
LCRYPTO_USED(X509_STORE_get_ex_data);
LCRYPTO_USED(X509_STORE_set_ex_data);
LCRYPTO_USED(X509_STORE_set_flags);
LCRYPTO_USED(X509_STORE_set_purpose);
LCRYPTO_USED(X509_STORE_set_trust);
LCRYPTO_USED(X509_STORE_set1_param);
LCRYPTO_USED(X509_STORE_get0_param);
LCRYPTO_USED(X509_STORE_get_verify_cb);
LCRYPTO_USED(X509_STORE_set_verify_cb);
LCRYPTO_USED(X509_STORE_get_check_issued);
LCRYPTO_USED(X509_STORE_set_check_issued);
LCRYPTO_USED(X509_STORE_CTX_get_check_issued);
LCRYPTO_USED(X509_STORE_CTX_new);
LCRYPTO_USED(X509_STORE_CTX_get1_issuer);
LCRYPTO_USED(X509_STORE_CTX_free);
LCRYPTO_USED(X509_STORE_CTX_init);
LCRYPTO_USED(X509_STORE_CTX_get0_cert);
LCRYPTO_USED(X509_STORE_CTX_get0_chain);
LCRYPTO_USED(X509_STORE_CTX_get0_store);
LCRYPTO_USED(X509_STORE_CTX_get0_untrusted);
LCRYPTO_USED(X509_STORE_CTX_set0_untrusted);
LCRYPTO_USED(X509_STORE_CTX_get1_certs);
LCRYPTO_USED(X509_STORE_CTX_get1_crls);
LCRYPTO_USED(X509_STORE_CTX_trusted_stack);
LCRYPTO_USED(X509_STORE_CTX_set0_trusted_stack);
LCRYPTO_USED(X509_STORE_CTX_cleanup);
LCRYPTO_USED(X509_STORE_add_lookup);
LCRYPTO_USED(X509_LOOKUP_hash_dir);
LCRYPTO_USED(X509_LOOKUP_file);
LCRYPTO_USED(X509_LOOKUP_mem);
LCRYPTO_USED(X509_STORE_add_cert);
LCRYPTO_USED(X509_STORE_add_crl);
LCRYPTO_USED(X509_STORE_CTX_get_by_subject);
LCRYPTO_USED(X509_STORE_CTX_get_obj_by_subject);
LCRYPTO_USED(X509_LOOKUP_ctrl);
LCRYPTO_USED(X509_load_cert_file);
LCRYPTO_USED(X509_load_crl_file);
LCRYPTO_USED(X509_load_cert_crl_file);
LCRYPTO_USED(X509_LOOKUP_new);
LCRYPTO_USED(X509_LOOKUP_free);
LCRYPTO_USED(X509_LOOKUP_init);
LCRYPTO_USED(X509_LOOKUP_by_subject);
LCRYPTO_USED(X509_LOOKUP_by_issuer_serial);
LCRYPTO_USED(X509_LOOKUP_by_fingerprint);
LCRYPTO_USED(X509_LOOKUP_by_alias);
LCRYPTO_USED(X509_LOOKUP_shutdown);
LCRYPTO_USED(X509_STORE_load_locations);
LCRYPTO_USED(X509_STORE_load_mem);
LCRYPTO_USED(X509_STORE_set_default_paths);
LCRYPTO_USED(X509_STORE_CTX_get_ex_new_index);
LCRYPTO_USED(X509_STORE_CTX_set_ex_data);
LCRYPTO_USED(X509_STORE_CTX_get_ex_data);
LCRYPTO_USED(X509_STORE_CTX_get_error);
LCRYPTO_USED(X509_STORE_CTX_set_error);
LCRYPTO_USED(X509_STORE_CTX_get_error_depth);
LCRYPTO_USED(X509_STORE_CTX_set_error_depth);
LCRYPTO_USED(X509_STORE_CTX_get_current_cert);
LCRYPTO_USED(X509_STORE_CTX_set_current_cert);
LCRYPTO_USED(X509_STORE_CTX_get0_current_issuer);
LCRYPTO_USED(X509_STORE_CTX_get0_current_crl);
LCRYPTO_USED(X509_STORE_CTX_get0_parent_ctx);
LCRYPTO_USED(X509_STORE_CTX_get_chain);
LCRYPTO_USED(X509_STORE_CTX_get1_chain);
LCRYPTO_USED(X509_STORE_CTX_set_cert);
LCRYPTO_USED(X509_STORE_CTX_set_chain);
LCRYPTO_USED(X509_STORE_CTX_set0_crls);
LCRYPTO_USED(X509_STORE_CTX_set_purpose);
LCRYPTO_USED(X509_STORE_CTX_set_trust);
LCRYPTO_USED(X509_STORE_CTX_purpose_inherit);
LCRYPTO_USED(X509_STORE_CTX_set_flags);
LCRYPTO_USED(X509_STORE_CTX_set_time);
LCRYPTO_USED(X509_STORE_CTX_set0_verified_chain);
LCRYPTO_USED(X509_STORE_CTX_get_verify);
LCRYPTO_USED(X509_STORE_CTX_set_verify);
LCRYPTO_USED(X509_STORE_CTX_get_verify_cb);
LCRYPTO_USED(X509_STORE_CTX_set_verify_cb);
LCRYPTO_USED(X509_STORE_set_verify);
LCRYPTO_USED(X509_STORE_get_verify);
LCRYPTO_USED(X509_STORE_CTX_get_num_untrusted);
LCRYPTO_USED(X509_STORE_CTX_get0_param);
LCRYPTO_USED(X509_STORE_CTX_set0_param);
LCRYPTO_USED(X509_STORE_CTX_set_default);
LCRYPTO_USED(X509_VERIFY_PARAM_new);
LCRYPTO_USED(X509_VERIFY_PARAM_free);
LCRYPTO_USED(X509_VERIFY_PARAM_inherit);
LCRYPTO_USED(X509_VERIFY_PARAM_set1);
LCRYPTO_USED(X509_VERIFY_PARAM_set1_name);
LCRYPTO_USED(X509_VERIFY_PARAM_set_flags);
LCRYPTO_USED(X509_VERIFY_PARAM_clear_flags);
LCRYPTO_USED(X509_VERIFY_PARAM_get_flags);
LCRYPTO_USED(X509_VERIFY_PARAM_set_purpose);
LCRYPTO_USED(X509_VERIFY_PARAM_set_trust);
LCRYPTO_USED(X509_VERIFY_PARAM_set_depth);
LCRYPTO_USED(X509_VERIFY_PARAM_set_auth_level);
LCRYPTO_USED(X509_VERIFY_PARAM_get_time);
LCRYPTO_USED(X509_VERIFY_PARAM_set_time);
LCRYPTO_USED(X509_VERIFY_PARAM_add0_policy);
LCRYPTO_USED(X509_VERIFY_PARAM_set1_policies);
LCRYPTO_USED(X509_VERIFY_PARAM_get_depth);
LCRYPTO_USED(X509_VERIFY_PARAM_set1_host);
LCRYPTO_USED(X509_VERIFY_PARAM_add1_host);
LCRYPTO_USED(X509_VERIFY_PARAM_set_hostflags);
LCRYPTO_USED(X509_VERIFY_PARAM_get0_peername);
LCRYPTO_USED(X509_VERIFY_PARAM_set1_email);
LCRYPTO_USED(X509_VERIFY_PARAM_set1_ip);
LCRYPTO_USED(X509_VERIFY_PARAM_set1_ip_asc);
LCRYPTO_USED(X509_VERIFY_PARAM_get0_name);
LCRYPTO_USED(X509_VERIFY_PARAM_get0);
LCRYPTO_USED(X509_VERIFY_PARAM_get_count);
LCRYPTO_USED(X509_VERIFY_PARAM_add0_table);
LCRYPTO_USED(X509_VERIFY_PARAM_lookup);
LCRYPTO_USED(X509_VERIFY_PARAM_table_cleanup);
#endif /* _LIBCRYPTO_X509_VFY_H */

265
crypto/hidden/openssl/x509v3.h Normal file
View File

@@ -0,0 +1,265 @@
/* $OpenBSD: x509v3.h,v 1.5 2023/07/05 21:14:54 bcook Exp $ */
/*
* Copyright (c) 2022 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_X509V3_H
#define _LIBCRYPTO_X509V3_H
#ifndef _MSC_VER
#include_next <openssl/x509v3.h>
#else
#include "../include/openssl/x509v3.h"
#endif
#include "crypto_namespace.h"
LCRYPTO_USED(BASIC_CONSTRAINTS_new);
LCRYPTO_USED(BASIC_CONSTRAINTS_free);
LCRYPTO_USED(d2i_BASIC_CONSTRAINTS);
LCRYPTO_USED(i2d_BASIC_CONSTRAINTS);
LCRYPTO_USED(AUTHORITY_KEYID_new);
LCRYPTO_USED(AUTHORITY_KEYID_free);
LCRYPTO_USED(d2i_AUTHORITY_KEYID);
LCRYPTO_USED(i2d_AUTHORITY_KEYID);
LCRYPTO_USED(PKEY_USAGE_PERIOD_new);
LCRYPTO_USED(PKEY_USAGE_PERIOD_free);
LCRYPTO_USED(d2i_PKEY_USAGE_PERIOD);
LCRYPTO_USED(i2d_PKEY_USAGE_PERIOD);
LCRYPTO_USED(GENERAL_NAME_new);
LCRYPTO_USED(GENERAL_NAME_free);
LCRYPTO_USED(d2i_GENERAL_NAME);
LCRYPTO_USED(i2d_GENERAL_NAME);
LCRYPTO_USED(GENERAL_NAME_dup);
LCRYPTO_USED(GENERAL_NAME_cmp);
LCRYPTO_USED(v2i_ASN1_BIT_STRING);
LCRYPTO_USED(i2v_ASN1_BIT_STRING);
LCRYPTO_USED(i2v_GENERAL_NAME);
LCRYPTO_USED(GENERAL_NAME_print);
LCRYPTO_USED(GENERAL_NAMES_new);
LCRYPTO_USED(GENERAL_NAMES_free);
LCRYPTO_USED(d2i_GENERAL_NAMES);
LCRYPTO_USED(i2d_GENERAL_NAMES);
LCRYPTO_USED(i2v_GENERAL_NAMES);
LCRYPTO_USED(v2i_GENERAL_NAMES);
LCRYPTO_USED(OTHERNAME_new);
LCRYPTO_USED(OTHERNAME_free);
LCRYPTO_USED(d2i_OTHERNAME);
LCRYPTO_USED(i2d_OTHERNAME);
LCRYPTO_USED(EDIPARTYNAME_new);
LCRYPTO_USED(EDIPARTYNAME_free);
LCRYPTO_USED(d2i_EDIPARTYNAME);
LCRYPTO_USED(i2d_EDIPARTYNAME);
LCRYPTO_USED(OTHERNAME_cmp);
LCRYPTO_USED(GENERAL_NAME_set0_value);
LCRYPTO_USED(GENERAL_NAME_get0_value);
LCRYPTO_USED(GENERAL_NAME_set0_othername);
LCRYPTO_USED(GENERAL_NAME_get0_otherName);
LCRYPTO_USED(i2s_ASN1_OCTET_STRING);
LCRYPTO_USED(s2i_ASN1_OCTET_STRING);
LCRYPTO_USED(EXTENDED_KEY_USAGE_new);
LCRYPTO_USED(EXTENDED_KEY_USAGE_free);
LCRYPTO_USED(d2i_EXTENDED_KEY_USAGE);
LCRYPTO_USED(i2d_EXTENDED_KEY_USAGE);
LCRYPTO_USED(i2a_ACCESS_DESCRIPTION);
LCRYPTO_USED(CERTIFICATEPOLICIES_new);
LCRYPTO_USED(CERTIFICATEPOLICIES_free);
LCRYPTO_USED(d2i_CERTIFICATEPOLICIES);
LCRYPTO_USED(i2d_CERTIFICATEPOLICIES);
LCRYPTO_USED(POLICYINFO_new);
LCRYPTO_USED(POLICYINFO_free);
LCRYPTO_USED(d2i_POLICYINFO);
LCRYPTO_USED(i2d_POLICYINFO);
LCRYPTO_USED(POLICYQUALINFO_new);
LCRYPTO_USED(POLICYQUALINFO_free);
LCRYPTO_USED(d2i_POLICYQUALINFO);
LCRYPTO_USED(i2d_POLICYQUALINFO);
LCRYPTO_USED(USERNOTICE_new);
LCRYPTO_USED(USERNOTICE_free);
LCRYPTO_USED(d2i_USERNOTICE);
LCRYPTO_USED(i2d_USERNOTICE);
LCRYPTO_USED(NOTICEREF_new);
LCRYPTO_USED(NOTICEREF_free);
LCRYPTO_USED(d2i_NOTICEREF);
LCRYPTO_USED(i2d_NOTICEREF);
LCRYPTO_USED(CRL_DIST_POINTS_new);
LCRYPTO_USED(CRL_DIST_POINTS_free);
LCRYPTO_USED(d2i_CRL_DIST_POINTS);
LCRYPTO_USED(i2d_CRL_DIST_POINTS);
LCRYPTO_USED(DIST_POINT_new);
LCRYPTO_USED(DIST_POINT_free);
LCRYPTO_USED(d2i_DIST_POINT);
LCRYPTO_USED(i2d_DIST_POINT);
LCRYPTO_USED(DIST_POINT_NAME_new);
LCRYPTO_USED(DIST_POINT_NAME_free);
LCRYPTO_USED(d2i_DIST_POINT_NAME);
LCRYPTO_USED(i2d_DIST_POINT_NAME);
LCRYPTO_USED(ISSUING_DIST_POINT_new);
LCRYPTO_USED(ISSUING_DIST_POINT_free);
LCRYPTO_USED(d2i_ISSUING_DIST_POINT);
LCRYPTO_USED(i2d_ISSUING_DIST_POINT);
LCRYPTO_USED(DIST_POINT_set_dpname);
LCRYPTO_USED(NAME_CONSTRAINTS_check);
LCRYPTO_USED(ACCESS_DESCRIPTION_new);
LCRYPTO_USED(ACCESS_DESCRIPTION_free);
LCRYPTO_USED(d2i_ACCESS_DESCRIPTION);
LCRYPTO_USED(i2d_ACCESS_DESCRIPTION);
LCRYPTO_USED(AUTHORITY_INFO_ACCESS_new);
LCRYPTO_USED(AUTHORITY_INFO_ACCESS_free);
LCRYPTO_USED(d2i_AUTHORITY_INFO_ACCESS);
LCRYPTO_USED(i2d_AUTHORITY_INFO_ACCESS);
LCRYPTO_USED(POLICY_MAPPING_new);
LCRYPTO_USED(POLICY_MAPPING_free);
LCRYPTO_USED(GENERAL_SUBTREE_new);
LCRYPTO_USED(GENERAL_SUBTREE_free);
LCRYPTO_USED(NAME_CONSTRAINTS_new);
LCRYPTO_USED(NAME_CONSTRAINTS_free);
LCRYPTO_USED(POLICY_CONSTRAINTS_new);
LCRYPTO_USED(POLICY_CONSTRAINTS_free);
LCRYPTO_USED(a2i_GENERAL_NAME);
LCRYPTO_USED(v2i_GENERAL_NAME);
LCRYPTO_USED(v2i_GENERAL_NAME_ex);
LCRYPTO_USED(X509V3_conf_free);
LCRYPTO_USED(X509V3_EXT_nconf_nid);
LCRYPTO_USED(X509V3_EXT_nconf);
LCRYPTO_USED(X509V3_EXT_add_nconf_sk);
LCRYPTO_USED(X509V3_EXT_add_nconf);
LCRYPTO_USED(X509V3_EXT_REQ_add_nconf);
LCRYPTO_USED(X509V3_EXT_CRL_add_nconf);
LCRYPTO_USED(X509V3_EXT_conf_nid);
LCRYPTO_USED(X509V3_EXT_conf);
LCRYPTO_USED(X509V3_EXT_add_conf);
LCRYPTO_USED(X509V3_EXT_REQ_add_conf);
LCRYPTO_USED(X509V3_EXT_CRL_add_conf);
LCRYPTO_USED(X509V3_add_value_bool_nf);
LCRYPTO_USED(X509V3_get_value_bool);
LCRYPTO_USED(X509V3_get_value_int);
LCRYPTO_USED(X509V3_set_nconf);
LCRYPTO_USED(X509V3_set_conf_lhash);
LCRYPTO_USED(X509V3_get_string);
LCRYPTO_USED(X509V3_get_section);
LCRYPTO_USED(X509V3_string_free);
LCRYPTO_USED(X509V3_section_free);
LCRYPTO_USED(X509V3_set_ctx);
LCRYPTO_USED(X509V3_add_value);
LCRYPTO_USED(X509V3_add_value_uchar);
LCRYPTO_USED(X509V3_add_value_bool);
LCRYPTO_USED(X509V3_add_value_int);
LCRYPTO_USED(i2s_ASN1_INTEGER);
LCRYPTO_USED(s2i_ASN1_INTEGER);
LCRYPTO_USED(i2s_ASN1_ENUMERATED);
LCRYPTO_USED(i2s_ASN1_ENUMERATED_TABLE);
LCRYPTO_USED(X509V3_EXT_add);
LCRYPTO_USED(X509V3_EXT_add_list);
LCRYPTO_USED(X509V3_EXT_add_alias);
LCRYPTO_USED(X509V3_EXT_cleanup);
LCRYPTO_USED(X509V3_EXT_get);
LCRYPTO_USED(X509V3_EXT_get_nid);
LCRYPTO_USED(X509V3_add_standard_extensions);
LCRYPTO_USED(X509V3_parse_list);
LCRYPTO_USED(X509V3_EXT_d2i);
LCRYPTO_USED(X509V3_get_d2i);
LCRYPTO_USED(X509V3_EXT_i2d);
LCRYPTO_USED(X509V3_add1_i2d);
LCRYPTO_USED(hex_to_string);
LCRYPTO_USED(string_to_hex);
LCRYPTO_USED(X509V3_EXT_val_prn);
LCRYPTO_USED(X509V3_EXT_print);
LCRYPTO_USED(X509V3_EXT_print_fp);
LCRYPTO_USED(X509V3_extensions_print);
LCRYPTO_USED(X509_check_ca);
LCRYPTO_USED(X509_check_purpose);
LCRYPTO_USED(X509_supported_extension);
LCRYPTO_USED(X509_PURPOSE_set);
LCRYPTO_USED(X509_check_issued);
LCRYPTO_USED(X509_check_akid);
LCRYPTO_USED(X509_PURPOSE_get_count);
LCRYPTO_USED(X509_PURPOSE_get0);
LCRYPTO_USED(X509_PURPOSE_get_by_sname);
LCRYPTO_USED(X509_PURPOSE_get_by_id);
LCRYPTO_USED(X509_PURPOSE_add);
LCRYPTO_USED(X509_PURPOSE_get0_name);
LCRYPTO_USED(X509_PURPOSE_get0_sname);
LCRYPTO_USED(X509_PURPOSE_get_trust);
LCRYPTO_USED(X509_PURPOSE_cleanup);
LCRYPTO_USED(X509_PURPOSE_get_id);
LCRYPTO_USED(X509_get_extension_flags);
LCRYPTO_USED(X509_get_key_usage);
LCRYPTO_USED(X509_get_extended_key_usage);
LCRYPTO_USED(X509_get1_email);
LCRYPTO_USED(X509_REQ_get1_email);
LCRYPTO_USED(X509_email_free);
LCRYPTO_USED(X509_get1_ocsp);
LCRYPTO_USED(X509_check_host);
LCRYPTO_USED(X509_check_email);
LCRYPTO_USED(X509_check_ip);
LCRYPTO_USED(X509_check_ip_asc);
LCRYPTO_USED(a2i_IPADDRESS);
LCRYPTO_USED(a2i_IPADDRESS_NC);
LCRYPTO_USED(a2i_ipadd);
LCRYPTO_USED(X509V3_NAME_from_section);
LCRYPTO_USED(ASRange_new);
LCRYPTO_USED(ASRange_free);
LCRYPTO_USED(d2i_ASRange);
LCRYPTO_USED(i2d_ASRange);
LCRYPTO_USED(ASIdOrRange_new);
LCRYPTO_USED(ASIdOrRange_free);
LCRYPTO_USED(d2i_ASIdOrRange);
LCRYPTO_USED(i2d_ASIdOrRange);
LCRYPTO_USED(ASIdentifierChoice_new);
LCRYPTO_USED(ASIdentifierChoice_free);
LCRYPTO_USED(d2i_ASIdentifierChoice);
LCRYPTO_USED(i2d_ASIdentifierChoice);
LCRYPTO_USED(ASIdentifiers_new);
LCRYPTO_USED(ASIdentifiers_free);
LCRYPTO_USED(d2i_ASIdentifiers);
LCRYPTO_USED(i2d_ASIdentifiers);
LCRYPTO_USED(IPAddressRange_new);
LCRYPTO_USED(IPAddressRange_free);
LCRYPTO_USED(d2i_IPAddressRange);
LCRYPTO_USED(i2d_IPAddressRange);
LCRYPTO_USED(IPAddressOrRange_new);
LCRYPTO_USED(IPAddressOrRange_free);
LCRYPTO_USED(d2i_IPAddressOrRange);
LCRYPTO_USED(i2d_IPAddressOrRange);
LCRYPTO_USED(IPAddressChoice_new);
LCRYPTO_USED(IPAddressChoice_free);
LCRYPTO_USED(d2i_IPAddressChoice);
LCRYPTO_USED(i2d_IPAddressChoice);
LCRYPTO_USED(IPAddressFamily_new);
LCRYPTO_USED(IPAddressFamily_free);
LCRYPTO_USED(d2i_IPAddressFamily);
LCRYPTO_USED(i2d_IPAddressFamily);
LCRYPTO_USED(X509v3_asid_add_inherit);
LCRYPTO_USED(X509v3_asid_add_id_or_range);
LCRYPTO_USED(X509v3_addr_add_inherit);
LCRYPTO_USED(X509v3_addr_add_prefix);
LCRYPTO_USED(X509v3_addr_add_range);
LCRYPTO_USED(X509v3_addr_get_afi);
LCRYPTO_USED(X509v3_addr_get_range);
LCRYPTO_USED(X509v3_asid_is_canonical);
LCRYPTO_USED(X509v3_addr_is_canonical);
LCRYPTO_USED(X509v3_asid_canonize);
LCRYPTO_USED(X509v3_addr_canonize);
LCRYPTO_USED(X509v3_asid_inherits);
LCRYPTO_USED(X509v3_addr_inherits);
LCRYPTO_USED(X509v3_asid_subset);
LCRYPTO_USED(X509v3_addr_subset);
LCRYPTO_USED(X509v3_asid_validate_path);
LCRYPTO_USED(X509v3_addr_validate_path);
LCRYPTO_USED(X509v3_asid_validate_resource_set);
LCRYPTO_USED(X509v3_addr_validate_resource_set);
LCRYPTO_USED(ERR_load_X509V3_strings);
#endif /* _LIBCRYPTO_X509V3_H */