mirror of https://github.com/oxen-io/lokinet
Merge remote-tracking branch 'origin/master' into ipv6-tun
commit
5c61df08b5
@ -0,0 +1 @@
|
||||
#include <constants/path.hpp>
|
@ -0,0 +1,31 @@
|
||||
#ifndef LLARP_CONSTANTS_PATH_HPP
|
||||
#define LLARP_CONSTANTS_PATH_HPP
|
||||
|
||||
#include <cstddef>
|
||||
|
||||
#include <util/types.hpp>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
namespace path
|
||||
{
|
||||
/// maximum path length
|
||||
constexpr std::size_t max_len = 8;
|
||||
/// default path length
|
||||
constexpr std::size_t default_len = 4;
|
||||
/// pad messages to the nearest this many bytes
|
||||
constexpr std::size_t pad_size = 128;
|
||||
/// default path lifetime in ms
|
||||
constexpr llarp_time_t default_lifetime = 10 * 60 * 1000;
|
||||
/// after this many ms a path build times out
|
||||
constexpr llarp_time_t build_timeout = 30000;
|
||||
|
||||
/// measure latency every this interval ms
|
||||
constexpr llarp_time_t latency_interval = 5000;
|
||||
|
||||
/// if a path is inactive for this amount of time it's dead
|
||||
constexpr llarp_time_t alive_timeout = 60000;
|
||||
} // namespace path
|
||||
} // namespace llarp
|
||||
|
||||
#endif
|
@ -1,76 +0,0 @@
|
||||
#include <messages/exit.hpp>
|
||||
#include <routing/handler.hpp>
|
||||
#include <crypto/crypto.hpp>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
namespace routing
|
||||
{
|
||||
bool
|
||||
CloseExitMessage::BEncode(llarp_buffer_t* buf) const
|
||||
{
|
||||
if(!bencode_start_dict(buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictMsgType(buf, "A", "C"))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("S", S, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("V", version, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictEntry("Y", Y, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictEntry("Z", Z, buf))
|
||||
return false;
|
||||
return bencode_end(buf);
|
||||
}
|
||||
|
||||
bool
|
||||
CloseExitMessage::DecodeKey(const llarp_buffer_t& k, llarp_buffer_t* buf)
|
||||
{
|
||||
bool read = false;
|
||||
if(!BEncodeMaybeReadDictInt("S", S, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("V", version, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictEntry("Y", Y, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictEntry("Z", Z, read, k, buf))
|
||||
return false;
|
||||
return read;
|
||||
}
|
||||
|
||||
bool
|
||||
CloseExitMessage::Verify(const llarp::PubKey& pk) const
|
||||
{
|
||||
std::array< byte_t, 512 > tmp;
|
||||
llarp_buffer_t buf(tmp);
|
||||
CloseExitMessage copy;
|
||||
copy = *this;
|
||||
copy.Z.Zero();
|
||||
if(!copy.BEncode(&buf))
|
||||
return false;
|
||||
buf.sz = buf.cur - buf.base;
|
||||
return CryptoManager::instance()->verify(pk, buf, Z);
|
||||
}
|
||||
|
||||
bool
|
||||
CloseExitMessage::Sign(const llarp::SecretKey& sk)
|
||||
{
|
||||
std::array< byte_t, 512 > tmp;
|
||||
llarp_buffer_t buf(tmp);
|
||||
Z.Zero();
|
||||
Y.Randomize();
|
||||
if(!BEncode(&buf))
|
||||
return false;
|
||||
buf.sz = buf.cur - buf.base;
|
||||
return CryptoManager::instance()->sign(Z, sk, buf);
|
||||
}
|
||||
|
||||
bool
|
||||
CloseExitMessage::HandleMessage(IMessageHandler* h, AbstractRouter* r) const
|
||||
{
|
||||
return h->HandleCloseExitMessage(*this, r);
|
||||
}
|
||||
|
||||
} // namespace routing
|
||||
} // namespace llarp
|
@ -0,0 +1,425 @@
|
||||
#include <exit/exit_messages.hpp>
|
||||
|
||||
#include <crypto/crypto.hpp>
|
||||
#include <routing/handler.hpp>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
namespace routing
|
||||
{
|
||||
bool
|
||||
ObtainExitMessage::Sign(const llarp::SecretKey& sk)
|
||||
{
|
||||
std::array< byte_t, 1024 > tmp;
|
||||
llarp_buffer_t buf(tmp);
|
||||
I = seckey_topublic(sk);
|
||||
Z.Zero();
|
||||
if(!BEncode(&buf))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
buf.sz = buf.cur - buf.base;
|
||||
return CryptoManager::instance()->sign(Z, sk, buf);
|
||||
}
|
||||
|
||||
bool
|
||||
ObtainExitMessage::Verify() const
|
||||
{
|
||||
std::array< byte_t, 1024 > tmp;
|
||||
llarp_buffer_t buf(tmp);
|
||||
ObtainExitMessage copy;
|
||||
copy = *this;
|
||||
copy.Z.Zero();
|
||||
if(!copy.BEncode(&buf))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
// rewind buffer
|
||||
buf.sz = buf.cur - buf.base;
|
||||
return CryptoManager::instance()->verify(I, buf, Z);
|
||||
}
|
||||
|
||||
bool
|
||||
ObtainExitMessage::BEncode(llarp_buffer_t* buf) const
|
||||
{
|
||||
if(!bencode_start_dict(buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictMsgType(buf, "A", "O"))
|
||||
return false;
|
||||
if(!BEncodeWriteDictArray("B", B, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("E", E, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictEntry("I", I, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("S", S, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("T", T, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("V", version, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictArray("W", W, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("X", X, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictEntry("Z", Z, buf))
|
||||
return false;
|
||||
return bencode_end(buf);
|
||||
}
|
||||
|
||||
bool
|
||||
ObtainExitMessage::DecodeKey(const llarp_buffer_t& k, llarp_buffer_t* buf)
|
||||
{
|
||||
bool read = false;
|
||||
if(!BEncodeMaybeReadDictList("B", B, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("E", E, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictEntry("I", I, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("S", S, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("T", T, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("V", version, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictList("W", W, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("X", X, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictEntry("Z", Z, read, k, buf))
|
||||
return false;
|
||||
return read;
|
||||
}
|
||||
|
||||
bool
|
||||
ObtainExitMessage::HandleMessage(IMessageHandler* h,
|
||||
AbstractRouter* r) const
|
||||
{
|
||||
return h->HandleObtainExitMessage(*this, r);
|
||||
}
|
||||
|
||||
bool
|
||||
GrantExitMessage::BEncode(llarp_buffer_t* buf) const
|
||||
{
|
||||
if(!bencode_start_dict(buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictMsgType(buf, "A", "G"))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("S", S, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("T", T, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("V", version, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictEntry("Y", Y, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictEntry("Z", Z, buf))
|
||||
return false;
|
||||
return bencode_end(buf);
|
||||
}
|
||||
|
||||
bool
|
||||
GrantExitMessage::DecodeKey(const llarp_buffer_t& k, llarp_buffer_t* buf)
|
||||
{
|
||||
bool read = false;
|
||||
if(!BEncodeMaybeReadDictInt("S", S, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("T", T, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("V", version, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictEntry("Y", Y, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictEntry("Z", Z, read, k, buf))
|
||||
return false;
|
||||
return read;
|
||||
}
|
||||
|
||||
bool
|
||||
GrantExitMessage::Verify(const llarp::PubKey& pk) const
|
||||
{
|
||||
std::array< byte_t, 512 > tmp;
|
||||
llarp_buffer_t buf(tmp);
|
||||
GrantExitMessage copy;
|
||||
copy = *this;
|
||||
copy.Z.Zero();
|
||||
if(!copy.BEncode(&buf))
|
||||
return false;
|
||||
buf.sz = buf.cur - buf.base;
|
||||
return CryptoManager::instance()->verify(pk, buf, Z);
|
||||
}
|
||||
|
||||
bool
|
||||
GrantExitMessage::Sign(const llarp::SecretKey& sk)
|
||||
{
|
||||
std::array< byte_t, 512 > tmp;
|
||||
llarp_buffer_t buf(tmp);
|
||||
Z.Zero();
|
||||
Y.Randomize();
|
||||
if(!BEncode(&buf))
|
||||
return false;
|
||||
buf.sz = buf.cur - buf.base;
|
||||
return CryptoManager::instance()->sign(Z, sk, buf);
|
||||
}
|
||||
|
||||
bool
|
||||
GrantExitMessage::HandleMessage(IMessageHandler* h, AbstractRouter* r) const
|
||||
{
|
||||
return h->HandleGrantExitMessage(*this, r);
|
||||
}
|
||||
|
||||
bool
|
||||
RejectExitMessage::BEncode(llarp_buffer_t* buf) const
|
||||
{
|
||||
if(!bencode_start_dict(buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictMsgType(buf, "A", "J"))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("B", B, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictList("R", R, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("S", S, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("T", T, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("V", version, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictEntry("Y", Y, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictEntry("Z", Z, buf))
|
||||
return false;
|
||||
return bencode_end(buf);
|
||||
}
|
||||
|
||||
bool
|
||||
RejectExitMessage::DecodeKey(const llarp_buffer_t& k, llarp_buffer_t* buf)
|
||||
{
|
||||
bool read = false;
|
||||
if(!BEncodeMaybeReadDictInt("B", B, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictList("R", R, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("S", S, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("T", T, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("V", version, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictEntry("Y", Y, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictEntry("Z", Z, read, k, buf))
|
||||
return false;
|
||||
return read;
|
||||
}
|
||||
|
||||
bool
|
||||
RejectExitMessage::Sign(const llarp::SecretKey& sk)
|
||||
{
|
||||
std::array< byte_t, 512 > tmp;
|
||||
llarp_buffer_t buf(tmp);
|
||||
Z.Zero();
|
||||
Y.Randomize();
|
||||
if(!BEncode(&buf))
|
||||
return false;
|
||||
buf.sz = buf.cur - buf.base;
|
||||
return CryptoManager::instance()->sign(Z, sk, buf);
|
||||
}
|
||||
|
||||
bool
|
||||
RejectExitMessage::Verify(const llarp::PubKey& pk) const
|
||||
{
|
||||
std::array< byte_t, 512 > tmp;
|
||||
llarp_buffer_t buf(tmp);
|
||||
RejectExitMessage copy;
|
||||
copy = *this;
|
||||
copy.Z.Zero();
|
||||
if(!copy.BEncode(&buf))
|
||||
return false;
|
||||
buf.sz = buf.cur - buf.base;
|
||||
return CryptoManager::instance()->verify(pk, buf, Z);
|
||||
}
|
||||
|
||||
bool
|
||||
RejectExitMessage::HandleMessage(IMessageHandler* h,
|
||||
AbstractRouter* r) const
|
||||
{
|
||||
return h->HandleRejectExitMessage(*this, r);
|
||||
}
|
||||
|
||||
bool
|
||||
UpdateExitMessage::BEncode(llarp_buffer_t* buf) const
|
||||
{
|
||||
if(!bencode_start_dict(buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictMsgType(buf, "A", "V"))
|
||||
return false;
|
||||
if(!BEncodeWriteDictEntry("P", P, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("S", S, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("T", T, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("V", version, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictEntry("Z", Z, buf))
|
||||
return false;
|
||||
return bencode_end(buf);
|
||||
}
|
||||
|
||||
bool
|
||||
UpdateExitMessage::DecodeKey(const llarp_buffer_t& k, llarp_buffer_t* buf)
|
||||
{
|
||||
bool read = false;
|
||||
if(!BEncodeMaybeReadDictInt("S", S, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("T", T, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("V", version, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictEntry("P", P, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictEntry("Z", Z, read, k, buf))
|
||||
return false;
|
||||
return read;
|
||||
}
|
||||
|
||||
bool
|
||||
UpdateExitMessage::Verify(const llarp::PubKey& pk) const
|
||||
|
||||
{
|
||||
std::array< byte_t, 512 > tmp;
|
||||
llarp_buffer_t buf(tmp);
|
||||
UpdateExitMessage copy;
|
||||
copy = *this;
|
||||
copy.Z.Zero();
|
||||
if(!copy.BEncode(&buf))
|
||||
return false;
|
||||
buf.sz = buf.cur - buf.base;
|
||||
return CryptoManager::instance()->verify(pk, buf, Z);
|
||||
}
|
||||
|
||||
bool
|
||||
UpdateExitMessage::Sign(const llarp::SecretKey& sk)
|
||||
{
|
||||
std::array< byte_t, 512 > tmp;
|
||||
llarp_buffer_t buf(tmp);
|
||||
Y.Randomize();
|
||||
if(!BEncode(&buf))
|
||||
return false;
|
||||
buf.sz = buf.cur - buf.base;
|
||||
return CryptoManager::instance()->sign(Z, sk, buf);
|
||||
}
|
||||
|
||||
bool
|
||||
UpdateExitMessage::HandleMessage(IMessageHandler* h,
|
||||
AbstractRouter* r) const
|
||||
{
|
||||
return h->HandleUpdateExitMessage(*this, r);
|
||||
}
|
||||
|
||||
bool
|
||||
UpdateExitVerifyMessage::BEncode(llarp_buffer_t* buf) const
|
||||
{
|
||||
if(!bencode_start_dict(buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictMsgType(buf, "A", "V"))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("S", S, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("T", T, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("V", version, buf))
|
||||
return false;
|
||||
return bencode_end(buf);
|
||||
}
|
||||
|
||||
bool
|
||||
UpdateExitVerifyMessage::DecodeKey(const llarp_buffer_t& k,
|
||||
llarp_buffer_t* buf)
|
||||
{
|
||||
bool read = false;
|
||||
if(!BEncodeMaybeReadDictInt("S", S, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("T", T, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("V", version, read, k, buf))
|
||||
return false;
|
||||
return read;
|
||||
}
|
||||
|
||||
bool
|
||||
UpdateExitVerifyMessage::HandleMessage(IMessageHandler* h,
|
||||
AbstractRouter* r) const
|
||||
{
|
||||
return h->HandleUpdateExitVerifyMessage(*this, r);
|
||||
}
|
||||
|
||||
bool
|
||||
CloseExitMessage::BEncode(llarp_buffer_t* buf) const
|
||||
{
|
||||
if(!bencode_start_dict(buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictMsgType(buf, "A", "C"))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("S", S, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("V", version, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictEntry("Y", Y, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictEntry("Z", Z, buf))
|
||||
return false;
|
||||
return bencode_end(buf);
|
||||
}
|
||||
|
||||
bool
|
||||
CloseExitMessage::DecodeKey(const llarp_buffer_t& k, llarp_buffer_t* buf)
|
||||
{
|
||||
bool read = false;
|
||||
if(!BEncodeMaybeReadDictInt("S", S, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("V", version, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictEntry("Y", Y, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictEntry("Z", Z, read, k, buf))
|
||||
return false;
|
||||
return read;
|
||||
}
|
||||
|
||||
bool
|
||||
CloseExitMessage::Verify(const llarp::PubKey& pk) const
|
||||
{
|
||||
std::array< byte_t, 512 > tmp;
|
||||
llarp_buffer_t buf(tmp);
|
||||
CloseExitMessage copy;
|
||||
copy = *this;
|
||||
copy.Z.Zero();
|
||||
if(!copy.BEncode(&buf))
|
||||
return false;
|
||||
buf.sz = buf.cur - buf.base;
|
||||
return CryptoManager::instance()->verify(pk, buf, Z);
|
||||
}
|
||||
|
||||
bool
|
||||
CloseExitMessage::Sign(const llarp::SecretKey& sk)
|
||||
{
|
||||
std::array< byte_t, 512 > tmp;
|
||||
llarp_buffer_t buf(tmp);
|
||||
Z.Zero();
|
||||
Y.Randomize();
|
||||
if(!BEncode(&buf))
|
||||
return false;
|
||||
buf.sz = buf.cur - buf.base;
|
||||
return CryptoManager::instance()->sign(Z, sk, buf);
|
||||
}
|
||||
|
||||
bool
|
||||
CloseExitMessage::HandleMessage(IMessageHandler* h, AbstractRouter* r) const
|
||||
{
|
||||
return h->HandleCloseExitMessage(*this, r);
|
||||
}
|
||||
} // namespace routing
|
||||
} // namespace llarp
|
@ -1,5 +1,5 @@
|
||||
#ifndef LLARP_MESSAGES_EXIT_HPP
|
||||
#define LLARP_MESSAGES_EXIT_HPP
|
||||
#ifndef LLARP_EXIT_MESSAGES_HPP
|
||||
#define LLARP_EXIT_MESSAGES_HPP
|
||||
|
||||
#include <crypto/types.hpp>
|
||||
#include <exit/policy.hpp>
|
@ -1,81 +0,0 @@
|
||||
#include <messages/exit.hpp>
|
||||
|
||||
#include <crypto/crypto.hpp>
|
||||
#include <routing/handler.hpp>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
namespace routing
|
||||
{
|
||||
bool
|
||||
GrantExitMessage::BEncode(llarp_buffer_t* buf) const
|
||||
{
|
||||
if(!bencode_start_dict(buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictMsgType(buf, "A", "G"))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("S", S, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("T", T, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("V", version, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictEntry("Y", Y, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictEntry("Z", Z, buf))
|
||||
return false;
|
||||
return bencode_end(buf);
|
||||
}
|
||||
|
||||
bool
|
||||
GrantExitMessage::DecodeKey(const llarp_buffer_t& k, llarp_buffer_t* buf)
|
||||
{
|
||||
bool read = false;
|
||||
if(!BEncodeMaybeReadDictInt("S", S, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("T", T, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("V", version, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictEntry("Y", Y, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictEntry("Z", Z, read, k, buf))
|
||||
return false;
|
||||
return read;
|
||||
}
|
||||
|
||||
bool
|
||||
GrantExitMessage::Verify(const llarp::PubKey& pk) const
|
||||
{
|
||||
std::array< byte_t, 512 > tmp;
|
||||
llarp_buffer_t buf(tmp);
|
||||
GrantExitMessage copy;
|
||||
copy = *this;
|
||||
copy.Z.Zero();
|
||||
if(!copy.BEncode(&buf))
|
||||
return false;
|
||||
buf.sz = buf.cur - buf.base;
|
||||
return CryptoManager::instance()->verify(pk, buf, Z);
|
||||
}
|
||||
|
||||
bool
|
||||
GrantExitMessage::Sign(const llarp::SecretKey& sk)
|
||||
{
|
||||
std::array< byte_t, 512 > tmp;
|
||||
llarp_buffer_t buf(tmp);
|
||||
Z.Zero();
|
||||
Y.Randomize();
|
||||
if(!BEncode(&buf))
|
||||
return false;
|
||||
buf.sz = buf.cur - buf.base;
|
||||
return CryptoManager::instance()->sign(Z, sk, buf);
|
||||
}
|
||||
|
||||
bool
|
||||
GrantExitMessage::HandleMessage(IMessageHandler* h, AbstractRouter* r) const
|
||||
{
|
||||
return h->HandleGrantExitMessage(*this, r);
|
||||
}
|
||||
|
||||
} // namespace routing
|
||||
} // namespace llarp
|
@ -1,103 +0,0 @@
|
||||
#include <messages/exit.hpp>
|
||||
|
||||
#include <crypto/crypto.hpp>
|
||||
#include <routing/handler.hpp>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
namespace routing
|
||||
{
|
||||
bool
|
||||
ObtainExitMessage::Sign(const llarp::SecretKey& sk)
|
||||
{
|
||||
std::array< byte_t, 1024 > tmp;
|
||||
llarp_buffer_t buf(tmp);
|
||||
I = seckey_topublic(sk);
|
||||
Z.Zero();
|
||||
if(!BEncode(&buf))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
buf.sz = buf.cur - buf.base;
|
||||
return CryptoManager::instance()->sign(Z, sk, buf);
|
||||
}
|
||||
|
||||
bool
|
||||
ObtainExitMessage::Verify() const
|
||||
{
|
||||
std::array< byte_t, 1024 > tmp;
|
||||
llarp_buffer_t buf(tmp);
|
||||
ObtainExitMessage copy;
|
||||
copy = *this;
|
||||
copy.Z.Zero();
|
||||
if(!copy.BEncode(&buf))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
// rewind buffer
|
||||
buf.sz = buf.cur - buf.base;
|
||||
return CryptoManager::instance()->verify(I, buf, Z);
|
||||
}
|
||||
|
||||
bool
|
||||
ObtainExitMessage::BEncode(llarp_buffer_t* buf) const
|
||||
{
|
||||
if(!bencode_start_dict(buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictMsgType(buf, "A", "O"))
|
||||
return false;
|
||||
if(!BEncodeWriteDictArray("B", B, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("E", E, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictEntry("I", I, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("S", S, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("T", T, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("V", version, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictArray("W", W, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("X", X, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictEntry("Z", Z, buf))
|
||||
return false;
|
||||
return bencode_end(buf);
|
||||
}
|
||||
|
||||
bool
|
||||
ObtainExitMessage::DecodeKey(const llarp_buffer_t& k, llarp_buffer_t* buf)
|
||||
{
|
||||
bool read = false;
|
||||
if(!BEncodeMaybeReadDictList("B", B, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("E", E, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictEntry("I", I, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("S", S, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("T", T, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("V", version, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictList("W", W, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("X", X, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictEntry("Z", Z, read, k, buf))
|
||||
return false;
|
||||
return read;
|
||||
}
|
||||
|
||||
bool
|
||||
ObtainExitMessage::HandleMessage(IMessageHandler* h,
|
||||
AbstractRouter* r) const
|
||||
{
|
||||
return h->HandleObtainExitMessage(*this, r);
|
||||
}
|
||||
|
||||
} // namespace routing
|
||||
} // namespace llarp
|
@ -1,90 +0,0 @@
|
||||
#include <messages/exit.hpp>
|
||||
|
||||
#include <crypto/crypto.hpp>
|
||||
#include <routing/handler.hpp>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
namespace routing
|
||||
{
|
||||
bool
|
||||
RejectExitMessage::BEncode(llarp_buffer_t* buf) const
|
||||
{
|
||||
if(!bencode_start_dict(buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictMsgType(buf, "A", "J"))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("B", B, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictList("R", R, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("S", S, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("T", T, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("V", version, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictEntry("Y", Y, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictEntry("Z", Z, buf))
|
||||
return false;
|
||||
return bencode_end(buf);
|
||||
}
|
||||
|
||||
bool
|
||||
RejectExitMessage::DecodeKey(const llarp_buffer_t& k, llarp_buffer_t* buf)
|
||||
{
|
||||
bool read = false;
|
||||
if(!BEncodeMaybeReadDictInt("B", B, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictList("R", R, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("S", S, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("T", T, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("V", version, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictEntry("Y", Y, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictEntry("Z", Z, read, k, buf))
|
||||
return false;
|
||||
return read;
|
||||
}
|
||||
|
||||
bool
|
||||
RejectExitMessage::Sign(const llarp::SecretKey& sk)
|
||||
{
|
||||
std::array< byte_t, 512 > tmp;
|
||||
llarp_buffer_t buf(tmp);
|
||||
Z.Zero();
|
||||
Y.Randomize();
|
||||
if(!BEncode(&buf))
|
||||
return false;
|
||||
buf.sz = buf.cur - buf.base;
|
||||
return CryptoManager::instance()->sign(Z, sk, buf);
|
||||
}
|
||||
|
||||
bool
|
||||
RejectExitMessage::Verify(const llarp::PubKey& pk) const
|
||||
{
|
||||
std::array< byte_t, 512 > tmp;
|
||||
llarp_buffer_t buf(tmp);
|
||||
RejectExitMessage copy;
|
||||
copy = *this;
|
||||
copy.Z.Zero();
|
||||
if(!copy.BEncode(&buf))
|
||||
return false;
|
||||
buf.sz = buf.cur - buf.base;
|
||||
return CryptoManager::instance()->verify(pk, buf, Z);
|
||||
}
|
||||
|
||||
bool
|
||||
RejectExitMessage::HandleMessage(IMessageHandler* h,
|
||||
AbstractRouter* r) const
|
||||
{
|
||||
return h->HandleRejectExitMessage(*this, r);
|
||||
}
|
||||
|
||||
} // namespace routing
|
||||
} // namespace llarp
|
@ -1,119 +0,0 @@
|
||||
#include <messages/exit.hpp>
|
||||
|
||||
#include <crypto/crypto.hpp>
|
||||
#include <routing/handler.hpp>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
namespace routing
|
||||
{
|
||||
bool
|
||||
UpdateExitMessage::BEncode(llarp_buffer_t* buf) const
|
||||
{
|
||||
if(!bencode_start_dict(buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictMsgType(buf, "A", "V"))
|
||||
return false;
|
||||
if(!BEncodeWriteDictEntry("P", P, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("S", S, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("T", T, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("V", version, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictEntry("Z", Z, buf))
|
||||
return false;
|
||||
return bencode_end(buf);
|
||||
}
|
||||
|
||||
bool
|
||||
UpdateExitMessage::DecodeKey(const llarp_buffer_t& k, llarp_buffer_t* buf)
|
||||
{
|
||||
bool read = false;
|
||||
if(!BEncodeMaybeReadDictInt("S", S, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("T", T, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("V", version, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictEntry("P", P, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictEntry("Z", Z, read, k, buf))
|
||||
return false;
|
||||
return read;
|
||||
}
|
||||
|
||||
bool
|
||||
UpdateExitMessage::Verify(const llarp::PubKey& pk) const
|
||||
|
||||
{
|
||||
std::array< byte_t, 512 > tmp;
|
||||
llarp_buffer_t buf(tmp);
|
||||
UpdateExitMessage copy;
|
||||
copy = *this;
|
||||
copy.Z.Zero();
|
||||
if(!copy.BEncode(&buf))
|
||||
return false;
|
||||
buf.sz = buf.cur - buf.base;
|
||||
return CryptoManager::instance()->verify(pk, buf, Z);
|
||||
}
|
||||
|
||||
bool
|
||||
UpdateExitMessage::Sign(const llarp::SecretKey& sk)
|
||||
{
|
||||
std::array< byte_t, 512 > tmp;
|
||||
llarp_buffer_t buf(tmp);
|
||||
Y.Randomize();
|
||||
if(!BEncode(&buf))
|
||||
return false;
|
||||
buf.sz = buf.cur - buf.base;
|
||||
return CryptoManager::instance()->sign(Z, sk, buf);
|
||||
}
|
||||
|
||||
bool
|
||||
UpdateExitMessage::HandleMessage(IMessageHandler* h,
|
||||
AbstractRouter* r) const
|
||||
{
|
||||
return h->HandleUpdateExitMessage(*this, r);
|
||||
}
|
||||
|
||||
bool
|
||||
UpdateExitVerifyMessage::BEncode(llarp_buffer_t* buf) const
|
||||
{
|
||||
if(!bencode_start_dict(buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictMsgType(buf, "A", "V"))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("S", S, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("T", T, buf))
|
||||
return false;
|
||||
if(!BEncodeWriteDictInt("V", version, buf))
|
||||
return false;
|
||||
return bencode_end(buf);
|
||||
}
|
||||
|
||||
bool
|
||||
UpdateExitVerifyMessage::DecodeKey(const llarp_buffer_t& k,
|
||||
llarp_buffer_t* buf)
|
||||
{
|
||||
bool read = false;
|
||||
if(!BEncodeMaybeReadDictInt("S", S, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("T", T, read, k, buf))
|
||||
return false;
|
||||
if(!BEncodeMaybeReadDictInt("V", version, read, k, buf))
|
||||
return false;
|
||||
return read;
|
||||
}
|
||||
|
||||
bool
|
||||
UpdateExitVerifyMessage::HandleMessage(IMessageHandler* h,
|
||||
AbstractRouter* r) const
|
||||
{
|
||||
return h->HandleUpdateExitVerifyMessage(*this, r);
|
||||
}
|
||||
|
||||
} // namespace routing
|
||||
} // namespace llarp
|
@ -1 +0,0 @@
|
||||
#include <messages/dht.hpp>
|
@ -1 +0,0 @@
|
||||
#include <messages/exit.hpp>
|
@ -0,0 +1,149 @@
|
||||
#include <messages/link_message_parser.hpp>
|
||||
|
||||
#include <messages/dht_immediate.hpp>
|
||||
#include <messages/discard.hpp>
|
||||
#include <messages/link_intro.hpp>
|
||||
#include <messages/link_message.hpp>
|
||||
#include <messages/relay_commit.hpp>
|
||||
#include <messages/relay.hpp>
|
||||
#include <router_contact.hpp>
|
||||
#include <util/buffer.hpp>
|
||||
#include <util/logger.hpp>
|
||||
#include <util/metrics.hpp>
|
||||
|
||||
#include <memory>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
struct LinkMessageParser::msg_holder_t
|
||||
{
|
||||
LinkIntroMessage i;
|
||||
RelayDownstreamMessage d;
|
||||
RelayUpstreamMessage u;
|
||||
DHTImmediateMessage m;
|
||||
LR_CommitMessage c;
|
||||
DiscardMessage x;
|
||||
|
||||
msg_holder_t() = default;
|
||||
};
|
||||
|
||||
LinkMessageParser::LinkMessageParser(AbstractRouter* _router)
|
||||
: router(_router)
|
||||
, from(nullptr)
|
||||
, msg(nullptr)
|
||||
, holder(std::make_unique< msg_holder_t >())
|
||||
{
|
||||
}
|
||||
|
||||
LinkMessageParser::~LinkMessageParser()
|
||||
{
|
||||
}
|
||||
|
||||
bool
|
||||
LinkMessageParser::operator()(llarp_buffer_t* buffer, llarp_buffer_t* key)
|
||||
{
|
||||
// we are reading the first key
|
||||
if(firstkey)
|
||||
{
|
||||
llarp_buffer_t strbuf;
|
||||
// check for empty dict
|
||||
if(!key)
|
||||
return false;
|
||||
// we are expecting the first key to be 'a'
|
||||
if(!(*key == "a"))
|
||||
{
|
||||
llarp::LogWarn("message has no message type");
|
||||
return false;
|
||||
}
|
||||
|
||||
if(!bencode_read_string(buffer, &strbuf))
|
||||
{
|
||||
llarp::LogWarn("could not read value of message type");
|
||||
return false;
|
||||
}
|
||||
// bad key size
|
||||
if(strbuf.sz != 1)
|
||||
{
|
||||
llarp::LogWarn("bad mesage type size: ", strbuf.sz);
|
||||
return false;
|
||||
}
|
||||
// create the message to parse based off message type
|
||||
llarp::LogDebug("inbound message ", *strbuf.cur);
|
||||
bool isLIM = false;
|
||||
switch(*strbuf.cur)
|
||||
{
|
||||
case 'i':
|
||||
msg = &holder->i;
|
||||
isLIM = true;
|
||||
break;
|
||||
case 'd':
|
||||
msg = &holder->d;
|
||||
break;
|
||||
case 'u':
|
||||
msg = &holder->u;
|
||||
break;
|
||||
case 'm':
|
||||
msg = &holder->m;
|
||||
break;
|
||||
case 'c':
|
||||
msg = &holder->c;
|
||||
break;
|
||||
case 'x':
|
||||
msg = &holder->x;
|
||||
break;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
|
||||
if(!isLIM)
|
||||
{
|
||||
metrics::integerTick(msg->Name(), "RX", 1, "id",
|
||||
RouterID(from->GetPubKey()).ToString());
|
||||
}
|
||||
|
||||
msg->session = from;
|
||||
firstkey = false;
|
||||
return true;
|
||||
}
|
||||
// check for last element
|
||||
if(!key)
|
||||
return MessageDone();
|
||||
|
||||
return msg->DecodeKey(*key, buffer);
|
||||
}
|
||||
|
||||
bool
|
||||
LinkMessageParser::MessageDone()
|
||||
{
|
||||
bool result = false;
|
||||
if(msg)
|
||||
{
|
||||
result = msg->HandleMessage(router);
|
||||
}
|
||||
Reset();
|
||||
return result;
|
||||
}
|
||||
|
||||
bool
|
||||
LinkMessageParser::ProcessFrom(ILinkSession* src, const llarp_buffer_t& buf)
|
||||
{
|
||||
if(!src)
|
||||
{
|
||||
llarp::LogWarn("no link session");
|
||||
return false;
|
||||
}
|
||||
|
||||
from = src;
|
||||
firstkey = true;
|
||||
ManagedBuffer copy(buf);
|
||||
return bencode_read_dict(*this, ©.underlying);
|
||||
}
|
||||
|
||||
void
|
||||
LinkMessageParser::Reset()
|
||||
{
|
||||
if(msg)
|
||||
msg->Clear();
|
||||
msg = nullptr;
|
||||
}
|
||||
} // namespace llarp
|
@ -1 +0,0 @@
|
||||
#include <messages/path_confirm.hpp>
|
@ -1 +0,0 @@
|
||||
#include <messages/path_latency.hpp>
|
@ -1 +0,0 @@
|
||||
#include <messages/path_transfer.hpp>
|
@ -1 +0,0 @@
|
||||
#include <messages/transfer_traffic.hpp>
|
@ -0,0 +1 @@
|
||||
#include <path/ihophandler.hpp>
|
@ -0,0 +1,65 @@
|
||||
#ifndef LLARP_PATH_IHOPHANDLER_HPP
|
||||
#define LLARP_PATH_IHOPHANDLER_HPP
|
||||
|
||||
#include <crypto/types.hpp>
|
||||
#include <util/types.hpp>
|
||||
|
||||
#include <memory>
|
||||
|
||||
struct llarp_buffer_t;
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
struct AbstractRouter;
|
||||
|
||||
namespace routing
|
||||
{
|
||||
struct IMessage;
|
||||
}
|
||||
|
||||
namespace path
|
||||
{
|
||||
struct IHopHandler
|
||||
{
|
||||
virtual ~IHopHandler()
|
||||
{
|
||||
}
|
||||
|
||||
virtual bool
|
||||
Expired(llarp_time_t now) const = 0;
|
||||
|
||||
virtual bool
|
||||
ExpiresSoon(llarp_time_t now, llarp_time_t dlt) const = 0;
|
||||
|
||||
/// send routing message and increment sequence number
|
||||
virtual bool
|
||||
SendRoutingMessage(const routing::IMessage& msg, AbstractRouter* r) = 0;
|
||||
|
||||
// handle data in upstream direction
|
||||
virtual bool
|
||||
HandleUpstream(const llarp_buffer_t& X, const TunnelNonce& Y,
|
||||
AbstractRouter* r) = 0;
|
||||
|
||||
// handle data in downstream direction
|
||||
virtual bool
|
||||
HandleDownstream(const llarp_buffer_t& X, const TunnelNonce& Y,
|
||||
AbstractRouter* r) = 0;
|
||||
|
||||
/// return timestamp last remote activity happened at
|
||||
virtual llarp_time_t
|
||||
LastRemoteActivityAt() const = 0;
|
||||
|
||||
uint64_t
|
||||
NextSeqNo()
|
||||
{
|
||||
return m_SequenceNum++;
|
||||
}
|
||||
|
||||
protected:
|
||||
uint64_t m_SequenceNum = 0;
|
||||
};
|
||||
|
||||
using HopHandler_ptr = std::shared_ptr< IHopHandler >;
|
||||
} // namespace path
|
||||
} // namespace llarp
|
||||
#endif
|
@ -0,0 +1,336 @@
|
||||
#include <path/path_context.hpp>
|
||||
|
||||
#include <messages/relay_commit.hpp>
|
||||
#include <path/path.hpp>
|
||||
#include <router/abstractrouter.hpp>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
namespace path
|
||||
{
|
||||
PathContext::PathContext(AbstractRouter* router)
|
||||
: m_Router(router), m_AllowTransit(false)
|
||||
{
|
||||
}
|
||||
|
||||
void
|
||||
PathContext::AllowTransit()
|
||||
{
|
||||
m_AllowTransit = true;
|
||||
}
|
||||
|
||||
bool
|
||||
PathContext::AllowingTransit() const
|
||||
{
|
||||
return m_AllowTransit;
|
||||
}
|
||||
|
||||
llarp_threadpool*
|
||||
PathContext::Worker()
|
||||
{
|
||||
return m_Router->threadpool();
|
||||
}
|
||||
|
||||
std::shared_ptr< Logic >
|
||||
PathContext::logic()
|
||||
{
|
||||
return m_Router->logic();
|
||||
}
|
||||
|
||||
const SecretKey&
|
||||
PathContext::EncryptionSecretKey()
|
||||
{
|
||||
return m_Router->encryption();
|
||||
}
|
||||
|
||||
bool
|
||||
PathContext::HopIsUs(const RouterID& k) const
|
||||
{
|
||||
return std::equal(m_Router->pubkey(), m_Router->pubkey() + PUBKEYSIZE,
|
||||
k.begin());
|
||||
}
|
||||
|
||||
PathContext::EndpointPathPtrSet
|
||||
PathContext::FindOwnedPathsWithEndpoint(const RouterID& r)
|
||||
{
|
||||
EndpointPathPtrSet found;
|
||||
m_OurPaths.ForEach([&](const PathSet_ptr& set) {
|
||||
set->ForEachPath([&](const Path_ptr& p) {
|
||||
if(p->Endpoint() == r && p->IsReady())
|
||||
found.insert(p);
|
||||
});
|
||||
});
|
||||
return found;
|
||||
}
|
||||
|
||||
bool
|
||||
PathContext::ForwardLRCM(const RouterID& nextHop,
|
||||
const std::array< EncryptedFrame, 8 >& frames)
|
||||
{
|
||||
auto msg = std::make_shared< const LR_CommitMessage >(frames);
|
||||
|
||||
LogDebug("forwarding LRCM to ", nextHop);
|
||||
if(m_Router->HasSessionTo(nextHop))
|
||||
{
|
||||
return m_Router->SendToOrQueue(nextHop, msg.get());
|
||||
}
|
||||
const RouterID router = nextHop;
|
||||
AbstractRouter* const r = m_Router;
|
||||
m_Router->EnsureRouter(
|
||||
nextHop, [msg, r, router](const std::vector< RouterContact >& found) {
|
||||
if(found.size())
|
||||
{
|
||||
r->TryConnectAsync(found[0], 1);
|
||||
r->SendToOrQueue(router, msg.get());
|
||||
}
|
||||
else
|
||||
LogError("dropped LRCM to ", router,
|
||||
" as we cannot find in via DHT");
|
||||
});
|
||||
LogInfo("we are not directly connected to ", router,
|
||||
" so we need to do a lookup");
|
||||
return true;
|
||||
}
|
||||
template < typename Map_t, typename Key_t, typename CheckValue_t,
|
||||
typename GetFunc_t >
|
||||
HopHandler_ptr
|
||||
MapGet(Map_t& map, const Key_t& k, CheckValue_t check, GetFunc_t get)
|
||||
{
|
||||
util::Lock lock(&map.first);
|
||||
auto range = map.second.equal_range(k);
|
||||
for(auto i = range.first; i != range.second; ++i)
|
||||
{
|
||||
if(check(i->second))
|
||||
return get(i->second);
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
template < typename Map_t, typename Key_t, typename CheckValue_t >
|
||||
bool
|
||||
MapHas(Map_t& map, const Key_t& k, CheckValue_t check)
|
||||
{
|
||||
util::Lock lock(&map.first);
|
||||
auto range = map.second.equal_range(k);
|
||||
for(auto i = range.first; i != range.second; ++i)
|
||||
{
|
||||
if(check(i->second))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
template < typename Map_t, typename Key_t, typename Value_t >
|
||||
void
|
||||
MapPut(Map_t& map, const Key_t& k, const Value_t& v)
|
||||
{
|
||||
util::Lock lock(&map.first);
|
||||
map.second.emplace(k, v);
|
||||
}
|
||||
|
||||
template < typename Map_t, typename Visit_t >
|
||||
void
|
||||
MapIter(Map_t& map, Visit_t v)
|
||||
{
|
||||
util::Lock lock(map.first);
|
||||
for(const auto& item : map.second)
|
||||
v(item);
|
||||
}
|
||||
|
||||
template < typename Map_t, typename Key_t, typename Check_t >
|
||||
void
|
||||
MapDel(Map_t& map, const Key_t& k, Check_t check)
|
||||
{
|
||||
util::Lock lock(map.first);
|
||||
auto range = map.second.equal_range(k);
|
||||
for(auto i = range.first; i != range.second;)
|
||||
{
|
||||
if(check(i->second))
|
||||
i = map.second.erase(i);
|
||||
else
|
||||
++i;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
PathContext::AddOwnPath(PathSet_ptr set, Path_ptr path)
|
||||
{
|
||||
set->AddPath(path);
|
||||
MapPut(m_OurPaths, path->TXID(), set);
|
||||
MapPut(m_OurPaths, path->RXID(), set);
|
||||
}
|
||||
|
||||
bool
|
||||
PathContext::HasTransitHop(const TransitHopInfo& info)
|
||||
{
|
||||
return MapHas(m_TransitPaths, info.txID,
|
||||
[info](const std::shared_ptr< TransitHop >& hop) -> bool {
|
||||
return info == hop->info;
|
||||
});
|
||||
}
|
||||
|
||||
HopHandler_ptr
|
||||
PathContext::GetByUpstream(const RouterID& remote, const PathID_t& id)
|
||||
{
|
||||
auto own = MapGet(
|
||||
m_OurPaths, id,
|
||||
[](const PathSet_ptr) -> bool {
|
||||
// TODO: is this right?
|
||||
return true;
|
||||
},
|
||||
[remote, id](PathSet_ptr p) -> HopHandler_ptr {
|
||||
return p->GetByUpstream(remote, id);
|
||||
});
|
||||
if(own)
|
||||
return own;
|
||||
|
||||
return MapGet(
|
||||
m_TransitPaths, id,
|
||||
[remote](const std::shared_ptr< TransitHop >& hop) -> bool {
|
||||
return hop->info.upstream == remote;
|
||||
},
|
||||
[](const std::shared_ptr< TransitHop >& h) -> HopHandler_ptr {
|
||||
return h;
|
||||
});
|
||||
}
|
||||
|
||||
bool
|
||||
PathContext::TransitHopPreviousIsRouter(const PathID_t& path,
|
||||
const RouterID& otherRouter)
|
||||
{
|
||||
util::Lock lock(&m_TransitPaths.first);
|
||||
auto itr = m_TransitPaths.second.find(path);
|
||||
if(itr == m_TransitPaths.second.end())
|
||||
return false;
|
||||
return itr->second->info.downstream == otherRouter;
|
||||
}
|
||||
|
||||
HopHandler_ptr
|
||||
PathContext::GetByDownstream(const RouterID& remote, const PathID_t& id)
|
||||
{
|
||||
return MapGet(
|
||||
m_TransitPaths, id,
|
||||
[remote](const std::shared_ptr< TransitHop >& hop) -> bool {
|
||||
return hop->info.downstream == remote;
|
||||
},
|
||||
[](const std::shared_ptr< TransitHop >& h) -> HopHandler_ptr {
|
||||
return h;
|
||||
});
|
||||
}
|
||||
|
||||
PathSet_ptr
|
||||
PathContext::GetLocalPathSet(const PathID_t& id)
|
||||
{
|
||||
auto& map = m_OurPaths;
|
||||
util::Lock lock(&map.first);
|
||||
auto itr = map.second.find(id);
|
||||
if(itr != map.second.end())
|
||||
{
|
||||
return itr->second;
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
const byte_t*
|
||||
PathContext::OurRouterID() const
|
||||
{
|
||||
return m_Router->pubkey();
|
||||
}
|
||||
|
||||
AbstractRouter*
|
||||
PathContext::Router()
|
||||
{
|
||||
return m_Router;
|
||||
}
|
||||
|
||||
HopHandler_ptr
|
||||
PathContext::GetPathForTransfer(const PathID_t& id)
|
||||
{
|
||||
RouterID us(OurRouterID());
|
||||
auto& map = m_TransitPaths;
|
||||
{
|
||||
util::Lock lock(&map.first);
|
||||
auto range = map.second.equal_range(id);
|
||||
for(auto i = range.first; i != range.second; ++i)
|
||||
{
|
||||
if(i->second->info.upstream == us)
|
||||
return i->second;
|
||||
}
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void
|
||||
PathContext::PutTransitHop(std::shared_ptr< TransitHop > hop)
|
||||
{
|
||||
MapPut(m_TransitPaths, hop->info.txID, hop);
|
||||
MapPut(m_TransitPaths, hop->info.rxID, hop);
|
||||
}
|
||||
|
||||
void
|
||||
PathContext::ExpirePaths(llarp_time_t now)
|
||||
{
|
||||
{
|
||||
util::Lock lock(&m_TransitPaths.first);
|
||||
auto& map = m_TransitPaths.second;
|
||||
auto itr = map.begin();
|
||||
while(itr != map.end())
|
||||
{
|
||||
if(itr->second->Expired(now))
|
||||
{
|
||||
itr = map.erase(itr);
|
||||
}
|
||||
else
|
||||
++itr;
|
||||
}
|
||||
}
|
||||
{
|
||||
util::Lock lock(&m_OurPaths.first);
|
||||
auto& map = m_OurPaths.second;
|
||||
for(auto& item : map)
|
||||
{
|
||||
item.second->ExpirePaths(now);
|
||||
}
|
||||
}
|
||||
}
|
||||
routing::MessageHandler_ptr
|
||||
PathContext::GetHandler(const PathID_t& id)
|
||||
{
|
||||
routing::MessageHandler_ptr h = nullptr;
|
||||
auto pathset = GetLocalPathSet(id);
|
||||
if(pathset)
|
||||
{
|
||||
h = pathset->GetPathByID(id);
|
||||
}
|
||||
if(h)
|
||||
return h;
|
||||
const RouterID us(OurRouterID());
|
||||
auto& map = m_TransitPaths;
|
||||
{
|
||||
util::Lock lock(&map.first);
|
||||
auto range = map.second.equal_range(id);
|
||||
for(auto i = range.first; i != range.second; ++i)
|
||||
{
|
||||
if(i->second->info.upstream == us)
|
||||
return i->second;
|
||||
}
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void
|
||||
PathContext::RemovePathSet(PathSet_ptr set)
|
||||
{
|
||||
util::Lock lock(&m_OurPaths.first);
|
||||
auto& map = m_OurPaths.second;
|
||||
auto itr = map.begin();
|
||||
while(itr != map.end())
|
||||
{
|
||||
if(itr->second.get() == set.get())
|
||||
itr = map.erase(itr);
|
||||
else
|
||||
++itr;
|
||||
}
|
||||
}
|
||||
} // namespace path
|
||||
} // namespace llarp
|
@ -0,0 +1,156 @@
|
||||
#ifndef LLARP_PATH_CONTEXT_HPP
|
||||
#define LLARP_PATH_CONTEXT_HPP
|
||||
|
||||
#include <crypto/encrypted_frame.hpp>
|
||||
#include <path/ihophandler.hpp>
|
||||
#include <path/path_types.hpp>
|
||||
#include <path/pathset.hpp>
|
||||
#include <path/transit_hop.hpp>
|
||||
#include <routing/handler.hpp>
|
||||
#include <util/compare_ptr.hpp>
|
||||
#include <util/types.hpp>
|
||||
|
||||
#include <memory>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
class Logic;
|
||||
struct AbstractRouter;
|
||||
struct LR_CommitMessage;
|
||||
struct RelayDownstreamMessage;
|
||||
struct RelayUpstreamMessage;
|
||||
struct RouterID;
|
||||
|
||||
namespace path
|
||||
{
|
||||
struct TransitHop;
|
||||
struct TransitHopInfo;
|
||||
|
||||
using TransitHop_ptr = std::shared_ptr< TransitHop >;
|
||||
|
||||
struct PathContext
|
||||
{
|
||||
PathContext(AbstractRouter* router);
|
||||
|
||||
/// called from router tick function
|
||||
void
|
||||
ExpirePaths(llarp_time_t now);
|
||||
|
||||
void
|
||||
AllowTransit();
|
||||
|
||||
void
|
||||
RejectTransit();
|
||||
|
||||
bool
|
||||
AllowingTransit() const;
|
||||
|
||||
bool
|
||||
HasTransitHop(const TransitHopInfo& info);
|
||||
|
||||
bool
|
||||
HandleRelayCommit(const LR_CommitMessage& msg);
|
||||
|
||||
void
|
||||
PutTransitHop(std::shared_ptr< TransitHop > hop);
|
||||
|
||||
HopHandler_ptr
|
||||
GetByUpstream(const RouterID& id, const PathID_t& path);
|
||||
|
||||
bool
|
||||
TransitHopPreviousIsRouter(const PathID_t& path, const RouterID& r);
|
||||
|
||||
HopHandler_ptr
|
||||
GetPathForTransfer(const PathID_t& topath);
|
||||
|
||||
HopHandler_ptr
|
||||
GetByDownstream(const RouterID& id, const PathID_t& path);
|
||||
|
||||
PathSet_ptr
|
||||
GetLocalPathSet(const PathID_t& id);
|
||||
|
||||
routing::MessageHandler_ptr
|
||||
GetHandler(const PathID_t& id);
|
||||
|
||||
using EndpointPathPtrSet = std::set< Path_ptr, ComparePtr< Path_ptr > >;
|
||||
/// get a set of all paths that we own who's endpoint is r
|
||||
EndpointPathPtrSet
|
||||
FindOwnedPathsWithEndpoint(const RouterID& r);
|
||||
|
||||
bool
|
||||
ForwardLRCM(const RouterID& nextHop,
|
||||
const std::array< EncryptedFrame, 8 >& frames);
|
||||
|
||||
bool
|
||||
HopIsUs(const RouterID& k) const;
|
||||
|
||||
bool
|
||||
HandleLRUM(const RelayUpstreamMessage& msg);
|
||||
|
||||
bool
|
||||
HandleLRDM(const RelayDownstreamMessage& msg);
|
||||
|
||||
void
|
||||
AddOwnPath(PathSet_ptr set, Path_ptr p);
|
||||
|
||||
void
|
||||
RemovePathSet(PathSet_ptr set);
|
||||
|
||||
using TransitHopsMap_t = std::multimap< PathID_t, TransitHop_ptr >;
|
||||
|
||||
struct SyncTransitMap_t
|
||||
{
|
||||
util::Mutex first; // protects second
|
||||
TransitHopsMap_t second GUARDED_BY(first);
|
||||
|
||||
void
|
||||
ForEach(std::function< void(const TransitHop_ptr&) > visit)
|
||||
{
|
||||
util::Lock lock(&first);
|
||||
for(const auto& item : second)
|
||||
visit(item.second);
|
||||
}
|
||||
};
|
||||
|
||||
// maps path id -> pathset owner of path
|
||||
using OwnedPathsMap_t = std::map< PathID_t, PathSet_ptr >;
|
||||
|
||||
struct SyncOwnedPathsMap_t
|
||||
{
|
||||
util::Mutex first; // protects second
|
||||
OwnedPathsMap_t second GUARDED_BY(first);
|
||||
|
||||
void
|
||||
ForEach(std::function< void(const PathSet_ptr&) > visit)
|
||||
{
|
||||
util::Lock lock(&first);
|
||||
for(const auto& item : second)
|
||||
visit(item.second);
|
||||
}
|
||||
};
|
||||
|
||||
llarp_threadpool*
|
||||
Worker();
|
||||
|
||||
std::shared_ptr< Logic >
|
||||
logic();
|
||||
|
||||
AbstractRouter*
|
||||
Router();
|
||||
|
||||
const SecretKey&
|
||||
EncryptionSecretKey();
|
||||
|
||||
const byte_t*
|
||||
OurRouterID() const;
|
||||
|
||||
private:
|
||||
AbstractRouter* m_Router;
|
||||
SyncTransitMap_t m_TransitPaths;
|
||||
SyncOwnedPathsMap_t m_OurPaths;
|
||||
bool m_AllowTransit;
|
||||
};
|
||||
} // namespace path
|
||||
} // namespace llarp
|
||||
|
||||
#endif
|
@ -0,0 +1,206 @@
|
||||
#ifndef LLARP_PATH_TRANSIT_HOP_HPP
|
||||
#define LLARP_PATH_TRANSIT_HOP_HPP
|
||||
|
||||
#include <constants/path.hpp>
|
||||
#include <path/ihophandler.hpp>
|
||||
#include <path/path_types.hpp>
|
||||
#include <routing/handler.hpp>
|
||||
#include <router_id.hpp>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
struct LR_CommitRecord;
|
||||
|
||||
namespace dht
|
||||
{
|
||||
struct GotIntroMessage;
|
||||
}
|
||||
|
||||
namespace path
|
||||
{
|
||||
struct TransitHopInfo
|
||||
{
|
||||
TransitHopInfo() = default;
|
||||
TransitHopInfo(const RouterID& down, const LR_CommitRecord& record);
|
||||
|
||||
PathID_t txID, rxID;
|
||||
RouterID upstream;
|
||||
RouterID downstream;
|
||||
|
||||
std::ostream&
|
||||
print(std::ostream& stream, int level, int spaces) const;
|
||||
|
||||
struct PathIDHash
|
||||
{
|
||||
std::size_t
|
||||
operator()(const PathID_t& a) const
|
||||
{
|
||||
return AlignedBuffer< PathID_t::SIZE >::Hash()(a);
|
||||
}
|
||||
};
|
||||
|
||||
struct Hash
|
||||
{
|
||||
std::size_t
|
||||
operator()(TransitHopInfo const& a) const
|
||||
{
|
||||
std::size_t idx0 = RouterID::Hash()(a.upstream);
|
||||
std::size_t idx1 = RouterID::Hash()(a.downstream);
|
||||
std::size_t idx2 = PathIDHash()(a.txID);
|
||||
std::size_t idx3 = PathIDHash()(a.rxID);
|
||||
return idx0 ^ idx1 ^ idx2 ^ idx3;
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
inline bool
|
||||
operator==(const TransitHopInfo& lhs, const TransitHopInfo& rhs)
|
||||
{
|
||||
return std::tie(lhs.txID, lhs.rxID, lhs.upstream, lhs.downstream)
|
||||
== std::tie(rhs.txID, rhs.rxID, rhs.upstream, rhs.downstream);
|
||||
}
|
||||
|
||||
inline bool
|
||||
operator!=(const TransitHopInfo& lhs, const TransitHopInfo& rhs)
|
||||
{
|
||||
return !(lhs == rhs);
|
||||
}
|
||||
|
||||
inline bool
|
||||
operator<(const TransitHopInfo& lhs, const TransitHopInfo& rhs)
|
||||
{
|
||||
return std::tie(lhs.txID, lhs.rxID, lhs.upstream, lhs.downstream)
|
||||
< std::tie(rhs.txID, rhs.rxID, rhs.upstream, rhs.downstream);
|
||||
}
|
||||
|
||||
inline std::ostream&
|
||||
operator<<(std::ostream& out, const TransitHopInfo& info)
|
||||
{
|
||||
return info.print(out, -1, -1);
|
||||
}
|
||||
|
||||
struct TransitHop : public IHopHandler, public routing::IMessageHandler
|
||||
{
|
||||
TransitHop();
|
||||
|
||||
TransitHopInfo info;
|
||||
SharedSecret pathKey;
|
||||
ShortHash nonceXOR;
|
||||
llarp_time_t started = 0;
|
||||
// 10 minutes default
|
||||
llarp_time_t lifetime = default_lifetime;
|
||||
llarp_proto_version_t version;
|
||||
llarp_time_t m_LastActivity = 0;
|
||||
|
||||
bool
|
||||
IsEndpoint(const RouterID& us) const
|
||||
{
|
||||
return info.upstream == us;
|
||||
}
|
||||
|
||||
llarp_time_t
|
||||
ExpireTime() const;
|
||||
|
||||
llarp_time_t
|
||||
LastRemoteActivityAt() const override
|
||||
{
|
||||
return m_LastActivity;
|
||||
}
|
||||
|
||||
std::ostream&
|
||||
print(std::ostream& stream, int level, int spaces) const;
|
||||
|
||||
bool
|
||||
Expired(llarp_time_t now) const override;
|
||||
|
||||
bool
|
||||
ExpiresSoon(llarp_time_t now, llarp_time_t dlt) const override
|
||||
{
|
||||
return now >= ExpireTime() - dlt;
|
||||
}
|
||||
|
||||
// send routing message when end of path
|
||||
bool
|
||||
SendRoutingMessage(const routing::IMessage& msg,
|
||||
AbstractRouter* r) override;
|
||||
|
||||
// handle routing message when end of path
|
||||
bool
|
||||
HandleRoutingMessage(const routing::IMessage& msg, AbstractRouter* r);
|
||||
|
||||
bool
|
||||
HandleDataDiscardMessage(const routing::DataDiscardMessage& msg,
|
||||
AbstractRouter* r) override;
|
||||
|
||||
bool
|
||||
HandlePathConfirmMessage(const routing::PathConfirmMessage& msg,
|
||||
AbstractRouter* r) override;
|
||||
bool
|
||||
HandlePathTransferMessage(const routing::PathTransferMessage& msg,
|
||||
AbstractRouter* r) override;
|
||||
bool
|
||||
HandlePathLatencyMessage(const routing::PathLatencyMessage& msg,
|
||||
AbstractRouter* r) override;
|
||||
|
||||
bool
|
||||
HandleObtainExitMessage(const routing::ObtainExitMessage& msg,
|
||||
AbstractRouter* r) override;
|
||||
|
||||
bool
|
||||
HandleUpdateExitVerifyMessage(const routing::UpdateExitVerifyMessage& msg,
|
||||
AbstractRouter* r) override;
|
||||
|
||||
bool
|
||||
HandleTransferTrafficMessage(const routing::TransferTrafficMessage& msg,
|
||||
AbstractRouter* r) override;
|
||||
|
||||
bool
|
||||
HandleUpdateExitMessage(const routing::UpdateExitMessage& msg,
|
||||
AbstractRouter* r) override;
|
||||
|
||||
bool
|
||||
HandleGrantExitMessage(const routing::GrantExitMessage& msg,
|
||||
AbstractRouter* r) override;
|
||||
bool
|
||||
HandleRejectExitMessage(const routing::RejectExitMessage& msg,
|
||||
AbstractRouter* r) override;
|
||||
|
||||
bool
|
||||
HandleCloseExitMessage(const routing::CloseExitMessage& msg,
|
||||
AbstractRouter* r) override;
|
||||
|
||||
bool
|
||||
HandleHiddenServiceFrame(
|
||||
ABSL_ATTRIBUTE_UNUSED const service::ProtocolFrame& frame) override
|
||||
{
|
||||
/// TODO: implement me
|
||||
LogWarn("Got hidden service data on transit hop");
|
||||
return false;
|
||||
}
|
||||
|
||||
bool
|
||||
HandleGotIntroMessage(const dht::GotIntroMessage& msg);
|
||||
|
||||
bool
|
||||
HandleDHTMessage(const dht::IMessage& msg, AbstractRouter* r) override;
|
||||
|
||||
// handle data in upstream direction
|
||||
bool
|
||||
HandleUpstream(const llarp_buffer_t& X, const TunnelNonce& Y,
|
||||
AbstractRouter* r) override;
|
||||
|
||||
// handle data in downstream direction
|
||||
bool
|
||||
HandleDownstream(const llarp_buffer_t& X, const TunnelNonce& Y,
|
||||
AbstractRouter* r) override;
|
||||
};
|
||||
|
||||
inline std::ostream&
|
||||
operator<<(std::ostream& out, const TransitHop& h)
|
||||
{
|
||||
return h.print(out, -1, -1);
|
||||
}
|
||||
} // namespace path
|
||||
} // namespace llarp
|
||||
|
||||
#endif
|
@ -1,4 +1,5 @@
|
||||
#include <messages/path_latency.hpp>
|
||||
#include <routing/path_latency_message.hpp>
|
||||
|
||||
#include <routing/handler.hpp>
|
||||
#include <util/bencode.hpp>
|
||||
|
@ -1,4 +1,4 @@
|
||||
#include <messages/transfer_traffic.hpp>
|
||||
#include <routing/transfer_traffic_message.hpp>
|
||||
|
||||
#include <routing/handler.hpp>
|
||||
#include <util/bencode.hpp>
|
Loading…
Reference in New Issue