4. A jogosultsági rendszer

Minden többfelhasználós operációs rendszernek rendelkeznie kell jogosultsági rendszerrel. Erről több értelemben is beszélhetünk, ez a fejezet a fájlrendszer elemeihez (könyvárakhoz, fájlokhoz stb.) történő hozzáférés szabályozását tárgyalja. Mivel sok operációs rendszer létezik, és azokon is több fájlrendszert valósítottak meg, továbbá a jogosultsági rendszer többé-kevésbé mindig kötődik a fájlrendszerhez, ezért a használt fájlrendszer függvényében erős eltéréseket pasztalhatsz.

Ebben a fejeleztben a tradicionális Unix jogosultsági rendszerét tárgyaljuk.

4.1. Felhasználók és csoportok

Ahhoz, hogy egy jogosultsági rendszer működhessen, először felhasználói adatbázisra van szükség. Ezért először tekintsük át, hogy hogyan történik a felhasználók és csoportok kezelése, tárolása a Unix rendszerekben. Most itt is a tradicionális fogod megismerni, az alap Unix rendszerekben használt metódust mutatom be.

4.1.1. A passwd fájl

A rendszerbe felvett felhasználókról a /etc/passwd fájl tárol információkat. Amikor a rendszergazda felvesz egy új felhasználót, (többek közt) ebben a fájlban egy új sor keletkezik, a törlésekor a rá vonatkozó sor törlésre kerül. Nézzük meg, milyen adatokat tartalmaz ez a fájl! Mivel a közös használatú szerverünkön, a columbo.uni-eszterhazy.hu szerveren sok hallgatónknak van hozzáférése, ezért a kimenetből csak egy részletet mutatok most meg.

feri@columbo:~$ cat /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin

feri:x:1158:1158:Koczka Ferenc,,,:/home/feri:/bin/bash

XNVRDO:x:2275:2276:Varga Zsolt Róbert - programtervező informatikus [fejlesztő]:/home/2017/XNVRDO:/bin/bash
GZ0U7Y:x:2276:2277:Versényi Gábor - gazdaságinformatikus:/home/2017/GZ0U7Y:/bin/bash
LN79MA:x:2277:2278:Vígh Ádám - Gazdaságinformatikus BA:/home/2017/LN79MA:/bin/bash
GZU3PF:x:2278:2279:Víg Martin János - gazdaságinformatikus:/home/2017/GZU3PF:/bin/bash
CFS28O:x:2279:2280:Windegg Krisztián Henrik - programtervezõ informatikus:/home/2017/CFS28O:/bin/bash
WVDC9F:x:2280:2281:Zagyva Ádám - programtervezõ informatikus [fejlesztõ]:/home/2017/WVDC9F:/bin/bash
Y0EI4L:x:2281:2282:Zagyva Patrik - programtervező informatikus [fejlesztő]:/home/2017/Y0EI4L:/bin/bash

Nézzük meg az én felhasználói fiókomhoz tartozó sort! Vedd észre, hogy ez részekre bontható, az egyes mezőket kettőspont válaszja el egymástól. Lássuk, mit jelentenek ezek!

feri:x:1158:1158:Koczka Ferenc,,,:/home/feri:/bin/bash
----|-|----|----|----------------|----------|---------
  |  |   |    |          |             |         |
  1  2   3    4          5             6         7
1. Login név:Bejelentkezési név.
2. Jelszó:Régen itt a kódolt jelszó szerepelt. Ma már ez nem olvasható itt, helyette csak egy x látható. Ennek az az oka, hogy bár matematikai értelemben a jelszavak nem fejthetők vissza, annak nincs akadálya, hogy egy olyan programot írj, amely próbálgatással találja ki a jelszavadat.
3 userID:Ez az ún. userID, azaz felhasználói azonosító szám. A felhasználót a rendszeren belül valójában nem a neve azonosítja, hanem ez a szám. Így a rendszergazda sem feltétlenül root, nem ettől lesz az, hanem attól, hogy az userID-je 0. Nézd meg a fenti példa első sorát! Az egyes Unix variánsokban eltérő szabályok vannak arra, hogy milyen tartományokban milyen jellegű felhasználókat definiálnak, az Ubuntu Linuxban, amivel mi dolgozunk, a normál felhasználók számozása 1000-től kezdődik, az előre definiált felhasználóké 1-99 közt, a rendszer felhasználóké 100-999 közt van.
4. groupID:A negyedik helyen levő szám a mi példánkban ugyanaz, mint a harmadik helyen álló, ez a groupID. A csoportokkal később foglalkozunk ebben a fejezetben, dióhéjban most annyit, hogy a felhasználó csoportazonosítója lesz ez a szám.
5. Egyéb info:Ebben a mezőben vesszővel elválasztva több adat is található (az irodalom gyakran GECOS-nak hívja ezt). Az elsőt mindig meg szoktuk adni, ez a felhasználó teljes neve. Ez után meg lehet adni a felhasználó szobaszámát, telefonszámát stb. amit egy finger nevű paranccsal le lehet kérdezni, de ez ma már nemigen szokás.
6. Home könyvtár:
 A home könyvtáram. Erről már volt szó, a fájlban látszik, hogy minden felhasználónak van ilyenje, ebben szabadon tárolhat fájlokat, hozhat létre könyvtárakat.
7. shell:Ez a program indul el a sikeres bejelentkezést követően. Ez gyakran egy parancsértelmező (shell), de nem feltélenül kell annak lennie, bármilyen program meghatározható itt. Amikor a felhasználó ebből kilép, a bejelentkezési folyamat is véget ér.

4.1.2. A shadow fájl

A /etc/shadow fájl tartalmazza a felhasználók kódolt jelszavait, és egyéb kiegészítő adatokat. (Valószínűleg utóbbiak azért kerültek ide, mert annak idején a /etc/passwd tervezésekor kihagyták őket.) Nézzük meg ennek szerkezetét is!

feri@columbo:~$ cat /etc/shadow
cat: /etc/shadow: Engedély megtagadva

Mivel a /etc/shadow fájlt épp azért tervezték a rendszerbe, hogy a kódolt jelszóhoz ne lehessen hozzáférni, ezért a felhasználók számára ez nem olvasható. A tartalmát csak rendszergazdai jogosultsággal lehet megnézni (a hosszú kimenetből most is csak egy sort mutatok, és a kódolt jelszóból is kivágtam egy darabot):

root@columbo:~# cat /etc/shadow
feri:$6$Yf/x/ANA...5r00:16623:0:99999:7:::

Az /etc/shadow fájl sorai is kettősponttal elválasztott mezőkből állnak, lássuk, mit jelentenek ezek!

feri:$6$Yf/x/ANA...5r00:16623:0:99999:7:::
----|------------------|-----|-|-----|-|-|-|
  |          |            |   |   |   | | |
  1          2            3   4   5   6 7 8
1. Login név:Ez a bejelentkezési nevem. Ez köti össze a /etc/shadow adott sorát az /etc/passwd megfefelő sorával.
2. Kódolt jelszó:
 A kódolt jelszó, mindjárt részletesen lesz szó a képzéséről.
