Laboratórios
DRT-240 BITS
|
Seg 19 Abr 2004 02:00 |
- Detalhes
- Categoria: Laboratório de Criptografia
- Atualização: Quinta, 14 Janeiro 2010 14:00
- Autor: Yugi
- Acessos: 13612
O autor do DRT-240 BITS, Yugi Tumro, disponibiliza um pacote "zipado" contendo o texto explicativo do seu algoritmo, um programa para cifrar e decifrar textos além de um texto desafio cifrado com o DRT-240 mas de chave desconhecida.
Faça o download do DRT-240 (157 Kb).
INTRODUÇÃO
O Criptossistema DRT é um algoritmo simétrico que trabalha com criptografia de blocos de 64 bits e uma chave de 240 bits. A motivação para a sua construção foi elaborar um criptossistema seguro, porém muito mais simples que o criptossistema CPBA, também de minha autoria, mais que tem uma chave de 512 bits e codifica o texto claro em blocos de 256 bits.
A estrutura do algoritmo é absurdamente simples (somente a rotina de expansão de chaves é um pouco confusa...) e eficiente. A degenerescência do criptograma em relação ao texto claro é transparente e de fácil constatação.
O algoritmo utiliza 8 voltas e 52 sub-chaves de 16 bits (oriundas da chave mestra) para criptografar cada bloco de 64 bits. São empregadas substituições, permutações e operações de grupos algébricos diferentes para melhor promover a difusão dos elementos do bloco claro no bloco cifrado.
Dedico este trabalho a todos aqueles que lutam para realizar os seus sonhos. Em especial à Sueli Veiga, Noêmia, Jésus, Rafael Veríssimo e Sandra Aparecida. Este trabalho também é dedicado ao Prof. Antônio Faleiros e aos amigos do ITA (Instituto Tecnológico de Aeronáutica).
O Autor
SOBRE AS SUB-CHAVES
Resolvi quebrar a cronologia da descrição do cifrário face à simplicidade da estrutura de cifra do algoritmo em relação ao cálculo das sub-chaves. Não quero dizer que o cálculo de sub-chaves seja complexo, mas ele é pouco intuitivo. Deixemos pois esta questão para o final desta breve exposição do algoritmo DRT.
Como não é possível codificar sem ter as 52 sub-chaves vamos considerar as sub-chaves como sendo as seguintes:
Nº DA CHAVE VALOR Nº DA CHAVE VALOR 1 40443 27 40462 2 7862 28 50235 3 35747 29 37791 4 57512 30 33004 5 12596 31 29516 6 28188 32 38061 7 55699 33 31796 8 12491 34 34932 9 44864 35 62177 10 40374 36 19007 11 20623 37 11326 12 32346 38 8853 13 15641 39 33015 14 58660 40 57157 15 32403 41 60957 16 59878 42 11845 17 35192 43 63409 18 27081 44 12136 19 47423 45 57203 20 33484 46 51754 21 45665 47 5897 22 7483 48 22114 23 61792 49 46815 24 19179 50 62247 25 43081 51 775 26 34057 52 14601
Estas 52 Sub-chaves se originaram da chave mestre
[000000000000000000000000000000000000000000000000000000000000] em Hexadecimal.
Veremos em seguida o ciclo de cifragem do DRT-240 bits!
O CICLO DE CIFRAGEM
As quatro fases de cada rodada:
A = (A + CHAVE[1]) MOD 65536 B = (B - CHAVE[2] + 65536) MOD 65536 C = (C - CHAVE[3] + 65536) MOD 65536 D = (D + CHAVE[4]) MOD 65536
X1 = A DIV 256 X2 = C MOD 256 X3 = A MOD 256 X4 = C DIV 256 A = (X2 * 256) + X1 C = (X3 * 256) + X4 X1 = B DIV 256 X2 = D MOD 256 X3 = B MOD 256 X4 = D DIV 256 B = (X2 * 256) + X1 D = (X3 * 256) + X4
ACL = C XOR 27809 ACL = (ACL + (D * CHAVE[5])) MOD 65536 A = A XOR ACL B = (B + A) MOD 65536 ACL = (A * CHAVE[6]) ACL = (ACL + (B XOR 30561)) MOD 65536 C = ((C + ACL) MOD 65536) XOR B ACL = (C DIV 256) + ((B MOD 256) * 256) ACL = ACL XOR A D = ((D XOR B) + ACL) MOD 65536
ACL = A A = B B = C C = D D = ACL
Após a oitava rodada faz-se o processo da 1 parte da rodada, ou seja, soma e subtração. Na primeira rodada utilizamos as chaves de 1 até 6, na 2ª de 7 até 12, na 3ª de 13 até 18, na 4ª de 19 até 24, na 5ª rodada de 25 até 30, na 6ª de 31 até 36, na 7ª de 37 até 42, e na oitava rodada de 43 até 48. As Sub-chaves de números 49, 50, 51 e 52 são utilizadas na última parte da cifragem que é executada após a última rodada e corresponde a 1ª fase da rodada, ou seja:
A = (A + CHAVE[49]) MOD 65536 B = (B - CHAVE[50] + 65536) MOD 65536 C = (C - CHAVE[51] + 65536) MOD 65536 D = (D + CHAVE[52]) MOD 65536
Após este processo o bloco de 64 bits está cifrado. O ciclo da cifragem pode ser representado da seguinte forma:
----------------- A = (A + CHAVE[1]) MOD 65536 | B = (B - CHAVE[2] + 65536) MOD 65536 | C = (C - CHAVE[3] + 65536) MOD 65536 | D = (D + CHAVE[4]) MOD 65536 | | X1 = A DIV 256 | X2 = C MOD 256 | X3 = A MOD 256 | X4 = C DIV 256 | A = (X2 * 256) + X1 | C = (X3 * 256) + X4 | X1 = B DIV 256 | X2 = D MOD 256 | X3 = B MOD 256 | X4 = D DIV 256 | B = (X2 * 256) + X1 | D = (X3 * 256) + X4 | | ----- 8 voltas ACL = C XOR 27809 | ACL = (ACL + (D * CHAVE[5])) MOD 65536 | A = A XOR ACL | B = (B + A) MOD 65536 | | ACL = (A * CHAVE[6]) | ACL = (ACL + (B XOR 30561)) MOD 65536 | C = ((C + ACL) MOD 65536) XOR B | | ACL = (C DIV 256) + ((B MOD 256) * 256) | ACL = ACL XOR A | D = ((D XOR B) + ACL) MOD 65536 | | ACL = A | A = B | B = C | C = D | D = ACL | ------------------------------------------------- | | A = (A + CHAVE[49]) MOD 65536 B = (B - CHAVE[50] + 65536) MOD 65536 C = (C - CHAVE[51] + 65536) MOD 65536 D = (D + CHAVE[52]) MOD 65536
CIFRAGEM PASSO A PASSO
O Criptossistema DRT codifica o texto claro em blocos de 64 bits. Este bloco é dividido em 4 partes iguais (Words) de 16 bits. Estas 4 partes são representadas por A, B, C e D, respectivamente. Os Valores A, B, C e D são números de 16 bits, ou seja, números compreendidos entre 0 e 65535.
Vamos considerar que o texto claro seja representado por 8 bytes nulos, ou seja, com valor 0. Assim os valores A, B, C e D são iguais a zero.
Soma e Subtração:
A = (A + CHAVE[1]) MOD 65536 B = (B - CHAVE[2] + 65536) MOD 65536 C = (C - CHAVE[3] + 65536) MOD 65536 D = (D + CHAVE[4]) MOD 65536 Considerando os valores correntes teremos: A = (0 + 40443) MOD 65536 = 40443 B = (B – 7862 + 65536) MOD 65536 = 57674 C = (C – 35747 + 65536) MOD 65536 = 29789 D = (D + 57512) MOD 65536 = 57512
Inversão:
X1 = A DIV 256 X2 = C MOD 256 X3 = A MOD 256 X4 = C DIV 256 A = (X2 * 256) + X1 C = (X3 * 256) + X4 X1 = (40443 DIV 256) = 157 X2 = (29789 MOD 256) = 93 X3 = (40443 MOD 256) = 251 X4 = (29789 DIV 256) = 116 A = (93 * 256) + 57 = 23965 C = (251 * 256) + 116 = 64372 X1 = B DIV 256 X2 = D MOD 256 X3 = B MOD 256 X4 = D DIV 256 B = (X2 * 256) + X1 D = (X3 * 256) + X4 X1 = (57674 DIV 256) = 225 X2 = (57512 MOD 256) = 168 X3 = (57674 MOD 256) = 74 X4 = (57512 DIV 256) = 224 B = (168 * 256) + 225 = 43223 D = (74 * 256) + 224 = 19168 Neste ponto teremos os valores A = 23965 B = 43233 C = 64372 D = 19168
Difusão:
ACL = C XOR 27809 ACL = (ACL + (D * CHAVE[5])) MOD 65536 A = A XOR ACL B = (B + A) MOD 65536 ACL = (64372 XOR 27809) = 38869 ACL = (38869 + (19168 * 12596)) MOD 65536 ACL = 44373 A = 23965 XOR 44373 = 61640 B = (43233 + 61640) MOD 65536 = 39337 ACL = (A * CHAVE[6]) ACL = (ACL + (B XOR 30561)) MOD 65536 C = ((C + ACL) MOD 65536) XOR B ACL = (61640 * 28188) = 1737508320 ACL = (1737508320 + (39337 XOR 30561)) MOD 65536 = 13480 C = ((64372 + 13480) MOD 65536) XOR 39337 = 43445 ACL = (C DIV 256) + ((B MOD 256) * 256) ACL = ACL XOR A D = ((D XOR B) + ACL) MOD 65536 ACL = (43445 DIV 256) + ((39337 MOD 256) * 256) = 43433 ACL = 43433 XOR 61640 = 22881 D = ((19168 XOR 39337) + 22881) MOD 65536 = 11434 Neste ponto temos os valores: A = 61640 B = 39337 C = 43445 D = 11434
Rotação:
ACL = A A = B B = C C = D D = ACL ACL = 61640 A = 39337 B = 43445 C = 11434 D = 61640 Valores finais no final da 1ª rodada: A = 39337 B = 43445 C = 11434 D = 61640
Assim vemos acima os valores finais para a 1ª rodada da cifragem. As outras 7 rodadas têm o processo de cifragem idêntico e, por isso, vou condensar os dados destas 7 rodadas na tabela a seguir:
RODADA Soma & Subtração Inversão Difusão Rotação 2 A = 29500 A = 27251 A = 56413 A = 23253 B = 30954 B = 32376 B = 23253 B = 62006 C = 32106 C = 15485 C = 62006 C = 47626 D = 36478 D = 60046 D = 47626 D = 56413 3 A = 38894 A = 30615 A = 13053 A = 30218 B = 3346 B = 17165 B = 30218 B = 52033 C = 15223 C = 60987 C = 52033 C = 40194 D = 50755 D = 4806 D = 40194 D = 13053 4 A = 12105 A = 41263 A = 53860 A = 2732 B = 18549 B = 14408 B = 2732 B = 56111 C = 60065 C = 18922 C = 56111 C = 65211 D = 20536 D = 30032 D = 65211 D = 53860 5 A = 45813 A = 44466 A = 8025 A = 48815 B = 22054 B = 40790 B = 48815 B = 39829 C = 24749 C = 62816 C = 39829 C = 18683 D = 38559 D = 9878 D = 18683 D = 8025 6 A = 12795 A = 50993 A = 14085 A = 1035 B = 1768 B = 52486 B = 1035 B = 28538 C = 52423 C = 64460 C = 28538 C = 10518 D = 42957 D = 59559 D = 10518 D = 14085 7 A = 12361 A = 7984 A = 37815 A = 56835 B = 19685 B = 19020 B = 56835 B = 31582 C = 43039 C = 18856 C = 31582 C = 52193 D = 5706 D = 58646 D = 52193 D = 37815 8 A = 54708 A = 28373 A = 45639 A = 37778 B = 19446 B = 57675 B = 37778 B = 8351 C = 60526 C = 46316 C = 8351 C = 34358 D = 24033 D = 63069 D = 34358 D = 45639 INTERAÇÃO FINAL A = 19057 B = 11640 C = 33583 D = 60240
Esta tabela resume toda a cifragem de um bloco de 64 bits no algoritmo DRT. Na entrada temos:
A = 0 B = 0 C = 0 D = 0 A Chave de cifragem é (em Hexadecimal, 240 bits): 000000000000000000000000000000000000000000000000000000000000 O Criptograma correspondente é: A = 19057 B = 11640 C = 33583 D = 60240
Em seguida vejamos um exemplo da decifragem utilizando o algoritmo DRT.
2.4 DECIFRAGEM PASSO A PASSO
Consideremos o criptograma cujos valores para A, B, C e D, representem respectivamente 19057, 11640, 33583 e 60240, e cuja chave seja
[000000000000000000000000000000000000000000000000000000000000]. Vamos à sua decifragem. Como se fez na cifragem, vamos condensar a decifragem relativa à interação final e às rodadas de 8 até 2 (note que na decifragem devemos considerar tudo ao inverso!!!) em uma tabela. Veja a seguir:
| RODADA | Rotação | Difusão | Inversão | Soma & Subtração |
| INTERAÇÃO FINAL |
A = 37778 B = 8351 C = 34358 D = 45639 |
|||
| 8 | A = 45639 B = 37778 C = 8351 D = 34358 |
A = 28373 B = 57675 C = 46316 D = 63069 |
A = 54708 B = 19446 C = 60526 D = 24033 |
A = 56835 B = 31582 C = 52193 D = 37815 |
| 7 | A = 37815 B = 56835 C = 31582 D = 52193 |
A = 7984 B = 19020 C = 18856 D = 58646 |
A = 12361 B = 19685 C = 43039 D = 5706 |
A = 1035 B = 28538 C = 10518 D = 14085 |
| 6 | A = 14085 B = 1035 C = 28538 D = 10518 |
A = 50993 B = 52486 C = 64460 D = 59559 |
A = 12795 B = 1768 C = 52423 D = 42957 |
A = 48815 B = 39829 C = 18683 D = 8025 |
| 5 | A = 8025 B = 48815 C = 39829 D = 18683 |
A = 44466 B = 40790 C = 62816 D = 9878 |
A = 45813 B = 22054 C = 24749 D = 38559 |
A = 2732 B = 56111 C = 65211 D = 53860 |
| 4 | A = 53860 B = 2732 C = 56111 D = 65211 |
A = 41263 B = 14408 C = 18922 D = 30032 |
A = 12105 B = 18549 C = 60065 D = 20536 |
A = 30218 B = 52033 C = 40194 D = 13053 |
| 3 | A = 13053 B = 30218 C = 52033 D = 40194 |
A = 30615 B = 17165 C = 60987 D = 4806 |
A = 38894 B = 3346 C = 15223 D = 50755 |
A = 23253 B = 62006 C = 47626 D = 56413 |
| 2 | A = 56413 B = 23253 C = 62006 D = 47626 |
A = 27251 B = 32376 C = 15485 D = 60046 |
A = 29500 B = 30954 C = 32106 D = 36478 |
A = 39337 B = 43445 C = 11434 D = 61640 |
LÓGICA DA DECIFRAGEM (última volta)
A = 39337 B = 43445 C = 11434 D = 61640 ACL = D D = C C = B B = A A = ACL A = 61640 B = 39337 C = 43445 D = 11434
ACL = (C DIV 256) + ((B MOD 256) * 256) ACL = (ACL XOR A) D = (D – ACL + 65536) MOD 65536 D = (D XOR B) ACL = (43445 DIV 256) + ((39337 MOD 256) * 256) = 43433 ACL = 43433 XOR 61640 = 22881 D = (11434 – 22881 + 65536) MOD 65536 = 54089 D = (54089 XOR 39337) = 19168 ACL = (A * KEY[N + 5]) ACL = (ACL + (B XOR 30561)) MOD 65536 C = C XOR B C = (C - ACL + 65536) MOD 65536 ACL = (61640 * 28188) = 1737508320 ACL = (1737508320 + (39337 XOR 30561)) MOD 65536 = 13480 C = 43445 XOR 39337 = 12316 C = (12316 – 13480 + 65536) MOD 65536 = 64372 ACL = ((C XOR 27809) + (D * KEY[N + 4])) MOD 65536 B = (B - A + 65536) MOD 65536 A = (A XOR ACL) ACL = (64372 XOR 27809) = 38869 ACL = (38869 + (19168 * 12596)) MOD 65536 = 44373 B = (39337 – 61640 + 65536) MOD 65536 = 43233 A = (61640 XOR 44373) = 23965
Valores atuais para as words:
A = 23965 B = 43233 C = 64372 D = 19168
X1 = (A MOD 256) * 256 X2 = C DIV 256 X3 = (C MOD 256) * 256 X4 = A DIV 256 A = (X1 + X2) C = (X3 + X4) X1 = (23965 MOD 256) * 256 = 40192 X2 = 64372 DIV 256 = 251 X3 = (64372 MOD 256) * 256 = 29696 X4 = 23965 DIV 256 = 93 A = (40192 + 251) = 40443 C = (29696 + 93) = 29789 X1 = (B MOD 256) * 256 X2 = D DIV 256 X3 = (D MOD 256) * 256 X4 = B DIV 256 B = (X1 + X2) D = (X3 + X4) X1 = (43233 MOD 256) * 256 = 57600 X2 = (19168 DIV 256) = 74 X3 = (19168 MOD 256) * 256 = 57344 X4 = (43233 DIV 256) = 168 B = (57600 + 74) = 57674 D = (57344 + 168) = 57512 A = 40443 B = 57674 C = 29789 D = 57512
A = (A - KEY[N + 0] + 65536) MOD 65536 B = (B + KEY[N + 1]) MOD 65536 C = (C + KEY[N + 2]) MOD 65536 D = (D - KEY[N + 3] + 65536) MOD 65536 A = (40443 – 40443 + 65536) MOD 65536 = 0 B = (57674 + 7862) MOD 65536 = 0 C = (29789 + 35747) MOD 65536 = 0 D = (57512 – 57512 + 65536) MOD 65536 = 0
ENFIM O BLOCO DECIFRADO:
A = 0 B = 0 C = 0 D = 0
Está completo o processo de decifragem do Criptossistema DRT.
SOBRE A GERAÇÃO DE CHAVES
O módulo de geração de chaves do Criptossistema DRT parte de uma semente de 240 bits, ou 30 bytes. É necessário primeiro explicar a função transformadora CIF. Esta função recebe um conjunto de 80 bits e retorna um conjunto de 80 bits. Ela utiliza 2 vetores auxiliares que contém os seguintes valores:
Nº VETOR 1 VETOR 2 1 155 199 2 211 99 3 33 66 4 82 113 5 21 105 6 101 17 7 41 235 8 91 73 9 249 159 10 173 234
Observa-se que todos os elementos dos 2 vetores representados na tabela acima podem ser representados por um único byte. A entrada da função também deve corresponder a um vetor de 10 elementos que obrigatoriamente tem os seus elementos com valores entre 0 e 255.
A primeira operação consiste em somar cada um dos elementos do vetor de entrada com cada um dos elementos do vetor 1 extraindo o módulo em base 256. Considerando que o vetor de entrada (VETOR BASE) possui todos os seus 10 elementos iguais a zero, temos:
Nº VETOR BASE VETOR 1 NOVO VETOR BASE 1 0 155 155 2 0 211 211 3 0 33 33 4 0 82 82 5 0 21 21 6 0 101 101 7 0 41 41 8 0 91 93 9 0 249 249 10 0 173 173
Para dar seqüência ao processo desta função temos uma estrutura com 10 voltas. Esta estrutura é dividida em 4 partes:
- 1ª parte: Alteração dos 5 primeiros elementos do VETOR BASE.
- 2ª parte: Permutação dos 10 elementos do VETOR BASE.
- 3ª parte: Adição dos elementos do VETOR 2 no VETOR BASE.
- 4ª parte: Rotação dos elementos do VETOR 2.
Vamos explicá-las detalhadamente:
Consiste simplesmente em fazer uma operação XOR entre o elemento 6 do VETOR BASE ao elemento 1; o elemento 7 ao elemento 2; o elemento 8 ao elemento 3; o elemento 9 ao elemento 4 e finalmente o elemento 10 ao elemento 5. Resta dizer que os elementos alterados são os de índice 1, 2, 3, 4 e 5, PERMANECENDO INALTERADOS OS DEMAIS!!!
Nº VETOR BASE RESULTADO 1 155 2 211 3 33 4 82 5 21 6 101 254 7 41 250 8 91 122 9 249 171 10 173 184
O VETOR BASE resultante é: 254, 250, 122, 171, 184, 101, 41, 91, 249, 173. Observem que os últimos 5 elementos do VETOR BASE ficaram inalterados e os 5 primeiros (que estão em negrito) foram alterados.
Nesta fase o VETOR BASE tem os seus elementos trocados de posição. A troca obedece a 2 índices, sendo um para as voltas pares e outro para as voltas ímpares. Como estão na 2ª parte da PRIMEIRA VOLTA vamos utilizar o índice de permutação 1.
Nº VETOR BASE ÍNDICE DE VETOR BASE PERMUTAÇÃO 1 254 8 91 2 250 5 184 3 122 2 250 4 171 3 122 5 184 9 249 6 101 1 254 7 41 10 173 8 91 7 41 9 249 4 171 10 173 6 101
Verificamos que o índice de permutação é 8, 5, 2, 3, 9, 1, 10, 7, 4, 6. Este índice se refere às voltas de número ímpar. Para as voltas de número par o índice é 4, 7, 2, 9, 3, 6, 8, 10, 1, 5. O VETOR BASE, após a permutação contém os seguintes elementos: 91, 184, 250, 122, 249, 254, 173, 41, 171, 101.
Nesta parte soma-se cada elemento do VETOR BASE com cada elemento do VETOR 2 resultando deste processo um NOVO VETOR BASE.
Nº VETOR BASE VETOR 2 NOVO VETOR BASE 1 91 199 34 2 184 99 27 3 250 66 60 4 122 113 235 5 249 105 98 6 254 17 15 7 173 235 152 8 41 73 114 9 171 159 74 10 101 234 79
Quando há o estouro do valor 256 deve-se considerar o módulo do valor da soma nesta base.
Nesta operação os elementos do VETOR 2 sofrem uma rotação, ou seja, o 1º elemento passa a ser o 2º, o 2º passa a ser o 3º e assim por diante, sendo que o último elemento do vetor 2 passa a ser o primeiro.
Nº VETOR 2 NOVO VETOR 2 1 199 234 2 99 199 3 66 99 4 113 66 5 105 113 6 17 105 7 235 17 8 73 235 9 159 73 10 234 159
O VETOR BASE termina a primeira volta com os seguintes valores: 34, 27, 60, 235, 98, 15, 152, 114, 74, 79. A partir deste ponto o VETOR BASE é modificado pela outras 9 voltas restantes. Após a décima volta o VETOR BASE fica com os elementos 68, 80, 23, 97, 39, 137, 89, 160, 161, 177. Vamos chamar esta função de CIF. Ela recebeu um Vetor onde os 10 elementos eram nulos (0) e retornou um Vetor com os elementos 68, 80, 23, 97, 39, 137, 89, 160, 161, 177.
MOSTRANDO A FUNÇÃO DE GERAÇÃO DE SUB-CHAVES DO CRIPTOSSISTEMA DRT
Como o processo de geração de chaves é pouco intuitivo resolvi demonstrá-lo em um código escrito em CLIPPER. Vejamos:
PRIMEIRAMENTE ESCLARECEMOS: M_CHAVE é a variável que representa a chave do Sistema com 30 bytes, em formato ASCII.
D_Chave := M_chave
L_chave := Space(0)
For Ct := 1 to 3
CTemp := Space(0)
For Cont := 1 to 30 Step 10
L_Chave := Cif(Substr(D_chave,Cont,10))
Ctemp := Ctemp + L_Chave
Next
Ctemp := Stuff(Ctemp,11,10,Cif(Substr(CTemp,11,10)))
Ctemp := Stuff(Ctemp,21,10,Cif(Substr(CTemp,21,10)))
Ctemp := Stuff(Ctemp,21,10,Cif(Substr(CTemp,21,10)))
M_chave := M_chave + Ctemp
D_chave := Substr(CTemp,7) + Substr(Ctemp,1,6)
Next
ESCLARECENDO O CÓDIGO ACIMA:
Primeiramente temos duas variáveis: D_chave e L_chave. A primeira é uma cópia da chave inicial e a segunda é um elemento vazio (espaço zero).
Depois temos uma estrutura de 3 voltas onde temos uma variável nula (Ctemp). A estrutura interna tem 3 voltas sendo que em cada volta altera um terço da chave de entrada. A 1ª altera os primeiros 10 bytes da chave e os guarda na variável L_chave. A segunda volta altera os bytes intermediários da chave (11 até 20) e a 3ª volta altera os últimos 10 bytes da chave. O resultado destas operações é um cordel de 30 bytes que é armazenado na variável Ctemp.
Posteriormente os bytes intermediários de Ctemp (cordel calculado anteriormente) são alterados pela função CIF. Os últimos 10 bytes de Ctemp são alterados pela função CIF duas vezes!
Por fim a variável Ctemp (que tem 30 bytes) é agregada a chave inicial de 30 bytes. Então a chave inicial (M_chave) passa a ter 60 bytes após a primeira rodada. A variável D_chave é alterada sendo composta agora pelos elementos 7 até 30 e os elementos 1, 2, 3, 4, 5 e 6 de Ctemp (cordel calculado anteriormente).
Este processo é repetido mais duas vezes: na 2ª rodada a chave (M_chave) deve conter 90 bytes e na 3ª rodada 120 bytes. Após esta fase, como vemos no código abaixo, os bytes compreendidos entre os números 11 e 20 da chave (M_chave) sofrem uma transformação através da função CIF. Depois a chave é rotacionada tendo como ponto inicial o seu 7º elemento e terminando com os seus 6 primeiros elementos. Este processo é feito 120 vezes!
For Cont := 1 to 120
M_chave := Stuff(M_chave,11,10,Cif(Substr(M_chave,11,10)))
M_chave := Substr(M_chave,7) + Substr(M_chave,1,6)
Next
Preenchendo o Vetor de Chaves: ESTE CÓDIGO TRANSFORMA O VETOR ASCII EM 52 SUB-CHAVES DE 16 BITS.
CONT := 1
N := 1
DO WHILE.T.
KEY[N] := BIN2W(SUBSTR(M_CHAVE,CONT,2))
N := N + 1
CONT := CONT + 2
IF N > 52
EXIT
ENDIF
ENDDO
O código acima pode ser explicado simplesmente: A chave (M_CHAVE) possui 120 bytes. Estes 120 bytes são suficientes para gerar 60 chaves de 16 bits. As primeiras 52 serão as 52 sub-chaves utilizadas na cifragem ou decifragem dos dados criptografados com o algoritmo DRT. As últimas 8 sub-chaves são desprezadas.
De posse destas 52 sub-chaves nós podemos iniciar o processo de cifragem ou decifragem conforme já foi explicado anteriormente nesta exposição.
CONCLUSÃO
Como autor do criptossistema DRT minhas palavras de nada valem para louvá-lo ou desprezá-lo. Somente as opiniões dos especialistas podem dizer o que realmente este criptossistema representa.
Apesar disto, em alguns testes que foram feitos, o cifrário se revelou satisfatoriamente forte, não apresentando características comuns aos cifrários banais.
A vocês, leitores interessados na Criptologia, cabe dar o veredicto.
Sobre o autor
Meu amigo Yugi, sempre muito solícito, em Abril de 2004, enviou um novo criptossistema que ele chamou de DRT-240. Trata-se de um algoritmo simétrico que trabalha com criptografia de blocos de 64 bits e uma chave de 240 bits. Como sempre, um trabalho de altíssima qualidade. Sinto-me honrada em poder divulgá-lo. Conheça o DRT-240!
Este algoritmo também está zipado num pacote que contém o texto explicativo que foi publicado aqui na Aldeia, um programa de cifragem que usa o DRT-240 da autoria do próprio Yugi e um texto desafio - você deve achar a chave que foi usada para cifrá-lo. Quem é que se habilita?