Proteja contas de usuários com proteção entre contas

Se seu aplicativo permite que os usuários façam login em suas contas usando o Google, você pode melhorar a segurança das contas desses usuários compartilhados ouvindo e respondendo às notificações de eventos de segurança fornecidas pelo serviço de proteção entre contas.

Essas notificações alertam você sobre alterações importantes nas Contas do Google de seus usuários, que muitas vezes também podem ter implicações de segurança para suas contas com seu aplicativo. Por exemplo, se a Conta do Google de um usuário for invadida, isso poderá levar ao comprometimento da conta do usuário com seu aplicativo por meio da recuperação da conta de e-mail ou do uso de logon único.

Para ajudar você a reduzir o risco potencial desses eventos, o Google envia seus objetos de serviço chamados tokens de eventos de segurança. Esses tokens expõem muito pouca informação — apenas o tipo de evento de segurança e quando ocorreu, e o identificador do usuário afetado — mas você pode usá-los para tomar as medidas apropriadas em resposta. Por exemplo, se a Conta do Google de um usuário for comprometida, você poderá desativar temporariamente o Login com o Google para esse usuário e impedir que e-mails de recuperação de conta sejam enviados para o endereço do Gmail do usuário.

A proteção entre contas é baseada no padrão RISC , desenvolvido na OpenID Foundation.

Visão geral

Para usar a proteção entre contas com seu aplicativo ou serviço, você deve concluir as seguintes tarefas:

  1. Configure seu projeto no API Console.

  2. Crie um endpoint receptor de eventos, para o qual o Google enviará tokens de eventos de segurança. Esse endpoint é responsável por validar os tokens que recebe e, em seguida, responder aos eventos de segurança da maneira que você escolher.

  3. Registre seu endpoint no Google para começar a receber tokens de eventos de segurança.

Pré-requisito

Você só recebe tokens de eventos de segurança para usuários do Google que concederam permissão ao seu serviço para acessar as informações de perfil ou endereços de e-mail deles. Você obtém essa permissão solicitando o profile ou escopos de e- email . Os SDKs de login do Google mais recentes ou os SDKs de login do Google legados solicitam esses escopos por padrão, mas se você não usar as configurações padrão ou acessar o endpoint OpenID Connect do Google diretamente, verifique se está solicitando pelo menos um desses escopos.

Configurar um projeto no API Console

Antes de começar a receber tokens de evento de segurança, você deve criar uma conta de serviço e habilitar a API RISC em seu projetoAPI Console . Você deve usar o mesmo projetoAPI Console usado para acessar os serviços do Google, como o Login do Google, em seu aplicativo.

Para criar a conta de serviço:

  1. Abra o API ConsoleCredentials page . Quando solicitado, escolha o projetoAPI Consoleque você usa para acessar os serviços do Google em seu aplicativo.

  2. Clique em Criar credenciais > Conta de serviço .

  3. Crie uma nova conta de serviço com a função Editor.

  4. Crie uma chave para sua conta de serviço recém-criada. Escolha o tipo de chave JSON e clique em Criar . Quando a chave for criada, você fará o download de um arquivo JSON que contém as credenciais da sua conta de serviço. Mantenha esse arquivo em um local seguro, mas também acessível ao endpoint do receptor de eventos.

Enquanto estiver na página Credenciais do seu projeto, anote também os IDs de cliente que você usa para Fazer login com o Google ou Login do Google (herdado). Normalmente, você tem um ID de cliente para cada plataforma compatível. Você precisará desses IDs de cliente para validar os tokens de evento de segurança, conforme descrito na próxima seção.

Para habilitar a API RISC:

  1. Abra a página RISC API noAPI Console. Verifique se o projeto que você usa para acessar os serviços do Google ainda está selecionado.

  2. Leia os Termos RISC e certifique-se de entender os requisitos.

    Se você estiver habilitando a API para um projeto de propriedade de uma organização, certifique-se de estar autorizado a vincular sua organização aos Termos RISC.

  3. Clique em Habilitar somente se você concordar com os Termos RISC.

Criar um endpoint do receptor de eventos

Para receber notificações de eventos de segurança do Google, você cria um endpoint HTTPS que processa solicitações HTTPS POST. Depois de registrar esse endpoint (veja abaixo), o Google começará a postar strings assinadas criptograficamente chamadas tokens de evento de segurança para o endpoint. Os tokens de evento de segurança são JWTs assinados que contêm informações sobre um único evento relacionado à segurança.

