/src/hostap/src/tls/tlsv1_cred.c

Source (jump to first uncovered line)
/*
 * TLSv1 credentials
 * Copyright (c) 2006-2015, Jouni Malinen <j@w1.fi>
 *
 * This software may be distributed under the terms of the BSD license.
 * See README for more details.
 */

#include "includes.h"

#include "common.h"
#include "base64.h"
#include "crypto/crypto.h"
#include "crypto/sha1.h"
#include "pkcs5.h"
#include "pkcs8.h"
#include "x509v3.h"
#include "tlsv1_cred.h"


struct tlsv1_credentials * tlsv1_cred_alloc(void)
{
  struct tlsv1_credentials *cred;
  cred = os_zalloc(sizeof(*cred));
  return cred;
}


void tlsv1_cred_free(struct tlsv1_credentials *cred)
{
  if (cred == NULL)
    return;

  x509_certificate_chain_free(cred->trusted_certs);
  x509_certificate_chain_free(cred->cert);
  crypto_private_key_free(cred->key);
  os_free(cred->dh_p);
  os_free(cred->dh_g);
  os_free(cred->ocsp_stapling_response);
  os_free(cred->ocsp_stapling_response_multi);
  os_free(cred);
}


static int tlsv1_add_cert_der(struct x509_certificate **chain,
            const u8 *buf, size_t len)
{
  struct x509_certificate *cert, *p;
  char name[128];

  cert = x509_certificate_parse(buf, len);
  if (cert == NULL) {
    wpa_printf(MSG_INFO, "TLSv1: %s - failed to parse certificate",
         __func__);
    return -1;
  }

  p = *chain;
  while (p && p->next)
    p = p->next;
  if (p && x509_name_compare(&cert->subject, &p->issuer) == 0) {
    /*
     * The new certificate is the issuer of the last certificate in
     * the chain - add the new certificate to the end.
     */
    p->next = cert;
  } else {
    /* Add to the beginning of the chain */
    cert->next = *chain;
    *chain = cert;
  }

  x509_name_string(&cert->subject, name, sizeof(name));
  wpa_printf(MSG_DEBUG, "TLSv1: Added certificate: %s", name);

  return 0;
}


static const char *pem_cert_begin = "-----BEGIN CERTIFICATE-----";
static const char *pem_cert_end = "-----END CERTIFICATE-----";
static const char *pem_key_begin = "-----BEGIN RSA PRIVATE KEY-----";
static const char *pem_key_end = "-----END RSA PRIVATE KEY-----";
static const char *pem_key2_begin = "-----BEGIN PRIVATE KEY-----";
static const char *pem_key2_end = "-----END PRIVATE KEY-----";
static const char *pem_key_enc_begin = "-----BEGIN ENCRYPTED PRIVATE KEY-----";
static const char *pem_key_enc_end = "-----END ENCRYPTED PRIVATE KEY-----";


static const u8 * search_tag(const char *tag, const u8 *buf, size_t len)
{
  size_t i, plen;

  plen = os_strlen(tag);
  if (len < plen)
    return NULL;

  for (i = 0; i < len - plen; i++) {
    if (os_memcmp(buf + i, tag, plen) == 0)
      return buf + i;
  }

  return NULL;
}


static int tlsv1_add_cert(struct x509_certificate **chain,
        const u8 *buf, size_t len)
{
  const u8 *pos, *end;
  unsigned char *der;
  size_t der_len;

  pos = search_tag(pem_cert_begin, buf, len);
  if (!pos) {
    wpa_printf(MSG_DEBUG, "TLSv1: No PEM certificate tag found - "
         "assume DER format");
    return tlsv1_add_cert_der(chain, buf, len);
  }

  wpa_printf(MSG_DEBUG, "TLSv1: Converting PEM format certificate into "
       "DER format");

  while (pos) {
    pos += os_strlen(pem_cert_begin);
    end = search_tag(pem_cert_end, pos, buf + len - pos);
    if (end == NULL) {
      wpa_printf(MSG_INFO, "TLSv1: Could not find PEM "
           "certificate end tag (%s)", pem_cert_end);
      return -1;
    }

    der = base64_decode((const char *) pos, end - pos, &der_len);
    if (der == NULL) {
      wpa_printf(MSG_INFO, "TLSv1: Could not decode PEM "
           "certificate");
      return -1;
    }

    if (tlsv1_add_cert_der(chain, der, der_len) < 0) {
      wpa_printf(MSG_INFO, "TLSv1: Failed to parse PEM "
           "certificate after DER conversion");
      os_free(der);
      return -1;
    }

    os_free(der);

    end += os_strlen(pem_cert_end);
    pos = search_tag(pem_cert_begin, end, buf + len - end);
  }

  return 0;
}


static int tlsv1_set_cert_chain(struct x509_certificate **chain,
        const char *cert, const u8 *cert_blob,
        size_t cert_blob_len)
{
  if (cert_blob)
    return tlsv1_add_cert(chain, cert_blob, cert_blob_len);

  if (cert) {
    u8 *buf;
    size_t len;
    int ret;

    buf = (u8 *) os_readfile(cert, &len);
    if (buf == NULL) {
      wpa_printf(MSG_INFO, "TLSv1: Failed to read '%s'",
           cert);
      return -1;
    }

    ret = tlsv1_add_cert(chain, buf, len);
    os_free(buf);
    return ret;
  }

  return 0;
}


