SPB Git

Repository Public License

TestSupport.swift 15.2 KB 307 lines swift

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
Files main
Menu

Theme