Função MD5 existente no PHP

13/12/2005

Alguém sabe se há a possibilidade de usar a função MD5() cujo é bastante usada no php e no mysql para criação de senhas, dentro do delphi?

Gostaria muito de fazer a encriptação dos seriais de meu sistema utilizando essa excelente função.

se alguém souber de alguma coisa, agradeço imensamente...

:idea:


Henry Lima

Respostas

13/12/2005

Mysys

cara c tu usa mysql tem sim da mesma forma que é usado no php....


eu nao uso MD5 mas a funcao é quese a mesmma

depois de cadastrado o usuario eu gravo a senha

UPDATE tbl413 SET SENUSU = PASSWORD(:VSSenha)
WHERE IDEUSU = :VSIDeUsu

pra conferir a senha faz assim
SELECT PASSWORD(:VSSenha)SENHA


Responder Citar

14/12/2005

Vinicius2k

Colega,

Existem diversos componentes de criptografia/hash para Delphi, porém o melhor que já pude testar, e é o que eu uso, foi o TurboPower LockBox (free/opensource).
Nele você encontra diversos algorítimos de criptografia e também os hashes MD5 e SHA-1.
Podem ser utilizados como classes ou apenas realizando chamadas às suas rotinas.

http://sourceforge.net/projects/tplockbox

T+


Responder Citar

14/12/2005

Henry Lima

Obrigado pelos esclarecimentos que me foram muito importantes, sempre que precisarem podem contar comigo ok!

Feliz Natal para vocês... :D


Responder Citar

15/12/2005

Thomaz_prg

Olá amigo Vinicius.. eu já havia baixado esses componentes, porém não consegui utilizá-los :oops:
Você poderia me mostrar um exemplo usando o MD5 disponível na palheta de componentes????


Responder Citar

15/12/2005

Vinicius2k

Olá Thomaz,

Acho que melhor do que eu lhe postar um exemplo, é você verificar a pasta ´examples´ na raiz de instalação do pacote.
Lá você irá encontrar diversos exemplos utilizando componentes e também somente as rotinas presentes no pacote. (Pessoalmente, só utilizo as rotinas).

Um exemplo simples (utilizando apenas rotinas) seria:
uses
  LbCipher, LbUtils;

procedure GerarHashMD5;
var
  MD5Digest: TMD5Digest;
  SuaString, SeuHash: String;
begin
  SuaString := ´Qualquer texto.´;
  StringHashMD5(MD5Digest, SuaString);
  SeuHash := BufferToHex(MD5Digest, SizeOf(MD5Digest));

  ShowMessage(´O MD5 de ´ + SuaString + ´ é ´ + SeuHash);
end;


Se assim não ´desenrolar´, é só falar que eu lhe ajudo no que for possível.

T+


Responder Citar

15/12/2005

Thomaz_prg

Valeu amigão... Muito Obrigado!

Já esclareceu (na verdade solucionou minhas dúvidas).... muito obrigado mesmo.


Responder Citar

15/12/2005

William Thiago

Eu tenho um componente que implementa o algoritmo AES de 128, 256 e 512 bits. É um algoritmo muito bom, sucessor do DES.
Se alguem quiser, solicita por e-mail...

williamthiago at uol.com.br

Acho que ainda tenho um vídeo explicando como usar passo a passo (mobral mesmo) que fiz pra ajudar um colega. Deve dar uns 80 megas...


Responder Citar

16/12/2005

Lucianobarreto