/**
 * tlsv1_set_ca_cert - Set trusted CA certificate(s)
 * @cred: TLSv1 credentials from tlsv1_cred_alloc()
 * @cert: File or reference name for X.509 certificate in PEM or DER format
 * @cert_blob: cert as inlined data or %NULL if not used
 * @cert_blob_len: ca_cert_blob length
 * @path: Path to CA certificates (not yet supported)
 * Returns: 0 on success, -1 on failure
 */
int tlsv1_set_ca_cert(struct tlsv1_credentials *cred, const char *cert,
          const u8 *cert_blob, size_t cert_blob_len,
          const char *path)
{
  if (cert && os_strncmp(cert, "hash://", 7) == 0) {
    const char *pos = cert + 7;
    if (os_strncmp(pos, "server/sha256/", 14) != 0) {
      wpa_printf(MSG_DEBUG,
           "TLSv1: Unsupported ca_cert hash value '%s'",
           cert);
      return -1;
    }
    pos += 14;
    if (os_strlen(pos) != 32 * 2) {
      wpa_printf(MSG_DEBUG,
           "TLSv1: Unexpected SHA256 hash length in ca_cert '%s'",
           cert);
      return -1;
    }
    if (hexstr2bin(pos, cred->srv_cert_hash, 32) < 0) {
      wpa_printf(MSG_DEBUG,
           "TLSv1: Invalid SHA256 hash value in ca_cert '%s'",
           cert);
      return -1;
    }
    cred->server_cert_only = 1;
    cred->ca_cert_verify = 0;
    wpa_printf(MSG_DEBUG,
         "TLSv1: Checking only server certificate match");
    return 0;
  }

  if (cert && os_strncmp(cert, "probe://", 8) == 0) {
    cred->cert_probe = 1;
    cred->ca_cert_verify = 0;
    wpa_printf(MSG_DEBUG, "TLSv1: Only probe server certificate");
    return 0;
  }

  cred->ca_cert_verify = cert || cert_blob || path;

  if (tlsv1_set_cert_chain(&cred->trusted_certs, cert,
         cert_blob, cert_blob_len) < 0)
    return -1;

  if (path) {
    /* TODO: add support for reading number of certificate files */
    wpa_printf(MSG_INFO, "TLSv1: Use of CA certificate directory "
         "not yet supported");
    return -1;
  }

  return 0;
}


/**
 * tlsv1_set_cert - Set certificate
 * @cred: TLSv1 credentials from tlsv1_cred_alloc()
 * @cert: File or reference name for X.509 certificate in PEM or DER format
 * @cert_blob: cert as inlined data or %NULL if not used
 * @cert_blob_len: cert_blob length
 * Returns: 0 on success, -1 on failure
 */
int tlsv1_set_cert(struct tlsv1_credentials *cred, const char *cert,
       const u8 *cert_blob, size_t cert_blob_len)
{
  return tlsv1_set_cert_chain(&cred->cert, cert,
            cert_blob, cert_blob_len);
}


static struct crypto_private_key * tlsv1_set_key_pem(const u8 *key, size_t len)
{
  const u8 *pos, *end;
  unsigned char *der;
  size_t der_len;
  struct crypto_private_key *pkey;

  pos = search_tag(pem_key_begin, key, len);
  if (!pos) {
    pos = search_tag(pem_key2_begin, key, len);
    if (!pos)
      return NULL;
    pos += os_strlen(pem_key2_begin);
    end = search_tag(pem_key2_end, pos, key + len - pos);
    if (!end)
      return NULL;
  } else {
    const u8 *pos2;
    pos += os_strlen(pem_key_begin);
    end = search_tag(pem_key_end, pos, key + len - pos);
    if (!end)
      return NULL;
    pos2 = search_tag("Proc-Type: 4,ENCRYPTED", pos, end - pos);
    if (pos2) {
      wpa_printf(MSG_DEBUG, "TLSv1: Unsupported private key "
           "format (Proc-Type/DEK-Info)");
      return NULL;
    }
  }

  der = base64_decode((const char *) pos, end - pos, &der_len);
  if (!der)
    return NULL;
  pkey = crypto_private_key_import(der, der_len, NULL);
  os_free(der);
  return pkey;
}


static struct crypto_private_key * tlsv1_set_key_enc_pem(const u8 *key,
               size_t len,
               const char *passwd)
{
  const u8 *pos, *end;
  unsigned char *der;
  size_t der_len;
  struct crypto_private_key *pkey;

  if (passwd == NULL)
    return NULL;
  pos = search_tag(pem_key_enc_begin, key, len);
  if (!pos)
    return NULL;
  pos += os_strlen(pem_key_enc_begin);
  end = search_tag(pem_key_enc_end, pos, key + len - pos);
  if (!end)
    return NULL;

  der = base64_decode((const char *) pos, end - pos, &der_len);
  if (!der)
    return NULL;
  pkey = crypto_private_key_import(der, der_len, passwd);
  os_free(der);
  return pkey;
}


