Luckas Andre Farias. Criptografia em hardware usando VHDL aplicado a VOIP

Transcrição

1 Luckas Andre Farias Criptografia em hardware usando VHDL aplicado a VOIP Londrina 2012

2 Luckas Andre Farias Criptografia em hardware usando VHDL aplicado a VOIP Trabalho de Conclusão de curso apresentado à Universidade Estadual de Londrina como parte dos requisitos para obtenção do título de bacharel em Ciência da Computação. Orientador: Prof Dr Wesley Attrot. Londrina 2013

3 Luckas Andre Farias Criptografia em hardware usando VHDL aplicado a VOIP Trabalho de Conclusão de Curso apresentado à Universidade Estadual de Londrina como parte dos requisitos para obtenção do título bacharel em Ciência da Computação. Orientador(a): Prof Dr Wesley Attrot. COMISSÃO EXAMINADORA Prof Dr Wesley Attrot Universidade Estadual de Londrina - UEL segundo membro da banca Universidade Estadual de Londrina - UEL terceiro membro da banca Universidade Estadual de Londrina - UEL Londrina, data da publicação do TCC.

4 Farias, Luckas Criptografia em hardware usando VHDL aplicado a VOIP TCC - Universidade Estadual de Londrina, Londrina RESUMO O trabalho tem como objetivo desenvolver um chip de descriptografa usando-se o algoritmo de descriptografia do AES(ADVANCED..., 2001), o qual será testado usando-se um serviço de rede VoIP. Este processo vem a agregar nos conhecimentos de arquitetura de computadores e no processo de criptografia, visando unir estas duas áreas de conhecimento. Tem-se como intuito possibilitar que a comunicação e troca de arquivos pela rede sejam feitas de forma mais segura, possibilitando por exemplo um canal seguro de comunicação em redes VoIP. Para a sociedade tem-se como benefício a privacidade e a segurança que isso proporcionaria às suas intercomunicações com as demais pessoas através da Internet. Palavras-Chave: palavra-chave1, palavra-chave2...palavra-chaven.

5 Lista de Figuras 1.1 Fluxo de dados e sequência de procedimentos no AES p. 10

6 Lista de Tabelas 1.1 Realização de XOR entre 2 bits p S-Box p Tabela Inverse S-Box p MixColuns na forma matricial p Tabela de valores Mul02 (multiplicados por 2) p Tabela de valores Mul03 (multiplicados por 3) p Inverse Mix Coluns na forma matricial p Tabela de valores Mul09 (multiplicados por 9) p Tabela de valores Mul11 (multiplicados por 0xB) p Tabela de valores Mul13 (multiplicados por 0xC) p Tabela de valores Mul14 (multiplicados por 0xD) p. 19

7 LISTA DE SIGLAS E ABREVIATURAS SIGLA1 - Significado

8 Sumário 1 Fundamentação Teórico Metodológica e Estado da Arte p AES p Noções e Funções Matemáticas aplicadas ao algoritmo AES..... p Expansão da Chave p Criptografia p Descriptografador p. 66 Referências Bibliográficas p. 97

9 9 1 Fundamentação Teórico Metodológica e Estado da Arte 1.1 AES O AES pode ser dividido em três processos (STALLINGS, ), a criptografia, a decriptografia e a expansão da chave, sendo que o enfoque deste trabalho é a decriptografia. O AES é baseado em blocos de informação (plaintext) de 128 bits e chaves que podem varia entre 128, 192 e 256 bits, chamados de AES-128, AES-192 e AES-256 respectivamente. Conforme pode ser visto na Tabela 1.1 para cada tamanho de chave existe uma certa quantidade de rounds 1 que é diretamente relacionado ao tamanho da chave, entretanto em todos os casos o palintext é sempre de 128 bits. Tamanho da chave round Noções e Funções Matemáticas aplicadas ao algoritmo AES usadas no algoritmo: Para os processo que serão descritos a seguir é preciso se ter algumas noções Notação Polinomial GF(2 8 ) Considerando que b 7,b 6,b 5,b 4,b 3,b 2,b 1,b 0 são os bits de um byte B qualquer tem-se b 7 x 7 + b 6 x 6 + b 5 x 5 + b 4 x 4 + b 3 x 3 + b 2 x 2 + b 1 x 1 + b 0. 1 Sequência de passos pré-definidos onde dentro deste intervalo nomeado de round serão executadas as tarefas. Os rounds são semelhantes entre si, sendo que também há a possibilidade de serem nomeados como rodadas, pois cada round será uma rodada.

10 1.1 AES 10 Figura 1.1: Fluxo de dados e sequência de procedimentos no AES Porta lógica XOR A porta lógica XOR consiste em receber N entradas e transformá-las em 1 saída, sendo que esta é 0 caso a quantidade de bits 1 no conjunto N seja par e 1 caso o conjunto de bits 1 no conjunto N seja impar. Para N = 2 ten-se a Tabela 1.1. Soma É nomeada como soma, mas na realidade aplica-se o XOR bit a bit (sem a passagem do excedente ao bit subsequente: não possui o vai 1 ). Sendo assim sua função é

