firebase tokens php Télécharger - firebase tokens php Téléchargement du code source

Jetons Firebase

Une bibliothèque pour travailler avec les jetons Google Firebase. Vous pouvez l'utiliser pour créer des jetons personnalisés et vérifier les jetons d'identification.

Obtenez plus de résultats avec le SDK Firebase Admin pour PHP (qui utilise cette bibliothèque).

L'avenir du SDK PHP Firebase Admin

Veuillez en savoir plus sur l'avenir du SDK PHP Firebase Admin sur le référentiel GitHub du SDK.

Installation
Utilisation simple
- Créer un jeton personnalisé
- Vérifier un jeton d'identification
- Vérifier un cookie de session
- Jetons
- Sensibilisation des locataires
Utilisation avancée
- Mettre en cache les résultats du Google Secure Token Store
Versions prises en charge

Installation

composer require kreait/firebase-tokens

Utilisation simple

Créer un jeton personnalisé

Plus d'informations sur ce qu'est un jeton personnalisé et comment il peut être utilisé peuvent être trouvées dans la documentation officielle de Google.

 <?php

use Kreait  Firebase  JWT  CustomTokenGenerator ;

$ clientEmail = ' ... ' ;
$ privateKey = ' ... ' ;

$ generator = CustomTokenGenerator:: withClientEmailAndPrivateKey ( $ clientEmail , $ privateKey );
$ token = $ generator -> createCustomToken ( ' uid ' , [ ' first_claim ' => ' first_value ' /* ... */ ]);

echo $ token ;
// Output: eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.e...

Vérifier un jeton d'identification

Les méthodes de vérification des jetons d'identification incluses dans les SDK d'administration Firebase sont destinées à vérifier les jetons d'identification provenant des SDK clients, et non les jetons personnalisés que vous créez avec les SDK d'administration. Voir Jetons d'authentification pour plus d'informations.

 <?php

use Kreait  Firebase  JWT  Error  IdTokenVerificationFailed ;
use Kreait  Firebase  JWT  IdTokenVerifier ;

$ projectId = ' ... ' ;
$ idToken = ' eyJhb... ' ; // An ID token given to your backend by a Client application

$ verifier = IdTokenVerifier:: createWithProjectId ( $ projectId );

try {
    $ token = $ verifier -> verifyIdToken ( $ idToken );
} catch ( IdTokenVerificationFailed $ e ) {
    echo $ e -> getMessage ();
    // Example Output:
    // The value 'eyJhb...' is not a verified ID token:
    // - The token is expired.
    exit ;
}

try {
    $ token = $ verifier -> verifyIdTokenWithLeeway ( $ idToken , $ leewayInSeconds = 10000000 );
} catch ( IdTokenVerificationFailed $ e ) {
    print $ e -> getMessage ();
    exit ;
}

Vérifier un cookie de session

La vérification des cookies de session est similaire à la vérification du jeton d'identification.

Voir Gérer les cookies de session pour plus d'informations.

 <?php

use Kreait  Firebase  JWT  Error  SessionCookieVerificationFailed ;
use Kreait  Firebase  JWT  SessionCookieVerifier ;

$ projectId = ' ... ' ;
$ sessionCookie = ' eyJhb... ' ; // A session cookie given to your backend by a Client application

$ verifier = SessionCookieVerifier:: createWithProjectId ( $ projectId );

try {
    $ token = $ verifier -> verifySessionCookie ( $ sessionCookie );
} catch ( SessionCookieVerificationFailed $ e ) {
    echo $ e -> getMessage ();
    // Example Output:
    // The value 'eyJhb...' is not a verified ID token:
    // - The token is expired.
    exit ;
}

try {
    $ token = $ verifier -> verifySessionCookieWithLeeway ( $ sessionCookie , $ leewayInSeconds = 10000000 );
} catch ( SessionCookieVerificationFailed $ e ) {
    print $ e -> getMessage ();
    exit ;
}

Jetons

Les jetons renvoyés par le générateur et le vérificateur sont des instances de KreaitFirebaseJWTContractToken et représentent un JWT. Les résultats affichés sont des exemples et varient en fonction des informations associées à l'utilisateur donné dans la base de données d'authentification de votre projet.

