# デバッグコード例
def debug_password_auth(username, password):
    print(f"1. ユーザー検索: {username}")
    user = User.find_by_username(username)
    if not user:
        print("   → ユーザーが見つかりません")
        return
    
    print(f"2. アカウント状態: active={user.is_active}")
    if not user.is_active:
        print("   → アカウントが無効化されています")
        return
    
    print(f"3. パスワードハッシュ形式: {user.password_hash[:20]}...")
    
    # ハッシュアルゴリズムの確認
    if user.password_hash.startswith("$2b$"):
        print("   → bcrypt形式")
    elif user.password_hash.startswith("$argon2"):
        print("   → Argon2形式")
    
    print(f"4. パスワード検証実行")
    is_valid = verify_password(password, user.password_hash)
    print(f"   → 結果: {is_valid}")

import pyotp
import time
from datetime import datetime, timezone

def diagnose_totp_issue(secret, user_input_code):
    """TOTP問題の診断"""
    totp = pyotp.TOTP(secret)
    
    # 現在時刻での正しいコード
    current_time = time.time()
    correct_code = totp.at(current_time)
    
    print(f"サーバー時刻: {datetime.now(timezone.utc)}")
    print(f"正しいコード: {correct_code}")
    print(f"入力コード: {user_input_code}")
    
    # 時間窓での検証
    for offset in range(-3, 4):  # ±90秒
        time_at_offset = current_time + (offset * 30)
        code_at_offset = totp.at(time_at_offset)
        
        if code_at_offset == user_input_code:
            print(f"✓ コードは{offset * 30}秒のずれで一致")
            return True
    
    print("✗ 時間窓内で一致するコードなし")
    
    # よくある問題の確認
    if len(user_input_code) != 6:
        print("! コードの桁数が正しくありません")
    
    if not user_input_code.isdigit():
        print("! コードに数字以外が含まれています")
    
    return False

class FlexibleTOTPVerifier:
    def __init__(self, window=1, future_window=0):
        """
        window: 過去方向の許容ステップ数
        future_window: 未来方向の許容ステップ数
        """
        self.window = window
        self.future_window = future_window
    
    def verify(self, secret, token, for_time=None):
        """柔軟なTOTP検証"""
        if for_time is None:
            for_time = time.time()
        
        # pyotpのverifyメソッドを使用（時間窓対応）
        totp = pyotp.TOTP(secret)
        
        # 通常の検証
        if totp.verify(token, for_time, valid_window=self.window):
            return True, 0
        
        # 未来方向の検証（クライアント時刻が進んでいる場合）
        if self.future_window > 0:
            for i in range(1, self.future_window + 1):
                future_time = for_time + (i * 30)
                if totp.verify(token, future_time, valid_window=0):
                    return True, i * 30
        
        return False, None

def diagnose_session_issue(request, response):
    """セッション問題の診断"""
    issues = []
    
    # 1. Cookieの設定確認
    set_cookie_header = response.headers.get('Set-Cookie', '')
    
    if 'SameSite=None' in set_cookie_header and 'Secure' not in set_cookie_header:
        issues.append("SameSite=NoneにはSecure属性が必須")
    
    if 'HttpOnly' not in set_cookie_header:
        issues.append("HttpOnly属性が設定されていません（XSS脆弱性）")
    
    # 2. ドメイン設定の確認
    cookie_domain = extract_domain_from_cookie(set_cookie_header)
    request_host = request.headers.get('Host', '')
    
    if cookie_domain and not request_host.endswith(cookie_domain):
        issues.append(f"Cookieドメイン({cookie_domain})とリクエストホスト({request_host})が不一致")
    
    # 3. パス設定の確認
    cookie_path = extract_path_from_cookie(set_cookie_header)
    if cookie_path != '/':
        issues.append(f"Cookieパスが制限されています: {cookie_path}")
    
    # 4. プロキシ設定の確認
    x_forwarded_proto = request.headers.get('X-Forwarded-Proto')
    if x_forwarded_proto == 'http' and 'Secure' in set_cookie_header:
        issues.append("プロキシ背後でHTTP通信しているがSecure Cookieを設定")
    
    return issues

