Rilevare e prevenire attività fraudolente relative all'account nelle applicazioni mobile

Questo documento mostra come utilizzare reCAPTCHA Account Defender per rilevare e prevenire attività fraudolente correlate all'account nelle applicazioni mobile.

reCAPTCHA ti aiuta a proteggere le azioni critiche, come l'accesso e il pagamento. Tuttavia, esistono molte forme sottili di abuso dell'account che possono essere rilevate osservando il comportamento di un utente specifico su un'applicazione mobile per un periodo di tempo. reCAPTCHA Account Defender aiuta a identificare questi tipi di abusi sottili creando un modello specifico per il sito per la tua applicazione mobile per rilevare una tendenza di comportamento sospetto o un cambiamento nell'attività. Utilizzando il modello specifico per il sito, reCAPTCHA account defender ti aiuta a rilevare quanto segue:

• Attività sospette
• Account con comportamenti simili
• Richieste provenienti da dispositivi contrassegnati come attendibili per utenti specifici

In base all'analisi dell'account defender di reCAPTCHA e del modello specifico per il sito, puoi intraprendere le seguenti azioni:

• Limitare o disattivare gli account fraudolenti.
• Prevenire i tentativi di violazione dell'account.
• Mitiga le violazioni degli account.
• Concedi l'accesso solo alle richieste provenienti da account utente legittimi.
• Ridurre le difficoltà per gli utenti che accedono da uno dei loro dispositivi attendibili.

Prima di iniziare

1. reCAPTCHA Account Defender per le applicazioni mobile è accessibile dopo aver attivato una revisione della sicurezza automatica aggiungendo un account di fatturazione al progetto. Aggiungi un account di fatturazione al tuo progetto per eseguire l'onboarding del tuo sito a questa funzionalità.
2. Prepara l'ambiente per reCAPTCHA.
3. Crea una chiave basata sul punteggio.

Configurare l'applicazione mobile per reCAPTCHA Account Defender

reCAPTCHA account defender richiede una comprensione completa delle attività dell'account per consentire un rilevamento efficace. Per iniziare a inviare le attività correlate all'account a reCAPTCHA Account Defender e per creare e migliorare il tuo modello specifico per il sito, procedi nel seguente modo:

1. Integra reCAPTCHA con la tua applicazione mobile.

   • Per le app per Android, consulta Integrare reCAPTCHA con le app per Android.
   • Per le app per iOS, consulta Integrare reCAPTCHA con le app per iOS.
2. Report sulle azioni utente critiche.
3. Valutare gli eventi utente critici.
4. Annota gli eventi utente per ottimizzare il modello specifico per il sito.

Report sulle azioni utente critiche

Per rilevare pattern di attività sospette e comprendere meglio i pattern di attività tipici sul tuo sito, reCAPTCHA Account Defender ha bisogno delle informazioni sulle azioni utente critiche. Per ogni azione della tua app protetta tramite reCAPTCHA, chiama il metodo execute() con RecaptchaAction. Per ulteriori informazioni su execute() e RecaptchaAction, consulta quanto segue:

• Android: execute() e RecaptchaAction.
• iOS: execute() e RecaptchaAction.

reCAPTCHA fornisce un insieme integrato di azioni e, se necessario, puoi creare azioni personalizzate.

La seguente tabella elenca i nomi delle azioni che puoi utilizzare quando segnali le azioni utente fondamentali.

Valutare gli eventi utente critici

Quando chiami execute() in un'azione utente, viene generato un token. Per gli eventi utente critici, come accessi, registrazioni e azioni degli utenti autenticati riusciti e non riusciti, crea una valutazione per valutare i risultati della chiamata execute(). La valutazione fornisce un giudizio sul rischio, che puoi utilizzare per decidere come gestire attività potenzialmente fraudolente. Alcune delle azioni che puoi intraprendere sono il blocco di richieste sospette, la verifica di accessi rischiosi e l'indagine sugli account di interesse.

