Blog / Secure Development

Security by Design — Required Sisyphus

The boulder rolls back by itself. That is not a failure of engineering — it is a property of the cause side. What is missing is not more effort, but a coordinate system.

BK
Bernhard Kreinz
• • Framework version 2.3.1 • Loading...

01 The promise, stated fairly

In practice, "Security by Design" is implemented as front-loaded assurance: make the right architectural decisions early, complete the threat model before first release, and enter maintenance with the difficult thinking supposedly behind you.

The serious standards are more careful than that, and it is worth saying so before criticising them. The Cyber Resilience Act requires cybersecurity to be addressed in design, development and production (Annex I, Part I) and then mandates vulnerability handling across the entire support period (Annex I, Part II). IEC 62443-4-1 is a secure product development lifecycle standard by definition. ISO/SAE 21434 spans the vehicle lifecycle. ETSI EN 303 645 includes ongoing vulnerability handling. NIS2 requires security in acquisition, development and maintenance, though as an organisational risk-management regime rather than a product standard. None of them claims the work stops at release.

So the criticism worth making is not that these regimes promise finality. It is narrower, and harder to dismiss: they require the review to continue without supplying a completion criterion for any single iteration of it. A team can demonstrate that it performed a threat assessment. It cannot demonstrate that the cause side was covered completely, because no closed set of causes is supplied against which "completely" could be tested.

They tell you the review must repeat. They do not tell you what a finished iteration looks like.

02 Why the boulder rolls back

