mischief/openbsd-src
1
0
Fork 0
mirror of https://github.com/openbsd/src.git synced 2024-12-22 16:42:56 -08:00
Code

Hide symbols in ts

Browse Source 
ok jsing@
This commit is contained in:
beck 2023-07-07 07:25:21 +00:00
parent d37b81742f
commit bb933e2f23
13 changed files with 608 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

190
lib/libcrypto/Symbols.namespace
View File

@ -1263,3 +1263,193 @@ _libre_BIO_vprintf
_libre_BIO_snprintf
_libre_BIO_vsnprintf
_libre_ERR_load_BIO_strings
_libre_TS_REQ_new
_libre_TS_REQ_free
_libre_i2d_TS_REQ
_libre_d2i_TS_REQ
_libre_TS_REQ_dup
_libre_d2i_TS_REQ_fp
_libre_i2d_TS_REQ_fp
_libre_d2i_TS_REQ_bio
_libre_i2d_TS_REQ_bio
_libre_TS_MSG_IMPRINT_new
_libre_TS_MSG_IMPRINT_free
_libre_i2d_TS_MSG_IMPRINT
_libre_d2i_TS_MSG_IMPRINT
_libre_TS_MSG_IMPRINT_dup
_libre_d2i_TS_MSG_IMPRINT_fp
_libre_i2d_TS_MSG_IMPRINT_fp
_libre_d2i_TS_MSG_IMPRINT_bio
_libre_i2d_TS_MSG_IMPRINT_bio
_libre_TS_RESP_new
_libre_TS_RESP_free
_libre_i2d_TS_RESP
_libre_d2i_TS_RESP
_libre_PKCS7_to_TS_TST_INFO
_libre_TS_RESP_dup
_libre_d2i_TS_RESP_fp
_libre_i2d_TS_RESP_fp
_libre_d2i_TS_RESP_bio
_libre_i2d_TS_RESP_bio
_libre_TS_STATUS_INFO_new
_libre_TS_STATUS_INFO_free
_libre_i2d_TS_STATUS_INFO
_libre_d2i_TS_STATUS_INFO
_libre_TS_STATUS_INFO_dup
_libre_TS_TST_INFO_new
_libre_TS_TST_INFO_free
_libre_i2d_TS_TST_INFO
_libre_d2i_TS_TST_INFO
_libre_TS_TST_INFO_dup
_libre_d2i_TS_TST_INFO_fp
_libre_i2d_TS_TST_INFO_fp
_libre_d2i_TS_TST_INFO_bio
_libre_i2d_TS_TST_INFO_bio
_libre_TS_ACCURACY_new
_libre_TS_ACCURACY_free
_libre_i2d_TS_ACCURACY
_libre_d2i_TS_ACCURACY
_libre_TS_ACCURACY_dup
_libre_ESS_ISSUER_SERIAL_new
_libre_ESS_ISSUER_SERIAL_free
_libre_i2d_ESS_ISSUER_SERIAL
_libre_d2i_ESS_ISSUER_SERIAL
_libre_ESS_ISSUER_SERIAL_dup
_libre_ESS_CERT_ID_new
_libre_ESS_CERT_ID_free
_libre_i2d_ESS_CERT_ID
_libre_d2i_ESS_CERT_ID
_libre_ESS_CERT_ID_dup
_libre_ESS_SIGNING_CERT_new
_libre_ESS_SIGNING_CERT_free
_libre_i2d_ESS_SIGNING_CERT
_libre_d2i_ESS_SIGNING_CERT
_libre_ESS_SIGNING_CERT_dup
_libre_TS_REQ_set_version
_libre_TS_REQ_get_version
_libre_TS_REQ_set_msg_imprint
_libre_TS_REQ_get_msg_imprint
_libre_TS_MSG_IMPRINT_set_algo
_libre_TS_MSG_IMPRINT_get_algo
_libre_TS_MSG_IMPRINT_set_msg
_libre_TS_MSG_IMPRINT_get_msg
_libre_TS_REQ_set_policy_id
_libre_TS_REQ_get_policy_id
_libre_TS_REQ_set_nonce
_libre_TS_REQ_get_nonce
_libre_TS_REQ_set_cert_req
_libre_TS_REQ_get_cert_req
_libre_TS_REQ_get_exts
_libre_TS_REQ_ext_free
_libre_TS_REQ_get_ext_count
_libre_TS_REQ_get_ext_by_NID
_libre_TS_REQ_get_ext_by_OBJ
_libre_TS_REQ_get_ext_by_critical
_libre_TS_REQ_get_ext
_libre_TS_REQ_delete_ext
_libre_TS_REQ_add_ext
_libre_TS_REQ_get_ext_d2i
_libre_TS_REQ_print_bio
_libre_TS_RESP_set_status_info
_libre_TS_RESP_get_status_info
_libre_TS_STATUS_INFO_get0_failure_info
_libre_TS_STATUS_INFO_get0_text
_libre_TS_STATUS_INFO_get0_status
_libre_TS_STATUS_INFO_set_status
_libre_TS_RESP_set_tst_info
_libre_TS_RESP_get_token
_libre_TS_RESP_get_tst_info
_libre_TS_TST_INFO_set_version
_libre_TS_TST_INFO_get_version
_libre_TS_TST_INFO_set_policy_id
_libre_TS_TST_INFO_get_policy_id
_libre_TS_TST_INFO_set_msg_imprint
_libre_TS_TST_INFO_get_msg_imprint
_libre_TS_TST_INFO_set_serial
_libre_TS_TST_INFO_get_serial
_libre_TS_TST_INFO_set_time
_libre_TS_TST_INFO_get_time
_libre_TS_TST_INFO_set_accuracy
_libre_TS_TST_INFO_get_accuracy
_libre_TS_ACCURACY_set_seconds
_libre_TS_ACCURACY_get_seconds
_libre_TS_ACCURACY_set_millis
_libre_TS_ACCURACY_get_millis
_libre_TS_ACCURACY_set_micros
_libre_TS_ACCURACY_get_micros
_libre_TS_TST_INFO_set_ordering
_libre_TS_TST_INFO_get_ordering
_libre_TS_TST_INFO_set_nonce
_libre_TS_TST_INFO_get_nonce
_libre_TS_TST_INFO_set_tsa
_libre_TS_TST_INFO_get_tsa
_libre_TS_TST_INFO_get_exts
_libre_TS_TST_INFO_ext_free
_libre_TS_TST_INFO_get_ext_count
_libre_TS_TST_INFO_get_ext_by_NID
_libre_TS_TST_INFO_get_ext_by_OBJ
_libre_TS_TST_INFO_get_ext_by_critical
_libre_TS_TST_INFO_get_ext
_libre_TS_TST_INFO_delete_ext
_libre_TS_TST_INFO_add_ext
_libre_TS_TST_INFO_get_ext_d2i
_libre_TS_RESP_CTX_new
_libre_TS_RESP_CTX_free
_libre_TS_RESP_CTX_set_signer_cert
_libre_TS_RESP_CTX_set_signer_key
_libre_TS_RESP_CTX_set_def_policy
_libre_TS_RESP_CTX_set_certs
_libre_TS_RESP_CTX_add_policy
_libre_TS_RESP_CTX_add_md
_libre_TS_RESP_CTX_set_accuracy
_libre_TS_RESP_CTX_set_clock_precision_digits
_libre_TS_RESP_CTX_add_flags
_libre_TS_RESP_CTX_set_serial_cb
_libre_TS_RESP_CTX_set_time_cb
_libre_TS_RESP_CTX_set_extension_cb
_libre_TS_RESP_CTX_set_status_info
_libre_TS_RESP_CTX_set_status_info_cond
_libre_TS_RESP_CTX_add_failure_info
_libre_TS_RESP_CTX_get_request
_libre_TS_RESP_CTX_get_tst_info
_libre_TS_RESP_create_response
_libre_TS_RESP_verify_signature
_libre_TS_RESP_verify_response
_libre_TS_RESP_verify_token
_libre_TS_VERIFY_CTX_new
_libre_TS_VERIFY_CTX_free
_libre_TS_VERIFY_CTX_cleanup
_libre_TS_VERIFY_CTX_add_flags
_libre_TS_VERIFY_CTX_set_flags
_libre_TS_VERIFY_CTX_set_data
_libre_TS_VERIFY_CTX_set_store
_libre_TS_VERIFY_CTX_set_certs
_libre_TS_VERIFY_CTX_set_imprint
_libre_TS_REQ_to_TS_VERIFY_CTX
_libre_TS_RESP_print_bio
_libre_TS_STATUS_INFO_print_bio
_libre_TS_TST_INFO_print_bio
_libre_TS_ASN1_INTEGER_print_bio
_libre_TS_OBJ_print_bio
_libre_TS_ext_print_bio
_libre_TS_X509_ALGOR_print_bio
_libre_TS_MSG_IMPRINT_print_bio
_libre_TS_CONF_load_cert
_libre_TS_CONF_load_certs
_libre_TS_CONF_load_key
_libre_TS_CONF_get_tsa_section
_libre_TS_CONF_set_serial
_libre_TS_CONF_set_crypto_device
_libre_TS_CONF_set_default_engine
_libre_TS_CONF_set_signer_cert
_libre_TS_CONF_set_certs
_libre_TS_CONF_set_signer_key
_libre_TS_CONF_set_def_policy
_libre_TS_CONF_set_policies
_libre_TS_CONF_set_digests
_libre_TS_CONF_set_accuracy
_libre_TS_CONF_set_clock_precision_digits
_libre_TS_CONF_set_ordering
_libre_TS_CONF_set_tsa_name
_libre_TS_CONF_set_ess_cert_id_chain
_libre_ERR_load_TS_strings

