חתום על האפליקציה שלך

ב-Android נדרש שכל חבילות ה-APK יהיו חתומות באופן דיגיטלי באמצעות אישור לפני התקנה או עדכון במכשיר. כשמשחררים אפליקציות באמצעות Android App Bundles, צריך לחתום על חבילת האפליקציות באמצעות מפתח העלאה לפני שמעלים אותה ל-Play Console, והמערכת של Play App Signing מטפלת בשאר השלבים. באפליקציות שמפיצים באמצעות חבילות APK ב-Play Store או בחנויות אחרות, צריך לחתום על חבילות ה-APK באופן ידני כדי להעלות אותן.

בדף הזה נסביר על כמה מושגים חשובים שקשורים לחתימה על אפליקציות ולבטיחות, נסביר איך לחתום על האפליקציה כדי לפרסם אותה ב-Google Play באמצעות Android Studio ואיך להגדיר את חתימת האפליקציות ב-Play.

בהמשך מופיעה סקירה כללית של השלבים שעשויים להיות נדרשים כדי לחתום על אפליקציה חדשה ולפרסם אותה ב-Google Play:

1. יצירת מפתח העלאה ומאגר מפתחות
2. חתימה על האפליקציה באמצעות מפתח ההעלאה
3. הגדרת חתימת אפליקציה ב-Play
4. העלאת האפליקציה ל-Google Play
5. הכנה והשקה של הגרסה החדשה של האפליקציה

אם האפליקציה כבר פורסמה בחנות Google Play עם מפתח קיים לחתימה על אפליקציות, או אם אתם רוצים לבחור את מפתח החתימה על האפליקציות לאפליקציה חדשה במקום לאפשר ל-Google ליצור אותו, עליכם לפעול לפי השלבים הבאים:

1. חותמים על האפליקציה באמצעות מפתח החתימה של האפליקציה.
2. מעלים את מפתח החתימה של האפליקציה אל Play App Signing.
3. (מומלץ) יוצרים ומרשמים אישור העלאה לעדכונים עתידיים של האפליקציה
4. העלאת האפליקציה ל-Google Play
5. הכנה והשקה של הגרסה החדשה של האפליקציה

בדף הזה נסביר גם איך לנהל את המפתחות שלכם כשאתם מעלים את האפליקציה לחנויות אפליקציות אחרות. אם אתם לא משתמשים ב-Android Studio או אם אתם מעדיפים לחתום על האפליקציה דרך שורת הפקודה, תוכלו לקרוא איך משתמשים ב-apksigner.

חתימת אפליקציות ב-Play

באמצעות Play App Signing,‏ Google מנהלת עבורכם את חתימת האפליקציה ומגינה עליה, ומשתמשת בה כדי לחתום על חבילות ה-APK להפצה. בנוסף, מכיוון ש-Android App Bundle מעביר את היצירה והחתימה של חבילות ה-APK לחנות Google Play, צריך להגדיר את Play App Signing לפני שמעלים את חבילת האפליקציות. כך תוכלו ליהנות מהיתרונות הבאים:

• להשתמש ב-Android App Bundle ולתמוך במצבי ההעברה המתקדמים של Google Play. קובצי Android App Bundle מאפשרים להקטין את האפליקציה, לפרסם גרסאות בצורה פשוטה יותר, להשתמש במודולים של תכונות ולהציע חוויות שימוש מיידיות.
• להגביר את האבטחה של מפתח החתימה, ולאפשר להשתמש במפתח העלאה נפרד כדי לחתום על חבילת האפליקציות שאתם מעלים ל-Google Play.

• שדרוג מפתחות מאפשר לכם לשנות את חתימת האפליקציה במקרה שהמפתח הקיים נפרץ או אם אתם צריכים לעבור למפתח עם הצפנה חזקה יותר.

התכונה 'חתימת אפליקציה ב-Play' משתמשת בשני מפתחות: מפתח לחתימת אפליקציות ומפתח העלאה. מידע נוסף על המפתחות מופיע בקטע מפתחות ומאגרי מפתחות. אתם שומרים את מפתח ההעלאה ומשתמשים בו כדי לחתום על האפליקציה ולהעלות אותה לחנות Google Play. Google משתמשת באישור ההעלאה כדי לאמת את הזהות שלכם, ומחתימה על חבילות ה-APK באמצעות מפתח החתימה של האפליקציה לצורך הפצה, כפי שמוצג באיור 1. שימוש במפתח העלאה נפרד מאפשר לבקש איפוס של מפתח ההעלאה אם המפתח אבד או נחשף.

