Direkter Upload von Amazon S3-Dateien über den Client-Browser

159

Ich implementiere einen direkten Datei-Upload vom Client-Computer auf Amazon S3 über die REST-API, wobei nur JavaScript ohne serverseitigen Code verwendet wird. Alles funktioniert gut, aber eines macht mir Sorgen ...

Wenn ich eine Anfrage an die Amazon S3 REST-API sende, muss ich die Anfrage signieren und eine Signatur in den AuthenticationHeader einfügen. Um eine Signatur zu erstellen, muss ich meinen geheimen Schlüssel verwenden. Aber alles geschieht auf Client-Seite, sodass der geheime Schlüssel leicht aus der Seitenquelle enthüllt werden kann (selbst wenn ich meine Quellen verschleiere / verschlüssele).

Wie kann ich damit umgehen? Und ist es überhaupt ein Problem? Vielleicht kann ich die Verwendung bestimmter privater Schlüssel nur auf REST-API-Aufrufe von einem bestimmten CORS-Ursprung und nur auf PUT- und POST-Methoden beschränken oder den Schlüssel nur mit S3 und einem bestimmten Bucket verknüpfen? Möglicherweise gibt es andere Authentifizierungsmethoden?

Die "serverlose" Lösung ist ideal, aber ich kann in Betracht ziehen, einige serverseitige Verarbeitungen durchzuführen, ohne das Hochladen einer Datei auf meinen Server und das anschließende Senden an S3.

— Olegas
quelle

7

Ganz einfach: Speichern Sie keine Geheimnisse clientseitig. Sie müssen einen Server einbeziehen, um die Anforderung zu signieren.

— Ray Nicholus

1

Sie werden auch feststellen, dass das Signieren und Codieren dieser Anforderungen durch Base-64 auf der Serverseite viel einfacher ist. Es erscheint nicht unangemessen, hier überhaupt einen Server einzubeziehen. Ich kann verstehen, dass nicht alle Datei-Bytes an einen Server und dann bis zu S3 gesendet werden sollen, aber das Signieren der Anforderungen auf der Clientseite hat nur sehr geringe Vorteile, zumal dies auf der Clientseite etwas schwierig und möglicherweise langsam sein wird (in Javascript).

— Ray Nicholus

5

Es ist 2016, als die Architektur ohne Server sehr populär wurde. Das direkte Hochladen von Dateien in S3 ist mithilfe von AWS Lambda möglich. Siehe meine Antwort auf eine ähnliche Frage: stackoverflow.com/a/40828683/2504317 Grundsätzlich hätten Sie eine Lambda-Funktion als API, die eine hochladbare URL für jede Datei signiert, und Ihr cliend-seitiges Javascript führt einfach einen HTTP-PUT für das aus vorsignierte URL. Ich habe eine Vue-Komponente geschrieben, die solche Dinge tut. Der S3-Upload-bezogene Code ist bibliotheksunabhängig. Schauen Sie sich das an und kommen Sie auf die Idee.

— KF Lin

Ein weiterer Drittanbieter für den HTTP / S-POST-Upload in einem beliebigen S3-Bucket. JS3Upload reines HTML5: jfileupload.com/products/js3upload-html5/index.html

— JFU

215

Ich denke, was Sie wollen, sind browserbasierte Uploads mit POST.

Grundsätzlich benötigen Sie serverseitigen Code, der jedoch nur signierte Richtlinien generiert. Sobald der clientseitige Code über die signierte Richtlinie verfügt, kann er mithilfe von POST direkt in S3 hochgeladen werden, ohne dass die Daten über Ihren Server übertragen werden.

Hier sind die offiziellen Doc-Links:

Diagramm: http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingHTTPPOST.html

Beispielcode: http://docs.aws.amazon.com/AmazonS3/latest/dev/HTTPPOSTExamples.html

Die signierte Richtlinie wird in folgender Form in Ihr HTML eingefügt:

