Coder Legion - Recent posts tagged nvme

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.

11.5PB in 2U: Inside the Engineering Behind the Novodisq Novoblade

Mon, 02 Feb 2026 23:37:53 +0000

There's a quiet shift happening in storage engineering. It's not about faster IOPS or bigger flash arrays. It's about density, power, and what happens when a small team decides to build their own SSDs from scratch.

Novodisq is a New Zealand-based startup founded in 2018. They showed up at the 66th IT Press Tour with a pretty bold claim: 11.5 petabytes of storage in a 2U form factor, drawing 1200 watts at full capacity. That's not marketing fluff. It's the result of years of internal proofs of concept and a deliberate decision to go beyond off-the-shelf components.

Here's how they got there.

Why They Built Their Own SSDs

Novodisq didn't start out building custom drives. Their first two proofs of concept used commercial off-the-shelf SSDs in custom form factors. It didn't work. The COTS drives available at the time were either chasing high-performance benchmarks or targeting consumer workloads. Neither fit what Novodisq needed.

Their core insight was about the actual usage pattern of most enterprise data. It's write-once, read-sometimes. Data gets ingested and then mostly sits there—retained for legal, regulatory, or future analysis reasons. Some of it won't be touched for years. That's a very different workload than what most SSD firmware is optimized for.

So Novodisq built their own. Custom PCBs, custom firmware, and full control over the power and performance trade-offs. Micron supplies the NAND. Microchip provides the NVMe controllers. Novodisq writes the firmware on top.

The result is a drive architecture tuned specifically for long-term, low-power storage. They've achieved proof of life on their custom PCB—every NAND byte is addressable and functional. That's a real milestone for a team building SSDs from the ground up.

The AMD Versal G2 SoC: Where the Interesting Engineering Lives

Each Novoblade module is built around an AMD Versal G2 SoC. This chip is doing a lot of heavy lifting.

Versal combines ARM cores for running Linux and standard software stacks with a large block of FPGA fabric and dedicated AI accelerators. The same chip family shows up in Subaru's self-driving car systems. In Novoblade, it handles RAID, encryption, and checksumming entirely in hardware—none of that work hits the CPU.

But the FPGA fabric opens up more interesting possibilities. For genomics workloads, algorithms are increasingly being ported to run on FPGAs. Novodisq's architecture can ingest data, process it through FPGA logic in real time, and store it—all within a single blade module. For CCTV and video surveillance, the Versal has hardware video codecs and AI cores built in. You can inline recompress video streams, run detection models, and write long-term storage, all on the same hardware.

This isn't a storage box with compute bolted on afterward. The compute and storage are designed together from the start.

The Blade and Backplane Architecture

A single Novoblade module holds up to 576TB — that's four custom SSDs per blade in the production design. The prototype shown at FMS'25 had two SSDs installed, totaling 288 TB of raw NAND in one module.

Twenty of these blades fit into a 2U backplane chassis. The backplane handles networking and power distribution, and it supports multi-tenancy out of the box. The first four blades could belong to one customer, the next five to another, air-gapped within the same 2U unit. That's useful for managed service providers deploying shared infrastructure.

A single blade is already a functional Linux server on its own. You can start with one to three blades and scale up incrementally. No need to commit to a full 20-blade deployment upfront.

What This Means for Developers

The system runs standard Linux. No proprietary OS, no custom stack you need to learn. Kubernetes works. Existing tools like iSCSI and NFS work. Red Hat and other Kubernetes providers are on the radar for long-term support partnerships.

For developers working on data-heavy pipelines—genomics, video processing, AI training data management—this is worth watching. The FPGA acceleration during data ingestion is a real capability, not a roadmap item.

The Novoforge Dev Kit

Novodisq also introduced Novoforge™, their development kit. It's a 1U or 2U platform with eight E3.L hot-swap bays (currently around 0.5PB with available NAND), 16 ports of 2.5GbE with 800W PoE++ for edge and CCTV use cases, dual 10GbE uplinks, FPGA I/O, GNSS timing, and even DisplayPort over USB-C for workstation use.

It's designed for pilot projects and hands-on testing. Novodisq is already in conversations with customers about purchasing Novoforge units. If you're evaluating storage architectures for edge AI or sovereign data deployments, this is the entry point.

Where Things Stand

Novodisq is a seed-stage company. They have two New Zealand VCs, a tight engineering team, and 3-4 pilot customers in discussion across different verticals. Manufacturing is currently in Christchurch, but they've confirmed they can move production to Europe or the US if customers need it for supply chain or sovereignty reasons.

They'll be back at FMS 2026. The technology is real. The question now is whether the market moves fast enough to match what they've built.

Graid's SupremeRAID uses GPU acceleration to eliminate storage bottlenecks, delivering 28M IOPS for developers.

