(Delphi ActiveX) Streaming Compression --> Streaming Encryption

Demonstrate how to feed a compression stream into an encryption stream. This example does the following:

Data File --> Compress --> Encrypt --> Application Reads

Chilkat for Delphi Downloads Chilkat ActiveX DLL for Delphi Chilkat non-ActiveX DLL for Delphi * The examples here use the ActiveX DLL.

uses
    Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
    Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Chilkat_v9_5_0_TLB;

...

procedure TForm1.Button1Click(Sender: TObject);
var
success: Integer;
compress: TChilkatCompression;
crypt: TChilkatCrypt2;
ivHex: WideString;
keyHex: WideString;
streamC: TChilkatStream;
streamE: TChilkatStream;
taskC: IChilkatTask;
taskE: IChilkatTask;
outData: TChilkatBinData;

begin
//  This requires the Chilkat API to have been previously unlocked.
//  See Global Unlock Sample for sample code.

//  Initialize the compression object.
compress := TChilkatCompression.Create(Self);
compress.Algorithm := 'deflate';

//  Initialize the encryption object.
crypt := TChilkatCrypt2.Create(Self);
crypt.CryptAlgorithm := 'chacha20';
crypt.KeyLength := 256;
crypt.EncodingMode := 'hex';
ivHex := '000000000000000000000002';
crypt.SetEncodedIV(ivHex,'hex');
crypt.InitialCount := 42;
keyHex := '1c9240a5eb55d38af333888604f6b5f0473917c1402b80099dca5cbc207075c0';
crypt.SetEncodedKey(keyHex,'hex');

//  Setup the streams.
//  streamC is for compression
streamC := TChilkatStream.Create(Self);
//  streamE is for encryption
streamE := TChilkatStream.Create(Self);

//  The source for the compressor is a file.
streamC.SourceFile := 'qa_data/hamlet.xml';
//  The source for the encryptor is the output of the compressor stream.
success := streamE.SetSourceStream(streamC.ControlInterface);

//  Our application will be reading the output of streamE.
//  Start the compression and encryption streams in background threads..
taskC := compress.CompressStreamAsync(streamC.ControlInterface);
taskE := crypt.EncryptStreamAsync(streamE.ControlInterface);
success := taskC.Run();
success := taskE.Run();

//  Read the compressed and encrypted bytes.
outData := TChilkatBinData.Create(Self);
while (streamE.EndOfStream <> 1) do
  begin
    if (streamE.DataAvailable = 1) then
      begin
        success := streamE.ReadBd(outData.ControlInterface);
      end;
  end;

//  Let's make sure the background task finished.
//  It should already be the case that the task is finished.
while ((taskE.Finished <> 1) or (taskC.Finished <> 1)) do
  begin
    taskE.SleepMs(20);
  end;

//  Get any remaining data that needs to be flushed.
if (streamE.DataAvailable = 1) then
  begin
    success := streamE.ReadBd(outData.ControlInterface);
  end;

//  Double-check for success..
if (taskE.TaskSuccess <> 1) then
  begin
    Memo1.Lines.Add('async encryption failed:');
    Memo1.Lines.Add(taskE.ResultErrorText);
    success := 0;
  end;

//  Double-check for success..
if (taskC.TaskSuccess <> 1) then
  begin
    Memo1.Lines.Add('async compression failed:');
    Memo1.Lines.Add(taskC.ResultErrorText);
    success := 0;
  end;

//  Save the compressed/encrypted data to a file.
outData.WriteFile('qa_output/compressedEncrypted.dat');

Memo1.Lines.Add('The async compress/encrypt was successful.');

//  Let's decrypt and decompress to further verify...
success := crypt.DecryptBd(outData.ControlInterface);
success := compress.DecompressBd(outData.ControlInterface);

//  outData should contain the original data..
success := outData.WriteFile('qa_output/original_hamlet.xml');
end;