Checksum und XOR in Swift

Question

Ich habe diese Methoden in Objective-C. Sie sind nur Prüfsumme und einige 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; 
} 

jedoch XOR, ich bin nicht vertraut mit Bitweise Operatoren, vor allem in Swift, mit diesen UnsafeMutablePointer<Void> ... Dinge.

Kann mir jemand helfen, dies zu konvertieren? (Grundsätzlich brauche ich Prüfsumme und XOR-Funktionen)
Noch ein paar Dinge, sollten sie in NSData/NSMutableData Erweiterung eingefügt werden?

Vielen Dank.

Answer 1

Swift 3 Update:

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

Sie können auch eine andere Funktion erstellen: xored(key: Data) -> Data.
Dann können Sie diese Operatoren verketten: xored(key).checksum()

Answer 2

UnsafeBufferPointer/UnsafeMutableBufferPointer könnte was Sie jetzt brauchen. Ich habe versucht, deinen Code unten in Swift zu übersetzen. (Aber der Code ist nicht gut getestet.)

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

für Swift Aktualisiert vor 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 
}