6 respuestas en este tema

[Desart]

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

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;

[Rolphy Reyes]

Saludos.

A pesar de que el código tiene comentada algunas cosas, creo que debes de darnos una descripción más profunda de lo que hace la función, que persigues y que esperas para nosotros entender tu objetivo y así brindarte mejores ideas.

[felipe]

La verdad no entiendo el objetivo de algunos parámetros, hay partes de código que se pueden resumir, recuerda que una cadena string de por sí ya es un vector.

Por otra parte, la corrí y usando un punto de quiebre analicé paso a paso lo que hace el proceso de cifrar, se generan los caracteres pero no pude mostrarlos en pantalla, solo me salió el primero... no sé a que se deba 

Otra cosa, introduces caracteres falsos mediante la función random, entonces ¿cómo compruebas que la cadena introducida desifra el texto original?

Por lo demás, es un buen ejercicio algorítmico 


Saludos!

[Desart]

Bueno intentare dar una descripción detallada de lo que pretendo, los parámetros vienen ya en la cabecera una breve descripción, en cuanto a lo que pretendo, es lo siguiente, se puede encriptar/des encriptar un texto mediante un algoritmo numérico, sabiendo el valor absoluto de un valor numérico, entonces lo que pretendo es romper este sistema.

En un sistema normal, el encriptado solo depende de un número o clave de desencriptación, variable en tamaño, pero que por lo general se reduce a unos centenar de posibilidades, aquí es donde varia mi sistema ya que el primer paso, cada carácter va a variar un número de códigos ascii, según el valor de la clave a que pertenezca, repitiendo secuencial mente esta cadena.

En segundo lugar puedo hacer la búsqueda en subida o en bajada, lo que eleva las posibilidades de claves validas.

Por ultimo es sistema de caracteres falsos, viene de mi época militar en transmisiones de la marina, usábamos un sistema que te permite añadir cada x caracteres insertar un código que no se lee al descifrarlo, he intentado mejorarlo, mediante un sistema múltiple de caracteres falsos, hay que tener en cuenta, lo siguiente:

N_mentiras, nos dice cuantos sistemas de mentira vamos a introducir.

Mentir1..3 es la cantidad de caracteres que dejamos pasar antes de meter un carácter falso

O explicado de otra manera si tenemos el texto

Damían muerde al perro

Con clave 12365458, valor Positivo, N_mentiras en 2 (2 sistemas de mentiras), Mentir1 en 3 y mentir2 en 4

  seria tanto como exponerlo de la siguiente manera

Dam@ían &mue@rde &al @perr&o             

123@6545&812@3654&581@2365&4

Donde @= Mentir1 y &=Mentir2, Claro al descodificar como el tamaño del texto ha cambiado, debemos controlar donde están los caracteres falsos y eliminarlos.

De todas maneras hay que pensar que la desarrolle esta mañana, seguro que tiene bugs, y que se podrá acortar el texto, por eso quiero que la prueben y me digan o corrijan ustedes mismos.

En cuanto matemáticamente, cada valor que la hace variar (valor, Mentir..3) a parte de la clave claro, exponencial la dificultada de descifrado. ya no solo por el algoritmo numérico, sino por la creación de caracteres adicionales.

Espero haber dejado un poco mas claro el asunto.

[Desart]

Os adjunto una pequeña demos de su uso

Archivos adjuntos

•  1853_71a36af0301db50ad262cf0c94715b9fc242de87.zip   443,18KB   5 descargas

[felipe]

Os adjunto una pequeña demos de su uso

Ahora si lo pude ver funcionando ... no sé poque no me corrió bien

El asunto esta interesante, creo que sería solo cosa de optimizar el código


Saludos!

[Desart]

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

delphi

FunctionCompJenCript(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).