11 1.1 AES 11 Bit[0] Bit [1] Saída Tabela 1.1: Realização de XOR entre 2 bits A XOR B = C, sendo no algoritmo A, B e C informações na memória de 128 bits. Multiplicação A multiplicação ocorre entre 2 bytes (considerando-se eles em notação polinomial). Ao resultado da multiplicação é aplicado o módulo, usando-se o polinômio x 8 + x 4 + x 3 + x + 1 (11Bh = ). Faz-se necessário observar que a soma é constituída como a soma descrita anteriormente, onde x n + x n = 0. Tabela SBox É usada na função Substitute bytes, sendo que existem dois meios de se obter o mesmo resultado neste passo, um deles é calculando-se a S-Box e o outro é usando os valores já armazenados em memória (a tabela resultante será a mesma). Nesta descrição estará em foco apenas no uso da matriz S-Box que é apresentada na Tabela 1.2, sem ter a preocupação de como ela foi obtida. Como se observa a S-Box é organizada de maneira a possuir 16 colunas e 16 linhas, onde o elemento de entrada (em hexadecimal) é usado e substituído pelo elemento equivalente a seu valor na tabela (a linha representada pelo valor mais significativo e a coluna definida pelo valor menos significativo). Portanto a tabela SBox faz a transformação de valores, esta transformação é simples usando a forma matricial, mas para facilitar mais o entendimento e cálculos futuros, considere-a como um vetor de 128 posições, Sendo assim o seu funcionamento e uso se da de maneira em que acessa-se ela na posição X e pega-se o elemento Y que esta armazenado nesta posição, evitando o cálculo de linha e coluna na matriz. Por exemplo: SBox [ 0x00 ] = 0x63 Sbox [ 0x01 ] = 0x7c Sbox [ 0x52 ] = 0x00 Isto ocorre para todos os valores pertencentes a [0x00, 0xFF], e cada valor possui um representante único. Portanto não há duplicidades nesta tabela (o que garante o funcionamento correto do algoritmo).

12 1.1 AES a 0b 0c 0d 0e 0f c 77 7b f2 6b 6f c b fe d7 ab ca 82 c9 7d fa f0 ad d4 a2 af 9c a4 72 c0 20 b7 fd f f7 cc 34 a5 e5 f1 71 d c7 23 c a e2 eb 27 b c 1a 1b 6e 5a a0 52 3b d6 b3 29 e3 2f d1 00 ed 20 fc b1 5b 6a cb be 39 4a 4c 58 cf 60 d0 ef aa fb 43 4d f9 02 7f 50 3c 9f a a3 40 8f 92 9d 38 f5 bc b6 da ff f3 d2 80 cd 0c 13 ec 5f c4 a7 7e 3d 64 5d f dc 22 2a ee b8 14 de 5e 0b db a0 e0 32 3a 0a c c2 d3 ac e4 79 b0 e7 c8 37 6d 8d d5 4e a9 6c 56 f4 ea 65 7a ae 08 c0 ba e 1c a6 b4 c6 e8 dd 74 1f 4b bd 8b 8a d0 70 3e b f6 0e b9 86 c1 1d 9e e0 e1 f d9 8e 94 9b 1e 87 e9 ce df f0 8c a1 89 0d bf e d 0f b0 54 bb 16 Tabela 1.2: S-Box Tabela InverseSBox É usada na função Inverse Substitute bytes, sendo que existem dois meios de se obter o mesmo resultado neste passo, um deles é calculando-se a InverseSBox e o outro é usando os valores já armazenados em memória (a tabela resultante será a mesma). Nesta descrição estará em foco apenas no uso da matriz InverseS-Box que é apresentada na Tabela 1.3, sem ter a preocupação de como ela foi obtida. Como se observa a InverseSBox é organizada de maneira a possuir 16 colunas e 16 linhas, onde o elemento de entrada (em hexadecimal) é usado e substituído pelo elemento equivalente a seu valor na tabela (a linha representada pelo valor mais significativo e a coluna definida pelo valor menos significativo). Portanto a tabela InverseSBox faz a transformação de valores, esta transformação é simples usando a forma matricial, mas para facilitar mais o entendimento e cálculos futuros, considere-a como um vetor de 128 posições, Sendo assim o seu funcionamento ocorre usando-se o parâmetro de entrada X como endereço na memória conseguindo assim o valor representado na Inverse-SBox e recebe-se o elemento Y que esta armazenado nesta posição, evitando o cálculo de linha e coluna na matriz. Por exemplo: InverseSBox [ 0x00 ] = 0x52 InverseSbox [ 0x01 ] = 0x09 InverseSbox [ 0x52 ] = 0x48 Isto ocorre para todos os valores pertencentes a [0x00, 0xFF], e cada valor possui um representante único. Portanto não há duplicidades nesta tabela (o que garante o

13 1.1 AES a 0b 0c 0d 0e 0f a d a5 38 bf 40 a3 9e 81 f3 d7 fb 10 7c e b 2f ff e c4 de e9 cb b a6 c2 23 3d ee 4c 95 0b 42 fa c3 4e e a d9 24 b2 76 5b a2 49 6d 8b d f8 f d4 a4 5c cc 5d 65 b c fd ed b9 da 5e a7 8d 9d d8 ab 00 8c bc d3 0a f7 e b8 b d0 2c 1e 8f ca 3f 0f 02 c1 af bd a 6b 80 3a f 67 dc ea 97 f2 cf ce f0 b4 e ac e7 ad e2 f9 37 e8 1c 75 df 6e a0 47 f1 1a 71 1d 29 c5 89 6f b7 62 0e aa 18 be 1b b0 fc 56 3e 4b c6 d a db c0 fe 78 cd 5a f4 c0 1f dd a c7 31 b ec 5f d f a9 19 b5 4a 0d 2d e5 7a 9f 93 c9 9c ef e0 a0 e0 3b 4d ae 2a f5 b0 c8 eb bb 3c f0 17 2b 04 7e ba 77 d6 26 e c 7d Tabela 1.3: Tabela Inverse S-Box funcionamento correto do algoritmo). Função Shift rows Esta função tem como entrada a matriz de 128 bits (4 linhas e 4 colunas, sendo cada elemento composto por 4 bytes (palavra do algoritmo)) e realizar a função shift-left (do tamanho de bytes, ou seja considerando que cada linha possui 4 elementos), sendo que a primeira linha é deslocada em 0 posições, a segunda linha em 1 posição, a terceira linha em 2 posições e a quarta linha em 3 posições. Exemplificando: S 0,0 S 0,1 S 0,2 S 0,3 S 0,0 S 0,1 S 0,2 S 0,3 S 1,0 S 1,1 S 1,2 S 1,3 S 1,1 S 1,2 S 1,3 S 1,0 S 2,0 S 2,1 S 2,2 S 2,3 S 2,2 S 2,3 S 2,0 S 2,1 S 3,0 S 3,1 S 3,2 S 3,3 S 3,3 S 3,0 S 3,1 S 3,2 Função Inverse Shift rows Esta função tem como entrada a matriz de 128 bits (4 linhas e 4 colunas, sendo cada elemento composto por 4 bytes (palavra do algoritmo)) e realizar a função shiftright (do tamanho de bytes, ou seja considerando que cada linha possui 4 elementos). Este processo que reverte o shift rows, realizando-se o shift-right de 0 posições na primeira linha,

