Funcuion JENCRIPT

[José Luis Garcí] · #1 09-10-2010

Hola compañeros me gustaría compartir con ustedes la siguiente función, para que la estudien la comenten y si pueden ayudarme a mejorarla, fabuloso

Aquí os dejo el código

Código Delphi [-]function JENCRIPT(Accion: boolean; Cadena: String; Clave: integer;
  Valor: boolean; N_mentiras, Mentir1, Mentir2, Mentir3: integer): string;
// -----------------------------------------------------------------------------
// **************************************************[  FUNCION JENCRIPT ]******
// Funcion Propia [J.L.G.T.]
// Encipta o desencripta una cadena de texto según los valores introducidos
// [Accion]      Se encarga si es TRUE de encriptar y si es FALSE de Desincriptar
// [Cadena]      Texto para encriptar o desencriptar
// [Clave]       Valor de la clave para la encriptacion, Este valor es numero y no absoluto
// [Valor]       El valor puede ser positivo TRUE o negativo FALSE  la orden debe ser igual para
// Enciptar  que para desencriiptar pero su funcionamiento es adverso
// [N_Mentiras]  El numero de mentiras a introducir entre 1 y 3
// [Mentir1]     Cantidad de caracteres para introducir un caracter falso  Valores entre 1 y 9
// [Mentir2]     Cantidad de caracteres para introducir un caracter falso  Valores entre 1 y 9
// [Mentir3]     Cantidad de caracteres para introducir un caracter falso  Valores entre 1 y 9
// -----------------------------------------------------------------------------

// ---------------------------------------------------------------
// ShowMessage( 'Caracter:=               '+ JCaracter+      #13#10  +      //Para comprobar
// 'Valor Ordinal:=          '+  IntToStr(Ord(JCaracter[1]))+   #13#10 +
// 'Valor de Clave:=         '+  IntToStr(JValormas)+   #13#10 +
// 'Valor Jcontador0:=       '+  IntToStr(Jcontador0)+   #13#10 +
// 'Valor JCantCaracteres:=  '+  IntToStr(JCantCaracteres)+   #13#10 +
// 'Valor JuenClave:=        '+  IntToStr(Jcuenclave)+   #13#10 +
// '----------------------------------------------'+   #13#10 +
// 'Valor de Clave:=         '+  IntToStr(jclave[1])+   #13#10 +
// 'Valor de Clave:=         '+  IntToStr(jclave[2])+   #13#10 +
// 'Valor de Clave:=         '+  IntToStr(jclave[3])+   #13#10 +
// 'Valor de Clave:=         '+  IntToStr(jclave[4])+   #13#10 +
// 'Valor de Clave:=         '+  IntToStr(jclave[5])+   #13#10 +
// 'Valor de Clave:=         '+  IntToStr(jclave[6]));
// ----------------------------------------------------------------
var
  JContador, Jcadena, JVaCadena, Iclave, Icuenta, JValormas: integer;
  JFcuent1, JLie1, Jlie2, Jlie3, Jcuenclave, Jsaltar: integer;
  Jcontador0, JvalorCaracter, JCantCaracteres: integer;
  Jtexto, JCaracter: string;
  jclave: array of integer;
