GID, aktuelle, primäre, ergänzende, effektive und echte Gruppen-IDs?

Die folgenden Links erläutern diese Konzepte in verschiedenen Kontexten. Ich habe ihre Definitionen gelesen, kann aber immer noch nicht sagen, wie sie zusammenhängen oder ob einige von ihnen gleich sind.

• Aktuelle Gruppen-ID
• Gruppen-ID
• Primäre und ergänzende Gruppen-IDs
• Effektive und echte Gruppen-IDs (auch auf Wikipedia )

Hier ist ein Beispiel für die Quelle meiner Verwirrung:

Laut man id, wenn ich tippe id, sollte ich bekommen, was sie effektive und echte Gruppen-IDs nennen.

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

Jedoch Wikipedia bezieht sich auf die Ausgabe der idunterscheiden zwischen primären und ergänzenden IDs. Darüber hinaus unterscheidet Wikipedia zwischen primären vs Zusatz und wirksam gegen reale Gruppen - IDs. Wie hängen diese Konzepte zusammen?

Stimmt es auch, dass die primäre Gruppen-ID = Gruppen-ID = aktuelle Gruppen-ID ist?

Sie mischen hier zwei verschiedene Unterscheidungen:

1. Zwischen echten und effektiven Gruppen-IDs
2. Zwischen primären und ergänzenden Benutzergruppen

Die erste Unterscheidung bezieht sich darauf, wie Prozesse ausgeführt werden . Normalerweise wird ein Befehl / Programm mit den Rechten Ihres Benutzers ausgeführt. Die tatsächliche Gruppen-ID entspricht der primären Gruppe Ihres Benutzers. Dies kann durch einen Prozess geändert werden, um einige Aufgaben als Mitglied einer anderen speziellen Gruppe auszuführen. Dazu verwenden Programme die setgidFunktion, die ihre effektive Gruppen-ID ändert .

Die zweite Unterscheidung bezieht sich auf Benutzer . Jeder Benutzer hat seine / ihre primäre Gruppe . Es gibt nur einen pro Benutzer und wird in der Ausgabe des Befehls als gid bezeichnetid . Ansonsten kann jeder Benutzer einer Reihe von Zusatzgruppen angehören - diese werden am Ende der idAusgabe aufgelistet .

[Bearbeiten]:

Ich bin damit einverstanden, dass die Manpage für idhier etwas irreführend ist. Dies liegt wahrscheinlich daran, dass es sich um eine abgespeckte Version der Beschreibung handelt, die im Infodokument bereitgestellt wird. Führen Sie den Befehl aus info coreutils "id invocation"(wie am Ende des idHandbuchs vorgeschlagen), um ihn deutlicher anzuzeigen.

Die Kernel-Ansicht

Konzeptionell gibt es drei Gruppen, zu denen ein Prozess gehört. Jede Menge ist eine Teilmenge der folgenden.

1. Die einzelne Gruppe, die die Standardgruppe des Prozesses ist, zu der die von diesem Prozess erstellten Dateien gehören.
2. Die Gruppe von Gruppen, die überprüft werden, wenn die Gruppe die Berechtigung zum Öffnen einer Datei benötigt.
3. Die Gruppe von Gruppen, auf die sich ein Prozess stützen kann, der mit zusätzlichen Berechtigungen ausgeführt wird.

Aus historischen Gründen sind diese Sätze jeweils:

1. die effektive Gruppen-ID (egid);
2. die effektive Gruppen-ID plus die zusätzlichen Gruppen-IDs ;
3. alles zusammen mit der realen Gruppen-ID und der gespeicherten Set-Gruppen-ID .

Normalerweise hat ein Programm eine einzelne Benutzer-ID. Wenn für die ausführbare Datei das Setuid- Modus-Bit gesetzt ist, verfügt das Programm über zwei Benutzer-IDs: Die effektive Benutzer-ID ist diejenige, die für Dateiberechtigungen und Benutzerbegrenzungen von Bedeutung ist und bestimmt, ob der Prozess als Root ausgeführt wird und so weiter. Der Prozess kann zwischen der effektiven und der realen Benutzer-ID wechseln, wenn er nicht ständig seine zusätzlichen Berechtigungen benötigt oder wenn er zwischen zwei Nicht-Root-Benutzern wechseln muss.

