סקירה כללית על אמולציית כרטיסים מבוססת-מארח

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

ב-Android מגרסה 4.4 ואילך יש שיטה נוספת להדמיית כרטיס שלא כוללת רכיב מאובטח, שנקראת הדמיית כרטיס מבוססת-מארח. כך כל אפליקציה ל-Android יכולה לדמות כרטיס ולתקשר ישירות עם קורא ה-NFC. במאמר הזה מוסבר איך פועלת אמולציית כרטיס מבוססת-מארח (HCE) ב-Android, ואיך אפשר לפתח אפליקציה שמדמה כרטיס NFC באמצעות השיטה הזו.

אמולציית כרטיס עם רכיב מאובטח

כשמבצעים אמולציה של כרטיס NFC באמצעות רכיב מאובטח, הכרטיס שמבצעים לו אמולציה מוקצה לרכיב המאובטח במכשיר באמצעות אפליקציה ל-Android. לאחר מכן, כשהמשתמש מחזיק את המכשיר מעל מסוף NFC, בקר ה-NFC במכשיר מנתב את כל הנתונים מהקורא ישירות לרכיב המאובטח. איור 1 ממחיש את הרעיון הזה:

תרשים עם קורא NFC שעובר דרך בקר NFC כדי לאחזר מידע מרכיב מאובטח
איור 1. אמולציה של כרטיס NFC עם רכיב מאובטח.

הרכיב המאובטח עצמו מבצע את התקשורת עם מסוף ה-NFC, ואף אפליקציה ל-Android לא מעורבת בעסקה. אחרי שהעסקה מסתיימת, אפליקציה ל-Android יכולה לשלוח שאילתה ישירות לרכיב המאובטח כדי לקבל את סטטוס העסקה ולהודיע למשתמש.

אמולציית כרטיס מבוססת-מארח (HCE)

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

תרשים עם קורא NFC שעובר דרך בקר NFC כדי לאחזר מידע מהמעבד (CPU)
איור 2. אמולציה של כרטיס NFC בלי רכיב מאובטח.

כרטיסים ופרוטוקולים נתמכים של NFC

תרשים שמציג את מחסנית הפרוטוקולים של HCE
איור 3. מחסנית הפרוטוקולים של HCE ב-Android.

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

‫Android מגרסה 4.4 ואילך תומך בכמה פרוטוקולים שנפוצים כיום בשוק. הרבה כרטיסים קיימים לתשלום בטאץ' כבר מבוססים על הפרוטוקולים האלה, כמו כרטיסי תשלום בטאץ'. הפרוטוקולים האלה נתמכים גם על ידי הרבה קוראי NFC שקיימים היום בשוק, כולל מכשירי Android עם NFC שמתפקדים כקוראים בעצמם (ראו את המחלקה IsoDep). כך אתם יכולים לפתח ולפרוס פתרון NFC מקצה לקצה סביב HCE, באמצעות מכשירים שמבוססים על Android בלבד.

באופן ספציפי, Android מגרסה 4.4 ואילך תומך בהדמיה של כרטיסים שמבוססים על מפרט ISO-DEP של NFC-Forum (שמבוסס על ISO/IEC 14443-4) ומעבדים יחידות נתונים של פרוטוקול אפליקציה (APDU) כפי שמוגדר במפרט ISO/IEC 7816-4. מערכת Android מחייבת אמולציה של ISO-DEP רק מעל טכנולוגיית Nfc-A (ISO/IEC 14443-3 Type A). התמיכה בטכנולוגיית Nfc-B (ISO/IEC 14443-4 Type B) היא אופציונלית. איור 3 ממחיש את השכבות של כל המפרטים האלה.

שירותי HCE