reCAPTCHA Account Defender richiede di fornire un identificatore di account stabile per attribuire l&#39attività utentel'utente, ad esempio richieste di accesso, richieste di accesso e richieste di registrazione, a un account specifico. In questo modo, reCAPTCHA Account Defender può comprendere i pattern di attività utente e creare un modello di attività per ogni account per rilevare meglio il traffico anomalo e illecito.

Scegli un identificatore di account stabile accountId che non venga modificato spesso dall'utente e forniscilo alla valutazione nel metodo projects.assessments.create. Questo identificatore di account stabile deve avere lo stesso valore per tutti gli eventi correlati allo stesso utente. Puoi fornire i seguenti elementi come identificatore dell'account:

Oltre a fornire un identificatore di account stabile per tutte le richieste correlate all'account, puoi fornire identificatori di account aggiuntivi, potenzialmente non stabili, per alcune richieste specifiche. Gli identificatori dell'account specifici per il contesto forniti in aggiunta alla guida accountId consentono all'account defender di reCAPTCHA di comprendere meglio l'attività utente e rilevare i tentativi di compromissione dell'account per proteggere gli account utente. Quando fornisci identificatori aggiuntivi, reCAPTCHA utilizza queste informazioni per migliorare la protezione dei tuoi account utente in base a modelli cross-site contrassegnando gli identificatori di account illeciti e utilizzando la conoscenza di pattern di abuso cross-site correlati a questi identificatori. Ad esempio, puoi fornire quanto segue:

• Il nome utente, l'indirizzo email o il numero di telefono utilizzato come handle di accesso per le richieste di accesso

• L'indirizzo email o il numero di telefono verificato per una richiesta di autenticazione a più fattori

• Un indirizzo email o un numero di telefono (principale o secondario) fornito dall'utente durante una richiesta di aggiornamento dell'account

• Gli indirizzi email e i numeri di telefono forniti dall'utente durante una richiesta di registrazione

Aggiungi l'identificatore di account stabile scelto al parametro accountId nel metodo projects.assessments.create per tutte le richieste relative all'account. (Facoltativo) fornisci identificatori di account aggiuntivi per le richieste pertinenti utilizzando il campo userIds nella valutazione.

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

• PROJECT_ID: il tuo ID progetto Google Cloud
• TOKEN: token restituito dalla chiamata execute()
• KEY_ID: chiave reCAPTCHA associata all'app
• ACCOUNT_ID: l'identificatore associato in modo univoco all'account utente per un account utente alla tua app
• EMAIL_ADDRESS: (Facoltativo). Un indirizzo email associato a questa richiesta, se presente
• PHONE_NUMBER: (Facoltativo). Un numero di telefono associato a questa richiesta, se presente
• USERNAME: (Facoltativo). Un nome utente associato a questa richiesta, se presente

Metodo HTTP e URL:

POST https://recaptchaenterprise.googleapis.com/v1/projects/PROJECT_ID/assessments

Corpo JSON della richiesta:

{
  "event": {
    "token": "TOKEN",
    "siteKey": "KEY_ID",
    "userInfo": {
      "accountId": "ACCOUNT_ID",
      "userIds": [
        {
          "email": "EMAIL_ADDRESS"
        },
        {
          "phoneNumber": "PHONE_NUMBER"
        },
        {
          "username": "USERNAME"
        }
      ]
    }
  }
}

