Security Architect

Security Architect

Overview

Security Architect is a consolidated skill that covers the complete security lifecycle: threat modeling, secure design principles, secure coding practices, and regulatory compliance. It ensures security is integrated from the start, not bolted on at the end.

Consolidated from:

• threat-modeling - STRIDE threat analysis and risk assessment
• security-first-design - Security principles and secure design patterns
• secure-coding-review - OWASP Top 10 and vulnerability detection
• compliance-validator - GDPR, HIPAA, SOC2, PCI-DSS compliance

When to Use This Skill

Use Security Architect when:

• Starting a new project (design phase)
• Conducting security architecture review
• Reviewing code for security vulnerabilities
• Ensuring regulatory compliance
• Responding to security incidents
• Planning for security certifications (SOC2, ISO 27001)
• Designing authentication and authorization systems

Key Capabilities

Threat Modeling (from threat-modeling)

• Apply STRIDE methodology for threat identification
• Assess risk levels (Likelihood × Impact)
• Create threat models and mitigation plans
• Identify attack surfaces and trust boundaries

Security Design (from security-first-design)

• Apply security principles (Defense in Depth, Least Privilege, Zero Trust)
• Design secure authentication and authorization
• Implement encryption and key management
• Design secure APIs and data protection

Secure Coding (from secure-coding-review)

• Review code against OWASP Top 10
• Detect injection vulnerabilities (SQL, XSS, command)
• Identify broken authentication and access control
• Ensure secure data handling and validation

Compliance (from compliance-validator)

• Ensure GDPR, HIPAA, CCPA, SOC2, PCI-DSS compliance
• Implement data subject rights (access, erasure, portability)
• Design audit logging and retention policies
• Configure encryption and access controls

Workflow

Part 1: Threat Modeling (STRIDE)

STRIDE Framework

S - Spoofing (Authentication)

• Threat: Attacker impersonates a user or system
• Examples:
  • Stolen credentials
  • Session hijacking
  • Weak or no authentication
• Mitigations:
  • Multi-factor authentication (MFA)
  • Strong password policies
  • JWT with short expiration
  • Secure session management

T - Tampering (Integrity)

• Threat: Attacker modifies data or code
• Examples:
  • SQL injection
  • Man-in-the-middle attacks
  • Parameter manipulation
  • Code injection
• Mitigations:
  • Input validation and sanitization
  • HTTPS/TLS everywhere
  • Signed tokens (JWT)
  • Integrity checks (hashing)

R - Repudiation (Accountability)

• Threat: User denies performing an action
• Examples:
  • No audit logs
  • Unsigned transactions
  • Anonymous actions
• Mitigations:
  • Comprehensive audit logging
  • Digital signatures for transactions
  • Immutable log storage
  • User action tracking

I - Information Disclosure (Confidentiality)

• Threat: Sensitive data exposed to unauthorized parties
• Examples:
  • Exposed API keys
  • Database dumps
  • Verbose error messages
  • Insufficient access controls
• Mitigations:
  • Encryption at rest and in transit
  • Principle of least privilege
  • Secure secret management (AWS Secrets Manager, Vault)
  • Role-based access control (RBAC)

D - Denial of Service (Availability)

• Threat: System becomes unavailable to legitimate users
• Examples:
  • DDoS attacks
  • Resource exhaustion
  • Unhandled exceptions
• Mitigations:
  • Rate limiting and throttling
  • Input validation (reject massive payloads)
  • Auto-scaling infrastructure
  • CDN and DDoS protection (Cloudflare)

E - Elevation of Privilege (Authorization)

• Threat: User gains unauthorized access to higher privileges
• Examples:
  • Broken access control
  • Insecure direct object references (IDOR)
  • Missing authorization checks
• Mitigations:
  • Authorization checks on every request
  • Principle of least privilege
  • Attribute-based access control (ABAC)
  • Regular permission audits

Threat Modeling Process

Step 1: Identify Assets

• User data (PII, passwords, financial info)
• Business data (IP, customer lists, transactions)
• System credentials (API keys, certificates)
• Infrastructure (servers, databases, APIs)

Step 2: Identify Trust Boundaries

• User ↔ Web App
• Web App ↔ API
• API ↔ Database
• Internal services ↔ External APIs
• Admin ↔ Production systems

Step 3: Apply STRIDE to Each Boundary For each boundary, ask:

• S: Can an attacker spoof identity?
• T: Can data be tampered with?
• R: Can actions be repudiated?
• I: Can information be disclosed?
• D: Can service be denied?
• E: Can privileges be elevated?

Step 4: Assess Risk

Risk = Likelihood × Impact

Likelihood:
- High (likely to occur)
- Medium (may occur)
- Low (unlikely to occur)

Impact:
- Critical (data breach, financial loss, legal liability)
- High (significant damage, downtime)
- Medium (limited damage, temporary disruption)
- Low (minimal impact)

