Аутентификация и авторизация в Laravel API с OAuth2 и Passport

// Пример реализации OAuth2 клиента в Laravel
$http = new GuzzleHttp\Client;
 
$response = $http->post('http://your-app.com/oauth/token', [
    'form_params' => [
        'grant_type' => 'password',
        'client_id' => 'client-id',
        'client_secret' => 'client-secret',
        'username' => 'taylor@laravel.com',
        'password' => 'my-password',
        'scope' => '',
    ],
]);
 
return json_decode((string) $response->getBody(), true)['access_token'];

namespace App\Models;
 
use Laravel\Passport\HasApiTokens;
use Illuminate\Notifications\Notifiable;
use Illuminate\Foundation\Auth\User as Authenticatable;
 
class User extends Authenticatable
{
    use HasApiTokens, Notifiable;
    // ...
}

// Пример потока авторизации в Laravel Passport
// 1. Клиент запрашивает доступ, пользователь перенаправляется
Route::get('/authorize', function (Request $request) {
    $authRequest = $request->user()->createOAuth2Request(
        $clientId, 
        $redirectUri,
        ['email', 'profile'] // запрашиваемые scopes
    );
    
    return view('oauth.authorize', ['authRequest' => $authRequest]);
});
 
// 2. После подтверждения генерируется код авторизации
Route::post('/authorize', function (Request $request) {
    $authCode = createAuthCode(
        $request->user()->id,
        $request->client_id,
        $request->redirect_uri,
        $request->scope
    );
    
    return redirect($request->redirect_uri . '?code=' . $authCode);
});
 
// 3. Клиент обменивает код на токены
// Это обычно происходит через POST запрос к /oauth/token

// Пример защиты маршрута с помощью Passport middleware
Route::middleware('auth:api')->get('/user', function (Request $request) {
    // Токен уже проверен, пользователь аутентифицирован
    return $request->user();
});

// Отзыв токенов в Laravel Passport
Route::post('/oauth/revoke', function (Request $request) {
    $token = $request->user()->token();
    $token->revoke();
    
    // Также можно отозвать все токены пользователя
    $request->user()->tokens->each(function ($token) {
        $token->revoke();
    });
    
    return response()->json(['message' => 'Tokens revoked']);
});

// Настройка времени жизни токенов в Passport
use Carbon\Carbon;
 
Passport::tokensExpireIn(Carbon::now()->addMinutes(30)); // access tokens
Passport::refreshTokensExpireIn(Carbon::now()->addDays(30)); // refresh tokens

// Пример работы с токенами через TokenRepository
$tokens = app(TokenRepository::class);
$tokens->forUser($userId)->where('client_id', $clientId)->get();
 
// Пример работы с клиентами через ClientRepository
$clients = app(ClientRepository::class);
$client = $clients->createPasswordGrantClient(
    null, 'My Password Grant Client', 'http://localhost'
);

$user = User::find(1);
$tokens = $user->tokens;  // Моментально получаем все токены пользователя

// Отслеживание создания токенов
Event::listen(AccessTokenCreated::class, function ($event) {
    LogService::logNewTokenIssued($event->userId, $event->clientId);
});

use Laravel\Passport\HasApiTokens;
 
class User extends Authenticatable
{
    use HasApiTokens, Notifiable;
    // остальной код модели...
}

public function boot()
{
    $this->registerPolicies();
    
    Passport::routes();
    
    // Дополнительно можно настроить срок жизни токенов
    Passport::tokensExpireIn(now()->addDays(15));
    Passport::refreshTokensExpireIn(now()->addDays(30));
}

'guards' => [
    'web' => [
        'driver' => 'session',
        'provider' => 'users',
    ],
    
    'api' => [
        'driver' => 'passport', // Было 'token'
        'provider' => 'users',
    ],
],

Passport::tokensCan([
    'place-orders' => 'Размещать заказы',
    'check-status' => 'Проверять статус заказов',
    'manage-account' => 'Управлять аккаунтом',
]);
 
