mirror of https://github.com/oxen-io/oxen-core.git
164 lines
5.9 KiB
C++
164 lines
5.9 KiB
C++
#include "uptime_proof.h"
|
|
|
|
#include "common/string_util.h"
|
|
#include "epee/string_tools.h"
|
|
#include "logging/oxen_logger.h"
|
|
#include "service_node_list.h"
|
|
#include "version.h"
|
|
|
|
extern "C" {
|
|
#include <sodium/crypto_sign.h>
|
|
}
|
|
|
|
namespace uptime_proof {
|
|
|
|
static auto logcat = oxen::log::Cat("uptime_proof");
|
|
|
|
// Constructor for the uptime proof, will take the service node keys as a param and sign
|
|
Proof::Proof(
|
|
uint32_t sn_public_ip,
|
|
uint16_t sn_storage_https_port,
|
|
uint16_t sn_storage_omq_port,
|
|
const std::array<uint16_t, 3> ss_version,
|
|
uint16_t quorumnet_port,
|
|
const std::array<uint16_t, 3> lokinet_version,
|
|
const service_nodes::service_node_keys& keys) :
|
|
version{OXEN_VERSION},
|
|
pubkey{keys.pub},
|
|
timestamp{static_cast<uint64_t>(time(nullptr))},
|
|
public_ip{sn_public_ip},
|
|
pubkey_ed25519{keys.pub_ed25519},
|
|
qnet_port{quorumnet_port},
|
|
storage_https_port{sn_storage_https_port},
|
|
storage_omq_port{sn_storage_omq_port},
|
|
storage_server_version{ss_version},
|
|
lokinet_version{lokinet_version} {
|
|
crypto::hash hash = hash_uptime_proof();
|
|
|
|
crypto::generate_signature(hash, keys.pub, keys.key, sig);
|
|
crypto_sign_detached(
|
|
sig_ed25519.data(), nullptr, hash.data(), hash.size(), keys.key_ed25519.data());
|
|
}
|
|
|
|
// Deserialize from a btencoded string into our Proof instance
|
|
Proof::Proof(const std::string& serialized_proof) {
|
|
try {
|
|
using namespace oxenc;
|
|
|
|
const bt_dict bt_proof = bt_deserialize<bt_dict>(serialized_proof);
|
|
// snode_version <X,X,X>
|
|
const bt_list& bt_version = var::get<bt_list>(bt_proof.at("v"));
|
|
int k = 0;
|
|
for (bt_value const& i : bt_version) {
|
|
version[k++] = static_cast<uint16_t>(get_int<unsigned>(i));
|
|
}
|
|
// timestamp
|
|
timestamp = get_int<unsigned>(bt_proof.at("t"));
|
|
// public_ip
|
|
bool succeeded = epee::string_tools::get_ip_int32_from_string(
|
|
public_ip, var::get<std::string>(bt_proof.at("ip")));
|
|
// storage_port
|
|
storage_https_port = static_cast<uint16_t>(get_int<unsigned>(bt_proof.at("shp")));
|
|
// pubkey_ed25519
|
|
pubkey_ed25519 = tools::make_from_guts<crypto::ed25519_public_key>(
|
|
var::get<std::string>(bt_proof.at("pke")));
|
|
// pubkey
|
|
if (auto it = bt_proof.find("pk"); it != bt_proof.end())
|
|
pubkey = tools::make_from_guts<crypto::public_key>(
|
|
var::get<std::string>(bt_proof.at("pk")));
|
|
else
|
|
std::memcpy(pubkey.data(), pubkey_ed25519.data(), 32);
|
|
// qnet_port
|
|
qnet_port = get_int<unsigned>(bt_proof.at("q"));
|
|
// storage_omq_port
|
|
storage_omq_port = get_int<unsigned>(bt_proof.at("sop"));
|
|
// storage_version
|
|
const bt_list& bt_storage_version = var::get<bt_list>(bt_proof.at("sv"));
|
|
k = 0;
|
|
for (bt_value const& i : bt_storage_version) {
|
|
storage_server_version[k++] = static_cast<uint16_t>(get_int<unsigned>(i));
|
|
}
|
|
// lokinet_version
|
|
const bt_list& bt_lokinet_version = var::get<bt_list>(bt_proof.at("lv"));
|
|
k = 0;
|
|
for (bt_value const& i : bt_lokinet_version) {
|
|
lokinet_version[k++] = static_cast<uint16_t>(get_int<unsigned>(i));
|
|
}
|
|
} catch (const std::exception& e) {
|
|
oxen::log::warning(logcat, "deserialization failed: {}", e.what());
|
|
throw;
|
|
}
|
|
}
|
|
|
|
crypto::hash Proof::hash_uptime_proof() const {
|
|
crypto::hash result;
|
|
|
|
std::string serialized_proof = bt_serialize(bt_encode_uptime_proof());
|
|
size_t buf_size = serialized_proof.size();
|
|
crypto::cn_fast_hash(serialized_proof.data(), buf_size, result);
|
|
return result;
|
|
}
|
|
|
|
oxenc::bt_dict Proof::bt_encode_uptime_proof() const {
|
|
oxenc::bt_dict encoded_proof{
|
|
// version
|
|
{"v", oxenc::bt_list{{version[0], version[1], version[2]}}},
|
|
// timestamp
|
|
{"t", timestamp},
|
|
// public_ip
|
|
{"ip", epee::string_tools::get_ip_string_from_int32(public_ip)},
|
|
// storage_port
|
|
{"shp", storage_https_port},
|
|
// pubkey_ed25519
|
|
{"pke", tools::view_guts(pubkey_ed25519)},
|
|
// qnet_port
|
|
{"q", qnet_port},
|
|
// storage_omq_port
|
|
{"sop", storage_omq_port},
|
|
// storage_version
|
|
{"sv",
|
|
oxenc::bt_list{
|
|
{storage_server_version[0],
|
|
storage_server_version[1],
|
|
storage_server_version[2]}}},
|
|
// lokinet_version
|
|
{"lv", oxenc::bt_list{{lokinet_version[0], lokinet_version[1], lokinet_version[2]}}},
|
|
};
|
|
|
|
if (tools::view_guts(pubkey) != tools::view_guts(pubkey_ed25519)) {
|
|
encoded_proof["pk"] = tools::view_guts(pubkey);
|
|
}
|
|
|
|
return encoded_proof;
|
|
}
|
|
|
|
cryptonote::NOTIFY_BTENCODED_UPTIME_PROOF::request Proof::generate_request() const {
|
|
cryptonote::NOTIFY_BTENCODED_UPTIME_PROOF::request request;
|
|
request.proof = bt_serialize(this->bt_encode_uptime_proof());
|
|
request.sig = tools::view_guts(this->sig);
|
|
request.ed_sig = tools::view_guts(this->sig_ed25519);
|
|
|
|
return request;
|
|
}
|
|
|
|
bool operator==(const Proof& lhs, const Proof& rhs) {
|
|
bool result = true;
|
|
|
|
if ((lhs.timestamp != rhs.timestamp) || (lhs.pubkey != rhs.pubkey) || (lhs.sig != rhs.sig) ||
|
|
(lhs.pubkey_ed25519 != rhs.pubkey_ed25519) || (lhs.sig_ed25519 != rhs.sig_ed25519) ||
|
|
(lhs.public_ip != rhs.public_ip) || (lhs.storage_https_port != rhs.storage_https_port) ||
|
|
(lhs.storage_omq_port != rhs.storage_omq_port) || (lhs.qnet_port != rhs.qnet_port) ||
|
|
(lhs.version != rhs.version) ||
|
|
(lhs.storage_server_version != rhs.storage_server_version) ||
|
|
(lhs.lokinet_version != rhs.lokinet_version))
|
|
result = false;
|
|
|
|
return result;
|
|
}
|
|
|
|
bool operator!=(const Proof& lhs, const Proof& rhs) {
|
|
return !(lhs == rhs);
|
|
}
|
|
|
|
} // namespace uptime_proof
|