Newsgroup: it.comp.lang.delphi
Titolo: Conversioni e crittazione

C'č qualcuno che mi potrebbe aiutare?
Voglio fare in modo che la scritta (Es. Lorenzo) venga convertita in una
sfilza di numeri e lettere apparentemente senza significato, non č che
potreste scrivermi il codice contenente anche la formula per riconvertire la
sfilza di caratteri nella stringa di partenza?
Un grazie anticipato.


Eccolo qua.
Credo ci sia tutto altrimenti riscrivi.
unit uCripta;
interface
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, Menus;
type
  TfCripta = class(TForm)
    bCri : TButton ;
    lNoCri : TLabel ; eNCr : TEdit ;
    lCri : TLabel ; eCri : TEdit ;
    procedure FormCreate(Sender: TObject);
    procedure bCriClick(Sender: TObject);
    Function Cripta (s : String ): String ;
    Function Decripta (s : String ): String ;
  private
    c, d : Array [0..99] of String ;
    { Private declarations }
  public
    { Public declarations }
  end;
var
  fCripta: TfCripta;
implementation
{$R *.DFM}
procedure TfCripta.FormCreate(Sender: TObject);
begin
  c[0] := 'A' ; d[0] := 'M' ;
  c[1] := 'B' ; d[1] := 'b' ;
  c[2] := 'C' ; d[2] := '<' ;
  c[3] := 'D' ; d[3] := 'R' ;
  c[4] := 'E' ; d[4] := 'B' ;
  c[5] := 'F' ; d[5] := 'p' ;
  c[6] := 'G' ; d[6] := '@' ;
  c[7] := 'H' ; d[7] := 'k' ;
  c[8] := 'I' ; d[8] := 'W' ;
  c[9] := 'J' ; d[9] := '1' ;
  c[10] := 'K' ; d[10] := '8' ;
  c[11] := 'L' ; d[11] := 'S' ;
  c[12] := 'M' ; d[12] := ')' ;
  c[13] := 'N' ; d[13] := '§' ;
  c[14] := 'O' ; d[14] := ',' ;
  c[15] := 'P' ; d[15] := '2' ;
  c[16] := 'Q' ; d[16] := '%' ;
  c[17] := 'R' ; d[17] := '"' ;
  c[18] := 'S' ; d[18] := '5' ;
  c[19] := 'T' ; d[19] := 'G' ;
  c[20] := 'U' ; d[20] := 'g' ;
  c[21] := 'V' ; d[21] := 'l' ;
  c[22] := 'W' ; d[22] := 'n' ;
  c[23] := 'X' ; d[23] := 'Z' ;
  c[24] := 'Y' ; d[24] := 'U' ;
  c[25] := 'Z' ; d[25] := '4' ;
  c[26] := 'a' ; d[26] := 'J' ;
  c[27] := 'b' ; d[27] := 'Y' ;
  c[28] := 'c' ; d[28] := ' ' ;
  c[29] := 'd' ; d[29] := '>' ;
  c[30] := 'e' ; d[30] := 'd' ;
  c[31] := 'f' ; d[31] := '''' ;
  c[32] := 'g' ; d[32] := 'K' ;
  c[33] := 'h' ; d[33] := 'x' ;
  c[34] := 'i' ; d[34] := '=' ;
  c[35] := 'j' ; d[35] := '\' ;
  c[36] := 'k' ; d[36] := 'o' ;
  c[37] := 'l' ; d[37] := 'y' ;
  c[38] := 'm' ; d[38] := 'H' ;
  c[39] := 'n' ; d[39] := 'à' ;
  c[40] := 'o' ; d[40] := 'E' ;
  c[41] := 'p' ; d[41] := 'ì' ;
  c[42] := 'q' ; d[42] := ';' ;
  c[43] := 'r' ; d[43] := '{' ;
  c[44] := 's' ; d[44] := 'P' ;
  c[45] := 't' ; d[45] := 'ù' ;
  c[46] := 'u' ; d[46] := 'C' ;
  c[47] := 'v' ; d[47] := 'N' ;
  c[48] := 'w' ; d[48] := '$' ;
  c[49] := 'x' ; d[49] := 'D' ;
  c[50] := 'y' ; d[50] := 'u' ;
  c[51] := 'z' ; d[51] := '!' ;
  c[52] := '0' ; d[52] := '/' ;
  c[53] := '1' ; d[53] := 'w' ;
  c[54] := '2' ; d[54] := '&' ;
  c[55] := '3' ; d[55] := 't' ;
  c[56] := '4' ; d[56] := 'h' ;
  c[57] := '5' ; d[57] := 'z' ;
  c[58] := '6' ; d[58] := 'm' ;
  c[59] := '7' ; d[59] := ':' ;
  c[60] := '8' ; d[60] := ']' ;
  c[61] := '9' ; d[61] := 'é' ;
  c[62] := ' ' ; d[62] := 'j' ;
  c[63] := '+' ; d[63] := 'Q' ;
  c[64] := '-' ; d[64] := '+' ;
  c[65] := '*' ; d[65] := 'q' ;
  c[66] := '/' ; d[66] := '7' ;
  c[67] := '=' ; d[67] := '[' ;
  c[68] := '<' ; d[68] := 's' ;
  c[69] := '>' ; d[69] := '_' ;
  c[70] := '(' ; d[70] := 'O' ;
  c[71] := ')' ; d[71] := '£' ;
  c[72] := '[' ; d[72] := 'c' ;
  c[73] := ']' ; d[73] := '}' ;
  c[74] := '{' ; d[74] := 'V' ;
  c[75] := '}' ; d[75] := 'v' ;
  c[76] := 'à' ; d[76] := '*' ;
  c[77] := 'è' ; d[77] := 'I' ;
  c[78] := 'ì' ; d[78] := 'è' ;
  c[79] := 'ò' ; d[79] := 'a' ;
  c[80] := 'ù' ; d[80] := '^' ;
  c[81] := 'é' ; d[81] := 'f' ;
  c[82] := '_' ; d[82] := '#' ;
  c[83] := '|' ; d[83] := '9' ;
  c[84] := '\' ; d[84] := '3' ;
  c[85] := '£' ; d[85] := '6' ;
  c[86] := '$' ; d[86] := 'F' ;
  c[87] := '%' ; d[87] := '0' ;
  c[88] := '&' ; d[88] := 'L' ;
  c[89] := '^' ; d[89] := '-' ;
  c[90] := '#' ; d[90] := 'r' ;
  c[91] := '@' ; d[91] := 'A' ;
  c[92] := '.' ; d[92] := 'T' ;
  c[93] := ',' ; d[93] := '|' ;
  c[94] := ':' ; d[94] := 'e' ;
  c[95] := ';' ; d[95] := '.' ;
  c[96] := '?' ; d[96] := 'ò' ;
  c[97] := '!' ; d[97] := '?' ;
  c[98] := '"' ; d[98] := 'i' ;
  c[99] := '''' ; d[99] := '(' ;
End ;
// _______________________________________________________________________
Function TfCripta.Cripta ( s : String ) : String ;
Var
  s1, sc : String ;
  i, j, l : Integer ;
Begin
  sc := '' ;
  l := Length (s) ;
  For i:=1 to l Do
    Begin
      s1 := Copy (s, i, 1 ) ;
      For j:=0 to 98 Do
        If s1 = c[j] Then
          sc := sc + d[j] ;
    End ;
  Result := sc ;
End ;
// _______________________________________________________________________
Function TfCripta.Decripta ( s : String ) : String ;
Var
  s1, sd : String ;
  i, j, l : Integer ;
Begin
  sd := '' ;
  l := Length (s) ;
  For i:=1 to l Do
    Begin
      s1 := Copy (s, i, 1 ) ;
      For j:=0 to 98 Do
        If s1 = d[j] Then
          sd := sd + c[j] ;
    End ;
  Result := sd ;
End ;
// _____________________________________________________________________
Procedure TfCripta.bCriClick(Sender: TObject);
Var
  s, sc, sd : String ;
Begin
  s := eNCr.Text ;
  sc := Cripta ( s ) ;
  eCri.Text := sc ;
  sd := Decripta ( sc ) ;
  If AnsiCompareStr ( s, sd ) = 0 Then
    ShowMessage ( 'c r i p t a z i o n e r i u s c i t a' )
  Else
    ShowMessage ( 'c r i p t a z i o n e n o n r i u s c i t a' ) ;
End ;
END.
--------------------------------
Inviato via 
http://usenet.libero.it


Il processo deve essere reversibile. nel caso più semplice una volta
convertito il carattere in codice ascii, aggiungi un valore K ad esempio
determinato dalla funzione: K= 2x+1  (dove x è il codice ascii del carattere
che stai esaminando) naturalmente modulo 255 che corrisponde al nuovo
carattere.
Per ottenere il codice ascii iniziale è sufficiente che operi al contrario,
ci sono poi sistemi più sofisticati e sicuri, ma questo come inizio va più
che bene.
Cooper
PS: La funzione può essere una a tua scelta ovviamente.

sfilza di caratteri nella stringa di partenza?
Le funzioni seguenti allungano la stringa risultante, ma hanno il
vantaggio di poter essere vincolate a una password specifica.
function Crypt(const S, Pwd: String): String;
var
  I, J: Integer;
begin
  Result := '';
  J := 1;
  for I := 1 to Length(S) do
  begin
    Result := Result + IntToHex(Ord(S[I]) xor Ord(Pwd[J]), 2);
    Inc(J);
    if J > Length(Pwd) then J := 1;
  end;
end;
function Decrypt(const S, Pwd: String): String;
var
  I, J: Integer;
begin
  Result := '';
  J := 1;
  I := 1;
  repeat
    Result := Result + Chr(StrToInt('$'+Copy(S, I, 2)) xor
Ord(Pwd[J]));
    Inc(I, 2);
    Inc(J);
    if J > Length(Pwd) then J := 1;
  until I > Length(S);
end;
procedure TForm1.Button1Click(Sender: TObject);
begin
  ShowMessage(Crypt('Lorenzo', 'MickeyMouse'));
end;

 >sfilza di numeri e lettere apparentemente senza significato, non č che


troppo facilmente reversibili da chiunque :)
Con questo metodo, dubito molto che tu possa ottenere il valore di
partenza, se non conosci la "chiave" o perlomeno ti ci vorrebbe
moltissimo tempo.  Perché questo è il problema, il tempo.

 sfilza di numeri e lettere apparentemente senza significato, non è che
