Python pickle - 它是如何崩溃的？

Question

每个人都知道 pickle 不是存储用户数据的安全方式。盒子上也这么写。

我正在寻找在当前支持的 cPython >= 2.4 版本中破坏 pickle 解析的字符串或数据结构的示例。有没有可以腌制但不能解腌的东西？特定的 unicode 字符是否存在问题？真的是大数据结构吗？显然旧的 ASCII 协议存在一些问题，但是最新的二进制形式又如何呢？

我特别好奇 pickle loads 操作可能失败的方式，特别是当给定 pickle 本身生成的字符串时。在某些情况下，pickle 会继续解析 . 吗？

存在哪些类型的边缘情况？

编辑：以下是我正在寻找的一些示例：

• 在Python 2.4中，您可以毫无错误地pickle数组，但无法取消pickle它。 http://bugs.python.org/issue1281383
• 您无法可靠地pickle从 dict 继承的对象在使用 __setstate__ 设置实例变量之前调用 __setitem__。当酸洗 Cookie 对象时，这可能是一个陷阱。请参阅 http://bugs.python.org/issue964868 和 http://bugs.python.org/issue826897
• Python 2.4（和2.5？）将返回无穷大的pickle值（或接近它的值，例如1e100000 ），但加载时可能（取决于平台）失败。请参阅 http://bugs.python.org/issue880990 和 http://bugs.python.org/issue445484
• 最后一项很有趣，因为它揭示了 STOP 标记的情况实际上并不停止解析 - 当标记作为文字的一部分存在时，或者更一般地说，当前面没有换行符时。

Answer 1

这是一个非常简单的例子，说明了 pickle 不喜欢我的数据结构。

import cPickle as pickle

class Member(object):
    def __init__(self, key):
        self.key = key
        self.pool = None
    def __hash__(self):
        return self.key

class Pool(object):
    def __init__(self):
        self.members = set()
    def add_member(self, member):
        self.members.add(member)
        member.pool = self

member = Member(1)
pool = Pool()
pool.add_member(member)

with open("test.pkl", "w") as f:
    pickle.dump(member, f, pickle.HIGHEST_PROTOCOL)

with open("test.pkl", "r") as f:
    x = pickle.load(f)

众所周知，Pickle 的循环结构有点有趣，但如果你将自定义哈希函数和集合/字典混合在一起，那么事情就会变得非常棘手。

在这个特定的示例中，它部分地取消了成员的pickle，然后遇到了池。因此，它会部分地解开池并遇到成员集。因此它创建了集合并尝试将部分未腌制的成员添加到集合中。此时它会在自定义哈希函数中死亡，因为该成员仅部分 unpickled。我不敢想象如果哈希函数中有“if hasattr...”会发生什么。

$ python --version
Python 2.6.5
$ python test.py
Traceback (most recent call last):
  File "test.py", line 25, in <module>
    x = pickle.load(f)
  File "test.py", line 8, in __hash__
    return self.key
AttributeError: ("'Member' object has no attribute 'key'", <type 'set'>, ([<__main__.Member object at 0xb76cdaac>],))

Answer 2

如果您对 pickle（或 cPickle，因为它只是略有不同的导入）失败的情况感兴趣，您可以使用这个不断增长的所有不同对象类型的列表python 来测试相当容易。

https://github.com/uqfoundation/dill/blob/master/dill /_objects.py

包 dill 包含发现对象如何无法 pickle 的函数，例如通过捕获它抛出的错误并将其返回给用户。

dill.dill 具有这些函数，您也可以为 pickle 或 cPickle 构建这些函数，只需通过剪切和粘贴和 >import pickle 或 import cPickle as pickle （或 import dill as pickle）：

def copy(obj, *args, **kwds):
    """use pickling to 'copy' an object"""
    return loads(dumps(obj, *args, **kwds))


# quick sanity checking
def pickles(obj,exact=False,safe=False,**kwds):
    """quick check if object pickles with dill"""
    if safe: exceptions = (Exception,) # RuntimeError, ValueError
    else:
        exceptions = (TypeError, AssertionError, PicklingError, UnpicklingError)
    try:
        pik = copy(obj, **kwds)
        try:
            result = bool(pik.all() == obj.all())
        except AttributeError:
            result = pik == obj
        if result: return True
        if not exact:
            return type(pik) == type(obj)
        return False
    except exceptions:
        return False

并将这些包含在 dill.detect 中：

def baditems(obj, exact=False, safe=False): #XXX: obj=globals() ?
    """get items in object that fail to pickle"""
    if not hasattr(obj,'__iter__'): # is not iterable
        return [j for j in (badobjects(obj,0,exact,safe),) if j is not None]
    obj = obj.values() if getattr(obj,'values',None) else obj
    _obj = [] # can't use a set, as items may be unhashable
    [_obj.append(badobjects(i,0,exact,safe)) for i in obj if i not in _obj]
    return [j for j in _obj if j is not None]


def badobjects(obj, depth=0, exact=False, safe=False):
    """get objects that fail to pickle"""
    if not depth:
        if pickles(obj,exact,safe): return None
        return obj
    return dict(((attr, badobjects(getattr(obj,attr),depth-1,exact,safe)) \
           for attr in dir(obj) if not pickles(getattr(obj,attr),exact,safe)))

def badtypes(obj, depth=0, exact=False, safe=False):
    """get types for objects that fail to pickle"""
    if not depth:
        if pickles(obj,exact,safe): return None
        return type(obj)
    return dict(((attr, badtypes(getattr(obj,attr),depth-1,exact,safe)) \
           for attr in dir(obj) if not pickles(getattr(obj,attr),exact,safe)))

以及最后一个函数，您可以使用它来测试 dill._objects 中的对象

def errors(obj, depth=0, exact=False, safe=False):
    """get errors for objects that fail to pickle"""
    if not depth:
        try:
            pik = copy(obj)
            if exact:
                assert pik == obj, \
                    "Unpickling produces %s instead of %s" % (pik,obj)
            assert type(pik) == type(obj), \
                "Unpickling produces %s instead of %s" % (type(pik),type(obj))
            return None
        except Exception:
            import sys
            return sys.exc_info()[1]
    return dict(((attr, errors(getattr(obj,attr),depth-1,exact,safe)) \
           for attr in dir(obj) if not pickles(getattr(obj,attr),exact,safe)))

Answer 3

可以腌制类实例。如果我知道你的应用程序使用什么类，那么我就可以破坏它们。一个人为的示例：

import subprocess

class Command(object):
    def __init__(self, command):
        self._command = self._sanitize(command)

    @staticmethod
    def _sanitize(command):
        return filter(lambda c: c in string.letters, command)

    def run(self):
        subprocess.call('/usr/lib/myprog/%s' % self._command, shell=True)

现在，如果您的程序创建 Command 实例并使用 pickle 保存它们，并且我可以颠覆或注入该存储，那么我可以通过设置 self._command 运行我选择的任何命令直接。

实际上，我的示例无论如何都不应该被视为安全代码。但请注意，如果 sanitize 函数是安全的，那么整个类也是安全的，除了可能使用来自不受信任的数据的 pickle 来破坏这一点。因此，存在一些安全的程序，但由于pickle 的不当使用而变得不安全。

危险在于，使用 pickle 的代码可能会按照相同的原理被破坏，但在看似无辜的代码中，漏洞远不那么明显。最好的办法是始终避免使用 pickle 加载不受信任的数据。