Detalhes

Categoria: Cifras de bloco

Atualização: Segunda, 20 Abril 2009 13:37

Autor: vovó Vicki

Acessos: 37104

Passo 2: Codificar cada bloco de 64 bits de dados

Existe uma permutação inicial IP dos 64 bits de dados da mensagem M. Isto rearranja os bits de acordo com a seguinte tabela, onde as entradas da tabela mostram o novo arranjo de bits a partir da ordenação inicial. O 58º bit de M torna-se o primeiro bit de IP. O 50º bit de M passa a ser o segundo bit de IP. O 7º bit de M será o último bit de IP.

IP
-----------------------------------------
58    50   42    34    26   18    10    2
60    52   44    36    28   20    12    4
62    54   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
-----------------------------------------

Exemplo: Aplicando a permutação inicial ao bloco de texto M citado anteriormente obtemos

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

Aqui, o 58º bit de M é "1" e se torna o primeiro bit de IP. O 50º bit de M também é "1" e torna-se o segundo bit de IP. O 7º bit de M é "0", o qual se torna o último bit de IP.

Em seguida dividimos o bloco permutado IP numa metade esquerda L₀ de 32 bits e numa metade direita R₀ de 32 bits.

Exemplo: Obtemos L₀ e R₀ de IP

L0 = 1100 1100 0000 0000 1100 1100 1111 1111 
R0 = 1111 0000 1010 1010 1111 0000 1010 1010 

Agora prosseguimos com 16 iterações, para 1<=n<=16, usando uma função f que opera em dois blocos - no bloco de dados de 32 bits e na chave K_n de 48 bits - para produzir um bloco de 32 bits. Seja + uma adição XOR (adição bit-a-bit módulo 2) então, para n variando de 1 a 16, calculamos

Ln = Rn-1
Rn = Ln-1 + f(Rn-1,Kn)

O resultado aparece num bloco final, para n = 16, de L₁₆R₁₆. Isto é, em cada iteração, pegamos os 32 bits da direita do resultado anterior e transformamo-os nos 32 bits da esquerda do passo atual. Para os 32 bits da direita do passo atual nós fazemos um XOR dos 32 bits da esquerda do passo anterior através do cálculo de f.

Exemplo: Para n = 1 temos

K1 = 000110 110000 001011 101111 111111 000111 000001 110010 
L1 = R0 = 1111 0000 1010 1010 1111 0000 1010 1010 
R1 = L0 + f(R0,K1) 

Falta explicar como funciona a função f. Para calcular f, primeiramente expandimos cada bloco R_n-1 de 32 bits para 48 bits (para se ajustar ao tamanho das sub-chaves). Isto é feito usando uma tabela de seleção que repete alguns dos bits em R_n-1. Chamaremos o uso desta tabela de seleção de função E. Portanto, E(R_n-1) tem um bloco de entrada de 32 bits e um bloco de saída de 48 bits.

Seja E tal que os 48 bits de saída, escritos em 8 blocos de 6 bits cada, sejam obtidos através da seleção de bits nas suas entradas de acordo com a seguinte tabela:

Tabela E de Seleção de bits
----------------------------------
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    1
----------------------------------

Portanto, os primeiros três bits de E(R_n-1) são os bits das posições 32, 1 e 2 de R_n-1, enquanto que os dois últimos bits de E(R_n-1) são os bits da posição 32 e 1.

Exemplo: Calculamos E(R₀) de R₀ da seguinte maneira:

  R0  =  1111   0000   1010   1010   1111   0000   1010   1010

E(R0) = 011110 100001 010101 010101 011110 100001 010101 010101

(Note que cada bloco de 4 bits originais foi expandido para um bloco de 6 bits de saída).