C# ¿Cómo generar una subclave a partir de un generador de claves?

El objeto de datos procesado por el algoritmo DES es una cadena de texto sin formato de 64 bits. Supongamos que la cadena de texto plano es m=m1m2...m64 (mi=0 o 1). La cadena de texto plano se cifra con una clave K de 64 bits para generar un texto cifrado E de 64 bits. El proceso de cifrado es el siguiente:

Proceso de cifrado del algoritmo DES

El proceso de cifrado del algoritmo DES es el siguiente:

Reemplace la cadena de texto sin formato de 64 bits m por a cifrar es IP, y luego la lista de subíndices de la cadena de bits se obtiene de la siguiente manera:

IP 58 50 42 34 26 18 10 2

60 52 44 36 28 20 12 4

62 54 46 46 38 30 22 14 6

64 56 48 40 32 24 16 8

57 49 41 33 25 17 9 1

59 51 43 35 27 19 11 3

61 53 45 37 29 21 13 5

63 55 47 39 31 23 15 7

La broca La cadena se divide en dos partes, L0 de 32 bits y R0 de 32 bits. La subclave R0 K1 (la generación de la subclave se discutirá más adelante) se transforma mediante f (R0, K1) (la transformación f se discutirá a continuación) y se genera la cadena de bits de 32 bits f1, que es la operación de suma binaria del Bit L0. La suma binaria de L0 no incluye el redondeo. Las reglas operativas son:

f1 y L0 no se llevan después de la operación de suma binaria, el resultado se asigna a R1 y R0 se asigna al L1 original. L1 y R0 hacen exactamente la misma operación que arriba, y después de 16 operaciones, L2, R2... se genera un ****. Finalmente se generan R16 y L16. Entre ellos, R16 es L15, f (R15, K16) no avanza el resultado de la operación de suma binaria y L16 es la asignación directa de R15.

R16 y L16 se combinan en una cadena de 64 bits. Vale la pena señalar que R16 debe colocarse delante de L16. La lista de subíndices de la cadena de bits obtenida después de reemplazar R16 y L16 con IP-1 es la siguiente: La cadena de bits generada después de reemplazar IP-1 es el texto cifrado e.

La transformación f(Ri-1,Ki) se introducirá nuevamente a continuación.

Su función es convertir nuevamente la entrada de 32 bits en salida de 32 bits. El proceso se muestra en la figura:

La descripción de la transformación f es la siguiente: la entrada Ri-1 (32 bits) se expande a 48 bits después de la transformación E. La lista de índice de la cadena de bits expandida es la siguiente:

E: 32 1 2 3 4 5

4 5 6 7 8 9

8 9 10 11 12 13

12 13 14 15 16 17

16 17 18 19 20 21

20 21 22 23 24 25

24 25 26 27 28 29

28 29 30 31 32 31

La cadena de bits expandida se divide en 8 grupos, cada grupo tiene 6 bits. Después de que cada grupo pasa por su propia S-box, vuelve a ser de 4 bits (consulte el proceso a continuación) y, después de fusionarse, vuelve a ser de 32 bits. La lista de subíndices es la siguiente:

P: 16 7 20 21

29 12 28 17

1 15 23 26

5 18 31 10

2 8 24 14

32 27 3 9

19 13 30 6

22 11 4 25

La salida de la cadena de bits después de la transformación P es f de 32 bits (Ri-1, Ki).

El proceso de transformación de S-box se presenta con más detalle a continuación.

Elija cualquier S-box. Vea la imagen:

Ingrese b1, b2, b3, b4, b5, b6, calcule x=b1*2+b6, y=b5+b4*2+b3*4+b2*8, y luego, desde Encuentre el valor Sxy en la fila x y la columna y en la tabla Si y convierta Sxy a binario para obtener el resultado del cuadro Si. (La tabla S se muestra en la figura)

En este punto, se completa la introducción al principio de cifrado del algoritmo DES. El código fuente del programa en VC++6.0 es:

for(i=1;i<=64;i++)

