Calculate Linux/Unix file permissions visually. Convert between octal (755) and symbolic (rwxr-xr-x) notation instantly with an interactive checkbox interface — free online tool for DevOps and sysadmins.
| Role | Read (r) | Write (w) | Execute (x) | Value |
|---|---|---|---|---|
| Owner | 0 | |||
| Group | 0 | |||
| Others | 0 |
chmod 755 filename -rwxr-xr-x Chmod Calculator is a free visual tool for calculating Linux and Unix file permissions. It converts between octal notation (like 755) and symbolic notation (like rwxr-xr-x) instantly, with an interactive checkbox grid that makes it easy to understand exactly what each permission bit does. Whether you're configuring a web server, setting up SSH keys, or deploying scripts, this tool eliminates the guesswork from file permission management. It also supports special permission bits: setuid, setgid, and sticky bit.
Use the Chmod Calculator whenever you need to set or verify file permissions on Linux/Unix systems. It's especially useful when configuring web server document roots (directories need 755, files need 644), securing SSH keys (must be 600), setting up deployment scripts (need execute permission), or debugging "Permission denied" errors. The visual checkbox interface is faster and less error-prone than memorizing octal values.
DevOps engineers use this tool to configure permissions for CI/CD deployment scripts, Docker volumes, and Kubernetes mounted configs. System administrators use it to audit file permissions across server directories, set up shared directories with appropriate group permissions, and configure the sticky bit on /tmp-style directories. Web developers use it to troubleshoot Apache/Nginx 403 Forbidden errors caused by incorrect directory permissions.
Essential terms and definitions related to Chmod Calculator.
A set of rules controlling who can read, write, or execute a file on Unix/Linux systems. Permissions are assigned to three classes: Owner (the file creator), Group (users sharing a group), and Others (everyone else). Each class has three permission bits: read (r/4), write (w/2), and execute (x/1). Permissions are displayed as a 9-character string (rwxr-xr-x) or a 3-digit octal number (755).
A base-8 number system used to represent Unix file permissions. Each octal digit (0-7) encodes three permission bits: read (4) + write (2) + execute (1). Three digits represent owner, group, and others respectively. For example, 755 means owner=7 (rwx), group=5 (r-x), others=5 (r-x). An optional fourth leading digit encodes special permissions: setuid (4), setgid (2), sticky bit (1).
A human-readable format for Unix file permissions using the letters r (read), w (write), x (execute), and - (no permission). The 9-character string is read in groups of three: owner, group, others. For example, rwxr-xr-- means the owner can read/write/execute, the group can read/execute, and others can only read. Special permissions are shown as s (setuid/setgid) or t (sticky bit) in place of x.
A special permission bit (octal 1) that, when set on a directory, restricts file deletion to the file owner, directory owner, or root — even if other users have write permission on the directory. The most common example is /tmp, which uses permissions 1777: everyone can create files, but only each file's owner can delete it. Displayed as t (or T if execute is not set) in the others' execute position: drwxrwxrwt.
chmod 755 sets the following permissions: Owner can read, write, and execute (7 = rwx); Group can read and execute (5 = r-x); Others can read and execute (5 = r-x). This is the standard permission for executable scripts and public directories on web servers. The owner has full control, while everyone else can read and execute but not modify.
Octal notation uses three digits (e.g., 755) where each digit represents the sum of permission values: read=4, write=2, execute=1. Symbolic notation uses letters (e.g., rwxr-xr-x) where r=read, w=write, x=execute, and - means no permission. Both represent the same permissions — octal is faster to type, symbolic is easier to read. This tool converts between them instantly.
644 (rw-r--r--) is standard for files: owner can read/write, everyone else read-only. 755 (rwxr-xr-x) is standard for directories and scripts: owner has full access, others can read/execute. 600 (rw-------) is for private files like SSH keys: only owner can read/write. 777 (rwxrwxrwx) gives everyone full access and should be avoided for security reasons.
Special permissions are represented by a fourth octal digit prepended to the standard three: setuid (4) runs executables as the file owner, setgid (2) runs them as the group owner or inherits group on directories, and sticky bit (1) prevents deletion by non-owners in shared directories like /tmp. For example, chmod 1755 adds the sticky bit to standard 755 permissions.
No. This tool calculates Unix/Linux file permissions (POSIX). Windows uses a different permission system based on Access Control Lists (ACLs) with user/group SIDs. If you are on Windows using WSL (Windows Subsystem for Linux), chmod commands work within the WSL filesystem.
Common errors developers encounter and how to resolve them.
chmod: Operation not permitted — Cannot change permissions This error occurs when you are not the file owner and not root. Solutions: (1) Use sudo: sudo chmod 755 file.sh. (2) Check ownership with ls -la and change it with sudo chown youruser:yourgroup file. (3) On some filesystems (FAT32, NTFS mounted in Linux), chmod has no effect because the filesystem does not support Unix permissions. Use mount options like fmask and dmask instead.
Permission denied despite correct chmod — SELinux or ACL override If standard permissions look correct but access is still denied, check for extended ACLs (getfacl file) and SELinux context (ls -Z file). SELinux enforces mandatory access control that overrides standard Unix permissions. Use sestatus to check if SELinux is enforcing, and restorecon to fix contexts. ACLs set with setfacl can also override standard permissions — remove them with setfacl -b file.
SSH key rejected: Permissions 0644 are too open SSH requires private keys to have restrictive permissions. If you see "WARNING: UNPROTECTED PRIVATE KEY FILE", set the correct permissions: chmod 600 ~/.ssh/id_rsa (private key, owner read/write only), chmod 644 ~/.ssh/id_rsa.pub (public key), chmod 700 ~/.ssh/ (directory). SSH refuses to use keys that are readable by other users as a security measure.
Web server 403 Forbidden — Incorrect directory or file permissions Web servers (Apache, Nginx) need specific permissions to serve files. Directories need execute permission (typically 755) for the server to traverse them. Files need read permission (typically 644). The web server process user (www-data, nginx, or apache) must have read access. Check with: namei -l /var/www/html/index.html to see permissions for every directory in the path.