Rilevare e impedire attività fraudolente relative all'account

Questo documento mostra come utilizzare l'account defender dell'account reCAPTCHA Enterprise per rilevare e impedire attività fraudolente relative all'account.

reCAPTCHA Enterprise ti aiuta a proteggere le azioni critiche, come l'accesso e il pagamento. Tuttavia, esistono diverse forme sottili di abuso dell'account che possono essere rilevate osservando il comportamento di un utente specifico sul sito per un determinato periodo di tempo. Il dispositivo di difesa degli account reCAPTCHA Enterprise contribuisce a identificare questi tipi di uso illecito creando un modello specifico per il tuo sito web al fine di rilevare una tendenza di comportamento sospetto o un cambiamento di attività. Usando il modello specifico per il sito, reCAPTCHA Enterprise defender consente di rilevare quanto segue:

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

Sulla base dell'analisi dell'account defender di reCAPTCHA Enterprise e del modello specifico per il sito, puoi eseguire le seguenti azioni:

  • Limitare o disattivare gli account fraudolenti.
  • Impedisci i tentativi di violazione degli account.
  • Mitigare i tentativi di violazione dell'account riusciti.
  • Concedere l'accesso solo alle richieste provenienti da account utente legittimi.
  • Riduci le difficoltà per gli utenti che accedono da uno dei loro dispositivi attendibili.

Prima di iniziare

  1. Scegli il metodo migliore per configurare reCAPTCHA Enterprise nel tuo ambiente e completa la configurazione.
  2. Crea una chiave del sito basata sul punteggio.

Configura le tue pagine web per l'account defender di reCAPTCHA Enterprise

Account defender reCAPTCHA Enterprise richiede una comprensione completa delle attività dell'account per consentire un rilevamento efficace. Per iniziare a fornire attività relative agli account al framework di difesa degli account reCAPTCHA Enterprise e per creare e migliorare il tuo modello specifico per il sito, segui questi passaggi:

  1. Abilita la raccolta dei dati di telemetria orizzontale.
  2. Generare report sulle azioni critiche degli utenti.
  3. Valuta gli eventi utente critici.
  4. Annota gli eventi utente per ottimizzare il modello specifico per il sito.

Attiva la raccolta dei dati di telemetria orizzontale

L'account defender reCAPTCHA Enterprise richiede una visione completa delle azioni dell'utente, ad esempio se l'utente ha eseguito l'accesso o se sta eseguendo l'accesso. Per attivare la raccolta passiva di dati di telemetria orizzontale da parte dell'account defender reCAPTCHA Enterprise, carica lo script JavaScript di reCAPTCHA Enterprise con la chiave del sito basata sul punteggio che hai creato in background di tutte le pagine web che fanno parte del flusso di lavoro degli utenti.

L'esempio seguente mostra come caricare lo script JavaScript di reCAPTCHA Enterprise in una pagina web.

    <head>
    <script src="https://www.google.com/recaptcha/enterprise.js?render=site_key"></script>
    ....
    </head>

Report sulle azioni fondamentali degli utenti

Per rilevare pattern di attività sospetti e comprendere meglio i pattern di attività tipici sul tuo sito, il difensore dell'account reCAPTCHA Enterprise ha bisogno di informazioni sulle azioni critiche degli utenti. Pertanto, segnala le azioni critiche degli utenti nelle pagine web richiamando grecaptcha.enterprise.execute() su tali azioni.

Ti consigliamo di segnalare tutte le azioni critiche degli utenti perché contribuiscono a una raccolta di indicatori aggiuntiva. Per ogni azione dell'utente che vuoi segnalare, sostituisci il valore del parametro action di grecaptcha.enterprise.execute() con un nome di azione che descrive l'azione dell'utente.

La seguente tabella elenca i nomi delle azioni che puoi utilizzare durante la segnalazione delle azioni utente critiche.