m1[i]=m[ip[i- 1 ]];// Entrada de cadena de texto sin formato de 64 bits, después del reemplazo de IP.

Próxima iteración. Dado que el método es el mismo para cada iteración, solo la entrada y la salida son diferentes, solo se proporciona una de ellas. Tome la octava vez como ejemplo: //Realice la octava iteración. Primero realice la operación S-box usando una entrada de cadena de 32 bits.

for(i=1;i<=48;i++)//Extendido de 32 bits a 48 bits mediante transformación E

RE1[i]=R7[E[i - 1]];

for(i=1;i<=48;i++)//y K8 por bit para operación de suma no redondeada

RE1[i]= RE1[i ] +K8[i];

for(i=1;i<=48;i++)

{

si(RE1[i]== 2 )

RE1[i]=0;

}

for(i=1;i<7;i++)//48 bits se dividen en 8 Grupo

{

s11[i]=RE1[i]

s21[i]=RE1[i+6]; p>s31[i]=RE1[i+12];

s41[i]=RE1[i+18]

s51[i]=RE1[i+24] ];

s61[i]=RE1[i+30];

s71[i]=RE1[i+36]; ]=RE1[i+42];

}/// La siguiente operación atravesará el cuadro S y obtendrá 8 números.

s1,s2,s3,s4,s5,s6,s7,s8 son tablas S

s[1]=s1 [s11[6]+s11[1]*2][s11[5] +s11[4]*2+s11[3]*4+s11[2]*8]

s[2]=s2[s21[6]+s21[1]*2][ s21[5]+s21[4]*2+s21[3]*4+s21[2]*8];

s[3 ]=s3[s31[6]+s31[1] *2][s31[5]+s31[4]*2+s31[3]*4+s31[2]*8];

s[4]=s4[s41[6]+ s41[1]*2][s41[5]+s41[4]*2+s41[3]*4+s41[2]*8]; [6]+s51[1]*2][s51[5]+s51[4]*2+s51[3]*4+s51[2]*8];

s[6] =s6[s61[6]+s61[1]*2][s61[5]+s61[4]*2+s61[3]*4+s61[2]*8]

s[7]=s7[s71[6]+s71[1]*2][s71[5]+s71[4]*2+s71[3]*4+s71[2]*8];

s[8]=s8[s81[6]+s81[1]*2][s81[5]+s81[4]*2+s81[3]*4+s81[2]*8 ] ;

for(i=0;i<8;i++)//8 conversión digital de salida binaria

{

for(j=1;j< 5;j++)

{

temp[j]=s[i+1]%2

s[i+1]=s[i; +1]/2; <

}

para(j=1;j<5;j++)

f[4*i+j]= temp[5-j];

}

}

for(i=1;i<33;i++)//después de la transformación P

frk[i]=f[P[i-1]];//S box Operación completa

for(i=1;i<33;i++)//izquierda-derecha swap

L8[i]=R7[i];

for(i=1;i<33;i++)//R8 es la relación entre L7 y f(R, K) El resultado de la suma binaria no redondeada

{

R8[i ]=L7[i]+frk[i]

if(R8; [i]= =2)

R8[i]=0;

}

[Documento original Este artículo es para lectores intermedios y ha sido leído 21,783 veces]

.Herramienta de código de documento

Algoritmo DES y su implementación en VC++6.0 (Parte 2)

Autor: Zhu Yanjun, Departamento IV: Instituto de Ingeniería Médica Aeroespacial Cuarta Serie Zhu Yanjun

"Algoritmo DES y su implementación bajo VC++6.0 (Parte 1)" presenta principalmente los principios básicos del algoritmo DES.Continuemos:

1. Principios básicos del algoritmo DES

1. Generación de subclaves

Una clave de 64 bits genera 16 48. Subclaves de bits. El proceso de generación se muestra en la figura:

El proceso de generación de subclave se explica a continuación:

La clave K de 64 bits genera una cadena de 56 bits después de la PC-1.

Los subíndices son los que se muestran en la tabla:

