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

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.

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.

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!

Hidden files (those starting with .) have permissions too, but ls -l won't show them by default.

Revealing Hidden File Permissions:

# Show permissions for all files, including hidden ones
ls -la

# Show permissions for a specific hidden file
ls -l .bashrc

Common Hidden Files You'll Encounter:

• .bashrc - Your shell configuration
• .ssh/ - SSH keys and config
• .gitconfig - Git configuration
• .vimrc - Vim editor settings

Typical Hidden File Permissions:

-rw------- .ssh/id_rsa        # Private key: owner only
-rw-r--r-- .bashrc           # Config: owner write, others read
drwx------ .ssh/             # SSH directory: owner only

Security Note: Hidden files often contain sensitive configuration or private keys. They typically have restrictive permissions (600 or 700) to prevent unauthorized access.

Modifying Hidden File Permissions:

# Make .bashrc readable by group
chmod 640 .bashrc

# Secure SSH private key (very important!)
chmod 600 ~/.ssh/id_rsa

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

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.

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

Common Examples:

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