לעומת זאת, באפליקציות שלא הביעו הסכמה לשימוש ב-Play App Signing, אם תאבדו את מפתח החתימה של האפליקציה, לא תוכלו לעדכן אותה.

איור 1. חתימה על אפליקציה באמצעות Play App Signing

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

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

בקטע הבא מתוארים כמה מונחים ומושגים חשובים שקשורים לחתימה על אפליקציות ולאבטחה. אם אתם מעדיפים לדלג קדימה ולקרוא איך מכינים את האפליקציה להעלאה לחנות Google Play, תוכלו לעבור לקטע חתימה על האפליקציה לצורך פרסום.

מאגרי מפתחות, מפתחות ואישורים

מאגרי מפתחות של Java‏ (‎.jks או ‎ .keystore) הם קובצי בינאריים שמשמשים כמאגרים של אישורים ומפתחות פרטיים.

אישור מפתח ציבורי (קבצים מסוג .der או .pem), שנקרא גם אישור דיגיטלי או אישור זהות, מכיל את המפתח הציבורי של זוג מפתחות ציבורי/פרטי, וגם מטא-נתונים נוספים שמזהים את הבעלים (לדוגמה, שם ומיקום) שמחזיק במפתח הפרטי התואם.

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

• מפתח לחתימה על אפליקציה: המפתח שמשמש לחתימה על חבילות APK שמותקנות במכשיר של המשתמש. כחלק ממודל העדכונים המאובטחים של Android, מפתח החתימה לא משתנה אף פעם במהלך חיי האפליקציה. מפתח החתימה של האפליקציה הוא פרטי וצריך לשמור עליו בסוד. עם זאת, אפשר לשתף את האישור שנוצר באמצעות מפתח חתימת האפליקציה.

• מפתח העלאה: המפתח שבו משתמשים כדי לחתום על חבילת האפליקציות או על קובץ ה-APK לפני ההעלאה לצורך חתימה על האפליקציה באמצעות Google Play. עליכם לשמור בסוד את מפתח ההעלאה. עם זאת, אפשר לשתף את האישור שנוצר באמצעות מפתח ההעלאה. אפשר ליצור מפתח העלאה באחת מהדרכים הבאות:

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

  טיפ: כדי לשמור על האבטחה של המפתחות, מומלץ לוודא שמפתח החתימה של האפליקציה ומפתח ההעלאה הם שונים.

עבודה עם ספקי API

אפשר להוריד את האישור למפתח לחתימת האפליקציה ואת מפתח ההעלאה מהדף פרסום > הגדרה > חתימת אפליקציה ב-Play Console. הוא משמש לרישום מפתחות ציבוריים אצל ספקי API, והוא מיועד לשיתוף כי הוא לא מכיל את המפתח הפרטי שלכם.

טביעת אצבע של אישור היא ייצוג קצר וייחודי של אישור, שספקי API מבקשים לעיתים קרובות לצד שם החבילה כדי לרשום אפליקציה לשימוש בשירות שלהם. טביעות האצבע של MD5, ‏ SHA-1 ו-SHA-256 של האישורים להעלאה ולחתימה על האפליקציה מופיעות בדף חתימת האפליקציות ב-Play Console. אפשר לחשב טביעות אצבע אחרות גם על ידי הורדת האישור המקורי (.der) מאותו דף.

חתימה על גרסת build לניפוי באגים

כשמריצים את הפרויקט או מבצעים ניפוי באגים מ-IDE, Android Studio חותמת על האפליקציה באופן אוטומטי באמצעות אישור ניפוי באגים שנוצר על ידי הכלים של Android SDK. בפעם הראשונה שתפעילו או תבצעו ניפוי באגים בפרויקט ב-Android Studio, סביבת הפיתוח המשולבת (IDE) תיצור באופן אוטומטי את האחסון המאובטח ואת האישור של ניפוי הבאגים ב-$HOME/.android/debug.keystore, ותגדיר את הסיסמאות של האחסון המאובטח והמפתחות.

אישור ניפוי הבאגים נוצר על ידי כלי ה-build והוא לא מאובטח מעצם הגדרתו, ולכן רוב חנויות האפליקציות (כולל חנות Google Play) לא מקבלות לפרסום אפליקציות שחתומות על ידי אישור ניפוי באגים.

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

