Swift Language
Cifrado AES
Buscar..
Cifrado AES en modo CBC con un IV aleatorio (Swift 3.0)
El iv está prefijado a los datos encriptados.
aesCBC128Encrypt creará un IV aleatorio y con prefijo al código encriptado.
aesCBC128Decrypt usará el prefijo IV durante el descifrado.
Las entradas son los datos y la clave son los objetos de datos. Si una forma codificada, como Base64, si es necesario, se convierte y / o en el método de llamada.
La clave debe tener exactamente 128 bits (16 bytes), 192 bits (24 bytes) o 256 bits (32 bytes) de longitud. Si se usa otro tamaño de clave, se lanzará un error.
El relleno PKCS # 7 se establece de forma predeterminada.
Este ejemplo requiere Crypto común
Es necesario tener un encabezado puente al proyecto:
#import <CommonCrypto/CommonCrypto.h>
Agregue el Security.framework al proyecto.
Este es un ejemplo, no un código de producción.
enum AESError: Error {
case KeyError((String, Int))
case IVError((String, Int))
case CryptorError((String, Int))
}
// The iv is prefixed to the encrypted data
func aesCBCEncrypt(data:Data, keyData:Data) throws -> Data {
let keyLength = keyData.count
let validKeyLengths = [kCCKeySizeAES128, kCCKeySizeAES192, kCCKeySizeAES256]
if (validKeyLengths.contains(keyLength) == false) {
throw AESError.KeyError(("Invalid key length", keyLength))
}
let ivSize = kCCBlockSizeAES128;
let cryptLength = size_t(ivSize + data.count + kCCBlockSizeAES128)
var cryptData = Data(count:cryptLength)
let status = cryptData.withUnsafeMutableBytes {ivBytes in
SecRandomCopyBytes(kSecRandomDefault, kCCBlockSizeAES128, ivBytes)
}
if (status != 0) {
throw AESError.IVError(("IV generation failed", Int(status)))
}
var numBytesEncrypted :size_t = 0
let options = CCOptions(kCCOptionPKCS7Padding)
let cryptStatus = cryptData.withUnsafeMutableBytes {cryptBytes in
data.withUnsafeBytes {dataBytes in
keyData.withUnsafeBytes {keyBytes in
CCCrypt(CCOperation(kCCEncrypt),
CCAlgorithm(kCCAlgorithmAES),
options,
keyBytes, keyLength,
cryptBytes,
dataBytes, data.count,
cryptBytes+kCCBlockSizeAES128, cryptLength,
&numBytesEncrypted)
}
}
}
if UInt32(cryptStatus) == UInt32(kCCSuccess) {
cryptData.count = numBytesEncrypted + ivSize
}
else {
throw AESError.CryptorError(("Encryption failed", Int(cryptStatus)))
}
return cryptData;
}
// The iv is prefixed to the encrypted data
func aesCBCDecrypt(data:Data, keyData:Data) throws -> Data? {
let keyLength = keyData.count
let validKeyLengths = [kCCKeySizeAES128, kCCKeySizeAES192, kCCKeySizeAES256]
if (validKeyLengths.contains(keyLength) == false) {
throw AESError.KeyError(("Invalid key length", keyLength))
}
let ivSize = kCCBlockSizeAES128;
let clearLength = size_t(data.count - ivSize)
var clearData = Data(count:clearLength)
var numBytesDecrypted :size_t = 0
let options = CCOptions(kCCOptionPKCS7Padding)
let cryptStatus = clearData.withUnsafeMutableBytes {cryptBytes in
data.withUnsafeBytes {dataBytes in
keyData.withUnsafeBytes {keyBytes in
CCCrypt(CCOperation(kCCDecrypt),
CCAlgorithm(kCCAlgorithmAES128),
options,
keyBytes, keyLength,
dataBytes,
dataBytes+kCCBlockSizeAES128, clearLength,
cryptBytes, clearLength,
&numBytesDecrypted)
}
}
}
if UInt32(cryptStatus) == UInt32(kCCSuccess) {
clearData.count = numBytesDecrypted
}
else {
throw AESError.CryptorError(("Decryption failed", Int(cryptStatus)))
}
return clearData;
}
Ejemplo de uso:
let clearData = "clearData0123456".data(using:String.Encoding.utf8)!
let keyData = "keyData890123456".data(using:String.Encoding.utf8)!
print("clearData: \(clearData as NSData)")
print("keyData: \(keyData as NSData)")
var cryptData :Data?
do {
cryptData = try aesCBCEncrypt(data:clearData, keyData:keyData)
print("cryptData: \(cryptData! as NSData)")
}
catch (let status) {
print("Error aesCBCEncrypt: \(status)")
}
let decryptData :Data?
do {
let decryptData = try aesCBCDecrypt(data:cryptData!, keyData:keyData)
print("decryptData: \(decryptData! as NSData)")
}
catch (let status) {
print("Error aesCBCDecrypt: \(status)")
}
Ejemplo de salida:
clearData: <636c6561 72446174 61303132 33343536>
keyData: <6b657944 61746138 39303132 33343536>
cryptData: <92c57393 f454d959 5a4d158f 6e1cd3e7 77986ee9 b2970f49 2bafcf1a 8ee9d51a bde49c31 d7780256 71837a61 60fa4be0>
decryptData: <636c6561 72446174 61303132 33343536>
Notas:
Un problema típico con el código de ejemplo del modo CBC es que deja la creación y el intercambio del IV aleatorio al usuario. Este ejemplo incluye la generación del IV, prefijó los datos cifrados y usa el IV prefijado durante el descifrado. Esto libera al usuario ocasional de los detalles que son necesarios para el modo CBC .
Por seguridad, los datos cifrados también deben tener autenticación, este código de ejemplo no proporciona eso para ser pequeño y permitir una mejor interoperabilidad para otras plataformas.
También falta la derivación clave de la clave de una contraseña, se sugiere que se use PBKDF2 si se usan contraseñas de texto como material de claves.
Para un robusto código de encriptación multiplataforma listo para producción, consulte RNCryptor
Actualizado para usar tirar / atrapar y múltiples tamaños de clave basados en la clave provista.
Cifrado AES en modo CBC con un IV aleatorio (Swift 2.3)
El iv está prefijado a los datos encriptados.
aesCBC128Encrypt creará un IV aleatorio y con prefijo al código encriptado. aesCBC128Decrypt usará el prefijo IV durante el descifrado.
Las entradas son los datos y la clave son los objetos de datos. Si una forma codificada, como Base64, si es necesario, se convierte y / o en el método de llamada.
La clave debe ser exactamente de 128 bits (16 bytes). Para otros tamaños de clave vea el ejemplo de Swift 3.0.
El relleno PKCS # 7 se establece de forma predeterminada.
Este ejemplo requiere Common Crypto. Es necesario tener un encabezado puente para el proyecto: #import <CommonCrypto / CommonCrypto.h> Agregue el archivo Security.framework al proyecto.
Vea el ejemplo de Swift 3 para notas.
Este es un ejemplo, no un código de producción.
func aesCBC128Encrypt(data data:[UInt8], keyData:[UInt8]) -> [UInt8]? {
let keyLength = size_t(kCCKeySizeAES128)
let ivLength = size_t(kCCBlockSizeAES128)
let cryptDataLength = size_t(data.count + kCCBlockSizeAES128)
var cryptData = [UInt8](count:ivLength + cryptDataLength, repeatedValue:0)
let status = SecRandomCopyBytes(kSecRandomDefault, Int(ivLength), UnsafeMutablePointer<UInt8>(cryptData));
if (status != 0) {
print("IV Error, errno: \(status)")
return nil
}
var numBytesEncrypted :size_t = 0
let cryptStatus = CCCrypt(CCOperation(kCCEncrypt),
CCAlgorithm(kCCAlgorithmAES128),
CCOptions(kCCOptionPKCS7Padding),
keyData, keyLength,
cryptData,
data, data.count,
&cryptData + ivLength, cryptDataLength,
&numBytesEncrypted)
if UInt32(cryptStatus) == UInt32(kCCSuccess) {
cryptData.removeRange(numBytesEncrypted+ivLength..<cryptData.count)
}
else {
print("Error: \(cryptStatus)")
return nil;
}
return cryptData;
}
func aesCBC128Decrypt(data data:[UInt8], keyData:[UInt8]) -> [UInt8]? {
let clearLength = size_t(data.count)
var clearData = [UInt8](count:clearLength, repeatedValue:0)
let keyLength = size_t(kCCKeySizeAES128)
let ivLength = size_t(kCCBlockSizeAES128)
var numBytesDecrypted :size_t = 0
let cryptStatus = CCCrypt(CCOperation(kCCDecrypt),
CCAlgorithm(kCCAlgorithmAES128),
CCOptions(kCCOptionPKCS7Padding),
keyData, keyLength,
data,
UnsafePointer<UInt8>(data) + ivLength, data.count - ivLength,
&clearData, clearLength,
&numBytesDecrypted)
if UInt32(cryptStatus) == UInt32(kCCSuccess) {
clearData.removeRange(numBytesDecrypted..<clearLength)
} else {
print("Error: \(cryptStatus)")
return nil;
}
return clearData;
}
Ejemplo de uso:
let clearData = toData("clearData0123456")
let keyData = toData("keyData890123456")
print("clearData: \(toHex(clearData))")
print("keyData: \(toHex(keyData))")
let cryptData = aesCBC128Encrypt(data:clearData, keyData:keyData)!
print("cryptData: \(toHex(cryptData))")
let decryptData = aesCBC128Decrypt(data:cryptData, keyData:keyData)!
print("decryptData: \(toHex(decryptData))")
Ejemplo de salida:
clearData: <636c6561 72446174 61303132 33343536>
keyData: <6b657944 61746138 39303132 33343536>
cryptData: <9fce4323 830e3734 93dd93bf e464f72a a653a3a5 2c40d5ea e90c1017 958750a7 ff094c53 6a81b458 b1fbd6d4 1f583298>
decryptData: <636c6561 72446174 61303132 33343536>
Cifrado AES en modo ECB con relleno PKCS7
De la documentación de Apple para IV,
Este parámetro se ignora si se usa el modo ECB o si se selecciona un algoritmo de cifrado de flujo.
func AESEncryption(key: String) -> String? {
let keyData: NSData! = (key as NSString).data(using: String.Encoding.utf8.rawValue) as NSData!
let data: NSData! = (self as NSString).data(using: String.Encoding.utf8.rawValue) as NSData!
let cryptData = NSMutableData(length: Int(data.length) + kCCBlockSizeAES128)!
let keyLength = size_t(kCCKeySizeAES128)
let operation: CCOperation = UInt32(kCCEncrypt)
let algoritm: CCAlgorithm = UInt32(kCCAlgorithmAES128)
let options: CCOptions = UInt32(kCCOptionECBMode + kCCOptionPKCS7Padding)
var numBytesEncrypted :size_t = 0
let cryptStatus = CCCrypt(operation,
algoritm,
options,
keyData.bytes, keyLength,
nil,
data.bytes, data.length,
cryptData.mutableBytes, cryptData.length,
&numBytesEncrypted)
if UInt32(cryptStatus) == UInt32(kCCSuccess) {
cryptData.length = Int(numBytesEncrypted)
var bytes = [UInt8](repeating: 0, count: cryptData.length)
cryptData.getBytes(&bytes, length: cryptData.length)
var hexString = ""
for byte in bytes {
hexString += String(format:"%02x", UInt8(byte))
}
return hexString
}
return nil
}
