Swift Language
क्रिप्टोग्राफिक हैशिंग

MD2, MD4, MD5, SHA1, SHA224, SHA256, SHA384, SHA512 (स्विफ्ट 3)

इन कार्यों में आठ क्रिप्टोग्राफिक हैश एल्गोरिदम के साथ स्ट्रिंग या डेटा इनपुट हैश होगा।

नाम पैरामीटर हैश फ़ंक्शन का नाम स्ट्रिंग के रूप में निर्दिष्ट करता है
समर्थित कार्य MD2, MD4, MD5, SHA1, SHA224, SHA256, SHA384 और SHA512 हैं

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

यह फ़ंक्शन हैश नाम लेता है और डेटा को हैशड किया जाता है और डेटा लौटाता है:

name: A name of a hash function as a String  
data: The Data to be hashed  
returns: the hashed result as Data  

func hash(name:String, data:Data) -> Data? {
    let algos = ["MD2":    (CC_MD2,    CC_MD2_DIGEST_LENGTH),
                 "MD4":    (CC_MD4,    CC_MD4_DIGEST_LENGTH),
                 "MD5":    (CC_MD5,    CC_MD5_DIGEST_LENGTH),
                 "SHA1":   (CC_SHA1,   CC_SHA1_DIGEST_LENGTH),
                 "SHA224": (CC_SHA224, CC_SHA224_DIGEST_LENGTH),
                 "SHA256": (CC_SHA256, CC_SHA256_DIGEST_LENGTH),
                 "SHA384": (CC_SHA384, CC_SHA384_DIGEST_LENGTH),
                 "SHA512": (CC_SHA512, CC_SHA512_DIGEST_LENGTH)]
    guard let (hashAlgorithm, length) = algos[name]  else { return nil }
    var hashData = Data(count: Int(length))

    _ = hashData.withUnsafeMutableBytes {digestBytes in
        data.withUnsafeBytes {messageBytes in
            hashAlgorithm(messageBytes, CC_LONG(data.count), digestBytes)
        }
    }
    return hashData
}

यह फ़ंक्शन हैश नाम लेता है और स्ट्रिंग हैशेड हो जाता है और डेटा लौटाता है:

name: A name of a hash function as a String  
string: The String to be hashed  
returns: the hashed result as Data  

func hash(name:String, string:String) -> Data? {
    let data = string.data(using:.utf8)!
    return hash(name:name, data:data)
}

उदाहरण:

let clearString = "clearData0123456"
let clearData   = clearString.data(using:.utf8)!
print("clearString: \(clearString)")
print("clearData: \(clearData as NSData)")

let hashSHA256 = hash(name:"SHA256", string:clearString)
print("hashSHA256: \(hashSHA256! as NSData)")

let hashMD5 = hash(name:"MD5", data:clearData)
print("hashMD5: \(hashMD5! as NSData)")

आउटपुट:

clearString: clearData0123456
clearData: <636c6561 72446174 61303132 33343536>

hashSHA256: <aabc766b 6b357564 e41f4f91 2d494bcc bfa16924 b574abbd ba9e3e9d a0c8920a>
hashMD5: <4df665f7 b94aea69 695b0e7b baf9e9d6>

MD5, SHA1, SHA224, SHA256, SHA384, SHA512 (स्विफ्ट 3) के साथ HMAC

इन कार्यों में आठ क्रिप्टोग्राफिक हैश एल्गोरिदम के साथ स्ट्रिंग या डेटा इनपुट हैश होगा।

नाम पैरामीटर हैश फ़ंक्शन का नाम निर्दिष्ट करता है क्योंकि स्ट्रिंग समर्थित कार्य MD5, SHA1, SHA224, SHA256, SHA384 और SHA512 हैं

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

ये फ़ंक्शन हैश नाम लेता है, संदेश हैशेड, एक कुंजी और एक डाइजेस्ट वापस करता है:

hashName: name of a hash function as String  
message:  message as Data  
key:      key as Data  
returns:  digest as Data  

func hmac(hashName:String, message:Data, key:Data) -> Data? {
    let algos = ["SHA1":   (kCCHmacAlgSHA1,   CC_SHA1_DIGEST_LENGTH),
                 "MD5":    (kCCHmacAlgMD5,    CC_MD5_DIGEST_LENGTH),
                 "SHA224": (kCCHmacAlgSHA224, CC_SHA224_DIGEST_LENGTH),
                 "SHA256": (kCCHmacAlgSHA256, CC_SHA256_DIGEST_LENGTH),
                 "SHA384": (kCCHmacAlgSHA384, CC_SHA384_DIGEST_LENGTH),
                 "SHA512": (kCCHmacAlgSHA512, CC_SHA512_DIGEST_LENGTH)]
    guard let (hashAlgorithm, length) = algos[hashName]  else { return nil }
    var macData = Data(count: Int(length))

    macData.withUnsafeMutableBytes {macBytes in
        message.withUnsafeBytes {messageBytes in
            key.withUnsafeBytes {keyBytes in
                CCHmac(CCHmacAlgorithm(hashAlgorithm),
                       keyBytes,     key.count,
                       messageBytes, message.count,
                       macBytes)
            }
        }
    }
    return macData
}

hashName: name of a hash function as String
message:  message as String
key:      key as String
returns:  digest as Data

func hmac(hashName:String, message:String, key:String) -> Data? {
    let messageData = message.data(using:.utf8)!
    let keyData = key.data(using:.utf8)!
    return hmac(hashName:hashName, message:messageData, key:keyData)
}

hashName: name of a hash function as String  
message:  message as String  
key:      key as Data  
returns:  digest as Data  

func hmac(hashName:String, message:String, key:Data) -> Data? {
    let messageData = message.data(using:.utf8)!
    return hmac(hashName:hashName, message:messageData, key:key)
}

// उदाहरण

let clearString = "clearData0123456"
let keyString   = "keyData8901234562"
let clearData   = clearString.data(using:.utf8)!
let keyData     = keyString.data(using:.utf8)!
print("clearString: \(clearString)")
print("keyString:   \(keyString)")
print("clearData: \(clearData as NSData)")
print("keyData:   \(keyData as NSData)")

let hmacData1 = hmac(hashName:"SHA1", message:clearData, key:keyData)
print("hmacData1: \(hmacData1! as NSData)")

let hmacData2 = hmac(hashName:"SHA1", message:clearString, key:keyString)
print("hmacData2: \(hmacData2! as NSData)")

let hmacData3 = hmac(hashName:"SHA1", message:clearString, key:keyData)
print("hmacData3: \(hmacData3! as NSData)")

आउटपुट:

clearString: clearData0123456
keyString:   keyData8901234562
clearData: <636c6561 72446174 61303132 33343536>
keyData:   <6b657944 61746138 39303132 33343536 32>

hmacData1: <bb358f41 79b68c08 8e93191a da7dabbc 138f2ae6>
hmacData2: <bb358f41 79b68c08 8e93191a da7dabbc 138f2ae6>
hmacData3: <bb358f41 79b68c08 8e93191a da7dabbc 138f2ae6>