14 1.1 AES 14 de 1 posição na segunda linha, de 2 posições na terceira linha e 3 posições na quarta linha. Exemplificando: S 0,0 S 0,1 S 0,2 S 0,3 S 0,0 S 0,1 S 0,2 S 0,3 S 1,0 S 1,1 S 1,2 S 1,3 S 1,3 S 1,0 S 1,1 S 1,2 S 2,0 S 2,1 S 2,2 S 2,3 S 2,2 S 2,3 S 2,0 S 2,1 S 3,0 S 3,1 S 3,2 S 3,3 S 3,1 S 3,2 S 3,3 S 3,0 Função Mix coluns Sua função assim como diz o nome é embaralhar as colunas desta matriz de informação, preparando-a assim para a próxima etapa. Este processo consiste em multiplicar cada coluna da matriz intermediária por um polinômio constante: p(x) = 03hx hx hx + 02h. Esta função também pode ser representada na forma de uma multiplicação matricial 1.4: S 0,c S 0,c S 1,c = * S 1,c S 2,c S 2,c S 3,c S 3,c Tabela 1.4: MixColuns na forma matricial Mas em nossos exemplos a fim de facilitar o entendimento estaremos usando a soma de valores armazenados em tabelas: Mul02 (Tabela 1.5) e Mul03 (Tabela 1.6), representando o valor multiplicado por 0x2 e 0x3 respectivamente. Portanto nossa função MixColuns realiza o seguinte cálculo por coluna da matriz informação: Dado [0x0] = Mul02[dado[0x0]] + Mul03[dado[0x1]] + dado[0x2] + dado[0x3] Dado [0x1] = dado[0x0] + Mul02[dado[0x1]] + Mul03[dado[0x2]] + dado[0x3] Dado [0x2] = dado[0x0] + dado[0x1] + Mul02[dado[0x2]] + Mul03[dado[0x3]] Dado [0x3] = Mul03[dado[0x0]] + dado[0x1] + dado[0x2] + Mul02[dado[0x3]] Dado [0x4] = Mul02[dado[0x4]] + Mul03[dado[0x5]] + dado[0x6] + dado[0x7] Dado [0x5] = dado[0x4] + Mul02[dado[0x5]] + Mul03[dado[0x6]] + dado[0x7] Dado [0x6] = dado[0x4] + dado[0x5] + Mul02[dado[0x6]] + Mul03[dado[0x7]] Dado [0x7] = Mul03[dado[0x4]] + dado[0x5] + dado[0x6] + Mul02[dado[0x7]]

15 1.1 AES a 0c 0e a 1c 1e a 2c 2e a 3c 3e a 4c 4e a 5c 5e a 6c 6e a 7c 7e a 8c 8e a 9c 9e a0 a2 a4 a6 a8 aa ac ae b0 b2 b4 b6 b8 ba bc be c0 c2 c4 c6 c8 ca cc ce d0 d2 d4 d6 d8 da dc de e0 e2 e4 e6 e8 ea ec ee f0 f2 f4 f6 f8 fa fc fe 1b 19 1f 1d b 09 0f 0d b 39 3f 3d b 29 2f 2d b 59 5f 5d b 49 4f 4d b 79 7f 7d b 69 6f 6d b 99 9f 9d b 89 8f 8d bb b9 bf bd b3 b1 b7 b5 ab a9 af ad a3 a1 a7 a5 db d9 df dd d3 d1 d7 d5 cb c9 cf cd c3 c1 c7 c5 fb f9 ff fd f3 f1 f7 f5 eb e9 ef ed e3 e1 e7 e5 Tabela 1.5: Tabela de valores Mul02 (multiplicados por 2) Dado [0x8] = Mul02[dado[0x8]] + Mul03[dado[0x9]] + dado[0xa] + dado[0xb] Dado [0x9] = dado[0x8] + Mul02[dado[0x9]] + Mul03[dado[0xA]] + dado[0xb] Dado [0xA] = dado[0x8] + dado[0x9] + Mul02[dado[0xA]] + Mul03[dado[0xB]] Dado [0xB] = Mul03[dado[0x8]] + dado[0x9] + dado[0xa] + Mul02[dado[0xB]] Dado [0xC] = Mul02[dado[0xC]] + Mul03[dado[0xD]] + dado[0xe] + dado[0xf] Dado [0xD] = dado[0xc] + Mul02[dado[0xD]] + Mul03[dado[0xE]] + dado[0xf] Dado [0xE] = dado[0xc] + dado[0xd] + Mul02[dado[0xE]] + Mul03[dado[0xF]] Dado [0xF] = Mul03[dado[0xC]] + dado[0xd] + dado[0xe] + Mul02[dado[0xF]] dado = Dado Função Inverse Mix coluns Sua função assim como diz o nome, é desembaralhar as colunas da matriz de informação que já foram embaralhadas, preparando-a assim para a próxima etapa. Este processo consiste em multiplicar cada coluna da matriz intermediária por um polinômio constante, mas esta função também pode ser representada na forma de uma multiplicação matricial assim como esta na Tabela 1.7. Mas no exemplo a fim de facilitar o entendimento estará sendo usado a soma de valores armazenados em tabelas: Mul09 (Tabela 1.8), Mul11 (Tabela 1.9), Mul13

