| Message ID | 20201207163255.564116-5-mszeredi@redhat.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | allow unprivileged overlay mounts | expand |
On Mon, Dec 7, 2020 at 6:36 PM Miklos Szeredi <mszeredi@redhat.com> wrote: > > ovl_ioctl_set_flags() does a capability check using flags, but then the > real ioctl double-fetches flags and uses potentially different value. > > The "Check the capability before cred override" comment misleading: user > can skip this check by presenting benign flags first and then overwriting > them to non-benign flags. > > Just remove the cred override for now, hoping this doesn't cause a > regression. > > The proper solution is to create a new setxflags i_op (patches are in the > works). > > Xfstests don't show a regression. > > Reported-by: Dmitry Vyukov <dvyukov@google.com> > Signed-off-by: Miklos Szeredi <mszeredi@redhat.com> Looks reasonable Reviewed-by: Amir Goldstein <amir73il@gmail.com> > --- > fs/overlayfs/file.c | 75 ++------------------------------------------- > 1 file changed, 3 insertions(+), 72 deletions(-) > > diff --git a/fs/overlayfs/file.c b/fs/overlayfs/file.c > index efccb7c1f9bc..3cd1590f2030 100644 > --- a/fs/overlayfs/file.c > +++ b/fs/overlayfs/file.c > @@ -541,46 +541,26 @@ static long ovl_real_ioctl(struct file *file, unsigned int cmd, > unsigned long arg) > { > struct fd real; > - const struct cred *old_cred; > long ret; > > ret = ovl_real_fdget(file, &real); > if (ret) > return ret; > > - old_cred = ovl_override_creds(file_inode(file)->i_sb); > ret = security_file_ioctl(real.file, cmd, arg); > if (!ret) > ret = vfs_ioctl(real.file, cmd, arg); > - revert_creds(old_cred); > > fdput(real); > > return ret; > } > I wonder if we shouldn't leave a comment behind to explain that no override is intentional. I also wonder if "Permission model" sections shouldn't be saying something about ioctl() (current task checks only)? or we just treat this is a breakage of the permission model that needs to be fixed? Thanks, Amir.
On Mon, 7 Dec 2020, Miklos Szeredi wrote: > ovl_ioctl_set_flags() does a capability check using flags, but then the > real ioctl double-fetches flags and uses potentially different value. > > The "Check the capability before cred override" comment misleading: user > can skip this check by presenting benign flags first and then overwriting > them to non-benign flags. Is this a security bug which should be fixed in stable?
On Tue, Dec 8, 2020 at 12:15 PM Amir Goldstein <amir73il@gmail.com> wrote: > > On Mon, Dec 7, 2020 at 6:36 PM Miklos Szeredi <mszeredi@redhat.com> wrote: > > > > ovl_ioctl_set_flags() does a capability check using flags, but then the > > real ioctl double-fetches flags and uses potentially different value. > > > > The "Check the capability before cred override" comment misleading: user > > can skip this check by presenting benign flags first and then overwriting > > them to non-benign flags. > > > > Just remove the cred override for now, hoping this doesn't cause a > > regression. > > > > The proper solution is to create a new setxflags i_op (patches are in the > > works). > > > > Xfstests don't show a regression. > > > > Reported-by: Dmitry Vyukov <dvyukov@google.com> > > Signed-off-by: Miklos Szeredi <mszeredi@redhat.com> > > Looks reasonable > > Reviewed-by: Amir Goldstein <amir73il@gmail.com> > > > --- > > fs/overlayfs/file.c | 75 ++------------------------------------------- > > 1 file changed, 3 insertions(+), 72 deletions(-) > > > > diff --git a/fs/overlayfs/file.c b/fs/overlayfs/file.c > > index efccb7c1f9bc..3cd1590f2030 100644 > > --- a/fs/overlayfs/file.c > > +++ b/fs/overlayfs/file.c > > @@ -541,46 +541,26 @@ static long ovl_real_ioctl(struct file *file, unsigned int cmd, > > unsigned long arg) > > { > > struct fd real; > > - const struct cred *old_cred; > > long ret; > > > > ret = ovl_real_fdget(file, &real); > > if (ret) > > return ret; > > > > - old_cred = ovl_override_creds(file_inode(file)->i_sb); > > ret = security_file_ioctl(real.file, cmd, arg); > > if (!ret) > > ret = vfs_ioctl(real.file, cmd, arg); > > - revert_creds(old_cred); > > > > fdput(real); > > > > return ret; > > } > > > > > I wonder if we shouldn't leave a comment behind to explain > that no override is intentional. Comment added. > I also wonder if "Permission model" sections shouldn't be saying > something about ioctl() (current task checks only)? or we just treat > this is a breakage of the permission model that needs to be fixed? This is a breakage of the permission model. But I don't think this is a serious breakage, or one that actually matters. Not sure which is better: adding exceptions to the model or applying the model in situations where it's unnecessary. I'd rather go with the latter, but clearly in this case that was the wrong decision. Thanks, Miklos
On Wed, Dec 9, 2020 at 3:01 AM James Morris <jmorris@namei.org> wrote: > > On Mon, 7 Dec 2020, Miklos Szeredi wrote: > > > ovl_ioctl_set_flags() does a capability check using flags, but then the > > real ioctl double-fetches flags and uses potentially different value. > > > > The "Check the capability before cred override" comment misleading: user > > can skip this check by presenting benign flags first and then overwriting > > them to non-benign flags. > > Is this a security bug which should be fixed in stable? Yes, good point. Added Cc: stable@... Thanks, Miklos
On Thu, Dec 10, 2020 at 5:18 PM Miklos Szeredi <miklos@szeredi.hu> wrote: > > On Tue, Dec 8, 2020 at 12:15 PM Amir Goldstein <amir73il@gmail.com> wrote: > > > > On Mon, Dec 7, 2020 at 6:36 PM Miklos Szeredi <mszeredi@redhat.com> wrote: > > > > > > ovl_ioctl_set_flags() does a capability check using flags, but then the > > > real ioctl double-fetches flags and uses potentially different value. > > > > > > The "Check the capability before cred override" comment misleading: user > > > can skip this check by presenting benign flags first and then overwriting > > > them to non-benign flags. > > > > > > Just remove the cred override for now, hoping this doesn't cause a > > > regression. > > > > > > The proper solution is to create a new setxflags i_op (patches are in the > > > works). > > > > > > Xfstests don't show a regression. > > > > > > Reported-by: Dmitry Vyukov <dvyukov@google.com> > > > Signed-off-by: Miklos Szeredi <mszeredi@redhat.com> > > > > Looks reasonable > > > > Reviewed-by: Amir Goldstein <amir73il@gmail.com> > > > > > --- > > > fs/overlayfs/file.c | 75 ++------------------------------------------- > > > 1 file changed, 3 insertions(+), 72 deletions(-) > > > > > > diff --git a/fs/overlayfs/file.c b/fs/overlayfs/file.c > > > index efccb7c1f9bc..3cd1590f2030 100644 > > > --- a/fs/overlayfs/file.c > > > +++ b/fs/overlayfs/file.c > > > @@ -541,46 +541,26 @@ static long ovl_real_ioctl(struct file *file, unsigned int cmd, > > > unsigned long arg) > > > { > > > struct fd real; > > > - const struct cred *old_cred; > > > long ret; > > > > > > ret = ovl_real_fdget(file, &real); > > > if (ret) > > > return ret; > > > > > > - old_cred = ovl_override_creds(file_inode(file)->i_sb); > > > ret = security_file_ioctl(real.file, cmd, arg); > > > if (!ret) > > > ret = vfs_ioctl(real.file, cmd, arg); > > > - revert_creds(old_cred); > > > > > > fdput(real); > > > > > > return ret; > > > } > > > > > > > > > I wonder if we shouldn't leave a comment behind to explain > > that no override is intentional. > > Comment added. > > > I also wonder if "Permission model" sections shouldn't be saying > > something about ioctl() (current task checks only)? or we just treat > > this is a breakage of the permission model that needs to be fixed? > > This is a breakage of the permission model. But I don't think this is > a serious breakage, or one that actually matters. > Perhaps, but there is a much bigger issue with this change IMO. Not because of dropping rule (b) of the permission model, but because of relaxing rule (a). Should overlayfs respect the conservative interpretation as it partly did until this commit, a lower file must not lose IMMUTABLE/APPEND_ONLY after copy up, but that is exactly what is going to happen if we first copy up and then fail permission check on setting the flags. It's true that before this change, file could still be copied up and system crash would leave it without the flags, but after the change it is much worse as the flags completely lose their meaning on lower files when any unprivileged process can remove them. So I suggest that you undo all the changes except for the no override. And this calls for a fork of generic/545 to overlay test with lower files. Thanks, Amir.
On Mon, Dec 14, 2020 at 6:44 AM Amir Goldstein <amir73il@gmail.com> wrote: > Perhaps, but there is a much bigger issue with this change IMO. > Not because of dropping rule (b) of the permission model, but because > of relaxing rule (a). > > Should overlayfs respect the conservative interpretation as it partly did > until this commit, a lower file must not lose IMMUTABLE/APPEND_ONLY > after copy up, but that is exactly what is going to happen if we first > copy up and then fail permission check on setting the flags. Yeah, it's a mess. This will hopefully sort it out, as it will allow easier copy up of flags: https://lore.kernel.org/linux-fsdevel/20201123141207.GC327006@miu.piliscsaba.redhat.com/ In actual fact losing S_APPEND is not currently prevented by copy-up triggered by anything other than FS_IOC_SETX*, and even that is prone to races as indicated by the bug report that resulted in this patch. Let's just fix the IMMUTABLE case: - if the file is already copied up with data (since the overlay ioctl implementation currently uses the realdata), then we're fine to copy up - if the file is not IMMUTABLE to start with, then also fine to copy up; even if the op will fail after copy up we haven't done anything that wouldn't be possible without this particular codepath - if task has CAP_LINUX_IMMUTABLE (can add/remove immutable) then it's also fine to copy up since we can be fairly sure that the actual setflags will succeed as well. If not, that can be a problem, but as I've said copying up IMMUTABLE and other flags should really be done by the copy up code, otherwise it won't work properly. Something like this incremental should be good, I think: @@ -576,6 +576,15 @@ static long ovl_ioctl_set_flags(struct f inode_lock(inode); + /* + * Prevent copy up if immutable and has no CAP_LINUX_IMMUTABLE + * capability. + */ + ret = -EPERM; + if (!ovl_has_upperdata(inode) && IS_IMMUTABLE(inode) && + !capable(CAP_LINUX_IMMUTABLE)) + goto unlock; + ret = ovl_maybe_copy_up(file_dentry(file), O_WRONLY); if (ret) goto unlock; Thanks, Miklos
On Mon, Dec 14, 2020 at 3:24 PM Miklos Szeredi <miklos@szeredi.hu> wrote: > > On Mon, Dec 14, 2020 at 6:44 AM Amir Goldstein <amir73il@gmail.com> wrote: > > > Perhaps, but there is a much bigger issue with this change IMO. > > Not because of dropping rule (b) of the permission model, but because > > of relaxing rule (a). > > > > Should overlayfs respect the conservative interpretation as it partly did > > until this commit, a lower file must not lose IMMUTABLE/APPEND_ONLY > > after copy up, but that is exactly what is going to happen if we first > > copy up and then fail permission check on setting the flags. > > Yeah, it's a mess. This will hopefully sort it out, as it will allow > easier copy up of flags: > > https://lore.kernel.org/linux-fsdevel/20201123141207.GC327006@miu.piliscsaba.redhat.com/ > > In actual fact losing S_APPEND is not currently prevented by copy-up > triggered by anything other than FS_IOC_SETX*, and even that is prone > to races as indicated by the bug report that resulted in this patch. > > Let's just fix the IMMUTABLE case: > > - if the file is already copied up with data (since the overlay > ioctl implementation currently uses the realdata), then we're fine to > copy up > > - if the file is not IMMUTABLE to start with, then also fine to copy > up; even if the op will fail after copy up we haven't done anything > that wouldn't be possible without this particular codepath > > - if task has CAP_LINUX_IMMUTABLE (can add/remove immutable) then > it's also fine to copy up since we can be fairly sure that the actual > setflags will succeed as well. If not, that can be a problem, but as > I've said copying up IMMUTABLE and other flags should really be done > by the copy up code, otherwise it won't work properly. > > Something like this incremental should be good, I think: > > @@ -576,6 +576,15 @@ static long ovl_ioctl_set_flags(struct f > > inode_lock(inode); > > + /* > + * Prevent copy up if immutable and has no CAP_LINUX_IMMUTABLE > + * capability. > + */ > + ret = -EPERM; > + if (!ovl_has_upperdata(inode) && IS_IMMUTABLE(inode) && > + !capable(CAP_LINUX_IMMUTABLE)) > + goto unlock; > + > ret = ovl_maybe_copy_up(file_dentry(file), O_WRONLY); > if (ret) > goto unlock; > I guess that looks ok for a band aid. Thanks, Amir.
diff --git a/fs/overlayfs/file.c b/fs/overlayfs/file.c index efccb7c1f9bc..3cd1590f2030 100644 --- a/fs/overlayfs/file.c +++ b/fs/overlayfs/file.c @@ -541,46 +541,26 @@ static long ovl_real_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { struct fd real; - const struct cred *old_cred; long ret; ret = ovl_real_fdget(file, &real); if (ret) return ret; - old_cred = ovl_override_creds(file_inode(file)->i_sb); ret = security_file_ioctl(real.file, cmd, arg); if (!ret) ret = vfs_ioctl(real.file, cmd, arg); - revert_creds(old_cred); fdput(real); return ret; } -static unsigned int ovl_iflags_to_fsflags(unsigned int iflags) -{ - unsigned int flags = 0; - - if (iflags & S_SYNC) - flags |= FS_SYNC_FL; - if (iflags & S_APPEND) - flags |= FS_APPEND_FL; - if (iflags & S_IMMUTABLE) - flags |= FS_IMMUTABLE_FL; - if (iflags & S_NOATIME) - flags |= FS_NOATIME_FL; - - return flags; -} - static long ovl_ioctl_set_flags(struct file *file, unsigned int cmd, - unsigned long arg, unsigned int flags) + unsigned long arg) { long ret; struct inode *inode = file_inode(file); - unsigned int oldflags; if (!inode_owner_or_capable(inode)) return -EACCES; @@ -591,12 +571,6 @@ static long ovl_ioctl_set_flags(struct file *file, unsigned int cmd, inode_lock(inode); - /* Check the capability before cred override */ - oldflags = ovl_iflags_to_fsflags(READ_ONCE(inode->i_flags)); - ret = vfs_ioc_setflags_prepare(inode, oldflags, flags); - if (ret) - goto unlock; - ret = ovl_maybe_copy_up(file_dentry(file), O_WRONLY); if (ret) goto unlock; @@ -613,46 +587,6 @@ static long ovl_ioctl_set_flags(struct file *file, unsigned int cmd, } -static long ovl_ioctl_set_fsflags(struct file *file, unsigned int cmd, - unsigned long arg) -{ - unsigned int flags; - - if (get_user(flags, (int __user *) arg)) - return -EFAULT; - - return ovl_ioctl_set_flags(file, cmd, arg, flags); -} - -static unsigned int ovl_fsxflags_to_fsflags(unsigned int xflags) -{ - unsigned int flags = 0; - - if (xflags & FS_XFLAG_SYNC) - flags |= FS_SYNC_FL; - if (xflags & FS_XFLAG_APPEND) - flags |= FS_APPEND_FL; - if (xflags & FS_XFLAG_IMMUTABLE) - flags |= FS_IMMUTABLE_FL; - if (xflags & FS_XFLAG_NOATIME) - flags |= FS_NOATIME_FL; - - return flags; -} - -static long ovl_ioctl_set_fsxflags(struct file *file, unsigned int cmd, - unsigned long arg) -{ - struct fsxattr fa; - - memset(&fa, 0, sizeof(fa)); - if (copy_from_user(&fa, (void __user *) arg, sizeof(fa))) - return -EFAULT; - - return ovl_ioctl_set_flags(file, cmd, arg, - ovl_fsxflags_to_fsflags(fa.fsx_xflags)); -} - long ovl_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { long ret; @@ -663,12 +597,9 @@ long ovl_ioctl(struct file *file, unsigned int cmd, unsigned long arg) ret = ovl_real_ioctl(file, cmd, arg); break; - case FS_IOC_SETFLAGS: - ret = ovl_ioctl_set_fsflags(file, cmd, arg); - break; - case FS_IOC_FSSETXATTR: - ret = ovl_ioctl_set_fsxflags(file, cmd, arg); + case FS_IOC_SETFLAGS: + ret = ovl_ioctl_set_flags(file, cmd, arg); break; default:
ovl_ioctl_set_flags() does a capability check using flags, but then the real ioctl double-fetches flags and uses potentially different value. The "Check the capability before cred override" comment misleading: user can skip this check by presenting benign flags first and then overwriting them to non-benign flags. Just remove the cred override for now, hoping this doesn't cause a regression. The proper solution is to create a new setxflags i_op (patches are in the works). Xfstests don't show a regression. Reported-by: Dmitry Vyukov <dvyukov@google.com> Signed-off-by: Miklos Szeredi <mszeredi@redhat.com> --- fs/overlayfs/file.c | 75 ++------------------------------------------- 1 file changed, 3 insertions(+), 72 deletions(-)