Protéger les comptes utilisateur grâce à la protection multicompte

Si votre application permet aux utilisateurs de se connecter à leur compte à l'aide de Google, vous pouvez améliorer la sécurité des comptes de ces utilisateurs partagés en écoutant les notifications d'événements de sécurité fournies par le service de protection multicompte et en y répondant.

Ces notifications vous informent des modifications importantes apportées aux comptes Google de vos utilisateurs, ce qui peut souvent avoir des conséquences sur la sécurité des comptes associés à votre application. Par exemple, si le compte Google d'un utilisateur a été piraté, il est possible que celui-ci soit piraté via la récupération de compte de messagerie ou l'utilisation de l'authentification unique.

Pour vous aider à limiter les risques liés à de tels événements, Google envoie vos objets de service appelés jetons d'événement de sécurité. Ces jetons exposent très peu d'informations (seulement le type d'événement lié à la sécurité, le moment auquel il s'est produit et l'identifiant de l'utilisateur concerné), mais vous pouvez les utiliser pour prendre les mesures appropriées en réponse. Par exemple, si le compte Google d'un utilisateur a été piraté, vous pouvez désactiver temporairement Se connecter avec Google pour cet utilisateur et empêcher l'envoi d'e-mails de récupération de compte à son adresse Gmail.

La protection multicompte est basée sur la norme RISC, développée par l'OpenID Foundation.

Présentation

Pour utiliser la protection multicompte avec votre application ou votre service, vous devez effectuer les tâches suivantes:

  1. Configurez votre projet dans le API Console.

  2. Créez un point de terminaison de récepteur d'événements, auquel Google enverra des jetons d'événement de sécurité. Ce point de terminaison est chargé de valider les jetons qu'il reçoit, puis de répondre aux événements de sécurité de la manière de votre choix.

  3. Enregistrez votre point de terminaison auprès de Google pour commencer à recevoir des jetons d'événement de sécurité.

Prérequis

Vous ne recevez des jetons d'événement de sécurité que pour les utilisateurs Google qui ont autorisé votre service à accéder aux informations de leur profil ou à leurs adresses e-mail. Pour obtenir cette autorisation, demandez les champs d'application profile ou email. Les nouveaux SDK Se connecter avec Google ou Google Sign-In demandent ces champs d'application par défaut. Toutefois, si vous n'utilisez pas les paramètres par défaut ou si vous accédez directement au point de terminaison OpenID Connect de Google, veillez à demander au moins l'un de ces champs d'application.

Configurez un projet dans le API Console

Avant de pouvoir recevoir des jetons d'événement de sécurité, vous devez créer un compte de service et activer l'API RISC dans votre projetAPI Console . Vous devez utiliser le même projetAPI Console que celui utilisé pour accéder aux services Google, tels que Google Sign-In, dans votre application.

Pour créer le compte de service :

  1. Ouvrez API Console Credentials page. Lorsque vous y êtes invité, sélectionnez le projetAPI Consoleque vous utilisez pour accéder aux services Google dans votre application.

  2. Cliquez sur Créer des identifiants > Compte de service.

  3. Créez un compte de service avec le rôle Administrateur de configuration RISC (roles/riscconfigs.admin) en suivant ces instructions.

  4. Créez une clé pour le compte de service que vous venez de créer. Choisissez le type de clé JSON, puis cliquez sur Créer. Une fois la clé créée, vous téléchargez un fichier JSON contenant les identifiants de votre compte de service. Conservez ce fichier en lieu sûr, mais également accessible au point de terminaison du récepteur d'événements.

Sur la page "Identifiants" de votre projet, notez également les ID client que vous utilisez pour Se connecter avec Google ou Google Sign-In (ancien). En règle générale, vous disposez d'un ID client pour chaque plate-forme compatible. Vous en aurez besoin pour valider les jetons d'événement de sécurité, comme décrit dans la section suivante.

