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.
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.
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)
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/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 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/securetoken@system.gserviceaccount.com
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.