Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-tls

Source of release 0.7.0

0.7.0 / src / certificate.lucb

## A strict X.509 v3 certificate parser (RFC 5280) for TLS path validation.
## It records byte ranges into the DER rather than copying: the signed TBS, the
## signature algorithm and value, issuer and subject Names, validity, the
## subject public key, and the extensions path validation uses (basic
## constraints, key usage, extended key usage, subject alternative names).
## Unknown critical extensions and name constraints are rejected; a critical
## certificatePolicies extension is accepted only with CPS-pointer qualifiers.
import der
import signature

pub let invalid = der.invalid
pub let max_certificate_bytes: usize = 16384

## A parsed certificate; ranges index the DER it was parsed from.
pub struct Certificate:
    pub var tbs_start: usize
    pub var tbs_end: usize
    pub var algorithm: u8
    pub var signature_start: usize
    pub var signature_end: usize
    pub var issuer_start: usize
    pub var issuer_end: usize
    pub var subject_start: usize
    pub var subject_end: usize
    pub var not_before: i64
    pub var not_after: i64
    pub var key_kind: u8
    var key_a_start: usize
    var key_a_end: usize
    var key_b_start: usize
    var key_b_end: usize
    pub var san_start: usize
    pub var san_end: usize
    pub var basic_present: bool
    pub var is_ca: bool
    pub var path_len_present: bool
    pub var path_len: usize
    pub var key_usage_present: bool
    pub var digital_signature: bool
    pub var key_cert_sign: bool
    pub var eku_present: bool
    pub var server_auth: bool

    ## The subject public key.
    pub func public_key(bytes: const u8[]) -> signature.PublicKey!:
        let a = bytes[self.key_a_start..<self.key_a_end]
        let b = bytes[self.key_b_start..<self.key_b_end]
        if self.key_kind == signature.key_p256:
            return try signature.PublicKey.p256(a, b)
        if self.key_kind == signature.key_p384:
            return try signature.PublicKey.p384(a, b)
        return try signature.PublicKey.rsa(a, b)

    ## The issuer Name as encoded.
    pub func issuer(bytes: const u8[]) -> const u8[]:
        return bytes[self.issuer_start..<self.issuer_end]

    ## The subject Name as encoded.
    pub func subject(bytes: const u8[]) -> const u8[]:
        return bytes[self.subject_start..<self.subject_end]

    ## Whether issuer and subject are the same Name (RFC 5280 self-issued).
    pub func self_issued(bytes: const u8[]) -> bool:
        return self.issuer(bytes) == self.subject(bytes)

    ## Whether `now` lies within the validity period, inclusive.
    pub func valid_at(now: i64) -> bool:
        return now >= self.not_before and now <= self.not_after

    ## Verify this certificate's signature with the issuer's key.
    pub func signed_by(bytes: const u8[], key: const signature.PublicKey*) -> bool!:
        return try signature.verify(key, self.algorithm, bytes[self.tbs_start..<self.tbs_end],
            bytes[self.signature_start..<self.signature_end])

## Object identifiers (content bytes).
let oid_sha256_rsa = b"\x2a\x86\x48\x86\xf7\x0d\x01\x01\x0b"
let oid_sha384_rsa = b"\x2a\x86\x48\x86\xf7\x0d\x01\x01\x0c"
let oid_sha512_rsa = b"\x2a\x86\x48\x86\xf7\x0d\x01\x01\x0d"
let oid_rsa_pss = b"\x2a\x86\x48\x86\xf7\x0d\x01\x01\x0a"
let oid_mgf1 = b"\x2a\x86\x48\x86\xf7\x0d\x01\x01\x08"
let oid_rsa = b"\x2a\x86\x48\x86\xf7\x0d\x01\x01\x01"
let oid_sha224_rsa = b"\x2a\x86\x48\x86\xf7\x0d\x01\x01\x0e"
let oid_ecdsa_sha224 = b"\x2a\x86\x48\xce\x3d\x04\x03\x01"
let oid_ecdsa_sha256 = b"\x2a\x86\x48\xce\x3d\x04\x03\x02"
let oid_ecdsa_sha384 = b"\x2a\x86\x48\xce\x3d\x04\x03\x03"
let oid_ecdsa_sha512 = b"\x2a\x86\x48\xce\x3d\x04\x03\x04"
let oid_ec_public = b"\x2a\x86\x48\xce\x3d\x02\x01"
let oid_p256 = b"\x2a\x86\x48\xce\x3d\x03\x01\x07"
let oid_p384 = b"\x2b\x81\x04\x00\x22"
let oid_sha256 = b"\x60\x86\x48\x01\x65\x03\x04\x02\x01"
let oid_sha384 = b"\x60\x86\x48\x01\x65\x03\x04\x02\x02"
let oid_sha512 = b"\x60\x86\x48\x01\x65\x03\x04\x02\x03"
let oid_server_auth = b"\x2b\x06\x01\x05\x05\x07\x03\x01"
let oid_any_eku = b"\x55\x1d\x25\x00"

