net: Treat raw message bytes as uint8_t

Summary: This is a backport of [[bitcoin/bitcoin#20432 | core#20432]]

Test Plan: `ninja all check-all bitcoin-fuzzers`

Reviewers: #bitcoin_abc, Fabien

Reviewed By: #bitcoin_abc, Fabien

Differential Revision: https://reviews.bitcoinabc.org/D11090

Author: MarcoFalke

src/net.cpp

@@ -656,7 +656,7 @@ void CNode::copyStats(CNodeStats &stats) {
     stats.m_conn_type_string = ConnectionTypeAsString();
 }
 
-bool CNode::ReceiveMsgBytes(const Config &config, Span<const char> msg_bytes,
+bool CNode::ReceiveMsgBytes(const Config &config, Span<const uint8_t> msg_bytes,
                             bool &complete) {
     complete = false;
     const auto time = GetTime<std::chrono::microseconds>();
@@ -696,7 +696,7 @@ bool CNode::ReceiveMsgBytes(const Config &config, Span<const char> msg_bytes,
 }
 
 int V1TransportDeserializer::readHeader(const Config &config,
-                                        Span<const char> msg_bytes) {
+                                        Span<const uint8_t> msg_bytes) {
     // copy data to temporary parsing buffer
     uint32_t nRemaining = CMessageHeader::HEADER_SIZE - nHdrPos;
     uint32_t nCopy = std::min<unsigned int>(nRemaining, msg_bytes.size());
@@ -728,7 +728,7 @@ int V1TransportDeserializer::readHeader(const Config &config,
     return nCopy;
 }
 
-int V1TransportDeserializer::readData(Span<const char> msg_bytes) {
+int V1TransportDeserializer::readData(Span<const uint8_t> msg_bytes) {
     unsigned int nRemaining = hdr.nMessageSize - nDataPos;
     unsigned int nCopy = std::min<unsigned int>(nRemaining, msg_bytes.size());
 
@@ -738,7 +738,7 @@ int V1TransportDeserializer::readData(Span<const char> msg_bytes) {
         vRecv.resize(std::min(hdr.nMessageSize, nDataPos + nCopy + 256 * 1024));
     }
 
-    hasher.Write(MakeUCharSpan(msg_bytes.first(nCopy)));
+    hasher.Write(msg_bytes.first(nCopy));
     memcpy(&vRecv[nDataPos], msg_bytes.data(), nCopy);
     nDataPos += nCopy;
 
@@ -1819,20 +1819,20 @@ void CConnman::SocketHandler() {
         }
         if (recvSet || errorSet) {
             // typical socket buffer is 8K-64K
-            char pchBuf[0x10000];
+            uint8_t pchBuf[0x10000];
             int32_t nBytes = 0;
             {
                 LOCK(pnode->cs_hSocket);
                 if (pnode->hSocket == INVALID_SOCKET) {
                     continue;
                 }
-                nBytes =
-                    recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
+                nBytes = recv(pnode->hSocket, (char *)pchBuf, sizeof(pchBuf),
+                              MSG_DONTWAIT);
             }
             if (nBytes > 0) {
                 bool notify = false;
                 if (!pnode->ReceiveMsgBytes(
-                        *config, Span<const char>(pchBuf, nBytes), notify)) {
+                        *config, Span<const uint8_t>(pchBuf, nBytes), notify)) {
                     pnode->CloseSocketDisconnect();
                 }
                 RecordBytesRecv(nBytes);

src/net.h

@@ -357,7 +357,7 @@ class TransportDeserializer {
     // set the serialization context version
     virtual void SetVersion(int version) = 0;
     /** read and deserialize data, advances msg_bytes data pointer */
-    virtual int Read(const Config &config, Span<const char> &msg_bytes) = 0;
+    virtual int Read(const Config &config, Span<const uint8_t> &msg_bytes) = 0;
     // decomposes a message from the context
     virtual CNetMessage GetMessage(const Config &config,
                                    std::chrono::microseconds time) = 0;
@@ -381,8 +381,8 @@ class V1TransportDeserializer final : public TransportDeserializer {
     uint32_t nDataPos;
 
     const uint256 &GetMessageHash() const;
-    int readHeader(const Config &config, Span<const char> msg_bytes);
-    int readData(Span<const char> msg_bytes);
+    int readHeader(const Config &config, Span<const uint8_t> msg_bytes);
+    int readData(Span<const uint8_t> msg_bytes);
 
     void Reset() {
         vRecv.clear();
@@ -416,7 +416,7 @@ class V1TransportDeserializer final : public TransportDeserializer {
         hdrbuf.SetVersion(nVersionIn);
         vRecv.SetVersion(nVersionIn);
     }
-    int Read(const Config &config, Span<const char> &msg_bytes) override {
+    int Read(const Config &config, Span<const uint8_t> &msg_bytes) override {
         int ret = in_data ? readData(msg_bytes) : readHeader(config, msg_bytes);
         if (ret < 0) {
             Reset();
@@ -815,7 +815,7 @@ class CNode {
      * @return  True if the peer should stay connected,
      *          False if the peer should be disconnected from.
      */
-    bool ReceiveMsgBytes(const Config &config, Span<const char> msg_bytes,
+    bool ReceiveMsgBytes(const Config &config, Span<const uint8_t> msg_bytes,
                          bool &complete);
 
     void SetCommonVersion(int greatest_common_version) {

src/test/fuzz/net.cpp

@@ -113,8 +113,7 @@ void test_one_input(const std::vector<uint8_t> &buffer) {
                 const std::vector<uint8_t> b =
                     ConsumeRandomLengthByteVector(fuzzed_data_provider);
                 bool complete;
-                node.ReceiveMsgBytes(config, {(const char *)b.data(), b.size()},
-                                     complete);
+                node.ReceiveMsgBytes(config, b, complete);
                 break;
             }
         }

src/test/fuzz/p2p_transport_deserializer.cpp

@@ -22,7 +22,7 @@ void test_one_input(const std::vector<uint8_t> &buffer) {
     const Config &config = GetConfig();
     V1TransportDeserializer deserializer{config.GetChainParams().NetMagic(),
                                          SER_NETWORK, INIT_PROTO_VERSION};
-    Span<const char> msg_bytes{(const char *)buffer.data(), buffer.size()};
+    Span<const uint8_t> msg_bytes{buffer};
     while (msg_bytes.size() > 0) {
         const int handled = deserializer.Read(config, msg_bytes);
         if (handled < 0) {

src/test/util/net.cpp

@@ -12,7 +12,7 @@
 #include <vector>
 
 void ConnmanTestMsg::NodeReceiveMsgBytes(CNode &node,
-                                         Span<const char> msg_bytes,
+                                         Span<const uint8_t> msg_bytes,
                                          bool &complete) const {
     assert(node.ReceiveMsgBytes(*config, msg_bytes, complete));
     if (complete) {
@@ -40,12 +40,8 @@ bool ConnmanTestMsg::ReceiveMsgFrom(CNode &node,
     node.m_serializer->prepareForTransport(*config, ser_msg, ser_msg_header);
 
     bool complete;
-    NodeReceiveMsgBytes(
-        node, {(const char *)ser_msg_header.data(), ser_msg_header.size()},
-        complete);
-    NodeReceiveMsgBytes(
-        node, {(const char *)ser_msg.data.data(), ser_msg.data.size()},
-        complete);
+    NodeReceiveMsgBytes(node, ser_msg_header, complete);
+    NodeReceiveMsgBytes(node, ser_msg.data, complete);
     return complete;
 }
 

src/test/util/net.h

@@ -38,7 +38,7 @@ struct ConnmanTestMsg : public CConnman {
         m_msgproc->ProcessMessages(*config, &node, flagInterruptMsgProc);
     }
 
-    void NodeReceiveMsgBytes(CNode &node, Span<const char> msg_bytes,
+    void NodeReceiveMsgBytes(CNode &node, Span<const uint8_t> msg_bytes,
                              bool &complete) const;
 
     bool ReceiveMsgFrom(CNode &node, CSerializedNetMsg &ser_msg) const;