Se o app permitir que os usuários façam login nas contas deles usando o Google, é possível melhorar a segurança das contas desses usuários compartilhados. Basta ouvir e responder às notificações de eventos de segurança fornecidas pelo serviço Proteção entre contas.
Essas notificações alertam você sobre grandes mudanças nas Contas do Google dos seus usuários, o que muitas vezes também pode ter implicações de segurança para as contas deles no seu app. Por exemplo, se a Conta do Google de um usuário tiver sido invadida, isso pode levar ao comprometimento da conta do usuário com seu app por meio da recuperação de conta de e-mail ou do uso do Logon único.
Para ajudar a reduzir o potencial de risco desses eventos, o Google envia os objetos de serviço chamados tokens de segurança. Esses tokens expõem muito pouca informação, 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 as medidas apropriadas em resposta. Por exemplo, se a Conta do Google de um usuário tiver sido comprometida, você poderá desativar temporariamente o recurso Fazer login com o Google para esse 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 baseia-se no padrão RISC, desenvolvido na OpenID Foundation.
Visão geral
Para usar a Proteção entre contas com seu app ou serviço, conclua as seguintes tarefas:
Configure seu projeto no API Console.
Crie um endpoint de receptor de eventos, para o qual o Google 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.
Registre seu endpoint no Google para começar a receber tokens de evento de segurança.
Pré-requisitos
Você só recebe tokens de evento de segurança de usuários do Google que concederam permissão ao seu serviço para acessar informações de perfil ou endereços de e-mail deles. Você recebe essa permissão solicitando os escopos profile ou email. Os SDKs
mais recentes do Fazer login com o Google ou
Login do Google legado solicitam esses escopos por padrão. No entanto,
se você não usar as configurações padrão ou acessar o endpoint
do OpenID Connect do Google,
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ê precisa criar uma conta de serviço e ativar a API RISC no projetoAPI Console . Use o mesmo projeto doAPI Console para acessar serviços do Google, como o Login do Google, no seu app.
Para criar a conta de serviço:
Abra o API Console Credentials page. Quando solicitado, escolha o projetoAPI Consoleque você usa para acessar os serviços do Google no seu app.
Clique em Criar credenciais > Conta de serviço.
Crie uma nova conta de serviço com o papel Administrador de configuração RISC (
roles/riscconfigs.admin) seguindo estas instruções.Crie uma chave para a 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 lugar seguro, mas também acessível ao endpoint do receptor do evento.
Quando estiver na página "Credenciais" do projeto, anote também os IDs de cliente usados para o Fazer login com o Google ou o Login do Google (legado). Normalmente, você tem um ID do cliente para cada plataforma compatível. Você precisará desses IDs do cliente para validar os tokens de eventos de segurança, conforme descrito na próxima seção.
Para ativar a API RISC:
Abra a página da API RISC noAPI Console. Verifique se o projeto que você usa para acessar os serviços do Google ainda está selecionado.
Leia os Termos do RISC e entenda os requisitos.
Se você estiver ativando a API para um projeto de uma organização, verifique se está autorizado a vincular sua organização aos Termos do RISC.
Clique em Ativar somente 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 processe solicitações HTTPS POST. Depois de registrar esse endpoint, o Google começará a postar strings assinadas criptograficamente, chamadas de 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 recebido no seu endpoint, valide e decodifique o token primeiro. 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, é possível usar qualquer biblioteca JWT, como a listada em jwt.io, para decodificá-los e validá-los. Independentemente da biblioteca usada, seu código de validação de token precisa fazer o seguinte:
- Consiga 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 emhttps://accounts.google.com/.well-known/risc-configuration. - Usando a biblioteca JWT de sua escolha, consiga o ID da chave de assinatura no cabeçalho do token de evento de segurança.
- No documento do certificado de chave de assinatura do Google, consiga a chave pública com o ID da chave que você recebeu na etapa anterior. Se o documento não contiver uma chave com o código 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.
- Usando a biblioteca JWT de sua escolha, verifique o seguinte:
- O token de evento de segurança é assinado usando a chave pública que você recebeu na etapa anterior.
- A declaração
auddo token é um dos IDs de cliente dos seus apps. - A declaração
issdo token corresponde ao identificador do emissor que você recebeu do documento de descoberta RISC. Observe que você não precisa verificar a validade do token (exp), porque os tokens de evento de segurança representam eventos históricos e, portanto, 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, retorne o status HTTP 202. Em seguida, processe o evento de segurança indicado pelo token.
2. Processar ocorrências 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 stream. É possível usar esse identificador para rastrear quais ocorrências de segurança você recebeu.
A declaração 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 subject, que especifica o usuário sobre o qual esse evento se refere, além de outros
detalhes sobre o evento que podem estar disponíveis.
A declaração 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 do JWT emitidos pela biblioteca do Login do Google mais recente (Javascript,
HTML), biblioteca legada do Login do Google ou
OpenID Connect. Quando o subject_type da declaração é id_token_claims, também pode incluir um campo email com o endereço de e-mail do usuário.
Use as informações da declaração events para realizar a ação apropriada para o tipo de evento na conta do usuário especificado.
Identificadores de token OAuth
Para eventos OAuth sobre tokens individuais, o tipo de identificador subject assunto contém os seguintes campos:
token_type: somenterefresh_tokené compatível.token_identifier_alg: veja os valores possíveis na tabela abaixo.token: consulte a tabela abaixo.
| token_identifier_alg (em inglês) | 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: encerre a sessão atual do usuário e proteja-a novamente. | |
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, convém sugerir ao usuário que configure um método de login alternativo. Sugerido: se o token for para acessar outras APIs do Google, exclua qualquer um dos tokens OAuth do usuário que você armazenou. |
|
https://schemas.openid.net/secevent/oauth/event-type/token-revoked |
Consulte a seção Identificadores de token OAuth para ver os identificadores de token. |
Obrigatório: se você armazenar o token de atualização correspondente, exclua-o e solicite o consentimento do usuário 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 o motivo da desativação da conta for Sugerido: se o motivo da desativação da conta for Sugerido: se nenhum motivo for fornecido, desative o Login do Google para o usuário e 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 |
Sugerido: reative o Login do Google do 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 |
Sugerida: 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 atento a atividades suspeitas no seu serviço e tome as medidas adequadas. | |
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 ela acredita que não foram. Portanto, 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. Há ferramentas externas, como o Google Cloud Dataflow, que podem ajudar você a executar o Dataflow sem duplicação.
Observe que 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 seu 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ê receberá ocorrências de segurança apenas para os usuários do aplicativo. Por isso, é necessário ter uma tela de consentimento OAuth configurada no projeto do GCP como 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ê baixou quando criou 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 à API RISC por uma hora. Quando o token expirar, gere um novo para continuar fazendo chamadas à API RISC.
2. Chamar a API de configuração de stream RISC
Agora que você tem um token de autorização, pode usar a API RISC para configurar o stream de eventos de segurança do 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 eventos 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, isso significa que o fluxo de eventos foi 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 juntos.
Receber e atualizar a configuração da transmissão atual
Se, no futuro, você quiser modificar a configuração de stream, faça uma solicitação GET autorizada para https://risc.googleapis.com/v1beta/stream para conseguir a configuração de stream atual, modificando o corpo da resposta e POSTando novamente a configuração modificada em https://risc.googleapis.com/v1beta/stream:update, conforme descrito acima.
Parar e retomar o stream 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 o endpoint e não armazena eventos de segurança em buffer quando eles ocorrem. Para reativar o stream de eventos, POST { "status": "enabled" } para o 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 corretamente juntos, envie um token de verificação por meio do stream de eventos. Esse token pode conter uma string exclusiva que pode ser usada para verificar se o token foi recebido no endpoint. Para usar esse fluxo, inscreva-se no tipo de evento https://schemas.openid.net/secevent/risc/event-type/verification ao registrar seu receptor.
Para solicitar um token de verificação, faça uma solicitação POST HTTPS 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 processar tokens de verificação apenas por meio de registros, examine os 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 de stream precisa conter o campo $fieldname. | Sua solicitação para o ponto de extremidade https://risc.googleapis.com/v1beta/stream:update é inválida ou não pode ser analisada. Inclua $fieldname na 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. | O endpoint de entrega (ou seja, o endpoint em que os eventos RISC serão entregues) 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 em conformidade com as especificações para RISC. | Seu projeto do Google Cloud já 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 seu 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 como ver todas as contas de serviço associadas a um projeto. |
| 403. | A conta de serviço precisa de permissão para acessar sua configuração RISC | Acesse o papel API Console do seu projeto e atribua o papel "Administrador de configuração RISC" (roles/riscconfigs.admin) à conta de serviço que está fazendo as chamadas para o 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. | Cada projeto tem um conjunto de domínios autorizados. Se o endpoint de entrega (ou seja, o endpoint que espera os eventos RISC ser entregue) não estiver hospedado em um deles, será necessário adicionar o domínio do endpoint a esse conjunto. |
| 403. | Para usar essa API, seu projeto precisa ter pelo menos um cliente OAuth configurado. | O RISC só funcionará se você criar um app compatível com o Login do Google. Esta conexão requer um cliente OAuth. Se o projeto não tiver clientes OAuth, é provável que o RISC não seja útil para você. Saiba mais sobre como o Google usa o OAuth para nossas APIs. |
| 403. |
Status incompatível. Status de inválido(a). |
No momento, o status da transmissão é compatível apenas com "enabled" e
"disabled". |
| 404. |
O projeto não tem configuração RISC. O projeto não tem uma configuração RISC. Não é possível atualizar o status. |
Chame o ponto de extremidade 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. | Verifique a mensagem de erro detalhada para mais informações. |
Acessar escopos do token
Se você decidir usar tokens de acesso para autenticação na API RISC, estes são os escopos que seu aplicativo precisa solicitar:
| Endpoint | Scope |
|---|---|
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 de código de erro. Se você ainda tiver dúvidas, poste-as no Stack Overflow com a tag #SecEvents.