219
lib/libcrypto/hidden/openssl/ts.h Normal file
View File

@ -0,0 +1,219 @@
/* $OpenBSD: ts.h,v 1.1 2023/07/07 07:25:21 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_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_crypto_device);
LCRYPTO_USED(TS_CONF_set_default_engine);
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 */

64
lib/libcrypto/ts/ts_asn1.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: ts_asn1.c,v 1.13 2022/07/24 08:16:47 tb Exp $ */
/* $OpenBSD: ts_asn1.c,v 1.14 2023/07/07 07:25:21 beck Exp $ */
/* Written by Nils Larsch for the OpenSSL project 2004.
*/
/* ====================================================================
@ -97,30 +97,35 @@ d2i_TS_MSG_IMPRINT(TS_MSG_IMPRINT **a, const unsigned char **in, long len)
return (TS_MSG_IMPRINT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&TS_MSG_IMPRINT_it);
}
LCRYPTO_ALIAS(d2i_TS_MSG_IMPRINT);
int
i2d_TS_MSG_IMPRINT(const TS_MSG_IMPRINT *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_MSG_IMPRINT_it);
}
LCRYPTO_ALIAS(i2d_TS_MSG_IMPRINT);
TS_MSG_IMPRINT *
TS_MSG_IMPRINT_new(void)
{
return (TS_MSG_IMPRINT *)ASN1_item_new(&TS_MSG_IMPRINT_it);
}
LCRYPTO_ALIAS(TS_MSG_IMPRINT_new);
void
TS_MSG_IMPRINT_free(TS_MSG_IMPRINT *a)
{
ASN1_item_free((ASN1_VALUE *)a, &TS_MSG_IMPRINT_it);
}
LCRYPTO_ALIAS(TS_MSG_IMPRINT_free);
TS_MSG_IMPRINT *
TS_MSG_IMPRINT_dup(TS_MSG_IMPRINT *x)
{
return ASN1_item_dup(&TS_MSG_IMPRINT_it, x);
}
LCRYPTO_ALIAS(TS_MSG_IMPRINT_dup);
#ifndef OPENSSL_NO_BIO
TS_MSG_IMPRINT *
@ -128,12 +133,14 @@ d2i_TS_MSG_IMPRINT_bio(BIO *bp, TS_MSG_IMPRINT **a)
{
return ASN1_item_d2i_bio(&TS_MSG_IMPRINT_it, bp, a);
}
LCRYPTO_ALIAS(d2i_TS_MSG_IMPRINT_bio);
int
i2d_TS_MSG_IMPRINT_bio(BIO *bp, TS_MSG_IMPRINT *a)
{
return ASN1_item_i2d_bio(&TS_MSG_IMPRINT_it, bp, a);
}
LCRYPTO_ALIAS(i2d_TS_MSG_IMPRINT_bio);
#endif
TS_MSG_IMPRINT *
@ -141,12 +148,14 @@ d2i_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT **a)
{
return ASN1_item_d2i_fp(&TS_MSG_IMPRINT_it, fp, a);
}
LCRYPTO_ALIAS(d2i_TS_MSG_IMPRINT_fp);
int
i2d_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT *a)
{
return ASN1_item_i2d_fp(&TS_MSG_IMPRINT_it, fp, a);
}
LCRYPTO_ALIAS(i2d_TS_MSG_IMPRINT_fp);
static const ASN1_TEMPLATE TS_REQ_seq_tt[] = {
{
@ -210,30 +219,35 @@ d2i_TS_REQ(TS_REQ **a, const unsigned char **in, long len)
return (TS_REQ *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&TS_REQ_it);
}
LCRYPTO_ALIAS(d2i_TS_REQ);
int
i2d_TS_REQ(const TS_REQ *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_REQ_it);
}
LCRYPTO_ALIAS(i2d_TS_REQ);
TS_REQ *
TS_REQ_new(void)
{
return (TS_REQ *)ASN1_item_new(&TS_REQ_it);
}
LCRYPTO_ALIAS(TS_REQ_new);
void
TS_REQ_free(TS_REQ *a)
{
ASN1_item_free((ASN1_VALUE *)a, &TS_REQ_it);
}
LCRYPTO_ALIAS(TS_REQ_free);
TS_REQ *
TS_REQ_dup(TS_REQ *x)
{
return ASN1_item_dup(&TS_REQ_it, x);
}
LCRYPTO_ALIAS(TS_REQ_dup);
#ifndef OPENSSL_NO_BIO
TS_REQ *
@ -241,12 +255,14 @@ d2i_TS_REQ_bio(BIO *bp, TS_REQ **a)
{
return ASN1_item_d2i_bio(&TS_REQ_it, bp, a);
}
LCRYPTO_ALIAS(d2i_TS_REQ_bio);
int
i2d_TS_REQ_bio(BIO *bp, TS_REQ *a)
{
return ASN1_item_i2d_bio(&TS_REQ_it, bp, a);
}
LCRYPTO_ALIAS(i2d_TS_REQ_bio);
#endif
TS_REQ *
@ -254,12 +270,14 @@ d2i_TS_REQ_fp(FILE *fp, TS_REQ **a)
{
return ASN1_item_d2i_fp(&TS_REQ_it, fp, a);
}
LCRYPTO_ALIAS(d2i_TS_REQ_fp);
int
i2d_TS_REQ_fp(FILE *fp, TS_REQ *a)
{
return ASN1_item_i2d_fp(&TS_REQ_it, fp, a);
}
LCRYPTO_ALIAS(i2d_TS_REQ_fp);
static const ASN1_TEMPLATE TS_ACCURACY_seq_tt[] = {
{
@ -302,30 +320,35 @@ d2i_TS_ACCURACY(TS_ACCURACY **a, const unsigned char **in, long len)
return (TS_ACCURACY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&TS_ACCURACY_it);
}
LCRYPTO_ALIAS(d2i_TS_ACCURACY);
int
i2d_TS_ACCURACY(const TS_ACCURACY *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_ACCURACY_it);
}
LCRYPTO_ALIAS(i2d_TS_ACCURACY);
TS_ACCURACY *
TS_ACCURACY_new(void)
{
return (TS_ACCURACY *)ASN1_item_new(&TS_ACCURACY_it);
}
LCRYPTO_ALIAS(TS_ACCURACY_new);
void
TS_ACCURACY_free(TS_ACCURACY *a)
{
ASN1_item_free((ASN1_VALUE *)a, &TS_ACCURACY_it);
}
LCRYPTO_ALIAS(TS_ACCURACY_free);
TS_ACCURACY *
TS_ACCURACY_dup(TS_ACCURACY *x)
{
return ASN1_item_dup(&TS_ACCURACY_it, x);
}
LCRYPTO_ALIAS(TS_ACCURACY_dup);
static const ASN1_TEMPLATE TS_TST_INFO_seq_tt[] = {
{
@ -417,30 +440,35 @@ d2i_TS_TST_INFO(TS_TST_INFO **a, const unsigned char **in, long len)
return (TS_TST_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&TS_TST_INFO_it);
}
LCRYPTO_ALIAS(d2i_TS_TST_INFO);
int
i2d_TS_TST_INFO(const TS_TST_INFO *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_TST_INFO_it);
}
LCRYPTO_ALIAS(i2d_TS_TST_INFO);
TS_TST_INFO *
TS_TST_INFO_new(void)
{
return (TS_TST_INFO *)ASN1_item_new(&TS_TST_INFO_it);
}
LCRYPTO_ALIAS(TS_TST_INFO_new);
void
TS_TST_INFO_free(TS_TST_INFO *a)
{
ASN1_item_free((ASN1_VALUE *)a, &TS_TST_INFO_it);
}
LCRYPTO_ALIAS(TS_TST_INFO_free);
TS_TST_INFO *
TS_TST_INFO_dup(TS_TST_INFO *x)
{
return ASN1_item_dup(&TS_TST_INFO_it, x);
}
LCRYPTO_ALIAS(TS_TST_INFO_dup);
#ifndef OPENSSL_NO_BIO
TS_TST_INFO *
@ -448,12 +476,14 @@ d2i_TS_TST_INFO_bio(BIO *bp, TS_TST_INFO **a)
{
return ASN1_item_d2i_bio(&TS_TST_INFO_it, bp, a);
}
LCRYPTO_ALIAS(d2i_TS_TST_INFO_bio);
int
i2d_TS_TST_INFO_bio(BIO *bp, TS_TST_INFO *a)
{
return ASN1_item_i2d_bio(&TS_TST_INFO_it, bp, a);
}
LCRYPTO_ALIAS(i2d_TS_TST_INFO_bio);
#endif
TS_TST_INFO *
@ -461,12 +491,14 @@ d2i_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO **a)
{
return ASN1_item_d2i_fp(&TS_TST_INFO_it, fp, a);
}
LCRYPTO_ALIAS(d2i_TS_TST_INFO_fp);
int
i2d_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO *a)
{
return ASN1_item_i2d_fp(&TS_TST_INFO_it, fp, a);
}
LCRYPTO_ALIAS(i2d_TS_TST_INFO_fp);
static const ASN1_TEMPLATE TS_STATUS_INFO_seq_tt[] = {
{
@ -509,30 +541,35 @@ d2i_TS_STATUS_INFO(TS_STATUS_INFO **a, const unsigned char **in, long len)
return (TS_STATUS_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&TS_STATUS_INFO_it);
}
LCRYPTO_ALIAS(d2i_TS_STATUS_INFO);
int
i2d_TS_STATUS_INFO(const TS_STATUS_INFO *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_STATUS_INFO_it);
}
LCRYPTO_ALIAS(i2d_TS_STATUS_INFO);
TS_STATUS_INFO *
TS_STATUS_INFO_new(void)
{
return (TS_STATUS_INFO *)ASN1_item_new(&TS_STATUS_INFO_it);
}
LCRYPTO_ALIAS(TS_STATUS_INFO_new);
void
TS_STATUS_INFO_free(TS_STATUS_INFO *a)
{
ASN1_item_free((ASN1_VALUE *)a, &TS_STATUS_INFO_it);
}
LCRYPTO_ALIAS(TS_STATUS_INFO_free);
TS_STATUS_INFO *
TS_STATUS_INFO_dup(TS_STATUS_INFO *x)
{
return ASN1_item_dup(&TS_STATUS_INFO_it, x);
}
LCRYPTO_ALIAS(TS_STATUS_INFO_dup);
static int
ts_resp_set_tst_info(TS_RESP *a)
@ -620,30 +657,35 @@ d2i_TS_RESP(TS_RESP **a, const unsigned char **in, long len)
return (TS_RESP *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&TS_RESP_it);
}
LCRYPTO_ALIAS(d2i_TS_RESP);
int
i2d_TS_RESP(const TS_RESP *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_RESP_it);
}
LCRYPTO_ALIAS(i2d_TS_RESP);
TS_RESP *
TS_RESP_new(void)
{
return (TS_RESP *)ASN1_item_new(&TS_RESP_it);
}
LCRYPTO_ALIAS(TS_RESP_new);
void
TS_RESP_free(TS_RESP *a)
{
ASN1_item_free((ASN1_VALUE *)a, &TS_RESP_it);
}
LCRYPTO_ALIAS(TS_RESP_free);
TS_RESP *
TS_RESP_dup(TS_RESP *x)
{
return ASN1_item_dup(&TS_RESP_it, x);
}
LCRYPTO_ALIAS(TS_RESP_dup);
#ifndef OPENSSL_NO_BIO
TS_RESP *
@ -651,12 +693,14 @@ d2i_TS_RESP_bio(BIO *bp, TS_RESP **a)
{
return ASN1_item_d2i_bio(&TS_RESP_it, bp, a);
}
LCRYPTO_ALIAS(d2i_TS_RESP_bio);
int
i2d_TS_RESP_bio(BIO *bp, TS_RESP *a)
{
return ASN1_item_i2d_bio(&TS_RESP_it, bp, a);
}
LCRYPTO_ALIAS(i2d_TS_RESP_bio);
#endif
TS_RESP *
@ -664,12 +708,14 @@ d2i_TS_RESP_fp(FILE *fp, TS_RESP **a)
{
return ASN1_item_d2i_fp(&TS_RESP_it, fp, a);
}
LCRYPTO_ALIAS(d2i_TS_RESP_fp);
int
i2d_TS_RESP_fp(FILE *fp, TS_RESP *a)
{
return ASN1_item_i2d_fp(&TS_RESP_it, fp, a);
}
LCRYPTO_ALIAS(i2d_TS_RESP_fp);
static const ASN1_TEMPLATE ESS_ISSUER_SERIAL_seq_tt[] = {
{
@ -705,30 +751,35 @@ d2i_ESS_ISSUER_SERIAL(ESS_ISSUER_SERIAL **a, const unsigned char **in, long len)
return (ESS_ISSUER_SERIAL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ESS_ISSUER_SERIAL_it);
}
LCRYPTO_ALIAS(d2i_ESS_ISSUER_SERIAL);
int
i2d_ESS_ISSUER_SERIAL(const ESS_ISSUER_SERIAL *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_ISSUER_SERIAL_it);
}
LCRYPTO_ALIAS(i2d_ESS_ISSUER_SERIAL);
ESS_ISSUER_SERIAL *
ESS_ISSUER_SERIAL_new(void)
{
return (ESS_ISSUER_SERIAL *)ASN1_item_new(&ESS_ISSUER_SERIAL_it);
}
LCRYPTO_ALIAS(ESS_ISSUER_SERIAL_new);
void
ESS_ISSUER_SERIAL_free(ESS_ISSUER_SERIAL *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ESS_ISSUER_SERIAL_it);
}
LCRYPTO_ALIAS(ESS_ISSUER_SERIAL_free);
ESS_ISSUER_SERIAL *
ESS_ISSUER_SERIAL_dup(ESS_ISSUER_SERIAL *x)
{
return ASN1_item_dup(&ESS_ISSUER_SERIAL_it, x);
}
LCRYPTO_ALIAS(ESS_ISSUER_SERIAL_dup);
static const ASN1_TEMPLATE ESS_CERT_ID_seq_tt[] = {
{
@ -764,30 +815,35 @@ d2i_ESS_CERT_ID(ESS_CERT_ID **a, const unsigned char **in, long len)
return (ESS_CERT_ID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ESS_CERT_ID_it);
}
LCRYPTO_ALIAS(d2i_ESS_CERT_ID);
int
i2d_ESS_CERT_ID(const ESS_CERT_ID *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_CERT_ID_it);
}
LCRYPTO_ALIAS(i2d_ESS_CERT_ID);
ESS_CERT_ID *
ESS_CERT_ID_new(void)
{
return (ESS_CERT_ID *)ASN1_item_new(&ESS_CERT_ID_it);
}
LCRYPTO_ALIAS(ESS_CERT_ID_new);
void
ESS_CERT_ID_free(ESS_CERT_ID *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ESS_CERT_ID_it);
}
LCRYPTO_ALIAS(ESS_CERT_ID_free);
ESS_CERT_ID *
ESS_CERT_ID_dup(ESS_CERT_ID *x)
{
return ASN1_item_dup(&ESS_CERT_ID_it, x);
}
LCRYPTO_ALIAS(ESS_CERT_ID_dup);
static const ASN1_TEMPLATE ESS_SIGNING_CERT_seq_tt[] = {
{
@ -823,30 +879,35 @@ d2i_ESS_SIGNING_CERT(ESS_SIGNING_CERT **a, const unsigned char **in, long len)
return (ESS_SIGNING_CERT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ESS_SIGNING_CERT_it);
}
LCRYPTO_ALIAS(d2i_ESS_SIGNING_CERT);
int
i2d_ESS_SIGNING_CERT(const ESS_SIGNING_CERT *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_SIGNING_CERT_it);
}
LCRYPTO_ALIAS(i2d_ESS_SIGNING_CERT);
ESS_SIGNING_CERT *
ESS_SIGNING_CERT_new(void)
{
return (ESS_SIGNING_CERT *)ASN1_item_new(&ESS_SIGNING_CERT_it);
}
LCRYPTO_ALIAS(ESS_SIGNING_CERT_new);
void
ESS_SIGNING_CERT_free(ESS_SIGNING_CERT *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ESS_SIGNING_CERT_it);
}
LCRYPTO_ALIAS(ESS_SIGNING_CERT_free);
ESS_SIGNING_CERT *
ESS_SIGNING_CERT_dup(ESS_SIGNING_CERT *x)
{
return ASN1_item_dup(&ESS_SIGNING_CERT_it, x);
}
LCRYPTO_ALIAS(ESS_SIGNING_CERT_dup);
static const ASN1_TEMPLATE ESS_CERT_ID_V2_seq_tt[] = {
{
@ -1013,3 +1074,4 @@ PKCS7_to_TS_TST_INFO(PKCS7 *token)
p = tst_info_der->data;
return d2i_TS_TST_INFO(NULL, &p, tst_info_der->length);
}
LCRYPTO_ALIAS(PKCS7_to_TS_TST_INFO);

20
lib/libcrypto/ts/ts_conf.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: ts_conf.c,v 1.11 2018/04/14 07:18:37 tb Exp $ */
/* $OpenBSD: ts_conf.c,v 1.12 2023/07/07 07:25:21 beck Exp $ */
/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL
* project 2002.
*/
@ -110,6 +110,7 @@ end:
BIO_free(cert);
return x;
}
LCRYPTO_ALIAS(TS_CONF_load_cert);
STACK_OF(X509) *
TS_CONF_load_certs(const char *file)
@ -144,6 +145,7 @@ end:
BIO_free(certs);
return othercerts;
}
LCRYPTO_ALIAS(TS_CONF_load_certs);
EVP_PKEY *
TS_CONF_load_key(const char *file, const char *pass)
@ -161,6 +163,7 @@ end:
BIO_free(key);
return pkey;
}
LCRYPTO_ALIAS(TS_CONF_load_key);
/* Function definitions for handling configuration options. */
@ -186,6 +189,7 @@ TS_CONF_get_tsa_section(CONF *conf, const char *section)
}
return section;
}
LCRYPTO_ALIAS(TS_CONF_get_tsa_section);
int
TS_CONF_set_serial(CONF *conf, const char *section, TS_serial_cb cb,
@ -205,6 +209,7 @@ TS_CONF_set_serial(CONF *conf, const char *section, TS_serial_cb cb,
err:
return ret;
}
LCRYPTO_ALIAS(TS_CONF_set_serial);
#ifndef OPENSSL_NO_ENGINE
@ -225,6 +230,7 @@ TS_CONF_set_crypto_device(CONF *conf, const char *section, const char *device)
err:
return ret;
}
LCRYPTO_ALIAS(TS_CONF_set_crypto_device);
int
TS_CONF_set_default_engine(const char *name)
@ -251,6 +257,7 @@ err:
ENGINE_free(e);
return ret;
}
LCRYPTO_ALIAS(TS_CONF_set_default_engine);
#endif
@ -278,6 +285,7 @@ err:
X509_free(cert_obj);
return ret;
}
LCRYPTO_ALIAS(TS_CONF_set_signer_cert);
int
TS_CONF_set_certs(CONF *conf, const char *section, const char *certs,
@ -302,6 +310,7 @@ err:
sk_X509_pop_free(certs_obj, X509_free);
return ret;
}
LCRYPTO_ALIAS(TS_CONF_set_certs);
int
TS_CONF_set_signer_key(CONF *conf, const char *section, const char *key,
@ -327,6 +336,7 @@ err:
EVP_PKEY_free(key_obj);
return ret;
}
LCRYPTO_ALIAS(TS_CONF_set_signer_key);
int
TS_CONF_set_def_policy(CONF *conf, const char *section, const char *policy,
@ -354,6 +364,7 @@ err:
ASN1_OBJECT_free(policy_obj);
return ret;
}
LCRYPTO_ALIAS(TS_CONF_set_def_policy);
int
TS_CONF_set_policies(CONF *conf, const char *section, TS_RESP_CTX *ctx)
@ -387,6 +398,7 @@ err:
sk_CONF_VALUE_pop_free(list, X509V3_conf_free);
return ret;
}
LCRYPTO_ALIAS(TS_CONF_set_policies);
int
TS_CONF_set_digests(CONF *conf, const char *section, TS_RESP_CTX *ctx)
@ -426,6 +438,7 @@ err:
sk_CONF_VALUE_pop_free(list, X509V3_conf_free);
return ret;
}
LCRYPTO_ALIAS(TS_CONF_set_digests);
int
TS_CONF_set_accuracy(CONF *conf, const char *section, TS_RESP_CTX *ctx)
@ -465,6 +478,7 @@ err:
sk_CONF_VALUE_pop_free(list, X509V3_conf_free);
return ret;
}
LCRYPTO_ALIAS(TS_CONF_set_accuracy);
int
TS_CONF_set_clock_precision_digits(CONF *conf, const char *section,
@ -490,6 +504,7 @@ TS_CONF_set_clock_precision_digits(CONF *conf, const char *section,
err:
return ret;
}
LCRYPTO_ALIAS(TS_CONF_set_clock_precision_digits);
static int
TS_CONF_add_flag(CONF *conf, const char *section, const char *field, int flag,
@ -515,12 +530,14 @@ TS_CONF_set_ordering(CONF *conf, const char *section, TS_RESP_CTX *ctx)
{
return TS_CONF_add_flag(conf, section, ENV_ORDERING, TS_ORDERING, ctx);
}
LCRYPTO_ALIAS(TS_CONF_set_ordering);
int
TS_CONF_set_tsa_name(CONF *conf, const char *section, TS_RESP_CTX *ctx)
{
return TS_CONF_add_flag(conf, section, ENV_TSA_NAME, TS_TSA_NAME, ctx);
}
LCRYPTO_ALIAS(TS_CONF_set_tsa_name);
int
TS_CONF_set_ess_cert_id_chain(CONF *conf, const char *section, TS_RESP_CTX *ctx)
@ -528,3 +545,4 @@ TS_CONF_set_ess_cert_id_chain(CONF *conf, const char *section, TS_RESP_CTX *ctx)
return TS_CONF_add_flag(conf, section, ENV_ESS_CERT_ID_CHAIN,
TS_ESS_CERT_ID_CHAIN, ctx);
}
LCRYPTO_ALIAS(TS_CONF_set_ess_cert_id_chain);

3
lib/libcrypto/ts/ts_err.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: ts_err.c,v 1.6 2022/07/12 14:42:50 kn Exp $ */
/* $OpenBSD: ts_err.c,v 1.7 2023/07/07 07:25:21 beck Exp $ */
/* ====================================================================
* Copyright (c) 1999-2007 The OpenSSL Project. All rights reserved.
*
@ -121,3 +121,4 @@ ERR_load_TS_strings(void)
}
#endif
}
LCRYPTO_ALIAS(ERR_load_TS_strings);

7
lib/libcrypto/ts/ts_lib.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: ts_lib.c,v 1.13 2022/11/26 16:08:54 tb Exp $ */
/* $OpenBSD: ts_lib.c,v 1.14 2023/07/07 07:25:21 beck Exp $ */
/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL
* project 2002.
*/
@ -89,6 +89,7 @@ TS_ASN1_INTEGER_print_bio(BIO *bio, const ASN1_INTEGER *num)
return result;
}
LCRYPTO_ALIAS(TS_ASN1_INTEGER_print_bio);
int
TS_OBJ_print_bio(BIO *bio, const ASN1_OBJECT *obj)
@ -102,6 +103,7 @@ TS_OBJ_print_bio(BIO *bio, const ASN1_OBJECT *obj)
BIO_write(bio, "\n", 1);
return 1;
}
LCRYPTO_ALIAS(TS_OBJ_print_bio);
int
TS_ext_print_bio(BIO *bio, const STACK_OF(X509_EXTENSION) *extensions)
@ -127,6 +129,7 @@ TS_ext_print_bio(BIO *bio, const STACK_OF(X509_EXTENSION) *extensions)
return 1;
}
LCRYPTO_ALIAS(TS_ext_print_bio);
int
TS_X509_ALGOR_print_bio(BIO *bio, const X509_ALGOR *alg)
@ -136,6 +139,7 @@ TS_X509_ALGOR_print_bio(BIO *bio, const X509_ALGOR *alg)
return BIO_printf(bio, "Hash Algorithm: %s\n",
(i == NID_undef) ? "UNKNOWN" : OBJ_nid2ln(i));
}
LCRYPTO_ALIAS(TS_X509_ALGOR_print_bio);
int
TS_MSG_IMPRINT_print_bio(BIO *bio, TS_MSG_IMPRINT *a)
@ -151,3 +155,4 @@ TS_MSG_IMPRINT_print_bio(BIO *bio, TS_MSG_IMPRINT *a)
return 1;
}
LCRYPTO_ALIAS(TS_MSG_IMPRINT_print_bio);