16 1.1 AES c 0f 0a b 1e 1d c 3f 3a b 2e 2d c 6f 6a b 7e 7d c 5f 5a b 4e 4d c0 c3 c6 c5 cc cf ca c9 d8 db de dd d4 d7 d2 d1 f0 f3 f6 f5 fc ff fa f9 e8 eb ee ed e4 e7 e2 e1 a0 a3 a6 a5 ac af aa a9 b8 bb be bd b4 b7 b2 b c 9f 9a b 8e 8d b 98 9d 9e f 8c 89 8a ab a8 ad ae a7 a4 a1 a2 b3 b0 b5 b6 bf bc b9 ba fb f8 fd fe f7 f4 f1 f2 e3 e0 e5 e6 ef ec e9 ea cb c8 cd ce c7 c4 c1 c2 d3 d0 d5 d6 df dc d9 da 5b 58 5d 5e f 4c 49 4a 6b 68 6d 6e f 7c 79 7a 3b 38 3d 3e f 2c 29 2a 0b 08 0d 0e f 1c 19 1a Tabela 1.6: Tabela de valores Mul03 (multiplicados por 3) S ( 0,c) S ( 0,c) S ( 1,c) = * S ( 1,c) S ( 2,c) S ( 2,c) S ( 3,c) S ( 3,c) Tabela 1.7: Inverse Mix Coluns na forma matricial (Tabela 1.10) e Mul14 (Tabela 1.11), representando o valor multiplicado por 0x9, 0xB, 0xD, 0xE respectivamente. Portanto a função InverseMixColuns realiza o seguinte cálculo por coluna da matriz informação: Dado [0x0] = Mul14[dado[0x0]] + Mul11[dado[0x1]] + Mul13[dado[0x2]] + Mul09[dado[0x3]] Dado [0x1] = Mul09[dado[0x0]] + Mul14[dado[0x1]] + Mul11[dado[0x2]] + Mul13[dado[0x3]] Dado [0x2] = Mul13[dado[0x0]] + Mul09[dado[0x1]] + Mul14[dado[0x2]] + Mul11[dado[0x3]] Dado [0x3] = Mul11[dado[0x0]] + Mul13[dado[0x1]] + Mul09[dado[0x2]] + Mul14[dado[0x3]] Dado [0x4] = Mul14[dado[0x4]] + Mul11[dado[0x5]] + Mul13[dado[0x6]] + Mul09[dado[0x7]] Dado [0x5] = Mul09[dado[0x4]] + Mul14[dado[0x5]]

17 1.1 AES 17 + Mul11[dado[0x6]] + Mul13[dado[0x7]] Dado [0x6] = Mul13[dado[0x4]] + Mul09[dado[0x5]] + Mul14[dado[0x6]] + Mul11[dado[0x7]] Dado [0x7] = Mul11[dado[0x4]] + Mul13[dado[0x5]] + Mul09[dado[0x6]] + Mul14[dado[0x7]] Dado [0x8] = Mul14[dado[0x8]] + Mul11[dado[0x9]] + Mul13[dado[0xA]] + Mul09[dado[0xB]] Dado [0x9] = Mul09[dado[0x8]] + Mul14[dado[0x9]] + Mul11[dado[0xA]] + Mul13[dado[0xB]] Dado [0xA] = Mul13[dado[0x8]] + Mul09[dado[0x9]] + Mul14[dado[0xA]] + Mul11[dado[0xB]] Dado [0xB] = Mul11[dado[0x8]] + Mul13[dado[0x9]] + Mul09[dado[0xA]] + Mul14[dado[0xB]] Dado [0xC] = Mul14[dado[0xC]] + Mul11[dado[0xD]] + Mul13[dado[0xE]] + Mul09[dado[0xF]] Dado [0xD] = Mul09[dado[0xC]] + Mul14[dado[0xD]] + Mul11[dado[0xE]] + Mul13[dado[0xF]] Dado [0xE] = Mul13[dado[0xC]] + Mul09[dado[0xD]] + Mul14[dado[0xE]] + Mul11[dado[0xF]] Dado [0xF] = Mul11[dado[0xC]] + Mul13[dado[0xD]] + Mul09[dado[0xE]] + Mul14[dado[0xF]] dado = Dado Expansão da Chave Este processo recebe como entrada uma chave de 128 bits que será usada para expandir e criar outras 10 novas chaves (totalizando 11 chaves), as quais serão usadas uma a uma no round onde lhe cabe. Na criptografia são usadas as chaves de forma crescente iniciando-se na chave 0 e terminando-se na chave 10, mas no processo descriptografia são usadas de forma decrescente iniciando-se pela chave 10 e terminando com o uso da chave 0. Para a expansão da chave são usados alguns valores pré-definidos, um em cada round, no algoritmo definidos como o algoritmo Rc = [ 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36 ] A expansão da chave consiste em produzir 11 chaves, as quais são conside-

