Changing ownership

Table of Contents

Understanding Ownership Changes

In this chapter you’ll learn how to change the user and group that own files and directories. You already know what users, groups, and permissions are; here we focus on the specific tools and patterns used to modify ownership.

Changing ownership is mainly done with:

chown — change file owner and/or group
chgrp — change group only (often redundant but still common)

You usually need sudo or root privileges to change ownership to another user.

The `chown` Command

Basic syntax:

chown [OPTIONS] NEW_OWNER[:NEW_GROUP] FILE...

NEW_OWNER — username or numeric user ID (UID)
NEW_GROUP — group name or numeric group ID (GID)
FILE... — one or more files or directories

Examples:

Change owner only:

  sudo chown alice notes.txt

Change owner and group:

  sudo chown alice:developers project.txt

Change group only (with chown):

  sudo chown :developers project.txt

If you omit NEW_OWNER and keep the colon, you are changing only the group.

Common `chown` Use Cases

Giving Files to a Different User

Move files to another user’s ownership:

sudo chown bob report.pdf
sudo chown bob:bob -R /home/bob/Documents

This is common when:

Migrating data from one account to another
Fixing ownership after copying as root

Fixing Ownership After Using `sudo`

If you accidentally create a file as root in your home directory:

sudo touch /home/alice/.config/app.conf
ls -l /home/alice/.config/app.conf
# -rw-r--r-- 1 root root ...

Fix it:

sudo chown alice:alice /home/alice/.config/app.conf

Changing Ownership Recursively

To apply ownership changes to a directory and everything inside it, use -R (recursive):

sudo chown -R alice:developers /var/www/myapp

This will:

Change the owner to alice
Change the group to developers
Apply to myapp and all of its subdirectories and files

Be very careful with -R, especially on system directories. A mistake like:

sudo chown -R alice:alice /etc

can break your system.

Using `chgrp` to Change Group Only

chgrp is a dedicated command to change the group ownership:

chgrp [OPTIONS] NEW_GROUP FILE...

Examples:

sudo chgrp developers project.txt
sudo chgrp -R www-data /var/www

Functionally, many people use chown :group file instead, but chgrp is still widely used in scripts and documentation.

Ownership and Numeric IDs

chown and chgrp can use numeric IDs instead of names:

sudo chown 1001:1001 data.bin
sudo chgrp 1001 data.bin

This is useful when:

Restoring from backups where user names differ between systems
Working in minimal environments where name services are not configured

You can see numeric IDs with:

id alice

Verifying Ownership Changes

Always confirm what you changed:

Use ls -l for single directories:

  ls -l notes.txt
  ls -ld /var/www

Combine with find for recursive checks:

  find /var/www/myapp -maxdepth 2 -ls

Safe Patterns and Common Pitfalls

Safe Patterns

Limit paths explicitly:

  sudo chown -R alice:alice /home/alice/projects

Use -v (verbose) to see what is changing:

  sudo chown -v alice:alice file1 file2
  sudo chown -Rv alice:alice dir/

Test with -c (report only changes) or pair with ls/find before/after.

Common Pitfalls

Running chown -R on the wrong directory

A typo like:

   sudo chown -R alice:alice /home

may change ownership for all users’ home directories. Always double-check the path.

Changing system directory ownership

Directories like /bin, /usr, /etc, /lib, /var are usually owned by root or system users. Changing their ownership arbitrarily can break software or the boot process.

Breaking user permission expectations

Changing ownership from a user to root:

   sudo chown root:root /home/alice/file.txt

means alice may no longer be able to modify or delete the file (depending on permissions). Ensure you intend that.

Combining Ownership with Groups for Collaboration

Ownership changes are often used to enable shared work:

Create a shared group (done elsewhere with groupadd).
Change directory group:

   sudo chgrp developers /srv/shared

Add appropriate permissions (covered in the permissions chapter).
Optionally change owner to a service account:

   sudo chown appuser:developers /srv/shared

This pattern is common for:

Web application directories (owned by a web user, shared with developers)
Shared team folders

Practice Suggestions

Try these in a test directory in your home:

Create some files and directories:

   mkdir -p testdir/sub
   touch testdir/file1 testdir/sub/file2

View initial ownership:

   ls -lR testdir

Change group only with chgrp (to a group you’re in).
Change owner and group with chown.
Use -R on testdir and see how it affects everything inside.

Focusing on small, isolated directories helps you build confidence with chown and chgrp without risking your system.

Comments

Please login to add a comment.

Don't have an account? Register now!