Coverage Report

Created: 2023-06-08 06:41

/src/openssl30/crypto/x509/x_name.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
3
 *
4
 * Licensed under the Apache License 2.0 (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 "crypto/ctype.h"
12
#include "internal/cryptlib.h"
13
#include <openssl/asn1t.h>
14
#include <openssl/x509.h>
15
#include "crypto/x509.h"
16
#include "crypto/asn1.h"
17
#include "x509_local.h"
18
19
/*
20
 * Maximum length of X509_NAME: much larger than anything we should
21
 * ever see in practice.
22
 */
23
24
27.4k
#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(const 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, const ASN1_STRING *in);
39
static int i2d_name_canon(const STACK_OF(STACK_OF_X509_NAME_ENTRY) * intname,
40
                          unsigned char **in);
41
42
static int x509_name_ex_print(BIO *out, const 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
63.7k
{
92
63.7k
    X509_NAME *ret = OPENSSL_zalloc(sizeof(*ret));
93
94
63.7k
    if (ret == NULL)
95
0
        goto memerr;
96
63.7k
    if ((ret->entries = sk_X509_NAME_ENTRY_new_null()) == NULL)
97
0
        goto memerr;
98
63.7k
    if ((ret->bytes = BUF_MEM_new()) == NULL)
99
0
        goto memerr;
100
63.7k
    ret->modified = 1;
101
63.7k
    *val = (ASN1_VALUE *)ret;
102
63.7k
    return 1;
103
104
0
 memerr:
105
0
    ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
106
0
    if (ret) {
107
0
        sk_X509_NAME_ENTRY_free(ret->entries);
108
0
        OPENSSL_free(ret);
109
0
    }
110
0
    return 0;
111
63.7k
}
112
113
static void x509_name_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it)
114
63.7k
{
115
63.7k
    X509_NAME *a;
116
117
63.7k
    if (pval == NULL || *pval == NULL)
118
0
        return;
119
63.7k
    a = (X509_NAME *)*pval;
120
121
63.7k
    BUF_MEM_free(a->bytes);
122
63.7k
    sk_X509_NAME_ENTRY_pop_free(a->entries, X509_NAME_ENTRY_free);
123
63.7k
    OPENSSL_free(a->canon_enc);
124
63.7k
    OPENSSL_free(a);
125
63.7k
    *pval = NULL;
126
63.7k
}
127
128
static void local_sk_X509_NAME_ENTRY_free(STACK_OF(X509_NAME_ENTRY) *ne)
129
26.7k
{
130
26.7k
    sk_X509_NAME_ENTRY_free(ne);
131
26.7k
}
132
133
static void local_sk_X509_NAME_ENTRY_pop_free(STACK_OF(X509_NAME_ENTRY) *ne)
134
21.2k
{
135
21.2k
    sk_X509_NAME_ENTRY_pop_free(ne, X509_NAME_ENTRY_free);
136
21.2k
}
137
138
static int x509_name_ex_d2i(ASN1_VALUE **val,
139
                            const unsigned char **in, long len,
140
                            const ASN1_ITEM *it, int tag, int aclass,
141
                            char opt, ASN1_TLC *ctx)
142
27.4k
{
143
27.4k
    const unsigned char *p = *in, *q;
144
27.4k
    union {
145
27.4k
        STACK_OF(STACK_OF_X509_NAME_ENTRY) *s;
146
27.4k
        ASN1_VALUE *a;
147
27.4k
    } intname = {
148
27.4k
        NULL
149
27.4k
    };
150
27.4k
    union {
151
27.4k
        X509_NAME *x;
152
27.4k
        ASN1_VALUE *a;
153
27.4k
    } nm = {
154
27.4k
        NULL
155
27.4k
    };
156
27.4k
    int i, j, ret;
157
27.4k
    STACK_OF(X509_NAME_ENTRY) *entries;
158
27.4k
    X509_NAME_ENTRY *entry;
159
160
27.4k
    if (len > X509_NAME_MAX)
161
0
        len = X509_NAME_MAX;
162
27.4k
    q = p;
163
164
    /* Get internal representation of Name */
165
27.4k
    ret = ASN1_item_ex_d2i(&intname.a,
166
27.4k
                           &p, len, ASN1_ITEM_rptr(X509_NAME_INTERNAL),
167
27.4k
                           tag, aclass, opt, ctx);
168
169
27.4k
    if (ret <= 0)
170
89
        return ret;
171
172
27.4k
    if (*val)
173
5.12k
        x509_name_ex_free(val, NULL);
174
27.4k
    if (!x509_name_ex_new(&nm.a, NULL))
175
0
        goto err;
176
    /* We've decoded it: now cache encoding */
177
27.4k
    if (!BUF_MEM_grow(nm.x->bytes, p - q))
178
0
        goto err;
179
27.4k
    memcpy(nm.x->bytes->data, q, p - q);
180
181
    /* Convert internal representation to X509_NAME structure */
182
54.2k
    for (i = 0; i < sk_STACK_OF_X509_NAME_ENTRY_num(intname.s); i++) {
183
26.8k
        entries = sk_STACK_OF_X509_NAME_ENTRY_value(intname.s, i);
184
91.0k
        for (j = 0; j < sk_X509_NAME_ENTRY_num(entries); j++) {
185
64.2k
            entry = sk_X509_NAME_ENTRY_value(entries, j);
186
64.2k
            entry->set = i;
187
64.2k
            if (!sk_X509_NAME_ENTRY_push(nm.x->entries, entry))
188
0
                goto err;
189
64.2k
            (void)sk_X509_NAME_ENTRY_set(entries, j, NULL);
190
64.2k
        }
191
26.8k
    }
192
27.4k
    ret = x509_name_canon(nm.x);
193
27.4k
    if (!ret)
194
84
        goto err;
195
27.3k
    sk_STACK_OF_X509_NAME_ENTRY_pop_free(intname.s,
196
27.3k
                                         local_sk_X509_NAME_ENTRY_free);
197
27.3k
    nm.x->modified = 0;
198
27.3k
    *val = nm.a;
199
27.3k
    *in = p;
200
27.3k
    return ret;
201
202
84
 err:
203
84
    if (nm.x != NULL)
204
84
        X509_NAME_free(nm.x);
205
84
    sk_STACK_OF_X509_NAME_ENTRY_pop_free(intname.s,
206
84
                                         local_sk_X509_NAME_ENTRY_pop_free);
207
84
    ERR_raise(ERR_LIB_ASN1, ERR_R_NESTED_ASN1_ERROR);
208
84
    return 0;
209
27.4k
}
210
211
static int x509_name_ex_i2d(const ASN1_VALUE **val, unsigned char **out,
212
                            const ASN1_ITEM *it, int tag, int aclass)
213
101k
{
214
101k
    int ret;
215
101k
    X509_NAME *a = (X509_NAME *)*val;
216
217
101k
    if (a->modified) {
218
7.14k
        ret = x509_name_encode(a);
219
7.14k
        if (ret < 0)
220
0
            return ret;
221
7.14k
        ret = x509_name_canon(a);
222
7.14k
        if (!ret)
223
0
            return -1;
224
7.14k
    }
225
101k
    ret = a->bytes->length;
226
101k
    if (out != NULL) {
227
20.5k
        memcpy(*out, a->bytes->data, ret);
228
20.5k
        *out += ret;
229
20.5k
    }
230
101k
    return ret;
231
101k
}
232
233
static int x509_name_encode(X509_NAME *a)
234
7.14k
{
235
7.14k
    union {
236
7.14k
        STACK_OF(STACK_OF_X509_NAME_ENTRY) *s;
237
7.14k
        const ASN1_VALUE *a;
238
7.14k
    } intname = {
239
7.14k
        NULL
240
7.14k
    };
241
7.14k
    int len;
242
7.14k
    unsigned char *p;
243
7.14k
    STACK_OF(X509_NAME_ENTRY) *entries = NULL;
244
7.14k
    X509_NAME_ENTRY *entry;
245
7.14k
    int i, set = -1;
246
247
7.14k
    intname.s = sk_STACK_OF_X509_NAME_ENTRY_new_null();
248
7.14k
    if (!intname.s)
249
0
        goto memerr;
250
7.14k
    for (i = 0; i < sk_X509_NAME_ENTRY_num(a->entries); i++) {
251
0
        entry = sk_X509_NAME_ENTRY_value(a->entries, i);
252
0
        if (entry->set != set) {
253
0
            entries = sk_X509_NAME_ENTRY_new_null();
254
0
            if (!entries)
255
0
                goto memerr;
256
0
            if (!sk_STACK_OF_X509_NAME_ENTRY_push(intname.s, entries)) {
257
0
                sk_X509_NAME_ENTRY_free(entries);
258
0
                goto memerr;
259
0
            }
260
0
            set = entry->set;
261
0
        }
262
0
        if (!sk_X509_NAME_ENTRY_push(entries, entry))
263
0
            goto memerr;
264
0
    }
265
7.14k
    len = ASN1_item_ex_i2d(&intname.a, NULL,
266
7.14k
                           ASN1_ITEM_rptr(X509_NAME_INTERNAL), -1, -1);
267
7.14k
    if (!BUF_MEM_grow(a->bytes, len))
268
0
        goto memerr;
269
7.14k
    p = (unsigned char *)a->bytes->data;
270
7.14k
    ASN1_item_ex_i2d(&intname.a,
271
7.14k
                     &p, ASN1_ITEM_rptr(X509_NAME_INTERNAL), -1, -1);
272
7.14k
    sk_STACK_OF_X509_NAME_ENTRY_pop_free(intname.s,
273
7.14k
                                         local_sk_X509_NAME_ENTRY_free);
274
7.14k
    a->modified = 0;
275
7.14k
    return len;
276
0
 memerr:
277
0
    sk_STACK_OF_X509_NAME_ENTRY_pop_free(intname.s,
278
0
                                         local_sk_X509_NAME_ENTRY_free);
279
0
    ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
280
0
    return -1;
281
7.14k
}
282
283
static int x509_name_ex_print(BIO *out, const ASN1_VALUE **pval,
284
                              int indent,
285
                              const char *fname, const ASN1_PCTX *pctx)
286
4.76k
{
287
4.76k
    if (X509_NAME_print_ex(out, (const X509_NAME *)*pval,
288
4.76k
                           indent, pctx->nm_flags) <= 0)
289
44
        return 0;
290
4.72k
    return 2;
291
4.76k
}
292
293
/*
294
 * This function generates the canonical encoding of the Name structure. In
295
 * it all strings are converted to UTF8, leading, trailing and multiple
296
 * spaces collapsed, converted to lower case and the leading SEQUENCE header
297
 * removed. In future we could also normalize the UTF8 too. By doing this
298
 * comparison of Name structures can be rapidly performed by just using
299
 * memcmp() of the canonical encoding. By omitting the leading SEQUENCE name
300
 * constraints of type dirName can also be checked with a simple memcmp().
301
 * NOTE: For empty X509_NAME (NULL-DN), canon_enclen == 0 && canon_enc == NULL
302
 */
303
304
static int x509_name_canon(X509_NAME *a)
305
34.5k
{
306
34.5k
    unsigned char *p;
307
34.5k
    STACK_OF(STACK_OF_X509_NAME_ENTRY) *intname;
308
34.5k
    STACK_OF(X509_NAME_ENTRY) *entries = NULL;
309
34.5k
    X509_NAME_ENTRY *entry, *tmpentry = NULL;
310
34.5k
    int i, set = -1, ret = 0, len;
311
312
34.5k
    OPENSSL_free(a->canon_enc);
313
34.5k
    a->canon_enc = NULL;
314
    /* Special case: empty X509_NAME => null encoding */
315
34.5k
    if (sk_X509_NAME_ENTRY_num(a->entries) == 0) {
316
23.9k
        a->canon_enclen = 0;
317
23.9k
        return 1;
318
23.9k
    }
319
10.5k
    intname = sk_STACK_OF_X509_NAME_ENTRY_new_null();
320
10.5k
    if (intname == NULL) {
321
0
        ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
322
0
        goto err;
323
0
    }
324
74.6k
    for (i = 0; i < sk_X509_NAME_ENTRY_num(a->entries); i++) {
325
64.1k
        entry = sk_X509_NAME_ENTRY_value(a->entries, i);
326
64.1k
        if (entry->set != set) {
327
21.1k
            entries = sk_X509_NAME_ENTRY_new_null();
328
21.1k
            if (entries == NULL)
329
0
                goto err;
330
21.1k
            if (!sk_STACK_OF_X509_NAME_ENTRY_push(intname, entries)) {
331
0
                sk_X509_NAME_ENTRY_free(entries);
332
0
                ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
333
0
                goto err;
334
0
            }
335
21.1k
            set = entry->set;
336
21.1k
        }
337
64.1k
        tmpentry = X509_NAME_ENTRY_new();
338
64.1k
        if (tmpentry == NULL) {
339
0
            ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
340
0
            goto err;
341
0
        }
342
64.1k
        tmpentry->object = OBJ_dup(entry->object);
343
64.1k
        if (tmpentry->object == NULL) {
344
0
            ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
345
0
            goto err;
346
0
        }
347
64.1k
        if (!asn1_string_canon(tmpentry->value, entry->value))
348
84
            goto err;
349
64.0k
        if (!sk_X509_NAME_ENTRY_push(entries, tmpentry)) {
350
0
            ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
351
0
            goto err;
352
0
        }
353
64.0k
        tmpentry = NULL;
354
64.0k
    }
355
356
    /* Finally generate encoding */
357
10.5k
    len = i2d_name_canon(intname, NULL);
358
10.5k
    if (len < 0)
359
0
        goto err;
360
10.5k
    a->canon_enclen = len;
361
362
10.5k
    p = OPENSSL_malloc(a->canon_enclen);
363
10.5k
    if (p == NULL) {
364
0
        ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
365
0
        goto err;
366
0
    }
367
368
10.5k
    a->canon_enc = p;
369
370
10.5k
    i2d_name_canon(intname, &p);
371
372
10.5k
    ret = 1;
373
374
10.5k
 err:
375
10.5k
    X509_NAME_ENTRY_free(tmpentry);
376
10.5k
    sk_STACK_OF_X509_NAME_ENTRY_pop_free(intname,
377
10.5k
                                         local_sk_X509_NAME_ENTRY_pop_free);
378
10.5k
    return ret;
379
10.5k
}
380
381
/* Bitmap of all the types of string that will be canonicalized. */
382
383
#define ASN1_MASK_CANON \
384
64.1k
        (B_ASN1_UTF8STRING | B_ASN1_BMPSTRING | B_ASN1_UNIVERSALSTRING \
385
64.1k
        | B_ASN1_PRINTABLESTRING | B_ASN1_T61STRING | B_ASN1_IA5STRING \
386
64.1k
        | B_ASN1_VISIBLESTRING)
387
388
static int asn1_string_canon(ASN1_STRING *out, const ASN1_STRING *in)
389
64.1k
{
390
64.1k
    unsigned char *to, *from;
391
64.1k
    int len, i;
392
393
    /* If type not in bitmask just copy string across */
394
64.1k
    if (!(ASN1_tag2bit(in->type) & ASN1_MASK_CANON)) {
395
37.1k
        if (!ASN1_STRING_copy(out, in))
396
0
            return 0;
397
37.1k
        return 1;
398
37.1k
    }
399
400
27.0k
    out->type = V_ASN1_UTF8STRING;
401
27.0k
    out->length = ASN1_STRING_to_UTF8(&out->data, in);
402
27.0k
    if (out->length == -1)
403
84
        return 0;
404
405
26.9k
    to = out->data;
406
26.9k
    from = to;
407
408
26.9k
    len = out->length;
409
410
    /*
411
     * Convert string in place to canonical form. Ultimately we may need to
412
     * handle a wider range of characters but for now ignore anything with
413
     * MSB set and rely on the ossl_isspace() to fail on bad characters without
414
     * needing isascii or range checks as well.
415
     */
416
417
    /* Ignore leading spaces */
418
27.3k
    while (len > 0 && ossl_isspace(*from)) {
419
440
        from++;
420
440
        len--;
421
440
    }
422
423
26.9k
    to = from + len;
424
425
    /* Ignore trailing spaces */
426
27.1k
    while (len > 0 && ossl_isspace(to[-1])) {
427
263
        to--;
428
263
        len--;
429
263
    }
430
431
26.9k
    to = out->data;
432
433
26.9k
    i = 0;
434
5.00M
    while (i < len) {
435
        /* If not ASCII set just copy across */
436
4.97M
        if (!ossl_isascii(*from)) {
437
3.50M
            *to++ = *from++;
438
3.50M
            i++;
439
3.50M
        }
440
        /* Collapse multiple spaces */
441
1.46M
        else if (ossl_isspace(*from)) {
442
            /* Copy one space across */
443
22.3k
            *to++ = ' ';
444
            /*
445
             * Ignore subsequent spaces. Note: don't need to check len here
446
             * because we know the last character is a non-space so we can't
447
             * overflow.
448
             */
449
30.7k
            do {
450
30.7k
                from++;
451
30.7k
                i++;
452
30.7k
            }
453
30.7k
            while (ossl_isspace(*from));
454
1.44M
        } else {
455
1.44M
            *to++ = ossl_tolower(*from);
456
1.44M
            from++;
457
1.44M
            i++;
458
1.44M
        }
459
4.97M
    }
460
461
26.9k
    out->length = to - out->data;
462
463
26.9k
    return 1;
464
465
27.0k
}
466
467
static int i2d_name_canon(const STACK_OF(STACK_OF_X509_NAME_ENTRY) * _intname,
468
                          unsigned char **in)
469
21.0k
{
470
21.0k
    int i, len, ltmp;
471
21.0k
    const ASN1_VALUE *v;
472
21.0k
    STACK_OF(ASN1_VALUE) *intname = (STACK_OF(ASN1_VALUE) *)_intname;
473
474
21.0k
    len = 0;
475
63.1k
    for (i = 0; i < sk_ASN1_VALUE_num(intname); i++) {
476
42.1k
        v = sk_ASN1_VALUE_value(intname, i);
477
42.1k
        ltmp = ASN1_item_ex_i2d(&v, in,
478
42.1k
                                ASN1_ITEM_rptr(X509_NAME_ENTRIES), -1, -1);
479
42.1k
        if (ltmp < 0)
480
0
            return ltmp;
481
42.1k
        len += ltmp;
482
42.1k
    }
483
21.0k
    return len;
484
21.0k
}
485
486
int X509_NAME_set(X509_NAME **xn, const X509_NAME *name)
487
10.2k
{
488
10.2k
    X509_NAME *name_copy;
489
490
10.2k
    if (*xn == name)
491
0
        return *xn != NULL;
492
10.2k
    if ((name_copy = X509_NAME_dup(name)) == NULL)
493
0
        return 0;
494
10.2k
    X509_NAME_free(*xn);
495
10.2k
    *xn = name_copy;
496
10.2k
    return 1;
497
10.2k
}
498
499
int X509_NAME_print(BIO *bp, const X509_NAME *name, int obase)
500
4.76k
{
501
4.76k
    char *s, *c, *b;
502
4.76k
    int i;
503
504
4.76k
    b = X509_NAME_oneline(name, NULL, 0);
505
4.76k
    if (b == NULL)
506
44
        return 0;
507
4.72k
    if (*b == '\0') {
508
2.22k
        OPENSSL_free(b);
509
2.22k
        return 1;
510
2.22k
    }
511
2.49k
    s = b + 1;                  /* skip the first slash */
512
513
2.49k
    c = s;
514
51.0M
    for (;;) {
515
51.0M
        if (((*s == '/') &&
516
51.0M
             (ossl_isupper(s[1]) && ((s[2] == '=') ||
517
23.2k
                                (ossl_isupper(s[2]) && (s[3] == '='))
518
51.0M
              ))) || (*s == '\0'))
519
4.18k
        {
520
4.18k
            i = s - c;
521
4.18k
            if (BIO_write(bp, c, i) != i)
522
0
                goto err;
523
4.18k
            c = s + 1;          /* skip following slash */
524
4.18k
            if (*s != '\0') {
525
1.68k
                if (BIO_write(bp, ", ", 2) != 2)
526
0
                    goto err;
527
1.68k
            }
528
4.18k
        }
529
51.0M
        if (*s == '\0')
530
2.49k
            break;
531
51.0M
        s++;
532
51.0M
    }
533
534
2.49k
    OPENSSL_free(b);
535
2.49k
    return 1;
536
0
 err:
537
0
    ERR_raise(ERR_LIB_X509, ERR_R_BUF_LIB);
538
0
    OPENSSL_free(b);
539
0
    return 0;
540
2.49k
}
541
542
int X509_NAME_get0_der(const X509_NAME *nm, const unsigned char **pder,
543
                       size_t *pderlen)
544
0
{
545
    /* Make sure encoding is valid */
546
0
    if (i2d_X509_NAME(nm, NULL) <= 0)
547
0
        return 0;
548
0
    if (pder != NULL)
549
0
        *pder = (unsigned char *)nm->bytes->data;
550
0
    if (pderlen != NULL)
551
0
        *pderlen = nm->bytes->length;
552
0
    return 1;
553
0
}