1 /*************************************************************************
2 * Written in 2020-2022 by Elichai Turkel *
3 * To the extent possible under law, the author(s) have dedicated all *
4 * copyright and related and neighboring rights to the software in this *
5 * file to the public domain worldwide. This software is distributed *
6 * without any warranty. For the CC0 Public Domain Dedication, see *
7 * EXAMPLES_COPYING or https://creativecommons.org/publicdomain/zero/1.0 *
8 *************************************************************************/
9 10 #include <stdio.h>
11 #include <assert.h>
12 #include <string.h>
13 14 #include <secp256k1.h>
15 #include <secp256k1_ecdh.h>
16 17 #include "examples_util.h"
18 19 int main(void) {
20 unsigned char seckey1[32];
21 unsigned char seckey2[32];
22 unsigned char compressed_pubkey1[33];
23 unsigned char compressed_pubkey2[33];
24 unsigned char shared_secret1[32];
25 unsigned char shared_secret2[32];
26 unsigned char randomize[32];
27 int return_val;
28 size_t len;
29 secp256k1_pubkey pubkey1;
30 secp256k1_pubkey pubkey2;
31 32 /* Before we can call actual API functions, we need to create a "context". */
33 secp256k1_context* ctx = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
34 if (!fill_random(randomize, sizeof(randomize))) {
35 printf("Failed to generate randomness\n");
36 return 1;
37 }
38 /* Randomizing the context is recommended to protect against side-channel
39 * leakage See `secp256k1_context_randomize` in secp256k1.h for more
40 * information about it. This should never fail. */
41 return_val = secp256k1_context_randomize(ctx, randomize);
42 assert(return_val);
43 44 /*** Key Generation ***/
45 if (!fill_random(seckey1, sizeof(seckey1)) || !fill_random(seckey2, sizeof(seckey2))) {
46 printf("Failed to generate randomness\n");
47 return 1;
48 }
49 /* If the secret key is zero or out of range (greater than secp256k1's
50 * order), we fail. Note that the probability of this occurring is negligible
51 * with a properly functioning random number generator. */
52 if (!secp256k1_ec_seckey_verify(ctx, seckey1) || !secp256k1_ec_seckey_verify(ctx, seckey2)) {
53 printf("Generated secret key is invalid. This indicates an issue with the random number generator.\n");
54 return 1;
55 }
56 57 /* Public key creation using a valid context with a verified secret key should never fail */
58 return_val = secp256k1_ec_pubkey_create(ctx, &pubkey1, seckey1);
59 assert(return_val);
60 return_val = secp256k1_ec_pubkey_create(ctx, &pubkey2, seckey2);
61 assert(return_val);
62 63 /* Serialize pubkey1 in a compressed form (33 bytes), should always return 1 */
64 len = sizeof(compressed_pubkey1);
65 return_val = secp256k1_ec_pubkey_serialize(ctx, compressed_pubkey1, &len, &pubkey1, SECP256K1_EC_COMPRESSED);
66 assert(return_val);
67 /* Should be the same size as the size of the output, because we passed a 33 byte array. */
68 assert(len == sizeof(compressed_pubkey1));
69 70 /* Serialize pubkey2 in a compressed form (33 bytes) */
71 len = sizeof(compressed_pubkey2);
72 return_val = secp256k1_ec_pubkey_serialize(ctx, compressed_pubkey2, &len, &pubkey2, SECP256K1_EC_COMPRESSED);
73 assert(return_val);
74 /* Should be the same size as the size of the output, because we passed a 33 byte array. */
75 assert(len == sizeof(compressed_pubkey2));
76 77 /*** Creating the shared secret ***/
78 79 /* Perform ECDH with seckey1 and pubkey2. Should never fail with a verified
80 * seckey and valid pubkey */
81 return_val = secp256k1_ecdh(ctx, shared_secret1, &pubkey2, seckey1, NULL, NULL);
82 assert(return_val);
83 84 /* Perform ECDH with seckey2 and pubkey1. Should never fail with a verified
85 * seckey and valid pubkey */
86 return_val = secp256k1_ecdh(ctx, shared_secret2, &pubkey1, seckey2, NULL, NULL);
87 assert(return_val);
88 89 /* Both parties should end up with the same shared secret */
90 return_val = memcmp(shared_secret1, shared_secret2, sizeof(shared_secret1));
91 assert(return_val == 0);
92 93 printf("Secret Key1: ");
94 print_hex(seckey1, sizeof(seckey1));
95 printf("Compressed Pubkey1: ");
96 print_hex(compressed_pubkey1, sizeof(compressed_pubkey1));
97 printf("\nSecret Key2: ");
98 print_hex(seckey2, sizeof(seckey2));
99 printf("Compressed Pubkey2: ");
100 print_hex(compressed_pubkey2, sizeof(compressed_pubkey2));
101 printf("\nShared Secret: ");
102 print_hex(shared_secret1, sizeof(shared_secret1));
103 104 /* This will clear everything from the context and free the memory */
105 secp256k1_context_destroy(ctx);
106 107 /* It's best practice to try to clear secrets from memory after using them.
108 * This is done because some bugs can allow an attacker to leak memory, for
109 * example through "out of bounds" array access (see Heartbleed), or the OS
110 * swapping them to disk. Hence, we overwrite the secret key buffer with zeros.
111 *
112 * Here we are preventing these writes from being optimized out, as any good compiler
113 * will remove any writes that aren't used. */
114 secure_erase(seckey1, sizeof(seckey1));
115 secure_erase(seckey2, sizeof(seckey2));
116 secure_erase(shared_secret1, sizeof(shared_secret1));
117 secure_erase(shared_secret2, sizeof(shared_secret2));
118 119 return 0;
120 }
121