Ir para o console

Verificar tokens de código

Se o seu app cliente do Firebase se comunicar com um servidor de back-end personalizado, poderá ser necessário identificar o usuário atualmente conectado no servidor. Para fazer isso de maneira segura, após o login bem-sucedido, envie o token de código do usuário para o servidor usando HTTPS. Em seguida, no servidor, verifique a integridade e autenticidade do token de código e veja o uid dele. Use o uid transmitido dessa maneira para identificar com segurança o usuário conectado ao servidor.

Antes de começar

Para verificar os tokens de código com o SDK Admin do Firebase, você precisa ter uma conta de serviço. Siga as instruções de configuração do SDK Admin para saber mais sobre como inicializá-lo com uma conta de serviço.

Recuperar tokens de código de clientes

Quando um usuário ou dispositivo faz login, o Firebase cria um token de código correspondente que o identifica como único e concede a ele acesso a vários recursos, como o Firebase Realtime Database e o Cloud Storage. Você pode reutilizar esse token de código para identificar o usuário ou dispositivo no seu servidor de back-end personalizado. Para recuperar o token de código do cliente, verifique se o usuário está conectado e, em seguida, receba o token de código do usuário conectado:

iOS

Objective-C
FIRUser *currentUser = [FIRAuth auth].currentUser;
[currentUser getIDTokenForcingRefresh:YES
                           completion:^(NSString *_Nullable idToken,
                                        NSError *_Nullable error) {
          if (error) {
            // Handle error
            return;
          }

          // Send token to your backend via HTTPS
          // ...
}];
Swift
let currentUser = FIRAuth.auth()?.currentUser
currentUser?.getIDTokenForcingRefresh(true) { idToken, error in
  if let error = error {
    // Handle error
    return;
  }

  // Send token to your backend via HTTPS
  // ...
}

Android

FirebaseUser mUser = FirebaseAuth.getInstance().getCurrentUser();
mUser.getIdToken(true)
    .addOnCompleteListener(new OnCompleteListener<GetTokenResult>() {
        public void onComplete(@NonNull Task<GetTokenResult> task) {
            if (task.isSuccessful()) {
                String idToken = task.getResult().getToken();
                // Send token to your backend via HTTPS
                // ...
            } else {
                // Handle error -> task.getException();
            }
        }
    });

Unity

Firebase.Auth.FirebaseUser user = auth.CurrentUser;
user.TokenAsync(true).ContinueWith(task => {
  if (task.IsCanceled) {
    Debug.LogError("TokenAsync was canceled.");
   return;
  }

  if (task.IsFaulted) {
    Debug.LogError("TokenAsync encountered an error: " + task.Exception);
    return;
  }

  string idToken = task.Result;

  // Send token to your backend via HTTPS
  // ...
});

C++

firebase::auth::User* user = auth->current_user();
if (user != nullptr) {
  firebase::Future<std::string> idToken = user->GetToken(true);

  // Send token to your backend via HTTPS
  // ...
}

Web

firebase.auth().currentUser.getIdToken(/* forceRefresh */ true).then(function(idToken) {
  // Send token to your backend via HTTPS
  // ...
}).catch(function(error) {
  // Handle error
});

Assim que tiver um token de código, você pode enviar esse JWT para seu back-end e validá-lo por meio do SDK Admin do Firebase ou de uma biblioteca JWT de terceiros, caso seu servidor esteja gravado em uma linguagem com a qual o Firebase não tenha compatibilidade nativa.

Verificar os tokens de código com o SDK Admin do Firebase

O SDK Admin do Firebase tem um método integrado para verificar e decodificar tokens de código. Se o token de código fornecido tiver o formato correto, não tiver expirado e estiver devidamente assinado, o método retornará o token de código decodificado. Você pode ver o uid do usuário ou dispositivo no token decodificado.