3
lib/libcrypto/ts/ts_req_print.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: ts_req_print.c,v 1.4 2014/07/11 08:44:49 jsing Exp $ */
/* $OpenBSD: ts_req_print.c,v 1.5 2023/07/07 07:25:21 beck Exp $ */
/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL
* project 2002.
*/
@ -102,3 +102,4 @@ TS_REQ_print_bio(BIO *bio, TS_REQ *a)
return 1;
}
LCRYPTO_ALIAS(TS_REQ_print_bio);

25
lib/libcrypto/ts/ts_req_utils.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: ts_req_utils.c,v 1.7 2022/07/24 08:16:47 tb Exp $ */
/* $OpenBSD: ts_req_utils.c,v 1.8 2023/07/07 07:25:21 beck Exp $ */
/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL
* project 2002.
*/
@ -70,12 +70,14 @@ TS_REQ_set_version(TS_REQ *a, long version)
{
return ASN1_INTEGER_set(a->version, version);
}
LCRYPTO_ALIAS(TS_REQ_set_version);
long
TS_REQ_get_version(const TS_REQ *a)
{
return ASN1_INTEGER_get(a->version);
}
LCRYPTO_ALIAS(TS_REQ_get_version);
int
TS_REQ_set_msg_imprint(TS_REQ *a, TS_MSG_IMPRINT *msg_imprint)
@ -93,12 +95,14 @@ TS_REQ_set_msg_imprint(TS_REQ *a, TS_MSG_IMPRINT *msg_imprint)
a->msg_imprint = new_msg_imprint;
return 1;
}
LCRYPTO_ALIAS(TS_REQ_set_msg_imprint);
TS_MSG_IMPRINT *
TS_REQ_get_msg_imprint(TS_REQ *a)
{
return a->msg_imprint;
}
LCRYPTO_ALIAS(TS_REQ_get_msg_imprint);
int
TS_MSG_IMPRINT_set_algo(TS_MSG_IMPRINT *a, X509_ALGOR *alg)
@ -116,24 +120,28 @@ TS_MSG_IMPRINT_set_algo(TS_MSG_IMPRINT *a, X509_ALGOR *alg)
a->hash_algo = new_alg;
return 1;
}
LCRYPTO_ALIAS(TS_MSG_IMPRINT_set_algo);
X509_ALGOR *
TS_MSG_IMPRINT_get_algo(TS_MSG_IMPRINT *a)
{
return a->hash_algo;
}
LCRYPTO_ALIAS(TS_MSG_IMPRINT_get_algo);
int
TS_MSG_IMPRINT_set_msg(TS_MSG_IMPRINT *a, unsigned char *d, int len)
{
return ASN1_OCTET_STRING_set(a->hashed_msg, d, len);
}
LCRYPTO_ALIAS(TS_MSG_IMPRINT_set_msg);
ASN1_OCTET_STRING *
TS_MSG_IMPRINT_get_msg(TS_MSG_IMPRINT *a)
{
return a->hashed_msg;
}
LCRYPTO_ALIAS(TS_MSG_IMPRINT_get_msg);
int
TS_REQ_set_policy_id(TS_REQ *a, const ASN1_OBJECT *policy)
@ -151,12 +159,14 @@ TS_REQ_set_policy_id(TS_REQ *a, const ASN1_OBJECT *policy)
a->policy_id = new_policy;
return 1;
}
LCRYPTO_ALIAS(TS_REQ_set_policy_id);
ASN1_OBJECT *
TS_REQ_get_policy_id(TS_REQ *a)
{
return a->policy_id;
}
LCRYPTO_ALIAS(TS_REQ_get_policy_id);
int
TS_REQ_set_nonce(TS_REQ *a, const ASN1_INTEGER *nonce)
@ -174,12 +184,14 @@ TS_REQ_set_nonce(TS_REQ *a, const ASN1_INTEGER *nonce)
a->nonce = new_nonce;
return 1;
}
LCRYPTO_ALIAS(TS_REQ_set_nonce);
const ASN1_INTEGER *
TS_REQ_get_nonce(const TS_REQ *a)
{
return a->nonce;
}
LCRYPTO_ALIAS(TS_REQ_get_nonce);
int
TS_REQ_set_cert_req(TS_REQ *a, int cert_req)
@ -187,12 +199,14 @@ TS_REQ_set_cert_req(TS_REQ *a, int cert_req)
a->cert_req = cert_req ? 0xFF : 0x00;
return 1;
}
LCRYPTO_ALIAS(TS_REQ_set_cert_req);
int
TS_REQ_get_cert_req(const TS_REQ *a)
{
return a->cert_req ? 1 : 0;
}
LCRYPTO_ALIAS(TS_REQ_get_cert_req);
STACK_OF(X509_EXTENSION) *TS_REQ_get_exts(TS_REQ *a)
{
@ -207,51 +221,60 @@ TS_REQ_ext_free(TS_REQ *a)
sk_X509_EXTENSION_pop_free(a->extensions, X509_EXTENSION_free);
a->extensions = NULL;
}
LCRYPTO_ALIAS(TS_REQ_ext_free);
int
TS_REQ_get_ext_count(TS_REQ *a)
{
return X509v3_get_ext_count(a->extensions);
}
LCRYPTO_ALIAS(TS_REQ_get_ext_count);
int
TS_REQ_get_ext_by_NID(TS_REQ *a, int nid, int lastpos)
{
return X509v3_get_ext_by_NID(a->extensions, nid, lastpos);
}
LCRYPTO_ALIAS(TS_REQ_get_ext_by_NID);
int
TS_REQ_get_ext_by_OBJ(TS_REQ *a, const ASN1_OBJECT *obj, int lastpos)
{
return X509v3_get_ext_by_OBJ(a->extensions, obj, lastpos);
}
LCRYPTO_ALIAS(TS_REQ_get_ext_by_OBJ);
int
TS_REQ_get_ext_by_critical(TS_REQ *a, int crit, int lastpos)
{
return X509v3_get_ext_by_critical(a->extensions, crit, lastpos);
}
LCRYPTO_ALIAS(TS_REQ_get_ext_by_critical);
X509_EXTENSION *
TS_REQ_get_ext(TS_REQ *a, int loc)
{
return X509v3_get_ext(a->extensions, loc);
}
LCRYPTO_ALIAS(TS_REQ_get_ext);
X509_EXTENSION *
TS_REQ_delete_ext(TS_REQ *a, int loc)
{
return X509v3_delete_ext(a->extensions, loc);
}
LCRYPTO_ALIAS(TS_REQ_delete_ext);
int
TS_REQ_add_ext(TS_REQ *a, X509_EXTENSION *ex, int loc)
{
return X509v3_add_ext(&a->extensions, ex, loc) != NULL;
}
LCRYPTO_ALIAS(TS_REQ_add_ext);
void *
TS_REQ_get_ext_d2i(TS_REQ *a, int nid, int *crit, int *idx)
{
return X509V3_get_d2i(a->extensions, nid, crit, idx);
}
LCRYPTO_ALIAS(TS_REQ_get_ext_d2i);

