Proteja las cuentas de usuario con la protección de cuentas cruzadas

Si su aplicación permite que los usuarios inicien sesión en sus cuentas usando Google, puede mejorar la seguridad de las cuentas de estos usuarios compartidos escuchando y respondiendo a las notificaciones de eventos de seguridad proporcionadas por el servicio Protección de cuentas cruzadas.

Estas notificaciones le alertan sobre cambios importantes en las cuentas de Google de sus usuarios, que a menudo también pueden tener implicaciones de seguridad para sus cuentas con su aplicación. Por ejemplo, si la cuenta de Google de un usuario fuera secuestrada, podría potencialmente llevar a comprometer la cuenta del usuario con su aplicación a través de la recuperación de la cuenta de correo electrónico o el uso del inicio de sesión único.

Para ayudarlo a mitigar el riesgo potencial de tales eventos, Google envía sus objetos de servicio 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 puede usarlos para tomar las medidas adecuadas en respuesta. Por ejemplo, si la cuenta de Google de un usuario se vio comprometida, podría deshabilitar temporalmente el inicio de sesión de Google para ese usuario y evitar que los correos electrónicos de recuperación de la cuenta se envíen a la dirección de Gmail del usuario.

La protección de cuentas cruzadas se basa en el estándar RISC , desarrollado en OpenID Foundation.

Descripción general

Para utilizar la protección de cuentas cruzadas con su aplicación o servicio, debe completar las siguientes tareas:

  1. Configure su proyecto en el API Console.

  2. Cree un extremo receptor de eventos, al que Google enviará tokens de eventos de seguridad. Este punto final es responsable de validar los tokens que recibe y luego responder a los eventos de seguridad de la forma que elija.

  3. Registre su punto final con Google para comenzar a recibir tokens de eventos de seguridad.

Requisito previo

Solo recibe tokens de eventos de seguridad para los usuarios de Google que hayan otorgado permiso a su servicio para acceder a la información de su perfil o direcciones de correo electrónico. Obtiene este permiso al solicitar el profile o email alcances de email . Los SDK de inicio de sesión de Google solicitan estos alcances de forma predeterminada, pero si no usa la configuración predeterminada o si accede directamente al punto final de OpenID Connect de Google, asegúrese de que solicita al menos uno de estos alcances.

Configurar un proyecto en el API Console

Antes de que pueda comenzar a recibir tokens de eventos de seguridad, debe crear una cuenta de servicio y habilitar la API RISC en su proyecto API Console. Debe usar el mismo proyecto API Console que usa para acceder a los servicios de Google, como el inicio de sesión de Google, en su aplicación.

Para crear la cuenta de servicio:

  1. Abra el API Console Credentials page . Cuando se le solicite, elija el proyecto API Console que usa para acceder a los servicios de Google en su aplicación.

  2. Haga clic en Crear credenciales> Clave de cuenta de servicio .

  3. Cree una nueva cuenta de servicio con el rol de Editor.

    Elija el tipo de clave JSON y luego haga clic en Crear . Cuando se crea la clave, descargará un archivo JSON que contiene las credenciales de su cuenta de servicio. Mantenga este archivo en un lugar seguro, pero también accesible para su terminal receptor de eventos.

Mientras está en la página de Credenciales de su proyecto, también tome nota de los ID de cliente que usa para el inicio de sesión de Google. Por lo general, tiene un ID de cliente para cada plataforma que admite. Necesitará 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:

  1. Abra la página de la API de RISC en API Console. Asegúrese de que el proyecto que usa para acceder a los servicios de Google aún esté seleccionado.

  2. Lea los Términos de RISC y asegúrese de comprender los requisitos.

    Si habilita la API para un proyecto propiedad de una organización, asegúrese de estar autorizado para vincular su organización a los Términos de RISC.

  3. Haga clic en Activar solo si acepta los Términos de RISC.

Crear un punto final de receptor de eventos

