Line data Source code
1 : #include "config.h"
2 : /* Generated from /builds/samba-team/devel/samba/source4/heimdal/lib/asn1/pkcs8.asn1 */
3 : /* Do not edit */
4 :
5 : #define ASN1_LIB
6 :
7 : #include <stdio.h>
8 : #include <stdlib.h>
9 : #include <time.h>
10 : #include <string.h>
11 : #include <errno.h>
12 : #include <limits.h>
13 : #include <krb5-types.h>
14 : #include <pkcs8_asn1.h>
15 : #include <pkcs8_asn1-priv.h>
16 : #include <asn1_err.h>
17 : #include <der.h>
18 : #include <der-private.h>
19 : #include <asn1-template.h>
20 : #include <parse_units.h>
21 :
22 : int ASN1CALL
23 0 : encode_PKCS8PrivateKeyAlgorithmIdentifier(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PKCS8PrivateKeyAlgorithmIdentifier *data, size_t *size)
24 : {
25 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
26 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
27 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
28 :
29 0 : e = encode_AlgorithmIdentifier(p, len, data, &l);
30 0 : if (e) return e;
31 0 : p -= l; len -= l; ret += l;
32 :
33 0 : *size = ret;
34 0 : return 0;
35 : }
36 :
37 : int ASN1CALL
38 0 : decode_PKCS8PrivateKeyAlgorithmIdentifier(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PKCS8PrivateKeyAlgorithmIdentifier *data, size_t *size)
39 : {
40 0 : size_t ret = 0;
41 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
42 : int e HEIMDAL_UNUSED_ATTRIBUTE;
43 :
44 0 : memset(data, 0, sizeof(*data));
45 0 : e = decode_AlgorithmIdentifier(p, len, data, &l);
46 0 : if(e) goto fail;
47 0 : p += l; len -= l; ret += l;
48 0 : if(size) *size = ret;
49 0 : return 0;
50 0 : fail:
51 0 : free_PKCS8PrivateKeyAlgorithmIdentifier(data);
52 0 : return e;
53 : }
54 :
55 : void ASN1CALL
56 0 : free_PKCS8PrivateKeyAlgorithmIdentifier(PKCS8PrivateKeyAlgorithmIdentifier *data)
57 : {
58 0 : free_AlgorithmIdentifier(data);
59 0 : }
60 :
61 : size_t ASN1CALL
62 0 : length_PKCS8PrivateKeyAlgorithmIdentifier(const PKCS8PrivateKeyAlgorithmIdentifier *data)
63 : {
64 0 : size_t ret = 0;
65 0 : ret += length_AlgorithmIdentifier(data);
66 0 : return ret;
67 : }
68 :
69 : int ASN1CALL
70 0 : copy_PKCS8PrivateKeyAlgorithmIdentifier(const PKCS8PrivateKeyAlgorithmIdentifier *from, PKCS8PrivateKeyAlgorithmIdentifier *to)
71 : {
72 0 : memset(to, 0, sizeof(*to));
73 0 : if(copy_AlgorithmIdentifier(from, to)) goto fail;
74 0 : return 0;
75 0 : fail:
76 0 : free_PKCS8PrivateKeyAlgorithmIdentifier(to);
77 0 : return ENOMEM;
78 : }
79 :
80 : int ASN1CALL
81 0 : encode_PKCS8PrivateKey(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PKCS8PrivateKey *data, size_t *size)
82 : {
83 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
84 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
85 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
86 :
87 0 : e = der_put_octet_string(p, len, data, &l);
88 0 : if (e) return e;
89 0 : p -= l; len -= l; ret += l;
90 :
91 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
92 0 : if (e) return e;
93 0 : p -= l; len -= l; ret += l;
94 :
95 0 : *size = ret;
96 0 : return 0;
97 : }
98 :
99 : int ASN1CALL
100 0 : decode_PKCS8PrivateKey(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PKCS8PrivateKey *data, size_t *size)
101 : {
102 0 : size_t ret = 0;
103 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
104 : int e HEIMDAL_UNUSED_ATTRIBUTE;
105 :
106 0 : memset(data, 0, sizeof(*data));
107 : {
108 : size_t Top_datalen, Top_oldlen;
109 : Der_type Top_type;
110 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_OctetString, &Top_datalen, &l);
111 0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
112 0 : if(e) goto fail;
113 0 : p += l; len -= l; ret += l;
114 0 : Top_oldlen = len;
115 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
116 0 : len = Top_datalen;
117 0 : e = der_get_octet_string(p, len, data, &l);
118 0 : if(e) goto fail;
119 0 : p += l; len -= l; ret += l;
120 0 : len = Top_oldlen - Top_datalen;
121 : }
122 0 : if(size) *size = ret;
123 0 : return 0;
124 0 : fail:
125 0 : free_PKCS8PrivateKey(data);
126 0 : return e;
127 : }
128 :
129 : void ASN1CALL
130 0 : free_PKCS8PrivateKey(PKCS8PrivateKey *data)
131 : {
132 0 : der_free_octet_string(data);
133 0 : }
134 :
135 : size_t ASN1CALL
136 0 : length_PKCS8PrivateKey(const PKCS8PrivateKey *data)
137 : {
138 0 : size_t ret = 0;
139 0 : ret += der_length_octet_string(data);
140 0 : ret += 1 + der_length_len (ret);
141 0 : return ret;
142 : }
143 :
144 : int ASN1CALL
145 0 : copy_PKCS8PrivateKey(const PKCS8PrivateKey *from, PKCS8PrivateKey *to)
146 : {
147 0 : memset(to, 0, sizeof(*to));
148 0 : if(der_copy_octet_string(from, to)) goto fail;
149 0 : return 0;
150 0 : fail:
151 0 : free_PKCS8PrivateKey(to);
152 0 : return ENOMEM;
153 : }
154 :
155 : int ASN1CALL
156 0 : encode_PKCS8Attributes(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PKCS8Attributes *data, size_t *size)
157 : {
158 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
159 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
160 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
161 :
162 : {
163 : struct heim_octet_string *val;
164 0 : size_t elen = 0, totallen = 0;
165 0 : int eret = 0;
166 0 : if ((data)->len > UINT_MAX/sizeof(val[0]))
167 0 : return ERANGE;
168 0 : val = malloc(sizeof(val[0]) * (data)->len);
169 0 : if (val == NULL && (data)->len != 0) return ENOMEM;
170 0 : for(i = 0; i < (int)(data)->len; i++) {
171 0 : ASN1_MALLOC_ENCODE(Attribute, val[i].data, val[i].length, &(data)->val[i], &elen, eret);
172 0 : if(eret) {
173 0 : i--;
174 0 : while (i >= 0) {
175 0 : free(val[i].data);
176 0 : i--;
177 : }
178 0 : free(val);
179 0 : return eret;
180 : }
181 0 : totallen += elen;
182 : }
183 0 : if (totallen > len) {
184 0 : for (i = 0; i < (int)(data)->len; i++) {
185 0 : free(val[i].data);
186 : }
187 0 : free(val);
188 0 : return ASN1_OVERFLOW;
189 : }
190 0 : qsort(val, (data)->len, sizeof(val[0]), _heim_der_set_sort);
191 0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
192 0 : p -= val[i].length;
193 0 : ret += val[i].length;
194 0 : memcpy(p + 1, val[i].data, val[i].length);
195 0 : free(val[i].data);
196 : }
197 0 : free(val);
198 : }
199 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Set, &l);
200 0 : if (e) return e;
201 0 : p -= l; len -= l; ret += l;
202 :
203 0 : *size = ret;
204 0 : return 0;
205 : }
206 :
207 : int ASN1CALL
208 0 : decode_PKCS8Attributes(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PKCS8Attributes *data, size_t *size)
209 : {
210 0 : size_t ret = 0;
211 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
212 : int e HEIMDAL_UNUSED_ATTRIBUTE;
213 :
214 0 : memset(data, 0, sizeof(*data));
215 : {
216 : size_t Top_datalen, Top_oldlen;
217 : Der_type Top_type;
218 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Set, &Top_datalen, &l);
219 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
220 0 : if(e) goto fail;
221 0 : p += l; len -= l; ret += l;
222 0 : Top_oldlen = len;
223 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
224 0 : len = Top_datalen;
225 : {
226 0 : size_t Top_Tag_origlen = len;
227 0 : size_t Top_Tag_oldret = ret;
228 0 : size_t Top_Tag_olen = 0;
229 : void *Top_Tag_tmp;
230 0 : ret = 0;
231 0 : (data)->len = 0;
232 0 : (data)->val = NULL;
233 0 : while(ret < Top_Tag_origlen) {
234 0 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
235 0 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
236 0 : Top_Tag_olen = Top_Tag_nlen;
237 0 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
238 0 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
239 0 : (data)->val = Top_Tag_tmp;
240 0 : e = decode_Attribute(p, len, &(data)->val[(data)->len], &l);
241 0 : if(e) goto fail;
242 0 : p += l; len -= l; ret += l;
243 0 : (data)->len++;
244 0 : len = Top_Tag_origlen - ret;
245 : }
246 0 : ret += Top_Tag_oldret;
247 : }
248 0 : len = Top_oldlen - Top_datalen;
249 : }
250 0 : if(size) *size = ret;
251 0 : return 0;
252 0 : fail:
253 0 : free_PKCS8Attributes(data);
254 0 : return e;
255 : }
256 :
257 : void ASN1CALL
258 0 : free_PKCS8Attributes(PKCS8Attributes *data)
259 : {
260 0 : while((data)->len){
261 0 : free_Attribute(&(data)->val[(data)->len-1]);
262 0 : (data)->len--;
263 : }
264 0 : free((data)->val);
265 0 : (data)->val = NULL;
266 0 : }
267 :
268 : size_t ASN1CALL
269 0 : length_PKCS8Attributes(const PKCS8Attributes *data)
270 : {
271 0 : size_t ret = 0;
272 : {
273 0 : size_t Top_tag_oldret = ret;
274 : int i;
275 0 : ret = 0;
276 0 : for(i = (data)->len - 1; i >= 0; --i){
277 0 : size_t Top_tag_for_oldret = ret;
278 0 : ret = 0;
279 0 : ret += length_Attribute(&(data)->val[i]);
280 0 : ret += Top_tag_for_oldret;
281 : }
282 0 : ret += Top_tag_oldret;
283 : }
284 0 : ret += 1 + der_length_len (ret);
285 0 : return ret;
286 : }
287 :
288 : int ASN1CALL
289 0 : copy_PKCS8Attributes(const PKCS8Attributes *from, PKCS8Attributes *to)
290 : {
291 0 : memset(to, 0, sizeof(*to));
292 0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
293 0 : goto fail;
294 0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
295 0 : if(copy_Attribute(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
296 : }
297 0 : return 0;
298 0 : fail:
299 0 : free_PKCS8Attributes(to);
300 0 : return ENOMEM;
301 : }
302 :
303 : int ASN1CALL
304 0 : encode_PKCS8PrivateKeyInfo(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PKCS8PrivateKeyInfo *data, size_t *size)
305 : {
306 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
307 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
308 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
309 :
310 : /* attributes */
311 0 : if((data)->attributes) {
312 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
313 0 : ret = 0;
314 : {
315 : struct heim_octet_string *val;
316 0 : size_t elen = 0, totallen = 0;
317 0 : int eret = 0;
318 0 : if (((data)->attributes)->len > UINT_MAX/sizeof(val[0]))
319 0 : return ERANGE;
320 0 : val = malloc(sizeof(val[0]) * ((data)->attributes)->len);
321 0 : if (val == NULL && ((data)->attributes)->len != 0) return ENOMEM;
322 0 : for(i = 0; i < (int)((data)->attributes)->len; i++) {
323 0 : ASN1_MALLOC_ENCODE(Attribute, val[i].data, val[i].length, &((data)->attributes)->val[i], &elen, eret);
324 0 : if(eret) {
325 0 : i--;
326 0 : while (i >= 0) {
327 0 : free(val[i].data);
328 0 : i--;
329 : }
330 0 : free(val);
331 0 : return eret;
332 : }
333 0 : totallen += elen;
334 : }
335 0 : if (totallen > len) {
336 0 : for (i = 0; i < (int)((data)->attributes)->len; i++) {
337 0 : free(val[i].data);
338 : }
339 0 : free(val);
340 0 : return ASN1_OVERFLOW;
341 : }
342 0 : qsort(val, ((data)->attributes)->len, sizeof(val[0]), _heim_der_set_sort);
343 0 : for(i = (int)((data)->attributes)->len - 1; i >= 0; --i) {
344 0 : p -= val[i].length;
345 0 : ret += val[i].length;
346 0 : memcpy(p + 1, val[i].data, val[i].length);
347 0 : free(val[i].data);
348 : }
349 0 : free(val);
350 : }
351 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
352 0 : if (e) return e;
353 0 : p -= l; len -= l; ret += l;
354 :
355 0 : ret += Top_tag_oldret;
356 : }
357 : /* privateKey */
358 : {
359 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
360 0 : ret = 0;
361 0 : e = encode_PKCS8PrivateKey(p, len, &(data)->privateKey, &l);
362 0 : if (e) return e;
363 0 : p -= l; len -= l; ret += l;
364 :
365 0 : ret += Top_tag_oldret;
366 : }
367 : /* privateKeyAlgorithm */
368 : {
369 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
370 0 : ret = 0;
371 0 : e = encode_PKCS8PrivateKeyAlgorithmIdentifier(p, len, &(data)->privateKeyAlgorithm, &l);
372 0 : if (e) return e;
373 0 : p -= l; len -= l; ret += l;
374 :
375 0 : ret += Top_tag_oldret;
376 : }
377 : /* version */
378 : {
379 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
380 0 : ret = 0;
381 0 : e = der_put_heim_integer(p, len, &(data)->version, &l);
382 0 : if (e) return e;
383 0 : p -= l; len -= l; ret += l;
384 :
385 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
386 0 : if (e) return e;
387 0 : p -= l; len -= l; ret += l;
388 :
389 0 : ret += Top_tag_oldret;
390 : }
391 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
392 0 : if (e) return e;
393 0 : p -= l; len -= l; ret += l;
394 :
395 0 : *size = ret;
396 0 : return 0;
397 : }
398 :
399 : int ASN1CALL
400 0 : decode_PKCS8PrivateKeyInfo(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PKCS8PrivateKeyInfo *data, size_t *size)
401 : {
402 0 : size_t ret = 0;
403 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
404 : int e HEIMDAL_UNUSED_ATTRIBUTE;
405 :
406 0 : memset(data, 0, sizeof(*data));
407 : {
408 : size_t Top_datalen, Top_oldlen;
409 : Der_type Top_type;
410 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
411 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
412 0 : if(e) goto fail;
413 0 : p += l; len -= l; ret += l;
414 0 : Top_oldlen = len;
415 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
416 0 : len = Top_datalen;
417 : {
418 : size_t version_datalen, version_oldlen;
419 : Der_type version_type;
420 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &version_type, UT_Integer, &version_datalen, &l);
421 0 : if (e == 0 && version_type != PRIM) { e = ASN1_BAD_ID; }
422 0 : if(e) goto fail;
423 0 : p += l; len -= l; ret += l;
424 0 : version_oldlen = len;
425 0 : if (version_datalen > len) { e = ASN1_OVERRUN; goto fail; }
426 0 : len = version_datalen;
427 0 : e = der_get_heim_integer(p, len, &(data)->version, &l);
428 0 : if(e) goto fail;
429 0 : p += l; len -= l; ret += l;
430 0 : len = version_oldlen - version_datalen;
431 : }
432 0 : e = decode_PKCS8PrivateKeyAlgorithmIdentifier(p, len, &(data)->privateKeyAlgorithm, &l);
433 0 : if(e) goto fail;
434 0 : p += l; len -= l; ret += l;
435 0 : e = decode_PKCS8PrivateKey(p, len, &(data)->privateKey, &l);
436 0 : if(e) goto fail;
437 0 : p += l; len -= l; ret += l;
438 : {
439 : size_t attributes_datalen, attributes_oldlen;
440 : Der_type attributes_type;
441 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &attributes_type, 0, &attributes_datalen, &l);
442 0 : if (e == 0 && attributes_type != CONS) { e = ASN1_BAD_ID; }
443 0 : if(e) {
444 0 : (data)->attributes = NULL;
445 : } else {
446 0 : (data)->attributes = calloc(1, sizeof(*(data)->attributes));
447 0 : if ((data)->attributes == NULL) { e = ENOMEM; goto fail; }
448 0 : p += l; len -= l; ret += l;
449 0 : attributes_oldlen = len;
450 0 : if (attributes_datalen > len) { e = ASN1_OVERRUN; goto fail; }
451 0 : len = attributes_datalen;
452 : {
453 0 : size_t attributes_Tag_origlen = len;
454 0 : size_t attributes_Tag_oldret = ret;
455 0 : size_t attributes_Tag_olen = 0;
456 : void *attributes_Tag_tmp;
457 0 : ret = 0;
458 0 : ((data)->attributes)->len = 0;
459 0 : ((data)->attributes)->val = NULL;
460 0 : while(ret < attributes_Tag_origlen) {
461 0 : size_t attributes_Tag_nlen = attributes_Tag_olen + sizeof(*(((data)->attributes)->val));
462 0 : if (attributes_Tag_olen > attributes_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
463 0 : attributes_Tag_olen = attributes_Tag_nlen;
464 0 : attributes_Tag_tmp = realloc(((data)->attributes)->val, attributes_Tag_olen);
465 0 : if (attributes_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
466 0 : ((data)->attributes)->val = attributes_Tag_tmp;
467 0 : e = decode_Attribute(p, len, &((data)->attributes)->val[((data)->attributes)->len], &l);
468 0 : if(e) goto fail;
469 0 : p += l; len -= l; ret += l;
470 0 : ((data)->attributes)->len++;
471 0 : len = attributes_Tag_origlen - ret;
472 : }
473 0 : ret += attributes_Tag_oldret;
474 : }
475 0 : len = attributes_oldlen - attributes_datalen;
476 : }
477 : }
478 0 : len = Top_oldlen - Top_datalen;
479 : }
480 0 : if(size) *size = ret;
481 0 : return 0;
482 0 : fail:
483 0 : free_PKCS8PrivateKeyInfo(data);
484 0 : return e;
485 : }
486 :
487 : void ASN1CALL
488 0 : free_PKCS8PrivateKeyInfo(PKCS8PrivateKeyInfo *data)
489 : {
490 0 : der_free_heim_integer(&(data)->version);
491 0 : free_PKCS8PrivateKeyAlgorithmIdentifier(&(data)->privateKeyAlgorithm);
492 0 : free_PKCS8PrivateKey(&(data)->privateKey);
493 0 : if((data)->attributes) {
494 0 : while(((data)->attributes)->len){
495 0 : free_Attribute(&((data)->attributes)->val[((data)->attributes)->len-1]);
496 0 : ((data)->attributes)->len--;
497 : }
498 0 : free(((data)->attributes)->val);
499 0 : ((data)->attributes)->val = NULL;
500 0 : free((data)->attributes);
501 0 : (data)->attributes = NULL;
502 : }
503 0 : }
504 :
505 : size_t ASN1CALL
506 0 : length_PKCS8PrivateKeyInfo(const PKCS8PrivateKeyInfo *data)
507 : {
508 0 : size_t ret = 0;
509 : {
510 0 : size_t Top_tag_oldret = ret;
511 0 : ret = 0;
512 0 : ret += der_length_heim_integer(&(data)->version);
513 0 : ret += 1 + der_length_len (ret);
514 0 : ret += Top_tag_oldret;
515 : }
516 : {
517 0 : size_t Top_tag_oldret = ret;
518 0 : ret = 0;
519 0 : ret += length_PKCS8PrivateKeyAlgorithmIdentifier(&(data)->privateKeyAlgorithm);
520 0 : ret += Top_tag_oldret;
521 : }
522 : {
523 0 : size_t Top_tag_oldret = ret;
524 0 : ret = 0;
525 0 : ret += length_PKCS8PrivateKey(&(data)->privateKey);
526 0 : ret += Top_tag_oldret;
527 : }
528 0 : if((data)->attributes){
529 0 : size_t Top_tag_oldret = ret;
530 0 : ret = 0;
531 : {
532 0 : size_t attributes_tag_oldret = ret;
533 : int i;
534 0 : ret = 0;
535 0 : for(i = ((data)->attributes)->len - 1; i >= 0; --i){
536 0 : size_t attributes_tag_for_oldret = ret;
537 0 : ret = 0;
538 0 : ret += length_Attribute(&((data)->attributes)->val[i]);
539 0 : ret += attributes_tag_for_oldret;
540 : }
541 0 : ret += attributes_tag_oldret;
542 : }
543 0 : ret += 1 + der_length_len (ret);
544 0 : ret += Top_tag_oldret;
545 : }
546 0 : ret += 1 + der_length_len (ret);
547 0 : return ret;
548 : }
549 :
550 : int ASN1CALL
551 0 : copy_PKCS8PrivateKeyInfo(const PKCS8PrivateKeyInfo *from, PKCS8PrivateKeyInfo *to)
552 : {
553 0 : memset(to, 0, sizeof(*to));
554 0 : if(der_copy_heim_integer(&(from)->version, &(to)->version)) goto fail;
555 0 : if(copy_PKCS8PrivateKeyAlgorithmIdentifier(&(from)->privateKeyAlgorithm, &(to)->privateKeyAlgorithm)) goto fail;
556 0 : if(copy_PKCS8PrivateKey(&(from)->privateKey, &(to)->privateKey)) goto fail;
557 0 : if((from)->attributes) {
558 0 : (to)->attributes = malloc(sizeof(*(to)->attributes));
559 0 : if((to)->attributes == NULL) goto fail;
560 0 : if((((to)->attributes)->val = malloc(((from)->attributes)->len * sizeof(*((to)->attributes)->val))) == NULL && ((from)->attributes)->len != 0)
561 0 : goto fail;
562 0 : for(((to)->attributes)->len = 0; ((to)->attributes)->len < ((from)->attributes)->len; ((to)->attributes)->len++){
563 0 : if(copy_Attribute(&((from)->attributes)->val[((to)->attributes)->len], &((to)->attributes)->val[((to)->attributes)->len])) goto fail;
564 : }
565 : }else
566 0 : (to)->attributes = NULL;
567 0 : return 0;
568 0 : fail:
569 0 : free_PKCS8PrivateKeyInfo(to);
570 0 : return ENOMEM;
571 : }
572 :
573 : int ASN1CALL
574 0 : encode_PKCS8EncryptedData(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PKCS8EncryptedData *data, size_t *size)
575 : {
576 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
577 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
578 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
579 :
580 0 : e = der_put_octet_string(p, len, data, &l);
581 0 : if (e) return e;
582 0 : p -= l; len -= l; ret += l;
583 :
584 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
585 0 : if (e) return e;
586 0 : p -= l; len -= l; ret += l;
587 :
588 0 : *size = ret;
589 0 : return 0;
590 : }
591 :
592 : int ASN1CALL
593 0 : decode_PKCS8EncryptedData(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PKCS8EncryptedData *data, size_t *size)
594 : {
595 0 : size_t ret = 0;
596 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
597 : int e HEIMDAL_UNUSED_ATTRIBUTE;
598 :
599 0 : memset(data, 0, sizeof(*data));
600 : {
601 : size_t Top_datalen, Top_oldlen;
602 : Der_type Top_type;
603 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_OctetString, &Top_datalen, &l);
604 0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
605 0 : if(e) goto fail;
606 0 : p += l; len -= l; ret += l;
607 0 : Top_oldlen = len;
608 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
609 0 : len = Top_datalen;
610 0 : e = der_get_octet_string(p, len, data, &l);
611 0 : if(e) goto fail;
612 0 : p += l; len -= l; ret += l;
613 0 : len = Top_oldlen - Top_datalen;
614 : }
615 0 : if(size) *size = ret;
616 0 : return 0;
617 0 : fail:
618 0 : free_PKCS8EncryptedData(data);
619 0 : return e;
620 : }
621 :
622 : void ASN1CALL
623 0 : free_PKCS8EncryptedData(PKCS8EncryptedData *data)
624 : {
625 0 : der_free_octet_string(data);
626 0 : }
627 :
628 : size_t ASN1CALL
629 0 : length_PKCS8EncryptedData(const PKCS8EncryptedData *data)
630 : {
631 0 : size_t ret = 0;
632 0 : ret += der_length_octet_string(data);
633 0 : ret += 1 + der_length_len (ret);
634 0 : return ret;
635 : }
636 :
637 : int ASN1CALL
638 0 : copy_PKCS8EncryptedData(const PKCS8EncryptedData *from, PKCS8EncryptedData *to)
639 : {
640 0 : memset(to, 0, sizeof(*to));
641 0 : if(der_copy_octet_string(from, to)) goto fail;
642 0 : return 0;
643 0 : fail:
644 0 : free_PKCS8EncryptedData(to);
645 0 : return ENOMEM;
646 : }
647 :
648 : int ASN1CALL
649 0 : encode_PKCS8EncryptedPrivateKeyInfo(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PKCS8EncryptedPrivateKeyInfo *data, size_t *size)
650 : {
651 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
652 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
653 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
654 :
655 : /* encryptedData */
656 : {
657 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
658 0 : ret = 0;
659 0 : e = encode_PKCS8EncryptedData(p, len, &(data)->encryptedData, &l);
660 0 : if (e) return e;
661 0 : p -= l; len -= l; ret += l;
662 :
663 0 : ret += Top_tag_oldret;
664 : }
665 : /* encryptionAlgorithm */
666 : {
667 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
668 0 : ret = 0;
669 0 : e = encode_AlgorithmIdentifier(p, len, &(data)->encryptionAlgorithm, &l);
670 0 : if (e) return e;
671 0 : p -= l; len -= l; ret += l;
672 :
673 0 : ret += Top_tag_oldret;
674 : }
675 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
676 0 : if (e) return e;
677 0 : p -= l; len -= l; ret += l;
678 :
679 0 : *size = ret;
680 0 : return 0;
681 : }
682 :
683 : int ASN1CALL
684 0 : decode_PKCS8EncryptedPrivateKeyInfo(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PKCS8EncryptedPrivateKeyInfo *data, size_t *size)
685 : {
686 0 : size_t ret = 0;
687 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
688 : int e HEIMDAL_UNUSED_ATTRIBUTE;
689 :
690 0 : memset(data, 0, sizeof(*data));
691 : {
692 : size_t Top_datalen, Top_oldlen;
693 : Der_type Top_type;
694 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
695 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
696 0 : if(e) goto fail;
697 0 : p += l; len -= l; ret += l;
698 0 : Top_oldlen = len;
699 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
700 0 : len = Top_datalen;
701 0 : e = decode_AlgorithmIdentifier(p, len, &(data)->encryptionAlgorithm, &l);
702 0 : if(e) goto fail;
703 0 : p += l; len -= l; ret += l;
704 0 : e = decode_PKCS8EncryptedData(p, len, &(data)->encryptedData, &l);
705 0 : if(e) goto fail;
706 0 : p += l; len -= l; ret += l;
707 0 : len = Top_oldlen - Top_datalen;
708 : }
709 0 : if(size) *size = ret;
710 0 : return 0;
711 0 : fail:
712 0 : free_PKCS8EncryptedPrivateKeyInfo(data);
713 0 : return e;
714 : }
715 :
716 : void ASN1CALL
717 0 : free_PKCS8EncryptedPrivateKeyInfo(PKCS8EncryptedPrivateKeyInfo *data)
718 : {
719 0 : free_AlgorithmIdentifier(&(data)->encryptionAlgorithm);
720 0 : free_PKCS8EncryptedData(&(data)->encryptedData);
721 0 : }
722 :
723 : size_t ASN1CALL
724 0 : length_PKCS8EncryptedPrivateKeyInfo(const PKCS8EncryptedPrivateKeyInfo *data)
725 : {
726 0 : size_t ret = 0;
727 : {
728 0 : size_t Top_tag_oldret = ret;
729 0 : ret = 0;
730 0 : ret += length_AlgorithmIdentifier(&(data)->encryptionAlgorithm);
731 0 : ret += Top_tag_oldret;
732 : }
733 : {
734 0 : size_t Top_tag_oldret = ret;
735 0 : ret = 0;
736 0 : ret += length_PKCS8EncryptedData(&(data)->encryptedData);
737 0 : ret += Top_tag_oldret;
738 : }
739 0 : ret += 1 + der_length_len (ret);
740 0 : return ret;
741 : }
742 :
743 : int ASN1CALL
744 0 : copy_PKCS8EncryptedPrivateKeyInfo(const PKCS8EncryptedPrivateKeyInfo *from, PKCS8EncryptedPrivateKeyInfo *to)
745 : {
746 0 : memset(to, 0, sizeof(*to));
747 0 : if(copy_AlgorithmIdentifier(&(from)->encryptionAlgorithm, &(to)->encryptionAlgorithm)) goto fail;
748 0 : if(copy_PKCS8EncryptedData(&(from)->encryptedData, &(to)->encryptedData)) goto fail;
749 0 : return 0;
750 0 : fail:
751 0 : free_PKCS8EncryptedPrivateKeyInfo(to);
752 0 : return ENOMEM;
753 : }
754 :
|
