English version: scroll down

Security by obscurity is dood

Een paar dagen geleden zag ik een post van Danielle Fong. Claude Code had in acht minuten, met één prompt, een kwetsbaarheid gevonden in de firmware van een Coldcard-wallet. Haar conclusie was simpel en scherp: we hebben jarenlang geleund op security by obscurity. Die obscurity wordt nu razendsnel doorzichtig door geïndustrialiseerde code-reasoning agents.

Als obscurity verdwijnt, blijft preventie noodzakelijk, maar niet langer voldoende. We moeten systemen bouwen die bestand zijn tegen ontdekking én we moeten kunnen bewijzen wat er werkelijk is gebeurd. Dat is een fundamenteel andere manier van denken over security. De klassieke vraag was: hoe voorkom ik dat iemand binnenkomt? De nieuwe vraag wordt: als iemand binnenkomt, als een systeem een fout maakt of als een AI-agent ontspoort, kan ik dan nog vaststellen en bewijzen wat er is gebeurd?

In een wereld waarin AI-agents zelfstandig code analyseren, systemen aanpassen, data verwerken en beslissingen nemen, is security niet langer alleen een kwestie van preventie. We hebben daarnaast een onveranderbaar geheugen nodig. Een digitale zwarte doos.

Security krijgt een geheugen

In de luchtvaart is het ondenkbaar dat een vliegtuig alleen beveiligd zou zijn zolang alles goed gaat. Een cockpitrecorder en flight data recorder zijn juist bedoeld voor het moment waarop iets misgaat. Niet om de crash te voorkomen, maar om achteraf zo precies mogelijk te kunnen reconstrueren wat er gebeurde. Voor IT is dat lange tijd anders geweest. We hebben logs, monitoring, SIEM-systemen en databases. Maar veel van die registraties bevinden zich uiteindelijk binnen hetzelfde IT-landschap dat onderzocht moet worden. Een beheerder kan logs aanpassen. Een aanvaller kan sporen wissen. Een gecompromitteerd systeem kan zijn eigen geschiedenis veranderen.

Dan heb je wel logging, maar nog geen bewijs. Dat onderscheid wordt steeds belangrijker: een log is informatie; een onveranderbaar vastgelegde gebeurtenis is bewijs. Oplossingen zoals de DGMV ICT BlackBox van DigiCorp Labs zijn vanuit precies die gedachte ontwikkeld. Logging wordt onafhankelijk van de kern-IT vastgelegd, waarbij blockchain-validatie, Non-Fungible Data Entries en WORM-opslag samen een onveranderbare audit trail vormen. Logging verschuift daarmee van een operationeel hulpmiddel naar een forensische bewijslaag.

Als iedereen kan kijken, moet je kunnen bewijzen

Dat is de stap die nodig is wanneer obscurity geen bescherming meer biedt. Als iedereen kan kijken, moeten we achteraf kunnen aantonen wat er werkelijk stond, wat er veranderde en wie of wat die verandering veroorzaakte. Een Black Box registreert vooral gebeurtenissen nadat data of een actie is ontstaan. Daar zit nog een volgende laag. Want hoe weet je of de data waarmee een systeem begon überhaupt betrouwbaar was?

Daarvoor is niet alleen een zwarte doos nodig, maar ook een geboorteakte van data. Dat is de gedachte achter de Non-Fungible Data Entry, de NFD. Niet als digitaal eigendomsbewijs, maar als een cryptografisch vastgelegde geboorte van data: waar kwam deze data vandaan, wanneer ontstond zij, wie of welk systeem was erbij betrokken en onder welke omstandigheden? Op het eerste gezicht lijkt dat een administratief detail. In werkelijkheid is het een nieuwe securitylaag.

Stel dat een AI-agent vandaag een beslissing neemt op basis van een dataset. Dan is de cruciale vraag niet alleen of die beslissing is genomen, maar waar de oorspronkelijke data vandaan kwam, wat er onderweg met die data is gebeurd en welke beslissing de AI vervolgens heeft genomen.