begin
  Jtexto := ''; // Para que siempre tenga que devolver la funcion
  Jcontador0 := 1; // Encargado de asignar los controles de clave
  JCantCaracteres := 1; // PAra poder comprobar caracteres falsos
  Jsaltar:=0;     //Para hacer saltos en el For
  case N_mentiras of // Para optener el numero de caracteres total en el control de caracteres falsos
    1:
      begin
        Icuenta := Mentir1;
        JLie1 := Mentir1; // Para saber si hay que introducir un carater falso en el Mentir1
        Jlie2 := 0; // Para no introducir caracter falso
        Jlie3 := 0; // Para no introducir caracter falso
      end;
    2:
      begin
        Icuenta := Mentir1 + Mentir2;
        JLie1 := Mentir1; // PAra saber si hay que introducir un carater falso en el Mentir1
        Jlie2 := Mentir1 + Mentir2; // PAra saber si hay que introducir un carater falso en el Mentir2
        Jlie3 := 0; // Para no introducir caracter falso
      end;
    3:
      begin
        Icuenta := Mentir1 + Mentir2 + Mentir3;
        JLie1 := Mentir1; // Para saber si hay que introducir un carater falso en el Mentir1
        Jlie2 := Mentir1 + Mentir2; // Para saber si hay que introducir un carater falso en el Mentir2
        Jlie3 := Mentir1 + Mentir2 + Mentir3; // Para saber si hay que introducir un carater falso en el Mentir3
      end;
  end;
  if length(IntToStr(Clave)) <= 10 then // Comprobamos que no pase de diez digitos la clave
  begin
    Jcuenclave := length(IntToStr(Clave));
    SetLength(jclave, Jcuenclave); // Para asignar el tamaño del array dinamico
    for Iclave := 1 to Jcuenclave do
    begin
      jclave[Iclave] := StrToInt(Copy(IntToStr(Clave), Iclave, 1));
      // A cada parte del array su valor
    end;

    if Accion = False then // Para desencriptar     *********************************************************
    begin
      for Jcadena := 1 to length(Cadena)-1 do // Empezamos el encriptado
      begin
        if Jcadena=(length(Cadena)-1) then Continue;   //El ultimo Caracter crea un caracter de mas ?? con esto lo soluciono
        if JSaltar=1 then
        begin
           Jsaltar:=0;
           Continue;
        end;
        JCaracter := Copy(Cadena, Jcadena, 1); // Cogemos un unico caracter
        JValormas := jclave[Jcontador0];
        if Valor = False then // Para valor en negativo
        begin
          JvalorCaracter := Ord(JCaracter[1]) + JValormas; // Pasamos a su valor AscII y le añadimos el Valor númerico de la clave que le pertenezca
          if JvalorCaracter > 255 then // Comprobamos que no se pase del valor mínimo ASII
          begin
            JvalorCaracter :=JvalorCaracter-255;          // La diferencia sera el nuevo valor
          end;
        end else
        begin
          JvalorCaracter := Ord(JCaracter[1]) - JValormas; // Pasamos a su valor AscII y le añadimos el Valor númerico de la clave que le pertenezca
          if JvalorCaracter < 0 then // Comprobamos que no se pase del valor mínimo ASII
          begin
            JvalorCaracter := 255 - JvalorCaracter;          // La diferencia sera el nuevo valor
          end;
        end;
        Jtexto := Jtexto + chr(JvalorCaracter);
        Jcontador0 := Jcontador0 + 1; // Sumamos para el siguiente valor de clave
        if Jcontador0 > Jcuenclave then
          Jcontador0 := 1; // Si el Jcontador0 es mayor que el numero de digitos clave lo reiniciamos
        if JLie1 = JCantCaracteres then Jsaltar:=1; // Comprobamos si hay que eliminar un caracter falso segun Mentir1
        if Jlie2 <> 0 then
        begin
          if Jlie2 = JCantCaracteres then Jsaltar:=1;// Comprobamos si hay que eliminar un caracter falso segun Mentir2
        end;
        if Jlie3 <> 0 then
        begin
          if Jlie3 = JCantCaracteres then Jsaltar:=1; // Comprobamos si hay que eliminar un caracter falso segun Mentir3
        end;
        JCantCaracteres := JCantCaracteres + 1; // Sumamos 1 a este contador
        if JCantCaracteres > Icuenta then
          JCantCaracteres := 1; // Si el contador sobrepasa el numero de caracteres de la suma de los mentir lo pone de nuevo en 1
      end;
    end   else // PAra encriptar ********************************************************
    begin // Si es enciptado
      for Jcadena := 1 to length(Cadena) do // Empezamos el encriptado
      begin
        JCaracter := Copy(Cadena, Jcadena, 1); // Cogemos un unico caracter
        JValormas := jclave[Jcontador0];
        if Valor = False then // Para valor en negativo
        begin
          JvalorCaracter := Ord(JCaracter[1]) - JValormas; // Pasamos a su valor AscII y le añadimos el Valor númerico de la clave que le pertenezca
          if JvalorCaracter < 0 then // Comprobamos que no se pase del valor mínimo ASII
          begin
            JvalorCaracter := 255 - JvalorCaracter;          // La diferencia sera el nuevo valor
          end;
        end else
        begin
          JvalorCaracter := Ord(JCaracter[1]) + JValormas; // Pasamos a su valor AscII y le añadimos el Valor númerico de la clave que le pertenezca
          if JvalorCaracter > 255 then // Comprobamos que no se pase del valor mínimo ASII
          begin
            JvalorCaracter :=JvalorCaracter - 255;          // La diferencia sera el nuevo valor
          end;
        end;
        Jtexto := Jtexto + chr(JvalorCaracter);
        Jcontador0 := Jcontador0 + 1; // Sumamos para el siguiente valor de clave
        if Jcontador0 > Jcuenclave then
          Jcontador0 := 1; // Si el Jcontador0 es mayor que el numero de digitos clave lo reiniciamos
        if JLie1 = JCantCaracteres then
          Jtexto := Jtexto + chr(Random(255)); // Comprobamos si hay que introducir un caracter falso segun Mentir1
        if Jlie2 <> 0 then
        begin
          if Jlie2 = JCantCaracteres then
            Jtexto := Jtexto + chr(Random(255)); // Comprobamos si hay que introducir un caracter falso segun Mentir2
        end;
        if Jlie3 <> 0 then
        begin
          if Jlie3 = JCantCaracteres then
            Jtexto := Jtexto + chr(Random(255)); // Comprobamos si hay que introducir un caracter falso segun Mentir3
        end;
        JCantCaracteres := JCantCaracteres + 1; // Sumamos 1 a este contador
        if JCantCaracteres > Icuenta then
          JCantCaracteres := 1; // Si el contador sobrepasa el numero de caracteres de la suma de los mentir lo pone de nuevo en 1
      end;
    end;
  end  else  ShowMessage( 'El valor de la clave no puede superar diez digitos, corrijalo e intentelo de nuevo');
  Result := Jtexto;
end;

cmm07 · #2 10-10-2010

gracias por el aporte!:.

[José Luis Garcí] · #3 12-10-2010

Hola compañeros he encontrado un par de errores, como claves que empiezen por cero o de muy pocos número, he intentado corregirlo dentro de la función, pero al final opte por crear una funcion que compare la funcion jemcript y que esta última este integrada en la nueva, (como siempre creo que lio las cosas), asi que aquí esta el código

Código Delphi [-]Function CompJencript(Accion: boolean; Cadena: String; Clave: integer;
  Valor: boolean; N_mentiras, Mentir1, Mentir2, Mentir3: integer): string;
function JENCRIPT(Accion: boolean; Cadena: String; Clave: integer;
  Valor: boolean; N_mentiras, Mentir1, Mentir2, Mentir3: integer): string;
// -----------------------------------------------------------------------------
// **************************************************[  FUNCION JENCRIPT ]******
// Funcion Propia [J.L.G.T.]
// Encipta o desencripta una cadena de texto según los valores introducidos
// [Accion]      Se encarga si es TRUE de encriptar y si es FALSE de Desincriptar
// [Cadena]      Texto para encriptar o desencriptar
// [Clave]       Valor de la clave para la encriptacion, Este valor es numero y no absoluto de 4 a 10 digitos
// [Valor]       El valor puede ser positivo TRUE o negativo FALSE  la orden debe ser igual para
// Enciptar  que para desencriiptar pero su funcionamiento es adverso
// [N_Mentiras]  El numero de mentiras a introducir entre 1 y 3
// [Mentir1]     Cantidad de caracteres para introducir un caracter falso  Valores entre 1 y 9
// [Mentir2]     Cantidad de caracteres para introducir un caracter falso  Valores entre 1 y 9
// [Mentir3]     Cantidad de caracteres para introducir un caracter falso  Valores entre 1 y 9
// -----------------------------------------------------------------------------

