1 /* 2 * Copyright (c) 2013-2021, The PurpleI2P Project 3 * 4 * This file is part of Purple i2pd project and licensed under BSD3 5 * 6 * See full license text in LICENSE file at top of project tree 7 */ 8 9 #ifndef I2NP_PROTOCOL_H__ 10 #define I2NP_PROTOCOL_H__ 11 12 #include <inttypes.h> 13 #include <string.h> 14 #include <set> 15 #include <memory> 16 #include "Crypto.h" 17 #include "I2PEndian.h" 18 #include "Identity.h" 19 #include "RouterInfo.h" 20 #include "LeaseSet.h" 21 22 namespace i2p 23 { 24 // I2NP header 25 const size_t I2NP_HEADER_TYPEID_OFFSET = 0; 26 const size_t I2NP_HEADER_MSGID_OFFSET = I2NP_HEADER_TYPEID_OFFSET + 1; 27 const size_t I2NP_HEADER_EXPIRATION_OFFSET = I2NP_HEADER_MSGID_OFFSET + 4; 28 const size_t I2NP_HEADER_SIZE_OFFSET = I2NP_HEADER_EXPIRATION_OFFSET + 8; 29 const size_t I2NP_HEADER_CHKS_OFFSET = I2NP_HEADER_SIZE_OFFSET + 2; 30 const size_t I2NP_HEADER_SIZE = I2NP_HEADER_CHKS_OFFSET + 1; 31 32 // I2NP short header 33 const size_t I2NP_SHORT_HEADER_TYPEID_OFFSET = 0; 34 const size_t I2NP_SHORT_HEADER_EXPIRATION_OFFSET = I2NP_SHORT_HEADER_TYPEID_OFFSET + 1; 35 const size_t I2NP_SHORT_HEADER_SIZE = I2NP_SHORT_HEADER_EXPIRATION_OFFSET + 4; 36 37 // I2NP NTCP2 header 38 const size_t I2NP_NTCP2_HEADER_SIZE = I2NP_HEADER_EXPIRATION_OFFSET + 4; 39 40 // Tunnel Gateway header 41 const size_t TUNNEL_GATEWAY_HEADER_TUNNELID_OFFSET = 0; 42 const size_t TUNNEL_GATEWAY_HEADER_LENGTH_OFFSET = TUNNEL_GATEWAY_HEADER_TUNNELID_OFFSET + 4; 43 const size_t TUNNEL_GATEWAY_HEADER_SIZE = TUNNEL_GATEWAY_HEADER_LENGTH_OFFSET + 2; 44 45 // DeliveryStatus 46 const size_t DELIVERY_STATUS_MSGID_OFFSET = 0; 47 const size_t DELIVERY_STATUS_TIMESTAMP_OFFSET = DELIVERY_STATUS_MSGID_OFFSET + 4; 48 const size_t DELIVERY_STATUS_SIZE = DELIVERY_STATUS_TIMESTAMP_OFFSET + 8; 49 50 // DatabaseStore 51 const size_t DATABASE_STORE_KEY_OFFSET = 0; 52 const size_t DATABASE_STORE_TYPE_OFFSET = DATABASE_STORE_KEY_OFFSET + 32; 53 const size_t DATABASE_STORE_REPLY_TOKEN_OFFSET = DATABASE_STORE_TYPE_OFFSET + 1; 54 const size_t DATABASE_STORE_HEADER_SIZE = DATABASE_STORE_REPLY_TOKEN_OFFSET + 4; 55 56 // TunnelBuild 57 const size_t TUNNEL_BUILD_RECORD_SIZE = 528; 58 const size_t SHORT_TUNNEL_BUILD_RECORD_SIZE = 218; 59 60 // BuildRequestRecordEncrypted 61 const size_t BUILD_REQUEST_RECORD_TO_PEER_OFFSET = 0; 62 const size_t BUILD_REQUEST_RECORD_ENCRYPTED_OFFSET = BUILD_REQUEST_RECORD_TO_PEER_OFFSET + 16; 63 64 // ECIES BuildRequestRecordClearText 65 const size_t ECIES_BUILD_REQUEST_RECORD_RECEIVE_TUNNEL_OFFSET = 0; 66 const size_t ECIES_BUILD_REQUEST_RECORD_NEXT_TUNNEL_OFFSET = ECIES_BUILD_REQUEST_RECORD_RECEIVE_TUNNEL_OFFSET + 4; 67 const size_t ECIES_BUILD_REQUEST_RECORD_NEXT_IDENT_OFFSET = ECIES_BUILD_REQUEST_RECORD_NEXT_TUNNEL_OFFSET + 4; 68 const size_t ECIES_BUILD_REQUEST_RECORD_LAYER_KEY_OFFSET = ECIES_BUILD_REQUEST_RECORD_NEXT_IDENT_OFFSET + 32; 69 const size_t ECIES_BUILD_REQUEST_RECORD_IV_KEY_OFFSET = ECIES_BUILD_REQUEST_RECORD_LAYER_KEY_OFFSET + 32; 70 const size_t ECIES_BUILD_REQUEST_RECORD_REPLY_KEY_OFFSET = ECIES_BUILD_REQUEST_RECORD_IV_KEY_OFFSET + 32; 71 const size_t ECIES_BUILD_REQUEST_RECORD_REPLY_IV_OFFSET = ECIES_BUILD_REQUEST_RECORD_REPLY_KEY_OFFSET + 32; 72 const size_t ECIES_BUILD_REQUEST_RECORD_FLAG_OFFSET = ECIES_BUILD_REQUEST_RECORD_REPLY_IV_OFFSET + 16; 73 const size_t ECIES_BUILD_REQUEST_RECORD_MORE_FLAGS_OFFSET = ECIES_BUILD_REQUEST_RECORD_FLAG_OFFSET + 1; 74 const size_t ECIES_BUILD_REQUEST_RECORD_REQUEST_TIME_OFFSET = ECIES_BUILD_REQUEST_RECORD_MORE_FLAGS_OFFSET + 3; 75 const size_t ECIES_BUILD_REQUEST_RECORD_REQUEST_EXPIRATION_OFFSET = ECIES_BUILD_REQUEST_RECORD_REQUEST_TIME_OFFSET + 4; 76 const size_t ECIES_BUILD_REQUEST_RECORD_SEND_MSG_ID_OFFSET = ECIES_BUILD_REQUEST_RECORD_REQUEST_EXPIRATION_OFFSET + 4; 77 const size_t ECIES_BUILD_REQUEST_RECORD_PADDING_OFFSET = ECIES_BUILD_REQUEST_RECORD_SEND_MSG_ID_OFFSET + 4; 78 const size_t ECIES_BUILD_REQUEST_RECORD_CLEAR_TEXT_SIZE = 464; 79 80 // ECIES BuildResponseRecord 81 const size_t ECIES_BUILD_RESPONSE_RECORD_OPTIONS_OFFSET = 0; 82 const size_t ECIES_BUILD_RESPONSE_RECORD_RET_OFFSET = 511; 83 84 // ShortRequestRecordClearText 85 const size_t SHORT_REQUEST_RECORD_ENCRYPTED_OFFSET = 16; 86 const size_t SHORT_REQUEST_RECORD_RECEIVE_TUNNEL_OFFSET = 0; 87 const size_t SHORT_REQUEST_RECORD_NEXT_TUNNEL_OFFSET = SHORT_REQUEST_RECORD_RECEIVE_TUNNEL_OFFSET + 4; 88 const size_t SHORT_REQUEST_RECORD_NEXT_IDENT_OFFSET = SHORT_REQUEST_RECORD_NEXT_TUNNEL_OFFSET + 4; 89 const size_t SHORT_REQUEST_RECORD_FLAG_OFFSET = SHORT_REQUEST_RECORD_NEXT_IDENT_OFFSET + 32; 90 const size_t SHORT_REQUEST_RECORD_MORE_FLAGS_OFFSET = SHORT_REQUEST_RECORD_FLAG_OFFSET + 1; 91 const size_t SHORT_REQUEST_RECORD_LAYER_ENCRYPTION_TYPE = SHORT_REQUEST_RECORD_MORE_FLAGS_OFFSET + 2; 92 const size_t SHORT_REQUEST_RECORD_REQUEST_TIME_OFFSET = SHORT_REQUEST_RECORD_LAYER_ENCRYPTION_TYPE + 1; 93 const size_t SHORT_REQUEST_RECORD_REQUEST_EXPIRATION_OFFSET = SHORT_REQUEST_RECORD_REQUEST_TIME_OFFSET + 4; 94 const size_t SHORT_REQUEST_RECORD_SEND_MSG_ID_OFFSET = SHORT_REQUEST_RECORD_REQUEST_EXPIRATION_OFFSET + 4; 95 const size_t SHORT_REQUEST_RECORD_PADDING_OFFSET = SHORT_REQUEST_RECORD_SEND_MSG_ID_OFFSET + 4; 96 const size_t SHORT_REQUEST_RECORD_CLEAR_TEXT_SIZE = 154; 97 98 // ShortResponseRecord 99 const size_t SHORT_RESPONSE_RECORD_OPTIONS_OFFSET = 0; 100 const size_t SHORT_RESPONSE_RECORD_RET_OFFSET = 201; 101 102 enum I2NPMessageType 103 { 104 eI2NPDummyMsg = 0, 105 eI2NPDatabaseStore = 1, 106 eI2NPDatabaseLookup = 2, 107 eI2NPDatabaseSearchReply = 3, 108 eI2NPDeliveryStatus = 10, 109 eI2NPGarlic = 11, 110 eI2NPTunnelData = 18, 111 eI2NPTunnelGateway = 19, 112 eI2NPData = 20, 113 eI2NPTunnelBuild = 21, 114 eI2NPTunnelBuildReply = 22, 115 eI2NPVariableTunnelBuild = 23, 116 eI2NPVariableTunnelBuildReply = 24, 117 eI2NPShortTunnelBuild = 25, 118 eI2NPShortTunnelBuildReply = 26 119 }; 120 121 const uint8_t TUNNEL_BUILD_RECORD_GATEWAY_FLAG = 0x80; 122 const uint8_t TUNNEL_BUILD_RECORD_ENDPOINT_FLAG = 0x40; 123 const int NUM_TUNNEL_BUILD_RECORDS = 8; 124 125 // DatabaseLookup flags 126 const uint8_t DATABASE_LOOKUP_DELIVERY_FLAG = 0x01; 127 const uint8_t DATABASE_LOOKUP_ENCRYPTION_FLAG = 0x02; 128 const uint8_t DATABASE_LOOKUP_ECIES_FLAG = 0x10; 129 const uint8_t DATABASE_LOOKUP_TYPE_FLAGS_MASK = 0x0C; 130 const uint8_t DATABASE_LOOKUP_TYPE_NORMAL_LOOKUP = 0; 131 const uint8_t DATABASE_LOOKUP_TYPE_LEASESET_LOOKUP = 0x04; // 0100 132 const uint8_t DATABASE_LOOKUP_TYPE_ROUTERINFO_LOOKUP = 0x08; // 1000 133 const uint8_t DATABASE_LOOKUP_TYPE_EXPLORATORY_LOOKUP = 0x0C; // 1100 134 135 namespace tunnel 136 { 137 class InboundTunnel; 138 class TunnelPool; 139 } 140 141 const size_t I2NP_MAX_MESSAGE_SIZE = 62708; 142 const size_t I2NP_MAX_SHORT_MESSAGE_SIZE = 4096; 143 const unsigned int I2NP_MESSAGE_EXPIRATION_TIMEOUT = 8000; // in milliseconds (as initial RTT) 144 const unsigned int I2NP_MESSAGE_CLOCK_SKEW = 60*1000; // 1 minute in milliseconds 145 146 struct I2NPMessage 147 { 148 uint8_t * buf; 149 size_t len, offset, maxLen; 150 std::shared_ptr<i2p::tunnel::InboundTunnel> from; 151 I2NPMessageI2NPMessage152 I2NPMessage (): buf (nullptr),len (I2NP_HEADER_SIZE + 2), 153 offset(2), maxLen (0), from (nullptr) {}; // reserve 2 bytes for NTCP header 154 155 // header accessors GetHeaderI2NPMessage156 uint8_t * GetHeader () { return GetBuffer (); }; GetHeaderI2NPMessage157 const uint8_t * GetHeader () const { return GetBuffer (); }; SetTypeIDI2NPMessage158 void SetTypeID (uint8_t typeID) { GetHeader ()[I2NP_HEADER_TYPEID_OFFSET] = typeID; }; GetTypeIDI2NPMessage159 uint8_t GetTypeID () const { return GetHeader ()[I2NP_HEADER_TYPEID_OFFSET]; }; SetMsgIDI2NPMessage160 void SetMsgID (uint32_t msgID) { htobe32buf (GetHeader () + I2NP_HEADER_MSGID_OFFSET, msgID); }; GetMsgIDI2NPMessage161 uint32_t GetMsgID () const { return bufbe32toh (GetHeader () + I2NP_HEADER_MSGID_OFFSET); }; SetExpirationI2NPMessage162 void SetExpiration (uint64_t expiration) { htobe64buf (GetHeader () + I2NP_HEADER_EXPIRATION_OFFSET, expiration); }; GetExpirationI2NPMessage163 uint64_t GetExpiration () const { return bufbe64toh (GetHeader () + I2NP_HEADER_EXPIRATION_OFFSET); }; SetSizeI2NPMessage164 void SetSize (uint16_t size) { htobe16buf (GetHeader () + I2NP_HEADER_SIZE_OFFSET, size); }; GetSizeI2NPMessage165 uint16_t GetSize () const { return bufbe16toh (GetHeader () + I2NP_HEADER_SIZE_OFFSET); }; UpdateSizeI2NPMessage166 void UpdateSize () { SetSize (GetPayloadLength ()); }; SetChksI2NPMessage167 void SetChks (uint8_t chks) { GetHeader ()[I2NP_HEADER_CHKS_OFFSET] = chks; }; UpdateChksI2NPMessage168 void UpdateChks () 169 { 170 uint8_t hash[32]; 171 SHA256(GetPayload (), GetPayloadLength (), hash); 172 GetHeader ()[I2NP_HEADER_CHKS_OFFSET] = hash[0]; 173 } 174 175 // payload GetPayloadI2NPMessage176 uint8_t * GetPayload () { return GetBuffer () + I2NP_HEADER_SIZE; }; GetPayloadI2NPMessage177 const uint8_t * GetPayload () const { return GetBuffer () + I2NP_HEADER_SIZE; }; GetBufferI2NPMessage178 uint8_t * GetBuffer () { return buf + offset; }; GetBufferI2NPMessage179 const uint8_t * GetBuffer () const { return buf + offset; }; GetLengthI2NPMessage180 size_t GetLength () const { return len - offset; }; GetPayloadLengthI2NPMessage181 size_t GetPayloadLength () const { return GetLength () - I2NP_HEADER_SIZE; }; 182 AlignI2NPMessage183 void Align (size_t alignment) 184 { 185 if (len + alignment > maxLen) return; 186 size_t rem = ((size_t)GetBuffer ()) % alignment; 187 if (rem) 188 { 189 offset += (alignment - rem); 190 len += (alignment - rem); 191 } 192 } 193 ConcatI2NPMessage194 size_t Concat (const uint8_t * buf1, size_t len1) 195 { 196 // make sure with don't write beyond maxLen 197 if (len + len1 > maxLen) len1 = maxLen - len; 198 memcpy (buf + len, buf1, len1); 199 len += len1; 200 return len1; 201 } 202 203 I2NPMessage& operator=(const I2NPMessage& other) 204 { 205 memcpy (buf + offset, other.buf + other.offset, other.GetLength ()); 206 len = offset + other.GetLength (); 207 from = other.from; 208 return *this; 209 } 210 211 // for SSU only GetSSUHeaderI2NPMessage212 uint8_t * GetSSUHeader () { return buf + offset + I2NP_HEADER_SIZE - I2NP_SHORT_HEADER_SIZE; }; FromSSUI2NPMessage213 void FromSSU (uint32_t msgID) // we have received SSU message and convert it to regular 214 { 215 const uint8_t * ssu = GetSSUHeader (); 216 GetHeader ()[I2NP_HEADER_TYPEID_OFFSET] = ssu[I2NP_SHORT_HEADER_TYPEID_OFFSET]; // typeid 217 SetMsgID (msgID); 218 SetExpiration (bufbe32toh (ssu + I2NP_SHORT_HEADER_EXPIRATION_OFFSET)*1000LL); 219 SetSize (len - offset - I2NP_HEADER_SIZE); 220 SetChks (0); 221 } ToSSUI2NPMessage222 uint32_t ToSSU () // return msgID 223 { 224 uint8_t header[I2NP_HEADER_SIZE]; 225 memcpy (header, GetHeader (), I2NP_HEADER_SIZE); 226 uint8_t * ssu = GetSSUHeader (); 227 ssu[I2NP_SHORT_HEADER_TYPEID_OFFSET] = header[I2NP_HEADER_TYPEID_OFFSET]; // typeid 228 htobe32buf (ssu + I2NP_SHORT_HEADER_EXPIRATION_OFFSET, bufbe64toh (header + I2NP_HEADER_EXPIRATION_OFFSET)/1000LL); 229 len = offset + I2NP_SHORT_HEADER_SIZE + bufbe16toh (header + I2NP_HEADER_SIZE_OFFSET); 230 return bufbe32toh (header + I2NP_HEADER_MSGID_OFFSET); 231 } 232 // for NTCP2 only GetNTCP2HeaderI2NPMessage233 uint8_t * GetNTCP2Header () { return GetPayload () - I2NP_NTCP2_HEADER_SIZE; }; GetNTCP2LengthI2NPMessage234 size_t GetNTCP2Length () const { return GetPayloadLength () + I2NP_NTCP2_HEADER_SIZE; }; FromNTCP2I2NPMessage235 void FromNTCP2 () 236 { 237 const uint8_t * ntcp2 = GetNTCP2Header (); 238 memcpy (GetHeader () + I2NP_HEADER_TYPEID_OFFSET, ntcp2 + I2NP_HEADER_TYPEID_OFFSET, 5); // typeid + msgid 239 SetExpiration (bufbe32toh (ntcp2 + I2NP_HEADER_EXPIRATION_OFFSET)*1000LL); 240 SetSize (len - offset - I2NP_HEADER_SIZE); 241 SetChks (0); 242 } 243 ToNTCP2I2NPMessage244 void ToNTCP2 () 245 { 246 uint8_t * ntcp2 = GetNTCP2Header (); 247 htobe32buf (ntcp2 + I2NP_HEADER_EXPIRATION_OFFSET, bufbe64toh (GetHeader () + I2NP_HEADER_EXPIRATION_OFFSET)/1000LL); 248 memcpy (ntcp2 + I2NP_HEADER_TYPEID_OFFSET, GetHeader () + I2NP_HEADER_TYPEID_OFFSET, 5); // typeid + msgid 249 } 250 251 void FillI2NPMessageHeader (I2NPMessageType msgType, uint32_t replyMsgID = 0, bool checksum = true); 252 void RenewI2NPMessageHeader (); 253 bool IsExpired () const; 254 }; 255 256 template<int sz> 257 struct I2NPMessageBuffer: public I2NPMessage 258 { I2NPMessageBufferI2NPMessageBuffer259 I2NPMessageBuffer () { buf = m_Buffer; maxLen = sz; }; 260 uint8_t m_Buffer[sz + 32]; // 16 alignment + 16 padding 261 }; 262 263 std::shared_ptr<I2NPMessage> NewI2NPMessage (); 264 std::shared_ptr<I2NPMessage> NewI2NPShortMessage (); 265 std::shared_ptr<I2NPMessage> NewI2NPTunnelMessage (bool endpoint); 266 std::shared_ptr<I2NPMessage> NewI2NPMessage (size_t len); 267 268 std::shared_ptr<I2NPMessage> CreateI2NPMessage (I2NPMessageType msgType, const uint8_t * buf, size_t len, uint32_t replyMsgID = 0); 269 std::shared_ptr<I2NPMessage> CreateI2NPMessage (const uint8_t * buf, size_t len, std::shared_ptr<i2p::tunnel::InboundTunnel> from = nullptr); 270 std::shared_ptr<I2NPMessage> CopyI2NPMessage (std::shared_ptr<I2NPMessage> msg); 271 272 std::shared_ptr<I2NPMessage> CreateDeliveryStatusMsg (uint32_t msgID); 273 std::shared_ptr<I2NPMessage> CreateRouterInfoDatabaseLookupMsg (const uint8_t * key, const uint8_t * from, 274 uint32_t replyTunnelID, bool exploratory = false, std::set<i2p::data::IdentHash> * excludedPeers = nullptr); 275 std::shared_ptr<I2NPMessage> CreateLeaseSetDatabaseLookupMsg (const i2p::data::IdentHash& dest, 276 const std::set<i2p::data::IdentHash>& excludedFloodfills, 277 std::shared_ptr<const i2p::tunnel::InboundTunnel> replyTunnel, 278 const uint8_t * replyKey, const uint8_t * replyTag, bool replyECIES = false); 279 std::shared_ptr<I2NPMessage> CreateDatabaseSearchReply (const i2p::data::IdentHash& ident, std::vector<i2p::data::IdentHash> routers); 280 281 std::shared_ptr<I2NPMessage> CreateDatabaseStoreMsg (std::shared_ptr<const i2p::data::RouterInfo> router = nullptr, uint32_t replyToken = 0, std::shared_ptr<const i2p::tunnel::InboundTunnel> replyTunnel = nullptr); 282 std::shared_ptr<I2NPMessage> CreateDatabaseStoreMsg (const i2p::data::IdentHash& storeHash, std::shared_ptr<const i2p::data::LeaseSet> leaseSet); // for floodfill only 283 std::shared_ptr<I2NPMessage> CreateDatabaseStoreMsg (std::shared_ptr<const i2p::data::LocalLeaseSet> leaseSet, uint32_t replyToken = 0, std::shared_ptr<const i2p::tunnel::InboundTunnel> replyTunnel = nullptr); 284 bool IsRouterInfoMsg (std::shared_ptr<I2NPMessage> msg); 285 286 std::shared_ptr<I2NPMessage> CreateTunnelDataMsg (const uint8_t * buf); 287 std::shared_ptr<I2NPMessage> CreateTunnelDataMsg (uint32_t tunnelID, const uint8_t * payload); 288 std::shared_ptr<I2NPMessage> CreateEmptyTunnelDataMsg (bool endpoint); 289 290 std::shared_ptr<I2NPMessage> CreateTunnelGatewayMsg (uint32_t tunnelID, const uint8_t * buf, size_t len); 291 std::shared_ptr<I2NPMessage> CreateTunnelGatewayMsg (uint32_t tunnelID, I2NPMessageType msgType, 292 const uint8_t * buf, size_t len, uint32_t replyMsgID = 0); 293 std::shared_ptr<I2NPMessage> CreateTunnelGatewayMsg (uint32_t tunnelID, std::shared_ptr<I2NPMessage> msg); 294 295 size_t GetI2NPMessageLength (const uint8_t * msg, size_t len); 296 void HandleI2NPMessage (uint8_t * msg, size_t len); 297 void HandleI2NPMessage (std::shared_ptr<I2NPMessage> msg); 298 299 class I2NPMessagesHandler 300 { 301 public: 302 303 ~I2NPMessagesHandler (); 304 void PutNextMessage (std::shared_ptr<I2NPMessage>&& msg); 305 void Flush (); 306 307 private: 308 309 std::vector<std::shared_ptr<I2NPMessage> > m_TunnelMsgs, m_TunnelGatewayMsgs; 310 }; 311 312 const uint16_t DEFAULT_MAX_NUM_TRANSIT_TUNNELS = 2500; 313 void SetMaxNumTransitTunnels (uint16_t maxNumTransitTunnels); 314 uint16_t GetMaxNumTransitTunnels (); 315 } 316 317 #endif 318