מידע נוסף על פיתוח גרסאות build והרצה של אפליקציות לצורך ניפוי באגים זמין במאמר פיתוח גרסאות build והרצה של האפליקציה.

תאריך התפוגה של אישור הניפוי הבאגים

תאריך התפוגה של האישור עם החתימה העצמית שמשמש לחתימה על האפליקציה לצורך ניפוי באגים הוא 30 שנה מתאריך היצירה שלו. כשפג התוקף של האישור, תופיע שגיאה ב-build.

כדי לפתור את הבעיה, פשוט מוחקים את הקובץ debug.keystore שנשמר באחד מהמיקומים הבאים:

• ~/.android/ ב-OS X וב-Linux
• C:\Documents and Settings\user\.android\ ב-Windows XP
• C:\Users\user\.android\ ב-Windows Vista וב-Windows 7,‏ 8 ו-10

בפעם הבאה שתיצרו ותפעילו גרסה לניפוי באגים של האפליקציה, מערכת Android Studio תיצור מחדש מאגר מפתחות ומפתח לניפוי באגים.

חתימה על האפליקציה לצורך פרסום ב-Google Play

כשתהיו מוכנים לפרסם את האפליקציה, תצטרכו לחתום עליה ולהעלות אותה לחנות אפליקציות, כמו Google Play. כשמפרסמים את האפליקציה ב-Google Play בפעם הראשונה, צריך גם להגדיר את 'חתימת אפליקציות ב-Google Play'. חתימת אפליקציות ב-Play היא אופציונלית לאפליקציות שנוצרו לפני אוגוסט 2021. בקטע הזה מוסבר איך לחתום על האפליקציה בצורה נכונה כדי לפרסם אותה, ואיך להגדיר את חתימת האפליקציה ב-Play.

יצירת מפתח העלאה ומאגר מפתחות

אם עדיין אין לכם מפתח העלאה, ששימושי כשמגדירים את Play App Signing, תוכלו ליצור מפתח כזה באמצעות Android Studio באופן הבא:

1. בסרגל התפריטים, לוחצים על Build (יצירת גרסה) > Generate Signed Bundle/APK (יצירת חבילת APK/חבילת bundle חתומה).
2. בתיבת הדו-שיח Generate Signed Bundle or APK, בוחרים באפשרות Android App Bundle או APK ולוחצים על Next.
3. מתחת לשדה נתיב למאגר המפתחות, לוחצים על Create new.

4. בחלון New Key Store, מזינים את הפרטים הבאים למאגר המפתחות ולמפתח, כפי שמוצג באיור 2.

   

   איור 2. יוצרים מפתח העלאה ומאגר מפתחות חדשים ב-Android Studio.

5. Keystore

   • נתיב של מאגר המפתחות: בוחרים את המיקום שבו צריך ליצור את מאגר המפתחות. בנוסף, צריך להוסיף שם קובץ בסוף נתיב המיקום עם הסיומת .jks.
   • סיסמה: יוצרים ומאשרים סיסמה מאובטחת למאגר המפתחות.

6. מפתח

   • Alias: מזינים שם מזהה למפתח.
   • סיסמה: יוצרים ומאשרים סיסמה מאובטחת למפתח. הסיסמה הזו צריכה להיות זהה לסיסמה של מאגר המפתחות. (מידע נוסף זמין בבעיה המוכרת)
   • תוקף (שנים): מגדירים את משך הזמן, בשנים, שבו המפתח יהיה בתוקף. המפתח צריך להיות תקף לפחות 25 שנה, כדי שתוכלו לחתום על עדכוני האפליקציה עם אותו מפתח לאורך כל משך החיים של האפליקציה.
   • אישור: מזינים פרטים על עצמכם לצורך האישור. המידע הזה לא מוצג באפליקציה, אבל הוא כלול באישור כחלק מ-APK.

7. אחרי שממלאים את הטופס, לוחצים על אישור.

8. אם אתם רוצים ליצור ולחתום על האפליקציה באמצעות מפתח ההעלאה, תוכלו להמשיך לקטע חתימה על האפליקציה באמצעות מפתח ההעלאה. אם רוצים ליצור רק את המפתח ואת מאגר המפתחות, לוחצים על ביטול.

חותמים על האפליקציה באמצעות המפתח

