Linux-bestandsrechten uitgelegd: chmod 755, 644 & 777

Linux-bestandsrechten bepalen wie elk bestand en elke map op het systeem mag lezen, schrijven of uitvoeren. Elk item heeft drie klassen gebruikers (de eigenaar, een groep en alle anderen), en elke klasse krijgt drie rechtenbits: lezen (r), schrijven (w) en uitvoeren (x). Dat zijn negen bits per bestand. chmod stelt ze in, en de afkorting die je overal ziet is octaal: de rwx van elke klasse valt samen tot één cijfer van 0 tot 7 (lezen 4 + schrijven 2 + uitvoeren 1).

Drie modi dekken vrijwel alles wat je ooit zult typen:

• 755 (rwxr-xr-x) — mappen en scripts: de eigenaar kan ze wijzigen, alle anderen kunnen ze lezen en uitvoeren.
• 644 (rw-r--r--) — gewone bestanden: de eigenaar schrijft, alle anderen lezen.
• 777 (rwxrwxrwx) — volledige toegang voor iedereen. Bijna altijd fout; het is een beveiligingslek, geen oplossing.

Wissel elke combinatie in de gratis chmod-calculator en zie hoe het octale getal, de rwx-string en het exacte commando samen meebewegen. De rest van deze gids legt uit hoe die getallen werken en waar elk getal thuishoort.

Linux-bestandsrechten in 30 seconden

Octaal	Symbolisch	Typisch gebruik
400	r--------	SSH-privésleutel, alleen-lezen
600	rw-------	Privébestanden, SSH-sleutels, .env
644	rw-r--r--	Webpagina’s, config, de meeste bestanden
700	rwx------	Privémappen (~/.ssh)
755	rwxr-xr-x	Scripts, binaries, webmappen
775	rwxrwxr-x	Groepsgedeelde mappen
777	rwxrwxrwx	Iedereen, alles — vermijden
1777	rwxrwxrwt	Gedeelde tijdelijke mappen zoals /tmp

Vuistregel: 644 voor bestanden, 755 voor mappen, en van daaruit strakker. Versoepel een modus alleen wanneer er iets concreets kapotgaat; doe het nooit preventief.

Het rechtenmodel: eigenaar, groep, anderen

Drie klassen delen één bestand. De eigenaar (meestal wie het heeft aangemaakt), één groep, en anderen, oftewel elk account dat noch de eigenaar noch lid van de groep is. Elke klasse krijgt onafhankelijk lezen, schrijven en uitvoeren:

• lezen (r) — de inhoud van een bestand bekijken, of de items van een map opsommen.
• schrijven (w) — een bestand wijzigen, of items in een map toevoegen en verwijderen.
• uitvoeren (x) — een bestand als programma uitvoeren, of een map binnengaan (er met cd in gaan).

De valkuil waar mensen over struikelen: bij een map betekenen de bits iets anders. r laat je namen opsommen, w laat je items binnenin aanmaken en verwijderen, en x laat je de map doorlopen om de onderliggende bestanden te bereiken, zodat je er met cd in kunt. Je kunt r zonder x op een map hebben, er ls op draaien en toch “Permission denied” krijgen op het moment dat je hem probeert binnen te gaan. Precies daarom zijn mappen 755 en geen 644.

Een ls -l-regel lezen

Draai ls -l en elk item begint met een blok van tien tekens:

$ ls -l
-rw-r--r--  1 jack staff  1400 Jul 17 10:00 index.html
drwxr-xr-x  5 jack staff   160 Jul 17 10:00 assets

Lees hem van links naar rechts. Het eerste teken is het bestandstype, geen recht: - is een gewoon bestand, d een map, l een symlink, c of b een apparaat, p een named pipe, s een socket. De volgende negen tekens zijn drie groepen rwx: eigenaar, groep, anderen. Dus -rw-r--r-- is een gewoon bestand waarbij de eigenaar leest en schrijft (rw-) terwijl groep en anderen alleen lezen (r-- r--), oftewel 644. drwxr-xr-x is een map op 755.

