lbstring.pas

tool pour ubuntu 8.10

    LbEncodeBase64(WorkStream, OutStream);
  end else begin
    LbDecodeBase64(InStream, WorkStream);
    WorkStream.Position := 0;
    BFEncryptStreamCBC(WorkStream, OutStream, Key, False);
  end;
  OutStream.Position := 0;
  SetLength(Result, OutStream.Size);
  OutStream.Read(Result[1], OutStream.Size);

  InStream.Free;
  OutStream.Free;
  WorkStream.Free;
end;
{ -------------------------------------------------------------------------- }
procedure BFEncryptString(const InString : string; var OutString : string;
            const Key : TKey128; Encrypt : Boolean);
begin
  OutString := BFEncryptStringEx(InString, Key, Encrypt);
end;
{ -------------------------------------------------------------------------- }
procedure BFEncryptStringCBC(const InString : string; var OutString : string;
            const Key : TKey128; Encrypt : Boolean);
begin
  OutString := BFEncryptStringCBCEx(InString, Key, Encrypt);
end;


{ == DES string encryption/decryption ====================================== }
function DESEncryptStringEx(const InString : string;
            const Key : TKey64; Encrypt : Boolean) : string;
var
  InStream  : TMemoryStream;
  OutStream : TMemoryStream;
  WorkStream : TMemoryStream;
begin
  InStream := TMemoryStream.Create;
  OutStream := TMemoryStream.Create;
  WorkStream := TMemoryStream.Create;
  InStream.Write(InString[1], Length(InString));
  InStream.Position := 0;

  if Encrypt then begin
    DESEncryptStream(InStream, WorkStream, Key, True);
    WorkStream.Position := 0;
    LbEncodeBase64(WorkStream, OutStream);
  end else begin
    LbDecodeBase64(InStream, WorkStream);
    WorkStream.Position := 0;
    DESEncryptStream(WorkStream, OutStream, Key, False);
  end;
  OutStream.Position := 0;
  SetLength(Result, OutStream.Size);
  OutStream.Read(Result[1], OutStream.Size);

  InStream.Free;
  OutStream.Free;
  WorkStream.Free;
end;
{ -------------------------------------------------------------------------- }
function DESEncryptStringCBCEx(const InString : string;
            const Key : TKey64; Encrypt : Boolean) : string;
var
  InStream  : TMemoryStream;
  OutStream : TMemoryStream;
  WorkStream : TMemoryStream;
begin
  InStream := TMemoryStream.Create;
  OutStream := TMemoryStream.Create;
  WorkStream := TMemoryStream.Create;
  InStream.Write(InString[1], Length(InString));
  InStream.Position := 0;

  if Encrypt then begin
    DESEncryptStreamCBC(InStream, WorkStream, Key, True);
    WorkStream.Position := 0;
    LbEncodeBase64(WorkStream, OutStream);
  end else begin
    LbDecodeBase64(InStream, WorkStream);
    WorkStream.Position := 0;
    DESEncryptStreamCBC(WorkStream, OutStream, Key, False);
  end;
  OutStream.Position := 0;
  SetLength(Result, OutStream.Size);
  OutStream.Read(Result[1], OutStream.Size);

  InStream.Free;
  OutStream.Free;
  WorkStream.Free;
end;
{ -------------------------------------------------------------------------- }
procedure DESEncryptString(const InString : string; var OutString : string;
            const Key : TKey64; Encrypt : Boolean);
begin
  OutString := DESEncryptStringEx(InString, Key, Encrypt);
end;
{ -------------------------------------------------------------------------- }
procedure DESEncryptStringCBC(const InString : string; var OutString : string;
            const Key : TKey64; Encrypt : Boolean);
begin
  OutString := DESEncryptStringCBCEx(InString, Key, Encrypt);
end;


{ == TripleDES string encryption/decryption ================================ }
function TripleDESEncryptStringEx(const InString : string;
            const Key : TKey128; Encrypt : Boolean) : string;
var
  InStream  : TMemoryStream;
  OutStream : TMemoryStream;
  WorkStream : TMemoryStream;
begin
  InStream := TMemoryStream.Create;
  OutStream := TMemoryStream.Create;
  WorkStream := TMemoryStream.Create;
  InStream.Write(InString[1], Length(InString));
  InStream.Position := 0;

  if Encrypt then begin
    TripleDESEncryptStream(InStream, WorkStream, Key, True);
    WorkStream.Position := 0;
    LbEncodeBase64(WorkStream, OutStream);
  end else begin
    LbDecodeBase64(InStream, WorkStream);
    WorkStream.Position := 0;
    TripleDESEncryptStream(WorkStream, OutStream, Key, False);
  end;
  OutStream.Position := 0;
  SetLength(Result, OutStream.Size);
  OutStream.Read(Result[1], OutStream.Size);

  InStream.Free;
  OutStream.Free;
  WorkStream.Free;
