Vous êtes sur la page 1sur 7

Seguridad

Informtica. Esquema de cifrado DES


Esquema de cifrado DES


DES es un esquema de cifrado en bloque que opera sobre bloques de texto de 64 bits, devolviendo
bloques cifrados tambin de 64 bits. As pues, DES sobre 264 posibles combinaciones de bits. Cada
bloque de 64 bits es dividido en dos bloques del mismo tamao (32 bits cada uno), que se representan
mediante L (para los 32 bits de la izquierda) y R (para los 32 bits de ms a la derecha)
Ejemplo: Sea M cierto mensaje con el texto plano siguiente: M = 0123456789ABCDEF, donde M est en
formato hexadecimal. Si transformamos M al sistema binario obtendremos el siguiente bloque de bits
(64):
M = 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
L = 0000 0001 0010 0011 0100 0101 0110 0111
R = 1000 1001 1010 1011 1100 1101 1110 1111
Una de las caractersticas de DES es que opera con bloques de 64 bits, pero usando tamaos de claves de
56 bits. La clave se almacena usando 64 bits, pero el octavo bit de cada byte (de izda. a dcha.) no se usa.
Ejemplo: Sea K una clave en formato hexadecimal K = 133457799BBCDFF1. En binario:
K = 00010011 00110100 01010111 01111001 10011011 10111100 11011111 11110001
El esquema de cifrado DES realizar los siguientes pasos:

Paso 1: Crear 16 sub-claves de 48 bits cada una


La clave de 64 bits se permuta usando la tabla PC-1. Ya que la primera entrada en la tabla es 57, esto
significa que el bit n 57 de la clave original pasar a ser el primer bit de la permutacin; anlogamente, el
bit 49 pasar a ser el segundo en la permutacin, y as sucesivamente. NOTA: es importante observar que
en la tabla PC-1 no aparecen los bits de paridad, para as eliminarlos.
PC-1
57
1
10
19
63
7
14
21

49
58
2
11
55
62
6
13

41
50
59
3
47
54
61
5

33
42
51
60
39
46
53
28

25
34
43
52
31
38
45
20

17
26
35
44
23
30
37
12

9
18
27
36
15
22
29
4

Ejemplo: A partir de la clave original de 64 bits:


K = 00010011 00110100 01010111 01111001 10011011 10111100 11011111 11110001
se obtiene, aplicando la permutacin PC-1:
K+ = 1111000 0110011 0010101 0101111 0101010 1011001 1001111 0001111
A continuacin, dividimos el resultado en dos mitades C0 y D0, cada una de ellas de 28 bits.
A partir de K+ tendramos:
C0 = 1111000 0110011 0010101 0101111
D0 = 0101010 1011001 1001111 0001111

Con C0 y D0 definidas, ahora creamos 16 bloques Ci y Di, 1<=n<=16. Cada par de bloques (Ci , Di) se
forma a partir del par (Ci -1, Di-1), usando para ello una tabla de rotaciones (circulares de dcha. a izda.)
prefijadas de la siguiente forma:
Iteracin
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# desplazamientos
1
1
2
2
2
2
2
2
1
2
2
2
2
2
2
1

Siguiendo nuestro ejemplo, as quedaran Ci y Di, para las 16 iteraciones:


C0 = 1111000011001100101010101111
D0 = 0101010101100110011110001111
C1 = 1110000110011001010101011111
D1 = 1010101011001100111100011110
C2 = 1100001100110010101010111111
D2 = 0101010110011001111000111101
C3 = 0000110011001010101011111111
D3 = 0101011001100111100011110101
C4 = 0011001100101010101111111100
D4 = 0101100110011110001111010101
C5 = 1100110010101010111111110000
D5 = 0110011001111000111101010101
C6 = 0011001010101011111111000011
D6 = 1001100111100011110101010101
C7 = 1100101010101111111100001100
D7 = 0110011110001111010101010110
C8 = 0010101010111111110000110011
D8 = 1001111000111101010101011001
C9 = 0101010101111111100001100110
D9 = 0011110001111010101010110011
C10 = 0101010111111110000110011001
D10 = 1111000111101010101011001100
C11 = 0101011111111000011001100101
D11 = 1100011110101010101100110011
C12 = 0101111111100001100110010101
D12 = 0001111010101010110011001111
C13 = 0111111110000110011001010101
D13 = 0111101010101011001100111100
C14 = 1111111000011001100101010101
D14 = 1110101010101100110011110001
C15 = 1111100001100110010101010111
D15 = 1010101010110011001111000111
C16 = 1111000011001100101010101111
D16 = 0101010101100110011110001111

