Lors de la restriction de l'accès au contenu sous CloudFront

URL signée avec politique normative
URL signée avec politique personnalisée
Cookie signé avec politique prescriptive
Cookie signé avec politique personnalisée

Peut être utilisé.

[Référence: lien vers des documents dans AWS] ** Utiliser une URL signée ** ** · [Créer une URL signée en utilisant la stratégie par défaut](http://docs.aws.amazon.com/ja_jp/AmazonCloudFront/latest/DeveloperGuide/private-content-creating-signed-url-canned- policy.html) ** ** · [Créer une URL signée à l'aide d'une stratégie personnalisée](http://docs.aws.amazon.com/ja_jp/AmazonCloudFront/latest/DeveloperGuide/private-content-creating-signed-url-custom- policy.html) ** ** Utiliser des cookies signés ** ** · [Définition des cookies signés à l'aide de la stratégie par défaut](http://docs.aws.amazon.com/ja_jp/AmazonCloudFront/latest/DeveloperGuide/private-content-setting-signed-cookie-canned-policy. html) ** ** · [Définition des cookies signés à l'aide de stratégies personnalisées](http://docs.aws.amazon.com/ja_jp/AmazonCloudFront/latest/DeveloperGuide/private-content-setting-signed-cookie-custom-policy. html) **

Mais,

Si vous utilisez une URL signée, vous devez signer chaque lien de la ressource à laquelle vous accédez.
Lors de l'utilisation de la stratégie par défaut, les caractères génériques (** "?" "*" **) ne peuvent pas être utilisés pour spécifier la cible d'autorisation.

Alors

1 Donne accès à chaque fichier
Générer dynamiquement des liens vers les ressources un par un du côté application

Dans ce cas, la stratégie par défaut ou l'URL signée convient,

Le contenu soumis à des restrictions d'accès comprend un fichier HTML + .css + image + vidéo

Dans ce cas, il n'est pas réaliste de signer les liens vers les fichiers .css, image et vidéo qui sont lus avec l'URL signée, donc cette fois ** Cookie signé à l'aide d'une stratégie personnalisée * J'ai expérimenté avec *.

0. Contenu de cette expérience

L'application émet un cookie signé et le place dans le navigateur.
Le contenu soumis à des restrictions d'accès est stocké dans le compartiment S3 ** "testmatsusignedcookie" **.
L'application est publiée sur ** "https://hmatsu47.site/" ** (l'ensemble de cookies est exécuté sur ** "/ set-cookie" **).
Le contenu soumis à des restrictions d'accès sera publié sur ** "https://www.hmatsu47.site/" ** (distribution CloudFront).
Spécifiez l'attribut Domaine ** "hmatsu47.site" ** pour que le cookie signé soit émis afin que vous n'ayez pas à vous soucier de la méthode d'émission et des restrictions d'acceptation du cookie tiers.
En même temps, activez l'attribut Secure (désactivé lors de la publication avec non-SSL / TLS) et l'attribut HttpOnly (désactivé lors du traitement des cookies avec JavaScript).

1. Paramètres latéraux CloudFront + S3

Réglez selon le flux suivant.

1-1. Créez une paire de clés CloudFront dans AWS Management Console

Ci-dessous, les utilisateurs IAM ne peuvent pas le créer, utilisez donc ** un utilisateur avec des informations d'identification root ** pour effectuer l'opération.

① Sélectionnez ** «Security Credentials» ** dans le menu utilisateur en haut à droite. ② Développez ** "Paire de clés avant cloud" ** ③ Cliquez sur ** [Créer une nouvelle paire de clés] ** ④ Cliquez sur ** [Télécharger le fichier de clé privée] ** pour télécharger le fichier de clé privée ⑤ Confirmez et enregistrez l'ID de la paire de clés à l'écran avec la fenêtre contextuelle fermée.

Vous pouvez également vérifier l'ID de la paire de clés à partir de la chaîne de caractères entre ** "pk-" ** et ** ".pem" ** dans le fichier de clé privée téléchargé. ⑥ Convertissez le fichier de clé privée (format .pem) au format .der avec OpenSSL, en vous référant au lien ci-dessous. ** [Modifier le format de la clé privée CloudFront (.NET et Java uniquement)](http://docs.aws.amazon.com/ja_jp/AmazonCloudFront/latest/DeveloperGuide/private-content-trusted-signers.html# private-content-reformatting-private-key) **
Certains sites fournissent des binaires OpenSSL (.exe) pour les environnements Windows, vous pouvez donc également les utiliser.

`commande openssl`


openssl pkcs8 -topk8 -nocrypt -dans [Nom du fichier de clé privée].pem -inform PEM -out [nom du fichier de sortie].der -outform DER

1-2. Créer une distribution CloudFront

① Cliquez sur ** [Créer une distribution] ** dans Cloud Front → Distribution sur la console.

② Cliquez sur ** [Commencer] ** sur le Web

③ Définissez les éléments liés au compartiment d'origine S3 ④ Sélectionnez ** "Oui" ** dans ** "Restreindre l'accès au bucket" ** ⑤ Sélectionnez ** «Créer une nouvelle identité» ** dans ** «Identité d'accès à l'origine» ** ⑥ Sélectionnez ** "Oui,…" ** dans ** "Accorder des autorisations de lecture sur le compartiment" **

⑦ Sélectionnez ** "Oui" ** dans ** "Restreindre l'accès du spectateur" ** ⑧ Cochez ** «Self» ** dans ** «Trusted Signers» ** ⑨ Spécifiez le nom de domaine (FQDN attribué à la distribution CloudFront) dans ** «Alternate Domain Names» **

