crypto/ts/ts_req_utils.c

   1 /* crypto/ts/ts_req_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/x509v3.h>
  64 #include <openssl/ts.h>
  65 #include "ts_lcl.h"
  66
  67 int TS_REQ_set_version(TS_REQ *a, long version)
  68 {
  69     return ASN1_INTEGER_set(a->version, version);
  70 }
  71
  72 long TS_REQ_get_version(const TS_REQ *a)
  73 {
  74     return ASN1_INTEGER_get(a->version);
  75 }
  76
  77 int TS_REQ_set_msg_imprint(TS_REQ *a, TS_MSG_IMPRINT *msg_imprint)
  78 {
  79     TS_MSG_IMPRINT *new_msg_imprint;
  80
  81     if (a->msg_imprint == msg_imprint)
  82         return 1;
  83     new_msg_imprint = TS_MSG_IMPRINT_dup(msg_imprint);
  84     if (new_msg_imprint == NULL) {
  85         TSerr(TS_F_TS_REQ_SET_MSG_IMPRINT, ERR_R_MALLOC_FAILURE);
  86         return 0;
  87     }
  88     TS_MSG_IMPRINT_free(a->msg_imprint);
  89     a->msg_imprint = new_msg_imprint;
  90     return 1;
  91 }
  92
  93 TS_MSG_IMPRINT *TS_REQ_get_msg_imprint(TS_REQ *a)
  94 {
  95     return a->msg_imprint;
  96 }
  97
  98 int TS_MSG_IMPRINT_set_algo(TS_MSG_IMPRINT *a, X509_ALGOR *alg)
  99 {
 100     X509_ALGOR *new_alg;
 101
 102     if (a->hash_algo == alg)
 103         return 1;
 104     new_alg = X509_ALGOR_dup(alg);
 105     if (new_alg == NULL) {
 106         TSerr(TS_F_TS_MSG_IMPRINT_SET_ALGO, ERR_R_MALLOC_FAILURE);
 107         return 0;
 108     }
 109     X509_ALGOR_free(a->hash_algo);
 110     a->hash_algo = new_alg;
 111     return 1;
 112 }
 113
 114 X509_ALGOR *TS_MSG_IMPRINT_get_algo(TS_MSG_IMPRINT *a)
 115 {
 116     return a->hash_algo;
 117 }
 118
 119 int TS_MSG_IMPRINT_set_msg(TS_MSG_IMPRINT *a, unsigned char *d, int len)
 120 {
 121     return ASN1_OCTET_STRING_set(a->hashed_msg, d, len);
 122 }
 123
 124 ASN1_OCTET_STRING *TS_MSG_IMPRINT_get_msg(TS_MSG_IMPRINT *a)
 125 {
 126     return a->hashed_msg;
 127 }
 128
 129 int TS_REQ_set_policy_id(TS_REQ *a, ASN1_OBJECT *policy)
 130 {
 131     ASN1_OBJECT *new_policy;
 132
 133     if (a->policy_id == policy)
 134         return 1;
 135     new_policy = OBJ_dup(policy);
 136     if (new_policy == NULL) {
 137         TSerr(TS_F_TS_REQ_SET_POLICY_ID, ERR_R_MALLOC_FAILURE);
 138         return 0;
 139     }
 140     ASN1_OBJECT_free(a->policy_id);
 141     a->policy_id = new_policy;
 142     return 1;
 143 }
 144
 145 ASN1_OBJECT *TS_REQ_get_policy_id(TS_REQ *a)
 146 {
 147     return a->policy_id;
 148 }
 149
 150 int TS_REQ_set_nonce(TS_REQ *a, const ASN1_INTEGER *nonce)
 151 {
 152     ASN1_INTEGER *new_nonce;
 153
 154     if (a->nonce == nonce)
 155         return 1;
 156     new_nonce = ASN1_INTEGER_dup(nonce);
 157     if (new_nonce == NULL) {
 158         TSerr(TS_F_TS_REQ_SET_NONCE, ERR_R_MALLOC_FAILURE);
 159         return 0;
 160     }
 161     ASN1_INTEGER_free(a->nonce);
 162     a->nonce = new_nonce;
 163     return 1;
 164 }
 165
 166 const ASN1_INTEGER *TS_REQ_get_nonce(const TS_REQ *a)
 167 {
 168     return a->nonce;
 169 }
 170
 171 int TS_REQ_set_cert_req(TS_REQ *a, int cert_req)
 172 {
 173     a->cert_req = cert_req ? 0xFF : 0x00;
 174     return 1;
 175 }
 176
 177 int TS_REQ_get_cert_req(const TS_REQ *a)
 178 {
 179     return a->cert_req ? 1 : 0;
 180 }
 181
 182 STACK_OF(X509_EXTENSION) *TS_REQ_get_exts(TS_REQ *a)
 183 {
 184     return a->extensions;
 185 }
 186
 187 void TS_REQ_ext_free(TS_REQ *a)
 188 {
 189     if (!a)
 190         return;
 191     sk_X509_EXTENSION_pop_free(a->extensions, X509_EXTENSION_free);
 192     a->extensions = NULL;
 193 }
 194
 195 int TS_REQ_get_ext_count(TS_REQ *a)
 196 {
 197     return X509v3_get_ext_count(a->extensions);
 198 }
 199
 200 int TS_REQ_get_ext_by_NID(TS_REQ *a, int nid, int lastpos)
 201 {
 202     return X509v3_get_ext_by_NID(a->extensions, nid, lastpos);
 203 }
 204
 205 int TS_REQ_get_ext_by_OBJ(TS_REQ *a, ASN1_OBJECT *obj, int lastpos)
 206 {
 207     return X509v3_get_ext_by_OBJ(a->extensions, obj, lastpos);
 208 }
 209
 210 int TS_REQ_get_ext_by_critical(TS_REQ *a, int crit, int lastpos)
 211 {
 212     return X509v3_get_ext_by_critical(a->extensions, crit, lastpos);
 213 }
 214
 215 X509_EXTENSION *TS_REQ_get_ext(TS_REQ *a, int loc)
 216 {
 217     return X509v3_get_ext(a->extensions, loc);
 218 }
 219
 220 X509_EXTENSION *TS_REQ_delete_ext(TS_REQ *a, int loc)
 221 {
 222     return X509v3_delete_ext(a->extensions, loc);
 223 }
 224
 225 int TS_REQ_add_ext(TS_REQ *a, X509_EXTENSION *ex, int loc)
 226 {
 227     return X509v3_add_ext(&a->extensions, ex, loc) != NULL;
 228 }
 229
 230 void *TS_REQ_get_ext_d2i(TS_REQ *a, int nid, int *crit, int *idx)
 231 {
 232     return X509V3_get_d2i(a->extensions, nid, crit, idx);
 233 }