// Устанавливаем скопы по умолчанию
Passport::setDefaultScope([
    'check-status',
    'manage-account',
]);

Passport::withCookieTransport(function ($request, $user, $token) {
    if ($request->ip() != $token->last_used_ip) {
        // Подозрительная активность, отклоняем токен
        return false;
    }
    
    return true;
});

PASSPORT_PRIVATE_KEY="-----BEGIN RSA PRIVATE KEY-----\nYour-Private-Key\n-----END RSA PRIVATE KEY-----"
PASSPORT_PUBLIC_KEY="-----BEGIN PUBLIC KEY-----\nYour-Public-Key\n-----END PUBLIC KEY-----"

// В сервис-провайдере
public function register()
{
    $this->app->singleton(TokenRepository::class, function ($app) {
        return new CachedTokenRepository(
            $app->make(TokenRepository::class),
            $app->make(Cache::class)
        );
    });
}

Route::post('/login', function (Request $request) {
    $http = new GuzzleHttp\Client;
    
    try {
        $response = $http->post(config('app.url').'/oauth/token', [
            'form_params' => [
                'grant_type' => 'password',
                'client_id' => config('passport.password_client_id'),
                'client_secret' => config('passport.password_client_secret'),
                'username' => $request->email,
                'password' => $request->password,
                'scope' => '',
            ],
        ]);
        
        return json_decode((string) $response->getBody(), true);
    } catch (\GuzzleHttp\Exception\ClientException $e) {
        return response()->json([
            'message' => 'Неверные учетные данные'
        ], 401);
    }
});

$response = $http->post(config('app.url').'/oauth/token', [
    'form_params' => [
        'grant_type' => 'client_credentials',
        'client_id' => $clientId,
        'client_secret' => $clientSecret,
        'scope' => 'view-payments process-reports',
    ],
]);

// Шаг 1: Перенаправление на страницу авторизации
Route::get('/oauth/redirect', function () {
    $query = http_build_query([
        'client_id' => config('passport.client_id'),
        'redirect_uri' => url('/oauth/callback'),
        'response_type' => 'code',
        'scope' => 'view-profile edit-profile',
    ]);
 
    return redirect(url('/oauth/authorize?'.$query));
});
 
// Шаг 2: Обмен кода на токен
Route::get('/oauth/callback', function (Request $request) {
    $http = new GuzzleHttp\Client;
 
    $response = $http->post(url('/oauth/token'), [
        'form_params' => [
            'grant_type' => 'authorization_code',
            'client_id' => config('passport.client_id'),
            'client_secret' => config('passport.client_secret'),
            'redirect_uri' => url('/oauth/callback'),
            'code' => $request->code,
        ],
    ]);
 
    $tokenData = json_decode((string) $response->getBody(), true);
    
    // Сохраняем токен в сессии, куках или возвращаем клиенту
    return $tokenData;
});

// После стандартной аутентификации
if ($user->hasTwoFactorEnabled()) {
    // Генерируем временный токен с ограниченными правами
    $tempToken = $user->createToken('2fa-pending', ['2fa-pending'])->accessToken;
    
    // Отправляем код подтверждения
    $user->sendTwoFactorCode();
    
    return response()->json([
        'requires_2fa' => true,
        'temp_token' => $tempToken
    ]);
}

// Генерация state перед перенаправлением
$state = Str::random(40);
session(['oauth2_state' => $state]);
 
$query = http_build_query([
    'client_id' => config('passport.client_id'),
    'redirect_uri' => url('/oauth/callback'),
    'response_type' => 'code',
    'scope' => 'profile',
    'state' => $state // Защита от CSRF
]);
 
return redirect(url('/oauth/authorize?'.$query));

Route::get('/oauth/callback', function (Request $request) {
    // Проверка state для защиты от CSRF
    if ($request->state !== session('oauth2_state')) {
        abort(403, 'Недопустимое состояние');
    }
    
    // Обмен кода на токен...
});

