Pythonのitsdangerousライブラリ徹底解説：安全なデータ署名の世界

from itsdangerous import Signer, BadSignature

# 秘密鍵を設定 (実際のアプリケーションではもっと複雑な鍵を安全に管理してください)
SECRET_KEY = 'my-super-secret-key-dont-tell-anyone'
signer = Signer(SECRET_KEY)

original_data = b'Hello, ItsDangerous!'

# データの署名
signed_value = signer.sign(original_data)
print(f"署名された値: {signed_value}")
# 出力例: 署名された値: b'Hello, ItsDangerous!.aBcDeFgHiJkLmNoPqRsTuVwXyZ' (署名部分は実行ごとに変わります)

# 署名の検証
try:
    unsigned_data = signer.unsign(signed_value)
    print(f"検証後のデータ: {unsigned_data}")
    # 出力: 検証後のデータ: b'Hello, ItsDangerous!'
    assert original_data == unsigned_data
    print(" 署名は有効です。")
except BadSignature as e:
    print(f" 署名が無効です: {e}")

# 改ざんされたデータで検証してみる
tampered_value = signed_value + b'.tampered' # 末尾に不正なデータを追加
try:
    signer.unsign(tampered_value)
except BadSignature as e:
    print(f" 改ざんされたデータの検証結果: {e}")
    # 出力例:  改ざんされたデータの検証結果: Signature "..." does not match

# 署名部分を少し変えてみる
parts = signed_value.split(b'.')
if len(parts) == 2:
    tampered_signature = parts[0] + b'.' + parts[1][:-1] + b'X' # 署名の最後の文字を変える
    try:
        signer.unsign(tampered_signature)
    except BadSignature as e:
        print(f" 不正な署名の検証結果: {e}")
        # 出力例:  不正な署名の検証結果: Signature "..." does not match
else:
    print("署名形式が予期したものと異なります。")

from itsdangerous import Serializer, BadSignature

SECRET_KEY = 'another-secret-key-wow-so-secret'
serializer = Serializer(SECRET_KEY)

# シリアライズしたいPythonオブジェクト (辞書)
user_data = {'user_id': 123, 'username': 'Alice', 'roles': ['user', 'editor']}

# オブジェクトをシリアライズして署名
signed_blob = serializer.dumps(user_data)
print(f"署名付きシリアライズデータ: {signed_blob}")
# 出力例: 署名付きシリアライズデータ: eyJ1c2VyX2lkIjoxMjMsInVzZXJuYW1lIjoiQWxpY2UiLCJyb2xlcyI6WyJ1c2VyIiwiZWRpdG9yIl19.aBcDeFgHiJkLmNoPqRsTuVwXyZ12345

# 検証とデシリアライズ
try:
    loaded_data = serializer.loads(signed_blob)
    print(f"検証・デシリアライズ後のデータ: {loaded_data}")
    # 出力: 検証・デシリアライズ後のデータ: {'user_id': 123, 'username': 'Alice', 'roles': ['user', 'editor']}
    assert user_data == loaded_data
    print(" 署名は有効で、データは正常に復元されました。")
except BadSignature as e:
    print(f" 署名が無効か、データが改ざんされています: {e}")
    # BadSignature例外には payload 属性があり、署名検証に失敗したペイロード（デシリアライズ試行前のデータ）を確認できる場合があります。
    # ただし、このデータは改ざんされている可能性があるので、取り扱いには注意が必要です。
    if hasattr(e, 'payload') and e.payload:
        try:
            # Base64デコードなどを試みる（Serializerの実装に依存）
            import base64
            potential_payload = base64.urlsafe_b64decode(e.payload + b'=' * (-len(e.payload) % 4))
            print(f"   (デバッグ情報：署名検証前のペイロードの可能性: {potential_payload})")
        except Exception:
            print(f"   (デバッグ情報：署名検証前のペイロード: {e.payload})")


# 改ざんされたデータで試す
tampered_blob = signed_blob[:-5] + "XXXXX" # 署名部分を書き換える
try:
    serializer.loads(tampered_blob)
except BadSignature as e:
    print(f" 改ざんデータの検証結果: {e}")
    # 出力例:  改ざんデータの検証結果: Signature "..." does not match

from itsdangerous import URLSafeSerializer, BadSignature

SECRET_KEY = 'url-safe-secret-key-is-important'
serializer = URLSafeSerializer(SECRET_KEY)