#ifdef PKCS12_FUNCS

static int oid_is_rsadsi(struct asn1_oid *oid)
{
  return oid->len >= 4 &&
    oid->oid[0] == 1 /* iso */ &&
    oid->oid[1] == 2 /* member-body */ &&
    oid->oid[2] == 840 /* us */ &&
    oid->oid[3] == 113549 /* rsadsi */;
}


static int pkcs12_is_bagtype_oid(struct asn1_oid *oid, unsigned long type)
{
  return oid->len == 9 &&
    oid_is_rsadsi(oid) &&
    oid->oid[4] == 1 /* pkcs */ &&
    oid->oid[5] == 12 /* pkcs-12 */ &&
    oid->oid[6] == 10 &&
    oid->oid[7] == 1 /* bagtypes */ &&
    oid->oid[8] == type;
}


static int is_oid_pkcs7(struct asn1_oid *oid)
{
  return oid->len == 7 &&
    oid->oid[0] == 1 /* iso */ &&
    oid->oid[1] == 2 /* member-body */ &&
    oid->oid[2] == 840 /* us */ &&
    oid->oid[3] == 113549 /* rsadsi */ &&
    oid->oid[4] == 1 /* pkcs */ &&
    oid->oid[5] == 7 /* pkcs-7 */;
}


static int is_oid_pkcs7_data(struct asn1_oid *oid)
{
  return is_oid_pkcs7(oid) && oid->oid[6] == 1 /* data */;
}


static int is_oid_pkcs7_enc_data(struct asn1_oid *oid)
{
  return is_oid_pkcs7(oid) && oid->oid[6] == 6 /* encryptedData */;
}


static int is_oid_pkcs9(struct asn1_oid *oid)
{
  return oid->len >= 6 &&
    oid->oid[0] == 1 /* iso */ &&
    oid->oid[1] == 2 /* member-body */ &&
    oid->oid[2] == 840 /* us */ &&
    oid->oid[3] == 113549 /* rsadsi */ &&
    oid->oid[4] == 1 /* pkcs */ &&
    oid->oid[5] == 9 /* pkcs-9 */;
}


static int is_oid_pkcs9_friendly_name(struct asn1_oid *oid)
{
  return oid->len == 7 && is_oid_pkcs9(oid) &&
    oid->oid[6] == 20;
}


static int is_oid_pkcs9_local_key_id(struct asn1_oid *oid)
{
  return oid->len == 7 && is_oid_pkcs9(oid) &&
    oid->oid[6] == 21;
}


static int is_oid_pkcs9_x509_cert(struct asn1_oid *oid)
{
  return oid->len == 8 && is_oid_pkcs9(oid) &&
    oid->oid[6] == 22 /* certTypes */ &&
    oid->oid[7] == 1 /* x509Certificate */;
}


static int pkcs12_keybag(struct tlsv1_credentials *cred,
       const u8 *buf, size_t len)
{
  /* TODO */
  return 0;
}


static int pkcs12_pkcs8_keybag(struct tlsv1_credentials *cred,
             const u8 *buf, size_t len,
             const char *passwd)
{
  struct crypto_private_key *key;

  /* PKCS8ShroudedKeyBag ::= EncryptedPrivateKeyInfo */
  key = pkcs8_enc_key_import(buf, len, passwd);
  if (!key)
    return -1;

  wpa_printf(MSG_DEBUG,
       "PKCS #12: Successfully decrypted PKCS8ShroudedKeyBag");
  crypto_private_key_free(cred->key);
  cred->key = key;

  return 0;
}


static int pkcs12_certbag(struct tlsv1_credentials *cred,
        const u8 *buf, size_t len)
{
  struct asn1_hdr hdr;
  struct asn1_oid oid;
  char obuf[80];
  const u8 *pos, *end;

  /*
   * CertBag ::= SEQUENCE {
   *     certId      BAG-TYPE.&id   ({CertTypes}),
   *     certValue   [0] EXPLICIT BAG-TYPE.&Type ({CertTypes}{@certId})
   * }
   */

  if (asn1_get_next(buf, len, &hdr) < 0 || !asn1_is_sequence(&hdr)) {
    asn1_unexpected(&hdr, "PKCS #12: Expected SEQUENCE (CertBag)");
    return -1;
  }

  pos = hdr.payload;
  end = hdr.payload + hdr.length;

  if (asn1_get_oid(pos, end - pos, &oid, &pos)) {
    wpa_printf(MSG_DEBUG,
         "PKCS #12: Failed to parse OID (certId)");
    return -1;
  }

  asn1_oid_to_str(&oid, obuf, sizeof(obuf));
  wpa_printf(MSG_DEBUG, "PKCS #12: certId %s", obuf);

  if (!is_oid_pkcs9_x509_cert(&oid)) {
    wpa_printf(MSG_DEBUG,
         "PKCS #12: Ignored unsupported certificate type (certId %s)",
         obuf);
  }

  if (asn1_get_next(pos, end - pos, &hdr) < 0 || !hdr.constructed ||
      !asn1_is_cs_tag(&hdr, 0)) {
    asn1_unexpected(&hdr,
        "PKCS #12: Expected [0] EXPLICIT (certValue)");
    return -1;
  }

  if (asn1_get_next(hdr.payload, hdr.length, &hdr) < 0 ||
      !asn1_is_octetstring(&hdr)) {
    asn1_unexpected(&hdr,
        "PKCS #12: Expected OCTET STRING (x509Certificate)");
    return -1;
  }

  wpa_hexdump(MSG_DEBUG, "PKCS #12: x509Certificate",
        hdr.payload, hdr.length);
  if (cred->cert) {
    struct x509_certificate *cert;

    wpa_printf(MSG_DEBUG, "PKCS #12: Ignore extra certificate");
    cert = x509_certificate_parse(hdr.payload, hdr.length);
    if (!cert) {
      wpa_printf(MSG_DEBUG,
           "PKCS #12: Failed to parse x509Certificate");
      return 0;
    }
    x509_certificate_chain_free(cert);

    return 0;
  }
  return tlsv1_set_cert(cred, NULL, hdr.payload, hdr.length);
}