Para cada token de evento de segurança que você recebe em seu endpoint, primeiro valide e decodifique o token e, em seguida, trate o evento de segurança conforme apropriado para seu serviço. É essencial validar o token de evento antes da decodificação para evitar ataques mal-intencionados de agentes mal-intencionados. As seções a seguir descrevem essas tarefas:

1. Decodifique e valide o token de evento de segurança

Como os tokens de evento de segurança são um tipo específico de JWT, você pode usar qualquer biblioteca JWT, como uma listada em jwt.io , para decodificá-los e validá-los. Qualquer que seja a biblioteca que você usa, seu código de validação de token deve fazer o seguinte:

  1. Obtenha o identificador do emissor da proteção entre contas ( issuer ) e o URI do certificado da chave de assinatura ( jwks_uri ) do documento de configuração RISC do Google, que pode ser encontrado em https://accounts.google.com/.well-known/risc-configuration .
  2. Usando a biblioteca JWT de sua escolha, obtenha o ID da chave de assinatura do cabeçalho do token de evento de segurança.
  3. No documento de certificado da chave de assinatura do Google, obtenha a chave pública com o ID da chave que você obteve na etapa anterior. Se o documento não contiver uma chave com o ID que você está procurando, é provável que o token de evento de segurança seja inválido e seu endpoint deve retornar o erro HTTP 400.
  4. Usando a biblioteca JWT de sua escolha, verifique o seguinte:
    • O token de evento de segurança é assinado usando a chave pública obtida na etapa anterior.
    • A declaração de aud do token é um dos IDs de cliente dos seus aplicativos.
    • A declaração iss do token corresponde ao identificador do emissor que você obteve do documento de descoberta RISC. Observe que você não precisa verificar a expiração do token ( exp ) porque os tokens de evento de segurança representam eventos históricos e, como tal, não expiram.

Por exemplo:

Java

Usando java-jwt e 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ão

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)

Se o token for válido e tiver sido decodificado com êxito, retorne o status HTTP 202. Em seguida, trate do evento de segurança indicado pelo token.

2. Lidar com eventos de segurança

Quando decodificado, um token de evento de segurança se parece com o seguinte exemplo:

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

As declarações iss e aud indicam o emissor do token (Google) e o destinatário pretendido do token (seu serviço). Você verificou essas reivindicações na etapa anterior.

A declaração jti é uma string que identifica um único evento de segurança e é exclusiva do fluxo. Você pode usar esse identificador para rastrear quais eventos de segurança você recebeu.

A declaração de events contém informações sobre o evento de segurança que o token representa. Essa declaração é um mapeamento de um identificador de tipo de evento para uma declaração de subject , que especifica o usuário a que esse evento se refere e para quaisquer detalhes adicionais sobre o evento que possam estar disponíveis.

A declaração de subject identifica um usuário específico com o ID exclusivo da Conta do Google do usuário ( sub ). Esse ID da Conta do Google é o mesmo identificador ( sub ) contido nos tokens de ID JWT emitidos pela biblioteca mais recente de login com o Google ( Javascript , HTML ), biblioteca de login do Google herdada ou OpenID Connect . Quando o subject_type da declaração é id_token_claims , ele também pode incluir um campo de email com o endereço de email do usuário.

Use as informações na declaração de events para executar a ação apropriada para o tipo de evento na conta do usuário especificado.

Tipos de eventos compatíveis

A proteção entre contas é compatível com os seguintes tipos de eventos de segurança:

Tipo de evento Atributos Como responder
https://schemas.openid.net/secevent/risc/event-type/sessions-revoked Obrigatório : proteja novamente a conta do usuário encerrando suas sessões abertas no momento.
https://schemas.openid.net/secevent/oauth/event-type/tokens-revoked

Obrigatório : se o token for para o Login do Google, encerre as sessões atualmente abertas. Além disso, você pode sugerir ao usuário que configure um método de entrada alternativo.

Sugestão : se o token for para acesso a outras APIs do Google, exclua qualquer um dos tokens OAuth do usuário que você armazenou.

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

Obrigatório : se o motivo da desativação da conta foi o hijacking , proteja novamente a conta do usuário encerrando suas sessões abertas no momento.

Sugerido : se o motivo da desativação da conta for uma conta bulk-account , analise a atividade do usuário em seu serviço e determine as ações de acompanhamento apropriadas.

Sugerido : se nenhum motivo for fornecido, desative o Login do Google para o usuário e desative a recuperação de conta usando o endereço de e-mail associado à Conta do Google do usuário (geralmente, mas não necessariamente, uma conta do Gmail). Ofereça ao usuário um método de login alternativo.

https://schemas.openid.net/secevent/risc/event-type/account-enabled Sugestão : reative o Login do Google para o usuário e reative a recuperação de conta com o endereço de e-mail da Conta do Google do usuário.
https://schemas.openid.net/secevent/risc/event-type/account-purged Sugerido : exclua a conta do usuário ou forneça a ele um método de login alternativo.
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required Sugerido : Fique atento a atividades suspeitas em seu serviço e tome as medidas apropriadas.
https://schemas.openid.net/secevent/risc/event-type/verification estado= state Sugerido : Registre que um token de teste foi recebido.

Eventos duplicados e perdidos

A proteção entre contas tentará reenviar eventos que acredita não terem sido entregues. Portanto, às vezes você pode receber o mesmo evento várias vezes. Se isso puder causar ações repetidas que incomodem seus usuários, considere usar a declaração jti (que é um identificador exclusivo para um evento) para desduplicar os eventos. Existem ferramentas externas, como o Google Cloud Dataflow , que podem ajudar você a executar o fluxo de dados de eliminação de duplicação.

Observe que os eventos são entregues com tentativas limitadas, portanto, se o receptor ficar inativo por um longo período de tempo, você poderá perder alguns eventos permanentemente.

Registre seu receptor

Para começar a receber eventos de segurança, registre seu endpoint receptor usando a API RISC. As chamadas para a API RISC devem ser acompanhadas por um token de autorização.

Você receberá eventos de segurança apenas para os usuários do seu aplicativo. Portanto, você precisa ter uma tela de consentimento do OAuth configurada em seu projeto do GCP como pré-requisito para as etapas descritas abaixo.

1. Gere um token de autorização

Para gerar um token de autorização para a API RISC, crie um JWT com as seguintes declarações:

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

Assine o JWT usando a chave privada da sua conta de serviço, que pode ser encontrada no arquivo JSON que você baixou quando criou a chave da conta de serviço.

Por exemplo:

Java

Usando java-jwt e a biblioteca de autenticação do 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ão

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')

Esse token de autorização pode ser usado para fazer chamadas de API RISC por uma hora. Quando o token expirar, gere um novo para continuar a fazer chamadas à API RISC.

2. Chame a API de configuração de fluxo RISC

Agora que você tem um token de autorização, pode usar a API RISC para configurar o fluxo de eventos de segurança do seu projeto, incluindo o registro do terminal receptor.

Para fazer isso, faça uma solicitação HTTPS POST para https://risc.googleapis.com/v1beta/stream:update , especificando seu endpoint receptor e os tipos de eventos de segurança nos quais você está interessado:

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 exemplo:

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ão

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'])

Se a solicitação retornar HTTP 200, o fluxo de eventos foi configurado com êxito e seu ponto de extremidade receptor deve começar a receber tokens de eventos de segurança. A próxima seção descreve como você pode testar sua configuração de stream e endpoint para verificar se tudo está funcionando corretamente em conjunto.

Obtenha e atualize sua configuração de stream atual

Se, no futuro, você quiser modificar sua configuração de stream, poderá fazê-lo fazendo uma solicitação GET autorizada para https://risc.googleapis.com/v1beta/stream para obter a configuração de stream atual, modificando o corpo da resposta e, em seguida, POSTe a configuração modificada de volta para https://risc.googleapis.com/v1beta/stream:update conforme descrito acima.

Parar e retomar o fluxo de eventos

Se você precisar interromper o fluxo de eventos do Google, faça uma solicitação POST autorizada para https://risc.googleapis.com/v1beta/stream/status:update com { "status": "disabled" } no corpo da solicitação. Enquanto o stream está desativado, o Google não envia eventos para seu endpoint e não armazena em buffer os eventos de segurança quando eles ocorrem. Para reativar o fluxo de eventos, POST { "status": "enabled" } para o mesmo endpoint.

