Provided by: manpages-fr_1.67.0-1_all bug

NOM

       capabilities - Présentation des capacités Linux.

DESCRIPTION

       Pour vérifier les permissions, les implémentations Unix traditionnelles
       distinguent deux catégories de processus :  Les  processus  privilgis
       (dont  l’UID  effectif est nul, appelés Super-Utilisateur, ou root), et
       et les processus non-privilgis (dont  l’UID  effectif  est  non-nul).
       Les  processus privilégiés contournent les vérifications de permissions
       du noyau, alors que les processus non-privilégiés  sont  soumis  à  une
       vérification   complète   basée   sur   l’identification  du  processus
       (habituellement : UID effectif, GID effectif, et liste des groupes).

       À partir du noyau 2.2, Linux propose un mécanisme  (encore  impcomplet)
       de  capacits,  qui  scinde  les privilèges traditionnement associés au
       Super-utilisateur en unités distinctes que l’on peut activer ou inhiber
       individuellement.

   Liste des capacités
       Sous Linux 2.4.20, les capacités suivantes sont implémentées :

       CAP_CHOWN
              Permet  de  modifier  arbitrairement les UID et GID des fichiers
              (voir chown(2)).

       CAP_DAC_OVERRIDE
              Contourne les permissions de  lecture,  écriture  et  exécution.
              (DAC  =  "discretionary  access  control",  contrôle  d’accès  à
              volonté).

       CAP_DAC_READ_SEARCH
              Contourne les permissions de lecture de fichiers  et  celles  de
              lecture et exécution des répertoires.

       CAP_FOWNER
              Contourne  les  vérifications  pour les opérations qui demandent
              que le FS-UID du processus corresponde à l’UID du  fichier  (par
              exemple  utime(2)),  à  l’exclusion des opérations couvertes par
              les CAP_DAC_OVERRIDE et CAP_DAC_READ_SEARCH  ;  Ignorer  le  bit
              sticky pour supprimer un fichier.

       CAP_FSETID
              Ne  pas effacer les bits Set-UID et Set-GID quand un fichier est
              modifié ; autoriser le positionnement  du  bit  Set-GID  sur  un
              fichier  dont  le  GID  ne  correspond  à aucun GID du processus
              appelant.

       CAP_IPC_LOCK
              Permer le verrouillage de page mémoire  (mlock(2),  mlockall(2),
              shmctl(2)).

       CAP_IPC_OWNER
              Contourne  les  vérifications  pour  les  opérations sur les IPC
              Système V.

       CAP_KILL
              Contourne les vérifications pour  l’émission  de  signaux  (voir
              kill(2)).

       CAP_LEASE
              (Depuis  Linux  2.4)  Autorise  la demande de bail sur n’importe
              quel fichier (voir fcntl(2)).

       CAP_LINUX_IMMUTABLE
              Autorise le positionnement des attributs étendus  EXT2_APPEND_FL
              et EXT2_IMMUTABLE_FL du système de fichiers ext2.

       CAP_MKNOD
              (Depuis  Linux  2.4)  Autorise  la création de fichiers spéciaux
              avec mknod(2).

       CAP_NET_ADMIN
              Permet certaines opérations résaeu (par ex. obtenir des  options
              privilégiées  sur  les sockets, activer le multicast, configurer
              les interfaces, modifier les tables de routage).

       CAP_NET_BIND_SERVICE
              Autorise l’attachement d’une socket sur un port réservé  (numéro
              de port inférieur à 1024).

       CAP_NET_BROADCAST
              (Inutilisé)  Permet  le  broadcast et l’écoute multicast sur les
              sockets.

       CAP_NET_RAW
              Autorise l’utilisation des sockets RAW et PACKET.

       CAP_SETGID
              Accès toute les manipulations des GID  du  processus  et  de  la
              liste  de  groupes supplémentaires, permet l’utilisation de faux
              GID sur les socket Unix.

       CAP_SETPCAP
              Autorise le transfert de  toutes  capacités  de  l’ensemble  des
              capacités  autorisées  de  l’appelant à partir ou vers n’importe
              quel processus.

       CAP_SETUID
              Permer  la  manipulation  arbitraire  des   UID   du   processus
              (setuid(2)...)  permet de transmettre un faux UID sur une socket
              dans le domaine Unix.

       CAP_SYS_ADMIN
              Autorise  un  ensemble  d’opérations  d’aministration   système,
              comprenant :  quotactl(2),  mount(2), swapon(2), sethostname(2),
              setdomainname(2), IPC_SET et IPC_RMID sur n’importe  quel  objet
              IPC   Système  V ;  permet  d’utiliser  un  faux  UID  pour  les
              authentifications des sockets.

       CAP_SYS_BOOT
              Autorise l’appel reboot(2).

       CAP_SYS_CHROOT
              Autorise l’appel chroot(2).

       CAP_SYS_MODULE
              Permet le chargement ou le déchargement de modules  du  noyaux ;
              permet la modification des limitations de capacités.

       CAP_SYS_NICE
              Autorise    la    diminution    de   la   courtoisie   (nice(2),
              setpriority(2)) et la modification de la valeur de courtoisie de
              n’importe    quel   processus ;   autorise   l’utilisation   des
              ordonnancements temps-réel pour le  processus  appelant,  et  la
              modification  de  l’ordonnancement  de n’importe quel processus.
              (sched_setscheduler(2), sched_setparam(2)).

       CAP_SYS_PACCT
              Autorise l’appel acct(2).

       CAP_SYS_PTRACE
              Permet de suivre n’importe quel processus avec ptrace(2)

       CAP_SYS_RAWIO
              Autorise   les   opérations   d’entrées/sorties   (iopl(2)    et
              ioperm(2)).

       CAP_SYS_RESOURCE
              Permet : l’utilisation de l’espace réservé sur un système ext2 ;
              l’appel ioctl(2) pour configurer  la  journalisation  ext3 ;  le
              dépassement des quotas de disque ; l’augmentation des limites de
              ressources  (voir  setrlimit(2));  la  surcharge  de  la  limite
              RLIMIT_NPROC  ;  l’augmentation de la limite msg_qbytes pour une
              file   de    messages    au-dessus    de    la    limite    dans
              /proc/sys/kernel/msgmnb (voir msgop(2) et msgctl(2)).

       CAP_SYS_TIME
              Autorise  la  modification  de l’heure système (settimeofday(2),
              adjtimex(2)) ; permet la modification  de  l’horloge  temps-réel
              (matérielle).

       CAP_SYS_TTY_CONFIG
              Autorise l’appel de vhangup(2).

   Capacités dun processus
       Chaque processus a trois ensembles contenant zéro ou plus des capacités
       ci-dessus :

       Effectif :
              Les  capacités  utilisées  par  le  noyau  pour   vérifier   les
              permissions du processus.

       Autoris :
              Les  capacités  auxquelles  le  processus  peut accéder (un sur-
              ensemble limite pour les ensembles effectif et  héritable).   Si
              un  processus supprime une capacité de son ensemble autorisé, il
              ne plus jamais la récupérer (sauf s’il exécute un programme Set-
              UID root).

       Hritable :
              les capacités qui sont conservées au cours d’un execve(2).

       Dans   l’implémentation   actuelle,  un  processus  reçoit  toutes  les
       capacités dans ses  ensembles  autorisé  et  effectif  (à  travers  les
       limites  décrites  ci-dessous)  lorsqu’il exécute un programme Set-UID-
       root, ou si un processus avec  un  UID  réel  nul  exécute  un  nouveau
       programme.

       Un  enfant  créé par fork(2) reçoit une copie des ensembles de capacité
       de son père.

       En  utilisant  capset(2),  un  processus  peut  manipuler  ses  propres
       ensembles,  ou  s’il  a  la  capacité  CAP_SETPCAP,  celles  d’un autre
       processus.

   Limitation des des capacités
       Quand un programme est exécuté, les capacités effectives et  autorisées
       sont  filtrées  par  un  ET  binaire  avec  la  valeur  en  cours de la
       limitation des capacits, définie dans le fichier /proc/sys/kernel/cap-
       bound.   Ce  paramètre peut servir à fixer une limite au niveau système
       sur  les  capacités  disponibles  pour  tous  les  programmes  exécutés
       ultérieurement.  (Le masque de bits est exprimé comme un nombre décimal
       signé  dans   /proc/sys/kernel/cap-bound,   ce   qui   entretient   les
       confusion).

       Seul  le  processus init peut fixer l’ensemble des limitations ; sinon,
       le  Super-Utilisateur  peut  uniquement  effacer  des  bits  dans   cet
       ensemble.

       Sur  un  système  standard,  la limitation élimine toujours la capacité
       CAP_SETPCAP.  Pour supprimer cette restriction modifiez  la  définition
       de  CAP_INIT_EFF_SET  dans  include/linux/capability.h et recompilez le
       noyau.

   Implémentations actuelle et à venir
       Une implémentation complète des capacités réclame :

       1.     que pour toutes les opérations privilégiées,  le  noyau  vérifie
              que  le  processus  dispose  de  la capacité nécessaire dans son
              ensemble effectif.

       2.     que le noyau fournisse un appel-système permettant de changer et
              récupérer les ensembles de capacités d’un processus.

       3.     le  support  du  système de fichiers pour attacher des capacités
              aux fichiers exécutables, pour qu’un  processus  en  dispose  en
              lançant le programme.

       Sous Linux 2.4.20, seules les deux premières clauses sont remplies.

       Il  pourrait  même être possible d’associer trois ensembles de capacité
       avec un fichier exécutable, lesquels, en conjonction avec les ensembles
       de  capacité  du  procesus, déterminera les capacités dont un processus
       disposera après un exec :

       Autoris :
              ce ensemble est combiné par un ET avec l’ensemble  héritable  du
              processus  pour  savoir  quelles capacités seront héritées après
              l’appel exec().

       Forc :
              les capacités automatiquement fournies  au  processus,  quelques
              soient ses capacités héritables.

       Effectif :
              les  capacités  qui  du  nouvel  ensemble  autorisé seront aussi
              placées dans l’ensemble effectif.  (F(effectif) est  normalement
              entièrement composé de zéros ou de uns).

       En  attendant,  comme  l’implémentation  actuelle  ne  supporte pas les
       ensemble de capacités sur les fichiers, au cours d’un exec :

       1.     Les trois ensembles du fichier sont supposés vides.

       2.     Si on exécute un programme Set-UID root, ou si  l’UID  réel  est
              nul,  alors  les  ensembles  Forcé  et  Autorisé du fichier sont
              remplis de uns (toutes les capacités activées).

       3.     Si un programme  Set-UID  root  est  exécuté,  alors  l’ensemble
              effectif du fichier est rempli avec des uns.

       Durant un exec(), le noyau calcule les nouvelles capacités du processus
       en utilisant l’algorithme suivant :

           P’(autorisé) = (P(héritable) & F(autorisé) | (F(forcé) & cap_bset)

           P’(effectif) = P’(autorisé) & F(effectif)

           P’(héritable) = P(héritable)    [inchangé]

       avec :

       P         indique la valeur d’une capacité du processus avant le exec()

       P’        indique la valeur d’une capacité du processus après le exec()

       F         indique la valeur d’une capacité du fichier

       cap_bset  est la valeur de la limitation de capacité.

NOTES

       Le paquet libcap fournit un ensemble de routines pour  écrire  et  lire
       les   capacités  d’un  processus,  de  manière  plus  simple  et  moins
       susceptible  de  changer  que  l’interface  fournie  par  capset(2)  et
       capget(2).

CONFORMITÉ

       Il   n’y   a  pas  de  véritable  standard  pour  les  capacités,  mais
       l’implémentation Linux est basé sur une interprétation du projet  POSIX
       1003.1e.

BOGUES

       Il  n’y  a pas encore de support dans le système de fichiers permettant
       d’associer les capacités et les fichiers exécutables.

VOIR AUSSI

       capget(2), prctl(2)

TRADUCTION

       Christophe Blaess, 2003.