Beim Einschränken des Zugriffs auf Inhalte unter CloudFront

Signierte URL mit Richtlinien
Signierte URL mit benutzerdefinierter Richtlinie
Signiertes Cookie mit Richtlinien
Signiertes Cookie mit benutzerdefinierten Richtlinien

Kann verwendet werden.

[Referenz: Link zu Dokumenten in AWS] ** Signierte URL verwenden ** ** · [Erstellen Sie eine signierte URL mit der Standardrichtlinie](http://docs.aws.amazon.com/ja_jp/AmazonCloudFront/latest/DeveloperGuide/private-content-creating-signed-url-canned- policy.html) ** ** · [Erstellen einer signierten URL mithilfe einer benutzerdefinierten Richtlinie](http://docs.aws.amazon.com/ja_jp/AmazonCloudFront/latest/DeveloperGuide/private-content-creating-signed-url-custom- policy.html) ** ** Signierte Cookies verwenden ** ** · Festlegen signierter Cookies mithilfe der Standardrichtlinie. html) ** ** · Festlegen signierter Cookies mithilfe benutzerdefinierter Richtlinien. html) **

Aber,

Wenn Sie eine signierte URL verwenden, müssen Sie jeden Link der Ressource signieren, auf die Sie zugreifen.
Bei Verwendung der Standardrichtlinie können keine Platzhalter (** "?" "*" **) zum Angeben des Berechtigungsziels verwendet werden.

Damit

1 Zugriff auf jede Datei gewähren
Generieren Sie dynamisch nacheinander Links zu Ressourcen von der Anwendungsseite

In diesem Fall ist die Standardrichtlinie oder die signierte URL in Ordnung.

Inhalte, die Zugriffsbeschränkungen unterliegen, bestehen aus HTML-Datei + .css + Bild + Video

In diesem Fall ist es nicht realistisch, die Links zu den CSS-, Bild- und Videodateien zu signieren, die mit der signierten URL gelesen werden. Diesmal ** Signiertes Cookie mit benutzerdefinierten Richtlinien * Ich habe mit * experimentiert.

0. Inhalt dieses Experiments

Die Anwendung gibt ein signiertes Cookie aus und setzt es im Browser.
Inhalte, die Zugriffsbeschränkungen unterliegen, werden im S3-Bucket gespeichert ** "testmatsusignedcookie" **.
Die Anwendung wird unter ** "https://hmatsu47.site/" ** veröffentlicht (der Satz von Cookies wird unter ** "/ set-cookie" ** ausgeführt).
Inhalte, die Zugriffsbeschränkungen unterliegen, werden auf ** "https://www.hmatsu47.site/" ** (CloudFront-Distribution) veröffentlicht.
Geben Sie das Domain-Attribut ** "hmatsu47.site" ** für das signierte Cookie an, das ausgegeben werden soll, damit Sie sich nicht um die Ausstellungsmethode und die Akzeptanzbeschränkungen des Cookies eines Drittanbieters kümmern müssen.
Aktivieren Sie gleichzeitig das Attribut "Sicher" (deaktiviert beim Veröffentlichen mit Nicht-SSL / TLS) und das Attribut "HttpOnly" (deaktiviert, wenn Cookies mit JavaScript verarbeitet werden).

1. CloudFront + S3-Seiteneinstellungen

Stellen Sie gemäß dem folgenden Fluss ein.

1-1 Erstellen Sie ein CloudFront-Schlüsselpaar in der AWS Management Console

Im Folgenden können IAM-Benutzer es nicht erstellen. Verwenden Sie daher ** einen Benutzer mit Root-Anmeldeinformationen **, um den Vorgang auszuführen.

① Wählen Sie ** "Sicherheitsanmeldeinformationen" ** aus dem Benutzermenü oben rechts. ② Erweitern Sie ** "Cloud Front Key Pair" ** ③ Klicken Sie auf ** [Neues Schlüsselpaar erstellen] ** ④ Klicken Sie auf ** [Private Schlüsseldatei herunterladen] **, um die private Schlüsseldatei herunterzuladen ⑤ Bestätigen Sie die Schlüsselpaar-ID und zeichnen Sie sie bei geschlossenem Popup auf dem Bildschirm auf.

Sie können die Schlüsselpaar-ID auch anhand der Zeichenfolge zwischen ** "pk-" ** und ** ".pem" ** in der heruntergeladenen privaten Schlüsseldatei überprüfen. ⑥ Konvertieren Sie die private Schlüsseldatei (.pem-Format) mit OpenSSL in das .der-Format, indem Sie auf den folgenden Link verweisen. ** [Privates CloudFront-Schlüsselformat ändern (nur .NET und Java)](http://docs.aws.amazon.com/ja_jp/AmazonCloudFront/latest/DeveloperGuide/private-content-trusted-signers.html# Private-Content-Neuformatierung-Private-Key) **
Einige Websites bieten OpenSSL-Binärdateien (.exe) für Windows-Umgebungen, sodass Sie diese auch verwenden können.

`Befehl openssl`


openssl pkcs8 -topk8 -nocrypt -in [Dateiname des privaten Schlüssels].pem -inform PEM -out [Name der Ausgabedatei].der -outform DER

1-2. Erstellen Sie eine CloudFront-Distribution

① Klicken Sie in der Konsole unter Cloud Front → Distribution auf ** [Distribution erstellen] **.

② Klicken Sie im Web auf ** [Erste Schritte] **

③ Legen Sie Elemente fest, die sich auf den Ursprungs-S3-Bucket beziehen ④ Wählen Sie ** "Ja" ** in ** "Bucket Access einschränken" ** ⑤ Wählen Sie ** "Neue Identität erstellen" ** in ** "Ursprungszugriffsidentität" ** ⑥ Wählen Sie ** "Ja, ..." ** in ** "Leseberechtigungen für Bucket erteilen" **

⑦ Wählen Sie ** "Ja" ** in ** "Viewer-Zugriff einschränken" ** ⑧ Aktivieren Sie ** "Self" ** in ** "Trusted Signers" ** ⑨ Geben Sie den Domainnamen (FQDN, der der CloudFront-Distribution zugewiesen ist) in ** "Alternative Domainnamen" ** an

Geben Sie nach Abschluss der Verteilungserstellung den Alias des A-Datensatzes im entsprechenden Datensatz von Route 53 an.

⑩ Festlegen von SSL / TLS-bezogenen Elementen (Wählen Sie nach Auswahl von ** "Benutzerdefiniertes SSL-Zertifikat" ** das zu verwendende Zertifikat aus oder fordern Sie ein neues SNI-SSL-Zertifikat an.)

⑪ ** Klicken Sie auf "Distribution erstellen" **

⑫ Klicken Sie auf ** "Origin Access Identity" ** ⑬ ** Bestätigen Sie "Amazon S3 Canonical User ID" ** ⑭ Warten Sie, bis die Distribution erstellt wurde

1-3 Legen Sie die Zugriffsberechtigung für den S3-Bucket fest

① Wählen Sie auf S3 der Konsole den zu veröffentlichenden S3-Bucket aus → ** Registerkarte "Zugriffsberechtigung" **

② Klicken Sie auf ** [Zugriffssteuerungsliste] ** ③ Klicken Sie auf ** [Benutzer hinzufügen] ** ④ Geben Sie die in ⑬ der CloudFront-Einstellungen bestätigte Zeichenfolge ein ⑤ Aktivieren Sie ** "Lesen" ** in ** "Objektzugriff" ** ⑥ Klicken Sie auf ** [Speichern] **

⑦ Klicken Sie auf ** [Bucket-Richtlinie] ** und überprüfen Sie, ob die Richtlinie festgelegt ist (wie beim Erstellen der CloudFront-Distribution angegeben).

2. Implementieren Sie Code, der ein signiertes Cookie in Ihrer Anwendung setzt

Dieses Mal wurde es in der Spring Boot-Umgebung für Experimente in der lokalen Entwicklungsumgebung implementiert. Im Folgenden wird nur die Controller-Klasse ** für ** "/ set-cookie" beschrieben.

Erstellen Sie einen ** "files" ** Ordner unter ** "src / main / resources" ** und erstellen Sie einen ** "private-" Ordner in der privaten Schlüsseldatei, die zuvor in das .der-Format konvertiert wurde. Speichern Sie es als "key.der" **. Dieses Mal wurde die Datei gemäß der Umgebung von Spring Boot an diesem Speicherort gespeichert. Daher ist es etwas mühsam, den Inhalt der privaten Schlüsseldatei abzurufen, die Datei jedoch in WEB-INF in der normalen Servlet-Umgebung zu speichern. Wenn Sie es behalten, sollten Sie es einfacher herausnehmen können.

Darüber hinaus empfiehlt Amazon, das Schlüsselpaar (privater Schlüssel und öffentlicher Schlüssel) alle 90 Tage zu aktualisieren. Wenn die Aktualisierung in einem so kurzen Zyklus erfolgt, werden die Schlüsselpaar-ID und die private Schlüsseldatei fest codiert. Es ist besser, es in einem Formular aufzubewahren, das separat von der Anwendung aktualisiert werden kann, als es fest im Anwendungspaket zu haben.

`SetCookieController.java`


package site.hmatsu47.springboot;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.bind.annotation.RequestMapping;

import com.amazonaws.services.cloudfront.CloudFrontCookieSigner;
import com.amazonaws.services.cloudfront.CloudFrontCookieSigner.CookiesForCustomPolicy;
import com.amazonaws.util.DateUtils;

import java.io.File;
import java.nio.file.Files;
import java.security.KeyFactory;
import java.security.interfaces.RSAPrivateKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.util.Date;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.stereotype.Controller;

@Controller
public class SetCookieController {

	@Autowired
    ResourceLoader resourceLoader;
	
	@RequestMapping("/set-cookie")
	public void setCookie(HttpServletResponse res) throws Exception{
		String url = "https://www.hmatsu47.site/";		// URL
		String filepath = "files/private-key.der";		//Privat Schlüssel
		Resource resource = resourceLoader.getResource("classpath:" + filepath);
		File file = resource.getFile();
		byte[] privateKeyByteArray = Files.readAllBytes(file.toPath());
		PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyByteArray);
		KeyFactory kf = KeyFactory.getInstance("RSA");
		RSAPrivateKey privateKey = (RSAPrivateKey) kf.generatePrivate(keySpec);
		String resourcePath = "*";						//Zugriffsbereich
		String keyPairId = "[Schlüsselpaar-ID]";					//Schlüsselpaar-ID
		Date activeFrom = null;							//Gültigkeitsdauer: Start (null = sofort)
		Date expiresOn = DateUtils.parseISO8601Date("2020-12-31T23:59:59.999Z"); //Gültigkeitsdauer: Ende (in UTC)
		String ipRange = "0.0.0.0/0";					//Zugriff auf den IP-Adressbereich der Quelle
		//Generieren von Schlüsseln / Werten für Cookies
		CookiesForCustomPolicy cookies = CloudFrontCookieSigner.getCookiesForCustomPolicy(
				url + resourcePath, privateKey, keyPairId, expiresOn, activeFrom, ipRange);
		//Cookie-Einstellungen
		Cookie cookiePolicy = new Cookie(
				cookies.getPolicy().getKey(), cookies.getPolicy().getValue());
		cookiePolicy.setDomain("hmatsu47.site");
		cookiePolicy.setHttpOnly(true);
		cookiePolicy.setSecure(true);
		res.addCookie(cookiePolicy);

		Cookie cookieSignature = new Cookie(
				cookies.getSignature().getKey(), cookies.getSignature().getValue());
		cookieSignature.setDomain("hmatsu47.site");
		cookieSignature.setHttpOnly(true);
		cookieSignature.setSecure(true);
		res.addCookie(cookieSignature);

		Cookie cookieKeyPairId = new Cookie(
				cookies.getKeyPairId().getKey(), cookies.getKeyPairId().getValue());
		cookieKeyPairId.setDomain("hmatsu47.site");
		cookieKeyPairId.setHttpOnly(true);
		cookieKeyPairId.setSecure(true);
		res.addCookie(cookieKeyPairId);
		//Übergang durch Umleitung
		res.sendRedirect(url + "index.html");
	}
}

3. Ausführen

Speichern Sie im zu veröffentlichenden S3-Bucket index.html mit den entsprechenden Inhalten und Bildern, die durch Angabe von index.html geladen wurden.

Starten Sie zuerst den Browser und öffnen Sie ** "https://www.hmatsu47.site/index.html" **. Da Sie dann keine Zugriffsberechtigung haben, wird die Zielseite nicht geöffnet und es tritt ein Fehler auf.

Öffnen Sie als Nächstes die in 2 implementierte ** "https://hmatsu47.site/set-cookie" **. Nachdem das signierte Cookie für die Domain ** "hmatsu47.site" ** und ihren Subdomain-Bereich gesetzt wurde, wird es umgeleitet und diesmal wird die Seite korrekt geöffnet.

Wenn Sie den Browser schließen, verschwindet das signierte Cookie. Wenn Sie den Browser erneut starten, wird ** "https://www.hmatsu47.site/index.html" ** nicht geöffnet und es tritt ein Fehler auf.

Dieses Mal habe ich die Spring Boot-Anwendung in der lokalen Entwicklungsumgebung (Windows 8.1) zur schnellen Bestätigung ausgeführt (bearbeiten Sie die Hosts-Datei und zeigen Sie ** "hmatsu47.site" ** lokal. Selbstauthentifizierungsschlüssel Verwenden Sie Spring Boot, um die SSL / TLS-Kommunikation einzurichten (Qiita hat in der Vergangenheit auch mehrere Beiträge zu dieser Methode veröffentlicht). Der Überwachungsport sollte 443 anstelle von 8443 usw. sein.

`Hosts-Datei (zusätzlicher Hinweis)`


127.0.0.1	hmatsu47.site

Dies funktionierte in der diesmal vorbereiteten Entwicklungsumgebung (STS 3.8.4.RELEASE unter Windows 8.1) einwandfrei, es gibt jedoch keine Garantie dafür, dass es in anderen Umgebungen (lokale Umgebung) funktioniert. Wenn es also nicht funktioniert, handelt es sich um eine normale öffentliche Serverumgebung. Es scheint besser, es mit zu versuchen.

4. Für die Videowiedergabe verwenden

Siehe den Artikel unten. ** Videos mit eingeschränktem Zugriff (HLS-Format) unter CloudFront mit Video.js mit signierten Cookies abspielen **

Richten Sie signierte Cookies (für CloudFront) mit benutzerdefinierten Richtlinien mithilfe des AWS SDK für Java ein