18 1.1 AES b 24 2d 36 3f a 53 6c 65 7e b b4 bd a6 af d8 d1 ca c3 fc f5 ee e7 3b f 16 0d a e 45 4c ab a2 b9 b0 8f 86 9d 94 e3 ea f1 f8 c7 ce d5 dc 76 7f 64 6d 52 5b e 37 2c 25 1a e6 ef f4 fd c2 cb d0 d9 ae a7 bc b5 8a d 44 5f b c 17 1e a dd d4 cf c6 f9 f0 eb e2 95 9c 87 8e b1 b8 a3 aa ec e5 fe f7 c8 c1 da d3 a4 ad b6 bf b 7c 75 6e a d 26 2f b d7 de c5 cc f3 fa e1 e8 9f 96 8d 84 bb b2 a9 a0 47 4e 55 5c 63 6a f 06 1d 14 2b a be b7 ac a5 d2 db c0 c9 f6 ff e4 ed 0a e 27 3c b f 74 7d a1 a8 b3 ba 85 8c 97 9e e9 e0 fb f2 cd c4 df d a 15 1c 07 0e b 62 5d 54 4f 46 Tabela 1.8: Tabela de valores Mul09 (multiplicados por 9) 00 0b 16 1d 2c 27 3a e f b0 bb a6 ad 9c 97 8a 81 e8 e3 fe f5 c4 cf d2 d9 7b 70 6d c 41 4a e 0f cb c0 dd d6 e7 ec f1 fa e bf b4 a9 a2 f6 fd e0 eb da d1 cc c7 ae a5 b8 b f 46 4d 50 5b 6a 61 7c 77 1e f 8d 86 9b 90 a1 aa b7 bc d5 de c3 c8 f9 f2 ef e4 3d 36 2b a 07 0c 65 6e f 54 f7 fc e1 ea db d0 cd c6 af a4 b9 b e 47 4c 51 5a 6b 60 7d 76 1f e 8c 87 9a 91 a0 ab b6 bd d4 df c2 c9 f8 f3 ee e5 3c 37 2a b 06 0d 64 6f e a 17 1c 2d 26 3b f e b1 ba a7 ac 9d 96 8b 80 e9 e2 ff f4 c5 ce d3 d8 7a 71 6c d 40 4b f 0e ca c1 dc d7 e6 ed f0 fb f be b5 a8 a3 Tabela 1.9: Tabela de valores Mul11 (multiplicados por 0xB)

19 1.1 AES d 1a e f 5c b d0 dd ca c7 e4 e9 fe f3 b8 b5 a2 af 8c b bb b6 a1 ac 8f d3 de c9 c4 e7 ea fd f0 6b c 5f e a 2d 20 6d a e f c 2b 26 bd b0 a7 aa e d5 d8 cf c2 e1 ec fb f6 d6 db cc c1 e2 ef f8 f5 be b3 a4 a9 8a d 06 0b 1c f e a d da d7 c0 cd ee e3 f4 f9 b2 bf a8 a5 86 8b 9c 91 0a d 3e f b 4c c 7b f e 3d a b1 bc ab a f 92 d9 d4 c3 ce ed e0 f7 fa b7 ba ad a0 83 8e df d2 c5 c8 eb e6 f1 fc 67 6a 7d e f b c 0c b f e d 4a 47 dc d1 c6 cb e8 e5 f2 ff b4 b9 ae a3 80 8d 9a 97 Tabela 1.10: Tabela de valores Mul13 (multiplicados por 0xC) 00 0e 1c a 70 7e 6c a e0 ee fc f2 d8 d6 c4 ca 90 9e 8c 82 a8 a6 b4 ba db d5 c7 c9 e3 ed ff f1 ab a5 b7 b9 93 9d 8f 81 3b d 1f 11 4b d 6f 61 ad a3 b1 bf 95 9b dd d3 c1 cf e5 eb f9 f7 4d f 75 7b d f 05 0b a 64 4e c a 14 3e c a 84 ae a0 b2 bc e6 e8 fa f4 de d0 c2 cc 41 4f 5d b 31 3f 2d b a1 af bd b b d1 df cd c3 e9 e7 f5 fb 9a a2 ac be b0 ea e4 f6 f8 d2 dc ce c0 7a c 5e 50 0a c 2e 20 ec e2 f0 fe d4 da c8 c6 9c e a4 aa b8 b6 0c e 34 3a c e 44 4a b 25 0f d b 55 7f d d7 d9 cb c5 ef e1 f3 fd a7 a9 bb b5 9f d Tabela 1.11: Tabela de valores Mul14 (multiplicados por 0xD)

