blob: 8fafab05184f85018c04a842aefdbeb479002af5 [file]
// SPDX-License-Identifier: MPL-2.0 OR LGPL-3.0-or-later
/*
* libpathrs: safe path resolution on Linux
* Copyright (C) 2019-2025 SUSE LLC
* Copyright (C) 2026 Aleksa Sarai <cyphar@cyphar.com>
*
* == MPL-2.0 ==
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
*
* Alternatively, this Source Code Form may also (at your option) be used
* under the terms of the GNU Lesser General Public License Version 3, as
* described below:
*
* == LGPL-3.0-or-later ==
*
* This program is free software: you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
* Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
use crate::{
error::{Error, ErrorExt, ErrorImpl},
flags::OpenFlags,
syscalls,
};
use std::{
ffi::OsStr,
os::unix::{ffi::OsStrExt, io::AsFd},
path::Path,
};
use rustix::fs::{AtFlags, Dir};
trait RmdirResultExt {
// ENOENT from a removal function should be treated the same as an Ok(()).
fn ignore_enoent(self) -> Self;
}
impl RmdirResultExt for Result<(), Error> {
fn ignore_enoent(self) -> Self {
match self.map_err(|err| (err.kind().errno(), err)) {
Ok(()) | Err((Some(libc::ENOENT), _)) => Ok(()),
Err((_, err)) => Err(err),
}
}
}
fn remove_inode(dirfd: impl AsFd, name: impl AsRef<Path>) -> Result<(), Error> {
let dirfd = dirfd.as_fd();
let name = name.as_ref();
// To ensure we return a useful error, we try both unlink and rmdir and
// try to avoid returning EISDIR/ENOTDIR if both failed.
syscalls::unlinkat(dirfd, name, AtFlags::empty())
.or_else(|unlink_err| {
syscalls::unlinkat(dirfd, name, AtFlags::REMOVEDIR).map_err(|rmdir_err| {
if rmdir_err.root_cause().raw_os_error() == Some(libc::ENOTDIR) {
unlink_err
} else {
rmdir_err
}
})
})
.map_err(|err| {
ErrorImpl::RawOsError {
operation: "remove inode".into(),
source: err,
}
.into()
})
}
pub(crate) fn remove_all(dirfd: impl AsFd, name: impl AsRef<Path>) -> Result<(), Error> {
let dirfd = dirfd.as_fd();
let name = name.as_ref();
if name.as_os_str().as_bytes().contains(&b'/') {
Err(ErrorImpl::SafetyViolation {
description: "remove_all reached a component containing '/'".into(),
})?;
}
// Fast path -- try to remove it with unlink/rmdir.
if remove_inode(dirfd, name).ignore_enoent().is_ok() {
return Ok(());
}
// Try to delete all children. We need to re-do the iteration until there
// are no components left because deleting entries while iterating over a
// directory can lead to the iterator skipping components. An attacker could
// try to make this loop forever by consistently creating inodes, but
// there's not much we can do about it and I suspect they would eventually
// lose the race.
let subdir = match syscalls::openat(dirfd, name, OpenFlags::O_DIRECTORY, 0).map_err(|err| {
ErrorImpl::RawOsError {
operation: "open directory to scan entries".into(),
source: err,
}
}) {
Ok(fd) => fd,
Err(err) => match err.kind().errno() {
// The path was deleted between us trying to with remove_inode() and
// now -- just return as if we were the ones that deleted it.
Some(libc::ENOENT) => return Ok(()),
_ => Err(err)?,
},
};
loop {
// TODO: Dir creates a new file descriptor rather than reusing the one
// we have, and RawDir can't be used as an Iterator yet (rustix
// needs GAT to make that work). But this is okay for now...
let mut iter = match Dir::read_from(&subdir)
.map_err(|err| ErrorImpl::OsError {
operation: "create directory iterator".into(),
source: err.into(),
})
.with_wrap(|| format!("scan directory {name:?} for deletion"))
{
Ok(iter) => iter,
Err(err) => match err.kind().errno() {
// If we got ENOENT that means the directory got deleted after
// we opened it, so stop iterating (maybe another thread did "rm
// -rf"). An attacker might've also replaced the directory but
// we're not going retry opening it because that could lead to a
// DoS. remove_inode will error out in that case, and that's
// fine.
Some(libc::ENOENT) => break,
// TODO: Maybe we want to just break out of the loop here as
// well, rather than return an error? If remove_inode()
// again succeeds we're golden.
_ => Err(err)?,
},
}
.filter(|res| {
!matches!(
res.as_ref().map(|dentry| dentry.file_name().to_bytes()),
Ok(b".") | Ok(b"..")
)
})
.peekable();
// We can stop iterating when a fresh directory iterator is empty.
if iter.peek().is_none() {
break;
}
// Recurse into all of the children and try to delete them.
for child in iter {
// TODO: We probably want to break out of the scan loop here if this
// is an error as well.
let child = child.map_err(|err| ErrorImpl::OsError {
operation: format!("scan directory {name:?}").into(),
source: err.into(),
})?;
let name: &Path = OsStr::from_bytes(child.file_name().to_bytes()).as_ref();
remove_all(&subdir, name).ignore_enoent()?
}
}
// We have deleted all of the children of the directory, let's try to delete
// the inode again (it should be empty now -- an attacker could add things
// but we can just error out in that case, and if they swapped it to a file
// then remove_inode will take care of that).
remove_inode(dirfd, name)
.ignore_enoent()
.with_wrap(|| format!("deleting emptied directory {name:?}"))
}
#[cfg(test)]
mod tests {
use super::remove_all;
use crate::{error::ErrorKind, tests::common as tests_common, Root};
use std::{os::unix::io::OwnedFd, path::Path};
use anyhow::Error;
use pretty_assertions::assert_eq;
#[test]
fn remove_all_basic() -> Result<(), Error> {
let dir = tests_common::create_basic_tree()?;
let dirfd: OwnedFd = Root::open(&dir)?.into();
assert_eq!(
remove_all(&dirfd, Path::new("a")).map_err(|err| err.kind()),
Ok(()),
"removeall(root, 'a') should work",
);
assert_eq!(
remove_all(&dirfd, Path::new("b")).map_err(|err| err.kind()),
Ok(()),
"removeall(root, 'b') should work",
);
assert_eq!(
remove_all(&dirfd, Path::new("c")).map_err(|err| err.kind()),
Ok(()),
"removeall(root, 'c') should work",
);
let _dir = dir; // make sure the tempdir is not dropped early
Ok(())
}
#[test]
fn remove_all_slash_path() -> Result<(), Error> {
let dir = tests_common::create_basic_tree()?;
let dirfd: OwnedFd = Root::open(&dir)?.into();
assert_eq!(
remove_all(&dirfd, Path::new("/")).map_err(|err| err.kind()),
Err(ErrorKind::SafetyViolation),
"removeall(root, '/') should fail",
);
assert_eq!(
remove_all(&dirfd, Path::new("./a")).map_err(|err| err.kind()),
Err(ErrorKind::SafetyViolation),
"removeall(root, './a') should fail",
);
assert_eq!(
remove_all(&dirfd, Path::new("a/")).map_err(|err| err.kind()),
Err(ErrorKind::SafetyViolation),
"removeall(root, 'a/') should fail",
);
let _dir = dir; // make sure the tempdir is not dropped early
Ok(())
}
}