Sommige systemen plakken een markering achter de negen bits. Een afsluitende . duidt op een SELinux-context, een + betekent dat een ACL regels toevoegt bovenop de basisbits, en op macOS markeert een @ uitgebreide attributen. Geen daarvan verandert het octale getal. Negeer de markering en lees de negen tekens.

Octale notatie: hoe 755 rwxr-xr-x wordt

Octale bestandsrechten werken doordat elk recht een macht van twee is:

• lezen = 4
• schrijven = 2
• uitvoeren = 1

Tel de bits op die een klasse heeft en je krijgt het cijfer ervan. rwx is 4 + 2 + 1 = 7. r-x is 4 + 1 = 5. r-- is 4. Dus rwxr-xr-x lees je, per drietal, als 7 5 5. Doe hetzelfde voor rw-r--r-- en je krijgt 4 + 2, 4, 4 → 644. Dat is de hele truc; octale rechten zijn niet meer dan drie onafhankelijke sommen.

De rechtencijfers 0–7 in één oogopslag

Cijfer	Binair	Rechten
0	000	Geen rechten
1	001	Alleen uitvoeren
2	010	Alleen schrijven
3	011	Schrijven + uitvoeren
4	100	Alleen lezen
5	101	Lezen + uitvoeren
6	110	Lezen + schrijven
7	111	Lezen + schrijven + uitvoeren

Octaal is simpelweg grondtal 8, dus elk cijfer stopt drie bits zonder overlap in de volgende klasse. Als het positionele rekenwerk wat weggezakt is, laat talstelsel omrekenen zien hoe grondtal 8 op binair aansluit, net zoals elk rechtencijfer dat doet.

chmod 755 vs 644 vs 777: de modi die je echt zult typen

Deze tabel zet chmod 755 vs 644 vs 777 direct tegenover elkaar:

Octaal	Symbolisch	Eigenaar	Groep	Anderen	Typisch gebruik	Risico
644	rw-r--r--	lezen/schrijven	lezen	lezen	Gewone bestanden	Veilige standaard
755	rwxr-xr-x	alles	lezen/uitvoeren	lezen/uitvoeren	Mappen, scripts	Veilige standaard
600	rw-------	lezen/schrijven	—	—	Privébestanden, sleutels	Zeer veilig
700	rwx------	alles	—	—	Privémappen	Zeer veilig
775	rwxrwxr-x	alles	alles	lezen/uitvoeren	Groepsgedeelde mappen	Groep kan schrijven
777	rwxrwxrwx	alles	alles	alles	(vermijden)	Wereldwijd schrijfbaar

Het verschil tussen 755 en 644 is één enkele bit: uitvoeren. Mappen, scripts en binaries hebben x nodig om binnengegaan of uitgevoerd te worden, dus die komen op 755 uit. Een gewoon bestand zoals een HTML-pagina, een afbeelding of een config heeft geen reden om uitvoerbaar te zijn, dus dat blijft op 644. Die twee door elkaar halen zit achter de meeste alledaagse rechtenfouten.

Waarom 777 gevaarlijk is. Het geeft schrijftoegang aan elk account op de machine, inclusief een gecompromitteerd serviceaccount of een gekaapt webproces. Een wereldwijd schrijfbare document-root is de klassieke route naar een bekladde website of geïnjecteerde malware, omdat iedereen die er toegang toe krijgt jouw code kan overschrijven. Wanneer een forumpost zegt dat je ergens chmod 777 op moet toepassen “om het werkend te krijgen”, is het echte probleem vrijwel altijd eigenaarschap, dat hieronder aan bod komt.

De uitzondering 1777. /tmp is bewust wereldwijd schrijfbaar, maar met een vangnet. Modus 1777 voegt de sticky bit toe, waarmee iedereen bestanden kan aanmaken terwijl gebruikers geen bestanden kunnen verwijderen of hernoemen die niet van henzelf zijn. Daarom zijn gedeelde tijdelijke mappen veilig op 1777 maar nooit op kaal 777. Typ 777 in de chmod-calculator en het risicopaneel markeert het direct, terwijl 1777 wordt herkend als het standaardpatroon voor gedeelde mappen.

Numerieke vs symbolische modus

