1~
2פגיעות שמתגלה בזמן כתיבת הקוד עולה למפתח דקות לתיקון. אותה פגיעות שנתפסת בפרודקשן עולה ספרינט שלם. ואם תוקף מוצא אותה ראשון, היא עולה מיליונים. זהו הטיעון המרכזי מאחורי **shift-left security**  -  הזזת בדיקות האבטחה מוקדם ככל האפשר במחזור חיי הפיתוח.
3~
4DevSecOps לוקח את הרעיון הזה והופך אותו לפרקטיקה: אבטחה אינה שלב נפרד בסוף אלא תהליך מתמשך השזור בכל שלב בפיתוח, מהשורה הראשונה של הקוד ועד לפריסה לפרודקשן.
5~
6## המחיר של אבטחה מאוחרת
7~
8דוח Cost of a Data Breach של IBM הראה באופן עקבי שהעלות של תיקון בעיות אבטחה גדלה באופן מעריכי ככל שהן נתפסות מאוחר יותר:
9~
10| שלב | עלות תיקון | זמן תיקון |
11|-------|------------|-------------|
12| **IDE / פיתוח מקומי** | דקות | שניות עד דקות |
13| **Code Review / PR** | שעות | דקות עד שעות |
14| **CI/CD Pipeline** | ימים | שעות עד ימים |
15| **Staging / QA** | שבועות | ימים |
16| **פרודקשן** | חודשים | שבועות עד חודשים |
17| **לאחר פריצה** | מיליונים ($) | חודשים עד שנים |
18~
19המסקנה ברורה: כל שלב שבו דוחפים את האבטחה מוקדם יותר חוסך סדר גודל בעלות ובזמן.
20~
21## ה-DevSecOps Pipeline
22~
23pipeline בוגר של DevSecOps משלב בדיקות אבטחה בכל שלב:
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~
43בואו נפרק כל שלב עם כלים קונקרטיים וקונפיגורציה.
44~
45## שלב 1: אבטחה ב-IDE
46~
47לולאת המשוב המהירה ביותר. תפסו פגיעויות עוד לפני שאתם שומרים את הקובץ.
48~
49### כלים מומלצים
50~
51- **Semgrep**: ניתוח סטטי קל משקל עם כללים קהילתיים לפגיעויות OWASP
52- **Snyk IDE Extension**: סריקת פגיעויות של תלויות בזמן אמת
53- **GitLens + GitLeaks**: גילוי סודות בעורך שלכם
54- **ESLint Security Plugins**: `eslint-plugin-security` עבור Node.js, `eslint-plugin-no-unsanitized` עבור DOM XSS
55~
56### דוגמה: קונפיגורציית ESLint Security
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## שלב 2: Pre-commit Hooks
77~
78קו ההגנה השני. רץ אוטומטית לפני כל commit, וחוסם קוד מסוכן מלהיכנס למאגר.
79~
80### Gitleaks: תפסו סודות לפני שהם מגיעים ל-Git
81~
82טעות האבטחה הנפוצה ביותר בבסיסי קוד היא commit של סודות  -  מפתחות API, סיסמאות של מסדי נתונים, tokens. ברגע שסוד מגיע להיסטוריה של git, קשה מאוד להסיר אותו לחלוטין (אפילו עם force push, forks ו-caches עשויים לשמר אותו).
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~
99התקנה והפעלה:
100~
101```bash
102pip install pre-commit
103pre-commit install
104```
105~
106כעת כל `git commit` סורק אוטומטית סודות דלופים ופגיעויות נפוצות. אם נמצא משהו, ה-commit נחסם.
107~
108### כללי Gitleaks מותאמים אישית
109~
110אתם יכולים להוסיף דפוסים מותאמים אישית עבור הסודות של הארגון שלכם:
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## שלב 3: אבטחת CI/CD Pipeline
124~
125כאן מתבצעת העבודה הכבדה. ה-pipeline של ה-CI שלכם צריך להריץ מספר סריקות אבטחה על כל pull request.
126~
127### SAST (Static Application Security Testing)
128~
129כלי SAST מנתחים קוד מקור מבלי להריץ אותו, ומחפשים דפוסים המצביעים על פגיעויות.
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~
161ערכת הכללים `p/owasp-top-ten` של Semgrep תופסת את הפגיעויות הנפוצות ביותר: SQL injection, XSS, SSRF, path traversal, deserialization לא בטוח ועוד.
162~
163### SCA (Software Composition Analysis)
164~
165SCA סורק את התלויות שלכם עבור פגיעויות ידועות. זה קריטי  -  מעל 80% מקוד אפליקציות מודרניות מגיע מתלויות קוד פתוח.
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### אבטחת קונטיינרים עם Trivy
186~
187אם אתם בונים Docker images, סריקתם עבור פגיעויות היא חיונית. **Trivy** הוא סורק הקונטיינרים הפופולרי ביותר בקוד פתוח.
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
215~
216**Software Bill of Materials (SBOM)** הוא מלאי מלא של כל רכיב באפליקציה שלכם. נדרש יותר ויותר על ידי מסגרות ציות ותקנות ממשלתיות (ה-Executive Order האמריקאי על Cybersecurity מחייב SBOM עבור תוכנה פדרלית).
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## שלב 4: Docker Images מאובטחים
239~
240Docker image של פרודקשן צריך לעקוב אחר עקרון ההרשאה המינימלית. כך נראה Dockerfile מחוזק:
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~
278שיטות מפתח:
279~
2801. **השתמשו ב-multi-stage builds**: שלב ה-builder מכיל תלויות פיתוח; שלב ה-runner מכיל רק קוד פרודקשן
2812. **אל תריצו כ-root**: צרו משתמש שאינו root ועברו אליו
2823. **השתמשו ב-Alpine images**: משטח תקיפה קטן יותר (פחות חבילות מותקנות כברירת מחדל)
2834. **קבעו גרסאות image**: `node:22-alpine` במקום `node:latest` כדי להימנע מהתקפות supply chain
2845. **השתמשו ב-`npm ci`**: התקנות דטרמיניסטיות מקובץ lock, ולא `npm install`
285~
286## שלב 5: ניהול סודות
287~
288סודות קשיחים בקוד הם הסיבה מספר אחת לפריצות באירועים שנגרמים על ידי מפתחים.
289~
290### מה לא לעשות
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### מה לעשות במקום זאת
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### היררכיית ניהול סודות
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## OWASP Top 10: מדריך מהיר
336~
337כל מפתח צריך להכיר את OWASP Top 10. גרסה מתומצתת:
338~
339| # | פגיעות | מה זה | מניעה |
340|---|--------------|-----------|------------|
341| 1 | **Broken Access Control** | משתמשים ניגשים למשאבים שאסורים להם | דחייה כברירת מחדל, אימות בצד השרת |
342| 2 | **Cryptographic Failures** | הצפנה חלשה, נתונים בטקסט גלוי | השתמשו באלגוריתמים חזקים (AES-256, bcrypt), TLS בכל מקום |
343| 3 | **Injection** | SQL, NoSQL, OS command injection | Parameterized queries, אימות קלט |
344| 4 | **Insecure Design** | ארכיטקטורה פגומה | Threat modeling, דפוסי עיצוב מאובטחים |
345| 5 | **Security Misconfiguration** | אישורי ברירת מחדל, buckets פתוחים בענן | ברירות מחדל מחוזקות, ביקורות קונפיגורציה אוטומטיות |
346| 6 | **Vulnerable Components** | CVEs ידועים בתלויות | סריקת SCA, עדכונים סדירים |
347| 7 | **Auth Failures** | סיסמאות חלשות, sessions שבורים | MFA, הגבלת קצב, ניהול sessions מאובטח |
348| 8 | **Data Integrity Failures** | עדכונים לא חתומים, CI/CD לא אמין | חתימת קוד, SBOM, שלמות pipeline |
349| 9 | **Logging Failures** | אין audit trail | לוגים מובנים, התרעות על אנומליות |
350| 10 | **SSRF** | Server-side request forgery | Allowlist של URLs יוצאים, אימות קלטים |
351~
352## Workflow מלא של GitHub Actions Security
353~
354workflow מלא ומוכן לפרודקשן שמשלב את כל מה שלמעלה:
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## מטריקות למעקב
449~
450איך יודעים שתוכנית ה-DevSecOps שלכם עובדת? עקבו אחר המטריקות האלה:
451~
452- **Mean time to remediate (MTTR)**: כמה מהר אתם מתקנים פגיעויות לאחר גילוי
453- **Vulnerability escape rate**: אחוז הפגיעויות שמגיעות לפרודקשן
454- **False positive rate**: יותר מדי false positives גורמים לעייפות התרעות ולהתעלמות מאזהרות
455- **Dependency freshness**: גיל ממוצע של התלויות שלכם (ישנות יותר = סיכוי גבוה יותר ל-CVEs ידועים)
456- **SBOM coverage**: אחוז הפרויקטים עם SBOMs עדכניים
457~
458## תחילת העבודה: מפת דרכים מעשית
459~
460אל תנסו ליישם הכל בבת אחת. גישה שלבית עובדת טוב יותר:
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## סיכום
486~
487DevSecOps אינו עוסק בהוספת עוד כלים ל-pipeline שלכם  -  הוא עוסק בהפיכת האבטחה לחלק טבעי מהאופן שבו אתם בונים תוכנה. המטרה אינה לחסום כל PR עם אזהרות אבטחה אלא לתת למפתחים משוב מהיר כדי שיוכלו לתקן בעיות בזמן שהקוד עדיין טרי במוחם.
488~
489התחילו מהבסיס: pre-commit hooks לסודות, סריקת תלויות ב-CI וסריקת קונטיינרים עבור Docker images. לאחר מכן בצעו איטרציות על בסיס צורכי הצוות שלכם.
490~
491אבטחה אינה פיצ'ר שמוציאים לאור פעם אחת. זו פרקטיקה שבונים לתוך כל commit.
492~
493> **רשימת מטלות התחלתית ל-DevSecOps:**
494>
495> - [x] Gitleaks pre-commit hooks מותקנים
496> - [x] קבצי .env וקבצי סודות ב-.gitignore
497> - [x] Semgrep SAST ב-CI pipeline
498> - [x] Snyk או npm audit לסריקת תלויות
499> - [x] Trivy לסריקת container images
500> - [x] משתמש שאינו root ב-Dockerfiles
501> - [x] סודות במשתני סביבה או ב-secret manager
502> - [x] יצירת SBOM בכל release
503> - [x] מודעות ל-OWASP Top 10 לרוחב הצוות
504~