Protégez les comptes d'utilisateurs avec la protection entre comptes

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

Ces notifications vous avertissent des modifications majeures apportées aux comptes Google de vos utilisateurs, qui peuvent souvent également avoir des implications sur la sécurité de leurs comptes avec votre application. Par exemple, si le compte Google d'un utilisateur était piraté, cela pourrait potentiellement entraîner la compromission du compte de l'utilisateur avec votre application via la récupération du compte de messagerie ou l'utilisation de l'authentification unique.

Pour vous aider à atténuer le risque potentiel 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 (juste le type d'événement de sécurité et le moment où il s'est produit, ainsi que 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 est compromis, vous pouvez temporairement désactiver la connexion avec Google pour cet utilisateur et empêcher l'envoi d'e-mails de récupération de compte à l'adresse Gmail de l'utilisateur.

La protection entre comptes est basée sur la norme RISC , développée à l'OpenID Foundation.

Aperçu

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

  1. Configurez votre projet dans le API Console.

  2. Créez un point de terminaison 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 que vous choisissez.

  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 de Google qui ont autorisé votre service à accéder à leurs informations de profil ou à leurs adresses e-mail. Vous obtenez cette autorisation en demandant les champs d'application du profile ou de l'e- email . Les nouveaux SDK de connexion avec Google ou les anciens SDK de connexion Google demandent ces champs d'application par défaut, mais 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, assurez-vous de demander au moins l'un d'entre eux. étendues.

Configurer un projet dans le API Console

Avant de pouvoir commencer à 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 que vous utilisez pour accéder aux services Google, tels que Google Sign-in, dans votre application.

Pour créer le compte de service :

  1. Ouvrez le API ConsoleCredentials page . Lorsque vous y êtes invité, choisissez 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 nouveau compte de service avec le rôle d'éditeur.

  4. Créez une clé pour votre compte de service nouvellement créé. Choisissez le type de clé JSON puis cliquez sur Créer . Une fois la clé créée, vous téléchargerez un fichier JSON contenant les informations d'identification de votre compte de service. Conservez ce fichier dans un endroit sûr, mais également accessible à votre point de terminaison récepteur d'événements.

Pendant que vous êtes sur la page Identifiants de votre projet, notez également les ID client que vous utilisez pour vous connecter avec Google ou Google Sign-in (ancien). En règle générale, vous disposez d'un ID client pour chaque plate-forme que vous prenez en charge. Vous aurez besoin de ces ID client 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 RISC API dansAPI 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 que vous êtes autorisé à lier votre organisation aux conditions RISC.

  3. Cliquez sur Activer uniquement si vous acceptez les conditions RISC.

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

Pour recevoir des notifications d'événements de sécurité de Google, vous créez un point de terminaison HTTPS qui gère les requêtes HTTPS POST. Après avoir enregistré ce point de terminaison (voir ci-dessous), Google commencera à publier des chaînes signées de manière cryptographique appelées jetons d'événement de sécurité sur le point de terminaison. Les jetons d'événement de sécurité sont des 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, validez et décodez d'abord le jeton, puis gérez l'événement de sécurité en fonction de votre service. Il est essentiel de valider le jeton d'événement avant de le décoder pour empêcher les attaques malveillantes d'acteurs malveillants. Les sections suivantes décrivent ces tâches :

1. Décodez et validez le jeton d'événement de sécurité

Étant donné que les jetons d'événement de sécurité sont un type spécifique de 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 effectuer les opérations suivantes :

  1. Obtenez l'identifiant de l'émetteur de la protection multicompte ( issuer ) et l'URI du certificat de clé de signature ( jwks_uri ) à partir du document de configuration RISC de Google, que vous pouvez trouver à l' https://accounts.google.com/.well-known/risc-configuration .
  2. À l'aide de la bibliothèque JWT de votre choix, obtenez l'ID de clé de signature à partir de l'en-tête du jeton d'événement de sécurité.
  3. À partir du document de certificat de clé de signature de Google, obtenez la clé publique avec l'ID de clé que vous avez 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 et votre point de terminaison devrait 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 que vous avez 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 à partir du 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, en tant que tels, n'expirent pas.

Par exemple:

Java

Utilisation 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 été décodé avec succès, renvoyez le statut HTTP 202. Ensuite, gérez l'événement de sécurité indiqué par le jeton.

2. Gérer les événements de sécurité

Une fois 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 le destinataire prévu du jeton (votre service). Vous avez vérifié ces revendications à l'étape précédente.

La revendication jti est une chaîne qui identifie un événement de sécurité unique et qui est unique pour le flux. Vous pouvez utiliser cet identifiant pour suivre les événements de sécurité que vous avez reçus.

La demande d' events contient des informations sur l'événement de sécurité représenté par le jeton. Cette revendication est un mappage d'un identificateur de type d'événement à une revendication de subject , qui spécifie l'utilisateur concerné par cet événement, et à tous les détails supplémentaires sur l'événement qui pourraient être disponibles.

L' subject de la revendication identifie un utilisateur particulier avec son identifiant de compte Google unique ( sub ). Cet ID de compte Google est le même identifiant ( sub ) contenu dans les jetons d'ID JWT émis par la nouvelle bibliothèque Sign In With Google ( Javascript , HTML ), l'ancienne bibliothèque de connexion Google ou OpenID Connect . Lorsque le subject_type de la revendication est id_token_claims , il peut également inclure un champ e- email avec l'adresse e-mail de l'utilisateur.

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

Types d'événements pris en charge

La protection entre comptes prend en charge les types d'événements de sécurité suivants :

Type d'événement Les attributs Comment 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é à la connexion à Google, mettez fin à leurs sessions actuellement ouvertes. En outre, vous pouvez suggérer à l'utilisateur de configurer une autre méthode de connexion.

Suggestion : 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/risc/event-type/account-disabled reason=hijacking ,
reason=bulk-account

Obligatoire : si la raison pour laquelle le compte a été désactivé était un hijacking , sécurisez à nouveau le compte de l'utilisateur en mettant fin à ses sessions actuellement ouvertes.

Suggestion : Si la raison pour laquelle le compte a été désactivé était bulk-account , analysez l'activité de l'utilisateur sur votre service et déterminez les actions de suivi appropriées.

Suggestion : si aucune raison n'a été fournie, désactivez la connexion Google pour l'utilisateur et désactivez la récupération de compte à l'aide de l'adresse e-mail associée au compte Google de l'utilisateur (généralement, mais pas nécessairement, un compte Gmail). Offrez à l'utilisateur une autre méthode de connexion.

https://schemas.openid.net/secevent/risc/event-type/account-enabled Suggestion : réactivez la connexion Google pour l'utilisateur et réactivez la récupération du compte avec l'adresse e-mail du compte Google de l'utilisateur.
https://schemas.openid.net/secevent/risc/event-type/account-purged Suggestion : supprimez le compte de l'utilisateur ou fournissez-lui une autre méthode de connexion.
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required Suggestion : recherchez les activités suspectes sur votre service et prenez les mesures appropriées.
https://schemas.openid.net/secevent/risc/event-type/verification état = state Suggestion : consigner qu'un jeton de test a été reçu.

Événements dupliqués et manqués

La protection multicompte tentera de retransmettre les événements qui, selon elle, n'ont pas été transmis. Par conséquent, vous pouvez parfois recevoir le même événement plusieurs fois. Si cela peut entraîner des actions répétées qui gênent vos utilisateurs, envisagez d'utiliser la revendication jti (qui est un identifiant unique pour un événement) pour dédupliquer les événements. Il existe des outils externes tels que Google Cloud Dataflow qui peuvent vous aider à exécuter le flux de données de déduplication.

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

Enregistrez votre récepteur

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

Vous ne recevrez des événements de sécurité que pour les utilisateurs de votre application. Vous devez donc configurer un écran de consentement OAuth dans votre projet GCP comme condition 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 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 JWT à l'aide de la clé privée de votre compte de service, que vous pouvez trouver dans le fichier JSON que vous avez téléchargé lors de la création de la clé de compte de service.

Par exemple:

Java

Utilisation 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 d'API RISC pendant une heure. Lorsque le jeton expire, générez-en un nouveau pour continuer à effectuer des appels d'API RISC.

2. Appelez l'API de configuration du 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 l'enregistrement de votre point de terminaison 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 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
  ]
}

