Chmod Calculator

The Chmod Calculator is a free online tool for working with Unix/Linux file permissions. Calculate the octal number (like 755 or 644) for any combination of read/write/execute permissions for owner, group, and others. Convert between symbolic notation (rwxr-xr-x), octal notation (755), and long listing format (as shown by ls -l). Perfect for sysadmins setting file permissions, developers debugging permission-denied errors, and anyone learning Unix/Linux file system security.

File permissions are the foundation of Unix security. Every file and directory on Linux, macOS, BSD, or WSL has a mode — a set of permission bits telling the operating system who can read, write, or execute it. Get permissions wrong and your web server shows "403 Forbidden", your script refuses to run, or a file becomes world-writable (a security disaster). Get them right and your system is secure and functional. This calculator makes the octal-symbolic mapping instant and visual, plus it explains what each permission combination means in practice. Includes setuid, setgid, and sticky bit special permissions. All calculations are pure math — nothing is uploaded anywhere.

Unix/Linux file permissions use a 12-bit mode stored with each file's inode. The mode is traditionally shown in octal (base-8) because 3 bits fit perfectly in one octal digit.

The three permission bits:

- r (read) — bit value 4 — view file contents or list directory contents
- w (write) — bit value 2 — modify file or create/delete files in directory
- x (execute) — bit value 1 — run file as program, or enter directory

Three permission sets (in order):

- Owner (user, u) — the user who owns the file
- Group (g) — the group assigned to the file
- Others (o) — everyone else

Octal permission calculation:

Each set of 3 bits (rwx) becomes one octal digit. Add the values of the bits that are set:

- rwx = 4+2+1 = 7
- rw- = 4+2+0 = 6
- r-x = 4+0+1 = 5
- r-- = 4+0+0 = 4
- -wx = 0+2+1 = 3
- -w- = 0+2+0 = 2
- --x = 0+0+1 = 1
- --- = 0+0+0 = 0

Combine three digits for owner-group-others: 755 = rwx r-x r-x, 644 = rw- r-- r--.

Common permission values:

| Octal | Symbolic | Use case |
|---|---|---|
| 755 | rwxr-xr-x | Executable files, directories (standard) |
| 644 | rw-r--r-- | Regular files (readable, only owner writes) |
| 600 | rw------- | Private files, SSH keys |
| 700 | rwx------ | Private executable, owner-only directory |
| 777 | rwxrwxrwx | Avoid — world-writable, security risk |
| 666 | rw-rw-rw- | Avoid — world-writable files |
| 400 | r-------- | Read-only, owner-only (e.g., SSH private key) |
| 000 | --------- | No permissions (files effectively inaccessible) |

Special permission bits (additional octal digit prefix):

- setuid (4xxx) — when executed, runs with owner's privileges (e.g., /usr/bin/sudo is 4755 = setuid root)
- setgid (2xxx) — when executed, runs with group's privileges; on directories, new files inherit the directory's group
- sticky bit (1xxx) — in a directory, only the file owner can delete files (used on /tmp = 1777)

Umask:

The umask subtracts permissions from newly-created files. A umask of 022 means new files get 666 & ~022 = 644 (for files) and 777 & ~022 = 755 (for directories). Default umask on most systems is 022 or 002.

Symbolic chmod commands:

``bash
chmod u+x script.sh # Add execute for owner
chmod g-w file.txt # Remove write for group
chmod o=r file.txt # Set others to read-only
chmod ugo+x script.sh # All can execute
chmod a+x script.sh # Same as ugo+x (a = all)
chmod -R 755 my_dir/ # Recursive change
``

Octal vs Symbolic notation: Octal (755) is compact and fast for experienced sysadmins. Symbolic (u=rwx,g=rx,o=rx) is more explicit and readable. Both produce the same result. Octal sets absolute permissions; symbolic supports relative changes (+x adds, -x removes). Scripts often use octal; teaching often uses symbolic.

chmod vs chown vs chgrp: chmod changes permissions. chown changes file owner. chgrp changes file group. All three may be needed to fully control access. Often: chown user:group file && chmod 644 file.

POSIX permissions vs ACLs: POSIX permissions (owner, group, others) handle simple cases. ACLs (Access Control Lists) via setfacl allow per-user and per-group permissions for complex scenarios. Use POSIX when possible; ACLs when you need finer control.

Unix permissions vs Windows ACLs: Windows uses a fundamentally different permission model (full ACLs, no concept of owner/group/others bits). WSL translates between them. NTFS mounted in Linux may show rwxrwxrwx regardless of real permissions — the kernel doesn't map NTFS ACLs to POSIX.

chmod vs attrib (Windows): Windows attrib is the closest equivalent but much more limited — handles read-only, hidden, system attributes. Windows permission management is done via the Properties dialog, icacls, or PowerShell.

Container file permissions: Docker images preserve permissions when COPY/ADD. But UID/GID inside containers may differ from the host. Use chown in your Dockerfile to align UIDs if needed.