Swift Language
AES-Verschlüsselung
Suche…
AES-Verschlüsselung im CBC-Modus mit einer zufälligen IV (Swift 3.0)
Das iv ist den verschlüsselten Daten vorangestellt
aesCBC128Encrypt erstellt eine zufällige IV und wird dem verschlüsselten Code vorangestellt.
aesCBC128Decrypt verwendet das vorangestellte IV während der Entschlüsselung.
Eingaben sind die Daten und der Schlüssel sind Datenobjekte. Wenn ein verschlüsseltes Formular, z. B. Base64, erforderlich ist, konvertieren Sie in und / oder von der aufrufenden Methode.
Der Schlüssel sollte genau 128 Bit (16 Byte), 192 Bit (24 Byte) oder 256 Bit (32 Byte) lang sein. Wenn eine andere Schlüsselgröße verwendet wird, wird ein Fehler ausgegeben.
Die PKCS # 7-Auffüllung ist standardmäßig eingestellt.
Dieses Beispiel erfordert Common Crypto
Es ist notwendig, einen Brückenkopf zum Projekt zu haben:
#import <CommonCrypto/CommonCrypto.h>
Fügen Sie das Security.framework dem Projekt hinzu.
Dies ist ein Beispiel, kein Produktionscode.
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;
}
Verwendungsbeispiel:
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)")
}
Beispielausgabe:
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>
Anmerkungen:
Ein typisches Problem mit Beispielcode im CBC-Modus besteht darin, dass die Erstellung und gemeinsame Nutzung der Zufalls-IV dem Benutzer überlassen wird. In diesem Beispiel wird die IV generiert, die verschlüsselten Daten werden vorangestellt und während der Entschlüsselung die vorangestellte IV verwendet. Dies befreit den gelegentlichen Benutzer von den Details, die für den CBC-Modus erforderlich sind.
Aus Sicherheitsgründen sollten die verschlüsselten Daten auch über eine Authentifizierung verfügen. In diesem Beispielcode ist dies nicht vorgesehen, um klein zu sein und eine bessere Interoperabilität für andere Plattformen zu ermöglichen.
Es fehlt auch die Schlüsselableitung des Schlüssels aus einem Kennwort. Es wird vorgeschlagen, PBKDF2 zu verwenden, wenn Textkennwörter als Schlüsselmaterial verwendet werden.
Für robusten, produktionsbereiten Verschlüsselungscode für mehrere Plattformen siehe RNCryptor .
Aktualisiert, um Wurf / Fang und mehrere Schlüsselgrößen basierend auf dem bereitgestellten Schlüssel zu verwenden.
AES-Verschlüsselung im CBC-Modus mit einer zufälligen IV (Swift 2.3)
Das iv ist den verschlüsselten Daten vorangestellt
aesCBC128Encrypt erstellt eine zufällige IV und wird dem verschlüsselten Code vorangestellt. aesCBC128Decrypt verwendet das vorangestellte IV während der Entschlüsselung.
Eingaben sind die Daten und der Schlüssel sind Datenobjekte. Wenn ein verschlüsseltes Formular, z. B. Base64, erforderlich ist, konvertieren Sie in und / oder von der aufrufenden Methode.
Der Schlüssel sollte genau 128 Bit (16 Byte) betragen. Für andere Schlüsselgrößen siehe das Swift 3.0-Beispiel.
Die PKCS # 7-Auffüllung ist standardmäßig eingestellt.
Für dieses Beispiel ist Common Crypto erforderlich. Für das Projekt muss ein Bridging-Header vorhanden sein: #import <CommonCrypto / CommonCrypto.h> Fügen Sie das Security.framework dem Projekt hinzu.
Hinweise finden Sie im Swift 3-Beispiel.
Dies ist ein Beispiel, kein Produktionscode.
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;
}
Verwendungsbeispiel:
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))")
Beispielausgabe:
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>
AES-Verschlüsselung im ECB-Modus mit PKCS7-Auffüllung
Aus der Apple-Dokumentation für IV,
Dieser Parameter wird ignoriert, wenn der ECB-Modus verwendet wird oder wenn ein Stream-Verschlüsselungsalgorithmus ausgewählt ist.
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
}
