handle existing session message

libi2pd/ECIESX25519AEADRatchetSession.cpp

@@ -86,7 +86,7 @@ namespace garlic
         return tagsetNsr.GetNextSessionTag ();   
     }
 
-    bool ECIESX25519AEADRatchetSession::HandleNewIncomingSession (const uint8_t * buf, size_t len,  CloveHandler handleClove)
+    bool ECIESX25519AEADRatchetSession::HandleNewIncomingSession (const uint8_t * buf, size_t len)
     {
         if (!GetOwner ()) return false;
         // we are Bob
@@ -138,12 +138,12 @@ namespace garlic
         m_State = eSessionStateNewSessionReceived;            
 		GetOwner ()->AddECIESx25519Session (m_RemoteStaticKey, shared_from_this ());
 
-        HandlePayload (payload.data (), len - 16, handleClove);    
+        HandlePayload (payload.data (), len - 16);    
 
         return true;
     }
 
-    void ECIESX25519AEADRatchetSession::HandlePayload (const uint8_t * buf, size_t len, CloveHandler& handleClove)
+    void ECIESX25519AEADRatchetSession::HandlePayload (const uint8_t * buf, size_t len)
     {
         size_t offset = 0;
 		while (offset < len)
@@ -161,7 +161,7 @@ namespace garlic
 			switch (blk)
 			{
 				case eECIESx25519BlkGalicClove:
-					handleClove (buf + offset, size);
+					GetOwner ()->HandleECIESx25519GarlicClove (buf + offset, size);
 				break;
 				case eECIESx25519BlkDateTime:
 					LogPrint (eLogDebug, "Garlic: datetime");
@@ -220,7 +220,7 @@ namespace garlic
 
 		m_State = eSessionStateNewSessionSent;
         if (GetOwner ())
-            GetOwner ()->AddECIESx25519SessionTag (CreateNewSessionTag (), shared_from_this ());   		
+            GetOwner ()->AddECIESx25519SessionTag (CreateNewSessionTag (), 0, shared_from_this ());   		
 
         return true;
     }
@@ -260,9 +260,12 @@ namespace garlic
         // KDF for payload
         uint8_t keydata[64];
         i2p::crypto::HKDF (m_CK, nullptr, 0, "", keydata); // keydata = HKDF(chainKey, ZEROLEN, "", 64)
-        // k_ab = keydata[0:31], k_ba = keydata[32:63]
+		memcpy (m_ReceiveKey, keydata, 32); // k_ab = keydata[0:31]
-        m_TagsetAB.DHInitialize (m_CK, keydata); // tagset_ab = DH_INITIALIZE(chainKey, k_ab)
+		memcpy (m_SendKey, keydata + 32, 32);// k_ba = keydata[32:63]
-        m_TagsetBA.DHInitialize (m_CK, keydata + 32); // tagset_ba = DH_INITIALIZE(chainKey, k_ba)
+        m_ReceiveTagset.DHInitialize (m_CK, keydata); // tagset_ab = DH_INITIALIZE(chainKey, k_ab)
+		m_ReceiveTagset.NextSessionTagRatchet ();
+        m_SendTagset.DHInitialize (m_CK, keydata + 32); // tagset_ba = DH_INITIALIZE(chainKey, k_ba)
+		m_SendTagset.NextSessionTagRatchet ();	
         i2p::crypto::HKDF (keydata + 32, nullptr, 0, "AttachPayloadKDF", keydata, 32); // k = HKDF(k_ba, ZEROLEN, "AttachPayloadKDF", 32)
         // encrypt payload
         if (!i2p::crypto::AEADChaCha20Poly1305 (payload, len, m_H, 32, keydata, nonce, out + offset, len + 16, true)) // encrypt
@@ -270,11 +273,12 @@ namespace garlic
 			LogPrint (eLogWarning, "Garlic: Payload section AEAD encryption failed");
 			return false;
 		}
+		m_State = eSessionStateEstablished;
 
         return true;
     }
 
-    bool ECIESX25519AEADRatchetSession::HandleNewOutgoingSessionReply (const uint8_t * buf, size_t len, CloveHandler handleClove)
+    bool ECIESX25519AEADRatchetSession::HandleNewOutgoingSessionReply (const uint8_t * buf, size_t len)
     {
 		// we are Alice
 		LogPrint (eLogDebug, "Garlic: reply received");
@@ -308,9 +312,12 @@ namespace garlic
 		// KDF for payload
         uint8_t keydata[64];
         i2p::crypto::HKDF (m_CK, nullptr, 0, "", keydata); // keydata = HKDF(chainKey, ZEROLEN, "", 64)
-        // k_ab = keydata[0:31], k_ba = keydata[32:63]
+        memcpy (m_SendKey, keydata, 32); // k_ab = keydata[0:31]
-        m_TagsetAB.DHInitialize (m_CK, keydata); // tagset_ab = DH_INITIALIZE(chainKey, k_ab)
+		memcpy (m_ReceiveKey, keydata + 32, 32);// k_ba = keydata[32:63]
-        m_TagsetBA.DHInitialize (m_CK, keydata + 32); // tagset_ba = DH_INITIALIZE(chainKey, k_ba)
+        m_SendTagset.DHInitialize (m_CK, keydata); // tagset_ab = DH_INITIALIZE(chainKey, k_ab)
+		m_SendTagset.NextSessionTagRatchet ();
+        m_ReceiveTagset.DHInitialize (m_CK, keydata + 32); // tagset_ba = DH_INITIALIZE(chainKey, k_ba)
+		m_ReceiveTagset.NextSessionTagRatchet ();
         i2p::crypto::HKDF (keydata + 32, nullptr, 0, "AttachPayloadKDF", keydata, 32); // k = HKDF(k_ba, ZEROLEN, "AttachPayloadKDF", 32)		
 		// decrypt payload
 		std::vector<uint8_t> payload (len - 16);
@@ -320,21 +327,41 @@ namespace garlic
 			return false;
 		}
 	
