added load/save of random bias in GxsNetTunnel service

libretroshare/src/gxs/rsgxsnetservice.cc

@@ -1522,8 +1522,8 @@ class StoreHere
 {
 public:
 
-    StoreHere(RsGxsNetService::ClientGrpMap& cgm, RsGxsNetService::ClientMsgMap& cmm, RsGxsNetService::ServerMsgMap& smm,RsGxsNetService::GrpConfigMap& gcm, RsGxsServerGrpUpdate& sgm)
+    StoreHere(RsGxsNetService::ClientGrpMap& cgm, RsGxsNetService::ClientMsgMap& cmm, RsGxsNetService::ServerMsgMap& smm,RsGxsNetService::GrpConfigMap& gcm, RsGxsServerGrpUpdate& sgm,Bias20Bytes& mrb)
-            : mClientGrpMap(cgm), mClientMsgMap(cmm), mServerMsgMap(smm), mGrpConfigMap(gcm), mServerGrpUpdate(sgm)
+            : mClientGrpMap(cgm), mClientMsgMap(cmm), mServerMsgMap(smm), mGrpConfigMap(gcm), mServerGrpUpdate(sgm), mRandomBias(mrb)
     {}
 
 	template <typename ID_type,typename UpdateMap,class ItemClass> void check_store(ID_type id,UpdateMap& map,ItemClass& item)
@@ -1536,11 +1536,12 @@ public:
 
     void operator() (RsItem* item)
     {
-        RsGxsMsgUpdateItem* mui;
+        RsGxsMsgUpdateItem        *mui;
-        RsGxsGrpUpdateItem* gui;
+        RsGxsGrpUpdateItem        *gui;
-        RsGxsServerGrpUpdateItem* gsui;
+        RsGxsServerGrpUpdateItem  *gsui;
-        RsGxsServerMsgUpdateItem* msui;
+        RsGxsServerMsgUpdateItem  *msui;
-        RsGxsGrpConfigItem* mgci;
+        RsGxsGrpConfigItem        *mgci;
+        RsGxsTunnelRandomBiasItem *rbsi;
 
         if((mui = dynamic_cast<RsGxsMsgUpdateItem*>(item)) != NULL)
             check_store(mui->peerID,mClientMsgMap,*mui);
@@ -1552,6 +1553,8 @@ public:
             check_store(msui->grpId,mServerMsgMap, *msui);
         else if((gsui = dynamic_cast<RsGxsServerGrpUpdateItem*>(item)) != NULL)
             mServerGrpUpdate = *gsui;
+		else if((rbsi = dynamic_cast<RsGxsTunnelRandomBiasItem*>(item))!=NULL)
+			mRandomBias = rbsi->mRandomBias;
         else
             std::cerr << "Type not expected!" << std::endl;
 
@@ -1566,7 +1569,7 @@ private:
     RsGxsNetService::GrpConfigMap& mGrpConfigMap;
 
     RsGxsServerGrpUpdate& mServerGrpUpdate;
-
+	Bias20Bytes& mRandomBias ;
 };
 
 bool RsGxsNetService::loadList(std::list<RsItem *> &load)
@@ -1575,7 +1578,7 @@ bool RsGxsNetService::loadList(std::list<RsItem *> &load)
 
     // The delete is done in StoreHere, if necessary
 
-    std::for_each(load.begin(), load.end(), StoreHere(mClientGrpUpdateMap, mClientMsgUpdateMap, mServerMsgUpdateMap, mServerGrpConfigMap, mGrpServerUpdate));
+    std::for_each(load.begin(), load.end(), StoreHere(mClientGrpUpdateMap, mClientMsgUpdateMap, mServerMsgUpdateMap, mServerGrpConfigMap, mGrpServerUpdate,mRandomBias));
 
     // We reset group statistics here. This is the best place since we know at this point which are all unsubscribed groups.
 
@@ -1652,6 +1655,11 @@ bool RsGxsNetService::saveList(bool& cleanup, std::list<RsItem*>& save)
 
     save.push_back(it);
 
+	RsGxsTunnelRandomBiasItem *it2 = new RsGxsTunnelRandomBiasItem(mServType) ;
+	it2->mRandomBias = mRandomBias;
+
+	save.push_back(it2) ;
+
     cleanup = true;
     return true;
 }

libretroshare/src/gxs/rsgxsnettunnel.cc

@@ -39,7 +39,7 @@
 RsGxsNetTunnelService::RsGxsNetTunnelService(): mGxsNetTunnelMtx("GxsNetTunnel")
 {
 #warning this is for testing only. In the final version this needs to be initialized with some random content, saved and re-used for a while (e.g. 1 month)
-	memset(mRandomBias,0,RS_GXS_TUNNEL_CONST_RANDOM_BIAS_SIZE) ;
+	mRandomBias.clear();
 }
 
 //===========================================================================================================================================//
