Rete di Mutliround Feistel in Java

Question

Per alcune cose da studente ho bisogno di implementare una rete Feistel in Java.

ho iniziato con 3 turni manuali, come questo:

// 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]); 
    } 

Se voglio avere 10 giri avrei bisogno di copiare questa roba 10 volte e regolare le variabili, c'è un modo migliore per fare questo ? Forse è troppo tardi, ma non riesco a pensare a una soluzione di ...

Answer 1

Si può semplicemente scambiare avanti un all'indietro:

//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 

Dopo ogni giro, si scambia a destra ea sinistra, così facendo, a livello di riferimento (e utilizzare temp) per memorizzare di riferimento temporaneo:

int[] temp = left; 
left = right; 
right = temp; 

Nota che non copia i valori qui, è sufficiente scambiare i riferimenti, questo è quindi fatto in tempo costante. Questo può essere utile se si desidera crittografare/decodificare i messaggi lunghi e non si vuole perdere tempo a copiare di nuovo.

Quindi, ciò che accade è, inizialmente si dispone di tre liste L, R e K

Ora, nel primo turno, è sufficiente modificare la lista ascensore, elemento-saggio, come avete dimostrato nel codice:

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

importante è che non si scrive keys[i], ma utilizzare keys[r] (l'indice essendo turno corrente): esso implica di avere almeno 10 chiavi per fare l'aritmetica, naturalmente.

Si noti che è possibile sovrascrivere right[i] perché non si riutilizza tale valore in un secondo momento. Puoi così fare modifiche in linea.

Dopo le modifiche, si scambiano i buffer. L'unico aspetto che devi prendere in considerazione è che per l'ultimo round, dopo aver eseguito l'operazione, anche i buffer verranno scambiati. Pertanto verranno scambiati anche gli ultimi left e right. Puoi (1) fare uno scambio addizionale dopo il ciclo for; oppure (2) prendere in considerazione lo swap e fingere che left sia right e viceversa; o (3) utilizzare un valore di if -clausa per impedire l'ultimo scambio.

Answer 2

Uso 2 matrice bidimensionale

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

Poi:

• leftArray[0][0] equivale a left1[0];
• leftArray[0][1] è equivalente a left1[1];
• rightArray[0][0] è equivalente a right1[0];
• rightArray[2][2] è equivalente a right3[2];
• ...

quindi utilizzare un ciclo annidato per scorrere le cose che dovete fare

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