Secure Boot
Secure boot is a chain of cryptographic signature checks where each stage of a chip's startup software verifies the next stage's signature before ever running it, so a single piece of code running first and trusted unconditionally — because it's burned directly into on-chip ROM and can't be altered after manufacturing — is enough to guarantee every later stage is authentic too. Without this chain, an attacker who can modify any piece of boot software — a bootloader, a kernel, firmware sitting in flash — can make a device run whatever code they want, completely invisibly, before any higher-level security feature even gets a chance to start.
The chain's entire strength comes from the very first link, which is why that link gets the most unusual protection of all. The boot ROM code itself can't be verified by anything running before it — there is nothing before it — so it has to be trusted unconditionally, which means it's deliberately made as small and simple as possible, laid down in actual silicon mask ROM or one-time-programmable fuses rather than rewritable flash, specifically so no software exploit discovered after the chip ships can ever modify it; a bug found in this first stage years later often can't be patched at all, which is exactly why it's kept so minimal that there's as little as possible left to go wrong.
Measured boot is the complementary idea for when a device still needs to run even if something in the chain looks wrong. Instead of halting on a failed check, measured boot hashes every stage as it loads and stores those hashes in a tamper-resistant log, so a remote server or a local policy can later ask the device to prove exactly what software it actually ran before trusting it with anything sensitive — this is the mechanism that lets a corporate laptop boot into a recovery mode after a failed integrity check instead of simply bricking, while still giving anyone who cares a verifiable record that something was off.
Anti-rollback protection closes a gap that signature checking alone leaves wide open. A signature check only proves a piece of firmware is genuinely signed by the vendor, not that it's the latest version — without additional protection, an attacker can reinstall an older, genuinely signed version of firmware that has a known, already-patched vulnerability, then exploit that old bug on purpose; secure boot implementations close this by storing a monotonic version counter in write-once hardware fuses and refusing to boot any firmware whose declared version is older than the counter already recorded.
Mobile and embedded SoC vendors build this chain directly into silicon rather than leaving it to firmware alone. Qualcomm, Apple, and Arm's TrustZone-based reference designs all implement their own variant of this exact boot-ROM-anchored chain, and it's the reason a locked phone refuses to run a modified operating system no matter how the attacker tries to load it — the rejection doesn't happen because the OS looks suspicious, it happens because its signature simply doesn't match the key the boot ROM was told to trust at the factory.
Read secure boot through a *first-link-earns-everything* lens rather than a *every-stage-is-equally-secure* lens — the entire chain's trustworthiness rests on one piece of code that was never itself verified by anything, which is precisely why that one piece is made as small, as simple, and as physically unchangeable as engineering can manage.