# コード例1: TLS 接続の詳細確認
 
# TLS 1.3 ハンドシェイクの詳細を表示
openssl s_client -connect example.com:443 -tls1_3 -msg
 
# 証明書チェーンを確認
openssl s_client -connect example.com:443 -showcerts
 
# 使用される暗号スイートの確認
openssl s_client -connect example.com:443 -cipher 'TLS_AES_256_GCM_SHA384'
 
# サーバがサポートする暗号スイート一覧
nmap --script ssl-enum-ciphers -p 443 example.com
 
# testssl.sh による包括的なTLSテスト
testssl.sh https://example.com
 
# sslyze による詳細分析
sslyze --regular example.com
 
# curl でTLSバージョンとプロトコル情報を表示
curl -vI https://example.com 2>&1 | grep -E "SSL|TLS|subject|issuer"

# コード例2: 証明書の詳細確認コマンド
 
# 証明書の内容をデコード
openssl x509 -in server.crt -text -noout
 
# 出力例:
# Certificate:
#     Data:
#         Version: 3 (0x2)
#         Serial Number: 04:00:00:00:00:01:2f:...
#         Signature Algorithm: sha256WithRSAEncryption
#         Issuer: C=US, O=DigiCert Inc, CN=DigiCert SHA2 ...
#         Validity:
#             Not Before: Jan  1 00:00:00 2025 GMT
#             Not After : Dec 31 23:59:59 2025 GMT
#         Subject: CN=*.example.com
#         Subject Public Key Info:
#             Public Key Algorithm: id-ecPublicKey
#             Public-Key: (256 bit)
#         X509v3 extensions:
#             X509v3 Subject Alternative Name:
#                 DNS:*.example.com, DNS:example.com
#             X509v3 Key Usage: critical
#                 Digital Signature
#             X509v3 Extended Key Usage:
#                 TLS Web Server Authentication
#             Authority Information Access:
#                 OCSP - URI:http://ocsp.digicert.com
#                 CA Issuers - URI:http://cacerts.digicert.com/...
#             X509v3 CRL Distribution Points:
#                 URI:http://crl3.digicert.com/...
 
# 証明書チェーンの検証
openssl verify -CAfile ca-bundle.crt server.crt
 
# リモートサーバの証明書チェーン全体を表示
openssl s_client -connect example.com:443 -showcerts 2>/dev/null | \
  openssl x509 -noout -subject -issuer -dates
 
# 証明書のフィンガープリント
openssl x509 -in server.crt -fingerprint -sha256 -noout
 
# CSR (証明書署名要求) の確認
openssl req -in server.csr -text -noout
 
# 秘密鍵と証明書の一致確認
openssl x509 -in server.crt -modulus -noout | openssl md5
openssl rsa -in server.key -modulus -noout | openssl md5
# 同じハッシュ値なら一致

# コード例3: Nginx での OCSP Stapling 設定
server {
    listen 443 ssl;
    server_name example.com;
 
    ssl_certificate     /etc/nginx/ssl/server.crt;
    ssl_certificate_key /etc/nginx/ssl/server.key;
 
    # OCSP Stapling の有効化
    ssl_stapling on;
    ssl_stapling_verify on;
 
    # OCSP レスポンダへの接続に使用する CA 証明書
    ssl_trusted_certificate /etc/nginx/ssl/ca-chain.crt;
 
    # OCSP レスポンスの DNS 解決
    resolver 1.1.1.1 8.8.8.8 valid=300s;
    resolver_timeout 5s;
}

# コード例4: CT ログの監視
# crt.sh で特定ドメインの全証明書を確認
curl -s "https://crt.sh/?q=%25.example.com&output=json" | \
  python3 -m json.tool | head -50
 
# certspotter でリアルタイム監視
# certspotter watch example.com

# コード例5: certbot の各種使用方法
 
# Nginx 用に証明書を取得・設定（最も簡単）
sudo certbot --nginx -d example.com -d www.example.com
 