Zonder die keten kunnen we achteraf hooguit vaststellen dat er iets is gebeurd. Met die keten kunnen we proberen te reconstrueren waarom, op basis waarvan en door wie of wat. Daarmee ontstaat iets wat we in de fysieke wereld heel normaal vinden: provenance. Een voedselproduct heeft een herkomst. Een medicijn heeft een batchnummer. Een vliegtuigonderdeel heeft een serienummer en onderhoudshistorie. Een financieel document heeft een auteur, datum en goedkeuring. Data had dat lange tijd nauwelijks. Data kon vrijwel anoniem door organisaties bewegen. AI maakt dat probleem groter.

AI maakt data genealogisch

De interessante consequentie van een NFD is dat data niet alleen een oorsprong kan hebben, maar ook een stamboom. Een dataset wordt gebruikt door een AI-model. Het model produceert nieuwe data. Die nieuwe data wordt vervolgens gebruikt door een ander model. Dat model maakt weer een nieuwe analyse. Enzovoort. Zo ontstaat een keten van bron naar verwerking, van AI-model naar afgeleide data, van nieuwe verwerking naar beslissing en uiteindelijk naar actie. Als iedere belangrijke stap aantoonbaar wordt vastgelegd, ontstaat een digitale genealogie. Dat is veel meer dan logging. Logging vertelt wat een systeem heeft gedaan. Data provenance vertelt waar de input vandaan kwam. Samen vertellen ze de geschiedenis van een digitale beslissing.

Precies daar raken de twee ideeën elkaar: het geboortebewijs van data en de zwarte doos van IT. De eerste legt vast wat er aan het begin van de keten gebeurt. De tweede legt vast wat er tijdens het proces gebeurt. Tussen die twee ontstaat iets nieuws: digitale accountability.

De AI-agent heeft een flight recorder nodig

Dit wordt vooral relevant voor AI-agents. Een klassieke applicatie doet wat een programmeur heeft bedacht. Een AI-agent krijgt steeds vaker een doel en zoekt vervolgens zelf de route naar dat doel. Hij observeert, interpreteert, beslist en handelt. Dat lijkt sterk op de OODA-loop: Observe, Orient, Decide, Act. Deze denkwijze werd ontwikkeld door de Amerikaanse luchtmachtpiloot en strateeg John Boyd en beschrijft een continue cyclus van waarnemen, oriënteren, beslissen en handelen. Juist omdat AI-agents deze cyclus steeds sneller kunnen doorlopen, wordt het moeilijker voor mensen om achteraf uit het geheugen van het systeem te reconstrueren waarom een bepaalde actie is uitgevoerd. Een AI-agent zonder onafhankelijke registratie is eigenlijk een vliegtuig zonder flight recorder. Zolang alles goed gaat, merk je het niet.

Totdat het misgaat.

Mijn eerdere stuk over de AI-black box ging precies over dat probleem: we hebben een onafhankelijke getuige nodig die AI-beslissingen en acties kan vastleggen, zodat afwijkend gedrag, incidenten en manipulatie achteraf onderzocht kunnen worden. Daaruit volgt een belangrijk nieuw principe. Een autonome AI-agent heeft niet alleen een identiteit nodig. Hij heeft ook een geschiedenis nodig. Wie heeft hem gemaakt? Met welke versie van het model werkt hij? Welke data mag hij gebruiken? Welke bevoegdheden heeft hij? Welke tools mag hij aanroepen? Welke beslissingen heeft hij genomen? Welke acties heeft hij uitgevoerd? En vooral: kan hij achteraf nog ontkennen wat hij heeft gedaan?

Van Zero Trust naar Zero Unknown

Zero Trust zegt: vertrouw niets, verifieer alles. In de wereld van autonome AI moeten we daar nog een principe aan toevoegen: Zero Unknown. Niet alleen moet een agent worden geauthenticeerd en iedere actie worden geautoriseerd. We moeten ook kunnen reconstrueren wat er is gebeurd. Identity, authorization, provenance en auditability horen bij elkaar. Een AI-agent krijgt een digitale identiteit. Zijn bevoegdheden worden vastgelegd. De data waarmee hij werkt heeft een herkomst. Zijn acties worden onafhankelijk geregistreerd. En de belangrijke gebeurtenissen worden onveranderbaar vastgelegd.