# URLに埋め込みたいデータ
activation_data = {'email': 'test@example.com', 'action': 'activate_account'}

# URLセーフな署名付きトークンを生成
token = serializer.dumps(activation_data)
print(f"生成されたURLセーフなトークン: {token}")
# 出力例: 生成されたURLセーフなトークン: eyJlbWFpbCI6InRlc3RAZXhhbXBsZS5jb20iLCJhY3Rpb24iOiJhY3RpdmF0ZV9hY2NvdW50In0.aBcDeFgHiJkLmNoPqRsTuVwXyZabcde

# このトークンはURLの一部として安全に使える
activation_url = f"https://example.com/activate?token={token}"
print(f"生成されたアクティベーションURL: {activation_url}")

# 受け取ったトークンを検証・デシリアライズ
received_token = token # 通常はURLから抽出する
try:
    loaded_data = serializer.loads(received_token)
    print(f"トークンから復元されたデータ: {loaded_data}")
    # 出力: トークンから復元されたデータ: {'email': 'test@example.com', 'action': 'activate_account'}
    assert activation_data == loaded_data
    print(" トークンは有効です。")
except BadSignature as e:
    print(f" 無効なトークンです: {e}")

# トークンを改ざんしてみる
tampered_token = token.replace('A', 'B') # トークンの一部を変更
try:
    serializer.loads(tampered_token)
except BadSignature as e:
    print(f" 改ざんされたトークンの検証結果: {e}")
    # 出力例:  改ざんされたトークンの検証結果: Signature "..." does not match

import time
from itsdangerous import TimestampSigner, BadSignature, SignatureExpired

SECRET_KEY = 'time-sensitive-secret-shhh'
signer = TimestampSigner(SECRET_KEY)

message = b'This message expires soon!'

# タイムスタンプ付きで署名
signed_value_with_ts = signer.sign(message)
print(f"タイムスタンプ付き署名: {signed_value_with_ts}")
# 出力例: タイムスタンプ付き署名: b'This message expires soon!.XqlDIQ.aBcDeFgHiJkLmNoPqRsTuVwXyZ12345' (タイムスタンプ部分はBase64エンコードされています)

# すぐに検証 (max_age=60秒)
try:
    unsigned_data = signer.unsign(signed_value_with_ts, max_age=60)
    print(f"検証成功 (60秒以内): {unsigned_data}")
    # 出力: 検証成功 (60秒以内): b'This message expires soon!'
    print(" 署名は有効期間内です。")
except SignatureExpired as e:
    print(f" 署名の有効期限が切れています: {e}")
except BadSignature as e:
    print(f" 署名が無効です: {e}")

# 5秒待機してから検証 (max_age=3秒)
print("5秒待機します...")
time.sleep(5)

try:
    signer.unsign(signed_value_with_ts, max_age=3)
    print(" 署名は有効期間内です。") # ここは実行されないはず
except SignatureExpired as e:
    print(f" 署名の有効期限が切れています (max_age=3): {e}")
    # 出力例:  署名の有効期限が切れています (max_age=3): Signature age 5 > 3 seconds
    # SignatureExpired 例外は BadSignature を継承しています
    print(f"   SignatureExpired は BadSignature のサブクラスか？: {isinstance(e, BadSignature)}") # True
except BadSignature as e:
    print(f" 署名が無効です: {e}")

# 署名時刻を取得する (return_timestamp=True)
try:
    unsigned_data, timestamp = signer.unsign(signed_value_with_ts, max_age=60, return_timestamp=True)
    print(f"検証成功 (タイムスタンプ付き): データ='{unsigned_data}', 署名時刻={timestamp}")
    # 出力例: 検証成功 (タイムスタンプ付き): データ=b'This message expires soon!', 署名時刻=2025-04-02 03:36:00+00:00 (datetimeオブジェクト)
except (BadSignature, SignatureExpired) as e:
    print(f"検証失敗: {e}")

import time
from itsdangerous import URLSafeTimedSerializer, BadSignature, SignatureExpired

SECRET_KEY = 'timed-url-safe-secret-very-secure'
# 有効期間をデフォルトで設定することも可能 (loads呼び出し時に上書き可能)
# serializer = URLSafeTimedSerializer(SECRET_KEY, default_max_age=3600) # 1時間
serializer = URLSafeTimedSerializer(SECRET_KEY)

reset_data = {'user_id': 42, 'purpose': 'password_reset'}

