Question

我需要动态加载几个可能不安全的模块以进行测试。

关于安全性，我的脚本由低访问权限的用户执行。

尽管，我仍然需要一种使导入过程超时的方法，因为我不能保证模块脚本将终止。例如，它可以包含对input的调用或无限循环。

我目前正在将Thread.join与timeout一起使用，但这不能完全解决问题，因为该脚本仍在后台运行并且无法杀死线程。

from threading import Thread
import importlib.util

class ReturnThread(Thread):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._return = None

    def run(self):
        if self._target is not None:
            self._return = self._target(*self._args, **self._kwargs)

    def join(self, *args, **kwargs):
        super().join(*args, **kwargs)
        return self._return

def loader(name, path):
    spec = importlib.util.spec_from_file_location(name, path)
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module) # This may run into an infinite loop
    return module

module_loader = ReturnThread(loader, ('module_name', 'module/path'))
module_loader.start()
module = module_loader.join(timeout=0.1)

# The thread might still be alive here
if module is None:
    ...
else:
    ...

如何导入模块，但是如果脚本超时，则返回None？

Answer 1

您无法可靠地终止导入模块。本质上，您是在自己的解释器中执行实时代码，因此所有赌注都没有了。

从不导入不受信任的代码

首先，没有办法从不受信任的来源安全地导入不安全的模块。如果您使用的是低访问量用户，则无关紧要。 切勿导入未验证的代码。导入代码的那一刻，它可能已经利用了系统中的安全漏洞，远远超出了Python进程本身。 Python是一种通用的编程语言，而不是沙盒环境，并且您导入的任何代码都具有系统的完整功能

至少要运行，而不是使用访问权限较低的用户，而是一个虚拟机。可以从已知良好的快照设置虚拟机环境，而无需访问网络，并在达到时间限制后将其关闭。然后，您可以比较快照以查看代码尝试执行的操作（如果有）。该级别的任何安全漏洞都是短暂的，没有价值。另请参阅软件工程堆栈交换上的Best practices for execution of untrusted code。

您无法停止撤消工作的代码

接下来，由于您无法控制导入的代码所执行的操作，因此它可能会干扰任何使代码超时的尝试。导入的代码可以做的第一件事是撤销您设置的保护！导入的代码可以访问Python的所有全局状态，包括触发导入的代码。该代码可以将thread switch interval设置为最大值（内部为无符号的长建模毫秒，因此最大值为((2 ** 32) - 1)毫秒，仅是71分钟35秒内的smidgen）以扰乱调度。

如果不想停止线程，则不能可靠地停止线程

在Python中退出线程为handled by raising a exception：

引发SystemExit异常。 未被捕获时，这将导致线程静默退出。

（加粗强调）。

从纯Python代码中，您只能从在该线程中运行的代码中退出线程，但是有一种解决方法，请参见下文。

但是您不能保证所导入的代码不仅仅是捕获和处理所有异常；如果是这种情况，代码将继续运行。在那时，它成为一场武器竞赛。您的线程可以设法在另一个线程位于异常处理程序内部的位置插入异常吗？然后，您可以退出该线程，否则会丢失。您必须继续尝试，直到成功为止。

在本机扩展中等待阻塞I / O或启动阻塞操作的线程无法（轻松）杀死

如果您导入的代码正在等待阻止I / O（例如input()调用），则您将无法中断该调用。引发异常无济于事，并且您不能使用信号（因为Python仅在主线程上处理信号）。您必须找到并关闭它们可能被阻塞的每个打开的I / O通道。这超出了我的回答范围，开始I / O操作的方法太多。

如果代码启动了以本机代码（Python扩展）实现的某事并且被阻止，则所有赌注将完全取消。

您的解释器状态可以在您停止它们时显示出来

导入的代码在设法停止它们之前可能已经完成了任何事情。导入的模块可能已更换。磁盘上的源代码可能已更改。您不能确定没有其他线程已启动。在Python中一切皆有可能，因此请假定已发生。

如果您想这样做

请记住这些警告，因此您可以接受

您导入的代码可能会对正在运行的操作系统执行恶意操作，而无法阻止它们在同一进程甚至操作系统中停止运行
您导入的代码可能会使您的代码无法正常工作。
您导入的代码可能已经导入并启动了您不想导入或启动的内容。
代码可能会启动阻止您完全停止线程的操作

然后您可以通过在单独的线程中运行它们来使导入超时，然后在线程中引发SystemExit异常。您可以通过PyThreadState_SetAsyncExc C-API function调用ctypes.pythonapi object在另一个线程中引发异常。 Python测试套件actually uses this path in a test，下面将其用作解决方案的模板。

因此，这是一个完整的实现，它会执行此操作，并在无法中断导入的情况下引发自定义UninterruptableImport异常（ImportError的子类）。如果导入引发异常，那么将在启动导入过程的线程中重新引发该异常：

"""Import a module within a timeframe

Uses the PyThreadState_SetAsyncExc C API and a signal handler to interrupt
the stack of calls triggered from an import within a timeframe

No guarantees are made as to the state of the interpreter after interrupting

"""

import ctypes
import importlib
import random
import sys
import threading
import time

_set_async_exc = ctypes.pythonapi.PyThreadState_SetAsyncExc
_set_async_exc.argtypes = (ctypes.c_ulong, ctypes.py_object)
_system_exit = ctypes.py_object(SystemExit)


class UninterruptableImport(ImportError):
    pass


class TimeLimitedImporter():
    def __init__(self, modulename, timeout=5):
        self.modulename = modulename
        self.module = None
        self.exception = None
        self.timeout = timeout

        self._started = None
        self._started_event = threading.Event()
        self._importer = threading.Thread(target=self._import, daemon=True)
        self._importer.start()
        self._started_event.wait()

    def _import(self):
        self._started = time.time()
        self._started_event.set()
        timer = threading.Timer(self.timeout, self.exit)
        timer.start()
        try:
            self.module = importlib.import_module(self.modulename)
        except Exception as e:
            self.exception = e
        finally:
            timer.cancel()

    def result(self, timeout=None):
        # give the importer a chance to finish first
        if timeout is not None:
            timeout += max(time.time() + self.timeout - self._started, 0)
        self._importer.join(timeout)
        if self._importer.is_alive():
            raise UninterruptableImport(
                f"Could not interrupt the import of {self.modulename}")
        if self.module is not None:
            return self.module
        if self.exception is not None:
            raise self.exception

    def exit(self):
        target_id = self._importer.ident
        if target_id is None:
            return
        # set a very low switch interval to be able to interrupt an exception
        # handler if SystemExit is being caught
        old_interval = sys.getswitchinterval()
        sys.setswitchinterval(1e-6)

        try:
            # repeatedly raise SystemExit until the import thread has exited.
            # If the exception is being caught by a an exception handler,
            # our only hope is to raise it again *while inside the handler*
            while True:
                _set_async_exc(target_id, _system_exit)

                # short randomised wait times to 'surprise' an exception
                # handler
                self._importer.join(
                    timeout=random.uniform(1e-4, 1e-5)
                )
                if not self._importer.is_alive():
                    return
        finally:
            sys.setswitchinterval(old_interval)


def import_with_timeout(modulename, import_timeout=5, exit_timeout=1):
    importer = TimeLimitedImporter(modulename, import_timeout)
    return importer.result(exit_timeout)

如果无法终止代码，它将在守护程序线程中运行，这意味着您至少可以正常退出Python。

像这样使用它：

module = import_with_timeout(modulename)

默认5秒钟的超时时间，然后等待1秒钟，以查看导入是否确实不可杀。

如何动态导入超时的不安全Python模块？

1 个答案: