Banque Centrale (serveur unique)
    └── Compte Alice: 1000€
    └── Compte Bob: 500€
    └── Compte Charlie: 200€
    
Si Alice donne 50€ à Bob :
    Alice envoie la demande à la banque
    La banque modifie son registre unique
    Tout le monde doit faire confiance à la banque

Ordinateur d'Alice:    Alice:1000€ | Bob:500€ | Charlie:200€
Ordinateur de Bob:     Alice:1000€ | Bob:500€ | Charlie:200€
Ordinateur de Charlie: Alice:1000€ | Bob:500€ | Charlie:200€
Ordinateur de David:   Alice:1000€ | Bob:500€ | Charlie:200€
(1000 autres ordinateurs...)

Si Alice donne 50€ à Bob :
    1. Alice annonce à tous : "Je donne 50€ à Bob"
    2. Chaque ordinateur vérifie qu'Alice a bien 50€
    3. Si la majorité est d'accord, tous mettent à jour leur copie
    4. Personne ne peut tricher car les autres ont la bonne version

# Simulation simple d'une base distribuée
class NoeudReseau:
    def __init__(self, nom):
        self.nom = nom
        self.registre = {"Alice": 100, "Bob": 50}
    
    def proposer_transaction(self, donneur, receveur, montant):
        if self.registre[donneur] >= montant:
            # Proposition de modification
            return {"donneur": donneur, "receveur": receveur, "montant": montant}
        return None

# Création du réseau distribué (plusieurs ordinateurs)
reseau = [
    NoeudReseau("Ordi_Alice"),
    NoeudReseau("Ordi_Bob"),
    NoeudReseau("Ordi_Charlie"),
    NoeudReseau("Ordi_David")
]

# Transaction proposée
transaction = reseau[0].proposer_transaction("Alice", "Bob", 30)

# Vote de chaque nœud
votes = 0
for noeud in reseau:
    if noeud.registre["Alice"] >= 30:
        votes += 1
        print(f"{noeud.nom} vote OUI")
    else:
        print(f"{noeud.nom} vote NON")

# Consensus
if votes > len(reseau) / 2:  # Majorité
    print("✅ Consensus atteint ! Transaction validée")
    # Tous les nœuds mettent à jour leur registre
    for noeud in reseau:
        noeud.registre["Alice"] -= 30
        noeud.registre["Bob"] += 30
else:
    print("❌ Pas de consensus - Transaction rejetée")

>>> Ordi_Alice vote OUI
Ordi_Bob vote OUI
Ordi_Charlie vote OUI
Ordi_David vote OUI
✅ Consensus atteint ! Transaction validée

import hashlib

# Peu importe la taille d'entrée, SHA256 donne TOUJOURS 64 caractères hexadécimaux
textes = ["a", "NSI", "Un très long texte..." * 1000]

for texte in textes:
    hash_resultat = hashlib.sha256(texte.encode()).hexdigest()
    print(f"Entrée ({len(texte)} car.) → Hash SHA256 ({len(hash_resultat)} car.)")
    print(f"'{texte[:42]}' → {hash_resultat}")
# Résultat : TOUJOURS 64 caractères hexadécimaux !
>>> Entrée (1 car.) → Hash SHA256 (64 car.)
'a' → ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb
Entrée (3 car.) → Hash SHA256 (64 car.)
'NSI' → a0c87b3a9a3f13c4dc2ce2abde4d7dd4a5fb2fd26af757ccfe22cf5ce4840ecf
Entrée (21000 car.) → Hash SHA256 (64 car.)
'Un très long texte...Un très long texte...' → 7b4af83cfbbb1f3089159a3144fbbe485d283fdfedbb4f9f0d2052a0a3ec16f4

# La moindre modification change TOUT le hash
message1 = "Alice donne 10€ à Bob"
message2 = "Alice donne 10€ à Bob."  # Un point en plus !

hash1 = hashlib.sha256(message1.encode()).hexdigest()
hash2 = hashlib.sha256(message2.encode()).hexdigest()

print(f"Message 1: {message1}")
print(f"Hash 1: {hash1[:30]}...")
print(f"Message 2: {message2}")
print(f"Hash 2: {hash2[:30]}...")

if hash1 != hash2:
    print("\n✅ Même avec 1 caractère de différence, les hash sont COMPLÈTEMENT différents !")
    
>>> Message 1: Alice donne 10€ à Bob
Hash 1: dcb9b3bc4a118c83965427433de6fe...
Message 2: Alice donne 10€ à Bob.
Hash 2: a8d58b572a33f4f4ca101533715145...

✅ Même avec 1 caractère de différence, les hash sont COMPLÈTEMENT différents !

# SHA256 est à sens unique
def demonstration_sens_unique():
    print("🔐 On peut calculer le hash, mais pas retrouver le message :")
    message_secret = "MotDePasseSuperSecret"
    hash_secret = hashlib.sha256(message_secret.encode()).hexdigest()
    print(f"Message secret : {message_secret}")
    print(f"Hash : {hash_secret[:30]}...")
    print("\nSi quelqu'un pirate la blockchain et trouve ce hash :")
    print("❌ Il ne peut PAS retrouver le message original !")
    print("✅ Mais il peut vérifier si un message proposé correspond au hash")

