1/* Generated from pkcs12.asn1 */
2/* Do not edit */
3
4#define ASN1_LIB
5
6#include <stdio.h>
7#include <stdlib.h>
8#include <time.h>
9#include <string.h>
10#include <errno.h>
11#include <limits.h>
12#include <krb5/krb5-types.h>
13#include "pkcs12_asn1.h"
14#include "pkcs12_asn1-priv.h"
15#include <krb5/asn1_err.h>
16#include <krb5/der.h>
17#include <asn1-template.h>
18
19#include <krb5/parse_units.h>
20
21static unsigned oid_id_pkcs_12_variable_num[6] = {1, 2, 840, 113549, 1, 12 };
22const heim_oid asn1_oid_id_pkcs_12 = { 6, oid_id_pkcs_12_variable_num };
23
24static unsigned oid_id_pkcs_12PbeIds_variable_num[7] = {1, 2, 840, 113549, 1, 12, 1 };
25const heim_oid asn1_oid_id_pkcs_12PbeIds = { 7, oid_id_pkcs_12PbeIds_variable_num };
26
27static unsigned oid_id_pbeWithSHAAnd128BitRC4_variable_num[8] = {1, 2, 840, 113549, 1, 12, 1, 1 };
28const heim_oid asn1_oid_id_pbeWithSHAAnd128BitRC4 = { 8, oid_id_pbeWithSHAAnd128BitRC4_variable_num };
29
30static unsigned oid_id_pbeWithSHAAnd40BitRC4_variable_num[8] = {1, 2, 840, 113549, 1, 12, 1, 2 };
31const heim_oid asn1_oid_id_pbeWithSHAAnd40BitRC4 = { 8, oid_id_pbeWithSHAAnd40BitRC4_variable_num };
32
33static unsigned oid_id_pbeWithSHAAnd3_KeyTripleDES_CBC_variable_num[8] = {1, 2, 840, 113549, 1, 12, 1, 3 };
34const heim_oid asn1_oid_id_pbeWithSHAAnd3_KeyTripleDES_CBC = { 8, oid_id_pbeWithSHAAnd3_KeyTripleDES_CBC_variable_num };
35
36static unsigned oid_id_pbeWithSHAAnd2_KeyTripleDES_CBC_variable_num[8] = {1, 2, 840, 113549, 1, 12, 1, 4 };
37const heim_oid asn1_oid_id_pbeWithSHAAnd2_KeyTripleDES_CBC = { 8, oid_id_pbeWithSHAAnd2_KeyTripleDES_CBC_variable_num };
38
39static unsigned oid_id_pbeWithSHAAnd128BitRC2_CBC_variable_num[8] = {1, 2, 840, 113549, 1, 12, 1, 5 };
40const heim_oid asn1_oid_id_pbeWithSHAAnd128BitRC2_CBC = { 8, oid_id_pbeWithSHAAnd128BitRC2_CBC_variable_num };
41
42static unsigned oid_id_pbewithSHAAnd40BitRC2_CBC_variable_num[8] = {1, 2, 840, 113549, 1, 12, 1, 6 };
43const heim_oid asn1_oid_id_pbewithSHAAnd40BitRC2_CBC = { 8, oid_id_pbewithSHAAnd40BitRC2_CBC_variable_num };
44
45static unsigned oid_id_pkcs12_bagtypes_variable_num[8] = {1, 2, 840, 113549, 1, 12, 10, 1 };
46const heim_oid asn1_oid_id_pkcs12_bagtypes = { 8, oid_id_pkcs12_bagtypes_variable_num };
47
48static unsigned oid_id_pkcs12_keyBag_variable_num[9] = {1, 2, 840, 113549, 1, 12, 10, 1, 1 };
49const heim_oid asn1_oid_id_pkcs12_keyBag = { 9, oid_id_pkcs12_keyBag_variable_num };
50
51static unsigned oid_id_pkcs12_pkcs8ShroudedKeyBag_variable_num[9] = {1, 2, 840, 113549, 1, 12, 10, 1, 2 };
52const heim_oid asn1_oid_id_pkcs12_pkcs8ShroudedKeyBag = { 9, oid_id_pkcs12_pkcs8ShroudedKeyBag_variable_num };
53
54static unsigned oid_id_pkcs12_certBag_variable_num[9] = {1, 2, 840, 113549, 1, 12, 10, 1, 3 };
55const heim_oid asn1_oid_id_pkcs12_certBag = { 9, oid_id_pkcs12_certBag_variable_num };
56
57static unsigned oid_id_pkcs12_crlBag_variable_num[9] = {1, 2, 840, 113549, 1, 12, 10, 1, 4 };
58const heim_oid asn1_oid_id_pkcs12_crlBag = { 9, oid_id_pkcs12_crlBag_variable_num };
59
60static unsigned oid_id_pkcs12_secretBag_variable_num[9] = {1, 2, 840, 113549, 1, 12, 10, 1, 5 };
61const heim_oid asn1_oid_id_pkcs12_secretBag = { 9, oid_id_pkcs12_secretBag_variable_num };
62
63static unsigned oid_id_pkcs12_safeContentsBag_variable_num[9] = {1, 2, 840, 113549, 1, 12, 10, 1, 6 };
64const heim_oid asn1_oid_id_pkcs12_safeContentsBag = { 9, oid_id_pkcs12_safeContentsBag_variable_num };
65
66int ASN1CALL
67encode_PKCS12_MacData(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PKCS12_MacData *data, size_t *size)
68{
69size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
70size_t l HEIMDAL_UNUSED_ATTRIBUTE;
71int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
72
73/* iterations */
74if((data)->iterations) {
75size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
76ret = 0;
77e = der_put_heim_integer(p, len, (data)->iterations, &l);
78if (e) return e;
79p -= l; len -= l; ret += l;
80
81e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
82if (e) return e;
83p -= l; len -= l; ret += l;
84
85ret += Top_tag_oldret;
86}
87/* macSalt */
88{
89size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
90ret = 0;
91e = der_put_octet_string(p, len, &(data)->macSalt, &l);
92if (e) return e;
93p -= l; len -= l; ret += l;
94
95e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
96if (e) return e;
97p -= l; len -= l; ret += l;
98
99ret += Top_tag_oldret;
100}
101/* mac */
102{
103size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
104ret = 0;
105e = encode_DigestInfo(p, len, &(data)->mac, &l);
106if (e) return e;
107p -= l; len -= l; ret += l;
108
109ret += Top_tag_oldret;
110}
111e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
112if (e) return e;
113p -= l; len -= l; ret += l;
114
115*size = ret;
116return 0;
117}
118
119int ASN1CALL
120decode_PKCS12_MacData(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PKCS12_MacData *data, size_t *size)
121{
122size_t ret = 0;
123size_t l HEIMDAL_UNUSED_ATTRIBUTE;
124int e HEIMDAL_UNUSED_ATTRIBUTE;
125
126memset(data, 0, sizeof(*data));
127{
128size_t Top_datalen, Top_oldlen;
129Der_type Top_type;
130e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
131if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
132if(e) goto fail;
133p += l; len -= l; ret += l;
134Top_oldlen = len;
135if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
136len = Top_datalen;
137e = decode_DigestInfo(p, len, &(data)->mac, &l);
138if(e) goto fail;
139p += l; len -= l; ret += l;
140{
141size_t macSalt_datalen, macSalt_oldlen;
142Der_type macSalt_type;
143e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &macSalt_type, UT_OctetString, &macSalt_datalen, &l);
144if (e == 0 && macSalt_type != PRIM) { e = ASN1_BAD_ID; }
145if(e) goto fail;
146p += l; len -= l; ret += l;
147macSalt_oldlen = len;
148if (macSalt_datalen > len) { e = ASN1_OVERRUN; goto fail; }
149len = macSalt_datalen;
150e = der_get_octet_string(p, len, &(data)->macSalt, &l);
151if(e) goto fail;
152p += l; len -= l; ret += l;
153len = macSalt_oldlen - macSalt_datalen;
154}
155{
156size_t iterations_datalen, iterations_oldlen;
157Der_type iterations_type;
158e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &iterations_type, UT_Integer, &iterations_datalen, &l);
159if (e == 0 && iterations_type != PRIM) { e = ASN1_BAD_ID; }
160if(e) {
161(data)->iterations = NULL;
162} else {
163(data)->iterations = calloc(1, sizeof(*(data)->iterations));
164if ((data)->iterations == NULL) { e = ENOMEM; goto fail; }
165p += l; len -= l; ret += l;
166iterations_oldlen = len;
167if (iterations_datalen > len) { e = ASN1_OVERRUN; goto fail; }
168len = iterations_datalen;
169e = der_get_heim_integer(p, len, (data)->iterations, &l);
170if(e) goto fail;
171p += l; len -= l; ret += l;
172len = iterations_oldlen - iterations_datalen;
173}
174}
175len = Top_oldlen - Top_datalen;
176}
177if(size) *size = ret;
178return 0;
179fail:
180free_PKCS12_MacData(data);
181return e;
182}
183
184void ASN1CALL
185free_PKCS12_MacData(PKCS12_MacData *data)
186{
187free_DigestInfo(&(data)->mac);
188der_free_octet_string(&(data)->macSalt);
189if((data)->iterations) {
190der_free_heim_integer((data)->iterations);
191free((data)->iterations);
192(data)->iterations = NULL;
193}
194}
195
196size_t ASN1CALL
197length_PKCS12_MacData(const PKCS12_MacData *data)
198{
199size_t ret = 0;
200{
201size_t Top_tag_oldret = ret;
202ret = 0;
203ret += length_DigestInfo(&(data)->mac);
204ret += Top_tag_oldret;
205}
206{
207size_t Top_tag_oldret = ret;
208ret = 0;
209ret += der_length_octet_string(&(data)->macSalt);
210ret += 1 + der_length_len (ret);
211ret += Top_tag_oldret;
212}
213if((data)->iterations){
214size_t Top_tag_oldret = ret;
215ret = 0;
216ret += der_length_heim_integer((data)->iterations);
217ret += 1 + der_length_len (ret);
218ret += Top_tag_oldret;
219}
220ret += 1 + der_length_len (ret);
221return ret;
222}
223
224int ASN1CALL
225copy_PKCS12_MacData(const PKCS12_MacData *from, PKCS12_MacData *to)
226{
227memset(to, 0, sizeof(*to));
228if(copy_DigestInfo(&(from)->mac, &(to)->mac)) goto fail;
229if(der_copy_octet_string(&(from)->macSalt, &(to)->macSalt)) goto fail;
230if((from)->iterations) {
231(to)->iterations = malloc(sizeof(*(to)->iterations));
232if((to)->iterations == NULL) goto fail;
233if(der_copy_heim_integer((from)->iterations, (to)->iterations)) goto fail;
234}else
235(to)->iterations = NULL;
236return 0;
237fail:
238free_PKCS12_MacData(to);
239return ENOMEM;
240}
241
242int ASN1CALL
243encode_PKCS12_PFX(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PKCS12_PFX *data, size_t *size)
244{
245size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
246size_t l HEIMDAL_UNUSED_ATTRIBUTE;
247int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
248
249/* macData */
250if((data)->macData) {
251size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
252ret = 0;
253e = encode_PKCS12_MacData(p, len, (data)->macData, &l);
254if (e) return e;
255p -= l; len -= l; ret += l;
256
257ret += Top_tag_oldret;
258}
259/* authSafe */
260{
261size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
262ret = 0;
263e = encode_ContentInfo(p, len, &(data)->authSafe, &l);
264if (e) return e;
265p -= l; len -= l; ret += l;
266
267ret += Top_tag_oldret;
268}
269/* version */
270{
271size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
272ret = 0;
273e = der_put_heim_integer(p, len, &(data)->version, &l);
274if (e) return e;
275p -= l; len -= l; ret += l;
276
277e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
278if (e) return e;
279p -= l; len -= l; ret += l;
280
281ret += Top_tag_oldret;
282}
283e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
284if (e) return e;
285p -= l; len -= l; ret += l;
286
287*size = ret;
288return 0;
289}
290
291int ASN1CALL
292decode_PKCS12_PFX(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PKCS12_PFX *data, size_t *size)
293{
294size_t ret = 0;
295size_t l HEIMDAL_UNUSED_ATTRIBUTE;
296int e HEIMDAL_UNUSED_ATTRIBUTE;
297
298memset(data, 0, sizeof(*data));
299{
300size_t Top_datalen, Top_oldlen;
301Der_type Top_type;
302e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
303if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
304if(e) goto fail;
305p += l; len -= l; ret += l;
306Top_oldlen = len;
307if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
308len = Top_datalen;
309{
310size_t version_datalen, version_oldlen;
311Der_type version_type;
312e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &version_type, UT_Integer, &version_datalen, &l);
313if (e == 0 && version_type != PRIM) { e = ASN1_BAD_ID; }
314if(e) goto fail;
315p += l; len -= l; ret += l;
316version_oldlen = len;
317if (version_datalen > len) { e = ASN1_OVERRUN; goto fail; }
318len = version_datalen;
319e = der_get_heim_integer(p, len, &(data)->version, &l);
320if(e) goto fail;
321p += l; len -= l; ret += l;
322len = version_oldlen - version_datalen;
323}
324e = decode_ContentInfo(p, len, &(data)->authSafe, &l);
325if(e) goto fail;
326p += l; len -= l; ret += l;
327(data)->macData = calloc(1, sizeof(*(data)->macData));
328if ((data)->macData == NULL) goto fail;
329e = decode_PKCS12_MacData(p, len, (data)->macData, &l);
330if(e) {
331free((data)->macData);
332(data)->macData = NULL;
333} else {
334p += l; len -= l; ret += l;
335}
336len = Top_oldlen - Top_datalen;
337}
338if(size) *size = ret;
339return 0;
340fail:
341free_PKCS12_PFX(data);
342return e;
343}
344
345void ASN1CALL
346free_PKCS12_PFX(PKCS12_PFX *data)
347{
348der_free_heim_integer(&(data)->version);
349free_ContentInfo(&(data)->authSafe);
350if((data)->macData) {
351free_PKCS12_MacData((data)->macData);
352free((data)->macData);
353(data)->macData = NULL;
354}
355}
356
357size_t ASN1CALL
358length_PKCS12_PFX(const PKCS12_PFX *data)
359{
360size_t ret = 0;
361{
362size_t Top_tag_oldret = ret;
363ret = 0;
364ret += der_length_heim_integer(&(data)->version);
365ret += 1 + der_length_len (ret);
366ret += Top_tag_oldret;
367}
368{
369size_t Top_tag_oldret = ret;
370ret = 0;
371ret += length_ContentInfo(&(data)->authSafe);
372ret += Top_tag_oldret;
373}
374if((data)->macData){
375size_t Top_tag_oldret = ret;
376ret = 0;
377ret += length_PKCS12_MacData((data)->macData);
378ret += Top_tag_oldret;
379}
380ret += 1 + der_length_len (ret);
381return ret;
382}
383
384int ASN1CALL
385copy_PKCS12_PFX(const PKCS12_PFX *from, PKCS12_PFX *to)
386{
387memset(to, 0, sizeof(*to));
388if(der_copy_heim_integer(&(from)->version, &(to)->version)) goto fail;
389if(copy_ContentInfo(&(from)->authSafe, &(to)->authSafe)) goto fail;
390if((from)->macData) {
391(to)->macData = malloc(sizeof(*(to)->macData));
392if((to)->macData == NULL) goto fail;
393if(copy_PKCS12_MacData((from)->macData, (to)->macData)) goto fail;
394}else
395(to)->macData = NULL;
396return 0;
397fail:
398free_PKCS12_PFX(to);
399return ENOMEM;
400}
401
402int ASN1CALL
403encode_PKCS12_AuthenticatedSafe(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PKCS12_AuthenticatedSafe *data, size_t *size)
404{
405size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
406size_t l HEIMDAL_UNUSED_ATTRIBUTE;
407int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
408
409for(i = (int)(data)->len - 1; i >= 0; --i) {
410size_t Top_tag_for_oldret = ret;
411ret = 0;
412e = encode_ContentInfo(p, len, &(data)->val[i], &l);
413if (e) return e;
414p -= l; len -= l; ret += l;
415
416ret += Top_tag_for_oldret;
417}
418e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
419if (e) return e;
420p -= l; len -= l; ret += l;
421
422*size = ret;
423return 0;
424}
425
426int ASN1CALL
427decode_PKCS12_AuthenticatedSafe(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PKCS12_AuthenticatedSafe *data, size_t *size)
428{
429size_t ret = 0;
430size_t l HEIMDAL_UNUSED_ATTRIBUTE;
431int e HEIMDAL_UNUSED_ATTRIBUTE;
432
433memset(data, 0, sizeof(*data));
434{
435size_t Top_datalen, Top_oldlen;
436Der_type Top_type;
437e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
438if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
439if(e) goto fail;
440p += l; len -= l; ret += l;
441Top_oldlen = len;
442if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
443len = Top_datalen;
444{
445size_t Top_Tag_origlen = len;
446size_t Top_Tag_oldret = ret;
447size_t Top_Tag_olen = 0;
448void *Top_Tag_tmp;
449ret = 0;
450(data)->len = 0;
451(data)->val = NULL;
452while(ret < Top_Tag_origlen) {
453size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
454if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
455Top_Tag_olen = Top_Tag_nlen;
456Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
457if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
458(data)->val = Top_Tag_tmp;
459e = decode_ContentInfo(p, len, &(data)->val[(data)->len], &l);
460if(e) goto fail;
461p += l; len -= l; ret += l;
462(data)->len++;
463len = Top_Tag_origlen - ret;
464}
465ret += Top_Tag_oldret;
466}
467len = Top_oldlen - Top_datalen;
468}
469if(size) *size = ret;
470return 0;
471fail:
472free_PKCS12_AuthenticatedSafe(data);
473return e;
474}
475
476void ASN1CALL
477free_PKCS12_AuthenticatedSafe(PKCS12_AuthenticatedSafe *data)
478{
479while((data)->len){
480free_ContentInfo(&(data)->val[(data)->len-1]);
481(data)->len--;
482}
483free((data)->val);
484(data)->val = NULL;
485}
486
487size_t ASN1CALL
488length_PKCS12_AuthenticatedSafe(const PKCS12_AuthenticatedSafe *data)
489{
490size_t ret = 0;
491{
492size_t Top_tag_oldret = ret;
493unsigned int n_Top_tag;
494ret = 0;
495for(n_Top_tag = (data)->len; n_Top_tag > 0; --n_Top_tag){
496size_t Top_tag_for_oldret = ret;
497ret = 0;
498ret += length_ContentInfo(&(data)->val[n_Top_tag - 1]);
499ret += Top_tag_for_oldret;
500}
501ret += Top_tag_oldret;
502}
503ret += 1 + der_length_len (ret);
504return ret;
505}
506
507int ASN1CALL
508copy_PKCS12_AuthenticatedSafe(const PKCS12_AuthenticatedSafe *from, PKCS12_AuthenticatedSafe *to)
509{
510memset(to, 0, sizeof(*to));
511if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
512goto fail;
513for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
514if(copy_ContentInfo(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
515}
516return 0;
517fail:
518free_PKCS12_AuthenticatedSafe(to);
519return ENOMEM;
520}
521
522int ASN1CALL
523encode_PKCS12_Attribute(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PKCS12_Attribute *data, size_t *size)
524{
525size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
526size_t l HEIMDAL_UNUSED_ATTRIBUTE;
527int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
528
529/* attrValues */
530{
531size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
532ret = 0;
533e = encode_heim_any_set(p, len, &(data)->attrValues, &l);
534if (e) return e;
535p -= l; len -= l; ret += l;
536
537ret += Top_tag_oldret;
538}
539/* attrId */
540{
541size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
542ret = 0;
543e = der_put_oid(p, len, &(data)->attrId, &l);
544if (e) return e;
545p -= l; len -= l; ret += l;
546
547e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
548if (e) return e;
549p -= l; len -= l; ret += l;
550
551ret += Top_tag_oldret;
552}
553e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
554if (e) return e;
555p -= l; len -= l; ret += l;
556
557*size = ret;
558return 0;
559}
560
561int ASN1CALL
562decode_PKCS12_Attribute(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PKCS12_Attribute *data, size_t *size)
563{
564size_t ret = 0;
565size_t l HEIMDAL_UNUSED_ATTRIBUTE;
566int e HEIMDAL_UNUSED_ATTRIBUTE;
567
568memset(data, 0, sizeof(*data));
569{
570size_t Top_datalen, Top_oldlen;
571Der_type Top_type;
572e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
573if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
574if(e) goto fail;
575p += l; len -= l; ret += l;
576Top_oldlen = len;
577if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
578len = Top_datalen;
579{
580size_t attrId_datalen, attrId_oldlen;
581Der_type attrId_type;
582e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &attrId_type, UT_OID, &attrId_datalen, &l);
583if (e == 0 && attrId_type != PRIM) { e = ASN1_BAD_ID; }
584if(e) goto fail;
585p += l; len -= l; ret += l;
586attrId_oldlen = len;
587if (attrId_datalen > len) { e = ASN1_OVERRUN; goto fail; }
588len = attrId_datalen;
589e = der_get_oid(p, len, &(data)->attrId, &l);
590if(e) goto fail;
591p += l; len -= l; ret += l;
592len = attrId_oldlen - attrId_datalen;
593}
594e = decode_heim_any_set(p, len, &(data)->attrValues, &l);
595if(e) goto fail;
596p += l; len -= l; ret += l;
597len = Top_oldlen - Top_datalen;
598}
599if(size) *size = ret;
600return 0;
601fail:
602free_PKCS12_Attribute(data);
603return e;
604}
605
606void ASN1CALL
607free_PKCS12_Attribute(PKCS12_Attribute *data)
608{
609der_free_oid(&(data)->attrId);
610free_heim_any_set(&(data)->attrValues);
611}
612
613size_t ASN1CALL
614length_PKCS12_Attribute(const PKCS12_Attribute *data)
615{
616size_t ret = 0;
617{
618size_t Top_tag_oldret = ret;
619ret = 0;
620ret += der_length_oid(&(data)->attrId);
621ret += 1 + der_length_len (ret);
622ret += Top_tag_oldret;
623}
624{
625size_t Top_tag_oldret = ret;
626ret = 0;
627ret += length_heim_any_set(&(data)->attrValues);
628ret += Top_tag_oldret;
629}
630ret += 1 + der_length_len (ret);
631return ret;
632}
633
634int ASN1CALL
635copy_PKCS12_Attribute(const PKCS12_Attribute *from, PKCS12_Attribute *to)
636{
637memset(to, 0, sizeof(*to));
638if(der_copy_oid(&(from)->attrId, &(to)->attrId)) goto fail;
639if(copy_heim_any_set(&(from)->attrValues, &(to)->attrValues)) goto fail;
640return 0;
641fail:
642free_PKCS12_Attribute(to);
643return ENOMEM;
644}
645
646int ASN1CALL
647encode_PKCS12_Attributes(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PKCS12_Attributes *data, size_t *size)
648{
649size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
650size_t l HEIMDAL_UNUSED_ATTRIBUTE;
651int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
652
653{
654heim_octet_string *val;
655size_t elen = 0, totallen = 0;
656int eret = 0;
657if ((data)->len > UINT_MAX/sizeof(val[0]))
658return ERANGE;
659val = malloc(sizeof(val[0]) * (data)->len);
660if (val == NULL && (data)->len != 0) return ENOMEM;
661for(i = 0; i < (int)(data)->len; i++) {
662ASN1_MALLOC_ENCODE(PKCS12_Attribute, val[i].data, val[i].length, &(data)->val[i], &elen, eret);
663if(eret) {
664i--;
665while (i >= 0) {
666free(val[i].data);
667i--;
668}
669free(val);
670return eret;
671}
672totallen += elen;
673}
674if (totallen > len) {
675for (i = 0; i < (int)(data)->len; i++) {
676free(val[i].data);
677}
678free(val);
679return ASN1_OVERFLOW;
680}
681qsort(val, (data)->len, sizeof(val[0]), _heim_der_set_sort);
682for(i = (int)(data)->len - 1; i >= 0; --i) {
683p -= val[i].length;
684ret += val[i].length;
685memcpy(p + 1, val[i].data, val[i].length);
686free(val[i].data);
687}
688free(val);
689}
690e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Set, &l);
691if (e) return e;
692p -= l; len -= l; ret += l;
693
694*size = ret;
695return 0;
696}
697
698int ASN1CALL
699decode_PKCS12_Attributes(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PKCS12_Attributes *data, size_t *size)
700{
701size_t ret = 0;
702size_t l HEIMDAL_UNUSED_ATTRIBUTE;
703int e HEIMDAL_UNUSED_ATTRIBUTE;
704
705memset(data, 0, sizeof(*data));
706{
707size_t Top_datalen, Top_oldlen;
708Der_type Top_type;
709e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Set, &Top_datalen, &l);
710if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
711if(e) goto fail;
712p += l; len -= l; ret += l;
713Top_oldlen = len;
714if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
715len = Top_datalen;
716{
717size_t Top_Tag_origlen = len;
718size_t Top_Tag_oldret = ret;
719size_t Top_Tag_olen = 0;
720void *Top_Tag_tmp;
721ret = 0;
722(data)->len = 0;
723(data)->val = NULL;
724while(ret < Top_Tag_origlen) {
725size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
726if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
727Top_Tag_olen = Top_Tag_nlen;
728Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
729if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
730(data)->val = Top_Tag_tmp;
731e = decode_PKCS12_Attribute(p, len, &(data)->val[(data)->len], &l);
732if(e) goto fail;
733p += l; len -= l; ret += l;
734(data)->len++;
735len = Top_Tag_origlen - ret;
736}
737ret += Top_Tag_oldret;
738}
739len = Top_oldlen - Top_datalen;
740}
741if(size) *size = ret;
742return 0;
743fail:
744free_PKCS12_Attributes(data);
745return e;
746}
747
748void ASN1CALL
749free_PKCS12_Attributes(PKCS12_Attributes *data)
750{
751while((data)->len){
752free_PKCS12_Attribute(&(data)->val[(data)->len-1]);
753(data)->len--;
754}
755free((data)->val);
756(data)->val = NULL;
757}
758
759size_t ASN1CALL
760length_PKCS12_Attributes(const PKCS12_Attributes *data)
761{
762size_t ret = 0;
763{
764size_t Top_tag_oldret = ret;
765unsigned int n_Top_tag;
766ret = 0;
767for(n_Top_tag = (data)->len; n_Top_tag > 0; --n_Top_tag){
768size_t Top_tag_for_oldret = ret;
769ret = 0;
770ret += length_PKCS12_Attribute(&(data)->val[n_Top_tag - 1]);
771ret += Top_tag_for_oldret;
772}
773ret += Top_tag_oldret;
774}
775ret += 1 + der_length_len (ret);
776return ret;
777}
778
779int ASN1CALL
780copy_PKCS12_Attributes(const PKCS12_Attributes *from, PKCS12_Attributes *to)
781{
782memset(to, 0, sizeof(*to));
783if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
784goto fail;
785for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
786if(copy_PKCS12_Attribute(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
787}
788return 0;
789fail:
790free_PKCS12_Attributes(to);
791return ENOMEM;
792}
793
794int ASN1CALL
795encode_PKCS12_SafeBag(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PKCS12_SafeBag *data, size_t *size)
796{
797size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
798size_t l HEIMDAL_UNUSED_ATTRIBUTE;
799int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
800
801/* bagAttributes */
802if((data)->bagAttributes) {
803size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
804ret = 0;
805e = encode_PKCS12_Attributes(p, len, (data)->bagAttributes, &l);
806if (e) return e;
807p -= l; len -= l; ret += l;
808
809ret += Top_tag_oldret;
810}
811/* bagValue */
812{
813size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
814ret = 0;
815e = encode_heim_any(p, len, &(data)->bagValue, &l);
816if (e) return e;
817p -= l; len -= l; ret += l;
818
819e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
820if (e) return e;
821p -= l; len -= l; ret += l;
822
823ret += Top_tag_oldret;
824}
825/* bagId */
826{
827size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
828ret = 0;
829e = der_put_oid(p, len, &(data)->bagId, &l);
830if (e) return e;
831p -= l; len -= l; ret += l;
832
833e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
834if (e) return e;
835p -= l; len -= l; ret += l;
836
837ret += Top_tag_oldret;
838}
839e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
840if (e) return e;
841p -= l; len -= l; ret += l;
842
843*size = ret;
844return 0;
845}
846
847int ASN1CALL
848decode_PKCS12_SafeBag(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PKCS12_SafeBag *data, size_t *size)
849{
850size_t ret = 0;
851size_t l HEIMDAL_UNUSED_ATTRIBUTE;
852int e HEIMDAL_UNUSED_ATTRIBUTE;
853
854memset(data, 0, sizeof(*data));
855{
856size_t Top_datalen, Top_oldlen;
857Der_type Top_type;
858e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
859if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
860if(e) goto fail;
861p += l; len -= l; ret += l;
862Top_oldlen = len;
863if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
864len = Top_datalen;
865{
866size_t bagId_datalen, bagId_oldlen;
867Der_type bagId_type;
868e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &bagId_type, UT_OID, &bagId_datalen, &l);
869if (e == 0 && bagId_type != PRIM) { e = ASN1_BAD_ID; }
870if(e) goto fail;
871p += l; len -= l; ret += l;
872bagId_oldlen = len;
873if (bagId_datalen > len) { e = ASN1_OVERRUN; goto fail; }
874len = bagId_datalen;
875e = der_get_oid(p, len, &(data)->bagId, &l);
876if(e) goto fail;
877p += l; len -= l; ret += l;
878len = bagId_oldlen - bagId_datalen;
879}
880{
881size_t bagValue_datalen, bagValue_oldlen;
882Der_type bagValue_type;
883e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &bagValue_type, 0, &bagValue_datalen, &l);
884if (e == 0 && bagValue_type != CONS) { e = ASN1_BAD_ID; }
885if(e) goto fail;
886p += l; len -= l; ret += l;
887bagValue_oldlen = len;
888if (bagValue_datalen > len) { e = ASN1_OVERRUN; goto fail; }
889len = bagValue_datalen;
890e = decode_heim_any(p, len, &(data)->bagValue, &l);
891if(e) goto fail;
892p += l; len -= l; ret += l;
893len = bagValue_oldlen - bagValue_datalen;
894}
895(data)->bagAttributes = calloc(1, sizeof(*(data)->bagAttributes));
896if ((data)->bagAttributes == NULL) goto fail;
897e = decode_PKCS12_Attributes(p, len, (data)->bagAttributes, &l);
898if(e) {
899free((data)->bagAttributes);
900(data)->bagAttributes = NULL;
901} else {
902p += l; len -= l; ret += l;
903}
904len = Top_oldlen - Top_datalen;
905}
906if(size) *size = ret;
907return 0;
908fail:
909free_PKCS12_SafeBag(data);
910return e;
911}
912
913void ASN1CALL
914free_PKCS12_SafeBag(PKCS12_SafeBag *data)
915{
916der_free_oid(&(data)->bagId);
917free_heim_any(&(data)->bagValue);
918if((data)->bagAttributes) {
919free_PKCS12_Attributes((data)->bagAttributes);
920free((data)->bagAttributes);
921(data)->bagAttributes = NULL;
922}
923}
924
925size_t ASN1CALL
926length_PKCS12_SafeBag(const PKCS12_SafeBag *data)
927{
928size_t ret = 0;
929{
930size_t Top_tag_oldret = ret;
931ret = 0;
932ret += der_length_oid(&(data)->bagId);
933ret += 1 + der_length_len (ret);
934ret += Top_tag_oldret;
935}
936{
937size_t Top_tag_oldret = ret;
938ret = 0;
939ret += length_heim_any(&(data)->bagValue);
940ret += 1 + der_length_len (ret);
941ret += Top_tag_oldret;
942}
943if((data)->bagAttributes){
944size_t Top_tag_oldret = ret;
945ret = 0;
946ret += length_PKCS12_Attributes((data)->bagAttributes);
947ret += Top_tag_oldret;
948}
949ret += 1 + der_length_len (ret);
950return ret;
951}
952
953int ASN1CALL
954copy_PKCS12_SafeBag(const PKCS12_SafeBag *from, PKCS12_SafeBag *to)
955{
956memset(to, 0, sizeof(*to));
957if(der_copy_oid(&(from)->bagId, &(to)->bagId)) goto fail;
958if(copy_heim_any(&(from)->bagValue, &(to)->bagValue)) goto fail;
959if((from)->bagAttributes) {
960(to)->bagAttributes = malloc(sizeof(*(to)->bagAttributes));
961if((to)->bagAttributes == NULL) goto fail;
962if(copy_PKCS12_Attributes((from)->bagAttributes, (to)->bagAttributes)) goto fail;
963}else
964(to)->bagAttributes = NULL;
965return 0;
966fail:
967free_PKCS12_SafeBag(to);
968return ENOMEM;
969}
970
971int ASN1CALL
972encode_PKCS12_SafeContents(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PKCS12_SafeContents *data, size_t *size)
973{
974size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
975size_t l HEIMDAL_UNUSED_ATTRIBUTE;
976int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
977
978for(i = (int)(data)->len - 1; i >= 0; --i) {
979size_t Top_tag_for_oldret = ret;
980ret = 0;
981e = encode_PKCS12_SafeBag(p, len, &(data)->val[i], &l);
982if (e) return e;
983p -= l; len -= l; ret += l;
984
985ret += Top_tag_for_oldret;
986}
987e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
988if (e) return e;
989p -= l; len -= l; ret += l;
990
991*size = ret;
992return 0;
993}
994
995int ASN1CALL
996decode_PKCS12_SafeContents(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PKCS12_SafeContents *data, size_t *size)
997{
998size_t ret = 0;
999size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1000int e HEIMDAL_UNUSED_ATTRIBUTE;
1001
1002memset(data, 0, sizeof(*data));
1003{
1004size_t Top_datalen, Top_oldlen;
1005Der_type Top_type;
1006e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1007if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1008if(e) goto fail;
1009p += l; len -= l; ret += l;
1010Top_oldlen = len;
1011if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1012len = Top_datalen;
1013{
1014size_t Top_Tag_origlen = len;
1015size_t Top_Tag_oldret = ret;
1016size_t Top_Tag_olen = 0;
1017void *Top_Tag_tmp;
1018ret = 0;
1019(data)->len = 0;
1020(data)->val = NULL;
1021while(ret < Top_Tag_origlen) {
1022size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
1023if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
1024Top_Tag_olen = Top_Tag_nlen;
1025Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
1026if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
1027(data)->val = Top_Tag_tmp;
1028e = decode_PKCS12_SafeBag(p, len, &(data)->val[(data)->len], &l);
1029if(e) goto fail;
1030p += l; len -= l; ret += l;
1031(data)->len++;
1032len = Top_Tag_origlen - ret;
1033}
1034ret += Top_Tag_oldret;
1035}
1036len = Top_oldlen - Top_datalen;
1037}
1038if(size) *size = ret;
1039return 0;
1040fail:
1041free_PKCS12_SafeContents(data);
1042return e;
1043}
1044
1045void ASN1CALL
1046free_PKCS12_SafeContents(PKCS12_SafeContents *data)
1047{
1048while((data)->len){
1049free_PKCS12_SafeBag(&(data)->val[(data)->len-1]);
1050(data)->len--;
1051}
1052free((data)->val);
1053(data)->val = NULL;
1054}
1055
1056size_t ASN1CALL
1057length_PKCS12_SafeContents(const PKCS12_SafeContents *data)
1058{
1059size_t ret = 0;
1060{
1061size_t Top_tag_oldret = ret;
1062unsigned int n_Top_tag;
1063ret = 0;
1064for(n_Top_tag = (data)->len; n_Top_tag > 0; --n_Top_tag){
1065size_t Top_tag_for_oldret = ret;
1066ret = 0;
1067ret += length_PKCS12_SafeBag(&(data)->val[n_Top_tag - 1]);
1068ret += Top_tag_for_oldret;
1069}
1070ret += Top_tag_oldret;
1071}
1072ret += 1 + der_length_len (ret);
1073return ret;
1074}
1075
1076int ASN1CALL
1077copy_PKCS12_SafeContents(const PKCS12_SafeContents *from, PKCS12_SafeContents *to)
1078{
1079memset(to, 0, sizeof(*to));
1080if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
1081goto fail;
1082for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
1083if(copy_PKCS12_SafeBag(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
1084}
1085return 0;
1086fail:
1087free_PKCS12_SafeContents(to);
1088return ENOMEM;
1089}
1090
1091int ASN1CALL
1092encode_PKCS12_CertBag(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PKCS12_CertBag *data, size_t *size)
1093{
1094size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1095size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1096int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1097
1098/* certValue */
1099{
1100size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1101ret = 0;
1102e = encode_heim_any(p, len, &(data)->certValue, &l);
1103if (e) return e;
1104p -= l; len -= l; ret += l;
1105
1106e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
1107if (e) return e;
1108p -= l; len -= l; ret += l;
1109
1110ret += Top_tag_oldret;
1111}
1112/* certType */
1113{
1114size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1115ret = 0;
1116e = der_put_oid(p, len, &(data)->certType, &l);
1117if (e) return e;
1118p -= l; len -= l; ret += l;
1119
1120e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
1121if (e) return e;
1122p -= l; len -= l; ret += l;
1123
1124ret += Top_tag_oldret;
1125}
1126e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1127if (e) return e;
1128p -= l; len -= l; ret += l;
1129
1130*size = ret;
1131return 0;
1132}
1133
1134int ASN1CALL
1135decode_PKCS12_CertBag(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PKCS12_CertBag *data, size_t *size)
1136{
1137size_t ret = 0;
1138size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1139int e HEIMDAL_UNUSED_ATTRIBUTE;
1140
1141memset(data, 0, sizeof(*data));
1142{
1143size_t Top_datalen, Top_oldlen;
1144Der_type Top_type;
1145e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1146if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1147if(e) goto fail;
1148p += l; len -= l; ret += l;
1149Top_oldlen = len;
1150if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1151len = Top_datalen;
1152{
1153size_t certType_datalen, certType_oldlen;
1154Der_type certType_type;
1155e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &certType_type, UT_OID, &certType_datalen, &l);
1156if (e == 0 && certType_type != PRIM) { e = ASN1_BAD_ID; }
1157if(e) goto fail;
1158p += l; len -= l; ret += l;
1159certType_oldlen = len;
1160if (certType_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1161len = certType_datalen;
1162e = der_get_oid(p, len, &(data)->certType, &l);
1163if(e) goto fail;
1164p += l; len -= l; ret += l;
1165len = certType_oldlen - certType_datalen;
1166}
1167{
1168size_t certValue_datalen, certValue_oldlen;
1169Der_type certValue_type;
1170e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &certValue_type, 0, &certValue_datalen, &l);
1171if (e == 0 && certValue_type != CONS) { e = ASN1_BAD_ID; }
1172if(e) goto fail;
1173p += l; len -= l; ret += l;
1174certValue_oldlen = len;
1175if (certValue_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1176len = certValue_datalen;
1177e = decode_heim_any(p, len, &(data)->certValue, &l);
1178if(e) goto fail;
1179p += l; len -= l; ret += l;
1180len = certValue_oldlen - certValue_datalen;
1181}
1182len = Top_oldlen - Top_datalen;
1183}
1184if(size) *size = ret;
1185return 0;
1186fail:
1187free_PKCS12_CertBag(data);
1188return e;
1189}
1190
1191void ASN1CALL
1192free_PKCS12_CertBag(PKCS12_CertBag *data)
1193{
1194der_free_oid(&(data)->certType);
1195free_heim_any(&(data)->certValue);
1196}
1197
1198size_t ASN1CALL
1199length_PKCS12_CertBag(const PKCS12_CertBag *data)
1200{
1201size_t ret = 0;
1202{
1203size_t Top_tag_oldret = ret;
1204ret = 0;
1205ret += der_length_oid(&(data)->certType);
1206ret += 1 + der_length_len (ret);
1207ret += Top_tag_oldret;
1208}
1209{
1210size_t Top_tag_oldret = ret;
1211ret = 0;
1212ret += length_heim_any(&(data)->certValue);
1213ret += 1 + der_length_len (ret);
1214ret += Top_tag_oldret;
1215}
1216ret += 1 + der_length_len (ret);
1217return ret;
1218}
1219
1220int ASN1CALL
1221copy_PKCS12_CertBag(const PKCS12_CertBag *from, PKCS12_CertBag *to)
1222{
1223memset(to, 0, sizeof(*to));
1224if(der_copy_oid(&(from)->certType, &(to)->certType)) goto fail;
1225if(copy_heim_any(&(from)->certValue, &(to)->certValue)) goto fail;
1226return 0;
1227fail:
1228free_PKCS12_CertBag(to);
1229return ENOMEM;
1230}
1231
1232int ASN1CALL
1233encode_PKCS12_PBEParams(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PKCS12_PBEParams *data, size_t *size)
1234{
1235size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1236size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1237int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1238
1239/* iterations */
1240if((data)->iterations) {
1241size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1242ret = 0;
1243e = der_put_unsigned(p, len, (data)->iterations, &l);
1244if (e) return e;
1245p -= l; len -= l; ret += l;
1246
1247e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
1248if (e) return e;
1249p -= l; len -= l; ret += l;
1250
1251ret += Top_tag_oldret;
1252}
1253/* salt */
1254{
1255size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1256ret = 0;
1257e = der_put_octet_string(p, len, &(data)->salt, &l);
1258if (e) return e;
1259p -= l; len -= l; ret += l;
1260
1261e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
1262if (e) return e;
1263p -= l; len -= l; ret += l;
1264
1265ret += Top_tag_oldret;
1266}
1267e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1268if (e) return e;
1269p -= l; len -= l; ret += l;
1270
1271*size = ret;
1272return 0;
1273}
1274
1275int ASN1CALL
1276decode_PKCS12_PBEParams(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PKCS12_PBEParams *data, size_t *size)
1277{
1278size_t ret = 0;
1279size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1280int e HEIMDAL_UNUSED_ATTRIBUTE;
1281
1282memset(data, 0, sizeof(*data));
1283{
1284size_t Top_datalen, Top_oldlen;
1285Der_type Top_type;
1286e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1287if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1288if(e) goto fail;
1289p += l; len -= l; ret += l;
1290Top_oldlen = len;
1291if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1292len = Top_datalen;
1293{
1294size_t salt_datalen, salt_oldlen;
1295Der_type salt_type;
1296e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &salt_type, UT_OctetString, &salt_datalen, &l);
1297if (e == 0 && salt_type != PRIM) { e = ASN1_BAD_ID; }
1298if(e) goto fail;
1299p += l; len -= l; ret += l;
1300salt_oldlen = len;
1301if (salt_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1302len = salt_datalen;
1303e = der_get_octet_string(p, len, &(data)->salt, &l);
1304if(e) goto fail;
1305p += l; len -= l; ret += l;
1306len = salt_oldlen - salt_datalen;
1307}
1308{
1309size_t iterations_datalen, iterations_oldlen;
1310Der_type iterations_type;
1311e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &iterations_type, UT_Integer, &iterations_datalen, &l);
1312if (e == 0 && iterations_type != PRIM) { e = ASN1_BAD_ID; }
1313if(e) {
1314(data)->iterations = NULL;
1315} else {
1316(data)->iterations = calloc(1, sizeof(*(data)->iterations));
1317if ((data)->iterations == NULL) { e = ENOMEM; goto fail; }
1318p += l; len -= l; ret += l;
1319iterations_oldlen = len;
1320if (iterations_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1321len = iterations_datalen;
1322e = der_get_unsigned(p, len, (data)->iterations, &l);
1323if(e) goto fail;
1324p += l; len -= l; ret += l;
1325len = iterations_oldlen - iterations_datalen;
1326}
1327}
1328len = Top_oldlen - Top_datalen;
1329}
1330if(size) *size = ret;
1331return 0;
1332fail:
1333free_PKCS12_PBEParams(data);
1334return e;
1335}
1336
1337void ASN1CALL
1338free_PKCS12_PBEParams(PKCS12_PBEParams *data)
1339{
1340der_free_octet_string(&(data)->salt);
1341if((data)->iterations) {
1342free((data)->iterations);
1343(data)->iterations = NULL;
1344}
1345}
1346
1347size_t ASN1CALL
1348length_PKCS12_PBEParams(const PKCS12_PBEParams *data)
1349{
1350size_t ret = 0;
1351{
1352size_t Top_tag_oldret = ret;
1353ret = 0;
1354ret += der_length_octet_string(&(data)->salt);
1355ret += 1 + der_length_len (ret);
1356ret += Top_tag_oldret;
1357}
1358if((data)->iterations){
1359size_t Top_tag_oldret = ret;
1360ret = 0;
1361ret += der_length_unsigned((data)->iterations);
1362ret += 1 + der_length_len (ret);
1363ret += Top_tag_oldret;
1364}
1365ret += 1 + der_length_len (ret);
1366return ret;
1367}
1368
1369int ASN1CALL
1370copy_PKCS12_PBEParams(const PKCS12_PBEParams *from, PKCS12_PBEParams *to)
1371{
1372memset(to, 0, sizeof(*to));
1373if(der_copy_octet_string(&(from)->salt, &(to)->salt)) goto fail;
1374if((from)->iterations) {
1375(to)->iterations = malloc(sizeof(*(to)->iterations));
1376if((to)->iterations == NULL) goto fail;
1377*((to)->iterations) = *((from)->iterations);
1378}else
1379(to)->iterations = NULL;
1380return 0;
1381fail:
1382free_PKCS12_PBEParams(to);
1383return ENOMEM;
1384}
1385
1386int ASN1CALL
1387encode_PKCS12_OctetString(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PKCS12_OctetString *data, size_t *size)
1388{
1389size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1390size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1391int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1392
1393e = der_put_octet_string(p, len, data, &l);
1394if (e) return e;
1395p -= l; len -= l; ret += l;
1396
1397e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
1398if (e) return e;
1399p -= l; len -= l; ret += l;
1400
1401*size = ret;
1402return 0;
1403}
1404
1405int ASN1CALL
1406decode_PKCS12_OctetString(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PKCS12_OctetString *data, size_t *size)
1407{
1408size_t ret = 0;
1409size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1410int e HEIMDAL_UNUSED_ATTRIBUTE;
1411
1412memset(data, 0, sizeof(*data));
1413{
1414size_t Top_datalen, Top_oldlen;
1415Der_type Top_type;
1416e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_OctetString, &Top_datalen, &l);
1417if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
1418if(e) goto fail;
1419p += l; len -= l; ret += l;
1420Top_oldlen = len;
1421if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1422len = Top_datalen;
1423e = der_get_octet_string(p, len, data, &l);
1424if(e) goto fail;
1425p += l; len -= l; ret += l;
1426len = Top_oldlen - Top_datalen;
1427}
1428if(size) *size = ret;
1429return 0;
1430fail:
1431free_PKCS12_OctetString(data);
1432return e;
1433}
1434
1435void ASN1CALL
1436free_PKCS12_OctetString(PKCS12_OctetString *data)
1437{
1438der_free_octet_string(data);
1439}
1440
1441size_t ASN1CALL
1442length_PKCS12_OctetString(const PKCS12_OctetString *data)
1443{
1444size_t ret = 0;
1445ret += der_length_octet_string(data);
1446ret += 1 + der_length_len (ret);
1447return ret;
1448}
1449
1450int ASN1CALL
1451copy_PKCS12_OctetString(const PKCS12_OctetString *from, PKCS12_OctetString *to)
1452{
1453memset(to, 0, sizeof(*to));
1454if(der_copy_octet_string(from, to)) goto fail;
1455return 0;
1456fail:
1457free_PKCS12_OctetString(to);
1458return ENOMEM;
1459}
1460
1461