# Apache 用
sudo certbot --apache -d example.com
 
# スタンドアロンモード（既存のWebサーバを停止して使用）
sudo certbot certonly --standalone -d example.com
 
# Webroot モード（既存のWebサーバを停止せずに使用）
sudo certbot certonly --webroot -w /var/www/html -d example.com
 
# DNS-01 チャレンジでワイルドカード証明書を取得
sudo certbot certonly --manual --preferred-challenges dns \
  -d "*.example.com" -d "example.com"
 
# DNS-01 + Cloudflare プラグインで自動化
sudo certbot certonly \
  --dns-cloudflare \
  --dns-cloudflare-credentials /etc/letsencrypt/cloudflare.ini \
  -d "*.example.com" -d "example.com"
 
# 自動更新のテスト
sudo certbot renew --dry-run
 
# 自動更新の設定
# systemd timer (推奨)
# /etc/systemd/system/certbot-renewal.timer
# [Timer]
# OnCalendar=*-*-* 03:00:00
# RandomizedDelaySec=3600
 
# crontab による自動更新（代替）
# 0 3 * * * certbot renew --quiet --post-hook "systemctl reload nginx"
 
# 証明書の情報確認
sudo certbot certificates
 
# 証明書の手動失効
sudo certbot revoke --cert-path /etc/letsencrypt/live/example.com/cert.pem

# コード例6: Nginx での mTLS 設定
server {
    listen 443 ssl;
    server_name api.example.com;
 
    # サーバ証明書
    ssl_certificate     /etc/nginx/ssl/server.crt;
    ssl_certificate_key /etc/nginx/ssl/server.key;
 
    # TLS プロトコルと暗号スイートの設定
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers 'ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256';
    ssl_prefer_server_ciphers on;
 
    # クライアント証明書の検証
    ssl_client_certificate /etc/nginx/ssl/ca.crt;  # 信頼するCA証明書
    ssl_verify_client on;       # 必須 (optional にすると選択的になる)
    ssl_verify_depth 2;         # チェーンの最大深度
 
    # CRL (証明書失効リスト) の設定
    ssl_crl /etc/nginx/ssl/ca.crl;
 
    # OCSP Stapling
    ssl_stapling on;
    ssl_stapling_verify on;
 
    location / {
        # クライアント証明書の情報をバックエンドに転送
        proxy_set_header X-Client-DN $ssl_client_s_dn;
        proxy_set_header X-Client-Serial $ssl_client_serial;
        proxy_set_header X-Client-Verify $ssl_client_verify;
        proxy_set_header X-Client-Fingerprint $ssl_client_fingerprint;
        proxy_pass http://backend;
    }
}

// コード例7: Go での mTLS 実装（サーバ + クライアント）
package main
 
import (
    "crypto/ecdsa"
    "crypto/elliptic"
    "crypto/rand"
    "crypto/tls"
    "crypto/x509"
    "crypto/x509/pkix"
    "encoding/pem"
    "fmt"
    "math/big"
    "net/http"
    "os"
    "time"
)
 
// ===== CA と証明書の生成 =====
 
func generateCA() (*x509.Certificate, *ecdsa.PrivateKey, error) {
    caKey, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
 
    template := &x509.Certificate{
        SerialNumber: big.NewInt(1),
        Subject: pkix.Name{
            Organization: []string{"MyOrg Internal CA"},
            CommonName:   "MyOrg Root CA",
        },
        NotBefore:             time.Now(),
        NotAfter:              time.Now().Add(10 * 365 * 24 * time.Hour),
        KeyUsage:              x509.KeyUsageCertSign | x509.KeyUsageCRLSign,
        BasicConstraintsValid: true,
        IsCA:                  true,
        MaxPathLen:            1,
    }
 
    certDER, _ := x509.CreateCertificate(
        rand.Reader, template, template, &caKey.PublicKey, caKey,
    )
    cert, _ := x509.ParseCertificate(certDER)
    return cert, caKey, nil
}
 
