Ecole Supérieure de Télécommunication

********

Niveau : ING3 Génie Logiciel Enseignant : ALMOU Bassirou

Module : Sécurité des Applications

Une application web désigne un logiciel applicatif hébergé sur un serveur et accessible via un navigateur
web.

Contrairement à un logiciel traditionnel, l’utilisateur d’une application web n’a pas besoin de l’installer sur
son ordinateur. Il lui suffit de se connecter à l’application à l’aide de son navigateur favori. La tendance
actuelle est d’offrir une expérience utilisateur et des fonctionnalités équivalentes aux logiciels directement
installés sur les ordinateurs. Les technologies utilisées pour développer les applications web sont les mêmes
que celles employées dans la création des sites internet.

Serveur Web

Serveur BDD

Client Client
PC1 PC2

Les accès a l’application Web

Architecture a 2 niveaux

Serveurs app Web + BDD

Figure : architecture 2 niveaux

client
 Serveur app Web Serveur BDD

Access via VPN (Virtual Private Network)

Client nomade VPN

Serveur app Web
- Position du pare-feu

LAN

Position dans la zone DMZ

Le pare-feu

Les types de pare-feu

- Pare-feu sans état (stateless firewall)

C'est le plus vieux dispositif de filtrage réseau, introduit sur les routeurs. Il regarde chaque paquet
indépendamment des autres et le compare à une liste de règles préconfigurées.
Ces règles peuvent avoir des noms très différents en fonction du pare-feu :
- « ACL » pour Access Control List (certains pare-feux Cisco),
- politique ou policy (pare-feu Juniper/Netscreen),
- filtres,
- règles ou rules,
- etc.
Netfilter
Netfilter est un framework implémentant le pare-feu au sein du noyau Linux
iptables est un logiciel libre grâce auquel l’administrateur système peut configurer les chaînes et règles du
pare-feu en espace noyau.
Un pare-feu rejette les paquets du réseau selon des règles stockées dans la mémoire du PC.
Linux iptables travaille avec des « chaînes ». Ces chaînes sont des regroupements de règles qui régissent le
trafic réseau en fonction de trois axes : les paquets ; les protocoles ; les ports.
Un paquet ou un datagramme
Il est une représentation d'un phénomène physique. Il forme une unité de confinement où les données
peuvent être examinées, acheminées et filtrées en pour qui concerne leur destination, leur origine et leur
contenu.
iptables -t filter --lis Lister le contenu de la table filter

- La première ligne Chain INPUT (policy ACCEPT) concerne les paquets entrants INPUT.
- target : c'est l'action à prendre, quand des règles seront mises en place, on trouvera dans cette
colonne plusieurs lignes dont chacune aura l'une de ces valeurs :
- ACCEPT (autoriser) ou DROP (interdire) ou REJECT (interdire en envoyant un signal d'interdiction).
- prot : pour protocole, par exemple UDP, TCP
- source : l'IP source de l'ordinateur distant qui se connecte à vous (pour INPUT)
- destination : l'IP de destination de l'ordinateur auquel on se connecte (pour OUTPUT)
- La troisième ligne Chain FORWARD (policy ACCEPT) concerne les paquets qui passent d'une interface
à une autres d'un PC (FORWARD). La maîtrise par iptables de la chaîne FROWARD permet de rediriger
le trafique.
- La cinquième ligne Chain OUTPUT (policy ACCEPT) concerne les paquets sortants (OUTPUT).

Une chaîne est un ensemble de règles définies dans un ordre précis.

iptables -L --line-number INPUT Liste les regles de la chaine INPUT par ordre

Exemple :
num target prot opt source destination
1 ACCEPT tcp -- anywhere anywhere tcp dpt:www
2 ACCEPT tcp -- anywhere anywhere tcp dpt:ssh
3 ACCEPT tcp -- anywhere anywhere tcp dpt:imap2

- La première règle (1) autorise ACCEPT, le protocole tcp, venant de partout anywhere, allant partout
anywhere, et cela pour www, le web (ou port 80).
- La seconde (2) pour ssh
- la troisième (3)pour imap2
NB : Cet ordre est important car iptables lit de haut en bas, et le résultat n'est pas le même selon l'ordre des
règles.
- La dernière colonne indique après les deux points : le protocole.
- Avec l'option -n: iptables -L -n on aurait le numéro de port.
iptables : permet à l’administrateur de configurer les chaînes et règles du pare-feu en espace noyau.
Linux iptables travaille avec des « chaînes ». Ces chaînes sont des regroupements de règles qui régissent le
trafic réseau en fonction de trois axes : les paquets ; les protocoles ; les ports.
Netfilter est un framework implémentant le pare-feu au sein du noyau Linux.
Un pare-feu rejette les paquets du réseau selon des règles stockées dans la mémoire du PC.
FTP = TCP 21/20
SSH = TCP 22
Telnet = TCP 23
Web/http = TCP 80
SSL/https = UDP 4432)
DNS = UDP = 53
DHCP = UDP = 67 et 68
SAMBA = 137-139 et 445
NETBIOS = 137-139
ACTIVE DIRECTORY = 445 NetBios/DNS
SMTP = (email sorti) 253)
POP3 = email entré) 1104)
IMAP = (email entré) 1435)
VPN = 1723
Enfin pour lister les protocoles connus du système cat /etc/protocols

Remarque : iptables ne sert pas uniquement à bloquer certains paquets et n'est pas uniquement utiliser pour
dresser un pare-feu. On peut s'en servir modifier un paquet (table MANGLE), ou pour faire de la redirection
de paquet (table NAT).
Lister les règles de la table filter iptables -t filter --list

Les tables
a. Table NAT (Network Address Translation) : Table utilisée pour la translation d'adresse ou la
translation de port.
Les paquets soumis au NAT voient leur adresse modifiée, en accord avec les règles concernées. Les
paquets d'un flux ne traversent cette table qu'une seule fois. En effet, le sort du premier paquet d'un
flux conditionne celui des autres. Si le premier paquet est accepté, les autres paquets du flux sont
soumis automatiquement au NAT
(ou au camouflage, etc.), donc subissent les mêmes actions que le premier paquet. Par conséquent, ils
ne passeront pas par cette table, mais seront néanmoins traités de la même façon que le premier paquet
du flux. C'est pour cette raison qu'on déconseille le filtrage dans cette table. La chaîne PREROUTING
permet de modifier les paquets dès qu'ils entrent dans le pare-feu. La chaîne OUTPUT permet de
modifier les paquets générés localement (c-à-d. dans le pare-feu) avant qu'ils n'accèdent à la décision
de routage. En dernier lieu, la chaîne POSTROUTING offre la possibilité de modifier les paquets juste
avant qu'ils ne quittent le pare-feu.
Il a 2 types de chaînes :
- PREROUTING qui permet de spécifier « à l'arrivée du pare-feu »
- POSTROUTING qui permet de spécifier « à la sortie du pare-feu ».
 Il existe 3 targets (ou cibles) :
o DNAT
o SNAT
o MASQUERADE.
b. Table FILTER : La table filter devrait être exclusivement consacrée à filtrer les paquets. Par exemple, elle
permet de détruire (DROP), journaliser (LOG), accepter (ACCEPT) ou rejeter (REJECT) des paquets sans
aucun problème, de la même manière que dans les autres tables. Cette table est constituée de trois chaînes
prédéfinies. La première se nomme FORWARD et s'applique à tous les paquets qui ne sont ni générés
localement, ni destinés à l'hôte local (c.-à-d. le pare-feu). La chaîne INPUT s'applique à tous les paquets
destinés à l'hôte local (le pare-feu), et au final, OUTPUT s'applique à tous les paquets générés localement.
c. Table Mangle : Cette table sert à transformer les paquets. Entre autres, on peut modifier le contenu de
différents paquets et celui de leurs en-têtes. Par exemple, on peut changer les champs TTL, TOS ou
MARK. Notez que le champ MARK n'est pas à proprement parlé un changement sur le paquet, mais une
valeur de marquage définie dans l'espace du noyau. D'autres règles ou programmes peuvent s'appuyer sur
ce marquage à l'intérieur du pare-feu pour filtrer ou opérer un routage évolué. Cette table est constituée de
cinq chaînes prédéfinies, qui sont nommées PREROUTING, POSTROUTING, OUTPUT, INPUT et
FORWARD. La chaîne PREROUTING permet de modifier les paquets juste quand ils entrent dans le
 pare-feu mais avant qu'ils n'atteignent la décision de routage. La chaîne POSTROUTING permet de
modifier les paquets juste après toutes les décisions de routage. La chaîne OUTPUT s'utilise pour
transformer les paquets générés localement avant qu'ils ne sollicitent la décision de routage. La chaîne
INPUT permet de modifier les paquets une fois qu'ils ont été routés vers la machine locale, mais avant que
l'application de l'espace utilisateur n'ait réceptionné les données. La chaîne FORWARD permet de
modifier les paquets après la première décision de routage mais avant la dernière. Notez que la table
mangle ne peut en aucun cas servir à une forme de traduction d'adresse réseau ou de camouflage, la table
NAT a été conçue pour ce genre d'opérations.
d. La table raw et ses chaînes sont utilisées avant tout autre table dans Netfilter. Elle fût introduite pour
utiliser la cible NOTRACK. Cette table est plutôt récente et seulement disponible, si compilée, avec les
derniers noyaux 2.6. La table raw contient deux chaînes. Les chaînes PREROUTING et OUTPUT, qui
modifient les paquets avant qu'ils atteignent les autres sous-systèmes de Netfilter. La chaîne
PREROUTING peut être utilisée pour tous les paquets entrants sur la machine, ou qui sont transférés
(forward), tandis que la chaîne OUTPUT peut être utilisée pour modifier les paquets générés localement
avant qu'ils atteignent les autres sous systèmes de Netfilter
Remarques :
- Les règles sont évaluées dans l'ordre,
- par défaut la table FILTER est vide et donc accepte tout.
- Aucune règle de translation d'adresse n'est présente par défaut.

