如何检查一个目录是否是另一个目录的子目录

Question

我喜欢用 Python 编写一个模板系统，它允许包含文件。

例如

这是一个模板 您可以使用 safe_include`othertemplate.rst` 安全地包含文件

如您所知，包含文件可能很危险。例如，如果我在允许用户创建自己的模板的 Web 应用程序中使用模板系统，他们可能会执行类似

我想要你的密码：safe_include`/etc/password`

因此，我必须将文件的包含限制为例如位于某个子目录中的文件（例如/home/user/templates）

现在的问题是：如何检查/home/user/templates/includes/inc1.rst 是否在/home/user/templates 的子目录中？

下面的代码会工作并且安全吗？

import os.path

def in_directory(file, directory, allow_symlink = False):
    #make both absolute    
    directory = os.path.abspath(directory)
    file = os.path.abspath(file)

    #check whether file is a symbolic link, if yes, return false if they are not allowed
    if not allow_symlink and os.path.islink(file):
        return False

    #return true, if the common prefix of both is equal to directory
    #e.g. /a/b/c/d.rst and directory is /a/b, the common prefix is /a/b
    return os.path.commonprefix([file, directory]) == directory

只要allow_symlink 为False，我认为它应该是安全的。如果用户能够创建此类链接，则允许符号链接当然会使其不安全。

更新 - 解决方案 如果中间目录是符号链接，则上面的代码不起作用。 为了防止这种情况，您必须使用realpath 而不是abspath。

更新：在目录后面添加 / 以解决 commonprefix() Reorx 指出的问题。

这也使得allow_symlink 变得不必要，因为符号链接会扩展到它们的真实目的地

import os.path

def in_directory(file, directory):
    #make both absolute    
    directory = os.path.join(os.path.realpath(directory), '')
    file = os.path.realpath(file)

    #return true, if the common prefix of both is equal to directory
    #e.g. /a/b/c/d.rst and directory is /a/b, the common prefix is /a/b
    return os.path.commonprefix([file, directory]) == directory

Answer 1

许多建议方法的问题

如果您要使用字符串比较或os.path.commonprefix 方法测试目录父级，则这些方法很容易出现类似命名路径或相对路径的错误。例如：

• /path/to/files/myfile 将使用许多方法显示为 /path/to/file 的子路径。
• /path/to/files/../../myfiles 不会被许多方法显示为/path/myfiles/myfile 的父级。事实上，确实如此。

Rob Dennis 的previous answer 提供了一种比较路径亲子关系而不遇到这些问题的好方法。 Python 3.4 添加了pathlib 模块，该模块可以以更复杂的方式执行此类路径操作，可选择不引用底层操作系统。 jme 在another previous answer 中描述了如何使用pathlib 来准确确定一条路径是否是另一条路径的子路径。如果您不想使用pathlib（不知道为什么，这非常棒），那么 Python 3.5 在os.path 中引入了一种新的基于操作系统的方法，允许您以同样准确和错误的方式执行路径父子检查 -免费方式，代码少得多。

Python 3.5 的新功能

Python 3.5 引入了函数os.path.commonpath。这是一种特定于运行代码的操作系统的方法。您可以通过以下方式使用commonpath来准确确定路径父级：

def path_is_parent(parent_path, child_path):
    # Smooth out relative path names, note: if you are concerned about symbolic links, you should use os.path.realpath too
    parent_path = os.path.abspath(parent_path)
    child_path = os.path.abspath(child_path)

    # Compare the common path of the parent and child path with the common path of just the parent path. Using the commonpath method on just the parent path will regularise the path name in the same way as the comparison that deals with both paths, removing any trailing path separator
    return os.path.commonpath([parent_path]) == os.path.commonpath([parent_path, child_path])

准确的单线

您可以在 Python 3.5 中将所有内容组合成一行 if 语句。这很丑陋，它包含对os.path.abspath 的不必要重复调用，而且它绝对不符合 PEP 8 79 字符行长指南，但如果你喜欢这种东西，这里是：

if os.path.commonpath([os.path.abspath(parent_path_to_test)]) == os.path.commonpath([os.path.abspath(parent_path_to_test), os.path.abspath(child_path_to_test)]):
    # Yes, the child path is under the parent path

Python 3.9 的新功能

pathlib 在PurePath 上有一个名为is_relative_to 的新方法，它直接执行此功能。如果您需要了解如何使用它，可以阅读the python documentation on how is_relative_to works。或者您可以查看my other answer 以获得更完整的使用说明。

Answer 2

Python 3.9 的新功能

pathlib 在PurePath 上有一个名为is_relative_to 的新方法，它直接执行此功能。你可以阅读the python documentation on how is_relative_to works，或者使用这个例子：

from pathlib import Path

child_path = Path("/path/to/file")
if child_path.is_relative_to("/path"):
    print("/path/to/file is a child of /path") # This prints
if child_path.is_relative_to("/anotherpath"):
    print("/path/to/file is a child of /anotherpath") # This does not print

Answer 3

在您的启发下，此方法已添加到我的实用程序中：

def is_in_basefolder(path_to_check: PosixPath, basefolder: PosixPath):
        """
        check if a given path is in base folder
        
        parameters:
            path_to_check: a path to match with base folder
            basefolder: the base folder
        """
        path = path_to_check.resolve()
        base = basefolder.resolve()
        
        if path == base:
            return True
        
        if base.stem in path.parts:
            return True
        else:
            return False

Answer 4

我用下面的函数来解决类似的问题：

