commit f4740594fa6c579bc2fe7638a7c4121b12929d0b
Author: Pierre Ferreira <p.ferreira1@outlook.fr>
Date:   Wed Oct 11 00:50:50 2023 +0200

    :see_no_evil::see_no_evil::see_no_evil:

diff --git a/Enonce.pdf b/Enonce.pdf
new file mode 100644
index 0000000..4cffcff
Binary files /dev/null and b/Enonce.pdf differ
diff --git a/HowRHWork.py b/HowRHWork.py
new file mode 100644
index 0000000..a45c00a
--- /dev/null
+++ b/HowRHWork.py
@@ -0,0 +1,68 @@
+import random
+from colorama import Fore, Style, init
+
+
+# Fonction pour afficher la mémoire actuelle
+def afficher_memoire(memoire, lastEditedLine):
+    for i, ligne in enumerate(memoire):
+        if lastEditedLine != None and i == lastEditedLine:
+            print(Fore.RED + f"Ligne {i + 1}: {' '.join(map(str, ligne))}" + Fore.WHITE)
+        else : 
+            print(Fore.WHITE + f"Ligne {i + 1}: {' '.join(map(str, ligne))}")
+
+# Fonction pour générer une mémoire aléatoire
+def generer_memoire():
+    return [[random.randint(0, 1) for _ in range(10)] for _ in range(10)]
+
+# Fonction pour simuler un coup de marteau
+def coup_de_marteau(memoire):
+    if random.randint(1, 20) == 1:
+        ligne_modifiee = random.randint(0, 9)
+        bit_modifie = random.randint(0, 9)
+        memoire[ligne_modifiee][bit_modifie] = 1 - memoire[ligne_modifiee][bit_modifie]
+        return ligne_modifiee
+    return None
+
+# Fonction principale
+def main():
+    lastEditedLine = None
+    memoire = generer_memoire()
+    print("Bienvenue dans le jeu de la mémoire !")
+    
+    while True:
+        print("\nMenu:")
+        print("1. Afficher la mémoire")
+        print("2. Coup de marteau")
+        print("3. Submit")
+        print("4. Quitter")
+        
+        choix = input("Choisissez une option (1/2/3/4): ")
+        
+        if choix == '1':
+            afficher_memoire(memoire, lastEditedLine)
+        elif choix == '2':
+            ligne_modifiee = coup_de_marteau(memoire)
+            if ligne_modifiee is not None:
+                #print(f"Un coup de marteau a modifié la ligne {ligne_modifiee + 1}.")
+                lastEditedLine = ligne_modifiee
+        elif choix == '3':
+            ligne_guess = int(input("Entrez le numéro de la ligne que vous pensez avoir été modifiée (1-10) : ")) - 1
+            if ligne_guess >= 0 and ligne_guess < 10:
+                #if memoire[ligne_guess] == generer_memoire()[ligne_guess]:
+                if lastEditedLine == ligne_guess :
+                    print(Fore.GREEN + "Félicitations ! Vous avez gagné !"+ Fore.WHITE)
+                    break
+                else:
+                    print(Fore.CYAN + "Désolé, la ligne que vous avez choisie n'a pas été modifiée."+ Fore.WHITE)
+            else:
+                print(Fore.RED + "Numéro de ligne invalide. Veuillez choisir un numéro de ligne entre 1 et 10."+ Fore.WHITE)
+        elif choix == '4':
+            print("Au revoir !")
+            break
+        else:
+            print("Option invalide. Veuillez choisir une option valide (1/2/3/4).")
+
+if __name__ == "__main__":
+    main()
+
+
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..3b612e7
--- /dev/null
+++ b/README.md
@@ -0,0 +1,10 @@
+# TP ROWHAMMER
+
+Bonjour à tous !
+
+Aujourd'hui, vous serez dans la peau de véritable Hacker, près a utiliser l'attaque Rowhammer pour parvenir à leur fin. Je ne vous en dis pas plus !
+Le TP rédigé est disponible ici : ``./Enonce.pdf``
+
+Toutes les autres informations sont disponibles sur ce repos, dépêchez vous, vous avez **30 minutes** !
+
+---
\ No newline at end of file
diff --git a/Top_Secret/CorruptedCode.c b/Top_Secret/CorruptedCode.c
new file mode 100644
index 0000000..144bca9
--- /dev/null
+++ b/Top_Secret/CorruptedCode.c
@@ -0,0 +1,61 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <time.h>
+
+#define NUM_ROWS 1024
+#define NUM_ITERATIONS 1000000
+
+// Fonction pour accéder à une ligne de mémoire et provoquer "rowhammer".
+void accessRow(uint64_t* memory, int row) {
+
+    // Pour chaque itération, nous faisons un XOR sur la ligne de la mémoire sélectionné avec 1.
+    // Rappel : XOR en c se fait avec le symbole " ^ "
+    /***/
+}
+
+int main() {
+
+    //Nous utiliserons le type "uint64_t" qui signifie unsigned long long, un type optimal pour la mémoire.
+    // Allocation de la mémoire (malloc)
+    
+    /*uint64_t* memory =*/ /***/
+
+
+    printf("Exploitation de la vulnérabilité Rowhammer...\n");
+
+    // Initialiser le générateur de nombres aléatoires.
+    srand(time(NULL));
+
+    /// Exploiter la vulnérabilité Rowhammer sur une ligne de mémoire aléatoire.
+
+    // On sélectionne une ligne aléatoire en mémoire > NUM_ROWS, avec la fonction rand() en c
+
+    /*int randomRow = */ /***/ 
+    
+    // Appel de la fonction accessRow
+    accessRow(memory, randomRow);
+
+
+    /// Vérification des erreurs de bits dans la ligne sélectionnée.
+    int bitErrors = 0;
+    
+    // On vérifie que pour chaque itération
+    for (int i = 0; i < NUM_ITERATIONS; i++) {
+        if (memory[randomRow] != 0) {
+            bitErrors++;
+        }
+    }
+
+    // On nettoie la mémoire et libère les ressources.
+    /***/
+
+    if (bitErrors > 0) {
+        printf("Oui, un bit a flipé en mémoire.\n");
+    } else {
+        printf("Non, aucun bit n'a flipé en mémoire.\n");
+    }
+
+    return 0;
+}
+