ארכיטקטורת ה-HCE ב-Android מבוססת על רכיבי Service ב-Android (שנקראים שירותי HCE). אחד היתרונות המרכזיים של שירות הוא שהוא יכול לפעול ברקע בלי ממשק משתמש. זה מתאים באופן טבעי לאפליקציות HCE רבות, כמו כרטיסי מועדון לקוחות או כרטיסים לתחבורה ציבורית, שהמשתמש לא צריך להפעיל אפליקציה כדי להשתמש בהם. במקום זאת, הצמדת המכשיר לקורא ה-NFC מפעילה את השירות הנכון אם הוא עדיין לא פועל, ומבצעת את העסקה ברקע. כמובן שאפשר להפעיל ממשק משתמש נוסף (כמו התראות למשתמשים) מהשירות שלך במקרים המתאימים.

בחירת שירות

כשהמשתמש מצמיד מכשיר לקורא NFC, מערכת Android צריכה לדעת עם איזה שירות HCE קורא ה-NFC רוצה לתקשר. במפרט ISO/IEC 7816-4 מוגדרת דרך לבחירת אפליקציות, שמתמקדת במזהה האפליקציה (AID). מזהה AID מורכב מ-16 בייטים לכל היותר. אם אתם מדמים כרטיסים לתשתית קיימת של קורא NFC, מזהי ה-AID שהקוראים האלה מחפשים הם בדרך כלל מוכרים ורשומים באופן ציבורי (לדוגמה, מזהי ה-AID של רשתות תשלומים כמו Visa ו-MasterCard).

אם אתם רוצים לפרוס תשתית קוראים חדשה לאפליקציה שלכם, אתם צריכים לרשום מזהי AID משלכם. הליך הרישום של מזהי AID מוגדר במפרט ISO/IEC 7816-5. אם אתם פורסים אפליקציית HCE ל-Android, מומלץ לרשום AID בהתאם לתקן 7816-5 כדי למנוע התנגשויות עם אפליקציות אחרות.

קבוצות AID

במקרים מסוימים, יכול להיות ששירות HCE יצטרך לרשום כמה מזהי AID ולהיות מוגדר כ-handler שמוגדר כברירת מחדל לכל מזהי ה-AID כדי להטמיע אפליקציה מסוימת. אין תמיכה בהעברת חלק ממזהי ה-AID בקבוצה לשירות אחר.

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

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

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

קטגוריות וקבוצות של AID

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

ב-Android מגרסה 4.4 ואילך יש תמיכה בשתי קטגוריות:

  • CATEGORY_PAYMENT (כולל אפליקציות תשלומים שעומדות בתקנים המקובלים בתחום)
  • CATEGORY_OTHER (לכל שאר האפליקציות של HCE)

אפליקציות שרושמות מזהי AID בקטגוריה CATEGORY_PAYMENT יכולות לעבד עסקה רק אם:

  • המשתמש מגדיר את האפליקציה כאפליקציית תשלומים המוגדרת כברירת מחדל (בעל תפקיד Wallet במכשירי Android מגרסה 15 ואילך), או
  • האפליקציה פועלת בחזית ומפעילה את setPreferredService.

הטמעת שירות HCE

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

איך בודקים אם יש תמיכה ב-HCE

כדי לבדוק אם המכשיר תומך ב-HCE, האפליקציה יכולה לבדוק אם התכונה FEATURE_NFC_HOST_CARD_EMULATION קיימת. משתמשים בתג <uses-feature> במניפסט של האפליקציה כדי להצהיר שהאפליקציה משתמשת בתכונה HCE, ולציין אם היא נדרשת כדי שהאפליקציה תפעל או לא.

הטמעת השירות

ב-Android מגרסה 4.4 ואילך יש מחלקה נוחה של Service שאפשר להשתמש בה כבסיס להטמעה של שירות HCE: המחלקה HostApduService.

השלב הראשון הוא להרחיב את HostApduService, כמו שמוצג בדוגמת הקוד הבאה:

class MyHostApduService : HostApduService() {

    override fun processCommandApdu(commandApdu: ByteArray, extras: Bundle?): ByteArray {
        // ...
    }

    override fun onDeactivated(reason: Int) {
        // ...
    }
}

HostApduService מצהיר על שתי שיטות מופשטות שצריך לשנות ולהטמיע. אחת מהן, processCommandApdu(), נקראת בכל פעם שקורא NFC שולח יחידת נתונים של פרוטוקול אפליקציה (APDU) לשירות שלכם. יחידות APDU מוגדרות במפרט ISO/IEC 7816-4. ‫APDU הן חבילות ברמת האפליקציה שמועברות בין קורא ה-NFC לבין שירות ה-HCE. הפרוטוקול הזה ברמת האפליקציה הוא half-duplex: קורא ה-NFC שולח לכם פקודת APDU, וממתין שתשלחו לו תגובת APDU בחזרה.

כפי שצוין קודם, מערכת Android משתמשת ב-AID כדי לקבוע עם איזה שירות HCE הקורא רוצה לתקשר. בדרך כלל, ה-APDU הראשון שקורא NFC שולח למכשיר הוא APDU מסוג SELECT AID. ה-APDU הזה מכיל את ה-AID שאיתו הקורא רוצה לתקשר. מערכת Android מחלצת את ה-AID מה-APDU, פותרת אותו לשירות HCE ואז מעבירה את ה-APDU לשירות שנפתר.

כדי לשלוח APDU של תשובה, מחזירים את הבייטים של ה-APDU של התשובה מ-processCommandApdu(). חשוב לזכור שהשיטה הזו נקראת ב-thread הראשי של האפליקציה, ואין לחסום אותו. אם אי אפשר לחשב ולהחזיר APDU של תגובה באופן מיידי, צריך להחזיר ערך null. אחר כך תוכלו לבצע את העבודה הנדרשת בשרשור אחר ולהשתמש ב-method‏ sendResponseApdu() שמוגדרת בכיתה HostApduService כדי לשלוח את התשובה כשתסיימו.

מערכת Android ממשיכה להעביר יחידות APDU חדשות מהקורא לשירות שלכם, עד שקורה אחד מהמקרים הבאים:

  • קורא ה-NFC שולח עוד APDU של SELECT AID, ומערכת ההפעלה מפנה אותו לשירות אחר.
  • החיבור בין קורא ה-NFC למכשיר שלכם נותק.

בשני המקרים, ההטמעה של onDeactivated() בכיתה שלכם נקראת עם ארגומנט שמציין איזה משני המקרים קרה.

אם אתם עובדים עם תשתית קוראים קיימת, אתם צריכים להטמיע בשירות ה-HCE את הפרוטוקול הקיים ברמת האפליקציה שהקוראים מצפים לו.

אם אתם פורסים תשתית קוראים חדשה שגם נמצאת בשליטתכם, אתם יכולים להגדיר פרוטוקול ורצף APDU משלכם. נסו להגביל את כמות ה-APDU ואת גודל הנתונים שמועברים: כך המשתמשים יצטרכו להחזיק את המכשיר מעל קורא ה-NFC לזמן קצר בלבד. גבול עליון סביר הוא כ-1KB של נתונים, שבדרך כלל אפשר להחליף תוך 300 אלפיות השנייה.

הצהרת מניפסט השירות ורישום AID

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

  1. כדי להודיע לפלטפורמה שמדובר בשירות HCE שמטמיע ממשק HostApduService, צריך להוסיף מסנן Intent לפעולה SERVICE_INTERFACE להצהרת השירות.

  2. כדי לציין לפלטפורמה אילו קבוצות AID נדרשות על ידי השירות הזה, צריך לכלול תג SERVICE_META_DATA <meta-data> בהצהרה של השירות, שמפנה למשאב XML עם מידע נוסף על שירות ה-HCE.

  3. מגדירים את המאפיין android:exported לערך true, ודורשים את ההרשאה android.permission.BIND_NFC_SERVICE בהצהרת השירות. הראשון מבטיח שאפליקציות חיצוניות יוכלו להתחבר לשירות. האפליקציה אוכפת שרק אפליקציות חיצוניות עם ההרשאה android.permission.BIND_NFC_SERVICE יכולות להתחבר לשירות שלכם. מכיוון ש-android.permission.BIND_NFC_SERVICE היא הרשאת מערכת, היא אוכפת בפועל שרק מערכת ההפעלה של Android תוכל להיות מקושרת לשירות שלך.

דוגמה להצהרה במניפסט של HostApduService:

<service android:name=".MyHostApduService" android:exported="true"
         android:permission="android.permission.BIND_NFC_SERVICE">
    <intent-filter>
        <action android:name="android.nfc.cardemulation.action.HOST_APDU_SERVICE"/>
    </intent-filter>
    <meta-data android:name="android.nfc.cardemulation.host_apdu_service"
               android:resource="@xml/apduservice"/>
</service>

תג המטא-נתונים הזה מפנה לקובץ apduservice.xml. הדוגמה הבאה היא קובץ כזה עם הצהרה אחת של קבוצת AID שמכילה שני מזהי AID קנייניים:

<host-apdu-service xmlns:android="http://schemas.android.com/apk/res/android"
           android:description="@string/servicedesc"
           android:requireDeviceUnlock="false">
    <aid-group android:description="@string/aiddescription"
               android:category="other">
        <aid-filter android:name="F0010203040506"/>
        <aid-filter android:name="F0394148148100"/>
    </aid-group>
</host-apdu-service>

התג <host-apdu-service> חייב להכיל מאפיין <android:description> שכולל תיאור ידידותי למשתמש של השירות, שאפשר להציג בממשק המשתמש של האפליקציה. אפשר להשתמש במאפיין requireDeviceUnlock כדי לציין שהמכשיר צריך להיות פתוח לפני שמפעילים את השירות הזה לטיפול ב-APDU.

ה-<host-apdu-service> חייב להכיל תג <aid-group> אחד או יותר. כל תג <aid-group> צריך:

  • להכיל מאפיין android:description שכולל תיאור ידידותי למשתמש של קבוצת ה-AID, שמתאים להצגה בממשק המשתמש.
  • המאפיין android:category שלו צריך להיות מוגדר כך שיציין את הקטגוריה שאליה שייכת קבוצת ה-AID, כמו קבועי המחרוזת שמוגדרים על ידי CATEGORY_PAYMENT או CATEGORY_OTHER.
  • להכיל תג <aid-filter> אחד או יותר, שכל אחד מהם מכיל מזהה AID אחד. צריך לציין את ה-AID בפורמט הקסדצימלי, ולוודא שהוא מכיל מספר זוגי של תווים.

כדי לרשום את האפליקציה כשירות HCE, היא צריכה גם את ההרשאה NFC.

פתרון התנגשויות ב-AID

יכול להיות שיוגדרו כמה רכיבי HostApduService במכשיר אחד, ושאותו AID יירשם על ידי יותר משירות אחד. כדי לקבוע איזה שירות להפעיל, מערכת Android מבצעת את השלבים הבאים:

  1. אם אפליקציית הארנק שמוגדרת כברירת מחדל אצל המשתמש רשמה את ה-AID, האפליקציה הזו מופעלת.
  2. אם אפליקציית הארנק שמוגדרת כברירת מחדל לא רשמה את ה-AID, השירות שרשם את ה-AID מופעל.
  3. אם יותר משירות אחד רשם את ה-AID, מערכת Android שואלת את המשתמש איזה שירות להפעיל.

העדפה לגבי שירות שפועל בחזית

אפליקציות שפועלות בחזית יכולות להפעיל את setPreferredService כדי לציין איזה שירות של אמולציית כרטיס צריך להיות מועדף בזמן שפעילות ספציפית פועלת בחזית. ההעדפה הזו של אפליקציה שפועלת בחזית מבטלת את פתרון ההתנגשויות של AID. מומלץ להשתמש בשיטה הזו כשהאפליקציה צופה שהמשתמש ישתמש באמולציית כרטיס NFC.

‫Android מגרסה 13 ואילך

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

‫Android מגרסה 12 ומטה

מגדירים את גודל הבאנר של השירות ל-‎260x96 dp, ואז מגדירים את גודל הבאנר של השירות בקובץ ה-XML של המטא-נתונים על ידי הוספת המאפיין android:apduServiceBanner לתג <host-apdu-service>, שמצביע על הפריט הגרפי שניתן להזזה. לדוגמה:

<host-apdu-service xmlns:android="http://schemas.android.com/apk/res/android"
        android:description="@string/servicedesc"
        android:requireDeviceUnlock="false"
        android:apduServiceBanner="@drawable/my_banner">
    <aid-group android:description="@string/aiddescription"
               android:category="payment">
        <aid-filter android:name="F0010203040506"/>
        <aid-filter android:name="F0394148148100"/>
    </aid-group>
</host-apdu-service>

אפליקציות ארנק

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

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

כדי לבדוק אם אפליקציה מסוימת מוגדרת כברירת המחדל, צריך להעביר את RoleManager.ROLE_WALLET אל RoleManager.isRoleHeld().

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

הנכסים הנדרשים לאפליקציות של ארנק דיגיטלי

כדי לספק חוויית משתמש מושכת יותר מבחינה חזותית, אפליקציות ארנק של HCE נדרשות לספק באנר שירות.

מצב תצפית

ב-Android 15 נוספה התכונה מצב צפייה. כשהמצב הזה מופעל, המכשיר יכול לזהות לולאות דגימה של NFC ולשלוח התראות לגביהן לרכיבי HostApduService המתאימים, כדי שהם יוכלו להתכונן לאינטראקציה עם מסוף NFC מסוים. ‫HostApduService יכול להעביר את המכשיר למצב תצפית על ידי העברת true אל setObserveModeEnabled(). ההגדרה הזו מורה למחסנית ה-NFC לא לאפשר תשלומים דרך NFC, ובמקום זאת לצפות באופן פסיבי בלולאות דגימה.

מסנני לולאת דגימה

אפשר לרשום מסנני לולאת דגימה ל-HostApduService באחת מהשיטות הבאות:

כשמסנן של לולאת דגימה תואם למסגרות דגימה לא סטנדרטיות, מחסנית ה-NFC מנתבת את מסגרות הדגימה האלה אל ה-HostApduService המתאים באמצעות קריאה ל-method‏ processPollingFrames() שלו. כך השירות יכול לבצע את כל הפעולות הנדרשות כדי לוודא שהמשתמש מוכן לבצע עסקה ומתכוון לעשות זאת – לדוגמה, לאמת את המשתמש. אם קורא NFC משתמש רק במסגרות רגילות בלולאת הסקר שלו, מחסנית ה-NFC מנתבת את מסגרות הסקר האלה לשירות המועדף שפועל בחזית אם השירות הזה נמצא בחזית, או למחזיק התפקיד של ארנק ברירת המחדל במקרים אחרים.

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

תגובה ללולאות דגימה ויציאה ממצב תצפית

כשהשירות מוכן לביצוע עסקאות, הוא יכול לצאת ממצב תצפית על ידי העברת הערך false אל setObserveModeEnabled(). מחסנית ה-NFC תאפשר לעסקאות להמשיך.

רכיבי HostApduService יכולים לציין שצריך להפעיל את מצב התצפית בכל פעם שהם שירות התשלומים המועדף. כדי לעשות את זה, צריך להגדיר את shouldDefaultToObserveMode ל-true במניפסט או להפעיל את CardEmulation.setShouldDefaultToObserveModeForService().

רכיבי HostApduService ו-OffHostApduService יכולים גם לציין שמסנני לולאת הסקר שתואמים למסגרות של לולאת הסקר שהתקבלו צריכים להשבית באופן אוטומטי את מצב התצפית ולאפשר לעסקאות להמשיך על ידי הגדרת autoTransact ל-true בהצהרה PollingLoopFilter במניפסט.

העדפה לגבי שירות שפועל בחזית

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

התנהגות כשהמסך כבוי או נעול

ההתנהגות של שירותי HCE משתנה בהתאם לגרסת Android שפועלת במכשיר.

‫Android מגרסה 15 ואילך

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

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

‫Android מגרסה 12 ואילך

באפליקציות שמטרגטות את Android 12 (רמת API‏ 31) ומעלה, אפשר להפעיל תשלומים דרך NFC בלי להפעיל את מסך המכשיר. כדי לעשות את זה, מגדירים את requireDeviceScreenOn כ-false.

