(Ruby) 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.

Chilkat Ruby Downloads Ruby Library for Linux and MAC OS X

require 'chilkat'

#  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 = Chilkat::CkPrng.new()
eccClient = Chilkat::CkEcc.new()
# privKeyClient is a CkPrivateKey
privKeyClient = eccClient.GenEccKey("secp256r1",prngClient)
if (eccClient.get_LastMethodSuccess() != true)
    print eccClient.lastErrorText() + "\n";
    exit
end

# pubKeyClient is a CkPublicKey
pubKeyClient = privKeyClient.GetPublicKey()
pubKeyClient.SavePemFile(false,"qa_output/eccClientPub.pem")

#  -----------------------------------------------------------------
#  (Server-Side) Generate an ECC key, save the public part to a file.
#  -----------------------------------------------------------------
prngServer = Chilkat::CkPrng.new()
eccServer = Chilkat::CkEcc.new()
# privKeyServer is a CkPrivateKey
privKeyServer = eccServer.GenEccKey("secp256r1",prngServer)
if (eccServer.get_LastMethodSuccess() != true)
    print eccServer.lastErrorText() + "\n";
    exit
end

# pubKeyServer is a CkPublicKey
pubKeyServer = privKeyServer.GetPublicKey()
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 = Chilkat::CkPublicKey.new()
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 = Chilkat::CkPublicKey.new()
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.
#  ---------------------------------------------------------
print sharedSecret1 + "\n";
print sharedSecret2 + "\n";