स्विफ्ट

Question

में चेकसम और एक्सओआर उद्देश्य-सी में इन तरीकों को worte। वे सिर्फ चेकसम हैं और कुछ NSData

- (void)XOR:(NSMutableData *)inputData withKey:(NSData *)key 
{ 
    unsigned char* inputByteData = (unsigned char*)[inputData mutableBytes]; 
    unsigned char* keyByteData = (unsigned char*)[key bytes]; 
    for (int i = 0; i < [inputData length]; i++) 
    { 
     inputByteData[i] = inputByteData[i]^keyByteData[i % [key length]]; 
    } 
} 

- (Byte)checkSum:(NSMutableData *)data withLength:(Byte)dataLength 
{ 
    Byte * dataByte = (Byte *)malloc(dataLength); 
    memcpy(dataByte, [data bytes], dataLength); 

    Byte result = 0; 
    int count = 0; 
    while (dataLength>0) { 
     result += dataByte[count]; 
     dataLength--; 
     count++; 
    }; 
    result = result&0xff; 
    return result&0xff; 
} 

हालांकि, मैं बिटवाइज़ ऑपरेटर्स से परिचित नहीं हूँ, विशेष रूप से स्विफ्ट में, इन UnsafeMutablePointer<Void> साथ ... बातें XOR।

क्या कोई मुझे इसे परिवर्तित करने में मदद कर सकता है? (असल में, मुझे चेकसम और एक्सओआर फ़ंक्शंस की आवश्यकता है)
एक और चीजें, उन्हें NSData/NSMutableData एक्सटेंशन में रखा जाना चाहिए?

धन्यवाद।

Answer 1

स्विफ्ट 3 अद्यतन:

public extension Data { 

    public mutating func xor(key: Data) { 
     for i in 0..<self.count { 
      self[i] ^= key[i % key.count] 
     } 
    } 


    public func checkSum() -> Int { 
     return self.map { Int($0) }.reduce(0, +) & 0xff 
    } 
} 

तुम भी एक और समारोह बना सकते हैं: xored(key: Data) -> Data।
फिर आप इन ऑपरेटरों को चेन कर सकते हैं: xored(key).checksum()

Answer 2

UnsafeBufferPointer/UnsafeMutableBufferPointer जो आपको अभी चाहिए वह हो सकता है। मैंने नीचे दिए गए स्विफ्ट में अपना कोड अनुवाद करने का प्रयास किया है। (लेकिन कोड अच्छी तरह से परीक्षण किया जाता है नहीं।)

func XOR(inputData: NSMutableData, withKey key: NSData) { 
    let b = UnsafeMutableBufferPointer<UInt8>(start: 
     UnsafeMutablePointer(inputData.mutableBytes), count: inputData.length) 

    let k = UnsafeBufferPointer<UInt8>(start: 
     UnsafePointer(key.bytes), count: key.length) 

    for i in 0..<inputData.length { 
     b[i] ^= k[i % key.length] 
    } 
} 

func checkSum(data: NSData) -> Int { 
    let b = UnsafeBufferPointer<UInt8>(start: 
     UnsafePointer(data.bytes), count: data.length) 

    var sum = 0 
    for i in 0..<data.length { 
     sum += Int(b[i]) 
    } 
    return sum & 0xff 
} 

Answer 3

स्विफ्ट 3 के लिए अपडेट किया गया:

func xor(data: Data, with key: Data) -> Data { 
    var xorData = data 

    xorData.withUnsafeMutableBytes { (start: UnsafeMutablePointer<UInt8>) -> Void in 
     key.withUnsafeBytes { (keyStart: UnsafePointer<UInt8>) -> Void in 
      let b = UnsafeMutableBufferPointer<UInt8>(start: start, count: xorData.count) 

      let k = UnsafeBufferPointer<UInt8>(start: keyStart, count: data.count) 
      let length = data.count 

      for i in 0..<xorData.count { 
       b[i] ^= k[i % length] 
      } 
     } 
    } 

    return xorData 
}