FABIANO REESE RIGHETTI
O IMPACTO DO USO DA CRIPTOGRAFIA NO THROUGHPUT DE
REDES LOCAIS: UM ESTUDO DE CASO USANDO O ALGORITMO
TRIPLE-DES
Monografia apresentada para obtenção
do título de Bacharel em Ciência da
Computação do Curso de Ciência da
Computação da Faculdade de Ciências
Aplicadas de Cascavel - FACIAP.
Orientador: Prof. Fabio Alexandre Spanhol, MSc.
CASCAVEL
2004
TERMO DE APROVAÇÃO
FABIANO REESE RIGHETTI
O IMPACTO DO USO DA CRIPTOGRAFIA NO THROUGHPUT DE REDES LOCAIS: UM ESTUDO
DE CASO USANDO O ALGORITMO TRIPLE-DES
Monografia aprovada como requisito parcial para obtenção do grau de Bacharel em
Ciência da Computação da Faculdade de Ciências Aplicadas de Cascavel – FACIAP,
pela Comissão formada pelos professores:
Orientador: Prof. Fabio Alexandre Spanhol, MSc.
Ciência da Computação, UNIPAN
Prof.ª Sirlei Lourdes Bach, MSc.
Ciência da Computação, UNIPAN
Prof. Ivonei Freitas da Silva, MSc.
Informática, UNIOESTE
Cascavel, 17 de dezembro de 2004.
ii
“Software Livre, socialmente justo, economicamente
viável e tecnologicamente sustentável”
(Software Livre Brasil)
iii
SUMÁRIO
1 INTRODUÇÃO....................................................................................................................1
1.1 OBJETIVOS ........................................................................................................................ 1
1.2 MOTIVAÇÃO ..................................................................................................................... 2
2 CRIPTOGRAFIA ................................................................................................................ 3
2.1 HISTÓRIA........................................................................................................................... 3
2.1.1 Cifras por substituição ...................................................................................................... 4
2.1.2 Cifras por permutação ....................................................................................................... 5
2.2 TIPOS DE CHAVES ...........................................................................................................5
2.2.1 Algoritmos Simétricos ...................................................................................................... 6
2.2.2 Algoritmos Assimétricos................................................................................................... 8
3 ALGORITMO DES........................................................................................................... 11
3.1 DESCRIÇÃO..................................................................................................................... 12
3.2 ESTRUTURA DE FUNCIONAMENTO..........................................................................12
3.2.1 Obter 16 sub-chaves de 48 bits cada ............................................................................... 12
3.2.2 Obter blocos codificados de cada 64 bits da mensagem .................................................14
3.2.3 Decifração ....................................................................................................................... 19
3.2.4 Triple-DES ...................................................................................................................... 19
4 IMPLEMENTAÇÃO.........................................................................................................22
4.1 AMBIENTE DE SIMULAÇÃO........................................................................................ 22
4.2 SISTEMA GERADOR DE DATAGRAMAS CIFRADOS..............................................23
4.3 TESTES REALIZADOS ................................................................................................... 29
4.4 RESULTADOS ................................................................................................................. 31
5 CONCLUSÃO.................................................................................................................... 33
5.1 TRABALHOS FUTUROS ................................................................................................33
REFERÊNCIAS ..................................................................................................................... 34
APÊNDICE 1 .......................................................................................................................... 36
iv
LISTA DE ACRÔNIMOS
DED – Decrypt-Encrypt-Decrypt
DES – Data Encryption Standard
EDE – Encrypt-Decrypt-Encrypt
IP
– Internet Protocol
TCP – Transmission Control Protocol
v
LISTA DE ILUSTRAÇÕES
FIGURA 1:
FUNCIONAMENTO DE ALGORITMOS DE CHAVES SIMÉTRICAS ................................. 7
FIGURA 2:
FUNCIONAMENTO DE ALGORITMOS DE CHAVES ASSIMÉTRICAS ............................ 9
FIGURA 3:
CICLO DES DE OBTENÇÃO DE 16 SUB-CHAVES DE 48 BITS........................................ 14
FIGURA 4:
CICLO DES DE CODIFICAÇÃO DE BLOCOS DE MENSAGENS...................................... 18
FIGURA 5:
FUNCIONAMENTO DO TRIPLE-DES COM DUAS CHAVES DE 56 BITS....................... 20
FIGURA 6:
FUNCIONAMENTO DO TRIPLE-DES COM TRÊS CHAVES DE 56 BITS ........................ 21
FIGURA 7:
AMBIENTE DE SIMULAÇÃO................................................................................................ 23
FIGURA 8:
ESTRUTURA DO CABEÇALHO IP ....................................................................................... 23
FIGURA 9:
ESTRUTURA DO CABEÇALHO TCP ................................................................................... 26
FIGURA 10:
GRÁFICO CONFRONTANDO TOTAL DE DADOS RECEBIDOS...................................... 32
FIGURA 11:
GRÁFICO CONFRONTANDO DADOS RECEBIDOS POR SEGUNDO ............................. 32
vi
LISTA DE TABELAS
TABELA 1:
PERMUTAÇÃO PC-1 .............................................................................................................. 13
TABELA 2:
NÚMERO DE ITERAÇÕES DO DESLOCAMENTO A ESQUERDA CIRCULAR ............. 13
TABELA 3:
PERMUTAÇÃO PC-2 .............................................................................................................. 13
TABELA 4:
PERMUTAÇÃO IP ................................................................................................................... 14
TABELA 5:
EXPANSÃO E .......................................................................................................................... 15
TABELA 6:
S-BOX S1................................................................................................................................... 15
TABELA 7:
S-BOX S2................................................................................................................................... 15
TABELA 8:
S-BOX S3................................................................................................................................... 16
TABELA 9:
S-BOX S4................................................................................................................................... 16
TABELA 10:
S-BOX S5 .................................................................................................................................. 16
TABELA 11:
S-BOX S6 .................................................................................................................................. 16
TABELA 12:
S-BOX S7 .................................................................................................................................. 16
TABELA 13:
S-BOX S8 .................................................................................................................................. 16
TABELA 14:
PERMUTAÇÃO P .................................................................................................................... 16
TABELA 15:
PERMUTAÇÃO IP-1................................................................................................................. 17
vii
LISTA DE QUADROS
QUADRO 1:
ROTINA QUE DEFINE O CABEÇALHO IP.......................................................................... 24
QUADRO 2:
ROTINA QUE DEFINE O CABEÇALHO TCP ...................................................................... 26
QUADRO 3:
ROTINA QUE DEFINE OS DATAGRAMA........................................................................... 28
QUADRO 4:
OPÇÕES DISPONÍVEIS PARA O USUÁRIO........................................................................ 28
QUADRO 5:
ROTINA UTILIZADA PARA CRIPTOGRAFAR .................................................................. 29
QUADRO 6:
PARÂMETROS USADOS PARA GERAR DATAGRAMAS EM TEXTO PLANO............. 29
QUADRO 7:
DATAGRAMA CAPTURADO PELO TCPDUMP EM TEXTO PLANO.............................. 30
QUADRO 8:
PARÂMETROS USADOS PARA GERAR DATAGRAMAS CRIPTOGRAFADOS............ 30
QUADRO 9:
DATAGRAMA CAPTURADO PELO TCPDUMP JÁ CRIPTOGRAFADO ......................... 30
QUADRO 10:
VAZÃO DE REDE ALCANÇADA POR DATAGRAMAS EM TEXTO PLANO ................ 31
QUADRO 11:
VAZÃO DE REDE ALCANÇADA POR DATAGRAMAS CRIPTOGRAFADOS ............... 31
viii
RESUMO
Este trabalho realiza uma análise comparativa entre o envio de dados não
criptografados e dados criptografados em redes locais com o intuito de medir o
impacto causado no throughput. O algoritmo de criptografia simétrica escolhido para
esta análise foi o Triple-DES por se tratar de um algoritmo seguro, simples,
amplamente utilizado e relativamente rápido.
Foi adotado um ambiente de simulação utilizando-se de dois microcomputadores
interligados através de uma rede 10/100 BaseT, um sistema para geração de
datagramas em texto puro e criptografados desenvolvido na linguagem de
programação C, ferramenta para análise do tráfego na rede (TCPDUMP) e o sistema
operacional GNU/Linux.
Os testes realizados buscaram simular um ambiente real sendo a rede isolada e todas as
características dos computadores mantidas durante a geração dos dois tipos de
datagramas. Com base nos resultados alcançados pode-se notar uma elevada diferença
no volume de pacotes enviados nas duas formas, cerca de 60%. Ficando claro que por
mais que o algoritmo seja simples e relativamente rápido o throughput é afetado,
sendo de elevada importância fazer um estudo de qual algoritmo adotar em um projeto
e analisar formas de aumentar a segurança sem degradar o desempenho do mesmo.
ix
1
1
INTRODUÇÃO
A crescente utilização de computadores interligados em rede para
transmissão ou armazenamento de informações torna o fator de segurança essencial,
precisando que em tais informações sejam garantidas sua integridade, origem e
autenticidade.
Sendo que todas as mensagens que trafegam na rede de computadores estão
sujeitas a algum tipo de ataque ou violação, a solução é o emprego de técnicas que
enfatizem manter o conteúdo dessas mensagens desconhecidas para quem não tiver
autorização.
Entre as várias técnicas de escrita secreta conhecida, a mais adequada à
aplicação em computadores são as cifras. Uma cifra implica em um método, ou
sistema, de escrita que é ilimitado no seu uso e pelo qual deve ser possível transformar
qualquer mensagem, sem consideração sobre linguagem e tamanho, para uma forma
não compreensível, chamada criptograma (PICONI, 2004). O processo de transformar
o criptograma na mensagem em claro original se chama decifragem. Tanto para
cifragem quanto para decifragem é necessário um segundo parâmetro: a chave. A
ciência que estuda como quebrar um sistema criptográfico é chamado de criptoanálise,
a união das duas ciências forma um campo chamado criptografia (MORAES, 2004).
1.1 OBJETIVOS
Avaliar o impacto que o emprego do algoritmo de criptografia simétrica
Triple-DES causa no throughput de uma rede local, confrontando os dados estatísticos
obtidos com os da não utilização dele, já que é considerável o aumento de um
datagrama utilizando tais técnicas de ocultação de informação e o delay gerado para
criar cada criptograma.
2
1.2 MOTIVAÇÃO
A segurança da informação tornando-se um fator essencial para todo tipo de
comunicação, seja ela, pessoal ou comercial. É praticamente obrigatório à utilização de
algum meio que garanta a troca de tais informações entre um emissor e destinatário
sem que haja interferência no meio do caminho, ou seja, que a informação mandada só
possa ser lida pelo destinatário sem que outros consigam obter o significado do esteja
sendo enviado.
Para isto existem os algoritmos de criptografia que são seqüências de
operações que buscam a complexidade (BLAZA et al., 1996) com o objetivo de elevar
exponencialmente o custo para decifração por qualquer um que não seja o real
destinatário (LAMBERT, 2003).
Uma variante do algoritmo de criptografia DES foi escolhida por se tratar de
um algoritmo criptográfico mais estudado e conhecido da história (FIPS, 1999).
3
2
CRIPTOGRAFIA
Criptografia é a ciência que consiste na arte da transformação de mensagens
numa representação sem significado para qualquer pessoa exceto para quem saiba qual
o processo de reverter à transformação. A palavra criptografia teve origem da palavra
grega kryptos que significa "escondida", e graphia cujo significado é "escrever".
No uso generalizado em redes de comunicação de dados à criptografia
estende-se a diversos domínios, desde a autenticação de utilizadores, a privacidade de
comunicações pessoais, ou difundidas, em canais de comunicação poucos seguros, ou
de acesso livre.
Algoritmos criptográficos envolvem funções matemáticas usadas para
codificação dos dados, garantindo segredo e autenticação. Precisando ser conhecidos e
testados, pois, ao contrario do que muitos sistemas de segurança existentes que se
utilizam da obscuridade para garantir sua suposta funcionalidade, os algoritmos
criptográficos mais seguros são justamente os mais conhecidos, aqueles que já foram
publicados em periódicos de pesquisa e amplamente estudados em universidades do
mundo todo. A segurança reside na chave secreta que deve ter tamanho suficiente para
evitar sua descoberta por teste exaustivo.
A principal motivação de sistemas de criptografia é proporcionar segurança a
todos os usuários e evitar que a transação possa ser decifrada por pessoas não
autorizadas.
2.1 HISTÓRIA
A palavra criptografia é derivada de palavras gregas, e a definição que a
originou é: "Arte de escrever com chave secreta ou de modo enigmático". Obviamente
há anos que a criptografia deixou de ser uma arte para virar uma técnica, ou melhor,
um conjunto de técnicas que tratam da proteção. Este tipo de técnica já existe há muito
4
tempo, mesmo que tenha sido usada informalmente por muitas pessoas que, de alguma
forma ou de outra, queriam manter segredo em relação ao conteúdo de suas mensagens
(MORAES, 2004).
Os militares foram os grupos de pessoas que mais usaram a técnica de
criptografia para conseguir segurança de seus dados transmitidos, sendo eles também
os maiores responsáveis pelo desenvolvimento da criptografia.
Todos os sistemas de criptografia anteriores a 2ª Guerra Mundial podem-se
chamar de algoritmos de criptografia clássicos, que coincide com o nascimento dos
computadores.
Com o avanço dos computadores as mensagens criptografadas utilizando-se
de algoritmos clássicos são facilmente decifradas por teste exaustivo, por isso caíram
rapidamente em desuso.
Todos os algoritmos clássicos são simétricos, ou seja, se utilizam de uma
mesma chave tanto para criptografar ou para decifrar. Dentre eles pode-se citar as
cifras por substituição e por permutação, os quais estas são descritas nas seções
seguintes.
2.1.1 Cifras por substituição
As cifras por substituição são aquelas em que os caracteres da mensagem em
texto plano são sistematicamente substituídos por outros caracteres. As quais são
divididas nas seguintes categorias:
• Cifras por deslocamento ou mono alfabéticas: são todos os algoritmos de
criptografia que, sem desordenar os símbolos dentro da mensagem,
estabelecem um mapeamento único para todos eles em todo o texto.
o Algoritmo Caesar: é chamado assim por ser o que Julio Caesar
empregava para enviar suas mensagens secretas, é um dos algoritmos
mais simples. Consiste em somar três ao número de ordem de cada
letra. Desta forma o A corresponde ao D, o B ao E, ..., o W ao Z, o X
5
ao A, o Y ao B e o Z ao C.
o Algoritmo Rot 13: muito semelhante ao de Caesar, consiste em
substituir uma letra por outra situada treze posições mais à frente no
alfabeto.
o Algoritmo Shift-n: é substituído às letras por outras situadas mais à
frente no alfabeto, como nos métodos anteriores. A única diferença é
o número de deslocamentos a serem realizados a cada letra definido
no algoritmo. Sendo este a chave.
• Cifras poli alfabéticas: neste tipo de algoritmo existem múltiplas chaves e
cada uma é usada para encriptar uma letra do texto, ou seja, a substituição
aplicada a cada caractere varia em função da posição que ele ocupa dentro
do texto plano.
• Cifras homofônicas: estes algoritmos tratam de ocultar as propriedades
estatísticas do texto plano, empregando um alfabeto de saída com mais
símbolos que o alfabeto de entrada, ou seja, associando várias saídas a um
símbolo que ocorre mais vezes na palavra, impossibilitando assim um
ataque baseado em freqüências.
2.1.2 Cifras por permutação
As cifras por permutação também são conhecidas como cifra por
transposição e a idéia emprega é manter os mesmos caracteres do texto plano, apenas
rearranjando suas posições.
Neste tipo de cifra consiste em misturar as letras do texto original de acordo
com uma regra reversível qualquer. A transposição pode ser uma permutação baseada
numa palavra-chave ou obtida através de um dispositivo mecânico.
2.2 TIPOS DE CHAVES
A chave consiste em uma string que pode ser alterada sempre que necessário.
6
Desse modo o algoritmo de criptografia pode ser conhecido. Quando o algoritmo se
torna público, vários especialistas tentam decodificar o sistema. Se após alguns anos
nenhum destes conseguirem quebrá-lo, significa que o algoritmo é seguro (PICONI et
al., 2004).
O tipo de chave usada depende do tipo da criptografia usada. Existem dois
tipos de criptografia:
• Criptografia simétrica: que usa uma chave privada.
• Criptografia assimétrica: que usa um par de chaves, conhecida como chave
pública e privada.
2.2.1 Algoritmos Simétricos
Sistema simétrico ou também conhecido como criptografia por chave secreta
ou única e criptografia simétrica ou tradicional, são os algoritmos que se utiliza de
uma única chave para encriptar ou criptografar e decriptar ou descriptografar os dados,
ou seja, por usar a mesma chave para as duas tarefas o processo de criptografia é
relativamente pequeno e rápido, contudo como desvantagem, não só o transmissor
deve conhecer a chave como também o receptor (PICONI et al., 2004).
7
FIGURA 1: FUNCIONAMENTO DE ALGORITMOS DE CHAVES SIMÉTRICAS
Texto Puro
Algoritmo
Criptografia
Mensagem
Criptografada
Chave
Internet
Mensagem
Criptografada
Mensagem
Decriptografada
Algoritmo
Decriptografia
Chave
Fonte: MORAES (2004)
Conforme demonstra a figura acima, o funcionamento de algoritmos
simétricos é simples. A soma da mensagem mais a chave geram uma mensagem
criptografada, após a geração, ela é enviada através da rede, e ao chegar ao lado
oposto, ela é descriptografada através da chave que esta no destino.
A chave deve ser conhecida tanto pelo remetente quanto pelo receptor da
mensagem. Sua geração, transmissão e armazenamento são denominados Gerência de
Chaves (MORAES, 2004).
O principal desafio (e fragilidade) deste método é garantir que ninguém mais
conheça a chave além do transmissor e receptor originais, pois o simples fato de ter
que transmitir ou informar a chave para o receptor já torna falho este tipo de algoritmo,
porque estaria abrindo a possibilidade de um atacante obter a chave e ter acesso
irrestrito aos dados criptografados, podendo ler, modificar ou até mesmo forjar novas
8
mensagens encriptadas ou autenticadas.
Esta forma de algoritmo por chave privada funciona muito bem quando o
usuário que encripta é o mesmo que desencripta o arquivo (MORAES, 2004).
2.2.2 Algoritmos Assimétricos
Em 1976, os cientistas americanos Whitfield Diffie e Martin Hellman
apresentaram o conceito de criptografia por chave pública. A grande inovação foi o
uso de duas chaves (PICONI et al., 2004). Os principais objetivos desta nova
modalidade de troca de mensagens cifradas, é encriptação e assinaturas digitais. Neste
sistema cada pessoa possui um par de chaves, uma denominada chave pública e outra
denominada chave privada. Enquanto a chave pública tem seu conhecimento
difundido, a chave privada deve ser mantida em segredo (MORAES, 2004).
Esta nova modalidade elimina o problema dos algoritmos simétricos que
necessitavam que as partes comunicantes trocassem informações sigilosas, sendo que
agora todas as comunicações irão envolver somente a chave pública (sem a
necessidade de meios de transmissão seguros) não sendo necessária à troca de chaves
secretas por nenhuma das partes.
9
FIGURA 2: FUNCIONAMENTO DE ALGORITMOS DE CHAVES ASSIMÉTRICAS
Texto Puro
Algoritmo
Criptografia
Mensagem
Criptografada
Chave
Pública
Internet
Mensagem
Criptografada
Mensagem
Decriptografada
Algoritmo
Decriptografia
Chave
Privada
Fonte: MORAES (2004)
Um emissor possuindo a chave pública do receptor pode usá-la para enviar
mensagens cifradas e a mesma mensagem só pode ser lida mediante o uso da chave
privada de pertence ao receptor.
Neste sistema criptográfico a chave privada é matematicamente derivada da
chave pública. Se, em tese, é probabilisticamente impossível a um atacante derivar a
chave privada da chave pública, esta propriedade ainda não pode ser matematicamente
comprovada (MORAES, 2004).
Algoritmos de criptografia por chave pública resolvem o problema de
transmitir uma mensagem totalmente segura através de um canal inseguro (sujeito a
observação). O receptor da mensagem cria duas chaves que são relacionadas entre si,
uma pública e uma privada. A chave pública pode e deve ser distribuída livremente.
Quem envia a mensagem tem que utilizar a chave pública do receptor para encriptá-la.
10
Uma vez encriptada, esta mensagem só pode ser desencriptada pela chave do receptor
(MORAES, 2004).
11
3
ALGORITMO DES
Após a segunda guerra mundial, ainda não se tinha um padrão criptográfico
que permitisse que diferentes equipamentos compartilhassem dados criptografados,
mesmo com a chamada criptografia moderna que no período da 2ª guerra mundial
avançou muito nesta década. Com criação desse padrão tornaria a proteção de
informações muito mais barata e confiável (HINZ, 2000). Pensando nisto em 15 de
maio de 1973 a NBS (National Bureau of Standards) realizou um anúncio público
solicitando propostas de algoritmos para proteção de dados durante sua transmissão e
armazenamento (MORAES, 2004).
Este algoritmo deveria obedecer algumas especificações (HINZ, 2000):
• Deve ter alto nível de segurança;
• Deve estar totalmente documentado e ser de fácil entendimento;
• A segurança do algoritmo deve se encontrar na chave e não depender do
sigilo do algoritmo;
• Deve estar disponível para todos os usuários;
• Deve ser adaptável para uso em diversas aplicações;
• Deve ser economicamente implementável em dispositivos eletrônicos;
• Deve ser eficiente;
• Deve estar habilitado para validação;
• Deve ser exportável.
Não houve resposta até seis de agosto de 1974 quando a IBM apresentou o
criptossistema desenvolvido chamado LUCIFER (WEBER, 1995). A NSA (National
Security Agency) e a NBS avaliaram o algoritmo e em 15 de julho de 1977 adotou-se
uma modificação no LUCIFER e passou a chamar-se DES (Data Encryption
Standard) (MORAES, 2004) com um padrão de 64 bits de leitura e uma chave com 56
bits para a mensagem (GONÇALVES, 2001).
12
3.1 DESCRIÇÃO
Tanto o algoritmo quanto a chave são simétricos, ou seja, utiliza-se de uma
chave K para cifrar blocos de texto claro (M) e decifrar blocos de texto cifrado (C)
(LAMBERT, 2003). Por padrão possui uma chave de 64 bits no qual para cada 64 bits
de texto simples na entrada do algoritmo, surgem 64 bits de texto criptografado na
saída e todos os oitavos bits de cada byte da mensagem são usados somente como bits
de paridade (HINZ, 2000).
Este algoritmo foi adotado e permaneceu como padrão para criptografia de
dados do governo americano por mais de 25 anos, no qual ainda é muito estudado
atualmente (LAMBERT, 2003). O DES é um algoritmo criptográfico que se utiliza
originalmente de uma seqüência de 16 iterações, sendo que em cada uma dessas são
realizadas sucessivas transposições, substituições e permutações entre os bits da chave
e de cada bloco de texto em claro (que por padrão devem possuir 64 bits cada),
resultando finalmente em um criptograma.
3.2 ESTRUTURA DE FUNCIONAMENTO
O DES opera sobre os blocos de mensagem de 64 bits a fim de obter o
criptograma na seguinte seqüência de operações apresentadas nas próximas seções
(LAMBERT, 2003).
3.2.1 Obter 16 sub-chaves de 48 bits cada
É preciso obter-se 16 sub-chaves de 48 bits cada para serem usadas
posteriormente na etapa de geração dos criptogramas 64 bits, mais especificamente nas
operações XOR (Exclusive OR).
Depois de realizado a verificação de integridade da chave (K) resta-se
somente 56 bits e esses são permutados conforme demonstrado na tabela de
permutação de compressão PC-1 a seguir:
13
TABELA 1:
57
1
10
19
63
7
14
21
49
58
2
11
55
62
6
13
PERMUTAÇÃO PC-1
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
Agora se divide a chave em duas partes. Os primeiros 28 bits da chave
passam a se chamar C0 e os últimos 28 bits em D0 (MORAES, 2004), então inicia-se
um processo de iteração que tem o objetivo de criar 16 blocos Cn e Dn, onde, 1 <= n
<= 16, utilizando-se do esquema de deslocamento para a esquerda circular conforme
tabela a seguir:
TABELA 2:
NÚMERO DE ITERAÇÕES DO DESLOCAMENTO A ESQUERDA CIRCULAR
Iteração:
Deslocamento:
1
1
2
1
3
2
4
2
5
2
6
2
7
2
8
2
9
1
10
2
11
2
12
2
13
2
14
2
15
2
16
1
Aplicando outra tabela de permutação de compressão chamada PC-2
(apresentada logo abaixo) em cada um dos pares concatenados CnDn, obtêm-se 16 subchaves (Kn) de 48 bits cada.
TABELA 3:
14
3
23
16
41
30
44
46
17
28
19
7
52
40
49
42
PERMUTAÇÃO PC-2
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
A figura abaixo ilustra melhor as etapas aqui apresentadas para obtenção de
16 sub-chaves de 48 bits cada a partir da chave original.
14
FIGURA 3: CICLO DES DE OBTENÇÃO DE 16 SUB-CHAVES DE 48 BITS
Chave Original
Permutação de Compressão (PC-1)
Left
Shift
Left
Shift
Permutação de Compressão (PC-2)
Chave 48 bits
Fonte: Baseado em HINZ (2000)
3.2.2 Obter blocos codificados de cada 64 bits da mensagem
Primeiramente é separado do texto plano um bloco de 64 bits. Se o bloco for
menor do que 64 bits, ele é preenchido com zeros (MORAES, 2004).
Então é realizada uma permutação inicial (IP) de cada bloco da mensagem
M, conforme tabela logo abaixo. A permutação inicial não influi diretamente na
segurança do DES, pois ela apenas executa uma simples permutação de bits com o
propósito de facilitar o uso do DES em chips quando ele é implementado em hardware
(HINZ, 2000).
TABELA 4:
58
60
62
64
57
59
61
63
50
52
54
56
49
51
53
55
42
44
46
48
41
43
45
47
PERMUTAÇÃO IP
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
15
Divide-se o bloco de 64 bits resultante da permutação em duas partes L0 e
R0, cada uma com 32 bits (MORAES, 2004). Depois disto, deve-se processar o bloco
de dados L0R0 em 16 sub-chaves. E para isto o bloco Rn-1 com 32 bits é expandido
para 48 bits através da tabela de expansão abaixo que repete alguns bits da chave,
resultando E(Rn-1).
TABELA 5:
32
4
8
12
16
20
24
28
1
5
9
13
17
21
25
29
EXPANSÃO E
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
A seguir é realizado um XOR na saída E(Rn-1) com a chave Kn. É importante
esta etapa porque o XOR é reversível e serve para podermos reverter o processo na
decifragem da mensagem (FIPS, 1999).
O XOR resultará em uma chave de 48 bits que será dividida em oito blocos
de seis bits cada, se tornando B1, ..., B8. Para cada bloco Bj será aplicada uma S-Box
correspondente (conforme tabelas a seguir). Sendo a linha representada pelo primeiro e
último bit do bloco Bj e a coluna representada pelos quatro bits do meio do bloco Bj,
resultando a transformação Sj(Bj) num número binário de 4 bits que se encontra na
posição indicada pela linha e coluna formada pelo Bj.
TABELA 6:
14
0
4
15
4
15
1
12
13
7
14
8
1
4
8
2
15
3
0
13
1
13
14
8
8
4
7
10
14
7
11
1
2
14
13
4
15
2
6
9
11
13
2
1
8
1
11
7
TABELA 7:
6
15
10
3
11
2
4
15
3
8
13
4
4
14
1
2
S-BOX S1
3
10
15
5
10
6
12
11
6
12
9
3
12
11
7
14
5
9
3
10
9
5
10
0
0
3
5
6
7
8
0
13
13
10
6
12
12
6
9
0
0
9
3
5
5
11
2
14
10
5
15
9
S-BOX S2
9
12
5
11
7
0
8
6
2
1
12
7
16
TABELA 8:
10
13
13
1
0
7
6
10
9
0
4
13
14
9
9
0
6
3
8
6
3
5
0
6
0
6
12
10
3
4
15
9
15
6
3
8
5
10
0
7
TABELA 9:
7
13
10
3
13
8
6
15
14
11
9
0
6
15
11
1
9
0
7
13
10
3
13
8
S-BOX S3
1
2
11
4
13
8
1
15
12
5
2
14
7
14
12
3
11
12
5
11
4
11
10
5
2
15
14
2
8
1
7
12
S-BOX S4
1
4
15
9
2
7
1
4
8
2
3
5
5
12
14
11
11
1
5
12
12
10
2
7
4
14
8
2
15
9
4
14
TABELA 10: S-BOX S5
2
14
4
11
12
11
2
8
4
2
1
12
1
12
11
7
7
4
10
1
12
10
9
4
1
15
14
3
10
4
15
2
15
2
5
12
9
7
2
9
10
7
13
14
11
13
7
2
6
1
8
13
8
5
15
6
5
0
9
15
3
15
12
0
15
10
5
9
13
3
6
10
0
9
3
4
14
8
0
5
9
6
14
3
11
8
6
13
TABELA 11: S-BOX S6
2
12
8
5
6
9
12
15
8
5
3
10
0
6
7
11
13
1
0
14
3
13
4
1
4
14
10
7
14
0
1
6
7
11
13
0
5
3
11
8
7
12
8
15
5
2
0
14
10
15
5
2
6
8
9
3
14
11
13
0
5
0
15
3
0
14
3
5
12
9
5
6
TABELA 12: S-BOX S7
4
13
1
6
11
0
4
11
2
11
11
13
14
7
13
8
15
4
12
1
0
9
3
4
8
1
7
10
13
10
14
7
3
14
10
9
12
3
15
5
9
5
6
0
1
6
2
12
TABELA 13: S-BOX S8
13
1
7
2
2
15
11
1
8
13
4
14
4
8
1
7
6
10
9
4
15
3
12
10
11
7
14
8
1
4
2
13
10
12
0
15
9
5
6
12
3
6
10
9
7
2
8
11
A concatenação da saída das S-Box Sj(Bj) resulta em um novo bloco de 32
bits. Neste bloco aplica-se a permutação P apresentada na tabela abaixo.
TABELA 14: PERMUTAÇÃO P
16
29
1
5
2
32
7
12
15
18
8
27
20
28
23
31
24
3
21
17
26
10
14
9
17
19
22
13
11
30
4
6
25
Com o resultado da permutação P aplica-se a operação XOR com o elemento
Ln-1, resultando em Rn. Por último o elemento Ln é igual a Rn-1.
Depois de realizado o cálculo dos 16 sub-blocos deve-se aplicar a
permutação IP-1 na concatenação de R16L16.
TABELA 15: PERMUTAÇÃO IP-1
40
39
38
37
36
35
34
33
8
7
6
5
4
3
2
1
48
47
46
45
44
43
42
41
16
15
14
13
12
11
10
9
56
55
54
53
52
51
50
49
24
23
22
21
20
19
18
17
64
63
62
61
60
59
58
57
32
31
30
29
28
27
26
25
Com todas estas etapas, resultará o bloco de 64 bits M num bloco cifrado C
com o algoritmo DES.
Todo este processo pode ser melhor compreendido na ilustração abaixo
(Figura 4), que representa a junção do passo anterior (obter 16 sub-chaves de 48 bits
cada) com este.
18
FIGURA 4: CICLO DES DE CODIFICAÇÃO DE BLOCOS DE MENSAGENS
Bloco Plano
Chave Original
Permutação IP
Permutação de Compressão (PC-1)
Ln-1
Rn-1
Left
Shift
Permutação de
Expansão (E)
Left
Shift
Permutação de Compressão (PC-2)
Chave 48 bits
S-Box
P-Box
Ln
Rn
R16
L16
Permutação IP-1
Bloco Cifrado
Fonte: Baseado em HINZ (2000) e FIPS (1999)
19
3.2.3 Decifração
O processo de decifração de blocos cifrados pelo algoritmo de criptografia
DES utiliza-se do mesmo processo de cifragem, mas as sub-chaves de 48 bits (K1 à
K16) geradas a partir da chave original de 64 bits, são usadas na ordem inversa durante
o algoritmo, ou seja, após a permutação de expansão a primeira sub-chave que irá
realizar a operação XOR com o resultado da permutação será K16.
3.2.4 Triple-DES
Como o DES tem dois objetivos básicos, a difusão que busca distribuir a
redundância existente na mensagem original para a cifrada, e a confusão que tem o
propósito de tornar complexa a relação entre a chave e a mensagem (JASCONE,
2003). O DES pode ser quebrado pelo método de força bruta (testes exaustivos),
tentando-se todas as combinações possíveis de chave (JASCONE, 2003). Por este
motivo buscou-se a criação de alguma técnica para alavancar a segurança neste
algoritmo.
Em 1979 Tuchman propôs o uso de três etapas adicionais no algoritmo
padrão DES (HANDSCHUH, 1999), por isso o nome Triple-DES que é uma variação
do algoritmo DES no qual é considerado seguro e mesmo que praticamente triplicando
o processo de crifagem ele ainda é um método de criptografia simétrica rápida
(SANTOS, 2002) (VILELA, 2003).
Na etapa de cifragem este algoritmo é do tipo EDE (Encrypt-DecryptEncrypt), ou seja, a primeira chave é utilizada para encriptar, a segunda para decifrar
(com o intuito de embaralhar ainda mais o bloco e não de voltar para o bloco original),
e finalmente a terceira e última chave é utilizada para encriptar novamente o bloco de
64 bits fornecido no inicio do algoritmo. Na primeira e terceira chave pode ser
utilizado a mesma chave (MAO, 2003). Já para decifrar o algoritmo realiza as
operações inversas da cifragem, ficando com o esquema de DED (Decrypt-EncryptDecrypt) (MAO, 2003).
20
Nas figuras 5 e 6 pode-se visualizar mais adequadamente o funcionamento
deste algoritmo utilizando duas chaves de 56 bits (totalizando 112 bits) e na seqüência
com três chaves também de 56 bits cada (totalizando 168 bits).
FIGURA 5: FUNCIONAMENTO DO TRIPLE-DES COM DUAS CHAVES DE 56 BITS
Bloco Plano
DES
Encripta
Chave 2
DES
Decifrar
DES
Encripta
Bloco Cifrado
Fonte: Baseado em JILANI (2003)
Chave 1
21
FIGURA 6: FUNCIONAMENTO DO TRIPLE-DES COM TRÊS CHAVES DE 56 BITS
Bloco Plano
DES
Encripta
Chave 2
DES
Decifrar
DES
Encripta
Bloco Cifrado
Fonte: Baseado em JILANI (2003)
Chave 1
Chave 3
22
4
IMPLEMENTAÇÃO
Com o objetivo de demonstrar o impacto gerado na utilização de um
algoritmo de criptografia, mais especificamente, o algoritmo Triple-DES, no
throughput de uma rede local. Definiu-se a utilização dos seguintes componentes para
o desenvolvimento de uma aplicação que servirão para demonstrar o objetivo descrito:
• Sistema Operacional GNU/Linux;
• Ferramenta de captura de tráfego na rede TCPDUMP versão 3.8.3;
• Linguagem de programação C, no qual será utilizada para geração de
datagramas criptográficos com o algoritmo Triple-DES.
• Computador AMD K7-800 MHz com as seguintes características:
o 384 MB de memória RAM;
o Placa de rede Realtek 8139;
o Distribuição Debian Testing com kernel 2.4.27.
• Computador AMD K6-500 MHz com as seguintes características:
o 160 MB de memória RAM;
o Placa de rede Realtek 8139;
o Distribuição Debian Stable com kernel 2.6.7.
4.1 AMBIENTE DE SIMULAÇÃO
No ambiente de simulação será utilizado duas máquinas com GNU/Linux
interligadas por um HUB e sem nenhuma conexão externa, conforme demonstra a
figura abaixo.
23
FIGURA 7: AMBIENTE DE SIMULAÇÃO
Sistema
GNU/Linux
Debian com
Kernel 2.4.27
e rodando a
ferramenta
TCPDUMP
10.0.0.139
Sistema
GNU/Linux
Debian com
Kernel 2.6.7
e rodando o
sistema
10.0.0.144
gerador de datagramas
HUB 10/100 BaseT
4.2 SISTEMA GERADOR DE DATAGRAMAS CIFRADOS
Este sistema tem por função a geração de datagramas TCP cifrados pelo
algoritmo Triple-DES para um determinado IP e porta específica durante um tempo
pré-definido. E para realizar esta tarefa foi utilizado raw sockets (AL-HERBISH,
1999), no qual possibilita trabalhar diretamente com a estrutura do protocolo, ou seja,
possibilita a manipulação dos dados no cabeçalho do datagrama IP (Internet Protocol).
O datagrama IP é muito importante no que diz respeito à versão do
protocolo, fragmentação dos datagramas, entre outras opções como demonstra a figura
abaixo.
FIGURA 8: ESTRUTURA DO CABEÇALHO IP
Versão
Tamanho do
cabeçalho
Tipo do serviço (TOS)
Tamanho Total
Identificação
Flags
Deslocamento do fragmento
Tempo de vida (TTL)
Protocolo
Checksum do cabeçalho
Endereço IP de origem
Endereço IP de destino
Opções
Padding
Dados
Fonte: TORRES (2001)
Todas essas opções acima apresentadas do datagrama IP foram
24
respectivamente definidas pelo trecho de código no quadro a seguir.
QUADRO 1: ROTINA QUE DEFINE O CABEÇALHO IP
void
set_ip_header(struct sockaddr_in *dst)
{
datagram.ipheader.version
= IPVERSION;
datagram.ipheader.ihl
= sizeof(struct iphdr) >> 2;
datagram.ipheader.tos
= 0x00;
datagram.ipheader.tot_len
= htons(sizeof(struct _datagram));
datagram.ipheader.id
= htons(0x01);
datagram.ipheader.frag_off = htons(IP_DF); // Não fragmentar.
datagram.ipheader.ttl
= 0x40;
datagram.ipheader.protocol = IP_TCP;
datagram.ipheader.check
= htons(0x00);
datagram.ipheader.saddr
= htonl(SRCADDR);
datagram.ipheader.daddr
= dst->sin_addr.s_addr;
}
Explicando o trecho de código acima:
• datagram.ipheader.version: define a versão do protocolo IP que está sendo
usado. No qual neste caso é a versão 4;
• datagram.ipheader.ihl: especifica o número de linhas de 32 bits que o
cabeçalho possui. É feito um deslocamento a direito de 2 bits sobre o
tamanho da struct iphdr, resultando no número 5;
• datagram.ipheader.tos: este campo define a qualidade desejada para a
entrega do datagrama. Como o datagrama gerado não irá passar por nenhum
roteador, então definiu-se como “0”, pois não iria fazer diferença se o definise para ter delay (atraso), throughput (velocidade) e realiability
(confiabilidade);
• datagram.ipheader.tot_len: indica o número total de bytes que compõem o
datagrama. Este recebe o tamanho da struct _datagram que é composta
pelos cabeçalhos IP e TCP (Transmission Control Protocol) mais a quantia
de dados, totalizando neste caso 48 bytes;
• datagram.ipheader.id: usado para identificar o datagrama. Como os
datagramas gerados pelo sistema não vão ser fragmentados este campo
recebeu o valor numérico um;
• datagram.ipheader.frag_off: controla a fragmentação de datagramas, e
25
como já dito acima não é necessário fragmentar pois os datagramas gerados
são pequenos (48 bytes), foi definido como IP_DF (IP Don’t Fragment) que
possui o valor 0x4000;
• datagram.ipheader.ttl: indica o tempo máximo de vida do datagrama. Como
especificado anteriormente, os datagramas gerados não irão passar por
nenhum roteador, então foi adotado um valor padrão de 64;
• datagram.ipheader.protocol: define o protocolo utilizado para envio dos
datagramas. Neste caso o protocolo TCP que é definido pelo valor numérico
seis;
• datagram.ipheader.check: este campo indica o checksum, no qual é
utilizado para definir se o cabeçalho está ou não corrompido. Como neste
ambiente de simulação os datagramas não irão passar por nenhum roteador
optou-se por defini-lo com o valor zero.
• datagram.ipheader.saddr: endereço IP de onde esta partindo o datagrama.
Foi definido com o valor 127.0.0.1;
• datagram.ipheader.daddr: endereço IP de destino do datagrama. É definido
por parâmetro ao programa.
Como foi definido no cabeçalho IP que o protocolo utilizado é o TCP, a
figura a seguir demonstra as opções que o mesmo contém.
26
FIGURA 9: ESTRUTURA DO CABEÇALHO TCP
Porta origem
Porta destino
Número Seqüência
Número reconhecimento
Deslocamento
Reservado
Controle
Janela
Checksum
Ponteiro urgência
Opções
Padding
Dados
Fonte: TORRES (2001)
Essas opções acima apresentadas do datagrama TCP foram respectivamente
definidas pelo trecho de código no quadro a seguir.
QUADRO 2: ROTINA QUE DEFINE O CABEÇALHO TCP
void
set_tcp_header(struct sockaddr_in
{
datagram.tcpheader.th_sport =
datagram.tcpheader.th_dport =
datagram.tcpheader.th_seq
=
datagram.tcpheader.th_ack
=
datagram.tcpheader.th_off
=
datagram.tcpheader.th_flags =
datagram.tcpheader.th_win
=
datagram.tcpheader.th_urp
=
*dst)
dst->sin_port;
dst->sin_port;
0x00;
0x00;
sizeof(struct tcphdr) >> 2;
TH_SYN;
htons(0x01);
0x01;
memset(&header, 0, sizeof(struct _header));
header.saddr.s_addr
header.daddr.s_addr
header.zero
header.protocol
header.length
=
=
=
=
=
htonl(SRCADDR);
dst->sin_addr.s_addr;
0;
IP_TCP;
sizeof(struct tcphdr) +
DES3_DATASIZE;
datagram.tcpheader.th_sum
= checksum((u_short *) &header,
sizeof(struct _header));
}
Explicando o trecho de código acima:
• datagram.tcpheader.th_sport: porta de origem dos dados, sendo definido a
mesma porta que a de destino;
• datagram.tcpheader.th_dport: porta de destino dos dados, definido com o
27
valor padrão de 63221 ou podendo ser especificada pelo usuário através de
parâmetros;
• datagram.tcpheader.th_seq: representa o número do primeiro byte do
fragmento. Como neste ambiente é gerado toda vez o mesmo datagrama e
não ocorre fragmentação, o valor vai ser sempre zero;
• datagram.tcpheader.th_ack: número de seqüência do próximo fragmento.
Novamente este campo também é definido por não ocorrer fragmentação;
• datagram.tcpheader.th_off: especifica o tamanho do cabeçalho, sendo
realizado um deslocamento de dois bits para a direita sobre o tamanho da
struct tcphdr, resultando o valor numérico cinco (5);
• datagram.tcpheader.th_flags: este define os códigos de controle, sendo
somente defino pelo código de TH_SYN que significa sincronismo;
• datagram.tcpheader.th_win: serve para enviar vários pacotes antes de
receber a confirmação de recebimento. Neste caso não foi preciso usar esta
opção, pois não é feito o controle se o datagrama foi recebido ou não, então
o mesmo recebeu o valor numérico um;
• datagram.tcpheader.th_urp: outro campo desnecessário nesta aplicação no
qual define se existe dados urgentes no segmento de dados, especificando
onde os mesmos terminam;
• datagram.tcpheader.th_sum: este recebe o valor calculado do checksum
sobre um pseudo cabeçalho. Sendo o pseudo cabeçalho utilizado somente
para o cálculo do checksum e por conseqüência não irá ser transmitido.
Todo este processo de definição do cabeçalho IP, TCP e inserção dos dados
que serão enviados (texto plano ou cifrado) se repete toda vez que irá ser enviado um
datagrama, possibilitando uma melhor comparação com um fato real. O trecho que
monta o datagrama pode ser visualizado no quadro a seguir.
28
QUADRO 3: ROTINA QUE DEFINE OS DATAGRAMA
void
init_datagram(const char *data, struct sockaddr_in *dst)
{
memset(&datagram, 0, sizeof(struct _datagram));
memcpy(&datagram.data, data, DES3_DATASIZE);
set_ip_header(dst);
set_tcp_header(dst);
}
Repara-se que toda vez é realizado a mesma operação tanto para criação dos
datagramas criptografados e para datagramas em texto plano, isto para não afetar nos
resultados. Seguindo o código, é primeiramente zerada a estrutura datagram com a
função memset() e então copiados os dados passados por parâmetros a sub-rotina
init_datagram() para o campo de dados do datagrama definido na estrutura como
datagram.data, após isto é definido o cabeçalho IP e TCP através das sub-rotinas
apresentas anteriormente.
As opções disponíveis para o usuário como, definição de tempo de envio dos
datagramas, porta de destino, especificar se o datagrama é criptografado ou não e o
endereço do destino, pode-se ser compreendido no quadro abaixo.
QUADRO 4: OPÇÕES DISPONÍVEIS PARA O USUÁRIO
# ./gen
Sistema Gerador de Datagramas Cifrados - v0.1
Copyright (C) 2004 Fabiano R. Righetti - frighetti AT cascavel.pm.org
Mode de uso: ./gen [-cpt] <host|ip>
-c
Habilitar cifragem com algoritmo Triple-DES
-p <porta>
Porta TCP do servidor.
-t <tempo>
Tempo total de envio de datagramas em minutos. (default: 10)
#
Os datagramas criptografados irão se utilizar do algoritmo de criptografia
Triple-DES implementado por DEVINE (2004) seguindo as normas do documento
FIPS (1999).
Segue trecho de código que realiza a criptografia dos dados através de
funções da biblioteca de DEVINE (2004).
29
QUADRO 5: ROTINA UTILIZADA PARA CRIPTOGRAFAR
void
triple_des_cipher(const char *data)
{
des3_context ctx3;
memset(triple_des.DATA,
0, DES3_DATASIZE + 1);
memcpy(triple_des.DATA, data, DES3_DATASIZE);
des3_set_3keys(&ctx3, DES3_KEY[0], DES3_KEY[1], DES3_KEY[2]);
des3_encrypt(&ctx3, triple_des.DATA, triple_des.DATA);
}
Em todo datagrama criptografado será primeiramente zerada o campo de
dados da estrutura triple_des e então copiados os dados recebidos por parâmetro que
estão em texto plano para o campo triple_des.DATA. Depois de realizado esta tarefa é
definida as três chaves que serão utilizadas para cifrar os dados na variável declarada
no início da sub-rotina como ctx3 do tipo des3_context através da chamada da função
des3_set_3keys(). Finalmente é realizado a cifragem dos dados pela função
des3_encrypt() passando a estrutura de chaves e o texto plano que será criptografado.
4.3 TESTES REALIZADOS
Foi realizado diversas vezes testes de desempenho com o objetivo de
verificar a vazão de rede alcançada. Primeiramente foi feito um isolamento da rede,
deixando somente duas máquinas rodando o sistema GNU/Linux interligadas por um
HUB e utilizando-se de uma conexão 10/100 BaseT. A composição dos datagramas
em texto plano e já criptografados, capturados pelo analisador de rede TCPDUMP
pode ser visualizado nos quadros a seguir, com os respectivos parâmetros passados ao
programa.
QUADRO 6: PARÂMETROS USADOS PARA GERAR DATAGRAMAS EM TEXTO PLANO
# ./gen 10.0.0.139
Sistema Gerador de Datagramas Cifrados - v0.1
Copyright (C) 2004 Fabiano R. Righetti - frighetti AT cascavel.pm.org
+ stream inicializada!
+++ aguarde 10 minutos...
+ stream finalizada!
#
30
QUADRO 7: DATAGRAMA CAPTURADO PELO TCPDUMP EM TEXTO PLANO
# tcpdump -i eth0 tcp dst port 63221 -n -c 1 -X
listening on eth0, link-type EN10MB (Ethernet), capture size 96 bytes
20:46:38.592821 IP 127.0.0.1.63221 > 10.0.0.139.63221: S 0:8(8) win 1
0x0000: 4500 0030 0001 4000 4006 b13b 7f00 0001 E..0..@.@..;....
0x0010: 0a00 008b f6f5 f6f5 0000 0000 0000 0000 ................
0x0020: 5002 0001 237e 0100 7465 7374 616e 646f P...#~..testando
1 packets captured
#
QUADRO 8: PARÂMETROS USADOS PARA GERAR DATAGRAMAS CRIPTOGRAFADOS
# ./gen 10.0.0.139 -c
Sistema Gerador de Datagramas Cifrados - v0.1
Copyright (C) 2004 Fabiano R. Righetti - frighetti AT cascavel.pm.org
+ stream inicializada!
+++ aguarde 10 minutos...
+ stream finalizada!
#
QUADRO 9: DATAGRAMA CAPTURADO PELO TCPDUMP JÁ CRIPTOGRAFADO
# tcpdump -i eth0 tcp dst port 63221 -n -c 1 -X
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on eth0, link-type EN10MB (Ethernet), capture size 96 bytes
20:47:32.678442 IP 127.0.0.1.63221 > 10.0.0.139.63221: S 0:8(8) win 1
0x0000: 4500 0030 0001 4000 4006 b13b 7f00 0001 E..0..@.@..;....
0x0010: 0a00 008b f6f5 f6f5 0000 0000 0000 0000 ................
0x0020: 5002 0001 237e 0100 91e4 15c6 468b 4ee7 P...#~......F.N.
1 packets captured
#
Após ter realizado alguns testes, notou-se que o intervalo entre um
datagrama em texto plano e outro estava sendo maior que o dos datagramas
criptografados. Por razão disto foi averiguado que o TCPDUMP não estava
conseguindo receber todos os datagramas enviados em texto plano e que recebia
somente uma notificação do kernel do sistema que o pacote foi recebido, mas
descartado pelo mesmo. Em razão disto buscaram-se outros meios de captura de
datagramas, e então foi realizado o teste utilizando-se da ferramenta IPTABLES
(programa utilizado para criar regras de filtragem em pacotes provenientes da rede, em
outras palavras, um firewall) para gravar em um arquivo os datagramas recebidos, mas
novamente a taxa de recebimento de datagramas em texto plano estava sendo muito
pouco.
Devido a estes fatores chegou-se a conclusão que pelo fato de os datagramas
estarem sendo gerados muito rapidamente e enviados pela rede, levou a algum motivo
o kernel do sistema bloquear os mesmo.
31
Pode-se notar a grande diferença em datagramas bloqueados pelo kernel
entre os em texto plano e os criptografados nos quadros a seguir.
QUADRO 10: VAZÃO DE REDE ALCANÇADA POR DATAGRAMAS EM TEXTO PLANO
# tcpdump -i eth0 tcp dst port 63221 -n -w plain.raw
tcpdump: listening on eth0, link-type EN10MB (Ethernet), capture size 96 bytes
1307185 packets captured
21796712 packets received by filter
20489527 packets dropped by kernel
#
QUADRO 11: VAZÃO DE REDE ALCANÇADA POR DATAGRAMAS CRIPTOGRAFADOS
# tcpdump -i eth0 tcp dst port 63221 -n -w cipher.raw
tcpdump: listening on eth0, link-type EN10MB (Ethernet), capture size 96 bytes
10313926 packets captured
10313938 packets received by filter
12 packets dropped by kernel
#
Os dados apresentados nos quadros acima representam a captura dos
respectivos tipos de datagramas durante dez minutos. Sendo que as características da
rede foram mantidas durante os dois testes.
4.4 RESULTADOS
Diante dos resultados obtidos durante os testes, averiguou-se que os
datagramas em texto plano alcançaram à marca de 21.796.712 datagramas recebidos
com 48 bytes cada. Já os datagramas de criptografia chegaram à marca de 10.313.938
datagramas recebidos de 48 bytes cada. Com a totalização de datagramas recebidos
pode-se chegar-se aos seguintes dados apresentados nos gráficos a seguir.
32
FIGURA 10: GRÁFICO CONFRONTANDO TOTAL DE DADOS RECEBIDOS
Tipo do datagrama
Dados enviados durante 10 minutos
472,13
1
997,77
-
500,00
Criptografado
Texto Plano
1.000,00
Total de dados em MBytes
FIGURA 11: GRÁFICO CONFRONTANDO DADOS RECEBIDOS POR SEGUNDO
Tipo do datagrama
Dados enviados por segundo
0,79
1
-
1,66
0,50
1,00
1,50
Total de dados em MBytes
2,00
Criptografado
Texto Plano
33
5
CONCLUSÃO
Com os resultados obtidos pode-se concluir que mesmo utilizando um
algoritmo de criptografia simétrica no qual é considerado rápido, houve uma elevada
diferença entre o total de dados enviados, aproximadamente 60%.
Todo sistema que seja necessário uma melhor segurança e que a solução para
isto é a utilização de sistema de criptografia, deve-se fazer um estudo sobre qual
algoritmo utilizar, seja ele simétrico ou assimétrico, e se os blocos criptografados pelo
mesmo serão maiores que em texto puro, pois como demonstrado no ambiente de teste
proposto, os resultados foram afetados somente pelo delay causado pelo algoritmo
criptografia, sem considerar o tamanho dos blocos gerados porque a cifragem
realizado pelo Triple-DES resulta em blocos de mesmo tamanho.
Pelo fato de algoritmos simétricos se utilizarem de uma mesma chave, e
havendo a necessidade de o receptor conhece-la, pode-se optar por usar em conjunto
os algoritmos assimétricos para não perder muito desempenho na transmissão. Sendo
os algoritmos assimétricos utilizados somente para repassar ao receptor a chave
utilizada pelos algoritmos simétricos.
5.1 TRABALHOS FUTUROS
Ainda tem-se uma ampla gama de testes que devem ser feitos que possam
contribuir ainda mais com as conclusões chegadas com este trabalho, entre eles:
• Adotar um algoritmo de criptografia que não resulte um bloco
criptografado de mesmo tamanho do bloco de entrada como o DES;
• Variar o tamanho dos datagramas enviados;
• Confrontar os resultados obtidos entre algoritmos de criptografia
simétrica e assimétrica;
• Realizar teste utilizando-se os dois tipos de algoritmos em conjunto.
34
REFERÊNCIAS
AL-HERBISH, Thamer. Raw IP Networking FAQ. Disponível
<http://www.whitefang.com/rin/rawfaq.html>. Acesso em: 08 dez. 2004.
em:
BLAZE, Matt; DIFFIE, Whitfield; RIVEST, Ronald L.; SCHNEIER, Bruce;
SHIMOMURA, Tsutomu; THOMPSON, Eric; WIENER, Michael. Minimal Key
Lengths for Symmetric Ciphers to Provide Adequate Commercial Security. 1996.
DEVINE, Christophe. Implementação do Triple-DES na liguagem ANSI C.
Disponível em: <http://www.cr0.net:8040/code/crypto/des/>. Acesso em: 05 dez.
2004.
FIPS. Data Encryption Standard. Federal Information Processing Standards
Publication (46-3). 1999.
GONÇALVES, Leandro Salenave; RIBEIRO, Vinicius Gadis. Um Estudo
Comparativo entre algoritmos de criptografia DES – Lucifer (1977) e AES –
Rijndael (2000). Canoas, 2001. Faculdade de Informática – Universidade Luterana do
Brasil.
HANDSCHUH, Helena; Preneel, Bart. On the Security of Double and 2-key Triple
Modes of Operation. In: Fast Software Encryption, vol. 1636, pp. 215. SpringerVerlag, 1999.
HINZ, Marco Antônio Mielke. Um estudo descritivo de novos algoritmos de
criptografia. Pelotas, 2000. Monografia (Bacharelado em Informática) – Instituto de
Física e Matemática, Universidade Federal de Pelotas.
JASCONE, Fábio Luis Tavares. Protótipo de Software para Ocultar Texto
Criptografado em Imagens Digitais. Blumenau, 2003. Monografia (Bacharelado em
Ciência da Computação) – Centro de Ciências Exatas e Naturais – FURB –
Universidade Regional de Blumenau.
JILANI, Ibrahim; LI, Lan; SHI, Yixin. VHDL implementation of Data Encryption
Standard (DES). Chicago, 2003. ECE 567 Project Report – ECE Department – UIC –
University of Illinois at Chicago.
LAMBERT, Jorge. Criptoanalise por Entradas Invariantes. Rio de Janeiro, 2003.
Relatório Técnico – Departamento de Engenharia de Sistemas, Instituto Militar de
Engenharia.
MAO, Wenbo. Modern Cryptography: Theory and Practice. Upper Saddle River,
NJ: Prentice Hall PTR, 2003.
MORAES, Rosane França. Construção de um ambiente WEB com ferramentas
para estudo de algoritmos de criptografia através do Matlab. Rio de Janeiro, 2004.
Departamento de Eletrônica – Escola de Engenharia. UFRJ – Universidade Federal do
Rio de Janeiro.
PICONI, Andressa Cristiani; SUZUKI, Elcio Keniti; CAMARGO, Juliana Aparecida.
Algoritmo RSA. Campinas, 2004. Especialização em Redes de Computadores –
Instituto de Computação, UNICAMP – Universidade de Campinas.
35
SANTOS, Jorge Manuel Lopes. O uso de cifragem para protecção de canais
abertos. Portugal, 2002. Dissertação (Mestrado em Ensino da Matemática) –
Departamento de Matemática Pura – Faculdade de Ciências da UP – Universidade do
Porto.
TORRES, Gabriel. Redes de Computadores - Curso Completo. Rio de Janeiro, RJ:
Axcel Books, 2001.
VILELA, Henrique de Souza. Criptografia. Pelotas, 2003. Escola de Informática,
UCPEL – Universidade Católica de Pelotas.
WEBER, Raul Fernando. Criptografia Contêmporanea. Porto Alegre, 1995.
Instituto de Informática, UFRGS – Universidade Federal do Rio Grando do Sul.
36
APÊNDICE 1
Código fonte do sistema gerador de datagramas cifrados desenvolvido na
linguagem de programação C.
/*
* Sistema Gerador de Datagramas Cifrados
* Copyright (C) 2004 Fabiano R. Righetti - frighetti AT cascavel.pm.org
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Library General Public License for more details.
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
<stdio.h>
<stdlib.h>
<string.h>
<unistd.h>
<time.h>
<netdb.h>
<arpa/inet.h>
<sys/types.h>
<sys/socket.h>
<netinet/in.h>
<netinet/ip.h>
#include "des.h"
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
VERSION
TEMPO
PORTA
SRCADDR
IP_TCP
TH_FIN
TH_SYN
TH_RST
TH_PUSH
TH_ACK
TH_URG
DES3_DATASIZE
DES3_KEYSIZE
"0.1"
10
63221
0x7f000001 // 127.0.0.1
6
0x01
0x02
0x04
0x08
0x10
0x20
8
8
void
u_short
void
void
int
void
void
void
void
init_sockaddr(struct sockaddr_in *, const char *, int);
checksum(u_short *, u_short);
usage(const char *);
send_datagrams(char *, int, int, int);
open_rawsocket();
set_ip_header(struct sockaddr_in *);
set_tcp_header(struct sockaddr_in *);
init_datagram(const char *, struct sockaddr_in *);
triple_des_cipher(const char *);
static unsigned char DES3_DATA[DES3_DATASIZE] =
{
0x74, 0x65, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x6f // testando
};
static unsigned char DES3_KEY[3][DES3_KEYSIZE] =
{
{ 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
{ 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01 },
{ 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23 }
37
};
/*
* TCP header.
* Per RFC 793, September, 1981.
*
* Copyright (c) 1982, 1986 Regents
* All rights reserved.
*/
struct tcphdr {
u_short
th_sport;
u_short
th_dport;
u_int32_t
th_seq;
u_int32_t
th_ack;
#if __BYTE_ORDER == __LITTLE_ENDIAN
u_char
th_x2:4,
th_off:4;
#endif
#if __BYTE_ORDER == __BIG_ENDIAN
u_char
th_off:4,
th_x2:4;
#endif
u_char
th_flags;
u_short
th_win;
u_short
th_sum;
u_short
th_urp;
};
struct _header
{
struct in_addr
struct in_addr
u_char
u_char
u_short
} header;
struct _datagram
{
struct iphdr
struct tcphdr
char
} datagram;
of the University of California.
/*
/*
/*
/*
source port */
destination port */
sequence number */
acknowledgement number */
/* (unused) */
/* data offset */
/* data offset */
/* (unused) */
/* window */
/* checksum */
/* urgent pointer */
saddr;
daddr;
zero;
protocol;
length;
ipheader;
tcpheader;
data[DES3_DATASIZE];
struct _triple_des
{
char DATA[DES3_DATASIZE + 1];
} triple_des;
void
init_sockaddr(struct sockaddr_in *dst, const char *hostname, int port)
{
struct hostent
*host = NULL;
memset(dst, 0, sizeof(struct sockaddr_in));
dst->sin_family = PF_INET;
dst->sin_port
= htons(port);
if ((host = gethostbyname(hostname)) == NULL)
{
fprintf(stderr, "+ não foi possível resolver %s...\n",
hostname);
exit(EXIT_FAILURE);
}
memcpy(&dst->sin_addr, host->h_addr, host->h_length);
}
// Esta é uma referência da Internet do algoritmo de checksum.
u_short
checksum(u_short *data, u_short length)
{
register long value = 0.0;
u_short
i
= 0;
38
for (i = 0; i < (length >> 1); i++)
value += data[i];
if ((length & 1) == 1)
value += (data[i] << 8);
value = (value & 65535) + (value >> 16);
return(~value);
}
void
usage(const char *progname)
{
fprintf(stderr, "Mode de uso: %s [-cpt] <host|ip>\n"
" -c\t\tHabilitar cifragem com algoritmo "
"Triple-DES\n"
" -p <porta>\tPorta TCP do servidor.\n"
" -t <tempo>\tTempo total de envio de datagramas "
"em minutos. (default: %i)\n\n", progname, TEMPO);
exit(EXIT_FAILURE);
}
int
open_rawsocket()
{
int sock = 0;
if ((sock = socket(PF_INET, SOCK_RAW, IPPROTO_RAW)) == -1)
{
fprintf(stderr, "+ socket() error\n");
exit(EXIT_FAILURE);
}
return(sock);
}
void
triple_des_cipher(const char *data)
{
des3_context ctx3;
memset(triple_des.DATA,
0, DES3_DATASIZE + 1);
memcpy(triple_des.DATA, data, DES3_DATASIZE);
des3_set_3keys(&ctx3, DES3_KEY[0], DES3_KEY[1], DES3_KEY[2]);
des3_encrypt(&ctx3, triple_des.DATA, triple_des.DATA);
}
void
send_datagrams(char *host, int port, int tm, int cipher)
{
int
sock
= 0;
struct sockaddr_in dst;
int
until
= time(0) + (tm * 60);
char
data[DES3_DATASIZE + 1];
init_sockaddr(&dst, host, port);
sock = open_rawsocket();
fprintf(stderr, "+ stream inicializada!\n"
"+++ aguarde %d minutos...\n", tm);
memset(data,
0, DES3_DATASIZE + 1);
memcpy(data, DES3_DATA, DES3_DATASIZE);
while (time(0) <= until)
{
if (cipher == 1)
{
triple_des_cipher(data);
memcpy(data, triple_des.DATA, DES3_DATASIZE);
39
}
init_datagram(data, &dst);
if(sendto(sock, &datagram, sizeof(struct _datagram), 0,
(struct sockaddr *) &dst,
sizeof(struct sockaddr_in)) == -1)
{
fprintf(stderr,"+ couldn't send packet\n");
exit(EXIT_FAILURE);
}
}
close(sock);
fprintf(stderr,"+ stream finalizada!\n");
}
void
init_datagram(const char *data, struct sockaddr_in *dst)
{
memset(&datagram, 0, sizeof(struct _datagram));
memcpy(&datagram.data, data, DES3_DATASIZE);
set_ip_header(dst);
set_tcp_header(dst);
}
void
set_ip_header(struct sockaddr_in *dst)
{
datagram.ipheader.version
= IPVERSION;
datagram.ipheader.ihl
= sizeof(struct iphdr) >> 2;
datagram.ipheader.tos
= 0x00;
datagram.ipheader.tot_len
= htons(sizeof(struct _datagram));
datagram.ipheader.id
= htons(0x01);
datagram.ipheader.frag_off = htons(IP_DF); // Não fragmentar.
datagram.ipheader.ttl
= 0x40;
datagram.ipheader.protocol
= IP_TCP;
datagram.ipheader.check
= htons(0x00);
datagram.ipheader.saddr
= htonl(SRCADDR);
datagram.ipheader.daddr
= dst->sin_addr.s_addr;
}
void
set_tcp_header(struct sockaddr_in
{
datagram.tcpheader.th_sport =
datagram.tcpheader.th_dport =
datagram.tcpheader.th_seq
=
datagram.tcpheader.th_ack
=
datagram.tcpheader.th_off
=
datagram.tcpheader.th_flags =
datagram.tcpheader.th_win
=
datagram.tcpheader.th_urp
=
*dst)
dst->sin_port;
dst->sin_port;
0x00;
0x00;
sizeof(struct tcphdr) >> 2;
TH_SYN;
htons(0x01);
0x01;
memset(&header, 0, sizeof(struct _header));
header.saddr.s_addr
header.daddr.s_addr
header.zero
header.protocol
header.length
=
=
=
=
=
datagram.tcpheader.th_sum
= checksum((u_short *) &header,
sizeof(struct _header));
}
int
main(int argc, char *argv[])
{
int opt
= 0;
int port
= PORTA;
htonl(SRCADDR);
dst->sin_addr.s_addr;
0;
IP_TCP;
sizeof(struct tcphdr) +
DES3_DATASIZE;
40
int tm
int cipher
= TEMPO;
= 0;
fprintf(stdout, "Sistema Gerador de Datagramas Cifrados - v%s\n"
"Copyright (C) 2004 Fabiano R. Righetti - "
"frighetti AT cascavel.pm.org\n\n", VERSION);
if(argc < 2)
usage(argv[0]);
while((opt = getopt(argc, argv, "cp:t:")) != EOF)
{
switch(opt)
{
case 'c' : cipher = 1;
break;
case 'p' :
port = atoi(optarg);
if((port <= 0) || (port > 65535))
{
fprintf(stderr, "+ porta especificada é "
"inválida!\n");
return(EXIT_FAILURE);
}
break;
case 't' :
tm = atoi(optarg);
if((tm <= 0) || (tm > 60))
{
fprintf(stderr, "+ tempo especificado é "
"inválido!\n");
return(EXIT_FAILURE);
}
break;
default
usage(argv[0]);
break;
:
}
}
if(argv[optind] == NULL)
usage(argv[0]);
send_datagrams(argv[optind], port, tm, cipher);
return(EXIT_SUCCESS);
}