Camus' point about Sisyphus was never the weight of the stone. It was the repetition without end. Secure development has that shape, and the mechanisms are enumerable:

  • The artifact changes. Every added feature widens functional scope, and scope is surface (#1). Every implementation change can introduce or expose server- or client-side flaws (#2, #3).
  • The inherited artifact changes. A dependency ships new functionality, new defects, or newly discovered weaknesses without your own code moving. Those exposures still classify by their cause — commonly #1, #2 or #3. It becomes #10 only where the attack succeeds because your environment accepts and relies on a compromised third-party trust artifact, component, update or service. An SBOM records what you shipped; it cannot record what will later be discovered about those components, what their maintainers will release next, or which trust relationship an attacker will eventually compromise.
  • The environment changes. #8 and #9 are Bridge topology — physical and human contexts that a designer models by assumption. Products get deployed into rooms and workflows nobody wrote a threat model for.
  • Nothing changes, and the design claim expires anyway. This is the case that settles the argument.

03 The clock alone is enough to invalidate the design claim

Take a product shipped in 2016 with a cipher suite that was, at the time, a correct and defensible decision. No line of code changes. No configuration drifts. No dependency moves. And the assumption under which the #5 surface — lack of end-to-end communication protection — was accepted as adequately controlled expires anyway, because cryptanalysis and available compute advanced while the artifact stood still. NIST has institutionalised precisely this: cryptographic transitions are planned events driven by algorithm weakening and growing computational capability, not incidents. The same logic governs the assumptions behind authentication binding (#4), and will govern them again through the post-quantum transition.

Be precise about what time does and does not do, because the distinction protects the taxonomy as well as the argument. Time does not obtain a position on the communication path, capture an artifact, present it, or abuse the resulting access. An attacker still performs every step:

A frozen product can become newly exploitable without receiving a new defect
#5 → #4 → #1 + [DRE: C]

What time supplied was not the attack. It was the reopening of an exposure that the design had recorded as adequately controlled.

Design-time correctness has a half-life. Treating a design claim as permanent is the most expensive assumption in secure development.

04 The wrong answer: accretion

The industry's response to recurrence has been to add. More controls, more checklists, more maturity levels, more framework crosswalks. Control catalogues grow with every revision; behavioural knowledge bases grow with every observation.

This does not address the problem, because an open-ended catalogue can demonstrate coverage of its own current entries and nothing beyond that. It cannot establish that its entries exhaust the cause space. You can evidence a hundred and fifty implemented safeguards and still have no answer to the question that matters: which classes of cause did this design never consider?

That is Sisyphus without even the dignity of a defined task — pushing up a hill of unknown height, unable to distinguish progress from motion.

05 "But STRIDE is already closed"

This is the fair objection from anyone who has run a real threat model, and it deserves an answer rather than a dismissal. STRIDE is a closed six-category set derived from six security properties — authentication, integrity, non-repudiation, confidentiality, availability, authorization. That gives it genuine coverage discipline, and it is why STRIDE outlived a generation of behavioural catalogues.

It is not, however, a completeness proof, and its authors never claimed one. The original Microsoft treatment states that if you decompose a system and mitigate every threat to every component you can argue the system is secure — and then immediately concedes that this cannot be proved, because threats frequently emerge only when subsystems are composed, and composition tends to violate the assumptions each subsystem was designed under. The same article grants that the word "threat" is itself open to interpretation and that no established method exists for measuring the quality of a threat model. It even poses the completeness problem outright — how do you know what you don't know? — and answers it by delegating downward to threat trees, checklists and attack patterns: an open-ended layer.

So the question is not whether six categories can be listed exhaustively. It is what those six categories are exhaustive over.

STRIDE categories against the cause/effect distinction
STRIDENegated propertyWhat it namesTLCTC placement
SpoofingAuthenticationA system state: one identity accepted as anotherCredential presentation or use is #4; acquisition or creation classifies to its own enabling cluster
TamperingIntegrityA data-level outcome[DRE: I]
RepudiationNon-repudiationAn accountability deficitNot a cause; manipulation, deletion or bypass of evidence classifies by its own cause
Information DisclosureConfidentialityA data-level outcome[DRE: C]
Denial of ServiceAvailabilityA data-level outcome[DRE: A] — reachable from multiple clusters; classify the actual step
Elevation of PrivilegeAuthorizationA system stateReached through a cause step; classify that step

Six categories, zero generic vulnerabilities.

Note also which elements STRIDE analyses: data flows, data stores, processes, interactors and trust boundaries. That is a model of the system as designed. A supplier's build pipeline, a maintenance technician with a screwdriver and a help-desk operator under time pressure are not data flow diagram elements — which is a structural reason why #10, #8 and #9 tend to be handled, if at all, outside the threat model rather than inside it.

Two consequences show up in almost every STRIDE-per-element table.

One label, many paths. A spoofing entry on a data flow names a state, not a cause. Under a cause-side taxonomy the presentation of a credential is always #4; what differs is everything that precedes it:

  • stolen artifact → enabling cluster → #4
  • relay from an on-path position → #5 → #4
  • help-desk manipulation → #9 → #4
  • identity forged through a trusted supplier → #10 → … → #4

These are not four competing classifications of one step. They are four distinct paths converging on one state, and they call for four different design decisions. STRIDE gives the state a single name, which is precisely why the mitigation column drifts toward the generic — "use TLS," "validate input," "authenticate" — because the label alone does not determine what to build.

The blind spot. STRIDE searches for property violations. #1 Abuse of Functions violates none. A capability operating exactly as designed, at exactly its intended trust level, producing harm — legitimate administrative tooling, an over-broad OAuth consent, a feature that is misconfigured yet perfectly functional — breaks no security property at the moment it is used. A model derived by negating properties cannot see it until a downstream violation appears, by which time the cause has already been lost. That is a recurring and increasingly consequential pattern, and it is part of why "living off the land" is discussed as a detection problem rather than a design problem.

It is tempting to say STRIDE simply occupies the right-hand side of the bow-tie, but its own table shows that is too clean. The six categories do not sit on one semantic layer: three describe data-level outcomes, two describe system states, one describes an accountability deficit. What none of them supplies is a classification of the generic vulnerability exploited at each attacker step.

The resolution is complementary rather than territorial. Keep STRIDE for the consequence question — which property would be violated, and how badly? Put a closed cause set underneath it for the design question. Tampering, information disclosure and denial of service collapse into [DRE: I], [DRE: C], [DRE: A]. Spoofing and elevation of privilege are states reached through cause sequences. Repudiation belongs to logging and evidence design. Nothing of value is lost, and the cause side finally gets a floor.

06 Ten questions, asked every iteration

The repetition is not escapable. It is boundable. The ten TLCTC clusters are derived from the structure of what is being protected rather than from observed attacker behaviour, which is why they do not grow when attackers get creative.

What follows is the cause-side half of a design review — deliberately scoped. It does not replace consequence analysis; Section 07 addresses where that belongs. The third column is the point: every answer carries an expiry date.

Cause-side design review — ten questions and their expiry conditions
ClusterThe design-time questionWhat makes the answer expire
#1 Abuse of FunctionsWhich capability we ship, used exactly as designed at its intended trust level, produces harm?Every new feature, flag, API, integration
#2 Exploiting ServerWhich attacker-controlled input does server-side code parse — protocol, core function, external handler?Every implementation change; every new handler
#3 Exploiting ClientWhat attacker-controlled content does our client fetch, render or interpret?New content types, new renderers
#4 Identity TheftWhat binds a presented artifact to its authentic holder at the point of authentication?Attacker replay capability; weakening binding assumptions; new proof-of-possession mechanisms
#5 Man in the MiddleIs protection end-to-end — and can the cryptography be replaced without a redesign?Cryptanalysis, compute, suite deprecation, PQC transition
#6 Flooding AttackWhich resource is finite, and what is the behaviour at saturation?Traffic growth; cheaper attacker bandwidth
#7 MalwareWhere can attacker-controlled Foreign Executable Content be loaded, interpreted or executed through an intended execution capability — and can that capability be removed, constrained or isolated?New interpreters, macro engines, plugin loaders, tool-execution paths
#8 Physical AttackWhat does an attacker holding the device — or standing near it — actually get?Deployment into unmodelled physical contexts
#9 Social EngineeringWhich security decisions do we push onto a human, under time pressure, with what indicators?New workflows, new interfaces, new support processes
#10 Supply Chain AttackWhich third-party trust relationships, if removed, would make the attack fail?New trust relationships; changes in supplier control, ownership or signing infrastructure

The gain is not that these questions are hard to think of. It is that the list is closed, so the omission of one becomes visible. "Not applicable" stops being a silent gap and becomes a claim somebody signs: "#8 is out of scope — the device only ever runs in a controlled facility." That sentence can be challenged, tested, and proven wrong when the product ships to a customer who mounts it on a lamp post. Today, that assumption is usually not written down at all.

07 Where design work accumulates

The tidy version of this argument would be that cause-side decisions decay while consequence-side decisions hold. That version is wrong in both directions, and worth correcting.

Consequence-side design decays too. Segmentation rules accumulate exceptions. Recovery assumptions go stale and backups become incompatible. Data minimisation is quietly undone by new collection. Blast-radius boundaries expand, key separation erodes, and business criticality moves under the architecture that was built for it.

Conversely, durable progress absolutely does accumulate on the cause side. Removing an unnecessary function permanently eliminates a #1 surface. Replacing an unsafe parser eliminates concrete #2 instances. Removing an interpreter closes a #7 execution path. Phishing-resistant authentication removes whole families of #4 paths. Eliminating a dependency removes a #10 trust relationship outright.

Design work accumulates in three places: eliminating or constraining cause-side surfaces, bounding the consequences of a successful compromise, and making the next reassessment cheaper. The first two decay under different pressures and at different rates. The third is what makes the repetition survivable: updateability, crypto-agility, modular isolation, observability. These are not classical controls so much as security-enabling architectural properties — meta-controls that preserve the system's ability to adapt.

Sisyphus does not make progress on only one side of the mountain. He makes progress whenever the next ascent is shorter, safer, or more measurable.

08 What closure does — and does not — buy

Covering all ten clusters at class level does not mean the product is secure. Class-level completeness makes gaps visible; it does not make instances absent. You can answer the #2 question thoughtfully and still ship an exploitable parser.

And the standard applied to STRIDE above has to be applied here too, or the argument is dishonest. TLCTC's closure is not proved either. It is constructive: the ten clusters are derived analytically from the structure of what is being protected, one attack surface at a time, rather than assembled from observation. And it is falsifiable: each cluster carries boundary tests stating the conditions under which a classification would be wrong. Remove the third-party trust relationship — if the attack still succeeds, the step was never #10. A taxonomy that specifies how it could be shown wrong can be argued about on evidence rather than preference.

That is a weaker claim than proof and a considerably stronger one than a checklist. It is also the only claim being made here. Throughout this article, closure means one thing: closed category-level cause coverage for a single iteration of the review. Not proof that the product is secure. Not finality across its lifecycle.

09 The regulator has already conceded Sisyphus

Look at the structure of the CRA. Annex I, Part I sets out security properties the product must have. Part II sets out vulnerability-handling processes the manufacturer must run across the support period — testing, remediation, security updates, coordinated disclosure. Read structurally — and this reading is mine, not the legislator's — Part II is the acknowledgement that Part I cannot remain sufficient on its own.

What is absent is the coordinate system. The CRA names risks, vulnerabilities, misuse conditions, security properties and selected attack forms, but it does not provide a closed cause-side reference set against which the completeness of a manufacturer's threat assessment could be tested. Article 13 requires a cybersecurity risk assessment; nothing specifies the categories it must exhaust.

That is not a defect of the regulation as such — EU law is technology-neutral by legislative design, and enumeration is deliberately delegated to the harmonised standards. The gap sits one layer down: the standards commonly used for secure development organise processes, security properties, requirements and risk-assessment activities, but they do not supply the kind of compact, non-overlapping cause-side reference set proposed here. A manufacturer's statement that all relevant threats were considered therefore remains an assertion: it cannot be shown to be wrong, which means it cannot be shown to be right. Ten technology-neutral clusters are exactly the sort of thing that layer is missing — and technology neutrality is an argument in their favour, not against.

10 Imagine the designer happy

Camus ends by insisting that Sisyphus must be imagined happy. The labour does not end; that is simply the condition of the work. What makes labour absurd is not repetition — it is repetition without a measure.

Security by Design is not a state you reach. It is a question set you keep answering, at every design iteration, for the entire supported life of the product. Ten questions, asked repeatedly and answered on the record, is not absurdity. It is engineering.

Without closure, you are not doing Security by Design. You are performing it.

— References

  1. Regulation (EU) 2024/2847 (Cyber Resilience Act), Article 13 (obligations of manufacturers) and Annex I, Parts I and II. eur-lex.europa.eu
  2. Directive (EU) 2022/2555 (NIS2), Article 21(2)(e) — security in network and information systems acquisition, development and maintenance.
  3. IEC 62443-4-1, Secure product development lifecycle requirements.
  4. ISO/SAE 21434, Road vehicles — Cybersecurity engineering.
  5. ETSI EN 303 645 V3.1.3, Cyber Security for Consumer Internet of Things: Baseline Requirements.
  6. S. Hernan, S. Lambert, T. Ostwald, A. Shostack, "Uncover Security Design Flaws Using the STRIDE Approach," MSDN Magazine, November 2006. learn.microsoft.com
  7. NIST SP 800-131A Rev. 2, Transitioning the Use of Cryptographic Algorithms and Key Lengths.
  8. B. Kreinz, A Cause-Oriented Cyber Threat Taxonomy: The Top Level Cyber Threat Clusters Framework, v2.3.1, 2026. DOI: 10.5281/zenodo.20633177
  9. A. Camus, Le Mythe de Sisyphe, Gallimard, 1942.

TLCTC — Top Level Cyber Threat Clusters, v2.3.1. A cause-oriented, closed taxonomy of ten generic cyber threat clusters. CC BY 4.0 · Published 1 August 2026 · tlctc.net · github.com/Barnes70/TLCTC