‫Android מגרסה 10 ואילך

מכשירים עם Android מגרסה 10 (רמת API‏ 29) ואילך תומכים בNFC מאובטח. כשהתכונה Secure NFC מופעלת, כל האמולטורים של הכרטיסים (אפליקציות מארחות ואפליקציות לא מארחות) לא זמינים כשמסך המכשיר כבוי. כשהתכונה Secure NFC מושבתת, אפליקציות לא מארחות זמינות כשמסך המכשיר כבוי. אפשר לבדוק אם יש תמיכה ב-Secure NFC באמצעות isSecureNfcSupported().

במכשירים עם Android מגרסה 10 ומעלה, אותה פונקציונליות להגדרת android:requireDeviceUnlock ל-true חלה כמו במכשירים עם Android מגרסה 9 ומטה, אבל רק כשהתכונה "NFC מאובטח" מושבתת. כלומר, אם התכונה "NFC מאובטח" מופעלת, שירותי HCE לא יכולים לפעול ממסך הנעילה, בלי קשר להגדרה של android:requireDeviceUnlock.

‫Android מגרסה 9 ומטה

במכשירים עם Android בגרסה 9 (רמת API‏ 28) ומטה, בקר ה-NFC ומעבד האפליקציות מושבתים לגמרי כשהמסך של המכשיר כבוי. לכן, שירותי HCE לא פועלים כשהמסך כבוי.

בנוסף, ב-Android מגרסה 9 ומטה, שירותי HCE יכולים לפעול ממסך הנעילה. עם זאת, ההגדרה הזו נקבעת על ידי המאפיין android:requireDeviceUnlock בתג <host-apdu-service> של שירות ה-HCE. כברירת מחדל, לא נדרשת פתיחת נעילה של המכשיר, והשירות מופעל גם אם המכשיר נעול.

אם מגדירים את המאפיין android:requireDeviceUnlock לערך true בשירות ה-HCE, מערכת Android מבקשת מהמשתמש לבטל את נעילת המכשיר במקרים הבאים:

  • המשתמש מצמיד את המכשיר לקורא NFC.
  • קורא ה-NFC בוחר AID שמוביל לשירות שלכם.

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

שימוש משולב עם כרטיסים עם רכיב מאובטח

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

הדו-קיום הזה מבוסס על עיקרון שנקרא ניתוב AID. בקר ה-NFC מכיל טבלת ניתוב שמורכבת מרשימה (סופית) של כללי ניתוב. כל כלל ניתוב מכיל AID ויעד. היעד יכול להיות המעבד המארח, שבו פועלות אפליקציות ל-Android, או רכיב מאובטח מחובר.

כשקורא ה-NFC שולח APDU עם SELECT AID, בקר ה-NFC מנתח אותו ובודק אם מזהי האפליקציות תואמים למזהה אפליקציה כלשהו בטבלת הניתוב שלו. אם יש התאמה, ה-APDU הזה וכל ה-APDUs שאחריו נשלחים ליעד שמשויך ל-AID, עד שמתקבל APDU אחר של SELECT AID או שקישור ה-NFC נשבר.

באיור 4 מוצגת הארכיטקטורה הזו:

תרשים עם קורא NFC שמתקשר גם עם רכיב מאובטח וגם עם המעבד (CPU)
איור 4. מערכת הפעלה Android שפועלת גם עם רכיב מאובטח וגם עם Host Card Emulation.

בדרך כלל, בקר ה-NFC מכיל גם נתיב ברירת מחדל ל-APDU. אם לא נמצא AID בטבלת הניתוב, המערכת משתמשת בנתיב ברירת המחדל. ההגדרה הזו עשויה להיות שונה ממכשיר למכשיר, אבל במכשירי Android צריך לוודא שמזהי האפליקציות שנרשמים על ידי האפליקציה מנותבים כראוי למארח.

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

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

