contrib/wpa_supplicant/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 /**
1189  * x509_certificate_parse - Parse a X.509 certificate in DER format
1190  * @buf: Pointer to the X.509 certificate in DER format
1191  * @len: Buffer length
1192  * Returns: Pointer to the parsed certificate or %NULL on failure
1193  *
1194  * Caller is responsible for freeing the returned certificate by calling
1195  * x509_certificate_free().
1196  */
1197 struct x509_certificate * x509_certificate_parse(const u8 *buf, size_t len)
1198 {
1199         struct asn1_hdr hdr;
1200         const u8 *pos, *end, *hash_start;
1201         struct x509_certificate *cert;
1202
1203         cert = os_zalloc(sizeof(*cert) + len);
1204         if (cert == NULL)
1205                 return NULL;
1206         os_memcpy(cert + 1, buf, len);
1207         cert->cert_start = (u8 *) (cert + 1);
1208         cert->cert_len = len;
1209
1210         pos = buf;
1211         end = buf + len;
1212
1213         /* RFC 3280 - X.509 v3 certificate / ASN.1 DER */
1214
1215         /* Certificate ::= SEQUENCE */
1216         if (asn1_get_next(pos, len, &hdr) < 0 ||
1217             hdr.class != ASN1_CLASS_UNIVERSAL ||
1218             hdr.tag != ASN1_TAG_SEQUENCE) {
1219                 wpa_printf(MSG_DEBUG, "X509: Certificate did not start with "
1220                            "a valid SEQUENCE - found class %d tag 0x%x",
1221                            hdr.class, hdr.tag);
1222                 x509_certificate_free(cert);
1223                 return NULL;
1224         }
1225         pos = hdr.payload;
1226
1227         if (pos + hdr.length > end) {
1228                 x509_certificate_free(cert);
1229                 return NULL;
1230         }
1231
1232         if (pos + hdr.length < end) {
1233                 wpa_hexdump(MSG_MSGDUMP, "X509: Ignoring extra data after DER "
1234                             "encoded certificate",
1235                             pos + hdr.length, end - pos + hdr.length);
1236                 end = pos + hdr.length;
1237         }
1238
1239         hash_start = pos;
1240         cert->tbs_cert_start = cert->cert_start + (hash_start - buf);
1241         if (x509_parse_tbs_certificate(pos, end - pos, cert, &pos)) {
1242                 x509_certificate_free(cert);
1243                 return NULL;
1244         }
1245         cert->tbs_cert_len = pos - hash_start;
1246
1247         /* signatureAlgorithm AlgorithmIdentifier */
1248         if (x509_parse_algorithm_identifier(pos, end - pos,
1249                                             &cert->signature_alg, &pos)) {
1250                 x509_certificate_free(cert);
1251                 return NULL;
1252         }
1253
1254         /* signatureValue BIT STRING */
1255         if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
1256             hdr.class != ASN1_CLASS_UNIVERSAL ||
1257             hdr.tag != ASN1_TAG_BITSTRING) {
1258                 wpa_printf(MSG_DEBUG, "X509: Expected BITSTRING "
1259                            "(signatureValue) - found class %d tag 0x%x",
1260                            hdr.class, hdr.tag);
1261                 x509_certificate_free(cert);
1262                 return NULL;
1263         }
1264         if (hdr.length < 1) {
1265                 x509_certificate_free(cert);
1266                 return NULL;
1267         }
1268         pos = hdr.payload;
1269         if (*pos) {
1270                 wpa_printf(MSG_DEBUG, "X509: BITSTRING - %d unused bits",
1271                            *pos);
1272                 /* PKCS #1 v1.5 10.2.1:
1273                  * It is an error if the length in bits of the signature S is
1274                  * not a multiple of eight.
1275                  */
1276                 x509_certificate_free(cert);
1277                 return NULL;
1278         }
1279         os_free(cert->sign_value);
1280         cert->sign_value = os_malloc(hdr.length - 1);
1281         if (cert->sign_value == NULL) {
1282                 wpa_printf(MSG_DEBUG, "X509: Failed to allocate memory for "
1283                            "signatureValue");
1284                 x509_certificate_free(cert);
1285                 return NULL;
1286         }
1287         os_memcpy(cert->sign_value, pos + 1, hdr.length - 1);
1288         cert->sign_value_len = hdr.length - 1;
1289         wpa_hexdump(MSG_MSGDUMP, "X509: signature",
1290                     cert->sign_value, cert->sign_value_len);
1291
1292         return cert;
1293 }
1294
1295
1296 /**
1297  * x509_certificate_check_signature - Verify certificate signature
1298  * @issuer: Issuer certificate
1299  * @cert: Certificate to be verified
1300  * Returns: 0 if cert has a valid signature that was signed by the issuer,
1301  * -1 if not
1302  */
1303 int x509_certificate_check_signature(struct x509_certificate *issuer,
1304                                      struct x509_certificate *cert)
1305 {
1306         struct crypto_public_key *pk;
1307         u8 *data;
1308         const u8 *pos, *end, *next, *da_end;
1309         size_t data_len;
1310         struct asn1_hdr hdr;
1311         struct asn1_oid oid;
1312         u8 hash[20];
1313         size_t hash_len;
1314
1315         if (!x509_pkcs_oid(&cert->signature.oid) ||
1316             cert->signature.oid.len != 7 ||
1317             cert->signature.oid.oid[5] != 1 /* pkcs-1 */) {
1318                 wpa_printf(MSG_DEBUG, "X509: Unrecognized signature "
1319                            "algorithm");
1320                 return -1;
1321         }
1322
1323         pk = crypto_public_key_import(issuer->public_key,
1324                                       issuer->public_key_len);
1325         if (pk == NULL)
1326                 return -1;
1327
1328         data_len = cert->sign_value_len;
1329         data = os_malloc(data_len);
1330         if (data == NULL) {
1331                 crypto_public_key_free(pk);
1332                 return -1;
1333         }
1334
1335         if (crypto_public_key_decrypt_pkcs1(pk, cert->sign_value,
1336                                             cert->sign_value_len, data,
1337                                             &data_len) < 0) {
1338                 wpa_printf(MSG_DEBUG, "X509: Failed to decrypt signature");
1339                 crypto_public_key_free(pk);
1340                 os_free(data);
1341                 return -1;
1342         }
1343         crypto_public_key_free(pk);
1344
1345         wpa_hexdump(MSG_MSGDUMP, "X509: Signature data D", data, data_len);
1346
1347         /*
1348          * PKCS #1 v1.5, 10.1.2:
1349          *
1350          * DigestInfo ::= SEQUENCE {
1351          *     digestAlgorithm DigestAlgorithmIdentifier,
1352          *     digest Digest
1353          * }
1354          *
1355          * DigestAlgorithmIdentifier ::= AlgorithmIdentifier
1356          *
1357          * Digest ::= OCTET STRING
1358          *
1359          */
1360         if (asn1_get_next(data, data_len, &hdr) < 0 ||
1361             hdr.class != ASN1_CLASS_UNIVERSAL ||
1362             hdr.tag != ASN1_TAG_SEQUENCE) {
1363                 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE "
1364                            "(DigestInfo) - found class %d tag 0x%x",
1365                            hdr.class, hdr.tag);
1366                 os_free(data);
1367                 return -1;
1368         }
1369
1370         pos = hdr.payload;
1371         end = pos + hdr.length;
1372
1373         /*
1374          * X.509:
1375          * AlgorithmIdentifier ::= SEQUENCE {
1376          *     algorithm            OBJECT IDENTIFIER,
1377          *     parameters           ANY DEFINED BY algorithm OPTIONAL
1378          * }
1379          */
1380
1381         if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
1382             hdr.class != ASN1_CLASS_UNIVERSAL ||
1383             hdr.tag != ASN1_TAG_SEQUENCE) {
1384                 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE "
1385                            "(AlgorithmIdentifier) - found class %d tag 0x%x",
1386                            hdr.class, hdr.tag);
1387                 os_free(data);
1388                 return -1;
1389         }
1390         da_end = hdr.payload + hdr.length;
1391
1392         if (asn1_get_oid(hdr.payload, hdr.length, &oid, &next)) {
1393                 wpa_printf(MSG_DEBUG, "X509: Failed to parse digestAlgorithm");
1394                 os_free(data);
1395                 return -1;
1396         }
1397
1398         if (x509_sha1_oid(&oid)) {
1399                 if (cert->signature.oid.oid[6] !=
1400                     5 /* sha-1WithRSAEncryption */) {
1401                         wpa_printf(MSG_DEBUG, "X509: digestAlgorithm SHA1 "
1402                                    "does not match with certificate "
1403                                    "signatureAlgorithm (%lu)",
1404                                    cert->signature.oid.oid[6]);
1405                         os_free(data);
1406                         return -1;
1407                 }
1408                 goto skip_digest_oid;
1409         }
1410
1411         if (!x509_digest_oid(&oid)) {
1412                 wpa_printf(MSG_DEBUG, "X509: Unrecognized digestAlgorithm");
1413                 os_free(data);
1414                 return -1;
1415         }
1416         switch (oid.oid[5]) {
1417         case 5: /* md5 */
1418                 if (cert->signature.oid.oid[6] != 4 /* md5WithRSAEncryption */)
1419                 {
1420                         wpa_printf(MSG_DEBUG, "X509: digestAlgorithm MD5 does "
1421                                    "not match with certificate "
1422                                    "signatureAlgorithm (%lu)",
1423                                    cert->signature.oid.oid[6]);
1424                         os_free(data);
1425                         return -1;
1426                 }
1427                 break;
1428         case 2: /* md2 */
1429         case 4: /* md4 */
1430         default:
1431                 wpa_printf(MSG_DEBUG, "X509: Unsupported digestAlgorithm "
1432                            "(%lu)", oid.oid[5]);
1433                 os_free(data);
1434                 return -1;
1435         }
1436
1437 skip_digest_oid:
1438         /* Digest ::= OCTET STRING */
1439         pos = da_end;
1440         end = data + data_len;
1441
1442         if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
1443             hdr.class != ASN1_CLASS_UNIVERSAL ||
1444             hdr.tag != ASN1_TAG_OCTETSTRING) {
1445                 wpa_printf(MSG_DEBUG, "X509: Expected OCTETSTRING "
1446                            "(Digest) - found class %d tag 0x%x",
1447                            hdr.class, hdr.tag);
1448                 os_free(data);
1449                 return -1;
1450         }
1451         wpa_hexdump(MSG_MSGDUMP, "X509: Decrypted Digest",
1452                     hdr.payload, hdr.length);
1453
1454         switch (cert->signature.oid.oid[6]) {
1455         case 4: /* md5WithRSAEncryption */
1456                 md5_vector(1, &cert->tbs_cert_start, &cert->tbs_cert_len,
1457                            hash);
1458                 hash_len = 16;
1459                 wpa_hexdump(MSG_MSGDUMP, "X509: Certificate hash (MD5)",
1460                             hash, hash_len);
1461                 break;
1462         case 5: /* sha-1WithRSAEncryption */
1463                 sha1_vector(1, &cert->tbs_cert_start, &cert->tbs_cert_len,
1464                             hash);
1465                 hash_len = 20;
1466                 wpa_hexdump(MSG_MSGDUMP, "X509: Certificate hash (SHA1)",
1467                             hash, hash_len);
1468                 break;
1469         case 2: /* md2WithRSAEncryption */
1470         case 11: /* sha256WithRSAEncryption */
1471         case 12: /* sha384WithRSAEncryption */
1472         case 13: /* sha512WithRSAEncryption */
1473         default:
1474                 wpa_printf(MSG_INFO, "X509: Unsupported certificate signature "
1475                            "algorithm (%lu)", cert->signature.oid.oid[6]);
1476                 os_free(data);
1477                 return -1;
1478         }
1479
1480         if (hdr.length != hash_len ||
1481             os_memcmp(hdr.payload, hash, hdr.length) != 0) {
1482                 wpa_printf(MSG_INFO, "X509: Certificate Digest does not match "
1483                            "with calculated tbsCertificate hash");
1484                 os_free(data);
1485                 return -1;
1486         }
1487
1488         os_free(data);
1489
1490         wpa_printf(MSG_DEBUG, "X509: Certificate Digest matches with "
1491                    "calculated tbsCertificate hash");
1492
1493         return 0;
1494 }
1495
1496
1497 static int x509_valid_issuer(const struct x509_certificate *cert)
1498 {
1499         if ((cert->extensions_present & X509_EXT_BASIC_CONSTRAINTS) &&
1500             !cert->ca) {
1501                 wpa_printf(MSG_DEBUG, "X509: Non-CA certificate used as an "
1502                            "issuer");
1503                 return -1;
1504         }
1505
1506         if (cert->version == X509_CERT_V3 &&
1507             !(cert->extensions_present & X509_EXT_BASIC_CONSTRAINTS)) {
1508                 wpa_printf(MSG_DEBUG, "X509: v3 CA certificate did not "
1509                            "include BasicConstraints extension");
1510                 return -1;
1511         }
1512
1513         if ((cert->extensions_present & X509_EXT_KEY_USAGE) &&
1514             !(cert->key_usage & X509_KEY_USAGE_KEY_CERT_SIGN)) {
1515                 wpa_printf(MSG_DEBUG, "X509: Issuer certificate did not have "
1516                            "keyCertSign bit in Key Usage");
1517                 return -1;
1518         }
1519
1520         return 0;
1521 }
1522
1523
1524 /**
1525  * x509_certificate_chain_validate - Validate X.509 certificate chain
1526  * @trusted: List of trusted certificates
1527  * @chain: Certificate chain to be validated (first chain must be issued by
1528  * signed by the second certificate in the chain and so on)
1529  * @reason: Buffer for returning failure reason (X509_VALIDATE_*)
1530  * Returns: 0 if chain is valid, -1 if not
1531  */
1532 int x509_certificate_chain_validate(struct x509_certificate *trusted,
1533                                     struct x509_certificate *chain,
1534                                     int *reason)
1535 {
1536         long unsigned idx;
1537         int chain_trusted = 0;
1538         struct x509_certificate *cert, *trust;
1539         char buf[128];
1540         struct os_time now;
1541
1542         *reason = X509_VALIDATE_OK;
1543
1544         wpa_printf(MSG_DEBUG, "X509: Validate certificate chain");
1545         os_get_time(&now);
1546
1547         for (cert = chain, idx = 0; cert; cert = cert->next, idx++) {
1548                 x509_name_string(&cert->subject, buf, sizeof(buf));
1549                 wpa_printf(MSG_DEBUG, "X509: %lu: %s", idx, buf);
1550
1551                 if (chain_trusted)
1552                         continue;
1553
1554                 if ((unsigned long) now.sec <
1555                     (unsigned long) cert->not_before ||
1556                     (unsigned long) now.sec >
1557                     (unsigned long) cert->not_after) {
1558                         wpa_printf(MSG_INFO, "X509: Certificate not valid "
1559                                    "(now=%lu not_before=%lu not_after=%lu)",
1560                                    now.sec, cert->not_before, cert->not_after);
1561                         *reason = X509_VALIDATE_CERTIFICATE_EXPIRED;
1562                         return -1;
1563                 }
1564
1565                 if (cert->next) {
1566                         if (x509_name_compare(&cert->issuer,
1567                                               &cert->next->subject) != 0) {
1568                                 wpa_printf(MSG_DEBUG, "X509: Certificate "
1569                                            "chain issuer name mismatch");
1570                                 *reason = X509_VALIDATE_CERTIFICATE_UNKNOWN;
1571                                 return -1;
1572                         }
1573
1574                         if (x509_valid_issuer(cert->next) < 0) {
1575                                 *reason = X509_VALIDATE_BAD_CERTIFICATE;
1576                                 return -1;
1577                         }
1578
1579                         if ((cert->next->extensions_present &
1580                              X509_EXT_PATH_LEN_CONSTRAINT) &&
1581                             idx > cert->next->path_len_constraint) {
1582                                 wpa_printf(MSG_DEBUG, "X509: pathLenConstraint"
1583                                            " not met (idx=%lu issuer "
1584                                            "pathLenConstraint=%lu)", idx,
1585                                            cert->next->path_len_constraint);
1586                                 *reason = X509_VALIDATE_BAD_CERTIFICATE;
1587                                 return -1;
1588                         }
1589
1590                         if (x509_certificate_check_signature(cert->next, cert)
1591                             < 0) {
1592                                 wpa_printf(MSG_DEBUG, "X509: Invalid "
1593                                            "certificate signature within "
1594                                            "chain");
1595                                 *reason = X509_VALIDATE_BAD_CERTIFICATE;
1596                                 return -1;
1597                         }
1598                 }
1599
1600                 for (trust = trusted; trust; trust = trust->next) {
1601                         if (x509_name_compare(&cert->issuer, &trust->subject)
1602                             == 0)
1603                                 break;
1604                 }
1605
1606                 if (trust) {
1607                         wpa_printf(MSG_DEBUG, "X509: Found issuer from the "
1608                                    "list of trusted certificates");
1609                         if (x509_valid_issuer(trust) < 0) {
1610                                 *reason = X509_VALIDATE_BAD_CERTIFICATE;
1611                                 return -1;
1612                         }
1613
1614                         if (x509_certificate_check_signature(trust, cert) < 0)
1615                         {
1616                                 wpa_printf(MSG_DEBUG, "X509: Invalid "
1617                                            "certificate signature");
1618                                 *reason = X509_VALIDATE_BAD_CERTIFICATE;
1619                                 return -1;
1620                         }
1621
1622                         wpa_printf(MSG_DEBUG, "X509: Trusted certificate "
1623                                    "found to complete the chain");
1624                         chain_trusted = 1;
1625                 }
1626         }
1627
1628         if (!chain_trusted) {
1629                 wpa_printf(MSG_DEBUG, "X509: Did not find any of the issuers "
1630                            "from the list of trusted certificates");
1631                 if (trusted) {
1632                         *reason = X509_VALIDATE_UNKNOWN_CA;
1633                         return -1;
1634                 }
1635                 wpa_printf(MSG_DEBUG, "X509: Certificate chain validation "
1636                            "disabled - ignore unknown CA issue");
1637         }
1638
1639         wpa_printf(MSG_DEBUG, "X509: Certificate chain valid");
1640
1641         return 0;
1642 }
1643
1644
1645 /**
1646  * x509_certificate_get_subject - Get a certificate based on Subject name
1647  * @chain: Certificate chain to search through
1648  * @name: Subject name to search for
1649  * Returns: Pointer to the certificate with the given Subject name or
1650  * %NULL on failure
1651  */
1652 struct x509_certificate *
1653 x509_certificate_get_subject(struct x509_certificate *chain,
1654                              struct x509_name *name)
1655 {
1656         struct x509_certificate *cert;
1657
1658         for (cert = chain; cert; cert = cert->next) {
1659                 if (x509_name_compare(&cert->subject, name) == 0)
1660                         return cert;
1661         }
1662         return NULL;
1663 }
1664
1665
1666 /**
1667  * x509_certificate_self_signed - Is the certificate self-signed?
1668  * @cert: Certificate
1669  * Returns: 1 if certificate is self-signed, 0 if not
1670  */
1671 int x509_certificate_self_signed(struct x509_certificate *cert)
1672 {
1673         return x509_name_compare(&cert->issuer, &cert->subject) == 0;
1674 }
1675
1676 #endif /* CONFIG_INTERNAL_X509 */