-		// TODO: change state
+		m_State = eSessionStateEstablished;
 		GetOwner ()->AddECIESx25519Session (m_RemoteStaticKey, shared_from_this ());
-		HandlePayload (payload.data (), len - 16, handleClove); 
+		HandlePayload (payload.data (), len - 16); 
 
         return true;
     }
 
-	bool ECIESX25519AEADRatchetSession::HandleNextMessage (const uint8_t * buf, size_t len, CloveHandler handleClove)
+	bool ECIESX25519AEADRatchetSession::HandleExistingSessionMessage (const uint8_t * buf, size_t len, int index)
+	{
+		uint8_t nonce[12];
+		memset (nonce, 0, 12); 
+		htole64buf (nonce + 4, index); // tag's index
+		// ad = The session tag, 8 bytes
+		// ciphertext = ENCRYPT(k, n, payload, ad)
+		len -= 8; // tag 
+		std::vector<uint8_t> payload (len - 16);
+		if (!i2p::crypto::AEADChaCha20Poly1305 (buf + 8, len - 16, buf, 8, m_ReceiveKey, nonce, payload.data (), len - 16, false)) // decrypt
+		{
+			LogPrint (eLogWarning, "Garlic: Payload section AEAD decryption failed");
+			return false;
+		}	
+		HandlePayload (payload.data (), len - 16); 
+		return true;
+	}
+
+	bool ECIESX25519AEADRatchetSession::HandleNextMessage (const uint8_t * buf, size_t len, int index)
 	{
 		switch (m_State)
 		{
+			case eSessionStateEstablished:
+				return HandleExistingSessionMessage (buf, len, index);
 			case eSessionStateNew:
-				return HandleNewIncomingSession (buf, len, handleClove);
+				return HandleNewIncomingSession (buf, len);
 			case eSessionStateNewSessionSent:
-				return HandleNewOutgoingSessionReply (buf, len, handleClove);
+				return HandleNewOutgoingSessionReply (buf, len);
 			default:
 				return false;
 		}
@@ -425,7 +452,6 @@ namespace garlic
         memcpy (buf + 9, msg->GetPayload (), msg->GetPayloadLength ());
         return cloveSize + 3;
     } 
- 
 }
 }
 

libi2pd/ECIESX25519AEADRatchetSession.h

@@ -54,17 +54,16 @@ namespace garlic
         {
             eSessionStateNew =0,
             eSessionStateNewSessionReceived,
-			eSessionStateNewSessionSent
+			eSessionStateNewSessionSent,
+			eSessionStateEstablished		
         };
 
         public:
 
-            typedef std::function<void (const uint8_t * buf, size_t len)> CloveHandler;
-
             ECIESX25519AEADRatchetSession (GarlicDestination * owner);
             ~ECIESX25519AEADRatchetSession ();
 
-			bool HandleNextMessage (const uint8_t * buf, size_t len, CloveHandler handleClove);
+			bool HandleNextMessage (const uint8_t * buf, size_t len, int index = 0);
             std::shared_ptr<I2NPMessage> WrapSingleMessage (std::shared_ptr<const I2NPMessage> msg);
 
             const uint8_t * GetRemoteStaticKey () const { return m_RemoteStaticKey; }
@@ -82,9 +81,10 @@ namespace garlic
             bool GenerateEphemeralKeysAndEncode (uint8_t * buf); // buf is 32 bytes
             uint64_t CreateNewSessionTag () const;
 
-			bool HandleNewIncomingSession (const uint8_t * buf, size_t len, CloveHandler handleClove);
+			bool HandleNewIncomingSession (const uint8_t * buf, size_t len);
-            bool HandleNewOutgoingSessionReply (const uint8_t * buf, size_t len, CloveHandler handleClove);
+            bool HandleNewOutgoingSessionReply (const uint8_t * buf, size_t len);
-            void HandlePayload (const uint8_t * buf, size_t len,  CloveHandler& handleClove);
+			bool HandleExistingSessionMessage (const uint8_t * buf, size_t len, int index);
+            void HandlePayload (const uint8_t * buf, size_t len);
 
             bool NewOutgoingSessionMessage (const uint8_t * payload, size_t len, uint8_t * out, size_t outLen);
             bool NewSessionReplyMessage (const uint8_t * payload, size_t len, uint8_t * out, size_t outLen);
