Créer des jetons personnalisés

Ce document explique comment utiliser Identity Platform pour créer des Jetons JSON Web (JWT) personnalisés.

Les jetons personnalisés vous permettent de contrôler entièrement le processus d'authentification. Vous devez générer ces jetons sur votre serveur, les renvoyer à un appareil client, puis appeler signInWithCustomToken() pour connecter les utilisateurs.

Vous pouvez créer des jetons personnalisés avec le SDK Admin Identity Platform ou utiliser une bibliothèque JWT tierce.

Avant de commencer

  • Installez le SDK Admin. Si vous utilisez la découverte automatique des comptes de service ou un ID de compte de service spécifié explicitement, assurez-vous que le compte de service que vous utilisez dispose au moins du rôle Créateur de jetons de compte de service (roles/iam.serviceAccountTokenCreator).

  • Créez et déployez un point de terminaison de serveur qui accepte les identifiants de connexion des utilisateurs.

Créer des jetons personnalisés à l'aide du SDK Admin

Le SDK Admin intègre une méthode pour créer des jetons personnalisés. Vous devez au moins fournir un uid. Il peut s'agir de n'importe quelle chaîne qui identifie de manière unique l'utilisateur ou l'appareil. Ces jetons expirent au bout d'une heure.

L'exemple suivant montre comment créer un jeton personnalisé :

Node.js

const uid = 'some-uid';

getAuth()
  .createCustomToken(uid)
  .then((customToken) => {
    // Send token back to client
  })
  .catch((error) => {
    console.log('Error creating custom token:', error);
  });
create_custom_tokens.js

Java

String uid = "some-uid";

String customToken = FirebaseAuth.getInstance().createCustomToken(uid);
// Send token back to client
FirebaseAuthSnippets.java

Python

uid = 'some-uid'

custom_token = auth.create_custom_token(uid)
index.py

Go

client, err := app.Auth(context.Background())
if err != nil {
	log.Fatalf("error getting Auth client: %v\n", err)
}

token, err := client.CustomToken(ctx, "some-uid")
if err != nil {
	log.Fatalf("error minting custom token: %v\n", err)
}

log.Printf("Got custom token: %v\n", token)
auth.go

C#

var uid = "some-uid";

string customToken = await FirebaseAuth.DefaultInstance.CreateCustomTokenAsync(uid);
// Send token back to client
FirebaseAuthSnippets.cs

Une fois que vous avez créé un jeton personnalisé, votre application peut l'utiliser pour connecter un utilisateur.

Vous pouvez éventuellement inclure d'autres revendications sur le jeton personnalisé. Celles-ci sont transmises au jeton d'ID de l'utilisateur en tant que revendications de premier niveau.

L'exemple suivant montre comment ajouter une revendication premiumAccount :

Node.js

const userId = 'some-uid';
const additionalClaims = {
  premiumAccount: true,
};

getAuth()
  .createCustomToken(userId, additionalClaims)
  .then((customToken) => {
    // Send token back to client
  })
  .catch((error) => {
    console.log('Error creating custom token:', error);
  });
create_custom_tokens.js

Java

String uid = "some-uid";
Map<String, Object> additionalClaims = new HashMap<String, Object>();
additionalClaims.put("premiumAccount", true);

String customToken = FirebaseAuth.getInstance()
    .createCustomToken(uid, additionalClaims);
// Send token back to client
FirebaseAuthSnippets.java

Python

uid = 'some-uid'
additional_claims = {
    'premiumAccount': True
}

custom_token = auth.create_custom_token(uid, additional_claims)
index.py

Go

client, err := app.Auth(context.Background())
if err != nil {
	log.Fatalf("error getting Auth client: %v\n", err)
}

claims := map[string]interface{}{
	"premiumAccount": true,
}

token, err := client.CustomTokenWithClaims(ctx, "some-uid", claims)
if err != nil {
	log.Fatalf("error minting custom token: %v\n", err)
}

log.Printf("Got custom token: %v\n", token)
auth.go

C#

var uid = "some-uid";
var additionalClaims = new Dictionary<string, object>()
{
    { "premiumAccount", true },
};

