python反序列化

前言：最近打比赛遇到了就简单记录学习一下

一、概念

什么是序列化？

  序列化是将 Python 对象转换为一种可以存储或传输的格式的过程。常见的序列化格式包括 JSON、XML、protobuf 以及 Python 自带的 pickle 模块。

什么是反序列化？

  反序列化是将序列化的数据转换回 Python 对象的过程。这使得我们可以从文件、网络或其他存储介质中恢复对象的状态。

Python 中的序列化和反序列化

1. 使用 pickle 模块

pickle 是 Python 内置的序列化和反序列化模块，它可以处理复杂的 Python 对象，包括类实例、列表、字典等。

序列化

import pickle

# 创建一个 Python 对象

data = {'name': 'Alice', 'age': 30}

# 将对象序列化为字节流

with open('data.pickle', 'wb') as f:

         pickle.dump(data, f)

 反序列化

import pickle

# 从字节流中反序列化对象

with open('data.pickle', 'rb') as f:

         loaded_data = pickle.load(f)

print(loaded_data)

# 输出：{'name': 'Alice', 'age': 30}

2. 使用 json 模块

json 模块用于处理 JSON 格式的数据，它也是 Python 中常用的序列化和反序列化工具。

序列化

 import json

# 创建一个 Python 对象

data = {'name': 'Alice', 'age': 30}

# 将对象序列化为 JSON 字符串

json_string = json.dumps(data)

# 将 JSON 字符串写入文件

with open('data.json', 'w') as f:

         json.dump(data, f)

 反序列化

import json

# 从 JSON 字符串中反序列化对象

json_string = '{"name": "Alice", "age": 30}'

loaded_data = json.loads(json_string)

# 从文件中读取 JSON 字符串并反序列化为对象

with open('data.json', 'r') as f:

        loaded_data = json.load(f)

print(loaded_data)

# 输出：{'name': 'Alice', 'age': 30}

 总结：

安全性考虑

pickle 模块的安全性问题

pickle 模块虽然功能强大，但存在一定的安全隐患。反序列化不受信任的数据可能导致安全问题，因为 pickle 可以执行任意代码。因此，在处理不受信任的数据时，应尽量避免使用 pickle。

更安全的选择

对于需要在网络上传输或存储的数据，建议使用更安全的序列化格式，如 JSON 或 XML。这些格式虽然不如 pickle 强大，但在安全性和跨平台兼容性方面更有优势。

总结

• 序列化：将 Python 对象转换为可以存储或传输的格式。
• 反序列化：将序列化的数据转换回 Python 对象。
• pickle 模块：支持复杂的 Python 对象，但存在安全风险。
• json 模块：支持 JSON 格式，更安全，适用于大多数应用场景。
• 安全性：处理不受信任的数据时，应避免使用 pickle。

注意：

pickle 和 json 模块中的序列化和反序列化函数

1. pickle 模块

• pickle.dumps(obj)：

  • 功能：将 Python 对象序列化为一个字节序列。
  • 参数：obj 是要序列化的 Python 对象。
  • 返回值：返回一个字节序列（bytes 类型），表示序列化后的对象。

• pickle.dump(obj, fp)：

  • 功能：将 Python 对象序列化并写入到一个文件对象 fp 中。
  • 参数：obj 是要序列化的 Python 对象，fp 是一个打开的文件对象。
  • 用途：用于将对象直接写入到文件中。

2. json 模块

• json.dumps(obj)：

  • 功能：将 Python 对象序列化为一个 JSON 格式的字符串。
  • 参数：obj 是要序列化的 Python 对象。
  • 返回值：返回一个字符串，表示序列化后的对象。

• json.dump(obj, fp)：

  • 功能：将 Python 对象序列化为 JSON 格式，并写入到一个文件对象 fp 中。
  • 参数：obj 是要序列化的 Python 对象，fp 是一个打开的文件对象。
  • 用途：用于将对象直接写入到文件中。

pickle模块序列化格式

