Swift for operators: syntax, the Network framework, and the macOS attack surface

var userScore = 0
userScore = 100              // legal

let targetIP = "192.168.1.1"
// targetIP = "10.0.0.1"     // compile error

var inferredInt = 10                  // Int
let inferredString = "Swift"          // String
let inferredBool = true               // Bool

var explicitInt: Int = 42
let explicitDouble: Double = 3.141592
var emptyArray: [String] = []         // type annotation required for empty
var optionalString: String?           // optional, more on this below

var ipAddresses: [String] = ["192.168.1.1", "192.168.1.10"]
ipAddresses.append("192.168.1.50")

var portServices: [Int: String] = [
    22: "SSH",
    80: "HTTP",
    443: "HTTPS",
]
portServices[3389] = "RDP"

var findings: Set<String> = ["SQLi", "XSS", "CSRF"]
findings.insert("SQLi")          // no-op; sets dedupe
findings.insert("Buffer Overflow")

// Arithmetic: + - * / %    (integer / truncates; use Float/Double for fractional)
let sum = 10 + 3            // 13
let quot = 10 / 3           // 3
let rem  = 10 % 3           // 1

// Comparison: == != < > <= >=
let isEqual = 5 == 10       // false

// Logical: ! && ||  (Bool operands only; no truthiness coercion)
let hasAccess = isLoggedIn && isAdmin

// Bitwise: ~ & | ^ << >>
let mask = 0b1100 & 0b1010  // 0b1000 (8)
let shift = 0b1100 << 1     // 0b11000 (24)

if temperature > 20 {
    print("It's hot")
} else {
    print("It's not")
}

switch grade {
case "A":            print("Excellent")
case "B":            print("Good")
case "C", "D":       print("Acceptable")
case let other:      print("Invalid: \(other)")  // pattern binding
}

for i in 1...5 {                  // closed range, 1 through 5
    print(i)
}

var counter = 0
while counter < 5 {
    counter += 1
}

repeat {                          // do-while in other languages
    counter -= 1
} while counter > 0

func greet() {
    print("Hello")
}

func greet(name: String) {
    print("Hello, \(name)")
}

func add(_ a: Int, _ b: Int) -> Int {
    return a + b
}

greet()
greet(name: "Alice")              // argument labels are required by default
let sum = add(5, 3)               // the `_` in the signature suppresses labels

var optionalString: String? = "Hello"
var optionalInt: Int? = nil

if let s = optionalString {
    print("got: \(s)")
} else {
    print("was nil")
}

func process(_ value: String?) {
    guard let v = value else {
        return                              // early-exit pattern
    }
    print("processing: \(v)")
}

let display = optionalInt ?? -1             // default if nil
let forced  = optionalString!                // force unwrap; crashes if nil

enum NetworkError: Error {
    case invalidURL
    case noData
    case serverError(code: Int)
}

func fetchData(from urlString: String) throws -> Data {
    guard let url = URL(string: urlString) else {
        throw NetworkError.invalidURL
    }
    // ... actual fetch ...
    return Data()
}

do {
    let data = try fetchData(from: "https://example.com")
    print("got \(data.count) bytes")
} catch NetworkError.invalidURL {
    print("bad url")
} catch NetworkError.serverError(let code) {
    print("server error \(code)")
} catch {
    print("unexpected: \(error)")        // bound to local `error` variable
}

let optionalData = try? fetchData(from: url)   // converts throws to optional
// let crashing = try! fetchData(...)            // crashes on error

struct NetworkDevice {
    var ip: String
    var openPorts: [Int]
}

var a = NetworkDevice(ip: "192.168.1.1", openPorts: [80, 443])
var b = a                      // copy
b.openPorts.append(22)
print(a.openPorts)             // [80, 443]  -- unchanged
print(b.openPorts)             // [80, 443, 22]

class ExploitModule {
    var version: String
    init(version: String) { self.version = version }
}

let x = ExploitModule(version: "1.0")
let y = x                      // reference
y.version = "1.1"
print(x.version)               // "1.1"  -- both see the change

protocol Scanner {
    var target: String { get set }
    func performScan() throws -> String
}

struct PortScanner: Scanner {
    var target: String
    var ports: ClosedRange<Int>