PC-1 57 49 41 33 25 17 9

1 58 50 42 34 26 18

10 2 59 51 43 35 27

19 11 3 60 52 44 36

63 55 47 39 31 23 15

7 62 54 46 38 30 22

14 6 61 53 45 37 29

21 13 5 28 20 12 4

La cadena de bits se divide en dos cadenas de igual longitud, C0 y D0, y se obtiene después de cambiar cíclicamente un bit, C1 y D1 se combinan para obtener C1D1, que luego se convierte a K1 de 48 bits a través de PC-2. La lista de subíndices de K1 es

PC-2 14 17 11 24 1 5

3 28 15 6 21 10

23 19 12 4 26 8

p>

16 7 27 20 13 2

41 52 31 37 47 55

30 40 51 45 33 48

44 49 39 56 34 53

46 42 50 36 29 32

C1 y D1 se desplazan circularmente hacia la izquierda en bits LS2 respectivamente y luego se fusionan después de PC-2 para generar la subclave K2 . ....., y así sucesivamente hasta que se genere la subclave K16.

Nota: Lsi (I =1,2,....16) tiene valores diferentes. -1 se convierte en k0[i]=k[PC_1[i-1]] de 56 bits;

El K0 de 56 bits se distribuye uniformemente en C0 y D0 de 28 bits. for(i=1;i<27;i++)//bucle dejado por dos bits

{

C8[i]=C7[i+2]

D8[i]=D7[i+2]

}

C8[27]=C7[1]; ]=D7[1];

C8[28]=C7[2];

D8[28]=D7[2]; i=1;i<=28;i++)

{

C[i]=C8[i]

C[i+28]= D8[i];

}

para( i=1;i<=48;i++)

K8[i]=C[PC_2[i -1]];//generar subclave k8

Nota: Las diferentes subclaves generadas requieren un número diferente de bits para desplazarse hacia la izquierda en el bucle. En el programa fuente, tomando como ejemplo la generación de la subclave K8, dos bits se desplazan cíclicamente hacia la izquierda. Pero en programación se deben generar diferentes subclaves según la tabla Lsi.

III. Descifrado

El proceso de descifrado de DES es completamente similar al proceso de cifrado de DES, excepto que el orden de las subclaves de 16 ciclos K1, K2...K16 es invertido. Es decir, la decimosexta subclave K16 se usa para el primer ciclo, K15 se usa para el segundo ciclo, y así sucesivamente.

Primer círculo:

Resultado cifrado

L=R15, R=L15⊕f(R15,K16)⊕f(R15,K16) =L15

Del mismo modo, R15=L14⊕f(R14,K15), L15=R14.

Similares y análogos:

Obtener L=R0, R=L0.

El código fuente del programa es el mismo que el cifrado. No más reescritura aquí.

IV.Ejemplo

Por ejemplo, texto plano conocido m= aprendizaje, clave k= computadora.

Representación binaria ASCII de texto plano m:

m= 01101100 01100101 01100001 01110010

01101110 01101001 01101110 01100111

ASCII de la clave k Representación binaria:

L1=00000000 11111111 01110001 11011000 R1=00110101 00111011 10100101

L2=00110101 00111011 10100101 R2=00010 11 1 11100010 1010011010 100111

L3=00010111 11100010 10111010 10000111 R3=00111110 10110001 00001011 10000100

L4=001111101011000010100 11010000100 R4=1111011111011 11110100 0111110

L5= 11110111110101111111101000111110 R5=10010110011001110100111111100101

L6=10010110011001110100111 1111001 01 R6= 11001011001010000101110110100111

L7=11001011001010000101110110100111 R7=01100011110011101000111011011001

L8= 0110 0011110011101000111011011001 R8=01 001011110100001111001000000100

L9=01001011110100001111001000000100 R9= 0001110100110111 01111010111011100001

L10= 00 0111010011011101111010111011100001 R10=111011101111101111010100000101

L11= 11101110111110111111010100000101 R11=0110 1101111011011110010111111000

