One place for hosting & domains

      Comment mettre en place et configurer une autorité de certification (AC) sur Ubuntu 20.04


      Introduction

      Une autorité de certification (AC) est une entité chargée d’émettre des certificats numériques pour vérifier les identités sur l’internet. Bien que les AC publiques soient un choix populaire pour vérifier l’identité des sites web et autres services qui sont fournis au grand public, les AC privées sont généralement utilisées pour les groupes fermés et les services privés.

      La création d’une autorité de certification privée vous permettra de configurer, de tester et d’exécuter des programmes qui nécessitent des connexions cryptées entre un client et un serveur. Avec une AC privée, vous pouvez émettre des certificats pour les utilisateurs, les serveurs ou les programmes et services individuels au sein de votre infrastructure.

      Quelques exemples de programmes sur Linux qui utilisent leur propre AC privée sont OpenVPN et Puppet. Vous pouvez également configurer votre serveur web pour utiliser des certificats émis par une AC privée afin de faire correspondre les environnements de développement et de simulation aux serveurs de production qui utilisent TLS pour crypter les connexions.

      Dans ce guide, nous allons apprendre comment mettre en place une autorité de certification privée sur un serveur Ubuntu 20.04 et comment générer et signer un certificat de test en utilisant votre nouvelle AC. Vous apprendrez également comment importer le certificat public du serveur de l’AC dans le magasin de certificats de votre système d’exploitation afin de pouvoir vérifier la chaîne de confiance entre l’AC et les serveurs ou utilisateurs distants. Enfin, vous apprendrez comment révoquer des certificats et distribuer une liste de révocation de certificats pour vous assurer que seuls les utilisateurs et les systèmes autorisés peuvent utiliser les services qui reposent sur votre AC.

      Conditions préalables

      Pour suivre ce tutoriel, vous devrez avoir accès à un serveur Ubuntu 20.04 pour héberger votre serveur AC. Vous devrez configurer un utilisateur non root avec privilèges sudo avant de commencer ce guide. Vous pouvez suivre notre guide de configuration initiale de serveur Ubuntu 20.04 pour configurer un utilisateur avec les permissions appropriées. Le tutoriel joint permettra également de mettre en place un pare-feu, supposé rester en place tout au long de ce guide.

      Ce serveur sera appelé Serveur AC dans ce tutoriel.

      Assurez-vous que le serveur AC est un système autonome. Il ne sera utilisé que pour importer, signer et révoquer les demandes de certificats. Il ne doit pas gérer d’autres services et, dans l’idéal, il sera hors ligne ou complètement fermé lorsque vous ne travaillerez pas activement avec votre AC.

      Remarque : la dernière section de ce tutoriel est facultative si vous souhaitez en savoir plus sur la signature et la révocation des certificats. Si vous choisissez de suivre ces étapes de pratique, vous aurez besoin d’un second serveur Ubuntu 20.04 ou vous pouvez également utiliser votre propre ordinateur Linux local fonctionnant sous Ubuntu ou Debian, ou des distributions dérivées de l’un ou l’autre.

      Étape 1 — Installation d’Easy-RSA

      La première tâche de ce tutoriel consiste à installer l’ensemble de scripts easy-rsa sur votre serveur d’AC. easy-rsa est un outil de gestion d’autorité de certification que vous utiliserez pour générer une clé privée et un certificat racine public, que vous utiliserez ensuite pour signer les demandes des clients et des serveurs qui s’appuieront sur votre AC.

      Connectez-vous à votre serveur AC en tant qu’utilisateur sudo non root que vous avez créé lors des étapes de configuration initiales et exécutez ce qui suit :

      • sudo apt update
      • sudo apt install easy-rsa

      Vous serez invité à télécharger le package et à l’installer. Appuyez sur y pour confirmer que vous souhaitez installer le package.

      À ce stade, vous disposez de tout ce dont vous avez besoin, installé et prêt pour utiliser Easy-RSA. Dans l’étape suivante, vous allez créer une infrastructure à clés publiques, puis vous commencerez à construire votre autorité de certification.

      Étape 2 — Préparation d’un répertoire d’infrastructures à clés publiques

      Maintenant que vous avez installé easy-rsa​​​, il est temps de créer un squelette de l’infrastructure de clés publiques (ICP) sur le serveur AC. Assurez-vous que vous êtes encore connecté en tant qu’utilisateur non root et créez un répertoire easy-rsa Assurez-vous que vous n’utilisez pas sudo pour exécuter l’une des commandes suivantes, puisque votre utilisateur normal doit gérer et interagir avec l’AC sans privilèges élevés.

      Cela créera un nouveau répertoire appelé easy-rsa dans votre dossier de base. Nous utiliserons ce répertoire pour créer des liens symboliques pointant vers les fichiers de packages easy-rsa que nous avons installés à l’étape précédente. Ces fichiers sont situés dans le dossier /usr/share/easy-rsa sur le serveur AC.

      Créez les liens symboliques (symlinks) avec la commande ln :

      • ln -s /usr/share/easy-rsa/* ~/easy-rsa/

      Remarque : alors que d’autres guides peuvent vous demander de copier les fichiers du package easy-rsa dans votre répertoire ICP, ce tutoriel adopte une approche par lien symbolique. Par conséquent, toute mise à jour du paquet easy-rsa sera automatiquement répercutée dans les scripts de votre ICP.

      Pour restreindre l’accès à votre nouveau répertoire ICP, assurez-vous que seul le propriétaire peut y accéder en utilisant la commande chmod :

      • chmod 700 /home/sammy/easy-rsa

      Enfin, initialisez l’ICP dans le répertoire easy-rsa :

      • cd ~/easy-rsa
      • ./easyrsa init-pki

      Output

      init-pki complete; you may now create a CA or requests. Your newly created PKI dir is: /home/sammy/easy-rsa/pki

      Après avoir terminé cette section, vous disposez d’un répertoire qui contient tous les fichiers nécessaires pour créer une autorité de certification. Dans la section suivante, vous allez créer la clé privée et le certificat public pour votre AC.

      Étape 3 — Création d’une autorité de certification

      Avant de pouvoir créer la clé et le certificat privés de votre AC, vous devez créer et alimenter un fichier appelé vars avec quelques valeurs par défaut. Tout d’abord, vous allez cd dans le répertoire easy-rsa, puis vous allez créer et modifier le fichier vars avec nano ou votre éditeur de texte préféré :

      Une fois le fichier ouvert, collez les lignes suivantes et modifiez chaque valeur mise en évidence pour refléter les informations de votre propre organisation. L’important ici est de veiller à ne laisser aucune des valeurs en blanc :

      ~/easy-rsa/vars

      set_var EASYRSA_REQ_COUNTRY "US" set_var EASYRSA_REQ_PROVINCE "NewYork" set_var EASYRSA_REQ_CITY "New York City" set_var EASYRSA_REQ_ORG "DigitalOcean" set_var EASYRSA_REQ_EMAIL "admin@example.com" set_var EASYRSA_REQ_OU "Community" set_var EASYRSA_ALGO "ec" set_var EASYRSA_DIGEST "sha512"

      Lorsque vous avez terminé, enregistrez et fermez le fichier. Si vous utilisez nano, vous pouvez le faire en appuyant sur CTRL+X, puis Y et ENTER pour confirmer. Vous êtes maintenant prêt à construire votre AC.

      Pour créer la paire de clés root public et privé pour votre autorité de certification, exécutez à nouveau la commande ./easy-rsa, cette fois-ci avec l’option build-ca :

      Dans la sortie, vous verrez quelques lignes sur la version OpenSSL et vous serez invité à entrer une phrase de passe pour votre paire de clés. Assurez-vous de choisir une phrase de passe solide, et notez-le dans un endroit sûr. Vous devrez saisir la phrase de passe chaque fois vous devrez interagir avec votre AC, par exemple pour signer ou révoquer un certificat.

      Il vous sera également demandé de confirmer le Nom commun (CN) de votre AC. Le nom commun est le nom utilisé pour désigner cette machine dans le contexte de l’autorité de certification. Vous pouvez saisir n’importe quelle chaîne de caractères pour le nom commun de l’AC mais, par souci de simplicité, appuyez sur ENTER (ENTRÉE) pour accepter le nom par défaut.

      Output

      . . . Enter New CA Key Passphrase: Re-Enter New CA Key Passphrase: . . . Common Name (eg: your user, host, or server name) [Easy-RSA CA]: CA creation complete and you may now import and sign cert requests. Your new CA certificate file for publishing is at: /home/sammy/easy-rsa/pki/ca.crt

      Remarque : Si vous ne voulez pas qu’un mot de passe vous soit demandé à chaque fois que vous interagissez avec votre AC, vous pouvez exécuter la commande build-ca avec l’option nopass, comme ceci :

      • ./easyrsa build-ca nopass

      Vous disposez maintenant de deux fichiers importants – ~/easy-rsa/pki/ca.crt et ~/easy-rsa/pki/private/ca.key – qui constituent les composants publics et privés d’une autorité de certification.

      • ca.crt est le fichier de certificats public de l’AC. Les utilisateurs, les serveurs et les clients utiliseront ce certificat pour vérifier qu’ils font partie du même réseau de confiance. Chaque utilisateur et serveur qui utilise votre AC devront avoir une copie de ce fichier. Toutes les parties s’appuieront sur le certificat public pour s’assurer qu’une personne ne se fait pas passer pour un système et n’effectue pas une attaque de type Man-in-the-middle.

      • ca.key est la clé privée que l’AC utilise pour signer les clés et les certificats des serveurs et des clients. Si un intrus accède à votre AC et, à son tour, à votre fichier ca.key, vous devrez détruire votre AC. C’est pourquoi votre fichier ca.key ne doit se trouver que sur votre machine AC et votre machine AC doit idéalement être maintenue hors ligne lorsqu’elle ne signe pas de demandes de certificat, par mesure de sécurité supplémentaire.

      Avec cela, votre AC est en place et elle est prête à être utilisée pour signer des demandes de certificats et pour révoquer des certificats.

      Étape 4 — Distribuer le certificat public de votre autorité de certification

      Votre AC est maintenant configurée et prête à agir comme une racine de confiance pour tous les systèmes que vous voulez configurer en vue de son utilisation. Vous pouvez ajouter le certificat de l’AC à vos serveurs OpenVPN, serveurs web, serveurs de messagerie, etc. Tout utilisateur ou serveur qui doit vérifier l’identité d’un autre utilisateur ou serveur de votre réseau devrait avoir une copie du fichier ca.crt importé dans le magasin de certificats de son système d’exploitation.

      Pour importer le certificat public de l’AC dans un deuxième système Linux comme un autre serveur ou un ordinateur local, obtenez d’abord une copie du fichier ca.crt de votre serveur AC. Vous pouvez utiliser la commande cat pour le sortir dans un terminal, puis le copier et le coller dans un fichier sur le deuxième ordinateur qui importe le certificat. Vous pouvez également utiliser des outils comme scp, rsync pour transférer le fichier entre les systèmes. Cependant, nous utiliserons un copier-coller avec nano dans cette étape car cela fonctionne sur tous les systèmes.

      En tant qu’utilisateur non root sur le serveur AC, exécutez la commande suivante :

      • cat ~/easy-rsa/pki/ca.crt

      Il y aura une sortie dans votre terminal qui ressemblera à ce qui suit :

      Output

      -----BEGIN CERTIFICATE----- MIIDSzCCAjOgAwIBAgIUcR9Crsv3FBEujrPZnZnU4nSb5TMwDQYJKoZIhvcNAQEL BQAwFjEUMBIGA1UEAwwLRWFzeS1SU0EgQ0EwHhcNMjAwMzE4MDMxNjI2WhcNMzAw . . . . . . -----END CERTIFICATE-----

      Copiez tout, y compris les lignes -----BEGIN CERTIFICATE-----​​​ et –-----END CERTIFICATE----- et les tirets.

      Sur votre deuxième système Linux, utilisez nano ou votre éditeur de texte préféré pour ouvrir un fichier appelé /tmp/ca.crt :

      Collez le contenu que vous venez de copier du serveur AC dans l’éditeur. Lorsque vous avez terminé, enregistrez et fermez le fichier. Si vous utilisez nano, vous pouvez le faire en appuyant sur CTRL+X, puis Y et ENTER pour confirmer.

      Maintenant que vous disposez d’une copie du fichier ca.crt sur votre deuxième système Linux,il est temps d’importer le certificat dans le magasin de certificats de son système d’exploitation.

      Sur les systèmes basés sur Ubuntu et Debian, exécutez les commandes suivantes en tant qu’utilisateur non root pour importer le certificat :

      Ubuntu and Debian derived distributions

      • sudo cp /tmp/ca.crt /usr/local/share/ca-certificates/
      • sudo update-ca-certificates

      Pour importer le certificat du serveur AC sur un système basé sur CentOS, Fedora ou RedHat, copiez et collez le contenu du fichier sur le système tout comme dans l’exemple précédent dans un fichier appelé /tmp/ca.crt. Ensuite, vous copierez le certificat dans /etc/pki/ca-trust/source/anchors/, puis vous exécuterez la commande update-ca-trust.

      CentOS, Fedora, RedHat distributions

      • sudo cp /tmp/ca.crt /etc/pki/ca-trust/source/anchors/
      • sudo update-ca-trust

      Votre deuxième système Linux fera maintenant confiance à tout certificat qui a été signé par le serveur AC.

      Remarque : si vous utilisez votre AC avec des serveurs web et si vous utilisez le navigateur Firefox, vous devrez importer directement le certificat ca.crt public dans Firefox. Firefox n’utilise pas le magasin de certificats du système d’exploitation local. Pour plus de détails sur la façon d’ajouter le certificat de votre AC à Firefox, veuillez consulter cet article de Mozilla sur la configuration des autorités de certification (AC) dans Firefox.

      Si vous utilisez votre AC pour intégrer un environnement Windows ou des ordinateurs de bureau, veuillez consulter la documentation sur la façon d’utiliser certutil.exe pour installer un certificat d’AC.

      Si vous utilisez ce tutoriel comme condition préalable à un autre tutoriel, ou si vous savez comment signer et révoquer des certificats, vous pouvez vous arrêter ici. Si vous souhaitez en savoir plus sur la façon de signer et de révoquer des certificats, la section facultative suivante vous expliquera chaque processus en détail.

      (Facultatif) — Création de demandes de signature de certificats et révocation des certificats

      Les sections suivantes du tutoriel sont facultatives. Si vous avez effectué toutes les étapes précédentes, vous disposez d’une autorité de certification entièrement configurée et opérationnelle que vous pouvez utiliser comme condition préalable pour d’autres tutoriels. Vous pouvez importer le fichier ca.crt de votre AC et vérifier dans votre réseau les certificats qui ont été signés par votre AC.

      Si vous souhaitez vous entraîner et en savoir plus sur la manière de signer des demandes de certificat et sur la manière de révoquer des certificats, ces sections facultatives vous expliqueront comment fonctionnent les deux processus.

      (Facultatif) — Création et signature d’une demande de certificat de pratique

      Maintenant que vous avez une AC prête à l’emploi, vous pouvez vous entraîner à générer une clé privée et une demande de certificat pour vous familiariser avec le processus de signature et de distribution.

      Une demande de signature de certificat (CSR) se compose de trois parties : une clé publique, des informations d’identification sur le système requérant, et une signature de la requête elle-même, qui est créée en utilisant la clé privée de la partie requérante. La clé privée sera gardée secrète et sera utilisée pour chiffrer les informations que toute personne possédant le certificat public signé pourra ensuite déchiffrer.

      Les étapes suivantes seront exécutées sur votre second système Ubuntu ou Debian ou une distribution dérivée de l’un de ces systèmes. Il peut s’agir d’un autre serveur distant, ou d’une machine Linux locale comme un ordinateur portable ou un ordinateur de bureau. Comme easy-rsa n’est pas disponible par défaut sur tous les systèmes, nous utiliserons l’outil openssl pour créer une clé privée et un certificat de pratique.

      openssl est généralement installé par défaut sur la plupart des distributions Linux, mais juste pour en être certain, exécutez ce qui suit sur votre système

      • sudo apt update
      • sudo apt install openssl

      Lorsque vous êtes invité à installer openssl, entrez y pour poursuivre les étapes d’installation.  Maintenant, vous êtes prêt à créer une pratique CSR avec openssl.

      La première étape que vous devez suivre pour créer une CSR est la génération d’une clé privée. Pour créer une clé privée en utilisant openssl, créez un répertoire “practice-csr” et générez ensuite une clé à l’intérieur de celui-ci. Nous allons faire cette requête pour un serveur fictif appelé sammy-server, par opposition à la création d’un certificat qui est utilisé pour identifier un utilisateur ou une autre AC.

      • mkdir ~/practice-csr
      • cd ~/practice-csr
      • openssl genrsa -out sammy-server.key

      Output

      Generating RSA private key, 2048 bit long modulus (2 primes) . . . . . . e is 65537 (0x010001)

      Maintenant que vous avez une clé privée, vous pouvez créer une CSR correspondante, à nouveau en utilisant l’utilitaire openssl. Vous serez invité à remplir un certain nombre de champs comme Pays, État et Ville. Vous pouvez saisir un . si vous souhaitez laisser un champ vide, mais sachez que s’il s’agit d’une véritable CSR, il est préférable d’utiliser les valeurs correctes de votre localisation et votre organisation :

      • openssl req -new -key sammy-server.key -out sammy-server.req

      Output

      . . . ----- Country Name (2 letter code) [XX]:US State or Province Name (full name) []:New York Locality Name (eg, city) [Default City]:New York City Organization Name (eg, company) [Default Company Ltd]:DigitalOcean Organizational Unit Name (eg, section) []:Community Common Name (eg, your name or your server's hostname) []:sammy-server Email Address []: Please enter the following 'extra' attributes to be sent with your certificate request A challenge password []: An optional company name []:

      Si vous souhaitez ajouter automatiquement ces valeurs dans le cadre de l’invocation openssl plutôt que via l’invite interactive, vous pouvez passer l’argument -subj à OpenSSL. Veillez à modifier les valeurs mises en évidence pour qu’elles correspondent à votre lieu d’exercice, à votre organisation et au nom de votre serveur :

      • openssl req -new -key sammy-server.key -out server.req -subj
      • /C=US/ST=New York/L=New York City/O=DigitalOcean/OU=Community/CN=sammy-server

      Pour vérifier le contenu d’une CSR, vous pouvez lire dans un fichier de requête avec openssl et examiner les champs à l’intérieur

      • openssl req -in sammy-server.req -noout -subject

      Output

      subject=C = US, ST = New York, L = New York City, O = DigitalOcean, OU = Community, CN = sammy-server

      Une fois que vous êtes satisfait de l’objet de votre demande de certificat de pratique, copiez le fichier sammy-server.req sur votre serveur AC en utilisant scp

      • scp sammy-server.req sammy@your_ca_server_ip:/tmp/sammy-server.req

      Au cours de cette étape, vous avez généré une demande de signature de certificat pour un serveur fictif appelé sammy-server. Dans un scénario réel, la demande peut provenir d’un serveur web de développement ou de simulation qui a besoin d’un certificat TLS pour des tests, ou d’un serveur OpenVPN qui demande un certificat pour que les utilisateurs puissent se connecter à un VPN. Au cours de l’étape suivante, nous allons passer à la signature de la demande de signature de certificat en utilisant la clé privée du serveur AC.

      (Facultatif) – Signature d’une CSR

      Dans l’étape précédente, vous avez créé une demande de certificat de pratique et une clé pour un serveur fictif. Vous l’avez copiée dans le répertoire /tmp de votre serveur AC, en émulant le processus que vous utiliseriez si vous aviez de vrais clients ou serveurs vous envoyant des demandes de CSR à signer.

      Poursuivant le scénario fictif, le serveur AC doit maintenant importer le certificat de pratique et le signer. Une fois qu’une demande de certificat est validée par l’AC et relayée à un serveur, les clients qui font confiance à l’autorité de certification pourront également faire confiance au certificat nouvellement émis.

      Comme nous opérerons au sein de l’ICP de l’AC où l’utilitaire easy-rsa est disponible, les étapes de signature utiliseront l’utilitaire easy-rsa pour faciliter les choses, au lieu d’utiliser directement openssl comme nous l’avons fait dans l’exemple précédent.

      La première étape pour signer la CSR fictive est d’importer la demande de certificat en utilisant le script easy-rsa

      • cd ~/easy-rsa
      • ./easyrsa import-req /tmp/sammy-server.req sammy-server

      Output

      . . . The request has been successfully imported with a short name of: sammy-server You may now use this name to perform signing operations on this request.

      Maintenant, vous pouvez signer la demande en exécutant le script easyrsa avec l’option sign-req suivi du type de requête et du nom commun qui est inclus dans la CSR. Le type de requête peut soit être client, server, ou ca. Comme nous nous entraînons avec un certificat pour un serveur fictif, assurez-vous d’utiliser le type de requête du serveur :

      • ./easyrsa sign-req server sammy-server

      Dans la sortie, il vous sera demandé de vérifier que la requête provient d’une source fiable. Tapez yes puis appuyez sur ENTER pour confirmer :

      Output

      You are about to sign the following certificate. Please check over the details shown below for accuracy. Note that this request has not been cryptographically verified. Please be sure it came from a trusted source or that you have verified the request checksum with the sender. Request subject, to be signed as a server certificate for 3650 days: subject= commonName = sammy-server Type the word 'yes' to continue, or any other input to abort. Confirm request details: yes . . . Certificate created at: /home/sammy/easy-rsa/pki/issued/sammy-server.crt

      Si vous avez crypté votre clé AC, on vous demandera votre mot de passe à ce stade.

      Une fois ces étapes terminées, vous avez signé la CSR sammy-server.req en utilisant la clé privée du serveur AC dans /home/sammy/easy-rsa/pki/private/ca.key. Le fichier sammy-server.crt qui en résulte contient la clé de chiffrement publique du serveur de pratique, ainsi qu’une nouvelle signature du serveur AC. Le but de la signature est de dire à toute personne qui fait confiance à l’AC qu’elle peut également faire confiance au certificat du sammy-server.

      Si cette requête concerne un vrai serveur comme un serveur web ou un serveur VPN, la dernière étape sur le serveur AC serait de distribuer les nouveaux fichiers sammy-server.crt et ca.crt du serveur AC au serveur distant qui a fait la requête CSR :

      • scp pki/issued/sammy-server.crt sammy@your_server_ip:/tmp
      • scp pki/ca.crt sammy@your_server_ip:/tmp

      À ce stade, vous pourrez utiliser le certificat délivré avec un serveur web, un VPN, un outil de gestion de la configuration, un système de base de données ou à des fins d’authentification des clients.

      (Facultatif) — Révocation d’un certificat

      Il peut arriver que vous deviez révoquer un certificat pour empêcher un utilisateur ou un serveur de l’utiliser. Il se peut que l’ordinateur portable de quelqu’un ait été volé, qu’un serveur web ait été compromis, ou qu’un employé ou un contractant ait quitté votre organisation.

      Pour révoquer un certificat, la procédure générale suit les étapes suivantes :

      1. Révoquez le certificat avec la commande ./easyrsa revoke client_name
      2. Générez une nouvelle LRC avec la commande ./easyrsa gen-crl
      3. Transférez le fichier crl.pem mis à jour vers le ou les serveurs qui dépendent de votre AC, et sur ces systèmes, copiez le fichier dans le ou les répertoires requis pour les programmes qui s’y réfèrent.
      4. Redémarrez tous les services qui utilisent votre AC et le fichier LRC.

      Vous pouvez utiliser ce processus pour révoquer à tout moment les certificats que vous avez précédemment émis. Nous allons passer en détail chaque étape dans les sections suivantes, en commençant par la commande revoke

      Révoquer un certificat

      Pour révoquer un certificat, naviguez vers le répertoire easy-rsa sur votre serveur AC :

      Ensuite, lancez le script easyrsa avec l’option revoke, suivi du nom du client que vous souhaitez révoquer : En suivant l’exemple de pratique ci-dessus, le nom commun du certificat est sammy-server :

      • ./easyrsa revoke sammy-server

      Il vous sera demandé de confirmer la révocation en entrant yes :

      Output

      Please confirm you wish to revoke the certificate with the following subject: subject= commonName = sammy-server Type the word 'yes' to continue, or any other input to abort. Continue with revocation: yes . . . Revoking Certificate 8348B3F146A765581946040D5C4D590A . . .

      Notez la valeur mise en évidence sur la ligne Revoking Certificate Cette valeur est le numéro de série unique du certificat qui est en cours de révocation. Si vous voulez examiner la liste de révocation à la dernière étape de cette section pour vérifier que le certificat y figure, vous aurez besoin de cette valeur.

      Après avoir confirmé l’action, l’AC va révoquer le certificat. Cependant, les systèmes distants qui dépendent de l’AC n’ont aucun moyen de vérifier si des certificats ont été révoqués. Les utilisateurs et les serveurs pourront toujours utiliser le certificat jusqu’à ce que la liste des certificats révoqués (LCR) de l’AC soit distribuée à tous les systèmes qui dépendent de l’AC.

      Dans l’étape suivante, vous allez générer une LCR ou mettre à jour un fichier crl.pem existant.

      Générer une liste de révocation de certificats

      Maintenant que vous avez révoqué un certificat, il est important de mettre à jour la liste des certificats révoqués sur votre serveur AC. Une fois que vous aurez mis à jour la liste des révocations, vous serez en mesure de savoir quels utilisateurs et quels systèmes ont des certificats valides dans votre AC.

      Pour générer une LRC, exécutez la commande easy-rsa avec l’option gen-crl tout en restant dans le répertoire ~/easy-rsa :

      Si vous avez utilisé une phrase de passe lors de la création de votre fichier ca.key, vous serez invité à l’entrer. La commande gen-crl générera un fichier appelé crl.pem, contenant la liste actualisée des certificats révoqués pour cette AC.

      Ensuite, vous devrez transférer le fichier crl.pem mis à jour à tous les serveurs et clients qui dépendent de cette AC chaque fois que vous exécuterez la commande gen-crl. Sinon, les clients et les systèmes pourront toujours accéder aux services et aux systèmes qui utilisent votre AC, puisque ces services doivent connaître le statut de révocation du certificat.

      Transférer une liste de révocation de certificats

      Maintenant que vous avez généré une LCR sur le serveur de votre AC, vous devez la transférer vers les systèmes distants qui dépendent de votre AC. Pour transférer ce fichier à vos serveurs, vous pouvez utiliser la commande scp.

      Remarque : ce tutoriel explique comment générer et distribuer manuellement une LCR. Bien qu’il existe des méthodes plus solides et automatisées pour distribuer et vérifier les listes de révocation, comme l’agrafage OCSP, la configuration de ces méthodes dépasse le cadre de cet article.

      Assurez-vous que vous êtes connecté à votre serveur AC en tant qu’utilisateur non racine et exécutez les opérations suivantes, en substituant l’IP ou le nom DNS de votre propre serveur à la place de your_server_ip :

      • scp ~/easy-rsa/pki/crl.pem sammy@your_server_ip:/tmp

      Maintenant que le fichier est sur le système distant, la dernière étape consiste à mettre à jour tous les services avec la nouvelle copie de la liste de révocation.

      Mise à jour des services qui prennent en charge une LCR

      L’énumération des étapes à suivre pour mettre à jour les services qui utilisent le fichier crl.pem dépasse la portée de ce tutoriel. En général, vous devrez copier le fichier crl.pem à l’emplacement prévu par le service, puis le redémarrer à l’aide de systemctl.

      Une fois que vous aurez mis à jour vos services avec le nouveau fichier crl.pem, vos services pourront rejeter les connexions des clients ou des serveurs qui utilisent un certificat révoqué.

      Examen et vérification du contenu d’une LCR

      Si vous souhaitez examiner un fichier CRL, par exemple pour confirmer une liste de certificats révoqués, utilisez la commande openssl suivante à partir de votre répertoire easy-rsa sur votre serveur AC :

      • cd ~/easy-rsa
      • openssl crl -in pki/crl.pem -noout -text

      Vous pouvez également exécuter cette commande sur tout serveur ou système qui dispose de l’outil openssl installé avec une copie du fichier crl.pem. Par exemple, si vous avez transféré le fichier crl.pem sur votre second système et que vous souhaitez vérifier que le certificat de sammy-server est révoqué, vous pouvez utiliser une commande openssl comme celle qui suit, en introduisant le numéro de série que vous avez noté précédemment lorsque vous avez révoqué le certificat à la place de numéro mis en évidence ici :

      • openssl crl -in /tmp/crl.pem -noout -text |grep -A 1 8348B3F146A765581946040D5C4D590A

      Output

      Serial Number: 8348B3F146A765581946040D5C4D590A Revocation Date: Apr 1 20:48:02 2020 GMT

      Remarquez comment la commande grep est utilisée pour vérifier le numéro de série unique que vous avez noté dans l’étape de révocation. Vous pouvez maintenant vérifier le contenu de votre liste de révocation de certificat sur tout système qui s’appuie sur elle pour restreindre l’accès aux utilisateurs et aux services.

      Conclusion

      Dans ce tutoriel, vous avez créé une autorité de certification privée en utilisant le package Easy-RSA sur un serveur Ubuntu 20.04 autonome. Vous avez appris comment fonctionne le modèle de confiance entre les parties qui s’appuient sur l’autorité de certification. Vous avez également créé et signé une demande de signature de certificat (CSR) pour un serveur de pratique, puis appris à révoquer un certificat. Enfin, vous avez appris comment générer et distribuer une liste de révocation de certificats (LRC) pour tout système qui dépend de votre AC afin de s’assurer que les utilisateurs ou les serveurs qui ne devraient pas accéder aux services en soient empêchés.

      Vous pouvez maintenant délivrer des certificats pour les utilisateurs et les utiliser avec des services comme OpenVPN. Vous pouvez également utiliser votre AC pour configurer des serveurs web de développement et de simulation avec des certificats, afin de sécuriser vos environnements hors production. L’utilisation d’une AC avec des certificats TLS pendant le développement peut contribuer à garantir que votre code et vos environnements correspondent autant que possible à votre environnement de production.

      Si vous souhaitez en savoir plus sur l’utilisation d’OpenSSL, consultez notre page sur les principes essentiels d’OpenSSL : Travailler avec les certificats SSL, les clés privées et les CSR contient de nombreuses informations supplémentaires pour vous aider à vous familiariser avec les principes fondamentaux d’OpenSSL.



      Source link

      Comment créer une application web en utilisant Flask en Python 3


      L’auteur a choisi le Free and Open Source Fund pour recevoir un don dans le cadre du programme Write for Donations.

      Introduction

      Flask est un petit framework web Python léger, qui fournit des outils et des fonctionnalités utiles qui facilitent la création d’applications web en Python.  Il offre aux développeurs une certaine flexibilité et constitue un cadre plus accessible pour les nouveaux développeurs puisque vous pouvez construire rapidement une application web en utilisant un seul fichier Python. Flask est également extensible et ne force pas une structure de répertoire particulière ou ne nécessite pas de code standard compliqué avant de commencer.

      Dans le cadre de ce tutoriel, vous utiliserez la boîte à outils Bootstrap pour styliser votre application afin qu’elle soit plus attrayante visuellement. Bootstrap vous aidera à incorporer des pages web réactives dans votre application web afin qu’elle fonctionne également bien sur les navigateurs mobiles sans avoir à écrire votre propre code HTML, CSS et JavaScript pour atteindre ces objectifs. La boîte à outils vous permettra de vous concentrer sur l’apprentissage du fonctionnement de Flask.

      Flask utilise le moteur de modèle Jinja pour construire dynamiquement des pages HTML en utilisant des concepts Python familiers tels que les variables, les boucles, les listes, etc. Vous utiliserez ces modèles dans le cadre de ce projet.

      Dans ce tutoriel, vous allez construire un petit blog web en utilisant Flask et SQLite en Python 3. Les utilisateurs de l’application peuvent consulter tous les articles de votre base de données et cliquer sur le titre d’un article pour en voir le contenu, avec la possibilité d’ajouter un nouvel article à la base de données et de modifier ou supprimer un article existant.

      Conditions préalables

      Avant de commencer à suivre ce guide, vous aurez besoin des éléments suivants :

      Étape 1 – Installation de Flask

      Dans cette étape, vous allez activer votre environnement Python et installer Flask en utilisant l’installateur de paquets pip.

      Si vous n’avez pas encore activé votre environnement de programmation, assurez-vous que vous êtes dans le répertoire de votre projet (flask_blog) et utilisez la commande suivante pour activer l’environnement :

      Une fois que votre environnement de programmation est activé, votre invite aura maintenant un préfixe env qui peut ressembler à ce qui suit :

      Ce préfixe est une indication que l’environnement env est actuellement actif, qui peut avoir un autre nom selon la façon dont vous l’avez nommé lors de sa création.

      Remarque : vous pouvez utiliser Git, un système de contrôle de version pour gérer et suivre efficacement le processus de développement de votre projet. Pour apprendre à utiliser Git, vous pouvez consulter notre article Introduction à l’installation, l’utilisation et les branches de Git.

      Si vous utilisez Git, il est conseillé d’ignorer le répertoire env nouvellement créé dans votre fichier .gitignore pour éviter de suivre des fichiers non liés au projet.

      Vous allez maintenant installer des paquets Python et isoler le code de votre projet de l’installation principale du système Python. Vous ferez cela en utilisant pip et python.

      Pour installer Flask, exécutez la commande suivante :

      Une fois l’installation terminée, exécutez la commande suivante pour confirmer l’installation :

      • python -c "import flask; print(flask.__version__)"

      Vous utilisez l’interface en ligne de commande python avec l’option -c pour exécuter le code Python. Ensuite, vous importez le paquet flask avec import flask; puis vous imprimez la version de Flask, qui est fournie via la variable flask.__version__.

      La sortie sera un numéro de version semblable à ce qui suit :

      Output

      1.1.2

      Vous avez créé le dossier du projet, un environnement virtuel et installé Flask. Vous êtes maintenant prêt à configurer votre application de base.

      Étape 2 – Créer une application de base

      Maintenant que vous avez configuré votre environnement de programmation, vous allez commencer à utiliser Flask. Dans cette étape, vous allez créer une petite application web dans un fichier Python et l’exécuter pour démarrer le serveur, qui affichera certaines informations sur le navigateur.

      Dans votre répertoire flask_blog, ouvrez un fichier nommé hello.py pour le modifier, utilisez nano ou votre éditeur de texte préféré :

      Ce fichier hello.py servira d’exemple minimal de la manière de traiter les requêtes HTTP. À l’intérieur de ce fichier, vous importerez l’objet Flask et créerez une fonction qui renvoie une réponse HTTP.  Écrivez le code suivant à l’intérieur hello.py :

      flask_blog/hello.py

      from flask import Flask
      
      app = Flask(__name__)
      
      
      @app.route('/')
      def hello():
          return 'Hello, World!'
      

      Dans le bloc de code précédent, vous importez d’abord l’objet Flask du paquet flask. Vous l’utilisez ensuite pour créer votre instance d’application Flask avec le nom app. Vous passez la variable spéciale __name__ qui contient le nom du module Python actuel.  Il est utilisé pour indiquer à l’instance où elle se trouve – vous en avez besoin car Flask établit certains chemins en coulisses.

      Une fois que vous avez créé l’instance de l'application, vous l’utilisez pour traiter les demandes web entrantes et envoyer des réponses à l’utilisateur. @app.route est un décorateur qui transforme une fonction Python ordinaire en une fonction d’affichage Flask, qui convertit la valeur de retour de la fonction en une réponse HTTP à afficher par un client HTTP, tel qu’un navigateur web. Vous passez à la valeur '/' à @app.route() pour indiquer que cette fonction répondra aux requêtes web pour l’URL /, qui est l’URL principale.

      La fonction d’affichage hello() renvoie la chaîne "Hello, World!" comme réponse.

      Enregistrez et fermez le fichier.

      Pour exécuter votre application web, vous devez d’abord indiquer à Flask où trouver l’application (le fichier hello.py dans votre cas) avec la variable d’environnement FLASK_APP :

      Ensuite, exécutez-la en mode développement avec la variable d’environnement FLASK_ENV :

      • export FLASK_ENV=development

      Pour terminer, exécutez l’application en utilisant la commande flask run :

      Une fois l’application lancée, la sortie sera quelque chose comme ceci :

      Output

      * Serving Flask app "hello" (lazy loading) * Environment: development * Debug mode: on * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit) * Restarting with stat * Debugger is active! * Debugger PIN: 813-894-335

      La sortie précédente contient plusieurs éléments d’information, tels que :

      • Le nom de l’application que vous exécutez.
      • L’environnement dans lequel l’application est exécutée.
      • Debug mode: onsignifie que le débogueur Flask est en cours d’exécution. Ceci est utile lors du développement car il nous donne des messages d’erreur détaillés lorsque les choses tournent mal, ce qui facilite le dépannage.
      • L’application s’exécute localement sur l’URL http://127.0.0.1:5000/, 127.0.0.1 est l’IP qui représente le localhost de votre machine et :5000 est le numéro du port.

      Ouvrez un navigateur et tapez l’URL http://127.0.0.1:5000/, vous recevrez la chaîne de caractères Hello, World! en réponse, cela confirme que votre application fonctionne correctement.

      Warning Flask utilise un simple serveur web pour servir notre application dans un environnement de développement, ce qui signifie également que le débogueur Flask est en cours d’exécution pour faciliter la capture des erreurs. Ce serveur de développement ne doit pas être utilisé dans un déploiement de production. Consultez la page des options de déploiement dans la documentation Flask pour plus d’informations, vous pouvez également consulter ce tutoriel sur le déploiement de Flask.

      Vous pouvez maintenant quitter le serveur de développement en cours d’exécution dans le terminal et ouvrir une autre fenêtre du terminal. Déplacez-vous dans le dossier du projet où hello.py se trouve, activez l’environnement virtuel, définissez les variables d’environnement FLASK_ENV et FLASK_APP, et passez aux étapes suivantes. (Ces commandes sont énumérées plus haut dans cette étape).

      Remarque : lors de l’ouverture d’un nouveau terminal, il est important de se souvenir d’activer l’environnement virtuel et de définir les variables d’environnement FLASK_ENV et FLASK_APP.

      Pendant que le serveur de développement d’une application Flask est déjà en cours d’exécution, il n’est pas possible d’exécuter une autre application Flask avec la même commande flask run. En effet, flask run utilise le numéro de port 5000 par défaut, et une fois qu’il est pris, il devient indisponible pour exécuter une autre application de sorte que vous recevriez une erreur similaire à la suivante :

      Output

      OSError: [Errno 98] Address already in use

      Pour résoudre ce problème, vous pouvez soit arrêter le serveur qui tourne actuellement via CTRL+C, puis relancer flask run, soit, si vous voulez exécuter les deux en même temps, vous pouvez passer un numéro de port différent à l’argument -p; par exemple, pour exécuter une autre application sur le port 5001, utilisez la commande suivante :

      Vous disposez maintenant d’une petite application web Flask. Vous avez lancé votre application et affiché des informations sur le navigateur web. Ensuite, vous allez utiliser des fichiers HTML dans votre application.

      Étape 3 – Utilisation des modèles HTML

      Actuellement, votre application n’affiche qu’un simple message sans aucun HTML. Les applications web utilisent principalement le HTML pour afficher des informations à l’intention du visiteur. Vous allez donc maintenant travailler à l’incorporation de fichiers HTML à votre application, qui pourront être affichés sur le navigateur web.

      Flask fournit une fonction d’aide render_template() qui permet l’utilisation du moteur de modèle Jinja. Cela facilitera grandement la gestion du HTML en écrivant votre code HTML dans des fichiers .html et en utilisant la logique dans votre code HTML. Vous allez utiliser ces fichiers HTML (modèles) pour construire toutes les pages de votre application, comme la page principale où vous afficherez les articles de blog en cours, la page de l’article de blog, la page où l’utilisateur peut ajouter un nouvel article, etc.

      Dans cette étape, vous allez créer votre application Flask principale dans un nouveau fichier.

      Tout d’abord, dans votre répertoire flask_blog, utilisez nano ou votre éditeur préféré pour créer et modifier votre fichier app.py. Ce fichier contiendra tout le code que vous utiliserez pour créer l’application de blog :

      Dans ce nouveau fichier, vous allez importer l’objet Flask pour créer une instance d’application Flask comme vous l’avez déjà fait. Vous importerez également la fonction d’aide render_template() qui vous permet de rendre les fichiers de modèles HTML qui existent dans le dossier des modèles que vous êtes en train de créer. Le fichier aura une fonction d’affichage unique qui sera responsable de la gestion des demandes vers la principale route /. Ajoutez le contenu suivant :

      flask_blog/app.py

      from flask import Flask, render_template
      
      app = Flask(__name__)
      
      @app.route('/')
      def index():
          return render_template('index.html')
      

      La fonction d’affichage index() renvoie le résultat de l’appel de render_template() avec index.html en argument, ce qui indique à render_template() qu’il doit rechercher un fichier appelé index.html dans le dossier des modèles. Le dossier et le fichier n’existent pas encore, vous obtiendrez une erreur si vous deviez exécuter l’application à ce stade. Vous l’exécuterez néanmoins afin de vous familiariser avec cette exception couramment rencontrée. Vous la corrigerez ensuite en créant le dossier et le fichier nécessaires.

      Enregistrez et quittez le fichier.

      Arrêtez le serveur de développement dans votre autre terminal qui exécute l’application hello avec CTRL+C.

      Avant d’exécuter l’application, assurez-vous de spécifier correctement la valeur de la variable d’environnement FLASK_APP, puisque vous n’utilisez plus l’application hello :

      • export FLASK_APP=app
      • flask run

      En ouvrant l’URL http://127.0.0.1:5000/ dans votre navigateur, la page du débogueur vous informera que le modèle index.html n’a pas été trouvé. La ligne principale du code responsable de cette erreur sera mise en évidence. Dans ce cas, il s’agit de la ligne return render_template('index.html').

      Si vous cliquez sur cette ligne, le débogueur vous révélera plus de code afin que vous disposiez de plus de contexte pour vous aider à résoudre le problème.

      Le débogueur Flask

      Pour corriger cette erreur, créez un répertoire appelé templates à l’intérieur de votre répertoire flask_blog. Ensuite, à l’intérieur de ce répertoire, ouvrez un fichier appelé index.html pour l’éditer :

      • mkdir templates
      • nano templates/index.html

      Ensuite, ajoutez le code HTML suivant dans index.html :

      flask_blog/templates/index.html

      <!DOCTYPE html>
      <html lang="en">
      <head>
          <meta charset="UTF-8">
          <title>FlaskBlog</title>
      </head>
      <body>
         <h1>Welcome to FlaskBlog</h1>
      </body>
      </html>
      

      Enregistrez le fichier et utilisez votre navigateur pour naviguer à nouveau sur http://127.0.0.1:5000/, ou actualisez la page. Cette fois, le navigateur doit afficher le texte Welcome to FlaskBlog dans une balise <h1>.

      En plus du dossier templates, les applications web de Flask disposent généralement d’un dossier static pour l’hébergement des fichiers statiques, tels que les fichiers CSS, les fichiers JavaScript et les images utilisées par l’application.

      Vous pouvez créer un fichier de feuille de style style.css pour ajouter du CSS à votre application. Tout d’abord, créez un répertoire appelé static à l’intérieur de votre répertoire principal flask_blog :

      Ensuite, créez un autre répertoire appelé css à l’intérieur du répertoire static pour héberger les fichiers .css. Cela est généralement fait pour organiser les fichiers statiques dans des dossiers dédiés, comme par exemple, les fichiers JavaScript se trouvent généralement dans un répertoire appelé js, les images sont placées dans un répertoire appelé images (ou img), etc. La commande suivante créera le répertoire css à l’intérieur du répertoire static :

      Ouvrez ensuite un fichier style.css à l’intérieur du répertoire css pour l’éditer :

      • nano static/css/style.css

      Ajoutez la règle CSS suivante à votre fichier style.css :

      flask_blog/static/css/style.css

      h1 {
          border: 2px #eee solid;
          color: brown;
          text-align: center;
          padding: 10px;
      }
      

      Le code CSS ajoutera une bordure, changera la couleur en marron, centrera le texte et ajoutera un peu de padding aux balises <h1>.

      Enregistrez et fermez le fichier.

      Ensuite, ouvrez le fichier de modèle index.html pour le modifier :

      • nano templates/index.html

      Vous ajouterez un lien vers le fichier style.css à l’intérieur de la section <head> du fichier modèle index.html :

      flask_blog/templates/index.html

      . . .
      <head>
          <meta charset="UTF-8">
          <link rel="stylesheet" href="https://www.digitalocean.com/{{ url_for("static', filename= 'css/style.css') }}">
          <title>FlaskBlog</title>
      </head>
      . . .
      

      Ici, vous utilisez la fonction d’aide url_for() pour générer l’emplacement approprié du fichier. Le premier argument spécifie que vous créez un lien vers un fichier statique et que le deuxième argument est le chemin du fichier à l’intérieur du répertoire static.

      Enregistrez et fermez le fichier.

      En rafraîchissant la page d’index de votre application, vous remarquerez que le texte Welcome to FlaskBlog est maintenant en brun, centré et entouré d’une bordure.

      Vous pouvez utiliser le langage CSS pour styliser l’application et la rendre plus attrayante en utilisant votre propre design. Toutefois, si vous n’êtes pas un concepteur de sites web ou si vous ne connaissez pas le langage CSS, vous pouvez utiliser la boîte à outils Bootstrap, qui fournit des composants faciles à utiliser pour styliser votre application. Dans ce projet, nous utiliserons Bootstrap.

      Vous pourriez penser que la création d’un autre modèle HTML impliquerait la répétition de la plupart du code HTML que vous avez déjà écrit dans le modèle index.html. Vous pouvez éviter la répétition inutile du code à l’aide d’un fichier de modèle de base, dont tous vos fichiers HTML hériteront. Pour plus d’informations, voir la section Héritage de modèles dans Jinja.

      Pour créer un modèle de base, créez d’abord un fichier appelé base.html dans votre répertoire templates :

      Tapez le code suivant dans votre modèle base.html :

      flask_blog/templates/base.html

      <!doctype html>
      <html lang="en">
        <head>
          <!-- Required meta tags -->
          <meta charset="utf-8">
          <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
      
          <!-- Bootstrap CSS -->
          <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css" integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T" crossorigin="anonymous">
      
          <title>{% block title %} {% endblock %}</title>
        </head>
        <body>
          <nav class="navbar navbar-expand-md navbar-light bg-light">
              <a class="navbar-brand" href="https://www.digitalocean.com/{{ url_for('index')}}">FlaskBlog</a>
              <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarNav" aria-controls="navbarNav" aria-expanded="false" aria-label="Toggle navigation">
                  <span class="navbar-toggler-icon"></span>
              </button>
              <div class="collapse navbar-collapse" id="navbarNav">
                  <ul class="navbar-nav">
                  <li class="nav-item active">
                      <a class="nav-link" href="https://www.digitalocean.com/#">About</a>
                  </li>
                  </ul>
              </div>
          </nav>
          <div class="container">
              {% block content %} {% endblock %}
          </div>
      
          <!-- Optional JavaScript -->
          <!-- jQuery first, then Popper.js, then Bootstrap JS -->
          <script src="https://code.jquery.com/jquery-3.3.1.slim.min.js" integrity="sha384-q8i/X+965DzO0rT7abK41JStQIAqVgRVzpbzo5smXKp4YfRvH+8abtTE1Pi6jizo" crossorigin="anonymous"></script>
          <script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.7/umd/popper.min.js" integrity="sha384-UO2eT0CpHqdSJQ6hJty5KVphtPhzWj9WO1clHTMGa3JDZwrnQq4sF86dIHNDz0W1" crossorigin="anonymous"></script>
          <script src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js" integrity="sha384-JjSmVgyd0p3pXB1rRibZUAYoIIy6OrQ6VrjIEaFf/nJGzIxFDsf4x0xIM+B07jRM" crossorigin="anonymous"></script>
        </body>
      </html>
      

      Enregistrez et fermez le fichier une fois que vous avez terminé de le modifier.

      La majeure partie du code du bloc précédent est du HTML standard et du code requis pour Bootstrap. Les balises <meta> fournissent des informations pour le navigateur web, la balise <link> relie les fichiers CSS de Bootstrap, et les balises <script> sont des liens vers le code JavaScript qui permet certaines fonctionnalités supplémentaires de Bootstrap, consultez la documentation de Bootstrap pour en savoir plus.

      Cependant, les parties surlignées suivantes sont spécifiques au moteur de template Jinja :

      • {% block title %} {% endblock %}​​​ : un bloc qui sert d’emplacement pour un titre, vous l’utiliserez plus tard dans d’autres modèles pour donner un titre personnalisé à chaque page de votre application sans réécrire à chaque fois toute la section <head>.
      • {{ url_for('index')}}: un appel de fonction qui renvoie l’URL pour la fonction d’affichage index(). Il est différent de l’ancien appel url_for() que vous utilisiez pour lier un fichier CSS statique, car il ne prend qu’un seul argument, qui est le nom de la fonction de visualisation, et renvoie à la route associée à la fonction au lieu d’un fichier statique.
      • {% block content %} {% endblock %}: un autre bloc qui sera remplacé par un contenu dépendant du modèle enfant (modèles qui héritent de base.html) qui le remplacera.

      Maintenant que vous avez un modèle de base, vous pouvez en tirer profit grâce à l’héritage. Ouvrez le fichier index.html :

      • nano templates/index.html

      Ensuite, remplacez son contenu par le suivant :

      flask_blog/templates/index.html

      {% extends 'base.html' %}
      
      {% block content %}
          <h1>{% block title %} Welcome to FlaskBlog {% endblock %}</h1>
      {% endblock %}
      

      Dans cette nouvelle version du modèle index.html, vous utilisez la balise {% extends %} pour hériter du modèle base.html. Vous l’étendez ensuite en remplaçant le bloc de contenu dans le modèle de base par ce qui se trouve à l’intérieur du bloc de contenu dans le bloc de code précédent.

      Ce bloc de contenu contient une balise <h1> avec le texte Welcome to FlaskBlog à l’intérieur d’un bloc de titre, qui à son tour remplace le bloc de titre original dans le modèle base.html par le texte Welcome to FlaskBlog. De cette façon, vous pouvez éviter de répéter deux fois le même texte, car il fonctionne à la fois comme un titre pour la page et un titre qui apparaît sous la barre de navigation héritée du modèle de base.

      L’héritage du modèle vous donne également la possibilité de réutiliser le code HTML que vous avez dans d’autres modèles (base.html dans ce cas) sans avoir à le répéter chaque fois que nécessaire.

      Enregistrez et fermez le fichier et rafraîchissez la page d’index sur votre navigateur. Vous verrez votre page avec une barre de navigation et un titre stylisé.

      Page d'index avec Bootstrap

      Vous avez utilisé des modèles HTML et des fichiers statiques dans Flask. Vous avez également utilisé Bootstrap pour commencer à affiner l’apparence de votre page et un modèle de base pour éviter la répétition du code. Dans l’étape suivante, vous allez configurer une base de données qui va stocker les données de votre application.

      Étape 4 – Mise en place de la base de données

      Au cours de cette étape, vous allez créer une base de données pour stocker les données, c’est-à-dire les articles de blog de votre application. Vous allez également remplir la base de données avec quelques exemples d’entrées.

      Vous utiliserez un fichier de base de données SQLite pour stocker vos données, car le module sqlite3, que nous utiliserons pour interagir avec la base de données, est disponible dans la bibliothèque standard Python. Pour plus d’informations sur SQLite, consultez ce tutoriel.

      Tout d’abord, comme les données dans SQLite sont stockées dans des tableaux et des colonnes, et comme vos données consistent principalement en des articles de blog, vous devez d’abord créer un tableau appelé posts (articles) avec les colonnes nécessaires. Vous allez créer un fichier .sql qui contient des commandes SQL pour créer le tableau posts avec quelques colonnes. Vous utiliserez ensuite ce fichier pour créer la base de données.

      Ouvrez un fichier appelé schema.sql à l’intérieur de votre répertoire flask_blog :

      Tapez les commandes SQL suivantes dans ce fichier :

      flask_blog/schema.sql

      DROP TABLE IF EXISTS posts;
      
      CREATE TABLE posts (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
          title TEXT NOT NULL,
          content TEXT NOT NULL
      );
      

      Enregistrez et fermez le fichier.

      La première commande SQL est DROP TABLE IF EXISTS posts; elle supprime toutes les tables déjà existantes nommées posts afin de ne pas créer de confusion. Notez que cela supprimera tout le contenu que vous avez dans la base de données chaque fois que vous utiliserez ces commandes SQL, donc assurez-vous de ne pas écrire de contenu important dans l’application web avant d’avoir terminé ce tutoriel et d’avoir expérimenté le résultat final. Ensuite, CREATE TABLE posts est utilisé pour créer la table posts avec les colonnes suivantes :

      • id : nombre entier qui représente une clé primaire, à laquelle la base de données attribuera une valeur unique pour chaque entrée (c’est-à-dire un billet de blog).
      • created : l’heure où le billet de blog a été créé. NOT NULL signifie que cette colonne ne doit pas être vide et la valeur DEFAULT est la valeur CURRENT_TIMESTAMP, qui est le moment où l’article a été ajouté à la base de données. Tout comme id, vous n’avez pas besoin de spécifier une valeur pour cette colonne, car elle sera automatiquement remplie.
      • title : le titre de l’article.
      • content : le contenu de l’article.

      Maintenant que vous avez un schéma SQL dans le fichier schema.sql, vous allez l’utiliserez pour créer la base de données à l’aide d’un fichier Python qui génèrera un fichier de base de données SQLite .db. Ouvrez un fichier nommé init_db.py dans le répertoire flask_blog en utilisant votre éditeur préféré :

      Ensuite, ajoutez le code suivant.

      flask_blog/init_db.py

      import sqlite3
      
      connection = sqlite3.connect('database.db')
      
      
      with open('schema.sql') as f:
          connection.executescript(f.read())
      
      cur = connection.cursor()
      
      cur.execute("INSERT INTO posts (title, content) VALUES (?, ?)",
                  ('First Post', 'Content for the first post')
                  )
      
      cur.execute("INSERT INTO posts (title, content) VALUES (?, ?)",
                  ('Second Post', 'Content for the second post')
                  )
      
      connection.commit()
      connection.close()
      

      Vous importez d’abord le module sqlite3 et ouvrez ensuite une connexion à un fichier de base de données nommé base de database.db, qui sera créé une fois que vous aurez lancé le fichier Python. Ensuite, vous utilisez la fonction open() pour ouvrir le fichier schema.sql. Ensuite, vous exécutez son contenu en utilisant la méthode executescript() qui exécute plusieurs instructions SQL en une seule fois, ce qui créera la table posts. Vous créez un objet Cursor qui vous permet d’utiliser sa méthode execute() pour exécuter deux instructions SQL INSERT afin d’ajouter deux articles de blog à votre table posts.  Enfin, vous validez les modifications et coupez la connexion.

      Enregistrez et fermez le fichier et exécutez-le dans le terminal en utilisant la commande python :

      Une fois l’exécution du fichier terminée, un nouveau fichier appelé database.db apparaîtra dans votre répertoire flask_blog. Cela signifie que vous avez configuré avec succès votre base de données.

      Dans l’étape suivante, vous récupérerez les articles de blog que vous avez insérés dans votre base de données et les afficherez sur la page d’accueil de votre application.

      Étape 5 – Afficher tous les articles

      Maintenant que vous avez configuré votre base de données, vous pouvez modifier la fonction d’affichage index() pour afficher tous les articles que vous avez dans votre base de données.

      Ouvrez le fichier app.py pour apporter les modifications suivantes :

      Pour votre première modification, vous importerez le module sqlite3 en haut du fichier :

      flask_blog/app.py

      import sqlite3
      from flask import Flask, render_template
      
      . . .
      

      Ensuite, vous allez créer une fonction qui crée une connexion à la base de données et la renvoie. Ajoutez-la directement après l’importation :

      flask_blog/app.py

      . . .
      from flask import Flask, render_template
      
      def get_db_connection():
          conn = sqlite3.connect('database.db')
          conn.row_factory = sqlite3.Row
          return conn
      
      . . .
      

      Cette fonction get_db_connection() ouvre une connexion au fichier de base de données database.db, et définit ensuite l’attribut row_factory à sqlite3. Row afin que vous puissiez avoir un accès par nom aux colonnes. Cela signifie que la connexion à la base de données renverra des lignes qui se comporteront comme des dictionnaires Python normaux. Enfin, la fonction renvoie l’objet de connexion conn que vous utiliserez pour accéder à la base de données.

      Après avoir défini la fonction get_db_connection(), modifier la fonction index() pour qu’elle ressemble à ce qui suit :

      flask_blog/app.py

      . . .
      
      @app.route('/')
      def index():
          conn = get_db_connection()
          posts = conn.execute('SELECT * FROM posts').fetchall()
          conn.close()
          return render_template('index.html"https://www.digitalocean.com/, posts=posts)
      

      Dans cette nouvelle version de la fonction index(), vous ouvrez d’abord une connexion à la base de données en utilisant la fonction get_db_connection() que vous avez définie précédemment. Ensuite, vous exécutez une requête SQL pour sélectionner toutes les entrées de la table posts. Vous implémentez la méthode fetchall() pour récupérer toutes les lignes du résultat de la requête, celle-ci renvoie une liste des articles que vous avez insérés dans la base de données à l’étape précédente.

      Vous fermez la connexion à la base de données en utilisant la méthode close() et vous retournez le résultat du rendu du modèle index.html. Vous passez également l’objet posts en argument, lequel contient les résultats que vous avez obtenus de la base de données, ce qui vous permettra d’accéder aux articles de blog dans le modèle index.html.

      Une fois ces modifications apportées, enregistrez et fermez le fichier app.py.

      Maintenant que vous avez passé les articles que vous avez extraits de la base de données au modèle index.html, vous pouvez utiliser une boucle for pour afficher chaque article sur votre page d’index.

      Ouvrez le fichier index.html :

      • nano templates/index.html

      Ensuite, modifiez-le pour qu’il ressemble à :

      flask_blog/templates/index.html

      {% extends 'base.html' %}
      
      {% block content %}
          <h1>{% block title %} Welcome to FlaskBlog {% endblock %}</h1>
          {% for post in posts %}
              <a href="https://www.digitalocean.com/#">
                  <h2>{{ post['title'] }}</h2>
              </a>
              <span class="badge badge-primary">{{ post['created'] }}</span>
              <hr>
          {% endfor %}
      {% endblock %}
      

      Ici, la syntaxe {% for post in posts %} est un Jinja pour boucle, qui est similaire à un Python pour boucle sauf qu’il doit être fermé plus tard avec la syntaxe {% endfor %}. Vous utilisez cette syntaxe pour boucler sur chaque élément de la liste des messages qui a été passé par la fonction index() dans la ligne return render_template('index.html', posts=posts). Dans cette boucle for, vous affichez le titre de l’article dans un titre <h2> à l’intérieur d’une balise <a> (vous utiliserez plus tard cette balise pour faire un lien vers chaque article individuellement).

      Vous affichez le titre en utilisant un délimiteur de variable littérale ({{ ... }}). N’oubliez pas que post sera un objet de type dictionnaire, vous pouvez donc accéder au titre de l’article avec la balise post['title']. Vous affichez également la date de création l’article en utilisant la même méthode.

      Une fois que vous avez fini d’éditer le fichier, enregistrez-le et fermez-le. Ensuite, naviguez vers la page d’index de votre navigateur. Vous verrez les deux articles que vous avez ajoutés à la base de données sur votre page.

      Page d'index avec les articles affichés

      Maintenant que vous avez modifié la fonction d’affichage index() pour afficher tous les articles que vous avez dans la base de données sur la page d’accueil de votre application, vous allez afficher chaque article sur une seule page et permettre aux utilisateurs de se relier à chaque article.

      Étape 6 – Afficher un article unique

      Au cours de cette étape, vous allez créer un nouvel itinéraire Flask avec une fonction d’affichage et un nouveau modèle HTML pour afficher un article de blog individuel par son ID.

      À la fin de cette étape, l’URL http://127.0.0.1:5000/1 sera une page qui affichera le premier article (parce qu’il a l’ID 1). L’URL http://127.0.0.1:5000/ID affichera l’article avec le numéro ID associé s’il existe.

      Ouvrez app.py pour le modifier :

      Comme vous devrez obtenir un article de blog par son ID à partir de la base de données à plusieurs endroits plus tard dans ce projet, vous créerez une fonction autonome appelée get_post(). Vous pouvez l’appeler en lui passant un ID et recevoir en retour le billet associé à l’ID fourni, ou faire en sorte que Flask réponde avec un message 404 Not Found si le billet n’existe pas.

      Pour répondre avec une page 404, vous devez importer la fonction abort() de la bibliothèque Werkzeug, qui a été installée avec Flask, en haut du fichier :

      flask_blog/app.py

      import sqlite3
      from flask import Flask, render_template
      from werkzeug.exceptions import abort
      
      . . .
      

      Ensuite, ajoutez la fonction get_post() juste après la fonction get_db_connection() que vous avez créée à l’étape précédente :

      flask_blog/app.py

      . . .
      
      def get_db_connection():
          conn = sqlite3.connect('database.db')
          conn.row_factory = sqlite3.Row
          return conn
      
      
      def get_post(post_id):
          conn = get_db_connection()
          post = conn.execute('SELECT * FROM posts WHERE id = ?',
                              (post_id,)).fetchone()
          conn.close()
          if post is None:
              abort(404)
          return post
      
      . . .
      

      Cette nouvelle fonction a un argument post_id qui détermine quel article de blog doit être renvoyé.

      À l’intérieur de la fonction, vous utilisez la fonction get_db_connection() pour ouvrir une connexion à la base de données et exécuter une requête SQL pour obtenir l’article de blog associé à la valeur post_id donnée. Vous ajoutez la méthode fetchone() pour obtenir le résultat et le stocker dans la variable post, puis fermez la connexion. Si la variable post a la valeur None, ce qui signifie qu’aucun résultat n’a été trouvé dans la base de données, vous utilisez la fonction abort() que vous avez importée précédemment pour répondre avec un code d’erreur 404 et la fonction terminera son exécution. Si toutefois, un article a été trouvé, vous retournez la valeur de la variable post.

      Ensuite, ajoutez la fonction d’affichage suivante à la fin du fichier app.py :

      flask_blog/app.py

      . . .
      
      @app.route('/<int:post_id>')
      def post(post_id):
          post = get_post(post_id)
          return render_template('post.html', post=post)
      

      Dans cette nouvelle fonction de visualisation, vous ajoutez une règle de variable <int:post_id> pour spécifier que la partie après la barre oblique (/) est un entier positif (marqué avec le convertisseur int) auquel vous devez accéder dans votre fonction de visualisation. Flask reconnaît cela et passe sa valeur à l’argument du mot-clé post_id de votre fonction de visualisation post(). Vous utilisez ensuite la fonction get_post() pour obtenir l’article de blog associé à l’ID spécifié et stocker le résultat dans la variable post, que vous passez à un modèle post.html que vous allez bientôt créer.

      Enregistrez le fichier app.py et ouvrez un nouveau fichier de modèle post.html pour le modifier :

      Tapez le code suivant dans ce nouveau fichier post.html. Celui-ci sera similaire au fichier index.html, sauf qu’il n’affichera qu’un seul article, en plus d’afficher également le contenu de l’article :

      flask_blog/templates/post.html

      {% extends 'base.html' %}
      
      {% block content %}
          <h2>{% block title %} {{ post['title'] }} {% endblock %}</h2>
          <span class="badge badge-primary">{{ post['created'] }}</span>
          <p>{{ post['content'] }}</p>
      {% endblock %}
      

      Vous ajoutez le bloc title que vous avez défini dans le modèle base.html pour que le titre de la page reflète en même temps le titre de l’article qui est affiché dans un titre <h2>.

      Enregistrez et fermez le fichier.

      Vous pouvez maintenant naviguer vers les URL suivantes pour voir les deux articles que vous avez dans votre base de données, ainsi qu’une page qui indique à l’utilisateur que l’article de blog demandé n’a pas été trouvé (puisqu’il n’y a pas d’article avec un numéro d’identification de 3 pour l’instant) :

      http://127.0.0.1:5000/1
      http://127.0.0.1:5000/2
      http://127.0.0.1:5000/3
      

      En retournant à la page d’index, vous ferez en sorte que le titre de chaque article renvoie à sa page respective. Vous ferez cela en utilisant la fonction url_for(). Tout d’abord, ouvrez le modèle index.html pour le modifier :

      • nano templates/index.html

      Ensuite, changez la valeur de l’attribut href de # à {{ url_for('post', post_id=post['id']) }} pour que la boucle for se présente exactement comme suit :

      flask_blog/templates/index.html

      {% for post in posts %}
          <a href="https://www.digitalocean.com/{{ url_for('post', post_id=post['id']) }}">
              <h2>{{ post['title'] }}</h2>
          </a>
          <span class="badge badge-primary">{{ post['created'] }}</span>
          <hr>
      {% endfor %}
      

      Ici, vous passez « post » à la fonction url_for() comme un premier argument. C’est le nom de la fonction d’affichage post() et comme elle accepte un argument post_id, vous lui donnez la valeur post['id']. La fonction url_for() renvoie l’URL appropriée pour chaque article en fonction de son ID.

      Enregistrez et fermez le fichier.

      Les liens de la page d’index fonctionneront désormais comme prévu. Vous avez maintenant terminé la construction de la partie de l’application responsable de l’affichage des articles de blog dans votre base de données. Ensuite, vous allez ajouter à votre application la possibilité de créer, de modifier et de supprimer des articles de blog.

      Étape 7 – Modification d’articles

      Maintenant que vous avez fini d’afficher les articles de blog présents dans la base de données sur l’application web, vous devez permettre aux utilisateurs de votre application d’écrire de nouveaux articles de blog et de les ajouter à la base de données, de modifier les articles existants et de supprimer les articles de blog inutiles.

      Créer un nouvel article

      À ce stade, vous disposez d’une application qui affiche les messages dans votre base de données mais qui ne vous permet pas d’ajouter un nouveau message, sauf si vous vous connectez directement à la base de données SQLite et que vous en ajoutez un manuellement. Dans cette section, vous allez créer une page sur laquelle vous pourrez créer un article en fournissant son titre et son contenu.

      Ouvrez le fichier app.py pour le modifier :

      Tout d’abord, vous allez importer ce qui suit depuis le framework Flask :

      • L’objet request global pour accéder aux données de la requête entrante qui sera soumise via un formulaire HTML.
      • La fonction url_for() pour générer des URL.
      • La fonction flash() pour afficher un message lorsqu’une requête est traitée.
      • La fonction redirect() pour rediriger le client vers un autre emplacement.

      Ajoutez les importations à votre fichier comme suit :

      flask_blog/app.py

      import sqlite3
      from flask import Flask, render_template, request, url_for, flash, redirect
      from werkzeug.exceptions import abort
      
      . . .
      

      La fonction flash() stocke les messages flashs dans la session du navigateur du client, ce qui nécessite la définition d’une clé secrète. Cette clé secrète est utilisée pour sécuriser les sessions, ce qui permet à Flask de se souvenir des informations d’une requête à l’autre, comme passer de la page du nouveau message à la page d’index. L’utilisateur peut accéder aux informations stockées dans la session, mais ne peut pas les modifier s’il ne dispose pas de la clé secrète, de sorte que vous ne devez jamais autoriser quiconque à accéder à votre clé secrète. Pour plus d’informations, consultez la documentation Flask pour les sessions.

      Pour définir une clé secrète, vous ajouterez une configuration SECRET_KEY à votre application via l’objet app.config. Ajoutez-la directement après la définition de l’app avant de définir la fonction de visualisation index() :

      flask_blog/app.py

      . . .
      app = Flask(__name__)
      app.config['SECRET_KEY'] = 'your secret key'
      
      
      @app.route('/')
      def index():
          conn = get_db_connection()
          posts = conn.execute('SELECT * FROM posts').fetchall()
          conn.close()
          return render_template('index.html', posts=posts)
      
      . . .
      

      N’oubliez pas que la clé secrète doit être une longue chaîne aléatoire.

      Après avoir défini une clé secrète, vous allez créer une fonction de visualisation qui rendra un modèle affichant un formulaire que vous pouvez remplir pour créer un nouveau article de blog. Ajoutez cette nouvelle fonction au bas du fichier :

      flask_blog/app.py

      . . .
      
      @app.route('/create', methods=('GET', 'POST'))
      def create():
          return render_template('create.html')
      

      Cela crée une route /create qui accepte les demandes GET et POST. Les requêtes GET sont acceptées par défaut. Pour accepter également les requêtes POST, qui sont envoyées par le navigateur lors de la soumission des formulaires, vous passerez un tuple avec les types de requêtes acceptés à l’argument methods du décorateur @app.route().

      Enregistrez et fermez le fichier.

      Pour créer le modèle, ouvrez un fichier appelé create.html dans votre dossier templates :

      • nano templates/create.html

      Ajoutez le code suivant dans ce nouveau fichier :

      flask_blog/templates/create.html

      {% extends 'base.html' %}
      
      {% block content %}
      <h1>{% block title %} Create a New Post {% endblock %}</h1>
      
      <form method="post">
          <div class="form-group">
              <label for="title">Title</label>
              <input type="text" name="title"
                     placeholder="Post title" class="form-control"
                     value="{{ request.form['title'] }}"></input>
          </div>
      
          <div class="form-group">
              <label for="content">Content</label>
              <textarea name="content" placeholder="Post content"
                        class="form-control">{{ request.form['content'] }}</textarea>
          </div>
          <div class="form-group">
              <button type="submit" class="btn btn-primary">Submit</button>
          </div>
      </form>
      {% endblock %}
      

      La majorité de ce code est du HTML standard. Il affichera une zone de saisie pour le titre du message, une zone de texte pour le contenu du message et un bouton pour soumettre le formulaire.

      La valeur du titre de l’article est {{ request.form['title'] }} et la zone de texte a la valeur {{ request.form['content'] }}, ceci afin que les données que vous entrez ne soient pas perdues si quelque chose se passe mal.  Par exemple, si vous écrivez un long article et que vous oubliez de lui donner un titre, un message s’affiche pour vous informer que le titre est requis. Cela se produira sans perdre le message que vous avez écrit puisqu’il sera stocké dans l’objet request global auquel vous avez accès dans vos modèles.

      Maintenant que le serveur de développement tourne, utilisez votre navigateur pour accéder à la route /create :

      http://127.0.0.1:5000/create
      

      Vous verrez une page Create a New Post avec une boîte pour un titre et un contenu.

      Créer une nouvelle page d'article

      Ce formulaire soumet une demande POST à votre fonction create() view. Cependant, il n’y a pas encore de code pour traiter une demande POST dans la fonction, donc rien ne se passe après avoir rempli le formulaire et l’avoir soumis.

      Vous traiterez la requête POST entrante lorsqu’un formulaire sera soumis. Vous ferez cela à l’intérieur de la fonction de visualisation create(). Vous pouvez traiter la demande POST séparément en vérifiant la valeur de request.method. Lorsque sa valeur est réglée sur 'POST', elle signifie que la requête est une requête POST, vous allez ensuite continuer à extraire les données soumises, le valider et l’insérer dans votre base de données.

      Ouvrez le fichier app.py pour le modifier :

      Modifiez la fonction de visualisation create() pour qu’elle ressemble exactement à ce qui suit :

      flask_blog/app.py

      . . .
      
      @app.route('/create', methods=('GET', 'POST'))
      def create():
          if request.method == 'POST':
              title = request.form['title']
              content = request.form['content']
      
              if not title:
                  flash('Title is required!')
              else:
                  conn = get_db_connection()
                  conn.execute('INSERT INTO posts (title, content) VALUES (?, ?)',
                               (title, content))
                  conn.commit()
                  conn.close()
                  return redirect(url_for('index'))
      
          return render_template('create.html')
      

      Dans la déclaration if, vous devez vous assurer que le code qui suit n’est exécuté que lorsque la demande est une demande POST via la comparaison request.method == 'POST'.

      Vous extrayez ensuite le titre et le contenu soumis de l’objet request.form qui vous donne accès aux données du formulaire dans la demande. Si le titre n’est pas fourni, la condition if not title serait remplie, en affichant un message à l’utilisateur l’informant que le titre est requis. Si, en revanche, le titre est fourni, vous ouvrez une connexion avec la fonction get_db_connection() et insérez le titre et le contenu que vous avez reçu dans le tableau posts.

      Vous validez ensuite les modifications dans la base de données et coupez la connexion. Après avoir ajouté l’article de blog à la base de données, vous redirigez le client vers la page d’index en utilisant la fonction redirect() en lui passant l’URL générée par la fonction url_for() avec la valeur 'index' en argument.

      Enregistrez et fermez le fichier.

      Maintenant, naviguez vers la route /create en utilisant votre navigateur web :

      http://127.0.0.1:5000/create
      

      Remplissez le formulaire avec un titre de votre choix et un peu de contenu. Une fois que vous avez soumis le formulaire, vous verrez le nouveau article listé sur la page d’index.

      Enfin, vous afficherez des messages clignotants et ajouterez un lien vers la barre de navigation dans le modèle base.html pour accéder facilement à cette nouvelle page. Ouvrez le fichier modèle :

      Modifiez le fichier en ajoutant une nouvelle balise <li> à la suite du lien “About” à l’intérieur de la balise <nav>. Ensuite, ajoutez un nouveau for loop directement au-dessus du bloc content pour afficher les messages clignotants sous la barre de navigation. Ces messages sont disponibles dans la fonction spéciale get_flashed_messages() que Flask fournit :

      flask_blog/templates/base.html

      <nav class="navbar navbar-expand-md navbar-light bg-light">
          <a class="navbar-brand" href="https://www.digitalocean.com/{{ url_for("index')}}">FlaskBlog</a>
          <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarNav" aria-controls="navbarNav" aria-expanded="false" aria-label="Toggle navigation">
              <span class="navbar-toggler-icon"></span>
          </button>
          <div class="collapse navbar-collapse" id="navbarNav">
              <ul class="navbar-nav">
              <li class="nav-item">
                  <a class="nav-link" href="https://www.digitalocean.com/#">About</a>
              </li>
              <li class="nav-item">
                  <a class="nav-link" href="https://www.digitalocean.com/{{url_for("create')}}">New Post</a>
              </li>
              </ul>
          </div>
      </nav>
      <div class="container">
          {% for message in get_flashed_messages() %}
              <div class="alert alert-danger">{{ message }}</div>
          {% endfor %}
          {% block content %} {% endblock %}
      </div>
      

      Enregistrez et fermez le fichier. La barre de navigation comportera désormais un élément New Post qui renvoie à la route /create.

      Éditer un message

      Pour qu’un blog soit à jour, vous devez être en mesure de modifier vos articles existants. Cette section vous guidera dans la création d’une nouvelle page dans votre application afin de simplifier le processus de modification d’un article.

      Tout d’abord, vous allez ajouter une nouvelle route au fichier app.py. Sa fonction de visualisation recevra l’ID du message qui doit être édité, l’URL sera au format /post_id/edit avec la variable post_id étant l’ID du message. Ouvrez le fichier app.py pour le modifier :

      Ensuite, ajoutez la fonction d’affichage edit() suivante à la fin du fichier. L’édition d’un article existant est similaire à la création d’un nouvel article, donc cette fonction de visualisation sera similaire à la fonction de visualisation create() :

      flask_blog/app.py

      . . .
      
      @app.route('/<int:id>/edit', methods=('GET', 'POST'))
      def edit(id):
          post = get_post(id)
      
          if request.method == 'POST':
              title = request.form['title']
              content = request.form['content']
      
              if not title:
                  flash('Title is required!')
              else:
                  conn = get_db_connection()
                  conn.execute('UPDATE posts SET title = ?, content = ?'
                               ' WHERE id = ?',
                               (title, content, id))
                  conn.commit()
                  conn.close()
                  return redirect(url_for('index'))
      
          return render_template('edit.html', post=post)
      

      L article que vous éditez est déterminé par l’URL et Flask passera le numéro d’identification à la fonction edit() via l’argument id. Vous ajoutez cette valeur à la fonction get_post() pour récupérer le message associé à l’ID fourni de la base de données. Les nouvelles données seront envoyées dans une requête POST, qui est traitée dans la condition if request.method == 'POST'.

      Tout comme lorsque vous créez un nouveau message, vous extrayez d’abord les données de l’objet request.form, puis vous envoyez un message si le titre a une valeur vide, sinon, vous ouvrez une connexion à la base de données. Ensuite, vous mettez à jour le tableau posts en définissant un nouveau titre et un nouveau contenu où l’ID de l’article dans la base de données est égal à l’ID qui se trouvait dans l’URL.

      Dans le cas d’une requête GET, vous rendez un modèle edit.html en passant dans la variable post qui contient la valeur retournée par la fonction get_post(). Vous l’utiliserez pour afficher le titre et le contenu existants sur la page d’édition.

      Enregistrez et fermez le fichier, puis créez un nouveau modèle edit.html :

      Ecrivez le code suivant dans ce nouveau fichier :

      flask_blog/templates/edit.html

      {% extends 'base.html' %}
      
      {% block content %}
      <h1>{% block title %} Edit "{{ post['title'] }}" {% endblock %}</h1>
      
      <form method="post">
          <div class="form-group">
              <label for="title">Title</label>
              <input type="text" name="title" placeholder="Post title"
                     class="form-control"
                     value="{{ request.form['title'] or post['title'] }}">
              </input>
          </div>
      
          <div class="form-group">
              <label for="content">Content</label>
              <textarea name="content" placeholder="Post content"
                        class="form-control">{{ request.form['content'] or post['content'] }}</textarea>
          </div>
          <div class="form-group">
              <button type="submit" class="btn btn-primary">Submit</button>
          </div>
      </form>
      <hr>
      {% endblock %}
      

      Enregistrez et fermez le fichier.

      Ce code suit le même modèle, à l’exception de la syntaxe {{ request.form['title'] ou post['title'] }} et {{ request.form['content'] ou post['content'] }}. Cela affiche les données stockées dans la requête si elles existent, sinon, cela affiche les données de la variable post qui a été passée au modèle contenant les données actuelles de la base de données.

      Maintenant, naviguez vers l’URL suivante pour modifier le premier article :

      http://127.0.0.1:5000/1/edit
      

      Vous verrez une page Edit “First Post”.

      Modifier la page d'un article

      Modifiez l’article et soumettez le formulaire, puis assurez-vous que l’article a été mis à jour.

      Vous devez maintenant ajouter un lien qui pointe vers la page d’édition pour chaque article sur la page d’index. Ouvrez le fichier modèle index.html :

      • nano templates/index.html

      Modifiez le fichier pour qu’il ressemble exactement à ce qui suit :

      flask_blog/templates/index.html

      {% extends 'base.html' %}
      
      {% block content %}
          <h1>{% block title %} Welcome to FlaskBlog {% endblock %}</h1>
          {% for post in posts %}
              <a href="https://www.digitalocean.com/{{ url_for("post', post_id=post['id']) }}">
                  <h2>{{ post['title'] }}</h2>
              </a>
              <span class="badge badge-primary">{{ post['created'] }}</span>
              <a href="https://www.digitalocean.com/{{ url_for("edit', id=post['id']) }}">
                  <span class="badge badge-warning">Edit</span>
              </a>
              <hr>
          {% endfor %}
      {% endblock %}
      

      Enregistrez et fermez le fichier.

      Ici, vous ajoutez une balise <a> pour faire un lien vers la fonction de visualisation edit(), en passant la valeur post['id'] pour faire un lien vers la page d’édition de chaque article avec le lien Edit.

      Suppression d’un article

      Parfois, un article n’a plus besoin d’être accessible au public, c’est pourquoi la fonctionnalité de suppression d’un article est cruciale. Au cours de cette étape, vous allez ajouter la fonctionnalité de suppression à votre application.

      Tout d’abord, vous allez ajouter une nouvelle route /ID/delete qui accepte les requêtes POST, similaire à la fonction de visualisation edit(). Votre nouvelle fonction de visualisation delete() recevra l’ID du message à supprimer de l’URL. Ouvrez le fichier app.py :

      Ajoutez la fonction de visualisation suivante au bas du fichier :

      flask_blog/app.py

      # ....
      
      @app.route('/<int:id>/delete', methods=('POST',))
      def delete(id):
          post = get_post(id)
          conn = get_db_connection()
          conn.execute('DELETE FROM posts WHERE id = ?', (id,))
          conn.commit()
          conn.close()
          flash('"{}" was successfully deleted!'.format(post['title']))
          return redirect(url_for('index'))
      

      Cette fonction de visualisation n’accepte que les requêtes POST. Cela signifie que la navigation vers la route /ID/delete sur votre navigateur renvoie une erreur, car les navigateurs web acceptent par défaut les requêtes GET.

      Cependant, vous pouvez accéder à cette route via un formulaire qui envoie une requête POST passant l’ID de l’article que vous voulez supprimer. La fonction recevra la valeur de l’ID et l’utilisera pour récupérer l’article dans la base de données avec la fonction get_post().

      Ensuite, vous ouvrez une connexion à la base de données et exécutez une commande SQL DELETE FROM pour supprimer l’article. Vous validez la modification dans la base de données et fermez la connexion tout en faisant clignoter un message pour informer l’utilisateur que le message a été supprimé avec succès et le rediriger vers la page d’index.

      Notez que vous ne rendez pas un fichier modèle, ceci est dû au fait que vous allez juste ajouter un bouton Delete à la page d’édition.

      Ouvrez le fichier modèle edit.html :

      Ensuite, ajoutez la balise <form> suivante après la balise <hr> et directement avant la ligne {% endblock %} :

      flask_blog/templates/edit.html

      <hr>
      
      <form action="https://www.digitalocean.com/{{ url_for("delete', id=post['id']) }}" method="POST">
          <input type="submit" value="Delete Post"
                  class="btn btn-danger btn-sm"
                  onclick="return confirm('Are you sure you want to delete this post?')">
      </form>
      
      {% endblock %}
      

      Vous utilisez la méthode confirm() pour afficher un message de confirmation avant de soumettre la demande.

      Maintenant, naviguez à nouveau vers la page d’édition d’un article de blog et essayez de le supprimer :

      http://127.0.0.1:5000/1/edit
      

      À la fin de cette étape, le code source de votre projet ressemblera au code de cette page.

      Grâce à cela, les utilisateurs de votre application peuvent maintenant écrire de nouveaux articles de blog et les ajouter à la base de données, modifier et supprimer des articles existants.

      Conclusion

      Ce tutoriel a introduit les concepts essentiels du framework Flask Python. Vous avez appris à créer une petite application web, à l’exécuter dans un serveur de développement et à permettre à l’utilisateur de fournir des données personnalisées via des paramètres d’URL et des formulaires web. Vous avez également utilisé le moteur de modèles Jinja pour réutiliser les fichiers HTML et y utiliser la logique. À la fin de ce tutoriel, vous disposez maintenant d’un blog web entièrement fonctionnel qui interagit avec une base de données SQLite pour créer, afficher, modifier et supprimer des articles de blog en utilisant le langage Python et des requêtes SQL.

      Vous pouvez développer davantage cette application en ajoutant l’authentification des utilisateurs afin que seuls les utilisateurs enregistrés puissent créer et modifier des articles de blog, vous pouvez également ajouter des commentaires et des balises pour chaque article de blog, et ajouter des téléchargements de fichiers pour donner aux utilisateurs la possibilité d’inclure des images dans l’article. Pour plus d’informations, consultez la documentation Flask.

      Flask possède de nombreuses extensions Flask créées par sa communauté. Voici une liste d’extensions que vous pourriez envisager d’utiliser pour faciliter votre processus de développement :

      • Flask-Login : gère la session utilisateur et gère la connexion et la déconnexion ainsi que la mémorisation des utilisateurs connectés.
      • Flask-SQLAlchemy : simplifie l’utilisation de Flask avec SQLAlchemy, une boîte à outils SQL Python et un ORM (mappeur relationnel d’objets) pour interagir avec les bases de données SQL.
      • Flask-Mail : aide à l’envoi de messages électroniques dans votre application Flask.



      Source link

      Comment mettre en place et configurer une autorité de certification (AC) sur CentOS 8


      Introduction

      Une autorité de certification (AC) est une entité chargée d’émettre des certificats numériques pour vérifier les identités sur l’internet. Bien que les AC publiques soient un choix populaire pour vérifier l’identité des sites web et autres services qui sont fournis au grand public, les AC privées sont généralement utilisées pour les groupes fermés et les services privés.

      La création d’une autorité de certification privée vous permettra de configurer, de tester et d’exécuter des programmes qui nécessitent des connexions cryptées entre un client et un serveur. Avec une AC privée, vous pouvez émettre des certificats pour les utilisateurs, les serveurs ou les programmes et services individuels au sein de votre infrastructure.

      Quelques exemples de programmes sur Linux qui utilisent leur propre AC privée sont OpenVPN et Puppet.  Vous pouvez également configurer votre serveur web pour utiliser des certificats émis par une AC privée afin de faire correspondre les environnements de développement et de simulation aux serveurs de production qui utilisent TLS pour crypter les connexions.

      Dans ce guide, nous allons apprendre comment mettre en place une autorité de certification privée sur un serveur CentOS 8 et comment générer et signer un certificat de test en utilisant votre nouvelle AC. Vous apprendrez également comment importer le certificat public du serveur de l’AC dans le magasin de certificats de votre système d’exploitation afin de pouvoir vérifier la chaîne de confiance entre l’AC et les serveurs ou utilisateurs distants. Enfin, vous apprendrez comment révoquer des certificats et distribuer une liste de révocation de certificats pour vous assurer que seuls les utilisateurs et les systèmes autorisés peuvent utiliser les services qui reposent sur votre AC.

      Conditions préalables

      Pour suivre ce tutoriel, vous aurez besoin d’un serveur CentOS 8 avec un utilisateur sudo activé, non root et d’un pare-feu configuré avec firewalld. Vous pouvez suivre notre guide de configuration initiale de serveur avec CentOS 8 pour aborder ce tutoriel.

      Ce serveur sera appelé Serveur AC dans ce tutoriel.

      Assurez-vous que le serveur AC est un système autonome. Il ne sera utilisé que pour importer, signer et révoquer les demandes de certificats. Il ne doit pas gérer d’autres services et, dans l’idéal, il sera hors ligne ou complètement fermé lorsque vous ne travaillerez pas activement avec votre AC.

      Remarque : la dernière section de ce tutoriel est facultative si vous souhaitez en savoir plus sur la signature et la révocation des certificats. Si vous choisissez de suivre ces étapes de pratique, vous aurez besoin d’un second serveur CentOS 8 ou vous pouvez également utiliser votre propre ordinateur Linux local fonctionnant sous CentOS 8, Fedora ou un dérivé de RedHat.

      Étape 1 — Installation d’Easy-RSA

      La première tâche de ce tutoriel consiste à installer l’ensemble de scripts easy-rsa sur votre serveur d’AC. easy-rsa est un outil de gestion d’autorité de certification que vous utiliserez pour générer une clé privée et un certificat racine public, que vous utiliserez ensuite pour signer les demandes des clients et des serveurs qui s’appuieront sur votre AC.

      Le paquet easy-rsa n’est pas disponible par défaut dans CentOS 8, de sorte que vous devrez activer le référentiel Extra Packages for Enterprise Linux (EPEL) EPEL est géré par le projet Fedora et contient des paquets non standard mais populaires pour Fedora, CentOS et d’autres distributions Linux qui utilisent le format du paquet RPM. Connectez-vous à votre serveur AC en tant qu’utilisateur sudo non root que vous avez créé lors des étapes de configuration initiales et exécutez ce qui suit :

      • sudo dnf install epel-release

      Vous serez invité à télécharger le package et à l’installer. Appuyez sur y pour confirmer que vous souhaitez installer le package.

      Installez maintenant le paquet easy-rsa, en entrant à nouveau y à l’invite :

      • sudo dnf install easy-rsa

      À ce stade, vous disposez de tout ce dont vous avez besoin, installé et prêt pour utiliser Easy-RSA. Dans l’étape suivante, vous allez créer une infrastructure à clés publiques, puis vous commencerez à construire votre autorité de certification.

      Étape 2 — Préparation d’un répertoire d’infrastructures à clés publiques

      Maintenant que vous avez installé easy-rsa​​​, il est temps de créer un squelette de l’infrastructure de clés publiques (ICP) sur le serveur AC. Assurez-vous que vous êtes encore connecté en tant qu’utilisateur non root et créez un répertoire easy-rsa Assurez-vous que vous n’utilisez pas sudo pour exécuter l’une des commandes suivantes, puisque votre utilisateur normal doit gérer et interagir avec l’AC sans privilèges élevés.

      Cela créera un nouveau répertoire appelé easy-rsa dans votre dossier de base. Nous utiliserons ce répertoire pour créer des liens symboliques pointant vers les fichiers de packages easy-rsa que nous avons installés à l’étape précédente. Ces fichiers sont situés dans le dossier /usr/share/easy-rsa/3 sur le serveur AC.

      Créez les liens symboliques (symlinks) avec la commande ln :

      • ln -s /usr/share/easy-rsa/3/* ~/easy-rsa/

      Remarque : alors que d’autres guides peuvent vous demander de copier les fichiers du package easy-rsa dans votre répertoire ICP, ce tutoriel adopte une approche par lien symbolique. Par conséquent, toute mise à jour du paquet easy-rsa sera automatiquement répercutée dans les scripts de votre ICP.

      Pour restreindre l’accès à votre nouveau répertoire ICP, assurez-vous que seul le propriétaire peut y accéder en utilisant la commande chmod :

      • chmod 700 /home/sammy/easy-rsa

      Enfin, initialisez l’ICP dans le répertoire easy-rsa :

      • cd ~/easy-rsa
      • ./easyrsa init-pki

      Output

      init-pki complete; you may now create a CA or requests. Your newly created PKI dir is: /home/sammy/easy-rsa/pki

      Après avoir terminé cette section, vous disposez d’un répertoire qui contient tous les fichiers nécessaires pour créer une autorité de certification. Dans la section suivante, vous allez créer la clé privée et le certificat public pour votre AC.

      Étape 3 — Création d’une autorité de certification

      Avant de pouvoir créer la clé et le certificat privés de votre AC, vous devez créer et alimenter un fichier appelé vars avec quelques valeurs par défaut. Tout d’abord, vous allez cd dans le répertoire easy-rsa, puis vous allez créer et modifier le fichier vars avec nano ou votre éditeur de texte préféré.

      L’éditeur de texte par défaut fourni avec CentOS 8 est vi. vi, un éditeur de texte extrêmement puissant, mais il peut être difficile à utiliser pour les utilisateurs qui manquent d’expérience. Vous pouvez installer un éditeur plus adapté, tel que nano, pour faciliter l’édition des fichiers de configuration sur votre serveur CentOS 8 :

      Lorsque vous êtes invité à installer nano, entrez y pour poursuivre les étapes d’installation. Maintenant, vous êtes prêt à modifier le fichier vars :

      Une fois le fichier ouvert, collez les lignes suivantes et modifiez chaque valeur mise en évidence pour refléter les informations de votre propre organisation. L’important ici est de veiller à ne laisser aucune des valeurs en blanc :

      ~/easy-rsa/vars

      set_var EASYRSA_REQ_COUNTRY "US" set_var EASYRSA_REQ_PROVINCE "NewYork" set_var EASYRSA_REQ_CITY "New York City" set_var EASYRSA_REQ_ORG "DigitalOcean" set_var EASYRSA_REQ_EMAIL "admin@example.com" set_var EASYRSA_REQ_OU "Community" set_var EASYRSA_ALGO "ec" set_var EASYRSA_DIGEST "sha512"

      Lorsque vous avez terminé, enregistrez et fermez le fichier. Si vous utilisez nano, vous pouvez le faire en appuyant sur CTRL+X, puis Y et ENTER (ENTRÉE) pour confirmer. Vous êtes maintenant prêt à construire votre AC.

      Pour créer la paire de clés root public et privé pour votre autorité de certification, exécutez à nouveau la commande ./easy-rsa, cette fois-ci avec l’option build-ca :

      Dans la sortie, vous verrez quelques lignes sur la version OpenSSL et vous serez invité à entrer une phrase de passe pour votre paire de clés. Assurez-vous de choisir une phrase de passe solide, et notez-le dans un endroit sûr. Vous devrez saisir la phrase de passe chaque fois vous devrez interagir avec votre AC, par exemple pour signer ou révoquer un certificat.

      Il vous sera également demandé de confirmer le Nom commun (CN) de votre AC. Le nom commun est le nom utilisé pour désigner cette machine dans le contexte de l’autorité de certification. Vous pouvez saisir n’importe quelle chaîne de caractères pour le nom commun de l’AC mais, par souci de simplicité, appuyez sur ENTER (ENTRÉE) pour accepter le nom par défaut.

      Output

      . . . Enter New CA Key Passphrase: Re-Enter New CA Key Passphrase: . . . Common Name (eg: your user, host, or server name) [Easy-RSA CA]: CA creation complete and you may now import and sign cert requests. Your new CA certificate file for publishing is at: /home/sammy/easy-rsa/pki/ca.crt

      Remarque : Si vous ne voulez pas qu’un mot de passe vous soit demandé à chaque fois que vous interagissez avec votre AC, vous pouvez exécuter la commande build-ca avec l’option nopass, comme ceci :

      • ./easyrsa build-ca nopass

      Vous disposez maintenant de deux fichiers importants – ~/easy-rsa/pki/ca.crt et ~/easy-rsa/pki/private/ca.key – qui constituent les composants publics et privés d’une autorité de certification.

      • ca.crt est le fichier de certificats public de l’AC. Les utilisateurs, les serveurs et les clients utiliseront ce certificat pour vérifier qu’ils font partie du même réseau de confiance. Chaque utilisateur et serveur qui utilise votre AC devront avoir une copie de ce fichier. Toutes les parties s’appuieront sur le certificat public pour s’assurer qu’une personne ne se fait pas passer pour un système et n’effectue pas une attaque de type Man-in-the-middle.

      • ca.key est la clé privée que l’AC utilise pour signer les clés et les certificats des serveurs et des clients. Si un intrus accède à votre AC et, à son tour, à votre fichier ca.key, vous devrez détruire votre AC. C’est pourquoi votre fichier ca.key ne doit se trouver que sur votre machine AC et votre machine AC doit idéalement être maintenue hors ligne lorsqu’elle ne signe pas de demandes de certificat, par mesure de sécurité supplémentaire.

      Avec cela, votre AC est en place et elle est prête à être utilisée pour signer des demandes de certificats et pour révoquer des certificats.

      Étape 4 — Distribuer le certificat public de votre autorité de certification

      Votre AC est maintenant configurée et prête à agir comme une racine de confiance pour tous les systèmes que vous voulez configurer pour l’utiliser. Vous pouvez ajouter le certificat de l’AC à vos serveurs OpenVPN, serveurs web, serveurs de messagerie, etc. Tout utilisateur ou serveur qui doit vérifier l’identité d’un autre utilisateur ou serveur de votre réseau devrait avoir une copie du fichier ca.crt importé dans le magasin de certificats de son système d’exploitation.

      Pour importer le certificat public de l’AC dans un deuxième système Linux comme un autre serveur ou un ordinateur local, obtenez d’abord une copie du fichier ca.crt de votre serveur AC. Vous pouvez utiliser la commande cat pour le sortir dans un terminal, puis le copier et le coller dans un fichier sur le deuxième ordinateur qui importe le certificat. Vous pouvez également utiliser des outils comme scp, rsync pour transférer le fichier entre les systèmes. Cependant, nous utiliserons un copier-coller avec nano dans cette étape car cela fonctionne sur tous les systèmes.

      En tant qu’utilisateur non root sur le serveur AC, exécutez la commande suivante :

      • cat ~/easy-rsa/pki/ca.crt

      Il y aura une sortie dans votre terminal qui ressemblera à ce qui suit :

      Output

      -----BEGIN CERTIFICATE----- MIIDSzCCAjOgAwIBAgIUcR9Crsv3FBEujrPZnZnU4nSb5TMwDQYJKoZIhvcNAQEL BQAwFjEUMBIGA1UEAwwLRWFzeS1SU0EgQ0EwHhcNMjAwMzE4MDMxNjI2WhcNMzAw . . . . . . -----END CERTIFICATE-----

      Copiez tout, y compris les lignes -----BEGIN CERTIFICATE-----​​​ et –-----END CERTIFICATE----- et les tirets.

      Sur votre deuxième système Linux, utilisez nano ou votre éditeur de texte préféré pour ouvrir un fichier appelé /tmp/ca.crt :

      Collez le contenu que vous venez de copier du serveur AC dans l’éditeur. Lorsque vous avez terminé, enregistrez et fermez le fichier. Si vous utilisez nano, vous pouvez le faire en appuyant sur CTRL+X, puis Y et ENTER (ENTRÉE) pour confirmer.

      Maintenant que vous disposez d’une copie du fichier ca.crt sur votre deuxième système Linux,il est temps d’importer le certificat dans le magasin de certificats de son système d’exploitation.

      Sur CentOS, Fedora ou d’autres systèmes Linux dérivés de RedHat, exécutez les commandes suivantes pour importer le certificat :

      CentOS, Fedora, RedHat distributions

      • sudo cp /tmp/ca.crt /etc/pki/ca-trust/source/anchors/
      • update-ca-trust

      Pour importer le certificat du serveur AC sur un système basé sur Debian ou Ubuntu, copiez et collez le contenu du fichier sur le système tout comme dans l’exemple précédent dans un fichier appelé /tmp/ca.crt. Ensuite, copiez le certificat dans /usr/local/share/ca-certificates/, puis exécutez la commande update-ca-certificates.

      Debian and Ubuntu derived distributions

      • sudo cp /tmp/ca.crt /usr/local/share/ca-certificates/
      • update-ca-certificates

      Votre deuxième système Linux fera maintenant confiance à tout certificat qui a été signé par le serveur AC.

      Remarque : si vous utilisez votre AC avec des serveurs web et si vous utilisez le navigateur Firefox, vous devrez importer directement le certificat ca.crt public dans Firefox. Firefox n’utilise pas le magasin de certificats du système d’exploitation local. Pour plus de détails sur la façon d’ajouter le certificat de votre AC à Firefox, veuillez consulter cet article de Mozilla sur la configuration des autorités de certification (AC) dans Firefox.

      Si vous utilisez votre AC pour intégrer un environnement Windows ou des ordinateurs de bureau, veuillez consulter la documentation sur la façon d’utiliser certutil.exe pour installer un certificat d’AC.

      Si vous utilisez ce tutoriel comme condition préalable à un autre tutoriel, ou si vous savez comment signer et révoquer des certificats, vous pouvez vous arrêter ici. Si vous souhaitez en savoir plus sur la façon de signer et de révoquer des certificats, la section facultative suivante vous expliquera chaque processus en détail.

      (Facultatif) — Création de demandes de signature de certificats et révocation des certificats

      Les sections suivantes du tutoriel sont facultatives. Si vous avez effectué toutes les étapes précédentes, vous disposez d’une autorité de certification entièrement configurée et opérationnelle que vous pouvez utiliser comme condition préalable pour d’autres tutoriels. Vous pouvez importer le fichier ca.crt de votre AC et vérifier dans votre réseau les certificats qui ont été signés par votre AC.

      Si vous souhaitez vous entraîner et en savoir plus sur la manière de signer des demandes de certificat et sur la manière de révoquer des certificats, ces sections facultatives vous expliqueront comment fonctionnent les deux processus.

      (Facultatif) — Création et signature d’une demande de certificat de pratique

      Maintenant que vous avez une AC prête à l’emploi, vous pouvez vous entraîner à générer une clé privée et une demande de certificat pour vous familiariser avec le processus de signature et de distribution.

      Une demande de signature de certificat (CSR) se compose de trois parties : une clé publique, des informations d’identification sur le système requérant, et une signature de la requête elle-même, qui est créée en utilisant la clé privée de la partie requérante. La clé privée sera gardée secrète et sera utilisée pour chiffrer les informations que toute personne possédant le certificat public signé pourra ensuite déchiffrer.

      Les étapes suivantes seront exécutées sur votre deuxième système Linux fonctionnant sous CentOS, Fedora ou une autre distribution Linux dérivée de RedHat. Il peut s’agir d’un autre serveur distant, ou d’une machine Linux locale comme un ordinateur portable ou un ordinateur de bureau. Comme easy-rsa n’est pas disponible par défaut sur tous les systèmes, nous utiliserons l’outil openssl pour créer une clé privée et un certificat de pratique.

      openssl est généralement installé par défaut sur la plupart des distributions Linux, mais juste pour en être certain, exécutez ce qui suit sur votre système

      Lorsque vous êtes invité à installer openssl, entrez y pour poursuivre les étapes d’installation.  Maintenant, vous êtes prêt à créer une pratique CSR avec openssl.

      La première étape que vous devez suivre pour créer une CSR est la génération d’une clé privée. Pour créer une clé privée en utilisant openssl, créez un répertoire “practice-csr” et générez ensuite une clé à l’intérieur de celui-ci. Nous allons faire cette requête pour un serveur fictif appelé sammy-server, par opposition à la création d’un certificat qui est utilisé pour identifier un utilisateur ou une autre AC.

      • mkdir ~/practice-csr
      • cd ~/practice-csr
      • openssl genrsa -out sammy-server.key

      Output

      Generating RSA private key, 2048 bit long modulus (2 primes) . . . . . . e is 65537 (0x010001)

      Maintenant que vous avez une clé privée, vous pouvez créer une CSR correspondante, à nouveau en utilisant l’utilitaire openssl. Vous serez invité à remplir un certain nombre de champs comme Pays, État et Ville. Vous pouvez saisir un . si vous souhaitez laisser un champ vide, mais sachez que s’il s’agit d’une véritable CSR, il est préférable d’utiliser les valeurs correctes de votre localisation et votre organisation :

      • openssl req -new -key sammy-server.key -out sammy-server.req

      Output

      . . . ----- Country Name (2 letter code) [XX]:US State or Province Name (full name) []:New York Locality Name (eg, city) [Default City]:New York City Organization Name (eg, company) [Default Company Ltd]:DigitalOcean Organizational Unit Name (eg, section) []:Community Common Name (eg, your name or your server's hostname) []:sammy-server Email Address []: Please enter the following 'extra' attributes to be sent with your certificate request A challenge password []: An optional company name []:

      Si vous souhaitez ajouter automatiquement ces valeurs dans le cadre de l’invocation openssl plutôt que via l’invite interactive, vous pouvez passer l’argument -subj à OpenSSL. Assurez-vous de modifier les valeurs mises en évidence pour qu’elles correspondent à votre lieu d’exercice, à votre organisation et au nom de votre serveur :

      • openssl req -new -key sammy-server.key -out sammy-server.req -subj
      • /C=US/ST=New York/L=New York City/O=DigitalOcean/OU=Community/CN=sammy-server

      Pour vérifier le contenu d’une CSR, vous pouvez lire dans un fichier de requête avec openssl et examiner les champs à l’intérieur

      • openssl req -in sammy-server.req -noout -subject

      Output

      subject=C = US, ST = New York, L = New York City, O = DigitalOcean, OU = Community, CN = sammy-server

      Une fois que vous êtes satisfait de l’objet de votre demande de certificat de pratique, copiez le fichier sammy-server.req sur votre serveur AC en utilisant scp

      • scp sammy-server.req sammy@your_ca_server_ip:/tmp/sammy-server.req

      Au cours de cette étape, vous avez généré une demande de signature de certificat pour un serveur fictif appelé sammy-server. Dans un scénario réel, la demande peut provenir d’un serveur web de développement ou de simulation qui a besoin d’un certificat TLS pour des tests, ou d’un serveur OpenVPN qui demande un certificat pour que les utilisateurs puissent se connecter à un VPN. Au cours de l’étape suivante, nous allons passer à la signature de la demande de signature de certificat en utilisant la clé privée du serveur AC.

      (Facultatif) – Signature d’une CSR

      Dans l’étape précédente, vous avez créé une demande de certificat de pratique et une clé pour un serveur fictif. Vous l’avez copiée dans le répertoire /tmp de votre serveur AC, en émulant le processus que vous utiliseriez si vous aviez de vrais clients ou serveurs vous envoyant des demandes de CSR qui doivent être signées.

      Poursuivant le scénario fictif, le serveur AC doit maintenant importer le certificat de pratique et le signer. Une fois qu’une demande de certificat est validée par l’AC et relayée à un serveur, les clients qui font confiance à l’autorité de certification pourront également faire confiance au certificat nouvellement émis.

      Comme nous opérerons au sein de l’ICP de l’AC où l’utilitaire easy-rsa est disponible, les étapes de signature utiliseront l’utilitaire easy-rsa pour faciliter les choses, au lieu d’utiliser directement openssl comme nous l’avons fait dans l’exemple précédent.

      La première étape pour signer la CSR fictive est d’importer la demande de certificat en utilisant le script easy-rsa

      • cd ~/easy-rsa
      • ./easyrsa import-req /tmp/sammy-server.req sammy-server

      Output

      . . . The request has been successfully imported with a short name of: sammy-server You may now use this name to perform signing operations on this request.

      Maintenant, vous pouvez signer la demande en exécutant le script easyrsa avec l’option sign-req suivi du type de requête et du nom commun qui est inclus dans la CSR. Le type de requête peut soit être client, server, ou ca. Comme nous nous entraînons avec un certificat pour un serveur fictif, assurez-vous d’utiliser le type de requête du serveur :

      • ./easyrsa sign-req server sammy-server

      Dans la sortie, il vous sera demandé de vérifier que la requête provient d’une source fiable. Tapez yes puis appuyez sur ENTER pour confirmer :

      Output

      You are about to sign the following certificate. Please check over the details shown below for accuracy. Note that this request has not been cryptographically verified. Please be sure it came from a trusted source or that you have verified the request checksum with the sender. Request subject, to be signed as a server certificate for 3650 days: subject= commonName = sammy-server Type the word 'yes' to continue, or any other input to abort. Confirm request details: yes . . . Certificate created at: /home/sammy/easy-rsa/pki/issued/sammy-server.crt

      Si vous avez crypté votre clé AC, on vous demandera votre mot de passe à ce stade.

      Une fois ces étapes terminées, vous avez signé la CSR sammy-server.req en utilisant la clé privée du serveur AC dans /home/sammy/easy-rsa/pki/private/ca.key. Le fichier sammy-server.crt qui en résulte contient la clé de chiffrement publique du serveur de pratique, ainsi qu’une nouvelle signature du serveur AC. Le but de la signature est de dire à toute personne qui fait confiance à l’AC qu’elle peut également faire confiance au certificat du serveur de pratique sammy-server.

      Si cette requête concerne un vrai serveur comme un serveur web ou un serveur VPN, la dernière étape sur le serveur AC serait de distribuer les nouveaux fichiers sammy-server.crt et ca.crt du serveur AC au serveur distant qui a fait la requête CSR :

      • scp pki/issued/sammy-server.crt sammy@your_server_ip:/tmp
      • scp pki/ca.crt sammy@your_server_ip:/tmp

      À ce stade, vous devriez pouvoir utiliser le certificat délivré avec quelque chose comme un serveur web, un VPN, un outil de gestion de configuration, un système de base de données, ou à des fins d’authentification de clients.

      (Facultatif) — Révocation d’un certificat

      Il peut arriver que vous deviez révoquer un certificat pour empêcher un utilisateur ou un serveur de l’utiliser. Il se peut que l’ordinateur portable de quelqu’un ait été volé, qu’un serveur web ait été compromis, ou qu’un employé ou un contractant ait quitté votre organisation.

      Pour révoquer un certificat, la procédure générale suit les étapes suivantes :

      1. Révoquez le certificat avec la commande ./easyrsa revoke client_name
      2. Générer une nouvelle LRC avec la commande ./easyrsa gen-crl
      3. Transférez le fichier crl.pem mis à jour vers le ou les serveurs qui dépendent de votre AC, et sur ces systèmes, copiez le fichier dans le ou les répertoires requis pour les programmes qui s’y réfèrent.
      4. Redémarrez tous les services qui utilisent votre AC et le fichier LRC.

      Vous pouvez utiliser ce processus pour révoquer à tout moment les certificats que vous avez précédemment émis. Nous allons passer en détail chaque étape dans les sections suivantes, en commençant par la commande revoke

      Révoquer un certificat

      Pour révoquer un certificat, naviguez vers le répertoire easy-rsa sur votre serveur AC :

      Ensuite, lancez le script easyrsa avec l’option revoke, suivi du nom du client que vous souhaitez révoquer : En suivant l’exemple de pratique ci-dessus, le nom commun du certificat est sammy-server :

      • ./easyrsa revoke sammy-server

      Il vous sera demandé de confirmer la révocation en entrant yes :

      Output

      Please confirm you wish to revoke the certificate with the following subject: subject= commonName = sammy-server Type the word 'yes' to continue, or any other input to abort. Continue with revocation: yes . . . Revoking Certificate 8348B3F146A765581946040D5C4D590A . . .

      Notez la valeur mise en évidence sur la ligne Revoking Certificate Cette valeur est le numéro de série unique du certificat qui est en cours de révocation. Si vous voulez examiner la liste de révocation à la dernière étape de cette section pour vérifier que le certificat y figure, vous aurez besoin de cette valeur.

      Après avoir confirmé l’action, l’AC va révoquer le certificat. Cependant, les systèmes distants qui dépendent de l’AC n’ont aucun moyen de vérifier si des certificats ont été révoqués. Les utilisateurs et les serveurs pourront toujours utiliser le certificat jusqu’à ce que la liste des certificats révoqués (LCR) de l’AC soit distribuée à tous les systèmes qui dépendent de l’AC.

      Dans l’étape suivante, vous allez générer une LCR ou mettre à jour un fichier crl.pem existant.

      Générer une liste de révocation de certificat

      Maintenant que vous avez révoqué un certificat, il est important de mettre à jour la liste des certificats révoqués sur votre serveur AC. Une fois que vous aurez mis à jour la liste des révocations, vous serez en mesure de savoir quels utilisateurs et quels systèmes ont des certificats valides dans votre AC.

      Pour générer une LRC, exécutez la commande easy-rsa avec l’option gen-crl tout en restant dans le répertoire ~/easy-rsa :

      Si vous avez utilisé une phrase de passe lors de la création de votre fichier ca.key, vous serez invité à l’entrer. La commande gen-crl générera un fichier appelé crl.pem, contenant la liste actualisée des certificats révoqués pour cette AC.

      Ensuite, vous devrez transférer le fichier crl.pem mis à jour à tous les serveurs et clients qui dépendent de cette AC a chaque fois que vous exécuterez la commande gen-crl.  Sinon, les clients et les systèmes pourront toujours accéder aux services et aux systèmes qui utilisent votre AC, puisque ces services doivent connaître le statut de révocation du certificat.

      Transférer une liste de révocation de certificat

      Maintenant que vous avez généré une LCR sur le serveur de votre AC, vous devez la transférer vers les systèmes distants qui dépendent de votre AC. Pour transférer ce fichier à vos serveurs, vous pouvez utiliser la commande scp.

      Remarque : ce tutoriel explique comment générer et distribuer manuellement une LCR. Bien qu’il existe des méthodes plus solides et automatisées pour distribuer et vérifier les listes de révocation, comme l’agrafage OCSP, la configuration de ces méthodes dépasse le cadre de cet article.

      Assurez-vous que vous êtes connecté à votre serveur AC en tant qu’utilisateur non racine et exécutez les opérations suivantes, en substituant l’IP ou le nom DNS de votre propre serveur à la place de your_server_ip :

      • scp ~/easy-rsa/pki/crl.pem sammy@your_server_ip:/tmp

      Maintenant que le fichier est sur le système distant, la dernière étape consiste à mettre à jour tous les services avec la nouvelle copie de la liste de révocation.

      Mise à jour des services qui prennent en charge une LCR

      L’énumération des étapes à suivre pour mettre à jour les services qui utilisent le fichier crl.pem dépasse la portée de ce tutoriel.  En général, vous devrez copier le fichier crl.pem à l’emplacement prévu par le service, puis le redémarrer à l’aide de systemctl.

      Une fois que vous aurez mis à jour vos services avec le nouveau fichier crl.pem, vos services pourront rejeter les connexions des clients ou des serveurs qui utilisent un certificat révoqué.

      Examen et vérification du contenu d’une LCR

      Si vous souhaitez examiner un fichier CRL, par exemple pour confirmer une liste de certificats révoqués, utilisez la commande openssl suivante à partir de votre répertoire easy-rsa sur votre serveur AC :

      • cd ~/easy-rsa
      • openssl crl -in pki/crl.pem -noout -text

      Vous pouvez également exécuter cette commande sur tout serveur ou système qui dispose de l’outil openssl installé avec une copie du fichier crl.pem. Par exemple, si vous avez transféré le fichier crl.pem sur votre second système et que vous souhaitez vérifier que le certificat de sammy-server est révoqué, vous pouvez utiliser une commande openssl comme celle qui suit, en introduisant le numéro de série que vous avez noté précédemment lorsque vous avez révoqué le certificat à la place de numéro mis en évidence ici :

      • openssl crl -in /tmp/crl.pem -noout -text |grep -A 1 8348B3F146A765581946040D5C4D590A

      Output

      Serial Number: 8348B3F146A765581946040D5C4D590A Revocation Date: Apr 1 20:48:02 2020 GMT

      Remarquez comment la commande grep est utilisée pour vérifier le numéro de série unique que vous avez noté dans l’étape de révocation. Vous pouvez maintenant vérifier le contenu de votre liste de révocation de certificat sur tout système qui s’appuie sur elle pour restreindre l’accès aux utilisateurs et aux services.

      Conclusion

      Dans ce tutoriel, vous avez créé une autorité de certification privée en utilisant le package Easy-RSA sur un serveur CentOS 8 autonome. Vous avez appris comment fonctionne le modèle de confiance entre les parties qui s’appuient sur l’autorité de certification.  Vous avez également créé et signé une demande de signature de certificat (CSR) pour un serveur de pratique, puis appris à révoquer un certificat. Enfin, vous avez appris comment générer et distribuer une liste de révocation de certificats (LRC) pour tout système qui dépend de votre AC afin de s’assurer que les utilisateurs ou les serveurs qui ne devraient pas accéder aux services en soient empêchés.

      Vous pouvez maintenant délivrer des certificats pour les utilisateurs et les utiliser avec des services comme OpenVPN. Vous pouvez également utiliser votre AC pour configurer des serveurs web de développement et de simulation avec des certificats afin de sécuriser vos environnements de non-production. L’utilisation d’une AC avec des certificats TLS pendant le développement peut contribuer à garantir que votre code et vos environnements correspondent autant que possible à votre environnement de production.

      Si vous souhaitez en savoir plus sur l’utilisation d’OpenSSL, consultez notre page sur les principes essentiels d’OpenSSL : Travailler avec les certificats SSL, les clés privées et les CSR contient de nombreuses informations supplémentaires pour vous aider à vous familiariser avec les principes fondamentaux d’OpenSSL.



      Source link