ANÁLISE DE BLOCOS DE ARQUIVOS CRIPTOGRAFADOS … · Gostaria de agradecer a toda minha família...

i

ANÁLISE DE BLOCOS DE ARQUIVOS

CRIPTOGRAFADOS PARA A OBTENÇÃO DO

ALGORITMO

Arthur Reimão Santos Figueiredo Vidal

Projeto de Graduação apresentado ao Curso de

Engenharia Eletrônica e de Computação da

Escola Politécnica, Universidade Federal do Rio

de Janeiro, como parte dos requisitos necessários

à obtenção do título de Engenheiro.

Orientador: Flávio Luis de Mello

Rio de Janeiro

Março de 2015

ii

ANÁLISE DE BLOCOS DE ARQUIVOS

CRIPTOGRAFADOS PARA A OBTENÇÃO DO

ALGORITMO


PROJETO DE GRADUAÇÃO APRESENTADO AO CURSO DE ENGENHARIA

ELETRÔNICA E DE COMPUTAÇÃO DA ESCOLA POLITÉCNICA, UNIVERSIDADE

FEDERAL DO RIO DE JANEIRO, COMO PARTE DOS REQUISITOS NECESSÁRIOS

À OBTENÇÃO DO TÍTULO DE ENGENHEIRO ELETRÔNICO E DE COMPUTAÇÃO.

Autor: _______________________________________________


Orientador: _______________________________________________

Flávio Luis de Mello, DSc

Examinador: _______________________________________________

Edilberto Strauss, Phd

Examinador: _______________________________________________

Sergio Genaro, MSc

Rio de Janeiro – RJ, Brasil

Março de 2015

iii

Agradecimentos

Gostaria de agradecer a toda minha família por todo apoio e amor e por

sempre acreditar em mim. Aos meus amigos de faculdade que me acompanharam

durante a graduação por todo o companheirismo, principalmente Bruno, Cristiano,

Ewerton, Felippe, Igor, Pedro, Rafael e o Timóteo. Aos meus amigos de fora da

faculdade Bernardo, Bruno e Felipe por me ajudarem a me distrair e pelos grandes

jogos de futebol.

Ao coordenador e orientador Casé, que sempre está disponível para fazer o

possível para ajudar os alunos e tirar dúvidas. E, finalmente, ao professor Flávio Mello

pela paciência e por ter me ajudado e orientado ao longo desse projeto.

iv

Resumo

Esse trabalho consiste na elaboração de um programa em Java que criptografa

arquivos e os divide em blocos baseado nos algoritmos, tamanho do bloco e chave de

criptografia definidos pelo usuário. Para isso foi criada uma interface gráfica simples e

intuitiva com instruções quando necessário. Após sua execução são criados dois

arquivos principais, um contendo a contagem dos blocos e o outro contendo possíveis

blocos com tamanho diferente do especificado, bem como os arquivos contendo cada

texto criptografado com o(s) algoritmo(s) escolhido(s).

Posteriormente é feita uma análise dos blocos, utilizando o arquivo gerado,

através de um programa de mineração de dados seguindo algumas regras pré-

definidas, para que se obtenha o algoritmo utilizado para cada arquivo com o menor

erro possível. Por fim, é realizada uma tentativa de classificação de documentos

criptografados utilizando o provador automático de teoremas chamado Witty.

Palavras-chave: Java, Criptografia, DES, RSA, RC4, Blowfish, WEKA, Mineração de

Dados, Eclipse

v

Abstract

This work is the development of software, in Java, that encrypts files and

divides them into blocks according to the algorithms, size of the block and the

cryptography key chosen by the user. For that purpose a simple and intuitive graphic

interface was made with instructions where utilization might be unclear. After its

execution two main files are created, one containing the count of blocks and the other

containing blocks smaller than the size set by the user, as well as one file for each text

for each algorithm previously chosen containing the cipher text.

Afterwards a block analysis is made, using the generated file, by a data mining

program, following some pre-defined rules, to discover which algorithm was used in

each file with minimum error. Lastly, we try to classify some encrypted documents

using an automatic theorem tester called Witty.

Key words: Java, Cryptography, DES, RSA, RC4, Blowfish, WEKA, Data Mining,

Eclipse

vi

Siglas

ANSI – American National Standards Institute

DEA – Data Encryption Algorithm

DES – Data Encryption Standard

GUI – Graphical User Interface

IDE – Integrated Development Environment

NSA – National Security Agency

OFB – Output Feedback

RC4 – Rivest Cipher 4

RSA – Iniciais dos criadores do algoritmo, Ron Rivest, Adi Shamir e Leonard Adleman

RSADSI – RSA Data Security, Inc

WEKA – Waikato Environment for Knowledge Analysis

vii

Índice

1. Introdução .................................................................................. 1

1.1. Tema .................................................................................... 1

1.2. Justificativa ........................................................................... 1

1.3. Objetivos .............................................................................. 1

1.4. Metodologia .......................................................................... 2

1.5. Descrição ............................................................................. 2

2. Criptografia ................................................................................ 3

2.1. DES ...................................................................................... 4

2.2. Blowfish ................................................................................ 7

2.3. RC4 ...................................................................................... 9

2.4. RSA .................................................................................... 11

3. Protótipo .................................................................................. 12

3.1. Eclipse................................................................................ 13

3.2 Ferramenta de Encriptação ................................................ 15

3.3. WEKA ................................................................................ 17

3.4. Mineração de Dados .......................................................... 18

3.5 Testes de validação ........................................................... 22

4. Conclusão ................................................................................ 26

5. Bibliografia ............................................................................... 27

Anexo 1 – Regras obtidas no WEKA. ............................................ 28

Anexo 2 – Tabela de acerto dos classificadores do WEKA ......... 120

1

1. Introdução

1.1. Tema

O tema do trabalho é a análise de arquivos criptografados divididos em blocos

de tamanho pré-definidos com a finalidade de obter o algoritmo usado na criptografia.

Neste sentido, o problema é o desenvolvimento de um protótipo computacional capaz

de identificar um algoritmo criptográfico a partir de um criptograma.

1.2. Justificativa

Este trabalho possibilitou uma pequena experiência em gerência de projetos e

desenvolvimento de sistemas, utilizando diversos conceitos apresentados ao longo do

curso. Ele é extremamente útil para a segurança da informação, uma área

extremamente sensível e com importância cada vez maior.

Por conta de a tecnologia estar cada vez mais presente no dia-a-dia da

população, é importante sempre ter confiança na segurança da comunicação. Assim, é

essencial estar sempre estudando sobre as possibilidades de se obter a menor

informação que possibilite uma falha de segurança. Esse trabalho visa estudar um

modo de se obter o algoritmo de criptografia utilizado em um texto, o que facilitaria a

descoberta da informação daquele texto e acarretaria em uma falha de segurança.

1.3. Objetivos

O objetivo principal é criar um protótipo para obter o algoritmo utilizado na

criptografia de um arquivo através da análise de blocos com mesmo tamanho em bits.

Desta forma, os seguintes objetivos específicos devem ser atingidos:

- Escolher e estudar os algoritmos de criptografia que serão utilizados;

- Utilizar o Eclipse como plataforma de desenvolvimento Java para a criação do

protótipo;

- Dividir os textos cifrados em blocos e escrevê-los em arquivos com um

cabeçalho pré-definido para a análise no software WEKA.

2

- Fazer a análise, gerar regras para a escolha do algoritmo e utilizar essas

regras para classificar novos textos.

1.4. Metodologia

Para atender ao objetivo, foi criado um programa em Java para criptografar 100

textos de cada língua (inglês, espanhol e português) em quatro algoritmos pré-

definidos (DES, RC4, Blowfish e RSA) e dividi-los em blocos. A segunda etapa foi

utilizar um programa de mineração de dados capaz de criar uma árvore de decisões

que classificasse cada arquivo no algoritmo correspondente, baseado na contagem de

blocos iguais. Nele também é possível obter informações importantes para a análise,

como erro, estatística Kappa, entre outras. Por fim, utilizou-se um provador de

teoremas para verificar a desempenho das regras obtidas através da análise.

1.5. Descrição

Esse trabalho foi feito de forma que o leitor possa acompanhar seu

desenvolvimento, levando em conta as dificuldades e as decisões tomadas para

superá-las. Nesse primeiro capítulo será feita uma introdução geral sobre o projeto e

sobre sua inserção na engenharia eletrônica e de computação.

Levando em conta que o projeto envolve em sua grande parte criptografia,

esse será o primeiro assunto a ser discutido no capítulo 2. Nele será destacada a

importância dessa área com enfoque nos quatro algoritmos utilizados: DES, Blowfish,

RC4 e RSA, cada um com uma forma de funcionamento distinta.

No capítulo 3 serão explicadas todas as etapas para a criação do protótipo,

desde a apresentação da principal ferramenta de desenvolvimento do projeto, o

eclipse, até a análise no WEKA e a utilização das regras geradas através dela.

Também será mostrada a interface da ferramenta de encriptação criada e dos diversos

softwares utilizados e sua interatividade com o usuário.

Por fim, no capítulo 4 serão apresentados os resultados, como a taxa de acerto

na identificação do algoritmo, e conclusões acerca do projeto e trabalhos futuros.

3

2. Criptografia

O estudo de manter mensagens seguras é chamado de criptografia e é

praticado por criptógrafos. Do mesmo modo, existe a criptoanálise, a arte de tentar

descobrir o texto cifrado ou a lógica de sua encriptação. Os dois estão sempre em

desenvolvimento contínuo, porém nesse trabalho focaremos apenas no primeiro.

Qualquer tipo de informação pode ser transformado para se tornar seguro,

sejam fluxos de bits, uma imagem, um vídeo, um arquivo de texto (utilizado neste

trabalho), dentre outros. Para o computador, todos esses casos são simplesmente

dados binários. Depois de criptografado, o texto cifrado também é composto de dados

binários e seu comprimento pode ser alterado de acordo com o modo em que foi

encriptado. Seja a informação original “𝑀”, de mensagem, o texto cifrado “𝐶”, a função

de criptografia “𝐸” e a função de descriptografia “𝐷”, temos que a seguinte equação

precisa ser verdadeira:

𝐷(𝐸(𝑀)) = 𝑀 , porque 𝐸(𝑀) = 𝐶 e 𝐷(𝐶) = 𝑀.

Além de prover confidencialidade, a criptografia também deve possibilitar o

receptor da mensagem de ter certeza de sua origem, possibilitar o receptor de verificar

que a mensagem não foi modificada durante o envio e negar a possibilidade do

transmissor da mensagem de mentir sobre seu envio. Isso evita a intervenção de um

intruso na comunicação e é vital para interações via computadores.

Um algoritmo de criptografia, também chamado de cifra, é uma função

matemática usada para encriptação e decriptação. Além disso, se a segurança de um

algoritmo é baseada em manter seu modo de funcionamento em segredo, ele é

chamado de algoritmo restrito. Contudo, estes estão ultrapassados e são

extremamente inadequados para os dias de hoje devido a um grande grupo, ou um

grupo que esteja em constante mudança, não poder utilizá-los. O menor vazamento de

informações, ou a saída de um integrante, deve resultar na mudança do algoritmo para

manter a segurança da informação.

A criptografia moderna resolve esse problema com uma chave “𝐾” (do inglês

“key”), que pode ter inúmeros valores. Assim, a chave é usada tanto para obter o texto

cifrado, como para retorná-lo à mensagem original e toda a segurança fica baseada na

4

chave (ou chaves). Isso possibilita a publicação e a análise do algoritmo expondo suas

falhas.

Existem basicamente dois tipos de algoritmos baseados em chave: os

simétricos e os de chave pública. No primeiro, chamado também de algoritmos

convencionais, a chave de encriptação pode ser calculada através da chave de

decriptação e vice-versa. Na maioria das vezes, ambas são iguais para este tipo. O

segredo da comunicação com esse algoritmo é a chave, enquanto a chave

permanecer secreta a informação será secreta. Assim, o transmissor e o receptor

combinam uma chave antes, para se comunicar em segurança.

Os algoritmos simétricos ainda podem ser divididos em outras duas categorias.

Alguns modificam a mensagem bit a bit, ou byte a byte, e são chamados de algoritmos

ou cifras de fluxo. Outras alteram a mensagem em grupos de bits, ou seja, blocos. Por

isso, chamamos de algoritmos ou cifras de bloco.

Já os algoritmos de chave pública, ou algoritmos assimétricos, são criados para

que a chave usada na encriptação seja diferente daquela usada na decriptação, e

ainda, uma chave não pode ser calculada através da outra. Assim, qualquer um pode

saber a chave de encriptação, mas somente uma pessoa com a chave correspondente

à cifra criada que poderá descriptografar a mensagem e daí vem o nome. Nesse

sistema a chave para criptografar é chamada de chave pública e a chave para realizar

a operação inversa é chamada de chave privada ou chave secreta.

Como citado anteriormente, a criptoanálise está sempre acompanhando a

evolução da criptografia. Porém, como esse trabalho não envolve retornar uma cifra

para o texto original, deixamos o aprofundamento desde assunto para o leitor, caso

tenha curiosidade ou ache necessário. Ao invés disso, será explicado o funcionamento

de cada algoritmo utilizado no projeto.

2.1. DES

O DES, conhecido como “Data Encryption Algorithm” (DEA) pela ANSI e como

DEA-1 pela ISO foi um padrão mundial por 20 anos. Embora esteja mostrando sinais

de estar ficando velho, ele aguentou excepcionalmente bem contra anos de analistas

criptográficos e só não é seguro contra os adversários mais poderosos.

5

No começo dos anos 70, a pesquisa criptográfica era casual e haviam

pouquíssimos documentos publicados na área. Por mais que se soubesse da

utilização de equipamentos especiais de codificação utilizados pelo exército, poucos

entendiam seu funcionamento. Assim, a escassez desse conhecimento fazia que a

criptografia nos produtos fosse diferente e tornava impossível a operação entre eles.

Por esse motivo, a National Bureau of Standards (NBS) iniciou um programa para

proteger dados de comunicação e de computadores. Para isso iniciou o

desenvolvimento de um algoritmo criptográfico padrão.

Os critérios eram que o algoritmo deveria fornecer um alto nível de segurança,

deveria ser completamente especificado e de fácil compreensão, deveria ter a

segurança através da chave e não do algoritmo, deveria ser público, deveria ser

adaptável para diversas aplicações, deveria ser economicamente viável para ser

implementado em dispositivos eletrônicos, deveria ser eficiente, deveria poder ser

validado e deveria ser exportável.

Assim, baseado em um algoritmo desenvolvido pela IBM e avaliado pela NSA,

surgiu o DES.

O DES é uma cifra de bloco simétrica que criptografa em blocos de 64 bits. A

chave utilizada por ele é de 56 bits e pode ser alterada a qualquer hora. A chave pode

ser qualquer combinação de caracteres, porém recomenda-se evitar combinações

óbvias, já que a segurança só depende dela.

De modo geral, o algoritmo é uma combinação de duas técnicas básicas de

criptografia, confusão e difusão. A construção de um bloco fundamental do DES é uma

utilização dessas técnicas no texto, baseado na chave. Isso é chamado de ciclo. A

cifra realiza 16 ciclos, repetindo a mesma combinação de técnicas.

Para explicar seu funcionamento, suponhamos que ele opera em um bloco de

mensagem de 64 bits. Após uma permutação inicial o bloco é quebrado em duas

partes, cada uma com 32 bits, chamadas de metade esquerda e metade direita. Então

acontecem os 16 ciclos de operações idênticas, chamadas de função Feistel (𝑓), nas

quais os dados são combinados com a chave. Logo após, as duas metades são

unidas novamente e ocorre um ultima permutação, que é o inverso da primeira, como

é mostrado na figura 2.1.

Em cada ciclo, os bits da chave são deslocados e 48 dos 56 bits são

selecionados. A metade da direita dos dados é expandida para 48 bits através de uma

permutação expansiva, é combinada com 48 bits de uma chave deslocada e

6

permutada via XOR, é mandada através de oito blocos de substituição produzindo 32

novos bits e é permutada novamente. Essas quatro operações constituem a função 𝑓.

A saída dessa função é combinada com a metade esquerda via XOR e o resultado se

torna a nova metade direita, com a antiga metade direita se tornando a nova metade

esquerda, encerrando um ciclo.

Se 𝐵𝑖 é o resultado da 𝑖-ésima iteração, 𝐿𝑖 e 𝑅𝑖 são, respectivamente, as

metades esquerda e direita de 𝐵𝑖, 𝐾𝑖 é a chave de 48 bits para o ciclo 𝑖 e 𝑓 é a função,

então a equação do ciclo fica:

𝐿𝑖 = 𝑅𝑖−1

𝑅𝑖 = 𝐿𝑖−1 ⊕ 𝑓(𝑅𝑖−1, 𝐾𝑖)

Figura 2.1 – Esquema do algoritmo DES

Para o esse trabalho, no entanto, foi utilizada um pacote já existente no Java,

chamado “crypto” [1]. Nela estão incluídas classes e funções necessárias para tornar

7

uma chave inserida pelo usuário utilizável para a classe bem como a função para

criptografar em DES. De fato, essa biblioteca será utilizada para todos os algoritmos

desde trabalho.

Figura 2.2 – Algoritmo de criptografia DES em Java

Primeiramente é criado o objeto “DESKeySpec” que pega os primeiros 8 bytes

da chave, para poderem ser utilizados na criptografia. Em seguida, é criado o objeto

SecretKeyFactory que será utilizado para modificar os bytes da chave que foram

pegos para poderem ser utilizados no algoritmo. Em seguida é criada a cifra para DES

ela é iniciada no modo de criptografia com a chave modificada. Então, é criado um

fluxo de dados contendo o texto cifrado. A função “doCopy” simplesmente copia o

texto cifrado para o arquivo de destino e a função “bitBlocks” é utilizada para separar

esse texto em blocos, o que será explicado mais a frente.

2.2. Blowfish

O Blowfish é um algoritmo criado por Bruce Schneier para ser implantado em

grandes microprocessadores. Ele foi criado para atender os seguintes critérios: ser

rápido, o algoritmo criptografa dados em um microprocessador de 32 bits a 26 ciclos

