Protégez votre vie privée

Saviez-vous que vous pouvez supprimer les métadonnées de vos photos pour protéger votre vie privée ? Voici quelques outils qui peuvent vous aider à supprimer les métadonnées de vos photos.

• VerExif - Outil en ligne pour supprimer les métadonnées des photos.
• ExifRemove - Outil en ligne pour supprimer les métadonnées des photos.
• Remove Photo Metadata - Outil en ligne pour supprimer les métadonnées des photos.
• ExifTool - Outil en ligne de commande pour supprimer les métadonnées des photos.

Protégez votre vie privée

Saviez-vous que vous pouvez utiliser un VPN pour masquer votre adresse IP et protéger votre vie privée ? Voici quelques outils qui peuvent vous aider à masquer votre adresse IP.

• Firefox - Navigateur gratuit avec VPN intégré.
• ExpressVPN - Service VPN pour masquer votre adresse IP.
• NordVPN - Service VPN pour masquer votre adresse IP.
• CyberGhost VPN - Service VPN pour masquer votre adresse IP.
• Private Internet Access - Service VPN pour masquer votre adresse IP.

Protégez votre vie privée

Vous pouvez protéger votre vie privée en désactivant le chargement des images dans votre client de messagerie ou en utilisant un client de messagerie textuel. Cela empêchera les traceurs de pixel d'être chargés et d'envoyer des informations à l'expéditeur.

De plus, vous pouvez utiliser des extensions de navigateur ou des services de messagerie qui bloquent les pixels de suivi.

Protégez votre application web

Pour protéger votre application web des vulnérabilités d'injection SQL, tenez compte des meilleures pratiques suivantes :

• Important : Utilisez des instructions préparées et des requêtes paramétrées.

• PHP
• Python
• Node
• .Net
• Java

/* mot de passe en base de données précédemment haché avec la fonction password_hash() */
function login($db, $email, $pass) {
    $stmt = $db->prepare("SELECT password FROM users WHERE email = ?");
    $stmt->bind_param("s", $email); //HL
    $stmt->execute();
    $user = $stmt->get_result()->fetch_assoc();
    if (!$user || !password_verify($pass, $user['password'])) {
        unset($_SESSION['user_email']);
        return false;
    }
    $_SESSION['user_email'] = $email;
    return true;
}

# mot de passe en base de données précédemment haché avec la fonction bcrypt.hashpw
import bcrypt

def login(db, session, email, password):
    cursor = db.cursor(dictionary=True)
    cursor.execute("SELECT password FROM users WHERE email = %s", (email,))  //HL
    user = cursor.fetchone()
    if not user or not bcrypt.checkpw(password.encode(), user['password'].encode()):
        session.pop('user_email', None)
        return False
    session['user_email'] = email
    return True

/* mot de passe en base de données précédemment haché avec la fonction bcrypt.hash */
const bcrypt = require('bcrypt');

async function login(db, session, email, pass) {
    const [rows] = await db.execute("SELECT password FROM users WHERE email = ?", [email]);  //HL
    const user = rows[0];
    if (!user || !await bcrypt.compare(pass, user.password)) {
        delete session.user_email;
        return false;
    }
    session.user_email = email;
    return true;
}

/* mot de passe en base de données précédemment haché avec la fonction BCrypt.HashPassword */
using BCrypt.Net;
using MySql.Data.MySqlClient;
using Microsoft.AspNetCore.Http;

public async Task<bool> Login(MySqlConnection db, ISession session, string email, string pass)
{
    using var cmd = new MySqlCommand("SELECT password FROM users WHERE email = @email", db);
    cmd.Parameters.AddWithValue("@email", email);  //HL

    using var reader = await cmd.ExecuteReaderAsync();
    if (!await reader.ReadAsync() || !BCrypt.Verify(pass, reader.GetString("password")))
    {
        session.Remove("user_email");
        return false;
    }

    session.SetString("user_email", email);
    return true;
}

/* mot de passe en base de données précédemment haché avec la fonction BCrypt.hashpw */
import org.mindrot.jbcrypt.BCrypt;
import java.sql.*;
import jakarta.servlet.http.HttpSession;

public boolean login(Connection db, HttpSession session, String email, String pass) throws SQLException {
    try (PreparedStatement stmt = db.prepareStatement("SELECT password FROM users WHERE email = ?")) {
        stmt.setString(1, email);  //HL
        ResultSet rs = stmt.executeQuery();

        if (!rs.next() || !BCrypt.checkpw(pass, rs.getString("password"))) {
            session.removeAttribute("user_email");
            return false;
        }

        session.setAttribute("user_email", email);
        return true;
    }
}

