Remove dependency on crc_any

The crc_any is not currently imported in Chromium, and since the dcsctp 
library only uses a very small part of it, reimplement this ourselves.

In contrast to the crc_any crate, we generate the tables by the 
compiler, but similarly to it, we process 8 bytes at a time, so 
performance should be identical.

The correctness of this algorithm is guaranteed by test vectors and with
the recorded packet captures that exist in other unit tests.

We could add an optional feature to add a dependency on the crc32c 
crate, which adds hardware accelerated support for some platforms, but
that library is not imported in Chromium and other monorepos.

Note that the crc32c checksum becomes less relevant with support for
https://datatracker.ietf.org/doc/rfc9653/, which his library has,
and will use if configured and when both sides support it.

Author: boivie

CHANGELOG.md

@@ -10,6 +10,10 @@ and this project adheres to
 
 ## 0.1.7 - 2026-01-21
 
+### Changed
+
+ - Removed dependency on `crc_any` crate.
+
 ### Fixed
 
  - Fixed a socket handover bug.

Cargo.lock

@@ -8,7 +8,6 @@ license = "Apache-2.0"
 repository = "https://github.com/webrtc/dcsctp"
 
 [workspace.dependencies]
-crc-any = "2.5.0"
 cxx = "1.0.192"
 cxx-build = "1.0.192"
 dcsctp = { path = "." }
@@ -49,7 +48,6 @@ license = { workspace = true }
 repository = { workspace = true }
 
 [dependencies]
-crc-any = { workspace = true }
 cxx = { workspace = true, optional = true }
 log = { workspace = true }
 rand = { workspace = true }

Cargo.toml