class SessionStorageDiagnostics:
    def __init__(self, redis_clients):
        self.redis_clients = redis_clients  # 複数のRedisノード
    
    async def check_session_replication(self, session_id):
        """セッションレプリケーションの確認"""
        results = {}
        
        for node_name, client in self.redis_clients.items():
            try:
                # セッションデータの取得
                session_data = await client.get(f"session:{session_id}")
                
                if session_data:
                    results[node_name] = {
                        'exists': True,
                        'size': len(session_data),
                        'ttl': await client.ttl(f"session:{session_id}")
                    }
                else:
                    results[node_name] = {'exists': False}
                    
            except Exception as e:
                results[node_name] = {'error': str(e)}
        
        # 整合性チェック
        unique_sessions = set(
            r.get('size', 0) for r in results.values() 
            if r.get('exists')
        )
        
        if len(unique_sessions) > 1:
            print("警告: ノード間でセッションデータのサイズが異なります")
        
        return results
    
    async def test_session_persistence(self):
        """セッション永続性テスト"""
        test_session_id = f"test_{uuid.uuid4()}"
        test_data = {"user": "test", "timestamp": time.time()}
        
        # 書き込みテスト
        write_results = {}
        for node_name, client in self.redis_clients.items():
            start = time.time()
            try:
                await client.setex(
                    f"session:{test_session_id}",
                    300,  # 5分
                    json.dumps(test_data)
                )
                write_results[node_name] = {
                    'success': True,
                    'latency': time.time() - start
                }
            except Exception as e:
                write_results[node_name] = {
                    'success': False,
                    'error': str(e)
                }
        
        # レプリケーション待機
        await asyncio.sleep(0.5)
        
        # 読み取りテスト
        read_results = await self.check_session_replication(test_session_id)
        
        return {
            'write_results': write_results,
            'read_results': read_results,
            'replication_ok': all(r.get('exists') for r in read_results.values())
        }

import cProfile
import pstats
from io import StringIO

class AuthPerformanceProfiler:
    def profile_authentication(self, username, password):
        """認証処理のプロファイリング"""
        pr = cProfile.Profile()
        pr.enable()
        
        # 認証処理の実行
        try:
            result = authenticate_user(username, password)
        finally:
            pr.disable()
        
        # 結果の解析
        s = StringIO()
        ps = pstats.Stats(pr, stream=s).sort_stats('cumulative')
        ps.print_stats(20)  # 上位20個の関数
        
        # ボトルネックの特定
        profile_data = s.getvalue()
        
        # パスワードハッシュ処理の時間
        bcrypt_time = self._extract_time(profile_data, 'bcrypt')
        db_time = self._extract_time(profile_data, 'database')
        
        recommendations = []
        
        if bcrypt_time > 0.5:
            recommendations.append({
                'issue': 'bcryptコストファクターが高すぎる',
                'current': bcrypt_time,
                'recommendation': 'コストファクターを12に調整'
            })
        
        if db_time > 0.1:
            recommendations.append({
                'issue': 'データベースクエリが遅い',
                'current': db_time,
                'recommendation': 'インデックスの追加、コネクションプーリング'
            })
        
        return {
            'total_time': pr.total_tt,
            'profile': profile_data,
            'recommendations': recommendations
        }

import asyncio
import aiohttp
import time
from datetime import datetime, timedelta

