Branch data Line data Source code
1 : : /* crypto/ts/ts_resp_utils.c */
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 : : #include "cryptlib.h"
61 : : #include <openssl/objects.h>
62 : : #include <openssl/ts.h>
63 : : #include <openssl/pkcs7.h>
64 : :
65 : : /* Function definitions. */
66 : :
67 : 5 : int TS_RESP_set_status_info(TS_RESP *a, TS_STATUS_INFO *status_info)
68 : : {
69 : : TS_STATUS_INFO *new_status_info;
70 : :
71 [ + - ]: 5 : if (a->status_info == status_info)
72 : : return 1;
73 : 5 : new_status_info = TS_STATUS_INFO_dup(status_info);
74 [ - + ]: 5 : if (new_status_info == NULL)
75 : : {
76 : 0 : TSerr(TS_F_TS_RESP_SET_STATUS_INFO, ERR_R_MALLOC_FAILURE);
77 : 0 : return 0;
78 : : }
79 : 5 : TS_STATUS_INFO_free(a->status_info);
80 : 5 : a->status_info = new_status_info;
81 : :
82 : 5 : return 1;
83 : : }
84 : :
85 : 9 : TS_STATUS_INFO *TS_RESP_get_status_info(TS_RESP *a)
86 : : {
87 : 9 : return a->status_info;
88 : : }
89 : :
90 : : /* Caller loses ownership of PKCS7 and TS_TST_INFO objects. */
91 : 5 : void TS_RESP_set_tst_info(TS_RESP *a, PKCS7 *p7, TS_TST_INFO *tst_info)
92 : : {
93 : : /* Set new PKCS7 and TST_INFO objects. */
94 : 5 : PKCS7_free(a->token);
95 : 5 : a->token = p7;
96 : 5 : TS_TST_INFO_free(a->tst_info);
97 : 5 : a->tst_info = tst_info;
98 : 5 : }
99 : :
100 : 9 : PKCS7 *TS_RESP_get_token(TS_RESP *a)
101 : : {
102 : 9 : return a->token;
103 : : }
104 : :
105 : 14 : TS_TST_INFO *TS_RESP_get_tst_info(TS_RESP *a)
106 : : {
107 : 14 : return a->tst_info;
108 : : }
109 : :
110 : 3 : int TS_TST_INFO_set_version(TS_TST_INFO *a, long version)
111 : : {
112 : 3 : return ASN1_INTEGER_set(a->version, version);
113 : : }
114 : :
115 : 14 : long TS_TST_INFO_get_version(const TS_TST_INFO *a)
116 : : {
117 : 14 : return ASN1_INTEGER_get(a->version);
118 : : }
119 : :
120 : 3 : int TS_TST_INFO_set_policy_id(TS_TST_INFO *a, ASN1_OBJECT *policy)
121 : : {
122 : : ASN1_OBJECT *new_policy;
123 : :
124 [ + - ]: 3 : if (a->policy_id == policy)
125 : : return 1;
126 : 3 : new_policy = OBJ_dup(policy);
127 [ - + ]: 3 : if (new_policy == NULL)
128 : : {
129 : 0 : TSerr(TS_F_TS_TST_INFO_SET_POLICY_ID, ERR_R_MALLOC_FAILURE);
130 : 0 : return 0;
131 : : }
132 : 3 : ASN1_OBJECT_free(a->policy_id);
133 : 3 : a->policy_id = new_policy;
134 : 3 : return 1;
135 : : }
136 : :
137 : 10 : ASN1_OBJECT *TS_TST_INFO_get_policy_id(TS_TST_INFO *a)
138 : : {
139 : 10 : return a->policy_id;
140 : : }
141 : :
142 : 3 : 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 [ + - ]: 3 : if (a->msg_imprint == msg_imprint)
147 : : return 1;
148 : 3 : new_msg_imprint = TS_MSG_IMPRINT_dup(msg_imprint);
149 [ - + ]: 3 : if (new_msg_imprint == NULL)
150 : : {
151 : 0 : TSerr(TS_F_TS_TST_INFO_SET_MSG_IMPRINT, ERR_R_MALLOC_FAILURE);
152 : 0 : return 0;
153 : : }
154 : 3 : TS_MSG_IMPRINT_free(a->msg_imprint);
155 : 3 : a->msg_imprint = new_msg_imprint;
156 : 3 : return 1;
157 : : }
158 : :
159 : 15 : TS_MSG_IMPRINT *TS_TST_INFO_get_msg_imprint(TS_TST_INFO *a)
160 : : {
161 : 15 : return a->msg_imprint;
162 : : }
163 : :
164 : 3 : int TS_TST_INFO_set_serial(TS_TST_INFO *a, const ASN1_INTEGER *serial)
165 : : {
166 : : ASN1_INTEGER *new_serial;
167 : :
168 [ + - ]: 3 : if (a->serial == serial)
169 : : return 1;
170 : 3 : new_serial = ASN1_INTEGER_dup(serial);
171 [ - + ]: 3 : if (new_serial == NULL)
172 : : {
173 : 0 : TSerr(TS_F_TS_TST_INFO_SET_SERIAL, ERR_R_MALLOC_FAILURE);
174 : 0 : return 0;
175 : : }
176 : 3 : ASN1_INTEGER_free(a->serial);
177 : 3 : a->serial = new_serial;
178 : 3 : return 1;
179 : : }
180 : :
181 : 5 : const ASN1_INTEGER *TS_TST_INFO_get_serial(const TS_TST_INFO *a)
182 : : {
183 : 5 : return a->serial;
184 : : }
185 : :
186 : 3 : int TS_TST_INFO_set_time(TS_TST_INFO *a, const ASN1_GENERALIZEDTIME *gtime)
187 : : {
188 : : ASN1_GENERALIZEDTIME *new_time;
189 : :
190 [ + - ]: 3 : if (a->time == gtime)
191 : : return 1;
192 : 3 : new_time = M_ASN1_GENERALIZEDTIME_dup(gtime);
193 [ - + ]: 3 : if (new_time == NULL)
194 : : {
195 : 0 : TSerr(TS_F_TS_TST_INFO_SET_TIME, ERR_R_MALLOC_FAILURE);
196 : 0 : return 0;
197 : : }
198 : 3 : ASN1_GENERALIZEDTIME_free(a->time);
199 : 3 : a->time = new_time;
200 : 3 : return 1;
201 : : }
202 : :
203 : 5 : const ASN1_GENERALIZEDTIME *TS_TST_INFO_get_time(const TS_TST_INFO *a)
204 : : {
205 : 5 : return a->time;
206 : : }
207 : :
208 : 3 : int TS_TST_INFO_set_accuracy(TS_TST_INFO *a, TS_ACCURACY *accuracy)
209 : : {
210 : : TS_ACCURACY *new_accuracy;
211 : :
212 [ + - ]: 3 : if (a->accuracy == accuracy)
213 : : return 1;
214 : 3 : new_accuracy = TS_ACCURACY_dup(accuracy);
215 [ - + ]: 3 : if (new_accuracy == NULL)
216 : : {
217 : 0 : TSerr(TS_F_TS_TST_INFO_SET_ACCURACY, ERR_R_MALLOC_FAILURE);
218 : 0 : return 0;
219 : : }
220 : 3 : TS_ACCURACY_free(a->accuracy);
221 : 3 : a->accuracy = new_accuracy;
222 : 3 : return 1;
223 : : }
224 : :
225 : 5 : TS_ACCURACY *TS_TST_INFO_get_accuracy(TS_TST_INFO *a)
226 : : {
227 : 5 : return a->accuracy;
228 : : }
229 : :
230 : 3 : int TS_ACCURACY_set_seconds(TS_ACCURACY *a, const ASN1_INTEGER *seconds)
231 : : {
232 : : ASN1_INTEGER *new_seconds;
233 : :
234 [ + - ]: 3 : if (a->seconds == seconds)
235 : : return 1;
236 : 3 : new_seconds = ASN1_INTEGER_dup(seconds);
237 [ - + ]: 3 : if (new_seconds == NULL)
238 : : {
239 : 0 : TSerr(TS_F_TS_ACCURACY_SET_SECONDS, ERR_R_MALLOC_FAILURE);
240 : 0 : return 0;
241 : : }
242 : 3 : ASN1_INTEGER_free(a->seconds);
243 : 3 : a->seconds = new_seconds;
244 : 3 : return 1;
245 : : }
246 : :
247 : 5 : const ASN1_INTEGER *TS_ACCURACY_get_seconds(const TS_ACCURACY *a)
248 : : {
249 : 5 : return a->seconds;
250 : : }
251 : :
252 : 3 : int TS_ACCURACY_set_millis(TS_ACCURACY *a, const ASN1_INTEGER *millis)
253 : : {
254 : 3 : ASN1_INTEGER *new_millis = NULL;
255 : :
256 [ + - ]: 3 : if (a->millis == millis)
257 : : return 1;
258 [ + - ]: 3 : if (millis != NULL)
259 : : {
260 : 3 : new_millis = ASN1_INTEGER_dup(millis);
261 [ - + ]: 3 : if (new_millis == NULL)
262 : : {
263 : 0 : TSerr(TS_F_TS_ACCURACY_SET_MILLIS,
264 : : ERR_R_MALLOC_FAILURE);
265 : 0 : return 0;
266 : : }
267 : : }
268 : 3 : ASN1_INTEGER_free(a->millis);
269 : 3 : a->millis = new_millis;
270 : 3 : return 1;
271 : : }
272 : :
273 : 5 : const ASN1_INTEGER *TS_ACCURACY_get_millis(const TS_ACCURACY *a)
274 : : {
275 : 5 : return a->millis;
276 : : }
277 : :
278 : 3 : int TS_ACCURACY_set_micros(TS_ACCURACY *a, const ASN1_INTEGER *micros)
279 : : {
280 : 3 : ASN1_INTEGER *new_micros = NULL;
281 : :
282 [ + - ]: 3 : if (a->micros == micros)
283 : : return 1;
284 [ + - ]: 3 : if (micros != NULL)
285 : : {
286 : 3 : new_micros = ASN1_INTEGER_dup(micros);
287 [ - + ]: 3 : if (new_micros == NULL)
288 : : {
289 : 0 : TSerr(TS_F_TS_ACCURACY_SET_MICROS,
290 : : ERR_R_MALLOC_FAILURE);
291 : 0 : return 0;
292 : : }
293 : : }
294 : 3 : ASN1_INTEGER_free(a->micros);
295 : 3 : a->micros = new_micros;
296 : 3 : return 1;
297 : : }
298 : :
299 : 5 : const ASN1_INTEGER *TS_ACCURACY_get_micros(const TS_ACCURACY *a)
300 : : {
301 : 5 : return a->micros;
302 : : }
303 : :
304 : 3 : int TS_TST_INFO_set_ordering(TS_TST_INFO *a, int ordering)
305 : : {
306 [ - + ]: 3 : a->ordering = ordering ? 0xFF : 0x00;
307 : 3 : return 1;
308 : : }
309 : :
310 : 5 : int TS_TST_INFO_get_ordering(const TS_TST_INFO *a)
311 : : {
312 : 5 : return a->ordering ? 1 : 0;
313 : : }
314 : :
315 : 1 : int TS_TST_INFO_set_nonce(TS_TST_INFO *a, const ASN1_INTEGER *nonce)
316 : : {
317 : : ASN1_INTEGER *new_nonce;
318 : :
319 [ + - ]: 1 : if (a->nonce == nonce)
320 : : return 1;
321 : 1 : new_nonce = ASN1_INTEGER_dup(nonce);
322 [ - + ]: 1 : if (new_nonce == NULL)
323 : : {
324 : 0 : TSerr(TS_F_TS_TST_INFO_SET_NONCE, ERR_R_MALLOC_FAILURE);
325 : 0 : return 0;
326 : : }
327 : 1 : ASN1_INTEGER_free(a->nonce);
328 : 1 : a->nonce = new_nonce;
329 : 1 : return 1;
330 : : }
331 : :
332 : 7 : const ASN1_INTEGER *TS_TST_INFO_get_nonce(const TS_TST_INFO *a)
333 : : {
334 : 7 : return a->nonce;
335 : : }
336 : :
337 : 3 : int TS_TST_INFO_set_tsa(TS_TST_INFO *a, GENERAL_NAME *tsa)
338 : : {
339 : : GENERAL_NAME *new_tsa;
340 : :
341 [ + - ]: 3 : if (a->tsa == tsa)
342 : : return 1;
343 : 3 : new_tsa = GENERAL_NAME_dup(tsa);
344 [ - + ]: 3 : if (new_tsa == NULL)
345 : : {
346 : 0 : TSerr(TS_F_TS_TST_INFO_SET_TSA, ERR_R_MALLOC_FAILURE);
347 : 0 : return 0;
348 : : }
349 : 3 : GENERAL_NAME_free(a->tsa);
350 : 3 : a->tsa = new_tsa;
351 : 3 : return 1;
352 : : }
353 : :
354 : 14 : GENERAL_NAME *TS_TST_INFO_get_tsa(TS_TST_INFO *a)
355 : : {
356 : 14 : return a->tsa;
357 : : }
358 : :
359 : 5 : STACK_OF(X509_EXTENSION) *TS_TST_INFO_get_exts(TS_TST_INFO *a)
360 : : {
361 : 5 : return a->extensions;
362 : : }
363 : :
364 : 0 : void TS_TST_INFO_ext_free(TS_TST_INFO *a)
365 : : {
366 [ # # ]: 0 : if (!a) return;
367 : 0 : sk_X509_EXTENSION_pop_free(a->extensions, X509_EXTENSION_free);
368 : 0 : a->extensions = NULL;
369 : : }
370 : :
371 : 0 : int TS_TST_INFO_get_ext_count(TS_TST_INFO *a)
372 : : {
373 : 0 : return X509v3_get_ext_count(a->extensions);
374 : : }
375 : :
376 : 0 : int TS_TST_INFO_get_ext_by_NID(TS_TST_INFO *a, int nid, int lastpos)
377 : : {
378 : 0 : return X509v3_get_ext_by_NID(a->extensions, nid, lastpos);
379 : : }
380 : :
381 : 0 : int TS_TST_INFO_get_ext_by_OBJ(TS_TST_INFO *a, ASN1_OBJECT *obj, int lastpos)
382 : : {
383 : 0 : return X509v3_get_ext_by_OBJ(a->extensions, obj, lastpos);
384 : : }
385 : :
386 : 0 : int TS_TST_INFO_get_ext_by_critical(TS_TST_INFO *a, int crit, int lastpos)
387 : : {
388 : 0 : return X509v3_get_ext_by_critical(a->extensions, crit, lastpos);
389 : : }
390 : :
391 : 0 : X509_EXTENSION *TS_TST_INFO_get_ext(TS_TST_INFO *a, int loc)
392 : : {
393 : 0 : return X509v3_get_ext(a->extensions,loc);
394 : : }
395 : :
396 : 0 : X509_EXTENSION *TS_TST_INFO_delete_ext(TS_TST_INFO *a, int loc)
397 : : {
398 : 0 : return X509v3_delete_ext(a->extensions,loc);
399 : : }
400 : :
401 : 0 : int TS_TST_INFO_add_ext(TS_TST_INFO *a, X509_EXTENSION *ex, int loc)
402 : : {
403 : 0 : return X509v3_add_ext(&a->extensions,ex,loc) != NULL;
404 : : }
405 : :
406 : 0 : void *TS_TST_INFO_get_ext_d2i(TS_TST_INFO *a, int nid, int *crit, int *idx)
407 : : {
408 : 0 : return X509V3_get_d2i(a->extensions, nid, crit, idx);
409 : : }
|
