# コード例1: セキュリティインシデントのコスト試算モデル
from dataclasses import dataclass
from typing import List, Optional
from enum import Enum
 
class IncidentSeverity(Enum):
    """インシデントの深刻度レベル"""
    LOW = "低"
    MEDIUM = "中"
    HIGH = "高"
    CRITICAL = "重大"
 
@dataclass
class SecurityIncident:
    """セキュリティインシデントのモデル"""
    name: str
    severity: IncidentSeverity
    affected_records: int
    detection_days: int  # 検出までの日数
    containment_days: int  # 封じ込めまでの日数
 
    @property
    def estimated_cost(self) -> float:
        """
        インシデントコストの概算（IBM Cost of Data Breach 2023 ベース）
        レコード単価 * 影響レコード数 + 検出遅延ペナルティ
        """
        cost_per_record = {
            IncidentSeverity.LOW: 50,
            IncidentSeverity.MEDIUM: 120,
            IncidentSeverity.HIGH: 180,
            IncidentSeverity.CRITICAL: 250,
        }
        base_cost = cost_per_record[self.severity] * self.affected_records
        # 検出に200日以上かかると追加コスト30%
        delay_penalty = 1.3 if self.detection_days > 200 else 1.0
        return base_cost * delay_penalty
 
    @property
    def total_lifecycle_days(self) -> int:
        return self.detection_days + self.containment_days
 
    def summary(self) -> str:
        return (
            f"インシデント: {self.name}\n"
            f"  深刻度: {self.severity.value}\n"
            f"  影響レコード: {self.affected_records:,}\n"
            f"  ライフサイクル: {self.total_lifecycle_days}日 "
            f"(検出{self.detection_days}日 + 封じ込め{self.containment_days}日)\n"
            f"  推定コスト: ${self.estimated_cost:,.0f}"
        )
 
# 使用例
breach = SecurityIncident(
    name="顧客情報データベース漏洩",
    severity=IncidentSeverity.HIGH,
    affected_records=50000,
    detection_days=250,
    containment_days=60,
)
print(breach.summary())
# => インシデント: 顧客情報データベース漏洩
# =>   深刻度: 高
# =>   影響レコード: 50,000
# =>   ライフサイクル: 310日 (検出250日 + 封じ込め60日)
# =>   推定コスト: $11,700,000

# コード例2: ロールベースアクセス制御（RBAC）による機密性の確保
import hashlib
import hmac
import logging
from typing import Dict, List, Optional, Set
from dataclasses import dataclass, field
from enum import Enum, auto
from functools import wraps
 
# ログ設定（監査証跡として重要）
logger = logging.getLogger("access_control")
logging.basicConfig(level=logging.INFO)
 
class Permission(Enum):
    """システムの権限定義"""
    READ = auto()
    WRITE = auto()
    DELETE = auto()
    MANAGE_USERS = auto()
    VIEW_AUDIT_LOG = auto()
    EXPORT_DATA = auto()
 
class DataClassification(Enum):
    """データ分類（機密レベル）"""
    PUBLIC = "公開"
    INTERNAL = "社内限定"
    CONFIDENTIAL = "機密"
    RESTRICTED = "極秘"
 
@dataclass
class User:
    """ユーザーモデル"""
    user_id: str
    name: str
    role: str
    department: str
    clearance_level: DataClassification = DataClassification.INTERNAL
 
@dataclass
class AccessControlSystem:
    """ロールベースアクセス制御（RBAC）の実装"""
 
    role_permissions: Dict[str, Set[Permission]] = field(default_factory=dict)
    data_classifications: Dict[str, DataClassification] = field(default_factory=dict)
 
    def __post_init__(self):
        # デフォルトのロール定義
        self.role_permissions = {
            "admin": {
                Permission.READ, Permission.WRITE, Permission.DELETE,
                Permission.MANAGE_USERS, Permission.VIEW_AUDIT_LOG,
                Permission.EXPORT_DATA,
            },
            "editor": {
                Permission.READ, Permission.WRITE,
            },
            "viewer": {
                Permission.READ,
            },
            "auditor": {
                Permission.READ, Permission.VIEW_AUDIT_LOG,
            },
        }
 
    def check_permission(self, user: User, action: Permission,
                         resource: str) -> bool:
        """ユーザーのロールとデータ分類に基づいてアクセスを判定"""
        # ロールに基づく権限チェック
        allowed_permissions = self.role_permissions.get(user.role, set())
        if action not in allowed_permissions:
            self._log_access_denied(user, action, resource, "権限不足")
            return False
 
        # データ分類に基づくアクセスチェック
        resource_classification = self.data_classifications.get(
            resource, DataClassification.INTERNAL
        )
        if not self._check_clearance(user.clearance_level, resource_classification):
            self._log_access_denied(user, action, resource, "クリアランス不足")
            return False
 
        self._log_access_granted(user, action, resource)
        return True
 
    def _check_clearance(self, user_level: DataClassification,
                         resource_level: DataClassification) -> bool:
        """ユーザーのクリアランスレベルがリソースの分類以上かチェック"""
        hierarchy = [
            DataClassification.PUBLIC,
            DataClassification.INTERNAL,
            DataClassification.CONFIDENTIAL,
            DataClassification.RESTRICTED,
        ]
        return hierarchy.index(user_level) >= hierarchy.index(resource_level)
 
    def _log_access_denied(self, user: User, action: Permission,
                           resource: str, reason: str) -> None:
        logger.warning(
            f"ACCESS DENIED: user={user.user_id}, action={action.name}, "
            f"resource={resource}, reason={reason}"
        )
 
    def _log_access_granted(self, user: User, action: Permission,
                            resource: str) -> None:
        logger.info(
            f"ACCESS GRANTED: user={user.user_id}, action={action.name}, "
            f"resource={resource}"
        )
 
# 使用例
acl = AccessControlSystem()
acl.data_classifications["customer_data"] = DataClassification.CONFIDENTIAL
acl.data_classifications["public_catalog"] = DataClassification.PUBLIC
 
admin_user = User("u001", "Admin Taro", "admin", "IT",
                   DataClassification.RESTRICTED)
viewer_user = User("u002", "Viewer Hanako", "viewer", "Marketing",
                    DataClassification.INTERNAL)
 
# admin は customer_data にアクセスできる
print(acl.check_permission(admin_user, Permission.READ, "customer_data"))
# => True
 
# viewer は customer_data にアクセスできない（クリアランス不足）
print(acl.check_permission(viewer_user, Permission.READ, "customer_data"))
# => False

# コード例3: ハッシュチェーンによるデータ完全性の検証
import hashlib
import hmac
import json
import time
from dataclasses import dataclass, field
from typing import List, Optional
 
@dataclass
class IntegrityRecord:
    """改ざん検知可能なデータレコード"""
    data: dict
    timestamp: float = field(default_factory=time.time)
    previous_hash: str = ""
    record_hash: str = ""
 
    def __post_init__(self):
        if not self.record_hash:
            self.record_hash = self._compute_hash()
 
    def _compute_hash(self) -> str:
        """レコードのハッシュを計算（チェーン構造）"""
        content = json.dumps({
            "data": self.data,
            "timestamp": self.timestamp,
            "previous_hash": self.previous_hash,
        }, sort_keys=True)
        return hashlib.sha256(content.encode()).hexdigest()
 
    def verify(self) -> bool:
        """レコードの完全性を検証"""
        expected = self._compute_hash()
        return hmac.compare_digest(self.record_hash, expected)
 
class IntegrityChain:
    """ハッシュチェーンによる完全性保証（簡易ブロックチェーン構造）"""
 
    def __init__(self):
        self.records: List[IntegrityRecord] = []
 
    def add_record(self, data: dict) -> IntegrityRecord:
        """新しいレコードをチェーンに追加"""
        previous_hash = (
            self.records[-1].record_hash if self.records else "GENESIS"
        )
        record = IntegrityRecord(
            data=data,
            previous_hash=previous_hash,
        )
        self.records.append(record)
        return record
 
    def verify_chain(self) -> dict:
        """チェーン全体の完全性を検証"""
        results = {"valid": True, "total": len(self.records), "errors": []}
 
        for i, record in enumerate(self.records):
            # 個別レコードのハッシュ検証
            if not record.verify():
                results["valid"] = False
                results["errors"].append(f"Record {i}: ハッシュ不一致（改ざん検出）")
 
            # チェーンの連続性検証
            if i > 0:
                expected_prev = self.records[i - 1].record_hash
                if record.previous_hash != expected_prev:
                    results["valid"] = False
                    results["errors"].append(
                        f"Record {i}: チェーン断裂（前レコード改ざん検出）"
                    )
 
        return results
 
