contrib/hostapd/src/tls/x509v3.c

   1 /*
   2  * X.509v3 certificate parsing and processing (RFC 3280 profile)
   3  * Copyright (c) 2006-2007, Jouni Malinen <j@w1.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  */
  14
  15 #include "includes.h"
  16
  17 #include "common.h"
  18
  19 #ifdef CONFIG_INTERNAL_X509
  20
  21 #include "asn1.h"
  22 #include "crypto.h"
  23 #include "x509v3.h"
  24
  25
  26 static void x509_free_name(struct x509_name *name)
  27 {
  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);
  34         os_free(name->email);
  35         name->cn = name->c = name->l = name->st = name->o = name->ou = NULL;
  36         name->email = NULL;
  37 }
  38
  39
  40 /**
  41  * x509_certificate_free - Free an X.509 certificate
  42  * @cert: Certificate to be freed
  43  */
  44 void x509_certificate_free(struct x509_certificate *cert)
  45 {
  46         if (cert == NULL)
  47                 return;
  48         if (cert->next) {
  49                 wpa_printf(MSG_DEBUG, "X509: x509_certificate_free: cer=%p "
  50                            "was still on a list (next=%p)\n",
  51                            cert, cert->next);
  52         }
  53         x509_free_name(&cert->issuer);
  54         x509_free_name(&cert->subject);
  55         os_free(cert->public_key);
  56         os_free(cert->sign_value);
  57         os_free(cert);
  58 }
  59
  60
  61 /**
  62  * x509_certificate_free - Free an X.509 certificate chain
  63  * @cert: Pointer to the first certificate in the chain
  64  */
  65 void x509_certificate_chain_free(struct x509_certificate *cert)
  66 {
  67         struct x509_certificate *next;
  68
  69         while (cert) {
  70                 next = cert->next;
  71                 cert->next = NULL;
  72                 x509_certificate_free(cert);
  73                 cert = next;
  74         }
  75 }
  76
  77
  78 static int x509_whitespace(char c)
  79 {
  80         return c == ' ' || c == '\t';
  81 }
  82
  83
  84 static void x509_str_strip_whitespace(char *a)
  85 {
  86         char *ipos, *opos;
  87         int remove_whitespace = 1;
  88
  89         ipos = opos = a;
  90
  91         while (*ipos) {
  92                 if (remove_whitespace && x509_whitespace(*ipos))
  93                         ipos++;
  94                 else {
  95                         remove_whitespace = x509_whitespace(*ipos);
  96                         *opos++ = *ipos++;
  97                 }
  98         }
  99
 100         *opos-- = '\0';
 101         if (opos > a && x509_whitespace(*opos))
 102                 *opos = '\0';
 103 }
 104
 105
 106 static int x509_str_compare(const char *a, const char *b)
 107 {
 108         char *aa, *bb;
 109         int ret;
 110
 111         if (!a && b)
 112                 return -1;
 113         if (a && !b)
 114                 return 1;
 115         if (!a && !b)
 116                 return 0;
 117
 118         aa = os_strdup(a);
 119         bb = os_strdup(b);
 120
 121         if (aa == NULL || bb == NULL) {
 122                 os_free(aa);
 123                 os_free(bb);
 124                 return os_strcasecmp(a, b);
 125         }
 126
 127         x509_str_strip_whitespace(aa);
 128         x509_str_strip_whitespace(bb);
 129
 130         ret = os_strcasecmp(aa, bb);
 131
 132         os_free(aa);
 133         os_free(bb);
 134
 135         return ret;
 136 }
 137
 138
 139 /**
 140  * x509_name_compare - Compare X.509 certificate names
 141  * @a: Certificate name
 142  * @b: Certificate name
 143  * Returns: <0, 0, or >0 based on whether a is less than, equal to, or
 144  * greater than b
 145  */
 146 int x509_name_compare(struct x509_name *a, struct x509_name *b)
 147 {
 148         int res;
 149
 150         if (!a && b)
 151                 return -1;
 152         if (a && !b)
 153                 return 1;
 154         if (!a && !b)
 155                 return 0;
 156
 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;
 175         res = x509_str_compare(a->email, b->email);
 176         if (res)
 177                 return res;
 178
 179         return 0;
 180 }
 181
 182
 183 static int x509_parse_algorithm_identifier(
 184         const u8 *buf, size_t len,
 185         struct x509_algorithm_identifier *id, const u8 **next)
 186 {
 187         struct asn1_hdr hdr;
 188         const u8 *pos, *end;
 189
 190         /*
 191          * AlgorithmIdentifier ::= SEQUENCE {
 192          *     algorithm            OBJECT IDENTIFIER,
 193          *     parameters           ANY DEFINED BY algorithm OPTIONAL
 194          * }
 195          */
 196
 197         if (asn1_get_next(buf, len, &hdr) < 0 ||
 198             hdr.class != ASN1_CLASS_UNIVERSAL ||
 199             hdr.tag != ASN1_TAG_SEQUENCE) {
 200                 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE "
 201                            "(AlgorithmIdentifier) - found class %d tag 0x%x",
 202                            hdr.class, hdr.tag);
 203                 return -1;
 204         }
 205         pos = hdr.payload;
 206         end = pos + hdr.length;
 207
 208         if (end > buf + len)
 209                 return -1;
 210
 211         *next = end;
 212
 213         if (asn1_get_oid(pos, end - pos, &id->oid, &pos))
 214                 return -1;
 215
 216         /* TODO: optional parameters */
 217
 218         return 0;
 219 }
 220
 221
 222 static int x509_parse_public_key(const u8 *buf, size_t len,
 223                                  struct x509_certificate *cert,
 224                                  const u8 **next)
 225 {
 226         struct asn1_hdr hdr;
 227         const u8 *pos, *end;
 228
 229         /*
 230          * SubjectPublicKeyInfo ::= SEQUENCE {
 231          *     algorithm            AlgorithmIdentifier,
 232          *     subjectPublicKey     BIT STRING
 233          * }
 234          */
 235
 236         pos = buf;
 237         end = buf + len;
 238
 239         if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
 240             hdr.class != ASN1_CLASS_UNIVERSAL ||
 241             hdr.tag != ASN1_TAG_SEQUENCE) {
 242                 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE "
 243                            "(SubjectPublicKeyInfo) - found class %d tag 0x%x",
 244                            hdr.class, hdr.tag);
 245                 return -1;
 246         }
 247         pos = hdr.payload;
 248
 249         if (pos + hdr.length > end)
 250                 return -1;
 251         end = pos + hdr.length;
 252         *next = end;
 253
 254         if (x509_parse_algorithm_identifier(pos, end - pos,
 255                                             &cert->public_key_alg, &pos))
 256                 return -1;
 257
 258         if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
 259             hdr.class != ASN1_CLASS_UNIVERSAL ||
 260             hdr.tag != ASN1_TAG_BITSTRING) {
 261                 wpa_printf(MSG_DEBUG, "X509: Expected BITSTRING "
 262                            "(subjectPublicKey) - found class %d tag 0x%x",
 263                            hdr.class, hdr.tag);
 264                 return -1;
 265         }
 266         if (hdr.length < 1)
 267                 return -1;
 268         pos = hdr.payload;
 269         if (*pos) {
 270                 wpa_printf(MSG_DEBUG, "X509: BITSTRING - %d unused bits",
 271                            *pos);
 272                 /*
 273                  * TODO: should this be rejected? X.509 certificates are
 274                  * unlikely to use such a construction. Now we would end up
 275                  * including the extra bits in the buffer which may also be
 276                  * ok.
 277                  */
 278         }
 279         os_free(cert->public_key);
 280         cert->public_key = os_malloc(hdr.length - 1);
 281         if (cert->public_key == NULL) {
 282                 wpa_printf(MSG_DEBUG, "X509: Failed to allocate memory for "
 283                            "public key");
 284                 return -1;
 285         }
 286         os_memcpy(cert->public_key, pos + 1, hdr.length - 1);
 287         cert->public_key_len = hdr.length - 1;
 288         wpa_hexdump(MSG_MSGDUMP, "X509: subjectPublicKey",
 289                     cert->public_key, cert->public_key_len);
 290
 291         return 0;
 292 }
 293
 294
 295 static int x509_parse_name(const u8 *buf, size_t len, struct x509_name *name,
 296                            const u8 **next)
 297 {
 298         struct asn1_hdr hdr;
 299         const u8 *pos, *end, *set_pos, *set_end, *seq_pos, *seq_end;
 300         struct asn1_oid oid;
 301         char **fieldp;
 302
 303         /*
 304          * Name ::= CHOICE { RDNSequence }
 305          * RDNSequence ::= SEQUENCE OF RelativeDistinguishedName
 306          * RelativeDistinguishedName ::= SET OF AttributeTypeAndValue
 307          * AttributeTypeAndValue ::= SEQUENCE {
 308          *     type     AttributeType,
 309          *     value    AttributeValue
 310          * }
 311          * AttributeType ::= OBJECT IDENTIFIER
 312          * AttributeValue ::= ANY DEFINED BY AttributeType
 313          */
 314
 315         if (asn1_get_next(buf, len, &hdr) < 0 ||
 316             hdr.class != ASN1_CLASS_UNIVERSAL ||
 317             hdr.tag != ASN1_TAG_SEQUENCE) {
 318                 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE "
 319                            "(Name / RDNSequencer) - found class %d tag 0x%x",
 320                            hdr.class, hdr.tag);
 321                 return -1;
 322         }
 323         pos = hdr.payload;
 324
 325         if (pos + hdr.length > buf + len)
 326                 return -1;
 327
 328         end = *next = pos + hdr.length;
 329
 330         while (pos < end) {
 331                 if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
 332                     hdr.class != ASN1_CLASS_UNIVERSAL ||
 333                     hdr.tag != ASN1_TAG_SET) {
 334                         wpa_printf(MSG_DEBUG, "X509: Expected SET "
 335                                    "(RelativeDistinguishedName) - found class "
 336                                    "%d tag 0x%x", hdr.class, hdr.tag);
 337                         x509_free_name(name);
 338                         return -1;
 339                 }
 340
 341                 set_pos = hdr.payload;
 342                 pos = set_end = hdr.payload + hdr.length;
 343
 344                 if (asn1_get_next(set_pos, set_end - set_pos, &hdr) < 0 ||
 345                     hdr.class != ASN1_CLASS_UNIVERSAL ||
 346                     hdr.tag != ASN1_TAG_SEQUENCE) {
 347                         wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE "
 348                                    "(AttributeTypeAndValue) - found class %d "
 349                                    "tag 0x%x", hdr.class, hdr.tag);
 350                         x509_free_name(name);
 351                         return -1;
 352                 }
 353
 354                 seq_pos = hdr.payload;
 355                 seq_end = hdr.payload + hdr.length;
 356
 357                 if (asn1_get_oid(seq_pos, seq_end - seq_pos, &oid, &seq_pos)) {
 358                         x509_free_name(name);
 359                         return -1;
 360                 }
 361
 362                 if (asn1_get_next(seq_pos, seq_end - seq_pos, &hdr) < 0 ||
 363                     hdr.class != ASN1_CLASS_UNIVERSAL) {
 364                         wpa_printf(MSG_DEBUG, "X509: Failed to parse "
 365                                    "AttributeValue");
 366                         x509_free_name(name);
 367                         return -1;
 368                 }
 369
 370                 /* RFC 3280:
 371                  * MUST: country, organization, organizational-unit,
 372                  * distinguished name qualifier, state or province name,
 373                  * common name, serial number.
 374                  * SHOULD: locality, title, surname, given name, initials,
 375                  * pseudonym, generation qualifier.
 376                  * MUST: domainComponent (RFC 2247).
 377                  */
 378                 fieldp = NULL;
 379                 if (oid.len == 4 &&
 380                     oid.oid[0] == 2 && oid.oid[1] == 5 && oid.oid[2] == 4) {
 381                         /* id-at ::= 2.5.4 */
 382                         switch (oid.oid[3]) {
 383                         case 3:
 384                                 /* commonName */
 385                                 fieldp = &name->cn;
 386                                 break;
 387                         case 6:
 388                                 /*  countryName */
 389                                 fieldp = &name->c;
 390                                 break;
 391                         case 7:
 392                                 /* localityName */
 393                                 fieldp = &name->l;
 394                                 break;
 395                         case 8:
 396                                 /* stateOrProvinceName */
 397                                 fieldp = &name->st;
 398                                 break;
 399                         case 10:
 400                                 /* organizationName */
 401                                 fieldp = &name->o;
 402                                 break;
 403                         case 11:
 404                                 /* organizationalUnitName */
 405                                 fieldp = &name->ou;
 406                                 break;
 407                         }
 408                 } else if (oid.len == 7 &&
 409                            oid.oid[0] == 1 && oid.oid[1] == 2 &&
 410                            oid.oid[2] == 840 && oid.oid[3] == 113549 &&
 411                            oid.oid[4] == 1 && oid.oid[5] == 9 &&
 412                            oid.oid[6] == 1) {
 413                         /* 1.2.840.113549.1.9.1 - e-mailAddress */
 414                         fieldp = &name->email;
 415                 }
 416
 417                 if (fieldp == NULL) {
 418                         wpa_hexdump(MSG_DEBUG, "X509: Unrecognized OID",
 419                                     (u8 *) oid.oid,
 420                                     oid.len * sizeof(oid.oid[0]));
 421                         wpa_hexdump_ascii(MSG_MSGDUMP, "X509: Attribute Data",
 422                                           hdr.payload, hdr.length);
 423                         continue;
 424                 }
 425
 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';
 434         }
 435
 436         return 0;
 437 }
 438
 439
 440 /**
 441  * x509_name_string - Convert an X.509 certificate name into a string
 442  * @name: Name to convert
 443  * @buf: Buffer for the string
 444  * @len: Maximum buffer length
 445  */
 446 void x509_name_string(struct x509_name *name, char *buf, size_t len)
 447 {
 448         char *pos, *end;
 449         int ret;
 450
 451         if (len == 0)
 452                 return;
 453
 454         pos = buf;
 455         end = buf + len;
 456
 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);
 489                 if (ret < 0 || ret >= end - pos)
 490                         goto done;
 491                 pos += ret;
 492         }
 493
 494         if (pos > buf + 1 && pos[-1] == ' ' && pos[-2] == ',') {
 495                 *pos-- = '\0';
 496                 *pos-- = '\0';
 497         }
 498
 499         if (name->email) {
 500                 ret = os_snprintf(pos, end - pos, "/emailAddress=%s",
 501                                   name->email);
 502                 if (ret < 0 || ret >= end - pos)
 503                         goto done;
 504                 pos += ret;
 505         }
 506
 507 done:
 508         end[-1] = '\0';
 509 }
 510
 511
 512 static int x509_parse_time(const u8 *buf, size_t len, u8 asn1_tag,
 513                            os_time_t *val)
 514 {
 515         const char *pos;
 516         int year, month, day, hour, min, sec;
 517
 518         /*
 519          * Time ::= CHOICE {
 520          *     utcTime        UTCTime,
 521          *     generalTime    GeneralizedTime
 522          * }
 523          *
 524          * UTCTime: YYMMDDHHMMSSZ
 525          * GeneralizedTime: YYYYMMDDHHMMSSZ
 526          */
 527
 528         pos = (const char *) buf;
 529
 530         switch (asn1_tag) {
 531         case ASN1_TAG_UTCTIME:
 532                 if (len != 13 || buf[12] != 'Z') {
 533                         wpa_hexdump_ascii(MSG_DEBUG, "X509: Unrecognized "
 534                                           "UTCTime format", buf, len);
 535                         return -1;
 536                 }
 537                 if (sscanf(pos, "%02d", &year) != 1) {
 538                         wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse "
 539                                           "UTCTime year", buf, len);
 540                         return -1;
 541                 }
 542                 if (year < 50)
 543                         year += 2000;
 544                 else
 545                         year += 1900;
 546                 pos += 2;
 547                 break;
 548         case ASN1_TAG_GENERALIZEDTIME:
 549                 if (len != 15 || buf[14] != 'Z') {
 550                         wpa_hexdump_ascii(MSG_DEBUG, "X509: Unrecognized "
 551                                           "GeneralizedTime format", buf, len);
 552                         return -1;
 553                 }
 554                 if (sscanf(pos, "%04d", &year) != 1) {
 555                         wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse "
 556                                           "GeneralizedTime year", buf, len);
 557                         return -1;
 558                 }
 559                 pos += 4;
 560                 break;
 561         default:
 562                 wpa_printf(MSG_DEBUG, "X509: Expected UTCTime or "
 563                            "GeneralizedTime - found tag 0x%x", asn1_tag);
 564                 return -1;
 565         }
 566
 567         if (sscanf(pos, "%02d", &month) != 1) {
 568                 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse Time "
 569                                   "(month)", buf, len);
 570                 return -1;
 571         }
 572         pos += 2;
 573
 574         if (sscanf(pos, "%02d", &day) != 1) {
 575                 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse Time "
 576                                   "(day)", buf, len);
 577                 return -1;
 578         }
 579         pos += 2;
 580
 581         if (sscanf(pos, "%02d", &hour) != 1) {
 582                 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse Time "
 583                                   "(hour)", buf, len);
 584                 return -1;
 585         }
 586         pos += 2;
 587
 588         if (sscanf(pos, "%02d", &min) != 1) {
 589                 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse Time "
 590                                   "(min)", buf, len);
 591                 return -1;
 592         }
 593         pos += 2;
 594
 595         if (sscanf(pos, "%02d", &sec) != 1) {
 596                 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse Time "
 597                                   "(sec)", buf, len);
 598                 return -1;
 599         }
 600
 601         if (os_mktime(year, month, day, hour, min, sec, val) < 0) {
 602                 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to convert Time",
 603                                   buf, len);
 604                 if (year < 1970) {
 605                         /*
 606                          * At least some test certificates have been configured
 607                          * to use dates prior to 1970. Set the date to
 608                          * beginning of 1970 to handle these case.
 609                          */
 610                         wpa_printf(MSG_DEBUG, "X509: Year=%d before epoch - "
 611                                    "assume epoch as the time", year);
 612                         *val = 0;
 613                         return 0;
 614                 }
 615                 return -1;
 616         }
 617
 618         return 0;
 619 }
 620
 621
 622 static int x509_parse_validity(const u8 *buf, size_t len,
 623                                struct x509_certificate *cert, const u8 **next)
 624 {
 625         struct asn1_hdr hdr;
 626         const u8 *pos;
 627         size_t plen;
 628
 629         /*
 630          * Validity ::= SEQUENCE {
 631          *     notBefore      Time,
 632          *     notAfter       Time
 633          * }
 634          *
 635          * RFC 3280, 4.1.2.5:
 636          * CAs conforming to this profile MUST always encode certificate
 637          * validity dates through the year 2049 as UTCTime; certificate
 638          * validity dates in 2050 or later MUST be encoded as GeneralizedTime.
 639          */
 640
 641         if (asn1_get_next(buf, len, &hdr) < 0 ||
 642             hdr.class != ASN1_CLASS_UNIVERSAL ||
 643             hdr.tag != ASN1_TAG_SEQUENCE) {
 644                 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE "
 645                            "(Validity) - found class %d tag 0x%x",
 646                            hdr.class, hdr.tag);
 647                 return -1;
 648         }
 649         pos = hdr.payload;
 650         plen = hdr.length;
 651
 652         if (pos + plen > buf + len)
 653                 return -1;
 654
 655         *next = pos + plen;
 656
 657         if (asn1_get_next(pos, plen, &hdr) < 0 ||
 658             hdr.class != ASN1_CLASS_UNIVERSAL ||
 659             x509_parse_time(hdr.payload, hdr.length, hdr.tag,
 660                             &cert->not_before) < 0) {
 661                 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse notBefore "
 662                                   "Time", hdr.payload, hdr.length);
 663                 return -1;
 664         }
 665
 666         pos = hdr.payload + hdr.length;
 667         plen = *next - pos;
 668
 669         if (asn1_get_next(pos, plen, &hdr) < 0 ||
 670             hdr.class != ASN1_CLASS_UNIVERSAL ||
 671             x509_parse_time(hdr.payload, hdr.length, hdr.tag,
 672                             &cert->not_after) < 0) {
 673                 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse notAfter "
 674                                   "Time", hdr.payload, hdr.length);
 675                 return -1;
 676         }
 677
 678         wpa_printf(MSG_MSGDUMP, "X509: Validity: notBefore: %lu notAfter: %lu",
 679                    (unsigned long) cert->not_before,
 680                    (unsigned long) cert->not_after);
 681
 682         return 0;
 683 }
 684
 685
 686 static int x509_id_ce_oid(struct asn1_oid *oid)
 687 {
 688         /* id-ce arc from X.509 for standard X.509v3 extensions */
 689         return oid->len >= 4 &&
 690                 oid->oid[0] == 2 /* joint-iso-ccitt */ &&
 691                 oid->oid[1] == 5 /* ds */ &&
 692                 oid->oid[2] == 29 /* id-ce */;
 693 }
 694
 695
 696 static int x509_parse_ext_key_usage(struct x509_certificate *cert,
 697                                     const u8 *pos, size_t len)
 698 {
 699         struct asn1_hdr hdr;
 700
 701         /*
 702          * KeyUsage ::= BIT STRING {
 703          *     digitalSignature        (0),
 704          *     nonRepudiation          (1),
 705          *     keyEncipherment         (2),
 706          *     dataEncipherment        (3),
 707          *     keyAgreement            (4),
 708          *     keyCertSign             (5),
 709          *     cRLSign                 (6),
 710          *     encipherOnly            (7),
 711          *     decipherOnly            (8) }
 712          */
 713
 714         if (asn1_get_next(pos, len, &hdr) < 0 ||
 715             hdr.class != ASN1_CLASS_UNIVERSAL ||
 716             hdr.tag != ASN1_TAG_BITSTRING ||
 717             hdr.length < 1) {
 718                 wpa_printf(MSG_DEBUG, "X509: Expected BIT STRING in "
 719                            "KeyUsage; found %d tag 0x%x len %d",
 720                            hdr.class, hdr.tag, hdr.length);
 721                 return -1;
 722         }
 723
 724         cert->extensions_present |= X509_EXT_KEY_USAGE;
 725         cert->key_usage = asn1_bit_string_to_long(hdr.payload, hdr.length);
 726
 727         wpa_printf(MSG_DEBUG, "X509: KeyUsage 0x%lx", cert->key_usage);
 728
 729         return 0;
 730 }
 731
 732
 733 static int x509_parse_ext_basic_constraints(struct x509_certificate *cert,
 734                                             const u8 *pos, size_t len)
 735 {
 736         struct asn1_hdr hdr;
 737         unsigned long value;
 738         size_t left;
 739
 740         /*
 741          * BasicConstraints ::= SEQUENCE {
 742          * cA                      BOOLEAN DEFAULT FALSE,
 743          * pathLenConstraint       INTEGER (0..MAX) OPTIONAL }
 744          */
 745
 746         if (asn1_get_next(pos, len, &hdr) < 0 ||
 747             hdr.class != ASN1_CLASS_UNIVERSAL ||
 748             hdr.tag != ASN1_TAG_SEQUENCE) {
 749                 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE in "
 750                            "BasicConstraints; found %d tag 0x%x",
 751                            hdr.class, hdr.tag);
 752                 return -1;
 753         }
 754
 755         cert->extensions_present |= X509_EXT_BASIC_CONSTRAINTS;
 756
 757         if (hdr.length == 0)
 758                 return 0;
 759
 760         if (asn1_get_next(hdr.payload, hdr.length, &hdr) < 0 ||
 761             hdr.class != ASN1_CLASS_UNIVERSAL) {
 762                 wpa_printf(MSG_DEBUG, "X509: Failed to parse "
 763                            "BasicConstraints");
 764                 return -1;
 765         }
 766
 767         if (hdr.tag == ASN1_TAG_BOOLEAN) {
 768                 if (hdr.length != 1) {
 769                         wpa_printf(MSG_DEBUG, "X509: Unexpected "
 770                                    "Boolean length (%u) in BasicConstraints",
 771                                    hdr.length);
 772                         return -1;
 773                 }
 774                 cert->ca = hdr.payload[0];
 775
 776                 if (hdr.payload + hdr.length == pos + len) {
 777                         wpa_printf(MSG_DEBUG, "X509: BasicConstraints - cA=%d",
 778                                    cert->ca);
 779                         return 0;
 780                 }
 781
 782                 if (asn1_get_next(hdr.payload + hdr.length, len - hdr.length,
 783                                   &hdr) < 0 ||
 784                     hdr.class != ASN1_CLASS_UNIVERSAL) {
 785                         wpa_printf(MSG_DEBUG, "X509: Failed to parse "
 786                                    "BasicConstraints");
 787                         return -1;
 788                 }
 789         }
 790
 791         if (hdr.tag != ASN1_TAG_INTEGER) {
 792                 wpa_printf(MSG_DEBUG, "X509: Expected INTEGER in "
 793                            "BasicConstraints; found class %d tag 0x%x",
 794                            hdr.class, hdr.tag);
 795                 return -1;
 796         }
 797
 798         pos = hdr.payload;
 799         left = hdr.length;
 800         value = 0;
 801         while (left) {
 802                 value <<= 8;
 803                 value |= *pos++;
 804                 left--;
 805         }
 806
 807         cert->path_len_constraint = value;
 808         cert->extensions_present |= X509_EXT_PATH_LEN_CONSTRAINT;
 809
 810         wpa_printf(MSG_DEBUG, "X509: BasicConstraints - cA=%d "
 811                    "pathLenConstraint=%lu",
 812                    cert->ca, cert->path_len_constraint);
 813
 814         return 0;
 815 }
 816
 817
 818 static int x509_parse_extension_data(struct x509_certificate *cert,
 819                                      struct asn1_oid *oid,
 820                                      const u8 *pos, size_t len)
 821 {
 822         if (!x509_id_ce_oid(oid))
 823                 return 1;
 824
 825         /* TODO: add other extensions required by RFC 3280, Ch 4.2:
 826          * certificate policies (section 4.2.1.5)
 827          * the subject alternative name (section 4.2.1.7)
 828          * name constraints (section 4.2.1.11)
 829          * policy constraints (section 4.2.1.12)
 830          * extended key usage (section 4.2.1.13)
 831          * inhibit any-policy (section 4.2.1.15)
 832          */
 833         switch (oid->oid[3]) {
 834         case 15: /* id-ce-keyUsage */
 835                 return x509_parse_ext_key_usage(cert, pos, len);
 836         case 19: /* id-ce-basicConstraints */
 837                 return x509_parse_ext_basic_constraints(cert, pos, len);
 838         default:
 839                 return 1;
 840         }
 841 }
 842
 843
 844 static int x509_parse_extension(struct x509_certificate *cert,
 845                                 const u8 *pos, size_t len, const u8 **next)
 846 {
 847         const u8 *end;
 848         struct asn1_hdr hdr;
 849         struct asn1_oid oid;
 850         int critical_ext = 0, res;
 851         char buf[80];
 852
 853         /*
 854          * Extension  ::=  SEQUENCE  {
 855          *     extnID      OBJECT IDENTIFIER,
 856          *     critical    BOOLEAN DEFAULT FALSE,
 857          *     extnValue   OCTET STRING
 858          * }
 859          */
 860
 861         if (asn1_get_next(pos, len, &hdr) < 0 ||
 862             hdr.class != ASN1_CLASS_UNIVERSAL ||
 863             hdr.tag != ASN1_TAG_SEQUENCE) {
 864                 wpa_printf(MSG_DEBUG, "X509: Unexpected ASN.1 header in "
 865                            "Extensions: class %d tag 0x%x; expected SEQUENCE",
 866                            hdr.class, hdr.tag);
 867                 return -1;
 868         }
 869         pos = hdr.payload;
 870         *next = end = pos + hdr.length;
 871
 872         if (asn1_get_oid(pos, end - pos, &oid, &pos) < 0) {
 873                 wpa_printf(MSG_DEBUG, "X509: Unexpected ASN.1 data for "
 874                            "Extension (expected OID)");
 875                 return -1;
 876         }
 877
 878         if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
 879             hdr.class != ASN1_CLASS_UNIVERSAL ||
 880             (hdr.tag != ASN1_TAG_BOOLEAN &&
 881              hdr.tag != ASN1_TAG_OCTETSTRING)) {
 882                 wpa_printf(MSG_DEBUG, "X509: Unexpected ASN.1 header in "
 883                            "Extensions: class %d tag 0x%x; expected BOOLEAN "
 884                            "or OCTET STRING", hdr.class, hdr.tag);
 885                 return -1;
 886         }
 887
 888         if (hdr.tag == ASN1_TAG_BOOLEAN) {
 889                 if (hdr.length != 1) {
 890                         wpa_printf(MSG_DEBUG, "X509: Unexpected "
 891                                    "Boolean length (%u)", hdr.length);
 892                         return -1;
 893                 }
 894                 critical_ext = hdr.payload[0];
 895                 pos = hdr.payload;
 896                 if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
 897                     (hdr.class != ASN1_CLASS_UNIVERSAL &&
 898                      hdr.class != ASN1_CLASS_PRIVATE) ||
 899                     hdr.tag != ASN1_TAG_OCTETSTRING) {
 900                         wpa_printf(MSG_DEBUG, "X509: Unexpected ASN.1 header "
 901                                    "in Extensions: class %d tag 0x%x; "
 902                                    "expected OCTET STRING",
 903                                    hdr.class, hdr.tag);
 904                         return -1;
 905                 }
 906         }
 907
 908         asn1_oid_to_str(&oid, buf, sizeof(buf));
 909         wpa_printf(MSG_DEBUG, "X509: Extension: extnID=%s critical=%d",
 910                    buf, critical_ext);
 911         wpa_hexdump(MSG_MSGDUMP, "X509: extnValue", hdr.payload, hdr.length);
 912
 913         res = x509_parse_extension_data(cert, &oid, hdr.payload, hdr.length);
 914         if (res < 0)
 915                 return res;
 916         if (res == 1 && critical_ext) {
 917                 wpa_printf(MSG_INFO, "X509: Unknown critical extension %s",
 918                            buf);
 919                 return -1;
 920         }
 921
 922         return 0;
 923 }
 924
 925
 926 static int x509_parse_extensions(struct x509_certificate *cert,
 927                                  const u8 *pos, size_t len)
 928 {
 929         const u8 *end;
 930         struct asn1_hdr hdr;
 931
 932         /* Extensions  ::=  SEQUENCE SIZE (1..MAX) OF Extension */
 933
 934         if (asn1_get_next(pos, len, &hdr) < 0 ||
 935             hdr.class != ASN1_CLASS_UNIVERSAL ||
 936             hdr.tag != ASN1_TAG_SEQUENCE) {
 937                 wpa_printf(MSG_DEBUG, "X509: Unexpected ASN.1 data "
 938                            "for Extensions: class %d tag 0x%x; "
 939                            "expected SEQUENCE", hdr.class, hdr.tag);
 940                 return -1;
 941         }
 942
 943         pos = hdr.payload;
 944         end = pos + hdr.length;
 945
 946         while (pos < end) {
 947                 if (x509_parse_extension(cert, pos, end - pos, &pos)
 948                     < 0)
 949                         return -1;
 950         }
 951
 952         return 0;
 953 }
 954
 955
 956 static int x509_parse_tbs_certificate(const u8 *buf, size_t len,
 957                                       struct x509_certificate *cert,
 958                                       const u8 **next)
 959 {
 960         struct asn1_hdr hdr;
 961         const u8 *pos, *end;
 962         size_t left;
 963         char sbuf[128];
 964         unsigned long value;
 965
 966         /* tbsCertificate TBSCertificate ::= SEQUENCE */
 967         if (asn1_get_next(buf, len, &hdr) < 0 ||
 968             hdr.class != ASN1_CLASS_UNIVERSAL ||
 969             hdr.tag != ASN1_TAG_SEQUENCE) {
 970                 wpa_printf(MSG_DEBUG, "X509: tbsCertificate did not start "
 971                            "with a valid SEQUENCE - found class %d tag 0x%x",
 972                            hdr.class, hdr.tag);
 973                 return -1;
 974         }
 975         pos = hdr.payload;
 976         end = *next = pos + hdr.length;
 977
 978         /*
 979          * version [0]  EXPLICIT Version DEFAULT v1
 980          * Version  ::=  INTEGER  {  v1(0), v2(1), v3(2)  }
 981          */
 982         if (asn1_get_next(pos, end - pos, &hdr) < 0)
 983                 return -1;
 984         pos = hdr.payload;
 985
 986         if (hdr.class == ASN1_CLASS_CONTEXT_SPECIFIC) {
 987                 if (asn1_get_next(pos, end - pos, &hdr) < 0)
 988                         return -1;
 989
 990                 if (hdr.class != ASN1_CLASS_UNIVERSAL ||
 991                     hdr.tag != ASN1_TAG_INTEGER) {
 992                         wpa_printf(MSG_DEBUG, "X509: No INTEGER tag found for "
 993                                    "version field - found class %d tag 0x%x",
 994                                    hdr.class, hdr.tag);
 995                         return -1;
 996                 }
 997                 if (hdr.length != 1) {
 998                         wpa_printf(MSG_DEBUG, "X509: Unexpected version field "
 999                                    "length %u (expected 1)", hdr.length);
1000                         return -1;
1001                 }
1002                 pos = hdr.payload;
1003                 left = hdr.length;
1004                 value = 0;
1005                 while (left) {
1006                         value <<= 8;
1007                         value |= *pos++;
1008                         left--;
1009                 }
1010
1011                 cert->version = value;
1012                 if (cert->version != X509_CERT_V1 &&
1013                     cert->version != X509_CERT_V2 &&
1014                     cert->version != X509_CERT_V3) {
1015                         wpa_printf(MSG_DEBUG, "X509: Unsupported version %d",
1016                                    cert->version + 1);
1017                         return -1;
1018                 }
1019
1020                 if (asn1_get_next(pos, end - pos, &hdr) < 0)
1021                         return -1;
1022         } else
1023                 cert->version = X509_CERT_V1;
1024         wpa_printf(MSG_MSGDUMP, "X509: Version X.509v%d", cert->version + 1);
1025
1026         /* serialNumber CertificateSerialNumber ::= INTEGER */
1027         if (hdr.class != ASN1_CLASS_UNIVERSAL ||
1028             hdr.tag != ASN1_TAG_INTEGER) {
1029                 wpa_printf(MSG_DEBUG, "X509: No INTEGER tag found for "
1030                            "serialNumber; class=%d tag=0x%x",
1031                            hdr.class, hdr.tag);
1032                 return -1;
1033         }
1034
1035         pos = hdr.payload;
1036         left = hdr.length;
1037         while (left) {
1038                 cert->serial_number <<= 8;
1039                 cert->serial_number |= *pos++;
1040                 left--;
1041         }
1042         wpa_printf(MSG_MSGDUMP, "X509: serialNumber %lu", cert->serial_number);
1043
1044         /* signature AlgorithmIdentifier */
1045         if (x509_parse_algorithm_identifier(pos, end - pos, &cert->signature,
1046                                             &pos))
1047                 return -1;
1048
1049         /* issuer Name */
1050         if (x509_parse_name(pos, end - pos, &cert->issuer, &pos))
1051                 return -1;
1052         x509_name_string(&cert->issuer, sbuf, sizeof(sbuf));
1053         wpa_printf(MSG_MSGDUMP, "X509: issuer %s", sbuf);
1054
1055         /* validity Validity */
1056         if (x509_parse_validity(pos, end - pos, cert, &pos))
1057                 return -1;
1058
1059         /* subject Name */
1060         if (x509_parse_name(pos, end - pos, &cert->subject, &pos))
1061                 return -1;
1062         x509_name_string(&cert->subject, sbuf, sizeof(sbuf));
1063         wpa_printf(MSG_MSGDUMP, "X509: subject %s", sbuf);
1064
1065         /* subjectPublicKeyInfo SubjectPublicKeyInfo */
1066         if (x509_parse_public_key(pos, end - pos, cert, &pos))
1067                 return -1;
1068
1069         if (pos == end)
1070                 return 0;
1071
1072         if (cert->version == X509_CERT_V1)
1073                 return 0;
1074
1075         if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
1076             hdr.class != ASN1_CLASS_CONTEXT_SPECIFIC) {
1077                 wpa_printf(MSG_DEBUG, "X509: Expected Context-Specific"
1078                            " tag to parse optional tbsCertificate "
1079                            "field(s); parsed class %d tag 0x%x",
1080                            hdr.class, hdr.tag);
1081                 return -1;
1082         }
1083
1084         if (hdr.tag == 1) {
1085                 /* issuerUniqueID  [1]  IMPLICIT UniqueIdentifier OPTIONAL */
1086                 wpa_printf(MSG_DEBUG, "X509: issuerUniqueID");
1087                 /* TODO: parse UniqueIdentifier ::= BIT STRING */
1088
1089                 if (hdr.payload + hdr.length == end)
1090                         return 0;
1091
1092                 if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
1093                     hdr.class != ASN1_CLASS_CONTEXT_SPECIFIC) {
1094                         wpa_printf(MSG_DEBUG, "X509: Expected Context-Specific"
1095                                    " tag to parse optional tbsCertificate "
1096                                    "field(s); parsed class %d tag 0x%x",
1097                                    hdr.class, hdr.tag);
1098                         return -1;
1099                 }
1100         }
1101
1102         if (hdr.tag == 2) {
1103                 /* subjectUniqueID [2]  IMPLICIT UniqueIdentifier OPTIONAL */
1104                 wpa_printf(MSG_DEBUG, "X509: subjectUniqueID");
1105                 /* TODO: parse UniqueIdentifier ::= BIT STRING */
1106
1107                 if (hdr.payload + hdr.length == end)
1108                         return 0;
1109
1110                 if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
1111                     hdr.class != ASN1_CLASS_CONTEXT_SPECIFIC) {
1112                         wpa_printf(MSG_DEBUG, "X509: Expected Context-Specific"
1113                                    " tag to parse optional tbsCertificate "
1114                                    "field(s); parsed class %d tag 0x%x",
1115                                    hdr.class, hdr.tag);
1116                         return -1;
1117                 }
1118         }
1119
1120         if (hdr.tag != 3) {
1121                 wpa_printf(MSG_DEBUG, "X509: Ignored unexpected "
1122                            "Context-Specific tag %d in optional "
1123                            "tbsCertificate fields", hdr.tag);
1124                 return 0;
1125         }
1126
1127         /* extensions      [3]  EXPLICIT Extensions OPTIONAL */
1128
1129         if (cert->version != X509_CERT_V3) {
1130                 wpa_printf(MSG_DEBUG, "X509: X.509%d certificate and "
1131                            "Extensions data which are only allowed for "
1132                            "version 3", cert->version + 1);
1133                 return -1;
1134         }
1135
1136         if (x509_parse_extensions(cert, hdr.payload, hdr.length) < 0)
1137                 return -1;
1138
1139         pos = hdr.payload + hdr.length;
1140         if (pos < end) {
1141                 wpa_hexdump(MSG_DEBUG,
1142                             "X509: Ignored extra tbsCertificate data",
1143                             pos, end - pos);
1144         }
1145
1146         return 0;
1147 }
1148
1149
1150 static int x509_rsadsi_oid(struct asn1_oid *oid)
1151 {
1152         return oid->len >= 4 &&
1153                 oid->oid[0] == 1 /* iso */ &&
1154                 oid->oid[1] == 2 /* member-body */ &&
1155                 oid->oid[2] == 840 /* us */ &&
1156                 oid->oid[3] == 113549 /* rsadsi */;
1157 }
1158
1159
1160 static int x509_pkcs_oid(struct asn1_oid *oid)
1161 {
1162         return oid->len >= 5 &&
1163                 x509_rsadsi_oid(oid) &&
1164                 oid->oid[4] == 1 /* pkcs */;
1165 }
1166
1167
1168 static int x509_digest_oid(struct asn1_oid *oid)
1169 {
1170         return oid->len >= 5 &&
1171                 x509_rsadsi_oid(oid) &&
1172                 oid->oid[4] == 2 /* digestAlgorithm */;
1173 }
1174
1175
1176 static int x509_sha1_oid(struct asn1_oid *oid)
1177 {
1178         return oid->len == 6 &&
1179                 oid->oid[0] == 1 /* iso */ &&
1180                 oid->oid[1] == 3 /* identified-organization */ &&
1181                 oid->oid[2] == 14 /* oiw */ &&
1182                 oid->oid[3] == 3 /* secsig */ &&
1183                 oid->oid[4] == 2 /* algorithms */ &&
1184                 oid->oid[5] == 26 /* id-sha1 */;
1185 }
1186
1187
1188 static int x509_sha256_oid(struct asn1_oid *oid)
1189 {
1190         return oid->len == 9 &&
1191                 oid->oid[0] == 2 /* joint-iso-itu-t */ &&
1192                 oid->oid[1] == 16 /* country */ &&
1193                 oid->oid[2] == 840 /* us */ &&
1194                 oid->oid[3] == 1 /* organization */ &&
1195                 oid->oid[4] == 101 /* gov */ &&
1196                 oid->oid[5] == 3 /* csor */ &&
1197                 oid->oid[6] == 4 /* nistAlgorithm */ &&
1198                 oid->oid[7] == 2 /* hashAlgs */ &&
1199                 oid->oid[8] == 1 /* sha256 */;
1200 }
1201
1202
1203 /**
1204  * x509_certificate_parse - Parse a X.509 certificate in DER format
1205  * @buf: Pointer to the X.509 certificate in DER format
1206  * @len: Buffer length
1207  * Returns: Pointer to the parsed certificate or %NULL on failure
1208  *
1209  * Caller is responsible for freeing the returned certificate by calling
1210  * x509_certificate_free().
1211  */
1212 struct x509_certificate * x509_certificate_parse(const u8 *buf, size_t len)
1213 {
1214         struct asn1_hdr hdr;
1215         const u8 *pos, *end, *hash_start;
1216         struct x509_certificate *cert;
1217
1218         cert = os_zalloc(sizeof(*cert) + len);
1219         if (cert == NULL)
1220                 return NULL;
1221         os_memcpy(cert + 1, buf, len);
1222         cert->cert_start = (u8 *) (cert + 1);
1223         cert->cert_len = len;
1224
1225         pos = buf;
1226         end = buf + len;
1227
1228         /* RFC 3280 - X.509 v3 certificate / ASN.1 DER */
1229
1230         /* Certificate ::= SEQUENCE */
1231         if (asn1_get_next(pos, len, &hdr) < 0 ||
1232             hdr.class != ASN1_CLASS_UNIVERSAL ||
1233             hdr.tag != ASN1_TAG_SEQUENCE) {
1234                 wpa_printf(MSG_DEBUG, "X509: Certificate did not start with "
1235                            "a valid SEQUENCE - found class %d tag 0x%x",
1236                            hdr.class, hdr.tag);
1237                 x509_certificate_free(cert);
1238                 return NULL;
1239         }
1240         pos = hdr.payload;
1241
1242         if (pos + hdr.length > end) {
1243                 x509_certificate_free(cert);
1244                 return NULL;
1245         }
1246
1247         if (pos + hdr.length < end) {
1248                 wpa_hexdump(MSG_MSGDUMP, "X509: Ignoring extra data after DER "
1249                             "encoded certificate",
1250                             pos + hdr.length, end - pos + hdr.length);
1251                 end = pos + hdr.length;
1252         }
1253
1254         hash_start = pos;
1255         cert->tbs_cert_start = cert->cert_start + (hash_start - buf);
1256         if (x509_parse_tbs_certificate(pos, end - pos, cert, &pos)) {
1257                 x509_certificate_free(cert);
1258                 return NULL;
1259         }
1260         cert->tbs_cert_len = pos - hash_start;
1261
1262         /* signatureAlgorithm AlgorithmIdentifier */
1263         if (x509_parse_algorithm_identifier(pos, end - pos,
1264                                             &cert->signature_alg, &pos)) {
1265                 x509_certificate_free(cert);
1266                 return NULL;
1267         }
1268
1269         /* signatureValue BIT STRING */
1270         if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
1271             hdr.class != ASN1_CLASS_UNIVERSAL ||
1272             hdr.tag != ASN1_TAG_BITSTRING) {
1273                 wpa_printf(MSG_DEBUG, "X509: Expected BITSTRING "
1274                            "(signatureValue) - found class %d tag 0x%x",
1275                            hdr.class, hdr.tag);
1276                 x509_certificate_free(cert);
1277                 return NULL;
1278         }
1279         if (hdr.length < 1) {
1280                 x509_certificate_free(cert);
1281                 return NULL;
1282         }
1283         pos = hdr.payload;
1284         if (*pos) {
1285                 wpa_printf(MSG_DEBUG, "X509: BITSTRING - %d unused bits",
1286                            *pos);
1287                 /* PKCS #1 v1.5 10.2.1:
1288                  * It is an error if the length in bits of the signature S is
1289                  * not a multiple of eight.
1290                  */
1291                 x509_certificate_free(cert);
1292                 return NULL;
1293         }
1294         os_free(cert->sign_value);
1295         cert->sign_value = os_malloc(hdr.length - 1);
1296         if (cert->sign_value == NULL) {
1297                 wpa_printf(MSG_DEBUG, "X509: Failed to allocate memory for "
1298                            "signatureValue");
1299                 x509_certificate_free(cert);
1300                 return NULL;
1301         }
1302         os_memcpy(cert->sign_value, pos + 1, hdr.length - 1);
1303         cert->sign_value_len = hdr.length - 1;
1304         wpa_hexdump(MSG_MSGDUMP, "X509: signature",
1305                     cert->sign_value, cert->sign_value_len);
1306
1307         return cert;
1308 }
1309
1310
1311 /**
1312  * x509_certificate_check_signature - Verify certificate signature
1313  * @issuer: Issuer certificate
1314  * @cert: Certificate to be verified
1315  * Returns: 0 if cert has a valid signature that was signed by the issuer,
1316  * -1 if not
1317  */
1318 int x509_certificate_check_signature(struct x509_certificate *issuer,
1319                                      struct x509_certificate *cert)
1320 {
1321         struct crypto_public_key *pk;
1322         u8 *data;
1323         const u8 *pos, *end, *next, *da_end;
1324         size_t data_len;
1325         struct asn1_hdr hdr;
1326         struct asn1_oid oid;
1327         u8 hash[32];
1328         size_t hash_len;
1329
1330         if (!x509_pkcs_oid(&cert->signature.oid) ||
1331             cert->signature.oid.len != 7 ||
1332             cert->signature.oid.oid[5] != 1 /* pkcs-1 */) {
1333                 wpa_printf(MSG_DEBUG, "X509: Unrecognized signature "
1334                            "algorithm");
1335                 return -1;
1336         }
1337
1338         pk = crypto_public_key_import(issuer->public_key,
1339                                       issuer->public_key_len);
1340         if (pk == NULL)
1341                 return -1;
1342
1343         data_len = cert->sign_value_len;
1344         data = os_malloc(data_len);
1345         if (data == NULL) {
1346                 crypto_public_key_free(pk);
1347                 return -1;
1348         }
1349
1350         if (crypto_public_key_decrypt_pkcs1(pk, cert->sign_value,
1351                                             cert->sign_value_len, data,
1352                                             &data_len) < 0) {
1353                 wpa_printf(MSG_DEBUG, "X509: Failed to decrypt signature");
1354                 crypto_public_key_free(pk);
1355                 os_free(data);
1356                 return -1;
1357         }
1358         crypto_public_key_free(pk);
1359
1360         wpa_hexdump(MSG_MSGDUMP, "X509: Signature data D", data, data_len);
1361
1362         /*
1363          * PKCS #1 v1.5, 10.1.2:
1364          *
1365          * DigestInfo ::= SEQUENCE {
1366          *     digestAlgorithm DigestAlgorithmIdentifier,
1367          *     digest Digest
1368          * }
1369          *
1370          * DigestAlgorithmIdentifier ::= AlgorithmIdentifier
1371          *
1372          * Digest ::= OCTET STRING
1373          *
1374          */
1375         if (asn1_get_next(data, data_len, &hdr) < 0 ||
1376             hdr.class != ASN1_CLASS_UNIVERSAL ||
1377             hdr.tag != ASN1_TAG_SEQUENCE) {
1378                 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE "
1379                            "(DigestInfo) - found class %d tag 0x%x",
1380                            hdr.class, hdr.tag);
1381                 os_free(data);
1382                 return -1;
1383         }
1384
1385         pos = hdr.payload;
1386         end = pos + hdr.length;
1387
1388         /*
1389          * X.509:
1390          * AlgorithmIdentifier ::= SEQUENCE {
1391          *     algorithm            OBJECT IDENTIFIER,
1392          *     parameters           ANY DEFINED BY algorithm OPTIONAL
1393          * }
1394          */
1395
1396         if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
1397             hdr.class != ASN1_CLASS_UNIVERSAL ||
1398             hdr.tag != ASN1_TAG_SEQUENCE) {
1399                 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE "
1400                            "(AlgorithmIdentifier) - found class %d tag 0x%x",
1401                            hdr.class, hdr.tag);
1402                 os_free(data);
1403                 return -1;
1404         }
1405         da_end = hdr.payload + hdr.length;
1406
1407         if (asn1_get_oid(hdr.payload, hdr.length, &oid, &next)) {
1408                 wpa_printf(MSG_DEBUG, "X509: Failed to parse digestAlgorithm");
1409                 os_free(data);
1410                 return -1;
1411         }
1412
1413         if (x509_sha1_oid(&oid)) {
1414                 if (cert->signature.oid.oid[6] !=
1415                     5 /* sha-1WithRSAEncryption */) {
1416                         wpa_printf(MSG_DEBUG, "X509: digestAlgorithm SHA1 "
1417                                    "does not match with certificate "
1418                                    "signatureAlgorithm (%lu)",
1419                                    cert->signature.oid.oid[6]);
1420                         os_free(data);
1421                         return -1;
1422                 }
1423                 goto skip_digest_oid;
1424         }
1425
1426         if (x509_sha256_oid(&oid)) {
1427                 if (cert->signature.oid.oid[6] !=
1428                     11 /* sha2561WithRSAEncryption */) {
1429                         wpa_printf(MSG_DEBUG, "X509: digestAlgorithm SHA256 "
1430                                    "does not match with certificate "
1431                                    "signatureAlgorithm (%lu)",
1432                                    cert->signature.oid.oid[6]);
1433                         os_free(data);
1434                         return -1;
1435                 }
1436                 goto skip_digest_oid;
1437         }
1438
1439         if (!x509_digest_oid(&oid)) {
1440                 wpa_printf(MSG_DEBUG, "X509: Unrecognized digestAlgorithm");
1441                 os_free(data);
1442                 return -1;
1443         }
1444         switch (oid.oid[5]) {
1445         case 5: /* md5 */
1446                 if (cert->signature.oid.oid[6] != 4 /* md5WithRSAEncryption */)
1447                 {
1448                         wpa_printf(MSG_DEBUG, "X509: digestAlgorithm MD5 does "
1449                                    "not match with certificate "
1450                                    "signatureAlgorithm (%lu)",
1451                                    cert->signature.oid.oid[6]);
1452                         os_free(data);
1453                         return -1;
1454                 }
1455                 break;
1456         case 2: /* md2 */
1457         case 4: /* md4 */
1458         default:
1459                 wpa_printf(MSG_DEBUG, "X509: Unsupported digestAlgorithm "
1460                            "(%lu)", oid.oid[5]);
1461                 os_free(data);
1462                 return -1;
1463         }
1464
1465 skip_digest_oid:
1466         /* Digest ::= OCTET STRING */
1467         pos = da_end;
1468         end = data + data_len;
1469
1470         if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
1471             hdr.class != ASN1_CLASS_UNIVERSAL ||
1472             hdr.tag != ASN1_TAG_OCTETSTRING) {
1473                 wpa_printf(MSG_DEBUG, "X509: Expected OCTETSTRING "
1474                            "(Digest) - found class %d tag 0x%x",
1475                            hdr.class, hdr.tag);
1476                 os_free(data);
1477                 return -1;
1478         }
1479         wpa_hexdump(MSG_MSGDUMP, "X509: Decrypted Digest",
1480                     hdr.payload, hdr.length);
1481
1482         switch (cert->signature.oid.oid[6]) {
1483         case 4: /* md5WithRSAEncryption */
1484                 md5_vector(1, &cert->tbs_cert_start, &cert->tbs_cert_len,
1485                            hash);
1486                 hash_len = 16;
1487                 wpa_hexdump(MSG_MSGDUMP, "X509: Certificate hash (MD5)",
1488                             hash, hash_len);
1489                 break;
1490         case 5: /* sha-1WithRSAEncryption */
1491                 sha1_vector(1, &cert->tbs_cert_start, &cert->tbs_cert_len,
1492                             hash);
1493                 hash_len = 20;
1494                 wpa_hexdump(MSG_MSGDUMP, "X509: Certificate hash (SHA1)",
1495                             hash, hash_len);
1496                 break;
1497         case 11: /* sha256WithRSAEncryption */
1498 #ifdef NEED_SHA256
1499                 sha256_vector(1, &cert->tbs_cert_start, &cert->tbs_cert_len,
1500                               hash);
1501                 hash_len = 32;
1502                 wpa_hexdump(MSG_MSGDUMP, "X509: Certificate hash (SHA256)",
1503                             hash, hash_len);
1504                 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         case 2: /* md2WithRSAEncryption */
1511         case 12: /* sha384WithRSAEncryption */
1512         case 13: /* sha512WithRSAEncryption */
1513         default:
1514                 wpa_printf(MSG_INFO, "X509: Unsupported certificate signature "
1515                            "algorithm (%lu)", cert->signature.oid.oid[6]);
1516                 os_free(data);
1517                 return -1;
1518         }
1519
1520         if (hdr.length != hash_len ||
1521             os_memcmp(hdr.payload, hash, hdr.length) != 0) {
1522                 wpa_printf(MSG_INFO, "X509: Certificate Digest does not match "
1523                            "with calculated tbsCertificate hash");
1524                 os_free(data);
1525                 return -1;
1526         }
1527
1528         os_free(data);
1529
1530         wpa_printf(MSG_DEBUG, "X509: Certificate Digest matches with "
1531                    "calculated tbsCertificate hash");
1532
1533         return 0;
1534 }
1535
1536
1537 static int x509_valid_issuer(const struct x509_certificate *cert)
1538 {
1539         if ((cert->extensions_present & X509_EXT_BASIC_CONSTRAINTS) &&
1540             !cert->ca) {
1541                 wpa_printf(MSG_DEBUG, "X509: Non-CA certificate used as an "
1542                            "issuer");
1543                 return -1;
1544         }
1545
1546         if (cert->version == X509_CERT_V3 &&
1547             !(cert->extensions_present & X509_EXT_BASIC_CONSTRAINTS)) {
1548                 wpa_printf(MSG_DEBUG, "X509: v3 CA certificate did not "
1549                            "include BasicConstraints extension");
1550                 return -1;
1551         }
1552
1553         if ((cert->extensions_present & X509_EXT_KEY_USAGE) &&
1554             !(cert->key_usage & X509_KEY_USAGE_KEY_CERT_SIGN)) {
1555                 wpa_printf(MSG_DEBUG, "X509: Issuer certificate did not have "
1556                            "keyCertSign bit in Key Usage");
1557                 return -1;
1558         }
1559
1560         return 0;
1561 }
1562
1563
1564 /**
1565  * x509_certificate_chain_validate - Validate X.509 certificate chain
1566  * @trusted: List of trusted certificates
1567  * @chain: Certificate chain to be validated (first chain must be issued by
1568  * signed by the second certificate in the chain and so on)
1569  * @reason: Buffer for returning failure reason (X509_VALIDATE_*)
1570  * Returns: 0 if chain is valid, -1 if not
1571  */
1572 int x509_certificate_chain_validate(struct x509_certificate *trusted,
1573                                     struct x509_certificate *chain,
1574                                     int *reason)
1575 {
1576         long unsigned idx;
1577         int chain_trusted = 0;
1578         struct x509_certificate *cert, *trust;
1579         char buf[128];
1580         struct os_time now;
1581
1582         *reason = X509_VALIDATE_OK;
1583
1584         wpa_printf(MSG_DEBUG, "X509: Validate certificate chain");
1585         os_get_time(&now);
1586
1587         for (cert = chain, idx = 0; cert; cert = cert->next, idx++) {
1588                 x509_name_string(&cert->subject, buf, sizeof(buf));
1589                 wpa_printf(MSG_DEBUG, "X509: %lu: %s", idx, buf);
1590
1591                 if (chain_trusted)
1592                         continue;
1593
1594                 if ((unsigned long) now.sec <
1595                     (unsigned long) cert->not_before ||
1596                     (unsigned long) now.sec >
1597                     (unsigned long) cert->not_after) {
1598                         wpa_printf(MSG_INFO, "X509: Certificate not valid "
1599                                    "(now=%lu not_before=%lu not_after=%lu)",
1600                                    now.sec, cert->not_before, cert->not_after);
1601                         *reason = X509_VALIDATE_CERTIFICATE_EXPIRED;
1602                         return -1;
1603                 }
1604
1605                 if (cert->next) {
1606                         if (x509_name_compare(&cert->issuer,
1607                                               &cert->next->subject) != 0) {
1608                                 wpa_printf(MSG_DEBUG, "X509: Certificate "
1609                                            "chain issuer name mismatch");
1610                                 x509_name_string(&cert->issuer, buf,
1611                                                  sizeof(buf));
1612                                 wpa_printf(MSG_DEBUG, "X509: cert issuer: %s",
1613                                            buf);
1614                                 x509_name_string(&cert->next->subject, buf,
1615                                                  sizeof(buf));
1616                                 wpa_printf(MSG_DEBUG, "X509: next cert "
1617                                            "subject: %s", buf);
1618                                 *reason = X509_VALIDATE_CERTIFICATE_UNKNOWN;
1619                                 return -1;
1620                         }
1621
1622                         if (x509_valid_issuer(cert->next) < 0) {
1623                                 *reason = X509_VALIDATE_BAD_CERTIFICATE;
1624                                 return -1;
1625                         }
1626
1627                         if ((cert->next->extensions_present &
1628                              X509_EXT_PATH_LEN_CONSTRAINT) &&
1629                             idx > cert->next->path_len_constraint) {
1630                                 wpa_printf(MSG_DEBUG, "X509: pathLenConstraint"
1631                                            " not met (idx=%lu issuer "
1632                                            "pathLenConstraint=%lu)", idx,
1633                                            cert->next->path_len_constraint);
1634                                 *reason = X509_VALIDATE_BAD_CERTIFICATE;
1635                                 return -1;
1636                         }
1637
1638                         if (x509_certificate_check_signature(cert->next, cert)
1639                             < 0) {
1640                                 wpa_printf(MSG_DEBUG, "X509: Invalid "
1641                                            "certificate signature within "
1642                                            "chain");
1643                                 *reason = X509_VALIDATE_BAD_CERTIFICATE;
1644                                 return -1;
1645                         }
1646                 }
1647
1648                 for (trust = trusted; trust; trust = trust->next) {
1649                         if (x509_name_compare(&cert->issuer, &trust->subject)
1650                             == 0)
1651                                 break;
1652                 }
1653
1654                 if (trust) {
1655                         wpa_printf(MSG_DEBUG, "X509: Found issuer from the "
1656                                    "list of trusted certificates");
1657                         if (x509_valid_issuer(trust) < 0) {
1658                                 *reason = X509_VALIDATE_BAD_CERTIFICATE;
1659                                 return -1;
1660                         }
1661
1662                         if (x509_certificate_check_signature(trust, cert) < 0)
1663                         {
1664                                 wpa_printf(MSG_DEBUG, "X509: Invalid "
1665                                            "certificate signature");
1666                                 *reason = X509_VALIDATE_BAD_CERTIFICATE;
1667                                 return -1;
1668                         }
1669
1670                         wpa_printf(MSG_DEBUG, "X509: Trusted certificate "
1671                                    "found to complete the chain");
1672                         chain_trusted = 1;
1673                 }
1674         }
1675
1676         if (!chain_trusted) {
1677                 wpa_printf(MSG_DEBUG, "X509: Did not find any of the issuers "
1678                            "from the list of trusted certificates");
1679                 if (trusted) {
1680                         *reason = X509_VALIDATE_UNKNOWN_CA;
1681                         return -1;
1682                 }
1683                 wpa_printf(MSG_DEBUG, "X509: Certificate chain validation "
1684                            "disabled - ignore unknown CA issue");
1685         }
1686
1687         wpa_printf(MSG_DEBUG, "X509: Certificate chain valid");
1688
1689         return 0;
1690 }
1691
1692
1693 /**
1694  * x509_certificate_get_subject - Get a certificate based on Subject name
1695  * @chain: Certificate chain to search through
1696  * @name: Subject name to search for
1697  * Returns: Pointer to the certificate with the given Subject name or
1698  * %NULL on failure
1699  */
1700 struct x509_certificate *
1701 x509_certificate_get_subject(struct x509_certificate *chain,
1702                              struct x509_name *name)
1703 {
1704         struct x509_certificate *cert;
1705
1706         for (cert = chain; cert; cert = cert->next) {
1707                 if (x509_name_compare(&cert->subject, name) == 0)
1708                         return cert;
1709         }
1710         return NULL;
1711 }
1712
1713
1714 /**
1715  * x509_certificate_self_signed - Is the certificate self-signed?
1716  * @cert: Certificate
1717  * Returns: 1 if certificate is self-signed, 0 if not
1718  */
1719 int x509_certificate_self_signed(struct x509_certificate *cert)
1720 {
1721         return x509_name_compare(&cert->issuer, &cert->subject) == 0;
1722 }
1723
1724 #endif /* CONFIG_INTERNAL_X509 */