## Parse an AlgorithmIdentifier for a certificate signature, returning the
## signature algorithm, or zero for one this client does not verify.
func parse_algorithm(bytes: const u8[], element: der.Element) -> u8!:
    let oid = try der.expect(bytes, element.content, element.end(), 0x06)
    let has_parameters = oid.next != element.end()
    var rsa_kind: u8 = 0
    if der.oid_is(bytes, oid, oid_ecdsa_sha224) or der.oid_is(bytes, oid, oid_ecdsa_sha256) or der.oid_is(bytes, oid, oid_ecdsa_sha384) or der.oid_is(bytes, oid, oid_ecdsa_sha512):
        if has_parameters:
            error(invalid, "ECDSA AlgorithmIdentifier has parameters")
        if der.oid_is(bytes, oid, oid_ecdsa_sha224): return signature.ecdsa_sha224
        if der.oid_is(bytes, oid, oid_ecdsa_sha256): return signature.ecdsa_sha256
        if der.oid_is(bytes, oid, oid_ecdsa_sha384): return signature.ecdsa_sha384
        return signature.ecdsa_sha512
    if der.oid_is(bytes, oid, oid_sha224_rsa): rsa_kind = signature.rsa_pkcs1_sha224
    elif der.oid_is(bytes, oid, oid_sha256_rsa): rsa_kind = signature.rsa_pkcs1_sha256
    elif der.oid_is(bytes, oid, oid_sha384_rsa): rsa_kind = signature.rsa_pkcs1_sha384
    elif der.oid_is(bytes, oid, oid_sha512_rsa): rsa_kind = signature.rsa_pkcs1_sha512
    if rsa_kind != 0:
        if has_parameters:
            let null = try der.read(bytes, oid.next, element.end())
            if null.tag != 0x05 or null.length != 0 or null.next != element.end():
                error(invalid, "RSA AlgorithmIdentifier parameters are not NULL")
        return rsa_kind
    if der.oid_is(bytes, oid, oid_rsa_pss):
        return try parse_pss(bytes, oid.next, element.end())
    return 0

## RSASSA-PSS-params (RFC 4055 ยง3.1) with explicit SHA-256/384/512, MGF1 over
## the same hash and a salt as long as the hash; zero for anything else.
func parse_pss(bytes: const u8[], at: usize, limit: usize) -> u8!:
    let params = try der.expect(bytes, at, limit, 0x30)
    var pos = params.content
    if pos >= params.end() or bytes[pos] != 0xa0:
        return 0
    let hash_field = try der.expect(bytes, pos, params.end(), 0xa0)
    let hash_algorithm = try der.expect(bytes, hash_field.content, hash_field.end(), 0x30)
    let hash_oid = try der.expect(bytes, hash_algorithm.content, hash_algorithm.end(), 0x06)
    var kind: u8 = 0
    var size: usize = 0
    if der.oid_is(bytes, hash_oid, oid_sha256):
        kind = signature.rsa_pss_sha256
        size = 32
    elif der.oid_is(bytes, hash_oid, oid_sha384):
        kind = signature.rsa_pss_sha384
        size = 48
    elif der.oid_is(bytes, hash_oid, oid_sha512):
        kind = signature.rsa_pss_sha512
        size = 64
    else:
        return 0
    pos = hash_field.next
    if pos >= params.end() or bytes[pos] != 0xa1:
        return 0
    let mgf_field = try der.expect(bytes, pos, params.end(), 0xa1)
    let mgf = try der.expect(bytes, mgf_field.content, mgf_field.end(), 0x30)
    let mgf_oid = try der.expect(bytes, mgf.content, mgf.end(), 0x06)
    let mgf_hash = try der.expect(bytes, mgf_oid.next, mgf.end(), 0x30)
    let mgf_hash_oid = try der.expect(bytes, mgf_hash.content, mgf_hash.end(), 0x06)
    if not der.oid_is(bytes, mgf_oid, oid_mgf1) or bytes[mgf_hash_oid.content..<mgf_hash_oid.end()] != bytes[hash_oid.content..<hash_oid.end()]:
        return 0
    pos = mgf_field.next
    if pos >= params.end() or bytes[pos] != 0xa2:
        return 0
    let salt_field = try der.expect(bytes, pos, params.end(), 0xa2)
    let salt = try der.small_integer(bytes, try der.expect(bytes, salt_field.content, salt_field.end(), 0x02))
    if salt != size:
        return 0
    if salt_field.next != params.end():
        let trailer = try der.expect(bytes, salt_field.next, params.end(), 0xa3)
        if trailer.next != params.end() or try der.small_integer(bytes, try der.expect(bytes, trailer.content, trailer.end(), 0x02)) != 1:
            return 0
    return kind

