Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libcrypto/crypto/../../libssl/src/crypto/pkcs12/p12_asn.c	Lines:	0	16	0.0 %
Date:	2016-12-06	Branches:	0	0	0.0 %


/* $OpenBSD: p12_asn.c,v 1.9 2015/07/25 17:08:40 jsing Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 1999.
 */
/* ====================================================================
 * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. All advertising materials mentioning features or use of this
 *    software must display the following acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
 *
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For written permission, please contact
 *    licensing@OpenSSL.org.
 *
 * 5. Products derived from this software may not be called "OpenSSL"
 *    nor may "OpenSSL" appear in their names without prior written
 *    permission of the OpenSSL Project.
 *
 * 6. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
 *
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 * ====================================================================
 *
 * This product includes cryptographic software written by Eric Young
 * (eay@cryptsoft.com).  This product includes software written by Tim
 * Hudson (tjh@cryptsoft.com).
 *
 */

#include <stdio.h>

#include <openssl/asn1t.h>
#include <openssl/pkcs12.h>

/* PKCS#12 ASN1 module */

static const ASN1_TEMPLATE PKCS12_seq_tt[] = {
	{
		.flags = 0,
		.tag = 0,
		.offset = offsetof(PKCS12, version),
		.field_name = "version",
		.item = &ASN1_INTEGER_it,
	},
	{
		.flags = 0,
		.tag = 0,
		.offset = offsetof(PKCS12, authsafes),
		.field_name = "authsafes",
		.item = &PKCS7_it,
	},
	{
		.flags = ASN1_TFLG_OPTIONAL,
		.tag = 0,
		.offset = offsetof(PKCS12, mac),
		.field_name = "mac",
		.item = &PKCS12_MAC_DATA_it,
	},
};

const ASN1_ITEM PKCS12_it = {
	.itype = ASN1_ITYPE_SEQUENCE,
	.utype = V_ASN1_SEQUENCE,
	.templates = PKCS12_seq_tt,
	.tcount = sizeof(PKCS12_seq_tt) / sizeof(ASN1_TEMPLATE),
	.funcs = NULL,
	.size = sizeof(PKCS12),
	.sname = "PKCS12",
};


PKCS12 *
d2i_PKCS12(PKCS12 **a, const unsigned char **in, long len)
{
	return (PKCS12 *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
	    &PKCS12_it);
}

int
i2d_PKCS12(PKCS12 *a, unsigned char **out)
{
	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_it);
}

PKCS12 *
PKCS12_new(void)
{
	return (PKCS12 *)ASN1_item_new(&PKCS12_it);
}

void
PKCS12_free(PKCS12 *a)
{
	ASN1_item_free((ASN1_VALUE *)a, &PKCS12_it);
}

static const ASN1_TEMPLATE PKCS12_MAC_DATA_seq_tt[] = {
	{
		.flags = 0,
		.tag = 0,
		.offset = offsetof(PKCS12_MAC_DATA, dinfo),
		.field_name = "dinfo",
		.item = &X509_SIG_it,
	},
	{
		.flags = 0,
		.tag = 0,
		.offset = offsetof(PKCS12_MAC_DATA, salt),
		.field_name = "salt",
		.item = &ASN1_OCTET_STRING_it,
	},
	{
		.flags = ASN1_TFLG_OPTIONAL,
		.tag = 0,
		.offset = offsetof(PKCS12_MAC_DATA, iter),
		.field_name = "iter",
		.item = &ASN1_INTEGER_it,
	},
};

const ASN1_ITEM PKCS12_MAC_DATA_it = {
	.itype = ASN1_ITYPE_SEQUENCE,
	.utype = V_ASN1_SEQUENCE,
	.templates = PKCS12_MAC_DATA_seq_tt,
	.tcount = sizeof(PKCS12_MAC_DATA_seq_tt) / sizeof(ASN1_TEMPLATE),
	.funcs = NULL,
	.size = sizeof(PKCS12_MAC_DATA),
	.sname = "PKCS12_MAC_DATA",
};


PKCS12_MAC_DATA *
d2i_PKCS12_MAC_DATA(PKCS12_MAC_DATA **a, const unsigned char **in, long len)
{
	return (PKCS12_MAC_DATA *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
	    &PKCS12_MAC_DATA_it);
}

int
i2d_PKCS12_MAC_DATA(PKCS12_MAC_DATA *a, unsigned char **out)
{
	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_MAC_DATA_it);
}