string customToken = await FirebaseAuth.DefaultInstance
    .CreateCustomTokenAsync(uid, additionalClaims);
// Send token back to client
FirebaseAuthSnippets.cs

Identity Platform est conforme à la spécification JWT OpenID Connect. Cela signifie que les revendications suivantes sont réservées et ne peuvent pas être spécifiées :

  • acr
  • amr
  • at_hash
  • aud
  • auth_time
  • azp
  • cnf
  • c_hash
  • exp
  • firebase
  • iat
  • iss
  • jti
  • nbf
  • nonce
  • sub

Créer des jetons personnalisés à l'aide d'une bibliothèque JWT tierce

Si votre backend est écrit dans un langage non compatible avec le SDK Admin, vous pouvez toujours créer manuellement des jetons personnalisés. Commencez par trouver une bibliothèque JWT tierce pour votre langage. Exécutez ensuite cette bibliothèque pour exploiter un jeton JWT incluant les revendications suivantes :

alg Algorithme "RS256"
iss Émetteur Adresse e-mail du compte de service de votre projet
sub Objet Adresse e-mail du compte de service de votre projet
aud Cible "https://identitytoolkit.googleapis.com/google.identity.identitytoolkit.v1.IdentityToolkit"
iat Date/Heure d'émission Heure actuelle, en secondes, depuis l'epoch UNIX.
exp Date/Heure d'expiration Durée, en secondes depuis l'époque UNIX, au bout de laquelle le jeton expire. Cette valeur peut correspondre à un maximum de 3 600 secondes après l'heure iat.
Notez que cette propriété ne contrôle que l'heure d'expiration du jeton personnalisé lui-même. Une fois que vous avez connecté un utilisateur à l'aide de signInWithCustomToken(), cet utilisateur reste connecté jusqu'à ce qu'il se déconnecte ou que sa session soit invalidé.
uid Identifiant unique de l'utilisateur connecté. Doit être une chaîne de 1 à 36 caractères.
claims (facultatif) Revendications personnalisées supplémentaires à inclure.

Les exemples suivants montrent comment créer des jetons personnalisés dans des langages non compatibles avec le SDK Admin :

PHP

Utiliser php-jwt :

// Requires: composer require firebase/php-jwt
use Firebase\JWT\JWT;

// Get your service account's email address and private key from the JSON key file
$service_account_email = "abc-123@a-b-c-123.iam.gserviceaccount.com";
$private_key = "-----BEGIN PRIVATE KEY-----...";

function create_custom_token($uid, $is_premium_account) {
  global $service_account_email, $private_key;

  $now_seconds = time();
  $payload = array(
  "iss" => $service_account_email,
  "sub" => $service_account_email,
  "aud" => "https://identitytoolkit.googleapis.com/google.identity.identitytoolkit.v1.IdentityToolkit",
  "iat" => $now_seconds,
  "exp" => $now_seconds+(60*60),  // Maximum expiration time is one hour
  "uid" => $uid,
  "claims" => array(
      "premium_account" => $is_premium_account
  )
  );
  return JWT::encode($payload, $private_key, "RS256");
}

Ruby

Utiliser ruby-jwt :

require "jwt"

# Get your service account's email address and private key from the JSON key file
$service_account_email = "service-account@my-project-abc123.iam.gserviceaccount.com"
$private_key = OpenSSL::PKey::RSA.new "-----BEGIN PRIVATE KEY-----\n..."

def create_custom_token(uid, is_premium_account)
  now_seconds = Time.now.to_i
  payload = {:iss => $service_account_email,
              :sub => $service_account_email,
              :aud => "https://identitytoolkit.googleapis.com/google.identity.identitytoolkit.v1.IdentityToolkit",
              :iat => now_seconds,
              :exp => now_seconds+(60*60), # Maximum expiration time is one hour
              :uid => uid,
              :claims => {:premium_account => is_premium_account}}
  JWT.encode payload, $private_key, "RS256"
end

Une fois que vous avez créé un jeton personnalisé, votre application peut l'utiliser pour connecter un utilisateur.

Étape suivante