Risk Level:
- Critical: Immediate action required
- High: Address before launch
- Medium: Address post-launch
- Low: Monitor, may accept risk

Step 5: Define Mitigations For each threat, document:

• Mitigation strategy
• Implementation effort (low, medium, high)
• Residual risk after mitigation
• Owner and timeline

Part 2: Security-First Design

Security Principles

1. Defense in Depth Multiple layers of security controls. If one fails, others still protect.

Example:

• Layer 1: Firewall
• Layer 2: Authentication
• Layer 3: Authorization
• Layer 4: Encryption
• Layer 5: Audit logs

2. Least Privilege Users/systems only have minimum permissions needed.

Example:

• Read-only database credentials for reporting service
• User can only see their own data
• Admin access requires MFA + time-limited token

3. Zero Trust Never trust, always verify. Even internal networks are untrusted.

Example:

• Every request authenticated and authorized
• No "trusted" internal network
• Encrypt internal traffic
• Assume breach mentality

4. Secure by Default Default configuration is secure. Users must opt-in to less secure options.

Example:

• HTTPS enforced by default
• Strict password policy by default
• MFA recommended on signup
• Secure cookies (HttpOnly, Secure, SameSite)

5. Fail Securely When errors occur, fail in a way that doesn't compromise security.

Example:

• Access denied on error (not granted)
• Log error but don't expose details to user
• Graceful degradation without exposing internals

Secure Design Patterns

Authentication:

• Pattern: OAuth 2.0 + OpenID Connect (OIDC)
• Implementation:
  • Use Auth0, AWS Cognito, or Okta (don't build your own)
  • JWT tokens with short expiration (15 min access, 7 day refresh)
  • Secure token storage (HttpOnly cookies or secure local storage)
  • MFA for sensitive operations

Authorization:

• Pattern: Role-Based Access Control (RBAC) or Attribute-Based Access Control (ABAC)
• Implementation:
  • Define roles: admin, user, viewer
  • Check authorization on every API request
  • Use middleware: @requireRole('admin')
  • Implement IDOR protection (verify ownership)

Data Protection:

• Pattern: Encryption at rest and in transit
• Implementation:
  • TLS 1.3 for all external traffic
  • AES-256 for data at rest
  • Key management service (AWS KMS, Google Cloud KMS)
  • Encrypt PII fields (email, SSN, credit cards)

API Security:

• Pattern: Rate limiting + authentication + input validation
• Implementation:
  • Rate limit: 100 requests/minute per user
  • API keys for server-to-server
  • OAuth tokens for user-to-server
  • Validate all inputs (type, length, format)
  • Whitelist allowed values

Secrets Management:

• Pattern: Never commit secrets, use secret managers
• Implementation:
  • AWS Secrets Manager or HashiCorp Vault
  • Environment variables for config (never in code)
  • Rotate secrets regularly (90 days)
  • Use IAM roles (not long-lived credentials)

Part 3: Secure Coding Review (OWASP Top 10)

OWASP Top 10 (2021)

A01: Broken Access Control

• Risk: Users access data/functions they shouldn't
• Examples:
  • URL tampering: /user/123 → /user/456
  • Missing authorization checks
  • Insecure Direct Object References (IDOR)

How to Detect:

// BAD: No authorization check
app.get('/api/users/:id', (req, res) => {
  const user = db.users.findById(req.params.id)
  res.json(user) // Anyone can see any user!
})

// GOOD: Check ownership
app.get('/api/users/:id', authMiddleware, (req, res) => {
  const requestedId = req.params.id
  const currentUserId = req.user.id

  if (requestedId !== currentUserId && !req.user.isAdmin) {
    return res.status(403).json({ error: 'Forbidden' })
  }

  const user = db.users.findById(requestedId)
  res.json(user)
})

A02: Cryptographic Failures

• Risk: Sensitive data exposed due to weak or missing encryption
• Examples:
  • Plaintext passwords in database
  • HTTP instead of HTTPS
  • Weak hashing (MD5, SHA1)

How to Detect:

// BAD: Plaintext password
const user = { email, password: req.body.password }
db.users.create(user)

// GOOD: Hash with bcrypt
const bcrypt = require('bcrypt')
const hashedPassword = await bcrypt.hash(req.body.password, 10)
const user = { email, password: hashedPassword }
db.users.create(user)

A03: Injection

• Risk: Attacker injects malicious code (SQL, XSS, command)
• Examples:
  • SQL injection
  • Cross-site scripting (XSS)
  • Command injection

How to Detect:

// BAD: SQL Injection
const query = `SELECT * FROM users WHERE email = '${req.body.email}'`
db.query(query) // Attacker can send: ' OR '1'='1

// GOOD: Parameterized query
const query = 'SELECT * FROM users WHERE email = ?'
db.query(query, [req.body.email])

// BAD: XSS
;<div dangerouslySetInnerHTML={{ __html: userInput }} />

// GOOD: Escape user input
import DOMPurify from 'dompurify'
const sanitized = DOMPurify.sanitize(userInput)
;<div dangerouslySetInnerHTML={{ __html: sanitized }} />

A04: Insecure Design

• Risk: Flawed architecture or missing security controls
• Examples:
  • No rate limiting
  • Lack of threat modeling
  • No security requirements

How to Detect:

• Review architecture diagram
• Check for rate limiting, authentication, authorization
• Validate threat model exists

A05: Security Misconfiguration

• Risk: Default configs, verbose errors, unnecessary features enabled
• Examples:
  • Default admin password
  • Directory listing enabled
  • Stack traces in production

How to Detect:

// BAD: Exposes stack trace
app.use((err, req, res, next) => {
  res.status(500).json({ error: err.stack })
})

// GOOD: Generic error message
app.use((err, req, res, next) => {
  logger.error(err)
  res.status(500).json({ error: 'Internal server error' })
})

A06-A10: Other Critical Issues

• A06: Vulnerable and Outdated Components (use npm audit, Dependabot)
• A07: Identification and Authentication Failures (weak passwords, no MFA)
• A08: Software and Data Integrity Failures (supply chain attacks)
• A09: Security Logging and Monitoring Failures (no audit logs)
• A10: Server-Side Request Forgery (SSRF) (validate URLs)

Part 4: Compliance Validation

Regulatory Frameworks

GDPR (General Data Protection Regulation)

• Scope: EU data subjects
• Key Requirements:
  • Lawful basis for processing (consent, contract, legitimate interest)
  • Data subject rights (access, rectification, erasure, portability)
  • Privacy by design and default
  • Data breach notification (72 hours)
  • Data Protection Impact Assessment (DPIA) for high-risk processing

Implementation Checklist:

• Consent mechanism for data collection
• Data subject access request (DSAR) process
• Right to erasure ("right to be forgotten") implementation
• Data portability export (JSON/CSV)
• Privacy policy and cookie banner
• Data Processing Agreement (DPA) with vendors
• Breach notification process

HIPAA (Health Insurance Portability and Accountability Act)

• Scope: Healthcare data in the US
• Key Requirements:
  • Protected Health Information (PHI) must be encrypted
  • Access controls and audit logs
  • Business Associate Agreements (BAA)
  • Breach notification

Implementation Checklist:

• Encrypt PHI at rest (AES-256) and in transit (TLS 1.3)
• Role-based access control to PHI
• Audit logs for all PHI access
• BAA with cloud providers (AWS, Azure)
• Breach notification process
• Regular security risk assessments

SOC 2 (Service Organization Control 2)

• Scope: SaaS companies handling customer data
• Key Requirements:
  • Trust Service Criteria (Security, Availability, Confidentiality)
  • Access controls and monitoring
  • Change management
  • Incident response

Implementation Checklist:

• Security policies documented
• Background checks for employees
• Multi-factor authentication (MFA) enforced
• Encryption at rest and in transit
• Audit logging and monitoring
• Incident response plan
• Vendor management program
• Regular security training

PCI-DSS (Payment Card Industry Data Security Standard)

• Scope: Organizations handling credit card data
• Key Requirements:
  • Never store CVV/CVC codes
  • Encrypt cardholder data
  • Regularly update and patch systems
  • Restrict access to cardholder data

Implementation Checklist:

• Use payment processor (Stripe, Braintree) - DON'T store cards yourself
• If storing cards, use tokenization
• PCI-compliant hosting (Level 1 certified)
• Network segmentation (isolate cardholder data)
• Vulnerability scanning and penetration testing
• Strong access controls

Examples

Example 1: Threat Model for SaaS Application

Application: Project Management SaaS

Assets:

• User credentials (email, password)
• Project data (documents, tasks, comments)
• Payment information (via Stripe)
• API keys for integrations

Trust Boundaries:

1. User Browser ↔ Web App (HTTPS)
2. Web App ↔ API Server (internal TLS)
3. API Server ↔ Database (encrypted connection)
4. API Server ↔ Stripe API (HTTPS)

STRIDE Analysis for Boundary 1 (User ↔ Web App):

Priority Mitigations:

1. Implement MFA (High risk, high impact)
2. Add rate limiting (Medium risk, easy fix)
3. Enable CSP headers (High risk, easy fix)

Example 2: Secure Code Review Findings

Code Review: User authentication endpoint

Findings:

CRITICAL: SQL Injection (A03)

// Current code (VULNERABLE):
const query = `SELECT * FROM users WHERE email = '${email}' AND password = '${password}'`

// Recommended fix:
const query = 'SELECT * FROM users WHERE email = ? AND password_hash = ?'
const hashedPassword = bcrypt.hashSync(password, user.salt)
db.query(query, [email, hashedPassword])

HIGH: Plaintext Passwords (A02)

// Current code (VULNERABLE):
db.users.create({ email, password })

// Recommended fix:
const hashedPassword = await bcrypt.hash(password, 10)
db.users.create({ email, password: hashedPassword })

MEDIUM: No Rate Limiting (A04)

// Recommended fix:
const rateLimit = require('express-rate-limit')
const loginLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 5 // 5 attempts
})
app.post('/login', loginLimiter, loginHandler)

