it-swarm.com.de

AES verschlüsseln und entschlüsseln

Ich schreibe eine Anwendung von Swift, ich brauche die AES Encrypt- und Decrypt-Funktionalität. Ich habe verschlüsselte Daten von einer anderen .Net-Lösung erhalten, kann aber nichts finden.

Dies ist meine .net-Verschlüsselung:

 public static byte[] AES_Encrypt(byte[] bytesToBeEncrypted, byte[] passwordBytes)
    {
        byte[] encryptedBytes = null;

        byte[] saltBytes = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };

        using (MemoryStream ms = new MemoryStream())
        {
            using (RijndaelManaged AES = new RijndaelManaged())
            {
                AES.KeySize = 256;
                AES.BlockSize = 128;

                var key = new Rfc2898DeriveBytes(passwordBytes, saltBytes, 1000);
                AES.Key = key.GetBytes(AES.KeySize / 8);
                AES.IV = key.GetBytes(AES.BlockSize / 8);

                AES.Mode = CipherMode.CBC;

                using (var cs = new CryptoStream(ms, AES.CreateEncryptor(), CryptoStreamMode.Write))
                {
                    cs.Write(bytesToBeEncrypted, 0, bytesToBeEncrypted.Length);
                    cs.Close();
                }
                encryptedBytes = ms.ToArray();
            }
        }

        return encryptedBytes;
    }

Ich muss die Funktion in Swift entschlüsseln.

21
mehr

Ich habe die Lösung gefunden, es ist eine gute Bibliothek.

Plattformübergreifende 256-Bit-AES-Verschlüsselung/Entschlüsselung.