de clock por byte (o que era bastante na época), ser compacto, ele pode rodar em

menos de 5K de memória, ser simples, a cifra usa apenas operações simples como

adições e XORs, o que a torna resistente a erros de implementação, e ter segurança

variável, o Blowfish possui chave com tamanho variável e pode ter até 448 bits.

O Blowfish é um algoritmo de blocos de 64 bits com chave variável, como

citado anteriormente. Ele consiste em duas etapas expansão da chave, que a converte

em várias matrizes de subchaves totalizando 4168 bytes, e criptografia de dados, que

consiste numa função simples realizada 16 vezes. Cada realização consiste em uma

permutação dependente da chave e em uma substituição dependente da chave e dos

dados. Como é utilizado um grande número de subchaves, elas devem ser calculadas

8

antes de qualquer criptografia ou descriptografia. A matriz 𝑃 é composta de 18

subchaves de 32 bits.

Figura 2.3 – Esquema do Blowfish

Na figura 2.3 temos o esquema do algoritmo do Blowfish. Ele nada mais é do

que uma rede de Feistel de 16 ciclos. Considerando dados de 64 bits, chamados de 𝑥,

para criptografar primeiramente dividimos 𝑥 pela metade. Assim, para cada ciclo

fazemos:

𝑥𝐿 = 𝑥𝐿 ⊕ 𝑃𝑖

𝑥𝑅 = 𝑓(𝑥𝐿) ⊕ 𝑥𝑅

E então trocar 𝑥𝐿 por 𝑥𝑅.

9

Nas equações 𝑖 é o número do ciclo, 𝑥𝐿 é a metade da esquerda, 𝑥𝑅 é a

metade da direita e 𝑓 é a função de Feistel. Após o último ciclo, temos que trocar 𝑥𝐿

por 𝑥𝑅 novamente e fazer:

𝑥𝑅 = 𝑥𝑅 ⊕ 𝑃17

𝑥𝐿 = 𝑥𝐿 ⊕ 𝑃18

E recombinar as metades. Para a função de Feistel, dividimos 𝑥𝐿 em quatro

partes iguais, 𝑎, 𝑏, 𝑐 e 𝑑 e fazemos:

𝑓(𝑥𝐿) = ((𝑆1,𝑎 + 𝑆2,𝑏 𝑚𝑜𝑑 232) ⊕ 𝑆3,𝑐) + 𝑆4,𝑑 𝑚𝑜𝑑 232

Onde S são os blocos de substituição. Na figura 2.4 está esquematizada a

função de Feistel.

Figura 2.4 – Função 𝑓

No programa criado para este trabalho, a implementação é praticamente

idêntica à realizada com o DES. A única diferença é que os objetos são instanciados

para o Blowfish. Porém, na execução do programa estava acontecendo um problema

caso a chave fosse maior do que 16 bytes. O Java vem, por padrão, com limite no

tamanho das chaves de criptografia para alguns algoritmos, incluindo esse e o RC4.

Assim, a solução foi modificar um arquivo de licença do Java, para poder utilizar os

algoritmos plenamente.

2.3. RC4

O RC4 é uma cifra de fluxo com tamanho de chave variável desenvolvida por

Ron Rivest em 1987. Durante sete anos ela ficou em segredo, ficando acessível

10

apenas para quem assinasse um acordo de não divulgação. Até que uma pessoa

anônima postou o código fonte em uma lista de e-mail e, apesar da tentativa de

contenção do segredo, o algoritmo se espalhou e foi rapidamente discutido e

estudado.

O algoritmo é fácil de descrever, ele trabalha em OFB, o fluxo principal é

independente da mensagem. Ele tem um bloco S variando de 0 a 255 e as entradas

são uma permutação desses números. A permutação é em função da chave de

tamanho variável e a cifra ainda possui dois contadores, 𝑖 e 𝑗, ambos inicializados em

zero. Para gerar um byte aleatório fazemos:

𝑖 = (𝑖 + 1) 𝑚𝑜𝑑 256

𝑗 = (𝑗 + 𝑆𝑖) 𝑚𝑜𝑑 256

Troca 𝑆𝑖 com 𝑆𝑗.

𝑡 = (𝑆𝑖 + 𝑆𝑗) 𝑚𝑜𝑑 256

𝐾 = 𝑆𝑡

Então é feito um XOR do byte 𝐾 com a mensagem para produzir o texto cifrado

ou o inverso. A criptografia é rápida, mais ou menos dez vezes mais rápida que a do

DES [2]. Na figura 2.5 temos o esquema do algoritmo.

Figura 2.5 – Esquema do RC4

Inicializar o bloco S também é fácil. Primeiro preenchemos ele linearmente de 0

a 255. Então, criamos outra matriz, de mesmo tamanho, e a preenchemos com a

chave, repetindo se for necessário. Inicializamos 𝑗 em zero e variando 𝑖 de 0 a 255

fazemos:

𝑗 = (𝑗 + 𝑆𝑖 + 𝐾𝑖) 𝑚𝑜𝑑 256

11

realizando a troca de 𝑆𝑖 com 𝑆𝑗 para cada variação de 𝑖. Assim, o algoritmo está

completo. A RSADSI alega que o algoritmo é imune a qualquer criptoanálise linear e

diferencial, já que ele possui nenhum ciclo pequeno e é altamente não linear.

Para ser implementado no programa desse projeto, mesmo sendo um

algoritmo bem diferente dos anteriores, utilizou-se o mesmo código já mostrado

anteriormente. Como foi dito, a biblioteca “crypto” do Java é bem abrangente, portanto

a implementação foi a mesma, somente instanciando aonde é necessário para RC4.

No entanto, como citado na parte anterior, o RC4 sofreu do mesmo problema de

execução que o Blowfish e foi corrigido da mesma maneira.

2.4. RSA

O RSA foi a primeira cifra de chave pública desenvolvida e é de longe a mais

fácil de entender e de implementar deste tipo. Ela é também a mais popular, tendo

aguentado anos de criptoanálises.

Esse algoritmo tem sua segurança na dificuldade de fatoração de grandes

números. As chaves pública e privada são funções de um par de números primos de

mais de 100 dígitos. Recuperar a mensagem através da chave pública e do texto

cifrado é o mesmo que a fatoração desses dois números.

Para criar as chaves, escolhemos dois números primos grandes, 𝑝 e 𝑞. Para

maior segurança os dois devem ter o mesmo tamanho. Assim:

𝑛 = 𝑝𝑞

Então, escolhemos uma chave de criptografia aleatória, 𝑒, tal que ela e

(𝑝 − 1)(𝑞 − 1) sejam primos entre si. Finalmente, usamos o algoritmo Euclidiano

estendido para calcular a chave de descriptografia, 𝑑.

𝑒𝑑 ≡ 1 𝑚𝑜𝑑 ((𝑝 − 1)(𝑞 − 1)) ou

𝑑 = 𝑒−1 𝑚𝑜𝑑 ((𝑝 − 1)(𝑞 − 1))

Assim, 𝑑 e 𝑛 também são primos entre si. Os números 𝑒 e 𝑛 são a chave

pública e 𝑑 é a chave privada. Os números primos 𝑝 e 𝑞 não serão mais necessários,

eles podem ser descartados, mas nunca revelados.

12

Para criptografar uma mensagem 𝑚, primeiro devemos dividi-la em blocos

menores do que 𝑛. A mensagem cifrada, 𝑐, será constituída de blocos de tamanhos

similares, 𝑐𝑖. A fórmula é simplesmente:

𝑐𝑖 = 𝑚𝑖𝑒 𝑚𝑜𝑑 𝑛

Tanto para hardware quanto para software o RSA é mais lento que o DES.

Mesmo com todas as mudanças da tecnologia que aconteceram desde sua criação e

as que ainda estão por vir, essa situação nunca se reverterá.

Para incluir esse algoritmo no programa deste projeto foi mais complicado.

Além da forma das chaves serem calculadas impossibilitar um uso direto da chave

digitada pelo usuário, o fato de que o texto deve ser menor do que ela levou a algumas

mudanças no código. Assim, a chave utilizada pelo usuário é utilizada para inicializar o

gerador de chaves e a partir daí obtemos a chave pública. Como o texto de cada

arquivo era grande o suficiente para ser maior que a chave, foi necessário um ajuste

no código para dividir o texto em blocos para, então, poder criptografá-lo.

Assim, estão listados todos os algoritmos utilizados nesse trabalho. Procurou-

se trabalhar com cifras conhecidas e de diferentes tipos para obter resultados e

conclusões mais concretas.

3. Protótipo

Com a tecnologia fazendo cada vez mais parte da vida do ser humano a

necessidade de proteção e segurança da informação está ganhando ainda mais

importância.

O protótipo desse projeto visa verificar e confirmar a existência de padrões de

bits na criptografia dos algoritmos citados no capítulo anterior, o que poderia ser

explorado para a obtenção de informações confidenciais.

Nesse capítulo será esclarecido como o protótipo foi construído, demonstrando

as principais ferramentas utilizadas e os métodos para a obtenção e identificação dos

padrões de bits.

13

3.1. Eclipse

No início do projeto, juntamente com a escolha dos algoritmos, foi discutido

qual seria a melhor linguagem ou plataforma para o desenvolvimento do projeto.

Decidiu-se usar o Eclipse [3], uma IDE que gera código Java, por sua grande gama de

possibilidades e pela facilidade que ele proporciona para realizar o proposto pelo

projeto. Nesse capítulo serão mostradas as funções dessa plataforma e seu

funcionamento.

Uma IDE é um ambiente voltado para auxiliar para um rápido desenvolvimento

de aplicativos para aumentar a produtividade de desenvolvedores. Nele estão

incluídas diversas ferramentas que são necessárias para a criação de códigos como

um editor, um compilador, um depurador, dentre outras. O Eclipse chega a ser mais do

que uma IDE, pode-se dizer que ele é uma plataforma de desenvolvimento que é

genérico o suficiente para atender a várias outras linguagens além do Java. Além de

conter as ferramentas citadas anteriormente, o Eclipse também ajuda o desenvolvedor

em tempo real, identificando e dando sugestões para corrigir erros que impeçam a

execução do código.

Na figura 3.1, temos a tela de desenvolvimento do Eclipse. Na janela da

esquerda temos a parte de projetos, sendo possível ter vários projetos independentes

abertos simultaneamente. A janela do meio, em cinza, é a área de trabalho. É nela que

podemos criar ou alterar códigos bem como usar algumas aplicações do eclipse. A

janela inferior é onde estão a aba da console e a aba de problemas. Essas três são as

principais e mais básicas áreas do eclipse e serão utilizadas em todos os projetos.

Um projeto Java é uma estrutura de diretórios onde são armazenados os

códigos-fonte. A parte principal é o “src/” contendo o todo o necessário para a

Aplicação. A partir dessa parte principal podem ser criados vários pacotes, que são

diretórios que agrupam arquivos de um determinado tipo ou funcionalidade.

14

Figura 3.1 – Tela Principal do Eclipse

Nesse projeto foi utilizada também uma aplicação criada para o Eclipse

chamada Window Builder [4], que permite montar um design simples e rápido de uma

janela gráfica. Ela funciona a partir do “JFrame”, que é a janela propriamente dita com

título e os botões de minimizar, maximizar e fechar. A partir daí, é possível inserir

componentes apenas arrastando eles para a janela e a customização é toda feita

através da aplicação, o código é gerado automaticamente. Na figura 3.2 podemos ver

a janela do início da criação de uma aplicação utilizando o Window Builder. Nela é

possível definir nomes, definir tamanhos, customizar a janela de diversos modos.

Também podemos escolher o nome da variável que será gerada automaticamente e

definir ações para alguns botões caso haja interação entre eles.

15

Figura 3.2 – Janela de desenvolvimento do Window Builder

3.2 Ferramenta de Encriptação

O Window Builder foi a base desse projeto. Todo o código foi gerado por ele ou

a partir dele. A tela foi toda montada arrastando os botões e as listas e os organizando

no “JFrame” de acordo com o layout combinado. A figura 3.3 mostra o resultado final.

Para o programa funcionar deveremos escolher os arquivos que serão

criptografados, escolher os algoritmos que são utilizados, digitar o tamanho dos blocos

em bits e digitar a chave que será utilizada. Para selecionar o arquivo, é só clicar no

botão indicado que irá abrir uma janela padrão de acordo com o sistema operacional

que está sendo utilizado. A partir daí é só selecionar um ou múltiplos arquivos para

serem criptografado e eles serão listados na caixa logo abaixo do botão. É importante

notar que a seleção não é cumulativa, ou seja, todos os arquivos deverão ser

escolhidos de uma só vez. Caso contrário, a nova seleção sobrescreverá a seleção

anterior. A seleção do algoritmo é semelhante, porém eles já estão listados em uma

tabela e é só escolher e clicar no botão. Do mesmo modo que na escolha dos

arquivos, cada nova escolha sobrescreverá a anterior.

Por fim, é só digitar o número do tamanho do bloco em bits e a chave que será

utilizada nos seus respectivos campos. É importante notar que, como o algoritmo do

16

DES aceita chaves de no máximo oito bytes, caso a chave digitada seja maior do que

isso, somente serão usados seus oito primeiros bytes. Somente após todos os campos

serem preenchidos que, ao clicar no botão “Criptografar”, o programa será executado.

Caso alguma informação não tenha sido preenchida o programa para e é exibida uma

janela lembrando o usuário do campo que está em branco.

Figura 3.3 – Janela do programa desenvolvido

Após clicar em criptografar o programa realmente começa a funcionar.

Primeiro, ele pega todas as informações preenchidas e as utiliza para criptografar os

arquivos, conforme foi mostrado no capítulo anterior. Para cada arquivo e para cada

algoritmo é criado um novo arquivo “.txt” no mesmo diretório e contendo em seu nome

o nome do arquivo original, o algoritmo utilizado, a chave e seu tamanho. Após a

criptografia, o texto cifrado é dividido em blocos de bits, com tamanho definido pelo

usuário, que são salvos em um “HashMap” para que possa ser contada a quantidade

de cada bloco diferente. Depois da contagem o “HashMap” de cada arquivo é escrito

17

em um outro arquivo com um cabeçalho próprio para ser entendido no programa de

mineração de dados. Nessa etapa a contagem é normalizada para que a diferença no

número de caracteres de cada texto não influencie na próxima etapa e é descartado o

bloco com tamanho diferente do definido, caso haja. Como existe no máximo um bloco

deste tipo, caso a divisão do número de bits no arquivo pelo número de bits não tenha

resto zero, não há problema em não utilizá-lo na análise posteriormente. Ele será

apenas um dentre milhares e não influenciará no resultado final. Esse bloco é salvo

em um arquivo à parte chamado resíduo.

Ao término de todo processamento, ficamos então com um arquivo contendo a

contagem de todos os blocos de todos os arquivos com texto cifrado, um arquivo de

resíduo. Estamos prontos para avançar para a etapa de análise e ver se através da

quantidade de certos blocos é possível descobrir o algoritmo usado naquele texto.

3.3. WEKA

O WEKA [5] é um software de aprendizagem da máquina gratuito desenvolvido

em Java pela universidade de Waikato. Ele contém uma variedade de ferramentas de

visualização, algoritmos para analise de dados e uma GUI para um fácil acesso as

suas funcionalidades. Suas principais vantagens são: ser gratuito, funcionar em

praticamente todos os sistemas operacionais modernos, uma boa coleção de dados

de pré-processamento e técnicas de modelagem e a facilidade de uso. Ele suporta

diversas tarefas padrões de mineração de dados e suas técnicas não baseadas na

suposição de que os dados estão disponíveis em um único arquivo ou relação, onde

cada ponto é descrito por um número fixo de atributos. O WEKA também permite

acesso ao banco de dados SQL e pode processar o resultado de uma query.

A principal interface do programa, que também foi a utilizada neste projeto, é o

“Explorer” que permite acesso aos principais componentes da plataforma como o

painel de pré-processamento e o painel de classificação, os dois utilizados neste

trabalho. O primeiro é o início de qualquer análise sendo possível importar dados de

arquivos ou bancos de dados e pré-processa-los usando algoritmos de filtragem, que

podem alterar os dados e apagar instâncias e atributos de acordo com certos critérios.

Nessa etapa que importamos o arquivo contendo o cabeçalho e a contagem de bloco

para cada texto para fazermos sua análise. Na figura 3.4 temos a imagem da interface

do WEKA e do painel de pré-processamento.

18

Figura 3.4 – Painel de pré-processamento do WEKA Explorer

O painel de classificação permite utilizar algoritmos de classificação e

regressão, chamados de classificadores no WEKA, no conjunto de dados obtidos no

painel de pré-processamento para estimar precisão do respectivo modelo escolhido e

visualizar escolhas errôneas ou o próprio modelo, caso seja uma árvore de decisões,

por exemplo.

3.4. Mineração de Dados

Para a análise nesse trabalho foram criptografados, de acordo com o descrito

no capitulo anterior 100 arquivos de três idiomas diferentes, espanhol, inglês e

português. Para verificar a influência do tamanho do bloco no resultado, eles foram

criptografados para tamanhos de blocos de 2, 4, 8 e 16 bits, obtendo um total de 12

arquivos para análise. Em seguida eles foram importados pela aba de pré-

processamento e foram aplicados diversos algoritmos de classificação, estudando o

desempenho de cada um e visualizando a árvore de decisões dos melhores.

Neste sentido, foi verificado o desempenho de todos os classificadores

contidos no programa, porém só foram estudados os que tiveram melhor desempenho,

levando em conta não só a taxa de acerto, mas também o erro médio absoluto e mais

19

alguns dados. Foram escolhidos classificadores que tivessem um erro médio absoluto

abaixo de 15% por exemplo, mas a maioria deles ficava entre 2% e 5%. Os

classificadores J48 e PART foram os mais estáveis mantendo o erro médio absoluto

sempre abaixo de 3% e 4% respectivamente.

Além disso, foi verificada também a estatística Kappa. Kappa é uma medida de

possibilidade corrigida de concordância entre as classificações e as verdadeiras

classes. Ela é calculada subtraindo a concordância ao acaso da concordância

observada e dividindo pela maior concordância possível. Um valor maior que zero

