LCOV - code coverage report
Current view: top level - src/rpc - signmessage.cpp (source / functions) Coverage Total Hit
Test: test_bitcoin_coverage.info Lines: 54.4 % 68 37
Test Date: 2024-11-04 04:45:35 Functions: 60.0 % 5 3
Branches: 36.6 % 216 79

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

Generated by: LCOV version 2.0-1