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 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 ID de clientes
Quando um usuário ou dispositivo faz login, o Firebase cria um token de ID correspondente que o identifica como único e concede a ele acesso a vários recursos, como o Firebase Realtime Database e o 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:
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 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 inicializar
o SDK Admin 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();
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(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 acessar esse ID por meio de 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 usará o valor dela como o ID do projeto. Essa variável de ambiente está disponível para o código em execução na infraestrutura do Google, como o App Engine e o Compute Engine.
Verificar os tokens de ID 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 ID.
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 |
ID 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 ID 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>" , em que <projectId> é o mesmo ID do projeto usado para a aud acima. |
sub |
Assunto | Precisa ser uma string que não esteja em branco e também 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. |
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.