func generateClientCert(caCert *x509.Certificate, caKey *ecdsa.PrivateKey,
    commonName string) error {
    // クライアント鍵ペア生成
    clientKey, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
 
    // 証明書テンプレート
    template := &x509.Certificate{
        SerialNumber: big.NewInt(2),
        Subject: pkix.Name{
            Organization: []string{"MyOrg"},
            CommonName:   commonName,
        },
        NotBefore:             time.Now(),
        NotAfter:              time.Now().Add(365 * 24 * time.Hour),
        KeyUsage:              x509.KeyUsageDigitalSignature,
        ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth},
        BasicConstraintsValid: true,
    }
 
    // CA で署名
    certDER, _ := x509.CreateCertificate(
        rand.Reader, template, caCert, &clientKey.PublicKey, caKey,
    )
 
    // PEM 書き出し
    certFile, _ := os.Create(commonName + ".crt")
    pem.Encode(certFile, &pem.Block{Type: "CERTIFICATE", Bytes: certDER})
    certFile.Close()
 
    keyDER, _ := x509.MarshalECPrivateKey(clientKey)
    keyFile, _ := os.Create(commonName + ".key")
    pem.Encode(keyFile, &pem.Block{Type: "EC PRIVATE KEY", Bytes: keyDER})
    keyFile.Close()
 
    return nil
}
 
// ===== mTLS サーバ =====
 
func startMTLSServer(caCertPool *x509.CertPool) {
    tlsConfig := &tls.Config{
        ClientAuth: tls.RequireAndVerifyClientCert,
        ClientCAs:  caCertPool,
        MinVersion: tls.VersionTLS13,
    }
 
    server := &http.Server{
        Addr:      ":8443",
        TLSConfig: tlsConfig,
    }
 
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        // クライアント証明書の情報を取得
        if len(r.TLS.PeerCertificates) > 0 {
            clientCert := r.TLS.PeerCertificates[0]
            fmt.Fprintf(w, "Hello, %s (verified by mTLS)\n",
                clientCert.Subject.CommonName)
        }
    })
 
    server.ListenAndServeTLS("server.crt", "server.key")
}
 
// ===== mTLS クライアント =====
 
func createMTLSClient(clientCert, clientKey, caCert string) (*http.Client, error) {
    cert, err := tls.LoadX509KeyPair(clientCert, clientKey)
    if err != nil {
        return nil, err
    }
 
    caCertPEM, _ := os.ReadFile(caCert)
    caCertPool := x509.NewCertPool()
    caCertPool.AppendCertsFromPEM(caCertPEM)
 
    tlsConfig := &tls.Config{
        Certificates: []tls.Certificate{cert},
        RootCAs:      caCertPool,
        MinVersion:   tls.VersionTLS13,
    }
 
    return &http.Client{
        Transport: &http.Transport{TLSClientConfig: tlsConfig},
        Timeout:   30 * time.Second,
    }, nil
}

# コード例8: Python mTLS クライアント
import httpx
import ssl
 
def create_mtls_client(
    client_cert: str,
    client_key: str,
    ca_cert: str,
) -> httpx.Client:
    """mTLS 対応の HTTP クライアントを作成"""
    ssl_context = ssl.create_default_context(
        purpose=ssl.Purpose.SERVER_AUTH,
        cafile=ca_cert,
    )
    ssl_context.load_cert_chain(
        certfile=client_cert,
        keyfile=client_key,
    )
    ssl_context.minimum_version = ssl.TLSVersion.TLSv1_2
 
    return httpx.Client(
        verify=ssl_context,
        timeout=30.0,
    )
 
# 使用例
client = create_mtls_client(
    client_cert="client.crt",
    client_key="client.key",
    ca_cert="ca.crt",
)
response = client.get("https://api.example.com/data")
print(response.json())

# コード例9: Nginx TLS 設定（Modern プロファイル）
server {
    listen 443 ssl http2;
    server_name example.com;
 
    # 証明書
    ssl_certificate     /etc/nginx/ssl/fullchain.pem;
    ssl_certificate_key /etc/nginx/ssl/privkey.pem;
 
    # プロトコル（TLS 1.3 のみ — Modern）
    ssl_protocols TLSv1.3;
    # TLS 1.2 も含める場合（Intermediate）:
    # ssl_protocols TLSv1.2 TLSv1.3;
 
    # 暗号スイート
    # TLS 1.3 の場合は ssl_ciphers の設定は不要（TLS 1.3 のスイートは固定）
    # TLS 1.2 を含める場合:
    # ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305;
    ssl_prefer_server_ciphers off;  # TLS 1.3 ではクライアント選択を推奨
 
    # DH パラメータ (TLS 1.2 使用時)
    # openssl dhparam -out /etc/nginx/ssl/dhparam.pem 2048
    # ssl_dhparam /etc/nginx/ssl/dhparam.pem;
 
    # セッションキャッシュ
    ssl_session_timeout 1d;
    ssl_session_cache shared:SSL:10m;
    ssl_session_tickets off;  # PFS を完全に保証するため
 
    # OCSP Stapling
    ssl_stapling on;
    ssl_stapling_verify on;
    ssl_trusted_certificate /etc/nginx/ssl/chain.pem;
    resolver 1.1.1.1 8.8.8.8 valid=300s;
 
    # 0-RTT (TLS 1.3)
    ssl_early_data on;
 
    # セキュリティヘッダ
    add_header Strict-Transport-Security "max-age=63072000; includeSubDomains; preload" always;
    add_header X-Content-Type-Options nosniff always;
    add_header X-Frame-Options DENY always;
 
    # HTTP → HTTPS リダイレクト（別の server ブロックで）
}
 
server {
    listen 80;
    server_name example.com;
    return 301 https://$host$request_uri;
}

# コード例10: 証明書有効期限監視スクリプト
import ssl
import socket
import datetime
import json
from typing import Optional
 
class CertificateMonitor:
    """TLS 証明書の有効期限を監視"""
 
    def __init__(self, warning_days: int = 30, critical_days: int = 7):
        self.warning_days = warning_days
        self.critical_days = critical_days
 
    def check_certificate(self, hostname: str, port: int = 443) -> dict:
        """証明書情報を取得して有効期限をチェック"""
        context = ssl.create_default_context()
        try:
            with socket.create_connection((hostname, port), timeout=10) as sock:
                with context.wrap_socket(sock, server_hostname=hostname) as ssock:
                    cert = ssock.getpeercert()
 
            # 有効期限を解析
            not_after = datetime.datetime.strptime(
                cert["notAfter"], "%b %d %H:%M:%S %Y %Z"
            )
            days_remaining = (not_after - datetime.datetime.utcnow()).days
 
            # ステータス判定
            if days_remaining < 0:
                status = "EXPIRED"
            elif days_remaining <= self.critical_days:
                status = "CRITICAL"
            elif days_remaining <= self.warning_days:
                status = "WARNING"
            else:
                status = "OK"
 
            # SAN (Subject Alternative Name) の取得
            san = []
            for entry_type, value in cert.get("subjectAltName", []):
                if entry_type == "DNS":
                    san.append(value)
 
            return {
                "hostname": hostname,
                "status": status,
                "days_remaining": days_remaining,
                "not_after": not_after.isoformat(),
                "issuer": dict(x[0] for x in cert["issuer"]),
                "subject": dict(x[0] for x in cert["subject"]),
                "san": san,
                "serial_number": cert.get("serialNumber"),
                "version": cert.get("version"),
            }
 
        except ssl.SSLCertVerificationError as e:
            return {"hostname": hostname, "status": "VERIFICATION_ERROR",
                    "error": str(e)}
        except (socket.timeout, ConnectionRefusedError) as e:
            return {"hostname": hostname, "status": "CONNECTION_ERROR",
                    "error": str(e)}
 
    def check_multiple(self, hostnames: list[str]) -> list[dict]:
        """複数ホストの証明書を一括チェック"""
        results = []
        for hostname in hostnames:
            result = self.check_certificate(hostname)
            results.append(result)
            if result["status"] in ("CRITICAL", "EXPIRED"):
                print(f"[{result['status']}] {hostname}: "
                      f"{result.get('days_remaining', 'N/A')} days remaining")
        return results
 
 
