暗号化の基礎——共通鍵・公開鍵・ハッシュ関数の仕組みを実装で理解する

import hashlib

# SHA-256 の使用
data = "Hello, World!"
hash_value = hashlib.sha256(data.encode()).hexdigest()

print(f"データ：{data}")
print(f"SHA-256: {hash_value}")
# 315f5bdb76d078c43b8ac0064e4a0164612b1fce77c869345bfc94c75894edd3

# Avalanche effect の確認
data1 = "Hello, World!"
data2 = "Hello, World."  # 1 文字だけ違う

hash1 = hashlib.sha256(data1.encode()).hexdigest()
hash2 = hashlib.sha256(data2.encode()).hexdigest()

print(f"data1: {hash1}")
print(f"data2: {hash2}")

# 1 文字の違いでハッシュ値が完全に異なる
# 315f5bdb76d078c43b8ac0064e4a0164612b1fce77c869345bfc94c75894edd3
# 42b66d07948be0663a1c7e6b56b70706a09a31e599df10e8f910312f460c3ab9

import os
import hashlib

def hash_password(password: str, salt: bytes = None) -> tuple[str, bytes]:
    """パスワードをソルト付きでハッシュ化"""
    if salt is None:
        salt = os.urandom(32)  # 32 バイトのランダムソルト

    # PBKDF2: ソルト付きパスワードを複数回ハッシュ
    # 10 万回のイテレーションで総当たり攻撃を困難に
    key = hashlib.pbkdf2_hmac(
        'sha256',
        password.encode(),
        salt,
        100000  # イテレーション回数
    )
    return key.hex(), salt

def verify_password(password: str, stored_hash: str, salt: bytes) -> bool:
    """パスワードの検証"""
    computed_hash, _ = hash_password(password, salt)
    return computed_hash == stored_hash

# 使用例
password = "my_secure_password"
hashed, salt = hash_password(password)

print(f"ハッシュ値：{hashed}")
print(f"ソルト：{salt.hex()}")

# 検証
print(verify_password("my_secure_password", hashed, salt))  # True
print(verify_password("wrong_password", hashed, salt))      # False

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
import os

def aes_encrypt(plaintext: bytes, key: bytes) -> tuple[bytes, bytes]:
    """AES-256-CBC で暗号化"""
    # ランダムな IV（初期化ベクトル）を生成
    iv = os.urandom(16)

    # 暗号化
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    encryptor = cipher.encryptor()

    # パディング（16 バイトの倍数にする）
    padding_len = 16 - (len(plaintext) % 16)
    padded = plaintext + bytes([padding_len] * padding_len)

    ciphertext = encryptor.update(padded) + encryptor.finalize()
    return ciphertext, iv

def aes_decrypt(ciphertext: bytes, key: bytes, iv: bytes) -> bytes:
    """AES-256-CBC で復号"""
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    decryptor = cipher.decryptor()

    padded = decryptor.update(ciphertext) + decryptor.finalize()

    # パディングを除去
    padding_len = padded[-1]
    return padded[:-padding_len]

# 使用例
key = os.urandom(32)  # 256 ビット鍵
plaintext = b"Secret message!"

ciphertext, iv = aes_encrypt(plaintext, key)
print(f"暗号文（16 進）: {ciphertext.hex()}")

decrypted = aes_decrypt(ciphertext, key, iv)
print(f"復号文：{decrypted.decode()}")  # Secret message!

# AES-GCM の使用（推奨）
from cryptography.hazmat.primitives.ciphers.aead import AESGCM

def aes_gcm_encrypt(plaintext: bytes, key: bytes) -> tuple[bytes, bytes]:
    """AES-256-GCM で暗号化（認証付き）"""
    nonce = os.urandom(12)  # 96 ビット nonce
    aesgcm = AESGCM(key)
    ciphertext = aesgcm.encrypt(nonce, plaintext, None)
    return ciphertext, nonce

def aes_gcm_decrypt(ciphertext: bytes, key: bytes, nonce: bytes) -> bytes:
    """AES-256-GCM で復号（認証検証付き）"""
    aesgcm = AESGCM(key)
    plaintext = aesgcm.decrypt(nonce, ciphertext, None)
    return plaintext

# 使用例
key = os.urandom(32)
plaintext = b"Authenticated message!"

ciphertext, nonce = aes_gcm_encrypt(plaintext, key)
decrypted = aes_gcm_decrypt(ciphertext, key, nonce)

print(f"復号文：{decrypted.decode()}")

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

# RSA 鍵ペアの生成
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,  # 2048 ビット
    backend=default_backend()
)
public_key = private_key.public_key()

# 暗号化（公開鍵使用）
plaintext = b"Secret message for RSA!"
ciphertext = public_key.encrypt(
    plaintext,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)
print(f"暗号文（16 進）: {ciphertext.hex()[:64]}...")

# 復号（秘密鍵使用）
decrypted = private_key.decrypt(
    ciphertext,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)
print(f"復号文：{decrypted.decode()}")

from cryptography.hazmat.primitives.asymmetric import padding as asym_padding

# 署名生成
message = b"Important contract document"
signature = private_key.sign(
    message,
    asym_padding.PSS(
        mgf=asym_padding.MGF1(hashes.SHA256()),
        salt_length=asym_padding.PSS.MAX_LENGTH
    ),
    hashes.SHA256()
)
print(f"署名（16 進）: {signature.hex()[:64]}...")

