src/pubkey.cpp

   1 // Copyright (c) 2009-2016 The Bitcoin Core developers
   2 // Distributed under the MIT software license, see the accompanying
   3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   4
   5 #include <pubkey.h>
   6
   7 #include <secp256k1.h>
   8 #include <secp256k1_recovery.h>
   9
  10 namespace
  11 {
  12 /* Global secp256k1_context object used for verification. */
  13 secp256k1_context* secp256k1_context_verify = nullptr;
  14 } // namespace
  15
  16 /** This function is taken from the libsecp256k1 distribution and implements
  17  *  DER parsing for ECDSA signatures, while supporting an arbitrary subset of
  18  *  format violations.
  19  *
  20  *  Supported violations include negative integers, excessive padding, garbage
  21  *  at the end, and overly long length descriptors. This is safe to use in
  22  *  Bitcoin because since the activation of BIP66, signatures are verified to be
  23  *  strict DER before being passed to this module, and we know it supports all
  24  *  violations present in the blockchain before that point.
  25  */
  26 static int ecdsa_signature_parse_der_lax(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input, size_t inputlen) {
  27     size_t rpos, rlen, spos, slen;
  28     size_t pos = 0;
  29     size_t lenbyte;
  30     unsigned char tmpsig[64] = {0};
  31     int overflow = 0;
  32
  33     /* Hack to initialize sig with a correctly-parsed but invalid signature. */
  34     secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
  35
  36     /* Sequence tag byte */
  37     if (pos == inputlen || input[pos] != 0x30) {
  38         return 0;
  39     }
  40     pos++;
  41
  42     /* Sequence length bytes */
  43     if (pos == inputlen) {
  44         return 0;
  45     }
  46     lenbyte = input[pos++];
  47     if (lenbyte & 0x80) {
  48         lenbyte -= 0x80;
  49         if (pos + lenbyte > inputlen) {
  50             return 0;
  51         }
  52         pos += lenbyte;
  53     }
  54
  55     /* Integer tag byte for R */
  56     if (pos == inputlen || input[pos] != 0x02) {
  57         return 0;
  58     }
  59     pos++;
  60
  61     /* Integer length for R */
  62     if (pos == inputlen) {
  63         return 0;
  64     }
  65     lenbyte = input[pos++];
  66     if (lenbyte & 0x80) {
  67         lenbyte -= 0x80;
  68         if (pos + lenbyte > inputlen) {
  69             return 0;
  70         }
  71         while (lenbyte > 0 && input[pos] == 0) {
  72             pos++;
  73             lenbyte--;
  74         }
  75         if (lenbyte >= sizeof(size_t)) {
  76             return 0;
  77         }
  78         rlen = 0;
  79         while (lenbyte > 0) {
  80             rlen = (rlen << 8) + input[pos];
  81             pos++;
  82             lenbyte--;
  83         }
  84     } else {
  85         rlen = lenbyte;
  86     }
  87     if (rlen > inputlen - pos) {
  88         return 0;
  89     }
  90     rpos = pos;
  91     pos += rlen;
  92
  93     /* Integer tag byte for S */
  94     if (pos == inputlen || input[pos] != 0x02) {
  95         return 0;
  96     }
  97     pos++;
  98
  99     /* Integer length for S */
 100     if (pos == inputlen) {
 101         return 0;
 102     }
 103     lenbyte = input[pos++];
 104     if (lenbyte & 0x80) {
 105         lenbyte -= 0x80;
 106         if (pos + lenbyte > inputlen) {
 107             return 0;
 108         }
 109         while (lenbyte > 0 && input[pos] == 0) {
 110             pos++;
 111             lenbyte--;
 112         }
 113         if (lenbyte >= sizeof(size_t)) {
 114             return 0;
 115         }
 116         slen = 0;
 117         while (lenbyte > 0) {
 118             slen = (slen << 8) + input[pos];
 119             pos++;
 120             lenbyte--;
 121         }
 122     } else {
 123         slen = lenbyte;
 124     }
 125     if (slen > inputlen - pos) {
 126         return 0;
 127     }
 128     spos = pos;
 129
 130     /* Ignore leading zeroes in R */
 131     while (rlen > 0 && input[rpos] == 0) {
 132         rlen--;
 133         rpos++;
 134     }
 135     /* Copy R value */
 136     if (rlen > 32) {
 137         overflow = 1;
 138     } else {
 139         memcpy(tmpsig + 32 - rlen, input + rpos, rlen);
 140     }
 141
 142     /* Ignore leading zeroes in S */
 143     while (slen > 0 && input[spos] == 0) {
 144         slen--;
 145         spos++;
 146     }
 147     /* Copy S value */
 148     if (slen > 32) {
 149         overflow = 1;
 150     } else {
 151         memcpy(tmpsig + 64 - slen, input + spos, slen);
 152     }
 153
 154     if (!overflow) {
 155         overflow = !secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
 156     }
 157     if (overflow) {
 158         /* Overwrite the result again with a correctly-parsed but invalid
 159            signature if parsing failed. */
 160         memset(tmpsig, 0, 64);
 161         secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
 162     }
 163     return 1;
 164 }
 165
 166 bool CPubKey::Verify(const uint256 &hash, const std::vector<unsigned char>& vchSig) const {
 167     if (!IsValid())
 168         return false;
 169     secp256k1_pubkey pubkey;
 170     secp256k1_ecdsa_signature sig;
 171     if (!secp256k1_ec_pubkey_parse(secp256k1_context_verify, &pubkey, &(*this)[0], size())) {
 172         return false;
 173     }
 174     if (!ecdsa_signature_parse_der_lax(secp256k1_context_verify, &sig, vchSig.data(), vchSig.size())) {
 175         return false;
 176     }
 177     /* libsecp256k1's ECDSA verification requires lower-S signatures, which have
 178      * not historically been enforced in Bitcoin, so normalize them first. */
 179     secp256k1_ecdsa_signature_normalize(secp256k1_context_verify, &sig, &sig);
 180     return secp256k1_ecdsa_verify(secp256k1_context_verify, &sig, hash.begin(), &pubkey);
 181 }
 182
 183 bool CPubKey::RecoverCompact(const uint256 &hash, const std::vector<unsigned char>& vchSig) {
 184     if (vchSig.size() != 65)
 185         return false;
 186     int recid = (vchSig[0] - 27) & 3;
 187     bool fComp = ((vchSig[0] - 27) & 4) != 0;
 188     secp256k1_pubkey pubkey;
 189     secp256k1_ecdsa_recoverable_signature sig;
 190     if (!secp256k1_ecdsa_recoverable_signature_parse_compact(secp256k1_context_verify, &sig, &vchSig[1], recid)) {
 191         return false;
 192     }
 193     if (!secp256k1_ecdsa_recover(secp256k1_context_verify, &pubkey, &sig, hash.begin())) {
 194         return false;
 195     }
 196     unsigned char pub[65];
 197     size_t publen = 65;
 198     secp256k1_ec_pubkey_serialize(secp256k1_context_verify, pub, &publen, &pubkey, fComp ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED);
 199     Set(pub, pub + publen);
 200     return true;
 201 }
 202
 203 bool CPubKey::IsFullyValid() const {
 204     if (!IsValid())
 205         return false;
 206     secp256k1_pubkey pubkey;
 207     return secp256k1_ec_pubkey_parse(secp256k1_context_verify, &pubkey, &(*this)[0], size());
 208 }
 209
 210 bool CPubKey::Decompress() {
 211     if (!IsValid())
 212         return false;
 213     secp256k1_pubkey pubkey;
 214     if (!secp256k1_ec_pubkey_parse(secp256k1_context_verify, &pubkey, &(*this)[0], size())) {
 215         return false;
 216     }
 217     unsigned char pub[65];
 218     size_t publen = 65;
 219     secp256k1_ec_pubkey_serialize(secp256k1_context_verify, pub, &publen, &pubkey, SECP256K1_EC_UNCOMPRESSED);
 220     Set(pub, pub + publen);
 221     return true;
 222 }
 223
 224 bool CPubKey::Derive(CPubKey& pubkeyChild, ChainCode &ccChild, unsigned int nChild, const ChainCode& cc) const {
 225     assert(IsValid());
 226     assert((nChild >> 31) == 0);
 227     assert(begin() + 33 == end());
 228     unsigned char out[64];
 229     BIP32Hash(cc, nChild, *begin(), begin()+1, out);
 230     memcpy(ccChild.begin(), out+32, 32);
 231     secp256k1_pubkey pubkey;
 232     if (!secp256k1_ec_pubkey_parse(secp256k1_context_verify, &pubkey, &(*this)[0], size())) {
 233         return false;
 234     }
 235     if (!secp256k1_ec_pubkey_tweak_add(secp256k1_context_verify, &pubkey, out)) {
 236         return false;
 237     }
 238     unsigned char pub[33];
 239     size_t publen = 33;
 240     secp256k1_ec_pubkey_serialize(secp256k1_context_verify, pub, &publen, &pubkey, SECP256K1_EC_COMPRESSED);
 241     pubkeyChild.Set(pub, pub + publen);
 242     return true;
 243 }
 244
 245 void CExtPubKey::Encode(unsigned char code[BIP32_EXTKEY_SIZE]) const {
 246     code[0] = nDepth;
 247     memcpy(code+1, vchFingerprint, 4);
 248     code[5] = (nChild >> 24) & 0xFF; code[6] = (nChild >> 16) & 0xFF;
 249     code[7] = (nChild >>  8) & 0xFF; code[8] = (nChild >>  0) & 0xFF;
 250     memcpy(code+9, chaincode.begin(), 32);
 251     assert(pubkey.size() == 33);
 252     memcpy(code+41, pubkey.begin(), 33);
 253 }
 254
 255 void CExtPubKey::Decode(const unsigned char code[BIP32_EXTKEY_SIZE]) {
 256     nDepth = code[0];
 257     memcpy(vchFingerprint, code+1, 4);
 258     nChild = (code[5] << 24) | (code[6] << 16) | (code[7] << 8) | code[8];
 259     memcpy(chaincode.begin(), code+9, 32);
 260     pubkey.Set(code+41, code+BIP32_EXTKEY_SIZE);
 261 }
 262
 263 bool CExtPubKey::Derive(CExtPubKey &out, unsigned int _nChild) const {
 264     out.nDepth = nDepth + 1;
 265     CKeyID id = pubkey.GetID();
 266     memcpy(&out.vchFingerprint[0], &id, 4);
 267     out.nChild = _nChild;
 268     return pubkey.Derive(out.pubkey, out.chaincode, _nChild, chaincode);
 269 }
 270
 271 /* static */ bool CPubKey::CheckLowS(const std::vector<unsigned char>& vchSig) {
 272     secp256k1_ecdsa_signature sig;
 273     if (!ecdsa_signature_parse_der_lax(secp256k1_context_verify, &sig, vchSig.data(), vchSig.size())) {
 274         return false;
 275     }
 276     return (!secp256k1_ecdsa_signature_normalize(secp256k1_context_verify, nullptr, &sig));
 277 }
 278
 279 /* static */ int ECCVerifyHandle::refcount = 0;
 280
 281 ECCVerifyHandle::ECCVerifyHandle()
 282 {
 283     if (refcount == 0) {
 284         assert(secp256k1_context_verify == nullptr);
 285         secp256k1_context_verify = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY);
 286         assert(secp256k1_context_verify != nullptr);
 287     }
 288     refcount++;
 289 }
 290
 291 ECCVerifyHandle::~ECCVerifyHandle()
 292 {
 293     refcount--;
 294     if (refcount == 0) {
 295         assert(secp256k1_context_verify != nullptr);
 296         secp256k1_context_destroy(secp256k1_context_verify);
 297         secp256k1_context_verify = nullptr;
 298     }
 299 }