# 使用例
monitor = CertificateMonitor(warning_days=30, critical_days=7)
domains = [
    "example.com",
    "api.example.com",
    "app.example.com",
]
results = monitor.check_multiple(domains)
print(json.dumps(results, indent=2, default=str))

# コード例11: cert-manager による自動証明書管理
# ClusterIssuer (Let's Encrypt)
apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt-production
spec:
  acme:
    server: https://acme-v02.api.letsencrypt.org/directory
    email: admin@example.com
    privateKeySecretRef:
      name: letsencrypt-production-key
    solvers:
      - http01:
          ingress:
            class: nginx
      - dns01:
          cloudflare:
            email: admin@example.com
            apiTokenSecretRef:
              name: cloudflare-api-token
              key: api-token
        selector:
          dnsZones:
            - "example.com"
 
---
# Certificate リソース
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: example-com-tls
  namespace: default
spec:
  secretName: example-com-tls-secret
  issuerRef:
    name: letsencrypt-production
    kind: ClusterIssuer
  dnsNames:
    - example.com
    - "*.example.com"
  duration: 2160h      # 90日
  renewBefore: 720h    # 30日前に更新
 
---
# Ingress での使用
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
  annotations:
    cert-manager.io/cluster-issuer: "letsencrypt-production"
spec:
  tls:
    - hosts:
        - example.com
      secretName: example-com-tls-secret
  rules:
    - host: example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: web-service
                port:
                  number: 80

# NG: 本番環境で証明書検証を無効化
import requests
response = requests.get("https://api.example.com", verify=False)
# WARNING: InsecureRequestWarning が出るが無視される
 
# OK: 正しい CA バンドルを指定
response = requests.get("https://api.example.com", verify="/path/to/ca-bundle.crt")
 
# OK: 環境変数で CA バンドルを指定
# export REQUESTS_CA_BUNDLE=/path/to/ca-bundle.crt

# NG: TLS 1.0/1.1 を許可
ssl_protocols TLSv1 TLSv1.1 TLSv1.2 TLSv1.3;
 
# OK: TLS 1.2 以上のみ許可
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers 'ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256';
ssl_prefer_server_ciphers on;

# NG: ソースコードに秘密鍵を埋め込む
PRIVATE_KEY = """-----BEGIN EC PRIVATE KEY-----
MHQCAQEEIBkg4LVWM...
-----END EC PRIVATE KEY-----"""
 
# OK: 環境変数またはシークレットマネージャから取得
import os
key_path = os.environ["TLS_KEY_PATH"]
with open(key_path) as f:
    private_key = f.read()
 
# OK: AWS Secrets Manager / HashiCorp Vault から取得
import boto3
client = boto3.client("secretsmanager")
secret = client.get_secret_value(SecretId="tls/server-key")

# 1. 任意のサイトの TLS バージョンと暗号スイートを確認
openssl s_client -connect google.com:443 -tls1_3
 
# 2. 証明書チェーンの発行者を確認
openssl s_client -connect github.com:443 -showcerts 2>/dev/null | \
  grep -E "subject|issuer"
 
# 質問:
# - TLS 1.3 で使用されている暗号スイートは?
# - 証明書チェーンは何階層か?
# - Root CA は何か?

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()