PurpleI2P/i2pd
1
0
Fork 0
mirror of https://github.com/PurpleI2P/i2pd.git synced 2025-01-11 13:27:52 +00:00
Code Issues Releases Activity

extended identity for local destination

Browse Source
This commit is contained in:
orignal 2014-08-22 23:02:48 -04:00
parent 9b8460cffa
commit 2bc1ba1a9c
10 changed files with 59 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
Identity.cpp
View File

@ -77,6 +77,20 @@ namespace data
return *this;
}
IdentityEx& IdentityEx::operator=(const Identity& standard)
{
m_StandardIdentity = standard;
m_IdentHash = m_StandardIdentity.Hash ();
delete m_Verifier;
m_Verifier = nullptr;
delete[] m_ExtendedBuffer;
m_ExtendedBuffer = nullptr;
m_ExtendedLen = 0;
return *this;
}
size_t IdentityEx::FromBuffer (const uint8_t * buf, size_t len)
{
delete m_Verifier;
@ -99,7 +113,15 @@ namespace data
return GetFullLen ();
}
size_t IdentityEx::GetSigningPublicKeyLen ()
size_t IdentityEx::ToBuffer (uint8_t * buf, size_t len) const
{
memcpy (buf, &m_StandardIdentity, DEFAULT_IDENTITY_SIZE);
if (m_ExtendedLen > 0 && m_ExtendedBuffer)
memcpy (buf + DEFAULT_IDENTITY_SIZE, m_ExtendedBuffer, m_ExtendedLen);
return GetFullLen ();
}
size_t IdentityEx::GetSigningPublicKeyLen () const
{
if (!m_Verifier)
CreateVerifier ();
@ -108,7 +130,7 @@ namespace data
return 128;
}
size_t IdentityEx::GetSignatureLen ()
size_t IdentityEx::GetSignatureLen () const
{
if (!m_Verifier)
CreateVerifier ();
@ -125,7 +147,7 @@ namespace data
return false;
}
void IdentityEx::CreateVerifier ()
void IdentityEx::CreateVerifier () const
{
switch (m_StandardIdentity.certificate.type)
{

15
Identity.h
View File

@ -109,24 +109,26 @@ namespace data
IdentityEx (const IdentityEx& other);
~IdentityEx ();
IdentityEx& operator=(const IdentityEx& other);
IdentityEx& operator=(const Identity& standard);
size_t FromBuffer (const uint8_t * buf, size_t len);
size_t ToBuffer (uint8_t * buf, size_t len) const;
const Identity& GetStandardIdentity () const { return m_StandardIdentity; };
const IdentHash& GetIdentHash () const { return m_IdentHash; };
size_t GetFullLen () const { return m_ExtendedLen + DEFAULT_IDENTITY_SIZE; };
size_t GetSigningPublicKeyLen ();
size_t GetSignatureLen ();
size_t GetSigningPublicKeyLen () const;
size_t GetSignatureLen () const;
bool Verify (const uint8_t * buf, size_t len, const uint8_t * signature);
private:
void CreateVerifier ();
void CreateVerifier () const;
private:
Identity m_StandardIdentity;
IdentHash m_IdentHash;
i2p::crypto::Verifier * m_Verifier;
mutable i2p::crypto::Verifier * m_Verifier;
size_t m_ExtendedLen;
uint8_t * m_ExtendedBuffer;
};
@ -201,8 +203,7 @@ namespace data
public:
virtual ~LocalDestination() {};
virtual const IdentHash& GetIdentHash () const = 0;
virtual const Identity& GetIdentity () const = 0;
virtual const IdentityEx& GetIdentity () const = 0;
virtual const uint8_t * GetEncryptionPrivateKey () const = 0;
virtual const uint8_t * GetEncryptionPublicKey () const = 0;
virtual void Sign (const uint8_t * buf, int len, uint8_t * signature) const = 0;

20
LeaseSet.cpp
View File

@ -22,17 +22,18 @@ namespace data
LeaseSet::LeaseSet (const i2p::tunnel::TunnelPool& pool):
m_IsUnsolicited (false)
{
m_BufferLen = 0;
{
// header
const i2p::data::LocalDestination& localDestination = pool.GetLocalDestination ();
LeaseSetHeader * header = (LeaseSetHeader *)m_Buffer;
header->destination = localDestination.GetIdentity ();
memcpy (header->encryptionKey, localDestination.GetEncryptionPublicKey (), 256);
memset (header->signingKey, 0, 128);
m_BufferLen = localDestination.GetIdentity ().ToBuffer (m_Buffer, MAX_LS_BUFFER_SIZE);
memcpy (m_Buffer + m_BufferLen, localDestination.GetEncryptionPublicKey (), 256);
m_BufferLen += 256;
auto signingKeyLen = localDestination.GetIdentity ().GetSigningPublicKeyLen ();
memset (m_Buffer + m_BufferLen, 0, signingKeyLen);
m_BufferLen += signingKeyLen;
auto tunnels = pool.GetInboundTunnels (5); // 5 tunnels maximum
header->num = tunnels.size (); // num leases
m_BufferLen += sizeof (LeaseSetHeader);
m_Buffer[m_BufferLen] = tunnels.size (); // num leases
m_BufferLen++;
// leases
for (auto it: tunnels)
{
@ -45,8 +46,9 @@ namespace data
m_BufferLen += sizeof (Lease);
}
// signature
// TODO: signer
localDestination.Sign (m_Buffer, m_BufferLen, m_Buffer + m_BufferLen);
m_BufferLen += 40;
m_BufferLen += 40; // TODO:
LogPrint ("Local LeaseSet of ", tunnels.size (), " leases created");
ReadFromBuffer ();

8
LeaseSet.h
View File

@ -34,14 +34,6 @@ namespace data
}
};
struct LeaseSetHeader
{
Identity destination;
uint8_t encryptionKey[256];
uint8_t signingKey[128];
uint8_t num;
};
#pragma pack()
const int MAX_LS_BUFFER_SIZE = 2048;

4
RouterContext.cpp
View File

@ -44,6 +44,7 @@ namespace i2p
routerInfo.CreateBuffer ();
m_RouterInfo.Update (routerInfo.GetBuffer (), routerInfo.GetBufferLen ());
m_Identity = m_RouterInfo.GetRouterIdentity ();
}
void RouterContext::OverrideNTCPAddress (const char * host, int port)
@ -84,7 +85,8 @@ namespace i2p
i2p::data::RouterInfo routerInfo(i2p::util::filesystem::GetFullPath (ROUTER_INFO)); // TODO
m_RouterInfo.Update (routerInfo.GetBuffer (), routerInfo.GetBufferLen ());
m_Identity = m_RouterInfo.GetRouterIdentity ();
return true;
}

