OpenCoverage

ts_asn1.c

Absolute File Name:/home/opencoverage/opencoverage/guest-scripts/libressl/src/crypto/ts/ts_asn1.c
Source codeSwitch to Preprocessed file
LineSourceCount
1/* $OpenBSD: ts_asn1.c,v 1.11 2017/01/29 17:49:23 beck 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-
64static const ASN1_TEMPLATE TS_MSG_IMPRINT_seq_tt[] = {-
65 {-
66 .flags = 0,-
67 .tag = 0,-
68 .offset = offsetof(TS_MSG_IMPRINT, hash_algo),-
69 .field_name = "hash_algo",-
70 .item = &X509_ALGOR_it,-
71 },-
72 {-
73 .flags = 0,-
74 .tag = 0,-
75 .offset = offsetof(TS_MSG_IMPRINT, hashed_msg),-
76 .field_name = "hashed_msg",-
77 .item = &ASN1_OCTET_STRING_it,-
78 },-
79};-
80-
81const ASN1_ITEM TS_MSG_IMPRINT_it = {-
82 .itype = ASN1_ITYPE_SEQUENCE,-
83 .utype = V_ASN1_SEQUENCE,-
84 .templates = TS_MSG_IMPRINT_seq_tt,-
85 .tcount = sizeof(TS_MSG_IMPRINT_seq_tt) / sizeof(ASN1_TEMPLATE),-
86 .funcs = NULL,-
87 .size = sizeof(TS_MSG_IMPRINT),-
88 .sname = "TS_MSG_IMPRINT",-
89};-
90-
91-
92TS_MSG_IMPRINT *-
93d2i_TS_MSG_IMPRINT(TS_MSG_IMPRINT **a, const unsigned char **in, long len)-
94{-
95 return (TS_MSG_IMPRINT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
never executed: return (TS_MSG_IMPRINT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_MSG_IMPRINT_it);
0
96 &TS_MSG_IMPRINT_it);
never executed: return (TS_MSG_IMPRINT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_MSG_IMPRINT_it);
0
97}-
98-
99int-
100i2d_TS_MSG_IMPRINT(const TS_MSG_IMPRINT *a, unsigned char **out)-
101{-
102 return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_MSG_IMPRINT_it);
never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_MSG_IMPRINT_it);
0
103}-
104-
105TS_MSG_IMPRINT *-
106TS_MSG_IMPRINT_new(void)-
107{-
108 return (TS_MSG_IMPRINT *)ASN1_item_new(&TS_MSG_IMPRINT_it);
never executed: return (TS_MSG_IMPRINT *)ASN1_item_new(&TS_MSG_IMPRINT_it);
0
109}-
110-
111void-
112TS_MSG_IMPRINT_free(TS_MSG_IMPRINT *a)-
113{-
114 ASN1_item_free((ASN1_VALUE *)a, &TS_MSG_IMPRINT_it);-
115}
executed 1 time by 1 test: end of block
Executed by:
  • freenull
1
116-
117TS_MSG_IMPRINT *-
118TS_MSG_IMPRINT_dup(TS_MSG_IMPRINT *x)-
119{-
120 return ASN1_item_dup(&TS_MSG_IMPRINT_it, x);
never executed: return ASN1_item_dup(&TS_MSG_IMPRINT_it, x);
0
121}-
122-
123#ifndef OPENSSL_NO_BIO-
124TS_MSG_IMPRINT *-
125d2i_TS_MSG_IMPRINT_bio(BIO *bp, TS_MSG_IMPRINT **a)-
126{-
127 return ASN1_item_d2i_bio(&TS_MSG_IMPRINT_it, bp, a);
never executed: return ASN1_item_d2i_bio(&TS_MSG_IMPRINT_it, bp, a);
0
128}-
129-
130int-
131i2d_TS_MSG_IMPRINT_bio(BIO *bp, TS_MSG_IMPRINT *a)-
132{-
133 return ASN1_item_i2d_bio(&TS_MSG_IMPRINT_it, bp, a);
never executed: return ASN1_item_i2d_bio(&TS_MSG_IMPRINT_it, bp, a);
0
134}-
135#endif-
136-
137TS_MSG_IMPRINT *-
138d2i_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT **a)-
139{-
140 return ASN1_item_d2i_fp(&TS_MSG_IMPRINT_it, fp, a);
never executed: return ASN1_item_d2i_fp(&TS_MSG_IMPRINT_it, fp, a);
0
141}-
142-
143int-
144i2d_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT *a)-
145{-
146 return ASN1_item_i2d_fp(&TS_MSG_IMPRINT_it, fp, a);
never executed: return ASN1_item_i2d_fp(&TS_MSG_IMPRINT_it, fp, a);
0
147}-
148-
149static const ASN1_TEMPLATE TS_REQ_seq_tt[] = {-
150 {-
151 .flags = 0,-
152 .tag = 0,-
153 .offset = offsetof(TS_REQ, version),-
154 .field_name = "version",-
155 .item = &ASN1_INTEGER_it,-
156 },-
157 {-
158 .flags = 0,-
159 .tag = 0,-
160 .offset = offsetof(TS_REQ, msg_imprint),-
161 .field_name = "msg_imprint",-
162 .item = &TS_MSG_IMPRINT_it,-
163 },-
164 {-
165 .flags = ASN1_TFLG_OPTIONAL,-
166 .tag = 0,-
167 .offset = offsetof(TS_REQ, policy_id),-
168 .field_name = "policy_id",-
169 .item = &ASN1_OBJECT_it,-
170 },-
171 {-
172 .flags = ASN1_TFLG_OPTIONAL,-
173 .tag = 0,-
174 .offset = offsetof(TS_REQ, nonce),-
175 .field_name = "nonce",-
176 .item = &ASN1_INTEGER_it,-
177 },-
178 {-
179 .flags = ASN1_TFLG_OPTIONAL,-
180 .tag = 0,-
181 .offset = offsetof(TS_REQ, cert_req),-
182 .field_name = "cert_req",-
183 .item = &ASN1_FBOOLEAN_it,-
184 },-
185 {-
186 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,-
187 .tag = 0,-
188 .offset = offsetof(TS_REQ, extensions),-
189 .field_name = "extensions",-
190 .item = &X509_EXTENSION_it,-
191 },-
192};-
193-
194const ASN1_ITEM TS_REQ_it = {-
195 .itype = ASN1_ITYPE_SEQUENCE,-
196 .utype = V_ASN1_SEQUENCE,-
197 .templates = TS_REQ_seq_tt,-
198 .tcount = sizeof(TS_REQ_seq_tt) / sizeof(ASN1_TEMPLATE),-
199 .funcs = NULL,-
200 .size = sizeof(TS_REQ),-
201 .sname = "TS_REQ",-
202};-
203-
204-
205TS_REQ *-
206d2i_TS_REQ(TS_REQ **a, const unsigned char **in, long len)-
207{-
208 return (TS_REQ *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
never executed: return (TS_REQ *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_REQ_it);
0
209 &TS_REQ_it);
never executed: return (TS_REQ *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_REQ_it);
0
210}-
211-
212int-
213i2d_TS_REQ(const TS_REQ *a, unsigned char **out)-
214{-
215 return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_REQ_it);
never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_REQ_it);
0
216}-
217-
218TS_REQ *-
219TS_REQ_new(void)-
220{-
221 return (TS_REQ *)ASN1_item_new(&TS_REQ_it);
never executed: return (TS_REQ *)ASN1_item_new(&TS_REQ_it);
0
222}-
223-
224void-
225TS_REQ_free(TS_REQ *a)-
226{-
227 ASN1_item_free((ASN1_VALUE *)a, &TS_REQ_it);-
228}
executed 1 time by 1 test: end of block
Executed by:
  • freenull
1
229-
230TS_REQ *-
231TS_REQ_dup(TS_REQ *x)-
232{-
233 return ASN1_item_dup(&TS_REQ_it, x);
never executed: return ASN1_item_dup(&TS_REQ_it, x);
0
234}-
235-
236#ifndef OPENSSL_NO_BIO-
237TS_REQ *-
238d2i_TS_REQ_bio(BIO *bp, TS_REQ **a)-
239{-
240 return ASN1_item_d2i_bio(&TS_REQ_it, bp, a);
never executed: return ASN1_item_d2i_bio(&TS_REQ_it, bp, a);
0
241}-
242-
243int-
244i2d_TS_REQ_bio(BIO *bp, TS_REQ *a)-
245{-
246 return ASN1_item_i2d_bio(&TS_REQ_it, bp, a);
never executed: return ASN1_item_i2d_bio(&TS_REQ_it, bp, a);
0
247}-
248#endif-
249-
250TS_REQ *-
251d2i_TS_REQ_fp(FILE *fp, TS_REQ **a)-
252{-
253 return ASN1_item_d2i_fp(&TS_REQ_it, fp, a);
never executed: return ASN1_item_d2i_fp(&TS_REQ_it, fp, a);
0
254}-
255-
256int-
257i2d_TS_REQ_fp(FILE *fp, TS_REQ *a)-
258{-
259 return ASN1_item_i2d_fp(&TS_REQ_it, fp, a);
never executed: return ASN1_item_i2d_fp(&TS_REQ_it, fp, a);
0
260}-
261-
262static const ASN1_TEMPLATE TS_ACCURACY_seq_tt[] = {-
263 {-
264 .flags = ASN1_TFLG_OPTIONAL,-
265 .tag = 0,-
266 .offset = offsetof(TS_ACCURACY, seconds),-
267 .field_name = "seconds",-
268 .item = &ASN1_INTEGER_it,-
269 },-
270 {-
271 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_OPTIONAL,-
272 .tag = 0,-
273 .offset = offsetof(TS_ACCURACY, millis),-
274 .field_name = "millis",-
275 .item = &ASN1_INTEGER_it,-
276 },-
277 {-
278 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_OPTIONAL,-
279 .tag = 1,-
280 .offset = offsetof(TS_ACCURACY, micros),-
281 .field_name = "micros",-
282 .item = &ASN1_INTEGER_it,-
283 },-
284};-
285-
286const ASN1_ITEM TS_ACCURACY_it = {-
287 .itype = ASN1_ITYPE_SEQUENCE,-
288 .utype = V_ASN1_SEQUENCE,-
289 .templates = TS_ACCURACY_seq_tt,-
290 .tcount = sizeof(TS_ACCURACY_seq_tt) / sizeof(ASN1_TEMPLATE),-
291 .funcs = NULL,-
292 .size = sizeof(TS_ACCURACY),-
293 .sname = "TS_ACCURACY",-
294};-
295-
296-
297TS_ACCURACY *-
298d2i_TS_ACCURACY(TS_ACCURACY **a, const unsigned char **in, long len)-
299{-
300 return (TS_ACCURACY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
never executed: return (TS_ACCURACY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_ACCURACY_it);
0
301 &TS_ACCURACY_it);
never executed: return (TS_ACCURACY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_ACCURACY_it);
0
302}-
303-
304int-
305i2d_TS_ACCURACY(const TS_ACCURACY *a, unsigned char **out)-
306{-
307 return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_ACCURACY_it);
never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_ACCURACY_it);
0
308}-
309-
310TS_ACCURACY *-
311TS_ACCURACY_new(void)-
312{-
313 return (TS_ACCURACY *)ASN1_item_new(&TS_ACCURACY_it);
never executed: return (TS_ACCURACY *)ASN1_item_new(&TS_ACCURACY_it);
0
314}-
315-
316void-
317TS_ACCURACY_free(TS_ACCURACY *a)-
318{-
319 ASN1_item_free((ASN1_VALUE *)a, &TS_ACCURACY_it);-
320}
executed 1 time by 1 test: end of block
Executed by:
  • freenull
1
321-
322TS_ACCURACY *-
323TS_ACCURACY_dup(TS_ACCURACY *x)-
324{-
325 return ASN1_item_dup(&TS_ACCURACY_it, x);
never executed: return ASN1_item_dup(&TS_ACCURACY_it, x);
0
326}-
327-
328static const ASN1_TEMPLATE TS_TST_INFO_seq_tt[] = {-
329 {-
330 .flags = 0,-
331 .tag = 0,-
332 .offset = offsetof(TS_TST_INFO, version),-
333 .field_name = "version",-
334 .item = &ASN1_INTEGER_it,-
335 },-
336 {-
337 .flags = 0,-
338 .tag = 0,-
339 .offset = offsetof(TS_TST_INFO, policy_id),-
340 .field_name = "policy_id",-
341 .item = &ASN1_OBJECT_it,-
342 },-
343 {-
344 .flags = 0,-
345 .tag = 0,-
346 .offset = offsetof(TS_TST_INFO, msg_imprint),-
347 .field_name = "msg_imprint",-
348 .item = &TS_MSG_IMPRINT_it,-
349 },-
350 {-
351 .flags = 0,-
352 .tag = 0,-
353 .offset = offsetof(TS_TST_INFO, serial),-
354 .field_name = "serial",-
355 .item = &ASN1_INTEGER_it,-
356 },-
357 {-
358 .flags = 0,-
359 .tag = 0,-
360 .offset = offsetof(TS_TST_INFO, time),-
361 .field_name = "time",-
362 .item = &ASN1_GENERALIZEDTIME_it,-
363 },-
364 {-
365 .flags = ASN1_TFLG_OPTIONAL,-
366 .tag = 0,-
367 .offset = offsetof(TS_TST_INFO, accuracy),-
368 .field_name = "accuracy",-
369 .item = &TS_ACCURACY_it,-
370 },-
371 {-
372 .flags = ASN1_TFLG_OPTIONAL,-
373 .tag = 0,-
374 .offset = offsetof(TS_TST_INFO, ordering),-
375 .field_name = "ordering",-
376 .item = &ASN1_FBOOLEAN_it,-
377 },-
378 {-
379 .flags = ASN1_TFLG_OPTIONAL,-
380 .tag = 0,-
381 .offset = offsetof(TS_TST_INFO, nonce),-
382 .field_name = "nonce",-
383 .item = &ASN1_INTEGER_it,-
384 },-
385 {-
386 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,-
387 .tag = 0,-
388 .offset = offsetof(TS_TST_INFO, tsa),-
389 .field_name = "tsa",-
390 .item = &GENERAL_NAME_it,-
391 },-
392 {-
393 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,-
394 .tag = 1,-
395 .offset = offsetof(TS_TST_INFO, extensions),-
396 .field_name = "extensions",-
397 .item = &X509_EXTENSION_it,-
398 },-
399};-
400-
401const ASN1_ITEM TS_TST_INFO_it = {-
402 .itype = ASN1_ITYPE_SEQUENCE,-
403 .utype = V_ASN1_SEQUENCE,-
404 .templates = TS_TST_INFO_seq_tt,-
405 .tcount = sizeof(TS_TST_INFO_seq_tt) / sizeof(ASN1_TEMPLATE),-
406 .funcs = NULL,-
407 .size = sizeof(TS_TST_INFO),-
408 .sname = "TS_TST_INFO",-
409};-
410-
411-
412TS_TST_INFO *-
413d2i_TS_TST_INFO(TS_TST_INFO **a, const unsigned char **in, long len)-
414{-
415 return (TS_TST_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
never executed: return (TS_TST_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_TST_INFO_it);
0
416 &TS_TST_INFO_it);
never executed: return (TS_TST_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_TST_INFO_it);
0
417}-
418-
419int-
420i2d_TS_TST_INFO(const TS_TST_INFO *a, unsigned char **out)-
421{-
422 return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_TST_INFO_it);
never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_TST_INFO_it);
0
423}-
424-
425TS_TST_INFO *-
426TS_TST_INFO_new(void)-
427{-
428 return (TS_TST_INFO *)ASN1_item_new(&TS_TST_INFO_it);
never executed: return (TS_TST_INFO *)ASN1_item_new(&TS_TST_INFO_it);
0
429}-
430-
431void-
432TS_TST_INFO_free(TS_TST_INFO *a)-
433{-
434 ASN1_item_free((ASN1_VALUE *)a, &TS_TST_INFO_it);-
435}
executed 1 time by 1 test: end of block
Executed by:
  • freenull
1
436-
437TS_TST_INFO *-
438TS_TST_INFO_dup(TS_TST_INFO *x)-
439{-
440 return ASN1_item_dup(&TS_TST_INFO_it, x);
never executed: return ASN1_item_dup(&TS_TST_INFO_it, x);
0
441}-
442-
443#ifndef OPENSSL_NO_BIO-
444TS_TST_INFO *-
445d2i_TS_TST_INFO_bio(BIO *bp, TS_TST_INFO **a)-
446{-
447 return ASN1_item_d2i_bio(&TS_TST_INFO_it, bp, a);
never executed: return ASN1_item_d2i_bio(&TS_TST_INFO_it, bp, a);
0
448}-
449-
450int-
451i2d_TS_TST_INFO_bio(BIO *bp, TS_TST_INFO *a)-
452{-
453 return ASN1_item_i2d_bio(&TS_TST_INFO_it, bp, a);
never executed: return ASN1_item_i2d_bio(&TS_TST_INFO_it, bp, a);
0
454}-
455#endif-
456-
457TS_TST_INFO *-
458d2i_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO **a)-
459{-
460 return ASN1_item_d2i_fp(&TS_TST_INFO_it, fp, a);
never executed: return ASN1_item_d2i_fp(&TS_TST_INFO_it, fp, a);
0
461}-
462-
463int-
464i2d_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO *a)-
465{-
466 return ASN1_item_i2d_fp(&TS_TST_INFO_it, fp, a);
never executed: return ASN1_item_i2d_fp(&TS_TST_INFO_it, fp, a);
0
467}-
468-
469static const ASN1_TEMPLATE TS_STATUS_INFO_seq_tt[] = {-
470 {-
471 .flags = 0,-
472 .tag = 0,-
473 .offset = offsetof(TS_STATUS_INFO, status),-
474 .field_name = "status",-
475 .item = &ASN1_INTEGER_it,-
476 },-
477 {-
478 .flags = ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,-
479 .tag = 0,-
480 .offset = offsetof(TS_STATUS_INFO, text),-
481 .field_name = "text",-
482 .item = &ASN1_UTF8STRING_it,-
483 },-
484 {-
485 .flags = ASN1_TFLG_OPTIONAL,-
486 .tag = 0,-
487 .offset = offsetof(TS_STATUS_INFO, failure_info),-
488 .field_name = "failure_info",-
489 .item = &ASN1_BIT_STRING_it,-
490 },-
491};-
492-
493const ASN1_ITEM TS_STATUS_INFO_it = {-
494 .itype = ASN1_ITYPE_SEQUENCE,-
495 .utype = V_ASN1_SEQUENCE,-
496 .templates = TS_STATUS_INFO_seq_tt,-
497 .tcount = sizeof(TS_STATUS_INFO_seq_tt) / sizeof(ASN1_TEMPLATE),-
498 .funcs = NULL,-
499 .size = sizeof(TS_STATUS_INFO),-
500 .sname = "TS_STATUS_INFO",-
501};-
502-
503-
504TS_STATUS_INFO *-
505d2i_TS_STATUS_INFO(TS_STATUS_INFO **a, const unsigned char **in, long len)-
506{-
507 return (TS_STATUS_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
never executed: return (TS_STATUS_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_STATUS_INFO_it);
0
508 &TS_STATUS_INFO_it);
never executed: return (TS_STATUS_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_STATUS_INFO_it);
0
509}-
510-
511int-
512i2d_TS_STATUS_INFO(const TS_STATUS_INFO *a, unsigned char **out)-
513{-
514 return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_STATUS_INFO_it);
never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_STATUS_INFO_it);
0
515}-
516-
517TS_STATUS_INFO *-
518TS_STATUS_INFO_new(void)-
519{-
520 return (TS_STATUS_INFO *)ASN1_item_new(&TS_STATUS_INFO_it);
never executed: return (TS_STATUS_INFO *)ASN1_item_new(&TS_STATUS_INFO_it);
0
521}-
522-
523void-
524TS_STATUS_INFO_free(TS_STATUS_INFO *a)-
525{-
526 ASN1_item_free((ASN1_VALUE *)a, &TS_STATUS_INFO_it);-
527}
executed 1 time by 1 test: end of block
Executed by:
  • freenull
1
528-
529TS_STATUS_INFO *-
530TS_STATUS_INFO_dup(TS_STATUS_INFO *x)-
531{-
532 return ASN1_item_dup(&TS_STATUS_INFO_it, x);
never executed: return ASN1_item_dup(&TS_STATUS_INFO_it, x);
0
533}-
534-
535static int-
536ts_resp_set_tst_info(TS_RESP *a)-
537{-
538 long status;-
539-
540 status = ASN1_INTEGER_get(a->status_info->status);-
541-
542 if (a->token) {
a->tokenDescription
TRUEnever evaluated
FALSEnever evaluated
0
543 if (status != 0 && status != 1) {
status != 0Description
TRUEnever evaluated
FALSEnever evaluated
status != 1Description
TRUEnever evaluated
FALSEnever evaluated
0
544 TSerror(TS_R_TOKEN_PRESENT);-
545 return 0;
never executed: return 0;
0
546 }-
547 if (a->tst_info != NULL)
a->tst_info != ((void *)0)Description
TRUEnever evaluated
FALSEnever evaluated
0
548 TS_TST_INFO_free(a->tst_info);
never executed: TS_TST_INFO_free(a->tst_info);
0
549 a->tst_info = PKCS7_to_TS_TST_INFO(a->token);-
550 if (!a->tst_info) {
!a->tst_infoDescription
TRUEnever evaluated
FALSEnever evaluated
0
551 TSerror(TS_R_PKCS7_TO_TS_TST_INFO_FAILED);-
552 return 0;
never executed: return 0;
0
553 }-
554 } else if (status == 0 || status == 1) {
never executed: end of block
status == 0Description
TRUEnever evaluated
FALSEnever evaluated
status == 1Description
TRUEnever evaluated
FALSEnever evaluated
0
555 TSerror(TS_R_TOKEN_NOT_PRESENT);-
556 return 0;
never executed: return 0;
0
557 }-
558-
559 return 1;
never executed: return 1;
0
560}-
561-
562static int-
563ts_resp_cb(int op, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg)-
564{-
565 TS_RESP *ts_resp = (TS_RESP *)*pval;-
566-
567 if (op == ASN1_OP_NEW_POST) {
op == 1Description
TRUEnever evaluated
FALSEnever evaluated
0
568 ts_resp->tst_info = NULL;-
569 } else if (op == ASN1_OP_FREE_POST) {
never executed: end of block
op == 3Description
TRUEnever evaluated
FALSEnever evaluated
0
570 if (ts_resp->tst_info != NULL)
ts_resp->tst_i...!= ((void *)0)Description
TRUEnever evaluated
FALSEnever evaluated
0
571 TS_TST_INFO_free(ts_resp->tst_info);
never executed: TS_TST_INFO_free(ts_resp->tst_info);
0
572 } else if (op == ASN1_OP_D2I_POST) {
never executed: end of block
op == 5Description
TRUEnever evaluated
FALSEnever evaluated
0
573 if (ts_resp_set_tst_info(ts_resp) == 0)
ts_resp_set_ts...(ts_resp) == 0Description
TRUEnever evaluated
FALSEnever evaluated
0
574 return 0;
never executed: return 0;
0
575 }
never executed: end of block
0
576 return 1;
never executed: return 1;
0
577}-
578-
579static const ASN1_AUX TS_RESP_aux = {-
580 .app_data = NULL,-
581 .flags = 0,-
582 .ref_offset = 0,-
583 .ref_lock = 0,-
584 .asn1_cb = ts_resp_cb,-
585 .enc_offset = 0,-
586};-
587static const ASN1_TEMPLATE TS_RESP_seq_tt[] = {-
588 {-
589 .flags = 0,-
590 .tag = 0,-
591 .offset = offsetof(TS_RESP, status_info),-
592 .field_name = "status_info",-
593 .item = &TS_STATUS_INFO_it,-
594 },-
595 {-
596 .flags = ASN1_TFLG_OPTIONAL,-
597 .tag = 0,-
598 .offset = offsetof(TS_RESP, token),-
599 .field_name = "token",-
600 .item = &PKCS7_it,-
601 },-
602};-
603-
604const ASN1_ITEM TS_RESP_it = {-
605 .itype = ASN1_ITYPE_SEQUENCE,-
606 .utype = V_ASN1_SEQUENCE,-
607 .templates = TS_RESP_seq_tt,-
608 .tcount = sizeof(TS_RESP_seq_tt) / sizeof(ASN1_TEMPLATE),-
609 .funcs = &TS_RESP_aux,-
610 .size = sizeof(TS_RESP),-
611 .sname = "TS_RESP",-
612};-
613-
614-
615TS_RESP *-
616d2i_TS_RESP(TS_RESP **a, const unsigned char **in, long len)-
617{-
618 return (TS_RESP *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
never executed: return (TS_RESP *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_RESP_it);
0
619 &TS_RESP_it);
never executed: return (TS_RESP *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_RESP_it);
0
620}-
621-
622int-
623i2d_TS_RESP(const TS_RESP *a, unsigned char **out)-
624{-
625 return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_RESP_it);
never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_RESP_it);
0
626}-
627-
628TS_RESP *-
629TS_RESP_new(void)-
630{-
631 return (TS_RESP *)ASN1_item_new(&TS_RESP_it);
never executed: return (TS_RESP *)ASN1_item_new(&TS_RESP_it);
0
632}-
633-
634void-
635TS_RESP_free(TS_RESP *a)-
636{-
637 ASN1_item_free((ASN1_VALUE *)a, &TS_RESP_it);-
638}
executed 1 time by 1 test: end of block
Executed by:
  • freenull
1
639-
640TS_RESP *-
641TS_RESP_dup(TS_RESP *x)-
642{-
643 return ASN1_item_dup(&TS_RESP_it, x);
never executed: return ASN1_item_dup(&TS_RESP_it, x);
0
644}-
645-
646#ifndef OPENSSL_NO_BIO-
647TS_RESP *-
648d2i_TS_RESP_bio(BIO *bp, TS_RESP **a)-
649{-
650 return ASN1_item_d2i_bio(&TS_RESP_it, bp, a);
never executed: return ASN1_item_d2i_bio(&TS_RESP_it, bp, a);
0
651}-
652-
653int-
654i2d_TS_RESP_bio(BIO *bp, TS_RESP *a)-
655{-
656 return ASN1_item_i2d_bio(&TS_RESP_it, bp, a);
never executed: return ASN1_item_i2d_bio(&TS_RESP_it, bp, a);
0
657}-
658#endif-
659-
660TS_RESP *-
661d2i_TS_RESP_fp(FILE *fp, TS_RESP **a)-
662{-
663 return ASN1_item_d2i_fp(&TS_RESP_it, fp, a);
never executed: return ASN1_item_d2i_fp(&TS_RESP_it, fp, a);
0
664}-
665-
666int-
667i2d_TS_RESP_fp(FILE *fp, TS_RESP *a)-
668{-
669 return ASN1_item_i2d_fp(&TS_RESP_it, fp, a);
never executed: return ASN1_item_i2d_fp(&TS_RESP_it, fp, a);
0
670}-
671-
672static const ASN1_TEMPLATE ESS_ISSUER_SERIAL_seq_tt[] = {-
673 {-
674 .flags = ASN1_TFLG_SEQUENCE_OF,-
675 .tag = 0,-
676 .offset = offsetof(ESS_ISSUER_SERIAL, issuer),-
677 .field_name = "issuer",-
678 .item = &GENERAL_NAME_it,-
679 },-
680 {-
681 .flags = 0,-
682 .tag = 0,-
683 .offset = offsetof(ESS_ISSUER_SERIAL, serial),-
684 .field_name = "serial",-
685 .item = &ASN1_INTEGER_it,-
686 },-
687};-
688-
689const ASN1_ITEM ESS_ISSUER_SERIAL_it = {-
690 .itype = ASN1_ITYPE_SEQUENCE,-
691 .utype = V_ASN1_SEQUENCE,-
692 .templates = ESS_ISSUER_SERIAL_seq_tt,-
693 .tcount = sizeof(ESS_ISSUER_SERIAL_seq_tt) / sizeof(ASN1_TEMPLATE),-
694 .funcs = NULL,-
695 .size = sizeof(ESS_ISSUER_SERIAL),-
696 .sname = "ESS_ISSUER_SERIAL",-
697};-
698-
699-
700ESS_ISSUER_SERIAL *-
701d2i_ESS_ISSUER_SERIAL(ESS_ISSUER_SERIAL **a, const unsigned char **in, long len)-
702{-
703 return (ESS_ISSUER_SERIAL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
never executed: return (ESS_ISSUER_SERIAL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &ESS_ISSUER_SERIAL_it);
0
704 &ESS_ISSUER_SERIAL_it);
never executed: return (ESS_ISSUER_SERIAL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &ESS_ISSUER_SERIAL_it);
0
705}-
706-
707int-
708i2d_ESS_ISSUER_SERIAL(const ESS_ISSUER_SERIAL *a, unsigned char **out)-
709{-
710 return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_ISSUER_SERIAL_it);
never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_ISSUER_SERIAL_it);
0
711}-
712-
713ESS_ISSUER_SERIAL *-
714ESS_ISSUER_SERIAL_new(void)-
715{-
716 return (ESS_ISSUER_SERIAL *)ASN1_item_new(&ESS_ISSUER_SERIAL_it);
never executed: return (ESS_ISSUER_SERIAL *)ASN1_item_new(&ESS_ISSUER_SERIAL_it);
0
717}-
718-
719void-
720ESS_ISSUER_SERIAL_free(ESS_ISSUER_SERIAL *a)-
721{-
722 ASN1_item_free((ASN1_VALUE *)a, &ESS_ISSUER_SERIAL_it);-
723}
executed 1 time by 1 test: end of block
Executed by:
  • freenull
1
724-
725ESS_ISSUER_SERIAL *-
726ESS_ISSUER_SERIAL_dup(ESS_ISSUER_SERIAL *x)-
727{-
728 return ASN1_item_dup(&ESS_ISSUER_SERIAL_it, x);
never executed: return ASN1_item_dup(&ESS_ISSUER_SERIAL_it, x);
0
729}-
730-
731static const ASN1_TEMPLATE ESS_CERT_ID_seq_tt[] = {-
732 {-
733 .flags = 0,-
734 .tag = 0,-
735 .offset = offsetof(ESS_CERT_ID, hash),-
736 .field_name = "hash",-
737 .item = &ASN1_OCTET_STRING_it,-
738 },-
739 {-
740 .flags = ASN1_TFLG_OPTIONAL,-
741 .tag = 0,-
742 .offset = offsetof(ESS_CERT_ID, issuer_serial),-
743 .field_name = "issuer_serial",-
744 .item = &ESS_ISSUER_SERIAL_it,-
745 },-
746};-
747-
748const ASN1_ITEM ESS_CERT_ID_it = {-
749 .itype = ASN1_ITYPE_SEQUENCE,-
750 .utype = V_ASN1_SEQUENCE,-
751 .templates = ESS_CERT_ID_seq_tt,-
752 .tcount = sizeof(ESS_CERT_ID_seq_tt) / sizeof(ASN1_TEMPLATE),-
753 .funcs = NULL,-
754 .size = sizeof(ESS_CERT_ID),-
755 .sname = "ESS_CERT_ID",-
756};-
757-
758-
759ESS_CERT_ID *-
760d2i_ESS_CERT_ID(ESS_CERT_ID **a, const unsigned char **in, long len)-
761{-
762 return (ESS_CERT_ID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
never executed: return (ESS_CERT_ID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &ESS_CERT_ID_it);
0
763 &ESS_CERT_ID_it);
never executed: return (ESS_CERT_ID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &ESS_CERT_ID_it);
0
764}-
765-
766int-
767i2d_ESS_CERT_ID(const ESS_CERT_ID *a, unsigned char **out)-
768{-
769 return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_CERT_ID_it);
never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_CERT_ID_it);
0
770}-
771-
772ESS_CERT_ID *-
773ESS_CERT_ID_new(void)-
774{-
775 return (ESS_CERT_ID *)ASN1_item_new(&ESS_CERT_ID_it);
never executed: return (ESS_CERT_ID *)ASN1_item_new(&ESS_CERT_ID_it);
0
776}-
777-
778void-
779ESS_CERT_ID_free(ESS_CERT_ID *a)-
780{-
781 ASN1_item_free((ASN1_VALUE *)a, &ESS_CERT_ID_it);-
782}
executed 1 time by 1 test: end of block
Executed by:
  • freenull
1
783-
784ESS_CERT_ID *-
785ESS_CERT_ID_dup(ESS_CERT_ID *x)-
786{-
787 return ASN1_item_dup(&ESS_CERT_ID_it, x);
never executed: return ASN1_item_dup(&ESS_CERT_ID_it, x);
0
788}-
789-
790static const ASN1_TEMPLATE ESS_SIGNING_CERT_seq_tt[] = {-
791 {-
792 .flags = ASN1_TFLG_SEQUENCE_OF,-
793 .tag = 0,-
794 .offset = offsetof(ESS_SIGNING_CERT, cert_ids),-
795 .field_name = "cert_ids",-
796 .item = &ESS_CERT_ID_it,-
797 },-
798 {-
799 .flags = ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,-
800 .tag = 0,-
801 .offset = offsetof(ESS_SIGNING_CERT, policy_info),-
802 .field_name = "policy_info",-
803 .item = &POLICYINFO_it,-
804 },-
805};-
806-
807const ASN1_ITEM ESS_SIGNING_CERT_it = {-
808 .itype = ASN1_ITYPE_SEQUENCE,-
809 .utype = V_ASN1_SEQUENCE,-
810 .templates = ESS_SIGNING_CERT_seq_tt,-
811 .tcount = sizeof(ESS_SIGNING_CERT_seq_tt) / sizeof(ASN1_TEMPLATE),-
812 .funcs = NULL,-
813 .size = sizeof(ESS_SIGNING_CERT),-
814 .sname = "ESS_SIGNING_CERT",-
815};-
816-
817-
818ESS_SIGNING_CERT *-
819d2i_ESS_SIGNING_CERT(ESS_SIGNING_CERT **a, const unsigned char **in, long len)-
820{-
821 return (ESS_SIGNING_CERT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
never executed: return (ESS_SIGNING_CERT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &ESS_SIGNING_CERT_it);
0
822 &ESS_SIGNING_CERT_it);
never executed: return (ESS_SIGNING_CERT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &ESS_SIGNING_CERT_it);
0
823}-
824-
825int-
826i2d_ESS_SIGNING_CERT(const ESS_SIGNING_CERT *a, unsigned char **out)-
827{-
828 return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_SIGNING_CERT_it);
never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_SIGNING_CERT_it);
0
829}-
830-
831ESS_SIGNING_CERT *-
832ESS_SIGNING_CERT_new(void)-
833{-
834 return (ESS_SIGNING_CERT *)ASN1_item_new(&ESS_SIGNING_CERT_it);
never executed: return (ESS_SIGNING_CERT *)ASN1_item_new(&ESS_SIGNING_CERT_it);
0
835}-
836-
837void-
838ESS_SIGNING_CERT_free(ESS_SIGNING_CERT *a)-
839{-
840 ASN1_item_free((ASN1_VALUE *)a, &ESS_SIGNING_CERT_it);-
841}
executed 1 time by 1 test: end of block
Executed by:
  • freenull
1
842-
843ESS_SIGNING_CERT *-
844ESS_SIGNING_CERT_dup(ESS_SIGNING_CERT *x)-
845{-
846 return ASN1_item_dup(&ESS_SIGNING_CERT_it, x);
never executed: return ASN1_item_dup(&ESS_SIGNING_CERT_it, x);
0
847}-
848-
849/* Getting encapsulated TS_TST_INFO object from PKCS7. */-
850TS_TST_INFO *-
851PKCS7_to_TS_TST_INFO(PKCS7 *token)-
852{-
853 PKCS7_SIGNED *pkcs7_signed;-
854 PKCS7 *enveloped;-
855 ASN1_TYPE *tst_info_wrapper;-
856 ASN1_OCTET_STRING *tst_info_der;-
857 const unsigned char *p;-
858-
859 if (!PKCS7_type_is_signed(token)) {
!(OBJ_obj2nid(...->type) == 22)Description
TRUEnever evaluated
FALSEnever evaluated
0
860 TSerror(TS_R_BAD_PKCS7_TYPE);-
861 return NULL;
never executed: return ((void *)0) ;
0
862 }-
863-
864 /* Content must be present. */-
865 if (PKCS7_get_detached(token)) {
PKCS7_ctrl(tok... ((void *)0) )Description
TRUEnever evaluated
FALSEnever evaluated
0
866 TSerror(TS_R_DETACHED_CONTENT);-
867 return NULL;
never executed: return ((void *)0) ;
0
868 }-
869-
870 /* We have a signed data with content. */-
871 pkcs7_signed = token->d.sign;-
872 enveloped = pkcs7_signed->contents;-
873 if (OBJ_obj2nid(enveloped->type) != NID_id_smime_ct_TSTInfo) {
OBJ_obj2nid(en...->type) != 207Description
TRUEnever evaluated
FALSEnever evaluated
0
874 TSerror(TS_R_BAD_PKCS7_TYPE);-
875 return NULL;
never executed: return ((void *)0) ;
0
876 }-
877-
878 /* We have a DER encoded TST_INFO as the signed data. */-
879 tst_info_wrapper = enveloped->d.other;-
880 if (tst_info_wrapper->type != V_ASN1_OCTET_STRING) {
tst_info_wrapper->type != 4Description
TRUEnever evaluated
FALSEnever evaluated
0
881 TSerror(TS_R_BAD_TYPE);-
882 return NULL;
never executed: return ((void *)0) ;
0
883 }-
884-
885 /* We have the correct ASN1_OCTET_STRING type. */-
886 tst_info_der = tst_info_wrapper->value.octet_string;-
887 /* At last, decode the TST_INFO. */-
888 p = tst_info_der->data;-
889 return d2i_TS_TST_INFO(NULL, &p, tst_info_der->length);
never executed: return d2i_TS_TST_INFO( ((void *)0) , &p, tst_info_der->length);
0
890}-
Source codeSwitch to Preprocessed file
Generated by Squish Coco 4.2.2