3. Utolsó csere:
 A jelszó cseréje óta az itt látható számú nap telt el 1970. január 1-je óta.
4. Minimum:Két jelszócsere közt minimálisan ennyi napnak kell eltelnie.
5. Maximum:A jelszó maximum ennyi napig érvényes, utána ki kell cserélni. A 99999 jelentése 273 évente, a gyakorlatban soha nem kell cserélni a jelszót.
6. Figyelmeztetés:
 A jelszó lejárta előtt ennyi nappal küld a rendszer figyelmeztetést.
7. Inaktivitás:Ha a felhasználó ennyi napon át nem jelentkezik be, a hozzáférését a rendszer letiltja. Az üres érték azt jelenti, hogy nincs ilyen lejárat beállítva.
8. Lejárat:A hozzáférés eddig érvényes, ezt is az 1970. január 1-je óta eltelt napok számával kell megadni. Az üres érték azt jelenti, hogy nincs ilyen lejárat beállítva.

4.1.2.1. A jelszó kódolása

A kódolt jelszó több részből áll melyet $ karakterek választanak el egymástól három mezőre.

$6$Yf/x/ANA$zNcw1iiFwkWku...6lzhrdtcUhD70eup6abp.ZXXZSSVPuJGRWq2qFq8FrF5r00
--|--------|---------------------------------------------------------------
 |    |                                   |
 1    2                                   3
1. Algoritmus:Az első a jelszó kodolási algoritmusát adja meg, ez példánkban 6, azaz az SHA-512.
2. Salt:A salt (só) a jelszóbiztonság növelésére szolgál. A rendszer ezt a felhasználó létrehozásakor véletlenszerűen generálja, és a jelszavához illeszti. A bejelentkezéskor szintén ugyanez történik, a felhasználó megadja a jeszavát, ehhez a rendszer újra hozzáilleszti a jelszót védő salt-ot, majd ezt kódolva kell a harmadik mezőben levő kódolt formát (lenyomatot) kapnunk.
3. Lenyomat:A kódolt jelszó.

Tip

Van lehetőség arra, hogy a a /etc/shadow és az /etc/passwd fájt a régi formára alakítsuk. A pwunconv hatására a kódolt jelszavak visszakerülnek az /etc/passwd fájlba, a pwconv újra szétválasztja azokat. Egy egyesítést és egy szétválasztást mutat az alábbi példa:
root@columbo:~# cat /etc/passwd
feri:x:1158:1158:Koczka Ferenc,,,:/home/feri:/bin/bash

root@columbo:~# pwunconv
root@columbo:~# cat /etc/passwd
feri:$6$Yf/x/ANA...5r00:1158:1158:Koczka Ferenc,,,:/home/feri:/bin/bash

root@columbo:~# pwconv
root@columbo:~# cat /etc/passwd
feri:x:1158:1158:Koczka Ferenc,,,:/home/feri:/bin/bash

4.1.2.2. A lenyomat

E könyv keretében az /etc/shadow fájlban levő jelszvak kapcsán találkozol először a lenyomattal (hash-sel), de számos helyen előkerül még, ezért tegyünk egy kis kitérőt ebben a témában. A lenyomatképzést akkor használjuk, ha valamilyen bemeneti adatból (jeszóból, fájlból) az eredetinél általában egy rövidebb hosszúságú, rendszerint fix hosszúságú adatsort, a lenyomatot kell előállítani úgy, hogy:

  • a műveletet újból elvégezve ugyanazt a lenyomatot kapjuk,
  • a lenyomatból ne lehessen előállítani az eredeti adatot,
  • az eredeti adat legkisebb megváltozása is a lenyomat megváltozását eredményezze.

A fentiekből következik, hogy létezik több olyan bemenet is, amely ugyanazt a lenyomatot adja.

Több lenyomatképző eljárás létezik, a legismertebbek között az md5, a blowfish, az sha-256 vagy az sha-512 szerepel. A blowfish egy gyors, ennek megfelelően kis megbízhatóságú algoritmus, az md5 mára már feltörhető, használata magas biztonsági követelmények mellett nem ajánlott.

A Linuxban több parancs is rendelkezésedre áll, ha lenyomatot akarsz készíteni valamiről. Kettőt mutatok meg neked, az md5sum és a sha512sum parancsokat. Mindkettőben az /etc/passwd fájlból kézek egy-egy lenyomatot, az elsőben az md5 algoritmust alkalmazva:

feri@columbo:~$ md5sum /etc/passwd
78264bf59cfac9c1f3f2f54b1be3323b  /etc/passwd

Nagy biztonságot az sha512 nyújt, ehhez egy másik parancsra van szükségünk (látható, hogy ezt használva egy hosszabb lenyomat keletkezik):

feri@columbo:~$ sha512sum /etc/passwd
8a5aa1376187e54cbae2754d4bb68d1e827315c856350772632f7718329320b32ff93132962bcd4b6cf7bd355752b87592a0f4aa096ac368f37661d26d4c37fc  /etc/passwd

Egy másik példa: ha a titok szó lenyomatát szeretnéd képezni, így kell használnod a parancsot, részletesen majd a Szűrők c. fejezetben tanulsz arról, hogy mit jelent itt a | karakter.

feri@columbo:~$ echo "titok" | md5sum
ea6b6aac5a93ae6f815208530ca9c767  -

feri@columbo:~$ echo "titok" | sha512sum
8e019005a4d9063e29baaa4c0e9a27f7a4ca13e07f935b6e264c98a33d2e5b612eb9135e92e60223d3a9eb54778c1976a8ac15160b7dbcee9682d584ec118061  -

Ha van kedved, próbáld ki a shasum, sha1sum, sha256sum, sha224sum és a sha384sum parancsokat, ezek mindegyike egy-egy lenyomatképési eljárást kínál.

Tip

Ha egy fájlt letölthetővé teszel egy weblapon, tedd közzé a lenyomatát is! Ezzel a letöltés után ellenőrizhető annak sértetlensége.

Danger

A fentiek alapján láthatod, hogy egy helyesen megtervezett rendszerben miért nem tudja a rendszergazda megadni az elfelejtett jelszavadat: számára is csak annak lenyomata áll rendelkezésre, a próbálkozásos módszeren kívül neki sincs lehetősége arra, hogy azt visszafejtse. Ha fejlesztő leszel, fontos, hogy te sem tárolj jelszavakat a saját rendszeredben, csak azok lenyomatát! Ha a rendszeredhez rosszindulatú személyek valahogyan mégis hozzáférnek, a jelszavakat lemásolják, és saját céljaikhoz fel fogják használni azokat. Ez nagy probléma lehet, mert sok ember mindenfelé ugyanazt a jelszót használja, és egy ilyen esetben hozzáférhetnek a Facebook, GMail stb. fiókjaikhoz is. Az pedig nagyon rossz fényt vet majd a cégre, ahol dolgozol.

4.1.3. Csoportok kezelése

