edhoc 1.0.1 → 1.0.3

package/external/libedhoc/externals/mbedtls/programs/pkey/dh_server.c

@@ -0,0 +1,296 @@
+/*
+ *  Diffie-Hellman-Merkle key exchange (server side)
+ *
+ *  Copyright The Mbed TLS Contributors
+ *  SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+ */
+
+#include "mbedtls/build_info.h"
+
+#include "mbedtls/platform.h"
+/* md.h is included this early since MD_CAN_XXX macros are defined there. */
+#include "mbedtls/md.h"
+
+#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_DHM_C) && \
+    defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_NET_C) && \
+    defined(MBEDTLS_RSA_C) && defined(MBEDTLS_MD_CAN_SHA256) && \
+    defined(MBEDTLS_FS_IO) && defined(MBEDTLS_CTR_DRBG_C) && \
+    defined(MBEDTLS_MD_CAN_SHA1)
+#include "mbedtls/net_sockets.h"
+#include "mbedtls/aes.h"
+#include "mbedtls/dhm.h"
+#include "mbedtls/rsa.h"
+#include "mbedtls/sha1.h"
+#include "mbedtls/entropy.h"
+#include "mbedtls/ctr_drbg.h"
+
+#include <stdio.h>
+#include <string.h>
+#endif
+
+#define SERVER_PORT "11999"
+#define PLAINTEXT "==Hello there!=="
+
+#if !defined(MBEDTLS_AES_C) || !defined(MBEDTLS_DHM_C) ||     \
+    !defined(MBEDTLS_ENTROPY_C) || !defined(MBEDTLS_NET_C) ||  \
+    !defined(MBEDTLS_RSA_C) || !defined(MBEDTLS_MD_CAN_SHA256) ||    \
+    !defined(MBEDTLS_FS_IO) || !defined(MBEDTLS_CTR_DRBG_C) || \
+    !defined(MBEDTLS_SHA1_C)
+int main(void)
+{
+    mbedtls_printf("MBEDTLS_AES_C and/or MBEDTLS_DHM_C and/or MBEDTLS_ENTROPY_C "
+                   "and/or MBEDTLS_NET_C and/or MBEDTLS_RSA_C and/or "
+                   "MBEDTLS_MD_CAN_SHA256 and/or MBEDTLS_FS_IO and/or "
+                   "MBEDTLS_CTR_DRBG_C and/or MBEDTLS_SHA1_C not defined.\n");
+    mbedtls_exit(0);
+}
+#else
+
+
+int main(void)
+{
+    FILE *f;
+
+    int ret = 1;
+    int exit_code = MBEDTLS_EXIT_FAILURE;
+    size_t n, buflen;
+    mbedtls_net_context listen_fd, client_fd;
+
+    unsigned char buf[2048];
+    unsigned char hash[32];
+    unsigned char buf2[2];
+    const char *pers = "dh_server";
+
+    mbedtls_entropy_context entropy;
+    mbedtls_ctr_drbg_context ctr_drbg;
+    mbedtls_rsa_context rsa;
+    mbedtls_dhm_context dhm;
+    mbedtls_aes_context aes;
+
+    mbedtls_mpi N, P, Q, D, E;
+
+    mbedtls_net_init(&listen_fd);
+    mbedtls_net_init(&client_fd);
+    mbedtls_dhm_init(&dhm);
+    mbedtls_aes_init(&aes);
+    mbedtls_ctr_drbg_init(&ctr_drbg);
+
+    mbedtls_mpi_init(&N); mbedtls_mpi_init(&P); mbedtls_mpi_init(&Q);
+    mbedtls_mpi_init(&D); mbedtls_mpi_init(&E);
+
+    /*
+     * 1. Setup the RNG
+     */
+    mbedtls_printf("\n  . Seeding the random number generator");
+    fflush(stdout);
+
+    mbedtls_entropy_init(&entropy);
+    if ((ret = mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy,
+                                     (const unsigned char *) pers,
+                                     strlen(pers))) != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_ctr_drbg_seed returned %d\n", ret);
+        goto exit;
+    }
+
+    /*
+     * 2a. Read the server's private RSA key
+     */
+    mbedtls_printf("\n  . Reading private key from rsa_priv.txt");
+    fflush(stdout);
+
+    if ((f = fopen("rsa_priv.txt", "rb")) == NULL) {
+        mbedtls_printf(" failed\n  ! Could not open rsa_priv.txt\n" \
+                       "  ! Please run rsa_genkey first\n\n");
+        goto exit;
+    }
+
+    mbedtls_rsa_init(&rsa);
+
+    if ((ret = mbedtls_mpi_read_file(&N, 16, f)) != 0 ||
+        (ret = mbedtls_mpi_read_file(&E, 16, f)) != 0 ||
+        (ret = mbedtls_mpi_read_file(&D, 16, f)) != 0 ||
+        (ret = mbedtls_mpi_read_file(&P, 16, f)) != 0 ||
+        (ret = mbedtls_mpi_read_file(&Q, 16, f)) != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_mpi_read_file returned %d\n\n",
+                       ret);
+        fclose(f);
+        goto exit;
+    }
+    fclose(f);
+
+    if ((ret = mbedtls_rsa_import(&rsa, &N, &P, &Q, &D, &E)) != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_rsa_import returned %d\n\n",
+                       ret);
+        goto exit;
+    }
+
+    if ((ret = mbedtls_rsa_complete(&rsa)) != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_rsa_complete returned %d\n\n",
+                       ret);
+        goto exit;
+    }
+
+    /*
+     * 2b. Get the DHM modulus and generator
+     */
+    mbedtls_printf("\n  . Reading DH parameters from dh_prime.txt");
+    fflush(stdout);
+
+    if ((f = fopen("dh_prime.txt", "rb")) == NULL) {
+        mbedtls_printf(" failed\n  ! Could not open dh_prime.txt\n" \
+                       "  ! Please run dh_genprime first\n\n");
+        goto exit;
+    }
+
+    if (mbedtls_mpi_read_file(&dhm.MBEDTLS_PRIVATE(P), 16, f) != 0 ||
+        mbedtls_mpi_read_file(&dhm.MBEDTLS_PRIVATE(G), 16, f) != 0) {
+        mbedtls_printf(" failed\n  ! Invalid DH parameter file\n\n");
+        fclose(f);
+        goto exit;
+    }
+
+    fclose(f);
+
+    /*
+     * 3. Wait for a client to connect
+     */
+    mbedtls_printf("\n  . Waiting for a remote connection");
+    fflush(stdout);
+
+    if ((ret = mbedtls_net_bind(&listen_fd, NULL, SERVER_PORT, MBEDTLS_NET_PROTO_TCP)) != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_net_bind returned %d\n\n", ret);
+        goto exit;
+    }
+
+    if ((ret = mbedtls_net_accept(&listen_fd, &client_fd,
+                                  NULL, 0, NULL)) != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_net_accept returned %d\n\n", ret);
+        goto exit;
+    }
+
+    /*
+     * 4. Setup the DH parameters (P,G,Ys)
+     */
+    mbedtls_printf("\n  . Sending the server's DH parameters");
+    fflush(stdout);
+
+    memset(buf, 0, sizeof(buf));
+
+    if ((ret =
+             mbedtls_dhm_make_params(&dhm, (int) mbedtls_mpi_size(&dhm.MBEDTLS_PRIVATE(P)), buf, &n,
+                                     mbedtls_ctr_drbg_random, &ctr_drbg)) != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_dhm_make_params returned %d\n\n", ret);
+        goto exit;
+    }
+
+    /*
+     * 5. Sign the parameters and send them
+     */
+    if ((ret = mbedtls_sha1(buf, n, hash)) != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_sha1 returned %d\n\n", ret);
+        goto exit;
+    }
+
+    buf[n] = (unsigned char) (rsa.MBEDTLS_PRIVATE(len) >> 8);
+    buf[n + 1] = (unsigned char) (rsa.MBEDTLS_PRIVATE(len));
+
+    if ((ret = mbedtls_rsa_pkcs1_sign(&rsa, NULL, NULL, MBEDTLS_MD_SHA256,
+                                      32, hash, buf + n + 2)) != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_rsa_pkcs1_sign returned %d\n\n", ret);
+        goto exit;
+    }
+
+    buflen = n + 2 + rsa.MBEDTLS_PRIVATE(len);
+    buf2[0] = (unsigned char) (buflen >> 8);
+    buf2[1] = (unsigned char) (buflen);
+
+    if ((ret = mbedtls_net_send(&client_fd, buf2, 2)) != 2 ||
+        (ret = mbedtls_net_send(&client_fd, buf, buflen)) != (int) buflen) {
+        mbedtls_printf(" failed\n  ! mbedtls_net_send returned %d\n\n", ret);
+        goto exit;
+    }
+
+    /*
+     * 6. Get the client's public value: Yc = G ^ Xc mod P
+     */
+    mbedtls_printf("\n  . Receiving the client's public value");
+    fflush(stdout);
+
+    memset(buf, 0, sizeof(buf));
+
+    n = mbedtls_dhm_get_len(&dhm);
+    if ((ret = mbedtls_net_recv(&client_fd, buf, n)) != (int) n) {
+        mbedtls_printf(" failed\n  ! mbedtls_net_recv returned %d\n\n", ret);
+        goto exit;
+    }
+
+    if ((ret = mbedtls_dhm_read_public(&dhm, buf, n)) != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_dhm_read_public returned %d\n\n", ret);
+        goto exit;
+    }
+
+    /*
+     * 7. Derive the shared secret: K = Ys ^ Xc mod P
+     */
+    mbedtls_printf("\n  . Shared secret: ");
+    fflush(stdout);
+
+    if ((ret = mbedtls_dhm_calc_secret(&dhm, buf, sizeof(buf), &n,
+                                       mbedtls_ctr_drbg_random, &ctr_drbg)) != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_dhm_calc_secret returned %d\n\n", ret);
+        goto exit;
+    }
+
+    for (n = 0; n < 16; n++) {
+        mbedtls_printf("%02x", buf[n]);
+    }
+
+    /*
+     * 8. Setup the AES-256 encryption key
+     *
+     * This is an overly simplified example; best practice is
+     * to hash the shared secret with a random value to derive
+     * the keying material for the encryption/decryption keys
+     * and MACs.
+     */
+    mbedtls_printf("...\n  . Encrypting and sending the ciphertext");
+    fflush(stdout);
+
+    ret = mbedtls_aes_setkey_enc(&aes, buf, 256);
+    if (ret != 0) {
+        goto exit;
+    }
+    memcpy(buf, PLAINTEXT, 16);
+    ret = mbedtls_aes_crypt_ecb(&aes, MBEDTLS_AES_ENCRYPT, buf, buf);
+    if (ret != 0) {
+        goto exit;
+    }
+
+    if ((ret = mbedtls_net_send(&client_fd, buf, 16)) != 16) {
+        mbedtls_printf(" failed\n  ! mbedtls_net_send returned %d\n\n", ret);
+        goto exit;
+    }
+
+    mbedtls_printf("\n\n");
+
+    exit_code = MBEDTLS_EXIT_SUCCESS;
+
+exit:
+
+    mbedtls_mpi_free(&N); mbedtls_mpi_free(&P); mbedtls_mpi_free(&Q);
+    mbedtls_mpi_free(&D); mbedtls_mpi_free(&E);
+
+    mbedtls_net_free(&client_fd);
+    mbedtls_net_free(&listen_fd);
+
+    mbedtls_aes_free(&aes);
+    mbedtls_rsa_free(&rsa);
+    mbedtls_dhm_free(&dhm);
+    mbedtls_ctr_drbg_free(&ctr_drbg);
+    mbedtls_entropy_free(&entropy);
+
+    mbedtls_exit(exit_code);
+}
+#endif /* MBEDTLS_AES_C && MBEDTLS_DHM_C && MBEDTLS_ENTROPY_C &&
+          MBEDTLS_NET_C && MBEDTLS_RSA_C && MBEDTLS_MD_CAN_SHA256 &&
+          MBEDTLS_FS_IO && MBEDTLS_CTR_DRBG_C */