5
lib/libcrypto/ts/ts_rsp_print.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: ts_rsp_print.c,v 1.6 2022/07/24 08:16:47 tb Exp $ */
/* $OpenBSD: ts_rsp_print.c,v 1.7 2023/07/07 07:25:21 beck Exp $ */
/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL
* project 2002.
*/
@ -95,6 +95,7 @@ TS_RESP_print_bio(BIO *bio, TS_RESP *a)
return 1;
}
LCRYPTO_ALIAS(TS_RESP_print_bio);
int
TS_STATUS_INFO_print_bio(BIO *bio, TS_STATUS_INFO *a)
@ -177,6 +178,7 @@ TS_STATUS_INFO_print_bio(BIO *bio, TS_STATUS_INFO *a)
return 1;
}
LCRYPTO_ALIAS(TS_STATUS_INFO_print_bio);
static int
TS_status_map_print(BIO *bio, struct status_map_st *a, ASN1_BIT_STRING *v)
@ -275,6 +277,7 @@ TS_TST_INFO_print_bio(BIO *bio, TS_TST_INFO *a)
return 1;
}
LCRYPTO_ALIAS(TS_TST_INFO_print_bio);
static int
TS_ACCURACY_print_bio(BIO *bio, const TS_ACCURACY *accuracy)