static int pkcs12_parse_attr_friendly_name(const u8 *pos, const u8 *end)
{
  struct asn1_hdr hdr;

  /*
   * RFC 2985, 5.5.1:
   * friendlyName ATTRIBUTE ::= {
   *         WITH SYNTAX BMPString (SIZE(1..pkcs-9-ub-friendlyName))
   *         EQUALITY MATCHING RULE caseIgnoreMatch
   *         SINGLE VALUE TRUE
   *          ID pkcs-9-at-friendlyName
   * }
   */
  if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
      !asn1_is_bmpstring(&hdr)) {
    asn1_unexpected(&hdr,
        "PKCS #12: Expected BMPSTRING (friendlyName)");
    return 0;
  }
  wpa_hexdump_ascii(MSG_DEBUG, "PKCS #12: friendlyName",
        hdr.payload, hdr.length);
  return 0;
}


static int pkcs12_parse_attr_local_key_id(const u8 *pos, const u8 *end)
{
  struct asn1_hdr hdr;

  /*
   * RFC 2985, 5.5.2:
   * localKeyId ATTRIBUTE ::= {
   *         WITH SYNTAX OCTET STRING
   *         EQUALITY MATCHING RULE octetStringMatch
   *         SINGLE VALUE TRUE
   *         ID pkcs-9-at-localKeyId
   * }
   */
  if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
      !asn1_is_octetstring(&hdr)) {
    asn1_unexpected(&hdr,
        "PKCS #12: Expected OCTET STRING (localKeyID)");
    return -1;
  }
  wpa_hexdump_key(MSG_DEBUG, "PKCS #12: localKeyID",
      hdr.payload, hdr.length);
  return 0;
}


static int pkcs12_parse_attr(const u8 *pos, size_t len)
{
  const u8 *end = pos + len;
  struct asn1_hdr hdr;
  struct asn1_oid a_oid;
  char obuf[80];

  /*
   * PKCS12Attribute ::= SEQUENCE {
   * attrId      ATTRIBUTE.&id ({PKCS12AttrSet}),
   * attrValues  SET OF ATTRIBUTE.&Type ({PKCS12AttrSet}{@attrId})
   * }
   */

  if (asn1_get_oid(pos, end - pos, &a_oid, &pos)) {
    wpa_printf(MSG_DEBUG, "PKCS #12: Failed to parse OID (attrId)");
    return -1;
  }

  asn1_oid_to_str(&a_oid, obuf, sizeof(obuf));
  wpa_printf(MSG_DEBUG, "PKCS #12: attrId %s", obuf);

  if (asn1_get_next(pos, end - pos, &hdr) < 0 || !asn1_is_set(&hdr)) {
    asn1_unexpected(&hdr, "PKCS #12: Expected SET (attrValues)");
    return -1;
  }
  wpa_hexdump_key(MSG_MSGDUMP, "PKCS #12: attrValues",
      hdr.payload, hdr.length);
  pos = hdr.payload;
  end = hdr.payload + hdr.length;

  if (is_oid_pkcs9_friendly_name(&a_oid))
    return pkcs12_parse_attr_friendly_name(pos, end);
  if (is_oid_pkcs9_local_key_id(&a_oid))
    return pkcs12_parse_attr_local_key_id(pos, end);

  wpa_printf(MSG_DEBUG, "PKCS #12: Ignore unknown attribute");
  return 0;
}


