Preface

Every few years, someone dumps lsass.exe and the industry remembers that a Windows machine is only as trustworthy as the weakest link in a very long chain. The hash that comes out of that memory dump is not the beginning of the story or the end of it. Behind it sits a credential-isolation trustlet; behind that, a hypervisor; behind that, a measured boot; behind that, a key fused into silicon the operating system never sees. Modern Windows is not secured by one feature. It is secured by a chain: each link making a promise to the link above it, all the way from the CPU's first instruction to a token your identity provider honors in the cloud.

This book walks that chain, link by link, in the order trust is actually established: silicon → kernel → credentials → cloud. For each link it answers three questions a serious practitioner has to be able to answer: How does this link establish trust? How can I prove it is actually doing so on a real machine? And where, exactly, does it break? The last question is not an afterthought. Every link in this chain has a documented way around it, and a reader who understands the mechanism but not its limits is more dangerous than one who knows neither.

Who this is for

This is a book for Reasoners: security architects, detection engineers, advanced blue-teamers, and threat modelers who need to reason precisely about what a Windows platform actually protects. It is not an exploitation manual. When an attack appears in these pages, it appears as gap analysis: the boundary of what a defense was ever going to cover, so you can decide what compensating control has to live somewhere else. You do not need to be an expert in all four domains the chain spans (almost nobody is), which is why the book opens with a short Foundations chapter that levels the vocabulary before Part I begins.

A word about how this book was written

This book was produced by a multi-agent writing pipeline that I designed and operate. I chose the topics, set the editorial bar, audited the output, and own every error that remains. That should lower your trust in these pages, not raise it, and so it should: a pipeline of language models is exactly the kind of author you must not take on faith. So this book does not ask you to. It is built around a single, uncomfortable discipline, the same one it demands of every link in the chain: an author who cannot be taken on faith must show his work, and hand you the means to check it.

So the book shows it. Wherever a claim can be checked against a live Windows machine, you will find the evidence inline: the exact probe, the verbatim output, and a SHA-256 hash of that output recorded at capture time. A build gate re-hashes every quoted capture against its manifest and refuses to publish the chapter if a single character was changed. The prose is reasoned and, like all reasoning, can be wrong; the numbers are captured, hashed, and reproducible, and you can re-run the probe yourself. Where a mechanism cannot be captured on the lab machine (the parts of the chain that live in physical silicon a virtual machine cannot expose), the book says so, in those words, rather than dressing a documented claim up as a measured one. That honesty, made mechanical, is the whole point.

How to read it

You can read the chain front to back, which is how it was built to be read, or drop into any link you own and use the Foundations chapter and each chapter's inline Foundations section to fill the gaps. Either way, do the one thing the book keeps asking you to do: don't take the chapter's word for it. Run the probe. The trust chain is only worth anything if you can verify it, and so is a book about it.

— Parag Mali, 2026