mirror of
https://github.com/PurpleI2P/i2pd.git
synced 2024-11-17 21:26:04 +00:00
242 lines
8.9 KiB
C++
242 lines
8.9 KiB
C++
#ifndef I2NP_PROTOCOL_H__
|
|
#define I2NP_PROTOCOL_H__
|
|
|
|
#include <inttypes.h>
|
|
#include <set>
|
|
#include <cryptopp/sha.h>
|
|
#include <string.h>
|
|
#include "I2PEndian.h"
|
|
#include "Identity.h"
|
|
#include "RouterInfo.h"
|
|
#include "LeaseSet.h"
|
|
|
|
namespace i2p
|
|
{
|
|
// I2NP header
|
|
const size_t I2NP_HEADER_TYPEID_OFFSET = 0;
|
|
const size_t I2NP_HEADER_MSGID_OFFSET = I2NP_HEADER_TYPEID_OFFSET + 1;
|
|
const size_t I2NP_HEADER_EXPIRATION_OFFSET = I2NP_HEADER_MSGID_OFFSET + 4;
|
|
const size_t I2NP_HEADER_SIZE_OFFSET = I2NP_HEADER_EXPIRATION_OFFSET + 8;
|
|
const size_t I2NP_HEADER_CHKS_OFFSET = I2NP_HEADER_SIZE_OFFSET + 2;
|
|
const size_t I2NP_HEADER_SIZE = I2NP_HEADER_CHKS_OFFSET + 1;
|
|
|
|
// I2NP short header
|
|
const size_t I2NP_SHORT_HEADER_TYPEID_OFFSET = 0;
|
|
const size_t I2NP_SHORT_HEADER_EXPIRATION_OFFSET = I2NP_SHORT_HEADER_TYPEID_OFFSET + 1;
|
|
const size_t I2NP_SHORT_HEADER_SIZE = I2NP_SHORT_HEADER_EXPIRATION_OFFSET + 4;
|
|
|
|
// Tunnel Gateway header
|
|
const size_t TUNNEL_GATEWAY_HEADER_TUNNELID_OFFSET = 0;
|
|
const size_t TUNNEL_GATEWAY_HEADER_LENGTH_OFFSET = TUNNEL_GATEWAY_HEADER_TUNNELID_OFFSET + 4;
|
|
const size_t TUNNEL_GATEWAY_HEADER_SIZE = TUNNEL_GATEWAY_HEADER_LENGTH_OFFSET + 2;
|
|
|
|
#pragma pack (1)
|
|
|
|
struct I2NPDatabaseStoreMsg
|
|
{
|
|
uint8_t key[32];
|
|
uint8_t type;
|
|
uint32_t replyToken;
|
|
};
|
|
|
|
struct I2NPDeliveryStatusMsg
|
|
{
|
|
uint32_t msgID;
|
|
uint64_t timestamp;
|
|
};
|
|
|
|
struct I2NPBuildRequestRecordClearText
|
|
{
|
|
uint32_t receiveTunnel;
|
|
uint8_t ourIdent[32];
|
|
uint32_t nextTunnel;
|
|
uint8_t nextIdent[32];
|
|
uint8_t layerKey[32];
|
|
uint8_t ivKey[32];
|
|
uint8_t replyKey[32];
|
|
uint8_t replyIV[16];
|
|
uint8_t flag;
|
|
uint32_t requestTime;
|
|
uint32_t nextMessageID;
|
|
uint8_t filler[29];
|
|
};
|
|
|
|
struct I2NPBuildResponseRecord
|
|
{
|
|
uint8_t hash[32];
|
|
uint8_t padding[495];
|
|
uint8_t ret;
|
|
};
|
|
|
|
struct I2NPBuildRequestRecordElGamalEncrypted
|
|
{
|
|
uint8_t toPeer[16];
|
|
uint8_t encrypted[512];
|
|
};
|
|
|
|
#pragma pack ()
|
|
|
|
enum I2NPMessageType
|
|
{
|
|
eI2NPDatabaseStore = 1,
|
|
eI2NPDatabaseLookup = 2,
|
|
eI2NPDatabaseSearchReply = 3,
|
|
eI2NPDeliveryStatus = 10,
|
|
eI2NPGarlic = 11,
|
|
eI2NPTunnelData = 18,
|
|
eI2NPTunnelGateway = 19,
|
|
eI2NPData = 20,
|
|
eI2NPTunnelBuild = 21,
|
|
eI2NPTunnelBuildReply = 22,
|
|
eI2NPVariableTunnelBuild = 23,
|
|
eI2NPVariableTunnelBuildReply = 24
|
|
};
|
|
|
|
const int NUM_TUNNEL_BUILD_RECORDS = 8;
|
|
|
|
namespace tunnel
|
|
{
|
|
class InboundTunnel;
|
|
class TunnelPool;
|
|
}
|
|
|
|
const size_t I2NP_MAX_MESSAGE_SIZE = 32768;
|
|
const size_t I2NP_MAX_SHORT_MESSAGE_SIZE = 2400;
|
|
struct I2NPMessage
|
|
{
|
|
uint8_t * buf;
|
|
size_t len, offset, maxLen;
|
|
i2p::tunnel::InboundTunnel * from;
|
|
|
|
I2NPMessage (): buf (nullptr),len (I2NP_HEADER_SIZE + 2),
|
|
offset(2), maxLen (0), from (nullptr) {};
|
|
// reserve 2 bytes for NTCP header
|
|
// I2NPHeader * GetHeader () { return (I2NPHeader *)GetBuffer (); }; // depricated
|
|
// header accessors
|
|
uint8_t * GetHeaderBuffer () { return GetBuffer (); };
|
|
const uint8_t * GetHeaderBuffer () const { return GetBuffer (); };
|
|
void SetTypeID (uint8_t typeID) { GetHeaderBuffer ()[I2NP_HEADER_TYPEID_OFFSET] = typeID; };
|
|
uint8_t GetTypeID () const { return GetHeaderBuffer ()[I2NP_HEADER_TYPEID_OFFSET]; };
|
|
void SetMsgID (uint32_t msgID) { htobe32buf (GetHeaderBuffer () + I2NP_HEADER_MSGID_OFFSET, msgID); };
|
|
uint32_t GetMsgID () const { return bufbe32toh (GetHeaderBuffer () + I2NP_HEADER_MSGID_OFFSET); };
|
|
void SetExpiration (uint64_t expiration) { htobe64buf (GetHeaderBuffer () + I2NP_HEADER_EXPIRATION_OFFSET, expiration); };
|
|
uint64_t GetExpiration () const { return bufbe64toh (GetHeaderBuffer () + I2NP_HEADER_EXPIRATION_OFFSET); };
|
|
void SetSize (uint16_t size) { htobe16buf (GetHeaderBuffer () + I2NP_HEADER_SIZE_OFFSET, size); };
|
|
uint16_t GetSize () const { return bufbe16toh (GetHeaderBuffer () + I2NP_HEADER_SIZE_OFFSET); };
|
|
void UpdateSize () { SetSize (GetPayloadLength ()); };
|
|
void SetChks (uint8_t chks) { GetHeaderBuffer ()[I2NP_HEADER_CHKS_OFFSET] = chks; };
|
|
void UpdateChks ()
|
|
{
|
|
uint8_t hash[32];
|
|
CryptoPP::SHA256().CalculateDigest(hash, GetPayload (), GetPayloadLength ());
|
|
GetHeaderBuffer ()[I2NP_HEADER_CHKS_OFFSET] = hash[0];
|
|
}
|
|
|
|
// payload
|
|
uint8_t * GetPayload () { return GetBuffer () + I2NP_HEADER_SIZE; };
|
|
uint8_t * GetBuffer () { return buf + offset; };
|
|
const uint8_t * GetBuffer () const { return buf + offset; };
|
|
size_t GetLength () const { return len - offset; };
|
|
size_t GetPayloadLength () const { return GetLength () - I2NP_HEADER_SIZE; };
|
|
|
|
void Align (size_t alignment)
|
|
{
|
|
size_t rem = ((size_t)GetBuffer ()) % alignment;
|
|
if (rem)
|
|
{
|
|
offset += (alignment - rem);
|
|
len += (alignment - rem);
|
|
}
|
|
}
|
|
|
|
I2NPMessage& operator=(const I2NPMessage& other)
|
|
{
|
|
memcpy (buf + offset, other.buf + other.offset, other.GetLength ());
|
|
len = offset + other.GetLength ();
|
|
from = other.from;
|
|
return *this;
|
|
}
|
|
|
|
// for SSU only
|
|
uint8_t * GetSSUHeader () { return buf + offset + I2NP_HEADER_SIZE - I2NP_SHORT_HEADER_SIZE; };
|
|
void FromSSU (uint32_t msgID) // we have received SSU message and convert it to regular
|
|
{
|
|
const uint8_t * ssu = GetSSUHeader ();
|
|
GetHeaderBuffer ()[I2NP_HEADER_TYPEID_OFFSET] = ssu[I2NP_SHORT_HEADER_TYPEID_OFFSET]; // typeid
|
|
SetMsgID (msgID);
|
|
SetExpiration (bufbe32toh (ssu + I2NP_SHORT_HEADER_EXPIRATION_OFFSET)*1000LL);
|
|
SetSize (len - offset - I2NP_HEADER_SIZE);
|
|
SetChks (0);
|
|
}
|
|
uint32_t ToSSU () // return msgID
|
|
{
|
|
uint8_t header[I2NP_HEADER_SIZE];
|
|
memcpy (header, GetHeaderBuffer (), I2NP_HEADER_SIZE);
|
|
uint8_t * ssu = GetSSUHeader ();
|
|
ssu[I2NP_SHORT_HEADER_TYPEID_OFFSET] = header[I2NP_HEADER_TYPEID_OFFSET]; // typeid
|
|
htobe32buf (ssu + I2NP_SHORT_HEADER_EXPIRATION_OFFSET, bufbe64toh (header + I2NP_HEADER_EXPIRATION_OFFSET)/1000LL);
|
|
len = offset + I2NP_SHORT_HEADER_SIZE + bufbe16toh (header + I2NP_HEADER_SIZE_OFFSET);
|
|
return bufbe32toh (header + I2NP_HEADER_MSGID_OFFSET);
|
|
}
|
|
};
|
|
|
|
template<int sz>
|
|
struct I2NPMessageBuffer: public I2NPMessage
|
|
{
|
|
I2NPMessageBuffer () { buf = m_Buffer; maxLen = sz; };
|
|
uint8_t m_Buffer[sz];
|
|
};
|
|
|
|
I2NPMessage * NewI2NPMessage ();
|
|
I2NPMessage * NewI2NPShortMessage ();
|
|
I2NPMessage * NewI2NPMessage (size_t len);
|
|
void DeleteI2NPMessage (I2NPMessage * msg);
|
|
void FillI2NPMessageHeader (I2NPMessage * msg, I2NPMessageType msgType, uint32_t replyMsgID = 0);
|
|
void RenewI2NPMessageHeader (I2NPMessage * msg);
|
|
I2NPMessage * CreateI2NPMessage (I2NPMessageType msgType, const uint8_t * buf, int len, uint32_t replyMsgID = 0);
|
|
I2NPMessage * CreateI2NPMessage (const uint8_t * buf, int len, i2p::tunnel::InboundTunnel * from = nullptr);
|
|
|
|
I2NPMessage * CreateDeliveryStatusMsg (uint32_t msgID);
|
|
I2NPMessage * CreateDatabaseLookupMsg (const uint8_t * key, const uint8_t * from,
|
|
uint32_t replyTunnelID, bool exploratory = false,
|
|
std::set<i2p::data::IdentHash> * excludedPeers = nullptr, bool encryption = false,
|
|
i2p::tunnel::TunnelPool * pool = nullptr);
|
|
I2NPMessage * CreateLeaseSetDatabaseLookupMsg (const i2p::data::IdentHash& dest,
|
|
const std::set<i2p::data::IdentHash>& excludedFloodfills,
|
|
const i2p::tunnel::InboundTunnel * replyTunnel, const uint8_t * replyKey, const uint8_t * replyTag);
|
|
I2NPMessage * CreateDatabaseSearchReply (const i2p::data::IdentHash& ident, const i2p::data::RouterInfo * floodfill);
|
|
|
|
I2NPMessage * CreateDatabaseStoreMsg (const i2p::data::RouterInfo * router = nullptr);
|
|
I2NPMessage * CreateDatabaseStoreMsg (const i2p::data::LeaseSet * leaseSet, uint32_t replyToken = 0);
|
|
|
|
I2NPBuildRequestRecordClearText CreateBuildRequestRecord (
|
|
const uint8_t * ourIdent, uint32_t receiveTunnelID,
|
|
const uint8_t * nextIdent, uint32_t nextTunnelID,
|
|
const uint8_t * layerKey,const uint8_t * ivKey,
|
|
const uint8_t * replyKey, const uint8_t * replyIV, uint32_t nextMessageID,
|
|
bool isGateway, bool isEndpoint);
|
|
void EncryptBuildRequestRecord (const i2p::data::RouterInfo& router,
|
|
const I2NPBuildRequestRecordClearText& clearText,
|
|
I2NPBuildRequestRecordElGamalEncrypted& record);
|
|
|
|
bool HandleBuildRequestRecords (int num, I2NPBuildRequestRecordElGamalEncrypted * records, I2NPBuildRequestRecordClearText& clearText);
|
|
void HandleVariableTunnelBuildMsg (uint32_t replyMsgID, uint8_t * buf, size_t len);
|
|
void HandleVariableTunnelBuildReplyMsg (uint32_t replyMsgID, uint8_t * buf, size_t len);
|
|
void HandleTunnelBuildMsg (uint8_t * buf, size_t len);
|
|
|
|
I2NPMessage * CreateTunnelDataMsg (const uint8_t * buf);
|
|
I2NPMessage * CreateTunnelDataMsg (uint32_t tunnelID, const uint8_t * payload);
|
|
|
|
void HandleTunnelGatewayMsg (I2NPMessage * msg);
|
|
I2NPMessage * CreateTunnelGatewayMsg (uint32_t tunnelID, const uint8_t * buf, size_t len);
|
|
I2NPMessage * CreateTunnelGatewayMsg (uint32_t tunnelID, I2NPMessageType msgType,
|
|
const uint8_t * buf, size_t len, uint32_t replyMsgID = 0);
|
|
I2NPMessage * CreateTunnelGatewayMsg (uint32_t tunnelID, I2NPMessage * msg);
|
|
|
|
size_t GetI2NPMessageLength (const uint8_t * msg);
|
|
void HandleI2NPMessage (uint8_t * msg, size_t len);
|
|
void HandleI2NPMessage (I2NPMessage * msg);
|
|
}
|
|
|
|
#endif
|