Convalidare i callback della verifica lato server (SSV)

Verifica manuale della verifica lato server degli annunci con premio

Di seguito sono descritti i passaggi eseguiti dalla classe RewardedAdsVerifier per verificare un SSV con premio. Sebbene gli snippet di codice inclusi siano in Java e utilizzino la libreria di terze parti Tink, puoi implementare questi passaggi nel linguaggio di tua scelta, utilizzando qualsiasi libreria di terze parti che supporti ECDSA.

Recuperare le chiavi pubbliche

Per verificare un callback di verifica lato server degli annunci con premio, devi disporre di una chiave pubblica fornita da AdMob.

È possibile recuperare un elenco di chiavi pubbliche da utilizzare per convalidare i callback di verifica lato server degli annunci con premio da l server delle chiavi di AdMob. L'elenco delle chiavi pubbliche viene fornito come rappresentazione JSON con un formato simile al seguente:

{
 "keys": [
    {
      keyId: 1916455855,
      pem: "-----BEGIN PUBLIC KEY-----\nMF...YTPcw==\n-----END PUBLIC KEY-----"
      base64: "MFkwEwYHKoZIzj0CAQYI...ltS4nzc9yjmhgVQOlmSS6unqvN9t8sqajRTPcw=="
    },
    {
      keyId: 3901585526,
      pem: "-----BEGIN PUBLIC KEY-----\nMF...aDUsw==\n-----END PUBLIC KEY-----"
      base64: "MFYwEAYHKoZIzj0CAQYF...4akdWbWDCUrMMGIV27/3/e7UuKSEonjGvaDUsw=="
    },
  ],
}

Per recuperare le chiavi pubbliche, connettiti al server delle chiavi di AdMob e scarica le chiavi. Il seguente codice esegue questa attività e salva la rappresentazione JSON delle chiavi nella variabile data.

String url = ...;
NetHttpTransport httpTransport = new NetHttpTransport.Builder().build();
HttpRequest httpRequest =
    httpTransport.createRequestFactory().buildGetRequest(new GenericUrl(url));
HttpResponse httpResponse = httpRequest.execute();
if (httpResponse.getStatusCode() != HttpStatusCodes.STATUS_CODE_OK) {
  throw new IOException("Unexpected status code = " + httpResponse.getStatusCode());
}
String data;
InputStream contentStream = httpResponse.getContent();
try {
  InputStreamReader reader = new InputStreamReader(contentStream, UTF_8);
  data = readerToString(reader);
} finally {
  contentStream.close();
}

Tieni presente che le chiavi pubbliche vengono ruotate regolarmente. Riceverai un'email per informarti di una rotazione imminente. Se memorizzi nella cache le chiavi pubbliche, devi aggiornarle al ricevimento di questa email.

Una volta recuperate, le chiavi pubbliche devono essere analizzate. Il metodo parsePublicKeysJson riportato di seguito accetta come input una stringa JSON, come l'esempio riportato sopra, e crea una mappatura dai valori key_id alle chiavi pubbliche, che vengono incapsulate come oggetti ECPublicKey dalla libreria Tink.

private static Map<Integer, ECPublicKey> parsePublicKeysJson(String publicKeysJson)
    throws GeneralSecurityException {
  Map<Integer, ECPublicKey> publicKeys = new HashMap<>();
  try {
    JSONArray keys = new JSONObject(publicKeysJson).getJSONArray("keys");
    for (int i = 0; i < keys.length(); i++) {
      JSONObject key = keys.getJSONObject(i);
      publicKeys.put(
          key.getInt("keyId"),
          EllipticCurves.getEcPublicKey(Base64.decode(key.getString("base64"))));
    }
  } catch (JSONException e) {
    throw new GeneralSecurityException("failed to extract trusted signing public keys", e);
  }
  if (publicKeys.isEmpty()) {
    throw new GeneralSecurityException("No trusted keys are available.");
  }
  return publicKeys;
}

Recuperare i contenuti da verificare

Gli ultimi due parametri di query dei callback di verifica lato server degli annunci con premio sono sempre signature e key_id, in questo ordine. I parametri di query rimanenti specificano i contenuti da verificare. Supponiamo che tu abbia configurato AdMob per inviare i callback dei premi a https://www.myserver.com/mypath. Lo snippet riportato di seguito mostra un esempio di callback di verifica lato server degli annunci con premio con i contenuti da verificare evidenziati.

https://www.myserver.com/path?ad_network=54...55&ad_unit=12345678&reward_amount=10&reward_item=coins
&timestamp=150777823&transaction_id=12...DEF&user_id=1234567&signature=ME...Z1c&key_id=1268887

Il codice riportato di seguito mostra come analizzare i contenuti da verificare da un URL di callback come array di byte UTF-8.

public static final String SIGNATURE_PARAM_NAME = "signature=";
...
URI uri;
try {
  uri = new URI(rewardUrl);
} catch (URISyntaxException ex) {
  throw new GeneralSecurityException(ex);
}
String queryString = uri.getQuery();
int i = queryString.indexOf(SIGNATURE_PARAM_NAME);
if (i == -1) {
  throw new GeneralSecurityException("needs a signature query parameter");
}
byte[] queryParamContentData =
    queryString
        .substring(0, i - 1)
        // i - 1 instead of i because of & in the query string
        .getBytes(Charset.forName("UTF-8"));

Recuperare la firma e key_id dall'URL di callback

Utilizzando il valore queryString del passaggio precedente, analizza i parametri di query signature e key_id dall'URL di callback come mostrato di seguito:

public static final String KEY_ID_PARAM_NAME = "key_id=";
...
String sigAndKeyId = queryString.substring(i);
i = sigAndKeyId.indexOf(KEY_ID_PARAM_NAME);
if (i == -1) {
  throw new GeneralSecurityException("needs a key_id query parameter");
}
String sig =
    sigAndKeyId.substring(
        SIGNATURE_PARAM_NAME.length(), i - 1 /* i - 1 instead of i because of & */);
int keyId = Integer.valueOf(sigAndKeyId.substring(i + KEY_ID_PARAM_NAME.length()));

Eseguire la verifica

Il passaggio finale consiste nel verificare i contenuti dell'URL di callback con la chiave pubblica appropriata. Prendi la mappatura restituita dal metodo parsePublicKeysJson e utilizza il parametro key_id dall'URL di callback per ottenere la chiave pubblica da quella mappatura. Quindi verifica la firma con quella chiave pubblica. Questi passaggi sono illustrati di seguito nel metodo verify.

private void verify(final byte[] dataToVerify, int keyId, final byte[] signature)
    throws GeneralSecurityException {
  Map<Integer, ECPublicKey> publicKeys = parsePublicKeysJson();
  if (publicKeys.containsKey(keyId)) {
    foundKeyId = true;
    ECPublicKey publicKey = publicKeys.get(keyId);
    EcdsaVerifyJce verifier = new EcdsaVerifyJce(publicKey, HashType.SHA256, EcdsaEncoding.DER);
    verifier.verify(signature, dataToVerify);
  } else {
    throw new GeneralSecurityException("cannot find verifying key with key ID: " + keyId);
  }
}

Se il metodo viene eseguito senza generare un'eccezione, l'URL di callback è stato verificato correttamente.

Domande frequenti

Posso memorizzare nella cache la chiave pubblica fornita dal server delle chiavi di AdMob?

Ti consigliamo di memorizzare nella cache la chiave pubblica fornita dal server delle chiavi di AdMob per ridurre il numero di operazioni necessarie per convalidare i callback di verifica lato server. Tuttavia, tieni presente che le chiavi pubbliche vengono ruotate regolarmente e non devono essere memorizzate nella cache per più di 24 ore.

Con quale frequenza vengono ruotate le chiavi pubbliche fornite dal server delle chiavi di AdMob?

Le chiavi pubbliche fornite dal server delle chiavi di AdMob vengono ruotate in base a una pianificazione variabile. Per garantire che la verifica dei callback di verifica lato server continui a funzionare come previsto, le chiavi pubbliche non devono essere memorizzate nella cache per più di 24 ore.

Cosa succede se il mio server non è raggiungibile?

Google si aspetta un codice di risposta di successo HTTP 200 OK per i callback di verifica lato server. Se il tuo server non è raggiungibile o non fornisce la risposta prevista, Google tenterà di inviare nuovamente i callback di verifica lato server fino a cinque volte a intervalli di un secondo.

Come faccio a verificare che i callback di verifica lato server provengano da Google?

Utilizza la ricerca DNS inversa per verificare che i callback di verifica lato server provengano da Google.