Zo ontstaat een nieuwe security-architectuur waarin identiteit, autorisatie, herkomst, handeling en bewijs onlosmakelijk met elkaar verbonden zijn. Dat is fundamenteel anders dan security by obscurity. Obscurity zegt: je weet niet hoe het werkt, dus je kunt het niet aanvallen. Deze nieuwe architectuur zegt: je mag weten hoe het werkt. Maar als je het aanvalt, kunnen we bewijzen dat je het deed, wat je deed en wat er is gebeurd. Dat is een veel sterkere positie.

De paradox van openheid en controle

Daarmee ontstaat een interessante paradox. Hoe opener systemen worden, hoe belangrijker het wordt om de geschiedenis van die systemen betrouwbaar vast te leggen. Open source maakt de code zichtbaar. AI maakt analyse van die code goedkoop. Cryptografie maakt bepaalde eigenschappen wiskundig controleerbaar. Maar geen van die drie vertelt automatisch wat er gisteren met een systeem is gebeurd. Daarvoor heb je bewijs nodig.

Onveranderbare logging en data provenance zijn geen tegengestelde beweging van open source. Ze vullen elkaar juist aan. Openheid zegt: kijk maar. Cryptografie zegt: controleer maar. Provenance zegt: dit is waar het vandaan kwam. De Black Box zegt: dit is wat er daarna gebeurde. Samen zeggen ze: je hoeft mij niet op mijn woord te geloven. Je kunt het controleren.

Van geheim naar bewijs

Daarmee komen we terug bij het begin. Security by obscurity probeerde onzekerheid te creëren bij de aanvaller. De nieuwe security-architectuur probeert juist zekerheid te creëren bij de verdediger. Niet verbergen, maar bewijzen. Niet hopen dat niemand het ontdekt, maar ervan uitgaan dat iemand het ontdekt. Niet vertrouwen op het feit dat een systeem geheim is, maar ervoor zorgen dat het systeem veilig blijft wanneer het volledig bekend is. En als er toch iets misgaat, zorgen dat de digitale geschiedenis niet kan worden uitgewist.

Dat is misschien wel de belangrijkste verschuiving die AI ons brengt. AI vernietigt niet alleen security by obscurity. AI dwingt ons om na te denken over wat er daarna komt. Het antwoord is niet nóg meer geheimhouding. Het antwoord is evidence.

Van security naar bewijsvoering

De komende jaren zullen we daarom een verschuiving zien van security als een probleem van preventie naar security als een combinatie van preventie, verificatie en bewijsvoering. De vraag is dan niet meer alleen of een systeem veilig is, maar of we kunnen aantonen dat het veilig was, welke data het heeft gebruikt, wie of wat een beslissing heeft genomen en of de registratie achteraf niet is veranderd. Als het antwoord op die vragen nee is, hebben we misschien geen securityprobleem in de klassieke betekenis. We hebben iets fundamentelers: een bewijsprobleem.

Daarmee verschuift ook de betekenis van vertrouwen. We vertrouwen straks niet meer omdat een leverancier zegt dat zijn systeem veilig is. We vertrouwen omdat de architectuur het mogelijk maakt om dat onafhankelijk te controleren. Dat is de stap van trust naar verifiable trust.

Misschien is dat wel de echte les van de Coldcard-kwetsbaarheid. Niet dat AI tegenwoordig sneller bugs kan vinden. Maar dat we een wereld binnengaan waarin alles wat verborgen is uiteindelijk gevonden kan worden, en waarin alleen datgene duurzaam waarde houdt wat aantoonbaar klopt.

Security by obscurity is dood

Security by obscurity is dood. AI heeft alleen de stekker eruit getrokken. Wat overblijft is de vraag hoe we digitale systemen bouwen waarin niet geheimhouding, maar bewijs de basis van vertrouwen vormt. De toekomst van security is niet dat niemand het systeem begrijpt. De toekomst is dat iedereen het mag begrijpen, en dat niemand de geschiedenis ervan kan vervalsen.