// ---------------------------------------------------------------
// ShowMessage( 'Caracter:=               '+ JCaracter+      #13#10  +      //Para comprobar
// 'Valor Ordinal:=          '+  IntToStr(Ord(JCaracter[1]))+   #13#10 +
// 'Valor de Clave:=         '+  IntToStr(JValormas)+   #13#10 +
// 'Valor Jcontador0:=       '+  IntToStr(Jcontador0)+   #13#10 +
// 'Valor JCantCaracteres:=  '+  IntToStr(JCantCaracteres)+   #13#10 +
// 'Valor JuenClave:=        '+  IntToStr(Jcuenclave)+   #13#10 +
// '----------------------------------------------'+   #13#10 +
// 'Valor de Clave:=         '+  IntToStr(jclave[1])+   #13#10 +
// 'Valor de Clave:=         '+  IntToStr(jclave[2])+   #13#10 +
// 'Valor de Clave:=         '+  IntToStr(jclave[3])+   #13#10 +
// 'Valor de Clave:=         '+  IntToStr(jclave[4])+   #13#10 +
// 'Valor de Clave:=         '+  IntToStr(jclave[5])+   #13#10 +
// 'Valor de Clave:=         '+  IntToStr(jclave[6]));
// ----------------------------------------------------------------
var
  JContador, Jcadena, JVaCadena, Iclave, Icuenta, JValormas: integer;
  JFcuent1, JLie1, Jlie2, Jlie3, Jcuenclave, Jsaltar: integer;
  Jcontador0, JvalorCaracter, JCantCaracteres: integer;
  Jtexto, JCaracter: string;
  jclave: array of integer;
