GROS COMMIT

Assembleur/cours.md

@@ -254,7 +254,4 @@ jmp                             intrinsèquement saut inconditionnel
 
 cmp
 jmp                             saut conditionnel, cmp va modifier un flag lu par jmp
-
-
-
 ```

AttaqueSecuReseau/cours.md

@@ -0,0 +1 @@
+# Attaques et sécurisation des couches OSI, Cartographie de Réseau

Conferences/Lyra_PCI-DSS.md

@@ -0,0 +1,29 @@
+# Lyra Network
+# Entreprise de Paiement
+
+Société en charge de la bonne circulation des paiements
+
+Les cannaux de communications TPE-Banque : 
+
+- RTC
+- GPRS
+- IP
+
+# PCI-DSS
+## Payment Card Industriy Security Standard Council
+
+Fondé en 2006 par les réseaux de Cartes Bancaires :
+
+- Visa
+- Mastercard
+- AMEX
+- Discover
+- JCB International
+
+Cette norme a pour but d'augmenter de façon signifiante la sécurité des données de paiement. On la trouve sous plusieurs déclinaisons : 
+
+- PCI DSS : Service de traitement de données de cartes bancaires
+- PA  DSS : Logiciels de traitement de données de cartes bancaires
+- PCI HSM : Hardware Security Module
+- PCI-PTS : Terminaux de paiements
+

Conferences/Marine.md

@@ -0,0 +1,11 @@
+# Conférence Marine Nationatle
+
+## Renseignement
+
+## Prévention
+
+## Protection
+
+## Dissuasion
+
+## Intervention

Crypto/cours.md

@@ -152,18 +152,19 @@ Pour optimiser le chiffrement on souhaiterait
   <img src="./Images/bloccipher.png">
 </p>
 
-On considère un chiffrement à bloc réussi si 
+On considère un chiffrement à bloc réussi si
 
 - Les blocs sont assimilables à des permutations
 - Un n-bit block chiffré est indistinguable d'un random n-bit block
 
-En pratique, pour valider ce type de chiffrement, on se base sur les propriétés de Shannon : 
+En pratique, pour valider ce type de chiffrement, on se base sur les propriétés de Shannon :
+
 - **Diffusion** : Si 1 bit change dans le bloc d'origine, il faut que statistiquement, plus de la moitié du bloc chiffré soit impactée
 - **Confusion** : 1 bit du bloc chiffré doit être lié à plusieurs bits de la clé
 
 ## Réseau de Substitutions/Permutations
 
-Une autre techinque de chiffrement consiste à faier passer le message dans une chaine de bloc de substitutions permutations : 
+Une autre techinque de chiffrement consiste à faier passer le message dans une chaine de bloc de substitutions permutations :
 
 <p align="center">
   <img src="./Images/spnet.png">
@@ -184,13 +185,13 @@ on a donc ici $nb_{itération de recherches} = 2^{security level} = 2^{taille de
 
 On parle de S-Box pour les substitions et P-Box ou D-Box pour Permutation ( Ou diffusion).
 
-## S-Box 
+## S-Box
 
-Substitue un symbole pour un autre. Cela contribue à la confusion puisque ça rend la sortie inintelligible. D'une pière deux coups, cela accentue également la non linéarité de la sortie. 
+Substitue un symbole pour un autre. Cela contribue à la confusion puisque ça rend la sortie inintelligible. D'une pière deux coups, cela accentue également la non linéarité de la sortie.
 
-## P-Box ou D-Box 
+## P-Box ou D-Box
 
-Echange deux symboles les uns par rapport aux autres. Cela contribue à la diffusion puisque cela déplace les symboles d'un endroit à l'autre. Par contre cela n'a aucun effet sur la linéarité de la sortie. 
+Echange deux symboles les uns par rapport aux autres. Cela contribue à la diffusion puisque cela déplace les symboles d'un endroit à l'autre. Par contre cela n'a aucun effet sur la linéarité de la sortie.
 
 # AES
 
@@ -202,21 +203,24 @@ Nous sommes ici avec un chiffrement symétrique.
   <img src="./Images/AES_round1.png">
 </p>
 
-On est sur des blocs de 128 bits en général. 
+On est sur des blocs de 128 bits en général.
 
 L'état interne est composé d'une matrice d'octets de 4x4. 4 operations sont exécutées sur l'état interne à chacun des rounds.
 
 1 - AddRoundKey
+
 - xor between state and round-key.
 - if message independant from key, and key uniform, then the new state
 - looks uniform.
 
 2 - SubBytes
+
 - Non-linearity: Minimization of input-output correlation.
 - Complexity: Complex expression in GF(28).
 - Simple implementation: Look-up table (and must be since litteral expression complex).
 
 3 - ShiftRows
+
 - Variable byte rotation of each line depending on line index.
 - First line: no rotation.
 - Second row: 1 byte rotation.
@@ -224,6 +228,7 @@ L'état interne est composé d'une matrice d'octets de 4x4. 4 operations sont ex
 - Fourth row: 3 bytes rotation.
 
 4 - MixColumns
+
 - Column per column scrambling of coefficients. Equivalent to multiplying each column by following matrix:
 
 $\begin{pmatrix}
@@ -244,17 +249,19 @@ $\begin{pmatrix}
 The message is split into blocks matching the size of Block-Cipher’s block
 length. Each block is encrypted with the same key.
 Pros:
+
 - Simplest construction.
 - Destination can decrypt a specific block without extra computations.
 - Vulnerabilities?
 
 # Comment évaluer la sécurité ?
 
-Propriétés de Sécurité : 
+Propriétés de Sécurité :
 
 Sans information sur la clé, aucune info du chiffré n'informe d'aucune info du clair. : Sécurité Sémantique
 
 Adversary capabilities are defined as indistinguishability games:
+
 - IND-KPA (known plaintext-attack): adversary sees pairs $(m_i
 , Enc(m_i))$.
 - IND-CPA (chosen plaintext-attack): adversary SELECTS messages mi
@@ -262,12 +269,14 @@ and ASKS an entity to encrypt $m_i$
 
 - IND-CCA: More information during asymmetric encryption lesson.
 
-## IND-CPA 
+## IND-CPA
+
 <p align="center">
   <img src="./Images/IND-CPA.png">
 </p>
 
 Win condition
+
 - L'adversaire gagne si : $Pr[b = b'] > 1/2$.
 - Si Pr[b = b'] = 1/2, alors l'adversaire peut seulement deviner au hasard quel message a été chiffré.
 - Advantage: $ACPA = |Pr[b = b'] − 1/2| = \in$
@@ -280,38 +289,42 @@ Win condition
 
 - On souhaiterait une robustesse intrinseque aux bitflips.
 
-- On voudrait qu'il soit impossible de trouver un antécédant du code chiffré à partir de ce petit bout code. 
+- On voudrait qu'il soit impossible de trouver un antécédant du code chiffré à partir de ce petit bout code.
 
-On parle ici de **codes de contrôles d'intégrité**, ou **fonction de Hash**. 
+On parle ici de **codes de contrôles d'intégrité**, ou **fonction de Hash**.
 
-Propriétés usuelles : 
+Propriétés usuelles :
 
 - En connaissant $h_{m_1} = H(m_1)$, trouver $m_2$ est difficile tel que $H(m_2)=h_{m1}$
 - Pour un message $m_1$, trouver $m_2$ tel que $H(m_1) = H(m_2)$ est difficile
 - Trouver $m_1$ et $m_2$ tel que $H(m_1)=H(m_2)$ est difficile.
 
 # Etude de la sécurité des fonctions de hashage
-## Est ce que la pire des attaques concernant les fonctions de hashage est la recherche exhausitve
 
+## Est ce que la pire des attaques concernant les fonctions de hashage est la recherche exhausitve
 
 On parle d'attaque annivesaire en lien avec le paradoxe de l'anniversaire.
 
-## Notation 
+## Notation
+
+Soit $\mathbb{Z}_M -> \mathbb{Z}_H$ une fonction de Hash avec H sorties possibles. On note
 
-Soit $\mathbb{Z}_M -> \mathbb{Z}_H$ une fonction de Hash avec H sorties possibles. On note 
 - p(n;H) la probabilité de trouver au moins une collision après n essais
 - n(p,H) le nombre d'essais avant de trouver une collision avec une probabilité p.
 
 ## Estimation of p(n; H)
+
 - $p(n; H) = \frac{365!}{(365−n)!365^n} \simeq 1 −e^{−n2 /(2H)}$.
 - (Birthday attack exact formula + application of stirling formula
 - $(n! \simeq \sqrt{2\pi n}(\frac{n}{e})^n)$
+
 + application of taylor expansion at order 2).
 Estimation of n(p; H)
-- $n(p; H) = \sqrt{2H\ln\frac{1}{1−p}} $
 
+- $n(p; H) = \sqrt{2H\ln\frac{1}{1−p}} $
 
 Au vu des chiffres induits par ces valeurs, on estime qu'un mécanisme sécurisé l'est à partir de 80 bits de niveau de sécurité, soit $2^{80}$
+
 # Construction d'une fonction de Hash - Merkle-Dagmard (MD5, SHA-1, SHA-2...)
 
 <p align="center">
@@ -335,6 +348,7 @@ MD5(m1||s1) = MD5(m2||s2). Has been successfully used to forge a
 fake server certificate from legal authority.
 
 Other limitation
+
 - MD5 computation is fast: A GPU can compute about 150 million hashes per second
 (Yanjun et al., 2014).
 - Chosen Prefix Attack: $150 millions \simeq 2^{27} =⇒ 2{39}/2^{27} = 2^{12} sec = 1h 8m
@@ -352,7 +366,7 @@ to cover several cryptographic algorithms).
 
 ### Limite des fonctions de Hash en pratique
 
-Si on considère qu'un utilisateur télécharge un programme depuis un serveur officiel, un attaquant pourrait intercepter la communication et remplacer le programme par un malveillant. En contre-mesure on pourrait imaginer que le serveur et l'utilisateur partagent un secret, inconnu par l'attaquant, et ils peuvent utiliser une construction appelée MACs, similaire aux fonctions de hash pour authentifier le message reçu. 
+Si on considère qu'un utilisateur télécharge un programme depuis un serveur officiel, un attaquant pourrait intercepter la communication et remplacer le programme par un malveillant. En contre-mesure on pourrait imaginer que le serveur et l'utilisateur partagent un secret, inconnu par l'attaquant, et ils peuvent utiliser une construction appelée MACs, similaire aux fonctions de hash pour authentifier le message reçu.
 
 ## Préfixe secret
 
@@ -373,8 +387,9 @@ On note p le block de padding d'un message s||m. Avec une paie (m,MAC=H(s||m)),
 
 Pour un message m et un secret s, MAC = H(m||s).
 
-### Quelques faiblesses architecturelles demeurent...
-- **Vulnérabilité  hors ligne d'une attaque par seconde-preimage**: 
+### Quelques faiblesses architecturelles demeurent
+
+- **Vulnérabilité  hors ligne d'une attaque par seconde-preimage**:
 (i.e. For given m1, finding m2 such as H(m1) = H(m2)). An attacker can search second pre-image offline (i.e. without information on the secret s) and find m2. Then, attacker can substitute m1 by m2.
 
 - **Vulnerability on offline collision attack (weak collision)**: (i.e. Find m1 and m2 such as H(m1) = H(m2)). If an attacker can ask an authority to compute a MAC, then he asks a MAC for m1 and an substitute this for m2.
@@ -383,7 +398,7 @@ Pour un message m et un secret s, MAC = H(m||s).
 
 $ HMAC(S_k,m) = H((S_k)\oplus opad) || H((S_k\oplus ipad)||m)) $
 
-Propriétés: 
+Propriétés:
 
 Une propriété de HMAC est que la fonction de compression n'est pas résistante aux collisions. (seulement PRF est requis) si elle est utilisée intentionnellement => MD5 et SHA-1 peuvent êtrer utilisée pour HMACs
 
@@ -401,18 +416,20 @@ Donc HMAC(Sk , m1) = HMAC(Sk , m2)
 ## Aglo MAC basé sur un chiffrement par blocs - CMAC
 
 CMAC est construit à partir d'un chiffrement par bloc qui opère en mode CBC. _NIST SP800-38B_. C'est une amélioration de CBC-MAC qui avait des vulnérabilités lorsque les messages avaient des longueurs variables. La variante XCBC-MAC a été proposée en 2003.
+
 ## Algo MAC basé sur un HASH - HMAC
 
-HMAC est aussi appelée Keyed-Hash message authentification code est construit à partir d'un e fonction de hash. 
+HMAC est aussi appelée Keyed-Hash message authentification code est construit à partir d'un e fonction de hash.
 
 ## Intégrité, Authentification, et Confidentialité
 
 GMC et GMAC sont des modes d'opérations de chiffrement par bloc qui intègrent directement ces principes.
 
 ## Exemple de MACs implémentés en OpenSSL
+
 CMAC, GMAC, HMAC, KMAC, SiphHASH, Poly1305 (Bernstein, selectionné par google pour remplacer RC4 dans TLS/SSL).
 
-# MAC + Encryption : How to ? 
+# MAC + Encryption : How to ?
 
 <p align="center">
   <img src="./Images/encrypt_mac.png">
@@ -420,7 +437,7 @@ CMAC, GMAC, HMAC, KMAC, SiphHASH, Poly1305 (Bernstein, selectionné par google p
 
 Le process le plus rapide pour chiffrer et certifier est Encrypt and Mac puisqu'on parallélise les process Encrypt et Mac.
 
-Le process qui mène à la vérification la plus rapide est Encrypt then Mac, ou on peut vérifier le MAC sans avoir à déchiffrer le plain. 
+Le process qui mène à la vérification la plus rapide est Encrypt then Mac, ou on peut vérifier le MAC sans avoir à déchiffrer le plain.
 
 Le plus vulnérable au chosen plain-text attack, est la construction Encrypt and MAC puisque le Hash est directement correlé au plain-text.
 
@@ -447,7 +464,9 @@ GCM utilise donc le parallélisme encrypt then MAC, LA STAR.
 </p>
 
 ## Use-Case : SHA-1
+
 No storage
+
 - Number of combinations is $36^8 = 2^{40} $⇒ brute force requires 240 calls to SHA-1 before expecting finding a password.
 - Modern 4GHz CPU: 3.5 MHash/sec = $2^{21}$ Hash/sec
 =⇒ 2
@@ -468,6 +487,7 @@ Ici, H est une fonction de Hash, R, une fonction de réduction qui transforme le
 
 **Attack**
 We note h the hashes obtained by attacker after a successfull attack.
+
 - step 1: Check if h is in database. If it is, take the corresponding password p and compute R2(H(R1(H(p)))) ⇒ done.
 - step 2: Check if H(R2(h)) is in database. If it is, take the corresponding password p and computes H(R1(H(p))) ⇒ done.
 - step 3: Check if H(R1(H(R2(h)))) is in database. If it is, take the corresponding password p ⇒ done.
@@ -482,10 +502,38 @@ We note h the hashes obtained by attacker after a successfull attack.
   - Since attacker must execute hash function many times and legitimate server only one, slowing hash function drastically penalize attacker.
 
 ## Autre construction des PasswordCheck
+
 ### Preuve de travail | Proof of work
 
 Pour éviter le spam ou le déni de service, oh force les hashes des émetteuurs de message à avoir 20 bits de poids forts à zéro, en utilisant un custom header. C'est également utilisé pour le bitcoin.
 
 ### Dérivation de clé
 
-Des que les fonctions de hash ont des sorties uniformes, ont peut également les utiliser pour créer des secrets uniformes.
+Des que les fonctions de hash ont des sorties uniformes, ont peut également les utiliser pour créer des secrets uniformes.
+
+# Definitions of Random Number Generators
+
+## True Random Number Generator (TRNG)
+
+- Généralement créé par hardware, avec une forte entroie puisqu'on n'a aucun moyen de remonter à la source.
+- Peut être biaisée par la loi utilisée (i.e. si ce n'est ni gaussien ni uniforme), mais chacun des biais peut être contré par des algorithmes que l'on appelle des extracteurs
+
+## Pseudo  Random Number Generator
+
+- Entropie Finie, au bout d'un moment on peut prédire les sorties
+
+Exemple de générateurs d'aléas purs :
+
+- Bruit thermique autour d'une résistance
+- Décomposition atomique 
+
+# Partage de clés dans un monde symétrique
+
+**Cas de deux utilisateurs**, si le secret est déjà partagé ok, sinon, il yè a échange de clé sur un canal sûr, ou trouver un moyen de le partager astucieusement.
+
+**Cas d'un groupe d'utilisateurs** :   Partager un secret peut être dangereux puisqu'il peut y avoir des usurpation d'identité, de l'interception de messages... On peut aussi envisager d'avoir un secret par paire d'uitlisateurs, mais cela nécessiterait énromément de clés. 
+
+En pratique on adopte un modèle serveur client avec une clé par client.
+
+## Comment échange-t-on le secret
+cf . slides

OS/cours.md

@@ -244,14 +244,13 @@ _Un exemple : DosBox_
 
 # Segmentation
 
-
 ## Gestion mémoire du mode protégé
 
-En mode protégé, on a un espace mémoire en 32 bits, ce qui engendre un espace linéaire de 32 bits => $2^32$ <=> 4Gb. Pendant un temps supérieur à la RAM installée. On va segmenter cet espace, et ainsi mettre en place un adressage relatif au début d'un segment(adresse logique). 
+En mode protégé, on a un espace mémoire en 32 bits, ce qui engendre un espace linéaire de 32 bits => $2^32$ <=> 4Gb. Pendant un temps supérieur à la RAM installée. On va segmenter cet espace, et ainsi mettre en place un adressage relatif au début d'un segment(adresse logique).
 
 ## La segmentation
 
-Il s'agit donc d'une prolongation du principe de segments du mode réel. On a plusieurs types de modèles, _flat/protected_ et _flat/multiy-segment_. Chaque segment a des propriétés de type, de taille et de droits. 
+Il s'agit donc d'une prolongation du principe de segments du mode réel. On a plusieurs types de modèles, _flat/protected_ et _flat/multiy-segment_. Chaque segment a des propriétés de type, de taille et de droits.
 
 Avec cette segmentation on peut réellement découper la mémoire et attribuer certaines propriétés à ces segments de mémoire. On peut donc créer des segments read only, read write, execution...
 
@@ -267,7 +266,7 @@ Pour faciliter ce fonctionnement, on met en place une table GDT - Global Descrip
 
 ## Les sélecteurs de segments
 
-Ils permettent l'accès à un descripteur donné. Chaque sélecteur permet de définir : 
+Ils permettent l'accès à un descripteur donné. Chaque sélecteur permet de définir :
 
 - Un niveau de privilège
 - Une table (locale ou globale)
@@ -278,11 +277,13 @@ Ils permettent l'accès à un descripteur donné. Chaque sélecteur permet de d
 </p>
 
 Les sélecteurs de segments sont en général **CS, DS, SS** qui pointent vers une table GDTR en mémoire qui elle contient les descripteurs de segments.
+
 ## Descripteur de segment
 
-Ils contiennent toutes les informations relatives auc segments : 
+Ils contiennent toutes les informations relatives auc segments :
+
 - base et limite
-- type de segment 
+- type de segment
   - code (X,RX), data (R,W)
   - système : TSS, Task Gate, Interrupt Gate, Call Gate
 
@@ -291,7 +292,7 @@ Ils contiennent toutes les informations relatives auc segments :
 </p>
 
 - Base : Début du segment
-- Limite : Taille - 1, dernier octet accessible 
+- Limite : Taille - 1, dernier octet accessible
 - Granularité, on l'utilise pour multiplier nos bits de limite et ainsi pouvoir arriver à 4GB.
 
 # Niveaux de privilèges
@@ -336,7 +337,7 @@ Du point de vue de la sécurité
 - simulation d’une architecture harvard (contre von Neumann)
 - imaginez un descripteur par buffer ? anti-overflow
 - Linux Kernel PaX protection : SEGMEXEC
-_https://pax.grsecurity.net/docs/segmexec.txt_
+_<https://pax.grsecurity.net/docs/segmexec.txt>_
 
 Et pourtant ...
 
@@ -346,9 +347,175 @@ Et pourtant ...
 
 # Interruptions et Exceptions
 
+Les interruptions et les exceptions ont pour intérêt d'éviter l'attente active et bloquer le CPU, d'apporter une composante événementielle à l'OS et peut être réveillé sur demande en fonction des besoins du programme.
+
+Les exceptions sont générées
+
+- par le CPU, en cas d'erreurs (#GP, #NP).
+- par du code
+- ou d'autres sources
+  - fault, on la gère et on ré-excécutee l'instruction
+  - trap, on la gère et on continue après l'instruction
+  - abort, non récupérable
+
+Il y a une classification qui permet une priorisation des exceptions en cas de déclenchement simultanné.  En général, chacune des erreurs vient en général avec un code d'erreur.
+
+## Exceptions Usuelles
+
+- General Protection Fault #GP
+  - Survient dans de nombreux cas
+    - Liés  la segmentation (taille, droits, pvl...)
+    - Configuration invalide des registres de contrôle, MSRs
+  - Du type fault
+  - Fournit un code d'erreur
+    - Sélecteur de segment fautif si erreur de segmentation
+    - ou 0 pour les autres erreurs
+- BreakPoint #BP
+  - Survient quand l'instruction int3 est exécutée
+  - Du type trap
+  - Pas de code d'erreur
+
+## Interruptions 
+
+Qui dit Interruptions dit aussi reprise d'exécution, ainsi, au moment  de l'interruption, l'état actuel du CPU doit être sauvegardé. Ainsi, on doit mettre en oeuvre les concepts de pile d'interruption, d'Interrupt Gate (descripteur de segment d'interruption), et d'appels systèmes (implémentation historique).
+
+## Table des interruptions IDT
+
+Les descripteurs référencent des segments de code et du handler associé. Ils indiquent également le DPL nécessaire pour y accéder qui sont généralement en ring 0, à l'exception du handler d'appels systèmes qui sera en ring 3.
+
+<p align="center">
+  <img src="./Images/IDT.png">
+</p>
+
+## Contexte d'interruption
+
+On parle du contexte pour indiquer l'état du CPU à un instant donné. Cela sous entend 
+
+- Un niveau actuel de privilèges
+- La valeur des registres généraux (eax, ebx, ..., esp)
+- Le registre d'état (EFLAGS)
+
+Dans le cadre du déclenchement d'une exception/interruption, on peut potentiellement changer subitement le niveau de privilèges (ring 3 => ring 0)
+
+Le CPU doit donc sauvegarder les informations d'état du niveau de provenance pour y retourner après l'exécution de l'exception. Le noyau s'occupe du reste.
+
+**En trois étapes**
+
+- Au moment de l'interruption, le CPU sauvegarde le minimum et détermine s'il y a eu changement de niveau de privilèges
+- Avant de traiter l'interruption, l'OS sauvegarde ce qu'il pense être nécessaire de restaurer
+- Au retour de l'interruption, l'OS utiliser une instruction spécifique (iret)
+
+## Comment le CPU sait où sauvegarder ?
+
+Dans le cas d'une transition ring 3 => ring 0 :
+
+- Le CPU cherche à changer de pile (registre esp)
+- Sauver les informations du ring 3 dans le ring de destination
+
+Mais l'une des question serait , où trouver la nouvelle valeur à mettre dans esp ?
+On peut y parvenir grâce au TSS - Task State Segment
+
 # Pagination
 
+Introduction d'un nouveau système de ségragation mémoire, avec l'arrivée de nouveaux concepts, comme les adresses virtuelle. C'est permis par un nouveau composant qui permet les calculs, la MMU, Memory Management Unit
+
+## Définiition 
+
+On a un programme qui va avoir des adresses de 1000 à 2000 (adresse relative), qui va être traduite vers une adresses linéaire qui n'est plus nécessaireemnt l'adresse physique finale dans la RAM. Avec la segmentation, au démarrage, bien qu'on ait pas accès à la RAM entière, on pouvait écrire un peu n'importe où, sans que cela ait d'impact. Avec la pagination, on peut dire rajouter une étape, qui va permettre une traduction des adresses linéaires, qui fait que l'on peut dire que l'adresse linéaire 0xffffff (non accessible par segmentation) correspond en réalité à l'adresse 0x00. La pagination introduit donc des une table de traduction des adresses virtuelles  -> adresses physiques par taches.
+
+On parle ici
+
+- Espace d'adressage
+- mappping memoire
+- page trables/directory (via la MMU)
+- page table entries (PTE)
+
+<p align="center">
+  <img src="./Images/pagination.png">
+</p>
+
+Chacue page de mémoire physique fait 4kB, et on n'a qu'un seul Page Directory, avec 1024 entrées (PDE - Page DIrectory Entry, 4kB)
+
+PDE 
+
+- 1024 entrées, Page Directory Entry, 4kB
+  - Une entrée => Une Page Table 
+  - Une entrée définit l'adresse physique d'une Page Table
+
+Page Table
+
+- 1024 Entrées, Page Table Entry
+  - Contient l'adresse de la mémoire physique associée à cette table
+
+Page 
+- 4kB
+
+Une page table permet de mapper 4Mb de mémoire => Un Page Directory permet de mapper 1024  Page Table => 1024*4Mb = 4Gb.
+
+Si on a une continuité de pages dans les adresses des pages au niveau de l'entrée d'une page table, on peut également définir des blocs de pages pour avoir une seule page mémoire plus grande.
+
+### Dans le détail 
+
+- le PGD voit son adresse physique stockée dans cr3
+- chaque table contient au plus 1024 entrées de 4 octets
+- une entrée de table (PTE) définie une page de 4KB
+- une table de pages couvre donc 1024 ∗ 4KB = 4MB d’espace virtuel
+- une entrée de répertoire (PDE) peut définir
+- une table de pages de 1024 entrées
+- une page de 4MB (bit pse)
+- un répertoire de pages couvre donc 1024 ∗ 4MB = 4GB d’espace virtuel
+
+ON REECRIT CR3 POUR CHACUN DES PROCESS. ET ON DEFINIT AINSI UN PAGE DIRECTRORY PAR PROCESS. 
+
+A chaque changement de process, on doit flusher les traductions d'adresses, pour ne pas qu'un autre process puisse accéder aux mémoires associées aux autres process. 
+
+Ce tableau de correspondances @virt <=> @phys s'appelle la TLB, et est flushé à chaque changement de process et de contexte.
+
+
+**Comment le processeur traduit les adresses virtuelles en mode 32 Bits ?**
+
+On découpe une adresse virtuelle en 3 parties : 
+
+- 10 bits de poids fort indique l'index de l'entrée dans le page directory
+- 10 Bits suivant servent d'index dans la table de page => adresses physique de la page de mémoire associée, à l'offset 0.
+- 12 bits de poids faibles qui servent d'offset pour se ballader dans la page de mémoire physique.
+
+<p align="center">
+  <img src="./Images/v_addr.png">
+</p>
+
+
+## Découpage des entrées des Page Tables et Page Directory
+
+- Bit 0 : Flag Present, qui génère une Page fault si = 0
+- Bit 1 : Read or Write : 0 = Read Only, 1 = Read Write
+- Bit 2 : Niveau de privilège, 0 = User ou 1 = Superviseur
+
+<p align="center">
+  <img src="./Images/desc_PDE_PTE.png">
+</p>
+
+Il a fallu attendre les processeurs 64 bits pour avoir des PTE plus grande, et ainsi préciser en plus de R/W, l'aspect exécutable d'une page de mémoire.
+
+Si on a plusieurs instances d'un même process, si le Bit G est à 1, on peut la conserver dans les caches de traduction malgré un changement de contexte.
+
+## En 64 bits...
+
+<p align="center">
+  <img src="./Images/64bits_vaddr.png">
+</p>
+
+## Sécurité et Pagination
+
+La sécurité proposée par la pagination par défaut est vraiment relative, on a quasiment aucune protection noyau/tache, du au bit User/Superviseur, les données sont peu protégée, on a uniquement un bit read/write qui peut impliquer de l'exécution... et on empêche l'opération XOR.
+
+Mais petit à petit, le système a été amélioré au fil du temps. On a vu la mise en place de nouvelles normes et notamment la mise en place de iTLB pour les isntructions, et du dTLB pour les données.
+
+Sous Linux, un patch a été publié sous le nom de PAGEEXEC rajoute une couche de protection.
+
+Sur les architectures 64 bits, on a vu arriver au niveau des PTE un bit NX, qui empêche une page d'être exécutable. 
+
+Enfin, d'autres protections ont été mises en oeuvre via cr0, à savoir la mise en place d'un write protect et d'un SMEP/SMAP qui contrôle l'acces et l'exécution.
 # Composants d'un OS
 
 # Conclusions
-

Vulnérabilités/buffer_overflow.md

@@ -0,0 +1,56 @@
+# Sécurité des applications, débordements de tampon mémoire
+
+Un programme doit anticiper les actions malveillantes pouvant se produire à chacune des interactions:
+
+- Entrées du programme vérifiées et assainies
+- Contrôle des appels de programmes externes
+- Utilisation correcte de fonctions sûres
+  - par exemple ```strncpy``` et ```strncat``` au lieu de ```strcpy``` et ```strcat```
+
+```C
+strcat(dst,src)
+```
+
+Cette fonction enlève le caractère de fin de chaine de dst, et concatène src à la fin de dst. Le problème ? On ne vérifie pas la taille de l'espace alloué à dst, et on peut ainsi déborder sur la pile.
+
+Une bonne façon d'utiliser ```strcat``` est de précéder ```strcat``` d'un test :
+
+```C
+if (strlen(dst)+strlen(src)< sizeof(dst)-1){
+    strcat(dst,src);
+}
+```
+
+L'alternative est
+
+```C
+/// Le troisième paramètre de strncat est le nombre max de char que l'on va copier de src dans dst
+/// -1 pour le symbole de fin de chaine de caractères
+strncat(dst, src, sizeof(dst)-strlen(dst)-1);
+```
+
+Accès à l'origine : (lecture) ou (écriture) qui sont causés par de mauvais indices d'un tableau, un strcpy mal maîtrisé, etc...
+
+## Les possibles conséquences d'un débordement
+
+**Cela dépend de l'emplacement du débordement :**
+
+- Pile : données de contrôle d'exécution ou variables du programme
+- Tas : Données gérées par la ```libc``` ou variables du programme
+- Data : Variables du programme
+- Code : Pas en écriture !
+
+**L'exploitation demande de connaitre la sémantique des données écrasées :**
+
+- Données de contrôle d'exécution : Specification du processeur
+- Données gérées par la ```libc``` => implémentation de ```malloc```
+- Variables du progrmame => Sémantique du programme (rétro-conception...)
+
+**Conséquences de l'exploitation :** Déni de service (```seg fault```), changement de comportement du processus vulnérable, escalade de privilèges, etc...
+
+**Définition du Tas :** Zone mémoire qui sert de base pour l'allocation dynamique de mémoire ``` malloc free ```
+
+# Exploiter une vulnérabilité
+
+## Etape 1 : Recherche de l'adresse de retour
+