(PowerBuilder) How to Generate an Elliptic Curve Shared Secret

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.

Note: This example requires Chilkat v11.0.0 or greater.

Chilkat ActiveX Downloads ActiveX for 32-bit and 64-bit Windows

integer li_rc
integer li_Success
oleobject loo_PrngClient
oleobject loo_EccClient
oleobject loo_PrivKeyClient
oleobject loo_PubKeyClient
oleobject loo_PrngServer
oleobject loo_EccServer
oleobject loo_PrivKeyServer
oleobject loo_PubKeyServer
oleobject loo_PubKeyFromServer
string ls_SharedSecret1
oleobject loo_PubKeyFromClient
string ls_SharedSecret2

// 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.
// -----------------------------------------------------------------
loo_PrngClient = create oleobject
li_rc = loo_PrngClient.ConnectToNewObject("Chilkat.Prng")
if li_rc < 0 then
    destroy loo_PrngClient
    MessageBox("Error","Connecting to COM object failed")
    return
end if
loo_EccClient = create oleobject
li_rc = loo_EccClient.ConnectToNewObject("Chilkat.Ecc")

loo_PrivKeyClient = create oleobject
li_rc = loo_PrivKeyClient.ConnectToNewObject("Chilkat.PrivateKey")

li_Success = loo_EccClient.GenKey("secp256r1",loo_PrngClient,loo_PrivKeyClient)
if li_Success = 0 then
    Write-Debug loo_EccClient.LastErrorText
    destroy loo_PrngClient
    destroy loo_EccClient
    destroy loo_PrivKeyClient
    return
end if

loo_PubKeyClient = create oleobject
li_rc = loo_PubKeyClient.ConnectToNewObject("Chilkat.PublicKey")

loo_PrivKeyClient.ToPublicKey(loo_PubKeyClient)
loo_PubKeyClient.SavePemFile(0,"qa_output/eccClientPub.pem")

// -----------------------------------------------------------------
// (Server-Side) Generate an ECC key, save the public part to a file.
// -----------------------------------------------------------------
loo_PrngServer = create oleobject
li_rc = loo_PrngServer.ConnectToNewObject("Chilkat.Prng")

loo_EccServer = create oleobject
li_rc = loo_EccServer.ConnectToNewObject("Chilkat.Ecc")

loo_PrivKeyServer = create oleobject
li_rc = loo_PrivKeyServer.ConnectToNewObject("Chilkat.PrivateKey")

loo_EccServer.GenKey("secp256r1",loo_PrngServer,loo_PrivKeyServer)

loo_PubKeyServer = create oleobject
li_rc = loo_PubKeyServer.ConnectToNewObject("Chilkat.PublicKey")

loo_PrivKeyServer.ToPublicKey(loo_PubKeyServer)
loo_PubKeyServer.SavePemFile(0,"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.
loo_PubKeyFromServer = create oleobject
li_rc = loo_PubKeyFromServer.ConnectToNewObject("Chilkat.PublicKey")

loo_PubKeyFromServer.LoadFromFile("qa_output/eccServerPub.pem")
ls_SharedSecret1 = loo_EccClient.SharedSecretENC(loo_PrivKeyClient,loo_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.
loo_PubKeyFromClient = create oleobject
li_rc = loo_PubKeyFromClient.ConnectToNewObject("Chilkat.PublicKey")

loo_PubKeyFromClient.LoadFromFile("qa_output/eccClientPub.pem")
ls_SharedSecret2 = loo_EccServer.SharedSecretENC(loo_PrivKeyServer,loo_PubKeyFromClient,"base64")

// ---------------------------------------------------------
// Examine the shared secrets.  They should be the same.
// Both sides now have a secret that only they know.
// ---------------------------------------------------------
Write-Debug ls_SharedSecret1
Write-Debug ls_SharedSecret2


destroy loo_PrngClient
destroy loo_EccClient
destroy loo_PrivKeyClient
destroy loo_PubKeyClient
destroy loo_PrngServer
destroy loo_EccServer
destroy loo_PrivKeyServer
destroy loo_PubKeyServer
destroy loo_PubKeyFromServer
destroy loo_PubKeyFromClient