API Gateway:Authentification par token basée sur JWT

Présentation

De nombreuses API publiques doivent identifier les appelants afin de déterminer s'il convient d'accorder l'accès aux ressources demandées. Un token constitue un mécanisme d'authentification. Avec l'authentification basée sur un token, une application n'a pas besoin de stocker les informations d'authentification ou de session des utilisateurs sur le serveur. Cela permet une autorisation distribuée et sans état pour les applications web, tout en simplifiant la mise à l'échelle des applications.

Flux de travail

API Gateway utilise le plug-in d'authentification JWT pour gérer l'authentification. Le flux de travail est le suivant :

1. Un client envoie une requête incluant un token à API Gateway.

2. API Gateway vérifie le token à l'aide de la clé publique configurée dans le plug-in d'authentification JWT. Si le token est valide, API Gateway transmet la requête au service backend.

3. Le service backend traite la requête et renvoie une réponse.

4. API Gateway renvoie la réponse du service backend au client.

Tout au long de ce processus, API Gateway utilise l'authentification par token pour autoriser l'accès aux API en se basant sur votre propre système d'utilisateurs. Les sections suivantes décrivent JSON Web Token (JWT), qu'API Gateway utilise pour l'authentification.

JWT

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

{
  'typ': 'JWT',
  'alg': 'HS256'
}

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9

iss: Issuer. The principal that issued the token. This claim is a string.
sub: Subject. The principal that is the subject of the token. This value is unique within the scope of the issuer. It is a case-sensitive string with a maximum length of 255 ASCII characters.
aud: Audience. The recipients that the token is intended for. This is a case-sensitive array of strings.
exp: Expiration Time. The time after which the token is considered invalid. This claim is an integer that represents the number of seconds from 1970-01-01T00:00:00Z.
iat: Issued At. The time at which the token was issued. This claim is an integer that represents the number of seconds from 1970-01-01T00:00:00Z.
jti: JWT ID. A unique identifier for the token. This value is unique for each token created by the same issuer and is often a cryptographically random value to prevent collisions. This value adds a random entropy component to the structured token that an attacker cannot obtain, which helps prevent token guessing and replay attacks.

{
  "sub": "1234567890",
  "name": "John Doe"
}

JTdCJTBBJTIwJTIwJTIyc3ViJTIyJTNBJTIwJTIyMTIzNDU2Nzg5MCUyMiUyQyUwQSUyMCUyMCUyMm5hbWUlMjIlM0ElMjAlMjJKb2huJTIwRG9lJTIyJTBBJTdE

// javascript
var encodedString = base64UrlEncode(header) + '.' + base64UrlEncode(payload);
var signature = HMACSHA256(encodedString, '$secret');

2.1 Générer une paire de clés JSON Web Key (JWK)

<dependency>
     <groupId>org.bitbucket.b_c</groupId>
    <artifactId>jose4j</artifactId>
    <version>0.7.0</version>
</dependency>

RsaJsonWebKey rsaJsonWebKey = RsaJwkGenerator.generateJwk(2048);
rsaJsonWebKey.setKeyId("authServer");
final String publicKeyString = rsaJsonWebKey.toJson(JsonWebKey.OutputControlLevel.PUBLIC_ONLY);
final String privateKeyString = rsaJsonWebKey.toJson(JsonWebKey.OutputControlLevel.INCLUDE_PRIVATE);

2.2 Implémenter un service d'émission de tokens

Utilisez la chaîne JSON JWK de clé publique générée en ligne dans la section 2.1 ou la chaîne JSON privateKeyString générée localement comme clé privée pour émettre des tokens. Ces tokens autorisent les utilisateurs de confiance à accéder aux API protégées. Pour plus d'informations, consultez le Exemple de code pour le service d'émission et d'authentification des tokens. La manière dont vous émettez les tokens dépend de vos scénarios métier. Vous pouvez déployer la fonctionnalité d'émission de tokens dans un environnement de production en tant qu'API standard permettant aux visiteurs d'obtenir un token avec un nom d'utilisateur et un mot de passe, ou générer un token localement et le fournir directement à un utilisateur spécifique.

2.3 Configurer le plug-in JWT

1. Connectez-vous à la console API Gateway.

2. Dans le volet de navigation de gauche, choisissez API Management > Plug-in Management.

3. Sur la page de gestion des plug-ins, cliquez sur Create Plug-in dans le coin supérieur droit.

4. Sur la page Create Plug-in, définissez Plug-in Name et sélectionnez un Plug-in Type. Le code suivant illustre un exemple de configuration pour un plug-in d'authentification JWT. Pour plus d'informations sur la configuration, consultez le plug-in d'authentification JWT.

---
parameter: X-Token         # The parameter from which to retrieve the JWT. This corresponds to an API parameter.
parameterLocation: header  # The location from which to read the JWT. This parameter is optional if the API is in mapping mode, but required if the API is in pass-through mode. Valid values: `query` and `header`.
claimParameters:           # Claim parameter mapping. API Gateway maps JWT claims to backend parameters.
- claimName: aud           # The name of the claim. Public and private claims are supported.
  parameterName: X-Aud     # The name of the mapped parameter.
  location: header         # The location of the mapped parameter. Valid values: `query`, `header`, `path`, and `formData`.
- claimName: userId        # The name of the claim. Public and private claims are supported.
  parameterName: userId    # The name of the mapped parameter.
  location: query          # The location of the mapped parameter. Valid values: `query`, `header`, `path`, and `formData`.
preventJtiReplay: false    # Specifies whether to enable anti-replay checks for the `jti` claim. Default value: false.
# The public key of the JSON Web Key (JWK) generated in section 2.1.
jwk:
  kty: RSA
  e: AQAB
  use: sig
  kid: uniq_key
  alg: RS256
  n: qSVxcknOm0uCq5vGsOmaorPDzHUubBmZZ4UXj-9do7w9X1uKFXAnqfto4TepSNuYU2bA_-tzSLAGBsR-BqvT6w9SjxakeiyQpVmexxnDw5WZwpWenUAcYrfSPEoNU-0hAQwFYgqZwJQMN8ptxkd0170PFauwACOx4Hfr-9FPGy8NCoIO4MfLXzJ3mJ7xqgIZp3NIOGXz-GIAbCf13ii7kSStpYqN3L_zzpvXUAos1FJ9IPXRV84tIZpFVh2lmRh0h8ImK-vI42dwlD_hOIzayL1Xno2R0T-d5AwTSdnep7g-Fwu8-sj4cCRWq3bd61Zs2QOJ8iustH0vSRMYdP5oYQ

2.4 Lier le plug-in JWT à une API

Sur la page Plug-ins, recherchez le plug-in d'authentification JWT que vous avez créé et cliquez sur Bind API. Dans la boîte de dialogue, sélectionnez les API du groupe d'API et de l'environnement spécifiés, ajoutez-les à la liste de droite, puis cliquez sur OK.

Si une API est déjà liée à un plug-in du même type, le nouveau plug-in remplace l'existant. Procédez avec prudence.

La fonctionnalité de débogage d'API dans la console API Gateway ne prend pas en charge le plug-in d'authentification JWT. Pour tester les API liées au plug-in, utilisez un outil tel que Postman ou exécutez la commande curl.

import java.security.PrivateKey; 
import org.jose4j.json.JsonUtil;
import org.jose4j.jwk.RsaJsonWebKey;
import org.jose4j.jwk.RsaJwkGenerator;
import org.jose4j.jws.AlgorithmIdentifiers;
import org.jose4j.jws.JsonWebSignature;
import org.jose4j.jwt.JwtClaims;
import org.jose4j.jwt.NumericDate;
import org.jose4j.lang.JoseException;
public class GenerateJwtDemo {
    public static void main(String[] args) throws JoseException  {
          // Use the keyId that is set in API Gateway.
        String keyId = "uniq_key";
          // Use the key pair that you generated in Section 2.1.
        String privateKeyJson = "{\n"
            + "  \"kty\": \"RSA\",\n"
            + "  \"d\": "
            +
            "\"O9MJSOgcjjiVMNJ4jmBAh0mRHF_TlaVva70Imghtlgwxl8BLfcf1S8ueN1PD7xV6Cnq8YenSKsfiNOhC6yZ_fjW1syn5raWfj68eR7cjHWjLOvKjwVY33GBPNOvspNhVAFzeqfWneRTBbga53Agb6jjN0SUcZdJgnelzz5JNdOGaLzhacjH6YPJKpbuzCQYPkWtoZHDqWTzCSb4mJ3n0NRTsWy7Pm8LwG_Fd3pACl7JIY38IanPQDLoighFfo-Lriv5z3IdlhwbPnx0tk9sBwQBTRdZ8JkqqYkxUiB06phwr7mAnKEpQJ6HvhZBQ1cCnYZ_nIlrX9-I7qomrlE1UoQ\",\n"
            + "  \"e\": \"AQAB\",\n"
            + "  \"kid\": \"myJwtKey\",\n"
            + "  \"alg\": \"RS256\",\n"
            + "  \"n\": \"vCuB8MgwPZfziMSytEbBoOEwxsG7XI3MaVMoocziP4SjzU4IuWuE_DodbOHQwb_thUru57_Efe"
            +
            "--sfATHEa0Odv5ny3QbByqsvjyeHk6ZE4mSAV9BsHYa6GWAgEZtnDceeeDc0y76utXK2XHhC1Pysi2KG8KAzqDa099Yh7s31AyoueoMnrYTmWfEyDsQL_OAIiwgXakkS5U8QyXmWicCwXntDzkIMh8MjfPskesyli0XQD1AmCXVV3h2Opm1Amx0ggSOOiINUR5YRD6mKo49_cN-nrJWjtwSouqDdxHYP-4c7epuTcdS6kQHiQERBd1ejdpAxV4c0t0FHF7MOy9kw\"\n"
            + "}";
        JwtClaims claims = new JwtClaims();
        claims.setGeneratedJwtId();
        claims.setIssuedAtToNow();
        // The expiration time must be set and be less than 7 days.
        NumericDate date = NumericDate.now();
        date.addSeconds(120*60);
        claims.setExpirationTime(date);
        claims.setNotBeforeMinutesInThePast(1);
        claims.setSubject("YOUR_SUBJECT");
        claims.setAudience("YOUR_AUDIENCE");
        // Add custom parameters. All values must be of the String type.
        claims.setClaim("userId", "1213234");
        claims.setClaim("email", "userEm***@youapp.com");
        JsonWebSignature jws = new JsonWebSignature();
        jws.setAlgorithmHeaderValue(AlgorithmIdentifiers.RSA_USING_SHA256);
          // This parameter is required.
        jws.setKeyIdHeaderValue(keyId);
        jws.setPayload(claims.toJson());
        PrivateKey privateKey = new RsaJsonWebKey(JsonUtil.parseJson(privateKeyJson)).getPrivateKey();
        jws.setKey(privateKey);
        String jwtResult = jws.getCompactSerialization();
        System.out.println("Generate Json Web token , result is " + jwtResult);
    }
}