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