Para recibir notificaciones de eventos de seguridad de Google, cree un punto final HTTPS que maneje las solicitudes HTTPS POST. Después de registrar este punto final (ver más abajo), Google comenzará a publicar cadenas firmadas criptográficamente llamadas tokens de eventos de seguridad en el punto final. 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 reciba en su punto final, primero valide y decodifique el token, luego maneje el evento de seguridad según corresponda para su servicio. Las siguientes secciones describen estas tareas:

1. Decodificar y validar el token de evento de seguridad

Debido a que los tokens de eventos de seguridad son un tipo específico de JWT, puede usar cualquier biblioteca JWT, como una listada en jwt.io , para decodificarlos y validarlos. Independientemente de la biblioteca que utilice, su código de validación de token debe hacer lo siguiente:

  1. Obtenga el identificador de emisor ( issuer ) de protección de cuentas cruzadas y el URI del certificado de clave de firma ( jwks_uri ) del documento de configuración RISC de Google, que puede encontrar en https://accounts.google.com/.well-known/risc-configuration .
  2. Con la biblioteca JWT de su elección, obtenga el ID de la clave de firma del encabezado del token de evento de seguridad.
  3. Del documento de certificado de clave de firma de Google, obtenga la clave pública con el ID de clave que obtuvo en el paso anterior. Si el documento no contiene una clave con el ID que está buscando, es probable que el token de evento de seguridad no sea válido y su punto final debería devolver el error HTTP 400.
  4. Utilizando la biblioteca JWT de su elección, verifique lo siguiente:
    • El token de evento de seguridad se firma con la clave pública que obtuvo en el paso anterior.
    • El reclamo aud del token es uno de los ID de cliente de sus aplicaciones.
    • La reclamación de iss del token coincide con el identificador de emisor que obtuvo del documento de descubrimiento de RISC. Tenga en cuenta que no necesita verificar el vencimiento del token ( exp ) porque los tokens de eventos de seguridad representan eventos históricos y, como tales, no caducan.

Por ejemplo:

Java

Usando 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;
}

Pitón

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 descodificó correctamente, devuelva el estado HTTP 202. Luego, maneje el evento de seguridad indicado por el token.

2. Manejar eventos de seguridad

Cuando se decodifica, un token de evento de seguridad se parece al 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 (su servicio). Verificó estas afirmaciones en el paso anterior.

La reclamación jti es una cadena que identifica un solo evento de seguridad y es única para el flujo. Puede utilizar este identificador para realizar un seguimiento de los eventos de seguridad que ha recibido.

La notificación de events contiene información sobre el evento de seguridad que representa el token. Esta afirmación es un mapeo de un identificador de tipo de evento a una reclamación de 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 en subject identifica a un usuario en particular con el ID de cuenta de Google exclusivo del usuario ( sub ). Este ID es el mismo que el identificador contenido en los tokens de ID producidos por Google Sign-in . Cuando el subject_type del reclamo es id_token_claims , también puede incluir un campo de email con la dirección de correo electrónico del usuario.

Utilice la información de la notificación de events para tomar las medidas adecuadas para el tipo de evento en la cuenta de usuario especificada.

Tipos de eventos admitidos

La protección entre cuentas 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 : Vuelva 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 el inicio de sesión de Google, finalice sus sesiones abiertas actualmente. Además, es posible que desee sugerirle al usuario que configure un método de inicio de sesión alternativo.

Sugerido : si el token es para acceder a otras API de Google, elimine cualquiera de los tokens OAuth del usuario que haya almacenado.

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

Obligatorio : si la razón por la que se deshabilitó la cuenta fue un hijacking , vuelva a proteger la cuenta del usuario finalizando sus sesiones abiertas actualmente.

Sugerido : si la razón por la que se deshabilitó la cuenta fue una cuenta bulk-account , analice la actividad del usuario en su servicio y determine las acciones de seguimiento adecuadas.

