f0b35fb4fadc8916adfbc64bb16adb79eed22f8a
[openssl.git] / crypto / x509 / x_name.c
1 /*
2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <stdio.h>
11 #include <ctype.h>
12 #include "internal/cryptlib.h"
13 #include <openssl/asn1t.h>
14 #include <openssl/x509.h>
15 #include "internal/x509_int.h"
16 #include "internal/asn1_int.h"
17 #include "x509_lcl.h"
18
19 /*
20  * Maximum length of X509_NAME: much larger than anything we should
21  * ever see in practice.
22  */
23
24 #define X509_NAME_MAX (1024 * 1024)
25
26 static int x509_name_ex_d2i(ASN1_VALUE **val,
27                             const unsigned char **in, long len,
28                             const ASN1_ITEM *it,
29                             int tag, int aclass, char opt, ASN1_TLC *ctx);
30
31 static int x509_name_ex_i2d(ASN1_VALUE **val, unsigned char **out,
32                             const ASN1_ITEM *it, int tag, int aclass);
33 static int x509_name_ex_new(ASN1_VALUE **val, const ASN1_ITEM *it);
34 static void x509_name_ex_free(ASN1_VALUE **val, const ASN1_ITEM *it);
35
36 static int x509_name_encode(X509_NAME *a);
37 static int x509_name_canon(X509_NAME *a);
38 static int asn1_string_canon(ASN1_STRING *out, ASN1_STRING *in);
39 static int i2d_name_canon(STACK_OF(STACK_OF_X509_NAME_ENTRY) * intname,
40                           unsigned char **in);
41
42 static int x509_name_ex_print(BIO *out, ASN1_VALUE **pval,
43                               int indent,
44                               const char *fname, const ASN1_PCTX *pctx);
45
46 ASN1_SEQUENCE(X509_NAME_ENTRY) = {
47         ASN1_SIMPLE(X509_NAME_ENTRY, object, ASN1_OBJECT),
48         ASN1_SIMPLE(X509_NAME_ENTRY, value, ASN1_PRINTABLE)
49 } ASN1_SEQUENCE_END(X509_NAME_ENTRY)
50
51 IMPLEMENT_ASN1_FUNCTIONS(X509_NAME_ENTRY)
52 IMPLEMENT_ASN1_DUP_FUNCTION(X509_NAME_ENTRY)
53
54 /*
55  * For the "Name" type we need a SEQUENCE OF { SET OF X509_NAME_ENTRY } so
56  * declare two template wrappers for this
57  */
58
59 ASN1_ITEM_TEMPLATE(X509_NAME_ENTRIES) =
60         ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SET_OF, 0, RDNS, X509_NAME_ENTRY)
61 static_ASN1_ITEM_TEMPLATE_END(X509_NAME_ENTRIES)
62
63 ASN1_ITEM_TEMPLATE(X509_NAME_INTERNAL) =
64         ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, Name, X509_NAME_ENTRIES)
65 static_ASN1_ITEM_TEMPLATE_END(X509_NAME_INTERNAL)
66
67 /*
68  * Normally that's where it would end: we'd have two nested STACK structures
69  * representing the ASN1. Unfortunately X509_NAME uses a completely different
70  * form and caches encodings so we have to process the internal form and
71  * convert to the external form.
72  */
73
74 static const ASN1_EXTERN_FUNCS x509_name_ff = {
75     NULL,
76     x509_name_ex_new,
77     x509_name_ex_free,
78     0,                          /* Default clear behaviour is OK */
79     x509_name_ex_d2i,
80     x509_name_ex_i2d,
81     x509_name_ex_print
82 };
83
84 IMPLEMENT_EXTERN_ASN1(X509_NAME, V_ASN1_SEQUENCE, x509_name_ff)
85
86 IMPLEMENT_ASN1_FUNCTIONS(X509_NAME)
87
88 IMPLEMENT_ASN1_DUP_FUNCTION(X509_NAME)
89
90 static int x509_name_ex_new(ASN1_VALUE **val, const ASN1_ITEM *it)
91 {
92     X509_NAME *ret = OPENSSL_zalloc(sizeof(*ret));
93
94     if (ret == NULL)
95         goto memerr;
96     if ((ret->entries = sk_X509_NAME_ENTRY_new_null()) == NULL)
97         goto memerr;
98     if ((ret->bytes = BUF_MEM_new()) == NULL)
99         goto memerr;
100     ret->modified = 1;
101     *val = (ASN1_VALUE *)ret;
102     return 1;
103
104  memerr:
105     ASN1err(ASN1_F_X509_NAME_EX_NEW, ERR_R_MALLOC_FAILURE);
106     if (ret) {
107         sk_X509_NAME_ENTRY_free(ret->entries);
108         OPENSSL_free(ret);
109     }
110     return 0;
111 }
112
113 static void x509_name_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it)
114 {
115     X509_NAME *a;
116
117     if (!pval || !*pval)
118         return;
119     a = (X509_NAME *)*pval;
120
121     BUF_MEM_free(a->bytes);
122     sk_X509_NAME_ENTRY_pop_free(a->entries, X509_NAME_ENTRY_free);
123     OPENSSL_free(a->canon_enc);
124     OPENSSL_free(a);
125     *pval = NULL;
126 }
127
128 static int x509_name_ex_d2i(ASN1_VALUE **val,
129                             const unsigned char **in, long len,
130                             const ASN1_ITEM *it, int tag, int aclass,
131                             char opt, ASN1_TLC *ctx)
132 {
133     const unsigned char *p = *in, *q;
134     union {
135         STACK_OF(STACK_OF_X509_NAME_ENTRY) *s;
136         ASN1_VALUE *a;
137     } intname = {
138         NULL
139     };
140     union {
141         X509_NAME *x;
142         ASN1_VALUE *a;
143     } nm = {
144         NULL
145     };
146     int i, j, ret;
147     STACK_OF(X509_NAME_ENTRY) *entries;
148     X509_NAME_ENTRY *entry;
149     if (len > X509_NAME_MAX)
150         len = X509_NAME_MAX;
151     q = p;
152
153     /* Get internal representation of Name */
154     ret = ASN1_item_ex_d2i(&intname.a,
155                            &p, len, ASN1_ITEM_rptr(X509_NAME_INTERNAL),
156                            tag, aclass, opt, ctx);
157
158     if (ret <= 0)
159         return ret;
160
161     if (*val)
162         x509_name_ex_free(val, NULL);
163     if (!x509_name_ex_new(&nm.a, NULL))
164         goto err;
165     /* We've decoded it: now cache encoding */
166     if (!BUF_MEM_grow(nm.x->bytes, p - q))
167         goto err;
168     memcpy(nm.x->bytes->data, q, p - q);
169
170     /* Convert internal representation to X509_NAME structure */
171     for (i = 0; i < sk_STACK_OF_X509_NAME_ENTRY_num(intname.s); i++) {
172         entries = sk_STACK_OF_X509_NAME_ENTRY_value(intname.s, i);
173         for (j = 0; j < sk_X509_NAME_ENTRY_num(entries); j++) {
174             entry = sk_X509_NAME_ENTRY_value(entries, j);
175             entry->set = i;
176             if (!sk_X509_NAME_ENTRY_push(nm.x->entries, entry))
177                 goto err;
178         }
179         sk_X509_NAME_ENTRY_free(entries);
180     }
181     sk_STACK_OF_X509_NAME_ENTRY_free(intname.s);
182     ret = x509_name_canon(nm.x);
183     if (!ret)
184         goto err;
185     nm.x->modified = 0;
186     *val = nm.a;
187     *in = p;
188     return ret;
189  err:
190     X509_NAME_free(nm.x);
191     ASN1err(ASN1_F_X509_NAME_EX_D2I, ERR_R_NESTED_ASN1_ERROR);
192     return 0;
193 }
194
195 static int x509_name_ex_i2d(ASN1_VALUE **val, unsigned char **out,
196                             const ASN1_ITEM *it, int tag, int aclass)
197 {
198     int ret;
199     X509_NAME *a = (X509_NAME *)*val;
200     if (a->modified) {
201         ret = x509_name_encode(a);
202         if (ret < 0)
203             return ret;
204         ret = x509_name_canon(a);
205         if (ret < 0)
206             return ret;
207     }
208     ret = a->bytes->length;
209     if (out != NULL) {
210         memcpy(*out, a->bytes->data, ret);
211         *out += ret;
212     }
213     return ret;
214 }
215
216 static void local_sk_X509_NAME_ENTRY_free(STACK_OF(X509_NAME_ENTRY) *ne)
217 {
218     sk_X509_NAME_ENTRY_free(ne);
219 }
220
221 static void local_sk_X509_NAME_ENTRY_pop_free(STACK_OF(X509_NAME_ENTRY) *ne)
222 {
223     sk_X509_NAME_ENTRY_pop_free(ne, X509_NAME_ENTRY_free);
224 }
225
226 static int x509_name_encode(X509_NAME *a)
227 {
228     union {
229         STACK_OF(STACK_OF_X509_NAME_ENTRY) *s;
230         ASN1_VALUE *a;
231     } intname = {
232         NULL
233     };
234     int len;
235     unsigned char *p;
236     STACK_OF(X509_NAME_ENTRY) *entries = NULL;
237     X509_NAME_ENTRY *entry;
238     int i, set = -1;
239     intname.s = sk_STACK_OF_X509_NAME_ENTRY_new_null();
240     if (!intname.s)
241         goto memerr;
242     for (i = 0; i < sk_X509_NAME_ENTRY_num(a->entries); i++) {
243         entry = sk_X509_NAME_ENTRY_value(a->entries, i);
244         if (entry->set != set) {
245             entries = sk_X509_NAME_ENTRY_new_null();
246             if (!entries)
247                 goto memerr;
248             if (!sk_STACK_OF_X509_NAME_ENTRY_push(intname.s, entries))
249                 goto memerr;
250             set = entry->set;
251         }
252         if (!sk_X509_NAME_ENTRY_push(entries, entry))
253             goto memerr;
254     }
255     len = ASN1_item_ex_i2d(&intname.a, NULL,
256                            ASN1_ITEM_rptr(X509_NAME_INTERNAL), -1, -1);
257     if (!BUF_MEM_grow(a->bytes, len))
258         goto memerr;
259     p = (unsigned char *)a->bytes->data;
260     ASN1_item_ex_i2d(&intname.a,
261                      &p, ASN1_ITEM_rptr(X509_NAME_INTERNAL), -1, -1);
262     sk_STACK_OF_X509_NAME_ENTRY_pop_free(intname.s,
263                                          local_sk_X509_NAME_ENTRY_free);
264     a->modified = 0;
265     return len;
266  memerr:
267     sk_STACK_OF_X509_NAME_ENTRY_pop_free(intname.s,
268                                          local_sk_X509_NAME_ENTRY_free);
269     ASN1err(ASN1_F_X509_NAME_ENCODE, ERR_R_MALLOC_FAILURE);
270     return -1;
271 }
272
273 static int x509_name_ex_print(BIO *out, ASN1_VALUE **pval,
274                               int indent,
275                               const char *fname, const ASN1_PCTX *pctx)
276 {
277     if (X509_NAME_print_ex(out, (X509_NAME *)*pval,
278                            indent, pctx->nm_flags) <= 0)
279         return 0;
280     return 2;
281 }
282
283 /*
284  * This function generates the canonical encoding of the Name structure. In
285  * it all strings are converted to UTF8, leading, trailing and multiple
286  * spaces collapsed, converted to lower case and the leading SEQUENCE header
287  * removed. In future we could also normalize the UTF8 too. By doing this
288  * comparison of Name structures can be rapidly performed by just using
289  * memcmp() of the canonical encoding. By omitting the leading SEQUENCE name
290  * constraints of type dirName can also be checked with a simple memcmp().
291  */
292
293 static int x509_name_canon(X509_NAME *a)
294 {
295     unsigned char *p;
296     STACK_OF(STACK_OF_X509_NAME_ENTRY) *intname = NULL;
297     STACK_OF(X509_NAME_ENTRY) *entries = NULL;
298     X509_NAME_ENTRY *entry, *tmpentry = NULL;
299     int i, set = -1, ret = 0, len;
300
301     OPENSSL_free(a->canon_enc);
302     a->canon_enc = NULL;
303     /* Special case: empty X509_NAME => null encoding */
304     if (sk_X509_NAME_ENTRY_num(a->entries) == 0) {
305         a->canon_enclen = 0;
306         return 1;
307     }
308     intname = sk_STACK_OF_X509_NAME_ENTRY_new_null();
309     if (!intname)
310         goto err;
311     for (i = 0; i < sk_X509_NAME_ENTRY_num(a->entries); i++) {
312         entry = sk_X509_NAME_ENTRY_value(a->entries, i);
313         if (entry->set != set) {
314             entries = sk_X509_NAME_ENTRY_new_null();
315             if (!entries)
316                 goto err;
317             if (!sk_STACK_OF_X509_NAME_ENTRY_push(intname, entries))
318                 goto err;
319             set = entry->set;
320         }
321         tmpentry = X509_NAME_ENTRY_new();
322         if (tmpentry == NULL)
323             goto err;
324         tmpentry->object = OBJ_dup(entry->object);
325         if (!asn1_string_canon(tmpentry->value, entry->value))
326             goto err;
327         if (!sk_X509_NAME_ENTRY_push(entries, tmpentry))
328             goto err;
329         tmpentry = NULL;
330     }
331
332     /* Finally generate encoding */
333
334     len = i2d_name_canon(intname, NULL);
335     if (len < 0)
336         goto err;
337     a->canon_enclen = len;
338
339     p = OPENSSL_malloc(a->canon_enclen);
340
341     if (p == NULL)
342         goto err;
343
344     a->canon_enc = p;
345
346     i2d_name_canon(intname, &p);
347
348     ret = 1;
349
350  err:
351
352     X509_NAME_ENTRY_free(tmpentry);
353     sk_STACK_OF_X509_NAME_ENTRY_pop_free(intname,
354                                          local_sk_X509_NAME_ENTRY_pop_free);
355     return ret;
356 }
357
358 /* Bitmap of all the types of string that will be canonicalized. */
359
360 #define ASN1_MASK_CANON \
361         (B_ASN1_UTF8STRING | B_ASN1_BMPSTRING | B_ASN1_UNIVERSALSTRING \
362         | B_ASN1_PRINTABLESTRING | B_ASN1_T61STRING | B_ASN1_IA5STRING \
363         | B_ASN1_VISIBLESTRING)
364
365 static int asn1_string_canon(ASN1_STRING *out, ASN1_STRING *in)
366 {
367     unsigned char *to, *from;
368     int len, i;
369
370     /* If type not in bitmask just copy string across */
371     if (!(ASN1_tag2bit(in->type) & ASN1_MASK_CANON)) {
372         if (!ASN1_STRING_copy(out, in))
373             return 0;
374         return 1;
375     }
376
377     out->type = V_ASN1_UTF8STRING;
378     out->length = ASN1_STRING_to_UTF8(&out->data, in);
379     if (out->length == -1)
380         return 0;
381
382     to = out->data;
383     from = to;
384
385     len = out->length;
386
387     /*
388      * Convert string in place to canonical form. Ultimately we may need to
389      * handle a wider range of characters but for now ignore anything with
390      * MSB set and rely on the isspace() and tolower() functions.
391      */
392
393     /* Ignore leading spaces */
394     while ((len > 0) && !(*from & 0x80) && isspace(*from)) {
395         from++;
396         len--;
397     }
398
399     to = from + len - 1;
400
401     /* Ignore trailing spaces */
402     while ((len > 0) && !(*to & 0x80) && isspace(*to)) {
403         to--;
404         len--;
405     }
406
407     to = out->data;
408
409     i = 0;
410     while (i < len) {
411         /* If MSB set just copy across */
412         if (*from & 0x80) {
413             *to++ = *from++;
414             i++;
415         }
416         /* Collapse multiple spaces */
417         else if (isspace(*from)) {
418             /* Copy one space across */
419             *to++ = ' ';
420             /*
421              * Ignore subsequent spaces. Note: don't need to check len here
422              * because we know the last character is a non-space so we can't
423              * overflow.
424              */
425             do {
426                 from++;
427                 i++;
428             }
429             while (!(*from & 0x80) && isspace(*from));
430         } else {
431             *to++ = tolower(*from);
432             from++;
433             i++;
434         }
435     }
436
437     out->length = to - out->data;
438
439     return 1;
440
441 }
442
443 static int i2d_name_canon(STACK_OF(STACK_OF_X509_NAME_ENTRY) * _intname,
444                           unsigned char **in)
445 {
446     int i, len, ltmp;
447     ASN1_VALUE *v;
448     STACK_OF(ASN1_VALUE) *intname = (STACK_OF(ASN1_VALUE) *)_intname;
449
450     len = 0;
451     for (i = 0; i < sk_ASN1_VALUE_num(intname); i++) {
452         v = sk_ASN1_VALUE_value(intname, i);
453         ltmp = ASN1_item_ex_i2d(&v, in,
454                                 ASN1_ITEM_rptr(X509_NAME_ENTRIES), -1, -1);
455         if (ltmp < 0)
456             return ltmp;
457         len += ltmp;
458     }
459     return len;
460 }
461
462 int X509_NAME_set(X509_NAME **xn, X509_NAME *name)
463 {
464     X509_NAME *in;
465
466     if (!xn || !name)
467         return (0);
468
469     if (*xn != name) {
470         in = X509_NAME_dup(name);
471         if (in != NULL) {
472             X509_NAME_free(*xn);
473             *xn = in;
474         }
475     }
476     return (*xn != NULL);
477 }
478
479 int X509_NAME_print(BIO *bp, X509_NAME *name, int obase)
480 {
481     char *s, *c, *b;
482     int l, i;
483
484     l = 80 - 2 - obase;
485
486     b = X509_NAME_oneline(name, NULL, 0);
487     if (!b)
488         return 0;
489     if (!*b) {
490         OPENSSL_free(b);
491         return 1;
492     }
493     s = b + 1;                  /* skip the first slash */
494
495     c = s;
496     for (;;) {
497 #ifndef CHARSET_EBCDIC
498         if (((*s == '/') &&
499              ((s[1] >= 'A') && (s[1] <= 'Z') && ((s[2] == '=') ||
500                                                  ((s[2] >= 'A')
501                                                   && (s[2] <= 'Z')
502                                                   && (s[3] == '='))
503               ))) || (*s == '\0'))
504 #else
505         if (((*s == '/') &&
506              (isupper(s[1]) && ((s[2] == '=') ||
507                                 (isupper(s[2]) && (s[3] == '='))
508               ))) || (*s == '\0'))
509 #endif
510         {
511             i = s - c;
512             if (BIO_write(bp, c, i) != i)
513                 goto err;
514             c = s + 1;          /* skip following slash */
515             if (*s != '\0') {
516                 if (BIO_write(bp, ", ", 2) != 2)
517                     goto err;
518             }
519             l--;
520         }
521         if (*s == '\0')
522             break;
523         s++;
524         l--;
525     }
526
527     OPENSSL_free(b);
528     return 1;
529  err:
530     X509err(X509_F_X509_NAME_PRINT, ERR_R_BUF_LIB);
531     OPENSSL_free(b);
532     return 0;
533 }
534
535 int X509_NAME_get0_der(const unsigned char **pder, size_t *pderlen,
536                        X509_NAME *nm)
537 {
538     /* Make sure encoding is valid */
539     if (i2d_X509_NAME(nm, NULL) <= 0)
540         return 0;
541     if (pder != NULL)
542         *pder = (unsigned char *)nm->bytes->data;
543     if (pderlen != NULL)
544         *pderlen = nm->bytes->length;
545     return 1;
546 }