$response = $http->post('/oauth/token', [
'form_params' => [
    'grant_type' => 'password',
    'client_id' => $clientId,
    'client_secret' => $clientSecret,
    'username' => 'email@example.com',
    'password' => 'password',
    'scope' => '',
],
]);
 
$responseData = json_decode((string) $response->getBody(), true);
// $responseData содержит access_token и refresh_token

$response = $http->post('/oauth/token', [
'form_params' => [
    'grant_type' => 'refresh_token',
    'refresh_token' => $refreshToken,
    'client_id' => $clientId,
    'client_secret' => $clientSecret,
    'scope' => '',
],
]);

// Кастомный обработчик обновления токенов
Route::post('/token/refresh', function (Request $request) {
    // Валидация refresh токена
    $validator = Validator::make($request->all(), [
        'refresh_token' => 'required|string'
    ]);
    
    if ($validator->fails()) {
        return response()->json(['error' => 'Invalid refresh token'], 400);
    }
    
    try {
        // Делаем запрос к стандартному endpoint Passport
        $response = app(Client::class)->post(url('/oauth/token'), [
            'form_params' => [
                'grant_type' => 'refresh_token',
                'refresh_token' => $request->refresh_token,
                'client_id' => config('services.passport.client_id'),
                'client_secret' => config('services.passport.client_secret'),
                'scope' => '',
            ],
        ]);
        
        // Отзываем старый refresh токен для безопасности
        // Это требует дополнительной логики в базе
        $this->revokeOldRefreshToken($request->refresh_token);
        
        return json_decode((string) $response->getBody(), true);
    } catch (\Exception $e) {
        return response()->json(['error' => 'Invalid refresh token'], 401);
    }
});

// В обработчике смены пароля
public function changePassword(Request $request)
{
    // Валидация, обновление пароля...
    
    // Отзываем все токены пользователя
    $request->user()->tokens->each(function ($token) {
        $token->revoke();
    });
    
    return response()->json(['message' => 'Пароль изменён, все сеансы завершены']);
}

// В кастомном middleware
public function handle($request, Closure $next)
{
    $user = $request->user();
    
    if ($user && $user->is_banned) {
        // Отзываем токен текущего запроса
        $request->user()->token()->revoke();
        
        return response()->json([
            'error' => 'Ваш аккаунт заблокирован'
        ], 403);
    }
    
    return $next($request);
}

// При аутентификации
$token = $user->createToken('Mobile App', ['*'], [
    'device_id' => $request->header('X-Device-ID')
])->accessToken;
 
// При логауте с конкретного устройства
Route::post('/logout-device', function (Request $request) {
    $deviceId = $request->device_id;
    
    $request->user()->tokens()
        ->where('name', 'Mobile App')
        ->where('device_id', $deviceId)
        ->get()
        ->each(function ($token) {
            $token->revoke();
        });
    
    return response()->json(['message' => 'Устройство отключено']);
});

// Проверка иерархических прав доступа
class CompanyAccessGate
{
    public function handle($request, $next, $actions)
    {
        $user = $request->user();
        $companyId = $request->route('company');
        
        if (!$this->userHasCompanyAccess($user, $companyId, $actions)) {
            return response()->json(['error' => 'Недостаточно прав'], 403);
        }
        
        return $next($request);
    }
    
    protected function userHasCompanyAccess($user, $companyId, $actions)
    {
        $membership = $user->companyMemberships()->where('company_id', $companyId)->first();
        
        if (!$membership) {
            return false;
        }
        
        return $membership->role->hasPermissions($actions);
    }
}

// При создании токена
$token = $user->createToken('API Token', ['*'], [
  'profile' => [
    'name' => $user->name,
    'role' => $user->role,
    'settings' => $user->settings->only(['language', 'timezone'])
  ]
])->accessToken;

Schema::table('oauth_access_tokens', function (Blueprint $table) {
    $table->string('user_agent')->nullable();
    $table->string('ip_address')->nullable();
    $table->string('geolocation')->nullable();
    $table->json('usage_stats')->nullable();
});