static int pkcs12_safebag(struct tlsv1_credentials *cred,
        const u8 *buf, size_t len, const char *passwd)
{
  struct asn1_hdr hdr;
  struct asn1_oid oid;
  char obuf[80];
  const u8 *pos = buf, *end = buf + len;
  const u8 *value;
  size_t value_len;

  wpa_hexdump_key(MSG_MSGDUMP, "PKCS #12: SafeBag", buf, len);

  /* BAG-TYPE ::= TYPE-IDENTIFIER */
  if (asn1_get_oid(pos, end - pos, &oid, &pos)) {
    wpa_printf(MSG_DEBUG,
         "PKCS #12: Failed to parse OID (BAG-TYPE)");
    return -1;
  }

  asn1_oid_to_str(&oid, obuf, sizeof(obuf));
  wpa_printf(MSG_DEBUG, "PKCS #12: BAG-TYPE %s", obuf);

  if (asn1_get_next(pos, end - pos, &hdr) < 0 || !hdr.constructed ||
      !asn1_is_cs_tag(&hdr, 0)) {
    asn1_unexpected(&hdr,
        "PKCS #12: Expected [0] EXPLICIT (bagValue)");
    return 0;
  }
  value = hdr.payload;
  value_len = hdr.length;
  wpa_hexdump_key(MSG_MSGDUMP, "PKCS #12: bagValue", value, value_len);
  pos = hdr.payload + hdr.length;

  if (pos < end) {
    /* bagAttributes  SET OF PKCS12Attribute OPTIONAL */
    if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
        !asn1_is_set(&hdr)) {
      asn1_unexpected(&hdr,
          "PKCS #12: Expected SET (bagAttributes)");
      return -1;
    }
    wpa_hexdump_key(MSG_MSGDUMP, "PKCS #12: bagAttributes",
        hdr.payload, hdr.length);

    pos = hdr.payload;
    end = hdr.payload + hdr.length;
    while (pos < end) {
      /* PKCS12Attribute ::= SEQUENCE */
      if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
          !asn1_is_sequence(&hdr)) {
        asn1_unexpected(&hdr,
            "PKCS #12: Expected SEQUENCE (PKCS12Attribute)");
        return -1;
      }
      if (pkcs12_parse_attr(hdr.payload, hdr.length) < 0)
        return -1;
      pos = hdr.payload + hdr.length;
    }
  }

  if (pkcs12_is_bagtype_oid(&oid, 1))
    return pkcs12_keybag(cred, value, value_len);
  if (pkcs12_is_bagtype_oid(&oid, 2))
    return pkcs12_pkcs8_keybag(cred, value, value_len, passwd);
  if (pkcs12_is_bagtype_oid(&oid, 3))
    return pkcs12_certbag(cred, value, value_len);

  wpa_printf(MSG_DEBUG, "PKCS #12: Ignore unsupported BAG-TYPE");
  return 0;
}


static int pkcs12_safecontents(struct tlsv1_credentials *cred,
             const u8 *buf, size_t len,
             const char *passwd)
{
  struct asn1_hdr hdr;
  const u8 *pos, *end;

  /* SafeContents ::= SEQUENCE OF SafeBag */
  if (asn1_get_next(buf, len, &hdr) < 0 || !asn1_is_sequence(&hdr)) {
    asn1_unexpected(&hdr,
        "PKCS #12: Expected SEQUENCE (SafeContents)");
    return -1;
  }
  pos = hdr.payload;
  end = hdr.payload + hdr.length;

  /*
   * SafeBag ::= SEQUENCE {
   *   bagId          BAG-TYPE.&id ({PKCS12BagSet})
   *   bagValue       [0] EXPLICIT BAG-TYPE.&Type({PKCS12BagSet}{@bagId}),
   *   bagAttributes  SET OF PKCS12Attribute OPTIONAL
   * }
   */

  while (pos < end) {
    if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
        !asn1_is_sequence(&hdr)) {
      asn1_unexpected(&hdr,
          "PKCS #12: Expected SEQUENCE (SafeBag)");
      return -1;
    }
    if (pkcs12_safebag(cred, hdr.payload, hdr.length, passwd) < 0)
      return -1;
    pos = hdr.payload + hdr.length;
  }

  return 0;
}


static int pkcs12_parse_content_data(struct tlsv1_credentials *cred,
             const u8 *pos, const u8 *end,
             const char *passwd)
{
  struct asn1_hdr hdr;

  /* Data ::= OCTET STRING */
  if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
      !asn1_is_octetstring(&hdr)) {
    asn1_unexpected(&hdr, "PKCS #12: Expected OCTET STRING (Data)");
    return -1;
  }

  wpa_hexdump(MSG_MSGDUMP, "PKCS #12: Data", hdr.payload, hdr.length);

  return pkcs12_safecontents(cred, hdr.payload, hdr.length, passwd);
}