package/external/libedhoc/externals/mbedtls/programs/pkey/ecdh_curve25519.c

@@ -0,0 +1,189 @@
+/*
+ *  Example ECDHE with Curve25519 program
+ *
+ *  Copyright The Mbed TLS Contributors
+ *  SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+ */
+
+#include "mbedtls/build_info.h"
+
+#include "mbedtls/platform.h"
+
+#if !defined(MBEDTLS_ECDH_C) || \
+    !defined(MBEDTLS_ECP_DP_CURVE25519_ENABLED) || \
+    !defined(MBEDTLS_ENTROPY_C) || !defined(MBEDTLS_CTR_DRBG_C)
+int main(void)
+{
+    mbedtls_printf("MBEDTLS_ECDH_C and/or "
+                   "MBEDTLS_ECP_DP_CURVE25519_ENABLED and/or "
+                   "MBEDTLS_ENTROPY_C and/or MBEDTLS_CTR_DRBG_C "
+                   "not defined\n");
+    mbedtls_exit(0);
+}
+#else
+
+#include "mbedtls/entropy.h"
+#include "mbedtls/ctr_drbg.h"
+#include "mbedtls/ecdh.h"
+
+#include <string.h>
+
+
+int main(int argc, char *argv[])
+{
+    int ret = 1;
+    int exit_code = MBEDTLS_EXIT_FAILURE;
+    mbedtls_ecdh_context ctx_cli, ctx_srv;
+    mbedtls_entropy_context entropy;
+    mbedtls_ctr_drbg_context ctr_drbg;
+    unsigned char cli_to_srv[36], srv_to_cli[33];
+    const char pers[] = "ecdh";
+
+    size_t srv_olen;
+    size_t cli_olen;
+    unsigned char secret_cli[32] = { 0 };
+    unsigned char secret_srv[32] = { 0 };
+    const unsigned char *p_cli_to_srv = cli_to_srv;
+
+    ((void) argc);
+    ((void) argv);
+
+    mbedtls_ecdh_init(&ctx_cli);
+    mbedtls_ecdh_init(&ctx_srv);
+    mbedtls_ctr_drbg_init(&ctr_drbg);
+
+    /*
+     * Initialize random number generation
+     */
+    mbedtls_printf("  . Seed the random number generator...");
+    fflush(stdout);
+
+    mbedtls_entropy_init(&entropy);
+    if ((ret = mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func,
+                                     &entropy,
+                                     (const unsigned char *) pers,
+                                     sizeof(pers))) != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_ctr_drbg_seed returned %d\n",
+                       ret);
+        goto exit;
+    }
+
+    mbedtls_printf(" ok\n");
+
+    /*
+     * Client: initialize context and generate keypair
+     */
+    mbedtls_printf("  . Set up client context, generate EC key pair...");
+    fflush(stdout);
+
+    ret = mbedtls_ecdh_setup(&ctx_cli, MBEDTLS_ECP_DP_CURVE25519);
+    if (ret != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_ecdh_setup returned %d\n", ret);
+        goto exit;
+    }
+
+    ret = mbedtls_ecdh_make_params(&ctx_cli, &cli_olen, cli_to_srv,
+                                   sizeof(cli_to_srv),
+                                   mbedtls_ctr_drbg_random, &ctr_drbg);
+    if (ret != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_ecdh_make_params returned %d\n",
+                       ret);
+        goto exit;
+    }
+
+    mbedtls_printf(" ok\n");
+
+    /*
+     * Server: initialize context and generate keypair
+     */
+    mbedtls_printf("  . Server: read params, generate public key...");
+    fflush(stdout);
+
+    ret = mbedtls_ecdh_read_params(&ctx_srv, &p_cli_to_srv,
+                                   p_cli_to_srv + sizeof(cli_to_srv));
+    if (ret != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_ecdh_read_params returned %d\n",
+                       ret);
+        goto exit;
+    }
+
+    ret = mbedtls_ecdh_make_public(&ctx_srv, &srv_olen, srv_to_cli,
+                                   sizeof(srv_to_cli),
+                                   mbedtls_ctr_drbg_random, &ctr_drbg);
+    if (ret != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_ecdh_make_public returned %d\n",
+                       ret);
+        goto exit;
+    }
+
+    mbedtls_printf(" ok\n");
+
+    /*
+     * Client: read public key
+     */
+    mbedtls_printf("  . Client: read public key...");
+    fflush(stdout);
+
+    ret = mbedtls_ecdh_read_public(&ctx_cli, srv_to_cli,
+                                   sizeof(srv_to_cli));
+    if (ret != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_ecdh_read_public returned %d\n",
+                       ret);
+        goto exit;
+    }
+
+    mbedtls_printf(" ok\n");
+
+    /*
+     * Calculate secrets
+     */
+    mbedtls_printf("  . Calculate secrets...");
+    fflush(stdout);
+
+    ret = mbedtls_ecdh_calc_secret(&ctx_cli, &cli_olen, secret_cli,
+                                   sizeof(secret_cli),
+                                   mbedtls_ctr_drbg_random, &ctr_drbg);
+    if (ret != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_ecdh_calc_secret returned %d\n",
+                       ret);
+        goto exit;
+    }
+
+    ret = mbedtls_ecdh_calc_secret(&ctx_srv, &srv_olen, secret_srv,
+                                   sizeof(secret_srv),
+                                   mbedtls_ctr_drbg_random, &ctr_drbg);
+    if (ret != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_ecdh_calc_secret returned %d\n",
+                       ret);
+        goto exit;
+    }
+
+    mbedtls_printf(" ok\n");
+
+    /*
+     * Verification: are the computed secrets equal?
+     */
+    mbedtls_printf("  . Check if both calculated secrets are equal...");
+    fflush(stdout);
+
+    ret = memcmp(secret_srv, secret_cli, srv_olen);
+    if (ret != 0 || (cli_olen != srv_olen)) {
+        mbedtls_printf(" failed\n  ! Shared secrets not equal.\n");
+        goto exit;
+    }
+
+    mbedtls_printf(" ok\n");
+
+    exit_code = MBEDTLS_EXIT_SUCCESS;
+
+exit:
+
+    mbedtls_ecdh_free(&ctx_srv);
+    mbedtls_ecdh_free(&ctx_cli);
+    mbedtls_ctr_drbg_free(&ctr_drbg);
+    mbedtls_entropy_free(&entropy);
+
+    mbedtls_exit(exit_code);
+}
+#endif /* MBEDTLS_ECDH_C && MBEDTLS_ECP_DP_CURVE25519_ENABLED &&
+          MBEDTLS_ENTROPY_C && MBEDTLS_CTR_DRBG_C */