significa que o classificador está com um desempenho melhor do que uma escolha ao

acaso e isso também foi um critério na escolha dos classificadores.

Além disso, também foram retirados da análise classificadores com alta taxa de

acerto que não possibilitavam a visualização das regras de classificação. Desta forma,

foram selecionados quatro algoritmos, a saber - Attribute Selected Classifier [6],

Filtered Classifier [7], PART [8] e J48[9].

Após a verificação do aproveitamento e a escolha dos classificadores, foram

retiradas todas as regras para acertos superiores a 90% (valor empírico). As tabelas

3.1, 3.2, 3.3 e 3.4 apresentam de forma organizada as regras obtidas para cada

classificador segundo os algoritmos de encriptação e idioma. As regras não estão

explícitas nas tabelas por serem muito extensas.

A regra R1, por exemplo, é “if Bloco11101001(*a) and <=(*a,0.46263) and

Bloco11100010(*b) and <=(*b,0.27126) and Bloco11000010(*c) and >(*c,0.467611)

then algoritmo(DES)” e é uma das menores. No anexo 1 se encontram todas as regras

escritas, do mesmo modo do exemplo citado, já prontas para serem utilizadas no teste

de validação. A expressão “(*a)” é a forma de declarar uma variável no Witty, o

programa utilizado para o teste de validação que será explicado na próxima sessão.

20

Tabela 3.1: Regras obtidas a partir da mineração de dados para o algoritmo DES.

Tabela 3.2: Regras obtidas a partir da mineração de dados para o algoritmo Blowfish.

Attribute

PART

J48

EN

DES

R1, R2, R3, R4, R5, R6, R7, R8, R9,

R10, R11, R12, R13, R14, R15, R16,

R17, R18, R19, R20, R21, R22, R23

R24, R25, R26, R27, R28, R29, R30,

R31, R32, R33, R34, R35, R36, R37

R38, R39, R40, R41, R42, R43, R44,

R45, R46, R47, R48, R49, R50, R51,

R52, R53, R54, R55, R56, R57, R58,

R59, R60, R61, R62, R63, R64, R65,

R66, R67, R68, R69, R70, R71, R72,

R73, R74, R75, R76, R77, R78, R79,

R80, R81, R82, R83, R84, R85, R86,

R87

PT

R269, R270, R271, R272, R273, R274,

R275, R276, R277, R278, R279, R280,

R281, R282, R283, R284, R285, R286,

R287, R288, R289, R290, R291, R292,

R293, R294, R295

R296, R297, R298, R299, R300, R301,

R302, R303, R304, R305, R306, R307,

R308, R309, R310, R311, R312, R313,

R314, R315, R316, R317, R318, R319,

R320, R321, R322, R323, R324, R325,

R326, R327

R328, R329, R330, R331, R332, R333,

R334, R335, R336, R337, R338, R339,

R340, R341, R342, R343, R344, R345,

R346, R347, R348, R349, R350, R351,

R352, R353, R354, R355, R356

SP

R574, R575, R576, R577, R578, R579,

R580, R581, R582, R583, R584, R585,

R586, R587, R588, R589, R590, R591,

R592, R593, R594, R595, R596, R597,

R598, R599, R600, R601, R602, R603,

R604, R605, R606, R607

R608, R609, R610, R611, R612, R613,

R614, R615, R616, R617, R618, R619,

R620, R621, R622, R623, R624, R625,

R626, R627, R628, R629, R630, R631,

R632, R633, R634, R635, R636, R637,

R638, R639, R640, R641, R642, R643,

R644, R645, R646, R647, R648, R649,

R650, R651, R652, R653, R654, R655,

R656

EN

Attribute

PART

Blowfish

J48

R127, R128, R129, R130, R131, R132,

R133, R134, R135, R136, R137, R138,

R139, R140, R141, R142, R143, R144,

R145, R146

R411, R412, R413, R414, R415, R416,

R417, R418, R419, R420, R421, R422,

R423, R424, R425, R426, R427, R428,

R429, R430, R431, R432, R433, R434,

R435, R436, R437, R438, R439, R440,

R441, R442, R443, R444, R445, R446,

R447, R448, R449, R450, R451, R452,

R453, R454, R455, R456, R457, R458,

R459, R460, R461, R462, R463, R464

PT SP

R88, R89, R90, R91, R92, R93, R94,

R95, R96, R97, R98, R99, R100, R101,

R102, R013, R014, R105, R106, R107,

R108, R109, R110, R111, R112

R357, R358, R359, R360, R361, R362,

R363, R364, R365, R366, R367, R368,

R369, R370, R371, R372, R373, R374,

R375, R376

R657, R658, R659, R660, R661, R662,

R663, R664, R665, R666, R667, R668,

R669, R670, R671, R672, R673, R674

R113, R114, R115, R116, R117, R118,

R119, R120, R121, R122, R123, R124,

R125, R126

R377, R378, R379, R380, R381, R382,

R383, R384, R385, R386, R387, R388,

R389, R390, R391, R392, R393, R394,

R395, R396, R397, R398, R399, R400,

R401, R402, R403, R404, R405, R406,

R407, R408, R409, R410

R675, R676, R677, R678, R679, R680,

R681, R682, R683, R684, R685, R686,

R687, R688, R689, R690, R691, R692,

R693, R694, R695, R696, R697, R698,

R699, R700, R701, R702, R703, R704,

R705

R706, R707, R708, R709, R710, R711,

R712, R713, R714, R715, R716, R717,

R718, R719, R720, R721, R722, R723,

R724, R725, R726, R727, R728, R729,

R730, R731, R732, R733, R734, R735,

R736, R737, R738, R739, R740, R741,

R742, R743, R744, R745, R746, R747,

R748, R749, R750, R751, R752, R753,

R754, R755

21

Tabela 3.3: Regras obtidas a partir da mineração de dados para o algoritmo RSA.

Tabela 3.4: Regras obtidas a partir da mineração de dados para o algoritmo RC4.

PART

J48

R241, R242, R243, R244, R245, R246,

R247, R248, R249, R250, R251, R252,

R253, R254, R255, R256, R257, R258,

R259, R260, R261, R262, R263, R264,

R265, R266, R267, R268

R563, R564, R565, R566, R567, R568,

R569, R570, R571, R572, R573

RSA

EN

R864, R865

PT SP

R228, R229, R230, R231, R232, R233,

R234, R235, R236, R237, R238, R239,

R240

R551, R552, R553, R554, R555, R556,

R557, R558, R559, R560, R561, R562

R847, R848, R849, R850, R851, R852,

R853, R854, R855, R856, R857, R858,

R859, R860, R861, R862, R863

Attribute

J48

R147, R148, R149, R150, R151, R152,

R153, R154, R155, R156, R157, R158,

R159, R160, R161, R162, R163, R164,

R165, R166, R167, R168, R169, R170,

R171, R172, R173

R465, R466, R467, R468, R469, R470,

R471, R472, R473, R474, R475, R476,

R477, R478, R479, R480, R481, R482,

R483, R484, R485, R486, R487, R488,

R489, R490, R491, R492, R493

R756, R757, R758, R759, R760, R761,

R762, R763, R764, R765, R766, R767,

R768

RC4

EN PT SP

R782, R783, R784, R785, R786, R787,

R788, R789, R790, R791, R792, R793,

R794, R795, R796, R797, R798, R799,

R800

R192, R193, R194, R195, R196, R197,

R198, R199, R200, R201, R202, R203,

R204, R205, R206, R207, R208, R209,

R210, R211, R212, R213, R214, R215,

R216, R217, R218, R219, R220, R221,

R222, R223, R224, R225, R226, R227

R518, R519, R520, R521, R522, R523,

R524, R525, R526, R527, R528, R529,

R530, R531, R532, R533, R534, R535,

R536, R537, R538, R539, R540, R541,

R542, R543, R544, R545, R546, R547,

R548, R549, R550

R801, R802, R803, R804, R805, R806,

R807, R808, R809, R810, R811, R812,

R813, R814, R815, R816, R817, R818,

R819, R820, R821, R822, R823, R824,

R825, R826, R827, R828, R829, R830,

R831, R832, R833, R834, R835, R836,

R837, R838, R839, R840, R841, R842,

R843, R844, R845, R846

Filtered

R769, R770, R771, R772, R773, R774,

R775, R776, R777, R778, R779, R780,

R781

PART

R174, R175, R176, R177, R178, R179,

R180, R181, R182, R183, R184, R185,

R186, R187, R188, R189, R190, R191

R494, R495, R496, R497, R498, R499,

R500, R501, R502, R503, R504, R505,

R506, R507, R508, R509, R510, R511,

R512, R513, R514, R515, R516, R517

22

Para blocos de dois bits não foi retirada nenhuma regra e para quatro bits

foram retiradas poucas. A pequena variedade de blocos fez com que os algoritmos

fossem confundidos facilmente. Ainda no caso dos blocos de dois bits para um

classificador surpreendentemente houve uma taxa de 93% de acerto. Porém era

inviável a utilização da regra, já que ele possuía uma alta taxa de erro, isto é o erro

relativo absoluto da classificação foi de 77.61%. Nesse caso há uma regra que

classifica 79 arquivos como sendo do algoritmo RC4, que teve 93% de acerto, mas 47

deles não eram RC4 de fato.

Para 16 bits, como os textos eram relativamente pequenos, em torno de 6500

caracteres, a análise resultou em diversos blocos com contagem nula. Além disso,

como a quantidade de blocos diferentes era muito grande (65536 blocos), só foi

possível realizar a análise para os classificadores PART e J48, ficando com excelente

precisão em ambos. A menor classificação correta foi de 92% e a segunda menor foi

de 98%. As taxas de acerto de todos os algoritmos para todos os classificadores se

encontram no anexo 2.

O melhor desempenho foi realmente com oito bits, sendo possível visualizar

todos os classificadores com taxa de classificação variando de 57% a 99%. Apesar da

grande variação, 32 das 48 classificações (levando em conta o idioma também)

tiveram acerto maior do que 90% e somente quatro ficaram com acerto menor ou igual

a 70%. Com uma boa variedade de blocos, não houve nenhum com contagem nula e

as regras ficaram bem claras e não tão extensas, possibilitando um melhor

desempenho nos testes de validação.

3.5 Testes de validação

Para o teste de validação foi necessário criar uma nova etapa na ferramenta

de encriptação descrita na sessão 3.2. A janela ganhou uma nova aba para essa

segunda etapa, mas a parte gráfica continuou a mesma. O objetivo é gerar um arquivo

contendo a contagem de blocos já no formato para ser utilizado nos testes. Não foram

necessárias muitas alterações no código, porém como serão utilizados arquivos

diferentes para essa etapa foi necessária a criação de uma nova aba para que

pudessem ser executadas as novas funções. A diferença está basicamente na criação

de um arquivo para cada texto e em seu conteúdo. Na figura 3.5 podemos ver como

ficou a interface da ferramenta.

23

Para realizar os testes de validação foi utilizado o software Witty [10], um

provador automático de regras flexível e robusto. Para esse projeto foram criadas

quatro bases, uma para cada algoritmo de criptografia avaliado, para que as regras

fossem incluídas nas respectivas bases de conhecimento de acordo com o algoritmo.

Os fatos serão retirados da ferramenta de encriptação como citado no parágrafo

anterior. As regras serão as obtidas na mineração de dados, como mostrado na

sessão 3.4. A figura 3.6 mostra a interface do programa.

Figura 3.5: Interface da ferramenta de encriptação após alterações.

24

Figura 3.6: Interface do Witty

A figura 3.6 também mostra o programa já preparado para um teste, com as

regras e os fatos definidos. Para isso, copiamos as regras para um arquivo “.prg” no

formato “assert(chaos, regra)#” e carregamos esse arquivo no Witty, juntamente com

um arquivo gerado pela ferramenta de encriptação para obter os fatos, finalizando a

preparação para o teste. Serão gerados fatos para cada algoritmo em cada arquivo,

para que sejam identificadas classificações corretas ou não. Podemos, então, escrever

na linha de comando o que queremos provar. Na figura 3.6 podemos ver também o

script utilizado para carregar as regras e fatos nas respectivas bases e a linha de

comando com a função para provar se as descrições correspondem a um determinado

algoritmo ou não. Por exemplo, seja uma verificação quanto à pertinência em relação

ao algoritmo DES. Caso o teste seja positivo será impressa a mensagem “DES OK”,

caso contrário será impresso “DES ???”.

Um problema foi que, a grande quantidade de blocos existente em um vetor de

16 bits gerou dificuldade de carga dos mesmos no Witty. Devido à necessidade

premente de defender este Projeto de Graduação, não houve tempo para efetuar a

depuração desde problema e, portanto, as regras e fatos referentes a 16 bits não

puderam ser testados.

Para a avaliação proposta desde trabalho, foram feitos testes somente para os

arquivos cujo idioma era Português. Foram utilizados 50 arquivos diferentes daqueles

empregados para o levantamento das regras.

Após toda preparação e realizado o teste, obtivemos o resultado da tabela 3.5.

25

Tabela 3.5: Resultado após primeiro teste de validação.

Na tabela temos que dos 50 arquivos criptografados como DES 49 foram

classificados como DES, 45 como Blowfish, 39 como RC4 e 46 como RSA. Como

podemos ver, os resultados foram bastante decepcionantes. Esperava-se uma

classificação com um acerto de pelo menos 90% para o algoritmo testado e alguma

classificação residual para os demais algoritmos, porém eles foram confundidos

facilmente para os novos textos e ficou impossível identificar qual algoritmo utilizado

em qual texto.

Numa tentativa de corrigir a classificação, foi feita a verificação manual de cada

regra. Foram escolhidos os 50 fatos do algoritmo RSA e, um a um, foi verificada quais

regras eram responsáveis por classificar o documento em um algoritmo diferente do

RSA. Essa verificação foi feita olhando as regras referentes aos outros algoritmos

diretamente e comparando com os valores da contagem dos blocos até encontrar uma

regra com resultado positivo. Essa regra era retirada e o teste era feito novamente,

para confirmar se o documento estava sendo classificado exclusivamente como RSA.

Se não, o processo era repetido. Os resultados obtidos após essa alteração podem

ser vistos na tabela 3.6.

Tabela 3.6: Resultados após alteração nas regras.

Podemos ver que a remoção das regras eliminou completamente a

ambiguidade na classificação do RSA. Com exceção do DES, foi possível verificar

também que os resultados começam a convergir para classificações melhores para o

Blowfish e o RC4 (desconsiderando as classificações desses algoritmos em RSA, já

que as regras desde último não foram modificadas). No entanto, um contratempo foi a

queda da classificação correta nos algoritmos cujas regras foram alteradas. Caso o

processo feito para o RSA se repita, esse número tende a diminuir cada vez mais,

DES Blowfish RC4 RSA

DES 49 45 39 46

Blowfish 50 49 48 45

RC4 50 49 49 48

RSA 50 46 44 45

DES Blowfish RC4 RSA

DES 29 31 30 46

Blowfish 27 39 32 45

RC4 29 43 46 48

RSA 0 0 0 45

26

porém ainda é melhor classificar pouco e ter certeza dessa classificação do que não

ter nada.

4. Conclusão

Apesar de os algoritmos criptográficos contarem tanto com as cifras quanto

com a chave para sua segurança, descobrir um dos dois é de grande ajuda para se

realizar a criptoanálise de um texto cifrado.

Nesse trabalho verificamos que a divisão em blocos de bits de um texto cifrado

e o estudo desses blocos tornou possível a obtenção de regras que classificassem

padrões de blocos de acordo com o algoritmo utilizado na criptografia o que, apesar de

não ser o necessário para expor a informação, pode resultar em uma grave falha de

segurança. No entanto, o desempenho das regras obtidas não foi satisfatório,

impedindo a obtenção de conclusões concretas, mas abrindo questionamentos e

novas oportunidades de estudo na área.

Nesse projeto foi utilizado o valor de 90% de acerto dos classificadores como

critério de corte para a escolha das regras. Para um trabalho futuro, seria interessante

estudar se essa foi uma boa escolha e qual seria o valor mais adequado para um

maior aproveitamento. O mais provável é que com uma taxa de acerto maior a

classificação não se confunda tanto e seja possível realizar um teste de validação

mais concreto.

Do mesmo modo, em outro trabalho futuro, seria interessante estudar se a

quantidade e o tamanho de arquivos utilizados na obtenção dos blocos foram

corretamente escolhidos e qual seriam os melhores valores para o resultado ótimo.

Além disso, pode ser um fator importante aumentar a quantidade de blocos

analisados e, por esta razão, recomenda-se avaliar o problema obtido na carga dos

arquivos de 16 bits. Adicionalmente, a quantidade de bits utilizada na contagem de

blocos também é um impeditivo ao aplicativo de pré-processamento. Neste sentido, é

necessário alterar a aplicação e incluir uma estrutura de dados dinâmica, como, por

exemplo, uma tabela hash com encadeamento interno.

Por fim, sugere-se realizar a poda das regras, tal como foi feito para o algoritmo

RSA na sessão 3.5, de modo a verificar o impacto da poda de um classificador nas

regras de classificação dos demais algoritmos.

27

5. Bibliografia

[1] Documentos do Oracle, “javax.crypto (Java Platform SE 7)”,

http://docs.oracle.com/javase/7/docs/api/javax/crypto/package-summary.html, 2014.

(acessado em 28 de novembro de 2014)

[2] Schneier, B., Applied Cryptography. Illinois, John Wiley & Sons, 1996.

[3] “Eclipse Luna”, https://eclipse.org/, 2014. (acessado em 15 de outubro de 2014)

[4] “Window Builder”, https://eclipse.org/windowbuilder/, 2014. (acessado em 20 de

novembro de 2014)

[5] Hall M., Frank E., Holmes G., Pfahringer B., Reutemann P., Witten I. H., The WEKA

Data Mining Software: An Update, SIGKDD Explorations, Volume 11, Issue 1, 2009.

[6] “AttributeSelectedClassifier”,

http://weka.sourceforge.net/doc.dev/weka/classifiers/meta/AttributeSelectedClassifier.h

tml, 2014. (acessado em 03 de Março de 2015)

[7] “FilteredClassifier”,

