demos/signature/EVP_Signature_demo.c

   1 /*-
   2  * Copyright 2021 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 /*
  11  * An example that uses the EVP_MD*, EVP_DigestSign* and EVP_DigestVerify*
  12  * methods to calculate and verify a signature of two static buffers.
  13  */
  14
  15 #include <string.h>
  16 #include <stdio.h>
  17 #include <openssl/err.h>
  18 #include <openssl/evp.h>
  19 #include <openssl/decoder.h>
  20 #include "EVP_Signature_demo.h"
  21
  22 /*
  23  * This demonstration will calculate and verify a signature of data using
  24  * the soliloquy from Hamlet scene 1 act 3
  25  */
  26
  27 static const char *hamlet_1 =
  28     "To be, or not to be, that is the question,\n"
  29     "Whether tis nobler in the minde to suffer\n"
  30     "The slings and arrowes of outragious fortune,\n"
  31     "Or to take Armes again in a sea of troubles,\n"
  32 ;
  33 static const char *hamlet_2 =
  34     "And by opposing, end them, to die to sleep;\n"
  35     "No more, and by a sleep, to say we end\n"
  36     "The heart-ache, and the thousand natural shocks\n"
  37     "That flesh is heir to? tis a consumation\n"
  38 ;
  39
  40 /*
  41  * For demo_sign, load EC private key priv_key from priv_key_der[].
  42  * For demo_verify, load EC public key pub_key from pub_key_der[].
  43  */
  44 static EVP_PKEY *get_key(OSSL_LIB_CTX *libctx, const char *propq, int public)
  45 {
  46     OSSL_DECODER_CTX *dctx = NULL;
  47     EVP_PKEY  *pkey = NULL;
  48     int selection;
  49     const unsigned char *data;
  50     size_t data_len;
  51
  52     if (public) {
  53         selection = EVP_PKEY_PUBLIC_KEY;
  54         data =  pub_key_der;
  55         data_len = sizeof(pub_key_der);
  56     } else {
  57         selection =  EVP_PKEY_KEYPAIR;
  58         data = priv_key_der;
  59         data_len = sizeof(priv_key_der);
  60     }
  61     dctx = OSSL_DECODER_CTX_new_for_pkey(&pkey, "DER", NULL, "EC",
  62                                          selection, libctx, propq);
  63     (void)OSSL_DECODER_from_data(dctx, &data, &data_len);
  64     OSSL_DECODER_CTX_free(dctx);
  65     if (pkey == NULL)
  66         fprintf(stderr, "Failed to load %s key.\n", public ? "public" : "private");
  67     return pkey;
  68 }
  69
  70 static int demo_sign(OSSL_LIB_CTX *libctx,  const char *sig_name,
  71                      size_t *sig_out_len, unsigned char **sig_out_value)
  72 {
  73     int result = 0, public = 0;
  74     size_t sig_len;
  75     unsigned char *sig_value = NULL;
  76     const char *propq = NULL;
  77     EVP_MD_CTX *sign_context = NULL;
  78     EVP_PKEY *priv_key = NULL;
  79
  80     /* Get private key */
  81     priv_key = get_key(libctx, propq, public);
  82     if (priv_key == NULL) {
  83         fprintf(stderr, "Get private key failed.\n");
  84         goto cleanup;
  85     }
  86     /*
  87      * Make a message signature context to hold temporary state
  88      * during signature creation
  89      */
  90     sign_context = EVP_MD_CTX_new();
  91     if (sign_context == NULL) {
  92         fprintf(stderr, "EVP_MD_CTX_new failed.\n");
  93         goto cleanup;
  94     }
  95     /*
  96      * Initialize the sign context to use the fetched
  97      * sign provider.
  98      */
  99     if (!EVP_DigestSignInit_ex(sign_context, NULL, sig_name,
 100                               libctx, NULL, priv_key, NULL)) {
 101         fprintf(stderr, "EVP_DigestSignInit_ex failed.\n");
 102         goto cleanup;
 103     }
 104     /*
 105      * EVP_DigestSignUpdate() can be called several times on the same context
 106      * to include additional data.
 107      */
 108     if (!EVP_DigestSignUpdate(sign_context, hamlet_1, strlen(hamlet_1))) {
 109         fprintf(stderr, "EVP_DigestSignUpdate(hamlet_1) failed.\n");
 110         goto cleanup;
 111     }
 112     if (!EVP_DigestSignUpdate(sign_context, hamlet_2, strlen(hamlet_2))) {
 113         fprintf(stderr, "EVP_DigestSignUpdate(hamlet_2) failed.\n");
 114         goto cleanup;
 115     }
 116     /* Call EVP_DigestSignFinal to get signature length sig_len */
 117     if (!EVP_DigestSignFinal(sign_context, NULL, &sig_len)) {
 118         fprintf(stderr, "EVP_DigestSignFinal failed.\n");
 119         goto cleanup;
 120     }
 121     if (sig_len <= 0) {
 122         fprintf(stderr, "EVP_DigestSignFinal returned invalid signature length.\n");
 123         goto cleanup;
 124     }
 125     sig_value = OPENSSL_malloc(sig_len);
 126     if (sig_value == NULL) {
 127         fprintf(stderr, "No memory.\n");
 128         goto cleanup;
 129     }
 130     if (!EVP_DigestSignFinal(sign_context, sig_value, &sig_len)) {
 131         fprintf(stderr, "EVP_DigestSignFinal failed.\n");
 132         goto cleanup;
 133     }
 134     *sig_out_len = sig_len;
 135     *sig_out_value = sig_value;
 136     fprintf(stdout, "Generating signature:\n");
 137     BIO_dump_indent_fp(stdout, sig_value, sig_len, 2);
 138     fprintf(stdout, "\n");
 139     result = 1;
 140
 141 cleanup:
 142     /* OpenSSL free functions will ignore NULL arguments */
 143     if (!result)
 144         OPENSSL_free(sig_value);
 145     EVP_PKEY_free(priv_key);
 146     EVP_MD_CTX_free(sign_context);
 147     return result;
 148 }
 149
 150 static int demo_verify(OSSL_LIB_CTX *libctx, const char *sig_name,
 151                        size_t sig_len, unsigned char *sig_value)
 152 {
 153     int result = 0, public = 1;
 154     const char *propq = NULL;
 155     EVP_MD_CTX *verify_context = NULL;
 156     EVP_PKEY *pub_key = NULL;
 157
 158     /*
 159      * Make a verify signature context to hold temporary state
 160      * during signature verification
 161      */
 162     verify_context = EVP_MD_CTX_new();
 163     if (verify_context == NULL) {
 164         fprintf(stderr, "EVP_MD_CTX_new failed.\n");
 165         goto cleanup;
 166     }
 167     /* Get public key */
 168     pub_key = get_key(libctx, propq, public);
 169     if (pub_key == NULL) {
 170         fprintf(stderr, "Get public key failed.\n");
 171         goto cleanup;
 172     }
 173     /* Verify */
 174     if (!EVP_DigestVerifyInit_ex(verify_context, NULL, sig_name,
 175                                 libctx, NULL, pub_key, NULL)) {
 176         fprintf(stderr, "EVP_DigestVerifyInit failed.\n");
 177         goto cleanup;
 178     }
 179     /*
 180      * EVP_DigestVerifyUpdate() can be called several times on the same context
 181      * to include additional data.
 182      */
 183     if (!EVP_DigestVerifyUpdate(verify_context, hamlet_1, strlen(hamlet_1))) {
 184         fprintf(stderr, "EVP_DigestVerifyUpdate(hamlet_1) failed.\n");
 185         goto cleanup;
 186     }
 187     if (!EVP_DigestVerifyUpdate(verify_context, hamlet_2, strlen(hamlet_2))) {
 188         fprintf(stderr, "EVP_DigestVerifyUpdate(hamlet_2) failed.\n");
 189         goto cleanup;
 190     }
 191     if (EVP_DigestVerifyFinal(verify_context, sig_value, sig_len) <= 0) {
 192         fprintf(stderr, "EVP_DigestVerifyFinal failed.\n");
 193         goto cleanup;
 194     }
 195     fprintf(stdout, "Signature verified.\n");
 196     result = 1;
 197
 198 cleanup:
 199     /* OpenSSL free functions will ignore NULL arguments */
 200     EVP_PKEY_free(pub_key);
 201     EVP_MD_CTX_free(verify_context);
 202     return result;
 203 }
 204
 205 int main(void)
 206 {
 207     OSSL_LIB_CTX *libctx = NULL;
 208     const char *sig_name = "SHA3-512";
 209     size_t sig_len = 0;
 210     unsigned char *sig_value = NULL;
 211     int result = 0;
 212
 213     libctx = OSSL_LIB_CTX_new();
 214     if (libctx == NULL) {
 215         fprintf(stderr, "OSSL_LIB_CTX_new() returned NULL\n");
 216         goto cleanup;
 217     }
 218     if (!demo_sign(libctx, sig_name, &sig_len, &sig_value)) {
 219         fprintf(stderr, "demo_sign failed.\n");
 220         goto cleanup;
 221     }
 222     if (!demo_verify(libctx, sig_name, sig_len, sig_value)) {
 223         fprintf(stderr, "demo_verify failed.\n");
 224         goto cleanup;
 225     }
 226     result = 1;
 227
 228 cleanup:
 229     if (result != 1)
 230         ERR_print_errors_fp(stderr);
 231     /* OpenSSL free functions will ignore NULL arguments */
 232     OSSL_LIB_CTX_free(libctx);
 233     OPENSSL_free(sig_value);
 234     return result == 0;
 235 }