Branch data Line data Source code
1 : : // Copyright (c) 2015-2022 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 <logging.h>
11 : : #include <netaddress.h>
12 : : #include <rpc/protocol.h>
13 : : #include <rpc/server.h>
14 : : #include <util/fs.h>
15 : : #include <util/fs_helpers.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 : :
29 : : using util::SplitString;
30 : : using util::TrimStringView;
31 : :
32 : : /** WWW-Authenticate to present with 401 Unauthorized response */
33 : : static const char* WWW_AUTH_HEADER_DATA = "Basic realm=\"jsonrpc\"";
34 : :
35 : : /** Simple one-shot callback timer to be used by the RPC mechanism to e.g.
36 : : * re-lock the wallet.
37 : : */
38 : : class HTTPRPCTimer : public RPCTimerBase
39 : : {
40 : : public:
41 : 44 : HTTPRPCTimer(struct event_base* eventBase, std::function<void()>& func, int64_t millis) :
42 [ + - + - ]: 88 : ev(eventBase, false, func)
43 : : {
44 : 44 : struct timeval tv;
45 : 44 : tv.tv_sec = millis/1000;
46 : 44 : tv.tv_usec = (millis%1000)*1000;
47 [ + - ]: 44 : ev.trigger(&tv);
48 : 44 : }
49 : : private:
50 : : HTTPEvent ev;
51 : : };
52 : :
53 : : class HTTPRPCTimerInterface : public RPCTimerInterface
54 : : {
55 : : public:
56 : 991 : explicit HTTPRPCTimerInterface(struct event_base* _base) : base(_base)
57 : : {
58 : : }
59 : 44 : const char* Name() override
60 : : {
61 : 44 : return "HTTP";
62 : : }
63 : 44 : RPCTimerBase* NewTimer(std::function<void()>& func, int64_t millis) override
64 : : {
65 [ + - ]: 44 : return new HTTPRPCTimer(base, func, millis);
66 : : }
67 : : private:
68 : : struct event_base* base;
69 : : };
70 : :
71 : :
72 : : /* Pre-base64-encoded authentication token */
73 : : static std::string strRPCUserColonPass;
74 : : /* Stored RPC timer interface (for unregistration) */
75 : : static std::unique_ptr<HTTPRPCTimerInterface> httpRPCTimerInterface;
76 : : /* List of -rpcauth values */
77 : : static std::vector<std::vector<std::string>> g_rpcauth;
78 : : /* RPC Auth Whitelist */
79 : : static std::map<std::string, std::set<std::string>> g_rpc_whitelist;
80 : : static bool g_rpc_whitelist_default = false;
81 : :
82 : 6 : static void JSONErrorReply(HTTPRequest* req, UniValue objError, const JSONRPCRequest& jreq)
83 : : {
84 : : // Sending HTTP errors is a legacy JSON-RPC behavior.
85 : 6 : Assume(jreq.m_json_version != JSONRPCVersion::V2);
86 : :
87 : : // Send error reply from json-rpc error object
88 : 6 : int nStatus = HTTP_INTERNAL_SERVER_ERROR;
89 : 6 : int code = objError.find_value("code").getInt<int>();
90 : :
91 [ + + ]: 6 : if (code == RPC_INVALID_REQUEST)
92 : : nStatus = HTTP_BAD_REQUEST;
93 [ + + ]: 4 : else if (code == RPC_METHOD_NOT_FOUND)
94 : 1 : nStatus = HTTP_NOT_FOUND;
95 : :
96 [ + - + - : 12 : std::string strReply = JSONRPCReplyObj(NullUniValue, std::move(objError), jreq.id, jreq.m_json_version).write() + "\n";
+ - ]
97 : :
98 [ + - + - : 12 : req->WriteHeader("Content-Type", "application/json");
+ - ]
99 [ + - ]: 6 : req->WriteReply(nStatus, strReply);
100 : 6 : }
101 : :
102 : : //This function checks username and password against -rpcauth
103 : : //entries from config file.
104 : 36 : static bool multiUserAuthorized(std::string strUserPass)
105 : : {
106 [ + - ]: 36 : if (strUserPass.find(':') == std::string::npos) {
107 : : return false;
108 : : }
109 : 36 : std::string strUser = strUserPass.substr(0, strUserPass.find(':'));
110 [ + - ]: 36 : std::string strPass = strUserPass.substr(strUserPass.find(':') + 1);
111 : :
112 [ + + ]: 96 : for (const auto& vFields : g_rpcauth) {
113 [ + - ]: 75 : std::string strName = vFields[0];
114 [ + + ]: 75 : if (!TimingResistantEqual(strName, strUser)) {
115 : 57 : continue;
116 : : }
117 : :
118 [ + - ]: 18 : std::string strSalt = vFields[1];
119 [ + - ]: 18 : std::string strHash = vFields[2];
120 : :
121 : 18 : static const unsigned int KEY_SIZE = 32;
122 : 18 : unsigned char out[KEY_SIZE];
123 : :
124 [ + - + - : 18 : CHMAC_SHA256(reinterpret_cast<const unsigned char*>(strSalt.data()), strSalt.size()).Write(reinterpret_cast<const unsigned char*>(strPass.data()), strPass.size()).Finalize(out);
+ - ]
125 [ + - ]: 18 : std::vector<unsigned char> hexvec(out, out+KEY_SIZE);
126 [ + - ]: 18 : std::string strHashFromPass = HexStr(hexvec);
127 : :
128 [ + + ]: 18 : if (TimingResistantEqual(strHashFromPass, strHash)) {
129 : 15 : return true;
130 : : }
131 : 75 : }
132 : : return false;
133 : 36 : }
134 : :
135 : 187931 : static bool RPCAuthorized(const std::string& strAuth, std::string& strAuthUsernameOut)
136 : : {
137 [ + + ]: 187931 : if (strAuth.substr(0, 6) != "Basic ")
138 : : return false;
139 : 187929 : std::string_view strUserPass64 = TrimStringView(std::string_view{strAuth}.substr(6));
140 : 187929 : auto userpass_data = DecodeBase64(strUserPass64);
141 [ + - ]: 187929 : std::string strUserPass;
142 [ + - ]: 187929 : if (!userpass_data) return false;
143 [ + - ]: 187929 : strUserPass.assign(userpass_data->begin(), userpass_data->end());
144 : :
145 [ + - ]: 187929 : if (strUserPass.find(':') != std::string::npos)
146 [ + - ]: 187929 : strAuthUsernameOut = strUserPass.substr(0, strUserPass.find(':'));
147 : :
148 : : // Check if authorized under single-user field.
149 : : // (strRPCUserColonPass is empty when -norpccookiefile is specified).
150 [ + + + + ]: 187929 : if (!strRPCUserColonPass.empty() && TimingResistantEqual(strUserPass, strRPCUserColonPass)) {
151 : : return true;
152 : : }
153 [ + - + - ]: 36 : return multiUserAuthorized(strUserPass);
154 : 187929 : }
155 : :
156 : 187931 : static bool HTTPReq_JSONRPC(const std::any& context, HTTPRequest* req)
157 : : {
158 : : // JSONRPC handles only POST
159 [ - + ]: 187931 : if (req->GetRequestMethod() != HTTPRequest::POST) {
160 : 0 : req->WriteReply(HTTP_BAD_METHOD, "JSONRPC server handles only POST requests");
161 : 0 : return false;
162 : : }
163 : : // Check authorization
164 [ + - ]: 187931 : std::pair<bool, std::string> authHeader = req->GetHeader("authorization");
165 [ - + ]: 187931 : if (!authHeader.first) {
166 [ # # # # : 0 : req->WriteHeader("WWW-Authenticate", WWW_AUTH_HEADER_DATA);
# # ]
167 [ # # ]: 0 : req->WriteReply(HTTP_UNAUTHORIZED);
168 : : return false;
169 : : }
170 : :
171 : 187931 : JSONRPCRequest jreq;
172 [ + - ]: 187931 : jreq.context = context;
173 [ + - + - ]: 187931 : jreq.peerAddr = req->GetPeer().ToStringAddrPort();
174 [ + - + + ]: 187931 : if (!RPCAuthorized(authHeader.second, jreq.authUser)) {
175 [ + - ]: 23 : LogPrintf("ThreadRPCServer incorrect password attempt from %s\n", jreq.peerAddr);
176 : :
177 : : /* Deter brute-forcing
178 : : If this results in a DoS the user really
179 : : shouldn't have their RPC port exposed. */
180 [ + - ]: 23 : UninterruptibleSleep(std::chrono::milliseconds{250});
181 : :
182 [ + - + - : 23 : req->WriteHeader("WWW-Authenticate", WWW_AUTH_HEADER_DATA);
+ - ]
183 [ + - ]: 23 : req->WriteReply(HTTP_UNAUTHORIZED);
184 : : return false;
185 : : }
186 : :
187 : 187908 : try {
188 : : // Parse request
189 [ + - ]: 187908 : UniValue valRequest;
190 [ + - + - : 187908 : if (!valRequest.read(req->ReadBody()))
+ + ]
191 [ + - + - ]: 4 : throw JSONRPCError(RPC_PARSE_ERROR, "Parse error");
192 : :
193 : : // Set the URI
194 [ + - ]: 187906 : jreq.URI = req->GetURI();
195 : :
196 : 187906 : UniValue reply;
197 : 187906 : bool user_has_whitelist = g_rpc_whitelist.count(jreq.authUser);
198 [ + + - + ]: 187906 : if (!user_has_whitelist && g_rpc_whitelist_default) {
199 [ # # ]: 0 : LogPrintf("RPC User %s not allowed to call any methods\n", jreq.authUser);
200 [ # # ]: 0 : req->WriteReply(HTTP_FORBIDDEN);
201 : : return false;
202 : :
203 : : // singleton request
204 [ + + ]: 187906 : } else if (valRequest.isObject()) {
205 [ + + ]: 187735 : jreq.parse(valRequest);
206 [ + + + - : 187733 : if (user_has_whitelist && !g_rpc_whitelist[jreq.authUser].count(jreq.strMethod)) {
+ + ]
207 [ + - ]: 5 : LogPrintf("RPC User %s not allowed to call method %s\n", jreq.authUser, jreq.strMethod);
208 [ + - ]: 5 : req->WriteReply(HTTP_FORBIDDEN);
209 : : return false;
210 : : }
211 : :
212 : : // Legacy 1.0/1.1 behavior is for failed requests to throw
213 : : // exceptions which return HTTP errors and RPC errors to the client.
214 : : // 2.0 behavior is to catch exceptions and return HTTP success with
215 : : // RPC errors, as long as there is not an actual HTTP server error.
216 : 187728 : const bool catch_errors{jreq.m_json_version == JSONRPCVersion::V2};
217 [ + + ]: 187728 : reply = JSONRPCExec(jreq, catch_errors);
218 : :
219 [ + + ]: 187726 : if (jreq.IsNotification()) {
220 : : // Even though we do execute notifications, we do not respond to them
221 [ + - ]: 2 : req->WriteReply(HTTP_NO_CONTENT);
222 : : return true;
223 : : }
224 : :
225 : : // array of requests
226 [ + - ]: 171 : } else if (valRequest.isArray()) {
227 : : // Check authorization for each request's method
228 [ - + ]: 171 : if (user_has_whitelist) {
229 [ # # ]: 0 : for (unsigned int reqIdx = 0; reqIdx < valRequest.size(); reqIdx++) {
230 [ # # # # ]: 0 : if (!valRequest[reqIdx].isObject()) {
231 [ # # # # ]: 0 : throw JSONRPCError(RPC_INVALID_REQUEST, "Invalid Request object");
232 : : } else {
233 [ # # # # ]: 0 : const UniValue& request = valRequest[reqIdx].get_obj();
234 : : // Parse method
235 [ # # # # : 0 : std::string strMethod = request.find_value("method").get_str();
# # ]
236 [ # # # # ]: 0 : if (!g_rpc_whitelist[jreq.authUser].count(strMethod)) {
237 [ # # ]: 0 : LogPrintf("RPC User %s not allowed to call method %s\n", jreq.authUser, strMethod);
238 [ # # ]: 0 : req->WriteReply(HTTP_FORBIDDEN);
239 : 0 : return false;
240 : : }
241 : 0 : }
242 : : }
243 : : }
244 : :
245 : : // Execute each request
246 : 171 : reply = UniValue::VARR;
247 [ + + ]: 13734 : for (size_t i{0}; i < valRequest.size(); ++i) {
248 : : // Batches never throw HTTP errors, they are always just included
249 : : // in "HTTP OK" responses. Notifications never get any response.
250 [ + - ]: 13563 : UniValue response;
251 : 13563 : try {
252 [ + - + + ]: 13563 : jreq.parse(valRequest[i]);
253 [ + - ]: 13551 : response = JSONRPCExec(jreq, /*catch_errors=*/true);
254 [ - + - ]: 12 : } catch (UniValue& e) {
255 [ + - + - : 12 : response = JSONRPCReplyObj(NullUniValue, std::move(e), jreq.id, jreq.m_json_version);
+ - ]
256 : 12 : } catch (const std::exception& e) {
257 [ - - - - : 0 : response = JSONRPCReplyObj(NullUniValue, JSONRPCError(RPC_PARSE_ERROR, e.what()), jreq.id, jreq.m_json_version);
- - - - -
- ]
258 : 0 : }
259 [ + + ]: 13563 : if (!jreq.IsNotification()) {
260 [ + - ]: 13558 : reply.push_back(std::move(response));
261 : : }
262 : 13563 : }
263 : : // Return no response for an all-notification batch, but only if the
264 : : // batch request is non-empty. Technically according to the JSON-RPC
265 : : // 2.0 spec, an empty batch request should also return no response,
266 : : // However, if the batch request is empty, it means the request did
267 : : // not contain any JSON-RPC version numbers, so returning an empty
268 : : // response could break backwards compatibility with old RPC clients
269 : : // relying on previous behavior. Return an empty array instead of an
270 : : // empty response in this case to favor being backwards compatible
271 : : // over complying with the JSON-RPC 2.0 spec in this case.
272 [ + + + + ]: 171 : if (reply.size() == 0 && valRequest.size() > 0) {
273 [ + - ]: 1 : req->WriteReply(HTTP_NO_CONTENT);
274 : : return true;
275 : : }
276 : : }
277 : : else
278 [ # # # # ]: 0 : throw JSONRPCError(RPC_PARSE_ERROR, "Top-level object parse error");
279 : :
280 [ + - + - : 375788 : req->WriteHeader("Content-Type", "application/json");
+ - ]
281 [ + - + - ]: 563682 : req->WriteReply(HTTP_OK, reply.write() + "\n");
282 [ - + - ]: 187918 : } catch (UniValue& e) {
283 [ + - ]: 6 : JSONErrorReply(req, std::move(e), jreq);
284 : 6 : return false;
285 : 6 : } catch (const std::exception& e) {
286 [ - - - - : 0 : JSONErrorReply(req, JSONRPCError(RPC_PARSE_ERROR, e.what()), jreq);
- - ]
287 : 0 : return false;
288 : 0 : }
289 : 187894 : return true;
290 : 375862 : }
291 : :
292 : 1003 : static bool InitRPCAuthentication()
293 : : {
294 [ + - + - : 1003 : if (gArgs.GetArg("-rpcpassword", "") == "")
+ + ]
295 : : {
296 : 1002 : std::optional<fs::perms> cookie_perms{std::nullopt};
297 [ + - ]: 1002 : auto cookie_perms_arg{gArgs.GetArg("-rpccookieperms")};
298 [ + + ]: 1002 : if (cookie_perms_arg) {
299 [ + - ]: 3 : auto perm_opt = InterpretPermString(*cookie_perms_arg);
300 [ - + ]: 3 : if (!perm_opt) {
301 [ # # ]: 0 : LogError("Invalid -rpccookieperms=%s; must be one of 'owner', 'group', or 'all'.", *cookie_perms_arg);
302 : : return false;
303 : : }
304 : 3 : cookie_perms = *perm_opt;
305 : : }
306 : :
307 [ - + ]: 1002 : assert(strRPCUserColonPass.empty()); // Only support initializing once
308 [ + - + + ]: 1002 : if (!GenerateAuthCookie(&strRPCUserColonPass, cookie_perms)) {
309 : : return false;
310 : : }
311 [ + + ]: 1001 : if (strRPCUserColonPass.empty()) {
312 [ + - ]: 1 : LogInfo("RPC authentication cookie file generation is disabled.");
313 : : } else {
314 [ + - ]: 1000 : LogInfo("Using random cookie authentication.");
315 : : }
316 : 1002 : } else {
317 : 1 : LogPrintf("Config options rpcuser and rpcpassword will soon be deprecated. Locally-run instances may remove rpcuser to use cookie-based auth, or may be replaced with rpcauth. Please see share/rpcauth for rpcauth auth generation.\n");
318 [ + - + - : 2 : strRPCUserColonPass = gArgs.GetArg("-rpcuser", "") + ":" + gArgs.GetArg("-rpcpassword", "");
+ - + - +
- + - ]
319 : : }
320 : :
321 [ + - + + ]: 1002 : if (!gArgs.GetArgs("-rpcauth").empty()) {
322 : 16 : LogInfo("Using rpcauth authentication.\n");
323 [ + - + + ]: 37 : for (const std::string& rpcauth : gArgs.GetArgs("-rpcauth")) {
324 [ + - ]: 32 : std::vector<std::string> fields{SplitString(rpcauth, ':')};
325 [ + - ]: 32 : const std::vector<std::string> salt_hmac{SplitString(fields.back(), '$')};
326 [ + + + + ]: 32 : if (fields.size() == 2 && salt_hmac.size() == 2) {
327 : 21 : fields.pop_back();
328 [ + - ]: 21 : fields.insert(fields.end(), salt_hmac.begin(), salt_hmac.end());
329 [ + - ]: 21 : g_rpcauth.push_back(fields);
330 : : } else {
331 [ + - ]: 11 : LogPrintf("Invalid -rpcauth argument.\n");
332 : 11 : return false;
333 : : }
334 : 37 : }
335 : : }
336 : :
337 [ + - + - : 991 : g_rpc_whitelist_default = gArgs.GetBoolArg("-rpcwhitelistdefault", gArgs.IsArgSet("-rpcwhitelist"));
+ - ]
338 [ + - + + ]: 999 : for (const std::string& strRPCWhitelist : gArgs.GetArgs("-rpcwhitelist")) {
339 : 8 : auto pos = strRPCWhitelist.find(':');
340 [ + - ]: 8 : std::string strUser = strRPCWhitelist.substr(0, pos);
341 : 8 : bool intersect = g_rpc_whitelist.count(strUser);
342 [ + - ]: 8 : std::set<std::string>& whitelist = g_rpc_whitelist[strUser];
343 [ + + ]: 8 : if (pos != std::string::npos) {
344 [ + - ]: 7 : std::string strWhitelist = strRPCWhitelist.substr(pos + 1);
345 [ + - ]: 7 : std::vector<std::string> whitelist_split = SplitString(strWhitelist, ", ");
346 [ + - ]: 7 : std::set<std::string> new_whitelist{
347 [ + - ]: 7 : std::make_move_iterator(whitelist_split.begin()),
348 [ + - ]: 7 : std::make_move_iterator(whitelist_split.end())};
349 [ + + ]: 7 : if (intersect) {
350 [ + - ]: 1 : std::set<std::string> tmp_whitelist;
351 [ + - ]: 1 : std::set_intersection(new_whitelist.begin(), new_whitelist.end(),
352 : : whitelist.begin(), whitelist.end(), std::inserter(tmp_whitelist, tmp_whitelist.end()));
353 : 1 : new_whitelist = std::move(tmp_whitelist);
354 : 1 : }
355 : 7 : whitelist = std::move(new_whitelist);
356 : 7 : }
357 : 8 : }
358 : :
359 : 991 : return true;
360 : : }
361 : :
362 : 1003 : bool StartHTTPRPC(const std::any& context)
363 : : {
364 [ + - ]: 1003 : LogDebug(BCLog::RPC, "Starting HTTP RPC server\n");
365 [ + + ]: 1003 : if (!InitRPCAuthentication())
366 : : return false;
367 : :
368 [ + - + - ]: 576678 : auto handle_rpc = [context](HTTPRequest* req, const std::string&) { return HTTPReq_JSONRPC(context, req); };
369 [ + - + - : 1982 : RegisterHTTPHandler("/", true, handle_rpc);
+ - ]
370 [ + - + - ]: 991 : if (g_wallet_init_interface.HasWalletSupport()) {
371 [ + - + - : 1982 : RegisterHTTPHandler("/wallet/", false, handle_rpc);
+ - ]
372 : : }
373 [ + - ]: 991 : struct event_base* eventBase = EventBase();
374 [ - + ]: 991 : assert(eventBase);
375 [ + - ]: 1982 : httpRPCTimerInterface = std::make_unique<HTTPRPCTimerInterface>(eventBase);
376 [ + - ]: 991 : RPCSetTimerInterface(httpRPCTimerInterface.get());
377 : 991 : return true;
378 : 991 : }
379 : :
380 : 1037 : void InterruptHTTPRPC()
381 : : {
382 [ + + ]: 1037 : LogDebug(BCLog::RPC, "Interrupting HTTP RPC server\n");
383 : 1037 : }
384 : :
385 : 1037 : void StopHTTPRPC()
386 : : {
387 [ + + ]: 1037 : LogDebug(BCLog::RPC, "Stopping HTTP RPC server\n");
388 [ + - ]: 1037 : UnregisterHTTPHandler("/", true);
389 [ + - ]: 1037 : if (g_wallet_init_interface.HasWalletSupport()) {
390 [ + - ]: 2074 : UnregisterHTTPHandler("/wallet/", false);
391 : : }
392 [ + + ]: 1037 : if (httpRPCTimerInterface) {
393 : 991 : RPCUnsetTimerInterface(httpRPCTimerInterface.get());
394 [ + - ]: 991 : httpRPCTimerInterface.reset();
395 : : }
396 : 1037 : }
|