Seguridad Informtica. Esquema de cifrado DES



En este momento, ya estamos en condiciones de generar las 16 sub-claves ki para nuestro esquema. Para
ello, usaremos la permutacin prefijada por la tabla PC-2 a cada par concatenado Ci || Di. Recuerda que
cada par contiene 56 bits; la permutacin con PC-2 la reduce a 48 bits.

PC-2
14
3
23
16
41
30
44
46

17
28
19
7
52
40
49
42

11
15
12
27
31
51
39
50

24
6
4
20
37
45
56
36

1
21
26
13
47
33
34
29

5
10
8
2
55
48
53
32

Ejemplo: para la primera clave tenemos


C1D1 = 1110000 1100110 0101010 1011111 1010101 0110011 0011110 0011110
Tras su permutacin con PC-2, obtendramos:
K1 = 000110 110000 001011 101111 111111 000111 000001 110010
Para el resto de claves:
K2 = 011110 011010 111011 011001 110110 111100 100111 100101
K3 = 010101 011111 110010 001010 010000 101100 111110 011001
K4 = 011100 101010 110111 010110 110110 110011 010100 011101
K5 = 011111 001110 110000 000111 111010 110101 001110 101000
K6 = 011000 111010 010100 111110 010100 000111 101100 101111
K7 = 111011 001000 010010 110111 111101 100001 100010 111100
K8 = 111101 111000 101000 111010 110000 010011 101111 111011
K9 = 111000 001101 101111 101011 111011 011110 011110 000001
K10 = 101100 011111 001101 000111 101110 100100 011001 001111
K11 = 001000 010101 111111 010011 110111 101101 001110 000110
K12 = 011101 010111 000111 110101 100101 000110 011111 101001
K13 = 100101 111100 010111 010001 111110 101011 101001 000001
K14 = 010111 110100 001110 110111 111100 101110 011100 111010
K15 = 101111 111001 000110 001101 001111 010011 111100 001010
K16 = 110010 110011 110110 001011 000011 100001 011111 110101

Paso 2: Cmo se cifra el mensaje


Se realiza una permutacin inicial, con la tabla IP sobre el mensaje en claro M. Esto provoca una
reordenacin de los bits originales como sigue:
IP
58
60
62
64
57
59
61
63

50
52
54
56
49
51
53
55

42
44
46
48
41
43
45
47

34
36
38
40
33
35
37
39

26
28
30
32
25
27
29
31

18
20
22
24
17
19
21
23

10
12
14
16
9
11
13
15

2
4
6
8
1
3
5
7

Ejemplo: aplicando la permutacin inicial al bloque del texto M, obtenemos:

M = 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
IP = 1100 1100 0000 0000 1100 1100 1111 1111 1111 0000 1010 1010 1111 0000 1010 1010
A continuacin, dividimos el bloque permutado IP en dos mitades: una parte izquierda L0 y una parte
derecha (ambas de 32 bits).
Ejemplo: a partir de IP, obtenemos
L0 = 1100 1100 0000 0000 1100 1100 1111 1111
R0 = 1111 0000 1010 1010 1111 0000 1010 1010
A partir de este momento, el algoritmo realiza 16 iteraciones, usando una funcin f que opera con dos
bloques: un bloque de datos de 32 bits y una clave de 48 bits, para producir un bloque de 32 bits. Se
define como sigue:
Li = Ri-1
Ri = Li-1 + f(Ri-1,Ki)
Este proceso finalizar con un bloque final con i = 16, de L16R16. Es decir, en cada iteracin, los 32 bits de
ms a la derecha se convierten en los 32 bits de ms a la izquierda de la siguiente iteracin. Sin embargo,
los 32 bits de ms a la izquierda de la iteracin actual, se suman usando la funcin XOR con los 32 bits
resultado de la funcin f.
Ejemplo: Para i = 1 obtenemos:
K1 = 000110 110000 001011 101111 111111 000111 000001 110010
L1 = R0 = 1111 0000 1010 1010 1111 0000 1010 1010
R1 = L0 f(R0,K1)
Slo queda por explicar cmo funciona la funcin f. Para calcular f, debemos primero expandir cada
bloque Ri-1, de 32 bits a 48 bits (para poder operar con la clave). Esto se har usando la tabla E, que se
muestra a continuacin:
E
32
4
8
12
16
20
24
28

