Requisito previo: estándar de cifrado de datos simplificado | Serie 1
El estándar de cifrado de datos simplificado es una versión simple del estándar de cifrado de datos que tiene una clave de 10 bits y texto sin formato de 8 bits. Es mucho más pequeño que el algoritmo DES, ya que solo toma texto sin formato de 8 bits, mientras que DES toma texto sin formato de 64 bits. Fue desarrollado con fines educativos para que la comprensión de DES pueda ser fácil. Es un algoritmo de cifrado de bloques y utiliza una clave simétrica para su algoritmo, es decir, utilizan la misma clave tanto para el cifrado como para el descifrado. Tiene 2 rondas de cifrado que utilizan dos claves diferentes.
Primero, necesitamos generar 2 claves antes del cifrado. Después de generar claves, las pasamos a cada ronda individual para el cifrado s-des. El siguiente diagrama muestra los pasos involucrados en el algoritmo s-des.
Componentes:
el cifrado S-DES implica cuatro funciones:
1. Permutación inicial (IP) –
2. Función compleja (f k ) –
Es la combinación de funciones de permutación y sustitución. La siguiente imagen representa una ronda de cifrado y descifrado. Esta ronda se repite dos veces en cada cifrado y descifrado.
Los componentes en f k son –
a. Permutación expandida (EP):
toma una entrada de 4 bits y la convierte en una salida de 8 bits.
b. S-boxes (S0 y S1):
es un componente básico de un algoritmo de clave simétrica que realiza la sustitución.
C. Permutación P4 –
3. Interruptor (SW) –
4. Inversa de Permutación Inicial (IP -1 ) –
Primero , necesitamos generar 2 claves antes del cifrado.
Consider, the entered 10-bit key is - 1 0 1 0 0 0 0 0 1 0
Por lo tanto,
Key-1 is - 1 0 1 0 0 1 0 0 Key-2 is - 0 1 0 0 0 0 1 1
Cifrado –
Entered 8-bit plaintext is - 1 0 0 1 0 1 1 1
Paso 1:
Realizamos la permutación inicial en nuestro texto sin formato de 8 bits utilizando la tabla de IP. La permutación inicial se define como:
IP(k1, k2, k3, k4, k5, k6, k7, k8) = (k2, k6, k3, k1, k4, k8, k5, k7) After ip = 0 1 0 1 1 1 0 1
Paso 2:
después de la permutación inicial, obtenemos un bloque de texto de 8 bits que dividimos en 2 mitades de 4 bits cada una.
l = 0 1 0 1 and r = 1 1 0 1
En la mitad derecha, realizamos una permutación expandida usando la tabla EP que convierte 4 bits en 8 bits. La permutación de expansión se define como:
EP(k1, k2, k3, k4) = (k4, k1, k2, k3, k2, k3, k4, k1)
After ep = 1 1 1 0 1 0 1 1
Realizamos la operación XOR usando la primera clave K1 con la salida de permutación expandida.
Key-1 is - 1 0 1 0 0 1 0 0 (1 0 1 0 0 1 0 0) XOR (1 1 1 0 1 0 1 1) = 0 1 0 0 1 1 1 1 After XOR operation with 1st Key = 0 1 0 0 1 1 1 1
Nuevamente dividimos la salida de XOR en 2 mitades de 4 bits cada una.
l = 0 1 0 0 and r = 1 1 1 1
Tomamos el primer y cuarto bit como fila y el segundo y tercer bit como columna para nuestras cajas S.
S0 = [1,0,3,2
3,2,1,0
0,2,1,3
3,1,3,2]
S1= [0,1,2,3
2,0,1,3
3,0,1,0
2,1,0,3]
For l = 0 1 0 0
row = 00 = 0, column = 10 = 2
S0 = 3 = 11
For r = 1 1 1 1
row = 11 = 3, column = 11 = 3
S1 = 3 = 11
After first S-Boxes combining S0 and S1 = 1 1 1 1
Las cajas S dan una salida de 2 bits que combinamos para obtener 4 bits y luego realizamos la permutación usando la tabla P4. P4 se define como –
P4(k1, k2, k3, k4) = (k2, k4, k3, k1) After P4 = 1 1 1 1
Hacemos XOR la salida de la tabla P4 con la mitad izquierda de la tabla de permutación inicial, es decir, la tabla IP.
(0 1 0 1) XOR (1 1 1 1) = 1 0 1 0 After XOR operation with left nibble of after ip = 1 0 1 0
Combinamos ambas mitades, es decir, la mitad derecha de la permutación inicial y la salida de ip.
Combine 1 1 0 1 and 1 0 1 0 After combine = 1 0 1 0 1 1 0 1
Paso 3:
Ahora, divida la salida en dos mitades de 4 bits cada una. Combínalos de nuevo, pero ahora la parte izquierda debe convertirse en la derecha y la parte derecha debe convertirse en la izquierda.
After step 3 = 1 1 0 1 1 0 1 0
Paso 4: vuelva a
realizar el paso 2, pero esta vez mientras realiza la operación XOR después de la permutación expandida, use la tecla 2 en lugar de la tecla 1.
Expand permutation is defined as - 4 1 2 3 2 3 4 1 After second ep = 0 1 0 1 0 1 0 1 After XOR operation with 2nd Key = 0 0 0 1 0 1 1 0 After second S-Boxes = 1 1 1 1 P4 is defined as - 2 4 3 1 After P4 = 1 1 1 1 After XOR operation with left nibble of after first part = 0 0 1 0 After second part = 0 0 1 0 1 0 1 0 l = 1 1 0 1 and r = 1 0 1 0
En la mitad derecha, realizamos una permutación expandida usando la tabla EP que convierte 4 bits en 8 bits. La permutación de expansión se define como:
EP(k1, k2, k3, k4) = (k4, k1, k2, k3, k2, k3, k4, k1) After second ep = 0 1 0 1 0 1 0 1
Realizamos la operación XOR usando la segunda clave K2 con la salida de permutación expandida.
Key-2 is - 0 1 0 0 0 0 1 1 (0 1 0 0 0 0 1 1) XOR (0 1 0 1 0 1 0 1) = 0 0 0 1 0 1 1 0 After XOR operation with 2nd Key = 0 0 0 1 0 1 1 0
Nuevamente dividimos la salida de XOR en 2 mitades de 4 bits cada una.
l = 0 0 0 1 and r = 0 1 1 0
Tomamos el primer y cuarto bit como fila y el segundo y tercer bit como columna para nuestras cajas S.
S0 = [1,0,3,2
3,2,1,0
0,2,1,3
3,1,3,2]
S1 = [0,1,2,3
2,0,1,3
3,0,1,0
2,1,0,3]
For l = 0 0 0 1
row = 01 = 1 , column = 00 = 0
S0 = 3 = 11
For r = 0 1 1 0
row = 00 = 0 , column = 11 = 3
S1 = 3 = 11
After first S-Boxes combining S0 and S1 = 1 1 1 1
Las cajas S dan una salida de 2 bits que combinamos para obtener 4 bits y luego realizamos la permutación usando la tabla P4. P4 se define como –
P4(k1, k2, k3, k4) = (k2, k4, k3, k1) After P4 = 1 1 1 1
Hacemos XOR la salida de la tabla P4 con la mitad izquierda de la tabla de permutación inicial, es decir, la tabla IP.
(1 1 0 1) XOR (1 1 1 1) = 0 0 1 0 After XOR operation with left nibble of after first part = 0 0 1 0
Combinamos ambas mitades, es decir, la mitad derecha de la permutación inicial y la salida de ip.
Combine 1 0 1 0 and 0 0 1 0 After combine = 0 0 1 0 1 0 1 0 After second part = 0 0 1 0 1 0 1 0
Paso 5:
Realice la permutación inicial inversa. La salida de esta tabla es el texto cifrado de 8 bits.
Output of step 4 : 0 0 1 0 1 0 1 0
La permutación inicial inversa se define como:
IP-1(k1, k2, k3, k4, k5, k6, k7, k8) = (k4, k1, k3, k5, k7, k2, k8, k6)
El texto cifrado de 8 bits será = 0 0 1 1 1 0 0 0
Java
/*package whatever //do not write package name here */
import java.io.*;
public class GFG {
// int key[]= {0,0,1,0,0,1,0,1,1,1};
int key[] = {
1, 0, 1, 0, 0, 0, 0, 0, 1, 0
}; // extra example for checking purpose
int P10[] = { 3, 5, 2, 7, 4, 10, 1, 9, 8, 6 };
int P8[] = { 6, 3, 7, 4, 8, 5, 10, 9 };
int key1[] = new int[8];
int key2[] = new int[8];
int[] IP = { 2, 6, 3, 1, 4, 8, 5, 7 };
int[] EP = { 4, 1, 2, 3, 2, 3, 4, 1 };
int[] P4 = { 2, 4, 3, 1 };
int[] IP_inv = { 4, 1, 3, 5, 7, 2, 8, 6 };
int[][] S0 = { { 1, 0, 3, 2 },
{ 3, 2, 1, 0 },
{ 0, 2, 1, 3 },
{ 3, 1, 3, 2 } };
int[][] S1 = { { 0, 1, 2, 3 },
{ 2, 0, 1, 3 },
{ 3, 0, 1, 0 },
{ 2, 1, 0, 3 } };
// this function basically generates the key(key1 and
//key2) using P10 and P8 with (1 and 2)left shifts
void key_generation()
{
int key_[] = new int[10];
for (int i = 0; i < 10; i++) {
key_[i] = key[P10[i] - 1];
}
int Ls[] = new int[5];
int Rs[] = new int[5];
for (int i = 0; i < 5; i++) {
Ls[i] = key_[i];
Rs[i] = key_[i + 5];
}
int[] Ls_1 = shift(Ls, 1);
int[] Rs_1 = shift(Rs, 1);
for (int i = 0; i < 5; i++) {
key_[i] = Ls_1[i];
key_[i + 5] = Rs_1[i];
}
for (int i = 0; i < 8; i++) {
key1[i] = key_[P8[i] - 1];
}
int[] Ls_2 = shift(Ls, 2);
int[] Rs_2 = shift(Rs, 2);
for (int i = 0; i < 5; i++) {
key_[i] = Ls_2[i];
key_[i + 5] = Rs_2[i];
}
for (int i = 0; i < 8; i++) {
key2[i] = key_[P8[i] - 1];
}
System.out.println("Your Key-1 :");
for (int i = 0; i < 8; i++)
System.out.print(key1[i] + " ");
System.out.println();
System.out.println("Your Key-2 :");
for (int i = 0; i < 8; i++)
System.out.print(key2[i] + " ");
}
// this function is use full for shifting(circular) the
//array n position towards left
int[] shift(int[] ar, int n)
{
while (n > 0) {
int temp = ar[0];
for (int i = 0; i < ar.length - 1; i++) {
ar[i] = ar[i + 1];
}
ar[ar.length - 1] = temp;
n--;
}
return ar;
}
// this is main encryption function takes plain text as
//input uses another functions and returns the array of
//cipher text
int[] encryption(int[] plaintext)
{
int[] arr = new int[8];
for (int i = 0; i < 8; i++) {
arr[i] = plaintext[IP[i] - 1];
}
int[] arr1 = function_(arr, key1);
int[] after_swap = swap(arr1, arr1.length / 2);
int[] arr2 = function_(after_swap, key2);
int[] ciphertext = new int[8];
for (int i = 0; i < 8; i++) {
ciphertext[i] = arr2[IP_inv[i] - 1];
}
return ciphertext;
}
// decimal to binary string 0-3
String binary_(int val)
{
if (val == 0)
return "00";
else if (val == 1)
return "01";
else if (val == 2)
return "10";
else
return "11";
}
// this function is doing core things like expansion
// then xor with desired key then S0 and S1
//substitution P4 permutation and again xor we have used
//this function 2 times(key-1 and key-2) during
//encryption and 2 times(key-2 and key-1) during
//decryption
int[] function_(int[] ar, int[] key_)
{
int[] l = new int[4];
int[] r = new int[4];
for (int i = 0; i < 4; i++) {
l[i] = ar[i];
r[i] = ar[i + 4];
}
int[] ep = new int[8];
for (int i = 0; i < 8; i++) {
ep[i] = r[EP[i] - 1];
}
for (int i = 0; i < 8; i++) {
ar[i] = key_[i] ^ ep[i];
}
int[] l_1 = new int[4];
int[] r_1 = new int[4];
for (int i = 0; i < 4; i++) {
l_1[i] = ar[i];
r_1[i] = ar[i + 4];
}
int row, col, val;
row = Integer.parseInt("" + l_1[0] + l_1[3], 2);
col = Integer.parseInt("" + l_1[1] + l_1[2], 2);
val = S0[row][col];
String str_l = binary_(val);
row = Integer.parseInt("" + r_1[0] + r_1[3], 2);
col = Integer.parseInt("" + r_1[1] + r_1[2], 2);
val = S1[row][col];
String str_r = binary_(val);
int[] r_ = new int[4];
for (int i = 0; i < 2; i++) {
char c1 = str_l.charAt(i);
char c2 = str_r.charAt(i);
r_[i] = Character.getNumericValue(c1);
r_[i + 2] = Character.getNumericValue(c2);
}
int[] r_p4 = new int[4];
for (int i = 0; i < 4; i++) {
r_p4[i] = r_[P4[i] - 1];
}
for (int i = 0; i < 4; i++) {
l[i] = l[i] ^ r_p4[i];
}
int[] output = new int[8];
for (int i = 0; i < 4; i++) {
output[i] = l[i];
output[i + 4] = r[i];
}
return output;
}
// this function swaps the nibble of size n(4)
int[] swap(int[] array, int n)
{
int[] l = new int[n];
int[] r = new int[n];
for (int i = 0; i < n; i++) {
l[i] = array[i];
r[i] = array[i + n];
}
int[] output = new int[2 * n];
for (int i = 0; i < n; i++) {
output[i] = r[i];
output[i + n] = l[i];
}
return output;
}
// this is main decryption function
// here we have used all previously defined function
// it takes cipher text as input and returns the array
//of decrypted text
int[] decryption(int[] ar)
{
int[] arr = new int[8];
for (int i = 0; i < 8; i++) {
arr[i] = ar[IP[i] - 1];
}
int[] arr1 = function_(arr, key2);
int[] after_swap = swap(arr1, arr1.length / 2);
int[] arr2 = function_(after_swap, key1);
int[] decrypted = new int[8];
for (int i = 0; i < 8; i++) {
decrypted[i] = arr2[IP_inv[i] - 1];
}
return decrypted;
}
public static void main(String[] args)
{
GFG obj = new GFG();
obj.key_generation(); // call to key generation
// function
// int []plaintext= {1,0,1,0,0,1,0,1};
int[] plaintext = {
1, 0, 0, 1, 0, 1, 1, 1
}; // extra example for checking purpose
System.out.println();
System.out.println("Your plain Text is :");
for (int i = 0; i < 8; i++) // printing the
// plaintext
System.out.print(plaintext[i] + " ");
int[] ciphertext = obj.encryption(plaintext);
System.out.println();
System.out.println(
"Your cipher Text is :"); // printing the cipher
// text
for (int i = 0; i < 8; i++)
System.out.print(ciphertext[i] + " ");
int[] decrypted = obj.decryption(ciphertext);
System.out.println();
System.out.println(
"Your decrypted Text is :"); // printing the
// decrypted text
for (int i = 0; i < 8; i++)
System.out.print(decrypted[i] + " ");
}
}
//Omkar Varhadi
Your Key-1 : 1 0 1 0 0 1 0 0 Your Key-2 : 0 1 0 0 0 0 1 1 Your plain Text is : 1 0 0 1 0 1 1 1 Your cipher Text is : 0 0 1 1 1 0 0 0 Your decrypted Text is : 1 0 0 1 0 1 1 1
Publicación traducida automáticamente
Artículo escrito por devangj9689 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA