CryptoSwift Documentation

CryptoSwift uses Array<UInt8> as its base type for all operations. You can easily convert between Data and byte arrays using convenience properties and methods.

• Data to Bytes: Use the .byteArray property on a Data object.
• Bytes to Data: Initialize Data with an array of bytes.
• Hexadecimal: Use Array<UInt8>(hex: "...") to create bytes from a hex string, and .toHexString() to convert bytes to a hex string.
• String to Bytes: Use the .bytes property on a String.
• Base64: Use .toBase64() to encode bytes, and .decryptBase64ToString(cipher) or .decryptBase64(cipher) on a Base64 string to decode.

// Data from bytes
let data = Data([0x01, 0x02, 0x03])

// Data to Array<UInt8>
let bytes = data.byteArray                // [1,2,3]

// Hexadecimal encoding
let bytes = Array<UInt8>(hex: "0x010203")  // [1,2,3]
let hex   = bytes.toHexString()            // "010203"

// Build bytes out of String
let bytes: Array<UInt8> = "cipherkey".bytes  // Array("cipherkey".utf8)

// Base64 helpers
"aPf/i9th9iX+vf49eR7PYk2q7S5xmm3jkRLejgzHNJs=".decryptBase64ToString(cipher)
"aPf/i9th9iX+vf49eR7PYk2q7S5xmm3jkRLejgzHNJs=".decryptBase64(cipher)
bytes.toBase64()

CryptoSwift supports various AES modes (CBC, CFB, OFB, CTR, GCM, CCM).

Key Lengths:

• AES-128: 16 bytes
• AES-192: 24 bytes
• AES-256: 32 bytes

Important Notes:

• Padding: CryptoSwift uses PKCS7 padding by default. To disable it, set padding: .noPadding in the initializer.
• Incremental Updates: For large files, use .makeEncryptor() to create a Cryptor instance and process data in chunks using .update(withBytes:) and .finish() to save memory.
• AES-GCM: In .combined mode, the authentication tag is automatically appended to the ciphertext. Note that a GCM instance should not be reused for both encoding and decoding.

// Standard AES-CBC encryption
let aes = try AES(key: [1,2,3 /* ... 32 bytes total */], blockMode: CBC(iv: [1,2,3 /* ... 16 bytes total */]), padding: .pkcs7)
let encryptedBytes = try aes.encrypt(Array("secret message".utf8))

// Incremental AES encryption
do {
    var encryptor = try AES(key: "keykeykeykeykeyk", iv: "drowssapdrowssap").makeEncryptor()
    var ciphertext = Array<UInt8>()
    ciphertext += try encryptor.update(withBytes: Array("Nullam quis risus ".utf8))
    ciphertext += try encryptor.update(withBytes: Array("eget urna mollis ".utf8))
    ciphertext += try encryptor.finish()
} catch {
    print(error)
}

// AES-GCM (Combined mode)
do {
    let gcm = GCM(iv: iv, mode: .combined)
    let aes = try AES(key: key, blockMode: gcm, padding: .noPadding)
    let encrypted = try aes.encrypt(plaintext)
    let tag = gcm.authenticationTag
} catch {
    // failed
}

You can calculate cryptographic digests (MD5, SHA1, SHA256, etc.) on Array<UInt8>, Data, or String types.

Hashing Array<UInt8> or Data: Use the direct extension methods like .md5(), .sha1(), .sha256(), etc.

Incremental Hashing: For large inputs, use the Digest class to update the hash state incrementally to save memory.

Hashing Strings: You can call .md5() directly on a String (which internally converts it to bytes).

// Hashing an array of bytes
let input: Array<UInt8> = [0x01, 0x02, 0x03]
let md5Digest = input.md5()

// Hashing Data
let data = Data([0x01, 0x02, 0x03])
let sha256Digest = data.sha256()

// Incremental hashing
do {
    var digest = MD5()
    _ = try digest.update(withBytes: [0x31, 0x32])
    _ = try digest.update(withBytes: [0x33])
    let result = try digest.finish()
} catch {
    print(error)
}

// Hashing a String
let hash = "123".md5()