22
lib/libcrypto/ts/ts_rsp_sign.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: ts_rsp_sign.c,v 1.30 2022/11/26 16:08:54 tb Exp $ */
/* $OpenBSD: ts_rsp_sign.c,v 1.31 2023/07/07 07:25:21 beck Exp $ */
/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL
* project 2002.
*/
@ -149,6 +149,7 @@ TS_RESP_CTX_set_time_cb(TS_RESP_CTX *ctx, TS_time_cb cb, void *data)
ctx->time_cb = cb;
ctx->time_cb_data = data;
}
LCRYPTO_ALIAS(TS_RESP_CTX_set_time_cb);
/* TS_RESP_CTX management functions. */
@ -169,6 +170,7 @@ TS_RESP_CTX_new(void)
return ctx;
}
LCRYPTO_ALIAS(TS_RESP_CTX_new);
void
TS_RESP_CTX_free(TS_RESP_CTX *ctx)
@ -187,6 +189,7 @@ TS_RESP_CTX_free(TS_RESP_CTX *ctx)
ASN1_INTEGER_free(ctx->micros);
free(ctx);
}
LCRYPTO_ALIAS(TS_RESP_CTX_free);
int
TS_RESP_CTX_set_signer_cert(TS_RESP_CTX *ctx, X509 *signer)
@ -200,6 +203,7 @@ TS_RESP_CTX_set_signer_cert(TS_RESP_CTX *ctx, X509 *signer)
CRYPTO_add(&ctx->signer_cert->references, +1, CRYPTO_LOCK_X509);
return 1;
}
LCRYPTO_ALIAS(TS_RESP_CTX_set_signer_cert);
int
TS_RESP_CTX_set_signer_key(TS_RESP_CTX *ctx, EVP_PKEY *key)
@ -210,6 +214,7 @@ TS_RESP_CTX_set_signer_key(TS_RESP_CTX *ctx, EVP_PKEY *key)
return 1;
}
LCRYPTO_ALIAS(TS_RESP_CTX_set_signer_key);
int
TS_RESP_CTX_set_def_policy(TS_RESP_CTX *ctx, const ASN1_OBJECT *def_policy)
@ -224,6 +229,7 @@ err:
TSerror(ERR_R_MALLOC_FAILURE);
return 0;
}
LCRYPTO_ALIAS(TS_RESP_CTX_set_def_policy);
int
TS_RESP_CTX_set_certs(TS_RESP_CTX *ctx, STACK_OF(X509) *certs)
@ -247,6 +253,7 @@ TS_RESP_CTX_set_certs(TS_RESP_CTX *ctx, STACK_OF(X509) *certs)
return 1;
}
LCRYPTO_ALIAS(TS_RESP_CTX_set_certs);
int
TS_RESP_CTX_add_policy(TS_RESP_CTX *ctx, const ASN1_OBJECT *policy)
@ -268,6 +275,7 @@ err:
ASN1_OBJECT_free(copy);
return 0;
}
LCRYPTO_ALIAS(TS_RESP_CTX_add_policy);
int
TS_RESP_CTX_add_md(TS_RESP_CTX *ctx, const EVP_MD *md)
@ -285,6 +293,7 @@ err:
TSerror(ERR_R_MALLOC_FAILURE);
return 0;
}
LCRYPTO_ALIAS(TS_RESP_CTX_add_md);
#define TS_RESP_CTX_accuracy_free(ctx) \
ASN1_INTEGER_free(ctx->seconds); \
@ -315,12 +324,14 @@ err:
TSerror(ERR_R_MALLOC_FAILURE);
return 0;
}
LCRYPTO_ALIAS(TS_RESP_CTX_set_accuracy);
void
TS_RESP_CTX_add_flags(TS_RESP_CTX *ctx, int flags)
{
ctx->flags |= flags;
}
LCRYPTO_ALIAS(TS_RESP_CTX_add_flags);
void
TS_RESP_CTX_set_serial_cb(TS_RESP_CTX *ctx, TS_serial_cb cb, void *data)
@ -328,6 +339,7 @@ TS_RESP_CTX_set_serial_cb(TS_RESP_CTX *ctx, TS_serial_cb cb, void *data)
ctx->serial_cb = cb;
ctx->serial_cb_data = data;
}
LCRYPTO_ALIAS(TS_RESP_CTX_set_serial_cb);
void
TS_RESP_CTX_set_extension_cb(TS_RESP_CTX *ctx, TS_extension_cb cb, void *data)
@ -335,6 +347,7 @@ TS_RESP_CTX_set_extension_cb(TS_RESP_CTX *ctx, TS_extension_cb cb, void *data)
ctx->extension_cb = cb;
ctx->extension_cb_data = data;
}
LCRYPTO_ALIAS(TS_RESP_CTX_set_extension_cb);
int
TS_RESP_CTX_set_status_info(TS_RESP_CTX *ctx, int status, const char *text)
@ -368,6 +381,7 @@ err:
ASN1_UTF8STRING_free(utf8_text);
return ret;
}
LCRYPTO_ALIAS(TS_RESP_CTX_set_status_info);
int
TS_RESP_CTX_set_status_info_cond(TS_RESP_CTX *ctx, int status, const char *text)
@ -381,6 +395,7 @@ TS_RESP_CTX_set_status_info_cond(TS_RESP_CTX *ctx, int status, const char *text)
}
return ret;
}
LCRYPTO_ALIAS(TS_RESP_CTX_set_status_info_cond);
int
TS_RESP_CTX_add_failure_info(TS_RESP_CTX *ctx, int failure)
@ -397,18 +412,21 @@ err:
TSerror(ERR_R_MALLOC_FAILURE);
return 0;
}
LCRYPTO_ALIAS(TS_RESP_CTX_add_failure_info);
TS_REQ *
TS_RESP_CTX_get_request(TS_RESP_CTX *ctx)
{
return ctx->request;
}
LCRYPTO_ALIAS(TS_RESP_CTX_get_request);
TS_TST_INFO *
TS_RESP_CTX_get_tst_info(TS_RESP_CTX *ctx)
{
return ctx->tst_info;
}
LCRYPTO_ALIAS(TS_RESP_CTX_get_tst_info);
int
TS_RESP_CTX_set_clock_precision_digits(TS_RESP_CTX *ctx, unsigned precision)
@ -418,6 +436,7 @@ TS_RESP_CTX_set_clock_precision_digits(TS_RESP_CTX *ctx, unsigned precision)
ctx->clock_precision_digits = precision;
return 1;
}
LCRYPTO_ALIAS(TS_RESP_CTX_set_clock_precision_digits);
/* Main entry method of the response generation. */
TS_RESP *
@ -488,6 +507,7 @@ end:
TS_RESP_CTX_cleanup(ctx);
return response;
}
LCRYPTO_ALIAS(TS_RESP_create_response);
/* Initializes the variable part of the context. */
static void