Egy operációs rendszer felhasználóinak különféle jogosultságai vannak, amiket a rendszergazda állít be számukra. A gyakorlatban, ha az egyetem többezres hallgatósága számára kellene beállítani valamilyen jogosultságot, eléggé kellemetlen feladat lenne azt egyesével megtenni. Nagyszámú felhasználó mellett hamar felmerül, hogy jó lenne a felhasználókat csoportosítani, és azokhoz jogosultságokat rendelni. Ha az egyetemi hallgatók egy csoport tagjai, a szükséges jogosultságot a csoporthoz rendeljük hozzá, így a csoport minden tagja rendelkezni fog azzal.

A /etc/group fájl írja le az operációs rendszer csoportjait és azok tagjait. (Megint csak néhány sort mutatok a kimenetből.)

feri@columbo:~$ cat /etc/group
root:x:0:
daemon:x:1:
bin:x:2:
sys:x:3:
adm:x:4:syslog

Nézzük meg ennek szerkezetét is, ez alapján könnyebben megértheted a működését. Egy sor egy csoportot ír le, szerkezete az alábbi:

sudo:x:27:feri,lajos,bela
----|-|--|---------------
  |  | |        |
  1  2 3        4
Név:A csoport neve.
Jelszó:A csoport jelszava. A gyakorlatban még sosem használtam.
groupID:A csoport belső azonosítója.
Tagok:A csoport tagjainak listája, az elválasztásukhoz vesszőt kell használnod. Nem kötelező, hogy a csoportnak legyenek tagjai.

Emlékezz vissza, a /etc/passwd fájl sorainak negyedik mezője a groupID volt, ez azt jelenti, hogy minden felhasználónak legalább egy csoportba tartoznia kell. Az egyetemen jó megoldás lehet, hogy készítünk három csoportot, pl. hallgatok, oktatok és dolgozok néven, minden felhasználót ezek valamelyikébe soroljuk, és ennek groupID-je kerül a /etc/passd fájlban a negyedik mezőbe. Ha nincs ilyen besorolási lehetőség, az is egy bevált megoldás, hogy a felhasználó felvételekor azonnal készül egy olyan csoport, aminek a neve megegyezik a felhasználóéval, és csak ő a tagja. A columbo szerveren ezt a módszert használtuk, ezért ott van egy feri nevű csoport is, aminek csak én vagyok tagja:

feri@columbo:~$ cat /etc/group
feri:x:1158:

Vedd észre, hogy a fenti példában a tagokat felsoroló mező üres. Ennek a csoportnak feri azért tagja, mert a /etc/passwd fájlban a groupID mezőben az 1158-as szám, a feri nevű csoport id-je szerepel. Ezt a csoportot a felhasználó elsődleges csoportjának nevezzük.

/etc/passwd:

feri:x:1158:1158:Koczka Ferenc,,,:/home/feri:/bin/bash
----|-|----|----|----------------|----------|---------
              |
              |
/etc/group:   |
              |
      feri:x:1158:

4.1.3.1. id

Az id parancs részletes tájékoztatást ad egy felhasználó csoport tagságairól. Egy példa:

feri@columbo:~$ id
uid=1158(feri) gid=1158(feri) csoportok=1158(feri),27(sudo),104(fuse),106(whoopsie)

A kimenetben látszik, hogy az userID-m 1158, amihez a /etc/passwd fájlban a feri bejelentkezési név tartozik. A groupID-m szintén 1158, ez az elsődleges csooortom, amelynek neve a /etc/shadow fájlban szintén feri. Emellett további csoportok tagja is vagyok, ezek a 27-es groupID-jű sudo, a 104-es fuse és a 106-os whoopsie.

Tip

Az id parancsot más felhasználók esetén is használhatod úgy, hogy a parancs paramétereként megadod a kívánt felhasználó login nevét:

feri@columbo:~$ id kiraly.roland
uid=1008(kiraly.roland) gid=1008(kiraly.roland) csoportok=1008(kiraly.roland),27(sudo)

4.1.4. Tulajdonos és csoport cseréje

A tulajdonos és a csoport cseréjére két parancs áll rendelkezésre, a chown (CHange OWNer) és a chgrp (CHange GRouP). Megmutatom a használatukat, de rendszergazdai jogkör nélkül ez csupán elmélet marad, az egyszerű felhasználók Linuxon nem változtathatják meg ezeket. Más rendszerek erre lehetőséget adhatnak, a SunOS-ben van ilyen lehetőség.

Lássuk a parancsok használatát! A chown parancsnak két paramétert kell adni, az új tulajdonost és a file vagy könyvtár nevét. Az alábbi példában a tesztFile fájl tulajdonosát kiraly.roland-ra cseréljük.

root@columbo:~/demo# ls -l
-rw-rw-r-- 1 feri feri        0 júl    8 22:35 tesztFile
root@columbo:~/demo# chown kiraly.roland tesztFile
root@columbo:~/demo# ls -l
-rw-rw-r-- 1 kiraly.roland feri        0 júl    8 22:35 tesztFile

Hasonló képpen történik a csoport cseréje is, a chgrp parancsot használom, melynek szintén két paramétere van, az új csoport és a fájl vagy könyvtár neve.

root@columbo:~/demo# chgrp www-data tesztFile
root@columbo:~/demo# ls -l
-rw-rw-r-- 1 kiraly.roland www-data    0 júl    8 22:35 tesztFile

Ha a tulajdonost és a csoportot is meg akarod változtatni, akkor a chown és a chgrp egyetlen chown parancsba is összevonhatod úgy, hogy a tulajdonost és a csoport nevét kettősponttal elválasztva adod meg paraméterként.

root@columbo:~/demo# chown feri:users tesztFile
root@columbo:~/demo# ls -l
-rw-rw-r-- 1 feri users       0 júl    8 22:35 tesztFile

A parancs a -R paraméterrel ún. rekurzív módban működik. Ekkor nem csak a megadott fájlra és könyvtárra vonatkozik a hatása, hanem az összes abból nyíló könyvtárra is. Az alábbi pédában létrehozok egy könyvtárat, abban egy fájlt, majd a könyvtár tulajdonosának és csoportjának cseréjt a -R kapcsolóval végzem el. Így tehát a könyvtárban levő fájl tulajdonosa és csoportja is megváltozik.

root@columbo:~/demo# mkdir tesztDir
root@columbo:~/demo# touch tesztDir/adatok.txt
root@columbo:~/demo# ls -l
drwxr-xr-x 2 root root     4096 júl    8 22:46 tesztDir
root@columbo:~/demo# chown kiraly.roland:users tesztDir -R
root@columbo:~/demo# ls -ld tesztDir/
drwxr-xr-x 2 kiraly.roland users 4096 júl    8 22:46 tesztDir/
root@columbo:~/demo# ls -l tesztDir/
-rw-r--r-- 1 kiraly.roland users 0 júl    8 22:46 adatok.txt

Note

