Struttura del token Metodo validateToken ()Metodo generateToken ()

Supporto CWT per le funzioni CloudFront

Questa sezione fornisce dettagli sul supporto per i CBOR Web Tokens (CWT) nelle CloudFront funzioni, che consente l'autenticazione e l'autorizzazione sicure basate su token presso le Edge Locations. CloudFront Questo supporto viene fornito come modulo, accessibile nella tua funzione. CloudFront

Per utilizzare questo modulo, create una CloudFront Function utilizzando JavaScript runtime 2.0 e includete la seguente dichiarazione nella prima riga del codice della funzione:


import cf from 'cloudfront';

I metodi associati a questo modulo sono accessibili tramite (dove * è un carattere jolly che rappresenta le diverse funzioni presenti nel modulo):


cf.cwt.*

Per ulteriori informazioni, consulta JavaScript funzionalità di runtime 2.0 per CloudFront Functions.

Attualmente, il modulo supporta solo la struttura MAC0 con algoritmo HS256 (HMAC-SHA256) con un limite di 1 KB per la dimensione massima del token.

Struttura del token

Questa sezione descrive la struttura dei token prevista dal modulo CWT. Il modulo si aspetta che il token sia etichettato e identificabile correttamente (ad esempio COSE MAC0). Inoltre, per quanto riguarda la struttura del token, il modulo segue gli standard stabiliti da 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,        
        ]    
    )
)

Esempio: CWT utilizza la struttura 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       
        ]     
    )   
)

Nota

Il tag CWT è opzionale quando si generano i token. Tuttavia, il tag di struttura COSE è obbligatorio.

Metodo validateToken ()

La funzione decodifica e convalida un token CWT utilizzando la chiave specificata. Se la convalida ha esito positivo, restituisce il token CWT decodificato. Altrimenti, genera un errore. Tieni presente che questa funzione non esegue alcuna convalida sul set di attestazioni.

Richiesta


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

Parameters

token (obbligatorio): Token codificato per la convalida. Deve essere un JavaScript buffer.
HandlerContext (obbligatorio): Un JavaScript oggetto che memorizza il contesto per la chiamata ValidateToken. Al momento, è supportata solo la proprietà key.
chiave (Obbligatorio): Chiave segreta per il calcolo del riepilogo dei messaggi. Può essere fornita come stringa o JavaScript come buffer.

Risposta

Quando il validateToken() metodo restituisce un token convalidato con successo, la risposta della funzione è CWTObject nel formato seguente. Una volta decodificate, tutte le chiavi di attestazione vengono rappresentate come stringhe.


CWTObject {    
    protectedHeaders,    
    unprotectedHeaders,    
    payload
}

Esempio: convalida il token con kid inviato come parte del token

Questo esempio dimostra la convalida del token CWT, in cui il kid viene estratto dall'intestazione. Il bambino viene quindi passato KeyValueStore a CloudFront Functions per recuperare la chiave segreta utilizzata per convalidare il token.


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;
}

Metodo generateToken ()

Questa funzione genera un nuovo token CWT utilizzando il payload e le impostazioni di contesto fornite.

Richiesta


cf.cwt.generateToken(generatorContext, payload)

Parameters

GeneratorContext (obbligatorio)

Si tratta di un JavaScript oggetto utilizzato come contesto per la generazione del token e contiene le seguenti coppie chiave-valore:

CWTTag (opzionale): Questo valore è un valore booleano che, se lo true specifica, deve essere aggiunto. cwtTag
coseTag (Obbligatorio): Specifica il tipo di tag COSE. Attualmente supporta MAC0 solo.
chiave (Obbligatorio): Chiave segreta per calcolare il riepilogo dei messaggi. Questo valore può essere una stringa o. JavaScript Buffer

payload (Obbligatorio)

Payload del token per la codifica. Il payload deve essere in formato. CWTObject

Risposta

Restituisce un JavaScript Buffer contenente il token codificato.

Esempio: genera un token 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'
        };
    }
}

Esempio: Aggiorna il token in base a una logica


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;
}

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Utilizzo asincrono and await

Metodi generali di supporto