Форум программистов [Powered by Invision Power Board]

Цитата

А как она хранит инфу - известно?

Цитата(December @ 19.3.2006, 18:43

)

как максимально секьюрно обеспечить локальное хранение паролей?

Цитата(Vit @ 14.11.2003, 19:30

)

есть более быстрые алгоритмы - но всё равно речь идёт о многих днях машинного времени. Сейчас стандартом де-факто является MD5.

Цитата(_hunter @ 20.3.2006, 12:15

)

в том-то и проблема ICQ-клиентов -- воруют пароли из всяких .dat-файлов со страшной силой

Код


unit RegClass;

interface

uses
 SysUtils,
 Classes,
 Windows,
 MD5,
 Registry;

const
 PASS_DONT_MATCH = 1;
 ALREADY_EXISTS = 2;
 CANT_ADD = 3;
 NOT_EXISTS = 4;
 
type
 TRegClass = class
 private
  FLogins: TStringList;
  Reg: TRegistry;
  FCount: integer;
 public
  constructor Create(Key: HKEY; Section: string; CreateIfNotExists: boolean);
  destructor Destroy; override;

  property Logins: TStringList read FLogins write FLogins;
  property Count: integer read FCount write FCount;

  function AddNewUser(Login: string; Password: string; Password2: string): integer;
  function DeleteUser(Login: string): boolean;
  function PasswordMatch(Login: string; Password: string): boolean;
  procedure GetUserList;
 end;
 
implementation

constructor TRegClass.Create(Key: HKEY; Section: string; CreateIfNotExists: boolean);
begin
 Reg := TRegistry.Create;
 Reg.RootKey := Key;
 Reg.OpenKey(Section, CreateIfNotExists);
 FLogins := TStringList.Create;
end;

destructor TRegClass.Destroy;
begin
 Reg.CloseKey;
 Reg.Free;
 FLogins.Free;
end;

function TRegClass.AddNewUser(Login: string; Password: string; Password2: string): integer;
begin
 if Password <> Password2 then begin Result := 1; exit;
  end;
 if Reg.ValueExists(Login) then begin Result := 2; exit;
  end;
 try
  Reg.WriteString(Login, StrMD5(Password));
  Result := 0;
 except
  Result := 3;
 end;
end;

function TRegClass.DeleteUser(Login: string): boolean;
begin
 if not Reg.ValueExists(Login) then begin Result := false; exit;
  end;
 Result := Reg.DeleteValue(Login);
end;

function TRegClass.PasswordMatch(Login: string; Password: string): boolean;
begin
 Result := false;
 if Reg.ReadString(Login) = StrMD5(Password) then Result := true;
end;

procedure TRegClass.GetUserList;
begin
 Reg.GetValueNames(Logins);
 Count := Logins.Count;
end;

end.

Код


unit MD5;

interface

uses
    SysUtils;

const
    MD5Version         = 102;
    CopyRight : String = ' MD5 Message-Digest (c) 97-98 F. Piette V1.02 ';

{$Q-}
{$R-}

type
    TMD5Context = record
        State: array[0..3] of LongInt;
        Count: array[0..1] of LongInt;
        case Integer of
        0: (BufChar: array[0..63] of Byte);
        1: (BufLong: array[0..15] of LongInt);
    end;
    TMD5Digest = array[0..15] of Char;

procedure MD5Init(var MD5Context: TMD5Context);
procedure MD5Update(var MD5Context: TMD5Context;
                    const Data;
                    Len: Integer);
procedure MD5Transform(var Buf: array of LongInt;
                       const Data: array of LongInt);
procedure MD5UpdateBuffer(var MD5Context: TMD5Context;
                          Buffer: Pointer;
                          BufSize: Integer);
procedure MD5Final(var Digest: TMD5Digest; var MD5Context: TMD5Context);

function GetMD5(Buffer: Pointer; BufSize: Integer): string;
function StrMD5(Buffer : String): string;

implementation

const
    MaxBufSize = 16384;

type
    PMD5Buffer = ^TMD5Buffer;
    TMD5Buffer = array[0..(MaxBufSize - 1)] of Char;



{* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *}
{ MD5 initialization. Begins an MD5 operation, writing a new context.         }
procedure MD5Init(var MD5Context: TMD5Context);
begin
    FillChar(MD5Context, SizeOf(TMD5Context), #0);
    with MD5Context do begin
        { Load magic initialization constants. }
        State[0] := LongInt($67452301);
        State[1] := LongInt($EFCDAB89);
        State[2] := LongInt($98BADCFE);
        State[3] := LongInt($10325476);
    end
end;


{* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *}
{ MD5 block update operation. Continues an MD5 message-digest operation,      }
{ processing another message block, and updating the context.                 }
procedure MD5Update(
    var MD5Context: TMD5Context;            { Context                         }
    const Data;                             { Input block                     }
    Len: Integer);                          { Length of input block           }
type
    TByteArray = array[0..0] of Byte;
var
    Index: Word;
    T: LongInt;
begin
    with MD5Context do begin
        T := Count[0];
        Inc(Count[0], LongInt(Len) shl 3);
        if Count[0] < T then
            Inc(Count[1]);
        Inc(Count[1], Len shr 29);
        T := (T shr 3) and $3F;
        Index := 0;
        if T <> 0 then begin
            Index := T;
            T := 64 - T;
            if Len < T then begin
                Move(Data, BufChar[Index], Len);
                Exit;
            end;
            Move(Data, BufChar[Index], T);
            MD5Transform(State, BufLong);
            Dec(Len, T);
            Index := T;  { Wolfgang Klein, 05/06/99 }
        end;
        while Len >= 64 do begin
            Move(TByteArray(Data)[Index], BufChar, 64);
            MD5Transform(State, BufLong);
            Inc(Index, 64);
            Dec(Len, 64);
        end;
        Move(TByteArray(Data)[Index], BufChar, Len);
    end
end;


{* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *}
{ MD5 finalization. Ends an MD5 message-digest operation, writing the message }
{ digest and zeroizing the context.                                           }
procedure MD5Final(var Digest: TMD5Digest; var MD5Context: TMD5Context);
var
    Cnt : Word;
    P   : Byte;
begin
    with MD5Context do begin
        Cnt := (Count[0] shr 3) and $3F;
        P := Cnt;
        BufChar[P] := $80;
        Inc(P);
        Cnt := 64 - 1 - Cnt;
        if Cnt < 8 then begin
            FillChar(BufChar[P], Cnt, #0);
            MD5Transform(State, BufLong);
            FillChar(BufChar, 56, #0);
        end
        else
            FillChar(BufChar[P], Cnt - 8, #0);
        BufLong[14] := Count[0];
        BufLong[15] := Count[1];
        MD5Transform(State, BufLong);
        Move(State, Digest, 16)
    end;
    FillChar(MD5Context, SizeOf(TMD5Context), #0)
end;


{* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *}
{ MD5 basic transformation. Transforms state based on block.                  }
procedure MD5Transform(
    var Buf: array of LongInt;
    const Data: array of LongInt);
var
    A, B, C, D: LongInt;

    procedure Round1(var W: LongInt; X, Y, Z, Data: LongInt; S: Byte);
    begin
        Inc(W, (Z xor (X and (Y xor Z))) + Data);
        W := (W shl S) or (W shr (32 - S));
        Inc(W, X)
    end;

    procedure Round2(var W: LongInt; X, Y, Z, Data: LongInt; S: Byte);
    begin
        Inc(W, (Y xor (Z and (X xor Y))) + Data);
        W := (W shl S) or (W shr (32 - S));
        Inc(W, X)
    end;

    procedure Round3(var W: LongInt; X, Y, Z, Data: LongInt; S: Byte);
    begin
        Inc(W, (X xor Y xor Z) + Data);
        W := (W shl S) or (W shr (32 - S));
        Inc(W, X)
    end;

    procedure Round4(var W: LongInt; X, Y, Z, Data: LongInt; S: Byte);
    begin
        Inc(W, (Y xor (X or not Z)) + Data);
        W := (W shl S) or (W shr (32 - S));
        Inc(W, X)
    end;
begin
    A := Buf[0];
    B := Buf[1];
    C := Buf[2];
    D := Buf[3];

    Round1(A, B, C, D, Data[ 0] + LongInt($d76aa478),  7);
    Round1(D, A, B, C, Data[ 1] + LongInt($e8c7b756), 12);
    Round1(C, D, A, B, Data[ 2] + LongInt($242070db), 17);
    Round1(B, C, D, A, Data[ 3] + LongInt($c1bdceee), 22);
    Round1(A, B, C, D, Data[ 4] + LongInt($f57c0faf),  7);
    Round1(D, A, B, C, Data[ 5] + LongInt($4787c62a), 12);
    Round1(C, D, A, B, Data[ 6] + LongInt($a8304613), 17);
    Round1(B, C, D, A, Data[ 7] + LongInt($fd469501), 22);
    Round1(A, B, C, D, Data[ 8] + LongInt($698098d8),  7);
    Round1(D, A, B, C, Data[ 9] + LongInt($8b44f7af), 12);
    Round1(C, D, A, B, Data[10] + LongInt($ffff5bb1), 17);
    Round1(B, C, D, A, Data[11] + LongInt($895cd7be), 22);
    Round1(A, B, C, D, Data[12] + LongInt($6b901122),  7);
    Round1(D, A, B, C, Data[13] + LongInt($fd987193), 12);
    Round1(C, D, A, B, Data[14] + LongInt($a679438e), 17);
    Round1(B, C, D, A, Data[15] + LongInt($49b40821), 22);

    Round2(A, B, C, D, Data[ 1] + LongInt($f61e2562),  5);
    Round2(D, A, B, C, Data[ 6] + LongInt($c040b340),  9);
    Round2(C, D, A, B, Data[11] + LongInt($265e5a51), 14);
    Round2(B, C, D, A, Data[ 0] + LongInt($e9b6c7aa), 20);
    Round2(A, B, C, D, Data[ 5] + LongInt($d62f105d),  5);
    Round2(D, A, B, C, Data[10] + LongInt($02441453),  9);
    Round2(C, D, A, B, Data[15] + LongInt($d8a1e681), 14);
    Round2(B, C, D, A, Data[ 4] + LongInt($e7d3fbc8), 20);
    Round2(A, B, C, D, Data[ 9] + LongInt($21e1cde6),  5);
    Round2(D, A, B, C, Data[14] + LongInt($c33707d6),  9);
    Round2(C, D, A, B, Data[ 3] + LongInt($f4d50d87), 14);
    Round2(B, C, D, A, Data[ 8] + LongInt($455a14ed), 20);
    Round2(A, B, C, D, Data[13] + LongInt($a9e3e905),  5);
    Round2(D, A, B, C, Data[ 2] + LongInt($fcefa3f8),  9);
    Round2(C, D, A, B, Data[ 7] + LongInt($676f02d9), 14);
    Round2(B, C, D, A, Data[12] + LongInt($8d2a4c8a), 20);

    Round3(A, B, C, D, Data[ 5] + LongInt($fffa3942),  4);
    Round3(D, A, B, C, Data[ 8] + LongInt($8771f681), 11);
    Round3(C, D, A, B, Data[11] + LongInt($6d9d6122), 16);
    Round3(B, C, D, A, Data[14] + LongInt($fde5380c), 23);
    Round3(A, B, C, D, Data[ 1] + LongInt($a4beea44),  4);
    Round3(D, A, B, C, Data[ 4] + LongInt($4bdecfa9), 11);
    Round3(C, D, A, B, Data[ 7] + LongInt($f6bb4b60), 16);
    Round3(B, C, D, A, Data[10] + LongInt($bebfbc70), 23);
    Round3(A, B, C, D, Data[13] + LongInt($289b7ec6),  4);
    Round3(D, A, B, C, Data[ 0] + LongInt($eaa127fa), 11);
    Round3(C, D, A, B, Data[ 3] + LongInt($d4ef3085), 16);
    Round3(B, C, D, A, Data[ 6] + LongInt($04881d05), 23);
    Round3(A, B, C, D, Data[ 9] + LongInt($d9d4d039),  4);
    Round3(D, A, B, C, Data[12] + LongInt($e6db99e5), 11);
    Round3(C, D, A, B, Data[15] + LongInt($1fa27cf8), 16);
    Round3(B, C, D, A, Data[ 2] + LongInt($c4ac5665), 23);

    Round4(A, B, C, D, Data[ 0] + LongInt($f4292244),  6);
    Round4(D, A, B, C, Data[ 7] + LongInt($432aff97), 10);
    Round4(C, D, A, B, Data[14] + LongInt($ab9423a7), 15);
    Round4(B, C, D, A, Data[ 5] + LongInt($fc93a039), 21);
    Round4(A, B, C, D, Data[12] + LongInt($655b59c3),  6);
    Round4(D, A, B, C, Data[ 3] + LongInt($8f0ccc92), 10);
    Round4(C, D, A, B, Data[10] + LongInt($ffeff47d), 15);
    Round4(B, C, D, A, Data[ 1] + LongInt($85845dd1), 21);
    Round4(A, B, C, D, Data[ 8] + LongInt($6fa87e4f),  6);
    Round4(D, A, B, C, Data[15] + LongInt($fe2ce6e0), 10);
    Round4(C, D, A, B, Data[ 6] + LongInt($a3014314), 15);
    Round4(B, C, D, A, Data[13] + LongInt($4e0811a1), 21);
    Round4(A, B, C, D, Data[ 4] + LongInt($f7537e82),  6);
    Round4(D, A, B, C, Data[11] + LongInt($bd3af235), 10);
    Round4(C, D, A, B, Data[ 2] + LongInt($2ad7d2bb), 15);
    Round4(B, C, D, A, Data[ 9] + LongInt($eb86d391), 21);

    Inc(Buf[0], A);
    Inc(Buf[1], B);
    Inc(Buf[2], C);
    Inc(Buf[3], D);
end;


{* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *}
procedure MD5UpdateBuffer(
    var MD5Context: TMD5Context;
    Buffer: Pointer;
    BufSize: Integer);
var
    BufTmp : PMD5Buffer;
    BufPtr : PChar;
    Bytes  : Word;
begin
    New(BufTmp);
    BufPtr := Buffer;
    try
        repeat
            if BufSize > MaxBufSize then
                Bytes := MaxBufSize
            else
                Bytes := BufSize;
            Move(BufPtr^, BufTmp^, Bytes);
            Inc(BufPtr, Bytes);
            Dec(BufSize, Bytes);
            if Bytes > 0 then
                MD5Update(MD5Context, BufTmp^, Bytes);
        until Bytes < MaxBufSize;
    finally
        Dispose(BufTmp);
    end;
end;


{* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *}
function GetMD5(Buffer: Pointer; BufSize: Integer): string;
var
    I          : Integer;
    MD5Digest  : TMD5Digest;
    MD5Context : TMD5Context;
begin
    for I := 0 to 15 do
        Byte(MD5Digest[I]) := I + 1;
    MD5Init(MD5Context);
    MD5UpdateBuffer(MD5Context, Buffer, BufSize);
    MD5Final(MD5Digest, MD5Context);
    Result := '';
    for I := 0 to 15 do
        Result := Result + IntToHex(Byte(MD5Digest[I]), 2);
end;


{* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *}
function StrMD5(Buffer : String): string;
begin
    Result := GetMD5(@Buffer[1], Length(Buffer));
end;


{* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *}

end.

Код


function DebuggerPresent: boolean;  
type  
  TDebugProc = function: boolean; stdcall;  
var  
  Kernel32: HMODULE;  
  DebugProc: TDebugProc;  
begin  
  Result := False;  
  Kernel32 := GetModuleHandle('kernel32.dll');  
  if Kernel32 <> 0 then  
  begin  
    @DebugProc := GetProcAddress(Kernel32, 'IsDebuggerPresent');  
    if Assigned(DebugProc) then  
      Result := DebugProc;
  end;  
end;

Код


if DebuggerPresent then  
  ShowMessage('debugging') //здесь можно вопще комп выключать, чтоб не мог хакер найти корявку 
else  
  ShowMessage('NOT debugging');

Код

interface

uses Windows, SysUtils;

type
  HCRYPTPROV  = ULONG;
  HCRYPTKEY   = ULONG;

  TPassSaver = class
  private
    hProv: HCRYPTPROV;   // криптопровайдер
    hSKey: HCRYPTKEY;    // сессионный ключ
  public
    constructor Create(pass: string);
    {* конструктор }
    destructor Destroy; override;
    {* деструктор }
    function HideStr(s: string): string;
    {* зашифровать строку }
    function ShowStr(s: string): string;
    {* расшифровать строку }
  end;

implementation

const
  ADVAPI32    = 'advapi32.dll';
  PROV_RSA_FULL    = 1;
  CRYPT_VERIFYCONTEXT = $F0000000;
  CALG_RC4         = ((3 shl 13) or (4 shl 9) or 1);
  CALG_RC2         = ((3 shl 13) or (3 shl 9) or 2);
  CALG_SHA         = ((4 shl 13) or 0 or 4);

Type
  ALG_ID = ULONG;
  PHCRYPTPROV = ^HCRYPTPROV;
  PHCRYPTKEY  = ^HCRYPTKEY;
  LPAWSTR = PWideChar;
  HCRYPTHASH  = ULONG;
  PHCRYPTHASH = ^HCRYPTHASH;
function CryptReleaseContext(hProv:HCRYPTPROV;dwFlags:DWORD):BOOL;stdcall;external ADVAPI32 name 'CryptReleaseContext';
function CryptAcquireContext(Prov:PHCRYPTPROV;Container:LPAWSTR;Provider:LPAWSTR;ProvType:DWORD;Flags:DWORD):BOOL;stdcall;external ADVAPI32 name 'CryptAcquireContextW';
function CryptEncrypt(Key:HCRYPTKEY;Hash:HCRYPTHASH;Final:BOOL;Flags:DWORD;Data:PBYTE;Len:PDWORD;BufLen:DWORD):BOOL;stdcall;external ADVAPI32 name 'CryptEncrypt';
function CryptDecrypt(Key:HCRYPTKEY;Hash:HCRYPTHASH;Final:BOOL;Flags:DWORD;Data:PBYTE;Len:PDWORD):BOOL;stdcall;external ADVAPI32 name 'CryptDecrypt';
function CryptCreateHash(Prov:HCRYPTPROV;Algid:ALG_ID;Key:HCRYPTKEY;Flags:LongInt;Hash:PHCRYPTHASH):BOOL;stdcall;external ADVAPI32 name 'CryptCreateHash';
function CryptHashData(Hash:HCRYPTHASH;Data:PBYTE;DataLen :LongInt;Flags:LongInt):BOOL;stdcall;external ADVAPI32 name 'CryptHashData';
function CryptDeriveKey(Prov:HCRYPTPROV;Algid:ALG_ID;BaseData:HCRYPTHASH;Flags:LongInt;Key:PHCRYPTKEY) :BOOL;stdcall;external ADVAPI32 name 'CryptDeriveKey';
function CryptDestroyHash(hHash :HCRYPTHASH) :BOOL;stdcall;external ADVAPI32 name 'CryptDestroyHash';

constructor TPassSaver.Create(pass: string);
var
  hash: HCRYPTHASH;
begin
  inherited Create;
  CryptAcquireContext(@hProv, nil, nil, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
  CryptCreateHash(hProv, CALG_SHA, 0, 0, @hash);
  CryptHashData(hash, @pass[1], length(pass), 0);
  // Если в следующей строке заменить RC4 на RC2, то будет блочное шифрование
  // оно лучше тем, что в закрытом варианте кол-во символов неочевидно
  CryptDeriveKey(hProv, CALG_RC4, hash, 0, @hSKey);
  CryptDestroyHash(hash);
end;

destructor TPassSaver.Destroy;
begin
  CryptReleaseContext(hProv, 0);
  inherited;
end;

function StringToHex(s: string): string;
var
  i: integer;
begin
  result := '';
  for i := 1 to Length(s) do
    result := result + IntToHex(ord(s[i]), 2);
end;

function HexToString(s: string): string;
var
  i: integer;
begin
  result := '';
  for i := 1 to Length(s) div 2 do
    try result := result + chr(StrToInt('$' + copy(s, i*2-1, 2)));
    except result := result + '?'; end;
end;

function TPassSaver.HideStr(s: string): string;
var
  p:  PByte;
  sz: dword;
begin
  sz := Length(s);
  GetMem(p, sz + 8); move(s[1], p^, sz);
  if CryptEncrypt(hSKey, 0, true, 0, p, @sz, sz + 8) then
  begin
    SetLength(result, sz);
    move(p^, result[1], sz);
    result := StringToHex(result);
  end else result := s;
  FreeMem(p);
end;

function TPassSaver.ShowStr(s: string): string;
var
  p:  PByte;
  sz: dword;
begin
  s := HexToString(s);
  sz := Length(s);
  GetMem(p, sz); move(s[1], p^, sz);
  if CryptDecrypt(hSKey, 0, true, 0, p, @sz) then
  begin
    SetLength(result, sz);
    move(p^, result[1], sz);
  end else result := s;
  FreeMem(p);
end;

end.

Код

var
  pass, crypt: string;
  ps:  TPassSaver;
begin
  pass := 'MySecretPassword';
  ps := TPassSaver.Create('4E600974-653A-4B1D-9DD3-F1CAC3001F7C'); // ключ - любая строка
  crypt := ps.HideStr(pass); // шифруем

  // где-нить сохраняем
  
  // и наоборот

  pass := ps.ShowStr(crypt); // декодируем
  ps.Free;
end;

Код


type
  TForm1 = class(TForm)
    Edit1: TEdit;
    Edit2: TEdit;
    Button1: TButton;
    Button2: TButton;
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;
  ps:    TPassSaver;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  ps := TPassSaver.Create('460180F1-A607-4729-BE83-A53297851AC4');
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  ps.Free;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  Edit2.Text := ps.HideStr(Edit1.Text);
  Edit1.Text := '';
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  Edit1.Text := ps.ShowStr(Edit2.Text)
end;

end.

Цитата(RAdmin @ 21.3.2006, 13:42

)

етсь мнение, что лутше всего вместо хранения хэша хранить хэш хэша, что обязательно поставит в тупичёк взломщика.