http://weka.sourceforge.net/doc.dev/weka/classifiers/meta/FilteredClassifier.html, 2014.

(acessado em 03 de Março de 2015)

[8] Frank E., Witten I. H., Generating Accurate Rule Sets Without Global Optimization,

Em: Fifteenth International Conference on Machine Learning, 144-151, 1998.

[9] Quinlan, R., C4.5: Programs for Machine Learning, San Mateo, Morgan Kaufmann

Publishers, 1993.

[10] Mello, F. L. de, “Witty – Máquina de Inferência e Provador Automático de

Teoremas”, http://www.del.ufrj.br/~fmello/witty.html, 2012 (acessado em 25 de

fevereiro de 2015)

28

Anexo 1 – Regras obtidas no WEKA.

R1if Bloco11101001(*a) and <=(*a,0.46263) and Bloco11100010(*b) and <=(*b,0.27126) and

Bloco11000010(*c) and >(*c,0.467611) then algoritmo(DES)

R2

if Bloco11101001(*a) and <=(*a,0.46263) and Bloco11100010(*b) and >(*b,0.27126) and

Bloco11100000(*d) and <=(*d,0.334495) and Bloco10011101(*e) and <=(*e,0.476915) and

Bloco11111000(*f) and >(*f,0.358112) and Bloco11111000(*f) and <=(*f,0.454728) and

Bloco11011100(*g) and <=(*g,0.385591) and Bloco01011011(*h) and >(*h,0.331904) and

Bloco11101001(*i) and >(*i,0.437546) then algoritmo(DES)

R3


Bloco11100000(*d) and <=(*d,0.334495) and Bloco10011101(*e) and <=(*e,0.476915) and

Bloco11111000(*f) and >(*f,0.358112) and Bloco11111000(*f) and <=(*f,0.454728) and

Bloco11011100(*g) and >(*g,0.385591) and Bloco10010101(*j) and <=(*j,0.374636) and

Bloco11011100(*k) and <=(*k,0.41488) then algoritmo(DES)

R4


Bloco11100000(*c) and <=(*c,0.334495) and Bloco10011101(*d) and >(*d,0.476915) and

Bloco01010010(*e) and >(*e,0.479808) then algoritmo(DES)

R5


Bloco11100000(*c) and >(*c,0.334495) and Bloco11111111(*d) and <=(*d,0.297297) and

Bloco11111000(*e) and <=(*e,0.366499) and Bloco10010010(*f) and <=(*f,0.38484) then

algoritmo(DES)

R6


Bloco11100000(*c) and >(*c,0.334495) and Bloco11111111(*d) and >(*d,0.297297) and

Bloco10010101(*e) and <=(*e,0.541723) and Bloco10010010(*f) and <=(*f,0.310517) and


Bloco01100101(*i) and <=(*i,0.349854) then algoritmo(DES)

R7





Bloco01100101(*i) and >(*i,0.349854) and Bloco01100101(*j) and >(*j,0.395875) then

algoritmo(DES)

R8




Bloco01100101(*g) and >(*g,0.482962) and Bloco01011011(*h) and <=(*h,0.366157) then

algoritmo(DES)

R9



Bloco10010101(*e) and <=(*e,0.541723) and Bloco10010010(*f) and >(*f,0.310517) and

Bloco11000010(*g) and <=(*g,0.36247) and Bloco10011101(*h) and <=(*h,0.451869) and

Bloco10111000(*i) and <=(*i,0.339351) then algoritmo(DES)

R10





Bloco10111000(*i) and >(*i,0.339351) and Bloco01011011(*j) and >(*j,0.343832) and

Bloco11100000(*k) and <=(*k,0.423223) and Bloco11101110(*l) and >(*l,0.47599) then

algoritmo(DES)

29

R11






Bloco11100000(*k) and >(*k,0.423223) and Bloco01011011(*l) and >(*l,0.426042) then

algoritmo(DES)

R12




Bloco11000010(*g) and >(*g,0.36247) and Bloco11111000(*h) and <=(*h,0.480294) and


Bloco11101110(*k) and <=(*k,0.301576) and Bloco01010010(*l) and >(*l,0.388012) then

algoritmo(DES)

R13






Bloco11101110(*k) and >(*k,0.301576) and Bloco01010010(*l) and <=(*l,0.481644) and

Bloco11100010(*m) and <=(*m,0.420223) and Bloco11100000(*n) and <=(*n,0.438176) and

Bloco01111100(*o) and >(*o,0.297661) and Bloco01011011(*p) and >(*p,0.380384) and

Bloco11101110(*q) and >(*q,0.447963) then algoritmo(DES)

R14







Bloco11100010(*m) and <=(*m,0.420223) and Bloco11100000(*n) and >(*n,0.438176) and

Bloco11011100(*o) and <=(*o,0.386512) and Bloco00011101(*p) and <=(*p,0.342502) then

algoritmo(DES)

R15







Bloco11100010(*m) and <=(*m,0.420223) and Bloco11100000(*n) and >(*n,0.438176) and

Bloco11011100(*o) and >(*o,0.386512) then algoritmo(DES)

R16







Bloco11100010(*m) and >(*m,0.420223) and Bloco01100101(*n) and <=(*n,0.315977) then

algoritmo(DES)

30

R17







Bloco11100010(*m) and >(*m,0.420223) and Bloco01100101(*n) and >(*n,0.315977) and

Bloco11101110(*o) and >(*o,0.378021) and Bloco10010010(*p) and <=(*p,0.434075) then

algoritmo(DES)

R18






Bloco11101110(*k) and >(*k,0.301576) and Bloco01010010(*l) and >(*l,0.481644) and

Bloco01111100(*m) and <=(*m,0.405992) then algoritmo(DES)

R19




Bloco11000010(*g) and >(*g,0.36247) and Bloco11111000(*h) and >(*h,0.480294) and

Bloco11000010(*i) and <=(*i,0.487262) and Bloco00101000(*j) and >(*j,0.327568) then

algoritmo(DES)

R20if Bloco11101001(*a) and >(*a,0.46263) and Bloco01010010(*b) and <=(*b,0.39879) and

Bloco01011011(*c) and <=(*c,0.242104) then algoritmo(DES)

R21

if Bloco11101001(*a) and >(*a,0.46263) and Bloco01010010(*b) and <=(*b,0.39879) and

Bloco01011011(*c) and >(*c,0.242104) and Bloco01010010(*d) and <=(*d,0.318514) and


R22

if Bloco11101001(*a) and >(*a,0.46263) and Bloco01010010(*b) and >(*b,0.39879) and


Bloco10111000(*e) and <=(*e,0.321633) and Bloco00101000(*f) and <=(*f,0.380827) then

algoritmo(DES)

R23

if Bloco11101001(*a) and >(*a,0.46263) and Bloco01010010(*b) and >(*b,0.39879) and



R24if Bloco11101001(*q) and >(*q, 0.467977) and Bloco00011110(*w) and >(*w, 0.328299)

then algoritmo(DES)

R25if Bloco11111111(*q) and >(*q, 0.249688) and Bloco11110011(*w) and >(*w, 0.470941) and

Bloco10100111(*e) and <=(*e, 0.475248) then algoritmo(DES)

R26if Bloco10101001(*q) and <=(*q, 0.295144) and Bloco00101100(*w) and <=(*w, 0.482022)

and Bloco10000011(*e) and >(*e, 0.366157) then algoritmo(DES)



R28if Bloco11110001(*q) and <=(*q, 0.276461) and Bloco11000000(*w) and >(*w, 0.293665)

and Bloco11010000(*e) and <=(*e, 0.408108) then algoritmo(DES)




then algoritmo(DES)

31


then algoritmo(DES)

R32

if Bloco00001101(*q) and >(*q, 0.352542) and Bloco00001110(*w) and >(*w, 0.29969) and

Bloco10001011(*e) and >(*e, 0.424425) and Bloco10000011(*r) and >(*r, 0.375444) then

algoritmo(DES)

R33

if Bloco01011011(*q) and <=(*q, 0.442939) and Bloco00001001(*w) and <=(*w, 0.458595)

and Bloco10001011(*e) and <=(*e, 0.437546) and Bloco01101101(*r) and >(*r, 0.319872)

then algoritmo(DES)

R34if Bloco0111010011000010(*q) and >(*q, 0.025361) and Bloco0000110000010000(*w) and

<=(*w, 0) then algoritmo(DES)

R35if Bloco0101011111101110(*q) and <=(*q, 0.023326) and Bloco1110010010111110(*w) and

>(*w, 0.026295) then algoritmo(DES)

R36 if Bloco0101011111101110(*q) and >(*q, 0.023326) then algoritmo(DES)



R38if Bloco11100010(*q) and <=(*q,0.27126) and Bloco00110100(*w) and >(*w,0.317023) and

Bloco01000010(*e) and <=(*e,0.35515) then algoritmo(DES)

R39

if Bloco11100010(*q) and >(*q,0.27126) and Bloco11101001(*w) and <=(*w,0.46263) and

Bloco00011001(*e) and <=(*e,0.499339) and Bloco11111111(*r) and >(*r,0.249688) and

Bloco00100110(*t) and <=(*t,0.286026) and Bloco11000010(*y) and >(*y,0.346159) then

algoritmo(DES)

R40



Bloco00100110(*t) and >(*t,0.286026) and Bloco10011000(*y) and <=(*y,0.559969) and

Bloco10010101(*u) and <=(*u,0.475248) and Bloco11101110(*i) and <=(*i,0.302572) and

Bloco01100010(*o) and <=(*o,0.439138) and Bloco00101000(*p) and <=(*p,0.409241) and

Bloco01011110(*a) and >(*a,0.417425) and Bloco00000100(*s) and <=(*s,0.34046) then

algoritmo(DES)

R41





Bloco01100010(*o) and <=(*o,0.439138) and Bloco00101000(*p) and >(*p,0.409241) then

algoritmo(DES)

R42





Bloco01100010(*o) and >(*o,0.439138) and Bloco00000000(*p) and >(*p,0.357339) then

algoritmo(DES)

R43




Bloco10010101(*u) and <=(*u,0.475248) and Bloco11101110(*i) and >(*i,0.302572) and


algoritmo(DES)

32

R44





Bloco00001111(*o) and <=(*o,0.508089) and Bloco11110000(*p) and >(*p,0.269724) and

Bloco11011001(*a) and <=(*a,0.261312) then algoritmo(DES)

R45






Bloco11011001(*a) and >(*a,0.261312) and Bloco10100100(*s) and <=(*s,0.496252) and

Bloco01100110(*d) and <=(*d,0.270717) and Bloco11010110(*f) and >(*f,0.456368) and

Bloco00001010(*g) and >(*g,0.380384) then algoritmo(DES)

R46







Bloco01100110(*d) and >(*d,0.270717) and Bloco11110010(*f) and <=(*f,0.263296) and

Bloco00011000(*g) and <=(*g,0.413508) then algoritmo(DES)

R47







Bloco01100110(*d) and >(*d,0.270717) and Bloco11110010(*f) and >(*f,0.26329) and


Bloco00100011(*j) and >(*j,0.385719) and bloco00000010(*k) and <=(*k,0.34727) then

algoritmo(DES)

R48









Bloco10011011(*j) and <=(*j,0.519377) and Bloco10010010(*k) and <=(*k,0.310517) and

Bloco01111010(*l) and <=(*l,0.439138) then algoritmo(DES)

33

99999999

R49









Bloco10011011(*j) and <=(*j,0.519377) and Bloco10010010(*k) and >(*k,0.310517) and

Bloco01010100(*l) and >(*l,0.256514) and Bloco10100111(*z) and <=(*z,0.551149) and

Bloco10101000(*x) and <=(*x,0.534594) and Bloco00110101(*c) and <=(*c,0.549044) and

Bloco00111001(*v) and <=(*v,0.51396) and Bloco00100100(*b) and <=(*b,0.476257) and

Bloco00010010(*n) and <=(*n,0.306279) and Bloco00000101(*m) and <=(*m,0.401519) then

algoritmo(DES)

R50












Bloco00111001(*v) and <=(*v,0.51396) and Bloco00100100(*b) and >(*b,0.476257) and

Bloco01111001(*n) and >(*n,0.410698) then algoritmo(DES)

R51











Bloco10101000(*x) and <=(*x,0.534594) and Bloco00110101(*c) and >(*c,0.549044) then

algoritmo(DES)

34

R52











Bloco10101000(*x) and >(*x,0.534594) and Bloco00000010(*c) and <=(*c,0.41488) then

algoritmo(DES)

R53




Bloco10010101(*u) and >(*u,0.475248) and Bloco11111000(*i) and >(*i,0.371083) and

Bloco01000100(*o) and >(*o,0.495889) then algoritmo(DES)

R54if Bloco11100010(*q) and >(*q,0.27126) and Bloco11101001(*w) and >(*w,0.46263) and

Bloco01010001(*e) and <=(*e,0.310998) then algoritmo(DES)

R55

if Bloco11100010(*q) and >(*q,0.27126) and Bloco11101001(*w) and >(*w,0.46263) and

Bloco01010001(*e) and >(*e,0.310998) and Bloco00010010(*r) and >(*r,0.350976) and

Bloco01100100(*t) and <=(*t,0.354925) and Bloco00001100(*y) and <=(*y,0.402847) then

algoritmo(DES)

R56

if Bloco0100110001101000(*q) and <=(*q, 0.021706) and Bloco0111010011000010(*w) and

<=(*w, 0.025361) and Bloco1010010001100111(*e) and <=(*e, 0.021706) and

Bloco1110111100111100(*r) and <=(*r, 0.026546) and Bloco1001100110001111(*t) and

<=(*t, 0.021706) and Bloco0111000011001111(*y) and <=(*y, 0.020838) and

Bloco0100111000100111(*u) and <=(*u, 0.021706) and Bloco0000101010010100(*i) and

<=(*i, 0.021409) and Bloco0101011010001000(*o) and <=(*o, 0.026171) and

Bloco0010111000001111(*p) and >(*p, 0.021409) and Bloco0000000001010110(*a) and

>(*a, 0) then algoritmo(DES)

R57






<=(*i, 0.021409) and Bloco0101011010001000(*o) and >(*o, 0.026171) then algoritmo(DES)

R58






>(*i, 0.021409) then algoritmo(DES)

35

R59





Bloco0100111000100111(*u) and >(*u, 0.021706) then algoritmo(DES)

R60




<=(*t, 0.021706) and Bloco0111000011001111(*y) and >(*y, 0.020838) and

Bloco0000001000101100(*u) and <=(*u, 0) then algoritmo(DES)


>(*w, 0.025361) and Bloco0000110000010000(*e) and <=(*e, 0) then algoritmo(DES)



R63if Bloco1100(*q) and <=(*q, 5.961446) and Bloco1011(*w) and <=(*w, 6.11543) and

Bloco0010(*e) and >(*e, 6.12788) then algoritmo(DES)

R64if Bloco1100(*q) and <=(*q, 5.961446) and Bloco1011(*w) and >(*w, 6.11543) and


R65

if Bloco1100(*q) and >(*q, 5.961446) and Bloco1111(*w) and <=(*w, 6.233006) and

Bloco1110(*e) and <=(*e, 6.162103) and Bloco1111(*r) and <=(*r, 6.038664) and

Bloco0001(*t) and <=(*t, 6.573211) and Bloco1101(*y) and >(*y, 6.326417) and

Bloco1100(*u) and >(*u, 6.243699) and Bloco0001(*i) and >(*i, 6.189437) then

algoritmo(DES)

R66



Bloco0001(*t) and >(*t, 6.573211) then algoritmo(DES)

R67


Bloco1110(*e) and <=(*e, 6.162103) and Bloco1111(*r) and >(*r, 6.038664) and

Bloco0000(*t) and >(*t, 6.162579) and Bloco0010(*y) and <=(*y, 6.257298) and

Bloco1000(*u) and <=(*u, 6.267986) and Bloco0010(*i) and <=(*i, 6.181517) then

algoritmo(DES)

R68




Bloco1000(*u) and >(*u, 6.267986) and Bloco0011(*i) and <=(*i, 6.134299) and

Bloco0000(*o) and <=(*o, 6.354538) then algoritmo(DES)

R69



Bloco0000(*t) and >(*t, 6.162579) and Bloco0010(*y) and >(*y, 6.257298) and

Bloco0000(*u) and >(*u, 6.43517) and Bloco0001(*i) and <=(*i, 6.130089) then

algoritmo(DES)

R70


Bloco1110(*e) and >(*e, 6.162103) and Bloco0001(*r) and <=(*r, 6.007092) then

algoritmo(DES)

36

R71


Bloco1110(*e) and >(*e, 6.162103) and Bloco0001(*r) and >(*r, 6.007092) and Bloco0001(*t)

and <=(*t, 6.450032) and Bloco0010(*y) and <=(*y, 6.542007) and Bloco1011(*u) and <=(*u,

6.321505) and Bloco0001(*i) and <=(*i, 6.228637) and Bloco0111(*o) and <=(*o, 6.151409)

then algoritmo(DES)

R72




6.321505) and Bloco0001(*i) and <=(*i, 6.228637) and Bloco0111(*o) and >(*o, 6.151409)

and Bloco1101(*p) and <=(*p, 6.120124) and Bloco0010(*a) and <=(*a, 6.187152) then

algoritmo(DES)

R73




6.321505) and Bloco0001(*i) and >(*i, 6.228637) and Bloco0000(*o) and <=(*o, 6.070109)

then algoritmo(DES)

R74



and <=(*t, 6.450032) and Bloco0010(*y) and <=(*y, 6.542007) and Bloco1011(*u) and >(*u,

6.321505) and Bloco1110(*i) and <=(*i, 6.407984) and Bloco0000(*o) and <=(*o, 5.888545)

then algoritmo(DES)

R75





then algoritmo(DES)

R76



and >(*t, 6.450032) and Bloco0000(*y) and <=(*y, 6.210095) then algoritmo(DES)

R77



Bloco0000(*t) and <=(*t, 6.250411) then algoritmo(DES)

R78



Bloco0000(*t) and >(*t, 6.250411) and Bloco1010(*y) and <=(*y, 6.160548) then

algoritmo(DES)

R79



