2019-01-05 00:49:06 +00:00
|
|
|
#include <router_contact.hpp>
|
|
|
|
|
2019-01-10 19:41:51 +00:00
|
|
|
#include <constants/version.hpp>
|
2019-01-13 14:00:50 +00:00
|
|
|
#include <crypto/crypto.hpp>
|
2019-01-11 01:42:02 +00:00
|
|
|
#include <net/net.hpp>
|
2019-01-10 19:41:51 +00:00
|
|
|
#include <util/bencode.hpp>
|
|
|
|
#include <util/buffer.hpp>
|
2019-09-01 12:10:49 +00:00
|
|
|
#include <util/logging/logger.hpp>
|
2019-01-10 19:41:51 +00:00
|
|
|
#include <util/mem.hpp>
|
2019-02-24 23:46:37 +00:00
|
|
|
#include <util/printer.hpp>
|
2019-01-10 19:41:51 +00:00
|
|
|
#include <util/time.hpp>
|
2018-05-27 13:42:55 +00:00
|
|
|
|
2018-08-31 12:46:54 +00:00
|
|
|
#include <fstream>
|
2019-06-24 16:39:03 +00:00
|
|
|
#include <util/fs.hpp>
|
2018-08-31 12:46:54 +00:00
|
|
|
|
2018-08-30 18:48:43 +00:00
|
|
|
namespace llarp
|
2018-07-08 13:26:24 +00:00
|
|
|
{
|
2019-01-05 00:49:06 +00:00
|
|
|
NetID &
|
|
|
|
NetID::DefaultValue()
|
|
|
|
{
|
|
|
|
static NetID defaultID(
|
2019-12-12 02:32:27 +00:00
|
|
|
reinterpret_cast< const byte_t * >(llarp::DEFAULT_NETID));
|
2019-01-05 00:49:06 +00:00
|
|
|
return defaultID;
|
|
|
|
}
|
2018-12-21 13:08:01 +00:00
|
|
|
|
2019-08-26 23:29:17 +00:00
|
|
|
bool RouterContact::BlockBogons = true;
|
2018-12-17 20:46:08 +00:00
|
|
|
|
2018-12-19 16:19:16 +00:00
|
|
|
#ifdef TESTNET
|
|
|
|
// 1 minute for testnet
|
|
|
|
llarp_time_t RouterContact::Lifetime = 60 * 1000;
|
|
|
|
#else
|
2018-12-19 17:48:29 +00:00
|
|
|
/// 1 day for real network
|
|
|
|
llarp_time_t RouterContact::Lifetime = 24 * 60 * 60 * 1000;
|
2018-12-19 16:19:16 +00:00
|
|
|
#endif
|
2020-01-18 21:07:21 +00:00
|
|
|
/// an RC inserted long enough ago (4 hrs) is considered stale and is removed
|
|
|
|
llarp_time_t RouterContact::StaleInsertionAge = 4 * 60 * 60 * 1000;
|
2020-01-18 21:37:42 +00:00
|
|
|
/// update RCs shortly before they are about to expire
|
|
|
|
llarp_time_t RouterContact::UpdateInterval =
|
|
|
|
RouterContact::StaleInsertionAge - (5 * 60 * 1000);
|
2019-01-02 22:21:29 +00:00
|
|
|
|
2019-08-26 23:29:17 +00:00
|
|
|
NetID::NetID(const byte_t *val)
|
2019-01-05 00:49:06 +00:00
|
|
|
{
|
|
|
|
size_t len = strnlen(reinterpret_cast< const char * >(val), size());
|
|
|
|
std::copy(val, val + len, begin());
|
|
|
|
}
|
|
|
|
|
|
|
|
NetID::NetID() : NetID(DefaultValue().data())
|
2018-12-19 16:17:41 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
NetID::operator==(const NetID &other) const
|
|
|
|
{
|
2018-12-28 15:04:05 +00:00
|
|
|
return ToString() == other.ToString();
|
2018-12-19 16:17:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
std::string
|
|
|
|
NetID::ToString() const
|
|
|
|
{
|
2019-01-02 01:03:53 +00:00
|
|
|
auto term = std::find(begin(), end(), '\0');
|
|
|
|
return std::string(begin(), term);
|
2018-12-19 16:17:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
NetID::BDecode(llarp_buffer_t *buf)
|
|
|
|
{
|
|
|
|
Zero();
|
|
|
|
llarp_buffer_t strbuf;
|
|
|
|
if(!bencode_read_string(buf, &strbuf))
|
|
|
|
return false;
|
2019-08-26 23:29:17 +00:00
|
|
|
|
2018-12-28 15:04:05 +00:00
|
|
|
if(strbuf.sz > size())
|
2018-12-19 16:17:41 +00:00
|
|
|
return false;
|
2019-01-02 01:03:53 +00:00
|
|
|
|
2019-01-02 01:04:04 +00:00
|
|
|
std::copy(strbuf.base, strbuf.base + strbuf.sz, begin());
|
2018-12-19 16:17:41 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
NetID::BEncode(llarp_buffer_t *buf) const
|
|
|
|
{
|
2019-01-02 01:03:53 +00:00
|
|
|
auto term = std::find(begin(), end(), '\0');
|
2019-04-19 18:24:33 +00:00
|
|
|
return bencode_write_bytestring(buf, data(), std::distance(begin(), term));
|
2018-12-19 16:17:41 +00:00
|
|
|
}
|
|
|
|
|
2018-08-30 18:48:43 +00:00
|
|
|
bool
|
|
|
|
RouterContact::BEncode(llarp_buffer_t *buf) const
|
2018-05-13 18:07:36 +00:00
|
|
|
{
|
2018-08-30 18:48:43 +00:00
|
|
|
/* write dict begin */
|
|
|
|
if(!bencode_start_dict(buf))
|
2018-06-10 14:05:48 +00:00
|
|
|
return false;
|
|
|
|
|
2018-08-30 18:48:43 +00:00
|
|
|
/* write ai if they exist */
|
|
|
|
if(!bencode_write_bytestring(buf, "a", 1))
|
2018-05-13 18:07:36 +00:00
|
|
|
return false;
|
2018-08-30 18:48:43 +00:00
|
|
|
if(!BEncodeWriteList(addrs.begin(), addrs.end(), buf))
|
2018-05-13 18:07:36 +00:00
|
|
|
return false;
|
|
|
|
|
2018-12-19 16:17:41 +00:00
|
|
|
/* write netid */
|
|
|
|
if(!bencode_write_bytestring(buf, "i", 1))
|
|
|
|
return false;
|
2018-12-21 13:08:01 +00:00
|
|
|
if(!netID.BEncode(buf))
|
2018-12-19 16:17:41 +00:00
|
|
|
return false;
|
2018-08-30 18:48:43 +00:00
|
|
|
/* write signing pubkey */
|
|
|
|
if(!bencode_write_bytestring(buf, "k", 1))
|
2018-05-22 18:41:38 +00:00
|
|
|
return false;
|
2018-08-30 18:48:43 +00:00
|
|
|
if(!pubkey.BEncode(buf))
|
2018-05-13 18:07:36 +00:00
|
|
|
return false;
|
|
|
|
|
2018-08-30 18:48:43 +00:00
|
|
|
std::string nick = Nick();
|
2019-08-26 23:29:17 +00:00
|
|
|
if(!nick.empty())
|
2018-05-22 15:54:19 +00:00
|
|
|
{
|
2018-08-30 18:48:43 +00:00
|
|
|
/* write nickname */
|
|
|
|
if(!bencode_write_bytestring(buf, "n", 1))
|
2019-08-26 23:29:17 +00:00
|
|
|
{
|
2018-08-30 18:48:43 +00:00
|
|
|
return false;
|
2019-08-26 23:29:17 +00:00
|
|
|
}
|
2018-08-30 18:48:43 +00:00
|
|
|
if(!bencode_write_bytestring(buf, nick.c_str(), nick.size()))
|
2019-08-26 23:29:17 +00:00
|
|
|
{
|
2018-08-30 18:48:43 +00:00
|
|
|
return false;
|
2019-08-26 23:29:17 +00:00
|
|
|
}
|
2018-05-22 15:54:19 +00:00
|
|
|
}
|
2018-05-13 18:07:36 +00:00
|
|
|
|
2018-08-30 18:48:43 +00:00
|
|
|
/* write encryption pubkey */
|
|
|
|
if(!bencode_write_bytestring(buf, "p", 1))
|
2018-05-13 18:07:36 +00:00
|
|
|
return false;
|
2018-08-30 18:48:43 +00:00
|
|
|
if(!enckey.BEncode(buf))
|
2018-05-13 18:07:36 +00:00
|
|
|
return false;
|
2020-01-25 16:28:07 +00:00
|
|
|
// write router version if present
|
|
|
|
if(routerVersion.has_value())
|
|
|
|
{
|
|
|
|
if(not BEncodeWriteDictEntry("r", routerVersion.value(), buf))
|
|
|
|
return false;
|
|
|
|
}
|
2018-08-30 18:48:43 +00:00
|
|
|
/* write last updated */
|
2019-01-24 13:18:15 +00:00
|
|
|
if(!bencode_write_bytestring(buf, "u", 1))
|
2018-08-30 18:48:43 +00:00
|
|
|
return false;
|
|
|
|
if(!bencode_write_uint64(buf, last_updated))
|
|
|
|
return false;
|
2018-05-13 18:07:36 +00:00
|
|
|
|
2019-11-22 17:39:35 +00:00
|
|
|
/* write versions */
|
|
|
|
if(!bencode_write_uint64_entry(buf, "v", 1, version))
|
2018-08-30 18:48:43 +00:00
|
|
|
return false;
|
2018-05-25 17:52:10 +00:00
|
|
|
|
2018-11-28 14:58:38 +00:00
|
|
|
/* write xi if they exist */
|
2018-08-30 18:48:43 +00:00
|
|
|
if(!bencode_write_bytestring(buf, "x", 1))
|
2018-05-22 15:54:19 +00:00
|
|
|
return false;
|
2018-08-30 18:48:43 +00:00
|
|
|
if(!BEncodeWriteList(exits.begin(), exits.end(), buf))
|
2018-05-22 15:54:19 +00:00
|
|
|
return false;
|
2018-06-10 14:05:48 +00:00
|
|
|
|
2018-08-30 18:48:43 +00:00
|
|
|
/* write signature */
|
|
|
|
if(!bencode_write_bytestring(buf, "z", 1))
|
|
|
|
return false;
|
|
|
|
if(!signature.BEncode(buf))
|
|
|
|
return false;
|
|
|
|
return bencode_end(buf);
|
|
|
|
}
|
2018-05-10 23:32:46 +00:00
|
|
|
|
2018-08-31 13:51:24 +00:00
|
|
|
void
|
|
|
|
RouterContact::Clear()
|
|
|
|
{
|
|
|
|
addrs.clear();
|
|
|
|
exits.clear();
|
|
|
|
signature.Zero();
|
|
|
|
nickname.Zero();
|
|
|
|
enckey.Zero();
|
|
|
|
pubkey.Zero();
|
2020-01-25 16:28:07 +00:00
|
|
|
routerVersion = absl::optional< RouterVersion >{};
|
|
|
|
last_updated = 0;
|
2018-08-31 13:51:24 +00:00
|
|
|
}
|
|
|
|
|
2019-02-11 17:14:43 +00:00
|
|
|
util::StatusObject
|
|
|
|
RouterContact::ExtractStatus() const
|
2019-02-08 19:43:25 +00:00
|
|
|
{
|
2019-02-11 17:14:43 +00:00
|
|
|
util::StatusObject obj{{"lastUpdated", last_updated},
|
|
|
|
{"exit", IsExit()},
|
|
|
|
{"publicRouter", IsPublicRouter()},
|
2019-08-19 22:25:40 +00:00
|
|
|
{"identity", pubkey.ToString()},
|
|
|
|
{"addresses", addrs}};
|
|
|
|
|
2019-02-08 19:43:25 +00:00
|
|
|
if(HasNick())
|
2019-08-26 23:29:17 +00:00
|
|
|
{
|
2019-08-19 09:33:26 +00:00
|
|
|
obj["nickname"] = Nick();
|
2019-08-26 23:29:17 +00:00
|
|
|
}
|
2020-01-25 16:28:07 +00:00
|
|
|
if(routerVersion.has_value())
|
|
|
|
{
|
|
|
|
obj["routerVersion"] = routerVersion->ToString();
|
|
|
|
}
|
2019-02-11 17:14:43 +00:00
|
|
|
return obj;
|
2019-02-08 19:43:25 +00:00
|
|
|
}
|
|
|
|
|
2018-08-30 18:48:43 +00:00
|
|
|
bool
|
2019-02-01 01:58:06 +00:00
|
|
|
RouterContact::DecodeKey(const llarp_buffer_t &key, llarp_buffer_t *buf)
|
2018-08-09 15:36:58 +00:00
|
|
|
{
|
2018-08-30 18:48:43 +00:00
|
|
|
bool read = false;
|
|
|
|
if(!BEncodeMaybeReadDictList("a", addrs, read, key, buf))
|
2018-08-09 15:36:58 +00:00
|
|
|
return false;
|
2018-08-30 18:48:43 +00:00
|
|
|
|
2018-12-19 16:17:41 +00:00
|
|
|
if(!BEncodeMaybeReadDictEntry("i", netID, read, key, buf))
|
|
|
|
return false;
|
|
|
|
|
2018-08-30 18:48:43 +00:00
|
|
|
if(!BEncodeMaybeReadDictEntry("k", pubkey, read, key, buf))
|
2018-08-09 15:36:58 +00:00
|
|
|
return false;
|
2018-08-02 00:48:43 +00:00
|
|
|
|
2020-01-25 16:28:07 +00:00
|
|
|
if(key == "r")
|
|
|
|
{
|
|
|
|
RouterVersion r;
|
|
|
|
if(not r.BDecode(buf))
|
|
|
|
return false;
|
|
|
|
routerVersion = r;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2019-02-17 12:13:34 +00:00
|
|
|
if(key == "n")
|
2018-08-31 13:51:24 +00:00
|
|
|
{
|
|
|
|
llarp_buffer_t strbuf;
|
|
|
|
if(!bencode_read_string(buf, &strbuf))
|
2019-08-26 23:29:17 +00:00
|
|
|
{
|
2018-08-31 13:51:24 +00:00
|
|
|
return false;
|
2019-08-26 23:29:17 +00:00
|
|
|
}
|
|
|
|
if(strbuf.sz > llarp::AlignedBuffer< (32) >::size())
|
|
|
|
{
|
2018-08-31 13:51:24 +00:00
|
|
|
return false;
|
2019-08-26 23:29:17 +00:00
|
|
|
}
|
2018-08-31 13:51:24 +00:00
|
|
|
nickname.Zero();
|
2019-01-02 22:21:29 +00:00
|
|
|
std::copy(strbuf.base, strbuf.base + strbuf.sz, nickname.begin());
|
2018-08-31 13:51:24 +00:00
|
|
|
return true;
|
|
|
|
}
|
2018-06-12 12:49:23 +00:00
|
|
|
|
2018-08-30 18:48:43 +00:00
|
|
|
if(!BEncodeMaybeReadDictEntry("p", enckey, read, key, buf))
|
|
|
|
return false;
|
2018-05-21 12:44:50 +00:00
|
|
|
|
2019-01-24 13:18:15 +00:00
|
|
|
if(!BEncodeMaybeReadDictInt("u", last_updated, read, key, buf))
|
2018-08-31 13:51:24 +00:00
|
|
|
return false;
|
|
|
|
|
2019-01-24 13:18:15 +00:00
|
|
|
if(!BEncodeMaybeReadDictInt("v", version, read, key, buf))
|
2018-08-30 18:48:43 +00:00
|
|
|
return false;
|
2018-05-10 23:32:46 +00:00
|
|
|
|
2018-08-30 18:48:43 +00:00
|
|
|
if(!BEncodeMaybeReadDictList("x", exits, read, key, buf))
|
2018-05-22 15:54:19 +00:00
|
|
|
return false;
|
2018-08-30 18:48:43 +00:00
|
|
|
|
|
|
|
if(!BEncodeMaybeReadDictEntry("z", signature, read, key, buf))
|
2018-05-22 15:54:19 +00:00
|
|
|
return false;
|
2018-08-30 18:48:43 +00:00
|
|
|
|
|
|
|
return read;
|
2018-05-10 23:32:46 +00:00
|
|
|
}
|
|
|
|
|
2018-08-31 12:46:54 +00:00
|
|
|
bool
|
|
|
|
RouterContact::IsPublicRouter() const
|
|
|
|
{
|
2019-08-26 23:29:17 +00:00
|
|
|
return !addrs.empty();
|
2018-08-31 12:46:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
RouterContact::HasNick() const
|
|
|
|
{
|
|
|
|
return nickname[0] != 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2019-07-02 21:28:28 +00:00
|
|
|
RouterContact::SetNick(string_view nick)
|
2018-08-31 12:46:54 +00:00
|
|
|
{
|
|
|
|
nickname.Zero();
|
2019-01-02 01:04:03 +00:00
|
|
|
std::copy(nick.begin(),
|
|
|
|
nick.begin() + std::min(nick.size(), nickname.size()),
|
|
|
|
nickname.begin());
|
2018-08-31 12:46:54 +00:00
|
|
|
}
|
|
|
|
|
2018-12-19 16:17:41 +00:00
|
|
|
bool
|
|
|
|
RouterContact::IsExpired(llarp_time_t now) const
|
2019-07-15 16:56:09 +00:00
|
|
|
{
|
2019-09-09 11:36:21 +00:00
|
|
|
(void)now;
|
2019-09-09 10:37:26 +00:00
|
|
|
return false;
|
|
|
|
// return Age(now) >= Lifetime;
|
2019-07-15 16:56:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
llarp_time_t
|
|
|
|
RouterContact::TimeUntilExpires(llarp_time_t now) const
|
2018-12-19 16:17:41 +00:00
|
|
|
{
|
2019-06-04 13:19:45 +00:00
|
|
|
const auto expiresAt = last_updated + Lifetime;
|
2019-07-15 16:56:09 +00:00
|
|
|
return now < expiresAt ? expiresAt - now : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
llarp_time_t
|
|
|
|
RouterContact::Age(llarp_time_t now) const
|
|
|
|
{
|
|
|
|
return now > last_updated ? now - last_updated : 0;
|
2018-12-19 16:17:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
RouterContact::ExpiresSoon(llarp_time_t now, llarp_time_t dlt) const
|
|
|
|
{
|
2019-07-15 16:56:09 +00:00
|
|
|
return TimeUntilExpires(now) <= dlt;
|
2018-12-19 16:17:41 +00:00
|
|
|
}
|
|
|
|
|
2018-08-31 12:46:54 +00:00
|
|
|
std::string
|
|
|
|
RouterContact::Nick() const
|
|
|
|
{
|
2019-01-02 01:03:53 +00:00
|
|
|
auto term = std::find(nickname.begin(), nickname.end(), '\0');
|
|
|
|
return std::string(nickname.begin(), term);
|
2018-08-31 12:46:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
2019-05-28 19:45:08 +00:00
|
|
|
RouterContact::Sign(const SecretKey &secretkey)
|
2018-08-31 12:46:54 +00:00
|
|
|
{
|
2019-02-02 23:12:42 +00:00
|
|
|
pubkey = llarp::seckey_topublic(secretkey);
|
|
|
|
std::array< byte_t, MAX_RC_SIZE > tmp;
|
|
|
|
llarp_buffer_t buf(tmp);
|
2018-08-31 12:46:54 +00:00
|
|
|
signature.Zero();
|
2018-11-19 22:45:37 +00:00
|
|
|
last_updated = time_now_ms();
|
2018-08-31 12:46:54 +00:00
|
|
|
if(!BEncode(&buf))
|
2019-08-26 23:29:17 +00:00
|
|
|
{
|
2018-08-31 12:46:54 +00:00
|
|
|
return false;
|
2019-08-26 23:29:17 +00:00
|
|
|
}
|
2018-08-31 12:46:54 +00:00
|
|
|
buf.sz = buf.cur - buf.base;
|
|
|
|
buf.cur = buf.base;
|
2019-05-28 19:45:08 +00:00
|
|
|
return CryptoManager::instance()->sign(signature, secretkey, buf);
|
2018-08-31 12:46:54 +00:00
|
|
|
}
|
|
|
|
|
2018-10-15 12:02:32 +00:00
|
|
|
bool
|
2019-06-04 13:19:45 +00:00
|
|
|
RouterContact::Verify(llarp_time_t now, bool allowExpired) const
|
2018-10-15 12:02:32 +00:00
|
|
|
{
|
2019-01-17 15:11:17 +00:00
|
|
|
if(netID != NetID::DefaultValue())
|
2018-12-28 15:04:05 +00:00
|
|
|
{
|
2019-01-17 15:11:17 +00:00
|
|
|
llarp::LogError("netid missmatch: '", netID, "' != '",
|
|
|
|
NetID::DefaultValue(), "'");
|
2018-12-19 16:17:41 +00:00
|
|
|
return false;
|
2018-12-28 15:04:05 +00:00
|
|
|
}
|
2018-12-19 16:17:41 +00:00
|
|
|
if(IsExpired(now))
|
2018-12-28 15:04:05 +00:00
|
|
|
{
|
2019-06-04 13:19:45 +00:00
|
|
|
if(!allowExpired)
|
|
|
|
{
|
|
|
|
llarp::LogError("RC is expired");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
llarp::LogWarn("RC is expired");
|
2018-12-28 15:04:05 +00:00
|
|
|
}
|
2018-10-15 12:02:32 +00:00
|
|
|
for(const auto &a : addrs)
|
|
|
|
{
|
2019-08-26 23:29:17 +00:00
|
|
|
if(IsBogon(a.ip) && BlockBogons)
|
2018-10-15 12:02:32 +00:00
|
|
|
{
|
|
|
|
llarp::LogError("invalid address info: ", a);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for(const auto &exit : exits)
|
|
|
|
{
|
|
|
|
if(IsBogonRange(exit.address, exit.netmask))
|
2019-04-08 17:40:51 +00:00
|
|
|
{
|
|
|
|
llarp::LogError("bogon exit: ", exit);
|
2018-10-15 12:02:32 +00:00
|
|
|
return false;
|
2019-04-08 17:40:51 +00:00
|
|
|
}
|
2018-10-15 12:02:32 +00:00
|
|
|
}
|
2019-05-28 19:45:08 +00:00
|
|
|
if(!VerifySignature())
|
2018-12-28 15:04:05 +00:00
|
|
|
{
|
2020-01-15 15:42:28 +00:00
|
|
|
llarp::LogError("invalid signature: ", *this);
|
2018-12-28 15:04:05 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
2018-10-15 12:02:32 +00:00
|
|
|
}
|
|
|
|
|
2018-08-31 12:46:54 +00:00
|
|
|
bool
|
2019-05-28 19:45:08 +00:00
|
|
|
RouterContact::VerifySignature() const
|
2018-08-31 12:46:54 +00:00
|
|
|
{
|
2018-08-31 13:51:24 +00:00
|
|
|
RouterContact copy;
|
|
|
|
copy = *this;
|
2018-08-31 12:46:54 +00:00
|
|
|
copy.signature.Zero();
|
2019-02-02 23:12:42 +00:00
|
|
|
std::array< byte_t, MAX_RC_SIZE > tmp;
|
|
|
|
llarp_buffer_t buf(tmp);
|
2018-08-31 12:46:54 +00:00
|
|
|
if(!copy.BEncode(&buf))
|
2018-08-31 13:51:24 +00:00
|
|
|
{
|
|
|
|
llarp::LogError("bencode failed");
|
2018-08-31 12:46:54 +00:00
|
|
|
return false;
|
2018-08-31 13:51:24 +00:00
|
|
|
}
|
2018-08-31 12:46:54 +00:00
|
|
|
buf.sz = buf.cur - buf.base;
|
|
|
|
buf.cur = buf.base;
|
2019-05-28 19:45:08 +00:00
|
|
|
return CryptoManager::instance()->verify(pubkey, buf, signature);
|
2018-08-31 12:46:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
RouterContact::Write(const char *fname) const
|
|
|
|
{
|
2019-02-02 23:12:42 +00:00
|
|
|
std::array< byte_t, MAX_RC_SIZE > tmp;
|
|
|
|
llarp_buffer_t buf(tmp);
|
2018-08-31 12:46:54 +00:00
|
|
|
if(!BEncode(&buf))
|
2019-08-26 23:29:17 +00:00
|
|
|
{
|
2018-08-31 12:46:54 +00:00
|
|
|
return false;
|
2019-08-26 23:29:17 +00:00
|
|
|
}
|
2019-06-24 16:39:03 +00:00
|
|
|
buf.sz = buf.cur - buf.base;
|
|
|
|
buf.cur = buf.base;
|
|
|
|
const fs::path fpath = std::string(fname); /* */
|
|
|
|
auto optional_f =
|
|
|
|
llarp::util::OpenFileStream< std::ofstream >(fpath, std::ios::binary);
|
|
|
|
if(!optional_f)
|
2019-08-26 23:29:17 +00:00
|
|
|
{
|
2019-06-24 16:39:03 +00:00
|
|
|
return false;
|
2019-08-26 23:29:17 +00:00
|
|
|
}
|
2019-06-24 16:39:03 +00:00
|
|
|
auto &f = optional_f.value();
|
2019-01-11 01:44:45 +00:00
|
|
|
if(!f.is_open())
|
2019-08-26 23:29:17 +00:00
|
|
|
{
|
2019-01-11 01:44:45 +00:00
|
|
|
return false;
|
2019-08-26 23:29:17 +00:00
|
|
|
}
|
2019-01-11 01:44:45 +00:00
|
|
|
f.write((char *)buf.base, buf.sz);
|
2018-08-31 12:46:54 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
RouterContact::Read(const char *fname)
|
|
|
|
{
|
2019-02-02 23:12:42 +00:00
|
|
|
std::array< byte_t, MAX_RC_SIZE > tmp;
|
|
|
|
llarp_buffer_t buf(tmp);
|
2019-01-11 01:44:45 +00:00
|
|
|
std::ifstream f;
|
|
|
|
f.open(fname, std::ios::binary);
|
|
|
|
if(!f.is_open())
|
2018-08-31 12:46:54 +00:00
|
|
|
{
|
2019-01-11 01:44:45 +00:00
|
|
|
llarp::LogError("Failed to open ", fname);
|
|
|
|
return false;
|
2018-08-31 12:46:54 +00:00
|
|
|
}
|
2019-01-11 01:44:45 +00:00
|
|
|
f.seekg(0, std::ios::end);
|
2019-01-26 11:12:48 +00:00
|
|
|
auto l = f.tellg();
|
|
|
|
if(l > static_cast< std::streamoff >(sizeof tmp))
|
2019-08-26 23:29:17 +00:00
|
|
|
{
|
2019-01-24 15:13:41 +00:00
|
|
|
return false;
|
2019-08-26 23:29:17 +00:00
|
|
|
}
|
2019-01-11 01:44:45 +00:00
|
|
|
f.seekg(0, std::ios::beg);
|
2019-02-02 23:12:42 +00:00
|
|
|
f.read((char *)tmp.data(), l);
|
2018-08-31 12:46:54 +00:00
|
|
|
return BDecode(&buf);
|
|
|
|
}
|
|
|
|
|
2019-02-24 23:46:37 +00:00
|
|
|
std::ostream &
|
|
|
|
RouterContact::print(std::ostream &stream, int level, int spaces) const
|
|
|
|
{
|
|
|
|
Printer printer(stream, level, spaces);
|
|
|
|
printer.printAttribute("k", pubkey);
|
|
|
|
printer.printAttribute("updated", last_updated);
|
|
|
|
printer.printAttribute("netid", netID);
|
|
|
|
printer.printAttribute("v", version);
|
|
|
|
printer.printAttribute("ai", addrs);
|
|
|
|
printer.printAttribute("xi", exits);
|
|
|
|
printer.printAttribute("e", enckey);
|
|
|
|
printer.printAttribute("z", signature);
|
|
|
|
|
|
|
|
return stream;
|
|
|
|
}
|
|
|
|
|
2018-08-30 18:48:43 +00:00
|
|
|
} // namespace llarp
|