/* Dépendance Maven */
<dependency>
    <groupId>org.mindrot</groupId>
    <artifactId>jbcrypt</artifactId>
    <version>0.4</version>
</dependency>

• Validez et assainissez les entrées utilisateur.
• Utilisez des frameworks ORM (mapping objet-relationnel) qui gèrent SQL en toute sécurité.
• Mettez régulièrement à jour et corrigez votre base de données et votre logiciel d'application web.
• Implémentez une gestion appropriée des erreurs pour éviter d'exposer les erreurs de base de données aux utilisateurs.

Protégez votre application web

Pour protéger votre application web des vulnérabilités XSS, tenez compte des meilleures pratiques suivantes :

• Assainissez et validez les entrées utilisateur.

• PHP
• Python
• Node
• .Net
• Java

/* Installer via composer :
composer require ezyang/htmlpurifier */

require_once 'HTMLPurifier.auto.php';

function sanitize_html(string $input): string {
    $config = HTMLPurifier_Config::createDefault();
    $config->set('HTML.Allowed', 'b,i,u,strong,em,p,br,ul,ol,li,a[href|title],img[src|alt]');
    return (new HTMLPurifier($config))->purify($input);
}

# Installer via pip :
# pip install bleach

import bleach

ALLOWED_TAGS = ['b', 'i', 'u', 'strong', 'em', 'p', 'br', 'ul', 'ol', 'li', 'a', 'img']

ALLOWED_ATTRIBUTES = {
    'a':   ['href', 'title'],
    'img': ['src', 'alt'],
}

def sanitize_html(input: str) -> str:
    return bleach.clean(input, tags=ALLOWED_TAGS, attributes=ALLOWED_ATTRIBUTES, strip=True)

/* Installer via npm :
npm install sanitize-html */

const sanitizeHtml = require('sanitize-html');

const ALLOWED_TAGS = ['b', 'i', 'u', 'strong', 'em', 'p', 'br', 'ul', 'ol', 'li', 'a', 'img'];

const ALLOWED_ATTRIBUTES = {
    'a':   ['href', 'title'],
    'img': ['src', 'alt'],
};

function sanitizeHtmlInput(input) {
    return sanitizeHtml(input, {
        allowedTags: ALLOWED_TAGS,
        allowedAttributes: ALLOWED_ATTRIBUTES,
    });
}

/* Installer via dotnet :
dotnet add package HtmlSanitizer */

using Ganss.Xss;

public static string SanitizeHtml(string input)
{
    var sanitizer = new HtmlSanitizer();

    sanitizer.AllowedTags.Clear();
    foreach (var tag in new[] { "b", "i", "u", "strong", "em", "p", "br", "ul", "ol", "li", "a", "img" })
        sanitizer.AllowedTags.Add(tag);

    sanitizer.AllowedAttributes.Clear();
    sanitizer.AllowedAttributes.Add("href");
    sanitizer.AllowedAttributes.Add("title");
    sanitizer.AllowedAttributes.Add("src");
    sanitizer.AllowedAttributes.Add("alt");

    return sanitizer.Sanitize(input);
}

/* Installer via Gradle :
implementation 'org.jsoup:jsoup:1.17.2' */

import org.jsoup.Jsoup;
import org.jsoup.safety.Safelist;

public static String sanitizeHtml(String input) {
    Safelist safelist = new Safelist()
        .addTags("b", "i", "u", "strong", "em", "p", "br", "ul", "ol", "li", "a", "img")
        .addAttributes("a",   "href", "title")
        .addAttributes("img", "src",  "alt");

    return Jsoup.clean(input, safelist);
}

<dependency>
    <groupId>org.jsoup</groupId>
    <artifactId>jsoup</artifactId>
    <version>1.17.2</version>
</dependency>

• Utilisez les en-têtes de politique de sécurité du contenu (CSP).

• PHP
• Python
• Node
• .Net
• Java