    func performScan() throws -> String {
        // ... real scan logic ...
        return "Open ports on \(target): 22, 80"
    }
}

struct VulnScanner: Scanner {
    var target: String
    var vulnDB: [String]

    func performScan() throws -> String {
        return vulnDB.isEmpty
            ? "no findings"
            : "findings: \(vulnDB.joined(separator: ", "))"
    }
}

import Foundation
import CryptoKit            // Apple-platform modern crypto API
                            // Use `import Crypto` on Linux via swift-crypto

extension String {
    func sha256() -> String {
        let digest = SHA256.hash(data: Data(self.utf8))
        return digest.map { String(format: "%02x", $0) }.joined()
    }

    func base64Encoded() -> String? {
        return Data(self.utf8).base64EncodedString()
    }

    func base64Decoded() -> String? {
        guard let data = Data(base64Encoded: self) else { return nil }
        return String(data: data, encoding: .utf8)
    }
}

print("admin".sha256())            // 8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918
print("Hello World!".base64Encoded() ?? "")

import Foundation

func fetch(_ host: String) async throws -> String {
    try await Task.sleep(nanoseconds: 1_000_000_000)   // 1 second
    return "data from \(host)"
}

func runConcurrent() async {
    async let a = fetch("host1.com")
    async let b = fetch("host2.com")
    async let c = fetch("host3.com")

    do {
        let results = try await [a, b, c]              // all three run concurrently
        for r in results { print(r) }
    } catch {
        print("error: \(error)")
    }
}

actor LogCollector {
    private var logs: [String] = []
    func add(_ message: String) { logs.append(message) }
    func all() -> [String] { logs }
}

func demoActor() async {
    let collector = LogCollector()
    await collector.add("scan started")
    await collector.add("found port 80")
    let logs = await collector.all()
    for log in logs { print(log) }
}

Task { await runConcurrent() }
Task { await demoActor() }

# Install Swift via Apple's installer, or rustup-style toolchain manager `swiftly`
# https://www.swift.org/install/

# One-file script
echo 'print("Hello, World!")' > main.swift
swiftc main.swift -o hello
./hello

# Real project with dependencies (the modern default)
mkdir tool && cd tool
swift package init --type executable
swift build
swift run

import Foundation
import CryptoKit

extension Data {
    func sha256() -> Data {
        return Data(SHA256.hash(data: self))
    }
    var hex: String {
        return map { String(format: "%02x", $0) }.joined()
    }
}

func crack(target: String, charset: String, maxLen: Int) -> String? {
    func recurse(_ attempt: String) -> String? {
        if Data(attempt.utf8).sha256().hex == target {
            return attempt
        }
        if attempt.count >= maxLen {
            return nil
        }
        for ch in charset {
            if let result = recurse(attempt + String(ch)) {
                return result
            }
        }
        return nil
    }
    return recurse("")
}

let charset = "abcdefghijklmnopqrstuvwxyz0123456789"
// SHA256 of "abc"
let target = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
if let cracked = crack(target: target, charset: charset, maxLen: 4) {
    print("found: \(cracked)")
} else {
    print("not found")
}

import Foundation
import Network // Requires Network.framework, typically on Apple platforms

