Chmod Calculator
Set Linux file permissions visually with checkboxes. Instantly get the numeric chmod command, symbolic notation, and common presets with our free chmod generator.
rwxr-xr-x chmod 755 filename How ZeroData protects your privacy
- ✓ No Uploads: Tool input is processed in your browser and is not sent to ZeroData servers.
- ✓ No Storage: Tool input is not saved by this website.
- ✓ No Input Tracking: Analytics never receive the text, files, keys, or credentials you process.
- ✓ Verifiable: Disconnect from the network after the page loads; local tool processing continues without uploading your input.
When Should I Use This?
Use a chmod calculator when you need to determine the exact numeric or symbolic permissions for files and directories on Linux/Unix systems.
- Setting up SSH key permissions (e.g.,
chmod 600 ~/.ssh/id_rsa) to prevent connection errors likeUNPROTECTED PRIVATE KEY FILE!. - Configuring web server document root permissions (e.g., 755 for directories, 644 for files) for Apache or Nginx.
- Creating executable bash scripts in your CI/CD pipelines (e.g.,
chmod +x deploy.sh). - Securing database configuration files that contain plaintext passwords so only the owner can read them (e.g., 400).
Visual Chmod Generator & Linux Permission Calculator
Managing POSIX file permissions in Linux and Unix-like operating systems is a foundational task for DevOps engineers, system administrators, and web developers. However, translating between mental permission models, symbolic strings (like rwxr-xr-x), and 3-digit octal numeric modes (like 755) can be confusing.
This interactive chmod calculator replaces manual mental arithmetic with a visual, real-time matrix. By selecting checkboxes for Read, Write, and Execute across Owner, Group, and Others, the tool automatically calculates the exact octal mode, symbolic representation, and executable terminal command.
Understanding POSIX Permission Classes & Octal Math
Linux evaluates permissions by dividing system users into three distinct classes:
- Owner (u): The individual user account that owns the file or directory.
- Group (g): Members of the system group assigned to the file.
- Others (o): All other users on the operating system.
Each class is assigned a combination of three basic permission bits, calculated using binary weights:
- Read (r = 4): Permission to view file contents or list directory entries.
- Write (w = 2): Permission to modify file contents or add/delete files inside a directory.
- Execute (x = 1): Permission to execute a binary/script or traverse into a directory.
Octal Mode Quick Reference Table
Combining these values yields a single octal digit (0 through 7) for each entity class:
| Octal Digit | Symbolic String | Permission Combination |
|---|---|---|
| 7 | rwx | Read (4) + Write (2) + Execute (1) |
| 6 | rw- | Read (4) + Write (2) |
| 5 | r-x | Read (4) + Execute (1) |
| 4 | r-- | Read (4) only |
| 3 | -wx | Write (2) + Execute (1) |
| 2 | -w- | Write (2) only |
| 1 | --x | Execute (1) only |
| 0 | --- | No permissions |
Special Linux Permissions: SUID, SGID, and Sticky Bit
Advanced Linux environments utilize a 4th leading octal digit for special permissions:
- SUID (Set User ID - 4000): Executables run with the effective permissions of the file owner rather than the executing user.
- SGID (Set Group ID - 2000): Executables run with group privileges, and new files created within an SGID directory inherit the directory's group ownership.
- Sticky Bit (1000): Applied to shared directories (like
/tmp) to prevent users from deleting or renaming files owned by others.
⚡ Quick Solution: Safe Web Server Permissions
To configure production web root directories (Apache, Nginx) safely without granting unnecessary execute permissions:
Directories (755): find /var/www/html -type d -exec chmod 755 {} +
Files (644): find /var/www/html -type f -exec chmod 644 {} +
Troubleshooting "Permission Denied" Errors
HTTP 403 Forbidden errors or terminal EACCES: permission denied exceptions occur when the running process user (such as www-data or nginx) lacks required access bits. Using this calculator, you can quickly verify whether adding read (4) or execute (1) permissions to Others resolves access issues while avoiding insecure chmod 777 overrides.
Why Privacy Matters for System Permission Calculations
Calculating permissions often involves evaluating internal file paths, deployment folder structures, and security configurations. Passing server directory paths or permission schemes to online cloud calculators can expose your infrastructure setup to third-party tracking.
Our Chmod Calculator is 100% private — your file permissions and directory paths never leave your browser. All calculations happen instantly client-side using JavaScript, guaranteeing zero network uploads and complete local privacy.
Browser & Operating System Compatibility
This tool functions across all modern desktop and mobile browsers, including Chrome, Firefox, Safari, Edge, and Opera. The generated commands strictly adhere to POSIX chmod specifications, making them fully compatible with Linux, macOS, Unix, BSD, and Windows WSL.
Related DevOps & System Utilities
Enhance your server administration toolkit with our free utilities:
- Change file user and group ownership with our Chown Command Generator.
- Generate Linux systemd unit files using our Systemd Service Generator.
- Build cron schedules visually with our Cron Job Generator.
- Configure Web CORS headers safely using our CORS Header Generator.
- Fix container mount permissions using our Docker Volume Permissions Helper.
- Generate SSH configurations with our SSH Config Generator.
- Read our detailed guide: Complete Guide to Linux Permissions & Chmod.
How to Use the Chmod Calculator
- Select the Read, Write, and Execute checkboxes for Owner, Group, and Others.
- Instantly view the calculated 3-digit octal mode (e.g., 755) and symbolic string (e.g., rwxr-xr-x).
- Use one-click preset buttons for common Linux permissions like 755, 644, 700, and 600.
- Copy the generated chmod command string directly to your clipboard.
- Paste the verified command into your terminal to safely update your target file permissions.
Common Use Cases
- Setting standard permissions for web server files (644 for static files, 755 for web directories).
- Fixing 'Permission denied' (Error 403 or EACCES) errors on Linux, macOS, and WSL systems.
- Configuring strict security permissions for SSH private keys (600) and .ssh directories (700).
- Translating octal permission numbers found in deployment scripts or Dockerfiles to symbolic notation.
- Teaching Linux file system permission models and bitmask calculations to system administrators.
Frequently Asked Questions
What does chmod 777 mean?
chmod 777 represents the most permissive state in Linux file permissions where the owner, group, and all other users have full read (r), write (w), and execute (x) access. Because this exposes the file or directory to any user on the system, it represents a severe security vulnerability and should be avoided in production environments.
What does chmod 755 mean?
chmod 755 means the owner can read, write, and execute (7), while the group and others can read and execute but not write (5). This is the standard permission for directories and executable scripts on Linux servers.
What is the difference between chmod 644 and 755?
644 (rw-r--r--) allows the owner to read and write, and everyone else to only read. 755 (rwxr-xr-x) adds execute permission for all users. Use 644 for regular files (like HTML, CSS) and 755 for directories and scripts that need to be executed.
Is chmod 777 dangerous?
Yes. chmod 777 gives full read, write, and execute permissions to everyone — including unprivileged or compromised system users. This is a major security risk on multi-tenant or production servers. Only use it temporarily for debugging, never in production.
How do I read the symbolic notation rwxr-xr-x?
The 9 characters are split into 3 groups of 3: owner (rwx), group (r-x), others (r-x). Each position is either the permission letter (r=read, w=write, x=execute) or a dash (-) meaning that specific permission is denied.
What permission should I use for SSH private keys?
SSH private keys (like id_rsa or id_ed25519) require strict permissions of 600 (rw-------). This grants read and write access only to the file owner. OpenSSH will refuse to connect if key permissions are overly permissive.
How do I apply chmod recursively to files vs directories?
To set permissions recursively without making regular files executable, use find: 'find /path -type d -exec chmod 755 {} +' for directories, and 'find /path -type f -exec chmod 644 {} +' for regular files.
Are my permission calculations stored on a server?
No. 100% private — your file permissions and directory paths never leave your browser. The calculator operates entirely client-side without network calls.
Related Tools
Cron Job Generator
Build cron expressions visually and copy production-ready schedules without trial and error.
Docker Run to Compose Converter
Convert docker run commands into docker-compose.yml files instantly. Runs completely locally in your browser.
CORS Header Generator
Generate CORS headers for Nginx, Apache, and Express.js with a visual builder. No data uploaded.
Chown Command Generator
Generate Linux chown commands visually to change file and directory ownership. Set user, group, and flags — 100% browser-based.
Systemd Service Generator
Generate Linux systemd service unit files visually. Configure ExecStart, restart policies, and dependencies — 100% browser-based.
Docker Volume Permissions Helper
Fix Docker volume permission issues visually. Generate chown, chmod, and Dockerfile commands for bind mounts and named volumes — 100% browser-based.