Forum: Ruby-core [ruby-trunk - Bug #7879][Open] File.readable? fails when ruby runs as root

Issue #7879 has been reported by balbi (Feliple Balbi).

----------------------------------------
Bug #7879: File.readable? fails when ruby runs as root
https://bugs.ruby-lang.org/issues/7879

Author: balbi (Feliple Balbi)
Status: Open
Priority: Normal
Assignee:
Category:
Target version:
ruby -v: ruby 1.9.3p194 (2012-04-20 revision 35410) [x86_64-linux]


I have the following script to find sysfs (linux) files which are 
readable but throw an exception when read:

Dir.glob("/sys/**/*").each do |file|
        next if File.directory?(file)

        if File.world_writable?(file)
                puts "#{file} is world-writable"
        end

        if File.readable?(file)
                begin
                        File.open(file) { |f|
                                result = f.readline
                        }
                rescue EOFError
                        nil
                rescue => e
                        puts e.message
                end
        end
end

If I run as a normal user, it works just fine, but when I run as root, 
even for files which are write only (chmod 200), File.readable?(f) will 
return true which makes my script fail. I have also tried 
File.readable_real? but it has the same outcome.

Issue #7879 has been updated by ko1 (Koichi Sasada).

Category set to core
Assignee set to nobu (Nobuyoshi Nakada)
Target version set to 2.1.0


----------------------------------------
Bug #7879: File.readable? fails when ruby runs as root
https://bugs.ruby-lang.org/issues/7879#change-36571

Author: balbi (Feliple Balbi)
Status: Open
Priority: Normal
Assignee: nobu (Nobuyoshi Nakada)
Category: core
Target version: 2.1.0
ruby -v: ruby 1.9.3p194 (2012-04-20 revision 35410) [x86_64-linux]


I have the following script to find sysfs (linux) files which are 
readable but throw an exception when read:

Dir.glob("/sys/**/*").each do |file|
        next if File.directory?(file)

        if File.world_writable?(file)
                puts "#{file} is world-writable"
        end

        if File.readable?(file)
                begin
                        File.open(file) { |f|
                                result = f.readline
                        }
                rescue EOFError
                        nil
                rescue => e
                        puts e.message
                end
        end
end

If I run as a normal user, it works just fine, but when I run as root, 
even for files which are write only (chmod 200), File.readable?(f) will 
return true which makes my script fail. I have also tried 
File.readable_real? but it has the same outcome.

Issue #7879 has been updated by kosaki (Motohiro KOSAKI).

Status changed from Open to Rejected

When run as root, access(2) ignore permission and always return success. 
That's UNIX filesystem semantics.
In the other words, this is completely your script bug.

You need specific concern when opening /proc, /sys and similar pseudo 
filesystem's file.
----------------------------------------
Bug #7879: File.readable? fails when ruby runs as root
https://bugs.ruby-lang.org/issues/7879#change-36583

Author: balbi (Feliple Balbi)
Status: Rejected
Priority: Normal
Assignee: nobu (Nobuyoshi Nakada)
Category: core
Target version: 2.1.0
ruby -v: ruby 1.9.3p194 (2012-04-20 revision 35410) [x86_64-linux]


I have the following script to find sysfs (linux) files which are 
readable but throw an exception when read:

Dir.glob("/sys/**/*").each do |file|
        next if File.directory?(file)

        if File.world_writable?(file)
                puts "#{file} is world-writable"
        end

        if File.readable?(file)
                begin
                        File.open(file) { |f|
                                result = f.readline
                        }
                rescue EOFError
                        nil
                rescue => e
                        puts e.message
                end
        end
end

If I run as a normal user, it works just fine, but when I run as root, 
even for files which are write only (chmod 200), File.readable?(f) will 
return true which makes my script fail. I have also tried 
File.readable_real? but it has the same outcome.

Issue #7879 has been updated by mame (Yusuke Endoh).


kosaki (Motohiro KOSAKI) wrote:
> When run as root, access(2) ignore permission and always return success. That's 
UNIX filesystem semantics.
> In the other words, this is completely your script bug.

Wow...

> You need specific concern when opening /proc, /sys and similar pseudo 
filesystem's file.

Out of curiosity, what should we concern concretely?  Should we assume 
File.readable? as a hint?

--
Yusuke Endoh <mame@tsg.ne.jp>

----------------------------------------
Bug #7879: File.readable? fails when ruby runs as root
https://bugs.ruby-lang.org/issues/7879#change-36653

Author: balbi (Feliple Balbi)
Status: Rejected
Priority: Normal
Assignee: nobu (Nobuyoshi Nakada)
Category: core
Target version: 2.1.0
ruby -v: ruby 1.9.3p194 (2012-04-20 revision 35410) [x86_64-linux]


I have the following script to find sysfs (linux) files which are 
readable but throw an exception when read:

Dir.glob("/sys/**/*").each do |file|
        next if File.directory?(file)

        if File.world_writable?(file)
                puts "#{file} is world-writable"
        end

        if File.readable?(file)
                begin
                        File.open(file) { |f|
                                result = f.readline
                        }
                rescue EOFError
                        nil
                rescue => e
                        puts e.message
                end
        end
end

If I run as a normal user, it works just fine, but when I run as root, 
even for files which are write only (chmod 200), File.readable?(f) will 
return true which makes my script fail. I have also tried 
File.readable_real? but it has the same outcome.

>> You need specific concern when opening /proc, /sys and similar pseudo 
filesystem's file.
>
> Out of curiosity, what should we concern concretely?  Should we assume 
File.readable? as a hint?

Pseudo filesystem hae several exceptional rule. this is one of them.
So, yes, when you can touch pseudo filesystems, I don't recommend to
use File.readable?. This is OS limitation and we can not fix them.