class LoadTestSimulator:
    def __init__(self, base_url, total_users=10000):
        self.base_url = base_url
        self.total_users = total_users
        self.results = []
    
    async def simulate_morning_rush(self):
        """朝のログインラッシュをシミュレート"""
        # 7:00-9:00の2時間で、ピークは8:00
        async def user_login(user_id, delay):
            await asyncio.sleep(delay)
            
            start_time = time.time()
            async with aiohttp.ClientSession() as session:
                try:
                    async with session.post(
                        f"{self.base_url}/auth/login",
                        json={
                            "username": f"user{user_id}",
                            "password": "password"
                        },
                        timeout=aiohttp.ClientTimeout(total=30)
                    ) as response:
                        end_time = time.time()
                        
                        self.results.append({
                            'user_id': user_id,
                            'status': response.status,
                            'response_time': end_time - start_time,
                            'timestamp': datetime.now()
                        })
                        
                except asyncio.TimeoutError:
                    self.results.append({
                        'user_id': user_id,
                        'status': 'timeout',
                        'response_time': 30,
                        'timestamp': datetime.now()
                    })
                except Exception as e:
                    self.results.append({
                        'user_id': user_id,
                        'status': 'error',
                        'error': str(e),
                        'timestamp': datetime.now()
                    })
        
        # 正規分布でログイン時刻を分散
        tasks = []
        for i in range(self.total_users):
            # 平均60分（8:00）、標準偏差20分
            delay = max(0, np.random.normal(60, 20) * 60)
            tasks.append(user_login(i, delay))
        
        start_time = time.time()
        await asyncio.gather(*tasks)
        total_time = time.time() - start_time
        
        # 結果の分析
        successful = sum(1 for r in self.results if r.get('status') == 200)
        failed = len(self.results) - successful
        avg_response = np.mean([
            r['response_time'] for r in self.results 
            if r.get('status') == 200
        ])
        
        return {
            'total_users': self.total_users,
            'successful_logins': successful,
            'failed_logins': failed,
            'success_rate': successful / self.total_users * 100,
            'average_response_time': avg_response,
            'total_test_time': total_time,
            'requests_per_second': self.total_users / total_time
        }

class AutoScalingStrategy:
    def __init__(self):
        self.metrics_history = []
        self.scaling_decisions = []
    
    def analyze_and_recommend(self, current_metrics):
        """メトリクスに基づくスケーリング推奨"""
        recommendations = []
        
        # CPU使用率ベース
        if current_metrics['cpu_usage'] > 80:
            recommendations.append({
                'type': 'scale_out',
                'reason': 'CPU使用率が80%を超過',
                'action': 'インスタンスを2台追加',
                'priority': 'high'
            })
        
        # レスポンスタイムベース
        if current_metrics['p95_response_time'] > 1000:  # 1秒
            recommendations.append({
                'type': 'optimize',
                'reason': 'レスポンスタイムが遅い',
                'action': 'キャッシュ層の追加',
                'priority': 'medium'
            })
        
        # エラー率ベース
        if current_metrics['error_rate'] > 0.01:  # 1%
            recommendations.append({
                'type': 'investigate',
                'reason': 'エラー率が高い',
                'action': 'ログ分析とデバッグ',
                'priority': 'high'
            })
        
        # 予測的スケーリング
        if self._predict_traffic_spike(current_metrics['timestamp']):
            recommendations.append({
                'type': 'pre_scale',
                'reason': '過去のパターンから負荷増大を予測',
                'action': '30分前にインスタンス追加',
                'priority': 'medium'
            })
        
        return recommendations

class SecurityIncidentDetector:
    def __init__(self):
        self.thresholds = {
            'failed_login_rate': 10,  # 5分間で10回
            'geo_velocity': 1000,     # km/h
            'concurrent_sessions': 5,  # 同時セッション数
            'unusual_hour_login': (0, 5)  # 深夜帯
        }
    
    async def analyze_login_attempt(self, event):
        """ログイン試行の分析"""
        user_id = event['user_id']
        
        # 1. ブルートフォース検知
        recent_failures = await self.get_recent_failures(user_id)
        if len(recent_failures) >= self.thresholds['failed_login_rate']:
            return {
                'risk_level': 'critical',
                'threat_type': 'brute_force',
                'action': 'block_and_notify',
                'details': f'{len(recent_failures)}回の失敗'
            }
        
        # 2. 地理的異常検知
        last_location = await self.get_last_login_location(user_id)
        if last_location:
            velocity = self.calculate_velocity(
                last_location, 
                event['location'],
                event['timestamp'] - last_location['timestamp']
            )
            
            if velocity > self.thresholds['geo_velocity']:
                return {
                    'risk_level': 'high',
                    'threat_type': 'impossible_travel',
                    'action': 'require_2fa',
                    'details': f'移動速度: {velocity}km/h'
                }
        
        # 3. 同時セッション検知
        active_sessions = await self.get_active_sessions(user_id)
        if len(active_sessions) >= self.thresholds['concurrent_sessions']:
            return {
                'risk_level': 'medium',
                'threat_type': 'concurrent_sessions',
                'action': 'notify_user',
                'details': f'{len(active_sessions)}個の同時セッション'
            }
        
        return {'risk_level': 'low', 'action': 'allow'}

