Question

我一直在尝试将一个Rc4算法从objective-c重写为swift，以测试苹果（现在是旧的）声明，关于它运行得更快。但是，在某些地方，我正在做一些可怕的错误，这些时候我会得到

这是目标c代码：

+(NSString*)Rc4:(NSString*)aInput key:(NSString *)aKey {
    NSMutableArray *iS = [[NSMutableArray alloc] initWithCapacity:256];
    NSMutableArray *iK = [[NSMutableArray alloc] initWithCapacity:256];

    for (int i = 0; i <256;i++){
        [iS addObject:[NSNumber numberWithInt:i]];
    }

    for(short i=0;i<256;i++){
        UniChar c = [aKey characterAtIndex:i%aKey.length];
        [iK addObject:[NSNumber numberWithChar:c]];
    }
    int j=2;
    for (int i=0; i<255;i++){
        int is = [[iS objectAtIndex:i]  intValue];
        UniChar ik = (UniChar)[[iK objectAtIndex:i]charValue];

        j= (j+is+ik)%256;
        NSNumber *temp = [iS objectAtIndex:i];
        [iS replaceObjectAtIndex:i withObject:[iS objectAtIndex:j]];
        [iS replaceObjectAtIndex:j withObject:temp];
    }

    int i =0;
    j=0;
    NSString *result = aInput;

    for (short x=0;x<[aInput length]; x++){
        i = (i+1)%256;

        int is = [[iS objectAtIndex:i]intValue];
        j=(j+is)%256;

        int is_i = [[iS objectAtIndex:i]intValue];
        int is_j = [[iS objectAtIndex:j]intValue];

        int t= (is_i+is_j)%256;
        int iY = [[iS objectAtIndex:t]intValue];

        UniChar ch = (UniChar)[aInput characterAtIndex:x];
        UniChar ch_y=ch^iY;
        //NSLog(ch);
        //NSLog(iY);

        result = [result stringByReplacingCharactersInRange:NSMakeRange(x,1) withString:
                  [NSString stringWithCharacters:&ch_y length:1] ];
    }
    [iS release];
    [iK release];
    return result;
}

使用-O3进行非常快速的编译我得到的时间是：

100次运行：0.006秒

带密钥：6f7e2a3d744a3b5859725f412f（128bit）

并输入：＆＃34; MySecretCodeToBeEncryptionSoNobodySeesIt＆＃34;

这是我尝试使用Swift以相同的方式实现它：

extension String {
   subscript (i: Int) -> String {
      return String(Array(self)[i])
   }
}
extension Character {
  func unicodeValue() -> UInt32 {
    for s in String(self).unicodeScalars {
      return s.value
    }
    return 0

    }
  }
func Rc4(input:String, key:String)-> String{
  var iS = Array(count:256, repeatedValue: 0)
  var iK = Array(count:256, repeatedValue: "")
  var keyLength = countElements(key)

  for var i = 0; i < 256; i++ {
    iS[i] = i;
  }

  for var i = 0; i < 256 ; i++ {
    var c = key[i%keyLength]
    iK[i] = c;  
  }

  var j = 2

  for var i = 0; i < 255; i++ {
    var iss = iS[i]
    var ik = iK[i]
    // transform string to int
    var ik_x:Character = Character(ik)
    var ikk_xx = Int(ik_x.unicodeValue())

    j = (j+iss+ikk_xx)%256;
    var temp = iS[i]
    iS[i] = iS[j]
    iS[j] = temp
  }

  var i = 0
  j=0
  var result = input
  var eles = countElements(input)
  for var x = 0 ; x<eles ; x++ {
    i = (i+1)%256

    var iss = iS[i]
    j = (j+iss)%256

    var is_i = iS[i]
    var is_j = iS[j]
    var t = (is_i+is_j)%256
    var iY = iS[t]

    var ch = (input[x])
    var ch_x:Character = Character(ch)
    var ch_xx = Int(ch_x.unicodeValue())
    var ch_y = ch_xx^iY
    var start = advance(result.startIndex, x)
    var end = advance(start,1);
    let range = Range(start:start, end:end)
    var maybestring = String(UnicodeScalar(ch_y))
    result = result.stringByReplacingCharactersInRange(range, withString:maybestring)
  }
  return result;
}

我试图实现它，因此它看起来尽可能与objective-c版本一样多。然而，这给了我这些可怕的时间，使用-O

100次运行：0.5秒

修改代码现在应该使用我发布的扩展方法在xcode 6.1中运行。

我从终端这样运行它：

xcrun swiftc -O Swift.swift -o swift

其中Swift.swift是我的文件，swift是我的可执行文件

Answer 1

通常声称速度并不真正适用于加密算法，它们更多地用于我通常所说的“业务逻辑”。位，字节，16/32/64位字等的功能通常难以优化。基本上，加密算法被设计为对这些数据结构进行密集操作，只有相对较少的选择可以被优化掉。

以Java为例。虽然比大多数解释语言无限快，但它与C / C ++的比较并不好，更不用说装配优化的加密算法了。对于大多数相对较小的代数问题也是如此。

为了加快速度，您至少应该使用explicit numeric types作为数字。

Answer 2

在对代码进行过度测试之后，我已经将其缩小到使我的时间超慢的原因。如果我注释掉这段代码，那么iK数组只包含它的初始值。我从5秒到1秒的运行时间。这是一个显着的增长。

for var i = 0; i < 256 ; i++ {
var c = key[i%keyLength]
iK[i] = c;  
}

问题出在这一部分：

var c = key[i%keyLength]

Swift中没有“characterAtIndex（int）”方法，因此我将其作为获取characterAtIndex的变通方法。我使用我的扩展程序来做到这一点：

extension String {
  subscript (i: Int) -> String {
    return String(Array(self)[i])
  }
}

但基本上它与此相同：

var c = Array(key)[i%keyLength]

而不是在objective-c中该操作的O（1） - （常数时间），我们得到O（n）的运行时间。

Swift RC4与Objective-C RC4性能

2 个答案: