Repository Public License
1// ORIX Secure2// File: Packages/ORIXNetworkLab/Tests/ORIXNetworkLabTests/TestSupport.swift3// Description: Test helpers: static DER fixtures, certificate generation with the system openssl CLI, a local TLS4// server (openssl s_server), a connectivity gate for live tests and a seeded random generator.5//6// Author: Simon-Pierre Boucher7// Contact: contact@spboucher.ai8import Foundation9@testable import ORIXNetworkLab10import ORIXSecureModel1112enum Fixtures {13 /// EC P-256 self-signed CA, serial 0A1B2C, CN=placeholder, 2025-01-01 → 2035-01-01, pathlen 1.14 static let caBase64 = "MIIBYjCCAQigAwIBAgIDChssMAoGCCqGSM49BAMCMBYxFDASBgNVBAMMC3BsYWNlaG9sZGVyMB4XDTI1MDEwMTAwMDAwMFoXDTM1MDEwMTAwMDAwMFowFjEUMBIGA1UEAwwLcGxhY2Vob2xkZXIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARBbMyl9QFeUJY3unEWEFmpdSnFtbT5xIh2mevru/1UWS2J9wzh9l+al7quuwTUPRlvRMgWjQrF+Gd6LCC14HXXo0UwQzASBgNVHRMBAf8ECDAGAQH/AgEBMA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUTTpRbeCXa6AohfIURj3Tp4vSw7IwCgYIKoZIzj0EAwIDSAAwRQIhAL6O9uEJPGegU8TjCpk2sMzRvU4M9HcI+oA6SkAVsa0TAiBEB6++4D5yxGFqyCZmTspRLBTz56AkQLa8X8oEPNM2mQ=="15 /// RSA-2048 leaf issued by the CA above, serial 0A1B2D, 2026-01-01 12:00 → 2027-01-01 12:00, DNS + wildcard + IPv4 + IPv6 SANs.16 static let leafBase64 = "MIICszCCAlqgAwIBAgIDChstMAoGCCqGSM49BAMCMBYxFDASBgNVBAMMC3BsYWNlaG9sZGVyMB4XDTI2MDEwMTEyMDAwMFoXDTI3MDEwMTEyMDAwMFowFjEUMBIGA1UEAwwLcGxhY2Vob2xkZXIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDFk6m//eyW9MnsAN3Fhkee732FEpnkXgtg/z+YG5wJbYOaqKL0mEx3I0CfBz/497vQQCpeUVNCBhkeZD+a56B64bwTlXWwno+QVWNd3dxV47+3NT+7U7QK4nHZ2pcl0dGThaQuTjF3LkSRs4T9VH5PfDqrd0YqZvHrkOmRQ5zEG+0FtRqz9JZIgDk4+37uBr1Wv7rM9BkpSQ4jo6bnVfJeIqDzydiYg7QXQhCi9+FhGVLhzvA3k//dAUx7IoYjZQnALiK2ySH0+lLRUa91yg6H8Q3jbXhsas1yf/iNYqddevkX4VMk0r8pM4ENnb70EYzgb3RgMg1WHkvcD/af4vatAgMBAAGjgcswgcgwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMEkGA1UdEQRCMECCEWZpeHR1cmUub3JpeC50ZXN0ghMqLmZpeHR1cmUub3JpeC50ZXN0hwTAAAIKhxAgAQ24AAAAAAAAAAAAAAAQMB0GA1UdDgQWBBTYKc1J3SOeRmkV0fRWw4THaHKobzAfBgNVHSMEGDAWgBRNOlFt4JdroCiF8hRGPdOni9LDsjAKBggqhkjOPQQDAgNHADBEAiBlcD/cVZeAdNBYgTnQ+uHkrzAXvbAPyg15kKj0lUMCvwIgSSD6oqplgVPwSqeKY5Vq1OwI9wrlazOPD4IukRkvI4M="1718 static var caDER: Data { Data(base64Encoded: caBase64) ?? Data() }19 static var leafDER: Data { Data(base64Encoded: leafBase64) ?? Data() }20}2122func utc(_ text: String) -> Date {23 let formatter = ISO8601DateFormatter()24 formatter.formatOptions = [.withInternetDateTime]25 return formatter.date(from: text) ?? Date(timeIntervalSince1970: 0)26}2728/// Deterministic generator (SplitMix64) so fuzz inputs are reproducible.29struct SeededGenerator: RandomNumberGenerator {30 var state: UInt6431 mutating func next() -> UInt64 {32 state &+= 0x9e37_79b9_7f4a_7c1533 var z = state34 z = (z ^ (z >> 30)) &* 0xbf58_476d_1ce4_e5b935 z = (z ^ (z >> 27)) &* 0x94d0_49bb_1331_11eb36 return z ^ (z >> 31)37 }38}3940/// Notes printed by live tests ("LIVE ran …" / "LIVE skipped …") so the run shows what really executed.41func liveNote(_ text: String) {42 print("LIVE \(text)")43}4445enum Live {46 /// `true` when the device has a satisfied path and can resolve a public name.47 static func isOnline() async -> Bool {48 guard let snapshot = await ConnectivityMonitor.currentSnapshot().value, snapshot.status == .satisfied else { return false }49 let result = await DNSProbe.resolve("apple.com", timeout: .seconds(4))50 return result.succeeded51 }52}5354struct OpenSSLError: Error, CustomStringConvertible {55 var description: String56}5758enum KeyKind {59 case rsa(Int)60 case ecP25661}6263struct CertificateSpec {64 var name: String65 var commonName: String66 var organization: String?67 var country: String?68 var key: KeyKind69 var digest = "sha256"70 /// UTCTime "YYMMDDHHMMSSZ" or GeneralizedTime "YYYYMMDDHHMMSSZ".71 var start: String72 var end: String73 /// Lines of the extension section; empty for no extensions.74 var extensions: [String]75 /// Name of the issuing certificate in the same workspace; `nil` to self-sign.76 var issuer: String?77 var serial: String78}7980/// A temporary directory in which the system openssl (LibreSSL) issues certificates with exact dates and serials.81final class OpenSSLWorkspace: @unchecked Sendable {82 static let executable = "/usr/bin/openssl"83 let directory: URL8485 static var isAvailable: Bool { FileManager.default.isExecutableFile(atPath: executable) }8687 init() throws {88 guard Self.isAvailable else { throw OpenSSLError(description: "openssl not found") }89 directory = FileManager.default.temporaryDirectory.appendingPathComponent("orix-networklab-" + UUID().uuidString, isDirectory: true)90 try FileManager.default.createDirectory(at: directory.appendingPathComponent("newcerts"), withIntermediateDirectories: true)91 try Data().write(to: directory.appendingPathComponent("index.txt"))92 }9394 deinit {95 try? FileManager.default.removeItem(at: directory)96 }9798 func path(_ file: String) -> String { directory.appendingPathComponent(file).path }99100 @discardableResult101 func run(_ arguments: [String]) throws -> String {102 let process = Process()103 process.executableURL = URL(fileURLWithPath: Self.executable)104 process.arguments = arguments105 process.currentDirectoryURL = directory106 let output = Pipe()107 process.standardOutput = output108 process.standardError = output109 try process.run()110 let data = output.fileHandleForReading.readDataToEndOfFile()111 process.waitUntilExit()112 let text = String(decoding: data, as: UTF8.self)113 guard process.terminationStatus == 0 else {114 throw OpenSSLError(description: "openssl \(arguments.joined(separator: " ")) failed: \(text)")115 }116 return text117 }118119 /// Issues the certificate and returns its DER. Leaves `<name>.pem` and `<name>.key` in the workspace.120 func issue(_ spec: CertificateSpec) throws -> Data {121 var config = """122 [ ca ]123 default_ca = CA_default124 [ CA_default ]125 dir = .126 database = $dir/index.txt127 new_certs_dir = $dir/newcerts128 serial = $dir/serial129 default_md = sha256130 policy = policy_any131 unique_subject = no132 [ policy_any ]133 countryName = optional134 organizationName = optional135 commonName = supplied136 [ req ]137 distinguished_name = dn138 prompt = no139 [ dn ]140141 """142 if let country = spec.country { config += "C = \(country)\n" }143 if let organization = spec.organization { config += "O = \(organization)\n" }144 config += "CN = \(spec.commonName)\n[ ext ]\n" + spec.extensions.joined(separator: "\n") + "\n"145 let name = spec.name146 try Data(config.utf8).write(to: directory.appendingPathComponent("\(name).cnf"))147 try Data((spec.serial + "\n").utf8).write(to: directory.appendingPathComponent("serial"))148 switch spec.key {149 case .rsa(let bits): try run(["genrsa", "-out", "\(name).key", String(bits)])150 case .ecP256: try run(["ecparam", "-name", "prime256v1", "-genkey", "-noout", "-out", "\(name).key"])151 }152 try run(["req", "-new", "-key", "\(name).key", "-out", "\(name).csr", "-config", "\(name).cnf", "-\(spec.digest)"])153 var arguments = ["ca", "-batch", "-config", "\(name).cnf", "-in", "\(name).csr", "-out", "\(name).pem", "-startdate", spec.start, "-enddate", spec.end, "-notext", "-md", spec.digest]154 if let issuer = spec.issuer {155 arguments += ["-cert", "\(issuer).pem", "-keyfile", "\(issuer).key"]156 } else {157 arguments += ["-selfsign", "-keyfile", "\(name).key"]158 }159 if !spec.extensions.isEmpty { arguments += ["-extensions", "ext"] }160 try run(arguments)161 try run(["x509", "-in", "\(name).pem", "-outform", "DER", "-out", "\(name).der"])162 return try Data(contentsOf: directory.appendingPathComponent("\(name).der"))163 }164}165166/// Certificates generated once per test run.167struct GeneratedCertificates: @unchecked Sendable {168 let workspace: OpenSSLWorkspace169 let root: Data170 let leaf: Data171 let expired: Data172 let future: Data173 let weak: Data174 let expiring: Data175 let localhost: Data176 let plain: Data177178 /// `nil` when openssl is absent or refused a step; the reason is printed once.179 static let shared: GeneratedCertificates? = {180 do {181 let workspace = try OpenSSLWorkspace()182 let root = try workspace.issue(CertificateSpec(183 name: "root", commonName: "ORIX Test Root", organization: "ORIX Test Authority", country: "CA", key: .ecP256,184 start: "240101000000Z", end: "20600101000000Z",185 extensions: ["basicConstraints = critical, CA:TRUE, pathlen:0", "keyUsage = critical, keyCertSign, cRLSign", "subjectKeyIdentifier = hash"],186 issuer: nil, serial: "01"187 ))188 let leafExtensions = [189 "basicConstraints = critical, CA:FALSE", "keyUsage = critical, digitalSignature, keyEncipherment", "extendedKeyUsage = serverAuth",190 "subjectAltName = DNS:www.orix.test, DNS:*.apps.orix.test, IP:127.0.0.1, IP:::1, email:admin@orix.test, URI:https://www.orix.test/",191 "subjectKeyIdentifier = hash", "authorityKeyIdentifier = keyid",192 ]193 let leaf = try workspace.issue(CertificateSpec(194 name: "leaf", commonName: "www.orix.test", organization: "ORIX Test", country: "CA", key: .rsa(2048),195 start: "260601000000Z", end: "270101000000Z", extensions: leafExtensions, issuer: "root", serial: "1000"196 ))197 let expired = try workspace.issue(CertificateSpec(198 name: "expired", commonName: "expired.orix.test", organization: "ORIX Test", country: nil, key: .ecP256,199 start: "200101000000Z", end: "210101000000Z", extensions: ["subjectAltName = DNS:expired.orix.test"], issuer: "root", serial: "1001"200 ))201 let future = try workspace.issue(CertificateSpec(202 name: "future", commonName: "future.orix.test", organization: nil, country: nil, key: .ecP256,203 start: "400101000000Z", end: "410101000000Z", extensions: ["subjectAltName = DNS:future.orix.test"], issuer: "root", serial: "1002"204 ))205 let weak = try workspace.issue(CertificateSpec(206 name: "weak", commonName: "weak.orix.test", organization: "Weak Org", country: nil, key: .rsa(1024), digest: "sha1",207 start: "260101000000Z", end: "360101000000Z", extensions: ["subjectAltName = DNS:weak.orix.test", "basicConstraints = CA:FALSE"], issuer: nil, serial: "00DEADBEEF"208 ))209 let expiring = try workspace.issue(CertificateSpec(210 name: "expiring", commonName: "soon.orix.test", organization: nil, country: nil, key: .ecP256,211 start: "260825000000Z", end: "260910000000Z", extensions: ["subjectAltName = DNS:soon.orix.test"], issuer: "root", serial: "1003"212 ))213 let localhost = try workspace.issue(CertificateSpec(214 name: "localhost", commonName: "localhost", organization: "ORIX Local Test", country: nil, key: .rsa(2048),215 start: "260101000000Z", end: "360101000000Z", extensions: ["subjectAltName = DNS:localhost, IP:127.0.0.1", "basicConstraints = CA:FALSE"], issuer: nil, serial: "2000"216 ))217 let plain = try workspace.issue(CertificateSpec(218 name: "plain", commonName: "plain.orix.test", organization: nil, country: nil, key: .ecP256,219 start: "260101000000Z", end: "261231235959Z", extensions: [], issuer: "root", serial: "1004"220 ))221 return GeneratedCertificates(workspace: workspace, root: root, leaf: leaf, expired: expired, future: future, weak: weak, expiring: expiring, localhost: localhost, plain: plain)222 } catch {223 print("NOTE skipped: openssl certificate generation unavailable (\(error))")224 return nil225 }226 }()227}228229/// `openssl s_server` on a free localhost port, serving the self-signed "localhost" certificate.230final class LocalTLSServer: @unchecked Sendable {231 let port: UInt16232 private let process: Process233234 init?(certificates: GeneratedCertificates) {235 guard let port = Self.freePort() else { return nil }236 self.port = port237 process = Process()238 process.executableURL = URL(fileURLWithPath: OpenSSLWorkspace.executable)239 process.arguments = ["s_server", "-accept", String(port), "-cert", certificates.workspace.path("localhost.pem"), "-key", certificates.workspace.path("localhost.key"), "-www"]240 process.standardOutput = FileHandle.nullDevice241 process.standardError = FileHandle.nullDevice242 process.standardInput = Pipe()243 do { try process.run() } catch { return nil }244 guard Self.waitUntilListening(port: port) else {245 process.terminate()246 return nil247 }248 }249250 deinit {251 if process.isRunning { process.terminate() }252 }253254 func stop() {255 if process.isRunning { process.terminate() }256 }257258 private static func freePort() -> UInt16? {259 let descriptor = socket(AF_INET, SOCK_STREAM, 0)260 guard descriptor >= 0 else { return nil }261 defer { close(descriptor) }262 var address = sockaddr_in()263 address.sin_len = UInt8(MemoryLayout<sockaddr_in>.size)264 address.sin_family = sa_family_t(AF_INET)265 address.sin_addr.s_addr = inet_addr("127.0.0.1")266 address.sin_port = 0267 let bound = withUnsafePointer(to: &address) { pointer in268 pointer.withMemoryRebound(to: sockaddr.self, capacity: 1) { bind(descriptor, $0, socklen_t(MemoryLayout<sockaddr_in>.size)) }269 }270 guard bound == 0 else { return nil }271 var length = socklen_t(MemoryLayout<sockaddr_in>.size)272 let named = withUnsafeMutablePointer(to: &address) { pointer in273 pointer.withMemoryRebound(to: sockaddr.self, capacity: 1) { getsockname(descriptor, $0, &length) }274 }275 guard named == 0 else { return nil }276 return UInt16(bigEndian: address.sin_port)277 }278279 private static func waitUntilListening(port: UInt16) -> Bool {280 for _ in 0..<100 {281 let descriptor = socket(AF_INET, SOCK_STREAM, 0)282 guard descriptor >= 0 else { return false }283 var address = sockaddr_in()284 address.sin_len = UInt8(MemoryLayout<sockaddr_in>.size)285 address.sin_family = sa_family_t(AF_INET)286 address.sin_addr.s_addr = inet_addr("127.0.0.1")287 address.sin_port = port.bigEndian288 let connected = withUnsafePointer(to: &address) { pointer in289 pointer.withMemoryRebound(to: sockaddr.self, capacity: 1) { connect(descriptor, $0, socklen_t(MemoryLayout<sockaddr_in>.size)) }290 }291 close(descriptor)292 if connected == 0 {293 usleep(100_000)294 return true295 }296 usleep(50_000)297 }298 return false299 }300}301302/// Words the product never uses in a finding.303func bannedWord(in finding: Finding) -> String? {304 let text = ([finding.title, finding.explanation, finding.recommendation ?? ""] + finding.notInspected + finding.evidence.map(\.label)).joined(separator: " ").lowercased()305 return ["hacked", "safe", "secure network"].first { text.contains($0) }306}307