// tabs = 2 
// ----------------------------------------------------------------------------------------------- 
// 
//                                 MD5 Message-Digest for Delphi 4 
// 
//                                 Delphi 4 Unit implementing the 
//                      RSA Data Security, Inc. MD5 Message-Digest Algorithm 
//
//                          Implementation of Ronald L. Rivest´s RFC 1321 
// 
//                      Copyright © 1997-1999 Medienagentur Fichtner & Meyer 
//                                  Written by Matthias Fichtner 
// 
// ----------------------------------------------------------------------------------------------- 
//               See RFC 1321 for RSA Data Security´s copyright and license notice! 
// ----------------------------------------------------------------------------------------------- 
// 
//     14-Jun-97  mf  Implemented MD5 according to RFC 1321                           RFC 1321 
//     16-Jun-97  mf  Initial release of the compiled unit (no source code)           RFC 1321 
//     28-Feb-99  mf  Added MD5Match function for comparing two digests               RFC 1321 
//     13-Sep-99  mf  Reworked the entire unit                                        RFC 1321 
//     17-Sep-99  mf  Reworked the "Test Driver" project                              RFC 1321 
//     19-Sep-99  mf  Release of sources for MD5 unit and "Test Driver" project       RFC 1321 
// 
// ----------------------------------------------------------------------------------------------- 
//                   The latest release of md5.pas will always be available from 
//                  the distribution site at: http://www.fichtner.net/delphi/md5/ 
// ----------------------------------------------------------------------------------------------- 
//                       Please send questions, bug reports and suggestions 
//                      regarding this code to: mfichtner@fichtner-meyer.com 
// ----------------------------------------------------------------------------------------------- 
//                        This code is provided "as is" without express or 
//                     implied warranty of any kind. Use it at your own risk. 
// ----------------------------------------------------------------------------------------------- 

unit UnitMD5;

// ----------------------------------------------------------------------------------------------- 
INTERFACE 
// ----------------------------------------------------------------------------------------------- 

uses 
   Windows; 