Event::listen(AccessTokenCreated::class, function ($event) {
    $request = request();
    $token = Passport::token()->find($event->tokenId);
    
    if ($token) {
        $token->user_agent = $request->header('User-Agent');
        $token->ip_address = $request->ip();
        $token->geolocation = optional(
            geoip()->getLocation($request->ip())
        )->toArray();
        $token->save();
    }
});

class ApiAuditMiddleware
{
    public function handle($request, Closure $next)
    {
        $response = $next($request);
        
        // Логируем только после успешного ответа
        if ($response->getStatusCode() < 500) {
            $this->logApiRequest($request, $response);
        }
        
        return $response;
    }
    
    protected function logApiRequest($request, $response)
    {
        try {
            ApiRequestLog::create([
                'token_id' => optional($request->user('api'))->token()->id,
                'user_id' => optional($request->user('api'))->id,
                'path' => $request->path(),
                'method' => $request->method(),
                'ip_address' => $request->ip(),
                'user_agent' => $request->header('User-Agent'),
                'request_data' => $this->sanitizeData($request->all()),
                'response_code' => $response->getStatusCode(),
                'response_data' => $this->sanitizeData(
                    json_decode($response->getContent(), true)
                ),
                'execution_time' => microtime(true) - LARAVEL_START,
            ]);
        } catch (\Exception $e) {
            Log::error('Failed to log API request: ' . $e->getMessage());
        }
    }
    
    protected function sanitizeData($data)
    {
        // Удаляем конфиденциальные поля перед логированием
        if (is_array($data)) {
            foreach (['password', 'token', 'credit_card', 'secret'] as $field) {
                if (isset($data[$field])) {
                    $data[$field] = '*[B]REDACTED[/B]*';
                }
            }
        }
        
        return $data;
    }
}

// В планировщике задач
$schedule->call(function () {
    // Поиск токенов, используемых с нескольких IP
    $multiIpTokens = ApiRequestLog::selectRaw('token_id, COUNT(DISTINCT ip_address) as ip_count')
        ->where('created_at', '>=', now()->subHours(1))
        ->groupBy('token_id')
        ->having('ip_count', '>', 3)
        ->get();
    
    if ($multiIpTokens->isNotEmpty()) {
        // Отправляем уведомление командам безопасности
        SecurityAlert::dispatch(
            'Multiple IP usage detected',
            $multiIpTokens->pluck('token_id')->toArray()
        );
    }
    
    // Другие проверки...
})->hourly();

// Middleware для защиты критических операций
class RiskBasedSecurityMiddleware
{
    public function handle($request, Closure $next)
    {
        $user = $request->user();
        $riskScore = $this->calculateRiskScore($request);
        
        if ($riskScore > 80) {
            // Критически высокий риск — требуем повторную аутентификацию
            return response()->json([
                'message' => 'Для выполнения этой операции требуется повторная аутентификация',
                'action_required' => 'reauthenticate'
            ], 403);
        } elseif ($riskScore > 50) {
            // Средний риск — проверяем дополнительные факторы
            if (!$this->verifyAdditionalFactors($user, $request)) {
                return response()->json([
                    'message' => 'Требуется дополнительное подтверждение',
                    'action_required' => 'verify_additional_factors'
                ], 403);
            }
        }
        
        return $next($request);
    }
    
    protected function calculateRiskScore($request)
    {
        $score = 0;
        $user = $request->user();
        $token = $user->token();
        
        // Факторы увеличения риска
        if ($request->ip() !== $token->ip_address) {
            $score += 30; // Смена IP
        }
        
        if (!$this->isKnownDevice($request, $user)) {
            $score += 25; // Новое устройство
        }
        
        if ($this->isUnusualTime($user)) {
            $score += 10; // Необычное время активности
        }
        
        if ($this->isSensitiveOperation($request)) {
            $score += 30; // Чувствительная операция
        }
        
        return $score;
    }
    
    // Другие методы...
}

class CachedTokenRepository implements TokenRepositoryInterface
{
    protected $repository;
    protected $cache;
    protected $expires;
    