5
RouterContext.h
View File

@ -22,14 +22,14 @@ namespace i2p
const uint8_t * GetPrivateKey () const { return m_Keys.privateKey; };
const uint8_t * GetSigningPrivateKey () const { return m_Keys.signingPrivateKey; };
const i2p::data::Identity& GetRouterIdentity () const { return m_RouterInfo.GetRouterIdentity (); };
const i2p::data::IdentHash& GetRouterIdentHash () const { return m_RouterInfo.GetIdentHash (); };
CryptoPP::RandomNumberGenerator& GetRandomNumberGenerator () { return m_Rnd; };
void OverrideNTCPAddress (const char * host, int port); // temporary
void UpdateAddress (const char * host); // called from SSU
// implements LocalDestination
const i2p::data::IdentHash& GetIdentHash () const { return m_RouterInfo.GetIdentHash (); };
const i2p::data::Identity& GetIdentity () const { return GetRouterIdentity (); };
const i2p::data::IdentityEx& GetIdentity () const { return m_Identity; };
const uint8_t * GetEncryptionPrivateKey () const { return GetPrivateKey (); };
const uint8_t * GetEncryptionPublicKey () const { return m_Keys.publicKey; };
void Sign (const uint8_t * buf, int len, uint8_t * signature) const;
@ -45,6 +45,7 @@ namespace i2p
private:
i2p::data::RouterInfo m_RouterInfo;
i2p::data::IdentityEx m_Identity; // TODO: move to RI
i2p::data::Keys m_Keys;
CryptoPP::DSA::PrivateKey m_SigningPrivateKey;
CryptoPP::AutoSeededRandomPool m_Rnd;

8
Streaming.cpp
View File

