ID di gruppo GID, attuali, primari, supplementari, effettivi e reali?


22

I seguenti collegamenti discutono questi concetti in diversi contesti. Ho letto le loro definizioni, ma non riesco ancora a capire come siano correlate o se alcune di esse sono uguali.

Ecco un esempio della fonte della mia confusione:

Secondo man id, se scrivo id, dovrei ottenere quelli che chiamano ID di gruppo effettivi e reali .

id uid=501(joe) gid=501(joe) groups=501(joe), 100(users)

Tuttavia, Wikipedia si riferisce all'output di iddistinguere tra ID primari e supplementari . Inoltre, Wikipedia distingue tra ID di gruppo primari vs supplementari ed effettivi vs reali . In che modo questi concetti si relazionano tra loro?

Inoltre, è vero che ID gruppo primario = ID gruppo = ID gruppo corrente ?


La domanda non è chiara: i collegamenti forniti forniscono molte informazioni. Che ne dici non capisci?
psusi,

Risposte:


24

Mescoli due distinzioni diverse qui:

  1. Tra ID di gruppo reali ed effettivi
  2. Tra gruppi di utenti primari e supplementari

La prima distinzione si riferisce a come vengono eseguiti i processi . Normalmente, quando si esegue un comando / programma, viene eseguito con i privilegi dell'utente. Ha l' ID gruppo reale uguale al gruppo principale dell'utente. Questo può essere modificato da un processo al fine di eseguire alcune attività come membro di un altro gruppo speciale. Per fare ciò, i programmi usano la setgidfunzione che modifica il loro ID di gruppo effettivo .

La seconda distinzione si riferisce agli utenti . Ogni utente ha il suo gruppo principale . Ne esiste solo uno per utente e viene definito gid nell'output del idcomando. A parte questo, ogni utente può appartenere a un numero di gruppi supplementari - e questi sono elencati alla fine iddell'output.

[Modificare] :

Concordo sul fatto che la manpage per idsia in qualche modo fuorviante qui. Probabilmente è perché è una versione ridotta della descrizione fornita dal documento informativo. Per vederlo più chiaramente, esegui info coreutils "id invocation"(come suggerito alla fine del idmanuale).


Grazie @rozcietrzewiacz. È stato molto utile. Posso quindi presumere che l' ID gruppo corrente = gruppo primario ?
Amelio Vazquez-Reina,

1
In generale, no. L'attuale gruppo "reale" può essere modificato usando il newgrpcomando - vedi il secondo paragrafo del manuale nel tuo primo link!
rozcietrzewiacz,

18

La vista del kernel

Concettualmente, ci sono tre gruppi di gruppi di cui fa parte un processo. Ogni set è un sottoinsieme di quello seguente.

  1. Il singolo gruppo che è il gruppo predefinito del processo, a cui apparterranno i file creati da questo processo.
  2. L'insieme di gruppi che vengono controllati quando il gruppo richiede l'autorizzazione per aprire un file.
  3. L'insieme di gruppi su cui può attingere un processo in esecuzione con un processo con privilegi aggiuntivi.

Per motivi storici, questi set sono rispettivamente:

  1. l' ID gruppo effettivo (egid);
  2. l'ID gruppo effettivo più gli ID gruppo supplementari ;
  3. tutto quanto sopra, più l' ID gruppo reale e l' ID set-gruppo salvato .

Normalmente, un programma ha un singolo ID utente. Se l'eseguibile ha il bit della modalità setuid impostato, il programma ha due ID utente: il suo ID utente effettivo è quello che conta per le autorizzazioni dei file, i limiti per utente, determinando se il processo è in esecuzione come root e così via. Il processo può passare dall'ID utente effettivo a quello reale, se non ha bisogno dei suoi privilegi extra in ogni momento o se deve passare da due utenti non root.

Lo stesso meccanismo esiste per il gruppo. Per i gruppi, esiste una funzionalità aggiuntiva che non esisteva al momento della progettazione del sistema: un processo può essere membro di un numero qualsiasi di gruppi; questi sono gli ID di gruppo supplementari.

La vista del database utente

