Skip to content

A free open source IT asset/license management system

Fixed FD-56236 - 2FA guard on API

snipe0969ccb38756
diff --git a/app/Http/Controllers/Api/ProfileController.php b/app/Http/Controllers/Api/ProfileController.php
index c261f5cf2a..cf54d32e93 100644
--- a/app/Http/Controllers/Api/ProfileController.php
+++ b/app/Http/Controllers/Api/ProfileController.php
@@ -4,6 +4,7 @@ namespace App\Http\Controllers\Api;
use App\Helpers\Helper;
use App\Http\Controllers\Controller;
+use App\Http\Middleware\CheckForTwoFactor;
use App\Http\Transformers\ActionlogsTransformer;
use App\Http\Transformers\ProfileTransformer;
use App\Models\CheckoutRequest;
@@ -102,6 +103,13 @@ class ProfileController extends Controller
abort(403);
}
+ // Refuse to issue tokens for a session that hasn't cleared 2FA, even
+ // if it picked up a Passport cookie elsewhere. Closes the bypass
+ // chain "password → /two-factor cookie → mint token → use forever".
+ if (! CheckForTwoFactor::isComplete($request)) {
+ abort(403, trans('auth/message.two_factor.enter_two_factor_code'));
+ }
+
$accessTokenName = $request->input('name', 'Auth Token');
if ($accessToken = auth()->user()->createToken($accessTokenName)->accessToken) {
@@ -133,6 +141,10 @@ class ProfileController extends Controller
abort(403);
}
+ if (! CheckForTwoFactor::isComplete(request())) {
+ abort(403, trans('auth/message.two_factor.enter_two_factor_code'));
+ }
+
$token = $this->tokenRepository->findForUser(
$tokenId, auth()->user()->getAuthIdentifier()
);
@@ -161,6 +173,10 @@ class ProfileController extends Controller
abort(403);
}
+ if (! CheckForTwoFactor::isComplete(request())) {
+ abort(403, trans('auth/message.two_factor.enter_two_factor_code'));
+ }
+
$tokens = $this->tokenRepository->forUser(auth()->user()->getAuthIdentifier());
$token_values = $tokens->load('client')->filter(function ($token) {
return $token->client->personal_access_client && ! $token->revoked;
diff --git a/app/Http/Kernel.php b/app/Http/Kernel.php
index ed573b3bfd..e9787ae56c 100644
--- a/app/Http/Kernel.php
+++ b/app/Http/Kernel.php
@@ -11,6 +11,7 @@ use App\Http\Middleware\CheckPermissions;
use App\Http\Middleware\CheckUserIsActivated;
use App\Http\Middleware\EncryptCookies;
use App\Http\Middleware\EnforceApiUserAgent;
+use App\Http\Middleware\IssueFreshApiTokenIfTwoFactorComplete;
use App\Http\Middleware\LogAuthedUserHeader;
use App\Http\Middleware\NoSessionStore;
use App\Http\Middleware\PreventBackHistory;
@@ -34,7 +35,6 @@ use Illuminate\Routing\Middleware\ThrottleRequests;
use Illuminate\Session\Middleware\AuthenticateSession;
use Illuminate\Session\Middleware\StartSession;
use Illuminate\View\Middleware\ShareErrorsFromSession;
-use Laravel\Passport\Http\Middleware\CreateFreshApiToken;
class Kernel extends HttpKernel
{
@@ -74,7 +74,7 @@ class Kernel extends HttpKernel
CheckLocale::class,
CheckUserIsActivated::class,
CheckForTwoFactor::class,
- CreateFreshApiToken::class,
+ IssueFreshApiTokenIfTwoFactorComplete::class,
CheckColorSettings::class,
AuthenticateSession::class,
SubstituteBindings::class,
diff --git a/app/Http/Middleware/CheckForTwoFactor.php b/app/Http/Middleware/CheckForTwoFactor.php
index 0a8ead6ebb..028550d86b 100644
--- a/app/Http/Middleware/CheckForTwoFactor.php
+++ b/app/Http/Middleware/CheckForTwoFactor.php
@@ -14,6 +14,39 @@ class CheckForTwoFactor
*/
public const IGNORE_ROUTES = ['two-factor', 'two-factor-enroll', 'setup', 'logout'];
+ /**
+ * Whether the *session* attached to this request has cleared 2FA — i.e.
+ * the user is allowed to act beyond the password+2FA-prompt screens.
+ *
+ * Sharing this check lets other middleware (the Passport cookie issuer)
+ * and the API-token endpoints refuse to mint or expose tokens for a
+ * password-only session that never entered a 2FA code. Without it a
+ * session that landed on /two-factor (which is in IGNORE_ROUTES) could
+ * pick up the Passport cookie, hit POST /api/v1/account/personal-access-
+ * tokens and walk away with a long-lived bearer token.
+ */
+ public static function isComplete(Request $request): bool
+ {
+ if (! Auth::check()) {
+ return true;
+ }
+
+ $settings = Setting::getSettings();
+ if (! $settings || $settings->two_factor_enabled == '') {
+ return true;
+ }
+
+ // 2FA is optional and this user has not opted in.
+ if ($settings->two_factor_enabled == '1' && auth()->user()->two_factor_optin != '1') {
+ return true;
+ }
+
+ // 2FA required (or opted in): session must carry the authed marker
+ // set by Auth\TwoFactorAuthController after a valid code is entered.
+ return $request->hasSession()
+ && $request->session()->get('2fa_authed') == auth()->id();
+ }
+
/**
* Handle an incoming request.
*
diff --git a/app/Http/Middleware/IssueFreshApiTokenIfTwoFactorComplete.php b/app/Http/Middleware/IssueFreshApiTokenIfTwoFactorComplete.php
new file mode 100644
index 0000000000..9ae4dcb157
--- /dev/null
+++ b/app/Http/Middleware/IssueFreshApiTokenIfTwoFactorComplete.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use Closure;
+use Laravel\Passport\Http\Middleware\CreateFreshApiToken;
+
+/**
+ * Wrapper around Laravel Passport's CreateFreshApiToken that refuses to
+ * mint the `snipeit_passport_token` cookie for a session that hasn't
+ * cleared 2FA. Without this, a password-only session that landed on
+ * /two-factor (in CheckForTwoFactor::IGNORE_ROUTES) would still get the
+ * cookie issued by the web middleware group, giving it session-based
+ * access to the API and the personal-access-token endpoints.
+ *
+ * See CheckForTwoFactor::isComplete() for the actual rule.
+ */
+class IssueFreshApiTokenIfTwoFactorComplete extends CreateFreshApiToken
+{
+ public function handle($request, Closure $next, $guard = null)
+ {
+ if (! CheckForTwoFactor::isComplete($request)) {
+ // Skip the cookie issuance entirely; the rest of the pipeline runs
+ // as if Passport's middleware weren't installed for this request.
+ return $next($request);
+ }
+
+ return parent::handle($request, $next, $guard);
+ }
+}
diff --git a/tests/Feature/Authentication/PersonalAccessTokenTwoFactorGuardTest.php b/tests/Feature/Authentication/PersonalAccessTokenTwoFactorGuardTest.php
new file mode 100644
index 0000000000..9d0e4c7625
--- /dev/null
+++ b/tests/Feature/Authentication/PersonalAccessTokenTwoFactorGuardTest.php
@@ -0,0 +1,117 @@
+<?php
+
+namespace Tests\Feature\Authentication;
+
+use App\Models\User;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+/**
+ * Regression: a password-only session that lands on /two-factor (exempt from
+ * CheckForTwoFactor) used to pick up the Passport `snipeit_passport_token`
+ * cookie and then mint a persistent personal-access-token via the API
+ * group, fully bypassing the second factor. ProfileController endpoints
+ * now refuse when the session hasn't cleared 2FA, and the wrapper
+ * IssueFreshApiTokenIfTwoFactorComplete refuses to issue the Passport
+ * cookie in the same state.
+ */
+class PersonalAccessTokenTwoFactorGuardTest extends TestCase
+{
+ private function seedPassportPersonalAccessClient(): void
+ {
+ // Passport's personal-access-token flow requires a personal access
+ // client to exist. The migration that ships with this app doesn't
+ // seed one for tests, so create + register it before each test that
+ // calls Passport::createToken (the happy-path cases).
+ $clientId = DB::table('oauth_clients')->insertGetId([
+ 'user_id' => null,
+ 'name' => 'Test Personal Client',
+ 'secret' => 'secret',
+ 'redirect' => 'http://localhost/callback',
+ 'personal_access_client' => 1,
+ 'password_client' => 0,
+ 'revoked' => 0,
+ 'created_at' => now(),
+ 'updated_at' => now(),
+ ]);
+
+ DB::table('oauth_personal_access_clients')->insert([
+ 'client_id' => $clientId,
+ 'created_at' => now(),
+ 'updated_at' => now(),
+ ]);
+ }
+
+ public function test_cannot_create_personal_access_token_before_completing_two_factor()
+ {
+ $this->settings->set(['two_factor_enabled' => '2']); // required for everyone
+ $user = User::factory()->state(fn () => ['permissions' => json_encode(['self.api' => '1'])])->create([
+ 'two_factor_optin' => '1',
+ 'two_factor_enrolled' => '1',
+ 'two_factor_secret' => 'TESTSECRET',
+ ]);
+
+ // actingAs sets auth() but does NOT mark the session as 2FA-cleared.
+ $this->actingAs($user, 'api')
+ ->postJson(route('api.personal-access-token.create'), ['name' => 'poc'])
+ ->assertForbidden();
+
+ $this->assertDatabaseMissing('oauth_access_tokens', ['name' => 'poc']);
+ }
+
+ public function test_cannot_list_personal_access_tokens_before_completing_two_factor()
+ {
+ $this->settings->set(['two_factor_enabled' => '2']);
+ $user = User::factory()->state(fn () => ['permissions' => json_encode(['self.api' => '1'])])->create([
+ 'two_factor_optin' => '1',
+ 'two_factor_enrolled' => '1',
+ 'two_factor_secret' => 'TESTSECRET',
+ ]);
+
+ $this->actingAs($user, 'api')
+ ->getJson(route('api.personal-access-token.index'))
+ ->assertForbidden();
+ }
+
+ public function test_can_create_personal_access_token_after_completing_two_factor()
+ {
+ $this->seedPassportPersonalAccessClient();
+ $this->settings->set(['two_factor_enabled' => '2']);
+ $user = User::factory()->state(fn () => ['permissions' => json_encode(['self.api' => '1'])])->create([
+ 'two_factor_optin' => '1',
+ 'two_factor_enrolled' => '1',
+ 'two_factor_secret' => 'TESTSECRET',
+ ]);
+
+ $this->actingAs($user, 'api')
+ // simulate the post-code state the TwoFactorAuthController sets
+ ->withSession(['2fa_authed' => $user->id])
+ ->postJson(route('api.personal-access-token.create'), ['name' => 'valid'])
+ ->assertOk();
+ }
+
+ public function test_can_create_personal_access_token_when_two_factor_is_disabled()
+ {
+ // Setting "two_factor_enabled" empty == disabled globally; the guard
+ // returns true so existing installs without 2FA are unaffected.
+ $this->seedPassportPersonalAccessClient();
+ $this->settings->set(['two_factor_enabled' => '']);
+ $user = User::factory()->state(fn () => ['permissions' => json_encode(['self.api' => '1'])])->create();
+
+ $this->actingAs($user, 'api')
+ ->postJson(route('api.personal-access-token.create'), ['name' => 'no2fa'])
+ ->assertOk();
+ }
+
+ public function test_optional_two_factor_user_not_opted_in_can_still_create_token()
+ {
+ // 2FA optional, user hasn't opted in — they shouldn't be blocked.
+ $this->seedPassportPersonalAccessClient();
+ $this->settings->set(['two_factor_enabled' => '1']);
+ $user = User::factory()->state(fn () => ['permissions' => json_encode(['self.api' => '1'])])->create(['two_factor_optin' => '0']);
+
+ $this->actingAs($user, 'api')
+ ->postJson(route('api.personal-access-token.create'), ['name' => 'optout'])
+ ->assertOk();
+ }
+}