Inadequate Padding

import Security
import Foundation

func encryptRSAPKCS1_Vulnerable(_ plaintext: Data, publicKey: SecKey) throws -> Data {
    // FLAW: PKCS#1 v1.5 padding vulnerable to Bleichenbacher attack
    var error: Unmanaged<CFError>?
    guard let encrypted = SecKeyCreateEncryptedData(
        publicKey,
        .rsaEncryptionPKCS1,  // FLAW: Vulnerable padding
        plaintext as CFData,
        &error
    ) else {
        throw error!.takeRetainedValue() as Error
    }

    return encrypted as Data
}

import CryptoSwift

func encryptNoPadding_Vulnerable(_ plaintext: String, key: [UInt8], iv: [UInt8]) throws -> [UInt8] {
    // FLAW: No padding specified for block cipher
    let aes = try AES(key: key, blockMode: CBC(iv: iv), padding: .noPadding)  // FLAW
    return try aes.encrypt(Array(plaintext.utf8))
}

import CryptoSwift

func encryptZeroPadding_Vulnerable(_ plaintext: String, key: [UInt8], iv: [UInt8]) throws -> [UInt8] {
    // FLAW: Zero padding has ambiguity issues
    let aes = try AES(key: key, blockMode: CBC(iv: iv), padding: .zeroPadding)  // FLAW
    return try aes.encrypt(Array(plaintext.utf8))
}

import Security
import Foundation

func encryptRSAOAEP_Fixed(_ plaintext: Data, publicKey: SecKey) throws -> Data {
    // FIXED: OAEP padding (PKCS#1 v2.0) is secure
    var error: Unmanaged<CFError>?
    guard let encrypted = SecKeyCreateEncryptedData(
        publicKey,
        .rsaEncryptionOAEPSHA256,  // FIXED: Secure padding
        plaintext as CFData,
        &error
    ) else {
        throw error!.takeRetainedValue() as Error
    }

    return encrypted as Data
}

func decryptRSAOAEP_Fixed(_ ciphertext: Data, privateKey: SecKey) throws -> Data {
    var error: Unmanaged<CFError>?
    guard let decrypted = SecKeyCreateDecryptedData(
        privateKey,
        .rsaEncryptionOAEPSHA256,  // FIXED
        ciphertext as CFData,
        &error
    ) else {
        throw error!.takeRetainedValue() as Error
    }

    return decrypted as Data
}

import CryptoSwift

struct EncryptedData {
    let ciphertext: [UInt8]
    let iv: [UInt8]
}

func encryptWithPKCS7_Fixed(_ plaintext: String, key: [UInt8]) throws -> EncryptedData {
    // FIXED: PKCS#7 padding for block cipher
    let iv = (0..<AES.blockSize).map { _ in UInt8.random(in: 0...UInt8.max) }
    let aes = try AES(key: key, blockMode: CBC(iv: iv), padding: .pkcs7)  // FIXED
    let ciphertext = try aes.encrypt(Array(plaintext.utf8))

    return EncryptedData(ciphertext: ciphertext, iv: iv)
}

func decryptWithPKCS7_Fixed(_ encrypted: EncryptedData, key: [UInt8]) throws -> String {
    let aes = try AES(key: key, blockMode: CBC(iv: encrypted.iv), padding: .pkcs7)
    let decrypted = try aes.decrypt(encrypted.ciphertext)

    return String(bytes: decrypted, encoding: .utf8) ?? ""
}

import CryptoKit
import Foundation

func encryptWithAESGCM_Fixed(_ plaintext: Data, key: SymmetricKey) throws -> Data {
    // FIXED: AES-GCM is AEAD mode, doesn't require padding
    let sealedBox = try AES.GCM.seal(plaintext, using: key)

    // Combined data includes nonce, ciphertext, and authentication tag
    return sealedBox.combined!
}

func decryptWithAESGCM_Fixed(_ combined: Data, key: SymmetricKey) throws -> Data {
    let sealedBox = try AES.GCM.SealedBox(combined: combined)
    return try AES.GCM.open(sealedBox, using: key)
}

import Security
import CryptoKit
import Foundation

func signWithRSAPSS_Fixed(_ message: Data, privateKey: SecKey) throws -> Data {
    // FIXED: PSS padding for RSA signatures
    let hash = SHA256.hash(data: message)

    var error: Unmanaged<CFError>?
    guard let signature = SecKeyCreateSignature(
        privateKey,
        .rsaSignatureMessagePSSSHA256,  // FIXED: PSS padding
        Data(hash) as CFData,
        &error
    ) else {
        throw error!.takeRetainedValue() as Error
    }

    return signature as Data
}

func verifyRSAPSS_Fixed(_ message: Data, signature: Data, publicKey: SecKey) throws -> Bool {
    let hash = SHA256.hash(data: message)

    var error: Unmanaged<CFError>?
    let result = SecKeyVerifySignature(
        publicKey,
        .rsaSignatureMessagePSSSHA256,  // FIXED
        Data(hash) as CFData,
        signature as CFData,
        &error
    )

    if let error = error {
        throw error.takeRetainedValue() as Error
    }

    return result
}