Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

Verificar tokens de ID

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

Se o aplicativo cliente do Firebase se comunicar com um servidor de back-end personalizado, talvez seja necessário identificar o usuário conectado no momento nesse servidor. Para fazer isso com segurança, após um login bem-sucedido, envie o token de ID do usuário para seu servidor usando HTTPS. Em seguida, no servidor, verifique a integridade e a autenticidade do token de ID e recupere o uid dele. Você pode usar o uid transmitido dessa maneira para identificar com segurança o usuário conectado no momento em seu servidor.

Antes de você 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 Admin SDK para obter mais informações sobre como inicializar o Admin SDK com uma conta de serviço.

Recuperar tokens de ID em clientes

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

iOS+

Objetivo-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
          // ...
}];
Rápido
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();
            }
        }
    });

Unidade

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

Rede

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

Depois de ter um token de ID, você pode enviar esse JWT para seu back-end e validá-lo usando o SDK Admin do Firebase ou uma biblioteca JWT de terceiros se o servidor estiver escrito em um idioma que o Firebase não oferece suporte nativo.

Verifique os tokens de ID usando 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 ID fornecido tiver o formato correto, não tiver expirado e estiver devidamente assinado, o método retornará o token de ID decodificado. Você pode pegar o uid do usuário ou dispositivo do token decodificado.

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

Node.js

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

Java

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

Pitão

# id_token comes from the client app (shown above)

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

Vai

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)

C#

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 obter um ID de projeto por meio de um dos seguintes métodos:

  • Se o SDK foi inicializado com uma opção de aplicativo projectId explícita, o SDK usará o valor dessa opção.
  • Se o SDK foi inicializado com credenciais de conta de serviço, o SDK usará 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 usará seu valor como o ID do projeto. Essa variável de ambiente está disponível para código executado na infraestrutura do Google, como App Engine e Compute Engine.

Verifique os tokens de ID usando uma biblioteca JWT de terceiros

Se seu back-end estiver em um idioma não compatível com o SDK Admin do Firebase, você ainda poderá verificar os tokens de ID. Primeiro, encontre uma biblioteca JWT de terceiros para seu idioma . Em seguida, verifique o cabeçalho, a carga útil e a assinatura do token de ID.

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

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

Verifique se a carga útil do token de ID está em conformidade com as seguintes restrições:

Reivindicações de carga útil de token de identificação
exp Data de validade Deve ser no futuro. O tempo é medido em segundos desde a época do UNIX.
iat Emitido no momento Deve estar no passado. O tempo é medido em segundos desde a época do UNIX.
aud Público Deve ser o ID do projeto do Firebase, o identificador exclusivo do projeto do Firebase, que pode ser encontrado no URL do console desse projeto.
iss Emissor Deve ser "https://securetoken.google.com/<projectId>" , em que <projectId> é o mesmo ID do projeto usado para aud acima.
sub Sujeito Deve ser uma string não vazia e deve ser o uid do usuário ou dispositivo.
auth_time Tempo de autenticação Deve estar no passado. A hora em que o usuário se autenticou.

Por fim, certifique-se de que o token de ID foi assinado pela chave privada correspondente à declaração de kid do token. Pegue 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 endpoint para saber quando atualizar as chaves públicas.

Se todas as verificações acima forem bem-sucedidas, você poderá usar o assunto ( sub ) do token de ID como o uid do usuário ou dispositivo correspondente.