static int pkcs12_parse_content_enc_data(struct tlsv1_credentials *cred,
           const u8 *pos, const u8 *end,
           const char *passwd)
{
  struct asn1_hdr hdr;
  struct asn1_oid oid;
  char buf[80];
  const u8 *enc_alg;
  u8 *data;
  size_t enc_alg_len, data_len;
  int res = -1;

  /*
   * EncryptedData ::= SEQUENCE {
   *   version Version,
   *   encryptedContentInfo EncryptedContentInfo }
   */
  if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
      !asn1_is_sequence(&hdr)) {
    asn1_unexpected(&hdr,
        "PKCS #12: Expected SEQUENCE (EncryptedData)");
    return 0;
  }
  pos = hdr.payload;

  /* Version ::= INTEGER */
  if (asn1_get_next(pos, end - pos, &hdr) < 0 || !asn1_is_integer(&hdr)) {
    asn1_unexpected(&hdr,
        "PKCS #12: No INTEGER tag found for version");
    return -1;
  }
  if (hdr.length != 1 || hdr.payload[0] != 0) {
    wpa_printf(MSG_DEBUG, "PKCS #12: Unrecognized PKCS #7 version");
    return -1;
  }
  pos = hdr.payload + hdr.length;

  wpa_hexdump(MSG_MSGDUMP, "PKCS #12: EncryptedContentInfo",
        pos, end - pos);

  /*
   * EncryptedContentInfo ::= SEQUENCE {
   *   contentType ContentType,
   *   contentEncryptionAlgorithm ContentEncryptionAlgorithmIdentifier,
   *   encryptedContent [0] IMPLICIT EncryptedContent OPTIONAL }
   */
  if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
      !asn1_is_sequence(&hdr)) {
    asn1_unexpected(&hdr,
        "PKCS #12: Expected SEQUENCE (EncryptedContentInfo)");
    return -1;
  }

  pos = hdr.payload;
  end = pos + hdr.length;

  /* ContentType ::= OBJECT IDENTIFIER */
  if (asn1_get_oid(pos, end - pos, &oid, &pos)) {
    wpa_printf(MSG_DEBUG,
         "PKCS #12: Could not find OBJECT IDENTIFIER (contentType)");
    return -1;
  }
  asn1_oid_to_str(&oid, buf, sizeof(buf));
  wpa_printf(MSG_DEBUG, "PKCS #12: EncryptedContentInfo::contentType %s",
       buf);

  if (!is_oid_pkcs7_data(&oid)) {
    wpa_printf(MSG_DEBUG,
         "PKCS #12: Unsupported EncryptedContentInfo::contentType %s",
         buf);
    return 0;
  }

  /* ContentEncryptionAlgorithmIdentifier ::= AlgorithmIdentifier */
  if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
      !asn1_is_sequence(&hdr)) {
    asn1_unexpected(&hdr,
        "PKCS #12: Expected SEQUENCE (ContentEncryptionAlgorithmIdentifier)");
    return -1;
  }
  enc_alg = hdr.payload;
  enc_alg_len = hdr.length;
  pos = hdr.payload + hdr.length;

  if (asn1_get_next(pos, end - pos, &hdr) < 0 || hdr.constructed ||
      !asn1_is_cs_tag(&hdr, 0)) {
    asn1_unexpected(&hdr,
        "PKCS #12: Expected [0] IMPLICIT (encryptedContent)");
    return -1;
  }

  /* EncryptedContent ::= OCTET STRING */
  data = pkcs5_decrypt(enc_alg, enc_alg_len, hdr.payload, hdr.length,
           passwd, &data_len);
  if (data) {
    wpa_hexdump_key(MSG_MSGDUMP,
        "PKCS #12: Decrypted encryptedContent",
        data, data_len);
    res = pkcs12_safecontents(cred, data, data_len, passwd);
    os_free(data);
  }

  return res;
}


static int pkcs12_parse_content(struct tlsv1_credentials *cred,
        const u8 *buf, size_t len,
        const char *passwd)
{
  const u8 *pos = buf;
  const u8 *end = buf + len;
  struct asn1_oid oid;
  char txt[80];
  struct asn1_hdr hdr;

  wpa_hexdump(MSG_MSGDUMP, "PKCS #12: ContentInfo", buf, len);

  if (asn1_get_oid(pos, end - pos, &oid, &pos)) {
    wpa_printf(MSG_DEBUG,
         "PKCS #12: Could not find OBJECT IDENTIFIER (contentType)");
    return 0;
  }

  asn1_oid_to_str(&oid, txt, sizeof(txt));
  wpa_printf(MSG_DEBUG, "PKCS #12: contentType %s", txt);

  if (asn1_get_next(pos, end - pos, &hdr) < 0 || !hdr.constructed ||
      !asn1_is_cs_tag(&hdr, 0)) {
    asn1_unexpected(&hdr,
        "PKCS #12: Expected [0] EXPLICIT (content)");
    return 0;
  }
  pos = hdr.payload;

  if (is_oid_pkcs7_data(&oid))
    return pkcs12_parse_content_data(cred, pos, end, passwd);
  if (is_oid_pkcs7_enc_data(&oid))
    return pkcs12_parse_content_enc_data(cred, pos, end, passwd);

  wpa_printf(MSG_DEBUG, "PKCS #12: Ignored unsupported contentType %s",
       txt);

  return 0;
}


