(Unicode C) Understanding a few ECDSA Public Key Formats

See more ECC Examples

Describes a few ECDSA public key formats.

Chilkat C/C++ Library Downloads
MS Visual C/C++ Linux/CentOS C/C++ Alpine Linux C/C++ MAC OS X C/C++	armhf/aarch64 C/C++ C++ Builder iOS C/C++ Android C/C++	Solaris C/C++ MinGW C/C++

#include <C_CkStringBuilderW.h>
#include <C_CkPublicKeyW.h>
#include <C_CkBinDataW.h>

void ChilkatSample(void)
    {
    BOOL success;
    HCkStringBuilderW sbPem;
    HCkPublicKeyW pubKey1;
    HCkStringBuilderW sbHex;
    int numReplaced;
    HCkBinDataW bdKey;
    HCkPublicKeyW pubKey2;

    // 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 = CkStringBuilderW_Create();
    CkStringBuilderW_Append(sbPem,L"-----BEGIN PUBLIC KEY-----\r\n");
    CkStringBuilderW_Append(sbPem,L"MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEXRpP2b1JnuT9VSwN6m2xZmR6cZET\r\n");
    CkStringBuilderW_Append(sbPem,L"Y4b+ypTUR1E5Zv9D1WLe8vJBPC4/lRgtI/fnjnUZO8ZQ+9mQ9egSt7hqQw==\r\n");
    CkStringBuilderW_Append(sbPem,L"-----END PUBLIC KEY-----\r\n");

    pubKey1 = CkPublicKeyW_Create();
    success = CkPublicKeyW_LoadFromString(pubKey1,CkStringBuilderW_getAsString(sbPem));
    if (success == FALSE) {
        wprintf(L"%s\n",CkPublicKeyW_lastErrorText(pubKey1));
        CkStringBuilderW_Dispose(sbPem);
        CkPublicKeyW_Dispose(pubKey1);
        return;
    }

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

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

    // We'll need to convert hex to base64..
    bdKey = CkBinDataW_Create();
    CkBinDataW_AppendEncoded(bdKey,CkStringBuilderW_getAsString(sbHex),L"hex");

    pubKey2 = CkPublicKeyW_Create();
    success = CkPublicKeyW_LoadFromString(pubKey2,CkBinDataW_getEncoded(bdKey,L"base64"));
    if (success == FALSE) {
        wprintf(L"%s\n",CkPublicKeyW_lastErrorText(pubKey2));
        CkStringBuilderW_Dispose(sbPem);
        CkPublicKeyW_Dispose(pubKey1);
        CkStringBuilderW_Dispose(sbHex);
        CkBinDataW_Dispose(bdKey);
        CkPublicKeyW_Dispose(pubKey2);
        return;
    }

    // Let's get the key in pubKey2 as PEM.
    // It should be idential to the PEM above.
    wprintf(L"%s\n",CkPublicKeyW_getPem(pubKey2,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-----


    CkStringBuilderW_Dispose(sbPem);
    CkPublicKeyW_Dispose(pubKey1);
    CkStringBuilderW_Dispose(sbHex);
    CkBinDataW_Dispose(bdKey);
    CkPublicKeyW_Dispose(pubKey2);

    }