20 1.1 AES 20 radas pelo algoritmo como 44 palavras (4 palavras por chave, sendo que cada palavra tem 4 letras de 16 bits, com valores de 0x00 a 0xFF), no caso desta exemplificação pertencentes a um vetor denominado de Word. A primeira chave consiste nos valores que foram fornecidos na entrada como Key. Todas as demais consistem em uma conta ultilizando as chaves anteriores. Para melhor entendimento observe o pseudo código a seguir: Chave 0: Chave inicial que foi fornecida, considerando o algoritmo, tem-se que: Word[0] = [ Key[0x0], Key[0x1], Key[0x2], Key[0x3] ] Word[1] = [ Key[0x4], Key[0x5], Key[0x6], Key[0x7] ] Word[2] = [ Key[0x8], Key[0x9], Key[0xA], Key[0xB] ] Word[3] = [ Key[0xC], Key[0xD], Key[0xE], Key[0xF] ] Chave 1-10: Considerando a K-ésima palavra em Word, tem-se que: Se K é divisível por 4: Word[k][0] = (SubBites[ Word[k-1][1] ] ) XOR ( Rc[chao((k/4)-1)] ) XOR ( Word[k- 4][0] ) Word[k][1] = (SubBites[ Word[k-1][2] ] ) XOR ( Word[k-4][1] ) Word[k][2] = (SubBites[ Word[k-1][3] ] ) XOR ( Word[k-4][2] ) Word[k][3] = (SubBites[ Word[k-1][0] ] ) XOR ( Word[k-4][3] ) Caso contrario: Word[k][0] = (Word[k-1][0] ) XOR ( Word[k-4][0] ) Word[k][1] = (Word[k-1][1] ) XOR ( Word[k-4][1] ) Word[k][2] = (Word[k-1][2] ) XOR ( Word[k-4][2] ) Word[k][3] = (Word[k-1][3] ) XOR ( Word[k-4][3] ) Feitas estas considerações também é importante definir os valores iniciais das variáveis em nosso exemplo. Portanto considerando inicialmente: Key = [ 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF] gera: Sendo assim e considerando o valor de Key dado como exemplo, o processo

21 1.1 AES 21 Chave 0: 0x00 0x11 0x22 0x33 0x44 0x55 0x66 0x77 0x88 0x99 0xAA 0xBB 0xCC 0xDD 0xEE 0xFF E o processo de obtenção e geração de palavras: Word[0][0] = 0x00 Word[0][2] = 0x22 Word[1][0] = 0x44 Word[1][2] = 0x66 Word[2][0] = 0x88 Word[2][2] = 0xAA Word[3][0] = 0xCC Word[3][2] = 0xEE Word[0][1] = 0x11 Word[0][3] = 0x33 Word[1][1] = 0x55 Word[1][3] = 0x77 Word[2][1] = 0x99 Word[2][3] = 0xBB Word[3][1] = 0xDD Word[3][3] = 0xFF Chave 1: 0xC0 0x39 0x34 0x78 0x84 0x6C 0x52 0x0F 0x0C 0xF5 0xF8 0xB4 0xC0 0x28 0x16 0x4B Word[4][0] = (SubBites[ Word[3][1] ]) XOR ( Rc[0] ) XOR (Word[0][0]) = (SubBites[ 0xDD ] ) XOR ( Rc[0] ) XOR ( Word[0][0] ) = 0xC1 XOR 0x01 XOR 0x00 0xC1 = e 0x01 = , realizando bit a bit tem-se: 1 XOR 0 = 1 1 XOR 0 = 1 0 XOR 0 = 0 1 XOR 0 = 1 0 XOR 0 = 0 0 XOR 0 = 0 0 XOR 0 = 0 1 XOR 1 = 0 O que resulta em 0xC0. E realizando o XOR com 0x00 que é XOR 0 = 1

22 1.1 AES 22 1 XOR 0 = 1 0 XOR 0 = 0 1 XOR 0 = 1 0 XOR 0 = 0 0 XOR 0 = 0 0 XOR 0 = 0 0 XOR 0 = 0 O que resulta em = 0xC0 Word[4][1] = (SubBites[ Word[3][2] ] ) XOR ( Word[ 0 ][1] ) = (SubBites[ 0xEE ] ) XOR ( Word[ 0 ][1] ) = 0x28 XOR 0x11 0x28 = e 0x11 = , realizando bit a bit tem-se: 0 XOR 0 = 0 0 XOR 0 = 0 1 XOR 0 = 1 0 XOR 1 = 1 1 XOR 0 = 1 0 XOR 0 = 0 0 XOR 0 = 0 0 XOR 1 = 1 O que resulta em = 0x39. Word[4][2] = (SubBites[ Word[3][3] ] ) XOR ( Word[ 0 ][2] ) (SubBites[ 0xFF ] ) XOR ( Word[ 0 ][2] ) = 0x16 XOR 0x22 0x16 = e 0x22 = , realizando bit a bit tem-se: 0 XOR 0 = 0 0 XOR 0 = 0 0 XOR 1 = 1 1 XOR 0 = 1 0 XOR 0 = 0 1 XOR 0 = 1 1 XOR 1 = 0 0 XOR 0 = 0 O que resulta em = 0x34. Word[4][3] = (SubBites[ Word[3][0] ] ) XOR ( Word[ 0 ][3] ) (SubBites[ 0xCC ] ) XOR ( Word[ 0 ][3] ) = 0x4B XOR 0x33 0x4B = e 0x33 = , realizando bit a bit tem-se:

