2 * Copyright 2006-2016 The OpenSSL Project Authors. All Rights Reserved.
4 * Licensed under the OpenSSL license (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
10 #include "internal/cryptlib.h"
12 #if defined(OPENSSL_SYS_UNIX)
13 # include <sys/time.h>
16 #include <openssl/objects.h>
17 #include <openssl/ts.h>
18 #include <openssl/pkcs7.h>
21 static ASN1_INTEGER
*def_serial_cb(struct TS_resp_ctx
*, void *);
22 static int def_time_cb(struct TS_resp_ctx
*, void *, long *sec
, long *usec
);
23 static int def_extension_cb(struct TS_resp_ctx
*, X509_EXTENSION
*, void *);
25 static void ts_RESP_CTX_init(TS_RESP_CTX
*ctx
);
26 static void ts_RESP_CTX_cleanup(TS_RESP_CTX
*ctx
);
27 static int ts_RESP_check_request(TS_RESP_CTX
*ctx
);
28 static ASN1_OBJECT
*ts_RESP_get_policy(TS_RESP_CTX
*ctx
);
29 static TS_TST_INFO
*ts_RESP_create_tst_info(TS_RESP_CTX
*ctx
,
31 static int ts_RESP_process_extensions(TS_RESP_CTX
*ctx
);
32 static int ts_RESP_sign(TS_RESP_CTX
*ctx
);
34 static ESS_SIGNING_CERT
*ess_SIGNING_CERT_new_init(X509
*signcert
,
35 STACK_OF(X509
) *certs
);
36 static ESS_CERT_ID
*ess_CERT_ID_new_init(X509
*cert
, int issuer_needed
);
37 static int ts_TST_INFO_content_new(PKCS7
*p7
);
38 static int ess_add_signing_cert(PKCS7_SIGNER_INFO
*si
, ESS_SIGNING_CERT
*sc
);
40 static ESS_SIGNING_CERT_V2
*ess_signing_cert_v2_new_init(const EVP_MD
*hash_alg
,
44 static ESS_CERT_ID_V2
*ess_cert_id_v2_new_init(const EVP_MD
*hash_alg
,
45 X509
*cert
, int issuer_needed
);
46 static int ess_add_signing_cert_v2(PKCS7_SIGNER_INFO
*si
,
47 ESS_SIGNING_CERT_V2
*sc
);
49 static ASN1_GENERALIZEDTIME
50 *TS_RESP_set_genTime_with_precision(ASN1_GENERALIZEDTIME
*, long, long,
53 /* Default callback for response generation. */
54 static ASN1_INTEGER
*def_serial_cb(struct TS_resp_ctx
*ctx
, void *data
)
56 ASN1_INTEGER
*serial
= ASN1_INTEGER_new();
60 if (!ASN1_INTEGER_set(serial
, 1))
65 TSerr(TS_F_DEF_SERIAL_CB
, ERR_R_MALLOC_FAILURE
);
66 TS_RESP_CTX_set_status_info(ctx
, TS_STATUS_REJECTION
,
67 "Error during serial number generation.");
71 #if defined(OPENSSL_SYS_UNIX)
73 static int def_time_cb(struct TS_resp_ctx
*ctx
, void *data
,
74 long *sec
, long *usec
)
77 if (gettimeofday(&tv
, NULL
) != 0) {
78 TSerr(TS_F_DEF_TIME_CB
, TS_R_TIME_SYSCALL_ERROR
);
79 TS_RESP_CTX_set_status_info(ctx
, TS_STATUS_REJECTION
,
80 "Time is not available.");
81 TS_RESP_CTX_add_failure_info(ctx
, TS_INFO_TIME_NOT_AVAILABLE
);
92 static int def_time_cb(struct TS_resp_ctx
*ctx
, void *data
,
93 long *sec
, long *usec
)
96 if (time(&t
) == (time_t)-1) {
97 TSerr(TS_F_DEF_TIME_CB
, TS_R_TIME_SYSCALL_ERROR
);
98 TS_RESP_CTX_set_status_info(ctx
, TS_STATUS_REJECTION
,
99 "Time is not available.");
100 TS_RESP_CTX_add_failure_info(ctx
, TS_INFO_TIME_NOT_AVAILABLE
);
111 static int def_extension_cb(struct TS_resp_ctx
*ctx
, X509_EXTENSION
*ext
,
114 TS_RESP_CTX_set_status_info(ctx
, TS_STATUS_REJECTION
,
115 "Unsupported extension.");
116 TS_RESP_CTX_add_failure_info(ctx
, TS_INFO_UNACCEPTED_EXTENSION
);
120 /* TS_RESP_CTX management functions. */
122 TS_RESP_CTX
*TS_RESP_CTX_new()
126 if ((ctx
= OPENSSL_zalloc(sizeof(*ctx
))) == NULL
) {
127 TSerr(TS_F_TS_RESP_CTX_NEW
, ERR_R_MALLOC_FAILURE
);
131 ctx
->signer_md
= EVP_sha256();
133 ctx
->serial_cb
= def_serial_cb
;
134 ctx
->time_cb
= def_time_cb
;
135 ctx
->extension_cb
= def_extension_cb
;
140 void TS_RESP_CTX_free(TS_RESP_CTX
*ctx
)
145 X509_free(ctx
->signer_cert
);
146 EVP_PKEY_free(ctx
->signer_key
);
147 sk_X509_pop_free(ctx
->certs
, X509_free
);
148 sk_ASN1_OBJECT_pop_free(ctx
->policies
, ASN1_OBJECT_free
);
149 ASN1_OBJECT_free(ctx
->default_policy
);
150 sk_EVP_MD_free(ctx
->mds
); /* No EVP_MD_free method exists. */
151 ASN1_INTEGER_free(ctx
->seconds
);
152 ASN1_INTEGER_free(ctx
->millis
);
153 ASN1_INTEGER_free(ctx
->micros
);
157 int TS_RESP_CTX_set_signer_cert(TS_RESP_CTX
*ctx
, X509
*signer
)
159 if (X509_check_purpose(signer
, X509_PURPOSE_TIMESTAMP_SIGN
, 0) != 1) {
160 TSerr(TS_F_TS_RESP_CTX_SET_SIGNER_CERT
,
161 TS_R_INVALID_SIGNER_CERTIFICATE_PURPOSE
);
164 X509_free(ctx
->signer_cert
);
165 ctx
->signer_cert
= signer
;
166 X509_up_ref(ctx
->signer_cert
);
170 int TS_RESP_CTX_set_signer_key(TS_RESP_CTX
*ctx
, EVP_PKEY
*key
)
172 EVP_PKEY_free(ctx
->signer_key
);
173 ctx
->signer_key
= key
;
174 EVP_PKEY_up_ref(ctx
->signer_key
);
179 int TS_RESP_CTX_set_signer_digest(TS_RESP_CTX
*ctx
, const EVP_MD
*md
)
185 int TS_RESP_CTX_set_def_policy(TS_RESP_CTX
*ctx
, const ASN1_OBJECT
*def_policy
)
187 ASN1_OBJECT_free(ctx
->default_policy
);
188 if ((ctx
->default_policy
= OBJ_dup(def_policy
)) == NULL
)
192 TSerr(TS_F_TS_RESP_CTX_SET_DEF_POLICY
, ERR_R_MALLOC_FAILURE
);
196 int TS_RESP_CTX_set_certs(TS_RESP_CTX
*ctx
, STACK_OF(X509
) *certs
)
199 sk_X509_pop_free(ctx
->certs
, X509_free
);
203 if ((ctx
->certs
= X509_chain_up_ref(certs
)) == NULL
) {
204 TSerr(TS_F_TS_RESP_CTX_SET_CERTS
, ERR_R_MALLOC_FAILURE
);
211 int TS_RESP_CTX_add_policy(TS_RESP_CTX
*ctx
, const ASN1_OBJECT
*policy
)
213 ASN1_OBJECT
*copy
= NULL
;
215 if (ctx
->policies
== NULL
216 && (ctx
->policies
= sk_ASN1_OBJECT_new_null()) == NULL
)
218 if ((copy
= OBJ_dup(policy
)) == NULL
)
220 if (!sk_ASN1_OBJECT_push(ctx
->policies
, copy
))
225 TSerr(TS_F_TS_RESP_CTX_ADD_POLICY
, ERR_R_MALLOC_FAILURE
);
226 ASN1_OBJECT_free(copy
);
230 int TS_RESP_CTX_add_md(TS_RESP_CTX
*ctx
, const EVP_MD
*md
)
233 && (ctx
->mds
= sk_EVP_MD_new_null()) == NULL
)
235 if (!sk_EVP_MD_push(ctx
->mds
, md
))
240 TSerr(TS_F_TS_RESP_CTX_ADD_MD
, ERR_R_MALLOC_FAILURE
);
244 #define TS_RESP_CTX_accuracy_free(ctx) \
245 ASN1_INTEGER_free(ctx->seconds); \
246 ctx->seconds = NULL; \
247 ASN1_INTEGER_free(ctx->millis); \
248 ctx->millis = NULL; \
249 ASN1_INTEGER_free(ctx->micros); \
252 int TS_RESP_CTX_set_accuracy(TS_RESP_CTX
*ctx
,
253 int secs
, int millis
, int micros
)
256 TS_RESP_CTX_accuracy_free(ctx
);
258 && ((ctx
->seconds
= ASN1_INTEGER_new()) == NULL
259 || !ASN1_INTEGER_set(ctx
->seconds
, secs
)))
262 && ((ctx
->millis
= ASN1_INTEGER_new()) == NULL
263 || !ASN1_INTEGER_set(ctx
->millis
, millis
)))
266 && ((ctx
->micros
= ASN1_INTEGER_new()) == NULL
267 || !ASN1_INTEGER_set(ctx
->micros
, micros
)))
272 TS_RESP_CTX_accuracy_free(ctx
);
273 TSerr(TS_F_TS_RESP_CTX_SET_ACCURACY
, ERR_R_MALLOC_FAILURE
);
277 void TS_RESP_CTX_add_flags(TS_RESP_CTX
*ctx
, int flags
)
282 void TS_RESP_CTX_set_serial_cb(TS_RESP_CTX
*ctx
, TS_serial_cb cb
, void *data
)
285 ctx
->serial_cb_data
= data
;
288 void TS_RESP_CTX_set_time_cb(TS_RESP_CTX
*ctx
, TS_time_cb cb
, void *data
)
291 ctx
->time_cb_data
= data
;
294 void TS_RESP_CTX_set_extension_cb(TS_RESP_CTX
*ctx
,
295 TS_extension_cb cb
, void *data
)
297 ctx
->extension_cb
= cb
;
298 ctx
->extension_cb_data
= data
;
301 int TS_RESP_CTX_set_status_info(TS_RESP_CTX
*ctx
,
302 int status
, const char *text
)
304 TS_STATUS_INFO
*si
= NULL
;
305 ASN1_UTF8STRING
*utf8_text
= NULL
;
308 if ((si
= TS_STATUS_INFO_new()) == NULL
)
310 if (!ASN1_INTEGER_set(si
->status
, status
))
313 if ((utf8_text
= ASN1_UTF8STRING_new()) == NULL
314 || !ASN1_STRING_set(utf8_text
, text
, strlen(text
)))
317 && (si
->text
= sk_ASN1_UTF8STRING_new_null()) == NULL
)
319 if (!sk_ASN1_UTF8STRING_push(si
->text
, utf8_text
))
321 utf8_text
= NULL
; /* Ownership is lost. */
323 if (!TS_RESP_set_status_info(ctx
->response
, si
))
328 TSerr(TS_F_TS_RESP_CTX_SET_STATUS_INFO
, ERR_R_MALLOC_FAILURE
);
329 TS_STATUS_INFO_free(si
);
330 ASN1_UTF8STRING_free(utf8_text
);
334 int TS_RESP_CTX_set_status_info_cond(TS_RESP_CTX
*ctx
,
335 int status
, const char *text
)
338 TS_STATUS_INFO
*si
= ctx
->response
->status_info
;
340 if (ASN1_INTEGER_get(si
->status
) == TS_STATUS_GRANTED
) {
341 ret
= TS_RESP_CTX_set_status_info(ctx
, status
, text
);
346 int TS_RESP_CTX_add_failure_info(TS_RESP_CTX
*ctx
, int failure
)
348 TS_STATUS_INFO
*si
= ctx
->response
->status_info
;
349 if (si
->failure_info
== NULL
350 && (si
->failure_info
= ASN1_BIT_STRING_new()) == NULL
)
352 if (!ASN1_BIT_STRING_set_bit(si
->failure_info
, failure
, 1))
356 TSerr(TS_F_TS_RESP_CTX_ADD_FAILURE_INFO
, ERR_R_MALLOC_FAILURE
);
360 TS_REQ
*TS_RESP_CTX_get_request(TS_RESP_CTX
*ctx
)
365 TS_TST_INFO
*TS_RESP_CTX_get_tst_info(TS_RESP_CTX
*ctx
)
367 return ctx
->tst_info
;
370 int TS_RESP_CTX_set_clock_precision_digits(TS_RESP_CTX
*ctx
,
373 if (precision
> TS_MAX_CLOCK_PRECISION_DIGITS
)
375 ctx
->clock_precision_digits
= precision
;
379 /* Main entry method of the response generation. */
380 TS_RESP
*TS_RESP_create_response(TS_RESP_CTX
*ctx
, BIO
*req_bio
)
386 ts_RESP_CTX_init(ctx
);
388 if ((ctx
->response
= TS_RESP_new()) == NULL
) {
389 TSerr(TS_F_TS_RESP_CREATE_RESPONSE
, ERR_R_MALLOC_FAILURE
);
392 if ((ctx
->request
= d2i_TS_REQ_bio(req_bio
, NULL
)) == NULL
) {
393 TS_RESP_CTX_set_status_info(ctx
, TS_STATUS_REJECTION
,
394 "Bad request format or system error.");
395 TS_RESP_CTX_add_failure_info(ctx
, TS_INFO_BAD_DATA_FORMAT
);
398 if (!TS_RESP_CTX_set_status_info(ctx
, TS_STATUS_GRANTED
, NULL
))
400 if (!ts_RESP_check_request(ctx
))
402 if ((policy
= ts_RESP_get_policy(ctx
)) == NULL
)
404 if ((ctx
->tst_info
= ts_RESP_create_tst_info(ctx
, policy
)) == NULL
)
406 if (!ts_RESP_process_extensions(ctx
))
408 if (!ts_RESP_sign(ctx
))
414 TSerr(TS_F_TS_RESP_CREATE_RESPONSE
, TS_R_RESPONSE_SETUP_ERROR
);
415 if (ctx
->response
!= NULL
) {
416 if (TS_RESP_CTX_set_status_info_cond(ctx
,
418 "Error during response "
419 "generation.") == 0) {
420 TS_RESP_free(ctx
->response
);
421 ctx
->response
= NULL
;
425 response
= ctx
->response
;
426 ctx
->response
= NULL
; /* Ownership will be returned to caller. */
427 ts_RESP_CTX_cleanup(ctx
);
431 /* Initializes the variable part of the context. */
432 static void ts_RESP_CTX_init(TS_RESP_CTX
*ctx
)
435 ctx
->response
= NULL
;
436 ctx
->tst_info
= NULL
;
439 /* Cleans up the variable part of the context. */
440 static void ts_RESP_CTX_cleanup(TS_RESP_CTX
*ctx
)
442 TS_REQ_free(ctx
->request
);
444 TS_RESP_free(ctx
->response
);
445 ctx
->response
= NULL
;
446 TS_TST_INFO_free(ctx
->tst_info
);
447 ctx
->tst_info
= NULL
;
450 /* Checks the format and content of the request. */
451 static int ts_RESP_check_request(TS_RESP_CTX
*ctx
)
453 TS_REQ
*request
= ctx
->request
;
454 TS_MSG_IMPRINT
*msg_imprint
;
457 const ASN1_OCTET_STRING
*digest
;
458 const EVP_MD
*md
= NULL
;
461 if (TS_REQ_get_version(request
) != 1) {
462 TS_RESP_CTX_set_status_info(ctx
, TS_STATUS_REJECTION
,
463 "Bad request version.");
464 TS_RESP_CTX_add_failure_info(ctx
, TS_INFO_BAD_REQUEST
);
468 msg_imprint
= request
->msg_imprint
;
469 md_alg
= msg_imprint
->hash_algo
;
470 md_alg_id
= OBJ_obj2nid(md_alg
->algorithm
);
471 for (i
= 0; !md
&& i
< sk_EVP_MD_num(ctx
->mds
); ++i
) {
472 const EVP_MD
*current_md
= sk_EVP_MD_value(ctx
->mds
, i
);
473 if (md_alg_id
== EVP_MD_type(current_md
))
477 TS_RESP_CTX_set_status_info(ctx
, TS_STATUS_REJECTION
,
478 "Message digest algorithm is "
480 TS_RESP_CTX_add_failure_info(ctx
, TS_INFO_BAD_ALG
);
484 if (md_alg
->parameter
&& ASN1_TYPE_get(md_alg
->parameter
) != V_ASN1_NULL
) {
485 TS_RESP_CTX_set_status_info(ctx
, TS_STATUS_REJECTION
,
486 "Superfluous message digest "
488 TS_RESP_CTX_add_failure_info(ctx
, TS_INFO_BAD_ALG
);
491 digest
= msg_imprint
->hashed_msg
;
492 if (digest
->length
!= EVP_MD_size(md
)) {
493 TS_RESP_CTX_set_status_info(ctx
, TS_STATUS_REJECTION
,
494 "Bad message digest.");
495 TS_RESP_CTX_add_failure_info(ctx
, TS_INFO_BAD_DATA_FORMAT
);
502 /* Returns the TSA policy based on the requested and acceptable policies. */
503 static ASN1_OBJECT
*ts_RESP_get_policy(TS_RESP_CTX
*ctx
)
505 ASN1_OBJECT
*requested
= ctx
->request
->policy_id
;
506 ASN1_OBJECT
*policy
= NULL
;
509 if (ctx
->default_policy
== NULL
) {
510 TSerr(TS_F_TS_RESP_GET_POLICY
, TS_R_INVALID_NULL_POINTER
);
513 if (!requested
|| !OBJ_cmp(requested
, ctx
->default_policy
))
514 policy
= ctx
->default_policy
;
516 /* Check if the policy is acceptable. */
517 for (i
= 0; !policy
&& i
< sk_ASN1_OBJECT_num(ctx
->policies
); ++i
) {
518 ASN1_OBJECT
*current
= sk_ASN1_OBJECT_value(ctx
->policies
, i
);
519 if (!OBJ_cmp(requested
, current
))
523 TSerr(TS_F_TS_RESP_GET_POLICY
, TS_R_UNACCEPTABLE_POLICY
);
524 TS_RESP_CTX_set_status_info(ctx
, TS_STATUS_REJECTION
,
525 "Requested policy is not " "supported.");
526 TS_RESP_CTX_add_failure_info(ctx
, TS_INFO_UNACCEPTED_POLICY
);
531 /* Creates the TS_TST_INFO object based on the settings of the context. */
532 static TS_TST_INFO
*ts_RESP_create_tst_info(TS_RESP_CTX
*ctx
,
536 TS_TST_INFO
*tst_info
= NULL
;
537 ASN1_INTEGER
*serial
= NULL
;
538 ASN1_GENERALIZEDTIME
*asn1_time
= NULL
;
540 TS_ACCURACY
*accuracy
= NULL
;
541 const ASN1_INTEGER
*nonce
;
542 GENERAL_NAME
*tsa_name
= NULL
;
544 if ((tst_info
= TS_TST_INFO_new()) == NULL
)
546 if (!TS_TST_INFO_set_version(tst_info
, 1))
548 if (!TS_TST_INFO_set_policy_id(tst_info
, policy
))
550 if (!TS_TST_INFO_set_msg_imprint(tst_info
, ctx
->request
->msg_imprint
))
552 if ((serial
= ctx
->serial_cb(ctx
, ctx
->serial_cb_data
)) == NULL
553 || !TS_TST_INFO_set_serial(tst_info
, serial
))
555 if (!ctx
->time_cb(ctx
, ctx
->time_cb_data
, &sec
, &usec
)
557 TS_RESP_set_genTime_with_precision(NULL
, sec
, usec
,
558 ctx
->clock_precision_digits
)) == NULL
559 || !TS_TST_INFO_set_time(tst_info
, asn1_time
))
562 if ((ctx
->seconds
|| ctx
->millis
|| ctx
->micros
)
563 && (accuracy
= TS_ACCURACY_new()) == NULL
)
565 if (ctx
->seconds
&& !TS_ACCURACY_set_seconds(accuracy
, ctx
->seconds
))
567 if (ctx
->millis
&& !TS_ACCURACY_set_millis(accuracy
, ctx
->millis
))
569 if (ctx
->micros
&& !TS_ACCURACY_set_micros(accuracy
, ctx
->micros
))
571 if (accuracy
&& !TS_TST_INFO_set_accuracy(tst_info
, accuracy
))
574 if ((ctx
->flags
& TS_ORDERING
)
575 && !TS_TST_INFO_set_ordering(tst_info
, 1))
578 if ((nonce
= ctx
->request
->nonce
) != NULL
579 && !TS_TST_INFO_set_nonce(tst_info
, nonce
))
582 if (ctx
->flags
& TS_TSA_NAME
) {
583 if ((tsa_name
= GENERAL_NAME_new()) == NULL
)
585 tsa_name
->type
= GEN_DIRNAME
;
587 X509_NAME_dup(X509_get_subject_name(ctx
->signer_cert
));
588 if (!tsa_name
->d
.dirn
)
590 if (!TS_TST_INFO_set_tsa(tst_info
, tsa_name
))
597 TS_TST_INFO_free(tst_info
);
599 TSerr(TS_F_TS_RESP_CREATE_TST_INFO
, TS_R_TST_INFO_SETUP_ERROR
);
600 TS_RESP_CTX_set_status_info_cond(ctx
, TS_STATUS_REJECTION
,
601 "Error during TSTInfo "
604 GENERAL_NAME_free(tsa_name
);
605 TS_ACCURACY_free(accuracy
);
606 ASN1_GENERALIZEDTIME_free(asn1_time
);
607 ASN1_INTEGER_free(serial
);
612 /* Processing the extensions of the request. */
613 static int ts_RESP_process_extensions(TS_RESP_CTX
*ctx
)
615 STACK_OF(X509_EXTENSION
) *exts
= ctx
->request
->extensions
;
619 for (i
= 0; ok
&& i
< sk_X509_EXTENSION_num(exts
); ++i
) {
620 X509_EXTENSION
*ext
= sk_X509_EXTENSION_value(exts
, i
);
622 * The last argument was previously (void *)ctx->extension_cb,
623 * but ISO C doesn't permit converting a function pointer to void *.
624 * For lack of better information, I'm placing a NULL there instead.
625 * The callback can pick its own address out from the ctx anyway...
627 ok
= (*ctx
->extension_cb
) (ctx
, ext
, NULL
);
633 /* Functions for signing the TS_TST_INFO structure of the context. */
634 static int ts_RESP_sign(TS_RESP_CTX
*ctx
)
638 PKCS7_SIGNER_INFO
*si
;
639 STACK_OF(X509
) *certs
; /* Certificates to include in sc. */
640 ESS_SIGNING_CERT_V2
*sc2
= NULL
;
641 ESS_SIGNING_CERT
*sc
= NULL
;
646 if (!X509_check_private_key(ctx
->signer_cert
, ctx
->signer_key
)) {
647 TSerr(TS_F_TS_RESP_SIGN
, TS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE
);
651 if ((p7
= PKCS7_new()) == NULL
) {
652 TSerr(TS_F_TS_RESP_SIGN
, ERR_R_MALLOC_FAILURE
);
655 if (!PKCS7_set_type(p7
, NID_pkcs7_signed
))
657 if (!ASN1_INTEGER_set(p7
->d
.sign
->version
, 3))
660 if (ctx
->request
->cert_req
) {
661 PKCS7_add_certificate(p7
, ctx
->signer_cert
);
663 for (i
= 0; i
< sk_X509_num(ctx
->certs
); ++i
) {
664 X509
*cert
= sk_X509_value(ctx
->certs
, i
);
665 PKCS7_add_certificate(p7
, cert
);
670 if ((si
= PKCS7_add_signature(p7
, ctx
->signer_cert
,
671 ctx
->signer_key
, ctx
->signer_md
)) == NULL
) {
672 TSerr(TS_F_TS_RESP_SIGN
, TS_R_PKCS7_ADD_SIGNATURE_ERROR
);
676 oid
= OBJ_nid2obj(NID_id_smime_ct_TSTInfo
);
677 if (!PKCS7_add_signed_attribute(si
, NID_pkcs9_contentType
,
678 V_ASN1_OBJECT
, oid
)) {
679 TSerr(TS_F_TS_RESP_SIGN
, TS_R_PKCS7_ADD_SIGNED_ATTR_ERROR
);
683 certs
= ctx
->flags
& TS_ESS_CERT_ID_CHAIN
? ctx
->certs
: NULL
;
684 if (ctx
->ess_cert_id_digest
== EVP_sha1()) {
685 if ((sc
= ess_SIGNING_CERT_new_init(ctx
->signer_cert
, certs
)) == NULL
)
688 if (!ess_add_signing_cert(si
, sc
)) {
689 TSerr(TS_F_TS_RESP_SIGN
, TS_R_ESS_ADD_SIGNING_CERT_ERROR
);
693 sc2
= ess_signing_cert_v2_new_init(ctx
->ess_cert_id_digest
,
694 ctx
->signer_cert
, certs
);
698 if (!ess_add_signing_cert_v2(si
, sc2
)) {
699 TSerr(TS_F_TS_RESP_SIGN
, TS_R_ESS_ADD_SIGNING_CERT_V2_ERROR
);
704 if (!ts_TST_INFO_content_new(p7
))
706 if ((p7bio
= PKCS7_dataInit(p7
, NULL
)) == NULL
) {
707 TSerr(TS_F_TS_RESP_SIGN
, ERR_R_MALLOC_FAILURE
);
710 if (!i2d_TS_TST_INFO_bio(p7bio
, ctx
->tst_info
)) {
711 TSerr(TS_F_TS_RESP_SIGN
, TS_R_TS_DATASIGN
);
714 if (!PKCS7_dataFinal(p7
, p7bio
)) {
715 TSerr(TS_F_TS_RESP_SIGN
, TS_R_TS_DATASIGN
);
718 TS_RESP_set_tst_info(ctx
->response
, p7
, ctx
->tst_info
);
719 p7
= NULL
; /* Ownership is lost. */
720 ctx
->tst_info
= NULL
; /* Ownership is lost. */
725 TS_RESP_CTX_set_status_info_cond(ctx
, TS_STATUS_REJECTION
,
726 "Error during signature "
729 ESS_SIGNING_CERT_V2_free(sc2
);
730 ESS_SIGNING_CERT_free(sc
);
735 static ESS_SIGNING_CERT
*ess_SIGNING_CERT_new_init(X509
*signcert
,
736 STACK_OF(X509
) *certs
)
739 ESS_SIGNING_CERT
*sc
= NULL
;
742 if ((sc
= ESS_SIGNING_CERT_new()) == NULL
)
744 if (sc
->cert_ids
== NULL
745 && (sc
->cert_ids
= sk_ESS_CERT_ID_new_null()) == NULL
)
748 if ((cid
= ess_CERT_ID_new_init(signcert
, 0)) == NULL
749 || !sk_ESS_CERT_ID_push(sc
->cert_ids
, cid
))
751 for (i
= 0; i
< sk_X509_num(certs
); ++i
) {
752 X509
*cert
= sk_X509_value(certs
, i
);
753 if ((cid
= ess_CERT_ID_new_init(cert
, 1)) == NULL
754 || !sk_ESS_CERT_ID_push(sc
->cert_ids
, cid
))
760 ESS_SIGNING_CERT_free(sc
);
761 TSerr(TS_F_ESS_SIGNING_CERT_NEW_INIT
, ERR_R_MALLOC_FAILURE
);
765 static ESS_CERT_ID
*ess_CERT_ID_new_init(X509
*cert
, int issuer_needed
)
767 ESS_CERT_ID
*cid
= NULL
;
768 GENERAL_NAME
*name
= NULL
;
769 unsigned char cert_sha1
[SHA_DIGEST_LENGTH
];
771 /* Call for side-effect of computing hash and caching extensions */
772 X509_check_purpose(cert
, -1, 0);
773 if ((cid
= ESS_CERT_ID_new()) == NULL
)
775 X509_digest(cert
, EVP_sha1(), cert_sha1
, NULL
);
776 if (!ASN1_OCTET_STRING_set(cid
->hash
, cert_sha1
, SHA_DIGEST_LENGTH
))
779 /* Setting the issuer/serial if requested. */
781 if (cid
->issuer_serial
== NULL
782 && (cid
->issuer_serial
= ESS_ISSUER_SERIAL_new()) == NULL
)
784 if ((name
= GENERAL_NAME_new()) == NULL
)
786 name
->type
= GEN_DIRNAME
;
787 if ((name
->d
.dirn
= X509_NAME_dup(X509_get_issuer_name(cert
))) == NULL
)
789 if (!sk_GENERAL_NAME_push(cid
->issuer_serial
->issuer
, name
))
791 name
= NULL
; /* Ownership is lost. */
792 ASN1_INTEGER_free(cid
->issuer_serial
->serial
);
793 if (!(cid
->issuer_serial
->serial
=
794 ASN1_INTEGER_dup(X509_get_serialNumber(cert
))))
800 GENERAL_NAME_free(name
);
801 ESS_CERT_ID_free(cid
);
802 TSerr(TS_F_ESS_CERT_ID_NEW_INIT
, ERR_R_MALLOC_FAILURE
);
806 static int ts_TST_INFO_content_new(PKCS7
*p7
)
809 ASN1_OCTET_STRING
*octet_string
= NULL
;
811 /* Create new encapsulated NID_id_smime_ct_TSTInfo content. */
812 if ((ret
= PKCS7_new()) == NULL
)
814 if ((ret
->d
.other
= ASN1_TYPE_new()) == NULL
)
816 ret
->type
= OBJ_nid2obj(NID_id_smime_ct_TSTInfo
);
817 if ((octet_string
= ASN1_OCTET_STRING_new()) == NULL
)
819 ASN1_TYPE_set(ret
->d
.other
, V_ASN1_OCTET_STRING
, octet_string
);
822 /* Add encapsulated content to signed PKCS7 structure. */
823 if (!PKCS7_set_content(p7
, ret
))
828 ASN1_OCTET_STRING_free(octet_string
);
833 static int ess_add_signing_cert(PKCS7_SIGNER_INFO
*si
, ESS_SIGNING_CERT
*sc
)
835 ASN1_STRING
*seq
= NULL
;
836 unsigned char *p
, *pp
= NULL
;
839 len
= i2d_ESS_SIGNING_CERT(sc
, NULL
);
840 if ((pp
= OPENSSL_malloc(len
)) == NULL
) {
841 TSerr(TS_F_ESS_ADD_SIGNING_CERT
, ERR_R_MALLOC_FAILURE
);
845 i2d_ESS_SIGNING_CERT(sc
, &p
);
846 if ((seq
= ASN1_STRING_new()) == NULL
|| !ASN1_STRING_set(seq
, pp
, len
)) {
847 TSerr(TS_F_ESS_ADD_SIGNING_CERT
, ERR_R_MALLOC_FAILURE
);
852 return PKCS7_add_signed_attribute(si
,
853 NID_id_smime_aa_signingCertificate
,
854 V_ASN1_SEQUENCE
, seq
);
856 ASN1_STRING_free(seq
);
862 static ESS_SIGNING_CERT_V2
*ess_signing_cert_v2_new_init(const EVP_MD
*hash_alg
,
864 STACK_OF(X509
) *certs
)
866 ESS_CERT_ID_V2
*cid
= NULL
;
867 ESS_SIGNING_CERT_V2
*sc
= NULL
;
870 if ((sc
= ESS_SIGNING_CERT_V2_new()) == NULL
)
872 if ((cid
= ess_cert_id_v2_new_init(hash_alg
, signcert
, 0)) == NULL
)
874 if (!sk_ESS_CERT_ID_V2_push(sc
->cert_ids
, cid
))
878 for (i
= 0; i
< sk_X509_num(certs
); ++i
) {
879 X509
*cert
= sk_X509_value(certs
, i
);
881 if ((cid
= ess_cert_id_v2_new_init(hash_alg
, cert
, 1)) == NULL
)
883 if (!sk_ESS_CERT_ID_V2_push(sc
->cert_ids
, cid
))
890 ESS_SIGNING_CERT_V2_free(sc
);
891 ESS_CERT_ID_V2_free(cid
);
892 TSerr(TS_F_ESS_SIGNING_CERT_V2_NEW_INIT
, ERR_R_MALLOC_FAILURE
);
896 static ESS_CERT_ID_V2
*ess_cert_id_v2_new_init(const EVP_MD
*hash_alg
,
897 X509
*cert
, int issuer_needed
)
899 ESS_CERT_ID_V2
*cid
= NULL
;
900 GENERAL_NAME
*name
= NULL
;
901 unsigned char hash
[EVP_MAX_MD_SIZE
];
902 unsigned int hash_len
= sizeof(hash
);
903 X509_ALGOR
*alg
= NULL
;
905 memset(hash
, 0, sizeof(hash
));
907 if ((cid
= ESS_CERT_ID_V2_new()) == NULL
)
910 if (hash_alg
!= EVP_sha256()) {
911 alg
= X509_ALGOR_new();
914 X509_ALGOR_set_md(alg
, hash_alg
);
915 if (alg
->algorithm
== NULL
)
920 cid
->hash_alg
= NULL
;
923 if (!X509_digest(cert
, hash_alg
, hash
, &hash_len
))
926 if (!ASN1_OCTET_STRING_set(cid
->hash
, hash
, hash_len
))
930 if ((cid
->issuer_serial
= ESS_ISSUER_SERIAL_new()) == NULL
)
932 if ((name
= GENERAL_NAME_new()) == NULL
)
934 name
->type
= GEN_DIRNAME
;
935 if ((name
->d
.dirn
= X509_NAME_dup(X509_get_issuer_name(cert
))) == NULL
)
937 if (!sk_GENERAL_NAME_push(cid
->issuer_serial
->issuer
, name
))
939 name
= NULL
; /* Ownership is lost. */
940 ASN1_INTEGER_free(cid
->issuer_serial
->serial
);
941 cid
->issuer_serial
->serial
=
942 ASN1_INTEGER_dup(X509_get_serialNumber(cert
));
943 if (cid
->issuer_serial
->serial
== NULL
)
949 X509_ALGOR_free(alg
);
950 GENERAL_NAME_free(name
);
951 ESS_CERT_ID_V2_free(cid
);
952 TSerr(TS_F_ESS_CERT_ID_V2_NEW_INIT
, ERR_R_MALLOC_FAILURE
);
956 static int ess_add_signing_cert_v2(PKCS7_SIGNER_INFO
*si
,
957 ESS_SIGNING_CERT_V2
*sc
)
959 ASN1_STRING
*seq
= NULL
;
960 unsigned char *p
, *pp
= NULL
;
961 int len
= i2d_ESS_SIGNING_CERT_V2(sc
, NULL
);
963 if ((pp
= OPENSSL_malloc(len
)) == NULL
) {
964 TSerr(TS_F_ESS_ADD_SIGNING_CERT_V2
, ERR_R_MALLOC_FAILURE
);
969 i2d_ESS_SIGNING_CERT_V2(sc
, &p
);
970 if ((seq
= ASN1_STRING_new()) == NULL
|| !ASN1_STRING_set(seq
, pp
, len
)) {
971 TSerr(TS_F_ESS_ADD_SIGNING_CERT_V2
, ERR_R_MALLOC_FAILURE
);
977 return PKCS7_add_signed_attribute(si
,
978 NID_id_smime_aa_signingCertificateV2
,
979 V_ASN1_SEQUENCE
, seq
);
981 ASN1_STRING_free(seq
);
986 static ASN1_GENERALIZEDTIME
*TS_RESP_set_genTime_with_precision(
987 ASN1_GENERALIZEDTIME
*asn1_time
, long sec
, long usec
,
990 time_t time_sec
= (time_t)sec
;
991 struct tm
*tm
= NULL
;
992 char genTime_str
[17 + TS_MAX_CLOCK_PRECISION_DIGITS
];
993 char *p
= genTime_str
;
994 char *p_end
= genTime_str
+ sizeof(genTime_str
);
996 if (precision
> TS_MAX_CLOCK_PRECISION_DIGITS
)
999 if ((tm
= gmtime(&time_sec
)) == NULL
)
1003 * Put "genTime_str" in GeneralizedTime format. We work around the
1004 * restrictions imposed by rfc3280 (i.e. "GeneralizedTime values MUST
1005 * NOT include fractional seconds") and OpenSSL related functions to
1006 * meet the rfc3161 requirement: "GeneralizedTime syntax can include
1007 * fraction-of-second details".
1009 p
+= BIO_snprintf(p
, p_end
- p
,
1010 "%04d%02d%02d%02d%02d%02d",
1011 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
1012 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
1013 if (precision
> 0) {
1014 BIO_snprintf(p
, 2 + precision
, ".%06ld", usec
);
1018 * To make things a bit harder, X.690 | ISO/IEC 8825-1 provides the
1019 * following restrictions for a DER-encoding, which OpenSSL
1020 * (specifically ASN1_GENERALIZEDTIME_check() function) doesn't
1021 * support: "The encoding MUST terminate with a "Z" (which means
1022 * "Zulu" time). The decimal point element, if present, MUST be the
1023 * point option ".". The fractional-seconds elements, if present,
1024 * MUST omit all trailing 0's; if the elements correspond to 0, they
1025 * MUST be wholly omitted, and the decimal point element also MUST be
1029 * Remove trailing zeros. The dot guarantees the exit condition of
1030 * this loop even if all the digits are zero.
1040 if (asn1_time
== NULL
1041 && (asn1_time
= ASN1_GENERALIZEDTIME_new()) == NULL
)
1043 if (!ASN1_GENERALIZEDTIME_set_string(asn1_time
, genTime_str
)) {
1044 ASN1_GENERALIZEDTIME_free(asn1_time
);
1050 TSerr(TS_F_TS_RESP_SET_GENTIME_WITH_PRECISION
, TS_R_COULD_NOT_SET_TIME
);
1054 int TS_RESP_CTX_set_ess_cert_id_digest(TS_RESP_CTX
*ctx
, const EVP_MD
*md
)
1056 ctx
->ess_cert_id_digest
= md
;