>>> demonstration_sens_unique()
🔐 On peut calculer le hash, mais pas retrouver le message :
Message secret : MotDePasseSuperSecret
Hash : 72bb4dffe16f935aa619207c5c12fd...
-
Si quelqu'un pirate la blockchain et trouve ce hash :
❌ Il ne peut PAS retrouver le message original !
✅ Mais il peut vérifier si un message proposé correspond au hash

def atelier_sha256():
    # 1. Test avec différents types de données
    print("1 SHA256 avec différents types :")
    donnees_test = [
        "42",  # Un nombre
        "42",  # Le même nombre (vérification)
        "43",  # Nombre différent
        "Hello World",  # Texte
        ""  # Chaîne vide
    ]
    
    for donnee in donnees_test:
        hash_result = hashlib.sha256(str(donnee).encode()).hexdigest()
        print(f"'{donnee}' → {hash_result[:20]}...")
    
    # 2. Démonstration de la taille fixe
    print(f"\n2 Taille fixe : Toujours 64 caractères hexadécimaux")
    print(f"   Un caractère → {len(hashlib.sha256(b'a').hexdigest())} caractères")
    print(f"   Un livre entier → {len(hashlib.sha256(b'a'*1000000).hexdigest())} caractères")
    
    # 3. Propriété d'avalanche visuelle
    print("\n3 Effet d'avalanche (visualisation) :")
    msg_base = "NSI"
    msg_modifie = "NSi"  # juste 'i' minuscule au lieu de 'I' majuscule
    
    hash_base = hashlib.sha256(msg_base.encode()).hexdigest()
    hash_modifie = hashlib.sha256(msg_modifie.encode()).hexdigest()
    
    print(f"'{msg_base}' → {hash_base}")
    print(f"'{msg_modifie}' → {hash_modifie}")
    
    # Comparaison caractère par caractère
    differences = sum(1 for a, b in zip(hash_base, hash_modifie) if a != b)
    print(f"\n👉 {differences} caractères différents sur 64 !")

atelier_sha256()

>>>🔨 Atelier SHA256
1 SHA256 avec différents types :
'42' → 73475cb40a568e8da8a0...
'42' → 73475cb40a568e8da8a0...
'43' → 44cb730c420480a0477b...
'Hello World' → a591a6d40bf420404a01...
'' → e3b0c44298fc1c149afb...
-
2 Taille fixe : Toujours 64 caractères hexadécimaux
   Un caractère → 64 caractères
   Un livre entier → 64 caractères
-
3 Effet d'avalanche (visualisation) :
'NSI' → a0c87b3a9a3f13c4dc2ce2abde4d7dd4a5fb2fd26af757c
cfe22cf5ce4840ecf
'NSi' → 5c308e3beb80e8f9559b3e0a08ba4bc6f7669dbca05353f
053d89335a4e96c4e
-
👉 61 caractères différents sur 64 !

def comparer_hashage(texte):
    print(f"Texte à hasher : '{texte}'")
    print(f"SHA256 : {hashlib.sha256(texte.encode()).hexdigest()[:40]}...")
    print(f"SHA1   : {hashlib.sha1(texte.encode()).hexdigest()[:40]}...")
    print(f"MD5    : {hashlib.md5(texte.encode()).hexdigest()[:40]}...")
    print("-" * 50)

print("🔬 Comparaison des algorithmes de hash :")
comparer_hashage("NSI")
comparer_hashage("NSI c'est génial!")

print("✅ SHA256 est le plus sécurisé (utilisé par Bitcoin)")
print("⚠️  MD5 et SHA1 sont maintenant considérés comme vulnérables")

>>>🔬 Comparaison des algorithmes de hash :
Texte à hasher : 'NSI'
SHA256 : a0c87b3a9a3f13c4dc2ce2abde4d7dd4a5fb2fd2...
SHA1   : 5a63a58f8d68fd8d8dc685aafe89a626036d7619...
MD5    : 5848127ecd37d8c56f45572e9ed4cc6a...
--------------------------------------------------
Texte à hasher : 'NSI c'est génial!'
SHA256 : 35b2efe9fe83531ca6753f536607b5b0f8ad596a...
SHA1   : e0922b950f59af9671ce00c6161097276c9f52ae...
MD5    : 149c9273e2e27d570f9fac0f432a4f7f...
--------------------------------------------------
✅ SHA256 est le plus sécurisé (utilisé par Bitcoin)
⚠️  MD5 et SHA1 sont maintenant considérés comme vulnérables

from datetime import datetime
import time
# Exemple 1: Timestamp simple
moment_present = datetime.now()
print(f"Timestamp lisible : {moment_present}")
# Exemple 2: Timestamp en secondes (standard informatique)
timestamp_unix = time.time()
print(f"Timestamp Unix (secondes depuis 1970) : {timestamp_unix}")

>>>Timestamp lisible : 2026-03-23 12:52:28.965000
Timestamp Unix (secondes depuis 1970) : 1774288348.997