1
5
9
13
17
21
25
29

2
6
10
14
18
22
26
30

3
7
11
15
19
23
27
31

4
8
12
16
20
24
28
32

5
9
13
17
21
25
29
1

De esta forma, se obtiene una extensin de 48 bits. El resultado de la extensin definida por la tabla E se
suele escribir como 8 bloques de 6 bits.
Ejemplo: Si calculamos E(R0) obtendremos:
R0 = 1111 0000 1010 1010 1111 0000 1010 1010
E(R0) = 011110 100001 010101 010101 011110 100001 010101 010101
Ahora, para el clculo de f se realiza una operacin de XOR entre E(Ri.-1) y Ki => (E(Ri.-1) Ki)
Ejemplo: para K1 , E(R0), obtendramos:
K1 =
000110 110000 001011 101111 111111 000111 000001 110010
E(R0) =
011110 100001 010101 010101 011110 100001 010101 010101
-------------------------------------------------------------------------------------------------------K1+E(R0) =
011000 010001 011110 111010 100001 100110 010100 100111

Seguridad Informtica. Esquema de cifrado DES



En este punto, seguimos manejando bloques de 48 bits, ms concretamente, tenemos 8 bloques de 6 bits
cada uno. Cada uno de estos bloques nos servir para indexar direcciones de entrada a un grupo de tablas
de sustitucin llamadas S-Cajas. Cada grupo de 6 bits nos dar una direccin diferente para la entrada de
una S-Caja. En la direccin concreta que indique el bloque habr un nmero de 4 bits, que ser la salida
de la S-Caja. Existirn un total de 8 S-Cajas (una para cada bloque). De esta forma la salida de este
proceso convertir 8 bloques de 6 bits en 8 bloques de 4 bits (32 bits en total).
Dividimos pues, el resultado anterior en 8 bloques de 6 bits de esta forma:
E(Ri.-1) Ki = B1B2B3B4B5B6B7B8
donde cada Bj es un bloque de 6 bits. Ahora calculamos:
S1(B1)S2(B2)S3(B3)S4(B4)S5(B5)S6(B6)S7(B7)S8(B8)
donde Sj(Bj) se refiere a la salida de la S-Caja j para el bloque j de 6 bits. Las tablas que determinan estas
sustituciones son las siguientes:
S1
14 4
0 15
4 1
15 12

13
7
14
8

1
4
8
2

2 15
14 2
13 6
4 9

11 8
13 1
2 11
1 7

3 10
10 6
15 12
5 11

6
12
9
3

12
11
7
14

5
9
9
5
3 10
10 0

0
3
5
6

7
8
0
13

S2
15
3
0
13

1
13
14
8

8 14
4 7
7 11
10 1

6 11
15 2
10 4
3 15

3 4
8 14
13 1
4 2

9
12
5
11

7
0
8
6

2 13
1 10
12 6
7 12

12
6
9
0

0
9
3
5

5 10
11 5
2 15
14 9

S3
10
13
13
1

0
7
6
10

9 14
0 9
4 9
13 0

6 3
3 4
8 15
6 9

15 5
6 10
3 0
8 7

1 13
2 8
11 1
4 15

12 7
5 14
2 12
14 3

11 4
12 11
5 10
11 5

2 8
15 1
14 7
2 12

S4
7
13
10
3

13
8
6
15

14
11
9
0

0 6
6 15
12 11
10 1

9 10
0 3
7 13
13 8

1
4
15
9

8 5
2 12
3 14
5 11

11 12
1 10
5 2
12 7

4 15
14 9
8 4
2 14

3
5
0
6

2
7
1
4

S5
2 12
14 11
4 2
11 8

4 1
2 12
1 11
12 7

7 10
4 7
10 13
1 14

11 6
13 1
7 8
2 13

8 5
5 0
15 9
6 15

3 15
15 10
12 5
0 9

13
3
6
10

0
9
3
4

14 9
8 6
0 14
5 3

S6
12 1
10 15
9 14
4 3

10 15
4 2
15 5
2 12

9 2
7 12
2 8
9 5

6 8
9 5
12 3
15 10