chmod neemt dezelfde bits op twee manieren aan.

De numerieke (absolute) modus benoemt het volledige resultaat. chmod 755 file zet alle negen bits op rwxr-xr-x, ongeacht wat er eerder stond. Dit is wat je wilt in scripts en bij deployment, waar je een bekende, goede staat afdwingt.

De symbolische (relatieve) modus beschrijft een wijziging. chmod u+x file zet één bit om (uitvoeren toevoegen voor de eigenaar) en laat de rest ongemoeid. chmod u=rwx,go=rx file stelt hele klassen expliciet in. De symbolische modus past bij eenmalige aanpassingen waarbij de hele modus opnieuw benoemen overdreven zou zijn.

# Numeric: overwrite the whole mode
$ chmod 644 report.txt

# Symbolic: change only what you name
$ chmod u+x deploy.sh        # add execute for the owner
$ chmod go-w shared.conf     # remove write from group and others
$ chmod u=rw,go=r notes.md   # set each class explicitly → 644

Eén valkuil bij de symbolische modus: chmod +x zonder klasse wordt gefilterd door je umask. Met de gangbare umask 022 voegt chmod +x script.sh uitvoeren voor iedereen toe, dus dat komt overeen met chmod a+x. Onder een strengere umask zoals 077 raakt het alleen de eigenaar. Wil je een gegarandeerde uitkomst, benoem dan de klasse: u+x voor alleen de eigenaar, a+x voor iedereen.

Speciale rechten: setuid, setgid en de sticky bit

Naast de negen standaardbits draagt een vierde, voorloop-octaal cijfer drie speciale modi, het trio setuid, setgid en sticky bit:

• setuid = 4000 — het programma draait met de rechten van de bestandseigenaar, niet die van de aanroeper. Zo laat passwd, eigendom van root, een gewone gebruiker een door root beheerde wachtwoorddatabase bijwerken.
• setgid = 2000 — hetzelfde idee voor de groep. Op een map zorgt het er ook voor dat nieuwe bestanden de groep van de map erven, wat een gedeeld project consistent in groepseigendom houdt.
• sticky bit = 1000 — op een gedeelde map beperkt het verwijderen zodat gebruikers alleen hun eigen bestanden kunnen weghalen. /tmp op 1777 is het klassieke voorbeeld.

$ chmod 4755 /usr/local/bin/mytool   # setuid
$ chmod 2775 /srv/shared             # setgid on a shared dir
$ chmod 1777 /tmp                     # sticky bit
$ ls -l /usr/bin/passwd
-rwsr-xr-x 1 root root 59976 Jul 17 10:00 /usr/bin/passwd

De hoofdletterregel voor s/S en t/T

In ls -l hergebruiken de speciale bits de uitvoeren-plek, en de hoofdletter vertelt je of uitvoeren ook is gezet. Een kleine letter s (setuid/setgid) of t (sticky) betekent dat de speciale bit én uitvoeren aanstaan, het normale geval. Een hoofdletter S of T betekent dat de speciale bit is gezet maar uitvoeren niet, wat meestal een vergissing is, omdat een speciale bit op een niet-uitvoerbaar bestand niets nuttigs doet.

Vergelijk rwsr-xr-x (4755, setuid met uitvoeren, correct) met rwSr--r-- (4644, setuid zonder uitvoeren, verdacht). Zie je een hoofdletter S of T, controleer dan of iemand per ongeluk de uitvoeren-bit heeft laten vallen.

De GNU-mapvalkuil die niemand noemt

Dit is het platformverschil dat vrijwel elke tutorial verkeerd heeft. Op Linux (GNU coreutils) wist een numerieke chmod 755 dir een bestaande setuid- of setgid-bit op die map niet. Het behoudt hem. Als een map al 2755 (setgid) is en je draait chmod 755 in de verwachting van een schone lei, dan blijft de setgid-bit staan en is de map in werkelijkheid nog steeds 2755.

Om hem echt te wissen, wees expliciet:

$ chmod 00755 dir      # five-digit form zeroes the special digit
$ chmod =755 dir       # = clears every bit not listed
$ chmod u-s,g-s dir    # remove setuid and setgid by name