44
lib/libcrypto/ts/ts_rsp_utils.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: ts_rsp_utils.c,v 1.9 2022/07/24 19:25:36 tb Exp $ */
/* $OpenBSD: ts_rsp_utils.c,v 1.10 2023/07/07 07:25:21 beck Exp $ */
/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL
* project 2002.
*/
@ -84,36 +84,42 @@ TS_RESP_set_status_info(TS_RESP *a, TS_STATUS_INFO *status_info)
return 1;
}
LCRYPTO_ALIAS(TS_RESP_set_status_info);
TS_STATUS_INFO *
TS_RESP_get_status_info(TS_RESP *a)
{
return a->status_info;
}
LCRYPTO_ALIAS(TS_RESP_get_status_info);
const ASN1_UTF8STRING *
TS_STATUS_INFO_get0_failure_info(const TS_STATUS_INFO *si)
{
return si->failure_info;
}
LCRYPTO_ALIAS(TS_STATUS_INFO_get0_failure_info);
const STACK_OF(ASN1_UTF8STRING) *
TS_STATUS_INFO_get0_text(const TS_STATUS_INFO *si)
{
return si->text;
}
LCRYPTO_ALIAS(TS_STATUS_INFO_get0_text);
const ASN1_INTEGER *
TS_STATUS_INFO_get0_status(const TS_STATUS_INFO *si)
{
return si->status;
}
LCRYPTO_ALIAS(TS_STATUS_INFO_get0_status);
int
TS_STATUS_INFO_set_status(TS_STATUS_INFO *si, int i)
{
return ASN1_INTEGER_set(si->status, i);
}
LCRYPTO_ALIAS(TS_STATUS_INFO_set_status);
/* Caller loses ownership of PKCS7 and TS_TST_INFO objects. */
void
@ -125,30 +131,35 @@ TS_RESP_set_tst_info(TS_RESP *a, PKCS7 *p7, TS_TST_INFO *tst_info)
TS_TST_INFO_free(a->tst_info);
a->tst_info = tst_info;
}
LCRYPTO_ALIAS(TS_RESP_set_tst_info);
PKCS7 *
TS_RESP_get_token(TS_RESP *a)
{
return a->token;
}
LCRYPTO_ALIAS(TS_RESP_get_token);
TS_TST_INFO *
TS_RESP_get_tst_info(TS_RESP *a)
{
return a->tst_info;
}
LCRYPTO_ALIAS(TS_RESP_get_tst_info);
int
TS_TST_INFO_set_version(TS_TST_INFO *a, long version)
{
return ASN1_INTEGER_set(a->version, version);
}
LCRYPTO_ALIAS(TS_TST_INFO_set_version);
long
TS_TST_INFO_get_version(const TS_TST_INFO *a)
{
return ASN1_INTEGER_get(a->version);
}
LCRYPTO_ALIAS(TS_TST_INFO_get_version);
int
TS_TST_INFO_set_policy_id(TS_TST_INFO *a, ASN1_OBJECT *policy)
@ -166,12 +177,14 @@ TS_TST_INFO_set_policy_id(TS_TST_INFO *a, ASN1_OBJECT *policy)
a->policy_id = new_policy;
return 1;
}
LCRYPTO_ALIAS(TS_TST_INFO_set_policy_id);
ASN1_OBJECT *
TS_TST_INFO_get_policy_id(TS_TST_INFO *a)
{
return a->policy_id;
}
LCRYPTO_ALIAS(TS_TST_INFO_get_policy_id);
int
TS_TST_INFO_set_msg_imprint(TS_TST_INFO *a, TS_MSG_IMPRINT *msg_imprint)
@ -189,12 +202,14 @@ TS_TST_INFO_set_msg_imprint(TS_TST_INFO *a, TS_MSG_IMPRINT *msg_imprint)
a->msg_imprint = new_msg_imprint;
return 1;
}
LCRYPTO_ALIAS(TS_TST_INFO_set_msg_imprint);
TS_MSG_IMPRINT *
TS_TST_INFO_get_msg_imprint(TS_TST_INFO *a)
{
return a->msg_imprint;
}
LCRYPTO_ALIAS(TS_TST_INFO_get_msg_imprint);
int
TS_TST_INFO_set_serial(TS_TST_INFO *a, const ASN1_INTEGER *serial)
@ -212,12 +227,14 @@ TS_TST_INFO_set_serial(TS_TST_INFO *a, const ASN1_INTEGER *serial)
a->serial = new_serial;
return 1;
}
LCRYPTO_ALIAS(TS_TST_INFO_set_serial);
const ASN1_INTEGER *
TS_TST_INFO_get_serial(const TS_TST_INFO *a)
{
return a->serial;
}
LCRYPTO_ALIAS(TS_TST_INFO_get_serial);
int
TS_TST_INFO_set_time(TS_TST_INFO *a, const ASN1_GENERALIZEDTIME *gtime)
@ -235,12 +252,14 @@ TS_TST_INFO_set_time(TS_TST_INFO *a, const ASN1_GENERALIZEDTIME *gtime)
a->time = new_time;
return 1;
}
LCRYPTO_ALIAS(TS_TST_INFO_set_time);
const ASN1_GENERALIZEDTIME *
TS_TST_INFO_get_time(const TS_TST_INFO *a)
{
return a->time;
}
LCRYPTO_ALIAS(TS_TST_INFO_get_time);
int
TS_TST_INFO_set_accuracy(TS_TST_INFO *a, TS_ACCURACY *accuracy)
@ -258,12 +277,14 @@ TS_TST_INFO_set_accuracy(TS_TST_INFO *a, TS_ACCURACY *accuracy)
a->accuracy = new_accuracy;
return 1;
}
LCRYPTO_ALIAS(TS_TST_INFO_set_accuracy);
TS_ACCURACY *
TS_TST_INFO_get_accuracy(TS_TST_INFO *a)
{
return a->accuracy;
}
LCRYPTO_ALIAS(TS_TST_INFO_get_accuracy);
int
TS_ACCURACY_set_seconds(TS_ACCURACY *a, const ASN1_INTEGER *seconds)
@ -281,12 +302,14 @@ TS_ACCURACY_set_seconds(TS_ACCURACY *a, const ASN1_INTEGER *seconds)
a->seconds = new_seconds;
return 1;
}
LCRYPTO_ALIAS(TS_ACCURACY_set_seconds);
const ASN1_INTEGER *
TS_ACCURACY_get_seconds(const TS_ACCURACY *a)
{
return a->seconds;
}
LCRYPTO_ALIAS(TS_ACCURACY_get_seconds);
int
TS_ACCURACY_set_millis(TS_ACCURACY *a, const ASN1_INTEGER *millis)
@ -306,12 +329,14 @@ TS_ACCURACY_set_millis(TS_ACCURACY *a, const ASN1_INTEGER *millis)
a->millis = new_millis;
return 1;
}
LCRYPTO_ALIAS(TS_ACCURACY_set_millis);
const ASN1_INTEGER *
TS_ACCURACY_get_millis(const TS_ACCURACY *a)
{
return a->millis;
}
LCRYPTO_ALIAS(TS_ACCURACY_get_millis);
int
TS_ACCURACY_set_micros(TS_ACCURACY *a, const ASN1_INTEGER *micros)
@ -331,12 +356,14 @@ TS_ACCURACY_set_micros(TS_ACCURACY *a, const ASN1_INTEGER *micros)
a->micros = new_micros;
return 1;
}
LCRYPTO_ALIAS(TS_ACCURACY_set_micros);
const ASN1_INTEGER *
TS_ACCURACY_get_micros(const TS_ACCURACY *a)
{
return a->micros;
}
LCRYPTO_ALIAS(TS_ACCURACY_get_micros);
int
TS_TST_INFO_set_ordering(TS_TST_INFO *a, int ordering)
@ -344,12 +371,14 @@ TS_TST_INFO_set_ordering(TS_TST_INFO *a, int ordering)
a->ordering = ordering ? 0xFF : 0x00;
return 1;
}
LCRYPTO_ALIAS(TS_TST_INFO_set_ordering);
int
TS_TST_INFO_get_ordering(const TS_TST_INFO *a)
{
return a->ordering ? 1 : 0;
}
LCRYPTO_ALIAS(TS_TST_INFO_get_ordering);
int
TS_TST_INFO_set_nonce(TS_TST_INFO *a, const ASN1_INTEGER *nonce)
@ -367,12 +396,14 @@ TS_TST_INFO_set_nonce(TS_TST_INFO *a, const ASN1_INTEGER *nonce)
a->nonce = new_nonce;
return 1;
}
LCRYPTO_ALIAS(TS_TST_INFO_set_nonce);
const ASN1_INTEGER *
TS_TST_INFO_get_nonce(const TS_TST_INFO *a)
{
return a->nonce;
}
LCRYPTO_ALIAS(TS_TST_INFO_get_nonce);
int
TS_TST_INFO_set_tsa(TS_TST_INFO *a, GENERAL_NAME *tsa)
@ -390,12 +421,14 @@ TS_TST_INFO_set_tsa(TS_TST_INFO *a, GENERAL_NAME *tsa)
a->tsa = new_tsa;
return 1;
}
LCRYPTO_ALIAS(TS_TST_INFO_set_tsa);
GENERAL_NAME *
TS_TST_INFO_get_tsa(TS_TST_INFO *a)
{
return a->tsa;
}
LCRYPTO_ALIAS(TS_TST_INFO_get_tsa);
STACK_OF(X509_EXTENSION) *TS_TST_INFO_get_exts(TS_TST_INFO *a)
{
@ -410,51 +443,60 @@ TS_TST_INFO_ext_free(TS_TST_INFO *a)
sk_X509_EXTENSION_pop_free(a->extensions, X509_EXTENSION_free);
a->extensions = NULL;
}
LCRYPTO_ALIAS(TS_TST_INFO_ext_free);
int
TS_TST_INFO_get_ext_count(TS_TST_INFO *a)
{
return X509v3_get_ext_count(a->extensions);
}
LCRYPTO_ALIAS(TS_TST_INFO_get_ext_count);
int
TS_TST_INFO_get_ext_by_NID(TS_TST_INFO *a, int nid, int lastpos)
{
return X509v3_get_ext_by_NID(a->extensions, nid, lastpos);
}
LCRYPTO_ALIAS(TS_TST_INFO_get_ext_by_NID);
int
TS_TST_INFO_get_ext_by_OBJ(TS_TST_INFO *a, const ASN1_OBJECT *obj, int lastpos)
{
return X509v3_get_ext_by_OBJ(a->extensions, obj, lastpos);
}
LCRYPTO_ALIAS(TS_TST_INFO_get_ext_by_OBJ);
int
TS_TST_INFO_get_ext_by_critical(TS_TST_INFO *a, int crit, int lastpos)
{
return X509v3_get_ext_by_critical(a->extensions, crit, lastpos);
}
LCRYPTO_ALIAS(TS_TST_INFO_get_ext_by_critical);
X509_EXTENSION *
TS_TST_INFO_get_ext(TS_TST_INFO *a, int loc)
{
return X509v3_get_ext(a->extensions, loc);
}
LCRYPTO_ALIAS(TS_TST_INFO_get_ext);
X509_EXTENSION *
TS_TST_INFO_delete_ext(TS_TST_INFO *a, int loc)
{
return X509v3_delete_ext(a->extensions, loc);
}
LCRYPTO_ALIAS(TS_TST_INFO_delete_ext);
int
TS_TST_INFO_add_ext(TS_TST_INFO *a, X509_EXTENSION *ex, int loc)
{
return X509v3_add_ext(&a->extensions, ex, loc) != NULL;
}
LCRYPTO_ALIAS(TS_TST_INFO_add_ext);
void *
TS_TST_INFO_get_ext_d2i(TS_TST_INFO *a, int nid, int *crit, int *idx)
{
return X509V3_get_d2i(a->extensions, nid, crit, idx);
}
LCRYPTO_ALIAS(TS_TST_INFO_get_ext_d2i);