אם כבר יש לכם מפתח העלאה, תוכלו להשתמש בו כדי לחתום על האפליקציה. אם האפליקציה כבר חתומה ופורסמה בחנות Google Play באמצעות מפתח קיים לחתימת אפליקציה, תוכלו להשתמש בו כדי לחתום על האפליקציה. בהמשך תוכלו ליצור ולרשום מפתח העלאה נפרד ב-Google Play כדי לחתום על עדכונים עתידיים של האפליקציה ולהעלות אותם.

כדי לחתום על האפליקציה באמצעות Android Studio:

1. אם תיבת הדו-שיח Generate Signed Bundle or APK לא פתוחה, לוחצים על Build > Generate Signed Bundle/APK.
2. בתיבת הדו-שיח Generate Signed Bundle or APK בוחרים באפשרות Android App Bundle או APK ולוחצים על Next.
3. בוחרים מודול מהתפריט הנפתח.

4. מציינים את הנתיב למאגר המפתחות, את הכינוי למפתח ומזינים את הסיסמאות לשניהם. אם עדיין לא הכנתם את מפתח ה-upload ואת מאגר המפתחות, עליכם ליצור מפתח העלאה ומאגר מפתחות ואז לחזור לשלב הזה כדי להשלים אותו.

   

   איור 3. חותמים על האפליקציה באמצעות מפתח ההעלאה.

5. לוחצים על הבא.

6. בחלון הבא (שמוצג באיור 4), בוחרים תיקיית יעד לאפליקציה החתומה, בוחרים את סוג ה-build ובוחרים את טעמי המוצר הרלוונטיים, אם רלוונטי.

7. אם אתם יוצרים קובץ APK וחותמים עליו, עליכם לבחור את גרסאות החתימה שאתם רוצים שהאפליקציה תתמוך בהן. מידע נוסף זמין במאמר סכימות לחתימה על אפליקציות

8. לוחצים על יצירה.

איור 5. לוחצים על הקישור בחלון הקופץ כדי לנתח או לאתר את חבילת האפליקציות.

אחרי ש-Android Studio מסיים ליצור את האפליקציה החתומה, אפשר ללחוץ על האפשרות המתאימה בהודעה הקופצת כדי לאתר או לנתח את האפליקציה, כפי שמתואר באיור 5.

עכשיו אתם מוכנים להצטרף עם האפליקציה לתוכנית Play App Signing ולהעלות אותה להפצה. אם זו הפעם הראשונה שאתם מפרסמים אפליקציה, מומלץ לקרוא את הסקירה הכללית על השקת אפליקציות. אחרת, תוכלו להמשיך לדף העלאת האפליקציה ל-Play Console.

שימוש בחתימת אפליקציות ב-Play

כפי שמתואר למעלה, צריך להגדיר את Play App Signing כדי לחתום על האפליקציה ולהפיץ אותה דרך Google Play (למעט אפליקציות שנוצרו לפני אוגוסט 2021, שעדיין יכולות להפיץ חבילות APK בחתימה עצמית). השלבים שצריך לבצע משתנים בהתאם למצב של האפליקציה: האם היא עדיין לא פורסמה ב-Google Play, או שהיא כבר חתומה ופורסמה לפני אוגוסט 2021 באמצעות מפתח קיים לחתימת אפליקציה.

הגדרת אפליקציה חדשה

כדי להגדיר חתימה לאפליקציה שעדיין לא פורסמה ב-Google Play:

1. אם עדיין לא עשיתם זאת, יוצרים מפתח העלאה וחותמים על האפליקציה באמצעות מפתח ההעלאה הזה.
2. נכנסים ל-Play Console.
3. כדי ליצור גרסה חדשה, פועלים לפי השלבים להכנה והשקה של הגרסה.
4. אחרי שבוחרים את נתיב הפרסום, מגדירים את החתימה על האפליקציה בקטע App signing באופן הבא:
   • כדי לאפשר ל-Google Play ליצור מפתח לחתימת אפליקציה ולהשתמש בו כדי לחתום על האפליקציה, אתם לא צריכים לעשות שום דבר. המפתח שבו משתמשים כדי לחתום על הגרסה הראשונה הופך למפתח ההעלאה, וצריך להשתמש בו כדי לחתום על גרסאות עתידיות.
   • כדי להשתמש באותו מפתח שבו משתמשת אפליקציה אחרת בחשבון הפיתוח, בוחרים באפשרות שינוי מפתח החתימה של האפליקציה > שימוש באותו מפתח שבו משתמשת אפליקציה אחרת בחשבון הזה, בוחרים אפליקציה ולוחצים על המשך.
   • כדי לספק מפתח חתימה משלכם ש-Google תשתמש בו בזמן החתימה על האפליקציה, בוחרים באפשרות Change app signing key (שינוי מפתח החתימה של האפליקציה) ובוחרים באחת מהאפשרויות של Export and upload (ייצוא והעלאה), שמאפשרת להעלות מפתח פרטי ואת האישור הציבורי שלו בצורה מאובטחת.

