One key creates it.
Only one key opens it.

use secp256k1::{Secp256k1, SecretKey, PublicKey};

// G is the generator. Private key k gives public key k*G.
fn explore_key_relationship() {
    let secp = Secp256k1::new();

    // Private key 1: the simplest possible. Never use for real Bitcoin.
    let mut one = [0u8; 32];
    one[31] = 1;
    let privkey_one = SecretKey::from_slice(&one).unwrap();

    // Public key for k=1 is G itself, the generator point.
    let pubkey_one = PublicKey::from_secret_key(&secp, &privkey_one);
    println!("k=1 public key (=G): {:02x?}", &pubkey_one.serialize()[..4]);

    // Private key 2: public key is 2*G = G + G (point doubling).
    let mut two = [0u8; 32];
    two[31] = 2;
    let privkey_two = SecretKey::from_slice(&two).unwrap();
    let pubkey_two  = PublicKey::from_secret_key(&secp, &privkey_two);
    println!("k=2 public key (=2G): {:02x?}", &pubkey_two.serialize()[..4]);
    // 2G looks unrelated to G. Adding G to itself produces a
    // mathematically related but visually unrelated point.
}

// ECDH: two parties derive the same shared secret
// without ever transmitting it.
// Used in TLS for every HTTPS connection,
// and in Bitcoin stealth addresses.
fn ecdh_demo() {
    use secp256k1::ecdh::SharedSecret;
    use secp256k1::rand::rngs::OsRng;

    let secp = Secp256k1::new();
    let (alice_priv, alice_pub) = secp.generate_keypair(&mut OsRng);
    let (bob_priv,   bob_pub)   = secp.generate_keypair(&mut OsRng);

    // Alice: a * B = a*(b*G) = (a*b)*G
    // Bob:   b * A = b*(a*G) = (a*b)*G
    let alice_shared = SharedSecret::new(&bob_pub,   &alice_priv);
    let bob_shared   = SharedSecret::new(&alice_pub, &bob_priv);

    assert_eq!(alice_shared.as_ref(), bob_shared.as_ref());
    println!("Shared secret established without transmitting it.");
    // An eavesdropper saw A and B but cannot compute (a*b)*G.
}

/* Compile: gcc keys.c -o keys -lssl -lcrypto */
#include <openssl/ec.h>
#include <openssl/bn.h>
#include <openssl/ecdh.h>
#include <openssl/obj_mac.h>
#include <stdint.h>
#include <string.h>
#include <stdio.h>

/* public_key = private_key * G.
 * Forward: O(log k) steps. Reverse: O(2^128). */
void explore_key_relationship(void) {
    EC_GROUP *group = EC_GROUP_new_by_curve_name(NID_secp256k1);
    BN_CTX   *ctx   = BN_CTX_new();
    BIGNUM   *k     = BN_new();
    EC_POINT *pub   = EC_POINT_new(group);
    uint8_t   compressed[33];

    /* k = 1: public key is G itself */
    BN_set_word(k, 1);
    EC_POINT_mul(group, pub, k, NULL, NULL, ctx);
    EC_POINT_point2oct(group, pub, POINT_CONVERSION_COMPRESSED,
                       compressed, 33, ctx);
    printf("k=1 public key prefix: %02x\n", compressed[0]);
    /* These 33 bytes are the generator point G. */

    /* k = 2: public key is G + G = 2G */
    BN_set_word(k, 2);
    EC_POINT_mul(group, pub, k, NULL, NULL, ctx);
    EC_POINT_point2oct(group, pub, POINT_CONVERSION_COMPRESSED,
                       compressed, 33, ctx);
    printf("k=2 public key prefix: %02x\n", compressed[0]);
    /* Different x coordinate. Visually unrelated to G. */

    BN_free(k);
    EC_POINT_free(pub);
    BN_CTX_free(ctx);
    EC_GROUP_free(group);
}

/* ECDH: shared secret derivation.
 * Used in TLS and Bitcoin stealth addresses. */
void ecdh_demo(void) {
    EC_GROUP *group = EC_GROUP_new_by_curve_name(NID_secp256k1);

    EC_KEY *alice = EC_KEY_new();
    EC_KEY_set_group(alice, group);
    EC_KEY_generate_key(alice);

    EC_KEY *bob = EC_KEY_new();
    EC_KEY_set_group(bob, group);
    EC_KEY_generate_key(bob);

    uint8_t alice_secret[32], bob_secret[32];
    ECDH_compute_key(alice_secret, 32,
                     EC_KEY_get0_public_key(bob), alice, NULL);
    ECDH_compute_key(bob_secret, 32,
                     EC_KEY_get0_public_key(alice), bob, NULL);

    printf("Secrets match: %d\n",
           memcmp(alice_secret, bob_secret, 32) == 0); /* 1 */

    EC_KEY_free(alice);
    EC_KEY_free(bob);
    EC_GROUP_free(group);
}