mirror of https://github.com/bitcoin/bitcoin
241 lines
8.1 KiB
C++
241 lines
8.1 KiB
C++
// Copyright (c) 2010 Satoshi Nakamoto
|
|
// Copyright (c) 2009-2022 The Bitcoin Core developers
|
|
// Distributed under the MIT software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include <rpc/request.h>
|
|
|
|
#include <util/fs.h>
|
|
|
|
#include <common/args.h>
|
|
#include <logging.h>
|
|
#include <random.h>
|
|
#include <rpc/protocol.h>
|
|
#include <util/fs_helpers.h>
|
|
#include <util/strencodings.h>
|
|
|
|
#include <fstream>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
/**
|
|
* JSON-RPC protocol. Bitcoin speaks version 1.0 for maximum compatibility,
|
|
* but uses JSON-RPC 1.1/2.0 standards for parts of the 1.0 standard that were
|
|
* unspecified (HTTP errors and contents of 'error').
|
|
*
|
|
* 1.0 spec: http://json-rpc.org/wiki/specification
|
|
* 1.2 spec: http://jsonrpc.org/historical/json-rpc-over-http.html
|
|
*
|
|
* If the server receives a request with the JSON-RPC 2.0 marker `{"jsonrpc": "2.0"}`
|
|
* then Bitcoin will respond with a strictly specified response.
|
|
* It will only return an HTTP error code if an actual HTTP error is encountered
|
|
* such as the endpoint is not found (404) or the request is not formatted correctly (500).
|
|
* Otherwise the HTTP code is always OK (200) and RPC errors will be included in the
|
|
* response body.
|
|
*
|
|
* 2.0 spec: https://www.jsonrpc.org/specification
|
|
*
|
|
* Also see http://www.simple-is-better.org/rpc/#differences-between-1-0-and-2-0
|
|
*/
|
|
|
|
UniValue JSONRPCRequestObj(const std::string& strMethod, const UniValue& params, const UniValue& id)
|
|
{
|
|
UniValue request(UniValue::VOBJ);
|
|
request.pushKV("method", strMethod);
|
|
request.pushKV("params", params);
|
|
request.pushKV("id", id);
|
|
return request;
|
|
}
|
|
|
|
UniValue JSONRPCReplyObj(UniValue result, UniValue error, const std::optional<UniValue>& id, JSONVersion json_version)
|
|
{
|
|
UniValue reply(UniValue::VOBJ);
|
|
// Add JSON-RPC version number field in v2 only.
|
|
if (json_version == JSONVersion::JSON_2_0) reply.pushKV("jsonrpc", "2.0");
|
|
|
|
// Add both result and error fields in v1, even though one will be null.
|
|
// Omit the null field in v2.
|
|
if (error.isNull()) {
|
|
reply.pushKV("result", result);
|
|
if (json_version == JSONVersion::JSON_1_BTC) reply.pushKV("error", NullUniValue);
|
|
} else {
|
|
if (json_version == JSONVersion::JSON_1_BTC) reply.pushKV("result", NullUniValue);
|
|
reply.pushKV("error", error);
|
|
}
|
|
if (id.has_value()) reply.pushKV("id", id.value());
|
|
return reply;
|
|
}
|
|
|
|
std::string JSONRPCReply(const UniValue& result, const UniValue& error, const JSONRPCRequest& jreq)
|
|
{
|
|
UniValue reply = JSONRPCReplyObj(result, error, jreq.id, jreq.m_json_version);
|
|
return reply.write() + "\n";
|
|
}
|
|
|
|
UniValue JSONRPCError(int code, const std::string& message)
|
|
{
|
|
UniValue error(UniValue::VOBJ);
|
|
error.pushKV("code", code);
|
|
error.pushKV("message", message);
|
|
return error;
|
|
}
|
|
|
|
/** Username used when cookie authentication is in use (arbitrary, only for
|
|
* recognizability in debugging/logging purposes)
|
|
*/
|
|
static const std::string COOKIEAUTH_USER = "__cookie__";
|
|
/** Default name for auth cookie file */
|
|
static const char* const COOKIEAUTH_FILE = ".cookie";
|
|
|
|
/** Get name of RPC authentication cookie file */
|
|
static fs::path GetAuthCookieFile(bool temp=false)
|
|
{
|
|
fs::path arg = gArgs.GetPathArg("-rpccookiefile", COOKIEAUTH_FILE);
|
|
if (temp) {
|
|
arg += ".tmp";
|
|
}
|
|
return AbsPathForConfigVal(gArgs, arg);
|
|
}
|
|
|
|
static bool g_generated_cookie = false;
|
|
|
|
bool GenerateAuthCookie(std::string *cookie_out)
|
|
{
|
|
const size_t COOKIE_SIZE = 32;
|
|
unsigned char rand_pwd[COOKIE_SIZE];
|
|
GetRandBytes(rand_pwd);
|
|
std::string cookie = COOKIEAUTH_USER + ":" + HexStr(rand_pwd);
|
|
|
|
/** the umask determines what permissions are used to create this file -
|
|
* these are set to 0077 in common/system.cpp.
|
|
*/
|
|
std::ofstream file;
|
|
fs::path filepath_tmp = GetAuthCookieFile(true);
|
|
file.open(filepath_tmp);
|
|
if (!file.is_open()) {
|
|
LogPrintf("Unable to open cookie authentication file %s for writing\n", fs::PathToString(filepath_tmp));
|
|
return false;
|
|
}
|
|
file << cookie;
|
|
file.close();
|
|
|
|
fs::path filepath = GetAuthCookieFile(false);
|
|
if (!RenameOver(filepath_tmp, filepath)) {
|
|
LogPrintf("Unable to rename cookie authentication file %s to %s\n", fs::PathToString(filepath_tmp), fs::PathToString(filepath));
|
|
return false;
|
|
}
|
|
g_generated_cookie = true;
|
|
LogPrintf("Generated RPC authentication cookie %s\n", fs::PathToString(filepath));
|
|
|
|
if (cookie_out)
|
|
*cookie_out = cookie;
|
|
return true;
|
|
}
|
|
|
|
bool GetAuthCookie(std::string *cookie_out)
|
|
{
|
|
std::ifstream file;
|
|
std::string cookie;
|
|
fs::path filepath = GetAuthCookieFile();
|
|
file.open(filepath);
|
|
if (!file.is_open())
|
|
return false;
|
|
std::getline(file, cookie);
|
|
file.close();
|
|
|
|
if (cookie_out)
|
|
*cookie_out = cookie;
|
|
return true;
|
|
}
|
|
|
|
void DeleteAuthCookie()
|
|
{
|
|
try {
|
|
if (g_generated_cookie) {
|
|
// Delete the cookie file if it was generated by this process
|
|
fs::remove(GetAuthCookieFile());
|
|
}
|
|
} catch (const fs::filesystem_error& e) {
|
|
LogPrintf("%s: Unable to remove random auth cookie file: %s\n", __func__, fsbridge::get_filesystem_error_message(e));
|
|
}
|
|
}
|
|
|
|
std::vector<UniValue> JSONRPCProcessBatchReply(const UniValue& in)
|
|
{
|
|
if (!in.isArray()) {
|
|
throw std::runtime_error("Batch must be an array");
|
|
}
|
|
const size_t num {in.size()};
|
|
std::vector<UniValue> batch(num);
|
|
for (const UniValue& rec : in.getValues()) {
|
|
if (!rec.isObject()) {
|
|
throw std::runtime_error("Batch member must be an object");
|
|
}
|
|
size_t id = rec["id"].getInt<int>();
|
|
if (id >= num) {
|
|
throw std::runtime_error("Batch member id is larger than batch size");
|
|
}
|
|
batch[id] = rec;
|
|
}
|
|
return batch;
|
|
}
|
|
|
|
void JSONRPCRequest::parse(const UniValue& valRequest)
|
|
{
|
|
// Parse request
|
|
if (!valRequest.isObject())
|
|
throw JSONRPCError(RPC_INVALID_REQUEST, "Invalid Request object");
|
|
const UniValue& request = valRequest.get_obj();
|
|
|
|
// Check for JSON-RPC 2.0 (default 1.1)
|
|
// We must do this before looking for the id field
|
|
m_json_version = JSONVersion::JSON_1_BTC;
|
|
const UniValue& valJsonRPC = request.find_value("jsonrpc");
|
|
if (!valJsonRPC.isNull()) {
|
|
if (!valJsonRPC.isStr()) {
|
|
throw JSONRPCError(RPC_INVALID_REQUEST, "jsonrpc field must be a string");
|
|
}
|
|
if (valJsonRPC.get_str() == "1.0") {
|
|
m_json_version = JSONVersion::JSON_1_BTC;
|
|
} else if (valJsonRPC.get_str() == "2.0") {
|
|
m_json_version = JSONVersion::JSON_2_0;
|
|
} else {
|
|
throw JSONRPCError(RPC_INVALID_REQUEST, "JSON-RPC version not supported");
|
|
}
|
|
}
|
|
|
|
// Parse id now so errors from here on will have the id.
|
|
// In 1.1 a default null value is inserted if no id field was present in the request
|
|
// In 2.0 a missing id field is a notification, but `"id": null` is not
|
|
if (m_json_version != JSONVersion::JSON_2_0 || request.exists("id")) {
|
|
id = request.find_value("id");
|
|
} else {
|
|
// Because we reuse JSONRPCRequest objects with multiple valRequests in
|
|
// a batch request, we may need to reset this optional value.
|
|
id.reset();
|
|
}
|
|
|
|
// Parse method
|
|
const UniValue& valMethod{request.find_value("method")};
|
|
if (valMethod.isNull())
|
|
throw JSONRPCError(RPC_INVALID_REQUEST, "Missing method");
|
|
if (!valMethod.isStr())
|
|
throw JSONRPCError(RPC_INVALID_REQUEST, "Method must be a string");
|
|
strMethod = valMethod.get_str();
|
|
if (fLogIPs)
|
|
LogPrint(BCLog::RPC, "ThreadRPCServer method=%s user=%s peeraddr=%s\n", SanitizeString(strMethod),
|
|
this->authUser, this->peerAddr);
|
|
else
|
|
LogPrint(BCLog::RPC, "ThreadRPCServer method=%s user=%s\n", SanitizeString(strMethod), this->authUser);
|
|
|
|
// Parse params
|
|
const UniValue& valParams{request.find_value("params")};
|
|
if (valParams.isArray() || valParams.isObject())
|
|
params = valParams;
|
|
else if (valParams.isNull())
|
|
params = UniValue(UniValue::VARR);
|
|
else
|
|
throw JSONRPCError(RPC_INVALID_REQUEST, "Params must be an array or object");
|
|
}
|