end;
{ -------------------------------------------------------------------------- }
function TripleDESEncryptStringCBCEx(const InString : string;
            const Key : TKey128; Encrypt : Boolean) : string;
var
  InStream  : TMemoryStream;
  OutStream : TMemoryStream;
  WorkStream : TMemoryStream;
begin
  InStream := TMemoryStream.Create;
  OutStream := TMemoryStream.Create;
  WorkStream := TMemoryStream.Create;
  InStream.Write(InString[1], Length(InString));
  InStream.Position := 0;

  if Encrypt then begin
    TripleDESEncryptStreamCBC(InStream, WorkStream, Key, True);
    WorkStream.Position := 0;
    LbEncodeBase64(WorkStream, OutStream);
  end else begin
    LbDecodeBase64(InStream, WorkStream);
    WorkStream.Position := 0;
    TripleDESEncryptStreamCBC(WorkStream, OutStream, Key, False);
  end;
  OutStream.Position := 0;
  SetLength(Result, OutStream.Size);
  OutStream.Read(Result[1], OutStream.Size);

  InStream.Free;
  OutStream.Free;
  WorkStream.Free;
end;
{ -------------------------------------------------------------------------- }
procedure TripleDESEncryptString(const InString : string; var OutString : string;
            const Key : TKey128; Encrypt : Boolean);
begin
  OutString := TripleDESEncryptStringEx(InString, Key, Encrypt);
end;
{ -------------------------------------------------------------------------- }
procedure TripleDESEncryptStringCBC(const InString : string; var OutString : string;
            const Key : TKey128; Encrypt : Boolean);
begin
  OutString := TripleDESEncryptStringCBCEx(InString, Key, Encrypt);
end;


{ == Rijndael string encryption/decryption ================================== }
function RDLEncryptStringEx(const InString : string;
            const Key; KeySize : Longint; Encrypt : Boolean) : string;
var
  InStream  : TMemoryStream;
  OutStream : TMemoryStream;
  WorkStream : TMemoryStream;
begin
  InStream := TMemoryStream.Create;
  OutStream := TMemoryStream.Create;
  WorkStream := TMemoryStream.Create;
  InStream.Write(InString[1], Length(InString));
  InStream.Position := 0;

  if Encrypt then begin
    RDLEncryptStream(InStream, WorkStream, Key, KeySize, True);
    WorkStream.Position := 0;
    LbEncodeBase64(WorkStream, OutStream);
  end else begin
    LbDecodeBase64(InStream, WorkStream);
    WorkStream.Position := 0;
    RDLEncryptStream(WorkStream, OutStream, Key, KeySize, False);
  end;
  OutStream.Position := 0;
  SetLength(Result, OutStream.Size);
  OutStream.Read(Result[1], OutStream.Size);

  InStream.Free;
  OutStream.Free;
  WorkStream.Free;
end;
{ -------------------------------------------------------------------------- }
function RDLEncryptStringCBCEx(const InString : string;
            const Key; KeySize : Longint; Encrypt : Boolean) : string;
var
  InStream  : TMemoryStream;
  OutStream : TMemoryStream;
  WorkStream : TMemoryStream;
begin
  InStream := TMemoryStream.Create;
  OutStream := TMemoryStream.Create;
  WorkStream := TMemoryStream.Create;
  InStream.Write(InString[1], Length(InString));
  InStream.Position := 0;

  if Encrypt then begin
    RDLEncryptStreamCBC(InStream, WorkStream, Key, KeySize, True);
    WorkStream.Position := 0;
    LbEncodeBase64(WorkStream, OutStream);
  end else begin
    LbDecodeBase64(InStream, WorkStream);
    WorkStream.Position := 0;
    RDLEncryptStreamCBC(WorkStream, OutStream, Key, KeySize, False);
  end;
  OutStream.Position := 0;
  SetLength(Result, OutStream.Size);
  OutStream.Read(Result[1], OutStream.Size);

  InStream.Free;
  OutStream.Free;
  WorkStream.Free;
end;
{ -------------------------------------------------------------------------- }
procedure RDLEncryptString(const InString : string; var OutString : string;
            const Key; KeySize : Longint; Encrypt : Boolean);
begin
  OutString := RDLEncryptStringEx(InString, Key, KeySize, Encrypt);
end;
{ -------------------------------------------------------------------------- }
procedure RDLEncryptStringCBC(const InString : string; var OutString : string;
            const Key; KeySize : Longint; Encrypt : Boolean);
begin
  OutString := RDLEncryptStringCBCEx(InString, Key, KeySize, Encrypt);
end;


end.