# 使用例
chain = IntegrityChain()
chain.add_record({"transaction": "入金", "amount": 10000, "user": "alice"})
chain.add_record({"transaction": "出金", "amount": 3000, "user": "alice"})
chain.add_record({"transaction": "送金", "amount": 2000, "user": "bob"})
 
# 完全性検証
result = chain.verify_chain()
print(f"チェーン検証: {'OK' if result['valid'] else 'NG'}")
print(f"レコード数: {result['total']}")
# => チェーン検証: OK
# => レコード数: 3
 
# 改ざんテスト
chain.records[1].data["amount"] = 99999  # 改ざん!
result = chain.verify_chain()
print(f"改ざん後の検証: {'OK' if result['valid'] else 'NG'}")
print(f"エラー: {result['errors']}")
# => 改ざん後の検証: NG
# => エラー: ['Record 1: ハッシュ不一致（改ざん検出）']

# コード例4: 可用性監視とフェイルオーバー制御
import time
from typing import List, Dict, Optional, Callable
from dataclasses import dataclass, field
from enum import Enum
 
class ServiceStatus(Enum):
    HEALTHY = "healthy"
    DEGRADED = "degraded"
    UNHEALTHY = "unhealthy"
    UNKNOWN = "unknown"
 
@dataclass
class HealthCheckResult:
    """ヘルスチェック結果"""
    endpoint: str
    status: ServiceStatus
    latency_ms: float
    timestamp: float
    error: Optional[str] = None
 
@dataclass
class AvailabilityMonitor:
    """サービスの可用性を監視しフェイルオーバーを制御するシステム"""
 
    endpoints: List[str]
    timeout_seconds: int = 5
    max_failures: int = 3  # フェイルオーバー閾値
    check_interval: int = 30  # ヘルスチェック間隔（秒）
    failure_counts: Dict[str, int] = field(default_factory=dict)
    history: List[HealthCheckResult] = field(default_factory=list)
 
    def __post_init__(self):
        for ep in self.endpoints:
            self.failure_counts[ep] = 0
 
    def check_health(self, endpoint: str) -> HealthCheckResult:
        """
        エンドポイントの稼働状態を確認する。
        実際にはHTTPリクエストを送信するが、ここではシミュレーション。
        """
        start = time.time()
        try:
            # 実運用では requests.get(f"{endpoint}/health", timeout=self.timeout_seconds)
            # ここではシミュレーション
            latency = (time.time() - start) * 1000
            result = HealthCheckResult(
                endpoint=endpoint,
                status=ServiceStatus.HEALTHY,
                latency_ms=round(latency, 2),
                timestamp=time.time(),
            )
        except Exception as e:
            result = HealthCheckResult(
                endpoint=endpoint,
                status=ServiceStatus.UNHEALTHY,
                latency_ms=0,
                timestamp=time.time(),
                error=str(e),
            )
 
        # 失敗カウントの更新
        if result.status == ServiceStatus.UNHEALTHY:
            self.failure_counts[endpoint] = (
                self.failure_counts.get(endpoint, 0) + 1
            )
        else:
            self.failure_counts[endpoint] = 0
 
        self.history.append(result)
        return result
 
    def should_failover(self, endpoint: str) -> bool:
        """フェイルオーバーが必要かどうかを判定"""
        return self.failure_counts.get(endpoint, 0) >= self.max_failures
 
    def select_healthy_endpoint(self) -> Optional[str]:
        """最も健全なエンドポイントを選択"""
        for ep in self.endpoints:
            if not self.should_failover(ep):
                return ep
        return None  # 全エンドポイント障害
 
    def calculate_uptime(self, endpoint: str) -> float:
        """稼働率を計算"""
        ep_history = [h for h in self.history if h.endpoint == endpoint]
        if not ep_history:
            return 0.0
        healthy = sum(1 for h in ep_history
                      if h.status == ServiceStatus.HEALTHY)
        return (healthy / len(ep_history)) * 100
 
# 使用例
monitor = AvailabilityMonitor(
    endpoints=[
        "https://primary.example.com",
        "https://secondary.example.com",
        "https://tertiary.example.com",
    ],
    max_failures=3,
)
 
