1. Overview

In Unix-based operating systems, access to files is restricted using the concept of access rights such as read, write, and execute.

In this tutorial, we’ll learn different ways to get file permissions in the octal format.

2. Using the stat Command

The stat command is the recommended strategy if we need to know the file permissions without any filters. In addition, it supports the –format option that accepts different format strings to get specific details about files, such as %a to get octal permission, %n to get the filename, and many others.

Let’s go ahead and get the octal file permissions for all the files under the/bin directory whose filename begins with the “w” character:

$ stat --format="%n: %a" /bin/w*
/bin/w: 755
/bin/wall: 2755
/bin/watch: 755
/bin/wc: 755
/bin/wdctl: 755
/bin/whatis: 755
/bin/whereis: 755
/bin/which: 777
/bin/which.debianutils: 755
/bin/who: 755
/bin/whoami: 755
/bin/write: 777
/bin/write.ul: 2755

We can notice that each line of the output contains a filename with its permissions in octal format. Moreover, we needed the %n format string to identify which permissions belong to which file.

Next, let’s get the file permissions for the /bin/whereis file by limiting the format string to “%a“:

$ stat --format="%a" /bin/whereis

Great! We’ve got this right. The output is limited to the octal permissions of the file, so we can use the result directly in a script if required.

3. Using the find Command

The find command in Linux is the standard way to search for file information. It offers advanced filter options such as -name, -type, -size, and so on to restrict the search results. Moreover, we can use the -printf option to get the file information in the desired format.

First, let’s go ahead and use the find command to get octal permission information for all files within the /bin directory, such that their name starts with the “w” character:

$ find /bin/ -name "w*" -printf "%f: %m\n"
whereis: 755
wc: 755
which.debianutils: 755
watch: 755
whoami: 755
wall: 2755
which: 777
who: 755
wdctl: 755
w: 755
write: 777
whatis: 755
write.ul: 2755

Great! The result looks correct. Furthermore, we must note that we used the %f and %m format strings to get the filename and octal permissions, respectively.

4. Using the ls and sed Commands

Yet another way to derive the octal permissions is by using the ls and sed commands.

First, let’s use the ls command with the -l option to see verbose file information:

$ ls -l /bin/w*
-rwxr-xr-x 1 root root 18440 Feb 25  2022 /bin/w
-rwxr-sr-x 1 root tty  18592 Feb 21  2022 /bin/wall
-rwxr-xr-x 1 root root 35192 Feb 25  2022 /bin/watch
-rwxr-xr-x 1 root root 35136 Feb  7  2022 /bin/wc
-rwxr-xr-x 1 root root 26808 Feb 21  2022 /bin/wdctl
-rwxr-xr-x 1 root root 39952 Mar 17  2022 /bin/whatis
-rwxr-xr-x 1 root root 27232 Feb 21  2022 /bin/whereis
lrwxrwxrwx 1 root root    23 Nov 30 02:16 /bin/which -> /etc/alternatives/which
-rwxr-xr-x 1 root root   946 Mar 23  2022 /bin/which.debianutils
-rwxr-xr-x 1 root root 39288 Feb  7  2022 /bin/who
-rwxr-xr-x 1 root root 22888 Feb  7  2022 /bin/whoami
lrwxrwxrwx 1 root root    23 Feb 28 04:34 /bin/write -> /etc/alternatives/write
-rwxr-sr-x 1 root tty  18600 Feb 21  2022 /bin/write.ul

We can see that the first column of the output contains the file permissions, but it’s not in the octal format. Further, we can use the sed command to replace the file permissions’ rwx- characters with their equivalent 0-7 octal representation to get the desired result.

Next, let’s pipe the output of the ls command to a series of sed substitution commands:

$ ls -l /bin/w* | \
sed -E -e 's/([^ ]*) .* (.*)/\1:\2/' \
-e 's/^[bcCdlps?]//' \
-e 's/rw[sx]/7/g' \
-e 's/rw-/6/g' \
-e 's/r-[sx]/5/g' \
-e 's/r--/4/g' \
-e 's/-w[sx]/3/g' \
-e 's/-w-/2/g' \
-e 's/--[sx]/1/g' \
-e 's/---/0/g' \
-e 's/^-//'

We must note that the first substitution command extracts the first and last column containing file permission and filename from the output of the ls command. Further, we ignored the first leading character among the [bcCdlps] characters as they represent the file type.

Finally, we should remember that this approach doesn’t handle special file permissions. Nonetheless, it’s good to know from a learning perspective.

5. Using the ls and awk Commands

awk offers common programming constructs such as if-else blocks. As a result, we can improve our computing logic to get the octal file permissions using awk instead of sed by handling the sticky bits.

Let’s write the script.awk script that takes input from the ls -l command and prints the octal file permissions along with the filename:

$ cat script.awk
    for(i=0;i<=8;i++) {
        if (substr($1,i+2,1)~/[s]/) {
            decimal_perm += ((substr($1,i+2,1)~/[s]/)*2^9);
        } else {

    if (k) {
        printf("%0o %s\n",decimal_perm, $NF);

We can see that we’re computing the decimal value of the permission in the decimal_perm variable and eventually printing its octal representation. Further, we’re iterating over the characters of the permission string and matching it against [s] or [rwx] permissions. Accordingly, we increment decimal_perm with the equivalent decimal value for a sticky or regular bit with 2^9 or 2^(8-i), respectively.

Finally, let’s see the script in action:

$ ls -l bin/w* | awk -f script.awk
755 bin/w
1745 bin/wall
755 bin/watch
755 bin/wc
755 bin/wdctl
755 bin/whatis
755 bin/whereis
777 /etc/alternatives/which
755 bin/which.debianutils
755 bin/who
755 bin/whoami
777 /etc/alternatives/write
1745 bin/write.ul

6. Using the exa Command

exa is popularly known as a modern replacement for ls. Using exa, we can get the octal file permissions directly using the –octal-permissions option, so we don’t need any lengthy custom script.

Before we start, we need to install the exa package because it doesn’t come preinstalled:

$ apt-get install exa

Next, let’s go ahead and see it in action:

$ exa -l --octal-permissions bin/w*
0755 .rwxr-xr-x 18k root 25 Feb  2022 bin/w
2755 .rwxr-sr-x 19k root 21 Feb  2022 bin/wall
0755 .rwxr-xr-x 35k root 25 Feb  2022 bin/watch
0755 .rwxr-xr-x 35k root  7 Feb  2022 bin/wc
0755 .rwxr-xr-x 27k root 21 Feb  2022 bin/wdctl
0755 .rwxr-xr-x 40k root 17 Mar  2022 bin/whatis
0755 .rwxr-xr-x 27k root 21 Feb  2022 bin/whereis
0777 lrwxrwxrwx  23 root 30 Nov  2022 bin/which -> /etc/alternatives/which
0755 .rwxr-xr-x 946 root 23 Mar  2022 bin/which.debianutils
0755 .rwxr-xr-x 39k root  7 Feb  2022 bin/who
0755 .rwxr-xr-x 23k root  7 Feb  2022 bin/whoami
0777 lrwxrwxrwx  23 root 28 Feb 04:34 bin/write -> /etc/alternatives/write
2755 .rwxr-sr-x 19k root 21 Feb  2022 bin/write.ul

We can see that the first column represents the octal permission. Further, if required, we can limit the output to octal permissions and filename using utilities such as awk, sed, or cut commands.

7. Conclusion

In this article, we learned how to get the octal permissions of files in Linux. Further, we explored multiple options with the stat, find, sed, awk, and exa commands to solve the use case.

Comments are open for 30 days after publishing a post. For any issues past this date, use the Contact form on the site.