Learn how Linux controls who can read, write, and execute files through its powerful permission system.

In Linux, there's a fundamental principle that might sound strange at first: everything is a file.

This means your keyboard, mouse, hard drive, network connections, and even directories are all treated as files by the Linux system. This unified approach makes Linux incredibly powerful and consistent.

Why does this matter for permissions? Since everything is a file, the same permission system applies to:

• Regular text files
• Executable programs
• Directories (folders)
• System devices
• Network connections

The Big Picture: Understanding that everything is a file helps explain why Linux has such a comprehensive and consistent permission system. Every single thing in your Linux system can be secured and controlled using the same set of rules.

This is why mastering file permissions isn't just about protecting documents - it's about understanding how Linux secures your entire system!

Linux doesn't just ask "who owns this file?" - it asks "which user owns this file and which group owns this file?"

Every file has two owners:

1. User Owner - Usually the person who created the file
2. Group Owner - Usually the primary group of that user

Why two owners? Imagine you're working on a project with your team:

• You (user owner) might need full control to edit and delete files
• Your team (group owner) might need to read and modify files
• Everyone else should only be able to read the final results

Real Example: When you create a file called test.txt:

-rw-r--r-- 1 nana nana 0 Mar 15 10:30 test.txt

• User owner: nana (you)
• Group owner: nana (your primary group)

The Power: This dual ownership system lets you create sophisticated access controls. You can give yourself full access, your team partial access, and everyone else limited access - all for the same file!

What if you need to transfer ownership of a file? Linux provides powerful commands to change who owns what.

The chown Command (Change Owner)

# Change both user and group owner
sudo chown tom:admin test.txt

# Change only the user owner
sudo chown admin test.txt

The chgrp Command (Change Group)

# Change only the group owner
sudo chgrp devops test.txt

Why sudo? Changing ownership is a powerful operation that affects system security, so you need administrator privileges.

Real-World Scenario: Imagine you created a configuration file but now need to hand it over to the system administrator (root) and the admin group:

sudo chown root:admin config.yml

Key Insight: Ownership changes are permanent and immediate. The moment you run these commands, the file belongs to its new owners with all the rights and restrictions that come with that ownership.

You already know ls shows files and ls -a shows hidden files. But there's a third flag that reveals the secret life of your files: ls -l

When you run ls -l, suddenly each file displays a cryptic string of letters and dashes:

-rwxr-xr-- 1 user group 1024 Mar 15 10:30 myfile.txt
drwxr-xr-x 2 user group 4096 Mar 15 09:15 myfolder

This isn't random gibberish - it's a permission blueprint that tells you:

• Who owns each file
• What they're allowed to do with it
• Who else can access it
• How they can access it

Pro Tip: Want to see permissions for hidden files too? Combine the flags: ls -la

The Revelation: Every file in Linux has been quietly carrying this detailed security information all along. The ls -l command is like putting on X-ray glasses to see the permission structure that's always been there, silently protecting your system.

Let's decode this mysterious string: -rwxr-xr--

First Character - File Type:

• - = Regular file
• d = Directory
• l = Link (we'll learn about these later)

Next 9 Characters - Permissions (3 blocks of 3):

Block 1 (positions 2-4): User Owner Permissions

• r = Read (can view file contents)
• w = Write (can edit/modify file)
• x = Execute (can run the file as a program)

Block 2 (positions 5-7): Group Owner Permissions

• Same r, w, x meanings, but for the group

Block 3 (positions 8-10): Everyone Else Permissions

• Same r, w, x meanings, but for all other users

Example Breakdown: -rwxr-xr-- means:

• - = Regular file
• rwx = User owner can read, write, and execute
• r-x = Group owner can read and execute (but not write)
• r-- = Everyone else can only read

The Dash Rule: A dash (-) means "permission denied" for that specific action.

Linux has exactly three permission types, but their meaning changes depending on whether you're dealing with files or directories.

For Regular Files:

Read (r) - "Can I see what's inside?"

• View file contents
• Copy the file
• Search through the file

Write (w) - "Can I change it?"

• Edit file contents
• Delete the file
• Rename the file

Execute (x) - "Can I run it?"

• Run the file as a program or script
• Only makes sense for executable files

For Directories:

Read (r) - "Can I list what's inside?"

• See the names of files and subdirectories

Write (w) - "Can I modify the contents?"

• Create new files or directories inside
• Delete files or directories inside
• Rename items inside

Execute (x) - "Can I enter this directory?"

• Navigate into the directory (cd command)
• Access files inside (even if you can't list them)

Important: You need execute permission on a directory to access files inside it, even if you have read permission on those files!

The chmod (change mode) command is your tool for modifying permissions. The symbolic method is intuitive and precise.

Basic Syntax: chmod [who][action][permission] filename

Who:

• u = User owner
• g = Group owner
• o = Other users
• a = All (user + group + other)

Action:

• + = Add permission
• - = Remove permission
• = = Set exact permissions

Permission:

• r = Read
• w = Write
• x = Execute

Practical Examples:

# Give execute permission to user owner
chmod u+x script.sh

# Remove write permission from group
chmod g-w document.txt

# Give read permission to everyone
chmod a+r public_file.txt

# Set exact permissions for group (read and execute only)
chmod g=rx program.exe

Pro Tip: You can combine actions: chmod u+x,g-w,o=r filename

Typing chmod u+r,g+w,o-x gets tedious. Linux offers a shortcut: numeric permissions.

The Magic Numbers: Each permission has a value:

• r (read) = 4
• w (write) = 2
• x (execute) = 1

How it works: Add the numbers for each permission block:

• rwx = 4+2+1 = 7 (all permissions)
• rw- = 4+2+0 = 6 (read and write)
• r-x = 4+0+1 = 5 (read and execute)
• r-- = 4+0+0 = 4 (read only)
• -wx = 0+2+1 = 3 (write and execute)
• -w- = 0+2+0 = 2 (write only)
• --x = 0+0+1 = 1 (execute only)
• --- = 0+0+0 = 0 (no permissions)

Common Examples:

# Everyone gets all permissions
chmod 777 file.txt    # rwxrwxrwx

# Owner: all, Group: read, Other: none
chmod 740 file.txt    # rwxr-----

# Owner: read/write, Group: read, Other: read
chmod 644 file.txt    # rw-r--r--

Memory Trick: 644 is the most common permission for regular files, 755 for executable files and directories.

Modifying Hidden File Permissions:

Remember: Hidden files follow the same permission rules as regular files - they're just not displayed by default.