Hola,

Os dejo esta herramienta que acabo de hacer, es un generador de cifrados del [Enlace externo eliminado para invitados] que hice, genera nuevas tablas de modo que la herramienta genera un cifrado diferente cada vez.

A su vez, lo he modificado para que esté todo en una única función, en lugar de usar una para cifrar y otra para descifrar.



Ejemplo de Cifrado generado:

Function CifSustMetal(Texto: string; EncDec: ShortInt): string;
Const Letr: array [0..255] of byte = (
$F7,$38,$50,$68,$80,$98,$A8,$C0,$D8,$F0,$00,$21,$39,$49,$59,$71,
$91,$A9,$B9,$D1,$E1,$F1,$02,$12,$2A,$3A,$4A,$5A,$6A,$7A,$8A,$9A,
$B2,$C2,$D2,$E2,$F3,$03,$13,$23,$3B,$4B,$5B,$6B,$83,$93,$9B,$AB,
$BB,$CB,$D3,$E4,$EC,$FC,$0C,$14,$24,$34,$44,$4C,$5C,$64,$74,$7C,
$8C,$9C,$AC,$B4,$C4,$CC,$DD,$E5,$F5,$05,$0D,$1D,$25,$35,$45,$4D,
$5D,$6D,$75,$85,$8D,$9D,$A5,$B5,$C6,$CE,$DE,$E6,$F6,$06,$0E,$1E,
$2E,$3E,$46,$56,$66,$6E,$7E,$86,$96,$9E,$AE,$B7,$C7,$D7,$DF,$EF,
$FF,$07,$17,$27,$2F,$3F,$47,$57,$5F,$6F,$77,$87,$97,$9F,$B0,$B8,
$C8,$E0,$E8,$F8,$08,$10,$20,$28,$40,$48,$58,$60,$70,$78,$88,$90,
$A1,$B1,$C1,$C9,$D9,$E9,$F9,$01,$11,$19,$29,$31,$41,$51,$61,$69,
$79,$92,$A2,$AA,$BA,$CA,$DA,$EA,$F2,$0A,$1A,$22,$32,$42,$52,$62,
$72,$7B,$8B,$A3,$B3,$C3,$DB,$E3,$FB,$0B,$1B,$2B,$33,$43,$53,$63,
$84,$94,$A4,$BC,$D4,$DC,$F4,$04,$1C,$2C,$3C,$54,$65,$7D,$95,$AD,
$BD,$C5,$D5,$ED,$FD,$15,$2D,$3D,$4E,$5E,$76,$8E,$A6,$B6,$BE,$D6,
$EE,$FE,$16,$26,$36,$4F,$67,$7F,$8F,$A7,$AF,$BF,$CF,$E7,$0F,$1F,
$A0,$D0,$18,$81,$89,$99,$09,$82,$FA,$73,$EB,$6C,$55,$CD,$37,$30);
var
i, j: integer;
begin
SetLength(Result, Length(Texto));
for i:= 1 to Length(Texto) do
  if EncDec = 0 then
    begin
      Texto[i]:= chr(Letr[ord(Texto[i])]);
    end else
  if EncDec = 1 then
    begin
      for j:= 0 to 255 do
        begin
          if Texto[i] = chr(Letr[j]) then
            begin
              Texto[i]:= chr(j);
              break;
            end;
        end;
    end;
Result:= Texto;
end;

Un simple ejemplo de uso:

Parámetros de la función principal:

Function CifSustMetal(Texto: string; EncDec: ShortInt): string;

• Texto: Cadena para encriptar o desencriptar.
• EncDec: Número; 0 para encriptar y 1 para desencriptar.

procedure TForm1.Button1Click(Sender: TObject);
var
Txt: string;
begin
Txt:= 'Texto sin cifrar.';
Txt:= CifSustMetal(Txt, 0); // 0 para encriptar
showmessage(Txt);
Txt:= CifSustMetal(Txt, 1); // 1 para desencriptar
showmessage(Txt);
end;