# Sans timestamp, on ne saurait pas dans quel ordre sont les blocs !
bloc_1 = {"index": 1, "transaction": "Alice donne 10€ à Bob"}
bloc_2 = {"index": 2, "transaction": "Bob dépense ses 10€"}

# Mais si quelqu'un inverse l'ordre, Bob dépense de l'argent qu'il n'a pas encore !
# Le timestamp empêche ça :
bloc_1_avec_timestamp = {
    "index": 1, 
    "transaction": "Alice donne 10€ à Bob",
    "timestamp": "2024-12-15 10:00:00"  # D'abord Alice donne
}
bloc_2_avec_timestamp = {
    "index": 2, 
    "transaction": "Bob achète un café",
    "timestamp": "2024-12-15 10:05:00"  # Ensuite Bob dépense
}
# L'ordre est clair et vérifiable !

# Situation problématique sans timestamp
print("🚨 SANS TIMESTAMP :")
transaction_1 = "Bob donne 10€ à Alice"
transaction_2 = "Bob donne 10€ à Charlie"
# On ne sait pas laquelle est valide ! Bob a peut-être dépensé 2 fois les mêmes 10€

# Avec timestamp, c'est clair
print("\n✅ AVEC TIMESTAMP :")
transaction_1 = {"montant": "10€", "de": "Bob", "à": "Alice", "timestamp": "10:00"}
transaction_2 = {"montant": "10€", "de": "Bob", "à": "Charlie", "timestamp": "10:01"}

if transaction_2["timestamp"] > transaction_1["timestamp"]:
    print("Bob a dépensé ses 10€ à 10:00, puis à 10:01 il n'avait plus rien → TRANSACTION FRAUDULEUSE DÉTECTÉE !")

import hashlib
import json
from datetime import datetime

def creer_bloc(transaction):
    bloc = {
        "transaction": transaction,
        "timestamp": str(datetime.now()),  # Le timestamp est inclus !
        "previous_hash": "abc123..."
    }
    
    # Le hash est calculé à partir de TOUT le bloc, y compris le timestamp
    bloc_string = json.dumps(bloc, sort_keys=True)
    bloc["hash"] = hashlib.sha256(bloc_string.encode()).hexdigest()
    
    return bloc

# Si on essaye de modifier le timestamp après coup :
bloc = creer_bloc("Alice → Bob: 10€")
print(f"Hash original: {bloc['hash'][:20]}...")

# On modifie même juste 1 seconde
bloc["timestamp"] = "2024-12-16"  # Changement de jour
nouveau_hash = hashlib.sha256(json.dumps(bloc, sort_keys=True).encode()).hexdigest()
print(f"Nouveau hash: {nouveau_hash[:20]}...")
print("👀 Le hash a complètement changé ! La blockchain détecte la modification.")

import random
from datetime import datetime, timedelta

print(" JEU : DÉTECTIVE DU TIMESTAMP")
print("Voici 3 transactions. Laquelle est frauduleuse ?\n")

transactions = [
    {
        "description": "Alice achète un café",
        "timestamp": datetime.now()
    },
    {
        "description": "Alice achète un sandwich",
        "timestamp": datetime.now() - timedelta(hours=1)
    },
    {
        "description": "Alice donne 50€ à Bob",
        "timestamp": datetime.now() + timedelta(days=1)  # Dans le futur !
    }
]

for i, t in enumerate(transactions, 1):
    print(f"{i}. {t['description']} - {t['timestamp'].strftime('%d/%m/%Y %H:%M')}")

print("\n🔍 Indice : Regarde bien les dates...")
print("✅ Réponse : La transaction 3 est frauduleuse car elle a un timestamp DANS LE FUTUR !")
print("Dans une vraie blockchain, impossible d'avoir un bloc avec une date future.")

>>> JEU : DÉTECTIVE DU TIMESTAMP
Voici 3 transactions. Laquelle est frauduleuse ?
-
1. Alice achète un café - 23/03/2026 12:58
2. Alice achète un sandwich - 23/03/2026 11:58
3. Alice donne 50€ à Bob - 24/03/2026 12:58
-
🔍 Indice : Regarde bien les dates...
✅ Réponse : La transaction 3 est frauduleuse car elle a
un timestamp DANS LE FUTUR !
Dans une vraie blockchain, impossible d'avoir un bloc a
vec une date future.

# À faire avec les élèves :
print("📝 EXERCICE : À toi de jouer !")

# Crée ton propre bloc avec timestamp
mon_bloc = {
    "timestamp": datetime.now(),
    "couleur_preferee": input("Quelle est ta couleur préférée ? ")
}

# Calcule son hash
hash_du_bloc = hashlib.sha256(str(mon_bloc).encode()).hexdigest()
print(f"\n✅ Ton bloc personnel a été créé à {mon_bloc['timestamp']}")
print(f"Il a pour identifiant unique (hash) : {hash_du_bloc[:30]}...")

# Maintenant, si tu changes ne serait-ce qu'une lettre dans le message :
print("\n🔄 Essaie de modifier ton message ou pas pour constater que tu obtiens un hash totalement différent ...")
print("👉 C'est ça, la magie de la blockchain !")