Der gleiche Mechanismus existiert für die Gruppe. Für Gruppen gibt es eine zusätzliche Funktion, die bei der Entwicklung des Systems nicht vorhanden war: Ein Prozess kann Mitglied einer beliebigen Anzahl von Gruppen sein. Dies sind die zusätzlichen Gruppen-IDs.

Die Benutzerdatenbankansicht

Sobald ein Benutzer authentifiziert ist, wechselt der Anmeldevorgang zu diesem Benutzer, kurz bevor die Shell des Benutzers (oder das vom Benutzer angeforderte Programm) gestartet wird. Kurz vor dem Wechsel zum gewünschten Benutzer (und dem Verlust der Root-Rechte) wechselt der Anmeldevorgang zu den gewünschten Gruppen.

In früheren Unix-Versionen konnte sich ein Prozess nur in einer einzelnen Gruppe befinden. Diese Gruppe ist die primäre Gruppen-ID des Benutzers, die (normalerweise /etc/passwd) in der Benutzerdatenbank gespeichert ist . Diese Gruppe wird zur tatsächlichen und effektiven Gruppen-ID der Shell oder eines anderen Programms, die durch den Anmeldevorgang gestartet werden.

Heutzutage kann ein Prozess mehreren Gruppen angehören, sodass Benutzer auch mehreren Gruppen angehören können. Die Gruppendatenbank /etc/groupenthält (normalerweise ) eine Liste von Benutzern für jede Gruppe. Diese Gruppen werden zu zusätzlichen Gruppen-IDs für das Programm, das durch den Anmeldevorgang gestartet wird.

Viele andere ausgezeichnete Antworten hier, aber wenn Sie immer noch verwirrt sind wie ich, hier ist ein anderer Ansatz. Bitte beachte, dass ich nur ein Schüler dieses Stoffes bin, kein Meister , daher ist diese Antwort noch in Arbeit und nicht als solide Antwort zu betrachten, zumindest noch nicht. Betrachten Sie diese Antwort v0.2.

Gruppen sind einfach und komplex zugleich.

Schlüssel zu den unten verwendeten IDs:

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.

Benutzer- und Gruppen-ID-Namen:

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

Wie Prozesse IDs erhalten:

1) Login authentifiziert den Benutzernamen und kehrt zurück LuIDund LgIDvon /etc/passwd.

2) Der erste Prozess richtet effektiv = real = login ein, dh

EuID=RuID=LuID 
EgID=RgID=LgID

3) Gespaltene Kinder vererben RuID, EuID, RgID, und EgID, (& möglicherweise gerettet & supp), jedoch

• Wenn in der Datei des neuen Programms, das ausgeführt werden soll, das (die) s U ID-Bit ( s U ID-Bit ( s U ID-Bit) gesetzt ist (sind), wird dies ab Datei wirksam:

  EuID = FuID

• Wenn das s g id-Bit ( s g id-Bit) in der Datei des auszuführenden neuen Programms gesetzt ist, wird es ab Datei wirksam gesetzt:

  EgID = FgID

Hinweis: Die suid- und nosuid- Mount-Optionen des zugrunde liegenden Dateisystems gelten ebenfalls.

4a) Wenn s u id wurde verwendet , um eingestellte EuID, dann EuIDkann vorübergehend geändert werden (zB von der Wurzel degradiert), aber es ist erster ursprünglicher Wert in gespeichert wird , OuIDso kann er später gestellt werden , falls gewünscht.

4b) Wurde für die Einstellung s g id verwendetEgID , EgIDkann dies vorübergehend geändert werden (z. B. ein Downgrade von root), aber zuerst wird der ursprüngliche Wert gespeichert, OgIDdamit er bei Bedarf später wiederhergestellt werden kann.

Wenn eine Datei erstellt werden soll:

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

Zum Lesen öffnen:

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.

Zum Schreiben öffnen:

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

Zur Ausführung öffnen:

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

Wenn eine Nachricht gesendet werden muss:

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

Referenzen: Mannausweise

Extra: Hier ist ein Hilfsprogramm, um Ihre / etc / group-Datei hübsch zu drucken:

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 }'