Linux File Permissions Explained: chmod, chown, Users, and Groups

Linux does not let every user read, change, or run every file. Instead, each file and directory has an owner, a group, and a set of permissions that determine who can do what.

This is the system behind permission strings such as -rw-r--r--, commands such as chmod and chown, and many familiar errors such as Permission denied.

Once you understand the model, Linux permissions stop looking like cryptic symbols and start behaving like a simple access-control rule.

🔐 Why Linux Needs File Permissions

A multi-user operating system needs boundaries.

An ordinary account should not automatically be able to modify every system configuration file. A web service should not need unrestricted access to every user’s home directory. A private SSH key should not be readable by unrelated accounts.

Linux solves much of this basic access-control problem by associating files and directories with ownership and permission information.

The traditional permission model is compact, fast, and used throughout Linux. More advanced access controls also exist, but understanding owner, group, and other permissions is the essential foundation.

👤 Every File Has an Owner and a Group

For permission purposes, Linux commonly divides access into three classes.

You can see ownership and permission information with:

ls -l

A simplified output line might look like this:

-rw-r----- 1 alice developers 2480 notes.txt

The important fields for this lesson are:

-rw-r-----   alice   developers   notes.txt
     │         │          │          │
     │         │          │          └── file name
     │         │          └───────────── group
     │         └──────────────────────── owner
     └────────────────────────────────── permissions

🧩 How to Read rwx Permissions

The permission string contains several pieces of information.

Consider:

-rwxr-xr--

The first character identifies the object type. A regular file commonly begins with -, while a directory begins with d.

The remaining nine characters form three permission groups:

So -rwxr-xr-- means:

• The owner can read, write, and execute.
• The group can read and execute, but not write.
• Others can read, but cannot write or execute.

📖 What r, w, and x Mean for Files

A missing permission is represented by a hyphen.

For example:

rw-

means read and write are allowed, but execute is not.

📁 Permissions Mean Something Different on Directories

This is one of the most important concepts beginners often miss.

The same symbols are used for directories, but their practical meaning changes.

🔍 A Permission Example Step by Step

Suppose a file shows:

-rw-r----- 1 alice developers 2480 notes.txt

This approach works far better than trying to read all nine characters as one symbol.

🛠️ chmod Changes Permissions

The command chmod changes file mode bits.

There are two common ways to express the permissions you want: symbolic notation and numeric notation.

Symbolic chmod

Symbolic mode uses letters to describe who should receive or lose a permission.

For example, this adds execute permission for the owner:

chmod u+x script.sh

This removes write permission from the group:

chmod g-w notes.txt

And this gives others read permission:

chmod o+r notes.txt

🔢 Numeric chmod: Why 755 and 644 Work

Linux permissions are also commonly expressed using octal numbers.

Each basic permission has a value:

Add the values within each permission class.

A mode such as:

chmod 755 script.sh

means:

7   5   5
│   │   │
│   │   └── others: r-x
│   └────── group:  r-x
└────────── owner:  rwx

So 755 corresponds to:

rwxr-xr-x

Similarly:

chmod 644 notes.txt

corresponds to:

rw-r--r--

👑 chown Changes Ownership

chmod changes permissions. chown changes ownership.

This distinction matters:

For example:

chown alice notes.txt

changes the file owner to alice, assuming the command is run with sufficient privileges.

You can specify both user and group:

chown alice:developers notes.txt

This sets the owner to alice and the group to developers.

👥 Why Groups Matter

Groups let multiple users receive access through one permission class.

Imagine three developers who need to collaborate on the same project files. Instead of granting access individually through basic mode bits, the files can belong to a shared group and receive appropriate group permissions.

If a project file belongs to the developers group and has group write permission, qualifying members of that group can work with the file according to the directory permissions and other access-control rules in effect.

You can inspect your current user and group memberships with:

id

Or list group names associated with your current account using:

groups

📁 File Permissions and Directory Permissions Work Together

A common troubleshooting mistake is to examine only the file itself.

Suppose a file has readable permissions, but you cannot reach it because one of its parent directories does not permit traversal for your account. The file’s own read bit does not remove the need to traverse the path leading to it.

Conceptually:

Linux may need to check permissions at multiple points along that path.

🔍 How to Inspect Permissions Before Changing Anything

A good administrator investigates before modifying permissions.

Start with:

ls -l filename

For a directory itself, use:

ls -ld directory

The -d option matters here because it asks ls to show information about the directory entry itself rather than listing its contents.

You can also inspect detailed metadata with:

stat filename

The exact formatting varies by implementation and system, but stat provides useful ownership, mode, and filesystem metadata.

🧪 Mini Lab: Learn Permissions Safely

touch permission-lab.txt

ls -l permission-lab.txt

chmod 600 permission-lab.txt

ls -l permission-lab.txt

chmod g+r permission-lab.txt

ls -l permission-lab.txt

rm permission-lab.txt

⚠️ Common Linux Permission Mistakes

🧠 A Simple Permission Troubleshooting Method

When Linux denies access, work through the problem in a fixed order instead of changing random permissions.

What You Should Understand About Linux Permissions

Linux permissions combine two ideas: identity and allowed actions.

The identity side asks which user owns the object, which group is associated with it, and which account is trying to access it.

The permission side asks whether that relevant class has read, write, or execute permission for the requested operation.

Once these two parts are separated mentally, permission strings become much easier to decode:

chmod changes the allowed actions. chown changes ownership. Commands such as ls -l, ls -ld, id, and stat help you understand the existing state before changing anything.