# URLセーフでタイムスタンプ付きのトークンを生成
timed_token = serializer.dumps(reset_data)
print(f"生成された時間制限付きトークン: {timed_token}")
# 出力例: 生成された時間制限付きトークン: eyJ1c2VyX2lkIjo0MiwicHVycG9zZSI6InBhc3N3b3JkX3Jlc2V0In0.XqlDJA.aBcDeFgHiJkLmNoPqRsTuVwXyZabcde

reset_link = f"https://example.com/reset-password?token={timed_token}"
print(f"パスワードリセットリンク: {reset_link}")

# すぐに検証 (max_age=600秒 = 10分)
try:
    loaded_data = serializer.loads(timed_token, max_age=600)
    print(f"トークン検証成功 (10分以内): {loaded_data}")
    # 出力: トークン検証成功 (10分以内): {'user_id': 42, 'purpose': 'password_reset'}
    print(" トークンは有効期間内です。")
except SignatureExpired as e:
    print(f" トークンの有効期限が切れています: {e}")
except BadSignature as e:
    print(f" 無効なトークンです: {e}")

# 10秒待機して検証 (max_age=5秒)
print("10秒待機します...")
time.sleep(10)

try:
    serializer.loads(timed_token, max_age=5)
    print(" トークンは有効期間内です。") # ここは実行されないはず
except SignatureExpired as e:
    print(f" トークンの有効期限が切れています (max_age=5): {e}")
    # 出力例:  トークンの有効期限が切れています (max_age=5): Signature age 10 > 5 seconds
except BadSignature as e:
    print(f" 無効なトークンです: {e}")

from itsdangerous import URLSafeTimedSerializer, BadSignature

SECRET_KEY = 'shared-secret-key-but-use-salts'

# パスワードリセット用シリアライザ (salt='password-reset')
pw_reset_serializer = URLSafeTimedSerializer(SECRET_KEY, salt='password-reset-salt')

# メール確認用シリアライザ (salt='email-confirm')
email_confirm_serializer = URLSafeTimedSerializer(SECRET_KEY, salt='email-confirm-salt')

user_id = 101

# パスワードリセットトークンを生成
pw_token = pw_reset_serializer.dumps({'user_id': user_id})
print(f"パスワードリセットトークン: {pw_token}")

# メール確認トークンを生成
email_token = email_confirm_serializer.dumps({'user_id': user_id})
print(f"メール確認トークン: {email_token}")

# --- 検証 ---

# パスワードリセットトークンを正しいシリアライザで検証 (成功するはず)
try:
    data = pw_reset_serializer.loads(pw_token, max_age=3600)
    print(f" パスワードリセットトークンを pw_reset_serializer で検証成功: {data}")
except BadSignature as e:
    print(f" パスワードリセットトークンを pw_reset_serializer で検証失敗: {e}")

# メール確認トークンを正しいシリアライザで検証 (成功するはず)
try:
    data = email_confirm_serializer.loads(email_token, max_age=3600)
    print(f" メール確認トークンを email_confirm_serializer で検証成功: {data}")
except BadSignature as e:
    print(f" メール確認トークンを email_confirm_serializer で検証失敗: {e}")

# *** ここからが重要 ***
# パスワードリセットトークンを「メール確認用」シリアライザで検証 (失敗するはず)
try:
    data = email_confirm_serializer.loads(pw_token, max_age=3600)
    print(f" パスワードリセットトークンを email_confirm_serializer で検証成功 (これは問題)")
except BadSignature as e:
    print(f" パスワードリセットトークンを email_confirm_serializer で検証失敗 (期待通り): {e}")
    # 出力例:  パスワードリセットトークンを email_confirm_serializer で検証失敗 (期待通り): Signature "..." does not match

# メール確認トークンを「パスワードリセット用」シリアライザで検証 (失敗するはず)
try:
    data = pw_reset_serializer.loads(email_token, max_age=3600)
    print(f" メール確認トークンを pw_reset_serializer で検証成功 (これは問題)")
except BadSignature as e:
    print(f" メール確認トークンを pw_reset_serializer で検証失敗 (期待通り): {e}")
    # 出力例:  メール確認トークンを pw_reset_serializer で検証失敗 (期待通り): Signature "..." does not match

import pickle
from itsdangerous import Serializer, BadSignature