Par 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 demande renvoie HTTP 200, le flux d'événements a été configuré avec succès et votre point de terminaison récepteur doit commencer à recevoir des jetons d'événement de sécurité. La section suivante décrit comment vous pouvez tester votre configuration de flux et votre point de terminaison pour vérifier que tout fonctionne correctement ensemble.

Obtenez et mettez à jour votre configuration de flux actuelle

Si, à l'avenir, vous souhaitez modifier la configuration de votre flux, vous pouvez 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 postez la configuration modifiée sur https://risc.googleapis.com/v1beta/stream:update comme décrit ci-dessus.

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

Si vous avez besoin d'arrêter le flux d'événements de Google, envoyez une requête POST autorisée à https://risc.googleapis.com/v1beta/stream/status:update avec { "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, POST { "status": "enabled" } au même point de terminaison.

3. Facultatif : testez la configuration de votre flux

Vous pouvez vérifier que votre configuration de flux et votre point de terminaison récepteur fonctionnent correctement ensemble en envoyant un jeton de vérification via votre flux d'événements. Ce jeton peut contenir une chaîne unique que vous pouvez utiliser pour vérifier que le jeton a été reçu sur votre point de terminaison.

Pour demander un jeton de vérification, 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"
}

Par 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 demande aboutit, le jeton de vérification sera envoyé au point de terminaison que vous avez enregistré. Ensuite, par exemple, si votre point de terminaison gère les jetons de vérification en les enregistrant simplement, vous pouvez examiner vos journaux pour confirmer que le jeton a été reçu.

