lokinet/llarp/dns/server.cpp

247 lines
7.1 KiB
C++
Raw Normal View History

2018-12-12 00:58:08 +00:00
#include <dns/server.hpp>
2018-12-03 22:22:59 +00:00
#include <crypto/crypto.hpp>
2019-09-01 13:26:16 +00:00
#include <util/thread/logic.hpp>
2019-02-02 23:12:42 +00:00
#include <array>
2019-07-30 23:42:13 +00:00
#include <utility>
2019-02-02 23:12:42 +00:00
2018-12-03 22:22:59 +00:00
namespace llarp
{
namespace dns
{
Proxy::Proxy(llarp_ev_loop_ptr serverLoop, Logic_ptr serverLogic,
2019-05-22 16:20:50 +00:00
llarp_ev_loop_ptr clientLoop, Logic_ptr clientLogic,
IQueryHandler* h)
2019-07-30 23:42:13 +00:00
: m_ServerLoop(std::move(serverLoop))
, m_ClientLoop(std::move(clientLoop))
, m_ServerLogic(std::move(serverLogic))
, m_ClientLogic(std::move(clientLogic))
2019-05-22 16:20:50 +00:00
, m_QueryHandler(h)
2018-12-03 22:22:59 +00:00
{
2018-12-04 16:35:25 +00:00
m_Client.user = this;
m_Server.user = this;
m_Client.tick = nullptr;
m_Server.tick = nullptr;
m_Client.recvfrom = &HandleUDPRecv_client;
m_Server.recvfrom = &HandleUDPRecv_server;
2018-12-03 22:22:59 +00:00
}
void
Proxy::Stop()
{
}
bool
Proxy::Start(const llarp::Addr addr,
2018-12-03 22:22:59 +00:00
const std::vector< llarp::Addr >& resolvers)
{
m_Resolvers.clear();
m_Resolvers = resolvers;
const llarp::Addr any("0.0.0.0", 0);
auto self = shared_from_this();
LogicCall(m_ClientLogic, [=]() {
llarp_ev_add_udp(self->m_ClientLoop.get(), &self->m_Client, any);
});
LogicCall(m_ServerLogic, [=]() {
llarp_ev_add_udp(self->m_ServerLoop.get(), &self->m_Server, addr);
});
return true;
2018-12-03 22:22:59 +00:00
}
2019-11-01 13:40:31 +00:00
static Proxy::Buffer_t
CopyBuffer(const llarp_buffer_t& buf)
{
std::vector< byte_t > msgbuf(buf.sz);
std::copy_n(buf.base, buf.sz, msgbuf.data());
return msgbuf;
}
2018-12-03 22:22:59 +00:00
void
2018-12-04 16:35:25 +00:00
Proxy::HandleUDPRecv_server(llarp_udp_io* u, const sockaddr* from,
2019-02-03 00:48:10 +00:00
ManagedBuffer buf)
2018-12-03 22:22:59 +00:00
{
2019-11-01 13:40:31 +00:00
const llarp::Addr addr(*from);
Buffer_t msgbuf = CopyBuffer(buf.underlying);
auto self = static_cast< Proxy* >(u->user)->shared_from_this();
// yes we use the server loop here because if the server loop is not the
// client loop we'll crash again
LogicCall(self->m_ServerLogic, [self, addr, msgbuf]() {
self->HandlePktServer(addr, msgbuf);
});
2018-12-04 16:35:25 +00:00
}
void
Proxy::HandleUDPRecv_client(llarp_udp_io* u, const sockaddr* from,
2019-02-03 00:48:10 +00:00
ManagedBuffer buf)
2018-12-04 16:35:25 +00:00
{
2019-11-01 13:40:31 +00:00
const llarp::Addr addr(*from);
Buffer_t msgbuf = CopyBuffer(buf.underlying);
auto self = static_cast< Proxy* >(u->user)->shared_from_this();
LogicCall(self->m_ServerLogic, [self, addr, msgbuf]() {
self->HandlePktClient(addr, msgbuf);
});
2018-12-03 22:22:59 +00:00
}
llarp::Addr
Proxy::PickRandomResolver() const
{
const size_t sz = m_Resolvers.size();
if(sz <= 1)
2018-12-03 22:22:59 +00:00
return m_Resolvers[0];
auto itr = m_Resolvers.begin();
std::advance(itr, llarp::randint() % sz);
2018-12-03 22:22:59 +00:00
return *itr;
}
void
Proxy::HandleTick(llarp_udp_io*)
{
}
void
Proxy::SendServerMessageTo(llarp::Addr to, Message msg)
2018-12-03 22:22:59 +00:00
{
auto self = shared_from_this();
LogicCall(m_ServerLogic, [to, msg, self]() {
std::array< byte_t, 1500 > tmp = {{0}};
llarp_buffer_t buf(tmp);
if(msg.Encode(&buf))
{
buf.sz = buf.cur - buf.base;
buf.cur = buf.base;
llarp_ev_udp_sendto(&self->m_Server, to, buf);
}
else
llarp::LogWarn("failed to encode dns message when sending");
});
}
void
Proxy::SendClientMessageTo(llarp::Addr to, Message msg)
{
auto self = shared_from_this();
LogicCall(m_ClientLogic, [to, msg, self]() {
std::array< byte_t, 1500 > tmp = {{0}};
llarp_buffer_t buf(tmp);
if(msg.Encode(&buf))
{
buf.sz = buf.cur - buf.base;
buf.cur = buf.base;
llarp_ev_udp_sendto(&self->m_Client, to, buf);
}
else
llarp::LogWarn("failed to encode dns message when sending");
});
2018-12-03 22:22:59 +00:00
}
void
2019-11-01 13:40:31 +00:00
Proxy::HandlePktClient(llarp::Addr from, Buffer_t buf)
2018-12-03 22:22:59 +00:00
{
2018-12-04 16:16:43 +00:00
MessageHeader hdr;
{
2019-11-01 13:40:31 +00:00
llarp_buffer_t pkt(buf);
if(!hdr.Decode(&pkt))
{
llarp::LogWarn("failed to parse dns header from ", from);
return;
}
2018-12-04 16:16:43 +00:00
}
TX tx = {hdr.id, from};
auto itr = m_Forwarded.find(tx);
if(itr == m_Forwarded.end())
return;
2019-05-22 16:20:50 +00:00
const Addr requester = itr->second;
2019-11-01 13:40:31 +00:00
auto self = shared_from_this();
LogicCall(m_ServerLogic, [=]() {
// forward reply to requester via server
2019-11-01 13:40:31 +00:00
const llarp_buffer_t tmpbuf(buf);
llarp_ev_udp_sendto(&self->m_Server, requester, tmpbuf);
2019-05-22 16:20:50 +00:00
});
// remove pending
m_Forwarded.erase(itr);
2018-12-04 16:35:25 +00:00
}
2018-12-04 16:16:43 +00:00
2018-12-04 16:35:25 +00:00
void
2019-11-01 13:40:31 +00:00
Proxy::HandlePktServer(llarp::Addr from, Buffer_t buf)
2018-12-04 16:35:25 +00:00
{
MessageHeader hdr;
2019-11-01 13:40:31 +00:00
llarp_buffer_t pkt(buf);
if(!hdr.Decode(&pkt))
2018-12-04 16:35:25 +00:00
{
llarp::LogWarn("failed to parse dns header from ", from);
return;
}
2019-11-01 13:40:31 +00:00
2018-12-04 16:35:25 +00:00
TX tx = {hdr.id, from};
auto itr = m_Forwarded.find(tx);
2018-12-04 16:16:43 +00:00
Message msg(hdr);
2019-11-01 13:40:31 +00:00
if(!msg.Decode(&pkt))
2018-12-03 22:22:59 +00:00
{
2018-12-04 16:16:43 +00:00
llarp::LogWarn("failed to parse dns message from ", from);
2018-12-03 22:22:59 +00:00
return;
}
// we don't provide a DoH resolver because it requires verified TLS
// TLS needs X509/ASN.1-DER and opting into the Root CA Cabal
// thankfully mozilla added a backdoor that allows ISPs to turn it off
// so we disable DoH for firefox using mozilla's ISP backdoor
// see: https://github.com/loki-project/loki-network/issues/832
2019-10-28 14:44:56 +00:00
for(const auto& q : msg.questions)
{
// is this firefox looking for their backdoor record?
if(q.IsName("use-application-dns.net"))
{
// yea it is, let's turn off DoH because god is dead.
msg.AddNXReply();
// press F to pay respects
SendServerMessageTo(from, std::move(msg));
return;
}
}
auto self = shared_from_this();
2018-12-03 22:22:59 +00:00
if(m_QueryHandler && m_QueryHandler->ShouldHookDNSMessage(msg))
{
if(!m_QueryHandler->HandleHookedDNSMessage(
2018-12-04 16:16:43 +00:00
std::move(msg),
std::bind(&Proxy::SendServerMessageTo, self, from,
2018-12-03 22:22:59 +00:00
std::placeholders::_1)))
{
llarp::LogWarn("failed to handle hooked dns");
}
}
else if(m_Resolvers.size() == 0)
{
// no upstream resolvers
// let's serv fail it
msg.AddServFail();
2019-05-22 16:20:50 +00:00
SendServerMessageTo(from, std::move(msg));
}
2018-12-04 16:16:43 +00:00
else if(itr == m_Forwarded.end())
2018-12-03 22:22:59 +00:00
{
// new forwarded query
tx.from = PickRandomResolver();
m_Forwarded[tx] = from;
LogicCall(m_ClientLogic, [=] {
// do query
2019-11-01 13:40:31 +00:00
const llarp_buffer_t tmpbuf(buf);
llarp_ev_udp_sendto(&self->m_Client, tx.from, tmpbuf);
});
2018-12-03 22:22:59 +00:00
}
else
{
2019-11-01 13:40:31 +00:00
// send the query again because it's probably FEC from the requester
const auto resolver = itr->first.from;
LogicCall(m_ClientLogic, [=] {
2019-11-01 13:40:31 +00:00
// send it
const llarp_buffer_t tmpbuf(buf);
llarp_ev_udp_sendto(&self->m_Client, resolver, tmpbuf);
});
2018-12-03 22:22:59 +00:00
}
}
} // namespace dns
} // namespace llarp