Swift Language
AES-kryptering
Sök…
AES-kryptering i CBC-läge med en slumpmässig IV (Swift 3.0)
Iv är prefix till den krypterade datan
aesCBC128Encrypt skapar en slumpmässig IV och förinställdes till den krypterade koden.
aesCBC128Decrypt kommer att använda det förinställda IV under dekryptering.
Ingångar är data och nyckeln är dataobjekt. Om en kodad form som Base64 vid behov konverteras till och / eller från i anropsmetoden.
Nyckeln ska vara exakt 128 bitar (16 bitar), 192 bitar (24 byte) eller 256 bitar (32 bitar) i längd. Om en annan nyckelstorlek används kastas ett fel.
PKCS # 7-stoppning är som standard inställd.
Detta exempel kräver Common Crypto
Det är nödvändigt att ha en överbryggande rubrik till projektet:
#import <CommonCrypto/CommonCrypto.h>
Lägg till Security.framework till projektet.
Detta är exempel, inte produktionskod.
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;
}
Exempel på användning:
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)")
}
Exempel på utgång:
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>
Anmärkningar:
Ett typiskt problem med exempelkod för CBC-läge är att det lämnar skapandet och delningen av den slumpmässiga IV till användaren. Detta exempel inkluderar generering av IV, förinställda den krypterade datan och använder den förinställda IV under dekryptering. Detta frigör den avslappnade användaren från detaljerna som är nödvändiga för CBC-läget .
För säkerhet bör den krypterade informationen också ha autentisering, detta exempelkod tillhandahåller inte att för att vara liten och möjliggöra bättre interoperabilitet för andra plattformar.
Det saknas också nyckelderivering av nyckeln från ett lösenord, det föreslås att PBKDF2 används när textlösenord används som nyckelmaterial.
För RNP-krypteringskod för robust produktionsklar multiplattformskodning .
Uppdaterad för att använda kast / fångst och flera nyckelstorlekar baserat på den medföljande nyckeln.
AES-kryptering i CBC-läge med en slumpmässig IV (Swift 2.3)
Iv är prefix till den krypterade datan
aesCBC128Encrypt skapar en slumpmässig IV och förinsticks till den krypterade koden. aesCBC128Decrypt kommer att använda den förinställda IV under dekryptering.
Ingångar är data och nyckeln är dataobjekt. Om en kodad form som Base64 vid behov konverteras till och / eller från i anropsmetoden.
Nyckeln ska vara exakt 128 bitar (16-byte). För andra nyckelstorlekar, se Swift 3.0-exemplet.
PKCS # 7-stoppning är som standard inställd.
Detta exempel kräver Common Crypto Det är nödvändigt att ha en överbryggande rubrik till projektet: #import <CommonCrypto / CommonCrypto.h> Lägg till Security.framework till projektet.
Se Swift 3-exempel för anteckningar.
Detta är exempel, inte produktionskod.
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;
}
Exempel på användning:
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))")
Exempel på utgång:
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-kryptering i ECB-läge med PKCS7-stoppning
Från Apple-dokumentation för IV,
Denna parameter ignoreras om ECB-läge används eller om en strömcifferalgoritm är vald.
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
}