func parse_spki(bytes: const u8[], spki: der.Element, cert: Certificate*) -> !:
    let algorithm = try der.expect(bytes, spki.content, spki.end(), 0x30)
    let oid = try der.expect(bytes, algorithm.content, algorithm.end(), 0x06)
    let key = try der.expect(bytes, algorithm.next, spki.end(), 0x03)
    if key.next != spki.end() or key.length < 2 or bytes[key.content] != 0:
        error(invalid, "malformed subjectPublicKey")
    if der.oid_is(bytes, oid, oid_rsa):
        let rsa = try der.expect(bytes, key.content + 1, key.end(), 0x30)
        let modulus = try der.expect(bytes, rsa.content, rsa.end(), 0x02)
        let exponent = try der.expect(bytes, modulus.next, rsa.end(), 0x02)
        if exponent.next != rsa.end() or rsa.next != key.end():
            error(invalid, "malformed RSAPublicKey")
        let n = try der.positive_integer(bytes, modulus)
        let e = try der.positive_integer(bytes, exponent)
        cert.key_kind = signature.key_rsa
        cert.key_a_start = modulus.end() - n.length
        cert.key_a_end = modulus.end()
        cert.key_b_start = exponent.end() - e.length
        cert.key_b_end = exponent.end()
        _ = try cert.public_key(bytes)
        return
    if not der.oid_is(bytes, oid, oid_ec_public):
        error(invalid, "unsupported certificate public key algorithm")
    let curve = try der.expect(bytes, oid.next, algorithm.end(), 0x06)
    if curve.next != algorithm.end():
        error(invalid, "trailing EC algorithm parameters")
    var width: usize = 0
    if der.oid_is(bytes, curve, oid_p256):
        cert.key_kind = signature.key_p256
        width = 32
    elif der.oid_is(bytes, curve, oid_p384):
        cert.key_kind = signature.key_p384
        width = 48
    else:
        error(invalid, "unsupported certificate EC curve")
    if key.length != 2 + 2 * width or bytes[key.content + 1] != 4:
        error(invalid, "invalid uncompressed EC public key")
    cert.key_a_start = key.content + 2
    cert.key_a_end = key.content + 2 + width
    cert.key_b_start = key.content + 2 + width
    cert.key_b_end = key.end()

func parse_basic_constraints(bytes: const u8[], value: der.Element, cert: Certificate*) -> !:
    cert.basic_present = true
    let sequence = try der.expect(bytes, value.content, value.end(), 0x30)
    if sequence.next != value.end():
        error(invalid, "trailing basicConstraints bytes")
    var pos = sequence.content
    if pos < sequence.end() and bytes[pos] == 0x01:
        let flag = try der.expect(bytes, pos, sequence.end(), 0x01)
        if flag.length != 1 or bytes[flag.content] != 0xff:
            error(invalid, "non-canonical basicConstraints cA")
        cert.is_ca = true
        pos = flag.next
    if pos < sequence.end():
        cert.path_len = try der.small_integer(bytes, try der.expect(bytes, pos, sequence.end(), 0x02))
        cert.path_len_present = true
        pos = (try der.read(bytes, pos, sequence.end())).next
    if pos != sequence.end() or (cert.path_len_present and not cert.is_ca):
        error(invalid, "invalid basicConstraints")

