In simple cases, with a filesystem that consists on files on a local disk, the filesystem driver¹ reads permission metadata (traditional Unix user and group ownership and rwxrwxrwx permissons, access control lists, etc.) stored on the disk according to the filesystem format, and decides whether to grant access based on these permissions. But when there are more layers between the on-disk representation and the application, the permission metadata used for access control and the permission metadata reported through the metadata access interface may not match.
When you run
ls, it uses the metadata access interface to display permissions and ownership. When the filesystem is a remote one, the local filesystem driver sends a metadata query to the remote filesystem. When you try to access a file (e.g. when you read it by opening it in an application), with a remote filesystem, the local filesystem driver sends a read request to the remote filesystem. The two may not be consistent if the remote filesystem's responses are incoherent.
It's possible for the remote filesystem's reponses to be incoherent when the remote filesystem supports metadata that the local filesystem doesn't. For example, if the remote server has accounts that the local client doesn't have, the filesystem cannot report metadata accurately. This is pretty common when the server and the client run different operating systems (e.g. Windows server and Linux client or vice versa).
In your case, evidently, either the remote filessytem server is not configured in the way user01 desired or the permissions on the server are not as restrictive as expected. For example there may be an extra ACL entry that grants access to (some) remote users. If the remote filesystem can only report Unix permissions but not richer ACL, you'd see a file owned by the user, with no “group” or “other” permissions, and with an owner who isn't you, but there could be an ACL entry that grants you permission.
¹ This may be subdivided into a type-specific filesystem driver and a generic layer (typically called VFS), but this is system-dependent so I'm purposefully not making the distinction here.