# ヘルスチェック実行（シミュレーション）
result = monitor.check_health("https://primary.example.com")
print(f"Status: {result.status.value}, Latency: {result.latency_ms}ms")
 
# フェイルオーバー判定
selected = monitor.select_healthy_endpoint()
print(f"Selected endpoint: {selected}")

# コード例5: 監査ログによる責任追跡性の実装
import json
import time
import hashlib
from datetime import datetime
from typing import Optional, Dict, Any
from dataclasses import dataclass, field, asdict
 
@dataclass
class AuditLogEntry:
    """改ざん検知機能付き監査ログエントリ"""
    event_id: str
    timestamp: str
    actor: str            # 操作者
    action: str           # 操作内容
    resource: str         # 対象リソース
    result: str           # 成功/失敗
    source_ip: str        # 接続元IP
    details: Dict[str, Any] = field(default_factory=dict)
    integrity_hash: str = ""
 
    def __post_init__(self):
        if not self.integrity_hash:
            self.integrity_hash = self._compute_hash()
 
    def _compute_hash(self) -> str:
        """ログエントリの改ざん検知用ハッシュを計算"""
        content = json.dumps({
            "event_id": self.event_id,
            "timestamp": self.timestamp,
            "actor": self.actor,
            "action": self.action,
            "resource": self.resource,
            "result": self.result,
            "source_ip": self.source_ip,
            "details": self.details,
        }, sort_keys=True)
        return hashlib.sha256(content.encode()).hexdigest()
 
    def verify_integrity(self) -> bool:
        """ログエントリの改ざんを検証"""
        import hmac as _hmac
        return _hmac.compare_digest(
            self.integrity_hash, self._compute_hash()
        )
 
class AuditLogger:
    """監査ログ管理システム"""
 
    def __init__(self):
        self.logs: list = []
        self._counter = 0
 
    def log(self, actor: str, action: str, resource: str,
            result: str, source_ip: str,
            details: Optional[Dict[str, Any]] = None) -> AuditLogEntry:
        """監査ログを記録"""
        self._counter += 1
        entry = AuditLogEntry(
            event_id=f"EVT-{self._counter:06d}",
            timestamp=datetime.utcnow().isoformat() + "Z",
            actor=actor,
            action=action,
            resource=resource,
            result=result,
            source_ip=source_ip,
            details=details or {},
        )
        self.logs.append(entry)
        return entry
 
    def query(self, actor: Optional[str] = None,
              action: Optional[str] = None) -> list:
        """監査ログの検索"""
        results = self.logs
        if actor:
            results = [e for e in results if e.actor == actor]
        if action:
            results = [e for e in results if e.action == action]
        return results
 
    def verify_all(self) -> Dict[str, Any]:
        """全ログの完全性を検証"""
        total = len(self.logs)
        valid = sum(1 for e in self.logs if e.verify_integrity())
        return {
            "total": total,
            "valid": valid,
            "tampered": total - valid,
            "integrity": "OK" if valid == total else "COMPROMISED",
        }
 
# 使用例
audit = AuditLogger()
audit.log("admin", "LOGIN", "/auth", "SUCCESS", "192.168.1.100")
audit.log("admin", "DELETE", "/users/42", "SUCCESS", "192.168.1.100",
          {"target_user": "user42", "reason": "規約違反"})
audit.log("user01", "READ", "/reports/financial", "DENIED", "10.0.0.50",
          {"reason": "権限不足"})
 
# ログの検索
admin_actions = audit.query(actor="admin")
print(f"admin の操作数: {len(admin_actions)}")
 
# 完全性検証
integrity = audit.verify_all()
print(f"ログ完全性: {integrity['integrity']}")
# => ログ完全性: OK

# コード例6: リスクマトリクスの生成と可視化
from dataclasses import dataclass
from typing import List, Tuple
 
@dataclass
class RiskItem:
    """リスク評価対象"""
    name: str
    threat_level: int      # 1-5: 脅威レベル
    vulnerability: int     # 1-5: 脆弱性レベル
    impact: int            # 1-5: 影響度
 
    @property
    def risk_score(self) -> float:
        """リスクスコア（正規化: 0-100）"""
        raw = self.threat_level * self.vulnerability * self.impact
        return round((raw / 125) * 100, 1)  # 125 = 5*5*5
 
    @property
    def risk_level(self) -> str:
        score = self.risk_score
        if score >= 60:
            return "Critical"
        elif score >= 40:
            return "High"
        elif score >= 20:
            return "Medium"
        return "Low"
 
    @property
    def recommended_action(self) -> str:
        level = self.risk_level
        actions = {
            "Critical": "即時対応: 緩和策の即座の適用",
            "High": "優先対応: 30日以内に対策を実施",
            "Medium": "計画対応: 次のスプリントで対策を計画",
            "Low": "受容/監視: リスクを受容し定期的に再評価",
        }
        return actions[level]
 
def generate_risk_matrix() -> str:
    """5x5のリスクマトリクスを文字列として生成する"""
    impact_labels = ["軽微", "  小", "  中", "  大", "甚大"]
    likelihood_labels = ["  稀", "  低", "  中", "  高", "極高"]
 
    lines = []
    lines.append("影響度→  |  軽微  |   小   |   中   |   大   |  甚大  |")
    lines.append("発生可能性↓" + "-" * 50)
 
    for l_idx in range(5, 0, -1):
        row_label = likelihood_labels[l_idx - 1]
        cells = []
        for i_idx in range(1, 6):
            score = l_idx * i_idx
            if score >= 20:
                level = "C"  # Critical
            elif score >= 12:
                level = "H"  # High
            elif score >= 6:
                level = "M"  # Medium
            else:
                level = "L"  # Low
            cells.append(f"{score:2d}({level})")
        lines.append(f"  {row_label}   | {'  |  '.join(cells)}  |")
 
    return "\n".join(lines)
 
# リスクマトリクスの表示
print(generate_risk_matrix())
 
# 具体的なリスク評価
risks = [
    RiskItem("SQLインジェクション", 4, 5, 5),
    RiskItem("DDoS攻撃", 3, 3, 4),
    RiskItem("内部者による情報漏洩", 2, 4, 5),
    RiskItem("フィッシング", 5, 3, 3),
]
 
print("\n--- リスク評価結果 ---")
for risk in sorted(risks, key=lambda r: r.risk_score, reverse=True):
    print(f"{risk.name}: スコア={risk.risk_score}, "
          f"レベル={risk.risk_level}, "
          f"推奨={risk.recommended_action}")

# コード例7: セキュリティメトリクスダッシュボード
from dataclasses import dataclass, field
from typing import List, Dict
from datetime import datetime, timedelta
 
@dataclass
class SecurityMetrics:
    """セキュリティKPIの収集と分析"""
 
    # 脆弱性管理メトリクス
    open_vulnerabilities: Dict[str, int] = field(default_factory=dict)
    # パッチ管理メトリクス
    patch_compliance_rate: float = 0.0
    # インシデントメトリクス
    incidents: List[dict] = field(default_factory=list)
    # 教育メトリクス
    training_completion_rate: float = 0.0
 
    def __post_init__(self):
        self.open_vulnerabilities = {
            "critical": 0,
            "high": 0,
            "medium": 0,
            "low": 0,
        }
 
    def add_incident(self, severity: str, detected_at: datetime,
                     resolved_at: datetime, category: str) -> None:
        """インシデントを記録"""
        self.incidents.append({
            "severity": severity,
            "detected_at": detected_at,
            "resolved_at": resolved_at,
            "category": category,
            "mttr_hours": (resolved_at - detected_at).total_seconds() / 3600,
        })
 
    @property
    def mean_time_to_respond(self) -> float:
        """平均対応時間（MTTR）を計算"""
        if not self.incidents:
            return 0.0
        total_hours = sum(i["mttr_hours"] for i in self.incidents)
        return round(total_hours / len(self.incidents), 2)
 
    @property
    def vulnerability_density(self) -> int:
        """脆弱性の総数"""
        return sum(self.open_vulnerabilities.values())
 
    def generate_report(self) -> str:
        """セキュリティメトリクスレポートを生成"""
        lines = [
            "=== セキュリティメトリクスレポート ===",
            f"日時: {datetime.now().strftime('%Y-%m-%d %H:%M')}",
            "",
            "--- 脆弱性管理 ---",
            f"  未解決脆弱性: {self.vulnerability_density}件",
        ]
        for severity, count in self.open_vulnerabilities.items():
            lines.append(f"    {severity}: {count}件")
        lines.extend([
            "",
            "--- パッチ管理 ---",
            f"  パッチ適用率: {self.patch_compliance_rate:.1f}%",
            "",
            "--- インシデント対応 ---",
            f"  インシデント数: {len(self.incidents)}件",
            f"  平均対応時間(MTTR): {self.mean_time_to_respond}時間",
            "",
            "--- セキュリティ教育 ---",
            f"  研修完了率: {self.training_completion_rate:.1f}%",
        ])
        return "\n".join(lines)
 
