Pascal (Lazarus/Delphi)

How to Generate an Elliptic Curve Shared Secret

See more ECC Examples

Demonstrates how to generate an ECC (Elliptic Curve Cryptography) shared secret. Imagine a cilent has one ECC private key, the server has another. A shared secret is computed by each side providing it's public key to the other. The private keys are kept private. Pascal (Lazarus/Delphi)

program ChilkatDemo;

// Demonstrates using the Chilkat Pascal wrapper via the C bridge DLL.
// Builds as a console application under Lazarus (FPC) or Delphi.

{$IFDEF FPC}
  {$MODE DELPHI}
{$ENDIF}
{$APPTYPE CONSOLE}

uses
  {$IFDEF UNIX}
  cthreads,
  {$ENDIF}
  SysUtils,
  CkDllLoader,
  Chilkat.PublicKey,
  Chilkat.PrivateKey,
  Chilkat.Prng,
  Chilkat.Ecc;

// ---------------------------------------------------------------------------

procedure RunDemo;
var
  success: Boolean;
  prngClient: TPrng;
  eccClient: TEcc;
  privKeyClient: TPrivateKey;
  pubKeyClient: TPublicKey;
  prngServer: TPrng;
  eccServer: TEcc;
  privKeyServer: TPrivateKey;
  pubKeyServer: TPublicKey;
  pubKeyFromServer: TPublicKey;
  sharedSecret1: string;
  pubKeyFromClient: TPublicKey;
  sharedSecret2: string;

begin
  success := False;

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

  //  This example includes both client-side and server-side code.
  //  Each code segment is marked as client-side or server-side.
  //  Imagine these segments are running on separate computers...

  //  -----------------------------------------------------------------
  //  (Client-Side) Generate an ECC key, save the public part to a file.
  //  -----------------------------------------------------------------
  prngClient := TPrng.Create;
  eccClient := TEcc.Create;
  privKeyClient := TPrivateKey.Create;
  success := eccClient.GenKey('secp256r1',prngClient,privKeyClient);
  if (success = False) then
    begin
      WriteLn(eccClient.LastErrorText);
      Exit;
    end;
  pubKeyClient := TPublicKey.Create;
  privKeyClient.ToPublicKey(pubKeyClient);
  pubKeyClient.SavePemFile(False,'qa_output/eccClientPub.pem');

  //  -----------------------------------------------------------------
  //  (Server-Side) Generate an ECC key, save the public part to a file.
  //  -----------------------------------------------------------------
  prngServer := TPrng.Create;
  eccServer := TEcc.Create;
  privKeyServer := TPrivateKey.Create;
  eccServer.GenKey('secp256r1',prngServer,privKeyServer);

  pubKeyServer := TPublicKey.Create;
  privKeyServer.ToPublicKey(pubKeyServer);
  pubKeyServer.SavePemFile(False,'qa_output/eccServerPub.pem');

  //  -----------------------------------------------------------------
  //  (Client-Side) Generate the shared secret using our private key, and the other's public key.
  //  -----------------------------------------------------------------

  //  Imagine that the server sent the public key PEM to the client.
  //  (This is simulated by loading the server's public key from the file.
  pubKeyFromServer := TPublicKey.Create;
  pubKeyFromServer.LoadFromFile('qa_output/eccServerPub.pem');
  sharedSecret1 := eccClient.SharedSecretENC(privKeyClient,pubKeyFromServer,'base64');

  //  -----------------------------------------------------------------
  //  (Server-Side) Generate the shared secret using our private key, and the other's public key.
  //  -----------------------------------------------------------------

  //  Imagine that the client sent the public key PEM to the server.
  //  (This is simulated by loading the client's public key from the file.
  pubKeyFromClient := TPublicKey.Create;
  pubKeyFromClient.LoadFromFile('qa_output/eccClientPub.pem');
  sharedSecret2 := eccServer.SharedSecretENC(privKeyServer,pubKeyFromClient,'base64');

  //  ---------------------------------------------------------
  //  Examine the shared secrets.  They should be the same.
  //  Both sides now have a secret that only they know.
  //  ---------------------------------------------------------
  WriteLn(sharedSecret1);
  WriteLn(sharedSecret2);


  prngClient.Free;
  eccClient.Free;
  privKeyClient.Free;
  pubKeyClient.Free;
  prngServer.Free;
  eccServer.Free;
  privKeyServer.Free;
  pubKeyServer.Free;
  pubKeyFromServer.Free;
  pubKeyFromClient.Free;

end;

// ---------------------------------------------------------------------------

begin

  try
    RunDemo;
  except
    on E: Exception do
      WriteLn('Unhandled exception: ', E.ClassName, ': ', E.Message);
  end;

  WriteLn;
  {$IFDEF MSWINDOWS}
  WriteLn('Press Enter to exit...');
  ReadLn;
  {$ENDIF}
end.