Sugerido : si no se proporcionó ningún motivo, deshabilite el inicio de sesión de Google para el usuario y deshabilite la recuperación de la cuenta utilizando la dirección de correo electrónico asociada con la cuenta de Google del usuario (generalmente, pero no necesariamente, una cuenta de Gmail). Ofrezca al usuario un método de inicio de sesión alternativo.

https://schemas.openid.net/secevent/risc/event-type/account-enabled Sugerido : vuelva a habilitar el inicio de sesión de Google para el usuario y vuelva 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 Sugerido : elimine la cuenta del usuario o bríndele un método de inicio de sesión alternativo.
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required Sugerido : esté atento a la actividad sospechosa en su servicio y tome las medidas adecuadas.
https://schemas.openid.net/secevent/risc/event-type/verification estado = state Sugerido : registre que se recibió un token de prueba.

Eventos duplicados y perdidos

La protección entre cuentas intentará volver a enviar los eventos que crea que no se han entregado. Por lo tanto, a veces puede recibir el mismo evento varias veces. Si esto pudiera causar acciones repetidas que incomoden a sus usuarios, considere usar el reclamo jti (que es un identificador único para un evento) para deducir los eventos. Existen herramientas externas como Google Cloud Dataflow que pueden ayudarlo a ejecutar el flujo de datos de-dup.

Tenga en cuenta que los eventos se entregan con reintentos limitados, por lo que si su receptor está inactivo durante un período prolongado de tiempo, es posible que se pierda permanentemente algunos eventos.

Registre su receptor

Para comenzar a recibir eventos de seguridad, registre su punto final receptor usando la API RISC. Las llamadas a la API de RISC deben ir acompañadas de un token de autorización.

Recibirá eventos de seguridad solo para los usuarios de su aplicación, por lo que debe tener una pantalla de consentimiento de OAuth configurada en su proyecto de GCP como requisito previo para los pasos que se describen a continuación.

1. Genere un token de autorización

Para generar un token de autorización para la API de RISC, cree un JWT con las siguientes afirmaciones:

{
  "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
}

Firme el JWT con la clave privada de su cuenta de servicio, que puede encontrar en el archivo JSON que descargó cuando creó la clave de la cuenta de servicio.

Por ejemplo:

Java

Usando 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;
}

Pitón

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 utilizar para realizar llamadas a la API RISC durante una hora. Cuando el token caduque, genere uno nuevo para continuar haciendo llamadas a la API RISC.

2. Llame a la API de configuración de flujo RISC

Ahora que tiene un token de autorización, puede usar la API RISC para configurar el flujo de eventos de seguridad de su proyecto, incluido el registro de su punto final receptor.

Para hacerlo, realice una solicitud HTTPS POST a https://risc.googleapis.com/v1beta/stream:update , especificando el punto final de su receptor y los tipos de eventos de seguridad que le 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);

Pitón

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 el punto final del receptor debería comenzar a recibir tokens de eventos de seguridad. La siguiente sección describe cómo puede probar la configuración de la transmisión y el punto final para verificar que todo funcione correctamente en conjunto.

Obtenga y actualice su configuración de transmisión actual

Si, en el futuro, alguna vez desea modificar la configuración de su transmisión, puede hacerlo realizando una solicitud GET autorizada a https://risc.googleapis.com/v1beta/stream para obtener la configuración de transmisión actual, modificando el cuerpo de la respuesta y luego PUBLICAR la configuración modificada en https://risc.googleapis.com/v1beta/stream:update como se describe arriba.

Detener y reanudar la transmisión del evento

Si alguna vez necesita detener la transmisión de eventos de Google, realice una solicitud POST autorizada a https://risc.googleapis.com/v1beta/stream/status:update con { "status": "disabled" } en el cuerpo de la solicitud. Si bien la transmisión está desactivada, Google no envía eventos a su punto final y no almacena los eventos de seguridad cuando ocurren. Para volver a habilitar la transmisión de eventos, POST { "status": "enabled" } en el mismo punto final.