23 1.1 AES 23 0 XOR 0 = 0 1 XOR 0 = 1 0 XOR 1 = 1 0 XOR 1 = 1 1 XOR 0 = 1 0 XOR 0 = 0 1 XOR 1 = 0 1 XOR 1 = 0 O que resulta em = 0x78. Word[5][0] = (Word[4][0] ) XOR ( Word[1][0] ) = 0xC0 XOR 0x44 0xC0 = e 0x44 = , realizando bit a bit tem-se: 1 XOR 0 = 1 1 XOR 1 = 0 0 XOR 0 = 0 0 XOR 0 = 0 0 XOR 0 = 0 0 XOR 1 = 1 0 XOR 0 = 0 0 XOR 0 = 0 O que resulta em = 0x84. Word[5][1] = (Word[4][1] ) XOR ( Word[1][1] ) = 0x39 XOR 0x55 0x39 = e 0x55 = , realizando bit a bit tem-se: 0 XOR 0 = 0 0 XOR 1 = 1 1 XOR 0 = 1 1 XOR 1 = 0 1 XOR 0 = 1 0 XOR 1 = 1 0 XOR 0 = 0 1 XOR 1 = 0 O que resulta em = 0x6C. Word[5][2] = (Word[4][2] ) XOR ( Word[1][2] ) = 0x34 XOR 0x66 0x34 = e 0x66 = , realizando bit a bit tem-se: 0 XOR 0 = 0

24 1.1 AES 24 0 XOR 1 = 1 1 XOR 1 = 0 1 XOR 0 = 1 0 XOR 0 = 0 1 XOR 1 = 0 0 XOR 1 = 1 0 XOR 0 = 0 O que resulta em = 0x52. Word[5][3] = (Word[4][3] ) XOR ( Word[1][3] ) = 0x78 XOR 0x77 0x78 = e 0x77 = , realizando bit a bit tem-se: 0 XOR 0 = 0 1 XOR 1 = 0 1 XOR 1 = 0 1 XOR 1 = 0 1 XOR 0 = 1 0 XOR 1 = 1 0 XOR 1 = 1 0 XOR 1 = 1 O que resulta em = 0x0F. Word[6][0] = (Word[5][0] ) XOR ( Word[2][0] ) = 0x84 XOR 0x88 0x84 = e 0x88 = , realizando bit a bit tem-se: 1 XOR 1 = 0 0 XOR 0 = 0 0 XOR 0 = 0 0 XOR 0 = 0 0 XOR 1 = 1 1 XOR 0 = 1 0 XOR 0 = 0 0 XOR 0 = 0 O que resulta em = 0x0C Word[6][1] = (Word[5][1] ) XOR ( Word[2][1] ) = 0x6C XOR 0x99 0x6C = e 0x99 = , realizando bit a bit tem-se: 0 XOR 1 = 1 1 XOR 0 = 1

25 1.1 AES 25 1 XOR 0 = 1 0 XOR 1 = 1 1 XOR 1 = 0 1 XOR 0 = 1 0 XOR 0 = 0 0 XOR 1 = 1 O que resulta em = 0xF5 Word[6][2] = (Word[5][2] ) XOR ( Word[2][2] ) = 0x52 XOR 0xAA 0x52 = e 0xAA = , realizando bit a bit tem-se: 0 XOR 1 = 1 1 XOR 0 = 1 0 XOR 1 = 1 1 XOR 0 = 1 0 XOR 1 = 1 0 XOR 0 = 0 1 XOR 1 = 0 0 XOR 0 = 0 O que resulta em = 0xF8 Word[6][3] = (Word[5][3] ) XOR ( Word[2][3] ) = 0x0F XOR 0xBB 0x0F = e 0xBB = , realizando bit a bit tem-se: 0 XOR 1 = 1 0 XOR 0 = 0 0 XOR 1 = 1 0 XOR 1 = 1 1 XOR 1 = 0 1 XOR 0 = 1 1 XOR 1 = 0 1 XOR 1 = 0 O que resulta em = 0xB4 Word[7][0] = (Word[6][0] ) XOR ( Word[3][0] ) = 0x0C XOR 0xCC 0x = e 0x = , realizando bit a bit tem-se: 0 XOR 1 = 1 0 XOR 1 = 1 0 XOR 0 = 0

26 1.1 AES 26 0 XOR 0 = 0 1 XOR 1 = 0 1 XOR 1 = 0 0 XOR 0 = 0 0 XOR 0 = 0 O que resulta em = 0xC0 Word[7][1] = (Word[6][1] ) XOR ( Word[3][1] ) = 0xF5 XOR 0xDD 0xF5 = e 0x = , realizando bit a bit tem-se: 1 XOR 1 = 0 1 XOR 1 = 0 1 XOR 0 = 1 1 XOR 1 = 0 0 XOR 1 = 1 1 XOR 1 = 0 0 XOR 0 = 0 1 XOR 1 = 0 O que resulta em = 0x28 Word[7][2] = (Word[6][2] ) XOR ( Word[3][2] ) = 0xF8 XOR 0xEE 0xF8 = e 0xEE = , realizando bit a bit tem-se: 1 XOR 1 = 0 1 XOR 1 = 0 1 XOR 1 = 0 1 XOR 0 = 1 1 XOR 1 = 0 0 XOR 1 = 1 0 XOR 1 = 1 0 XOR 0 = 0 O que resulta em = 0x16 Word[7][3] = (Word[6][3] ) XOR ( Word[3][3] ) = 0xB4 XOR 0xFF 0xB4 = e 0xFF = , realizando bit a bit tem-se: 1 XOR 1 = 0 0 XOR 1 = 1 1 XOR 1 = 0 1 XOR 1 = 0

