# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
from __future__ import annotations
import logging
import secrets
from typing import Annotated, Literal, cast
from urllib.parse import quote, urljoin
from fastapi import HTTPException, Query, Request, status
from fastapi.responses import HTMLResponse, RedirectResponse
from airflow.api_fastapi.app import AUTH_MANAGER_FASTAPI_APP_PREFIX, get_auth_manager
from airflow.api_fastapi.auth.managers.base_auth_manager import COOKIE_NAME_JWT_TOKEN
from airflow.providers.keycloak.version_compat import (
AIRFLOW_V_3_1_1_PLUS,
AIRFLOW_V_3_1_8_PLUS,
AIRFLOW_V_3_3_PLUS,
)
if AIRFLOW_V_3_1_8_PLUS:
from airflow.api_fastapi.app import get_cookie_path
else:
[docs]
get_cookie_path = lambda: "/"
from airflow.api_fastapi.common.router import AirflowRouter
from airflow.api_fastapi.core_api.openapi.exceptions import create_openapi_http_exception_doc
from airflow.api_fastapi.core_api.security import is_safe_url
from airflow.providers.common.compat.sdk import conf
from airflow.providers.keycloak.auth_manager.constants import (
COOKIE_NAME_ACCESS_TOKEN,
COOKIE_NAME_ID_TOKEN,
COOKIE_NAME_LOGIN_NEXT_URL,
COOKIE_NAME_OAUTH_STATE,
COOKIE_NAME_REFRESH_TOKEN,
)
from airflow.providers.keycloak.auth_manager.keycloak_auth_manager import (
KeycloakAuthManager,
is_cli_authorization_code_enabled,
)
from airflow.providers.keycloak.auth_manager.services.token import (
build_user_from_userinfo,
is_cli_loopback_redirect_uri,
translate_keycloak_outage,
)
[docs]
log = logging.getLogger(__name__)
[docs]
login_router = AirflowRouter(tags=["KeycloakAuthManagerLogin"])
def _login_callback_url(request: Request) -> str:
"""
Build the OAuth ``redirect_uri`` for the login callback.
Prefer the configured public base URL (as ``logout`` and the post-login redirect
already do) so the value handed to Keycloak does not depend on the request
``Host``/``X-Forwarded-Host`` headers, which are attacker-controlled when the API
server runs with ``--proxy-headers``. Fall back to the request URL when
``base_url`` is not configured.
"""
base_url = conf.get("api", "base_url", fallback=None)
if base_url:
return urljoin(base_url, f"{AUTH_MANAGER_FASTAPI_APP_PREFIX}/login_callback")
return str(request.url_for("login_callback"))
@login_router.get("/login")
[docs]
def login(request: Request) -> RedirectResponse:
"""Initiate the authentication."""
client = KeycloakAuthManager.get_keycloak_client()
redirect_uri = _login_callback_url(request)
state = secrets.token_urlsafe(32)
auth_url = client.auth_url(redirect_uri=str(redirect_uri), scope="openid", state=state)
response = RedirectResponse(auth_url)
secure = request.base_url.scheme == "https" or bool(conf.get("api", "ssl_cert", fallback=""))
cookie_path = get_cookie_path()
response.set_cookie(
COOKIE_NAME_OAUTH_STATE, state, max_age=300, path=cookie_path, httponly=True, secure=secure
)
# Remember where the user was going so the callback can send them back there
next_url = request.query_params.get("next")
if next_url and is_safe_url(next_url, request=request):
response.set_cookie(
COOKIE_NAME_LOGIN_NEXT_URL,
next_url,
max_age=300,
path=cookie_path,
httponly=True,
secure=secure,
)
else:
# Do not let a target left over from an earlier, unfinished login be used
response.delete_cookie(COOKIE_NAME_LOGIN_NEXT_URL, path=cookie_path, httponly=True, secure=secure)
return response
@login_router.get(
"/login/cli",
responses=create_openapi_http_exception_doc(
[
status.HTTP_307_TEMPORARY_REDIRECT,
status.HTTP_400_BAD_REQUEST,
status.HTTP_503_SERVICE_UNAVAILABLE,
]
),
)
[docs]
def login_cli(
redirect_uri: str,
state: Annotated[str, Query(min_length=1, max_length=512)],
# An S256 challenge is 43 base64url characters. ``auth_url`` does not encode its parameters,
# so nothing else may reach it.
code_challenge: Annotated[str, Query(pattern=r"^[A-Za-z0-9_-]{43}$")],
code_challenge_method: Literal["S256"],
) -> RedirectResponse:
"""Start the browser login of a command-line client."""
if not is_cli_authorization_code_enabled():
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Browser login is not enabled for command-line clients",
)
if not is_cli_loopback_redirect_uri(redirect_uri):
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Invalid redirect_uri")
client = KeycloakAuthManager.get_keycloak_client()
# auth_url fetches Keycloak's OpenID configuration.
with translate_keycloak_outage():
auth_url = client.auth_url(
redirect_uri=quote(redirect_uri, safe=""),
scope="openid",
state=quote(state, safe=""),
code_challenge=code_challenge,
code_challenge_method=code_challenge_method,
)
return RedirectResponse(auth_url)
@login_router.get("/login_callback")
[docs]
def login_callback(request: Request):
"""Authenticate the user."""
code = request.query_params.get("code")
if not code:
return HTMLResponse("Missing code", status_code=400)
state_q = request.query_params.get("state", "")
state_c = request.cookies.get(COOKIE_NAME_OAUTH_STATE, "")
if not state_q or not state_c or not secrets.compare_digest(state_q, state_c):
return HTMLResponse("Invalid OAuth state parameter", status_code=403)
client = KeycloakAuthManager.get_keycloak_client()
redirect_uri = _login_callback_url(request)
tokens = client.token(
grant_type="authorization_code",
code=code,
redirect_uri=str(redirect_uri),
)
user = build_user_from_userinfo(client, tokens)
token = get_auth_manager().generate_jwt(user)
request.state.jwt_token_issued = True
fallback_url = conf.get("api", "base_url", fallback="/")
next_url = request.cookies.get(COOKIE_NAME_LOGIN_NEXT_URL)
redirect_url = next_url if next_url and is_safe_url(next_url, request=request) else fallback_url
response = RedirectResponse(url=redirect_url, status_code=303)
secure = request.base_url.scheme == "https" or bool(conf.get("api", "ssl_cert", fallback=""))
# In Airflow 3.1.1 authentication changes, front-end no longer handle the token
# See https://github.com/apache/airflow/pull/55506
cookie_path = get_cookie_path()
if AIRFLOW_V_3_1_1_PLUS:
response.set_cookie(COOKIE_NAME_JWT_TOKEN, token, path=cookie_path, secure=secure, httponly=True)
else:
response.set_cookie(COOKIE_NAME_JWT_TOKEN, token, path=cookie_path, secure=secure)
# Save id token as separate cookie.
# Cookies have a size limit (usually 4k), saving all the tokens in a same cookie goes beyond this limit
response.set_cookie(
COOKIE_NAME_ID_TOKEN, tokens["id_token"], path=cookie_path, secure=secure, httponly=True
)
if AIRFLOW_V_3_3_PLUS:
response.set_cookie(
COOKIE_NAME_ACCESS_TOKEN, tokens["access_token"], path=cookie_path, secure=secure, httponly=True
)
if tokens.get("refresh_token"):
response.set_cookie(
COOKIE_NAME_REFRESH_TOKEN,
tokens["refresh_token"],
path=cookie_path,
secure=secure,
httponly=True,
)
response.delete_cookie(COOKIE_NAME_LOGIN_NEXT_URL, path=cookie_path, secure=secure, httponly=True)
return response
@login_router.get("/logout")
[docs]
def logout(request: Request):
"""Log out the user from Keycloak."""
auth_manager = cast("KeycloakAuthManager", get_auth_manager())
keycloak_config = auth_manager.get_keycloak_client().well_known()
end_session_endpoint = keycloak_config["end_session_endpoint"]
id_token = request.cookies.get(COOKIE_NAME_ID_TOKEN)
base_url = conf.get("api", "base_url", fallback="/")
post_logout_redirect_uri = urljoin(base_url, f"{AUTH_MANAGER_FASTAPI_APP_PREFIX}/logout_callback")
# Validate id_token format before using in redirect (JWT tokens have 3 parts separated by dots)
if id_token and id_token.count(".") == 2 and all(c.isalnum() or c in ".-_" for c in id_token):
encoded_id_token = quote(id_token, safe="")
logout_url = (
f"{end_session_endpoint}?post_logout_redirect_uri={post_logout_redirect_uri}"
f"&id_token_hint={encoded_id_token}"
)
else:
logout_url = str(post_logout_redirect_uri)
return RedirectResponse(logout_url)
@login_router.get("/logout_callback")
[docs]
def logout_callback(request: Request):
"""
Complete the log-out.
This callback is redirected by Keycloak after the user has been logged out from Keycloak.
"""
login_url = get_auth_manager().get_url_login()
secure = request.base_url.scheme == "https" or bool(conf.get("api", "ssl_cert", fallback=""))
cookie_path = get_cookie_path()
response = RedirectResponse(login_url)
response.delete_cookie(
key=COOKIE_NAME_JWT_TOKEN,
path=cookie_path,
secure=secure,
httponly=True,
)
response.delete_cookie(
key=COOKIE_NAME_ID_TOKEN,
path=cookie_path,
secure=secure,
httponly=True,
)
if AIRFLOW_V_3_3_PLUS:
response.delete_cookie(
key=COOKIE_NAME_ACCESS_TOKEN,
path=cookie_path,
secure=secure,
httponly=True,
)
response.delete_cookie(
key=COOKIE_NAME_REFRESH_TOKEN,
path=cookie_path,
secure=secure,
httponly=True,
)
return response