← Back to branch summary

~ubuntu-branches/ubuntu/saucy/wpasupplicant/saucy

« back to all changes in this revision

Viewing changes to src/tls/x509v3.c

  • Committer: Bazaar Package Importer
  • Author(s): Mathieu Trudel-Lapierre
  • Date: 2010-11-22 09:43:43 UTC
  • mfrom: (1.1.16 upstream)
  • Revision ID: james.westby@ubuntu.com-20101122094343-qgsxaojvmswfri77
Tags: 0.7.3-0ubuntu1
* Get wpasupplicant 0.7.3 from Debian's SVN. Leaving 0.7.3-1 as unreleased
  for now.
* Build-Depend on debhelper 8, since the packaging from Debian uses compat 8.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/tls/x509v3.c
15
15
#include "includes.h"
16
16
 
17
17
#include "common.h"
18
 
 
19
 
#ifdef CONFIG_INTERNAL_X509
20
 
 
 
18
#include "crypto/crypto.h"
21
19
#include "asn1.h"
22
 
#include "crypto.h"
23
20
#include "x509v3.h"
24
21
 
25
22
 
26
23
static void x509_free_name(struct x509_name *name)
27
24
{
28
 
        os_free(name->cn);
29
 
        os_free(name->c);
30
 
        os_free(name->l);
31
 
        os_free(name->st);
32
 
        os_free(name->o);
33
 
        os_free(name->ou);
 
25
        size_t i;
 
26
 
 
27
        for (i = 0; i < name->num_attr; i++) {
 
28
                os_free(name->attr[i].value);
 
29
                name->attr[i].value = NULL;
 
30
                name->attr[i].type = X509_NAME_ATTR_NOT_USED;
 
31
        }
 
32
        name->num_attr = 0;
34
33
        os_free(name->email);
35
 
        name->cn = name->c = name->l = name->st = name->o = name->ou = NULL;
36
34
        name->email = NULL;
 
35
 
 
36
        os_free(name->alt_email);
 
37
        os_free(name->dns);
 
38
        os_free(name->uri);
 
39
        os_free(name->ip);
 
40
        name->alt_email = name->dns = name->uri = NULL;
 
41
        name->ip = NULL;
 
42
        name->ip_len = 0;
 
43
        os_memset(&name->rid, 0, sizeof(name->rid));
37
44
}
38
45
 
39
46
 
146
153
int x509_name_compare(struct x509_name *a, struct x509_name *b)
147
154
{
148
155
        int res;
 
156
        size_t i;
149
157
 
150
158
        if (!a && b)
151
159
                return -1;
153
161
                return 1;
154
162
        if (!a && !b)
155
163
                return 0;
 
164
        if (a->num_attr < b->num_attr)
 
165
                return -1;
 
166
        if (a->num_attr > b->num_attr)
 
167
                return 1;
156
168
 
157
 
        res = x509_str_compare(a->cn, b->cn);
158
 
        if (res)
159
 
                return res;
160
 
        res = x509_str_compare(a->c, b->c);
161
 
        if (res)
162
 
                return res;
163
 
        res = x509_str_compare(a->l, b->l);
164
 
        if (res)
165
 
                return res;
166
 
        res = x509_str_compare(a->st, b->st);
167
 
        if (res)
168
 
                return res;
169
 
        res = x509_str_compare(a->o, b->o);
170
 
        if (res)
171
 
                return res;
172
 
        res = x509_str_compare(a->ou, b->ou);
173
 
        if (res)
174
 
                return res;
 
169
        for (i = 0; i < a->num_attr; i++) {
 
170
                if (a->attr[i].type < b->attr[i].type)
 
171
                        return -1;
 
172
                if (a->attr[i].type > b->attr[i].type)
 
173
                        return -1;
 
174
                res = x509_str_compare(a->attr[i].value, b->attr[i].value);
 
175
                if (res)
 
176
                        return res;
 
177
        }
175
178
        res = x509_str_compare(a->email, b->email);
176
179
        if (res)
177
180
                return res;
298
301
        struct asn1_hdr hdr;
299
302
        const u8 *pos, *end, *set_pos, *set_end, *seq_pos, *seq_end;
300
303
        struct asn1_oid oid;
301
 
        char **fieldp;
 
304
        char *val;
302
305
 
303
306
        /*
304
307
         * Name ::= CHOICE { RDNSequence }
328
331
        end = *next = pos + hdr.length;
329
332
 
330
333
        while (pos < end) {
 
334
                enum x509_name_attr_type type;
 
335
 
331
336
                if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
332
337
                    hdr.class != ASN1_CLASS_UNIVERSAL ||
333
338
                    hdr.tag != ASN1_TAG_SET) {
375
380
                 * pseudonym, generation qualifier.
376
381
                 * MUST: domainComponent (RFC 2247).
377
382
                 */
378
 
                fieldp = NULL;
 
383
                type = X509_NAME_ATTR_NOT_USED;
379
384
                if (oid.len == 4 &&
380
385
                    oid.oid[0] == 2 && oid.oid[1] == 5 && oid.oid[2] == 4) {
381
386
                        /* id-at ::= 2.5.4 */
382
387
                        switch (oid.oid[3]) {
383
388
                        case 3:
384
389
                                /* commonName */
385
 
                                fieldp = &name->cn;
 
390
                                type = X509_NAME_ATTR_CN;
386
391
                                break;
387
392
                        case 6:
388
393
                                /*  countryName */
389
 
                                fieldp = &name->c;
 
394
                                type = X509_NAME_ATTR_C;
390
395
                                break;
391
396
                        case 7:
392
397
                                /* localityName */
393
 
                                fieldp = &name->l;
 
398
                                type = X509_NAME_ATTR_L;
394
399
                                break;
395
400
                        case 8:
396
401
                                /* stateOrProvinceName */
397
 
                                fieldp = &name->st;
 
402
                                type = X509_NAME_ATTR_ST;
398
403
                                break;
399
404
                        case 10:
400
405
                                /* organizationName */
401
 
                                fieldp = &name->o;
 
406
                                type = X509_NAME_ATTR_O;
402
407
                                break;
403
408
                        case 11:
404
409
                                /* organizationalUnitName */
405
 
                                fieldp = &name->ou;
 
410
                                type = X509_NAME_ATTR_OU;
406
411
                                break;
407
412
                        }
408
413
                } else if (oid.len == 7 &&
411
416
                           oid.oid[4] == 1 && oid.oid[5] == 9 &&
412
417
                           oid.oid[6] == 1) {
413
418
                        /* 1.2.840.113549.1.9.1 - e-mailAddress */
414
 
                        fieldp = &name->email;
 
419
                        os_free(name->email);
 
420
                        name->email = os_malloc(hdr.length + 1);
 
421
                        if (name->email == NULL) {
 
422
                                x509_free_name(name);
 
423
                                return -1;
 
424
                        }
 
425
                        os_memcpy(name->email, hdr.payload, hdr.length);
 
426
                        name->email[hdr.length] = '\0';
 
427
                        continue;
 
428
                } else if (oid.len == 7 &&
 
429
                           oid.oid[0] == 0 && oid.oid[1] == 9 &&
 
430
                           oid.oid[2] == 2342 && oid.oid[3] == 19200300 &&
 
431
                           oid.oid[4] == 100 && oid.oid[5] == 1 &&
 
432
                           oid.oid[6] == 25) {
 
433
                        /* 0.9.2342.19200300.100.1.25 - domainComponent */
 
434
                        type = X509_NAME_ATTR_DC;
415
435
                }
416
436
 
417
 
                if (fieldp == NULL) {
 
437
                if (type == X509_NAME_ATTR_NOT_USED) {
418
438
                        wpa_hexdump(MSG_DEBUG, "X509: Unrecognized OID",
419
439
                                    (u8 *) oid.oid,
420
440
                                    oid.len * sizeof(oid.oid[0]));
423
443
                        continue;
424
444
                }
425
445
 
426
 
                os_free(*fieldp);
427
 
                *fieldp = os_malloc(hdr.length + 1);
428
 
                if (*fieldp == NULL) {
429
 
                        x509_free_name(name);
430
 
                        return -1;
431
 
                }
432
 
                os_memcpy(*fieldp, hdr.payload, hdr.length);
433
 
                (*fieldp)[hdr.length] = '\0';
 
446
                if (name->num_attr == X509_MAX_NAME_ATTRIBUTES) {
 
447
                        wpa_printf(MSG_INFO, "X509: Too many Name attributes");
 
448
                        x509_free_name(name);
 
449
                        return -1;
 
450
                }
 
451
 
 
452
                val = os_malloc(hdr.length + 1);
 
453
                if (val == NULL) {
 
454
                        x509_free_name(name);
 
455
                        return -1;
 
456
                }
 
457
                os_memcpy(val, hdr.payload, hdr.length);
 
458
                val[hdr.length] = '\0';
 
459
                if (os_strlen(val) != hdr.length) {
 
460
                        wpa_printf(MSG_INFO, "X509: Reject certificate with "
 
461
                                   "embedded NUL byte in a string (%s[NUL])",
 
462
                                   val);
 
463
                        x509_free_name(name);
 
464
                        return -1;
 
465
                }
 
466
 
 
467
                name->attr[name->num_attr].type = type;
 
468
                name->attr[name->num_attr].value = val;
 
469
                name->num_attr++;
434
470
        }
435
471
 
436
472
        return 0;
437
473
}
438
474
 