Dieses Projekt enthält die Implementierung einer 256-Bit-AES-Verschlüsselung, die auf allen Plattformen (C #, iOS, Android) funktioniert. Eines der Hauptziele besteht darin, AES auf allen Plattformen mit einfacher Implementierung zum Laufen zu bringen.

Unterstützte Plattformen: IOS, Android, Windows (C #).

https://github.com/Pakhee/Cross-platform-AES-encryption

0
mehr

CryptoSwift Beispiel

Auf Swift 2 aktualisiert

import Foundation
import CryptoSwift

extension String {
    func aesEncrypt(key: String, iv: String) throws -> String{
        let data = self.dataUsingEncoding(NSUTF8StringEncoding)
        let enc = try AES(key: key, iv: iv, blockMode:.CBC).encrypt(data!.arrayOfBytes(), padding: PKCS7())
        let encData = NSData(bytes: enc, length: Int(enc.count))
        let base64String: String = encData.base64EncodedStringWithOptions(NSDataBase64EncodingOptions(rawValue: 0));
        let result = String(base64String)
        return result
    }

    func aesDecrypt(key: String, iv: String) throws -> String {
        let data = NSData(base64EncodedString: self, options: NSDataBase64DecodingOptions(rawValue: 0))
        let dec = try AES(key: key, iv: iv, blockMode:.CBC).decrypt(data!.arrayOfBytes(), padding: PKCS7())
        let decData = NSData(bytes: dec, length: Int(dec.count))
        let result = NSString(data: decData, encoding: NSUTF8StringEncoding)
        return String(result!)
    }
}

Verwendungszweck:

let key = "bbC2H19lkVbQDfakxcrtNMQdd0FloLyw" // length == 32
let iv = "gqLOHUioQ0QjhuvI" // length == 16
let s = "string to encrypt"
let enc = try! s.aesEncrypt(key, iv: iv)
let dec = try! enc.aesDecrypt(key, iv: iv)
print(s) // string to encrypt
print("enc:\(enc)") // 2r0+KirTTegQfF4wI8rws0LuV8h82rHyyYz7xBpXIpM=
print("dec:\(dec)") // string to encrypt
print("\(s == dec)") // true

Vergewissern Sie sich, dass Sie die richtige Länge von iv (16) und Taste (32) haben, und drücken Sie nicht "Blockgröße und Initialisierungsvektor muss dieselbe Länge haben!" Error.

29
yutelin

CryptoSwift Beispiel

Swift 4 aktualisiert. *

func aesEncrypt() throws -> String {
    let encrypted = try AES(key: KEY, iv: IV, padding: .pkcs7).encrypt([UInt8](self.data(using: .utf8)!))
    return Data(encrypted).base64EncodedString()
}

func aesDecrypt() throws -> String {
    guard let data = Data(base64Encoded: self) else { return "" }
    let decrypted = try AES(key: KEY, iv: IV, padding: .pkcs7).decrypt([UInt8](data))
    return String(bytes: Data(decrypted).bytes, encoding: .utf8) ?? "Could not decrypt"
}
21
Maksim Kniazev

Von SHS zur Verfügung gestellter Code hat für mich nicht funktioniert, aber anscheinend funktionierte dies (ich habe einen Bridging-Header verwendet: #import <CommonCrypto/CommonCrypto.h>):

extension String {

    func aesEncrypt(key:String, iv:String, options:Int = kCCOptionPKCS7Padding) -> String? {
        if let keyData = key.data(using: String.Encoding.utf8),
            let data = self.data(using: String.Encoding.utf8),
            let cryptData    = NSMutableData(length: Int((data.count)) + kCCBlockSizeAES128) {


            let keyLength              = size_t(kCCKeySizeAES128)
            let operation: CCOperation = UInt32(kCCEncrypt)
            let algoritm:  CCAlgorithm = UInt32(kCCAlgorithmAES128)
            let options:   CCOptions   = UInt32(options)



            var numBytesEncrypted :size_t = 0

            let cryptStatus = CCCrypt(operation,
                                      algoritm,
                                      options,
                                      (keyData as NSData).bytes, keyLength,
                                      iv,
                                      (data as NSData).bytes, data.count,
                                      cryptData.mutableBytes, cryptData.length,
                                      &numBytesEncrypted)

            if UInt32(cryptStatus) == UInt32(kCCSuccess) {
                cryptData.length = Int(numBytesEncrypted)
                let base64cryptString = cryptData.base64EncodedString(options: .lineLength64Characters)
                return base64cryptString


            }
            else {
                return nil
            }
        }
        return nil
    }

    func aesDecrypt(key:String, iv:String, options:Int = kCCOptionPKCS7Padding) -> String? {
        if let keyData = key.data(using: String.Encoding.utf8),
            let data = NSData(base64Encoded: self, options: .ignoreUnknownCharacters),
            let cryptData    = NSMutableData(length: Int((data.length)) + kCCBlockSizeAES128) {

            let keyLength              = size_t(kCCKeySizeAES128)
            let operation: CCOperation = UInt32(kCCDecrypt)
            let algoritm:  CCAlgorithm = UInt32(kCCAlgorithmAES128)
            let options:   CCOptions   = UInt32(options)

            var numBytesEncrypted :size_t = 0

            let cryptStatus = CCCrypt(operation,
                                      algoritm,
                                      options,
                                      (keyData as NSData).bytes, keyLength,
                                      iv,
                                      data.bytes, data.length,
                                      cryptData.mutableBytes, cryptData.length,
                                      &numBytesEncrypted)

            if UInt32(cryptStatus) == UInt32(kCCSuccess) {
                cryptData.length = Int(numBytesEncrypted)
                let unencryptedMessage = String(data: cryptData as Data, encoding:String.Encoding.utf8)
                return unencryptedMessage
            }
            else {
                return nil
            }
        }
        return nil
    }


}

Von meiner ViewController:

 let encoded = message.aesEncrypt(key: keyString, iv: iv)
 let unencode = encoded?.aesDecrypt(key: keyString, iv: iv)
9
user1094081

Es gibt eine interessante "pure-Swift" Open Source-Bibliothek: 

Beispiel mit AES-Entschlüsselung (aus Projektdatei README.md erhalten):

import CryptoSwift
let setup = (key: keyData, iv: ivData)
let decryptedAES = Cipher.AES(setup).decrypt(encryptedData)
6
Roberto

Ich habe CommonCrypto verwendet, um Hash durch den Code von MihaelIsaev/HMAC.Swift von Einfache Swift-Implementierung von CommonCrypto HMAC zu generieren. Diese Implementierung ist ohne die Verwendung von Bridging-Header bei der Erstellung der Moduldatei erforderlich.

Um nun AESEncrypt und Decrypt verwenden zu können, habe ich die Funktionen in "extension String {" in HAMC.Swift direkt hinzugefügt.

func aesEncrypt(key:String, iv:String, options:Int = kCCOptionPKCS7Padding) -> String? {
    if let keyData = key.dataUsingEncoding(NSUTF8StringEncoding),
        data = self.dataUsingEncoding(NSUTF8StringEncoding),
        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(options)

            var numBytesEncrypted :size_t = 0

            let cryptStatus = CCCrypt(operation,
                algoritm,
                options,
                keyData.bytes, keyLength,
                iv,
                data.bytes, data.length,
                cryptData.mutableBytes, cryptData.length,
                &numBytesEncrypted)

            if UInt32(cryptStatus) == UInt32(kCCSuccess) {
                cryptData.length = Int(numBytesEncrypted)
                let base64cryptString = cryptData.base64EncodedStringWithOptions(.Encoding64CharacterLineLength)
                return base64cryptString
            }
            else {
                return nil
            }
    }
    return nil
}

func aesDecrypt(key:String, iv:String, options:Int = kCCOptionPKCS7Padding) -> String? {
    if let keyData = key.dataUsingEncoding(NSUTF8StringEncoding),
        data = NSData(base64EncodedString: self, options: .IgnoreUnknownCharacters),
        cryptData    = NSMutableData(length: Int((data.length)) + kCCBlockSizeAES128) {

            let keyLength              = size_t(kCCKeySizeAES128)
            let operation: CCOperation = UInt32(kCCDecrypt)
            let algoritm:  CCAlgorithm = UInt32(kCCAlgorithmAES128)
            let options:   CCOptions   = UInt32(options)

            var numBytesEncrypted :size_t = 0

            let cryptStatus = CCCrypt(operation,
                algoritm,
                options,
                keyData.bytes, keyLength,
                iv,
                data.bytes, data.length,
                cryptData.mutableBytes, cryptData.length,
                &numBytesEncrypted)

            if UInt32(cryptStatus) == UInt32(kCCSuccess) {
                cryptData.length = Int(numBytesEncrypted)
                let unencryptedMessage = String(data: cryptData, encoding:NSUTF8StringEncoding)
                return unencryptedMessage
            }
            else {
                return nil
            }
    }
    return nil
}

Die Funktionen wurden aus RNCryptor übernommen. Es war eine einfache Ergänzung in den Hashfunktionen und in einer einzigen Datei "HMAC.Swift", ohne den Bridging-Header zu verwenden. Ich hoffe, dass dies für Entwickler in Swift nützlich sein wird, die Hashing und AES-Verschlüsselung/-Entschlüsselung benötigen.

Beispiel für die Verwendung des AESDecrypt wie unter.

 let iv = "AA-salt-BBCCDD--" // should be of 16 characters.
 //here we are convert nsdata to String
 let encryptedString = String(data: dataFromURL, encoding: NSUTF8StringEncoding)
 //now we are decrypting
 if let decryptedString = encryptedString?.aesDecrypt("12345678901234567890123456789012", iv: iv) // 32 char pass key
 {                    
      // Your decryptedString
 }
4
SHS

CryptoSwift ist ein sehr interessantes Projekt, aber im Moment gibt es einige Einschränkungen der AES-Geschwindigkeit. Seien Sie vorsichtig, wenn Sie ernsthafte Kryptooperationen durchführen müssen. Es lohnt sich möglicherweise, den Schmerz der Bridge-Implementierung von CommonCrypto zu durchlaufen.

BigUps an Marcin für die Implementierung von pureSwift

3
ha100

Swift4:

let key = "ccC2H19lDDbQDfakxcrtNMQdd0FloLGG" // length == 32
let iv = "ggGGHUiDD0Qjhuvv" // length == 16
func encryptFile(_ path: URL) -> Bool{
    do{
        let data = try Data.init(contentsOf: path)
        let encodedData = try data.aesEncrypt(key: key, iv: iv)
        try encodedData.write(to: path)
        return true
    }catch{
        return false
    }
}

func decryptFile(_ path: URL) -> Bool{
    do{
        let data = try Data.init(contentsOf: path)
        let decodedData = try data.aesDecrypt(key: key, iv: iv)
        try decodedData.write(to: path)
        return true
    }catch{
        return false
    }
}

** Pod installieren Crypto Swift ** 1. pod 'CryptoSwift' #add zu PodFile 2. pod installieren

import CryptoSwift

extension Data {
    func aesEncrypt(key: String, iv: String) throws -> Data{
        let encypted = try AES(key: key.bytes, blockMode: CBC(iv: iv.bytes), padding: .pkcs7).encrypt(self.bytes)
        return Data(bytes: encypted)
    }

    func aesDecrypt(key: String, iv: String) throws -> Data {
        let decrypted = try AES(key: key.bytes, blockMode: CBC(iv: iv.bytes), padding: .pkcs7).decrypt(self.bytes)
        return Data(bytes: decrypted)
    }
}
0
August Lin

Dies ist ein ziemlich alter Beitrag, aber XCode 1 hat das CommonCrypto-Modul hinzugefügt, sodass Sie keine Modulzuordnung benötigen. Auch bei Swift 5 entfallen die nervigen Würfe.

Sie könnten etwas tun wie:

func decrypt(_ data: Data, iv: Data, key: Data) throws -> String {

    var buffer = [UInt8](repeating: 0, count: data.count + kCCBlockSizeAES128)
    var bufferLen: Int = 0

    let status = CCCrypt(
        CCOperation(kCCDecrypt),
        CCAlgorithm(kCCAlgorithmAES128),
        CCOptions(kCCOptionPKCS7Padding),
        [UInt8](key),
        kCCBlockSizeAES128,
        [UInt8](iv),
        [UInt8](data),
        data.count,
        &buffer,
        buffer.count,
        &bufferLen
    )

    guard status == kCCSuccess,
        let str = String(data: Data(bytes: buffer, count: bufferLen),
                         encoding: .utf8) else {
                            throw NSError(domain: "AES", code: -1, userInfo: nil)
    }

    return str
}
0
gdollardollar

Sie können CommonCrypto von iOS oder CryptoSwift als externe Bibliothek verwenden. Nachfolgend finden Sie Implementierungen mit beiden Tools. Die CommonCrypto-Ausgabe mit AES sollte jedoch getestet werden, da in der CC-Dokumentation nicht klar ist, welchen AES-Modus sie verwendet.

CommonCrypto in Swift 4.2

 importieren Sie CommonCrypto 

 func encrypt (Daten: Daten) -> Daten {
 return cryptCC (Daten: Daten, Schlüssel: Schlüssel, Operation: kCCEncrypt) 
 } 

 Funkentschlüsselung (Daten: Daten) -> Daten {
 return cryptCC (Daten: Daten, Schlüssel: Schlüssel, Operation: kCCDecrypt) 
 } 

 private func cryptCC (Daten: Daten, Schlüssel: Zeichenfolgeoperation: Int) -> Daten {

 guard key.count == kCCKeySizeAES128 else {
 fatalError ("Schlüsselgröße fehlgeschlagen!") 
 } 

 var ivBytes: [UInt8] 
 var inBytes: [UInt8] 
 var outLength: Int 

 wenn Operation == kCCEncrypt {
 ivBytes = [UInt8] (Wiederholung: 0, Anzahl: kCCBlockSizeAES128) 
 guard kCCSuccess == SecRandomCopyBytes (kSecRandomDefault, ivBytes.count & ivBytes) else {
 fatalError ("IV-Erstellung fehlgeschlagen!") 
 } 

 inBytes = Array (Daten) 
 outLength = data.count + kCCBlockSizeAES128 

 } else {
 ivBytes = Array (Array (Daten) .dropLast (data.count - kCCBlockSizeAES128)) 
 inBytes = Array (Array (Daten) .dropFirst (kCCBlockSizeAES128)) 
 outLength = inBytes.count 

 } 

 var outBytes = [UInt8] (Wiederholung: 0, Anzahl: OutLength) 
 var bytesMutated = 0 

 guard kCCSuccess == CCCrypt (CCOperation (Operation), CCAlgorithm (kCCAlgorithmAES128), CCOptions (kCCOptionPKCS7Padding), Array (Schlüssel), kCCKeySizeAES128, & ivBytes, & inBytes, Yachthafen, Yachthafen, Yachthafen, Yachthafen fatalError ("Kryptografieoperation\(Operation) ist fehlgeschlagen") 
 } 

 var outData = Daten (Bytes: & OutBytes, Anzahl: BytesMutated) 

 wenn Operation == kCCEncrypt {
 ivBytes.append (contentsOf: Array (outData)) 
 outData = Daten (Bytes: ivBytes) 
 } 
 return outData 

 } 


CryptoSwift v0.14 in Swift 4.2

 enum Operation {
 Fall verschlüsseln 
 Fall entschlüsseln 
 } 

 privat let keySizeAES128 = 16 
 private let aesBlockSize = 16 

 func encrypt (Daten: Daten, Schlüssel: String) -> Daten {
 return crypt (Daten: Daten, Schlüssel: Schlüssel, Operation: .encrypt) 
 } 

 Funkentschlüsselung (Daten: Daten, Schlüssel: String) -> Daten {
 return crypt (Daten: Daten, Schlüssel: Schlüssel, Operation: .decrypt) 
 } 

 private func crypt (Daten: Daten, Schlüssel: String, Operation: Vorgang) -> Daten {

 guard key.count == keySizeAES128 else {
 fatalError ("Schlüsselgröße fehlgeschlagen!") 
 } 
 var outData: Daten? = null 

 wenn Operation ==. verschlüsselt {
 var ivBytes = [UInt8] (Wiederholung: 0, Anzahl: aesBlockSize) 
 guard 0 == SecRandomCopyBytes (kSecRandomDefault, ivBytes.count & ivBytes) else {
 fatalError ("IV-Erstellung fehlgeschlagen!") 
 } 

 tun {
 let aes = try AES (key: Array (key.data (using: .utf8)!), blockMode: CBC (iv: ivBytes)) 
 let encrypted = versuche aes.encrypt (Array (Daten)) 
 ivBytes.append (contentsOf: verschlüsselt) 
 outData = Daten (Bytes: ivBytes) 

 } Fang {
 print ("Verschlüsselungsfehler:\(Fehler)") 
 } 

 } else {
 let ivBytes = Array (Array (Daten) .dropLast (data.count - aesBlockSize)) 
 let inBytes = Array (Array (Daten) .dropFirst (aesBlockSize)) 

 tun {
 let aes = try AES (key: Array (key.data (using: .utf8)!), blockMode: CBC (iv: ivBytes)) 
 Lassen Sie entschlüsselt = versuchen Sie aes.decrypt (inBytes) 
 outData = Daten (Byte: entschlüsselt) 

 } Fang {
 print ("Entschlüsselungsfehler:\(Fehler)") 
 } 
 } 
 Rückgabe outData! 

 } 

0
cenkarioz

Versuchen Sie es mit dem folgenden Code, es funktioniert für mich.

AES-Verschlüsselung

public static String getEncryptedString(String value) {
        try {
          byte[] key = your Key in byte array;
          byte[] input = sault in byte array

            return Base64.encodeToString(encrypt(value.getBytes("UTF-8"), key, input), Base64.DEFAULT);
        } catch (UnsupportedEncodingException e) {
            return "";
        }
    }


 public static byte[] encrypt(byte[] data, byte[] key, byte[] ivs) {
        try {
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            SecretKeySpec secretKeySpec = new SecretKeySpec(key, "AES");
            byte[] finalIvs = new byte[16];
            int len = ivs.length > 16 ? 16 : ivs.length;
            System.arraycopy(ivs, 0, finalIvs, 0, len);
            IvParameterSpec ivps = new IvParameterSpec(finalIvs);
            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, ivps);
            return cipher.doFinal(data);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

AES DECRYPTION

 public static String decrypt(String encrypted) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {

            byte[] key = your Key in byte array;
            byte[] input = sault in byte array


            SecretKeySpec skeySpec = new SecretKeySpec(key, "AES");
            IvParameterSpec ivSpec = new IvParameterSpec(input);
            Cipher ecipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            ecipher.init(Cipher.DECRYPT_MODE, skeySpec, ivSpec);
            byte[] raw = Base64.decode(encrypted, Base64.DEFAULT);
            byte[] originalBytes = ecipher.doFinal(raw);
            String original = new String(originalBytes, "UTF8");
            return original;
        }
0
Rhn Bhadani

Update Swift 4.2

Hier verschlüsseln wir beispielsweise eine Zeichenfolge in eine Base64-kodierte Zeichenfolge. Und dann entschlüsseln wir dasselbe zu einer lesbaren Zeichenfolge. (Das wäre das gleiche wie unsere Eingabezeichenfolge).

In meinem Fall verwende ich dies, um eine Zeichenfolge zu verschlüsseln und in QR-Code einzubetten. Dann scannt eine andere Partei das und entschlüsselt das gleiche. Daher verstehen Intermediate die QR-Codes nicht. 

Schritt 1: Eine Zeichenfolge verschlüsseln "Meine Nachricht verschlüsseln 123"

Schritt 2: Verschlüsselte base64Encoded-Zeichenfolge: + yvNjiD7F9/JKmqHTc/Mjg == (Dieselbe Angabe auf QR-Code)

Schritt 3: Scanne und entschlüssele die Zeichenfolge "+ yvNjiD7F9/JKmqHTc/Mjg ==" 

Schritt 4: Endgültiges Ergebnis - "Meine Nachricht verschlüsseln" 123

Funktionen zum Verschlüsseln und Entschlüsseln

func encryption(stringToEncrypt: String) -> String{
    let key = "MySecretPKey"
    //let iv = "92c9d2c07a9f2e0a"
    let data = stringToEncrypt.data(using: .utf8)
    let keyD = key.data(using: .utf8)
    let encr = (data as NSData?)!.aes128EncryptedData(withKey: keyD)
    let base64String: String = (encr as NSData?)!.base64EncodedString(options: NSData.Base64EncodingOptions(rawValue: 0))
    print(base64String)
    return base64String
}

func decryption(encryptedString:String) -> String{
    let key = "MySecretPKey"
    //let iv = "92c9d2c07a9f2e0a"
    let keyD = key.data(using: .utf8)
    let decrpStr = NSData(base64Encoded: encryptedString, options: NSData.Base64DecodingOptions(rawValue: 0))
    let dec = (decrpStr)!.aes128DecryptedData(withKey: keyD)
    let backToString = String(data: dec!, encoding: String.Encoding.utf8)
    print(backToString!)
    return backToString!
}

Verwendungszweck:

    let enc = encryption(stringToEncrypt: "Encrypt My Message 123")
    let decryptedString = decryption(encryptedString: enc)
    print(decryptedString) 

Klassen zur Unterstützung von AES-Verschlüsselungsfunktionen, diese sind in Objective-C geschrieben. Daher müssen Sie für Swift einen Bridge-Header verwenden, um diese zu unterstützen.

Klassenname: NSData + AES.h

#import <Foundation/Foundation.h>

@interface NSData (AES)

- (NSData *)AES128EncryptedDataWithKey:(NSData *)key;
- (NSData *)AES128DecryptedDataWithKey:(NSData *)key;
- (NSData *)AES128EncryptedDataWithKey:(NSData *)key iv:(NSData *)iv;
- (NSData *)AES128DecryptedDataWithKey:(NSData *)key iv:(NSData *)iv;

@end

Klassenname: NSData + AES.m

#import "NSData+AES.h"
#import <CommonCrypto/CommonCryptor.h>

@implementation NSData (AES)

- (NSData *)AES128EncryptedDataWithKey:(NSData *)key
{
    return [self AES128EncryptedDataWithKey:key iv:nil];
}

- (NSData *)AES128DecryptedDataWithKey:(NSData *)key
{
    return [self AES128DecryptedDataWithKey:key iv:nil];
}

- (NSData *)AES128EncryptedDataWithKey:(NSData *)key iv:(NSData *)iv
{
    return [self AES128Operation:kCCEncrypt key:key iv:iv];
}

- (NSData *)AES128DecryptedDataWithKey:(NSData *)key iv:(NSData *)iv
{
    return [self AES128Operation:kCCDecrypt key:key iv:iv];
}

- (NSData *)AES128Operation:(CCOperation)operation key:(NSData *)key iv:(NSData *)iv
{

    NSUInteger dataLength = [self length];
    size_t bufferSize = dataLength + kCCBlockSizeAES128;
    void *buffer = malloc(bufferSize);

    size_t numBytesEncrypted = 0;
    CCCryptorStatus cryptStatus = CCCrypt(operation,
                                          kCCAlgorithmAES128,
                                          kCCOptionPKCS7Padding | kCCOptionECBMode,
                                          key.bytes,
                                          kCCBlockSizeAES128,
                                          iv.bytes,
                                          [self bytes],
                                          dataLength,
                                          buffer,
                                          bufferSize,
                                          &numBytesEncrypted);
    if (cryptStatus == kCCSuccess) {
        return [NSData dataWithBytesNoCopy:buffer length:numBytesEncrypted];
    }
    free(buffer);
    return nil;
}

@end

Ich hoffe das hilft.

Vielen Dank!!!

0
Harjot Singh

Sie können einfachcopy & pastediese Methoden (Swift 4+) :

    class func encryptMessage(message: String, encryptionKey: String, iv: String) -> String? {
        if let aes = try? AES(key: encryptionKey, iv: iv),
            let encrypted = try? aes.encrypt(Array<UInt8>(message.utf8)) {
            return encrypted.toHexString()
        }
        return nil
    }

    class func decryptMessage(encryptedMessage: String, encryptionKey: String, iv: String) -> String? {
        if let aes = try? AES(key: encryptionKey, iv: iv),
            let decrypted = try? aes.decrypt(Array<UInt8>(hex: encryptedMessage)) {
            return String(data: Data(bytes: decrypted), encoding: .utf8)
        }
        return nil
    }

Beispiel:

let encryptMessage = encryptMessage(message: "Hello World!", encryptionKey: "mykeymykeymykey1", iv: "myivmyivmyivmyiv")    
// Output of encryptMessage is: 649849a5e700d540f72c4429498bf9f4

let decryptedMessage = decryptMessage(encryptedMessage: encryptMessage, encryptionKey: "mykeymykeymykey1", iv: "myivmyivmyivmyiv")
// Output of decryptedMessage is: Hello World!

Vergiss die Verschlüsselung nicht .Key & iv sollte 16 Byte groß sein.


0
Dardan