¿Cuándo usar pkexec vs. gksu / gksudo?

Hay dos formas generales de ejecutar aplicaciones gráficamente como root (o, más generalmente, como otro usuario). Programas como gksu, gksudoy kdesudoson interfaces gráficas para sudo. Por el contrario, pkexeces una interfaz gráfica para PolicyKit .

Cuando se ejecutan programas manualmente como root (o como otro usuario no root), ¿cuáles son las ventajas / desventajas (si las hay) de usar pkexec, en comparación con el método más tradicional de usar una sudointerfaz de usuario ?

PolicyKit es más configurable, aunque pkexecno hace uso de esta configurabilidad. Además, pkexecmuestre al usuario la ruta completa del programa que se iniciará, para que el usuario esté un poco más seguro de lo que sucederá. Las llamadas 'políticas' de PolicyKit se pueden usar para establecer configuraciones más avanzadas. Por ejemplo, si se debe recordar la contraseña.

Algo que obtuve del pkexecmanual:

El entorno en el que PROGRAM lo ejecutará se establecerá en un entorno mínimo conocido y seguro para evitar inyectar código a través de LD_LIBRARY_PATH o mecanismos similares. Además, la variable de entorno PKEXEC_UID se establece en el ID de usuario del proceso que invoca pkexec. Como resultado, pkexec no le permitirá ejecutar, por ejemplo, aplicaciones X11 como otro usuario ya que la variable de entorno $ DISPLAY no está configurada.

Más información sobre políticas o definiciones de acciones del pkexecmanual:

   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).

Con sudo puede establecer políticas por usuario y por programa sobre si desea retener o restablecer el entorno de las personas que llaman en el contexto de sudo. La política env_reset se establece de manera predeterminada.

No puede ejecutar aplicaciones gráficas a través de pkexec sin configurarlo explícitamente para hacerlo. Debido a que esto es simplemente el resultado del reinicio del entorno, esto obviamente también es cierto para sudo. Sin embargo, tenga en cuenta que ni pkexec ni sudo pueden evitar que una aplicación maliciosa se ejecute como root para recuperar toda la información necesaria de los administradores de visualización o del archivo X11-cookie de los usuarios. Esto último, tanto o similar, incluso puede ser realizado por aplicaciones no root, dependiendo de las circunstancias.

Sudo no requiere listados explícitos de usuarios. Se puede enumerar cualquier grupo de usuarios o incluso establecer un permiso para todos los usuarios en general. La directiva target_pw permite que esos usuarios se autentiquen con las credenciales del usuario en cuyo contexto desean ejecutar una aplicación, es decir, root. Aparte de eso, el programa igualmente tradicional su (su / gtksu / kdesu) puede usarse para hacer lo mismo sin una configuración especial.

sudo también permite que el usuario permanezca autenticado por un tiempo específico. La opción se denomina tiempo de espera, configurable globalmente, por usuario o por aplicación. La autenticación se puede retener por tty o globalmente por usuario.

Si bien pkexec puede no validar los ARGUMENTOS pasados ​​a PROGRAM, sudo sí tiene esta característica. Sin embargo, admitido, puede equivocarse fácilmente con esto, y normalmente no se hace.

Puede modificar un poco cómo desea que los programas se ejecuten a través de pkexec: icono, texto para mostrar, incluso puede tener cosas de localización y todo eso. Dependiendo de las circunstancias, esto puede ser ingenioso. Sin embargo, es triste que alguien sintiera la necesidad de reinventar la rueda para esta función. Esto probablemente sería algo para poner en los contenedores gráficos gtksudo / kdesu.

Policykit es solo un marco de configuración centralizado entonces. Lamentablemente no es bonita. Los archivos XML de PK son mucho más complicados que cualquier cosa que una aplicación pueda proporcionar de forma nativa sin archivos binarios. Y nadie estaría tan loco para usar binario ... oh gconf ... no importa.

Algunas cosas en las que pkexeces diferente sudoy sus interfaces:

1. No puede ejecutar aplicaciones gráficas pkexecsin configurarlo explícitamente para hacerlo.
2. Puede modificar un poco cómo desea que se ejecuten los programas pkexec: icono, texto para mostrar, si recordar la contraseña o no, si permitir que se ejecute gráficamente y algo más.
3. Cualquiera puede ejecutar "Ejecutar como" un superusuario (siempre que pueda autenticarse como tal), con sudolo que debe aparecer en el sudoersarchivo como administrador .
4. gksudobloquea el teclado, el mouse y el foco cuando solicita una contraseña, pkexecno lo hace. Sin embargo, en ambos casos, las pulsaciones de teclas son sniffable .
5. Con pkexecusted trabaje en un ambiente un poco más desinfectado.

Prueba por ejemplo:

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