dec_api.pas

nice crypt method, if you are a delphi programmer you really love this because is very useful code

{Copyright:      Hagen Reddmann  mailto:[e-mail]
 Author:         Hagen Reddmann
 Remarks:        freeware, but this Copyright must included
 known Problems: none
 Version:        3.0,  Part I from Delphi Encryption Compendium
                 Delphi 2-4, designed and testet under D3 and D4
 Description:    Low Level API Routines for Cipher and Hash

 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ''AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

                 }
unit DEC_api;

interface

{$I VER.INC}

uses Windows;

type
  TCipherHandle = Integer;
  THashHandle   = Integer;
  TEnumProc     = function(Name: PChar; ID, MaxKeySize: Integer; Data: Pointer): Bool; stdcall;

const
{Cipher Modes for Cipher_Create()}
  cm_CTS        = 0;
  cm_CBC        = 1;
  cm_CFB        = 2;
  cm_OFB        = 3;
  cm_ECB        = 4;

function Cipher_GetID(Name: PChar): Integer; stdcall;
function Cipher_Create(ID, Mode: Integer): TCipherHandle; stdcall;
function Cipher_Delete(Handle: TCipherHandle): Integer; stdcall;
function Cipher_Encode(Handle: TCipherHandle; Source, Dest: PChar; Size: Integer): Integer; stdcall;
function Cipher_Decode(Handle: TCipherHandle; Source, Dest: PChar; Size: Integer): Integer; stdcall;
function Cipher_Init(Handle: TCipherHandle; Key: Pointer; KeyLen: Integer; IVector: Pointer): Integer; stdcall;
function Cipher_InitKey(Handle: TCipherHandle; Key: PChar; IVector: Pointer): Integer; stdcall;
function Cipher_Done(Handle: TCipherHandle): Integer; stdcall;
function Cipher_Protect(Handle: TCipherHandle): Integer; stdcall;
function Cipher_GetMaxKeySize(Handle: TCipherHandle): Integer; stdcall;
function Cipher_SetHash(Handle: TCipherHandle; Hash_ID: Integer): Integer; stdcall;
function Cipher_GetHash(Handle: TCipherHandle): Integer; stdcall;
procedure Cipher_EnumNames(Proc: TEnumProc; UserData: Pointer); stdcall;

function Hash_GetID(Name: PChar): Integer; stdcall;
function Hash_Create(ID: Integer): THashHandle; stdcall;
function Hash_Delete(Handle: THashHandle): Integer; stdcall;
function Hash_Init(Handle: THashHandle): Integer; stdcall;
function Hash_Done(Handle: THashHandle; Digest: PChar; DigestSize: Integer): Integer; stdcall;
function Hash_Update(Handle: THashHandle; Source: PChar; SourceLen: Integer): Integer; stdcall;
function Hash_GetMaxDigestSize(Handle: THashHandle): Integer; stdcall;
function Hash_CalcFile(ID: Integer; FileName, Digest: PChar; MaxDigestLen: Integer): Integer; stdcall;
procedure Hash_EnumNames(Proc: TEnumProc; UserData: Pointer); stdcall;

{give back 0 when Ok otherwise the required Size for Dest}
function StrToBase64(Dest, Source: PChar; Len, MaxLen: Integer): Integer; stdcall;
function Base64ToStr(Dest, Source: PChar; Len, MaxLen: Integer): Integer; stdcall;
function StrToBase16(Dest, Source: PChar; Len, MaxLen: Integer): Integer; stdcall;
function Base16ToStr(Dest, Source: PChar; Len, MaxLen: Integer): Integer; stdcall;

{using Hash

var
  Handle: THashHandle;
  Digest: Pointer;
  DigestSize: Integer;
begin
  Handle := Hash_Create(3);  // for SHA1
  try
    DigestSize := Hash_GetMaxDigestSize(Handle);
    Digest := GetMem(DigestSize);
    Hash_Init(Handle);
    Hash_Update(Handle, Data, DataSize);
    Hash_Done(Handle, Digest, DigestSize);
  finally
    Hash_Delete(Handle);
    FreeMem(Digest, DigestSize);
  end;
end;

using Cipher

var
  Handle: TCipherHandle;
begin
  Handle := Cipher_Create(1); // for Blowfish
  try
    Cipher_SetHash(Handle, 14);  // for Tiger, default is SHA1
    Cipher_InitKey(Handle, 'Password', nil);
    Cipher_Encode(Handle, Data, Data, DataSize);
  finally
    Cipher_Delete(Handle);
  end;
end;

}
implementation