Nome azione Evento o azione dell'utente avviati dall'utente
LOGIN Accedi al sito web.
REGISTRATION Registrazione sul sito web.
SECURITY_QUESTION_CHANGE Richiedi di modificare la domanda di sicurezza.
PASSWORD_RESET Richiedi di reimpostare la password.
PHONE_NUMBER_UPDATE Richiedi di aggiornare il numero di telefono.
EMAIL_UPDATE Richiedi di aggiornare l'indirizzo email.
ACCOUNT_UPDATE Richiedi di aggiornare le informazioni relative all'account, ad esempio i dati di contatto.
TRIGGER_MFA Azione che attiva una verifica MFA.
REDEEM_CODE Richiedi di utilizzare codice.
LIST_PAYMENT_METHODS Recupera l'elenco dei metodi di pagamento.

L'esempio seguente mostra come chiamare grecaptcha.enterprise.execute() con un aggiornamento del numero di telefono:

    <script>
    function onClick(e) {
      e.preventDefault();
      grecaptcha.enterprise.ready(async () => {
        const token = await grecaptcha.enterprise.execute('site_key', {action: 'PHONE_NUMBER_UPDATE'});
      });
    }
    </script>

Valutare gli eventi utente critici

Quando chiami grecaptcha.enterprise.execute() su un'azione dell'utente, viene generato un token. Per gli eventi utente critici, ad esempio accessi riusciti e non riusciti, registrazioni e azioni degli utenti che hanno eseguito l'accesso, crea una valutazione con un identificatore dell'account per valutare i risultati della chiamata grecaptcha.enterprise.execute(). Fornire un identificatore account (identificatore di account opaco) per ogni evento utente che ha origine o scelto come target un account consente alle richieste di attributi Account defender di reCAPTCHA Enterprise di creare account per proteggere meglio la tua piattaforma e i tuoi utenti da comportamenti illeciti.

La valutazione fornisce un esito del rischio basato su cui puoi prendere una decisione su come gestire le potenziali attività fraudolente. Alcune delle azioni che puoi intraprendere sono il blocco di richieste sospette, la verifica di accessi rischiosi, la verifica degli account di interesse e la rimozione delle difficoltà per gli utenti legittimi.

Per creare una valutazione utilizzando un identificatore dell'account opaco:

  1. Per generare un identificatore dell'account opaco hashedAccountId associato in modo univoco all'account utente a cui è correlata la richiesta in entrata:

    1. Scegli un identificatore dell'account stabile che non può essere modificato dall'utente, di solito un ID utente, un nome utente o un indirizzo email.

    2. Convertilo in un identificatore opaco utilizzando la crittografia (consigliata) o l'hashing:

      • Crittografia (consigliata): cripta l'identificatore dell'account utilizzando un metodo di crittografia deterministico che produce un testo crittografato stabile. Per istruzioni dettagliate, vedi Criptare i dati in modo deterministico. Quando scegli la crittografia simmetrica rispetto all'hashing, non è necessario mantenere una mappatura tra gli identificatori utente e gli identificatori utente opachi corrispondenti. Decripta gli identificatori opachi che potrebbero essere restituiti per trasformarli in identificatori utente.
      • hashing: ti consigliamo di eseguire l'hashing dell'account account utilizzando il metodo SHA256-HMAC con un salt personalizzato a tua scelta. Poiché gli hash sono solo unidirezionali, devi mantenere una mappatura tra gli hash generati e gli identificatori utente in modo da poter mappare l'identificatore dell'account sottoposto ad hashing che potrebbe essere restituito agli account originali.

  2. Aggiungi l'identificatore dell'account opaco al parametro hashedAccountId nel metodo projects.assessments.create.

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

    • PROJECT_ID: il tuo ID progetto Google Cloud
    • TOKEN: token restituito dalla chiamata grecaptcha.enterprise.execute()
    • KEY: chiave reCAPTCHA associata al sito/all'app.
    • HASHED_ACCOUNT_ID: un identificatore utente con hash stabile generato utilizzando il metodo SHA256-HMAC per un account utente nel tuo sito web

    Metodo e URL HTTP: 

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

    Corpo JSON richiesta: 

    {
  "event": {
    "token": "TOKEN",
    "siteKey": "KEY",
    "hashedAccountId": "HASHED_ACCOUNT_ID"
  }
}

    Per inviare la richiesta, scegli una delle seguenti opzioni:

    ricci

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

    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"

    PowerShell

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

    $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,
    "hostname": "www.google.com",
    "action": "login",
    "createTime": "2019-03-28T12:24:17.894Z"
   },
  "riskAnalysis": {
    "score": 0.6,
  },
 "event": {
    "token": "TOKEN",
    "siteKey": "KEY",
    "expectedAction": "USER_ACTION"
  },
  "name": "projects/PROJECT_NUMBER/assessments/b6ac310000000000",
  "accountDefenderAssessment": {
    labels: ["SUSPICIOUS_LOGIN_ACTIVITY"]
  }
}