רישום AID של רכיב מאובטח

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

  • הפעולה שמשתמשים בה במסנן ה-Intent צריכה להיות מוגדרת כ-SERVICE_INTERFACE.
  • צריך להגדיר את מאפיין השם של המטא-נתונים לערך SERVICE_META_DATA.
  • קובץ ה-XML של המטא-נתונים חייב להשתמש בתג הבסיס (root) <offhost-apdu-service>.

    <service android:name=".MyOffHostApduService" android:secureElementName="eSE"
           android:exported="true" android:permission="android.permission.BIND_NFC_SERVICE">
      <intent-filter>
          <action android:name="android.nfc.cardemulation.action.OFF_HOST_APDU_SERVICE"/>
      </intent-filter>
      <meta-data android:name="android.nfc.cardemulation.off_host_apdu_service"
                 android:resource="@xml/apduservice"/>
    </service>

הקובץ הבא הוא דוגמה לקובץ apduservice.xml תואם שרושם שני מזהי AID:

<offhost-apdu-service xmlns:android="http://schemas.android.com/apk/res/android"
           android:description="@string/servicedesc">
    <aid-group android:description="@string/subscription" android:category="other">
        <aid-filter android:name="F0010203040506"/>
        <aid-filter android:name="F0394148148100"/>
    </aid-group>
</offhost-apdu-service>

המאפיין android:requireDeviceUnlock לא חל על שירותים שלא מתארחים במכשיר, כי המעבד (CPU) של המארח לא מעורב בעסקה, ולכן לא יכול למנוע מהרכיב המאובטח לבצע עסקאות כשהמכשיר נעול.

המאפיין android:apduServiceBanner נדרש לשירותים מחוץ למארח שהם אפליקציות תשלומים, וכדי שניתן יהיה לבחור אותם כאפליקציית תשלומים שמוגדרת כברירת מחדל.

הפעלת שירות מחוץ למארח

מערכת Android אף פעם לא מפעילה שירות שמוגדר כ-off-host או מקשרת אליו, כי העסקאות בפועל מבוצעות על ידי הרכיב המאובטח ולא על ידי שירות Android. הצהרת השירות רק מאפשרת לאפליקציות לרשום מזהי אפליקציות (AID) שקיימים ברכיב המאובטח.

HCE ואבטחה

ארכיטקטורת ה-HCE מספקת רכיב אבטחה מרכזי אחד: מכיוון שהשירות שלכם מוגן על ידי הרשאת המערכת BIND_NFC_SERVICE, רק מערכת ההפעלה יכולה להתחבר לשירות שלכם ולתקשר איתו. כך אפשר לוודא שכל APDU שמתקבל הוא באמת APDU שהתקבל על ידי מערכת ההפעלה מבקר ה-NFC, וכל APDU שנשלח בחזרה מגיע רק למערכת ההפעלה, שמעבירה את ה-APDUs ישירות לבקר ה-NFC.

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

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

פרמטרים ופרטים של הפרוטוקול

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

פרוטוקול Nfc-A (ISO/IEC 14443 type A) למניעת התנגשויות והפעלה

במסגרת ההפעלה של פרוטוקול Nfc-A, מוחלפים כמה פריימים.

בחלק הראשון של ההחלפה, מכשיר ה-HCE מציג את ה-UID שלו. צריך להניח שלמכשירי HCE יש UID אקראי. כלומר, בכל לחיצה, מזהה המשתמש שמוצג לקורא הוא מזהה משתמש שנוצר באופן אקראי. לכן, קוראי NFC לא צריכים להסתמך על ה-UID של מכשירי HCE כצורה של אימות או זיהוי.

לאחר מכן, קורא ה-NFC יכול לבחור את מכשיר ה-HCE על ידי שליחת פקודת SEL_REQ. בתגובת ה-SEL_RES של מכשיר ה-HCE, הביט השישי (0x20) לפחות מוגדר, מה שמציין שהמכשיר תומך ב-ISO-DEP. שימו לב שגם ביטים אחרים ב-SEL_RES עשויים להיות מוגדרים, מה שמציין למשל תמיכה בפרוטוקול NFC-DEP (p2p). יכול להיות שיוגדרו ביטים אחרים, לכן קוראים שרוצים לקיים אינטראקציה עם מכשירי HCE צריכים לבדוק במפורש רק את הביט השישי, ולא להשוות את ה-SEL_RES המלא עם ערך של 0x20.