439
475
 
 
476
static char * x509_name_attr_str(enum x509_name_attr_type type)
 
477
{
 
478
        switch (type) {
 
479
        case X509_NAME_ATTR_NOT_USED:
 
480
                return "[N/A]";
 
481
        case X509_NAME_ATTR_DC:
 
482
                return "DC";
 
483
        case X509_NAME_ATTR_CN:
 
484
                return "CN";
 
485
        case X509_NAME_ATTR_C:
 
486
                return "C";
 
487
        case X509_NAME_ATTR_L:
 
488
                return "L";
 
489
        case X509_NAME_ATTR_ST:
 
490
                return "ST";
 
491
        case X509_NAME_ATTR_O:
 
492
                return "O";
 
493
        case X509_NAME_ATTR_OU:
 
494
                return "OU";
 
495
        }
 
496
        return "?";
 
497
}
 
498
 
 
499
 
440
500
/**
441
501
 * x509_name_string - Convert an X.509 certificate name into a string
442
502
 * @name: Name to convert
447
507
{
448
508
        char *pos, *end;
449
509
        int ret;
 
510
        size_t i;
450
511
 
451
512
        if (len == 0)
452
513
                return;
454
515
        pos = buf;
455
516
        end = buf + len;
456
517
 
457
 
        if (name->c) {
458
 
                ret = os_snprintf(pos, end - pos, "C=%s, ", name->c);
459
 
                if (ret < 0 || ret >= end - pos)
460
 
                        goto done;
461
 
                pos += ret;
462
 
        }
463
 
        if (name->st) {
464
 
                ret = os_snprintf(pos, end - pos, "ST=%s, ", name->st);
465
 
                if (ret < 0 || ret >= end - pos)
466
 
                        goto done;
467
 
                pos += ret;
468
 
        }
469
 
        if (name->l) {
470
 
                ret = os_snprintf(pos, end - pos, "L=%s, ", name->l);
471
 
                if (ret < 0 || ret >= end - pos)
472
 
                        goto done;
473
 
                pos += ret;
474
 
        }
475
 
        if (name->o) {
476
 
                ret = os_snprintf(pos, end - pos, "O=%s, ", name->o);
477
 
                if (ret < 0 || ret >= end - pos)
478
 
                        goto done;
479
 
                pos += ret;
480
 
        }
481
 
        if (name->ou) {
482
 
                ret = os_snprintf(pos, end - pos, "OU=%s, ", name->ou);
483
 
                if (ret < 0 || ret >= end - pos)
484
 
                        goto done;
485
 
                pos += ret;
486
 
        }
487
 
        if (name->cn) {
488
 
                ret = os_snprintf(pos, end - pos, "CN=%s, ", name->cn);
 
518
        for (i = 0; i < name->num_attr; i++) {
 
519
                ret = os_snprintf(pos, end - pos, "%s=%s, ",
 
520
                                  x509_name_attr_str(name->attr[i].type),
 
521
                                  name->attr[i].value);
489
522
                if (ret < 0 || ret >= end - pos)
490
523
                        goto done;
491
524
                pos += ret;
492
525
        }
493
526
 
494
527
        if (pos > buf + 1 && pos[-1] == ' ' && pos[-2] == ',') {
495
 
                *pos-- = '\0';
496
 
                *pos-- = '\0';
 
528
                pos--;
 
529
                *pos = '\0';
 
530
                pos--;
 
531
                *pos = '\0';
497
532
        }
498
533
 
499
534
        if (name->email) {
815
850
}
816
851
 
817
852
 
 
853
static int x509_parse_alt_name_rfc8222(struct x509_name *name,
 
854
                                       const u8 *pos, size_t len)
 
855
{
 
856
        /* rfc822Name IA5String */
 
