1 /* $OpenBSD: ts_rsp_utils.c,v 1.9 2022/07/24 19:25:36 tb Exp $ */ 2 /* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL 3 * project 2002. 4 */ 5 /* ==================================================================== 6 * Copyright (c) 2006 The OpenSSL Project. All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in 17 * the documentation and/or other materials provided with the 18 * distribution. 19 * 20 * 3. All advertising materials mentioning features or use of this 21 * software must display the following acknowledgment: 22 * "This product includes software developed by the OpenSSL Project 23 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" 24 * 25 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to 26 * endorse or promote products derived from this software without 27 * prior written permission. For written permission, please contact 28 * licensing@OpenSSL.org. 29 * 30 * 5. Products derived from this software may not be called "OpenSSL" 31 * nor may "OpenSSL" appear in their names without prior written 32 * permission of the OpenSSL Project. 33 * 34 * 6. Redistributions of any form whatsoever must retain the following 35 * acknowledgment: 36 * "This product includes software developed by the OpenSSL Project 37 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" 38 * 39 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY 40 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 41 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 42 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR 43 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 44 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 45 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 46 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 48 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 49 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 50 * OF THE POSSIBILITY OF SUCH DAMAGE. 51 * ==================================================================== 52 * 53 * This product includes cryptographic software written by Eric Young 54 * (eay@cryptsoft.com). This product includes software written by Tim 55 * Hudson (tjh@cryptsoft.com). 56 * 57 */ 58 59 #include <stdio.h> 60 61 #include <openssl/err.h> 62 #include <openssl/objects.h> 63 #include <openssl/pkcs7.h> 64 #include <openssl/ts.h> 65 66 #include "ts_local.h" 67 68 /* Function definitions. */ 69 70 int 71 TS_RESP_set_status_info(TS_RESP *a, TS_STATUS_INFO *status_info) 72 { 73 TS_STATUS_INFO *new_status_info; 74 75 if (a->status_info == status_info) 76 return 1; 77 new_status_info = TS_STATUS_INFO_dup(status_info); 78 if (new_status_info == NULL) { 79 TSerror(ERR_R_MALLOC_FAILURE); 80 return 0; 81 } 82 TS_STATUS_INFO_free(a->status_info); 83 a->status_info = new_status_info; 84 85 return 1; 86 } 87 88 TS_STATUS_INFO * 89 TS_RESP_get_status_info(TS_RESP *a) 90 { 91 return a->status_info; 92 } 93 94 const ASN1_UTF8STRING * 95 TS_STATUS_INFO_get0_failure_info(const TS_STATUS_INFO *si) 96 { 97 return si->failure_info; 98 } 99 100 const STACK_OF(ASN1_UTF8STRING) * 101 TS_STATUS_INFO_get0_text(const TS_STATUS_INFO *si) 102 { 103 return si->text; 104 } 105 106 const ASN1_INTEGER * 107 TS_STATUS_INFO_get0_status(const TS_STATUS_INFO *si) 108 { 109 return si->status; 110 } 111 112 int 113 TS_STATUS_INFO_set_status(TS_STATUS_INFO *si, int i) 114 { 115 return ASN1_INTEGER_set(si->status, i); 116 } 117 118 /* Caller loses ownership of PKCS7 and TS_TST_INFO objects. */ 119 void 120 TS_RESP_set_tst_info(TS_RESP *a, PKCS7 *p7, TS_TST_INFO *tst_info) 121 { 122 /* Set new PKCS7 and TST_INFO objects. */ 123 PKCS7_free(a->token); 124 a->token = p7; 125 TS_TST_INFO_free(a->tst_info); 126 a->tst_info = tst_info; 127 } 128 129 PKCS7 * 130 TS_RESP_get_token(TS_RESP *a) 131 { 132 return a->token; 133 } 134 135 TS_TST_INFO * 136 TS_RESP_get_tst_info(TS_RESP *a) 137 { 138 return a->tst_info; 139 } 140 141 int 142 TS_TST_INFO_set_version(TS_TST_INFO *a, long version) 143 { 144 return ASN1_INTEGER_set(a->version, version); 145 } 146 147 long 148 TS_TST_INFO_get_version(const TS_TST_INFO *a) 149 { 150 return ASN1_INTEGER_get(a->version); 151 } 152 153 int 154 TS_TST_INFO_set_policy_id(TS_TST_INFO *a, ASN1_OBJECT *policy) 155 { 156 ASN1_OBJECT *new_policy; 157 158 if (a->policy_id == policy) 159 return 1; 160 new_policy = OBJ_dup(policy); 161 if (new_policy == NULL) { 162 TSerror(ERR_R_MALLOC_FAILURE); 163 return 0; 164 } 165 ASN1_OBJECT_free(a->policy_id); 166 a->policy_id = new_policy; 167 return 1; 168 } 169 170 ASN1_OBJECT * 171 TS_TST_INFO_get_policy_id(TS_TST_INFO *a) 172 { 173 return a->policy_id; 174 } 175 176 int 177 TS_TST_INFO_set_msg_imprint(TS_TST_INFO *a, TS_MSG_IMPRINT *msg_imprint) 178 { 179 TS_MSG_IMPRINT *new_msg_imprint; 180 181 if (a->msg_imprint == msg_imprint) 182 return 1; 183 new_msg_imprint = TS_MSG_IMPRINT_dup(msg_imprint); 184 if (new_msg_imprint == NULL) { 185 TSerror(ERR_R_MALLOC_FAILURE); 186 return 0; 187 } 188 TS_MSG_IMPRINT_free(a->msg_imprint); 189 a->msg_imprint = new_msg_imprint; 190 return 1; 191 } 192 193 TS_MSG_IMPRINT * 194 TS_TST_INFO_get_msg_imprint(TS_TST_INFO *a) 195 { 196 return a->msg_imprint; 197 } 198 199 int 200 TS_TST_INFO_set_serial(TS_TST_INFO *a, const ASN1_INTEGER *serial) 201 { 202 ASN1_INTEGER *new_serial; 203 204 if (a->serial == serial) 205 return 1; 206 new_serial = ASN1_INTEGER_dup(serial); 207 if (new_serial == NULL) { 208 TSerror(ERR_R_MALLOC_FAILURE); 209 return 0; 210 } 211 ASN1_INTEGER_free(a->serial); 212 a->serial = new_serial; 213 return 1; 214 } 215 216 const ASN1_INTEGER * 217 TS_TST_INFO_get_serial(const TS_TST_INFO *a) 218 { 219 return a->serial; 220 } 221 222 int 223 TS_TST_INFO_set_time(TS_TST_INFO *a, const ASN1_GENERALIZEDTIME *gtime) 224 { 225 ASN1_GENERALIZEDTIME *new_time; 226 227 if (a->time == gtime) 228 return 1; 229 new_time = ASN1_STRING_dup(gtime); 230 if (new_time == NULL) { 231 TSerror(ERR_R_MALLOC_FAILURE); 232 return 0; 233 } 234 ASN1_GENERALIZEDTIME_free(a->time); 235 a->time = new_time; 236 return 1; 237 } 238 239 const ASN1_GENERALIZEDTIME * 240 TS_TST_INFO_get_time(const TS_TST_INFO *a) 241 { 242 return a->time; 243 } 244 245 int 246 TS_TST_INFO_set_accuracy(TS_TST_INFO *a, TS_ACCURACY *accuracy) 247 { 248 TS_ACCURACY *new_accuracy; 249 250 if (a->accuracy == accuracy) 251 return 1; 252 new_accuracy = TS_ACCURACY_dup(accuracy); 253 if (new_accuracy == NULL) { 254 TSerror(ERR_R_MALLOC_FAILURE); 255 return 0; 256 } 257 TS_ACCURACY_free(a->accuracy); 258 a->accuracy = new_accuracy; 259 return 1; 260 } 261 262 TS_ACCURACY * 263 TS_TST_INFO_get_accuracy(TS_TST_INFO *a) 264 { 265 return a->accuracy; 266 } 267 268 int 269 TS_ACCURACY_set_seconds(TS_ACCURACY *a, const ASN1_INTEGER *seconds) 270 { 271 ASN1_INTEGER *new_seconds; 272 273 if (a->seconds == seconds) 274 return 1; 275 new_seconds = ASN1_INTEGER_dup(seconds); 276 if (new_seconds == NULL) { 277 TSerror(ERR_R_MALLOC_FAILURE); 278 return 0; 279 } 280 ASN1_INTEGER_free(a->seconds); 281 a->seconds = new_seconds; 282 return 1; 283 } 284 285 const ASN1_INTEGER * 286 TS_ACCURACY_get_seconds(const TS_ACCURACY *a) 287 { 288 return a->seconds; 289 } 290 291 int 292 TS_ACCURACY_set_millis(TS_ACCURACY *a, const ASN1_INTEGER *millis) 293 { 294 ASN1_INTEGER *new_millis = NULL; 295 296 if (a->millis == millis) 297 return 1; 298 if (millis != NULL) { 299 new_millis = ASN1_INTEGER_dup(millis); 300 if (new_millis == NULL) { 301 TSerror(ERR_R_MALLOC_FAILURE); 302 return 0; 303 } 304 } 305 ASN1_INTEGER_free(a->millis); 306 a->millis = new_millis; 307 return 1; 308 } 309 310 const ASN1_INTEGER * 311 TS_ACCURACY_get_millis(const TS_ACCURACY *a) 312 { 313 return a->millis; 314 } 315 316 int 317 TS_ACCURACY_set_micros(TS_ACCURACY *a, const ASN1_INTEGER *micros) 318 { 319 ASN1_INTEGER *new_micros = NULL; 320 321 if (a->micros == micros) 322 return 1; 323 if (micros != NULL) { 324 new_micros = ASN1_INTEGER_dup(micros); 325 if (new_micros == NULL) { 326 TSerror(ERR_R_MALLOC_FAILURE); 327 return 0; 328 } 329 } 330 ASN1_INTEGER_free(a->micros); 331 a->micros = new_micros; 332 return 1; 333 } 334 335 const ASN1_INTEGER * 336 TS_ACCURACY_get_micros(const TS_ACCURACY *a) 337 { 338 return a->micros; 339 } 340 341 int 342 TS_TST_INFO_set_ordering(TS_TST_INFO *a, int ordering) 343 { 344 a->ordering = ordering ? 0xFF : 0x00; 345 return 1; 346 } 347 348 int 349 TS_TST_INFO_get_ordering(const TS_TST_INFO *a) 350 { 351 return a->ordering ? 1 : 0; 352 } 353 354 int 355 TS_TST_INFO_set_nonce(TS_TST_INFO *a, const ASN1_INTEGER *nonce) 356 { 357 ASN1_INTEGER *new_nonce; 358 359 if (a->nonce == nonce) 360 return 1; 361 new_nonce = ASN1_INTEGER_dup(nonce); 362 if (new_nonce == NULL) { 363 TSerror(ERR_R_MALLOC_FAILURE); 364 return 0; 365 } 366 ASN1_INTEGER_free(a->nonce); 367 a->nonce = new_nonce; 368 return 1; 369 } 370 371 const ASN1_INTEGER * 372 TS_TST_INFO_get_nonce(const TS_TST_INFO *a) 373 { 374 return a->nonce; 375 } 376 377 int 378 TS_TST_INFO_set_tsa(TS_TST_INFO *a, GENERAL_NAME *tsa) 379 { 380 GENERAL_NAME *new_tsa; 381 382 if (a->tsa == tsa) 383 return 1; 384 new_tsa = GENERAL_NAME_dup(tsa); 385 if (new_tsa == NULL) { 386 TSerror(ERR_R_MALLOC_FAILURE); 387 return 0; 388 } 389 GENERAL_NAME_free(a->tsa); 390 a->tsa = new_tsa; 391 return 1; 392 } 393 394 GENERAL_NAME * 395 TS_TST_INFO_get_tsa(TS_TST_INFO *a) 396 { 397 return a->tsa; 398 } 399 400 STACK_OF(X509_EXTENSION) *TS_TST_INFO_get_exts(TS_TST_INFO *a) 401 { 402 return a->extensions; 403 } 404 405 void 406 TS_TST_INFO_ext_free(TS_TST_INFO *a) 407 { 408 if (!a) 409 return; 410 sk_X509_EXTENSION_pop_free(a->extensions, X509_EXTENSION_free); 411 a->extensions = NULL; 412 } 413 414 int 415 TS_TST_INFO_get_ext_count(TS_TST_INFO *a) 416 { 417 return X509v3_get_ext_count(a->extensions); 418 } 419 420 int 421 TS_TST_INFO_get_ext_by_NID(TS_TST_INFO *a, int nid, int lastpos) 422 { 423 return X509v3_get_ext_by_NID(a->extensions, nid, lastpos); 424 } 425 426 int 427 TS_TST_INFO_get_ext_by_OBJ(TS_TST_INFO *a, const ASN1_OBJECT *obj, int lastpos) 428 { 429 return X509v3_get_ext_by_OBJ(a->extensions, obj, lastpos); 430 } 431 432 int 433 TS_TST_INFO_get_ext_by_critical(TS_TST_INFO *a, int crit, int lastpos) 434 { 435 return X509v3_get_ext_by_critical(a->extensions, crit, lastpos); 436 } 437 438 X509_EXTENSION * 439 TS_TST_INFO_get_ext(TS_TST_INFO *a, int loc) 440 { 441 return X509v3_get_ext(a->extensions, loc); 442 } 443 444 X509_EXTENSION * 445 TS_TST_INFO_delete_ext(TS_TST_INFO *a, int loc) 446 { 447 return X509v3_delete_ext(a->extensions, loc); 448 } 449 450 int 451 TS_TST_INFO_add_ext(TS_TST_INFO *a, X509_EXTENSION *ex, int loc) 452 { 453 return X509v3_add_ext(&a->extensions, ex, loc) != NULL; 454 } 455 456 void * 457 TS_TST_INFO_get_ext_d2i(TS_TST_INFO *a, int nid, int *crit, int *idx) 458 { 459 return X509V3_get_d2i(a->extensions, nid, crit, idx); 460 } 461