Protege las cuentas de usuario con la Protección integral de la cuenta

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Si tu app permite que los usuarios accedan a sus cuentas con Google, puedes mejorar la seguridad de las cuentas de estos usuarios compartidos si escuchas y respondes 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 usurpó la Cuenta de Google de un usuario, se podría comprometer su cuenta mediante la recuperación de la cuenta de correo electrónico o el uso del inicio de sesión único.

Para ayudarte a mitigar el potencial de riesgo de esos eventos, Google envía tus objetos de servicio llamados tokens de evento de seguridad. Estos tokens exponen muy poca información (solo el tipo de evento de seguridad y cuándo ocurrió, además del identificador del usuario afectado), pero puedes usarlos para tomar las medidas adecuadas. Por ejemplo, si se hackeó la Cuenta de Google de un usuario, puedes inhabilitar la función Acceder con Google para ese usuario de forma temporal 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 OpenID Foundation.

Descripción general

Para usar la Protección integral de la cuenta con tu app o servicio, debes completar las siguientes tareas:

  1. Configura tu proyecto en el API Console.

  2. Crea un extremo de receptor de eventos al que Google enviará tokens de evento de seguridad. Este extremo es responsable de validar los tokens que recibe y, luego, responder a los eventos de seguridad de la manera que elijas.

  3. Registra tu extremo con Google para comenzar a recibir tokens de evento de seguridad.

Requisito previo

Solo recibes tokens de eventos de seguridad para los usuarios de Google que le otorgaron permiso a tu servicio para acceder a la información de su perfil o direcciones de correo electrónico. Para obtener este permiso, solicita los alcances profile o email. Los SDK de Acceso con Google más nuevos o los de Acceso con Google heredados solicitan estos alcances 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 alcances.

Configura un proyecto en el API Console

Antes de comenzar a recibir tokens de evento de seguridad, debes crear una cuenta de servicio y habilitar la API de RISC en el proyectoAPI Console . Debes usar el mismo proyectoAPI Console que usas para acceder a los servicios de Google, como el Acceso con Google, en tu aplicación.

Para crear la cuenta de servicio, sigue estos pasos:

  1. Abre API Console Credentials page. Cuando se te solicite, elige el proyectoAPI Consoleque usas para acceder a los servicios de Google en tu app.

  2. Haz clic en Crear credenciales > Cuenta de servicio.

  3. Crea una cuenta de servicio nueva con la función de administrador de configuración de RISC (roles/riscconfigs.admin) mediante estas instrucciones.

  4. Crea una clave para la cuenta de servicio recién creada. 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. Mantén 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 ID 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 ID de cliente para validar los tokens de eventos de seguridad, como se describe en la siguiente sección.

Para habilitar la API de RISC, haz lo siguiente:

  1. Abre la página de la API de RISC enAPI Console. Asegúrate de que el proyecto que usas para acceder a los servicios de Google aún esté seleccionado.

  2. Lee los Términos de RISC y asegúrate de comprender los requisitos.

    Si habilitas la API para un proyecto que es propiedad de una organización, asegúrate de tener autorización para vincular tu organización a las Condiciones del RISC.

  3. Haga clic en Habilitar solo si acepta las Condiciones del 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 HTTPS. Después de registrar este extremo (ver a continuación), Google comenzará a publicar en el extremo strings con firma criptográfica que sean tokens de evento de seguridad. 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 debes validar y decodificar el token y, luego, controlar el evento de seguridad según corresponda para tu servicio. Es fundamental validar el token de evento antes de la decodificación para evitar ataques maliciosos de personas 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 la que aparece en jwt.io, para decodificarlos y validarlos. Sin importar la biblioteca que uses, tu código de validación de tokens debe hacer lo siguiente:

  1. Obtén el identificador de la entidad emisora de la cuenta cruzada de protección (issuer) y el URI del certificado de clave de firma (jwks_uri) del documento de configuración de RISC de Google, que puedes encontrar en https://accounts.google.com/.well-known/risc-configuration.
  2. Con la biblioteca de JWT que elijas, obtén el ID de la clave de firma del encabezado del token de evento de seguridad.
  3. En el documento de certificado de 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 el extremo muestre el error HTTP 400.
  4. Con la biblioteca 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 aud del token es uno de los ID de cliente de tus apps.
    • La reclamación iss del 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), ya que los tokens de eventos de seguridad representan eventos históricos y, por lo tanto, 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, muestra el estado HTTP 202. Luego, controla el evento de seguridad indicado por el token.

