Leer entrada Leer clave longitud_seed <- 64 iniciador <- 0 ini <- 0 texto <- entrada llave <- clave
si llave = NULO entonces llave <- "DEA" fin si
longitud_texto <- funcion_hallar_longitud(texto) longitud_llave <- funcion_hallar_longitud(llave) para i<-iniciador mientras i < longitud_texto hacer
suma_ascii_texto <- suma_ascii_texto + funcion_hallar_ascii(texto{i}) cadena_acsii_texto <-
funcion_concatenar(cadena_ascii_texto,suma_ascii_texto) i <- i + 1
fin para
longitud_cadena_acsii_texto <- funcion_hallar_longitud(cadena_acsii_texto) para i<-iniciador mientras i < longitud_cadena_ascii_texto hacer
nuevo_texto_temp <- funcion_convertir_a_texto(funcion_concatenar(cadena_acsii_texto{i},cadena_acsii_t exto{i+1},cadena_acsii_texto{i+2})) nuevo_texto <- funcion_concatenar(nuevo_texto,nuevo_texto_temp) i <- i + 2 fin para
para i<-iniciador mientras i < longitud_llave hacer
suma_ascii_llave <- suma_ascii_llave + funcion_hallar_ascii(llave{i}) cadena_acsii_llave <-
funcion_concatenar(cadena_ascii_llave,suma_ascii_llave) i <- i + 1
fin para
longitud_cadena_acsii_llave <- funcion_hallar_longitud(cadena_acsii_llave) para i<-iniciador mientras i < longitud_cadena_ascii_llave hacer
nueva_llave_temp <- funcion_convertir_a_texto(funcion_concatenar(cadena_acsii_llave{i},cadena_acsii_ll ave{i+1},cadena_acsii_llave{i+2})) nueva_llave <- funcion_concatenar(nueva_llave,nueva_llave_temp) i <- i + 2 fin para
para i<-iniciador mientras i < longitud_seed hacer
para j<-iniciador mientras j < longitud_llave hacer si i = longitud_seed entonces
terminar_ciclos sino
nueva_llave{j}) fin si i <- i + 1 fin para i <- i - 1 fin para
para i<-iniciador mientras i < longitud_seed hacer nt <- funcion_concatenar(nt, nuevo_texto{i}) nt <- funcion_concatenar(nt, nueva_seed{i}) i <- i + 1
fin para
longitud_nt <- funcion_hallar_longitu(nt)
para i<-iniciador mientras i < longitud_nt hacer
ascii <- funcion_concatenar(ascii, funcion_hallar_ascii(nt{i})) i <- i + 1
fin para
longitud_ascii <- funcion_hallar_longitud(ascii) para i<-iniciador mientras i < longitud_ascii hacer
h1 <- funcion_concatenar(ascii{i}, ascii{i+1}) h2 <- funcion_concatenar(ascii{i+2}, ascii{i+3}) sec <- nuevo_ascii{i} + nuevo_ascii{i+1}
h3 <- h1 + h2 + h3
nuevo_ascii <- funcion_concatenar(nuevo_ascii, h3) i <- i + 1
longitud_nuevo_ascii <- funcion_hallar_longitud(nuevo_ascii) si longitud_nuevo_ascii < 1024 entonces
para i<-longitud_nuevo_ascii+1 mientras i < 1024 hacer nuevo_ascii <- funcion_concatenar(nuevo_ascii, "3") i <- i + 1
fin para fin si
para i<-iniciador mientras i < 8 haga
para j<-ini mientras j < ini+128 haga
semi[i] <- funcion_concatenar(semi[i], nuevo_ascii{j}) j <- j + 1
fin para
ini <- ini + 128 fin para
para i<-127 mientas i >= 0 hacer
o <- semi[0]{i} + semi[1]{i} + semi[2]{i} + semi[3]{i} + semi[4]{i} + semi[5]{i} + semi[6]{i} + semi[7]{i}
s <- funcion_concatenar(s, o) i <- i - 1
fin para
longitud_s <- funcion_hallar_longitud(s) para i<-iniciador mientras i < longitud_s hacer
string <- funcion_concatenar(s{i},s{i+1},s{i+2},s{i+3}) si string < 48 entonces
fin si
si string > 122 entonces string <- string - 74 fin si
si string > 57 y string < 65 entonces string <- string + 8
fin si
si string > 90 y string < 97 entonces string <- string - 8
fin si
hash <- funcion_concatenar(hash, funcion_convertir_a_texto(string)) i <- i + 4
fin para escribir hash FINALGORITMO
4.2.5 Implementación
Tabla 2. Comparación entre C, PHP, ASP
Características C Pts. PHP Pts. ASP Pts.
Licencia Libre 5 Libre 5 No Libre 1
Multi-plataforma Sí 5 Sí 5 No 1
Portabilidad No 1 Sí 5 Sí 5
Conocimientos necesarios Avanzado 1 Intermedio 3 Intermedio 3
Intuitividad Baja 1 Alta 5 Alta 5
Rapidéz Alta 5 Alta 5 Alta 5
Puntuación TOTAL 18 TOTAL 27 TOTAL 20
Debido a las características necesarias para implementar el algorítmo, y la calificación recibida según los items estipulados, el mejor lenguaje de programación para la implementación y demostración del algorítmo es PHP.
Para la demostración del funcionamiento del algorítmo este se escribió en el lenguaje de programación web PHP, y su código y explicación se encuentran a continuación. Para entender el funcionamiento del algorítmo hace falta tener conocimientos medianos en el lenguaje de programación estipulado.
Se declara la función DEA junto con los argumentos de entrada, los cuales son dos variables, $text que representa el texto plano a ser cifrado y la variable $key la cual representa la llave a ser usada, ya que el algorítmo acepta una llave estipulada por el usuario. Si no existe una llave estipulada por el usuario, el algorítmo usará una llave por defecto, la cual es 'DEA', el texto y la llave se copian en las variables $t y $l respectivamente a su vez, la variable $long almacena la longitud de la llave, esta longitud entre más alta sea, mayor será su seguridad, en este caso se usará una llave de 64 bits. function DEA($text,$key){ $long = 64; $count = 0; $t=$text; $l=$key; $texto = $t; if($l == NULL){ $l = 'DEA'; } $lt = strlen($t); $ll = strlen($l);
Las variables $lt y $ll almacenan la longitud del texto ingresado y la longitud de la llave respectivamente, esta longitud se obtiene por medio de la función strlen(). Luego de obtener los datos necesarios, iniciamos la conversión de cada carácter de la cadena de texto en su respectivo valor hexadecimal, estos valores se obtienen
usando la función ord() y se almacenan en la variable $at concatenando sus valores y dejando un solo texto hexadecimal al cual se le halla la longitud y se almacena en la variabale $lat.
for($a=0; $a<$lt ; $a++){ $ab = $ab + ord($t{$a}); $at = $at . $ab;
}
$lat = strlen($at);
Una vez obtenida la longitud de la cadena hexadecimal, se hacen grupos de 3 bits, para así obtener su valor ASCII por medio de la función chr() y estos se almacenan en la variable $ab concatenandolos. El nuevo texto plano será almacenando en su totalidad en la variable $t, reemplazando el antiguo texto plano.
for($a=0; $a<$lat ; $a++){
$ab = $ab . chr($at{$a}.$at{$a+1}.$at{+2}); $a = $a + 2;
}
$t = $ab;
Se realizan los mismos procedimientos para cambiar la llave. for($a=0; $a<$ll ; $a++){
$ab = $ab + ord($l{$a}); $at = $at . $ab;
}
$lat = strlen($at);
for($a=0; $a<$lat ; $a++){
$a = $a + 2; }
$l = $ab;
Una vez convertida la cadena de texto y la llave en un diferentes y nuevos textos planos, almacenados en $t y $l respectivamente, se procede a realizar grupos del tamaño de la longitud de la llave, entre más alto sea el valor de la longitud de la llave más probabilidades diferentes de hash existirán, el algorítmo fue programado para trabajar con llaves de 64 bits, por esta razón la longitud del hash es de 64 bits y la agrupación de los mismos también.
for($a=0 ; $a<$long ; $a++){ for($b=0 ; $b<$ll ; $b++){ if($a == $long){ break; } else{ $l64 = $l64.$l{$b}; } $a++; } $a = $a-1; }
Ahora se concatenan la llave y el nuevo texto hexadecimal, intercalando un bit del texto con un bit de la llave, hasta alcanzar una longitud de 128 bits y se almacena este nuevo texto en la variable $nt a la cual se le halla la longitud y se almacena en la variable $lnt, así se generarán grupos de 128 bits.
$nt = $nt.$t{$j}; $nt = $nt.$l64{$j}; }
$lnt = strlen($nt);
Se convierte el texto en una nueva cadena ASCII de carácteres, con las siguientes funciones, y estas se almacenan en la variable $ascii al igual que las otras funciones se halla la longitud para mantener siempre un control y evitar un desbordamiento de buffer.
for($j = 0; $j < $lnt ; $j++){
$ascii = $ascii.$preascii = ord($nt{$j}); }
$lascii = strlen($ascii);
Una vez obtenidos los datos, realizamos una concatenación y sumatoria de bits en grupos de 4 bits, divididos en 2 bits y concatenandolos en la nueva variable $nascii, hallando tambien su longitud.
for($j=0 ; $j < $lascii ; $j++){ $h1 = $ascii{$j}.$ascii{$j+1}; $h2 = $ascii{$j+2}.$ascii{$j+3}; $sec = $nascii{$j} + $nascii{$j+1}; $h3 = $h1 + $h2 + $sec;
$nascii = $nascii . $h3; }
$nlna = strlen($nascii);
if($nlna < 1024){ for($j=$nlna+1 ; $j<=1024 ; $j++){ $nascii = $nascii.'3'; } } $nlna = strlen($nascii);
Se inicializa la variable $ini en cero y se realizan grupos de 128 bits. En un array llamado $semi.
$ini = 0;
for($i=0 ; $i<8 ; $i++){
for($j=$ini ; $j<$ini+128 ; $j++){ $semi[$i] = $semi[$i].$nascii{$j}; }
$ini = $ini + 128; }
Ahora, luego de obtener ocho grupos de 128 bits, dentro de cada grupo se toman 8 bits y se suman entre ellos.
for($i=127 ; $i>=0 ; $i--){
$o = $semi[0]{$i}+$semi[1]{$i}+$semi[2]{$i}+$semi[3]{$i}+$semi[4]{$i}+ $semi[5]{$i}+$semi[6]{$i}+$semi[7]{$i};
$s = $s.$o; }
$ls = strlen($s);
Luego se de la sumatoria, se realizan parejas de bits y se suman consecutivamente, y se le realiza un control de salida, para que solo muestre
carácteres alfanuméricos. for($k=0 ; $k<$ls ; $k++){ $string = ($s{$k}.$s{$k+1})+($s{$k+2}.$s{$k+3}); if($string<48){ $string = $string + 74; } if($string>122){ $string = $string - 74; } if(($string>57)&&($string<65)){ $string = $string + 8; } if(($string>90)&&($string<97)){ $string = $string - 8; }
Una vez confirmado el código hexadecimal final, se convierte en convierte en texto plano, y se concatena para obtener el hash final.
$f = $f.chr($string); $k = $k + 3; } $final = $f; $msjdigest = return($final); }