L12=01101101111011011110010111111000 R12= 11111101110011100111000110110111

L13=11111101 110011100111000110110111 R13=111001111110010110101000000100

L14= 111001111110010110101000000100 R14 =000111100100011100001100001

L15=00011110010011011100001100001 R15= 010100001110 01001101110110100011

L16=0101000 0111001101110110100011 R16=01111101101010000100110001100001

Entre ellos, el resultado de f- es el resultado de la función

f1=11001010001110011110100000000011 f2=000101110001

0 1100010001100001 f6=00111100111111111010011110011001

f7= 1111010110101010011100000100111100 f8=100000001111100010101110 1 00011

f9 =01111110111110010010000000111000 f10= 10100101001010110000011100000001

f11=01110000110110100100101100011001 f12=0001001 10011011000010010110010p

f 13= 1000100000100001001111111100 f14=11100011100001111100100111010110

f15=10110111000000 010111011110100111 f16= 01100011 111000011111010000000000

16 Las subclaves son las siguientes:

K1=1111000010111110111011010000 K2=11100000101111101111011010010101

K3=11110100111111100111011000101 000 K4=1 1100110111101110111001000011010

K5=1110111011010111110111011100100110 K6= 11101111110100110101101110001011

K7=00101111110100111111101111100110 K8=10111111010110011101101010000

K9= 00011111010110111101101101000100 K10=0011 1111 01111001110110100001001

K11=00011111011011011011100110101101000 K12= 01011011011011011011011110100001010

K13=1 101 110110110110110110110001111 K14=110100111010111010111110000000

K15= 11111001101110101010011011010011 K16=1111000110111 1100010111000000001

En el S-box, los 8 resultados de las 16 operaciones son:

Primera vez: 5 , 11, 4, 1, 0, 3, 13, 9;

La segunda vez: 7, 13, 15, 8, 12, 12, 13, 1;

El tercera vez: 8, 0, 0, 4, 9;

Tercera vez: 8, 0, 0, 4, 9: 8, 0, 0, 4, 8, 1, 9, 12;

La cuarta vez: 0, 7, 4, 1, 7, 6, 12, 4;

La quinta vez: 8, 1, 0, 11, 5, 0, 14 , 14;

La sexta vez: 14, 12.

10, 15, 8, 2, 1, 12, 12, 3;

El 12: 5, 4, 4, 0, 1, 15, 5, 12: 5, 4, 4, 0, 14, 10, 7, 4;

13: 2, 13, 10, 9, 2, 4, 3, 13; 9, 15, 0, 1, 3;

La 15.ª vez: 3, 1, 15, 5, 11, 9, 11, 4;

La 16.ª vez: 12 , 3, 4, 6, 9, 3, 3, 0;

El proceso de generación de subclaves producirá los siguientes valores:

C0=000000001111111111011 D0= 1000001101110110000001101000

p>

C1=000000011111111110110 D1=0000011011101100000011010001

C2= 000000111111111111101100 D2=0000110111011000000110 10 0010

C3=00001111111111110110000 D3=00110111011000000110100000

C4=00111111111111111111011000000D4 =110111011000 0001101000100000

C5=11111111111111111101100000000 D5= 0111011000000110100010000011

C6=11111111111111 0110000000011 D6=11011000000 11010001000001101

C7= 1111111111111011000000001111 D7=0110000001101000100000110111

C8=1111111111101100000000111 111D8=1000000110100010000011011101

C8=11111111111011000000001111 D8=1000000110101011011101

C9=1111111111011000000001111111 D9=000000110100010000011 0111011

C10=1111111101100000000111111111 D10= 000011010001 0000011011101100

C11=1111110110000000011111111111 D11 =0011010001101110110000

C12=111101100000000111111111111 D12=110100010000011011101 1000000

C13=110110000000 011111111111 D13=0100010000011011101100000011

C14=0110000000011111111111 D14=00010000011011 10110000001101

C15= 1000000001111111111111101 D15=0100000110111011000000110100

C16=000000001111111111111011 D16=100000110111011000 00011 01000