<html>
  <head>
    ...
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    ...
  </head>
  <body>
  ...
  <form action="http://johnsmith.s3.amazonaws.com/" method="post" enctype="multipart/form-data">
    Key to upload: <input type="input" name="key" value="user/eric/" /><br />
    <input type="hidden" name="acl" value="public-read" />
    <input type="hidden" name="success_action_redirect" value="http://johnsmith.s3.amazonaws.com/successful_upload.html" />
    Content-Type: <input type="input" name="Content-Type" value="image/jpeg" /><br />
    <input type="hidden" name="x-amz-meta-uuid" value="14365123651274" />
    Tags for File: <input type="input" name="x-amz-meta-tag" value="" /><br />
    <input type="hidden" name="AWSAccessKeyId" value="AKIAIOSFODNN7EXAMPLE" />
    <input type="hidden" name="Policy" value="POLICY" />
    <input type="hidden" name="Signature" value="SIGNATURE" />
    File: <input type="file" name="file" /> <br />
    <!-- The elements after this will be ignored -->
    <input type="submit" name="submit" value="Upload to Amazon S3" />
  </form>
  ...
</html>

Beachten Sie, dass die FORM-Aktion die Datei direkt an S3 sendet - nicht über Ihren Server.

Jedes Mal, wenn einer Ihrer Benutzer eine Datei hochladen möchte, erstellen Sie das POLICYund SIGNATUREauf Ihrem Server. Sie geben die Seite an den Browser des Benutzers zurück. Der Benutzer kann dann eine Datei direkt in S3 hochladen, ohne Ihren Server zu durchlaufen.

Wenn Sie die Richtlinie unterschreiben, läuft die Richtlinie normalerweise nach einigen Minuten ab. Dies zwingt Ihre Benutzer, vor dem Hochladen mit Ihrem Server zu sprechen. Auf diese Weise können Sie Uploads überwachen und begrenzen, wenn Sie dies wünschen.

Die einzigen Daten, die zu oder von Ihrem Server gesendet werden, sind die signierten URLs. Ihre geheimen Schlüssel bleiben auf dem Server geheim.

— secretmike
quelle

14

Bitte beachten Sie, dass hierfür Signature v2 verwendet wird, das in Kürze durch v4 ersetzt wird: docs.aws.amazon.com/AmazonS3/latest/API/…

— Jörn Berkefeld

9

Stellen Sie sicher, dass Sie ${filename}den Schlüsselnamen hinzufügen , also für das obige Beispiel user/eric/${filename}anstatt nur user/eric. Wenn user/ericbereits ein Ordner vorhanden ist, schlägt der Upload unbeaufsichtigt fehl (Sie werden sogar zu success_action_redirect umgeleitet), und der hochgeladene Inhalt ist nicht vorhanden. Ich habe gerade Stunden damit verbracht, dieses Denken zu debuggen, dass es sich um ein Berechtigungsproblem handelt.

— Balint Erdi

@secretmike Wenn Sie eine Zeitüberschreitung von dieser Methode erhalten hätten, wie würden Sie empfehlen, diese zu umgehen?

— Reise

1

@Trip Da der Browser die Datei an S3 sendet, müssen Sie das Zeitlimit in Javascript erkennen und selbst einen erneuten Versuch starten.

— secretmike

@secretmike Das riecht nach einem Endlosschleifenzyklus. Da das Timeout für jede Datei über 10 / mbs auf unbestimmte Zeit wiederholt wird.

— Reise

40

Sie können dies mit AWS S3 Cognito tun. Versuchen Sie diesen Link hier:

http://docs.aws.amazon.com/AWSJavaScriptSDK/guide/browser-examples.html#Amazon_S3

Versuchen Sie auch diesen Code

Ändern Sie einfach Region, IdentityPoolId und Ihren Bucket-Namen

<!DOCTYPE html>
<html>

<head>
    <title>AWS S3 File Upload</title>
    <script src="https://sdk.amazonaws.com/js/aws-sdk-2.1.12.min.js"></script>
</head>

<body>
    <input type="file" id="file-chooser" />
    <button id="upload-button">Upload to S3</button>
    <div id="results"></div>
    <script type="text/javascript">
    AWS.config.region = 'your-region'; // 1. Enter your region

    AWS.config.credentials = new AWS.CognitoIdentityCredentials({
        IdentityPoolId: 'your-IdentityPoolId' // 2. Enter your identity pool
    });

    AWS.config.credentials.get(function(err) {
        if (err) alert(err);
        console.log(AWS.config.credentials);
    });

    var bucketName = 'your-bucket'; // Enter your bucket name
    var bucket = new AWS.S3({
        params: {
            Bucket: bucketName
        }
    });

    var fileChooser = document.getElementById('file-chooser');
    var button = document.getElementById('upload-button');
    var results = document.getElementById('results');
    button.addEventListener('click', function() {

        var file = fileChooser.files[0];

        if (file) {

            results.innerHTML = '';
            var objKey = 'testing/' + file.name;
            var params = {
                Key: objKey,
                ContentType: file.type,
                Body: file,
                ACL: 'public-read'
            };

            bucket.putObject(params, function(err, data) {
                if (err) {
                    results.innerHTML = 'ERROR: ' + err;
                } else {
                    listObjs();
                }
            });
        } else {
            results.innerHTML = 'Nothing to upload.';
        }
    }, false);
    function listObjs() {
        var prefix = 'testing';
        bucket.listObjects({
            Prefix: prefix
        }, function(err, data) {
            if (err) {
                results.innerHTML = 'ERROR: ' + err;
            } else {
                var objKeys = "";
                data.Contents.forEach(function(obj) {
                    objKeys += obj.Key + "<br>";
                });
                results.innerHTML = objKeys;
            }
        });
    }
    </script>
</body>

</html>

Erweitern Sie das Snippet

Weitere Informationen finden Sie unter - Github

— Joomler
quelle

Unterstützt dies mehrere Bilder?

— user2722667

@ user2722667 ja das tut es.

— Joomler

@Joomler Hallo Danke, aber ich habe dieses Problem mit Firefox RequestTimeout. Ihre Socket-Verbindung zum Server wurde innerhalb des Timeout-Zeitraums nicht gelesen oder beschrieben. Inaktive Verbindungen werden geschlossen und die Datei wird nicht auf S3 hochgeladen. Können Sie mir bitte helfen, wie ich dieses Problem beheben kann. Danke

— usama

1

@usama können Sie bitte die Ausgabe im Github öffnen, weil mir die Ausgabe nicht klar ist

— Joomler

@Joomler Entschuldigung für die späte Antwort hier Ich habe eine Ausgabe bei GitHub eröffnet. Bitte schauen Sie sich diese an. Danke. github.com/aws/aws-sdk-php/issues/1332

— usama

16

Sie sagen, Sie wollen eine "serverlose" Lösung. Dies bedeutet jedoch, dass Sie keinen "Ihrer" Code in die Schleife einfügen können. (HINWEIS: Sobald Sie Ihren Code einem Client übergeben haben, ist er jetzt "sein" Code.) Das Sperren von CORS hilft nicht weiter: Benutzer können problemlos ein nicht webbasiertes Tool (oder einen webbasierten Proxy) schreiben, das hinzugefügt wird den richtigen CORS-Header, um Ihr System zu missbrauchen.

Das große Problem ist, dass Sie nicht zwischen den verschiedenen Benutzern unterscheiden können. Sie können einem Benutzer nicht erlauben, seine Dateien aufzulisten / darauf zuzugreifen, aber andere daran hindern. Wenn Sie Missbrauch feststellen, können Sie nichts dagegen tun, außer den Schlüssel zu ändern. (Was der Angreifer vermutlich gerade nochmal bekommen kann.)

Am besten erstellen Sie einen "IAM-Benutzer" mit einem Schlüssel für Ihren Javascript-Client. Geben Sie ihm nur Schreibzugriff auf nur einen Bucket. (Aktivieren Sie den ListBucket-Vorgang jedoch im Idealfall nicht, da er für Angreifer attraktiver wird.)

Wenn Sie einen Server hätten (sogar eine einfache Mikroinstanz für 20 US-Dollar pro Monat), könnten Sie die Schlüssel auf Ihrem Server signieren und gleichzeitig den Missbrauch in Echtzeit überwachen / verhindern. Ohne Server können Sie am besten regelmäßig nachträglich auf Missbrauch überwachen. Folgendes würde ich tun:

1) Drehen Sie die Schlüssel für diesen IAM-Benutzer regelmäßig: Generieren Sie jede Nacht einen neuen Schlüssel für diesen IAM-Benutzer und ersetzen Sie den ältesten Schlüssel. Da es 2 Schlüssel gibt, ist jeder Schlüssel 2 Tage gültig.

2) Aktivieren Sie die S3-Protokollierung und laden Sie die Protokolle stündlich herunter. Stellen Sie Warnungen auf "zu viele Uploads" und "zu viele Downloads" ein. Sie sollten sowohl die Gesamtgröße der Datei als auch die Anzahl der hochgeladenen Dateien überprüfen. Außerdem möchten Sie sowohl die globalen Summen als auch die Summen pro IP-Adresse (mit einem niedrigeren Schwellenwert) überwachen.

Diese Überprüfungen können "serverlos" durchgeführt werden, da Sie sie auf Ihrem Desktop ausführen können. (dh S3 erledigt die ganze Arbeit, diese Prozesse dienen nur dazu, Sie auf den Missbrauch Ihres S3-Buckets aufmerksam zu machen, damit Sie am Monatsende keine riesige AWS-Rechnung erhalten.)

— BraveNewCurrency
quelle

3

Mann, ich habe vergessen, wie kompliziert die Dinge vor Lambda waren.

— Ryan Shillington

10

Wenn Sie der akzeptierten Antwort weitere Informationen hinzufügen, können Sie in meinem Blog eine laufende Version des Codes mit AWS Signature Version 4 anzeigen.

Fasst hier zusammen:

Sobald der Benutzer eine hochzuladende Datei auswählt, gehen Sie wie folgt vor: 1. Rufen Sie den Webserver an, um einen Dienst zum Generieren der erforderlichen Parameter zu initiieren

Rufen Sie in diesem Service den AWS IAM-Service an, um eine temporäre Gutschrift zu erhalten
Sobald Sie die Berechtigung haben, erstellen Sie eine Bucket-Richtlinie (Base 64-codierte Zeichenfolge). Signieren Sie dann die Bucket-Richtlinie mit dem temporären geheimen Zugriffsschlüssel, um die endgültige Signatur zu generieren
Senden Sie die erforderlichen Parameter an die Benutzeroberfläche zurück
Sobald dies empfangen wurde, erstellen Sie ein HTML-Formularobjekt, legen Sie die erforderlichen Parameter fest und POSTEN Sie es.

Ausführliche Informationen finden Sie unter https://wordpress1763.wordpress.com/2016/10/03/browser-based-upload-aws-signature-version-4/

— RajeevJ
quelle

5

Ich habe einen ganzen Tag lang versucht, dies in Javascript herauszufinden, und diese Antwort zeigt mir genau, wie dies mit XMLhttprequest gemacht wird. Ich bin sehr überrascht, dass Sie abgelehnt wurden. Das OP bat um Javascript und erhielt Formulare in den empfohlenen Antworten. Guter Kummer. Danke für diese Antwort!

— Paul S.

Übrigens, Superagent hat ernsthafte CORS-Probleme, daher scheint xmlhttprequest der einzig vernünftige Weg zu sein, dies jetzt zu tun

— Paul S

4

Um eine Signatur zu erstellen, muss ich meinen geheimen Schlüssel verwenden. Aber alles geschieht auf Client-Seite, sodass der geheime Schlüssel leicht aus der Seitenquelle enthüllt werden kann (selbst wenn ich meine Quellen verschleiere / verschlüssele).

Hier haben Sie falsch verstanden. Der Grund, warum digitale Signaturen verwendet werden, besteht darin, dass Sie etwas als korrekt überprüfen können, ohne Ihren geheimen Schlüssel preiszugeben. In diesem Fall wird die digitale Signatur verwendet, um zu verhindern, dass der Benutzer die Richtlinie ändert, die Sie für den Formularbeitrag festgelegt haben.

Digitale Signaturen wie die hier werden aus Sicherheitsgründen im gesamten Web verwendet. Wenn jemand (NSA?) Sie wirklich brechen könnte, hätte er viel größere Ziele als Ihr S3-Eimer :)

— OlliM
quelle

2

Ein Roboter kann jedoch versuchen, unbegrenzt viele Dateien schnell hochzuladen. Kann ich eine Richtlinie für die maximale Anzahl von Dateien pro Bucket festlegen?

— Dejell

3

Ich habe einen einfachen Code angegeben, um Dateien vom Javascript-Browser in AWS S3 hochzuladen und alle Dateien im S3-Bucket aufzulisten.

Schritte:

Informationen zum Erstellen von Create IdentityPoolId finden Sie unter http://docs.aws.amazon.com/cognito/latest/developerguide/identity-pools.html

Gehen Sie zur Konsolenseite von S3 und öffnen Sie die Cors-Konfiguration über die Bucket-Eigenschaften und schreiben Sie den folgenden XML-Code hinein.

<?xml version="1.0" encoding="UTF-8"?>
<CORSConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
 <CORSRule>    
  <AllowedMethod>GET</AllowedMethod>
  <AllowedMethod>PUT</AllowedMethod>
  <AllowedMethod>DELETE</AllowedMethod>
  <AllowedMethod>HEAD</AllowedMethod>
  <AllowedHeader>*</AllowedHeader>
 </CORSRule>
</CORSConfiguration>

Erstellen Sie eine HTML-Datei mit folgendem Code, ändern Sie die Anmeldeinformationen, öffnen Sie die Datei im Browser und genießen Sie.

<script type="text/javascript">
 AWS.config.region = 'ap-north-1'; // Region
 AWS.config.credentials = new AWS.CognitoIdentityCredentials({
 IdentityPoolId: 'ap-north-1:*****-*****',
 });
 var bucket = new AWS.S3({
 params: {
 Bucket: 'MyBucket'
 }
 });

 var fileChooser = document.getElementById('file-chooser');
 var button = document.getElementById('upload-button');
 var results = document.getElementById('results');

 function upload() {
 var file = fileChooser.files[0];
 console.log(file.name);

 if (file) {
 results.innerHTML = '';
 var params = {
 Key: n + '.pdf',
 ContentType: file.type,
 Body: file
 };
 bucket.upload(params, function(err, data) {
 results.innerHTML = err ? 'ERROR!' : 'UPLOADED.';
 });
 } else {
 results.innerHTML = 'Nothing to upload.';
 }    }
</script>
<body>
 <input type="file" id="file-chooser" />
 <input type="button" onclick="upload()" value="Upload to S3">
 <div id="results"></div>
</body>

— Nilesh Pawar
quelle

2

Wäre nicht jemand in der Lage, meine "IdentityPoolId" zum Hochladen von Dateien in meinen S3-Bucket zu verwenden. Wie verhindert diese Lösung, dass Dritte nur meine "IdentityPoolId" kopieren und viele Dateien in meinen S3-Bucket hochladen?

— Sahil

1

stackoverflow.com/users/4535741/sahil Sie können das Hochladen von Daten / Dateien aus anderen Domänen verhindern, indem Sie die entsprechenden CORS-Einstellungen auf S3-Bucket setzen. Selbst wenn jemand auf Ihre Identitätspool-ID zugegriffen hat, kann er Ihre S3-Bucket-Dateien nicht manipulieren.

— Nilesh Pawar

2

Wenn Sie keinen serverseitigen Code haben, hängt Ihre Sicherheit von der Sicherheit des Zugriffs auf Ihren JavaScript-Code auf der Clientseite ab (dh jeder, der den Code hat, kann etwas hochladen).

Daher würde ich empfehlen, einfach einen speziellen S3-Bucket zu erstellen, der öffentlich beschreibbar (aber nicht lesbar) ist, sodass Sie auf der Clientseite keine signierten Komponenten benötigen.

Der Bucket-Name (z. B. eine GUID) ist Ihre einzige Verteidigung gegen böswillige Uploads (ein potenzieller Angreifer konnte Ihren Bucket jedoch nicht zum Übertragen von Daten verwenden, da er nur an ihn geschrieben wird).

— Rüdiger Jungbeck
quelle

1

So generieren Sie ein Richtliniendokument mit Node und Serverless

"use strict";

const uniqid = require('uniqid');
const crypto = require('crypto');

class Token {

    /**
     * @param {Object} config SSM Parameter store JSON config
     */
    constructor(config) {

        // Ensure some required properties are set in the SSM configuration object
        this.constructor._validateConfig(config);

        this.region = config.region; // AWS region e.g. us-west-2
        this.bucket = config.bucket; // Bucket name only
        this.bucketAcl = config.bucketAcl; // Bucket access policy [private, public-read]
        this.accessKey = config.accessKey; // Access key
        this.secretKey = config.secretKey; // Access key secret

        // Create a really unique videoKey, with folder prefix
        this.key = uniqid() + uniqid.process();

        // The policy requires the date to be this format e.g. 20181109
        const date = new Date().toISOString();
        this.dateString = date.substr(0, 4) + date.substr(5, 2) + date.substr(8, 2);

        // The number of minutes the policy will need to be used by before it expires
        this.policyExpireMinutes = 15;

        // HMAC encryption algorithm used to encrypt everything in the request
        this.encryptionAlgorithm = 'sha256';

        // Client uses encryption algorithm key while making request to S3
        this.clientEncryptionAlgorithm = 'AWS4-HMAC-SHA256';
    }

    /**
     * Returns the parameters that FE will use to directly upload to s3
     *
     * @returns {Object}
     */
    getS3FormParameters() {
        const credentialPath = this._amazonCredentialPath();
        const policy = this._s3UploadPolicy(credentialPath);
        const policyBase64 = new Buffer(JSON.stringify(policy)).toString('base64');
        const signature = this._s3UploadSignature(policyBase64);

        return {
            'key': this.key,
            'acl': this.bucketAcl,
            'success_action_status': '201',
            'policy': policyBase64,
            'endpoint': "https://" + this.bucket + ".s3-accelerate.amazonaws.com",
            'x-amz-algorithm': this.clientEncryptionAlgorithm,
            'x-amz-credential': credentialPath,
            'x-amz-date': this.dateString + 'T000000Z',
            'x-amz-signature': signature
        }
    }

    /**
     * Ensure all required properties are set in SSM Parameter Store Config
     *
     * @param {Object} config
     * @private
     */
    static _validateConfig(config) {
        if (!config.hasOwnProperty('bucket')) {
            throw "'bucket' is required in SSM Parameter Store Config";
        }
        if (!config.hasOwnProperty('region')) {
            throw "'region' is required in SSM Parameter Store Config";
        }
        if (!config.hasOwnProperty('accessKey')) {
            throw "'accessKey' is required in SSM Parameter Store Config";
        }
        if (!config.hasOwnProperty('secretKey')) {
            throw "'secretKey' is required in SSM Parameter Store Config";
        }
    }

    /**
     * Create a special string called a credentials path used in constructing an upload policy
     *
     * @returns {String}
     * @private
     */
    _amazonCredentialPath() {
        return this.accessKey + '/' + this.dateString + '/' + this.region + '/s3/aws4_request';
    }

    /**
     * Create an upload policy
     *
     * @param {String} credentialPath
     *
     * @returns {{expiration: string, conditions: *[]}}
     * @private
     */
    _s3UploadPolicy(credentialPath) {
        return {
            expiration: this._getPolicyExpirationISODate(),
            conditions: [
                {bucket: this.bucket},
                {key: this.key},
                {acl: this.bucketAcl},
                {success_action_status: "201"},
                {'x-amz-algorithm': 'AWS4-HMAC-SHA256'},
                {'x-amz-credential': credentialPath},
                {'x-amz-date': this.dateString + 'T000000Z'}
            ],
        }
    }

    /**
     * ISO formatted date string of when the policy will expire
     *
     * @returns {String}
     * @private
     */
    _getPolicyExpirationISODate() {
        return new Date((new Date).getTime() + (this.policyExpireMinutes * 60 * 1000)).toISOString();
    }

    /**
     * HMAC encode a string by a given key
     *
     * @param {String} key
     * @param {String} string
     *
     * @returns {String}
     * @private
     */
    _encryptHmac(key, string) {
        const hmac = crypto.createHmac(
            this.encryptionAlgorithm, key
        );
        hmac.end(string);

        return hmac.read();
    }

    /**
     * Create an upload signature from provided params
     * https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html#signing-request-intro
     *
     * @param policyBase64
     *
     * @returns {String}
     * @private
     */
    _s3UploadSignature(policyBase64) {
        const dateKey = this._encryptHmac('AWS4' + this.secretKey, this.dateString);
        const dateRegionKey = this._encryptHmac(dateKey, this.region);
        const dateRegionServiceKey = this._encryptHmac(dateRegionKey, 's3');
        const signingKey = this._encryptHmac(dateRegionServiceKey, 'aws4_request');

        return this._encryptHmac(signingKey, policyBase64).toString('hex');
    }
}

module.exports = Token;

Das verwendete Konfigurationsobjekt wird im SSM- Parameterspeicher gespeichert und sieht folgendermaßen aus

{
    "bucket": "my-bucket-name",
    "region": "us-west-2",
    "bucketAcl": "private",
    "accessKey": "MY_ACCESS_KEY",
    "secretKey": "MY_SECRET_ACCESS_KEY",
}

— Samir Patel
quelle

0

Wenn Sie bereit sind, einen Dienst eines Drittanbieters zu verwenden, unterstützt auth0.com diese Integration. Der auth0-Dienst tauscht eine SSO-Dienstauthentifizierung eines Drittanbieters gegen ein temporäres AWS-Sitzungstoken aus, wodurch die Berechtigungen eingeschränkt werden.

Siehe: https://github.com/auth0-samples/auth0-s3-sample/
und die auth0-Dokumentation.

— Jason
quelle

1

Soweit ich weiß - haben wir jetzt Cognito dafür?

— Vitaly Zdanevich

Direkter Upload von Amazon S3-Dateien über den Client-Browser - Offenlegung privater Schlüssel