Photo by Lucas Andrade

———————-Translated by ChatGPT  —————————-

From Security by Obscurity to Security by Evidence

Security by obscurity is dead

A few days ago, I came across a post by Danielle Fong. Claude Code had found a vulnerability in the firmware of a Coldcard wallet in just eight minutes, using a single prompt. Her conclusion was simple and sharp: for years, we have relied on security by obscurity. That obscurity is now becoming transparent at an astonishing speed through industrialized code-reasoning agents.

If obscurity disappears, prevention remains necessary, but it is no longer sufficient. We need to build systems that can withstand discovery, and we need to be able to prove what actually happened. That is a fundamentally different way of thinking about security. The classic question was: how do we prevent someone from getting in? The new question becomes: if someone gets in, if a system makes a mistake, or if an AI agent goes off the rails, can I still determine and prove what happened?

In a world where AI agents independently analyze code, modify systems, process data, and make decisions, security is no longer just a matter of prevention. We also need an immutable memory. A digital black box.

Security needs a memory

In aviation, it is unthinkable that an aircraft would only be considered secure as long as everything goes well. A cockpit voice recorder and flight data recorder are specifically designed for the moment when something goes wrong. Not to prevent the crash, but to reconstruct as accurately as possible what happened afterwards. IT has traditionally been different. We have logs, monitoring, SIEM systems, and databases. But many of these records ultimately reside within the same IT environment that needs to be investigated. An administrator can modify logs. An attacker can erase traces. A compromised system can alter its own history.

Then you have logging, but you do not yet have evidence. That distinction is becoming increasingly important: a log is information; an immutably recorded event is evidence. Solutions such as DigiCorp Labs’ DGMV ICT BlackBox are built precisely around that idea. Logging is recorded independently of the core IT environment, with blockchain validation, Non-Fungible Data Entries, and WORM storage together creating an immutable audit trail. Logging therefore shifts from an operational tool to a forensic evidence layer.

If everyone can look, you need to be able to prove

That is the step we need when obscurity no longer provides protection. If everyone can look, we need to be able to demonstrate afterwards what was actually there, what changed, and who or what caused that change. A Black Box primarily records events after data or an action has occurred. There is another layer beneath that. How do we know that the data with which a system started was reliable in the first place?

The birth certificate of data

For that, we need not only a black box, but also a birth certificate for data. That is the idea behind the Non-Fungible Data Entry, or NFD. Not as a digital ownership certificate, but as a cryptographically recorded birth of data: where did this data come from, when was it created, who or what system was involved, and under what circumstances? At first glance, this may seem like an administrative detail. In reality, it is a new security layer.

Suppose an AI agent makes a decision today based on a dataset. The crucial question is not only whether that decision was made, but where the original data came from, what happened to that data along the way, and which decision the AI ultimately made.

Without that chain, we can at best establish that something happened. With that chain, we can try to reconstruct why it happened, what it was based on, and who or what was responsible. This creates something that we take for granted in the physical world: provenance. Food has an origin. Medicine has a batch number. An aircraft component has a serial number and maintenance history. A financial document has an author, a date, and an approval. Data has had very little of this for a long time. Data could move through organizations almost anonymously. AI makes that problem bigger.

AI makes data genealogical

The interesting consequence of an NFD is that data can have not only an origin, but also a family tree. A dataset is used by an AI model. The model produces new data. That new data is then used by another model. That model produces another analysis. And so on. A chain emerges from source to processing, from AI model to derived data, from new processing to decision, and ultimately to action. If every important step can be demonstrably recorded, a digital genealogy emerges. That is much more than logging. Logging tells us what a system did. Data provenance tells us where the input came from. Together, they tell the history of a digital decision.

That is precisely where the two ideas meet: the birth certificate of data and the black box of IT. The first records what happens at the beginning of the chain. The second records what happens during the process. Between the two, something new emerges: digital accountability.

The AI agent needs a flight recorder