func parse_key_usage(bytes: const u8[], value: der.Element, cert: Certificate*) -> !:
    cert.key_usage_present = true
    let bits = try der.expect(bytes, value.content, value.end(), 0x03)
    if bits.next != value.end() or bits.length < 2 or bytes[bits.content] > 7:
        error(invalid, "invalid keyUsage BIT STRING")
    cert.digital_signature = (bytes[bits.content + 1] & 0x80) != 0
    cert.key_cert_sign = (bytes[bits.content + 1] & 0x04) != 0

func parse_eku(bytes: const u8[], value: der.Element, cert: Certificate*) -> !:
    cert.eku_present = true
    let sequence = try der.expect(bytes, value.content, value.end(), 0x30)
    if sequence.next != value.end() or sequence.length == 0:
        error(invalid, "invalid extendedKeyUsage")
    var pos = sequence.content
    while pos < sequence.end():
        let purpose = try der.expect(bytes, pos, sequence.end(), 0x06)
        if der.oid_is(bytes, purpose, oid_server_auth) or der.oid_is(bytes, purpose, oid_any_eku):
            cert.server_auth = true
        pos = purpose.next

func parse_san(bytes: const u8[], value: der.Element, cert: Certificate*) -> !:
    let sequence = try der.expect(bytes, value.content, value.end(), 0x30)
    if sequence.next != value.end() or sequence.length == 0:
        error(invalid, "invalid subjectAltName")
    var pos = sequence.content
    while pos < sequence.end():
        let name = try der.read(bytes, pos, sequence.end())
        if name.tag == 0x82:
            if name.length == 0:
                error(invalid, "empty subjectAltName dNSName")
            for i in name.content..<name.end():
                if bytes[i] < 0x21 or bytes[i] > 0x7e:
                    error(invalid, "non-ASCII subjectAltName dNSName")
        pos = name.next
    cert.san_start = sequence.content
    cert.san_end = sequence.end()

func parse_extensions(bytes: const u8[], at: usize, limit: usize, cert: Certificate*) -> !:
    let sequence = try der.expect(bytes, at, limit, 0x30)
    if sequence.next != limit or sequence.length == 0:
        error(invalid, "invalid certificate extensions")
    var seen_start: usize[40]
    var seen_end: usize[40]
    var seen: usize = 0
    var pos = sequence.content
    while pos < sequence.end():
        if seen >= 40:
            error(invalid, "too many certificate extensions")
        let extension = try der.expect(bytes, pos, sequence.end(), 0x30)
        let oid = try der.expect(bytes, extension.content, extension.end(), 0x06)
        for i in 0..<seen:
            if bytes[oid.content..<oid.end()] == bytes[seen_start[i]..<seen_end[i]]:
                error(invalid, "duplicate certificate extension")
        seen_start[seen] = oid.content
        seen_end[seen] = oid.end()
        seen += 1
        var critical = false
        var value_at = oid.next
        if value_at < extension.end() and bytes[value_at] == 0x01:
            let flag = try der.expect(bytes, value_at, extension.end(), 0x01)
            if flag.length != 1 or bytes[flag.content] != 0xff:
                error(invalid, "non-canonical extension critical flag")
            critical = true
            value_at = flag.next
        let value = try der.expect(bytes, value_at, extension.end(), 0x04)
        if value.next != extension.end():
            error(invalid, "trailing extension fields")
        let id = bytes[oid.content..<oid.end()]
        if id == b"\x55\x1d\x0f":
            try parse_key_usage(bytes, value, cert)
        elif id == b"\x55\x1d\x11":
            try parse_san(bytes, value, cert)
        elif id == b"\x55\x1d\x13":
            try parse_basic_constraints(bytes, value, cert)
        elif id == b"\x55\x1d\x25":
            try parse_eku(bytes, value, cert)
        elif id == b"\x55\x1d\x1e":
            error(invalid, "nameConstraints are not supported")
        elif id == b"\x55\x1d\x20":
            if critical:
                try check_critical_policies(bytes, value)
        elif critical:
            error(invalid, "unsupported critical certificate extension")
        pos = extension.next