Bloco0101(*t) and <=(*t, 6.328455) and Bloco0010(*y) and <=(*y, 6.190657) then

algoritmo(DES)

R80





37

R81



Bloco1101(*t) and <=(*t, 6.492429) and Bloco1001(*y) and <=(*y, 6.354841) and

Bloco1110(*u) and <=(*u, 6.153749) and Bloco1110(*i) and >(*i, 5.905858) and

Bloco1011(*o) and <=(*o, 6.321505) and Bloco0010(*p) and >(*p, 6.113537) then

algoritmo(DES)

R82






R83





Bloco0101(*o) and >(*o, 5.973973) and Bloco1101(*p) and <=(*p, 6.263457) and

Bloco1000(*a) and <=(*a, 6.232959) and Bloco1000(*s) and >(*s, 6.202173) and

Bloco1001(*d) and >(*d, 6.180767) then algoritmo(DES)

R84




Bloco1110(*u) and >(*u, 6.153749) and Bloco0100(*i) and >(*i, 6.359724) and Bloco0101(*o)

and <=(*o, 6.209922) then algoritmo(DES)

R85





and >(*o, 6.209922) and Bloco0000(*p) and >(*p, 6.123404) and Bloco1000(*a) and >(*a,

6.212875) then algoritmo(DES)

R86




algoritmo(DES)

R87





R88

if Bloco11101001(*q) and <=(*q,0.46263) and Bloco11100010(*w) and <=(*w,0.27126) and


Bloco11011100(*t) and <=(*t,0.277546) then algoritmo(Blowfish)

R89



Bloco11011100(*t) and >(*t,0.277546) and Bloco10111000(*y) and >(*y,0.536625) then

algoritmo(Blowfish)

R90

if Bloco11101001(*q) and <=(*q,0.46263) and Bloco11100010(*w) and >(*w,0.27126) and

Bloco11100000(*e) and <=(*e,0.334495) and Bloco10011101(*r) and <=(*r,0.476915) and



Bloco11100000(*o) and >(*o,0.285365) then algoritmo(Blowfish)

38

R91



Bloco11111000(*t) and >(*t,0.358112) and Bloco11111000(*y) and >(*y,0.454728) and

Bloco11111111(*u) and >(*u,0.375052) then algoritmo(Blowfish)

R92

if Bloco11101001(*q) and <=(*q,0.46263) and Bloco11100010(w*) and >(*w,0.27126) and



R93


Bloco11100000(*e) and >(*e,0.334495) and Bloco11111111(*r) and <=(*r,0.297297) and


Bloco11111000(*u) and <=(*u,0.397097) then algoritmo(Blowfish)

R94




Bloco00101000(*u) and <=(*u,0.380108) and Bloco00101000(*i) and <=(*i,0.35524) then

algoritmo(Blowfish)

R95




Bloco00101000(*u) and >(*u,0.380108) then algoritmo(Blowfish)

R96



Bloco10010101(*t) and <=(*t,0.541723) and Bloco10010010(*y) and <=(*y,0.310517) and

Bloco01100101(*u) and <=(*u,0.482962) and Bloco01010010(*i) and <=(*i,0.311189) then

algoritmo(Blowfish)

R97






algoritmo(Blowfish)

R98



Bloco10010101(*t) and <=(*t,0.541723) and Bloco10010010(*y) and >(*y,0.310517) and



Bloco11100000(*a) and >(*a,0.423223) and Bloco01011011(*s) and <=(*s,0.426042) then

algoritmo(Blowfish)

R99




Bloco11000010(*u) and <=(*u,0.36247) and Bloco10011101(*i) and >(*i,0.451869) then

algoritmo(Blowfish)

R100




Bloco11000010(*u) and >(*u,0.36247) and Bloco11111000(*i) and <=(*i,0.480294) and

Bloco11101001(*o) and <=(*o,0.249757) then algoritmo(Blowfish)

39

R101





Bloco11101001(*o) and >(*o,0.249757) and Bloco10010010(*p) and <=(*p,0.319872) and

Bloco11111000(*a) and >(*a,0.381629) then algoritmo(Blowfish)

R102






Bloco11101110(*a) and <=(*a,0.301576) and Bloco01010010(*s) and <=(*s,0.388012) then

algoritmo(Blowfish)

R103







Bloco11100010(*d) and <=(*d,0.420223) and Bloco11100000(*f) and <=(*f,0.438176) and

Bloco01111100(*g) and <=(*g,0.2976661) then algoritmo(Blowfish)

R104










Bloco01100101(*l) and >(*l,0.356824) then algoritmo(Blowfish)

R105






algoritmo(Blowfish)

R106



Bloco10010101(*t) and >(*t,0.541723) and Bloco10111000(*y) and <=(*y,0.408552) then

algoritmo(Blowfish)

R107




R108




40

R109



Bloco11000010(*t) and >(*t,0.363993) and Bloco01011011(*y) and >(*y,0.406292) then

algoritmo(Blowfish)

R110if Bloco11101001(*q) and >(*q,0.46263) and Bloco01010010(*w) and >(*w,0.39879) and

Bloco11011100(*e) and <=(*e,0.325071) then algoritmo(Blowfish)

R111


Bloco11011100(*e) and >(*e,0.325071) and Bloco11101110(*r) and <=(*r,0.299605) then

algoritmo(Blowfish)

R112




algoritmo(Blowfish)

R113


Bloco01100100(*e) and >(*e, 0.302572) and Bloco01110100(*r) and >(*r, 0.332138) and


algoritmo(Blowfish)

R114


Bloco10011000(*e) and <=(*e, 0.437546) and Bloco00000111(*r) and >(*r, 0.333056) then

algoritmo(Blowfish)


then algoritmo(Blowfish)



R117if Bloco10110100(*q) and >(*q, 0.5175) and Bloco10000110(*w) and >(*w, 0.390462) then

algoritmo(Blowfish)

R118

if Bloco00001101(*q) and <=(*q, 0.297016) and Bloco00000010(*w) and >(*w, 0.310393)

and Bloco01111101(*e) and >(*e, 0.370117) and Bloco00011001(*r) and >(*r, 0.310278)


R119 if Bloco01001100(*q) and >(*q, 0.528957) then algoritmo(Blowfish)


algoritmo(Blowfish)

R121


and Bloco01100010(*e) and >(*e, 0.243746) and Bloco00100110(*r) and >(*r, 0.449534) and

Bloco00000000(*t) and <=(*t, 0.493472) then algoritmo(Blowfish)




<=(*w, 0.026831) and Bloco0011010000100011(*e) and <=(*e, 0) then algoritmo(Blowfish)


>(*w, 0.021706) and Bloco0000000000010001(*e) and <=(*e, 0) then algoritmo(Blowfish)


R126if Bloco0000000000010100(*q) and <=(*q, 0) and Bloco0000111110111111(*w) and <=(*w,

0) then algoritmo(Blowfish)

R127if Bloco11100010(*q) and <=(*q,0.27126) and Bloco00110100(*w) and <=(*w,0.317023)


41

R128





Bloco01100010(*o) and <=(*o,0.439138) and Bloco00101000(*p) and <=(*p,409241) and

Bloco01011110(*a) and >(*a,0.417425) and Bloco00000100(*s) and >(*s,0.34046) then

algoritmo(Blowfish)

R129







Bloco01100110(*d) and <=(*d,0.270717) and Bloco11010110(*f) and >(*f,0.456368) and

Bloco00001010(*g) and <=(*g,0.380384) then algoritmo(Blowfish)

R130









Bloco00100011(*j) and >(*j,0.385719) and Bloco00000010(*k) and >(*k,0.34727) then

algoritmo(Blowfish)

R131










Bloco01111010(*l) and >(*l,0.439138) then algoritmo(Blowfish)

R132










Bloco01010100(*l) and <=(*l,0.256514) then algoritmo(Blowfish)

42

R133













Bloco00010010(*n) and >(*n,0.306279) and Bloco10000100(*m) and >(*m,0.494719) then

algoritmo(Blowfish)

R134












Bloco00111001(*v) and >(*v,0.51396) then algoritmo(Blowfish)

R135











Bloco10101000(*x) and >(*x,0.534594) and Bloco00000010(*c) and >(*c,0.41488) then

algoritmo(Blowfish)

R136






Bloco11011001(*a) and >(*a,0.261312) and Bloco10100100(*s) and >(*s,0.496252) then

algoritmo(Blowfish)

R137





Bloco00001111(*o) and >(*o,0.508089) and Bloco11000010(*p) and >(*p,0.311569) then

algoritmo(Blowfish)

43

R138






algoritmo(Blowfish)

R139


Bloco00011001(*e) and >(*e,0.499339) and Bloco11010000(*r) and >(*r,0.301576) then

algoritmo(Blowfish)

R140




algoritmo(Blowfish)

R141




algoritmo(Blowfish)

R142




<=(*t, 0.021706) and Bloco0111000011001111(*y) and >(*y, 0.020838) and

Bloco0000001000101100(*u) and >(*u, 0) then algoritmo(Blowfish)

R143




>(*t, 0.021706) then algoritmo(Blowfish)

R144



Bloco1110111100111100(*r) and >(*r, 0.026546) then algoritmo(Blowfish)

R145


<=(*w, 0.025361) and Bloco1010010001100111(*e) and >(*e, 0.021706) then

algoritmo(Blowfish)


<=(*w, 0.026831) and Bloco0011010000100011(*e) and <=(*e, 0) then algoritmo(Blowfish)


Bloco1100(*e) and <=(*e, 5.967231) then algoritmo(RC4)

R148

if Bloco1011(*q) and <=(*q, 6.347555) and Bloco1110(*w) and <=(*w, 6.157983) and

Bloco1100(*e) and >(*e, 5.967231) and Bloco1111(*r) and <=(*r, 6.178564) and


Bloco1110(*u) and <=(*u, 6.056844) then algoritmo(RC4)

R149



Bloco1110(*t) and >(*t, 6.140415) then algoritmo(RC4)

R150



and >(*t, 6.368762) and Bloco1001(*y) and <=(*y, 6.432279) and Bloco1100(*u) and <=(*u,

6.239632) then algoritmo(RC4)

44

R151



and >(*t, 6.368762) and Bloco1001(*y) and >(*y, 6.432279) and Bloco1110(*u) and >(*u,

5.94206) and Bloco1100(*i) and >(*i, 6.07314) then algoritmo(RC4)

R152

if Bloco1011(*q) and <=(*q, 6.347555) and Bloco1110(*w) and >(*w, 6.157983) and


algoritmo(RC4)

R153if Bloco1011(*q) and >(*q, 6.347555) and Bloco1111(*w) and <=(*w, 6.110403) and


R154




algoritmo(RC4)

R155




Bloco1111(*u) and <=(*u, 5.95496) and Bloco1111(*i) and >(*i, 5.872622) then

algoritmo(RC4)

R156







R158


Bloco1100(*e) and >(*e, 5.964346) and Bloco1111(*r) and <=(*r, 6.25733) and Bloco1100(*t)

and <=(*t, 6.1112) and Bloco1011(*y) and >(*y, 6.503722) then algoritmo(RC4)

R159




6.460891) and Bloco1110(*i) and >(*i, 5.846282)then algoritmo(RC4)

R160


Bloco11000010(*e) and <=(*e,0.467611) and Bloco11111000(*r) and <=(*r,0.349854) then

algoritmo(RC4)

R161




algoritmo(RC4)

R162




Bloco00011101(*u) and >(*u,0.356898) then algoritmo(RC4)

R163




algoritmo(RC4)

45

R164





Bloco11101001(*o) and <=(*o,0.437546) then algoritmo(RC4)

R165





Bloco11100000(*o) and <=(*o,0.285365) then algoritmo(RC4)

R166




algoritmo(RC4)

R167




Bloco11111000(*u) and >(*u,0.397097) then algoritmo(RC4)

R168


Bloco11100000(*e) and >(*e,0.334495) and Bloco11111111(*r) and >(*r,0.297297 ) and


Bloco01100101(*u) and >(*u,0.482962) and Bloco01011011(*i) and >(*i,0.366157) then

algoritmo(RC4)

R169






Bloco11100000(*a) and <=(*a,0.423223) and Bloco11101110(*s) and <=(*s,0.47599) and


Bloco10010010(*g) and <=(*g,0.339293) then algoritmo(RC4)

R170







Bloco11100000(*d) and <=(*d,0.387752) and Bloco10010010(*f) and >(*f,0.38484) then

algoritmo(RC4)

R171







Bloco11100000(*d) and >(*d,0.387752) then algoritmo(RC4)

R172





Bloco11000010(*o) and >(*o,0.487262) then algoritmo(RC4)

46

R173



Bloco10010101(*t) and >(*t,0.541723) and Bloco10111000(*y) and >(*y,0.408552)then

algoritmo(RC4)


Bloco01000010(*e) and >(*e, 0.35515) then algoritmo(RC4)

R175

if Bloco10010101(*q) and >(*q, 0.475248) and Bloco00100000(*w) and <=(*w, 0.517585)


then algoritmo(RC4)

R176 if Bloco11111111(*q) and <=(*q, 0.249688) then algoritmo(RC4)

R177


and Bloco01011011(*e) and >(*e, 0.320545) and Bloco00101001(*r) and <=(*r, 0.548202)

then algoritmo(RC4)


and Bloco10111111(*e) and >(*e, 0.400946) then algoritmo(RC4)


and Bloco01111101(*e) and <=(*e, 0.411226) then algoritmo(RC4)

R180 if Bloco11010010(*q) and >(*q, 0.535788) then algoritmo(RC4)


then algoritmo(RC4)


and Bloco00000001(*e) and <=(*e, 0.381679)then algoritmo(RC4)

R183



algoritmo(RC4)



R185



Bloco1100(*t) and <=(*t, 6.416225) and Bloco0011(*y) and >(*y, 6.202173) then

algoritmo(RC4)

R186



and <=(*t, 6.368762) then algoritmo(RC4)

R187




algoritmo(RC4)

R188if Bloco1111(*q) and <=(*q, 5.999029) and Bloco0001(*w) and >(*w, 6.01664) then

algoritmo(RC4)

R189 if Bloco1001(*q) and <=(*q, 6.415458)then algoritmo(RC4)

R190


<=(*w, 0.02633) and Bloco0011001101101100(*e) and >(*e, 0.021706) and

Bloco0000000101010101(*r) and <=(*r, 0) then algoritmo(RC4)

R191

if Bloco0001011001110101(*q) and <=(*q, 0) and Bloco1100100010100101(*w) and <=(*w,

0) and Bloco0001100110100110(*e) and <=(*e, 0) and Bloco0100000110000011(*r) and

<=(*r, 0)then algoritmo(RC4)

R192if Bloco11100010(*q) and <=(*q,0.27126) and Bloco00110100(*w) and >(*w,0.317023) and

Bloco01000010(*e) and >(*e,0.35515) then algoritmo(RC4)

47

R193


Bloco00011001(*e) and <=(*e,0.499339) and Bloco11111111(*r) and <=(*r,0.249688) then

algoritmo(RC4)

R194



Bloco00100110(*t) and <=(*t,0.286026) and Bloco11000010(*y) and <=(*y,0.346159) then

algoritmo(RC4)

R195





Bloco01100010(*o) and <=(*o,0.439138) and Bloco00101000(*p) and <=(*p,0.409241) and

Bloco01011110(*a) and <=(*a,0.417425) then algoritmo(RC4)

R196







Bloco01100110(*d) and <=(*d,0.270717) and Bloco11010110(*f) and <=(*f,0.456368) then

algoritmo(RC4)

R197







Bloco01100110(*d) and >(*d,0.270717) and Bloco11110010(*f) and <=(*f,0.263296) and

Bloco00011000(*g) and >(*g,0.413508) then algoritmo(RC4)

R198








Bloco10000011(*g) and <=(*g,0.262177) then algoritmo(RC4)

R199








Bloco10000011(*g) and >(*g,0.262177) and Bloco(*h) and <=(*h,0.295183) and

Bloco00100011(*j) and <=(*j,0.385719) then algoritmo(RC4)

48

R200








Bloco10000011(*g) and >(*g,0.262177) and Bloco(*h) and >(*h,0.295183) and

Bloco10011011(*j) and >(*j,0.519377) and Bloco00000101(*k) and >(*k,0.430197) then

algoritmo(RC4)

R201






algoritmo(RC4)

R202





Bloco00000110(*o) and >(*o,0.367847) then algoritmo(RC4)

R203





Bloco01000100(*o) and <=(*o,0.495889) and Bloco01010010(*p) and >(*p,0.441075) then

algoritmo(RC4)

R204




algoritmo(RC4)

R205

if Bloco0100110001101000(*q) and <=(*q,0.021706) and Bloco0111010011000010(*w) and

<=(*w,0.025361) and Bloco1010010001100111(*e) and <=(*e,0.021706) and

Bloco1110111100111100(*r) and <=(*r,0.026546) and Bloco1001100110001111(*t) and

<=(*t,0.021706) and Bloco0111000011001111(*y) and <=(*y,0.020838) and

Bloco0100111000100111(*u) and <=(*u,0.021706) and Bloco0000101010010100(*i) and


Bloco0010111000001111(*p) and <=(*p, 0.021409) and Bloco1111110000010001(*a) and

<=(*a, 0.021409) and Bloco0000111000111111(*s) and <=(*s, 0.021706) and

Bloco1001101110000010(*d) and <=(*d, 0.021409) and Bloco0010011111100110(*f) and

<=(*f, 0.022012) and Bloco0111110001101000(*g) and <=(*g, 0.021706) and

Bloco0111101101010100(*h) and <=(*h, 0.02265) and Bloco0011111100010010(*j) and

<=(*j, 0.021706) and Bloco1110111000111110(*k) and >(*k, 0.021706) then algoritmo(RC4)

49

R206












>(*j, 0.021706) then algoritmo(RC4)

R207











Bloco0111101101010100(*h) and >(*h, 0.02265) then algoritmo(RC4)

R208










<=(*f, 0.022012) and Bloco0111110001101000(*g) and >(*g, 0.021706) then algoritmo(RC4)

R209










>(*f, 0.022012) then algoritmo(RC4)

50

R210









Bloco1001101110000010(*d) and >(*d, 0.021409) then algoritmo(RC4)