Descarga: [Enlace externo eliminado para invitados]
Pass: udtools.net

Espero que os sea de utilidad.

Un saludo.

Como ya te dije, esta de puta madre el code tio... me gusto mucho..

Qué tal tío?! :D

Un placer leerte
Hace un par de meses hice una herramienta similar, pero para VB6. El problema que le veo a tu solución, es que a la hora de desencriptar (EncDec = 1), recorres las 256 posibilidades hasta encontrar el valor correcto por el que sustituir (en el peor de los casos). En cambio, la encriptación se realiza de forma directa (Texto:= chr(Letr[ord(Texto)]);). Por lo tanto, lo apropiado sería conseguir esta conversión directa tanto para encriptar como para desencriptar. Opté por separar ambas funciones (encriptacón y desencriptación), debido a que normalmente se usan por separado (una en el cliente, y otra en el "stub", por ejemplo), y generar dos array, uno para encriptar y otro para desencriptar, de forma que las conversiones se realicen de forma directa.

Es decir, si tienes Enc(0) = 1, sustituirá los 0 por 1, por lo que para desencriptar deberíamos tener Dec(1) = 0, que sustituirá los 1 por 0, obteniendo el valor original.

Un saludo!

Pasa una cosa compañero, y es que la forma de desencriptar se basa en el contador del bucle, es decir, al encriptar sustituye el valor directamente, pero al desencriptar es necesaria la misma tabla ya que para volver al valor original se basa en la posición en la tabla y no en la sustitución directa con un valor concreto de la tabla, si 'A' está en la posición 15, entonces A desencriptado = contador desde 0 hasta 'A', si es la posición 27 en el bucle entonces desencripta con 'desencriptado = Chr(numero de I[27 en el ejemplo])' no sé muy bien cómo explicarlo xD.

La unifiqué para poder usarla en crypter y stub, pero se puede usar por separado, aunque viene a ser lo mismo.

Un saludo compañero, gracias por comentar

No puedo editar, pero creo que sí sería posible lo que dices, reordenando la tabla completamente en la función de desencriptar, así la reconversión sería directa, aunque.. pierde un poco la gracia de usar la misma función para todo xD.

Slek, ya lo tengo amigo

Ejemplo:

Cifrar:

Function Cifrar(Texto: string): string;
const
Letr: array [0..255] of byte = (
$F7,$38,$50,$68,$80,$98,$A8,$C0,$D8,$F0,$00,$21,$39,$49,$59,$71,
$91,$A9,$B9,$D1,$E1,$F1,$02,$12,$2A,$3A,$4A,$5A,$6A,$7A,$8A,$9A,
$B2,$C2,$D2,$E2,$F3,$03,$13,$23,$3B,$4B,$5B,$6B,$83,$93,$9B,$AB,
$BB,$CB,$D3,$E4,$EC,$FC,$0C,$14,$24,$34,$44,$4C,$5C,$64,$74,$7C,
$8C,$9C,$AC,$B4,$C4,$CC,$DD,$E5,$F5,$05,$0D,$1D,$25,$35,$45,$4D,
$5D,$6D,$75,$85,$8D,$9D,$A5,$B5,$C6,$CE,$DE,$E6,$F6,$06,$0E,$1E,
$2E,$3E,$46,$56,$66,$6E,$7E,$86,$96,$9E,$AE,$B7,$C7,$D7,$DF,$EF,
$FF,$07,$17,$27,$2F,$3F,$47,$57,$5F,$6F,$77,$87,$97,$9F,$B0,$B8,
$C8,$E0,$E8,$F8,$08,$10,$20,$28,$40,$48,$58,$60,$70,$78,$88,$90,
$A1,$B1,$C1,$C9,$D9,$E9,$F9,$01,$11,$19,$29,$31,$41,$51,$61,$69,
$79,$92,$A2,$AA,$BA,$CA,$DA,$EA,$F2,$0A,$1A,$22,$32,$42,$52,$62,
$72,$7B,$8B,$A3,$B3,$C3,$DB,$E3,$FB,$0B,$1B,$2B,$33,$43,$53,$63,
$84,$94,$A4,$BC,$D4,$DC,$F4,$04,$1C,$2C,$3C,$54,$65,$7D,$95,$AD,
$BD,$C5,$D5,$ED,$FD,$15,$2D,$3D,$4E,$5E,$76,$8E,$A6,$B6,$BE,$D6,
$EE,$FE,$16,$26,$36,$4F,$67,$7F,$8F,$A7,$AF,$BF,$CF,$E7,$0F,$1F,
$A0,$D0,$18,$81,$89,$99,$09,$82,$FA,$73,$EB,$6C,$55,$CD,$37,$30);
var
i: integer;
begin
SetLength(Result, Length(Texto));
for i:= 1 to Length(Texto) do
  Texto[i]:= chr(Letr[ord(Texto[i])]);
