|
|
|
|
@ -8,15 +8,24 @@ namespace llarp
|
|
|
|
|
{
|
|
|
|
|
namespace iwp
|
|
|
|
|
{
|
|
|
|
|
static constexpr size_t PacketOverhead = HMACSIZE + TUNNONCESIZE;
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
AddRandomPadding(std::vector< byte_t >& pkt, size_t min, size_t variance)
|
|
|
|
|
ILinkSession::Packet_t
|
|
|
|
|
CreatePacket(Command cmd, size_t plainsize, size_t minpad, size_t variance)
|
|
|
|
|
{
|
|
|
|
|
const auto sz = pkt.size();
|
|
|
|
|
const size_t randpad = min + randint() % variance;
|
|
|
|
|
pkt.resize(sz + randpad);
|
|
|
|
|
CryptoManager::instance()->randbytes(pkt.data() + sz, randpad);
|
|
|
|
|
const size_t pad =
|
|
|
|
|
minpad > 0 ? minpad + (variance > 0 ? randint() % variance : 0) : 0;
|
|
|
|
|
ILinkSession::Packet_t pkt(PacketOverhead + plainsize + pad
|
|
|
|
|
+ CommandOverhead);
|
|
|
|
|
// randomize pad
|
|
|
|
|
if(pad)
|
|
|
|
|
{
|
|
|
|
|
CryptoManager::instance()->randbytes(
|
|
|
|
|
pkt.data() + PacketOverhead + CommandOverhead + plainsize, pad);
|
|
|
|
|
}
|
|
|
|
|
// randomize nounce
|
|
|
|
|
CryptoManager::instance()->randbytes(pkt.data() + HMACSIZE, TUNNONCESIZE);
|
|
|
|
|
pkt[PacketOverhead] = LLARP_PROTO_VERSION;
|
|
|
|
|
pkt[PacketOverhead + 1] = cmd;
|
|
|
|
|
return pkt;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Session::Session(LinkLayer* p, RouterContact rc, AddressInfo ai)
|
|
|
|
|
@ -30,6 +39,8 @@ namespace llarp
|
|
|
|
|
{
|
|
|
|
|
token.Zero();
|
|
|
|
|
GotLIM = util::memFn(&Session::GotOutboundLIM, this);
|
|
|
|
|
CryptoManager::instance()->shorthash(m_SessionKey,
|
|
|
|
|
llarp_buffer_t(rc.pubkey));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Session::Session(LinkLayer* p, Addr from)
|
|
|
|
|
@ -40,7 +51,9 @@ namespace llarp
|
|
|
|
|
, m_RemoteAddr{from}
|
|
|
|
|
{
|
|
|
|
|
token.Randomize();
|
|
|
|
|
GotLIM = util::memFn(&Session::GotInboundLIM, this);
|
|
|
|
|
GotLIM = util::memFn(&Session::GotInboundLIM, this);
|
|
|
|
|
const PubKey pk = m_Parent->GetOurRC().pubkey;
|
|
|
|
|
CryptoManager::instance()->shorthash(m_SessionKey, llarp_buffer_t(pk));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
@ -54,9 +67,10 @@ namespace llarp
|
|
|
|
|
bool
|
|
|
|
|
Session::GotInboundLIM(const LinkIntroMessage* msg)
|
|
|
|
|
{
|
|
|
|
|
if(msg->rc.enckey != m_RemoteOnionKey)
|
|
|
|
|
if(msg->rc.pubkey != m_ExpectedIdent)
|
|
|
|
|
{
|
|
|
|
|
LogError("key missmatch");
|
|
|
|
|
LogError("ident key missmatch from ", m_RemoteAddr, " ", msg->rc.pubkey,
|
|
|
|
|
" != ", m_ExpectedIdent);
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
m_State = State::Ready;
|
|
|
|
|
@ -100,15 +114,13 @@ namespace llarp
|
|
|
|
|
LogError("failed to sign our RC for ", m_RemoteAddr);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
AlignedBuffer< LinkIntroMessage::MaxSize > data;
|
|
|
|
|
ILinkSession::Message_t data(LinkIntroMessage::MaxSize + PacketOverhead);
|
|
|
|
|
llarp_buffer_t buf(data);
|
|
|
|
|
if(not msg.BEncode(&buf))
|
|
|
|
|
{
|
|
|
|
|
LogError("failed to encode LIM for ", m_RemoteAddr);
|
|
|
|
|
}
|
|
|
|
|
buf.sz = buf.cur - buf.base;
|
|
|
|
|
buf.cur = buf.base;
|
|
|
|
|
if(!SendMessageBuffer(buf, h))
|
|
|
|
|
if(!SendMessageBuffer(std::move(data), h))
|
|
|
|
|
{
|
|
|
|
|
LogError("failed to send LIM to ", m_RemoteAddr);
|
|
|
|
|
}
|
|
|
|
|
@ -116,28 +128,38 @@ namespace llarp
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
Session::EncryptAndSend(const llarp_buffer_t& data)
|
|
|
|
|
Session::EncryptAndSend(ILinkSession::Packet_t data)
|
|
|
|
|
{
|
|
|
|
|
std::vector< byte_t > pkt;
|
|
|
|
|
pkt.resize(data.sz + PacketOverhead);
|
|
|
|
|
CryptoManager::instance()->randbytes(pkt.data(), pkt.size());
|
|
|
|
|
llarp_buffer_t pktbuf(pkt);
|
|
|
|
|
pktbuf.base += PacketOverhead;
|
|
|
|
|
pktbuf.cur = pktbuf.base;
|
|
|
|
|
pktbuf.sz -= PacketOverhead;
|
|
|
|
|
byte_t* nonce_ptr = pkt.data() + HMACSIZE;
|
|
|
|
|
|
|
|
|
|
CryptoManager::instance()->xchacha20_alt(pktbuf, data, m_SessionKey,
|
|
|
|
|
nonce_ptr);
|
|
|
|
|
|
|
|
|
|
pktbuf.base = nonce_ptr;
|
|
|
|
|
pktbuf.sz = data.sz + 32;
|
|
|
|
|
CryptoManager::instance()->hmac(pkt.data(), pktbuf, m_SessionKey);
|
|
|
|
|
if(m_EncryptNext == nullptr)
|
|
|
|
|
m_EncryptNext = std::make_shared< CryptoQueue_t >();
|
|
|
|
|
m_EncryptNext->emplace_back(std::move(data));
|
|
|
|
|
if(!IsEstablished())
|
|
|
|
|
{
|
|
|
|
|
EncryptWorker(std::move(m_EncryptNext));
|
|
|
|
|
m_EncryptNext = nullptr;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pktbuf.base = pkt.data();
|
|
|
|
|
pktbuf.cur = pkt.data();
|
|
|
|
|
pktbuf.sz = pkt.size();
|
|
|
|
|
Send_LL(pktbuf);
|
|
|
|
|
void
|
|
|
|
|
Session::EncryptWorker(CryptoQueue_ptr msgs)
|
|
|
|
|
{
|
|
|
|
|
LogDebug("encrypt worker ", msgs->size(), " messages");
|
|
|
|
|
for(auto& pkt : *msgs)
|
|
|
|
|
{
|
|
|
|
|
llarp_buffer_t pktbuf(pkt);
|
|
|
|
|
const TunnelNonce nonce_ptr{pkt.data() + HMACSIZE};
|
|
|
|
|
pktbuf.base += PacketOverhead;
|
|
|
|
|
pktbuf.cur = pktbuf.base;
|
|
|
|
|
pktbuf.sz -= PacketOverhead;
|
|
|
|
|
CryptoManager::instance()->xchacha20(pktbuf, m_SessionKey, nonce_ptr);
|
|
|
|
|
pktbuf.base = pkt.data() + HMACSIZE;
|
|
|
|
|
pktbuf.sz = pkt.size() - HMACSIZE;
|
|
|
|
|
CryptoManager::instance()->hmac(pkt.data(), pktbuf, m_SessionKey);
|
|
|
|
|
pktbuf.base = pkt.data();
|
|
|
|
|
pktbuf.cur = pkt.data();
|
|
|
|
|
pktbuf.sz = pkt.size();
|
|
|
|
|
Send_LL(pktbuf);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
@ -145,10 +167,8 @@ namespace llarp
|
|
|
|
|
{
|
|
|
|
|
if(m_State == State::Closed)
|
|
|
|
|
return;
|
|
|
|
|
std::vector< byte_t > close_msg = {LLARP_PROTO_VERSION, Command::eCLOS};
|
|
|
|
|
AddRandomPadding(close_msg);
|
|
|
|
|
const llarp_buffer_t buf(close_msg);
|
|
|
|
|
EncryptAndSend(buf);
|
|
|
|
|
auto close_msg = CreatePacket(Command::eCLOS, 0, 16, 16);
|
|
|
|
|
EncryptAndSend(std::move(close_msg));
|
|
|
|
|
if(m_State == State::Ready)
|
|
|
|
|
m_Parent->UnmapAddr(m_RemoteAddr);
|
|
|
|
|
m_State = State::Closed;
|
|
|
|
|
@ -156,23 +176,51 @@ namespace llarp
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool
|
|
|
|
|
Session::SendMessageBuffer(const llarp_buffer_t& buf,
|
|
|
|
|
Session::SendMessageBuffer(ILinkSession::Message_t buf,
|
|
|
|
|
ILinkSession::CompletionHandler completed)
|
|
|
|
|
{
|
|
|
|
|
if(m_TXMsgs.size() >= MaxSendQueueSize)
|
|
|
|
|
return false;
|
|
|
|
|
const auto now = m_Parent->Now();
|
|
|
|
|
const auto msgid = m_TXID++;
|
|
|
|
|
auto& msg =
|
|
|
|
|
m_TXMsgs.emplace(msgid, OutboundMessage{msgid, buf, now, completed})
|
|
|
|
|
m_TXMsgs
|
|
|
|
|
.emplace(msgid,
|
|
|
|
|
OutboundMessage{msgid, std::move(buf), now, completed})
|
|
|
|
|
.first->second;
|
|
|
|
|
auto xmit = msg.XMIT();
|
|
|
|
|
AddRandomPadding(xmit);
|
|
|
|
|
const llarp_buffer_t pkt(xmit);
|
|
|
|
|
EncryptAndSend(pkt);
|
|
|
|
|
EncryptAndSend(msg.XMIT());
|
|
|
|
|
msg.FlushUnAcked(util::memFn(&Session::EncryptAndSend, this), now);
|
|
|
|
|
LogDebug("send message ", msgid);
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
Session::SendMACK()
|
|
|
|
|
{
|
|
|
|
|
// send multi acks
|
|
|
|
|
while(m_SendMACKs.size() > 0)
|
|
|
|
|
{
|
|
|
|
|
const auto sz = m_SendMACKs.size();
|
|
|
|
|
const auto max = Session::MaxACKSInMACK;
|
|
|
|
|
auto numAcks = std::min(sz, max);
|
|
|
|
|
auto mack =
|
|
|
|
|
CreatePacket(Command::eMACK, 1 + (numAcks * sizeof(uint64_t)));
|
|
|
|
|
mack[PacketOverhead + CommandOverhead] =
|
|
|
|
|
byte_t{static_cast< byte_t >(numAcks)};
|
|
|
|
|
byte_t* ptr = mack.data() + 3 + PacketOverhead;
|
|
|
|
|
LogDebug("send ", numAcks, " macks to ", m_RemoteAddr);
|
|
|
|
|
auto itr = m_SendMACKs.begin();
|
|
|
|
|
while(numAcks > 0)
|
|
|
|
|
{
|
|
|
|
|
htobe64buf(ptr, *itr);
|
|
|
|
|
itr = m_SendMACKs.erase(itr);
|
|
|
|
|
numAcks--;
|
|
|
|
|
ptr += sizeof(uint64_t);
|
|
|
|
|
}
|
|
|
|
|
EncryptAndSend(std::move(mack));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
Session::Pump()
|
|
|
|
|
{
|
|
|
|
|
@ -198,6 +246,22 @@ namespace llarp
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
auto self = shared_from_this();
|
|
|
|
|
if(m_EncryptNext && !m_EncryptNext->empty())
|
|
|
|
|
{
|
|
|
|
|
m_Parent->QueueWork([self, data = std::move(m_EncryptNext)] {
|
|
|
|
|
self->EncryptWorker(data);
|
|
|
|
|
});
|
|
|
|
|
m_EncryptNext = nullptr;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(m_DecryptNext && !m_DecryptNext->empty())
|
|
|
|
|
{
|
|
|
|
|
m_Parent->QueueWork([self, data = std::move(m_DecryptNext)] {
|
|
|
|
|
self->DecryptWorker(data);
|
|
|
|
|
});
|
|
|
|
|
m_DecryptNext = nullptr;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool
|
|
|
|
|
@ -267,6 +331,7 @@ namespace llarp
|
|
|
|
|
{
|
|
|
|
|
if(itr->second.IsTimedOut(now))
|
|
|
|
|
{
|
|
|
|
|
m_ReplayFilter.emplace(itr->first, now);
|
|
|
|
|
itr = m_RXMsgs.erase(itr);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
@ -288,15 +353,33 @@ namespace llarp
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
using Introduction = AlignedBuffer< 64 >;
|
|
|
|
|
using Introduction = AlignedBuffer< PubKey::SIZE + PubKey::SIZE
|
|
|
|
|
+ TunnelNonce::SIZE + Signature::SIZE >;
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
Session::GenerateAndSendIntro()
|
|
|
|
|
{
|
|
|
|
|
Introduction intro;
|
|
|
|
|
|
|
|
|
|
TunnelNonce N;
|
|
|
|
|
N.Randomize();
|
|
|
|
|
ILinkSession::Packet_t req(Introduction::SIZE + PacketOverhead);
|
|
|
|
|
const auto pk = m_Parent->GetOurRC().pubkey;
|
|
|
|
|
const auto e_pk = m_Parent->RouterEncryptionSecret().toPublic();
|
|
|
|
|
auto itr = req.data() + PacketOverhead;
|
|
|
|
|
std::copy_n(pk.begin(), pk.size(), itr);
|
|
|
|
|
itr += pk.size();
|
|
|
|
|
std::copy_n(e_pk.begin(), e_pk.size(), itr);
|
|
|
|
|
itr += e_pk.size();
|
|
|
|
|
std::copy(N.begin(), N.end(), itr);
|
|
|
|
|
Signature Z;
|
|
|
|
|
llarp_buffer_t signbuf(req.data() + PacketOverhead,
|
|
|
|
|
Introduction::SIZE - Signature::SIZE);
|
|
|
|
|
m_Parent->Sign(Z, signbuf);
|
|
|
|
|
std::copy_n(
|
|
|
|
|
Z.begin(), Z.size(),
|
|
|
|
|
req.data() + PacketOverhead + (Introduction::SIZE - Signature::SIZE));
|
|
|
|
|
CryptoManager::instance()->randbytes(req.data() + HMACSIZE, TUNNONCESIZE);
|
|
|
|
|
EncryptAndSend(std::move(req));
|
|
|
|
|
m_State = State::Introduction;
|
|
|
|
|
if(not CryptoManager::instance()->transport_dh_client(
|
|
|
|
|
m_SessionKey, m_ChosenAI.pubkey,
|
|
|
|
|
m_Parent->RouterEncryptionSecret(), N))
|
|
|
|
|
@ -305,37 +388,25 @@ namespace llarp
|
|
|
|
|
m_RemoteAddr);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
const auto pk = m_Parent->RouterEncryptionSecret().toPublic();
|
|
|
|
|
std::copy_n(pk.begin(), pk.size(), intro.begin());
|
|
|
|
|
std::copy(N.begin(), N.end(), intro.begin() + PubKey::SIZE);
|
|
|
|
|
LogDebug("pk=", pk.ToHex(), " N=", N.ToHex(),
|
|
|
|
|
" remote-pk=", m_ChosenAI.pubkey.ToHex());
|
|
|
|
|
std::vector< byte_t > req;
|
|
|
|
|
std::copy_n(intro.begin(), intro.size(), std::back_inserter(req));
|
|
|
|
|
AddRandomPadding(req);
|
|
|
|
|
const llarp_buffer_t buf(req);
|
|
|
|
|
Send_LL(buf);
|
|
|
|
|
m_State = State::Introduction;
|
|
|
|
|
LogDebug("sent intro to ", m_RemoteAddr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
Session::HandleCreateSessionRequest(const llarp_buffer_t& buf)
|
|
|
|
|
Session::HandleCreateSessionRequest(Packet_t pkt)
|
|
|
|
|
{
|
|
|
|
|
std::vector< byte_t > result;
|
|
|
|
|
if(not DecryptMessage(buf, result))
|
|
|
|
|
if(not DecryptMessageInPlace(pkt))
|
|
|
|
|
{
|
|
|
|
|
LogError("failed to decrypt session request from ", m_RemoteAddr);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if(result.size() < token.size())
|
|
|
|
|
if(pkt.size() < token.size() + PacketOverhead)
|
|
|
|
|
{
|
|
|
|
|
LogError("bad session request size, ", result.size(), " < ",
|
|
|
|
|
token.size(), " from ", m_RemoteAddr);
|
|
|
|
|
LogError("bad session request size, ", pkt.size(), " < ",
|
|
|
|
|
token.size() + PacketOverhead, " from ", m_RemoteAddr);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if(not std::equal(result.begin(), result.begin() + token.size(),
|
|
|
|
|
token.begin()))
|
|
|
|
|
const auto begin = pkt.data() + PacketOverhead;
|
|
|
|
|
if(not std::equal(begin, begin + token.size(), token.begin()))
|
|
|
|
|
{
|
|
|
|
|
LogError("token missmatch from ", m_RemoteAddr);
|
|
|
|
|
return;
|
|
|
|
|
@ -346,19 +417,33 @@ namespace llarp
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
Session::HandleGotIntro(const llarp_buffer_t& buf)
|
|
|
|
|
Session::HandleGotIntro(Packet_t pkt)
|
|
|
|
|
{
|
|
|
|
|
if(buf.sz < Introduction::SIZE)
|
|
|
|
|
if(pkt.size() < Introduction::SIZE + PacketOverhead)
|
|
|
|
|
{
|
|
|
|
|
LogWarn("intro too small from ", m_RemoteAddr);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
byte_t* ptr = pkt.data() + PacketOverhead;
|
|
|
|
|
TunnelNonce N;
|
|
|
|
|
std::copy_n(buf.base, PubKey::SIZE, m_RemoteOnionKey.begin());
|
|
|
|
|
std::copy_n(buf.base + PubKey::SIZE, TunnelNonce::SIZE, N.begin());
|
|
|
|
|
std::copy_n(ptr, PubKey::SIZE, m_ExpectedIdent.begin());
|
|
|
|
|
ptr += PubKey::SIZE;
|
|
|
|
|
std::copy_n(ptr, PubKey::SIZE, m_RemoteOnionKey.begin());
|
|
|
|
|
ptr += PubKey::SIZE;
|
|
|
|
|
std::copy_n(ptr, TunnelNonce::SIZE, N.begin());
|
|
|
|
|
ptr += TunnelNonce::SIZE;
|
|
|
|
|
Signature Z;
|
|
|
|
|
std::copy_n(ptr, Z.size(), Z.begin());
|
|
|
|
|
const llarp_buffer_t verifybuf(pkt.data() + PacketOverhead,
|
|
|
|
|
Introduction::SIZE - Signature::SIZE);
|
|
|
|
|
if(!CryptoManager::instance()->verify(m_ExpectedIdent, verifybuf, Z))
|
|
|
|
|
{
|
|
|
|
|
LogError("intro verify failed from ", m_RemoteAddr);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
const PubKey pk = m_Parent->TransportSecretKey().toPublic();
|
|
|
|
|
LogDebug("got intro: remote-pk=", m_RemoteOnionKey.ToHex(),
|
|
|
|
|
" N=", N.ToHex(), " local-pk=", pk.ToHex(), " sz=", buf.sz);
|
|
|
|
|
" N=", N.ToHex(), " local-pk=", pk.ToHex());
|
|
|
|
|
if(not CryptoManager::instance()->transport_dh_server(
|
|
|
|
|
m_SessionKey, m_RemoteOnionKey, m_Parent->TransportSecretKey(), N))
|
|
|
|
|
{
|
|
|
|
|
@ -366,48 +451,53 @@ namespace llarp
|
|
|
|
|
m_RemoteAddr);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
std::vector< byte_t > reply;
|
|
|
|
|
std::copy_n(token.begin(), token.size(), std::back_inserter(reply));
|
|
|
|
|
AddRandomPadding(reply);
|
|
|
|
|
const llarp_buffer_t pkt(reply);
|
|
|
|
|
Packet_t reply(token.size() + PacketOverhead);
|
|
|
|
|
// random nonce
|
|
|
|
|
CryptoManager::instance()->randbytes(reply.data() + HMACSIZE,
|
|
|
|
|
TUNNONCESIZE);
|
|
|
|
|
// set token
|
|
|
|
|
std::copy_n(token.begin(), token.size(), reply.data() + PacketOverhead);
|
|
|
|
|
m_LastRX = m_Parent->Now();
|
|
|
|
|
EncryptAndSend(pkt);
|
|
|
|
|
EncryptAndSend(std::move(reply));
|
|
|
|
|
LogDebug("sent intro ack to ", m_RemoteAddr);
|
|
|
|
|
m_State = State::Introduction;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
Session::HandleGotIntroAck(const llarp_buffer_t& buf)
|
|
|
|
|
Session::HandleGotIntroAck(Packet_t pkt)
|
|
|
|
|
{
|
|
|
|
|
std::vector< byte_t > reply;
|
|
|
|
|
if(not DecryptMessage(buf, reply))
|
|
|
|
|
if(pkt.size() < token.size() + PacketOverhead)
|
|
|
|
|
{
|
|
|
|
|
LogError("intro ack decrypt failed from ", m_RemoteAddr);
|
|
|
|
|
LogError("bad intro ack size ", pkt.size(), " < ",
|
|
|
|
|
token.size() + PacketOverhead, " from ", m_RemoteAddr);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if(reply.size() < token.size())
|
|
|
|
|
Packet_t reply(token.size() + PacketOverhead);
|
|
|
|
|
if(not DecryptMessageInPlace(pkt))
|
|
|
|
|
{
|
|
|
|
|
LogError("bad intro ack size ", reply.size(), " < ", token.size(),
|
|
|
|
|
" from ", m_RemoteAddr);
|
|
|
|
|
LogError("intro ack decrypt failed from ", m_RemoteAddr);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
m_LastRX = m_Parent->Now();
|
|
|
|
|
std::copy_n(reply.begin(), token.size(), token.begin());
|
|
|
|
|
const llarp_buffer_t pkt(token);
|
|
|
|
|
EncryptAndSend(pkt);
|
|
|
|
|
std::copy_n(pkt.data() + PacketOverhead, token.size(), token.begin());
|
|
|
|
|
std::copy_n(token.begin(), token.size(), reply.data() + PacketOverhead);
|
|
|
|
|
// random nounce
|
|
|
|
|
CryptoManager::instance()->randbytes(reply.data() + HMACSIZE,
|
|
|
|
|
TUNNONCESIZE);
|
|
|
|
|
EncryptAndSend(std::move(reply));
|
|
|
|
|
LogDebug("sent session request to ", m_RemoteAddr);
|
|
|
|
|
m_State = State::LinkIntro;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool
|
|
|
|
|
Session::DecryptMessage(const llarp_buffer_t& buf,
|
|
|
|
|
std::vector< byte_t >& result)
|
|
|
|
|
Session::DecryptMessageInPlace(Packet_t& pkt)
|
|
|
|
|
{
|
|
|
|
|
if(buf.sz <= PacketOverhead)
|
|
|
|
|
if(pkt.size() <= PacketOverhead)
|
|
|
|
|
{
|
|
|
|
|
LogError("packet too small ", buf.sz);
|
|
|
|
|
LogError("packet too small from ", m_RemoteAddr);
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
const llarp_buffer_t buf(pkt);
|
|
|
|
|
ShortHash H;
|
|
|
|
|
llarp_buffer_t curbuf(buf.base, buf.sz);
|
|
|
|
|
curbuf.base += ShortHash::SIZE;
|
|
|
|
|
@ -424,14 +514,11 @@ namespace llarp
|
|
|
|
|
m_RemoteAddr, " state=", int(m_State), " size=", buf.sz);
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
const byte_t* nonce_ptr = curbuf.base;
|
|
|
|
|
const TunnelNonce N{curbuf.base};
|
|
|
|
|
curbuf.base += 32;
|
|
|
|
|
curbuf.sz -= 32;
|
|
|
|
|
result.resize(buf.sz - PacketOverhead);
|
|
|
|
|
const llarp_buffer_t outbuf(result);
|
|
|
|
|
LogDebug("decrypt: ", result.size(), " bytes from ", m_RemoteAddr);
|
|
|
|
|
return CryptoManager::instance()->xchacha20_alt(outbuf, curbuf,
|
|
|
|
|
m_SessionKey, nonce_ptr);
|
|
|
|
|
LogDebug("decrypt: ", curbuf.sz, " bytes from ", m_RemoteAddr);
|
|
|
|
|
return CryptoManager::instance()->xchacha20(curbuf, m_SessionKey, N);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
@ -443,77 +530,143 @@ namespace llarp
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
Session::HandleSessionData(const llarp_buffer_t& buf)
|
|
|
|
|
Session::HandleSessionData(Packet_t pkt)
|
|
|
|
|
{
|
|
|
|
|
if(m_DecryptNext == nullptr)
|
|
|
|
|
m_DecryptNext = std::make_shared< CryptoQueue_t >();
|
|
|
|
|
m_DecryptNext->emplace_back(std::move(pkt));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
Session::DecryptWorker(CryptoQueue_ptr msgs)
|
|
|
|
|
{
|
|
|
|
|
CryptoQueue_ptr recvMsgs = std::make_shared< CryptoQueue_t >();
|
|
|
|
|
for(auto& pkt : *msgs)
|
|
|
|
|
{
|
|
|
|
|
if(not DecryptMessageInPlace(pkt))
|
|
|
|
|
{
|
|
|
|
|
LogError("failed to decrypt session data from ", m_RemoteAddr);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if(pkt[PacketOverhead] != LLARP_PROTO_VERSION)
|
|
|
|
|
{
|
|
|
|
|
LogError("protocol version missmatch ", int(pkt[PacketOverhead]),
|
|
|
|
|
" != ", LLARP_PROTO_VERSION);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
recvMsgs->emplace_back(std::move(pkt));
|
|
|
|
|
}
|
|
|
|
|
LogDebug("decrypted ", recvMsgs->size(), " packets from ", m_RemoteAddr);
|
|
|
|
|
m_Parent->logic()->queue_func(
|
|
|
|
|
std::bind(&Session::HandlePlaintext, shared_from_this(), recvMsgs));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
Session::HandlePlaintext(CryptoQueue_ptr msgs)
|
|
|
|
|
{
|
|
|
|
|
std::vector< byte_t > result;
|
|
|
|
|
if(not DecryptMessage(buf, result))
|
|
|
|
|
for(auto& result : *msgs)
|
|
|
|
|
{
|
|
|
|
|
LogError("failed to decrypt session data from ", m_RemoteAddr);
|
|
|
|
|
LogDebug("Command ", int(result[PacketOverhead + 1]));
|
|
|
|
|
switch(result[PacketOverhead + 1])
|
|
|
|
|
{
|
|
|
|
|
case Command::eXMIT:
|
|
|
|
|
HandleXMIT(std::move(result));
|
|
|
|
|
break;
|
|
|
|
|
case Command::eDATA:
|
|
|
|
|
HandleDATA(std::move(result));
|
|
|
|
|
break;
|
|
|
|
|
case Command::eACKS:
|
|
|
|
|
HandleACKS(std::move(result));
|
|
|
|
|
break;
|
|
|
|
|
case Command::ePING:
|
|
|
|
|
HandlePING(std::move(result));
|
|
|
|
|
break;
|
|
|
|
|
case Command::eNACK:
|
|
|
|
|
HandleNACK(std::move(result));
|
|
|
|
|
break;
|
|
|
|
|
case Command::eCLOS:
|
|
|
|
|
HandleCLOS(std::move(result));
|
|
|
|
|
break;
|
|
|
|
|
case Command::eMACK:
|
|
|
|
|
HandleMACK(std::move(result));
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
LogError("invalid command ", int(result[PacketOverhead + 1]),
|
|
|
|
|
" from ", m_RemoteAddr);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
SendMACK();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
Session::HandleMACK(Packet_t data)
|
|
|
|
|
{
|
|
|
|
|
if(data.size() < 3 + PacketOverhead)
|
|
|
|
|
{
|
|
|
|
|
LogError("impossibly short mack from ", m_RemoteAddr);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if(result[0] != LLARP_PROTO_VERSION)
|
|
|
|
|
byte_t numAcks = data[CommandOverhead + PacketOverhead];
|
|
|
|
|
if(data.size()
|
|
|
|
|
< 1 + CommandOverhead + PacketOverhead + (numAcks * sizeof(uint64_t)))
|
|
|
|
|
{
|
|
|
|
|
LogError("protocol version missmatch ", int(result[0]),
|
|
|
|
|
" != ", LLARP_PROTO_VERSION);
|
|
|
|
|
LogError("short mack from ", m_RemoteAddr);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
LogDebug("command ", int(result[1]), " from ", m_RemoteAddr);
|
|
|
|
|
switch(result[1])
|
|
|
|
|
LogDebug("got ", int(numAcks), " mack from ", m_RemoteAddr);
|
|
|
|
|
byte_t* ptr = data.data() + CommandOverhead + PacketOverhead + 1;
|
|
|
|
|
while(numAcks > 0)
|
|
|
|
|
{
|
|
|
|
|
case Command::eXMIT:
|
|
|
|
|
HandleXMIT(std::move(result));
|
|
|
|
|
return;
|
|
|
|
|
case Command::eDATA:
|
|
|
|
|
HandleDATA(std::move(result));
|
|
|
|
|
return;
|
|
|
|
|
case Command::eACKS:
|
|
|
|
|
HandleACKS(std::move(result));
|
|
|
|
|
return;
|
|
|
|
|
case Command::ePING:
|
|
|
|
|
HandlePING(std::move(result));
|
|
|
|
|
return;
|
|
|
|
|
case Command::eNACK:
|
|
|
|
|
HandleNACK(std::move(result));
|
|
|
|
|
return;
|
|
|
|
|
case Command::eCLOS:
|
|
|
|
|
HandleCLOS(std::move(result));
|
|
|
|
|
return;
|
|
|
|
|
uint64_t acked = bufbe64toh(ptr);
|
|
|
|
|
LogDebug("mack containing txid=", acked, " from ", m_RemoteAddr);
|
|
|
|
|
auto itr = m_TXMsgs.find(acked);
|
|
|
|
|
if(itr != m_TXMsgs.end())
|
|
|
|
|
{
|
|
|
|
|
itr->second.Completed();
|
|
|
|
|
m_TXMsgs.erase(itr);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
LogDebug("ignored mack for txid=", acked, " from ", m_RemoteAddr);
|
|
|
|
|
}
|
|
|
|
|
ptr += sizeof(uint64_t);
|
|
|
|
|
numAcks--;
|
|
|
|
|
}
|
|
|
|
|
LogError("invalid command ", int(result[1]));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
Session::HandleNACK(std::vector< byte_t > data)
|
|
|
|
|
Session::HandleNACK(Packet_t data)
|
|
|
|
|
{
|
|
|
|
|
if(data.size() < 10)
|
|
|
|
|
if(data.size() < CommandOverhead + sizeof(uint64_t) + PacketOverhead)
|
|
|
|
|
{
|
|
|
|
|
LogError("short nack from ", m_RemoteAddr);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
uint64_t txid = bufbe64toh(data.data() + 2);
|
|
|
|
|
uint64_t txid =
|
|
|
|
|
bufbe64toh(data.data() + CommandOverhead + PacketOverhead);
|
|
|
|
|
LogDebug("got nack on ", txid, " from ", m_RemoteAddr);
|
|
|
|
|
auto itr = m_TXMsgs.find(txid);
|
|
|
|
|
if(itr != m_TXMsgs.end())
|
|
|
|
|
{
|
|
|
|
|
auto xmit = itr->second.XMIT();
|
|
|
|
|
AddRandomPadding(xmit);
|
|
|
|
|
const llarp_buffer_t pkt(xmit);
|
|
|
|
|
EncryptAndSend(pkt);
|
|
|
|
|
EncryptAndSend(itr->second.XMIT());
|
|
|
|
|
}
|
|
|
|
|
m_LastRX = m_Parent->Now();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
Session::HandleXMIT(std::vector< byte_t > data)
|
|
|
|
|
Session::HandleXMIT(Packet_t data)
|
|
|
|
|
{
|
|
|
|
|
if(data.size() < 44)
|
|
|
|
|
if(data.size() < CommandOverhead + PacketOverhead + sizeof(uint16_t)
|
|
|
|
|
+ sizeof(uint64_t) + ShortHash::SIZE)
|
|
|
|
|
{
|
|
|
|
|
LogError("short XMIT from ", m_RemoteAddr, " ", data.size(), " < 44");
|
|
|
|
|
LogError("short XMIT from ", m_RemoteAddr);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
uint16_t sz = bufbe16toh(data.data() + 2);
|
|
|
|
|
uint64_t rxid = bufbe64toh(data.data() + 4);
|
|
|
|
|
ShortHash h{data.data() + 12};
|
|
|
|
|
uint16_t sz = bufbe16toh(data.data() + CommandOverhead + PacketOverhead);
|
|
|
|
|
uint64_t rxid = bufbe64toh(data.data() + CommandOverhead
|
|
|
|
|
+ sizeof(uint16_t) + PacketOverhead);
|
|
|
|
|
ShortHash h{data.data() + CommandOverhead + sizeof(uint16_t)
|
|
|
|
|
+ sizeof(uint64_t) + PacketOverhead};
|
|
|
|
|
LogDebug("rxid=", rxid, " sz=", sz, " h=", h.ToHex());
|
|
|
|
|
m_LastRX = m_Parent->Now();
|
|
|
|
|
{
|
|
|
|
|
@ -521,6 +674,7 @@ namespace llarp
|
|
|
|
|
auto itr = m_ReplayFilter.find(rxid);
|
|
|
|
|
if(itr != m_ReplayFilter.end())
|
|
|
|
|
{
|
|
|
|
|
m_SendMACKs.emplace(rxid);
|
|
|
|
|
LogDebug("duplicate rxid=", rxid, " from ", m_RemoteAddr);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
@ -536,44 +690,51 @@ namespace llarp
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
Session::HandleDATA(std::vector< byte_t > data)
|
|
|
|
|
Session::HandleDATA(Packet_t data)
|
|
|
|
|
{
|
|
|
|
|
if(data.size() <= 12)
|
|
|
|
|
if(data.size() <= CommandOverhead + sizeof(uint16_t) + sizeof(uint64_t)
|
|
|
|
|
+ PacketOverhead)
|
|
|
|
|
{
|
|
|
|
|
LogError("short DATA from ", m_RemoteAddr, " ", data.size());
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
m_LastRX = m_Parent->Now();
|
|
|
|
|
uint16_t sz = bufbe16toh(data.data() + 2);
|
|
|
|
|
uint64_t rxid = bufbe64toh(data.data() + 4);
|
|
|
|
|
m_LastRX = m_Parent->Now();
|
|
|
|
|
uint16_t sz = bufbe16toh(data.data() + CommandOverhead + PacketOverhead);
|
|
|
|
|
uint64_t rxid = bufbe64toh(data.data() + CommandOverhead
|
|
|
|
|
+ sizeof(uint16_t) + PacketOverhead);
|
|
|
|
|
auto itr = m_RXMsgs.find(rxid);
|
|
|
|
|
if(itr == m_RXMsgs.end())
|
|
|
|
|
{
|
|
|
|
|
LogDebug("no rxid=", rxid, " for ", m_RemoteAddr);
|
|
|
|
|
std::vector< byte_t > nack = {
|
|
|
|
|
LLARP_PROTO_VERSION, Command::eNACK, 0, 0, 0, 0, 0, 0, 0, 0};
|
|
|
|
|
htobe64buf(nack.data() + 2, rxid);
|
|
|
|
|
AddRandomPadding(nack);
|
|
|
|
|
const llarp_buffer_t nackbuf(nack);
|
|
|
|
|
EncryptAndSend(nackbuf);
|
|
|
|
|
if(m_ReplayFilter.find(rxid) == m_ReplayFilter.end())
|
|
|
|
|
{
|
|
|
|
|
LogDebug("no rxid=", rxid, " for ", m_RemoteAddr);
|
|
|
|
|
auto nack = CreatePacket(Command::eNACK, 8);
|
|
|
|
|
htobe64buf(nack.data() + PacketOverhead + CommandOverhead, rxid);
|
|
|
|
|
EncryptAndSend(std::move(nack));
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
LogDebug("replay hit for rxid=", rxid, " for ", m_RemoteAddr);
|
|
|
|
|
m_SendMACKs.emplace(rxid);
|
|
|
|
|
}
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
const llarp_buffer_t buf(data.data() + 12, data.size() - 12);
|
|
|
|
|
const llarp_buffer_t buf(data.data() + PacketOverhead + 12,
|
|
|
|
|
data.size() - (PacketOverhead + 12));
|
|
|
|
|
itr->second.HandleData(sz, buf, m_Parent->Now());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(itr->second.IsCompleted())
|
|
|
|
|
{
|
|
|
|
|
itr->second.SendACKS(util::memFn(&Session::EncryptAndSend, this),
|
|
|
|
|
m_Parent->Now());
|
|
|
|
|
if(itr->second.Verify())
|
|
|
|
|
{
|
|
|
|
|
auto msg = std::move(itr->second);
|
|
|
|
|
const llarp_buffer_t buf(msg.m_Data.data(), msg.m_Size);
|
|
|
|
|
const llarp_buffer_t buf(msg.m_Data);
|
|
|
|
|
m_Parent->HandleMessage(this, buf);
|
|
|
|
|
m_ReplayFilter.emplace(itr->first, m_Parent->Now());
|
|
|
|
|
m_SendMACKs.emplace(itr->first);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
@ -584,23 +745,23 @@ namespace llarp
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
Session::HandleACKS(std::vector< byte_t > data)
|
|
|
|
|
Session::HandleACKS(Packet_t data)
|
|
|
|
|
{
|
|
|
|
|
if(data.size() < 11)
|
|
|
|
|
if(data.size() < 11 + PacketOverhead)
|
|
|
|
|
{
|
|
|
|
|
LogError("short ACKS from ", m_RemoteAddr, " ", data.size(), " < 11");
|
|
|
|
|
LogError("short ACKS from ", m_RemoteAddr);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
const auto now = m_Parent->Now();
|
|
|
|
|
m_LastRX = now;
|
|
|
|
|
uint64_t txid = bufbe64toh(data.data() + 2);
|
|
|
|
|
uint64_t txid = bufbe64toh(data.data() + 2 + PacketOverhead);
|
|
|
|
|
auto itr = m_TXMsgs.find(txid);
|
|
|
|
|
if(itr == m_TXMsgs.end())
|
|
|
|
|
{
|
|
|
|
|
LogDebug("no txid=", txid, " for ", m_RemoteAddr);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
itr->second.Ack(data[10]);
|
|
|
|
|
itr->second.Ack(data[10 + PacketOverhead]);
|
|
|
|
|
|
|
|
|
|
if(itr->second.IsTransmitted())
|
|
|
|
|
{
|
|
|
|
|
@ -615,13 +776,13 @@ namespace llarp
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Session::HandleCLOS(std::vector< byte_t >)
|
|
|
|
|
void Session::HandleCLOS(Packet_t)
|
|
|
|
|
{
|
|
|
|
|
LogInfo("remote closed by ", m_RemoteAddr);
|
|
|
|
|
Close();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Session::HandlePING(std::vector< byte_t >)
|
|
|
|
|
void Session::HandlePING(Packet_t)
|
|
|
|
|
{
|
|
|
|
|
m_LastRX = m_Parent->Now();
|
|
|
|
|
}
|
|
|
|
|
@ -631,9 +792,7 @@ namespace llarp
|
|
|
|
|
{
|
|
|
|
|
if(m_State == State::Ready)
|
|
|
|
|
{
|
|
|
|
|
std::vector< byte_t > ping{LLARP_PROTO_VERSION, Command::ePING};
|
|
|
|
|
const llarp_buffer_t buf(ping);
|
|
|
|
|
EncryptAndSend(buf);
|
|
|
|
|
EncryptAndSend(CreatePacket(Command::ePING, 0));
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
return false;
|
|
|
|
|
@ -646,7 +805,7 @@ namespace llarp
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
Session::Recv_LL(const llarp_buffer_t& buf)
|
|
|
|
|
Session::Recv_LL(ILinkSession::Packet_t data)
|
|
|
|
|
{
|
|
|
|
|
switch(m_State)
|
|
|
|
|
{
|
|
|
|
|
@ -655,7 +814,10 @@ namespace llarp
|
|
|
|
|
{
|
|
|
|
|
// initial data
|
|
|
|
|
// enter introduction phase
|
|
|
|
|
HandleGotIntro(buf);
|
|
|
|
|
if(DecryptMessageInPlace(data))
|
|
|
|
|
HandleGotIntro(std::move(data));
|
|
|
|
|
else
|
|
|
|
|
LogError("bad intro from ", m_RemoteAddr);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
@ -667,18 +829,18 @@ namespace llarp
|
|
|
|
|
if(m_Inbound)
|
|
|
|
|
{
|
|
|
|
|
// we are replying to an intro ack
|
|
|
|
|
HandleCreateSessionRequest(buf);
|
|
|
|
|
HandleCreateSessionRequest(std::move(data));
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
// we got an intro ack
|
|
|
|
|
// send a session request
|
|
|
|
|
HandleGotIntroAck(buf);
|
|
|
|
|
HandleGotIntroAck(std::move(data));
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case State::LinkIntro:
|
|
|
|
|
default:
|
|
|
|
|
HandleSessionData(buf);
|
|
|
|
|
HandleSessionData(std::move(data));
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
Jeff
5 years ago
committed by
GitHub