summaryrefslogtreecommitdiff
path: root/src/lib/libc
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/lib/libcrypto/Symbols.namespace190
-rw-r--r--src/lib/libcrypto/hidden/openssl/ts.h219
-rw-r--r--src/lib/libcrypto/ts/ts_asn1.c64
-rw-r--r--src/lib/libcrypto/ts/ts_conf.c20
-rw-r--r--src/lib/libcrypto/ts/ts_err.c3
-rw-r--r--src/lib/libcrypto/ts/ts_lib.c7
-rw-r--r--src/lib/libcrypto/ts/ts_req_print.c3
-rw-r--r--src/lib/libcrypto/ts/ts_req_utils.c25
-rw-r--r--src/lib/libcrypto/ts/ts_rsp_print.c5
-rw-r--r--src/lib/libcrypto/ts/ts_rsp_sign.c22
-rw-r--r--src/lib/libcrypto/ts/ts_rsp_utils.c44
-rw-r--r--src/lib/libcrypto/ts/ts_rsp_verify.c5
-rw-r--r--src/lib/libcrypto/ts/ts_verify_ctx.c12
13 files changed, 608 insertions, 11 deletions
diff --git a/src/lib/libcrypto/Symbols.namespace b/src/lib/libcrypto/Symbols.namespace
index d6c1610db9..cbf06b4d23 100644
--- a/src/lib/libcrypto/Symbols.namespace
+++ b/src/lib/libcrypto/Symbols.namespace
@@ -1263,3 +1263,193 @@ _libre_BIO_vprintf
1263_libre_BIO_snprintf 1263_libre_BIO_snprintf
1264_libre_BIO_vsnprintf 1264_libre_BIO_vsnprintf
1265_libre_ERR_load_BIO_strings 1265_libre_ERR_load_BIO_strings
1266_libre_TS_REQ_new
1267_libre_TS_REQ_free
1268_libre_i2d_TS_REQ
1269_libre_d2i_TS_REQ
1270_libre_TS_REQ_dup
1271_libre_d2i_TS_REQ_fp
1272_libre_i2d_TS_REQ_fp
1273_libre_d2i_TS_REQ_bio
1274_libre_i2d_TS_REQ_bio
1275_libre_TS_MSG_IMPRINT_new
1276_libre_TS_MSG_IMPRINT_free
1277_libre_i2d_TS_MSG_IMPRINT
1278_libre_d2i_TS_MSG_IMPRINT
1279_libre_TS_MSG_IMPRINT_dup
1280_libre_d2i_TS_MSG_IMPRINT_fp
1281_libre_i2d_TS_MSG_IMPRINT_fp
1282_libre_d2i_TS_MSG_IMPRINT_bio
1283_libre_i2d_TS_MSG_IMPRINT_bio
1284_libre_TS_RESP_new
1285_libre_TS_RESP_free
1286_libre_i2d_TS_RESP
1287_libre_d2i_TS_RESP
1288_libre_PKCS7_to_TS_TST_INFO
1289_libre_TS_RESP_dup
1290_libre_d2i_TS_RESP_fp
1291_libre_i2d_TS_RESP_fp
1292_libre_d2i_TS_RESP_bio
1293_libre_i2d_TS_RESP_bio
1294_libre_TS_STATUS_INFO_new
1295_libre_TS_STATUS_INFO_free
1296_libre_i2d_TS_STATUS_INFO
1297_libre_d2i_TS_STATUS_INFO
1298_libre_TS_STATUS_INFO_dup
1299_libre_TS_TST_INFO_new
1300_libre_TS_TST_INFO_free
1301_libre_i2d_TS_TST_INFO
1302_libre_d2i_TS_TST_INFO
1303_libre_TS_TST_INFO_dup
1304_libre_d2i_TS_TST_INFO_fp
1305_libre_i2d_TS_TST_INFO_fp
1306_libre_d2i_TS_TST_INFO_bio
1307_libre_i2d_TS_TST_INFO_bio
1308_libre_TS_ACCURACY_new
1309_libre_TS_ACCURACY_free
1310_libre_i2d_TS_ACCURACY
1311_libre_d2i_TS_ACCURACY
1312_libre_TS_ACCURACY_dup
1313_libre_ESS_ISSUER_SERIAL_new
1314_libre_ESS_ISSUER_SERIAL_free
1315_libre_i2d_ESS_ISSUER_SERIAL
1316_libre_d2i_ESS_ISSUER_SERIAL
1317_libre_ESS_ISSUER_SERIAL_dup
1318_libre_ESS_CERT_ID_new
1319_libre_ESS_CERT_ID_free
1320_libre_i2d_ESS_CERT_ID
1321_libre_d2i_ESS_CERT_ID
1322_libre_ESS_CERT_ID_dup
1323_libre_ESS_SIGNING_CERT_new
1324_libre_ESS_SIGNING_CERT_free
1325_libre_i2d_ESS_SIGNING_CERT
1326_libre_d2i_ESS_SIGNING_CERT
1327_libre_ESS_SIGNING_CERT_dup
1328_libre_TS_REQ_set_version
1329_libre_TS_REQ_get_version
1330_libre_TS_REQ_set_msg_imprint
1331_libre_TS_REQ_get_msg_imprint
1332_libre_TS_MSG_IMPRINT_set_algo
1333_libre_TS_MSG_IMPRINT_get_algo
1334_libre_TS_MSG_IMPRINT_set_msg
1335_libre_TS_MSG_IMPRINT_get_msg
1336_libre_TS_REQ_set_policy_id
1337_libre_TS_REQ_get_policy_id
1338_libre_TS_REQ_set_nonce
1339_libre_TS_REQ_get_nonce
1340_libre_TS_REQ_set_cert_req
1341_libre_TS_REQ_get_cert_req
1342_libre_TS_REQ_get_exts
1343_libre_TS_REQ_ext_free
1344_libre_TS_REQ_get_ext_count
1345_libre_TS_REQ_get_ext_by_NID
1346_libre_TS_REQ_get_ext_by_OBJ
1347_libre_TS_REQ_get_ext_by_critical
1348_libre_TS_REQ_get_ext
1349_libre_TS_REQ_delete_ext
1350_libre_TS_REQ_add_ext
1351_libre_TS_REQ_get_ext_d2i
1352_libre_TS_REQ_print_bio
1353_libre_TS_RESP_set_status_info
1354_libre_TS_RESP_get_status_info
1355_libre_TS_STATUS_INFO_get0_failure_info
1356_libre_TS_STATUS_INFO_get0_text
1357_libre_TS_STATUS_INFO_get0_status
1358_libre_TS_STATUS_INFO_set_status
1359_libre_TS_RESP_set_tst_info
1360_libre_TS_RESP_get_token
1361_libre_TS_RESP_get_tst_info
1362_libre_TS_TST_INFO_set_version
1363_libre_TS_TST_INFO_get_version
1364_libre_TS_TST_INFO_set_policy_id
1365_libre_TS_TST_INFO_get_policy_id
1366_libre_TS_TST_INFO_set_msg_imprint
1367_libre_TS_TST_INFO_get_msg_imprint
1368_libre_TS_TST_INFO_set_serial
1369_libre_TS_TST_INFO_get_serial
1370_libre_TS_TST_INFO_set_time
1371_libre_TS_TST_INFO_get_time
1372_libre_TS_TST_INFO_set_accuracy
1373_libre_TS_TST_INFO_get_accuracy
1374_libre_TS_ACCURACY_set_seconds
1375_libre_TS_ACCURACY_get_seconds
1376_libre_TS_ACCURACY_set_millis
1377_libre_TS_ACCURACY_get_millis
1378_libre_TS_ACCURACY_set_micros
1379_libre_TS_ACCURACY_get_micros
1380_libre_TS_TST_INFO_set_ordering
1381_libre_TS_TST_INFO_get_ordering
1382_libre_TS_TST_INFO_set_nonce
1383_libre_TS_TST_INFO_get_nonce
1384_libre_TS_TST_INFO_set_tsa
1385_libre_TS_TST_INFO_get_tsa
1386_libre_TS_TST_INFO_get_exts
1387_libre_TS_TST_INFO_ext_free
1388_libre_TS_TST_INFO_get_ext_count
1389_libre_TS_TST_INFO_get_ext_by_NID
1390_libre_TS_TST_INFO_get_ext_by_OBJ
1391_libre_TS_TST_INFO_get_ext_by_critical
1392_libre_TS_TST_INFO_get_ext
1393_libre_TS_TST_INFO_delete_ext
1394_libre_TS_TST_INFO_add_ext
1395_libre_TS_TST_INFO_get_ext_d2i
1396_libre_TS_RESP_CTX_new
1397_libre_TS_RESP_CTX_free
1398_libre_TS_RESP_CTX_set_signer_cert
1399_libre_TS_RESP_CTX_set_signer_key
1400_libre_TS_RESP_CTX_set_def_policy
1401_libre_TS_RESP_CTX_set_certs
1402_libre_TS_RESP_CTX_add_policy
1403_libre_TS_RESP_CTX_add_md
1404_libre_TS_RESP_CTX_set_accuracy
1405_libre_TS_RESP_CTX_set_clock_precision_digits
1406_libre_TS_RESP_CTX_add_flags
1407_libre_TS_RESP_CTX_set_serial_cb
1408_libre_TS_RESP_CTX_set_time_cb
1409_libre_TS_RESP_CTX_set_extension_cb
1410_libre_TS_RESP_CTX_set_status_info
1411_libre_TS_RESP_CTX_set_status_info_cond
1412_libre_TS_RESP_CTX_add_failure_info
1413_libre_TS_RESP_CTX_get_request
1414_libre_TS_RESP_CTX_get_tst_info
1415_libre_TS_RESP_create_response
1416_libre_TS_RESP_verify_signature
1417_libre_TS_RESP_verify_response
1418_libre_TS_RESP_verify_token
1419_libre_TS_VERIFY_CTX_new
1420_libre_TS_VERIFY_CTX_free
1421_libre_TS_VERIFY_CTX_cleanup
1422_libre_TS_VERIFY_CTX_add_flags
1423_libre_TS_VERIFY_CTX_set_flags
1424_libre_TS_VERIFY_CTX_set_data
1425_libre_TS_VERIFY_CTX_set_store
1426_libre_TS_VERIFY_CTX_set_certs
1427_libre_TS_VERIFY_CTX_set_imprint
1428_libre_TS_REQ_to_TS_VERIFY_CTX
1429_libre_TS_RESP_print_bio
1430_libre_TS_STATUS_INFO_print_bio
1431_libre_TS_TST_INFO_print_bio
1432_libre_TS_ASN1_INTEGER_print_bio
1433_libre_TS_OBJ_print_bio
1434_libre_TS_ext_print_bio
1435_libre_TS_X509_ALGOR_print_bio
1436_libre_TS_MSG_IMPRINT_print_bio
1437_libre_TS_CONF_load_cert
1438_libre_TS_CONF_load_certs
1439_libre_TS_CONF_load_key
1440_libre_TS_CONF_get_tsa_section
1441_libre_TS_CONF_set_serial
1442_libre_TS_CONF_set_crypto_device
1443_libre_TS_CONF_set_default_engine
1444_libre_TS_CONF_set_signer_cert
1445_libre_TS_CONF_set_certs
1446_libre_TS_CONF_set_signer_key
1447_libre_TS_CONF_set_def_policy
1448_libre_TS_CONF_set_policies
1449_libre_TS_CONF_set_digests
1450_libre_TS_CONF_set_accuracy
1451_libre_TS_CONF_set_clock_precision_digits
1452_libre_TS_CONF_set_ordering
1453_libre_TS_CONF_set_tsa_name
1454_libre_TS_CONF_set_ess_cert_id_chain
1455_libre_ERR_load_TS_strings
diff --git a/src/lib/libcrypto/hidden/openssl/ts.h b/src/lib/libcrypto/hidden/openssl/ts.h
new file mode 100644
index 0000000000..de336ef93b
--- /dev/null
+++ b/src/lib/libcrypto/hidden/openssl/ts.h
@@ -0,0 +1,219 @@
1/* $OpenBSD: ts.h,v 1.1 2023/07/07 07:25:21 beck Exp $ */
2/*
3 * Copyright (c) 2023 Bob Beck <beck@openbsd.org>
4 *
5 * Permission to use, copy, modify, and distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 */
17
18#ifndef _LIBCRYPTO_TS_H
19#define _LIBCRYPTO_TS_H
20
21#ifndef _MSC_VER
22#include_next <openssl/ts.h>
23#else
24#include "../include/openssl/ts.h"
25#endif
26#include "crypto_namespace.h"
27
28LCRYPTO_USED(TS_REQ_new);
29LCRYPTO_USED(TS_REQ_free);
30LCRYPTO_USED(i2d_TS_REQ);
31LCRYPTO_USED(d2i_TS_REQ);
32LCRYPTO_USED(TS_REQ_dup);
33LCRYPTO_USED(d2i_TS_REQ_fp);
34LCRYPTO_USED(i2d_TS_REQ_fp);
35LCRYPTO_USED(d2i_TS_REQ_bio);
36LCRYPTO_USED(i2d_TS_REQ_bio);
37LCRYPTO_USED(TS_MSG_IMPRINT_new);
38LCRYPTO_USED(TS_MSG_IMPRINT_free);
39LCRYPTO_USED(i2d_TS_MSG_IMPRINT);
40LCRYPTO_USED(d2i_TS_MSG_IMPRINT);
41LCRYPTO_USED(TS_MSG_IMPRINT_dup);
42LCRYPTO_USED(d2i_TS_MSG_IMPRINT_fp);
43LCRYPTO_USED(i2d_TS_MSG_IMPRINT_fp);
44LCRYPTO_USED(d2i_TS_MSG_IMPRINT_bio);
45LCRYPTO_USED(i2d_TS_MSG_IMPRINT_bio);
46LCRYPTO_USED(TS_RESP_new);
47LCRYPTO_USED(TS_RESP_free);
48LCRYPTO_USED(i2d_TS_RESP);
49LCRYPTO_USED(d2i_TS_RESP);
50LCRYPTO_USED(PKCS7_to_TS_TST_INFO);
51LCRYPTO_USED(TS_RESP_dup);
52LCRYPTO_USED(d2i_TS_RESP_fp);
53LCRYPTO_USED(i2d_TS_RESP_fp);
54LCRYPTO_USED(d2i_TS_RESP_bio);
55LCRYPTO_USED(i2d_TS_RESP_bio);
56LCRYPTO_USED(TS_STATUS_INFO_new);
57LCRYPTO_USED(TS_STATUS_INFO_free);
58LCRYPTO_USED(i2d_TS_STATUS_INFO);
59LCRYPTO_USED(d2i_TS_STATUS_INFO);
60LCRYPTO_USED(TS_STATUS_INFO_dup);
61LCRYPTO_USED(TS_TST_INFO_new);
62LCRYPTO_USED(TS_TST_INFO_free);
63LCRYPTO_USED(i2d_TS_TST_INFO);
64LCRYPTO_USED(d2i_TS_TST_INFO);
65LCRYPTO_USED(TS_TST_INFO_dup);
66LCRYPTO_USED(d2i_TS_TST_INFO_fp);
67LCRYPTO_USED(i2d_TS_TST_INFO_fp);
68LCRYPTO_USED(d2i_TS_TST_INFO_bio);
69LCRYPTO_USED(i2d_TS_TST_INFO_bio);
70LCRYPTO_USED(TS_ACCURACY_new);
71LCRYPTO_USED(TS_ACCURACY_free);
72LCRYPTO_USED(i2d_TS_ACCURACY);
73LCRYPTO_USED(d2i_TS_ACCURACY);
74LCRYPTO_USED(TS_ACCURACY_dup);
75LCRYPTO_USED(ESS_ISSUER_SERIAL_new);
76LCRYPTO_USED(ESS_ISSUER_SERIAL_free);
77LCRYPTO_USED(i2d_ESS_ISSUER_SERIAL);
78LCRYPTO_USED(d2i_ESS_ISSUER_SERIAL);
79LCRYPTO_USED(ESS_ISSUER_SERIAL_dup);
80LCRYPTO_USED(ESS_CERT_ID_new);
81LCRYPTO_USED(ESS_CERT_ID_free);
82LCRYPTO_USED(i2d_ESS_CERT_ID);
83LCRYPTO_USED(d2i_ESS_CERT_ID);
84LCRYPTO_USED(ESS_CERT_ID_dup);
85LCRYPTO_USED(ESS_SIGNING_CERT_new);
86LCRYPTO_USED(ESS_SIGNING_CERT_free);
87LCRYPTO_USED(i2d_ESS_SIGNING_CERT);
88LCRYPTO_USED(d2i_ESS_SIGNING_CERT);
89LCRYPTO_USED(ESS_SIGNING_CERT_dup);
90LCRYPTO_USED(TS_REQ_set_version);
91LCRYPTO_USED(TS_REQ_get_version);
92LCRYPTO_USED(TS_REQ_set_msg_imprint);
93LCRYPTO_USED(TS_REQ_get_msg_imprint);
94LCRYPTO_USED(TS_MSG_IMPRINT_set_algo);
95LCRYPTO_USED(TS_MSG_IMPRINT_get_algo);
96LCRYPTO_USED(TS_MSG_IMPRINT_set_msg);
97LCRYPTO_USED(TS_MSG_IMPRINT_get_msg);
98LCRYPTO_USED(TS_REQ_set_policy_id);
99LCRYPTO_USED(TS_REQ_get_policy_id);
100LCRYPTO_USED(TS_REQ_set_nonce);
101LCRYPTO_USED(TS_REQ_get_nonce);
102LCRYPTO_USED(TS_REQ_set_cert_req);
103LCRYPTO_USED(TS_REQ_get_cert_req);
104LCRYPTO_USED(TS_REQ_get_exts);
105LCRYPTO_USED(TS_REQ_ext_free);
106LCRYPTO_USED(TS_REQ_get_ext_count);
107LCRYPTO_USED(TS_REQ_get_ext_by_NID);
108LCRYPTO_USED(TS_REQ_get_ext_by_OBJ);
109LCRYPTO_USED(TS_REQ_get_ext_by_critical);
110LCRYPTO_USED(TS_REQ_get_ext);
111LCRYPTO_USED(TS_REQ_delete_ext);
112LCRYPTO_USED(TS_REQ_add_ext);
113LCRYPTO_USED(TS_REQ_get_ext_d2i);
114LCRYPTO_USED(TS_REQ_print_bio);
115LCRYPTO_USED(TS_RESP_set_status_info);
116LCRYPTO_USED(TS_RESP_get_status_info);
117LCRYPTO_USED(TS_STATUS_INFO_get0_failure_info);
118LCRYPTO_USED(TS_STATUS_INFO_get0_text);
119LCRYPTO_USED(TS_STATUS_INFO_get0_status);
120LCRYPTO_USED(TS_STATUS_INFO_set_status);
121LCRYPTO_USED(TS_RESP_set_tst_info);
122LCRYPTO_USED(TS_RESP_get_token);
123LCRYPTO_USED(TS_RESP_get_tst_info);
124LCRYPTO_USED(TS_TST_INFO_set_version);
125LCRYPTO_USED(TS_TST_INFO_get_version);
126LCRYPTO_USED(TS_TST_INFO_set_policy_id);
127LCRYPTO_USED(TS_TST_INFO_get_policy_id);
128LCRYPTO_USED(TS_TST_INFO_set_msg_imprint);
129LCRYPTO_USED(TS_TST_INFO_get_msg_imprint);
130LCRYPTO_USED(TS_TST_INFO_set_serial);
131LCRYPTO_USED(TS_TST_INFO_get_serial);
132LCRYPTO_USED(TS_TST_INFO_set_time);
133LCRYPTO_USED(TS_TST_INFO_get_time);
134LCRYPTO_USED(TS_TST_INFO_set_accuracy);
135LCRYPTO_USED(TS_TST_INFO_get_accuracy);
136LCRYPTO_USED(TS_ACCURACY_set_seconds);
137LCRYPTO_USED(TS_ACCURACY_get_seconds);
138LCRYPTO_USED(TS_ACCURACY_set_millis);
139LCRYPTO_USED(TS_ACCURACY_get_millis);
140LCRYPTO_USED(TS_ACCURACY_set_micros);
141LCRYPTO_USED(TS_ACCURACY_get_micros);
142LCRYPTO_USED(TS_TST_INFO_set_ordering);
143LCRYPTO_USED(TS_TST_INFO_get_ordering);
144LCRYPTO_USED(TS_TST_INFO_set_nonce);
145LCRYPTO_USED(TS_TST_INFO_get_nonce);
146LCRYPTO_USED(TS_TST_INFO_set_tsa);
147LCRYPTO_USED(TS_TST_INFO_get_tsa);
148LCRYPTO_USED(TS_TST_INFO_get_exts);
149LCRYPTO_USED(TS_TST_INFO_ext_free);
150LCRYPTO_USED(TS_TST_INFO_get_ext_count);
151LCRYPTO_USED(TS_TST_INFO_get_ext_by_NID);
152LCRYPTO_USED(TS_TST_INFO_get_ext_by_OBJ);
153LCRYPTO_USED(TS_TST_INFO_get_ext_by_critical);
154LCRYPTO_USED(TS_TST_INFO_get_ext);
155LCRYPTO_USED(TS_TST_INFO_delete_ext);
156LCRYPTO_USED(TS_TST_INFO_add_ext);
157LCRYPTO_USED(TS_TST_INFO_get_ext_d2i);
158LCRYPTO_USED(TS_RESP_CTX_new);
159LCRYPTO_USED(TS_RESP_CTX_free);
160LCRYPTO_USED(TS_RESP_CTX_set_signer_cert);
161LCRYPTO_USED(TS_RESP_CTX_set_signer_key);
162LCRYPTO_USED(TS_RESP_CTX_set_def_policy);
163LCRYPTO_USED(TS_RESP_CTX_set_certs);
164LCRYPTO_USED(TS_RESP_CTX_add_policy);
165LCRYPTO_USED(TS_RESP_CTX_add_md);
166LCRYPTO_USED(TS_RESP_CTX_set_accuracy);
167LCRYPTO_USED(TS_RESP_CTX_set_clock_precision_digits);
168LCRYPTO_USED(TS_RESP_CTX_add_flags);
169LCRYPTO_USED(TS_RESP_CTX_set_serial_cb);
170LCRYPTO_USED(TS_RESP_CTX_set_time_cb);
171LCRYPTO_USED(TS_RESP_CTX_set_extension_cb);
172LCRYPTO_USED(TS_RESP_CTX_set_status_info);
173LCRYPTO_USED(TS_RESP_CTX_set_status_info_cond);
174LCRYPTO_USED(TS_RESP_CTX_add_failure_info);
175LCRYPTO_USED(TS_RESP_CTX_get_request);
176LCRYPTO_USED(TS_RESP_CTX_get_tst_info);
177LCRYPTO_USED(TS_RESP_create_response);
178LCRYPTO_USED(TS_RESP_verify_signature);
179LCRYPTO_USED(TS_RESP_verify_response);
180LCRYPTO_USED(TS_RESP_verify_token);
181LCRYPTO_USED(TS_VERIFY_CTX_new);
182LCRYPTO_USED(TS_VERIFY_CTX_free);
183LCRYPTO_USED(TS_VERIFY_CTX_cleanup);
184LCRYPTO_USED(TS_VERIFY_CTX_add_flags);
185LCRYPTO_USED(TS_VERIFY_CTX_set_flags);
186LCRYPTO_USED(TS_VERIFY_CTX_set_data);
187LCRYPTO_USED(TS_VERIFY_CTX_set_store);
188LCRYPTO_USED(TS_VERIFY_CTX_set_certs);
189LCRYPTO_USED(TS_VERIFY_CTX_set_imprint);
190LCRYPTO_USED(TS_REQ_to_TS_VERIFY_CTX);
191LCRYPTO_USED(TS_RESP_print_bio);
192LCRYPTO_USED(TS_STATUS_INFO_print_bio);
193LCRYPTO_USED(TS_TST_INFO_print_bio);
194LCRYPTO_USED(TS_ASN1_INTEGER_print_bio);
195LCRYPTO_USED(TS_OBJ_print_bio);
196LCRYPTO_USED(TS_ext_print_bio);
197LCRYPTO_USED(TS_X509_ALGOR_print_bio);
198LCRYPTO_USED(TS_MSG_IMPRINT_print_bio);
199LCRYPTO_USED(TS_CONF_load_cert);
200LCRYPTO_USED(TS_CONF_load_certs);
201LCRYPTO_USED(TS_CONF_load_key);
202LCRYPTO_USED(TS_CONF_get_tsa_section);
203LCRYPTO_USED(TS_CONF_set_serial);
204LCRYPTO_USED(TS_CONF_set_crypto_device);
205LCRYPTO_USED(TS_CONF_set_default_engine);
206LCRYPTO_USED(TS_CONF_set_signer_cert);
207LCRYPTO_USED(TS_CONF_set_certs);
208LCRYPTO_USED(TS_CONF_set_signer_key);
209LCRYPTO_USED(TS_CONF_set_def_policy);
210LCRYPTO_USED(TS_CONF_set_policies);
211LCRYPTO_USED(TS_CONF_set_digests);
212LCRYPTO_USED(TS_CONF_set_accuracy);
213LCRYPTO_USED(TS_CONF_set_clock_precision_digits);
214LCRYPTO_USED(TS_CONF_set_ordering);
215LCRYPTO_USED(TS_CONF_set_tsa_name);
216LCRYPTO_USED(TS_CONF_set_ess_cert_id_chain);
217LCRYPTO_USED(ERR_load_TS_strings);
218
219#endif /* _LIBCRYPTO_TS_H */
diff --git a/src/lib/libcrypto/ts/ts_asn1.c b/src/lib/libcrypto/ts/ts_asn1.c
index 6537f1c85a..60ee0b81cb 100644
--- a/src/lib/libcrypto/ts/ts_asn1.c
+++ b/src/lib/libcrypto/ts/ts_asn1.c
@@ -1,4 +1,4 @@
1/* $OpenBSD: ts_asn1.c,v 1.13 2022/07/24 08:16:47 tb Exp $ */ 1/* $OpenBSD: ts_asn1.c,v 1.14 2023/07/07 07:25:21 beck Exp $ */
2/* Written by Nils Larsch for the OpenSSL project 2004. 2/* Written by Nils Larsch for the OpenSSL project 2004.
3 */ 3 */
4/* ==================================================================== 4/* ====================================================================
@@ -97,30 +97,35 @@ d2i_TS_MSG_IMPRINT(TS_MSG_IMPRINT **a, const unsigned char **in, long len)
97 return (TS_MSG_IMPRINT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, 97 return (TS_MSG_IMPRINT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
98 &TS_MSG_IMPRINT_it); 98 &TS_MSG_IMPRINT_it);
99} 99}
100LCRYPTO_ALIAS(d2i_TS_MSG_IMPRINT);
100 101
101int 102int
102i2d_TS_MSG_IMPRINT(const TS_MSG_IMPRINT *a, unsigned char **out) 103i2d_TS_MSG_IMPRINT(const TS_MSG_IMPRINT *a, unsigned char **out)
103{ 104{
104 return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_MSG_IMPRINT_it); 105 return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_MSG_IMPRINT_it);
105} 106}
107LCRYPTO_ALIAS(i2d_TS_MSG_IMPRINT);
106 108
107TS_MSG_IMPRINT * 109TS_MSG_IMPRINT *
108TS_MSG_IMPRINT_new(void) 110TS_MSG_IMPRINT_new(void)
109{ 111{
110 return (TS_MSG_IMPRINT *)ASN1_item_new(&TS_MSG_IMPRINT_it); 112 return (TS_MSG_IMPRINT *)ASN1_item_new(&TS_MSG_IMPRINT_it);
111} 113}
114LCRYPTO_ALIAS(TS_MSG_IMPRINT_new);
112 115
113void 116void
114TS_MSG_IMPRINT_free(TS_MSG_IMPRINT *a) 117TS_MSG_IMPRINT_free(TS_MSG_IMPRINT *a)
115{ 118{
116 ASN1_item_free((ASN1_VALUE *)a, &TS_MSG_IMPRINT_it); 119 ASN1_item_free((ASN1_VALUE *)a, &TS_MSG_IMPRINT_it);
117} 120}
121LCRYPTO_ALIAS(TS_MSG_IMPRINT_free);
118 122
119TS_MSG_IMPRINT * 123TS_MSG_IMPRINT *
120TS_MSG_IMPRINT_dup(TS_MSG_IMPRINT *x) 124TS_MSG_IMPRINT_dup(TS_MSG_IMPRINT *x)
121{ 125{
122 return ASN1_item_dup(&TS_MSG_IMPRINT_it, x); 126 return ASN1_item_dup(&TS_MSG_IMPRINT_it, x);
123} 127}
128LCRYPTO_ALIAS(TS_MSG_IMPRINT_dup);
124 129
125#ifndef OPENSSL_NO_BIO 130#ifndef OPENSSL_NO_BIO
126TS_MSG_IMPRINT * 131TS_MSG_IMPRINT *
@@ -128,12 +133,14 @@ d2i_TS_MSG_IMPRINT_bio(BIO *bp, TS_MSG_IMPRINT **a)
128{ 133{
129 return ASN1_item_d2i_bio(&TS_MSG_IMPRINT_it, bp, a); 134 return ASN1_item_d2i_bio(&TS_MSG_IMPRINT_it, bp, a);
130} 135}
136LCRYPTO_ALIAS(d2i_TS_MSG_IMPRINT_bio);
131 137
132int 138int
133i2d_TS_MSG_IMPRINT_bio(BIO *bp, TS_MSG_IMPRINT *a) 139i2d_TS_MSG_IMPRINT_bio(BIO *bp, TS_MSG_IMPRINT *a)
134{ 140{
135 return ASN1_item_i2d_bio(&TS_MSG_IMPRINT_it, bp, a); 141 return ASN1_item_i2d_bio(&TS_MSG_IMPRINT_it, bp, a);
136} 142}
143LCRYPTO_ALIAS(i2d_TS_MSG_IMPRINT_bio);
137#endif 144#endif
138 145
139TS_MSG_IMPRINT * 146TS_MSG_IMPRINT *
@@ -141,12 +148,14 @@ d2i_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT **a)
141{ 148{
142 return ASN1_item_d2i_fp(&TS_MSG_IMPRINT_it, fp, a); 149 return ASN1_item_d2i_fp(&TS_MSG_IMPRINT_it, fp, a);
143} 150}
151LCRYPTO_ALIAS(d2i_TS_MSG_IMPRINT_fp);
144 152
145int 153int
146i2d_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT *a) 154i2d_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT *a)
147{ 155{
148 return ASN1_item_i2d_fp(&TS_MSG_IMPRINT_it, fp, a); 156 return ASN1_item_i2d_fp(&TS_MSG_IMPRINT_it, fp, a);
149} 157}
158LCRYPTO_ALIAS(i2d_TS_MSG_IMPRINT_fp);
150 159
151static const ASN1_TEMPLATE TS_REQ_seq_tt[] = { 160static const ASN1_TEMPLATE TS_REQ_seq_tt[] = {
152 { 161 {
@@ -210,30 +219,35 @@ d2i_TS_REQ(TS_REQ **a, const unsigned char **in, long len)
210 return (TS_REQ *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, 219 return (TS_REQ *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
211 &TS_REQ_it); 220 &TS_REQ_it);
212} 221}
222LCRYPTO_ALIAS(d2i_TS_REQ);
213 223
214int 224int
215i2d_TS_REQ(const TS_REQ *a, unsigned char **out) 225i2d_TS_REQ(const TS_REQ *a, unsigned char **out)
216{ 226{
217 return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_REQ_it); 227 return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_REQ_it);
218} 228}
229LCRYPTO_ALIAS(i2d_TS_REQ);
219 230
220TS_REQ * 231TS_REQ *
221TS_REQ_new(void) 232TS_REQ_new(void)
222{ 233{
223 return (TS_REQ *)ASN1_item_new(&TS_REQ_it); 234 return (TS_REQ *)ASN1_item_new(&TS_REQ_it);
224} 235}
236LCRYPTO_ALIAS(TS_REQ_new);
225 237
226void 238void
227TS_REQ_free(TS_REQ *a) 239TS_REQ_free(TS_REQ *a)
228{ 240{
229 ASN1_item_free((ASN1_VALUE *)a, &TS_REQ_it); 241 ASN1_item_free((ASN1_VALUE *)a, &TS_REQ_it);
230} 242}
243LCRYPTO_ALIAS(TS_REQ_free);
231 244
232TS_REQ * 245TS_REQ *
233TS_REQ_dup(TS_REQ *x) 246TS_REQ_dup(TS_REQ *x)
234{ 247{
235 return ASN1_item_dup(&TS_REQ_it, x); 248 return ASN1_item_dup(&TS_REQ_it, x);
236} 249}
250LCRYPTO_ALIAS(TS_REQ_dup);
237 251
238#ifndef OPENSSL_NO_BIO 252#ifndef OPENSSL_NO_BIO
239TS_REQ * 253TS_REQ *
@@ -241,12 +255,14 @@ d2i_TS_REQ_bio(BIO *bp, TS_REQ **a)
241{ 255{
242 return ASN1_item_d2i_bio(&TS_REQ_it, bp, a); 256 return ASN1_item_d2i_bio(&TS_REQ_it, bp, a);
243} 257}
258LCRYPTO_ALIAS(d2i_TS_REQ_bio);
244 259
245int 260int
246i2d_TS_REQ_bio(BIO *bp, TS_REQ *a) 261i2d_TS_REQ_bio(BIO *bp, TS_REQ *a)
247{ 262{
248 return ASN1_item_i2d_bio(&TS_REQ_it, bp, a); 263 return ASN1_item_i2d_bio(&TS_REQ_it, bp, a);
249} 264}
265LCRYPTO_ALIAS(i2d_TS_REQ_bio);
250#endif 266#endif
251 267
252TS_REQ * 268TS_REQ *
@@ -254,12 +270,14 @@ d2i_TS_REQ_fp(FILE *fp, TS_REQ **a)
254{ 270{
255 return ASN1_item_d2i_fp(&TS_REQ_it, fp, a); 271 return ASN1_item_d2i_fp(&TS_REQ_it, fp, a);
256} 272}
273LCRYPTO_ALIAS(d2i_TS_REQ_fp);
257 274
258int 275int
259i2d_TS_REQ_fp(FILE *fp, TS_REQ *a) 276i2d_TS_REQ_fp(FILE *fp, TS_REQ *a)
260{ 277{
261 return ASN1_item_i2d_fp(&TS_REQ_it, fp, a); 278 return ASN1_item_i2d_fp(&TS_REQ_it, fp, a);
262} 279}
280LCRYPTO_ALIAS(i2d_TS_REQ_fp);
263 281
264static const ASN1_TEMPLATE TS_ACCURACY_seq_tt[] = { 282static const ASN1_TEMPLATE TS_ACCURACY_seq_tt[] = {
265 { 283 {
@@ -302,30 +320,35 @@ d2i_TS_ACCURACY(TS_ACCURACY **a, const unsigned char **in, long len)
302 return (TS_ACCURACY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, 320 return (TS_ACCURACY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
303 &TS_ACCURACY_it); 321 &TS_ACCURACY_it);
304} 322}
323LCRYPTO_ALIAS(d2i_TS_ACCURACY);
305 324
306int 325int
307i2d_TS_ACCURACY(const TS_ACCURACY *a, unsigned char **out) 326i2d_TS_ACCURACY(const TS_ACCURACY *a, unsigned char **out)
308{ 327{
309 return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_ACCURACY_it); 328 return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_ACCURACY_it);
310} 329}
330LCRYPTO_ALIAS(i2d_TS_ACCURACY);
311 331
312TS_ACCURACY * 332TS_ACCURACY *
313TS_ACCURACY_new(void) 333TS_ACCURACY_new(void)
314{ 334{
315 return (TS_ACCURACY *)ASN1_item_new(&TS_ACCURACY_it); 335 return (TS_ACCURACY *)ASN1_item_new(&TS_ACCURACY_it);
316} 336}
337LCRYPTO_ALIAS(TS_ACCURACY_new);
317 338
318void 339void
319TS_ACCURACY_free(TS_ACCURACY *a) 340TS_ACCURACY_free(TS_ACCURACY *a)
320{ 341{
321 ASN1_item_free((ASN1_VALUE *)a, &TS_ACCURACY_it); 342 ASN1_item_free((ASN1_VALUE *)a, &TS_ACCURACY_it);
322} 343}
344LCRYPTO_ALIAS(TS_ACCURACY_free);
323 345
324TS_ACCURACY * 346TS_ACCURACY *
325TS_ACCURACY_dup(TS_ACCURACY *x) 347TS_ACCURACY_dup(TS_ACCURACY *x)
326{ 348{
327 return ASN1_item_dup(&TS_ACCURACY_it, x); 349 return ASN1_item_dup(&TS_ACCURACY_it, x);
328} 350}
351LCRYPTO_ALIAS(TS_ACCURACY_dup);
329 352
330static const ASN1_TEMPLATE TS_TST_INFO_seq_tt[] = { 353static const ASN1_TEMPLATE TS_TST_INFO_seq_tt[] = {
331 { 354 {
@@ -417,30 +440,35 @@ d2i_TS_TST_INFO(TS_TST_INFO **a, const unsigned char **in, long len)
417 return (TS_TST_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, 440 return (TS_TST_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
418 &TS_TST_INFO_it); 441 &TS_TST_INFO_it);
419} 442}
443LCRYPTO_ALIAS(d2i_TS_TST_INFO);
420 444
421int 445int
422i2d_TS_TST_INFO(const TS_TST_INFO *a, unsigned char **out) 446i2d_TS_TST_INFO(const TS_TST_INFO *a, unsigned char **out)
423{ 447{
424 return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_TST_INFO_it); 448 return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_TST_INFO_it);
425} 449}
450LCRYPTO_ALIAS(i2d_TS_TST_INFO);
426 451
427TS_TST_INFO * 452TS_TST_INFO *
428TS_TST_INFO_new(void) 453TS_TST_INFO_new(void)
429{ 454{
430 return (TS_TST_INFO *)ASN1_item_new(&TS_TST_INFO_it); 455 return (TS_TST_INFO *)ASN1_item_new(&TS_TST_INFO_it);
431} 456}
457LCRYPTO_ALIAS(TS_TST_INFO_new);
432 458
433void 459void
434TS_TST_INFO_free(TS_TST_INFO *a) 460TS_TST_INFO_free(TS_TST_INFO *a)
435{ 461{
436 ASN1_item_free((ASN1_VALUE *)a, &TS_TST_INFO_it); 462 ASN1_item_free((ASN1_VALUE *)a, &TS_TST_INFO_it);
437} 463}
464LCRYPTO_ALIAS(TS_TST_INFO_free);
438 465
439TS_TST_INFO * 466TS_TST_INFO *
440TS_TST_INFO_dup(TS_TST_INFO *x) 467TS_TST_INFO_dup(TS_TST_INFO *x)
441{ 468{
442 return ASN1_item_dup(&TS_TST_INFO_it, x); 469 return ASN1_item_dup(&TS_TST_INFO_it, x);
443} 470}
471LCRYPTO_ALIAS(TS_TST_INFO_dup);
444 472
445#ifndef OPENSSL_NO_BIO 473#ifndef OPENSSL_NO_BIO
446TS_TST_INFO * 474TS_TST_INFO *
@@ -448,12 +476,14 @@ d2i_TS_TST_INFO_bio(BIO *bp, TS_TST_INFO **a)
448{ 476{
449 return ASN1_item_d2i_bio(&TS_TST_INFO_it, bp, a); 477 return ASN1_item_d2i_bio(&TS_TST_INFO_it, bp, a);
450} 478}
479LCRYPTO_ALIAS(d2i_TS_TST_INFO_bio);
451 480
452int 481int
453i2d_TS_TST_INFO_bio(BIO *bp, TS_TST_INFO *a) 482i2d_TS_TST_INFO_bio(BIO *bp, TS_TST_INFO *a)
454{ 483{
455 return ASN1_item_i2d_bio(&TS_TST_INFO_it, bp, a); 484 return ASN1_item_i2d_bio(&TS_TST_INFO_it, bp, a);
456} 485}
486LCRYPTO_ALIAS(i2d_TS_TST_INFO_bio);
457#endif 487#endif
458 488
459TS_TST_INFO * 489TS_TST_INFO *
@@ -461,12 +491,14 @@ d2i_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO **a)
461{ 491{
462 return ASN1_item_d2i_fp(&TS_TST_INFO_it, fp, a); 492 return ASN1_item_d2i_fp(&TS_TST_INFO_it, fp, a);
463} 493}
494LCRYPTO_ALIAS(d2i_TS_TST_INFO_fp);
464 495
465int 496int
466i2d_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO *a) 497i2d_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO *a)
467{ 498{
468 return ASN1_item_i2d_fp(&TS_TST_INFO_it, fp, a); 499 return ASN1_item_i2d_fp(&TS_TST_INFO_it, fp, a);
469} 500}
501LCRYPTO_ALIAS(i2d_TS_TST_INFO_fp);
470 502
471static const ASN1_TEMPLATE TS_STATUS_INFO_seq_tt[] = { 503static const ASN1_TEMPLATE TS_STATUS_INFO_seq_tt[] = {
472 { 504 {
@@ -509,30 +541,35 @@ d2i_TS_STATUS_INFO(TS_STATUS_INFO **a, const unsigned char **in, long len)
509 return (TS_STATUS_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, 541 return (TS_STATUS_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
510 &TS_STATUS_INFO_it); 542 &TS_STATUS_INFO_it);
511} 543}
544LCRYPTO_ALIAS(d2i_TS_STATUS_INFO);
512 545
513int 546int
514i2d_TS_STATUS_INFO(const TS_STATUS_INFO *a, unsigned char **out) 547i2d_TS_STATUS_INFO(const TS_STATUS_INFO *a, unsigned char **out)
515{ 548{
516 return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_STATUS_INFO_it); 549 return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_STATUS_INFO_it);
517} 550}
551LCRYPTO_ALIAS(i2d_TS_STATUS_INFO);
518 552
519TS_STATUS_INFO * 553TS_STATUS_INFO *
520TS_STATUS_INFO_new(void) 554TS_STATUS_INFO_new(void)
521{ 555{
522 return (TS_STATUS_INFO *)ASN1_item_new(&TS_STATUS_INFO_it); 556 return (TS_STATUS_INFO *)ASN1_item_new(&TS_STATUS_INFO_it);
523} 557}
558LCRYPTO_ALIAS(TS_STATUS_INFO_new);
524 559
525void 560void
526TS_STATUS_INFO_free(TS_STATUS_INFO *a) 561TS_STATUS_INFO_free(TS_STATUS_INFO *a)
527{ 562{
528 ASN1_item_free((ASN1_VALUE *)a, &TS_STATUS_INFO_it); 563 ASN1_item_free((ASN1_VALUE *)a, &TS_STATUS_INFO_it);
529} 564}
565LCRYPTO_ALIAS(TS_STATUS_INFO_free);
530 566
531TS_STATUS_INFO * 567TS_STATUS_INFO *
532TS_STATUS_INFO_dup(TS_STATUS_INFO *x) 568TS_STATUS_INFO_dup(TS_STATUS_INFO *x)
533{ 569{
534 return ASN1_item_dup(&TS_STATUS_INFO_it, x); 570 return ASN1_item_dup(&TS_STATUS_INFO_it, x);
535} 571}
572LCRYPTO_ALIAS(TS_STATUS_INFO_dup);
536 573
537static int 574static int
538ts_resp_set_tst_info(TS_RESP *a) 575ts_resp_set_tst_info(TS_RESP *a)
@@ -620,30 +657,35 @@ d2i_TS_RESP(TS_RESP **a, const unsigned char **in, long len)
620 return (TS_RESP *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, 657 return (TS_RESP *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
621 &TS_RESP_it); 658 &TS_RESP_it);
622} 659}
660LCRYPTO_ALIAS(d2i_TS_RESP);
623 661
624int 662int
625i2d_TS_RESP(const TS_RESP *a, unsigned char **out) 663i2d_TS_RESP(const TS_RESP *a, unsigned char **out)
626{ 664{
627 return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_RESP_it); 665 return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_RESP_it);
628} 666}
667LCRYPTO_ALIAS(i2d_TS_RESP);
629 668
630TS_RESP * 669TS_RESP *
631TS_RESP_new(void) 670TS_RESP_new(void)
632{ 671{
633 return (TS_RESP *)ASN1_item_new(&TS_RESP_it); 672 return (TS_RESP *)ASN1_item_new(&TS_RESP_it);
634} 673}
674LCRYPTO_ALIAS(TS_RESP_new);
635 675
636void 676void
637TS_RESP_free(TS_RESP *a) 677TS_RESP_free(TS_RESP *a)
638{ 678{
639 ASN1_item_free((ASN1_VALUE *)a, &TS_RESP_it); 679 ASN1_item_free((ASN1_VALUE *)a, &TS_RESP_it);
640} 680}
681LCRYPTO_ALIAS(TS_RESP_free);
641 682
642TS_RESP * 683TS_RESP *
643TS_RESP_dup(TS_RESP *x) 684TS_RESP_dup(TS_RESP *x)
644{ 685{
645 return ASN1_item_dup(&TS_RESP_it, x); 686 return ASN1_item_dup(&TS_RESP_it, x);
646} 687}
688LCRYPTO_ALIAS(TS_RESP_dup);
647 689
648#ifndef OPENSSL_NO_BIO 690#ifndef OPENSSL_NO_BIO
649TS_RESP * 691TS_RESP *
@@ -651,12 +693,14 @@ d2i_TS_RESP_bio(BIO *bp, TS_RESP **a)
651{ 693{
652 return ASN1_item_d2i_bio(&TS_RESP_it, bp, a); 694 return ASN1_item_d2i_bio(&TS_RESP_it, bp, a);
653} 695}
696LCRYPTO_ALIAS(d2i_TS_RESP_bio);
654 697
655int 698int
656i2d_TS_RESP_bio(BIO *bp, TS_RESP *a) 699i2d_TS_RESP_bio(BIO *bp, TS_RESP *a)
657{ 700{
658 return ASN1_item_i2d_bio(&TS_RESP_it, bp, a); 701 return ASN1_item_i2d_bio(&TS_RESP_it, bp, a);
659} 702}
703LCRYPTO_ALIAS(i2d_TS_RESP_bio);
660#endif 704#endif
661 705
662TS_RESP * 706TS_RESP *
@@ -664,12 +708,14 @@ d2i_TS_RESP_fp(FILE *fp, TS_RESP **a)
664{ 708{
665 return ASN1_item_d2i_fp(&TS_RESP_it, fp, a); 709 return ASN1_item_d2i_fp(&TS_RESP_it, fp, a);
666} 710}
711LCRYPTO_ALIAS(d2i_TS_RESP_fp);
667 712
668int 713int
669i2d_TS_RESP_fp(FILE *fp, TS_RESP *a) 714i2d_TS_RESP_fp(FILE *fp, TS_RESP *a)
670{ 715{
671 return ASN1_item_i2d_fp(&TS_RESP_it, fp, a); 716 return ASN1_item_i2d_fp(&TS_RESP_it, fp, a);
672} 717}
718LCRYPTO_ALIAS(i2d_TS_RESP_fp);
673 719
674static const ASN1_TEMPLATE ESS_ISSUER_SERIAL_seq_tt[] = { 720static const ASN1_TEMPLATE ESS_ISSUER_SERIAL_seq_tt[] = {
675 { 721 {
@@ -705,30 +751,35 @@ d2i_ESS_ISSUER_SERIAL(ESS_ISSUER_SERIAL **a, const unsigned char **in, long len)
705 return (ESS_ISSUER_SERIAL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, 751 return (ESS_ISSUER_SERIAL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
706 &ESS_ISSUER_SERIAL_it); 752 &ESS_ISSUER_SERIAL_it);
707} 753}
754LCRYPTO_ALIAS(d2i_ESS_ISSUER_SERIAL);
708 755
709int 756int
710i2d_ESS_ISSUER_SERIAL(const ESS_ISSUER_SERIAL *a, unsigned char **out) 757i2d_ESS_ISSUER_SERIAL(const ESS_ISSUER_SERIAL *a, unsigned char **out)
711{ 758{
712 return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_ISSUER_SERIAL_it); 759 return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_ISSUER_SERIAL_it);
713} 760}
761LCRYPTO_ALIAS(i2d_ESS_ISSUER_SERIAL);
714 762
715ESS_ISSUER_SERIAL * 763ESS_ISSUER_SERIAL *
716ESS_ISSUER_SERIAL_new(void) 764ESS_ISSUER_SERIAL_new(void)
717{ 765{
718 return (ESS_ISSUER_SERIAL *)ASN1_item_new(&ESS_ISSUER_SERIAL_it); 766 return (ESS_ISSUER_SERIAL *)ASN1_item_new(&ESS_ISSUER_SERIAL_it);
719} 767}
768LCRYPTO_ALIAS(ESS_ISSUER_SERIAL_new);
720 769
721void 770void
722ESS_ISSUER_SERIAL_free(ESS_ISSUER_SERIAL *a) 771ESS_ISSUER_SERIAL_free(ESS_ISSUER_SERIAL *a)
723{ 772{
724 ASN1_item_free((ASN1_VALUE *)a, &ESS_ISSUER_SERIAL_it); 773 ASN1_item_free((ASN1_VALUE *)a, &ESS_ISSUER_SERIAL_it);
725} 774}
775LCRYPTO_ALIAS(ESS_ISSUER_SERIAL_free);
726 776
727ESS_ISSUER_SERIAL * 777ESS_ISSUER_SERIAL *
728ESS_ISSUER_SERIAL_dup(ESS_ISSUER_SERIAL *x) 778ESS_ISSUER_SERIAL_dup(ESS_ISSUER_SERIAL *x)
729{ 779{
730 return ASN1_item_dup(&ESS_ISSUER_SERIAL_it, x); 780 return ASN1_item_dup(&ESS_ISSUER_SERIAL_it, x);
731} 781}
782LCRYPTO_ALIAS(ESS_ISSUER_SERIAL_dup);
732 783
733static const ASN1_TEMPLATE ESS_CERT_ID_seq_tt[] = { 784static const ASN1_TEMPLATE ESS_CERT_ID_seq_tt[] = {
734 { 785 {
@@ -764,30 +815,35 @@ d2i_ESS_CERT_ID(ESS_CERT_ID **a, const unsigned char **in, long len)
764 return (ESS_CERT_ID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, 815 return (ESS_CERT_ID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
765 &ESS_CERT_ID_it); 816 &ESS_CERT_ID_it);
766} 817}
818LCRYPTO_ALIAS(d2i_ESS_CERT_ID);
767 819
768int 820int
769i2d_ESS_CERT_ID(const ESS_CERT_ID *a, unsigned char **out) 821i2d_ESS_CERT_ID(const ESS_CERT_ID *a, unsigned char **out)
770{ 822{
771 return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_CERT_ID_it); 823 return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_CERT_ID_it);
772} 824}
825LCRYPTO_ALIAS(i2d_ESS_CERT_ID);
773 826
774ESS_CERT_ID * 827ESS_CERT_ID *
775ESS_CERT_ID_new(void) 828ESS_CERT_ID_new(void)
776{ 829{
777 return (ESS_CERT_ID *)ASN1_item_new(&ESS_CERT_ID_it); 830 return (ESS_CERT_ID *)ASN1_item_new(&ESS_CERT_ID_it);
778} 831}
832LCRYPTO_ALIAS(ESS_CERT_ID_new);
779 833
780void 834void
781ESS_CERT_ID_free(ESS_CERT_ID *a) 835ESS_CERT_ID_free(ESS_CERT_ID *a)
782{ 836{
783 ASN1_item_free((ASN1_VALUE *)a, &ESS_CERT_ID_it); 837 ASN1_item_free((ASN1_VALUE *)a, &ESS_CERT_ID_it);
784} 838}
839LCRYPTO_ALIAS(ESS_CERT_ID_free);
785 840
786ESS_CERT_ID * 841ESS_CERT_ID *
787ESS_CERT_ID_dup(ESS_CERT_ID *x) 842ESS_CERT_ID_dup(ESS_CERT_ID *x)
788{ 843{
789 return ASN1_item_dup(&ESS_CERT_ID_it, x); 844 return ASN1_item_dup(&ESS_CERT_ID_it, x);
790} 845}
846LCRYPTO_ALIAS(ESS_CERT_ID_dup);
791 847
792static const ASN1_TEMPLATE ESS_SIGNING_CERT_seq_tt[] = { 848static const ASN1_TEMPLATE ESS_SIGNING_CERT_seq_tt[] = {
793 { 849 {
@@ -823,30 +879,35 @@ d2i_ESS_SIGNING_CERT(ESS_SIGNING_CERT **a, const unsigned char **in, long len)
823 return (ESS_SIGNING_CERT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, 879 return (ESS_SIGNING_CERT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
824 &ESS_SIGNING_CERT_it); 880 &ESS_SIGNING_CERT_it);
825} 881}
882LCRYPTO_ALIAS(d2i_ESS_SIGNING_CERT);
826 883
827int 884int
828i2d_ESS_SIGNING_CERT(const ESS_SIGNING_CERT *a, unsigned char **out) 885i2d_ESS_SIGNING_CERT(const ESS_SIGNING_CERT *a, unsigned char **out)
829{ 886{
830 return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_SIGNING_CERT_it); 887 return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_SIGNING_CERT_it);
831} 888}
889LCRYPTO_ALIAS(i2d_ESS_SIGNING_CERT);
832 890
833ESS_SIGNING_CERT * 891ESS_SIGNING_CERT *
834ESS_SIGNING_CERT_new(void) 892ESS_SIGNING_CERT_new(void)
835{ 893{
836 return (ESS_SIGNING_CERT *)ASN1_item_new(&ESS_SIGNING_CERT_it); 894 return (ESS_SIGNING_CERT *)ASN1_item_new(&ESS_SIGNING_CERT_it);
837} 895}
896LCRYPTO_ALIAS(ESS_SIGNING_CERT_new);
838 897
839void 898void
840ESS_SIGNING_CERT_free(ESS_SIGNING_CERT *a) 899ESS_SIGNING_CERT_free(ESS_SIGNING_CERT *a)
841{ 900{
842 ASN1_item_free((ASN1_VALUE *)a, &ESS_SIGNING_CERT_it); 901 ASN1_item_free((ASN1_VALUE *)a, &ESS_SIGNING_CERT_it);
843} 902}
903LCRYPTO_ALIAS(ESS_SIGNING_CERT_free);
844 904
845ESS_SIGNING_CERT * 905ESS_SIGNING_CERT *
846ESS_SIGNING_CERT_dup(ESS_SIGNING_CERT *x) 906ESS_SIGNING_CERT_dup(ESS_SIGNING_CERT *x)
847{ 907{
848 return ASN1_item_dup(&ESS_SIGNING_CERT_it, x); 908 return ASN1_item_dup(&ESS_SIGNING_CERT_it, x);
849} 909}
910LCRYPTO_ALIAS(ESS_SIGNING_CERT_dup);
850 911
851static const ASN1_TEMPLATE ESS_CERT_ID_V2_seq_tt[] = { 912static const ASN1_TEMPLATE ESS_CERT_ID_V2_seq_tt[] = {
852 { 913 {
@@ -1013,3 +1074,4 @@ PKCS7_to_TS_TST_INFO(PKCS7 *token)
1013 p = tst_info_der->data; 1074 p = tst_info_der->data;
1014 return d2i_TS_TST_INFO(NULL, &p, tst_info_der->length); 1075 return d2i_TS_TST_INFO(NULL, &p, tst_info_der->length);
1015} 1076}
1077LCRYPTO_ALIAS(PKCS7_to_TS_TST_INFO);
diff --git a/src/lib/libcrypto/ts/ts_conf.c b/src/lib/libcrypto/ts/ts_conf.c
index 41d185ee5a..103d430272 100644
--- a/src/lib/libcrypto/ts/ts_conf.c
+++ b/src/lib/libcrypto/ts/ts_conf.c
@@ -1,4 +1,4 @@
1/* $OpenBSD: ts_conf.c,v 1.11 2018/04/14 07:18:37 tb Exp $ */ 1/* $OpenBSD: ts_conf.c,v 1.12 2023/07/07 07:25:21 beck Exp $ */
2/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL 2/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL
3 * project 2002. 3 * project 2002.
4 */ 4 */
@@ -110,6 +110,7 @@ end:
110 BIO_free(cert); 110 BIO_free(cert);
111 return x; 111 return x;
112} 112}
113LCRYPTO_ALIAS(TS_CONF_load_cert);
113 114
114STACK_OF(X509) * 115STACK_OF(X509) *
115TS_CONF_load_certs(const char *file) 116TS_CONF_load_certs(const char *file)
@@ -144,6 +145,7 @@ end:
144 BIO_free(certs); 145 BIO_free(certs);
145 return othercerts; 146 return othercerts;
146} 147}
148LCRYPTO_ALIAS(TS_CONF_load_certs);
147 149
148EVP_PKEY * 150EVP_PKEY *
149TS_CONF_load_key(const char *file, const char *pass) 151TS_CONF_load_key(const char *file, const char *pass)
@@ -161,6 +163,7 @@ end:
161 BIO_free(key); 163 BIO_free(key);
162 return pkey; 164 return pkey;
163} 165}
166LCRYPTO_ALIAS(TS_CONF_load_key);
164 167
165/* Function definitions for handling configuration options. */ 168/* Function definitions for handling configuration options. */
166 169
@@ -186,6 +189,7 @@ TS_CONF_get_tsa_section(CONF *conf, const char *section)
186 } 189 }
187 return section; 190 return section;
188} 191}
192LCRYPTO_ALIAS(TS_CONF_get_tsa_section);
189 193
190int 194int
191TS_CONF_set_serial(CONF *conf, const char *section, TS_serial_cb cb, 195TS_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,
205err: 209err:
206 return ret; 210 return ret;
207} 211}
212LCRYPTO_ALIAS(TS_CONF_set_serial);
208 213
209#ifndef OPENSSL_NO_ENGINE 214#ifndef OPENSSL_NO_ENGINE
210 215
@@ -225,6 +230,7 @@ TS_CONF_set_crypto_device(CONF *conf, const char *section, const char *device)
225err: 230err:
226 return ret; 231 return ret;
227} 232}
233LCRYPTO_ALIAS(TS_CONF_set_crypto_device);
228 234
229int 235int
230TS_CONF_set_default_engine(const char *name) 236TS_CONF_set_default_engine(const char *name)
@@ -251,6 +257,7 @@ err:
251 ENGINE_free(e); 257 ENGINE_free(e);
252 return ret; 258 return ret;
253} 259}
260LCRYPTO_ALIAS(TS_CONF_set_default_engine);
254 261
255#endif 262#endif
256 263
@@ -278,6 +285,7 @@ err:
278 X509_free(cert_obj); 285 X509_free(cert_obj);
279 return ret; 286 return ret;
280} 287}
288LCRYPTO_ALIAS(TS_CONF_set_signer_cert);
281 289
282int 290int
283TS_CONF_set_certs(CONF *conf, const char *section, const char *certs, 291TS_CONF_set_certs(CONF *conf, const char *section, const char *certs,
@@ -302,6 +310,7 @@ err:
302 sk_X509_pop_free(certs_obj, X509_free); 310 sk_X509_pop_free(certs_obj, X509_free);
303 return ret; 311 return ret;
304} 312}
313LCRYPTO_ALIAS(TS_CONF_set_certs);
305 314
306int 315int
307TS_CONF_set_signer_key(CONF *conf, const char *section, const char *key, 316TS_CONF_set_signer_key(CONF *conf, const char *section, const char *key,
@@ -327,6 +336,7 @@ err:
327 EVP_PKEY_free(key_obj); 336 EVP_PKEY_free(key_obj);
328 return ret; 337 return ret;
329} 338}
339LCRYPTO_ALIAS(TS_CONF_set_signer_key);
330 340
331int 341int
332TS_CONF_set_def_policy(CONF *conf, const char *section, const char *policy, 342TS_CONF_set_def_policy(CONF *conf, const char *section, const char *policy,
@@ -354,6 +364,7 @@ err:
354 ASN1_OBJECT_free(policy_obj); 364 ASN1_OBJECT_free(policy_obj);
355 return ret; 365 return ret;
356} 366}
367LCRYPTO_ALIAS(TS_CONF_set_def_policy);
357 368
358int 369int
359TS_CONF_set_policies(CONF *conf, const char *section, TS_RESP_CTX *ctx) 370TS_CONF_set_policies(CONF *conf, const char *section, TS_RESP_CTX *ctx)
@@ -387,6 +398,7 @@ err:
387 sk_CONF_VALUE_pop_free(list, X509V3_conf_free); 398 sk_CONF_VALUE_pop_free(list, X509V3_conf_free);
388 return ret; 399 return ret;
389} 400}
401LCRYPTO_ALIAS(TS_CONF_set_policies);
390 402
391int 403int
392TS_CONF_set_digests(CONF *conf, const char *section, TS_RESP_CTX *ctx) 404TS_CONF_set_digests(CONF *conf, const char *section, TS_RESP_CTX *ctx)
@@ -426,6 +438,7 @@ err:
426 sk_CONF_VALUE_pop_free(list, X509V3_conf_free); 438 sk_CONF_VALUE_pop_free(list, X509V3_conf_free);
427 return ret; 439 return ret;
428} 440}
441LCRYPTO_ALIAS(TS_CONF_set_digests);
429 442
430int 443int
431TS_CONF_set_accuracy(CONF *conf, const char *section, TS_RESP_CTX *ctx) 444TS_CONF_set_accuracy(CONF *conf, const char *section, TS_RESP_CTX *ctx)
@@ -465,6 +478,7 @@ err:
465 sk_CONF_VALUE_pop_free(list, X509V3_conf_free); 478 sk_CONF_VALUE_pop_free(list, X509V3_conf_free);
466 return ret; 479 return ret;
467} 480}
481LCRYPTO_ALIAS(TS_CONF_set_accuracy);
468 482
469int 483int
470TS_CONF_set_clock_precision_digits(CONF *conf, const char *section, 484TS_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,
490err: 504err:
491 return ret; 505 return ret;
492} 506}
507LCRYPTO_ALIAS(TS_CONF_set_clock_precision_digits);
493 508
494static int 509static int
495TS_CONF_add_flag(CONF *conf, const char *section, const char *field, int flag, 510TS_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)
515{ 530{
516 return TS_CONF_add_flag(conf, section, ENV_ORDERING, TS_ORDERING, ctx); 531 return TS_CONF_add_flag(conf, section, ENV_ORDERING, TS_ORDERING, ctx);
517} 532}
533LCRYPTO_ALIAS(TS_CONF_set_ordering);
518 534
519int 535int
520TS_CONF_set_tsa_name(CONF *conf, const char *section, TS_RESP_CTX *ctx) 536TS_CONF_set_tsa_name(CONF *conf, const char *section, TS_RESP_CTX *ctx)
521{ 537{
522 return TS_CONF_add_flag(conf, section, ENV_TSA_NAME, TS_TSA_NAME, ctx); 538 return TS_CONF_add_flag(conf, section, ENV_TSA_NAME, TS_TSA_NAME, ctx);
523} 539}
540LCRYPTO_ALIAS(TS_CONF_set_tsa_name);
524 541
525int 542int
526TS_CONF_set_ess_cert_id_chain(CONF *conf, const char *section, TS_RESP_CTX *ctx) 543TS_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)
528 return TS_CONF_add_flag(conf, section, ENV_ESS_CERT_ID_CHAIN, 545 return TS_CONF_add_flag(conf, section, ENV_ESS_CERT_ID_CHAIN,
529 TS_ESS_CERT_ID_CHAIN, ctx); 546 TS_ESS_CERT_ID_CHAIN, ctx);
530} 547}
548LCRYPTO_ALIAS(TS_CONF_set_ess_cert_id_chain);
diff --git a/src/lib/libcrypto/ts/ts_err.c b/src/lib/libcrypto/ts/ts_err.c
index ddd532a6a7..bb8209a85c 100644
--- a/src/lib/libcrypto/ts/ts_err.c
+++ b/src/lib/libcrypto/ts/ts_err.c
@@ -1,4 +1,4 @@
1/* $OpenBSD: ts_err.c,v 1.6 2022/07/12 14:42:50 kn Exp $ */ 1/* $OpenBSD: ts_err.c,v 1.7 2023/07/07 07:25:21 beck Exp $ */
2/* ==================================================================== 2/* ====================================================================
3 * Copyright (c) 1999-2007 The OpenSSL Project. All rights reserved. 3 * Copyright (c) 1999-2007 The OpenSSL Project. All rights reserved.
4 * 4 *
@@ -121,3 +121,4 @@ ERR_load_TS_strings(void)
121 } 121 }
122#endif 122#endif
123} 123}
124LCRYPTO_ALIAS(ERR_load_TS_strings);
diff --git a/src/lib/libcrypto/ts/ts_lib.c b/src/lib/libcrypto/ts/ts_lib.c
index ae715fb6c9..1e94922aa1 100644
--- a/src/lib/libcrypto/ts/ts_lib.c
+++ b/src/lib/libcrypto/ts/ts_lib.c
@@ -1,4 +1,4 @@
1/* $OpenBSD: ts_lib.c,v 1.13 2022/11/26 16:08:54 tb Exp $ */ 1/* $OpenBSD: ts_lib.c,v 1.14 2023/07/07 07:25:21 beck Exp $ */
2/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL 2/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL
3 * project 2002. 3 * project 2002.
4 */ 4 */
@@ -89,6 +89,7 @@ TS_ASN1_INTEGER_print_bio(BIO *bio, const ASN1_INTEGER *num)
89 89
90 return result; 90 return result;
91} 91}
92LCRYPTO_ALIAS(TS_ASN1_INTEGER_print_bio);
92 93
93int 94int
94TS_OBJ_print_bio(BIO *bio, const ASN1_OBJECT *obj) 95TS_OBJ_print_bio(BIO *bio, const ASN1_OBJECT *obj)
@@ -102,6 +103,7 @@ TS_OBJ_print_bio(BIO *bio, const ASN1_OBJECT *obj)
102 BIO_write(bio, "\n", 1); 103 BIO_write(bio, "\n", 1);
103 return 1; 104 return 1;
104} 105}
106LCRYPTO_ALIAS(TS_OBJ_print_bio);
105 107
106int 108int
107TS_ext_print_bio(BIO *bio, const STACK_OF(X509_EXTENSION) *extensions) 109TS_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)
127 129
128 return 1; 130 return 1;
129} 131}
132LCRYPTO_ALIAS(TS_ext_print_bio);
130 133
131int 134int
132TS_X509_ALGOR_print_bio(BIO *bio, const X509_ALGOR *alg) 135TS_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)
136 return BIO_printf(bio, "Hash Algorithm: %s\n", 139 return BIO_printf(bio, "Hash Algorithm: %s\n",
137 (i == NID_undef) ? "UNKNOWN" : OBJ_nid2ln(i)); 140 (i == NID_undef) ? "UNKNOWN" : OBJ_nid2ln(i));
138} 141}
142LCRYPTO_ALIAS(TS_X509_ALGOR_print_bio);
139 143
140int 144int
141TS_MSG_IMPRINT_print_bio(BIO *bio, TS_MSG_IMPRINT *a) 145TS_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)
151 155
152 return 1; 156 return 1;
153} 157}
158LCRYPTO_ALIAS(TS_MSG_IMPRINT_print_bio);
diff --git a/src/lib/libcrypto/ts/ts_req_print.c b/src/lib/libcrypto/ts/ts_req_print.c
index 64a8133a58..ddcdda97a3 100644
--- a/src/lib/libcrypto/ts/ts_req_print.c
+++ b/src/lib/libcrypto/ts/ts_req_print.c
@@ -1,4 +1,4 @@
1/* $OpenBSD: ts_req_print.c,v 1.4 2014/07/11 08:44:49 jsing Exp $ */ 1/* $OpenBSD: ts_req_print.c,v 1.5 2023/07/07 07:25:21 beck Exp $ */
2/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL 2/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL
3 * project 2002. 3 * project 2002.
4 */ 4 */
@@ -102,3 +102,4 @@ TS_REQ_print_bio(BIO *bio, TS_REQ *a)
102 102
103 return 1; 103 return 1;
104} 104}
105LCRYPTO_ALIAS(TS_REQ_print_bio);
diff --git a/src/lib/libcrypto/ts/ts_req_utils.c b/src/lib/libcrypto/ts/ts_req_utils.c
index 8d9d6f3e61..f331219373 100644
--- a/src/lib/libcrypto/ts/ts_req_utils.c
+++ b/src/lib/libcrypto/ts/ts_req_utils.c
@@ -1,4 +1,4 @@
1/* $OpenBSD: ts_req_utils.c,v 1.7 2022/07/24 08:16:47 tb Exp $ */ 1/* $OpenBSD: ts_req_utils.c,v 1.8 2023/07/07 07:25:21 beck Exp $ */
2/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL 2/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL
3 * project 2002. 3 * project 2002.
4 */ 4 */
@@ -70,12 +70,14 @@ TS_REQ_set_version(TS_REQ *a, long version)
70{ 70{
71 return ASN1_INTEGER_set(a->version, version); 71 return ASN1_INTEGER_set(a->version, version);
72} 72}
73LCRYPTO_ALIAS(TS_REQ_set_version);
73 74
74long 75long
75TS_REQ_get_version(const TS_REQ *a) 76TS_REQ_get_version(const TS_REQ *a)
76{ 77{
77 return ASN1_INTEGER_get(a->version); 78 return ASN1_INTEGER_get(a->version);
78} 79}
80LCRYPTO_ALIAS(TS_REQ_get_version);
79 81
80int 82int
81TS_REQ_set_msg_imprint(TS_REQ *a, TS_MSG_IMPRINT *msg_imprint) 83TS_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)
93 a->msg_imprint = new_msg_imprint; 95 a->msg_imprint = new_msg_imprint;
94 return 1; 96 return 1;
95} 97}
98LCRYPTO_ALIAS(TS_REQ_set_msg_imprint);
96 99
97TS_MSG_IMPRINT * 100TS_MSG_IMPRINT *
98TS_REQ_get_msg_imprint(TS_REQ *a) 101TS_REQ_get_msg_imprint(TS_REQ *a)
99{ 102{
100 return a->msg_imprint; 103 return a->msg_imprint;
101} 104}
105LCRYPTO_ALIAS(TS_REQ_get_msg_imprint);
102 106
103int 107int
104TS_MSG_IMPRINT_set_algo(TS_MSG_IMPRINT *a, X509_ALGOR *alg) 108TS_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)
116 a->hash_algo = new_alg; 120 a->hash_algo = new_alg;
117 return 1; 121 return 1;
118} 122}
123LCRYPTO_ALIAS(TS_MSG_IMPRINT_set_algo);
119 124
120X509_ALGOR * 125X509_ALGOR *
121TS_MSG_IMPRINT_get_algo(TS_MSG_IMPRINT *a) 126TS_MSG_IMPRINT_get_algo(TS_MSG_IMPRINT *a)
122{ 127{
123 return a->hash_algo; 128 return a->hash_algo;
124} 129}
130LCRYPTO_ALIAS(TS_MSG_IMPRINT_get_algo);
125 131
126int 132int
127TS_MSG_IMPRINT_set_msg(TS_MSG_IMPRINT *a, unsigned char *d, int len) 133TS_MSG_IMPRINT_set_msg(TS_MSG_IMPRINT *a, unsigned char *d, int len)
128{ 134{
129 return ASN1_OCTET_STRING_set(a->hashed_msg, d, len); 135 return ASN1_OCTET_STRING_set(a->hashed_msg, d, len);
130} 136}
137LCRYPTO_ALIAS(TS_MSG_IMPRINT_set_msg);
131 138
132ASN1_OCTET_STRING * 139ASN1_OCTET_STRING *
133TS_MSG_IMPRINT_get_msg(TS_MSG_IMPRINT *a) 140TS_MSG_IMPRINT_get_msg(TS_MSG_IMPRINT *a)
134{ 141{
135 return a->hashed_msg; 142 return a->hashed_msg;
136} 143}
144LCRYPTO_ALIAS(TS_MSG_IMPRINT_get_msg);
137 145
138int 146int
139TS_REQ_set_policy_id(TS_REQ *a, const ASN1_OBJECT *policy) 147TS_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)
151 a->policy_id = new_policy; 159 a->policy_id = new_policy;
152 return 1; 160 return 1;
153} 161}
162LCRYPTO_ALIAS(TS_REQ_set_policy_id);
154 163
155ASN1_OBJECT * 164ASN1_OBJECT *
156TS_REQ_get_policy_id(TS_REQ *a) 165TS_REQ_get_policy_id(TS_REQ *a)
157{ 166{
158 return a->policy_id; 167 return a->policy_id;
159} 168}
169LCRYPTO_ALIAS(TS_REQ_get_policy_id);
160 170
161int 171int
162TS_REQ_set_nonce(TS_REQ *a, const ASN1_INTEGER *nonce) 172TS_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)
174 a->nonce = new_nonce; 184 a->nonce = new_nonce;
175 return 1; 185 return 1;
176} 186}
187LCRYPTO_ALIAS(TS_REQ_set_nonce);
177 188
178const ASN1_INTEGER * 189const ASN1_INTEGER *
179TS_REQ_get_nonce(const TS_REQ *a) 190TS_REQ_get_nonce(const TS_REQ *a)
180{ 191{
181 return a->nonce; 192 return a->nonce;
182} 193}
194LCRYPTO_ALIAS(TS_REQ_get_nonce);
183 195
184int 196int
185TS_REQ_set_cert_req(TS_REQ *a, int cert_req) 197TS_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)
187 a->cert_req = cert_req ? 0xFF : 0x00; 199 a->cert_req = cert_req ? 0xFF : 0x00;
188 return 1; 200 return 1;
189} 201}
202LCRYPTO_ALIAS(TS_REQ_set_cert_req);
190 203
191int 204int
192TS_REQ_get_cert_req(const TS_REQ *a) 205TS_REQ_get_cert_req(const TS_REQ *a)
193{ 206{
194 return a->cert_req ? 1 : 0; 207 return a->cert_req ? 1 : 0;
195} 208}
209LCRYPTO_ALIAS(TS_REQ_get_cert_req);
196 210
197STACK_OF(X509_EXTENSION) *TS_REQ_get_exts(TS_REQ *a) 211STACK_OF(X509_EXTENSION) *TS_REQ_get_exts(TS_REQ *a)
198{ 212{
@@ -207,51 +221,60 @@ TS_REQ_ext_free(TS_REQ *a)
207 sk_X509_EXTENSION_pop_free(a->extensions, X509_EXTENSION_free); 221 sk_X509_EXTENSION_pop_free(a->extensions, X509_EXTENSION_free);
208 a->extensions = NULL; 222 a->extensions = NULL;
209} 223}
224LCRYPTO_ALIAS(TS_REQ_ext_free);
210 225
211int 226int
212TS_REQ_get_ext_count(TS_REQ *a) 227TS_REQ_get_ext_count(TS_REQ *a)
213{ 228{
214 return X509v3_get_ext_count(a->extensions); 229 return X509v3_get_ext_count(a->extensions);
215} 230}
231LCRYPTO_ALIAS(TS_REQ_get_ext_count);
216 232
217int 233int
218TS_REQ_get_ext_by_NID(TS_REQ *a, int nid, int lastpos) 234TS_REQ_get_ext_by_NID(TS_REQ *a, int nid, int lastpos)
219{ 235{
220 return X509v3_get_ext_by_NID(a->extensions, nid, lastpos); 236 return X509v3_get_ext_by_NID(a->extensions, nid, lastpos);
221} 237}
238LCRYPTO_ALIAS(TS_REQ_get_ext_by_NID);
222 239
223int 240int
224TS_REQ_get_ext_by_OBJ(TS_REQ *a, const ASN1_OBJECT *obj, int lastpos) 241TS_REQ_get_ext_by_OBJ(TS_REQ *a, const ASN1_OBJECT *obj, int lastpos)
225{ 242{
226 return X509v3_get_ext_by_OBJ(a->extensions, obj, lastpos); 243 return X509v3_get_ext_by_OBJ(a->extensions, obj, lastpos);
227} 244}
245LCRYPTO_ALIAS(TS_REQ_get_ext_by_OBJ);
228 246
229int 247int
230TS_REQ_get_ext_by_critical(TS_REQ *a, int crit, int lastpos) 248TS_REQ_get_ext_by_critical(TS_REQ *a, int crit, int lastpos)
231{ 249{
232 return X509v3_get_ext_by_critical(a->extensions, crit, lastpos); 250 return X509v3_get_ext_by_critical(a->extensions, crit, lastpos);
233} 251}
252LCRYPTO_ALIAS(TS_REQ_get_ext_by_critical);
234 253
235X509_EXTENSION * 254X509_EXTENSION *
236TS_REQ_get_ext(TS_REQ *a, int loc) 255TS_REQ_get_ext(TS_REQ *a, int loc)
237{ 256{
238 return X509v3_get_ext(a->extensions, loc); 257 return X509v3_get_ext(a->extensions, loc);
239} 258}
259LCRYPTO_ALIAS(TS_REQ_get_ext);
240 260
241X509_EXTENSION * 261X509_EXTENSION *
242TS_REQ_delete_ext(TS_REQ *a, int loc) 262TS_REQ_delete_ext(TS_REQ *a, int loc)
243{ 263{
244 return X509v3_delete_ext(a->extensions, loc); 264 return X509v3_delete_ext(a->extensions, loc);
245} 265}
266LCRYPTO_ALIAS(TS_REQ_delete_ext);
246 267
247int 268int
248TS_REQ_add_ext(TS_REQ *a, X509_EXTENSION *ex, int loc) 269TS_REQ_add_ext(TS_REQ *a, X509_EXTENSION *ex, int loc)
249{ 270{
250 return X509v3_add_ext(&a->extensions, ex, loc) != NULL; 271 return X509v3_add_ext(&a->extensions, ex, loc) != NULL;
251} 272}
273LCRYPTO_ALIAS(TS_REQ_add_ext);
252 274
253void * 275void *
254TS_REQ_get_ext_d2i(TS_REQ *a, int nid, int *crit, int *idx) 276TS_REQ_get_ext_d2i(TS_REQ *a, int nid, int *crit, int *idx)
255{ 277{
256 return X509V3_get_d2i(a->extensions, nid, crit, idx); 278 return X509V3_get_d2i(a->extensions, nid, crit, idx);
257} 279}
280LCRYPTO_ALIAS(TS_REQ_get_ext_d2i);
diff --git a/src/lib/libcrypto/ts/ts_rsp_print.c b/src/lib/libcrypto/ts/ts_rsp_print.c
index cfff955cd6..c65d226686 100644
--- a/src/lib/libcrypto/ts/ts_rsp_print.c
+++ b/src/lib/libcrypto/ts/ts_rsp_print.c
@@ -1,4 +1,4 @@
1/* $OpenBSD: ts_rsp_print.c,v 1.6 2022/07/24 08:16:47 tb Exp $ */ 1/* $OpenBSD: ts_rsp_print.c,v 1.7 2023/07/07 07:25:21 beck Exp $ */
2/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL 2/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL
3 * project 2002. 3 * project 2002.
4 */ 4 */
@@ -95,6 +95,7 @@ TS_RESP_print_bio(BIO *bio, TS_RESP *a)
95 95
96 return 1; 96 return 1;
97} 97}
98LCRYPTO_ALIAS(TS_RESP_print_bio);
98 99
99int 100int
100TS_STATUS_INFO_print_bio(BIO *bio, TS_STATUS_INFO *a) 101TS_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)
177 178
178 return 1; 179 return 1;
179} 180}
181LCRYPTO_ALIAS(TS_STATUS_INFO_print_bio);
180 182
181static int 183static int
182TS_status_map_print(BIO *bio, struct status_map_st *a, ASN1_BIT_STRING *v) 184TS_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)
275 277
276 return 1; 278 return 1;
277} 279}
280LCRYPTO_ALIAS(TS_TST_INFO_print_bio);
278 281
279static int 282static int
280TS_ACCURACY_print_bio(BIO *bio, const TS_ACCURACY *accuracy) 283TS_ACCURACY_print_bio(BIO *bio, const TS_ACCURACY *accuracy)
diff --git a/src/lib/libcrypto/ts/ts_rsp_sign.c b/src/lib/libcrypto/ts/ts_rsp_sign.c
index 7ebadb1049..84a6993106 100644
--- a/src/lib/libcrypto/ts/ts_rsp_sign.c
+++ b/src/lib/libcrypto/ts/ts_rsp_sign.c
@@ -1,4 +1,4 @@
1/* $OpenBSD: ts_rsp_sign.c,v 1.30 2022/11/26 16:08:54 tb Exp $ */ 1/* $OpenBSD: ts_rsp_sign.c,v 1.31 2023/07/07 07:25:21 beck Exp $ */
2/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL 2/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL
3 * project 2002. 3 * project 2002.
4 */ 4 */
@@ -149,6 +149,7 @@ TS_RESP_CTX_set_time_cb(TS_RESP_CTX *ctx, TS_time_cb cb, void *data)
149 ctx->time_cb = cb; 149 ctx->time_cb = cb;
150 ctx->time_cb_data = data; 150 ctx->time_cb_data = data;
151} 151}
152LCRYPTO_ALIAS(TS_RESP_CTX_set_time_cb);
152 153
153/* TS_RESP_CTX management functions. */ 154/* TS_RESP_CTX management functions. */
154 155
@@ -169,6 +170,7 @@ TS_RESP_CTX_new(void)
169 170
170 return ctx; 171 return ctx;
171} 172}
173LCRYPTO_ALIAS(TS_RESP_CTX_new);
172 174
173void 175void
174TS_RESP_CTX_free(TS_RESP_CTX *ctx) 176TS_RESP_CTX_free(TS_RESP_CTX *ctx)
@@ -187,6 +189,7 @@ TS_RESP_CTX_free(TS_RESP_CTX *ctx)
187 ASN1_INTEGER_free(ctx->micros); 189 ASN1_INTEGER_free(ctx->micros);
188 free(ctx); 190 free(ctx);
189} 191}
192LCRYPTO_ALIAS(TS_RESP_CTX_free);
190 193
191int 194int
192TS_RESP_CTX_set_signer_cert(TS_RESP_CTX *ctx, X509 *signer) 195TS_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)
200 CRYPTO_add(&ctx->signer_cert->references, +1, CRYPTO_LOCK_X509); 203 CRYPTO_add(&ctx->signer_cert->references, +1, CRYPTO_LOCK_X509);
201 return 1; 204 return 1;
202} 205}
206LCRYPTO_ALIAS(TS_RESP_CTX_set_signer_cert);
203 207
204int 208int
205TS_RESP_CTX_set_signer_key(TS_RESP_CTX *ctx, EVP_PKEY *key) 209TS_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)
210 214
211 return 1; 215 return 1;
212} 216}
217LCRYPTO_ALIAS(TS_RESP_CTX_set_signer_key);
213 218
214int 219int
215TS_RESP_CTX_set_def_policy(TS_RESP_CTX *ctx, const ASN1_OBJECT *def_policy) 220TS_RESP_CTX_set_def_policy(TS_RESP_CTX *ctx, const ASN1_OBJECT *def_policy)
@@ -224,6 +229,7 @@ err:
224 TSerror(ERR_R_MALLOC_FAILURE); 229 TSerror(ERR_R_MALLOC_FAILURE);
225 return 0; 230 return 0;
226} 231}
232LCRYPTO_ALIAS(TS_RESP_CTX_set_def_policy);
227 233
228int 234int
229TS_RESP_CTX_set_certs(TS_RESP_CTX *ctx, STACK_OF(X509) *certs) 235TS_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)
247 253
248 return 1; 254 return 1;
249} 255}
256LCRYPTO_ALIAS(TS_RESP_CTX_set_certs);
250 257
251int 258int
252TS_RESP_CTX_add_policy(TS_RESP_CTX *ctx, const ASN1_OBJECT *policy) 259TS_RESP_CTX_add_policy(TS_RESP_CTX *ctx, const ASN1_OBJECT *policy)
@@ -268,6 +275,7 @@ err:
268 ASN1_OBJECT_free(copy); 275 ASN1_OBJECT_free(copy);
269 return 0; 276 return 0;
270} 277}
278LCRYPTO_ALIAS(TS_RESP_CTX_add_policy);
271 279
272int 280int
273TS_RESP_CTX_add_md(TS_RESP_CTX *ctx, const EVP_MD *md) 281TS_RESP_CTX_add_md(TS_RESP_CTX *ctx, const EVP_MD *md)
@@ -285,6 +293,7 @@ err:
285 TSerror(ERR_R_MALLOC_FAILURE); 293 TSerror(ERR_R_MALLOC_FAILURE);
286 return 0; 294 return 0;
287} 295}
296LCRYPTO_ALIAS(TS_RESP_CTX_add_md);
288 297
289#define TS_RESP_CTX_accuracy_free(ctx) \ 298#define TS_RESP_CTX_accuracy_free(ctx) \
290 ASN1_INTEGER_free(ctx->seconds); \ 299 ASN1_INTEGER_free(ctx->seconds); \
@@ -315,12 +324,14 @@ err:
315 TSerror(ERR_R_MALLOC_FAILURE); 324 TSerror(ERR_R_MALLOC_FAILURE);
316 return 0; 325 return 0;
317} 326}
327LCRYPTO_ALIAS(TS_RESP_CTX_set_accuracy);
318 328
319void 329void
320TS_RESP_CTX_add_flags(TS_RESP_CTX *ctx, int flags) 330TS_RESP_CTX_add_flags(TS_RESP_CTX *ctx, int flags)
321{ 331{
322 ctx->flags |= flags; 332 ctx->flags |= flags;
323} 333}
334LCRYPTO_ALIAS(TS_RESP_CTX_add_flags);
324 335
325void 336void
326TS_RESP_CTX_set_serial_cb(TS_RESP_CTX *ctx, TS_serial_cb cb, void *data) 337TS_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)
328 ctx->serial_cb = cb; 339 ctx->serial_cb = cb;
329 ctx->serial_cb_data = data; 340 ctx->serial_cb_data = data;
330} 341}
342LCRYPTO_ALIAS(TS_RESP_CTX_set_serial_cb);
331 343
332void 344void
333TS_RESP_CTX_set_extension_cb(TS_RESP_CTX *ctx, TS_extension_cb cb, void *data) 345TS_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)
335 ctx->extension_cb = cb; 347 ctx->extension_cb = cb;
336 ctx->extension_cb_data = data; 348 ctx->extension_cb_data = data;
337} 349}
350LCRYPTO_ALIAS(TS_RESP_CTX_set_extension_cb);
338 351
339int 352int
340TS_RESP_CTX_set_status_info(TS_RESP_CTX *ctx, int status, const char *text) 353TS_RESP_CTX_set_status_info(TS_RESP_CTX *ctx, int status, const char *text)
@@ -368,6 +381,7 @@ err:
368 ASN1_UTF8STRING_free(utf8_text); 381 ASN1_UTF8STRING_free(utf8_text);
369 return ret; 382 return ret;
370} 383}
384LCRYPTO_ALIAS(TS_RESP_CTX_set_status_info);
371 385
372int 386int
373TS_RESP_CTX_set_status_info_cond(TS_RESP_CTX *ctx, int status, const char *text) 387TS_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)
381 } 395 }
382 return ret; 396 return ret;
383} 397}
398LCRYPTO_ALIAS(TS_RESP_CTX_set_status_info_cond);
384 399
385int 400int
386TS_RESP_CTX_add_failure_info(TS_RESP_CTX *ctx, int failure) 401TS_RESP_CTX_add_failure_info(TS_RESP_CTX *ctx, int failure)
@@ -397,18 +412,21 @@ err:
397 TSerror(ERR_R_MALLOC_FAILURE); 412 TSerror(ERR_R_MALLOC_FAILURE);
398 return 0; 413 return 0;
399} 414}
415LCRYPTO_ALIAS(TS_RESP_CTX_add_failure_info);
400 416
401TS_REQ * 417TS_REQ *
402TS_RESP_CTX_get_request(TS_RESP_CTX *ctx) 418TS_RESP_CTX_get_request(TS_RESP_CTX *ctx)
403{ 419{
404 return ctx->request; 420 return ctx->request;
405} 421}
422LCRYPTO_ALIAS(TS_RESP_CTX_get_request);
406 423
407TS_TST_INFO * 424TS_TST_INFO *
408TS_RESP_CTX_get_tst_info(TS_RESP_CTX *ctx) 425TS_RESP_CTX_get_tst_info(TS_RESP_CTX *ctx)
409{ 426{
410 return ctx->tst_info; 427 return ctx->tst_info;
411} 428}
429LCRYPTO_ALIAS(TS_RESP_CTX_get_tst_info);
412 430
413int 431int
414TS_RESP_CTX_set_clock_precision_digits(TS_RESP_CTX *ctx, unsigned precision) 432TS_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)
418 ctx->clock_precision_digits = precision; 436 ctx->clock_precision_digits = precision;
419 return 1; 437 return 1;
420} 438}
439LCRYPTO_ALIAS(TS_RESP_CTX_set_clock_precision_digits);
421 440
422/* Main entry method of the response generation. */ 441/* Main entry method of the response generation. */
423TS_RESP * 442TS_RESP *
@@ -488,6 +507,7 @@ end:
488 TS_RESP_CTX_cleanup(ctx); 507 TS_RESP_CTX_cleanup(ctx);
489 return response; 508 return response;
490} 509}
510LCRYPTO_ALIAS(TS_RESP_create_response);
491 511
492/* Initializes the variable part of the context. */ 512/* Initializes the variable part of the context. */
493static void 513static void
diff --git a/src/lib/libcrypto/ts/ts_rsp_utils.c b/src/lib/libcrypto/ts/ts_rsp_utils.c
index 2e37f26fda..4449c4a94c 100644
--- a/src/lib/libcrypto/ts/ts_rsp_utils.c
+++ b/src/lib/libcrypto/ts/ts_rsp_utils.c
@@ -1,4 +1,4 @@
1/* $OpenBSD: ts_rsp_utils.c,v 1.9 2022/07/24 19:25:36 tb Exp $ */ 1/* $OpenBSD: ts_rsp_utils.c,v 1.10 2023/07/07 07:25:21 beck Exp $ */
2/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL 2/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL
3 * project 2002. 3 * project 2002.
4 */ 4 */
@@ -84,36 +84,42 @@ TS_RESP_set_status_info(TS_RESP *a, TS_STATUS_INFO *status_info)
84 84
85 return 1; 85 return 1;
86} 86}
87LCRYPTO_ALIAS(TS_RESP_set_status_info);
87 88
88TS_STATUS_INFO * 89TS_STATUS_INFO *
89TS_RESP_get_status_info(TS_RESP *a) 90TS_RESP_get_status_info(TS_RESP *a)
90{ 91{
91 return a->status_info; 92 return a->status_info;
92} 93}
94LCRYPTO_ALIAS(TS_RESP_get_status_info);
93 95
94const ASN1_UTF8STRING * 96const ASN1_UTF8STRING *
95TS_STATUS_INFO_get0_failure_info(const TS_STATUS_INFO *si) 97TS_STATUS_INFO_get0_failure_info(const TS_STATUS_INFO *si)
96{ 98{
97 return si->failure_info; 99 return si->failure_info;
98} 100}
101LCRYPTO_ALIAS(TS_STATUS_INFO_get0_failure_info);
99 102
100const STACK_OF(ASN1_UTF8STRING) * 103const STACK_OF(ASN1_UTF8STRING) *
101TS_STATUS_INFO_get0_text(const TS_STATUS_INFO *si) 104TS_STATUS_INFO_get0_text(const TS_STATUS_INFO *si)
102{ 105{
103 return si->text; 106 return si->text;
104} 107}
108LCRYPTO_ALIAS(TS_STATUS_INFO_get0_text);
105 109
106const ASN1_INTEGER * 110const ASN1_INTEGER *
107TS_STATUS_INFO_get0_status(const TS_STATUS_INFO *si) 111TS_STATUS_INFO_get0_status(const TS_STATUS_INFO *si)
108{ 112{
109 return si->status; 113 return si->status;
110} 114}
115LCRYPTO_ALIAS(TS_STATUS_INFO_get0_status);
111 116
112int 117int
113TS_STATUS_INFO_set_status(TS_STATUS_INFO *si, int i) 118TS_STATUS_INFO_set_status(TS_STATUS_INFO *si, int i)
114{ 119{
115 return ASN1_INTEGER_set(si->status, i); 120 return ASN1_INTEGER_set(si->status, i);
116} 121}
122LCRYPTO_ALIAS(TS_STATUS_INFO_set_status);
117 123
118/* Caller loses ownership of PKCS7 and TS_TST_INFO objects. */ 124/* Caller loses ownership of PKCS7 and TS_TST_INFO objects. */
119void 125void
@@ -125,30 +131,35 @@ TS_RESP_set_tst_info(TS_RESP *a, PKCS7 *p7, TS_TST_INFO *tst_info)
125 TS_TST_INFO_free(a->tst_info); 131 TS_TST_INFO_free(a->tst_info);
126 a->tst_info = tst_info; 132 a->tst_info = tst_info;
127} 133}
134LCRYPTO_ALIAS(TS_RESP_set_tst_info);
128 135
129PKCS7 * 136PKCS7 *
130TS_RESP_get_token(TS_RESP *a) 137TS_RESP_get_token(TS_RESP *a)
131{ 138{
132 return a->token; 139 return a->token;
133} 140}
141LCRYPTO_ALIAS(TS_RESP_get_token);
134 142
135TS_TST_INFO * 143TS_TST_INFO *
136TS_RESP_get_tst_info(TS_RESP *a) 144TS_RESP_get_tst_info(TS_RESP *a)
137{ 145{
138 return a->tst_info; 146 return a->tst_info;
139} 147}
148LCRYPTO_ALIAS(TS_RESP_get_tst_info);
140 149
141int 150int
142TS_TST_INFO_set_version(TS_TST_INFO *a, long version) 151TS_TST_INFO_set_version(TS_TST_INFO *a, long version)
143{ 152{
144 return ASN1_INTEGER_set(a->version, version); 153 return ASN1_INTEGER_set(a->version, version);
145} 154}
155LCRYPTO_ALIAS(TS_TST_INFO_set_version);
146 156
147long 157long
148TS_TST_INFO_get_version(const TS_TST_INFO *a) 158TS_TST_INFO_get_version(const TS_TST_INFO *a)
149{ 159{
150 return ASN1_INTEGER_get(a->version); 160 return ASN1_INTEGER_get(a->version);
151} 161}
162LCRYPTO_ALIAS(TS_TST_INFO_get_version);
152 163
153int 164int
154TS_TST_INFO_set_policy_id(TS_TST_INFO *a, ASN1_OBJECT *policy) 165TS_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)
166 a->policy_id = new_policy; 177 a->policy_id = new_policy;
167 return 1; 178 return 1;
168} 179}
180LCRYPTO_ALIAS(TS_TST_INFO_set_policy_id);
169 181
170ASN1_OBJECT * 182ASN1_OBJECT *
171TS_TST_INFO_get_policy_id(TS_TST_INFO *a) 183TS_TST_INFO_get_policy_id(TS_TST_INFO *a)
172{ 184{
173 return a->policy_id; 185 return a->policy_id;
174} 186}
187LCRYPTO_ALIAS(TS_TST_INFO_get_policy_id);
175 188
176int 189int
177TS_TST_INFO_set_msg_imprint(TS_TST_INFO *a, TS_MSG_IMPRINT *msg_imprint) 190TS_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)
189 a->msg_imprint = new_msg_imprint; 202 a->msg_imprint = new_msg_imprint;
190 return 1; 203 return 1;
191} 204}
205LCRYPTO_ALIAS(TS_TST_INFO_set_msg_imprint);
192 206
193TS_MSG_IMPRINT * 207TS_MSG_IMPRINT *
194TS_TST_INFO_get_msg_imprint(TS_TST_INFO *a) 208TS_TST_INFO_get_msg_imprint(TS_TST_INFO *a)
195{ 209{
196 return a->msg_imprint; 210 return a->msg_imprint;
197} 211}
212LCRYPTO_ALIAS(TS_TST_INFO_get_msg_imprint);
198 213
199int 214int
200TS_TST_INFO_set_serial(TS_TST_INFO *a, const ASN1_INTEGER *serial) 215TS_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)
212 a->serial = new_serial; 227 a->serial = new_serial;
213 return 1; 228 return 1;
214} 229}
230LCRYPTO_ALIAS(TS_TST_INFO_set_serial);
215 231
216const ASN1_INTEGER * 232const ASN1_INTEGER *
217TS_TST_INFO_get_serial(const TS_TST_INFO *a) 233TS_TST_INFO_get_serial(const TS_TST_INFO *a)
218{ 234{
219 return a->serial; 235 return a->serial;
220} 236}
237LCRYPTO_ALIAS(TS_TST_INFO_get_serial);
221 238
222int 239int
223TS_TST_INFO_set_time(TS_TST_INFO *a, const ASN1_GENERALIZEDTIME *gtime) 240TS_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)
235 a->time = new_time; 252 a->time = new_time;
236 return 1; 253 return 1;
237} 254}
255LCRYPTO_ALIAS(TS_TST_INFO_set_time);
238 256
239const ASN1_GENERALIZEDTIME * 257const ASN1_GENERALIZEDTIME *
240TS_TST_INFO_get_time(const TS_TST_INFO *a) 258TS_TST_INFO_get_time(const TS_TST_INFO *a)
241{ 259{
242 return a->time; 260 return a->time;
243} 261}
262LCRYPTO_ALIAS(TS_TST_INFO_get_time);
244 263
245int 264int
246TS_TST_INFO_set_accuracy(TS_TST_INFO *a, TS_ACCURACY *accuracy) 265TS_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)
258 a->accuracy = new_accuracy; 277 a->accuracy = new_accuracy;
259 return 1; 278 return 1;
260} 279}
280LCRYPTO_ALIAS(TS_TST_INFO_set_accuracy);
261 281
262TS_ACCURACY * 282TS_ACCURACY *
263TS_TST_INFO_get_accuracy(TS_TST_INFO *a) 283TS_TST_INFO_get_accuracy(TS_TST_INFO *a)
264{ 284{
265 return a->accuracy; 285 return a->accuracy;
266} 286}
287LCRYPTO_ALIAS(TS_TST_INFO_get_accuracy);
267 288
268int 289int
269TS_ACCURACY_set_seconds(TS_ACCURACY *a, const ASN1_INTEGER *seconds) 290TS_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)
281 a->seconds = new_seconds; 302 a->seconds = new_seconds;
282 return 1; 303 return 1;
283} 304}
305LCRYPTO_ALIAS(TS_ACCURACY_set_seconds);
284 306
285const ASN1_INTEGER * 307const ASN1_INTEGER *
286TS_ACCURACY_get_seconds(const TS_ACCURACY *a) 308TS_ACCURACY_get_seconds(const TS_ACCURACY *a)
287{ 309{
288 return a->seconds; 310 return a->seconds;
289} 311}
312LCRYPTO_ALIAS(TS_ACCURACY_get_seconds);
290 313
291int 314int
292TS_ACCURACY_set_millis(TS_ACCURACY *a, const ASN1_INTEGER *millis) 315TS_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)
306 a->millis = new_millis; 329 a->millis = new_millis;
307 return 1; 330 return 1;
308} 331}
332LCRYPTO_ALIAS(TS_ACCURACY_set_millis);
309 333
310const ASN1_INTEGER * 334const ASN1_INTEGER *
311TS_ACCURACY_get_millis(const TS_ACCURACY *a) 335TS_ACCURACY_get_millis(const TS_ACCURACY *a)
312{ 336{
313 return a->millis; 337 return a->millis;
314} 338}
339LCRYPTO_ALIAS(TS_ACCURACY_get_millis);
315 340
316int 341int
317TS_ACCURACY_set_micros(TS_ACCURACY *a, const ASN1_INTEGER *micros) 342TS_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)
331 a->micros = new_micros; 356 a->micros = new_micros;
332 return 1; 357 return 1;
333} 358}
359LCRYPTO_ALIAS(TS_ACCURACY_set_micros);
334 360
335const ASN1_INTEGER * 361const ASN1_INTEGER *
336TS_ACCURACY_get_micros(const TS_ACCURACY *a) 362TS_ACCURACY_get_micros(const TS_ACCURACY *a)
337{ 363{
338 return a->micros; 364 return a->micros;
339} 365}
366LCRYPTO_ALIAS(TS_ACCURACY_get_micros);
340 367
341int 368int
342TS_TST_INFO_set_ordering(TS_TST_INFO *a, int ordering) 369TS_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)
344 a->ordering = ordering ? 0xFF : 0x00; 371 a->ordering = ordering ? 0xFF : 0x00;
345 return 1; 372 return 1;
346} 373}
374LCRYPTO_ALIAS(TS_TST_INFO_set_ordering);
347 375
348int 376int
349TS_TST_INFO_get_ordering(const TS_TST_INFO *a) 377TS_TST_INFO_get_ordering(const TS_TST_INFO *a)
350{ 378{
351 return a->ordering ? 1 : 0; 379 return a->ordering ? 1 : 0;
352} 380}
381LCRYPTO_ALIAS(TS_TST_INFO_get_ordering);
353 382
354int 383int
355TS_TST_INFO_set_nonce(TS_TST_INFO *a, const ASN1_INTEGER *nonce) 384TS_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)
367 a->nonce = new_nonce; 396 a->nonce = new_nonce;
368 return 1; 397 return 1;
369} 398}
399LCRYPTO_ALIAS(TS_TST_INFO_set_nonce);
370 400
371const ASN1_INTEGER * 401const ASN1_INTEGER *
372TS_TST_INFO_get_nonce(const TS_TST_INFO *a) 402TS_TST_INFO_get_nonce(const TS_TST_INFO *a)
373{ 403{
374 return a->nonce; 404 return a->nonce;
375} 405}
406LCRYPTO_ALIAS(TS_TST_INFO_get_nonce);
376 407
377int 408int
378TS_TST_INFO_set_tsa(TS_TST_INFO *a, GENERAL_NAME *tsa) 409TS_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)
390 a->tsa = new_tsa; 421 a->tsa = new_tsa;
391 return 1; 422 return 1;
392} 423}
424LCRYPTO_ALIAS(TS_TST_INFO_set_tsa);
393 425
394GENERAL_NAME * 426GENERAL_NAME *
395TS_TST_INFO_get_tsa(TS_TST_INFO *a) 427TS_TST_INFO_get_tsa(TS_TST_INFO *a)
396{ 428{
397 return a->tsa; 429 return a->tsa;
398} 430}
431LCRYPTO_ALIAS(TS_TST_INFO_get_tsa);
399 432
400STACK_OF(X509_EXTENSION) *TS_TST_INFO_get_exts(TS_TST_INFO *a) 433STACK_OF(X509_EXTENSION) *TS_TST_INFO_get_exts(TS_TST_INFO *a)
401{ 434{
@@ -410,51 +443,60 @@ TS_TST_INFO_ext_free(TS_TST_INFO *a)
410 sk_X509_EXTENSION_pop_free(a->extensions, X509_EXTENSION_free); 443 sk_X509_EXTENSION_pop_free(a->extensions, X509_EXTENSION_free);
411 a->extensions = NULL; 444 a->extensions = NULL;
412} 445}
446LCRYPTO_ALIAS(TS_TST_INFO_ext_free);
413 447
414int 448int
415TS_TST_INFO_get_ext_count(TS_TST_INFO *a) 449TS_TST_INFO_get_ext_count(TS_TST_INFO *a)
416{ 450{
417 return X509v3_get_ext_count(a->extensions); 451 return X509v3_get_ext_count(a->extensions);
418} 452}
453LCRYPTO_ALIAS(TS_TST_INFO_get_ext_count);
419 454
420int 455int
421TS_TST_INFO_get_ext_by_NID(TS_TST_INFO *a, int nid, int lastpos) 456TS_TST_INFO_get_ext_by_NID(TS_TST_INFO *a, int nid, int lastpos)
422{ 457{
423 return X509v3_get_ext_by_NID(a->extensions, nid, lastpos); 458 return X509v3_get_ext_by_NID(a->extensions, nid, lastpos);
424} 459}
460LCRYPTO_ALIAS(TS_TST_INFO_get_ext_by_NID);
425 461
426int 462int
427TS_TST_INFO_get_ext_by_OBJ(TS_TST_INFO *a, const ASN1_OBJECT *obj, int lastpos) 463TS_TST_INFO_get_ext_by_OBJ(TS_TST_INFO *a, const ASN1_OBJECT *obj, int lastpos)
428{ 464{
429 return X509v3_get_ext_by_OBJ(a->extensions, obj, lastpos); 465 return X509v3_get_ext_by_OBJ(a->extensions, obj, lastpos);
430} 466}
467LCRYPTO_ALIAS(TS_TST_INFO_get_ext_by_OBJ);
431 468
432int 469int
433TS_TST_INFO_get_ext_by_critical(TS_TST_INFO *a, int crit, int lastpos) 470TS_TST_INFO_get_ext_by_critical(TS_TST_INFO *a, int crit, int lastpos)
434{ 471{
435 return X509v3_get_ext_by_critical(a->extensions, crit, lastpos); 472 return X509v3_get_ext_by_critical(a->extensions, crit, lastpos);
436} 473}
474LCRYPTO_ALIAS(TS_TST_INFO_get_ext_by_critical);
437 475
438X509_EXTENSION * 476X509_EXTENSION *
439TS_TST_INFO_get_ext(TS_TST_INFO *a, int loc) 477TS_TST_INFO_get_ext(TS_TST_INFO *a, int loc)
440{ 478{
441 return X509v3_get_ext(a->extensions, loc); 479 return X509v3_get_ext(a->extensions, loc);
442} 480}
481LCRYPTO_ALIAS(TS_TST_INFO_get_ext);
443 482
444X509_EXTENSION * 483X509_EXTENSION *
445TS_TST_INFO_delete_ext(TS_TST_INFO *a, int loc) 484TS_TST_INFO_delete_ext(TS_TST_INFO *a, int loc)
446{ 485{
447 return X509v3_delete_ext(a->extensions, loc); 486 return X509v3_delete_ext(a->extensions, loc);
448} 487}
488LCRYPTO_ALIAS(TS_TST_INFO_delete_ext);
449 489
450int 490int
451TS_TST_INFO_add_ext(TS_TST_INFO *a, X509_EXTENSION *ex, int loc) 491TS_TST_INFO_add_ext(TS_TST_INFO *a, X509_EXTENSION *ex, int loc)
452{ 492{
453 return X509v3_add_ext(&a->extensions, ex, loc) != NULL; 493 return X509v3_add_ext(&a->extensions, ex, loc) != NULL;
454} 494}
495LCRYPTO_ALIAS(TS_TST_INFO_add_ext);
455 496
456void * 497void *
457TS_TST_INFO_get_ext_d2i(TS_TST_INFO *a, int nid, int *crit, int *idx) 498TS_TST_INFO_get_ext_d2i(TS_TST_INFO *a, int nid, int *crit, int *idx)
458{ 499{
459 return X509V3_get_d2i(a->extensions, nid, crit, idx); 500 return X509V3_get_d2i(a->extensions, nid, crit, idx);
460} 501}
502LCRYPTO_ALIAS(TS_TST_INFO_get_ext_d2i);
diff --git a/src/lib/libcrypto/ts/ts_rsp_verify.c b/src/lib/libcrypto/ts/ts_rsp_verify.c
index dc467d8604..69236f68ab 100644
--- a/src/lib/libcrypto/ts/ts_rsp_verify.c
+++ b/src/lib/libcrypto/ts/ts_rsp_verify.c
@@ -1,4 +1,4 @@
1/* $OpenBSD: ts_rsp_verify.c,v 1.29 2022/11/26 16:08:54 tb Exp $ */ 1/* $OpenBSD: ts_rsp_verify.c,v 1.30 2023/07/07 07:25:21 beck Exp $ */
2/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL 2/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL
3 * project 2002. 3 * project 2002.
4 */ 4 */
@@ -230,6 +230,7 @@ err:
230 230
231 return ret; 231 return ret;
232} 232}
233LCRYPTO_ALIAS(TS_RESP_verify_signature);
233 234
234/* 235/*
235 * The certificate chain is returned in chain. Caller is responsible for 236 * 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)
485err: 486err:
486 return ret; 487 return ret;
487} 488}
489LCRYPTO_ALIAS(TS_RESP_verify_response);
488 490
489/* 491/*
490 * Tries to extract a TS_TST_INFO structure from the PKCS7 token and 492 * 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)
502 } 504 }
503 return ret; 505 return ret;
504} 506}
507LCRYPTO_ALIAS(TS_RESP_verify_token);
505 508
506/* 509/*
507 * Verifies whether the 'token' contains a valid time stamp token 510 * Verifies whether the 'token' contains a valid time stamp token
diff --git a/src/lib/libcrypto/ts/ts_verify_ctx.c b/src/lib/libcrypto/ts/ts_verify_ctx.c
index a7b90f9e4c..5a2d95c680 100644
--- a/src/lib/libcrypto/ts/ts_verify_ctx.c
+++ b/src/lib/libcrypto/ts/ts_verify_ctx.c
@@ -1,4 +1,4 @@
1/* $OpenBSD: ts_verify_ctx.c,v 1.13 2023/04/25 17:52:54 tb Exp $ */ 1/* $OpenBSD: ts_verify_ctx.c,v 1.14 2023/07/07 07:25:21 beck Exp $ */
2/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL 2/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL
3 * project 2003. 3 * project 2003.
4 */ 4 */
@@ -74,6 +74,7 @@ TS_VERIFY_CTX_new(void)
74 74
75 return ctx; 75 return ctx;
76} 76}
77LCRYPTO_ALIAS(TS_VERIFY_CTX_new);
77 78
78void 79void
79TS_VERIFY_CTX_free(TS_VERIFY_CTX *ctx) 80TS_VERIFY_CTX_free(TS_VERIFY_CTX *ctx)
@@ -84,6 +85,7 @@ TS_VERIFY_CTX_free(TS_VERIFY_CTX *ctx)
84 TS_VERIFY_CTX_cleanup(ctx); 85 TS_VERIFY_CTX_cleanup(ctx);
85 free(ctx); 86 free(ctx);
86} 87}
88LCRYPTO_ALIAS(TS_VERIFY_CTX_free);
87 89
88void 90void
89TS_VERIFY_CTX_cleanup(TS_VERIFY_CTX *ctx) 91TS_VERIFY_CTX_cleanup(TS_VERIFY_CTX *ctx)
@@ -107,6 +109,7 @@ TS_VERIFY_CTX_cleanup(TS_VERIFY_CTX *ctx)
107 109
108 memset(ctx, 0, sizeof(*ctx)); 110 memset(ctx, 0, sizeof(*ctx));
109} 111}
112LCRYPTO_ALIAS(TS_VERIFY_CTX_cleanup);
110 113
111/* 114/*
112 * XXX: The following accessors demonstrate the amount of care and thought that 115 * 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)
127 130
128 return ctx->flags; 131 return ctx->flags;
129} 132}
133LCRYPTO_ALIAS(TS_VERIFY_CTX_add_flags);
130 134
131int 135int
132TS_VERIFY_CTX_set_flags(TS_VERIFY_CTX *ctx, int flags) 136TS_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)
135 139
136 return ctx->flags; 140 return ctx->flags;
137} 141}
142LCRYPTO_ALIAS(TS_VERIFY_CTX_set_flags);
138 143
139BIO * 144BIO *
140TS_VERIFY_CTX_set_data(TS_VERIFY_CTX *ctx, BIO *bio) 145TS_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)
143 148
144 return ctx->data; 149 return ctx->data;
145} 150}
151LCRYPTO_ALIAS(TS_VERIFY_CTX_set_data);
146 152
147X509_STORE * 153X509_STORE *
148TS_VERIFY_CTX_set_store(TS_VERIFY_CTX *ctx, X509_STORE *store) 154TS_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)
151 157
152 return ctx->store; 158 return ctx->store;
153} 159}
160LCRYPTO_ALIAS(TS_VERIFY_CTX_set_store);
154 161
155STACK_OF(X509) * 162STACK_OF(X509) *
156TS_VERIFY_CTX_set_certs(TS_VERIFY_CTX *ctx, STACK_OF(X509) *certs) 163TS_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)
159 166
160 return ctx->certs; 167 return ctx->certs;
161} 168}
169LCRYPTO_ALIAS(TS_VERIFY_CTX_set_certs);
162 170
163unsigned char * 171unsigned char *
164TS_VERIFY_CTX_set_imprint(TS_VERIFY_CTX *ctx, unsigned char *imprint, 172TS_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,
171 179
172 return ctx->imprint; 180 return ctx->imprint;
173} 181}
182LCRYPTO_ALIAS(TS_VERIFY_CTX_set_imprint);
174 183
175TS_VERIFY_CTX * 184TS_VERIFY_CTX *
176TS_REQ_to_TS_VERIFY_CTX(TS_REQ *req, TS_VERIFY_CTX *ctx) 185TS_REQ_to_TS_VERIFY_CTX(TS_REQ *req, TS_VERIFY_CTX *ctx)
@@ -224,3 +233,4 @@ err:
224 TS_VERIFY_CTX_free(ret); 233 TS_VERIFY_CTX_free(ret);
225 return NULL; 234 return NULL;
226} 235}
236LCRYPTO_ALIAS(TS_REQ_to_TS_VERIFY_CTX);
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-11-13 23:35:07 +0000