R211








<=(*a, 0.021409) and Bloco0000111000111111(*s) and >(*s,0.021706) then algoritmo(RC4)

R212








>(*a, 0.021409) then algoritmo(RC4)

R213


<=(*w,0.025361) and Bloco1010010001100111(*e)and <=(*e,0.021706) and






<=(*a, 0) then algoritmo(RC4)

R214if Bloco0100110001101000(*q) and <=(*q,0.021706) and Bloco0111010011000010(*w) and

>(*w,0.025361) and Bloco0000110000010000(*e) and >(*e, 0) then algoritmo(RC4)


<=(*w, 0.026831) and Bloco0011010000100011(*e) and >(*e, 0)then algoritmo(RC4)

R216



algoritmo(RC4)

R217




Bloco1010(*u) and <=(*u, 6.265951) and Bloco0100(*i) and <=(*i, 6.424924) and

Bloco0011(*o) and <=(*o, 6.283414) then algoritmo(RC4)

51

R218




Bloco1010(*u) and >(*u, 6.265951) then algoritmo(RC4)

R219





R220




algoritmo(RC4)

R221





algoritmo(RC4)

R222




Bloco0000(*u) and <=(*u, 6.43517) and Bloco0001(*i) and >(*i, 6.326404) and Bloco0100(*o)

and >(*o, 6.209661) then algoritmo(RC4)

R223




Bloco0000(*u) and >(*u, 6.43517) and Bloco0001(*i) and >(*i, 6.130089) then algoritmo(RC4)

R224





and Bloco0001(*p) and <=(*p, 6.08883) then algoritmo(RC4)

R225





and Bloco0001(*p) and >(*p, 6.08883) and Bloco0011(*a) and >(*a, 6.435474) then

algoritmo(RC4)

R226



and >(*t, 6.450032) and Bloco0000(*y) and >(*y, 6.210095) then algoritmo(RC4)

R227



Bloco0000(*t) and <=(*t, 6.374888)then algoritmo(RC4)

52

R228




Bloco01010000(*u) and >(*u, 0.297016) and Bloco00010101(*i) and >(*i, 0.236934) and

Bloco10100011(*o) and <=(*o, 0.508871) and Bloco10111010(*p) and <=(*p, 0.50305) and

Bloco10001101(*a) and >(*a, 0.262758) and Bloco11010101(*s) and <=(*s, 0.451869) then

algoritmo(RSA)


then algoritmo(RSA)

R230



Bloco01010000(*t) and >(*t, 0.317767) and Bloco10000001(*y) and >(*y, 0.330142)then

algoritmo(RSA)

R231



and <=(*t, 6.324497) and Bloco1000(*y) and >(*y, 6.131977) then algoritmo(RSA)

R232



algoritmo(RSA)

R233



and >(*t, 6.278964) then algoritmo(RSA)

R234



algoritmo(RSA)

R235



Bloco1010(*t) and <=(*t, 6.500339) then algoritmo(RSA)


algoritmo(RSA)

R237



algoritmo(RSA)

R238


Bloco1011(*e) and <=(*e, 6.336989) and Bloco0011(*r) and <=(*r, 6.479671)then

algoritmo(RSA)

R239


<=(*w, 0.02633) and Bloco1111111011001100(*e) and >(*e, 0) and

Bloco0000000101010101(*r) and <=(*r, 0) then algoritmo(RSA)

R240








<=(*a, 0.021409) and Bloco0110000000110110(*s) and <=(*s, 0)then algoritmo(RSA)

53

R241






algoritmo(RSA)

R242













Bloco00010010(*n) and <=(*n,0.306279) and Bloco00000101(*m) and >(*m,0.401519) then

algoritmo(RSA)

R243













Bloco00010010(*n) and >(*n,0.306279) and Bloco10000100(*m) and <=(*m,0.494719) then

algoritmo(RSA)

R244












Bloco00111001(*v) and <=(*v,0.51396) and Bloco00100100(*b) and >(*b,0.476257) and

Bloco01111001(*n) and <=(*n,0.410698) then algoritmo(RSA)

54

R245









Bloco10011011(*j) and >(*j,0.519377) and Bloco00000101(*k) and <=(*k,0.430197) then

algoritmo(RSA)

R246





Bloco00000110(*o) and <=(*o,0.367847) then algoritmo(RSA)

R247



algoritmo(RSA)

R248



algoritmo(RSA)

R249




algoritmo(RSA)

R250












<=(*j, 0.021706) and Bloco1110111000111110(*k) and <=(*k, 0.021706)then algoritmo(RSA)

R251





Bloco0011(*o) and >(*o, 6.283414) then algoritmo(RSA)

R252





algoritmo(RSA)

55

R253





algoritmo(RSA)

R254





algoritmo(RSA)

R255





and Bloco1101(*p) and >(*p, 6.120124) and Bloco0000(*a) and >(*a, 6.453782) then

algoritmo(RSA)

R256




6.321505) and Bloco0001(*i) and >(*i, 6.228637) and Bloco0000(*o) and >(*o, 6.070109) and

Bloco0111(*p) and <=(*p, 6.358852) and Bloco1100(*a) and <=(*a, 6.183639) and

Bloco1001(*s) and >(*s, 6.31627) then algoritmo(RSA)

R257





Bloco0111(*p) and <=(*p, 6.358852) and Bloco1100(*a) and >(*a, 6.183639) then

algoritmo(RSA)

R258





and Bloco0001(*p) and >(*p, 6.08883) and Bloco0011(*a) and <=(*a, 6.435474) then

algoritmo(RSA)

R259




6.153749) and Bloco1110(*i) and <=(*i, 5.905858) then algoritmo(RSA)

R260




6.153749) and Bloco1110(*i) and >(*i, 5.905858) and Bloco1011(*o) and >(*o, 6.321505)

then algoritmo(RSA)

56

R261





and Bloco1101(*p) and <=(*p, 6.263457) and Bloco1000(*a) and <=(*a, 6.232959) and

Bloco1000(*s) and <=(*s, 6.202173) then algoritmo(RSA)

R262





and Bloco1101(*p) and <=(*p, 6.263457) and Bloco1000(*a) and <=(*a, 6.232959) and

Bloco1000(*s) and >(*s, 6.202173) and Bloco1001(*d) and <=(*d, 6.180767) then

algoritmo(RSA)

R263





and Bloco1101(*p) and <=(*p, 6.263457) and Bloco1000(*a) and >(*a, 6.232959) and

Bloco0001(*s) and <=(*s, 6.307978) then algoritmo(RSA)

R264





and Bloco1101(*p) and >(*p, 6.263457) and Bloco0000(*a) and >(*a, 6.210095) and

Bloco1101(*s) and >(*s, 6.306123) then algoritmo(RSA)

R265





Bloco0000(*p) and <=(*p, 6.123404) then algoritmo(RSA)

R266



and <=(*t, 6.492429) and Bloco1001(*y) and >(*y, 6.354841) and Bloco1000(*u) and <=(*u,

6.330637) and Bloco1001(*i) and <=(*i, 6.403222) then algoritmo(RSA)

R267



and <=(*t, 6.492429) and Bloco1001(*y) and >(*y, 6.354841) and Bloco1000(*u) and <=(*u,


then algoritmo(RSA)

R268



and <=(*t, 6.492429) and Bloco1001(*y) and >(*y, 6.354841) and Bloco1000(*u) and >(*u,

6.330637)then algoritmo(RSA)

57

R269


and Bloco11011000(*e) and <=(*e, 0.422357) and Bloco00001000(*r) and <=(*r, 0.545554)

and Bloco11101010(*t) and >(*t, 0.377155) and Bloco11111111(*y) and >(*y, 0.378839) and


algoritmo(DES)

R270



then algoritmo(DES)

R271



then algoritmo(DES)

R272



and Bloco11011100(*t) and <=(*t, 0.355823) and Bloco11111111(*y) and <=(*y, 0.330142)

and Bloco11100111(*u) and <=(*u, 0.451745) and Bloco11010011(*i) and <=(*i, 0.394504)

and Bloco11100011(*o) and <=(*o, 0.403675) and Bloco01100101(*p) and <=(*p, 0.293337)

then algoritmo(DES)

R273





and Bloco11100011(*o) and >(*o, 0.403675) then algoritmo(DES)

R274



and Bloco11011100(*t) and <=(*t, 0.355823) and Bloco11111111(*y) and >(*y, 0.330142)

and Bloco11100000(*u) and <=(*u, 0.363538) and Bloco11101010(*i) and >(*i, 0.385591)

then algoritmo(DES)

R275




and Bloco11100000(*u) and >(*u, 0.363538) and Bloco11101010(*i) and <=(*i, 0.303909)

and Bloco10011000(*o) and <=(*o, 0.356098) then algoritmo(DES)

R276



and Bloco11011100(*t) and >(*t, 0.355823) and Bloco11011000(*y) and <=(*y, 0.24119) and


R277





Bloco11101010(*o) and <=(*o, 0.407221) and Bloco00111001(*p) and <=(*p, 0.356408) then

algoritmo(DES)

R278






Bloco11100011(*a) and >(*a, 0.361865) and Bloco11100111(*s) and <=(*s, 0.333376) and


58

R279





Bloco11100111(*o) and <=(*o, 0.357192) and Bloco11100111(*p) and >(*p, 0.343077) and

Bloco00001000(*a) and <=(*a, 0.446852) and Bloco11100011(*s) and <=(*s, 0.389001) then

algoritmo(DES)

R280







Bloco11010011(*d) and <=(*d, 0.409445) and Bloco11100000(*f) and >(*f, 0.392047) and

Bloco11101010(*g) and <=(*g, 0.375307) then algoritmo(DES)

R281








Bloco11101010(*g) and >(*g, 0.375307) and Bloco01100101(*h) and <=(*h, 0.388584) then

algoritmo(DES)

R282







Bloco11010011(*d) and >(*d, 0.409445) and Bloco01100101(*f) and >(*f, 0.408497) then

algoritmo(DES)

R283






Bloco11101110(*a) and >(*a, 0.361563) and Bloco11101110(*s) and >(*s, 0.423223) then

algoritmo(DES)

R284






algoritmo(DES)

R285





algoritmo(DES)

59

R286





then algoritmo(DES)

R287




and Bloco11100000(*u) and >(*u, 0.37226) and Bloco11100000(*i) and >(*i, 0.445001) then

algoritmo(DES)

R288





R289



and Bloco11011011(*t) and >(*t, 0.371747) and Bloco11011000(*y) and >(*y, 0.42871) then

algoritmo(DES)

R290




then algoritmo(DES)

R291



and Bloco11011100(*t) and >(*t, 0.37032) then algoritmo(DES)

R292



algoritmo(DES)

R293




Bloco00111001(*u) and <=(*u, 0.356408) then algoritmo(DES)

R294




algoritmo(DES)

R295




algoritmo(DES)

R296



and Bloco01010001(*t) and <=(*t, 0.461087) then algoritmo(DES)



R298



algoritmo(DES)

R299if Bloco11111000(*q) and >(*q, 0.496894) and Bloco11101010(*w) and <=(*w, 0.397969)

then algoritmo(DES)

60




then algoritmo(DES)


then algoritmo(DES)


then algoritmo(DES)

R304 if Bloco01100000(*q) and <=(*q, 0.259032) then algoritmo(DES)






algoritmo(DES)



R310



algoritmo(DES)



R312if Bloco1110(*q) and >(*q, 6.074608) and Bloco0000(*w) and <=(*w, 6.013734) then

algoritmo(DES)

R313



algoritmo(DES)

R314









R318if Bloco1111(*q) and <=(*q, 6.022264) and Bloco0111(*w) and <=(*w, 6.356622) then

algoritmo(DES)


algoritmo(DES)


algoritmo(DES)


algoritmo(DES)









61



R327


<=(*w, 0) and Bloco1100100111100100(*e) and <=(*e, 0) and Bloco1010100110111000(*r)

and <=(*r, 0) and Bloco1101101110000010(*t) and <=(*t, 0) and

Bloco0010110110101110(*y) and <=(*y, 0) and Bloco0000010100110100(*u) and <=(*u, 0)

then algoritmo(DES)


then algoritmo(DES)

R329



then algoritmo(DES)

R330




R331





then algoritmo(DES)

R332




then algoritmo(DES)

R333






Bloco00001110(*a) and >(*a, 0.382566) then algoritmo(DES)

R334








R335






Bloco00010010(*a) and >(*a, 0.289137) and Bloco00101010(*s) and >(*s, 0.27356) and

Bloco00001000(*d) and <=(*d, 0.483191) and Bloco01100100(*f) and <=(*f, 0.519197) and

Bloco01000000(*g) and <=(*g, 0.481644) and Bloco11101011(*h) and <=(*h, 0.522747) and

Bloco01010010(*j) and <=(*j, 0.496252) and Bloco00110010(*k) and <=(*k, 0.488334) and

Bloco10100011(*l) and >(*l, 0.511827) and Bloco00001100(*z) and >(*z, 0.375307) then

algoritmo(DES)

62

R336









Bloco01010010(*j) and <=(*j, 0.496252) and Bloco00110010(*k) and >(*k, 0.488334) and

Bloco00101011(*l) and <=(*l, 0.314939) then algoritmo(DES)

R337








Bloco01000000(*g) and >(*g, 0.481644) and Bloco00001011(*h) and <=(*h, 0.429743) then

algoritmo(DES)

R338







Bloco00001000(*d) and <=(*d, 0.483191) and Bloco01100100(*f) and >(*f, 0.519197) then

algoritmo(DES)

R339





Bloco01110001(*o) and >(*o, 0.528365) then algoritmo(DES)

R340




Bloco01111011(*u) and <=(*u, 0.487062) and Bloco10011001(*i) and >(*i,0.488895) and


R341




Bloco01111011(*u) and <=(*u, 0.487062) and Bloco10011001(*i) and >(*i,0.488895) and

Bloco10111100(*o) and >(*o, 0.387222) and Bloco00101001(*p) and <=(*p, 0.343454) then

algoritmo(DES)

R342





algoritmo(DES)

63

R343





R344




algoritmo(DES)

R345












<=(*j, 0.020036) and Bloco0011111001001110(*k) and <=(*k, 0.027167) and

Bloco1000001001011011(*l) and >(*l, 0.021409) and Bloco0000001000100101(*z) and >(*z,

0) then algoritmo(DES)

R346












>(*j, 0.020036) and Bloco0000000100110010(*k) and <=(*k, 0) then algoritmo(DES)

R347











Bloco0000100011110110(*h) and >(*h, 0.021409) and Bloco0000000000000101(*j) and

<=(*j, 0) then algoritmo(DES)

64

R348










<=(*f, 0.021706) and Bloco0111101001000100(*g) and >(*g, 0.025445) then algoritmo(DES)

R349










>(*f, 0.021706) then algoritmo(DES)

R350







R351






R352




<=(*t, 0.02736) and Bloco1011011101001100(*y) and >(*y, 0.021706) then algoritmo(DES)

R353




>(*t, 0.02736) then algoritmo(DES)

R354



Bloco1111011001011010(*r) and >(*r, 0.023975) then algoritmo(DES)




65

R357




and Bloco11100011(*u) and <=(*u, 0.437039) then algoritmo(Blowfish)

R358





algoritmo(Blowfish)

R359




and Bloco11100111(*u) and >(*u, 0.451745) then algoritmo(Blowfish)

R360




and Bloco11100000(*u) and >(*u, 0.363538) and Bloco11101010(*i) and >(*i, 0.303909) and

Bloco11011000(*o) and <=(*o, 0.316756) then algoritmo(Blowfish)

R361






Bloco11011011(*a) and >(*a, 0.370523) then algoritmo(Blowfish)

R362





Bloco11101010(*o) and >(*o, 0.407221) then algoritmo(Blowfish)

R363








algoritmo(Blowfish)

R364







R365







algoritmo(Blowfish)

66

R366







Bloco11010011(*d) and >(*d, 0.409445) and Bloco01100101(*f) and <=(*f, 0.408497) then

algoritmo(Blowfish)

R367






algoritmo(Blowfish)

R368





Bloco00001000(*o) and >(*o, 0.314704) and Bloco11011011(*p) and >(*p, 0.300259) and


R369




and Bloco11100000(*u) and <=(*u, 0.37226) and Bloco11100111(*i) and >(*i, 0.401553) then

algoritmo(Blowfish)

R370




and Bloco11111111(*u) and <=(*u, 0.478731) then algoritmo(Blowfish)

R371





algoritmo(Blowfish)

R372






R373





and Bloco10011000(*e) and <=(*e, 0.346117) then algoritmo(Blowfish)


Bloco01100101(*e) and <=(*e, 0.330806) then algoritmo(Blowfish)

R376



Bloco11010011(*t) and >(*t, 0.3861) and Bloco01100101(*y) and >(*y, 0.358522) then

algoritmo(Blowfish)

67







R380




algoritmo(Blowfish)




Bloco00000000(*e) and >(*e, 0.303114) then algoritmo(Blowfish)

R383 if Bloco01000110(*q) and <=(*q, 0.269143) then algoritmo(Blowfish)






algoritmo(Blowfish)

R387



algoritmo(Blowfish)

R388



algoritmo(Blowfish)

R389



algoritmo(Blowfish)

R390



algoritmo(Blowfish)

R391




algoritmo(Blowfish)

R392


Bloco0001(*e) and <=(*e, 6.049655) and Bloco0111(*r) and <=(*r, 6.350631) then

algoritmo(Blowfish)

R393



algoritmo(Blowfish)





R396



algoritmo(Blowfish)

68


algoritmo(Blowfish)

R398



algoritmo(Blowfish)


algoritmo(Blowfish)



R401






>(*i, 0.022012) then algoritmo(Blowfish)


>(*w, 0.025621) and Bloco0000101110000101(*e) and <=(*e, 0) then algoritmo(Blowfish)

R403



Bloco0001101011110001(*r) and <=(*r, 0) then algoritmo(Blowfish)




<=(*w, 0) then algoritmo(Blowfish)







R410if Bloco0001001010100100(*q) and >(*q, 0) and Bloco0000000100101011(*w) and <=(*w,

0) then algoritmo(Blowfish)



R412





R413




and Bloco11110111(*u) and >(*u, 0.451869) then algoritmo(Blowfish)

R414






69

R415




and Bloco11100001(*u) and >(*u, 0.363343) and Bloco11100101(*i) and >(*i, 0.348432)


R416






Bloco00001110(*a) and <=(*a, 0.382566) then algoritmo(Blowfish)

R417






Bloco00010010(*a) and <=(*a, 0.289137) and Bloco00101010(*s) and >(*s, 0.426821) then

algoritmo(Blowfish)

R418










Bloco10100011(*l) and <=(*l, 0.511827) and Bloco10011101(*z) and <=(*z, 0.278404) then

algoritmo(Blowfish)

R419










Bloco10100011(*l) and <=(*l, 0.511827) and Bloco10011101(*z) and >(*z, 0.278404) and

Bloco00000110(*x) and <=(*x, 0.263926) then algoritmo(Blowfish)

70

R420











Bloco00000110(*x) and >(*x, 0.263926) and Bloco11110011(*c) and <=(*c, 0.279369) and

Bloco00000100(*v) and >(*v, 0.477685) then algoritmo(Blowfish)

R421











Bloco00000110(*x) and >(*x, 0.263926) and Bloco11110011(*c) and >(*c, 0.279369) and

Bloco01100000(*v) and >(*v, 0.288819) and Bloco11001101(*b) and >(*b, 0.28023) and

Bloco00101011(*n) and <=(*n, 0.484457) and Bloco00111010(*m) and <=(*m, 0.259882)


R422











Bloco00000110(*c) and >(*c, 0.263926) and Bloco11110011(*v) and >(*v, 0.279369) and

Bloco01100000(*b) and >(*b, 0.288819) and Bloco11001101(*n) and >(*n, 0.28023) and

Bloco00101011(*m) and >(*m, 0.484457) then algoritmo(Blowfish)

71

R423










Bloco10100011(*l) and >(*l, 0.511827) and Bloco00001100(*z) and <=(*z, 0.375307) then

algoritmo(Blowfish)

R424








Bloco01000000(*g) and <=(*g, 0.481644) and Bloco11101011(*h) and >(*h, 0.522747) then

algoritmo(Blowfish)

R425








Bloco01000000(*g) and >(*g, 0.481644) and Bloco00001011(*h) and >(*h, 0.429743) then

algoritmo(Blowfish)

R426





algoritmo(Blowfish)

R427




Bloco00101000(*u) and >(*u, 0.374782) then algoritmo(Blowfish)

R428




algoritmo(Blowfish)

R429



Bloco11101100(*t) and >(*t, 0.388249) then algoritmo(Blowfish)

R430




algoritmo(Blowfish)

72

R431




R432



algoritmo(Blowfish)

R433



algoritmo(Blowfish)

R434













Bloco1000001001011011(*l) and <=(*l, 0.021409) and Bloco0001101111001100(*z) and

<=(*z, 0.021706) and Bloco1001101100011100(*x) and <=(*x, 0.021409) and

Bloco1110001000111010(*c) and >(*c, 0.024528) and Bloco0000000010111110(*v) and

R435














<=(*z, 0.021706) and Bloco1001101100011100(*x) and >(*x, 0.021409) and

Bloco0000001000110100(*c) and <=(*c, 0) then algoritmo(Blowfish)

73

R436














>(*z, 0.021706) then algoritmo(Blowfish)

R437













Bloco1000001001011011(*l) and >(*l, 0.021409) and Bloco0000001000100101(*z) and

<=(*z, 0) then algoritmo(Blowfish)

R438












<=(*j, 0.020036) and Bloco0011111001001110(*k) and >(*k, 0.027167) then

algoritmo(Blowfish)

74

R439











Bloco0000100011110110(*h) and >(*h, 0.021409) and Bloco0000000000000101(*j) and

>(*j, 0) then algoritmo(Blowfish)

R440









Bloco1001001100000110(*d) and >(*d, 0.023952) then algoritmo(Blowfish)

R441








<=(*a, 0.021706) and Bloco0000000001111111(*s) and >(*s, 0.027152) then

algoritmo(Blowfish)

R442








>(*a, 0.021706) then algoritmo(Blowfish)

R443







Bloco0111101000101100(*p) and >(*p, 0.023975) then algoritmo(Blowfish)

R444






>(*i, 0.022012) then algoritmo(Blowfish)

75

R445


<=(*w, 0.021706) and Bloco1010000100111110(*e) and >(*e, 0.026048) then

algoritmo(Blowfish)

R446





algoritmo(Blowfish)

R447



Bloco1011(*t) and >(*t, 6.13237) and Bloco1101(*y) and >(*y, 5.805646) and Bloco0011(*u)

and <=(*u, 6.31455) and Bloco0101(*i) and <=(*i, 5.89614) then algoritmo(Blowfish)

R448




and <=(*u, 6.31455) and Bloco0101(*i) and >(*i, 5.89614) and Bloco1000(*o) and >(*o,

5.997309) and Bloco0100(*p) and >(*p, 6.126765) and Bloco1101(*a) and <=(*a, 6.067477)

and Bloco0000(*s) and <=(*s, 6.236707) then algoritmo(Blowfish)

R449




and >(*u, 6.31455) and Bloco1000(*i) and >(*i, 6.057064) and Bloco1000(*o) and <=(*o,

6.20371) and Bloco0110(*p) and <=(*p, 6.229978) then algoritmo(Blowfish)

R450




and >(*u, 6.31455) and Bloco1000(*i) and >(*i, 6.057064) and Bloco1000(*o) and >(*o,

6.20371) and Bloco1001(*p) and <=(*p, 6.345644) then algoritmo(Blowfish)

R451



and >(*t, 6.291323) then algoritmo(Blowfish)

R452






algoritmo(Blowfish)

R453






Bloco0011(*a) and <=(*a, 6.491894) then algoritmo(Blowfish)

76

R454





Bloco1011(*o) and >(*o, 6.181517) and Bloco1010(*p) and >(*p, 6.38169) then

algoritmo(Blowfish)

R455



Bloco1110(*t) and <=(*t, 6.47795) and Bloco0001(*y) and >(*y, 6.451613) and Bloco1110(*u)

and <=(*u, 6.089795) and Bloco0010(*i) and <=(*i, 6.119926) then algoritmo(Blowfish)

R456




and >(*u, 6.089795) then algoritmo(Blowfish)

R457




and <=(*u, 6.484713) and Bloco1111(*i) and <=(*i, 6.340417) and Bloco0001(*o) and <=(*o,

6.491627) then algoritmo(Blowfish)

R458





R459




algoritmo(Blowfish)

R460




R461





algoritmo(Blowfish)

R462




algoritmo(Blowfish)

R463



algoritmo(Blowfish)

R464






77

R466



and >(*t, 6.068454) and Bloco1111(*y) and <=(*y, 6.308587) and Bloco1001(*u) and >(*u,

6.117115) and Bloco1011(*i) and <=(*i, 6.294284) then algoritmo(RC4)

R467




6.117115) and Bloco1011(*i) and >(*i, 6.294284) and Bloco1110(*o) and <=(*o, 5.93402) and

