Quando usare pkexec vs. gksu / gksudo?

Esistono due modi generali per eseguire graficamente le applicazioni come root (o, più in generale, come un altro utente). Programmi come gksu, gksudoe kdesudosono frontend grafici per sudo. Al contrario, pkexecè un frontend grafico per PolicyKit .

Quando si eseguono manualmente programmi come root (o come un altro utente non root), quali sono i vantaggi / gli svantaggi (se presenti) dell'utilizzo pkexec, rispetto al metodo più tradizionale di utilizzare un sudofrontend?

PolicyKit è più configurabile, sebbene pkexecnon faccia uso di questa configurabilità. Inoltre, pkexecmostra all'utente l'intero percorso del programma che verrà avviato, in modo che l'utente sia un po 'più sicuro di ciò che accadrà. Le cosiddette "politiche" di PolicyKit possono essere utilizzate per impostare più impostazioni di avanzamento. Ad esempio, se la password deve essere ricordata.

Qualcosa che ho preso dal pkexecmanuale:

L'ambiente in cui PROGRAM lo eseguirà verrà impostato su un ambiente minimo noto e sicuro per evitare l'iniezione di codice tramite LD_LIBRARY_PATH o meccanismi simili. Inoltre, la variabile di ambiente PKEXEC_UID è impostata sull'ID utente del processo che richiama pkexec. Di conseguenza, pkexec non consente di eseguire ad es. Applicazioni X11 come un altro utente poiché la variabile di ambiente $ DISPLAY non è impostata.

Maggiori informazioni su politiche o definizioni di azioni dal pkexecmanuale:

   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 è possibile impostare i criteri per utente e per programma su wether per conservare o ripristinare l'ambiente dei chiamanti nel contesto di sudo. La politica env_reset è impostata per impostazione predefinita.

Non è possibile eseguire applicazioni grafiche tramite pkexec senza configurarlo esplicitamente per farlo. Poiché questo è semplicemente il risultato del ripristino dell'ambiente, questo è ovviamente vero anche per sudo. Si noti tuttavia che né pkexec né sudo possono impedire a un'applicazione malevola in esecuzione come root di recuperare tutte le informazioni necessarie dai display manager o dal file X11-cookie degli utenti. Quest'ultimo, sia o simile, può anche essere fatto da applicazioni non root a seconda delle circostanze.

Sudo non richiede elenchi espliciti di utenti. È possibile elencare qualsiasi gruppo di utenti o anche impostare un'autorizzazione per tutti gli utenti in generale. La direttiva target_pw consente a quegli utenti di autenticarsi con le credenziali dell'utente nel contesto in cui desiderano eseguire un'applicazione, ad esempio root. A parte questo, il altrettanto tradizionale programma su (su / gtksu / kdesu) può essere usato per fare lo stesso senza una configurazione speciale.

anche sudo consente all'utente di rimanere autenticato per un periodo di tempo specificato. L'opzione è denominata timeout, configurabile a livello globale, per utente o per applicazione. L'autenticazione può essere mantenuta per tty o globalmente per utente.

Mentre pkexec potrebbe non eseguire la convalida degli ARGUMENTI passati a PROGRAM, sudo ha effettivamente questa funzione. Ammesso però, puoi facilmente sbagliare con questo, e normalmente non è fatto.

Puoi modificare un po 'come vuoi che i programmi vengano eseguiti tramite pkexec: icona, testo da visualizzare, puoi persino avere cose di localizzazione e tutto il resto. A seconda delle circostanze, ciò può essere davvero intelligente. Purtroppo però, qualcuno ha sentito il bisogno di reinventare la ruota per questa funzione. Questo sarebbe probabilmente qualcosa da mettere nei wrapper grafici gtksudo / kdesu.

Policykit è quindi solo un framework di configurazione centralizzato. Purtroppo non è carino. I file XML di PK sono molto più complicati di qualsiasi cosa un'app possa fornire nativamente a corto di file binari. E nessuno sarebbe così sciocco da usare il binario ... oh gconf ... non importa.

Alcune cose in che cosa pkexecè diverso sudoe dai suoi frontend:

1. Non è possibile eseguire applicazioni grafiche pkexecsenza configurarlo esplicitamente per farlo.
2. Puoi modificare un po 'come vuoi che i programmi vengano eseguiti tramite pkexec: icona, testo da visualizzare, se ricordare la password o meno, se permetterne l'esecuzione grafica e altro ancora.
3. Chiunque può eseguire "Esegui come" un superutente (a condizione che possano eseguire l'autenticazione in quanto tale), sudopertanto è necessario essere elencati nel sudoersfile come admin .
4. gksudoblocca la tastiera, il mouse e lo stato attivo quando si richiede una password, pkexecno. In entrambi i casi i tasti sono comunque sniffabili .
5. Con pkexecte lavori in un ambiente leggermente più igienizzato.

Prova ad esempio:

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