SPB Git

Repository Public License

LiveTests.swift 18.7 KB 323 lines swift

1// ORIX Secure2// File: Packages/ORIXNetworkLab/Tests/ORIXNetworkLabTests/LiveTests.swift3// Description: Tests that really use the network stack: a local TLS server (openssl s_server) inspected over loopback,4//              and optional checks against apple.com that record "skipped: offline" instead of failing.5//6// Author: Simon-Pierre Boucher7// Contact: contact@spboucher.ai8import Foundation9@testable import ORIXNetworkLab10import ORIXSecureModel11import Testing1213@Suite("Local TLS server (loopback)", .serialized)14struct LocalTLSTests {15    @Test func reportOnlyModeCompletesTheHandshakeAndReportsTheUntrustedCertificate() async throws {16        guard let generated = GeneratedCertificates.shared, let server = LocalTLSServer(certificates: generated) else {17            liveNote("skipped: local TLS server (openssl s_server unavailable)")18            return19        }20        defer { server.stop() }21        let inspection = await TLSInspector.inspect(TLSEndpoint(host: "localhost", port: server.port), mode: .reportOnly, timeout: .seconds(5))22        liveNote("ran: local TLS reportOnly — \(ORIXFormat.milliseconds(inspection.duration)), \(inspection.protocolVersion.value?.rawValue ?? "?"), \(inspection.cipherSuite.value?.name ?? "?"), trust error: \(inspection.trust.value?.errorDescription ?? "none")")23        #expect(inspection.handshakeCompleted)24        #expect(inspection.failure == nil)25        #expect(inspection.serverName == "localhost")26        let version = try #require(inspection.protocolVersion.value)27        #expect(version == .tls12 || version == .tls13)28        #expect(inspection.cipherSuite.isMeasured)29        let trust = try #require(inspection.trust.value)30        #expect(!trust.isTrusted)31        #expect(trust.errorDescription?.isEmpty == false)32        let leaf = try #require(inspection.leaf)33        let expected = try X509Certificate(der: generated.localhost)34        #expect(leaf == expected)35        #expect(leaf.subject.commonName == "localhost")36        #expect(leaf.subject.organization == "ORIX Local Test")37        #expect(leaf.serialNumber == "2000")38        #expect(leaf.isSelfSigned)39        #expect(inspection.hostnameCovered == true)40        #expect(inspection.unparsedCertificateCount == 0)41        expectWellFormed(inspection.findings)42        let ids = Set(inspection.findings.map(\.id))43        #expect(ids.contains("tls.trust"))44        #expect(ids.contains("tls.selfSigned"))45        #expect(ids.contains("tls.validityPeriod"))46        #expect(!ids.contains("tls.handshake"))47        let trustFinding = inspection.findings.first { $0.id == "tls.trust" }48        #expect(trustFinding?.state == .attention)49        #expect(trustFinding?.evidence.contains { $0.value == trust.errorDescription } == true)50        #expect(inspection.findings.first { $0.id == "tls.hostname" }?.state == .verified)51        #expect(inspection.findings.first { $0.id == "tls.protocol" }?.state == .verified)52        #expect(inspection.notInspected.contains { $0.contains("revocation") })53        let encoded = try JSONEncoder().encode(inspection)54        let decoded = try JSONDecoder().decode(TLSInspection.self, from: encoded)55        #expect(decoded == inspection)56    }5758    @Test func enforcingModeAbortsTheHandshakeButStillReportsTheCertificate() async throws {59        guard let generated = GeneratedCertificates.shared, let server = LocalTLSServer(certificates: generated) else {60            liveNote("skipped: local TLS enforce mode (openssl s_server unavailable)")61            return62        }63        defer { server.stop() }64        let inspection = await TLSInspector.inspect(TLSEndpoint(host: "127.0.0.1", port: server.port), mode: .enforceSystemTrust, timeout: .seconds(5))65        liveNote("ran: local TLS enforceSystemTrust — failure: \(inspection.failure ?? "none")")66        #expect(!inspection.handshakeCompleted)67        #expect(inspection.failure != nil)68        #expect(inspection.serverName == nil)69        #expect(!inspection.protocolVersion.isMeasured)70        #expect(inspection.trust.value?.isTrusted == false)71        #expect(inspection.leaf?.serialNumber == "2000")72        // The address is covered by the certificate's IP subject alternative name.73        #expect(inspection.hostnameCovered == true)74        expectWellFormed(inspection.findings)75        #expect(inspection.findings.contains { $0.id == "tls.handshake" })76        #expect(inspection.findings.contains { $0.id == "tls.trust" && $0.severity == .high })77    }7879    @Test func aNameTheServedCertificateDoesNotCoverIsReported() throws {80        guard let generated = GeneratedCertificates.shared else { return }81        // The served certificate names DNS:localhost and IP:127.0.0.1 only.82        let leaf = try X509Certificate(der: generated.localhost)83        for host in ["localhost.localdomain", "::1", "127.0.0.2"] {84            let findings = TLSAssessment.findings(endpoint: TLSEndpoint(host: host), chain: [leaf], trust: TLSTrustVerdict(isTrusted: false, errorDescription: "x"), protocolVersion: .tls13)85            #expect(findings.first { $0.id == "tls.hostname" }?.state == .attention, "\(host)")86        }87    }8889    @Test func aClosedLocalPortFailsFastWithAReadableReason() async {90        // Port 1 on loopback: nothing listens there.91        let inspection = await TLSInspector.inspect(TLSEndpoint(host: "127.0.0.1", port: 1), timeout: .seconds(3))92        #expect(!inspection.handshakeCompleted)93        #expect(inspection.chain.isEmpty)94        #expect(!inspection.trust.isMeasured)95        #expect(inspection.findings.map(\.id) == ["tls.handshake"])96        expectWellFormed(inspection.findings)97        let latency = await LatencyProbe.measure(host: "127.0.0.1", port: 1, samples: 2, timeout: .seconds(2), interval: .milliseconds(10))98        #expect(latency.samples.count == 2)99        #expect(!latency.statistics.isMeasured)100        #expect(latency.samples.allSatisfy { $0.duration == nil && $0.failure != nil })101        liveNote("ran: closed loopback port — TLS: \(inspection.failure ?? "?") / TCP: \(latency.samples.first?.failure ?? "?")")102    }103104    @Test func latencyToTheLocalServer() async throws {105        guard let generated = GeneratedCertificates.shared, let server = LocalTLSServer(certificates: generated) else {106            liveNote("skipped: loopback latency (openssl s_server unavailable)")107            return108        }109        defer { server.stop() }110        let result = await LatencyProbe.measure(host: "127.0.0.1", port: server.port, samples: 5, timeout: .seconds(2), interval: .milliseconds(20))111        let stats = try #require(result.statistics.value)112        #expect(result.samples.count == 5)113        #expect(stats.lossCount == 0)114        #expect(stats.minimum <= stats.median && stats.median <= stats.maximum)115        #expect(stats.minimum <= stats.average && stats.average <= stats.maximum)116        #expect(stats.maximum < 1)117        liveNote("ran: loopback TCP latency — median \(ORIXFormat.milliseconds(stats.median)), min \(ORIXFormat.milliseconds(stats.minimum)), max \(ORIXFormat.milliseconds(stats.maximum)), jitter \(ORIXFormat.milliseconds(stats.jitter)), handshake report used: \(result.samples.filter(\.isHandshakeReport).count)/5")118    }119}120121@Suite("Live network (skipped when offline)", .serialized)122struct LiveNetworkTests {123    @Test func currentPathIsReadable() async throws {124        let monitor = ConnectivityMonitor()125        let reading = await monitor.current()126        let snapshot = try #require(reading.value)127        liveNote("ran: NWPathMonitor — \(snapshot.status.rawValue), kinds \(snapshot.interfaceKinds.map(\.rawValue)), expensive \(snapshot.isExpensive), constrained \(snapshot.isConstrained), IPv4 \(snapshot.supportsIPv4), IPv6 \(snapshot.supportsIPv6), DNS \(snapshot.supportsDNS), interfaces \(snapshot.availableInterfaces.map(\.name))")128        var received: ConnectivitySnapshot?129        for await value in monitor.snapshots() {130            received = value131            break132        }133        #expect(received != nil)134        #expect(monitor.isActive)135        #expect(monitor.changeLog.first?.kinds == [.initial])136        let again = await monitor.current()137        #expect(again.value?.status == received?.status)138        monitor.stop()139        #expect(!monitor.isActive)140        let input = await NetworkAssessment.collect(locationAuthorization: .notDetermined)141        let findings = NetworkAssessment.findings(for: input)142        expectWellFormed(findings)143        #expect(findings.contains { $0.id == "network.connectivity" })144        #expect(findings.contains { $0.id == "network.proxy" })145    }146147    @Test func tlsInspectionOfAppleDotCom() async throws {148        guard await Live.isOnline() else {149            liveNote("skipped: offline — TLS apple.com:443")150            return151        }152        let endpoint = try #require(TLSEndpoint(parsing: "apple.com:443"))153        let inspection = await TLSInspector.inspect(endpoint, mode: .enforceSystemTrust)154        liveNote("ran: TLS apple.com:443 — \(ORIXFormat.milliseconds(inspection.duration)), \(inspection.protocolVersion.value?.rawValue ?? "?"), \(inspection.cipherSuite.value?.name ?? "?"), ALPN \(inspection.alpn ?? "none"), chain \(inspection.chain.map(\.subject.shortDisplay)), leaf key \(inspection.leaf?.publicKey.display ?? "?"), days remaining \(inspection.leaf?.daysRemaining() ?? -1)")155        #expect(inspection.handshakeCompleted)156        let version = try #require(inspection.protocolVersion.value)157        #expect(version == .tls12 || version == .tls13)158        #expect(inspection.trust.value?.isTrusted == true)159        #expect(inspection.hostnameCovered == true)160        #expect(inspection.chain.count >= 2)161        #expect(inspection.unparsedCertificateCount == 0)162        let leaf = try #require(inspection.leaf)163        #expect(!leaf.isSelfSigned)164        #expect(!leaf.isCA)165        #expect(leaf.daysRemaining() > 0)166        #expect(leaf.extendedKeyUsage?.contains("serverAuth") == true)167        #expect(inspection.chain.dropFirst().allSatisfy { $0.isCA })168        expectWellFormed(inspection.findings)169        #expect(inspection.findings.count(.attention) == 0)170    }171172    @Test func tlsNameMismatchAgainstARealServer() async throws {173        guard await Live.isOnline() else {174            liveNote("skipped: offline — TLS name mismatch by address")175            return176        }177        // Connect to apple.com by address: the certificate names apple.com, not the address.178        let dns = await DNSProbe.resolve("apple.com")179        let address = try #require(dns.ipv4Addresses.first ?? dns.ipv6Addresses.first)180        let inspection = await TLSInspector.inspect(TLSEndpoint(host: address, port: 443), mode: .reportOnly)181        liveNote("ran: TLS \(address):443 without SNI — completed \(inspection.handshakeCompleted), covered \(String(describing: inspection.hostnameCovered)), trust error: \(inspection.trust.value?.errorDescription ?? "none")")182        guard inspection.leaf != nil else { return }183        #expect(inspection.serverName == nil)184        #expect(inspection.hostnameCovered == false)185        #expect(inspection.findings.first { $0.id == "tls.hostname" }?.state == .attention)186        expectWellFormed(inspection.findings)187    }188189    @Test func dnsForAppleAndForANameThatDoesNotExist() async throws {190        guard await Live.isOnline() else {191            liveNote("skipped: offline — DNS apple.com / nonexistent.invalid")192            return193        }194        let apple = await DNSProbe.resolve("apple.com")195        #expect(apple.succeeded)196        #expect(!apple.addresses.isEmpty)197        #expect(apple.addresses.allSatisfy { $0.scope == .global })198        let missing = await DNSProbe.resolve("nonexistent.invalid")199        #expect(missing.failure?.kind == .notFound)200        #expect(missing.addresses.isEmpty)201        let batch = await DNSProbe.resolve(hosts: ["apple.com", "nonexistent.invalid", "bad name", "icloud.com", "localhost"], maxConcurrent: 2)202        #expect(batch.map(\.host) == ["apple.com", "nonexistent.invalid", "bad name", "icloud.com", "localhost"])203        #expect(batch[0].succeeded && batch[3].succeeded && batch[4].succeeded)204        #expect(batch[1].failure?.kind == .notFound)205        #expect(batch[2].failure?.kind == .invalidName)206        liveNote("ran: DNS apple.com — \(ORIXFormat.milliseconds(apple.duration)), A \(apple.ipv4Addresses.count), AAAA \(apple.ipv6Addresses.count); nonexistent.invalid — \(missing.failure?.kind.rawValue ?? "?") in \(ORIXFormat.milliseconds(missing.duration))")207    }208209    @Test func dnsTimeoutAndCancellationReturnPromptly() async {210        // A 1 ms budget cannot be met by a real lookup of an uncached name; a cached one may still win the race.211        let name = "orix-\(UInt32.random(in: 0...UInt32.max)).example.com"212        let clock = ContinuousClock()213        let started = clock.now214        let result = await DNSProbe.resolve(name, timeout: .milliseconds(1))215        let elapsed = clock.now - started216        #expect(elapsed < .seconds(2))217        #expect(result.failure != nil)218        let task = Task { await DNSProbe.resolve("orix-cancel-\(UInt32.random(in: 0...UInt32.max)).example.com", timeout: .seconds(30)) }219        task.cancel()220        let cancelled = await task.value221        #expect(cancelled.failure != nil)222        liveNote("ran: DNS 1 ms budget — \(result.failure?.kind.rawValue ?? "resolved") after \(elapsed); cancelled lookup — \(cancelled.failure?.kind.rawValue ?? "resolved")")223    }224225    @Test func latencyToAppleDotCom() async throws {226        guard await Live.isOnline() else {227            liveNote("skipped: offline — latency apple.com:443")228            return229        }230        let result = await LatencyProbe.measure(host: "apple.com", port: 443, samples: 5)231        let stats = try #require(result.statistics.value)232        #expect(result.samples.count == 5)233        #expect(stats.sampleCount == 5)234        #expect(stats.lossCount <= 1)235        #expect(stats.minimum > 0)236        #expect(stats.minimum <= stats.median && stats.median <= stats.maximum)237        #expect(stats.jitter >= 0)238        liveNote("ran: TCP latency apple.com:443 — median \(ORIXFormat.milliseconds(stats.median)), avg \(ORIXFormat.milliseconds(stats.average)), min \(ORIXFormat.milliseconds(stats.minimum)), max \(ORIXFormat.milliseconds(stats.maximum)), jitter \(ORIXFormat.milliseconds(stats.jitter)), lost \(stats.lossCount)/5, handshake report used: \(result.samples.filter(\.isHandshakeReport).count)/5")239    }240241    @Test func blackholeAddressTimesOutWithinItsBudget() async {242        let clock = ContinuousClock()243        let started = clock.now244        let result = await LatencyProbe.measure(host: "10.255.255.1", port: 81, samples: 2, timeout: .seconds(1), interval: .milliseconds(10))245        let elapsed = clock.now - started246        #expect(result.samples.count == 2)247        #expect(result.samples.allSatisfy { $0.duration == nil && $0.failure != nil })248        #expect(result.statistics.unavailability?.kind == .failed)249        #expect(elapsed < .seconds(4))250        let tlsStarted = clock.now251        let inspection = await TLSInspector.inspect(TLSEndpoint(host: "10.255.255.1", port: 81), timeout: .seconds(1))252        let tlsElapsed = clock.now - tlsStarted253        #expect(!inspection.handshakeCompleted)254        #expect(inspection.chain.isEmpty)255        #expect(tlsElapsed < .seconds(3))256        #expect(inspection.findings.map(\.id) == ["tls.handshake"])257        expectWellFormed(inspection.findings)258        liveNote("ran: blackhole 10.255.255.1:81 — TCP: “\(result.samples.first?.failure ?? "?")” ×2 in \(elapsed); TLS: “\(inspection.failure ?? "?")” in \(tlsElapsed)")259    }260261    @Test func unresolvableHostBehavesLikeBeingOffline() async {262        let latency = await LatencyProbe.measure(host: "nonexistent.invalid", samples: 1, timeout: .seconds(3))263        #expect(!latency.statistics.isMeasured)264        #expect(latency.samples.first?.failure != nil)265        let inspection = await TLSInspector.inspect(TLSEndpoint(host: "nonexistent.invalid"), timeout: .seconds(3))266        #expect(!inspection.handshakeCompleted)267        #expect(inspection.failure != nil)268        #expect(inspection.findings.map(\.id) == ["tls.handshake"])269        let url = URL(string: "https://nonexistent.invalid/")270        if let url {271            let probe = await HTTPSProbe.head(url, timeout: .seconds(3))272            #expect(probe.failure != nil)273            #expect(probe.findings.map(\.state) == [.notAvailable])274        }275        liveNote("ran: unresolvable host — TCP: “\(latency.samples.first?.failure ?? "?")”; TLS: “\(inspection.failure ?? "?")”")276    }277278    @Test func httpsProbeFollowsTheUpgradeHopByHop() async throws {279        guard await Live.isOnline() else {280            liveNote("skipped: offline — HTTPS probe apple.com")281            return282        }283        let url = try #require(URL(string: "http://apple.com/"))284        let probe = await HTTPSProbe.head(url)285        liveNote("ran: HTTPS probe http://apple.com/ — \(ORIXFormat.milliseconds(probe.duration)), hops \(probe.hops.map { "\($0.status) \($0.url)" }), upgraded \(probe.upgradedToHTTPS), HSTS max-age \(probe.hsts?.maxAge.map(String.init) ?? "absent"), failure \(probe.failure ?? "none")")286        guard probe.failure == nil else { return }287        #expect(probe.hops.count >= 2)288        #expect(probe.hops.count <= HTTPSProbe.maximumRedirects + 1)289        #expect(probe.hops.first?.location != nil)290        #expect(probe.upgradedToHTTPS)291        #expect(probe.finalURL?.hasPrefix("https://") == true)292        expectWellFormed(probe.findings)293        #expect(probe.findings.contains { $0.id == "https.upgrade" && $0.state == .verified })294    }295296    @Test func bonjourBrowseIsBoundedAndSummarized() async {297        let clock = ContinuousClock()298        let started = clock.now299        var events = 0300        var summary: Reading<BonjourBrowseSummary>?301        for await event in LocalNetworkBrowser.browse(duration: .seconds(2)) {302            events += 1303            if case .finished(let result) = event { summary = result }304        }305        let elapsed = clock.now - started306        #expect(elapsed < .seconds(6))307        #expect(summary != nil)308        switch summary {309        case .measured(let result):310            #expect(result.serviceTypes == LocalNetworkBrowser.defaultServiceTypes)311            #expect(result.ignoredServiceTypes.isEmpty)312            #expect(result.services.count <= events)313            #expect(result.services.allSatisfy { LocalNetworkBrowser.defaultServiceTypes.contains($0.type) })314            #expect(result.notInspected.contains { $0.contains("not an inventory") })315            liveNote("ran: Bonjour browse 2 s — \(result.services.count) services, by type \(result.countsByType.sorted { $0.key < $1.key }.map { "\($0.key)=\($0.value)" }), failed types \(result.failedServiceTypes.count)")316        case .unavailable(let reason):317            liveNote("ran: Bonjour browse — unavailable (\(reason.kind.rawValue)): \(reason.detail)")318        case nil:319            break320        }321    }322}323
Files main
Menu

Theme