בקטע App Bundles, לוחצים על Browse files כדי לאתר את האפליקציה שחתמת עליה באמצעות מפתח ההעלאה ולהעלות אותה. למידע נוסף על השקת האפליקציה, קראו את המאמר הכנה והשקה של הגרסה. כשאתם משיקים את האפליקציה אחרי שמגדירים את חתימת האפליקציה ב-Play, Google Play יוצרת (אלא אם מעלים מפתח קיים) ומנהלת בשבילכם את מפתח החתימה של האפליקציה. פשוט חותמים על העדכונים הבאים של האפליקציה באמצעות מפתח ההעלאה של האפליקציה לפני ההעלאה ל-Google Play.

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

איך מאשרים את השימוש באפליקציה קיימת

אם אתם מעדכנים אפליקציה שכבר פורסמה ב-Google Play באמצעות מפתח קיים לחתימת אפליקציה, תוכלו להביע הסכמה לשימוש ב-Play App Signing באופן הבא:

1. נכנסים ל-Play Console ועוברים לאפליקציה.
2. בתפריט הימני, לוחצים על פרסום > הגדרה > חתימה על אפליקציה.
3. אם רלוונטי, קוראים את התנאים וההגבלות ולוחצים על אישור.
4. בוחרים באחת מהאפשרויות שמתארת בצורה הטובה ביותר את מפתח החתימה שרוצים להעלות ל-Google Play, ופועלים לפי ההוראות שמופיעות. לדוגמה, אם אתם משתמשים ב-Java Keystore למפתח החתימה, בוחרים באפשרות העלאה של חתימת אפליקציה חדשה מ-Java KeyStore ופועלים לפי ההוראות כדי להוריד ולהריץ את הכלי PEPK, ולהעלות את הקובץ שנוצר עם המפתח המוצפן.
5. לחץ על הירשם.

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

יצירת אישור העלאה ורישום שלו

כשמפרסמים אפליקציה שלא חתומה על ידי מפתח העלאה, ב-Google Play Console יש אפשרות לרשום מפתח להעלאה לעדכונים עתידיים של האפליקציה. זהו שלב אופציונלי, אבל מומלץ לפרסם את האפליקציה עם מפתח נפרד מזה ש-Google Play משתמשת בו כדי להפיץ את האפליקציה למשתמשים. כך Google שומרת על אבטחת מפתח החתימה, ויש לכם אפשרות לאפס מפתח העלאה פרטי שאבד או נפרץ. בקטע הזה מוסבר איך ליצור מפתח העלאה, ליצור ממנו אישור העלאה ולרשום את האישור הזה ב-Google Play לעדכונים עתידיים של האפליקציה.

אלה המצבים שבהם תופיע האפשרות לרשום אישור העלאה ב-Play Console:

• כשמפרסמים אפליקציה חדשה שחתומה באמצעות מפתח חתימה ומביעים הסכמה לשימוש ב-Play App Signing.
• כשאתם עומדים לפרסם אפליקציה קיימת שכבר הבעתם הסכמה להשתתף בתוכנית Play App Signing, אבל היא חתומה באמצעות מפתח החתימה שלה.

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

אם עדיין לא עשיתם זאת, יוצרים מפתח העלאה ומאגר מפתחות.

אחרי שיוצרים את מפתח ההעלאה ואת מאגר המפתחות, צריך ליצור אישור ציבורי ממפתח ההעלאה באמצעות keytool, באמצעות הפקודה הבאה:

$ keytool -export -rfc
  -keystore your-upload-keystore.jks
  -alias upload-alias
  -file output_upload_certificate.pem

עכשיו, כשיש לכם את אישור ההעלאה, עליכם לרשום אותו ב-Google כשמוצגת בקשה לכך ב-Play Console או כשמאפסים את מפתח ההעלאה.

שדרוג של חתימת האפליקציה

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

