type
   DByte = array[0..1] of byte;
 
 
 { BinToHex
 
   Convertis une donnée binaire vers sa représentation hexadécimal (chaine).
 
   Paramètres :
     Buffer [I] non typé
     Len [I] entier, taille du buffer
     Str [O] chaine, retour
 
   Retour :
     Retourne une chaine (Str) représentant la donnée en hexadécimal.
 }
 procedure BinToHex(const Buffer; const Len: integer; var Str: string);
 var pB : ^byte;
     pR : ^DByte;
     N : integer;
 const
   BTC : array[$0..$F] of byte = ($30,$31,$32,$33,$34,$35,$36,$37,
                                  $38,$39,$41,$42,$43,$44,$45,$46);
 begin
   SetLength(Str, Len shl 1);
   pB := @Buffer;
   pR := @Str[1];
   for N := 0 to Len-1 do
   begin
     pR^[0] := BTC[pB^ shr 4];
     pR^[1] := BTC[pB^ and $0F];
     inc(pR);
     inc(pB);
   end;
 end;
 
 
 { HexToBin
 
   Convertis une chaine representant une donnée en hexadecimal vers une donnée brute.
 
   Parametres :
     Str [I] chaine representant la donnée en hexadecimal
     LenStr [I] entier, taille de la chaine
     Buffer [O] buffer de sortie pour la donnée brute.
 
   Retour :
     Retourne une donnée brute (Buffer) a partir de la chaine Str.
 
   Note : 
     la taille du Buffer doit etre definie avant l'appel a HexToBin, qu'il s'agisse
     d'un pointeur, d'une chaine ou d'un tableau.
 }
 procedure HexToBin(const Str: string; const LenStr: integer; var Buffer);
 var pB   : ^byte;
     pS   : ^DByte;
     LZ,N : integer;
     L,H  : byte;
 begin
   LZ := LenStr shr 1;
 
   pS := @Str[1];
   pB := @Buffer;
   for N := 0 to LZ-2 do
   begin
     case pS^[0] of
       $30..$39 : H := (pS^[0] - $30) shl 4;
       $41..$46 : H := (pS^[0] - $37) shl 4;
       else
         break;
     end;
     case pS^[1] of
       $30..$39 : L := pS^[1] - $30;
       $41..$46 : L := pS^[1] - $37;
       else
         break;
     end;
     pB^ := byte(H or L);
     inc(pS);
     inc(pB);
   end;
 end;
 
 
 

__inline BYTE HexVal(BYTE bt) 
{
    if(bt >= '0' && bt <= '9') return (bt - 0x30); 
    if(bt >= 'a' && bt <= 'z') return (bt - 0x57);
    if(bt >= 'A' && bt <= 'Z') return (bt - 0x37); 
    return bt; 
}

void __stdcall Hex2Bin(BYTE* lpIn, DWORD dwInSize, BYTE* lpOut)
{
  DWORD i = (dwInSize-1);
  do {
    lpOut[i] = (HexVal(lpIn[i*2]) << 4) | (HexVal(lpIn[i*2+1]));
  } while(i--);
}
void __stdcall Bin2Hex(BYTE* lpIn, DWORD dwInSize, BYTE* lpOut)
{
  static const BYTE HexaTable[16] = {0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
                                     0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66 };
  DWORD i = (dwInSize-1);
  do {
    lpOut[2*i] = HexaTable[(lpIn[i] >> 4) & 0x0F];
    lpOut[2*i+1] = HexaTable[lpIn[i] & 0x0F];
  } while(i--); 
}