begin
  Jtexto := ''; // Para que siempre tenga que devolver la funcion
  Jcontador0 := 1; // Encargado de asignar los controles de clave
  JCantCaracteres := 1; // PAra poder comprobar caracteres falsos
  Jsaltar:=0;     //Para hacer saltos en el For
  case N_mentiras of // Para optener el numero de caracteres total en el control de caracteres falsos
    1:
      begin
        Icuenta := Mentir1;
        JLie1 := Mentir1; // Para saber si hay que introducir un carater falso en el Mentir1
        Jlie2 := 0; // Para no introducir caracter falso
        Jlie3 := 0; // Para no introducir caracter falso
      end;
    2:
      begin
        Icuenta := Mentir1 + Mentir2;
        JLie1 := Mentir1; // PAra saber si hay que introducir un carater falso en el Mentir1
        Jlie2 := Mentir1 + Mentir2; // PAra saber si hay que introducir un carater falso en el Mentir2
        Jlie3 := 0; // Para no introducir caracter falso
      end;
    3:
      begin
        Icuenta := Mentir1 + Mentir2 + Mentir3;
        JLie1 := Mentir1; // Para saber si hay que introducir un carater falso en el Mentir1
        Jlie2 := Mentir1 + Mentir2; // Para saber si hay que introducir un carater falso en el Mentir2
        Jlie3 := Mentir1 + Mentir2 + Mentir3; // Para saber si hay que introducir un carater falso en el Mentir3
      end;
  end;
  if (length(IntToStr(Clave)) >= 4) or (Length(IntToStr(Clave))<=10) then // Comprobamos que no pase de diez digitos la clave
  begin
    Jcuenclave := length(IntToStr(Clave));
    SetLength(jclave, Jcuenclave); // Para asignar el tamaño del array dinamico
    for Iclave := 1 to Jcuenclave do
    begin
      jclave[Iclave] := StrToInt(Copy(IntToStr(Clave), Iclave, 1));
      // A cada parte del array su valor
    end;

    if Accion = False then // Para desencriptar     *********************************************************
    begin
      for Jcadena := 1 to length(Cadena) do // Empezamos el encriptado
      begin
        if Jcadena=(length(Cadena)) then Continue;   //El ultimo Caracter crea un caracter de mas ?? con esto lo soluciono
        if JSaltar=1 then
        begin
           Jsaltar:=0;
           Continue;
        end;
        JCaracter := Copy(Cadena, Jcadena, 1); // Cogemos un unico caracter
        JValormas := jclave[Jcontador0];
        if Valor = False then // Para valor en negativo
        begin
          JvalorCaracter := Ord(JCaracter[1]) + JValormas; // Pasamos a su valor AscII y le añadimos el Valor númerico de la clave que le pertenezca
          if JvalorCaracter > 255 then // Comprobamos que no se pase del valor mínimo ASII
          begin
            JvalorCaracter :=JvalorCaracter-255;          // La diferencia sera el nuevo valor
          end;
        end else
        begin
          JvalorCaracter := Ord(JCaracter[1]) - JValormas; // Pasamos a su valor AscII y le añadimos el Valor númerico de la clave que le pertenezca
          if JvalorCaracter < 0 then // Comprobamos que no se pase del valor mínimo ASII
          begin
            JvalorCaracter := 255 - JvalorCaracter;          // La diferencia sera el nuevo valor
          end;
        end;
        Jtexto := Jtexto + chr(JvalorCaracter);
        Jcontador0 := Jcontador0 + 1; // Sumamos para el siguiente valor de clave
        if Jcontador0 > Jcuenclave then
          Jcontador0 := 1; // Si el Jcontador0 es mayor que el numero de digitos clave lo reiniciamos
        if JLie1 = JCantCaracteres then Jsaltar:=1; // Comprobamos si hay que eliminar un caracter falso segun Mentir1
        if Jlie2 <> 0 then
        begin
          if Jlie2 = JCantCaracteres then Jsaltar:=1;// Comprobamos si hay que eliminar un caracter falso segun Mentir2
        end;
        if Jlie3 <> 0 then
        begin
          if Jlie3 = JCantCaracteres then Jsaltar:=1; // Comprobamos si hay que eliminar un caracter falso segun Mentir3
        end;
        JCantCaracteres := JCantCaracteres + 1; // Sumamos 1 a este contador
        if JCantCaracteres > Icuenta then
          JCantCaracteres := 1; // Si el contador sobrepasa el numero de caracteres de la suma de los mentir lo pone de nuevo en 1
      end;
    end   else // PAra encriptar ********************************************************
    begin // Si es enciptado
      for Jcadena := 1 to length(Cadena) do // Empezamos el encriptado
      begin
        JCaracter := Copy(Cadena, Jcadena, 1); // Cogemos un unico caracter
        JValormas := jclave[Jcontador0];
        if Valor = False then // Para valor en negativo
        begin
          JvalorCaracter := Ord(JCaracter[1]) - JValormas; // Pasamos a su valor AscII y le añadimos el Valor númerico de la clave que le pertenezca
          if JvalorCaracter < 0 then // Comprobamos que no se pase del valor mínimo ASII
          begin
            JvalorCaracter := 255 - JvalorCaracter;          // La diferencia sera el nuevo valor
          end;
        end else
        begin
          JvalorCaracter := Ord(JCaracter[1]) + JValormas; // Pasamos a su valor AscII y le añadimos el Valor númerico de la clave que le pertenezca
          if JvalorCaracter > 255 then // Comprobamos que no se pase del valor mínimo ASII
          begin
            JvalorCaracter :=JvalorCaracter - 255;          // La diferencia sera el nuevo valor
          end;
        end;
        Jtexto := Jtexto + chr(JvalorCaracter);
        Jcontador0 := Jcontador0 + 1; // Sumamos para el siguiente valor de clave
        if Jcontador0 > Jcuenclave then
          Jcontador0 := 1; // Si el Jcontador0 es mayor que el numero de digitos clave lo reiniciamos
        if JLie1 = JCantCaracteres then
          Jtexto := Jtexto + chr(Random(255)); // Comprobamos si hay que introducir un caracter falso segun Mentir1
        if Jlie2 <> 0 then
        begin
          if Jlie2 = JCantCaracteres then
            Jtexto := Jtexto + chr(Random(255)); // Comprobamos si hay que introducir un caracter falso segun Mentir2
        end;
        if Jlie3 <> 0 then
        begin
          if Jlie3 = JCantCaracteres then
            Jtexto := Jtexto + chr(Random(255)); // Comprobamos si hay que introducir un caracter falso segun Mentir3
        end;
        JCantCaracteres := JCantCaracteres + 1; // Sumamos 1 a este contador
        if JCantCaracteres > Icuenta then
          JCantCaracteres := 1; // Si el contador sobrepasa el numero de caracteres de la suma de los mentir lo pone de nuevo en 1
      end;
    end;
  end  else  ShowMessage( 'El valor de la clave no puede ser inferior a 4 ni  superar los 10 digitos, corrijalo e intentelo de nuevo');
  Result := Jtexto;
