Saltar para o conteúdo

Usuário(a):F.R Rogerio/Algoritmo Criptografico ADR

Origem: Wikipédia, a enciclopédia livre.

ADR-8 (ADR-16, ADR-32 ou ADR-64 etc) é um algoritmo criptográfico simétrico de chave numérica, criado pelo programador Francisco Rogerio F. Ferreira, nascido em Morada Nova - CE em 1975.

ADR significa Algoritmo do Desenvolvedor Roger(apelido do programador).

O "-X" na composição da sigla do algoritmo significa que a chave a ser usada no algoritmo deve possuir 8 dígitos(para o ADR-8) e 16 dígitos para o ADR-16(e assim por diante).

Basicamente, o algoritmo consiste em converter cada caractere do texto plano em sua representação binária e, a partir daí aplicar uma equação, resultando o texto cifrado.

Uma vez, cada caractere, convertido (com base na chave) faz se uma permutação na representação numérica do caractere, resultando em um novo caractere.


Equação da criptografia (ADR-8)


C=( N[ i ] = T [ K[ i ] ] )

Onde

C = o texto cifrado;
N = é uma matriz contendo a representação binária do caractere
T = é o texto convertido em binário
K = é uma matriz contendo os 8 dígitos da chave;
[i] = representa o índice da matriz(sempre começando em 0)

Exemplo:

Para este exemplo o nosso texto plano será a letra "a" do alfabeto.

A representação do a em binário é 01100001.

Então T = 01100001.

A chave para o nosso exemplo será 13204657.

Logo, K será uma matriz [ 1, 3, 2, 0, 4, 6, 5, 7 ]; de 0 a 7, temos os 8 dígitos.

Passada essa etapa, agora vamos aplicar K de T em N(permutação);

(0 é a primeira posição da matriz. 1 é o primeiro caractere da chave. Portanto, 1 indica que tempos que pegar o caractere na segunda posição de T. Lembre-se que sempre começamos na posição 0, logo, 0 é a posição 1, 1 é a posição 2 e assim por diante)

N[ 0 ] = T[ k[ 0 ] ] = 1;( K[0] é o 1º índice da matriz K, no caso é o 1. O 1 indica a posição do caractere a ser pego de T. 1 é a 2ª posição de T ) T ficou agora 0 100001
N[ 1 ] = T[ k[ 1 ] ] = 0; ( K[1] é o 2º índice da matriz K, que no caso é o 3. Então pegamos o caractere na 4º posição de T ) T ficou agora 0 1 0001
N[ 2 ] = T[ k[ 2 ] ] = 1; T ficou agora 0 0001
N[ 3 ] = T[ k[ 3 ] ] = 0; ( K[3] é o 4º índice da matriz K, que no caso é o 0. Então pegamos o caractere na 1º posição de T ) T ficou agora 0001
N[ 4 ] = T[ k[ 4 ] ] = 0; T ficou agora 001
N[ 5 ] = T[ k[ 5 ] ] = 0; T ficou agora 0 1
N[ 6 ] = T[ k[ 6 ] ] = 0; T ficou agora 1
N[ 7 ] = T[ k[ 7 ] ] = 1; T ficou agora vazio

A nossa matriz N, após preenchida, ficou assim N[ 1, 0, 1, 0, 0, 0, 0, 1 ];

Juntando todos os índices da matriz temos "10100001" que representa a letra "¡".

C = ¡;


Equação da descriptografia (ADR-8)


C=( N[ K[i] ]= T[ i ] )

Onde

C = o texto cifrado;
N = é uma matriz contendo a representação binária do caractere, resultante da descriptografia;
K = é uma matriz contendo os 8 dígitos da chave;
T = é o texto convertido em binário
[i] = representa o índice da matriz e a posição de cada bit em T (sempre começando em 0)

Exemplo:

A representação binária de "¡" é 10100001.

Logo, T = 10100001.

N[ k[ 1 ] ] = T[ 0 ] = 1; (T[0] é o primeiro 1 que aparece em T, da esquerda para a direita) T ficou agora 0100001
N[ k[ 3 ] ] = T[ 1 ] = 0; (T[1] é 0, que está na segunda posição em T, da esquerda para a direita) T ficou agora 100001. E assim por diante.
N[ k[ 2 ] ] = T[ 2 ] = 1;
N[ k[ 0 ] ] = T[ 3 ] = 0;
N[ k[ 4 ] ] = T[ 4 ] = 0;
N[ k[ 6 ] ] = T[ 5 ] = 0;
N[ k[ 5 ] ] = T[ 6 ] = 0;
N[ k[ 7 ] ] = T[ 7 ] = 1;

Após nossa matriz N ser preenchida, basta ordená-la em ordem crescente. Ficando assim:

N[0] = 0;
N[1] = 1;
N[2] = 1;
N[3] = 0;
N[4] = 0;
N[5] = 0;
N[6] = 0;
N[7] = 1;

E for fim, juntando todos os índices da matriz N, temos "01100001" que é a representação da letra "a" em binário.


Segurança


Como se vê, a versão ADR-8 não é segura e, portanto só deve ser usada para fins didáticos. A versão ADR-16 é moderadamente segura, mas não é recomendada para casos em que se exija alto sigilo (o texto cifrado de “a” com ADR-16 é “Fgg=” e, embora mantendo a mesma base, muda um pouco a lógica do algoritmo).

A partir do ADR-16i, o algoritmo é considerado seguro.


Versão mais recente


Atualmente o algoritmo está na versão ADR-128i.


Referência


[1]