@@ -289,12 +289,12 @@ RsGxsNetTunnelVirtualPeerId RsGxsNetTunnelService::locked_makeVirtualPeerId(cons
 
 	RsPeerId ssl_id = rsPeers->getOwnId() ;
 
-	unsigned char mem[RsGxsGroupId::SIZE_IN_BYTES + RS_GXS_TUNNEL_CONST_RANDOM_BIAS_SIZE];
+	unsigned char mem[RsGxsGroupId::SIZE_IN_BYTES + mRandomBias.SIZE_IN_BYTES];
 
 	memcpy(mem                            ,group_id.toByteArray(),RsGxsGroupId::SIZE_IN_BYTES) ;
-	memcpy(mem+RsGxsGroupId::SIZE_IN_BYTES,mRandomBias           ,RS_GXS_TUNNEL_CONST_RANDOM_BIAS_SIZE) ;
+	memcpy(mem+RsGxsGroupId::SIZE_IN_BYTES,mRandomBias.toByteArray(),mRandomBias.SIZE_IN_BYTES) ;
 
-	return RsGxsNetTunnelVirtualPeerId(RsDirUtil::sha1sum(mem,RsGxsGroupId::SIZE_IN_BYTES+RS_GXS_TUNNEL_CONST_RANDOM_BIAS_SIZE).toByteArray());
+	return RsGxsNetTunnelVirtualPeerId(RsDirUtil::sha1sum(mem,RsGxsGroupId::SIZE_IN_BYTES+mRandomBias.SIZE_IN_BYTES).toByteArray());
 }
 
 void RsGxsNetTunnelService::dump() const

libretroshare/src/gxs/rsgxsnettunnel.h

@@ -23,6 +23,8 @@
  *
  */
 
+#pragma once
+
 #include <map>
 
 #include <turtle/p3turtle.h>
@@ -224,15 +226,17 @@ protected:
 	  void removeVirtualPeer(const TurtleFileHash&, const TurtleVirtualPeerId&) ;
 
 	  p3turtle 	*mTurtle ;
+
+	  static const uint32_t RS_GXS_TUNNEL_CONST_RANDOM_BIAS_SIZE = 20 ;
+	  static const uint32_t RS_GXS_TUNNEL_CONST_EKEY_SIZE        = 32 ;
+
+	  Bias20Bytes mRandomBias ; // constant accross reboots. Allows to disguise the real SSL id while providing a consistent value accross time.
 private:
 	  void autowash() ;
 	  void sendKeepAlivePackets() ;
 	  void handleIncoming(RsGxsNetTunnelItem *item) ;
 	  void flush_pending_items();
 
-	  static const uint32_t RS_GXS_TUNNEL_CONST_RANDOM_BIAS_SIZE = 20 ;
-	  static const uint32_t RS_GXS_TUNNEL_CONST_EKEY_SIZE        = 32 ;
-
 	  std::map<RsGxsGroupId,RsGxsNetTunnelGroupInfo> mGroups ;	// groups on the client and server side
 
 	  std::map<RsGxsNetTunnelVirtualPeerId, RsGxsNetTunnelVirtualPeerInfo> mVirtualPeers ;	// current virtual peers, which group they provide, and how to talk to them through turtle
@@ -259,8 +263,9 @@ private:
 
 	  static void generateEncryptionKey(const RsGxsGroupId& group_id,const TurtleVirtualPeerId& vpid,unsigned char key[RS_GXS_TUNNEL_CONST_EKEY_SIZE]) ;
 
-	  uint8_t mRandomBias[RS_GXS_TUNNEL_CONST_RANDOM_BIAS_SIZE] ; // constant accross reboots. Allows to disguise the real SSL id while providing a consistent value accross time.
-
 	  mutable RsMutex mGxsNetTunnelMtx;
+
+	  friend class RsGxsTunnelRandomBiasItem ;
+	  friend class StoreHere ;
 };
 

libretroshare/src/retroshare/rsids.h

@@ -238,12 +238,14 @@ static const uint32_t RS_GENERIC_ID_GXS_TUNNEL_ID_TYPE       = 0x0010 ;
 static const uint32_t RS_GENERIC_ID_GXS_DISTANT_CHAT_ID_TYPE = 0x0011 ;
 static const uint32_t RS_GENERIC_ID_NODE_GROUP_ID_TYPE       = 0x0012 ;
 static const uint32_t RS_GENERIC_ID_SHA256_ID_TYPE           = 0x0013 ;
