Pascal (Lazarus/Delphi)

Understanding a few ECDSA Public Key Formats

See more ECC Examples

Describes a few ECDSA public key formats. 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.BinData,
  Chilkat.StringBuilder,
  Chilkat.PublicKey;

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

procedure RunDemo;
var
  success: Boolean;
  sbPem: TStringBuilder;
  pubKey1: TPublicKey;
  sbHex: TStringBuilder;
  numReplaced: Integer;
  bdKey: TBinData;
  pubKey2: TPublicKey;

begin
  success := False;

  //  Here we have the output of the following openssl command:  openssl ec -in key.pem -pubout -text

  //  Private-Key: (256 bit)
  //  priv:
  //      0e:63:25:8a:73:3c:71:b6:c0:e7:a3:0f:94:b9:74:
  //      e0:be:bd:46:18:be:40:7e:66:9e:21:99:85:0e:ed:
  //      87:2d
  //  pub:
  //      04:5d:1a:4f:d9:bd:49:9e:e4:fd:55:2c:0d:ea:6d:
  //      b1:66:64:7a:71:91:13:63:86:fe:ca:94:d4:47:51:
  //      39:66:ff:43:d5:62:de:f2:f2:41:3c:2e:3f:95:18:
  //      2d:23:f7:e7:8e:75:19:3b:c6:50:fb:d9:90:f5:e8:
  //      12:b7:b8:6a:43
  //  ASN1 OID: prime256v1
  //  NIST CURVE: P-256
  //  writing EC key
  //  -----BEGIN PUBLIC KEY-----
  //  MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXRpP2b1JnuT9VSwN6m2xZmR6cZET
  //  Y4b+ypTUR1E5Zv9D1WLe8vJBPC4/lRgtI/fnjnUZO8ZQ+9mQ9egSt7hqQw==
  //  -----END PUBLIC KEY-----

  //  The public key is shown in two different formats.
  //  The first is this:

  //  pub:
  //      04:5d:1a:4f:d9:bd:49:9e:e4:fd:55:2c:0d:ea:6d:
  //      b1:66:64:7a:71:91:13:63:86:fe:ca:94:d4:47:51:
  //      39:66:ff:43:d5:62:de:f2:f2:41:3c:2e:3f:95:18:
  //      2d:23:f7:e7:8e:75:19:3b:c6:50:fb:d9:90:f5:e8:
  //      12:b7:b8:6a:43

  //  It is the ANSI X9.63 format.
  //  65-bytes are the uncompressed public key (04 || X || Y) 

  //  This is the same public key, but in PEM format

  //  -----BEGIN PUBLIC KEY-----
  //  MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXRpP2b1JnuT9VSwN6m2xZmR6cZET
  //  Y4b+ypTUR1E5Zv9D1WLe8vJBPC4/lRgtI/fnjnUZO8ZQ+9mQ9egSt7hqQw==
  //  -----END PUBLIC KEY-----

  //  It contains ASN.1 that more explicitly identifies the key type.
  //  
  //  SEQUENCE (2 elem)
  //    SEQUENCE (2 elem)
  //      OBJECT IDENTIFIER 1.2.840.10045.2.1 ecPublicKey (ANSI X9.62 public key type)
  //      OBJECT IDENTIFIER 1.2.840.10045.3.1.7 prime256v1 (ANSI X9.62 named elliptic curve)
  //    BIT STRING (520 bit) 000001000101110100011010010011111101100110111101010010011001111011100...

  //  PEM format can be loaded into a Chilkat public key object like this:

  sbPem := TStringBuilder.Create;
  sbPem.Append('-----BEGIN PUBLIC KEY-----' + #13#10);
  sbPem.Append('MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXRpP2b1JnuT9VSwN6m2xZmR6cZET' + #13#10);
  sbPem.Append('Y4b+ypTUR1E5Zv9D1WLe8vJBPC4/lRgtI/fnjnUZO8ZQ+9mQ9egSt7hqQw==' + #13#10);
  sbPem.Append('-----END PUBLIC KEY-----' + #13#10);

  pubKey1 := TPublicKey.Create;
  success := pubKey1.LoadFromString(sbPem.GetAsString());
  if (success = False) then
    begin
      WriteLn(pubKey1.LastErrorText);
      Exit;
    end;

  //  The X9.63 format can be loaded like this:
  sbHex := TStringBuilder.Create;
  sbHex.Append('04:5d:1a:4f:d9:bd:49:9e:e4:fd:55:2c:0d:ea:6d:');
  sbHex.Append('b1:66:64:7a:71:91:13:63:86:fe:ca:94:d4:47:51:');
  sbHex.Append('39:66:ff:43:d5:62:de:f2:f2:41:3c:2e:3f:95:18:');
  sbHex.Append('2d:23:f7:e7:8e:75:19:3b:c6:50:fb:d9:90:f5:e8:');
  sbHex.Append('12:b7:b8:6a:43');

  //  Get rid of the ":" chars.
  numReplaced := sbHex.Replace(':','');

  //  We'll need to convert hex to base64..
  bdKey := TBinData.Create;
  bdKey.AppendEncoded(sbHex.GetAsString(),'hex');

  pubKey2 := TPublicKey.Create;
  success := pubKey2.LoadFromString(bdKey.GetEncoded('base64'));
  if (success = False) then
    begin
      WriteLn(pubKey2.LastErrorText);
      Exit;
    end;

  //  Let's get the key in pubKey2 as PEM.
  //  It should be idential to the PEM above.
  WriteLn(pubKey2.GetPem(True));

  //  Here's the output.  You can see it's the same as the PEM above..

  //  -----BEGIN PUBLIC KEY-----
  //  MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXRpP2b1JnuT9VSwN6m2xZmR6cZET
  //  Y4b+ypTUR1E5Zv9D1WLe8vJBPC4/lRgtI/fnjnUZO8ZQ+9mQ9egSt7hqQw==
  //  -----END PUBLIC KEY-----


  sbPem.Free;
  pubKey1.Free;
  sbHex.Free;
  bdKey.Free;
  pubKey2.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.