class AuthForensicsAnalyzer:
    def __init__(self, log_sources):
        self.log_sources = log_sources
        
    async def analyze_user_activity(self, user_id, timeframe):
        """ユーザーアクティビティの詳細分析"""
        
        # すべてのログソースから情報収集
        auth_logs = await self.log_sources['auth'].query(user_id, timeframe)
        access_logs = await self.log_sources['access'].query(user_id, timeframe)
        audit_logs = await self.log_sources['audit'].query(user_id, timeframe)
        
        # タイムライン構築
        timeline = self.build_timeline(auth_logs, access_logs, audit_logs)
        
        # 異常パターンの検出
        anomalies = []
        
        # 1. 大量データアクセス
        data_access_volume = self.calculate_data_access_volume(access_logs)
        if data_access_volume > self.get_user_baseline(user_id) * 10:
            anomalies.append({
                'type': 'excessive_data_access',
                'severity': 'high',
                'volume': data_access_volume,
                'timeframe': self.identify_peak_period(access_logs)
            })
        
        # 2. 異常なアクセスパターン
        access_pattern = self.analyze_access_pattern(access_logs)
        if access_pattern['is_automated']:
            anomalies.append({
                'type': 'automated_access',
                'severity': 'critical',
                'indicators': access_pattern['indicators'],
                'confidence': access_pattern['confidence']
            })
        
        # 3. 権限昇格の痕跡
        privilege_changes = self.detect_privilege_escalation(audit_logs)
        if privilege_changes:
            anomalies.append({
                'type': 'privilege_escalation',
                'severity': 'critical',
                'changes': privilege_changes
            })
        
        return {
            'user_id': user_id,
            'timeframe': timeframe,
            'timeline': timeline,
            'anomalies': anomalies,
            'risk_score': self.calculate_risk_score(anomalies),
            'recommendations': self.generate_recommendations(anomalies)
        }
    
    def generate_forensics_report(self, analysis_results):
        """フォレンジックレポートの生成"""
        return {
            'executive_summary': self.create_executive_summary(analysis_results),
            'technical_details': {
                'timeline': analysis_results['timeline'],
                'anomalies': analysis_results['anomalies'],
                'evidence': self.collect_evidence(analysis_results)
            },
            'impact_assessment': self.assess_impact(analysis_results),
            'remediation_steps': self.recommend_remediation(analysis_results),
            'legal_considerations': self.identify_legal_requirements(analysis_results)
        }

class AuthDebugger:
    """認証デバッグ用ユーティリティ"""
    
    @staticmethod
    def decode_jwt_unsafe(token):
        """JWTをデコード（検証なし、デバッグ用のみ）"""
        try:
            parts = token.split('.')
            header = json.loads(base64.urlsafe_b64decode(parts[0] + '=='))
            payload = json.loads(base64.urlsafe_b64decode(parts[1] + '=='))
            
            return {
                'header': header,
                'payload': payload,
                'signature': parts[2],
                'expires_at': datetime.fromtimestamp(payload.get('exp', 0)),
                'issued_at': datetime.fromtimestamp(payload.get('iat', 0))
            }
        except Exception as e:
            return {'error': str(e)}
    
    @staticmethod
    def test_password_encoding(password):
        """パスワードエンコーディングのテスト"""
        encodings = {
            'utf-8': password.encode('utf-8'),
            'latin-1': password.encode('latin-1', errors='ignore'),
            'ascii': password.encode('ascii', errors='ignore')
        }
        
        results = {}
        for encoding, encoded in encodings.items():
            results[encoding] = {
                'bytes': encoded,
                'hex': encoded.hex(),
                'length': len(encoded)
            }
        
        return results
    
    @staticmethod
    def verify_system_time():
        """システム時刻の確認"""
        import ntplib
        
        try:
            ntp_client = ntplib.NTPClient()
            response = ntp_client.request('pool.ntp.org')
            
            local_time = time.time()
            ntp_time = response.tx_time
            diff = local_time - ntp_time
            
            return {
                'local_time': datetime.fromtimestamp(local_time),
                'ntp_time': datetime.fromtimestamp(ntp_time),
                'difference_seconds': diff,
                'synchronized': abs(diff) < 5
            }
        except Exception as e:
            return {'error': str(e)}