Skip to content

Ghidrust provides a hyper fast, AI native reverse engineering platform built in Rust, inspired by Ghidra. Includes experimental GPU kernels to rapidly decompile large files, a decryption suite, and network monitor for packet to binary reverse engineering.

4.8 KB
Raw Blame
//! Pure checksum math for the Checksum Generator pane.
//!
//! Extracted from `app.rs` (Wave 1 demonolith). UI + program I/O stay on
//! `GhidrustApp`; this module owns report types and hash helpers only.

/// Checksum Generator report.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ChecksumReport {
    pub target: String,
    pub len: usize,
    pub crc32: u32,
    pub sum8: u32,
    pub sum16: u32,
    pub sum32: u64,
    pub adler32: u32,
    pub fletcher16: u32,
    pub fletcher32: u64,
}

/// Checksum Generator scope.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ChecksumMode {
    /// Concatenation of every loaded memory block.
    WholeImage,
    /// A single memory block chosen by name.
    Section(String),
}

/// CRC-32/ISO-HDLC (polynomial `0xEDB88320`) — matches default.
pub fn crc32_ieee(data: &[u8]) -> u32 {
    let mut c: u32 = 0xFFFF_FFFF;
    for &b in data {
        c ^= b as u32;
        for _ in 0..8 {
            let mask = (c & 1).wrapping_neg();
            c = (c >> 1) ^ (0xEDB8_8320 & mask);
        }
    }
    !c
}

pub fn adler32(data: &[u8]) -> u32 {
    const MOD: u32 = 65521;
    let mut a: u32 = 1;
    let mut b: u32 = 0;
    for &byte in data {
        a = (a + byte as u32) % MOD;
        b = (b + a) % MOD;
    }
    (b << 16) | a
}

pub fn fletcher_pair(data: &[u8]) -> (u32, u64) {
    let (mut a16, mut b16): (u16, u16) = (0, 0);
    for &byte in data {
        a16 = a16.wrapping_add(byte as u16);
        b16 = b16.wrapping_add(a16);
    }
    let f16 = ((b16 as u32) << 16) | a16 as u32;

    let (mut a32, mut b32): (u32, u32) = (0, 0);
    for chunk in data.chunks_exact(2) {
        let w = u16::from_le_bytes([chunk[0], chunk[1]]) as u32;
        a32 = a32.wrapping_add(w);
        b32 = b32.wrapping_add(a32);
    }
    let f32 = ((b32 as u64) << 32) | a32 as u64;
    (f16, f32)
}

/// Compute every field of a [`ChecksumReport`] for `data` labeled `target`.
pub fn report_for(target: String, data: &[u8]) -> ChecksumReport {
    let len = data.len();
    let crc32 = crc32_ieee(data);
    let sum8: u32 = data.iter().map(|&b| b as u32).sum();
    let sum16: u32 = data
        .chunks_exact(2)
        .map(|c| u16::from_le_bytes([c[0], c[1]]) as u32)
        .sum::<u32>();
    let sum32: u64 = data
        .chunks_exact(4)
        .map(|c| u32::from_le_bytes([c[0], c[1], c[2], c[3]]) as u64)
        .sum::<u64>();
    let adler32 = adler32(data);
    let (fletcher16, fletcher32) = fletcher_pair(data);
    ChecksumReport {
        target,
        len,
        crc32,
        sum8,
        sum16,
        sum32,
        adler32,
        fletcher16,
        fletcher32,
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn crc32_ieee_empty_and_check_vector() {
        assert_eq!(crc32_ieee(b""), 0x0000_0000);
        // Well-known ISO-HDLC / IEEE check value for "123456789".
        assert_eq!(crc32_ieee(b"123456789"), 0xCBF4_3926);
    }

    #[test]
    fn adler32_empty_and_check_vector() {
        // Adler-32 of empty input is 1 (a=1, b=0).
        assert_eq!(adler32(b""), 0x0000_0001);
        // Adler-32 of "123456789" (RFC 1950 check vector).
        assert_eq!(adler32(b"123456789"), 0x091E_01DE);
    }

    #[test]
    fn fletcher_pair_empty_and_short() {
        assert_eq!(fletcher_pair(b""), (0, 0));
        // Single byte: a16=0x41, b16=0x41; no complete u16 for f32 → 0.
        assert_eq!(fletcher_pair(b"A"), (0x0041_0041, 0));
        // Two bytes: f16 from running sums; f32 from one LE u16 word.
        let (f16, f32) = fletcher_pair(b"AB");
        let mut a16: u16 = 0;
        let mut b16: u16 = 0;
        for &byte in b"AB" {
            a16 = a16.wrapping_add(byte as u16);
            b16 = b16.wrapping_add(a16);
        }
        assert_eq!(f16, ((b16 as u32) << 16) | a16 as u32);
        let w = u16::from_le_bytes([b'A', b'B']) as u32;
        assert_eq!(f32, ((w as u64) << 32) | w as u64);
    }

    #[test]
    fn report_for_aggregates_known_vector() {
        let data = b"123456789";
        let r = report_for("t".into(), data);
        assert_eq!(r.target, "t");
        assert_eq!(r.len, 9);
        assert_eq!(r.crc32, 0xCBF4_3926);
        assert_eq!(r.adler32, 0x091E_01DE);
        assert_eq!(r.sum8, data.iter().map(|&b| b as u32).sum::<u32>());
        // 4 complete LE u16 pairs from 8 bytes; last byte dropped by chunks_exact(2).
        let sum16: u32 = data
            .chunks_exact(2)
            .map(|c| u16::from_le_bytes([c[0], c[1]]) as u32)
            .sum();
        assert_eq!(r.sum16, sum16);
        // 2 complete LE u32 words; last byte dropped.
        let sum32: u64 = data
            .chunks_exact(4)
            .map(|c| u32::from_le_bytes([c[0], c[1], c[2], c[3]]) as u64)
            .sum();
        assert_eq!(r.sum32, sum32);
        let (f16, f32) = fletcher_pair(data);
        assert_eq!(r.fletcher16, f16);
        assert_eq!(r.fletcher32, f32);
    }
}