@@ -97,7 +97,8 @@ namespace garlic
 			uint8_t m_Aepk[32]; // Alice's ephemeral keys TODO: for incoming only
             i2p::crypto::X25519Keys m_EphemeralKeys;
             SessionState m_State = eSessionStateNew;
-            RatchetTagSet m_TagsetAB, m_TagsetBA;
+            RatchetTagSet m_SendTagset, m_ReceiveTagset;
+			uint8_t m_SendKey[32], m_ReceiveKey[32];
 			std::unique_ptr<i2p::data::IdentHash> m_Destination;// TODO: might not need it 
     };
 }

libi2pd/Garlic.cpp

@@ -864,17 +864,18 @@ namespace garlic
         uint64_t tag;
         memcpy (&tag, buf, 8);
 		ECIESX25519AEADRatchetSessionPtr session;
+		int index = 0;	
         auto it = m_ECIESx25519Tags.find (tag);
 		if (it != m_ECIESx25519Tags.end ())
 		{
-        	session = it->second;
+        	session = it->second.session;
+			index = it->second.index;
 			m_ECIESx25519Tags.erase (tag);
 		}	
 		else
 			session = std::make_shared<ECIESX25519AEADRatchetSession> (this); // incoming
 		
-		if (!session->HandleNextMessage (buf, len, std::bind (&GarlicDestination::HandleECIESx25519GarlicClove,
+		if (!session->HandleNextMessage (buf, len, index))
-            this, std::placeholders::_1, std::placeholders::_2)))
         	LogPrint (eLogError, "Garlic: can't handle ECIES-X25519-AEAD-Ratchet message");
 	}
 
@@ -934,9 +935,9 @@ namespace garlic
 		} 
     }
 
-    void GarlicDestination::AddECIESx25519SessionTag (uint64_t tag, ECIESX25519AEADRatchetSessionPtr session)
+    void GarlicDestination::AddECIESx25519SessionTag (uint64_t tag, int index, ECIESX25519AEADRatchetSessionPtr session)
     {
-        m_ECIESx25519Tags.emplace (tag, session);
+        m_ECIESx25519Tags.emplace (tag, ECIESX25519AEADRatchetIndexSession{index, session});
     }
 
 	void GarlicDestination::AddECIESx25519Session (const uint8_t * staticKey, ECIESX25519AEADRatchetSessionPtr session)

libi2pd/Garlic.h

@@ -198,6 +198,11 @@ namespace garlic
 
     class ECIESX25519AEADRatchetSession;
     typedef std::shared_ptr<ECIESX25519AEADRatchetSession> ECIESX25519AEADRatchetSessionPtr;     
+	struct ECIESX25519AEADRatchetIndexSession
+	{ 
+		int index; 
+		ECIESX25519AEADRatchetSessionPtr session; 
+	};
 
 	class GarlicDestination: public i2p::data::LocalDestination
 	{
@@ -217,8 +222,9 @@ namespace garlic
 			void AddSessionKey (const uint8_t * key, const uint8_t * tag); // one tag
 			virtual bool SubmitSessionKey (const uint8_t * key, const uint8_t * tag); // from different thread
 			void DeliveryStatusSent (ElGamalAESSessionPtr session, uint32_t msgID);
-            void AddECIESx25519SessionTag (uint64_t tag, ECIESX25519AEADRatchetSessionPtr session);
+            void AddECIESx25519SessionTag (uint64_t tag, int index, ECIESX25519AEADRatchetSessionPtr session);
 			void AddECIESx25519Session (const uint8_t * staticKey, ECIESX25519AEADRatchetSessionPtr session);
+			void HandleECIESx25519GarlicClove (const uint8_t * buf, size_t len);
 
 			virtual void ProcessGarlicMessage (std::shared_ptr<I2NPMessage> msg);
 			virtual void ProcessDeliveryStatusMessage (std::shared_ptr<I2NPMessage> msg);
@@ -245,7 +251,6 @@ namespace garlic
 
 			// ECIES-X25519-AEAD-Ratchet
 			void HandleECIESx25519 (const uint8_t * buf, size_t len);
-            void HandleECIESx25519GarlicClove (const uint8_t * buf, size_t len);
 
 		private:
 
@@ -257,7 +262,7 @@ namespace garlic
             std::unordered_map<i2p::data::Tag<32>, ECIESX25519AEADRatchetSessionPtr> m_ECIESx25519Sessions; // static key -> session
 			// incoming
 			std::unordered_map<SessionTag, std::shared_ptr<AESDecryption>, std::hash<i2p::data::Tag<32> > > m_Tags;
-            std::unordered_map<uint64_t, ECIESX25519AEADRatchetSessionPtr> m_ECIESx25519Tags; // session tag -> session
+            std::unordered_map<uint64_t, ECIESX25519AEADRatchetIndexSession> m_ECIESx25519Tags; // session tag -> session
 			// DeliveryStatus
 			std::mutex m_DeliveryStatusSessionsMutex;
 			std::unordered_map<uint32_t, ElGamalAESSessionPtr> m_DeliveryStatusSessions; // msgID -> session