3. Opcional: teste sua configuração de stream

Você pode verificar se a configuração do stream e o endpoint do receptor estão funcionando corretamente enviando um token de verificação por meio do stream de eventos. Esse token pode conter uma string exclusiva que você pode usar para verificar se o token foi recebido em seu endpoint.

Para solicitar um token de verificação, faça uma solicitação HTTPS POST autorizada para https://risc.googleapis.com/v1beta/stream:verify . No corpo da solicitação, especifique alguma string de identificação:

{
  "state": "ANYTHING"
}

Por exemplo:

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ão

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()))

Se a solicitação for bem-sucedida, o token de verificação será enviado para o endpoint que você registrou. Então, por exemplo, se seu endpoint lida com tokens de verificação simplesmente registrando-os, você pode examinar seus logs para confirmar que o token foi recebido.

Referência do código de erro

Os seguintes erros podem ser retornados pela API RISC:

Erro de código Mensagem de erro Ações sugeridas
400 A configuração do stream deve conter o campo $fieldname . Sua solicitação para o endpoint https://risc.googleapis.com/v1beta/stream:update é inválida ou não pode ser analisada. Por favor, inclua $fieldname em sua solicitação.
401 Não autorizado. Falha na autorização. Certifique-se de anexar um token de autorização à solicitação e de que o token é válido e não expirou.
403 O endpoint de entrega deve ser um URL HTTPS. Seu endpoint de entrega (ou seja, o endpoint para o qual você espera que os eventos RISC sejam entregues) deve ser HTTPS. Não enviamos eventos RISC para URLs HTTP.
403 A configuração de fluxo existente não tem um método de entrega compatível com especificações para RISC. Seu projeto do Google Cloud já deve ter uma configuração RISC. Se você estiver usando o Firebase e tiver o Login do Google ativado, o Firebase gerenciará o RISC para seu projeto; você não poderá criar uma configuração personalizada. Se você não estiver usando o Login do Google para seu projeto do Firebase, desative-o e tente atualizar novamente após uma hora.
403 Projeto não encontrado. Verifique se você está usando a conta de serviço correta para o projeto correto. Você pode estar usando uma conta de serviço associada a um projeto excluído. Saiba como ver todas as contas de serviço associadas a um projeto .
403 A conta de serviço deve ter permissões de editor em seu projeto. Acesse o console do Google Cloud Platform do seu projeto e conceda à conta de serviço que está fazendo as chamadas permissão de editor/proprietário para seu projeto seguindo estas instruções .
403 As APIs de gerenciamento de fluxo só devem ser chamadas por uma conta de serviço. Veja mais informações sobre como chamar APIs do Google com uma conta de serviço .
403 O endpoint de entrega não pertence a nenhum dos domínios do seu projeto. Cada projeto tem um conjunto de domínios autorizados. Se o seu endpoint de entrega (ou seja, o endpoint para o qual você espera que os eventos RISC sejam entregues) não estiver hospedado em um deles, exigimos que você adicione o domínio do endpoint a esse conjunto.
403 Para usar essa API, seu projeto deve ter pelo menos um cliente OAuth configurado. O RISC só funciona se você criar um aplicativo compatível com o Login do Google . Essa conexão requer um cliente OAuth. Se o seu projeto não tiver clientes OAuth, é provável que o RISC não seja útil para você. Saiba mais sobre o uso do OAuth pelo Google para nossas APIs .
403

Status sem suporte.

Estado inválido.

No momento, oferecemos suporte apenas aos status de transmissão “ enabled ” e “ disabled ”.
404

O projeto não tem configuração RISC.

O projeto não tem configuração RISC existente, não pode atualizar o status.

Chame o https://risc.googleapis.com/v1beta/stream:update endpoint para criar uma nova configuração de stream.
4XX/5XX Não foi possível atualizar o status. Verifique a mensagem de erro detalhada para obter mais informações.

Escopos do token de acesso

Caso você decida usar tokens de acesso para autenticação na API RISC, estes são os escopos que seu aplicativo deve solicitar:

Ponto final Alcance
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

Preciso de ajuda?

Primeiro, confira nossa seção de referência de código de erro . Se você ainda tiver dúvidas, poste-as no Stack Overflow com a tag #SecEvents .