header("Content-Security-Policy:
    default-src 'self';
    script-src  'self';
    style-src   'self' 'unsafe-inline' https://fonts.googleapis.com;
    img-src     'self' data: https:;
    font-src    'self' https://fonts.gstatic.com;
    connect-src 'self';
    frame-src   'none';
    object-src  'none';
");

# Avec Flask
@app.after_request
def set_csp(response):
    response.headers['Content-Security-Policy'] = (
        "default-src 'self'; "
        "script-src 'self'; "
        "style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; "
        "img-src 'self' data: https:; "
        "font-src 'self' https://fonts.gstatic.com; "
        "connect-src 'self'; "
        "frame-src 'none'; "
        "object-src 'none';"
    )
    return response

# Django (middleware.py) :
# pip install django-csp

class CSPMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        response = self.get_response(request)
        response['Content-Security-Policy'] = (
            "default-src 'self'; "
            "script-src 'self'; "
            "style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; "
            "img-src 'self' data: https:; "
            "font-src 'self' https://fonts.gstatic.com; "
            "connect-src 'self'; "
            "frame-src 'none'; "
            "object-src 'none';"
        )
        return response

# Ensuite, l'enregistrer dans settings.py :
MIDDLEWARE = [
    'yourapp.middleware.CSPMiddleware',
    ...
]

• Échappez les sorties dans les contextes HTML, JavaScript et CSS.
• Utilisez des frameworks qui gèrent automatiquement la protection XSS.

Protégez votre application web

Pour protéger votre application web des vulnérabilités de téléversement de fichiers, tenez compte des meilleures pratiques suivantes :

• Validez les types et tailles de fichiers. Acceptez les types de fichiers définis plutôt que de bloquer les types inconnus.
• Stockez les fichiers téléversés en dehors de la racine web.
• Renommez les fichiers téléversés pour éviter l'écrasement et l'exécution de scripts. Par exemple, renommez ".htaccess" en "my-download-001.bin"
• Définissez des permissions appropriées sur les fichiers et répertoires téléversés.
• Utilisez un antivirus pour analyser les fichiers téléversés.

Protégez votre application web

Pour protéger votre application web des attaques par tables arc-en-ciel, tenez compte des meilleures pratiques suivantes :

• Utilisez un algorithme de hachage robuste (ex. : bcrypt, Argon2) avec un sel unique pour chaque mot de passe.
• Implémentez des mécanismes de limitation de débit et de verrouillage de compte pour prévenir les attaques par force brute.
• Sensibilisez les utilisateurs à la création de mots de passe forts et uniques.
• Une façon de définir un mot de passe est d'utiliser une phrase plutôt que des caractères aléatoires, par exemple : "Regardezcequejaifaitaujourdhuichezmoicestaitsuper !"

Protégez votre application web

Pour protéger votre application web des attaques par force brute, tenez compte des meilleures pratiques suivantes :

• Implémentez des mécanismes de verrouillage de compte après un certain nombre de tentatives de connexion échouées.
• Utilisez des CAPTCHAs pour empêcher les tentatives de connexion automatisées.
• Encouragez les utilisateurs à créer des mots de passe forts et uniques et envisagez d'implémenter des exigences de robustesse des mots de passe.
• Utilisez l'authentification multi-facteurs (MFA) pour ajouter une couche de sécurité supplémentaire.
• Vous pourriez également vérifier que le mot de passe n'existe pas dans les fichiers de dictionnaire.

Protégez votre application web

Pour protéger votre application web des attaques par bombe fork, tenez compte des meilleures pratiques suivantes :

• Limitez le nombre de processus qu'un utilisateur peut créer.

• Linux
• Windows
• MacOS

#Via la stratégie de groupe :
# Win + R → gpedit.msc
# Configuration de l'ordinateur → Paramètres Windows → Paramètres de sécurité → Stratégies locales → Attribution des droits utilisateur
# Trouvez "Augmenter la priorité de planification" et restreignez les utilisateurs

# Limiter les processus pour un utilisateur spécifique en utilisant des objets de travail
# Nécessite des outils tiers comme Process Lasso ou SysInternals pour les limites par utilisateur
# Windows n'a pas de limite de processus par utilisateur native comme Linux — utilisez Process Lasso ou SysInternals PsExec pour un contrôle granulaire.

# Contenu du fichier /etc/security/limits.conf :
# Nombre maximum de processus par utilisateur
username    hard    nproc    100
# Ou pour tous les utilisateurs
*           hard    nproc    100

# Temporairement dans le shell :
ulimit -u 100

# Vérifier dans le shell :
ulimit -u

# Modifier /etc/launchd.conf (ancienne macOS) ou utiliser launchctl :
# Vérifier les limites actuelles
launchctl limit maxproc

# Définir la limite
sudo launchctl limit maxproc 100 200
# (limite souple 100, limite stricte 200)

# Ou via /etc/sysctl.conf :
kern.maxprocperuid=100
sudo sysctl -w kern.maxprocperuid=100

• Implémentez une surveillance et des alertes pour les activités de processus inhabituelles.
• Sensibilisez les utilisateurs aux dangers de l'exécution de code non fiable.