Форум: "Основная";
Текущий архив: 2005.01.30;
Скачать: [xml.tar.bz2];
ВнизШифрование паролей Найти похожие ветки
← →
ShimON © (2005-01-18 13:59) [0]Здравствуйте, не могли бы вы мне подсказать какие не самые сложные способы есть. Мне в форму вводят пароль, который потом надо будет сохранить, хотелось бы зашифровать, а то кто знает... Нет ли возможности в Delphi реализовать MD5??? Заранее спасибо за ответ
← →
kaZaNoVa © (2005-01-18 14:04) [1]ShimON © (18.01.05 13:59)
> Нет ли возможности в Delphi реализовать MD5??? Заранее
> спасибо за ответunit DCPmd5;
interface
uses
Classes, Sysutils, DCPcrypt2, DCPconst;
type
TDCP_md5= class(TDCP_hash)
protected
LenHi, LenLo: longword;
Index: DWord;
CurrentHash: array[0..3] of DWord;
HashBuffer: array[0..63] of byte;
procedure Compress;
public
class function GetId: integer; override;
class function GetAlgorithm: string; override;
class function GetHashSize: integer; override;
class function SelfTest: boolean; override;
procedure Init; override;
procedure Burn; override;
procedure Update(const Buffer; Size: longword); override;
procedure Final(var Digest); override;
end;
{******************************************************************************}
{******************************************************************************}
implementation
{$R-}{$Q-}
function LRot32(a, b: longword): longword;
begin
Result:= (a shl b) or (a shr (32-b));
end;
procedure TDCP_md5.Compress;
var
Data: array[0..15] of dword;
A, B, C, D: dword;
begin
Move(HashBuffer,Data,Sizeof(Data));
A:= CurrentHash[0];
B:= CurrentHash[1];
C:= CurrentHash[2];
D:= CurrentHash[3];
A:= B + LRot32(A + (D xor (B and (C xor D))) + Data[ 0] + $d76aa478,7);
D:= A + LRot32(D + (C xor (A and (B xor C))) + Data[ 1] + $e8c7b756,12);
C:= D + LRot32(C + (B xor (D and (A xor B))) + Data[ 2] + $242070db,17);
B:= C + LRot32(B + (A xor (C and (D xor A))) + Data[ 3] + $c1bdceee,22);
A:= B + LRot32(A + (D xor (B and (C xor D))) + Data[ 4] + $f57c0faf,7);
D:= A + LRot32(D + (C xor (A and (B xor C))) + Data[ 5] + $4787c62a,12);
C:= D + LRot32(C + (B xor (D and (A xor B))) + Data[ 6] + $a8304613,17);
B:= C + LRot32(B + (A xor (C and (D xor A))) + Data[ 7] + $fd469501,22);
A:= B + LRot32(A + (D xor (B and (C xor D))) + Data[ 8] + $698098d8,7);
D:= A + LRot32(D + (C xor (A and (B xor C))) + Data[ 9] + $8b44f7af,12);
C:= D + LRot32(C + (B xor (D and (A xor B))) + Data[10] + $ffff5bb1,17);
B:= C + LRot32(B + (A xor (C and (D xor A))) + Data[11] + $895cd7be,22);
A:= B + LRot32(A + (D xor (B and (C xor D))) + Data[12] + $6b901122,7);
D:= A + LRot32(D + (C xor (A and (B xor C))) + Data[13] + $fd987193,12);
C:= D + LRot32(C + (B xor (D and (A xor B))) + Data[14] + $a679438e,17);
B:= C + LRot32(B + (A xor (C and (D xor A))) + Data[15] + $49b40821,22);
A:= B + LRot32(A + (C xor (D and (B xor C))) + Data[ 1] + $f61e2562,5);
D:= A + LRot32(D + (B xor (C and (A xor B))) + Data[ 6] + $c040b340,9);
C:= D + LRot32(C + (A xor (B and (D xor A))) + Data[11] + $265e5a51,14);
B:= C + LRot32(B + (D xor (A and (C xor D))) + Data[ 0] + $e9b6c7aa,20);
A:= B + LRot32(A + (C xor (D and (B xor C))) + Data[ 5] + $d62f105d,5);
D:= A + LRot32(D + (B xor (C and (A xor B))) + Data[10] + $02441453,9);
C:= D + LRot32(C + (A xor (B and (D xor A))) + Data[15] + $d8a1e681,14);
B:= C + LRot32(B + (D xor (A and (C xor D))) + Data[ 4] + $e7d3fbc8,20);
A:= B + LRot32(A + (C xor (D and (B xor C))) + Data[ 9] + $21e1cde6,5);
D:= A + LRot32(D + (B xor (C and (A xor B))) + Data[14] + $c33707d6,9);
C:= D + LRot32(C + (A xor (B and (D xor A))) + Data[ 3] + $f4d50d87,14);
B:= C + LRot32(B + (D xor (A and (C xor D))) + Data[ 8] + $455a14ed,20);
A:= B + LRot32(A + (C xor (D and (B xor C))) + Data[13] + $a9e3e905,5);
D:= A + LRot32(D + (B xor (C and (A xor B))) + Data[ 2] + $fcefa3f8,9);
C:= D + LRot32(C + (A xor (B and (D xor A))) + Data[ 7] + $676f02d9,14);
B:= C + LRot32(B + (D xor (A and (C xor D))) + Data[12] + $8d2a4c8a,20);
A:= B + LRot32(A + (B xor C xor D) + Data[ 5] + $fffa3942,4);
D:= A + LRot32(D + (A xor B xor C) + Data[ 8] + $8771f681,11);
C:= D + LRot32(C + (D xor A xor B) + Data[11] + $6d9d6122,16);
B:= C + LRot32(B + (C xor D xor A) + Data[14] + $fde5380c,23);
A:= B + LRot32(A + (B xor C xor D) + Data[ 1] + $a4beea44,4);
D:= A + LRot32(D + (A xor B xor C) + Data[ 4] + $4bdecfa9,11);
C:= D + LRot32(C + (D xor A xor B) + Data[ 7] + $f6bb4b60,16);
B:= C + LRot32(B + (C xor D xor A) + Data[10] + $bebfbc70,23);
A:= B + LRot32(A + (B xor C xor D) + Data[13] + $289b7ec6,4);
D:= A + LRot32(D + (A xor B xor C) + Data[ 0] + $eaa127fa,11);
C:= D + LRot32(C + (D xor A xor B) + Data[ 3] + $d4ef3085,16);
B:= C + LRot32(B + (C xor D xor A) + Data[ 6] + $04881d05,23);
A:= B + LRot32(A + (B xor C xor D) + Data[ 9] + $d9d4d039,4);
D:= A + LRot32(D + (A xor B xor C) + Data[12] + $e6db99e5,11);
C:= D + LRot32(C + (D xor A xor B) + Data[15] + $1fa27cf8,16);
B:= C + LRot32(B + (C xor D xor A) + Data[ 2] + $c4ac5665,23);
A:= B + LRot32(A + (C xor (B or (not D))) + Data[ 0] + $f4292244,6);
D:= A + LRot32(D + (B xor (A or (not C))) + Data[ 7] + $432aff97,10);
C:= D + LRot32(C + (A xor (D or (not B))) + Data[14] + $ab9423a7,15);
B:= C + LRot32(B + (D xor (C or (not A))) + Data[ 5] + $fc93a039,21);
A:= B + LRot32(A + (C xor (B or (not D))) + Data[12] + $655b59c3,6);
D:= A + LRot32(D + (B xor (A or (not C))) + Data[ 3] + $8f0ccc92,10);
C:= D + LRot32(C + (A xor (D or (not B))) + Data[10] + $ffeff47d,15);
B:= C + LRot32(B + (D xor (C or (not A))) + Data[ 1] + $85845dd1,21);
A:= B + LRot32(A + (C xor (B or (not D))) + Data[ 8] + $6fa87e4f,6);
D:= A + LRot32(D + (B xor (A or (not C))) + Data[15] + $fe2ce6e0,10);
C:= D + LRot32(C + (A xor (D or (not B))) + Data[ 6] + $a3014314,15);
B:= C + LRot32(B + (D xor (C or (not A))) + Data[13] + $4e0811a1,21);
A:= B + LRot32(A + (C xor (B or (not D))) + Data[ 4] + $f7537e82,6);
D:= A + LRot32(D + (B xor (A or (not C))) + Data[11] + $bd3af235,10);
C:= D + LRot32(C + (A xor (D or (not B))) + Data[ 2] + $2ad7d2bb,15);
B:= C + LRot32(B + (D xor (C or (not A))) + Data[ 9] + $eb86d391,21);
Inc(CurrentHash[0],A);
Inc(CurrentHash[1],B);
Inc(CurrentHash[2],C);
Inc(CurrentHash[3],D);
Index:= 0;
FillChar(HashBuffer,Sizeof(HashBuffer),0);
end;
← →
kaZaNoVa © (2005-01-18 14:04) [2]
class function TDCP_md5.GetHashSize: integer;
begin
Result:= 128;
end;
class function TDCP_md5.GetId: integer;
begin
Result:= DCP_md5;
end;
class function TDCP_md5.GetAlgorithm: string;
begin
Result:= "MD5";
end;
class function TDCP_md5.SelfTest: boolean;
const
Test1Out: array[0..15] of byte=
($90,$01,$50,$98,$3c,$d2,$4f,$b0,$d6,$96,$3f,$7d,$28,$e1,$7f,$72);
Test2Out: array[0..15] of byte=
($c3,$fc,$d3,$d7,$61,$92,$e4,$00,$7d,$fb,$49,$6c,$ca,$67,$e1,$3b);
var
TestHash: TDCP_md5;
TestOut: array[0..19] of byte;
begin
TestHash:= TDCP_md5.Create(nil);
TestHash.Init;
TestHash.UpdateStr("abc");
TestHash.Final(TestOut);
Result:= CompareMem(@TestOut,@Test1Out,Sizeof(Test1Out));
TestHash.Init;
TestHash.UpdateStr("abcdefghijklmnopqrstuvwxyz");
TestHash.Final(TestOut);
Result:= CompareMem(@TestOut,@Test2Out,Sizeof(Test2Out)) and Result;
TestHash.Free;
end;
procedure TDCP_md5.Init;
begin
Burn;
CurrentHash[0]:= $67452301;
CurrentHash[1]:= $efcdab89;
CurrentHash[2]:= $98badcfe;
CurrentHash[3]:= $10325476;
fInitialized:= true;
end;
procedure TDCP_md5.Burn;
begin
LenHi:= 0; LenLo:= 0;
Index:= 0;
FillChar(HashBuffer,Sizeof(HashBuffer),0);
FillChar(CurrentHash,Sizeof(CurrentHash),0);
fInitialized:= false;
end;
procedure TDCP_md5.Update(const Buffer; Size: longword);
var
PBuf: ^byte;
begin
if not fInitialized then
raise EDCP_hash.Create("Hash not initialized");
Inc(LenHi,Size shr 29);
Inc(LenLo,Size*8);
if LenLo< (Size*8) then
Inc(LenHi);
PBuf:= @Buffer;
while Size> 0 do
begin
if (Sizeof(HashBuffer)-Index)<= DWord(Size) then
begin
Move(PBuf^,HashBuffer[Index],Sizeof(HashBuffer)-Index);
Dec(Size,Sizeof(HashBuffer)-Index);
Inc(PBuf,Sizeof(HashBuffer)-Index);
Compress;
end
else
begin
Move(PBuf^,HashBuffer[Index],Size);
Inc(Index,Size);
Size:= 0;
end;
end;
end;
procedure TDCP_md5.Final(var Digest);
begin
if not fInitialized then
raise EDCP_hash.Create("Hash not initialized");
HashBuffer[Index]:= $80;
if Index>= 56 then
Compress;
PDWord(@HashBuffer[56])^:= LenLo;
PDWord(@HashBuffer[60])^:= LenHi;
Compress;
Move(CurrentHash,Digest,Sizeof(CurrentHash));
Burn;
end;
end.
← →
kaZaNoVa © (2005-01-18 14:06) [3]
unit DCPconst;
interface
{******************************************************************************}
const
{ Component registration }
DCPcipherpage = "DCPciphers";
DCPhashpage = "DCPhashes";
{ ID values }
DCP_rc2 = 1;
DCP_sha1 = 2;
DCP_rc5 = 3;
DCP_rc6 = 4;
DCP_blowfish = 5;
DCP_twofish = 6;
DCP_cast128 = 7;
DCP_gost = 8;
DCP_rijndael = 9;
DCP_ripemd160 = 10;
DCP_misty1 = 11;
DCP_idea = 12;
DCP_mars = 13;
DCP_haval = 14;
DCP_cast256 = 15;
DCP_md5 = 16;
DCP_md4 = 17;
DCP_tiger = 18;
DCP_rc4 = 19;
DCP_ice = 20;
DCP_thinice = 21;
DCP_ice2 = 22;
DCP_des = 23;
DCP_3des = 24;
DCP_tea = 25;
DCP_serpent = 26;
DCP_ripemd128 = 27;
DCP_sha256 = 28;
DCP_sha384 = 29;
DCP_sha512 = 30;
{******************************************************************************}
{******************************************************************************}
implementation
end.
← →
kaZaNoVa © (2005-01-18 14:07) [4]
unit DCPcrypt2;
interface
uses
Classes, Sysutils, DCPconst, DCPbase64;
//{$DEFINE DCP1COMPAT} { DCPcrypt v1.31 compatiblity mode - see documentation }
{******************************************************************************}
{ A few predefined types to help out }
type
Pbyte= ^byte;
Pword= ^word;
Pdword= ^dword;
Pint64= ^int64;
dword= longword;
Pwordarray= ^Twordarray;
Twordarray= array[0..19383] of word;
Pdwordarray= ^Tdwordarray;
Tdwordarray= array[0..8191] of dword;
{******************************************************************************}
{ The base class from which all hash algorithms are to be derived }
type
EDCP_hash= class(Exception);
TDCP_hash= class(TComponent)
protected
fInitialized: boolean; { Whether or not the algorithm has been initialized }
procedure DeadInt(Value: integer); { Knudge to display vars in the object inspector }
procedure DeadStr(Value: string); { Knudge to display vars in the object inspector }
public
property Initialized: boolean
read fInitialized;
class function GetId: integer; virtual; abstract;
{ Get the algorithm id }
class function GetAlgorithm: string; virtual; abstract;
{ Get the algorithm name }
class function GetHashSize: integer; virtual; abstract;
{ Get the size of the digest produced - in bits }
class function SelfTest: boolean; virtual; abstract;
{ Tests the implementation with several test vectors }
procedure Init; virtual; abstract;
{ Initialize the hash algorithm }
procedure Final(var Digest); virtual; abstract;
{ Create the final digest and clear the stored information.
The size of the Digest var must be at least equal to the hash size }
procedure Burn; virtual; abstract;
{ Clear any stored information with out creating the final digest }
procedure Update(const Buffer; Size: longword); virtual; abstract;
{ Update the hash buffer with Size bytes of data from Buffer }
procedure UpdateStream(Stream: TStream; Size: longword); overload;
{ Update the hash buffer with Size bytes of data from the stream }
procedure UpdateStream(Stream: TStream; Size: longword; BufferSize: longword); overload;
{ RM-Modification: overloaded function that allows to select buffer size }
procedure UpdateStr(const Str: string);
{ Update the hash buffer with the string }
destructor Destroy; override;
published
property Id: integer
read GetId write DeadInt;
property Algorithm: string
read GetAlgorithm write DeadStr;
property HashSize: integer
read GetHashSize write DeadInt;
end;
TDCP_hashclass= class of TDCP_hash;
{******************************************************************************}
{ The base class from which all encryption components will be derived. }
{ Stream ciphers will be derived directly from this class where as }
{ Block ciphers will have a further foundation class TDCP_blockcipher. }
type
EDCP_cipher= class(Exception);
TDCP_cipher= class(TComponent)
protected
fInitialized: boolean; { Whether or not the key setup has been done yet }
procedure DeadInt(Value: integer); { Knudge to display vars in the object inspector }
procedure DeadStr(Value: string); { Knudge to display vars in the object inspector }
public
property Initialized: boolean
read fInitialized;
class function GetId: integer; virtual; abstract;
{ Get the algorithm id }
class function GetAlgorithm: string; virtual; abstract;
{ Get the algorithm name }
class function GetMaxKeySize: integer; virtual; abstract;
{ Get the maximum key size (in bits) }
class function SelfTest: boolean; virtual; abstract;
{ Tests the implementation with several test vectors }
procedure Init(const Key; Size: longword; InitVector: pointer); virtual;
{ Do key setup based on the data in Key, size is in bits }
procedure InitStr(const Key: string; HashType: TDCP_hashclass);
{ Do key setup based on a hash of the key string }
procedure Burn; virtual;
{ Clear all stored key information }
procedure Reset; virtual; abstract;
{ Reset any stored chaining information }
procedure Encrypt(const Indata; var Outdata; Size: longword); virtual; abstract;
{ Encrypt size bytes of data and place in Outdata }
procedure Decrypt(const Indata; var Outdata; Size: longword); virtual; abstract;
{ Decrypt size bytes of data and place in Outdata }
function EncryptStream(InStream, OutStream: TStream; Size: longword): longword;
{ Encrypt size bytes of data from InStream and place in OutStream }
function DecryptStream(InStream, OutStream: TStream; Size: longword): longword;
{ Decrypt size bytes of data from InStream and place in OutStream }
function EncryptString(const Str: string): string; virtual;
{ Encrypt a string and return Base64 encoded }
function DecryptString(const Str: string): string; virtual;
{ Decrypt a Base64 encoded string }
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
published
property Id: integer
read GetId write DeadInt;
property Algorithm: string
read GetAlgorithm write DeadStr;
property MaxKeySize: integer
read GetMaxKeySize write DeadInt;
end;
TDCP_cipherclass= class of TDCP_cipher;
{******************************************************************************}
{ The base class from which all block ciphers are to be derived, this }
{ extra class takes care of the different block encryption modes. }
type
TDCP_ciphermode= (cmCBC, cmCFB8bit, cmCFBblock, cmOFB, cmCTR); // cmCFB8bit is equal to DCPcrypt v1.xx"s CFB mode
EDCP_blockcipher= class(EDCP_cipher);
TDCP_blockcipher= class(TDCP_cipher)
protected
← →
kaZaNoVa © (2005-01-18 14:07) [5]
fCipherMode: TDCP_ciphermode; { The cipher mode the encrypt method uses }
procedure InitKey(const Key; Size: longword); virtual; abstract;
public
class function GetBlockSize: integer; virtual; abstract;
{ Get the block size of the cipher (in bits) }
procedure SetIV(const Value); virtual; abstract;
{ Sets the IV to Value and performs a reset }
procedure GetIV(var Value); virtual; abstract;
{ Returns the current chaining information, not the actual IV }
procedure Encrypt(const Indata; var Outdata; Size: longword); override;
{ Encrypt size bytes of data and place in Outdata using CipherMode }
procedure Decrypt(const Indata; var Outdata; Size: longword); override;
{ Decrypt size bytes of data and place in Outdata using CipherMode }
function EncryptString(const Str: string): string; override;
{ Encrypt a string and return Base64 encoded }
function DecryptString(const Str: string): string; override;
{ Decrypt a Base64 encoded string }
procedure EncryptECB(const Indata; var Outdata); virtual; abstract;
{ Encrypt a block of data using the ECB method of encryption }
procedure DecryptECB(const Indata; var Outdata); virtual; abstract;
{ Decrypt a block of data using the ECB method of decryption }
procedure EncryptCBC(const Indata; var Outdata; Size: longword); virtual; abstract;
{ Encrypt size bytes of data using the CBC method of encryption }
procedure DecryptCBC(const Indata; var Outdata; Size: longword); virtual; abstract;
{ Decrypt size bytes of data using the CBC method of decryption }
procedure EncryptCFB8bit(const Indata; var Outdata; Size: longword); virtual; abstract;
{ Encrypt size bytes of data using the CFB (8 bit) method of encryption }
procedure DecryptCFB8bit(const Indata; var Outdata; Size: longword); virtual; abstract;
{ Decrypt size bytes of data using the CFB (8 bit) method of decryption }
procedure EncryptCFBblock(const Indata; var Outdata; Size: longword); virtual; abstract;
{ Encrypt size bytes of data using the CFB (block) method of encryption }
procedure DecryptCFBblock(const Indata; var Outdata; Size: longword); virtual; abstract;
{ Decrypt size bytes of data using the CFB (block) method of decryption }
procedure EncryptOFB(const Indata; var Outdata; Size: longword); virtual; abstract;
{ Encrypt size bytes of data using the OFB method of encryption }
procedure DecryptOFB(const Indata; var Outdata; Size: longword); virtual; abstract;
{ Decrypt size bytes of data using the OFB method of decryption }
procedure EncryptCTR(const Indata; var Outdata; Size: longword); virtual; abstract;
{ Encrypt size bytes of data using the CTR method of encryption }
procedure DecryptCTR(const Indata; var Outdata; Size: longword); virtual; abstract;
{ Decrypt size bytes of data using the CTR method of decryption }
constructor Create(AOwner: TComponent); override;
published
property BlockSize: integer
read GetBlockSize write DeadInt;
property CipherMode: TDCP_ciphermode
read fCipherMode write fCipherMode default cmCBC;
end;
TDCP_blockcipherclass= class of TDCP_blockcipher;
{******************************************************************************}
{ Helper functions }
procedure XorBlock(var InData1, InData2; Size: longword);
implementation
{$Q-}{$R-}
{** TDCP_hash *****************************************************************}
procedure TDCP_hash.DeadInt(Value: integer);
begin
end;
procedure TDCP_hash.DeadStr(Value: string);
begin
end;
procedure TDCP_hash.UpdateStream(Stream: TStream; Size: longword);
var
Buffer: array[0..8191] of byte;
i, read: integer;
begin
for i:= 1 to (Size div Sizeof(Buffer)) do
begin
read:= Stream.Read(Buffer,Sizeof(Buffer));
Update(Buffer,read);
end;
if (Size mod Sizeof(Buffer))<> 0 then
begin
read:= Stream.Read(Buffer,Size mod Sizeof(Buffer));
Update(Buffer,read);
end;
end;
procedure TDCP_hash.UpdateStream(Stream: TStream; Size: longword; BufferSize: longword);
//RM-Modification: overloaded function that allows to select buffer size
var
Buffer: Pointer;
i, read: integer;
begin
GetMem(Buffer, BufferSize);
try
for i:= 1 to (Size div BufferSize) do
begin
read:= Stream.Read(Buffer^,BufferSize);
Update(Buffer^,read);
end;
if (Size mod BufferSize)<> 0 then
begin
read:= Stream.Read(Buffer^, Size mod BufferSize);
Update(Buffer^,read);
end;
finally
FreeMem(Buffer, BufferSize);
end;
end;
procedure TDCP_hash.UpdateStr(const Str: string);
begin
Update(Str[1],Length(Str));
end;
destructor TDCP_hash.Destroy;
begin
if fInitialized then
Burn;
inherited Destroy;
end;
{** TDCP_cipher ***************************************************************}
procedure TDCP_cipher.DeadInt(Value: integer);
begin
end;
procedure TDCP_cipher.DeadStr(Value: string);
begin
end;
procedure TDCP_cipher.Init(const Key; Size: longword; InitVector: pointer);
begin
if fInitialized then
Burn;
if (Size <= 0) or ((Size and 3)<> 0) or (Size> longword(GetMaxKeySize)) then
raise EDCP_cipher.Create("Invalid key size")
else
fInitialized:= true;
end;
procedure TDCP_cipher.InitStr(const Key: string; HashType: TDCP_hashclass);
var
Hash: TDCP_hash;
Digest: pointer;
begin
if fInitialized then
Burn;
try
GetMem(Digest,HashType.GetHashSize div 8);
Hash:= HashType.Create(Self);
Hash.Init;
Hash.UpdateStr(Key);
Hash.Final(Digest^);
Hash.Free;
if MaxKeySize< HashType.GetHashSize then
Init(Digest^,MaxKeySize,nil)
else
Init(Digest^,HashType.GetHashSize,nil);
FillChar(Digest^,HashType.GetHashSize div 8,$FF);
FreeMem(Digest);
except
raise EDCP_cipher.Create("Unable to allocate sufficient memory for hash digest");
end;
end;
procedure TDCP_cipher.Burn;
begin
← →
kaZaNoVa © (2005-01-18 14:07) [6]
fInitialized:= false;
end;
function TDCP_cipher.EncryptStream(InStream, OutStream: TStream; Size: longword): longword;
var
Buffer: array[0..8191] of byte;
i, Read: longword;
begin
Result:= 0;
for i:= 1 to (Size div Sizeof(Buffer)) do
begin
Read:= InStream.Read(Buffer,Sizeof(Buffer));
Inc(Result,Read);
Encrypt(Buffer,Buffer,Read);
OutStream.Write(Buffer,Read);
end;
if (Size mod Sizeof(Buffer))<> 0 then
begin
Read:= InStream.Read(Buffer,Size mod Sizeof(Buffer));
Inc(Result,Read);
Encrypt(Buffer,Buffer,Read);
OutStream.Write(Buffer,Read);
end;
end;
function TDCP_cipher.DecryptStream(InStream, OutStream: TStream; Size: longword): longword;
var
Buffer: array[0..8191] of byte;
i, Read: longword;
begin
Result:= 0;
for i:= 1 to (Size div Sizeof(Buffer)) do
begin
Read:= InStream.Read(Buffer,Sizeof(Buffer));
Inc(Result,Read);
Decrypt(Buffer,Buffer,Read);
OutStream.Write(Buffer,Read);
end;
if (Size mod Sizeof(Buffer))<> 0 then
begin
Read:= InStream.Read(Buffer,Size mod Sizeof(Buffer));
Inc(Result,Read);
Decrypt(Buffer,Buffer,Read);
OutStream.Write(Buffer,Read);
end;
end;
function TDCP_cipher.EncryptString(const Str: string): string;
begin
SetLength(Result,Length(Str));
Encrypt(Str[1],Result[1],Length(Str));
Result:= Base64EncodeStr(Result);
end;
function TDCP_cipher.DecryptString(const Str: string): string;
begin
Result:= Base64DecodeStr(Str);
Decrypt(Result[1],Result[1],Length(Result));
end;
constructor TDCP_cipher.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
Burn;
end;
destructor TDCP_cipher.Destroy;
begin
if fInitialized then
Burn;
inherited Destroy;
end;
{** TDCP_blockcipher **********************************************************}
procedure TDCP_blockcipher.Encrypt(const Indata; var Outdata; Size: longword);
begin
case fCipherMode of
cmCBC: EncryptCBC(Indata,Outdata,Size);
cmCFB8bit: EncryptCFB8bit(Indata,Outdata,Size);
cmCFBblock: EncryptCFBblock(Indata,Outdata,Size);
cmOFB: EncryptOFB(Indata,Outdata,Size);
cmCTR: EncryptCTR(Indata,Outdata,Size);
end;
end;
function TDCP_blockcipher.EncryptString(const Str: string): string;
begin
SetLength(Result,Length(Str));
EncryptCFB8bit(Str[1],Result[1],Length(Str));
Result:= Base64EncodeStr(Result);
end;
function TDCP_blockcipher.DecryptString(const Str: string): string;
begin
Result:= Base64DecodeStr(Str);
DecryptCFB8bit(Result[1],Result[1],Length(Result));
end;
procedure TDCP_blockcipher.Decrypt(const Indata; var Outdata; Size: longword);
begin
case fCipherMode of
cmCBC: DecryptCBC(Indata,Outdata,Size);
cmCFB8bit: DecryptCFB8bit(Indata,Outdata,Size);
cmCFBblock: DecryptCFBblock(Indata,Outdata,Size);
cmOFB: DecryptOFB(Indata,Outdata,Size);
cmCTR: DecryptCTR(Indata,Outdata,Size);
end;
end;
constructor TDCP_blockcipher.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
fCipherMode:= cmCBC;
end;
{** Helpher functions *********************************************************}
procedure XorBlock(var InData1, InData2; Size: longword);
var
i: longword;
begin
for i:= 1 to Size do
Pbyte(longword(@InData1)+i-1)^:= Pbyte(longword(@InData1)+i-1)^ xor Pbyte(longword(@InData2)+i-1)^;
end;
end.
← →
kaZaNoVa © (2005-01-18 14:08) [7]
unit DCPbase64;
interface
uses
Sysutils;
//Added for compiling with FreePascal
type
PByteArray = ^TByteArray;
TByteArray = array[0..32767] of Byte;
function Base64EncodeStr(const Value: string): string;
{ Encode a string into Base64 format }
function Base64DecodeStr(const Value: string): string;
{ Decode a Base64 format string }
function Base64Encode(pInput: pointer; pOutput: pointer; Size: longint): longint;
{ Encode a lump of raw data (output is (4/3) times bigger than input) }
function Base64Decode(pInput: pointer; pOutput: pointer; Size: longint): longint;
{ Decode a lump of raw data }
{******************************************************************************}
{******************************************************************************}
implementation
{$Q-}{$R-}
const
B64: array[0..63] of byte= (65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,
81,82,83,84,85,86,87,88,89,90,97,98,99,100,101,102,103,104,105,106,107,108,
109,110,111,112,113,114,115,116,117,118,119,120,121,122,48,49,50,51,52,53,
54,55,56,57,43,47);
function Base64Encode(pInput: pointer; pOutput: pointer; Size: longint): longint;
var
i, iptr, optr: integer;
Input, Output: PByteArray;
begin
Input:= PByteArray(pInput); Output:= PByteArray(pOutput);
iptr:= 0; optr:= 0;
for i:= 1 to (Size div 3) do
begin
Output^[optr+0]:= B64[Input^[iptr] shr 2];
Output^[optr+1]:= B64[((Input^[iptr] and 3) shl 4) + (Input^[iptr+1] shr 4)];
Output^[optr+2]:= B64[((Input^[iptr+1] and 15) shl 2) + (Input^[iptr+2] shr 6)];
Output^[optr+3]:= B64[Input^[iptr+2] and 63];
Inc(optr,4); Inc(iptr,3);
end;
case (Size mod 3) of
1: begin
Output^[optr+0]:= B64[Input^[iptr] shr 2];
Output^[optr+1]:= B64[(Input^[iptr] and 3) shl 4];
Output^[optr+2]:= byte("=");
Output^[optr+3]:= byte("=");
end;
2: begin
Output^[optr+0]:= B64[Input^[iptr] shr 2];
Output^[optr+1]:= B64[((Input^[iptr] and 3) shl 4) + (Input^[iptr+1] shr 4)];
Output^[optr+2]:= B64[(Input^[iptr+1] and 15) shl 2];
Output^[optr+3]:= byte("=");
end;
end;
Result:= ((Size+2) div 3) * 4;
end;
function Base64EncodeStr(const Value: string): string;
begin
SetLength(Result,((Length(Value)+2) div 3) * 4);
Base64Encode(@Value[1],@Result[1],Length(Value));
end;
function Base64Decode(pInput: pointer; pOutput: pointer; Size: longint): longint;
var
i, j, iptr, optr: integer;
Temp: array[0..3] of byte;
Input, Output: PByteArray;
begin
Input:= PByteArray(pInput); Output:= PByteArray(pOutput);
iptr:= 0; optr:= 0;
Result:= 0;
for i:= 1 to (Size div 4) do
begin
for j:= 0 to 3 do
begin
case Input^[iptr] of
65..90 : Temp[j]:= Input^[iptr] - Ord("A");
97..122: Temp[j]:= Input^[iptr] - Ord("a") + 26;
48..57 : Temp[j]:= Input^[iptr] - Ord("0") + 52;
43 : Temp[j]:= 62;
47 : Temp[j]:= 63;
61 : Temp[j]:= $FF;
end;
Inc(iptr);
end;
Output^[optr]:= (Temp[0] shl 2) or (Temp[1] shr 4);
Result:= optr+1;
if (Temp[2]<> $FF) and (Temp[3]= $FF) then
begin
Output^[optr+1]:= (Temp[1] shl 4) or (Temp[2] shr 2);
Result:= optr+2;
Inc(optr)
end
else if (Temp[2]<> $FF) then
begin
Output^[optr+1]:= (Temp[1] shl 4) or (Temp[2] shr 2);
Output^[optr+2]:= (Temp[2] shl 6) or Temp[3];
Result:= optr+3;
Inc(optr,2);
end;
Inc(optr);
end;
end;
function Base64DecodeStr(const Value: string): string;
begin
SetLength(Result,(Length(Value) div 4) * 3);
SetLength(Result,Base64Decode(@Value[1],@Result[1],Length(Value)));
end;
end.
← →
TUser © (2005-01-18 14:08) [8]Здесь был?
http://www.torry.net/pages.php?id=519
http://www.torry.net/pages.php?id=312
← →
kaZaNoVa © (2005-01-18 14:09) [9]пример юзания
var
Form1: TForm1;
t:textfile; kkk:boolean;
t1:file of byte;
k:array[1..8000000] of string;
p2, p,p1,pk,n,kk:int64; v,l,r:string;
Digest: array[0..15] of Byte;
q: array[0..15] of word;
C,o:Integer;
Hash: TDCP_md5;
implementation
{$R *.dfm}
procedure TForm1.Button1Click(Sender: TObject);
begin
Hash := TDCP_md5.Create(nil);
Hash.Init;
Hash.UpdateStr(edit1.Text);
Hash.Final(Digest);
Edit2.Text:="";
for C:=Low(Digest) to High(Digest) do begin
Edit2.Text :=Edit2.Text + IntToHex(Digest[C],2);
end;
Hash.Free;
end;
← →
kaZaNoVa © (2005-01-18 14:10) [10]ух, кажется всё запостил))))
← →
ShimON © (2005-01-18 14:11) [11]uses
Classes, Sysutils, DCPcrypt2, DCPconst;//
Не очень понял... А где DCPcrypt2, и нельзя ли примерчик простой...
← →
ShimON © (2005-01-18 14:12) [12]Спасибо :)
← →
kaZaNoVa © (2005-01-18 14:13) [13]ShimON © (18.01.05 14:11) [11]
всё запостил и пример тоже, пашет у меня 500 000 в секунду - делал перебор MD5
//но код не мой
← →
Kerk © (2005-01-18 14:16) [14]Казанова, ты реально достал! :)
Ты ссылку дать не мог? Нахрена столько сюда постить?
← →
Amoeba © (2005-01-18 14:18) [15]Между прочим готовый модуль есть здесь:
http://endimus.com/oldcontent/files/index_en.php
http://endimus.com/oldcontent/files/downloads/md5.zip
← →
kaZaNoVa © (2005-01-18 14:28) [16]Kerk © (18.01.05 14:16) [14]
ЛОЛ
я код Постил)))
а ссылки нет, тока у меня
Страницы: 1 вся ветка
Форум: "Основная";
Текущий архив: 2005.01.30;
Скачать: [xml.tar.bz2];
Память: 0.55 MB
Время: 0.035 c