# Permissions Linux et calculateur Chmod : Architecture technique et guide approfondi

Dans les systèmes Unix et POSIX, la sécurité repose sur le contrôle d'accès discrétionnaire (DAC). Le mot de mode de 16 bits régit lecture, écriture et exécution entre utilisateurs. De Nginx à OpenSSH ou Docker rootless, maîtriser ces permissions conditionne la fiabilité opérationnelle.

L'utilitaire chmod (change mode) modifie ces bits. Naviguer entre notation octale (755, 644) et symbolique (rwxr-xr-x, rw-r--r--) induit de fréquentes erreurs exposant des clés privées ou provoquant des erreurs HTTP 403 Forbidden.

Le Calculateur de permissions Linux et Chmod ToolsAA est un calculateur chmod interactif, un validateur POSIX et un générateur de permissions chmod 755 et 644. Bâti à 100 % côté client ("use client"), les calculs s'opèrent en mémoire locale sans télémétrie, garantissant la conformité stricte au RGPD.

# Présentation générale et cas d'usage en production

Le modèle POSIX structure les droits selon trois entités :

• Propriétaire (u - Owner) : Utilisateur propriétaire du fichier sur le système.
• Groupe (g - Group) : Groupe système assigné pour le travail d'équipe.
• Autres (o - Others) : Tout autre compte authentifié sur le système d'exploitation.

Trois opérations élémentaires sont évaluées par le noyau :

• Lecture (r / 4) : Lire le fichier ou lister le contenu d'un répertoire (readdir()).
• Écriture (w / 2) : Modifier le fichier ou créer/supprimer des entrées du dossier.
• Exécution (x / 1) : Exécuter le binaire (execve()) ou traverser le dossier (chdir()).

+-------------------------------------------------------------------------------------------+
|                           POSIX File Mode Word (16-Bit Bitmask)                           |
|  [ Type : 4b ]      [ Spécial : 3b ] [ Propriétaire : 3b ] [ Groupe : 3b ] [ Autres : 3b ]|
|  0100000 (Fichier)  4: SetUID        4: Lecture (r)        4: Lecture (r)  4: Lecture (r) |
|  0040000 (Dossier)  2: SetGID        2: Écriture (w)       2: Écriture (w) 2: Écriture (w)|
|  Mode 755 :         Spécial : 0      Propriétaire : 7(rwx) Groupe : 5(r-x) Autres : 5(r-x)|
|  Mode 644 :         Spécial : 0      Propriétaire : 6(rw-) Groupe : 4(r--) Autres : 4(r--)|
+-------------------------------------------------------------------------------------------+

# Cas d'usage clés en entreprise

• Serveurs web (Nginx/Apache) : Dossiers en 755 (traversée via chdir) et fichiers en 644.
• Durcissement SSH : Clés privées (id_rsa) en 600/400, dossier ~/.ssh/ en 700.
• Partage d'équipe (SetGID) : Dossiers en 2775 (héritage du groupe parent).
• Espaces temporaires : Répertoires sous Sticky Bit (1777 /tmp) interdisant la suppression tierce.

# Traitement côté client pour une confidentialité absolue

Les administrateurs manipulent des chemins sensibles (/etc/ssl/private, ~/.aws/credentials). ToolsAA traite 100 % des opérations en mémoire locale du navigateur ("use client"). Zéro requête HTTP ni journalisation.

# Architecture technique et fonctionnement interne

Le calcul des droits d'accès unix et des permissions linux s'appuie sur la manipulation binaire et les structures du noyau.

# 1. Le mot de mode POSIX et l'inode

Les métadonnées résident dans les inodes. Le champ st_mode (<sys/stat.h>) est un entier 16 bits :

• Type (Bits 15–12) : Fichier (0100000), dossier (0040000), lien (0120000), socket (0140000).
• Bits spéciaux (Bits 11–9) : SetUID (04000), SetGID (02000), Sticky Bit (01000).
• Triades (Bits 8–0) : Propriétaire (0700), Groupe (0070), Autres (0007).

# 2. Mathématiques binaires et base octale

La base octale encode trois bits par chiffre ($2^3 = 8$) :

