LCOV - code coverage report
Current view: top level - src/rpc - signmessage.cpp (source / functions) Coverage Total Hit
Test: total_coverage.info Lines: 96.7 % 61 59
Test Date: 2024-07-04 05:05:02 Functions: 100.0 % 5 5
Branches: 49.5 % 220 109

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

Generated by: LCOV version 2.0-1