    public function __construct(
        TokenRepositoryInterface $repository,
        Repository $cache,
        $expires = 60
    ) {
        $this->repository = $repository;
        $this->cache = $cache;
        $this->expires = $expires;
    }
    
    public function find($id)
    {
        return $this->cache->remember(
            "oauth_token_{$id}",
            $this->expires,
            function () use ($id) {
                return $this->repository->find($id);
            }
        );
    }
    
    // Реализация остальных методов интерфейса...
}

$this->app->singleton(TokenRepositoryInterface::class, function ($app) {
    return new CachedTokenRepository(
        $app->make(TokenRepository::class),
        $app->make(Repository::class),
        config('passport.token_cache_ttl', 60)
    );
});

// Кастомный Guard для JWT-токенов
class JwtGuard implements Guard
{
    protected $request;
    protected $provider;
    protected $jwtManager;
    
    public function __construct(
        Request $request,
        UserProvider $provider,
        JwtManager $jwtManager
    ) {
        $this->request = $request;
        $this->provider = $provider;
        $this->jwtManager = $jwtManager;
    }
    
    public function user()
    {
        if ($this->user) {
            return $this->user;
        }
        
        $token = $this->getTokenFromRequest();
        
        if (!$token) {
            return null;
        }
        
        try {
            $payload = $this->jwtManager->decode($token);
            
            // Валидация без запроса к БД
            if ($payload['exp'] < time()) {
                return null;
            }
            
            // Получаем пользователя только по ID
            $this->user = $this->provider->retrieveById($payload['sub']);
            
            return $this->user;
        } catch (\Exception $e) {
            return null;
        }
    }
    
    // Другие методы Guard...
}

class BlacklistJwtGuard extends JwtGuard
{
    protected $blacklist;
    
    public function __construct(
        Request $request,
        UserProvider $provider,
        JwtManager $jwtManager,
        TokenBlacklist $blacklist
    ) {
        parent::__construct($request, $provider, $jwtManager);
        $this->blacklist = $blacklist;
    }
    
    public function user()
    {
        if ($this->user) {
            return $this->user;
        }
        
        $token = $this->getTokenFromRequest();
        
        if (!$token) {
            return null;
        }
        
        try {
            $payload = $this->jwtManager->decode($token);
            
            // Проверка на отозванность
            if ($this->blacklist->has($payload['jti'])) {
                return null;
            }
            
            // Остальные проверки...
            
        } catch (\Exception $e) {
            return null;
        }
    }
}

class ScopeRepository extends \Laravel\Passport\Bridge\ScopeRepository
{
    protected $cache;
    
    public function __construct(\Laravel\Passport\Bridge\ScopeRepository $repository, Repository $cache)
    {
        // Наследуем базовое поведение
        parent::__construct();
        $this->cache = $cache;
    }
    
    public function finalizeScopes(
        array $scopes,
        $grantType,
        \League\OAuth2\Server\Entities\ClientEntityInterface $clientEntity,
        $userIdentifier = null
    ) {
        // Используем кэш для частых комбинаций скоупов
        $cacheKey = "oauth_scopes_{$grantType}_{$clientEntity->getIdentifier()}_{$userIdentifier}";
        
        return $this->cache->remember($cacheKey, 60, function () use ($scopes, $grantType, $clientEntity, $userIdentifier) {
            return parent::finalizeScopes($scopes, $grantType, $clientEntity, $userIdentifier);
        });
    }
}

class DynamicThrottleMiddleware
{
    protected $limiter;
    
    public function __construct(RateLimiter $limiter)
    {
        $this->limiter = $limiter;
    }
    
    public function handle($request, Closure $next, $maxAttempts = 60, $decayMinutes = 1)
    {
        $user = $request->user();
        
        // Динамически определяем лимиты в зависимости от клиента
        if ($user) {
            $client = $user->token()->client;
            
            if ($client->high_rate_limit) {
                $maxAttempts = 1000;
                $decayMinutes = 1;
            } elseif ($client->is_internal) {
                // Внутренние сервисы могут делать больше запросов
                $maxAttempts = 3000;
                $decayMinutes = 1;
            }
        }
        
        // Стандартная логика throttle
        // ...
        
        return $next($request);
    }
}