857
        wpa_hexdump_ascii(MSG_MSGDUMP, "X509: altName - rfc822Name", pos, len);
 
858
        os_free(name->alt_email);
 
859
        name->alt_email = os_zalloc(len + 1);
 
860
        if (name->alt_email == NULL)
 
861
                return -1;
 
862
        os_memcpy(name->alt_email, pos, len);
 
863
        if (os_strlen(name->alt_email) != len) {
 
864
                wpa_printf(MSG_INFO, "X509: Reject certificate with "
 
865
                           "embedded NUL byte in rfc822Name (%s[NUL])",
 
866
                           name->alt_email);
 
867
                os_free(name->alt_email);
 
868
                name->alt_email = NULL;
 
869
                return -1;
 
870
        }
 
871
        return 0;
 
872
}
 
873
 
 
874
 
 
875
static int x509_parse_alt_name_dns(struct x509_name *name,
 
876
                                   const u8 *pos, size_t len)
 
877
{
 
878
        /* dNSName IA5String */
 
879
        wpa_hexdump_ascii(MSG_MSGDUMP, "X509: altName - dNSName", pos, len);
 
880
        os_free(name->dns);
 
881
        name->dns = os_zalloc(len + 1);
 
882
        if (name->dns == NULL)
 
883
                return -1;
 
884
        os_memcpy(name->dns, pos, len);
 
885
        if (os_strlen(name->dns) != len) {
 
886
                wpa_printf(MSG_INFO, "X509: Reject certificate with "
 
887
                           "embedded NUL byte in dNSName (%s[NUL])",
 
888
                           name->dns);
 
889
                os_free(name->dns);
 
890
                name->dns = NULL;
 
891
                return -1;
 
892
        }
 
893
        return 0;
 
894
}
 
895
 
 
896
 
 
897
static int x509_parse_alt_name_uri(struct x509_name *name,
 
898
                                   const u8 *pos, size_t len)
 
899
{
 
900
        /* uniformResourceIdentifier IA5String */
 
901
        wpa_hexdump_ascii(MSG_MSGDUMP,
 
902
                          "X509: altName - uniformResourceIdentifier",
 
903
                          pos, len);
 
904
        os_free(name->uri);
 
905
        name->uri = os_zalloc(len + 1);
 
906
        if (name->uri == NULL)
 
907
                return -1;
 
908
        os_memcpy(name->uri, pos, len);
 
909
        if (os_strlen(name->uri) != len) {
 
910
                wpa_printf(MSG_INFO, "X509: Reject certificate with "
 
911
                           "embedded NUL byte in uniformResourceIdentifier "
 
912
                           "(%s[NUL])", name->uri);
 
913
                os_free(name->uri);
 
914
                name->uri = NULL;
 
915
                return -1;
 
916
        }
 
917
        return 0;
 
918
}
 
919
 
 
920
 
 
921
static int x509_parse_alt_name_ip(struct x509_name *name,
 
922
                                       const u8 *pos, size_t len)
 
923
{
 
924
        /* iPAddress OCTET STRING */
 
925
        wpa_hexdump(MSG_MSGDUMP, "X509: altName - iPAddress", pos, len);
 
926
        os_free(name->ip);
 
927
        name->ip = os_malloc(len);
 
928
        if (name->ip == NULL)
 
929
                return -1;
 
930
        os_memcpy(name->ip, pos, len);
 
931
        name->ip_len = len;
 
932
        return 0;
 
933
}
 
934
 
 
935
 
 
936
static int x509_parse_alt_name_rid(struct x509_name *name,
 
937
                                   const u8 *pos, size_t len)
 
938
{
 
939
        char buf[80];
 
940
 
 
941
        /* registeredID OBJECT IDENTIFIER */
 
942
        if (asn1_parse_oid(pos, len, &name->rid) < 0)
 
943
                return -1;
 
944
 
 
945
        asn1_oid_to_str(&name->rid, buf, sizeof(buf));
 
946
        wpa_printf(MSG_MSGDUMP, "X509: altName - registeredID: %s", buf);
 
947
 
 
948
        return 0;
 
949
}
 