Sun, 08 Jun 2025 00:01:50 +0000

Graid Technology Revolutionizes Storage Performance with GPU-Accelerated RAID for Developers

The storage landscape for high-performance computing and AI development is undergoing a fundamental transformation. Traditional CPU-based RAID solutions have long created bottlenecks that limit application performance, forcing developers to architect around storage constraints rather than focusing on optimal code design. Graid Technology's SupremeRAID™ represents a paradigm shift that developers have been waiting for—GPU-accelerated RAID that eliminates these performance limitations.

Breaking Free from CPU-Based Storage Constraints

For decades, developers working on data-intensive applications have faced a fundamental challenge: storage performance that couldn't keep pace with computational demands. Traditional RAID controllers consume valuable CPU cycles and create throughput bottlenecks that limit the effectiveness of multi-threaded applications, real-time analytics systems, and AI training workloads.
SupremeRAID™ addresses this limitation by offloading RAID operations entirely to dedicated GPU hardware. This "out-of-path" architecture means storage operations no longer compete with application logic for CPU resources, fundamentally changing how developers can approach performance-critical applications.

The results speak for themselves. Graid's flagship solution achieves up to 28 million IOPS and 260GB/s throughput with a single card supporting up to 32 native NVMe drives. Perhaps more importantly for developers, the company reports achieving over 95% of raw NVMe performance in production environments—performance that was previously impossible with traditional RAID solutions.

Game-Changing Performance for AI Development

AI and machine learning developers face unique storage challenges. Training large models requires massive datasets that must be continuously fed to GPUs at tremendous speeds. Any storage bottleneck directly translates to expensive GPU idle time and extended training cycles.

SupremeRAID AE (AI Edition) specifically addresses these challenges with features such as GPUDirect Storage (GDS) support and an Intelligent Data Offload Engine. GDS enables direct NVMe-to-GPU memory transfers, eliminating CPU bottlenecks entirely. The Intelligent Data Offload Engine can actually put the RAID kernel to sleep during intensive GPU computation phases, freeing up additional GPU resources for AI workloads.

For developers building AI training pipelines, this means they can finally design systems where storage performance matches computational capability. No more architectural compromises to work around storage limitations—just pure performance that scales with your data requirements.

Simplifying Development with Software-Defined Architecture

Traditional RAID controllers require developers to understand complex hardware configurations and work within rigid performance constraints. SupremeRAID™'s software-defined approach provides flexibility that hardware solutions cannot match.

The platform supports seamless scaling across multiple GPU servers through features like NVMe-over-Fabrics (NVMe-oF). Developers can design distributed applications that treat storage as a unified resource pool rather than managing individual server limitations. A single SupremeRAID™ installation can provide RAID protection across multiple servers, dramatically simplifying application architecture.

Integration with existing developer workflows is straightforward. The solution includes RESTful APIs for modern IT automation and supports popular clustering storage systems like BeeGFS, Lustre, and Ceph without requiring data migration.

Real-World Developer Impact

The practical implications for developers are substantial. Consider real-time analytics applications that previously required careful buffering strategies to accommodate storage latency. With SupremeRAID™, developers can design more responsive systems that process data streams without artificial delays.

Game development studios leveraging real-time asset streaming can eliminate loading bottlenecks that previously required complex content management strategies. Scientific computing applications can process larger datasets in memory without the traditional tradeoffs between storage speed and data protection.

Financial trading systems greatly benefit from ultra-low latency capabilities. TelSwitch, a legal data analytics company, has deployed SupremeRAID™ across multiple systems specifically for processing massive datasets with small block sizes, precisely the kind of workload that traditional RAID struggles with.

Enterprise-Grade Reliability for Mission-Critical Code

Despite its performance focus, SupremeRAID™ maintains enterprise-grade data protection features that developers can rely on. The solution supports RAID 6 configurations, protecting against multiple drive failures while maintaining RAID 10-level performance characteristics.

Advanced features, such as journaling, bad block detection, and extended retry mechanisms, enable developers to architect systems with confidence in data integrity. The US Department of Defense has deployed SupremeRAID for edge computing applications that require "military-grade" reliability standards.

The Future of High-Performance Development

NVIDIA CEO Jensen Huang's recent statement, "for the very first time, your storage system will be GPU-accelerated," validates what Graid Technology has been building. As AI workloads become increasingly central to application development, storage architectures that match GPU performance capabilities become essential.

For developers building the next generation of data-intensive applications—whether AI training systems, real-time analytics platforms, or high-performance scientific computing solutions—SupremeRAID™ represents more than just faster storage. It's the foundation for applications that were previously impossible to build efficiently.

The era of designing around storage limitations is coming to an end. With GPU-accelerated RAID, developers can finally focus on building better software rather than working around infrastructure constraints.