@ -507,7 +507,7 @@ namespace stream
{
m_Keys = i2p::data::CreateRandomKeys ();
m_IdentHash = m_Keys.pub.Hash ();
m_Identity = m_Keys.pub;
m_SigningPrivateKey.Initialize (i2p::crypto::dsap, i2p::crypto::dsaq, i2p::crypto::dsag,
CryptoPP::Integer (m_Keys.signingPrivateKey, 20));
CryptoPP::DH dh (i2p::crypto::elgp, i2p::crypto::elgg);
@ -524,7 +524,7 @@ namespace stream
else
LogPrint ("Can't open file ", fullPath);
m_IdentHash = m_Keys.pub.Hash ();
m_Identity = m_Keys.pub;
m_SigningPrivateKey.Initialize (i2p::crypto::dsap, i2p::crypto::dsaq, i2p::crypto::dsag,
CryptoPP::Integer (m_Keys.signingPrivateKey, 20));
CryptoPP::DH dh (i2p::crypto::elgp, i2p::crypto::elgg);
@ -627,7 +627,7 @@ namespace stream
if (!m_SharedLocalDestination)
{
m_SharedLocalDestination = new StreamingDestination (m_Service);
m_Destinations[m_SharedLocalDestination->GetIdentHash ()] = m_SharedLocalDestination;
m_Destinations[m_SharedLocalDestination->GetIdentity ().GetIdentHash ()] = m_SharedLocalDestination;
}
LoadLocalDestinations ();
@ -673,7 +673,7 @@ namespace stream
it->path();
#endif
auto localDestination = new StreamingDestination (m_Service, fullPath);
m_Destinations[localDestination->GetIdentHash ()] = localDestination;
m_Destinations[localDestination->GetIdentity ().GetIdentHash ()] = localDestination;
numDestinations++;
}
}

5
Streaming.h
View File

@ -153,8 +153,7 @@ namespace stream
void HandleNextPacket (Packet * packet);
// implements LocalDestination
const i2p::data::IdentHash& GetIdentHash () const { return m_IdentHash; };
const i2p::data::Identity& GetIdentity () const { return m_Keys.pub; };
const i2p::data::IdentityEx& GetIdentity () const { return m_Identity; };
const uint8_t * GetEncryptionPrivateKey () const { return m_EncryptionPrivateKey; };
const uint8_t * GetEncryptionPublicKey () const { return m_EncryptionPublicKey; };
void Sign (const uint8_t * buf, int len, uint8_t * signature) const;
@ -170,7 +169,7 @@ namespace stream
boost::asio::io_service& m_Service;
std::map<uint32_t, Stream *> m_Streams;
i2p::data::PrivateKeys m_Keys;
i2p::data::IdentHash m_IdentHash;
i2p::data::IdentityEx m_Identity;
uint8_t m_EncryptionPublicKey[256], m_EncryptionPrivateKey[256];
i2p::tunnel::TunnelPool * m_Pool;

2
TunnelPool.cpp
View File

@ -195,7 +195,7 @@ namespace tunnel
{
// last hop
auto hop = outboundTunnel->GetTunnelConfig ()->GetFirstHop ()->router;
if (hop->GetIdentHash () != i2p::context.GetIdentHash ()) // outbound shouldn't be zero-hop tunnel
if (hop->GetIdentHash () != i2p::context.GetRouterIdentHash ()) // outbound shouldn't be zero-hop tunnel
{
prevHop = hop;
hops.push_back (prevHop);

4
TunnelPool.h
View File

@ -30,7 +30,7 @@ namespace tunnel
const uint8_t * GetEncryptionPrivateKey () const { return m_LocalDestination.GetEncryptionPrivateKey (); };
const uint8_t * GetEncryptionPublicKey () const { return m_LocalDestination.GetEncryptionPublicKey (); };
const i2p::data::LocalDestination& GetLocalDestination () const { return m_LocalDestination; };
bool IsExploratory () const { return m_LocalDestination.GetIdentHash () == i2p::context.GetIdentHash (); };
bool IsExploratory () const { return GetIdentHash () == i2p::context.GetRouterIdentHash (); };
void CreateTunnels ();
void TunnelCreated (InboundTunnel * createdTunnel);
@ -40,7 +40,7 @@ namespace tunnel
std::vector<InboundTunnel *> GetInboundTunnels (int num) const;
OutboundTunnel * GetNextOutboundTunnel (OutboundTunnel * suggested = nullptr);
InboundTunnel * GetNextInboundTunnel (InboundTunnel * suggested = nullptr);
const i2p::data::IdentHash& GetIdentHash () { return m_LocalDestination.GetIdentHash (); };
const i2p::data::IdentHash& GetIdentHash () const { return m_LocalDestination.GetIdentity ().GetIdentHash (); };
void TestTunnels ();
void ProcessDeliveryStatus (I2NPMessage * msg);