3. Opcional: prueba la configuración de tu transmisión

Puede verificar que la configuración de su transmisión y el punto final del receptor funcionan juntos correctamente enviando un token de verificación a través de su transmisión de eventos. Este token puede contener una cadena única que puede usar para verificar que el token se recibió en su punto final.

Para solicitar un token de verificación, realice una solicitud HTTPS POST autorizada a https://risc.googleapis.com/v1beta/stream:verify . En el cuerpo de la solicitud, especifique alguna 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);

Pitón

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 tiene éxito, el token de verificación se enviará al punto final que registró. Luego, por ejemplo, si su punto final maneja los tokens de verificación simplemente registrándolos, puede examinar sus 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 . Su solicitud al https://risc.googleapis.com/v1beta/stream:update endpoint no es válida o no se puede analizar. Incluya $ fieldname en su solicitud.
401 No autorizado. Autorización fallida. Asegúrese de adjuntar un token de autorización con la solicitud y de que el token sea válido y no haya caducado.
403 El punto final de entrega debe ser una URL HTTPS. Su punto final de entrega (es decir, el punto final al que espera que se entreguen los eventos RISC) debe ser HTTPS. No enviamos eventos RISC a URL HTTP.
403 La configuración de transmisión existente no tiene un método de entrega compatible con las especificaciones para RISC. Tu proyecto de Google Cloud ya debe tener una configuración RISC. Si está utilizando Firebase y tiene habilitado el inicio de sesión de Google, Firebase administrará RISC para su proyecto; no podrá crear una configuración personalizada. Si no está utilizando el inicio de sesión de Google para su proyecto de Firebase, desactívelo e intente actualizar nuevamente después de una hora.
403 No se pudo encontrar el proyecto. Asegúrese de estar utilizando la cuenta de servicio correcta para el proyecto correcto. Es posible que esté utilizando una cuenta de servicio asociada con un proyecto eliminado. Aprenda a ver todas las cuentas de servicio asociadas con un proyecto .
403 La cuenta de servicio debe tener permisos de editor en su proyecto. Vaya a la consola de Google Cloud Platform de su proyecto y otorgue a la cuenta de servicio que realiza las llamadas el permiso de editor / propietario para su proyecto siguiendo estas instrucciones .
403 Las API de administración de transmisiones solo deben ser llamadas por una cuenta de servicio. Aquí hay más información sobre cómo puede llamar a las API de Google con una cuenta de servicio .
403 El punto final de entrega no pertenece a ninguno de los dominios de su proyecto. Cada proyecto tiene un conjunto de dominios autorizados. Si su punto final de entrega (es decir, el punto final al que espera que se entreguen los eventos RISC) no está alojado en uno de ellos, es necesario que agregue el dominio del punto final a ese conjunto.
403 Para utilizar esta API, su proyecto debe tener al menos un cliente OAuth configurado. RISC solo funciona si crea una aplicación que admita Inicio de sesión de Google . Esta conexión requiere un cliente OAuth. Si su proyecto no tiene clientes OAuth, es probable que RISC no le resulte útil. Obtenga más información sobre el uso de OAuth por parte de Google para nuestras API .
403

Estado no admitido.

Estado inválido.

Solo admitimos los estados de transmisión " enabled " y " disabled " en este momento.
404

El proyecto no tiene configuración RISC.

El proyecto no tiene una configuración RISC existente, no se puede actualizar el estado.

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

Ámbitos de token de acceso

Si decide utilizar tokens de acceso para autenticarse en la API de RISC, estos son los ámbitos que debe solicitar su aplicación:

Punto final Alcance
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, consulte nuestra sección de referencia de códigos de error . Si aún tiene preguntas, publíquelas en Stack Overflow con la etiqueta #SecEvents .