CWT-Unterstützung für Funktionen CloudFront - Amazon CloudFront
Token-StrukturvalidateToken () -MethodeMethode generateToken ()

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

CWT-Unterstützung für Funktionen CloudFront

Dieser Abschnitt enthält Einzelheiten zur Unterstützung von CBOR-Web-Tokens (CWT) in Ihren CloudFront Funktionen, wodurch eine sichere tokenbasierte Authentifizierung und Autorisierung an Edge-Standorten ermöglicht wird. CloudFront Diese Unterstützung wird als Modul bereitgestellt, auf das Sie in Ihrer Funktion zugreifen können. CloudFront

Um dieses Modul zu verwenden, erstellen Sie eine CloudFront Funktion mit JavaScript Runtime 2.0 und fügen Sie die folgende Anweisung in die erste Zeile des Funktionscodes ein: 

import cf from 'cloudfront';

Auf die mit diesem Modul verknüpften Methoden kann über zugegriffen werden (wobei * ein Platzhalter ist, der die verschiedenen im Modul vorhandenen Funktionen darstellt):

cf.cwt.*

Weitere Informationen finden Sie unter Features von JavaScript Runtime 2.0 für CloudFront-Funktionen.

Derzeit unterstützt das Modul nur die MAC0-Struktur mit HS256 (HMAC-SHA256) Algorithmus mit einem Limit von 1 KB für die maximale Tokengröße.

Token-Struktur

In diesem Abschnitt wird die Token-Struktur behandelt, die vom CWT-Modul erwartet wird. Das Modul erwartet, dass das Token korrekt markiert und identifizierbar ist (z. B. COSE MAC0). Darüber hinaus folgt das Modul in Bezug auf die Struktur des Tokens den Standards von 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,        
        ]    
    )
)
Beispiel : CWT verwendet die COSE MAC0-Struktur
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       
        ]     
    )   
)
Anmerkung

Das CWT-Tag ist bei der Generierung von Token optional. Das COSE-Struktur-Tag ist jedoch erforderlich.

validateToken () -Methode

Die Funktion dekodiert und validiert ein CWT-Token mithilfe des angegebenen Schlüssels. Wenn die Validierung erfolgreich ist, gibt sie das dekodierte CWT-Token zurück. Andernfalls wird ein Fehler ausgegeben. Bitte beachten Sie, dass diese Funktion keine Überprüfung des Anspruchssatzes durchführt.

Anforderung

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

Codiertes Token zur Validierung. Das muss ein JavaScript Buffer sein.

HandlerContext (erforderlich)

Ein JavaScript Objekt, das den Kontext für den ValidateToken-Aufruf speichert. Derzeit wird nur die Schlüsseleigenschaft unterstützt.

Schlüssel (erforderlich)

Geheimer Schlüssel für die Berechnung des Message-Digests. Kann entweder als Zeichenfolge oder JavaScript als Puffer bereitgestellt werden.

Antwort

Wenn die validateToken() Methode ein erfolgreich validiertes Token zurückgibt, hat die Antwort CWTObject der Funktion das folgende Format. Nach der Dekodierung werden alle Claim-Schlüssel als Zeichenketten dargestellt.

CWTObject {    
    protectedHeaders,    
    unprotectedHeaders,    
    payload
}

Beispiel: Token validieren, wobei das Kind als Teil des Tokens gesendet wird

Dieses Beispiel demonstriert die CWT-Token-Validierung, bei der das Kind aus dem Header extrahiert wird. Das Kind wird dann an CloudFront Functions übergeben KeyValueStore , um den geheimen Schlüssel abzurufen, der zur Validierung des Tokens verwendet wurde.

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

Methode generateToken ()

Diese Funktion generiert ein neues CWT-Token unter Verwendung der bereitgestellten Payload- und Kontexteinstellungen.

Anforderung

cf.cwt.generateToken(generatorContext, payload)
Parameters
GeneratorContext (erforderlich)

Dies ist ein JavaScript Objekt, das als Kontext für die Generierung des Tokens verwendet wird und die folgenden Schlüssel-Wert-Paare enthält:

cwtTag (optional)

Dieser Wert ist ein boolescher Wert, der, wenn er true angibt, hinzugefügt werden soll. cwtTag

CoseTag (erforderlich)

Gibt den Typ des COSE-Tags an. Unterstützt derzeit nurMAC0.

Schlüssel (erforderlich)

Geheimer Schlüssel zur Berechnung des Message Digest. Dieser Wert kann entweder eine Zeichenfolge oder JavaScript Buffer sein.

Nutzlast (erforderlich)

Token-Nutzlast für die Kodierung. Die Nutzdaten müssen im CWTObject Format vorliegen.

Antwort

Gibt einen JavaScript Buffer zurück, der das kodierte Token enthält.

Beispiel : Generieren Sie ein CWT-Token
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'
        };
    }
}
Beispiel : Aktualisiere das Token auf der Grundlage einer bestimmten Logik
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;
}