/// Scans a range of TCP ports on a given host.
/// - Parameters:
///   - host: The target host (IP address or hostname).
///   - ports: A closed range of ports to scan (for example, 1...1024).
///   - timeout: The maximum time in seconds to wait for a connection to establish for each port.
///   - completion: A closure that is called when the scan is completed, returning an array of open ports.
func scanPorts(host: String, ports: ClosedRange<Int>, timeout: TimeInterval = 2.0, completion: @escaping ([Int]) -> Void) {
    let dispatchQueue = DispatchQueue(label: "portScannerQueue", attributes: .concurrent)
    let dispatchGroup = DispatchGroup()
    var openPorts = [Int]()
    let lock = NSLock() // To safely append to openPorts from multiple threads

    print("Starting port scan on \(host) for ports \(ports.lowerBound)-\(ports.upperBound)...")

    for port in ports {
        dispatchGroup.enter() // Indicate that a task has started
        dispatchQueue.async {
            let endpoint = NWEndpoint.Host(host)
            let portEndpoint = NWEndpoint.Port(rawValue: UInt16(port))!
            let connection = NWConnection(to: portEndpoint, using: .tcp)

            connection.stateUpdateHandler = { state in
                switch state {
                case .ready:
                    lock.lock()
                    openPorts.append(port)
                    lock.unlock()
                    print("Port \(port) on \(host) is OPEN.")
                    connection.cancel() // Close the connection once port is found open
                    dispatchGroup.leave() // Indicate that this task is finished
                case .failed(let error):
                    // print("Port \(port) on \(host) is CLOSED or filtered. Error: \(error.localizedDescription)")
                    connection.cancel()
                    dispatchGroup.leave()
                case .cancelled:
                    dispatchGroup.leave()
                default:
                    break
                }
            }

            connection.start(queue: dispatchQueue)

            // Set a timeout for the connection attempt
            dispatchQueue.asyncAfter(deadline: .now() + timeout) {
                if connection.state != .ready && connection.state != .failed && connection.state != .cancelled {
                    // print("Port \(port) on \(host) timed out.")
                    connection.cancel() // Cancel if it hasn't connected or failed yet
                }
            }
        }
    }

    // Notify when all tasks in the group are complete
    dispatchGroup.notify(queue: .main) {
        let sortedOpenPorts = openPorts.sorted()
        print("\nPort scanning completed for \(host). Found \(sortedOpenPorts.count) open ports: \(sortedOpenPorts)")
        completion(sortedOpenPorts)
    }
}

// --- Usage Example ---
let targetHost = "scanme.nmap.org" // Use a legitimate target for testing, like scanme.nmap.org
let targetPorts: ClosedRange<Int> = 20...100

// Call the scanPorts function
scanPorts(host: targetHost, ports: targetPorts, timeout: 3.0) { foundPorts in
    print("Final list of open ports: \(foundPorts)")
}

// Note: For real-world use, ensure you have permission to scan the target host.
// The Network framework is primarily for client-side connections. For raw socket
// programming or more advanced packet manipulation, you might need to drop down
// to C-level APIs or use third-party libraries.

import Foundation

/// Searches for files with a specific extension within a directory and its subdirectories.
/// - Parameters:
///   - directoryURL: The URL of the directory to start the search from.
///   - fileExtension: The file extension to search for (for example, "log", "conf", "key").
/// - Returns: An array of URLs pointing to the found files.
func findFiles(in directoryURL: URL, withExtension fileExtension: String) -> [URL] {
    let fileManager = FileManager.default
    var foundFiles: [URL] = []

    guard let enumerator = fileManager.enumerator(at: directoryURL,
                                                  includingPropertiesForKeys: [.isRegularFileKey],
                                                  options: [.skipsHiddenFiles, .skipsPackageDescendants]) else {
        print("Error: Could not create enumerator for directory: \(directoryURL.path)")
        return []
    }

    print("Searching for *.\(fileExtension) files in \(directoryURL.path) and its subdirectories...")

    for case let fileURL as URL in enumerator {
        do {
            let fileAttributes = try fileURL.resourceValues(forKeys: [.isRegularFileKey])
            if fileAttributes.isRegularFile == true && fileURL.pathExtension == fileExtension {
                foundFiles.append(fileURL)
            }
        } catch {
            print("Error accessing file attributes for \(fileURL.path): \(error.localizedDescription)")
        }
    }
    return foundFiles
}

// --- Usage Example ---
// IMPORTANT: Replace with a path you have permission to access and want to scan.
// For security reasons, avoid scanning sensitive system directories without explicit understanding.
let startDirectory = URL(fileURLWithPath: "/Users/youruser/Documents") // Example: Your Documents folder
let sensitiveExtension = "log"

let sensitiveFiles = findFiles(in: startDirectory, withExtension: sensitiveExtension)

if sensitiveFiles.isEmpty {
    print("No .\(sensitiveExtension) files found in \(startDirectory.path).")
} else {
    print("\nFound the following .\(sensitiveExtension) files:")
    for file in sensitiveFiles {
        print("- \(file.lastPathComponent) (\(file.path))")
    }
}

