Aller au contenu principal

Chapitre 9.1 - Sécurisation des Permissions

Objectifs d'Apprentissage​

À la fin de ce chapitre, vous serez capable de:

  • Appliquer le principe du moindre privilège
  • Sécuriser les permissions fichiers
  • Comprendre les risques des permissions larges
  • Auditer les permissions système
  • Corriger les permissions incorrectes

Principe du Moindre Privilège​

Concept​

Donner seulement les permissions nécessaires, rien de plus.

Avantages:

  • Réduction surface d'attaque
  • Limitation des dégâts
  • Conformité sécurité

Permissions Sécurisées​

Fichiers Normaux​

# Fichiers de configuration
chmod 644 fichier.conf    # rw-r--r--
chmod 600 fichier.conf    # rw------- (privé)

# Scripts exécutables
chmod 755 script.sh       # rwxr-xr-x
chmod 700 script.sh       # rwx------ (privé)

# Fichiers sensibles
chmod 600 .ssh/id_rsa     # Clé privée
chmod 644 .ssh/id_rsa.pub # Clé publique
chmod 700 .ssh/           # Répertoire SSH

Répertoires​

# Répertoires normaux
chmod 755 repertoire/      # rwxr-xr-x

# Répertoires privés
chmod 700 repertoire/     # rwx------

# Répertoires partagés
chmod 775 shared/         # rwxrwxr-x
chmod 1777 /tmp           # Sticky bit

Permissions Dangereuses​

À Éviter​

# 777 - Tous les droits (DANGEREUX!)
chmod 777 fichier  # ÉVITER!

# SUID/SGID inutiles
chmod u+s script.sh  # Vérifier nécessité

# Répertoires world-writable
chmod 777 repertoire/  # ÉVITER!

Détecter​

# Fichiers avec permissions larges
find /home -type f -perm -o+w
find / -type f -perm 777 2>/dev/null

# Répertoires world-writable
find / -type d -perm -o+w ! -path "/proc/*" 2>/dev/null

# Fichiers SUID/SGID
find / -type f -perm /4000 2>/dev/null  # SUID
find / -type f -perm /2000 2>/dev/null  # SGID

Sécurisation SSH​

Permissions Correctes​

# Répertoire .ssh
chmod 700 ~/.ssh

# Clés privées
chmod 600 ~/.ssh/id_rsa
chmod 600 ~/.ssh/id_ed25519

# Clés publiques
chmod 644 ~/.ssh/id_rsa.pub
chmod 644 ~/.ssh/authorized_keys

# Config
chmod 600 ~/.ssh/config

Vérification​

# Script de vérification
#!/bin/bash
SSH_DIR="$HOME/.ssh"

if [ -d "$SSH_DIR" ]; then
    # Vérifier permissions répertoire
    PERMS=$(stat -c "%a" "$SSH_DIR")
    if [ "$PERMS" != "700" ]; then
        echo "ATTENTION: .ssh devrait être 700, actuellement $PERMS"
    fi
    
    # Vérifier clés privées
    for key in "$SSH_DIR"/id_*; do
        if [ -f "$key" ] && [[ "$key" != *.pub ]]; then
            PERMS=$(stat -c "%a" "$key")
            if [ "$PERMS" != "600" ]; then
                echo "ATTENTION: $key devrait être 600, actuellement $PERMS"
            fi
        fi
    done
fi

Sécurisation Cron​

Permissions Crontab​

# Crontab utilisateur
chmod 600 ~/.crontab  # Si fichier externe

# Vérifier crontab système
ls -l /etc/crontab
ls -l /etc/cron.d/*

Environnement Cron​

# Crontab sécurisé
PATH=/usr/bin:/bin
SHELL=/bin/bash
MAILTO=admin@example.com

# Utiliser chemins absolus
0 2 * * * /usr/local/bin/backup.sh

# Rediriger sortie
0 2 * * * /usr/local/bin/script.sh > /var/log/script.log 2>&1

# Ne pas utiliser variables non définies

Scripts Cron Sécurisés​

#!/bin/bash
# Script cron sécurisé

# Options sécurité
set -euo pipefail

# Chemins absolus
SCRIPT_DIR="/usr/local/bin"
LOG_FILE="/var/log/mon-script.log"

# Fonction de logging
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" >> "$LOG_FILE"
}

# Vérifications
if [ ! -f "$SCRIPT_DIR/config" ]; then
    log "ERREUR: Fichier config manquant"
    exit 1
fi

# Traitement...
log "Début traitement"
# ...
log "Fin traitement"

Audit des Permissions​

Script d'Audit​

#!/bin/bash
# Audit des permissions

echo "=== Fichiers world-writable ==="
find /home -type f -perm -o+w 2>/dev/null

echo "=== Répertoires world-writable ==="
find /home -type d -perm -o+w 2>/dev/null

echo "=== Fichiers SUID ==="
find /home -type f -perm /4000 2>/dev/null

echo "=== Fichiers SGID ==="
find /home -type f -perm /2000 2>/dev/null

echo "=== Permissions SSH ==="
if [ -d ~/.ssh ]; then
    ls -la ~/.ssh
fi

Correction Automatique​

#!/bin/bash
# Corriger permissions SSH

SSH_DIR="$HOME/.ssh"

if [ -d "$SSH_DIR" ]; then
    chmod 700 "$SSH_DIR"
    
    # Clés privées
    find "$SSH_DIR" -name "id_*" ! -name "*.pub" -exec chmod 600 {} \;
    
    # Clés publiques
    find "$SSH_DIR" -name "*.pub" -exec chmod 644 {} \;
    
    # authorized_keys
    [ -f "$SSH_DIR/authorized_keys" ] && chmod 600 "$SSH_DIR/authorized_keys"
    
    # config
    [ -f "$SSH_DIR/config" ] && chmod 600 "$SSH_DIR/config"
    
    echo "Permissions SSH corrigées"
fi

Bonnes Pratiques​

Fichiers​

  • 644 pour fichiers normaux
  • 600 pour fichiers sensibles
  • 755 pour scripts exécutables
  • 700 pour scripts privés

Répertoires​

  • 755 pour répertoires normaux
  • 700 pour répertoires privés
  • 775 pour répertoires partagés (avec groupe)
  • 1777 pour /tmp (sticky bit)

Vérifications​

  • Auditer régulièrement
  • Automatiser avec scripts
  • Documenter exceptions
  • Réviser après changements

Résumé​

Dans ce chapitre, vous avez appris:

Moindre privilège: Permissions minimales nécessaires
Sécurisation: Permissions appropriées selon type
Détection: Trouver permissions dangereuses
SSH: Permissions correctes pour clés et config
Cron: Sécurisation scripts et environnement
Audit: Scripts pour vérifier et corriger

Prochaines Étapes​

Chapitre 9.2: Configuration sudo
Chapitre 9.3: Pare-feu

Chapitre créé le: Décembre 2024