AK+Userland+Kernel+Tests: Deduplicate IPv4 header checksumming

Previously, there were two slightly different implementations of this in
the Kernel and in LibCrypto.

This patch removes those, and replaces them with an implementation that
seeks to combine the best aspects of both while not being a drop-in
replacement for either.

Two new tests are also included.

Author: implicitfield

AK/CMakeLists.txt

@@ -15,6 +15,7 @@ set(AK_SOURCES
     FuzzyMatch.cpp
     GenericLexer.cpp
     Hex.cpp
+    InternetChecksum.cpp
     JsonObject.cpp
     JsonParser.cpp
     JsonPath.cpp

AK/InternetChecksum.cpp

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2025, the SerenityOS developers.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/ByteReader.h>
+#include <AK/InternetChecksum.h>
+
+namespace AK {
+
+InternetChecksum::InternetChecksum(ReadonlyBytes bytes)
+{
+    update(bytes);
+}
+
+void InternetChecksum::update(ReadonlyBytes bytes)
+{
+    VERIFY(!m_uneven_payload);
+    for (size_t i = 0; i < bytes.size() / sizeof(u16); ++i)
+        m_state += ByteReader::load16(bytes.offset_pointer(i * sizeof(u16)));
+    if (bytes.size() % 2 == 1) {
+        m_state += bytes.last();
+        m_uneven_payload = true;
+    }
+}
+
+NetworkOrdered<u16> InternetChecksum::digest()
+{
+    u32 output = m_state;
+    // While there are any bits above the bottom 16...
+    while (output >> 16)
+        // Drop the top bits, and add the carries to the sum.
+        output = (output & 0xFFFF) + (output >> 16);
+
+    // Return the one's complement (this is already network-ordered, so we
+    // bypass the constructor of that).
+    return bit_cast<NetworkOrdered<u16>>(static_cast<u16>(~output));
+}
+
+}

AK/InternetChecksum.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2025, the SerenityOS developers.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/Endian.h>
+#include <AK/Forward.h>
+#include <AK/Types.h>
+
+namespace AK {
+
+class InternetChecksum {
+public:
+    InternetChecksum() = default;
+    InternetChecksum(ReadonlyBytes);
+
+    void update(ReadonlyBytes);
+    NetworkOrdered<u16> digest();
+
+private:
+    u32 m_state { 0 };
+    bool m_uneven_payload { false };
+};
+
+}
+
+#ifdef USING_AK_GLOBALLY
+using AK::InternetChecksum;
+#endif

Kernel/CMakeLists.txt

@@ -611,6 +611,7 @@ set(AK_SOURCES
     ../AK/DOSPackedTime.cpp
     ../AK/GenericLexer.cpp
     ../AK/Hex.cpp
+    ../AK/InternetChecksum.cpp
     ../AK/MemoryStream.cpp
     ../AK/SipHash.cpp
     ../AK/Stream.cpp

Kernel/Net/IP/IP.h

@@ -22,32 +22,4 @@ enum class TransportProtocol : u8 {
     ICMPv6 = 58,
 };
 
-class InternetChecksum {
-public:
-    void add(ReadonlyBytes bytes)
-    {
-        VERIFY(!m_uneven_payload);
-        Span<u16 const> words { bit_cast<u16 const*>(bytes.data()), bytes.size() / 2 };
-        for (u16 w : words) {
-            m_checksum += AK::convert_between_host_and_network_endian(w);
-            if (m_checksum & 0x80000000)
-                m_checksum = (m_checksum & 0xffff) | (m_checksum >> 16);
-        }
-        if (bytes.size() % 2 == 1) {
-            m_checksum += (bytes.last()) << 8;
-            m_uneven_payload = true;
-        }
-    }
-    NetworkOrdered<u16> finish()
-    {
-        while (m_checksum >> 16)
-            m_checksum = (m_checksum & 0xffff) + (m_checksum >> 16);
-        return ~m_checksum & 0xffff;
-    }
-
-private:
-    u32 m_checksum { 0 };
-    bool m_uneven_payload { false };
-};
-
 }

Kernel/Net/IP/IPv4.h

@@ -9,6 +9,7 @@
 #include <AK/Assertions.h>
 #include <AK/Endian.h>
 #include <AK/IPv4Address.h>
+#include <AK/InternetChecksum.h>
 #include <AK/Types.h>
 #include <Kernel/Net/IP/IP.h>
 
@@ -81,9 +82,7 @@ class [[gnu::packed]] IPv4Packet {
     NetworkOrdered<u16> compute_checksum() const
     {
         VERIFY(!m_checksum);
-        InternetChecksum checksum;
-        checksum.add({ this, sizeof(IPv4Packet) });
-        return checksum.finish();
+        return InternetChecksum({ this, sizeof(IPv4Packet) }).digest();
     }
 
 private:

Kernel/Net/NetworkTask.cpp

@@ -331,10 +331,10 @@ void handle_icmpv6(EthernetFrameHeader const& eth, IPv6PacketHeader const& ipv6_
         header.next_header = TransportProtocol::ICMPv6;
 
         InternetChecksum checksum;
-        checksum.add({ &header, sizeof(IPv6PseudoHeader) });
-        checksum.add({ &response, sizeof(advertisement_with_option) });
+        checksum.update({ &header, sizeof(IPv6PseudoHeader) });
+        checksum.update({ &response, sizeof(advertisement_with_option) });
 
-        response.base.header.set_checksum(checksum.finish());
+        response.base.header.set_checksum(checksum.digest());
     } else if (icmpv6_header.type() == ICMPv6Type::EchoRequest) {
         dbgln_if(ICMPV6_DEBUG, "handle_icmp6: got echo request");
         if (icmp_packet_size < sizeof(ICMPv6Echo)) {
@@ -370,10 +370,10 @@ void handle_icmpv6(EthernetFrameHeader const& eth, IPv6PacketHeader const& ipv6_
             memcpy(response.payload(), request.payload(), icmp_packet_size - sizeof(ICMPv6Echo));
 
         InternetChecksum checksum;
-        checksum.add({ &header, sizeof(IPv6PseudoHeader) });
-        checksum.add({ &response, icmp_packet_size });
+        checksum.update({ &header, sizeof(IPv6PseudoHeader) });
+        checksum.update({ &response, icmp_packet_size });
 
-        response.header.set_checksum(checksum.finish());
+        response.header.set_checksum(checksum.digest());
     } else {
         dbgln_if(ICMPV6_DEBUG, "handle_icmp6: got unknown ICMPv6 type {:#02x}", icmpv6_header.type());
         return;
@@ -431,9 +431,7 @@ void handle_icmp(EthernetFrameHeader const& eth, IPv4Packet const& ipv4_packet,
         if (icmp_packet_size > icmp_header_size)
             memcpy(response.payload, request.payload, icmp_packet_size - icmp_header_size);
 
-        InternetChecksum checksum;
-        checksum.add({ &response, icmp_packet_size });
-        response.header.checksum = checksum.finish();
+        response.header.checksum = InternetChecksum({ &response, icmp_packet_size }).digest();
 
         adapter->send_packet(packet->bytes());
         adapter->release_packet_buffer(*packet);

Tests/AK/CMakeLists.txt

@@ -51,6 +51,7 @@ set(AK_TEST_SOURCES
     TestIndexSequence.cpp
     TestInsertionSort.cpp
     TestIntegerMath.cpp
+    TestInternetChecksum.cpp
     TestIntrusiveList.cpp
     TestIntrusiveRedBlackTree.cpp
     TestJSON.cpp

Tests/AK/TestInternetChecksum.cpp

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2025, the SerenityOS developers.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/Array.h>
+#include <AK/InternetChecksum.h>
+#include <LibTest/TestCase.h>
+#include <netinet/in.h>
+
+TEST_CASE(test_internetchecksum)
+{
+    auto do_test = [](ReadonlyBytes input, u16 expected_result) {
+        auto digest = InternetChecksum(input).digest();
+        EXPECT_EQ(digest, expected_result);
+    };
+
+    do_test(to_readonly_bytes(Array<u16, 3> { htons(0b0110'0110'0110'0000), htons(0b0101'0101'0101'0101), htons(0b1000'1111'0000'1100) }.span()), 0b1011'0101'0011'1101);
+
+    // Test case from RFC1071.
+    // The specified result doesn't include the final conversion from one's complement,
+    // hence the bitwise negation.
+    do_test(to_readonly_bytes(Array<u16, 4> { 0x0100, 0x03f2, 0xf5f4, 0xf7f6 }.span()), static_cast<u16>(~0xddf2));
+
+    // Variation of the above (with an uneven payload).
+    do_test(to_readonly_bytes(Array<u8, 3> { 0x01, 0x00, 0x03 }.span()), htons(static_cast<u16>(~0x4)));
+}

Tests/LibCrypto/TestChecksum.cpp

@@ -6,7 +6,6 @@
 
 #include <LibCrypto/Checksum/Adler32.h>
 #include <LibCrypto/Checksum/CRC32.h>
-#include <LibCrypto/Checksum/IPv4Header.h>
 #include <LibCrypto/Checksum/cksum.h>
 #include <LibTest/TestCase.h>
 #include <arpa/inet.h>
@@ -65,13 +64,3 @@ TEST_CASE(test_crc32)
     do_test("The quick brown fox jumps over the lazy dog"sv.bytes(), 0x414FA339);
     do_test("various CRC algorithms input data"sv.bytes(), 0x9BD366AE);
 }
-
-TEST_CASE(test_ipv4header)
-{
-    auto do_test = [](ReadonlyBytes input, u16 expected_result) {
-        auto digest = Crypto::Checksum::IPv4Header(input).digest();
-        EXPECT_EQ(digest, expected_result);
-    };
-    Array<u16, 3> bytes = { htons(0b0110'0110'0110'0000), htons(0b0101'0101'0101'0101), htons(0b1000'1111'0000'1100) };
-    do_test(to_readonly_bytes(bytes.span()), htons(0b1011'0101'0011'1101));
-}