// Example: Searching for SSH private keys
let sshKeyDirectory = URL(fileURLWithPath: "/Users/youruser/.ssh") // Example: Your SSH directory
let keyFiles = findFiles(in: sshKeyDirectory, withExtension: "key")

if !keyFiles.isEmpty {
    print("\nPotentially sensitive key files found:")
    for keyFile in keyFiles {
        print("- \(keyFile.lastPathComponent) (\(keyFile.path))")
    }
}

import Foundation
import Network

/// A simple TCP listener that echoes received data.
class TCPEchoListener {
    private let port: NWEndpoint.Port
    private var listener: NWListener?

    init(port: UInt16) {
        self.port = NWEndpoint.Port(rawValue: port)!
    }

    func start() throws {
        listener = try NWListener(using: .tcp, on: port)
        listener?.stateUpdateHandler = { state in
            switch state {
            case .ready:
                print("Listener ready on port \(self.port)")
            case .failed(let error):
                print("Listener failed with error: \(error)")
                self.stop()
            case .cancelled:
                print("Listener cancelled.")
            default:
                break
            }
        }

        listener?.newConnectionHandler = { newConnection in
            print("New connection established from \(String(describing: newConnection.endpoint))")
            self.handleConnection(newConnection)
        }

        listener?.start(queue: .main)
    }

    func stop() {
        listener?.cancel()
        listener = nil
        print("Listener stopped.")
    }

    private func handleConnection(_ connection: NWConnection) {
        connection.stateUpdateHandler = { state in
            switch state {
            case .ready:
                print("Connection ready: \(connection.debugDescription)")
                self.receive(on: connection)
            case .failed(let error):
                print("Connection failed: \(error)")
                connection.cancel()
            case .cancelled:
                print("Connection cancelled: \(connection.debugDescription)")
            default:
                break
            }
        }
        connection.start(queue: .main)
    }

    private func receive(on connection: NWConnection) {
        connection.receiveMessage { (content, context, isComplete, error) in
            if let content = content, !content.isEmpty {
                let receivedString = String(data: content, encoding: .utf8) ?? "Undecodable data"
                print("Received from \(connection.endpoint): \(receivedString)")
                // Echo back the received data
                connection.send(content: content, completion: .contentProcessed({ sendError in
                    if let sendError = sendError {
                        print("Send error: \(sendError)")
                    }
                }))
            }
            if let error = error {
                print("Receive error: \(error)")
                connection.cancel()
            } else if isComplete {
                print("Connection complete from \(connection.endpoint)")
                connection.cancel()
            } else {
                self.receive(on: connection) // Continue receiving
            }
        }
    }
}

// --- Usage Example ---
// For demonstration, you can test this by connecting to localhost:8080
// using `netcat` or a web browser after running the Swift script.
// Example netcat command: echo "Hello from netcat" | nc localhost 8080

let echoListener = TCPEchoListener(port: 8080)

do {
    try echoListener.start()
    print("TCP Echo Listener started on port 8080. Press Enter to stop.")
    _ = readLine() // Keep the program running until Enter is pressed
    echoListener.stop()
} catch {
    print("Failed to start listener: \(error)")
}

import Foundation

/// Fetches data from a given URL and attempts to parse it as JSON.
/// - Parameters:
///   - urlString: The URL string of the API endpoint.
///   - completion: A closure that is called with the result: a Dictionary if JSON parsing is successful, or an Error.
func fetchDataFromAPI(urlString: String, completion: @escaping (Result<[String: Any], Error>) -> Void) {
    guard let url = URL(string: urlString) else {
        completion(.failure(APIError.invalidURL))
        return
    }

    let task = URLSession.shared.dataTask(with: url) { data, response, error in
        if let error = error {
            completion(.failure(error))
            return
        }

        guard let httpResponse = response as? HTTPURLResponse, (200...299).contains(httpResponse.statusCode) else {
            completion(.failure(APIError.invalidResponse(statusCode: (response as? HTTPURLResponse)?.statusCode ?? -1)))
            return
        }

        guard let data = data else {
            completion(.failure(APIError.noData))
            return
        }

        do {
            if let json = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] {
                completion(.success(json))
            } else {
                completion(.failure(APIError.jsonParsingFailed))
            }
        } catch {
            completion(.failure(error))
        }
    }
    task.resume()
}

