Structure du jeton méthode validateToken ()méthode generateToken ()

Support CWT pour Functions CloudFront

Cette section fournit des détails sur la prise en charge des jetons Web CBOR (CWT) dans vos CloudFront fonctions, qui permettent une authentification et une autorisation sécurisées basées sur des jetons dans les emplacements périphériques. CloudFront Ce support est fourni sous forme de module, accessible dans votre CloudFront fonction.

Pour utiliser ce module, créez une CloudFront fonction à l'aide de JavaScript Runtime 2.0 et incluez l'instruction suivante dans la première ligne du code de fonction :


import cf from 'cloudfront';

Les méthodes associées à ce module sont accessibles via (où * est un caractère générique représentant les différentes fonctions présentes dans le module) :


cf.cwt.*

Pour de plus amples informations, veuillez consulter Fonctionnalités d’exécution JavaScript 2.0 pour les fonctions CloudFront.

Actuellement, le module ne prend en charge que la structure MAC0 avec l'algorithme HS256 (HMAC-SHA256) avec une limite de 1 Ko pour la taille maximale du jeton.

Structure du jeton

Cette section couvre la structure des jetons attendue par le module CWT. Le module s'attend à ce que le jeton soit correctement étiqueté et identifiable (par exemple COSE MAC0). De plus, en ce qui concerne la structure du jeton, le module suit les normes établies par CBOR Object Signing and Encryption (COSE) [RFC 8152].


( // CWT Tag (Tag value: 61) --- optional    
    ( // COSE MAC0 Structure Tag (Tag value: 17) --- required        
        [            
            protectedHeaders,            
            unprotectedHeaders,            
            payload,            
            tag,        
        ]    
    )
)

Exemple : CWT utilisant la structure COSE MAC0


61( // CWT tag     
    17( // COSE_MAC0 tag       
        [         
            { // Protected Headers           
                1: 4  // algorithm : HMAC-256-64         
            },         
            { // Unprotected Headers           
                4: h'53796d6d6574726963323536' // kid : Symmetric key id          
            },         
            { // Payload           
                1: "https://iss.example.com", // iss           
                2: "exampleUser", // sub           
                3: "https://aud.example.com", // aud           
                4: 1444064944, // exp           
                5: 1443944944, // nbf           
                6: 1443944944, // iat         
            },         
            h'093101ef6d789200' // tag       
        ]     
    )   
)

Note

La balise CWT est facultative lors de la génération de jetons. Cependant, la balise de structure COSE est requise.

méthode validateToken ()

La fonction décode et valide un jeton CWT à l'aide de la clé spécifiée. Si la validation est réussie, elle renvoie le jeton CWT décodé. Dans le cas contraire, cela génère une erreur. Veuillez noter que cette fonction ne valide pas l'ensemble de réclamations.

Demande


cf.cwt.validateToken(token, handlerContext{key})

Parameters

jeton (obligatoire): Jeton codé pour validation. Il doit s'agir d'un JavaScript tampon.
HandlerContext (obligatoire): Un JavaScript objet qui stocke le contexte de l'appel ValidateToken. À l'heure actuelle, seule la propriété clé est prise en charge.
clé (obligatoire): Clé secrète pour le calcul du résumé du message. Peut être fourni sous forme de chaîne ou de JavaScript tampon.

Réponse

Lorsque la validateToken() méthode renvoie un jeton validé avec succès, la réponse de la fonction est au format suivant. CWTObject Une fois décodées, toutes les clés de réclamation sont représentées sous forme de chaînes.


CWTObject {    
    protectedHeaders,    
    unprotectedHeaders,    
    payload
}

Exemple - Valider un jeton avec un enfant envoyé dans le cadre du jeton

Cet exemple illustre la validation du jeton CWT, où l'enfant est extrait de l'en-tête. L'enfant est ensuite transmis KeyValueStore à CloudFront Functions pour récupérer la clé secrète utilisée pour valider le jeton.


import cf from 'cloudfront'

const CwtClaims = {
   iss: 1,
   aud: 3,
   exp: 4
}

async function handler(event) {
    try {
        let request = event.request;
        let encodedToken = request.headers['x-cwt-token'].value;
        let kid = request.headers['x-cwt-kid'].value;
                
        // Retrieve the secret key from the kvs
        let secretKey = await cf.kvs().get(kid);
                 
        // Now you can use the secretKey to decode & validate the token.
        let tokenBuffer = Buffer.from(encodedToken, 'base64url');
                
        let handlerContext = {
           key: secretKey,
        }
                
        try {
            let cwtObj = cf.cwt.validateToken(tokenBuffer, handlerContext);
                        
            // Check if token is expired
            const currentTime = Math.floor(Date.now() / 1000); // Current time in seconds
            if (cwtObj[CwtClaims.exp] && cwtObj[CwtClaims.exp] < currentTime) {
                return {
                    statusCode: 401,
                    statusDescription: 'Token expired'
                };
            }
        } catch (error) {
            return {
               statusCode: 401,
               statusDescription: 'Invalid token'
            };
         }
    } catch (error) {
        return {
            statusCode: 402,
            statusDescription: 'Token processing failed'
        };
     }
    return request;
}

méthode generateToken ()

Cette fonction génère un nouveau jeton CWT à l'aide de la charge utile et des paramètres contextuels fournis.

Demande


cf.cwt.generateToken(generatorContext, payload)