5
lib/libcrypto/ts/ts_rsp_verify.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: ts_rsp_verify.c,v 1.29 2022/11/26 16:08:54 tb Exp $ */
/* $OpenBSD: ts_rsp_verify.c,v 1.30 2023/07/07 07:25:21 beck Exp $ */
/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL
* project 2002.
*/
@ -230,6 +230,7 @@ err:
return ret;
}
LCRYPTO_ALIAS(TS_RESP_verify_signature);
/*
* The certificate chain is returned in chain. Caller is responsible for
@ -485,6 +486,7 @@ TS_RESP_verify_response(TS_VERIFY_CTX *ctx, TS_RESP *response)
err:
return ret;
}
LCRYPTO_ALIAS(TS_RESP_verify_response);
/*
* Tries to extract a TS_TST_INFO structure from the PKCS7 token and
@ -502,6 +504,7 @@ TS_RESP_verify_token(TS_VERIFY_CTX *ctx, PKCS7 *token)
}
return ret;
}
LCRYPTO_ALIAS(TS_RESP_verify_token);
/*
* Verifies whether the 'token' contains a valid time stamp token

12
lib/libcrypto/ts/ts_verify_ctx.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: ts_verify_ctx.c,v 1.13 2023/04/25 17:52:54 tb Exp $ */
/* $OpenBSD: ts_verify_ctx.c,v 1.14 2023/07/07 07:25:21 beck Exp $ */
/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL
* project 2003.
*/
@ -74,6 +74,7 @@ TS_VERIFY_CTX_new(void)
return ctx;
}
LCRYPTO_ALIAS(TS_VERIFY_CTX_new);
void
TS_VERIFY_CTX_free(TS_VERIFY_CTX *ctx)
@ -84,6 +85,7 @@ TS_VERIFY_CTX_free(TS_VERIFY_CTX *ctx)
TS_VERIFY_CTX_cleanup(ctx);
free(ctx);
}
LCRYPTO_ALIAS(TS_VERIFY_CTX_free);
void
TS_VERIFY_CTX_cleanup(TS_VERIFY_CTX *ctx)
@ -107,6 +109,7 @@ TS_VERIFY_CTX_cleanup(TS_VERIFY_CTX *ctx)
memset(ctx, 0, sizeof(*ctx));
}
LCRYPTO_ALIAS(TS_VERIFY_CTX_cleanup);
/*
* XXX: The following accessors demonstrate the amount of care and thought that
@ -127,6 +130,7 @@ TS_VERIFY_CTX_add_flags(TS_VERIFY_CTX *ctx, int flags)
return ctx->flags;
}
LCRYPTO_ALIAS(TS_VERIFY_CTX_add_flags);
int
TS_VERIFY_CTX_set_flags(TS_VERIFY_CTX *ctx, int flags)
@ -135,6 +139,7 @@ TS_VERIFY_CTX_set_flags(TS_VERIFY_CTX *ctx, int flags)
return ctx->flags;
}
LCRYPTO_ALIAS(TS_VERIFY_CTX_set_flags);
BIO *
TS_VERIFY_CTX_set_data(TS_VERIFY_CTX *ctx, BIO *bio)
@ -143,6 +148,7 @@ TS_VERIFY_CTX_set_data(TS_VERIFY_CTX *ctx, BIO *bio)
return ctx->data;
}
LCRYPTO_ALIAS(TS_VERIFY_CTX_set_data);
X509_STORE *
TS_VERIFY_CTX_set_store(TS_VERIFY_CTX *ctx, X509_STORE *store)
@ -151,6 +157,7 @@ TS_VERIFY_CTX_set_store(TS_VERIFY_CTX *ctx, X509_STORE *store)
return ctx->store;
}
LCRYPTO_ALIAS(TS_VERIFY_CTX_set_store);
STACK_OF(X509) *
TS_VERIFY_CTX_set_certs(TS_VERIFY_CTX *ctx, STACK_OF(X509) *certs)
@ -159,6 +166,7 @@ TS_VERIFY_CTX_set_certs(TS_VERIFY_CTX *ctx, STACK_OF(X509) *certs)
return ctx->certs;
}
LCRYPTO_ALIAS(TS_VERIFY_CTX_set_certs);
unsigned char *
TS_VERIFY_CTX_set_imprint(TS_VERIFY_CTX *ctx, unsigned char *imprint,
@ -171,6 +179,7 @@ TS_VERIFY_CTX_set_imprint(TS_VERIFY_CTX *ctx, unsigned char *imprint,
return ctx->imprint;
}
LCRYPTO_ALIAS(TS_VERIFY_CTX_set_imprint);
TS_VERIFY_CTX *
TS_REQ_to_TS_VERIFY_CTX(TS_REQ *req, TS_VERIFY_CTX *ctx)
@ -224,3 +233,4 @@ err:
TS_VERIFY_CTX_free(ret);
return NULL;
}
LCRYPTO_ALIAS(TS_REQ_to_TS_VERIFY_CTX);