enum APIError: Error, LocalizedError {
    case invalidURL
    case invalidResponse(statusCode: Int)
    case noData
    case jsonParsingFailed

    var errorDescription: String? {
        switch self {
        case .invalidURL:
            return "The provided URL is invalid."
        case .invalidResponse(let statusCode):
            return "Invalid HTTP response with status code: \(statusCode)."
        case .noData:
            return "No data received from the API."
        case .jsonParsingFailed:
            return "Failed to parse JSON response."
        }
    }
}

// --- Usage Example ---
// Using a public dummy API for demonstration
let dummyAPIURL = "https://jsonplaceholder.typicode.com/todos/1"

fetchDataFromAPI(urlString: dummyAPIURL) { result in
    switch result {
    case .success(let json):
        print("API Response (JSON):")
        for (key, value) in json {
            print("- \(key): \(value)")
        }
    case .failure(let error):
        print("Error fetching data: \(error.localizedDescription)")
    }
}

// Example with a bad URL
let badAPIURL = "https://this.is.not.a.real.api.com/data"
fetchDataFromAPI(urlString: badAPIURL) { result in
    switch result {
    case .success(let json):
        print("API Response (JSON):")
        for (key, value) in json {
            print("- \(key): \(value)")
        }
    case .failure(let error):
        print("Error fetching data from bad URL: \(error.localizedDescription)")
    }
}

struct ShodanHost: Codable {
    let ip_str: String
    let ports: [Int]
    let hostnames: [String]
}

let (data, _) = try await URLSession.shared.data(from: shodanURL)
let host = try JSONDecoder().decode(ShodanHost.self, from: data)

import Foundation

/// Encodes a string to Base64.
/// - Parameter input: The string to encode.
/// - Returns: The Base64 encoded string, or nil if encoding fails.
func base64Encode(input: String) -> String? {
    guard let data = input.data(using: .utf8) else { return nil }
    return data.base64EncodedString()
}

/// Decodes a Base64 string.
/// - Parameter input: The Base64 string to decode.
/// - Returns: The decoded string, or nil if decoding fails.
func base64Decode(input: String) -> String? {
    guard let data = Data(base64Encoded: input) else { return nil }
    return String(data: data, encoding: .utf8)
}

/// Converts a string to its hexadecimal representation.
/// - Parameter input: The string to convert.
/// - Returns: The hexadecimal string.
func hexEncode(input: String) -> String {
    return input.data(using: .utf8)?.map { String(format: "%02x", $0) }.joined() ?? ""
}

/// Converts a hexadecimal string back to a regular string.
/// - Parameter input: The hexadecimal string.
/// - Returns: The decoded string, or nil if decoding fails.
func hexDecode(input: String) -> String? {
    var data = Data(capacity: input.count / 2)
    var index = input.startIndex
    while index < input.endIndex {
        let nextIndex = input.index(index, offsetBy: 2)
        if let byte = UInt8(input[index..<nextIndex], radix: 16) {
            data.append(byte)
        } else {
            return nil // Invalid hex character
        }
        index = nextIndex
    }
    return String(data: data, encoding: .utf8)
}

// --- Usage Example ---
let originalPayload = "shellcode_payload_here"

// Base64 Encoding/Decoding
if let encodedBase64 = base64Encode(input: originalPayload) {
    print("Original: \(originalPayload)")
    print("Base64 Encoded: \(encodedBase64)")
    if let decodedBase64 = base64Decode(input: encodedBase64) {
        print("Base64 Decoded: \(decodedBase64)")
    }
}

print("---")

// Hex Encoding/Decoding
let encodedHex = hexEncode(input: originalPayload)
print("Original: \(originalPayload)")
print("Hex Encoded: \(encodedHex)")
if let decodedHex = hexDecode(input: encodedHex) {
    print("Hex Decoded: \(decodedHex)")
}

// Example of URL Encoding/Decoding (built-in to Foundation)
let originalURLComponent = "param with spaces & special chars"
if let urlEncoded = originalURLComponent.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) {
    print("\nURL Encoded: \(urlEncoded)")
    if let urlDecoded = urlEncoded.removingPercentEncoding {
        print("URL Decoded: \(urlDecoded)")
    }
}