Miért csak a rendszergazda adhat át tulajdonjogot és csoportjogot? Mert a felhasználók ezzel a lehetőséggel visszaélhetnek. Az egyik könnyen érthető helyzet a kvótán alapul. Ez az a beállítás, amely meghatározza, hogy egy felhasználó (vagy csoport) mekkora területet használhat el a rendszer diszkjéből. Ezt a rendszer minden felhasználó esetén az általa tulajdonolt fájlok méretének összegzésével állapítja meg, és nem engedi a meghatározottnál több terület elhasználását. Ha egy felhasználó át tudja adni egy fájl tulajdonjogát egy másiknak, esetleg ezt úgy teszi, hogy ez a fájl az új tulajdonos számára elérhetetlen könyvtárban van, akkor azzal el tudja fogyasztani az általa felhasználható tárhelyet úgy, hogy az ellen az illető semmit sem tehet.

Az eddig látott fájlokon alapuló rendszer a Unixok alapszintű felhasználó- és csoportkezelését jelentik. Ez jó megoldás abban az esetben, ha csak egy-két számítógépen kell felhasználókat kezelnünk, de hamar megérezzük a korlátait, ha sok szerverünk van, és azok mindegyikéhez hozzá kell férnie a felhasználóknak. Ezért az operációs rendszerek fejlesztése során a legtöbb gyártó elkészített valamilyen ún. címtár megoldást, amely a felhasználók központi kezelését valósítja meg, és a bejelentkezést (egyes esetekben a jogosultsági információkat is) ez valósítja meg. A Microsoft rendszereiben ez az Active Directory, a Unixok esetében a LDAP. Ha nagyvállalatnál dolgozol, szinte biztosan találkozol a címtárral.

4.2. A Unix jogosultsági rendszere

Most, hogy ismerjük a rendszer felhasználóinak és csoportjainak felépítését, lássuk, hogy hogyan olvashatjuk le, hogy melyik felhasználó és csoport melyik fájlon milyen jogosulsággal rendelkezik! Amit ebben a fejezetben megmutatok neked, az egy POSIX szabvány szerinti rendszer, nagyon sok Unix, a Linuxok ezt használják. Ez aránylag egyszerű, de bonyolultabb követelmények esetén már körülményes rendszer, ezért a későbbiekben még ennek kiegészítéseivel is foglalkozunk.

Idézzük fel a ls -l parancs kimenetét! A példában egy runme nevű programot látunk.

feri@columbo:~/demo$ ls -l
összesen 4
-rwxr-x--- 1 feri whoopsie 6 júl    8 15:03 runme

A jogosultságokat három oszlop írja le, ezek:

-rwxr-x--- 1 feri whoopsie 6 júl    8 15:03 runme
----------   ---- --------
     |         |     |
     1         2     3
1. Jogosultság:Ez írja le a fájlhoz tartozó jogosultságokat.
2. Tulajdonos:A fájl tulajdonosa.
3. Csoport:A fájl csoportja.

A jogosultságokat leíró első oszlop 9 karakterből áll. Az első három a felhasználó, a második a csoport, a harmadik minden más, a rendszerben létező felhasználóra vonatkozik. Ezt szemlélteti az alábbi ábra, amelyen a tulajdonos, feri jogait az rwx, a csoport, a whoopsie jogait az r-x, a többi felhasználóét az --- karakterhármas írja le:

Jog, tulajdonos, csoport

4.2.1. Fájlok

Az egyes jogok jelentése fájlok esetében:

r, Read:A fájl tartalma olvasható.
w, Write:A fájl tartalma írható.
x, eXecute:A fájl futtatható, azaz egy programfájl, amelyet el lehet indítani.
Példák:
  • Az rwxr-x--- jelentése: a tulajdonos olvashatja, írhatja és futtathatja a fájlt. A csoport olvashatja és futtathatja, a többi felhasználó semmit sem tehet vele.
  • Az rw-r--r-- jelentése: a tulajdonos írhatja és olvashatja, a csoport tagjai olvashatják, a többi felhasználó szintén olvashatja azt.
  • A --------- jelentése szerint senki sem fér a fájlkoz, a gyakorlatban viszont a root számára ez nem jelent valódi tiltást, ő írhatja és olvashatja is azt.

4.2.2. Könyvtárak

Könyvtárak esetén a jogok jelentése részben eltér. Megértésükhöz azt kell érdened, hogy a Unix fájlrendszereiben a könyvtárak olyan fájlok, amelyek tartalma a tartalomjegyzék. Az egyes jogok jelentése:

r, Read:A könyvtár tartalma (azaz a tartalomjegyzéke) olvasható. Ne feledd, a tartalomjegyzék csak a fájlok neveit tartalmazza, azok más jellemzői (tulajdonos, csoport stb.) a fájlokhoz tartozó inode-ban van tárolva.
w, Write:A könyvtár tartalma (azaz a tartalomjegyzéke) írható. Mivel van jogod írni a tartalomjegyzékbe, ezért abban létre tudsz hozni fájlokat, könyvtárakat.
x, eXecute:A könyvtárban levő fájlok és könyvtárak elérhetőségét (azaz az inode-hoz való hozzáférést) engedélyezi vagy tiltja.
Példák:
  • Az rwxr-x--- jelentése: a tulajdonos olvashatja, írhatja és futtathatja a fájlt. A csoport olvashatja és futtathatja, a többi felhasználó semmit sem tehet vele.
  • Az rw-r--r-- jelentése: a tulajdonos írhatja és olvashatja, a csoport tagjai olvashatják, a többi felhasználó szintén olvashatja azt.
  • A --------- jelentése szerint senki sem fér a fájlhoz, a gyakorlatban viszont a root számára ez nem jelent valódi tiltást, ő ennek ellenére írhatja és olvashatja is azt.

Danger

Eleinte nehéz elfogadni, hogy a jogosultsági rendszerben az, hogy egy fáj tartalmát írhatod, nem jelenti azt, hogy azt át is nevezheted vagy törölheted. Ugyanez a helyzet fordítva is: az hogy egy fájlt átnevezhetsz, vagy törölhetsz, nem jelenti azt, hogy a tartalmát is módosíthatod. Ezek a fentiek alapján a fálj írási jogától, másrészt az őt tartalmazó könyvtár írási jogától függenek.

Az r és az x jogok együttese hoz néhány érdekes helyzetet, pontosítsuk ezeket! Az alábbi példákban az adatok könyvtárban van egy tesztek.txt nevű szövegfájl. A kísérletünk elején minden “normális”: a könyvtáron a tulajdonosnak rwx jogköre van, azaz olvashatja a tartalomjegyzékét (r) és hozzáfér az abban levő bejegyzések (fájlok, könyvtárak) inode-jaihoz is (x).

feri@columbo:~/demo$ ls -ld adatok/
drwxrwxr-x 2 feri feri 4096 júl   22 23:35 adatok/

Az adatok könyvtár tartalma ezért megtekinthető:

feri@columbo:~/demo$ ls -l adatok
-rw-rw-r-- 1 feri feri 13 júl   22 23:35 adatok/tesztek.txt

Ebben a helyzetben a adatok/tesztek.txt fájl tartalma olvasható (a tulajdonosnak van r joga):

feri@columbo:~/demo$ cat adatok/tesztek.txt
Teszt adatok

