LCOV - code coverage report
Current view: top level - src/rpc - signmessage.cpp (source / functions) Coverage Total Hit
Test: total_coverage.info Lines: 97.3 % 73 71
Test Date: 2026-09-25 06:51:09 Functions: 100.0 % 5 5
Branches: 50.0 % 202 101

             Branch data     Line data    Source code
       1                 :             : // Copyright (c) 2010 Satoshi Nakamoto
       2                 :             : // Copyright (c) 2009-present 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 <common/signmessage.h>
       7                 :             : #include <rpc/register.h> // IWYU pragma: associated
       8                 :             : 
       9                 :             : #include <key.h>
      10                 :             : #include <key_io.h>
      11                 :             : #include <rpc/protocol.h>
      12                 :             : #include <rpc/request.h>
      13                 :             : #include <rpc/server.h>
      14                 :             : #include <rpc/util.h>
      15                 :             : #include <univalue.h>
      16                 :             : 
      17                 :             : #include <string>
      18                 :             : #include <string_view>
      19                 :             : #include <vector>
      20                 :             : 
      21                 :        2554 : static RPCMethod verifymessage()
      22                 :             : {
      23                 :        2554 :     return RPCMethod{"verifymessage",
      24         [ +  - ]:        5108 :         "Verify a signed message.",
      25                 :             :         {
      26   [ +  -  +  - ]:        5108 :             {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The bitcoin address to use for the signature."},
      27   [ +  -  +  - ]:        5108 :             {"signature", RPCArg::Type::STR, RPCArg::Optional::NO, "The signature provided by the signer in base 64 encoding (see signmessage)."},
      28   [ +  -  +  - ]:        5108 :             {"message", RPCArg::Type::STR, RPCArg::Optional::NO, "The message that was signed."},
      29                 :             :         },
      30         [ +  - ]:        5108 :         RPCResult{
      31   [ +  -  +  - ]:        5108 :             RPCResult::Type::BOOL, "", "If the signature is verified or not."
      32         [ +  - ]:        5108 :         },
      33                 :        2554 :         RPCExamples{
      34                 :             :             "\nUnlock the wallet for 30 seconds\n"
      35   [ +  -  +  -  :        5108 :             + HelpExampleCli("walletpassphrase", "\"mypassphrase\" 30") +
             +  -  +  - ]
      36                 :        2554 :             "\nCreate the signature\n"
      37   [ +  -  +  -  :       10216 :             + HelpExampleCli("signmessage", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" \"my message\"") +
             +  -  +  - ]
      38                 :        2554 :             "\nVerify the signature\n"
      39   [ +  -  +  -  :       10216 :             + HelpExampleCli("verifymessage", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" \"signature\" \"my message\"") +
             +  -  +  - ]
      40                 :        2554 :             "\nAs a JSON-RPC call\n"
      41   [ +  -  +  -  :       10216 :             + HelpExampleRpc("verifymessage", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\", \"signature\", \"my message\"")
             +  -  +  - ]
      42         [ +  - ]:        2554 :         },
      43                 :        2554 :         [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
      44                 :             :         {
      45   [ +  -  +  -  :          13 :             switch (MessageVerify(std::string{self.Arg<std::string_view>("address")},
                   +  - ]
      46   [ +  -  +  - ]:          26 :                                   std::string{self.Arg<std::string_view>("signature")},
      47   [ +  +  +  +  :          26 :                                   std::string{self.Arg<std::string_view>("message")})) {
                   +  - ]
      48                 :           1 :             case MessageVerificationResult::ERR_INVALID_ADDRESS:
      49   [ +  -  +  - ]:           2 :                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
      50                 :           2 :             case MessageVerificationResult::ERR_ADDRESS_NO_KEY:
      51   [ +  -  +  - ]:           4 :                 throw JSONRPCError(RPC_TYPE_ERROR, "Address does not refer to key");
      52                 :           1 :             case MessageVerificationResult::ERR_MALFORMED_SIGNATURE:
      53   [ +  -  +  - ]:           2 :                 throw JSONRPCError(RPC_TYPE_ERROR, "Malformed base64 encoding");
      54                 :           2 :             case MessageVerificationResult::ERR_PUBKEY_NOT_RECOVERED:
      55                 :           2 :             case MessageVerificationResult::ERR_NOT_SIGNED:
      56                 :           2 :                 return false;
      57                 :           7 :             case MessageVerificationResult::OK:
      58                 :           7 :                 return true;
      59                 :             :             }
      60                 :             : 
      61                 :           0 :             return false;
      62                 :             :         },
      63   [ +  -  +  -  :       17878 :     };
             +  +  -  - ]
      64   [ +  -  +  -  :       15324 : }
             +  -  -  - ]
      65                 :             : 
      66                 :        2543 : static RPCMethod signmessagewithprivkey()
      67                 :             : {
      68                 :        2543 :     return RPCMethod{
      69                 :        2543 :         "signmessagewithprivkey",
      70         [ +  - ]:        5086 :         "Sign a message with the private key of an address\n",
      71                 :             :         {
      72   [ +  -  +  - ]:        5086 :             {"privkey", RPCArg::Type::STR, RPCArg::Optional::NO, "The private key to sign the message with."},
      73   [ +  -  +  - ]:        5086 :             {"message", RPCArg::Type::STR, RPCArg::Optional::NO, "The message to create a signature of."},
      74                 :             :         },
      75         [ +  - ]:        5086 :         RPCResult{
      76   [ +  -  +  - ]:        5086 :             RPCResult::Type::STR, "signature", "The signature of the message encoded in base 64"
      77         [ +  - ]:        5086 :         },
      78                 :        2543 :         RPCExamples{
      79                 :             :             "\nCreate the signature\n"
      80   [ +  -  +  -  :        5086 :             + HelpExampleCli("signmessagewithprivkey", "\"privkey\" \"my message\"") +
             +  -  +  - ]
      81                 :        2543 :             "\nVerify the signature\n"
      82   [ +  -  +  -  :       10172 :             + HelpExampleCli("verifymessage", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" \"signature\" \"my message\"") +
             +  -  +  - ]
      83                 :        2543 :             "\nAs a JSON-RPC call\n"
      84   [ +  -  +  -  :       10172 :             + HelpExampleRpc("signmessagewithprivkey", "\"privkey\", \"my message\"")
             +  -  +  - ]
      85         [ +  - ]:        2543 :         },
      86                 :        2543 :         [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
      87                 :             :         {
      88         [ -  + ]:           2 :             std::string strPrivkey = request.params[0].get_str();
      89   [ +  -  +  -  :           2 :             std::string strMessage = request.params[1].get_str();
                   -  + ]
      90                 :             : 
      91         [ +  - ]:           2 :             CKey key = DecodeSecret(strPrivkey);
      92         [ +  + ]:           2 :             if (!key.IsValid()) {
      93   [ +  -  +  - ]:           2 :                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid private key");
      94                 :             :             }
      95                 :             : 
      96         [ +  - ]:           1 :             std::string signature;
      97                 :             : 
      98   [ +  -  -  + ]:           1 :             if (!MessageSign(key, strMessage, signature)) {
      99   [ #  #  #  # ]:           0 :                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Sign failed");
     100                 :             :             }
     101                 :             : 
     102         [ +  - ]:           1 :             return signature;
     103                 :           3 :         },
     104   [ +  -  +  -  :       15258 :     };
             +  +  -  - ]
     105   [ +  -  +  -  :       10172 : }
                   -  - ]
     106                 :             : 
     107                 :        1407 : void RegisterSignMessageRPCCommands(CRPCTable& t)
     108                 :             : {
     109                 :        1407 :     static const CRPCCommand commands[]{
     110         [ +  - ]:        2522 :         {"util", &verifymessage},
     111         [ +  - ]:        2522 :         {"util", &signmessagewithprivkey},
     112   [ +  +  +  -  :        3929 :     };
          +  -  +  -  -  
                      - ]
     113         [ +  + ]:        4221 :     for (const auto& c : commands) {
     114                 :        2814 :         t.appendCommand(c.name, &c);
     115                 :             :     }
     116                 :        1407 : }
        

Generated by: LCOV version 2.0-1