Por Jackeline Aguilar y Lucio Torrico
Pagina Nº 2

En el otro caso mencionado, el script que se utiliza para devolver una
página en función del carnet y la clave digitadas -previa desencriptación
de los datos- utiliza también perl junto a algunos módulos ya comentados.
Además dicho script hace mención a una Matriz misma que se describe a continuación. Luego está el script indicado.

"matriz.txt":

El script "Simetrico2" es:

#! /usr/bin/perl

require "cgi-lib.pl";         

&ReadParse(*input);

$Carnet = $input{'ci'}           
#Entrada del carnet mediante interfaz web

$Clave = $input{'cl'}           
#Entrada de la clave mediante interfaz web

if(open(TEXTO, "Taller.cfd"))     
#Apertura del archivo cifrado Taller.cfd

  {                          
#que permitirá la búsqueda del alumno

    $i = 0;                        

    $encontrado = 0;

    @Fila = <TEXTO>;         
#Manejamos las filas de Taller.cfd como un

    @Alumno = $Fila[0];      
#vector, hacemos lo mismo con las columnas
#Mientras existan elementos en Alumno y

    while((@Alumno != " ") & ($encontrado == 0))     
#el alumno no haya sido

    {                                                
#encontrado es buscado

      @Alumno = split(/:/, @Fila[$i]);

      $CI = $Alumno[0];

if ($Carnet == $CI)      
#Si el Carnet introducido es igual al     

{                            
#registrado, el alumno fue encontrado

          $encontrado = 1;

#Controlamos que su longitud sea 11

         if ((length($Clave) == 11) & ($encontrado == 1))     
#incluye enter

         {                         
#Si lo es, procedemos a descifrar

            $Todo = $Alumno[1];

            $Todo = &Descifra($Todo, $Clave);
#Llamada a función Descifra

                print "$Todo \n";

         }

         else                   
#La clave que introdujo no es correcta

         {

           print "SU CLAVE NO ES CORRECTA !!! \n";

         }

      }

      $i = $i + 1;

   }

   if($encontrado == 0)      
#Si el alumno no fue encontrado en Taller.cfd

   {

      print "El carnet NO SE ENCUENTRA,
consulte con Kardex \n";

   }

}

else                               
#En caso de que Taller.cfd no exista

{

    print "No se puede abrir el archivo..\n";

}

###### Inicio del segmento de las
funciones de Descifrado #####

#Función general de descifrado, incluye
#llamadas a funciones específicas

sub Descifra

{

   local($Texto, $Clave) = @_;       
#Recepción de variables de la función

   $Binario = &Bina($Texto, $Clave);     
#Llamada a la función Bina

   @Estudiante = split(/:/, $Binario);

   if ($Binario ne 'NO BUENA')

   {

     $Nombre = $Estudiante[0];

     $Nombre = &Descifrado($Nombre, $Clave); 
#Llamada a la función Descifrado

     $Nota1 = $Estudiante[1];

     $Nota1 = &Descifrado($Nota1, $Clave);   
#Llamada a la función Descifrado

     $Nota2 = $Estudiante[2];

     $Nota2 = &Descifrado($Nota2, $Clave);   
#Llamada a la función Descifrado

     $Nota3 = $Estudiante[3];

     $Nota3 = &Descifrado($Nota3, $Clave);  
#Llamada a la función Descifrado

     $NF = $Estudiante[4];

     $NF = &Descifrado($NF, $Clave);        
#Llamada a la función Descifrado

     $Cadena = '';                        
#Concatenamos los datos descifrados

     $Cadena = join($Nombre, $Cadena,'  ');

     $Cadena = join($Nota1, $Cadena,'  ');

     $Cadena = join($Nota2, $Cadena,'  ');

     $Cadena = join($Nota3, $Cadena,'  ');

     $Cadena = join($NF, $Cadena,'  ');

   }

   else {$Cadena = 'SU CLAVE NO ES CORRECTA !!! ';}

$Cadena;
#Devolución de Cadena como valor de la función

}

