SPB Git

Repository Public License

X509Tests.swift 18.1 KB 371 lines swift

1// ORIX Secure2// File: Packages/ORIXNetworkLab/Tests/ORIXNetworkLabTests/X509Tests.swift3// Description: X.509 parser tests: static DER fixtures, certificates generated with openssl at test time, and4//              malformed or random input that must always end in a typed error.5//6// Author: Simon-Pierre Boucher7// Contact: contact@spboucher.ai8import Foundation9@testable import ORIXNetworkLab10import ORIXSecureModel11import Testing1213@Suite("X.509 parser — static fixtures")14struct X509FixtureTests {15    @Test func parsesTheCAFixture() throws {16        let certificate = try X509Certificate(der: Fixtures.caDER)17        #expect(certificate.version == 3)18        #expect(certificate.serialNumber == "0a1b2c")19        #expect(certificate.subject.commonName == "placeholder")20        #expect(certificate.issuer.commonName == "placeholder")21        #expect(certificate.subject.display == "CN=placeholder")22        #expect(certificate.notBefore == utc("2025-01-01T00:00:00Z"))23        #expect(certificate.notAfter == utc("2035-01-01T00:00:00Z"))24        #expect(certificate.signatureAlgorithm.name == "ecdsa-with-SHA256")25        #expect(certificate.signatureAlgorithm.hash == .sha256)26        #expect(!certificate.signatureAlgorithm.isWeak)27        #expect(certificate.publicKey.algorithm == .ellipticCurve)28        #expect(certificate.publicKey.curve == "P-256")29        #expect(certificate.publicKey.bits == 256)30        #expect(certificate.basicConstraints == X509BasicConstraints(isCA: true, pathLength: 1))31        #expect(certificate.isCA)32        #expect(certificate.keyUsage == [.keyCertSign, .cRLSign])33        #expect(certificate.extendedKeyUsage == nil)34        #expect(certificate.subjectKeyIdentifier == "4d3a516de0976ba02885f214463dd3a78bd2c3b2")35        #expect(certificate.authorityKeyIdentifier == nil)36        #expect(certificate.sha256Fingerprint == "5efb1bf1bda65cd4991e32652e71aae9575b635a298b7f7a24d7c4e0da0d6b6a")37        #expect(certificate.isSelfIssued)38        #expect(certificate.isSelfSigned)39        #expect(certificate.verifySelfSignature() == true)40        #expect(certificate.subjectAlternativeNames.isEmpty)41        #expect(certificate.extensions.map(\.oid) == ["2.5.29.19", "2.5.29.15", "2.5.29.14"])42        #expect(certificate.extensions.map(\.isCritical) == [true, true, false])43        #expect(certificate.validityDays == 3652)44    }4546    @Test func parsesTheLeafFixture() throws {47        let certificate = try X509Certificate(der: Fixtures.leafDER)48        #expect(certificate.version == 3)49        #expect(certificate.serialNumber == "0a1b2d")50        #expect(certificate.notBefore == utc("2026-01-01T12:00:00Z"))51        #expect(certificate.notAfter == utc("2027-01-01T12:00:00Z"))52        #expect(certificate.validityDays == 365)53        #expect(certificate.publicKey.algorithm == .rsa)54        #expect(certificate.publicKey.bits == 2048)55        #expect(certificate.publicKey.display == "RSA 2048")56        #expect(certificate.signatureAlgorithm.oid == "1.2.840.10045.4.3.2")57        #expect(certificate.subjectAlternativeNames.dnsNames == ["fixture.orix.test", "*.fixture.orix.test"])58        #expect(certificate.subjectAlternativeNames.ipAddresses == ["192.0.2.10", "2001:db8::10"])59        #expect(certificate.basicConstraints == X509BasicConstraints(isCA: false, pathLength: nil))60        #expect(!certificate.isCA)61        #expect(certificate.keyUsage == [.digitalSignature, .keyEncipherment])62        #expect(certificate.extendedKeyUsage == ["serverAuth", "clientAuth"])63        #expect(certificate.authorityKeyIdentifier == "4d3a516de0976ba02885f214463dd3a78bd2c3b2")64        #expect(certificate.subjectKeyIdentifier == "d829cd49dd239e466915d1f456c384c76872a86f")65        #expect(certificate.sha256Fingerprint == "c6272595840af53eae022d47f2457f1d53d6a517b1fe52495769d291985b346c")66        // Same subject and issuer names, but the authority key identifier points at another key: not self-signed.67        #expect(certificate.isSelfIssued)68        #expect(!certificate.isSelfSigned)69        #expect(certificate.daysRemaining(at: utc("2026-12-31T12:00:00Z")) == 1)70        #expect(certificate.daysRemaining(at: utc("2027-01-03T12:00:00Z")) == -2)71        #expect(certificate.isExpired(at: utc("2027-01-01T12:00:01Z")))72        #expect(!certificate.isExpired(at: utc("2027-01-01T12:00:00Z")))73        #expect(certificate.isNotYetValid(at: utc("2026-01-01T11:59:59Z")))74        #expect(!certificate.tbsCertificate.isEmpty)75    }7677    @Test func parsesPEMAndRoundTripsThroughCodable() throws {78        let pem = "-----BEGIN CERTIFICATE-----\n" + Fixtures.leafBase64 + "\n-----END CERTIFICATE-----\n"79        let fromPEM = try X509Certificate(pem: pem)80        let fromDER = try X509Certificate(der: Fixtures.leafDER)81        #expect(fromPEM == fromDER)82        let encoded = try JSONEncoder().encode(fromDER)83        let decoded = try JSONDecoder().decode(X509Certificate.self, from: encoded)84        #expect(decoded == fromDER)85        #expect(decoded.tbsCertificate == fromDER.tbsCertificate)86    }87}8889@Suite("X.509 parser — certificates generated with openssl")90struct X509GeneratedTests {91    @Test func rsaLeafIssuedByTheTestRoot() throws {92        guard let generated = GeneratedCertificates.shared else { return }93        let leaf = try X509Certificate(der: generated.leaf)94        let root = try X509Certificate(der: generated.root)95        #expect(leaf.version == 3)96        #expect(leaf.serialNumber == "1000")97        #expect(leaf.subject.commonName == "www.orix.test")98        #expect(leaf.subject.organization == "ORIX Test")99        #expect(leaf.subject.country == "CA")100        #expect(leaf.issuer.commonName == "ORIX Test Root")101        #expect(leaf.issuer.organization == "ORIX Test Authority")102        #expect(leaf.notBefore == utc("2026-06-01T00:00:00Z"))103        #expect(leaf.notAfter == utc("2027-01-01T00:00:00Z"))104        #expect(leaf.validityDays == 214)105        #expect(leaf.publicKey.algorithm == .rsa)106        #expect(leaf.publicKey.bits == 2048)107        #expect(leaf.signatureAlgorithm.name == "ecdsa-with-SHA256")108        #expect(leaf.subjectAlternativeNames.dnsNames == ["www.orix.test", "*.apps.orix.test"])109        #expect(leaf.subjectAlternativeNames.ipAddresses == ["127.0.0.1", "::1"])110        #expect(leaf.subjectAlternativeNames.emailAddresses == ["admin@orix.test"])111        #expect(leaf.subjectAlternativeNames.uris == ["https://www.orix.test/"])112        #expect(leaf.basicConstraints?.isCA == false)113        #expect(leaf.keyUsage == [.digitalSignature, .keyEncipherment])114        #expect(leaf.extendedKeyUsage == ["serverAuth"])115        #expect(!leaf.isSelfIssued)116        #expect(!leaf.isSelfSigned)117        #expect(leaf.authorityKeyIdentifier == root.subjectKeyIdentifier)118        #expect(leaf.authorityKeyIdentifier != nil)119        #expect(leaf.sha256Fingerprint.count == 64)120    }121122    @Test func ecRootWithBasicConstraintsAndGeneralizedTime() throws {123        guard let generated = GeneratedCertificates.shared else { return }124        let root = try X509Certificate(der: generated.root)125        #expect(root.serialNumber == "01")126        #expect(root.subject.commonName == "ORIX Test Root")127        #expect(root.subject.country == "CA")128        #expect(root.basicConstraints == X509BasicConstraints(isCA: true, pathLength: 0))129        #expect(root.keyUsage == [.keyCertSign, .cRLSign])130        #expect(root.publicKey.algorithm == .ellipticCurve)131        #expect(root.publicKey.curve == "P-256")132        #expect(root.isSelfSigned)133        #expect(root.verifySelfSignature() == true)134        #expect(root.notBefore == utc("2024-01-01T00:00:00Z"))135        // 2060 is past the UTCTime range: the end date is a GeneralizedTime.136        #expect(root.notAfter == utc("2060-01-01T00:00:00Z"))137    }138139    @Test func rsa1024Sha1SelfSigned() throws {140        guard let generated = GeneratedCertificates.shared else { return }141        let weak = try X509Certificate(der: generated.weak)142        #expect(weak.serialNumber == "deadbeef")143        #expect(weak.publicKey.algorithm == .rsa)144        #expect(weak.publicKey.bits == 1024)145        #expect(weak.signatureAlgorithm.name == "sha1WithRSAEncryption")146        #expect(weak.signatureAlgorithm.isWeak)147        #expect(weak.isSelfSigned)148        #expect(weak.verifySelfSignature() == true)149        #expect(weak.subject.organization == "Weak Org")150        #expect(weak.validityDays == 3652)151        #expect(weak.subjectAlternativeNames.dnsNames == ["weak.orix.test"])152    }153154    @Test func expiredFutureExpiringAndPlain() throws {155        guard let generated = GeneratedCertificates.shared else { return }156        let now = utc("2026-09-01T00:00:00Z")157        let expired = try X509Certificate(der: generated.expired)158        #expect(expired.isExpired(at: now))159        #expect(expired.notAfter == utc("2021-01-01T00:00:00Z"))160        #expect(expired.daysRemaining(at: now) < 0)161        let future = try X509Certificate(der: generated.future)162        #expect(future.isNotYetValid(at: now))163        #expect(future.notBefore == utc("2040-01-01T00:00:00Z"))164        let expiring = try X509Certificate(der: generated.expiring)165        #expect(!expiring.isExpired(at: now))166        #expect(expiring.daysRemaining(at: now) == 9)167        let plain = try X509Certificate(der: generated.plain)168        #expect(plain.extensions.isEmpty)169        #expect(plain.basicConstraints == nil)170        #expect(plain.keyUsage == nil)171        #expect(plain.subjectAlternativeNames.isEmpty)172        #expect(plain.notAfter == utc("2026-12-31T23:59:59Z"))173        #expect(plain.verifySelfSignature() != true)174    }175176    @Test func aTamperedSelfSignedCertificateFailsItsSignatureCheck() throws {177        guard let generated = GeneratedCertificates.shared else { return }178        var bytes = [UInt8](generated.weak)179        // Flip one bit in the middle of the signature (the last bytes of the certificate).180        bytes[bytes.count - 20] ^= 0x01181        let tampered = try X509Certificate(der: Data(bytes))182        #expect(tampered.verifySelfSignature() == false)183    }184}185186@Suite("X.509 parser — malformed input")187struct X509MalformedTests {188    private func parseError(_ bytes: [UInt8]) -> X509Error? {189        do {190            _ = try X509Certificate(der: Data(bytes))191            return nil192        } catch let error as X509Error {193            return error194        } catch {195            Issue.record("untyped error: \(error)")196            return nil197        }198    }199200    @Test func emptyAndOversized() {201        #expect(parseError([]) == .empty)202        #expect(parseError([UInt8](repeating: 0x30, count: (1 << 20) + 1)) == .tooLarge)203    }204205    @Test func everyTruncationThrows() {206        let full = [UInt8](Fixtures.leafDER)207        var failures = 0208        for length in 1..<full.count {209            if parseError(Array(full[..<length])) == nil { failures += 1 }210        }211        #expect(failures == 0)212        #expect(parseError(Array(full[..<(full.count - 1)])) == .truncated)213    }214215    @Test func trailingDataThrows() {216        #expect(parseError([UInt8](Fixtures.leafDER) + [0x00]) != nil)217        #expect(parseError([UInt8](Fixtures.leafDER) + [0x05, 0x00]) == .trailingData)218    }219220    @Test func wrongLengthsThrow() {221        var longer = [UInt8](Fixtures.caDER)222        // Outer SEQUENCE is 30 82 01 62: claim more, then fewer, bytes than present.223        longer[3] = 0x63224        #expect(parseError(longer) == .truncated)225        var shorter = [UInt8](Fixtures.caDER)226        shorter[3] = 0x61227        #expect(parseError(shorter) != nil)228        var inner = [UInt8](Fixtures.caDER)229        // TBSCertificate length (30 82 01 08 at offset 4): make it overrun its parent.230        inner[6] = 0x7f231        #expect(parseError(inner) != nil)232    }233234    @Test func indefiniteLengthThrows() {235        #expect(parseError([0x30, 0x80, 0x02, 0x01, 0x00, 0x00, 0x00]) == .indefiniteLength)236        var nested = [UInt8](Fixtures.caDER)237        nested[4] = 0x30238        nested[5] = 0x80239        #expect(parseError(nested) != nil)240    }241242    @Test func fiveByteLengthThrows() {243        #expect(parseError([0x30, 0x85, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00]) == .lengthTooLarge)244        #expect(parseError([0x30, 0x88, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]) == .lengthTooLarge)245        #expect(parseError([0x30, 0x84, 0xff, 0xff, 0xff, 0xff, 0x00]) == .truncated)246    }247248    @Test func nonMinimalLengthAndHighTagThrow() {249        #expect(parseError([0x30, 0x81, 0x03, 0x02, 0x01, 0x00]) == .nonMinimalLength)250        #expect(parseError([0x30, 0x82, 0x00, 0x83] + [UInt8](repeating: 0, count: 0x83)) == .nonMinimalLength)251        #expect(parseError([0x1f, 0x81, 0x01, 0x00]) == .unsupportedTag)252    }253254    @Test func nestingDepthBombThrows() {255        var bomb: [UInt8] = [0x02, 0x01, 0x00]256        for _ in 0..<400 {257            let length = bomb.count258            var header: [UInt8] = [0x30]259            if length < 0x80 {260                header.append(UInt8(length))261            } else if length < 0x100 {262                header += [0x81, UInt8(length)]263            } else {264                header += [0x82, UInt8(length >> 8), UInt8(length & 0xff)]265            }266            bomb = header + bomb267        }268        #expect(parseError(bomb) == .depthExceeded)269        // A wide bomb: more elements than the parser accepts.270        let wide = [UInt8](repeating: 0, count: 0) + (0..<60_000).flatMap { _ in [UInt8(0x05), UInt8(0x00)] }271        let header: [UInt8] = [0x30, 0x83, UInt8(wide.count >> 16), UInt8((wide.count >> 8) & 0xff), UInt8(wide.count & 0xff)]272        #expect(parseError(header + wide) == .tooManyElements)273    }274275    @Test func wrongStructureThrows() {276        #expect(parseError([0x30, 0x00]) != nil)277        #expect(parseError([0x02, 0x01, 0x00]) == .unexpectedTag(expected: 0x30, found: 0x02))278        #expect(parseError([0x30, 0x03, 0x02, 0x01, 0x00]) != nil)279        #expect(parseError(Array("-----BEGIN CERTIFICATE-----".utf8)) != nil)280    }281282    @Test func twoThousandRandomBuffersNeverCrash() {283        var generator = SeededGenerator(state: 0x0715_2026)284        var parsed = 0285        for index in 0..<2000 {286            let length = Int.random(in: 1...600, using: &generator)287            var bytes = (0..<length).map { _ in UInt8.random(in: 0...255, using: &generator) }288            // Half of the buffers start like a certificate so the parser goes deeper before failing.289            if index % 2 == 0, length > 8 {290                bytes[0] = 0x30291                bytes[1] = 0x82292                bytes[2] = UInt8((length - 4) >> 8)293                bytes[3] = UInt8((length - 4) & 0xff)294                bytes[4] = 0x30295            }296            if parseError(bytes) == nil { parsed += 1 }297        }298        #expect(parsed == 0)299    }300301    @Test func mutatedCertificatesNeverCrash() {302        var generator = SeededGenerator(state: 42)303        let original = [UInt8](Fixtures.leafDER)304        var stillParsed = 0305        var rejected = 0306        for _ in 0..<4000 {307            var bytes = original308            let flips = Int.random(in: 1...3, using: &generator)309            for _ in 0..<flips {310                bytes[Int.random(in: 0..<bytes.count, using: &generator)] = UInt8.random(in: 0...255, using: &generator)311            }312            if parseError(bytes) == nil { stillParsed += 1 } else { rejected += 1 }313        }314        // Flips inside the key or signature leave a structurally valid certificate; flips in the structure are rejected.315        #expect(stillParsed + rejected == 4000)316        #expect(rejected > 100)317        print("MEASURED X.509 mutation fuzz: \(rejected) rejected with a typed error, \(stillParsed) still structurally valid, 0 crashes")318    }319320    @Test func derPrimitives() throws {321        let oidBytes: [UInt8] = [0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b]322        var reader = DERReader(oidBytes)323        let oid = try reader.readOID()324        #expect(oid == "1.2.840.113549.1.1.11")325        var bad = DERReader([0x06, 0x02, 0x2a, 0x86])326        #expect(throws: X509Error.invalidOID) { try bad.readOID() }327        var padded = DERReader([0x06, 0x03, 0x2a, 0x80, 0x01])328        #expect(throws: X509Error.invalidOID) { try padded.readOID() }329        var overflow = DERReader([0x06, 0x0b, 0x2a] + [UInt8](repeating: 0xff, count: 9) + [0x7f])330        #expect(throws: X509Error.invalidOID) { try overflow.readOID() }331332        func time(_ tag: UInt8, _ text: String) throws -> Date {333            var reader = DERReader([tag, UInt8(text.utf8.count)] + Array(text.utf8))334            return try reader.readTime()335        }336        let utcTime = try time(0x17, "491231235959Z")337        #expect(utcTime == utc("2049-12-31T23:59:59Z"))338        let oldTime = try time(0x17, "500101000000Z")339        #expect(oldTime == utc("1950-01-01T00:00:00Z"))340        let generalized = try time(0x18, "20500101000000Z")341        #expect(generalized == utc("2050-01-01T00:00:00Z"))342        let leapDay = try time(0x18, "20240229120000Z")343        #expect(leapDay == utc("2024-02-29T12:00:00Z"))344        for invalid in ["230229000000Z", "231301000000Z", "230132000000Z", "2301010000Z", "230101000000+0000", "23010100000ZZ", "230101250000Z"] {345            #expect(throws: X509Error.invalidTime) { try time(0x17, invalid) }346        }347        #expect(throws: X509Error.invalidTime) { try time(0x18, "2023010100000Z") }348    }349350    @Test func nameStringsAreDecodedAndSanitized() throws {351        func decode(_ tag: UInt8, _ content: [UInt8]) throws -> String {352            var reader = DERReader([tag, UInt8(content.count)] + content)353            let element = try reader.next()354            return try reader.string(element)355        }356        let utf8 = try decode(0x0c, Array("Zürich".utf8))357        #expect(utf8 == "Zürich")358        let bmp = try decode(0x1e, [0x00, 0x4f, 0x00, 0x52, 0x00, 0x49, 0x00, 0x58])359        #expect(bmp == "ORIX")360        let teletex = try decode(0x14, [0x43, 0x61, 0x66, 0xe9])361        #expect(teletex == "Café")362        let control = try decode(0x13, [0x41, 0x0a, 0x42, 0x00])363        #expect(control == "A\u{fffd}B\u{fffd}")364        let bidi = try decode(0x0c, Array("abc\u{202e}def".utf8))365        #expect(bidi == "abc\u{fffd}def")366        #expect(throws: X509Error.invalidString) { try decode(0x0c, [0xff, 0xfe]) }367        #expect(throws: X509Error.invalidString) { try decode(0x1e, [0x00]) }368        #expect(throws: X509Error.invalidString) { try decode(0x16, [0xc3, 0xa9]) }369    }370}371
Files main
Menu

Theme