2. Cómo controlar eventos de seguridad

Cuando se decodifica, un token de evento de seguridad se ve como el ejemplo siguiente:

{
  "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 la entidad emisora del token (Google) y el destinatario previsto del token (tu servicio). Verificaste estas reclamaciones en el paso anterior.

La reclamación jti es una string que identifica un solo evento de seguridad y es única de la transmisión. 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 corresponde este evento y a 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 (sub) del usuario. Este ID es el mismo identificador (sub) que contienen los tokens de ID de JWT emitidos por la biblioteca más reciente de Acceder con Google (Javascript, HTML), o la de Acceso con Google. Cuando el subject_type de la reclamación es id_token_claims, también podría incluir un campo email con la dirección de correo electrónico del usuario.

Usa la información de la reclamación events a fin de tomar las medidas adecuadas para el tipo de evento en la cuenta del usuario especificado.

Identificadores de token de OAuth

Para los eventos de OAuth sobre tokens individuales, el tipo de identificador subject subject contiene los siguientes campos:

  • token_type: Solo se admite refresh_token.

  • token_identifier_alg: Consulta la tabla a continuación para ver los valores posibles.

  • token: Consulta la tabla a continuación.

token_identificador_alg token
prefix Los primeros 16 caracteres del token
hash_base64_sha512_sha512 Es el hash doble del token mediante SHA-512.

Si integras estos eventos, se sugiere indexar tus tokens en función de estos valores posibles para garantizar una coincidencia rápida cuando se recibe 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: Finaliza las sesiones abiertas del usuario para proteger la cuenta del usuario.
https://schemas.openid.net/secevent/oauth/event-type/tokens-revoked

Obligatorio: Si el token es para el Acceso con Google, finaliza sus sesiones 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 API 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 token de OAuth para conocer los identificadores de token.

Obligatorio: Si almacenas el token de actualización correspondiente, bórralo y solicita al usuario que vuelva a otorgar 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 se inhabilitó la cuenta por un motivo de hijacking, vuelve a proteger la cuenta del usuario. Para ello, finaliza las sesiones que estén abiertas.

Sugerencia: Si la razón por la que se inhabilitó la cuenta fue bulk-account, analiza la actividad del usuario en el servicio y determina las acciones de seguimiento adecuadas.

Sugerencia: Si no se proporcionó ningún motivo, inhabilita el Acceso con Google para el usuario y la recuperación de la cuenta mediante 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 vuelve a habilitar 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-purged Sugerencia: Borra la cuenta del usuario o proporciónale un método de acceso alternativo.
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required Sugerencia: Busca actividad sospechosa en tu servicio y toma las medidas necesarias.
https://schemas.openid.net/secevent/risc/event-type/verification estado=state Sugerencia: Registra que se recibió un token de prueba.

Eventos duplicados y omitidos

La Protección integral de la cuenta intentará volver a entregar eventos que considera que no se entregaron. Por lo tanto, a veces puedes recibir el mismo evento varias veces. Si esto puede causar acciones repetidas que les resulten molestas a los usuarios, considera usar la reclamación jti (que es un identificador único para un evento) a fin de anular los duplicados. Existen herramientas externas como Google Cloud Dataflow que pueden ayudarte a ejecutar el flujo de trabajo para quitar duplicados.

Ten en cuenta que los eventos se entregan con reintentos limitados, por lo que si el receptor está inactivo durante un período prolongado, puedes perderte algunos eventos de forma permanente.

Registra tu receptor

Para comenzar a recibir eventos de seguridad, registra el extremo del receptor mediante la API de RISC. Las llamadas a la API de RISC deben ir acompañadas de un token de autorización.

Solo recibirás eventos de seguridad para los usuarios de tu app, así 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

A fin de generar un token de autorización para la API de RISC, 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

Mediante 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 haciendo llamadas a la API de RISC.

2. Llamar a la API de configuración de transmisión de RISC

Ahora que tienes un token de autorización, puedes usar la API de RISC para configurar la transmisión de eventos de seguridad de tu proyecto, incluido el registro del extremo del receptor.

Para hacerlo, realiza una solicitud HTTPS POST a https://risc.googleapis.com/v1beta/stream:update y especifica el extremo del 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 muestra HTTP 200, la transmisión del evento se configuró correctamente y el extremo del receptor debería comenzar a recibir tokens de evento de seguridad. En la siguiente sección, se describe cómo puedes probar el extremo y la configuración de la transmisión para verificar que todo funcione de manera correcta en conjunto.

Obtén y actualiza tu configuración de transmisión actual

Si en el futuro deseas modificar la configuración de tu transmisión, puedes hacerlo mediante una solicitud GET autorizada a https://risc.googleapis.com/v1beta/stream para obtener la configuración de la transmisión actual, modificar el cuerpo de la respuesta y, luego, publicar la configuración modificada de nuevo en https://risc.googleapis.com/v1beta/stream:update, como se describió anteriormente.

Cómo detener y reanudar la transmisión 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 la transmisión está desactivada, Google no envía eventos al extremo ni almacena en búfer los eventos de seguridad cuando ocurren. Para volver a habilitar la transmisión de eventos, PUBLICA { "status": "enabled" } en el mismo extremo.

3. Opcional: Prueba la configuración de la transmisión

Puedes verificar que la configuración de la transmisión y el extremo del receptor funcionen correctamente en conjunto si envías un token de verificación a través de la transmisión de eventos. Este token puede contener una string única que puedes usar para verificar que el token se recibió en tu extremo.

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 string 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, se enviará el token de verificación al extremo que registraste. Por ejemplo, si tu extremo controla los tokens de verificación mediante su registro, puedes examinar tus registros para confirmar que el token se recibió.

Referencia de código de error

La API de RISC puede mostrar 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 la solicitud.
401 No autorizado. No se pudo autorizar. Asegúrate de haber adjuntado un token de autorización a la solicitud y de que el token sea válido y no haya caducado.
403 El extremo de entrega debe ser una URL HTTPS. El extremo de entrega (es decir, el extremo al que esperas que se entreguen los eventos de RISC) debe ser HTTPS. No enviamos eventos RISC a URL HTTP.
403 La configuración de la 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 el Acceso con Google está habilitado, Firebase administrará el RISC de tu proyecto y no podrás crear una configuración personalizada. Si no usas el Acceso con Google para tu proyecto de Firebase, inhabilítalo y vuelve a intentarlo después de una hora.
403 No se pudo encontrar el proyecto. Asegúrate de usar la cuenta de servicio correcta para el proyecto correspondiente. Es posible que uses una cuenta de servicio asociada con un proyecto borrado. Obtén información sobre cómo ver todas las cuentas de servicio asociadas a un proyecto.
403 La cuenta de servicio necesita permiso para acceder a tu configuración de RISC Ve a la API Console de tu proyecto y asigna la función “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 las cuentas de servicio deben llamar a las API de administración de transmisiones. Aquí encontrarás más información sobre cómo llamar a las API 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 el extremo de entrega (es decir, el extremo al que esperas que se entreguen los eventos de RISC) no esté alojado en uno de ellos, debes agregar el dominio del extremo a ese conjunto.
403 Para usar esta API, tu proyecto debe tener configurado al menos un cliente de OAuth. RISC solo funciona si compilas una app que admite 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 de Google de OAuth para nuestras API.
403

Estado no admitido.

Estado no válido.

En este 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. No se puede actualizar el estado.

Llama al extremo https://risc.googleapis.com/v1beta/stream:update para crear una nueva configuración de transmisión.
4 XX/5 XX No se pudo actualizar el estado. Consulta el mensaje de error detallado para obtener más información.

Alcance del token de acceso

Si decides usar tokens de acceso para autenticarte en la API de RISC, estos son los alcances que tu aplicación debe solicitar:

Extremo Ámbito
https://risc.googleapis.com/v1beta/stream/status https://www.googleapis.com/auth/risc.status.readonly O 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 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 del código de error. Si todavía tienes preguntas, publícalas en Stack Overflow con la etiqueta #SecEvents.