type 
   MD5Count = array[0..1&93; of DWORD; 
   MD5State = array&91;0..3&93; of DWORD; 
   MD5Block = array[0..15&93; of DWORD; 
   MD5CBits = array&91;0..7&93; of byte; 
   MD5Digest = array&91;0..15&93; of byte; 
   MD5Buffer = array&91;0..63&93; of byte; 
   MD5Context = record 
      State: MD5State; 
      Count: MD5Count; 
      Buffer: MD5Buffer; 
   end; 

procedure MD5Init(var Context: MD5Context); 
procedure MD5Update(var Context: MD5Context; Input: pChar; Length: longword); 
procedure MD5Final(var Context: MD5Context; var Digest: MD5Digest); 

function MD5String(M: string): MD5Digest; 
function MD5File(N: string): MD5Digest; 
function MD5Print(D: MD5Digest): string; 

function MD5Match(D1, D2: MD5Digest): boolean; 

// ----------------------------------------------------------------------------------------------- 
IMPLEMENTATION 
// ----------------------------------------------------------------------------------------------- 

var 
   PADDING: MD5Buffer = ( 
      $80, $00, $00, $00, $00, $00, $00, $00, 
      $00, $00, $00, $00, $00, $00, $00, $00, 
      $00, $00, $00, $00, $00, $00, $00, $00, 
      $00, $00, $00, $00, $00, $00, $00, $00, 
      $00, $00, $00, $00, $00, $00, $00, $00, 
      $00, $00, $00, $00, $00, $00, $00, $00, 
      $00, $00, $00, $00, $00, $00, $00, $00, 
      $00, $00, $00, $00, $00, $00, $00, $00 
   ); 

function F(x, y, z: DWORD): DWORD; 
begin 
   Result := (x and y) or ((not x) and z); 
end; 

function G(x, y, z: DWORD): DWORD; 
begin 
   Result := (x and z) or (y and (not z)); 
end; 

function H(x, y, z: DWORD): DWORD; 
begin 
   Result := x xor y xor z; 
end; 

function I(x, y, z: DWORD): DWORD; 
begin 
   Result := y xor (x or (not z)); 
end; 

procedure rot(var x: DWORD; n: BYTE); 
begin 
   x := (x shl n) or (x shr (32 - n)); 
end; 

procedure FF(var a: DWORD; b, c, d, x: DWORD; s: BYTE; ac: DWORD); 
begin 
   inc(a, F(b, c, d) + x + ac); 
   rot(a, s); 
   inc(a, b); 
end; 

procedure GG(var a: DWORD; b, c, d, x: DWORD; s: BYTE; ac: DWORD); 
begin 
   inc(a, G(b, c, d) + x + ac); 
   rot(a, s); 
   inc(a, b); 
end; 

procedure HH(var a: DWORD; b, c, d, x: DWORD; s: BYTE; ac: DWORD); 
begin 
   inc(a, H(b, c, d) + x + ac); 
   rot(a, s); 
   inc(a, b); 
end; 

procedure II(var a: DWORD; b, c, d, x: DWORD; s: BYTE; ac: DWORD); 
begin 
   inc(a, I(b, c, d) + x + ac); 
   rot(a, s); 
   inc(a, b); 
end; 

// ----------------------------------------------------------------------------------------------- 

// Encode Count bytes at Source into (Count / 4) DWORDs at Target 
procedure Encode(Source, Target: pointer; Count: longword); 
var 
   S: PByte; 
   T: PDWORD; 
   I: longword; 
begin 
   S := Source; 
   T := Target; 
   for I := 1 to Count div 4 do begin 
      T^ := S^; 
      inc(S); 
      T^ := T^ or (S^ shl 8); 
      inc(S); 
      T^ := T^ or (S^ shl 16); 
      inc(S); 
      T^ := T^ or (S^ shl 24); 
      inc(S); 
      inc(T); 
   end; 
end; 

// Decode Count DWORDs at Source into (Count * 4) Bytes at Target 
procedure Decode(Source, Target: pointer; Count: longword); 
var 
   S: PDWORD; 
   T: PByte; 
   I: longword; 
begin 
   S := Source; 
   T := Target; 
   for I := 1 to Count do begin 
      T^ := S^ and $ff; 
      inc(T); 
      T^ := (S^ shr 8) and $ff; 
      inc(T); 
      T^ := (S^ shr 16) and $ff; 
      inc(T); 
      T^ := (S^ shr 24) and $ff; 
      inc(T); 
      inc(S); 
   end; 
end; 

// Transform State according to first 64 bytes at Buffer 
procedure Transform(Buffer: pointer; var State: MD5State); 
var 
   a, b, c, d: DWORD; 
   Block: MD5Block; 
begin 
   Encode(Buffer, @Block, 64); 
   a := State[0&93;; 
   b := State&91;1&93;; 
   c := State&91;2&93;; 
   d := State&91;3&93;; 
   FF (a, b, c, d, Block&91; 0&93;,  7, $d76aa478); 
   FF (d, a, b, c, Block&91; 1&93;, 12, $e8c7b756); 
   FF (c, d, a, b, Block&91; 2&93;, 17, $242070db); 
   FF (b, c, d, a, Block&91; 3&93;, 22, $c1bdceee); 
   FF (a, b, c, d, Block&91; 4&93;,  7, $f57c0faf); 
   FF (d, a, b, c, Block&91; 5&93;, 12, $4787c62a); 
   FF (c, d, a, b, Block&91; 6&93;, 17, $a8304613); 
   FF (b, c, d, a, Block&91; 7&93;, 22, $fd469501); 
   FF (a, b, c, d, Block&91; 8&93;,  7, $698098d8); 
   FF (d, a, b, c, Block[ 9&93;, 12, $8b44f7af); 
   FF (c, d, a, b, Block&91;10&93;, 17, $ffff5bb1); 
   FF (b, c, d, a, Block&91;11&93;, 22, $895cd7be); 
   FF (a, b, c, d, Block&91;12&93;,  7, $6b901122); 
   FF (d, a, b, c, Block&91;13&93;, 12, $fd987193); 
   FF (c, d, a, b, Block&91;14&93;, 17, $a679438e); 
   FF (b, c, d, a, Block&91;15&93;, 22, $49b40821); 
   GG (a, b, c, d, Block&91; 1&93;,  5, $f61e2562); 
   GG (d, a, b, c, Block&91; 6&93;,  9, $c040b340); 
   GG (c, d, a, b, Block&91;11&93;, 14, $265e5a51); 
   GG (b, c, d, a, Block&91; 0&93;, 20, $e9b6c7aa); 
   GG (a, b, c, d, Block&91; 5&93;,  5, $d62f105d); 
   GG (d, a, b, c, Block&91;10&93;,  9,  $2441453); 
   GG (c, d, a, b, Block&91;15&93;, 14, $d8a1e681); 
   GG (b, c, d, a, Block&91; 4&93;, 20, $e7d3fbc8); 
   GG (a, b, c, d, Block&91; 9&93;,  5, $21e1cde6); 
   GG (d, a, b, c, Block[14&93;,  9, $c33707d6); 
   GG (c, d, a, b, Block&91; 3&93;, 14, $f4d50d87); 
   GG (b, c, d, a, Block&91; 8&93;, 20, $455a14ed); 
   GG (a, b, c, d, Block&91;13&93;,  5, $a9e3e905); 
   GG (d, a, b, c, Block&91; 2&93;,  9, $fcefa3f8); 
   GG (c, d, a, b, Block&91; 7&93;, 14, $676f02d9); 
   GG (b, c, d, a, Block&91;12&93;, 20, $8d2a4c8a); 
   HH (a, b, c, d, Block&91; 5&93;,  4, $fffa3942); 
   HH (d, a, b, c, Block&91; 8&93;, 11, $8771f681); 
   HH (c, d, a, b, Block&91;11&93;, 16, $6d9d6122); 
   HH (b, c, d, a, Block&91;14&93;, 23, $fde5380c); 
   HH (a, b, c, d, Block&91; 1&93;,  4, $a4beea44); 
   HH (d, a, b, c, Block&91; 4&93;, 11, $4bdecfa9); 
   HH (c, d, a, b, Block&91; 7&93;, 16, $f6bb4b60); 
   HH (b, c, d, a, Block&91;10&93;, 23, $bebfbc70); 
   HH (a, b, c, d, Block&91;13&93;,  4, $289b7ec6); 
   HH (d, a, b, c, Block[ 0&93;, 11, $eaa127fa); 
   HH (c, d, a, b, Block&91; 3&93;, 16, $d4ef3085); 
   HH (b, c, d, a, Block&91; 6&93;, 23,  $4881d05); 
   HH (a, b, c, d, Block&91; 9&93;,  4, $d9d4d039); 
   HH (d, a, b, c, Block&91;12&93;, 11, $e6db99e5); 
   HH (c, d, a, b, Block&91;15&93;, 16, $1fa27cf8); 
   HH (b, c, d, a, Block&91; 2&93;, 23, $c4ac5665); 
   II (a, b, c, d, Block&91; 0&93;,  6, $f4292244); 
   II (d, a, b, c, Block&91; 7&93;, 10, $432aff97); 
   II (c, d, a, b, Block&91;14&93;, 15, $ab9423a7); 
   II (b, c, d, a, Block&91; 5&93;, 21, $fc93a039); 
   II (a, b, c, d, Block&91;12&93;,  6, $655b59c3); 
   II (d, a, b, c, Block&91; 3&93;, 10, $8f0ccc92); 
   II (c, d, a, b, Block&91;10&93;, 15, $ffeff47d); 
   II (b, c, d, a, Block&91; 1&93;, 21, $85845dd1); 
   II (a, b, c, d, Block&91; 8&93;,  6, $6fa87e4f); 
   II (d, a, b, c, Block[15&93;, 10, $fe2ce6e0); 
   II (c, d, a, b, Block&91; 6&93;, 15, $a3014314); 
   II (b, c, d, a, Block&91;13&93;, 21, $4e0811a1); 
   II (a, b, c, d, Block&91; 4&93;,  6, $f7537e82); 
   II (d, a, b, c, Block&91;11&93;, 10, $bd3af235); 
   II (c, d, a, b, Block&91; 2&93;, 15, $2ad7d2bb); 
   II (b, c, d, a, Block&91; 9&93;, 21, $eb86d391); 
   inc(State&91;0&93;, a); 
   inc(State&91;1&93;, b); 
   inc(State&91;2&93;, c); 
   inc(State&91;3&93;, d); 
end; 

// ----------------------------------------------------------------------------------------------- 

// Initialize given Context 
procedure MD5Init(var Context: MD5Context); 
begin 
   with Context do begin 
      State&91;0&93; := $67452301; 
      State&91;1&93; := $efcdab89; 
      State&91;2&93; := $98badcfe; 
      State&91;3&93; := $10325476; 
      Count[0&93; := 0; 
      Count&91;1&93; := 0; 
      ZeroMemory(@Buffer, SizeOf(MD5Buffer)); 
   end; 
end; 

// Update given Context to include Length bytes of Input 
procedure MD5Update(var Context: MD5Context; Input: pChar; Length: longword); 
var 
   Index: longword; 
   PartLen: longword; 
   I: longword; 
begin 
   with Context do begin 
      Index := (Count&91;0&93; shr 3) and $3f; 
      inc(Count&91;0&93;, Length shl 3); 
      if Count&91;0&93; < (Length shl 3) then inc(Count&91;1&93;); 
      inc(Count&91;1&93;, Length shr 29); 
   end; 
   PartLen := 64 - Index; 
   if Length >= PartLen then begin 
      CopyMemory(@Context.Buffer&91;Index&93;, Input, PartLen); 
      Transform(@Context.Buffer, Context.State); 
      I := PartLen; 
      while I + 63 < Length do begin 
         Transform(@Input[I&93;, Context.State); 
         inc(I, 64); 
      end; 
      Index := 0; 
   end else I := 0; 
   CopyMemory(@Context.Buffer&91;Index&93;, @Input&91;I&93;, Length - I); 
end; 

// Finalize given Context, create Digest and zeroize Context 
procedure MD5Final(var Context: MD5Context; var Digest: MD5Digest); 
var 
   Bits: MD5CBits; 
   Index: longword; 
   PadLen: longword; 
begin 
   Decode(@Context.Count, @Bits, 2); 
   Index := (Context.Count&91;0&93; shr 3) and $3f; 
   if Index < 56 then PadLen := 56 - Index else PadLen := 120 - Index; 
   MD5Update(Context, @PADDING, PadLen); 
   MD5Update(Context, @Bits, 8); 
   Decode(@Context.State, @Digest, 4); 
   ZeroMemory(@Context, SizeOf(MD5Context)); 
end; 

// ----------------------------------------------------------------------------------------------- 

// Create digest of given Message 
function MD5String(M: string): MD5Digest; 
var 
   Context: MD5Context; 
begin 
   MD5Init(Context); 
   MD5Update(Context, pChar(M), length(M)); 
   MD5Final(Context, Result); 
end; 

// Create digest of file with given Name 
function MD5File(N: string): MD5Digest; 
var 
   FileHandle: THandle; 
   MapHandle: THandle; 
   ViewPointer: pointer; 
   Context: MD5Context; 
begin 
   MD5Init(Context); 
   FileHandle := CreateFile(pChar(N), GENERIC_READ, FILE_SHARE_READ or FILE_SHARE_WRITE, 
      nil, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL or FILE_FLAG_SEQUENTIAL_SCAN, 0); 
   if FileHandle <> INVALID_HANDLE_VALUE then try 
      MapHandle := CreateFileMapping(FileHandle, nil, PAGE_READONLY, 0, 0, nil); 
      if MapHandle <> 0 then try 
         ViewPointer := MapViewOfFile(MapHandle, FILE_MAP_READ, 0, 0, 0); 
         if ViewPointer <> nil then try 
            MD5Update(Context, ViewPointer, GetFileSize(FileHandle, nil)); 
         finally 
            UnmapViewOfFile(ViewPointer); 
         end; 
      finally 
         CloseHandle(MapHandle); 
      end; 
   finally 
      CloseHandle(FileHandle); 
   end; 
   MD5Final(Context, Result); 
end; 

// Create hex representation of given Digest 
function MD5Print(D: MD5Digest): string; 
var 
   I: byte; 
const 
   Digits: array[0..15&93; of char = 
      (´0´, ´1´, ´2´, ´3´, ´4´, ´5´, ´6´, ´7´, ´8´, ´9´, ´a´, ´b´, ´c´, ´d´, ´e´, ´f´); 
begin 
   Result := ´´; 
   for I := 0 to 15 do Result := Result + Digits&91;(D&91;I&93; shr 4) and $0f&93; + Digits&91;D&91;I&93; and $0f&93;; 
end; 

// ----------------------------------------------------------------------------------------------- 

// Compare two Digests 
function MD5Match(D1, D2: MD5Digest): boolean; 
var 
   I: byte; 
begin 
   I := 0; 
   Result := TRUE; 
   while Result and (I < 16) do begin 
      Result := D1[I&93; = D2&91;I&93;; 
      inc(I); 
   end; 
end; 

end.


Use assim

  Variável_String:=MD5Print(MD5String(´Seu Texto´));


Até mais

Abraços


Responder Citar

16/12/2005

Thomaz_prg

Pessoal, se interessar para alguém, consegui fazer a criptografia (MD5) usando alguns componentes da palheta Indy....


Responder Citar

22/03/2006

Danilodcf

Achei interessante usando Indy, se puder, envia para o meu email.

Alguém aí sabe algum componente de criptografia para o Delphi2005?

vlw.


Responder Citar