objective-c - Swift RC4 与 Objective-C RC4 性能对比

Question

我一直在尝试将 Rc4 算法从 objective-c 重写为 swift，以测试苹果(现在已经过时)的说法，关于它运行得更快。 然而，在我得到的这些时间里，一定有什么地方我做错了一些可怕的事情

这是 Objective-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 秒

带 key :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为你的数字。