Per inviare la richiesta, scegli una di queste opzioni:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://recaptchaenterprise.googleapis.com/v1/projects/PROJECT_ID/assessments"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://recaptchaenterprise.googleapis.com/v1/projects/PROJECT_ID/assessments" | Select-Object -Expand Content

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "tokenProperties": {
    "valid": true,
    "androidPackageName": "com.example.app" or "iosBundleId": "com.example.app",
    "action": "login",
    "createTime": "2019-03-28T12:24:17.894Z"
   },
  "riskAnalysis": {
    "score": 0.6,
  },
 "event": {
    "token": "TOKEN",
    "siteKey": "KEY",
    "userInfo": {
      "accountId": "ACCOUNT_ID"
    }
  },
  "name": "projects/PROJECT_NUMBER/assessments/b6ac310000000000",
  "accountDefenderAssessment": {
    "labels": ["SUSPICIOUS_LOGIN_ACTIVITY"]
  }
}

Esempio di codice

import com.google.cloud.recaptchaenterprise.v1.RecaptchaEnterpriseServiceClient;
import com.google.protobuf.ByteString;
import com.google.recaptchaenterprise.v1.AccountDefenderAssessment.AccountDefenderLabel;
import com.google.recaptchaenterprise.v1.Assessment;
import com.google.recaptchaenterprise.v1.CreateAssessmentRequest;
import com.google.recaptchaenterprise.v1.Event;
import com.google.recaptchaenterprise.v1.ProjectName;
import com.google.recaptchaenterprise.v1.RiskAnalysis.ClassificationReason;
import com.google.recaptchaenterprise.v1.TokenProperties;
import com.google.recaptchaenterprise.v1.UserId;
import com.google.recaptchaenterprise.v1.UserInfo;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.List;
import java.util.UUID;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

public class AccountDefenderAssessment {

  public static void main(String[] args)
      throws IOException, NoSuchAlgorithmException, InvalidKeyException {
    // TODO(developer): Replace these variables before running the sample.
    // projectId: Google Cloud Project ID
    String projectId = "project-id";

    // recaptchaSiteKey: Site key obtained by registering a domain/app to use recaptcha
    // services.
    String recaptchaSiteKey = "recaptcha-site-key";

    // token: The token obtained from the client on passing the recaptchaSiteKey.
    // To get the token, integrate the recaptchaSiteKey with frontend. See,
    // https://cloud.google.com/recaptcha-enterprise/docs/instrument-web-pages#frontend_integration_score
    String token = "recaptcha-token";

    // recaptchaAction: The action name corresponding to the token.
    String recaptchaAction = "recaptcha-action";

    // Unique ID of the user, such as email, customer ID, etc.
    String accountId = "default" + UUID.randomUUID().toString().split("-")[0];

    // User phone number
    String phoneNumber = "555-987-XXXX";

    // User email address
    String emailAddress = "john.doe@example.com";

    accountDefenderAssessment(projectId, recaptchaSiteKey, token, recaptchaAction, accountId, phoneNumber, emailAddress);
  }

