READ THE CODE

Inside Bitcoin

The code behind the network, with room to understand it.

Stable release v32.1bitcoin/bitcoin · f0de87f04062 ↗3,020 source files · 47.5 MB stored on the server440 file guides

Release published 2026-10-28 · Snapshot fetched 2026-11-01. Latest stable release at fetch time; development branches and Git history are excluded. Only the selected code window and visible folders load here.

14,624 bytes · SHA-256 51fd4e6083100f75… · View upstream ↗

1// Copyright (c) 2015-present 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 <httprpc.h>
6
7#include <common/args.h>
8#include <crypto/hmac_sha256.h>
9#include <httpserver.h>
10#include <netaddress.h>
11#include <rpc/protocol.h>
12#include <rpc/server.h>
13#include <util/fs.h>
14#include <util/fs_helpers.h>
15#include <util/log.h>
16#include <util/strencodings.h>
17#include <util/string.h>
18#include <walletinitinterface.h>
19
20#include <algorithm>
21#include <iterator>
22#include <map>
23#include <memory>
24#include <optional>
25#include <set>
26#include <string>
27#include <vector>
28
29using util::SplitString;
30using util::TrimStringView;
31
32/** WWW-Authenticate to present with 401 Unauthorized response */
33static const char* WWW_AUTH_HEADER_DATA = "Basic realm=\"jsonrpc\"";
34
35/* List of -rpcauth values */
36static std::vector<std::vector<std::string>> g_rpcauth;
37/* RPC Auth Whitelist */
38static std::map<std::string, std::set<std::string>> g_rpc_whitelist;
39static bool g_rpc_whitelist_default = false;
40
41static UniValue JSONErrorReply(UniValue objError, const JSONRPCRequest& jreq, HTTPStatusCode& nStatus)
42{
43    // HTTP errors should never be returned if JSON-RPC v2 was requested. This
44    // function should only be called when a v1 request fails or when a request
45    // cannot be parsed, so the version is unknown.
46    Assume(jreq.m_json_version != JSONRPCVersion::V2);
47
48    // Send error reply from json-rpc error object
49    nStatus = HTTP_INTERNAL_SERVER_ERROR;
50    int code = objError.find_value("code").getInt<int>();
51
52    if (code == RPC_INVALID_REQUEST)
53        nStatus = HTTP_BAD_REQUEST;
54    else if (code == RPC_METHOD_NOT_FOUND)
55        nStatus = HTTP_NOT_FOUND;
56
57    return JSONRPCReplyObj(NullUniValue, std::move(objError), jreq.id, jreq.m_json_version);
58}
59
60//This function checks username and password against -rpcauth
61//entries from config file.
62static bool CheckUserAuthorized(std::string_view user, std::string_view pass)
63{
64    for (const auto& fields : g_rpcauth) {
65        if (!TimingResistantEqual(std::string_view(fields[0]), user)) {
66            continue;
67        }
68
69        const std::string& salt = fields[1];
70        const std::string& hash = fields[2];
71
72        std::array<unsigned char, CHMAC_SHA256::OUTPUT_SIZE> out;
73        CHMAC_SHA256(UCharCast(salt.data()), salt.size()).Write(UCharCast(pass.data()), pass.size()).Finalize(out.data());
74        std::string hash_from_pass = HexStr(out);
75
76        if (TimingResistantEqual(hash_from_pass, hash)) {
77            return true;
78        }
79    }
80    return false;
81}
82
83static bool RPCAuthorized(const std::string& strAuth, std::string& strAuthUsernameOut)
84{
85    if (!strAuth.starts_with("Basic "))
86        return false;
87    std::string_view strUserPass64 = TrimStringView(std::string_view{strAuth}.substr(6));
88    auto userpass_data = DecodeBase64(strUserPass64);
89    std::string strUserPass;
90    if (!userpass_data) return false;
91    strUserPass.assign(userpass_data->begin(), userpass_data->end());
92
93    size_t colon_pos = strUserPass.find(':');
94    if (colon_pos == std::string::npos) {
95        return false; // Invalid basic auth.
96    }
97    std::string user = strUserPass.substr(0, colon_pos);
98    std::string pass = strUserPass.substr(colon_pos + 1);
99    strAuthUsernameOut = user;
100    return CheckUserAuthorized(user, pass);
101}
102
103UniValue ExecuteHTTPRPC(const UniValue& valRequest, JSONRPCRequest& jreq, HTTPStatusCode& status)
104{
105    status = HTTP_OK;
106    try {
107        bool user_has_whitelist = g_rpc_whitelist.contains(jreq.authUser);
108        if (!user_has_whitelist && g_rpc_whitelist_default) {
109            LogWarning("RPC User %s not allowed to call any methods", jreq.authUser);
110            status = HTTP_FORBIDDEN;
111            return {};
112
113        // singleton request
114        } else if (valRequest.isObject()) {
115            jreq.parse(valRequest);
116            if (user_has_whitelist && !g_rpc_whitelist[jreq.authUser].contains(jreq.strMethod)) {
117                LogWarning("RPC User %s not allowed to call method %s", jreq.authUser, jreq.strMethod);
118                status = HTTP_FORBIDDEN;
119                return {};
120            }
121
122            // Legacy 1.0/1.1 behavior is for failed requests to throw
123            // exceptions which return HTTP errors and RPC errors to the client.
124            // 2.0 behavior is to catch exceptions and return HTTP success with
125            // RPC errors, as long as there is not an actual HTTP server error.
126            const bool catch_errors{jreq.m_json_version == JSONRPCVersion::V2};
127            UniValue reply{JSONRPCExec(jreq, catch_errors)};
128            if (jreq.IsNotification()) {
129                // Even though we do execute notifications, we do not respond to them
130                status = HTTP_NO_CONTENT;
131                return {};
132            }
133            return reply;
134        // array of requests
135        } else if (valRequest.isArray()) {
136            // Check authorization for each request's method
137            if (user_has_whitelist) {
138                for (unsigned int reqIdx = 0; reqIdx < valRequest.size(); reqIdx++) {
139                    if (!valRequest[reqIdx].isObject()) {
140                        throw JSONRPCError(RPC_INVALID_REQUEST, "Invalid Request object");
141                    } else {
142                        const UniValue& request = valRequest[reqIdx].get_obj();
143                        // Parse method
144                        std::string strMethod = request.find_value("method").get_str();
145                        if (!g_rpc_whitelist[jreq.authUser].contains(strMethod)) {
146                            LogWarning("RPC User %s not allowed to call method %s", jreq.authUser, strMethod);
147                            status = HTTP_FORBIDDEN;
148                            return {};
149                        }
150                    }
151                }
152            }
153
154            // Execute each request
155            UniValue reply = UniValue::VARR;
156            for (size_t i{0}; i < valRequest.size(); ++i) {
157                // Batches never throw HTTP errors, they are always just included
158                // in "HTTP OK" responses. Notifications never get any response.
159                UniValue response;
160                try {
161                    jreq.parse(valRequest[i]);
162                    response = JSONRPCExec(jreq, /*catch_errors=*/true);
163                } catch (UniValue& e) {
164                    response = JSONRPCReplyObj(NullUniValue, std::move(e), jreq.id, jreq.m_json_version);
165                } catch (const std::exception& e) {
166                    response = JSONRPCReplyObj(NullUniValue, JSONRPCError(RPC_PARSE_ERROR, e.what()), jreq.id, jreq.m_json_version);
167                }
168                if (!jreq.IsNotification()) {
169                    reply.push_back(std::move(response));
170                }
171            }
172            // Return no response for an all-notification batch, but only if the
173            // batch request is non-empty. Technically according to the JSON-RPC
174            // 2.0 spec, an empty batch request should also return no response,
175            // However, if the batch request is empty, it means the request did
176            // not contain any JSON-RPC version numbers, so returning an empty
177            // response could break backwards compatibility with old RPC clients
178            // relying on previous behavior. Return an empty array instead of an
179            // empty response in this case to favor being backwards compatible
180            // over complying with the JSON-RPC 2.0 spec in this case.
181            if (reply.size() == 0 && valRequest.size() > 0) {
182                status = HTTP_NO_CONTENT;
183                return {};
184            }
185            return reply;
186        }
187        else
188            throw JSONRPCError(RPC_PARSE_ERROR, "Top-level object parse error");
189    } catch (UniValue& e) {
190        return JSONErrorReply(std::move(e), jreq, status);
191    } catch (const std::exception& e) {
192        return JSONErrorReply(JSONRPCError(RPC_PARSE_ERROR, e.what()), jreq, status);
193    }
194}
195
196static void HTTPReq_JSONRPC(const std::any& context, HTTPRequest* req)
197{
198    // JSONRPC handles only POST
199    if (req->GetRequestMethod() != HTTPRequestMethod::POST) {
200        req->WriteReply(HTTP_BAD_METHOD, "JSONRPC server handles only POST requests");
201        return;
202    }
203    // Check authorization
204    std::optional<std::string> auth_header = req->GetHeader("authorization");
205    if (!auth_header) {
206        req->WriteHeader("WWW-Authenticate", WWW_AUTH_HEADER_DATA);
207        req->WriteReply(HTTP_UNAUTHORIZED);
208        return;
209    }
210
211    JSONRPCRequest jreq;
212    jreq.context = context;
213    jreq.peerAddr = req->GetPeer().ToStringAddrPort();
214    jreq.URI = req->GetURI();
215    if (!RPCAuthorized(*auth_header, jreq.authUser)) {
216        LogWarning("ThreadRPCServer incorrect password attempt from %s", jreq.peerAddr);
217
218        /* Deter brute-forcing
219           If this results in a DoS the user really
220           shouldn't have their RPC port exposed. */
221        UninterruptibleSleep(std::chrono::milliseconds{250});
222
223        req->WriteHeader("WWW-Authenticate", WWW_AUTH_HEADER_DATA);
224        req->WriteReply(HTTP_UNAUTHORIZED);
225        return;
226    }
227
228    // Generate reply
229    HTTPStatusCode status;
230    UniValue reply;
231    UniValue request;
232    if (request.read(req->ReadBody())) {
233        reply = ExecuteHTTPRPC(request, jreq, status);
234    } else {
235        reply = JSONErrorReply(JSONRPCError(RPC_PARSE_ERROR, "Parse error"), jreq, status);
236    }
237
238    // Write reply
239    if (reply.isNull()) {
240        // Error case or no-content notification reply.
241        req->WriteReply(status);
242    } else {
243        req->WriteHeader("Content-Type", "application/json");
244        req->WriteReply(status, reply.write() + "\n");
245    }
246}
247
248static bool InitRPCAuthentication()
249{
250    std::string user;

src/wallet/receive.cpp

src/wallet/coinselection.cpp

src/consensus/validation.h

src/primitives/transaction.cpp

src/script/descriptor.cpp

src/bitcoin-cli.cpp

src/rpc/blockchain.cpp

src/rpc/rawtransaction.cpp

src/init.cpp

src/crypto/sha256.cpp

src/consensus/merkle.h

src/consensus/tx_check.h

src/consensus/tx_verify.h

src/policy/feerate.h

src/policy/feerate.cpp

src/primitives/transaction_identifier.h

src/chainparamsbase.h

src/chainparamsbase.cpp

src/util/moneystr.cpp

src/crypto/ripemd160.h

src/crypto/sha1.h

src/crypto/sha512.h

src/crypto/hmac_sha256.h

src/crypto/hmac_sha512.h

src/crypto/hmac_sha256.cpp

src/crypto/hmac_sha512.cpp

src/crypto/hkdf_sha256_32.h

src/crypto/hkdf_sha256_32.cpp

src/support/cleanse.h

src/support/cleanse.cpp

src/crypto/siphash.cpp

src/crypto/muhash.h

src/crypto/chacha20.h

src/crypto/poly1305.h

src/crypto/chacha20poly1305.h

src/crypto/chacha20poly1305.cpp

src/util/chaintype.cpp

src/util/obfuscation.h

src/util/byte_units.h

src/util/overflow.h

src/blockencodings.cpp

src/net_permissions.cpp

src/policy/packages.cpp

src/policy/rbf.cpp

src/policy/truc_policy.cpp

src/policy/ephemeral_policy.cpp

src/policy/settings.cpp

src/policy/policy.cpp

src/node/transaction.cpp

src/node/coin.cpp

src/rpc/client.cpp

src/rpc/external_signer.cpp

src/rpc/request.cpp

src/rpc/server_util.cpp

src/rpc/fees.cpp

src/rpc/output_script.cpp

src/rpc/rawtransaction_util.cpp

src/rpc/rawtransaction_util.h

src/rpc/register.h

src/rpc/request.h

src/rpc/server_util.h

src/rpc/protocol.h

src/rpc/server.h

src/rpc/signmessage.cpp

src/rpc/txoutproof.cpp

src/rpc/util.cpp

src/rpc/util.h

src/wallet/rpc/addresses.cpp

src/wallet/rpc/backup.cpp

src/wallet/rpc/coins.cpp

src/wallet/rpc/encrypt.cpp

src/wallet/rpc/signmessage.cpp

src/wallet/rpc/util.cpp

src/wallet/rpc/util.h

src/wallet/coincontrol.cpp

src/wallet/coincontrol.h

src/wallet/context.cpp

src/wallet/context.h

src/wallet/crypter.cpp

src/wallet/crypter.h

src/wallet/db.cpp

src/wallet/export.cpp

src/wallet/external_signer_scriptpubkeyman.cpp

src/wallet/rpc/spend.cpp

src/wallet/rpc/transactions.cpp

src/wallet/rpc/wallet.cpp

src/wallet/feebumper.cpp

src/wallet/feebumper.h

src/index/base.h

src/index/base.cpp

src/index/txindex.h

src/index/txindex.cpp

src/index/txindex_key.h

src/index/txospenderindex.h

src/index/txospenderindex.cpp

src/index/blockfilterindex.h

src/index/blockfilterindex.cpp

src/index/coinstatsindex.h

src/index/coinstatsindex.cpp

src/index/db_key.h

src/index/disktxpos.h

src/kernel/chain.cpp

src/kernel/chain.h

src/kernel/checks.cpp

src/kernel/checks.h

src/kernel/context.cpp

src/kernel/context.h

src/kernel/cs_main.cpp

src/kernel/cs_main.h

src/kernel/disconnected_transactions.cpp

src/kernel/disconnected_transactions.h

src/kernel/mempool_removal_reason.cpp

src/kernel/mempool_removal_reason.h

src/kernel/coinstats.cpp

src/kernel/coinstats.h

src/kernel/chainparams.cpp

src/kernel/chainparams.h

src/wallet/sqlite.cpp

src/wallet/sqlite.h

src/wallet/transaction.cpp

src/wallet/transaction.h

src/wallet/dump.cpp

src/wallet/dump.h

src/wallet/init.cpp

src/wallet/walletutil.cpp

src/wallet/walletutil.h

src/wallet/wallettool.cpp

src/wallet/wallettool.h

src/wallet/export.h

src/wallet/migrate.cpp

src/wallet/migrate.h

src/wallet/db.h

src/wallet/walletdb.cpp

src/wallet/interfaces.cpp

src/wallet/scriptpubkeyman.cpp

src/wallet/scriptpubkeyman.h

src/kernel/bitcoinkernel.cpp

src/kernel/bitcoinkernel.h

src/kernel/bitcoinkernel_wrapper.h

src/node/chainstate.cpp

src/node/chainstate.h

src/node/blockstorage.cpp

src/node/blockstorage.h

src/node/mempool_persist.cpp

src/node/mempool_persist.h

src/node/utxo_snapshot.cpp

src/node/utxo_snapshot.h

src/node/kernel_notifications.cpp

src/node/kernel_notifications.h

src/node/blockmanager_args.cpp

src/kernel/blockmanager_opts.h

src/util/expected.cpp

src/policy/settings.h

src/util/types.h

src/kernel/messagestartchars.h

src/kernel/warning.h

src/util/exception.h

src/common/license_info.h

src/node/coins_view_args.h

src/node/database_args.h

src/util/batchpriority.h

src/util/ui_change_type.h

src/node/coins_view_args.cpp

src/node/peerman_args.h

src/util/serfloat.h

src/node/blockmanager_args.h

src/node/database_args.cpp

src/util/overloaded.h

src/interfaces/types.h

src/node/chainstatemanager_args.h

src/node/minisketchwrapper.h

src/util/macros.h

src/util/syserror.h

src/common/run_command.h

src/util/bytevectorhash.cpp

src/node/mempool_persist_args.cpp

src/util/exec.h

src/util/rbf.h

src/crypto/hex_base.h

src/node/mempool_persist_args.h

src/interfaces/echo.h

src/util/any.h

src/util/batchpriority.cpp

src/util/threadnames.h

src/node/coin.h

src/node/mempool_args.h

src/util/asmap.h

src/util/bytevectorhash.h

src/node/context.cpp

src/util/insert.h

src/util/readwritefile.h

src/node/peerman_args.cpp

src/node/interface_ui.cpp

src/interfaces/handler.h

src/node/mining_args.h

src/util/hasher.cpp

src/common/init.h

src/kernel/mempool_limits.h

src/common/system.h

src/crypto/sha3.h

src/util/threadinterrupt.cpp

src/node/protocol_version.h

src/util/exception.cpp

src/common/messages.h

src/node/connection_types.cpp

src/util/bip32.h

src/common/license_info.cpp

src/util/stdmutex.h

src/common/run_command.cpp

src/util/check.cpp

src/util/golombrice.h

src/node/types.h

src/node/timeoffsets.h

src/util/readwritefile.cpp

src/util/fastrange.h

src/util/signalinterrupt.h

src/util/task_runner.h

src/util/syserror.cpp

src/common/interfaces.cpp

src/common/types.h

src/util/threadinterrupt.h

src/kernel/chainstatemanager_opts.h

src/node/psbt.h

src/policy/ephemeral_policy.h

src/util/trace.h

src/common/url.cpp

src/kernel/mempool_options.h

src/util/serfloat.cpp

src/kernel/notifications_interface.h

src/node/timeoffsets.cpp

src/node/warnings.cpp

src/util/hash_type.h

src/crypto/hex_base.cpp

src/node/eviction.h

src/util/tokenbucket.h

src/crypto/aes.h

src/common/pcp.h

src/util/feefrac.cpp

src/node/transaction.h

src/util/threadnames.cpp

src/common/signmessage.h

src/util/exec.cpp

src/util/signalinterrupt.cpp

src/clientversion.cpp

src/common/signmessage.cpp

src/compat/assumptions.h

src/compat/byteswap.h

src/deploymentinfo.cpp

src/deploymentinfo.h

src/deploymentstatus.cpp

src/deploymentstatus.h

src/dummywallet.cpp

src/external_signer.h

src/init/bitcoin-gui.cpp

src/init/bitcoin-node.cpp

src/init/bitcoin-qt.cpp

src/init/bitcoin-wallet.cpp

src/init/bitcoind.cpp

src/init/common.h

src/interfaces/init.h

src/interfaces/ipc.h

src/key_io.h

src/logging/categories.h

src/logging/timer.h

src/mapport.h

src/musig.h

src/net_permissions.h

src/netgroup.h

src/netmessagemaker.h

src/node/chainstatemanager_args.cpp

src/node/connection_types.h

src/node/context.h

src/node/interface_ui.h

src/node/mempool_args.cpp

src/node/mining_args.cpp

src/node/minisketchwrapper.cpp

src/node/txreconciliation.h

src/policy/fees/estimator_args.cpp

src/policy/fees/estimator_args.h

src/policy/fees/estimator_man.cpp

src/policy/fees/estimator_man.h

src/policy/packages.h

src/policy/rbf.h

src/policy/truc_policy.h

src/pow.h

src/primitives/block.cpp

src/randomenv.h

src/rest.h

src/script/keyorigin.h

src/script/parsing.cpp

src/script/parsing.h

src/script/script_error.h

src/script/sigcache.cpp

src/script/sigcache.h

src/script/solver.h

src/script/verify_flags.h

src/semaphore_grant.h

src/signet.h

src/span.h

src/support/allocators/secure.h

src/support/allocators/zeroafterfree.h

src/util/tokenpipe.cpp

src/util/translation.h

src/util/vector.h

src/versionbits.h

src/versionbits_impl.h

src/wallet/external_signer_scriptpubkeyman.h

src/wallet/fees.h

src/wallet/load.h

src/wallet/receive.h

src/wallet/rpc/wallet.h

src/wallet/types.h

src/walletinitinterface.h

src/zmq/zmqabstractnotifier.cpp

Independent explanations by MyBitcoinExplorer. Not affiliated with or endorsed by Bitcoin Core. Guides are educational and do not replace the source or its tests.

Bitcoin Core source © its contributors, distributed under the MIT license. Original notices and bundled third-party licenses are retained in the source tree.