end;
var   texCadena1,            //Recogera el encriptado
      TexCadena2:String;     //Recogera el Desencriptado
      TotalCaracter: integer;//Para corregir en la salida
begin
     if Accion=true then  //Si la orden es encriptar
     begin
          while Length(Cadena)>Length(texCadena1) do   //Si La longitud de cadena es mayor que la longitud resultante
          begin   //Este while se ha puesto ya que me he encontrado que de vez en cuado no se por que no recoge todad la cadena al encriptar
            texCadena1:=JENCRIPT(Accion,Cadena,Clave,Valor,N_mentiras,Mentir1,Mentir2,Mentir3);
          end;
          texCadena2:=JENCRIPT(False,TexCadena1,Clave,Valor,N_mentiras,Mentir1,Mentir2,Mentir3);
          if TexCadena2=Cadena then Result:=texCadena1
                               else
                               begin
                                    ShowMessage('Clave no permitida, ' + #13#10  +
                                                'Puede ser que su clave no mantenga la integridad del texto,' + #13#10  +
                                                'al desencriptarlo, por lo que mantenesmos el texto original.' + #13#10  +
                                                '------------------------------------------------------------' + #13#10  +
                                                '-Texto Original-----------------------------------------------------------' + #13#10  +
                                                '['+Cadena+']'+ ' Total caracteres: '+IntToStr(Length(Cadena))+ #13#10  +
                                                '-Texto Desencriptado-----------------------------------------------------------' + #13#10  +
                                                '['+TexCadena2+']'+ ' Total caracteres: '+IntToStr(Length(Cadena))+ #13#10  +
                                                '------------------------------------------------------------' + #13#10  +
                                                'Intentelo con otra clave');
                                    Result:=Cadena;
                               end;

     end else
         begin
            TexCadena2:=JENCRIPT(Accion,Cadena,Clave,Valor,N_mentiras,Mentir1,Mentir2,Mentir3);
            TotalCaracter:=Length(TexCadena2);         //Contamo esl total de caracteres
            Result:=Copy(texCadena2,1,TotalCaracter-1); //Devolvemos el resultado menos el último caracter que es un cuadrado
         end;
end;

En cuanto tenga un rato si me acuerdo, claro, intentare acortar el código y controlar excepciones (siempre mi tarea pendiente).