Pour activer l'API RISC:

  1. Ouvrez la page API RISC dans le fichierAPI Console. Assurez-vous que le projet que vous utilisez pour accéder aux services Google est toujours sélectionné.

  2. Lisez les Conditions RISC et assurez-vous de bien comprendre les exigences.

    Si vous activez l'API pour un projet appartenant à une organisation, assurez-vous d'être autorisé à lier votre organisation aux conditions RISC.

  3. Cliquez sur Activer uniquement si vous acceptez les Conditions d'utilisation RISC.

Créer un point de terminaison de récepteur d'événements

Pour recevoir des notifications d'événements liés à la sécurité de la part de Google, vous devez créer un point de terminaison HTTPS qui gère les requêtes POST HTTPS. Une fois ce point de terminaison enregistré (voir ci-dessous), Google commencera à y publier des chaînes à signature cryptographique appelées jetons d'événement de sécurité. Les jetons d'événement de sécurité sont des jetons JWT signés qui contiennent des informations sur un seul événement lié à la sécurité.

Pour chaque jeton d'événement de sécurité que vous recevez sur votre point de terminaison, commencez par valider et décoder le jeton, puis gérez l'événement lié à la sécurité de manière appropriée pour votre service. Il est essentiel de valider le jeton d'événement avant de le décoder pour éviter les attaques malveillantes d'acteurs malintentionnés. Les sections suivantes décrivent ces tâches:

1. Décoder et valider le jeton d'événement de sécurité

Les jetons d'événement de sécurité étant un type spécifique de jetons JWT, vous pouvez utiliser n'importe quelle bibliothèque JWT, telle que celle répertoriée sur jwt.io, pour les décoder et les valider. Quelle que soit la bibliothèque que vous utilisez, votre code de validation de jeton doit:

  1. Obtenez l'identifiant de l'émetteur de la protection multicompte (issuer) et l'URI du certificat de la clé de signature (jwks_uri) dans le document de configuration RISC de Google, que vous trouverez sur https://accounts.google.com/.well-known/risc-configuration.
  2. À l'aide de la bibliothèque JWT de votre choix, récupérez l'ID de clé de signature à partir de l'en-tête du jeton d'événement de sécurité.
  3. Dans le document de certificat de clé de signature de Google, récupérez la clé publique avec l'ID de clé obtenu à l'étape précédente. Si le document ne contient pas de clé avec l'ID que vous recherchez, il est probable que le jeton d'événement de sécurité ne soit pas valide. Votre point de terminaison devrait alors renvoyer l'erreur HTTP 400.
  4. À l'aide de la bibliothèque JWT de votre choix, vérifiez les éléments suivants :
    • Le jeton d'événement de sécurité est signé à l'aide de la clé publique obtenue à l'étape précédente.
    • La revendication aud du jeton est l'un des ID client de vos applications.
    • La revendication iss du jeton correspond à l'identifiant de l'émetteur que vous avez obtenu dans le document de découverte RISC. Notez que vous n'avez pas besoin de vérifier l'expiration du jeton (exp), car les jetons d'événement de sécurité représentent des événements historiques et n'expirent donc pas.

Exemple :

Java

À l'aide de java-jwt et jwks-rsa-java:

public DecodedJWT validateSecurityEventToken(String token) {
    DecodedJWT jwt = null;
    try {
        // In a real implementation, get these values from
        // https://accounts.google.com/.well-known/risc-configuration
        String issuer = "accounts.google.com";
        String jwksUri = "https://www.googleapis.com/oauth2/v3/certs";

        // Get the ID of the key used to sign the token.
        DecodedJWT unverifiedJwt = JWT.decode(token);
        String keyId = unverifiedJwt.getKeyId();

        // Get the public key from Google.
        JwkProvider googleCerts = new UrlJwkProvider(new URL(jwksUri), null, null);
        PublicKey publicKey = googleCerts.get(keyId).getPublicKey();

        // Verify and decode the token.
        Algorithm rsa = Algorithm.RSA256((RSAPublicKey) publicKey, null);
        JWTVerifier verifier = JWT.require(rsa)
                .withIssuer(issuer)
                // Get your apps' client IDs from the API console:
                // https://console.developers.google.com/apis/credentials?project=_
                .withAudience("123456789-abcedfgh.apps.googleusercontent.com",
                              "123456789-ijklmnop.apps.googleusercontent.com",
                              "123456789-qrstuvwx.apps.googleusercontent.com")
                .acceptLeeway(Long.MAX_VALUE)  // Don't check for expiration.
                .build();
        jwt = verifier.verify(token);
    } catch (JwkException e) {
        // Key not found. Return HTTP 400.
    } catch (InvalidClaimException e) {

    } catch (JWTDecodeException exception) {
        // Malformed token. Return HTTP 400.
    } catch (MalformedURLException e) {
        // Invalid JWKS URI.
    }
    return jwt;
}

Python

import json
import jwt       # pip install pyjwt
import requests  # pip install requests

def validate_security_token(token, client_ids):
    # Get Google's RISC configuration.
    risc_config_uri = 'https://accounts.google.com/.well-known/risc-configuration'
    risc_config = requests.get(risc_config_uri).json()

    # Get the public key used to sign the token.
    google_certs = requests.get(risc_config['jwks_uri']).json()
    jwt_header = jwt.get_unverified_header(token)
    key_id = jwt_header['kid']
    public_key = None
    for key in google_certs['keys']:
        if key['kid'] == key_id:
            public_key = jwt.algorithms.RSAAlgorithm.from_jwk(json.dumps(key))
    if not public_key:
        raise Exception('Public key certificate not found.')
        # In this situation, return HTTP 400

    # Decode the token, validating its signature, audience, and issuer.
    try:
        token_data = jwt.decode(token, public_key, algorithms='RS256',
                                options={'verify_exp': False},
                                audience=client_ids, issuer=risc_config['issuer'])
    except:
        raise
        # Validation failed. Return HTTP 400.
    return token_data

# Get your apps' client IDs from the API console:
# https://console.developers.google.com/apis/credentials?project=_
client_ids = ['123456789-abcedfgh.apps.googleusercontent.com',
              '123456789-ijklmnop.apps.googleusercontent.com',
              '123456789-qrstuvwx.apps.googleusercontent.com']
token_data = validate_security_token(token, client_ids)

Si le jeton est valide et a bien été décodé, renvoyez l'état HTTP 202. Gérez ensuite l'événement lié à la sécurité indiqué par le jeton.

2. Gérer les événements liés à la sécurité

Lorsqu'il est décodé, un jeton d'événement de sécurité ressemble à l'exemple suivant:

{
  "iss": "https://accounts.google.com/",
  "aud": "123456789-abcedfgh.apps.googleusercontent.com",
  "iat": 1508184845,
  "jti": "756E69717565206964656E746966696572",
  "events": {
    "https://schemas.openid.net/secevent/risc/event-type/account-disabled": {
      "subject": {
        "subject_type": "iss-sub",
        "iss": "https://accounts.google.com/",
        "sub": "7375626A656374"
      },
      "reason": "hijacking"
    }
  }
}

Les revendications iss et aud indiquent l'émetteur du jeton (Google) et son destinataire (votre service). Vous avez vérifié ces revendications à l'étape précédente.

La revendication jti est une chaîne qui identifie un seul événement lié à la sécurité. Elle est propre au flux. Vous pouvez utiliser cet identifiant pour suivre les événements liés à la sécurité que vous avez reçus.

La revendication events contient des informations sur l'événement de sécurité représenté par le jeton. Cette revendication est le mappage entre un identifiant de type d'événement et une revendication subject, qui spécifie l'utilisateur concerné par cet événement, ainsi que tous les autres détails éventuellement disponibles concernant l'événement.