הפעלת ISO-DEP

אחרי שפרוטוקול Nfc-A מופעל, קורא ה-NFC מפעיל את פרוטוקול ISO-DEP. הוא שולח פקודת RATS (בקשה לתשובה לבחירה). בקר ה-NFC יוצר את תגובת ה-RATS, ה-ATS. שירותי HCE לא יכולים להגדיר את ה-ATS. עם זאת, הטמעות של HCE חייבות לעמוד בדרישות של NFC Forum לתגובת ATS, כך שקוראי NFC יכולים להסתמך על הפרמטרים האלה שמוגדרים בהתאם לדרישות של NFC Forum לכל מכשיר HCE.

בקטע הבא מפורטים הבייטים הנפרדים של תגובת ה-ATS שסופקה על ידי בקר ה-NFC במכשיר HCE:

  • ‫TL: אורך התגובה של ה-ATS. האורך לא יכול להיות יותר מ-20 בייטים.
  • ‫T0: הביטים 5, 6 ו-7 חייבים להיות מוגדרים בכל מכשירי ה-HCE, כדי לציין ש-TA(1), ‏ TB(1) ו-TC(1) כלולים בתגובת ה-ATS. ביטים 1 עד 4 מציינים את ה-FSCI, שמגדיר את גודל המסגרת המקסימלי. במכשירי HCE, הערך של FSCI צריך להיות בין 0h ל-8h.
  • ‫T(A)1: מגדיר את קצבי העברת הנתונים בין הקורא לאמולטור, ואם הם יכולים להיות אסימטריים. אין דרישות או הבטחות לגבי קצב העברת הנתונים במכשירי HCE.
  • ‫T(B)1: ביטים 1 עד 4 מציינים את מספר השלם של זמן ההגנה על מסגרת ההפעלה (SFGI). במכשירי HCE, הערך של SFGI חייב להיות קטן מ-8 שעות או שווה ל-8 שעות. סיביות 5 עד 8 מציינות את המספר השלם של זמן ההמתנה לפריים (FWI) ומקודדות את זמן ההמתנה לפריים (FWT). במכשירי HCE, ערך ה-FWI חייב להיות קטן מ-8 שעות או שווה ל-8 שעות.
  • ‫T(C)1: ביט 5 מציין תמיכה ב "תכונות פרוטוקול מתקדמות". יכול להיות שמכשירים עם HCE תומכים ב "תכונות פרוטוקול מתקדמות", ויכול להיות שלא. ביט 2 מציין תמיכה ב-DID. יכול להיות שמכשירי HCE תומכים ב-DID, ויכול להיות שלא. ביט 1 מציין תמיכה ב-NAD. מכשירי HCE לא צריכים לתמוך ב-NAD, וצריך להגדיר את ביט 1 לאפס.
  • בייטים היסטוריים: מכשירי HCE יכולים להחזיר עד 15 בייטים היסטוריים. קוראי NFC שמוכנים לקיים אינטראקציה עם שירותי HCE לא צריכים להניח הנחות לגבי התוכן של הבייטים ההיסטוריים או הנוכחות שלהם.

שימו לב: סביר להניח שהרבה מכשירי HCE תואמים לדרישות הפרוטוקול שרשתות התשלומים שמאוחדות ב-EMVCo ציינו במפרט Contactless Communication Protocol (פרוטוקול תקשורת לתשלומים בטאץ'). הקפידו במיוחד על הדברים הבאים:

  • ה-FSCI ב-T0 צריך להיות בין שעתיים ל-8 שעות.
  • צריך להגדיר את T(A)1 ל-0x80, כדי לציין שרק קצב העברת הנתונים של 106 קילו-ביט לשנייה נתמך, וקצבי העברת נתונים אסימטריים בין הקורא לאמולטור לא נתמכים.
  • ‫FWI ב-T(B)1 חייב להיות <= 7 שעות.

החלפת נתונים של APDU

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