PKCS12_MAC_DATA *
PKCS12_MAC_DATA_new(void)
{
	return (PKCS12_MAC_DATA *)ASN1_item_new(&PKCS12_MAC_DATA_it);
}

void
PKCS12_MAC_DATA_free(PKCS12_MAC_DATA *a)
{
	ASN1_item_free((ASN1_VALUE *)a, &PKCS12_MAC_DATA_it);
}

static const ASN1_TEMPLATE bag_default_tt = {
	.flags = ASN1_TFLG_EXPLICIT,
	.tag = 0,
	.offset = offsetof(PKCS12_BAGS, value.other),
	.field_name = "value.other",
	.item = &ASN1_ANY_it,
};

static const ASN1_ADB_TABLE PKCS12_BAGS_adbtbl[] = {
	{
		.value = NID_x509Certificate,
		.tt = {
			.flags = ASN1_TFLG_EXPLICIT,
			.tag = 0,
			.offset = offsetof(PKCS12_BAGS, value.x509cert),
			.field_name = "value.x509cert",
			.item = &ASN1_OCTET_STRING_it,
		},

	},
	{
		.value = NID_x509Crl,
		.tt = {
			.flags = ASN1_TFLG_EXPLICIT,
			.tag = 0,
			.offset = offsetof(PKCS12_BAGS, value.x509crl),
			.field_name = "value.x509crl",
			.item = &ASN1_OCTET_STRING_it,
		},

	},
	{
		.value = NID_sdsiCertificate,
		.tt = {
			.flags = ASN1_TFLG_EXPLICIT,
			.tag = 0,
			.offset = offsetof(PKCS12_BAGS, value.sdsicert),
			.field_name = "value.sdsicert",
			.item = &ASN1_IA5STRING_it,
		},

	},
};

static const ASN1_ADB PKCS12_BAGS_adb = {
	.flags = 0,
	.offset = offsetof(PKCS12_BAGS, type),
	.app_items = 0,
	.tbl = PKCS12_BAGS_adbtbl,
	.tblcount = sizeof(PKCS12_BAGS_adbtbl) / sizeof(ASN1_ADB_TABLE),
	.default_tt = &bag_default_tt,
	.null_tt = NULL,
};

static const ASN1_TEMPLATE PKCS12_BAGS_seq_tt[] = {
	{
		.flags = 0,
		.tag = 0,
		.offset = offsetof(PKCS12_BAGS, type),
		.field_name = "type",
		.item = &ASN1_OBJECT_it,
	},
	{
		.flags = ASN1_TFLG_ADB_OID,
		.tag = -1,
		.offset = 0,
		.field_name = "PKCS12_BAGS",
		.item = (const ASN1_ITEM *)&PKCS12_BAGS_adb,
	},
};

const ASN1_ITEM PKCS12_BAGS_it = {
	.itype = ASN1_ITYPE_SEQUENCE,
	.utype = V_ASN1_SEQUENCE,
	.templates = PKCS12_BAGS_seq_tt,
	.tcount = sizeof(PKCS12_BAGS_seq_tt) / sizeof(ASN1_TEMPLATE),
	.funcs = NULL,
	.size = sizeof(PKCS12_BAGS),
	.sname = "PKCS12_BAGS",
};


PKCS12_BAGS *
d2i_PKCS12_BAGS(PKCS12_BAGS **a, const unsigned char **in, long len)
{
	return (PKCS12_BAGS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
	    &PKCS12_BAGS_it);
}

int
i2d_PKCS12_BAGS(PKCS12_BAGS *a, unsigned char **out)
{
	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_BAGS_it);
}

PKCS12_BAGS *
PKCS12_BAGS_new(void)
{
	return (PKCS12_BAGS *)ASN1_item_new(&PKCS12_BAGS_it);
}

void
PKCS12_BAGS_free(PKCS12_BAGS *a)
{
	ASN1_item_free((ASN1_VALUE *)a, &PKCS12_BAGS_it);
}

static const ASN1_TEMPLATE safebag_default_tt = {
	.flags = ASN1_TFLG_EXPLICIT,
	.tag = 0,
	.offset = offsetof(PKCS12_SAFEBAG, value.other),
	.field_name = "value.other",
	.item = &ASN1_ANY_it,
};

