Forcing the Silicon’s Hand: How the AAD-50 Architecture Defeats Firmware Deception

Mon, 20 Jul 2026 16:18:56 +0000

In Part 1 of this series, we covered the uncomfortable truth about modern NVMe storage: vendor firmware is built on performance-based deception. Between Flash Translation Layer (FTL) redirection and flawed Cryptographic Erase implementations, relying on a drive's internal Success flag is a massive security liability.

So, how do we destroy data when the hardware is actively trying to hide it from us?

We stop asking nicely. We bypass the FTL abstractions and force verifiable physical exhaustion. Here is the exact architecture of the Abeselom ASIC-Direct 50 (AAD-50) protocol.

ASIC-Direct: Bypassing the Abstraction

Legacy protocols (like DoD 5220.22-M) fail because they operate at the Logical Block Addressing (LBA) layer. They trust the drive to map the overwrite to the correct physical cell.

AAD-50 abandons LBA reliance. Instead, it utilizes specific NVMe low-level admin commands designed to interact directly with the Application-Specific Integrated Circuit (ASIC)—the drive's controller. By utilizing ASIC-Direct commands, we bypass the FTL's standard wear-leveling algorithms and attack the raw NAND infrastructure.

The 50-Cycle B→C→A Destruction Matrix

To ensure absolute data obliteration, AAD-50 executes a punishing 50-cycle matrix broken into three distinct phases. We do not rely on cryptography as our primary weapon; we rely on physics.

1. Phase B: Physical Cell Exhaustion (40 Cycles)

We start with brute force. Phase B executes 40 continuous cycles of raw physical NAND cell overwrites. The goal here is to forcefully obliterate data at the voltage level, deliberately bypassing reliance on the drive's internal cryptographic engines. By flooding the physical blocks, we overwrite the actual sensitive data, not just the pointers.

2. Phase C: FTL Index Teardown (5 Cycles)

Even with the physical cells flooded, the metadata mapping where data used to live can provide forensic clues. Phase C executes 5 cycles specifically targeting the destruction of the FTL mapping tables. We shred the map so the controller permanently loses its spatial awareness of the drive's history.

3. Phase A: Cryptographic Key Destruction (5 Cycles)

Finally, as an immutable seal, Phase A executes 5 cycles targeting the Data Encryption Key (DEK). Even if a fragmented block miraculously survived Phase B and C, the cryptographic key required to decode it is atomized.

The Core Innovation: Hardware-Level Verification

Anyone can write a script to send 50 overwrite commands. The problem is that faulty firmware might silently drop those commands while returning a false Success flag.

This is the core problem I solved that got the AAD-50 logic merged into the official linux-nvme/nvme-cli master branch.

AAD-50 mandates hardware-level verification. After every single cycle in the matrix, the software must actively poll the NVMe Sanitize Status (Log Page 0x81). We demand cryptographic proof from the hardware that the cycle is completely finished. If the drive cannot prove it, the software loop halts and flags the failure.

We no longer trust the silicon; we verify it.

Join the Ecosystem (GPL)

The AAD-50 reference implementation is fully open-source and licensed under the GPL. This ensures it is completely compatible with third-party, community-driven tools (like the legacy Eraser utility) so we can build native, mathematically sound sanitization into enterprise pipelines.

Let's stop shredding perfectly good drives and start clearing them correctly.

🔗 Read the Full Whitepaper: aad50.com
🔗 Review the GitHub Repo: github.com/yonasabeselom/aad50

What are your thoughts on Log Page 0x81 polling versus traditional read-back verification? Let’s talk low-level storage in the comments! 👇

Why Your NVMe SSD is Lying to You

Sun, 19 Jul 2026 03:42:54 +0000

When you send a command to overwrite a file or sanitize a drive, what actually happens? You look at your screen, and the software confirms: 100% Complete. Success.

That confirmation is a mirage.

It’s not necessarily a malicious lie, but an operational lie born from the fundamental difference between how your Operating System sees data and how the physical storage silicon manages it.

1. The LBA/PBA Trust Divide

The root of the issue is the disconnect between Logical Block Addressing (LBA)—which your OS uses—and Physical Block Addressing (PBA)—which the drive silicon uses.

When your OS (e.g., Linux, Windows, macOS) wants to write or wipe a piece of data, it tells the drive controller, "Overwrite LBA 0 through LBA 100." The OS, assuming the drive is a simple "dumb" recorder, thinks that data has been destroyed.

But the drive's controller (the ASIC) knows that is terrible for the health of the drive. Writing to the same physical spot over and over burns out the NAND cells (this is known as wear).

2. The Flash Translation Layer (FTL) Illusion

To optimize for performance and drive life, modern NVMe drives use a sophisticated middleman called the Flash Translation Layer (FTL). This layer is an intricate map that translates the OS's requests into physical actions.

When the OS requests to "Overwrite LBA 0," the FTL instead writes that data to a new, fresh physical cell (e.g., PBA 500). It then updates its internal map: "OK, next time the OS asks for LBA 0, show them PBA 500."

Then—and this is the core of the lie—it immediately reports Success back to the OS.

The catch? The original raw data, sitting on the physical cells previously mapped to LBA 0 (e.g., PBA 0), was never touched. It is left structurally intact, completely invisible to the OS, until the drive’s internal "Garbage Collection" background process decides to wipe it—which might not happen for weeks or longer.

3. The Broken Cryptographic Shortcut

This is where things get truly dangerous. Manufacturers realized that physically overwriting all the data (or waiting for garbage collection) is too slow.

Their solution: Cryptographic Erase (Crypto Erase). Instead of wiping the data, the drive simply encrypts all the data first using an internal Data Encryption Key (DEK). When the OS asks to wipe the drive, the controller does one quick thing: it deletes the DEK.

It then instantly reports Sanitize Success to the OS.

The logic is sound if the drive implements the encryption perfectly. If the key is gone, the data (even if it’s left behind by the FTL) is unreadable. It becomes useless gibberish.

But 2026 academic research proved the implementation is fundamentally broken. Researchers found that major drive vendors had critically flawed firmware that suffered from:

Predictable Random Number Generators (RNGs) used to create the DEK.
AES-Tweak Reuse, which leaves decryptable patterns in the raw ciphertext.
Silent dropping of the Crypto Erase command (the drive reported "Success" but never actually deleted the key).

The drive was lying. It claimed the data was safe and unreadable, when in reality, the weak key could be guessed, the cipher could be broken, or the data was never encrypted in the first place.

This is why legacy sanitization protocols are obsolete on modern flash. They trust the drive to be honest, but the drive’s entire design philosophy is built on performance-based deception.

In the next section, I will detail how AAD-50's ASIC-Direct architecture defeats this deception by making the drive’s flawed cryptography irrelevant and demanding verifiable physical destruction.

Coder Legion - Recent posts tagged hardware-security