Pascal (Lazarus/Delphi)

ECDSA Sign Data and Get Raw R and S Values

See more ECC Examples

Demonstrates getting the raw R and S value of an ECDSA signature. 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.Asn,
  Chilkat.Prng,
  Chilkat.BinData,
  Chilkat.PrivateKey,
  Chilkat.Xml,
  Chilkat.Crypt2,
  Chilkat.Ecc;

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

procedure RunDemo;
var
  success: Boolean;
  crypt: TCrypt2;
  hash1: string;
  privKey: TPrivateKey;
  prng: TPrng;
  ecdsa: TEcc;
  ecdsaSigBase64: string;
  asn: TAsn;
  xml: TXml;
  bd: TBinData;
  r: string;
  s: string;

begin
  success := False;

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

  //  To create an ECDSA signature, the data first needs to be hashed.  Then the hash
  //  is signed.

  crypt := TCrypt2.Create;
  crypt.HashAlgorithm := 'SHA256';
  crypt.Charset := 'utf-8';
  crypt.EncodingMode := 'base64';

  //  Hash a string.
  hash1 := crypt.HashStringENC('The quick brown fox jumps over the lazy dog');
  WriteLn('hash1 = ' + hash1);

  //  -----------------------------------------------------------
  //  An ECDSA private key is used for signing.  The public key is for signature verification.
  //  Load our ECC private key.
  //  Our private key file contains this:

  //  	// -----BEGIN PRIVATE KEY-----
  //  	MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQg3J8q/24D1sEKGdP9
  //  	72MGYElLGpw/a56Y3t6pfON3uhShRANCAATlSmoizyhAwoYZAOuFBATl07/1RR54
  //  	a1Dzfm16grxJe666AGKR+bSs24hk7TEpaeCTvT8YOOM3l+xKFg7zq6Q9
  //  	-----END PRIVATE KEY-----

  privKey := TPrivateKey.Create;
  success := privKey.LoadPemFile('qa_data/ecc/secp256r1-key-pkcs8.pem');
  if (success <> True) then
    begin
      WriteLn(privKey.LastErrorText);
      Exit;
    end;

  //  Sign the hash..
  prng := TPrng.Create;
  ecdsa := TEcc.Create;
  ecdsaSigBase64 := ecdsa.SignHashENC(hash1,'base64',privKey,prng);
  if (ecdsa.LastMethodSuccess <> True) then
    begin
      WriteLn(ecdsa.LastErrorText);
      Exit;
    end;

  //  The ECDSA signature is ASN.1 that contains a sequence of 2 large integers (r and s)
  //  For example:
  //  SEQUENCE (2 elem)
  //    INTEGER (255 bit) 792134D9B4AD82D5431ED03835A88E2596EB35E5B13054BD9B05A0069281ACC9
  //    INTEGER (255 bit) 481E758CC1E3CBF825537EC3D9A2CA627E5FAD1137BBEA65DF38658DCB0A9ED5

  WriteLn('Base64 ECDSA signature = ' + ecdsaSigBase64);

  //  If the raw R and S values are needed, here's how to get them:
  asn := TAsn.Create;
  success := asn.LoadEncoded(ecdsaSigBase64,'base64');
  if (success = False) then
    begin
      WriteLn(asn.LastErrorText);
      Exit;
    end;

  //  The R and X will be in hexidecimal in the XML.
  xml := TXml.Create;
  xml.LoadXml(asn.AsnToXml());
  WriteLn(xml.GetXml());

  //  The XML looks like this:
  //  <sequence>
  //  <int>792134D9B4AD82D5431ED03835A88E2596EB35E5B13054BD9B05A0069281ACC9</int>
  //  <int>481E758CC1E3CBF825537EC3D9A2CA627E5FAD1137BBEA65DF38658DCB0A9ED5</int>
  //  </sequence>

  //  Copy raw R and S hex values into a Chilkat BinData object.
  bd := TBinData.Create;
  r := xml.GetChildContent('int[0]');
  s := xml.GetChildContent('int[1]');
  bd.AppendEncoded(r,'hex');
  bd.AppendEncoded(s,'hex');

  WriteLn('Number of bytes in bd: ' + bd.NumBytes);


  crypt.Free;
  privKey.Free;
  prng.Free;
  ecdsa.Free;
  asn.Free;
  xml.Free;
  bd.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.