Uživatelé a práva

V Linuxu nikdo nesmí sám od sebe všechno. Každý soubor má vlastníka a sadu pravidel, kdo si ho smí přečíst, změnit nebo spustit. Každý proces běží pod nějakým uživatelem a smí přesně to, co ten uživatel. Tenhle jednoduchý systém — uživatelé, skupiny, práva — je celý základ toho, proč se na Linuxu dá bezpečně provozovat server, na kterém pracuje deset lidí, a nikdo si navzájem nerozbije data. Až to pochopíš, přestane ti „Permission denied" nahánět hrůzu a začneš v něm vidět kamaráda.

Pár pojmů na úvod

• Uživatel (user) = účet, pod kterým něco běží. Nemusí to být člověk — spousta uživatelů jsou „systémoví" a slouží jen k tomu, aby pod nimi jezdily služby (web server, databáze).
• UID = číselné ID uživatele. Systém uvnitř pracuje s čísly, jméno (matej) je jen popiska. UID 0 = root, superuživatel, který smí všechno.
• Skupina (group) = pojmenovaná parta uživatelů. Práva se dají dát celé skupině najednou — třeba skupina docker znamená „smí ovládat Docker". GID = číselné ID skupiny.
• root = superuživatel (UID 0). Obchází všechna práva. Mocný a nebezpečný zároveň.
• Práva (permissions) = tři sady po třech písmenech (rwx) na každém souboru: co smí vlastník, co smí skupina, co smí ostatní.
• sudo = „spusť tenhle jeden příkaz jako root". Tvůj hlavní nástroj, jak dělat správcovské věci bezpečně, aniž bys pod rootem trvale seděl.

Uživatelé a skupiny — kdo je kdo

Každý účet v systému má jméno (pro lidi) a UID (pro systém). Když napíšeš whoami, uvidíš svoje jméno; id ti ukáže i čísla a skupiny, do kterých patříš:

whoami          # matej
id              # uid=1000(matej) gid=1000(matej) groups=1000(matej),10(wheel),984(docker)

Uživatelé se dělí na dva druhy:

• Lidští uživatelé — účty pro skutečné lidi. Mají UID typicky od 1000 výš, domovský adresář (/home/matej) a přihlašovací shell.
• Systémoví uživatelé — účty pro služby, ne pro lidi. Mají UID pod 1000 (např. www-data, postgres, sshd). Nemají heslo pro přihlášení a často ani shell — existují jen proto, aby pod nimi běžely programy s omezenými právy. Kdyby web server běžel pod tvým účtem a někdo ho hacknul, měl by útočník tvoje data. Když běží pod www-data, smí skoro nic.

💡 Proč vůbec skupiny? Představ si, že chceš deseti kolegům povolit přístup ke sdílené složce. Bez skupin bys musel práva nastavit desetkrát a při jedenáctém kolegovi znovu. Se skupinou přidáš člověka do skupiny a hotovo — práva už tam jsou.

Kde to všechno bydlí — tři soubory

Linux si účty a hesla drží v obyčejných textových souborech. Můžeš do nich nahlédnout (cat):

cat /etc/passwd     # seznam uživatelů (KDO existuje)
cat /etc/group      # seznam skupin
sudo cat /etc/shadow  # hesla (zahashovaná) — čitelné jen pro root

/etc/passwd — řádek na uživatele, pole oddělená dvojtečkou. Navzdory jménu tu hesla nejsou:

matej:x:1000:1000:Matej Pospisil:/home/matej:/bin/bash
│     │ │    │    │              │           └ shell (co se spustí po přihlášení)
│     │ │    │    │              └ domovský adresář
│     │ │    │    └ popis (jméno člověka)
│     │ │    └ GID (hlavní skupina)
│     │ └ UID
│     └ „x" = heslo je jinde (v /etc/shadow)
└ přihlašovací jméno

/etc/group — jméno skupiny, GID a seznam členů:

docker:x:984:matej,honza

/etc/shadow — sem se přesunula hesla, a to zahashovaná (ne v čitelné podobě) a soubor smí číst jen root. Hash znamená, že se z uloženého řetězce nedá heslo spočítat zpátky — při přihlášení se jen zahashuje to, co jsi zadal, a porovná se. Proto ani root „nevidí" tvoje heslo, jen jeho otisk.

🚩 Nikdy tyhle soubory needituj ručně v editoru „jen tak". Na přidání uživatele slouží useradd / adduser, na změnu hesla passwd, na skupiny usermod -aG. Ruční překlep v /etc/passwd ti může zavřít přihlášení.

root — superuživatel, a proč pod ním nejezdit

root (UID 0) je účet, který obchází všechna práva. Smaže cokoli, přečte cokoli, změní cokoli. Je potřeba na správu systému: instalace balíčků, úpravy v /etc, ovládání služeb. Ale:

• Nic tě nezastaví. Pod rootem projde i katastrofa: rm -rf /* nebo rm -rf /nejaka-slozka smaže bez milosti. (Holé rm -rf / dnešní rm naštěstí odmítne díky pojistce --preserve-root — ale rm -rf /* už glob rozbalí na /bin /etc /home … a pojistku obejde.) Pod běžným účtem ti to práva nedovolí, a to je záchrana.
• Chyba = katastrofa. Překlep v příkazu, zlomyslný skript, špatně zkopírovaný řádek z internetu — pod rootem má plný dopad.
• Malware taky. Když si omylem spustíš něco škodlivého jako root, dostane klíče od celého stroje.

Proto zlaté pravidlo: běžně pracuj jako obyčejný uživatel a root si „půjč" jen na tu jednu operaci, která ho fakt potřebuje — přes sudo. Je to jako klíče od trezoru: nenosíš je pořád v ruce, vezmeš si je jen na tu chvíli, kdy trezor otevíráš.

sudo vs su — dvě cesty k rootovi

Existují dva způsoby, jak udělat něco s právy roota:

su (switch user) — staneš se rootem a zůstaneš jím, dokud nenapíšeš exit. Celý shell pak běží pod rootem:

su -            # zeptá se na heslo ROOTA, pak jsi root pořád
# ... tady jsi root, každý příkaz je nebezpečný ...
exit            # zpátky na sebe

sudo (superuser do) — spustí jen ten jeden příkaz jako root, pak jsi zase sebou. Ptá se na tvoje heslo (ne rootovo):

sudo dnf install htop     # jen tenhle příkaz jede jako root
htop                      # tohle už zase jako ty

Proč je sudo skoro vždy lepší:

• Granularita — root máš jen na ten jeden příkaz, ne na celou session. Menší okno na chybu.
• Audit — každé použití sudo se zaloguje (kdo, kdy, co spustil). U su víš jen, že se někdo stal rootem; co pak dělal, se ztrácí.
• Žádné sdílené heslo roota — lidé používají svá vlastní hesla. Účet roota může být klidně zamčený (nemá použitelné heslo vůbec), a přesto správci fungují přes sudo.
• Nastavitelnost — v /etc/sudoers (edituj vždy přes visudo, ne ručně!) se dá povolit konkrétnímu uživateli jen konkrétní příkazy. Třeba „smí restartovat web server, ale nic víc".

💡 Kdo smí sudo, řídí členství ve skupině — na Fedoře/RHEL je to wheel, na Debianu/Ubuntu sudo. Přidání: sudo usermod -aG wheel matej (a znovu se přihlásit, aby se skupina projevila).

Práva souborů — jak číst ls -l

Napiš ls -l a u každého souboru uvidíš vlevo shluk písmen a pomlček. To je mapa práv:

ls -l
-rwxr-xr--  1 matej  vyvojari  8461 Jul 12 10:30 skript.sh

Prvních deset znaků rozlož takhle:

Tři písmena v každé skupině vždy znamenají totéž:

Takže -rwxr-xr-- čteš takhle:

• - — je to obyčejný soubor
• rwx — vlastník (matej) smí číst, měnit i spouštět
• r-x — skupina (vyvojari) smí číst a spouštět, ale ne měnit
• r-- — ostatní smí jen číst

🚩 U složek plete x každého začátečníka. r na složce ti dovolí vypsat jména souborů uvnitř, ale x ti dovolí vejít dovnitř a s těmi soubory pracovat. Bez x na složce se do ní nedostaneš, i kdybys měl práva na soubory uvnitř. Nejčastější „proč mě to nepustí do složky" je právě chybějící x.

chmod — měníme práva

chmod (change mode) nastavuje práva. Jdou zadat dvěma způsoby a je dobré umět oba.

Symbolicky — když měníš jednu věc

Řekneš komu (u vlastník, g skupina, o ostatní, a všichni), co (+ přidej, - odeber, = nastav přesně) a které právo (r/w/x):

chmod u+x skript.sh      # vlastníkovi přidej právo spouštět
chmod g-w soubor.txt     # skupině odeber právo zapisovat
chmod o-r tajne.txt      # ostatním zakaž čtení
chmod a+r verejne.txt    # všem povol čtení
chmod u+x,g+x deploy.sh  # víc změn najednou (čárkou)

Číselně — když nastavuješ celá práva naráz

Každé z rwx má svou hodnotu, a ty je sečteš:

r = 4     w = 2     x = 1

Součet dá jednu číslici (0–7) pro každou skupinu. Tři číslice = vlastník, skupina, ostatní:

rwx = 4+2+1 = 7      (čti, zapiš, spusť)
r-x = 4+0+1 = 5      (čti, spusť)
r-- = 4+0+0 = 4      (jen čti)
rw- = 4+2+0 = 6      (čti, zapiš)

Nejčastější kombinace, které si zapamatuj:

chmod 755 skript.sh      # rwxr-xr-x — vlastník vše, ostatní čtou+spouští (skripty, programy)
chmod 644 dokument.txt   # rw-r--r-- — vlastník čte+píše, ostatní jen čtou (běžné soubory)
chmod 600 klic.pem       # rw------- — jen vlastník, nikdo jiný (privátní klíče, hesla)
chmod 700 slozka         # rwx------ — do složky smím jen já

💡 755 vs 644: rozdíl je jen v tom x. Skript, který chceš spouštět, potřebuje 755 (nebo aspoň u+x). Obyčejný textový soubor x nepotřebuje a 644 mu úplně stačí.

chown a chgrp — kdo soubor vlastní

Práva říkají „co smí vlastník/skupina/ostatní". Ale kdo je ten vlastník a která skupina? To měníš zvlášť:

sudo chown honza soubor.txt          # vlastníkem bude honza
sudo chgrp vyvojari soubor.txt       # skupina bude vyvojari
sudo chown honza:vyvojari soubor.txt # obojí naráz (vlastník:skupina)
sudo chown -R matej:matej ~/projekt  # -R = rekurzivně, celý strom složek

Změna vlastníka většinou potřebuje sudo — nemůžeš „darovat" soubor někomu jinému a tím obejít účtování.

umask — jaká práva dostanou nové soubory

Když vytvoříš nový soubor, odkud se vezmou jeho práva? Ze základu, ze kterého umask vypne některé bity. umask je „maska", která z výchozích práv odmaskuje (technicky bitově, ne odčítáním — pro běžné masky ze sudých číslic to ale vyjde stejně). Výchozí základ je 666 pro soubory a 777 pro složky; typický umask je 022:

umask            # 0022 — vypne zápis skupině a ostatním
# nový soubor:  666 bez bitů z 022 = 644  (rw-r--r--)
# nová složka:  777 - 022 = 755  (rwxr-xr-x)

Nemusíš to počítat denně — stačí vědět, proč nové soubory nevznikají rovnou zapisovatelné pro všechny: postará se o to umask. Kdyby byl 000, každý nový soubor by mohl přepsat kdokoli, a to je díra. Proto ho neměň, pokud přesně nevíš proč.

Typické situace, na které narazíš

„Skript nejde spustit." Napíšeš ./deploy.sh a dostaneš Permission denied. Skoro vždy chybí x:

ls -l deploy.sh     # -rw-r--r-- ← žádné x
chmod +x deploy.sh  # přidej právo spouštět
./deploy.sh         # teď to jede

„Permission denied" při zápisu. Chceš editovat systémový soubor (třeba v /etc) a editor řekne, že nemáš práva. Ten soubor vlastní root — potřebuješ sudo:

nano /etc/hosts          # E212: Can't open file for writing
sudo nano /etc/hosts     # takhle ano

💡 Když si nejsi jistý, proč něco nejde, první sáhni po ls -l. Ukáže ti vlastníka, skupinu a práva — a z toho hned vidíš, jestli je problém v x, ve vlastníkovi, nebo ve skupině.

Failure modes — časté omyly začátečníků

• chmod 777 na všechno. „Nešlo to, tak jsem dal 777 a funguje." Jenže 777 znamená kdokoli smí číst, přepsat i spustit — otevřená díra. Skoro nikdy není správná odpověď; správně je najít, které konkrétní právo chybí (obvykle +x nebo správný vlastník).
• sudo u všeho ze zvyku. Když každý příkaz cpeš přes sudo, ztrácíš ochranu, kterou ti běžný účet dává — a jednoho dne omylem sudo-spustíš něco škodlivého. sudo používej jen tam, kde ho příkaz vyloženě potřebuje.
• chmod -R omylem na / nebo na /etc. Rekurzivní změna práv na půlku systému rozbije, co potká (ssh přestane přijímat klíče, služby nenaběhnou). Vždy si dvakrát zkontroluj cestu, než pustíš chmod -R nebo chown -R.
• Zapomenuté +x u skriptu. Permission denied u vlastního skriptu není chyba systému — jen mu chybí právo spouštět. chmod +x.
• Editace systémového souboru bez práv. Otevřeš /etc/… v editoru, hodinu píšeš a při uložení zjistíš, že nemáš práva a změny propadly. Systémové soubory otevírej rovnou přes sudo (a sudoers vždy přes visudo).

🛠️ Cvičení

1. Přečti si sám sebe. Zjisti svoje UID, GID a do jakých skupin patříš. (Nápověda: id, whoami.) Pak najdi v /etc/passwd svůj řádek a přečti z něj svůj domovský adresář a shell.
2. Rozlušti ls -l. Vytvoř soubor (touch pokus.txt), podívej se na jeho práva (ls -l pokus.txt) a napiš slovy, co smí vlastník, skupina a ostatní. Kolik je to číselně?
3. Udělej ze souboru skript. Vytvoř soubor ahoj.sh s jedním řádkem echo Ahoj, zkus ho spustit přes ./ahoj.sh a vysvětli, proč to nejde. Pak to naprav a spusť znovu.
4. Číselně vs symbolicky. Nastav souboru práva 640 číselně. Pak tomu samému souboru přidej právo spouštět pro vlastníka symbolicky a řekni, jaké číslo teď má.
5. Systémový vs lidský uživatel. Najdi v /etc/passwd jednoho uživatele s UID pod 1000 a jednoho nad 1000. Podle čeho poznáš, který je „služba" a který „člověk"?

🧠 Otázky & odpovědi