Chaîne : Une chaîne est une suite de règles, qui sont prises dans l'ordre ; dès qu'une règle s'applique à
un paquet, elle est déclenchée, et la suite de la chaîne est ignorée
SNAT : Permet de modifier l'adresse source du paquet.
DNAT : Permet de modifier l'adresse destination du paquet
MASQUERADE : Une passerelle (gateway) transforme les paquets sortants passant par elle pour
donner l'illusion qu'ils sortent de la passerelle elle-même par un port alloué dynamiquement ; lorsque
la passerelle reçoitz` une réponse sur ce port, elle utilise une table de correspondance entre le port et
les machines du réseau privé qu'elle gère pour lui faire suivre le paquet.

policy ACCEPT : Permet d'accepter un paquet grâce à la règle vérifiée.

policy DROP : Rejet d'un paquet sans message d'erreur si la règle est vérifiée
policy REJECT : Rejet avec un retour de paquet d'erreur à l'expéditeur si la règle est vérifiée
policy LOG : Affiche le résultat vers la sortie standard.

Les commandes

Exemple
/etc/rc.d/init.d
-A --append Ajoute la règle à la fin de la chaîne #iptables -A INPUT
spécifiée
-D --delete : Permet de supprimer une chaîne. On #iptables -D INPUT --dport 80 -j DROP
peut l'utiliser de deux manières, soit en #iptables -D INPUT 1
spécifiant le numéro de la chaîne à
supprimer, soit en spécifiant la règle à
retirer.
-R --replace Permet de remplacer la chaîne # iptables -R INPUT 1 -s 192.168.0.1 -j
spécifiée DROP
-I --insert Cette commande insère une règle # iptables -I INPUT 1 --dport 80 -j
quelque-part dans une chaîne. La règle ACCEPT
est insérée à l'emplacement donné par le
numéro spécifié. En l'occurrence,
l'exemple précédent insère dans la
chaîne INPUT la règle numéro 1, qui
devient ainsi la toute
première règle de la chaîne.
Si aucun chiffre n'est spécifié à la suite (#iptables -I INPUT --dport 80 -j ACCEPT), la règle est ajoutée au
début de la chaîne spécifiée
 -L --list Affiche toutes les règles des chaînes de
FILTER
-Z, --zero Cette commande permet de mettre à iptables -Z INPUT
zéro tous les compteurs dans une
chaîne spécifique ou dans toutes les
chaînes. Si vous utilisez l'option -v
avec la commande
-L, vous afficherez le compteur de
paquets au début de chaque champ.
Pour mettre
à zéro le compteur de paquets, utilisez
l'option -Z
-X, --delete-chain Cette commande efface de la table la iptables -X allowed
chaîne spécifiée. Appelée sans option,
cette commande efface toutes les
chaînes de la table spécifiée,
exceptées les chaînes prédéfinies.

# iptables -L INPUT # Affiche toutes les règles de INPUT

(FILTER)
-F --flush : Permet de vider toutes les règles d'une # iptables -F INPUT
chaîne.

-N --new-chain Permet de créer une nouvelle chaîne. # iptables -N LOG_DROP

-P --policy Permet de spécifier au noyau la # iptables -P INPUT DROP
politique par défaut d'une chaîne
DENY, ACCEPT, REJECT, DROP
-E, --rename-chain
Le "!" peut être utilisé pour certaines commandes afin de spécifier le contraire.
Exemple : une commande qui doit refuser tout trafic TCP sauf ce qui provient de l'adresse IP 10.42.42.42
#iptables -A INPUT -p tcp ! --source 10.42.42.42 -j DROP
-j (jump) : Défini l'action à prendre si un paquet répond aux critères de cette règle: ACCEPT, LOG,
DROP...
Exemple #iptables -A INPUT -p icmp -j DROP
-p --protocol Spécifier un protocole : tcp, udp, icmp, #iptables -A INPUT -p icmp -j DROP
all (tous)
-s --source Spécifier une adresse source à matcher #iptables -A INPUT -p icmp -s 10.0.0.2
–i etho -j DROP
d --destination Spécifier une adresse destination #iptables -A FORWARD -p tcp -d
10.1.0.1 -j ACCEPT
-i --in-interface Spécifier une interface d'entrée #iptables -A INPUT -p icmp -i eth0 -j
DROP
-o --out-interface Spécifier une interface de sortie #iptables -A OUTPUT -p icmp -o eth0 -j
DROP
-f --fragment Paquet fragmenté #iptables -A INPUT -p icmp -f -j DROP
--sport --source-port Spécifier le port source ou une plage de #iptables -A INPUT -p tcp --sport 80 -j
ports, fonctionne aussi en udp, -m ACCEPT
multiport permet de spécifier plusieurs #iptables -A INPUT -p udp --sport 80 -j
ports à matcher. DROP

Autres exemples :
# iptables -A OUTPUT -p tcp -m multiport --sport 3128,21,1000 -j DROP
# iptables -A OUTPUT -p tcp --sport 1024:2042 -j ACCEPT
--dport --destination-port : Spécifier le port destination ou une plage de ports, fonctionne aussi en udp, -m
multiport permet de spécifier plusieurs ports à matcher.
#iptables -A INPUT -p tcp --dport 110 -j DROP
# iptables -A INPUT -p udp --dport 110 -j DROP
# iptables -A INPUT -p tcp -m multiport --dport 110,4242,119 -j DROP
# iptables -A INPUT -p tcp --sport 4925:4633 -j ACCEPT
--tcp-flags : Spécifier un flag tcp à matcher : SYN ACK FIN RST URG PSH ALL NONE
#iptables -A INPUT -p tcp --dport 42 --tcp-flags SYN,ACK -j ACCEPT
--icmp-type : Spécifier un type de paquet icmp à matcher
#iptables -A INPUT -p icmp --icmp-type 8 -j DROP
--mac-source : Spécifier l'adresse MAC à matcher
#iptables -A INPUT --mac-source 42.42.AA.42.42.AA -j DROP
# iptables -A INPUT -m mac --mac-source 42.42.AA.42.42.AA -j DROP
--state : Permet de spécifier l'état du paquet à matcher parmi les états suivants :
 ESTABLISHED : paquet associé à une connexion déjà établie
 NEW : paquet demandant une nouvelle connexion
 INVALID : paquet associé à une connexion inconnue
 RELATED : Nouvelle connexion mais liée, idéal pour les connexions FTP
Exemple :
#iptables -A INPUT -i eth0 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j ACCEPT
# iptables -A OUTPUT -o eth0 -p tcp --sport 80 -m state --state ESTABLISHED -j ACCEPT
--to-destination : Utilisé en target pour le DNAT, permet de spécifier l'adresse de destination de la
translation, on peut également spécifier un port s'il est différent du port source.
--to-source : Utilisé pour en target pour le SNAT, permet de spécifier l'adresse source de la translation.
Exemple :
#iptables -t nat -A PREROUTING -d 42.12.42.12 -p tcp --dport 110 -j DNAT --to-destination
192.168.1.2:6110
# iptables -t nat -A PREROUTING -d ! 42.12.42.12 -p tcp --dport 80 -j DNAT --to-destination
192.168.2.1:3128
#vidage des chaînes ; les chaine de la filtrer par défaut
iptables -F
#destruction des chaînes personnelles
iptables -X
#init des tables NAT et MANGLE (pas forcément nécessaire)
iptables -t nat -F
iptables -t nat -X
iptables -t nat -P PREROUTING ACCEPT
iptables -t nat -P POSTROUTING ACCEPT
iptables -t nat -P OUTPUT ACCEPT

iptables -t mangle -F
iptables -t mangle -X
iptables -t mangle -P PREROUTING ACCEPT
iptables -t mangle -P OUTPUT ACCEPT

# Acceptation de toutes les connexions en local (un process avec l'autre)

iptables -A INPUT -i lo -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT

Les autres options :

-t filter : pour préciser la table (facultatif avec la table filter).

-A chain : ajouter une règle à la fin de la chaîne (OUTPUT, puis INPUT)
-p : pour indiquer le type de trames utilisé dans le paquet. ([!] “all”, “tcp”, “udp”, “icmp”, ou un numéro)
-m module : Demande d'utiliser un module particulier
conntrack : c'est un module de netfilter il est installé sur wheezy pour l'activer :

/sbin/modprobe ip_conntrack;

–ctstate liste des états : liste les états de connexion :

INVALID : signifie que le paquet est associé à aucune connexion connue

NEW : signifie que le paquet a commencé une nouvelle connexion
ESTABLISHED : ce qui signifie que le paquet est associé à une connexion qui a vu les paquets dans les
deux sens.
RELATED : signifie que le paquet commence une nouvelle connexion, mais est associé à une connexion
existante, telle qu'un transfert de données FTP, ou une erreur ICMP.
UNTRACKED : signifie que le paquet n'est pas suivi du tout.
SNAT : Un état virtuel, le paquet correspond si l'adresse source diffère la réponse de destination.
DNAT : Un état virtuel, le paquet correspond si l'adresse de destination diffère de l'adresse source.
EXPECTED : Cette connexion est prévue (c'est à dire un assistant conntrack est activé)
SEEN_REPLY : Conntrack a vu passer des paquets dans les deux directions.
ASSURED : ok si l'entrée de conntrack n'a expiré
CONFIRMED : Connexion est confirmée

Exemples
a. Pour fixer les politiques par défaut (ce qui se passe quand aucune règle ne correspond - ne matche
pas), ici, on refuse tout
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
b. Le rejet
iptables -A FORWARD -j LOG_DROP
iptables -A INPUT -j LOG_DROP
iptables -A OUTPUT -j LOG_DROP
c. Pour accepter tout ce qui se passe sur le réseau local 192.168.1.0
iptables -A INPUT -s 192.168.1.0/24 -j ACCEPT
iptables -A OUTPUT -d 192.168.1.0/24 -j ACCEPT
iptables -A FORWARD -s 192.168.1.0/24 -j ACCEPT
d. Pour accepter les résolutions de nom (ie: le dns) :
iptables -A INPUT -i eth0 --protocol udp --source-port 53 -j ACCEPT
iptables -A OUTPUT -o eth0 --protocol udp --destination-port 53 -j ACCEPT
iptables -A INPUT -i eth0 --protocol tcp --source-port 53 -j ACCEPT
iptables -A OUTPUT -o eth0 --protocol tcp --destination-port 53 -j ACCEPT
e. Pour accepter le Traffic web (on veut surfer!) :
iptables -A INPUT -i ppp0 --protocol tcp --source-port 80 -m state --state ESTABLISHED -j ACCEPT
iptables -A OUTPUT -o ppp0 --protocol tcp --destination-port 80 -m state --state NEW,ESTABLISHED
-j ACCEPT

iptables-save > /root/parefeu.fw Faire le backup de la configuration du pare-feu

iptables-restore < /root/parefeu.fw Restaurer la configuration du pare-feu
vi /etc/rc.local Editer le fichier /etc/rc.local et ajouter la ligne
/sbin/iptables-restore < /root/parefeu.fw /sbin/iptables-restore < /root/parefeu.fw

Etat de connexion

La machine d'état
Cela permet le traçage de connexion. Le traçage de connexion est effectué afin que l'architecture de
Netfilter puisse connaître l'état d'une connexion spécifique.
Les pare-feux qui implémentent ceci sont habituellement appelés pare-feux à état.
Le module conntrack permet justement d'effectuer du traçage de connexion !
Il prend en charge les protocoles TCP, UDP et ICMP.
Le traçage de connexion est entièrement pris en charge dans la chaîne PREROUTING, sauf pour les
paquets générés en local, qui sont pris en charge dans la chaîne OUTPUT. Ceci signifie qu'iptable effectue
tous les calculs d'état dans la chaîne PREROUTING. Si on envoie le premier paquet d'un flux, l'état est
défini comme NEW dans la chaîne OUTPUT, et quand on reçoit un paquet de réponse, l'état passe à
ESTABLISHED, et ainsi de suite. Si le premier paquet n'est pas envoyé par nous-mêmes, l'état NEW est
naturellemt défini dans la chaîne PREROUTING. Ainsi, tous les changements d'état et calculs sont réalisés
dans les chaînes PREROUTING et OUTPUT de la table nat.

Pour l'espace utilisateur les états valides sont NEW, ESTABLISHED, RELATED et INVALID.

Etude de cas 1
1. Vider les chaines
2. Supprimer les chaines personnelles
3. Définir la politique par défaut qui bloque les paquets d’une source inconnue
4. Accepter le trafic venant uniquement de la machine 192.168.56.1 sur le port 22, utilisant le service
SSH
5. Accepter les requêtes de la machine 192.168.56.1 sur le port 3306 de MySQL
6. Accepter le trafic sur le port 22, 3306 uniquement les jours ouvrables de 8h :00 a 18h, du lundi au
vendredi
7. Accepter 2 ping par seconde sur le serveur de l’application Web, a l’entree de l’interface eth
8. Rediriger le trafic destiné au port 443 du serveur Web vers le port 80 a condition que la soit
192.168.56.0/24
9. La machine a une adresse MAC e1 :5b :f4 :c2 :a3, accepter son trafic sur le port 80 du serveur
d’application Web
10. Accepter la connexion établie au niveau du serveur d’application sur l’interface eth0
11. Sauvegader la configuation du pare-feu dans un fichier
12. Restaurer la configuation sauvegadee precedemment

192.168.56.0/24
.1
eth0
.5

Etude de cas 2
1. Configurer la topologie suivante
2. Installer et configurer wordPress sur le serveur d’application Web
 3. Sur le pare-feu, definir une politique de sécurité par défaut qui bloque tout trafic venant d’une source
inconnue vers le serveur d’application Web
4. Sur le pare-feu, accepter le trafic de la machine 192.168.56.1 utilisant le protocole TCP sur le port 22
a destination du serveur 172.16.16.2
5.

.1 .1 172.16.16.0/20
eth0 .1 .2
192.168.56.0/24 eth1 eth0

Environnement virtuel

Les différentes menaces des applications Web

1) Virus

Un virus est un petit programme informatique situé dans le corps d'un autre, qui, lorsqu'on l'exécute, se
charge en mémoire et exécute les instructions que son auteur a programmé. La définition d'un virus pourrait
être la suivante : « Tout programme d'ordinateur capable d'infecter un autre programme d'ordinateur en le
modifiant de façon à ce qu'il puisse à son tour se reproduire. » [1]

Les virus résidents (appelés TSR en anglais pour Terminate and stay resident) se chargent dans la mémoire
vive de l'ordinateur afin d'infecter les fichiers exécutables lancés par l'utilisateur. Les virus non résidants
infectent les programmes présents sur le disque dur dès leur exécution.

Le champ d'application des virus va de la simple balle de ping-pong qui traverse l'écran au virus destructeur
de données, ce dernier étant la forme de virus la plus dangereuse. Ainsi, étant donné qu'il existe une vaste
gamme de virus ayant des actions aussi diverses que variées, les virus ne sont pas classés selon leurs dégâts
mais selon leur mode de propagation et d'infection.
On distingue ainsi différents types de virus :

- Les vers sont des virus capables de se propager à travers un réseau

- Les chevaux de Troie (troyens) sont des virus permettant de créer une faille dans un système
(généralement pour permettre à son concepteur de s'introduire dans le système infecté afin d'en
prendre le contrôle)
- Les bombes logiques sont des virus capables de se déclencher suite à un événement particulier (date
système, activation distante, ...)

Depuis quelques années un autre phénomène est apparu, il s'agit des canulars (en anglais hoax), c'est-à-dire
des annonces reçues par mail (par exemple l'annonce de l'apparition d'un nouveau virus destructeur ou bien
la possibilité de gagner un téléphone portable gratuitement) accompagnées d'une note précisant de faire
suivre la nouvelle à tous ses proches. Ce procédé a pour but l'engorgement des réseaux ainsi que la
désinformation.

Sécurité contre les virus

Un antivirus est un programme capable de détecter la présence de virus sur un ordinateur et, dans la mesure
du possible, de désinfecter ce dernier. On parle ainsi d'éradication de virus pour désigner la procédure de
nettoyage de l'ordinateur.
Il existe plusieurs méthodes d'éradication :
- La suppression du code correspondant au virus dans le fichier infecté ;
- La suppression du fichier infecté ;
- La mise en quarantaine du fichier infecté, consistant à le déplacer dans un emplacement où il ne
pourra pas être exécuté.

Comment se fait la détection ?

Certains antivirus utilisent un contrôleur d'intégrité pour vérifier si les fichiers ont été modifiés. Ainsi le
contrôleur d'intégrité construit une base de données contenant des informations sur les fichiers exécutables
du système (date de modification, taille et éventuellement une somme de contrôle). Ainsi, lorsqu'un fichier
exécutable change de caractéristiques, l'antivirus prévient l'utilisateur de la machine.

La méthode heuristique consiste à analyser le comportement des applications afin de détecter une activité
proche de celle d'un virus connu. Ce type d'antivirus peut ainsi détecter des virus même lorsque la base
antivirale n'a pas été mise à jour. En contrepartie, ils sont susceptibles de déclencher de fausses alertes.

Les différents types de virus

- Les virus mutants

En réalité, la plupart des virus sont des clones, ou plus exactement des « virus mutants », c'est-à-dire des
virus ayant été réécrits par d'autres utilisateurs afin d'en modifier leur comportement ou leur signature.

Le fait qu'il existe plusieurs versions (on parle de variantes) d'un même virus le rend d'autant plus difficile à
repérer dans la mesure où les éditeurs d'antivirus doivent ajouter ces nouvelles signatures à leurs bases de
données.

- Les virus polymorphes

Dans la mesure où les antivirus détectent notamment les virus grâce à leur signature (la succession de bits
qui les identifie), certains créateurs de virus ont pensé à leur donner la possibilité de modifier
automatiquement leur apparence, tel un caméléon, en dotant les virus de fonction de chiffrement et de
déchiffrement de leur signature, de façon à ce que seuls ces virus soient capables de reconnaître leur propre
signature. Ce type de virus est appelé « virus polymorphe » (mot provenant du grec signifiant « qui peut
prendre plusieurs formes »).
- Les rétrovirus
On appelle « rétrovirus » ou « virus flibustier » (en anglais bounty hunter) un virus ayant la capacité de
modifier les signatures des antivirus afin de les rendre inopérants.

- Les virus de secteur d'amorçage

On appelle « virus de secteur d'amorçage » (ou virus de boot), un virus capable d'infecter le secteur de
démarrage d'un disque dur (MBR, soit master boot record), c'est-à-dire un secteur du disque copié dans la
mémoire au démarrage de l'ordinateur, puis exécuté afin d'amorcer le démarrage du système d'exploitation.

- Les virus trans-applicatifs (virus macros)

Avec la multiplication des programmes utilisant des macros, Microsoft a mis au point un langage de script
commun pouvant être inséré dans la plupart des documents pouvant contenir des macros, il s'agit de
VBScript, un sous-ensemble de Visual Basic. Ces virus arrivent actuellement à infecter les macros des
documents Microsoft Office, c'est-à-dire qu'un tel virus peut être situé à l'intérieur d'un banal document
Word ou Excel, et exécuter une portion de code à l'ouverture de celui-ci lui permettant d'une part de se
propager dans les fichiers, mais aussi d'accéder au système d'exploitation (généralement Windows).

Or, de plus en plus d'applications supportent Visual Basic, ces virus peuvent donc être imaginables sur de
nombreuses autres applications supportant le VBScript.
Le début du troisième millénaire a été marqué par l'apparition à grande fréquence de scripts Visual Basic
diffusés par mail en fichier attaché (repérables grâce à leur extension .VBS) avec un titre de mail poussant à
ouvrir le cadeau empoisonné.
Celui-ci a la possibilité, lorsqu'il est ouvert sur un client de messagerie Microsoft, d'accéder à l'ensemble du
carnet d'adresse et de s'autodiffuser par le réseau. Ce type de virus est appelé ver (ou worm en anglais).
2) Les vers
Un ver informatique (en anglais worm) est un programme qui peut s'auto-reproduire et se déplacer à travers
un réseau en utilisant les mécanismes réseau, sans avoir réellement besoin d'un support physique ou logique
(disque dur, programme hôte, fichier, etc.) pour se propager ; un ver est donc un virus réseau.
Les vers se propagent principalement grâce à la messagerie (et notamment par le client de messagerie
Outlook) grâce à des fichiers attachés contenant des instructions permettant de récupérer l'ensemble des
adresses de courrier contenues dans le carnet d'adresse et en envoyant des copies d'eux-mêmes à tous ces
destinataires.
Ces vers sont la plupart du temps des scripts (généralement VBScript) ou des fichiers exécutables envoyés en
pièce jointe et se déclenchant lorsque l'utilisateur destinataire clique sur le fichier attaché.

Les espiogiciels
Un espiogiciel (en anglais spyware) est un programme chargé de recueillir des informations sur l'utilisateur
de l'ordinateur sur lequel il est installé (on l'appelle donc parfois mouchard) afin de les envoyer à la société
qui le diffuse pour lui permettre de dresser le profil des internautes (on parle de profilage).
Les récoltes d'informations peuvent ainsi être :
- la traçabilité des URL des sites visités,
- le traquage des mots-clés saisis dans les moteurs de recherche,
- l'analyse des achats réalisés via internet,
- voire les informations de paiement bancaire (numéro de carte bleue / VISA)
- ou bien des informations personnelles.
Les spywares s'installent généralement en même temps que d'autres logiciels (la plupart du temps des
freewares ou sharewares). En effet, cela permet aux auteurs des dits logiciels de rentabiliser leur programme,
par de la vente d'informations statistiques, et ainsi permettre de distribuer leur logiciel gratuitement. Il s'agit
donc d'un modèle économique dans lequel la gratuité est obtenue contre la cession de données à caractère
personnel.

Les spywares ne sont pas forcément illégaux car la licence d'utilisation du logiciel qu'ils accompagnent précise
que ce programme tiers va être installé ! En revanche étant donné que la longue licence d'utilisation est
rarement lue en entier par les utilisateurs, ceux-ci savent très rarement qu'un tel logiciel effectue ce profilage
dans leur dos.
Par ailleurs, outre le préjudice causé par la divulgation d'informations à caractère personnel, les spywares
peuvent également être une source de nuisances diverses :
- consommation de mémoire vive,
- utilisation d'espace disque,
- mobilisation des ressources du processeur,
- plantages d'autres applications,
- gêne ergonomique (par exemple l'ouverture d'écrans publicitaires ciblés en fonction des données
collectées).
Les types de spywares

On distingue généralement deux types de spywares :

- Les spywares internes (ou spywares internes ou spywares intégrés) comportant directement des
lignes de codes dédiées aux fonctions de collecte de données.
- Les spywares externes, programmes de collectes autonomes installés Voici une liste non exhaustive
de spywares non intégrés : Alexa, Aureate/Radiate, BargainBuddy, ClickTillUWin, Conducent
Timesink, Cydoor, Comet Cursor, Doubleclick, DSSAgent, EverAd, eZula/KaZaa Toptext,
Flashpoint/Flashtrack, Flyswat, Gator / Claria, GoHip, Hotbar, ISTbar, Lop, NewDotNet, Realplayer,
SaveNow, Songspy, Xupiter, Web3000 et WebHancer
Se protéger contre les spywares
La principale difficulté avec les spywares est de les détecter. La meilleure façon de se protéger est encore de
ne pas installer de logiciels dont on n'est pas sûr à 100% de la provenance et de la fiabilité (notamment les
freewares, les sharewares et plus particulièrement les logiciels d'échange de fichiers en peer-to-peer). Voici
quelques exemples (e liste non exhaustive) de logiciels connus pour embarquer un ou plusieurs spywares :
Babylon Translator, GetRight, Go!Zilla, Download Accelerator, Cute FTP, PKZip, KaZaA ou encore iMesh.
Qui plus est, la désinstallation de ce type de logiciels ne supprime que rarement les spywares qui
l'accompagnent. Pire, elle peut entraîner des dysfonctionnements sur d'autres applications !
Dans la pratique il est quasiment impossible de ne pas installer de logiciels. Ainsi la présence de processus
d'arrière plans suspects, de fichiers étranges ou d'entrées inquiétantes dans la base de registre peuvent
parfois trahir la présence de spywares dans le système.
Si vous ne parcourez pas la base de registre à la loupe tous les jours rassurez-vous, il existe des logiciels,
nommés anti-spywares permettant de détecter et de supprimer les fichiers, processus et entrées de la base
de registres créés par des spywares.
De plus l'installation d'un pare-feu personnel peut permettre d'une part de détecter la présence
d'espiogiciels, d'autre part de les empêcher d'accéder à Internet (donc de transmettre les informations
collectées).

La cryptographie

Le mot de passe est la méthode d'authentification utilisateur la plus courante, car elle est simple à
comprendre et à utiliser pour les utilisateurs. Cependant, les mots de passe ont mauvaise réputation en
raison de leurs faiblesses. Avec la cryptographie, il est possible de pallier ces faiblesses.

Un mot de passe est choisi par une personne qui doit le mémoriser, à la différence d'une clé secrète
cryptographique aléatoire qui est stockée et manipulée par des machines. Un mot de passe est souvent court,
il y a donc peu de combinaisons possibles. Cela le rend vulnérable à une attaque par force brute.

Les utilisateurs ont tendance à réutiliser le même mot de passe sur plusieurs sites Internet différents. Le
problème, c'est que si un attaquant vole la base de données utilisateurs d'un site Internet peu sécurisé, il
pourra ensuite réutiliser les emails et mots de passe pour se connecter à d'autres comptes de l'utilisateur
plus sensibles comme le compte email, le compte bancaire en ligne ou un compte professionnel. C'est
pourquoi il est essentiel de stocker les mots de passe d'une manière sécurisée, c'est-à-dire qu'il soit difficile
à un attaquant qui a accès à la base de données des mots de passe de retrouver la valeur des mots de passe.
C'est ce que nous allons voir tout de suite

- Les mots de passe sont vulnérables aux attaques de force brute et dictionnaire en raison de leur
faible entropie ;
- pour stocker des mots de passe, il faut utiliser une fonction de hachage de mots de passe sécurisée
avec un salt ;
- les fonctions de hachage de mots de passe sont lentes pour éviter les attaques de force brute ;
 - on utilise un salt aléatoire différent pour chaque mot de passe, afin que 2 mots de passe identiques
aient un haché différent pour éviter les attaques par rainbow table ;
- on peut utiliser en plus un pepper dans le serveur d'application pour se protéger d'une attaque qui
donne accès à la base de données, mais pas au serveur d'application.

Partie 2 : Sécurité

Tolérance aux pannes

Puisqu'il est impossible d'empêcher totalement les pannes, une solution consiste à mettre en place des
mécanismes de redondance, en dupliquant les ressources critiques.

La capacité d'un système à fonctionner malgré une défaillance d'une de ses composantes est appelée
tolérance aux pannes (parfois nommée tolérance aux fautes », en anglais fault tolerance).

Lorsqu'une des ressources tombe en panne, les autres ressources prennent le relais afin de laisser le temps
aux administrateurs du système de remédier à l'avarie. En anglais le terme de « Fail-Over Service » (noté FOS)
est ainsi utilisé.

Idéalement, dans le cas d'une panne matérielles, les éléments matériels fautifs devront pouvoir être «
extractibles à chaud » (en anglais « hot swappable »), c'est-à-dire pouvoir être extraits puis remplacés, sans
interruption de service.

IPS

L’IPS est un Système de Prévention/Protection contre les intrusions et non plus seulement de reconnaissance
et de signalisation des intrusions comme la plupart des IDS. La principale différence entre un IDS (réseau) et
un IPS (réseau) tient principalement en 2 caractéristiques :

- le positionnement en coupure sur le réseau de l’IPS et non plus seulement en écoute sur le réseau
pour l’IDS (traditionnellement positionné comme un sniffer sur le réseau).
- la possibilité de bloquer immédiatement les intrusions et ce quel que soit le type de protocole de
transport utilisé et sans reconfiguration d’un équipement tierce, ce qui induit que l’IPS est constitué
en natif d’une technique de filtrage de paquets et de moyens de bloquages (drop connection, drop
offending packets, block intruder, …).

IDS

On appelle IDS (Intrusion Detection System) un mécanisme écoutant le trafic réseau de manière furtive afin
de repérer des activités anormales ou suspectes et permettant ainsi d'avoir une action de prévention sur les
risques d'intrusion.

Il existe deux grandes familles distinctes d’IDS :

- Les N-IDS (Network Based Intrusion Detection System), ils assurent la sécurité au niveau du réseau.
 - Les H-IDS (Host Based Intrusion Detection System), ils assurent la sécurité au niveau des hôtes.

Un N-IDS nécessite un matériel dédié et constitue un système capable de contrôler les paquets circulant sur
un ou plusieurs lien(s) réseau dans le but de découvrir si un acte malveillant ou anormal a lieu. Le N-IDS place
une ou plusieurs cartes d’interface réseau du système dédié en mode promiscuité (promiscuous mode), elles
sont alors en mode « furtif » afin qu’elles n’aient pas d’adresse IP. Elles n’ont pas non plus de pile de protocole
attachée. Il est fréquent de trouver plusieurs IDS sur les différentes parties du réseau et en particulier de
placer une sonde à l'extérieur du réseau afin d'étudier les tentatives d'attaques ainsi qu'une sonde en interne
pour analyser les requêtes ayant traversé le pare-feu ou bien menée depuis l'intérieur.

- Position de l’IDS
Serveur App Web

Client IDS 1 Pare-feu IDS 2

Les différentes actions des IDS

Les principales méthodes utilisées pour signaler et bloquer les intrusions sur les N-IDS sont les suivantes :

- Reconfiguration d’équipement tierces (firewall, ACL sur routeurs) : Ordre envoyé par le N-IDS à un
équipement tierce (filtreur de paquets, pare-feu) pour une reconfiguration immédiate dans le but de
bloquer un intrus source d’intrusions. Cette reconfiguration est possible par passage des
informations détaillant une alerte (en tête(s) de paquet(s)).
- Envoi d’une trap SNMP à un hyperviseur tierce : Envoi de l’alerte (et le détail des informations la
constituant) sous format d’un datagramme SNMP à une console tierce comme HP OpenView, Tivoli,
Cabletron Spectrum, etc.
- Envoi d’un e-mail à un ou plusieurs utilisateurs : Envoi d’un e-mail à une ou plusieurs boîtes aux
lettres pour notifier d’une intrusion sérieuse.
- Journalisation (log) de l’attaque : Sauvegarde des détails de l’alerte dans une base de données
centrale comme par exemple les informations suivantes : timestamp, @IP de l’intrus, @IP de la cible,
protocole utilisé, payload).
- Sauvegarde des paquets suspicieux : Sauvegarde de l’ensemble des paquets réseaux (raw packets)
capturés et/ou seul(s) les paquets qui ont déclenchés une alerte.
- Démarrage d’une application : Lancement d'un programme extérieur pour exécuter une action
spécifique (envoi d’un message sms, émission d’une alerte auditive…).
- Envoi d’un "ResetKill" : Construction d'un paquet TCP FIN pour forcer la fin d’une connexion
(uniquement valable sur des techniques d’intrusions utilisant le protocole de transport TCP).
- Notification visuelle de l’alerte : Affichage de l’alerte dans une ou plusieurs console(s) de
management.
L'analyse des journaux

Un des meilleurs moyens de détecter les intrusions consiste à surveiller les journaux d'événements (appelés
aussi journaux d'activité ou en anglais logs).

En effet, d'une manière générale les serveurs stockent dans des fichiers une trace de leur activité et en
particulier des erreurs rencontrées.

Or, lors d'une attaque informatique il est rare que le pirate parvienne à compromettre un système du premier
coup. Il agit la plupart du temps par tâtonnement, en essayant différentes requêtes.

Ainsi la surveillance des journaux permet de détecter une activité suspecte. Il est en particulier important de
surveiller les journaux d'activité des dispositifs de protection car tout aussi bien configuré qu’ils soient, il se
peut qu'ils soient un jour la cible d'une attaque.
Notions de cryptographie

Signature numérique

Le paradigme de signature électronique (appelé aussi signature numérique) est un procédé permettant de
garantir l'authenticité de l'expéditeur (fonction d'authentification) et de vérifier l'intégrité du message reçu.

La signature électronique assure également une fonction de non-répudiation, c'est-à-dire qu'elle permet
d'assurer que l'expéditeur a bien envoyé le message, autrement dit elle empêche l'expéditeur de nier avoir
expédié le message.

Fonction de hachage

Une fonction de hachage , parfois appelée fonction de condensation est une fonction permettant d'obtenir
un condensé appelé aussi condensat ou haché ou en anglais message digest d'un texte, c'est-à-dire une suite
de caractères assez courte représentant le texte qu'il condense. La fonction de hachage doit être telle qu'elle
associe un et un seul haché à un texte en clair, cela signifie que la moindre modification du document entraîne
la modification de son haché). D'autre part, il doit s'agir d'une fonction à sens unique afin qu'il soit impossible
de retrouver le message original à partir du condensé.

Exemple : utilisation du module hashlib de python

Ce module implémente une interface commune à différents algorithmes de hachage sécurisés et de synthèse
de messages. Sont inclus les algorithmes standards FIPS de hachage SHA1, SHA224, SHA256, SHA384, et
SHA512 (définis dans FIPS 180-2) ainsi que l'algorithme MD5 de RSA (défini par la RFC 1321). Les termes
"algorithmes de hachage sécurisé" et "algorithme de synthèse de message" sont interchangeables. Les
anciens algorithmes étaient appelés" algorithmes de synthèse de messages". Le terme moderne est
"algorithme de hachage sécurisé". []

hash.name Le nom canonique de cet objet haché, toujours en minuscule

hash.update(data) Met à jour l'objet haché avec bytes-like object.
hash.digest() Renvoie le digest des données passées à la méthode update(). C'est un objet de
type bytes de taille digest_size qui contient des octets dans l'intervalle 0 à 255.
hash.hexdigest() le digest renvoyé est une chaîne de caractères de longueur double, contenant
seulement des chiffres hexadécimaux
hash.copy() Renvoie une copie ("clone") de l'objet haché. Cela peut être utilisé pour calculer
efficacement les digests de données partageant des sous-chaînes communes.
shake.hexdigest(length) Comme la méthode digest() sauf que le digest renvoyé est une chaîne de
caractères de longueur double, contenant seulement des chiffres hexadécimaux

Exemple :

Ecrire un script Python qui vérifie le mot de passe haché dans une table sous MySQL
Soit la requête de la création de table administrateur :
Exercice 2 :

Ecrire un script Python qui permet l’attaque brut-force par dictionnaire de mot de passe, jusqu’à retrouver
le mot de passe haché dans une table de votre application Web.
Exerice 1

alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
message = input("Entrer le message a crypter: ")
n = len(message)
resultat = ""
k=3
for i in range(n):
c = message[i]
rech = alphabet.find(c)
newrech = rech + k
resultat += alphabet[newrech]
print ("Resultat du cryptage:", resultat)

# ou

def cryptage(k):
alpha="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
m=input("Message: ")
r=""
for i in range(len(m)):
if alpha.find(m[i]):
r+=alpha[alpha.find(m[i])+k]
return r
print(cryptage(3))

# ou
alpha="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
m=input("message: ")
n=len(m)
k=4
r=""
for i in range(len(m)):
loc=alpha.find(m[i])
nloc=(loc+k)%26
r+=alpha[nloc]
print(r)
#ou
def crypto(m:str,k:int,r=""):
alpha="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
for i in range(len(m)):
r+=alpha[(alpha.find(m[i])+k)%26]
return r
print(crypto("UNIVERSIE",400))
hacker algorithm de Cesar

a. Cryptage

alpha='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def hackCesar(m):
for i in range(len(alpha)):
trouve=""
for c in m:
if c in alpha:
trouve+=alpha[(alpha.find(c)+i)%26]
print(i,trouve)
hackCesar("HELLO JE SUIS NIGERIEN")
b. deryptage

alpha='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def hackCesar(m):

for i in range(len(alpha)):
trouve=""
for c in m:
if c in alpha:
x=alpha.find(c)-i
if x<0:
x+=len(alpha)
trouve+=alpha[x]
else:
trouve+=c
print(i,trouve)
hackCesar("KHOORMHVXLVQLJHULHQ")

c. attaque but-force

c1. Le message cryptes et enregistres dans un fichier

alpha='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def hackCesar(m):
f=open("resultat.txt","a")
for i in range(len(alpha)):
trouve=""
for c in m:
if c in alpha:
trouve+=alpha[(alpha.find(c)+i)%26]
f.write(trouve+'\n')
f.close()

hackCesar("HELLO JE SUIS NIGERIEN")

 c.2 Decodage du fichier par l’attaque brut-force

alpha='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def hackCesar(m):

for i in range(len(alpha)):
trouve=""
for c in m:
if c in alpha:
x=alpha.find(c)-i
if x<0:
x+=len(alpha)
trouve+=alpha[x]
else:
trouve+=c
print(i,trouve)
with open("resultat.txt") as f:
for ligne in f:
hackCesar(ligne)
print('-'*100)

ROT13
def crypto(m:str,k:int,r=""):
alpha="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
for i in range(len(m)):
r+=alpha[(alpha.find(m[i])+k)%26]
return r
print("Cryptage: ",crypto("UNIVERSITE",13))
print("Decryptage: ",crypto(crypto("UNIVERSITE",13),13))

# crypter N fois
def crypto(m:str,k:int,r=""):
alpha="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
for i in range(len(m)):
r+=alpha[(alpha.find(m[i])+k)%26]
return r
m=input("messahe: ")

for i in range(20):
m+=crypto(m,4)
print(m)
Exercice
def renverser(m):
r=""
i=len(m)-1
while i>=0:
r+=m[i]
i-=1
return r
print(renverser("Fraternite Travail Progres"))
from cryptography.fernet import Fernet as F
cle=F.generate_key()
f=F(cle)
c=f.encrypt(b"Je chercher")
print("-"*20," Resultat du cryptage","*"*20)
print(c)
print("-"*20," Resultat du decryptage","*"*20)
print(f.decrypt(c))

Exercice 2 : crypter les lignes d’un fichier

from cryptography.fernet import Fernet as F
cle=F.generate_key()
f=F(cle)
with open("note.txt") as fic:
for l in fic:
c=f.encrypt(l.encode("ascii"))
print(c)

Exercice 3 : Crypter le contenu d’un fichier dans un autre fichier

from cryptography.fernet import Fernet as F
cle=F.generate_key()
f=F(cle)
fic=open("note.cr","ab")
with open("note.txt") as fi:
for l in fi:
c=f.encrypt(l.encode("ascii"))
fic.write(c+b"\n")

Exercice 4: décrypter le contenu du fichier précèdent

from cryptography.fernet import Fernet as F

cle=F.generate_key()
f=F(cle)
fi=open("note2.txt","a")
with open("note.cr","rb") as fic:
for l in fic:
print(l)
c=f.decrypt(l)
fi.write(c+"\n")

Exercice 5: crypter le contenu d’un dossier

import os
from cryptography.fernet import Fernet as F
cle=F.generate_key()
f=F(cle)
D=input("Entrer le chemin du dossier: ")
if os.path.exists(D):
L=os.listdir(D)
print(L)
for fic in L:
if os.path.isfile(fic):
for l in fic:
print(f.encrypt(l.encode("ascii")))

Exercice 6 : appliquer la cryptographie dans le domaine de réseau

Objectif : crypter le fichier du serveur SRV1 et envoyer la copie cryptée sur le serveur SRV2

192.168.56.0/24

.1 .104

import os
from cryptography.fernet import Fernet as F
cle=F.generate_key()
fic=open("finance.cr","ab")
f=F(cle)
with open("note.txt") as fi:
for line in fi:
fic.write(f.encrypt(line.encode("ascii")))
if os.system("ping 192.168.56.92") == 0:
os.system("scp finance.cr root@192.168.56.92:/root/")

exercice 7: Crypter le fichier d’un dossier et envoyer le résultat dans le serveur SRV2
import os
from cryptography.fernet import Fernet as F
cle=F.generate_key()
f=F(cle)
Ds=input("Entrer le chemin du dossier source: ")
Dd=input("Entrer le chemin du dossier destination: ")
if os.path.exists(Ds) and os.path.exists(Dd):
for ft in os.listdir(Ds):
if os.path.isfile(ft):
fcr=open("%s/%s.cr"%(Dd,ft),"ab")
for l in open(ft):
fcr.write(f.encrypt(l.encode("ascii")))

if os.system("ping 192.168.56.92") == 0:
os.system("tar cjvf %s.tar.bz2 %s"%(Dd,Dd))
os.system("scp %s.tar.bz2 root@192.168.56.92:/root/"%Dd)
Exercice 8:

.92
.93
.1
192.168.56.0/24

import os
from cryptography.fernet import Fernet as F
cle=F.generate_key()
f=F(cle)
Ds=input("Entrer le chemin du dossier source: ")
Dd=input("Entrer le chemin du dossier destination: ")
if os.path.exists(Ds) and os.path.exists(Dd):
for ft in os.listdir(Ds):
if os.path.isfile(ft):
fcr=open("%s/%s.cr"%(Dd,ft),"ab")
for l in open(ft):
fcr.write(f.encrypt(l.encode("ascii")))
os.system("tar cjvf %s.tar.bz2 %s"%(Dd,Dd))
for m in 192.168.56.92 192.168.56.93:
if os.system("ping %s"%m) == 0:
os.system("scp %s.tar.bz2 root@%m:/root/"%(Dd,m))

Exercice 9 : faire le dump des tables compte et mouvement de la base banque

import os,csv
from cryptography.fernet import Fernet as F
cle=F.generate_key()
f=F(cle)
import pymysql as M
cn=M.connect(host="localhost",user="root",password="est",database="banque")
cr=cn.cursor()
for t in ['compte','mouvement']:
with open("%s.csv"%t,"a") as fic:
e=csv.writer(fic, delimiter=";")
cr.execute("SELECT * FROM %s"%t)
for l in cr.fetchall():
e.writerow(l)
fc=open("%s.cr"%t,"ab")
with open("%s.csv"%t) as fic:
for l in fic:
fc.write(f.encrypt(l.encode("ascii")))
os.system("scp %s.cr root@192.168.56.92:/root/"%t)
fc.close()
OpenSSL : coté système
Exercice 1
import os
f=input("Entrer un fichier: ")
if os.path.isfile(f):
os.system("openssl aes-256-cbc -k secret -in %s -out %s.cr" %(f,f))
Exercice 2

import os
def crypto(m,f):
if os.path.isfile(f):
os.system("openssl %s -k secret -in %s -out %s.cr" %(m,f,f))
crypto('aes-128-cbc','resultat.txt')

Exercice 3: crypter les fichier du dossier courant

import os
def crypto(m,f):
if os.path.isfile(f):
os.system("openssl %s -k secret -in %s -out %s.cr" %(m,f,f))
def crypter():
contenu=os.listdir(".")
for f in contenu:
if os.path.isfile(f):
crypto('aes-256-cbc',f)
crypter()

exercice 4: écrire un script qui fait le décryptage des fichiers cryptés précédemment

Hashage

import hashlib as H import hashlib as H

print(H.algorithms_available) print(H.sha256(b"travaille!").hexdigest())
import hashlib as H import hashlib as H
print(H.md5(b"travaillez!").hexdigest()) print(H.sha3_256(b"travaille!").hexdigest(
import hashlib as H import hashlib as H
print(H.sha1 (b"travaille!").hexdigest()) print(H.sha3_512(b"travaille!").hexdigest(
import hashlib as H from hashlib import *
print(H.sha512(b"travaille!").hexdigest()) def hasher(algo):
import hashlib as H print(algo(b"Securite
print(H.sha224(b"travaille!").hexdigest()) nationale").hexdigest())
hasher(md5)
Accès distant avec le module netmiko de Python

192.168.56.0/24

 Script a saisir sur la machine cliente

from pprint import pprint

from netmiko import ConnectHandler as H
u,p='root','6858'
r='192.168.56.'
for i in [92,93]:
h=r+str(i)
conf={'device_type':'linux',
'username':u,
'host':h,
'password':p,
'secret':p
}
cn=H(**conf)
commande="ls -l /root/"
resultat=cn.send_command(commande)
pprint(resultat)
cn.disconnect()

Exercice : utiliser netmiko pour créer des utilisateurs

from print import pprint
from netmiko import ConnectHandler as H
u,p='root','6858'
r='192.168.1.'
for i in [92,93]:
h=r+str(i)
conf={'device_type':'linux',
'username':u,
'host':h,
'password':p,
'secret':p
}
cn=H(**conf)
commande="ls -l /root/"
for user in ["kiari","harou","balla","ladidi"]:
resultat=cn.send_config_set("useradd %s"%user)
print("operation effectuee avec succes")
cn.disconnect()
Gestion de base de données a l’aide de netmiko
1 mysql -u root -p Se connecter au serveur de base de données
MySQL
2 Create database vote ; Créer la base de données
3 use vote ; Entrer dans la base vote
4 CREATE TABLE electeur ( Création des table electeur, candidat et voter
ide int(11) NOT NULL AUTO_INCREMENT,
nom varchar(50) NOT NULL,
datenaiss date NOT NULL,
lieunaiss varchar(25) NOT NULL,
genre char(1) DEFAULT 'M',
PRIMARY KEY (ide)
);

CREATE TABLE candidat (

idc int(11) NOT NULL AUTO_INCREMENT,
nom varchar(50) NOT NULL,
datenaiss date NOT NULL,
lieunaiss varchar(25) NOT NULL,
codec int(6) NOT NULL,
parti varchar(25) NOT NULL,
PRIMARY KEY (idc),
UNIQUE KEY codec (codec)
);

CREATE TABLE voter (

idv int(11) NOT NULL AUTO_INCREMENT,
voix int(1) NOT NULL,
ide int(11) NOT NULL,
idc int(11) NOT NULL,
bureau int(6) NOT NULL,
commune varchar(50) NOT NULL,
departement varchar(50) NOT NULL,
region varchar(9) NOT NULL,
PRIMARY KEY (idv)
)

5 Script de requêtes sur la table VOTE, exécuté sur les serveurs 192.168.56.92 et 192.168.56.93
from netmiko import ConnectHandler as H
def connection(u:str,p:str,h:str):
conf={'device_type':'linux',
'username':u,
'host':h,
'password':p,
'secret':p,
'timeout':250,
'verbose':True}
return H(**conf)
r='192.168.1.'
for h in [92,93]:
cn=connection("root","6858",r+str(h))
commande=["mysql -u root --password='mysql' vote","SELECT * FROM vote"]
for l in commande:
result=cn.send_command(l)
 cn.disconnec()
print(result)

PARTIE 2 : Cryptographie avec le langage SHELL

Exercice

#!/bin/bash
crypto(){
read -p "Entrer le fichier a crypter: " f
if [ -s $f ];then
read -p "Entrer un algorithme de cryptage: " algo
if [ -n $algo ];then
openssl $algo -k secret -in $f > $f.cpt
fi
else
echo "$f n'est pas un fichier"
fi
}
crypto

Exercice

#!/bin/bash
crypto(){
if [[ -n $1 && -s $2 ]];then
openssl $1 -k secret -in $2 > $2.cpt
else
echo -e "\033[1;31m Erreur de parametre ! \033[0m"
fi
}
crypto aes-256-cbc exo1.sh

exercice
#!/bin/bash
crypto(){
if [[ -n $1 && -s $2 ]];then
openssl $1 -k secret -in $2 > $2.cpt
if [ $? -eq 0 ];then
echo -e "\033[1;32m [+] Cryptage effectue avec succes \033[0m"
fi
else
echo -e "\033[1;31m Erreur de parametre ! \033[0m"
fi
}
crypto $1 $2
Exercice

decrypto(){
if [[ -n $1 && -s $2 ]];then
openssl $1 -k secret -in $2 -d > $2.cpt
if [ $? -eq 0 ];then
echo -e "\033[1;32m [+] Decryptage effectue avec succes \033[0m"
fi
else
echo -e "\033[1;31m Erreur de parametre ! \033[0m"
fi
}
crypto $1 $2

exercice

cryptoDecrypto(){
if [[ -n $1 && -s $2 && -n $3 ]];then
case $1 in
-c)
openssl $2 -k secret -in $3 > $3.cpt ;;
-d)
openssl $2 -k secret -in $3 -d > $3.cpt ;;
esac
if [ $? -eq 0 ];then
echo -e "\033[1;32m [+] Decryptage effectue avec succes \033[0m"
fi
else
echo -e "\033[1;31m Erreur de parametre ! \033[0m"
fi
}
crypto $1 $2 $3

Exercice module :
Fichier : codeCrypto
crypto(){
if [ $# -ne 3 ];then
echo -e "\033[1;31m Erreur de Syntaxe: $0 fichier \033[0m"
exit 1
else
openssl $1 -k secret -in $2 > $2.cr
if [ $? -eq 0 ];then
echo -e "\033[1;32m $2 est crypte avec succes! \033[0m"
fi
fi
}

decrypto(){
if [ $# -ne 3 ];then
echo -e "\033[1;31m Erreur de Syntaxe: $0 fichier \033[0m"
exit 1
else
 openssl $1 -k secret -in $2 -d > $2.dc
if [ $? -eq 0 ];then
echo -e "\033]1;32 $2 est decrypte avec succes! \033]0m"
fi
fi
}
Appel du module codeCrypto:
#!/bin/bash
source codeCrypto
case $1 in
-c) crypto $2 $3;;
-d) decrypto $2 $3;;
*) echo -e "\033[1;31m Erreur de parametre ! \033[0m";;
esac
$1 $2 $3

TD1
Exercice 1 : Installer Apache, MySQL et PHP
- Apache et MySQL(Mariadb)
yum -y install httpd Installer le serveur Web
systemctl start httpd Demarrer le serveur Web
systemctl enable httpd.service Faire en sorte que le serveur soit démarré
automatiquement
Yum -y install mariadb-server Installer Mariadb Server
systemctl start mariadb Demarrer le serveur de base de données
systemctl enable mariadb.service Automatiser le demarrage du serveur Mariadb au
demarrage du système
mysql_secure_installation: Securiser la base de donnees
Ce script vous guidera à travers une série d'invites où vous pourrez apporter des modifications à votre
configuration MariaDB. La première invite vous demandera d'entrer le mot de passe root actuel de la base
de données. Cela ne doit pas être confondu avec l'utilisateur racine du système. L'utilisateur racine de la
base de données est un utilisateur administratif disposant de privilèges complets sur le système de base
de données. Étant donné que vous venez d'installer MariaDB et que vous n'avez apporté aucune
modification à la configuration, ce mot de passe sera vide. Appuyez sur ENTRÉE à l'invite.
L'invite suivante vous demande si vous souhaitez configurer un mot de passe root pour la base de données.
Tapez N puis appuyez sur ENTRÉE.
À partir de là, vous pouvez appuyer sur Y, puis sur ENTER pour accepter les valeurs par défaut pour toutes
les questions suivantes. Cela supprimera les utilisateurs anonymes et la base de données de test,
désactivera la connexion root à distance et chargera ces nouvelles règles afin que le serveur respecte
immédiatement les modifications que vous avez apportées.
Lorsque vous avez terminé, connectez-vous à la console MariaDB en saisissant sudo mysql
 - PHP
chown -R etudiant.ecole /var/www/html
<?php phpinfo(); ?>
http://your_server_IP_address/info.php
rm /var/www/html/info.php