Siga as instruções de configuração do SDK Admin para inicializar o SDK Admin com uma conta de serviço. Em seguida, use o método verifyIdToken() para verificar um token de código:

Node.js

// idToken comes from the client app (shown above)

admin.auth().verifyIdToken(idToken)
  .then(function(decodedToken) {
    var uid = decodedToken.uid;
    // ...
  }).catch(function(error) {
    // Handle error
  });

Java

// idToken comes from the client app (shown above)
FirebaseToken decodedToken = FirebaseAuth.getInstance().verifyIdToken(idToken);
String uid = decodedToken.getUid();

Python

# id_token comes from the client app (shown above)

decoded_token = auth.verify_id_token(id_token)
uid = decoded_token['uid']

Go

client, err := app.Auth(context.Background())
if err != nil {
	log.Fatalf("error getting Auth client: %v\n", err)
}

token, err := client.VerifyIDToken(ctx, idToken)
if err != nil {
	log.Fatalf("error verifying ID token: %v\n", err)
}

log.Printf("Verified ID token: %v\n", token)

C#

FirebaseToken decodedToken = await FirebaseAuth.DefaultInstance
    .VerifyIdTokenAsync(idToken);
string uid = decodedToken.Uid;

A verificação do token de código requer um código de projeto. O SDK Admin do Firebase tenta receber esse código por meio de um dos métodos a seguir:

  • Se o SDK foi inicializado com uma opção de aplicativo projectId explícita, o SDK usa o valor dessa opção.
  • Se o SDK foi inicializado com credenciais de conta de serviço, o SDK usa o campo project_id do objeto JSON da conta de serviço.
  • Se a variável de ambiente GOOGLE_CLOUD_PROJECT estiver definida, o SDK usa o valor dela como o código do projeto. Essa variável de ambiente está disponível para o código em execução na infraestrutura do Google, como o Google App Engine e o Google Compute Engine.

Verificar os tokens de código com uma biblioteca JWT de terceiros

Caso seu back-end esteja em uma linguagem incompatível com o SDK Admin do Firebase, ainda é possível verificar os tokens de código. Primeiro, encontre uma biblioteca JWT de terceiros para sua linguagem. Em seguida, verifique o cabeçalho, o payload e a assinatura do token de código.

Verifique se o cabeçalho do token de código está em conformidade com as seguintes restrições:

Reivindicações de cabeçalho do token de código
alg Algoritmo "RS256"
kid Código da chave Precisa corresponder a uma das chaves públicas listadas em https://www.googleapis.com/robot/v1/metadata/x509/securetoken@system.gserviceaccount.com.

Verifique se o payload do token de código está em conformidade com as seguintes restrições:

Reivindicações de payload do token de código
exp Data de validade Precisa estar no futuro. O tempo é medido em segundos desde a época do Unix.
iat Emitido em Precisa estar no passado. O tempo é medido em segundos desde a época do Unix.
aud Público Precisa ser seu código do projeto do Firebase, o identificador exclusivo do seu projeto do Firebase que pode ser encontrado no URL do console desse projeto.
iss Emissor Precisa ser "https://securetoken.google.com/<projectId>", sendo que <projectId> é o mesmo código do projeto usado para aud acima.
sub Assunto Precisa ser uma string que não esteja em branco e precisa ser o uid do usuário ou dispositivo.
auth_time Tempo de autenticação Precisa estar no passado. A hora em que o usuário realizou a autenticação.

Finalmente, verifique se o token de código foi assinado pela chave privada correspondente à declaração kid do token. Veja a chave pública em https://www.googleapis.com/robot/v1/metadata/x509/securetoken@system.gserviceaccount.com e use uma biblioteca JWT para verificar a assinatura. Use o valor de max-age no cabeçalho Cache-Control da resposta desse ponto de extremidade para saber quando atualizar as chaves públicas.

Depois que você realizar todas as verificações acima, será possível usar o assunto (sub) do token de código como o uid do usuário ou dispositivo correspondente.