FACULDADE DE TECNOLOGIA PROF.

WALDOMIRO MAY

ALGORITMOS DE CRIPTOGRAFIA:
Substituição, Caesar, Permuta e Vigenère

Cleber Rezende Carvalho

Cruzeiro – SP
2010
FACULDADE DE TECNOLOGIA PROF. WALDOMIRO MAY

ALGORITMOS DE CRIPTOGRAFIA:
Substituição, Caesar, Permuta e Vigenère

Cleber Rezende Carvalho

Trabalho complementar apresentado à Faculdade

de Tecnologia Prof. Waldomiro May como requisito
para a disciplina Segurança da Informação
ministrada pelo prof. Eduardo Arbex.

Cruzeiro – SP
2010
INDICE

Algoritmo de substituição

Algoritmo de Caesar

Algoritmo de Vingenère

Algoritmo de Permuta
/*
* FATEC CRUZEIRO - TECNOLOGIA EM INFORMÁTICA
* 6o SEMESTRE - BANCO DE DADOS
* CLEBER REZENDE CARVALHO - 18/11/2010
*/

package criptografia;

import java.text.Normalizer;

public class algoritmo1_substituicao {

static private char[][] gerarChave (){

//preenchendo o vetor com letras tendo índice como valor
char Letras[][];
Letras = new char[26][2];

//gera e exibe a tabela de referência

System.out.println("Tabela de referência \n--------------------");

for(int i = 0; i < 26; i++){

Letras[i][0] = (char)(i+97);

System.out.print(Letras[i][0] + "=");

int j = 0;
boolean ok = true;

do{
if (ok == false){
ok = true;
}

//gera um número aleatório para ser o ASCII da letra

int Temp = (int)((Math.random()*26)+97);

//comparo com as letras já utilizadas

for(j=0; j <= i; j++){
if (Letras[j][1] == (char)Temp){
ok = false;
break;
}
}

if (ok == true){
Letras[i][1] = (char)Temp;
}

}while(ok == false);

//exibe a tabela de referência

System.out.print(Letras[i][1] + " ");
if ((i == 12 || i == 25)) {
System.out.print("\n");
}
}
return Letras;
}

static private String encriptar(String Tp, char[][] Letras){

String Tc = "";

//remove acentos
Tp = Normalizer.normalize(Tp, Normalizer.Form.NFD);
Tp = Tp.replaceAll("[^\\p{ASCII}]", "");

//faz a varredura do texto puro

for (int i=0; i < Tp.length(); i++){
for (int j=0; j < 26; j++){
if (Tp.charAt(i) == Letras[j][0]){
Tc = Tc + Letras[j][1];
break;
}

//mantém espaços e caracteres especiais

if ((j == 25) && (Tp.charAt(i) != Letras[j][0])){
Tc = Tc + Tp.charAt(i);
}
}
}
return Tc;
}

static private String desencriptar (String Tc, char[][] Letras){

String Tp = "";

//faz a varredura do texto cifrado

for (int i=0; i < Tc.length(); i++){
for (int j=0; j < 26; j++){
if (Tc.charAt(i) == Letras[j][1]){
Tp = Tp + Letras[j][0];
break;
}

//mantém espaços e caracteres especiais

if ((j == 25) && (Tc.charAt(i) != Letras[j][1])){
Tp = Tp + Tc.charAt(i);
}
}
}
return Tp;

static private void exibirResultados(String Tc, String Tp, String Tp2){

System.out.println("");
System.out.println("Chave: \n" + "------\n" + "substituição" + "\n\n");
System.out.println("Texto puro: (entrada) \n" + "----------- \n" + Tp + "\n\n");
System.out.println("Texto cifrado: \n" + "----------- \n" + Tc + "\n\n");
System.out.println("Texto puro: (decifrado) \n" + "----------- \n" + Tp2 + "\n\n");
}

public static void main (String args[]){

//variaveis e valores iniciais
String Tc, Tp, Tp2;
char Letras[][];
 Tp = "the quick old lazy brown fox jumps over a lazy dog";
Tp2 = "";
Tc = "";

//chama o método de encriptação e de desencriptação

Letras = gerarChave();
Tc = encriptar(Tp, Letras);
Tp2 = desencriptar(Tc, Letras);

//exibe os resultados
exibirResultados(Tc, Tp, Tp2);

Este algoritmo produz a saída abaixo:

Tabela de referência
--------------------
a=p b=t c=q d=c e=f f=d g=x h=u i=k j=a k=n l=s m=m
n=j o=l p=z q=g r=i s=r t=b u=v v=w w=h x=y y=e z=o

Chave:
------
substituição

Texto puro: (entrada)

-----------
the quick old lazy brown fox jumps over a lazy dog

Texto cifrado:
-----------
buf gvkqn lsc spoe tilhj dly avmzr lwfi p spoe clx

Texto puro: (decifrado)

-----------
the quick old lazy brown fox jumps over a lazy dog

CONSTRUÍDO COM SUCESSO (tempo total: 1 segundo)

/*
* FATEC CRUZEIRO - TECNOLOGIA EM INFORMÁTICA
* 6o SEMESTRE - BANCO DE DADOS
* CLEBER REZENDE CARVALHO - 18/11/2010
*/

package criptografia;

import java.text.Normalizer;

public class algoritmo2_caesar {

static private char[] gerarChave(){

//preenchendo o vetor com letras tendo índice como valor
char Letras[];
Letras = new char[26];

//exibe a tabela de referência

System.out.println("Tabela de referência \n--------------------");
for(int i = 0; i < 26; i++){
Letras[i] = (char)(i+97);
if (i < 10){
System.out.print(Letras[i] + "=0" + i + " ");
}else {
System.out.print(Letras[i] + "=" + i + " ");
}
if ((i == 12 || i == 25)) {
System.out.print("\n");
}
}
return Letras;
}

static private String encriptar(String Tp, int ch, char[] Letras){

String Tc = "";
int letracifrada;

//faz a varredura do texto puro

for (int i = 0; i < Tp.length(); i++){
int j = -1;
//faz a varredura do vetor de letras e valores
do {
j++;
//caso não ache a letra sai do laço de repetição
if (j >=26){
j = -1;
break;
}

} while(Tp.charAt(i) != Letras[j]);

//caso não seja letra de A a Z minúscula não calcula

if (j != -1){
letracifrada = (j + ch) % 26;
}else{
letracifrada = -1;
}
 //escreve a letracifrada no texto cifrado caso seja uma letra
if (letracifrada != -1){
Tc = Tc + Letras[letracifrada];
}else{
Tc = Tc + Tp.charAt(i);
}

}
System.out.println("");
return Tc;
}

static private String desencriptar(String Tc, int ch, char[] Letras){

String Tp = "";
int letradecifrada;

//faz a varredura do texto cifrado

for (int i = 0; i < Tc.length(); i++){
int j = -1;
//faz a varredura do vetor de letras e valores
do {
j++;
//caso não ache a letra sai do laço de repetição
if (j >=26){
j = -1;
break;
}
} while(Tc.charAt(i) != Letras[j]);

//caso não seja letra de A a Z minúscula não calcula

if (j != -1){
letradecifrada = (j - ch) % 26;
if (letradecifrada < 0){
letradecifrada = 26 + (j-ch);
}
}else{
letradecifrada = -1;
}

//escreve a letracifrada no texto cifrado caso seja uma letra

if (letradecifrada != -1){
Tp = Tp + Letras[letradecifrada];
}else{
//se não for letra, copia o caracter
Tp = Tp + Tc.charAt(i);
}
}
System.out.println("");
return Tp;
}

static private void exibirResultados(String Tc, String Tp, String Tp2, int ch){
System.out.println("Chave: \n" + "------\n" + ch + "\n\n");
System.out.println("Texto puro: (entrada) \n" + "----------- \n" + Tp + "\n\n");
System.out.println("Texto cifrado: \n" + "----------- \n" + Tc + "\n\n");
System.out.println("Texto puro: (decifrado) \n" + "----------- \n" + Tp2 + "\n\n");
}

public static void main(String[] args) {

 //variaveis e valores iniciais
String Tc, Tp, Tp2;
int ch;
char Letras[];

Tp = "the quick old lazy brown fox jumps over a lazy dog";
Tc = "";
ch = 3;

//remove acentos
Tp = Normalizer.normalize(Tp, Normalizer.Form.NFD);
Tp = Tp.replaceAll("[^\\p{ASCII}]", "");

//chama o método de encriptação e de desencriptação

Letras = gerarChave();
Tc = encriptar(Tp, ch, Letras);
Tp2 = desencriptar(Tc, ch, Letras);

//exibe os resultados
exibirResultados(Tc, Tp, Tp2, ch);
}
}
Este algoritmo produz a saída abaixo:

Tabela de referência
--------------------
a=00 b=01 c=02 d=03 e=04 f=05 g=06 h=07 i=08 j=09 k=10 l=11 m=12
n=13 o=14 p=15 q=16 r=17 s=18 t=19 u=20 v=21 w=22 x=23 y=24 z=25

Chave:
------
3

Texto puro: (entrada)

-----------
the quick old lazy brown fox jumps over a lazy dog

Texto cifrado:
-----------
wkh txlfn rog odcb eurzq ira mxpsv ryhu d odcb grj

Texto puro: (decifrado)

-----------
the quick old lazy brown fox jumps over a lazy dog

CONSTRUÍDO COM SUCESSO (tempo total: 0 segundos)

/*
* FATEC CRUZEIRO - TECNOLOGIA EM INFORMÁTICA
* 6o SEMESTRE - BANCO DE DADOS
* CLEBER REZENDE CARVALHO - 18/11/2010
*/

package criptografia;

import java.text.Normalizer;

public class algoritmo3_vigenere {

static private char[] gerarTabela(){

//preenchendo o vetor com letras tendo índice como valor
char Letras[];
Letras = new char[26];

//exibe a tabela de referência

System.out.println("Tabela de referência \n--------------------");
for(int i = 0; i < 26; i++){
Letras[i] = (char)(i+97);
if (i < 10){
System.out.print(Letras[i] + "=0" + i + " ");
}else {
System.out.print(Letras[i] + "=" + i + " ");
}
if ((i == 12 || i == 25)) {
System.out.print("\n");
}
}
System.out.println("");
return Letras;
}

static private int[] gerarChave(String ch, char[] Letras){

int chn[];
chn = new int[ch.length()];

//cria vetor com valores para cada letra da chave

for(int i = 0; i < ch.length(); i++){
for (int j=0; j < 26; j++){
if (ch.charAt(i) == Letras[j]){
chn[i] = j;
System.out.println(ch.charAt(i) + " = " + j);
}
}
}

return chn;
}

static private String encriptar(String Tp, int[] chn, char[] Letras){

String Tc = "";
int letracifrada, chc;
letracifrada = 0;
chc = 0;
 //remove acentos
Tp = Normalizer.normalize(Tp, Normalizer.Form.NFD);
Tp = Tp.replaceAll("[^\\p{ASCII}]", "");

//faz a varredura do texto puro

for (int i = 0; i < Tp.length(); i++){
int j = -1;
//faz a varredura do vetor de letras e valores
do {
j++;
//caso não ache a letra sai do laço de repetição
if (j >=26){
j = -1;
break;
}

} while(Tp.charAt(i) != Letras[j]);

//caso não seja letra de A a Z minúscula não calcula

if (j != -1){
letracifrada = (j + chn[chc]) % 26;
if (chc != chn.length - 1){
chc++;
}else{
chc = 0;
}
}else{
letracifrada = -1;
}

//escreve a letracifrada no texto cifrado caso seja uma letra

if (letracifrada != -1){
Tc = Tc + Letras[letracifrada];
}else{
//Tc = Tc + Tp.charAt(i);
}

}
System.out.println("");

return Tc;
}

static private String desencriptar(String Tc, int[] chn, char[] Letras){

String Tp = "";
int letradecifrada = 0;
int chc = 0;

//faz a varredura do texto cifrado

for (int i = 0; i < Tc.length(); i++){
int j = -1;
//faz a varredura do vetor de letras e valores
do {
j++;
//caso não ache a letra sai do laço de repetição
if (j >=26){
j = -1;
break;
}
 } while(Tc.charAt(i) != Letras[j]);

//caso não seja letra de A a Z minúscula não calcula

if (j != -1){
letradecifrada = (j - chn[chc]) % 26;
if (letradecifrada < 0){
letradecifrada = 26 + (j-chn[chc]);
}
if (chc != chn.length - 1){
chc++;
}else{
chc = 0;
}
}else{
letradecifrada = -1;
}

//escreve a letracifrada no texto cifrado caso seja uma letra

if (letradecifrada != -1){
Tp = Tp + Letras[letradecifrada];
}else{
//Tp = Tp + Tc.charAt(i);
}

}
System.out.println("");
return Tp;
}

static private void exibirResultados(String Tc, String Tp, String Tp2, String ch){
System.out.println("Chave: \n" + "------\n" + ch + "\n\n");
System.out.println("Texto puro: (entrada) \n" + "----------- \n" + Tp + "\n\n");
System.out.println("Texto cifrado: \n" + "----------- \n" + Tc + "\n\n");
System.out.println("Texto puro: (decifrado) \n" + "----------- \n" + Tp2 + "\n\n");
}

public static void main(String args[]){

//variaveis e valores iniciais
String Tc, Tp, Tp2;
String ch;
char Letras[];
int chn[];

Tp = "the quick old lazy brown fox jumps over a lazy dog";
Tc = "";
ch = "senha";
Tp2 = "";

//gera a tabela de referência

Letras = gerarTabela();

//gera os valores da chave

chn = gerarChave(ch, Letras);

//método para encriptar e descriptografar

Tc = encriptar(Tp, chn, Letras);
Tp2 = desencriptar(Tc, chn, Letras);
 //exibe os resultados
exibirResultados(Tc, Tp, Tp2, ch);
}
}

Este algoritmo produz a saída abaixo:

Tabela de referência
--------------------
a=00 b=01 c=02 d=03 e=04 f=05 g=06 h=07 i=08 j=09 k=10 l=11 m=12
n=13 o=14 p=15 q=16 r=17 s=18 t=19 u=20 v=21 w=22 x=23 y=24 z=25

s = 18
e=4
n = 13
h=7
a=0

Chave:
------
senha

Texto puro: (entrada)

-----------
the quick old lazy brown fox jumps over a lazy dog

Texto cifrado:
-----------
llrxuagxvlvpngytvbdnxskquetfvvwvnsarcqvg

Texto puro: (decifrado)

-----------
thequickoldlazybrownfoxjumpsoveralazydog

CONSTRUÍDO COM SUCESSO (tempo total: 0 segundos)

/*
* FATEC CRUZEIRO - TECNOLOGIA EM INFORMÁTICA
* 6o SEMESTRE - BANCO DE DADOS
* CLEBER REZENDE CARVALHO - 18/11/2010
*/

package criptografia;

import java.text.Normalizer;

public class algoritmo4_permuta2 {

static private int[] gerarChave(int n){

int ch[];
ch = new int[n];
boolean ok = true;

for (int i = 0 ; i < n; i++){

do{
if (ok == false){
ok = true;
}

//gera a ordem aleatória do bloco

int Temp = (int)(Math.random() * n);

//testa se o índice da ordem de 0 a n já foi usado

for (int y = 0; y < i; y++){
if (Temp == ch[y]){
ok = false;
break;
}
}
if (ok == true){
ch[i] = Temp;
}
} while(ok == false);
}

return ch;
}

static private int[] gerarContraChave(int[] ch){

//cria vetor para receber a contra-chave
int[] ch2;
ch2 = new int[ch.length];
boolean ok = true;
//gera a contra-chave com valores opostos ao da chave
for (int i = 0; i < ch.length; i++){
ch2[ch[i]] = i;
}
return ch2;
}

static private String encriptar(String Tp, int[] ch){

String Tc = "";
char bloco[];
bloco = new char[ch.length];
 int j;

//remove acentos
Tp = Normalizer.normalize(Tp, Normalizer.Form.NFD);
Tp = Tp.replaceAll("[^\\p{ASCII}]", "");

//remove espaços em branco

//quebra em blocos de 5
//altera a ordem das letras
//cria o texto cifrado

//faz a varredura do texto puro controlando o bloco com j

j = 0;
for (int i = 0; i < Tp.length(); i++){
if (Tp.charAt(i) != ' '){
bloco[ch[j]] = Character.valueOf(Tp.charAt(i));
if (j < ch.length -1){
j++;
}else{
for (int x = 0; x < ch.length; x++){
//joga o bloco concluído em texto cifrado e
//esvazia o bloco
Tc = Tc + bloco[x];
bloco[x] = ' ';
j = 0;
}
}
}
}

System.out.println("");

return Tc;
}

static private void exibirResultados(String Tc, String Tp, String Tp2, int[] ch){
System.out.print("Chave: \n" + "------\n(");
for (int i = 0; i < ch.length; i++){
System.out.print(ch[i]);
if (i < ch.length-1){
System.out.print(", ");
}else{
System.out.print(")\n\n\n");
}
}
System.out.println("Texto puro: (entrada) \n" + "----------- \n" + Tp + "\n\n");
System.out.println("Texto cifrado: \n" + "----------- \n" + Tc + "\n\n");
System.out.println("Texto puro: (decifrado) \n" + "----------- \n" + Tp2 + "\n\n");
}

public static void main(String args[]){

//variaveis e valores iniciais
String Tc, Tp, Tp2;
int ch[], ch2[];
//char Letras[];

Tp = "the quick old lazy brown fox jumps over a lazy dog";
Tc = "";
Tp2 = "";
 //gera os valores da chave com um número definido pelo usuário
ch = gerarChave(5);
ch2 = gerarContraChave(ch);

//método para encriptar e descriptografar

Tc = encriptar(Tp, ch);
Tp2 = encriptar(Tc, ch2);

//exibe os resultados
exibirResultados(Tc, Tp, Tp2, ch);
}
}

Este algoritmo produz a saída abaixo:

Chave:
------
(1, 2, 3, 4, 0)

Texto puro: (entrada)

-----------
the quick old lazy brown fox jumps over a lazy dog

Texto cifrado:
-----------
utheqlickoydlaznbrowufoxjvmpsoaeralgzydo

Texto puro: (decifrado)

-----------
thequickoldlazybrownfoxjumpsoveralazydog

CONSTRUÍDO COM SUCESSO (tempo total: 0 segundos)