swift - स्विफ्ट में एसएचए 1 के साथ हैश एनएसएसटींग कैसे करें?




sha1 (4)

आपका उद्देश्य-सी कोड ( NSString श्रेणी का उपयोग करके) सीधे स्विफ्ट में अनुवाद किया जा सकता है (एक String एक्सटेंशन का उपयोग करके)।

सबसे पहले आपको "ब्रिजिंग हेडर" बनाना होगा और जोड़ना होगा

#import <CommonCrypto/CommonCrypto.h>

फिर:

extension String {
    func sha1() -> String {
        let data = self.dataUsingEncoding(NSUTF8StringEncoding)!
        var digest = [UInt8](count:Int(CC_SHA1_DIGEST_LENGTH), repeatedValue: 0)
        CC_SHA1(data.bytes, CC_LONG(data.length), &digest)
        let output = NSMutableString(capacity: Int(CC_SHA1_DIGEST_LENGTH))
        for byte in digest {
            output.appendFormat("%02x", byte)
        }
        return output as String
    }
}

println("Hello World".sha1())

इसे थोड़ा छोटा और स्विफ्ट के रूप में लिखा जा सकता है

extension String {
    func sha1() -> String {
        let data = self.dataUsingEncoding(NSUTF8StringEncoding)!
        var digest = [UInt8](count:Int(CC_SHA1_DIGEST_LENGTH), repeatedValue: 0)
        CC_SHA1(data.bytes, CC_LONG(data.length), &digest)
        let hexBytes = map(digest) { String(format: "%02hhx", $0) }
        return "".join(hexBytes)
    }
}

स्विफ्ट 2 के लिए अद्यतन करें:

extension String {
    func sha1() -> String {
        let data = self.dataUsingEncoding(NSUTF8StringEncoding)!
        var digest = [UInt8](count:Int(CC_SHA1_DIGEST_LENGTH), repeatedValue: 0)
        CC_SHA1(data.bytes, CC_LONG(data.length), &digest)
        let hexBytes = digest.map { String(format: "%02hhx", $0) }
        return hexBytes.joinWithSeparator("")
    }
}

एक हेक्स एन्कोडेड स्ट्रिंग के बजाय बेस -64 एन्कोडेड स्ट्रिंग को वापस करने के लिए, बस प्रतिस्थापित करें

        let hexBytes = digest.map { String(format: "%02hhx", $0) }
        return hexBytes.joinWithSeparator("")

साथ में

        return NSData(bytes: digest, length: digest.count).base64EncodedStringWithOptions([])

स्विफ्ट 3 के लिए अद्यतन करें:

extension String {
    func sha1() -> String {
        let data = self.data(using: String.Encoding.utf8)!
        var digest = [UInt8](repeating: 0, count:Int(CC_SHA1_DIGEST_LENGTH))
        data.withUnsafeBytes { 
            _ = CC_SHA1($0, CC_LONG(data.count), &digest)
        }
        let hexBytes = digest.map { String(format: "%02hhx", $0) }
        return hexBytes.joined()
    }
}

एक हेक्स एन्कोडेड स्ट्रिंग के बजाय बेस -64 एन्कोडेड स्ट्रिंग को वापस करने के लिए, बस प्रतिस्थापित करें

        let hexBytes = digest.map { String(format: "%02hhx", $0) }
        return hexBytes.joined()

द्वारा

        return Data(bytes: digest).base64EncodedString()

उद्देश्य-सी में ऐसा लगता है:

#include <sys/xattr.h>

@implementation NSString (reverse)

-(NSString*)sha1
{
    NSData *data = [self dataUsingEncoding:NSUTF8StringEncoding];
    uint8_t digest[CC_SHA1_DIGEST_LENGTH];
    CC_SHA1(data.bytes, (int)data.length, digest);
    NSMutableString *output = [NSMutableString stringWithCapacity:CC_SHA1_DIGEST_LENGTH * 2];
    for (int i = 0; i < CC_SHA1_DIGEST_LENGTH; i++)
        [output appendFormat:@"%02x", digest[i]];
    return output;
}

@end

मुझे स्विफ्ट के साथ ऐसा कुछ चाहिए, क्या यह संभव है?

कृपया, उदाहरण उदाहरण दिखाएं।


हम sha1 का उपयोग करके तीन चरणों के लिए स्ट्रिंग एन्क्रिप्ट करने के लिए तर्क निकाल सकते हैं:

  1. स्ट्रिंग को डेटा ऑब्जेक्ट में कनवर्ट करें
  2. डेटा में SHA1 फ़ंक्शन का उपयोग करके डेटा एन्क्रिप्ट करें
  3. डेटा ऑब्जेक्ट को हेक्स स्ट्रिंग में कनवर्ट करें

आईएमएचओ यह बहुत अधिक पठनीय है और इस संस्करण को एनएसडीटा की आवश्यकता नहीं है।

    extension String {

        var sha1: String {
            guard let data = data(using: .utf8, allowLossyConversion: false) else {
                // Here you can just return empty string or execute fatalError with some description that this specific string can not be converted to data
            }
            return data.digestSHA1.hexString
        }

    }

    fileprivate extension Data {

        var digestSHA1: Data {
            var bytes: [UInt8] = Array(repeating: 0, count: Int(CC_SHA1_DIGEST_LENGTH))

            withUnsafeBytes {
                _ = CC_SHA1($0, CC_LONG(count), &bytes)
            }

            return Data(bytes: bytes)
        }

        var hexString: String {
            return map { String(format: "%02x", UInt8($0)) }.joined()
        }

    }

हां, यह संभव है: उस उद्देश्य-सी कोड को तेज़ी से सुलभ बनाएं

documentation देखें।

यदि आपको कोई लाभ नहीं मिलेगा (जैसे स्विफ्ट-विशिष्ट विशेषताओं का उपयोग करना) तो मैं इसे तेजी से फिर से लिखने से बचूंगा।

साथ ही, एक परियोजना में मैं काम कर रहा हूं मैंने कुछ उद्देश्य-सी कोड का उपयोग किया है जो हैश को संभालने के लिए आपके जैसा है। शुरुआत में मैंने इसे तेजी से लिखना शुरू कर दिया, फिर मुझे एहसास हुआ कि पुराने अच्छे ओब्जे-सी का पुन: उपयोग करना आसान और बेहतर था।


<CommonCrypto/CommonCrypto.h> रूप में परिणाम प्राप्त करने के लिए, बशर्ते आपने अपने ब्रिजिंग हेडर में <CommonCrypto/CommonCrypto.h> किया हो:

extension NSData {

    func sha1() -> NSData? {
        let len = Int(CC_SHA1_DIGEST_LENGTH)
        let digest = UnsafeMutablePointer<UInt8>.alloc(len)
        CC_SHA1(bytes, CC_LONG(length), digest)
        return NSData(bytesNoCopy: UnsafeMutablePointer<Void>(digest), length: len)
    }
}

उचित सूचक आवंटन का भी उपयोग करता है। इसे इस तरह से आमंत्रित करें:

myString.dataUsingEncoding(NSUTF8StringEncoding)?.sha1()

यदि आपको NSData हेक्स प्रस्तुति की आवश्यकता है तो मेरे दूसरे answer पर एक नज़र डालें।





sha1