## A critical certificatePolicies extension can be ignored only when every
## policy qualifier is a CPS pointer, which RFC 5280 attaches no processing
## to (BearSSL's rule; this client does no policy processing).
## policyMappings, policyConstraints and inhibitAnyPolicy are not processed,
## so they are refused when critical, as any other unknown extension.
func check_critical_policies(bytes: const u8[], value: der.Element) -> !:
    let policies = try der.expect(bytes, value.content, value.end(), 0x30)
    var pos = policies.content
    while pos < policies.end():
        let information = try der.expect(bytes, pos, policies.end(), 0x30)
        let identifier = try der.expect(bytes, information.content, information.end(), 0x06)
        if identifier.next < information.end():
            let qualifiers = try der.expect(bytes, identifier.next, information.end(), 0x30)
            var at = qualifiers.content
            while at < qualifiers.end():
                let qualifier = try der.expect(bytes, at, qualifiers.end(), 0x30)
                let kind = try der.expect(bytes, qualifier.content, qualifier.end(), 0x06)
                if not der.oid_is(bytes, kind, b"\x2b\x06\x01\x05\x05\x07\x02\x01"):
                    error(invalid, "critical certificatePolicies carry a qualifier other than a CPS pointer")
                at = qualifier.next
        pos = information.next

## Parse a DER X.509 v3 certificate.
pub func parse(bytes: const u8[]) -> Certificate!:
    if bytes.length == 0 or bytes.length > max_certificate_bytes:
        error(invalid, "certificate size is out of range")
    var cert = Certificate()
    let outer = try der.expect(bytes, 0, bytes.length, 0x30)
    if outer.next != bytes.length:
        error(invalid, "trailing certificate bytes")
    let tbs = try der.expect(bytes, outer.content, outer.end(), 0x30)
    cert.tbs_start = tbs.start
    cert.tbs_end = tbs.next
    let outer_algorithm = try der.expect(bytes, tbs.next, outer.end(), 0x30)
    cert.algorithm = try parse_algorithm(bytes, outer_algorithm)
    let value = try der.expect(bytes, outer_algorithm.next, outer.end(), 0x03)
    if value.next != outer.end() or value.length < 2 or bytes[value.content] != 0:
        error(invalid, "malformed certificate signature")
    cert.signature_start = value.content + 1
    cert.signature_end = value.end()
    let version = try der.expect(bytes, tbs.content, tbs.end(), 0xa0)
    let number = try der.expect(bytes, version.content, version.end(), 0x02)
    if number.next != version.end() or number.length != 1 or bytes[number.content] != 2:
        error(invalid, "certificate is not X.509 v3")
    let serial = try der.expect(bytes, version.next, tbs.end(), 0x02)
    if serial.length == 0 or serial.length > 21:
        error(invalid, "invalid certificate serial number")
    let inner_algorithm = try der.expect(bytes, serial.next, tbs.end(), 0x30)
    if bytes[inner_algorithm.start..<inner_algorithm.next] != bytes[outer_algorithm.start..<outer_algorithm.next]:
        error(invalid, "certificate signature algorithms disagree")
    let issuer = try der.expect(bytes, inner_algorithm.next, tbs.end(), 0x30)
    cert.issuer_start = issuer.start
    cert.issuer_end = issuer.next
    let validity = try der.expect(bytes, issuer.next, tbs.end(), 0x30)
    let begin = try der.read(bytes, validity.content, validity.end())
    let finish = try der.read(bytes, begin.next, validity.end())
    cert.not_before = try der.time(bytes, begin)
    cert.not_after = try der.time(bytes, finish)
    if finish.next != validity.end() or cert.not_after < cert.not_before:
        error(invalid, "invalid certificate validity")
    let subject = try der.expect(bytes, validity.next, tbs.end(), 0x30)
    cert.subject_start = subject.start
    cert.subject_end = subject.next
    let spki = try der.expect(bytes, subject.next, tbs.end(), 0x30)
    try parse_spki(bytes, spki, &cert)
    var pos = spki.next
    while pos < tbs.end():
        let field = try der.read(bytes, pos, tbs.end())
        if field.tag == 0xa3:
            if field.next != tbs.end():
                error(invalid, "fields follow certificate extensions")
            try parse_extensions(bytes, field.content, field.end(), &cert)
        elif field.tag != 0x81 and field.tag != 0x82:
            error(invalid, "unexpected tbsCertificate field")
        pos = field.next
    return cert