אם אתם מתכננים לשלוח רק בקשות API רגילות, שמתאימות לרוב המפתחים, אתם יכולים לדלג קדימה אל החלטות לגבי תקינות. בדף הזה מוסבר איך לשלוח בקשות API קלאסיות לקבלת קביעות תקינות, שנתמכות ב-Android מגרסה 4.4 (רמת API 19) ואילך.
שיקולים
השוואה בין בקשות רגילות וקלאסיות
אתם יכולים לשלוח בקשות רגילות, בקשות קלאסיות או שילוב של השתיים, בהתאם לצרכים של האפליקציה שלכם בתחום האבטחה וההגנה מפני התנהלות פוגעת. בקשות רגילות מתאימות לכל האפליקציות והמשחקים, ואפשר להשתמש בהן כדי לוודא שכל פעולה או קריאה לשרת היא אמיתית, תוך העברת חלק מההגנה מפני יכולת הפעלה חוזרת וחילוץ נתונים ל-Google Play. בקשות קלאסיות יקרות יותר, ואתם אחראים להטמיע אותן בצורה נכונה כדי להגן מפני זליגת מידע וסוגים מסוימים של התקפות. בקשות קלאסיות צריכות להתבצע בתדירות נמוכה יותר מבקשות רגילות, למשל כפעולה חד-פעמית מדי פעם כדי לבדוק אם פעולה בעלת ערך גבוה או רגישה היא אמיתית.
בטבלה הבאה מפורטים ההבדלים העיקריים בין שני סוגי הבקשות:
| בקשת Standard API | בקשת API קלאסית | |
|---|---|---|
| דרישות סף | ||
| גרסת Android SDK מינימלית נדרשת* | Android מגרסה 6.0 (רמת API 23) ומעלה | Android מגרסה 6.0 (רמת API 23) ומעלה |
| הדרישות של Google Play | חנות Google Play ו-Google Play Services | חנות Google Play ו-Google Play Services |
| פרטי השילוב | ||
| נדרש חימום של ה-API | ✔️ (כמה שניות) | ❌ |
| זמן האחזור הרגיל של בקשות | כמה מאות אלפיות השנייה | כמה שניות |
| תדירות הבקשות הפוטנציאלית | תדירות גבוהה (בדיקה מתי שנוח של כל פעולה או בקשה) | לעיתים רחוקות (בדיקה חד-פעמית של הפעולות החשובות ביותר או הבקשות הרגישות ביותר) |
| חסימות זמניות | רוב החימומים נמשכים פחות מ-10 שניות, אבל הם כוללים קריאה לשרת, ולכן מומלץ להגדיר זמן קצוב ארוך (למשל, דקה אחת). בקשות לפסיקה מתבצעות בצד הלקוח | רוב הבקשות נמשכות פחות מ-10 שניות, אבל הן כוללות קריאה לשרת, ולכן מומלץ להגדיר זמן קצוב ארוך (למשל, דקה אחת). |
| אסימון של קביעת תקינות | ||
| מכיל פרטים על המכשיר, האפליקציה והחשבון | ✔️ | ✔️ |
| שמירת טוקנים במטמון | שמירה מוגנת במטמון במכשיר על ידי Google Play | לא מומלץ: |
| פענוח ואימות של הטוקן באמצעות שרת של Google Play | ✔️ | ✔️ |
| זמן האחזור הרגיל של בקשת פענוח משרת לשרת | עשרות אלפיות השנייה עם זמינות של 99.9% | עשרות אלפיות השנייה עם זמינות של 99.9% |
| פענוח ואימות של הטוקן באופן מקומי בסביבת שרת מאובטחת | ❌ | ✔️ |
| פענוח ואימות של טוקן בצד הלקוח | ❌ | ❌ |
| עדכניות של קביעת התקינות | שמירה אוטומטית במטמון ורענון על ידי Google Play | כל ההחלטות מחושבות מחדש בכל בקשה |
| מגבלות | ||
| בקשות לכל אפליקציה ביום | 10,000 כברירת מחדל (אפשר לבקש להגדיל את המכסה) | 10,000 כברירת מחדל (אפשר לבקש להגדיל את המכסה) |
| בקשות לכל מופע של אפליקציה לדקה | חימומים: 5 לדקה אסימוני תקינות: אין מגבלה ציבורית** |
אסימוני תקינות: 5 לדקה |
| הגנה | ||
| הגנה מפני פגיעה והתקפות דומות | שימוש בשדה requestHash |
שימוש בשדה nonce עם קישור תוכן על סמך נתוני הבקשה |
| הגנה מפני התקפות של הפעלה חוזרת והתקפות דומות | השבתה זמנית אוטומטית של אותות אכיפה על ידי Google Play | שימוש בשדה nonce עם לוגיקה בצד השרת |
* בספריית Play Integrity API מגרסה v1.4.0 ואילך, גרסת Android SDK המינימלית שנתמכת זהה לשני סוגי הבקשות, ונקבעת לפי ה-minSdkVersion של הספרייה. בגרסה 1.3.0 ובגרסאות קודמות, גרסת ה-Android SDK המינימלית שנדרשת היא Android 5.0 (רמת API 21) לבקשות Standard API ו-Android 4.4 (רמת API 19) לבקשות Classic API.
** כל הבקשות, כולל אלה שאין להן מגבלות ציבוריות, כפופות למגבלות הגנה לא ציבוריות בערכים גבוהים.
שליחת בקשות קלאסיות בתדירות נמוכה
יצירת אסימון תקינות צורכת זמן, נתונים וסוללה, ולכל אפליקציה יש מספר מקסימלי של בקשות קלאסיות שהיא יכולה לשלוח ביום. לכן, כדאי להשתמש בבקשות קלאסיות רק כדי לבדוק אם הפעולות בעלות הערך הגבוה ביותר או הרגישות ביותר הן אמיתיות, כשרוצים לקבל הבטחה נוספת לבקשה רגילה. לא כדאי להשתמש בבקשות קלאסיות לפעולות בתדירות גבוהה או לפעולות בעלות ערך נמוך. אל תשלחו בקשות קלאסיות בכל פעם שהאפליקציה עוברת לחזית או כל כמה דקות ברקע, והימנעו משליחת בקשות ממספר גדול של מכשירים בו-זמנית. אם אפליקציה שולחת יותר מדי קריאות לבקשות קלאסיות, יכול להיות שהיא תוגבל כדי להגן על המשתמשים מפני הטמעות שגויות.
הימנעות משמירת החלטות במטמון
שמירת פסיקה במטמון מגבירה את הסיכון להתקפות כמו זליגת מידע והפעלה מחדש, שבהן נעשה שימוש חוזר בפסיקה טובה מסביבה לא מהימנה. אם אתם שוקלים לשלוח בקשה קלאסית ואז לשמור אותה במטמון לשימוש מאוחר יותר, מומלץ במקום זאת לשלוח בקשה רגילה על פי דרישה. בקשות רגילות כוללות שמירה מסוימת במטמון במכשיר, אבל Google Play משתמשת בשיטות הגנה נוספות כדי לצמצם את הסיכון להתקפות של הפעלה חוזרת ולזליגת מידע.
שימוש בשדה nonce כדי להגן על בקשות קלאסיות
ב-Play Integrity API יש שדה שנקרא nonce, שמאפשר להגן על האפליקציה מפני מתקפות מסוימות, כמו מתקפות של הפעלה מחדש ומתקפות של שיבוש. Play Integrity API מחזיר את הערך שהגדרתם בשדה הזה, בתוך תגובת התקינות החתומה. כדי להגן על האפליקציה מפני התקפות, חשוב לפעול לפי ההנחיות ליצירת מספרים חד-פעמיים.
ניסיון חוזר של בקשות דרך Classic API עם השהיה מעריכית לפני ניסיון חוזר (exponential backoff)
תנאים סביבתיים, כמו חיבור לא יציב לאינטרנט או עומס יתר במכשיר, עלולים לגרום לכשל בבדיקות של תקינות המכשיר. במצב כזה, יכול להיות שלא ייווצרו תוויות למכשיר שהוא מהימן. כדי לצמצם את התרחישים האלה, כדאי לכלול אפשרות לניסיון חוזר עם השהיה מעריכית לפני ניסיון חוזר (exponential backoff).
סקירה כללית
כשהמשתמש מבצע באפליקציה פעולה חשובה שרוצים להגן עליה באמצעות בדיקת תקינות, צריך לבצע את השלבים הבאים:
- הקצה העורפי בצד השרת של האפליקציה יוצר ערך ייחודי ושולח אותו ללוגיקה בצד הלקוח. בשלבים הבאים, הלוגיקה הזו נקראת "אפליקציה".
- האפליקציה יוצרת את
nonceמהערך הייחודי ומהתוכן של הפעולה החשובה. לאחר מכן, האפליקציה שולחת קריאה ל-Play Integrity API ומעבירה את ה-nonce. - האפליקציה מקבלת קביעה חתומה ומוצפנת מ-Play Integrity API.
- האפליקציה מעבירה את התוצאה החתומה והמוצפנת למערכת ה-backend של האפליקציה.
- הקצה העורפי של האפליקציה שולח את התוצאה לשרת של Google Play. השרת של Google Play מפענח ומאמת את התוצאה, ומחזיר את התוצאות לקצה העורפי של האפליקציה.
- ה-backend של האפליקציה קובע איך להמשיך, על סמך האותות שכלולים במטען הייעודי (payload) של האסימון.
- הקצה העורפי של האפליקציה שולח את תוצאות ההחלטה לאפליקציה.
יצירת מספר חד-פעמי (nonce)
כשמגנים על פעולה באפליקציה באמצעות Play Integrity API, אפשר להשתמש בשדה nonce כדי לצמצם סוגים מסוימים של התקפות, כמו התקפות של שינוי נתונים מסוג "אדם בתווך" (PITM) והתקפות של הפעלה חוזרת. Play Integrity API מחזיר את הערך שהגדרתם בשדה הזה בתוך תגובת התקינות החתומה.
הערך שמוגדר בשדה nonce צריך להיות בפורמט הנכון:
String- בטוח לשימוש בכתובות URL
- מקודד כ-Base64 וללא גלישת טקסט
- לפחות 16 תווים
- עד 500 תווים
הנה כמה דרכים נפוצות להשתמש בשדה nonce ב-Play Integrity API. כדי לקבל את ההגנה החזקה ביותר מ-nonce, אתם יכולים לשלב את השיטות הבאות.
כדי להגן מפני פגיעה, צריך לכלול גיבוב (hash) של הבקשה
כדי להגן על תוכן הבקשה מפני שינויים, אתם יכולים להשתמש בפרמטר nonce בבקשת API קלאסית, בדומה לפרמטר requestHash בבקשת API רגילה.
כשמבקשים קביעת תקינות:
- מחשבים תקציר של כל הפרמטרים הקריטיים של הבקשה (למשל, SHA256 של סריאליזציה יציבה של בקשה) מפעולת המשתמש או מבקשת השרת שמתרחשת.
- משתמשים ב-
setNonceכדי להגדיר את השדהnonceלערך של התקציר המחושב.
כשמקבלים קביעת תקינות:
- מפענחים ומאמתים את אסימון התקינות, ומקבלים את התקציר מהשדה
nonce. - מחשבים תקציר של הבקשה באותו אופן כמו באפליקציה (למשל, SHA256 של סריאליזציה יציבה של בקשה).
- משווים בין התקצירים בצד האפליקציה ובצד השרת. אם הם לא תואמים, הבקשה לא מהימנה.
הכללת ערכים ייחודיים להגנה מפני התקפות שליחה מחדש
כדי למנוע ממשתמשים זדוניים לעשות שימוש חוזר בתגובות קודמות מ-Play Integrity API, אתם יכולים להשתמש בשדה nonce כדי לזהות כל הודעה באופן ייחודי.
כשמבקשים קביעת תקינות:
- צריך להשיג ערך ייחודי גלובלי באופן שמשתמשים זדוניים לא יוכלו לחזות. לדוגמה, מספר אקראי שנוצר בצד השרת ומאובטח באמצעות הצפנה יכול להיות ערך כזה, או מזהה קיים, כמו מזהה סשן או מזהה עסקה. גרסה פשוטה יותר ופחות מאובטחת היא ליצור מספר אקראי במכשיר. מומלץ ליצור ערכים של 128 ביטים או יותר.
- מפעילים את
setNonce()כדי להגדיר את השדהnonceלערך הייחודי משלב 1.
כשמקבלים קביעת תקינות:
- מפענחים ומאמתים את אסימון התקינות, ומקבלים את הערך הייחודי מהשדה
nonce. - אם הערך משלב 1 נוצר בשרת, צריך לוודא שהערך הייחודי שהתקבל הוא אחד מהערכים שנוצרו, ושהוא משמש בפעם הראשונה (השרת יצטרך לשמור תיעוד של הערכים שנוצרו למשך זמן מתאים). אם הערך הייחודי שהתקבל כבר היה בשימוש או לא מופיע ברשומה, דוחים את הבקשה.
- אחרת, אם הערך הייחודי נוצר במכשיר, צריך לוודא שהערך שהתקבל נמצא בשימוש בפעם הראשונה (השרת צריך לשמור תיעוד של ערכים שכבר נראו למשך זמן מתאים). אם כבר נעשה שימוש בערך הייחודי שהתקבל, דוחים את הבקשה.
שילוב של שתי ההגנות מפני התקפות של פגיעה והפעלה מחדש (מומלץ)
אפשר להשתמש בשדה nonce כדי להגן מפני התקפות שיבוש והתקפות שידור חוזר בו-זמנית. כדי לעשות זאת, יוצרים את הערך הייחודי כמו שמתואר למעלה וכוללים אותו כחלק מהבקשה. לאחר מכן מחשבים את גיבוב הבקשה, ומוודאים שהערך הייחודי נכלל כחלק מהגיבוב. הטמעה שמשלבת את שתי הגישות:
כשמבקשים קביעת תקינות:
- המשתמש מתחיל את הפעולה החשובה.
- מקבלים ערך ייחודי לפעולה הזו, כמו שמתואר בקטע הכללת ערכים ייחודיים להגנה מפני התקפות מסוג Replay.
- מכינים את ההודעה שרוצים להגן עליה. מוסיפים להודעה את הערך הייחודי משלב 2.
- האפליקציה מחשבת תקציר של ההודעה שעליה היא רוצה להגן, כמו שמתואר בקטע הוספת גיבוב (hash) של בקשה כדי להגן מפני שיבוש. מכיוון שההודעה מכילה את הערך הייחודי, הערך הייחודי הוא חלק מהגיבוב.
- משתמשים ב-
setNonce()כדי להגדיר את השדהnonceלתקציר המחושב מהשלב הקודם.
כשמקבלים קביעת תקינות:
- מקבלים את הערך הייחודי מהבקשה.
- מפענחים ומאמתים את אסימון התקינות, ומקבלים את התקציר מהשדה
nonce. - כפי שמתואר בקטע הוספת גיבוב (hash) של בקשה כדי להגן מפני שינויים, מחשבים מחדש את סיכום הנתונים בצד השרת ובודקים שהוא תואם לסיכום הנתונים שהתקבל מהאסימון לבדיקת תקינות.
- כמו שמתואר בקטע הכללת ערכים ייחודיים להגנה מפני התקפות מסוג Replay, בודקים את התקינות של הערך הייחודי.
בתרשים הרצף הבא מוצגים השלבים האלה עם nonce בצד השרת:
בקשה לקביעת תקינות
אחרי שיוצרים nonce, אפשר לבקש קביעת תקינות מ-Google Play. כדי לעשות את זה:
- יוצרים
IntegrityManager, כמו בדוגמאות הבאות. - יוצרים
IntegrityTokenRequestומספקים אתnonceבאמצעות ה-methodsetNonce()ב-builder המשויך. באפליקציות שמופצות רק מחוץ ל-Google Play ובערכות SDK, צריך לציין גם את מספר הפרויקט ב-Google Cloud באמצעות השיטהsetCloudProjectNumber(). אפליקציות ב-Google Play מקושרות לפרויקט בענן ב-Play Console, ואין צורך להגדיר את מספר הפרויקט בענן בבקשה. - משתמשים במנהל כדי לקרוא ל-
requestIntegrityToken(), ומספקים אתIntegrityTokenRequest. זהירות: הערכים שלnonceמועברים כמו שהם למערכות של Google, לכן אל תכללו פרטים אישיים מזהים או מידע רגיש אחר באופן ישיר או עקיף ב-nonce.
Kotlin
// Receive the nonce from the secure server.
val nonce: String = ...
// Create an instance of a manager.
val integrityManager =
IntegrityManagerFactory.create(applicationContext)
// Request the integrity token by providing a nonce.
val integrityTokenResponse: Task<IntegrityTokenResponse> =
integrityManager.requestIntegrityToken(
IntegrityTokenRequest.builder()
.setNonce(nonce)
.build())
Java
import com.google.android.gms.tasks.Task; ...
// Receive the nonce from the secure server.
String nonce = ...
// Create an instance of a manager.
IntegrityManager integrityManager =
IntegrityManagerFactory.create(getApplicationContext());
// Request the integrity token by providing a nonce.
Task<IntegrityTokenResponse> integrityTokenResponse =
integrityManager
.requestIntegrityToken(
IntegrityTokenRequest.builder().setNonce(nonce).build());
Unity
IEnumerator RequestIntegrityTokenCoroutine() { // Receive the nonce from the secure server. var nonce = ...// Initialize the V2 manager. Requires Play Integrity Unity Plugin v2.0.0 // or higher. var integrityManager = new IntegrityManagerV2();
// Request the integrity token by providing a nonce. var tokenRequest = new IntegrityTokenRequest(nonce); var requestIntegrityTokenOperation = integrityManager.RequestIntegrityToken(tokenRequest);
// Wait for PlayAsyncOperation to complete. yield return requestIntegrityTokenOperation;
// Check the resulting error code. if (requestIntegrityTokenOperation.Error != null && requestIntegrityTokenOperation.Error.ErrorCode != IntegrityErrorCode.NoError) { AppendStatusLog("IntegrityAsyncOperation failed with error: " + requestIntegrityTokenOperation.Error.ErrorCode); yield break; }
// Get the response. var tokenResponse = requestIntegrityTokenOperation.GetResult(); }
Unreal Engine
// .h
void MyClass::OnRequestIntegrityTokenCompleted(
EIntegrityErrorCode ErrorCode,
UIntegrityTokenResponse* Response)
{
// Check the resulting error code.
if (ErrorCode == EIntegrityErrorCode::Integrity_NO_ERROR)
{
// Get the token.
FString Token = Response->Token;
}
}
// .cpp
void MyClass::RequestIntegrityToken()
{
// Receive the nonce from the secure server.
FString Nonce = ...
// Create the Integrity Token Request.
FIntegrityTokenRequest Request = { Nonce };
// Create a delegate to bind the callback function.
FIntegrityOperationCompletedDelegate Delegate;
// Bind the completion handler (OnRequestIntegrityTokenCompleted) to the delegate.
Delegate.BindDynamic(this, &MyClass::OnRequestIntegrityTokenCompleted);
// Initiate the integrity token request, passing the delegate to handle the result.
GetGameInstance()
->GetSubsystem<UIntegrityManager>()
->RequestIntegrityToken(Request, Delegate);
}
פורמט מותאם
/// Create an IntegrityTokenRequest opaque object. const char* nonce = RequestNonceFromServer(); IntegrityTokenRequest* request; IntegrityTokenRequest_create(&request); IntegrityTokenRequest_setNonce(request, nonce);/// Prepare an IntegrityTokenResponse opaque type pointer and call /// IntegerityManager_requestIntegrityToken(). IntegrityTokenResponse* response; IntegrityErrorCode error_code = IntegrityManager_requestIntegrityToken(request, &response);
/// ... /// Proceed to polling iff error_code == INTEGRITY_NO_ERROR if (error_code != INTEGRITY_NO_ERROR) { /// Remember to call the *_destroy() functions. return; } /// ... /// Use polling to wait for the async operation to complete. /// Note, the polling shouldn't block the thread where the IntegrityManager /// is running.
IntegrityResponseStatus response_status;
/// Check for error codes. IntegrityErrorCode error_code = IntegrityTokenResponse_getStatus(response, &response_status); if (error_code == INTEGRITY_NO_ERROR && response_status == INTEGRITY_RESPONSE_COMPLETED) { const char* integrity_token = IntegrityTokenResponse_getToken(response); SendTokenToServer(integrity_token); } /// ... /// Remember to free up resources. IntegrityTokenRequest_destroy(request); IntegrityTokenResponse_destroy(response); IntegrityManager_destroy();
פענוח ואימות של קביעת התקינות
כשאתם מבקשים קביעת תקינות, Play Integrity API מספק אסימון תגובה חתום. הערך של nonce שאתם כוללים בבקשה הופך לחלק מהאסימון בתגובה.
פורמט הטוקן
האסימון הוא JSON Web Token (JWT) בתצורה של JSON Web Encryption (JWE) של JSON Web Signature (JWS). הרכיבים JWE ו-JWS מיוצגים באמצעות סריאליזציה קומפקטית.
האלגוריתמים של ההצפנה והחתימה נתמכים היטב בהטמעות שונות של JWT:
פענוח ואימות בשרתים של Google (מומלץ)
Play Integrity API מאפשר לכם לפענח ולאמת את קביעת התקינות בשרתים של Google, וכך לשפר את האבטחה של האפליקציה. כדי לעשות את זה:
- יוצרים חשבון שירות בפרויקט בענן של Google שמקושר לאפליקציה.
בשרת של האפליקציה, מאחזרים את טוקן הגישה מפרטי הכניסה של חשבון השירות באמצעות ההיקף
playintegrity, ושולחים את הבקשה הבאה:playintegrity.googleapis.com/v1/PACKAGE_NAME:decodeIntegrityToken -d \ '{ "integrity_token": "INTEGRITY_TOKEN" }'קוראים את תגובת ה-JSON.
פענוח ואימות באופן מקומי
אם תבחרו לנהל ולהוריד בעצמכם את המפתחות להצפנת תשובות, תוכלו לפענח ולאמת את האסימון שמוחזר בסביבת השרת המאובטחת שלכם.
אפשר לקבל את הטוקן שהוחזר באמצעות ה-method IntegrityTokenResponse#token().
הדוגמה הבאה מראה איך לפענח את מפתח ה-AES ואת מפתח ה-EC הציבורי בקידוד DER לאימות חתימה מ-Play Console למפתחות ספציפיים לשפה (שפת התכנות Java, במקרה שלנו) בקצה העורפי של האפליקציה. שימו לב שהמפתחות מקודדים ב-base64 באמצעות דגלי ברירת המחדל.
Kotlin
// base64OfEncodedDecryptionKey is provided through Play Console.
var decryptionKeyBytes: ByteArray =
Base64.decode(base64OfEncodedDecryptionKey, Base64.DEFAULT)
// Deserialized encryption (symmetric) key.
var decryptionKey: SecretKey = SecretKeySpec(
decryptionKeyBytes,
/* offset= */ 0,
AES_KEY_SIZE_BYTES,
AES_KEY_TYPE
)
// base64OfEncodedVerificationKey is provided through Play Console.
var encodedVerificationKey: ByteArray =
Base64.decode(base64OfEncodedVerificationKey, Base64.DEFAULT)
// Deserialized verification (public) key.
var verificationKey: PublicKey = KeyFactory.getInstance(EC_KEY_TYPE)
.generatePublic(X509EncodedKeySpec(encodedVerificationKey))
Java
// base64OfEncodedDecryptionKey is provided through Play Console.
byte[] decryptionKeyBytes =
Base64.decode(base64OfEncodedDecryptionKey, Base64.DEFAULT);
// Deserialized encryption (symmetric) key.
SecretKey decryptionKey =
new SecretKeySpec(
decryptionKeyBytes,
/* offset= */ 0,
AES_KEY_SIZE_BYTES,
AES_KEY_TYPE);
// base64OfEncodedVerificationKey is provided through Play Console.
byte[] encodedVerificationKey =
Base64.decode(base64OfEncodedVerificationKey, Base64.DEFAULT);
// Deserialized verification (public) key.
PublicKey verificationKey =
KeyFactory.getInstance(EC_KEY_TYPE)
.generatePublic(new X509EncodedKeySpec(encodedVerificationKey));
בשלב הבא, משתמשים במפתחות האלה כדי לפענח את אסימון התקינות (החלק של ה-JWE), ואז לאמת ולחלץ את החלק של ה-JWS המקונן.
Kotlin
val jwe: JsonWebEncryption =
JsonWebStructure.fromCompactSerialization(integrityToken) as JsonWebEncryption
jwe.setKey(decryptionKey)
// This also decrypts the JWE token.
val compactJws: String = jwe.getPayload()
val jws: JsonWebSignature =
JsonWebStructure.fromCompactSerialization(compactJws) as JsonWebSignature
jws.setKey(verificationKey)
// This also verifies the signature.
val payload: String = jws.getPayload()
Java
JsonWebEncryption jwe =
(JsonWebEncryption)JsonWebStructure
.fromCompactSerialization(integrityToken);
jwe.setKey(decryptionKey);
// This also decrypts the JWE token.
String compactJws = jwe.getPayload();
JsonWebSignature jws =
(JsonWebSignature) JsonWebStructure.fromCompactSerialization(compactJws);
jws.setKey(verificationKey);
// This also verifies the signature.
String payload = jws.getPayload();
המטען הייעודי (payload) שמתקבל הוא אסימון טקסט פשוט שמכיל החלטות לגבי תקינות.
תיקון בעיות שקשורות לתוצאות באמצעות הנחיה של Google Play (אופציונלי)
אחרי שהשרת מקבל את תוצאת התקינות, הוא יכול לקבוע איך להמשיך. אם התוצאה מצביעה על בעיה – למשל, אם האפליקציה לא מורשית, אם בוצעו בה שינויים או אם המכשיר נפרץ – אתם יכולים לתת למשתמשים הזדמנות לפתור את הבעיה בעצמם.
Play Integrity API מספק אפשרות להציג תיבת דו-שיח של Google Play שמבקשת מהמשתמש לבצע פעולה, למשל להוריד את הגרסה הרשמית של האפליקציה מ-Google Play.
במאמר תיבות דו-שיח לתיקון שגיאות מוסבר איך להפעיל את תיבות הדו-שיח האלה מהאפליקציה על סמך התגובה של השרת.