950
 
 
951
 
 
952
static int x509_parse_ext_alt_name(struct x509_name *name,
 
953
                                   const u8 *pos, size_t len)
 
954
{
 
955
        struct asn1_hdr hdr;
 
956
        const u8 *p, *end;
 
957
 
 
958
        /*
 
959
         * GeneralNames ::= SEQUENCE SIZE (1..MAX) OF GeneralName
 
960
         *
 
961
         * GeneralName ::= CHOICE {
 
962
         *     otherName                       [0]     OtherName,
 
963
         *     rfc822Name                      [1]     IA5String,
 
964
         *     dNSName                         [2]     IA5String,
 
965
         *     x400Address                     [3]     ORAddress,
 
966
         *     directoryName                   [4]     Name,
 
967
         *     ediPartyName                    [5]     EDIPartyName,
 
968
         *     uniformResourceIdentifier       [6]     IA5String,
 
969
         *     iPAddress                       [7]     OCTET STRING,
 
970
         *     registeredID                    [8]     OBJECT IDENTIFIER }
 
971
         *
 
972
         * OtherName ::= SEQUENCE {
 
973
         *     type-id    OBJECT IDENTIFIER,
 
974
         *     value      [0] EXPLICIT ANY DEFINED BY type-id }
 
975
         *
 
976
         * EDIPartyName ::= SEQUENCE {
 
977
         *     nameAssigner            [0]     DirectoryString OPTIONAL,
 
978
         *     partyName               [1]     DirectoryString }
 
979
         */
 
980
 
 
981
        for (p = pos, end = pos + len; p < end; p = hdr.payload + hdr.length) {
 
982
                int res;
 
983
 
 
984
                if (asn1_get_next(p, end - p, &hdr) < 0) {
 
985
                        wpa_printf(MSG_DEBUG, "X509: Failed to parse "
 
986
                                   "SubjectAltName item");
 
987
                        return -1;
 
988
                }
 
989
 
 
990
                if (hdr.class != ASN1_CLASS_CONTEXT_SPECIFIC)
 
991
                        continue;
 
992
 
 
993
                switch (hdr.tag) {
 
994
                case 1:
 
995
                        res = x509_parse_alt_name_rfc8222(name, hdr.payload,
 
996
                                                          hdr.length);
 
997
                        break;
 
998
                case 2:
 
999
                        res = x509_parse_alt_name_dns(name, hdr.payload,
 
1000
                                                      hdr.length);
 
1001
                        break;
 
1002
                case 6:
 
1003
                        res = x509_parse_alt_name_uri(name, hdr.payload,
 
1004
                                                      hdr.length);
 
1005
                        break;
 
1006
                case 7:
 
1007
                        res = x509_parse_alt_name_ip(name, hdr.payload,
 
1008
                                                     hdr.length);
 
1009
                        break;
 
1010
                case 8:
 
1011
                        res = x509_parse_alt_name_rid(name, hdr.payload,
 
1012
                                                      hdr.length);
 
1013
                        break;
 
1014
                case 0: /* TODO: otherName */
 
1015
                case 3: /* TODO: x500Address */
 
1016
                case 4: /* TODO: directoryName */
 
1017
                case 5: /* TODO: ediPartyName */
 
1018
                default:
 
1019
                        res = 0;
 
1020
                        break;
 
1021
                }
 
1022
                if (res < 0)
 
1023
                        return res;
 
1024
        }
 
1025
 
 
1026
        return 0;
 
1027
}
 
1028
 
 
1029
 
 
1030
static int x509_parse_ext_subject_alt_name(struct x509_certificate *cert,
 
1031
                                           const u8 *pos, size_t len)
 
1032
{
 
1033
        struct asn1_hdr hdr;
 
1034
 
 
1035
        /* SubjectAltName ::= GeneralNames */
 
1036
 
 
1037
        if (asn1_get_next(pos, len, &hdr) < 0 ||
 
1038
            hdr.class != ASN1_CLASS_UNIVERSAL ||
 
1039
            hdr.tag != ASN1_TAG_SEQUENCE) {
 
1040
                wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE in "
 
1041
                           "SubjectAltName; found %d tag 0x%x",
 
1042
                           hdr.class, hdr.tag);
 
1043
                return -1;
 
1044
        }
 
