crypto/ts/ts_rsp_utils.c

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