我用 Objective-C 编写了这些方法。它们只是校验和和异或一些
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;
}
但是,我不熟悉按位运算符,尤其是在 Swift 中,这些
UnsafeMutablePointer<Void>
... 东西。
有人可以帮我转换这个吗? (基本上,我需要校验和和异或函数)
还有一件事,应该把它们放在
NSData/NSMutableData
扩展中吗?
谢谢你。
UnsafeBufferPointer
/UnsafeMutableBufferPointer
可能就是您现在所需要的。我已经尝试将您的代码翻译成下面的 Swift 。 (但是代码没有经过很好的测试。)
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
}
Swift 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()
Swift 支持运算符重载,因此您可以轻松做到
let xorData = data1 ^ data2
。我已经为非相似大小的数据编写了异或扩展。
extension Data {
static func ^ (left: Data, right: Data) -> Data {
if left.count != right.count {
NSLog("Warning! XOR operands are not equal. left = \(left), right = \(right)")
}
var result: Data = Data()
var smaller: Data, bigger: Data
if left.count <= right.count {
smaller = left
bigger = right
} else {
smaller = right
bigger = left
}
let bs:[UInt8] = Array(smaller)
let bb:[UInt8] = Array (bigger)
var br = [UInt8] ()
for i in 0..<bs.count {
br.append(bs[i] ^ bb[i])
}
for j in bs.count..<bb.count {
br.append(bb[j])
}
result = Data(br)
return result
}
}
更新为 Swift 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
}
Swift 可以轻松地将
Data
对象视为字节数组,您可以使用 zip
和 map
的组合来操作它,从而避免需要 for
循环。这会产生更简洁且更具可读性的代码:
extension Data {
static func ^ (lhs: Data, rhs: Data) -> Data {
Data(zip(Array(lhs), Array(rhs)).map { $0 ^ $1 })
}
}