\documentclass{beamer}
%\documentclass[handout]{beamer}
%\usepackage{pgfpages}
%\pgfpagesuselayout{2 on 1}[a4paper,border shrink=5mm]

\usetheme{JuanLesPins}
\usepackage[french]{babel}
\usepackage[utf8x]{inputenc}
\usepackage{bortzmeyer-utils}

\title{Hypertext Transfer Protocol}
\author{Stéphane Bortzmeyer\\\texttt{stephane+cnam@bortzmeyer.org}}
\date{CNAM, 20 avril 2022}

%\setlength{\parskip}{1ex plus 0.5ex minus 0.2ex} 
% \setlength{\parskip}{15pt} 
\setlength{\parskip}{15pt plus 10pt minus 10pt} 
\setbeamersize{text margin left=0.2cm,text margin right=1.8cm}

\begin{document}

\maketitle

\expandafter\def\expandafter\insertshorttitle\expandafter{%
       \insertshorttitle\hfill%
       \insertframenumber\,/\,\inserttotalframenumber}

\begin{frame}
  \frametitle{Auteur du livre « Cyberstructure »}
  Chez C\&F Éditions. \url{https://cyberstructure.fr/}
  \includegraphics[scale=0.23]{cyberstructure.png}
  
\end{frame}

\AtBeginSection[]
{
\begin{frame}
    \frametitle{Plan du tutoriel}
    \tableofcontents[currentsection]
\end{frame}
}

\section{À quoi sert HTTP ?}

\begin{frame}
  \frametitle{Généralités}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
      \item On parlera bien de HTTP, pas du Web en général,
      \item<2->Protocole de couche 7 (Application),
      \item<3->Transfert de fichiers, simple,
      \item<4->Agnostique par rapport au contenu du fichier transféré,  
      \item<5->Créé pour le Web, mais peut s'utiliser ailleurs. 
      \end{itemize}
  \end{overlayarea}
\end{frame}

\section{Comment marche HTTP ?}

\begin{frame}
  \frametitle{Un protocole client/serveur}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
      \item<2->HTTP est requête/réponse,
        \item<3->Asymétrique (client/serveur),
        \item<4->Le \emph{client} ouvre une connexion avec le
          \emph{serveur} ou utilise une connexion existante,
        \item<5->Le client envoie une requête,
        \item<6->Le serveur envoie une réponse (comportant parfois un
          corps),
        \item<7->Peut ensuite dire au revoir (pas de notion de session).
      \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{HTTP, c'est simple}
  \includegraphics[scale=0.54]{http.pdf}
\end{frame}

\begin{frame}
  \frametitle{La requête}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
      \item<2->HTTP agit sur des \emph{ressources}\only<2->{ (exemple : une page
        Web est une ressource)},
      \item<3->La requête comprend une \emph{méthode} comme \computer{GET}
          (récupérer), \computer{PUT} (mettre), \computer{POST}
        (modifier)…
      \item<4->Et un chemin désignant la ressource,  
      \item<5->Et des \emph{en-têtes} pour indiquer… un peu de tout.
      \item<6->Les en-têtes : \{nom, valeur\},  
      \item<7->Exemples d'en-têtes : \computer{User-Agent} (type de
        logiciel client), \computer{Accept} (formats
        acceptés)…
      \item<8->Parfois un corps (charge utile, par exemple un fichier
        qu'on \computer{PUT}).
      \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{La réponse}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
        \item<2->La réponse comprend un code de retour en trois
          chiffres,
        \item<3->Des en-têtes,
        \item<4->Exemples d'en-têtes : \computer{Last-Modified}
          (dernière modification de la ressource),
          \computer{Content-Length} (taille de la ressource),
          \computer{Content-Type} (type de la ressource)…
        \item<5->Souvent un corps.  
      \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{Les codes de retour}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
      \item<2->Trois chiffres, le premier indique la catégorie (2xx,
        ça va, 4xx, vous avez fait une erreur, 5xx, j'ai fait une
        erreur…)
      \item<3->Quelques codes fameux (et merci à \url{https://http.cat/}).
      \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{200 OK}
  \includegraphics[scale=0.34]{200.jpg}
\end{frame}

\begin{frame}
  \frametitle{403 Forbidden}
  \includegraphics[scale=0.34]{403.jpg}
\end{frame}

\begin{frame}
  \frametitle{404 Not Found}
  \includegraphics[scale=0.34]{404.jpg}
\end{frame}

\begin{frame}
  \frametitle{500 Internal Server Error}
  \includegraphics[scale=0.34]{500.jpg}
\end{frame}

\begin{frame}
  \frametitle{HTTP 1… 2… 3…}
   \begin{overlayarea}{\textwidth}{.6\textheight}
  Il existe aujourd'hui trois versions de HTTP, qui coexistent.
     \begin{enumerate}
     \item HTTP/1
     \item HTTP/2
     \item HTTP/3  
     \end{enumerate}
     Les trois vont rester longtemps. 
   \end{overlayarea}  
\end{frame}

\begin{frame}
  \frametitle{L'encodage des requêtes et réponses}
   \begin{overlayarea}{\textwidth}{.6\textheight}
     \begin{itemize}
     \item<2->En HTTP/1, c'est du texte,
     \item<3->On peut donc utiliser un client réseau générique comme
       telnet ou netcat,
     \item<4->Trivial à programmer et déboguer,  
     \item<5->En HTTP/2 et HTTP/3, encodage binaire,
     \item<6->Plus efficace mais moins pratique.  
     \end{itemize}
   \end{overlayarea}  
\end{frame}

\begin{frame}
  \frametitle{Le transport}
   \begin{overlayarea}{\textwidth}{.6\textheight}
     \begin{itemize}
     \item<2->En HTTP/1 et HTTP/2, HTTP fonctionne sur TCP,
     \item<3->En HTTP/1, requêtes et réponses sur une même connexion
       sont séquentielles,
     \item<4->Mais partiellement parallèles en HTTP/2,
     \item<5->HTTP/3 utilise QUIC,
     \item<6->Maximum de parallélisme : une requête lente ou une perte
       de paquets n'affecte pas les autres requêtes.  
     \end{itemize}
   \end{overlayarea}  
\end{frame}

\begin{frame}[fragile]
  \frametitle{Vu avec curl}
  \begin{info}
% curl -v http://www.cnam.fr/
* Connected to www.cnam.fr (163.173.128.40) port 80 (#0)
> GET / HTTP/1.1
> Host: www.cnam.fr
> User-Agent: curl/7.52.1
> Accept: */*
> 
< HTTP/1.1 200 OK
< Date: Mon, 08 Apr 2019 15:14:12 GMT
< Server: Apache/2.4.10 (Debian)
< Set-Cookie: JSESSIONID=F70B19A7BFFFD3FB25C139FFA7527B6D.abeliap; Path=/; HttpOnly
< Vary: Accept-Encoding
< Connection: close
< Transfer-Encoding: chunked
< Content-Type: text/html;charset=UTF-8
< Set-Cookie: SERVERID=abeliap; path=/
< Cache-control: private
<
<!DOCTYPE html>
   <title>Cnam - Portail national - Conservatoire national des arts et métiers | Accueil</title>
  \end{info}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Vu avec tshark, www.internic.net} % Ou bien
                                % http://www.syfy.fr/ pour avoir IPv6
                                % mais pas HTTPS
  \begin{info}
% tshark -r http.pcap 
1 2001:67c:1348:7::86:133 → 2620:0:2d0:200::9 TCP 94 60900 → 80 [SYN] Seq=0 Win=28800 Len=0 MSS=1440 SACK_PERM=1 TSval=863052056 TSecr=0 WS=128
2 2620:0:2d0:200::9 → 2001:67c:1348:7::86:133 TCP 94 80 → 60900 [SYN, ACK] Seq=0 Ack=1 Win=23040 Len=0 MSS=1440 WS=512 SACK_PERM=1 TSval=4254146387 TSecr=863052056
3 2001:67c:1348:7::86:133 → 2620:0:2d0:200::9 TCP 86 60900 → 80 [ACK] Seq=1 Ack=1 Win=28800 Len=0 TSval=863052095 TSecr=4254146387
4 2001:67c:1348:7::86:133 → 2620:0:2d0:200::9 HTTP 166 GET / HTTP/1.1 
5 2620:0:2d0:200::9 → 2001:67c:1348:7::86:133 TCP 86 80 → 60900 [ACK] Seq=1 Ack=81 Win=23040 Len=0 TSval=4254146543 TSecr=863052095
6 2620:0:2d0:200::9 → 2001:67c:1348:7::86:133 TCP 1484 HTTP/1.1 200 OK  [TCP segment of a reassembled PDU]
7 2001:67c:1348:7::86:133 → 2620:0:2d0:200::9 TCP 86 60900 → 80 [ACK] Seq=81 Ack=1399 Win=31744 Len=0 TSval=863052135 TSecr=4254146544
8 2620:0:2d0:200::9 → 2001:67c:1348:7::86:133 TCP 1514 80 → 60900 [ACK] Seq=1399 Ack=81 Win=23040 Len=1428 TSval=4254146544 TSecr=863052095 [TCP segment of a reassembled PDU]
9 2001:67c:1348:7::86:133 → 2620:0:2d0:200::9 TCP 86 60900 → 80 [ACK] Seq=81 Ack=2827 Win=34560 Len=0 TSval=863052135 TSecr=4254146544
10 2620:0:2d0:200::9 → 2001:67c:1348:7::86:133 HTTP 6861 HTTP/1.1 200 OK  (text/html)
11 2001:67c:1348:7::86:133 → 2620:0:2d0:200::9 TCP 86 60900 → 80 [ACK] Seq=81 Ack=9602 Win=48128 Len=0 TSval=863052135 TSecr=4254146545
12 2001:67c:1348:7::86:133 → 2620:0:2d0:200::9 TCP 86 60900 → 80 [FIN, ACK] Seq=81 Ack=9602 Win=48128 Len=0 TSval=863052135 TSecr=4254146545
13 2620:0:2d0:200::9 → 2001:67c:1348:7::86:133 TCP 86 80 → 60900 [ACK] Seq=9602 Ack=82 Win=23040 Len=0 TSval=4254146701 TSecr=863052135
14 2620:0:2d0:200::9 → 2001:67c:1348:7::86:133 TCP 86 80 → 60900 [FIN, ACK] Seq=9602 Ack=82 Win=23040 Len=0 TSval=4254146702 TSecr=863052135
15 2001:67c:1348:7::86:133 → 2620:0:2d0:200::9 TCP 86 60900 → 80 [ACK] Seq=82 Ack=9603 Win=48128 Len=0 TSval=863052174 TSecr=4254146702    
  \end{info}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Exemple de requête}
  \begin{info}
Internet Protocol Version 6, Src: 2001:67c:1348:7::86:133, Dst: 2620:0:2d0:200::9
    Next Header: TCP (6)
    Source: 2001:67c:1348:7::86:133
    Destination: 2620:0:2d0:200::9
Transmission Control Protocol, Src Port: 60900, Dst Port: 80, Seq: 1, Ack: 1, Len: 80
    Source Port: 60900
    Destination Port: 80
    TCP payload (80 bytes)
Hypertext Transfer Protocol
    GET / HTTP/1.1\r\n
        [Expert Info (Chat/Sequence): GET / HTTP/1.1\r\n]
            [GET / HTTP/1.1\r\n]
            [Severity level: Chat]
            [Group: Sequence]
        Request Method: GET
        Request URI: /
        Request Version: HTTP/1.1
    Host: www.internic.net\r\n
    User-Agent: curl/7.52.1\r\n
    Accept: */*\r\n
    \r\n
    [Full request URI: http://www.internic.net/]
  \end{info}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Exemple de réponse}
  \begin{info}
Internet Protocol Version 6, Src: 2620:0:2d0:200::9, Dst: 2001:67c:1348:7::86:133
    Next Header: TCP (6)
    Source: 2620:0:2d0:200::9
    Destination: 2001:67c:1348:7::86:133
Transmission Control Protocol, Src Port: 80, Dst Port: 60900, Seq: 2827, Ack: 81, Len: 6775
    Source Port: 80
    Destination Port: 60900
    TCP payload (6775 bytes)
Hypertext Transfer Protocol
    HTTP/1.1 200 OK\r\n
    Date: Mon, 08 Apr 2019 15:29:00 GMT\r\n
    Content-Type: text/html; charset=UTF-8\r\n
    Last-Modified: Sun, 11 Jun 2017 00:01:00 GMT\r\n
    Content-Length: 9133\r\n
    \r\n
    <!DOCTYPE html>\n
    <html>\n
    <head>\n
    <title>InterNIC | The Internet's Network Information Center</title>\n    
  \end{info}
\end{frame}

\begin{frame}
  \frametitle{Mais comment le client savait quelle version utiliser ?}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
      \item<2->« Redirection » par le serveur via l'en-tête
        \computer{Alt-Svc},
      \item<3->Information dans le DNS (type d'enregistrement \computer{HTTPS}).  
      \end{itemize}
  \end{overlayarea}
\end{frame}

\section{Web, REST, transferts, les usages}

\begin{frame}
  \frametitle{Le Web classique}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
      \item<2->Un navigateur Web sert de client,
      \item<3->Il récupère de l'HTML et l'affiche,
      \item<4->HTTP ne fait « que » le transfert de fichiers.  
      \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{Transfert de fichiers}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
        \item<2->HTTP peut transférer du contenu, même en dehors de
          tout navigateur Web,
        \item<3->Exemple : mise à jour de logiciel\only<3>{ (sur
          Debian, sources HTTP dans \path{/etc/apt/sources.list})},
        \item<4->Exemple : le logiciel de gestion de versions Git
          récupérant un dépôt en HTTP :
      \end{itemize}
    \only<4>{\includegraphics[scale=0.32]{http-git.png}}
    \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{REST}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
        \item<2->REST\only<2>{ (\foreign{Representational state
            transfer})} est une architecture d'accès à des services au-dessus de HTTP,
        \item<3->Les méthodes HTTP sont utilisées par exemple pour mettre en œuvre
          les opérations CRUD (\foreign{Create}, \foreign{Read},
          \foreign{Update}, \foreign{Delete}). % Rappel : CRUD est
                                % bien plus ancien que HTTP.  Exemple
                                % avec HTTP : S3
         \item<4->API (\foreign{Application programming interface}) au-dessus de HTTP, pour accéder
          à des services distants,
      \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Exemple d'API}
  Le cours du Bitcoin, chez CoinDesk :
  \begin{info}
% curl -s https://api.coindesk.com/v1/bpi/currentprice.json 
...
    "EUR": {
      "code": "EUR",
      "symbol": "&euro;",
      "rate": "37,702.2399",
      "description": "Euro", ...
    }
  }
  \end{info}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Exemple d'API}
  Le protocole RDAP :
  \begin{info}
% curl  https://rdap.db.ripe.net/ip/2001:660:330f:2::7f
...
  "name" : "FR-ENST-PARIS-RAP-1",
...
    "remarks" : [ {
    "description" : [ "Ecole Nationale Superieure des Telecommunications - Telecom/Paris" ]
  } ],
...
  \end{info}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Exemple d'API}
  Un exemple CRUD \url{https://petstore.swagger.io/}
  \begin{info}
%  curl https://petstore.swagger.io/v2/pet/21          
{"code":1,"type":"error","message":"Pet not found"}

% curl -H "Content-type: application/json" --data "$(cat potamochere.json)" \
   -X PUT https://petstore.swagger.io/v2/pet/ 

%  curl https://petstore.swagger.io/v2/pet/21
{"id":21,"category":{"id":0,"name":"Dom"},"name":"Pork",
   "photoUrls":["https://www.potamochère.fr/potamoch%C3%A8re.jpg"],...
  \end{info}
\end{frame}

\section{HTTP en pratique : clients et serveurs}

\begin{frame}
  \frametitle{Clients}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
      \item<2->Navigateurs Web, bien sûr (Firefox, Chrome, Edge, lynx),
      \item<3->Ligne de commande (curl, wget),
      \item<4->\foreign{Crawlers} (\foreign{bots}),
      \item<5->Bibliothèques pour tous les langages. % On peut le
                                % programmer soi-même facilement mais,
                                % de toute façon, il y a plein de bibliothèques.
      \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{Serveurs}
    \begin{overlayarea}{\textwidth}{.6\textheight}
       \begin{itemize}
       \item<2->Serveurs autonomes (Apache, Nginx),
       \item<3->Bibliothèques pour tous les langages. 
       \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Un client HTTP en deux lignes de Python}
  \begin{info}
import requests

r = requests.get("http://www.cnam.fr/")
print(r.text)
  \end{info}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Un serveur HTTP en trois lignes de Python}
  \begin{info}
import http.server

server_address = ('', 8080)
httpd = http.server.HTTPServer(server_address,
                    http.server.SimpleHTTPRequestHandler)
httpd.serve_forever()
  \end{info}
\end{frame}

\begin{frame}
  \frametitle{Alternative}
    \begin{overlayarea}{\textwidth}{.6\textheight}
       \begin{itemize}
       \item<2->HTTP n'est pas le seul protocole de transfert de fichiers,
       \item<3->Une alternative récente : Gemini,
       \item<4->Le but est d'avoir un protocole plus simple, avec
         moins de possibilités de suivi des utilisateurs,
       \item<5->Encore plus simple d'écrire clients et serveurs.  
       \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{Avec intermédiaire}
  \includegraphics[scale=0.54]{http-proxy.pdf}
\end{frame}

\begin{frame}
  \frametitle{Relais, caches et autres intermédiaires}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
        \item<2->Relais (\foreign{proxies}), pour divers contournements,
        \item<3->Caches (mémorisation des ressources) pour économiser
          la capacité réseau\only<3>{ (moins important maintenant,
            avec TLS)},
        \item<4->Répartiteurs de charge, % Beaucoup de ces fonctions
                                % peuvent être assurées par les
                                % logiciels serveurs présentés plus
                                % haut. 
        \item<5->Pare-feux, pour protéger des applications Web écrites
          avec les pieds.
      \end{itemize}
  \end{overlayarea}
\end{frame}

\section{HTTP, le nouvel IP ?}

\begin{frame}
  \frametitle{L'Internet n'est plus ce qu'il était}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
        \item<2->De plus en plus d'intermédiaires sur le trajet
          (pare-feux, par exemple),
        \item<3->Souvent bogués et/ou mal configurés,
        \item<4->Par défaut, bloquent tout ce qu'ils ne connaissent
          pas,
        \item<5->Cela mène à une \emph{ossification} de l'Internet. Il
          est de plus en plus dur de déployer quelque chose de nouveau.
      \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{L'exemple de DoH}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
      \item<2->Pour contourner la censure, DNS devient chiffré,
      \item<3->DNS sur TLS utilise le port 853, qui peut être bloqué,
      \item<4->D'où DoH (DNS sur HTTPS, RFC 8484).
      \item<5->Tout sur le port 443 ?
      \end{itemize}
  \end{overlayarea}
\end{frame}

\section{HTTP et la sécurité}

\begin{frame}
  \frametitle{Simplicité d'abord}
  \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
      \item<2->Pas spécialement de sécurité dans HTTP au début,
      \item<3->Pas d'authentification,
      \item<4->Pas de session,
      \item<5->Tout en clair.  
      \item<6->Cette simplicité a permis à HTTP de s'imposer.  
      \end{itemize}
  \end{overlayarea}
\end{frame}
  
\begin{frame}
  \frametitle{Biscuits}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
        \item<2->But : créer une \emph{session} à partir d'un ensemble
          de requêtes/réponses HTTP.
        \item<3->Solution : le biscuit (\foreign{cookie}).
        \item<4->Un petit groupe de bits, que le serveur fabrique et
          envoie au client au début de la session,
        \item<5->et que le client renvoie à chaque requête, permettant
          de voir que c'est la même session,  
        \item<6->Normalisés dans le RFC 6265.
      \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{Authentification}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
      \item<2->Peut se faire par des en-têtes HTTP
        \path{Authorization} envoyés à chaque
        requête,
      \item<3->Exemple, mot de passe mémorisé par le client HTTP,
      \item<4->Ne permet pas de se déconnecter,  
       \item<5->En pratique, l'authentification est presque toujours
         faite par une solution non-HTTP\only<5>{ (exemple : mot de
           passe dans un formulaire et deuxième facteur par exemple
           sur une application externe)},
       \item<6->puis les \foreign{cookies} maintiennent la
         session\only<6->{ (« c'est bon, on a déjà authentifié le
           possesseur de ce biscuit »)}.  
       \item<7->(Il y a aussi les certificats clients mais c'est très rare.)
       \item<8->Les API utilisent d'autres solutions : biscuit géré
         manuellement et mis dans l'URL ou dans un en-tête plus ou
         moins spécifique. % RIPE Atlas: ``API key'' dans
                           % l'URL. cicrcl: authentification Basic
                           % HTTP. DNSDB: ``API key'' dans un en-tête
                           % X-API-Key:
      \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{Tout en clair}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
      \item<2->Le trafic numérique est trop facilement écoutable, et
        traitable,
      \item<3->Communiquer \emph{en clair} en 2022 n'est plus
        acceptable,
      \item<4->La surveillance est massivement pratiquée, par les
        opérateurs, les États, les délinquants…  
      \item<5->Révélations Snowden en 2013 : plus moyen de faire l'autruche.
      \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{TLS}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
        \item<2->\foreign{Transport Layer Security}, une couche de
          chiffrement pour les applications,
        \item<3->Normalisé dans le RFC 8446,
        \item<4->Principe : on chiffre au départ et on déchiffre à
          l'arrivée. Protège contre un tiers mais pas contre les
          extrémités. % Exemple Gmail
        \item<5->Risque d'attaque de l'Homme du Milieu : il faut
          \emph{authentifier} l'extrémité.  
      \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{Exemple de certificat}
  \includegraphics[scale=0.39]{cert.png}
\end{frame}

\begin{frame}
  \frametitle{Certificats}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
      \item<2->But : authentifier le serveur TLS,
      \item<3->Moyen : la cryptographie asymétrique\only<3>{ (une clé
        ayant une partie publique et une partie privée)},
      \item<4->La partie publique est signée par une AC (Autorité de
        Certification), RFC 5280,
      \item<5->En pratique, une source d'ennuis, de pannes, de
        frustrations et parfois de dépenses.  
      \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{HTTPS}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
        \item<2->Un service de chiffrement TLS sous HTTP,
        \item<3->Signes de chifrement (cadenas vert), % Parler de chrome ?
        \item<4->Attention, HTTPS garantit confidentialité et
          intégrité, pas confiance.
      \end{itemize}
  \end{overlayarea}
\end{frame}

\section{L'histoire}

\begin{frame}
  \frametitle{Évolution}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
      \item<2->Le premier HTTP, 0.9, n'avait même pas d'en-têtes,
      \item<3->HTTP/1 a été le premier normalisé,
      \item<4->HTTP/1.1 a introduit les connexions persistentes,
      \item<5->HTTP/2 passe en encodage binaire,
      \item<6->HTTP/3 futur HTTP au-dessus du protocole de
        transport QUIC (qui intègre TLS)…
      \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{La norme aujourd'hui}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
        \item RFC 7230, Message Syntax and Routing
        \item RFC 7231, Semantics and Content
        \item RFC 7232, Conditional Requests
        \item RFC 7233, Range Requests
        \item RFC 7234, Caching
        \item RFC 7235, Authentication
        \item RFC 7540, Hypertext Transfer Protocol version 2
     \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{La norme bientôt}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
        \item RFC 9110, HTTP en général, sa sémantique
        \item RFC 9111, Mémorisation
        \item RFC 9112, Spécificités de HTTP/1
        \item RFC 9113, Spécificités de HTTP/2
        \item RFC 9114, Spécificités de HTTP/3
        \item RFC 9204, Compression des en-têtes pour HTTP/3
     \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{Conclusion}
    \begin{overlayarea}{\textwidth}{.6\textheight}
      \begin{itemize}
      \item<2->Un succès fou,
      \item<3->En partie dû à la simplicité du protocole.  
      \end{itemize}
  \end{overlayarea}
\end{frame}

\end{document}