This becomes particularly relevant for AI agents. A traditional application does what a programmer has designed it to do. An AI agent increasingly receives a goal and then determines its own path toward that goal. It observes, interprets, decides, and acts. This strongly resembles the OODA loop: Observe, Orient, Decide, Act. The concept was developed by U.S. Air Force pilot and strategist John Boyd and describes a continuous cycle of observation, orientation, decision-making, and action. Precisely because AI agents can move through this cycle ever faster, it becomes harder for humans to reconstruct afterwards, from the system’s own memory, why a particular action was taken. An AI agent without independent recording is essentially an aircraft without a flight recorder. As long as everything goes well, you do not notice.

Until something goes wrong.

My earlier piece about the AI black box addressed precisely this problem: we need an independent witness that can record AI decisions and actions, so that anomalous behavior, incidents, and manipulation can be investigated afterwards. This leads to an important new principle. An autonomous AI agent does not only need an identity. It also needs a history. Who created it? Which version of the model is it using? Which data is it allowed to use? What permissions does it have? Which tools can it call? Which decisions has it made? Which actions has it taken? And above all: can it still deny what it did afterwards?

From Zero Trust to Zero Unknown

Zero Trust says: trust nothing, verify everything. In the world of autonomous AI, we need to add another principle: Zero Unknown. An agent must not only be authenticated and every action authorized. We must also be able to reconstruct what happened. Identity, authorization, provenance, and auditability belong together. An AI agent receives a digital identity. Its permissions are recorded. The data it works with has an origin. Its actions are independently recorded. And important events are stored immutably.

This creates a new security architecture in which identity, authorization, provenance, action, and evidence are inseparably connected. That is fundamentally different from security by obscurity. Obscurity says: you do not know how it works, so you cannot attack it. This new architecture says: you are allowed to know how it works. But if you attack it, we can prove that you did, what you did, and what happened. That is a much stronger position.

The paradox of openness and control

This creates an interesting paradox. The more open systems become, the more important it becomes to reliably record their history. Open source makes the code visible. AI makes analysis of that code inexpensive. Cryptography makes certain properties mathematically verifiable. But none of these automatically tells us what happened to a system yesterday. For that, we need evidence.

Immutable logging and data provenance are not the opposite of open source. They complement each other. Openness says: look. Cryptography says: verify. Provenance says: this is where it came from. The Black Box says: this is what happened afterwards. Together they say: you do not have to take my word for it. You can verify it.

From secrecy to evidence

That brings us back to the beginning. Security by obscurity tried to create uncertainty for the attacker. The new security architecture tries to create certainty for the defender. Do not hide, but prove. Do not hope that nobody discovers it, but assume that someone will. Do not rely on the fact that a system is secret, but make sure that the system remains secure when it is fully known. And if something does go wrong, make sure that the digital history cannot simply be erased.

That may be the most important shift AI is bringing us. AI is not merely destroying security by obscurity. AI is forcing us to think about what comes next. The answer is not even more secrecy. The answer is evidence.

From security to evidence

In the coming years, we will therefore see a shift from security as a problem of prevention to security as a combination of prevention, verification, and evidence. The question will no longer be only whether a system is secure, but whether we can demonstrate that it was secure, which data it used, who or what made a decision, and whether the record has remained unchanged afterwards. If the answer to those questions is no, we may not have a security problem in the traditional sense. We have something more fundamental: an evidence problem.

That also changes the meaning of trust. We will no longer trust simply because a supplier tells us that its system is secure. We will trust because the architecture makes it possible to verify that independently. That is the move from trust to verifiable trust.

Perhaps that is the real lesson of the Coldcard vulnerability. Not that AI can now find bugs faster. But that we are entering a world in which everything that is hidden can eventually be found, and in which only what can be demonstrably proven to be correct will retain lasting value.

Security by obscurity is dead

Security by obscurity is dead. AI has simply pulled the plug. What remains is the question of how we build digital systems in which not secrecy, but evidence, forms the foundation of trust. The future of security is not that nobody understands the system. The future is that everyone is allowed to understand it, and that nobody can falsify its history.