27 1.1 AES 27 0 XOR 1 = 1 1 XOR 1 = 0 0 XOR 1 = 1 0 XOR 1 = 1 O que resulta em = 0x4B Continuando este procedimento para as demais palavras de Word ten-se: Word[8][0] = SubBites[ Word[7][1] ] XOR Rc[1] XOR Word[4][0] = 0x34 XOR 0x2 XOR 0xc0 = 0xf6 Word[8][1] = SubBites[ Word[7][2] ] XOR Word[4][1] = 0x47 XOR 0x39 = 0x7e Word[8][2] = SubBites[ Word[7][3] ] XOR Word[4][2] = 0xb3 XOR 0x34 = 0x87 Word[8][3] = SubBites[ Word[7][0] ] XOR Word[4][3] = 0xba XOR 0x78 = 0xc2 Word[9][0] = Word[8][0] XOR Word[5][0] = 0xf6 XOR 0x84 = 0x72 Word[9][1] = Word[8][1] XOR Word[5][1] = 0x7e XOR 0x6c = 0x12 Word[9][2] = Word[8][2] XOR Word[5][2] = 0x87 XOR 0x52 = 0xd5 Word[9][3] = Word[8][3] XOR Word[5][3] = 0xc2 XOR 0xf = 0xcd Word[10][0] = Word[9][0] XOR Word[6][0] = 0x72 XOR 0xc = 0x7e Word[10][1] = Word[9][1] XOR Word[6][1] = 0x12 XOR 0xf5 = 0xe7 Word[10][2] = Word[9][2] XOR Word[6][2] = 0xd5 XOR 0xf8 = 0x2d Word[10][3] = Word[9][3] XOR Word[6][3] = 0xcd XOR 0xb4 = 0x79 Word[11][0] = Word[10][0] XOR Word[7][0] = 0x7e XOR 0xc0 = 0xbe Word[11][1] = Word[10][1] XOR Word[7][1] = 0xe7 XOR 0x28 = 0xcf Word[11][2] = Word[10][2] XOR Word[7][2] = 0x2d XOR 0x16 = 0x3b Word[11][3] = Word[10][3] XOR Word[7][3] = 0x79 XOR 0x4b = 0x32 Word[12][0] = SubBites[ Word[11][1] ] XOR Rc[2] XOR Word[8][0] = 0x8a XOR 0x4 XOR 0xf6 = 0x78 Word[12][1] = SubBites[ Word[11][2] ] XOR Word[8][1] = 0xe2 XOR 0x7e = 0x9c Word[12][2] = SubBites[ Word[11][3] ] XOR Word[8][2] = 0x23 XOR 0x87 = 0xa4

28 1.1 AES 28 Word[12][3] = SubBites[ Word[11][0] ] XOR Word[8][3] = 0xae XOR 0xc2 = 0x6c Word[13][0] = Word[12][0] XOR Word[9][0] = 0x78 XOR 0x72 = 0xa Word[13][1] = Word[12][1] XOR Word[9][1] = 0x9c XOR 0x12 = 0x8e Word[13][2] = Word[12][2] XOR Word[9][2] = 0xa4 XOR 0xd5 = 0x71 Word[13][3] = Word[12][3] XOR Word[9][3] = 0x6c XOR 0xcd = 0xa1 Word[14][0] = Word[13][0] XOR Word[10][0] = 0xa XOR 0x7e = 0x74 Word[14][1] = Word[13][1] XOR Word[10][1] = 0x8e XOR 0xe7 = 0x69 Word[14][2] = Word[13][2] XOR Word[10][2] = 0x71 XOR 0x2d = 0x5c Word[14][3] = Word[13][3] XOR Word[10][3] = 0xa1 XOR 0x79 = 0xd8 Word[15][0] = Word[14][0] XOR Word[11][0] = 0x74 XOR 0xbe = 0xca Word[15][1] = Word[14][1] XOR Word[11][1] = 0x69 XOR 0xcf = 0xa6 Word[15][2] = Word[14][2] XOR Word[11][2] = 0x5c XOR 0x3b = 0x67 Word[15][3] = Word[14][3] XOR Word[11][3] = 0xd8 XOR 0x32 = 0xea Word[16][0] = SubBites[ Word[15][1] ] XOR Rc[3] XOR Word[12][0] = 0x24 XOR 0x8 XOR 0x78 = 0x54 Word[16][1] = SubBites[ Word[15][2] ] XOR Word[12][1] = 0x85 XOR 0x9c = 0x19 Word[16][2] = SubBites[ Word[15][3] ] XOR Word[12][2] = 0x87 XOR 0xa4 = 0x23 Word[16][3] = SubBites[ Word[15][0] ] XOR Word[12][3] = 0x74 XOR 0x6c = 0x18 Word[17][0] = Word[16][0] XOR Word[13][0] = 0x54 XOR 0xa = 0x5e Word[17][1] = Word[16][1] XOR Word[13][1] = 0x19 XOR 0x8e = 0x97 Word[17][2] = Word[16][2] XOR Word[13][2] = 0x23 XOR 0x71 = 0x52 Word[17][3] = Word[16][3] XOR Word[13][3] = 0x18 XOR 0xa1 = 0xb9 Word[18][0] = Word[17][0] XOR Word[14][0] = 0x5e XOR 0x74 = 0x2a Word[18][1] = Word[17][1] XOR Word[14][1] = 0x97 XOR 0x69 = 0xfe Word[18][2] = Word[17][2] XOR Word[14][2] = 0x52 XOR 0x5c = 0xe Word[18][3] = Word[17][3] XOR Word[14][3] = 0xb9 XOR 0xd8 = 0x61 Word[19][0] = Word[18][0] XOR Word[15][0] = 0x2a XOR 0xca = 0xe0 Word[19][1] = Word[18][1] XOR Word[15][1] = 0xfe XOR 0xa6 = 0x58