$$\text{Valeur de la triade} = (r \times 4) + (w \times 2) + (x \times 1)$$

Combinaisons de 0 (---) à 7 (rwx). Concaténer les triades produit le mode standard (755). Les bits spéciaux ajoutent un préfixe (4755).

# 3. Bits spéciaux dans les chaînes symboliques

En notation symbolique (ls -l), les bits spéciaux remplacent le bit d'exécution (x) :

• SetUID : s avec exécution (rwsr-xr-x), S sans exécution (rwSr-xr-x).
• SetGID : s avec exécution (rwxrwsr-x), S sans exécution (rwxrwSr-x).
• Sticky Bit : t avec exécution (rwxrwxrwt), T sans exécution (rwxrwxrwT).

# 4. L'équation d'inversion du masque umask

Chaque processus hérite d'un masque umask filtrant les modes initiaux (0666 fichiers, 0777 dossiers) :

$$\text{Mode effectif} = \text{Mode par défaut} \ \& \ (\sim\text{Umask})$$

Avec umask 0022 : les fichiers reçoivent 0644 (0666 & 0022) ; les dossiers 0755 (0777 & 0022).

# 5. Dualisme sémantique du bit d'exécution

Sur un fichier, x permet l'exécution (execve()). Sur un dossier, x sert de fanion de traversée (search bit) : sans lui, impossible d'entrer dans le dossier (cd) ou d'inspecter les métadonnées (stat()), même si les fichiers enfants sont en 0644.

# 6. Architecture web in-browser

• Moteur binaire : Calculs instantanés via opérateurs bitwise JavaScript (&, |, ~).
• Web Crypto API : Intégrité locale via crypto.subtle.digest("SHA-256").
• Visualiseur réactif : Actualisation synchrone de la grille 3x3 sans latence.
• Export direct : Commandes terminal prêtes pour scripts shell et déploiements CI/CD.

# Guide pratique étape par étape

# Étape 1 : Grille interactive 3x3

Cochez Lecture (4), Écriture (2) ou Exécution (1) pour Propriétaire, Groupe et Autres. Mode octal (755) et chaîne symbolique (rwxr-xr-x) s'actualisent instantanément.

# Étape 2 : Préréglages d'entreprise

Chargez un profil en un clic : 755 (web, scripts), 644 (fichiers statiques), 600 (clés SSH), 700 (dossiers privés), 400 (certificats PEM) ou 1777 (dossiers /tmp).

# Étape 3 : Drapeaux spéciaux

Activez SetUID (4000), SetGID (2000) ou Sticky Bit (1000). L'affichage s'adapte en notation 4 chiffres (2755).

# Étape 4 : Commande récursive dissociée

Renseignez le chemin (ex. /var/www/html) et cochez l'option dissociée pour appliquer 755 aux répertoires et 644 aux fichiers.

# Étape 5 : Exportation et terminal

Sélectionnez le format octal (chmod 755 /chemin) ou symbolique (chmod u=rwx,go=rx /chemin) et cliquez sur Copier la commande.

# Implémentations de code prêtes pour la production

# 1. Implémentation en TypeScript

Moteur typé pour conversions octales, symboliques et calcul d'umask :

export interface Triad { read: boolean; write: boolean; execute: boolean; }
export interface SpecialBits { setuid: boolean; setgid: boolean; sticky: boolean; }

// Convertit les booléens de permissions en chaîne octale standard
export function toOctal(u: Triad, g: Triad, o: Triad, s: SpecialBits): string {
  const spec = (s.setuid ? 4 : 0) + (s.setgid ? 2 : 0) + (s.sticky ? 1 : 0);
  const val = (t: Triad) => (t.read ? 4 : 0) + (t.write ? 2 : 0) + (t.execute ? 1 : 0);
  const mode = `${val(u)}${val(g)}${val(o)}`;
  return spec > 0 ? `${spec}${mode}` : mode;
}

