From 700c53e60ab469d31f84791c8ce98a31f84981bc Mon Sep 17 00:00:00 2001 From: "Francisco Blas (klondike) Izquierdo Riera" Date: Tue, 30 Dec 2014 15:37:24 +0100 Subject: [PATCH 1/2] Fix any remaning aliasing rules with propper memcpy wrappers --- Datagram.cpp | 2 +- Garlic.cpp | 18 ++++++------- I2NPProtocol.cpp | 14 +++++------ I2PEndian.h | 64 ++++++++++++++++++++++++++++++++++++++++------- Identity.cpp | 4 +-- NTCPSession.cpp | 12 ++++----- SSUData.cpp | 6 ++--- SSUSession.cpp | 44 ++++++++++++++++---------------- Streaming.cpp | 52 +++++++++++++++++++------------------- TransitTunnel.cpp | 2 +- TunnelGateway.cpp | 16 ++++++------ 11 files changed, 140 insertions(+), 94 deletions(-) diff --git a/Datagram.cpp b/Datagram.cpp index ec851ba7..410b9740 100644 --- a/Datagram.cpp +++ b/Datagram.cpp @@ -117,7 +117,7 @@ namespace datagram compressor.MessageEnd(); int size = compressor.MaxRetrievable (); uint8_t * buf = msg->GetPayload (); - *(uint32_t *)buf = htobe32 (size); // length + htobe32buf (buf, size); // length buf += 4; compressor.Get (buf, size); memset (buf + 4, 0, 4); // source and destination are zeroes diff --git a/Garlic.cpp b/Garlic.cpp index 62fd010f..1948806b 100644 --- a/Garlic.cpp +++ b/Garlic.cpp @@ -138,7 +138,7 @@ namespace garlic } // AES block len += CreateAESBlock (buf, msg); - *(uint32_t *)(m->GetPayload ()) = htobe32 (len); + htobe32buf (m->GetPayload (), len); m->len += len + 4; FillI2NPMessageHeader (m, eI2NPGarlic); if (msg) @@ -151,7 +151,7 @@ namespace garlic size_t blockSize = 0; bool createNewTags = m_Owner && m_NumTags && ((int)m_SessionTags.size () <= m_NumTags/2); UnconfirmedTags * newTags = createNewTags ? GenerateSessionTags () : nullptr; - *(uint16_t *)buf = newTags ? htobe16 (newTags->numTags) : 0; // tag count + htobuf16 (buf, newTags ? htobe16 (newTags->numTags) : 0); // tag count blockSize += 2; if (newTags) // session tags recreated { @@ -220,9 +220,9 @@ namespace garlic memset (payload + size, 0, 3); // certificate of message size += 3; - *(uint32_t *)(payload + size) = htobe32 (msgID); // MessageID + htobe32buf (payload + size, msgID); // MessageID size += 4; - *(uint64_t *)(payload + size) = htobe64 (ts); // Expiration of message + htobe64buf (payload + size, ts); // Expiration of message size += 8; return size; } @@ -246,9 +246,9 @@ namespace garlic memcpy (buf + size, msg->GetBuffer (), msg->GetLength ()); size += msg->GetLength (); - *(uint32_t *)(buf + size) = htobe32 (m_Rnd.GenerateWord32 ()); // CloveID + htobe32buf (buf + size, m_Rnd.GenerateWord32 ()); // CloveID size += 4; - *(uint64_t *)(buf + size) = htobe64 (ts); // Expiration of clove + htobe64buf (buf + size, ts); // Expiration of clove size += 8; memset (buf + size, 0, 3); // certificate of clove size += 3; @@ -269,7 +269,7 @@ namespace garlic // hash and tunnelID sequence is reversed for Garlic memcpy (buf + size, leases[i].tunnelGateway, 32); // To Hash size += 32; - *(uint32_t *)(buf + size) = htobe32 (leases[i].tunnelID); // tunnelID + htobe32buf (buf + size, leases[i].tunnelID); // tunnelID size += 4; // create msg I2NPMessage * msg = CreateDeliveryStatusMsg (msgID); @@ -288,9 +288,9 @@ namespace garlic DeleteI2NPMessage (msg); // fill clove uint64_t ts = i2p::util::GetMillisecondsSinceEpoch () + 5000; // 5 sec - *(uint32_t *)(buf + size) = htobe32 (m_Rnd.GenerateWord32 ()); // CloveID + htobe32buf (buf + size, m_Rnd.GenerateWord32 ()); // CloveID size += 4; - *(uint64_t *)(buf + size) = htobe64 (ts); // Expiration of clove + htobe64buf (buf + size, ts); // Expiration of clove size += 8; memset (buf + size, 0, 3); // certificate of clove size += 3; diff --git a/I2NPProtocol.cpp b/I2NPProtocol.cpp index 95079260..f09abbd7 100644 --- a/I2NPProtocol.cpp +++ b/I2NPProtocol.cpp @@ -115,7 +115,7 @@ namespace i2p if (replyTunnelID) { *buf = encryption ? 0x03: 0x01; // set delivery flag - *(uint32_t *)(buf+1) = htobe32 (replyTunnelID); + htobe32buf (buf+1, replyTunnelID); buf += 5; } else @@ -127,7 +127,7 @@ namespace i2p if (exploratory) { - *(uint16_t *)buf = htobe16 (1); // one exlude record + htobe16buf (buf,1); // one exlude record buf += 2; // reply with non-floodfill routers only memset (buf, 0, 32); @@ -138,7 +138,7 @@ namespace i2p if (excludedPeers) { int cnt = excludedPeers->size (); - *(uint16_t *)buf = htobe16 (cnt); + htobe16buf (buf, cnt); buf += 2; for (auto& it: *excludedPeers) { @@ -149,7 +149,7 @@ namespace i2p else { // nothing to exclude - *(uint16_t *)buf = htobe16 (0); + htobe16buf (buf, 0); buf += 2; } } @@ -210,7 +210,7 @@ namespace i2p compressor.MessageEnd(); auto size = compressor.MaxRetrievable (); uint8_t * buf = m->GetPayload () + sizeof (I2NPDatabaseStoreMsg); - *(uint16_t *)buf = htobe16 (size); // size + htobe16buf (buf, size); // size buf += 2; // TODO: check if size doesn't exceed buffer compressor.Get (buf, size); @@ -235,7 +235,7 @@ namespace i2p auto leases = leaseSet->GetNonExpiredLeases (); if (leases.size () > 0) { - *(uint32_t *)(payload + size) = htobe32 (leases[0].tunnelID); + htobe32buf (payload + size, leases[0].tunnelID); size += 4; // reply tunnelID memcpy (payload + size, leases[0].tunnelGateway, 32); size += 32; // reply tunnel gateway @@ -422,7 +422,7 @@ namespace i2p { I2NPMessage * msg = NewI2NPMessage (); memcpy (msg->GetPayload () + 4, payload, i2p::tunnel::TUNNEL_DATA_MSG_SIZE - 4); - *(uint32_t *)(msg->GetPayload ()) = htobe32 (tunnelID); + htobe32buf (msg->GetPayload (), tunnelID); msg->len += i2p::tunnel::TUNNEL_DATA_MSG_SIZE; FillI2NPMessageHeader (msg, eI2NPTunnelData); return msg; diff --git a/I2PEndian.h b/I2PEndian.h index cff68669..d8be0f82 100644 --- a/I2PEndian.h +++ b/I2PEndian.h @@ -47,27 +47,73 @@ uint64_t be64toh(uint64_t big64); #endif +inline uint16_t buf16toh(const uint8_t *buf) +{ + uint16_t b16; + memcpy(&b16, buf, sizeof(uint16_t)); + return b16; +} + +inline uint32_t buf32toh(const uint8_t *buf) +{ + uint32_t b32; + memcpy(&b32, buf, sizeof(uint32_t)); + return b32; +} + +inline uint64_t buf64toh(const uint8_t *buf) +{ + uint64_t b64; + memcpy(&b64, buf, sizeof(uint64_t)); + return b64; +} + inline uint16_t bufbe16toh(const uint8_t *buf) { - uint16_t big16; - memcpy(&big16, buf, sizeof(uint16_t)); - return be16toh(big16); + return be16toh(buf16toh(buf)); } inline uint32_t bufbe32toh(const uint8_t *buf) { - uint32_t big32; - memcpy(&big32, buf, sizeof(uint32_t)); - return be32toh(big32); + return be32toh(buf32toh(buf)); } inline uint64_t bufbe64toh(const uint8_t *buf) { - uint64_t big64; - memcpy(&big64, buf, sizeof(uint64_t)); - return be64toh(big64); + return be64toh(buf64toh(buf)); } +inline void htobuf16(uint8_t *buf, uint16_t b16) +{ + memcpy(buf, &b16, sizeof(uint16_t)); +} + +inline void htobuf32(uint8_t *buf, uint32_t b32) +{ + memcpy(buf, &b32, sizeof(uint32_t)); +} + +inline void htobuf64(uint8_t *buf, uint64_t b64) +{ + memcpy(buf, &b64, sizeof(uint64_t)); +} + +inline void htobe16buf(uint8_t *buf, uint16_t big16) +{ + htobuf16(buf, htobe16(big16)); +} + +inline void htobe32buf(uint8_t *buf, uint32_t big32) +{ + htobuf32(buf, htobe32(big32)); +} + +inline void htobe64buf(uint8_t *buf, uint64_t big64) +{ + htobuf64(buf, htobe64(big64)); +} + + #endif // I2PENDIAN_H__ diff --git a/Identity.cpp b/Identity.cpp index e7d9afcb..52920f6b 100644 --- a/Identity.cpp +++ b/Identity.cpp @@ -101,8 +101,8 @@ namespace data m_StandardIdentity.certificate.length = htobe16 (m_ExtendedLen); // fill extended buffer m_ExtendedBuffer = new uint8_t[m_ExtendedLen]; - *(uint16_t *)m_ExtendedBuffer = htobe16 (type); - *(uint16_t *)(m_ExtendedBuffer + 2) = htobe16 (CRYPTO_KEY_TYPE_ELGAMAL); + htobe16buf (m_ExtendedBuffer, type); + htobe16buf (m_ExtendedBuffer + 2, CRYPTO_KEY_TYPE_ELGAMAL); if (excessLen && excessBuf) { memcpy (m_ExtendedBuffer + 4, excessBuf, excessLen); diff --git a/NTCPSession.cpp b/NTCPSession.cpp index f16264f4..3f326098 100644 --- a/NTCPSession.cpp +++ b/NTCPSession.cpp @@ -274,11 +274,11 @@ namespace transport { auto keys = i2p::context.GetPrivateKeys (); uint8_t * buf = m_ReceiveBuffer; - *(uint16_t *)buf = htobe16 (keys.GetPublic ().GetFullLen ()); + htobe16buf (buf, keys.GetPublic ().GetFullLen ()); buf += 2; buf += i2p::context.GetIdentity ().ToBuffer (buf, NTCP_BUFFER_SIZE); uint32_t tsA = htobe32 (i2p::util::GetSecondsSinceEpoch ()); - *(uint32_t *)buf = tsA; + htobuf32(buf,tsA); buf += 4; size_t signatureLen = keys.GetPublic ().GetSignatureLen (); size_t len = (buf - m_ReceiveBuffer) + signatureLen; @@ -376,7 +376,7 @@ namespace transport void NTCPSession::HandlePhase3 (uint32_t tsB, size_t paddingLen) { uint8_t * buf = m_ReceiveBuffer + m_RemoteIdentity.GetFullLen () + 2 /*size*/; - uint32_t tsA = *(uint32_t *)buf; + uint32_t tsA = buf32toh(buf); buf += 4; buf += paddingLen; @@ -580,15 +580,15 @@ namespace transport } sendBuffer = msg->GetBuffer () - 2; len = msg->GetLength (); - *((uint16_t *)sendBuffer) = htobe16 (len); + htobe16buf (sendBuffer, len); } else { // prepare timestamp sendBuffer = m_TimeSyncBuffer; len = 4; - *((uint16_t *)sendBuffer) = 0; - *((uint32_t *)(sendBuffer + 2)) = htobe32 (time (0)); + htobuf16(sendBuffer, 0); + htobe32buf (sendBuffer + 2, time (0)); } int rem = (len + 6) & 0x0F; // %16 int padding = 0; diff --git a/SSUData.cpp b/SSUData.cpp index 596b7238..c6f0b5e5 100644 --- a/SSUData.cpp +++ b/SSUData.cpp @@ -316,7 +316,7 @@ namespace transport payload++; *payload = 1; // always 1 message fragment per message payload++; - *(uint32_t *)payload = msgID; + htobuf32(payload, msgID); payload += 4; bool isLast = (len <= payloadSize); size_t size = isLast ? len : payloadSize; @@ -359,7 +359,7 @@ namespace transport payload++; *payload = 1; // number of ACKs payload++; - *(uint32_t *)(payload) = htobe32 (msgID); // msgID + htobe32buf (payload, msgID); // msgID payload += 4; *payload = 0; // number of fragments @@ -382,7 +382,7 @@ namespace transport *payload = 1; // number of ACK bitfields payload++; // one ack - *(uint32_t *)(payload) = htobe32 (msgID); // msgID + htobe32buf (payload, msgID); // msgID payload += 4; div_t d = div (fragmentNum, 7); memset (payload, 0x80, d.quot); // 0x80 means non-last diff --git a/SSUSession.cpp b/SSUSession.cpp index fffc232d..e8e82d9b 100644 --- a/SSUSession.cpp +++ b/SSUSession.cpp @@ -299,18 +299,18 @@ namespace transport uint8_t buf[96 + 18]; uint8_t * payload = buf + sizeof (SSUHeader); - *(uint32_t *)payload = htobe32 (iTag); + htobe32buf (payload, iTag); payload += 4; *payload = 0; // no address payload++; - *(uint16_t *)payload = 0; // port = 0 + htobuf16(payload, 0); // port = 0 payload += 2; *payload = 0; // challenge payload++; memcpy (payload, (const uint8_t *)address->key, 32); payload += 32; CryptoPP::RandomNumberGenerator& rnd = i2p::context.GetRandomNumberGenerator (); - *(uint32_t *)payload = htobe32 (rnd.GenerateWord32 ()); // nonce + htobe32buf (payload, rnd.GenerateWord32 ()); // nonce uint8_t iv[16]; rnd.GenerateBlock (iv, 16); // random iv @@ -358,7 +358,7 @@ namespace transport s.Insert (payload, 16); // remote endpoint IP V6 payload += 16; } - *(uint16_t *)(payload) = htobe16 (m_RemoteEndpoint.port ()); + htobe16buf (payload, m_RemoteEndpoint.port ()); s.Insert (payload, 2); // remote port payload += 2; if (address->host.is_v4 ()) @@ -373,9 +373,9 @@ namespace transport if (!relayTag) relayTag = 1; m_Server.AddRelay (relayTag, m_RemoteEndpoint); } - *(uint32_t *)(payload) = htobe32 (relayTag); + htobe32buf (payload, relayTag); payload += 4; // relay tag - *(uint32_t *)(payload) = htobe32 (i2p::util::GetSecondsSinceEpoch ()); // signed on time + htobe32buf (payload, i2p::util::GetSecondsSinceEpoch ()); // signed on time payload += 4; s.Insert (payload - 8, 8); // relayTag and signed on time s.Sign (i2p::context.GetPrivateKeys (), payload); // DSA signature @@ -404,12 +404,12 @@ namespace transport *payload = 1; // 1 fragment payload++; // info size_t identLen = i2p::context.GetIdentity ().GetFullLen (); // 387+ bytes - *(uint16_t *)(payload) = htobe16 (identLen); + htobe16buf (payload, identLen); payload += 2; // cursize i2p::context.GetIdentity ().ToBuffer (payload, identLen); payload += identLen; uint32_t signedOnTime = i2p::util::GetSecondsSinceEpoch (); - *(uint32_t *)(payload) = htobe32 (signedOnTime); // signed on time + htobe32buf (payload, signedOnTime); // signed on time payload += 4; auto signatureLen = i2p::context.GetIdentity ().GetSignatureLen (); size_t paddingSize = ((payload - buf) + signatureLen)%16; @@ -476,9 +476,9 @@ namespace transport } *payload = 4; payload++; // size - *(uint32_t *)payload = htobe32 (to.address ().to_v4 ().to_ulong ()); // Charlie's IP + htobe32buf (payload, to.address ().to_v4 ().to_ulong ()); // Charlie's IP payload += 4; // address - *(uint16_t *)payload = htobe16 (to.port ()); // Charlie's port + htobe16buf (payload, to.port ()); // Charlie's port payload += 2; // port // Alice bool isV4 = from.address ().is_v4 (); // Alice's @@ -496,9 +496,9 @@ namespace transport memcpy (payload, from.address ().to_v6 ().to_bytes ().data (), 16); // Alice's IP V6 payload += 16; // address } - *(uint16_t *)payload = htobe16 (from.port ()); // Alice's port + htobe16buf (payload, from.port ()); // Alice's port payload += 2; // port - *(uint32_t *)payload = htobe32 (nonce); + htobe32buf (payload, nonce); if (m_State == eSessionStateEstablished) { @@ -531,9 +531,9 @@ namespace transport uint8_t * payload = buf + sizeof (SSUHeader); *payload = 4; payload++; // size - *(uint32_t *)payload = htobe32 (from.address ().to_v4 ().to_ulong ()); // Alice's IP + htobe32buf (payload, from.address ().to_v4 ().to_ulong ()); // Alice's IP payload += 4; // address - *(uint16_t *)payload = htobe16 (from.port ()); // Alice's port + htobe16buf (payload, from.port ()); // Alice's port payload += 2; // port *payload = 0; // challenge size uint8_t iv[16]; @@ -612,7 +612,7 @@ namespace transport encryption.Encrypt (encrypted, encryptedLen, encrypted); // assume actual buffer size is 18 (16 + 2) bytes more memcpy (buf + len, iv, 16); - *(uint16_t *)(buf + len + 16) = htobe16 (encryptedLen); + htobe16buf (buf + len + 16, encryptedLen); i2p::crypto::HMACMD5Digest (encrypted, encryptedLen + 18, macKey, header->mac); } @@ -633,7 +633,7 @@ namespace transport m_SessionKeyEncryption.Encrypt (encrypted, encryptedLen, encrypted); // assume actual buffer size is 18 (16 + 2) bytes more memcpy (buf + len, header->iv, 16); - *(uint16_t *)(buf + len + 16) = htobe16 (encryptedLen); + htobe16buf (buf + len + 16, encryptedLen); i2p::crypto::HMACMD5Digest (encrypted, encryptedLen + 18, m_MacKey, header->mac); } @@ -682,7 +682,7 @@ namespace transport uint16_t encryptedLen = len - (encrypted - buf); // assume actual buffer size is 18 (16 + 2) bytes more memcpy (buf + len, header->iv, 16); - *(uint16_t *)(buf + len + 16) = htobe16 (encryptedLen); + htobe16buf (buf + len + 16, encryptedLen); uint8_t digest[16]; i2p::crypto::HMACMD5Digest (encrypted, encryptedLen + 18, macKey, digest); return !memcmp (header->mac, digest, 16); @@ -849,9 +849,9 @@ namespace transport uint8_t size = *buf; buf++; // size - uint32_t address = (size == 4) ? *(uint32_t *)buf : 0; // use it as is + uint32_t address = (size == 4) ? buf32toh(buf) : 0; // use it as is buf += size; // address - uint16_t port = *(uint16_t *)buf; // use it as is + uint16_t port = buf16toh(buf); // use it as is buf += 2; // port uint8_t * introKey = buf; if (port && !address) @@ -915,13 +915,13 @@ namespace transport uint8_t buf[80 + 18]; uint8_t iv[16]; uint8_t * payload = buf + sizeof (SSUHeader); - *(uint32_t *)payload = htobe32 (nonce); + htobe32buf (payload, nonce); payload += 4; // nonce if (address) { *payload = 4; payload++; // size - *(uint32_t *)payload = htobe32 (address); + htobe32buf (payload, address); payload += 4; // address } else @@ -929,7 +929,7 @@ namespace transport *payload = 0; payload++; //size } - *(uint16_t *)payload = htobe16 (port); + htobe16buf (payload, port); payload += 2; // port memcpy (payload, introKey, 32); // intro key diff --git a/Streaming.cpp b/Streaming.cpp index fa353275..3aa5f835 100644 --- a/Streaming.cpp +++ b/Streaming.cpp @@ -256,16 +256,16 @@ namespace stream uint8_t * packet = p->GetBuffer (); // TODO: implement setters size_t size = 0; - *(uint32_t *)(packet + size) = htobe32 (m_SendStreamID); + htobe32buf (packet + size, m_SendStreamID); size += 4; // sendStreamID - *(uint32_t *)(packet + size) = htobe32 (m_RecvStreamID); + htobe32buf (packet + size, m_RecvStreamID); size += 4; // receiveStreamID - *(uint32_t *)(packet + size) = htobe32 (m_SequenceNumber++); + htobe32buf (packet + size, m_SequenceNumber++); size += 4; // sequenceNum if (isNoAck) - *(uint32_t *)(packet + size) = htobe32 (m_LastReceivedSequenceNumber); + htobe32buf (packet + size, m_LastReceivedSequenceNumber); else - *(uint32_t *)(packet + size) = 0; + htobuf32 (packet + size, 0); size += 4; // ack Through packet[size] = 0; size++; // NACK count @@ -277,15 +277,15 @@ namespace stream uint16_t flags = PACKET_FLAG_SYNCHRONIZE | PACKET_FLAG_FROM_INCLUDED | PACKET_FLAG_SIGNATURE_INCLUDED | PACKET_FLAG_MAX_PACKET_SIZE_INCLUDED; if (isNoAck) flags |= PACKET_FLAG_NO_ACK; - *(uint16_t *)(packet + size) = htobe16 (flags); + htobe16buf (packet + size, flags); size += 2; // flags size_t identityLen = m_LocalDestination.GetOwner ().GetIdentity ().GetFullLen (); size_t signatureLen = m_LocalDestination.GetOwner ().GetIdentity ().GetSignatureLen (); - *(uint16_t *)(packet + size) = htobe16 (identityLen + signatureLen + 2); // identity + signature + packet size + htobe16buf (packet + size, identityLen + signatureLen + 2); // identity + signature + packet size size += 2; // options size m_LocalDestination.GetOwner ().GetIdentity ().ToBuffer (packet + size, identityLen); size += identityLen; // from - *(uint16_t *)(packet + size) = htobe16 (STREAMING_MTU); + htobe16buf (packet + size, STREAMING_MTU); size += 2; // max packet size uint8_t * signature = packet + size; // set it later memset (signature, 0, signatureLen); // zeroes for now @@ -301,9 +301,9 @@ namespace stream else { // follow on packet - *(uint16_t *)(packet + size) = 0; + htobuf16 (packet + size, 0); size += 2; // flags - *(uint16_t *)(packet + size) = 0; // no options + htobuf16 (packet + size, 0); // no options size += 2; // options size size_t sentLen = STREAMING_MTU - size; if (len < sentLen) sentLen = len; @@ -338,13 +338,13 @@ namespace stream Packet p; uint8_t * packet = p.GetBuffer (); size_t size = 0; - *(uint32_t *)(packet + size) = htobe32 (m_SendStreamID); + htobe32buf (packet + size, m_SendStreamID); size += 4; // sendStreamID - *(uint32_t *)(packet + size) = htobe32 (m_RecvStreamID); + htobe32buf (packet + size, m_RecvStreamID); size += 4; // receiveStreamID - *(uint32_t *)(packet + size) = 0; // this is plain Ack message + htobuf32 (packet + size, 0); // this is plain Ack message size += 4; // sequenceNum - *(uint32_t *)(packet + size) = htobe32 (lastReceivedSeqn); + htobe32buf (packet + size, lastReceivedSeqn); size += 4; // ack Through if (lastReceivedSeqn > m_LastReceivedSequenceNumber) { @@ -357,7 +357,7 @@ namespace stream auto seqn = it->GetSeqn (); for (uint32_t i = nextSeqn; i < seqn; i++) { - *(uint32_t *)nacks = htobe32 (i); + htobe32buf (nacks, i); nacks += 4; numNacks++; } @@ -374,9 +374,9 @@ namespace stream size++; // NACK count } size++; // resend delay - *(uint16_t *)(packet + size) = 0; // nof flags set + htobuf16 (packet + size, 0); // nof flags set size += 2; // flags - *(uint16_t *)(packet + size) = 0; // no options + htobuf16 (packet + size, 0); // no options size += 2; // options size p.len = size; @@ -392,21 +392,21 @@ namespace stream Packet * p = new Packet (); uint8_t * packet = p->GetBuffer (); size_t size = 0; - *(uint32_t *)(packet + size) = htobe32 (m_SendStreamID); + htobe32buf (packet + size, m_SendStreamID); size += 4; // sendStreamID - *(uint32_t *)(packet + size) = htobe32 (m_RecvStreamID); + htobe32buf (packet + size, m_RecvStreamID); size += 4; // receiveStreamID - *(uint32_t *)(packet + size) = htobe32 (m_SequenceNumber++); + htobe32buf (packet + size, m_SequenceNumber++); size += 4; // sequenceNum - *(uint32_t *)(packet + size) = htobe32 (m_LastReceivedSequenceNumber); + htobe32buf (packet + size, m_LastReceivedSequenceNumber); size += 4; // ack Through packet[size] = 0; size++; // NACK count size++; // resend delay - *(uint16_t *)(packet + size) = htobe16 (PACKET_FLAG_CLOSE | PACKET_FLAG_SIGNATURE_INCLUDED); + htobe16buf (packet + size, PACKET_FLAG_CLOSE | PACKET_FLAG_SIGNATURE_INCLUDED); size += 2; // flags size_t signatureLen = m_LocalDestination.GetOwner ().GetIdentity ().GetSignatureLen (); - *(uint16_t *)(packet + size) = htobe16 (signatureLen); // signature only + htobe16buf (packet + size, signatureLen); // signature only size += 2; // options size uint8_t * signature = packet + size; memset (packet + size, 0, signatureLen); @@ -617,11 +617,11 @@ namespace stream compressor.MessageEnd(); int size = compressor.MaxRetrievable (); uint8_t * buf = msg->GetPayload (); - *(uint32_t *)buf = htobe32 (size); // length + htobe32buf (buf, size); // length buf += 4; compressor.Get (buf, size); - *(uint16_t *)(buf + 4) = 0; // source port - *(uint16_t *)(buf + 6) = htobe16 (m_Port); // destination port + htobuf16(buf + 4, 0); // source port + htobe16buf (buf + 6, m_Port); // destination port buf[9] = i2p::client::PROTOCOL_TYPE_STREAMING; // streaming protocol msg->len += size + 4; FillI2NPMessageHeader (msg, eI2NPData); diff --git a/TransitTunnel.cpp b/TransitTunnel.cpp index 25b82424..1f755be5 100644 --- a/TransitTunnel.cpp +++ b/TransitTunnel.cpp @@ -31,7 +31,7 @@ namespace tunnel LogPrint ("TransitTunnel: ",m_TunnelID,"->", m_NextTunnelID); m_NumTransmittedBytes += tunnelMsg->GetLength (); - *(uint32_t *)(tunnelMsg->GetPayload ()) = htobe32 (m_NextTunnelID); + htobe32buf (tunnelMsg->GetPayload (), m_NextTunnelID); FillI2NPMessageHeader (tunnelMsg, eI2NPTunnelData); i2p::transport::transports.SendMessage (m_NextIdent, tunnelMsg); diff --git a/TunnelGateway.cpp b/TunnelGateway.cpp index d2f26bd9..3b3980e0 100644 --- a/TunnelGateway.cpp +++ b/TunnelGateway.cpp @@ -26,7 +26,7 @@ namespace tunnel { if (block.deliveryType == eDeliveryTypeTunnel) { - *(uint32_t *)(di + diLen) = htobe32 (block.tunnelID); + htobe32buf (di + diLen, block.tunnelID); diLen += 4; // tunnelID } @@ -41,7 +41,7 @@ namespace tunnel if (fullMsgLen <= m_RemainingSize) { // message fits. First and last fragment - *(uint16_t *)(di + diLen) = htobe16 (msg->GetLength ()); + htobe16buf (di + diLen, msg->GetLength ()); diLen += 2; // size memcpy (m_CurrentTunnelDataMsg->buf + m_CurrentTunnelDataMsg->len, di, diLen); memcpy (m_CurrentTunnelDataMsg->buf + m_CurrentTunnelDataMsg->len + diLen, msg->GetBuffer (), msg->GetLength ()); @@ -73,9 +73,9 @@ namespace tunnel // first fragment di[0] |= 0x08; // fragmented - *(uint32_t *)(di + diLen) = msgID; + htobuf32 (di + diLen, msgID); diLen += 4; // Message ID - *(uint16_t *)(di + diLen) = htobe16 (size); + htobe16buf (di + diLen, size); diLen += 2; // size memcpy (m_CurrentTunnelDataMsg->buf + m_CurrentTunnelDataMsg->len, di, diLen); memcpy (m_CurrentTunnelDataMsg->buf + m_CurrentTunnelDataMsg->len + diLen, msg->GetBuffer (), size); @@ -96,9 +96,9 @@ namespace tunnel { buf[0] |= 0x01; isLastFragment = true; - } - *(uint32_t *)(buf + 1) = msgID; //Message ID - *(uint16_t *)(buf + 5) = htobe16 (s); // size + } + htobuf32 (buf + 1, msgID); //Message ID + htobe16buf (buf + 5, s); // size memcpy (buf + 7, msg->GetBuffer () + size, s); m_CurrentTunnelDataMsg->len += s+7; if (isLastFragment) @@ -147,7 +147,7 @@ namespace tunnel m_CurrentTunnelDataMsg->offset = m_CurrentTunnelDataMsg->len - TUNNEL_DATA_MSG_SIZE - sizeof (I2NPHeader); uint8_t * buf = m_CurrentTunnelDataMsg->GetPayload (); - *(uint32_t *)(buf) = htobe32 (m_TunnelID); + htobe32buf (buf, m_TunnelID); CryptoPP::RandomNumberGenerator& rnd = i2p::context.GetRandomNumberGenerator (); rnd.GenerateBlock (buf + 4, 16); // original IV memcpy (payload + size, buf + 4, 16); // copy IV for checksum From b5f624a10f4b6ad4c8b39918e44e6ef31a56eb8e Mon Sep 17 00:00:00 2001 From: "Francisco Blas (klondike) Izquierdo Riera" Date: Tue, 30 Dec 2014 15:42:24 +0100 Subject: [PATCH 2/2] Use htobuf16 for 0 value instead of htobe16buf --- I2NPProtocol.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/I2NPProtocol.cpp b/I2NPProtocol.cpp index f09abbd7..eba49fa8 100644 --- a/I2NPProtocol.cpp +++ b/I2NPProtocol.cpp @@ -149,7 +149,7 @@ namespace i2p else { // nothing to exclude - htobe16buf (buf, 0); + htobuf16 (buf, 0); buf += 2; } }