# 使用例
metrics = SecurityMetrics()
metrics.open_vulnerabilities = {
    "critical": 2, "high": 8, "medium": 24, "low": 45
}
metrics.patch_compliance_rate = 94.5
metrics.training_completion_rate = 87.3
 
now = datetime.now()
metrics.add_incident(
    "high", now - timedelta(hours=12), now - timedelta(hours=4), "マルウェア"
)
metrics.add_incident(
    "medium", now - timedelta(hours=6), now - timedelta(hours=2), "不正アクセス"
)
 
print(metrics.generate_report())

# NG: 後からセキュリティを追加
class UserServiceBad:
    def create_user(self, username: str, password: str) -> None:
        # パスワードを平文で保存してしまう
        self.db.execute(
            "INSERT INTO users (username, password) VALUES (?, ?)",
            (username, password)
        )
 
# OK: 最初からセキュリティを組み込む
import bcrypt
 
class UserServiceGood:
    def create_user(self, username: str, password: str) -> None:
        # Step 1: パスワードポリシーの検証
        self._validate_password_policy(password)
        # Step 2: bcryptでハッシュ化（ソルト自動生成）
        hashed = bcrypt.hashpw(password.encode(), bcrypt.gensalt(rounds=12))
        # Step 3: パラメータ化クエリで安全に保存
        self.db.execute(
            "INSERT INTO users (username, password_hash) VALUES (?, ?)",
            (username, hashed.decode())
        )
        # Step 4: 監査ログの記録
        self.audit_log.record("CREATE_USER", username)
 
    def _validate_password_policy(self, password: str) -> None:
        """パスワードポリシーの検証"""
        if len(password) < 12:
            raise ValueError("パスワードは12文字以上必要です")
        if not any(c.isupper() for c in password):
            raise ValueError("大文字を含める必要があります")
        if not any(c.isdigit() for c in password):
            raise ValueError("数字を含める必要があります")
        if not any(c in "!@#$%^&*()-_+=[]{}|;:,.<>?" for c in password):
            raise ValueError("特殊文字を含める必要があります")

# NG: ファイアウォールだけに依存
class InsecureApp:
    """FWが守ってくれるから大丈夫、という危険な思考"""
    def handle_request(self, user_input: str) -> str:
        # 入力バリデーションなし
        # SQLパラメータ化なし
        # 認証チェックなし
        query = f"SELECT * FROM data WHERE name = '{user_input}'"
        return self.db.execute(query)
 
# OK: 多層防御の実装
class SecureApp:
    """複数の防御層を実装"""
    def handle_request(self, user_input: str, auth_token: str) -> str:
        # Layer 1: 認証チェック
        user = self.auth.verify_token(auth_token)
        if not user:
            raise AuthenticationError("認証が必要です")
 
        # Layer 2: 認可チェック
        if not self.acl.check_permission(user, "read", "data"):
            raise AuthorizationError("権限がありません")
 
        # Layer 3: 入力バリデーション
        if not self.validator.is_safe(user_input):
            raise ValidationError("不正な入力です")
 
        # Layer 4: パラメータ化クエリ
        result = self.db.execute(
            "SELECT * FROM data WHERE name = ?", (user_input,)
        )
 
        # Layer 5: 出力フィルタリング
        return self.sanitize_output(result)

# NG: 秘密のURLだけで保護
@app.route("/admin-secret-panel-xyz123")
def admin_panel_insecure():
    # URLが秘密だから大丈夫...は間違い
    return render_template("admin.html")
 
# OK: 適切な認証・認可 + 秘密のURL（補助的対策）
@app.route("/admin")
@require_authentication
@require_role("admin")
@require_mfa
def admin_panel_secure():
    return render_template("admin.html")