(Delphi ActiveX) Sign Manifest File to Generate a Passbook .pkpass in Memory

Demonstrates how to create a Passbook .pkpass archive by creating a signature of a manifest file and then zipping to a .pkpass archive in memory

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_TLB;

...

procedure TForm1.Button1Click(Sender: TObject);
var
success: Integer;
manifest: TChilkatJsonObject;
crypt: TChilkatCrypt2;
zip: TChilkatZip;
digestStr: WideString;
pngData: TChilkatBinData;
entry: IChilkatZipEntry;
passJson: WideString;
certVault: TChilkatXmlCertVault;
appleWwdrCert: TChilkatCert;
bdPfx: TChilkatBinData;
pfxPassword: WideString;
cert: TChilkatCert;
jsonSignedAttrs: TChilkatJsonObject;
sig: WideString;
bdSig: TChilkatBinData;
bdZip: TChilkatBinData;

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

// ---------------------------------------------------------------------------------------------
// This example is the same as Sign Manifest File to Generate a Passbook .pkpass file
// except everything happens in memory (no input files, no output files)
// ---------------------------------------------------------------------------------------------

// First create the manifest.json

manifest := TChilkatJsonObject.Create(Self);
crypt := TChilkatCrypt2.Create(Self);

zip := TChilkatZip.Create(Self);
zip.NewZip('notUsedAndNeverCreated.zip');

crypt.HashAlgorithm := 'sha1';
// Return hashes as lowercase hex.
crypt.EncodingMode := 'hexlower';

pngData := TChilkatBinData.Create(Self);
// Assume we load the pngData with bytes for "icon.png" from somewhere, such as a byte array in memory.
entry := zip.AppendBd('icon.png',pngData.ControlInterface);

digestStr := crypt.HashBdENC(pngData.ControlInterface);
manifest.UpdateString('"icon.png"',digestStr);

pngData.Clear();
// Assume we load the pngData with bytes for "icon@2x.png" from somewhere...
entry := zip.AppendBd('icon@2x.png',pngData.ControlInterface);

digestStr := crypt.HashBdENC(pngData.ControlInterface);
manifest.UpdateString('"icon@2x.png"',digestStr);

pngData.Clear();
// Assume we load the pngData with bytes for "logo.png" from somewhere...
entry := zip.AppendBd('logo.png',pngData.ControlInterface);

digestStr := crypt.HashBdENC(pngData.ControlInterface);
manifest.UpdateString('"logo.png"',digestStr);

pngData.Clear();
// Assume we load the pngData with bytes for "logo@2x.png" from somewhere...
entry := zip.AppendBd('logo@2x.png',pngData.ControlInterface);

digestStr := crypt.HashBdENC(pngData.ControlInterface);
manifest.UpdateString('"logo@2x.png"',digestStr);

passJson := '{ .... }';//  Contains the contents of pass.json
entry := zip.AppendString('pass.json',passJson);

digestStr := crypt.HashStringENC(passJson);
manifest.UpdateString('"pass.json"',digestStr);

entry := zip.AppendString('manifest.json',manifest.Emit());

// Make sure we have the Apple WWDR intermediate certificate available for 
// the cert chain in the signature.
certVault := TChilkatXmlCertVault.Create(Self);
appleWwdrCert := TChilkatCert.Create(Self);
success := appleWwdrCert.LoadByCommonName('Apple Worldwide Developer Relations Certification Authority');
if (success <> 1) then
  begin
    Memo1.Lines.Add('The Apple WWDR intermediate certificate is not installed.');
    Memo1.Lines.Add('It is available at https://developer.apple.com/certificationauthority/AppleWWDRCA.cer');
    Memo1.Lines.Add('You may alternatively load the .cer like this...');
    success := appleWwdrCert.LoadFromFile('qa_data/certs/AppleWWDRCA.cer');
    if (success <> 1) then
      begin
        Memo1.Lines.Add(appleWwdrCert.LastErrorText);
        Exit;
      end;
  end;
certVault.AddCert(appleWwdrCert.ControlInterface);
crypt.UseCertVault(certVault.ControlInterface);

// Use a digital certificate and private key from a PFX
bdPfx := TChilkatBinData.Create(Self);
// Assume we loaded a PFX into bdPfx....
pfxPassword := 'test123';

cert := TChilkatCert.Create(Self);
success := cert.LoadPfxBd(bdPfx.ControlInterface,pfxPassword);
if (success <> 1) then
  begin
    Memo1.Lines.Add(cert.LastErrorText);
    Exit;
  end;

// Provide the signing cert (with associated private key).
success := crypt.SetSigningCert(cert.ControlInterface);
if (success <> 1) then
  begin
    Memo1.Lines.Add(crypt.LastErrorText);
    Exit;
  end;

// Specify the signed attributes to be included.
// (These attributes appear to not be necessary, but we're including
// them just in case they become necessary in the future.)
jsonSignedAttrs := TChilkatJsonObject.Create(Self);
jsonSignedAttrs.UpdateInt('contentType',1);
jsonSignedAttrs.UpdateInt('signingTime',1);
crypt.SigningAttributes := jsonSignedAttrs.Emit();

// Sign the manifest JSON to produce a signature
crypt.EncodingMode := 'base64';
sig := crypt.SignStringENC(manifest.Emit());
bdSig := TChilkatBinData.Create(Self);
bdSig.AppendEncoded(sig,'base64');
entry := zip.AppendBd('signature',bdSig.ControlInterface);

// ---------------------------------------------------------------------------------------------
// Note: Chilkat also has the capability to do everything in-memory (no files would be involved).  
// If this is of interest, please send email to support@chilkatsoft.com
// ---------------------------------------------------------------------------------------------

// Create the .pkipass archive (which is a .zip archive containing the required files).
// the .zip is written to bdZip
bdZip := TChilkatBinData.Create(Self);
success := zip.WriteBd(bdZip.ControlInterface);
if (success <> 1) then
  begin
    Memo1.Lines.Add(zip.LastErrorText);
    Exit;
  end;

Memo1.Lines.Add('Success.');
end;