/src/libressl/crypto/pkcs12/p12_asn.c

Source (jump to first uncovered line)
/* $OpenBSD: p12_asn.c,v 1.11 2022/07/24 18:48:04 tb 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),
  .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_SEQUENCE_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),
  .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",
};


Coverage Report

Created: 2022-08-24 06:30

Line	Count	Source (jump to first uncovered line)
1		/* $OpenBSD: p12_asn.c,v 1.11 2022/07/24 18:48:04 tb 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	0	{
104	0	return (PKCS12 )ASN1_item_d2i((ASN1_VALUE *)a, in, len,
105	0	&PKCS12_it);
106	0	}
107
108		int
109		i2d_PKCS12(PKCS12 a, unsigned char *out)
110	0	{
111	0	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_it);
112	0	}
113
114		PKCS12 *
115		PKCS12_new(void)
116	0	{
117	0	return (PKCS12 *)ASN1_item_new(&PKCS12_it);
118	0	}
119
120		void
121		PKCS12_free(PKCS12 *a)
122	0	{
123	0	ASN1_item_free((ASN1_VALUE *)a, &PKCS12_it);
124	0	}
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	0	{
164	0	return (PKCS12_MAC_DATA )ASN1_item_d2i((ASN1_VALUE *)a, in, len,
165	0	&PKCS12_MAC_DATA_it);
166	0	}
167
168		int
169		i2d_PKCS12_MAC_DATA(PKCS12_MAC_DATA a, unsigned char *out)
170	0	{
171	0	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_MAC_DATA_it);
172	0	}
173
174		PKCS12_MAC_DATA *
175		PKCS12_MAC_DATA_new(void)
176	0	{
177	0	return (PKCS12_MAC_DATA *)ASN1_item_new(&PKCS12_MAC_DATA_it);
178	0	}
179
180		void
181		PKCS12_MAC_DATA_free(PKCS12_MAC_DATA *a)
182	0	{
183	0	ASN1_item_free((ASN1_VALUE *)a, &PKCS12_MAC_DATA_it);
184	0	}
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		.tbl = PKCS12_BAGS_adbtbl,
234		.tblcount = sizeof(PKCS12_BAGS_adbtbl) / sizeof(ASN1_ADB_TABLE),
235		.default_tt = &bag_default_tt,
236		.null_tt = NULL,
237		};
238
239		static const ASN1_TEMPLATE PKCS12_BAGS_seq_tt[] = {
240		{
241		.flags = 0,
242		.tag = 0,
243		.offset = offsetof(PKCS12_BAGS, type),
244		.field_name = "type",
245		.item = &ASN1_OBJECT_it,
246		},
247		{
248		.flags = ASN1_TFLG_ADB_OID,
249		.tag = -1,
250		.offset = 0,
251		.field_name = "PKCS12_BAGS",
252		.item = (const ASN1_ITEM *)&PKCS12_BAGS_adb,
253		},
254		};
255
256		const ASN1_ITEM PKCS12_BAGS_it = {
257		.itype = ASN1_ITYPE_SEQUENCE,
258		.utype = V_ASN1_SEQUENCE,
259		.templates = PKCS12_BAGS_seq_tt,
260		.tcount = sizeof(PKCS12_BAGS_seq_tt) / sizeof(ASN1_TEMPLATE),
261		.funcs = NULL,
262		.size = sizeof(PKCS12_BAGS),
263		.sname = "PKCS12_BAGS",
264		};
265
266
267		PKCS12_BAGS *
268		d2i_PKCS12_BAGS(PKCS12_BAGS a, const unsigned char in, long len)
269	0	{
270	0	return (PKCS12_BAGS )ASN1_item_d2i((ASN1_VALUE *)a, in, len,
271	0	&PKCS12_BAGS_it);
272	0	}
273
274		int
275		i2d_PKCS12_BAGS(PKCS12_BAGS a, unsigned char *out)
276	0	{
277	0	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_BAGS_it);
278	0	}
279
280		PKCS12_BAGS *
281		PKCS12_BAGS_new(void)
282	0	{
283	0	return (PKCS12_BAGS *)ASN1_item_new(&PKCS12_BAGS_it);
284	0	}
285
286		void
287		PKCS12_BAGS_free(PKCS12_BAGS *a)
288	0	{
289	0	ASN1_item_free((ASN1_VALUE *)a, &PKCS12_BAGS_it);
290	0	}
291
292		static const ASN1_TEMPLATE safebag_default_tt = {
293		.flags = ASN1_TFLG_EXPLICIT,
294		.tag = 0,
295		.offset = offsetof(PKCS12_SAFEBAG, value.other),
296		.field_name = "value.other",
297		.item = &ASN1_ANY_it,
298		};
299
300		static const ASN1_ADB_TABLE PKCS12_SAFEBAG_adbtbl[] = {
301		{
302		.value = NID_keyBag,
303		.tt = {
304		.flags = ASN1_TFLG_EXPLICIT,
305		.tag = 0,
306		.offset = offsetof(PKCS12_SAFEBAG, value.keybag),
307		.field_name = "value.keybag",
308		.item = &PKCS8_PRIV_KEY_INFO_it,
309		},
310
311		},
312		{
313		.value = NID_pkcs8ShroudedKeyBag,
314		.tt = {
315		.flags = ASN1_TFLG_EXPLICIT,
316		.tag = 0,
317		.offset = offsetof(PKCS12_SAFEBAG, value.shkeybag),
318		.field_name = "value.shkeybag",
319		.item = &X509_SIG_it,
320		},
321
322		},
323		{
324		.value = NID_safeContentsBag,
325		.tt = {
326		.flags = ASN1_TFLG_EXPLICIT \| ASN1_TFLG_SEQUENCE_OF,
327		.tag = 0,
328		.offset = offsetof(PKCS12_SAFEBAG, value.safes),
329		.field_name = "value.safes",
330		.item = &PKCS12_SAFEBAG_it,
331		},
332		},
333		{
334		.value = NID_certBag,
335		.tt = {
336		.flags = ASN1_TFLG_EXPLICIT,
337		.tag = 0,
338		.offset = offsetof(PKCS12_SAFEBAG, value.bag),
339		.field_name = "value.bag",
340		.item = &PKCS12_BAGS_it,
341		},
342
343		},
344		{
345		.value = NID_crlBag,
346		.tt = {
347		.flags = ASN1_TFLG_EXPLICIT,
348		.tag = 0,
349		.offset = offsetof(PKCS12_SAFEBAG, value.bag),
350		.field_name = "value.bag",
351		.item = &PKCS12_BAGS_it,
352		},
353
354		},
355		{
356		.value = NID_secretBag,
357		.tt = {
358		.flags = ASN1_TFLG_EXPLICIT,
359		.tag = 0,
360		.offset = offsetof(PKCS12_SAFEBAG, value.bag),
361		.field_name = "value.bag",
362		.item = &PKCS12_BAGS_it,
363		},
364
365		},
366		};
367
368		static const ASN1_ADB PKCS12_SAFEBAG_adb = {
369		.flags = 0,
370		.offset = offsetof(PKCS12_SAFEBAG, type),
371		.tbl = PKCS12_SAFEBAG_adbtbl,
372		.tblcount = sizeof(PKCS12_SAFEBAG_adbtbl) / sizeof(ASN1_ADB_TABLE),
373		.default_tt = &safebag_default_tt,
374		.null_tt = NULL,
375		};
376
377		static const ASN1_TEMPLATE PKCS12_SAFEBAG_seq_tt[] = {
378		{
379		.flags = 0,
380		.tag = 0,
381		.offset = offsetof(PKCS12_SAFEBAG, type),
382		.field_name = "type",
383		.item = &ASN1_OBJECT_it,
384		},
385		{
386		.flags = ASN1_TFLG_ADB_OID,
387		.tag = -1,
388		.offset = 0,
389		.field_name = "PKCS12_SAFEBAG",
390		.item = (const ASN1_ITEM *)&PKCS12_SAFEBAG_adb,
391		},
392		{
393		.flags = ASN1_TFLG_SET_OF \| ASN1_TFLG_OPTIONAL,
394		.tag = 0,
395		.offset = offsetof(PKCS12_SAFEBAG, attrib),
396		.field_name = "attrib",
397		.item = &X509_ATTRIBUTE_it,
398		},
399		};
400
401		const ASN1_ITEM PKCS12_SAFEBAG_it = {
402		.itype = ASN1_ITYPE_SEQUENCE,
403		.utype = V_ASN1_SEQUENCE,
404		.templates = PKCS12_SAFEBAG_seq_tt,
405		.tcount = sizeof(PKCS12_SAFEBAG_seq_tt) / sizeof(ASN1_TEMPLATE),
406		.funcs = NULL,
407		.size = sizeof(PKCS12_SAFEBAG),
408		.sname = "PKCS12_SAFEBAG",
409		};
410
411
412		PKCS12_SAFEBAG *
413		d2i_PKCS12_SAFEBAG(PKCS12_SAFEBAG a, const unsigned char in, long len)
414	0	{
415	0	return (PKCS12_SAFEBAG )ASN1_item_d2i((ASN1_VALUE *)a, in, len,
416	0	&PKCS12_SAFEBAG_it);
417	0	}
418
419		int
420		i2d_PKCS12_SAFEBAG(PKCS12_SAFEBAG a, unsigned char *out)
421	0	{
422	0	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_SAFEBAG_it);
423	0	}
424
425		PKCS12_SAFEBAG *
426		PKCS12_SAFEBAG_new(void)
427	0	{
428	0	return (PKCS12_SAFEBAG *)ASN1_item_new(&PKCS12_SAFEBAG_it);
429	0	}
430
431		void
432		PKCS12_SAFEBAG_free(PKCS12_SAFEBAG *a)
433	0	{
434	0	ASN1_item_free((ASN1_VALUE *)a, &PKCS12_SAFEBAG_it);
435	0	}
436
437		/* SEQUENCE OF SafeBag */
438		static const ASN1_TEMPLATE PKCS12_SAFEBAGS_item_tt = {
439		.flags = ASN1_TFLG_SEQUENCE_OF,
440		.tag = 0,
441		.offset = 0,
442		.field_name = "PKCS12_SAFEBAGS",
443		.item = &PKCS12_SAFEBAG_it,
444		};
445
446		const ASN1_ITEM PKCS12_SAFEBAGS_it = {
447		.itype = ASN1_ITYPE_PRIMITIVE,
448		.utype = -1,
449		.templates = &PKCS12_SAFEBAGS_item_tt,
450		.tcount = 0,
451		.funcs = NULL,
452		.size = 0,
453		.sname = "PKCS12_SAFEBAGS",
454		};
455
456		/* Authsafes: SEQUENCE OF PKCS7 */
457		static const ASN1_TEMPLATE PKCS12_AUTHSAFES_item_tt = {
458		.flags = ASN1_TFLG_SEQUENCE_OF,
459		.tag = 0,
460		.offset = 0,
461		.field_name = "PKCS12_AUTHSAFES",
462		.item = &PKCS7_it,
463		};
464
465		const ASN1_ITEM PKCS12_AUTHSAFES_it = {
466		.itype = ASN1_ITYPE_PRIMITIVE,
467		.utype = -1,
468		.templates = &PKCS12_AUTHSAFES_item_tt,
469		.tcount = 0,
470		.funcs = NULL,
471		.size = 0,
472		.sname = "PKCS12_AUTHSAFES",
473		};
474