lokinet/llarp/router_contact.cpp

386 lines
8.7 KiB
C++
Raw Normal View History

2019-01-05 00:49:06 +00:00
#include <router_contact.hpp>
#include <constants/version.hpp>
2019-01-13 14:00:50 +00:00
#include <crypto/crypto.hpp>
#include <net/net.hpp>
#include <util/bencode.hpp>
#include <util/buffer.hpp>
#include <util/logger.hpp>
#include <util/mem.hpp>
#include <util/time.hpp>
2018-08-31 12:46:54 +00:00
#include <fstream>
2018-08-30 18:48:43 +00:00
namespace llarp
{
2019-01-05 00:49:06 +00:00
NetID &
NetID::DefaultValue()
{
static NetID defaultID(
reinterpret_cast< const byte_t * >(Version::LLARP_NET_ID));
return defaultID;
}
bool RouterContact::IgnoreBogons = false;
#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;
#endif
2019-01-02 22:21:29 +00:00
2019-01-05 00:49:06 +00:00
NetID::NetID(const byte_t *val) : AlignedBuffer< 8 >()
{
size_t len = strnlen(reinterpret_cast< const char * >(val), size());
std::copy(val, val + len, begin());
}
NetID::NetID() : NetID(DefaultValue().data())
{
}
bool
NetID::operator==(const NetID &other) const
{
2018-12-28 15:04:05 +00:00
return ToString() == other.ToString();
}
std::string
NetID::ToString() const
{
auto term = std::find(begin(), end(), '\0');
return std::string(begin(), term);
}
bool
NetID::BDecode(llarp_buffer_t *buf)
{
Zero();
llarp_buffer_t strbuf;
if(!bencode_read_string(buf, &strbuf))
return false;
2018-12-28 15:04:05 +00:00
if(strbuf.sz > size())
return false;
std::copy(strbuf.base, strbuf.base + strbuf.sz, begin());
return true;
}
bool
NetID::BEncode(llarp_buffer_t *buf) const
{
auto term = std::find(begin(), end(), '\0');
return bencode_write_bytestring(buf, begin(), std::distance(begin(), term));
}
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;
/* write netid */
if(!bencode_write_bytestring(buf, "i", 1))
return false;
if(!netID.BEncode(buf))
return false;
2018-08-30 18:48:43 +00:00
/* write signing pubkey */
if(!bencode_write_bytestring(buf, "k", 1))
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();
if(nick.size())
{
2018-08-30 18:48:43 +00:00
/* write nickname */
if(!bencode_write_bytestring(buf, "n", 1))
return false;
if(!bencode_write_bytestring(buf, nick.c_str(), nick.size()))
return false;
}
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;
2018-08-30 18:48:43 +00:00
/* write last updated */
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
2018-08-30 18:48:43 +00:00
/* write version */
if(!bencode_write_version_entry(buf))
return false;
/* write xi if they exist */
2018-08-30 18:48:43 +00:00
if(!bencode_write_bytestring(buf, "x", 1))
return false;
2018-08-30 18:48:43 +00:00
if(!BEncodeWriteList(exits.begin(), exits.end(), buf))
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();
last_updated = 0;
}
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()},
{"identity", pubkey.ToHex()}};
2019-02-08 19:43:25 +00:00
if(HasNick())
2019-02-11 17:14:43 +00:00
obj.Put("nickname", Nick());
return obj;
2019-02-08 19:43:25 +00:00
}
2018-08-30 18:48:43 +00:00
bool
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
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;
if(key == "n")
2018-08-31 13:51:24 +00:00
{
llarp_buffer_t strbuf;
if(!bencode_read_string(buf, &strbuf))
return false;
if(strbuf.sz > nickname.size())
return false;
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
if(!BEncodeMaybeReadDictInt("u", last_updated, read, key, buf))
2018-08-31 13:51:24 +00:00
return false;
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))
return false;
2018-08-30 18:48:43 +00:00
if(!BEncodeMaybeReadDictEntry("z", signature, read, key, buf))
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
{
return addrs.size() > 0;
}
bool
RouterContact::HasNick() const
{
return nickname[0] != 0;
}
void
RouterContact::SetNick(const std::string &nick)
{
nickname.Zero();
std::copy(nick.begin(),
nick.begin() + std::min(nick.size(), nickname.size()),
nickname.begin());
2018-08-31 12:46:54 +00:00
}
bool
RouterContact::IsExpired(llarp_time_t now) const
{
2019-02-11 17:26:52 +00:00
/*
2018-12-19 17:48:29 +00:00
auto expiresAt = last_updated + Lifetime;
return now >= expiresAt;
2019-02-11 17:26:52 +00:00
*/
(void)now;
return false;
}
bool
RouterContact::ExpiresSoon(llarp_time_t now, llarp_time_t dlt) const
{
2019-02-11 17:26:52 +00:00
(void)now;
(void)dlt;
return false;
/*
2018-12-19 17:48:29 +00:00
if(IsExpired(now))
2019-01-02 22:21:29 +00:00
{
2018-12-19 17:48:29 +00:00
return true;
2019-01-02 22:21:29 +00:00
}
2018-12-19 17:48:29 +00:00
auto expiresAt = last_updated + Lifetime;
return expiresAt - now <= dlt;
2019-02-11 17:26:52 +00:00
*/
}
2018-08-31 12:46:54 +00:00
std::string
RouterContact::Nick() const
{
auto term = std::find(nickname.begin(), nickname.end(), '\0');
return std::string(nickname.begin(), term);
2018-08-31 12:46:54 +00:00
}
bool
RouterContact::Sign(llarp::Crypto *crypto, 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))
return false;
buf.sz = buf.cur - buf.base;
buf.cur = buf.base;
return crypto->sign(signature, secretkey, buf);
}
2018-10-15 12:02:32 +00:00
bool
RouterContact::Verify(llarp::Crypto *crypto, llarp_time_t now) 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(), "'");
return false;
2018-12-28 15:04:05 +00:00
}
if(IsExpired(now))
2018-12-28 15:04:05 +00:00
{
llarp::LogError("RC is expired");
return false;
2018-12-28 15:04:05 +00:00
}
2018-10-15 12:02:32 +00:00
for(const auto &a : addrs)
{
if(IsBogon(a.ip) && !IgnoreBogons)
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))
return false;
}
2018-12-28 15:04:05 +00:00
if(!VerifySignature(crypto))
{
llarp::LogError("invalid signature");
return false;
}
return true;
2018-10-15 12:02:32 +00:00
}
2018-08-31 12:46:54 +00:00
bool
RouterContact::VerifySignature(llarp::Crypto *crypto) 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;
2018-08-31 13:51:24 +00:00
return crypto->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))
return false;
buf.sz = buf.cur - buf.base;
buf.cur = buf.base;
2019-01-11 01:44:45 +00:00
std::ofstream f; // why was this in its own scope?
f.open(fname, std::ios::binary);
if(!f.is_open())
return false;
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-01-24 15:13:41 +00:00
return false;
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);
}
RouterContact &
RouterContact::operator=(const RouterContact &other)
{
addrs = other.addrs;
exits = other.exits;
signature = other.signature;
2018-08-31 12:46:54 +00:00
last_updated = other.last_updated;
enckey = other.enckey;
pubkey = other.pubkey;
nickname = other.nickname;
2018-08-31 13:51:24 +00:00
version = other.version;
2018-12-28 15:04:05 +00:00
netID = other.netID;
2018-08-31 12:46:54 +00:00
return *this;
}
2018-08-30 18:48:43 +00:00
} // namespace llarp