La revendication subject identifie un utilisateur particulier avec l'ID de compte Google unique de l'utilisateur (sub). Cet ID de compte Google est identique à l'identifiant (sub) contenu dans les jetons d'ID JWT émis par les nouvelles bibliothèques Se connecter avec Google (JavaScript, HTML), l'ancienne bibliothèque Google Sign-In ou OpenID Connect. Lorsque le subject_type de la revendication est id_token_claims, il peut également inclure un champ email avec l'adresse e-mail de l'utilisateur.

Utilisez les informations de la revendication events pour prendre les mesures appropriées pour le type d'événement sur le compte de l'utilisateur spécifié.

Identifiants de jeton OAuth

Pour les événements OAuth concernant des jetons individuels, le type d'identifiant token subject contient les champs suivants:

  • token_type: seul refresh_token est accepté.

  • token_identifier_alg: consultez le tableau ci-dessous pour connaître les valeurs possibles.

  • token: consultez le tableau ci-dessous.

token_identifier_alg jeton
prefix Les 16 premiers caractères du jeton.
hash_base64_sha512_sha512 Double hachage du jeton au moyen de SHA-512.

Si vous intégrez ces événements, nous vous recommandons d'indexer vos jetons en fonction de ces valeurs possibles pour garantir une correspondance rapide lors de la réception de l'événement.

Types d'événements acceptés

La protection multicompte est compatible avec les types d'événements de sécurité suivants:

Type d'événement Attributes Comment y répondre ?
https://schemas.openid.net/secevent/risc/event-type/sessions-revoked Obligatoire: Sécurisez à nouveau le compte de l'utilisateur en mettant fin à ses sessions actuellement ouvertes.
https://schemas.openid.net/secevent/oauth/event-type/tokens-revoked

Obligatoire: si le jeton est destiné à Google Sign-In, mettez fin aux sessions actuellement ouvertes. Vous pouvez également suggérer à l'utilisateur de configurer une autre méthode de connexion.

Suggéré: si le jeton permet d'accéder à d'autres API Google, supprimez tous les jetons OAuth de l'utilisateur que vous avez stockés.

https://schemas.openid.net/secevent/oauth/event-type/token-revoked Consultez la section Identifiants de jeton OAuth pour en savoir plus sur les identifiants de jeton.

Obligatoire: si vous stockez le jeton d'actualisation correspondant, supprimez-le et demandez à l'utilisateur de donner à nouveau son consentement la prochaine fois qu'un jeton d'accès sera nécessaire.

https://schemas.openid.net/secevent/risc/event-type/account-disabled reason=hijacking,
reason=bulk-account

Obligatoire: Si le motif de désactivation du compte était hijacking, sécurisez à nouveau le compte de l'utilisateur en mettant fin aux sessions actuellement ouvertes.

Suggéré: si le motif de désactivation du compte était bulk-account, analysez l'activité de l'utilisateur sur votre service et déterminez les actions de suivi appropriées.

Suggestion: Si aucun motif n'a été fourni, désactivez Google Sign-In pour l'utilisateur et désactivez la récupération de compte à l'aide de l'adresse e-mail associée à son compte Google (généralement, mais pas nécessairement, un compte Gmail). Proposez à l'utilisateur une autre méthode de connexion.

https://schemas.openid.net/secevent/risc/event-type/account-enabled Suggéré: Réactivez Google Sign-In pour l'utilisateur et réactivez la récupération de compte avec l'adresse e-mail du compte Google de l'utilisateur.
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required Suggéré: recherchez les activités suspectes sur votre service et prenez les mesures appropriées.
https://schemas.openid.net/secevent/risc/event-type/verification state=state Suggéré: consignez la réception d'un jeton de test.

Événements en double et manqués

