IBM i IFS Permissions and Security: CHGAUT, CHGOWN, Access Control Lists, Symbolic Links, and QAUDJRN Auditing in 2026

The IBM i Integrated File System (IFS) gives applications a hierarchical file system for stream files, directories, symbolic links, PASE applications, web assets, configuration files, exports, and logs. It also means IBM i administrators and developers need to understand how IFS authority works instead of treating it exactly like objects in a traditional library.

This guide explains how to inspect and change IFS authority with IBM i commands, how authorization lists fit into the model, how ownership and primary groups work, how PASE umask affects newly created files, how symbolic links change the security picture, and how to audit sensitive IFS objects.

The IBM i IFS Authority Model

The root (/), QOpenSys, and user-defined file systems support IBM i security commands such as CHGAUT, CHGOWN, CHGPGP, DSPAUT, and WRKAUT. They also expose UNIX-style read, write, and execute permissions to PASE and QShell applications.

An IFS object is still secured by IBM i. Do not assume that seeing a mode such as rwxr-x--- tells the whole story. IBM i can also use private authorities, a primary group, *PUBLIC authority, and an authorization list.

For an application directory, ask four questions:

  • Who owns the directory and files?
  • Which primary group, if any, should share access?
  • What should *PUBLIC be allowed to do?
  • Should access be managed through individual authorities or an authorization list?

A secure design answers those questions before an application begins creating files.

Displaying IFS Authorities

Use IBM i authority commands for the IBM i view of security, and shell commands for the UNIX-style permission bits visible to PASE applications.

/* Work with authority for a directory */
WRKAUT OBJ('/home/batch/exports')

/* Display authority for a directory */
DSPAUT OBJ('/home/batch/exports')

WRKAUT is an interactive command. For noninteractive checks, use DSPAUT or an SQL-based approach instead.

From QShell or PASE, ls -l gives a convenient view of owner, group, and permission bits:

ls -ld /home/batch/exports
ls -l  /home/batch/exports

For repeatable reviews, the QSYS2.IFS_OBJECT_PRIVILEGES table function, where available on your IBM i release and technology level, can expose authority information programmatically. That is useful when you need to identify *PUBLIC or private authorities across many paths instead of checking objects manually one at a time.

Changing IFS Authority with CHGAUT

CHGAUT changes authority for an IFS object. Important parameters include the object path, user, data authority, object authority, authorization list, subtree handling, and symbolic-link behavior.

Remove *PUBLIC access from an application directory:

CHGAUT OBJ('/opt/appdata') +
       USER(*PUBLIC) +
       DTAAUT(*NONE) +
       OBJAUT(*NONE)

Grant a service profile read, write, and execute data authority:

CHGAUT OBJ('/opt/appdata') +
       USER(APPSVCUSR) +
       DTAAUT(*RWX) +
       OBJAUT(*NONE)

Grant a reporting profile read and execute authority:

CHGAUT OBJ('/opt/appdata/reports') +
       USER(RPTUSER) +
       DTAAUT(*RX) +
       OBJAUT(*NONE)

On directories, SUBTREE(*ALL) tells IBM i to process the directory, its contents, and objects below its subdirectories:

CHGAUT OBJ('/opt/appdata') +
       USER(*PUBLIC) +
       DTAAUT(*NONE) +
       OBJAUT(*NONE) +
       SUBTREE(*ALL)

Use recursive authority changes carefully. A production tree may contain objects with deliberately different owners or permissions, and a blanket SUBTREE(*ALL) can overwrite those differences.

Authorization Lists and IFS Objects

An authorization list is useful when many objects share the same access policy. Instead of maintaining the same users separately on every object, you manage membership and authority on one authorization list and secure the objects with that list.

Create an authorization list and add users:

CRTAUTL AUTL(APPAUTL) AUT(*EXCLUDE) TEXT('Application data access list')

ADDAUTLE AUTL(APPAUTL) USER(APPSVCUSR) AUT(*CHANGE)
ADDAUTLE AUTL(APPAUTL) USER(RPTUSER)   AUT(*USE)

Associate the IFS object with the authorization list:

CHGAUT OBJ('/opt/appdata') AUTL(APPAUTL)

Authorization lists are especially useful for application areas with stable access roles because you can change one list rather than maintaining many separate private authority entries.

The previous live article described an extended-ACL-style *ACL parameter on CHGAUT. That is not a documented CHGAUT parameter. For IBM i administration, use the documented USER, DTAAUT, OBJAUT, and AUTL controls.

Changing Ownership with CHGOWN and CHGPGP

CHGOWN transfers ownership of an IFS object. For application content, the owner should normally be the profile responsible for the application rather than an administrator profile used only during installation.

CHGOWN OBJ('/opt/appdata') NEWOWN(APPSVCUSR)

IBM i supports changing ownership across a directory tree with SUBTREE(*ALL):

CHGOWN OBJ('/opt/appdata') +
       NEWOWN(APPSVCUSR) +
       SUBTREE(*ALL)

Change the primary group with CHGPGP:

CHGPGP OBJ('/opt/appdata') NEWPGP(APPGRP)

Before changing ownership recursively, review the tree first. Logs, configuration, uploaded files, binaries, and shared data may intentionally have different ownership requirements.

PASE umask on IBM i

The PASE and QShell umask is the most important unique topic from the duplicate IFS-permissions article. It controls which permission bits are removed when a process creates a new file or directory.

Display the current mask:

umask

Set a restrictive mask for the current shell or process:

umask 027

With an application that requests 666 for a new file and 777 for a new directory, a mask of 027 removes group write and all permissions for others. That commonly produces:

file:      640  rw-r-----
directory: 750  rwxr-x---

A mask of 077 is stricter:

umask 077

That commonly leaves only the owner with permissions requested by the creating program.

The key detail is that umask removes permission bits from the mode requested by the application. It does not grant permissions that the application did not request.

Set umask in the process that creates the files

For a shell-launched Node.js service, set the mask before starting the application:

#!/bin/sh
umask 027
exec node /home/nodeapps/ordapi/server.js

The same pattern works for Python:

#!/bin/sh
umask 027
exec python3 /home/apps/reporting/main.py

For persistent services, make the setting part of the controlled startup path rather than relying on an interactive shell session. IBM i also exposes a umask() API for changing the file creation mask for the current job.

IBM i Authority and PASE Permissions Work Together

Do not treat umask as a replacement for IBM i authority design.

A secure PASE application normally combines:

  • an application-specific owner profile;
  • a primary group when shared access is required;
  • restricted *PUBLIC authority;
  • deliberate private authorities or an authorization list;
  • an appropriate umask for newly created stream files;
  • controlled startup scripts for long-running Node.js, Python, Java, or shell processes.

This is why an IFS permissions review should use both IBM i tools such as DSPAUT or WRKAUT and shell tools such as ls -l.

Symbolic Links and Authority

Symbolic links deserve explicit review in application directories because the path a user sees may not be the object that ultimately supplies the data.

IBM i CHGAUT has a SYMLNK parameter that controls whether the command changes the symbolic link itself or the object to which it points. SYMLNK(*NO) changes the object pointed to by the link, while SYMLNK(*YES) changes the symbolic link object itself. That distinction matters during recursive administration.

List symbolic links from a shell:

find /opt/appdata -type l -ls

Review where each link points before making broad subtree changes. A symbolic link does not grant authority to a protected target, but it can make an unexpected target reachable through an application-controlled path if the user already has authority to that target.

A Practical Secure PASE Directory Pattern

Suppose a Node.js application runs under profile NODEAPP:

/opt/nodeapp/
├── app/       program files
├── config/    configuration
├── logs/      writable logs
├── data/      application data
└── uploads/   externally supplied files

A practical authority plan is:

  • app/ and config/: writable only by controlled deployment or administration processes; the runtime profile normally needs only the access required to run the application.
  • logs/, data/, and uploads/: writable by the service profile where required.
  • *PUBLIC: no authority unless there is a specific documented requirement.
  • Operations or support groups: grant only the access they need, such as read access to logs.
  • Startup process: set an appropriate umask before starting the service.

Example initial lockdown:

CHGAUT OBJ('/opt/nodeapp') +
       USER(*PUBLIC) +
       DTAAUT(*NONE) +
       OBJAUT(*NONE) +
       SUBTREE(*ALL)

CHGOWN OBJ('/opt/nodeapp') +
       NEWOWN(NODEAPP) +
       SUBTREE(*ALL)

Then add back the minimum access required for individual areas.

Auditing IFS Access with CHGAUD and QAUDJRN

Use CHGAUD to set object auditing values for IFS objects. This is separate from CHGAUT, which changes authority. IBM documents CHGAUD as requiring *AUDIT special authority.

Audit access to a sensitive configuration directory:

CHGAUD OBJ('/opt/nodeapp/config') +
       OBJAUD(*ALL) +
       SUBTREE(*ALL)

Or record changes:

CHGAUD OBJ('/opt/nodeapp/uploads') +
       OBJAUD(*CHANGE) +
       SUBTREE(*ALL)

The system audit journal QAUDJRN can then be used as part of a broader monitoring process. The exact entries available depend on system audit configuration, so production auditing should be designed together with the relevant QAUDCTL and QAUDLVL settings rather than assuming that changing one object’s auditing value is sufficient by itself.

IFS Security Best Practices

  1. Minimise *PUBLIC authority. Application data should not be broadly writable simply because it lives in the IFS.
  2. Use dedicated service profiles. Run Node.js, Python, Java, and batch workloads with profiles designed for those applications instead of QSECOFR or another highly privileged profile.
  3. Review authority before recursive changes. SUBTREE(*ALL) is powerful and can flatten intentional differences across a directory tree.
  4. Use authorization lists when many objects share one policy. They provide a central place to manage access for a group of secured objects.
  5. Set PASE umask deliberately. A startup script with umask 027 or a stricter value can prevent newly created files from being broader than intended.
  6. Inspect both IBM i authority and shell permission bits. Use DSPAUT or WRKAUT together with ls -l.
  7. Validate external file paths. Reject traversal such as unexpected .. components before using externally supplied paths in file operations.
  8. Treat shared temporary directories cautiously. Do not place sensitive exports, credentials, or private application data in broadly writable locations without additional controls.
  9. Review symbolic links. Unexpected links can make application paths point to data outside the intended tree.
  10. Define retention for exports and logs. Security includes removing sensitive files when the business no longer needs them.
  11. Audit sensitive paths. Use object auditing and QAUDJRN as part of a deliberate monitoring strategy.
  12. Protect secrets. API keys, TLS private keys, environment files, and database credentials should not be broadly readable.

Summary

IFS security on IBM i combines IBM i authority concepts with UNIX-style file permissions visible to PASE applications. CHGAUT changes authority, CHGOWN and CHGPGP control ownership and primary group, authorization lists centralise access policies, and PASE umask limits the permission bits available to newly created files.

The most reliable approach is to design ownership, group access, *PUBLIC authority, creation masks, and auditing together. That produces predictable permissions for modern IBM i workloads without weakening the platform’s native security model.

Leave a Comment

Your email address will not be published. Required fields are marked *

Scroll to Top