אם אתם מפרסמים את האפליקציה ב-Google Play, אתם יכולים לשדרג את מפתח החתימה של האפליקציה שפורסמה דרך Play Console. המפתח החדש ישמש לחתימה על התקנות ועדכוני אפליקציות ב-Android מגרסה 13 ואילך, בעוד שמפתח החתימה הקודם ישמש לחתימה על עדכונים למשתמשים בגרסאות ישנות יותר של Android.

למידע נוסף, קראו את המאמר שדרוג של חתימת האפליקציה.

איפוס של מפתח העלאה פרטי שאבד או נחשף

אם מפתח ההעלאה הפרטי אבד או נפרץ, תוכלו ליצור מפתח חדש ולבקש איפוס של מפתח ההעלאה במסוף Play.

הגדרת תהליך ה-build לחתימה אוטומטית על האפליקציה

ב-Android Studio, אפשר להגדיר שהפרויקט יחתום על גרסת הגרסה של האפליקציה באופן אוטומטי במהלך תהליך ה-build. לשם כך, יוצרים הגדרת חתימה ומקצים אותה לסוג ה-build של הגרסה. הגדרת החתימה מורכבת ממיקום של מאגר מפתחות, סיסמה של מאגר מפתחות, כינוי מפתח וסיסמה של מפתח. כדי ליצור הגדרת חתימה ולהקצות אותה לסוג ה-build של הגרסה המשוחררת באמצעות Android Studio:

1. בחלון Project, לוחצים לחיצה ימנית על האפליקציה ואז על Open Module Settings.
2. בחלון Project Structure, בקטע Modules בחלונית הימנית, לוחצים על המודול שרוצים לחתום עליו.
3. לוחצים על הכרטיסייה Signing ואז על Add .

4. בוחרים את קובץ מאגר המפתחות, מזינים שם להגדרת החתימה הזו (כי אפשר ליצור יותר מחתימה אחת) ומזינים את המידע הנדרש.

   

   איור 7. החלון ליצירת הגדרת חתימה חדשה.

5. לוחצים על הכרטיסייה Build Types.
6. לוחצים על גרסה release.

7. בקטע Signing Config, בוחרים את הגדרת החתימה שיצרתם.

   

   איור 8. בוחרים הגדרת חתימה ב-Android Studio.

8. לוחצים על אישור.

מעכשיו, בכל פעם שתיצרו את סוג ה-build של הגרסה המשוחררת על ידי בחירה באפשרות בקטע Build > Build Bundle(s) / APK(s) ב-Android Studio, סביבת הפיתוח המשולבת תחתום על האפליקציה באופן אוטומטי, באמצעות הגדרת החתימה שציינתם. קובץ ה-APK או חבילת ה-App Bundle החתומים נמצאים בספרייה build/outputs/ בתוך ספריית הפרויקט של המודול שאתם מפתחים.

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

חתימה על כל טעם של המוצר באופן שונה

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

1. בחלון Project, לוחצים לחיצה ימנית על האפליקציה ואז על Open Module Settings.
2. בחלון Project Structure, בקטע Modules בחלונית הימנית, לוחצים על המודול שרוצים לחתום עליו.
3. לוחצים על הכרטיסייה Signing ואז על Add .

4. בוחרים את קובץ מאגר המפתחות, מזינים שם להגדרת החתימה הזו (כי אפשר ליצור יותר מחתימה אחת) ומזינים את המידע הנדרש.

   

   איור 10. החלון ליצירת הגדרת חתימה חדשה.

5. חוזרים על שלבים 3 ו-4 לפי הצורך עד שיוצרים את כל ההגדרות לחתימה.
6. לוחצים על הכרטיסייה Flavors.
7. לוחצים על הגרסה שרוצים להגדיר ובוחרים את הגדרת החתימה המתאימה בתפריט הנפתח Signing Config.

   איור 11. הגדרת הגדרות החתימה לפי גרסת המוצר.

   חוזרים על הפעולה כדי להגדיר עוד טעמים של מוצרים.

8. לוחצים על אישור.

אפשר גם לציין את הגדרות החתימה בקובצי התצורה של Gradle. למידע נוסף, ראו הגדרת הגדרות החתימה.

הרצת דוח חתימה

כדי לקבל את פרטי החתימה של כל אחד מהוריאנטים של האפליקציה, מריצים את המשימה signingReport של Gradle ב-Android Studio:

1. בוחרים באפשרות View > Tool Windows > Gradle כדי לפתוח את חלון הכלי של Gradle.
2. בוחרים באפשרות YourApp > Tasks > android > signingReport כדי להריץ את הדוח.

