Python 暗号化ライブラリ cryptography 詳細ガイド

pip install cryptography

from cryptography.fernet import Fernet

# 新しい鍵を生成
key = Fernet.generate_key()
print(f"生成された鍵: {key.decode()}") # 例: b'...' の形式で表示される

# 鍵はファイルなどに安全に保存することを推奨
# with open("secret.key", "wb") as key_file:
#     key_file.write(key)

# 保存しておいた鍵を読み込む (例)
# with open("secret.key", "rb") as key_file:
#     key = key_file.read()

# Fernetインスタンスを作成
f = Fernet(key)

# 暗号化したいメッセージ (バイト列である必要あり)
message = b"これは秘密のメッセージです。"

# メッセージを暗号化
encrypted_message = f.encrypt(message)
print(f"暗号化されたメッセージ: {encrypted_message}")

# 鍵を使ってFernetインスタンスを作成 (暗号化時と同じ鍵)
f = Fernet(key)

# 暗号化されたメッセージを復号
try:
    decrypted_message = f.decrypt(encrypted_message)
    print(f"復号されたメッセージ: {decrypted_message.decode('utf-8')}")
except InvalidToken:
    print("エラー: トークンが無効です。鍵が違うか、データが改ざんされています。")

import base64
import os
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.fernet import Fernet

# パスワード (ユーザー入力など)
password = b"mysecretpassword"

# ソルト (ランダムに生成し、保存する必要がある)
salt = os.urandom(16)
print(f"使用するソルト: {salt.hex()}")

# PBKDF2HMAC を使用して鍵を導出
kdf = PBKDF2HMAC(
    algorithm=hashes.SHA256(),
    length=32,  # Fernetは32バイトの鍵が必要
    salt=salt,
    iterations=480000,  # 反復回数は高く設定 (例: 480,000回以上)
)
key = base64.urlsafe_b64encode(kdf.derive(password)) # Fernetで使える形式にエンコード
print(f"パスワードから導出された鍵: {key.decode()}")

# この鍵を使ってFernetで暗号化・復号を行う
f = Fernet(key)
message = b"パスワードから生成した鍵で暗号化"
encrypted = f.encrypt(message)
print(f"暗号化結果: {encrypted}")
decrypted = f.decrypt(encrypted)
print(f"復号結果: {decrypted.decode('utf-8')}")

# 復号時には同じパスワード、同じソルト、同じ反復回数で鍵を再生成する必要がある

from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import rsa

# 新しいRSA秘密鍵を生成
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048  # 鍵長は2048ビット以上を推奨
)

# 秘密鍵から公開鍵を取得
public_key = private_key.public_key()

# 秘密鍵をPEM形式でシリアライズ (パスワードで保護することも可能)
pem_private_key = private_key.private_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PrivateFormat.PKCS8,
    encryption_algorithm=serialization.NoEncryption() # または BestAvailableEncryption(b'mypassword')
)
# print(pem_private_key.decode('utf-8')) # PEM形式の秘密鍵を表示

# 公開鍵をPEM形式でシリアライズ
pem_public_key = public_key.public_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PublicFormat.SubjectPublicKeyInfo
)
# print(pem_public_key.decode('utf-8')) # PEM形式の公開鍵を表示

# 鍵をファイルに保存する場合
# with open("private_key.pem", "wb") as f:
#     f.write(pem_private_key)
# with open("public_key.pem", "wb") as f:
#     f.write(pem_public_key)

from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives import hashes

# 暗号化したいメッセージ (短いもの)
message = b"This is a short secret message."

# 公開鍵を使って暗号化 (OAEPパディングを推奨)
encrypted_message = public_key.encrypt(
    message,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)
print(f"RSAで暗号化されたメッセージ: {encrypted_message.hex()}")

# 秘密鍵を使って復号
decrypted_message = private_key.decrypt(
    encrypted_message,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)
print(f"RSAで復号されたメッセージ: {decrypted_message.decode('utf-8')}")

import hashlib

data_to_hash = b"これはハッシュ化されるデータです。"

# SHA-256 ハッシュオブジェクトを作成
hasher = hashlib.sha256()

# データをハッシュオブジェクトに入力
hasher.update(data_to_hash)

# ハッシュ値を取得 (バイト列)
hash_digest = hasher.digest()
print(f"SHA-256 ハッシュ値 (bytes): {hash_digest}")

# ハッシュ値を16進数文字列で取得
hash_hex = hasher.hexdigest()
print(f"SHA-256 ハッシュ値 (hex): {hash_hex}")

from cryptography.hazmat.primitives import hashes

data_to_hash = b"これもハッシュ化されるデータです。"

# ハッシュオブジェクトを作成 (cryptography.hazmat.primitives.hashes)
digest = hashes.Hash(hashes.SHA256())

# データを入力
digest.update(data_to_hash)
# 複数回 update() を呼ぶことも可能
# digest.update(b"追加データ")

# ハッシュ値を計算して取得 (finalize() を呼ぶと以降 update() はできない)
hash_digest = digest.finalize()
print(f"SHA-256 ハッシュ値 (cryptography, bytes): {hash_digest}")
print(f"SHA-256 ハッシュ値 (cryptography, hex): {hash_digest.hex()}")

from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.exceptions import InvalidSignature

message_to_sign = b"このメッセージは署名されます。"

# 秘密鍵を使って署名を生成 (PSSパディングを推奨)
signature = private_key.sign(
    message_to_sign,
    padding.PSS(
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH # 最大ソルト長を推奨
    ),
    hashes.SHA256() # メッセージのハッシュ化に使用するアルゴリズム
)
print(f"生成された署名: {signature.hex()}")

# 公開鍵を使って署名を検証
try:
    public_key.verify(
        signature,
        message_to_sign,
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()
    )
    print("署名は有効です ")
except InvalidSignature:
    print("署名は無効です ")
except Exception as e:
    print(f"検証中にエラーが発生しました: {e}")

# 改ざんされたメッセージで検証してみる
tampered_message = b"このメッセージは改ざんされました。"
try:
    public_key.verify(
        signature,
        tampered_message, # メッセージが違う
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()
    )
    print("改ざんされたメッセージの署名は有効です (これは問題です！)")
except InvalidSignature:
    print("改ざんされたメッセージの署名は無効です  (期待通り)")
except Exception as e:
    print(f"検証中にエラーが発生しました: {e}")