i2pd/Tunnel.cpp

538 lines
14 KiB
C++
Raw Normal View History

#include "I2PEndian.h"
2014-01-10 02:55:53 +04:00
#include <thread>
2013-12-07 04:02:49 +04:00
#include <cryptopp/sha.h>
#include "RouterContext.h"
#include "Log.h"
#include "Timestamp.h"
#include "I2NPProtocol.h"
#include "Transports.h"
#include "NetDb.h"
#include "Tunnel.h"
namespace i2p
{
namespace tunnel
{
2014-07-27 04:56:42 +04:00
Tunnel::Tunnel (TunnelConfig * config):
m_Config (config), m_Pool (nullptr), m_State (eTunnelStatePending)
2013-12-07 04:02:49 +04:00
{
}
Tunnel::~Tunnel ()
{
delete m_Config;
}
void Tunnel::Build (uint32_t replyMsgID, OutboundTunnel * outboundTunnel)
{
CryptoPP::RandomNumberGenerator& rnd = i2p::context.GetRandomNumberGenerator ();
2014-06-19 05:24:24 +04:00
int numRecords = m_Config->GetNumHops () + 1; // +1 fake record. TODO:
2013-12-07 04:02:49 +04:00
I2NPMessage * msg = NewI2NPMessage ();
*msg->GetPayload () = numRecords;
msg->len += numRecords*sizeof (I2NPBuildRequestRecordElGamalEncrypted) + 1;
I2NPBuildRequestRecordElGamalEncrypted * records = (I2NPBuildRequestRecordElGamalEncrypted *)(msg->GetPayload () + 1);
TunnelHopConfig * hop = m_Config->GetFirstHop ();
int i = 0;
while (hop)
{
EncryptBuildRequestRecord (*hop->router,
CreateBuildRequestRecord (hop->router->GetIdentHash (),
hop->tunnelID,
hop->nextRouter->GetIdentHash (),
hop->nextTunnelID,
hop->layerKey, hop->ivKey,
hop->replyKey, hop->replyIV,
hop->next ? rnd.GenerateWord32 () : replyMsgID, // we set replyMsgID for last hop only
hop->isGateway, hop->isEndpoint),
records[i]);
hop->recordIndex = i; //TODO:
2013-12-07 04:02:49 +04:00
i++;
hop = hop->next;
}
2014-06-19 05:24:24 +04:00
// fill up fake records with random data
while (i < numRecords)
{
rnd.GenerateBlock ((uint8_t *)(records + i), sizeof (records[i]));
i++;
}
2014-05-16 02:58:26 +04:00
i2p::crypto::CBCDecryption decryption;
2013-12-07 04:02:49 +04:00
hop = m_Config->GetLastHop ()->prev;
while (hop)
{
2014-05-16 02:58:26 +04:00
decryption.SetKey (hop->replyKey);
// decrypt records after current hop
TunnelHopConfig * hop1 = hop->next;
while (hop1)
{
2014-06-25 03:33:30 +04:00
decryption.SetIV (hop->replyIV);
decryption.Decrypt((uint8_t *)&records[hop1->recordIndex],
sizeof (I2NPBuildRequestRecordElGamalEncrypted),
(uint8_t *)&records[hop1->recordIndex]);
hop1 = hop1->next;
}
2013-12-07 04:02:49 +04:00
hop = hop->prev;
}
FillI2NPMessageHeader (msg, eI2NPVariableTunnelBuild);
if (outboundTunnel)
2014-01-06 06:25:48 +04:00
outboundTunnel->SendTunnelDataMsg (GetNextIdentHash (), 0, msg);
2013-12-07 04:02:49 +04:00
else
i2p::transports.SendMessage (GetNextIdentHash (), msg);
}
bool Tunnel::HandleTunnelBuildResponse (uint8_t * msg, size_t len)
{
LogPrint ("TunnelBuildResponse ", (int)msg[0], " records.");
2014-05-16 02:58:26 +04:00
i2p::crypto::CBCDecryption decryption;
2013-12-07 04:02:49 +04:00
TunnelHopConfig * hop = m_Config->GetLastHop ();
while (hop)
{
2014-05-16 02:58:26 +04:00
decryption.SetKey (hop->replyKey);
// decrypt records before and including current hop
TunnelHopConfig * hop1 = hop;
while (hop1)
{
2014-06-19 05:24:24 +04:00
auto idx = hop1->recordIndex;
if (idx >= 0 && idx < msg[0])
{
uint8_t * record = msg + 1 + idx*sizeof (I2NPBuildResponseRecord);
2014-06-25 03:33:30 +04:00
decryption.SetIV (hop->replyIV);
2014-06-19 05:24:24 +04:00
decryption.Decrypt(record, sizeof (I2NPBuildResponseRecord), record);
}
else
LogPrint ("Tunnel hop index ", idx, " is out of range");
hop1 = hop1->prev;
}
2013-12-07 04:02:49 +04:00
hop = hop->prev;
}
2014-07-27 04:56:42 +04:00
bool established = true;
2014-06-19 05:24:24 +04:00
hop = m_Config->GetFirstHop ();
while (hop)
2013-12-07 04:02:49 +04:00
{
2014-06-19 05:24:24 +04:00
I2NPBuildResponseRecord * record = (I2NPBuildResponseRecord *)(msg + 1 + hop->recordIndex*sizeof (I2NPBuildResponseRecord));
2013-12-07 04:02:49 +04:00
LogPrint ("Ret code=", (int)record->ret);
if (record->ret)
// if any of participants declined the tunnel is not established
2014-07-27 04:56:42 +04:00
established = false;
2014-06-19 05:24:24 +04:00
hop = hop->next;
2013-12-07 04:02:49 +04:00
}
2014-07-27 04:56:42 +04:00
if (established)
2014-05-10 03:34:12 +04:00
{
// change reply keys to layer keys
2014-06-19 05:24:24 +04:00
hop = m_Config->GetFirstHop ();
2014-05-10 03:34:12 +04:00
while (hop)
{
2014-05-16 02:58:26 +04:00
hop->decryption.SetKeys (hop->layerKey, hop->ivKey);
2014-05-10 03:34:12 +04:00
hop = hop->next;
}
}
2014-07-27 04:56:42 +04:00
if (established) m_State = eTunnelStateEstablished;
return established;
2013-12-07 04:02:49 +04:00
}
void Tunnel::EncryptTunnelMsg (I2NPMessage * tunnelMsg)
{
uint8_t * payload = tunnelMsg->GetPayload () + 4;
TunnelHopConfig * hop = m_Config->GetLastHop ();
while (hop)
{
2014-05-16 02:58:26 +04:00
hop->decryption.Decrypt (payload);
2013-12-07 04:02:49 +04:00
hop = hop->prev;
}
}
void InboundTunnel::HandleTunnelDataMsg (I2NPMessage * msg)
{
2014-07-27 04:56:42 +04:00
if (IsFailed ()) SetState (eTunnelStateEstablished); // incoming messages means a tunnel is alive
msg->from = this;
2013-12-07 04:02:49 +04:00
EncryptTunnelMsg (msg);
m_Endpoint.HandleDecryptedTunnelDataMsg (msg);
}
void OutboundTunnel::SendTunnelDataMsg (const uint8_t * gwHash, uint32_t gwTunnel, i2p::I2NPMessage * msg)
{
TunnelMessageBlock block;
if (gwHash)
{
block.hash = gwHash;
if (gwTunnel)
{
block.deliveryType = eDeliveryTypeTunnel;
block.tunnelID = gwTunnel;
}
else
block.deliveryType = eDeliveryTypeRouter;
}
else
block.deliveryType = eDeliveryTypeLocal;
block.data = msg;
2014-04-03 20:19:12 +04:00
std::unique_lock<std::mutex> l(m_SendMutex);
m_Gateway.SendTunnelDataMsg (block);
2013-12-07 04:02:49 +04:00
}
2014-01-21 03:37:51 +04:00
void OutboundTunnel::SendTunnelDataMsg (std::vector<TunnelMessageBlock> msgs)
2013-12-07 04:02:49 +04:00
{
2014-04-03 20:19:12 +04:00
std::unique_lock<std::mutex> l(m_SendMutex);
2014-01-21 03:37:51 +04:00
for (auto& it : msgs)
m_Gateway.PutTunnelDataMsg (it);
2014-01-21 03:37:51 +04:00
m_Gateway.SendBuffer ();
2013-12-07 04:02:49 +04:00
}
2014-01-21 03:37:51 +04:00
2013-12-07 04:02:49 +04:00
Tunnels tunnels;
2013-12-10 17:10:49 +04:00
Tunnels::Tunnels (): m_IsRunning (false), m_IsTunnelCreated (false),
2014-04-02 21:14:21 +04:00
m_NextReplyMsgID (555), m_Thread (nullptr), m_ExploratoryPool (nullptr)
2013-12-07 04:02:49 +04:00
{
}
Tunnels::~Tunnels ()
{
for (auto& it : m_OutboundTunnels)
delete it;
m_OutboundTunnels.clear ();
for (auto& it : m_InboundTunnels)
delete it.second;
m_InboundTunnels.clear ();
for (auto& it : m_TransitTunnels)
delete it.second;
m_TransitTunnels.clear ();
for (auto& it : m_PendingTunnels)
delete it.second;
m_PendingTunnels.clear ();
2014-03-15 04:24:12 +04:00
for (auto& it: m_Pools)
2014-04-01 23:08:53 +04:00
delete it.second;
2014-03-15 04:24:12 +04:00
m_Pools.clear ();
2013-12-07 04:02:49 +04:00
}
InboundTunnel * Tunnels::GetInboundTunnel (uint32_t tunnelID)
{
auto it = m_InboundTunnels.find(tunnelID);
if (it != m_InboundTunnels.end ())
return it->second;
return nullptr;
}
TransitTunnel * Tunnels::GetTransitTunnel (uint32_t tunnelID)
{
auto it = m_TransitTunnels.find(tunnelID);
if (it != m_TransitTunnels.end ())
return it->second;
return nullptr;
}
Tunnel * Tunnels::GetPendingTunnel (uint32_t replyMsgID)
{
auto it = m_PendingTunnels.find(replyMsgID);
if (it != m_PendingTunnels.end ())
{
Tunnel * t = it->second;
m_PendingTunnels.erase (it);
return t;
}
return nullptr;
}
InboundTunnel * Tunnels::GetNextInboundTunnel ()
{
InboundTunnel * tunnel = nullptr;
size_t minReceived = 0;
for (auto it : m_InboundTunnels)
2014-03-21 23:54:55 +04:00
{
if (it.second->IsFailed ()) continue;
2013-12-07 04:02:49 +04:00
if (!tunnel || it.second->GetNumReceivedBytes () < minReceived)
{
tunnel = it.second;
minReceived = it.second->GetNumReceivedBytes ();
2014-03-21 23:54:55 +04:00
}
}
2013-12-07 04:02:49 +04:00
return tunnel;
}
OutboundTunnel * Tunnels::GetNextOutboundTunnel ()
{
2013-12-29 19:48:57 +04:00
CryptoPP::RandomNumberGenerator& rnd = i2p::context.GetRandomNumberGenerator ();
uint32_t ind = rnd.GenerateWord32 (0, m_OutboundTunnels.size () - 1), i = 0;
2014-03-21 23:54:55 +04:00
OutboundTunnel * tunnel = nullptr;
2013-12-29 19:48:57 +04:00
for (auto it: m_OutboundTunnels)
{
if (i >= ind) return it;
2014-03-21 23:54:55 +04:00
if (!it->IsFailed ())
2013-12-07 04:02:49 +04:00
{
tunnel = it;
2014-03-21 23:54:55 +04:00
i++;
}
}
return tunnel;
2013-12-07 04:02:49 +04:00
}
2014-03-15 04:24:12 +04:00
TunnelPool * Tunnels::CreateTunnelPool (i2p::data::LocalDestination& localDestination, int numHops)
2014-03-15 04:24:12 +04:00
{
auto pool = new TunnelPool (localDestination, numHops);
2014-04-01 23:08:53 +04:00
m_Pools[pool->GetIdentHash ()] = pool;
2014-03-15 04:51:51 +04:00
return pool;
}
void Tunnels::DeleteTunnelPool (TunnelPool * pool)
{
2014-04-01 23:08:53 +04:00
if (pool)
{
m_Pools.erase (pool->GetIdentHash ());
delete pool;
}
2014-03-15 04:24:12 +04:00
}
2013-12-07 04:02:49 +04:00
void Tunnels::AddTransitTunnel (TransitTunnel * tunnel)
{
m_TransitTunnels[tunnel->GetTunnelID ()] = tunnel;
}
void Tunnels::Start ()
{
m_IsRunning = true;
m_Thread = new std::thread (std::bind (&Tunnels::Run, this));
}
void Tunnels::Stop ()
{
m_IsRunning = false;
m_Queue.WakeUp ();
if (m_Thread)
{
m_Thread->join ();
delete m_Thread;
m_Thread = 0;
}
}
void Tunnels::Run ()
{
2014-01-10 02:55:53 +04:00
std::this_thread::sleep_for (std::chrono::seconds(1)); // wait for other parts are ready
2013-12-07 04:02:49 +04:00
uint64_t lastTs = 0;
2013-12-07 04:02:49 +04:00
while (m_IsRunning)
{
try
{
I2NPMessage * msg = m_Queue.GetNextWithTimeout (1000); // 1 sec
while (msg)
{
uint32_t tunnelID = be32toh (*(uint32_t *)msg->GetPayload ());
InboundTunnel * tunnel = GetInboundTunnel (tunnelID);
if (tunnel)
tunnel->HandleTunnelDataMsg (msg);
else
{
TransitTunnel * transitTunnel = GetTransitTunnel (tunnelID);
if (transitTunnel)
transitTunnel->HandleTunnelDataMsg (msg);
else
{
LogPrint ("Tunnel ", tunnelID, " not found");
i2p::DeleteI2NPMessage (msg);
}
}
msg = m_Queue.Get ();
}
uint64_t ts = i2p::util::GetSecondsSinceEpoch ();
2013-12-07 04:02:49 +04:00
if (ts - lastTs >= 15) // manage tunnels every 15 seconds
{
ManageTunnels ();
lastTs = ts;
}
}
catch (std::exception& ex)
{
LogPrint ("Tunnels: ", ex.what ());
}
}
}
void Tunnels::ManageTunnels ()
{
// check pending tunnel. if something is still there, wipe it out
// because it wouldn't be responded anyway
2013-12-07 04:02:49 +04:00
for (auto& it : m_PendingTunnels)
{
LogPrint ("Pending tunnel build request ", it.first, " has not been responded. Deleted");
if (it.second->GetTunnelConfig ()->GetFirstHop ()->isGateway) // outbound
i2p::transports.CloseSession (it.second->GetTunnelConfig ()->GetFirstHop ()->router);
2013-12-07 04:02:49 +04:00
delete it.second;
}
m_PendingTunnels.clear ();
ManageInboundTunnels ();
2013-12-10 17:10:49 +04:00
ManageOutboundTunnels ();
2014-01-04 07:56:28 +04:00
ManageTransitTunnels ();
2014-03-15 04:24:12 +04:00
ManageTunnelPools ();
2013-12-07 04:02:49 +04:00
/* if (!m_IsTunnelCreated)
{
InboundTunnel * inboundTunnel = CreateOneHopInboundTestTunnel ();
if (inboundTunnel)
CreateOneHopOutboundTestTunnel (inboundTunnel);
inboundTunnel = CreateTwoHopsInboundTestTunnel ();
if (inboundTunnel)
CreateTwoHopsOutboundTestTunnel (inboundTunnel);
m_IsTunnelCreated = true;
}*/
}
void Tunnels::ManageOutboundTunnels ()
{
uint64_t ts = i2p::util::GetSecondsSinceEpoch ();
2013-12-07 04:02:49 +04:00
for (auto it = m_OutboundTunnels.begin (); it != m_OutboundTunnels.end ();)
{
if (ts > (*it)->GetCreationTime () + TUNNEL_EXPIRATION_TIMEOUT)
{
LogPrint ("Tunnel ", (*it)->GetTunnelID (), " expired");
2014-03-17 00:03:20 +04:00
auto pool = (*it)->GetTunnelPool ();
if (pool)
pool->TunnelExpired (*it);
2014-07-10 05:43:33 +04:00
delete *it;
2013-12-07 04:02:49 +04:00
it = m_OutboundTunnels.erase (it);
}
else
it++;
}
if (m_OutboundTunnels.size () < 5)
2013-12-07 04:02:49 +04:00
{
// trying to create one more oubound tunnel
2013-12-10 17:10:49 +04:00
InboundTunnel * inboundTunnel = GetNextInboundTunnel ();
if (!inboundTunnel) return;
LogPrint ("Creating one hop outbound tunnel...");
CreateTunnel<OutboundTunnel> (
new TunnelConfig (std::vector<const i2p::data::RouterInfo *>
{
i2p::data::netdb.GetRandomRouter ()
},
inboundTunnel->GetTunnelConfig ()));
2013-12-07 04:02:49 +04:00
}
}
void Tunnels::ManageInboundTunnels ()
{
uint64_t ts = i2p::util::GetSecondsSinceEpoch ();
2013-12-07 04:02:49 +04:00
for (auto it = m_InboundTunnels.begin (); it != m_InboundTunnels.end ();)
{
if (ts > it->second->GetCreationTime () + TUNNEL_EXPIRATION_TIMEOUT)
{
LogPrint ("Tunnel ", it->second->GetTunnelID (), " expired");
2014-03-15 05:22:59 +04:00
auto pool = it->second->GetTunnelPool ();
if (pool)
pool->TunnelExpired (it->second);
2014-07-10 05:43:33 +04:00
delete it->second;
2013-12-07 04:02:49 +04:00
it = m_InboundTunnels.erase (it);
}
else
it++;
}
2013-12-10 17:10:49 +04:00
if (m_InboundTunnels.empty ())
{
LogPrint ("Creating zero hops inbound tunnel...");
CreateZeroHopsInboundTunnel ();
if (!m_ExploratoryPool)
m_ExploratoryPool = CreateTunnelPool (i2p::context, 2); // 2-hop exploratory
2013-12-10 17:10:49 +04:00
return;
}
2013-12-07 04:02:49 +04:00
if (m_OutboundTunnels.empty () || m_InboundTunnels.size () < 5)
2013-12-07 04:02:49 +04:00
{
// trying to create one more inbound tunnel
LogPrint ("Creating one hop inbound tunnel...");
CreateTunnel<InboundTunnel> (
new TunnelConfig (std::vector<const i2p::data::RouterInfo *>
{
i2p::data::netdb.GetRandomRouter ()
}));
2013-12-07 04:02:49 +04:00
}
}
2014-01-04 07:56:28 +04:00
void Tunnels::ManageTransitTunnels ()
{
uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
for (auto it = m_TransitTunnels.begin (); it != m_TransitTunnels.end ();)
{
if (ts > it->second->GetCreationTime () + TUNNEL_EXPIRATION_TIMEOUT)
{
LogPrint ("Transit tunnel ", it->second->GetTunnelID (), " expired");
2014-07-04 03:53:11 +04:00
auto tmp = it->second;
2014-01-04 07:56:28 +04:00
it = m_TransitTunnels.erase (it);
2014-07-04 03:53:11 +04:00
delete tmp;
2014-01-04 07:56:28 +04:00
}
else
it++;
}
}
2014-03-15 04:24:12 +04:00
void Tunnels::ManageTunnelPools ()
{
for (auto& it: m_Pools)
2014-03-18 00:50:03 +04:00
{
2014-04-01 23:08:53 +04:00
it.second->CreateTunnels ();
it.second->TestTunnels ();
2014-03-18 00:50:03 +04:00
}
2014-03-15 04:24:12 +04:00
}
2013-12-07 04:02:49 +04:00
void Tunnels::PostTunnelData (I2NPMessage * msg)
{
if (msg) m_Queue.Put (msg);
}
template<class TTunnel>
TTunnel * Tunnels::CreateTunnel (TunnelConfig * config, OutboundTunnel * outboundTunnel)
{
TTunnel * newTunnel = new TTunnel (config);
m_PendingTunnels[m_NextReplyMsgID] = newTunnel;
newTunnel->Build (m_NextReplyMsgID, outboundTunnel);
m_NextReplyMsgID++; // TODO: should be atomic
return newTunnel;
}
void Tunnels::AddOutboundTunnel (OutboundTunnel * newTunnel)
{
2013-12-10 17:10:49 +04:00
m_OutboundTunnels.push_back (newTunnel);
2014-03-17 00:03:20 +04:00
auto pool = newTunnel->GetTunnelPool ();
if (pool)
pool->TunnelCreated (newTunnel);
2013-12-07 04:02:49 +04:00
}
void Tunnels::AddInboundTunnel (InboundTunnel * newTunnel)
{
2014-03-15 04:51:51 +04:00
m_InboundTunnels[newTunnel->GetTunnelID ()] = newTunnel;
auto pool = newTunnel->GetTunnelPool ();
2014-03-15 04:24:12 +04:00
if (!pool)
2014-03-15 04:51:51 +04:00
{
// build symmetric outbound tunnel
CreateTunnel<OutboundTunnel> (newTunnel->GetTunnelConfig ()->Invert (), GetNextOutboundTunnel ());
}
2014-03-15 04:24:12 +04:00
else
pool->TunnelCreated (newTunnel);
2013-12-07 04:02:49 +04:00
}
void Tunnels::CreateZeroHopsInboundTunnel ()
{
2013-12-10 17:10:49 +04:00
CreateTunnel<InboundTunnel> (
2014-01-09 04:30:47 +04:00
new TunnelConfig (std::vector<const i2p::data::RouterInfo *>
{
&i2p::context.GetRouterInfo ()
}));
2013-12-07 04:02:49 +04:00
}
}
}