1~
2Een kwetsbaarheid die tijdens het schrijven van code wordt ontdekt, kost een ontwikkelaar minuten om op te lossen. Dezelfde kwetsbaarheid die in productie wordt gevonden, kost een sprint. En als een aanvaller het eerst vindt, kost het miljoenen. Dit is het kernargument achter **shift-left security**  -  beveiligingscontroles zo vroeg mogelijk in de ontwikkelingscyclus uitvoeren.
3~
4DevSecOps neemt dit idee en maakt er een praktijk van: beveiliging is geen aparte fase aan het einde, maar een continu proces dat verweven is met elke fase van de ontwikkeling  -  van de eerste regel code tot de productie-deployment.
5~
6## De Kosten van Late Beveiliging
7~
8Het IBM Cost of a Data Breach Report heeft consequent aangetoond dat de kosten voor het oplossen van beveiligingsproblemen exponentieel stijgen naarmate ze later worden ontdekt:
9~
10| Fase | Kosten om te herstellen | Tijd om te herstellen |
11|------|-------------------------|------------------------|
12| **IDE / Lokale ontwikkeling** | Minuten | Seconden tot minuten |
13| **Code Review / PR** | Uren | Minuten tot uren |
14| **CI/CD Pipeline** | Dagen | Uren tot dagen |
15| **Staging / QA** | Weken | Dagen |
16| **Productie** | Maanden | Weken tot maanden |
17| **Na een aanval** | Miljoenen ($) | Maanden tot jaren |
18~
19De conclusie is duidelijk: elke fase die u beveiliging eerder plaatst, bespaart een orde van grootte aan kosten en tijd.
20~
21## De DevSecOps Pipeline
22~
23Een volwassen DevSecOps pipeline integreert beveiligingscontroles in elke fase:
24~
25```mermaid
26graph LR
27    IDE[IDE / Editor] --> PC[Pre-commit Hooks]
28    PC --> PR[Pull Request]
29    PR --> CI[CI Pipeline]
30    CI --> Build[Build / Package]
31    Build --> Deploy[Deploy]
32    Deploy --> Runtime[Runtime / Production]
33~
34    IDE -.- S1[SAST\nSecret Detection\nLinting]
35    PC -.- S2[Secrets Scan\nFormat Check]
36    PR -.- S3[Code Review\nDependency Audit]
37    CI -.- S4[SAST\nSCA\nContainer Scan\nSBOM]
38    Build -.- S5[Image Signing\nArtifact Verification]
39    Deploy -.- S6[Policy Enforcement\nAdmission Control]
40    Runtime -.- S7[DAST\nWAF\nMonitoring]
41```
42~
43Laten we elke fase doorlopen met concrete tools en configuratie.
44~
45## Fase 1: Beveiliging in de IDE
46~
47De snelste feedback-loop. Kwetsbaarheden opvangen voordat u het bestand zelfs maar opslaat.
48~
49### Aanbevolen Tools
50~
51- **Semgrep**: lichtgewicht statische analyse met community-regels voor OWASP-kwetsbaarheden
52- **Snyk IDE Extension**: real-time kwetsbaarheidsscanning voor dependencies
53- **GitLens + GitLeaks**: secrets detecteren in uw editor
54- **ESLint Security Plugins**: `eslint-plugin-security` voor Node.js, `eslint-plugin-no-unsanitized` voor DOM XSS
55~
56### Voorbeeld: ESLint Security-configuratie
57~
58```json
59{
60  "extends": ["eslint:recommended"],
61  "plugins": ["security", "no-unsanitized"],
62  "rules": {
63    "security/detect-object-injection": "warn",
64    "security/detect-non-literal-regexp": "warn",
65    "security/detect-unsafe-regex": "error",
66    "security/detect-buffer-noassert": "error",
67    "security/detect-eval-with-expression": "error",
68    "security/detect-no-csrf-before-method-override": "error",
69    "security/detect-possible-timing-attacks": "warn",
70    "no-unsanitized/method": "error",
71    "no-unsanitized/property": "error"
72  }
73}
74```
75~
76## Fase 2: Pre-commit Hooks
77~
78De tweede verdedigingslinie. Draait automatisch voor elke commit en blokkeert gevaarlijke code voordat deze in de repository terechtkomt.
79~
80### Gitleaks: Secrets opvangen voordat ze Git bereiken
81~
82De meest voorkomende beveiligingsfout in codebases is het committen van secrets  -  API keys, databasewachtwoorden, tokens. Zodra een secret in de git-geschiedenis terechtkomt, is het extreem moeilijk om het volledig te verwijderen (zelfs met force pushes kunnen forks en caches het behouden).
83~
84```yaml
85# .pre-commit-config.yaml
86repos:
87  - repo: https://github.com/gitleaks/gitleaks
88    rev: v8.21.0
89    hooks:
90      - id: gitleaks
91~
92  - repo: https://github.com/semgrep/semgrep
93    rev: v1.90.0
94    hooks:
95      - id: semgrep
96        args: ['--config', 'auto']
97```
98~
99Installeren en activeren:
100~
101```bash
102pip install pre-commit
103pre-commit install
104```
105~
106Nu scant elke `git commit` automatisch op gelekte secrets en veelvoorkomende kwetsbaarheden. Als er iets wordt gevonden, wordt de commit geblokkeerd.
107~
108### Aangepaste Gitleaks-regels
109~
110U kunt aangepaste patronen toevoegen voor de secrets van uw organisatie:
111~
112```toml
113# .gitleaks.toml
114title = "Custom Gitleaks Config"
115~
116[[rules]]
117id = "internal-api-key"
118description = "Internal API key detected"
119regex = '''INTERNAL_KEY_[A-Za-z0-9]{32}'''
120tags = ["key", "internal"]
121```
122~
123## Fase 3: CI/CD Pipeline Security
124~
125Hier wordt het zware werk gedaan. Uw CI pipeline moet bij elk pull request meerdere beveiligingsscans uitvoeren.
126~
127### SAST (Static Application Security Testing)
128~
129SAST-tools analyseren broncode zonder deze uit te voeren en zoeken naar patronen die wijzen op kwetsbaarheden.
130~
131```yaml
132# .github/workflows/security.yml
133name: Security Scan
134on:
135  pull_request:
136    branches: [main]
137~
138jobs:
139  sast:
140    name: Static Analysis
141    runs-on: ubuntu-latest
142    steps:
143      - uses: actions/checkout@v4
144~
145      - name: Run Semgrep
146        uses: semgrep/semgrep-action@v1
147        with:
148          config: >-
149            p/owasp-top-ten
150            p/typescript
151            p/nodejs
152            p/react
153          generateSarif: true
154~
155      - name: Upload SARIF
156        uses: github/codeql-action/upload-sarif@v3
157        with:
158          sarif_file: semgrep.sarif
159```
160~
161De Semgrep-ruleset `p/owasp-top-ten` vangt de meest voorkomende kwetsbaarheden op: SQL injection, XSS, SSRF, path traversal, insecure deserialization en meer.
162~
163### SCA (Software Composition Analysis)
164~
165SCA scant uw dependencies op bekende kwetsbaarheden. Dit is cruciaal  -  meer dan 80% van de code in moderne applicaties komt uit open-source dependencies.
166~
167```yaml
168  dependency-scan:
169    name: Dependency Audit
170    runs-on: ubuntu-latest
171    steps:
172      - uses: actions/checkout@v4
173~
174      - name: Run Snyk
175        uses: snyk/actions/node@master
176        env:
177          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
178        with:
179          args: --severity-threshold=high
180~
181      - name: npm audit
182        run: npm audit --audit-level=high
183```
184~
185### Container Security met Trivy
186~
187Als u Docker images bouwt, is het scannen op kwetsbaarheden essentieel. **Trivy** is de populairste open-source container scanner.
188~
189```yaml
190  container-scan:
191    name: Container Security
192    runs-on: ubuntu-latest
193    steps:
194      - uses: actions/checkout@v4
195~
196      - name: Build image
197        run: docker build -t my-app:${{ github.sha }} .
198~
199      - name: Run Trivy
200        uses: aquasecurity/trivy-action@master
201        with:
202          image-ref: my-app:${{ github.sha }}
203          format: 'sarif'
204          output: 'trivy-results.sarif'
205          severity: 'CRITICAL,HIGH'
206          exit-code: '1'
207~
208      - name: Upload Trivy SARIF
209        uses: github/codeql-action/upload-sarif@v3
210        with:
211          sarif_file: trivy-results.sarif
212```
213~
214### SBOM-generatie
215~
216Een **Software Bill of Materials (SBOM)** is een volledig overzicht van elke component in uw applicatie. Dit wordt steeds vaker vereist door compliance-frameworks en overheidsregelgeving (de US Executive Order on Cybersecurity schrijft SBOM voor bij federale software).
217~
218```yaml
219  sbom:
220    name: Generate SBOM
221    runs-on: ubuntu-latest
222    steps:
223      - uses: actions/checkout@v4
224~
225      - name: Generate SBOM with Syft
226        uses: anchore/sbom-action@v0
227        with:
228          format: spdx-json
229          output-file: sbom.spdx.json
230~
231      - name: Upload SBOM
232        uses: actions/upload-artifact@v4
233        with:
234          name: sbom
235          path: sbom.spdx.json
236```
237~
238## Fase 4: Veilige Docker Images
239~
240Een productie Docker image moet het principe van least privilege volgen. Zo ziet een geharde Dockerfile eruit:
241~
242```dockerfile
243# Build stage
244FROM node:22-alpine AS builder
245WORKDIR /app
246COPY package.json package-lock.json ./
247RUN npm ci
248COPY . .
249RUN npm run build
250~
251# Production stage
252FROM node:22-alpine AS runner
253WORKDIR /app
254~
255# Install dumb-init before dropping root
256RUN apk add --no-cache dumb-init
257~
258# Don't run as root
259RUN addgroup -S app && adduser -S app -G app
260~
261# Copy only what's needed
262COPY --from=builder --chown=app:app /app/dist ./dist
263COPY --from=builder --chown=app:app /app/node_modules ./node_modules
264COPY --from=builder --chown=app:app /app/package.json ./
265~
266# Drop to non-root user
267USER app
268ENTRYPOINT ["dumb-init", "--"]
269~
270# Health check
271HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
272  CMD wget -qO- http://localhost:3000/health || exit 1
273~
274EXPOSE 3000
275CMD ["node", "dist/server.js"]
276```
277~
278Belangrijke praktijken:
279~
2801. **Gebruik multi-stage builds**: de builder-fase bevat dev-dependencies; de runner-fase bevat alleen productiecode
2812. **Draai niet als root**: maak een niet-root gebruiker aan en schakel over
2823. **Gebruik Alpine images**: kleiner aanvalsoppervlak (minder pakketten standaard geinstalleerd)
2834. **Pin image-versies**: `node:22-alpine` in plaats van `node:latest` om supply chain-aanvallen te voorkomen
2845. **Gebruik `npm ci`**: deterministische installaties vanuit het lock-bestand, niet `npm install`
285~
286## Fase 5: Secret Management
287~
288Hardgecodeerde secrets zijn de nummer een oorzaak van inbreuken bij door ontwikkelaars veroorzaakte incidenten.
289~
290### Wat u NIET moet doen
291~
292```typescript
293// NEVER do this
294const API_KEY = "sk-1234567890abcdef";
295const DB_PASSWORD = "supersecret123";
296~
297const client = new Client({
298  connectionString: `postgres://admin:${DB_PASSWORD}@db.example.com/prod`
299});
300```
301~
302### Wat u in plaats daarvan moet doen
303~
304```typescript
305// Use environment variables
306const client = new Client({
307  connectionString: process.env.DATABASE_URL
308});
309~
310// Or use a secret manager
311import { SecretManagerServiceClient } from '@google-cloud/secret-manager';
312~
313const client = new SecretManagerServiceClient();
314const [version] = await client.accessSecretVersion({
315  name: 'projects/my-project/secrets/db-password/versions/latest',
316});
317const dbPassword = version.payload?.data?.toString();
318```
319~
320### Secret Management Hierarchie
321~
322```mermaid
323graph TD
324    A[Secret Manager\nAWS Secrets Manager\nGCP Secret Manager\nHashiCorp Vault] --> B[Best: Rotated, audited, centralized]
325    C[Environment Variables\nInjected at deploy time] --> D[Good: Not in code, but static]
326    E[.env files\nWith .gitignore] --> F[Acceptable: Local development only]
327    G[Hard-coded in source] --> H[NEVER: Instant breach risk]
328~
329    style A fill:#d4edda
330    style C fill:#fff3cd
331    style E fill:#ffeeba
332    style G fill:#f8d7da
333```
334~
335## De OWASP Top 10: Een Beknopt Overzicht
336~
337Elke ontwikkelaar zou de OWASP Top 10 moeten kennen. Samengevat:
338~
339| # | Kwetsbaarheid | Wat het is | Preventie |
340|---|---------------|-----------|-----------|
341| 1 | **Broken Access Control** | Gebruikers die toegang krijgen tot bronnen waar ze geen toegang toe zouden moeten hebben | Standaard weigeren, serversijdig valideren |
342| 2 | **Cryptographic Failures** | Zwakke encryptie, plaintext data | Sterke algoritmen gebruiken (AES-256, bcrypt), overal TLS |
343| 3 | **Injection** | SQL, NoSQL, OS command injection | Geparametriseerde queries, invoervalidatie |
344| 4 | **Insecure Design** | Gebrekkige architectuur | Threat modeling, veilige ontwerppatronen |
345| 5 | **Security Misconfiguration** | Standaard inloggegevens, open cloud buckets | Geharde standaardwaarden, geautomatiseerde configuratie-audits |
346| 6 | **Vulnerable Components** | Bekende CVEs in dependencies | SCA scanning, regelmatige updates |
347| 7 | **Auth Failures** | Zwakke wachtwoorden, defecte sessies | MFA, rate limiting, veilig session management |
348| 8 | **Data Integrity Failures** | Ongetekende updates, onbetrouwbare CI/CD | Code signing, SBOM, pipeline-integriteit |
349| 9 | **Logging Failures** | Geen audit trail | Gestructureerd logging, alerting bij afwijkingen |
350| 10 | **SSRF** | Server-side request forgery | Allowlist voor uitgaande URLs, invoer valideren |
351~
352## Volledige GitHub Actions Security Workflow
353~
354Een volledige, productieklare workflow die alles hierboven combineert:
355~
356```yaml
357# .github/workflows/security.yml
358name: Security Pipeline
359on:
360  pull_request:
361    branches: [main]
362  push:
363    branches: [main]
364~
365permissions:
366  contents: read
367  security-events: write
368~
369jobs:
370  secrets-scan:
371    name: Secret Detection
372    runs-on: ubuntu-latest
373    steps:
374      - uses: actions/checkout@v4
375        with:
376          fetch-depth: 0
377      - uses: gitleaks/gitleaks-action@v2
378        env:
379          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
380~
381  sast:
382    name: Static Analysis (SAST)
383    runs-on: ubuntu-latest
384    steps:
385      - uses: actions/checkout@v4
386      - uses: semgrep/semgrep-action@v1
387        with:
388          config: p/owasp-top-ten p/typescript p/nodejs
389~
390  dependency-audit:
391    name: Dependency Scan (SCA)
392    runs-on: ubuntu-latest
393    steps:
394      - uses: actions/checkout@v4
395      - uses: actions/setup-node@v4
396        with:
397          node-version: 22
398      - run: npm ci
399      - run: npm audit --audit-level=high
400      - uses: snyk/actions/node@master
401        env:
402          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
403        with:
404          args: --severity-threshold=high
405        continue-on-error: true
406~
407  container-scan:
408    name: Container Scan
409    runs-on: ubuntu-latest
410    needs: [sast, dependency-audit]
411    steps:
412      - uses: actions/checkout@v4
413      - run: docker build -t app:${{ github.sha }} .
414      - uses: aquasecurity/trivy-action@master
415        with:
416          image-ref: app:${{ github.sha }}
417          severity: CRITICAL,HIGH
418          exit-code: '1'
419~
420  sbom:
421    name: SBOM Generation
422    runs-on: ubuntu-latest
423    needs: [container-scan]
424    steps:
425      - uses: actions/checkout@v4
426      - uses: anchore/sbom-action@v0
427        with:
428          format: spdx-json
429          output-file: sbom.spdx.json
430```
431~
432```mermaid
433graph TD
434    PR[Pull Request] --> S1[Secret Detection]
435    PR --> S2[SAST - Semgrep]
436    PR --> S3[SCA - Snyk + npm audit]
437    S2 --> S4[Container Scan - Trivy]
438    S3 --> S4
439    S4 --> S5[SBOM Generation]
440    S5 --> Deploy[Deploy]
441~
442    S1 -.- F1[Block if secrets found]
443    S2 -.- F2[Block on critical vulns]
444    S3 -.- F3[Block on high severity]
445    S4 -.- F4[Block on critical CVEs]
446```
447~
448## Metrics om bij te houden
449~
450Hoe weet u of uw DevSecOps-programma werkt? Houd deze metrics bij:
451~
452- **Mean Time to Remediate (MTTR)**: hoe snel u kwetsbaarheden oplost na detectie
453- **Vulnerability Escape Rate**: percentage kwetsbaarheden dat de productie bereikt
454- **False Positive Rate**: te veel false positives leiden tot alarmmoeheid en genegeerde waarschuwingen
455- **Dependency Freshness**: gemiddelde leeftijd van uw dependencies (ouder = grotere kans op bekende CVEs)
456- **SBOM Coverage**: percentage projecten met actuele SBOMs
457~
458## Aan de slag: Een Praktisch Stappenplan
459~
460Probeer niet alles tegelijk te implementeren. Een gefaseerde aanpak werkt beter:
461~
462```mermaid
463flowchart TD
464    A[Week 1-2: Foundations] --> B[Week 3-4: CI/CD Integration]
465    B --> C[Month 2: Container Security]
466    C --> D[Month 3+: Advanced]
467~
468    A --> A1[Add Gitleaks pre-commit hooks]
469    A --> A2[Enable npm audit in CI]
470    A --> A3[Add .gitignore for .env files]
471~
472    B --> B1[Add Semgrep to GitHub Actions]
473    B --> B2[Add Snyk dependency scanning]
474    B --> B3[Set up SARIF upload to GitHub]
475~
476    C --> C1[Add Trivy container scanning]
477    C --> C2[Harden Dockerfiles]
478    C --> C3[Generate SBOMs]
479~
480    D --> D1[Secret manager integration]
481    D --> D2[Runtime protection - DAST]
482    D --> D3[Policy as code - OPA]
483```
484~
485## Conclusie
486~
487DevSecOps gaat niet over het toevoegen van meer tools aan uw pipeline  -  het gaat over het maken van beveiliging tot een natuurlijk onderdeel van hoe u software bouwt. Het doel is niet om elke PR te blokkeren met beveiligingswaarschuwingen, maar om ontwikkelaars snel feedback te geven zodat ze problemen kunnen oplossen terwijl de code nog vers in het geheugen zit.
488~
489Begin met de basis: pre-commit hooks voor secrets, dependency scanning in CI en container scanning voor Docker images. Vervolgens itereert u op basis van wat uw team nodig heeft.
490~
491Beveiliging is geen feature die u eenmalig levert. Het is een praktijk die u in elke commit inbouwt.
492~
493> **DevSecOps Starter Checklist:**
494>
495> - [x] Gitleaks pre-commit hooks geinstalleerd
496> - [x] .env en secret-bestanden in .gitignore
497> - [x] Semgrep SAST in CI pipeline
498> - [x] Snyk of npm audit voor dependency scanning
499> - [x] Trivy voor container image scanning
500> - [x] Niet-root gebruiker in Dockerfiles
501> - [x] Secrets in omgevingsvariabelen of secret manager
502> - [x] SBOM-generatie bij elke release
503> - [x] OWASP Top 10 bewustzijn in het hele team
504~