i2pd/libi2pd/Garlic.cpp

1045 lines
31 KiB
C++
Raw Normal View History

/*
* Copyright (c) 2013-2020, The PurpleI2P Project
*
* This file is part of Purple i2pd project and licensed under BSD3
*
* See full license text in LICENSE file at top of project tree
*/
2013-11-24 01:35:15 +04:00
#include <inttypes.h>
#include "I2PEndian.h"
2013-11-24 01:35:15 +04:00
#include <map>
#include <string>
2016-05-11 22:12:38 +03:00
#include "Crypto.h"
2013-11-24 01:35:15 +04:00
#include "RouterContext.h"
2014-01-09 07:47:22 +04:00
#include "I2NPProtocol.h"
#include "Tunnel.h"
#include "TunnelPool.h"
#include "Transports.h"
2013-11-24 01:35:15 +04:00
#include "Timestamp.h"
2015-11-03 17:15:49 +03:00
#include "Log.h"
2017-04-03 22:05:10 +03:00
#include "FS.h"
2020-01-15 23:13:43 +03:00
#include "ECIESX25519AEADRatchetSession.h"
2013-11-24 01:35:15 +04:00
#include "Garlic.h"
namespace i2p
{
2013-11-25 03:10:27 +04:00
namespace garlic
{
GarlicRoutingSession::GarlicRoutingSession (GarlicDestination * owner, bool attachLeaseSet):
m_Owner (owner), m_LeaseSetUpdateStatus (attachLeaseSet ? eLeaseSetUpdated : eLeaseSetDoNotSend),
2016-12-17 05:23:04 +03:00
m_LeaseSetUpdateMsgID (0)
2013-11-24 01:35:15 +04:00
{
2018-01-06 06:48:51 +03:00
}
2013-11-25 03:10:27 +04:00
GarlicRoutingSession::GarlicRoutingSession ():
m_Owner (nullptr), m_LeaseSetUpdateStatus (eLeaseSetDoNotSend), m_LeaseSetUpdateMsgID (0)
2014-07-28 19:54:34 +04:00
{
2018-01-06 06:48:51 +03:00
}
2014-07-28 19:54:34 +04:00
2013-11-25 03:10:27 +04:00
GarlicRoutingSession::~GarlicRoutingSession ()
2018-01-06 06:48:51 +03:00
{
2013-11-25 03:10:27 +04:00
}
2016-02-11 06:51:08 +03:00
std::shared_ptr<GarlicRoutingPath> GarlicRoutingSession::GetSharedRoutingPath ()
{
if (!m_SharedRoutingPath) return nullptr;
uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
2016-02-14 07:02:58 +03:00
if (m_SharedRoutingPath->numTimesUsed >= ROUTING_PATH_MAX_NUM_TIMES_USED ||
!m_SharedRoutingPath->outboundTunnel->IsEstablished () ||
2016-02-11 06:51:08 +03:00
ts*1000LL > m_SharedRoutingPath->remoteLease->endDate ||
ts > m_SharedRoutingPath->updateTime + ROUTING_PATH_EXPIRATION_TIMEOUT)
2016-02-11 06:51:08 +03:00
m_SharedRoutingPath = nullptr;
2016-02-14 07:02:58 +03:00
if (m_SharedRoutingPath) m_SharedRoutingPath->numTimesUsed++;
2016-02-11 06:51:08 +03:00
return m_SharedRoutingPath;
}
2018-01-06 06:48:51 +03:00
2016-02-11 06:51:08 +03:00
void GarlicRoutingSession::SetSharedRoutingPath (std::shared_ptr<GarlicRoutingPath> path)
2018-01-06 06:48:51 +03:00
{
if (path && path->outboundTunnel && path->remoteLease)
{
2016-02-11 06:51:08 +03:00
path->updateTime = i2p::util::GetSecondsSinceEpoch ();
2016-02-14 07:02:58 +03:00
path->numTimesUsed = 0;
2018-01-06 06:48:51 +03:00
}
2016-02-11 06:51:08 +03:00
else
path = nullptr;
m_SharedRoutingPath = path;
}
2018-01-06 06:48:51 +03:00
2020-03-09 01:13:41 +03:00
bool GarlicRoutingSession::MessageConfirmed (uint32_t msgID)
{
if (msgID == GetLeaseSetUpdateMsgID ())
{
SetLeaseSetUpdateStatus (eLeaseSetUpToDate);
SetLeaseSetUpdateMsgID (0);
LogPrint (eLogInfo, "Garlic: LeaseSet update confirmed");
return true;
}
return false;
}
2020-03-09 01:13:41 +03:00
void GarlicRoutingSession::CleanupUnconfirmedLeaseSet (uint64_t ts)
{
if (m_LeaseSetUpdateMsgID && ts*1000LL > m_LeaseSetSubmissionTime + LEASET_CONFIRMATION_TIMEOUT)
{
if (GetOwner ())
GetOwner ()->RemoveDeliveryStatusSession (m_LeaseSetUpdateMsgID);
m_LeaseSetUpdateMsgID = 0;
}
}
2020-03-09 01:13:41 +03:00
std::shared_ptr<I2NPMessage> GarlicRoutingSession::CreateEncryptedDeliveryStatusMsg (uint32_t msgID)
{
auto msg = CreateDeliveryStatusMsg (msgID);
if (GetOwner ())
{
//encrypt
uint8_t key[32], tag[32];
RAND_bytes (key, 32); // random session key
RAND_bytes (tag, 32); // random session tag
GetOwner ()->SubmitSessionKey (key, tag);
ElGamalAESSession garlic (key, tag);
msg = garlic.WrapSingleMessage (msg);
}
return msg;
}
ElGamalAESSession::ElGamalAESSession (GarlicDestination * owner,
std::shared_ptr<const i2p::data::RoutingDestination> destination, int numTags, bool attachLeaseSet):
GarlicRoutingSession (owner, attachLeaseSet),
m_Destination (destination), m_NumTags (numTags)
2015-01-23 18:07:11 +03:00
{
// create new session tags and session key
RAND_bytes (m_SessionKey, 32);
m_Encryption.SetKey (m_SessionKey);
2018-01-06 07:01:44 +03:00
}
2020-01-17 02:03:51 +03:00
ElGamalAESSession::ElGamalAESSession (const uint8_t * sessionKey, const SessionTag& sessionTag):
m_NumTags(1)
{
memcpy (m_SessionKey, sessionKey, 32);
m_Encryption.SetKey (m_SessionKey);
m_SessionTags.push_back (sessionTag);
m_SessionTags.back ().creationTime = i2p::util::GetSecondsSinceEpoch ();
}
2014-10-14 22:48:25 +04:00
std::shared_ptr<I2NPMessage> ElGamalAESSession::WrapSingleMessage (std::shared_ptr<const I2NPMessage> msg)
2014-01-18 19:34:57 +04:00
{
2015-11-24 21:09:12 +03:00
auto m = NewI2NPMessage ();
2014-11-26 19:04:49 +03:00
m->Align (12); // in order to get buf aligned to 16 (12 + 4)
2013-11-25 03:10:27 +04:00
size_t len = 0;
2013-11-24 01:35:15 +04:00
uint8_t * buf = m->GetPayload () + 4; // 4 bytes for length
2014-10-17 19:26:57 +04:00
// find non-expired tag
2018-01-06 06:48:51 +03:00
bool tagFound = false;
SessionTag tag;
if (m_NumTags > 0)
2018-01-06 06:48:51 +03:00
{
2014-10-17 19:26:57 +04:00
uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
2014-10-17 19:48:07 +04:00
while (!m_SessionTags.empty ())
{
2014-10-17 19:26:57 +04:00
if (ts < m_SessionTags.front ().creationTime + OUTGOING_TAGS_EXPIRATION_TIMEOUT)
{
tag = m_SessionTags.front ();
m_SessionTags.pop_front (); // use same tag only once
tagFound = true;
break;
2018-01-06 06:48:51 +03:00
}
2014-10-17 19:26:57 +04:00
else
m_SessionTags.pop_front (); // remove expired tag
}
2018-01-06 06:48:51 +03:00
}
// create message
2014-10-17 19:26:57 +04:00
if (!tagFound) // new session
2013-11-25 03:10:27 +04:00
{
2016-07-28 17:02:26 +03:00
LogPrint (eLogInfo, "Garlic: No tags available, will use ElGamal");
if (!m_Destination)
2014-07-28 19:54:34 +04:00
{
2015-12-18 09:59:43 +03:00
LogPrint (eLogError, "Garlic: Can't use ElGamal for unknown destination");
2014-07-28 19:54:34 +04:00
return nullptr;
}
2013-11-25 03:10:27 +04:00
// create ElGamal block
ElGamalBlock elGamal;
2018-01-06 06:48:51 +03:00
memcpy (elGamal.sessionKey, m_SessionKey, 32);
2015-11-03 17:15:49 +03:00
RAND_bytes (elGamal.preIV, 32); // Pre-IV
2013-11-25 03:10:27 +04:00
uint8_t iv[32]; // IV is first 16 bytes
2018-01-06 06:48:51 +03:00
SHA256(elGamal.preIV, 32, iv);
2017-03-14 19:03:51 +03:00
BN_CTX * ctx = BN_CTX_new ();
m_Destination->Encrypt ((uint8_t *)&elGamal, buf, ctx);
2018-01-06 06:48:51 +03:00
BN_CTX_free (ctx);
2014-05-12 06:37:33 +04:00
m_Encryption.SetIV (iv);
2014-01-18 19:34:57 +04:00
buf += 514;
2018-01-06 06:48:51 +03:00
len += 514;
2013-11-25 03:10:27 +04:00
}
else // existing session
2018-01-06 06:48:51 +03:00
{
2013-11-25 03:10:27 +04:00
// session tag
2018-01-06 06:48:51 +03:00
memcpy (buf, tag, 32);
2013-11-25 03:10:27 +04:00
uint8_t iv[32]; // IV is first 16 bytes
2015-11-03 17:15:49 +03:00
SHA256(tag, 32, iv);
2014-05-12 06:37:33 +04:00
m_Encryption.SetIV (iv);
2014-01-18 19:34:57 +04:00
buf += 32;
2018-01-06 06:48:51 +03:00
len += 32;
}
2014-01-18 19:34:57 +04:00
// AES block
2015-11-03 17:15:49 +03:00
len += CreateAESBlock (buf, msg);
htobe32buf (m->GetPayload (), len);
2013-11-25 03:10:27 +04:00
m->len += len + 4;
m->FillI2NPMessageHeader (eI2NPGarlic);
2013-11-25 03:10:27 +04:00
return m;
2018-01-06 06:48:51 +03:00
}
2013-11-25 03:10:27 +04:00
size_t ElGamalAESSession::CreateAESBlock (uint8_t * buf, std::shared_ptr<const I2NPMessage> msg)
2013-11-25 03:10:27 +04:00
{
2013-11-24 01:35:15 +04:00
size_t blockSize = 0;
bool createNewTags = GetOwner () && m_NumTags && ((int)m_SessionTags.size () <= m_NumTags*2/3);
2014-10-17 04:12:46 +04:00
UnconfirmedTags * newTags = createNewTags ? GenerateSessionTags () : nullptr;
htobuf16 (buf, newTags ? htobe16 (newTags->numTags) : 0); // tag count
2013-11-24 01:35:15 +04:00
blockSize += 2;
2014-10-17 04:12:46 +04:00
if (newTags) // session tags recreated
2018-01-06 06:48:51 +03:00
{
2014-10-17 04:12:46 +04:00
for (int i = 0; i < newTags->numTags; i++)
2014-07-28 20:02:50 +04:00
{
2014-10-17 04:12:46 +04:00
memcpy (buf + blockSize, newTags->sessionTags[i], 32); // tags
2014-07-28 20:02:50 +04:00
blockSize += 32;
}
2018-01-06 06:48:51 +03:00
}
2013-11-24 01:35:15 +04:00
uint32_t * payloadSize = (uint32_t *)(buf + blockSize);
blockSize += 4;
uint8_t * payloadHash = buf + blockSize;
blockSize += 32;
buf[blockSize] = 0; // flag
blockSize++;
2014-10-17 04:12:46 +04:00
size_t len = CreateGarlicPayload (buf + blockSize, msg, newTags);
2014-12-31 17:14:53 +03:00
htobe32buf (payloadSize, len);
2015-11-03 17:15:49 +03:00
SHA256(buf + blockSize, len, payloadHash);
2013-11-24 01:35:15 +04:00
blockSize += len;
size_t rem = blockSize % 16;
if (rem)
blockSize += (16-rem); //padding
2014-05-12 06:37:33 +04:00
m_Encryption.Encrypt(buf, blockSize, buf);
2013-11-25 03:10:27 +04:00
return blockSize;
2018-01-06 06:48:51 +03:00
}
2013-11-24 01:35:15 +04:00
size_t ElGamalAESSession::CreateGarlicPayload (uint8_t * payload, std::shared_ptr<const I2NPMessage> msg, UnconfirmedTags * newTags)
2013-11-24 01:35:15 +04:00
{
uint64_t ts = i2p::util::GetMillisecondsSinceEpoch ();
2015-11-03 17:15:49 +03:00
uint32_t msgID;
RAND_bytes ((uint8_t *)&msgID, 4);
2013-11-24 01:35:15 +04:00
size_t size = 0;
2013-12-31 05:46:33 +04:00
uint8_t * numCloves = payload + size;
*numCloves = 0;
2013-11-24 01:35:15 +04:00
size++;
2014-01-17 17:12:57 +04:00
if (GetOwner ())
2018-01-06 06:48:51 +03:00
{
2015-03-22 21:59:27 +03:00
// resubmit non-confirmed LeaseSet
if (GetLeaseSetUpdateStatus () == eLeaseSetSubmitted && ts > GetLeaseSetSubmissionTime () + LEASET_CONFIRMATION_TIMEOUT)
{
SetLeaseSetUpdateStatus (eLeaseSetUpdated);
SetSharedRoutingPath (nullptr); // invalidate path since leaseset was not confirmed
}
2015-03-22 21:59:27 +03:00
// attach DeviveryStatus if necessary
if (newTags || GetLeaseSetUpdateStatus () == eLeaseSetUpdated) // new tags created or leaseset updated
{
2018-01-06 06:48:51 +03:00
// clove is DeliveryStatus
2015-06-04 18:31:22 +03:00
auto cloveSize = CreateDeliveryStatusClove (payload + size, msgID);
if (cloveSize > 0) // successive?
{
2015-06-04 18:31:22 +03:00
size += cloveSize;
(*numCloves)++;
2015-03-22 21:59:27 +03:00
if (newTags) // new tags created
2016-07-08 05:39:20 +03:00
{
newTags->msgID = msgID;
2016-11-20 16:33:33 +03:00
m_UnconfirmedTagsMsgs.insert (std::make_pair(msgID, std::unique_ptr<UnconfirmedTags>(newTags)));
2016-11-16 20:10:13 +03:00
newTags = nullptr; // got acquired
2018-01-06 06:48:51 +03:00
}
GetOwner ()->DeliveryStatusSent (shared_from_this (), msgID);
}
else
2015-12-18 09:59:43 +03:00
LogPrint (eLogWarning, "Garlic: DeliveryStatus clove was not created");
2018-01-06 06:48:51 +03:00
}
2015-03-22 21:59:27 +03:00
// attach LeaseSet
if (GetLeaseSetUpdateStatus () == eLeaseSetUpdated)
{
if (GetLeaseSetUpdateMsgID ()) GetOwner ()->RemoveDeliveryStatusSession (GetLeaseSetUpdateMsgID ()); // remove previous
SetLeaseSetUpdateStatus (eLeaseSetSubmitted);
SetLeaseSetUpdateMsgID (msgID);
SetLeaseSetSubmissionTime (ts);
// clove if our leaseSet must be attached
auto leaseSet = CreateDatabaseStoreMsg (GetOwner ()->GetLeaseSet ());
2018-01-06 06:48:51 +03:00
size += CreateGarlicClove (payload + size, leaseSet, false);
(*numCloves)++;
}
2018-01-06 06:48:51 +03:00
}
2014-01-09 07:47:22 +04:00
if (msg) // clove message ifself if presented
2018-01-06 06:48:51 +03:00
{
size += CreateGarlicClove (payload + size, msg, m_Destination ? m_Destination->IsDestination () : false);
2013-12-31 05:46:33 +04:00
(*numCloves)++;
2018-01-06 06:48:51 +03:00
}
2013-12-31 05:46:33 +04:00
memset (payload + size, 0, 3); // certificate of message
size += 3;
htobe32buf (payload + size, msgID); // MessageID
2013-12-31 05:46:33 +04:00
size += 4;
htobe64buf (payload + size, ts + 8000); // Expiration of message, 8 sec
2013-12-31 05:46:33 +04:00
size += 8;
2018-01-06 06:48:51 +03:00
if (newTags) delete newTags; // not acquired, delete
2013-12-31 05:46:33 +04:00
return size;
2018-01-06 06:48:51 +03:00
}
2013-12-31 05:46:33 +04:00
size_t ElGamalAESSession::CreateGarlicClove (uint8_t * buf, std::shared_ptr<const I2NPMessage> msg, bool isDestination)
2013-12-31 05:46:33 +04:00
{
uint64_t ts = i2p::util::GetMillisecondsSinceEpoch () + 8000; // 8 sec
2013-12-31 05:46:33 +04:00
size_t size = 0;
2016-12-13 20:45:18 +03:00
if (isDestination)
{
2013-12-31 05:46:33 +04:00
buf[size] = eGarlicDeliveryTypeDestination << 5;// delivery instructions flag destination
size++;
memcpy (buf + size, m_Destination->GetIdentHash (), 32);
size += 32;
2018-01-06 06:48:51 +03:00
}
else
{
2013-12-31 05:46:33 +04:00
buf[size] = 0;// delivery instructions flag local
size++;
}
2018-01-06 06:48:51 +03:00
2013-12-31 05:46:33 +04:00
memcpy (buf + size, msg->GetBuffer (), msg->GetLength ());
2013-11-24 01:35:15 +04:00
size += msg->GetLength ();
2015-11-03 17:15:49 +03:00
uint32_t cloveID;
RAND_bytes ((uint8_t *)&cloveID, 4);
htobe32buf (buf + size, cloveID); // CloveID
2013-11-24 01:35:15 +04:00
size += 4;
htobe64buf (buf + size, ts); // Expiration of clove
2013-11-24 01:35:15 +04:00
size += 8;
2013-12-31 05:46:33 +04:00
memset (buf + size, 0, 3); // certificate of clove
2013-11-24 01:35:15 +04:00
size += 3;
return size;
2018-01-06 06:48:51 +03:00
}
2014-01-09 07:47:22 +04:00
size_t ElGamalAESSession::CreateDeliveryStatusClove (uint8_t * buf, uint32_t msgID)
2018-01-06 06:48:51 +03:00
{
2014-01-09 07:47:22 +04:00
size_t size = 0;
if (GetOwner ())
{
auto inboundTunnel = GetOwner ()->GetTunnelPool ()->GetNextInboundTunnel ();
if (inboundTunnel)
2018-01-06 06:48:51 +03:00
{
buf[size] = eGarlicDeliveryTypeTunnel << 5; // delivery instructions flag tunnel
size++;
2018-01-06 06:48:51 +03:00
// hash and tunnelID sequence is reversed for Garlic
memcpy (buf + size, inboundTunnel->GetNextIdentHash (), 32); // To Hash
size += 32;
htobe32buf (buf + size, inboundTunnel->GetNextTunnelID ()); // tunnelID
2018-01-06 06:48:51 +03:00
size += 4;
// create msg
2020-03-09 01:13:41 +03:00
auto msg = CreateEncryptedDeliveryStatusMsg (msgID);
if (msg)
{
2020-03-09 01:13:41 +03:00
memcpy (buf + size, msg->GetBuffer (), msg->GetLength ());
size += msg->GetLength ();
}
// fill clove
uint64_t ts = i2p::util::GetMillisecondsSinceEpoch () + 8000; // 8 sec
2015-11-03 17:15:49 +03:00
uint32_t cloveID;
RAND_bytes ((uint8_t *)&cloveID, 4);
htobe32buf (buf + size, cloveID); // CloveID
size += 4;
htobe64buf (buf + size, ts); // Expiration of clove
size += 8;
memset (buf + size, 0, 3); // certificate of clove
size += 3;
}
2018-01-06 06:48:51 +03:00
else
2015-12-18 09:59:43 +03:00
LogPrint (eLogError, "Garlic: No inbound tunnels in the pool for DeliveryStatus");
2014-01-09 07:47:22 +04:00
}
else
2015-12-18 09:59:43 +03:00
LogPrint (eLogWarning, "Garlic: Missing local LeaseSet");
2014-01-09 07:47:22 +04:00
return size;
}
ElGamalAESSession::UnconfirmedTags * ElGamalAESSession::GenerateSessionTags ()
{
auto tags = new UnconfirmedTags (m_NumTags);
tags->tagsCreationTime = i2p::util::GetSecondsSinceEpoch ();
for (int i = 0; i < m_NumTags; i++)
{
RAND_bytes (tags->sessionTags[i], 32);
tags->sessionTags[i].creationTime = tags->tagsCreationTime;
}
return tags;
}
2020-03-09 01:13:41 +03:00
bool ElGamalAESSession::MessageConfirmed (uint32_t msgID)
{
TagsConfirmed (msgID);
2020-03-09 01:13:41 +03:00
if (!GarlicRoutingSession::MessageConfirmed (msgID))
CleanupExpiredTags ();
2020-03-09 01:13:41 +03:00
return true;
}
void ElGamalAESSession::TagsConfirmed (uint32_t msgID)
{
uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
auto it = m_UnconfirmedTagsMsgs.find (msgID);
if (it != m_UnconfirmedTagsMsgs.end ())
{
auto& tags = it->second;
if (ts < tags->tagsCreationTime + OUTGOING_TAGS_EXPIRATION_TIMEOUT)
{
for (int i = 0; i < tags->numTags; i++)
m_SessionTags.push_back (tags->sessionTags[i]);
}
m_UnconfirmedTagsMsgs.erase (it);
}
}
bool ElGamalAESSession::CleanupExpiredTags ()
{
auto ts = i2p::util::GetSecondsSinceEpoch ();
for (auto it = m_SessionTags.begin (); it != m_SessionTags.end ();)
{
if (ts >= it->creationTime + OUTGOING_TAGS_EXPIRATION_TIMEOUT)
it = m_SessionTags.erase (it);
else
++it;
}
CleanupUnconfirmedTags ();
CleanupUnconfirmedLeaseSet (ts);
return !m_SessionTags.empty () || !m_UnconfirmedTagsMsgs.empty ();
}
bool ElGamalAESSession::CleanupUnconfirmedTags ()
{
bool ret = false;
uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
// delete expired unconfirmed tags
for (auto it = m_UnconfirmedTagsMsgs.begin (); it != m_UnconfirmedTagsMsgs.end ();)
{
if (ts >= it->second->tagsCreationTime + OUTGOING_TAGS_CONFIRMATION_TIMEOUT)
{
if (GetOwner ())
GetOwner ()->RemoveDeliveryStatusSession (it->first);
it = m_UnconfirmedTagsMsgs.erase (it);
ret = true;
}
else
++it;
}
return ret;
}
GarlicDestination::GarlicDestination (): m_NumTags (32) // 32 tags by default
{
m_Ctx = BN_CTX_new ();
2018-01-06 06:48:51 +03:00
}
GarlicDestination::~GarlicDestination ()
2013-11-25 03:10:27 +04:00
{
BN_CTX_free (m_Ctx);
}
2016-11-29 06:47:37 +03:00
void GarlicDestination::CleanUp ()
2018-01-06 06:48:51 +03:00
{
2016-11-29 06:47:37 +03:00
m_Sessions.clear ();
m_DeliveryStatusSessions.clear ();
m_Tags.clear ();
2020-02-05 23:48:51 +03:00
m_ECIESx25519Sessions.clear ();
m_ECIESx25519Tags.clear ();
2018-01-06 06:48:51 +03:00
}
void GarlicDestination::AddSessionKey (const uint8_t * key, const uint8_t * tag)
{
if (key)
{
2014-11-19 22:56:47 +03:00
uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
2017-04-03 22:05:10 +03:00
m_Tags[SessionTag(tag, ts)] = std::make_shared<AESDecryption>(key);
}
}
2018-01-06 06:48:51 +03:00
bool GarlicDestination::SubmitSessionKey (const uint8_t * key, const uint8_t * tag)
{
AddSessionKey (key, tag);
return true;
}
2015-06-16 17:14:14 +03:00
void GarlicDestination::HandleGarlicMessage (std::shared_ptr<I2NPMessage> msg)
{
uint8_t * buf = msg->GetPayload ();
uint32_t length = bufbe32toh (buf);
2015-05-18 02:40:46 +03:00
if (length > msg->GetLength ())
{
2015-12-18 09:59:43 +03:00
LogPrint (eLogWarning, "Garlic: message length ", length, " exceeds I2NP message length ", msg->GetLength ());
2015-05-18 02:40:46 +03:00
return;
2018-01-06 06:48:51 +03:00
}
auto mod = length & 0x0f; // %16
2014-11-19 22:56:47 +03:00
buf += 4; // length
auto it = !mod ? m_Tags.find (SessionTag(buf)) : m_Tags.end (); // AES block is multiple of 16
2020-01-02 21:30:54 +03:00
// AES tag might be used even if encryption type is not ElGamal/AES
if (it != m_Tags.end ())
{
// tag found. Use AES
2017-04-15 05:08:43 +03:00
auto decryption = it->second;
2018-01-06 06:48:51 +03:00
m_Tags.erase (it); // tag might be used only once
2015-05-18 02:40:46 +03:00
if (length >= 32)
2018-01-06 06:48:51 +03:00
{
2015-05-18 02:40:46 +03:00
uint8_t iv[32]; // IV is first 16 bytes
2015-11-03 17:15:49 +03:00
SHA256(buf, 32, iv);
2017-04-15 05:08:43 +03:00
decryption->SetIV (iv);
decryption->Decrypt (buf + 32, length - 32, buf + 32);
HandleAESBlock (buf + 32, length - 32, decryption, msg->from);
2018-01-06 06:48:51 +03:00
}
2015-05-18 02:40:46 +03:00
else
2015-12-18 09:59:43 +03:00
LogPrint (eLogWarning, "Garlic: message length ", length, " is less than 32 bytes");
}
else
{
2020-04-21 02:37:46 +03:00
bool found = false;
if (SupportsEncryptionType (i2p::data::CRYPTO_KEY_TYPE_ECIES_X25519_AEAD_RATCHET))
2018-01-06 06:48:51 +03:00
{
2020-04-21 02:37:46 +03:00
// try ECIESx25519 tag
uint64_t tag;
memcpy (&tag, buf, 8);
auto it1 = m_ECIESx25519Tags.find (tag);
if (it1 != m_ECIESx25519Tags.end ())
{
found = true;
2020-04-24 22:46:02 +03:00
auto session = it1->second.tagset->GetSession ();
2020-04-25 04:36:08 +03:00
if (!session || !session->HandleNextMessage (buf, length, it1->second.tagset, it1->second.index))
LogPrint (eLogError, "Garlic: can't handle ECIES-X25519-AEAD-Ratchet message");
2020-04-21 02:37:46 +03:00
m_ECIESx25519Tags.erase (it1);
}
}
if (!found) // assume new session
2020-04-21 02:37:46 +03:00
{
// AES tag not found. Handle depending on encryption type
// try ElGamal/AES first if leading block is 514
2020-04-21 02:37:46 +03:00
ElGamalBlock elGamal;
if (mod == 2 && length >= 514 && SupportsEncryptionType (i2p::data::CRYPTO_KEY_TYPE_ELGAMAL) &&
Decrypt (buf, (uint8_t *)&elGamal, m_Ctx, i2p::data::CRYPTO_KEY_TYPE_ELGAMAL))
{
auto decryption = std::make_shared<AESDecryption>(elGamal.sessionKey);
uint8_t iv[32]; // IV is first 16 bytes
SHA256(elGamal.preIV, 32, iv);
decryption->SetIV (iv);
decryption->Decrypt(buf + 514, length - 514, buf + 514);
HandleAESBlock (buf + 514, length - 514, decryption, msg->from);
}
else if (SupportsEncryptionType (i2p::data::CRYPTO_KEY_TYPE_ECIES_X25519_AEAD_RATCHET))
{
// otherwise ECIESx25519
2020-04-21 02:37:46 +03:00
auto session = std::make_shared<ECIESX25519AEADRatchetSession> (this, false); // incoming
2020-04-25 04:36:08 +03:00
if (!session->HandleNextMessage (buf, length, nullptr, 0))
LogPrint (eLogError, "Garlic: can't handle ECIES-X25519-AEAD-Ratchet message");
}
2020-04-21 02:37:46 +03:00
else
LogPrint (eLogError, "Garlic: Failed to decrypt message");
2018-01-06 06:48:51 +03:00
}
}
2018-01-06 06:48:51 +03:00
}
2014-01-18 19:34:57 +04:00
2017-04-03 22:05:10 +03:00
void GarlicDestination::HandleAESBlock (uint8_t * buf, size_t len, std::shared_ptr<AESDecryption> decryption,
2015-02-06 02:53:43 +03:00
std::shared_ptr<i2p::tunnel::InboundTunnel> from)
{
uint16_t tagCount = bufbe16toh (buf);
2018-01-06 06:48:51 +03:00
buf += 2; len -= 2;
if (tagCount > 0)
2018-01-06 06:48:51 +03:00
{
if (tagCount*32 > len)
2014-12-08 05:00:19 +03:00
{
2015-12-18 09:59:43 +03:00
LogPrint (eLogError, "Garlic: Tag count ", tagCount, " exceeds length ", len);
return ;
2018-01-06 06:48:51 +03:00
}
2014-10-17 19:26:57 +04:00
uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
for (int i = 0; i < tagCount; i++)
2018-01-06 06:48:51 +03:00
m_Tags[SessionTag(buf + i*32, ts)] = decryption;
}
buf += tagCount*32;
2014-12-08 05:00:19 +03:00
len -= tagCount*32;
uint32_t payloadSize = bufbe32toh (buf);
if (payloadSize > len)
{
2015-12-18 09:59:43 +03:00
LogPrint (eLogError, "Garlic: Unexpected payload size ", payloadSize);
return;
2018-01-06 06:48:51 +03:00
}
buf += 4;
uint8_t * payloadHash = buf;
2018-01-06 06:48:51 +03:00
buf += 32;// payload hash.
if (*buf) // session key?
buf += 32; // new session key
buf++; // flag
// payload
2015-11-03 17:15:49 +03:00
uint8_t digest[32];
SHA256 (buf, payloadSize, digest);
if (memcmp (payloadHash, digest, 32)) // payload hash doesn't match
{
2015-12-18 09:59:43 +03:00
LogPrint (eLogError, "Garlic: wrong payload hash");
return;
2018-01-06 06:48:51 +03:00
}
HandleGarlicPayload (buf, payloadSize, from);
2018-01-06 06:48:51 +03:00
}
2015-02-06 02:53:43 +03:00
void GarlicDestination::HandleGarlicPayload (uint8_t * buf, size_t len, std::shared_ptr<i2p::tunnel::InboundTunnel> from)
{
2017-12-01 20:57:05 +03:00
if (len < 1)
{
LogPrint (eLogError, "Garlic: payload is too short");
return;
}
int numCloves = buf[0];
2015-12-18 09:59:43 +03:00
LogPrint (eLogDebug, "Garlic: ", numCloves," cloves");
2017-12-01 20:57:05 +03:00
buf++; len--;
for (int i = 0; i < numCloves; i++)
{
2017-12-01 20:57:05 +03:00
const uint8_t * buf1 = buf;
// delivery instructions
uint8_t flag = buf[0];
buf++; // flag
if (flag & 0x80) // encrypted?
{
// TODO: implement
2015-12-18 09:59:43 +03:00
LogPrint (eLogWarning, "Garlic: clove encrypted");
2018-01-06 06:48:51 +03:00
buf += 32;
}
2017-12-01 20:57:05 +03:00
ptrdiff_t offset = buf - buf1;
GarlicDeliveryType deliveryType = (GarlicDeliveryType)((flag >> 5) & 0x03);
switch (deliveryType)
{
case eGarlicDeliveryTypeLocal:
2015-12-18 09:59:43 +03:00
LogPrint (eLogDebug, "Garlic: type local");
2017-12-01 20:57:05 +03:00
if (offset > (int)len)
{
LogPrint (eLogError, "Garlic: message is too short");
break;
2018-01-06 06:48:51 +03:00
}
2020-01-07 23:20:55 +03:00
HandleI2NPMessage (buf, len - offset);
2018-01-06 06:48:51 +03:00
break;
case eGarlicDeliveryTypeDestination:
2015-12-18 09:59:43 +03:00
LogPrint (eLogDebug, "Garlic: type destination");
buf += 32; // destination. check it later or for multiple destinations
2018-01-03 20:52:29 +03:00
offset = buf - buf1;
2017-12-01 20:57:05 +03:00
if (offset > (int)len)
{
LogPrint (eLogError, "Garlic: message is too short");
break;
2018-01-06 06:48:51 +03:00
}
2020-01-07 23:20:55 +03:00
HandleI2NPMessage (buf, len - offset);
2014-10-12 05:27:55 +04:00
break;
case eGarlicDeliveryTypeTunnel:
2018-01-06 06:48:51 +03:00
{
2015-12-18 09:59:43 +03:00
LogPrint (eLogDebug, "Garlic: type tunnel");
// gwHash and gwTunnel sequence is reverted
uint8_t * gwHash = buf;
buf += 32;
2018-01-03 20:52:29 +03:00
offset = buf - buf1;
2017-12-01 20:57:05 +03:00
if (offset + 4 > (int)len)
{
LogPrint (eLogError, "Garlic: message is too short");
break;
}
uint32_t gwTunnel = bufbe32toh (buf);
2017-12-01 20:57:05 +03:00
buf += 4; offset += 4;
auto msg = CreateI2NPMessage (buf, GetI2NPMessageLength (buf, len - offset), from);
if (from) // received through an inbound tunnel
{
std::shared_ptr<i2p::tunnel::OutboundTunnel> tunnel;
if (from->GetTunnelPool ())
tunnel = from->GetTunnelPool ()->GetNextOutboundTunnel ();
else
LogPrint (eLogError, "Garlic: Tunnel pool is not set for inbound tunnel");
2019-04-08 22:22:42 +03:00
if (tunnel) // we have sent it through an outbound tunnel
tunnel->SendTunnelDataMsg (gwHash, gwTunnel, msg);
else
LogPrint (eLogWarning, "Garlic: No outbound tunnels available for garlic clove");
}
else // received directly
i2p::transport::transports.SendMessage (gwHash, i2p::CreateTunnelGatewayMsg (gwTunnel, msg)); // send directly
break;
}
case eGarlicDeliveryTypeRouter:
{
uint8_t * ident = buf;
buf += 32;
2018-01-06 06:48:51 +03:00
offset = buf - buf1;
if (!from) // received directly
2017-12-01 20:57:05 +03:00
{
if (offset > (int)len)
{
LogPrint (eLogError, "Garlic: message is too short");
break;
}
i2p::transport::transports.SendMessage (ident,
2017-12-01 20:57:05 +03:00
CreateI2NPMessage (buf, GetI2NPMessageLength (buf, len - offset)));
}
else
LogPrint (eLogWarning, "Garlic: type router for inbound tunnels not supported");
2018-01-06 06:48:51 +03:00
break;
}
default:
2015-12-18 09:59:43 +03:00
LogPrint (eLogWarning, "Garlic: unknown delivery type ", (int)deliveryType);
}
2017-12-01 20:57:05 +03:00
if (offset > (int)len)
{
LogPrint (eLogError, "Garlic: message is too short");
break;
}
buf += GetI2NPMessageLength (buf, len - offset); // I2NP
buf += 4; // CloveID
buf += 8; // Date
buf += 3; // Certificate
2018-01-03 20:52:29 +03:00
offset = buf - buf1;
2017-12-01 20:57:05 +03:00
if (offset > (int)len)
2015-04-22 01:59:35 +03:00
{
2015-12-18 09:59:43 +03:00
LogPrint (eLogError, "Garlic: clove is too long");
2015-04-22 01:59:35 +03:00
break;
2018-01-06 06:48:51 +03:00
}
2017-12-01 20:57:05 +03:00
len -= offset;
2018-01-06 06:48:51 +03:00
}
}
std::shared_ptr<I2NPMessage> GarlicDestination::WrapMessage (std::shared_ptr<const i2p::data::RoutingDestination> destination,
std::shared_ptr<I2NPMessage> msg, bool attachLeaseSet)
{
2018-01-06 06:48:51 +03:00
auto session = GetRoutingSession (destination, attachLeaseSet);
return session->WrapSingleMessage (msg);
}
2015-01-22 23:31:34 +03:00
std::shared_ptr<GarlicRoutingSession> GarlicDestination::GetRoutingSession (
2015-04-06 03:07:32 +03:00
std::shared_ptr<const i2p::data::RoutingDestination> destination, bool attachLeaseSet)
2013-11-25 03:10:27 +04:00
{
if (destination->GetEncryptionType () == i2p::data::CRYPTO_KEY_TYPE_ECIES_X25519_AEAD_RATCHET &&
SupportsEncryptionType (i2p::data::CRYPTO_KEY_TYPE_ECIES_X25519_AEAD_RATCHET))
{
ECIESX25519AEADRatchetSessionPtr session;
uint8_t staticKey[32];
destination->Encrypt (nullptr, staticKey, nullptr); // we are supposed to get static key
auto it = m_ECIESx25519Sessions.find (staticKey);
if (it != m_ECIESx25519Sessions.end ())
{
session = it->second;
if (session->IsInactive (i2p::util::GetSecondsSinceEpoch ()))
{
LogPrint (eLogDebug, "Garlic: session restarted");
session = nullptr;
}
}
if (!session)
{
session = std::make_shared<ECIESX25519AEADRatchetSession> (this, true);
session->SetRemoteStaticKey (staticKey);
}
2020-01-30 19:48:32 +03:00
session->SetDestination (destination->GetIdentHash ()); // TODO: remove
return session;
}
else
{
ElGamalAESSessionPtr session;
{
std::unique_lock<std::mutex> l(m_SessionsMutex);
auto it = m_Sessions.find (destination->GetIdentHash ());
if (it != m_Sessions.end ())
session = it->second;
}
if (!session)
{
session = std::make_shared<ElGamalAESSession> (this, destination,
attachLeaseSet ? m_NumTags : 4, attachLeaseSet); // specified num tags for connections and 4 for LS requests
std::unique_lock<std::mutex> l(m_SessionsMutex);
m_Sessions[destination->GetIdentHash ()] = session;
}
return session;
}
2018-01-06 06:48:51 +03:00
}
void GarlicDestination::CleanupExpiredTags ()
2015-01-23 18:07:11 +03:00
{
// incoming
uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
int numExpiredTags = 0;
for (auto it = m_Tags.begin (); it != m_Tags.end ();)
{
if (ts > it->first.creationTime + INCOMING_TAGS_EXPIRATION_TIMEOUT)
{
numExpiredTags++;
it = m_Tags.erase (it);
2018-01-06 06:48:51 +03:00
}
else
2016-08-05 21:23:54 +03:00
++it;
}
if (numExpiredTags > 0)
LogPrint (eLogDebug, "Garlic: ", numExpiredTags, " tags expired for ", GetIdentHash().ToBase64 ());
// outgoing
2015-01-23 18:07:11 +03:00
{
std::unique_lock<std::mutex> l(m_SessionsMutex);
for (auto it = m_Sessions.begin (); it != m_Sessions.end ();)
2015-01-23 20:48:25 +03:00
{
it->second->GetSharedRoutingPath (); // delete shared path if necessary
if (!it->second->CleanupExpiredTags ())
{
LogPrint (eLogInfo, "Routing session to ", it->first.ToBase32 (), " deleted");
it->second->SetOwner (nullptr);
it = m_Sessions.erase (it);
}
else
++it;
2015-01-23 20:48:25 +03:00
}
}
// delivery status sessions
2018-01-06 06:48:51 +03:00
{
2016-11-18 19:16:55 +03:00
std::unique_lock<std::mutex> l(m_DeliveryStatusSessionsMutex);
for (auto it = m_DeliveryStatusSessions.begin (); it != m_DeliveryStatusSessions.end (); )
{
if (it->second->GetOwner () != this)
it = m_DeliveryStatusSessions.erase (it);
else
++it;
}
2018-01-06 06:48:51 +03:00
}
// ECIESx25519
for (auto it = m_ECIESx25519Tags.begin (); it != m_ECIESx25519Tags.end ();)
{
2020-05-01 04:27:35 +03:00
if (it->second.tagset->IsExpired (ts) || ts > it->second.creationTime + ECIESX25519_INCOMING_TAGS_EXPIRATION_TIMEOUT)
it = m_ECIESx25519Tags.erase (it);
else
++it;
}
for (auto it = m_ECIESx25519Sessions.begin (); it != m_ECIESx25519Sessions.end ();)
{
if (it->second->CheckExpired (ts))
{
it->second->SetOwner (nullptr);
it = m_ECIESx25519Sessions.erase (it);
}
else
++it;
}
2015-01-23 18:07:11 +03:00
}
2016-01-25 21:34:04 +03:00
void GarlicDestination::RemoveDeliveryStatusSession (uint32_t msgID)
2015-01-23 18:07:11 +03:00
{
2016-11-18 19:16:55 +03:00
std::unique_lock<std::mutex> l(m_DeliveryStatusSessionsMutex);
2016-01-25 21:34:04 +03:00
m_DeliveryStatusSessions.erase (msgID);
2015-01-23 18:07:11 +03:00
}
void GarlicDestination::DeliveryStatusSent (GarlicRoutingSessionPtr session, uint32_t msgID)
2014-08-30 06:10:00 +04:00
{
2016-11-18 19:16:55 +03:00
std::unique_lock<std::mutex> l(m_DeliveryStatusSessionsMutex);
2016-01-25 21:34:04 +03:00
m_DeliveryStatusSessions[msgID] = session;
2016-08-05 21:23:54 +03:00
}
2014-01-17 17:12:57 +04:00
2020-01-06 22:37:40 +03:00
void GarlicDestination::HandleDeliveryStatusMessage (uint32_t msgID)
2014-01-17 17:12:57 +04:00
{
2020-03-09 01:13:41 +03:00
GarlicRoutingSessionPtr session;
2014-01-17 17:12:57 +04:00
{
2016-11-18 19:16:55 +03:00
std::unique_lock<std::mutex> l(m_DeliveryStatusSessionsMutex);
2016-01-25 21:34:04 +03:00
auto it = m_DeliveryStatusSessions.find (msgID);
2016-08-05 21:23:54 +03:00
if (it != m_DeliveryStatusSessions.end ())
2014-08-31 16:56:03 +04:00
{
2016-11-18 19:16:55 +03:00
session = it->second;
2016-01-25 21:34:04 +03:00
m_DeliveryStatusSessions.erase (it);
2016-08-05 21:23:54 +03:00
}
2014-10-08 05:47:32 +04:00
}
2016-11-18 19:16:55 +03:00
if (session)
{
session->MessageConfirmed (msgID);
LogPrint (eLogDebug, "Garlic: message ", msgID, " acknowledged");
}
2014-10-08 05:47:32 +04:00
}
void GarlicDestination::SetLeaseSetUpdated ()
{
{
std::unique_lock<std::mutex> l(m_SessionsMutex);
for (auto& it: m_Sessions)
it.second->SetLeaseSetUpdated ();
}
for (auto& it: m_ECIESx25519Sessions)
it.second->SetLeaseSetUpdated ();
}
2015-06-16 17:14:14 +03:00
void GarlicDestination::ProcessGarlicMessage (std::shared_ptr<I2NPMessage> msg)
{
HandleGarlicMessage (msg);
}
2015-06-16 17:14:14 +03:00
void GarlicDestination::ProcessDeliveryStatusMessage (std::shared_ptr<I2NPMessage> msg)
{
2020-01-06 22:37:40 +03:00
uint32_t msgID = bufbe32toh (msg->GetPayload () + DELIVERY_STATUS_MSGID_OFFSET);
HandleDeliveryStatusMessage (msgID);
}
2017-04-03 22:05:10 +03:00
void GarlicDestination::SaveTags ()
{
if (m_Tags.empty ()) return;
std::string ident = GetIdentHash().ToBase32();
std::string path = i2p::fs::DataDirPath("tags", (ident + ".tags"));
2018-01-06 06:48:51 +03:00
std::ofstream f (path, std::ofstream::binary | std::ofstream::out | std::ofstream::trunc);
2017-04-03 22:05:10 +03:00
uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
// 4 bytes timestamp, 32 bytes tag, 32 bytes key
for (auto it: m_Tags)
{
if (ts < it.first.creationTime + INCOMING_TAGS_EXPIRATION_TIMEOUT)
{
f.write ((char *)&it.first.creationTime, 4);
f.write ((char *)it.first.data (), 32);
f.write ((char *)it.second->GetKey ().data (), 32);
2018-01-06 06:48:51 +03:00
}
2017-04-03 22:05:10 +03:00
}
}
void GarlicDestination::LoadTags ()
{
std::string ident = GetIdentHash().ToBase32();
std::string path = i2p::fs::DataDirPath("tags", (ident + ".tags"));
uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
2018-01-06 06:48:51 +03:00
if (ts < i2p::fs::GetLastUpdateTime (path) + INCOMING_TAGS_EXPIRATION_TIMEOUT)
2017-04-03 22:05:10 +03:00
{
// might contain non-expired tags
std::ifstream f (path, std::ifstream::binary);
2018-01-06 06:48:51 +03:00
if (f)
2017-04-03 22:05:10 +03:00
{
std::map<i2p::crypto::AESKey, std::shared_ptr<AESDecryption> > keys;
// 4 bytes timestamp, 32 bytes tag, 32 bytes key
while (!f.eof ())
{
uint32_t t;
uint8_t tag[32], key[32];
f.read ((char *)&t, 4); if (f.eof ()) break;
if (ts < t + INCOMING_TAGS_EXPIRATION_TIMEOUT)
{
f.read ((char *)tag, 32);
f.read ((char *)key, 32);
}
else
2018-01-06 06:48:51 +03:00
f.seekg (64, std::ios::cur); // skip
2017-04-03 22:05:10 +03:00
if (f.eof ()) break;
std::shared_ptr<AESDecryption> decryption;
auto it = keys.find (key);
if (it != keys.end ())
decryption = it->second;
else
decryption = std::make_shared<AESDecryption>(key);
m_Tags.insert (std::make_pair (SessionTag (tag, ts), decryption));
}
2018-01-06 06:48:51 +03:00
if (!m_Tags.empty ())
LogPrint (eLogInfo, "Garlic: ", m_Tags.size (), " tags loaded for ", ident);
2017-04-03 22:05:10 +03:00
}
}
2018-01-06 06:48:51 +03:00
i2p::fs::Remove (path);
2017-04-03 22:05:10 +03:00
}
void CleanUpTagsFiles ()
{
2018-01-06 06:48:51 +03:00
std::vector<std::string> files;
2017-04-03 22:05:10 +03:00
i2p::fs::ReadDir (i2p::fs::DataDirPath("tags"), files);
uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
for (auto it: files)
2017-04-03 22:05:10 +03:00
if (ts >= i2p::fs::GetLastUpdateTime (it) + INCOMING_TAGS_EXPIRATION_TIMEOUT)
i2p::fs::Remove (it);
}
void GarlicDestination::HandleECIESx25519GarlicClove (const uint8_t * buf, size_t len)
{
const uint8_t * buf1 = buf;
uint8_t flag = buf[0]; buf++; // flag
GarlicDeliveryType deliveryType = (GarlicDeliveryType)((flag >> 5) & 0x03);
switch (deliveryType)
{
case eGarlicDeliveryTypeDestination:
LogPrint (eLogDebug, "Garlic: type destination");
buf += 32; // TODO: check destination
#if (__cplusplus >= 201703L) // C++ 17 or higher
[[fallthrough]];
#endif
2020-02-29 17:21:50 +03:00
// no break here
case eGarlicDeliveryTypeLocal:
{
LogPrint (eLogDebug, "Garlic: type local");
I2NPMessageType typeID = (I2NPMessageType)(buf[0]); buf++; // typeid
buf += (4 + 4); // msgID + expiration
ptrdiff_t offset = buf - buf1;
if (offset <= (int)len)
HandleCloveI2NPMessage (typeID, buf, len - offset);
else
LogPrint (eLogError, "Garlic: clove is too long");
break;
}
case eGarlicDeliveryTypeTunnel:
{
LogPrint (eLogDebug, "Garlic: type tunnel");
// gwHash and gwTunnel sequence is reverted
const uint8_t * gwHash = buf;
buf += 32;
ptrdiff_t offset = buf - buf1;
if (offset + 13 > (int)len)
{
LogPrint (eLogError, "Garlic: message is too short");
break;
}
uint32_t gwTunnel = bufbe32toh (buf); buf += 4;
I2NPMessageType typeID = (I2NPMessageType)(buf[0]); buf++; // typeid
buf += (4 + 4); // msgID + expiration
offset += 13;
if (GetTunnelPool ())
{
auto tunnel = GetTunnelPool ()->GetNextOutboundTunnel ();
if (tunnel)
tunnel->SendTunnelDataMsg (gwHash, gwTunnel, CreateI2NPMessage (typeID, buf, len - offset));
else
LogPrint (eLogWarning, "Garlic: No outbound tunnels available for garlic clove");
}
else
LogPrint (eLogError, "Garlic: Tunnel pool is not set for inbound tunnel");
break;
}
default:
LogPrint (eLogWarning, "Garlic: unexpected delivery type ", (int)deliveryType);
}
}
2020-01-21 22:40:23 +03:00
void GarlicDestination::AddECIESx25519SessionNextTag (RatchetTagSetPtr tagset)
{
2020-04-24 22:46:02 +03:00
auto index = tagset->GetNextIndex ();
uint64_t tag = tagset->GetNextSessionTag ();
m_ECIESx25519Tags.emplace (tag, ECIESX25519AEADRatchetIndexTagset{index, tagset, i2p::util::GetSecondsSinceEpoch ()});
}
2020-01-29 20:54:26 +03:00
void GarlicDestination::AddECIESx25519Session (const uint8_t * staticKey, ECIESX25519AEADRatchetSessionPtr session)
{
i2p::data::Tag<32> staticKeyTag (staticKey);
auto it = m_ECIESx25519Sessions.find (staticKeyTag);
if (it != m_ECIESx25519Sessions.end ())
{
if (it->second->CanBeRestarted (i2p::util::GetSecondsSinceEpoch ()))
{
it->second->SetOwner (nullptr); // detach
m_ECIESx25519Sessions.erase (it);
}
else
{
LogPrint (eLogInfo, "Garlic: ECIESx25519 session with static key ", staticKeyTag.ToBase64 (), " already exists");
return;
}
}
m_ECIESx25519Sessions.emplace (staticKeyTag, session);
2020-01-29 20:54:26 +03:00
}
2020-05-05 20:01:23 +03:00
void GarlicDestination::RemoveECIESx25519Session (const uint8_t * staticKey)
{
auto it = m_ECIESx25519Sessions.find (staticKey);
if (it != m_ECIESx25519Sessions.end ())
{
it->second->SetOwner (nullptr);
m_ECIESx25519Sessions.erase (it);
}
}
2018-01-06 06:48:51 +03:00
}
2013-11-25 03:10:27 +04:00
}