Implementing Firmware Checksum and CRC Validation

In this lesson, you will learn how to verify firmware integrity by implementing Cyclic Redundancy Check (CRC) validation to detect corruption during storage or transmission.

When your bootloader transfers an image from external storage to internal flash, or when the application performs a self-test after a power-on reset, you must ensure the data is bit-perfect. While simple checksums (like a rolling sum) can catch random bit flips, they are weak against common data corruption patterns. CRCs are far more robust because they treat the firmware image as a long polynomial, dividing it by a fixed generator polynomial to produce a unique remainder.

Implementing the Validation Logic

To implement this, you first define a specific region in your memory map—typically the flash range containing your application code—to be included in the calculation. During the build process, you use a script to calculate the CRC of your binary and append it to a specific memory location, such as a metadata header at the end of the image.

At runtime, your bootloader calculates the CRC of the target memory range and compares it against the stored value:

uint32_t calculate_crc32(uint8_t *data, size_t length) {
    uint32_t crc = 0xFFFFFFFF;
    for (size_t i = 0; i < length; i++) {
        crc ^= data[i];
        for (int j = 0; j < 8; j++) {
            crc = (crc >> 1) ^ (crc & 1 ? 0xEDB88320 : 0);
        }
    }
    return ~crc;
}

bool verify_firmware(uint8_t *start, size_t len, uint32_t expected_crc) {
    return calculate_crc32(start, len) == expected_crc;
}

Why CRC matters for Embedded

In an embedded environment, you are often dealing with noisy power rails or failing flash cells that can lead to silent data corruption. By calculating the CRC immediately after the bootloader copies code from flash to RAM (or before jumping to the application entry point), you can abort the boot process if a mismatch occurs. This prevents the processor from executing malformed instructions, which could otherwise lead to system hangs or erratic hardware control.

Key Takeaway: Integrating a CRC check into your boot sequence provides a mathematically rigorous way to guarantee that your firmware remains uncorrupted before execution.