#Función de descifrado, incluye llamadas a los
#métodos Vigenere y César

sub Descifrado

{

   local($Texto, $Clave) = @_;
#Recepción de variables de la función

   $Transposicion = &Transpo($Texto, $Clave);

   $Cesar = &Cesi($Transposicion, $Clave);

   $Cesar;                   
#Devolución de Cesar como valor de la función

}

#Función de descifrado, método que trabaja
#con información binaria

sub Bina

{

   local ($Te, $Cl) = @_;
#Recepción de variables de la función

   @T = split(//, $Te);

   @C = split(//, $Cl);

   $NT = length($Te);

   $N = $NT/8;

   $i = 0;                   
#Ponemos la clave a igual longitud del texto

   $j = 0;

   while ( $i < $N)

   {

       if ($j eq 10)

       {

          $j = 0;

       }

       else

       {

        @NC[$i] = $C[$j];

        $j = $j + 1;

          $i = $i + 1;

       }

   }

   $l = 0;
#Convertimos la clave a su equivalente en binario

   while($l<$N)

   {

      $ave = $NC[$l];

      $NC[$l] = &DecBin($ave);
#Llamada a la función DecBin

      $l = $l + 1;

   }

   $j = 0;
#Negamos el texto cifrado, actualmente en binario

   $i = 0;

   while ($i<$NT)

   {

      if ($T[$i] == 0)

      {

         $T[$i] = 1;

      }

      else

      {

         $T[$i] = 0;

      }

      $i = $i + 1;

   }

  $i = 0;
#Tomamos el texto y la clave, los sometemos a un xor

  $j = 0;

  while ($i<$NT)

   {

      @AuxClav = split(//, $NC[$j]);

      $j++;

      $k = 0;

      while($k<8)

      {

         if ($T[$i] == $AuxClav[$k])

         {

            $T[$i] = 0;

         }

         else

         {

            $T[$i] = 1;

         }

         $i++;

         $k++;

      }

   }

     @Dec = '';
#Convertimos el texto a su equivalente decimal,

   $k = 0;
#para ello conformamos grupos de 8 bits

   $i = 0;

   $swi = 0;

   while($i<$NT)
#Mientras no se haya convertido todo el texto

   {  $j = 0;

      $DecVal = '';

      while($j<8)
#Mientras no sea un grupo de ocho bits

      {

         $DecVal = join($T[$i], $DecVal,'');

         $j++;

         $i++;

      }

      $Dec[$k] = $DecVal;

      $ave = $Dec[$k];

      $Dec[$k] = &BinDec($ave);
#Llamada a la función de conversión de
#binario a decimal BinDec

        if ($Dec[$k] eq 'NO BUENA')
#Si alguna conversión no fue posible

      {

         $k = $NT - 1;

         $swi = 1;

      }

       $k++;

   }

    if ($swi == 0)
#Si toda la conversión fue realizada
#satisfactoriamente concatenamos todo el texto

   {

      $Des = '';

      for ($i = 0; $i < $N; $i++)

      {

         $Des = join($Dec[$i], $Des,'');

      }

   }

   else {$Des = 'NO BUENA';}

   $Des;
#Devolución de Des como valor de la función

}

#Función de conversión de bases (de decimal a binario),
#necesaria para el método de descifrado que trabaja a
#nivel binario

sub DecBin

{

local ($Char) = @_;
#Recepción de variables de la función

@Letras=(' ','0','1','2','3','4','5','6','7','8','9',
'A','B','C','D','E','F','M','N','Ñ','O','P','Q','R',
'S','T','U','V','W','X', 'Y','Z',':');

@Valor=(32, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65,
66, 67, 68, 69, 70,71, 72, 73, 74, 75, 76, 77, 78,165,
79, 80, 81, 82, 83, 84, 85, 86, 87, 88,89, 90,58);

  $i = 0;
#Búsqueda de la posición equivalente a un caracter de

  $sw = 0;
#entrada en el vector Letras

  for ($c = 0; $c < 39; $c++)

  {

      if ($Letras[$c] eq $Char)

      {

         $sw = 1;

         $i = $c;

      }

  }

if ($sw == 1)
#Si el caracter está en Letras, encontrarlo en Valor

  {

      $ValBin = '';

      $Asci = $Valor[$i];

        while($Asci >= 2)
#Realizamos la conversión de bases (a binario)

      {

        $Resto = $Asci % 2;

        $Asci = int($Asci/2);

        $ValBin =  join($Resto, $ValBin,'');

      }

      $ValBin = join($Asci, $ValBin,'');

      $NV = length($ValBin);

      @BinVal = split(//, $ValBin);

       $ValBin = '';

      $i = $NV - 1;

       while ($i ne 0)

      {

         $ValBin = join($BinVal[$i], $ValBin,'');

         $i--;

      }

      $ValBin = join($BinVal[$i], $ValBin,'');

       $Falta = 8 - $NV;

      for ($i = 1; $i <= $Falta; $i++)
#Ponemos las conversiones a la

     {
#longitud de un byte (8 bits)

        $ValBin = join($ValBin, '0', '');
#completando con ceros a la izquierda

     }

  }

  else {$ValBin = 'NO BUENA';}

  $ValBin;
#Devolución de Balbín como valor de la función

}

#Función de conversión de bases (de binario a decimal),
#necesaria para el

#método de descifrado que trabaja a nivel binario

sub BinDec

{

local ($Cad) = @_; # Recepción de variables

@Letras=(' ','0','1','2','3','4','5','6','7','8','9',
'A','B','C','D','E','F','G','H','I','J','K','L','M',
'N','Ñ','O','P','Q','R','S','T','U','V','W','X','Y',
'Z',':');

@Valor=(32, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
65, 66, 67, 68, 69, 70,71, 72, 73, 74, 75, 76, 77,
78,165, 79, 80, 81, 82, 83, 84, 85, 86, 87,88, 89,
90,58);

   @Dig = split(//, $Cad);

   $Suma = 0;

   $Expo = 7;

   $p = 0;

   while($p < 8)
#Agrupamos bytes y calculamos potencias

   {

       $Potencia = &Pot($Expo);
#Llamada a la función Pot

       $Suma = $Suma + ($Dig[$p] * $Potencia);

       $Expo = $Expo - 1;

       $p++;

   }

  $p = 0;

  $sw = 0;

  for ($c = 0; $c < 39; $c++)
#Buscamos la cantidad obtenida en el

  {
#vector Valor

      if ($Valor[$c] eq $Suma)

      {

         $sw = 1;

         $p = $c;

      }

  }

  if ($sw == 1)
#Si no fue encontrada (la cantidad), el equivalente no

  {
#es correcto

     $ValDec = $Letras[$p];

  }  

  else {$ValDec = 'NO BUENA';}

  $ValDec;
#Devolución de ValDec como valor de la función

}

#Simulación del cálculo de potencia
# mediante multiplicaciones sucesivas,
#necesaria para la función de conversión
#de binario a decimal

sub Pot

{

  local ($Ex) = @_;
#Recepción de variables de la función

  $Resp = 1;

  for ($c = 0; $c < $Ex; $c++)

  {

     $Resp = $Resp * 2;

  }

$Resp;
#Devolución de ValDec como valor de la función

}

#Descifrado de datos mediante el método
de encriptamiento Vigenere

sub Transpo

{

   local ($Tex, $Cla) = @_;
#Recepción de variables de la función

   @T = split(//, $Tex);

   @C = split(//, $Cla);

   $N = length($Tex);

   $i = 0;
#Ponemos la clave a la longitud del texto

   $j = 0;

   while ( $i < $N)

   {

       if ($j == 10)

       {

          $j = 0;

       }

       else

       {

        $NC[$i] = $C[$j];

        $j = $j + 1;

          $i = $i + 1;

       }

   }

   open(M,"matriz.txt");
#Abrimos el archivo matriz.txt

   @Linea = <M>;
#Manejamos las filas matriz.txt como un vector

   $i = 0;
#Buscamos los caracteres de la clave en las     

   while ($i < $N)
#columnas de matriz.txt y los caracteres

   {
#cifrados en las filas

      $L = $Linea[0];

      @F = split(/:/, $L);

      $k = 0;

      while(@NC[$i] ne @F[$k])

      {

       $k++;

      }

      $j = 1;

      $L = $Linea[$j];

      @F = split(/:/, $L);

      while($F[$k] ne $T[$i])

      {

         $L = $Linea[$j];

         @F = split(/:/, $L);

         $j++;

      }

      $T[$i] = $F[0];

      $i++;

   }

   $Des = '';
#Unimos todos los caracteres descifrados en Des

   for ($i = 0; $i < $N; $i++)

   {

       $Des = join($T[$i], $Des,'');

   }

   $Des;
#Devolución de Des como valor de la función

}

#Descifrado de datos mediante el método
#de encriptamiento Cesar

sub Cesi

{

 local ($Text, $Clav)= @_;
#Recepción de variables de la función

 @Letras=(' ','0','1','2','3','4','5','6','7'
,'8','9','A','B','C','D','E','F','G','H','I',
'J','K','L','M','N','Ñ','O','P','Q','R','S',
'T','U','V','W','X','Y','Z');

   @T = split(//, $Text);

   @C = split(//, $Clav);

   $N = length($Text);

   $CCesar = join($C[1], $C[0],'');
#Obtenemos la clave para el descifrado

   $i = 0;
#Buscamos los caracteres del texto cifrado( para su  

   while($i < $N)
#sustitución) en el vector Letras

   {

      $j = 0;

      while($T[$i] ne $Letras[$j])

      {

         $j++;

      }

      $Posicion =  $j - $CCesar;

      if ($Posicion < 0)

      {

         $Posicion = 38 + $Posicion;

      }

      $T[$i] = $Letras[$Posicion];
#Los cambiamos

      $i++;

   }

   $Des = '';
#Unimos el texto descifrado en la variable Des

   for ($i = 0; $i < $N; $i++)

   {

       $Des = join($T[$i], $Des,'');

   }

   $Des;
#Devolución de Des como valor de la función

}

De ser necesario está abierta la posibilidad de que los autores distribuyan
a quienes deseen el programa utilizado para encriptar los datos iniciales
y llevar este resultado a un archivo de texto, el "Taller.cfd". Sin embargo,
creemos que ello es deducible a partir del programa para descifrado.

A continuación hacemos algunos comentarios globales sobre
el método de encriptación/desencriptación:

Para el cifrado de datos fueron aplicados métodos de encriptamiento
simétricos, los que poseen una gran ventaja -la velocidad-.
Los resultados de la desencriptación, haciendo referencia a la velocidad
de la plataforma de trabajo, son considerados satisfactorios pues el
tiempo de respuesta bien parecía el de una red local.

Retomando el tema de los métodos de encriptamiento, se aplicaron los
clásicos métodos César y Vigenere además del método que trabaja con
información a nivel binario. Juntos todos, hacen que el proceso de
descifrado sea más complejo.

Dichos métodos podemos encontrarlos junto a otros, en textos y
manuales básicos de Criptografía.

CONCLUSIONES

Como conclusión central el trabajo muestra -en la práctica- que la
plataforma linux ofrece interesantes e incluso ventajosas posibilidades
para el desarrollo de software. El hecho de que se esté utilizando
actualmente, muestra también que puede 'explotarse' -en el buen
sentido- ya, ahora.

Esta experiencia -la del concurso- es una demostración de que las
herramientas de base junto a las herramientas de desarrollo están
ya -en el plano local- suficientemente maduras como para ambicionar
más aplicaciones, bajo el marco de la filosofía que todos conocemos
está detrás de linux.