Si tu app permite que los usuarios accedan a sus cuentas con Google, puedes mejorar la seguridad de estas cuentas de usuario compartidas escuchando y respondiendo las notificaciones de eventos de seguridad que proporciona el servicio de Protección integral de la cuenta.
Estas notificaciones te alertan sobre cambios importantes en las Cuentas de Google de tus usuarios, que a menudo también pueden tener implicaciones de seguridad para sus cuentas con tu app. Por ejemplo, si se hackea la Cuenta de Google de un usuario, esto podría comprometer su cuenta con tu app a través de la recuperación de la cuenta de correo electrónico o el uso del inicio de sesión único.
Para ayudarte a mitigar el riesgo potencial de estos eventos, Google envía a tu servicio objetos llamados tokens de eventos de seguridad. Estos tokens exponen muy poca información (solo el tipo de evento de seguridad y cuándo ocurrió, y el identificador del usuario afectado), pero puedes usarlos para tomar las medidas adecuadas en respuesta. Por ejemplo, si la Cuenta de Google de un usuario se viera comprometida, podrías inhabilitar temporalmente Acceder con Google para ese usuario y evitar que se envíen correos electrónicos de recuperación de la cuenta a la dirección de Gmail del usuario.
La Protección integral de la cuenta se basa en el estándar RISC, desarrollado en la OpenID Foundation.
Descripción general
Para usar la Protección integral de la cuenta con tu app o servicio, debes completar las siguientes tareas:
Configura tu proyecto en la Consola de APIs.
Crea un extremo receptor de eventos, al que Google enviará tokens de eventos de seguridad. Este extremo se encarga de validar los tokens que recibe y, luego, responder a los eventos de seguridad de la manera que elijas.
Registra tu extremo en Google para comenzar a recibir tokens de eventos de seguridad.
Requisitos
Solo recibes tokens de eventos de seguridad para los usuarios de Google que otorgaron permiso a tu
servicio para acceder a su información de perfil o direcciones de correo electrónico. Para obtener este permiso,
solicita los permisos profile o email. Los SDKs más recientes de Acceder con Google o los SDKs heredados de Acceso con Google solicitan estos permisos de forma predeterminada, pero si no usas la configuración predeterminada o si accedes directamente al extremo de OpenID Connect de Google, asegúrate de solicitar al menos uno de estos permisos.
Configura un proyecto en la Consola de APIs
Antes de comenzar a recibir tokens de eventos de seguridad, debes crear una cuenta de servicio y habilitar la API de RISC en tu proyecto de la Consola de APIs. Debes usar el mismo proyecto de la consola de APIs que usas para acceder a los servicios de Google, como Acceso con Google, en tu app.
Para crear la cuenta de servicio, sigue estos pasos:
Abre la página Credenciales de la consola de APIs. Cuando se te solicite, elige el proyecto de la consola de APIs que usas para acceder a los servicios de Google en tu app.
Haz clic en Crear credenciales > Cuenta de servicio.
Crea una cuenta de servicio nueva con el rol de administrador de configuración de RISC (
roles/riscconfigs.admin) siguiendo estas instrucciones.Si tu organización de Google Cloud permite la creación de claves de cuentas de servicio y planeas firmar JWT de forma local, crea una clave para la cuenta de servicio que acabas de crear (opcional). Elige el tipo de clave JSON y, luego, haz clic en Crear. Cuando se cree la clave, descargarás un archivo JSON que contiene las credenciales de tu cuenta de servicio. Conserva este archivo en un lugar seguro, pero también accesible para el extremo del receptor de eventos.
Mientras estás en la página Credenciales de tu proyecto, también toma nota de los IDs de cliente que usas para Acceder con Google o Acceso con Google (heredado). Por lo general, tienes un ID de cliente para cada plataforma que admites. Necesitarás estos IDs de cliente para validar los tokens de eventos de seguridad, como se describe en la siguiente sección.
Para habilitar la API de RISC, sigue estos pasos:
Abre la página de la API de RISC en la Consola de APIs. Asegúrate de que el proyecto que usas para acceder a los servicios de Google siga seleccionado.
Lee las Condiciones de RISC y asegúrate de comprender los requisitos.
Si habilitas la API para un proyecto que pertenece a una organización, asegúrate de tener autorización para vincular tu organización a las Condiciones de RISC.
Haz clic en Habilitar solo si aceptas las Condiciones de RISC.
Crea un extremo de receptor de eventos
Para recibir notificaciones de eventos de seguridad de Google, crea un extremo HTTPS que controle las solicitudes POST de HTTPS. Después de registrar este extremo (consulta más abajo), Google comenzará a publicar strings firmadas de forma criptográfica llamadas tokens de eventos de seguridad en el extremo. Los tokens de eventos de seguridad son JWT firmados que contienen información sobre un solo evento relacionado con la seguridad.
Para cada token de evento de seguridad que recibas en tu extremo, primero valida y decodifica el token y, luego, controla el evento de seguridad según corresponda para tu servicio. Es fundamental validar el token de evento antes de decodificarlo para evitar ataques maliciosos de agentes que actúan de mala fe. En las siguientes secciones, se describen estas tareas:
1. Decodifica y valida el token de evento de seguridad
Debido a que los tokens de eventos de seguridad son un tipo específico de JWT, puedes usar cualquier biblioteca de JWT, como una de las que se indican en jwt.io, para decodificarlos y validarlos. Independientemente de la biblioteca que uses, el código de validación de tokens debe hacer lo siguiente:
- Obtén el identificador de la entidad emisora de la Protección integral de la cuenta (
issuer) y el URI del certificado de la clave de firma (jwks_uri) del documento de configuración de RISC de Google, que puedes encontrar enhttps://accounts.google.com/.well-known/risc-configuration. - Con la biblioteca de JWT que elijas, obtén el ID de la clave de firma del encabezado del token de evento de seguridad.
- En el documento del certificado de la clave de firma de Google, obtén la clave pública con el ID de clave que obtuviste en el paso anterior. Si el documento no contiene una clave con el ID que buscas, es probable que el token de evento de seguridad no sea válido y que tu extremo deba devolver el error de HTTP 400.
- Con la biblioteca de JWT que elijas, verifica lo siguiente:
- El token de evento de seguridad se firma con la clave pública que obtuviste en el paso anterior.
- La reclamación
auddel token es uno de los IDs de cliente de tus apps. - La reclamación
issdel token coincide con el identificador de la entidad emisora que obtuviste del documento de descubrimiento de RISC. Ten en cuenta que no necesitas verificar el vencimiento del token (exp) porque los tokens de eventos de seguridad representan eventos históricos y, como tales, no vencen.
Por ejemplo:
Java
Usa java-jwt y 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 el token es válido y se decodificó correctamente, devuelve el estado HTTP 202. Luego, controla el evento de seguridad que indica el token.
2. Cómo controlar eventos de seguridad
Cuando se decodifica, un token de evento de seguridad se ve como el siguiente ejemplo:
{
"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"
}
}
}
Las reclamaciones iss y aud indican el emisor del token (Google) y el
destinatario previsto del token (tu servicio). Verificaste estas reclamaciones en el
paso anterior.
La reclamación jti es una cadena que identifica un solo evento de seguridad y es
única para el flujo. Puedes usar este identificador para hacer un seguimiento de los eventos de seguridad
que recibiste.
La reclamación events contiene información sobre el evento de seguridad que representa el token. Esta reclamación es una asignación de un identificador de tipo de evento a una reclamación subject,
que especifica el usuario al que se refiere este evento y cualquier detalle adicional
sobre el evento que pueda estar disponible.
La reclamación subject identifica a un usuario en particular con el ID de Cuenta de Google único del usuario (sub). Este ID de Cuenta de Google es el mismo identificador (sub) que se incluye en los tokens de ID de JWT que emite la biblioteca más reciente de Acceder con Google (JavaScript, HTML), la biblioteca heredada de Acceso con Google o OpenID Connect. Cuando el subject_type del
reclamo es id_token_claims, también puede incluir un campo email con la
dirección de correo electrónico del usuario.
Usa la información de la reclamación events para tomar las medidas adecuadas para el
tipo de evento en la cuenta del usuario especificado.
Identificadores de tokens de OAuth
En el caso de los eventos de OAuth sobre tokens individuales, el tipo de identificador token subject contiene los siguientes campos:
token_type: Solo se admiterefresh_token.token_identifier_alg: Consulta la siguiente tabla para conocer los valores posibles.token: Consulta la tabla que se encuentra más abajo.
| token_identifier_alg | token |
|---|---|
prefix |
Los primeros 16 caracteres del token. |
hash_base64_sha512_sha512 |
Es el hash doble del token con SHA-512. |
Si te integras con estos eventos, se sugiere que indexar tus tokens en función de estos valores posibles para garantizar una coincidencia rápida cuando se reciba el evento.
Tipos de eventos admitidos
La Protección integral de la cuenta admite los siguientes tipos de eventos de seguridad:
| Tipo de evento | Atributos | Cómo responder |
|---|---|---|
https://schemas.openid.net/secevent/risc/event-type/sessions-revoked |
Obligatorio: Vuelve a proteger la cuenta del usuario finalizando sus sesiones abiertas actualmente. | |
https://schemas.openid.net/secevent/oauth/event-type/tokens-revoked |
Obligatorio: Si el token es para Acceder con Google, finaliza las sesiones que estén abiertas en ese momento. Además, te recomendamos que le sugieras al usuario que configure un método de acceso alternativo. Sugerencia: Si el token es para acceder a otras APIs de Google, borra cualquiera de los tokens de OAuth del usuario que hayas almacenado. |
|
https://schemas.openid.net/secevent/oauth/event-type/token-revoked |
Consulta la sección Identificadores de tokens de OAuth para obtener más información. |
Obligatorio: Si almacenas el token de actualización correspondiente, bórralo y solicita al usuario que vuelva a dar su consentimiento la próxima vez que se necesite un token de acceso. |
https://schemas.openid.net/secevent/risc/event-type/account-disabled |
reason=hijacking,reason=bulk-account |
Obligatorio: Si el motivo por el que se inhabilitó la cuenta fue
Sugerencia: Si el motivo por el que se inhabilitó la cuenta fue
Sugerencia: Si no se proporcionó ningún motivo, inhabilita Acceder con Google para el usuario y la recuperación de la cuenta con la dirección de correo electrónico asociada a la Cuenta de Google del usuario (por lo general, pero no necesariamente, una cuenta de Gmail). Ofrece al usuario un método de acceso alternativo. |
https://schemas.openid.net/secevent/risc/event-type/account-enabled |
Sugerencia: Vuelve a habilitar el Acceso con Google para el usuario y la recuperación de la cuenta con la dirección de correo electrónico de la Cuenta de Google del usuario. | |
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required |
Sugerencia: Busca actividad sospechosa en tu servicio y toma las medidas adecuadas. | |
https://schemas.openid.net/secevent/risc/event-type/verification |
state=state | Sugerencia: Registra que se recibió un token de prueba. |
Eventos duplicados y no detectados
La Protección integral de la cuenta intentará volver a entregar los eventos que cree que no se entregaron. Por lo tanto, es posible que, en ocasiones, recibas el mismo evento
varias veces. Si esto puede causar acciones repetidas que incomoden a tus
usuarios, considera usar la reclamación jti (que es un identificador único para un
evento) para anular la duplicación de los eventos. Existen herramientas externas, como Google Cloud
Dataflow, que pueden ayudarte a ejecutar
el flujo de datos de desduplicación.
Ten en cuenta que los eventos se entregan con reintentos limitados, por lo que, si tu receptor no funciona durante un período prolongado, es posible que te pierdas algunos eventos de forma permanente.
Registra tu receptor
Para comenzar a recibir eventos de seguridad, registra tu extremo receptor con la API de RISC. Las llamadas a la API de RISC deben ir acompañadas de un token de autorización.
Recibirás eventos de seguridad solo para los usuarios de tu app, por lo que debes tener una pantalla de consentimiento de OAuth configurada en tu proyecto de GCP como requisito previo para los pasos que se describen a continuación.
1. Genera un token de autorización
Puedes generar un token de autorización para la API de RISC con la
Google Cloud CLI (gcloud) con la
identidad temporal como cuenta de servicio (se recomienda cuando se aplica iam.disableServiceAccountKeyCreation
o para la configuración única de la CLI) o firmando un JWT de forma local con una
clave privada de cuenta de servicio.
Opción A: Genera un token de acceso de corta duración con gcloud (no se requiere una clave JSON)
Si tu cuenta de usuario tiene el rol de creador de tokens de cuenta de servicio
(roles/iam.serviceAccountTokenCreator) en la cuenta de servicio, puedes crear un
token de acceso de OAuth 2.0 de corta duración con el permiso de configuración de RISC requerido
directamente desde tu terminal:
AUTH_TOKEN=$(gcloud auth print-access-token \
--impersonate-service-account=SERVICE_ACCOUNT_EMAIL \
--scopes=https://www.googleapis.com/auth/risc.configuration.readwrite,https://www.googleapis.com/auth/risc.verify,https://www.googleapis.com/auth/risc.status.readwrite)
Consulta Permisos de tokens de acceso para obtener más detalles sobre los permisos de OAuth 2.0 disponibles para la API de RISC.
Opción B: Crea un JWT autofirmado con una clave de cuenta de servicio
Como alternativa, para generar un token de autorización de forma local sin un viaje de ida y vuelta de red, crea un JWT con las siguientes reclamaciones:
{
"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
}Firma el JWT con la clave privada de tu cuenta de servicio, que puedes encontrar en el archivo JSON que descargaste cuando creaste la clave de la cuenta de servicio.
Por ejemplo:
Java
Usa java-jwt y la biblioteca de autenticación 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')
Este token de autorización se puede usar para realizar llamadas a la API de RISC durante una hora. Cuando el token venza, genera uno nuevo para seguir realizando llamadas a la API de RISC.
2. Llama a la API de configuración de transmisiones de RISC
Ahora que tienes un token de autorización, puedes usar la API de RISC para configurar el flujo de eventos de seguridad de tu proyecto, incluido el registro de tu extremo receptor.
Para hacerlo, realiza una solicitud HTTPS POST a https://risc.googleapis.com/v1beta/stream:update y especifica tu extremo receptor y los tipos de eventos de seguridad que te interesan:
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
]
}
Por ejemplo:
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 solicitud devuelve HTTP 200, el flujo de eventos se configuró correctamente y tu extremo receptor debería comenzar a recibir tokens de eventos de seguridad. En la siguiente sección, se describe cómo puedes probar la configuración de la transmisión y el extremo para verificar que todo funcione correctamente en conjunto.
Obtén y actualiza la configuración actual de tu transmisión
Si, en el futuro, quieres modificar la configuración de tu transmisión, puedes hacerlo
enviando una solicitud GET autorizada a https://risc.googleapis.com/v1beta/stream para obtener la
configuración actual de la transmisión, modificar el cuerpo de la respuesta y, luego, enviar la
configuración modificada a https://risc.googleapis.com/v1beta/stream:update como se describió anteriormente.
Detén y reanuda el flujo de eventos
Si alguna vez necesitas detener la transmisión de eventos de Google, realiza una solicitud POST autorizada a https://risc.googleapis.com/v1beta/stream/status:update con { "status": "disabled" } en el cuerpo de la solicitud. Mientras el flujo está desactivado, Google no envía eventos
a tu extremo ni almacena en búfer los eventos de seguridad cuando ocurren. Para
volver a habilitar el flujo de eventos, envía una solicitud POST { "status": "enabled" } al mismo extremo.
3. Opcional: Prueba la configuración de tu transmisión
Para verificar que la configuración de tu transmisión y el extremo del receptor funcionen correctamente, envía un token de verificación a través de tu transmisión de eventos. Este token puede contener una cadena única que puedes usar para verificar que el token se recibió en tu extremo. Para usar este flujo, asegúrate de suscribirte al tipo de evento https://schemas.openid.net/secevent/risc/event-type/verification cuando registres tu receptor.
Para solicitar un token de verificación, realiza una solicitud HTTPS POST autorizada a
https://risc.googleapis.com/v1beta/stream:verify. En el cuerpo de la solicitud, especifica una
cadena de identificación:
{
"state": "ANYTHING"
}
Por ejemplo:
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 solicitud se realiza correctamente, el token de verificación se enviará al extremo que registraste. Luego, por ejemplo, si tu extremo controla los tokens de verificación con solo registrarlos, puedes examinar tus registros para confirmar que se recibió el token.
Referencia de código de error
La API de RISC puede devolver los siguientes errores:
| Código de error | Mensaje de error | Acciones sugeridas |
|---|---|---|
| 400 | La configuración de la transmisión debe contener el campo $fieldname. | Tu solicitud al extremo https://risc.googleapis.com/v1beta/stream:update no es válida o no se puede analizar. Incluye $fieldname en tu solicitud. |
| 401 | No autorizado. | No se pudo autorizar. Asegúrate de haber adjuntado un token de autorización con la solicitud y de que el token sea válido y no haya vencido. |
| 403 | El extremo de entrega debe ser una URL HTTPS. | Tu extremo de entrega (es decir, el extremo al que esperas que se entreguen los eventos de RISC) debe ser HTTPS. No enviamos eventos de RISC a URLs HTTP. |
| 403 | La configuración de transmisión existente no tiene un método de entrega que cumpla con las especificaciones para RISC. | Tu proyecto de Google Cloud ya debe tener una configuración de RISC. Si usas Firebase y tienes habilitado el Acceso con Google, Firebase administrará RISC para tu proyecto. No podrás crear una configuración personalizada. Si no usas el Acceso con Google para tu proyecto de Firebase, inhabilítalo y, luego, intenta actualizarlo de nuevo después de una hora. |
| 403 | No se pudo encontrar el proyecto. | Asegúrate de usar la cuenta de servicio correcta para el proyecto adecuado. Es posible que estés usando una cuenta de servicio asociada con un proyecto borrado. Obtén más información para ver todas las cuentas de servicio asociadas con un proyecto. |
| 403 | La cuenta de servicio necesita permiso para acceder a tu configuración de RISC | Ve a la Consola de APIs de tu proyecto y
asigna el rol "Administrador de configuración de RISC"
(roles/riscconfigs.admin)
a la cuenta de servicio que realiza las llamadas a tu proyecto. Para ello,
sigue
estas instrucciones.
|
| 403 | Solo una cuenta de servicio debe llamar a las APIs de administración de transmisiones. | Aquí encontrarás más información sobre cómo puedes llamar a las APIs de Google con una cuenta de servicio. |
| 403 | El extremo de entrega no pertenece a ninguno de los dominios de tu proyecto. | Cada proyecto tiene un conjunto de dominios autorizados. Si tu extremo de entrega (es decir, el extremo al que esperas que se entreguen los eventos de RISC) no está alojado en uno de ellos, te pedimos que agregues el dominio del extremo a ese conjunto. |
| 403 | Para usar esta API, tu proyecto debe tener al menos un cliente de OAuth configurado. | RISC solo funciona si compilas una app que admita el Acceso con Google. Esta conexión requiere un cliente de OAuth. Si tu proyecto no tiene clientes de OAuth, es probable que RISC no te resulte útil. Obtén más información sobre el uso que hace Google de OAuth para nuestras APIs. |
| 403 |
Estado no admitido. Estado no válido. |
Por el momento, solo admitimos los estados de transmisión “enabled” y
“disabled”. |
| 404 |
El proyecto no tiene una configuración de RISC. El proyecto no tiene una configuración de RISC existente, por lo que no se puede actualizar el estado. |
Llama al extremo https://risc.googleapis.com/v1beta/stream:update para crear una configuración de transmisión nueva. |
| 4XX/5XX | No se pudo actualizar el estado. | Consulta el mensaje de error detallado para obtener más información. |
Permisos de tokens de acceso
Si decides usar tokens de acceso para autenticarte en la API de RISC, estos son los permisos que debe solicitar tu aplicación:
| Extremo | Alcance |
|---|---|
https://risc.googleapis.com/v1beta/stream/status |
https://www.googleapis.com/auth/risc.status.readonly
O BIEN 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
O BIEN 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 |
¿Necesitas ayuda?
Primero, consulta nuestra sección de referencia de códigos de error. Si aún tienes preguntas, publícalas en Stack Overflow con la etiqueta #SecEvents.