// Convertit un mode octal en notation symbolique standard (ls -l)
export function toSymbolic(octal: string, isDir = false): string {
  const [s, u, g, o] = octal.padStart(4, "0").split("").map(Number);
  const fmt = (v: number, spec: boolean, sx: string, snx: string) => {
    const r = v & 4 ? "r" : "-", w = v & 2 ? "w" : "-", x = v & 1;
    return `${r}${w}${spec ? (x ? sx : snx) : (x ? "x" : "-")}`;
  };
  return `${isDir ? "d" : "-"}${fmt(u, !!(s & 4), "s", "S")}${fmt(g, !!(s & 2), "s", "S")}${fmt(o, !!(s & 1), "t", "T")}`;
}

// Calcule le mode effectif après application du masque umask
export function applyUmask(mode: number, umask: number): string {
  return ((mode & ~umask) & 0o777).toString(8).padStart(3, "0");
}

# 2. Implémentation en JavaScript

Module utilitaire JavaScript de validation et génération de commandes :

// Validation et génération de commandes sécurisées en JavaScript moderne
export class ChmodValidator {
  static parseTriad(t) {
    return (t.includes("r") ? 4 : 0) + (t.includes("w") ? 2 : 0) + (/[xst]/i.test(t) ? 1 : 0);
  }