  /**
   * This assessment detects account takeovers. See,
   * https://cloud.google.com/recaptcha-enterprise/docs/account-takeovers The input is the hashed
   * account id. Result tells if the action represents an account takeover. You can optionally
   * trigger a Multi-Factor Authentication based on the result.
   */
  public static void accountDefenderAssessment(
      String projectId,
      String recaptchaSiteKey,
      String token,
      String recaptchaAction,
      String accountId,
      String phoneNumber,
      String emailAddress)
      throws IOException {
    try (RecaptchaEnterpriseServiceClient client = RecaptchaEnterpriseServiceClient.create()) {

      // Set the properties of the event to be tracked.
      Event.Builder eventBuilder =
          Event.newBuilder()
              .setSiteKey(recaptchaSiteKey)
              .setToken(token);

      // Set the account id, email address and phone number (of the user).
      eventBuilder.setUserInfo(
        UserInfo.newBuilder()
          .setAccountId(accountId)
          .addUserIds(UserId.newBuilder().setEmail(emailAddress))
          .addUserIds(UserId.newBuilder().setPhoneNumber(phoneNumber)));

      Event event = eventBuilder.build();

      // Build the assessment request.
      CreateAssessmentRequest createAssessmentRequest =
          CreateAssessmentRequest.newBuilder()
              .setParent(ProjectName.of(projectId).toString())
              .setAssessment(Assessment.newBuilder().setEvent(event).build())
              .build();

      Assessment response = client.createAssessment(createAssessmentRequest);

      // Check integrity of the response token.
      if (!checkTokenIntegrity(response.getTokenProperties(), recaptchaAction)) {
        return;
      }

      // Get the reason(s) and the reCAPTCHA risk score.
      // For more information on interpreting the assessment,
      // see: https://cloud.google.com/recaptcha-enterprise/docs/interpret-assessment
      for (ClassificationReason reason : response.getRiskAnalysis().getReasonsList()) {
        System.out.println(reason);
      }
      float recaptchaScore = response.getRiskAnalysis().getScore();
      System.out.println("The reCAPTCHA score is: " + recaptchaScore);
      String assessmentName = response.getName();
      System.out.println(
          "Assessment name: " + assessmentName.substring(assessmentName.lastIndexOf("/") + 1));

      // Get the Account Defender result.
      com.google.recaptchaenterprise.v1.AccountDefenderAssessment accountDefenderAssessment =
          response.getAccountDefenderAssessment();
      System.out.println(accountDefenderAssessment);

      // Get Account Defender label.
      List<AccountDefenderLabel> defenderResult =
          response.getAccountDefenderAssessment().getLabelsList();
      // Based on the result, can you choose next steps.
      // If the 'defenderResult' field is empty, it indicates that Account Defender did not have
      // anything to add to the score.
      // Few result labels: ACCOUNT_DEFENDER_LABEL_UNSPECIFIED, PROFILE_MATCH,
      // SUSPICIOUS_LOGIN_ACTIVITY, SUSPICIOUS_ACCOUNT_CREATION, RELATED_ACCOUNTS_NUMBER_HIGH.
      // For more information on interpreting the assessment, see:
      // https://cloud.google.com/recaptcha-enterprise/docs/account-defender#interpret-assessment-details
      System.out.println("Account Defender Assessment Result: " + defenderResult);
    }
  }

  private static boolean checkTokenIntegrity(
      TokenProperties tokenProperties, String recaptchaAction) {
    // Check if the token is valid.
    if (!tokenProperties.getValid()) {
      System.out.println(
          "The Account Defender Assessment call failed because the token was: "
              + tokenProperties.getInvalidReason().name());
      return false;
    }

    // Check if the expected action was executed.
    if (!tokenProperties.getAction().equals(recaptchaAction)) {
      System.out.printf(
          "The action attribute in the reCAPTCHA tag '%s' does not match "
              + "the action '%s' you are expecting to score",
          tokenProperties.getAction(), recaptchaAction);
      return false;
    }
    return true;
  }
}

Interpretare il verdetto sul rischio degli eventi utente critici

Quando crei una valutazione con Account Defender abilitato, Account Defender restituisce accountDefenderAssessment come parte della risposta di valutazione. Il valore di accountDefenderAssessment ti aiuta a valutare se l'attività utente è legittima o fraudolenta. Restituisce anche un ID valutazione che devi utilizzare per annotare gli eventi utente.

Il seguente esempio è una risposta JSON di esempio:

{
  "tokenProperties": {
    "valid": true,
    "androidPackageName": "com.example.app" or "iosBundleId": "com.example.app",
    "action": "login",
    "createTime": "2019-03-28T12:24:17.894Z"
   },
  "riskAnalysis": {
    "score": 0.6,
  },
 "event": {
    "token": "TOKEN",
    "siteKey": "KEY_ID",
    "expectedAction": "USER_ACTION"
  },
  "name": "projects/PROJECT_ID/assessments/b6ac310000000000X",
  "accountDefenderAssessment": {
    labels: ["SUSPICIOUS_LOGIN_ACTIVITY"]
  }
}

Il campo accountDefenderAssessment può contenere uno qualsiasi dei seguenti valori:

Annotare gli eventi per ottimizzare il modello specifico per il sito

Per fornire maggiori informazioni a reCAPTCHA Account Defender e migliorare il modello di rilevamento specifico per il sito, devi annotare gli eventi che hai valutato creando valutazioni.

Per annotare una valutazione, invia una richiesta al metodo projects.assessments.annotate con l'ID valutazione. Nel corpo della richiesta, includi etichette che forniscono informazioni aggiuntive su un evento descritto nella valutazione.

Per annotare un test:

1. Determina le informazioni e le etichette da aggiungere nel corpo JSON della richiesta a seconda del caso d'uso.

   La tabella seguente elenca le etichette e i valori che puoi utilizzare per annotare gli eventi:

   Etichetta	Descrizione	Esempio di richiesta
   reasons	Obbligatorio. Un'etichetta per supportare le tue valutazioni. Fornisci i dettagli degli eventi in tempo reale nell'etichetta reasons in pochi secondi o minuti dopo l'evento perché influiscono sul rilevamento in tempo reale. Per l'elenco dei valori possibili, vedi Valori dei motivi. Esempio: per rilevare le compromissioni dell'account, annota se la password inserita era corretta con i valori CORRECT_PASSWORD o INCORRECT_PASSWORD. Se hai implementato la tua autenticazione a più fattori, puoi aggiungere i seguenti valori: INITIATED_TWO_FACTOR e PASSED_TWO_FACTOR o FAILED_TWO_FACTOR.	{ "reasons": ["INCORRECT_PASSWORD"] }
   annotation	Facoltativo. Un'etichetta per indicare la legittimità delle valutazioni. Fornisci informazioni sugli eventi di accesso e registrazione per convalidare o correggere le tue valutazioni del rischio nell'etichetta annotation. Valori possibili: LEGITIMATE o FRAUDULENT. Puoi inviare queste informazioni in qualsiasi momento o nell'ambito di un job batch. Tuttavia, ti consigliamo di inviare queste informazioni pochi secondi o minuti dopo l'evento, perché influiscono sul rilevamento in tempo reale.	{ "annotation": "LEGITIMATE" }
   accountId	Facoltativo. Un'etichetta per associare un ID account a un evento. Se hai creato una valutazione senza un ID account, utilizza questa etichetta per fornire l'ID account di un evento ogni volta che è disponibile.	{ "accountId": "ACCOUNT_ID" }