static int pkcs12_parse(struct tlsv1_credentials *cred,
      const u8 *key, size_t len, const char *passwd)
{
  struct asn1_hdr hdr;
  const u8 *pos, *end;
  struct asn1_oid oid;
  char buf[80];

  /*
   * PFX ::= SEQUENCE {
   *     version     INTEGER {v3(3)}(v3,...),
   *     authSafe    ContentInfo,
   *     macData     MacData OPTIONAL
   * }
   */

  if (asn1_get_next(key, len, &hdr) < 0 || !asn1_is_sequence(&hdr)) {
    asn1_unexpected(&hdr,
        "PKCS #12: Expected SEQUENCE (PFX); assume PKCS #12 not used");
    return -1;
  }

  pos = hdr.payload;
  end = pos + hdr.length;

  if (asn1_get_next(pos, end - pos, &hdr) < 0 || !asn1_is_integer(&hdr)) {
    asn1_unexpected(&hdr,
        "PKCS #12: No INTEGER tag found for version");
    return -1;
  }
  if (hdr.length != 1 || hdr.payload[0] != 3) {
    wpa_printf(MSG_DEBUG, "PKCS #12: Unrecognized version");
    return -1;
  }
  pos = hdr.payload + hdr.length;

  /*
   * ContentInfo ::= SEQUENCE {
   *   contentType ContentType,
   *   content [0] EXPLICIT ANY DEFINED BY contentType OPTIONAL }
   */

  if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
      !asn1_is_sequence(&hdr)) {
    asn1_unexpected(&hdr,
        "PKCS #12: Expected SEQUENCE (authSafe); assume PKCS #12 not used");
    return -1;
  }

  pos = hdr.payload;
  end = pos + hdr.length;

  /* ContentType ::= OBJECT IDENTIFIER */
  if (asn1_get_oid(pos, end - pos, &oid, &pos)) {
    wpa_printf(MSG_DEBUG,
         "PKCS #12: Could not find OBJECT IDENTIFIER (contentType); assume PKCS #12 not used");
    return -1;
  }
  asn1_oid_to_str(&oid, buf, sizeof(buf));
  wpa_printf(MSG_DEBUG, "PKCS #12: contentType %s", buf);
  if (!is_oid_pkcs7_data(&oid)) {
    wpa_printf(MSG_DEBUG, "PKCS #12: Unsupported contentType %s",
         buf);
    return -1;
  }

  if (asn1_get_next(pos, end - pos, &hdr) < 0 || !hdr.constructed ||
      !asn1_is_cs_tag(&hdr, 0)) {
    asn1_unexpected(&hdr,
        "PKCS #12: Expected [0] EXPLICIT (content); assume PKCS #12 not used");
    return -1;
  }

  pos = hdr.payload;

  /* Data ::= OCTET STRING */
  if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
      !asn1_is_octetstring(&hdr)) {
    asn1_unexpected(&hdr,
        "PKCS #12: Expected OCTET STRING (Data); assume PKCS #12 not used");
    return -1;
  }

  /*
   * AuthenticatedSafe ::= SEQUENCE OF ContentInfo
   *     -- Data if unencrypted
   *     -- EncryptedData if password-encrypted
   *     -- EnvelopedData if public key-encrypted
   */
  wpa_hexdump(MSG_MSGDUMP, "PKCS #12: Data content",
        hdr.payload, hdr.length);

  if (asn1_get_next(hdr.payload, hdr.length, &hdr) < 0 ||
      !asn1_is_sequence(&hdr)) {
    asn1_unexpected(&hdr,
        "PKCS #12: Expected SEQUENCE within Data content; assume PKCS #12 not used");
    return -1;
  }

  pos = hdr.payload;
  end = pos + hdr.length;

  while (end > pos) {
    if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
        !asn1_is_sequence(&hdr)) {
      asn1_unexpected(&hdr,
          "PKCS #12: Expected SEQUENCE (ContentInfo); assume PKCS #12 not used");
      return -1;
    }
    if (pkcs12_parse_content(cred, hdr.payload, hdr.length,
           passwd) < 0)
      return -1;

    pos = hdr.payload + hdr.length;
  }

  return 0;
}

#endif /* PKCS12_FUNCS */


static int tlsv1_set_key(struct tlsv1_credentials *cred,
       const u8 *key, size_t len, const char *passwd)
{
  cred->key = crypto_private_key_import(key, len, passwd);
  if (cred->key == NULL)
    cred->key = tlsv1_set_key_pem(key, len);
  if (cred->key == NULL)
    cred->key = tlsv1_set_key_enc_pem(key, len, passwd);
#ifdef PKCS12_FUNCS
  if (!cred->key)
    pkcs12_parse(cred, key, len, passwd);
#endif /* PKCS12_FUNCS */
  if (cred->key == NULL) {
    wpa_printf(MSG_INFO, "TLSv1: Failed to parse private key");
    return -1;
  }
  return 0;
}


/**
 * tlsv1_set_private_key - Set private key
 * @cred: TLSv1 credentials from tlsv1_cred_alloc()
 * @private_key: File or reference name for the key in PEM or DER format
 * @private_key_passwd: Passphrase for decrypted private key, %NULL if no
 * passphrase is used.
 * @private_key_blob: private_key as inlined data or %NULL if not used
 * @private_key_blob_len: private_key_blob length
 * Returns: 0 on success, -1 on failure
 */
