Proteger contas de usuários com a Proteção entre contas

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Se o app permitir que usuários façam login nas contas usando o Google, é possível melhorar a segurança dessas contas compartilhadas ao ouvir e responder às notificações de eventos de segurança fornecidas pelo serviço de proteção de várias contas.

Essas notificações alertam você sobre grandes mudanças nas Contas do Google dos seus usuários, que muitas vezes também podem ter implicações de segurança para as contas deles com seu app. Por exemplo, se uma Conta do Google do usuário for invadida, ela pode poder comprometer o uso da conta do usuário por meio do e-mail da recuperação ou o uso de um logon único.

Para ajudar a reduzir o potencial de risco desses eventos, o Google envia os objetos de serviço chamados tokens de eventos de segurança. Esses tokens expõem muito poucas informações, apenas o tipo de ocorrência de segurança e quando ela ocorreu e o identificador do usuário afetado, mas você pode usá-los para tomar a ação apropriada em resposta. Por exemplo, se a Conta do Google do usuário estiver comprometida, você poderá desativar temporariamente o Fazer login com o Google desse usuário e impedir que os e-mails de recuperação da conta sejam enviados para o endereço do Gmail do usuário.

A Proteção entre contas é baseada no padrão RISC (em inglês), desenvolvido na OpenID Foundation.

Visão geral

Para usar a Proteção de várias contas com seu app ou serviço, é necessário concluir as tarefas a seguir:

  1. Configure seu projeto no API Console.

  2. Criar um endpoint de receptor de eventos, para onde o Google vai enviar tokens de evento de segurança. Esse endpoint é responsável por validar os tokens recebidos e responder a eventos de segurança da maneira que você escolher.

  3. Registre seu endpoint com o Google para começar a receber tokens de ocorrências de segurança.

Pré-requisito

Você só recebe tokens de ocorrências de segurança para os usuários do Google que concederam ao seu serviço permissão para acessar as informações do perfil ou os endereços de e-mail deles. Para receber essa permissão, solicite os escopos profile ou email. Os SDKs mais recentes do Login com o Google ou do Login legado solicitam esses escopos por padrão, mas se você não usar as configurações padrão ou se acessar o endpoint do 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, crie uma conta de serviço e ative a API RISC no seu projetoAPI Console . Use o mesmo projetoAPI Console usado para acessar serviços do Google, como o Login do Google, no app.

Para criar a conta de serviço:

  1. Abra o API Console Credentials page. Quando solicitado, escolha o projetoAPI Consoleque você usa para acessar os serviços do Google no seu app.

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

  3. Crie uma conta de serviço com o papel de editor.

  4. Crie uma chave para a conta de serviço recém-criada. Escolha o tipo de chave JSON e clique em Criar. Após a criação da chave, você fará o download de um arquivo JSON com as credenciais da sua conta de serviço. Mantenha esse arquivo em um lugar seguro, mas também acessível para o endpoint do receptor do evento.

Enquanto você estiver na página "Credenciais" do projeto, anote também os IDs do cliente usados para o Login com o Google ou o Login do Google (legado). Normalmente, você tem um ID do cliente para cada plataforma com suporte. Esses IDs do cliente serão necessários para validar os tokens do evento de segurança, conforme descrito na próxima seção.

Para ativar a API RISC:

  1. Abra a página da API RISC no API Console. Verifique se o projeto usado para acessar os serviços do Google ainda está selecionado.

  2. Leia os Termos do RISC e entenda os requisitos.

    Se você estiver ativando a API para um projeto de uma organização, verifique se tem autorização para vincular sua organização aos Termos do RISC.

  3. Clique em Ativar apenas se você concordar com os Termos do RISC.

Criar um endpoint de receptor de eventos

Para receber notificações de eventos de segurança do Google, crie um endpoint HTTPS que gerencie solicitações HTTPS POST. Depois que você registrar esse endpoint (veja abaixo), o Google começará a postar strings assinadas criptograficamente e chamadas de tokens de evento de segurança no 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ê receber no seu endpoint, primeiro valide e decodifique o token. Em seguida, processe 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 usuários de má-fé. As seções a seguir descrevem essas tarefas:

1. Decodificar e validar 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 a listada em jwt.io, para decodificar e validá-los. Seja qual for a biblioteca usada, o código de validação do token precisa:

  1. Consulte o identificador do emissor da Proteção de várias contas (issuer) e o URI do certificado de chave de assinatura (jwks_uri) no 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, consiga o ID da chave de assinatura no cabeçalho do token de evento de segurança.
  3. No documento de certificado da chave de assinatura do Google, receba a chave pública com o ID da chave que você recebeu na etapa anterior. Se o documento não tiver 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 retorne 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 da etapa anterior.
    • A declaração aud do token é um dos IDs do cliente dos seus apps.
    • A declaração iss do token corresponde ao identificador do emissor que você recebeu do documento de descoberta RISC. Não é necessário verificar a expiração do token (exp) porque os tokens de evento de segurança representam eventos históricos e, por isso, não expiram.

Exemplo:

Java

Como usar 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;
}

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)

Se o token for válido e decodificado, retornar o status HTTP 202. Em seguida, processe a ocorrência de segurança indicada pelo token.

2. Lidar com ocorrências de segurança

Quando decodificado, um token de evento de segurança é semelhante ao exemplo a seguir:

{
  "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 do token (seu serviço). Você verificou essas declarações na etapa anterior.

A declaração jti é uma string que identifica um único evento de segurança e é exclusiva para o stream. É possível usar esse identificador para rastrear as ocorrências de segurança que você recebeu.

A declaração events contém informações sobre a ocorrência de segurança que o token representa. Essa declaração é um mapeamento de um identificador de tipo de evento para uma declaração subject, que especifica o usuário em questão e todos os outros detalhes sobre o evento.

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

Use as informações da declaração events para tomar as medidas apropriadas quanto ao tipo de evento na conta do usuário especificado.

Identificadores de token OAuth

Para eventos OAuth sobre tokens individuais, o tipo de identificador de subject de token contém os seguintes campos:

  • token_type: somente refresh_token é compatível.

  • token_identifier_alg: consulte a tabela abaixo para ver os possíveis valores.

  • token: consulte a tabela abaixo.

token_identifier_alg token
prefix Os primeiros 16 caracteres do token.
hash_base64_sha512_sha512 O hash duplo do token usando SHA-512.

Se você fizer a integração com esses eventos, será recomendável indexar seus tokens com base nesses valores possíveis para garantir uma correspondência rápida quando o evento for recebido.

Tipos de evento compatíveis

A Proteção entre contas é compatível com os seguintes tipos de ocorrências 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 as sessões abertas no momento.
https://schemas.openid.net/secevent/oauth/event-type/tokens-revoked

Obrigatório: se o token for para Login do Google, encerre as sessões abertas no momento. Além disso, é recomendável sugerir ao usuário a configuração de um método de login alternativo.

Sugerido: se o token for para acesso a outras APIs do Google, exclua qualquer um dos tokens OAuth armazenados pelo usuário.

https://schemas.openid.net/secevent/oauth/event-type/token-revoked Consulte a seção Identificadores de token OAuth para ver identificadores de token.

Obrigatório: se você armazenar o token de atualização correspondente, exclua-o e solicite que o usuário autorize novamente na próxima vez que um token de acesso for necessário.

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

Obrigatório: se a conta foi desativada por hijacking, corrija a conta do usuário encerrando as sessões abertas no momento.

Sugerido: se o motivo da conta foi desativada: bulk-account, analise a atividade do usuário no seu serviço e determine as ações de acompanhamento apropriadas.

Sugerido: se nenhum motivo tiver sido fornecido, desative o Login do Google para o usuário e desative a recuperação da 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 Sugerido: 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 um método de login alternativo.
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required Sugerido: fique de olho em atividades suspeitas no seu serviço e tome as medidas necessárias.
https://schemas.openid.net/secevent/risc/event-type/verification estado=state Sugestão: registre que um token de teste foi recebido.

Eventos duplicados e perdidos

A Proteção entre contas tentará entregar novamente os eventos que ele 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 atrapalham os usuários, considere usar a declaração jti, que é um identificador exclusivo de um evento, para eliminar a duplicação dos eventos. Existem ferramentas externas, como o Google Cloud Dataflow, que podem ajudar a executar o fluxo de dados sem duplicação.

Os eventos são entregues com novas tentativas limitadas. Portanto, se o receptor ficar inativo por um período prolongado, você poderá perder alguns eventos permanentemente.

Registrar o receptor

Para começar a receber ocorrências de segurança, registre o endpoint do receptor usando a API RISC. As chamadas para a API RISC precisam ser acompanhadas por um token de autorização.

Você vai receber eventos de segurança apenas para os usuários do seu app. Portanto, você precisa ter uma tela de permissão OAuth configurada no seu projeto do GCP como um pré-requisito para as etapas descritas abaixo.

1. Gerar um token de autorização

Para gerar um token de autorização da 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 conta de serviço, que pode ser encontrada no arquivo JSON que você salvou ao criar a chave da conta de serviço.

Exemplo:

Java

Como usar 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;
}

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

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

2. Chamar a API RISC stream configuration

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 endpoint do receptor.

Para fazer isso, faça uma solicitação HTTPS POST para https://risc.googleapis.com/v1beta/stream:update, especificando o endpoint do receptor e os tipos de ocorrências de segurança em que você tem interesse:

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
  ]
}

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

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

Se a solicitação retornar HTTP 200, o stream de eventos terá sido configurado e o endpoint do receptor começará a receber tokens de eventos de segurança. A próxima seção descreve como testar a configuração e o endpoint do stream para verificar se tudo está funcionando corretamente em conjunto.

Acessar e atualizar a configuração da transmissão atual

Se, no futuro, você quiser modificar a configuração do fluxo, poderá fazer uma solicitação GET autorizada para https://risc.googleapis.com/v1beta/stream para receber a configuração de stream atual, modificar o corpo da resposta e postar a configuração modificada de volta em https://risc.googleapis.com/v1beta/stream:update, conforme descrito acima.

Interromper 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 eventos de segurança em buffer quando eles ocorrem. Para reativar o stream de eventos, POST { "status": "enabled" } no mesmo endpoint.

3. Opcional: testar a configuração do stream

Para verificar se a configuração do stream e o endpoint do receptor estão funcionando juntos corretamente, envie um token de verificação pelo stream de eventos. Esse token pode conter uma string exclusiva que pode ser usada para verificar se o token foi recebido no endpoint.

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

{
  "state": "ANYTHING"
}

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

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

Se a solicitação for bem-sucedida, o token de verificação será enviado para o endpoint que você registrou. Por exemplo, se o endpoint lidar com tokens de verificação simplesmente registrando-os, você poderá examinar seus registros para confirmar se o token foi recebido.

Referência do código de erro

Os seguintes erros podem ser retornados pela API RISC:

Código do erro Mensagem de erro Ações sugeridas
400 A configuração do stream precisa 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. Inclua $fieldname na sua solicitação.
401 Não autorizado. Falha na autorização. Verifique se você anexou um token de autorização com a solicitação e se o token é válido e não expirou.
403 O endpoint de entrega precisa ser um URL HTTPS. Seu endpoint de entrega (ou seja, o endpoint que receberá os eventos RISC para entrega) precisa ser HTTPS. Não enviamos eventos RISC para URLs HTTP.
403 A configuração de stream atual não tem um método de entrega compatível com especificações para RISC. Seu projeto do Google Cloud precisa ter uma configuração RISC. Se você estiver usando o Firebase e tiver o Login do Google ativado, o Firebase gerenciará o RISC para o projeto. Não será possível criar uma configuração personalizada. Se você não estiver usando o Login do Google no seu projeto do Firebase, desative-o e tente atualizar novamente após uma hora.
403 Não foi possível encontrar o projeto. 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 mais sobre como ver todas as contas de serviço associadas a um projeto.
403 A conta de serviço precisa ter permissões de editor no projeto. Acesse o console do Google Cloud Platform do seu projeto e conceda à conta de serviço que está tornando o editor/autor das chamadas permissão para seu projeto seguindo estas instruções.
403 As APIs de gerenciamento de stream 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. Todo projeto tem um conjunto de domínios autorizados. Se o endpoint de entrega (ou seja, o endpoint que você espera que os eventos RISC sejam entregues) não está hospedado em um deles, é necessário adicionar o domínio do endpoint a esse conjunto.
403 Para usar essa API, o projeto precisa ter pelo menos um cliente OAuth configurado. O RISC só funciona se você criar um app compatível com o Login do Google. Essa conexão requer um cliente OAuth. Caso seu projeto não tenha clientes OAuth, é provável que o RISC não seja útil. Saiba mais sobre o uso do OAuth pelo Google para nossas APIs.
403

Status incompatível.

Status de inválido(a).

No momento, só aceitamos os status de stream"enabled"e"disabled".
404

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

O projeto não tem configurações RISC existentes, não é possível atualizar o status.

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

Escopos do token de acesso

Se você decidir usar tokens de acesso para autenticação na API RISC, estes são os escopos que o aplicativo precisa solicitar:

Endpoint Escopo
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

Precisa de ajuda?

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