Cleartext Transmission of Sensitive Information

import Foundation

class VulnerableAuthService {
    // VULNERABLE: Sending password over HTTP
    func login(username: String, password: String) {
        let loginURL = "http://api.example.com/login" // HTTP - not HTTPS!
        guard let url = URL(string: loginURL) else { return }

        var request = URLRequest(url: url)
        request.httpMethod = "POST"

        // FLAW: Sensitive password transmitted in cleartext
        let body = "username=\(username)&password=\(password)"
        request.httpBody = body.data(using: .utf8)

        // ISSUE: Password can be intercepted on the network
        URLSession.shared.dataTask(with: request) { data, response, error in
            // Handle response
        }.resume()
    }

    // VULNERABLE: API token in HTTP request
    func fetchUserData(apiToken: String) {
        let endpoint = "http://api.example.com/user/profile"
        guard let url = URL(string: endpoint) else { return }

        var request = URLRequest(url: url)
        // FLAW: API token in Authorization header over HTTP
        request.addValue("Bearer \(apiToken)", forHTTPHeaderField: "Authorization")

        URLSession.shared.dataTask(with: request) { data, response, error in
            // Token exposed in cleartext
        }.resume()
    }

    // VULNERABLE: Credit card data over HTTP
    func submitPayment(creditCardNumber: String, cvv: String) {
        let paymentURL = "http://payments.example.com/process"
        guard let url = URL(string: paymentURL) else { return }

        let paymentData = [
            "cardNumber": creditCardNumber, // FLAW: PCI-DSS violation
            "cvv": cvv
        ]

        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.httpBody = try? JSONSerialization.data(withJSONObject: paymentData)

        // ISSUE: Credit card data transmitted in cleartext
        URLSession.shared.dataTask(with: request) { data, response, error in
            // Payment info exposed
        }.resume()
    }
}

import Alamofire

class AlamofireVulnerableService {
    // VULNERABLE: Alamofire request with sensitive data over HTTP
    func authenticateUser(email: String, password: String) {
        let loginEndpoint = "http://api.example.com/auth/login" // HTTP!

        let parameters: [String: String] = [
            "email": email,
            "password": password // FLAW: Password in HTTP POST
        ]

        // ISSUE: Alamofire sends password over unencrypted connection
        AF.request(loginEndpoint, method: .post, parameters: parameters).response { response in
            // Password exposed in network traffic
        }
    }

    // VULNERABLE: API key in HTTP headers
    func fetchData(apiKey: String) {
        let endpoint = "http://api.example.com/data"

        let headers: HTTPHeaders = [
            "X-API-Key": apiKey // FLAW: API key over HTTP
        ]

        AF.request(endpoint, headers: headers).responseJSON { response in
            // API key can be captured
        }
    }

    // VULNERABLE: SSN transmitted over HTTP
    func updateProfile(ssn: String) {
        let profileURL = "http://api.example.com/profile"

        AF.request(profileURL, method: .put, parameters: ["ssn": ssn]).response { response in
            // ISSUE: Social Security Number in cleartext
        }
    }
}

import Vapor

class VaporVulnerableClient {
    // VULNERABLE: Vapor client sending sensitive data over HTTP
    func sendWebhook(req: Request, authToken: String) async throws {
        let webhookURL = "http://partner-api.com/webhook" // HTTP!

        let payload = [
            "token": authToken, // FLAW: Auth token over HTTP
            "event": "user_created"
        ]

        // ISSUE: Sending auth token in cleartext
        let response = try await req.client.post(URI(string: webhookURL)) { webhookReq in
            try webhookReq.content.encode(payload)
        }
    }

    // VULNERABLE: Health data over HTTP
    func syncHealthData(req: Request, healthRecords: [String: Any]) async throws {
        let syncURL = "http://health-sync.example.com/upload"

        // FLAW: PHI (Protected Health Information) over HTTP - HIPAA violation
        let response = try await req.client.post(URI(string: syncURL)) { syncReq in
            try syncReq.content.encode(healthRecords)
        }
    }
}

import Network

class NetworkConnectionService {
    // VULNERABLE: NWConnection without TLS
    func sendData(password: String) {
        // HTTP endpoint (port 80) without TLS
        let endpoint = NWEndpoint.hostPort(host: "api.example.com", port: 80)

        // FLAW: Parameters without TLS
        let parameters = NWParameters.tcp

        let connection = NWConnection(to: endpoint, using: parameters)

        connection.start(queue: .global())

        // ISSUE: Sending password without encryption
        let data = "password=\(password)".data(using: .utf8)!
        connection.send(content: data, completion: .contentProcessed { error in
            // Password transmitted in cleartext
        })
    }

    // VULNERABLE: Token over insecure connection
    func authenticateWithToken(authToken: String) {
        let host = NWEndpoint.Host("api.example.com")
        let port = NWEndpoint.Port(rawValue: 8080)!
        let endpoint = NWEndpoint.hostPort(host: host, port: port)

        // No TLS configured
        let connection = NWConnection(to: endpoint, using: .tcp)
        connection.start(queue: .main)

        // FLAW: Auth token sent without encryption
        let tokenData = "Authorization: Bearer \(authToken)".data(using: .utf8)!
        connection.send(content: tokenData, completion: .idempotent)
    }
}

properties:
  sensitiveKinds:
    - access_control
    - crypto
    - financial
    - health
    - location
    - personal_identifiable_information

  encryptionFunctions:
    - encrypt
    - seal
    - encryptData