Una volta autenticato un utente, il processo di accesso passa a quell'utente, appena prima di avviare la shell dell'utente (o qualsiasi programma richiesto dall'utente). Poco prima di passare all'utente desiderato (e perdere i privilegi di root), il processo di accesso passa ai gruppi desiderati.

Nelle prime versioni di unix, un processo poteva essere solo in un singolo gruppo. Questo gruppo è l'ID del gruppo principale dell'utente, memorizzato nel database dell'utente (in genere /etc/passwd). Questo gruppo diventa l'ID gruppo reale ed effettivo della shell o di altri programmi avviati dal processo di accesso.

Al giorno d'oggi, un processo può essere in più gruppi, quindi anche gli utenti possono essere in più gruppi. Il database del gruppo (in genere /etc/group) contiene un elenco di utenti per ciascun gruppo. Questi gruppi diventano ID di gruppo supplementari per il programma avviato dal processo di accesso.


Grazie. Ho alcune domande per capire la tua risposta. unix.stackexchange.com/questions/466742/…
Tim

1

Molte altre eccellenti risposte qui, ma se sei ancora confuso com'ero, ecco un altro approccio. Si prega di notare che sono solo uno studente di queste cose, non un maestro , quindi questa risposta è un lavoro in corso e non deve essere considerata una risposta solida, almeno non ancora. Considera questa risposta v0.2.

I gruppi sono semplici e complessi allo stesso tempo.

Chiave per gli ID utilizzati di seguito:

KEY  Full name --------  Description---------------------------------------------

 u   User                 uID = User  ID (a unique # associated with each user)
 g   Group                gID = Group ID (a unique # associated with each group)
                            While each /etc/passwd entry has one uID and one gID,
                            additional gIDs can be associated with a users via
                            /etc/group.


 L   Login          IDs - uID and gID produced from the Login process.  
                            ('L' is not exactly standard Linux terminology, but
                            useful for explanations below.)

 F   File           IDs - uID and gID retrieved from a file's ownership.
                            ('F' is not exactly standard Linux terminology, but
                            useful for explanations below.)


 R   Real           IDs - Who actually                      runs a process 
 E   Effective      IDs - Who spoofed via setuid or setgid, runs a process
 O   Original Eff.  IDs - Place to save the original Effective ID when changing 
                          it (e.g. temporarily downgrading it) so can later 
                          restore it.  Also called "Saved ID"; (but 'S' was not 
                          used for here to help avoid confusion with the 'S' in  
                          'SetUserID' & SetGroupID.)
 +   Supplimentary gIDs - Optional, additional groups (none or more) running 
                          this process which can be used to test for permissions.

Nomi ID utente e gruppo:

Category          USER  GROUP  Notes  
----------------- ----  -----  -------------------------------------------  
 From login:      LuID  LgID   From /etc/passwd lookup

 From files:      FuID  FgID   Each file has these. Set by creator process.


 For each running process:

            Real  RuID  RgID   Actual   user starting the program
       Effective  EuID  EgID   Assigned user starting the program*
           Saved  OuID  OgID   Saves original effective ID.
   Supplementary        +gID1  (optional, additional groups)
                        +gID2     
                         ...  

Come i processi acquisiscono gli ID:

1) Login autentica username e ritorna LuIDe LgIDda /etc/passwd.

2) Il primo processo imposta efficace = reale = login, cioè

EuID=RuID=LuID 
EgID=RgID=LgID

3) i bambini a forcella ereditare RuID, EuID, RgID, e EgID, (e forse salvato e supp), tuttavia,

  • Se i bit dell'id u sono impostati sul file del nuovo programma da eseguire, impostare in modo efficace dal file:

    EUID = fuid

  • Se i bit di s g id sono impostati sul file del nuovo programma da eseguire, impostare in modo efficace dal file:

    Egid = FGID

Nota: si applicano anche le opzioni di montaggio suid e nosuid del filesystem sottostante .

4a) Se è stato usato s u id per impostarlo EuID, EuIDpuò essere temporaneamente modificato (ad es. Declassato da root), ma prima viene salvato il suo valore originale in OuIDmodo da poterlo ripristinare in seguito, se lo si desidera.

4b) Se è stato usato s g id per impostarlo EgID, EgIDpuò essere temporaneamente modificato (ad es. Declassato da root), ma prima viene salvato il suo valore originale in OgIDmodo da poterlo ripristinare in seguito, se lo si desidera.


Quando si deve creare un file:

File's new id's are set from effective id's: FuID=EuID and FgID=EgID
(Permissions are set from umask.)

Per aprire per la lettura:

If FuID = EuID  and  user-read bit is set, or  
If FgID = EgID  and group-read bit is set, or  
If FgID = +gID1 and group-read bit is set, or  
If FgID = +gID2 and group-read bit is set, ...  
then allow reading.

Per aprire per la scrittura:

(Same as above but write bit set to allow writing.)

Per aprire per l'esecuzione:

(Same as above but execute bit set to allow execution.)

Quando è necessario inviare un messaggio:

Use RuID and RgID.  (Not EuID or EgID). *(Not sure where I read this.)*

Riferimenti: credenziali uomo

Extra: ecco un'utilità per stampare in modo grazioso il tuo file / etc / group:

cat /etc/group | sort -t: -k3n | awk  -F ':' \
  'BEGIN{printf "\n%-20s %-3s %-8s %s", \
           "Group name","pw", "Group ID ", "User list"}\
   BEGIN{printf "\n%-20s %-3s %-8s %s\n", \
           "----------","--", "---------", "---------"} \
        { printf "%-20s %-3s %8d %s\n", $1, $2, $3, $4 }'
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.