אימות תקינות קבצים בלינוקס באמצעות sha256sum
למדו לאמת הורדות בעזרת הפקודה sha256sum והדגל -c. המדריך מציג תרגול מעשי שבו משבשים קובץ בכוונה כדי לראות את הודעת השגיאה FAILED ולהבין מה באמת מוכיח ה-checksum.
אימות הורדה באמצעות checksum בתוך שתי דקות
כדי לאמת הורדה באמצעות checksum, בצעו hashing לקובץ שקיבלתם ותנו לכלי להשוות את ה-hash לזה שפרסם המפיץ. sha256sum מבצע את שני חלקי המשימה: בפני עצמו הוא מציג digest, ועם הדגל -c הוא קורא רשימת digests ומדווח אילו קבצים תואמים. מדריך זה מריץ את התהליך המלא על קובץ שתיצרו, ולאחר מכן משבש את הקובץ בכוונה כדי שתראו את הכשל מתרחש במקום רק לקרוא עליו.
זכרו משפט אחד לאורך כל הדרך. checksum אומר לכם האם הבתים שבידיכם הם הבתים שיצרו את ה-digest, אך הוא לא אומר דבר על מי שיצר אותם. השאלה השנייה דורשת חתימה ומפתח שאתם סומכים עליו. החלק האחרון של מדריך זה מראה בדיוק היכן עובר הגבול בין השניים.
יצירת קובץ לתרגול
עבדו בתוך ספריית עבודה זמנית כדי להבטיח ששום דבר כאן לא ישפיע על שאר המערכת. כל הפקודות להלן מגיעות מתוך GNU coreutils, סט הפקודות הבסיסי הקיים בכל שרת Ubuntu או Debian, כך שאין צורך בהתקנה של דבר.
mkdir -p ~/checksum-demo
cd ~/checksum-demo
printf 'the payload of a totally ordinary download\n' > payload.txt
sha256sum payload.txtתקבלו שורה אחת: 64 תווים הקסדצימליים, שני רווחים, ולאחריהם שם הקובץ. 64 התווים הללו הם ה-digest של הקובץ. הריצו את הפקודה שוב והשורה תהיה זהה, כיוון שפעולת ה-hashing היא דטרמיניסטית: אותו קלט תמיד מניב את אותו פלט. שנו תו אחד בקובץ והריצו את הפקודה שוב; ה-digest לא ישתנה רק במעט. הוא ייראה שונה לחלוטין, כיוון ששינוי של ביט אחד בקלט הופך בערך מחצית מביטי הפלט. תכונה זו היא שהופכת מחרוזת של 64 תווים לתחליף שמיש עבור קובץ image של 4 GB.
שמירת קובץ SHA256SUMS ובדיקתו
ערך גיבוב (digest) שמופיע על המסך אינו מועיל לאחר יום. שמרו אותו לקובץ, בפורמט שבו sha256sum עצמו כותב, כדי שהכלי יוכל לקרוא אותו בחזרה במועד מאוחר יותר.
sha256sum payload.txt > SHA256SUMS
cat SHA256SUMS
sha256sum -c SHA256SUMSsha256sum -c קורא כל שורה ברשימה, מחשב את ה-hash של הקובץ המצוין באותה שורה, ומשווה בין שני ערכי הגיבוב. הרצה תקינה מדפיסה שורה אחת עבור כל קובץ:
payload.txt: OKבדקו גם את סטטוס היציאה (exit status), כיוון שסקריפט קורא אותו ולעולם אינו קורא את הטקסט. echo $? מדפיס 0 לאחר הרצה נקייה. השם SHA256SUMS הוא מוסכמה ולא כלל מחייב, אך הפצות ורוב דפי השחרורים משתמשים בו, לכן השתמשו בו גם אתם כדי שהאדם הבא ידע מה מכיל הקובץ מבלי לפתוח אותו.
שינוי בייט אחד וצפייה בכישלון הבדיקה
כעת נשבש את הקובץ בכוונה. הפעולה הבאה כותבת בייט בודד ב-offset 5 ומשאירה את שאר הקובץ ללא שינוי, כך שהקובץ שומר על אורכו ועל שמו.
printf 'X' | dd of=payload.txt bs=1 seek=5 conv=notrunc status=none
cat payload.txt
sha256sum -c SHA256SUMSconv=notrunc הוא ה-flag הקריטי כאן: בלעדיו, dd מקצר את הקובץ בנקודה שבה הכתיבה נעצרת, ואז הייתם בוחנים סוג נזק מובן מאליו הרבה יותר. הבדיקה כעת מדפיסה:
payload.txt: FAILED
sha256sum: WARNING: 1 computed checksum did NOT matchecho $? מדפיס 1. המשמעות של FAILED היא שהקובץ נקרא, אך ה-digest שלו לא תאם לזה שברשימה. החזירו את הבייטים המקוריים וודאו שהבדיקה חוזרת ל-OK:
printf 'the payload of a totally ordinary download\n' > payload.txt
sha256sum -c SHA256SUMSזהו כל ההרגל. הבדל של בייט אחד, בכל מקום בקובץ, מפיק FAILED. הורדה שנקטעה בגלל חיבור שנפל, שרת mirror שמגיש גרסה מאתמול, proxy שכתב מחדש את הקובץ במהלך המעבר, או דיסק שהחזיר bad block: כולם מובילים לאותה שורת פלט.
כאשר הרשימה מציינת קובץ שלא הורדת
קובץ SHA256SUMS אמיתי מהפצה מפרט כל image שנמצא בתיקיית ההורדות שלה, ואתה הורדת רק אחד מהם. הוא לא תמיד כולל כל image שהפרויקט מפיץ: נכון לנובמבר 2026, Ubuntu שומרת את ה-ISO של גרסאות amd64 ו-arm64 עבור 24.04 ברשימות נפרדות בשרתים נפרדים, בעוד שהרשימה היומית של Noble כוללת את ה-desktop image של amd64 ושל arm64 זו לצד זו. שחזר מצב זה כאן.
printf 'a second file\n' > notes.txt
sha256sum payload.txt notes.txt > SHA256SUMS.all
rm notes.txt
sha256sum -c SHA256SUMS.allpayload.txt: OK
sha256sum: notes.txt: No such file or directory
notes.txt: FAILED open or read
sha256sum: WARNING: 1 listed file could not be readFAILED open or read הוא כשל שונה מ-FAILED, וערבוב ביניהם מבזבז זמן. FAILED אומר שהבתים אינם נכונים. FAILED open or read אומר ש-sha256sum לא הצליח לפתוח את הקובץ או לא הצליח לסיים את קריאתו, ולכן לא בוצעה השוואת digest. בהורדה אמיתית, הסיבה הנפוצה היא תיקיית העבודה, כיוון ששמות יחסיים ברשימה מפורשים לפי המיקום שבו מריצים את הפקודה. עברו לתיקייה המכילה את הקובץ והריצו שוב. כדי לבדוק רק את מה שיש לכם בפועל, בקשו זאת:
sha256sum --ignore-missing -c SHA256SUMS.allזה מדפיס את payload.txt: OK ומסיים עם קוד יציאה 0. אם אף אחד מהשמות ברשימה אינו קיים, --ignore-missing לא יצליח בשקט על אפס קבצים. הוא ידווח ש-no file was verified ויסיים עם קוד יציאה שאינו אפס, וזהו ההתנהגות הרצויה, כיוון שבדיקה שעברה בהצלחה מבלי לבדוק דבר היא כשל שלעולם לא תבחין בו.
הדבקת תקציר שפורסם ללא בדיקה ויזואלית
השוואה ויזואלית של 64 תווים הקסדצימליים היא המקום שבו הרגל זה נכשל. אנשים בודקים את ארבעת התווים הראשונים ואת ארבעת האחרונים ומכריזים על התאמה, וזו בדיוק ההשוואה שתוקף נחוש בונה עליה. תנו לכלי לבצע את ההשוואה במקומכם. הגדירו את EXPECTED לתקציר שהעתקתם מהמפרסם, באמצעות EXPECTED= ואחריו הערך שהודבק, ולאחר מכן בנו את השורה הבודדת ש־-c מצפה לה:
printf '%s %s\n' "$EXPECTED" payload.txt > payload.sha256
cat payload.sha256
sha256sum -c payload.sha256שני רווחים מפרידים בין התקציר לבין שם הקובץ, וזו הסיבה שמחרוזת הפורמט מכילה שניים כאלו. זהו המבנה ש־sha256sum כותב והמבנה ש־-c מנתח. קובץ המכיל תקציר בלבד אינו נחשב לשורת checksum, ולכן הבדיקה דוחה את הקובץ כולו עם no properly formatted checksum lines found במקום לנסות לנחש לאיזה קובץ התכוונתם. פרויקטים מסוימים מפרסמים את הפורמט בסגנון BSD, כלומר SHA256 (payload.txt) = ואחריו התקציר. חבילת GNU coreutils כותבת פורמט זה עם sha256sum --tag payload.txt וקוראת אותו חזרה עם -c, כך ששני המבנים תקינים לשמירה.
כאשר בדיקה מתנהגת בצורה מוזרה, בדקו את הרשימה עצמה עם cat -A SHA256SUMS, שמסמן את סוף כל שורה עם $ ומציג תווים שלא ניתן לראות בדרך אחרת. שורה שמסתיימת ב־^M$ מכילה תו carriage return שנאסף מעורך טקסט של Windows. הכלי sha256sum של GNU מתעלם מתו סיום זה ועדיין מדפיס OK, כך שרשימת CRLF אינה הגורם לכשל בבדיקה שלכם, אם כי כלים שאינם חלק מ-coreutils סלחניים פחות כלפיו. נרמלו את העותק שאתם שומרים באמצעות tr -d '\r' < SHA256SUMS > SHA256SUMS.clean.
מה מוכיח checksum, ומה הוא אינו מוכיח?
checksum מוכיח דבר אחד בלבד: הבתים שנמצאים על הדיסק שלך הם אותם הבתים שיצרו את ה-digest שפורסם. זה מכסה באופן מלא נזק מקרי. זה מכסה גם תוקף רשלן שהחליף את הקובץ בשרת מראה (mirror) להורדות, אך לא הייתה לו גישה לדף שפרסם את ה-digest.
הוא אינו מוכיח דבר בנוגע לזהות היוצר. digest הוא עובדה על בתים, לא עובדה על אנשים. אם אותו דף מגיש גם את הקובץ וגם את ה-digest, הרי שמי שיכול לשנות את האחד יכול לשנות גם את השני, ושורת ה-OK שלך מעידה רק על כך ששרת המראה מסכים עם עצמו. לכן, זהו הכלל שהופך את השימוש ב-checksum לכדאי: קחו את ה-digest ממקור שונה מזה שממנו הורדתם את הקובץ. למשל, הדומיין הרשמי של הפרויקט ב-TLS (transport layer security), בעוד הקובץ הגיע משרת מראה או מ-torrent. כעת, על התוקף לשלוט בשני מקומות במקום באחד. ה-checksum גם אינו אומר דבר על מה שהבתים המאומתים יעשו ברגע שתריצו אותם; זו שאלה נפרדת שכדאי לשאול על כל דבר שמורץ בשמכם, החל מסקריפט התקנה ועד תוסף dsh שרץ עם ההרשאות של ה-agent שלכם.
גם לאלגוריתם יש חשיבות. ל-SHA-256 (secure hash algorithm, 256-bit output) אין התנגשויות (collisions) ידועות נכון לאוקטובר 2026, וזו הסיבה שמפרסמים משתמשים בו. MD5 (message digest 5) ו-SHA-1 אינם עומדים במבחן המציאות: ניתן לייצר שני קבצים שונים בעלי אותו digest מסוג MD5 מאז 2004, והתנגשות SHA-1 מסוג chosen-prefix פורסמה ב-2020. קובץ MD5SUMS עדיין יזהה הורדה קטועה, כיוון ששחיתות נתונים אקראית אינה התנגשות מכוונת. הוא אינו יכול לעצור מישהו שמנסה להטעות אתכם. כאשר פרויקט מפרסם את שניהם, השתמשו בשורת ה-SHA-256.
היכן שחתימות נכנסות לתמונה
חתימה סוגרת את הפער שמותיר אחריו ה-digest. המפיץ חותם על קובץ ה-digest באמצעות מפתח פרטי, ואתם מאמתים זאת באמצעות המפתח הציבורי שלו: gpg --verify SHA256SUMS.asc SHA256SUMS. אם האימות עובר, הרי שרשימת ה-digests הגיעה ממי שמחזיק במפתח זה. לאחר מכן, sha256sum -c SHA256SUMS מקשר בין הקובץ שעל הדיסק שלכם לבין הרשימה, ושרשרת האמון נמתחת מהמפתח ועד לרמת הבתים הבודדים.
נקודת התורפה עוברת למפתח עצמו. הורדת המפתח מאותו דף שסיפק את הקובץ מעניקה לתוקף את שני החלקים גם יחד. GnuPG מציגה זאת בכנות, ואימות ראשוני מדפיס Good signature יחד עם WARNING: This key is not certified with a trusted signature!. המשמעות של Good signature היא שהמתמטיקה תקינה. אין זה אומר שהמפתח שייך בהכרח לפרויקט שאליו התכוונתם. השיגו את ה-fingerprint ממקור שני, כגון תיעוד הפרויקט בדומיין אחר או חבילת הפצה שכבר כוללת את המפתח, והשוו את ה-fingerprint המלא במקום להסתפק בשמונה התווים האחרונים. זוהי אותה רמת זהירות הנדרשת ממפתח SSH פרטי, מאותה סיבה בדיוק: המפתח הוא החלטת האמון, וכל מה שבא אחריו יורש אותה.
תהליכי בנייה הדירים (Reproducible builds) מקדמים את הרעיון צעד אחד קדימה. digest מפורסם עדיין קושר אתכם לקובץ בינארי שמכונה אחת בנתה. כאשר תהליך הבנייה של פרויקט הוא הדיר, כל אחד יכול לקמפל את אותו קוד מקור ולקבל פלט זהה ברמת הבייט, כך שבוני תוכנה עצמאיים יכולים לאשר את ה-digest המפורסם במקום שתצטרכו להסתמך על מילתו של שרת בודד. חשיבות הדבר עולה מדי שנה, ככל שיותר קוד מגיע דרך צינורות אוטומטיים וטלאים שנכתבו על ידי מכונה. ההחלטה מה לקבל לתוך תהליך הבנייה היא שאלה של מדיניות, ו-מדיניות קוד פתוח עבור קוד בסיוע בינה מלאכותית מטפלת באותה שרשרת אספקה מהצד השני.
מנהל החבילות שלך כבר עושה זאת עבורך
ב-Debian וב-Ubuntu, apt מריץ את השרשרת הזו בכל התקנה ללא צורך בבקשה מפורשת. אינדקס החבילות נושא digest מסוג SHA-256 עבור כל קובץ .deb. הקובץ Release נושא את ה-digests של קובצי אינדקס אלו, ו-InRelease נושא חתימה על Release, שנבדקת מול המפתח המצוין באפשרות Signed-By של אותו מאגר: מחזיק מפתחות (keyring) שחבילה התקינה תחת /usr/share/keyrings, קובץ מפתח שהצבת ב-/etc/apt/keyrings, או מפתח שמוטמע בתוך הקובץ .sources עצמו. כאשר השרשרת נשברת, apt מדווח על כך, אם כי הניסוח המדויק תלוי בגרסת ה-APT ובמנגנון האימות שמאחוריה. APT שמאמת באמצעות gpgv מדפיס את The following signatures couldn't be verified because the public key is not available: ואחריו את NO_PUBKEY ואת מזהה המפתח כאשר חסר מפתח של מאגר צד-שלישי. APT חדש יותר שמאמת באמצעות sqv של Sequoia מדווח על The signatures couldn't be verified because no keyring is specified כאשר הוא לא מוצא מחזיק מפתחות שמיש, ובמקרים אחרים מעביר הלאה את השגיאה של sqv לאחר Sub-process ... returned an error code. הודעה שונה, Hash Sum mismatch, אומרת שהאינדקס שהורדת אינו תואם ל-Release החתום, מה שבדרך כלל אומר ששרת proxy עם מטמון סיפק קובץ מיושן או שתפסת mirror באמצע סנכרון.
זהו הסטנדרט שיש למדוד לפיו כאשר דף הבית של פרויקט מורה לך להעביר (pipe) סקריפט מ-curl ישירות לתוך shell. שום דבר לא מאמת את הבתים ואתה לעולם לא רואה אותם. השרת יכול גם להחזיר דבר אחד לסקריפט ודבר אחר לדפדפן, ולא יהיה לך עותק לבדיקה לאחר מכן. הורד לקובץ בעזרת curl -fsSL <url> -o install.sh, בצע לו hash, קרא אותו בעזרת less, ורק אז הרץ אותו. ההרגל הזה עולה כעשרים שניות, וזהו אותו הרגל שכדאי להתחיל בו ב-שרת VPS חדש לגמרי בעשר הדקות הראשונות שלו, לפני שמותקן דבר מה נוסף על המכונה.
שמירה על רשימת חתימות (digests) עבור התקנות ידניות
חבילות המותקנות באמצעות apt מנוהלות על ידי המערכת. קובץ בינארי שהעתקת לתוך /usr/local/bin אינו מנוהל, ושום רכיב במערכת אינו מנטר אותו. רשימת חתימות הופכת קבצים אלו לניתנים לבדיקה לפי דרישה:
printf 'a second file\n' > notes.txt
sha256sum *.txt > inventory.sha256
sha256sum -c --quiet inventory.sha256הפקודה --quiet משמיטה את שורות ה-OK, כך שהיא אינה מדפיסה דבר כאשר כל הקבצים תואמים. כאשר קבצים אינם תואמים, היא עדיין מדפיסה שורת FAILED עבור כל קובץ חריג ומוסיפה סיכום אזהרה ל-standard error; לכן, שתיקה היא סימן להצלחה, ו-echo $? מאשר זאת באמצעות 0. זהו הפורמט המתאים לשימוש במשימות מתוזמנות. --status מרחיקה לכת עוד יותר ואינה מדפיסה דבר, ומותירה אותך רק עם ה-exit status. הפנה את אותו דפוס לקבצים אמיתיים באמצעות sha256sum /usr/local/bin/* > ~/local-bin.sha256 ותקבל בסיס להשוואה (baseline). נתיבים נשמרים ברשימה בדיוק כפי שהקלדת אותם, לכן שימוש בנתיבים מוחלטים (absolute paths) מאפשר לבצע את הבדיקה מכל ספרייה.
היה מודע לערכו של בסיס השוואה זה. הוא מזהה קובץ שהשתנה. הוא אינו מזהה תוקף שכבר מחזיק בהרשאות root, כיוון שתוקף כזה יכול לשכתב את inventory.sha256 באותה קלות שבה שיכתב את הקובץ הבינארי. שמור את הרשימה מחוץ למכונה אם ברצונך שהיא תהיה בעלת משמעות; זהו חלק מהשאלה הרחבה יותר של כמה מה-VPS אתה באמת מבטח ומי עוד יכול לגשת לדיסק שמתחתיו.
FAQ
האם checksum תואם מעיד על כך שההורדה בטוחה?
לא. המשמעות היא שהבתים שבידיך תואמים לערך ה-digest מולו ביצעת את הבדיקה. אם תוקף שולט בדף שפרסם את ה-digest, הוא יפרסם את ה-digest של הקובץ שלו, והבדיקה שלך תציג OK. התאמה היא טענה לעקביות בלבד. טענה לבטיחות דורשת חתימה מאומתת מול מפתח שהושג ממקור אחר; רק אז ה-digest יורש את רמת האמינות הזו.
מדוע sha256sum -c מדפיס FAILED open or read?
מכיוון שלא ניתן היה לפתוח או לקרוא את הקובץ, ולכן לא בוצעה השוואת digest. כאשר הקובץ חסר, שורה נפרדת המופיעה ממש מעל תציין No such file or directory עם שם הקובץ שחיפש. שמות בקובץ SHA256SUMS שאינם מתחילים ב-/ נפתרים מול הספרייה שבה מריצים את הפקודה; לכן, יש לעבור לספרייה המכילה את ההורדה ולהריץ את הפקודה שנית. אם הרשימה כוללת גם קבצים שלא הורדו, יש להוסיף --ignore-missing. הודעת FAILED פשוטה ללא open or read מצביעה על מצב הפוך: הקובץ נקרא, אך ה-digest שלו לא תאם.
האם MD5 מספיק טוב לאימות הורדה?
עבור נזק מקרי, כן. הסיכוי שהעברה קטועה או בלוק דיסק פגום ייצרו במקרה digest של MD5 תואם הוא אפסי. מול תוקף, התשובה היא לא. ניתן לייצר שני קבצים שונים בעלי אותו digest של MD5 מאז שנת 2004, ו-SHA-1 נפרץ באמצעות התקפת chosen-prefix collision בשנת 2020. השתמשו בשורת SHA-256 כאשר פרויקט מפרסם את שניהם, והתייחסו לפרויקט המציע MD5 בלבד כסימן לתהליך שחרור מיושן.
מה ההבדל בין sha256sum -c לבין gpg --verify?
sha256sum -c מוכיח שקובץ תואם ל-digest. gpg --verify מוכיח שקובץ ה-digest נחתם על ידי בעל מפתח פרטי מסוים. הם עונים על שאלות שונות, לכן יש להריץ את שניהם כאשר פרויקט מציע את שניהם. החתימה הופכת את רשימת ה-digest למהימנה, ורשימת ה-digest הופכת את הקובץ שהורד למהימן.
כיצד בודקים קובץ מול digest שמופיע בדף אינטרנט?
אל תשוו את התווים בעין. שמרו את ה-digest ואת שם הקובץ בשורה אחת, מופרדים על ידי שני רווחים, לאחר מכן הריצו sha256sum -c מול הקובץ וקראו את OK או FAILED שהוא מדפיס. בניית השורה באמצעות printf '%s %s\n' מונעת טעויות עיצוב שגורמות ל-sha256sum לדחות את הקובץ עם no properly formatted checksum lines found.