Linux File Permissions

Features

• Three notations, all interchanged: octal (755 / 0755 / 0o755), symbolic (u+x,g-w,o=r) and the ls -l string (-rwxr-xr-x / drwxr-xr-x)
• Every bit explained: what owner, group and others can read, write or execute
• The three special bits explained: setuid, setgid (on a directory it means group inheritance), sticky (on a directory, only the owner may delete)
• ⚠️ An uppercase S or T is flagged on its own — it means the special bit is set but the file is not executable, which is nearly always a mistake
• Defaults for new files (666 & ~umask) and directories (777 & ~umask) derived from the umask
• A ready-to-paste chmod command as well; when the input is a whole command, its paths and flags such as -R are carried through
• When a symbolic form omits the who (just +x), it works from the base permission you set rather than guessing your umask
• Supports copy-from-another-class assignments such as `g=u`: `=` clears before setting, and clauses apply left to right within one command (`u=x,g=u` and `g=u,u=x` differ)
• ⚠️ When the input is unrecognised the error points at the exact character (which one, what it is, the nearby text), not a vague “bad format”

How to use

1. Paste the permission in: octal, symbolic, or the ls -l string — all three work
2. Adjust the base permission (used by symbolic input that omits the who) and the umask if you want
3. The result gives the other two notations, a bit-by-bit explanation and the chmod command

FAQ

Is 755 different from 0755?

No. The leading `0` only marks the literal as octal (in C and shell, so it is not read as decimal or hex). Everything here is printed with four digits so the two forms never look like they differ. A two-digit `77` is rejected, though: it could be a mistyped `077` or `0077`, and those differ by two whole permission classes — a guess would open a hole you cannot see.

What is the difference between rwxr-xr-x and -rwxr-xr-x?

The first is the nine permission characters; the second adds the leading type character, where `-` is a regular file, `d` a directory and `l` a symlink. The type plays no part in the permission arithmetic, but it does change how the sticky bit reads — so both are accepted here, and the `d` is kept in the output.

Is setgid not for executables?

On a file it means running with the file’s group. ⚠️ On a directory it means something else: new entries inside inherit the directory’s group rather than the creator’s primary group. That second behaviour is what makes shared directories work, and it is the one people forget.

Why is my new file not 644?

New files default to `666 & ~umask` and new directories to `777 & ~umask`. Files start from 666 because a newly created regular file should not be executable by default; directories start from 777 because a directory you cannot execute is a directory you cannot enter. So umask 022 gives 644 and 755, and umask 077 gives 600 and 700.

What is the u in u+x, and what happens if I leave it out?

`u` is the file’s owner, `g` its group, `o` everyone else, and `a` all three. When the who is omitted (just `+x`), real `chmod` applies it according to your umask — which is process state, not a fixed value. So this tool does not guess it: it uses the base permission you set above and says so.

What is the difference between X and x?

`x` sets the execute bit unconditionally; `X` sets it only when the target is a directory or something already has an execute bit. `chmod -R a+X` is the usual form — let directories be entered without turning every data file inside them executable. This tool cannot know whether the target is a directory, so it uses the second condition.

What does g=u mean?

The right-hand side of an operator may be a class (`u`/`g`/`o`), meaning copy another class’s permissions: `g=u` copies the owner’s rwx bits to the group, and combinations such as `u=g,o=g` work too. ⚠️ Two things are easy to get wrong: ① `=` clears before it sets, so group bits the owner does not have are removed rather than OR-ed in; ② clauses apply left to right within one command, and the source class is read as of that point — so `u=x,g=u` (g sees the new u=1) differs from `g=u,u=x` (g sees the old u). Special bits are not copied.