pickle反序列化初探 - 先知社区 (aliyun.com)

pickle 序列化格式由一系列标记组成，每个标记代表一种操作或数据类型。下面是一些常见的标记及其含义：

1. c 标记：

   • 含义：表示全局对象（Global Object）。
   • 格式：c<module_name>\n<object_name>\n。
   • 示例：

     1c__builtin__
     2sys
     3T

     这表示从 __builtin__ 模块中引用 sys 对象。

2. S 标记：

   • 含义：表示字符串对象（String Object）。
   • 格式：S'your_string'\n.
   • 示例：

     1S'hello world'
     2p0

     这表示一个字符串对象 'hello world'。

3. p 标记：

   • 含义：表示持久 ID（Persistent ID）。
   • 格式：p<id>\n。
   • 示例：

     1p0

     这表示持久 ID 为 0 的对象。

4. t 标记：

   • 含义：表示字符串结束（Terminate String）。
   • 格式：t.
   • 示例：

     1t

     这表示字符串结束。

5. R 标记：

   • 含义：表示返回值（Return Value）。
   • 格式：R.
   • 示例：

     1R

     这表示返回值。

6. F 标记：

   • 含义：表示文件对象（File Object）。
   • 格式：F.
   • 示例：

     1F

     这表示文件对象。