Bloco1001(*p) and >(*p, 6.237385) then algoritmo(RC4)

R468





then algoritmo(RC4)

R469





Bloco1110(*p) and >(*p, 6.061876) then algoritmo(RC4)

R470





R471



Bloco1001(*t) and <=(*t, 6.605099) then algoritmo(RC4)

R472



algoritmo(RC4)



R474





algoritmo(RC4)

R475




algoritmo(RC4)

R476



Bloco1011(*t) and >(*t, 6.532663)then algoritmo(RC4)

R477




then algoritmo(RC4)

78

R478




and Bloco11100011(*u) and >(*u, 0.437039) then algoritmo(RC4)

R479



and Bloco11101010(*t) and >(*t, 0.377155) and Bloco11111111(*y) and <=(*y, 0.378839)

and Bloco11010011(*u) and <=(*u, 0.364668) then algoritmo(RC4)

R480





then algoritmo(RC4)

R481



then algoritmo(RC4)

R482





and Bloco11100011(*o) and <=(*o, 0.403675) and Bloco01100101(*p) and >(*p, 0.293337)

then algoritmo(RC4)

R483





then algoritmo(RC4)

R484





then algoritmo(RC4)

R485





and Bloco10011000(*o) and >(*o, 0.356098) then algoritmo(RC4)

R486





R487






algoritmo(RC4)

79

R488







Bloco01100101(*d) and <=(*d, 0.436741) and Bloco11111111(*f) and <=(*f, 0.350216) then

algoritmo(RC4)

R489






Bloco00001000(*a) and <=(*a, 0.446852) and Bloco11100011(*s) and >(*s, 0.389001) then

algoritmo(RC4)

R490





Bloco11100111(*o) and >(*o, 0.357192) and Bloco01100101(*p) and >(*p, 0.500064) then

algoritmo(RC4)

R491




and Bloco11100000(*u) and >(*u, 0.37226) and Bloco11100000(*i) and <=(*i, 0.445001) then

algoritmo(RC4)

R492





R493



and Bloco11011100(*t) and <=(*t, 0.37032) and Bloco00001000(*y) and <=(*y,

0.370117)then algoritmo(RC4)

R494






algoritmo(RC4)

R496





then algoritmo(RC4)


then algoritmo(RC4)


algoritmo(RC4)


then algoritmo(RC4)

80





and Bloco10000000(*e) and >(*e, 0.390257)then algoritmo(RC4)

R504









R507



algoritmo(RC4)

R508





algoritmo(RC4)

R510



algoritmo(RC4)




<=(*w, 0) then algoritmo(RC4)







R517


>(*w, 0) and Bloco0100011111111000(*e) and <=(*e, 0.021706) and



Bloco1001110010100010(*u) and >(*u, 0.025893) and Bloco1100100111100100(*i) and

>(*i, 0) and Bloco1010100110111000(*o) and >(*o, 0) and Bloco1101101110000010(*p) and

>(*p, 0) and Bloco0010110110101110(*a) and >(*a, 0) and Bloco0000010100110100(*s) and

>(*s, 0) and Bloco1011011110101111(*d) and >(*d, 0.027012) and

Bloco1101110111110101(*f) and >(*f, 0.021706) and Bloco1010000100111110(*g) and

>(*g, 0.026048) and Bloco1111011001011010(*h) and >(*h, 0.023975) and

Bloco1011111111101011(*j) and >(*j, 0.02736) and Bloco1011011101001100(*k) and >(*k,

0.021706) and Bloco1111011111100001(*l) and >(*l, 0.024516) and

Bloco1100001101001010(*z) and <=(*z, 0.022012) and Bloco0101101000101101(*x) and

>(*x, 0.026918) and Bloco0000000001111111(*c) and <=(*c, 0.025621) and