ניהול מפתח החתימה שלכם

אם בוחרים לא להצטרף ל-Play App Signing (רק לאפליקציות שנוצרו לפני אוגוסט 2021), אפשר לנהל את מפתח החתימה של האפליקציה ואת מאגר המפתחות שלכם. חשוב לזכור שאתם אחראים לאבטחת המפתח ומאגר המפתחות. בנוסף, האפליקציה לא תוכל לתמוך ב-Android App Bundles, ב-Play Feature Delivery וב-Play Asset Delivery.

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

אם אתם מנהלים את מפתח החתימה של האפליקציה ואת מאגר המפתחות שלכם, כשאתם חותמים על קובץ ה-APK, אתם צריכים לחתום עליו באופן מקומי באמצעות מפתח החתימה של האפליקציה, ולהעלות את קובץ ה-APK החתום ישירות ל-Google Play Store לצורך הפצה, כפי שמתואר באיור 12.

איור 12. חתימה על אפליקציה כשאתם מנהלים את מפתח חתימת האפליקציה שלכם

כשמשתמשים ב-Play App Signing, Google שומרת על אבטחת מפתח החתימה ומבטיחה שהאפליקציות שלכם חתומות בצורה נכונה ויכולות לקבל עדכונים לאורך כל מחזור החיים שלהן. עם זאת, אם תחליטו לנהל את מפתח חתימת האפליקציה בעצמכם, יש כמה שיקולים שכדאי להביא בחשבון.

שיקולים בנושא חתימה

עליכם לחתום על האפליקציה באותו אישור לאורך כל משך החיים הצפוי שלה. יש כמה סיבות לכך:

• שדרוג אפליקציה: כשהמערכת מתקינה עדכון לאפליקציה, היא משווה בין האישורים בגרסה החדשה לאלה בגרסה הקיימת. המערכת תאפשר את העדכון אם האישורים יהיו זהים. אם תחתימו על הגרסה החדשה באמצעות אישור אחר, תצטרכו להקצות לאפליקציה שם חבילה אחר. במקרה כזה, המשתמש יותקן את הגרסה החדשה כאפליקציה חדשה לגמרי.
• מודולריות של אפליקציות: מערכת Android מאפשרת להריץ חבילות APK חתומות באותו אישור באותו תהליך, אם האפליקציות מבקשות זאת, כך שהמערכת מתייחסת אליהן כאפליקציה אחת. כך תוכלו לפרוס את האפליקציה במודולים, והמשתמשים יוכלו לעדכן כל אחד מהמודולים בנפרד.
• שיתוף קוד/נתונים באמצעות הרשאות: Android מספק אכיפה של הרשאות שמבוססת על חתימות, כך שאפליקציה יכולה לחשוף פונקציונליות לאפליקציה אחרת שנחתמה באמצעות אישור ספציפי. כשחותמים על כמה חבילות APK באותו אישור ומשתמשים בבדיקות הרשאות שמבוססות על חתימות, האפליקציות יכולות לשתף קוד ונתונים באופן מאובטח.

אם אתם מתכננים לתמוך בשדרוגים של אפליקציה, חשוב לוודא שתקופת התוקף של מפתח החתימה של האפליקציה ארוכה יותר ממחזור החיים הצפוי של האפליקציה. מומלץ לקבוע תקופת תוקף של 25 שנים או יותר. כשתוקף המפתח יפוג, המשתמשים לא יוכלו יותר לשדרג בצורה חלקה לגרסאות חדשות של האפליקציה.

אם אתם מתכננים לפרסם את האפליקציות שלכם ב-Google Play, תקופת התוקף של המפתח שבו אתם משתמשים כדי לחתום על האפליקציה חייבת להסתיים אחרי 22 באוקטובר 2033. אנחנו אוכפים את הדרישה הזו ב-Google Play כדי לוודא שהמשתמשים יוכלו לשדרג את האפליקציות בצורה חלקה כשיהיו זמינות גרסאות חדשות.

שמירה על אבטחת המפתח

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

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

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

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

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

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

הסרת פרטי החתימה מקובצי ה-build

