Si votre application permet aux utilisateurs de se connecter à leurs comptes à l'aide de Google, vous pouvez améliorer la sécurité de ces comptes partagés en écoutant et en répondant aux notifications d'événements de sécurité fournies par le service Cross-Account Protection.
Ces notifications vous alertent des modifications majeures apportées aux comptes Google de vos utilisateurs, qui peuvent souvent avoir des implications en termes de sécurité pour leurs comptes dans votre application. Par exemple, si le compte Google d'un utilisateur était piraté, cela pourrait potentiellement entraîner la compromission de son compte dans votre application par le biais de la récupération de compte de messagerie ou de l'utilisation de l'authentification unique.
Pour vous aider à atténuer le risque potentiel de tels événements, Google vous envoie des objets de service appelés jetons d'événement de sécurité. Ces jetons n'exposent que très peu d'informations (le type d'événement de sécurité, la date à laquelle 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 était piraté, vous pourriez 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 :
Configurez votre projet dans API Console.
Créez un point de terminaison de récepteur d'événements auquel Google enverra des jetons d'événements 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.
Enregistrez votre point de terminaison auprès de Google pour commencer à recevoir des jetons d'événement de sécurité.
Conditions préalables
Vous ne recevez des jetons d'événement de sécurité que pour les utilisateurs Google qui ont accordé à votre service l'autorisation d'accéder à leurs informations de profil ou à leurs adresses e-mail. Vous obtenez cette autorisation en demandant les autorisations profile ou email. Les SDK S'identifier avec Google (nouveau) ou Google Sign-in (ancien) demandent ces autorisations 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, assurez-vous de demander au moins l'une de ces autorisations.
Configurer un projet dans API Console
Avant de pouvoir commencer à recevoir des jetons d'événements 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 :
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.
Cliquez sur Créer des identifiants > Compte de service.
Créez un compte de service avec le rôle Administrateur de configuration RISC (
roles/riscconfigs.admin) en suivant ces instructions.Créez une clé pour le compte de service que vous venez de créer. Sélectionnez 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 identifiants de votre compte de service. Conservez ce fichier dans un endroit sûr, mais également accessible au point de terminaison de votre 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 (ancienne version). En général, 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énements de sécurité, comme décrit dans la section suivante.
Pour activer l'API RISC :
Ouvrez la page de l'API RISC dansAPI Console. Assurez-vous que le projet que vous utilisez pour accéder aux services Google est toujours sélectionné.
Lisez les Conditions d'utilisation de 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é à associer votre organisation aux conditions d'utilisation de RISC.
Cliquez sur Activer uniquement si vous acceptez les conditions d'utilisation de RISC.
Créer un point de terminaison de récepteur d'événements
Pour recevoir des notifications d'événements de sécurité de Google, vous devez créer un point de terminaison HTTPS qui gère les requêtes HTTPS POST. Une fois ce point de terminaison enregistré (voir ci-dessous), Google commencera à y publier des chaînes signées de manière cryptographique appelées jetons d'événement de sécurité. Les jetons d'événement de sécurité sont des JWT signés qui contiennent des informations sur un événement unique lié à la sécurité.
Pour chaque jeton d'événement de sécurité que vous recevez à votre point de terminaison, commencez par valider et décoder le jeton, puis gérez l'événement de 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 de personnes malintentionnées. Les sections suivantes décrivent ces tâches :
1. Décoder et valider 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 jeton JWT, vous pouvez utiliser n'importe quelle bibliothèque JWT, comme celles listées 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 :
- Obtenez l'identifiant de l'émetteur de la protection multi-comptes (
issuer) et l'URI du certificat de clé de signature (jwks_uri) à partir du document de configuration RISC de Google, que vous trouverez à l'adressehttps://accounts.google.com/.well-known/risc-configuration. - À 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é.
- À 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 que votre point de terminaison renvoie l'erreur HTTP 400.
- À l'aide de la bibliothèque JWT de votre choix, vérifiez les points 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
auddu jeton est l'un des ID client de vos applications. - La revendication
issdu 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énements de sécurité représentent des événements historiques et n'expirent donc pas.
Exemple :
Java
Utiliser 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é, renvoyez l'état HTTP 202. Gérez ensuite 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 validé 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 propre au flux. Vous pouvez utiliser cet identifiant pour suivre les événements de sécurité que vous avez reçus.
La revendication events contient des informations sur l'événement de sécurité que représente le jeton. Cette revendication est une mise en correspondance 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 détails supplémentaires disponibles sur l'événement.
La revendication subject identifie un utilisateur spécifique grâce à l'ID de compte Google unique de l'utilisateur (sub). Cet ID de compte Google est le même identifiant (sub) que celui contenu dans les jetons d'ID JWT émis par la nouvelle bibliothèque 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 Objet du jeton contient les champs suivants :
token_type: seule la valeurrefresh_tokenest acceptée.token_identifier_alg: consultez le tableau ci-dessous pour connaître les valeurs possibles.token: voir le tableau ci-dessous.
| token_identifier_alg | token |
|---|---|
prefix |
Les 16 premiers caractères du jeton. |
hash_base64_sha512_sha512 |
Double hachage du jeton à l'aide de SHA-512. |
Si vous intégrez ces événements, il est suggéré d'indexer vos jetons en fonction de ces valeurs possibles pour assurer une correspondance rapide lorsque l'événement est reçu.
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 | 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é à Google Sign-In, mettez fin aux sessions actuellement ouvertes. Vous pouvez également suggérer à l'utilisateur de configurer une autre méthode de connexion. Recommandation : 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 |
Pour en savoir plus sur les identifiants de jetons, consultez la section Identifiants de jetons OAuth. |
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 compte a été désactivé pour le motif Suggestion : Si le compte a été désactivé pour la raison suivante : Suggestion : Si aucune raison n'a été fournie, désactivez la connexion avec 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). Proposez à l'utilisateur une autre méthode de connexion. |
https://schemas.openid.net/secevent/risc/event-type/account-enabled |
Suggestion : Réactivez Google Sign-In pour l'utilisateur et la récupération de compte avec l'adresse e-mail de son compte Google. | |
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required |
Suggestion : Surveillez 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é : enregistrez qu'un jeton de test a été reçu. |
Événements en double et manqués
La protection multicompte tentera de redistribuer les événements qui, selon elle, n'ont pas été distribués. Par conséquent, il est possible que vous receviez parfois 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) afin de 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 distribués avec un nombre limité de tentatives. Si votre récepteur est hors service 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 de sécurité, enregistrez votre point de terminaison de 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 avoir configuré un écran de consentement OAuth dans votre projet GCP comme condition préalable aux é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é lorsque vous avez créé la clé du compte de service.
Exemple :
Java
Utiliser java-jwt et 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 autre pour continuer à effectuer des appels à l'API RISC.
2. Appeler 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 enregistrer votre point de terminaison du 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 du 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 HTTP 200, cela signifie que le flux d'événements a été configuré correctement et que votre point de terminaison du récepteur devrait commencer à recevoir des jetons d'événements de sécurité. La section suivante explique comment tester la configuration de votre flux et votre point de terminaison pour vérifier que tout fonctionne correctement.
Obtenir et mettre à jour la configuration actuelle de votre flux
Si vous souhaitez modifier la configuration de votre flux à l'avenir, 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 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 provenant 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, envoyez une requête POST { "status": "enabled" } au même point de terminaison.
3. Facultatif : Tester la configuration de votre flux
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 que vous pouvez utiliser pour vérifier que le jeton a été reçu au niveau de 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é. Par exemple, si votre point de terminaison gère les jetons de validation en les consignant simplement, vous pouvez examiner vos journaux pour confirmer que le jeton a é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. | Votre requête 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 que ce jeton est valide et n'a pas expiré. |
| 403 | Le point de terminaison de la diffusion doit être une URL HTTPS. | Votre point de terminaison de distribution (c'est-à-dire le point de terminaison auquel vous vous attendez à ce que les événements RISC soient 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'une méthode 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 la connexion avec 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 la connexion Google pour votre projet Firebase, veuillez la désactiver, puis réessayer de mettre à jour au bout d'une heure. |
| 403 | Le projet est introuvable. | Assurez-vous d'utiliser le bon compte de service pour le bon projet. Il est possible que vous utilisiez 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 être autorisé à accéder à votre configuration RISC. | Accédez à la page API Console de votre projet et attribuez le rôle "Administrateur de la configuration RISC" (roles/riscconfigs.admin) au compte de service qui effectue les appels à votre projet en suivant ces instructions.
|
| 403 | Les API de gestion des flux ne doivent être appelées que par un compte de service. | Pour en savoir plus sur la façon d'appeler les API Google avec un compte de service, cliquez ici. |
| 403 | Le point de terminaison de la diffusion n'appartient à aucun des domaines de votre projet. | Chaque projet dispose d'un ensemble de domaines autorisés. Si votre point de terminaison de distribution (c'est-à-dire le point de terminaison auquel vous vous attendez à ce que les événements RISC soient distribués) n'est pas hébergé sur l'un d'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 ne comporte aucun client OAuth, il est probable que RISC ne vous soit pas utile. En savoir plus sur l'utilisation d'OAuth par Google pour ses API |
| 403 |
État non accepté. État incorrect |
Pour le moment, nous n'acceptons que les états de flux "enabled" et "disabled". |
| 404 |
Le projet ne comporte aucune configuration RISC. Le projet ne dispose d'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é. |
Niveaux d'accès des jetons
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 | 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 la section Référence des codes d'erreur. Si vous avez encore des questions, posez-les sur Stack Overflow en utilisant le tag #SecEvents.