Travaux Pratiques | Chapitre 4 : Internet | Informatique 3eme PF
INFORMATIQUE | 3e Programme Français
M Abdourahmane BALDE | Le College Bilingue.
[Link]@[Link] | [Link]@[Link]
CHAPITRE 4 : INTERNET
TRAVAUX PRATIQUES | Commandes & Python
Ce document contient
Partie 1 : NOTIONS D'INTERNET
TP 1 - Scanner le réseau avec Python (socket, ping)
TP 2 - Analyser les protocoles DNS avec nslookup et Python
TP 3 - Tester la connectivité et la vitesse réseau
Partie 2 : COMPRENDRE LE WEB
TP 4 - Inspecter et décoder des URL avec Python
TP 5 - Faire des requêtes HTTP/HTTPS avec Python (requests)
TP 6 - Scraper et analyser une page web (BeautifulSoup)
TP 7 - Mesurer les temps de réponse des serveurs
Partie 3 : SECURITE ET CONFIDENTIALITE
TP 8 - Detecter le phishing avec Python (analyse d'URL)
TP 9 - Generateur et evaluateur de mots de passe
TP 10 - Chiffrement simple : cryptage de messages
TP 11 - Analyser les en-tetes HTTP de securite
Prerequis et installation
Python 3.x installe sur votre machine
Commande d'installation des bibliothèques :
pip install requests beautifulsoup4 colorama
Éditeur recommande : IDLE (fourni avec Python), Thonny, ou VS Code
Systeme : Windows (CMD) ou Linux/macOS (Terminal Bash)
Python & Commandes Systeme
Travaux Pratiques | Chapitre 4 : Internet | Informatique 3eme PF
PARTIE 1 : NOTIONS D'INTERNET
TP 1 : Decouvrir son reseau avec les commandes [Bash + CMD]
systeme
Objectif : Apprendre à utiliser les commandes de base pour explorer son réseau et
comprendre les adresses IP.
Etape 1 : Commandes de base réseau
Ouvre un terminal (Linux/Mac) ou l'Invite de commandes (Windows) et tape ces commandes :
Connaitre son adresse IP locale et sa configuration reseau :
Bash / Terminal Linux
# Linux / macOS - affiche la configuration reseau complete
ip addr show
# Alternative plus simple
hostname -I
# Windows - equivalent dans CMD
ipconfig
# Windows - version detaillee (passerelle, DNS, masque...)
ipconfig /all
Tester la connectivité vers un serveur distant (ping) :
Bash / Terminal Linux
# Envoyer 4 paquets vers Google (verifier la connexion Internet)
ping [Link]
# Linux : limiter a 5 paquets
ping -c 5 [Link]
# Ping vers l'adresse IP de Google directement
ping [Link]
# Tracer le chemin des paquets jusqu'a destination
tracert [Link] # Windows
traceroute [Link] # Linux / macOS
Resultat attendu dans le terminal :
Pinging [Link] [[Link]] with 32 bytes of data:
Python & Commandes Systeme
Travaux Pratiques | Chapitre 4 : Internet | Informatique 3eme PF
Reply from [Link]: bytes=32 time=12ms TTL=55
Reply from [Link]: bytes=32 time=11ms TTL=55
Ping statistics: Packets: Sent = 4, Received = 4, Lost = 0 (0% loss)
Approximate round trip times in milli-seconds: Minimum = 11ms, Maximum =
12ms
Etape 2 : Script Python - Mon identité réseau
Cree un fichier identite_reseau.py et tape le code suivant :
Python
# identite_reseau.py - Affiche les informations réseau de la machine
import socket
import subprocess
import platform
def get_local_ip():
# Connexion fictive pour déterminer l'IP locale
s = [Link](socket.AF_INET, socket.SOCK_DGRAM)
try:
[Link](("[Link]", 80)
ip = [Link]()[0]
finally:
[Link]()
return ip
def get_hostname():
return [Link]()
def get_public_ip():
import [Link]
try:
url = "[Link]
with [Link](url, timeout=5) as r:
return [Link]().decode()
except:
return "Non disponible (pas d'Internet)"
# ─── Programme principal ─────────────────────────────────
print("="*50
print(" MON IDENTITE RESEAU"
print("="*50
print(f"Systeme : {[Link]()} {[Link]()}"
print(f"Nom machine : {get_hostname()}"
print(f"IP locale : {get_local_ip()}"
print(f"IP publique : {get_public_ip()}"
print("="*50
Resultat attendu dans le terminal :
==================================================
MON IDENTITE RESEAU
Python & Commandes Systeme
Travaux Pratiques | Chapitre 4 : Internet | Informatique 3eme PF
==================================================
Systeme : Windows 11
Nom machine : PC-ELEVE-01
IP locale : [Link]
IP publique : [Link]
==================================================
TP 2 : Analyser le DNS - Résoudre des noms de [Bash +
domaine Python]
Objectif : Comprendre comment fonctionne le DNS en traduisant des noms de domaine
en adresses IP.
Etape 1 : Commandes DNS
Bash / Terminal Linux
# Resoudre un nom de domaine en adresse IP
nslookup [Link]
nslookup [Link]
nslookup [Link]
# Obtenir tous les enregistrements DNS d'un domaine
nslookup -type=ANY [Link]
# Linux : utiliser 'dig' pour plus de details
dig [Link]
dig +short [Link] # Affiche seulement l'IP
dig MX [Link] # Enregistrements email (MX)
# Verifier si un site est accessible depuis son IP
ping -n 1 [Link] # Windows
ping -c 1 [Link] # Linux
Etape 2 : Script Python - Résolveur DNS
Python
# dns_resolver.py - Résoudre et analyser des domaines
import socket
def resoudre_domaine(domaine:
try:
ip = [Link](domaine)
return ip
except [Link]:
return "INTROUVABLE"
def ip_vers_domaine(ip:
Python & Commandes Systeme
Travaux Pratiques | Chapitre 4 : Internet | Informatique 3eme PF
# Recherche inverse : IP -> nom de domaine
try:
nom = [Link](ip)[0]
return nom
except:
return "Non trouve"
# Liste de sites a analyser
sites = [
"[Link]","[Link]","[Link]",
"[Link]","[Link]"
]
print(f"{"Domaine":<25} {"Adresse IP":<20} {"Statut"}"
print("-"*60
for site in sites:
ip = resoudre_domaine(site)
statut = "OK" if ip != "INTROUVABLE" else "ERREUR"
print(f" {site:<25} {ip:<20} {statut}"
print() # Ligne vide
# Recherche inverse sur l'IP de Google
ip_google = "[Link]"
print(f"Recherche inverse de {ip_google} : {ip_vers_domaine(ip_google)}"
Resultat attendu dans le terminal :
Domaine Adresse IP Statut
------------------------------------------------------------
[Link] [Link] OK
[Link] [Link] OK
[Link] [Link] OK
[Link] [Link] OK
[Link] [Link] OK
Recherche inverse de [Link] : [Link]
TP 3 : Tester la connectivité réseau avec Python [Python]
Objectif : Coder un script Python qui teste la connectivité vers plusieurs serveurs et
mesure les temps de réponse.
Python
# testeur_reseau.py - Teste la connexion vers plusieurs sites
import socket
import time
def tester_port(hote, port=80, timeout=3)
Teste si un port est ouvert sur un hote distant
Python & Commandes Systeme
Travaux Pratiques | Chapitre 4 : Internet | Informatique 3eme PF
debut = [Link]()
try:
s = socket.create_connection((hote, port), timeout=timeout)
[Link]()
ms = round(([Link]() - debut) * 1000, 1)
return True, ms
except:
return False, None
# Sites et ports a tester (port 80=HTTP, 443=HTTPS, 53=DNS)
cibles = [
("[Link]", 443, "HTTPS"),
("[Link]", 443, "HTTPS"),
("[Link]", 53, "DNS"),
("[Link]", 443, "HTTPS"),
]
print(" TEST DE CONNEXION RESEAU"
print("="*55
print(f"{"Site":<20} {"Port":<8} {"Statut":<12} {"Latence"}"
print("-"*55
for hote, port, proto in cibles:
ok, ms = tester_port(hote, port)
statut = "[ OK ]" if ok else "[ ERREUR ]"
latence = f'{ms} ms' if ms else "-"
print(f" {hote:<20} {proto:<8} {statut:<12} {latence}"
print("="*55
Resultat attendu dans le terminal :
TEST DE CONNEXION RESEAU
=======================================================
Site Port Statut Latence
-------------------------------------------------------
[Link] HTTPS [ OK ] 12.3 ms
[Link] HTTPS [ OK ] 45.1 ms
[Link] DNS [ OK ] 8.7 ms
[Link] HTTPS [ OK ] 14.2 ms
=======================================================
Python & Commandes Systeme
Travaux Pratiques | Chapitre 4 : Internet | Informatique 3eme PF
PARTIE 2 : COMPRENDRE LE WEB
TP 4 : Disséquer et decoder des URL avec Python [Python]
Objectif : utiliser Python pour décomposer une URL en ses éléments et en comprendre
chaque composant.
Python
# analyseur_url.py - Décomposer et analyser des URL
from [Link] import urlparse, urlencode, parse_qs
def analyser_url(url:
print("\n" + "="*60
print(f"URL analysee : {url}"
print("="*60
p = urlparse(url)
print(f" Protocole (scheme) : {[Link]}"
print(f" Domaine (netloc) : {[Link]}"
print(f" Chemin (path) : {[Link]}"
print(f" Parametres (query) : {[Link]}"
print(f" Fragment (#) : {[Link]}"
# Verifier si HTTPS (securise)
securise = [Link] == "https"
print(f" Connexion securisee : {"OUI (HTTPS) " if securise else
"NON (HTTP) "}"
# Decomposer les parametres de requete
if [Link]:
params = parse_qs([Link])
print(" Parametres decodes :"
for k, v in [Link]():
print(f" {k} = {v[0]}"
# Extraire l'extension TLD
domaine = [Link]("www.", "")
parties = [Link](".")
if len(parties) >= 2:
print(f" Extension TLD : .{parties[-1]}"
# Tester avec differentes URL
urls_test = [
"[Link]
"[Link]
"[Link]
]
for url in urls_test:
analyser_url(url)
Python & Commandes Systeme
Travaux Pratiques | Chapitre 4 : Internet | Informatique 3eme PF
Resultat attendu dans le terminal :
============================================================
URL analysee : [Link]
============================================================
Protocole (scheme) : https
Domaine (netloc) : [Link]
Chemin (path) : /search
Parametres (query) : q=informatique&hl=fr
Fragment (#) :
Connexion securisee : OUI (HTTPS)
Parametres decodes :
q = informatique
hl = fr
Extension TLD : .com
TP 5 : Faire des requêtes HTTP avec Python [Python]
(requests)
Objectif : Utiliser la bibliothèque 'requests' pour communiquer avec des serveurs web et
analyser les réponses HTTP.
Installation requise
pip install requests
Python
# requetes_http.py - Analyser les reponses HTTP
import requests
def analyser_reponse(url:
print(f"\n Requete vers : {url}"
print("-"*55
try:
reponse = [Link](url, timeout=5, allow_redirects=True)
# Code de statut HTTP
code = reponse.status_code
signif = {200: "OK", 301: "Redirection permanente"
302: "Redirection temp.", 404: "Page non trouvee"
403: "Acces interdit", 500: "Erreur serveur"
}.get(code, "Code inconnu")
print(f" Code HTTP : {code} ({signif})"
print(f" URL finale : {[Link]}"
# En-tetes importants
h = [Link]
Python & Commandes Systeme
Travaux Pratiques | Chapitre 4 : Internet | Informatique 3eme PF
print(f" Serveur : {[Link]("Server", "Non divulgue")}"
print(f" Type contenu : {[Link]("Content-Type", "?")}"
print(f" Taille reponse : {len([Link])} octets"
print(f" HTTPS : {"OUI" if
[Link]("https") else "NON"}"
except [Link] as e:
print(f" ERREUR : {e}"
# Tester plusieurs sites
for url in ["[Link] "[Link]
"[Link]
analyser_reponse(url)
TP 6 : Scraper et analyser une page web [Python]
(BeautifulSoup)
Objectif : Télécharger une page web et extraire son contenu structuré : titre, liens, texte.
Installation requise
pip install requests beautifulsoup4
Python
# analyseur_page.py - Extraire les informations d'une page web
import requests
from bs4 import BeautifulSoup
from [Link] import urlparse
def analyser_page(url:
print(f"\n Analyse de : {url}\n"
try:
rep = [Link](url, timeout=8, headers={"User-Agent":
"Mozilla/5.0"})
soup = BeautifulSoup([Link], "[Link]")
# 1. Titre de la page
titre = [Link] if [Link] else "Sans titre"
print(f" TITRE : {titre}"
# 2. Compter les elements HTML
print(f" Liens <a> : {len(soup.find_all("a"))} liens trouves"
print(f" Images <img>: {len(soup.find_all("img"))} images
trouvees"
print(f" Titres <h1> : {len(soup.find_all("h1"))} titres
principaux"
# 3. Extraire les 5 premiers liens
print("\n Premiers liens trouves :"
domaine_base = urlparse(url).netloc
liens = [a["href"] for a in soup.find_all("a", href=True) if
"http" in a["href"]][:5]
for i, l in enumerate(liens, 1:
Python & Commandes Systeme
Travaux Pratiques | Chapitre 4 : Internet | Informatique 3eme PF
print(f" {i}. {l[:70]}"
# 4. Premier paragraphe
premier_p = [Link]("p")
if premier_p:
texte = premier_p.get_text()[:150]
print(f"\n Debut du contenu :\n {texte}..."
except Exception as e:
print(f" Impossible d'analyser : {e}"
analyser_page("[Link]
TP 7 : Mesurer les temps de réponse des serveurs [Python]
web
Objectif : Comparer les performances de différents sites web en mesurant leur temps de
réponse.
Python
# benchmark_sites.py - Mesurer la vitesse de reponse des sites
import requests
import time
def mesurer_vitesse(url, nb_essais=3:
temps_list = []
for _ in range(nb_essais:
try:
debut = [Link]()
r = [Link](url, timeout=5)
fin = [Link]()
temps_list.append((fin - debut) * 1000)
except:
temps_list.append(None)
valides = [t for t in temps_list if t is not None]
if valides:
return round(sum(valides) / len(valides), 1)
return None
def barre_vitesse(ms:
# Representation visuelle ASCII de la vitesse
if ms is None: return "[ERREUR]"
if ms < 200: return "[### ] RAPIDE"
elif ms < 500: return "[###### ] MOYEN"
else: return "[##########] LENT"
sites = ["[Link] "[Link]
"[Link]
print("\n BENCHMARK DES SITES WEB (3 mesures par site)"
print("="*60
print(f"{"Site":<25} {"Moy (ms)":<12} Evaluation"
Python & Commandes Systeme
Travaux Pratiques | Chapitre 4 : Internet | Informatique 3eme PF
print("-"*60
for site in sites:
print(f" Test de {site}...", end="", flush=True)
ms = mesurer_vitesse(site)
nom = [Link]("[Link] "")
print(f"\r {nom:<25} {str(ms) + " ms" if ms else "ERREUR":<12}
{barre_vitesse(ms)}"
Resultat attendu dans le terminal :
BENCHMARK DES SITES WEB (3 mesures par site)
============================================================
Site Moy (ms) Evaluation
------------------------------------------------------------
[Link] 124.3 ms [### ] RAPIDE
[Link] 341.7 ms [###### ] MOYEN
[Link] 178.2 ms [### ] RAPIDE
Python & Commandes Systeme
Travaux Pratiques | Chapitre 4 : Internet | Informatique 3eme PF
PARTIE 3 : SECURITE ET CONFIDENTIALITE
TP 8 : Détecteur de Phishing - Analyser des URL [Python]
suspectes
Objectif : Coder un script Python qui analyse des URL et détecte les caractéristiques
typiques des sites de phishing.
Python
# detecteur_phishing.py - Analyser le risque d'une URL
from [Link] import urlparse
import re
# Domaines connus et legitimes (whitelist)
DOMAINES_LEGIT = {"[Link]", "[Link]", "[Link]", "[Link]",
"[Link]", "[Link]", "[Link]"}
# TLD souvent associés au phishing
TLD_SUSPECTS = [".tk", ".ml", ".ga", ".cf", ".gq", ".ru", ".xyz", ".cc"]
# Mots evoquant l'urgence ou la manipulation
MOTS_ALERTE = ["login", "secure", "verify", "update", "suspended",
"urgent", "confirm", "account", "bank", "paypal",
"password"]
def analyser_phishing(url:
score = 0
alertes = []
p = urlparse(url)
domaine = [Link]().replace("www.", "")
url_bas = [Link]()
1. Verifier le protocole
if [Link] != "https":
score += 25
[Link]("Pas de HTTPS - connexion non securisee")
2. URL trop longue (>75 caracteres = suspect)
if len(url) > 75:
score += 15
[Link](f"URL tres longue ({len(url)} caracteres)"
3. TLD suspect
for tld in TLD_SUSPECTS:
if [Link](tld):
score += 30
[Link](f"TLD suspect detecte : {tld}"
4. Chiffres excessifs dans le domaine
if len([Link]("r\\d", domaine)) > 4:
score += 20
[Link]("Trop de chiffres dans le domaine")
Python & Commandes Systeme
Travaux Pratiques | Chapitre 4 : Internet | Informatique 3eme PF
5. Mots d'alerte dans l'URL
for mot in MOTS_ALERTE:
if mot in url_bas:
score += 10
[Link](f"Mot suspect dans l'URL : "{mot}""
6. Imitation d'un domaine connu
for legit in DOMAINES_LEGIT:
nom = [Link](".")[0]
if nom in domaine and legit not in domaine:
score += 40
[Link](f"Imitation du domaine : {legit}"
Verdict final
if score >= 60: verdict = " PHISHING PROBABLE"
elif score >= 30: verdict = " SUSPECT"
else: verdict = " PROBABLEMENT SUR"
return score, verdict, alertes
# Tests
urls_test = [
"[Link]
"[Link]
"[Link]
"[Link]
]
print("\n ANALYSEUR DE PHISHING"
print("="*65
for url in urls_test:
score, verdict, alertes = analyser_phishing(url)
print(f"\nURL : {url[:55]}..."
print(f"Score de risque : {score}/100 => {verdict}"
for a in alertes:
print(f" [!] {a}"
Resultat attendu dans le terminal :
ANALYSEUR DE PHISHING
=================================================================
URL : [Link]
Score de risque : 0/100 => PROBABLEMENT SUR
URL : [Link]
Score de risque : 85/100 => PHISHING PROBABLE
[!] Pas de HTTPS - connexion non securisee
[!] TLD suspect detecte : .tk
[!] Imitation du domaine : [Link]
[!] Mot suspect dans l'URL : "login"
Python & Commandes Systeme
Travaux Pratiques | Chapitre 4 : Internet | Informatique 3eme PF
[!] Mot suspect dans l'URL : "verify"
URL : [Link]
Score de risque : 75/100 => PHISHING PROBABLE
[!] TLD suspect detecte : .ru
[!] Imitation du domaine : [Link]
TP 9 : Générateur et évaluateur de mots de passe [Python]
Objectif : Créer un outil Python qui évalue la solidité d'un mot de passe et en génère des
mots de passe forts.
Python
# mots_de_passe.py - Evaluateur et generateur
import random
import string
def evaluer_mdp(mdp:
score = 0
conseils = []
Critere 1 : Longueur
if len(mdp) >= 16: score += 30
elif len(mdp) >= 12: score += 20
elif len(mdp) >= 8: score += 10
else: [Link]("Trop court : vise au moins 12 caractères")
Critere 2 : Types de caracteres
if any([Link]() for c in mdp): score += 15
else: [Link]("Ajouter des majuscules (A-Z)")
if any([Link]() for c in mdp): score += 15
else: [Link]("Ajouter des minuscules (a-z)")
if any([Link]() for c in mdp): score += 15
else: [Link]("Ajouter des chiffres (0-9)")
speciaux = "!@#$%^&*()-_+=[]{}|;:,.<>?"
if any(c in speciaux for c in mdp): score += 20
else: [Link]("Ajouter des caracteres speciaux (!@#$...)")
Critere 3 : Mots de passe courants a eviter
courants = ["123456", "password", "azerty", "qwerty", "admin"]
if [Link]() in courants:
score = 0
[Link](0, "MOT DE PASSE TROP COMMUN ! A bannir
absolument")
Verdict
if score >= 80: niveau = " EXCELLENT"
elif score >= 60: niveau = " BON"
elif score >= 40: niveau = " MOYEN"
Python & Commandes Systeme
Travaux Pratiques | Chapitre 4 : Internet | Informatique 3eme PF
else: niveau = " FAIBLE"
return score, niveau, conseils
def generer_mdp(longueur=16:
Genere un mot de passe fort et aleatoire
chars = string.ascii_letters + [Link] + "!@#$%&*-_+?"
Garantir au moins un de chaque type
mdp = [
[Link](string.ascii_uppercase),
[Link](string.ascii_lowercase),
[Link]([Link]),
[Link]("!@#$%&*-_+?")
]
mdp += [[Link](chars) for _ in range(longueur - 4)]
[Link](mdp)
return "".join(mdp)
─── Programme principal ──────────────────────────────────
tests = ["123456", "monprenom2008", "Tr@il-Bl@zer_2025!"]
print("\n EVALUATION DE MOTS DE PASSE"
print("="*55
for mdp in tests:
score, niv, cons = evaluer_mdp(mdp)
print(f"\n Mot de passe : {"*"*len(mdp)} ({len(mdp)} car.)"
print(f" Score : {score}/95 => {niv}"
for c in cons: print(f" [!] {c}"
print("\n GENERATION DE MOTS DE PASSE FORTS"
print("="*55
for i in range(4:
mdp = generer_mdp(16)
score, niv, _ = evaluer_mdp(mdp)
print(f" {mdp} => {niv} ({score}/95)"
Resultat attendu dans le terminal :
EVALUATION DE MOTS DE PASSE
=======================================================
Mot de passe : ****** (6 car.)
Score : 0/95 => FAIBLE
[!] MOT DE PASSE TROP COMMUN ! A bannir absolument
Mot de passe : ************* (13 car.)
Score : 45/95 => MOYEN
[!] Ajouter des majuscules (A-Z)
[!] Ajouter des caracteres speciaux (!@#$...)
Mot de passe : ****************** (18 car.)
Score : 95/95 => EXCELLENT
Python & Commandes Systeme
Travaux Pratiques | Chapitre 4 : Internet | Informatique 3eme PF
GENERATION DE MOTS DE PASSE FORTS
=======================================================
Xk#7mP!qR9nL@2vW => EXCELLENT (95/95)
B!4zQw@mN8xK#3pL => EXCELLENT (95/95)
TP 10 : Chiffrement simple - Crypter et decrypter des [Python]
messages
Objectif : Comprendre les bases du chiffrement en implementant le chiffre de Cesar et le
chiffrement XOR.
Python
# [Link] - Chiffrement de Cesar et XOR
═══ 1. CHIFFRE DE CESAR ══════════════════════════════════
def cesar_chiffrer(message, decalage:
resultat = ""
for c in message:
if [Link]():
base = ord("A") if [Link]() else ord("a")
resultat += chr((ord(c) - base + decalage) % 26 + base)
else:
resultat += c # Garder les espaces et chiffres
return resultat
def cesar_dechiffrer(message, decalage:
return cesar_chiffrer(message, -decalage)
═══ 2. CHIFFREMENT XOR ══════════════════════════════════
def xor_chiffrer(message, cle:
Chiffrement symetrique : meme fonction pour chiffrer et dechiffrer
resultat = ""
for i, c in enumerate(message:
c_cle = cle[i % len(cle)]
chiffre = chr(ord(c) ^ ord(c_cle))
resultat += chiffre
return resultat
═══ Programme principal ════════════════════════════════
message = "Internet est un outil puissant"
decalage = 13 # ROT13 : decalage classique
print("=" * 50
print(" CHIFFRE DE CESAR (ROT13)"
print("=" * 50
print(f"Message original : {message}"
chiffre = cesar_chiffrer(message, decalage)
print(f"Message chiffre : {chiffre}"
dechiffre = cesar_dechiffrer(chiffre, decalage)
print(f"Message dechiffre : {dechiffre}"
print() # Ligne vide
print("=" * 50
Python & Commandes Systeme
Travaux Pratiques | Chapitre 4 : Internet | Informatique 3eme PF
print(" CHIFFREMENT XOR"
print("=" * 50
cle = "securite"
msg_xor = xor_chiffrer(message, cle)
print(f"Message original : {message}"
print(f"Cle : {cle}"
print(f"Apres chiffrement : (caracteres speciaux)"
msg_dechiffre = xor_chiffrer(msg_xor, cle) # XOR inverse = meme
fonction
print(f"Apres dechiffrement: {msg_dechiffre}"
Resultat attendu dans le terminal :
==================================================
CHIFFRE DE CESAR (ROT13)
==================================================
Message original : Internet est un outil puissant
Message chiffre : Vagrearg rfg ha bhgvy checffnag
Message dechiffre : Internet est un outil puissant
==================================================
CHIFFREMENT XOR
==================================================
Message original : Internet est un outil puissant
Cle : securite
Apres chiffrement : (caracteres speciaux non affichables)
Apres dechiffrement: Internet est un outil puissant
TP 11 : Inspecter les en-tetes de securite HTTP [Python]
Objectif : Analyser les en-tetes HTTP d'un site web pour evaluer son niveau de securite.
Python
# audit_securite_http.py - Verifier les en-tetes de securite
import requests
En-tetes de securite importants et leur role
ENTETES_SECURITE = {
"Strict-Transport-Security": "Force HTTPS (HSTS)",
"Content-Security-Policy": "Protege contre XSS et injections",
"X-Frame-Options": "Protege contre le clickjacking",
"X-Content-Type-Options": "Previent les attaques MIME",
"Referrer-Policy": "Controle les infos partagees",
"Permissions-Policy": "Controle l'acces camera/micro"
}
def auditer_site(url:
print(f"\n AUDIT SECURITE : {url}"
Python & Commandes Systeme
Travaux Pratiques | Chapitre 4 : Internet | Informatique 3eme PF
print("-"*65
try:
r = [Link](url, timeout=5, verify=True)
h = [Link]
score = 0
total = len(ENTETES_SECURITE)
Verifier chaque en-tete
for entete, desc in ENTETES_SECURITE.items():
present = entete in h
statut = " PRESENT" if present else " ABSENT"
if present: score += 1
print(f" {statut} {entete:<35} {desc}"
Score de securite
pct = round(score / total * 100)
print(f"\n Score securite HTTP : {score}/{total} ({pct}%)"
if pct >= 80: BI(print)(" Site bien protege ")
elif pct >= 50: BI(print)(" Protection moyenne")
else: BI(print)(" Protections insuffisantes")
Info supplementaire : serveur et technologies
print(f" Serveur web : {[Link]("Server", "Cache")}"
print(f" Technologies : {[Link]("X-Powered-By", "Non
divulgue")}"
except Exception as e: print(f" Erreur : {e}"
Auditer plusieurs sites
for site in ["[Link] "[Link]
auditer_site(site)
Résultat attendu dans le terminal :
AUDIT SECURITE : [Link]
-----------------------------------------------------------------
PRESENT Strict-Transport-Security Force HTTPS (HSTS)
PRESENT Content-Security-Policy Protege contre XSS
PRESENT X-Frame-Options Anti-clickjacking
PRESENT X-Content-Type-Options Previent MIME
ABSENT Referrer-Policy Controle partage
PRESENT Permissions-Policy Camera/micro
Score securite HTTP : 5/6 (83%)
Site bien protege
Serveur web : gws
Technologies : Non divulgue
Python & Commandes Systeme
Travaux Pratiques | Chapitre 4 : Internet | Informatique 3eme PF
SYNTHESE DES TRAVAUX PRATIQUES
TP Titre Outils Competences acquises
1 Decouvrir le reseau ping, ipconfig, Adresses IP, connectivite,
socket latence
2 Analyser le DNS nslookup, dig, Resolution de noms, TCP/IP,
socket DNS
3 Tester la connectivite socket, time Ports, TCP, mesure de
performance
4 Dissequer les URL [Link] Structure URL, parametres,
HTTPS
5 Requetes HTTP requests Codes HTTP, en-tetes,
protocoles
6 Scraper une page web BeautifulSoup, HTML, liens, extraction de
requests donnees
7 Benchmark de sites requests, time Performance, latence,
comparaison
8 Detecter le phishing re, [Link] Analyse d'URL, securite,
alertes
9 Mots de passe random, string Securite, entropie, generation
10 Chiffrement Cesar / XOR Bibliotheque Cryptographie, chiffrement
standard sym.
11 Audit en-tetes HTTP requests En-tetes securite, HTTPS,
CSP
Travaux Pratiques - Chapitre 4 : Internet | Informatique - 3eme Programme Francaise
Python & Commandes Systeme