1 /* $OpenBSD: ts_asn1.c,v 1.5 2014/07/10 22:45:58 jsing Exp $ */ 2 /* Written by Nils Larsch for the OpenSSL project 2004. 3 */ 4 /* ==================================================================== 5 * Copyright (c) 2006 The OpenSSL Project. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in 16 * the documentation and/or other materials provided with the 17 * distribution. 18 * 19 * 3. All advertising materials mentioning features or use of this 20 * software must display the following acknowledgment: 21 * "This product includes software developed by the OpenSSL Project 22 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" 23 * 24 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to 25 * endorse or promote products derived from this software without 26 * prior written permission. For written permission, please contact 27 * licensing@OpenSSL.org. 28 * 29 * 5. Products derived from this software may not be called "OpenSSL" 30 * nor may "OpenSSL" appear in their names without prior written 31 * permission of the OpenSSL Project. 32 * 33 * 6. Redistributions of any form whatsoever must retain the following 34 * acknowledgment: 35 * "This product includes software developed by the OpenSSL Project 36 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" 37 * 38 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY 39 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 40 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 41 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR 42 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 43 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 44 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 45 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 46 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 47 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 48 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 49 * OF THE POSSIBILITY OF SUCH DAMAGE. 50 * ==================================================================== 51 * 52 * This product includes cryptographic software written by Eric Young 53 * (eay@cryptsoft.com). This product includes software written by Tim 54 * Hudson (tjh@cryptsoft.com). 55 * 56 */ 57 58 #include <openssl/opensslconf.h> 59 60 #include <openssl/ts.h> 61 #include <openssl/err.h> 62 #include <openssl/asn1t.h> 63 64 ASN1_SEQUENCE(TS_MSG_IMPRINT) = { 65 ASN1_SIMPLE(TS_MSG_IMPRINT, hash_algo, X509_ALGOR), 66 ASN1_SIMPLE(TS_MSG_IMPRINT, hashed_msg, ASN1_OCTET_STRING) 67 } ASN1_SEQUENCE_END(TS_MSG_IMPRINT) 68 69 IMPLEMENT_ASN1_FUNCTIONS_const(TS_MSG_IMPRINT) 70 IMPLEMENT_ASN1_DUP_FUNCTION(TS_MSG_IMPRINT) 71 72 #ifndef OPENSSL_NO_BIO 73 TS_MSG_IMPRINT * 74 d2i_TS_MSG_IMPRINT_bio(BIO *bp, TS_MSG_IMPRINT **a) 75 { 76 return ASN1_d2i_bio_of(TS_MSG_IMPRINT, TS_MSG_IMPRINT_new, 77 d2i_TS_MSG_IMPRINT, bp, a); 78 } 79 80 int 81 i2d_TS_MSG_IMPRINT_bio(BIO *bp, TS_MSG_IMPRINT *a) 82 { 83 return ASN1_i2d_bio_of_const(TS_MSG_IMPRINT, i2d_TS_MSG_IMPRINT, bp, a); 84 } 85 #endif 86 87 TS_MSG_IMPRINT * 88 d2i_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT **a) 89 { 90 return ASN1_d2i_fp_of(TS_MSG_IMPRINT, TS_MSG_IMPRINT_new, 91 d2i_TS_MSG_IMPRINT, fp, a); 92 } 93 94 int 95 i2d_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT *a) 96 { 97 return ASN1_i2d_fp_of_const(TS_MSG_IMPRINT, i2d_TS_MSG_IMPRINT, fp, a); 98 } 99 100 ASN1_SEQUENCE(TS_REQ) = { 101 ASN1_SIMPLE(TS_REQ, version, ASN1_INTEGER), 102 ASN1_SIMPLE(TS_REQ, msg_imprint, TS_MSG_IMPRINT), 103 ASN1_OPT(TS_REQ, policy_id, ASN1_OBJECT), 104 ASN1_OPT(TS_REQ, nonce, ASN1_INTEGER), 105 ASN1_OPT(TS_REQ, cert_req, ASN1_FBOOLEAN), 106 ASN1_IMP_SEQUENCE_OF_OPT(TS_REQ, extensions, X509_EXTENSION, 0) 107 } ASN1_SEQUENCE_END(TS_REQ) 108 109 IMPLEMENT_ASN1_FUNCTIONS_const(TS_REQ) 110 IMPLEMENT_ASN1_DUP_FUNCTION(TS_REQ) 111 112 #ifndef OPENSSL_NO_BIO 113 TS_REQ * 114 d2i_TS_REQ_bio(BIO *bp, TS_REQ **a) 115 { 116 return ASN1_d2i_bio_of(TS_REQ, TS_REQ_new, d2i_TS_REQ, bp, a); 117 } 118 119 int 120 i2d_TS_REQ_bio(BIO *bp, TS_REQ *a) 121 { 122 return ASN1_i2d_bio_of_const(TS_REQ, i2d_TS_REQ, bp, a); 123 } 124 #endif 125 126 TS_REQ * 127 d2i_TS_REQ_fp(FILE *fp, TS_REQ **a) 128 { 129 return ASN1_d2i_fp_of(TS_REQ, TS_REQ_new, d2i_TS_REQ, fp, a); 130 } 131 132 int 133 i2d_TS_REQ_fp(FILE *fp, TS_REQ *a) 134 { 135 return ASN1_i2d_fp_of_const(TS_REQ, i2d_TS_REQ, fp, a); 136 } 137 138 ASN1_SEQUENCE(TS_ACCURACY) = { 139 ASN1_OPT(TS_ACCURACY, seconds, ASN1_INTEGER), 140 ASN1_IMP_OPT(TS_ACCURACY, millis, ASN1_INTEGER, 0), 141 ASN1_IMP_OPT(TS_ACCURACY, micros, ASN1_INTEGER, 1) 142 } ASN1_SEQUENCE_END(TS_ACCURACY) 143 144 IMPLEMENT_ASN1_FUNCTIONS_const(TS_ACCURACY) 145 IMPLEMENT_ASN1_DUP_FUNCTION(TS_ACCURACY) 146 147 ASN1_SEQUENCE(TS_TST_INFO) = { 148 ASN1_SIMPLE(TS_TST_INFO, version, ASN1_INTEGER), 149 ASN1_SIMPLE(TS_TST_INFO, policy_id, ASN1_OBJECT), 150 ASN1_SIMPLE(TS_TST_INFO, msg_imprint, TS_MSG_IMPRINT), 151 ASN1_SIMPLE(TS_TST_INFO, serial, ASN1_INTEGER), 152 ASN1_SIMPLE(TS_TST_INFO, time, ASN1_GENERALIZEDTIME), 153 ASN1_OPT(TS_TST_INFO, accuracy, TS_ACCURACY), 154 ASN1_OPT(TS_TST_INFO, ordering, ASN1_FBOOLEAN), 155 ASN1_OPT(TS_TST_INFO, nonce, ASN1_INTEGER), 156 ASN1_EXP_OPT(TS_TST_INFO, tsa, GENERAL_NAME, 0), 157 ASN1_IMP_SEQUENCE_OF_OPT(TS_TST_INFO, extensions, X509_EXTENSION, 1) 158 } ASN1_SEQUENCE_END(TS_TST_INFO) 159 160 IMPLEMENT_ASN1_FUNCTIONS_const(TS_TST_INFO) 161 IMPLEMENT_ASN1_DUP_FUNCTION(TS_TST_INFO) 162 163 #ifndef OPENSSL_NO_BIO 164 TS_TST_INFO * 165 d2i_TS_TST_INFO_bio(BIO *bp, TS_TST_INFO **a) 166 { 167 return ASN1_d2i_bio_of(TS_TST_INFO, TS_TST_INFO_new, d2i_TS_TST_INFO, 168 bp, a); 169 } 170 171 int 172 i2d_TS_TST_INFO_bio(BIO *bp, TS_TST_INFO *a) 173 { 174 return ASN1_i2d_bio_of_const(TS_TST_INFO, i2d_TS_TST_INFO, bp, a); 175 } 176 #endif 177 178 TS_TST_INFO * 179 d2i_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO **a) 180 { 181 return ASN1_d2i_fp_of(TS_TST_INFO, TS_TST_INFO_new, d2i_TS_TST_INFO, 182 fp, a); 183 } 184 185 int 186 i2d_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO *a) 187 { 188 return ASN1_i2d_fp_of_const(TS_TST_INFO, i2d_TS_TST_INFO, fp, a); 189 } 190 191 ASN1_SEQUENCE(TS_STATUS_INFO) = { 192 ASN1_SIMPLE(TS_STATUS_INFO, status, ASN1_INTEGER), 193 ASN1_SEQUENCE_OF_OPT(TS_STATUS_INFO, text, ASN1_UTF8STRING), 194 ASN1_OPT(TS_STATUS_INFO, failure_info, ASN1_BIT_STRING) 195 } ASN1_SEQUENCE_END(TS_STATUS_INFO) 196 197 IMPLEMENT_ASN1_FUNCTIONS_const(TS_STATUS_INFO) 198 IMPLEMENT_ASN1_DUP_FUNCTION(TS_STATUS_INFO) 199 200 static int 201 ts_resp_set_tst_info(TS_RESP *a) 202 { 203 long status; 204 205 status = ASN1_INTEGER_get(a->status_info->status); 206 207 if (a->token) { 208 if (status != 0 && status != 1) { 209 TSerr(TS_F_TS_RESP_SET_TST_INFO, TS_R_TOKEN_PRESENT); 210 return 0; 211 } 212 if (a->tst_info != NULL) 213 TS_TST_INFO_free(a->tst_info); 214 a->tst_info = PKCS7_to_TS_TST_INFO(a->token); 215 if (!a->tst_info) { 216 TSerr(TS_F_TS_RESP_SET_TST_INFO, 217 TS_R_PKCS7_TO_TS_TST_INFO_FAILED); 218 return 0; 219 } 220 } else if (status == 0 || status == 1) { 221 TSerr(TS_F_TS_RESP_SET_TST_INFO, TS_R_TOKEN_NOT_PRESENT); 222 return 0; 223 } 224 225 return 1; 226 } 227 228 static int 229 ts_resp_cb(int op, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg) 230 { 231 TS_RESP *ts_resp = (TS_RESP *)*pval; 232 233 if (op == ASN1_OP_NEW_POST) { 234 ts_resp->tst_info = NULL; 235 } else if (op == ASN1_OP_FREE_POST) { 236 if (ts_resp->tst_info != NULL) 237 TS_TST_INFO_free(ts_resp->tst_info); 238 } else if (op == ASN1_OP_D2I_POST) { 239 if (ts_resp_set_tst_info(ts_resp) == 0) 240 return 0; 241 } 242 return 1; 243 } 244 245 ASN1_SEQUENCE_cb(TS_RESP, ts_resp_cb) = { 246 ASN1_SIMPLE(TS_RESP, status_info, TS_STATUS_INFO), 247 ASN1_OPT(TS_RESP, token, PKCS7), 248 } ASN1_SEQUENCE_END_cb(TS_RESP, TS_RESP) 249 250 IMPLEMENT_ASN1_FUNCTIONS_const(TS_RESP) 251 IMPLEMENT_ASN1_DUP_FUNCTION(TS_RESP) 252 253 #ifndef OPENSSL_NO_BIO 254 TS_RESP * 255 d2i_TS_RESP_bio(BIO *bp, TS_RESP **a) 256 { 257 return ASN1_d2i_bio_of(TS_RESP, TS_RESP_new, d2i_TS_RESP, bp, a); 258 } 259 260 int 261 i2d_TS_RESP_bio(BIO *bp, TS_RESP *a) 262 { 263 return ASN1_i2d_bio_of_const(TS_RESP, i2d_TS_RESP, bp, a); 264 } 265 #endif 266 267 TS_RESP * 268 d2i_TS_RESP_fp(FILE *fp, TS_RESP **a) 269 { 270 return ASN1_d2i_fp_of(TS_RESP, TS_RESP_new, d2i_TS_RESP, fp, a); 271 } 272 273 int 274 i2d_TS_RESP_fp(FILE *fp, TS_RESP *a) 275 { 276 return ASN1_i2d_fp_of_const(TS_RESP, i2d_TS_RESP, fp, a); 277 } 278 279 ASN1_SEQUENCE(ESS_ISSUER_SERIAL) = { 280 ASN1_SEQUENCE_OF(ESS_ISSUER_SERIAL, issuer, GENERAL_NAME), 281 ASN1_SIMPLE(ESS_ISSUER_SERIAL, serial, ASN1_INTEGER) 282 } ASN1_SEQUENCE_END(ESS_ISSUER_SERIAL) 283 284 IMPLEMENT_ASN1_FUNCTIONS_const(ESS_ISSUER_SERIAL) 285 IMPLEMENT_ASN1_DUP_FUNCTION(ESS_ISSUER_SERIAL) 286 287 ASN1_SEQUENCE(ESS_CERT_ID) = { 288 ASN1_SIMPLE(ESS_CERT_ID, hash, ASN1_OCTET_STRING), 289 ASN1_OPT(ESS_CERT_ID, issuer_serial, ESS_ISSUER_SERIAL) 290 } ASN1_SEQUENCE_END(ESS_CERT_ID) 291 292 IMPLEMENT_ASN1_FUNCTIONS_const(ESS_CERT_ID) 293 IMPLEMENT_ASN1_DUP_FUNCTION(ESS_CERT_ID) 294 295 ASN1_SEQUENCE(ESS_SIGNING_CERT) = { 296 ASN1_SEQUENCE_OF(ESS_SIGNING_CERT, cert_ids, ESS_CERT_ID), 297 ASN1_SEQUENCE_OF_OPT(ESS_SIGNING_CERT, policy_info, POLICYINFO) 298 } ASN1_SEQUENCE_END(ESS_SIGNING_CERT) 299 300 IMPLEMENT_ASN1_FUNCTIONS_const(ESS_SIGNING_CERT) 301 IMPLEMENT_ASN1_DUP_FUNCTION(ESS_SIGNING_CERT) 302 303 /* Getting encapsulated TS_TST_INFO object from PKCS7. */ 304 TS_TST_INFO * 305 PKCS7_to_TS_TST_INFO(PKCS7 *token) 306 { 307 PKCS7_SIGNED *pkcs7_signed; 308 PKCS7 *enveloped; 309 ASN1_TYPE *tst_info_wrapper; 310 ASN1_OCTET_STRING *tst_info_der; 311 const unsigned char *p; 312 313 if (!PKCS7_type_is_signed(token)) { 314 TSerr(TS_F_PKCS7_TO_TS_TST_INFO, TS_R_BAD_PKCS7_TYPE); 315 return NULL; 316 } 317 318 /* Content must be present. */ 319 if (PKCS7_get_detached(token)) { 320 TSerr(TS_F_PKCS7_TO_TS_TST_INFO, TS_R_DETACHED_CONTENT); 321 return NULL; 322 } 323 324 /* We have a signed data with content. */ 325 pkcs7_signed = token->d.sign; 326 enveloped = pkcs7_signed->contents; 327 if (OBJ_obj2nid(enveloped->type) != NID_id_smime_ct_TSTInfo) { 328 TSerr(TS_F_PKCS7_TO_TS_TST_INFO, TS_R_BAD_PKCS7_TYPE); 329 return NULL; 330 } 331 332 /* We have a DER encoded TST_INFO as the signed data. */ 333 tst_info_wrapper = enveloped->d.other; 334 if (tst_info_wrapper->type != V_ASN1_OCTET_STRING) { 335 TSerr(TS_F_PKCS7_TO_TS_TST_INFO, TS_R_BAD_TYPE); 336 return NULL; 337 } 338 339 /* We have the correct ASN1_OCTET_STRING type. */ 340 tst_info_der = tst_info_wrapper->value.octet_string; 341 /* At last, decode the TST_INFO. */ 342 p = tst_info_der->data; 343 return d2i_TS_TST_INFO(NULL, &p, tst_info_der->length); 344 } 345