mirror of
https://github.com/oxen-io/lokinet
synced 2023-12-14 06:53:00 +01:00
Merge pull request #173 from majestrate/master
don't do as many allocations when processing messages
This commit is contained in:
commit
733191311e
28 changed files with 272 additions and 219 deletions
|
@ -12,6 +12,7 @@
|
|||
#include <memory>
|
||||
#include <numeric>
|
||||
#include <type_traits>
|
||||
#include <algorithm>
|
||||
|
||||
extern "C"
|
||||
{
|
||||
|
|
|
@ -8,6 +8,12 @@ namespace llarp
|
|||
{
|
||||
}
|
||||
|
||||
void
|
||||
DHTImmeidateMessage::Clear()
|
||||
{
|
||||
msgs.clear();
|
||||
}
|
||||
|
||||
bool
|
||||
DHTImmeidateMessage::DecodeKey(llarp_buffer_t key, llarp_buffer_t *buf)
|
||||
{
|
||||
|
@ -60,8 +66,9 @@ namespace llarp
|
|||
bool
|
||||
DHTImmeidateMessage::HandleMessage(llarp::Router *router) const
|
||||
{
|
||||
DHTImmeidateMessage reply(session);
|
||||
bool result = true;
|
||||
DHTImmeidateMessage reply;
|
||||
reply.session = session;
|
||||
bool result = true;
|
||||
for(auto &msg : msgs)
|
||||
{
|
||||
result &= msg->HandleMessage(router->dht, reply.msgs);
|
||||
|
|
|
@ -1 +1,5 @@
|
|||
#include <encrypted.hpp>
|
||||
#include <mem.hpp>
|
||||
namespace llarp
|
||||
{
|
||||
} // namespace llarp
|
||||
|
|
|
@ -4,6 +4,8 @@
|
|||
#include <aligned.hpp>
|
||||
#include <bencode.h>
|
||||
#include <buffer.h>
|
||||
#include <mem.hpp>
|
||||
#include <link_layer.hpp>
|
||||
|
||||
#include <vector>
|
||||
#include <stdexcept>
|
||||
|
@ -11,26 +13,66 @@
|
|||
namespace llarp
|
||||
{
|
||||
/// encrypted buffer base type
|
||||
template < size_t bufsz = MAX_LINK_MSG_SIZE >
|
||||
struct Encrypted
|
||||
{
|
||||
Encrypted(Encrypted&& other);
|
||||
Encrypted(const Encrypted& other);
|
||||
Encrypted();
|
||||
Encrypted(const byte_t* buf, size_t sz);
|
||||
Encrypted(size_t sz);
|
||||
~Encrypted();
|
||||
Encrypted(Encrypted&& other)
|
||||
{
|
||||
_sz = std::move(other._sz);
|
||||
memcpy(_buf, other._buf, _sz);
|
||||
UpdateBuffer();
|
||||
}
|
||||
|
||||
Encrypted(const Encrypted& other) : Encrypted(other.data(), other.size())
|
||||
{
|
||||
UpdateBuffer();
|
||||
}
|
||||
|
||||
Encrypted()
|
||||
{
|
||||
Clear();
|
||||
}
|
||||
|
||||
void
|
||||
Clear()
|
||||
{
|
||||
_sz = 0;
|
||||
UpdateBuffer();
|
||||
}
|
||||
|
||||
Encrypted(const byte_t* buf, size_t sz)
|
||||
{
|
||||
if(sz <= bufsz)
|
||||
{
|
||||
_sz = sz;
|
||||
if(buf)
|
||||
memcpy(_buf, buf, sz);
|
||||
else
|
||||
llarp::Zero(_buf, sz);
|
||||
}
|
||||
else
|
||||
_sz = 0;
|
||||
UpdateBuffer();
|
||||
}
|
||||
|
||||
Encrypted(size_t sz) : Encrypted(nullptr, sz)
|
||||
{
|
||||
}
|
||||
|
||||
~Encrypted()
|
||||
{
|
||||
}
|
||||
|
||||
bool
|
||||
BEncode(llarp_buffer_t* buf) const
|
||||
{
|
||||
return bencode_write_bytestring(buf, data(), size());
|
||||
return bencode_write_bytestring(buf, _buf, _sz);
|
||||
}
|
||||
|
||||
bool
|
||||
operator==(const Encrypted& other) const
|
||||
{
|
||||
return size() == other.size()
|
||||
&& memcmp(data(), other.data(), size()) == 0;
|
||||
return _sz == other._sz && memcmp(_buf, other._buf, _sz) == 0;
|
||||
}
|
||||
|
||||
bool
|
||||
|
@ -48,10 +90,10 @@ namespace llarp
|
|||
Encrypted&
|
||||
operator=(const llarp_buffer_t& buf)
|
||||
{
|
||||
_data.resize(buf.sz);
|
||||
if(buf.sz)
|
||||
if(buf.sz <= sizeof(_buf))
|
||||
{
|
||||
memcpy(data(), buf.base, buf.sz);
|
||||
_sz = buf.sz;
|
||||
memcpy(_buf, buf.base, _sz);
|
||||
}
|
||||
UpdateBuffer();
|
||||
return *this;
|
||||
|
@ -60,18 +102,16 @@ namespace llarp
|
|||
void
|
||||
Fill(byte_t fill)
|
||||
{
|
||||
size_t _sz = size();
|
||||
size_t idx = 0;
|
||||
while(idx < _sz)
|
||||
_data[idx++] = fill;
|
||||
_buf[idx++] = fill;
|
||||
}
|
||||
|
||||
void
|
||||
Randomize()
|
||||
{
|
||||
size_t _sz = size();
|
||||
if(_sz)
|
||||
randombytes(data(), _sz);
|
||||
randombytes(_buf, _sz);
|
||||
}
|
||||
|
||||
bool
|
||||
|
@ -80,10 +120,11 @@ namespace llarp
|
|||
llarp_buffer_t strbuf;
|
||||
if(!bencode_read_string(buf, &strbuf))
|
||||
return false;
|
||||
if(strbuf.sz == 0)
|
||||
if(strbuf.sz > sizeof(_buf))
|
||||
return false;
|
||||
_data.resize(strbuf.sz);
|
||||
memcpy(data(), strbuf.base, size());
|
||||
_sz = strbuf.sz;
|
||||
if(_sz)
|
||||
memcpy(_buf, strbuf.base, _sz);
|
||||
UpdateBuffer();
|
||||
return true;
|
||||
}
|
||||
|
@ -103,38 +144,39 @@ namespace llarp
|
|||
size_t
|
||||
size()
|
||||
{
|
||||
return _data.size();
|
||||
return _sz;
|
||||
}
|
||||
|
||||
size_t
|
||||
size() const
|
||||
{
|
||||
return _data.size();
|
||||
return _sz;
|
||||
}
|
||||
|
||||
byte_t*
|
||||
data()
|
||||
{
|
||||
return _data.data();
|
||||
return _buf;
|
||||
}
|
||||
|
||||
const byte_t*
|
||||
data() const
|
||||
{
|
||||
return _data.data();
|
||||
return _buf;
|
||||
}
|
||||
|
||||
protected:
|
||||
void
|
||||
UpdateBuffer()
|
||||
{
|
||||
m_Buffer.base = data();
|
||||
m_Buffer.cur = data();
|
||||
m_Buffer.sz = size();
|
||||
m_Buffer.base = _buf;
|
||||
m_Buffer.cur = _buf;
|
||||
m_Buffer.sz = _sz;
|
||||
}
|
||||
std::vector< byte_t > _data;
|
||||
byte_t _buf[bufsz];
|
||||
size_t _sz;
|
||||
llarp_buffer_t m_Buffer;
|
||||
};
|
||||
}; // namespace llarp
|
||||
} // namespace llarp
|
||||
|
||||
#endif
|
||||
|
|
|
@ -7,12 +7,6 @@ namespace llarp
|
|||
{
|
||||
struct Crypto;
|
||||
|
||||
struct EncryptedAck : public Encrypted
|
||||
{
|
||||
bool
|
||||
DecryptInPlace(const byte_t* symkey, const byte_t* nonce,
|
||||
llarp::Crypto* crypto);
|
||||
};
|
||||
} // namespace llarp
|
||||
|
||||
#endif
|
||||
|
|
|
@ -5,39 +5,6 @@
|
|||
|
||||
namespace llarp
|
||||
{
|
||||
Encrypted::Encrypted()
|
||||
{
|
||||
UpdateBuffer();
|
||||
}
|
||||
|
||||
Encrypted::Encrypted(Encrypted&& other)
|
||||
{
|
||||
_data = std::move(other._data);
|
||||
UpdateBuffer();
|
||||
}
|
||||
|
||||
Encrypted::Encrypted(const Encrypted& other)
|
||||
: Encrypted(other.data(), other.size())
|
||||
{
|
||||
}
|
||||
|
||||
Encrypted::Encrypted(const byte_t* buf, size_t sz) : _data(sz)
|
||||
{
|
||||
if(buf)
|
||||
memcpy(data(), buf, sz);
|
||||
else
|
||||
llarp::Zero(data(), sz);
|
||||
UpdateBuffer();
|
||||
}
|
||||
|
||||
Encrypted::~Encrypted()
|
||||
{
|
||||
}
|
||||
|
||||
Encrypted::Encrypted(size_t sz) : Encrypted(nullptr, sz)
|
||||
{
|
||||
}
|
||||
|
||||
bool
|
||||
EncryptedFrame::EncryptInPlace(const byte_t* ourSecretKey,
|
||||
const byte_t* otherPubkey,
|
||||
|
@ -63,7 +30,7 @@ namespace llarp
|
|||
llarp_buffer_t buf;
|
||||
buf.base = body;
|
||||
buf.cur = buf.base;
|
||||
buf.sz = size() - EncryptedFrame::OverheadSize;
|
||||
buf.sz = size() - EncryptedFrameOverheadSize;
|
||||
|
||||
// set our pubkey
|
||||
memcpy(pubkey, llarp::seckey_topublic(ourSecretKey), PUBKEYSIZE);
|
||||
|
@ -101,12 +68,6 @@ namespace llarp
|
|||
EncryptedFrame::DecryptInPlace(const byte_t* ourSecretKey,
|
||||
llarp::Crypto* crypto)
|
||||
{
|
||||
if(size() <= size_t(EncryptedFrame::OverheadSize))
|
||||
{
|
||||
llarp::LogWarn("encrypted frame too small, ", size(),
|
||||
" <= ", size_t(EncryptedFrame::OverheadSize));
|
||||
return false;
|
||||
}
|
||||
// format of frame is
|
||||
// <32 bytes keyed hash of following data>
|
||||
// <32 bytes nonce>
|
||||
|
@ -151,7 +112,7 @@ namespace llarp
|
|||
|
||||
buf.base = body;
|
||||
buf.cur = body;
|
||||
buf.sz = size() - EncryptedFrame::OverheadSize;
|
||||
buf.sz = size() - EncryptedFrameOverheadSize;
|
||||
|
||||
if(!Decrypt(buf, shared, nonce))
|
||||
{
|
||||
|
|
|
@ -3,38 +3,37 @@
|
|||
|
||||
#include <crypto.h>
|
||||
#include <encrypted.hpp>
|
||||
#include <buffer.hpp>
|
||||
#include <mem.h>
|
||||
#include <threadpool.h>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
struct EncryptedFrame : public Encrypted
|
||||
static constexpr size_t EncryptedFrameOverheadSize =
|
||||
PUBKEYSIZE + TUNNONCESIZE + SHORTHASHSIZE;
|
||||
static constexpr size_t EncryptedFrameBodySize = 512;
|
||||
static constexpr size_t EncryptedFrameSize =
|
||||
EncryptedFrameOverheadSize + EncryptedFrameBodySize;
|
||||
|
||||
struct EncryptedFrame : public Encrypted< EncryptedFrameSize >
|
||||
{
|
||||
static constexpr size_t OverheadSize =
|
||||
PUBKEYSIZE + TUNNONCESIZE + SHORTHASHSIZE;
|
||||
|
||||
EncryptedFrame() : EncryptedFrame(256)
|
||||
EncryptedFrame() : EncryptedFrame(EncryptedFrameBodySize)
|
||||
{
|
||||
}
|
||||
|
||||
EncryptedFrame(const EncryptedFrame& other)
|
||||
: EncryptedFrame(other.data(), other.size())
|
||||
{
|
||||
}
|
||||
|
||||
EncryptedFrame(const byte_t* buf, size_t sz) : Encrypted(buf, sz)
|
||||
{
|
||||
}
|
||||
EncryptedFrame(size_t sz)
|
||||
: Encrypted(sz + PUBKEYSIZE + TUNNONCESIZE + SHORTHASHSIZE)
|
||||
: Encrypted< EncryptedFrameSize >(std::min(sz, EncryptedFrameBodySize)
|
||||
+ EncryptedFrameOverheadSize)
|
||||
{
|
||||
UpdateBuffer();
|
||||
}
|
||||
|
||||
EncryptedFrame&
|
||||
operator=(const EncryptedFrame& other)
|
||||
{
|
||||
_data.resize(other.size());
|
||||
_sz = other._sz;
|
||||
memcpy(data(), other.data(), size());
|
||||
UpdateBuffer();
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
@ -58,8 +57,8 @@ namespace llarp
|
|||
AsyncFrameEncrypter< User >* ctx =
|
||||
static_cast< AsyncFrameEncrypter< User >* >(user);
|
||||
|
||||
if(ctx->frame->EncryptInPlace(ctx->seckey, ctx->otherKey, ctx->crypto))
|
||||
ctx->handler(ctx->frame, ctx->user);
|
||||
if(ctx->frame.EncryptInPlace(ctx->seckey, ctx->otherKey, ctx->crypto))
|
||||
ctx->handler(&ctx->frame, ctx->user);
|
||||
else
|
||||
{
|
||||
ctx->handler(nullptr, ctx->user);
|
||||
|
@ -69,7 +68,7 @@ namespace llarp
|
|||
llarp::Crypto* crypto;
|
||||
byte_t* secretkey;
|
||||
EncryptHandler handler;
|
||||
EncryptedFrame* frame;
|
||||
EncryptedFrame frame;
|
||||
User* user;
|
||||
byte_t* otherKey;
|
||||
|
||||
|
@ -84,9 +83,10 @@ namespace llarp
|
|||
{
|
||||
// TODO: should we own otherKey?
|
||||
otherKey = other;
|
||||
frame = new EncryptedFrame(buf.sz);
|
||||
memcpy(frame->data() + PUBKEYSIZE + TUNNONCESIZE + SHORTHASHSIZE,
|
||||
buf.base, buf.sz);
|
||||
if(buf.sz > EncryptedFrameBodySize)
|
||||
return;
|
||||
memcpy(frame.data() + PUBKEYSIZE + TUNNONCESIZE + SHORTHASHSIZE, buf.base,
|
||||
buf.sz);
|
||||
user = u;
|
||||
llarp_threadpool_queue_job(worker, {this, &Encrypt});
|
||||
}
|
||||
|
@ -104,10 +104,10 @@ namespace llarp
|
|||
AsyncFrameDecrypter< User >* ctx =
|
||||
static_cast< AsyncFrameDecrypter< User >* >(user);
|
||||
|
||||
if(ctx->target->DecryptInPlace(ctx->seckey, ctx->crypto))
|
||||
if(ctx->target.DecryptInPlace(ctx->seckey, ctx->crypto))
|
||||
{
|
||||
auto buf = ctx->target->Buffer();
|
||||
buf->cur = buf->base + EncryptedFrame::OverheadSize;
|
||||
auto buf = ctx->target.Buffer();
|
||||
buf->cur = buf->base + EncryptedFrameOverheadSize;
|
||||
ctx->result(buf, ctx->context);
|
||||
}
|
||||
else
|
||||
|
@ -124,10 +124,11 @@ namespace llarp
|
|||
User* context;
|
||||
llarp::Crypto* crypto;
|
||||
const byte_t* seckey;
|
||||
EncryptedFrame* target;
|
||||
EncryptedFrame target;
|
||||
|
||||
void
|
||||
AsyncDecrypt(llarp_threadpool* worker, EncryptedFrame* frame, User* user)
|
||||
AsyncDecrypt(llarp_threadpool* worker, const EncryptedFrame& frame,
|
||||
User* user)
|
||||
{
|
||||
target = frame;
|
||||
context = user;
|
||||
|
|
|
@ -121,6 +121,12 @@ namespace llarp
|
|||
return session->GotLIM(this);
|
||||
}
|
||||
|
||||
void
|
||||
LinkIntroMessage::Clear()
|
||||
{
|
||||
rc.Clear();
|
||||
}
|
||||
|
||||
bool
|
||||
LinkIntroMessage::Sign(llarp::Crypto* c, const SecretKey& k)
|
||||
{
|
||||
|
|
|
@ -2,6 +2,7 @@
|
|||
#include <logger.hpp>
|
||||
#include <messages.hpp>
|
||||
#include <router_contact.hpp>
|
||||
#include <link_message_parser.hpp>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
|
@ -45,29 +46,29 @@ namespace llarp
|
|||
switch(*strbuf.cur)
|
||||
{
|
||||
case 'i':
|
||||
handler->msg = std::make_unique< LinkIntroMessage >(handler->from);
|
||||
handler->msg = &handler->holder.i;
|
||||
break;
|
||||
case 'd':
|
||||
handler->msg =
|
||||
std::make_unique< RelayDownstreamMessage >(handler->from);
|
||||
handler->msg = &handler->holder.d;
|
||||
break;
|
||||
case 'u':
|
||||
handler->msg =
|
||||
std::make_unique< RelayUpstreamMessage >(handler->from);
|
||||
handler->msg = &handler->holder.u;
|
||||
break;
|
||||
case 'm':
|
||||
handler->msg = std::make_unique< DHTImmeidateMessage >(handler->from);
|
||||
handler->msg = &handler->holder.m;
|
||||
break;
|
||||
case 'c':
|
||||
handler->msg = std::make_unique< LR_CommitMessage >(handler->from);
|
||||
handler->msg = &handler->holder.c;
|
||||
break;
|
||||
case 'x':
|
||||
handler->msg = std::make_unique< DiscardMessage >(handler->from);
|
||||
handler->msg = &handler->holder.x;
|
||||
break;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
handler->firstkey = false;
|
||||
handler->msg->Clear();
|
||||
handler->msg->session = handler->from;
|
||||
handler->firstkey = false;
|
||||
return true;
|
||||
}
|
||||
// check for last element
|
||||
|
@ -107,6 +108,6 @@ namespace llarp
|
|||
void
|
||||
InboundMessageParser::Reset()
|
||||
{
|
||||
msg.reset(nullptr);
|
||||
msg = nullptr;
|
||||
}
|
||||
} // namespace llarp
|
||||
|
|
|
@ -19,55 +19,22 @@ namespace llarp
|
|||
struct ILinkMessage : public IBEncodeMessage
|
||||
{
|
||||
/// who did this message come from or is going to
|
||||
ILinkSession* session;
|
||||
uint64_t version = 0;
|
||||
ILinkSession* session = nullptr;
|
||||
uint64_t version = 0;
|
||||
|
||||
ILinkMessage() : ILinkMessage(nullptr)
|
||||
{
|
||||
}
|
||||
ILinkMessage() = default;
|
||||
|
||||
ILinkMessage(ILinkSession* from) : session(from)
|
||||
{
|
||||
}
|
||||
virtual ~ILinkMessage()
|
||||
{
|
||||
}
|
||||
|
||||
virtual bool
|
||||
HandleMessage(Router* router) const = 0;
|
||||
|
||||
virtual void
|
||||
Clear() = 0;
|
||||
};
|
||||
|
||||
struct InboundMessageParser
|
||||
{
|
||||
InboundMessageParser(Router* router);
|
||||
dict_reader reader;
|
||||
|
||||
static bool
|
||||
OnKey(dict_reader* r, llarp_buffer_t* buf);
|
||||
|
||||
/// start processig message from a link session
|
||||
bool
|
||||
ProcessFrom(ILinkSession* from, llarp_buffer_t buf);
|
||||
|
||||
/// called when the message is fully read
|
||||
/// return true when the message was accepted otherwise returns false
|
||||
bool
|
||||
MessageDone();
|
||||
|
||||
/// resets internal state
|
||||
void
|
||||
Reset();
|
||||
|
||||
private:
|
||||
RouterID
|
||||
GetCurrentFrom();
|
||||
|
||||
private:
|
||||
bool firstkey;
|
||||
Router* router;
|
||||
ILinkSession* from = nullptr;
|
||||
std::unique_ptr< ILinkMessage > msg;
|
||||
};
|
||||
} // namespace llarp
|
||||
|
||||
#endif
|
||||
|
|
52
llarp/link_message_parser.hpp
Normal file
52
llarp/link_message_parser.hpp
Normal file
|
@ -0,0 +1,52 @@
|
|||
#ifndef LLARP_LINK_MESSAGE_PARSER_HPP
|
||||
#define LLARP_LINK_MESSAGE_PARSER_HPP
|
||||
#include <link_message.hpp>
|
||||
#include <messages.hpp>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
struct InboundMessageParser
|
||||
{
|
||||
InboundMessageParser(Router* router);
|
||||
dict_reader reader;
|
||||
|
||||
static bool
|
||||
OnKey(dict_reader* r, llarp_buffer_t* buf);
|
||||
|
||||
/// start processig message from a link session
|
||||
bool
|
||||
ProcessFrom(ILinkSession* from, llarp_buffer_t buf);
|
||||
|
||||
/// called when the message is fully read
|
||||
/// return true when the message was accepted otherwise returns false
|
||||
bool
|
||||
MessageDone();
|
||||
|
||||
/// resets internal state
|
||||
void
|
||||
Reset();
|
||||
|
||||
private:
|
||||
RouterID
|
||||
GetCurrentFrom();
|
||||
|
||||
private:
|
||||
bool firstkey;
|
||||
Router* router;
|
||||
ILinkSession* from = nullptr;
|
||||
ILinkMessage* msg = nullptr;
|
||||
|
||||
struct msg_holder_t
|
||||
{
|
||||
LinkIntroMessage i;
|
||||
RelayDownstreamMessage d;
|
||||
RelayUpstreamMessage u;
|
||||
DHTImmeidateMessage m;
|
||||
LR_CommitMessage c;
|
||||
DiscardMessage x;
|
||||
};
|
||||
|
||||
msg_holder_t holder;
|
||||
};
|
||||
} // namespace llarp
|
||||
#endif
|
|
@ -9,10 +9,6 @@ namespace llarp
|
|||
{
|
||||
struct DHTImmeidateMessage : public ILinkMessage
|
||||
{
|
||||
DHTImmeidateMessage(ILinkSession* parent) : ILinkMessage(parent)
|
||||
{
|
||||
}
|
||||
|
||||
DHTImmeidateMessage() : ILinkMessage()
|
||||
{
|
||||
}
|
||||
|
@ -29,6 +25,9 @@ namespace llarp
|
|||
|
||||
bool
|
||||
HandleMessage(llarp::Router* router) const;
|
||||
|
||||
void
|
||||
Clear() override;
|
||||
};
|
||||
} // namespace llarp
|
||||
|
||||
|
|
|
@ -10,17 +10,7 @@ namespace llarp
|
|||
{
|
||||
struct DiscardMessage final : public ILinkMessage
|
||||
{
|
||||
/// who did this message come from or is going to
|
||||
|
||||
DiscardMessage() : ILinkMessage(nullptr)
|
||||
{
|
||||
}
|
||||
|
||||
DiscardMessage(ILinkSession* from) : ILinkMessage(from)
|
||||
{
|
||||
}
|
||||
|
||||
~DiscardMessage()
|
||||
DiscardMessage() : ILinkMessage()
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -36,6 +26,11 @@ namespace llarp
|
|||
return bencode_end(buf);
|
||||
}
|
||||
|
||||
void
|
||||
Clear() override
|
||||
{
|
||||
}
|
||||
|
||||
bool
|
||||
DecodeKey(__attribute__((unused)) llarp_buffer_t key,
|
||||
__attribute__((unused)) llarp_buffer_t* buf) override
|
||||
|
|
|
@ -16,10 +16,6 @@ namespace llarp
|
|||
{
|
||||
}
|
||||
|
||||
LinkIntroMessage(ILinkSession* s) : ILinkMessage(s)
|
||||
{
|
||||
}
|
||||
|
||||
~LinkIntroMessage();
|
||||
|
||||
RouterContact rc;
|
||||
|
@ -44,6 +40,9 @@ namespace llarp
|
|||
|
||||
bool
|
||||
Verify(llarp::Crypto* c) const;
|
||||
|
||||
void
|
||||
Clear() override;
|
||||
};
|
||||
} // namespace llarp
|
||||
|
||||
|
|
|
@ -13,7 +13,7 @@ namespace llarp
|
|||
struct RelayUpstreamMessage : public ILinkMessage
|
||||
{
|
||||
PathID_t pathid;
|
||||
Encrypted X;
|
||||
Encrypted< MAX_LINK_MSG_SIZE - 128 > X;
|
||||
TunnelNonce Y;
|
||||
|
||||
RelayUpstreamMessage();
|
||||
|
@ -21,32 +21,38 @@ namespace llarp
|
|||
~RelayUpstreamMessage();
|
||||
|
||||
bool
|
||||
DecodeKey(llarp_buffer_t key, llarp_buffer_t* buf);
|
||||
DecodeKey(llarp_buffer_t key, llarp_buffer_t* buf) override;
|
||||
|
||||
bool
|
||||
BEncode(llarp_buffer_t* buf) const;
|
||||
BEncode(llarp_buffer_t* buf) const override;
|
||||
|
||||
bool
|
||||
HandleMessage(llarp::Router* router) const;
|
||||
HandleMessage(llarp::Router* router) const override;
|
||||
|
||||
void
|
||||
Clear() override;
|
||||
};
|
||||
|
||||
struct RelayDownstreamMessage : public ILinkMessage
|
||||
{
|
||||
PathID_t pathid;
|
||||
Encrypted X;
|
||||
Encrypted< MAX_LINK_MSG_SIZE - 128 > X;
|
||||
TunnelNonce Y;
|
||||
RelayDownstreamMessage();
|
||||
RelayDownstreamMessage(ILinkSession* from);
|
||||
~RelayDownstreamMessage();
|
||||
|
||||
bool
|
||||
DecodeKey(llarp_buffer_t key, llarp_buffer_t* buf);
|
||||
DecodeKey(llarp_buffer_t key, llarp_buffer_t* buf) override;
|
||||
|
||||
bool
|
||||
BEncode(llarp_buffer_t* buf) const;
|
||||
BEncode(llarp_buffer_t* buf) const override;
|
||||
|
||||
bool
|
||||
HandleMessage(llarp::Router* router) const;
|
||||
HandleMessage(llarp::Router* router) const override;
|
||||
|
||||
void
|
||||
Clear() override;
|
||||
};
|
||||
} // namespace llarp
|
||||
|
||||
|
|
|
@ -53,10 +53,6 @@ namespace llarp
|
|||
{
|
||||
}
|
||||
|
||||
LR_CommitMessage(ILinkSession *from) : ILinkMessage(from)
|
||||
{
|
||||
}
|
||||
|
||||
~LR_CommitMessage();
|
||||
|
||||
void
|
||||
|
|
|
@ -11,11 +11,12 @@ namespace llarp
|
|||
{
|
||||
namespace routing
|
||||
{
|
||||
constexpr size_t ExitPadSize = 512 - 48;
|
||||
constexpr size_t MaxExitMTU = 1500;
|
||||
constexpr size_t ExitPadSize = 512 - 48;
|
||||
constexpr size_t MaxExitMTU = 1500;
|
||||
constexpr size_t ExitOverhead = sizeof(uint64_t);
|
||||
struct TransferTrafficMessage final : public IMessage
|
||||
{
|
||||
std::vector< llarp::Encrypted > X;
|
||||
std::vector< llarp::Encrypted< MaxExitMTU + ExitOverhead > > X;
|
||||
size_t _size = 0;
|
||||
|
||||
size_t
|
||||
|
|
|
@ -522,7 +522,7 @@ namespace llarp
|
|||
Path::Expired(llarp_time_t now) const
|
||||
{
|
||||
if(_status == ePathEstablished)
|
||||
return now - buildStarted > hops[0].lifetime;
|
||||
return now >= ExpireTime();
|
||||
else if(_status == ePathBuilding)
|
||||
return false;
|
||||
else
|
||||
|
|
|
@ -25,7 +25,7 @@
|
|||
#define MAXHOPS (8)
|
||||
#define DEFAULT_PATH_LIFETIME (10 * 60 * 1000)
|
||||
#define PATH_BUILD_TIMEOUT (30 * 1000)
|
||||
#define MESSAGE_PAD_SIZE (512)
|
||||
#define MESSAGE_PAD_SIZE (128)
|
||||
#define PATH_ALIVE_TIMEOUT (10 * 1000)
|
||||
|
||||
namespace llarp
|
||||
|
@ -314,7 +314,7 @@ namespace llarp
|
|||
void
|
||||
MarkActive(llarp_time_t now)
|
||||
{
|
||||
m_LastRecvMessage = now;
|
||||
m_LastRecvMessage = std::max(now, m_LastRecvMessage);
|
||||
}
|
||||
|
||||
/// return true if ALL of the specified roles are supported
|
||||
|
|
|
@ -80,12 +80,13 @@ namespace llarp
|
|||
record.commkey = llarp::seckey_topublic(hop.commkey);
|
||||
|
||||
auto buf = frame.Buffer();
|
||||
buf->cur = buf->base + EncryptedFrame::OverheadSize;
|
||||
buf->cur = buf->base + EncryptedFrameOverheadSize;
|
||||
// encode record
|
||||
if(!record.BEncode(buf))
|
||||
{
|
||||
// failed to encode?
|
||||
llarp::LogError("Failed to generate Commit Record");
|
||||
llarp::DumpBuffer(*buf);
|
||||
delete ctx;
|
||||
return;
|
||||
}
|
||||
|
|
|
@ -27,6 +27,19 @@ namespace llarp
|
|||
return read;
|
||||
}
|
||||
|
||||
void
|
||||
LR_CommitMessage::Clear()
|
||||
{
|
||||
frames[0].Clear();
|
||||
frames[1].Clear();
|
||||
frames[2].Clear();
|
||||
frames[3].Clear();
|
||||
frames[4].Clear();
|
||||
frames[5].Clear();
|
||||
frames[6].Clear();
|
||||
frames[7].Clear();
|
||||
}
|
||||
|
||||
bool
|
||||
LR_CommitMessage::BEncode(llarp_buffer_t* buf) const
|
||||
{
|
||||
|
@ -235,7 +248,7 @@ namespace llarp
|
|||
delete self;
|
||||
return;
|
||||
}
|
||||
buf->cur = buf->base + EncryptedFrame::OverheadSize;
|
||||
buf->cur = buf->base + EncryptedFrameOverheadSize;
|
||||
llarp::LogDebug("decrypted LRCM from ", info.downstream);
|
||||
// successful decrypt
|
||||
if(!self->record.BDecode(buf))
|
||||
|
@ -295,7 +308,7 @@ namespace llarp
|
|||
frames[5] = self->frames[6];
|
||||
frames[6] = self->frames[7];
|
||||
// put our response on the end
|
||||
frames[7] = EncryptedFrame(sz - EncryptedFrame::OverheadSize);
|
||||
frames[7] = EncryptedFrame(sz - EncryptedFrameOverheadSize);
|
||||
// random junk for now
|
||||
frames[7].Randomize();
|
||||
self->frames = std::move(frames);
|
||||
|
@ -325,7 +338,7 @@ namespace llarp
|
|||
LRCMFrameDecrypt* frames = new LRCMFrameDecrypt(context, decrypter, this);
|
||||
|
||||
// decrypt frames async
|
||||
decrypter->AsyncDecrypt(context->Worker(), &frames->frames[0], frames);
|
||||
decrypter->AsyncDecrypt(context->Worker(), frames->frames[0], frames);
|
||||
return true;
|
||||
}
|
||||
} // namespace llarp
|
||||
|
|
|
@ -4,11 +4,6 @@
|
|||
|
||||
namespace llarp
|
||||
{
|
||||
RelayUpstreamMessage::RelayUpstreamMessage(ILinkSession *from)
|
||||
: ILinkMessage(from)
|
||||
{
|
||||
}
|
||||
|
||||
RelayUpstreamMessage::RelayUpstreamMessage() : ILinkMessage()
|
||||
{
|
||||
}
|
||||
|
@ -17,6 +12,12 @@ namespace llarp
|
|||
{
|
||||
}
|
||||
|
||||
void
|
||||
RelayUpstreamMessage::Clear()
|
||||
{
|
||||
X.Clear();
|
||||
}
|
||||
|
||||
bool
|
||||
RelayUpstreamMessage::BEncode(llarp_buffer_t *buf) const
|
||||
{
|
||||
|
@ -63,11 +64,6 @@ namespace llarp
|
|||
return false;
|
||||
}
|
||||
|
||||
RelayDownstreamMessage::RelayDownstreamMessage(ILinkSession *from)
|
||||
: ILinkMessage(from)
|
||||
{
|
||||
}
|
||||
|
||||
RelayDownstreamMessage::RelayDownstreamMessage() : ILinkMessage()
|
||||
{
|
||||
}
|
||||
|
@ -75,6 +71,13 @@ namespace llarp
|
|||
RelayDownstreamMessage::~RelayDownstreamMessage()
|
||||
{
|
||||
}
|
||||
|
||||
void
|
||||
RelayDownstreamMessage::Clear()
|
||||
{
|
||||
X.Clear();
|
||||
}
|
||||
|
||||
bool
|
||||
RelayDownstreamMessage::BEncode(llarp_buffer_t *buf) const
|
||||
{
|
||||
|
|
|
@ -12,7 +12,7 @@
|
|||
#include <fs.hpp>
|
||||
#include <handlers/tun.hpp>
|
||||
#include <link_layer.hpp>
|
||||
#include <link_message.hpp>
|
||||
#include <link_message_parser.hpp>
|
||||
#include <logic.hpp>
|
||||
#include <mem.hpp>
|
||||
#include <nodedb.hpp>
|
||||
|
|
|
@ -163,8 +163,8 @@ namespace llarp
|
|||
{
|
||||
router->lokinetRouters.clear();
|
||||
for(const auto& pk : list)
|
||||
router->lokinetRouters.insert(
|
||||
std::make_pair(pk, std::numeric_limits< llarp_time_t >::max()));
|
||||
router->lokinetRouters.insert(std::make_pair(
|
||||
pk.data(), std::numeric_limits< llarp_time_t >::max()));
|
||||
llarp::LogInfo("updated service node list, we have ",
|
||||
router->lokinetRouters.size(), " authorized routers");
|
||||
}
|
||||
|
@ -225,7 +225,7 @@ namespace llarp
|
|||
peer.SetObject();
|
||||
abyss::json::Value ident_val, addr_val;
|
||||
|
||||
auto ident = session->GetPubKey().ToHex();
|
||||
auto ident = RouterID(session->GetPubKey()).ToString();
|
||||
ident_val.SetString(ident.c_str(), alloc);
|
||||
|
||||
auto addr = session->GetRemoteEndpoint().ToString();
|
||||
|
|
|
@ -157,8 +157,8 @@ namespace llarp
|
|||
const byte_t* sharedkey,
|
||||
ProtocolMessage& msg) const
|
||||
{
|
||||
Encrypted tmp = D;
|
||||
auto buf = tmp.Buffer();
|
||||
Encrypted_t tmp = D;
|
||||
auto buf = tmp.Buffer();
|
||||
crypto->xchacha20(*buf, sharedkey, N);
|
||||
return msg.BDecode(buf);
|
||||
}
|
||||
|
|
|
@ -59,8 +59,9 @@ namespace llarp
|
|||
/// outer message
|
||||
struct ProtocolFrame final : public llarp::routing::IMessage
|
||||
{
|
||||
using Encrypted_t = llarp::Encrypted< 2048 >;
|
||||
llarp::PQCipherBlock C;
|
||||
llarp::Encrypted D;
|
||||
Encrypted_t D;
|
||||
llarp::KeyExchangeNonce N;
|
||||
llarp::Signature Z;
|
||||
llarp::service::ConvoTag T;
|
||||
|
|
|
@ -11,11 +11,10 @@ using LRCR = llarp::LR_CommitRecord;
|
|||
class FrameTest : public ::testing::Test
|
||||
{
|
||||
public:
|
||||
llarp::Crypto crypto;
|
||||
llarp::Crypto crypto;
|
||||
SecretKey alice, bob;
|
||||
|
||||
FrameTest()
|
||||
: crypto(llarp::Crypto::sodium{})
|
||||
FrameTest() : crypto(llarp::Crypto::sodium{})
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -47,12 +46,12 @@ TEST_F(FrameTest, TestFrameCrypto)
|
|||
record.txid.Fill(4);
|
||||
|
||||
auto buf = f.Buffer();
|
||||
buf->cur = buf->base + EncryptedFrame::OverheadSize;
|
||||
buf->cur = buf->base + llarp::EncryptedFrameOverheadSize;
|
||||
|
||||
ASSERT_TRUE(record.BEncode(buf));
|
||||
|
||||
// rewind buffer
|
||||
buf->cur = buf->base + EncryptedFrame::OverheadSize;
|
||||
buf->cur = buf->base + llarp::EncryptedFrameOverheadSize;
|
||||
// encrypt to alice
|
||||
ASSERT_TRUE(f.EncryptInPlace(alice, llarp::seckey_topublic(bob), &crypto));
|
||||
// decrypt from alice
|
||||
|
|
|
@ -6,7 +6,7 @@
|
|||
|
||||
struct AbyssTestBase : public ::testing::Test
|
||||
{
|
||||
llarp::Crypto crypto;
|
||||
llarp::Crypto crypto;
|
||||
llarp_threadpool* threadpool = nullptr;
|
||||
llarp_ev_loop* loop = nullptr;
|
||||
llarp::Logic* logic = nullptr;
|
||||
|
@ -15,6 +15,10 @@ struct AbyssTestBase : public ::testing::Test
|
|||
const std::string method = "test.method";
|
||||
bool called = false;
|
||||
|
||||
AbyssTestBase() : crypto(llarp::Crypto::sodium{})
|
||||
{
|
||||
}
|
||||
|
||||
void
|
||||
AssertMethod(const std::string& meth) const
|
||||
{
|
||||
|
@ -25,7 +29,6 @@ struct AbyssTestBase : public ::testing::Test
|
|||
SetUp()
|
||||
{
|
||||
// for llarp::randint
|
||||
llarp_crypto_init(&crypto);
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -41,7 +44,7 @@ struct AbyssTestBase : public ::testing::Test
|
|||
{
|
||||
threadpool = llarp_init_same_process_threadpool();
|
||||
llarp_ev_loop_alloc(&loop);
|
||||
logic = llarp_init_single_process_logic(threadpool);
|
||||
logic = new llarp::Logic(threadpool);
|
||||
|
||||
sockaddr_in addr;
|
||||
addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
|
||||
|
@ -75,7 +78,8 @@ struct AbyssTestBase : public ::testing::Test
|
|||
{
|
||||
if(loop && threadpool && logic)
|
||||
{
|
||||
llarp_free_logic(&logic);
|
||||
delete logic;
|
||||
logic = nullptr;
|
||||
llarp_ev_loop_free(&loop);
|
||||
llarp_free_threadpool(&threadpool);
|
||||
}
|
||||
|
|
Loading…
Reference in a new issue