7. d 标记：

   • 含义：表示字典对象（Dictionary Object）。
   • 格式：(（表示开始一个新的对象）。
   • 示例：

     1(

     这表示开始一个新的对象。

8. . 标记：

   • 含义：表示元组结束（End of Tuple）。
   • 格式：.。
   • 示例：

     1.

     这表示元组的结束。

9. ( 标记：

   • 含义：表示元组开始（Start of Tuple）。
   • 格式：(。
   • 示例：

     1(

     这表示元组的开始。

10. N 标记：

    • 含义：表示 None 对象。
    • 格式：N.
    • 示例：

      1N

      这表示 None 对象。

11. b 标记：

    • 含义：表示布尔值对象。
    • 格式：I（表示整数对象），然后是布尔值的整数值（0 或 1）。
    • 示例：

      1I0
      2b

      这表示布尔值 False。

12. I 标记：

    • 含义：表示整数对象。
    • 格式：I<integer_value>\n。
    • 示例：

      1I42\n

      这表示整数 42。

13. L 标记：

    • 含义：表示长整数对象。
    • 格式：L<long_integer_value>\n。
    • 示例：

      1L9223372036854775807\n

      这表示长整数 9223372036854775807。

14. G 标记：

    • 含义：表示浮点数对象。
    • 格式：G<float_value>\n。
    • 示例：

      1G3.141592653589793\n

      这表示浮点数 3.141592653589793。

15. c 标记：

    • 含义：表示复杂数对象。
    • 格式：c<real_part> <imaginary_part>\n。
    • 示例：

      1c3.0 4.0\n

      这表示复数 3.0 + 4.0j。

16. S 标记：

    • 含义：表示字符串对象。
    • 格式：S'string_value'\n。
    • 示例：

      1S'hello world'
      2p0

      这表示字符串 'hello world'。

序列化示例

假设我们要序列化一个简单的字符串对象和一个全局对象 os.system，并传递一个命令字符串给它执行。

序列化代码示例

1import pickle
2
3# 构建一个恶意的序列化对象
4payload = (
5    b"c__builtin__\n"
6    b"globals\n"
7    b"(\n"
8    b"c_os\n"
9    b"system\n"
10    b"T\n"
11    b"S'ls -l'\n"
12    b"t\n"
13    b"."
14)
15
16# 序列化对象并输出
17print(pickle.dumps(payload))

反序列化格式

反序列化的过程是根据 pickle 序列化格式中的标记逐步重建 Python 对象。下面是一个反序列化的示例。

反序列化代码示例

1import pickle
2
3# 序列化后的字节串
4serialized_data = (
5    b"c__builtin__\n"
6    b"globals\n"
7    b"(\n"
8    b"c_os\n"
9    b"system\n"
10    b"T\n"
11    b"S'ls -l'\n"
12    b"t\n"
13    b"."
14)
15
16# 反序列化对象
17try:
18    deserialized_object = pickle.loads(serialized_data)
19    print(deserialized_object)
20except Exception as e:
21    print(f"Error during deserialization: {e}")

解释

1. 全局对象：

   • c__builtin__\n：表示 __builtin__ 模块。
   • globals\n：表示 globals() 函数。
   • (\n：表示开始一个新的对象。

2. 全局对象：

   • c_os\n：表示 os 模块。
   • system\n：表示 os.system 函数。
   • T\n：表示对象的结束。

3. 字符串对象：

   • S'ls -l'\n：表示一个字符串对象，其中包含一个命令字符串。
   • t\n：表示字符串结束。

4. 元组结束：

   • .\n：表示元组的结束。

python中的文件操作模式 

在 Python 中，当我们使用 open 函数打开文件时，可以指定不同的模式来控制文件的读写操作。这些模式通常以一个或多个字符的形式出现在 open 函数的第二个参数中。以下是常见的文件操作模式及其含义：

文件操作模式

1. r (Read)：

   • 说明：以只读方式打开文件。如果文件不存在，则会引发 FileNotFoundError。
   • 示例：

     1with open('example.txt', 'r') as f:
     2    content = f.read()

2. w (Write)：

   • 说明：以写入方式打开文件。如果文件已存在，其内容将被清空；如果文件不存在，则会创建新文件。
   • 示例：

     1with open('example.txt', 'w') as f:
     2    f.write('Hello, world!')

3. a (Append)：

   • 说明：以追加方式打开文件。如果文件已存在，将在文件末尾追加内容；如果文件不存在，则会创建新文件。
   • 示例：

     1with open('example.txt', 'a') as f:
     2    f.write('\nNew line added.')

4. b (Binary)：

   • 说明：以二进制模式打开文件。通常用于读写非文本文件，如图片或音频文件。
   • 示例：

     1with open('example.bin', 'rb') as f:
     2    data = f.read()

5. + (Update)：

   • 说明：同时打开文件进行读写操作。通常与上述模式结合使用。
   • 示例：

     1with open('example.txt', 'r+') as f:
     2    f.write('Updated text.')  # 先写入，再读取
     3    f.seek(0)               # 移动文件指针到文件开头
     4    content = f.read()

6. x (Exclusive creation)：

   • 说明：以独占方式创建新文件。如果文件已存在，则会引发 FileExistsError。
   • 示例：

     1with open('newfile.txt', 'x') as f:
     2    f.write('This is a new file.')

7. t (Text)：

   • 说明：以文本模式打开文件，默认模式。通常用于文本文件。
   • 示例：

     1with open('example.txt', 'wt') as f:
     2    f.write('Text mode example.')

组合模式

• rt：默认模式，表示以文本模式读取文件。
• wt：以文本模式写入文件。
• at：以文本模式追加文件。
• rb：以二进制模式读取文件。
• wb：以二进制模式写入文件。
• ab：以二进制模式追加文件。
• r+b：以二进制模式读写文件。
• w+b：以二进制模式写入并读取文件。
• a+b：以二进制模式追加并读取文件。

示例

以文本模式读取文件

1with open('example.txt', 'r') as f:
2    content = f.read()
3    print(content)

以文本模式写入文件

1with open('example.txt', 'w') as f:
2    f.write('Hello, world!')

以二进制模式读取文件

1with open('example.bin', 'rb') as f:
2    data = f.read()

以二进制模式写入文件

1with open('example.bin', 'wb') as f:
2    f.write(b'Binary data')

总结

• r：只读模式。
• w：写入模式，会清空原有内容。
• a：追加模式。
• b：二进制模式。
• +：读写模式。
• x：独占创建模式。
• t：文本模式（默认）。