Branch data     Line data    Source code

       1                 :            : // Copyright (c) 2009-2010 Satoshi Nakamoto
       2                 :            : // Copyright (c) 2009-2022 The Bitcoin Core developers
       3                 :            : // Distributed under the MIT software license, see the accompanying
       4                 :            : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       5                 :            : 
       6                 :            : #include <hash.h>
       7                 :            : #include <key.h>
       8                 :            : #include <key_io.h>
       9                 :            : #include <pubkey.h>
      10                 :            : #include <uint256.h>
      11                 :            : #include <util/message.h>
      12                 :            : #include <util/strencodings.h>
      13                 :            : 
      14                 :            : #include <cassert>
      15                 :            : #include <optional>
      16                 :            : #include <string>
      17                 :            : #include <variant>
      18                 :            : #include <vector>
      19                 :            : 
      20                 :            : /**
      21                 :            :  * Text used to signify that a signed message follows and to prevent
      22                 :            :  * inadvertently signing a transaction.
      23                 :            :  */
      24         [ +  - ]:        173 : const std::string MESSAGE_MAGIC = "Bitcoin Signed Message:\n";
      25                 :            : 
      26                 :        148 : MessageVerificationResult MessageVerify(
      27                 :            :     const std::string& address,
      28                 :            :     const std::string& signature,
      29                 :            :     const std::string& message)
      30                 :            : {
      31                 :        148 :     CTxDestination destination = DecodeDestination(address);
      32   [ +  -  +  + ]:        148 :     if (!IsValidDestination(destination)) {
      33                 :         85 :         return MessageVerificationResult::ERR_INVALID_ADDRESS;
      34                 :            :     }
      35                 :            : 
      36         [ +  + ]:         63 :     if (std::get_if<PKHash>(&destination) == nullptr) {
      37                 :          1 :         return MessageVerificationResult::ERR_ADDRESS_NO_KEY;
      38                 :            :     }
      39                 :            : 
      40         [ +  - ]:         62 :     auto signature_bytes = DecodeBase64(signature);
      41         [ +  + ]:         62 :     if (!signature_bytes) {
      42                 :          1 :         return MessageVerificationResult::ERR_MALFORMED_SIGNATURE;
      43                 :            :     }
      44                 :            : 
      45         [ +  - ]:         61 :     CPubKey pubkey;
      46   [ +  -  +  -  :         61 :     if (!pubkey.RecoverCompact(MessageHash(message), *signature_bytes)) {
             +  -  +  + ]
      47                 :          1 :         return MessageVerificationResult::ERR_PUBKEY_NOT_RECOVERED;
      48                 :            :     }
      49                 :            : 
      50   [ +  -  -  + ]:         60 :     if (!(PKHash(pubkey) == *std::get_if<PKHash>(&destination))) {
      51                 :          0 :         return MessageVerificationResult::ERR_NOT_SIGNED;
      52                 :            :     }
      53                 :            : 
      54                 :         60 :     return MessageVerificationResult::OK;
      55                 :        148 : }
      56                 :            : 
      57                 :         91 : bool MessageSign(
      58                 :            :     const CKey& privkey,
      59                 :            :     const std::string& message,
      60                 :            :     std::string& signature)
      61                 :            : {
      62                 :         91 :     std::vector<unsigned char> signature_bytes;
      63                 :            : 
      64   [ +  -  +  -  :         91 :     if (!privkey.SignCompact(MessageHash(message), signature_bytes)) {
                   +  + ]
      65                 :         15 :         return false;
      66                 :            :     }
      67                 :            : 
      68   [ +  -  +  - ]:         76 :     signature = EncodeBase64(signature_bytes);
      69                 :            : 
      70                 :         76 :     return true;
      71                 :         91 : }
      72                 :            : 
      73                 :        227 : uint256 MessageHash(const std::string& message)
      74                 :            : {
      75                 :        227 :     HashWriter hasher{};
      76                 :        227 :     hasher << MESSAGE_MAGIC << message;
      77                 :            : 
      78                 :        227 :     return hasher.GetHash();
      79                 :            : }
      80                 :            : 
      81                 :         75 : std::string SigningResultString(const SigningResult res)
      82                 :            : {
      83   [ +  +  +  - ]:         75 :     switch (res) {
      84                 :            :         case SigningResult::OK:
      85         [ -  + ]:         72 :             return "No error";
      86                 :            :         case SigningResult::PRIVATE_KEY_NOT_AVAILABLE:
      87         [ +  - ]:          1 :             return "Private key not available";
      88                 :            :         case SigningResult::SIGNING_FAILED:
      89         [ +  - ]:          2 :             return "Sign failed";
      90                 :            :         // no default case, so the compiler can warn about missing cases
      91                 :            :     }
      92                 :          0 :     assert(false);
      93                 :         75 : }