package/external/libedhoc/externals/mbedtls/programs/pkey/ecdsa.c

@@ -0,0 +1,217 @@
+/*
+ *  Example ECDSA program
+ *
+ *  Copyright The Mbed TLS Contributors
+ *  SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+ */
+
+#include "mbedtls/build_info.h"
+
+#include "mbedtls/platform.h"
+
+#if defined(MBEDTLS_ECDSA_C) && \
+    defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_CTR_DRBG_C)
+#include "mbedtls/entropy.h"
+#include "mbedtls/ctr_drbg.h"
+#include "mbedtls/ecdsa.h"
+#include "mbedtls/sha256.h"
+
+#include <string.h>
+#endif
+
+/*
+ * Uncomment to show key and signature details
+ */
+#define VERBOSE
+
+/*
+ * Uncomment to force use of a specific curve
+ */
+#define ECPARAMS    MBEDTLS_ECP_DP_SECP192R1
+
+#if !defined(ECPARAMS)
+#define ECPARAMS    mbedtls_ecp_curve_list()->grp_id
+#endif
+
+#if !defined(MBEDTLS_ECDSA_C) || !defined(MBEDTLS_SHA256_C) || \
+    !defined(MBEDTLS_ENTROPY_C) || !defined(MBEDTLS_CTR_DRBG_C)
+int main(void)
+{
+    mbedtls_printf("MBEDTLS_ECDSA_C and/or MBEDTLS_SHA256_C and/or "
+                   "MBEDTLS_ENTROPY_C and/or MBEDTLS_CTR_DRBG_C not defined\n");
+    mbedtls_exit(0);
+}
+#else
+#if defined(VERBOSE)
+static void dump_buf(const char *title, unsigned char *buf, size_t len)
+{
+    size_t i;
+
+    mbedtls_printf("%s", title);
+    for (i = 0; i < len; i++) {
+        mbedtls_printf("%c%c", "0123456789ABCDEF" [buf[i] / 16],
+                       "0123456789ABCDEF" [buf[i] % 16]);
+    }
+    mbedtls_printf("\n");
+}
+
+static void dump_pubkey(const char *title, mbedtls_ecdsa_context *key)
+{
+    unsigned char buf[300];
+    size_t len;
+
+    if (mbedtls_ecp_point_write_binary(&key->MBEDTLS_PRIVATE(grp), &key->MBEDTLS_PRIVATE(Q),
+                                       MBEDTLS_ECP_PF_UNCOMPRESSED, &len, buf, sizeof(buf)) != 0) {
+        mbedtls_printf("internal error\n");
+        return;
+    }
+
+    dump_buf(title, buf, len);
+}
+#else
+#define dump_buf(a, b, c)
+#define dump_pubkey(a, b)
+#endif
+
+
+int main(int argc, char *argv[])
+{
+    int ret = 1;
+    int exit_code = MBEDTLS_EXIT_FAILURE;
+    mbedtls_ecdsa_context ctx_sign, ctx_verify;
+    mbedtls_entropy_context entropy;
+    mbedtls_ctr_drbg_context ctr_drbg;
+    unsigned char message[100];
+    unsigned char hash[32];
+    unsigned char sig[MBEDTLS_ECDSA_MAX_LEN];
+    size_t sig_len;
+    const char *pers = "ecdsa";
+    ((void) argv);
+
+    mbedtls_ecdsa_init(&ctx_sign);
+    mbedtls_ecdsa_init(&ctx_verify);
+    mbedtls_ctr_drbg_init(&ctr_drbg);
+
+    memset(sig, 0, sizeof(sig));
+    memset(message, 0x25, sizeof(message));
+
+    if (argc != 1) {
+        mbedtls_printf("usage: ecdsa\n");
+
+#if defined(_WIN32)
+        mbedtls_printf("\n");
+#endif
+
+        goto exit;
+    }
+
+    /*
+     * Generate a key pair for signing
+     */
+    mbedtls_printf("\n  . Seeding the random number generator...");
+    fflush(stdout);
+
+    mbedtls_entropy_init(&entropy);
+    if ((ret = mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy,
+                                     (const unsigned char *) pers,
+                                     strlen(pers))) != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_ctr_drbg_seed returned %d\n", ret);
+        goto exit;
+    }
+
+    mbedtls_printf(" ok\n  . Generating key pair...");
+    fflush(stdout);
+
+    if ((ret = mbedtls_ecdsa_genkey(&ctx_sign, ECPARAMS,
+                                    mbedtls_ctr_drbg_random, &ctr_drbg)) != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_ecdsa_genkey returned %d\n", ret);
+        goto exit;
+    }
+
+    mbedtls_printf(" ok (key size: %d bits)\n", (int) ctx_sign.MBEDTLS_PRIVATE(grp).pbits);
+
+    dump_pubkey("  + Public key: ", &ctx_sign);
+
+    /*
+     * Compute message hash
+     */
+    mbedtls_printf("  . Computing message hash...");
+    fflush(stdout);
+
+    if ((ret = mbedtls_sha256(message, sizeof(message), hash, 0)) != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_sha256 returned %d\n", ret);
+        goto exit;
+    }
+
+    mbedtls_printf(" ok\n");
+
+    dump_buf("  + Hash: ", hash, sizeof(hash));
+
+    /*
+     * Sign message hash
+     */
+    mbedtls_printf("  . Signing message hash...");
+    fflush(stdout);
+
+    if ((ret = mbedtls_ecdsa_write_signature(&ctx_sign, MBEDTLS_MD_SHA256,
+                                             hash, sizeof(hash),
+                                             sig, sizeof(sig), &sig_len,
+                                             mbedtls_ctr_drbg_random, &ctr_drbg)) != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_ecdsa_write_signature returned %d\n", ret);
+        goto exit;
+    }
+    mbedtls_printf(" ok (signature length = %u)\n", (unsigned int) sig_len);
+
+    dump_buf("  + Signature: ", sig, sig_len);
+
+    /*
+     * Transfer public information to verifying context
+     *
+     * We could use the same context for verification and signatures, but we
+     * chose to use a new one in order to make it clear that the verifying
+     * context only needs the public key (Q), and not the private key (d).
+     */
+    mbedtls_printf("  . Preparing verification context...");
+    fflush(stdout);
+
+    if ((ret =
+             mbedtls_ecp_group_copy(&ctx_verify.MBEDTLS_PRIVATE(grp),
+                                    &ctx_sign.MBEDTLS_PRIVATE(grp))) != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_ecp_group_copy returned %d\n", ret);
+        goto exit;
+    }
+
+    if ((ret =
+             mbedtls_ecp_copy(&ctx_verify.MBEDTLS_PRIVATE(Q), &ctx_sign.MBEDTLS_PRIVATE(Q))) != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_ecp_copy returned %d\n", ret);
+        goto exit;
+    }
+
+    /*
+     * Verify signature
+     */
+    mbedtls_printf(" ok\n  . Verifying signature...");
+    fflush(stdout);
+
+    if ((ret = mbedtls_ecdsa_read_signature(&ctx_verify,
+                                            hash, sizeof(hash),
+                                            sig, sig_len)) != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_ecdsa_read_signature returned %d\n", ret);
+        goto exit;
+    }
+
+    mbedtls_printf(" ok\n");
+
+    exit_code = MBEDTLS_EXIT_SUCCESS;
+
+exit:
+
+    mbedtls_ecdsa_free(&ctx_verify);
+    mbedtls_ecdsa_free(&ctx_sign);
+    mbedtls_ctr_drbg_free(&ctr_drbg);
+    mbedtls_entropy_free(&entropy);
+
+    mbedtls_exit(exit_code);
+}
+#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ENTROPY_C && MBEDTLS_CTR_DRBG_C &&
+          ECPARAMS */