Esempio di codice

Java

Per eseguire l'autenticazione in reCAPTCHA Enterprise, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


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 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 customer, such as email, customer ID, etc.
    String userIdentifier = "default" + UUID.randomUUID().toString().split("-")[0];

    // Change this to a secret not shared with Google.
    final String HMAC_KEY = "SOME_INTERNAL_UNSHARED_KEY";

    // Get instance of Mac object implementing HmacSHA256, and initialize it with the above
    // secret key.
    Mac mac = Mac.getInstance("HmacSHA256");
    mac.init(new SecretKeySpec(HMAC_KEY.getBytes(StandardCharsets.UTF_8),
        "HmacSHA256"));
    byte[] hashBytes = mac.doFinal(userIdentifier.getBytes(StandardCharsets.UTF_8));
    ByteString hashedAccountId = ByteString.copyFrom(hashBytes);

    accountDefenderAssessment(projectId, recaptchaSiteKey, token, recaptchaAction, hashedAccountId);
  }

  /**
   * 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,
      ByteString hashedAccountId)
      throws IOException {
    try (RecaptchaEnterpriseServiceClient client = RecaptchaEnterpriseServiceClient.create()) {

      // Set the properties of the event to be tracked.
      Event event =
          Event.newBuilder()
              .setSiteKey(recaptchaSiteKey)
              .setToken(token)
              // Set the hashed account id (of the user).
              // Recommended approach: HMAC SHA256 along with salt (or secret key).
              .setHashedAccountId(hashedAccountId)
              .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 l'esito del rischio degli eventi utente critici

Quando crei una valutazione con l'account defender attivato, account defender restituisce accountDefenderAssessment come parte della risposta del test. Il valore accountDefenderAssessment consente di valutare se l'attività utente è legittima o fraudolenta. Restituisce anche un ID valutazione che devi utilizzare quando annotazione degli eventi utente.

L'esempio seguente è una risposta JSON di esempio:

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

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

Valore Descrizione
SUSPICIOUS_LOGIN_ACTIVITY Indica che la richiesta rappresenta un rischio elevato di credential stuffing o violazione di account.
SUSPICIOUS_ACCOUNT_CREATION Indica che la richiesta rappresenta un rischio elevato di creare un account illecito.
PROFILE_MATCH

Indica che gli attributi dell'utente corrispondono agli attributi che sono stati visualizzati in precedenza per questo utente specifico. Questo valore indica che l'utente utilizza un dispositivo attendibile utilizzato in precedenza per accedere al tuo sito web.

PROFILE_MATCH viene restituito solo nei seguenti scenari:

  • Utilizzate l'autenticazione a più fattori(MFA) o a due fattori(2FA) e il difensore degli account reCAPTCHA Enterprise contrassegna i profili utente come attendibili dopo che gli utenti hanno superato la verifica MFA o 2FA.
  • Annoti le valutazioni come LEGITIMATE o PASSED_TWO_FACTOR e il difensore degli account reCAPTCHA Enterprise contrassegna il profilo utente corrispondente come attendibile.
RELATED_ACCOUNTS_NUMBER_HIGH Indica che la richiesta ha un numero elevato di account correlati. Ciò non significa necessariamente che l'account sia difettoso, ma potrebbe richiedere ulteriori indagini.

Annota gli eventi per perfezionare il modello specifico per il sito

Per fornire ulteriori informazioni a defender degli account reCAPTCHA Enterprise e per migliorare il modello di rilevamento specifico del sito, devi annotare gli eventi valutati creando valutazioni.

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

Per annotare una valutazione:

  1. Determina le informazioni e le etichette da aggiungere al corpo JSON della richiesta in base al caso d'uso.

    Nella tabella seguente sono elencate le etichette e i valori che puoi utilizzare per annotare gli eventi:

    Etichetta Descrizione Esempio di richiesta
    reasons Obbligatorio. Un'etichetta per supportare le valutazioni.

    Fornisci i dettagli dell'evento in tempo reale nell'etichetta reasons pochi secondi o minuti dopo l'evento, perché questo influisce sul rilevamento in tempo reale.

    Per l'elenco dei valori possibili, consulta Valori dei motivi.

    Esempio: per rilevare i takeover dell'account, annota se la password inserita è corretta con valori di CORRECT_PASSWORD o INCORRECT_PASSWORD. Se hai eseguito il deployment della tua MFA, 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 di registrazione per convalidare o correggere le valutazioni dei rischi nell'etichetta annotation.

    Valori possibili: LEGITIMATE o FRAUDULENT.

    Puoi inviare queste informazioni in qualsiasi momento o come parte 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"
  }
    hashedAccountId

    Facoltativo. Un'etichetta per associare un [ID account opaco](##provide-account-id) a un evento.

    Se hai creato una valutazione senza un ID account opaco, utilizza questa etichetta per fornire l'ID account opaco di un evento ogni volta che è disponibile.

    		 
    
{
"hashedAccountId": "HASHED_ACCOUNT_ID"
}

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

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

    • ASSESSMENT_ID: valore del campo name restituito dalla chiamata projects.assessments.create.
    • ANNOTATION: facoltativo. Un'etichetta per indicare se il test è legittimo o fraudolento.
    • REASONS: facoltativo. I motivi che supportano l'annotazione. Per l'elenco dei possibili valori, vedi Valori dei motivi.
    • HASHED_ACCOUNT_ID: facoltativo. Un identificatore utente con hash stabile generato utilizzando il metodo SHA256-HMAC per un account utente sul tuo sito web

    Per maggiori informazioni, consulta la pagina relativa alle etichette per le annotazioni.

    Metodo e URL HTTP: 

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

    Corpo JSON richiesta: 

    {
  "annotation": ANNOTATION,
  "reasons": REASONS,
  "hashedAccountId": HASHED_ACCOUNT_ID
}

    Per inviare la richiesta, scegli una delle seguenti opzioni:

    ricci

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

    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 ed esegui il seguente comando: 

    $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 (2xx) completato e una risposta vuota.

Esempio di codice

Java

Per eseguire l'autenticazione in reCAPTCHA Enterprise, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


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;

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

    // hashedAccountId: Set the hashedAccountId corresponding to the assessment id.
    ByteString hashedAccountId = ByteString.copyFrom(new byte[] {});

    annotateAssessment(projectID, assessmentId, hashedAccountId);
  }

  /**
   * 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, ByteString hashedAccountId) 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)
              .setHashedAccountId(hashedAccountId)
              .build();

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

Attiva la protezione degli account reCAPTCHA Enterprise

Dopo aver configurato le pagine web per il servizio di difesa degli account reCAPTCHA Enterprise, puoi abilitarlo.

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

    Vai a reCAPTCHA Enterprise

  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, quindi seleziona il tuo progetto.

  3. Fai clic su Impostazioni.

  4. Nel riquadro Account defender, fai clic su Enable (Attiva).

  5. Nella finestra di dialogo Configura account defender, fai clic su Attiva.

La propagazione dell'abilitazione del difensore degli account reCAPTCHA Enterprise ai nostri sistemi potrebbe richiedere alcune ore. Una volta che l'attivazione delle funzionalità è stata propagata ai nostri sistemi, dovresti iniziare a ricevere risposte relative ai difensori dell'account nell'ambito delle valutazioni.

Passaggi successivi