La protection multicompte tentera de renvoyer les événements qui, selon elle, n'ont pas été effectués. Par conséquent, vous pouvez parfois recevoir le même événement plusieurs fois. Si cela peut engendrer des actions répétées pouvant gêner vos utilisateurs, envisagez d'utiliser la revendication jti (qui est un identifiant unique pour un événement) afin de supprimer les événements en double. Des outils externes, comme Google Cloud Dataflow, peuvent vous aider à exécuter le flux de données de suppression des données en double.

Notez que les événements sont envoyés avec un nombre de tentatives limité. Par conséquent, si votre récepteur est indisponible pendant une période prolongée, vous risquez de manquer définitivement certains événements.

Enregistrer votre récepteur

Pour commencer à recevoir des événements liés à la sécurité, enregistrez le point de terminaison de votre récepteur à l'aide de l'API RISC. Les appels vers l'API RISC doivent être accompagnés d'un jeton d'autorisation.

Vous ne recevrez des événements liés à la sécurité que pour les utilisateurs de votre application. Vous devez donc disposer d'un écran de consentement OAuth configuré dans votre projet GCP au préalable pour les étapes décrites ci-dessous.

1. Générer un jeton d'autorisation

Pour générer un jeton d'autorisation pour l'API RISC, créez un jeton JWT avec les revendications suivantes:

{
  "iss": SERVICE_ACCOUNT_EMAIL,
  "sub": SERVICE_ACCOUNT_EMAIL,
  "aud": "https://risc.googleapis.com/google.identity.risc.v1beta.RiscManagementService",
  "iat": CURRENT_TIME,
  "exp": CURRENT_TIME + 3600
}

Signez le jeton JWT à l'aide de la clé privée de votre compte de service, que vous trouverez dans le fichier JSON que vous avez téléchargé lors de la création de la clé de compte de service.

Exemple :

Java

À l'aide de java-jwt et de la bibliothèque d'authentification de Google:

public static String makeBearerToken() {
    String token = null;
    try {
        // Get signing key and client email address.
        FileInputStream is = new FileInputStream("your-service-account-credentials.json");
        ServiceAccountCredentials credentials =
               (ServiceAccountCredentials) GoogleCredentials.fromStream(is);
        PrivateKey privateKey = credentials.getPrivateKey();
        String keyId = credentials.getPrivateKeyId();
        String clientEmail = credentials.getClientEmail();

        // Token must expire in exactly one hour.
        Date issuedAt = new Date();
        Date expiresAt = new Date(issuedAt.getTime() + 3600000);

        // Create signed token.
        Algorithm rsaKey = Algorithm.RSA256(null, (RSAPrivateKey) privateKey);
        token = JWT.create()
                .withIssuer(clientEmail)
                .withSubject(clientEmail)
                .withAudience("https://risc.googleapis.com/google.identity.risc.v1beta.RiscManagementService")
                .withIssuedAt(issuedAt)
                .withExpiresAt(expiresAt)
                .withKeyId(keyId)
                .sign(rsaKey);
    } catch (ClassCastException e) {
        // Credentials file doesn't contain a service account key.
    } catch (IOException e) {
        // Credentials file couldn't be loaded.
    }
    return token;
}

Python

import json
import time

import jwt  # pip install pyjwt

def make_bearer_token(credentials_file):
    with open(credentials_file) as service_json:
        service_account = json.load(service_json)
        issuer = service_account['client_email']
        subject = service_account['client_email']
        private_key_id = service_account['private_key_id']
        private_key = service_account['private_key']
    issued_at = int(time.time())
    expires_at = issued_at + 3600
    payload = {'iss': issuer,
               'sub': subject,
               'aud': 'https://risc.googleapis.com/google.identity.risc.v1beta.RiscManagementService',
               'iat': issued_at,
               'exp': expires_at}
    encoded = jwt.encode(payload, private_key, algorithm='RS256',
                         headers={'kid': private_key_id})
    return encoded

auth_token = make_bearer_token('your-service-account-credentials.json')

