Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2025-06-28 08:07:31 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

fixed compilation and several problems following separation of public/private keys

Browse source
This commit is contained in:
csoler 2016-06-04 21:39:40 -04:00
parent 590be092e5
commit a2ca0385db
16 changed files with 291 additions and 523 deletions
Download patch file Download diff file Expand all files Collapse all files

2
libretroshare/src/serialiser/rsgxsrecognitems.h
View file

@ -117,7 +117,7 @@ virtual void clear();
std::ostream &print(std::ostream &out, uint16_t indent = 0);
RsTlvServiceIdSet signing_classes;
RsTlvSecurityKey_deprecated key; // has from->to, and flags.
RsTlvPublicRSAKey key; // has from->to, and flags.
RsTlvKeySignature sign;
};

10
libretroshare/src/serialiser/rsnxsitems.cc
View file

@ -401,7 +401,7 @@ bool RsNxsGroupPublishKeyItem::serialise(void *data, uint32_t& size) const
return false ;
ok &= grpId.serialise(data, size, offset) ;
ok &= key.SetTlv(data, size, &offset) ;
ok &= private_key.SetTlv(data, size, &offset) ;
if(offset != tlvsize)
{
@ -811,7 +811,7 @@ RsNxsGroupPublishKeyItem* RsNxsSerialiser::deserialNxsGroupPublishKeyItem(void *
RsNxsGroupPublishKeyItem* item = new RsNxsGroupPublishKeyItem(SERVICE_TYPE);
ok &= item->grpId.deserialise(data, *size, offset);
ok &= item->key.GetTlv(data, *size, &offset) ;
ok &= item->private_key.GetTlv(data, *size, &offset) ;
if (offset != *size)
{
@ -957,7 +957,7 @@ uint32_t RsNxsGroupPublishKeyItem::serial_size() const
uint32_t s = 8; // header size
s += grpId.serial_size() ;
s += key.TlvSize();
s += private_key.TlvSize();
return s;
}
@ -1091,7 +1091,7 @@ void RsNxsSyncGrpReqItem::clear()
}
void RsNxsGroupPublishKeyItem::clear()
{
key.TlvClear();
private_key.TlvClear();
}
void RsNxsSyncMsgReqItem::clear()
{
@ -1163,7 +1163,7 @@ std::ostream& RsNxsGroupPublishKeyItem::print(std::ostream &out, uint16_t indent
printIndent(out , int_Indent);
out << "GroupId: " << grpId << std::endl;
printIndent(out , int_Indent);
out << "keyId: " << key.keyId << std::endl;
out << "keyId: " << private_key.keyId << std::endl;
printRsItemEnd(out ,"RsNxsGroupPublishKeyItem", indent);

3
libretroshare/src/serialiser/rsnxsitems.h
View file

@ -157,8 +157,7 @@ public:
virtual uint32_t serial_size() const;
RsGxsGroupId grpId ;
#warning should be renamed private_key
RsTlvPrivateRSAKey key ;
RsTlvPrivateRSAKey private_key ;
};

14
libretroshare/src/serialiser/rstlvbase.h
View file

@ -207,14 +207,16 @@ const uint16_t TLV_TYPE_GXSCIRCLEIDSET= 0x1026;
const uint16_t TLV_TYPE_SERVICESET = 0x1030;
const uint16_t TLV_TYPE_SECURITYKEY_deprecated = 0x1040;
const uint16_t TLV_TYPE_SECURITYKEYSET = 0x1041;
const uint16_t TLV_TYPE_RSA_KEY_PUBLIC = 0x1042;
const uint16_t TLV_TYPE_RSA_KEY_PRIVATE= 0x1043;
// *_deprectate should not be used anymore!!
// We use 1040 for both public and private keys, so that transmitting them still works (backward compatibility), and so that
// signatures are kept. But the two different classes will check that the flags are correct when deserialising.
const uint16_t TLV_TYPE_KEYSIGNATURE = 0x1050;
const uint16_t TLV_TYPE_SECURITY_KEY = 0x1040;
const uint16_t TLV_TYPE_SECURITYKEYSET = 0x1041;
const uint16_t TLV_TYPE_KEYSIGNATURE = 0x1050;
const uint16_t TLV_TYPE_KEYSIGNATURESET = 0x1051;
const uint16_t TLV_TYPE_KEYSIGNATURETYPE = 0x1052;
const uint16_t TLV_TYPE_KEYSIGNATURETYPE = 0x1052;
const uint16_t TLV_TYPE_IMAGE = 0x1060;

207
libretroshare/src/serialiser/rstlvkeys.cc
View file

@ -38,13 +38,13 @@
/************************************* RsTlvSecurityKey ************************************/
RsTlvSecurityKey_deprecated::RsTlvSecurityKey_deprecated()
RsTlvRSAKey::RsTlvRSAKey()
:RsTlvItem(), keyFlags(0), startTS(0), endTS(0), keyData(TLV_TYPE_KEY_EVP_PKEY)
{
return;
}
void RsTlvSecurityKey_deprecated::TlvClear()
void RsTlvRSAKey::TlvClear()
{
keyId.clear();
keyFlags = 0;
@ -54,7 +54,7 @@ void RsTlvSecurityKey_deprecated::TlvClear()
}
/* clears keyData - but doesn't delete */
void RsTlvSecurityKey_deprecated::ShallowClear()
void RsTlvRSAKey::ShallowClear()
{
keyId.clear();
keyFlags = 0;
@ -70,21 +70,6 @@ uint32_t RsTlvRSAKey::TlvSize() const
/* now add comment and title length of this tlv object */
s += keyId.serial_size();
s += 4;
s += 4;
s += 4;
s += keyData.TlvSize();
return s;
}
uint32_t RsTlvSecurityKey_deprecated::TlvSize() const
{
uint32_t s = TLV_HEADER_SIZE; /* header + 4 for size */
/* now add comment and title length of this tlv object */
#ifdef KEEP_OLD_SIGNATURE_SERIALISE_FORMAT
s += GetTlvStringSize(keyId.toStdString()) ;
#else
@ -116,44 +101,7 @@ bool RsTlvRSAKey::SetTlv(void *data, uint32_t size, uint32_t *offset) const
/* start at data[offset] */
/* add mandatory parts first */
ok &= SetTlvBase(data, tlvend, offset, tlvType(), tlvsize);
ok &= keyId.serialise(data, tlvend, *offset) ;
ok &= setRawUInt32(data, tlvend, offset, keyFlags);
ok &= setRawUInt32(data, tlvend, offset, startTS);
ok &= setRawUInt32(data, tlvend, offset, endTS);
ok &= keyData.SetTlv(data, tlvend, offset);
return ok;
}
bool RsTlvSecurityKey_deprecated::SetTlv(void *data, uint32_t size, uint32_t *offset) const
{
std::cerr << "(EE) Serialisation of an old security key format. Will not be done! callstack is:" << std::cerr << std::endl;
print_stacktrace() ;
#warning REMOVE THIS CODE BELOW WHEN IT IS NOT CALLED ANYMORE
/* must check sizes */
uint32_t tlvsize = TlvSize();
uint32_t tlvend = *offset + tlvsize;
if (size < tlvend)
{
//#ifdef TLV_DEBUG
std::cerr << "RsTlvSecurityKey::SetTlv() Failed not enough space";
std::cerr << std::endl;
//#endif
return false; /* not enough space */
}
bool ok = true;
/* start at data[offset] */
/* add mandatory parts first */
ok &= SetTlvBase(data, tlvend, offset, TLV_TYPE_SECURITYKEY_deprecated, tlvsize);
ok &= SetTlvBase(data, tlvend, offset, TLV_TYPE_SECURITY_KEY, tlvsize);
#ifdef KEEP_OLD_SIGNATURE_SERIALISE_FORMAT
ok &= SetTlvString(data, tlvend, offset, TLV_TYPE_STR_KEYID, keyId.toStdString());
#else
@ -186,7 +134,7 @@ bool RsTlvRSAKey::GetTlv(void *data, uint32_t size, uint32_t *offset)
return false; /* not enough space */
}
if (tlvtype != tlvType()) /* check type */
if (tlvtype != TLV_TYPE_SECURITY_KEY) /* check type */
{
#ifdef TLV_DEBUG
std::cerr << "RsTlvSecurityKey::GetTlv() Fail, wrong type";
@ -202,75 +150,6 @@ bool RsTlvRSAKey::GetTlv(void *data, uint32_t size, uint32_t *offset)
/* skip the header */
(*offset) += TLV_HEADER_SIZE;
ok &= keyId.deserialise(data, tlvend, *offset) ;
ok &= getRawUInt32(data, tlvend, offset, &(keyFlags));
ok &= getRawUInt32(data, tlvend, offset, &(startTS));
ok &= getRawUInt32(data, tlvend, offset, &(endTS));
ok &= keyData.GetTlv(data, tlvend, offset);
ok &= checkFlags(keyFlags) ;
/***************************************************************************
* NB: extra components could be added (for future expansion of the type).
* or be present (if this code is reading an extended version).
*
* We must chew up the extra characters to conform with TLV specifications
***************************************************************************/
if (*offset != tlvend)
{
#ifdef TLV_DEBUG
std::cerr << "RsTlvSecurityKey::GetTlv() Warning extra bytes at end of item";
std::cerr << std::endl;
#endif
*offset = tlvend;
}
if (!ok)
{
#ifdef TLV_DEBUG
std::cerr << "RsTlvSecurityKey::GetTlv() Failed somewhere ok == false";
std::cerr << std::endl;
#endif
}
return ok;
}
bool RsTlvSecurityKey_deprecated::GetTlv(void *data, uint32_t size, uint32_t *offset)
{
if (size < *offset + TLV_HEADER_SIZE)
return false;
uint16_t tlvtype = GetTlvType( &(((uint8_t *) data)[*offset]) );
uint32_t tlvsize = GetTlvSize( &(((uint8_t *) data)[*offset]) );
uint32_t tlvend = *offset + tlvsize;
if (size < tlvend) /* check size */
{
#ifdef TLV_DEBUG
std::cerr << "RsTlvSecurityKey::GetTlv() Fail, not enough space";
std::cerr << std::endl;
#endif
return false; /* not enough space */
}
if (tlvtype != TLV_TYPE_SECURITYKEY_deprecated) /* check type */
{
#ifdef TLV_DEBUG
std::cerr << "RsTlvSecurityKey::GetTlv() Fail, wrong type";
std::cerr << std::endl;
#endif
return false;
}
bool ok = true;
/* ready to load */
TlvClear();
/* skip the header */
(*offset) += TLV_HEADER_SIZE;
#ifdef KEEP_OLD_SIGNATURE_SERIALISE_FORMAT
std::string s ;
ok &= GetTlvString(data, tlvend, offset, TLV_TYPE_STR_KEYID, s);
@ -282,7 +161,6 @@ bool RsTlvSecurityKey_deprecated::GetTlv(void *data, uint32_t size, uint32_t *o
ok &= getRawUInt32(data, tlvend, offset, &(startTS));
ok &= getRawUInt32(data, tlvend, offset, &(endTS));
ok &= keyData.GetTlv(data, tlvend, offset);
/***************************************************************************
* NB: extra components could be added (for future expansion of the type).
@ -306,12 +184,10 @@ bool RsTlvSecurityKey_deprecated::GetTlv(void *data, uint32_t size, uint32_t *o
std::cerr << std::endl;
#endif
}
return ok;
return ok && checkFlags(keyFlags) ;
}
std::ostream &RsTlvSecurityKey_deprecated::print(std::ostream &out, uint16_t indent) const
std::ostream& RsTlvRSAKey::print(std::ostream &out, uint16_t indent) const
{
printBase(out, "RsTlvSecurityKey", indent);
uint16_t int_Indent = indent + 2;
@ -435,54 +311,30 @@ bool RsTlvSecurityKeySet::GetTlv(void *data, uint32_t size, uint32_t *offset)
/* get the next type */
uint16_t tlvsubtype = GetTlvType( &(((uint8_t *) data)[*offset]) );
// Security key set can be composed of public or private keys. We sort them into the correct bins after deserialisation
switch(tlvsubtype)
{
case TLV_TYPE_SECURITYKEY_deprecated:
case TLV_TYPE_SECURITY_KEY:
{
RsTlvSecurityKey_deprecated key;
uint32_t offset_save = *offset ;
ok &= key.GetTlv(data, size, offset);
RsTlvPublicRSAKey public_key;
if (ok)
if(public_key.GetTlv(data, tlvend, offset))
public_keys[public_key.keyId] = public_key;
else
{
std::cerr << "(WW) read RSA key with old format. Will be converted to new format. Flags=" << std::hex << key.keyFlags << std::dec << std::endl;
*offset = offset_save ;
if(key.keyFlags & RSTLV_KEY_TYPE_FULL)
private_keys[key.keyId] = RsTlvPrivateRSAKey(key);
else
public_keys[key.keyId] = RsTlvPublicRSAKey(key);
RsTlvPrivateRSAKey private_key;
key.TlvClear(); /* so that the Map can get control - should be ref counted*/
if(private_key.GetTlv(data, tlvend, offset))
private_keys[private_key.keyId] = private_key;
}
}
break ;
case TLV_TYPE_RSA_KEY_PRIVATE:
{
RsTlvPrivateRSAKey key;
if(key.GetTlv(data, size, offset))
private_keys[key.keyId] = key;
else
ok = false ;
key.TlvClear(); /* so that the Map can get control - should be ref counted*/
}
break;
case TLV_TYPE_RSA_KEY_PUBLIC:
{
RsTlvPublicRSAKey key;
if(key.GetTlv(data, size, offset))
public_keys[key.keyId] = key;
else
ok = false ;
key.TlvClear(); /* so that the Map can get control - should be ref counted*/
}
break;
default:
ok &= SkipUnknownTlv(data, tlvend, offset);
break;
@ -513,6 +365,7 @@ bool RsTlvSecurityKeySet::GetTlv(void *data, uint32_t size, uint32_t *offset)
return ok;
}
// prints out contents of RsTlvSecurityKeySet
std::ostream &RsTlvSecurityKeySet::print(std::ostream &out, uint16_t indent) const
{
@ -855,3 +708,23 @@ uint32_t RsTlvKeySignatureSet::TlvSize() const
return s;
}

46
libretroshare/src/serialiser/rstlvkeys.h
View file

@ -49,39 +49,17 @@ const uint32_t RSTLV_KEY_DISTRIB_MASK = 0x00f0;
// Old class for RsTlvSecurityKey. Is kept for backward compatibility, but should not be serialised anymore
class RsTlvSecurityKey_deprecated: public RsTlvItem
{
public:
RsTlvSecurityKey_deprecated();
virtual ~RsTlvSecurityKey_deprecated() {}
virtual uint32_t TlvSize() const;
virtual void TlvClear();
virtual bool SetTlv(void *data, uint32_t size, uint32_t *offset) const;
virtual bool GetTlv(void *data, uint32_t size, uint32_t *offset);
virtual std::ostream &print(std::ostream &out, uint16_t indent) const;
/* clears KeyData - but doesn't delete - to transfer ownership */
void ShallowClear();
RsGxsId keyId; // Mandatory :
uint32_t keyFlags; // Mandatory ;
uint32_t startTS; // Mandatory :
uint32_t endTS; // Mandatory :
RsTlvBinaryData keyData; // Mandatory :
};
class RsTlvRSAKey
class RsTlvRSAKey: public RsTlvItem
{
public:
virtual uint32_t tlvType() const = 0 ;
virtual bool checkFlags(uint32_t flags) const = 0 ;
RsTlvRSAKey();
virtual bool checkFlags(uint32_t flags) const = 0 ; // this pure virtual forces people to explicitly declare if they use a public or a private key.
virtual uint32_t TlvSize() const;
virtual void TlvClear();
virtual bool SetTlv(void *data, uint32_t size, uint32_t *offset) const;
virtual bool GetTlv(void *data, uint32_t size, uint32_t *offset);
virtual std::ostream &print(std::ostream &out, uint16_t indent) const;
virtual std::ostream& print(std::ostream &out, uint16_t indent) const;
/* clears KeyData - but doesn't delete - to transfer ownership */
void ShallowClear();
@ -100,24 +78,16 @@ public:
class RsTlvPrivateRSAKey: public RsTlvRSAKey
{
public:
RsTlvPrivateRSAKey();
explicit RsTlvPrivateRSAKey(RsTlvSecurityKey_deprecated& key); // convertion tool. Should be called explicitely and performs some checks
virtual ~RsTlvPrivateRSAKey() {}
virtual bool checkFlags(uint32_t flags) const { return bool(flags & RSTLV_KEY_TYPE_FULL) && !bool(flags & RSTLV_KEY_TYPE_PUBLIC_ONLY) ; }
virtual uint32_t tlvType() const { return TLV_TYPE_RSA_KEY_PRIVATE ; }
};
class RsTlvPublicRSAKey: public RsTlvRSAKey
{
#warning TEST IF WE CAN CONVERT PUBLIC TO PRIVATE AND VIS VERSA. NORMALLY WE SHOULDNT
public:
RsTlvPublicRSAKey();
virtual ~RsTlvPublicRSAKey() {}
explicit RsTlvPublicRSAKey(RsTlvSecurityKey_deprecated& key); // convertion tool. Should be called explicitely and performs some checks
virtual bool checkFlags(uint32_t flags) const { return bool(flags & RSTLV_KEY_TYPE_PUBLIC_ONLY) && !bool(flags & RSTLV_KEY_TYPE_FULL) ; }
virtual uint32_t tlvType() const { return TLV_TYPE_RSA_KEY_PUBLIC ; }
};
class RsTlvSecurityKeySet: public RsTlvItem
@ -126,7 +96,9 @@ public:
RsTlvSecurityKeySet() { return; }
virtual ~RsTlvSecurityKeySet() { return; }
void initFromPublicKeys(const RsTlvSecurityKeySet& skset) ;
// creates the public keys that are possible missing although the private keys are present.
void createPublicFromPrivateKeys();
virtual uint32_t TlvSize() const;
virtual void TlvClear();
@ -137,10 +109,6 @@ public:
std::string groupId; // Mandatory :
std::map<RsGxsId, RsTlvPublicRSAKey> public_keys; // Mandatory :
std::map<RsGxsId, RsTlvPrivateRSAKey> private_keys; // Mandatory :
//private:
// RsTlvSecurityKeySet& operator=(const RsTlvSecurityKeySet&) { std::cerr << "(EE) " <<__PRETTY_FUNCTION__ << " shouldn't be called!" << std::endl; return *this;}
// RsTlvSecurityKeySet(const RsTlvSecurityKeySet&) { std::cerr << "(EE) " <<__PRETTY_FUNCTION__ << " shouldn't be called!" << std::endl;}
};