From d2ab6cc6ab62d68b8ec2dece60d3fa7fc23130f8 Mon Sep 17 00:00:00 2001 From: csoler Date: Sun, 23 Mar 2014 17:32:35 +0000 Subject: [PATCH] fixed up encryption/decryption of messages. Message passing through grouter works./RetroShare git-svn-id: http://svn.code.sf.net/p/retroshare/code/branches/v0.6-IdCleaning@7204 b45a01b8-16f6-495d-af2f-9b41ad6348cc --- libretroshare/src/grouter/grouteritems.cc | 100 +++++++++++---------- libretroshare/src/grouter/grouteritems.h | 16 ++-- libretroshare/src/grouter/groutermatrix.cc | 9 +- libretroshare/src/grouter/groutertypes.h | 28 +++--- libretroshare/src/grouter/p3grouter.cc | 85 +++++++++++------- libretroshare/src/grouter/p3grouter.h | 3 + libretroshare/src/gxs/gxssecurity.cc | 2 +- libretroshare/src/services/p3msgservice.cc | 20 +++-- 8 files changed, 157 insertions(+), 106 deletions(-) diff --git a/libretroshare/src/grouter/grouteritems.cc b/libretroshare/src/grouter/grouteritems.cc index 351dff27e..fca710763 100644 --- a/libretroshare/src/grouter/grouteritems.cc +++ b/libretroshare/src/grouter/grouteritems.cc @@ -170,7 +170,7 @@ RsItem *RsGRouterSerialiser::deserialise(void *data, uint32_t *pktsize) return NULL; } -RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterPublishKeyItem(void *data, uint32_t pktsize) const +RsGRouterPublishKeyItem *RsGRouterSerialiser::deserialise_RsGRouterPublishKeyItem(void *data, uint32_t pktsize) const { uint32_t offset = 8; // skip the header uint32_t rssize = getRsItemSize(data); @@ -197,7 +197,7 @@ RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterPublishKeyItem(void *da return item; } -RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterGenericDataItem(void *data, uint32_t pktsize) const +RsGRouterGenericDataItem *RsGRouterSerialiser::deserialise_RsGRouterGenericDataItem(void *data, uint32_t pktsize) const { uint32_t offset = 8; // skip the header uint32_t rssize = getRsItemSize(data); @@ -205,9 +205,10 @@ RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterGenericDataItem(void *d RsGRouterGenericDataItem *item = new RsGRouterGenericDataItem() ; - ok &= getRawUInt32(data, pktsize, &offset, &item->routing_id); // file hash - ok &= item->destination_key.deserialise(data, pktsize, offset) ; - ok &= getRawUInt32(data, pktsize, &offset, &item->data_size); // file hash + ok &= getRawUInt64(data, pktsize, &offset, &item->routing_id); + ok &= item->destination_key.deserialise(data, pktsize, offset) ; + ok &= getRawUInt32(data, pktsize, &offset, &item->randomized_distance); + ok &= getRawUInt32(data, pktsize, &offset, &item->data_size); if( NULL == (item->data_bytes = (uint8_t*)malloc(item->data_size))) { @@ -227,7 +228,7 @@ RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterGenericDataItem(void *d return item; } -RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterACKItem(void *data, uint32_t pktsize) const +RsGRouterACKItem *RsGRouterSerialiser::deserialise_RsGRouterACKItem(void *data, uint32_t pktsize) const { uint32_t offset = 8; // skip the header uint32_t rssize = getRsItemSize(data); @@ -235,7 +236,7 @@ RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterACKItem(void *data, uin RsGRouterACKItem *item = new RsGRouterACKItem() ; - ok &= getRawUInt32(data, pktsize, &offset, &item->mid); // file hash + ok &= getRawUInt64(data, pktsize, &offset, &item->mid); // file hash ok &= getRawUInt32(data, pktsize, &offset, &item->state); // file hash if (offset != rssize || !ok) @@ -247,7 +248,7 @@ RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterACKItem(void *data, uin return item; } -RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterRoutingInfoItem(void *data, uint32_t pktsize) const +RsGRouterRoutingInfoItem *RsGRouterSerialiser::deserialise_RsGRouterRoutingInfoItem(void *data, uint32_t pktsize) const { uint32_t offset = 8; // skip the header uint32_t rssize = getRsItemSize(data); @@ -256,7 +257,7 @@ RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterRoutingInfoItem(void *d RsGRouterRoutingInfoItem *item = new RsGRouterRoutingInfoItem() ; ok &= getRawUInt32(data, pktsize, &offset, &item->status_flags); - ok &= item->origin.deserialise(data, pktsize, offset) ; + ok &= item->origin.deserialise(data, pktsize, offset) ; ok &= getRawTimeT(data, pktsize, &offset, item->received_time); uint32_t s = 0 ; @@ -266,21 +267,15 @@ RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterRoutingInfoItem(void *d { FriendTrialRecord ftr ; - ok &= ftr.friend_id.deserialise(data, pktsize, offset) ; + ok &= ftr.friend_id.deserialise(data, pktsize, offset) ; ok &= getRawTimeT(data, pktsize, &offset, ftr.time_stamp) ; + ok &= getRawUFloat32(data, pktsize, &offset, ftr.probability) ; + ok &= getRawUInt32(data, pktsize, &offset, &ftr.nb_friends) ; item->tried_friends.push_back(ftr) ; } - item->data_item = new RsGRouterGenericDataItem ; - - ok &= getRawUInt32(data, pktsize, &offset, &item->data_item->routing_id); - ok &= item->data_item->destination_key.deserialise(data, pktsize, offset) ; - ok &= getRawUInt32(data, pktsize, &offset, &item->data_item->data_size) ; - - item->data_item->data_bytes = (uint8_t*)malloc(item->data_item->data_size) ; - memcpy(item->data_item->data_bytes,&((uint8_t*)data)[offset],item->data_item->data_size) ; - offset += item->data_item->data_size ; + item->data_item = deserialise_RsGRouterGenericDataItem(&((uint8_t*)data)[offset],pktsize - offset) ; if (offset != rssize || !ok) { @@ -290,7 +285,7 @@ RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterRoutingInfoItem(void *d return item; } -RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixFriendListItem(void *data, uint32_t pktsize) const +RsGRouterMatrixFriendListItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixFriendListItem(void *data, uint32_t pktsize) const { uint32_t offset = 8; // skip the header uint32_t rssize = getRsItemSize(data); @@ -314,7 +309,7 @@ RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixFriendListItem(vo return item; } -RsGRouterItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixCluesItem(void *data, uint32_t pktsize) const +RsGRouterMatrixCluesItem *RsGRouterSerialiser::deserialise_RsGRouterMatrixCluesItem(void *data, uint32_t pktsize) const { uint32_t offset = 8; // skip the header uint32_t rssize = getRsItemSize(data); @@ -357,6 +352,7 @@ RsGRouterGenericDataItem *RsGRouterGenericDataItem::duplicate() const item->routing_id = routing_id ; item->destination_key = destination_key ; item->data_size = data_size ; + item->randomized_distance = randomized_distance ; // then duplicate the memory chunk @@ -368,11 +364,12 @@ RsGRouterGenericDataItem *RsGRouterGenericDataItem::duplicate() const uint32_t RsGRouterGenericDataItem::serial_size() const { - uint32_t s = 8 ; // header + uint32_t s = 8 ; // header s += sizeof(GRouterMsgPropagationId) ; // routing id - s += destination_key.serial_size() ; // destination_key - s += 4 ; // data_size - s += data_size ; // data_size + s += destination_key.serial_size() ; // destination_key + s += 4 ; // randomized distance + s += 4 ; // data_size + s += data_size ; // data return s ; } @@ -393,8 +390,9 @@ bool RsGRouterGenericDataItem::serialise(void *data,uint32_t& size) const return false ; /* add mandatory parts first */ - ok &= setRawUInt32(data, tlvsize, &offset, routing_id); - ok &= destination_key.serialise(data, tlvsize, offset) ; + ok &= setRawUInt64(data, tlvsize, &offset, routing_id); + ok &= destination_key.serialise(data, tlvsize, offset) ; + ok &= setRawUInt32(data, tlvsize, &offset, randomized_distance) ; ok &= setRawUInt32(data, tlvsize, &offset, data_size); memcpy(&((uint8_t*)data)[offset],data_bytes,data_size) ; @@ -417,7 +415,7 @@ bool RsGRouterACKItem::serialise(void *data,uint32_t& size) const return false ; /* add mandatory parts first */ - ok &= setRawUInt32(data, tlvsize, &offset, mid); + ok &= setRawUInt64(data, tlvsize, &offset, mid); ok &= setRawUInt32(data, tlvsize, &offset, state); if (offset != tlvsize) @@ -450,18 +448,13 @@ uint32_t RsGRouterMatrixFriendListItem::serial_size() const } uint32_t RsGRouterRoutingInfoItem::serial_size() const { - uint32_t s = 8 ; // header + uint32_t s = 8 ; // header s += 4 ; // status_flags - s += origin.serial_size() ; // origin + s += origin.serial_size() ; // origin s += 8 ; // received_time s += 4 ; // tried_friends.size() ; - - s += tried_friends.size() * ( RsPeerId::SIZE_IN_BYTES + 8 ) ; // FriendTrialRecord - - s += 4; // data_item->routing_id - s += data_item->destination_key.serial_size(); // data_item->destination_key - s += 4; // data_item->data_size - s += data_item->data_size; // data_item->data_bytes + s += tried_friends.size() * ( RsPeerId::SIZE_IN_BYTES + 8 + 4 + 4 ) ; // FriendTrialRecord + s += data_item->serial_size(); // data_item return s ; } @@ -515,6 +508,25 @@ bool RsGRouterMatrixCluesItem::serialise(void *data,uint32_t& size) const return ok; } + +bool FriendTrialRecord::deserialise(void *data,uint32_t& offset,uint32_t size) +{ + bool ok = true ; + ok &= friend_id.deserialise(data, size, offset) ; + ok &= getRawTimeT(data, size, &offset, time_stamp) ; + ok &= getRawUFloat32(data, size, &offset, probability) ; + ok &= getRawUInt32(data, size, &offset, &nb_friends) ; + return ok ; +} +bool FriendTrialRecord::serialise(void *data,uint32_t& offset,uint32_t size) const +{ + bool ok = true ; + ok &= friend_id.serialise(data, size, offset) ; + ok &= setRawTimeT(data, size, &offset, time_stamp) ; + ok &= setRawUFloat32(data, size, &offset, probability) ; + ok &= setRawUInt32(data, size, &offset, nb_friends) ; + return ok ; +} bool RsGRouterRoutingInfoItem::serialise(void *data,uint32_t& size) const { uint32_t tlvsize,offset=0; @@ -529,17 +541,11 @@ bool RsGRouterRoutingInfoItem::serialise(void *data,uint32_t& size) const ok &= setRawUInt32(data, tlvsize, &offset, tried_friends.size()) ; for(std::list::const_iterator it(tried_friends.begin());it!=tried_friends.end();++it) - { - ok &= (*it).friend_id.serialise(data, tlvsize, offset ) ; - ok &= setRawTimeT(data, tlvsize, &offset, (*it).time_stamp) ; - } + ok &= (*it).serialise(data,offset,size - offset) ; - ok &= setRawUInt32(data, tlvsize, &offset, data_item->routing_id) ; - ok &= data_item->destination_key.serialise(data, tlvsize, offset) ; - ok &= setRawUInt32(data, tlvsize, &offset, data_item->data_size) ; - - memcpy(&((uint8_t*)data)[offset],data_item->data_bytes,data_item->data_size) ; - offset += data_item->data_size ; + uint32_t ns = size - offset ; + ok &= data_item->serialise( &((uint8_t*)data)[offset], ns) ; + offset += ns ; if (offset != tlvsize) { diff --git a/libretroshare/src/grouter/grouteritems.h b/libretroshare/src/grouter/grouteritems.h index 38d768ee7..a15592eed 100644 --- a/libretroshare/src/grouter/grouteritems.h +++ b/libretroshare/src/grouter/grouteritems.h @@ -34,12 +34,12 @@ static const uint8_t RS_SERVICE_TYPE_GROUTER = 0x0016 ; const uint8_t RS_PKT_SUBTYPE_GROUTER_PUBLISH_KEY = 0x01 ; // used to publish a key -const uint8_t RS_PKT_SUBTYPE_GROUTER_DATA = 0x02 ; // used to send data to a destination const uint8_t RS_PKT_SUBTYPE_GROUTER_ACK = 0x03 ; // acknowledgement of data received +const uint8_t RS_PKT_SUBTYPE_GROUTER_DATA = 0x05 ; // used to send data to a destination const uint8_t RS_PKT_SUBTYPE_GROUTER_MATRIX_CLUES = 0x80 ; // item to save matrix clues -const uint8_t RS_PKT_SUBTYPE_GROUTER_ROUTING_INFO = 0x81 ; // item to save routing info const uint8_t RS_PKT_SUBTYPE_GROUTER_FRIENDS_LIST = 0x82 ; // item to save friend lists +const uint8_t RS_PKT_SUBTYPE_GROUTER_ROUTING_INFO = 0x85 ; // item to save routing info const uint8_t QOS_PRIORITY_RS_GROUTER_PUBLISH_KEY = 3 ; // slow items. No need to congest the network with this. const uint8_t QOS_PRIORITY_RS_GROUTER_ACK = 3 ; @@ -253,12 +253,12 @@ class RsGRouterSerialiser: public RsSerialType virtual RsItem *deserialise (void *data, uint32_t *size) ; private: - RsGRouterItem *deserialise_RsGRouterPublishKeyItem(void *data,uint32_t size) const ; - RsGRouterItem *deserialise_RsGRouterGenericDataItem(void *data,uint32_t size) const ; - RsGRouterItem *deserialise_RsGRouterACKItem(void *data,uint32_t size) const ; - RsGRouterItem *deserialise_RsGRouterMatrixCluesItem(void *data,uint32_t size) const ; - RsGRouterItem *deserialise_RsGRouterMatrixFriendListItem(void *data,uint32_t size) const ; - RsGRouterItem *deserialise_RsGRouterRoutingInfoItem(void *data,uint32_t size) const ; + RsGRouterPublishKeyItem *deserialise_RsGRouterPublishKeyItem(void *data,uint32_t size) const ; + RsGRouterGenericDataItem *deserialise_RsGRouterGenericDataItem(void *data,uint32_t size) const ; + RsGRouterACKItem *deserialise_RsGRouterACKItem(void *data,uint32_t size) const ; + RsGRouterMatrixCluesItem *deserialise_RsGRouterMatrixCluesItem(void *data,uint32_t size) const ; + RsGRouterMatrixFriendListItem *deserialise_RsGRouterMatrixFriendListItem(void *data,uint32_t size) const ; + RsGRouterRoutingInfoItem *deserialise_RsGRouterRoutingInfoItem(void *data,uint32_t size) const ; }; diff --git a/libretroshare/src/grouter/groutermatrix.cc b/libretroshare/src/grouter/groutermatrix.cc index 746b3dfbb..acda1074f 100644 --- a/libretroshare/src/grouter/groutermatrix.cc +++ b/libretroshare/src/grouter/groutermatrix.cc @@ -150,7 +150,14 @@ bool GRouterMatrix::computeRoutingProbabilities(const GRouterKeyId& key_id, cons if(it2 == _time_combined_hits.end()) { - std::cerr << "GRouterMatrix::computeRoutingProbabilities(): key id " << key_id.toStdString() << " does not exist!" << std::endl; + // The key is not known. In this case, we return equal probabilities for all peers. + // + float p = 1.0f / friends.size() ; + + for(std::list::const_iterator it(friends.begin());it!=friends.end();++it) + probas[*it] = p ; + + std::cerr << "GRouterMatrix::computeRoutingProbabilities(): key id " << key_id.toStdString() << " does not exist! Returning uniform probabilities." << std::endl; return false ; } const std::vector& w(it2->second) ; diff --git a/libretroshare/src/grouter/groutertypes.h b/libretroshare/src/grouter/groutertypes.h index 479b62889..8aaf52779 100644 --- a/libretroshare/src/grouter/groutertypes.h +++ b/libretroshare/src/grouter/groutertypes.h @@ -34,7 +34,7 @@ class RsGRouterGenericDataItem ; typedef uint32_t GRouterServiceId ; typedef uint32_t GRouterKeyPropagationId ; -typedef uint32_t GRouterMsgPropagationId ; +typedef uint64_t GRouterMsgPropagationId ; static const uint32_t GROUTER_CLIENT_ID_MESSAGES = 0x1001 ; @@ -50,8 +50,8 @@ static const time_t RS_GROUTER_PUBLISH_CAMPAIGN_PERIOD = 1 *60 ; // Check static const time_t RS_GROUTER_PUBLISH_KEY_TIME_INTERVAL = 2 *60 ; // Advertise each key once a day at most. static const time_t RS_GROUTER_ROUTING_WAITING_TIME = 3600 ; // time between two trial of sending a given message static const time_t RS_GROUTER_KEY_DIFFUSION_MAX_KEEP = 7200 ; // time to keep key diffusion items in cache, to avoid multiple diffusion. -static const uint32_t GROUTER_ITEM_DISTANCE_UNIT = 100 ; // One unit of distance between two peers -static const uint32_t GROUTER_ITEM_MAX_TRAVEL_DISTANCE = 10*100 ; // 10 distance units. That is a lot. +static const uint32_t GROUTER_ITEM_DISTANCE_UNIT = 256 ; // One unit of distance between two peers +static const uint32_t GROUTER_ITEM_MAX_TRAVEL_DISTANCE = 16*256 ; // 16 distance units. That is a lot. static const uint32_t RS_GROUTER_ROUTING_STATE_UNKN = 0x0000 ; // unknown. Unused. static const uint32_t RS_GROUTER_ROUTING_STATE_PEND = 0x0001 ; // item is pending. Should be sent asap. @@ -68,23 +68,27 @@ class GRouterPublishedKeyInfo time_t validity_time ; }; -struct FriendTrialRecord +class FriendTrialRecord { - RsPeerId friend_id ; // id of the friend - time_t time_stamp ; // time of the last tried - float probability ; // probability at which the item was selected - int nb_friends ; // number of friends at the time of sending the item + public: + RsPeerId friend_id ; // id of the friend + time_t time_stamp ; // time of the last tried + float probability ; // probability at which the item was selected + uint32_t nb_friends ; // number of friends at the time of sending the item + + bool serialise(void *data,uint32_t& offset,uint32_t size) const ; + bool deserialise(void *data,uint32_t& offset,uint32_t size) ; }; class GRouterRoutingInfo { public: - RsGRouterGenericDataItem *data_item ; - uint32_t status_flags ; // pending, waiting, etc. - std::list tried_friends ; // list of friends to which the item was sent ordered with time. RsPeerId origin ; // which friend sent us that item time_t received_time ; // time at which the item was received - uint32_t randomized_distance ; // distance of travel, randomized at each hop. + + std::list tried_friends ; // list of friends to which the item was sent ordered with time. + + RsGRouterGenericDataItem *data_item ; }; diff --git a/libretroshare/src/grouter/p3grouter.cc b/libretroshare/src/grouter/p3grouter.cc index d21b9cf4f..67b1b7767 100644 --- a/libretroshare/src/grouter/p3grouter.cc +++ b/libretroshare/src/grouter/p3grouter.cc @@ -307,13 +307,14 @@ void p3GRouter::routePendingObjects() RsPeerId own_id( mLinkMgr->getOwnId() ); for(std::map::iterator it(_pending_messages.begin());it!=_pending_messages.end();) - if((it->second.status_flags & RS_GROUTER_ROUTING_STATE_PEND) || (it->second.status_flags == RS_GROUTER_ROUTING_STATE_SENT && it->second.tried_friends.front().time_stamp+RS_GROUTER_ROUTING_WAITING_TIME < now)) + if((it->second.status_flags == RS_GROUTER_ROUTING_STATE_PEND) || (it->second.status_flags == RS_GROUTER_ROUTING_STATE_SENT && it->second.tried_friends.front().time_stamp+RS_GROUTER_ROUTING_WAITING_TIME < now)) { std::cerr << " Msg id: " << std::hex << it->first << std::dec << std::endl; std::cerr << " Origin: " << it->second.origin.toStdString() << std::endl; std::cerr << " Last : " << it->second.tried_friends.front().friend_id.toStdString() << std::endl; std::cerr << " Time : " << it->second.tried_friends.front().time_stamp << std::endl; std::cerr << " Flags : " << it->second.status_flags << std::endl; + std::cerr << " Dist : " << it->second.data_item->randomized_distance<< std::endl; std::cerr << " Probabilities: " << std::endl; std::map probas ; // friends probabilities for online friend list. @@ -326,7 +327,7 @@ void p3GRouter::routePendingObjects() // Compute the branching factor. - int N = computeBranchingFactor(probas,it->second.randomized_distance) ; + int N = computeBranchingFactor(probas,it->second.data_item->randomized_distance) ; // Now use this to select N random peers according to the given probabilities @@ -358,6 +359,8 @@ void p3GRouter::routePendingObjects() // send new_item->PeerId(*its) ; + new_item->randomized_distance += computeRandomDistanceIncrement(*its,new_item->destination_key) ; + sendItem(new_item) ; } @@ -384,6 +387,25 @@ void p3GRouter::routePendingObjects() } } +uint32_t p3GRouter::computeRandomDistanceIncrement(const RsPeerId& pid,const GRouterKeyId& destination_key) +{ + // This computes a consistent random bias between 0 and 255, which only depends on the + // destination key and the friend the item is going to be routed through. + // Makes it much harder for attakcers to figure out what is going on with + // distances in the network, and makes statistics about multiple sending + // attempts impossible. + // + static uint64_t random_salt = RSRandom::random_u64() ; + static const int total_size = RsPeerId::SIZE_IN_BYTES + GRouterKeyId::SIZE_IN_BYTES + sizeof(random_salt) ; + + unsigned char tmpmem[total_size] ; + *(uint64_t*)&tmpmem[0] = random_salt ; + memcpy(&tmpmem[sizeof(random_salt)],pid.toByteArray(),RsPeerId::SIZE_IN_BYTES) ; + memcpy(&tmpmem[sizeof(random_salt) + RsPeerId::SIZE_IN_BYTES],destination_key.toByteArray(),GRouterKeyId::SIZE_IN_BYTES) ; + + return RsDirUtil::sha1sum(tmpmem,total_size).toByteArray()[5] ; +} + uint32_t p3GRouter::computeBranchingFactor(const std::map& probas,uint32_t dist) { // This should be made a bit more adaptive ;-) @@ -474,10 +496,15 @@ bool p3GRouter::registerKey(const GRouterKeyId& key,const GRouterServiceId& clie { RsStackMutex mtx(grMtx) ; + if(_registered_services.find(client_id) == _registered_services.end()) + { + std::cerr << __PRETTY_FUNCTION__ << ": unable to register key " << key << " for client id " << client_id << ": client id is not known." << std::endl; + return false ; + } + GRouterPublishedKeyInfo info ; info.service_id = client_id ; info.description_string = description.substr(0,20); - info.validity_time = 0 ; // not used yet. info.last_published_time = 0 ; // means never published, se it will be re-published soon. _owned_key_ids[key] = info ; @@ -615,9 +642,11 @@ void p3GRouter::handleRecvACKItem(RsGRouterACKItem *item) _routing_matrix.addRoutingClue(it->second.data_item->destination_key,item->PeerId(),weight) ; } - std::cerr << " forwarding ACK to origin: " << it->second.origin.toStdString() << std::endl; - - sendACK(it->second.origin,item->mid,item->state) ; + if(it->second.origin != mLinkMgr->getOwnId()) + { + std::cerr << " forwarding ACK to origin: " << it->second.origin.toStdString() << std::endl; + sendACK(it->second.origin,item->mid,item->state) ; + } break ; case RS_GROUTER_ACK_STATE_GIVEN_UP: // route is bad. We forward back and update the routing matrix. @@ -696,31 +725,25 @@ void p3GRouter::handleRecvDataItem(RsGRouterGenericDataItem *item) // Is the item for us? If so, find the client service and send the item back. // if(it != _owned_key_ids.end()) - if(time(NULL) < it->second.validity_time) - { - if(itr->second.status_flags == RS_GROUTER_ROUTING_STATE_ARVD) - sendACK(item->PeerId(), item->routing_id, RS_GROUTER_ACK_STATE_RECEIVED_INDIRECTLY) ; - else - { - sendACK(item->PeerId(), item->routing_id, RS_GROUTER_ACK_STATE_RECEIVED) ; - itr->second.status_flags = RS_GROUTER_ROUTING_STATE_ARVD ; - - std::map::const_iterator its = _registered_services.find(it->second.service_id) ; - - if(its != _registered_services.end()) - { - std::cerr << " Key is owned by us. Notifying service for this item." << std::endl; - its->second->receiveGRouterData(it->first,item_copy) ; - } - else - std::cerr << " (EE) weird situation. No service registered for a key that we own. Key id = " << item->destination_key.toStdString() << ", service id = " << it->second.service_id << std::endl; - } - } + { + if(itr->second.status_flags == RS_GROUTER_ROUTING_STATE_ARVD) + sendACK(item->PeerId(), item->routing_id, RS_GROUTER_ACK_STATE_RECEIVED_INDIRECTLY) ; else { - std::cerr << " key is outdated. The item will be dropped." << std::endl; - return ; + sendACK(item->PeerId(), item->routing_id, RS_GROUTER_ACK_STATE_RECEIVED) ; + itr->second.status_flags = RS_GROUTER_ROUTING_STATE_ARVD ; + + std::map::const_iterator its = _registered_services.find(it->second.service_id) ; + + if(its != _registered_services.end()) + { + std::cerr << " Key is owned by us. Notifying service for this item." << std::endl; + its->second->receiveGRouterData(it->first,item_copy) ; + } + else + std::cerr << " (EE) weird situation. No service registered for a key that we own. Key id = " << item->destination_key.toStdString() << ", service id = " << it->second.service_id << std::endl; } + } else { std::cerr << " item is not for us. Storing in pending mode." << std::endl; @@ -747,7 +770,7 @@ void p3GRouter::sendData(const GRouterKeyId& destination, RsGRouterGenericDataIt info.data_item = item ; info.status_flags = RS_GROUTER_ROUTING_STATE_PEND ; info.origin = RsPeerId(mLinkMgr->getOwnId()) ; - info.received_time = time(NULL) ; + info.data_item->randomized_distance = 0 ; // Make sure we have a unique id (at least locally). // @@ -762,6 +785,7 @@ void p3GRouter::sendData(const GRouterKeyId& destination, RsGRouterGenericDataIt std::cerr << " data_item.byte = " << info.data_item->data_bytes << std::endl; std::cerr << " destination = " << info.data_item->destination_key << std::endl; std::cerr << " status = " << info.status_flags << std::endl; + std::cerr << " distance = " << info.data_item->randomized_distance << std::endl; std::cerr << " origin = " << info.origin.toStdString() << std::endl; std::cerr << " Recv time = " << info.received_time << std::endl; @@ -878,7 +902,8 @@ void p3GRouter::debugDump() for(std::map::iterator it(_pending_messages.begin());it!=_pending_messages.end();++it) std::cerr << " Msg id: " << std::hex << it->first << std::dec - << " Origin: " << it->second.origin.toStdString() + << " Local Origin: " << it->second.origin.toStdString() + << " Destination: " << it->second.data_item->destination_key << " Time : " << now - it->second.tried_friends.front().time_stamp << " secs ago." << " Status: " << statusString[it->second.status_flags] << std::endl; diff --git a/libretroshare/src/grouter/p3grouter.h b/libretroshare/src/grouter/p3grouter.h index 1bf5e2d17..462c2c196 100644 --- a/libretroshare/src/grouter/p3grouter.h +++ b/libretroshare/src/grouter/p3grouter.h @@ -133,8 +133,11 @@ class p3GRouter: public RsGRouter, public p3Service, public p3Config void debugDump() ; void locked_forwardKey(const RsGRouterPublishKeyItem&) ; + // utility functions + // static uint32_t computeBranchingFactor(const std::map& probas,uint32_t dist) ; static std::set computeRoutingFriends(const std::map& probas,uint32_t N) ; + static uint32_t computeRandomDistanceIncrement(const RsPeerId& pid,const GRouterKeyId& destination_id) ; //===================================================// // p3Config methods // diff --git a/libretroshare/src/gxs/gxssecurity.cc b/libretroshare/src/gxs/gxssecurity.cc index 47969d71b..d12e62e31 100644 --- a/libretroshare/src/gxs/gxssecurity.cc +++ b/libretroshare/src/gxs/gxssecurity.cc @@ -312,7 +312,7 @@ bool GxsSecurity::decrypt(void *& out, int & outlen, const void *in, int inlen, #ifdef DISTRIB_DEBUG std::cerr << "GxsSecurity::decrypt() " << std::endl; #endif - RSA *rsa_publish = RSAPublicKey_dup(extractPrivateKey(key)) ; + RSA *rsa_publish = RSAPrivateKey_dup(extractPrivateKey(key)) ; EVP_PKEY *privateKey = NULL; //RSA* rsa_publish = EVP_PKEY_get1_RSA(privateKey); diff --git a/libretroshare/src/services/p3msgservice.cc b/libretroshare/src/services/p3msgservice.cc index c7f770f96..e6b30ccbd 100644 --- a/libretroshare/src/services/p3msgservice.cc +++ b/libretroshare/src/services/p3msgservice.cc @@ -1855,6 +1855,8 @@ bool p3MsgService::decryptMessage(const std::string& mId) if(!GxsSecurity::decrypt(decrypted_data,decrypted_size,(void*)encrypted_data,encrypted_size,encryption_key)) throw std::runtime_error("Decryption failed!") ; + std::cerr << " First bytes of decrypted data: " << RsUtil::BinToHex((const char *)decrypted_data,std::min(decrypted_size,50)) << "..."<< std::endl; + uint8_t *decr_data = (uint8_t*)decrypted_data ; #ifdef DEBUG_DISTANT_MSG std::cerr << " Message has succesfully decrypted. Decrypted size = " << decrypted_size << std::endl; @@ -1873,14 +1875,15 @@ bool p3MsgService::decryptMessage(const std::string& mId) #ifdef DEBUG_DISTANT_MSG std::cerr << " Reading identity section " << std::endl; #endif - uint8_t ptag = decr_data[offset] ; + uint8_t ptag = decr_data[offset++] ; if(ptag != DISTANT_MSG_TAG_IDENTITY) throw std::runtime_error("Bad ptag in encrypted msg packet "+printNumber(ptag,true)+" => packet is dropped.") ; unsigned char *tmp_data = &decr_data[offset] ; + unsigned char *old_data = tmp_data ; uint32_t identity_size = PGPKeyParser::read_125Size(tmp_data) ; - offset += tmp_data - decr_data ; + offset += tmp_data - old_data ; if(identity_size != RsGxsId::SIZE_IN_BYTES) throw std::runtime_error("Bad size in Identity section " + printNumber(identity_size,false) + " => packet is dropped.") ; @@ -1893,19 +1896,21 @@ bool p3MsgService::decryptMessage(const std::string& mId) #endif // 2 - deserialize the item - ptag = decr_data[offset] ; + ptag = decr_data[offset++] ; if(ptag != DISTANT_MSG_TAG_CLEAR_MSG) throw std::runtime_error("Bad ptag in encrypted msg packet " + printNumber(ptag,true) + " => packet is dropped.") ; tmp_data = &decr_data[offset] ; + old_data = tmp_data ; uint32_t item_size = PGPKeyParser::read_125Size(tmp_data) ; - offset += tmp_data - decr_data ; + offset += tmp_data - old_data ; #ifdef DEBUG_DISTANT_MSG std::cerr << " Deserializing..." << std::endl; #endif RsMsgItem *item = dynamic_cast(_serialiser->deserialise(&decr_data[offset],&item_size)) ; + offset += item_size ; if(item == NULL) throw std::runtime_error("Decrypted message could not be deserialized.") ; @@ -1923,9 +1928,10 @@ bool p3MsgService::decryptMessage(const std::string& mId) if(ptag != DISTANT_MSG_TAG_SIGNATURE) throw std::runtime_error("Bad ptag in signature packet " + printNumber(ptag,true) + " => packet is dropped.") ; - unsigned char *tmp_data = &decr_data[offset] ; + tmp_data = &decr_data[offset] ; + old_data = tmp_data ; uint32_t signature_size = PGPKeyParser::read_125Size(tmp_data) ; - offset += tmp_data - decr_data ; + offset += tmp_data - old_data ; RsTlvKeySignature signature ; signature.keyId = senders_id.toStdString() ; @@ -2024,7 +2030,7 @@ bool p3MsgService::decryptMessage(const std::string& mId) void p3MsgService::connectToGlobalRouter(p3GRouter *gr) { mGRouter = gr ; - gr->registerClientService(RS_SERVICE_TYPE_MSG,this) ; + gr->registerClientService(GROUTER_CLIENT_ID_MESSAGES,this) ; } void p3MsgService::enableDistantMessaging(bool b)