Repository Public License
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