Ce jeton d'autorisation peut être utilisé pour effectuer des appels à l'API RISC pendant une heure. Lorsque le jeton expire, générez-en un nouveau pour continuer à effectuer des appels d'API RISC.

2. Appeler l'API de configuration de flux RISC

Maintenant que vous disposez d'un jeton d'autorisation, vous pouvez utiliser l'API RISC pour configurer le flux d'événements de sécurité de votre projet, y compris pour enregistrer le point de terminaison de votre récepteur.

Pour ce faire, envoyez une requête HTTPS POST à https://risc.googleapis.com/v1beta/stream:update, en spécifiant votre point de terminaison de récepteur et les types d'événements de sécurité qui vous intéressent:

POST /v1beta/stream:update HTTP/1.1
Host: risc.googleapis.com
Authorization: Bearer AUTH_TOKEN

{
  "delivery": {
    "delivery_method":
      "https://schemas.openid.net/secevent/risc/delivery-method/push",
    "url": RECEIVER_ENDPOINT
  },
  "events_requested": [
    SECURITY_EVENT_TYPES
  ]
}

Exemple :

Java

public static void configureEventStream(final String receiverEndpoint,
                                        final List<String> eventsRequested,
                                        String authToken) throws IOException {
    ObjectMapper jsonMapper = new ObjectMapper();
    String streamConfig = jsonMapper.writeValueAsString(new Object() {
        public Object delivery = new Object() {
            public String delivery_method =
                    "https://schemas.openid.net/secevent/risc/delivery-method/push";
            public String url = receiverEndpoint;
        };
        public List<String> events_requested = eventsRequested;
    });

    HttpPost updateRequest = new HttpPost("https://risc.googleapis.com/v1beta/stream:update");
    updateRequest.addHeader("Content-Type", "application/json");
    updateRequest.addHeader("Authorization", "Bearer " + authToken);
    updateRequest.setEntity(new StringEntity(streamConfig));

    HttpResponse updateResponse = new DefaultHttpClient().execute(updateRequest);
    Header[] responseContentTypeHeaders = updateResponse.getHeaders("Content-Type");
    StatusLine responseStatus = updateResponse.getStatusLine();
    int statusCode = responseStatus.getStatusCode();
    HttpEntity entity = updateResponse.getEntity();
    // Now handle response
}

// ...

configureEventStream(
        "https://your-service.example.com/security-event-receiver",
        Arrays.asList(
                "https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required",
                "https://schemas.openid.net/secevent/risc/event-type/account-disabled"),
        authToken);

Python

import requests

def configure_event_stream(auth_token, receiver_endpoint, events_requested):
    stream_update_endpoint = 'https://risc.googleapis.com/v1beta/stream:update'
    headers = {'Authorization': 'Bearer {}'.format(auth_token)}
    stream_cfg = {'delivery': {'delivery_method': 'https://schemas.openid.net/secevent/risc/delivery-method/push',
                               'url': receiver_endpoint},
                  'events_requested': events_requested}
    response = requests.post(stream_update_endpoint, json=stream_cfg, headers=headers)
    response.raise_for_status()  # Raise exception for unsuccessful requests

configure_event_stream(auth_token, 'https://your-service.example.com/security-event-receiver',
                       ['https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required',
                        'https://schemas.openid.net/secevent/risc/event-type/account-disabled'])

Si la requête renvoie le code HTTP 200, le flux d'événements a bien été configuré et le point de terminaison destinataire doit commencer à recevoir des jetons d'événement de sécurité. La section suivante explique comment tester la configuration de flux et le point de terminaison pour vérifier que tout fonctionne correctement ensemble.

Obtenir et mettre à jour la configuration de flux actuelle

Si, à l'avenir, vous souhaitez modifier la configuration de votre flux, vous pourrez le faire en envoyant une requête GET autorisée à https://risc.googleapis.com/v1beta/stream pour obtenir la configuration actuelle du flux, en modifiant le corps de la réponse, puis en renvoyant la configuration modifiée à https://risc.googleapis.com/v1beta/stream:update, comme décrit ci-dessus.