# 署名検証
try:
    public_key.verify(
        signature,
        message,
        asym_padding.PSS(
            mgf=asym_padding.MGF1(hashes.SHA256()),
            salt_length=asym_padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()
    )
    print("署名検証：成功 ✓")
except Exception:
    print("署名検証：失敗 ✗")

from cryptography.hazmat.primitives.asymmetric import dh

# パラメータ生成
parameters = dh.generate_parameters(generator=2, key_size=2048)

# アリスの鍵ペア生成
alice_private = parameters.generate_private_key()
alice_public = alice_private.public_key()

# ボブの鍵ペア生成
bob_private = parameters.generate_private_key()
bob_public = bob_private.public_key()

# 共有秘密の生成
alice_shared = alice_private.exchange(bob_public)
bob_shared = bob_private.exchange(alice_public)

# 両者が同じ共有秘密を持つ
print(f"Alice: {alice_shared.hex()[:32]}...")
print(f"Bob:   {bob_shared.hex()[:32]}...")
print(f"一致：{alice_shared == bob_shared}")  # True

from cryptography.hazmat.primitives.asymmetric import ec

# アリスの鍵ペア（P-256 カーブ）
alice_private = ec.generate_private_key(ec.SECP256R1())
alice_public = alice_private.public_key()

# ボブの鍵ペア
bob_private = ec.generate_private_key(ec.SECP256R1())
bob_public = bob_private.public_key()

# 共有秘密
alice_shared = alice_private.exchange(ec.ECDH(), bob_public)
bob_shared = bob_private.exchange(ec.ECDH(), alice_public)

print(f"共有秘密（16 進）: {alice_shared.hex()[:32]}...")

import json
from base64 import b64encode, b64decode

class SecureMessenger:
    """簡易エンドツーエンド暗号化メッセージング"""

    def __init__(self):
        self.private_key = rsa.generate_private_key(
            public_exponent=65537,
            key_size=2048,
        )
        self.public_key = self.private_key.public_key()

    def get_public_key_pem(self) -> str:
        """公開鍵を PEM 形式で取得"""
        return self.public_key.public_bytes(
            encoding=serialization.Encoding.PEM,
            format=serialization.PublicFormat.SubjectPublicKeyInfo
        ).decode()

    def encrypt_message(self, message: str, recipient_public_key) -> dict:
        """メッセージを暗号化"""
        from cryptography.hazmat.primitives import serialization

        # PEM から公開鍵を読み込み
        pub_key = serialization.load_pem_public_key(
            recipient_public_key.encode()
        )

        # ランダムな AES 鍵を生成
        aes_key = os.urandom(32)

        # メッセージを AES で暗号化
        iv = os.urandom(16)
        cipher = Cipher(algorithms.AES(aes_key), modes.GCM(iv))
        encryptor = cipher.encryptor()
        ciphertext = encryptor.update(message.encode()) + encryptor.finalize()

        # AES 鍵を RSA で暗号化
        encrypted_key = pub_key.encrypt(
            aes_key,
            padding.OAEP(
                mgf=padding.MGF1(algorithm=hashes.SHA256()),
                algorithm=hashes.SHA256(),
                label=None
            )
        )

        # デジタル署名を生成
        signature = self.private_key.sign(
            message.encode(),
            asym_padding.PSS(
                mgf=asym_padding.MGF1(hashes.SHA256()),
                salt_length=asym_padding.PSS.MAX_LENGTH
            ),
            hashes.SHA256()
        )

        return {
            "encrypted_key": b64encode(encrypted_key).decode(),
            "iv": b64encode(iv).decode(),
            "ciphertext": b64encode(ciphertext).decode(),
            "signature": b64encode(signature).decode(),
            "sender_public_key": self.get_public_key_pem()
        }

    def decrypt_message(self, encrypted: dict) -> str:
        """メッセージを復号・検証"""
        from cryptography.hazmat.primitives import serialization

        # AES 鍵を復号
        aes_key = self.private_key.decrypt(
            b64decode(encrypted["encrypted_key"]),
            padding.OAEP(
                mgf=padding.MGF1(algorithm=hashes.SHA256()),
                algorithm=hashes.SHA256(),
                label=None
            )
        )

        # メッセージを復号
        iv = b64decode(encrypted["iv"])
        ciphertext = b64decode(encrypted["ciphertext"])

        cipher = Cipher(algorithms.AES(aes_key), modes.GCM(iv))
        decryptor = cipher.decryptor()
        plaintext = decryptor.update(ciphertext) + decryptor.finalize()

        # 署名を検証
        sender_public_key = serialization.load_pem_public_key(
            encrypted["sender_public_key"].encode()
        )
        signature = b64decode(encrypted["signature"])

        sender_public_key.verify(
            signature,
            plaintext,
            asym_padding.PSS(
                mgf=asym_padding.MGF1(hashes.SHA256()),
                salt_length=asym_padding.PSS.MAX_LENGTH
            ),
            hashes.SHA256()
        )

        return plaintext.decode()

# 使用例
alice = SecureMessenger()
bob = SecureMessenger()

# アリスがボブに送信
encrypted = alice.encrypt_message("Hello Bob!", bob.get_public_key_pem())
print("暗号化メッセージ送信...")

# ボブが受信・復号
decrypted = bob.decrypt_message(encrypted)
print(f"受信メッセージ：{decrypted}")  # Hello Bob!