Line data Source code
1 : #include "config.h"
2 : /* Generated from /builds/samba-team/devel/samba/source4/heimdal/lib/hx509/pkcs10.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 <pkcs10_asn1.h>
15 : #include <pkcs10_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_CertificationRequestInfo(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const CertificationRequestInfo *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 : /* attributes */
30 0 : if((data)->attributes) {
31 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
32 0 : ret = 0;
33 : {
34 : struct heim_octet_string *val;
35 0 : size_t elen = 0, totallen = 0;
36 0 : int eret = 0;
37 0 : if (((data)->attributes)->len > UINT_MAX/sizeof(val[0]))
38 0 : return ERANGE;
39 0 : val = malloc(sizeof(val[0]) * ((data)->attributes)->len);
40 0 : if (val == NULL && ((data)->attributes)->len != 0) return ENOMEM;
41 0 : for(i = 0; i < (int)((data)->attributes)->len; i++) {
42 0 : ASN1_MALLOC_ENCODE(Attribute, val[i].data, val[i].length, &((data)->attributes)->val[i], &elen, eret);
43 0 : if(eret) {
44 0 : i--;
45 0 : while (i >= 0) {
46 0 : free(val[i].data);
47 0 : i--;
48 : }
49 0 : free(val);
50 0 : return eret;
51 : }
52 0 : totallen += elen;
53 : }
54 0 : if (totallen > len) {
55 0 : for (i = 0; i < (int)((data)->attributes)->len; i++) {
56 0 : free(val[i].data);
57 : }
58 0 : free(val);
59 0 : return ASN1_OVERFLOW;
60 : }
61 0 : qsort(val, ((data)->attributes)->len, sizeof(val[0]), _heim_der_set_sort);
62 0 : for(i = (int)((data)->attributes)->len - 1; i >= 0; --i) {
63 0 : p -= val[i].length;
64 0 : ret += val[i].length;
65 0 : memcpy(p + 1, val[i].data, val[i].length);
66 0 : free(val[i].data);
67 : }
68 0 : free(val);
69 : }
70 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
71 0 : if (e) return e;
72 0 : p -= l; len -= l; ret += l;
73 :
74 0 : ret += Top_tag_oldret;
75 : }
76 : /* subjectPKInfo */
77 : {
78 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
79 0 : ret = 0;
80 0 : e = encode_SubjectPublicKeyInfo(p, len, &(data)->subjectPKInfo, &l);
81 0 : if (e) return e;
82 0 : p -= l; len -= l; ret += l;
83 :
84 0 : ret += Top_tag_oldret;
85 : }
86 : /* subject */
87 : {
88 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
89 0 : ret = 0;
90 0 : e = encode_Name(p, len, &(data)->subject, &l);
91 0 : if (e) return e;
92 0 : p -= l; len -= l; ret += l;
93 :
94 0 : ret += Top_tag_oldret;
95 : }
96 : /* version */
97 : {
98 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
99 0 : ret = 0;
100 : {
101 0 : int enumint = (int)*&(data)->version;
102 0 : e = der_put_integer(p, len, &enumint, &l);
103 0 : if (e) return e;
104 0 : p -= l; len -= l; ret += l;
105 :
106 : }
107 0 : ;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
108 0 : if (e) return e;
109 0 : p -= l; len -= l; ret += l;
110 :
111 0 : ret += Top_tag_oldret;
112 : }
113 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
114 0 : if (e) return e;
115 0 : p -= l; len -= l; ret += l;
116 :
117 0 : *size = ret;
118 0 : return 0;
119 : }
120 :
121 : int ASN1CALL
122 0 : decode_CertificationRequestInfo(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, CertificationRequestInfo *data, size_t *size)
123 : {
124 0 : size_t ret = 0;
125 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
126 : int e HEIMDAL_UNUSED_ATTRIBUTE;
127 0 : const unsigned char *begin = p;
128 :
129 0 : memset(data, 0, sizeof(*data));
130 : {
131 : size_t Top_datalen, Top_oldlen;
132 : Der_type Top_type;
133 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
134 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
135 0 : if(e) goto fail;
136 0 : p += l; len -= l; ret += l;
137 0 : Top_oldlen = len;
138 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
139 0 : len = Top_datalen;
140 : {
141 : size_t version_datalen, version_oldlen;
142 : Der_type version_type;
143 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &version_type, UT_Integer, &version_datalen, &l);
144 0 : if (e == 0 && version_type != PRIM) { e = ASN1_BAD_ID; }
145 0 : if(e) goto fail;
146 0 : p += l; len -= l; ret += l;
147 0 : version_oldlen = len;
148 0 : if (version_datalen > len) { e = ASN1_OVERRUN; goto fail; }
149 0 : len = version_datalen;
150 : {
151 : int enumint;
152 0 : e = der_get_integer(p, len, &enumint, &l);
153 0 : if(e) goto fail;
154 0 : p += l; len -= l; ret += l;
155 0 : *&(data)->version = enumint;
156 : }
157 0 : len = version_oldlen - version_datalen;
158 : }
159 0 : e = decode_Name(p, len, &(data)->subject, &l);
160 0 : if(e) goto fail;
161 0 : p += l; len -= l; ret += l;
162 0 : e = decode_SubjectPublicKeyInfo(p, len, &(data)->subjectPKInfo, &l);
163 0 : if(e) goto fail;
164 0 : p += l; len -= l; ret += l;
165 : {
166 : size_t attributes_datalen, attributes_oldlen;
167 : Der_type attributes_type;
168 0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &attributes_type, 0, &attributes_datalen, &l);
169 0 : if (e == 0 && attributes_type != CONS) { e = ASN1_BAD_ID; }
170 0 : if(e) {
171 0 : (data)->attributes = NULL;
172 : } else {
173 0 : (data)->attributes = calloc(1, sizeof(*(data)->attributes));
174 0 : if ((data)->attributes == NULL) { e = ENOMEM; goto fail; }
175 0 : p += l; len -= l; ret += l;
176 0 : attributes_oldlen = len;
177 0 : if (attributes_datalen > len) { e = ASN1_OVERRUN; goto fail; }
178 0 : len = attributes_datalen;
179 : {
180 0 : size_t attributes_Tag_origlen = len;
181 0 : size_t attributes_Tag_oldret = ret;
182 0 : size_t attributes_Tag_olen = 0;
183 : void *attributes_Tag_tmp;
184 0 : ret = 0;
185 0 : ((data)->attributes)->len = 0;
186 0 : ((data)->attributes)->val = NULL;
187 0 : while(ret < attributes_Tag_origlen) {
188 0 : size_t attributes_Tag_nlen = attributes_Tag_olen + sizeof(*(((data)->attributes)->val));
189 0 : if (attributes_Tag_olen > attributes_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
190 0 : attributes_Tag_olen = attributes_Tag_nlen;
191 0 : attributes_Tag_tmp = realloc(((data)->attributes)->val, attributes_Tag_olen);
192 0 : if (attributes_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
193 0 : ((data)->attributes)->val = attributes_Tag_tmp;
194 0 : e = decode_Attribute(p, len, &((data)->attributes)->val[((data)->attributes)->len], &l);
195 0 : if(e) goto fail;
196 0 : p += l; len -= l; ret += l;
197 0 : ((data)->attributes)->len++;
198 0 : len = attributes_Tag_origlen - ret;
199 : }
200 0 : ret += attributes_Tag_oldret;
201 : }
202 0 : len = attributes_oldlen - attributes_datalen;
203 : }
204 : }
205 0 : len = Top_oldlen - Top_datalen;
206 : }
207 0 : data->_save.data = calloc(1, ret);
208 0 : if (data->_save.data == NULL) {
209 0 : e = ENOMEM; goto fail;
210 : }
211 0 : data->_save.length = ret;
212 0 : memcpy(data->_save.data, begin, ret);
213 0 : if(size) *size = ret;
214 0 : return 0;
215 0 : fail:
216 0 : free_CertificationRequestInfo(data);
217 0 : return e;
218 : }
219 :
220 : void ASN1CALL
221 0 : free_CertificationRequestInfo(CertificationRequestInfo *data)
222 : {
223 0 : der_free_octet_string(&data->_save);
224 0 : free_Name(&(data)->subject);
225 0 : free_SubjectPublicKeyInfo(&(data)->subjectPKInfo);
226 0 : if((data)->attributes) {
227 0 : while(((data)->attributes)->len){
228 0 : free_Attribute(&((data)->attributes)->val[((data)->attributes)->len-1]);
229 0 : ((data)->attributes)->len--;
230 : }
231 0 : free(((data)->attributes)->val);
232 0 : ((data)->attributes)->val = NULL;
233 0 : free((data)->attributes);
234 0 : (data)->attributes = NULL;
235 : }
236 0 : }
237 :
238 : size_t ASN1CALL
239 0 : length_CertificationRequestInfo(const CertificationRequestInfo *data)
240 : {
241 0 : size_t ret = 0;
242 : {
243 0 : size_t Top_tag_oldret = ret;
244 0 : ret = 0;
245 : {
246 0 : int enumint = *&(data)->version;
247 0 : ret += der_length_integer(&enumint);
248 : }
249 0 : ret += 1 + der_length_len (ret);
250 0 : ret += Top_tag_oldret;
251 : }
252 : {
253 0 : size_t Top_tag_oldret = ret;
254 0 : ret = 0;
255 0 : ret += length_Name(&(data)->subject);
256 0 : ret += Top_tag_oldret;
257 : }
258 : {
259 0 : size_t Top_tag_oldret = ret;
260 0 : ret = 0;
261 0 : ret += length_SubjectPublicKeyInfo(&(data)->subjectPKInfo);
262 0 : ret += Top_tag_oldret;
263 : }
264 0 : if((data)->attributes){
265 0 : size_t Top_tag_oldret = ret;
266 0 : ret = 0;
267 : {
268 0 : size_t attributes_tag_oldret = ret;
269 : int i;
270 0 : ret = 0;
271 0 : for(i = ((data)->attributes)->len - 1; i >= 0; --i){
272 0 : size_t attributes_tag_for_oldret = ret;
273 0 : ret = 0;
274 0 : ret += length_Attribute(&((data)->attributes)->val[i]);
275 0 : ret += attributes_tag_for_oldret;
276 : }
277 0 : ret += attributes_tag_oldret;
278 : }
279 0 : ret += 1 + der_length_len (ret);
280 0 : ret += Top_tag_oldret;
281 : }
282 0 : ret += 1 + der_length_len (ret);
283 0 : return ret;
284 : }
285 :
286 : int ASN1CALL
287 0 : copy_CertificationRequestInfo(const CertificationRequestInfo *from, CertificationRequestInfo *to)
288 : {
289 0 : memset(to, 0, sizeof(*to));
290 : { int ret;
291 0 : ret = der_copy_octet_string(&(from)->_save, &(to)->_save);
292 0 : if (ret) goto fail;
293 : }
294 0 : *(&(to)->version) = *(&(from)->version);
295 0 : if(copy_Name(&(from)->subject, &(to)->subject)) goto fail;
296 0 : if(copy_SubjectPublicKeyInfo(&(from)->subjectPKInfo, &(to)->subjectPKInfo)) goto fail;
297 0 : if((from)->attributes) {
298 0 : (to)->attributes = malloc(sizeof(*(to)->attributes));
299 0 : if((to)->attributes == NULL) goto fail;
300 0 : if((((to)->attributes)->val = malloc(((from)->attributes)->len * sizeof(*((to)->attributes)->val))) == NULL && ((from)->attributes)->len != 0)
301 0 : goto fail;
302 0 : for(((to)->attributes)->len = 0; ((to)->attributes)->len < ((from)->attributes)->len; ((to)->attributes)->len++){
303 0 : if(copy_Attribute(&((from)->attributes)->val[((to)->attributes)->len], &((to)->attributes)->val[((to)->attributes)->len])) goto fail;
304 : }
305 : }else
306 0 : (to)->attributes = NULL;
307 0 : return 0;
308 0 : fail:
309 0 : free_CertificationRequestInfo(to);
310 0 : return ENOMEM;
311 : }
312 :
313 : int ASN1CALL
314 0 : encode_CertificationRequest(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const CertificationRequest *data, size_t *size)
315 : {
316 0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
317 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
318 : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
319 :
320 : /* signature */
321 : {
322 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
323 0 : ret = 0;
324 0 : e = der_put_bit_string(p, len, &(data)->signature, &l);
325 0 : if (e) return e;
326 0 : p -= l; len -= l; ret += l;
327 :
328 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
329 0 : if (e) return e;
330 0 : p -= l; len -= l; ret += l;
331 :
332 0 : ret += Top_tag_oldret;
333 : }
334 : /* signatureAlgorithm */
335 : {
336 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
337 0 : ret = 0;
338 0 : e = encode_AlgorithmIdentifier(p, len, &(data)->signatureAlgorithm, &l);
339 0 : if (e) return e;
340 0 : p -= l; len -= l; ret += l;
341 :
342 0 : ret += Top_tag_oldret;
343 : }
344 : /* certificationRequestInfo */
345 : {
346 0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
347 0 : ret = 0;
348 0 : e = encode_CertificationRequestInfo(p, len, &(data)->certificationRequestInfo, &l);
349 0 : if (e) return e;
350 0 : p -= l; len -= l; ret += l;
351 :
352 0 : ret += Top_tag_oldret;
353 : }
354 0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
355 0 : if (e) return e;
356 0 : p -= l; len -= l; ret += l;
357 :
358 0 : *size = ret;
359 0 : return 0;
360 : }
361 :
362 : int ASN1CALL
363 0 : decode_CertificationRequest(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, CertificationRequest *data, size_t *size)
364 : {
365 0 : size_t ret = 0;
366 : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
367 : int e HEIMDAL_UNUSED_ATTRIBUTE;
368 :
369 0 : memset(data, 0, sizeof(*data));
370 : {
371 : size_t Top_datalen, Top_oldlen;
372 : Der_type Top_type;
373 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
374 0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
375 0 : if(e) goto fail;
376 0 : p += l; len -= l; ret += l;
377 0 : Top_oldlen = len;
378 0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
379 0 : len = Top_datalen;
380 0 : e = decode_CertificationRequestInfo(p, len, &(data)->certificationRequestInfo, &l);
381 0 : if(e) goto fail;
382 0 : p += l; len -= l; ret += l;
383 0 : e = decode_AlgorithmIdentifier(p, len, &(data)->signatureAlgorithm, &l);
384 0 : if(e) goto fail;
385 0 : p += l; len -= l; ret += l;
386 : {
387 : size_t signature_datalen, signature_oldlen;
388 : Der_type signature_type;
389 0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &signature_type, UT_BitString, &signature_datalen, &l);
390 0 : if (e == 0 && signature_type != PRIM) { e = ASN1_BAD_ID; }
391 0 : if(e) goto fail;
392 0 : p += l; len -= l; ret += l;
393 0 : signature_oldlen = len;
394 0 : if (signature_datalen > len) { e = ASN1_OVERRUN; goto fail; }
395 0 : len = signature_datalen;
396 0 : e = der_get_bit_string(p, len, &(data)->signature, &l);
397 0 : if(e) goto fail;
398 0 : p += l; len -= l; ret += l;
399 0 : len = signature_oldlen - signature_datalen;
400 : }
401 0 : len = Top_oldlen - Top_datalen;
402 : }
403 0 : if(size) *size = ret;
404 0 : return 0;
405 0 : fail:
406 0 : free_CertificationRequest(data);
407 0 : return e;
408 : }
409 :
410 : void ASN1CALL
411 0 : free_CertificationRequest(CertificationRequest *data)
412 : {
413 0 : free_CertificationRequestInfo(&(data)->certificationRequestInfo);
414 0 : free_AlgorithmIdentifier(&(data)->signatureAlgorithm);
415 0 : der_free_bit_string(&(data)->signature);
416 0 : }
417 :
418 : size_t ASN1CALL
419 0 : length_CertificationRequest(const CertificationRequest *data)
420 : {
421 0 : size_t ret = 0;
422 : {
423 0 : size_t Top_tag_oldret = ret;
424 0 : ret = 0;
425 0 : ret += length_CertificationRequestInfo(&(data)->certificationRequestInfo);
426 0 : ret += Top_tag_oldret;
427 : }
428 : {
429 0 : size_t Top_tag_oldret = ret;
430 0 : ret = 0;
431 0 : ret += length_AlgorithmIdentifier(&(data)->signatureAlgorithm);
432 0 : ret += Top_tag_oldret;
433 : }
434 : {
435 0 : size_t Top_tag_oldret = ret;
436 0 : ret = 0;
437 0 : ret += der_length_bit_string(&(data)->signature);
438 0 : ret += 1 + der_length_len (ret);
439 0 : ret += Top_tag_oldret;
440 : }
441 0 : ret += 1 + der_length_len (ret);
442 0 : return ret;
443 : }
444 :
445 : int ASN1CALL
446 0 : copy_CertificationRequest(const CertificationRequest *from, CertificationRequest *to)
447 : {
448 0 : memset(to, 0, sizeof(*to));
449 0 : if(copy_CertificationRequestInfo(&(from)->certificationRequestInfo, &(to)->certificationRequestInfo)) goto fail;
450 0 : if(copy_AlgorithmIdentifier(&(from)->signatureAlgorithm, &(to)->signatureAlgorithm)) goto fail;
451 0 : if(der_copy_bit_string(&(from)->signature, &(to)->signature)) goto fail;
452 0 : return 0;
453 0 : fail:
454 0 : free_CertificationRequest(to);
455 0 : return ENOMEM;
456 : }
457 :
|