BSD en macOS doen het omgekeerde: een numerieke chmod 755 wist de speciale bits standaard. Zo gedraagt een deployscript dat rechten “reset” met chmod -R 755 zich anders op een Mac-laptop dan op een Linux-server. Dit behoud is gedocumenteerd in de GNU coreutils-handleiding; bij twijfel gebruik je de vijfcijferige of de u-s,g-s-vorm, zodat de uitkomst overal identiek is.

umask: wat nieuw aangemaakte bestanden krijgen

Je past zelden met de hand chmod toe op elk bestand; de meeste krijgen hun modus bij aanmaak, en umask bepaalt die. Een umask is een set bits om uit te schakelen. Nieuwe bestanden beginnen bij grondwaarde 666 en nieuwe mappen bij 777, en de umask maskeert bits weg:

effective mode = base & ~umask

Bestanden beginnen bij 666, niet 777, omdat een gloednieuw bestand standaard niets te zoeken heeft als uitvoerbaar bestand. Die bit voeg je bewust toe met chmod +x.

umask	Nieuwe bestanden	Nieuwe mappen	Betekenis
022	644	755	Standaard — anderen lezen, schrijven niet
077	600	700	Privé voor de eigenaar
002	664	775	Groepssamenwerking

Werk de standaard 022 met de hand uit: 666 & ~022 = 666 & 755 = 644, en 777 & ~022 = 755. Controleer je huidige waarde met umask, en stel een sessiestandaard in met bijvoorbeeld umask 077 op een machine waar niets voor de groep of wereldwijd leesbaar zou moeten zijn.

chmod vs chown: rechten vs eigenaarschap

chmod en chown beantwoorden verschillende vragen. chmod verandert wat de eigenaar, groep en anderen mogen doen: de rechtenbits. chown verandert wie de eigenaar en groep daadwerkelijk zijn. Naar 777 grijpen is vaak een eigenaarschapsprobleem in een rechtenkostuum.

Het klassieke geval: een webserver die als www-data draait kan niet naar zijn uploadmap schrijven. chmod 777 laat de fout verdwijnen door de hele wereld te laten schrijven, en laat een gat achter. De juiste oplossing wijst eigenaarschap toe aan het proces dat het nodig heeft:

# Wrong: opens the directory to every account on the box
$ sudo chmod -R 777 /var/www/uploads

# Right: give it to the web user, keep a tight mode
$ sudo chown -R www-data:www-data /var/www/uploads
$ sudo find /var/www/uploads -type d -exec chmod 755 {} +
$ sudo find /var/www/uploads -type f -exec chmod 644 {} +

Diagnostische volgorde wanneer iets onverwacht onleesbaar is: draai eerst ls -l om te zien wie de eigenaar is, decodeer daarna de modus, en beslis dan of de oplossing chown, chmod, of het toevoegen van een gebruiker aan een groep is.

Recursieve rechten goed aangepakt

Een botte chmod -R 755 . markeert elk gewoon bestand als uitvoerbaar, wat op zijn best ruis is en op zijn slechtst een stil risico. Recurseer in plaats daarvan per type:

$ find . -type d -exec chmod 755 {} +   # directories → 755
$ find . -type f -exec chmod 644 {} +   # files → 644

GNU chmod biedt een oplossing in één regel met de hoofdletter X, die uitvoeren alleen toevoegt aan mappen en aan bestanden die al een uitvoeren-bit dragen:

$ chmod -R u+rwX,go+rX .

De chmod-calculator genereert de find-commando’s voor alleen mappen en alleen bestanden voor elke modus die je kiest, zodat je de juiste splitsing kunt kopiëren in plaats van naar een kaal -R te grijpen.

Aanbevolen aanpak voor Linux-bestandsrechten

• Geef de minste rechten die werken. Begin met de strakste modus en open alleen wat kapotgaat. Elke extra schrijfbit is aanvalsoppervlak.
• Kies standaard 644-bestanden binnen 755-mappen. Dit duo bedient vrijwel elke web-root en repository-checkout. Gewone bestanden hebben zelden uitvoeren nodig; mappen altijd.
• Laat nooit 777 staan op iets wat een server kan bereiken. Als meerdere accounts moeten schrijven, gebruik dan een gedeelde groep met 775 of 2775 (setgid houdt het groepseigendom consistent) in plaats van de modus voor de hele wereld open te zetten.
• Houd SSH-privésleutels op 600, of 400 zodra ze definitief zijn. OpenSSH weigert privésleutels die voor de groep of wereldwijd leesbaar zijn ronduit. Zie de OpenSSH-handleiding voor de exacte eis aan het sleutelbestand. Publieke sleutels en authorized_keys zijn prima op 644.
• Stapel bestandsmodi op andere maatregelen. Rechten vormen de basis; combineer ze met basisauthenticatie uit de htpasswd-generator wanneer een map een login nodig heeft, en behandel bestandsmodi als één onderdeel van het geheel dat onze gids essentiële webbeveiliging behandelt.

FAQ

Wat betekent de d of l aan het begin van drwxr-xr-x?

Het eerste teken in een ls -l-regel is het bestandstype, geen recht. d markeert een map, l een symlink, - een gewoon bestand, c of b een apparaat, p een named pipe, en s een socket. Alleen de negen tekens erna coderen de daadwerkelijke lees-, schrijf- en uitvoeren-bits.

Wat is het verschil tussen een kleine letter s en een hoofdletter S in rechten?

Een kleine letter s en een hoofdletter S betekenen allebei dat de setuid- of setgid-bit is gezet. Een kleine letter s betekent dat uitvoeren ook is gezet, het normale werkgeval. Een hoofdletter S betekent dat de speciale bit aanstaat maar uitvoeren uit (zoals in 4644), wat vrijwel altijd een misconfiguratie is, aangezien een speciale bit zinloos is zonder uitvoeren.

Wat is umask en hoe bepaalt het de standaardrechten?

umask is de set rechtenbits die uit wordt gezet wanneer een bestand wordt aangemaakt. Nieuwe bestanden beginnen bij grondwaarde 666 en mappen bij 777, waarna effective = base & ~umask de gemaskeerde bits verwijdert. De standaard 022 levert 644-bestanden en 755-mappen op; draai umask om die van jou te zien, of umask 077 voor een meer private standaard.

Wanneer moet ik 400 of 700 gebruiken in plaats van 644 of 755?

Gebruik 400 of 700 wanneer een bestand of map volledig privé moet blijven. 400 (r--------) is een alleen-lezen privébestand, ideaal voor een definitieve SSH-privésleutel die je nooit bewerkt. 700 (rwx------) is een map die alleen de eigenaar kan binnengaan, zoals ~/.ssh of ~/.gnupg. Anders dan 644 en 755 geven ze niemand anders iets.

Waarom kan ik een map wel opsommen maar er niet met cd in?

Maprechten scheiden opsommen van doorlopen: de r-bit laat je namen opsommen, de x-bit laat je binnengaan. Een map met r maar zonder x (een 644-map) toont zijn namen onder ls maar blokkeert cd en elke toegang tot de bestanden erin. Voeg uitvoeren toe (maak er 755 van) om hem betreedbaar te maken.

Werken bestandsrechten hetzelfde op macOS als op Linux?

Bestandsrechten delen op beide hetzelfde kern-rwx- en octale model, omdat beide POSIX volgen, maar de details verschillen. BSD en macOS wissen bij een numerieke chmod standaard de setuid/setgid van een map, terwijl Linux die behoudt. Een modus lezen verschilt ook: stat -c '%a' file op Linux, stat -f '%Lp' file op macOS, en macOS voegt ACL’s en file flags toe.

Kan ik bestandsrechten wijzigen zonder de commandoregel?

Je kunt rechten berekenen en decoderen zonder terminal. Met de gratis chmod-calculator vink je een rechtenmatrix aan, typ je een octale waarde of plak je een ls -l-regel, waarna hij het exacte chmod-commando terugkopieert. Om het op een echt bestand toe te passen heb je nog steeds dat commando op de server nodig, of een GUI- of FTP-client die rechtenvelden toont.