2. Crea una richiesta di annotazione con le etichette appropriate.

   Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

   • ASSESSMENT_ID: valore del campo name restituito dalla chiamata projects.assessments.create.
   • ANNOTATION: (Facoltativo). Un'etichetta per indicare se la valutazione è legittima o fraudolenta.
   • REASONS: (Facoltativo). Motivi a sostegno dell'annotazione. Per l'elenco dei valori possibili, vedi valori di reasons.
   • ACCOUNT_ID: facoltativo. L'identificatore associato in modo univoco all'account utente nella tua app.

   Per ulteriori informazioni, consulta la sezione Etichette per le annotazioni.

   Metodo HTTP e URL:

   POST https://recaptchaenterprise.googleapis.com/v1/ASSESSMENT_ID:annotate

   Corpo JSON della richiesta:

   {
     "annotation": ANNOTATION,
     "reasons": REASONS,
     "accountId": ACCOUNT_ID
   }
   

   Per inviare la richiesta, scegli una di queste opzioni:

   curl

   Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

   curl -X POST \
        -H "Authorization: Bearer $(gcloud auth print-access-token)" \
        -H "Content-Type: application/json; charset=utf-8" \
        -d @request.json \
        "https://recaptchaenterprise.googleapis.com/v1/ASSESSMENT_ID:annotate"

   PowerShell

   Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

   $cred = gcloud auth print-access-token
   $headers = @{ "Authorization" = "Bearer $cred" }
   
   Invoke-WebRequest `
       -Method POST `
       -Headers $headers `
       -ContentType: "application/json; charset=utf-8" `
       -InFile request.json `
       -Uri "https://recaptchaenterprise.googleapis.com/v1/ASSESSMENT_ID:annotate" | Select-Object -Expand Content

   Dovresti ricevere un codice di stato riuscito (2xx) e una risposta vuota.

Esempio di codice

import com.google.cloud.recaptchaenterprise.v1.RecaptchaEnterpriseServiceClient;
import com.google.protobuf.ByteString;
import com.google.recaptchaenterprise.v1.AnnotateAssessmentRequest;
import com.google.recaptchaenterprise.v1.AnnotateAssessmentRequest.Annotation;
import com.google.recaptchaenterprise.v1.AnnotateAssessmentRequest.Reason;
import com.google.recaptchaenterprise.v1.AnnotateAssessmentResponse;
import com.google.recaptchaenterprise.v1.AssessmentName;
import java.io.IOException;
import java.security.NoSuchAlgorithmException;
import java.util.UUID;

public class AnnotateAccountDefenderAssessment {

  public static void main(String[] args) throws IOException, NoSuchAlgorithmException {
    // TODO(developer): Replace these variables before running the sample.
    // projectID: GCloud Project id.
    String projectID = "project-id";

    // assessmentId: Value of the 'name' field returned from the CreateAssessment call.
    String assessmentId = "account-defender-assessment-id";

    // accountId: Set the accountId corresponding to the assessment id.
    String accountId = "default" + UUID.randomUUID().toString().split("-")[0];

    annotateAssessment(projectID, assessmentId, accountId);
  }

  /**
   * Pre-requisite: Create an assessment before annotating. Annotate an assessment to provide
   * feedback on the correctness of recaptcha prediction.
   */
  public static void annotateAssessment(
      String projectID, String assessmentId, String accountId) throws IOException {

    try (RecaptchaEnterpriseServiceClient client = RecaptchaEnterpriseServiceClient.create()) {
      // Build the annotation request.
      // For more info on when/how to annotate, see:
      // https://cloud.google.com/recaptcha-enterprise/docs/annotate-assessment#when_to_annotate
      AnnotateAssessmentRequest annotateAssessmentRequest =
          AnnotateAssessmentRequest.newBuilder()
              .setName(AssessmentName.of(projectID, assessmentId).toString())
              .setAnnotation(Annotation.LEGITIMATE)
              .addReasons(Reason.PASSED_TWO_FACTOR)
              .setAccountId(accountId)
              .build();

      // Empty response is sent back.
      AnnotateAssessmentResponse response = client.annotateAssessment(annotateAssessmentRequest);
      System.out.println("Annotated response sent successfully ! " + response);
    }
  }
}

Abilitare reCAPTCHA Account Defender

Dopo aver configurato l'applicazione mobile per reCAPTCHA Account Defender, puoi attivarlo.

1. Nella console Google Cloud , vai alla pagina reCAPTCHA.

   Vai a reCAPTCHA

2. Verifica che il nome del tuo progetto venga visualizzato nel selettore di risorse nella parte superiore della pagina.

   Se non vedi il nome del tuo progetto, fai clic sul selettore di risorse, poi seleziona il tuo progetto.

3. Fai clic su settingsImpostazioni.

4. Nel riquadro Account Defender, fai clic su Configura.

   

5. Nella finestra di dialogo Configura Account Defender, fai clic su Attiva, poi su Salva.

   

L'abilitazione di reCAPTCHA Account Defender potrebbe richiedere alcune ore per la propagazione ai nostri sistemi. Una volta attivata la funzionalità nei nostri sistemi, dovresti iniziare a ricevere risposte relative ad Account Defender nell'ambito delle valutazioni.

Passaggi successivi

• Per scoprire di più su altre funzionalità di protezione dell'account, vedi Funzionalità di protezione degli account utente.