# pickle は安全でないデシリアライズのリスクがあるため、信頼できない入力には通常非推奨です。
# ここではあくまでカスタムシリアライザの例として示します。
# 実際の利用ではセキュリティリスクを十分に理解・評価してください。
custom_serializer = pickle

SECRET_KEY = 'custom-serializer-secret'
# serializer引数にpickleモジュール(dumps/loadsを持つ)を指定
s = Serializer(SECRET_KEY, serializer=custom_serializer)

my_object = {'a', 'b', 1, 2, (3, 4)} # pickleでシリアライズ可能なオブジェクト

# pickleでシリアライズして署名
signed_pickle = s.dumps(my_object)
print(f"Pickleで署名されたデータ (バイト列): {signed_pickle}")

# 検証してpickleでデシリアライズ
try:
    loaded_object = s.loads(signed_pickle)
    print(f"検証・デシリアライズ後のオブジェクト: {loaded_object}")
    assert my_object == loaded_object
    print(" Pickleデータの署名は有効です。")
except BadSignature as e:
    print(f" Pickleデータの署名が無効です: {e}")

import hashlib
from itsdangerous import Signer
from itsdangerous.signer import HMACAlgorithm

SECRET_KEY = 'sha256-key-example'

# SHA-256をダイジェストメソッドとして使用するSignerを作成
signer_sha256 = Signer(
    SECRET_KEY,
    digest_method=hashlib.sha256
)
# または、アルゴリズムクラスを直接指定
# algo = HMACAlgorithm(hashlib.sha256)
# signer_sha256_alt = Signer(SECRET_KEY, algorithm=algo)


data = b'Data to be signed with SHA256'
signed_data = signer_sha256.sign(data)
print(f"SHA256-HMAC署名付きデータ: {signed_data}")

try:
    unsigned_data = signer_sha256.unsign(signed_data)
    print(f"SHA256署名検証成功: {unsigned_data}")
except BadSignature as e:
    print(f"SHA256署名検証失敗: {e}")

from itsdangerous import Signer

# Djangoの signing.Signer と互換性のあるキー導出方法を使用
django_compatible_signer = Signer(
    'django-secret-key',
    salt='django.contrib.auth.tokens.PasswordResetTokenGenerator', # Djangoの例
    key_derivation='django-concat'
)

# ここでは署名・検証の例は省略

from itsdangerous import URLSafeTimedSerializer, BadSignature, SignatureExpired
import time

# 現在のキーと、一つ前のキー
SECRET_KEYS = ['new-very-strong-secret-key', 'old-still-valid-secret-key']

serializer = URLSafeTimedSerializer(SECRET_KEYS)

data = {'message': 'Test key rotation'}

# 署名は常にリストの最初のキー (new-very-strong-secret-key) で行われる
token_new_key = serializer.dumps(data)
print(f"新しいキーで生成されたトークン: {token_new_key}")

# 古いキーで署名されたトークンがあったとする (ここでは擬似的に生成)
old_serializer = URLSafeTimedSerializer('old-still-valid-secret-key')
token_old_key = old_serializer.dumps(data)
print(f"古いキーで生成されたトークン (例): {token_old_key}")

# --- 検証 ---
# 新しいキーで生成されたトークンを検証 (新しいキーで成功するはず)
try:
    loaded = serializer.loads(token_new_key, max_age=60)
    print(f" 新キートークン検証成功: {loaded}")
except (BadSignature, SignatureExpired) as e:
    print(f" 新キートークン検証失敗: {e}")

# 古いキーで生成されたトークンを検証 (古いキーも試行されるため成功するはず)
try:
    loaded = serializer.loads(token_old_key, max_age=60)
    print(f" 旧キートークン検証成功: {loaded}")
except (BadSignature, SignatureExpired) as e:
    print(f" 旧キートークン検証失敗: {e}")

# 無効なキーで署名されたトークン (どのキーでも失敗するはず)
invalid_serializer = URLSafeTimedSerializer('invalid-key')
token_invalid_key = invalid_serializer.dumps(data)
try:
    loaded = serializer.loads(token_invalid_key, max_age=60)
    print(f" 不正キートークン検証成功 (問題あり)")
except (BadSignature, SignatureExpired) as e:
    print(f" 不正キートークン検証失敗 (期待通り): {e}")

from flask import Flask, session, request, redirect, url_for

app = Flask(__name__)
# Flaskアプリケーションには必ず強力なSECRET_KEYを設定してください！
app.config['SECRET_KEY'] = 'dev-secret-key-replace-in-production'