@@ -0,0 +1,162 @@
+// Copyright 2026 The dcSCTP Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// See <https://datatracker.ietf.org/doc/html/rfc9260#appendix-A>.
+
+// CRC-32C (iSCSI) polynomial in reversed bit order.
+const CRC32C_POLY: u32 = 0x82F63B78;
+
+const fn generate_tables() -> [[u32; 256]; 8] {
+    let mut tables = [[0u32; 256]; 8];
+    let mut i = 0;
+
+    // Generate the first table (for single byte processing).
+    while i < 256 {
+        let mut crc = i as u32;
+        let mut j = 0;
+        while j < 8 {
+            if (crc & 1) != 0 {
+                crc = (crc >> 1) ^ CRC32C_POLY;
+            } else {
+                crc >>= 1;
+            }
+            j += 1;
+        }
+        tables[0][i] = crc;
+        i += 1;
+    }
+
+    // Generate subsequent tables (for 8 bytes at a time).
+    let mut k = 1;
+    while k < 8 {
+        let mut i = 0;
+        while i < 256 {
+            let prev = tables[k - 1][i];
+            tables[k][i] = (prev >> 8) ^ tables[0][(prev & 0xff) as usize];
+            i += 1;
+        }
+        k += 1;
+    }
+    tables
+}
+
+const CRC32C_LOOKUP_TABLE: [[u32; 256]; 8] = generate_tables();
+
+pub struct Crc32c(u32);
+
+impl Crc32c {
+    pub fn new() -> Self {
+        Self(0xffffffff)
+    }
+
+    pub fn digest(&mut self, data: &[u8]) {
+        let mut crc = self.0;
+        let mut iter = data.chunks_exact(8);
+
+        // Process 8 bytes at a time.
+        for chunk in iter.by_ref() {
+            let current_chunk = u64::from_le_bytes(chunk.try_into().unwrap());
+            let idx = (crc as u64) ^ current_chunk;
+
+            crc = CRC32C_LOOKUP_TABLE[7][(idx as u8) as usize]
+                ^ CRC32C_LOOKUP_TABLE[6][((idx >> 8) as u8) as usize]
+                ^ CRC32C_LOOKUP_TABLE[5][((idx >> 16) as u8) as usize]
+                ^ CRC32C_LOOKUP_TABLE[4][((idx >> 24) as u8) as usize]
+                ^ CRC32C_LOOKUP_TABLE[3][((idx >> 32) as u8) as usize]
+                ^ CRC32C_LOOKUP_TABLE[2][((idx >> 40) as u8) as usize]
+                ^ CRC32C_LOOKUP_TABLE[1][((idx >> 48) as u8) as usize]
+                ^ CRC32C_LOOKUP_TABLE[0][((idx >> 56) as u8) as usize];
+        }
+
+        // Process remaining bytes.
+        for &byte in iter.remainder() {
+            crc = (crc >> 8) ^ CRC32C_LOOKUP_TABLE[0][((crc ^ byte as u32) & 0xff) as usize];
+        }
+
+        self.0 = crc;
+    }
+
+    pub fn value(&self) -> u32 {
+        !self.0
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_crc32c_empty() {
+        let mut crc = Crc32c::new();
+        crc.digest(&[]);
+        assert_eq!(crc.value(), 0x00000000);
+    }
+
+    #[test]
+    fn test_table_0() {
+        // See the table at <https://datatracker.ietf.org/doc/html/rfc9260#appendix-A>.
+        assert_eq!(CRC32C_LOOKUP_TABLE[0][0], 0x00000000);
+        assert_eq!(CRC32C_LOOKUP_TABLE[0][1], 0xf26b8303);
+        assert_eq!(CRC32C_LOOKUP_TABLE[0][255], 0xad7d5351);
+    }
+
+    #[test]
+    fn test_crc32c_vectors() {
+        // Standard test vectors for CRC32c (Castagnoli)
+        // Check "123456789"
+        let mut crc = Crc32c::new();
+        crc.digest(b"123456789");
+        assert_eq!(crc.value(), 0xe3069283);
+
+        // 4 bytes (less than 8)
+        let mut crc = Crc32c::new();
+        crc.digest(b"1234");
+        assert_eq!(crc.value(), 0xf63af4ee);
+
+        // 8 bytes (exactly one chunk)
+        let mut crc = Crc32c::new();
+        crc.digest(b"12345678");
+        assert_eq!(crc.value(), 0x6087809a);
+    }
+
+    #[test]
+    fn test_vs_reference() {
+        // See <https://datatracker.ietf.org/doc/html/rfc9260#appendix-A>.
+        fn reference_crc32c(data: &[u8]) -> u32 {
+            let mut crc: u32 = 0xffffffff;
+            for &byte in data {
+                crc = (crc >> 8) ^ CRC32C_LOOKUP_TABLE[0][((crc ^ byte as u32) & 0xff) as usize];
+            }
+            !crc
+        }
+
+        // Test various lengths from 0 to 100
+        for len in 0..100 {
+            // Create determinstic "random" data
+            let data: Vec<u8> = (0..len).map(|i| (i * 17) as u8).collect();
+
+            let mut crc = Crc32c::new();
+            crc.digest(&data);
+
+            let ref_val = reference_crc32c(&data);
+            assert_eq!(crc.value(), ref_val, "Failed for length {}", len);
+        }
+
+        // Test a larger buffer to ensure no issues with multiple chunks
+        let data: Vec<u8> = (0..1024).map(|i| (i * 13) as u8).collect();
+        let mut crc = Crc32c::new();
+        crc.digest(&data);
+        assert_eq!(crc.value(), reference_crc32c(&data));
+    }
+}

src/packet/crc32c.rs

@@ -20,6 +20,7 @@ pub(crate) mod chunk_validators;
 pub(crate) mod cookie_ack_chunk;
 pub(crate) mod cookie_echo_chunk;
 pub(crate) mod cookie_received_while_shutting_down;
+pub(crate) mod crc32c;
 pub(crate) mod data;
 pub(crate) mod data_chunk;
 pub(crate) mod error_causes;

src/packet/mod.rs

@@ -21,12 +21,12 @@ use crate::packet::AsSerializableTlv;
 use crate::packet::ChunkParseError;
 use crate::packet::chunk::Chunk;
 use crate::packet::chunk::RawChunk;
+use crate::packet::crc32c::Crc32c;
 use crate::packet::ensure;
 use crate::packet::read_u16_be;
 use crate::packet::read_u32_be;
 use crate::packet::write_u16_be;
 use crate::packet::write_u32_be;
-use crc_any::CRCu32;
 use thiserror::Error;
 
 pub const COMMON_HEADER_SIZE: usize = 12;
@@ -111,11 +111,11 @@ impl SctpPacket {
         } else {
             const FOUR_ZEROES: &[u8] = &[0, 0, 0, 0];
             // Verify the checksum. The checksum field must be zero when that's done.
-            let mut crc = CRCu32::crc32c();
+            let mut crc = Crc32c::new();
             crc.digest(&data[0..8]);
             crc.digest(FOUR_ZEROES);
             crc.digest(&data[12..]);
-            let checksum = crc.get_crc().to_be();
+            let checksum = crc.value().to_be();
             ensure!(checksum == common_header.checksum, PacketParseError::InvalidChecksum);
         }
 
@@ -202,9 +202,9 @@ impl SctpPacketBuilder {
     pub fn build(&mut self) -> Vec<u8> {
         let mut out = Vec::<u8>::new();
         if self.write_checksum && !self.data.is_empty() {
-            let mut crc = CRCu32::crc32c();
+            let mut crc = Crc32c::new();
             crc.digest(&self.data);
-            let checksum = crc.get_crc().to_be();
+            let checksum = crc.value().to_be();
             write_u32_be!(&mut self.data[8..12], checksum);
         }
         std::mem::swap(&mut self.data, &mut out);