class UserCacheMiddleware
{
    public function handle($request, Closure $next)
    {
        $response = $next($request);
        
        if ($request->isMethod('GET') && $user = $request->user()) {
            // Добавляем заголовки для CDN или Proxy
            $response->header('Cache-Control', 'private, max-age=60');
            $response->header('X-User-ID', $user->id);
            
            // Для корректной работы с Varnish или другими CDN
            $response->header('Vary', 'Authorization');
        }
        
        return $response;
    }
}

# В .gitignore
/storage/*.key

// В config/passport.php
'keys' => [
    'private' => env('PASSPORT_PRIVATE_KEY'),
    'public' => env('PASSPORT_PUBLIC_KEY'),
],

// Пример для AWS Secrets Manager
public function register()
{
    $this->app->booted(function () {
        if (config('app.env') === 'production') {
            $secretsManager = new \Aws\SecretsManager\SecretsManagerClient([
                'version' => 'latest',
                'region' => env('AWS_DEFAULT_REGION'),
            ]);
            
            try {
                $result = $secretsManager->getSecretValue([
                    'SecretId' => 'passport/keys',
                ]);
                
                $secret = json_decode($result['SecretString'], true);
                
                config([
                    'passport.keys.private' => $secret['private_key'],
                    'passport.keys.public' => $secret['public_key'],
                ]);
            } catch (\Exception $e) {
                report($e);
            }
        }
    });
}

// Команда для ротации секретов клиентов
public function handle()
{
    $clients = Client::where('password_client', true)
        ->where('updated_at', '<', now()->subDays(90))
        ->get();
    
    foreach ($clients as $client) {
        $this->rotateClientSecret($client);
    }
}
 
protected function rotateClientSecret(Client $client)
{
    $newSecret = Str::random(40);
    
    // Храним старый секрет на период перехода
    $oldSecret = $client->secret;
    $client->old_secret = password_hash($oldSecret, PASSWORD_BCRYPT);
    $client->old_secret_expires_at = now()->addDays(7);
    
    // Устанавливаем новый секрет
    $client->secret = password_hash($newSecret, PASSWORD_BCRYPT);
    $client->save();
    
    // Уведомляем владельцев клиента
    ClientSecretRotated::dispatch($client, $newSecret);
}

// Переопределение метода validateClient в ClientRepository
public function validateClient($clientId, $clientSecret, $grantType)
{
    $client = $this->findActive($clientId);
    
    if (!$client) {
        return false;
    }
    
    // Проверяем текущий секрет
    if (hash_equals($client->secret, $clientSecret) || 
        password_verify($clientSecret, $client->secret)) {
        return true;
    }
    
    // Проверяем старый секрет, если он ещё действителен
    if ($client->old_secret && $client->old_secret_expires_at > now()) {
        if (hash_equals($client->old_secret, $clientSecret) || 
            password_verify($clientSecret, $client->old_secret)) {
            return true;
        }
    }
    
    return false;
}

// Пример использования AWS KMS для подписи токенов
class KmsTokenSigner implements TokenSignerInterface
{
    protected $kmsClient;
    protected $keyId;
    
    public function __construct($keyId)
    {
        $this->kmsClient = new \Aws\Kms\KmsClient([
            'version' => 'latest',
            'region' => env('AWS_DEFAULT_REGION'),
        ]);
        
        $this->keyId = $keyId;
    }
    
    public function sign($payload)
    {
        $result = $this->kmsClient->sign([
            'KeyId' => $this->keyId,
            'Message' => $payload,
            'MessageType' => 'RAW',
            'SigningAlgorithm' => 'RSASSA_PKCS1_V1_5_SHA_256',
        ]);
        
        return $result['Signature'];
    }
}