Kerckhoffs's principle

Design a cryptosystem to stay secure even when the entire algorithm is public, confining secrecy to the key alone — because a leaked key is cheaply rotated while a leaked algorithm cannot be replaced without rebuilding the whole system.

Version

v3 · 2026-09-28 · History

Domain-specific #

593

Domain group

Applied Sciences & Engineering

Origin domain

Computer Science & Software Engineering

Subdomain

Cryptography → Computer Science & Software Engineering

Core Idea

Kerckhoffs's principle states that a cryptosystem should be secure even if everything about it — algorithm, protocol, implementation — is public; only the key must stay secret. The operative mechanism is an asymmetry of replaceability: a key is small and cheap to generate, rotate, and revoke, whereas an algorithm, once deployed across hardware and protocol stacks, cannot be replaced without coordinated migration. Staking security on the key is recoverable; staking it on a hidden mechanism is catastrophic. Shannon restated it as "the enemy knows the system."

How would you explain it like I'm…

Hide the Key, Not the Lock

Think of a lock on a treasure box. Even if everyone knows exactly how the lock is built, the treasure stays safe as long as only you have the key. And if someone copies your key, you just get a new key instead of building a whole new lock.

Hide the Key, Not the Lock

Kerckhoffs's principle is a rule for secret codes. It says a code system should stay safe even if the enemy knows exactly how it works; the only secret should be the key. That's because keys are small and easy to change, but the whole system is hard to replace once lots of people use it. It's even good to show the system to everyone, so experts can find weak spots before bad guys do. Trying to keep the method itself hidden is called 'security through obscurity,' and it tends to fail.

The Enemy Knows the System

Kerckhoffs's principle says a cryptosystem should be secure even if everything about it, including the algorithm, protocol and implementation, is public; only the key must stay secret. Auguste Kerckhoffs stated it in 1883 for military ciphers, and Claude Shannon later summarized it as 'the enemy knows the system.' The logic is about replaceability: a key is cheap to generate, revoke and rotate, while an algorithm built into hardware and software is very costly to replace. So betting security on a hidden algorithm means betting on a secret you can't easily change if it leaks. That's why modern cryptography publishes algorithms for public attack, as in the AES and SHA-3 competitions, and why 'security through obscurity' is considered the failure mode.

 

Kerckhoffs's principle holds that a cryptosystem's security must rest solely on the secrecy of the key, not on the secrecy of the algorithm, protocol or implementation. Kerckhoffs formulated it in 1883 for military cipher design, reasoning that captured equipment should not compromise security; Shannon restated it as 'the enemy knows the system.' The mechanism is an asymmetry of replaceability. A key is a small, bounded secret that can be generated cheaply, distributed over authenticated channels, and revoked or rotated without changing the cipher, so a compromise is contained. An algorithm is a structural artifact embedded across hardware, software and protocol stacks; replacing it requires a coordinated system-wide migration. Hence a Kerckhoffs-compliant design puts security on the cheap-to-rotate secret. The principle also favors publishing designs for adversarial review, since public cryptanalysis finds flaws before deployment; the AES and SHA-3 selection processes embody this. Security through obscurity is the contrasting failure mode, whose protection erodes as knowledge leaks with no cheap recovery.

Scope of Application

Kerckhoffs's principle lives across cryptography and the adjacent security disciplines that share both an adversarial threat model and a genuine small-replaceable secret inside a public system.

• Symmetric and asymmetric cryptography — security staked entirely on the key.
• Cryptographic standardization — the NIST model (AES, SHA-3) publishes candidates for years of cryptanalysis.
• Open-source security review — crypto libraries published so weaknesses are found before deployment.
• Operational security — two-factor tokens and password rotation treat the credential as the secret.
• Nuclear command-and-control — Permissive Action Links separate weapon design from a rotatable unlock code.

Clarity

The principle makes the cost structure of a compromise legible where intuition pulls the wrong way. Leaking the key is recoverable; leaking the Algorithm is irreversible, because it cannot be rotated out of deployed systems. The question shifts from "how do we keep the adversary from learning anything?" to "where does a leak cost a cheap rotation, and where the whole system?" — and it dissolves the conflation of secrecy with security.

Manages Complexity

A component-by-component "how much of each should we hide?" deliberation collapses to one scalar per component: replaceability cost. That sorts every part into two bins — cheap-to-rotate (the key, the only thing allowed secret) and catastrophic-to-rotate (everything else, therefore published). The analyst tracks one binary: is all secrecy confined to the small rotatable parameter? The whole threat model is pre-answered at once.

Abstract Reasoning

The concept supports a threat-model-collapsing move — assuming the adversary holds the full design and asking only whether the key suffices — a replaceability sort that dictates design ("whatever you cannot afford to lose, make replaceable") — a diagnostic reading breach cost off where secrecy lives — and a publication-as-tool move that inverts the intuition that exposure is risk.

Knowledge Transfer

Within cryptography and adjacent security the mechanism transfers intact, because those domains share an adversarial threat model and a real replaceable secret. Beyond that envelope the maxim "don't rely on obscurity" travels as analogy, but the genuine cross-domain structure is the parent separation_of_concerns / modularity applied to volatility — isolate the volatile, high-risk concern in a swappable module. Kerckhoffs is its security-domain specialization; the key/algorithm framing stays home.

Relationships to Other Abstractions

Current abstraction Kerckhoffs's principle Domain-specific

Parents (2) — outgoing typed relations

• Kerckhoffs's principle is a decomposition of Asymmetry Prime

  Kerckhoffs preserves a directed replaceability imbalance: a key is cheap to rotate, while a deployed mechanism is catastrophically expensive to replace.

• Kerckhoffs's principle is a decomposition of Modularity Prime

  Removing cryptographic vocabulary leaves change-prone secret state isolated behind an interface so it can be replaced without rebuilding the mechanism.

Hierarchy paths (2) — routes to 2 parentless roots

• Kerckhoffs's principle → is a decomposition of Asymmetry

Show alternative path (1)

Neighborhood in Abstraction Space

Kerckhoffs's principle sits in a sparse region of the domain-specific corpus (68^th percentile for distinctiveness): few abstractions share its structure, so a faithful description tends to retrieve it precisely.

Family — Adversarial AI & Security Attacks (14 abstractions)

Nearest neighbors

• Encryption — 0.86
• Public-Key Cryptography — 0.84
• Prompt Injection — 0.84
• Data Extraction Through Prompting — 0.83
• AI Supply-Chain Attack — 0.83

Computed from structural-signature embeddings · 2026-10-25