La création d'signé S3 et Cloudfront Url via le SDK AWS

Mise à jour: j'ai déplacé la signature de fonctionnalités à partir de l'exemple de code ci-dessous dans la aws-cloudfront-signe paquet sur NPM. De cette façon, vous pouvez seulement besoin de ce paquet et appel getSignedUrl().

---

Après quelques recherches, j'ai trouvé une solution qui est une sorte de combo entre cette réponse et une méthode que j'ai trouvé dans le Boto bibliothèque. Il est vrai que S3 URL signatures sont traités différemment des CloudFront URL signatures. Si vous avez juste besoin de signer un S3 lien, puis le code d'exemple dans ma question de départ fonctionnent très bien pour vous. Cependant, il devient un peu plus compliqué si vous souhaitez générer signé Url qui utilisent votre distribution CloudFront. C'est parce que CloudFront URL signatures ne sont pas actuellement pris en charge dans le SDK AWS donc, vous devez créer la signature sur votre propre. Dans le cas où vous aussi vous avez besoin pour ce faire, voici les étapes de base. Je vais supposer que vous avez déjà un compartiment S3 installation:

Configurer CloudFront

1. Créer une distribution CloudFront
2. Configurer votre origine avec les paramètres suivants
   • Origine Nom de Domaine: {votre-s3-seau}
   • Restreindre Seau D'Accès: Oui
   • Accorder des Autorisations de Lecture sur Seau: Oui, la mise à Jour Seau Politique
3. Créer CloudFront Paire De Clés. Doit être capable de faire ce ici.

Créer Signé CloudFront URL

À grande signée CloudFront URL vous avez juste besoin de signer votre stratégie à l'aide de RSA-SHA1 et de l'inclure dans la requête param. Vous pouvez en savoir plus sur les politiques douanières ici mais j'ai inclus de base dans l'exemple de code ci-dessous qui devrait vous lever et courir. L'exemple de code est pour Node.js mais le processus peut être appliqué à n'importe quelle langue.

var crypto = require('crypto')
  , fs = require('fs')
  , util = require('util')
  , moment = require('moment')
  , urlParse = require('url')
  , cloudfrontAccessKey = '<your-cloudfront-public-key>'
  , expiration = moment().add('seconds', 30)  //epoch-expiration-time

//Define your policy.
var policy = {
   'Statement': [{
      'Resource': 'http://<your-cloudfront-domain-name>/path/to/object',
      'Condition': {
         'DateLessThan': {'AWS:EpochTime': '<epoch-expiration-time>'},
      }
   }]
}

//Now that you have your policy defined you can sign it like this:
var sign = crypto.createSign('RSA-SHA1')
  , pem = fs.readFileSync('<path-to-cloudfront-private-key>') 
  , key = pem.toString('ascii')

sign.update(JSON.stringify(policy))
var signature = sign.sign(key, 'base64')

//Finally, you build the URL with all of the required query params:
var url = {
  host: '<your-cloudfront-domain-name>',
  protocol: 'http',
  pathname: '<path-to-s3-object>'
}    
var params = {
  'Key-Pair-Id=' + cloudfrontAccessKey,
  'Expires=' + expiration,
  'Signature=' + signature
}
var signedUrl = util.format('%s?%s', urlParse.format(url), params.join('&'))

return signedUrl

AWS inclut certains intégrés dans des classes et des structures pour aider à la création d'signé des Url et des Cookies pour CloudFront. J'ai utilisé ces côtés de l'excellente réponse de Jason Sims pour le faire fonctionner dans une évolution légèrement différente (qui semble être très similaire à la MNP paquet qu'il a créé).

À savoir, l'AWS.CloudFront.Signataire de type description qui résume le processus de création signée les Url et les Cookies.

export class Signer {
    /**
     * A signer object can be used to generate signed URLs and cookies for granting access to content on restricted CloudFront distributions.
     * 
     * @param {string} keyPairId - The ID of the CloudFront key pair being used.
     * @param {string} privateKey - A private key in RSA format.
     */
    constructor(keyPairId: string, privateKey: string);

    ....
}

Et de l'une des options avec une politique de la chaîne JSON ou sans une politique avec une url et la date d'expiration.

export interface SignerOptionsWithPolicy {
    /**
     * A CloudFront JSON policy. Required unless you pass in a url and an expiry time. 
     */
    policy: string;
}
export interface SignerOptionsWithoutPolicy {
    /**
     * The URL to which the signature will grant access. Required unless you pass in a full policy.
     */
    url: string
    /**
     * A Unix UTC timestamp indicating when the signature should expire. Required unless you pass in a full policy.
     */
    expires: number
}

Exemple de mise en œuvre:

import aws, { CloudFront } from 'aws-sdk';

export async function getSignedUrl() {

    //https://abc.cloudfront.net/my-resource.jpg
    const url = <cloud front url/resource>;

    //Create signer object - requires a public key id and private key value
    const signer = new CloudFront.Signer(<public-key-id>, <private-key>);

    //Setup expiration time (one hour in the future, in this case)
    const expiration = new Date();
    expiration.setTime(expiration.getTime() + 1000 * 60 * 60);
    const expirationEpoch = expiration.valueOf();

    //Set options (Without policy in this example, but a JSON policy string can be substituted)
    const options = {
        url: url,
        expires: expirationEpoch
    };

    return new Promise((resolve, reject) => {
        //Call getSignedUrl passing in options, to be handled either by callback or synchronously without callback
        signer.getSignedUrl(options, (err, url) => {
            if (err) {
                console.error(err.stack);
                reject(err);
            }
            resolve(url);
        });
    });
}