static const ASN1_ADB_TABLE PKCS12_SAFEBAG_adbtbl[] = {
	{
		.value = NID_keyBag,
		.tt = {
			.flags = ASN1_TFLG_EXPLICIT,
			.tag = 0,
			.offset = offsetof(PKCS12_SAFEBAG, value.keybag),
			.field_name = "value.keybag",
			.item = &PKCS8_PRIV_KEY_INFO_it,
		},

	},
	{
		.value = NID_pkcs8ShroudedKeyBag,
		.tt = {
			.flags = ASN1_TFLG_EXPLICIT,
			.tag = 0,
			.offset = offsetof(PKCS12_SAFEBAG, value.shkeybag),
			.field_name = "value.shkeybag",
			.item = &X509_SIG_it,
		},

	},
	{
		.value = NID_safeContentsBag,
		.tt = {
			.flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_SET_OF,
			.tag = 0,
			.offset = offsetof(PKCS12_SAFEBAG, value.safes),
			.field_name = "value.safes",
			.item = &PKCS12_SAFEBAG_it,
		},
	},
	{
		.value = NID_certBag,
		.tt = {
			.flags = ASN1_TFLG_EXPLICIT,
			.tag = 0,
			.offset = offsetof(PKCS12_SAFEBAG, value.bag),
			.field_name = "value.bag",
			.item = &PKCS12_BAGS_it,
		},

	},
	{
		.value = NID_crlBag,
		.tt = {
			.flags = ASN1_TFLG_EXPLICIT,
			.tag = 0,
			.offset = offsetof(PKCS12_SAFEBAG, value.bag),
			.field_name = "value.bag",
			.item = &PKCS12_BAGS_it,
		},

	},
	{
		.value = NID_secretBag,
		.tt = {
			.flags = ASN1_TFLG_EXPLICIT,
			.tag = 0,
			.offset = offsetof(PKCS12_SAFEBAG, value.bag),
			.field_name = "value.bag",
			.item = &PKCS12_BAGS_it,
		},

	},
};

static const ASN1_ADB PKCS12_SAFEBAG_adb = {
	.flags = 0,
	.offset = offsetof(PKCS12_SAFEBAG, type),
	.app_items = 0,
	.tbl = PKCS12_SAFEBAG_adbtbl,
	.tblcount = sizeof(PKCS12_SAFEBAG_adbtbl) / sizeof(ASN1_ADB_TABLE),
	.default_tt = &safebag_default_tt,
	.null_tt = NULL,
};

static const ASN1_TEMPLATE PKCS12_SAFEBAG_seq_tt[] = {
	{
		.flags = 0,
		.tag = 0,
		.offset = offsetof(PKCS12_SAFEBAG, type),
		.field_name = "type",
		.item = &ASN1_OBJECT_it,
	},
	{
		.flags = ASN1_TFLG_ADB_OID,
		.tag = -1,
		.offset = 0,
		.field_name = "PKCS12_SAFEBAG",
		.item = (const ASN1_ITEM *)&PKCS12_SAFEBAG_adb,
	},
	{
		.flags = ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL,
		.tag = 0,
		.offset = offsetof(PKCS12_SAFEBAG, attrib),
		.field_name = "attrib",
		.item = &X509_ATTRIBUTE_it,
	},
};

const ASN1_ITEM PKCS12_SAFEBAG_it = {
	.itype = ASN1_ITYPE_SEQUENCE,
	.utype = V_ASN1_SEQUENCE,
	.templates = PKCS12_SAFEBAG_seq_tt,
	.tcount = sizeof(PKCS12_SAFEBAG_seq_tt) / sizeof(ASN1_TEMPLATE),
	.funcs = NULL,
	.size = sizeof(PKCS12_SAFEBAG),
	.sname = "PKCS12_SAFEBAG",
};


PKCS12_SAFEBAG *
d2i_PKCS12_SAFEBAG(PKCS12_SAFEBAG **a, const unsigned char **in, long len)
{
	return (PKCS12_SAFEBAG *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
	    &PKCS12_SAFEBAG_it);
}

int
i2d_PKCS12_SAFEBAG(PKCS12_SAFEBAG *a, unsigned char **out)
{
	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_SAFEBAG_it);
}

PKCS12_SAFEBAG *
PKCS12_SAFEBAG_new(void)
{
	return (PKCS12_SAFEBAG *)ASN1_item_new(&PKCS12_SAFEBAG_it);
}

