Verificar tokens de ID

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

Observação: muitos casos de uso para verificação de tokens de ID no servidor podem ser realizados usando regras de segurança para Firebase Realtime Database e Cloud Storage . Veja se isso resolve o seu problema antes de verificar você mesmo os tokens de identificação.

Aviso: os métodos de verificação de token de ID incluídos nos SDKs Admin do Firebase destinam-se a verificar os tokens de ID provenientes dos SDKs clientes, não os tokens personalizados criados com os SDKs Admin. Consulte Tokens de autenticação para obter mais informações.

Antes de você começar

Para verificar 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 com êxito, o Firebase cria um token de ID correspondente que o identifica exclusivamente 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 back-end personalizado. Para recuperar o token de ID do cliente, certifique-se de que o usuário esteja conectado e 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.is_valid()) {
  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 seu servidor estiver escrito em uma linguagem que o Firebase não oferece suporte nativo.

Verifique os tokens de ID usando o SDK Admin do Firebase

O Firebase Admin SDK 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 assinado corretamente, o método retornará o token de ID decodificado. Você pode obter o uid do usuário ou dispositivo do token decodificado.

Nota: Isto não verifica se o token foi revogado ou não. Consulte: Detectar revogação de token de ID .

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

Ir

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

C#

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

A verificação do token de ID requer um ID do projeto. O SDK Admin do Firebase tenta obter um ID do 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 tiver sido inicializado com credenciais de conta de serviço, ele 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 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 o 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 o 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	ID da chave	Deve corresponder a uma das chaves públicas listadas em https://www.googleapis.com/robot/v1/metadata/x509/[e-mail]

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 ID
exp	Data de validade	Deve estar 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>" , onde <projectId> é o mesmo ID do projeto usado para aud acima.
sub	Assunto	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 foi autenticado.

Por fim, certifique-se de que o token de ID foi assinado pela chave privada correspondente à reivindicação kid do token. Pegue a chave pública em https://www.googleapis.com/robot/v1/metadata/x509/[e-mail] e use uma biblioteca JWT para verificar a assinatura. Use o valor 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.