Bloco0000101110000101(*v) and >(*v, 0) and Bloco1100010111111010(*b) and >(*b,

81

R518





and Bloco10110101(*o) and >(*o, 0.302239) and Bloco00101101(*p) and <=(*p, 0.331904)

and Bloco10101110(*a) and >(*a, 0.404238) then algoritmo(RC4)

R519





and Bloco10110101(*o) and >(*o, 0.302239) and Bloco00101101(*p) and >(*p, 0.331904)

then algoritmo(RC4)

R520







Bloco00010011(*d) and <=(*d, 0.363909) then algoritmo(RC4)

R521












Bloco00000100(*v) and <=(*v, 0.477685) then algoritmo(RC4)

R522












Bloco01100000(*v) and <=(*v, 0.288819) then algoritmo(RC4)

82

R523












Bloco01100000(*v) and >(*v, 0.288819) and Bloco11001101(*b) and <=(*b, 0.28023) then

algoritmo(RC4)

R524













Bloco00101011(*n) and <=(*n, 0.484457) and Bloco00111010(*m) and >(*m, 0.259882) and

Bloco00001000(*qq) and <=(*qq, 0.298954) and Bloco00000010(*ww) and <=(*ww,

R525









Bloco01010010(*j) and <=(*j, 0.496252) and Bloco00110010(*k) and >(*k, 0.488334) and

Bloco00101011(*l) and >(*l, 0.314939) then algoritmo(RC4)

R526









Bloco01010010(*j) and >(*j, 0.496252) then algoritmo(RC4)

83

R527








R528





Bloco10111100(*o) and >(*o, 0.387222) and Bloco00101001(*p) and >(*p, 0.343454)then

algoritmo(RC4)

R529















Bloco1110001000111010(*c) and <=(*c, 0.024528) and Bloco1100100011011010(*v) and

R530
















84

R531
















R532
















R533
















85

R534
















R535
















R536















Bloco1110001000111010(*c) and >(*c, 0.024528) and Bloco0000000010111110(*v) and

86

R537














<=(*z, 0.021706) and Bloco1001101100011100(*x) and >(*x, 0.021409) and

Bloco0000001000110100(*c) and >(*c, 0)then algoritmo(RC4)

R538






algoritmo(RC4)

R539






Bloco0111(*a) and >(*a, 6.297364) then algoritmo(RC4)

R540





algoritmo(RC4)

R541




and <=(*u, 6.089795) and Bloco0010(*i) and >(*i, 6.119926) then algoritmo(RC4)

R542



and <=(*t, 6.290658) and Bloco1111(*y) and <=(*y, 5.90785) then algoritmo(RC4)

R543





R544



and >(*t, 6.290658) and Bloco0110(*y) and >(*y, 6.129586) then algoritmo(RC4)

87

R545




R546





R547





algoritmo(RC4)

R548





and <=(*o, 6.113657) then algoritmo(RC4)

R549





R550


Bloco0010(*e) and >(*e, 6.408581) and Bloco0011(*r) and <=(*r, 6.418064)then

algoritmo(RC4)


Bloco10100100(*e) and <=(*e, 0.323215) then algoritmo(RSA)

R552




then algoritmo(RSA)

R553




algoritmo(RSA)


then algoritmo(RSA)

R555 if Bloco00100011(*q) and <=(*q, 0.436264)then algoritmo(RSA)


0) then algoritmo(RSA)











88

R562





Bloco0000110001001100(*u) and <=(*u, 0.021706) and Bloco1010010101000011(*a) and




Bloco0011100101111111(*h) and <=(*h, 0.021706)then algoritmo(RSA)

R563





then algoritmo(RSA)

R564





and Bloco10110101(*o) and <=(*o, 0.302239) then algoritmo(RSA)

R565






and Bloco10101110(*a) and <=(*a, 0.404238) then algoritmo(RSA)

R566





then algoritmo(RSA)

R567







algoritmo(RSA)

R568














Bloco00001000(*qq) and <=(*qq, 0.298954) and Bloco00000010(*ww) and >(*ww,

89

R569














Bloco00001000(*qq) and >(*qq, 0.298954) then algoritmo(RSA)

R570




algoritmo(RSA)

R571


Bloco01100000(*e) and >(*e, 0.422746) and Bloco01100011(*r) and >(*r, 0.380108)then

algoritmo(RSA)

R572
















R573












>(*j, 0.020036) and Bloco0000000100110010(*k) and >(*k, 0)then algoritmo(RSA)

90



R575








R578



then algoritmo(DES)


then algoritmo(DES)


then algoritmo(DES)



R582



then algoritmo(DES)


R584



algoritmo(DES)

R585



algoritmo(DES)

R586



algoritmo(DES)



algoritmo(DES)





R591



algoritmo(DES)


algoritmo(DES)



R594



algoritmo(DES)



91

R596



algoritmo(DES)

R597







algoritmo(DES)


algoritmo(DES)


<=(*w, 0.00523) and Bloco0001011011011110(*e) and <=(*e, 0.00335) then algoritmo(DES)








R607


>(*w, 0.026681) and Bloco0000010010110001(*e) and <=(*e, 0.002615) then

algoritmo(DES)

R608






then algoritmo(DES)

R609





and Bloco00111001(*o) and <=(*o, 0.488895) then algoritmo(DES)

R610






and Bloco11100010(*a) and <=(*a, 0.249082) then algoritmo(DES)

R611






and Bloco11100010(*a) and >(*a, 0.249082) and Bloco10101100(*s) and <=(*s, 0.276587)

and Bloco00001100(*d) and >(*d, 0.325777) then algoritmo(DES)

92

R612






and Bloco11100010(*a) and >(*a, 0.249082) and Bloco10101100(*s) and >(*s, 0.276587)

and Bloco00000001(*d) and <=(*d, 0.520905) and Bloco00000111(*f) and <=(*f, 0.276587)

then algoritmo(DES)

R613







and Bloco00000001(*d) and <=(*d, 0.520905) and Bloco00000111(*f) and >(*f, 0.276587)

and Bloco10001110(*g) and <=(*g, 0.278404) and Bloco00000110(*h) and <=(*h, 0.448808)

then algoritmo(DES)

R614








and Bloco10001110(*g) and >(*g, 0.278404) and Bloco10110100(*h) and <=(*h, 0.575737)

and Bloco00010100(*j) and >(*j, 0.276587) and Bloco10100100(*k) and <=(*k, 0.52089) and

Bloco00001110(*l) and >(*l, 0.256341) and Bloco11100000(*z) and <=(*z, 0.251924) and

Bloco00000011(*x) and <=(*x, 0.395984) then algoritmo(DES)

R615










Bloco00001110(*l) and >(*l, 0.256341) and Bloco11100000(*z) and >(*z, 0.251924) and

Bloco11100001(*x) and <=(*x, 0.237729) and Bloco00000101(*c) and >(*c, 0.395875) then

algoritmo(DES)

93

R616












Bloco01110000(*v) and >(*v, 0.249204) and Bloco10001100(*b) and <=(*b, 0.521251) and

Bloco01101110(*n) and <=(*n, 0.266293) and Bloco10000010(*m) and >(*m, 0.428128) then

algoritmo(DES)

R617













Bloco01101110(*n) and >(*n, 0.266293) and Bloco01100011(*m) and <=(*m, 0.50305) and

Bloco10111110(*qq) and <=(*qq, 0.262758) and Bloco00000000(*ww) and <=(*ww,

R618














Bloco10111110(*qq) and >(*qq, 0.262758) and Bloco10101000(*ww) and <=(*ww,

94

R619













Bloco01101110(*n) and >(*n, 0.266293) and Bloco01100011(*m) and >(*m, 0.50305) then

algoritmo(DES)

R620












Bloco01110000(*v) and >(*v, 0.249204) and Bloco10001100(*b) and >(*b, 0.521251) then

algoritmo(DES)

R621







and Bloco00000001(*d) and >(*d, 0.520905) then algoritmo(DES)

R622






R623






R625




95

R626




R627









Bloco0001011101010011(*d) and >(*d, 0.001308) and Bloco0000000000000110(*f) and

>(*f, 0) then algoritmo(DES)

R628








<=(*a, 0.021706) and Bloco0100010110010101(*s) and >(*s, 0.021706) then algoritmo(DES)

R629








<=(*a, 0.00335) then algoritmo(DES)

R630







R631






>(*i, 0.022012) then algoritmo(DES)

R632






96

R633




<=(*t, 0.02751) and Bloco0010111001000000(*y) and >(*y, 0.027181) then algoritmo(DES)

R634




<=(*t, 0.00335) then algoritmo(DES)


>(*w, 0.027211) and Bloco0000100011011111(*e) and >(*e, 0.001675) then algoritmo(DES)





R638



algoritmo(DES)

R639



algoritmo(DES)

R640





R641





R642



algoritmo(DES)

R643





algoritmo(DES)

R644







Bloco0000(*d) and <=(*d, 6.400546) then algoritmo(DES)

97

R645






Bloco1101(*a) and <=(*a, 6.237368) and Bloco0011(*s) and <=(*s, 6.236936) and


R646







Bloco1101(*d) and <=(*d, 6.402713) and Bloco0001(*f) and <=(*f, 6.37475) then

algoritmo(DES)

R647






R648





and <=(*o, 6.488951) then algoritmo(DES)

R649





algoritmo(DES)

R650





R651





algoritmo(DES)

R652





Bloco1011(*o) and >(*o, 6.13555) and Bloco1110(*p) and <=(*p, 6.31455) and Bloco0100(*a)

and <=(*a, 6.123809) then algoritmo(DES)

98

R653





Bloco1011(*o) and >(*o, 6.13555) and Bloco1110(*p) and >(*p, 6.31455) then algoritmo(DES)

R654





R655






R656




6.217328) and Bloco0110(*i) and <=(*i, 6.340217) then algoritmo(DES)

R657





and Bloco11101010(*o) and >(*o, 0.374612) then algoritmo(Blowfish)

R658






R659





algoritmo(Blowfish)

R660






algoritmo(Blowfish)

R661





algoritmo(Blowfish)

R662


and Bloco11110001(*e) and >(*e, 0.46663) and Bloco10011011(*r) and <=(*r, 0.347657) and


algoritmo(Blowfish)

99

R663




R664




algoritmo(Blowfish)

R665





algoritmo(Blowfish)

R666




algoritmo(Blowfish)

R667




algoritmo(Blowfish)

R668




Bloco11111101(*u) and <=(*u, 0.290416) then algoritmo(Blowfish)

R669







R670







Bloco11110111(*d) and <=(*d, 0.440589) then algoritmo(Blowfish)

R671




Bloco11111101(*u) and >(*u, 0.290416) and Bloco10101010(*i) and >(*i, 0.471631) and




R673






100

R675
























R687



algoritmo(Blowfish)

R688




R689






R691







algoritmo(Blowfish)





R696



algoritmo(Blowfish)



101



R699



algoritmo(Blowfish)

R700

if Bloco0111110011100111(*q) and >(*q, 0.022012) and Bloco0000001000101001(*w) and

<=(*w, 0.00523) and Bloco0000011000110010(*e) and <=(*e, 0) and

Bloco0000101001011111(*r) and <=(*r, 0.00335) then algoritmo(Blowfish)


<=(*w, 0.001675) then algoritmo(Blowfish)

R702



algoritmo(Blowfish)


R704




R705 if Bloco0000100101100001(*q) and <=(*q, 0.002615) then algoritmo(Blowfish)

R706



and Bloco11101110(*t) and >(*t, 0.4092) then algoritmo(Blowfish)

R707





and Bloco00111100(*o) and <=(*o, 0.29969) then algoritmo(Blowfish)

R708







R709







R710







R711






and Bloco11100010(*a) and >(*a, 0.249082) and Bloco10101100(*s) and <=(*s, 0.276587)

and Bloco00001100(*d) and <=(*d, 0.325777) then algoritmo(Blowfish)

102

R712








and Bloco10001110(*g) and <=(*g, 0.278404) and Bloco00000110(*h) and >(*h, 0.448808)


R713









and Bloco00010100(*j) and <=(*j, 0.276587) and Bloco00000010(*k) and <=(*k, 0.358112)


R714












Bloco01110000(*v) and <=(*v, 0.249204) then algoritmo(Blowfish)

R715













Bloco01101110(*n) and <=(*n, 0.266293) and Bloco10000010(*m) and <=(*m, 0.428128)


103

R716














Bloco10111110(*qq) and <=(*qq, 0.262758) and Bloco00000000(*ww) and >(*ww,

R717















R718















104

R719














Bloco10111110(*qq) and >(*qq, 0.262758) and Bloco10101000(*ww) and >(*ww, 0.508871)

R720











Bloco11100001(*x) and >(*x, 0.237729) and Bloco11001110(*c) and >(*c, 0.527927) then

algoritmo(Blowfish)

R721


and Bloco11000111(e*) and <=(*e, 0.515105) and Bloco11110111(*r) and >(*r, 0.271739)

and Bloco00101101(*t) and >(*t, 0.515814) and Bloco01111100(*y) and <=(*y, 0.3125) then

algoritmo(Blowfish)

R722


and Bloco11000111(*e) and >(*e, 0.515105) and Bloco00110000(*r) and <=(*r, 0.3942) then

algoritmo(Blowfish)

R723




R724if Bloco11101000(*q) and <=(*q, 0.482027) and Bloco10100110(*w) and >(*w, 0.53756 ) and


R725



and Bloco00110101(*t) and <=(*t, 0.357194) then algoritmo(Blowfish)

R726




105

R727










>(*f, 0.021706) and Bloco0000000000100111(*g) and >(*g, 0.005025) then

algoritmo(Blowfish)

R728








>(*a, 0.021706) and Bloco0000101101110011(*s) and <=(*s, 0.001675) then

algoritmo(Blowfish)

R729








>(*a, 0.00335) then algoritmo(Blowfish)

R730




>(*t, 0.02751) then algoritmo(Blowfish)

R731




R732




R733



algoritmo(Blowfish)

R734

if Bloco0111110011100111(*q) and >(*q, 0.022012) and Bloco0000001000101001(*w) and


Bloco0000101001011111(*) and <=(*, 0.00335) then algoritmo(Blowfish)

R735





R736




106

R737



algoritmo(Blowfish)

R738




Bloco0001(*u) and <=(*u, 6.092451) then algoritmo(Blowfish)

R739





algoritmo(Blowfish)

R740





R741








Bloco0010(*g) and >(*g, 6.223132) then algoritmo(Blowfish)

R742







Bloco1110(*d) and >(*d, 6.137796) then algoritmo(Blowfish)

R743






R744





and >(*o, 6.488951) then algoritmo(Blowfish)

R745




algoritmo(Blowfish)

R746






107

R747





algoritmo(Blowfish)

R748





algoritmo(Blowfish)

R749






R750






algoritmo(Blowfish)

R751





Bloco1011(*o) and >(*o, 6.13555) and Bloco1110(*p) and <=(*p, 6.31455) and Bloco0100(*a)

and >(*a, 6.123809) then algoritmo(Blowfish)

R752





algoritmo(Blowfish)

R753





R754




6.217328) and Bloco0110(*i) and >(*i, 6.340217) then algoritmo(Blowfish)

R755





R756





and Bloco10000010(*o) and <=(*o, 0.491642) then algoritmo(RC4)

108

R757





then algoritmo(RC4)

R758



and Bloco11100000(*t) and <=(*t, 0.400166) and Bloco10010010(*y) and >(*y, 0.40678) and


R759



and Bloco11100000(*t) and <=(*t, 0.400166) and Bloco10010010(*y) and >(*y, 0.40678) and


algoritmo(RC4)

R760





R761




and Bloco11000111(*u) and >(*u, 0.358374) and Bloco11101000(*i) and >(*i, 0.390244)

then algoritmo(RC4)

R762


and Bloco11110001(*e) and <=(*e, 0.46663) and Bloco10101010(*r) and >(*r, 0.448997) and



R763




Bloco11101010 (*u) and >(*u, 0.408552) and Bloco01011001(*i) and <=(*i, 0.324719) then

algoritmo(RC4)

R764


and Bloco11110011(*e) and <=(*e, 0.331538) and Bloco01011001(*r) and <=(*r, 0.3568) and



algoritmo(RC4)

R765


and Bloco11110011(*e) and <=(*e, 0.331538) and Bloco01011001(*r) and <=(*r, 0.3568) and



R766




algoritmo(RC4)

R767




then algoritmo(RC4)

109

R768



Bloco01011001(*t) and <=(*t, 0.222006) and Bloco01011001(*y) and <=(*y, 0.204221)then

algoritmo(RC4)

R769




then algoritmo(RC4)

R770






then algoritmo(RC4)

R771






R772





R773



and Bloco10101010(*t) and >(*t, 0.434695) and Bloco10000010(*y) and >(*y, 0.362445)

then algoritmo(RC4)

R774





then algoritmo(RC4)

R775






R776





and Bloco11101010(*o) and <=(*o, 0.376097) then algoritmo(RC4)

R777






algoritmo(RC4)

110

R778





Bloco11101010(*o) and >(*o, 0.376097) then algoritmo(RC4)

R779




then algoritmo(RC4)

R780




and Bloco10010010(*u) and >(*u, 0.403506) and Bloco11110000(*i) and <=(*i, 0.3728) then

algoritmo(RC4)

R781




and Bloco11100111(*u) and <=(*u, 0.347241) and Bloco10010010(*i) and >(*i,

0.403506)then algoritmo(RC4)


then algoritmo(RC4)

R783






and Bloco00011100(*a) and <=(*a, 0.525961) then algoritmo(RC4)



and Bloco00011010(*e) and <=(*e, 0.443608) then algoritmo(RC4)



then algoritmo(RC4)


R789



algoritmo(RC4)

R790



algoritmo(RC4)



R792





algoritmo(RC4)



111

R795



algoritmo(RC4)


algoritmo(RC4)

R797



algoritmo(RC4)

R798 if Bloco0000(*q) and >(*q, 5.989908)then algoritmo(RC4)

R799



Bloco0000000000100111(*r) and <=(*r, 0.005025) then algoritmo(RC4)


<=(*w, 0) and Bloco1100001100010000(*e) and <=(*e, 0.003923)then algoritmo(RC4)

R801



and Bloco11101110(*t) and <=(*t, 0.4092) then algoritmo(RC4)

R802





and Bloco00111100(*o) and >(*o, 0.29969) and Bloco00100001(*p) and >(p*, 0.396018)

then algoritmo(RC4)

R803






then algoritmo(RC4)

R804






R805






then algoritmo(RC4)

R806









and Bloco00010100(*j) and <=(*j, 0.276587) and Bloco00000010(*k) and >(*k, 0.358112)

then algoritmo(RC4)

112

R807






then algoritmo(RC4)

R808










Bloco00001110(*l) and <=(*l, 0.256341) then algoritmo(RC4)

R809










Bloco00001110(*l) and >(*l, 0.256341) and Bloco11100000(*z) and <=(*z, 0.251924) and

Bloco00000011(*x) and >(*x, 0.395984) then algoritmo(RC4)

R810











Bloco11100001(*x) and <=(*x, 0.237729) and Bloco00000101(*c) and <=(*c, 0.395875) then

algoritmo(RC4)

R811









and Bloco00010100(*j) and >(*j, 0.276587) and Bloco10100100(*k) and >(*k, 0.52089) and

Bloco00000010(*l) and <=(*l, 0.428128) then algoritmo(RC4)

113

R812








and Bloco10001110(*g) and >(*g, 0.278404) and Bloco10110100(*h) and >(*h, 0.575737)

then algoritmo(RC4)

R813






R814



and Bloco00101101(*t) and >(*t, 0.515814) and Bloco01111100(*y) and >(*y, 0.3125) then

algoritmo(RC4)



R816if Bloco11101000(*q) and >(*q, 0.482027) and Bloco10011111(*w) and >(*w, 0.520907)then

algoritmo(RC4)

R817















Bloco0000000001010001(*c) and >(*c, 0) then algoritmo(RC4)

114

R818














<=(*z, 0.021706) and Bloco1110101010000010(*x) and >(*x, 0.021706) then algoritmo(RC4)

R819














>(*z, 0.021706) then algoritmo(RC4)

R820













Bloco0110010110011010(*l) and >(*l, 0.021409) then algoritmo(RC4)

115

R821












<=(*j, 0.021706) and Bloco0000010010010000(*k) and >(*k, 0.021409) then algoritmo(RC4)

R822





Bloco1111001111011100(*u) and <=(*uu, 0.027263) and Bloco1011101000001010(*i) and







>(*j, 0.021706) then algoritmo(RC4)

R823











Bloco1001011011001100(*h) and >(*h, 0.021706) then algoritmo(RC4)

R824










<=(*f, 0.021706) and Bloco0011011010111100(*g) and >(*g, 0.021706) then algoritmo(RC4)

116

R825










>(*f, 0.021706) and Bloco0000000000100111(*g) and <=(*g, 0.005025) then algoritmo(RC4)

R826








>(*a, 0.021706) and Bloco0000101101110011(*s) and >(*s, 0.001675) then algoritmo(RC4)

R827



Bloco0000000011100001(*r) and >(*r, 0.00335) then algoritmo(RC4)

R828

if Bloco0111110011100111(*q) and >(*q, 0.022012 ) and Bloco0000001000101001(*w) and


Bloco0000101001011111(*r) and >(*r, 0.00335) then algoritmo(RC4)

R829if Bloco0111110011100111(*q) and >(*q, 0.022012 ) and Bloco0000001000101001(*w) and

<=(*w, 0.00523) and Bloco0000011000110010(*e) and >(*e, 0)then algoritmo(RC4)

R830





R831



and <=(*t, 6.428807) and Bloco0001(*y) and >(*y, 6.143308) and Bloco1011(*u) and >(*u,


R832





R833


Bloco0011(*e) and >(*e, 5.933518) and Bloco0100(*r) and >(*r,6.154374) and Bloco1111(*t)


R834



and >(*t, 5.980548) and Bloco1110(*y) and <=(*y, 6.086681) then algoritmo(RC4)

117

R835



and >(*t, 5.980548) and Bloco1110(*y) and >(*y, 6.086681) and Bloco1001(*u) and <=(*u,

6.482606) and Bloco1000(*i) and >(*i, 6.369703) then algoritmo(RC4)

R836







R838



algoritmo(RC4)

R839




R840





algoritmo(RC4)

R841





R842






Bloco1101(*a) and <=(*a, 6.237368) and Bloco0011(*s) and <=(*s, 6.236936) and

Bloco0111(*d) and <=(*d, 6.320039) then algoritmo(RC4)

R843








Bloco0011(*g) and >(*g, 6.349206) then algoritmo(RC4)

R844








algoritmo(RC4)

118

R845








R846



and <=(*t, 6.202819) and Bloco1000(*y) and >(*y, 6.359604)then algoritmo(RC4)

R847



Bloco00010101(*t) and <=(*t, 0.433311) then algoritmo(RSA)

R848






then algoritmo(RSA)

R849 if Bloco10000010(*q) and <=(*q, 0.375444) then algoritmo(RSA)

R850if Bloco01101001(*q) and <=(*q, 0.34421) and Bloco00001110(*w) and >(*w, 0.356408)then

algoritmo(RSA)

R851



algoritmo(RSA)



R853



algoritmo(RSA)

R854



Bloco0101(*t) and >(*t, 6.244913) then algoritmo(RSA)

R855



algoritmo(RSA)



R857



and >(*t, 6.212028) and Bloco1001(*y) and <=(*y, 6.241135) then algoritmo(RSA)




algoritmo(RSA)

R860



algoritmo(RSA)

119



R862if Bloco0000(*q) and >(*q, 6.041623) and Bloco1010(*w) and <=(*w, 6.400171)then

algoritmo(RSA)

R863







Bloco0101001111101100(*p) and <=(*p, 0.021706)then algoritmo(RSA)

R864















Bloco0000000001010001(*c) and <=(*c, 0) then algoritmo(RSA)

R865









Bloco0001011101010011(*d) and >(*d, 0.001308) and Bloco0000000000000110(*f) and

<=(*f, 0)then algoritmo(RSA)

120

Anexo 2 – Tabela de acerto dos classificadores do WEKA

Tamanho do bloco 2 4 8 16 2 4 8 16 2 4 8 16

AttributeSelectedClassifier 40 88 95 43 34 93 52 72 81

FilteredClassifier 40 28 87 30 45 57 0 36 67

PART 48 80 98 99 42 92 97 96 80 97 96 100

J48 82 92 94 98 47 87 95 99 86 91 93 99

Tamanho do bloco 2 4 8 16 2 4 8 16 2 4 8 16



PART 76 77 98 99 26 94 99 100 40 92 99 100

J48 50 88 92 98 10 96 96 98 52 96 99 99

Tamanho do bloco 2 4 8 16 2 4 8 16 2 4 8 16



PART 63 96 99 100 48 95 97 97 77 96 98 98

J48 84 96 98 97 53 95 97 92 81 97 98 98

Tamanho do bloco 2 4 8 16 2 4 8 16 2 4 8 16



PART 49 95 95 99 54 88 98 100 46 98 95 100

J48 44 90 96 100 76 88 90 100 38 87 89 100

Blowfish

RC4

RSA

EN SP

EN PT

PT

SP

SP

EN PT SP

EN PT

DES

ANÁLISE DE BLOCOS DE ARQUIVOS CRIPTOGRAFADOS … · Gostaria de agradecer a toda minha família...

Documents

Transcript of ANÁLISE DE BLOCOS DE ARQUIVOS CRIPTOGRAFADOS … · Gostaria de agradecer a toda minha família...