+Cela est réalisé avec un \emph{MAC}, dans notre cas nous utilisons \emph{HMAC-SHA256} sur l'ensemble des données chiffrées (\emph{Encrypt-then-MAC}).
+
+
+\subsection{Quels sont les clefs cryptographiques requises qu'il est nécessaire de gérer ?}
+
+\subsubsection{Clefs externes}
+
+Concerne les clefs externes à l'\emph{API}.
+
+\begin{itemize}
+ \item Une paire de clefs \emph{RSA-2048} pour la signature.
+ \item Une paire de clefs \emph{RSA-2048} pour le chiffrement des clefs \emph{AES}.
+\end{itemize}
+
+
+\subsubsection{Clefs internes}
+
+Concerne les clefs gérées à l'intérieur du container.
+
+\begin{itemize}
+ \item Une clef de 256 bits pour \emph{AES}.
+ \item Une clef de 256 bits pour \emph{HMAC}.
+\end{itemize}
+
+Ces clefs sont générées aléatoirement à chaque création d'un container.
+
+
+\section{Choix des algorithmes et des paramètres}
+
+\begin{itemize}
+ \item \emph{RSA-2048} pour la signature ainsi que pour le chiffrage des clefs \emph{AES} et \emph{HMAC}. Le bourrage \emph{PKCS\#1 v1.5} est utilisé ;
+ \item \emph{HMAC-SHA256} pour la vérification de l'intégrité ;
+ \item \emph{AES-CBC256} pour le chiffrement symétrique du contenu du fichier et des méta-données associées. Le bourrage \emph{PKCS7} est utilisé.
+\end{itemize}
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{format du container}
+
+Le format est définit comme suit en \emph{EBNF}. Les valeurs entre crochets correspondent soit à une taille en bits soit à un type.
+
+\begin{lstlisting}[frame=single, breaklines, basicstyle=\ttfamily\footnotesize]
+container = header, ciphertext ;
+header = mac[256], signature[2048], keys[2048] ;
+ciphertext = AES(plaintext) ;
+plaintext = meta-data, file-content ;
+meta-data = nb-meta-data[byte], { key-value-pair } ;
+key-value-pair = key[string], value[string] ;
+string = size[vint], content-utf8 ;
+\end{lstlisting}
+
+\texttt{nb-meta-data} est le nombre de pair clef-valeur des méta-données.
+
+\texttt{keys} correspond aux clefs $k_c$ et $k_a$ ainsi qu'a l'\emph{IV} le tout chiffré avec \emph{RSA-2048}. La taille des données chiffrées est égale à $k_c + k_a + iv = 256 + 256 + 128 = 640\,bits$.
+
+Les méta-données (\texttt{meta-data}) peuvent contenir, par exemple, le nom du fichier, sa date de création, ses droits, ou tout autres données associées.
+
+Le type \texttt{vint} correspond à un entier de taille variable, initialement occupant un octet.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{processus}
+
+\subsection{chiffrement}
+
+Entrées :
+
+\begin{itemize}
+ \item $f$ : fichier
+ \item $k_{pub}$ : clef publique RSA
+ \item $k_{signpriv}$ : clef privé de signature RSA
+\end{itemize}
+
+
+Processus :
+
+\begin{enumerate}
+ \item Génération d'une clef 256 bits pour \emph{AES} $\rightarrow k_c$.
+ \item Génération d'une clef 256 bits pour \emph{MAC} $\rightarrow k_a$.
+ \item Génération d'un \emph{IV} 128 bits pour le mode \emph{CBC} $\rightarrow iv$.
+ \item Construction du $plaintext$, voir format ci dessus.
+ \item Chiffrement du $plaintext$ avec \emph{AES-CBC256}, $k_c$ et $iv \rightarrow ciphertext$.
+ \item Calcul de MAC de $ciphertext$ $\rightarrow mac$.
+ \item Signature de $mac$ avec $k_{signpriv}$ $\rightarrow sig$.
+ \item Chiffrement de $k_c + k_a + iv$ avec $k_pub \rightarrow keys$.
+ \item Renvoie $mac + sig + keys + ciphertext$.
+\end{enumerate}
+
+Où $+$ dénote la concaténation.
+
+
+\subsection{déchiffrement}
+
+Entrée :
+
+\begin{itemize}
+ \item $c$ : container chiffrées
+ \item $k_{priv}$ : clef privée RSA
+ \item $k_{signpub}$ : la clef publique de signature RSA
+\end{itemize}
+
+Processus :
+
+\begin{enumerate}
+ \item Lecture de $mac$, calcul de $mac'$ sur $c$ comparaison des deux afin de vérifier l'intégrité.
+ \item Vérification de la signature avec $k_{signpub}$.
+ \item Déchiffrement de $k_c + k_a + iv$ avec $k_{priv}$.
+ \item Déchiffrement du reste des données ($ciphertext$).
+\end{enumerate}
+
+Ce processus nécessite deux cycles de lecture des données, le premier pour le calcul de $mac'$ et le deuxième pour le déchiffrement. Le deuxième cycle n'est effectué que si l'intégrité et l'authenticité ont été validés.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{Implémentation}
+
+Nous utilisons ici la plate-forme \emph{.NET} ainsi que le langage \emph{F\#}. L'ensemble des éléments cryptographiques requis sont fournit par \emph{.NET}\footnote{\dotnetcrypto}.
+
+Deux \emph{assemblies} sont crées :
+
+\begin{itemize}
+ \item \emph{CryptoFile} : \emph{Library} mettant à disposition l'\emph{API} de chiffrement de fichier et de déchiffrement de container.
+ \item \emph{CryptoFileTests} : Exécutable utilisant la \emph{library} \emph{CryptoFile} et permettant d'utiliser l'\emph{API} à l'aide d'arguments fournis par la ligne de commande.
+\end{itemize}
+
+\subsection{Utilisation}
+
+Il est possible de compiler la solution à l'aide de \emph{MonoDevelop}\footnote{\monodevelop}. Le script \emph{Bash} \texttt{labo2-fsharp/run\_tests.sh} permet de compiler la solution puis d'exécuter un certain nombre de tests.
+
+À partir du dossier \texttt{labo2-fsharp} et après avoir compiler en \emph{release} la solution, voici ce qu'il est possible d'effectuer :
+
+\begin{itemize}
+ \item \texttt{CryptoFileTests/bin/Release/CryptoFileTests.exe tests} : Réalise une série de tests.
+ \item \texttt{CryptoFileTests/bin/Release/CryptoFileTests.exe encrypt <file> <container>} : Chiffre le fichier \texttt{<file>} ver le container \texttt{<container>}.
+ \item \texttt{CryptoFileTests/bin/Release/CryptoFileTests.exe decrypt <container> <output directory>} : Déchiffre le container \texttt{<container>} dans le dossier \texttt{<output directory>}.
+\end{itemize}
+
+Les clefs publiques et privées pour le chiffrement ainsi que pour la réalisation de la signature se trouvent dans les fichiers \texttt{keys-crypt.priv}, \texttt{keys-crypt.pub}, \texttt{keys-sign.priv} et \texttt{keys-sign.pub}. Ceux-ci sont automatiquement générés dans le cas où ils sont introuvables.
+
+
+\subsection{Organisation du code}
+
+La \emph{ĺibrary} \emph{CryptoFile} est composé de trois fichiers :
+
+\begin{itemize}
+ \item \emph{Types.fs} : Quelques types publics.
+ \item \emph{Crypto.fs} : Toutes les primitives cryptographique nécessaire.
+ \item \emph{UnitTests.fs} : Quelques tests unitaires du module \emph{Crypto}.
+ \item \emph{API.fs} : L'interface publique de la \emph{library}. Elle est détaillée ci-après.
+\end{itemize}
+
+\subsubsection{API}
+
+\begin{lstlisting}[language=FSharp, frame=single, basicstyle=\ttfamily\footnotesize]
+module API =
+ let generatKeysPair : Key * Key
+
+ let encryptFile (inputFilePath : string)
+ (outputFilePath : string)
+ (signaturePrivKey: Key)
+ (cryptPubKey : Key)
+
+ let decryptFile (sourceFilePath : string)
+ (targetDirPath : string)
+ (signaturePubKey: Key)
+ (decryptPrivKey : Key)
+\end{lstlisting}
+
+
+\subsection{Mesures de performance}
+
+Quelques mesures sur un fichier de 871 MiB.
+
+Chiffrement :
+
+\begin{itemize}
+ \item Temps : 42 s.
+ \item Mémoire utilisée : 15 MiB.
+ \item Taux \emph{CPU} : un cœur à 100 \%
+\end{itemize}
+
+Déchiffrement :
+
+\begin{itemize}
+ \item Temps : 55 s.
+ \item Mémoire utilisée : 20 MiB.
+ \item Taux \emph{CPU} : un cœur à 100 \%
+\end{itemize}
+
+
+\section{Analyse de la sécurité de l'implémentation}
+
+\subsection{Quelles sont les parties critiques du code et comment s'assure-t-on que ces parties soit correctement implémentées ?}
+
+La génération des clefs \emph{AES} doit être faite avec un générateur cryptographique. Dans notre cas nous utilisons \emph{System.Security.Cryptography.RSACryptoServiceProvider}\footnote{\rsacryptoserviceprovider}.
+
+La mémoire correspondant aux clefs générées devrait être effacé, dans notre cas si un attaquant a accès à la mémoire de notre programme alors il a accès au contenu des fichiers à chiffrer, il n'y a donc pas de précautions prise en particulier à ce sujet.
+