vincbeck commented on code in PR #70707:
URL: https://github.com/apache/airflow/pull/70707#discussion_r4615745601
##########
providers/keycloak/src/airflow/providers/keycloak/auth_manager/middleware.py:
##########
@@ -52,263 +59,235 @@ def get_cookie_path() -> str:
return "/"
-# The core route that revokes the Airflow JWT sent with the request, relative
to the root path.
-LOGOUT_PATH = "/api/v2/auth/logout"
+if AIRFLOW_V_3_4_PLUS:
+ from airflow.api_fastapi.auth.middlewares.refresh_token import
UNAUTHENTICATED_PATHS
+else:
+ # Unauthenticated endpoints that never read the user, so resolving it
there would only cost a
+ # JWT decode and a revocation lookup on every health check and UI boot.
+ UNAUTHENTICATED_PATHS = frozenset(["/api/v2/monitor/health",
"/api/v2/version"])
if TYPE_CHECKING:
- from fastapi import Request, Response
+ from starlette.types import ASGIApp, Message, Receive, Scope, Send
- from airflow.providers.keycloak.auth_manager.keycloak_auth_manager import
KeycloakAuthManager
+ from airflow.api_fastapi.auth.managers.models.base_user import BaseUser
from airflow.providers.keycloak.auth_manager.user import
KeycloakAuthManagerUser
+if AIRFLOW_V_3_4_1_PLUS:
+ from airflow.api_fastapi.app import request_cookie_is_secure
+ from airflow.api_fastapi.auth.middlewares.refresh_token import
JWTRefreshMiddleware # pyright: ignore[reportAssignmentType]
+else:
-class KeycloakJWTMiddleware(BaseHTTPMiddleware):
- """
- Attach the Keycloak JWT tokens to the user.
+ def request_cookie_is_secure(request: Request) -> bool:
+ return request.base_url.scheme == "https" or bool(conf.get("api",
"ssl_cert", fallback=""))
- Gets the Keycloak JWT tokens from the request cookies
- and attaches them to the user. If the token is expired,
- attempt to refresh it using the refresh token.
- """
+ class JWTRefreshMiddleware(metaclass=ABCMeta):
+ """Backport of JWTRefreshMiddleware."""
- async def dispatch(self, request: Request, call_next):
- user = None
- new_token = None
- new_user = None
- session_invalidated = False
- try:
- try:
- new_user, current_user = await self._refresh_user(request)
- user = new_user or current_user
- except (
- AuthManagerRefreshTokenExpiredException,
- HTTPException,
- ):
- new_token = ""
- # The session ends here and the response clears the Airflow
JWT. Hide it
- # from the inner middlewares and the route too: resolving it
again without
- # the Keycloak tokens yields no user, which ``get_user`` would
hand to the
- # authorization checks instead of answering 401. The logout
route needs no
- # user and revokes the JWT it receives, so it keeps it.
- if not self._is_logout(request):
- self._drop_cookie(request, COOKIE_NAME_JWT_TOKEN)
-
- if user is not None:
- request.state.user = user
-
- user_injected = getattr(
- core_api_security,
- "USER_INJECTED_BY_TRUSTED_MIDDLEWARE",
- None,
- )
- if user_injected is not None:
- request.state.user_authenticated_via = user_injected
+ def __init__(self, app: ASGIApp, skip_path_prefixes: tuple[str, ...] =
()) -> None:
+ self.app = app
+ self.skip_path_prefixes = skip_path_prefixes
- response = await call_next(request)
+ async def __call__(self, scope: Scope, receive: Receive, send: Send)
-> None:
+ if scope["type"] != "http" or self._is_skipped(scope):
+ await self.app(scope, receive, send)
+ return
- if new_token == "" and getattr(request.state, "jwt_token_issued",
False):
- new_token = None
+ request = Request(scope)
+ current_token = request.cookies.get(COOKIE_NAME_JWT_TOKEN)
+ if current_token is None:
+ await self.app(scope, receive, send)
+ return
- if new_user and not await self._is_jwt_still_valid(request):
- # The Airflow JWT sent with the request was invalidated while
the request was
- # handled (e.g. by the logout route). Do not replace it with a
freshly signed
- # one -- that would keep the session alive -- and clear the
session cookies.
- new_user = None
+ new_user = None
+ session_invalidated = False
+ try:
+ new_user, current_user = await self.refresh_user(request)
+ if user := (new_user or current_user):
+ # Stamp the trust sentinel alongside the user so
`get_user()`
+ # can distinguish this trusted assignment from a stray
write
+ # by unrelated middleware.
+ request.state.user = user
+ request.state.user_authenticated_via = getattr(
+ core_api_security,
+ "USER_INJECTED_BY_TRUSTED_MIDDLEWARE",
+ None,
+ )
+ except (HTTPException, AuthManagerRefreshTokenExpiredException):
+ # Receive a HTTPException when the Airflow token is expired
+ # Receive a AuthManagerRefreshTokenExpiredException when the
potential underlying refresh
+ # token used by the auth manager is expired
session_invalidated = True
- if new_user or new_token is not None or session_invalidated:
- secure = request.base_url.scheme == "https" or
bool(conf.get("api", "ssl_cert", fallback=""))
- cookie_path = get_cookie_path()
- if new_token == "":
- response.set_cookie(
- COOKIE_NAME_JWT_TOKEN,
- new_token,
- path=cookie_path,
- httponly=True,
- secure=secure,
- samesite="lax",
- max_age=0,
+ if session_invalidated or new_user is not None:
+ extra_cookies = self.get_extra_cookies(request, new_user)
+ token_cookie, cleanup_cookies = self.build_cookie_headers(
+ request, await self.generate_new_user_token(request,
new_user), extra_cookies
+ )
+ else:
+ token_cookie, cleanup_cookies = (None, [])
+ response_started = False
+
+ async def send_with_cookies(message: Message) -> None:
+ nonlocal response_started
+ if message["type"] == "http.response.start":
+ response_started = True
+ headers = MutableHeaders(scope=message)
+ route_cookies = headers.getlist("set-cookie")
+ route_set_token = any(
+ value.startswith(f"{COOKIE_NAME_JWT_TOKEN}=") for
value in route_cookies
)
- if cookie_path != "/":
- response.set_cookie(
- COOKIE_NAME_JWT_TOKEN,
- "",
- path="/",
- httponly=True,
- secure=secure,
- samesite="lax",
- max_age=0,
- )
- else:
- response = await self._set_new_token(new_user, secure,
response, cookie_path)
-
- except HTTPException as exc:
- # If any HTTPException is raised during user resolution or
refresh, return it as response
- return JSONResponse(status_code=exc.status_code,
content={"detail": exc.detail})
-
- return response
-
- @classmethod
- async def _set_new_token(
- cls,
- new_user: KeycloakAuthManagerUser | None,
- secure: bool,
- response: Response,
- cookie_path: str | None = None,
- ) -> Response:
- """
- Set Cookies in the response based on a new JWT token and a new user
model.
-
- :param new_user: User model for the JWT token
- :param secure: HTTP secure property for cookies
- :param response: FastAPI response object to set the cookies on
- :param cookie_path: Path for cookies in the response
- """
- if cookie_path is None:
+ del headers["set-cookie"]
+ # The route owns the token it sets: never send ours, so a
refreshed token can't outlive a logout.
+ cookie_values = (
+ cleanup_cookies
+ if route_set_token or not token_cookie
+ else [token_cookie, *cleanup_cookies]
+ )
+ # Ours go first: for the same cookie name and path the
later Set-Cookie wins, so the
+ # cookies set by the route itself take precedence.
+ for value in [*cookie_values, *route_cookies]:
+ headers.append("set-cookie", value)
+ await send(message)
+
+ try:
+ await self.app(scope, receive, send_with_cookies)
+ except HTTPException as exc:
+ if response_started:
+ raise
+ # An HTTPException escaping the inner middlewares is returned
as a response
+ response = JSONResponse(status_code=exc.status_code,
content={"detail": exc.detail})
+ await response(scope, receive, send)
+
+ def _is_skipped(self, scope: Scope) -> bool:
+ path = scope["path"].removeprefix(scope.get("root_path", ""))
+ return path in UNAUTHENTICATED_PATHS or
path.startswith(self.skip_path_prefixes)
+
+ @staticmethod
+ def build_cookie_headers(
+ request: Request, new_token: str, extra_cookies: dict[str, str]
+ ) -> tuple[str, list[str]]:
+ """
+ Return the ``Set-Cookie`` value of the token and those clearing
stale token cookies.
+
+ Any cookies with a nil value ("") will be cleared with Max-Age=0
+
+ :param request: FastAPI Request
+ :param new_token: New Airflow JWT token
+ :param extra_cookies: Additional cookie values to set
+ """
cookie_path = get_cookie_path()
- if new_user:
- # If we created a new user, serialize it and set it as a cookie
- new_token = get_auth_manager().generate_jwt(new_user)
- else:
- new_token = ""
- response.set_cookie(
- COOKIE_NAME_JWT_TOKEN,
- new_token,
- path=cookie_path,
- httponly=True,
- secure=secure,
- samesite="lax",
- max_age=0 if new_token == "" else None,
- )
- if new_user:
- # Update keycloak token cookies
+ secure = request_cookie_is_secure(request)
+ # Only used to render the Set-Cookie header values
+ response = Response()
response.set_cookie(
- COOKIE_NAME_ACCESS_TOKEN,
- new_user.access_token,
+ COOKIE_NAME_JWT_TOKEN,
+ new_token,
path=cookie_path,
+ httponly=True,
secure=secure,
samesite="lax",
- httponly=True,
+ max_age=0 if new_token == "" else None,
)
- if new_user.refresh_token:
- response.set_cookie(
- COOKIE_NAME_REFRESH_TOKEN,
- new_user.refresh_token,
- path=cookie_path,
+ # Clear any stale _token cookie at root path "/".
+ # Older Airflow instances may have set the cookie there;
+ # without this, the root-path cookie keeps being sent on
+ # every request, causing an infinite redirect loop.
+ if cookie_path != "/":
+ response.delete_cookie(
+ key=COOKIE_NAME_JWT_TOKEN,
+ path="/",
+ httponly=True,
secure=secure,
samesite="lax",
- httponly=True,
)
- else:
- # No refresh token
+ # Add any additional cookies required
+ for cookie, value in extra_cookies.items():
response.set_cookie(
- COOKIE_NAME_REFRESH_TOKEN,
- "",
+ cookie,
+ value,
path=cookie_path,
+ httponly=True,
secure=secure,
samesite="lax",
- httponly=True,
- max_age=0,
+ max_age=0 if value == "" else None,
)
- else:
- # User is not populated, clear cookies for login
- response.set_cookie(
- COOKIE_NAME_ACCESS_TOKEN,
- "",
- path=cookie_path,
- secure=secure,
- samesite="lax",
- httponly=True,
- max_age=0,
+ token_cookie, *cleanup_cookies = (
+ value.decode("latin-1") for key, value in response.raw_headers
if key == b"set-cookie"
)
- response.set_cookie(
- COOKIE_NAME_REFRESH_TOKEN,
- "",
- path=cookie_path,
- secure=secure,
- samesite="lax",
- httponly=True,
- max_age=0,
- )
- # Clear any stale _token cookie at root path "/".
- # Older Airflow instances may have set the cookie there;
- # without this, the root-path cookie keeps being sent on
- # every request, causing an infinite redirect loop.
- if cookie_path != "/":
- response.set_cookie(
- key=COOKIE_NAME_JWT_TOKEN,
- path="/",
- httponly=True,
- secure=secure,
- samesite="lax",
- max_age=0,
- )
- return response
+ return token_cookie, cleanup_cookies
- @staticmethod
- def _is_logout(request: Request) -> bool:
- """Tell whether the request is for the core logout route."""
- scope = request.scope
- return scope["path"].removeprefix(scope.get("root_path", "")) ==
LOGOUT_PATH
+ @staticmethod
+ @abstractmethod
+ def get_extra_cookies(request: Request, new_user: BaseUser | None) ->
dict[str, str]: ...
+
+ @staticmethod
+ async def generate_new_user_token(request: Request, new_user: BaseUser
| None) -> str:
+ """Generate a new Airflow JWT token from the user model."""
+ return get_auth_manager().generate_jwt(new_user) if new_user else
""
+
+ @staticmethod
+ @abstractmethod
+ async def refresh_user(request: Request) -> tuple[BaseUser | None,
BaseUser | None]: ...
- @staticmethod
- def _drop_cookie(request: Request, name: str) -> None:
- """Remove a cookie from the request that the inner middlewares and the
route receive."""
- prefix = f"{name}=".encode("latin-1")
- headers = []
- for key, value in request.scope["headers"]:
- if key != b"cookie":
- headers.append((key, value))
- continue
- kept = b";".join(part for part in value.split(b";") if not
part.lstrip().startswith(prefix))
- if kept.strip():
- headers.append((key, kept.strip()))
- request.scope["headers"] = headers
+
+log = logging.getLogger(__name__)
+
+
+class KeycloakJWTMiddleware(JWTRefreshMiddleware):
+ """
+ Attach the Keycloak JWT tokens to the user.
+
+ Gets the Keycloak JWT tokens from the request cookies
+ and attaches them to the user. If the token is expired,
+ attempt to refresh it using the refresh token.
+ """
@staticmethod
- async def _is_jwt_still_valid(request: Request) -> bool:
- """
- Check whether the Airflow JWT sent with the request is still accepted.
-
- It was valid when the request came in, so it is rejected now only if
it was revoked
- while the request was handled. Expiry in the meantime is not treated
as revocation:
- the refreshed session replaces the token anyway.
- """
- jwt_token = request.cookies.get(COOKIE_NAME_JWT_TOKEN)
- if not jwt_token:
- return True
- auth_manager = cast("KeycloakAuthManager", get_auth_manager())
- try:
- await auth_manager.get_user_from_token(
- jwt_token,
- request.cookies.get(COOKIE_NAME_ACCESS_TOKEN),
- request.cookies.get(COOKIE_NAME_REFRESH_TOKEN),
- )
- except ExpiredSignatureError:
- return True
- except InvalidTokenError:
- return False
- return True
+ def get_extra_cookies(request: Request, new_user: BaseUser | None) ->
dict[str, str]:
+ if new_user:
+ user = cast("KeycloakAuthManagerUser", new_user)
+ return {
+ COOKIE_NAME_ACCESS_TOKEN: user.access_token,
+ COOKIE_NAME_REFRESH_TOKEN: user.refresh_token or "",
+ }
+ return {COOKIE_NAME_ACCESS_TOKEN: "", COOKIE_NAME_REFRESH_TOKEN: ""}
@staticmethod
- async def _refresh_user(
- request: Request,
- ) -> tuple[KeycloakAuthManagerUser | None, KeycloakAuthManagerUser | None]:
- jwt_token = request.cookies.get(COOKIE_NAME_JWT_TOKEN)
- access_token = request.cookies.get(COOKIE_NAME_ACCESS_TOKEN)
- refresh_token = request.cookies.get(COOKIE_NAME_REFRESH_TOKEN)
- if not jwt_token:
- # User is not logged into Airflow
+ async def refresh_user(request: Request):
+ if not request.cookies.get(COOKIE_NAME_JWT_TOKEN):
+ # User is not logged into Airflow.
return None, None
- if not access_token:
+ if not request.cookies.get(COOKIE_NAME_ACCESS_TOKEN):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED, detail="User is not
logged into Keycloak."
)
- auth_manager = cast("KeycloakAuthManager", get_auth_manager())
try:
- user = await auth_manager.get_user_from_token(jwt_token,
access_token, refresh_token)
+ jwt_token = request.cookies.get(COOKIE_NAME_JWT_TOKEN, "")
+ access_token = request.cookies.get(COOKIE_NAME_ACCESS_TOKEN, "")
+ refresh_token = request.cookies.get(COOKIE_NAME_REFRESH_TOKEN)
+ auth_manager = cast("KeycloakAuthManager", get_auth_manager())
+ # Before BaseAuthManager.get_jwt_refresh_middleware() was
implemented
+ # get_user_from_token needed to return a None user to
JWTRefreshMiddleware.
+ # Adding the access_token and refresh_tokens here adds them to the
deserialised user model.
+ args: tuple[str] | tuple[str, str | None, str | None] = (
+ (jwt_token,)
+ if KeycloakAuthManager._middleware_handles_cookies()
+ else (jwt_token, access_token, refresh_token)
+ )
+
+ user = await auth_manager.get_user_from_token(*args)
+ if user:
+ if KeycloakAuthManager._middleware_handles_cookies():
+ # Re-attach Keycloak JWTs from cookies
+ user.access_token = access_token
+ user.refresh_token = refresh_token
Review Comment:
Can we always call `get_user_from_token(jwt_token)` here, then attach the
cookies and check the subject once? Today the version branching lives both here
and in `get_user_from_token`, and on 3.3 to 3.4.0 the subject is checked twice
(once in `get_user_from_token`, once at line 284).
##########
providers/keycloak/tests/unit/keycloak/auth_manager/test_middleware.py:
##########
@@ -75,441 +188,549 @@ def mock_request(self, secure):
del request.state.user_authenticated_via
return request
- @pytest.fixture
- def mock_user(self):
- user = Mock(name="user", spec=KeycloakAuthManagerUser)
- user.user_id = "user_id"
- user.name = "name"
- user.access_token = "access_token"
- user.refresh_token = "refresh_token"
- return user
-
- @pytest.fixture
- def call_next(self):
- return AsyncMock(return_value=Mock(name="response"), name="call_next")
+ def test_no_token(self, mock_auth_manager):
+ app, _ = _build_app()
- @pytest.fixture
- def auth_manager(self):
- return Mock(name="auth_manager")
-
- @pytest.fixture
- def secure(self, request):
- return request.param
+ response = TestClient(app, cookies={}).get("/api/v2/dags")
-
@patch("airflow.providers.keycloak.auth_manager.middleware.get_auth_manager")
- async def test_get_keycloak_tokens_from_cookies(
- self, mock_get_auth_manager, auth_manager, call_next, mock_request,
middleware, mock_user
- ):
- auth_manager.get_user_from_token = AsyncMock(return_value=mock_user)
- auth_manager.refresh_user.return_value = None
- mock_get_auth_manager.return_value = auth_manager
+ assert response.status_code == 200
+ assert "set-cookie" not in response.headers
+ mock_auth_manager.get_user_from_token.assert_not_called()
- mock_request.cookies = {
- COOKIE_NAME_JWT_TOKEN: "token",
- COOKIE_NAME_ACCESS_TOKEN: "access_token",
- COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
- }
+ def test_invalid_token_clears_cookie(self, mock_auth_manager):
+ mock_auth_manager.get_user_from_token.side_effect = HTTPException(
+ status_code=403, detail="Invalid JWT token"
+ )
+ app, seen = _build_app()
- await middleware.dispatch(mock_request, call_next)
+ response = TestClient(app, cookies={COOKIE_NAME_JWT_TOKEN:
"invalid_token"}).get("/api/v2/dags")
- assert mock_request.state.user is mock_user
- assert mock_request.state.user.access_token == "access_token"
- assert mock_request.state.user.refresh_token == "refresh_token"
+ assert response.status_code == 200
+ assert seen["user"] is None
+ assert '_token=""; HttpOnly; Max-Age=0; Path=/; SameSite=lax' in
response.headers["set-cookie"]
+ mock_auth_manager.refresh_user.assert_not_called()
+
+ def test_no_refreshed_user(self, mock_auth_manager):
+ access_token = keycloak_token("user_id")
+ mock_auth_manager.refresh_user.return_value = None
+ app, seen = _build_app()
+
+ response = TestClient(
+ app,
+ cookies={
+ COOKIE_NAME_JWT_TOKEN: "valid_token",
+ COOKIE_NAME_ACCESS_TOKEN: access_token,
+ COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
+ },
+ ).get("/api/v2/dags")
trusted_marker = getattr(
core_api_security,
"USER_INJECTED_BY_TRUSTED_MIDDLEWARE",
None,
)
- if trusted_marker is not None:
- assert mock_request.state.user_authenticated_via is trusted_marker
+ assert "set-cookie" not in response.headers
+ assert seen["user"] is
mock_auth_manager.get_user_from_token.return_value
+ assert seen["authenticated_via"] is trusted_marker
+ if KeycloakAuthManager._middleware_handles_cookies():
+
mock_auth_manager.get_user_from_token.assert_called_once_with("valid_token")
else:
- assert not hasattr(mock_request.state, "user_authenticated_via")
-
- auth_manager.get_user_from_token.assert_called_once_with("token",
"access_token", "refresh_token")
- auth_manager.refresh_user.assert_called_once_with(user=mock_user)
- call_next.assert_awaited_once_with(mock_request)
-
-
@patch("airflow.providers.keycloak.auth_manager.middleware.get_auth_manager")
- async def test_refresh_keycloak_token(
- self,
- mock_get_auth_manager,
- auth_manager,
- call_next,
- mock_request,
- middleware,
- mock_user,
- secure,
- ):
- new_user = Mock(name="user", spec=KeycloakAuthManagerUser)
- new_user.access_token = "new_access_token"
- new_user.refresh_token = "new_refresh_token"
- auth_manager.get_user_from_token = AsyncMock(return_value=mock_user)
- auth_manager.refresh_user = Mock(return_value=new_user)
- auth_manager.generate_jwt.return_value = "new_token"
- mock_get_auth_manager.return_value = auth_manager
-
- mock_request.cookies = {
- COOKIE_NAME_JWT_TOKEN: "token",
- COOKIE_NAME_ACCESS_TOKEN: "access_token",
- COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
- }
-
- response = await middleware.dispatch(mock_request, call_next)
-
- assert mock_request.state.user is new_user
- assert mock_request.state.user.access_token == "new_access_token"
- assert mock_request.state.user.refresh_token == "new_refresh_token"
+ mock_auth_manager.get_user_from_token.assert_called_once_with(
+ "valid_token", access_token, "refresh_token"
+ )
+ mock_auth_manager.generate_jwt.assert_not_called()
- response.set_cookie.assert_any_call(
- COOKIE_NAME_JWT_TOKEN,
- "new_token",
- path="/",
- secure=secure,
- samesite="lax",
- httponly=True,
- max_age=None,
+ def test_refreshed_user(self, mock_auth_manager):
+ access_token = keycloak_token("user_id")
+ current_user = _build_user(
+ user_id="user_id", name="name", access_token=access_token,
refresh_token="refresh_token"
)
- response.set_cookie.assert_any_call(
- COOKIE_NAME_ACCESS_TOKEN,
- "new_access_token",
- path="/",
- samesite="lax",
- secure=secure,
- httponly=True,
- )
- response.set_cookie.assert_any_call(
- COOKIE_NAME_REFRESH_TOKEN,
- "new_refresh_token",
- path="/",
- samesite="lax",
- secure=secure,
- httponly=True,
+ refreshed_user = KeycloakAuthManagerUser(
+ user_id="user_id", name="name", access_token=access_token,
refresh_token="new_refresh_token"
)
+ mock_auth_manager.refresh_user.return_value = refreshed_user
+ mock_auth_manager.get_user_from_token.side_effect = [current_user,
ExpiredSignatureError]
+ app, seen = _build_app()
+
+ response = TestClient(
+ app,
+ cookies={
+ COOKIE_NAME_JWT_TOKEN: "valid_token",
+ COOKIE_NAME_ACCESS_TOKEN: access_token,
+ COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
+ },
+ ).get("/api/v2/dags")
trusted_marker = getattr(
core_api_security,
"USER_INJECTED_BY_TRUSTED_MIDDLEWARE",
None,
)
- if trusted_marker is not None:
- assert mock_request.state.user_authenticated_via is trusted_marker
- else:
- assert not hasattr(mock_request.state, "user_authenticated_via")
+ assert seen["user"] is refreshed_user
+ assert seen["authenticated_via"] is trusted_marker
+
mock_auth_manager.refresh_user.assert_called_once_with(user=current_user)
+ mock_auth_manager.generate_jwt.assert_called_once_with(refreshed_user)
+ assert (
+ response.headers["set-cookie"]
+ == f"_token=new_token; HttpOnly; Path=/; SameSite=lax,
_access_token={access_token}; HttpOnly; Path=/; SameSite=lax,
_refresh_token=new_refresh_token; HttpOnly; Path=/; SameSite=lax"
+ )
- # Once to resolve the user, once more after the endpoint ran to
confirm the
- # token is still accepted before a replacement is issued.
- assert auth_manager.get_user_from_token.await_args_list == [
- call("token", "access_token", "refresh_token"),
- call("token", "access_token", "refresh_token"),
- ]
- auth_manager.refresh_user.assert_called_once_with(user=mock_user)
- auth_manager.generate_jwt.assert_called_once_with(new_user)
- call_next.assert_awaited_once_with(mock_request)
-
-
@patch("airflow.providers.keycloak.auth_manager.middleware.get_auth_manager")
- async def test_no_new_token_when_jwt_revoked_during_request(
- self,
- mock_get_auth_manager,
- auth_manager,
- call_next,
- mock_request,
- middleware,
- mock_user,
- secure,
- ):
- """
- When the endpoint revokes the token the request came with (the logout
route does),
- a refreshed session must not be turned into a new JWT; the session
cookies are cleared.
- """
- new_user = Mock(name="user", spec=KeycloakAuthManagerUser)
- new_user.access_token = "new_access_token"
- new_user.refresh_token = "new_refresh_token"
- auth_manager.get_user_from_token = AsyncMock(return_value=mock_user)
- auth_manager.refresh_user = Mock(return_value=new_user)
- auth_manager.generate_jwt.return_value = "new_token"
- mock_get_auth_manager.return_value = auth_manager
-
- mock_request.cookies = {
- COOKIE_NAME_JWT_TOKEN: "token",
- COOKIE_NAME_ACCESS_TOKEN: "access_token",
- COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
- }
+ def test_invalid_token_does_not_clear_token_set_by_route(self,
mock_auth_manager):
+ mock_auth_manager.get_user_from_token.side_effect = HTTPException(
+ status_code=403, detail="Invalid JWT token"
+ )
+ app, _ = _build_app()
- async def logout_endpoint(request):
- # The endpoint revokes the presented token, so it is rejected from
now on.
- auth_manager.get_user_from_token.side_effect =
InvalidTokenError("Token has been revoked")
- return Mock(name="response")
+ response = TestClient(app, cookies={COOKIE_NAME_JWT_TOKEN:
"stale_token"}).get("/auth/login_callback")
- call_next.side_effect = logout_endpoint
+ assert response.headers.get_list("set-cookie") == [
+ '_access_token=""; HttpOnly; Max-Age=0; Path=/; SameSite=lax',
+ '_refresh_token=""; HttpOnly; Max-Age=0; Path=/; SameSite=lax',
+ *_default_cookies,
+ ]
- response = await middleware.dispatch(mock_request, call_next)
+ def test_refreshed_token_does_not_override_logout(self, mock_auth_manager):
+ access_token = keycloak_token("user_id")
+ refreshed_user = KeycloakAuthManagerUser(
+ user_id="user_id", name="name", access_token=access_token,
refresh_token="new_refresh_token"
+ )
+ mock_auth_manager.refresh_user.return_value = refreshed_user
+ mock_auth_manager.generate_jwt.return_value = "new_token"
+ app, _ = _build_app()
+
+ response = TestClient(
+ app,
+ cookies={
+ COOKIE_NAME_JWT_TOKEN: "valid_token",
+ COOKIE_NAME_ACCESS_TOKEN: access_token,
+ COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
+ },
+ ).get("/api/v2/auth/logout")
+
+ set_cookie_headers = response.headers.get_list("set-cookie")
+ assert len(set_cookie_headers) == 3
+ assert "new_token" not in set_cookie_headers[0]
+ assert access_token not in set_cookie_headers[1]
+ assert "new_refresh_token" not in set_cookie_headers[2]
+
+ @patch(f"{MODULE}.get_cookie_path", autospec=True)
+ def test_root_cookie_cleared_when_route_sets_token(self, mock_cookie_path,
mock_auth_manager):
+ mock_cookie_path.return_value = "/team-a/"
+ mock_auth_manager.get_user_from_token.side_effect = HTTPException(
+ status_code=403, detail="Invalid JWT token"
+ )
+ app, _ = _build_app()
+
+ response = TestClient(
+ app,
+ cookies={
+ COOKIE_NAME_JWT_TOKEN: "stale_token",
+ COOKIE_NAME_ACCESS_TOKEN: "access_token",
+ COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
+ },
+ ).get("/auth/login_callback")
+
+ set_cookie_headers = response.headers.get_list("set-cookie")
+ assert len(set_cookie_headers) == 5
+ assert any("Path=/team-a/" in h and "_token=issued_token" in h for h
in set_cookie_headers)
+ assert any(
+ "Path=/team-a/" in h and "_access_token=issued_access_token" in h
for h in set_cookie_headers
+ )
+ assert any(
+ "Path=/team-a/" in h and "_refresh_token=issued_refresh_token" in
h for h in set_cookie_headers
+ )
+ assert any(
+ "Path=/" in h and "Path=/team-a/" not in h and "Max-Age=0" in h
for h in set_cookie_headers
+ )
- auth_manager.generate_jwt.assert_not_called()
- for cookie_name in (COOKIE_NAME_JWT_TOKEN, COOKIE_NAME_ACCESS_TOKEN,
COOKIE_NAME_REFRESH_TOKEN):
- assert any(
- c.args[0] == cookie_name and c.args[1] == "" and
c.kwargs.get("max_age") == 0
- for c in response.set_cookie.call_args_list
- ), f"{cookie_name} cookie was not cleared"
- issued_values = {c.args[1] for c in response.set_cookie.call_args_list
if len(c.args) > 1}
- assert issued_values.isdisjoint({"new_token", "new_access_token",
"new_refresh_token"})
-
-
@patch("airflow.providers.keycloak.auth_manager.middleware.get_auth_manager")
- async def test_new_token_when_jwt_expired_during_request(
- self,
- mock_get_auth_manager,
- auth_manager,
- call_next,
- mock_request,
- middleware,
- mock_user,
- secure,
- ):
- """A token that merely expired while the request was handled is still
replaced."""
- new_user = Mock(name="user", spec=KeycloakAuthManagerUser)
- new_user.access_token = "new_access_token"
- new_user.refresh_token = "new_refresh_token"
- auth_manager.get_user_from_token = AsyncMock(side_effect=[mock_user,
ExpiredSignatureError()])
- auth_manager.refresh_user = Mock(return_value=new_user)
- auth_manager.generate_jwt.return_value = "new_token"
- mock_get_auth_manager.return_value = auth_manager
-
- mock_request.cookies = {
- COOKIE_NAME_JWT_TOKEN: "token",
- COOKIE_NAME_ACCESS_TOKEN: "access_token",
- COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
- }
+ def test_refresh_user_runs_off_the_event_loop(self, mock_auth_manager):
+ """``refresh_user`` is synchronous and may do blocking I/O, so it must
not block the loop."""
+ refresh_threads = []
+ mock_auth_manager.refresh_user.side_effect = lambda user:
refresh_threads.append(
+ threading.get_ident()
+ )
+ loop_threads = []
+ if KeycloakAuthManager._middleware_handles_cookies():
+ get_user = lambda token: loop_threads.append(threading.get_ident())
+ else:
+ get_user = lambda token, access_token, refresh_token:
loop_threads.append(threading.get_ident())
+ mock_auth_manager.get_user_from_token.side_effect = get_user
+ app, _ = _build_app()
+
+ TestClient(
+ app,
+ cookies={
+ COOKIE_NAME_JWT_TOKEN: "valid_token",
+ COOKIE_NAME_ACCESS_TOKEN: "access_token",
+ COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
+ },
+ ).get("/api/v2/dags")
+
+ assert len(refresh_threads) == 1
+ assert refresh_threads != loop_threads
+
+ def test_streaming_response_passthrough(self, mock_auth_manager):
+ mock_auth_manager.refresh_user.return_value = KeycloakAuthManagerUser(
+ user_id="user_id",
+ name="name",
+ access_token=keycloak_token("user_id"),
+ refresh_token="refresh_token",
+ )
+ mock_auth_manager.generate_jwt.return_value = "new_token"
+ app, _ = _build_app()
+
+ response = TestClient(
+ app,
+ cookies={
+ COOKIE_NAME_JWT_TOKEN: "valid_token",
+ COOKIE_NAME_ACCESS_TOKEN: keycloak_token("user_id"),
+ COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
+ },
+ ).get("/api/v2/stream")
+
+ assert response.content == b"chunk1-chunk2-chunk3"
+ assert response.headers["content-type"].startswith("text/plain")
+ assert "_token=new_token" in response.headers["set-cookie"]
+
+ def test_http_exception_from_inner_app_returned_as_response(self,
mock_get_auth_manager):
+ mock_get_auth_manager.return_value = KeycloakAuthManager()
+
+ async def raising_app(scope, receive, send):
+ raise HTTPException(status_code=418, detail="teapot")
+
+ app = KeycloakJWTMiddleware(raising_app)
+
+ response = TestClient(
+ app,
+ cookies={
+ COOKIE_NAME_JWT_TOKEN: "valid_token",
+ COOKIE_NAME_ACCESS_TOKEN: "access_token",
+ COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
+ },
+ ).get("/api/v2/dags")
+
+ assert response.status_code == 418
+ assert response.json() == {"detail": "teapot"}
+
+ @pytest.mark.parametrize("root_path", ["", "/team-a"])
+ @pytest.mark.parametrize("path", ["/api/v2/monitor/health",
"/api/v2/version", "/static/main.js"])
+ def test_skipped_paths(self, mock_auth_manager, tmp_path, path, root_path):
+ """Static assets and unauthenticated endpoints never decode the JWT or
hit the DB."""
+ (tmp_path / "main.js").write_text("console.log('hi');")
+ app, _ = _build_app(static_dir=tmp_path)
+ client = TestClient(
+ app,
+ root_path=root_path,
+ cookies={
+ COOKIE_NAME_JWT_TOKEN: "valid_token",
+ COOKIE_NAME_ACCESS_TOKEN: "access_token",
+ COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
+ },
+ )
- response = await middleware.dispatch(mock_request, call_next)
+ response = client.get(f"{root_path}{path}")
- auth_manager.generate_jwt.assert_called_once_with(new_user)
- response.set_cookie.assert_any_call(
- COOKIE_NAME_JWT_TOKEN,
- "new_token",
- path="/",
- secure=secure,
- samesite="lax",
- httponly=True,
- max_age=None,
+ assert response.status_code == 200
+ assert "set-cookie" not in response.headers
+ mock_auth_manager.get_user_from_token.assert_not_called()
+ mock_auth_manager.refresh_user.assert_not_called()
+
+ @pytest.mark.parametrize(
+ ("headers", "expected_status", "expected_body"),
+ [
+ pytest.param({}, 200, b"0123456789", id="full"),
+ pytest.param({"range": "bytes=2-4"}, 206, b"234", id="range"),
+ ],
+ )
+ def test_static_files_served_unchanged(self, tmp_path, headers,
expected_status, expected_body):
+ (tmp_path / "main.js").write_bytes(b"0123456789")
+ app, _ = _build_app(static_dir=tmp_path)
+ client = TestClient(
+ app,
+ cookies={
+ COOKIE_NAME_JWT_TOKEN: "valid_token",
+ COOKIE_NAME_ACCESS_TOKEN: "access_token",
+ COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
+ },
)
-
@patch("airflow.providers.keycloak.auth_manager.middleware.get_auth_manager")
- async def test_no_keycloak_token(
- self, mock_get_auth_manager, auth_manager, call_next, middleware,
mock_request, secure
- ):
- mock_get_auth_manager.return_value = auth_manager
+ response = client.get("/static/main.js", headers=headers)
+
+ assert response.status_code == expected_status
+ assert response.content == expected_body
+ assert "etag" in response.headers
+ assert "last-modified" in response.headers
+ revalidated = client.get("/static/main.js", headers={"if-none-match":
response.headers["etag"]})
+ assert revalidated.status_code == 304
+
+ @pytest.mark.parametrize(
+ ("scheme", "ssl_cert", "expected_secure"),
+ [
+ pytest.param("https", "", True, id="https-no-local-ssl-cert"),
+ pytest.param("http", "/etc/ssl/cert.pem", True,
id="http-with-local-ssl-cert"),
+ pytest.param("https", "/etc/ssl/cert.pem", True,
id="https-with-local-ssl-cert"),
+ pytest.param("http", "", False, id="http-no-local-ssl-cert"),
+ ],
+ )
+ def test_cookie_secure_flag(self, mock_auth_manager, scheme, ssl_cert,
expected_secure):
+ """The cookie Secure flag must follow the request scheme as well as
the local ssl_cert."""
+ mock_auth_manager.refresh_user.return_value = KeycloakAuthManagerUser(
+ user_id="user_id",
+ name="name",
+ access_token=keycloak_token("user_id"),
+ refresh_token="new_refresh_token",
+ )
+ mock_auth_manager.generate_jwt.return_value = "new_token"
+ with conf_vars({("api", "ssl_cert"): ssl_cert}):
+ app, _ = _build_app()
+ client = TestClient(
+ app,
+ base_url=f"{scheme}://testserver",
+ cookies={
+ COOKIE_NAME_JWT_TOKEN: "valid_token",
+ COOKIE_NAME_ACCESS_TOKEN: "access_token",
+ COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
+ },
+ )
- mock_request.cookies = {COOKIE_NAME_JWT_TOKEN: "token"}
+ response = client.get("/api/v2/dags")
- response = await middleware.dispatch(mock_request, call_next)
+ assert ("Secure" in response.headers["set-cookie"]) is expected_secure
- auth_manager.get_user_from_token.assert_not_called()
- auth_manager.refresh_user.assert_not_called()
+ @pytest.mark.skipif(not AIRFLOW_V_3_1_7_PLUS, reason="Relies on
AuthManagerRefreshTokenExpiredException")
+ @pytest.mark.asyncio
+ async def test_dispatch_expired_keycloak_token(self, mock_auth_manager):
+ mock_user = _build_user(
+ user_id="user_id", name="name", access_token="expired_token",
refresh_token="expired_token"
+ )
+ mock_auth_manager.get_user_from_token.return_value = mock_user
+ mock_auth_manager._token_subject = Mock(return_value="user_id")
+ mock_auth_manager.refresh_user.side_effect =
AuthManagerRefreshTokenExpiredException()
+
+ app, _ = _build_app()
+ client = TestClient(
+ app,
+ cookies={
+ COOKIE_NAME_JWT_TOKEN: "valid_token",
+ COOKIE_NAME_ACCESS_TOKEN: "expired_token",
+ COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
+ },
+ )
- assert mock_request.state.user is None
+ response = client.get("/api/v2/dags")
+ if KeycloakAuthManager._middleware_handles_cookies():
+
mock_auth_manager.get_user_from_token.assert_called_once_with("valid_token")
+ else:
+ mock_auth_manager.get_user_from_token.assert_called_once_with(
+ "valid_token", "expired_token", "refresh_token"
+ )
+ mock_auth_manager.refresh_user.assert_called_once_with(user=mock_user)
+ if AIRFLOW_V_3_1_7_PLUS:
+ assert '_token=""; HttpOnly; Max-Age=0; Path=/; SameSite=lax' in
response.headers["set-cookie"]
+ mock_auth_manager.generate_jwt.assert_not_called()
+
+ @pytest.mark.parametrize(
+ "refresh_outcome",
+ [
+ pytest.param("refreshed", id="refreshed-token"),
+ pytest.param("invalid", id="invalid-token"),
+ ],
+ )
+ @patch(
+ "airflow.api_fastapi.auth.middlewares.refresh_token.get_cookie_path",
+ autospec=True,
+ return_value="/team-a/",
+ )
+ def test_cookie_uses_subpath_and_clears_root_cookie(
+ self, _mock_get_cookie_path, mock_auth_manager, refresh_outcome
+ ):
+ """With a subpath, the cookie is scoped to it and a stale root-path
cookie is cleared."""
+ if refresh_outcome == "refreshed":
+ mock_auth_manager.refresh_user.return_value =
KeycloakAuthManagerUser(
+ user_id="user_id",
+ name="name",
+ access_token=keycloak_token("user_id"),
+ refresh_token="new_refresh_token",
+ )
+ mock_auth_manager.generate_jwt.return_value = "new_token"
+ else:
+ mock_auth_manager.get_user_from_token.side_effect = HTTPException(
+ status_code=403, detail="Invalid JWT token"
+ )
+ app, _ = _build_app()
+
+ response = TestClient(
+ app,
+ root_path="/team-a/",
+ cookies={
+ COOKIE_NAME_JWT_TOKEN: "token",
+ COOKIE_NAME_ACCESS_TOKEN: keycloak_token("user_id"),
+ COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
+ },
+ ).get("/api/v2/dags")
+
+ set_cookie_headers = response.headers.get_list("set-cookie")
+ assert len(set_cookie_headers) == 4
+ assert any("Path=/team-a/" in h for h in set_cookie_headers)
+ if refresh_outcome == "refreshed":
+ assert any(
+ "Path=/" in h and "Path=/team-a/" not in h and "Max-Age=0" in
h for h in set_cookie_headers
+ )
+ else:
+ assert all("Max-Age=0" in h for h in set_cookie_headers)
+
+ def test_refresh_user_sets_keycloak_cookies(self, mock_auth_manager):
+ access_token = keycloak_token("user_id")
+ refreshed_user = MagicMock(spec=KeycloakAuthManagerUser)
+ refreshed_user.user_id = "user_id"
+ refreshed_user.access_token = access_token
+ refreshed_user.refresh_token = "new_refresh_token"
+ mock_auth_manager.refresh_user.return_value = refreshed_user
+ mock_auth_manager.generate_jwt.return_value = "new_token"
+ app, seen = _build_app()
+
+ response = TestClient(
+ app,
+ cookies={
+ COOKIE_NAME_JWT_TOKEN: "valid_token",
+ COOKIE_NAME_ACCESS_TOKEN: access_token,
+ COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
+ },
+ ).get("/api/v2/dags")
+
+ # JWTRefreshMiddleware must stamp the trust sentinel so `get_user()`
accepts
+ # the cached user. Without the marker, the auth dependency falls
through
+ # to a fresh JWT validation, defeating the refresh.
+ assert seen["user"] is refreshed_user
trusted_marker = getattr(
core_api_security,
"USER_INJECTED_BY_TRUSTED_MIDDLEWARE",
None,
)
-
- if trusted_marker is not None:
- assert getattr(mock_request.state, "user_authenticated_via", None)
is not trusted_marker
- else:
- assert not hasattr(mock_request.state, "user_authenticated_via")
-
- call_next.assert_awaited_with(mock_request)
-
- response.set_cookie.assert_any_call(
- COOKIE_NAME_JWT_TOKEN,
- "",
- path="/",
- secure=secure,
- httponly=True,
- samesite="lax",
- max_age=0,
+ assert seen["authenticated_via"] is trusted_marker
+ mock_auth_manager.refresh_user.assert_called_once_with(
+ user=mock_auth_manager.get_user_from_token.return_value
+ )
+ mock_auth_manager.generate_jwt.assert_called_once_with(refreshed_user)
+ assert (
+ response.headers["set-cookie"]
+ == f"_token=new_token; HttpOnly; Path=/; SameSite=lax,
_access_token={access_token}; HttpOnly; Path=/; SameSite=lax,
_refresh_token=new_refresh_token; HttpOnly; Path=/; SameSite=lax"
)
-
@patch("airflow.providers.keycloak.auth_manager.middleware.get_auth_manager")
- async def test_no_airflow_jwt_token(
- self, mock_get_auth_manager, auth_manager, call_next, middleware,
mock_request
- ):
- mock_get_auth_manager.return_value = auth_manager
-
- mock_request.cookies = {
- COOKIE_NAME_ACCESS_TOKEN: "access_token",
- COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
- }
-
- response = await middleware.dispatch(mock_request, call_next)
-
- auth_manager.get_user_from_token.assert_not_called()
- auth_manager.refresh_user.assert_not_called()
-
- assert mock_request.state.user is None
-
+ def test_refresh_user_clears_refresh_token_cookie(self, mock_auth_manager):
+ access_token = keycloak_token("user_id")
+ refreshed_user = KeycloakAuthManagerUser(
+ user_id="user_id",
+ name="name",
+ access_token=access_token,
+ refresh_token=None,
+ )
+ mock_auth_manager.refresh_user.return_value = refreshed_user
+ mock_auth_manager.generate_jwt.return_value = "new_token"
+ app, seen = _build_app()
+
+ response = TestClient(
+ app,
+ cookies={
+ COOKIE_NAME_JWT_TOKEN: "valid_token",
+ COOKIE_NAME_ACCESS_TOKEN: access_token,
+ COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
+ },
+ ).get("/api/v2/dags")
+
+ # JWTRefreshMiddleware must stamp the trust sentinel so `get_user()`
accepts
+ # the cached user. Without the marker, the auth dependency falls
through
+ # to a fresh JWT validation, defeating the refresh.
+ assert seen["user"] is refreshed_user
trusted_marker = getattr(
core_api_security,
"USER_INJECTED_BY_TRUSTED_MIDDLEWARE",
None,
)
-
- if trusted_marker is not None:
- assert getattr(mock_request.state, "user_authenticated_via", None)
is not trusted_marker
- else:
- assert not hasattr(mock_request.state, "user_authenticated_via")
-
- call_next.assert_awaited_once_with(mock_request)
- response.set_cookie.assert_not_called()
-
-
@patch("airflow.providers.keycloak.auth_manager.middleware.get_auth_manager")
- @pytest.mark.asyncio
- async def test_dispatch_expired_token(
- self,
- mock_get_auth_manager,
- auth_manager,
- call_next,
- middleware,
- mock_request,
- secure,
- ):
- mock_get_auth_manager.return_value = auth_manager
- mock_request.cookies = {
- COOKIE_NAME_JWT_TOKEN: "invalid_token",
- COOKIE_NAME_ACCESS_TOKEN: "access_token",
- COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
- }
- auth_manager.get_user_from_token.side_effect = InvalidTokenError()
-
- response = await middleware.dispatch(mock_request, call_next)
-
- call_next.assert_called_once_with(mock_request)
- auth_manager.get_user_from_token.assert_called_once_with(
- "invalid_token", "access_token", "refresh_token"
+ assert seen["authenticated_via"] is trusted_marker
+ mock_auth_manager.refresh_user.assert_called_once_with(
+ user=mock_auth_manager.get_user_from_token.return_value
)
-
- response.set_cookie.assert_any_call(
- COOKIE_NAME_JWT_TOKEN,
- "",
- path="/",
- secure=secure,
- httponly=True,
- samesite="lax",
- max_age=0,
+ mock_auth_manager.generate_jwt.assert_called_once_with(refreshed_user)
+ assert (
+ response.headers["set-cookie"]
+ == f'_token=new_token; HttpOnly; Path=/; SameSite=lax,
_access_token={refreshed_user.access_token}; HttpOnly; Path=/; SameSite=lax,
_refresh_token=""; HttpOnly; Max-Age=0; Path=/; SameSite=lax'
)
-
@patch("airflow.providers.keycloak.auth_manager.middleware.get_auth_manager")
- @pytest.mark.asyncio
- async def test_dispatch_expired_keycloak_token(
- self,
- mock_get_auth_manager,
- auth_manager,
- call_next,
- middleware,
- mock_request,
- mock_user,
- secure,
+ @patch(f"{MODULE}.KeycloakJWTMiddleware.get_extra_cookies")
+ def test_invalid_token_does_not_clear_extra_cookie_set_by_route(
+ self, mock_get_extra_cookies: MagicMock, mock_auth_manager
):
- mock_get_auth_manager.return_value = auth_manager
- mock_request.cookies = {
- COOKIE_NAME_JWT_TOKEN: "token",
- COOKIE_NAME_ACCESS_TOKEN: "expired_token",
- COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
- }
- mock_user.access_token = "expired_token"
- mock_user.refresh_token = "refresh_token"
- auth_manager.get_user_from_token = AsyncMock(return_value=mock_user)
- if AIRFLOW_V_3_1_7_PLUS:
- auth_manager.refresh_user.side_effect =
AuthManagerRefreshTokenExpiredException()
- else:
- auth_manager.refresh_user.return_value = None
-
- response = await middleware.dispatch(mock_request, call_next)
-
- call_next.assert_called_once_with(mock_request)
- auth_manager.get_user_from_token.assert_called_once_with("token",
"expired_token", "refresh_token")
- auth_manager.refresh_user.assert_called_once_with(user=mock_user)
-
- if AIRFLOW_V_3_1_7_PLUS:
- response.set_cookie.assert_any_call(
- COOKIE_NAME_JWT_TOKEN,
- "",
- path="/",
- secure=secure,
- httponly=True,
- samesite="lax",
- max_age=0,
- )
- auth_manager.generate_jwt.assert_not_called()
-
-
@patch("airflow.providers.keycloak.auth_manager.middleware.get_auth_manager")
- async def test_dispatch_does_not_clear_fresh_token_set_by_endpoint(
- self,
- mock_get_auth_manager,
- auth_manager,
- call_next,
- middleware,
- mock_request,
- mock_user,
- ):
- """
- An expired token on the request must not clear the cookie when the
endpoint
- set a fresh one on the response (e.g. the login callback exchanging the
- authorization code while an expired token is still in the cookie jar).
- """
- mock_get_auth_manager.return_value = auth_manager
- mock_request.cookies = {
- COOKIE_NAME_JWT_TOKEN: "expired",
- COOKIE_NAME_ACCESS_TOKEN: "expired_token",
- COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
- }
- auth_manager.get_user_from_token =
AsyncMock(side_effect=InvalidTokenError())
-
- async def call_endpoint(request):
- # The endpoint (login callback) mints a fresh JWT and signals it
- request.state.jwt_token_issued = True
- return Mock(name="response")
-
- call_next.side_effect = call_endpoint
-
- response = await middleware.dispatch(mock_request, call_next)
-
- response.set_cookie.assert_not_called()
+ mock_get_extra_cookies.return_value = {"_access_token": "",
"_refresh_token": ""}
+ mock_auth_manager.get_user_from_token.side_effect = HTTPException(
+ status_code=403, detail="Invalid JWT token"
+ )
+ app, _ = _build_app()
+
+ response = TestClient(
+ app,
+ cookies={
+ COOKIE_NAME_JWT_TOKEN: "stale_token",
+ COOKIE_NAME_ACCESS_TOKEN: "access_token",
+ COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
+ },
+ ).get("/auth/login_callback")
+
+ assert response.headers.get_list("set-cookie") == [
+ '_access_token=""; HttpOnly; Max-Age=0; Path=/; SameSite=lax',
+ '_refresh_token=""; HttpOnly; Max-Age=0; Path=/; SameSite=lax',
+ "_token=issued_token; HttpOnly; Path=/; SameSite=lax",
+ "_access_token=issued_access_token; HttpOnly; Path=/;
SameSite=lax",
+ "_refresh_token=issued_refresh_token; HttpOnly; Path=/;
SameSite=lax",
+ ]
-
@patch("airflow.providers.keycloak.auth_manager.middleware.get_cookie_path")
-
@patch("airflow.providers.keycloak.auth_manager.middleware.get_auth_manager")
@pytest.mark.asyncio
- async def test_dispatch_invalid_token_clears_root_cookie(
- self,
- mock_get_auth_manager,
- mock_get_cookie_path,
- auth_manager,
- call_next,
- middleware,
- mock_request,
- secure,
- ):
- mock_get_cookie_path.return_value = "/foo/"
- mock_get_auth_manager.return_value = auth_manager
- auth_manager.get_user_from_token.side_effect = InvalidTokenError()
- """When a stale _token exists at root path, clearing must target both
the subpath and root."""
- mock_request.cookies = {
- COOKIE_NAME_JWT_TOKEN: "stale_root_token",
- COOKIE_NAME_ACCESS_TOKEN: "access_token",
- COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
- }
- response = await middleware.dispatch(mock_request, call_next)
+ @pytest.mark.parametrize(
+ "jwt_token",
+ [
+ pytest.param("not-a-jwt", id="no-payload-segment"),
+ pytest.param(token_with_payload("not json"),
id="payload-not-json"),
+ pytest.param(token_with_payload("1"), id="payload-not-an-object"),
+ pytest.param(token_with_payload('{"other": "user_id"}'),
id="payload-without-sub"),
+ pytest.param(token_with_payload('{"sub": null}'),
id="payload-with-null-sub"),
+ ],
+ )
+ async def test_refresh_user_rejects_unparsable_token(self,
mock_get_auth_manager, jwt_token):
+ """A token whose subject cannot be read matches no user and is
refused."""
+ mock_get_auth_manager.return_value = KeycloakAuthManager()
+
+ app, _ = _build_app()
+ response = TestClient(
+ app,
+ cookies={
+ COOKIE_NAME_JWT_TOKEN: jwt_token,
+ COOKIE_NAME_ACCESS_TOKEN: keycloak_token("user_id"),
+ COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
+ },
+ ).get("/api/v2/dags")
+ assert '_token=""; HttpOnly; Max-Age=0; Path=/; SameSite=lax' in
response.headers["set-cookie"]
- # Expect two delete cookies: one at the subpath and one at root "/"
- response.set_cookie.assert_any_call(
- "_token", "", path="/foo/", secure=secure, samesite="lax",
httponly=True, max_age=0
- )
- response.set_cookie.assert_any_call(
- "_token", "", path="/", secure=secure, samesite="lax",
httponly=True, max_age=0
- )
+ @pytest.mark.asyncio
+ async def test_get_user_from_token_rejects_another_subjects_token(self,
mock_auth_manager):
+ """A Keycloak token naming a different subject must not attach to this
session."""
+ access_token = keycloak_token("someone_else")
+ mock_user = _build_user("user_id", "name", access_token,
"refresh_token")
+ mock_auth_manager.get_user_from_token =
AsyncMock(return_value=mock_user)
+ # mock_auth_manager.get_user_from_token.return_value = mock_user
Review Comment:
nit: leftover commented code
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]