uses SysUtils, Classes, DECUtil, Hash, Cipher, Cipher1;

const
  FCipherList: TStringList = nil;
  FHashList: TStringList = nil;

function StrToBase64(Dest, Source: PChar; Len, MaxLen: Integer): Integer;
var
  S: String;
begin
  Result := -1;
  if Source <> nil then
  begin
    S := DECUtil.StrToBase64(Source, Len);
    Result := Length(S);
    if (Dest <> nil) and (MaxLen >= Result) then
    begin
      Result := 0;
      FillChar(Dest^, MaxLen, 0);
      StrPLCopy(Dest, S, MaxLen);
    end;
  end;
end;

function Base64ToStr(Dest, Source: PChar; Len, MaxLen: Integer): Integer;
var
  S: String;
begin
  Result := -1;
  if Source <> nil then
  begin
    S := DECUtil.Base64ToStr(Source, Len);
    Result := Length(S);
    if (Dest <> nil) and (MaxLen >= Result) then
    begin
      Result := 0;
      FillChar(Dest^, MaxLen, 0);
      StrPLCopy(Dest, S, MaxLen);
    end;
  end;
end;

function StrToBase16(Dest, Source: PChar; Len, MaxLen: Integer): Integer;
var
  S: String;
begin
  Result := -1;
  if Source <> nil then
  begin
    S := DECUtil.StrToBase16(Source, Len);
    Result := Length(S);
    if (Dest <> nil) and (MaxLen >= Result) then
    begin
      Result := 0;
      FillChar(Dest^, MaxLen, 0);
      StrPLCopy(Dest, S, MaxLen);
    end;
  end;
end;

function Base16ToStr(Dest, Source: PChar; Len, MaxLen: Integer): Integer;
var
  S: String;
begin
  Result := -1;
  if Source <> nil then
  begin
    S := DECUtil.Base16ToStr(Source, Len);
    Result := Length(S);
    if (Dest <> nil) and (MaxLen >= Result) then
    begin
      Result := 0;
      FillChar(Dest^, MaxLen, 0);
      StrPLCopy(Dest, S, MaxLen);
    end;
  end;
end;

function IsObject(AObject: Integer; AClass: TClass): Boolean;
var
  E: Pointer;
begin
  Result := False;
  if AObject = 0 then Exit;
  E := ExceptionClass;
  ExceptionClass := nil;
  try
    if (PInteger(PChar(AObject) - SizeOf(Integer))^ and $00000002 = $00000002) and
       (TObject(AObject) is AClass) then Result := True;
  except
  end;
  ExceptionClass := E;
end;

function Cipher_GetID(Name: PChar): Integer;
begin
  Result := FCipherList.IndexOf(Name);
end;

function Cipher_Create(ID, Mode: Integer): TCipherHandle;
begin
  if (ID >= 0) and (ID < FCipherList.Count) then
  begin
    if TCipherClass(FCipherList.Objects[ID]).SelfTest then
    begin
      Result := Integer(TCipherClass(FCipherList.Objects[ID]).Create);
      Mode := Mode and $F;
      if Mode > 4 then Mode := 0;
      TCipher(Result).Mode := TCipherMode(Mode);
    end else Result := -2;
  end else Result := -1;
end;

function Cipher_Delete(Handle: TCipherHandle): Integer;
begin
  Result := 0;
  if IsObject(Handle, TCipher) then TCipher(Handle).Free else Result := -1
end;

function Cipher_Encode(Handle: TCipherHandle; Source, Dest: PChar; Size: Integer): Integer;
begin
  Result := -3;
  if IsObject(Handle, TCipher) then
  begin
    if TCipher(Handle).Initialized then
    begin
      TCipher(Handle).EncodeBuffer(Source^, Dest^, Size);
      Result := 0;
    end else Result := -2;
  end else Result := -1;
end;

function Cipher_Decode(Handle: TCipherHandle; Source, Dest: PChar; Size: Integer): Integer;
begin
  Result := -3;
  if IsObject(Handle, TCipher) then
  begin
    if TCipher(Handle).Initialized then
    begin
      TCipher(Handle).DecodeBuffer(Source^, Dest^, Size);
      Result := 0;
    end else Result := -2;
  end else Result := -1;
end;

function Cipher_Init(Handle: TCipherHandle; Key: Pointer; KeyLen: Integer; IVector: Pointer): Integer;
begin
  Result := -3;
  if IsObject(Handle, TCipher) then
  begin
    TCipher(Handle).Init(Key^, KeyLen, IVector);
    Result := 0;
  end else Result := -1;
end;