+static const uint32_t RS_GENERIC_ID_20_BYTES_UNTYPED         = 0x0014 ;
 
 typedef t_RsGenericIdType<  SSL_ID_SIZE             , false, RS_GENERIC_ID_SSL_ID_TYPE>          SSLIdType ;
 typedef t_RsGenericIdType<  PGP_KEY_ID_SIZE         , true,  RS_GENERIC_ID_PGP_ID_TYPE>          PGPIdType ;
 typedef t_RsGenericIdType<  SHA1_SIZE               , false, RS_GENERIC_ID_SHA1_ID_TYPE>         Sha1CheckSum ;
 typedef t_RsGenericIdType<  SHA256_SIZE             , false, RS_GENERIC_ID_SHA256_ID_TYPE>       Sha256CheckSum ;
 typedef t_RsGenericIdType<  PGP_KEY_FINGERPRINT_SIZE, true,  RS_GENERIC_ID_PGP_FINGERPRINT_TYPE> PGPFingerprintType ;
+typedef t_RsGenericIdType<  SHA1_SIZE               , true,  RS_GENERIC_ID_20_BYTES_UNTYPED>     Bias20Bytes ;
 
 typedef t_RsGenericIdType<  CERT_SIGN_LEN           , false, RS_GENERIC_ID_GXS_GROUP_ID_TYPE   > GXSGroupId ;
 typedef t_RsGenericIdType<  CERT_SIGN_LEN           , false, RS_GENERIC_ID_GXS_ID_TYPE         > GXSId ;

libretroshare/src/rsitems/rsgxsupdateitems.cc

@@ -44,6 +44,7 @@ RsItem* RsGxsUpdateSerialiser::create_item(uint16_t service,uint8_t item_subtype
 		case RS_PKT_SUBTYPE_GXS_SERVER_GRP_UPDATE: return new RsGxsServerGrpUpdateItem(SERVICE_TYPE);
 		case RS_PKT_SUBTYPE_GXS_SERVER_MSG_UPDATE: return new RsGxsServerMsgUpdateItem(SERVICE_TYPE);
 		case RS_PKT_SUBTYPE_GXS_GRP_CONFIG:        return new RsGxsGrpConfigItem(SERVICE_TYPE);
+		case RS_PKT_SUBTYPE_GXS_RANDOM_BIAS:       return new RsGxsTunnelRandomBiasItem(SERVICE_TYPE);
     default:
         return NULL ;
     }
@@ -76,6 +77,11 @@ void RsGxsServerGrpUpdateItem::clear()
     grpUpdateTS = 0;
 }
 
+void RsGxsTunnelRandomBiasItem::clear()
+{
+	mRandomBias.clear() ;
+}
+
 /**********************************************************************************************/
 /*                                          SERIALISER                                        */
 /**********************************************************************************************/
@@ -134,5 +140,8 @@ void RsGxsGrpConfigItem::serial_process(RsGenericSerializer::SerializeJob j,RsGe
     RsTypeSerializer::serial_process<uint32_t>(j,ctx,msg_send_delay,"msg_send_delay") ;
     RsTypeSerializer::serial_process<uint32_t>(j,ctx,msg_req_delay,"msg_req_delay") ;
 }
-
+void RsGxsTunnelRandomBiasItem::serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx)
+{
+    RsTypeSerializer::serial_process(j,ctx,mRandomBias,"random bias") ;
+}
 

libretroshare/src/rsitems/rsgxsupdateitems.h

@@ -39,6 +39,7 @@
 
 #include "gxs/rsgxs.h"
 #include "gxs/rsgxsdata.h"
+#include "gxs/rsgxsnettunnel.h"
 #include "serialiser/rstlvidset.h"
 
 
@@ -48,6 +49,7 @@ const uint8_t RS_PKT_SUBTYPE_GXS_MSG_UPDATE             = 0x03;
 const uint8_t RS_PKT_SUBTYPE_GXS_SERVER_GRP_UPDATE      = 0x04;
 const uint8_t RS_PKT_SUBTYPE_GXS_SERVER_MSG_UPDATE      = 0x08;
 const uint8_t RS_PKT_SUBTYPE_GXS_GRP_CONFIG             = 0x09;
+const uint8_t RS_PKT_SUBTYPE_GXS_RANDOM_BIAS            = 0x0a;
 
 class RsGxsNetServiceItem: public RsItem
 {
@@ -186,6 +188,17 @@ public:
 	RsGxsGroupId grpId;
 };
 
+class RsGxsTunnelRandomBiasItem: public RsGxsNetServiceItem
+{
+public:
+	explicit RsGxsTunnelRandomBiasItem(uint16_t servType) : RsGxsNetServiceItem(servType, RS_PKT_SUBTYPE_GXS_RANDOM_BIAS) { clear();}
+    virtual ~RsGxsTunnelRandomBiasItem() {}
+
+	virtual void clear();
+	virtual void serial_process(RsGenericSerializer::SerializeJob j,RsGenericSerializer::SerializeContext& ctx);
+
+	Bias20Bytes mRandomBias; // Cannot be a simple char[] because of serialization.
+};
 
 class RsGxsUpdateSerialiser : public RsServiceSerializer
 {