int tlsv1_set_private_key(struct tlsv1_credentials *cred,
        const char *private_key,
        const char *private_key_passwd,
        const u8 *private_key_blob,
        size_t private_key_blob_len)
{
  crypto_private_key_free(cred->key);
  cred->key = NULL;

  if (private_key_blob)
    return tlsv1_set_key(cred, private_key_blob,
             private_key_blob_len,
             private_key_passwd);

  if (private_key) {
    u8 *buf;
    size_t len;
    int ret;

    buf = (u8 *) os_readfile(private_key, &len);
    if (buf == NULL) {
      wpa_printf(MSG_INFO, "TLSv1: Failed to read '%s'",
           private_key);
      return -1;
    }

    ret = tlsv1_set_key(cred, buf, len, private_key_passwd);
    os_free(buf);
    return ret;
  }

  return 0;
}


static int tlsv1_set_dhparams_der(struct tlsv1_credentials *cred,
          const u8 *dh, size_t len)
{
  struct asn1_hdr hdr;
  const u8 *pos, *end;

  pos = dh;
  end = dh + len;

  /*
   * DHParameter ::= SEQUENCE {
   *   prime INTEGER, -- p
   *   base INTEGER, -- g
   *   privateValueLength INTEGER OPTIONAL }
   */

  /* DHParamer ::= SEQUENCE */
  if (asn1_get_next(pos, len, &hdr) < 0 || !asn1_is_sequence(&hdr)) {
    asn1_unexpected(&hdr,
        "DH: DH parameters did not start with a valid SEQUENCE");
    return -1;
  }
  pos = hdr.payload;

  /* prime INTEGER */
  if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
      !asn1_is_integer(&hdr)) {
    asn1_unexpected(&hdr, "DH: No INTEGER tag found for p");
    return -1;
  }

  wpa_hexdump(MSG_MSGDUMP, "DH: prime (p)", hdr.payload, hdr.length);
  if (hdr.length == 0)
    return -1;
  os_free(cred->dh_p);
  cred->dh_p = os_memdup(hdr.payload, hdr.length);
  if (cred->dh_p == NULL)
    return -1;
  cred->dh_p_len = hdr.length;
  pos = hdr.payload + hdr.length;

  /* base INTEGER */
  if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
      !asn1_is_integer(&hdr)) {
    asn1_unexpected(&hdr, "DH: No INTEGER tag found for g");
    return -1;
  }

  wpa_hexdump(MSG_MSGDUMP, "DH: base (g)", hdr.payload, hdr.length);
  if (hdr.length == 0)
    return -1;
  os_free(cred->dh_g);
  cred->dh_g = os_memdup(hdr.payload, hdr.length);
  if (cred->dh_g == NULL)
    return -1;
  cred->dh_g_len = hdr.length;

  return 0;
}


static const char *pem_dhparams_begin = "-----BEGIN DH PARAMETERS-----";
static const char *pem_dhparams_end = "-----END DH PARAMETERS-----";


static int tlsv1_set_dhparams_blob(struct tlsv1_credentials *cred,
           const u8 *buf, size_t len)
{
  const u8 *pos, *end;
  unsigned char *der;
  size_t der_len;

  pos = search_tag(pem_dhparams_begin, buf, len);
  if (!pos) {
    wpa_printf(MSG_DEBUG, "TLSv1: No PEM dhparams tag found - "
         "assume DER format");
    return tlsv1_set_dhparams_der(cred, buf, len);
  }

  wpa_printf(MSG_DEBUG, "TLSv1: Converting PEM format dhparams into DER "
       "format");

  pos += os_strlen(pem_dhparams_begin);
  end = search_tag(pem_dhparams_end, pos, buf + len - pos);
  if (end == NULL) {
    wpa_printf(MSG_INFO, "TLSv1: Could not find PEM dhparams end "
         "tag (%s)", pem_dhparams_end);
    return -1;
  }

  der = base64_decode((const char *) pos, end - pos, &der_len);
  if (der == NULL) {
    wpa_printf(MSG_INFO, "TLSv1: Could not decode PEM dhparams");
    return -1;
  }

  if (tlsv1_set_dhparams_der(cred, der, der_len) < 0) {
    wpa_printf(MSG_INFO, "TLSv1: Failed to parse PEM dhparams "
         "DER conversion");
    os_free(der);
    return -1;
  }

  os_free(der);

  return 0;
}


/**
 * tlsv1_set_dhparams - Set Diffie-Hellman parameters
 * @cred: TLSv1 credentials from tlsv1_cred_alloc()
 * @dh_file: File or reference name for the DH params in PEM or DER format
 * @dh_blob: DH params as inlined data or %NULL if not used
 * @dh_blob_len: dh_blob length
 * Returns: 0 on success, -1 on failure
 */
int tlsv1_set_dhparams(struct tlsv1_credentials *cred, const char *dh_file,
           const u8 *dh_blob, size_t dh_blob_len)
{
  if (dh_blob)
    return tlsv1_set_dhparams_blob(cred, dh_blob, dh_blob_len);

  if (dh_file) {
    u8 *buf;
    size_t len;
    int ret;

    buf = (u8 *) os_readfile(dh_file, &len);
    if (buf == NULL) {
      wpa_printf(MSG_INFO, "TLSv1: Failed to read '%s'",
           dh_file);
      return -1;
    }

    ret = tlsv1_set_dhparams_blob(cred, buf, len);
    os_free(buf);
    return ret;
  }

  return 0;
}

Coverage Report

Created: 2025-04-24 06:18