0 13
6 1
7 0
11 14

3 4
13 14
4 10
1 7

14 7
0 11
1 13
6 0

5 11
3 8
11 6
8 13

S7
4 11
13 0
1 4
6 11

2 14
11 7
11 13
13 8

8 13
1 10
7 14
10 7

3 12
14 3
10 15
9 5

9 7
5 12
6 8
0 15

5 10
2 15
0 5
14 2

6 1
8 6
9 2
3 12

15
4
12
1

0
9
3
4

S8
13 2
1 15
7 11
2 1

8
13
4
14

4
8
1
7

6 15
10 3
9 12
4 10

11 1
7 4
14 2
8 13

10 9
12 5
0 6
15 12

3 14
6 11
10 13
9 0

5 0
0 14
15 3
3 5

12 7
9 2
5 8
6 11

Cmo se selecciona la entrada de la S-Caja correspondiente a un bloque determinado se realiza de la


siguiente forma: el primer y el ltimo bit del bloque, en base 2, representan la fila a seleccionar, mientras
que los 4 bits restantes (en el centro) representan la columna a elegir. Por ejemplo, para el bloque 011011,
01 1 y 1101 13, representa la entrada de la primera fila y la columna 13, lo que devolvera un
bloque de 4 bits: 1001, correspondientes a 9.
Ejemplo: para la primera ronda el resultado de las S-Cajas ser el siguiente:
K1 E(R0) = 011000 010001 011110 111010 100001 100110 010100 100111.
S1(B1)S2(B2)S3(B3)S4(B4)S5(B5)S6(B6)S7(B7)S8(B8) = 0101 1100 1000 0010 1011 0101 1001 0111
El ltimo paso para el clculo de f es hacer una permutacin con (definida por P) del resultado anterior:
f = P(S1(B1)S2(B2)...S8(B8))
Ntese que la permutacin P toma como entrada un bloque de 32 bits y devuelve otro bloque de 32 bits.
P
16
29
1
5
2
32
19
22

7
12
15
18
8
27
13
11

20
28
23
31
24
3
30
4

21
17
26
10
14
9
6
25

Ejemplo: a partir de la salida de las 8 S-Cajas obtenemos el siguiente valor de f:


f = 0010 0011 0100 1010 1010 1001 1011 1011
Completamos calculando el valor de R1:
R1 = L0 f(R0 , K1 ) =
1100 1100 0000 0000 1100 1100 1111 1111
0010 0011 0100 1010 1010 1001 1011 1011
----------------------------------------------------------= 1110 1111 0100 1010 0110 0101 0100 0100
En la siguiente ronda tendremos que L2 = R1, que es precisamente el bloque que acabamos de calcular, y
deberemos calcular R2 =L1 f(R1, K2), y as sucesivamente hasta completar las 16 rondas. Al final de la
ronda 16, tendremos los bloques L16 y R16. En este momento invertimos el orden de ambos bloques
generando:
R16L16
Por ltimo, aplicamos una permutacin final, inversa de la permutacin inicial (IP-1). Esta permutacin
est definida por la siguiente tabla:
IP-1
40
39
38
37

8
7
6
5

48
47
46
45

16
15
14
13

56
55
54
53

24
23
22
21

64
63
62
61

32
31
30
29

Seguridad Informtica. Esquema de cifrado DES



36
35
34
33

4
3
2
1

44
43
42
41

12
11
10
9

52
51
50
49

20
19
18
17

60
59
58
57

28
27
26
25

Ejemplo: al finalizar el proceso de 16 rondas, en nuestro ejemplo obtendramos:


L16 = 0100 0011 0100 0010 0011 0010 0011 0100
R16 = 0000 1010 0100 1100 1101 1001 1001 0101
Los concatenamos invirtiendo el orden y les aplicamos la permutacin IP-1:
R16L16 = 00001010 01001100 11011001 10010101 01000011 01000010 00110010 00110100
IP-1 = 10000101 11101000 00010011 01010100 00001111 00001010 10110100 00000101
En hexadecimal => 85E813540F0AB405
De esta forma hemos usado DES para codificar M = 0123456789ABCDEF en C = 85E813540F0AB405.
IMPORTANTE: el proceso de descifrado es exactamente igual al anterior, pero invirtiendo el orden en
el que se aplican las sub-claves. Es decir, comenzaramos usando K16.