Référence du code d'erreur

Les erreurs suivantes peuvent être renvoyées par l'API RISC :

Code d'erreur Message d'erreur Actions suggérées
400 La configuration du flux doit contenir le champ $fieldname . Votre demande adressé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é. L'autorisation à échouée. Assurez-vous que vous avez joint un jeton d'autorisation à la demande et que le jeton est valide et n'a pas expiré.
403 Le point de terminaison de livraison doit être une URL HTTPS. Votre point de terminaison de livraison (c'est-à-dire le point de terminaison auquel vous vous attendez à ce que les événements RISC soient livrés) doit être HTTPS. Nous n'envoyons pas d'événements RISC aux URL HTTP.
403 La configuration de flux existante n'a pas de méthode de livraison conforme aux spécifications pour RISC. Votre projet Google Cloud doit déjà avoir une configuration RISC. Si vous utilisez Firebase et que la connexion Google est activée, Firebase gérera 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éessayer de mettre à jour après une heure.
403 Le projet n'a pas pu être trouvé. Assurez-vous que vous utilisez 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 doit disposer des autorisations d'éditeur dans votre projet. Accédez à la console Google Cloud Platform de votre projet et accordez au compte de service qui effectue les appels l'autorisation d'éditeur/propriétaire pour votre projet en suivant ces instructions .
403 Les API de gestion de flux ne doivent être appelées que par un compte de service. Voici plus d'informations sur la façon dont vous pouvez appeler les API Google avec un compte de service .
403 Le point de terminaison de diffusion n'appartient à aucun des domaines de votre projet. Chaque projet possède un ensemble de domaines autorisés. Si votre point de terminaison de livraison (c'est-à-dire le point de terminaison auquel vous vous attendez à ce que les événements RISC soient livré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 utiliser cette API, votre projet doit avoir au moins un client OAuth configuré. 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, il est probable que RISC ne vous sera pas utile. En savoir plus sur l'utilisation d'OAuth par Google pour nos API .
403

Statut non pris en charge.

Statut invalide.

Nous ne prenons en charge que les statuts de flux « enabled » et « disabled » pour le moment.
404

Le projet n'a pas de configuration RISC.

Le projet n'a pas de configuration RISC existante, impossible de mettre à jour le statut.

Appelez le point de terminaison https://risc.googleapis.com/v1beta/stream:update pour créer une nouvelle configuration de flux.
4XX/5XX Impossible de mettre à jour le statut. Consultez le message d'erreur détaillé pour plus d'informations.

Accéder aux champs d'application des jetons

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

Point final 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?

Tout d'abord, consultez notre section de référence des codes d'erreur . Si vous avez encore des questions, postez-les sur Stack Overflow avec la balise #SecEvents .