void
PKCS12_SAFEBAG_free(PKCS12_SAFEBAG *a)
{
	ASN1_item_free((ASN1_VALUE *)a, &PKCS12_SAFEBAG_it);
}

/* SEQUENCE OF SafeBag */
static const ASN1_TEMPLATE PKCS12_SAFEBAGS_item_tt = {
	.flags = ASN1_TFLG_SEQUENCE_OF,
	.tag = 0,
	.offset = 0,
	.field_name = "PKCS12_SAFEBAGS",
	.item = &PKCS12_SAFEBAG_it,
};

const ASN1_ITEM PKCS12_SAFEBAGS_it = {
	.itype = ASN1_ITYPE_PRIMITIVE,
	.utype = -1,
	.templates = &PKCS12_SAFEBAGS_item_tt,
	.tcount = 0,
	.funcs = NULL,
	.size = 0,
	.sname = "PKCS12_SAFEBAGS",
};

/* Authsafes: SEQUENCE OF PKCS7 */
static const ASN1_TEMPLATE PKCS12_AUTHSAFES_item_tt = {
	.flags = ASN1_TFLG_SEQUENCE_OF,
	.tag = 0,
	.offset = 0,
	.field_name = "PKCS12_AUTHSAFES",
	.item = &PKCS7_it,
};