1045
 
 
1046
        wpa_printf(MSG_DEBUG, "X509: SubjectAltName");
 
1047
        cert->extensions_present |= X509_EXT_SUBJECT_ALT_NAME;
 
1048
 
 
1049
        if (hdr.length == 0)
 
1050
                return 0;
 
1051
 
 
1052
        return x509_parse_ext_alt_name(&cert->subject, hdr.payload,
 
1053
                                       hdr.length);
 
1054
}
 
1055
 
 
1056
 
 
1057
static int x509_parse_ext_issuer_alt_name(struct x509_certificate *cert,
 
1058
                                          const u8 *pos, size_t len)
 
1059
{
 
1060
        struct asn1_hdr hdr;
 
1061
 
 
1062
        /* IssuerAltName ::= GeneralNames */
 
1063
 
 
1064
        if (asn1_get_next(pos, len, &hdr) < 0 ||
 
1065
            hdr.class != ASN1_CLASS_UNIVERSAL ||
 
1066
            hdr.tag != ASN1_TAG_SEQUENCE) {
 
1067
                wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE in "
 
1068
                           "IssuerAltName; found %d tag 0x%x",
 
1069
                           hdr.class, hdr.tag);
 
1070
                return -1;
 
1071
        }
 
1072
 
 
1073
        wpa_printf(MSG_DEBUG, "X509: IssuerAltName");
 
1074
        cert->extensions_present |= X509_EXT_ISSUER_ALT_NAME;
 
1075
 
 
1076
        if (hdr.length == 0)
 
1077
                return 0;
 
1078
 
 
1079
        return x509_parse_ext_alt_name(&cert->issuer, hdr.payload,
 
1080
                                       hdr.length);
 
1081
}
 
1082
 
 
1083
 
818
1084
static int x509_parse_extension_data(struct x509_certificate *cert,
819
1085
                                     struct asn1_oid *oid,
820
1086
                                     const u8 *pos, size_t len)
824
1090
 
825
1091
        /* TODO: add other extensions required by RFC 3280, Ch 4.2:
826
1092
         * certificate policies (section 4.2.1.5)
827
 
         * the subject alternative name (section 4.2.1.7)
828
1093
         * name constraints (section 4.2.1.11)
829
1094
         * policy constraints (section 4.2.1.12)
830
1095
         * extended key usage (section 4.2.1.13)
833
1098
        switch (oid->oid[3]) {
834
1099
        case 15: /* id-ce-keyUsage */
835
1100
                return x509_parse_ext_key_usage(cert, pos, len);
 
1101
        case 17: /* id-ce-subjectAltName */
 
1102
                return x509_parse_ext_subject_alt_name(cert, pos, len);
 
1103
        case 18: /* id-ce-issuerAltName */
 
1104
                return x509_parse_ext_issuer_alt_name(cert, pos, len);
836
1105
        case 19: /* id-ce-basicConstraints */
837
1106
                return x509_parse_ext_basic_constraints(cert, pos, len);
838
1107
        default:
1495
1764
                            hash, hash_len);
1496
1765
                break;
1497
1766
        case 11: /* sha256WithRSAEncryption */
1498
 
#ifdef NEED_SHA256
1499
1767
                sha256_vector(1, &cert->tbs_cert_start, &cert->tbs_cert_len,
1500
1768
                              hash);
1501
1769
                hash_len = 32;
1502
1770
                wpa_hexdump(MSG_MSGDUMP, "X509: Certificate hash (SHA256)",
1503
1771
                            hash, hash_len);
1504
1772
                break;
1505
 
#else /* NEED_SHA256 */
1506
 
                wpa_printf(MSG_INFO, "X509: SHA256 support disabled");
1507
 
                os_free(data);
1508
 
                return -1;
1509
 
#endif /* NEED_SHA256 */
1510
1773
        case 2: /* md2WithRSAEncryption */
1511
1774
        case 12: /* sha384WithRSAEncryption */
1512
1775
        case 13: /* sha512WithRSAEncryption */
1720
1983
{
1721
1984
        return x509_name_compare(&cert->issuer, &cert->subject) == 0;
1722
1985
}
1723
 
 
1724
 
#endif /* CONFIG_INTERNAL_X509 */