Játsszunk egy kicsit a könyvtár jogaival! Vegyük el az olvasás jogát, majd nézzük meg a tartalomjegyzéket! Láthatod, hogy az olvasás jog hiánya azt eredményezi, hogy nem férek hozzá a tartalomjegyzékhez, azt nem tudom kiolvasni. (A chmod paranccsal a jogokat állítom át, erről hamarosan részletesen olvashatsz.)

feri@columbo:~/demo$ chmod 330 adatok/
feri@columbo:~/demo$ ls -ld adatok/
d-wx-wx--- 2 feri feri 4096 júl   22 23:35 adatok/
feri@columbo:~/demo$ ls -l adatok/
ls: nem lehet a következő könyvtárat megnyitni: adatok/: Engedély megtagadva

Az r jog hiányzik, ezért nem olvashatom a könyvtár tartalomjegyzékét. Lássuk, az abban levő fájl tartalmához hozzáférek-e!

feri@columbo:~/demo$ cat adatok/tesztek.txt
Teszt adatok

Gondolom, nem ezt vártad, de igen, ettől még a fájl tartalma olvasható. Igaz, hogy a tartalomjegyzéket nem olvashatom, de nincs is szükségem erre, mert pontosan meg tudtam nevezni az olvasandó fájlt. Mivel az x jog él az adatok könyvtáron, ezért hozzáfértem a fájl inode-jához, ezzel a tartalmához is.

Nézzük fordítva! Most visszadom az r jogot és elveszem az x-et! Ezzel tehát olvashatom a tartalomjegyzéket, de nem férek hozzá az inode-okhoz.

feri@columbo:~/demo$ chmod 440 adatok/
feri@columbo:~/demo$ ls -ld adatok
dr--r----- 2 feri feri 4096 júl   22 23:35 adatok

Először nézzük meg az adatok könyvtár tartalomjegyzékét! Első pillantásra elég furcsa a parancs kimenete, látható, hogy addig eljutok, hogy lássam, van itt egy tesztek.txt nevű fájl. A nevén kívül azonban semmilyen más adata nem olvasható, csak kérdőjelek jelennek meg a helyükön.

feri@columbo:~/demo$ ls -l adatok/
ls: adatok/tesztek.txt nem érhető el: Engedély megtagadva
-????????? ? ? ? ?              ? tesztek.txt

Miért van ez így? Mivel az r jogom megvan, a tartalomjegyzéket olvashatom, ezért látszik a fájl neve. Az x hiánya miatt a tesztek.txt inode-jához, és az abban tárolt jellemzőkhöz már nem férek hozzá, ezért azok helyett csak kérdőjelek jelennek meg. Gondolom, sejted, hogy ebben a helyzetben tudom-e olvasni a adatok/tesztek.txt fájl tartalmát:

feri@columbo:~/demo$ cat adatok/tesztek.txt
cat: adatok/tesztek.txt: Engedély megtagadva

Az inode nélkül nem jutottam hozzá a fált tartalmazó adatblokkokhoz sem, ezért számomra a fájl tartalma nem olvasható.

4.2.3. Speciális jogok

Ha a jogosultsági rendszer csak az eddig bemutatottak szerint működne, nem tudna az operációs rendszer megfelelően működni. Vannak olyan helyzetek, amikor bizonyos szabályokat át kell hágni, ezért a rendszer még három speciális jogosultsági lehetőséget is tartalmat. Most ezeket nézzük meg.

4.2.3.1. setUID

Azt, hogy miért van erre szükség, hadd mutasssam meg egy példán! Azt már láttad, hogy a felhasználói jelszavak az /etc/shadow fájlban vannak. Ebbe a fájlba kell írni, ha a felhasználó meg akarja változtatni a jelszavát. De nézzük csak, mely felhasználóknak van írás joga erre a fájlra!

feri@columbo:~$ ls -l /etc/shadow
-r--r----- 1 root shadow 40521 júl    8 13:47 /etc/shadow