Après avoir terminé la création de la distribution, spécifiez l'alias de l'enregistrement A dans l'enregistrement correspondant de Route 53.

⑩ Définissez les éléments liés à SSL / TLS (après avoir sélectionné ** "Certificat SSL personnalisé" **, sélectionnez le certificat à utiliser ou demandez un nouveau certificat SSL SNI)

⑪ ** Cliquez sur "Créer une distribution" **

⑫ Cliquez sur ** "Origin Access Identity" ** ⑬ ** Confirmer "l'ID utilisateur Canonical Amazon S3" ** ⑭ Attendez que la distribution soit créée

1-3. Définir l'autorité d'accès du compartiment S3

① Dans S3 de la console, sélectionnez le compartiment S3 à publier → ** Onglet "Autorisation d'accès" **

② Cliquez sur ** [Liste de contrôle d'accès] ** ③ Cliquez sur ** [Ajouter un utilisateur] ** ④ Entrez la chaîne de caractères confirmée dans ⑬ des paramètres CloudFront ⑤ Cochez ** "Lire" ** dans ** "Accès aux objets" ** ⑥ Cliquez sur ** [Enregistrer] **

⑦ Cliquez sur ** [Bucket Policy] ** et vérifiez que la stratégie est définie (comme spécifié lors de la création de la distribution CloudFront).

2. Implémentez un code qui définit un cookie signé dans votre application

Cette fois, il a été implémenté dans l'environnement Spring Boot pour des expériences dans l'environnement de développement local. Ci-dessous, seule la classe Controller ** pour ** "/ set-cookie" est décrite.

Créez un dossier ** "files" ** sous ** "src / main / resources" ** et créez un dossier ** "private-" dans le fichier de clé privée qui a été préalablement converti au format .der. Enregistrez-le sous "key.der" **. Cette fois, le fichier a été enregistré à cet emplacement selon l'environnement de Spring Boot, il est donc un peu gênant de récupérer le contenu du fichier de clé privée, mais enregistrez le fichier dans WEB-INF dans l'environnement Servlet normal. Si vous le gardez, vous devriez pouvoir le retirer plus simplement.

En outre, Amazon recommande de mettre à jour la paire de clés (clé privée et clé publique) tous les 90 jours, et en cas de mise à jour dans un cycle aussi court, l'ID de la paire de clés et le fichier de clé privée sont codés en dur. Il est préférable de le conserver sous une forme pouvant être mise à jour séparément de l'application, plutôt que d'être inclus de manière fixe dans le package d'application.

`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";		//Clé privée
		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 = "*";						//Portée de l'accès
		String keyPairId = "[ID de la paire de clés]";					//ID de la paire de clés
		Date activeFrom = null;							//Période de validité: Début (nul = immédiat)
		Date expiresOn = DateUtils.parseISO8601Date("2020-12-31T23:59:59.999Z"); //Période de validité: Fin (en UTC)
		String ipRange = "0.0.0.0/0";					//Accéder à la plage d'adresses IP de la source
		//Générer des clés / valeurs pour les cookies
		CookiesForCustomPolicy cookies = CloudFrontCookieSigner.getCookiesForCustomPolicy(
				url + resourcePath, privateKey, keyPairId, expiresOn, activeFrom, ipRange);
		//paramètres des cookies
		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);
		//Transition par redirection
		res.sendRedirect(url + "index.html");
	}
}

3. Exécutez

Dans le compartiment S3 à publier, enregistrez index.html avec le contenu et les images appropriés chargés en spécifiant index.html.

Tout d'abord, démarrez le navigateur et ouvrez ** "https://www.hmatsu47.site/index.html" **. Ensuite, puisque vous n'avez pas d'autorisation d'accès, la page cible ne s'ouvrira pas et une erreur se produira.

Ensuite, ouvrez le ** "https://hmatsu47.site/set-cookie" ** implémenté dans 2. Ensuite, une fois le cookie signé défini pour le domaine ** "hmatsu47.site" ** et sa plage de sous-domaines, il sera redirigé et cette fois la page s'ouvrira correctement.

Lorsque vous fermez le navigateur, le cookie signé disparaît, donc lorsque vous redémarrez le navigateur, ** "https://www.hmatsu47.site/index.html" ** ne s'ouvre pas et une erreur se produit.

Cette fois, j'ai exécuté l'application Spring Boot dans l'environnement de développement local (Windows 8.1) pour une confirmation rapide (éditez le fichier hosts et pointez ** "hmatsu47.site" ** localement. Clé d'auto-authentification Utilisez Spring Boot pour configurer la communication SSL / TLS (Qiita a également publié plusieurs articles dans le passé sur la méthode). Définissez le port d'écoute sur 443 au lieu de 8443 etc.).

`fichier hosts (note supplémentaire)`


127.0.0.1	hmatsu47.site

Cela a bien fonctionné dans l'environnement de développement (STS 3.8.4.RELEASE sur Windows 8.1) préparé cette fois, mais il n'y a aucune garantie que cela fonctionnera dans d'autres environnements (environnement local), donc si cela ne fonctionne pas, il s'agit d'un environnement de serveur public normal. Il semble préférable de l'essayer avec.

4. Utiliser pour la lecture vidéo

Voir l'article ci-dessous. ** Lire des vidéos à accès restreint (format HLS) sous CloudFront avec Video.js à l'aide de cookies signés **

Configurer des cookies signés (pour CloudFront) avec des stratégies personnalisées à l'aide du kit AWS SDK pour Java