const ASN1_ITEM PKCS12_AUTHSAFES_it = {
	.itype = ASN1_ITYPE_PRIMITIVE,
	.utype = -1,
	.templates = &PKCS12_AUTHSAFES_item_tt,
	.tcount = 0,
	.funcs = NULL,
	.size = 0,
	.sname = "PKCS12_AUTHSAFES",
};



Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: p12_asn.c,v 1.9 2015/07/25 17:08:40 jsing Exp $ */
2			/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
3			* project 1999.
4			*/
5			/* ====================================================================
6			* Copyright (c) 1999 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
61			#include <openssl/asn1t.h>
62			#include <openssl/pkcs12.h>
63
64			/* PKCS#12 ASN1 module */
65
66			static const ASN1_TEMPLATE PKCS12_seq_tt[] = {
67			{
68			.flags = 0,
69			.tag = 0,
70			.offset = offsetof(PKCS12, version),
71			.field_name = "version",
72			.item = &ASN1_INTEGER_it,
73			},
74			{
75			.flags = 0,
76			.tag = 0,
77			.offset = offsetof(PKCS12, authsafes),
78			.field_name = "authsafes",
79			.item = &PKCS7_it,
80			},
81			{
82			.flags = ASN1_TFLG_OPTIONAL,
83			.tag = 0,
84			.offset = offsetof(PKCS12, mac),
85			.field_name = "mac",
86			.item = &PKCS12_MAC_DATA_it,
87			},
88			};
89
90			const ASN1_ITEM PKCS12_it = {
91			.itype = ASN1_ITYPE_SEQUENCE,
92			.utype = V_ASN1_SEQUENCE,
93			.templates = PKCS12_seq_tt,
94			.tcount = sizeof(PKCS12_seq_tt) / sizeof(ASN1_TEMPLATE),
95			.funcs = NULL,
96			.size = sizeof(PKCS12),
97			.sname = "PKCS12",
98			};
99
100
101			PKCS12 *
102			d2i_PKCS12(PKCS12 a, const unsigned char in, long len)
103			{
104			return (PKCS12 )ASN1_item_d2i((ASN1_VALUE *)a, in, len,
105			&PKCS12_it);
106			}
107
108			int
109			i2d_PKCS12(PKCS12 a, unsigned char *out)
110			{
111			return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_it);
112			}
113
114			PKCS12 *
115			PKCS12_new(void)
116			{
117			return (PKCS12 *)ASN1_item_new(&PKCS12_it);
118			}
119
120			void
121			PKCS12_free(PKCS12 *a)
122			{
123			ASN1_item_free((ASN1_VALUE *)a, &PKCS12_it);
124			}
125
126			static const ASN1_TEMPLATE PKCS12_MAC_DATA_seq_tt[] = {
127			{
128			.flags = 0,
129			.tag = 0,
130			.offset = offsetof(PKCS12_MAC_DATA, dinfo),
131			.field_name = "dinfo",
132			.item = &X509_SIG_it,
133			},
134			{
135			.flags = 0,
136			.tag = 0,
137			.offset = offsetof(PKCS12_MAC_DATA, salt),
138			.field_name = "salt",
139			.item = &ASN1_OCTET_STRING_it,
140			},
141			{
142			.flags = ASN1_TFLG_OPTIONAL,
143			.tag = 0,
144			.offset = offsetof(PKCS12_MAC_DATA, iter),
145			.field_name = "iter",
146			.item = &ASN1_INTEGER_it,
147			},
148			};
149
150			const ASN1_ITEM PKCS12_MAC_DATA_it = {
151			.itype = ASN1_ITYPE_SEQUENCE,
152			.utype = V_ASN1_SEQUENCE,
153			.templates = PKCS12_MAC_DATA_seq_tt,
154			.tcount = sizeof(PKCS12_MAC_DATA_seq_tt) / sizeof(ASN1_TEMPLATE),
155			.funcs = NULL,
156			.size = sizeof(PKCS12_MAC_DATA),
157			.sname = "PKCS12_MAC_DATA",
158			};
159
160
161			PKCS12_MAC_DATA *
162			d2i_PKCS12_MAC_DATA(PKCS12_MAC_DATA a, const unsigned char in, long len)
163			{
164			return (PKCS12_MAC_DATA )ASN1_item_d2i((ASN1_VALUE *)a, in, len,
165			&PKCS12_MAC_DATA_it);
166			}
167
168			int
169			i2d_PKCS12_MAC_DATA(PKCS12_MAC_DATA a, unsigned char *out)
170			{
171			return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_MAC_DATA_it);
172			}
173
174			PKCS12_MAC_DATA *
175			PKCS12_MAC_DATA_new(void)
176			{
177			return (PKCS12_MAC_DATA *)ASN1_item_new(&PKCS12_MAC_DATA_it);
178			}
179
180			void
181			PKCS12_MAC_DATA_free(PKCS12_MAC_DATA *a)
182			{
183			ASN1_item_free((ASN1_VALUE *)a, &PKCS12_MAC_DATA_it);
184			}
185
186			static const ASN1_TEMPLATE bag_default_tt = {
187			.flags = ASN1_TFLG_EXPLICIT,
188			.tag = 0,
189			.offset = offsetof(PKCS12_BAGS, value.other),
190			.field_name = "value.other",
191			.item = &ASN1_ANY_it,
192			};
193
194			static const ASN1_ADB_TABLE PKCS12_BAGS_adbtbl[] = {
195			{
196			.value = NID_x509Certificate,
197			.tt = {
198			.flags = ASN1_TFLG_EXPLICIT,
199			.tag = 0,
200			.offset = offsetof(PKCS12_BAGS, value.x509cert),
201			.field_name = "value.x509cert",
202			.item = &ASN1_OCTET_STRING_it,
203			},
204
205			},
206			{
207			.value = NID_x509Crl,
208			.tt = {
209			.flags = ASN1_TFLG_EXPLICIT,
210			.tag = 0,
211			.offset = offsetof(PKCS12_BAGS, value.x509crl),
212			.field_name = "value.x509crl",
213			.item = &ASN1_OCTET_STRING_it,
214			},
215
216			},
217			{
218			.value = NID_sdsiCertificate,
219			.tt = {
220			.flags = ASN1_TFLG_EXPLICIT,
221			.tag = 0,
222			.offset = offsetof(PKCS12_BAGS, value.sdsicert),
223			.field_name = "value.sdsicert",
224			.item = &ASN1_IA5STRING_it,
225			},
226
227			},
228			};
229
230			static const ASN1_ADB PKCS12_BAGS_adb = {
231			.flags = 0,
232			.offset = offsetof(PKCS12_BAGS, type),
233			.app_items = 0,
234			.tbl = PKCS12_BAGS_adbtbl,
235			.tblcount = sizeof(PKCS12_BAGS_adbtbl) / sizeof(ASN1_ADB_TABLE),
236			.default_tt = &bag_default_tt,
237			.null_tt = NULL,
238			};
239
240			static const ASN1_TEMPLATE PKCS12_BAGS_seq_tt[] = {
241			{
242			.flags = 0,
243			.tag = 0,
244			.offset = offsetof(PKCS12_BAGS, type),
245			.field_name = "type",
246			.item = &ASN1_OBJECT_it,
247			},
248			{
249			.flags = ASN1_TFLG_ADB_OID,
250			.tag = -1,
251			.offset = 0,
252			.field_name = "PKCS12_BAGS",
253			.item = (const ASN1_ITEM *)&PKCS12_BAGS_adb,
254			},
255			};
256
257			const ASN1_ITEM PKCS12_BAGS_it = {
258			.itype = ASN1_ITYPE_SEQUENCE,
259			.utype = V_ASN1_SEQUENCE,
260			.templates = PKCS12_BAGS_seq_tt,
261			.tcount = sizeof(PKCS12_BAGS_seq_tt) / sizeof(ASN1_TEMPLATE),
262			.funcs = NULL,
263			.size = sizeof(PKCS12_BAGS),
264			.sname = "PKCS12_BAGS",
265			};
266
267
268			PKCS12_BAGS *
269			d2i_PKCS12_BAGS(PKCS12_BAGS a, const unsigned char in, long len)
270			{
271			return (PKCS12_BAGS )ASN1_item_d2i((ASN1_VALUE *)a, in, len,
272			&PKCS12_BAGS_it);
273			}
274
275			int
276			i2d_PKCS12_BAGS(PKCS12_BAGS a, unsigned char *out)
277			{
278			return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_BAGS_it);
279			}
280
281			PKCS12_BAGS *
282			PKCS12_BAGS_new(void)
283			{
284			return (PKCS12_BAGS *)ASN1_item_new(&PKCS12_BAGS_it);
285			}
286
287			void
288			PKCS12_BAGS_free(PKCS12_BAGS *a)
289			{
290			ASN1_item_free((ASN1_VALUE *)a, &PKCS12_BAGS_it);
291			}
292
293			static const ASN1_TEMPLATE safebag_default_tt = {
294			.flags = ASN1_TFLG_EXPLICIT,
295			.tag = 0,
296			.offset = offsetof(PKCS12_SAFEBAG, value.other),
297			.field_name = "value.other",
298			.item = &ASN1_ANY_it,
299			};
300
301			static const ASN1_ADB_TABLE PKCS12_SAFEBAG_adbtbl[] = {
302			{
303			.value = NID_keyBag,
304			.tt = {
305			.flags = ASN1_TFLG_EXPLICIT,
306			.tag = 0,
307			.offset = offsetof(PKCS12_SAFEBAG, value.keybag),
308			.field_name = "value.keybag",
309			.item = &PKCS8_PRIV_KEY_INFO_it,
310			},
311
312			},
313			{
314			.value = NID_pkcs8ShroudedKeyBag,
315			.tt = {
316			.flags = ASN1_TFLG_EXPLICIT,
317			.tag = 0,
318			.offset = offsetof(PKCS12_SAFEBAG, value.shkeybag),
319			.field_name = "value.shkeybag",
320			.item = &X509_SIG_it,
321			},
322
323			},
324			{
325			.value = NID_safeContentsBag,
326			.tt = {
327			.flags = ASN1_TFLG_EXPLICIT \| ASN1_TFLG_SET_OF,
328			.tag = 0,
329			.offset = offsetof(PKCS12_SAFEBAG, value.safes),
330			.field_name = "value.safes",
331			.item = &PKCS12_SAFEBAG_it,
332			},
333			},
334			{
335			.value = NID_certBag,
336			.tt = {
337			.flags = ASN1_TFLG_EXPLICIT,
338			.tag = 0,
339			.offset = offsetof(PKCS12_SAFEBAG, value.bag),
340			.field_name = "value.bag",
341			.item = &PKCS12_BAGS_it,
342			},
343
344			},
345			{
346			.value = NID_crlBag,
347			.tt = {
348			.flags = ASN1_TFLG_EXPLICIT,
349			.tag = 0,
350			.offset = offsetof(PKCS12_SAFEBAG, value.bag),
351			.field_name = "value.bag",
352			.item = &PKCS12_BAGS_it,
353			},
354
355			},
356			{
357			.value = NID_secretBag,
358			.tt = {
359			.flags = ASN1_TFLG_EXPLICIT,
360			.tag = 0,
361			.offset = offsetof(PKCS12_SAFEBAG, value.bag),
362			.field_name = "value.bag",
363			.item = &PKCS12_BAGS_it,
364			},
365
366			},
367			};
368
369			static const ASN1_ADB PKCS12_SAFEBAG_adb = {
370			.flags = 0,
371			.offset = offsetof(PKCS12_SAFEBAG, type),
372			.app_items = 0,
373			.tbl = PKCS12_SAFEBAG_adbtbl,
374			.tblcount = sizeof(PKCS12_SAFEBAG_adbtbl) / sizeof(ASN1_ADB_TABLE),
375			.default_tt = &safebag_default_tt,
376			.null_tt = NULL,
377			};
378
379			static const ASN1_TEMPLATE PKCS12_SAFEBAG_seq_tt[] = {
380			{
381			.flags = 0,
382			.tag = 0,
383			.offset = offsetof(PKCS12_SAFEBAG, type),
384			.field_name = "type",
385			.item = &ASN1_OBJECT_it,
386			},
387			{
388			.flags = ASN1_TFLG_ADB_OID,
389			.tag = -1,
390			.offset = 0,
391			.field_name = "PKCS12_SAFEBAG",
392			.item = (const ASN1_ITEM *)&PKCS12_SAFEBAG_adb,
393			},
394			{
395			.flags = ASN1_TFLG_SET_OF \| ASN1_TFLG_OPTIONAL,
396			.tag = 0,
397			.offset = offsetof(PKCS12_SAFEBAG, attrib),
398			.field_name = "attrib",
399			.item = &X509_ATTRIBUTE_it,
400			},
401			};
402
403			const ASN1_ITEM PKCS12_SAFEBAG_it = {
404			.itype = ASN1_ITYPE_SEQUENCE,
405			.utype = V_ASN1_SEQUENCE,
406			.templates = PKCS12_SAFEBAG_seq_tt,
407			.tcount = sizeof(PKCS12_SAFEBAG_seq_tt) / sizeof(ASN1_TEMPLATE),
408			.funcs = NULL,
409			.size = sizeof(PKCS12_SAFEBAG),
410			.sname = "PKCS12_SAFEBAG",
411			};
412
413
414			PKCS12_SAFEBAG *
415			d2i_PKCS12_SAFEBAG(PKCS12_SAFEBAG a, const unsigned char in, long len)
416			{
417			return (PKCS12_SAFEBAG )ASN1_item_d2i((ASN1_VALUE *)a, in, len,
418			&PKCS12_SAFEBAG_it);
419			}
420
421			int
422			i2d_PKCS12_SAFEBAG(PKCS12_SAFEBAG a, unsigned char *out)
423			{
424			return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_SAFEBAG_it);
425			}
426
427			PKCS12_SAFEBAG *
428			PKCS12_SAFEBAG_new(void)
429			{
430			return (PKCS12_SAFEBAG *)ASN1_item_new(&PKCS12_SAFEBAG_it);
431			}
432
433			void
434			PKCS12_SAFEBAG_free(PKCS12_SAFEBAG *a)
435			{
436			ASN1_item_free((ASN1_VALUE *)a, &PKCS12_SAFEBAG_it);
437			}
438
439			/* SEQUENCE OF SafeBag */
440			static const ASN1_TEMPLATE PKCS12_SAFEBAGS_item_tt = {
441			.flags = ASN1_TFLG_SEQUENCE_OF,
442			.tag = 0,
443			.offset = 0,
444			.field_name = "PKCS12_SAFEBAGS",
445			.item = &PKCS12_SAFEBAG_it,
446			};
447
448			const ASN1_ITEM PKCS12_SAFEBAGS_it = {
449			.itype = ASN1_ITYPE_PRIMITIVE,
450			.utype = -1,
451			.templates = &PKCS12_SAFEBAGS_item_tt,
452			.tcount = 0,
453			.funcs = NULL,
454			.size = 0,
455			.sname = "PKCS12_SAFEBAGS",
456			};
457
458			/* Authsafes: SEQUENCE OF PKCS7 */
459			static const ASN1_TEMPLATE PKCS12_AUTHSAFES_item_tt = {
460			.flags = ASN1_TFLG_SEQUENCE_OF,
461			.tag = 0,
462			.offset = 0,
463			.field_name = "PKCS12_AUTHSAFES",
464			.item = &PKCS7_it,
465			};
466
467			const ASN1_ITEM PKCS12_AUTHSAFES_it = {
468			.itype = ASN1_ITYPE_PRIMITIVE,
469			.utype = -1,
470			.templates = &PKCS12_AUTHSAFES_item_tt,
471			.tcount = 0,
472			.funcs = NULL,
473			.size = 0,
474			.sname = "PKCS12_AUTHSAFES",
475			};
476