Verificar tokens de ID

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, use HTTPS para enviar o token de ID do usuário para o servidor. Em seguida, no servidor, verifique a integridade e a autenticidade do token de ID e recupere o uid dele. É possível usar 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 ID 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 ID de clientes

Quando um usuário ou dispositivo faz login, o Firebase cria um de ID exclusivo que os identifica e concede acesso a vários recursos, como Firebase Realtime Database e Cloud Storage. É possível reutilizar esse token de ID para identificar o usuário ou dispositivo no seu servidor de back-end personalizado. Para recuperar o token de ID do cliente, verifique se o usuário está conectado e, em seguida, acesse o token de ID dele:

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
          // ...
}];

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
  // ...
}

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

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
  // ...
});

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

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

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 ID, você poderá enviar esse JWT para seu back-end e validá-lo usando o SDK Admin do Firebase ou uma biblioteca JWT de terceiros caso seu servidor tenha sido criado com uma linguagem que o Firebase não suporta nativamente.

Verificar os tokens de ID com o SDK Admin do Firebase

O SDK Admin do Firebase tem um método integrado para verificar e decodificar tokens de ID. Se o token de ID fornecido tiver o formato correto, não tiver expirado e estiver devidamente assinado, o método retornará o token de ID decodificado. É possível ver o uid do usuário ou o dispositivo do token decodificado.

Siga as instruções de configuração do SDK Admin para inicializá-lo com uma conta de serviço. Em seguida, use o método verifyIdToken() para verificar um token de ID:

// idToken comes from the client app
getAuth()
  .verifyIdToken(idToken)
  .then((decodedToken) => {
    const uid = decodedToken.uid;
    // ...
  })
  .catch((error) => {
    // Handle error
  });

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

# id_token comes from the client app (shown above)

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

client, err := app.Auth(ctx)
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)
auth.go

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

A verificação do token de ID requer um ID de projeto. O SDK Admin do Firebase tenta acessar esse ID usando um dos métodos a seguir:

• Se o SDK foi inicializado com uma opção de app projectId explicita, o SDK usará o valor dessa opção.
• Se o SDK foi inicializado com credenciais de conta de serviço, ele usará o campo project_id do objeto JSON dessa conta.
• Se a variável de ambiente GOOGLE_CLOUD_PROJECT estiver definida, o SDK vai usar o valor dela como o ID do projeto. Essa variável de ambiente está disponível em execução na infraestrutura do Google, como App Engine e Compute Engine.

Verificar os tokens de ID com uma biblioteca JWT de terceiros

Caso seu back-end esteja em uma linguagem não suportada pelo SDK Admin do Firebase, você ainda poderá verificar os tokens de ID. Primeiro, encontre uma biblioteca JWT de terceiros para sua linguagem. Em seguida, verifique o cabeçalho, o payload e a assinatura do token de ID.

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

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

Por fim, verifique se o token de ID 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 determinar quando atualizar as chaves públicas.

Após realizar todas as verificações acima, será possível usar o assunto (sub) do token de ID como o uid do usuário ou dispositivo correspondente.