Question Quand utiliser pkexec vs gksu / gksudo?


Il existe deux manières générales d'exécuter les applications graphiquement en tant que root (ou, plus généralement, en tant qu'utilisateur différent). Des programmes comme gksu, gksudo, et kdesudo sont des interfaces graphiques pour sudo. En revanche, pkexec est une interface graphique pour PolicyKit.

Quand manuellement exécuter des programmes en tant que root (ou autre utilisateur non root), quels sont les avantages / inconvénients (le cas échéant) de pkexec, par rapport à la méthode plus traditionnelle d’utilisation d’un sudo l'extrémité avant?


73
2017-11-11 20:44


origine


Voir également Pourquoi gksu n'est-il plus installé par défaut? (dans 13.04 Raring) - nealmcb
En relation: askubuntu.com/questions/252962/… - Mechanical snail
En relation (mais pas en double): Est-ce que sudo -i est moins sécurisé que pkexec? - Eliah Kagan


Réponses:


PolicyKit est plus configurable, bien que pkexec n'utilise pas cette configurabilité. Aussi, pkexec montrer à l'utilisateur le chemin complet du programme qui sera démarré, pour que l'utilisateur soit un peu plus sûr de ce qui va se passer. Les «politiques» de PolicyKit peuvent être utilisées pour définir davantage de paramètres avancés. Par exemple, si le mot de passe doit être mémorisé.

Quelque chose que j'ai eu de la pkexec Manuel:

L’environnement dans lequel PROGRAM le lancera sera réglé au minimum   environnement connu et sûr afin d'éviter d'injecter du code à travers   LD_LIBRARY_PATH ou des mécanismes similaires. En plus le PKEXEC_UID   la variable d'environnement est définie sur l'ID utilisateur du processus appelant   pkexec. Par conséquent, pkexec ne vous autorisera pas, par exemple, à exécuter X11   applications en tant qu'autre utilisateur depuis la variable d'environnement $ DISPLAY   n'est pas défini

Plus d'informations sur les politiques ou définitions d'action du pkexec Manuel:

   To specify what kind of authorization is needed to execute the program
   /usr/bin/pk-example-frobnicate as another user, simply write an action
   definition file like this

       <?xml version="1.0" encoding="UTF-8"?>
       <!DOCTYPE policyconfig PUBLIC
        "-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN"
        "http://www.freedesktop.org/standards/PolicyKit/1/policyconfig.dtd">
       <policyconfig>

         <vendor>Examples for the PolicyKit Project</vendor>
         <vendor_url>http://hal.freedesktop.org/docs/PolicyKit/</vendor_url>

         <action id="org.freedesktop.policykit.example.pkexec.run-frobnicate">
           <description>Run the PolicyKit example program Frobnicate</description>
           <description xml:lang="da">Kør PolicyKit eksemplet Frobnicate</description>
           <message>Authentication is required to run the PolicyKit example program Frobnicate</message>
           <message xml:lang="da">Autorisering er påkrævet for at afvikle PolicyKit eksemplet Frobnicate</message>
           <icon_name>audio-x-generic</icon_name>
           <defaults>
             <allow_any>no</allow_any>
             <allow_inactive>no</allow_inactive>
             <allow_active>auth_self_keep</allow_active>
           </defaults>
           <annotate key="org.freedesktop.policykit.exec.path">/usr/bin/pk-example-frobnicate</annotate>
         </action>

       </policyconfig>

   and drop it in the /usr/share/polkit-1/actions directory under a
   suitable name (e.g. matching the namespace of the action). Note that in
   addition to specifying the program, the authentication message,
   description, icon and defaults can be specified. For example, for the
   action defined above, the following authentication dialog will be
   shown:

       [IMAGE][2]

           +----------------------------------------------------------+
           |                     Authenticate                     [X] |
           +----------------------------------------------------------+
           |                                                          |
           |  [Icon]  Authentication is required to run the PolicyKit |
           |          example program Frobnicate                      |
           |                                                          |
           |          An application is attempting to perform an      |
           |          action that requires privileges. Authentication |
           |          is required to perform this action.             |
           |                                                          |
           |          Password: [__________________________________]  |
           |                                                          |
           | [V] Details:                                             |
           |  Command: /usr/bin/pk-example-frobnicate                 |
           |  Run As:  Super User (root)                              |
           |  Action:  org.fd.pk.example.pkexec.run-frobnicate        |
           |  Vendor:  Examples for the PolicyKit Project             |
           |                                                          |
           |                                  [Cancel] [Authenticate] |
           +----------------------------------------------------------+

   If the user is using the da_DK locale, the dialog looks like this:

       [IMAGE][3]

           +----------------------------------------------------------+
           |                     Autorisering                     [X] |
           +----------------------------------------------------------+
           |                                                          |
           |  [Icon]  Autorisering er påkrævet for at afvikle         |
           |          PolicyKit eksemplet Frobnicate                  |
           |                                                          |
           |          Et program forsøger at udføre en handling der   |
           |          kræver privilegier. Autorisering er påkrævet.   |
           |                                                          |
           |          Kodeord: [___________________________________]  |
           |                                                          |
           | [V] Detaljer:                                            |
           |  Bruger:   Super User (root)                             |
           |  Program:  /usr/bin/pk-example-frobnicate                |
           |  Handling: org.fd.pk.example.pkexec.run-frobnicate       |
           |  Vendor:   Examples for the PolicyKit Project            |
           |                                                          |
           |                                [Annullér] [Autorisering] |
           +----------------------------------------------------------+

   Note that pkexec does no validation of the ARGUMENTS passed to PROGRAM.
   In the normal case (where administrator authentication is required
   every time pkexec is used), this is not a problem since if the user is
   an administrator he might as well just run pkexec bash to get root.

   However, if an action is used for which the user can retain
   authorization (or if the user is implicitly authorized), such as with
   pk-example-frobnicate above, this could be a security hole. Therefore,
   as a rule of thumb, programs for which the default required
   authorization is changed, should never implicitly trust user input
   (e.g. like any other well-written suid program).