Arrêter et reprendre le flux d'événements

Si vous devez arrêter le flux d'événements de Google, envoyez une requête POST autorisée à https://risc.googleapis.com/v1beta/stream/status:update en spécifiant { "status": "disabled" } dans le corps de la requête. Lorsque le flux est désactivé, Google n'envoie pas d'événements à votre point de terminaison et ne met pas en mémoire tampon les événements de sécurité lorsqu'ils se produisent. Pour réactiver le flux d'événements, publiez { "status": "enabled" } sur le même point de terminaison.

3. Facultatif: tester la configuration de votre diffusion

Vous pouvez vérifier que la configuration de votre flux et le point de terminaison du récepteur fonctionnent correctement ensemble en envoyant un jeton de validation via votre flux d'événements. Ce jeton peut contenir une chaîne unique permettant de vérifier qu'il a bien été reçu sur votre point de terminaison. Pour utiliser ce flux, assurez-vous de vous abonner au type d'événement https://schemas.openid.net/secevent/risc/event-type/verification lorsque vous enregistrez votre récepteur.

Pour demander un jeton de validation, envoyez une requête HTTPS POST autorisée à https://risc.googleapis.com/v1beta/stream:verify. Dans le corps de la requête, spécifiez une chaîne d'identification:

{
  "state": "ANYTHING"
}

Exemple :

Java

public static void testEventStream(final String stateString,
                                   String authToken) throws IOException {
    ObjectMapper jsonMapper = new ObjectMapper();
    String json = jsonMapper.writeValueAsString(new Object() {
        public String state = stateString;
    });

    HttpPost updateRequest = new HttpPost("https://risc.googleapis.com/v1beta/stream:verify");
    updateRequest.addHeader("Content-Type", "application/json");
    updateRequest.addHeader("Authorization", "Bearer " + authToken);
    updateRequest.setEntity(new StringEntity(json));

    HttpResponse updateResponse = new DefaultHttpClient().execute(updateRequest);
    Header[] responseContentTypeHeaders = updateResponse.getHeaders("Content-Type");
    StatusLine responseStatus = updateResponse.getStatusLine();
    int statusCode = responseStatus.getStatusCode();
    HttpEntity entity = updateResponse.getEntity();
    // Now handle response
}

// ...

testEventStream("Test token requested at " + new Date().toString(), authToken);

Python

import requests
import time

def test_event_stream(auth_token, nonce):
    stream_verify_endpoint = 'https://risc.googleapis.com/v1beta/stream:verify'
    headers = {'Authorization': 'Bearer {}'.format(auth_token)}
    state = {'state': nonce}
    response = requests.post(stream_verify_endpoint, json=state, headers=headers)
    response.raise_for_status()  # Raise exception for unsuccessful requests

test_event_stream(auth_token, 'Test token requested at {}'.format(time.ctime()))

Si la requête aboutit, le jeton de validation est envoyé au point de terminaison que vous avez enregistré. Ensuite, si votre point de terminaison gère les jetons de validation en les consignant simplement, vous pouvez examiner vos journaux pour vérifier que le jeton a bien été reçu.

Informations de référence sur les codes d'erreur

L'API RISC peut renvoyer les erreurs suivantes:

Code d'erreur Message d'erreur Actions suggérées
400 La configuration du flux doit contenir le champ $fieldname. La requête envoyée au point de terminaison https://risc.googleapis.com/v1beta/stream:update n'est pas valide ou ne peut pas être analysée. Veuillez inclure $fieldname dans votre demande.
401 Non autorisé. Échec de l'autorisation. Assurez-vous d'avoir joint un jeton d'autorisation à la requête, et vérifiez qu'il est valide et qu'il n'a pas expiré.
403 Le point de terminaison de diffusion doit être une URL HTTPS. Votre point de terminaison de livraison (c'est-à-dire le point de terminaison auquel vous prévoyez que les événements RISC doivent être distribués) doit être HTTPS. Nous n'envoyons pas d'événements RISC aux URL HTTP.
403 La configuration de flux existante ne dispose pas d'un mode de diffusion conforme aux spécifications pour RISC. Votre projet Google Cloud doit déjà disposer d'une configuration RISC. Si vous utilisez Firebase et que Google Sign-In est activé, Firebase gérera le RISC pour votre projet. Vous ne pourrez pas créer de configuration personnalisée. Si vous n'utilisez pas Google Sign-In pour votre projet Firebase, veuillez le désactiver, puis réessayez d'effectuer la mise à jour au bout d'une heure.
403 Projet introuvable. Assurez-vous d'utiliser le bon compte de service pour le bon projet. Vous utilisez peut-être un compte de service associé à un projet supprimé. Découvrez comment afficher tous les comptes de service associés à un projet.
403 Le compte de service a besoin d'une autorisation pour accéder à votre configuration RISC Accédez au fichier API Console de votre projet et attribuez le rôle "Administrateur de configuration RISC" (roles/riscconfigs.admin) au compte de service qui appelle votre projet en suivant ces instructions.
403 Les API de gestion des flux ne doivent être appelées que par un compte de service. Découvrez plus en détail comment appeler des API Google avec un compte de service.
403 Le point de terminaison de diffusion n'appartient à aucun des domaines de votre projet. Chaque projet est associé à un ensemble de domaines autorisés. Si votre point de terminaison de livraison (c'est-à-dire celui auquel vous prévoyez que les événements RISC doivent être distribués) n'est pas hébergé sur l'un d'entre eux, nous vous demandons d'ajouter le domaine du point de terminaison à cet ensemble.
403 Pour que vous puissiez utiliser cette API, au moins un client OAuth doit être configuré dans votre projet. RISC ne fonctionne que si vous créez une application compatible avec Google Sign-In. Cette connexion nécessite un client OAuth. Si votre projet n'a pas de clients OAuth, RISC ne vous sera probablement pas utile. En savoir plus sur l'utilisation par Google d'OAuth pour nos API.
403

État non compatible.

État non valide.

Seuls les états de flux "enabled" et "disabled" sont actuellement acceptés.
404

Le projet ne comporte aucune configuration RISC.

Le projet ne comporte aucune configuration RISC existante. Impossible de mettre à jour l'état.

Appelez le point de terminaison https://risc.googleapis.com/v1beta/stream:update pour créer une configuration de flux.
4XX/5XX Impossible de mettre à jour l'état. Pour en savoir plus, consultez le message d'erreur détaillé.

Champs d'application des jetons d'accès

Si vous décidez d'utiliser des jetons d'accès pour vous authentifier auprès de l'API RISC, voici les niveaux d'accès que votre application doit demander:

Point de terminaison Scope (Portée)
https://risc.googleapis.com/v1beta/stream/status https://www.googleapis.com/auth/risc.status.readonly OU https://www.googleapis.com/auth/risc.status.readwrite
https://risc.googleapis.com/v1beta/stream/status:update https://www.googleapis.com/auth/risc.status.readwrite
https://risc.googleapis.com/v1beta/stream https://www.googleapis.com/auth/risc.configuration.readonly OU https://www.googleapis.com/auth/risc.configuration.readwrite
https://risc.googleapis.com/v1beta/stream:update https://www.googleapis.com/auth/risc.configuration.readwrite
https://risc.googleapis.com/v1beta/stream:verify https://www.googleapis.com/auth/risc.verify

Besoin d'aide ?

Commencez par consulter notre documentation de référence sur les codes d'erreur. Si vous avez d'autres questions, publiez-les sur Stack Overflow en ajoutant le tag #SecEvents.