כשיוצרים הגדרת חתימה, Android Studio מוסיפה את פרטי החתימה בטקסט ללא הצפנה לקובצי build.gradle של המודול. אם אתם עובדים עם צוות או מפרסמים את הקוד שלכם כקוד פתוח, כדאי להעביר את המידע הרגיש הזה מקבצי ה-build כדי שלא יהיה קל לגשת אליו. כדי לעשות זאת, צריך ליצור קובץ מאפיינים נפרד לאחסון מידע מאובטח, ולהפנות לקובץ הזה בקובצי ה-build באופן הבא:

1. יוצרים הגדרת חתימה ומקצים אותה לסוג build אחד או יותר. ההוראות האלה מבוססות על ההנחה שהגדרתם הגדרת חתימה יחידה לסוג ה-build של הגרסה המשוחררת, כפי שמתואר בקטע הגדרת תהליך ה-build לחתימה אוטומטית על האפליקציה למעלה.
2. יוצרים קובץ בשם keystore.properties בתיקיית השורש של הפרויקט. הקובץ הזה צריך להכיל את פרטי החתימה שלכם, באופן הבא:

   storePassword=myStorePassword
   keyPassword=mykeyPassword
   keyAlias=myKeyAlias
   storeFile=myStoreFileLocation
   

3. בקובץ build.gradle של המודול, מוסיפים קוד לטעינת הקובץ keystore.properties לפני הבלוק android {}.

   Groovy

   ...
   
   // Create a variable called keystorePropertiesFile, and initialize it to your
   // keystore.properties file, in the rootProject folder.
   def keystorePropertiesFile = rootProject.file("keystore.properties")
   
   // Initialize a new Properties() object called keystoreProperties.
   def keystoreProperties = new Properties()
   
   // Load your keystore.properties file into the keystoreProperties object.
   keystoreProperties.load(new FileInputStream(keystorePropertiesFile))
   
   android {
       ...
   }

   Kotlin

   ...
   import java.util.Properties
   import java.io.FileInputStream
   
   // Create a variable called keystorePropertiesFile, and initialize it to your
   // keystore.properties file, in the rootProject folder.
   val keystorePropertiesFile = rootProject.file("keystore.properties")
   
   // Initialize a new Properties() object called keystoreProperties.
   val keystoreProperties = Properties()
   
   // Load your keystore.properties file into the keystoreProperties object.
   keystoreProperties.load(FileInputStream(keystorePropertiesFile))
   
   android {
       ...
   }

   הערה: אפשר לשמור את הקובץ keystore.properties במיקום אחר (לדוגמה, בתיקיית המודול במקום בתיקיית השורש של הפרויקט, או בשרת ה-build אם אתם משתמשים בכלי לשילוב רצוף). במקרה כזה, צריך לשנות את הקוד שלמעלה כדי לאתחל את keystorePropertiesFile בצורה נכונה באמצעות המיקום בפועל של הקובץ keystore.properties.

4. אפשר להפנות למאפיינים שמאוחסנים ב-keystoreProperties באמצעות התחביר keystoreProperties['propertyName']. משנים את הבלוק signingConfigs בקובץ build.gradle של המודול כך שיפנה לפרטי החתימה ששמורים בקובץ keystoreProperties באמצעות התחביר הזה.

   Groovy

   android {
       signingConfigs {
           config {
               keyAlias keystoreProperties['keyAlias']
               keyPassword keystoreProperties['keyPassword']
               storeFile file(keystoreProperties['storeFile'])
               storePassword keystoreProperties['storePassword']
           }
       }
       ...
     }

   Kotlin

   android {
       signingConfigs {
           create("config") {
               keyAlias = keystoreProperties["keyAlias"] as String
               keyPassword = keystoreProperties["keyPassword"] as String
               storeFile = file(keystoreProperties["storeFile"] as String)
               storePassword = keystoreProperties["storePassword"] as String
           }
       }
       ...
     }

5. פותחים את חלון הכלי Build Variants ומוודאים שבחרתם את סוג ה-build של הגרסה המשוחררת.
6. בוחרים אפשרות בקטע Build > Build Bundle(s) / APK(s) כדי ליצור קובץ APK או App Bundle של גרסה זמינה לפריסה. הפלט של ה-build אמור להופיע בספרייה build/outputs/ של המודול.

מאחר שקובצי ה-build כבר לא מכילים מידע רגיש, עכשיו אפשר לכלול אותם במערכת בקרת הגרסאות או להעלות אותם לקוד בסיס משותף. חשוב לשמור על האבטחה של קובץ ה-keystore.properties. יכול להיות שצריך גם להסיר אותו ממערכת בקרת הגרסאות.