Java中的多轮Feistel网络

对于一些学生来说，我需要用Java实现一个Feistel网络

我从3个手动回合开始，如下所示：

    // round 1
    int[] left1 = right;
    int[] right1 = new int[right.length];

    for(int i = 0; i < right.length; i++){
        right1[i] = left[i] ^ (right[i] ^ keys[0]);
    }

    // round 2
    int[] left2 = right1;
    int[] right2 = new int[right.length];

    for(int i = 0; i < right.length; i++){
        right2[i] = left1[i] ^ (right1[i] ^ keys[1]);
    }

    // round 3
    int[] left3 = right2;
    int[] right3 = new int[right.length];

    for(int i = 0; i < right.length; i++){
        right3[i] = left2[i] ^ ( right2[i] ^ keys[2]);
    }

//第一轮
int[]left1=右；
int[]right1=新int[right.length]；
for（int i=0；i

---

如果我想进行10轮，我需要将这些东西复制10次并调整变量，有更好的方法吗？也许已经太晚了，但我想不出一个解决方案…

你可以简单地向前和向后交换：

//initialization
int[] left = {};//setup left
int[] right = {};//setup right
//keys
int[] keys = {};//setup keys

for(int r = 0; r < 10; r++) {//the number of rounds
    for(int i = 0; i < right.length; i++){
        right[i] = left[i] ^ (right[i] ^ keys[r]);
    }

    //swap lists to do the next round
    int[] temp = left;
    left = right;
    right = temp;
}
//remark: the result (right) will be stored in left
//use left as resulting right

请注意，这里不复制值，只需交换引用，这是在固定时间内完成的。如果您想对长消息进行加密/解密，并且不想再次浪费时间进行复制，这将非常有用

发生的情况是，最初有三个列表L，R和K

现在在第一轮中，您只需修改提升列表，如代码中所示：

for(int i = 0; i < right.length; i++){
    right[i] = left[i] ^ (right[i] ^ keys[r]);
}

for（int i=0；i

重要的是，您不需要编写

keys[i]

，而是使用

keys[r]

（索引是当前一轮）：这意味着您至少有

10个
键来执行算术

请注意，您可以覆盖
right[i]
，因为以后不会重用该值。因此，您可以进行内联修改

修改后，交换缓冲区。您需要考虑的唯一方面是，对于最后一轮，在执行操作之后，缓冲区也将被交换。因此，最后一个
左
和
右
也将交换。您可以（1）在for循环之后进行额外的交换；或者（2）将掉期考虑在内，假装
左
是
右
，反之亦然；或者（3）使用
if
-子句防止最后一次交换。
使用二维数组

int rounds = 10 // number of rounds
int leftArray = new int[rounds][right.length];
int rightArray = new int[rounds][right.length];

然后：


leftArray[0][0]
相当于
left1[0]

leftArray[0][1]
相当于
left1[1]

rightArray[0][0]
相当于
right1[0]

rightArray[2][2]
相当于
right3[2]



然后使用嵌套循环来迭代需要执行的操作

for(int i=0; i<rouds; i++){
  //set your variables
  for(int j=0; j<right.length; j++){
  //do computation here
  }
}

for（int i=0；我必须像您已经使用的那样将其中一个封装在for循环中。如果我对left1总是被原来的right覆盖有问题，我需要上一轮中的left1和right数组。谢谢您为我清理了一切，尤其是交换部分。
for(int i=0; i<rouds; i++){
  //set your variables
  for(int j=0; j<right.length; j++){
  //do computation here
  }
}