Swift RC4 与 Objective-C RC4 性能对比

Question

我一直在尝试将 Rc4 算法从 Objective-c 重写为 swift，以测试 apples（现已旧）声称它运行得更快。 但是，在这些时候，我一定是在某个地方做错了什么

这是目标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)

并输入：“MySecretCodeToBeEncryptionSoNobodySeesIt”

这是我尝试使用 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]

我们得到了 O(n) 的运行时间，而不是 Objective-c 中此操作的 O(1) -（恒定时间）。