Parameters

GeneratorContext (obligatoire)

Il s'agit d'un JavaScript objet qui est utilisé comme contexte pour générer le jeton et qui contient les paires clé-valeur suivantes :

CWTtag (facultatif): Cette valeur est une valeur booléenne qui, si elle true indique qu'elle cwtTag doit être ajoutée.
CoseTag (obligatoire): Spécifie le type de balise COSE. Actuellement, seuls les supportsMAC0.
clé (obligatoire): Clé secrète pour calculer le résumé du message. Cette valeur peut être une chaîne ou JavaScript Buffer.

charge utile (obligatoire)

Charge utile du jeton pour l'encodage. La charge utile doit être CWTObject formatée.

Réponse

Renvoie un JavaScript Buffer contenant le jeton codé.

Exemple : Génère un jeton CWT


import cf from 'cloudfront';

const CwtClaims = {
    iss: 1,
    sub: 2,
    exp: 4
};

const CatClaims = {
    catu: 401,
    catnip: 402,
    catm: 403,
    catr: 404
};

const Catu = {
    host: 1,
    path: 2,
    ext: 3
};

const CatuMatchTypes = {
    prefix_match: 1,
    suffix_match: 2,
    exact_match: 3
};

const Catr = {
    renewal_method: 1,
    next_renewal_time: 2,
    max_uses: 3
};

async function handler(event) {
    try {
        const response = {
            statusCode: 200,
            statusDescription: 'OK',
            headers: {}
        };
        
        const commonAccessToken = {
            protected: {
                1: "5",
            },
            unprotected: {},
            payload: {
                [CwtClaims.iss]: "cloudfront-documentation",
                [CwtClaims.sub]: "cwt-support-on-cloudfront-functions",
                [CwtClaims.exp]: 1740000000,
                [CatClaims.catu]: {
                    [Catu.host]: {
                        [CatuMatchTypes.suffix_match]: ".cloudfront.net"
                    },
                    [Catu.path]: {
                        [CatuMatchTypes.prefix_match]: "/media/live-stream/cf-4k/"
                    },
                    [Catu.ext]: {
                        [CatuMatchTypes.exact_match]: [
                            ".m3u8",
                            ".ts",
                            ".mpd"
                        ]
                    }
                },
                [CatClaims.catnip]: [
                    "[IP_ADDRESS]",
                    "[IP_ADDRESS]"
                ],
                [CatClaims.catm]: [
                    "GET",
                    "HEAD"
                ],
                [CatClaims.catr]: {
                    [Catr.renewal_method]: "header_renewal",
                    [Catr.next_renewal_time]: 1750000000,
                    [Catr.max_uses]: 5
                }
            }
        };
        
        if (!request.headers['x-cwt-kid']) {
            throw new Error('Missing x-cwt-kid header');
        }
        
        const kid = request.headers['x-cwt-kid'].value;
        const secretKey = await cf.kvs().get(kid);
        
        if (!secretKey) {
            throw new Error('Secret key not found for provided kid');
        }
        
        try {
            const genContext = {
                cwtTag: true,
                coseTag: "MAC0",
                key: secretKey
            };
            
            const tokenBuffer = cf.cwt.generateToken(commonAccessToken, genContext);
            response.headers['x-generated-cwt-token'] = { value: tokenBuffer.toString('base64url') };
                        
            return response;
        } catch (tokenError) {
            return {
                statusCode: 401,
                statusDescription: 'Could not generate the token'
            };
        }
    } catch (error) {
        return {
            statusCode: 402,
            statusDescription: 'Token processing failed'
        };
    }
}

Exemple : Actualiser le jeton en fonction d'une certaine logique


import cf from 'cloudfront'

const CwtClaims = {
   iss: 1,
   aud: 3,
   exp: 4
}

async function handler(event) {
    try {
        let request = event.request;
        let encodedToken = request.headers['x-cwt-token'].value;
        let kid = request.headers['x-cwt-kid'].value;
        let secretKey = await cf.kvs().get(kid); // Retrieve the secret key from the kvs
                
        // Now you can use the secretKey to decode & validate the token.
        let tokenBuffer = Buffer.from(encodedToken, 'base64url');
                
        let handlerContext = {
           key: secretKey,
        }
                
        try {
            let cwtJSON = cf.cwt.validateToken(tokenBuffer, handlerContext);
                        
            // Check if token is expired
            const currentTime = Math.floor(Date.now() / 1000); // Current time in seconds
            if (cwtJSON[CwtClaims.exp] && cwtJSON[CwtClaims.exp] < currentTime) {
                // We can regnerate the token and add 8 hours to the expiry time
                cwtJSON[CwtClaims.exp] = Math.floor(Date.now() / 1000) + (8 * 60 * 60);
                                
                let genContext = {
                  coseTag: "MAC0",
                  key: secretKey
                }
                                
                let newTokenBuffer = cf.cwt.generateToken(cwtJSON, genContext);
                 request.headers['x-cwt-regenerated-token'] = newTokenBuffer.toString('base64url');
            }
        } catch (error) {
            return {
               statusCode: 401,
               statusDescription: 'Invalid token'
            };
         }
    }
    catch (error) {
        return {
            statusCode: 402,
            statusDescription: 'Token processing failed'
        };
     }
    return request;
}

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Utilisation de async et await

Méthodes d'assistance générales