  // Génère des commandes find dissociées pour dossiers et fichiers
  static bifurcatedCommands(path, dirMode = "755", fileMode = "644") {
    const p = path.replace(/"/g, '\\"');
    return {
      dirs: `find "${p}" -type d -exec chmod ${dirMode} {} +`,
      files: `find "${p}" -type f -exec chmod ${fileMode} {} +`
    };
  }
}

# 3. Implémentation en Python

Module Python d'audit et de manipulation des permissions POSIX :

from typing import Dict, Tuple

# Conversion et audit des permissions POSIX en Python
def to_octal(u: tuple, g: tuple, o: tuple, s: tuple = (0, 0, 0)) -> str:
    """Convertit des tuples (r, w, x) en notation octale."""
    spec = s[0] * 4 + s[1] * 2 + s[2] * 1
    val = lambda t: t[0] * 4 + t[1] * 2 + t[2] * 1
    mode = f"{val(u)}{val(g)}{val(o)}"
    return f"{spec}{mode}" if spec else mode

def to_symbolic(octal: str, is_dir: bool = False) -> str:
    """Convertit un mode octal en notation symbolique (ls -l)."""
    s, u, g, o = [int(d) for d in octal.zfill(4)]
    fmt = lambda v, spec, sx, snx: f"{'r' if v & 4 else '-'}{'w' if v & 2 else '-'}{(sx if v & 1 else snx) if spec else ('x' if v & 1 else '-')}"
    return f"{'d' if is_dir else '-'}{fmt(u, bool(s & 4), 's', 'S')}{fmt(g, bool(s & 2), 's', 'S')}{fmt(o, bool(s & 1), 't', 'T')}"

def bifurcated_commands(path: str, dir_m="755", file_m="644") -> dict[str, str]:
    """Génère des commandes find sécurisées dissociant dossiers et fichiers."""
    return {
        "dirs": f"find {path} -type d -exec chmod {dir_m} {{}} +",
        "files": f"find {path} -type f -exec chmod {file_m} {{}} +"
    }

# Pièges courants, cas limites et guide de dépannage

# 1. L'anti-pattern chmod 777

Accorder chmod 777 (rwxrwxrwx) ouvre les droits complets à tous. Tout processus compromis peut écraser des binaires ou déposer des webshells. Utilisez systématiquement 755 pour les dossiers et 644 pour les fichiers.

# 2. Le piège récursif chmod -R

Lancer chmod -R 644 supprime le bit d'exécution (x) des répertoires, bloquant la traversée. Inversement, chmod -R 755 rend tous les fichiers exécutables. Dissociez via find :

find /var/www/html -type d -exec chmod 755 {} +
find /var/www/html -type f -exec chmod 644 {} +

# 3. Traversée de répertoire (x) vs lecture (r)

Sur un répertoire, r-- permet de lister les noms (readdir()). Sans exécution (--x), entrer dans le dossier (cd) ou lire les métadonnées (stat()) est impossible, même avec des fichiers enfants en 0644.

# 4. Inefficacité du SetUID sur les scripts interprétés

Activer SetUID (chmod 4755 script.sh) sur un script shell (#!/bin/bash) ne donne aucun droit root : Linux ignore SetUID sur les scripts interprétés pour prévenir les failles de concurrence sur /dev/fd. Utilisez sudo.

# 5. Mythe de la soustraction arithmétique de l'umask

L'umask n'est pas une soustraction. Si 0666 - 0022 = 0644 semble cohérent, avec umask 0027 la soustraction échoue, alors que l'opération binaire 0666 & ~0027 donne 0640 (rw-r-----).

# 6. Avertissement de sécurité OpenSSH

OpenSSH refuse les clés privées accessibles par des tiers (WARNING: UNPROTECTED PRIVATE KEY FILE!). Restreignez l'accès avec chmod 600 /.ssh/id_rsa ou chmod 400 key.pem, et protégez /.ssh/ en 700.

# Foire aux questions détaillée (FAQ)

# Q1 : Différence technique entre chmod 755 et chmod 644 ?

Réponse : Le mode 755 (rwxr-xr-x) accorde contrôle total au propriétaire et lecture/exécution aux autres (répertoires, binaires). Le mode 644 (rw-r--r--) accorde lecture/écriture au propriétaire et lecture seule aux autres (fichiers statiques, configs).

# Q2 : Pourquoi le mode chmod 777 est-il interdit en production ?

Réponse : Le mode 777 accorde tous les droits à tous, violant le moindre privilège. Tout processus compromis peut écraser des fichiers système ou implanter des portes dérobées.

# Q3 : Que signifient SetUID, SetGID, Sticky Bit et les majuscules S et T ?

Réponse : SetUID (4000) exécute avec les droits du propriétaire. SetGID (2000) propage le groupe parent. Le Sticky Bit (1000) empêche la suppression tierce dans /tmp. Minuscule (s/t) indique l'exécution active ; majuscule (S/T) son inactivité.

# Q4 : Comment l'umask calcule-t-il les permissions par défaut ?

Réponse : Le noyau applique $\text{Mode effectif} = \text{Base} \ \& \ (\sim\text{Umask})$. Avec bases 0666 (fichiers) et 0777 (dossiers) et umask 0022, les fichiers reçoivent 0644 et dossiers 0755.

# Q5 : Pourquoi un répertoire lisible sans exécution est-il inaccessible ?

Réponse : La lecture (r) permet de lister les noms (readdir()). L'exécution (x) est requise pour entrer dans le dossier (cd) et lire les métadonnées (stat()). Sans x, l'accès reste impossible.

# Q6 : Comment corriger l'erreur OpenSSH « Permissions are too open » ?

Réponse : OpenSSH refuse les clés accessibles aux tiers. Restreignez l'accès au propriétaire avec chmod 600 /.ssh/id_rsa ou chmod 400 key.pem, et réservez /.ssh/ en 700.

# Q7 : Comment appliquer des permissions différentes aux dossiers et fichiers en récursif ?

Réponse : Évitez chmod -R. Utilisez find pour appliquer chmod 755 aux répertoires (-type d) et chmod 644 aux fichiers (-type f) de manière dissociée.

# Q8 : Le calculateur Chmod de ToolsAA transmet-il mes données à un serveur ?

Réponse : Non. ToolsAA s'exécute à 100 % côté client ("use client"). Tous les calculs s'opèrent en mémoire locale du navigateur. Aucun chemin ni métadonnée ne quitte votre machine.

# Matrice de référence technique : Modes de permissions Linux standards

# Conclusion

Le modèle de permissions POSIX est un fondement de l'administration Unix. Les modes de fichiers isolent les processus et préservent la confidentialité des identifiants critiques.

Céder à l'anti-pattern chmod 777 fragilise l'infrastructure. Un calculateur chmod interactif permet de visualiser la logique binaire, de configurer les bits spéciaux et de générer des commandes certifiées.

Le Calculateur de permissions Linux et Chmod ToolsAA offre une précision absolue pour valider vos permissions linux. Son exécution 100 % in-browser garantit une confidentialité totale sans transmission réseau.