@app.route('/')
def index():
    username = session.get('username')
    if username:
        return f'Logged in as {username}. Logout'
    return 'You are not logged in. Login'

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        # 実際にはここでユーザー認証を行う
        session['username'] = request.form['username']
        # セッションに値を設定すると、Flaskはレスポンス時に
        # セッションデータをシリアライズ・署名し、クッキーに設定します。
        return redirect(url_for('index'))
    return '''
        <form method="post">
            Username: <input type="text" name="username">
            <input type="submit" value="Login">
        </form>
    '''

@app.route('/logout')
def logout():
    # セッションから値を削除
    session.pop('username', None)
    # セッションが変更されると、Flaskはクッキーを更新（または削除）します。
    return redirect(url_for('index'))

# Flaskがリクエストを受け取るたびに、クッキーからセッションデータを読み込み、
# SECRET_KEYを使って署名とタイムスタンプを検証します。
# 検証に失敗すると、セッションは空として扱われます。

if __name__ == '__main__':
    # 開発サーバーでの実行例。本番環境ではGunicornなどを使用します。
    app.run(debug=True)

from flask import Flask, url_for, request, flash, redirect
from itsdangerous import URLSafeTimedSerializer, SignatureExpired, BadSignature
# メール送信ライブラリ (例)
# from flask_mail import Mail, Message

app = Flask(__name__)
app.config['SECRET_KEY'] = 'another-strong-secret-key'
# メール確認用のソルト
app.config['SECURITY_CONFIRM_SALT'] = 'my-email-confirm-salt'
# トークンの有効期間 (例: 1日)
app.config['SECURITY_CONFIRM_MAX_AGE'] = 86400 # 秒

# Mail設定 (例)
# app.config['MAIL_SERVER'] = 'smtp.example.com'
# ...
# mail = Mail(app)

def get_serializer(salt=None):
    """指定されたソルトでシリアライザを取得"""
    if salt is None:
        salt = app.config.get('SECURITY_CONFIRM_SALT', 'default-confirm-salt')
    return URLSafeTimedSerializer(app.config['SECRET_KEY'], salt=salt)

def generate_confirmation_token(email):
    """メール確認トークンを生成"""
    serializer = get_serializer()
    return serializer.dumps(email)

def confirm_token(token, max_age=None):
    """トークンを検証し、メールアドレスを返す (失敗時はFalse)"""
    serializer = get_serializer()
    if max_age is None:
        max_age = app.config.get('SECURITY_CONFIRM_MAX_AGE', 86400)
    try:
        email = serializer.loads(
            token,
            max_age=max_age
        )
        return email
    except SignatureExpired:
        print("トークンの有効期限が切れています。")
        return False
    except BadSignature:
        print("無効なトークンです。")
        return False
    except Exception as e:
        print(f"予期せぬエラー: {e}")
        return False

@app.route('/register', methods=['POST'])
def register():
    email = request.form['email']
    # ... ユーザー登録処理 ...

    # 確認トークンを生成
    token = generate_confirmation_token(email)
    confirm_url = url_for('confirm_email', token=token, _external=True)

    # メールを送信 (例)
    # subject = "メールアドレスを確認してください"
    # html = f'<p>確認するには次のリンクをクリックしてください: <a href="{confirm_url}">{confirm_url}</a></p>'
    # msg = Message(subject, recipients=[email], html=html)
    # mail.send(msg)
    print(f"確認メールを {email} に送信しました (URL: {confirm_url})")

    flash('確認メールを送信しました。')
    return redirect(url_for('index')) # 仮のindexルート

@app.route('/confirm/<token>')
def confirm_email(token):
    email = confirm_token(token)
    if email:
        # ... メールアドレスを有効化する処理 ...
        # 例: User.query.filter_by(email=email).update({'confirmed': True})
        # db.session.commit()
        print(f"メールアドレス {email} が確認されました。")
        flash('メールアドレスが確認されました。ありがとうございます！')
    else:
        flash('確認リンクが無効か、有効期限が切れています。')
    return redirect(url_for('index')) # 仮のindexルート

@app.route('/')
def index():
    # flashメッセージ表示などのための仮ルート
    messages = request.args.getlist('flash')
    return f"Welcome! Flashed messages: {messages}"

# 実行用 (実際には/registerはGETで作るか、別のページからPOSTする)
# if __name__ == '__main__':
#    app.run(debug=True)