25
2017-11-12 15:35



Je suppose que j'aurais dû dire il y en a deux pour exécuter des applications en tant que root avec authentification graphique. J'avais supposé qu'il y avait un moyen d'utiliser pkexec pour exécuter des applications graphiques (je ne l'avais jamais fait ...). Votre réponse explique pourquoi il n'y en a pas (ou du moins pourquoi un environnement personnalisé doit être spécifié pour le faire). - Eliah Kagan
J'ai cependant une question sur votre réponse: lorsqu'un programme est exécuté en tant que root avec pkexec, dans quel sens peut-il limiter ses capacités ("permissions")? J'accorde à un programme la possibilité de faire n'importe quoi quand je le lance avec sudo ou un sudo frontend ... dans quel sens exécuter un programme en tant que root avec pkexec pas aussi faire ça? - Eliah Kagan
je comprends que PolicyKit est utilisé pour permettre aux programmes d'exécuter uniquement des types spécifiques d'actions. Mais est-ce que pkexec faciliter cela, ou fait pkexec il suffit de lancer des choses comme root avec des capacités illimitées? le pkexec extrait manuel que vous avez inclus dans vos documents de réponse sur la manière d'écrire des règles pour déterminer qui peut exécuter un programme en tant qu'utilisateur root (ou en tant qu'utilisateur non root), plutôt que ce que le programme peut faire. - Eliah Kagan
Je veux accepter votre réponse, car elle fournit beaucoup de bonnes informations. Mais je pense que c'est très trompeur, car il est dit que pkexec est plus configurable que sudo, et compte tenu de la discussion que nous avons eue ici dans les commentaires, cela ne semble pas être le cas. Envisageriez-vous de modifier votre réponse pour expliquer sudola configurabilité et la comparer / contraster avec pkexec's, ou modifiez votre réponse pour dire que la différence est autre chose que la configurabilité? - Eliah Kagan
"écrivez simplement" et ensuite un morceau de XML. J'avais besoin de rire. - Jürgen A. Erhard


Avec sudo, vous pouvez définir des règles par utilisateur et par programme pour conserver ou réinitialiser l'environnement de l'appelant dans le contexte de sudo. La stratégie env_reset est définie par défaut.

Vous ne pouvez pas exécuter d'applications graphiques via pkexec sans le configurer explicitement. Comme il ne s'agit que d'un résultat de la réinitialisation de l'environnement, cela est également vrai pour sudo. Notez toutefois que ni pkexec ni sudo ne peuvent empêcher une application malveillante exécutée en tant que root de récupérer toutes les informations nécessaires à partir des gestionnaires d'affichage ou du fichier X11-cookie des utilisateurs. Ces dernières, les deux ou similaires, peuvent même être effectuées par des applications non root en fonction des circonstances.

Sudo ne nécessite pas de listes explicites d'utilisateurs. La liste de tout groupe d'utilisateurs ou même la définition d'une autorisation pour tous les utilisateurs en général peut être effectuée. La directive target_pw permet aux utilisateurs de s'authentifier avec les informations d'identification de l'utilisateur dans le contexte dans lequel ils souhaitent exécuter une application, à savoir root. En dehors de cela, le programme su (su / gtksu / kdesu) tout aussi traditionnel peut être utilisé pour faire la même chose sans configuration spéciale.

sudo permet également à l'utilisateur de rester authentifié pendant une durée déterminée. L'option est nommée timeout, configurable globalement, par utilisateur ou par application. L'authentification peut être conservée par tty ou globalement par utilisateur.

Bien que pkexec ne puisse pas valider les ARGUMENTS transmis à PROGRAM, sudo a bien cette fonctionnalité. Admis cependant, vous pouvez facilement vous gâter avec ceci, et ce n'est normalement pas fait.

Vous pouvez modifier un peu la façon dont vous voulez que les programmes soient exécutés via pkexec: icon, texte à afficher, vous pouvez même avoir des éléments de localisation et tout ça. Selon les circonstances, cela peut être utile. Malheureusement, quelqu'un a ressenti le besoin de réinventer la roue pour cette fonction. Ce serait probablement quelque chose à mettre dans les enveloppes graphiques gtksudo / kdesu.

Policykit n'est alors qu'un cadre de configuration centralisé. Malheureusement pas un joli. PK-Files XML-Files est bien plus compliqué que ce qu'une application pourrait fournir nativement à court de fichiers binaires. Et personne ne serait trop mal pour utiliser le binaire ... oh gconf ... ça ne fait rien.


14
2017-10-26 12:47



J'ai déclassé parce que ce post n'est pas vraiment une réponse, c'est une critique d'une autre réponse. Si vous estimez qu’il est généralement préférable d’utiliser sudo sur pkexec, dites-le en expliquant votre argument avec ces réfutations. - Flimm
Merci Paul, pour beaucoup d'analyses utiles ici! Mais je suis aussi d'accord avec Flimm. Pouvez-vous commencer par une réponse simple à la question posée? - nealmcb
Non, pkexec  pouvez exécuter l'interface graphique sans configurer: askubuntu.com/a/332847/89385 - akostadinov


Quelques choses comment pkexec est différent de sudo et ses frontends:

  1. Vous ne pouvez pas exécuter d'applications graphiques via pkexec sans le configurer explicitement pour le faire.
  2. Vous pouvez modifier un peu comment vous voulez que les programmes soient exécutés via pkexec: icône, texte à afficher, à mémoriser ou non le mot de passe, autoriser son exécution graphique, etc.
  3. N'importe qui peut exécuter "Exécuter en tant que" un superutilisateur (à condition qu'il puisse s'authentifier comme tel), avec sudo vous devez être répertorié dans le sudoers déposer comme admin.
  4. gksudo verrouille le clavier, la souris et la mise au point lorsque vous demandez un mot de passe, pkexec n'est pas Dans les deux cas les frappes sont reniflables si.
  5. Avec pkexec vous travaillez dans un environnement légèrement plus assaini.

Essayez par exemple:

cd /etc/init.d
sudo cat README
# and now the same with pkexec
pkexec cat README
# nice, huh?

8
2017-11-15 22:59



Bon point (# 3) sur la façon dont vous pouvez vous authentifier en tant qu'autres utilisateurs pour exécuter des programmes en tant que root avec pkexec. Est-il configurable, que les utilisateurs peuvent utiliser pkexec du tout (même s'ils connaissent le mot de passe d'un autre utilisateur autorisé à le faire)? su est configurable de cette manière. Quand je tente de su à un autre nonroot utilisateur en tant que guest sur un système onirique, il me dit que je ne suis pas autorisé à le faire. (En revanche, quand j'essaie d'utiliser pkexec comme guest sur Oneiric ou Precise, j'obtiens ce qui ressemble à une erreur d'assertion, que je pourrais bientôt signaler comme un bogue, car je ne devrais pas l'obtenir même si cela n'est pas autorisé.) - Eliah Kagan
Mais sudo et ses frontends peuvent également être modifiés comme décrit au point 2. Vous pouvez exécuter un programme avec gksu ou gksudo  affichage de texte personnalisé, arrêtez d'avoir besoin des mots de passe de certains utilisateurs en éditant /etc/sudoers (avec visudo), et changer la durée de leur mémorisation dans le sens de la modification du délai d’expiration du délai pour sudo (bien que je ne sois pas sûr de savoir comment le faire sur Ubuntu, configuré de manière à déterminer si sudo nécessite un mot de passe, et combien de temps jusqu'à ce qu'il en ait besoin à nouveau, sont spécifiques au terminal). - Eliah Kagan
# 4 n'est pas vrai si vous utilisez GNOME Shell. - muru
Non, pkexec  pouvez exécuter l'interface graphique sans configurer: askubuntu.com/a/332847/89385 - akostadinov