utility/vbnv_util.py

#!/usr/bin/env python3
# Copyright 2024 The ChromiumOS Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""Utility for vboot nvdata (nvram, nvstorage)."""

import argparse


NVDATA_SIZE = 16


def get_crc8(data, size):
    """Calculate CRC-8."""
    # CRC-8 ITU version, with x^8 + x^2 + x + 1 polynomial.
    # Note that result will evaluate to zero for a buffer of all zeroes.
    crc = 0

    # Calculate CRC-8 directly.  A table-based algorithm would be faster,
    # but for only a few bytes it isn't worth the code size.
    for i in range(size):
        crc ^= data[i] << 8
        for _ in range(8):
            if crc & 0x8000:
                crc ^= 0x1070 << 3
            crc = (crc << 1) & 0xFFFFFFFF

    return (crc >> 8) % 256


def verify_crc8(entry):
    """Verify CRC-8 of `entry`."""
    assert len(entry) == NVDATA_SIZE
    expected_crc8 = get_crc8(entry, NVDATA_SIZE - 1)
    crc8 = entry[NVDATA_SIZE - 1]
    return crc8 == expected_crc8


def process_entry(entry, offset):
    """Process an nvdata entry."""
    data = " ".join(f"{x:02x}" for x in entry)
    if all(x == 0xFF for x in entry):
        result = "EMPTY"
    else:
        is_valid = verify_crc8(entry)
        result = "VALID" if is_valid else "CRC ERROR"
    print(f"{offset:08x}  {data}  {result}")


def dump(nvdata_file):
    """Show the content of `nvdata_file`."""
    with open(nvdata_file, "rb") as f:
        nvdata = f.read()
    assert len(nvdata) % NVDATA_SIZE == 0
    for i in range(len(nvdata) // NVDATA_SIZE):
        offset = i * NVDATA_SIZE
        entry = nvdata[offset : offset + NVDATA_SIZE]
        process_entry(entry, offset)


def verify_hex_entry(hex_string):
    """Verify an nvdata entry."""
    values = []
    for s in hex_string.split():
        s = s.removeprefix("0x")
        for i in range(0, len(s), 2):
            value = int(s[i : i + 2], 16)
            values.append(value)
    if len(values) != NVDATA_SIZE:
        raise ValueError(
            f"Hex string should contain {NVDATA_SIZE} bytes"
            f", {len(values)} found"
        )

    entry = bytes(values)
    is_valid = verify_crc8(entry)
    print("VALID" if is_valid else "INVALID")


def main():
    parser = argparse.ArgumentParser()
    group = parser.add_mutually_exclusive_group()
    group.add_argument("-f", "--file", help="RW_NVRAM file to dump")
    group.add_argument(
        "--hex",
        help=(
            f"Hex string of {NVDATA_SIZE} bytes to verify (for example"
            " '50 40 00 00 00 02 00 02  00 fe ff 00 00 ff ff 60')"
        ),
    )

    args = parser.parse_args()
    if args.file:
        dump(args.file)
    elif args.hex:
        verify_hex_entry(args.hex)
    else:
        parser.print_help()


if __name__ == "__main__":
    main()