Action: Fix CRITICAL and HIGH before deployment. Add MEDIUM post-launch.

Example 3: GDPR Compliance Implementation

Requirement: Implement data subject rights

Implementation:

1. Right to Access (DSAR)

app.get('/api/user/data-export', authMiddleware, async (req, res) => {
  const userId = req.user.id

  const userData = {
    profile: await db.users.findById(userId),
    projects: await db.projects.findByUser(userId),
    comments: await db.comments.findByUser(userId),
    activity: await db.activityLog.findByUser(userId)
  }

  res.setHeader('Content-Type', 'application/json')
  res.setHeader('Content-Disposition', 'attachment; filename=my-data.json')
  res.json(userData)
})

2. Right to Erasure

app.delete('/api/user/account', authMiddleware, async (req, res) => {
  const userId = req.user.id

  // Anonymize instead of delete (retain for legal compliance)
  await db.users.update(userId, {
    email: `deleted-${userId}@example.com`,
    name: 'Deleted User',
    deleted_at: new Date()
  })

  // Delete PII
  await db.sessions.deleteByUser(userId)
  await db.notifications.deleteByUser(userId)

  res.json({ message: 'Account deleted successfully' })
})

3. Consent Management

const user = {
  email,
  marketing_consent: req.body.marketingConsent || false,
  analytics_consent: req.body.analyticsConsent || false,
  consent_date: new Date()
}

Best Practices

Threat Modeling

1. Model early - Design phase, not after development
2. Update regularly - When architecture changes
3. Focus on high-risk threats - Don't aim for 100% coverage
4. Document mitigations - Not just threats

Security Design

1. Use proven solutions - Don't roll your own crypto
2. Defense in depth - Multiple layers of security
3. Secure by default - Opt-in to less secure, not opt-out
4. Assume breach - Design with "when" not "if" mindset

Secure Coding

1. Automate security scanning - SAST, DAST, SCA in CI/CD
2. Validate all inputs - Trust nothing from users
3. Use security libraries - OWASP, helmet.js, DOMPurify
4. Keep dependencies updated - Monitor with Dependabot

Compliance

1. Understand scope - Which regulations apply to you
2. Document everything - Policies, procedures, decisions
3. Regular audits - Internal + external reviews
4. Work with legal - Don't interpret regulations alone

Common Pitfalls

1. Security as an Afterthought

Antipattern: Build first, secure later Result: Expensive retrofitting, vulnerabilities in production

Better: Integrate security from design phase

2. Trusting Client-Side Validation

Antipattern: Only validate on frontend Result: Attacker bypasses with curl

Better: Always validate on backend

3. Rolling Your Own Crypto

Antipattern: Custom encryption or hashing Result: Weak crypto, vulnerabilities

Better: Use proven libraries (bcrypt, libsodium)

4. Over-Reliance on Compliance

Antipattern: "We're compliant, so we're secure" Result: Compliant but insecure

Better: Compliance is minimum; security is ongoing

5. Ignoring Low-Risk Threats

Antipattern: Only fix CRITICAL issues Result: Death by a thousand cuts

Better: Systematically address all severity levels

Related Skills

• quality-assurance - Security testing and validation gates
• api-designer - API security patterns
• deployment-advisor - Infrastructure security
• framework-orchestrator - Security in phase gates
• data-engineer - Data security and privacy

Deliverables

When using Security Architect, produce:

1. Threat Model

   • Asset inventory
   • Trust boundaries
   • STRIDE analysis
   • Risk assessment
   • Mitigation plan

2. Security Architecture Document

   • Authentication/authorization design
   • Encryption strategy
   • Secrets management
   • Network diagram with security controls

3. Secure Code Review Report

   • OWASP Top 10 findings
   • Severity ratings
   • Remediation recommendations
   • Re-test results

4. Compliance Checklist

   • Applicable regulations
   • Implementation status
   • Gap analysis
   • Remediation plan

Success Metrics

Security Architect is effective when:

• Threat models completed before development
• Zero CRITICAL vulnerabilities in production
• Security incidents <1 per year
• Compliance audits passed
• Security gates enforced in CI/CD
• Team follows secure coding practices
• Regular security training completed

Remember: Security is not a feature, it's a foundation. Build it in from the start.