Selon la spécification JWT, vous pouvez vous attendre à ce que les champs de charge utile suivants soient toujours disponibles : iss , aud , auth_time , sub , iat , exp . Les autres champs dépendent de la méthode d'authentification du compte donné et des informations stockées dans la base de données Auth de votre projet.

 $ token = $ verifier -> verifyIdToken ( ' eyJhb... ' ); // An ID token given to your backend by a Client application

echo json_encode ( $ token -> headers (), JSON_PRETTY_PRINT );
// {
//     "alg": "RS256",
//     "kid": "e5a91d9f39fa4de254a1e89df00f05b7e248b985",
//     "typ": "JWT"
// }                                                   

echo json_encode ( $ token -> payload (), JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES );
// {
//     "name": "Jane Doe",
//     "picture": "https://domain.tld/picture.jpg",
//     "iss": "https://securetoken.google.com/your-project-id",
//     "aud": "your-project-id",
//     "auth_time": 1580063945,
//     "user_id": "W0IturDwy4TYTmX6ilkd2ZbAXRp2",
//     "sub": "W0IturDwy4TYTmX6ilkd2ZbAXRp2",
//     "iat": 1580063945,
//     "exp": 1580067545,
//     "email": "[email protected]",
//     "email_verified": true,
//     "phone_number": "+1234567890",
//     "firebase": {
//         "identities": {
//             "phone": [
//                 "+1234567890"
//             ],
//             "email": [
//                 "[email protected]"
//             ]
//         },
//         "sign_in_provider": "custom"
//     }
// }

echo $ token -> toString ();
// eyJhb...

$ tokenString = ( string ) $ token ; // string
// eyJhb...

Sensibilisation des locataires

Vous pouvez créer des jetons personnalisés limités à un locataire donné :

 <?php

use Kreait  Firebase  JWT  CustomTokenGenerator ;

$ generator = CustomTokenGenerator:: withClientEmailAndPrivateKey ( ' ... ' , ' ... ' );

$ tenantAwareGenerator = $ generator -> withTenantId ( ' my-tenant-id ' );

De même, vous pouvez vérifier que les jetons d'ID ont été émis dans le cadre d'un locataire donné :

 <?php

use Kreait  Firebase  JWT  IdTokenVerifier ;

$ verifier = IdTokenVerifier:: createWithProjectId ( ' my-project-id ' );

$ tenantAwareVerifier = $ verifier -> withExpectedTenantId ( ' my-tenant-id ' );

Les cookies de session ne prennent actuellement pas en charge les locataires.

Utilisation avancée

Mettre en cache les résultats du Google Secure Token Store

Afin de vérifier les jetons d'identification, le vérificateur effectue un appel pour récupérer les clés publiques actuellement disponibles de Firebase. Les clés sont mises en cache en mémoire par défaut.

Si vous souhaitez mettre en cache les clés publiques plus efficacement, vous pouvez initialiser le vérificateur avec une implémentation de psr/simple-cache ou psr/cache pour réduire le nombre de requêtes HTTP adressées aux serveurs de Google.

Voici un exemple utilisant le composant Symfony Cache :

 use Kreait  Firebase  JWT  IdTokenVerifier ;
use Symfony  Component  Cache  Adapter  FilesystemAdapter ;

$ cache = new FilesystemAdapter ();

$ verifier = IdTokenVerifier:: createWithProjectIdAndCache ( $ projectId , $ cache );

Versions prises en charge

Seule la dernière version est activement prise en charge.

Les versions antérieures recevront des correctifs de sécurité tant que leur exigence PHP la plus basse recevra des correctifs de sécurité. Par exemple, lorsqu'une version prend en charge PHP 7.4 et PHP 8.0, la prise en charge de la sécurité prendra fin à la fin de la prise en charge de la sécurité pour PHP 7.4.

Version	Version initiale	Versions PHP prises en charge	Statut
`5.x`	25 novembre 2023	`~8.1.0, ~8.2.0, ~8.3.0`	Actif
`4.x`	26 novembre 2022	`~8.1.0, ~8.2.0, ~8.3.0`	Prise en charge de la sécurité
`3.x`	25 avril 2022	`^7.4, ^8.0`	Fin de vie
`2.x`	03 janvier 2022	`^7.4, ^8.0`	Fin de vie
`1.x`	06 février 2017	`>=5.5`	Fin de vie