Swift Language
एईएस एन्क्रिप्शन

यादृच्छिक IV के साथ CBC मोड में AES एन्क्रिप्शन (स्विफ्ट 3.0)

Iv एन्क्रिप्टेड डेटा के लिए उपसर्ग है

aesCBC128Encrypt एक यादृच्छिक IV बना देगा और एन्क्रिप्टेड कोड के लिए उपसर्ग करेगा।
aesCBC128Decrypt डिक्रिप्शन के दौरान उपसर्ग IV का उपयोग करेगा।

इनपुट डेटा हैं और कुंजी डेटा ऑब्जेक्ट हैं। यदि कॉल करने की विधि में / से या में कनवर्ट करना आवश्यक हो तो बेस 64 जैसे एन्कोडेड फॉर्म।

कुंजी लंबाई में 128-बिट्स (16-बाइट्स), 192-बिट्स (24-बाइट्स) या 256-बिट्स (32-बाइट्स) होनी चाहिए। यदि किसी अन्य कुंजी आकार का उपयोग किया जाता है तो एक त्रुटि डाली जाएगी।

PKCS # 7 पैडिंग डिफ़ॉल्ट रूप से सेट की गई है।

इस उदाहरण के लिए सामान्य क्रिप्टो की आवश्यकता है
प्रोजेक्ट के लिए एक ब्रिजिंग हेडर होना आवश्यक है:
#import <CommonCrypto/CommonCrypto.h>
प्रोजेक्ट में Security.framework जोड़ें।

यह उदाहरण है, उत्पादन कोड नहीं।

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;
}

उदाहरण उपयोग:

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)")
}

उदाहरण आउटपुट:

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>

टिप्पणियाँ:
सीबीसी मोड उदाहरण कोड के साथ एक विशिष्ट समस्या यह है कि यह उपयोगकर्ता को यादृच्छिक IV का निर्माण और साझा करना छोड़ देता है। इस उदाहरण में IV की पीढ़ी शामिल है, जो एन्क्रिप्ट किए गए डेटा को उपसर्ग करता है और डिक्रिप्शन के दौरान उपसर्ग IV का उपयोग करता है। यह आकस्मिक उपयोगकर्ता को उन विवरणों से मुक्त करता है जो सीबीसी मोड के लिए आवश्यक हैं।

सुरक्षा के लिए एन्क्रिप्टेड डेटा में भी प्रमाणीकरण होना चाहिए, यह उदाहरण कोड प्रदान नहीं करता है ताकि छोटा हो और अन्य प्लेटफार्मों के लिए बेहतर इंटरऑपरेबिलिटी की अनुमति दे सके।

पासवर्ड से कुंजी की अनुपस्थिति भी गायब है, यह सुझाव दिया जाता है कि PBKDF2 का उपयोग किया जाए। टेक्स्ट पासवर्ड कुंजी सामग्री के रूप में उपयोग किए जाते हैं।

मजबूत उत्पादन के लिए तैयार मल्टी-प्लेटफ़ॉर्म एन्क्रिप्शन कोड RNCryptor देखें।

दिए गए कुंजी के आधार पर थ्रो / कैच और कई प्रमुख आकारों का उपयोग करने के लिए अपडेट किया गया।

यादृच्छिक IV के साथ CBC मोड में AES एन्क्रिप्शन (स्विफ्ट 2.3)

Iv एन्क्रिप्टेड डेटा के लिए उपसर्ग है

aesCBC128Encrypt एक यादृच्छिक IV बना देगा और एन्क्रिप्टेड कोड के लिए उपसर्ग करेगा। aesCBC128Decrypt डिक्रिप्शन के दौरान उपसर्ग IV का उपयोग करेगा।

इनपुट डेटा हैं और कुंजी डेटा ऑब्जेक्ट हैं। यदि कॉल करने की विधि में / से या में कनवर्ट करना आवश्यक हो तो बेस 64 जैसे एन्कोडेड फॉर्म।

कुंजी बिल्कुल 128-बिट (16-बाइट्स) होनी चाहिए। अन्य प्रमुख आकारों के लिए स्विफ्ट 3.0 का उदाहरण देखें।

PKCS # 7 पैडिंग डिफ़ॉल्ट रूप से सेट की गई है।

इस उदाहरण के लिए कॉमन क्रिप्टो की आवश्यकता है। प्रोजेक्ट के लिए एक ब्रिजिंग हेडर होना आवश्यक है: #import <CommonCrypto / CommonCrypto.h> इस प्रोजेक्ट में Security.framework जोड़ें।

नोट्स के लिए स्विफ्ट 3 उदाहरण देखें।

यह उदाहरण है, उत्पादन कोड नहीं।

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;
}

उदाहरण उपयोग:

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))")

उदाहरण आउटपुट:

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>

पीकेसीएस 7 पेडिंग के साथ ईसीबी मोड में एईएस एन्क्रिप्शन

IV के लिए Apple प्रलेखन से,

यदि ईसीबी मोड का उपयोग किया जाता है या यदि स्ट्रीम सिफर एल्गोरिथम चुना जाता है तो इस पैरामीटर को अनदेखा किया जाता है।

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
    }