A root olvashatja a tartalmát bár a korábbiak alapján, tudjuk, hogy ő akkor is írhatja, ha nincs kifejezett írási joga rá. Emellett olvashatja egy shadow nevű csoport, ennek azonban senki sem tagja a rendszer felhasználói közül (most megint csak egy részletet mutatok a /etc/group fájlból.

feri@columbo:~$ cat /etc/group
shadow:x:42:

Ezek után hogy lehet, hogy ha egy egyszerű felhasználó elindítja a passwd programot, az mégis képes módosítani az /etc/shadow fájl tartalmát? Ha figyelembe vesszük, hogy a felhasználók által elindított programok az adott felhasználó nevében, az ő jogkörükkel futnak, akkor nem volna szabad, hogy a passwd program írni tudja a /etc/shadow fájlt.

A kérdésre a választ az ls program jogosultásgi beállításai adják meg, ahol látható, hogy a tulajdonos jogkörét leíró blokk utolsó karaktere most nem x, hanem s:

feri@columbo:~$ ls -l /usr/bin/passwd
-rwsr-xr-x 1 root root 47032 máj   17 01:37 /usr/bin/passwd

Ha a tulajdonosi jogokat leíró karakterhármas x, helyén s áll, akkor ez azt jelenti, hogy a program futtatását az operációs rendszer a tulajdonos jogkörével végzi. Ezt a jogot setuidnek nevezik (SET User ID).

Note

  • A Windowsban is van setUID-szerű lehetőség, ha egy programot nem dupla kattintással, hanem a helyi menüben levő Futtatás rendszergazdaként menüponttal indítod.
  • A setUID nem működik shell scriptek esetén (lásd később).

A setUID könnyű lehetőséget nyújt egy rossz szándékú támadónak arra, hogy ún. hátsó ajtót helyezzen el a gépeden, ha azt rendszergazdaként bejelentkezve magára hagyod. Nézzük csak az alábbi két parancsot! Első lépésként a támadó egy parancsértelmezőt az átmeneti fájlok könyvtárába másol, valamilyen ártatlannak tűnő néven, ez példánkban a szakdolgozat.txt. Ez után bekpacsolja rá a setUID jogot úgy, hogy azt bármelyik felhasználó futtathassa.

root@columbo:~# cp /bin/bash /tmp/szakdolgozat.txt
root@columbo:~# chmod 4755 /tmp/szakdolgozat.txt

Később, egyszerű felhasználóként elindítja a szakdolgozat.txt programot egy -p kapcsolóval. Ez a setUID miatt root-ként indul el, és máris teljes jogkört biztosít a rendszer minden fájlja felett, amit a prompt végén levő # is jelez.

feri@columbo:~$ /tmp/szakdolgozat.txt -p
szakdolgozat.txt-4.3#

4.2.3.2. setGID

A setGID jelentése nagyon hasonlít a setUID-hez. Egy program futtatása esetén a setGID bekapcsolt állapota azt jelenti az operációs rendszer számára, hogy a programot az ahhoz tartozó csoport jogaival kell futtatnia.

feri@columbo:~/demo$ ls -ld sayHello
-rwxr-sr-x 1 feri biciklistak 26 júl   16 18:07 sayHello

4.2.3.3. A Sticky bit

Van még egy jogosultság, amit sticky bit-nek neveznek, és ma már csak könyvtárakon van hatása. Ha egy könyvtáron bekpacsolod ezt a jogot, akkor a felhasználók abban csak a saját tulajdonukban levő fájlokat tudják törölni. Emlékezz vissza, enélkül egy könyvtár írhatósága egy csoport, vagy a világ számára azt jelenti, hogy abban létrehozhat, átnevezhet és törölhet is fájlokat. A sticky bit ezt módosítja.

A sticky bitre pl. a /tmp könyvtár esetében van szükség, mert ezt a felhasználók közösen használják az átmeneti fájljaik (temporary files) tárolására. Nem lenne szerencsés, ha az egyes felhasználók törölhetnék egymás átmeneti fájljait, ezért azt a sticky bit bekapcsolásával akadályozza meg a rendszer. Nézzük meg a jogokat az alábbi példában!

feri@columbo:~$ ls -ld /tmp
drwxrwxrwt 6 root root 12288 júl   16 18:00 /tmp

Azt kell látnod, hogy a világ jogosultságait leíró blokk x helyén most t áll, ez a sticky bit bekapcsolt állapotát jelzi.

4.2.3.4. chmod

A jogodulstágok beállítása a chmod paranccsal történik. A használatakor meg kell adni, hogy milyen jogot szeretnél beállítani mely fájlokra és/vagy könyvtárakra. A -R kapcsoló itt is használható, így a könyvtárrendszer egy teljes ágára is érvényesítheted a hatását.

A nehezebb kérdés a jog leírása, erre két módszer használatos. Az egyikben számokkal írjuk le ezeket, egy gyors fejszámolással egy rövidebb írásmódot használhatsz. Ha megtanulod az egyes jogokhoz tartozó betűjeleket, akkor egy másik módszert is használhatsz. Mindkettőt megmutatom.

Lássunk még egy példát! Az alábbi C++ programot readShadow.cpp néven mentettem el, a feladata, hogy a /etc/shadow tartalmát kiírja a képernyőre:

#include <iostream>
#include <fstream>
#include <string>

#define FILENAME "/etc/shadow"

using namespace std;

int main () {
  string line;
  ifstream sf (FILENAME);
  if (sf.is_open()) {
    while ( getline (sf, line) ) {
      cout << line << '\n';
    }
    sf.close();
  }
  else cout << "Unable to open file: " << FILENAME << endl;

  return 0;
}

Ezt lefordítom, majd elindítom (hogy miért így, később megbeszéljük). Mivel a programot nem a rendszergazda indította, és az a tulajdonos jogaival fut, nem tudja olvasni a /etc/shadow fájlt, így egy erre vonatkozó hibaüzenet jelenik meg:

feri@columbo:~/demo$ g++ readShadow.cpp -o readShadow
feri@columbo:~/demo$ ./readShadow
Unable to open file: /etc/shadow

Most a rendszergazda a tulajdonába veszi a fájlt és beállítja rá a setUID jogot:

feri@columbo:~/demo$ sudo chown root readShadow
feri@columbo:~/demo$ sudo chmod 4755 readShadow
feri@columbo:~/demo$ ./readShadow
root:$6$kzBRAP2V$mxAtUNB59hfGn/EcjruM1AHM...amyVBHdCE4zzpH9tHK.:17355:0:99999:7:::
daemon:*:17355:0:99999:7:::
bin:*:17355:0:99999:7:::
sys:*:17355:0:99999:7:::
sync:*:17355:0:99999:7:::
games:*:17355:0:99999:7:::
man:*:17355:0:99999:7:::
lp:*:17355:0:99999:7:::

A program az indulása után a tulajdonos, a root jogaival fut, ezért hozzáfér az /etc/shadow tartalmához.

4.2.3.5. A umask

Felmerülhet benned a kérdés, hogy az újonnan létrehozott fájlok milyen jogosultsági beállításokkal jönnek létre. Végezzünk egy gyors tesztet, hozzunk létre egy fájlt, és nézzük meg, milyen jogok tartoznak hozzá!

feri@columbo:~/demo$ touch tesztFile
feri@columbo:~/demo$ ls -l tesztFile
-rw-rw-r-- 1 feri feri 0 aug    1 21:28 tesztFile

Hogy miért éppen 664, arra a választ a umask parancs adja meg. A parancs paraméter nélküli megadásakor egy 4 számjegyből álló oktális számot ad válaszul, ez a chmod parancsnál már bemutatott paraméterre vonatkozik, de itt azt írja le, hogy mely jogok NE kerüljenek beállításra. A helyzetet tovább bonyolítja, hogy a umask biztonsági okokból nem fog futtatási (x) jogot beállítani.

feri@columbo:~/demo$ umask
0002

A umask paramétere az alábbi táblázat alapján értelmezhető. A speciális jogok nem állíthatók be vele, és a futtatási jog sem, a legtöbb, amit adhatsz vele a rw-rw-rw- lehet, ennek a 0666 felel meg. A umask azt írja le, hogy ebből mit nem akarunk alapértelmezés szerint bekapcsolni.

  Speciális Tulajdonos Csoport Mások
  0 6 6 6
Umask 0 0 0 2
Jog 0 6 6 4

Ebben a példában a umask a 0666 paramétert kapja. Az ez után létrehozott fájl jogait a 0000 írja majd le:

feri@columbo:~/demo$ umask 0666
feri@columbo:~/demo$ touch umask-tesztfile
feri@columbo:~/demo$ ls -l
---------- 1 feri feri    0 aug    1 22:04 umask-tesztfile

4.3. Az ACL-ek

A POSIX szabványú jogosultsági rendszerrel szemben (erről volt eddig szó) szemben az egyik legnagyobb kritika az, hogy csak egyetlen felhasználóhoz és egyetlen csoporthoz rendelhetők jogosultságok. Nincs egyszerű lehetőség arra, hogy újabb felhasználókat, csoportokat vonjunk be ebbe a körbe, és számukra újabb jogosultságokat határozzunk meg. A csoportok kombinálásával, közös csoporttagságokkal lehet megoldásokat adni, de ezek elbonyolítják, áttekinthetetlenné teszik a jogosultsági rendszert. A probléma megoldására tervezték meg az ún. POSIX ACL-t (Access Control List) szabványtervezetet, amit a Linuxokban is megvalósítottak. Ebben a fejezetben ezzel ismerkedhetsz meg.

Ha egy rendszer támogatja az ACL használatát, tulajdonképpen újabb felhasználók és csoportok számára teszi lehetővé jogosultságok beállítását. Amikor egy fájlhoz vagy könyvtárhoz egy újabb jogosultságot rendelsz, egy ún. ACE (Access Control Entry) jön létre. Ez írja le, hogy kinek milyen jogot adtál. A jogok ugyanazok, mint amiket már megismertél, a jogosultak köre pedig a következők valamelyike lehet (az 1-es, 3-as és 6-os sorok azok, amiket már megismertél, de az ACL-ben is kezelni kell őket):

# Megnevezés Hivatkozás Jelentés
1 Tulajdonos user::rwx A fájl/könyvtár tulajdonosa.
2 Egyéb felhasználó user:<név>:rwx ACL-ben meghatározott felhasználó.
3 Tulajdonoscsoport group::rwx A fájl/könyvtár csoportja.
4 Egyéb csoport group:<név>:rwx ACL-ben megadott újabb csoport.
5 Maszk mask::rwx Ezzel a fentiekből kimaszkolhatsz egyes biteket.
6 Mindenki más other::rwx A fentiekben nem meghatározott felhasználók.

4.3.1. ACL fájlokon

Lássunk egy gyors példát! A hello.txt jogosultságait az eddigiek alapján könnyű értelmezni, a tulajdonos (feri) rw, a csoportja (feri) rw, míg mások r joggal rendelkeznek:

feri@columbo:~/demo$ ls -l hello.txt
-rw-rw-r-- 1 feri feri 6 aug    1 22:25 hello.txt

A kiterjesztett attribútumok lekérdezésére a getfacl (GET File ACL) parancs szolgál, paramétere az a fájl, amelynek attribútumait vizsgálni szeretnéd. Az alábbi példában getfacl válaszában is az alap jogokat láthatod, az egyes sorok a tulajdonos, a csoport és az egyéb felhasználók jogait írják le.

feri@columbo:~/demo$ getfacl hello.txt
# file: hello.txt
# owner: feri
# group: feri
user::rw-
group::rw-
other::r--

Most a hello.txt fájlhoz rw jogosultságot adok cartman nevű felhasználónak. Erre a setfacl (SET File ACL) parancsot használom. Az első paraméter a -m, ez jelzi, hogy egy ACL bejegyzést szeretnék módosítani. A továbbiakban megadom azt, hogy egy felhasználói jogot állítok be, ez után a felhasználó nevét, majd a hozzá rendelt jogosultságot. Természetesen meg kell adnom azt is, hogy melyik fájlra szeretném ezt beállítani.

feri@columbo:~/demo$ setfacl -m user:cartman:rw hello.txt

Názzük meg, hogyan változott a fájl jogosultsága! Látható, hogy megjelent az újabb felhasználóra vonatkozó sor:

feri@columbo:~/demo$ getfacl hello.txt
# file: hello.txt
# owner: feri
# group: feri
user::rw-
user:cartman:rw-
group::rw-
mask::rw-
other::r--

Azt, hogy a fájlra nem csak az alap jogok vonatkoznak, hanem arra ACL is érvényben van, az ls parancs kimenetében, a jogosultságok leírásának végén álló + karakter figyelmeztet. (Más rendszerekben ez eltérő lehet, a RedHat Linux esetében ez egy pont karakter.)

feri@columbo:~/demo$ ls -l hello.txt
-rw-rw-r--+ 1 feri feri 6 aug    1 22:25 hello.txt

Egy jog eltávolítása a -x kapcsolóval történik. Ebben az esetben is meg kell adni, hogy egy felhasználóhoz rendelt jogot akarsz törölni, ezt követi a felhasználó neve, majd a módosítandó fájl vagy könyvtár következik. Az eredményt a getfacl paranccsal ellenőrizzük:

feri@columbo:~/demo$ setfacl -x user:cartman hello.txt
feri@columbo:~/demo$ getfacl hello.txt
# file: hello.txt
# owner: feri
# group: feri
user::rw-
group::rw-
mask::rw-
other::r--

4.3.2. ACL könyvtárakon

Lássuk, hogyan működik mindez könyvtár esetén! Alapesetben egy könyvtár sem tartalmaz ACL szerinti jogosultság beállítást:

feri@columbo:~$ getfacl demo
# file: demo
# owner: feri
# group: feri
user::rwx
group::rwx
other::r-x

Most a hallgatok csoport számára teljes hozzáférést adok a könyvtárra. A forma ugyanaz, mint amit a felhasználó esetében láttál, a group kulcsszóval jelzem, hogy csoport hozzáférést adok meg, ezt a csoport neve követi, majd a megadom a módosítani kívánt könyvtár nevét:

feri@columbo:~$ setfacl -m group:hallgatok:rwx demo

A jogosultságokat leíró blokk mögötti + jel jelzi, hogy érvényes ACL beállítások vannak a könyvtáron:

feri@columbo:~$ ls -ld demo
drwxrwxr-x+ 4 feri feri 4096 aug    6 18:44 demo

Ezek lekérdezése a már látott módon történik, látható, hogy a hallgatók csoport is megjelent teljes hozzáférési jogkörrel.

feri@columbo:~$ getfacl demo
# file: demo
# owner: feri
# group: feri
user::rwx
group::rwx
group:hallgatok:rwx
mask::rwx
other::r-x

Ha egy fájlról vagy könyvtárról teljes egészében törölni szeretnéd az ACL szerinti jogosultságokat, használd a -b kapcsolót! Az alábbi példában elvégzem ezt a törlést, ez után az ls -l kimenetében az ACL létét jelző + jel el is tűnt.

feri@columbo:~$ setfacl -b demo
feri@columbo:~$ ls -ld demo
drwxrwxr-x 4 feri feri 4096 aug    6 18:44 demo

4.3.3. Default ACL

Könyvtárak esetén lehetőség van arra, hogy alapértelmezett jogsultságokat határozz meg. Egy újabb könyvtár létrehozásakor a gyermek könyvtár örökölni fogja a szülő könyvtár ACL bejegyzéseit és az öröklődés beállításait is. Új fájl lértehozásakor a könyvtár ACL-jei érvényesek lesznek a létrehozott fájl esetén is. Az alapértelmezett ACL beállításához a -m mellett a -d kapcsolót kell használni:

feri@columbo:~$ setfacl -d -m group:hallgatok:rwx demo

Nézzük meg, milyen beállítások vannak érvényben! látható, hogy megjelentek a default kezdetű sorok, ezek írják le az alapértelmezett jogosultságokat.

feri@columbo:~$ getfacl demo
# file: demo
# owner: feri
# group: feri
user::rwx
group::rwx
other::r-x
default:user::rwx
default:group::rwx
default:group:hallgatok:rwx
default:mask::rwx
default:other::r-x

Nézzük meg a default értékek hatását! Létrehozok egy új könyvtárat a demo könyvtáron belül. Azt várom, hogy a default ACL beállítások miatt erre is érvényes lesz a hallgatók csoport teljes hozzáférése, ezt a tartalomjegyzékben szereplő + karakter jelzi is:

feri@columbo:~$ mkdir demo/aclteszt
feri@columbo:~$ ls -ld demo/aclteszt/
drwxrwxr-x+ 2 feri feri 4096 aug    7 08:33 demo/aclteszt/

Lássuk az ACL szerinti jogosultságait! Működik, örökölte azokat, és a default beállításokat is!

feri@columbo:~$ getfacl demo/aclteszt/
# file: demo/aclteszt/
# owner: feri
# group: feri
user::rwx
group::rwx
group:hallgatok:rwx
mask::rwx
other::r-x
default:user::rwx
default:group::rwx
default:group:hallgatok:rwx
default:mask::rwx
default:other::r-x

Most létrehozok egy fájlt, lássuk, ennek hogy alakulnak a jogosultságai! A + karakter jelzi, hogy annak ellenére, hogy nem állítottam be ACL szerinti jogosultságot, már van érvényben ilyen:

feri@columbo:~$ touch demo/acltesztfile.txt
feri@columbo:~$ ls -l demo/acltesztfile.txt
-rw-rw-r--+ 1 feri feri 0 aug    7 08:41 demo/acltesztfile.txt

Lássuk, milyen jogai vannak:

feri@columbo:~$ getfacl demo/acltesztfile.txt
# file: demo/acltesztfile.txt
# owner: feri
# group: feri
user::rw-
group::rwx                      #effective:rw-
group:hallgatok:rwx             #effective:rw-
mask::rw-
other::r--

Az eredmény az, amit vártunk, a könyvtár default ACL jogosultságai öröklődtek az abban létrejövő fájlra is, a hallgatok csoport tagjai automatikusan teljes hozzáféréssel rendelkeznek azon.

4.3.4. A mask

A fenti példákban látható volt, hogy az ACL szabályokban szerepel egy mask kezdetű sor is. Ezt nem fontos használnod, de a jelentésével érdemes tisztában lenned, bizonyos helyzetekben sok munkától kímélhet meg.

A maszkban megadott jogok az Egyéb felhasználó, Tulajdonoscsoport és az Egyéb csoport esetében jelenthetnek korlátozást. Ezek esetében az adott jog csak akkor érvényesül, ha az a maszkban is megvan. Ha egy jog csak a maszkban, vagy csak a megfelelő bejegyzésben szerepel, akkor a jog nem lesz érvényes. Egy példán keresztül nézzük meg a maszk gyakorlati használatát!

Először törlök minden ACL bejegyzést a demo könyvtárról, hogy a korábban beállított öröklési szabály ne zavarjon.

feri@columbo:~$ setfacl -b demo

Ellenőrizzük! Nincs + karakter a jogosultságokat leíró blokk végén, tehát nincsenek élő ACL bejegyzések a könyvtárra.

feri@columbo:~$ ls -ld demo
drwxrwxr-x 3 feri feri 4096 aug    7 21:30 demo

A demo könyvtárban van egy hello.txt nevű szövegfájl, lássuk, hogy cartman nevű felhasználó tudja-e olvasni ennek tartalmát! A jogosultságok áttekintésével látszik, hogy a tulajdonos (feri) és a csoport (feri) képes erre, más felhasználók számára ez nem áll rendelkezésre. Feltéve, hogy cartman nem tagja a feri csoportnak, a cartman nem fér hozzá a fájl tartalmához.

feri@columbo:~$ ls -l demo/hello.txt
-rw-r----- 1 feri feri 13 aug    7 21:30 demo/hello.txt

Egy ellenőrzés során látszik, hogy ez tényleg így van:

cartman@columbo:/home/feri/demo$ cat hello.txt
cat: hello.txt: Engedély megtagadva

Most beállítom, hogy cartman felhasználónak legyen olvasási joga ezen a fájlon:

feri@columbo:~$ setfacl -m user:cartman:r demo/hello.txt
feri@columbo:~$ getfacl demo/hello.txt
# file: demo/hello.txt
# owner: feri
# group: feri
user::rw-
user:cartman:r--
group::r--
mask::r--
other::---

Lássuk, képes-e cartman hozzáférni a fájl tartalmához!

cartman@columbo:/home/feri/demo$ cat hello.txt
Hello World!

Az eredmény az, amit vártunk, az ACL szabály felvétele után már számára is megjelenik a fájl tartalma.

Lássuk, hogyan befolyásolja ezt a helyzetet a maszk! Ha a fenti példában megnézed, láthatod, hogy annak most r-- az értéke. Mivel a maszkban is szerepel az r és cartman jogaiban is, ezért ez a jog érvényre jut. Ha azonban a maszkból kiveszem az r jogot, akkor a fentiek értelmében cartman már nem tudja olvasni a fájlt, mert az csak a saját jogaiban szerepel, a maszkban nem:

feri@columbo:~$ setfacl -m mask:--- demo/hello.txt
feri@columbo:~$ getfacl demo/hello.txt
# file: demo/hello.txt
# owner: feri
# group: feri
user::rw-
user:cartman:r--                #effective:---
group::r--                      #effective:---
mask::---
other::---

Az #effective sorokban az adott jog és a maszk együtteséből adódó eredő jog (effektív jog) jelenik meg, ez segít a kimenet gyorsabb értelmezésében. Egy gyors ellenőrzés, és látható, cartman valóban nem fér hozzá a fájl tartalmához, a maszkban levő r jog hiánya ezt megakadályozta.

cartman@columbo:/home/feri/demo$ cat hello.txt
cat: hello.txt: Engedély megtagadva

Tip

  • A maszkot általában arra használjuk, hogy jogosultságokat átmenetileg megvonjunk. Segítségével nem kell a tényleges jogokat elvenni, csupán a maszkot módosítva egyetlen paranccsal elérni a tiltást.
  • A fenti példában hiába engedélyeztem volna a maszkban az írás jogot, ez szintén nem jutott volna érvényre azért, mert cartmannek csak olvasási joga van. Emlékezz, az effektív jog a maszk és a meglevő jog együtteséből áll elő.
  • A kiterjesztett attribútumok nem feltétlenül használhatók a telepítés után. Egyrészt telepíteni kell az acl csomagot (a telepítésről Csomagkezelés fejezetben olvashatsz. Emellett a fájlrendszer csatolásakor meg kell adni a acl opciót (erről bővebben a Fájlrendszerek csatolása fejezetben).

4.4. Attribútumok

A Linuxok esetében – attól függően, hogy milyen fájlrendszert használsz – lehetőséged van az ún. attribútumok használatára is. A gyakran használt fájlrendszerek (ext2, ext3, ext4, XFS) képesek ezek kezelésére, ezért érdemes ismerni a használatukat.

4.4.1. lsattr

Azt, hogy egy fájlra milyen attribútumokat állítottak be, a lsattr paranccsal nézheted meg. A következő példában a szamol nevű fájl attribútumait kérdezem le:

feri@columbo:~/demo$ lsattr szamol
-------------e-- szamol

A parancs kimenete szerint egyetlen attribútum, az e-vel jelölt van bekapcsolva ezen a fájlon.

Az lsattr paraméter nélkül az aktuális könyvtár összes fáljának attribútumait megjeleníti. A -R itt is a rekurziót jelenti, nem csak a meghatározott könyvtárra, hanem annak összes könyvtárára is vonatkozik.

4.4.2. chattr

Az attribútumok módosítása a chattr paranccsal végezhető el. Paraméterként meg kell adnod, hogy melyik attribútumot hogyan akarod beállítani, és azt is, hogy melyik fájlon vagy fájlokon. Egy egyszerű példa: