Chapter 11: Foundational Security Architecture: Building the Fortress, Not Just the Fence
This chapter introduction previews the security concepts, architectural boundaries, credential protection, and attack analysis covered later in the chapter.
After this chapter you will be able to
- Security as an architectural attribute. Explain why security must be part of system design from the start rather than added before launch or left entirely to a cybersecurity team.
- Containment after an outer breach. Explain why an architect should consider what an attacker can reach after breaching an outer defense.
- Breach-Limiting Security Mindset. Explain why security architecture should assume breaches will happen and seek to limit their blast radius, rather than rely on an expensive firewall alone.
- Least privilege and blast radius. Explain that the Principle of Least Privilege grants users, systems, and processes only the access needed for their functions, denying other access by default. Describe how this limits what an attacker can reach if one account or component is compromised.
- Granular access boundaries. Describe how database, network, and file-system permissions can be limited to a component's purpose, and contrast that with a monolith sharing database-wide “God Mode” credentials.
- Independent Layers of Protection. Describe Defense in Depth as multiple independent controls placed throughout a system so that breaching one does not give an attacker unrestricted access. Explain how this helps contain a threat, especially when combined with Least Privilege.
- Security Layers Across System Tiers. Describe the different jobs of network and perimeter controls, per-request identity checks, application validation, and data encryption in a layered defense.
- Consolidated Security Responsibilities. Explain why giving every microservice its own public traffic, password management, and rate-limiting responsibilities is a security problem, and name the architectural concepts the section proposes instead.
- Single External Entry Point. Explain where an API Gateway sits in a distributed system and why external clients must reach internal services through it rather than contacting each service directly.
- Gateway Routing and Defenses. Describe how the gateway routes requests to internal services and handles shared defenses before requests reach core business logic.
- Delegated Identity Management. Explain why an architecture delegates authentication to an Identity Provider instead of implementing its own password handling or cryptography.
- Authentication and Authorization Roles. Distinguish OIDC's authentication role from OAuth 2.0's authorization role, and explain what using them together permits.
- IdP Token Request Journey. Trace what happens from a user's login through an API request reaching internal microservices.
- Backend JWT Verification Safeguards. Explain why UI restrictions or merely decoding a JWT are insufficient, and describe the three backend verification checks and the alg: none failure they prevent.
- Zero Trust Security Principle. Explain why passing an API gateway or being on an internal network does not make a request safe, and state what Zero Trust requires instead.
- Service Identity and Access Checks. Trace how the Order Service proves its identity and permission before retrieving specific Customer Service data, distinguishing mTLS from the application-token check.
- Service Mesh Sidecars. Describe how a service mesh uses sidecar proxies to handle communication concerns without putting that logic in each service’s application code.
- Incremental Zero Trust Migration. Describe the staged approach for introducing mesh controls into a legacy system without abruptly blocking required traffic.
- Layered Security Chokepoints. Trace the checkpoints an attacker would have to pass to reach the core database, and explain why breaching one layer does not grant free movement through the system.
- Committed Credential Risks. Explain why services still need authentication credentials when a database is isolated from the internet, and why committing those credentials in configuration files is dangerous.
- Hardcoded Credential Risks. Explain why committing credentials, using an admin account, and embedding a password in application code create distinct security and maintenance problems.
- Runtime Secret Retrieval. Describe how the application retrieves credentials without embedding them: it requests a specific secret from a Secrets Manager at runtime, using a temporary IAM role assigned to its server or container.
- Credentials Outside Source Code. Explain how retrieving a password at runtime keeps it out of the source repository and lets the security team rotate it without an outage.
- Compute Identity and Limited Permissions. Explain how a server or container proves its identity to retrieve a secret and why its permission should be narrowly scoped.
- Credential Expiration and Recovery. Explain why securely fetching a database password at startup is insufficient, and trace how an application can recover when that password rotates.
- Failed Rotation Safeguards. Explain how the application should respond when it cannot obtain a working replacement credential.
- Compromised Secret Response. Describe the response playbook the section gives for a suspected secret leak or compromise.
- Proactive architectural threat modeling. Explain why architects model threats during initial design rather than waiting for a prelaunch security audit, and how examining a diagram from an attacker’s perspective leads to defensible security decisions.
- Spoofing and tampering defenses. Distinguish spoofing, where an attacker impersonates a user or service, from tampering, where an attacker changes data; describe the identity checks and data protections the section pairs with them.
- Repudiation and disclosure defenses. Explain how missing attribution lets an actor deny a malicious action, while excessive data exposure lets someone see unauthorized information; describe the respective audit-log and data-filtering defenses.
- Service exhaustion and privilege escalation. Distinguish flooding a service until legitimate users cannot use it from gaining rights a user should not have, and describe the gateway and backend authorization defenses given for each.
- Vendor Access to Card Theft. Trace how attackers went from compromising Target’s HVAC vendor to stealing customers’ card data from cash registers.
- Implicit Trust and Missing Boundaries. Explain why vendor-portal access could lead to the POS network, and how the boundaries described in the section should have stopped that move.
- Third-Party Breach Boundaries. Explain why a well-defended outer perimeter did not protect Target, and describe how segmentation, short-lived vendor tokens, and egress filtering limit what an attacker can do after a vendor or server is compromised.
- Automated Security Boundary Checks. Describe how CI/CD checks enforce infrastructure and application security rules before deployment, including what policy or IaC scanning and SAST catch.
- Software Supply Chain Risks. Explain how trusted third-party software or build systems can carry an attacker into an application, and distinguish that threat from the nonmalicious dependency failure illustrated by left-pad.
- Dependency and Build Safeguards. Describe how an SBOM and dependency scanning can halt deployment of a known compromised library, and why build runners need limited privileges.
- Ongoing Integration Security Ownership. Explain the three A’s of continuous assessment and how automation, periodic ADR reviews, and owned data boundaries keep third-party integrations secure as they change.
- Security audit decision record. Explain why the Order Processor’s security audit should produce an Architecture Decision Record that documents the reasons for its changes, not just the changes themselves.
- System entry point map. Describe how to map the Order Processor’s entry points before deciding where its security perimeter lies.
- Restricted database account. Explain how replacing an administrator database account with a restricted user limits the damage from a compromised Order Processor.
- Runtime secret handling. Describe how to remove hardcoded secrets from the Order Processor and supply them during local development.
- Security as Breach Containment. Explain why security belongs in the architecture and how least privilege and defense in depth limit the damage when a boundary fails.
- Gateway and Internal Identity Controls. Describe the distinct roles of an API gateway, an identity provider, and Zero Trust, including the service-mesh option mentioned for internal requests.
What it builds on
- The “-ilities”: Your Vocabulary of Quality (chapter 2) · Introduces architectural quality attributes, or “-ilities.”
- The Cloud is Not Magic: The Multi-Tenant Reality (chapter 9) · Introduces the cloud's shared-infrastructure reality.
- The Solution: Infrastructure as Code (IaC) (chapter 9) · The use of Infrastructure as Code to automate infrastructure configuration.
- S – Single Responsibility Principle (SRP) (chapter 3) · The Single Responsibility Principle used to critique duplicated service responsibilities.
- Cross-Cutting Concerns (chapter 4) · Cross-cutting concerns that need not be embedded in core application logic.
- The Circuit Breaker Pattern: Preventing the Fire (chapter 10) · Uses the circuit breaker pattern to stop repeated failing attempts.
- Architecture Decision Records (ADR) (chapter 2) · ADRs as records of architectural decisions.
Section by section
Introduction
This chapter introduction previews the security concepts, architectural boundaries, credential protection, and attack analysis covered later in the chapter.
Introduction
The introduction establishes security as an architectural responsibility, explains why cloud exposure raises the stakes, and frames breach containment as a design question.
- Security as an architectural attribute: Explain why security must be part of system design from the start rather than added before launch or left entirely to a cybersecurity team.
Why it matters: Treating security as a design concern makes it part of architectural decisions from the outset. - Cloud exposure changes security stakes: Describe how moving from on-premise applications to the cloud changes the potential impact of a security misconfiguration.
Why it matters: Cloud exposure makes security mistakes potentially immediate and far-reaching. - Containment after an outer breach: Explain why an architect should consider what an attacker can reach after breaching an outer defense.
Why it matters: The damage from an intrusion depends on what the system allows an attacker to reach next.
Key terms: security, architectural attribute, -ilities, on-premise data centers, corporate firewall, cloud, misconfigured cloud server, exposed storage bucket, outer defenses, compromised service
11.2 The Security Mindset: Least Privilege and Defense in Depth
This section frames security as an architectural mindset that assumes breaches can happen and aims to limit their impact.
- Breach-Limiting Security Mindset: Explain why security architecture should assume breaches will happen and seek to limit their blast radius, rather than rely on an expensive firewall alone.
Why it matters: This mindset gives a purpose to the security measures introduced next: containing harm when protection fails.
Key terms: structural mindset, blast radius
11.2.1 The Principle of Least Privilege (PoLP)
This section explains how limiting each user or component to the permissions it needs reduces the damage from a compromise, and how to make those limits practical.
- Least privilege and blast radius: Explain that the Principle of Least Privilege grants users, systems, and processes only the access needed for their functions, denying other access by default. Describe how this limits what an attacker can reach if one account or component is compromised.
Why it matters: A stolen credential should not become a key to the whole system. - Granular access boundaries: Describe how database, network, and file-system permissions can be limited to a component's purpose, and contrast that with a monolith sharing database-wide “God Mode” credentials.
Why it matters: Component-specific permissions keep a flaw in one part of the system from granting unrelated powers. - Wildcard permissions and developer friction: Explain why developers may resort to wildcard permissions when access controls slow them down, and describe how automated permission generation and temporary elevated access avoid permanent broad privileges.
Why it matters: Security controls are more likely to survive deployment when developers have a workable alternative to permanent wildcard access.
Key terms: Principle of Least Privilege, PoLP, blast radius, deny access by default, God Mode, granular boundaries, SELECT (read) access, inbound traffic, wildcard (*) permission, developer friction
11.2.2 Defense in Depth (The Castle Approach)
Explains why a single security perimeter is insufficient and how independent layers of defense contain a breach.
- Limits of Perimeter Defense: Explain why trusting everyone inside a firewall is unsafe in modern systems.
Why it matters: It explains why security cannot stop at the firewall. - Independent Layers of Protection: Describe Defense in Depth as multiple independent controls placed throughout a system so that breaching one does not give an attacker unrestricted access. Explain how this helps contain a threat, especially when combined with Least Privilege.
Why it matters: A breach of one barrier need not become a breach of the whole system. - Security Layers Across System Tiers: Describe the different jobs of network and perimeter controls, per-request identity checks, application validation, and data encryption in a layered defense.
Why it matters: Each layer addresses a different way an attacker might advance toward the data.
Key terms: Perimeter Defense Model, firewall, Defense in Depth, Castle Approach, Least Privilege, Passive Network Security, Active Perimeter Defenses, Identity and Access Management, Application Defenses, Data Security
11.3 Architectural Security: API Gateways, Identity Providers, and Zero Trust
Explains why distributed systems should consolidate perimeter defenses and identity verification rather than make each microservice handle them independently.
- Consolidated Security Responsibilities: Explain why giving every microservice its own public traffic, password management, and rate-limiting responsibilities is a security problem, and name the architectural concepts the section proposes instead.
Why it matters: It gives you the reason for assigning security responsibilities at the architectural level rather than repeating them in every service.
Key terms: Single Responsibility Principle, perimeter defenses, identity verification, API Gateway, Identity Providers (OAuth/OIDC), Zero Trust
11.3.1 The API Gateway: The Single Chokepoint
Explains how an API Gateway provides one controlled entry point for external requests and handles shared perimeter defenses before requests reach internal services.
- Single External Entry Point: Explain where an API Gateway sits in a distributed system and why external clients must reach internal services through it rather than contacting each service directly.
Why it matters: A single entry point makes perimeter defenses easier to apply consistently. - Gateway Routing and Defenses: Describe how the gateway routes requests to internal services and handles shared defenses before requests reach core business logic.
Why it matters: Shared gateway handling keeps these perimeter concerns from being repeated in every service.
Key terms: API Gateway, single point of entry, single chokepoint, perimeter defense, rate limiting, TLS termination, request routing, initial authentication
11.3.2 Identity Providers (OAuth and OIDC): The Royal Seal
Explains how identity providers issue tokens, how OIDC and OAuth 2.0 divide identity and access responsibilities, and why backend JWT verification must be strict.
- Delegated Identity Management: Explain why an architecture delegates authentication to an Identity Provider instead of implementing its own password handling or cryptography.
Why it matters: Delegating identity work reduces the security burden on each application. - Authentication and Authorization Roles: Distinguish OIDC's authentication role from OAuth 2.0's authorization role, and explain what using them together permits.
Why it matters: Separating identity from permissions makes it easier to describe what a token is meant to establish. - Client Scenario Flow Choices: Explain why public clients need PKCE and why a background third-party vendor integration typically uses the Client Credentials Flow rather than a browser redirect flow.
Why it matters: The client environment affects which login protection or flow fits the integration. - IdP Token Request Journey: Trace what happens from a user's login through an API request reaching internal microservices.
Why it matters: The sequence shows where identity is established and where requests are checked. - Backend JWT Verification Safeguards: Explain why UI restrictions or merely decoding a JWT are insufficient, and describe the three backend verification checks and the alg: none failure they prevent.
Why it matters: A token's readable claims are not proof that its contents are authentic, current, or safely signed.
Key terms: Identity Provider (IdP), Multi-Factor Authentication (MFA), OIDC (OpenID Connect), OAuth 2.0, Authentication, Authorization, PKCE, Proof Key for Code Exchange, public clients, client secret
11.3.3 Zero Trust Architecture: The Internal Guards
Explains why internal traffic cannot be trusted by default, how services verify each other, and how to adopt Zero Trust without overcomplicating or disrupting a system.
- Zero Trust Security Principle: Explain why passing an API gateway or being on an internal network does not make a request safe, and state what Zero Trust requires instead.
Why it matters: A secure perimeter alone cannot protect other services after one internal service is compromised. - Service Identity and Access Checks: Trace how the Order Service proves its identity and permission before retrieving specific Customer Service data, distinguishing mTLS from the application-token check.
Why it matters: Proving which services are connected is not the same as proving that a caller may access particular data. - Service Mesh Sidecars: Describe how a service mesh uses sidecar proxies to handle communication concerns without putting that logic in each service’s application code.
Why it matters: A mesh can provide consistent service-to-service controls without requiring every team to build them into its own application. - Incremental Zero Trust Migration: Describe the staged approach for introducing mesh controls into a legacy system without abruptly blocking required traffic.
Why it matters: Observing existing dependencies before enforcing rules reduces the risk of breaking a legacy system. - Security Tooling Fit: Justify choosing managed services or more operationally demanding self-hosted security tooling according to a team’s circumstances.
Why it matters: Security tooling is only a defensible choice if the team can sustain its operational burden.
Key terms: Zero Trust Architecture, never trust, always verify, implicit trust, lateral movement, TLS, mutual TLS (mTLS), application token, Least Privilege, Service Mesh, sidecar
11.4 Diagram: The Modern Security Architecture
The section brings earlier security concepts together in a diagram showing how layered checkpoints protect the core database.
- Layered Security Chokepoints: Trace the checkpoints an attacker would have to pass to reach the core database, and explain why breaching one layer does not grant free movement through the system.
Why it matters: A breach of one checkpoint need not expose the database if other security requirements still stand in the attacker’s way.
Key terms: layered defense strategy, chokepoints, API Gateway, Identity Provider, Zero Trust mTLS network, core database
11.5 Code Snippet: Secrets Management
This section explains why services need credentials and why committing those credentials to source control is insecure and difficult to maintain.
- Committed Credential Risks: Explain why services still need authentication credentials when a database is isolated from the internet, and why committing those credentials in configuration files is dangerous.
Why it matters: Protecting the database also means protecting the credentials that let services access it.
Key terms: database credentials, configuration file, source code repository, secret rotation
11.5.1 Why is This a Disaster?
This section explains why hardcoded, overprivileged database credentials are dangerous and how runtime retrieval from a Secrets Manager avoids those risks.
- Hardcoded Credential Risks: Explain why committing credentials, using an admin account, and embedding a password in application code create distinct security and maintenance problems.
Why it matters: These are separate reasons a working credential can still be an architectural liability. - Runtime Secret Retrieval: Describe how the application retrieves credentials without embedding them: it requests a specific secret from a Secrets Manager at runtime, using a temporary IAM role assigned to its server or container.
Why it matters: The service can obtain the credential it needs without storing the credential or a permanent access key in its code.
Key terms: Source Control Leakage, God Account, Principle of Least Privilege, Static Vulnerability, Secrets Manager, IAM role, short-lived, Least Privilege
11.5.2 What makes this "Secure"?
Explains why runtime secret retrieval is safer than credentials in code and how secret access differs across hosting platforms.
- Credentials Outside Source Code: Explain how retrieving a password at runtime keeps it out of the source repository and lets the security team rotate it without an outage.
Why it matters: Keeping passwords out of code and fetching current values makes credential changes safer. - Compute Identity and Limited Permissions: Explain how a server or container proves its identity to retrieve a secret and why its permission should be narrowly scoped.
Why it matters: Compute identity and narrow permissions limit who can retrieve a secret and what a compromised resource can access. - Developer Platform Secret Injection: Distinguish the secret-access approach for smaller projects on developer-focused platforms from the compute-identity approach.
Why it matters: The appropriate secret-delivery method depends on the hosting platform.
Key terms: No Credentials in Code, Ready for Rotation, 401 Unauthorized, Identity-Based Access, IAM role, Granular Permissions, ReadOnly secret, Blast Radius, compute-identity pattern, encrypted Environment Variable settings
11.5.3 The Art of Secret Rotation
This section explains how to keep an application running when database secrets rotate, handle rotation failures, and respond to a suspected secret compromise.
- Credential Expiration and Recovery: Explain why securely fetching a database password at startup is insufficient, and trace how an application can recover when that password rotates.
Why it matters: A routine password change should not require a manual restart or become a user-visible outage. - Framework Supported Secret Rotation: Describe why the section favors existing framework integrations over a custom retry loop, using its Spring Boot example.
Why it matters: Using a supported integration can keep rotation handling out of business logic. - Failed Rotation Safeguards: Explain how the application should respond when it cannot obtain a working replacement credential.
Why it matters: Automatic rotation also needs a safe failure path when fresh credentials cannot be used. - Compromised Secret Response: Describe the response playbook the section gives for a suspected secret leak or compromise.
Why it matters: A rehearsed response limits how long a stolen credential remains useful and helps the team act clearly.
Key terms: secret rotation, Unauthorized, Invalidate the Cache, Secrets Manager, Retry the Operation, database connection pools, dynamic secrets, credential rotation, @RefreshScope, graceful degradation
11.6 Threat Modeling: Thinking Like an Attacker
This section teaches architects to model threats early and use STRIDE to connect specific ways a system could be attacked with appropriate defenses.
- Proactive architectural threat modeling: Explain why architects model threats during initial design rather than waiting for a prelaunch security audit, and how examining a diagram from an attacker’s perspective leads to defensible security decisions.
Why it matters: Finding plausible attacks in the design gives the team time to choose defenses before those weaknesses reach production. - Spoofing and tampering defenses: Distinguish spoofing, where an attacker impersonates a user or service, from tampering, where an attacker changes data; describe the identity checks and data protections the section pairs with them.
Why it matters: Separating false identity from altered data helps match each attack to the defense proposed for it. - Repudiation and disclosure defenses: Explain how missing attribution lets an actor deny a malicious action, while excessive data exposure lets someone see unauthorized information; describe the respective audit-log and data-filtering defenses.
Why it matters: An architecture must both account for significant actions and avoid sending data a recipient should not see. - Service exhaustion and privilege escalation: Distinguish flooding a service until legitimate users cannot use it from gaining rights a user should not have, and describe the gateway and backend authorization defenses given for each.
Why it matters: Traffic controls and permission checks protect against different failure modes and belong at the boundaries identified in the architecture.
Key terms: Threat Modeling, shift left, STRIDE, Risk Scout, Happy Path, Spoofing, Tampering, Identity Providers (IdP), mutual TLS (mTLS), TLS 1.2
11.7 The Dork Side: Target's HVAC Hack (2013)
The Target breach illustrates how stolen vendor credentials and implicit trust inside an unsegmented network let attackers reach cash registers and steal card data.
- Vendor Access to Card Theft: Trace how attackers went from compromising Target’s HVAC vendor to stealing customers’ card data from cash registers.
Why it matters: The breach shows how a seemingly limited third-party login can become a path to sensitive systems. - Implicit Trust and Missing Boundaries: Explain why vendor-portal access could lead to the POS network, and how the boundaries described in the section should have stopped that move.
Why it matters: A breached perimeter need not become a breach of every system behind it.
Key terms: HVAC vendor, vendor portal, Point of Sale (POS), malware, Defense-in-Depth, Zero-Trust Architecture, Least Privilege, egg model, segmented
11.7.1 The Architectural Lesson
Uses the Target breach to show how architects can limit third-party integration risks, secure the software supply chain, and reassess security boundaries over time.
- Third-Party Breach Boundaries: Explain why a well-defended outer perimeter did not protect Target, and describe how segmentation, short-lived vendor tokens, and egress filtering limit what an attacker can do after a vendor or server is compromised.
Why it matters: These boundaries reduce how far an attacker can move or send data after one integration fails. - Automated Security Boundary Checks: Describe how CI/CD checks enforce infrastructure and application security rules before deployment, including what policy or IaC scanning and SAST catch.
Why it matters: Automated checks can stop an unsafe change before it reaches production. - Software Supply Chain Risks: Explain how trusted third-party software or build systems can carry an attacker into an application, and distinguish that threat from the nonmalicious dependency failure illustrated by left-pad.
Why it matters: Trusting an update or package does not guarantee that its code—or its continued availability—is safe. - Dependency and Build Safeguards: Describe how an SBOM and dependency scanning can halt deployment of a known compromised library, and why build runners need limited privileges.
Why it matters: These controls help prevent known poisoned dependencies from shipping and keep a compromised build server from automatically controlling production. - Ongoing Integration Security Ownership: Explain the three A’s of continuous assessment and how automation, periodic ADR reviews, and owned data boundaries keep third-party integrations secure as they change.
Why it matters: Integrations change, so their checks, documented decisions, and data limits need continuing attention.
Key terms: Least Privilege network segmentation, Short-Lived Tokens, OAuth 2.0, Egress Filtering, Zero Trust, Policy as Code, IaC scanners, SAST, CI/CD, Supply Chain Attack
11.8 Your "In Action" Mission: Applying Security
This section guides a security audit of a refactored Order Processor and asks the reader to document the reasons for its security decisions in an ADR.
- Security audit decision record: Explain why the Order Processor’s security audit should produce an Architecture Decision Record that documents the reasons for its changes, not just the changes themselves.
Why it matters: Recording the reasoning helps the next developer preserve the protections you put in place. - System entry point map: Describe how to map the Order Processor’s entry points before deciding where its security perimeter lies.
Why it matters: You cannot describe the system’s security boundary accurately until you know where data can enter. - Restricted database account: Explain how replacing an administrator database account with a restricted user limits the damage from a compromised Order Processor.
Why it matters: Restricted database permissions reduce the damage an attacker can do through a compromised application. - Runtime secret handling: Describe how to remove hardcoded secrets from the Order Processor and supply them during local development.
Why it matters: Keeping secret values out of the codebase avoids embedding them in files developers share and maintain. - Developer access MFA: State which project accounts should require Multi-Factor Authentication and why this belongs in the security audit.
Why it matters: Protecting developer access closes a route around the system’s architectural defenses.
Key terms: Architecture Decision Record (ADR), Scribe, defense-in-depth, entry points, API Gateway, perimeter, God Account, Least Privilege, DROP, DELETE
11.9 Checklist
This section provides a self-check on security concepts covered earlier in the chapter without explaining them further.
11.10 Recap
The recap presents security as an architectural responsibility built around containing breaches, controlling access, protecting secrets, and repeatedly examining threats.
- Security as Breach Containment: Explain why security belongs in the architecture and how least privilege and defense in depth limit the damage when a boundary fails.
Why it matters: A breach need not become a compromise of the whole system. - Gateway and Internal Identity Controls: Describe the distinct roles of an API gateway, an identity provider, and Zero Trust, including the service-mesh option mentioned for internal requests.
Why it matters: An entry-point check alone does not establish trust between internal services. - Secrets and Ongoing Threat Review: Explain the recap’s approaches to managing credentials, maintaining security ownership, and systematically identifying threats.
Why it matters: Credentials and defenses need continued care after the initial design is complete.
Key terms: Principle of Least Privilege (PoLP), blast radius, Defense in Depth, Castle Approach, API Gateway, Identity Providers (IdP), OIDC, OAuth 2.0, Zero Trust, Service Mesh
Where this is used later
- The Fallacies of Distributed Computing (chapter 12) · Zero Trust Architecture.
- Architecture Governance: Automated Guardrails (chapter 13) · The later treatment of automated architecture guardrails builds on this security example.
- Diagram: CI/CD Pipeline: The Conveyor Belt of Truth (chapter 13) · Delivery-pipeline design must account for risks entering through dependencies and builds.
Concepts explained in this chapter
- principle of least privilegeA security principle that grants users, processes, and systems only the permissions necessary for their required functions.
- zero-trust architectureZero trust architecture is a system design that applies zero-trust principles through explicit verification and access controls.
- API gatewayAn API gateway is a centralized edge server that provides a single entry point for external clients and routes requests to internal services while enforcing shared perimeter concerns.
- authorizationThe process of determining whether an identity has permission to perform an action or access a resource.
- threat modelA threat model is a structured representation of potential attackers, attack paths, assets, and mitigations for a system.
- identity providerAn identity provider is a service that authenticates identities and issues credentials or assertions that other systems use for access decisions.
- mutual TLSA TLS configuration in which both communicating endpoints authenticate each other using certificates.
- anticorruption layerA boundary pattern that translates between an external system's model and an application's domain model to prevent external concepts from affecting the domain model.
- defense in depthLayered defense is a security pattern that places multiple independent protective controls between an attacker and protected resources.
- software supply-chain attackA supply chain attack compromises a trusted supplier, dependency, build process, or distribution channel to reach downstream users.
- securitySecurity is the protection of software systems and their data from unauthorized access, misuse, disruption, or alteration.
- service meshA service mesh is an infrastructure layer that manages service-to-service communication through dedicated networking components and centralized traffic policies.
- JSON Web TokenJWT is a compact, URL-safe token format for representing claims that can be digitally signed or encrypted.
- egress controlEgress filtering is the control of outbound network traffic according to approved destinations, protocols, ports, or policies.
- secrets managerA secrets manager securely stores and controls access to credentials, keys, and other sensitive values.
- dependency scanDependency scanning is the automated inspection of software dependencies for known vulnerabilities, malicious changes, or policy violations.
- infrastructure as code scanningInfrastructure scanning is the automated analysis of infrastructure definitions for security violations and unsafe configurations.
- network segmentationNetwork segmentation is the division of a network into isolated zones with controlled communication paths between them.
- policy as codePolicy as code is the representation and automated enforcement of operational or security rules in machine-readable code.
- secret scanningSecrets scanning is the automated detection of credentials, tokens, and other sensitive values embedded in source code or configuration.
- short-lived tokenA credential configured to expire after a brief period, limiting the usefulness of theft or compromise.
- software bill of materialsA software bill of materials is a machine-readable inventory of the software components and dependencies included in an application.
- static application security testingStatic application security testing is the automated analysis of application source or compiled code for vulnerabilities without executing the application.
- certificateA cryptographic certificate binds an identity to a public key and is used to authenticate that identity in secure communication.
- deny-by-defaultDeny by default is a security policy in which access is rejected unless it is explicitly permitted.
- implicit trustImplicit trust is an access assumption that treats a request as trustworthy based on its location or origin without independently verifying it.
- sidecar patternThe sidecar pattern deploys a helper process alongside a primary application process to provide supporting infrastructure capabilities.
- multifactor authenticationMulti-factor authentication is an authentication method that requires evidence from two or more independent credential factors.
- credential rotationSecret rotation is the practice of replacing credentials on a recurring or triggered basis while maintaining application access without unnecessary downtime.
- OAuthA version of the OAuth authorization framework that enables delegated, token-based access to protected resources.
- openid connectAn identity layer built on OAuth 2.0 that lets clients verify an authenticated user’s identity and obtain basic profile information.
- STRIDESTRIDE is a threat-modeling framework that classifies security threats as spoofing, tampering, repudiation, information disclosure, denial of service, and elevation of privilege.
- environment variableAn environment variable is a named runtime setting supplied through the process environment rather than embedded in application source code.
- identity and access managementIdentity and access management comprises policies and controls for verifying identities and authorizing their access to resources.
- JSON Web Key SetA JSON Web Key Set is a JSON document containing public cryptographic keys used to verify signed tokens.
- Proof Key for Code ExchangePKCE is an OAuth 2.0 security extension that binds an authorization request to a client-generated code verifier to protect public clients from intercepted authorization codes.
- none attackThe alg none exploit is a JWT attack in which an implementation accepts a token declaring no signature algorithm and therefore skips signature verification.
- AWS Secrets ManagerAWS Secrets Manager is an AWS service for storing, retrieving, and managing application secrets.
- credential compromiseSecret compromise is the unauthorized exposure or acquisition of a credential that could enable access to protected systems or data.
- incident response guidelineAn incident response plan is a documented set of actions for detecting, containing, investigating, and recovering from a security incident.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
