src/valgrind_ctime_test.c

   1 /***********************************************************************
   2  * Copyright (c) 2020 Gregory Maxwell                                  *
   3  * Distributed under the MIT software license, see the accompanying    *
   4  * file COPYING or https://www.opensource.org/licenses/mit-license.php.*
   5  ***********************************************************************/
   6
   7 #include <valgrind/memcheck.h>
   8 #include <stdio.h>
   9
  10 #include "include/secp256k1.h"
  11 #include "assumptions.h"
  12 #include "util.h"
  13
  14 #ifdef ENABLE_MODULE_ECDH
  15 # include "include/secp256k1_ecdh.h"
  16 #endif
  17
  18 #ifdef ENABLE_MODULE_RECOVERY
  19 # include "include/secp256k1_recovery.h"
  20 #endif
  21
  22 #ifdef ENABLE_MODULE_EXTRAKEYS
  23 # include "include/secp256k1_extrakeys.h"
  24 #endif
  25
  26 #ifdef ENABLE_MODULE_SCHNORRSIG
  27 #include "include/secp256k1_schnorrsig.h"
  28 #endif
  29
  30 void run_tests(secp256k1_context *ctx, unsigned char *key);
  31
  32 int main(void) {
  33     secp256k1_context* ctx;
  34     unsigned char key[32];
  35     int ret, i;
  36
  37     if (!RUNNING_ON_VALGRIND) {
  38         fprintf(stderr, "This test can only usefully be run inside valgrind.\n");
  39         fprintf(stderr, "Usage: libtool --mode=execute valgrind ./valgrind_ctime_test\n");
  40         return 1;
  41     }
  42     ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN
  43                                    | SECP256K1_CONTEXT_VERIFY
  44                                    | SECP256K1_CONTEXT_DECLASSIFY);
  45     /** In theory, testing with a single secret input should be sufficient:
  46      *  If control flow depended on secrets the tool would generate an error.
  47      */
  48     for (i = 0; i < 32; i++) {
  49         key[i] = i + 65;
  50     }
  51
  52     run_tests(ctx, key);
  53
  54     /* Test context randomisation. Do this last because it leaves the context
  55      * tainted. */
  56     VALGRIND_MAKE_MEM_UNDEFINED(key, 32);
  57     ret = secp256k1_context_randomize(ctx, key);
  58     VALGRIND_MAKE_MEM_DEFINED(&ret, sizeof(ret));
  59     CHECK(ret);
  60
  61     secp256k1_context_destroy(ctx);
  62     return 0;
  63 }
  64
  65 void run_tests(secp256k1_context *ctx, unsigned char *key) {
  66     secp256k1_ecdsa_signature signature;
  67     secp256k1_pubkey pubkey;
  68     size_t siglen = 74;
  69     size_t outputlen = 33;
  70     int i;
  71     int ret;
  72     unsigned char msg[32];
  73     unsigned char sig[74];
  74     unsigned char spubkey[33];
  75 #ifdef ENABLE_MODULE_RECOVERY
  76     secp256k1_ecdsa_recoverable_signature recoverable_signature;
  77     int recid;
  78 #endif
  79 #ifdef ENABLE_MODULE_EXTRAKEYS
  80     secp256k1_keypair keypair;
  81 #endif
  82
  83     for (i = 0; i < 32; i++) {
  84         msg[i] = i + 1;
  85     }
  86
  87     /* Test keygen. */
  88     VALGRIND_MAKE_MEM_UNDEFINED(key, 32);
  89     ret = secp256k1_ec_pubkey_create(ctx, &pubkey, key);
  90     VALGRIND_MAKE_MEM_DEFINED(&pubkey, sizeof(secp256k1_pubkey));
  91     VALGRIND_MAKE_MEM_DEFINED(&ret, sizeof(ret));
  92     CHECK(ret);
  93     CHECK(secp256k1_ec_pubkey_serialize(ctx, spubkey, &outputlen, &pubkey, SECP256K1_EC_COMPRESSED) == 1);
  94
  95     /* Test signing. */
  96     VALGRIND_MAKE_MEM_UNDEFINED(key, 32);
  97     ret = secp256k1_ecdsa_sign(ctx, &signature, msg, key, NULL, NULL);
  98     VALGRIND_MAKE_MEM_DEFINED(&signature, sizeof(secp256k1_ecdsa_signature));
  99     VALGRIND_MAKE_MEM_DEFINED(&ret, sizeof(ret));
 100     CHECK(ret);
 101     CHECK(secp256k1_ecdsa_signature_serialize_der(ctx, sig, &siglen, &signature));
 102
 103 #ifdef ENABLE_MODULE_ECDH
 104     /* Test ECDH. */
 105     VALGRIND_MAKE_MEM_UNDEFINED(key, 32);
 106     ret = secp256k1_ecdh(ctx, msg, &pubkey, key, NULL, NULL);
 107     VALGRIND_MAKE_MEM_DEFINED(&ret, sizeof(ret));
 108     CHECK(ret == 1);
 109 #endif
 110
 111 #ifdef ENABLE_MODULE_RECOVERY
 112     /* Test signing a recoverable signature. */
 113     VALGRIND_MAKE_MEM_UNDEFINED(key, 32);
 114     ret = secp256k1_ecdsa_sign_recoverable(ctx, &recoverable_signature, msg, key, NULL, NULL);
 115     VALGRIND_MAKE_MEM_DEFINED(&recoverable_signature, sizeof(recoverable_signature));
 116     VALGRIND_MAKE_MEM_DEFINED(&ret, sizeof(ret));
 117     CHECK(ret);
 118     CHECK(secp256k1_ecdsa_recoverable_signature_serialize_compact(ctx, sig, &recid, &recoverable_signature));
 119     CHECK(recid >= 0 && recid <= 3);
 120 #endif
 121
 122     VALGRIND_MAKE_MEM_UNDEFINED(key, 32);
 123     ret = secp256k1_ec_seckey_verify(ctx, key);
 124     VALGRIND_MAKE_MEM_DEFINED(&ret, sizeof(ret));
 125     CHECK(ret == 1);
 126
 127     VALGRIND_MAKE_MEM_UNDEFINED(key, 32);
 128     ret = secp256k1_ec_seckey_negate(ctx, key);
 129     VALGRIND_MAKE_MEM_DEFINED(&ret, sizeof(ret));
 130     CHECK(ret == 1);
 131
 132     VALGRIND_MAKE_MEM_UNDEFINED(key, 32);
 133     VALGRIND_MAKE_MEM_UNDEFINED(msg, 32);
 134     ret = secp256k1_ec_seckey_tweak_add(ctx, key, msg);
 135     VALGRIND_MAKE_MEM_DEFINED(&ret, sizeof(ret));
 136     CHECK(ret == 1);
 137
 138     VALGRIND_MAKE_MEM_UNDEFINED(key, 32);
 139     VALGRIND_MAKE_MEM_UNDEFINED(msg, 32);
 140     ret = secp256k1_ec_seckey_tweak_mul(ctx, key, msg);
 141     VALGRIND_MAKE_MEM_DEFINED(&ret, sizeof(ret));
 142     CHECK(ret == 1);
 143
 144     /* Test keypair_create and keypair_xonly_tweak_add. */
 145 #ifdef ENABLE_MODULE_EXTRAKEYS
 146     VALGRIND_MAKE_MEM_UNDEFINED(key, 32);
 147     ret = secp256k1_keypair_create(ctx, &keypair, key);
 148     VALGRIND_MAKE_MEM_DEFINED(&ret, sizeof(ret));
 149     CHECK(ret == 1);
 150
 151     /* The tweak is not treated as a secret in keypair_tweak_add */
 152     VALGRIND_MAKE_MEM_DEFINED(msg, 32);
 153     ret = secp256k1_keypair_xonly_tweak_add(ctx, &keypair, msg);
 154     VALGRIND_MAKE_MEM_DEFINED(&ret, sizeof(ret));
 155     CHECK(ret == 1);
 156
 157     VALGRIND_MAKE_MEM_UNDEFINED(key, 32);
 158     VALGRIND_MAKE_MEM_UNDEFINED(&keypair, sizeof(keypair));
 159     ret = secp256k1_keypair_sec(ctx, key, &keypair);
 160     VALGRIND_MAKE_MEM_DEFINED(&ret, sizeof(ret));
 161     CHECK(ret == 1);
 162 #endif
 163
 164 #ifdef ENABLE_MODULE_SCHNORRSIG
 165     VALGRIND_MAKE_MEM_UNDEFINED(key, 32);
 166     ret = secp256k1_keypair_create(ctx, &keypair, key);
 167     VALGRIND_MAKE_MEM_DEFINED(&ret, sizeof(ret));
 168     CHECK(ret == 1);
 169     ret = secp256k1_schnorrsig_sign(ctx, sig, msg, &keypair, NULL, NULL);
 170     VALGRIND_MAKE_MEM_DEFINED(&ret, sizeof(ret));
 171     CHECK(ret == 1);
 172 #endif
 173 }