Result:= Texto;
end;

Descifrar:

Function Descrifrar(Texto: string): string;
const
Letr: array [0..255] of byte = (
$0A,$97,$16,$25,$C7,$49,$5D,$71,$84,$F6,$A9,$B9,$36,
$4A,$5E,$EE,$85,$98,$17,$26,$37,$D5,$E2,$72,$F2,$99,
$AA,$BA,$C8,$4B,$5F,$EF,$86,$0B,$AB,$27,$38,$4C,$E3,
$73,$87,$9A,$18,$BB,$C9,$D6,$60,$74,$FF,$9B,$AC,$BC,
$39,$4D,$E4,$FE,$01,$0C,$19,$28,$CA,$D7,$61,$75,$88,
$9C,$AD,$BD,$3A,$4E,$62,$76,$89,$0D,$1A,$29,$3B,$4F,
$D8,$E5,$02,$9D,$AE,$BE,$CB,$FC,$63,$77,$8A,$0E,$1B,
$2A,$3C,$50,$D9,$78,$8B,$9E,$AF,$BF,$3D,$CC,$64,$E6,
$03,$9F,$1C,$2B,$FB,$51,$65,$79,$8C,$0F,$B0,$F9,$3E,
$52,$DA,$7A,$8D,$A0,$1D,$B1,$3F,$CD,$66,$E7,$04,$F3,
$F7,$2C,$C0,$53,$67,$7B,$8E,$F4,$1E,$B2,$40,$54,$DB,
$E8,$8F,$10,$A1,$2D,$C1,$CE,$68,$7C,$05,$F5,$1F,$2E,
$41,$55,$69,$7D,$F0,$90,$A2,$B3,$C2,$56,$DC,$E9,$06,
$11,$A3,$2F,$42,$CF,$6A,$EA,$7E,$91,$20,$B4,$43,$57,
$DD,$6B,$7F,$12,$A4,$30,$C3,$D0,$DE,$EB,$07,$92,$21,
$B5,$44,$D1,$58,$6C,$80,$93,$A5,$31,$45,$FD,$59,$EC,
$F1,$13,$22,$32,$C4,$D2,$DF,$6D,$08,$94,$A6,$B6,$C5,
$46,$5A,$6E,$81,$14,$23,$B7,$33,$47,$5B,$ED,$82,$95,
$A7,$FA,$34,$D3,$E0,$6F,$09,$15,$A8,$24,$C6,$48,$5C,
$00,$83,$96,$F8,$B8,$35,$D4,$E1,$70);
var
i: integer;
begin
SetLength(Result, Length(Texto));
for i:= 1 to Length(Texto) do
  Texto[i]:= chr(Letr[ord(Texto[i])]);
Result:= Texto;
end;

Gracias por la idea, mañana hago la versión del generador con esta nueva forma, aunque a la primera no la veo nada de malo jaja, pero así ambas formas las 'traduce' de forma directa.

Saludos

See eso era lo que decía :D
Así el código es mucho más bonito :D

De malo la otra no tiene nada, pero esta es la mejor forma de hacerlo.

Un saludo amigo!!