Klassische API-Anfrage stellen

Wenn Sie nur Standard-API-Anfragen stellen möchten, die für die meisten Entwickler geeignet sind, können Sie direkt mit Integritätsergebnissen fortfahren. Auf dieser Seite wird beschrieben, wie Sie klassische API-Anfragen für Integritätsergebnisse stellen, die auf Geräten mit Android 4.4 (API-Level 19) oder höher unterstützt werden.

Hinweise

Standard- und klassische Anfragen vergleichen

Je nach den Sicherheits- und Missbrauchsanforderungen Ihrer App können Sie Standardanfragen, klassische Anfragen oder eine Kombination aus beidem senden. Standardanfragen eignen sich für alle Apps und Spiele und können verwendet werden, um zu prüfen, ob eine Aktion oder ein Serveraufruf echt ist. Dabei wird ein Teil des Schutzes vor Replay-Angriffen und Exfiltration an Google Play delegiert. Klassische Anfragen sind teurer und Sie sind dafür verantwortlich, sie korrekt zu implementieren, um sich vor Exfiltration und bestimmten Arten von Angriffen zu schützen. Klassische Anfragen sollten seltener als Standardanfragen gestellt werden, z. B. als gelegentliche einmalige Anfrage, um zu prüfen, ob eine sehr wertvolle oder sensible Aktion echt ist.

In der folgenden Tabelle sind die wichtigsten Unterschiede zwischen den beiden Arten von Anfragen aufgeführt:

	Standard-API-Anfrage	Klassische API-Anfrage
Voraussetzungen
Erforderliches Android SDK (Mindestversion)*	Android 6.0 (API-Level 23) oder höher	Android 6.0 (API-Level 23) oder höher
Google Play-Anforderungen	Google Play Store und Google Play-Dienste	Google Play Store und Google Play-Dienste
Integrationsdetails
API-Warm-up erforderlich	✔️ (ein paar Sekunden)	❌
Typische Anfragelatenz	Einige hundert Millisekunden	Ein paar Sekunden
Mögliche Anfragehäufigkeit	Häufig (On-Demand-Prüfung für jede Aktion oder Anfrage)	Selten (einmalige Überprüfung bei Aktionen mit dem höchsten Wert oder bei besonders sensiblen Anfragen)
Zeitlimits	Die meisten Aufwärmphasen dauern weniger als 10 Sekunden, beinhalten aber einen Serveraufruf. Daher wird ein langes Zeitlimit empfohlen (z. B. 1 Minute). Anfragen zum Ergebnis erfolgen clientseitig	Die meisten Anfragen dauern weniger als 10 Sekunden, beinhalten aber einen Serveraufruf. Daher wird ein langes Zeitlimit empfohlen (z. B. 1 Minute).
Integritätsergebnis-Token
Enthält Geräte-, App- und Kontodetails	✔️	✔️
Token-Caching	Geschütztes Caching auf dem Gerät durch Google Play	Nicht empfohlen
Token mit einem Google Play-Server entschlüsseln und überprüfen	✔️	✔️
Typische Latenz bei Server-zu-Server-Anfragen zur Entschlüsselung	Zehntel Millisekunden mit einer Verfügbarkeit von 99,9 %	Zehntel Millisekunden mit einer Verfügbarkeit von 99,9 %
Token lokal in einer sicheren Serverumgebung entschlüsseln und verifizieren	❌	✔️
Token clientseitig entschlüsseln und überprüfen	❌	❌
Aktualität des Integritätsergebnisses	Teilweise automatisches Caching und Aktualisieren durch Google Play	Alle Ergebnisse werden bei jeder Anfrage neu berechnet
Zeitbeschränkungen
Anfragen pro App und Tag	Standardmäßig 10.000 (eine Erhöhung kann beantragt werden)	Standardmäßig 10.000 (eine Erhöhung kann beantragt werden)
Anfragen pro App-Instanz und Minute	Aufwärmvorgänge: 5 pro Minute Integritätstokens: Kein öffentliches Limit**	Integritätstokens: 5 pro Minute
Schutz
Schutz vor Manipulationen und ähnlichen Angriffen	Feld „requestHash“ verwenden	Feld nonce mit Inhaltsbindung basierend auf Anfragedaten verwenden
Schutz vor Replay- und ähnlichen Angriffen	Automatische Aussetzung von Maßnahmen durch Google Play	Feld nonce mit serverseitiger Logik verwenden

* Für die Play Integrity API-Bibliothek v1.4.0 und höher ist das mindestens unterstützte Android SDK für beide Anfragetypen gleich und wird durch die minSdkVersion der Bibliothek bestimmt. Für v1.3.0 und frühere Versionen ist das mindestens erforderliche Android SDK Android 5.0 (API-Level 21) für Standard-API-Anfragen und Android 4.4 (API-Level 19) für Classic API-Anfragen.

** Alle Anfragen, einschließlich derer ohne öffentliche Limits, unterliegen bei hohen Werten nicht öffentlichen defensiven Limits.

Klassische Anfragen selten stellen

Das Generieren eines Integritätstokens erfordert Zeit, Daten und Akkuleistung. Außerdem gibt es für jede App eine maximale Anzahl an klassischen Anfragen, die pro Tag gestellt werden können. Daher sollten Sie klassische Anfragen nur dann stellen, um die Echtheit der wertvollsten oder sensibelsten Aktionen zu prüfen, wenn Sie eine zusätzliche Garantie zu einer Standardanfrage wünschen. Sie sollten keine klassischen Anfragen für hochfrequente oder geringwertige Aktionen stellen. Stellen Sie keine klassischen Anfragen, wenn die App in den Vordergrund wechselt oder alle paar Minuten im Hintergrund ausgeführt wird. Vermeiden Sie es, von einer großen Anzahl von Geräten gleichzeitig aufzurufen. Eine Anwendung, die zu viele klassische Anfragen stellt, kann gedrosselt werden, um Nutzer vor fehlerhaften Implementierungen zu schützen.

Caching von Ergebnissen vermeiden

Das Caching eines Ergebnisses erhöht das Risiko von Angriffen wie Exfiltration und Replay, bei denen ein gutes Ergebnis aus einer nicht vertrauenswürdigen Umgebung wiederverwendet wird. Wenn Sie eine klassische Anfrage stellen und diese dann für die spätere Verwendung im Cache speichern möchten, sollten Sie stattdessen eine Standardanfrage bei Bedarf ausführen. Bei Standardanfragen wird ein Teil des Cachings auf dem Gerät durchgeführt. Google Play verwendet jedoch zusätzliche Schutztechniken, um das Risiko von Replay-Angriffen und Exfiltration zu minimieren.

Nonce-Feld zum Schutz klassischer Anfragen verwenden

Die Play Integrity API bietet ein Feld namens nonce, mit dem Sie Ihre App zusätzlich vor bestimmten Angriffen wie Replay- und Manipulationsangriffen schützen können. Die Play Integrity API gibt den Wert, den Sie in diesem Feld festgelegt haben, in der signierten Integritätsantwort zurück. Folgen Sie der Anleitung zum Generieren von Nonces, um Ihre App vor Angriffen zu schützen.

Achtung: Der als nonce übergebene Wert ist für Ihre App und für Google im Klartext sichtbar. Sie sollten die Daten, die Sie in diesem Feld festlegen möchten, verschlüsseln oder hashen, bevor Sie sie an die Play Integrity API übergeben.

Klassische Anfragen mit exponentiellem Backoff wiederholen

Umgebungsbedingungen wie eine instabile Internetverbindung oder ein überlastetes Gerät können dazu führen, dass die Integritätsprüfung des Geräts fehlschlägt. Dies kann dazu führen, dass für ein Gerät, das ansonsten vertrauenswürdig ist, keine Labels generiert werden. Um diese Szenarien zu minimieren, sollten Sie eine Wiederholungsoption mit exponentiellem Backoff einbeziehen.

Übersicht

Abbildung 1. Sequenzdiagramm, das das allgemeine Design der Play Integrity API zeigt.

Wenn der Nutzer eine wichtige Aktion in Ihrer App ausführt, die Sie mit einer Integritätsprüfung schützen möchten, führen Sie die folgenden Schritte aus:

1. Das serverseitige Backend Ihrer App generiert einen eindeutigen Wert und sendet ihn an die clientseitige Logik. In den verbleibenden Schritten wird diese Logik als „App“ bezeichnet.
2. Ihre App erstellt die nonce aus dem eindeutigen Wert und dem Inhalt Ihrer hochwertigen Aktion. Anschließend wird die Play Integrity API aufgerufen und die nonce übergeben.
3. Ihre App erhält ein signiertes und verschlüsseltes Ergebnis von der Play Integrity API.
4. Ihre App übergibt das signierte und verschlüsselte Ergebnis an das Backend Ihrer App.
5. Das Backend Ihrer App sendet das Ergebnis an einen Google Play-Server. Der Google Play-Server entschlüsselt und verifiziert das Ergebnis und gibt die Ergebnisse an das Backend deiner App zurück.
6. Das Backend Ihrer App bestimmt anhand der in der Token-Nutzlast enthaltenen Signale, wie weiter vorgegangen werden soll.
7. Das Backend Ihrer App sendet die Entscheidungsergebnisse an Ihre App.

Nonce generieren

Wenn Sie eine Aktion in Ihrer App mit der Play Integrity API schützen, können Sie das Feld nonce nutzen, um bestimmte Arten von Angriffen wie PITM-Angriffe (Person-in-the-Middle) und Replay-Angriffe abzuwehren. Die Play Integrity API gibt den Wert, den Sie in diesem Feld festgelegt haben, in der signierten Integritätsantwort zurück.

Der im Feld nonce festgelegte Wert muss richtig formatiert sein:

• String
• URL-sicher
• Als Base64 codiert und ohne Zeilenumbruch
• Mindestens 16 Zeichen
• Maximal 500 Zeichen.

Im Folgenden finden Sie einige gängige Möglichkeiten, das Feld nonce in der Play Integrity API zu verwenden. Wenn Sie den bestmöglichen Schutz durch die nonce erhalten möchten, können Sie die folgenden Methoden kombinieren.

Anfrage-Hash zum Schutz vor Manipulationen einfügen

Sie können den Parameter nonce in einer klassischen API-Anfrage ähnlich wie den Parameter requestHash in einer Standard-API-Anfrage verwenden, um den Inhalt einer Anfrage vor Manipulationen zu schützen.

Wenn Sie ein Integritätsergebnis anfordern, gilt Folgendes:

1. Berechnen Sie einen Digest aller kritischen Anfrageparameter (z.B. SHA256 einer stabilen Anfrageserialisierung) aus der Nutzeraktion oder Serveranfrage, die gerade stattfindet.
2. Verwenden Sie setNonce, um das Feld nonce auf den Wert des berechneten Digests festzulegen.

Wenn Sie ein Integritätsergebnis erhalten:

1. Decodieren und prüfen Sie das Integritätstoken und rufen Sie den Digest aus dem Feld nonce ab.
2. Berechnen Sie einen Digest der Anfrage auf dieselbe Weise wie in der App (z.B. SHA256 einer stabilen Anfrageserialisierung).
3. Vergleiche die App- und serverseitigen Digests. Wenn sie nicht übereinstimmen, ist die Anfrage nicht vertrauenswürdig.

Hinweis: Du solltest auch die Integritätssignale des Geräts und die App-Integrität prüfen, um sicherzustellen, dass die Ergebnisse der wichtigen Aktion von deiner nicht manipulierten App auf einem nicht manipulierten Gerät stammen.

Eindeutige Werte zum Schutz vor Replay-Angriffen einbeziehen

Damit böswillige Nutzer keine früheren Antworten der Play Integrity API wiederverwenden können, kannst du das Feld nonce verwenden, um jede Nachricht eindeutig zu identifizieren.

Wenn Sie ein Integritätsergebnis anfordern, gilt Folgendes:

1. Einen global eindeutigen Wert auf eine Weise abrufen, die böswillige Nutzer nicht vorhersagen können. Ein solcher Wert kann beispielsweise eine kryptografisch sichere Zufallszahl sein, die auf der Serverseite generiert wird, oder eine bereits vorhandene ID, z. B. eine Sitzungs- oder Transaktions-ID. Eine einfachere und weniger sichere Variante besteht darin, eine Zufallszahl auf dem Gerät zu generieren. Wir empfehlen, Werte mit mindestens 128 Bit zu erstellen.
2. Rufen Sie setNonce() auf, um das Feld nonce auf den eindeutigen Wert aus Schritt 1 festzulegen.

Wenn Sie ein Integritätsergebnis erhalten:

1. Decodieren Sie das Integritätstoken, prüfen Sie es und rufen Sie den eindeutigen Wert aus dem Feld nonce ab.
2. Wenn der Wert aus Schritt 1 auf dem Server generiert wurde, prüfen Sie, ob der empfangene eindeutige Wert einer der generierten Werte ist und ob er zum ersten Mal verwendet wird. Ihr Server muss die generierten Werte für einen angemessenen Zeitraum speichern. Wenn der empfangene eindeutige Wert bereits verwendet wurde oder nicht im Datensatz enthalten ist, lehnen Sie die Anfrage ab.
3. Wenn der eindeutige Wert auf dem Gerät generiert wurde, prüfe, ob der empfangene Wert zum ersten Mal verwendet wird. Dein Server muss die bereits verwendeten Werte für einen angemessenen Zeitraum speichern. Wenn der empfangene eindeutige Wert bereits verwendet wurde, lehnen Sie die Anfrage ab.

Beide Schutzmaßnahmen gegen Manipulationen und Replay-Angriffe kombinieren (empfohlen)

Das Feld nonce kann verwendet werden, um sowohl vor Manipulationen als auch vor Replay-Angriffen zu schützen. Generieren Sie dazu den eindeutigen Wert wie oben beschrieben und fügen Sie ihn in Ihre Anfrage ein. Berechnen Sie dann den Anfrage-Hash und achten Sie darauf, dass der eindeutige Wert im Hash enthalten ist. Eine Implementierung, die beide Ansätze kombiniert, sieht so aus:

Wenn Sie ein Integritätsergebnis anfordern, gilt Folgendes:

1. Der Nutzer initiiert die Aktion mit hohem Wert.
2. Rufen Sie einen eindeutigen Wert für diese Aktion ab, wie im Abschnitt Eindeutige Werte zum Schutz vor Replay-Angriffen einfügen beschrieben.
3. Bereiten Sie eine Nachricht vor, die Sie schützen möchten. Fügen Sie den eindeutigen Wert aus Schritt 2 in die Nachricht ein.
4. Ihre App berechnet einen Digest der Nachricht, die sie schützen möchte, wie im Abschnitt Anfrage-Hash zum Schutz vor Manipulationen einfügen beschrieben. Da die Nachricht den eindeutigen Wert enthält, ist der eindeutige Wert Teil des Hashs.
5. Verwenden Sie setNonce(), um das Feld nonce auf den berechneten Digest aus dem vorherigen Schritt festzulegen.

Wenn Sie ein Integritätsergebnis erhalten:

1. Eindeutigen Wert aus der Anfrage abrufen
2. Decodieren und prüfen Sie das Integritätstoken und rufen Sie den Digest aus dem Feld nonce ab.
3. Wie im Abschnitt Anfrage-Hash zum Schutz vor Manipulationen einfügen beschrieben, berechnen Sie den Digest auf der Serverseite neu und prüfen Sie, ob er mit dem Digest aus dem Integritäts-Token übereinstimmt.
4. Prüfen Sie die Gültigkeit des eindeutigen Werts, wie im Abschnitt Eindeutige Werte zum Schutz vor Replay-Angriffen einfügen beschrieben.

Das folgende Sequenzdiagramm veranschaulicht diese Schritte mit einem serverseitigen nonce:

Abbildung 2. Sequenzdiagramm, das zeigt, wie Sie sich sowohl vor Manipulationen als auch vor Replay-Angriffen schützen können.

Integritätsergebnis anfordern

Nachdem Sie ein nonce generiert haben, können Sie ein Integritätsergebnis von Google Play anfordern. Führen Sie dazu folgende Schritte aus:

1. Erstellen Sie ein IntegrityManager, wie in den folgenden Beispielen gezeigt.
2. Erstellen Sie ein IntegrityTokenRequest-Objekt und geben Sie die nonce über die Methode setNonce() im zugehörigen Builder an. Apps, die ausschließlich außerhalb von Google Play vertrieben werden, und SDKs müssen ihre Google Cloud-Projektnummer ebenfalls über die Methode setCloudProjectNumber() angeben. Apps bei Google Play sind mit einem Cloud-Projekt in der Play Console verknüpft. Die Cloud-Projektnummer muss in der Anfrage nicht angegeben werden.
3. Verwenden Sie den Manager, um requestIntegrityToken() aufzurufen und die IntegrityTokenRequest anzugeben. Achtung: nonce-Werte werden unverändert an die Systeme von Google übergeben. Sie sollten daher keine personenidentifizierbaren Informationen oder andere vertrauliche Daten direkt oder indirekt in die nonce aufnehmen.

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);
}

Nativ

/// 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();

Integritätsergebnis entschlüsseln und prüfen

Wenn Sie ein Integritätsergebnis anfordern, stellt die Play Integrity API ein signiertes Antworttoken bereit. Die nonce, die Sie in Ihre Anfrage aufnehmen, wird Teil des Antworttokens.

Token format

Das Token ist ein verschachteltes JSON Web Token (JWT), d. h. eine JSON Web Encryption (JWE) einer JSON Web Signature (JWS). Die JWE- und JWS-Komponenten werden mithilfe der kompakten Serialisierung dargestellt.

Die Verschlüsselungs-/Signaturalgorithmen werden von verschiedenen JWT-Implementierungen gut unterstützt:

• JWE verwendet A256KW für alg und A256GCM für enc.

• JWS verwendet ES256.

Auf Google-Servern entschlüsseln und verifizieren (empfohlen)

Mit der Play Integrity API können Sie das Integritätsergebnis auf den Google-Servern entschlüsseln und überprüfen, was die Sicherheit Ihrer App erhöht. Führen Sie dazu die folgenden Schritte aus:

1. Erstellen Sie ein Dienstkonto in dem Google Cloud-Projekt, das mit Ihrer App verknüpft ist.

2. Rufen Sie auf dem Server Ihrer App das Zugriffstoken aus den Anmeldedaten Ihres Dienstkontos mit dem Bereich playintegrity ab und stellen Sie die folgende Anfrage:

   playintegrity.googleapis.com/v1/PACKAGE_NAME:decodeIntegrityToken -d \
   '{ "integrity_token": "INTEGRITY_TOKEN" }'

   Hinweis: Für den Zugriff auf die REST-Schnittstelle der API können Sie die Google API-Clientbibliothek verwenden, die in vielen Programmiersprachen verfügbar ist, einschließlich Java.

3. Lesen Sie die JSON-Antwort.

Lokal entschlüsseln und verifizieren

Hinweis: Zum Schutz Ihrer App wird empfohlen, Google Play die Verwaltung der Antwortverschlüsselung für Ihre App zu erlauben.

Wenn Sie Ihre Schlüssel zur Verschlüsselung von Antworten selbst verwalten und herunterladen, können Sie das zurückgegebene Token in Ihrer eigenen sicheren Serverumgebung entschlüsseln und verifizieren. Sie können das zurückgegebene Token mit der Methode IntegrityTokenResponse#token() abrufen.

Im folgenden Beispiel wird gezeigt, wie der AES-Schlüssel und der DER-codierte öffentliche EC-Schlüssel für die Signaturüberprüfung aus der Play Console in sprachspezifische Schlüssel (in unserem Fall die Programmiersprache Java) im Backend der App decodiert werden. Beachten Sie, dass die Schlüssel mit Standard-Flags base64-codiert sind.

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));

Verwenden Sie diese Schlüssel dann, um zuerst das Integritätstoken (JWE-Teil) zu entschlüsseln und dann den verschachtelten JWS-Teil zu überprüfen und zu extrahieren.

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();

Die resultierende Nutzlast ist ein Nur-Text-Token, das Integritätsergebnisse enthält.

Probleme mit dem Ergebnis über eine Google Play-Aufforderung beheben (optional)

Nachdem Ihr Server ein Integritätsergebnis erhalten hat, kann er entscheiden, wie er weiter vorgeht. Wenn das Ergebnis auf ein Problem hinweist, z. B. dass die App nicht lizenziert ist, manipuliert wurde oder das Gerät manipuliert wurde, kannst du Nutzern die Möglichkeit geben, das Problem selbst zu beheben.

Die Play Integrity API bietet die Möglichkeit, ein Google Play-Dialogfeld einzublenden, in dem der Nutzer aufgefordert wird, Maßnahmen zu ergreifen, z. B. die offizielle Version deiner App bei Google Play herunterzuladen.

Informationen dazu, wie Sie diese Dialogfelder basierend auf der Antwort des Servers in Ihrer App auslösen, finden Sie unter Dialogfelder zur Problembehebung.

Tipp: Nutzer können jederzeit in der Google Play Store App den Play Protect-Zertifizierungsstatus ihres Geräts prüfen und Probleme beheben. Du kannst deine Nutzer auf diese Supportseite verweisen, wenn sie Hilfe bei der Behebung eines Problems mit der Geräteintegrität benötigen.