mirror of
https://github.com/oxen-io/lokinet.git
synced 2024-11-17 15:25:35 +00:00
11e54f6552
- routing messages and surrounding code - shim code in place for iteration and optimization after deciding what to do with buffer, string handling, and subsequent function calls
464 lines
11 KiB
C++
464 lines
11 KiB
C++
#include "exit_messages.hpp"
|
|
|
|
#include <llarp/crypto/crypto.hpp>
|
|
#include <llarp/routing/handler.hpp>
|
|
|
|
namespace llarp::routing
|
|
{
|
|
bool
|
|
ObtainExitMessage::Sign(const llarp::SecretKey& sk)
|
|
{
|
|
std::array<byte_t, 1024> tmp;
|
|
llarp_buffer_t buf(tmp);
|
|
pubkey = seckey_topublic(sk);
|
|
sig.Zero();
|
|
|
|
auto bte = bt_encode();
|
|
buf.write(bte.begin(), bte.end());
|
|
|
|
buf.sz = buf.cur - buf.base;
|
|
return CryptoManager::instance()->sign(sig, sk, buf);
|
|
}
|
|
|
|
bool
|
|
ObtainExitMessage::Verify() const
|
|
{
|
|
std::array<byte_t, 1024> tmp;
|
|
llarp_buffer_t buf(tmp);
|
|
ObtainExitMessage copy;
|
|
copy = *this;
|
|
copy.sig.Zero();
|
|
|
|
auto bte = copy.bt_encode();
|
|
buf.write(bte.begin(), bte.end());
|
|
|
|
// rewind buffer
|
|
buf.sz = buf.cur - buf.base;
|
|
return CryptoManager::instance()->verify(pubkey, buf, sig);
|
|
}
|
|
|
|
std::string
|
|
ObtainExitMessage::bt_encode() const
|
|
{
|
|
oxenc::bt_dict_producer btdp;
|
|
|
|
try
|
|
{
|
|
btdp.append("A", "O");
|
|
|
|
{
|
|
auto subdict = btdp.append_dict("B");
|
|
|
|
for (auto& b : blacklist_policy)
|
|
b.bt_encode(subdict);
|
|
}
|
|
|
|
btdp.append("E", flag);
|
|
btdp.append("I", pubkey.ToView());
|
|
btdp.append("S", sequence_number);
|
|
btdp.append("T", tx_id);
|
|
btdp.append("V", version);
|
|
|
|
{
|
|
auto subdict = btdp.append_dict("B");
|
|
|
|
for (auto& w : whitelist_policy)
|
|
w.bt_encode(subdict);
|
|
}
|
|
|
|
btdp.append("X", address_lifetime);
|
|
btdp.append("Z", sig.ToView());
|
|
}
|
|
catch (...)
|
|
{
|
|
log::critical(route_cat, "Error: ObtainExitMessage failed to bt encode contents!");
|
|
}
|
|
|
|
return std::move(btdp).str();
|
|
}
|
|
|
|
bool
|
|
ObtainExitMessage::decode_key(const llarp_buffer_t& k, llarp_buffer_t* buf)
|
|
{
|
|
bool read = false;
|
|
if (!BEncodeMaybeReadDictList("B", blacklist_policy, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictInt("E", flag, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictEntry("I", pubkey, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictInt("S", sequence_number, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictInt("T", tx_id, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictInt("V", version, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictList("W", whitelist_policy, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictInt("X", address_lifetime, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictEntry("Z", sig, read, k, buf))
|
|
return false;
|
|
return read;
|
|
}
|
|
|
|
bool
|
|
ObtainExitMessage::handle_message(AbstractRoutingMessageHandler* h, AbstractRouter* r) const
|
|
{
|
|
return h->HandleObtainExitMessage(*this, r);
|
|
}
|
|
|
|
std::string
|
|
GrantExitMessage::bt_encode() const
|
|
{
|
|
oxenc::bt_dict_producer btdp;
|
|
|
|
try
|
|
{
|
|
btdp.append("A", "G");
|
|
btdp.append("S", sequence_number);
|
|
btdp.append("T", tx_id);
|
|
btdp.append("V", version);
|
|
btdp.append("Y", nonce.ToView());
|
|
btdp.append("Z", sig.ToView());
|
|
}
|
|
catch (...)
|
|
{
|
|
log::critical(route_cat, "Error: GrantExitMessage failed to bt encode contents!");
|
|
}
|
|
|
|
return std::move(btdp).str();
|
|
}
|
|
|
|
bool
|
|
GrantExitMessage::decode_key(const llarp_buffer_t& k, llarp_buffer_t* buf)
|
|
{
|
|
bool read = false;
|
|
if (!BEncodeMaybeReadDictInt("S", sequence_number, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictInt("T", tx_id, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictInt("V", version, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictEntry("Y", nonce, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictEntry("Z", sig, 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.sig.Zero();
|
|
|
|
auto bte = copy.bt_encode();
|
|
buf.write(bte.begin(), bte.end());
|
|
|
|
buf.sz = buf.cur - buf.base;
|
|
return CryptoManager::instance()->verify(pk, buf, sig);
|
|
}
|
|
|
|
bool
|
|
GrantExitMessage::Sign(const llarp::SecretKey& sk)
|
|
{
|
|
std::array<byte_t, 512> tmp;
|
|
llarp_buffer_t buf(tmp);
|
|
sig.Zero();
|
|
nonce.Randomize();
|
|
|
|
auto bte = bt_encode();
|
|
buf.write(bte.begin(), bte.end());
|
|
|
|
buf.sz = buf.cur - buf.base;
|
|
return CryptoManager::instance()->sign(sig, sk, buf);
|
|
}
|
|
|
|
bool
|
|
GrantExitMessage::handle_message(AbstractRoutingMessageHandler* h, AbstractRouter* r) const
|
|
{
|
|
return h->HandleGrantExitMessage(*this, r);
|
|
}
|
|
|
|
std::string
|
|
RejectExitMessage::bt_encode() const
|
|
{
|
|
oxenc::bt_dict_producer btdp;
|
|
|
|
try
|
|
{
|
|
btdp.append("A", "J");
|
|
btdp.append("B", backoff_time);
|
|
|
|
{
|
|
auto subdict = btdp.append_dict("R");
|
|
|
|
for (auto& b : blacklist_policy)
|
|
b.bt_encode(subdict);
|
|
}
|
|
|
|
btdp.append("S", sequence_number);
|
|
btdp.append("T", tx_id);
|
|
btdp.append("V", version);
|
|
btdp.append("Y", nonce.ToView());
|
|
btdp.append("Z", sig.ToView());
|
|
}
|
|
catch (...)
|
|
{
|
|
log::critical(route_cat, "Error: RejectExitMessage failed to bt encode contents!");
|
|
}
|
|
|
|
return std::move(btdp).str();
|
|
}
|
|
|
|
bool
|
|
RejectExitMessage::decode_key(const llarp_buffer_t& k, llarp_buffer_t* buf)
|
|
{
|
|
bool read = false;
|
|
if (!BEncodeMaybeReadDictInt("B", backoff_time, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictList("R", blacklist_policy, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictInt("S", sequence_number, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictInt("T", tx_id, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictInt("V", version, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictEntry("Y", nonce, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictEntry("Z", sig, 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);
|
|
sig.Zero();
|
|
nonce.Randomize();
|
|
|
|
auto bte = bt_encode();
|
|
buf.write(bte.begin(), bte.end());
|
|
|
|
buf.sz = buf.cur - buf.base;
|
|
return CryptoManager::instance()->sign(sig, 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.sig.Zero();
|
|
|
|
auto bte = copy.bt_encode();
|
|
buf.write(bte.begin(), bte.end());
|
|
|
|
buf.sz = buf.cur - buf.base;
|
|
return CryptoManager::instance()->verify(pk, buf, sig);
|
|
}
|
|
|
|
bool
|
|
RejectExitMessage::handle_message(AbstractRoutingMessageHandler* h, AbstractRouter* r) const
|
|
{
|
|
return h->HandleRejectExitMessage(*this, r);
|
|
}
|
|
|
|
std::string
|
|
UpdateExitMessage::bt_encode() const
|
|
{
|
|
oxenc::bt_dict_producer btdp;
|
|
|
|
try
|
|
{
|
|
btdp.append("A", "V");
|
|
btdp.append("P", path_id.ToView());
|
|
btdp.append("S", sequence_number);
|
|
btdp.append("T", tx_id);
|
|
btdp.append("V", version);
|
|
btdp.append("Z", sig.ToView());
|
|
}
|
|
catch (...)
|
|
{
|
|
log::critical(route_cat, "Error: UpdateExitMessage failed to bt encode contents!");
|
|
}
|
|
|
|
return std::move(btdp).str();
|
|
}
|
|
|
|
bool
|
|
UpdateExitMessage::decode_key(const llarp_buffer_t& k, llarp_buffer_t* buf)
|
|
{
|
|
bool read = false;
|
|
if (!BEncodeMaybeReadDictInt("S", sequence_number, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictInt("T", tx_id, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictInt("V", version, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictEntry("P", path_id, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictEntry("Z", sig, 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.sig.Zero();
|
|
|
|
auto bte = copy.bt_encode();
|
|
buf.write(bte.begin(), bte.end());
|
|
|
|
buf.sz = buf.cur - buf.base;
|
|
return CryptoManager::instance()->verify(pk, buf, sig);
|
|
}
|
|
|
|
bool
|
|
UpdateExitMessage::Sign(const llarp::SecretKey& sk)
|
|
{
|
|
std::array<byte_t, 512> tmp;
|
|
llarp_buffer_t buf(tmp);
|
|
nonce.Randomize();
|
|
|
|
auto bte = bt_encode();
|
|
buf.write(bte.begin(), bte.end());
|
|
|
|
buf.sz = buf.cur - buf.base;
|
|
return CryptoManager::instance()->sign(sig, sk, buf);
|
|
}
|
|
|
|
bool
|
|
UpdateExitMessage::handle_message(AbstractRoutingMessageHandler* h, AbstractRouter* r) const
|
|
{
|
|
return h->HandleUpdateExitMessage(*this, r);
|
|
}
|
|
|
|
std::string
|
|
UpdateExitVerifyMessage::bt_encode() const
|
|
{
|
|
oxenc::bt_dict_producer btdp;
|
|
|
|
try
|
|
{
|
|
btdp.append("A", "V");
|
|
btdp.append("S", sequence_number);
|
|
btdp.append("T", tx_id);
|
|
btdp.append("V", version);
|
|
}
|
|
catch (...)
|
|
{
|
|
log::critical(route_cat, "Error: UpdateExitVerifyMessage failed to bt encode contents!");
|
|
}
|
|
|
|
return std::move(btdp).str();
|
|
}
|
|
|
|
bool
|
|
UpdateExitVerifyMessage::decode_key(const llarp_buffer_t& k, llarp_buffer_t* buf)
|
|
{
|
|
bool read = false;
|
|
if (!BEncodeMaybeReadDictInt("S", sequence_number, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictInt("T", tx_id, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictInt("V", version, read, k, buf))
|
|
return false;
|
|
return read;
|
|
}
|
|
|
|
bool
|
|
UpdateExitVerifyMessage::handle_message(AbstractRoutingMessageHandler* h, AbstractRouter* r) const
|
|
{
|
|
return h->HandleUpdateExitVerifyMessage(*this, r);
|
|
}
|
|
|
|
std::string
|
|
CloseExitMessage::bt_encode() const
|
|
{
|
|
oxenc::bt_dict_producer btdp;
|
|
|
|
try
|
|
{
|
|
btdp.append("A", "C");
|
|
btdp.append("S", sequence_number);
|
|
btdp.append("V", version);
|
|
btdp.append("Y", nonce.ToView());
|
|
btdp.append("Z", sig.ToView());
|
|
}
|
|
catch (...)
|
|
{
|
|
log::critical(route_cat, "Error: CloseExitMessage failed to bt encode contents!");
|
|
}
|
|
|
|
return std::move(btdp).str();
|
|
}
|
|
|
|
bool
|
|
CloseExitMessage::decode_key(const llarp_buffer_t& k, llarp_buffer_t* buf)
|
|
{
|
|
bool read = false;
|
|
if (!BEncodeMaybeReadDictInt("S", sequence_number, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictInt("V", version, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictEntry("Y", nonce, read, k, buf))
|
|
return false;
|
|
if (!BEncodeMaybeReadDictEntry("Z", sig, 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.sig.Zero();
|
|
|
|
auto bte = copy.bt_encode();
|
|
buf.write(bte.begin(), bte.end());
|
|
|
|
buf.sz = buf.cur - buf.base;
|
|
return CryptoManager::instance()->verify(pk, buf, sig);
|
|
}
|
|
|
|
bool
|
|
CloseExitMessage::Sign(const llarp::SecretKey& sk)
|
|
{
|
|
std::array<byte_t, 512> tmp;
|
|
llarp_buffer_t buf(tmp);
|
|
sig.Zero();
|
|
nonce.Randomize();
|
|
|
|
auto bte = bt_encode();
|
|
buf.write(bte.begin(), bte.end());
|
|
|
|
buf.sz = buf.cur - buf.base;
|
|
return CryptoManager::instance()->sign(sig, sk, buf);
|
|
}
|
|
|
|
bool
|
|
CloseExitMessage::handle_message(AbstractRoutingMessageHandler* h, AbstractRouter* r) const
|
|
{
|
|
return h->HandleCloseExitMessage(*this, r);
|
|
}
|
|
} // namespace llarp::routing
|