def is_subdir(p1, p2):
    """returns true if p1 is p2 or its subdirectory"""
    p1, p2 = os.path.realpath(p1), os.path.realpath(p2)
    return p1 == p2 or p1.startswith(p2+os.sep)

在遇到符号链接问题后，我修改了函数。现在它检查两个路径是否都是目录。

def is_subdir(p1, p2):
    """check if p1 is p2 or its subdirectory
    :param str p1: subdirectory candidate
    :param str p2: parent directory
    :returns True if p1,p2 are directories and p1 is p2 or its subdirectory"""
    if os.path.isdir(p1) and os.path.isdir(p2):
        p1, p2 = os.path.realpath(p1), os.path.realpath(p2)
        return p1 == p2 or p1.startswith(p2+os.sep)
    else:
        return False

Answer 5

def is_in_directory(filepath, directory):
    return os.path.realpath(filepath).startswith(
        os.path.realpath(directory) + os.sep)

Answer 6

我喜欢另一个答案中提到的“other_path.parents 中的路径”，因为我是 pathlib 的忠实粉丝，但我觉得这种方法有点重（它为每个父路径创建一个路径实例到路径的根）。在这种情况下 path == other_path 也会失败，而 os.commonpath 在这种情况下会成功。

以下是一种不同的方法，与各种答案中确定的其他方法相比，它有自己的优缺点：

try:
   other_path.relative_to(path)
except ValueError:
   ...no common path...
else:
   ...common path...

这有点冗长，但可以很容易地作为函数添加到应用程序的公共实用程序模块中，甚至可以在启动时将方法添加到 Path 中。

Answer 7

Python 3 的 pathlib 模块通过其 Path.parents 属性使这一点变得简单。例如：

from pathlib import Path

root = Path('/path/to/root')
child = root / 'some' / 'child' / 'dir'
other = Path('/some/other/path')

然后：

>>> root in child.parents
True
>>> other in child.parents
False

Answer 8

基于此处的另一个答案，经过更正，并具有用户友好的名称：

def isA_subdirOfB_orAisB(A, B):
    """It is assumed that A is a directory."""
    relative = os.path.relpath(os.path.realpath(A), 
                               os.path.realpath(B))
    return not (relative == os.pardir
            or  relative.startswith(os.pardir + os.sep))

Answer 9

def is_subdir(path, directory):
    path = os.path.realpath(path)
    directory = os.path.realpath(directory)
    relative = os.path.relpath(path, directory)
    return not relative.startswith(os.pardir + os.sep)

Answer 10

所以，我需要这个，并且由于对 commonprefx 的批评，我采取了不同的方式：

def os_path_split_asunder(path, debug=False):
    """
    http://stackoverflow.com/a/4580931/171094
    """
    parts = []
    while True:
        newpath, tail = os.path.split(path)
        if debug: print repr(path), (newpath, tail)
        if newpath == path:
            assert not tail
            if path: parts.append(path)
            break
        parts.append(tail)
        path = newpath
    parts.reverse()
    return parts


def is_subdirectory(potential_subdirectory, expected_parent_directory):
    """
    Is the first argument a sub-directory of the second argument?

    :param potential_subdirectory:
    :param expected_parent_directory:
    :return: True if the potential_subdirectory is a child of the expected parent directory

    >>> is_subdirectory('/var/test2', '/var/test')
    False
    >>> is_subdirectory('/var/test', '/var/test2')
    False
    >>> is_subdirectory('var/test2', 'var/test')
    False
    >>> is_subdirectory('var/test', 'var/test2')
    False
    >>> is_subdirectory('/var/test/sub', '/var/test')
    True
    >>> is_subdirectory('/var/test', '/var/test/sub')
    False
    >>> is_subdirectory('var/test/sub', 'var/test')
    True
    >>> is_subdirectory('var/test', 'var/test')
    True
    >>> is_subdirectory('var/test', 'var/test/fake_sub/..')
    True
    >>> is_subdirectory('var/test/sub/sub2/sub3/../..', 'var/test')
    True
    >>> is_subdirectory('var/test/sub', 'var/test/fake_sub/..')
    True
    >>> is_subdirectory('var/test', 'var/test/sub')
    False
    """

    def _get_normalized_parts(path):
        return os_path_split_asunder(os.path.realpath(os.path.abspath(os.path.normpath(path))))

    # make absolute and handle symbolic links, split into components
    sub_parts = _get_normalized_parts(potential_subdirectory)
    parent_parts = _get_normalized_parts(expected_parent_directory)

    if len(parent_parts) > len(sub_parts):
        # a parent directory never has more path segments than its child
        return False

    # we expect the zip to end with the short path, which we know to be the parent
    return all(part1==part2 for part1, part2 in zip(sub_parts, parent_parts))

Answer 11

我会根据文件名测试 commonprefix 的结果以获得更好的答案，如下所示：

def is_in_folder(filename, folder='/tmp/'):
    # normalize both parameters
    fn = os.path.normpath(filename)
    fd = os.path.normpath(folder)

    # get common prefix
    commonprefix = os.path.commonprefix([fn, fd])
    if commonprefix == fd:
        # in case they have common prefix, check more:
        sufix_part = fn.replace(fd, '')
        sufix_part = sufix_part.lstrip('/')
        new_file_name = os.path.join(fd, sufix_part)
        if new_file_name == fn:
            return True
        pass
    # for all other, it's False
    return False

Answer 12

os.path.realpath(path)：返回指定文件名的规范路径，排除路径中遇到的任何符号链接（如果操作系统支持的话）。

在目录和子目录名称上使用它，然后检查后者是否以前者开头。