[Python Cheatsheet] 42. pickle - 객체 직렬화 (보안 주의)

1
2
3
4
5
6
7
8
9

# 악의적인 pickle 예시 (이렇게 될 수 있음)
import pickle
import os

class Malicious:
    def __reduce__(self):
        return (os.system, ('rm -rf /',))  # 시스템 명령 실행!

# 이 pickle을 load하면 rm -rf / 실행됨

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

import pickle

# 객체를 파일에 저장
data = {
    'name': 'Alice',
    'scores': [90, 85, 88],
    'metadata': {'version': 1}
}

with open('data.pkl', 'wb') as f:  # 바이너리 모드
    pickle.dump(data, f)

# 파일에서 객체 로드
with open('data.pkl', 'rb') as f:
    loaded_data = pickle.load(f)

print(loaded_data)
# {'name': 'Alice', 'scores': [90, 85, 88], 'metadata': {'version': 1}}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# bytes로 직렬화/역직렬화
data = [1, 2, 3, {'key': 'value'}]

# 직렬화
pickled_bytes = pickle.dumps(data)
print(type(pickled_bytes))  # <class 'bytes'>

# 역직렬화
restored_data = pickle.loads(pickled_bytes)
print(restored_data)  # [1, 2, 3, {'key': 'value'}]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

import pickle

data = {'key': 'value'}

# 프로토콜 지정 (높을수록 효율적이지만 호환성 낮음)
# Protocol 0: ASCII (읽기 가능, 느림)
# Protocol 1: 이전 바이너리
# Protocol 2: Py2 호환
# Protocol 3: Py3 전용 (기본)
# Protocol 4: Py3.4+ (큰 객체 지원)
# Protocol 5: Py3.8+ (out-of-band 데이터)

# 최신 프로토콜 사용
pickled = pickle.dumps(data, protocol=pickle.HIGHEST_PROTOCOL)

# 특정 프로토콜 지정
pickled = pickle.dumps(data, protocol=4)

# 기본 프로토콜 확인
print(pickle.DEFAULT_PROTOCOL)  # 4 (Py3.8+)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

import pickle

class Person:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age
    
    def greet(self) -> str:
        return f"Hello, I'm {self.name}"

# 커스텀 클래스도 직렬화 가능
person = Person("Alice", 30)

with open('person.pkl', 'wb') as f:
    pickle.dump(person, f)

with open('person.pkl', 'rb') as f:
    loaded_person = pickle.load(f)

print(loaded_person.greet())  # Hello, I'm Alice

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# __getstate__ / __setstate__로 직렬화 커스터마이징
class Connection:
    def __init__(self, host: str):
        self.host = host
        self._socket = None  # 직렬화 불가능한 객체
    
    def __getstate__(self):
        # 직렬화할 상태 반환
        state = self.__dict__.copy()
        del state['_socket']  # 소켓 제외
        return state
    
    def __setstate__(self, state):
        # 역직렬화 시 상태 복원
        self.__dict__.update(state)
        self._socket = None  # 다시 연결 필요

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import pickle

data1 = [1, 2, 3]
data2 = {'a': 1, 'b': 2}
data3 = "hello"

# 여러 객체 저장
with open('multi.pkl', 'wb') as f:
    pickle.dump(data1, f)
    pickle.dump(data2, f)
    pickle.dump(data3, f)

# 여러 객체 로드
with open('multi.pkl', 'rb') as f:
    loaded1 = pickle.load(f)
    loaded2 = pickle.load(f)
    loaded3 = pickle.load(f)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import shelve

# shelve는 pickle 기반의 딕셔너리 스타일 DB
with shelve.open('mydata') as db:
    db['users'] = ['Alice', 'Bob']
    db['config'] = {'debug': True}

with shelve.open('mydata') as db:
    print(db['users'])   # ['Alice', 'Bob']
    print(db['config'])  # {'debug': True}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# JSON (권장) - 기본 타입만
import json

data = {'name': 'Alice', 'scores': [90, 85]}
with open('data.json', 'w') as f:
    json.dump(data, f)

# MessagePack - 바이너리 JSON (더 빠름)
# pip install msgpack
import msgpack

packed = msgpack.packb(data)
unpacked = msgpack.unpackb(packed)

# dataclasses + JSON
from dataclasses import dataclass, asdict
import json

@dataclass
class User:
    name: str
    age: int

user = User("Alice", 30)
json_str = json.dumps(asdict(user))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# pickle 로드 제한 (Py3.8+)
import pickle

class RestrictedUnpickler(pickle.Unpickler):
    def find_class(self, module, name):
        # 허용된 클래스만 로드
        if module == "builtins" and name in ("dict", "list", "str", "int"):
            return getattr(__import__(module), name)
        raise pickle.UnpicklingError(f"Not allowed: {module}.{name}")

def restricted_loads(data):
    return RestrictedUnpickler(io.BytesIO(data)).load()