pypomes-iam 0.5.6__py3-none-any.whl → 0.5.8__py3-none-any.whl

pypomes_iam/__init__.py

@@ -3,19 +3,13 @@ from .iam_actions import (
     action_login, action_logout, action_token
 )
 from .iam_common import (
-    IamServer
+    IamServer, IamParam
 )
 from .iam_pomes import (
-    jwt_required
+    iam_setup, iam_get_token
 )
 from .iam_services import (
-     logger_register
-)
-from .jusbr_pomes import (
-    jusbr_setup, jusbr_get_token
-)
-from .keycloak_pomes import (
-    keycloak_setup, keycloak_get_token
+     jwt_required, logger_register
 )
 from .provider_pomes import (
     provider_register, provider_get_token
@@ -29,15 +23,11 @@ __all__ = [
     "action_callback", "action_exchange",
     "action_login", "action_logout", "action_token",
     # iam_commons
-    "IamServer",
+    "IamServer", "IamParam",
     # iam_pomes
-    "jwt_required",
+    "iam_setup", "iam_get_token",
     # iam_services
-    "logger_register",
-    # jusbr_pomes
-    "jusbr_setup", "jusbr_get_token",
-    # keycloak_pomes
-    "keycloak_setup", "keycloak_get_token",
+    "jwt_required", "logger_register",
     # provider_pomes
     "provider_register", "provider_get_token",
     # token_pomes

pypomes_iam/iam_actions.py

@@ -9,11 +9,11 @@ from pypomes_core import TZ_LOCAL, exc_format
 from typing import Any
 
 from .iam_common import (
-    IamServer, _iam_lock,
+    IamServer, IamParam, UserParam, _iam_lock,
     _get_iam_users, _get_iam_registry,  # _get_public_key,
     _get_login_timeout, _get_user_data
 )
-from .token_pomes import token_validate
+from .token_pomes import token_get_claims, token_validate
 
 
 def action_login(iam_server: IamServer,
@@ -54,24 +54,25 @@ def action_login(iam_server: IamServer,
                                                    errors=errors,
                                                    logger=logger)
         if user_data:
-            user_data["login-id"] = user_id
+            user_data[UserParam.LOGIN_ID] = user_id
             timeout: int = _get_login_timeout(iam_server=iam_server,
                                               errors=errors,
                                               logger=logger)
             if not errors:
-                user_data["login-expiration"] = int(datetime.now(tz=TZ_LOCAL).timestamp()) + timeout \
+                user_data[UserParam.LOGIN_EXPIRATION] = int(datetime.now(tz=TZ_LOCAL).timestamp()) + timeout \
                     if timeout else None
-                redirect_uri: str = args.get("redirect-uri")
-                user_data["redirect-uri"] = redirect_uri
+                redirect_uri: str = args.get(UserParam.REDIRECT_URI)
+                user_data[UserParam.REDIRECT_URI] = redirect_uri
 
                 # build the login url
                 registry: dict[str, Any] = _get_iam_registry(iam_server=iam_server,
                                                              errors=errors,
                                                              logger=logger)
                 if registry:
-                    result = (f"{registry["base-url"]}/protocol/openid-connect/auth"
+                    base_url: str = f"{registry[IamParam.URL_BASE]}/realms/{registry[IamParam.CLIENT_REALM]}"
+                    result = (f"{base_url}/protocol/openid-connect/auth"
                               f"?response_type=code&scope=openid"
-                              f"&client_id={registry["client-id"]}"
+                              f"&client_id={registry[IamParam.CLIENT_ID]}"
                               f"&redirect_uri={redirect_uri}"
                               f"&state={oauth_state}")
     return result
@@ -137,24 +138,28 @@ def action_token(iam_server: IamServer,
                                                        user_id=user_id,
                                                        errors=errors,
                                                        logger=logger)
-            token: str = user_data["access-token"] if user_data else None
+            token: str = user_data[UserParam.ACCESS_TOKEN] if user_data else None
             if token:
-                access_expiration: int = user_data.get("access-expiration")
+                access_expiration: int = user_data.get(UserParam.ACCESS_EXPIRATION)
                 now: int = int(datetime.now(tz=TZ_LOCAL).timestamp())
                 if now < access_expiration:
                     result = token
                 else:
                     # access token has expired
-                    refresh_token: str = user_data["refresh-token"]
+                    refresh_token: str = user_data[UserParam.REFRESH_TOKEN]
                     if refresh_token:
-                        refresh_expiration = user_data["refresh-expiration"]
+                        refresh_expiration = user_data[UserParam.REFRESH_EXPIRATION]
                         if now < refresh_expiration:
+                            header_data: dict[str, str] = {
+                                "Content-Type": "application/json"
+                            }
                             body_data: dict[str, str] = {
                                 "grant_type": "refresh_token",
                                 "refresh_token": refresh_token
                             }
                             now: int = int(datetime.now(tz=TZ_LOCAL).timestamp())
                             token_data: dict[str, Any] = __post_for_token(iam_server=iam_server,
+                                                                          header_data=header_data,
                                                                           body_data=body_data,
                                                                           errors=errors,
                                                                           logger=logger)
@@ -169,7 +174,7 @@ def action_token(iam_server: IamServer,
                                 result = token_info[1]
                             else:
                                 # refresh token is no longer valid
-                                user_data["refresh-token"] = None
+                                user_data[UserParam.REFRESH_TOKEN] = None
                         else:
                             # refresh token has expired
                             err_msg = "Access and refresh tokens expired"
@@ -236,6 +241,9 @@ def action_callback(iam_server: IamServer,
             else:
                 users.pop(oauth_state)
                 code: str = args.get("code")
+                header_data: dict[str, str] = {
+                    "Content-Type": "application/json"
+                }
                 body_data: dict[str, Any] = {
                     "grant_type": "authorization_code",
                     "code": code,
@@ -243,6 +251,7 @@ def action_callback(iam_server: IamServer,
                 }
                 now: int = int(datetime.now(tz=TZ_LOCAL).timestamp())
                 token_data: dict[str, Any] = __post_for_token(iam_server=iam_server,
+                                                              header_data=header_data,
                                                               body_data=body_data,
                                                               errors=errors,
                                                               logger=logger)
@@ -297,9 +306,8 @@ def action_exchange(iam_server: IamServer,
     user_id: str = args.get("user-id") or args.get("login")
 
     # obtain the token to be exchanged
-    token: str = args.get("access-token")
-
-    if user_id and token:
+    token: str = args.get("access-token") if user_id else None
+    if token:
         # HAZARD: only 'IAM_KEYCLOAK' is currently supported
         with _iam_lock:
             # retrieve the IAM server's registry
@@ -307,30 +315,166 @@ def action_exchange(iam_server: IamServer,
                                                          errors=errors,
                                                          logger=logger)
             if registry:
-                body_data: dict[str, str] = {
-                    "grant_type": "urn:ietf:params:oauth:grant-type:token-exchange",
-                    "subject_token": token,
-                    "subject_token_type": "urn:ietf:params:oauth:token-type:access_token",
-                    "requested_token_type": "urn:ietf:params:oauth:token-type:access_token",
-                    "audience": registry["client-id"],
-                    "subject_issuer": "oidc"
-                }
-                now: int = int(datetime.now(tz=TZ_LOCAL).timestamp())
-                token_data: dict[str, Any] = __post_for_token(iam_server=IamServer.IAM_KEYCLOAK,
-                                                              body_data=body_data,
-                                                              errors=errors,
-                                                              logger=logger)
-                # validate and store the token data
-                if token_data:
-                    user_data: dict[str, Any] = {}
-                    result = __validate_and_store(iam_server=iam_server,
-                                                  user_data=user_data,
-                                                  token_data=token_data,
-                                                  now=now,
+                # make sure 'client_id' is linked to the token's 'token_sub' at the IAM server
+                __assert_link(iam_server=iam_server,
+                              user_id=user_id,
+                              token=token,
+                              errors=errors,
+                              logger=logger)
+                if not errors:
+                    # exchange the token
+                    header_data: dict[str, Any] = {
+                        "Content-Type": "application/x-www-form-urlencoded"
+                    }
+                    body_data: dict[str, str] = {
+                        "grant_type": "urn:ietf:params:oauth:grant-type:token-exchange",
+                        "subject_token": token,
+                        "subject_token_type": "urn:ietf:params:oauth:token-type:access_token",
+                        "requested_token_type": "urn:ietf:params:oauth:token-type:access_token",
+                        "audience": registry[IamParam.CLIENT_ID],
+                        "subject_issuer": "oidc"
+                    }
+                    now: int = int(datetime.now(tz=TZ_LOCAL).timestamp())
+                    token_data: dict[str, Any] = __post_for_token(iam_server=iam_server,
+                                                                  header_data=header_data,
+                                                                  body_data=body_data,
+                                                                  errors=errors,
+                                                                  logger=logger)
+                    # validate and store the token data
+                    if token_data:
+                        user_data: dict[str, Any] = {}
+                        result = __validate_and_store(iam_server=iam_server,
+                                                      user_data=user_data,
+                                                      token_data=token_data,
+                                                      now=now,
+                                                      errors=errors,
+                                                      logger=logger)
+    else:
+        msg: str = "User identification or token not provided"
+        if logger:
+            logger.error(msg=msg)
+        if isinstance(errors, list):
+            errors.append(msg)
+
+    return result
+
+
+def __assert_link(iam_server: IamServer,
+                  user_id: str,
+                  token: str,
+                  errors: list[str] | None,
+                  logger: Logger | None) -> None:
+    """
+    Make sure *iam_server* has a link associating *user_id* to an internal user identification.
+    This is a requirement for exchanging a token issued by a federated *IAM* server for an equivalent
+    one from *iam_server.
+
+    :param iam_server: the reference *IAM* server
+    :param user_id: the reference user identification
+    :param token: the reference token
+    :param errors: incidental errors
+    :param logger: optional logger
+    """
+    # obtain a token with administrative rights
+    admin_token: str = __get_administrative_token(iam_server=iam_server,
                                                   errors=errors,
                                                   logger=logger)
+    if admin_token:
+        registry: dict[str, Any] = _get_iam_registry(iam_server=iam_server,
+                                                     errors=errors,
+                                                     logger=logger)
+        # obtain the internal user identification for 'from_id'
+        url: str = f"{registry[IamParam.URL_BASE]}/admin/realms/{registry[IamParam.CLIENT_REALM]}/users"
+        header_data: dict[str, str] = {
+            "Authorization": f"Bearer {admin_token}",
+            "Content-Type": "application/json"
+        }
+        params: dict[str, str] = {
+            "username": user_id,
+            "exact": "true"
+        }
+        users: dict[str, Any] = __get_for_data(url=url,
+                                               header_data=header_data,
+                                               params=params,
+                                               errors=errors,
+                                               logger=logger)
+        if users:
+            # verify whether the 'oidc' protocol is referred to in an
+            # association between 'from_id' and the internal user identification
+            internal_id: str = users.get("id")
+            url = (f"{registry[IamParam.URL_BASE]}/admin/realms/"
+                   f"{registry[IamParam.CLIENT_REALM]}/users/{internal_id}/federated-identity")
+            providers: list[dict[str, Any]] = __get_for_data(url=url,
+                                                             header_data=header_data,
+                                                             params=None,
+                                                             errors=errors,
+                                                             logger=logger)
+            no_link: bool = True
+            for provider in providers:
+                if provider.get("identityProvider") == "oidc":
+                    no_link = False
+                    break
+            if no_link:
+                # link the identities
+                claims: dict[str, dict[str, Any]] = token_get_claims(token=token,
+                                                                     errors=errors,
+                                                                     logger=logger)
+                if claims:
+                    token_sub: str = claims["paylod"]["sub"]
+                    url += "/oidc"
+                    body_data: dict[str, Any] = {
+                        "userId": token_sub,
+                        "userName": user_id
+                    }
+                    __post_data(url=url,
+                                header_data=header_data,
+                                body_data=body_data,
+                                errors=errors,
+                                logger=logger)
+
+
+def __get_administrative_token(iam_server: IamServer,
+                               errors: list[str] | None,
+                               logger: Logger | None) -> str:
+    """
+    Obtain a token with administrative rights from *iam_server*'s reference realm.
+
+    The reference realm is the realm specified at *iam_server*'s setup time. This operation requires
+    the realm administrator's identification and secret password to have also been provided.
+
+    :param iam_server: the reference *IAM* server
+    :param errors: incidental errors
+    :param logger: optional logger
+    :return: a token with administrative rights for the reference realm
+    """
+    # initialize the return variable
+    result: str | None = None
+
+    # obtain the IAM server's registry
+    registry: dict[str, Any] = _get_iam_registry(iam_server=iam_server,
+                                                 errors=errors,
+                                                 logger=logger)
+    if registry and registry[IamParam.ADMIN_ID] and registry[IamParam.ADMIN_SECRET]:
+        header_data: dict[str, str] = {
+            "Content-Type": "application/json"
+        }
+        body_data: dict[str, str] = {
+            "grant-type": "password",
+            "username": registry[IamParam.ADMIN_ID],
+            "password": registry[IamParam.ADMIN_SECRET],
+            "client_id": registry[IamParam.CLIENT_ID]
+        }
+        token_data: dict[str, Any] = __post_for_token(iam_server=iam_server,
+                                                      header_data=header_data,
+                                                      body_data=body_data,
+                                                      errors=errors,
+                                                      logger=logger)
+        if token_data:
+            # obtain the token
+            result = token_data["access_token"]
     else:
-        msg: str = "User identification or token not provided"
+        msg: str = (f"To obtain token with administrative rights from '{iam_server}', "
+                    f"the credentials for the realm administrator must be provided at setup time")
         if logger:
             logger.error(msg=msg)
         if isinstance(errors, list):
@@ -339,12 +483,165 @@ def action_exchange(iam_server: IamServer,
     return result
 
 
+def __get_client_secret(iam_server: IamServer,
+                        errors: list[str] | None,
+                        logger: Logger | None) -> str:
+    """
+    Retrieve the client's secret password.
+
+    If it has not been provided at *iam_server*'s setup time, an attempt is made to obtain it
+    from the *IAM* server itself. This would require the realm administrator's identification and
+    secret password to have been provided, instead.
+
+    :param iam_server: the reference *IAM* server
+    :param errors: incidental errors
+    :param logger: optional logger
+     :return: the client's secret password, or *None* if error
+    """
+    # retrieve client's secret password stored in the IAM server's registry
+    registry: dict[str, Any] = _get_iam_registry(iam_server=iam_server,
+                                                 errors=errors,
+                                                 logger=logger)
+    result: str = registry[IamParam.CLIENT_SECRET] if registry else None
+
+    if not result and not errors:
+        # obtain a token with administrative rights
+        token: str = __get_administrative_token(iam_server=iam_server,
+                                                errors=errors,
+                                                logger=logger)
+        if token:
+            # obtain the client UUID
+            url: str = f"{registry[IamParam.URL_BASE]}/realms/{registry[IamParam.CLIENT_REALM]}/clients"
+            header_data: dict[str, str] = {
+                "Authorization": f"Bearer {token}",
+                "Content-Type": "application/json"
+            }
+            params: dict[str, str] = {
+                "clientId": registry[IamParam.CLIENT_ID]
+            }
+            clients: list[dict[str, Any]] = __get_for_data(url=url,
+                                                           header_data=header_data,
+                                                           params=params,
+                                                           errors=errors,
+                                                           logger=logger)
+            if clients:
+                # obtain the client's secret password
+                client_uuid: str = clients[0]["id"]
+                url += f"/{client_uuid}/client-secret"
+                reply: dict[str, Any] = __get_for_data(url=url,
+                                                       header_data=header_data,
+                                                       params=None,
+                                                       errors=errors,
+                                                       logger=logger)
+                if reply:
+                    # store the client's secret password and return it
+                    result = reply["value"]
+                    registry[IamParam.CLIENT_ID] = result
+    return result
+
+
+def __get_for_data(url: str,
+                   header_data: dict[str, str],
+                   params: dict[str, Any] | None,
+                   errors: list[str] | None,
+                   logger: Logger | None) -> Any:
+    """
+    Send a *GET* request to *url* and return the data obtained.
+
+    :param url: the target URL
+    :param header_data: the data to send in the header of the request
+    :param params: the query parameters to send in the request
+    :param errors: incidental errors
+    :param logger: optional logger
+    :return: the data requested, or *None* if error
+    """
+    # initialize the return variable
+    result: Any = None
+
+    # log the GET
+    if logger:
+        logger.debug(msg=f"GET {url}, {json.dumps(obj=params,
+                                                  ensure_ascii=False)}")
+    try:
+        response: requests.Response = requests.get(url=url,
+                                                   headers=header_data,
+                                                   params=params)
+        if response.status_code == 200:
+            # request succeeded
+            result = response.json() or {}
+            if logger:
+                logger.debug(msg=f"GET success, {json.dumps(obj=result,
+                                                            ensure_ascii=False)}")
+        else:
+            # request resulted in error
+            msg: str = f"GET failure, status {response.status_code}, reason {response.reason}"
+            if hasattr(response, "content") and response.content:
+                msg += f", content '{response.content}'"
+            if logger:
+                logger.error(msg=msg)
+            if isinstance(errors, list):
+                errors.append(msg)
+    except Exception as e:
+        # the operation raised an exception
+        msg: str = exc_format(exc=e,
+                              exc_info=sys.exc_info())
+        if logger:
+            logger.error(msg=msg)
+        if isinstance(errors, list):
+            errors.append(msg)
+
+    return result
+
+
+def __post_data(url: str,
+                header_data: dict[str, str],
+                body_data: dict[str, Any],
+                errors: list[str] | None,
+                logger: Logger | None) -> None:
+    """
+    Submit a *POST* request to *url*.
+
+    :param header_data: the data to send in the header of the request
+    :param body_data: the data to send in the body of the request
+    :param errors: incidental errors
+    :param logger: optional logger
+    """
+    # log the POST
+    if logger:
+        logger.debug(msg=f"POST {url}, {json.dumps(obj=body_data,
+                                                   ensure_ascii=False)}")
+    try:
+        response: requests.Response = requests.get(url=url,
+                                                   headers=header_data,
+                                                   data=body_data)
+        if response.status_code >= 400:
+            # request resulted in error
+            msg = f"POST failure, status {response.status_code}, reason {response.reason}"
+            if hasattr(response, "content") and response.content:
+                msg += f", content '{response.content}'"
+            if logger:
+                logger.error(msg=msg)
+            if isinstance(errors, list):
+                errors.append(msg)
+        elif logger:
+            logger.debug(msg=f"POST success")
+    except Exception as e:
+        # the operation raised an exception
+        msg = exc_format(exc=e,
+                         exc_info=sys.exc_info())
+        if logger:
+            logger.error(msg=msg)
+        if isinstance(errors, list):
+            errors.append(msg)
+
+
 def __post_for_token(iam_server: IamServer,
+                     header_data: dict[str, str],
                      body_data: dict[str, Any],
                      errors: list[str] | None,
                      logger: Logger | None) -> dict[str, Any] | None:
     """
-    Send a POST request to obtain the authentication token data, and return the data received.
+    Send a *POST* request to *iam_server* and return the authentication token data obtained.
 
     For token acquisition, *body_data* will have the attributes:
         - "grant_type": "authorization_code"
@@ -363,9 +660,14 @@ def __post_for_token(iam_server: IamServer,
         - "audience": <client-id>,
         - "subject_issuer": "oidc"
 
+    For administrative token acquisition, *body_data* will have the attributes:
+        - "grant_type": "password"
+        - "username": <realm-administrator-identification>
+        - "password": <realm-administrator-secret>
+
     These attributes are then added to *body_data*:
-        - "client_id": <client-id>,
-        - "client_secret": <client-secret>,
+        - "client_id": <client-id>
+        - "client_secret": <client-secret>  <- except for acquiring administrative tokens
 
     If the operation is successful, the token data is stored in the *IAM* server's registry, and returned.
     Otherwise, *errors* will contain the appropriate error message.
@@ -380,6 +682,7 @@ def __post_for_token(iam_server: IamServer,
         }
 
     :param iam_server: the reference registered *IAM* server
+    :param header_data: the data to send in the header of the request
     :param body_data: the data to send in the body of the request
     :param errors: incidental errors
     :param logger: optional logger
@@ -396,18 +699,23 @@ def __post_for_token(iam_server: IamServer,
                                                      logger=logger)
         if registry:
             # complete the data to send in body of request
-            body_data["client_id"] = registry["client-id"]
-            client_secret: str = registry["client-secret"]
+            body_data["client_id"] = registry[IamParam.CLIENT_ID]
 
-            # obtain the token
-            url: str = registry["base-url"] + "/protocol/openid-connect/token"
+            # build the URL
+            base_url: str = f"{registry[IamParam.URL_BASE]}/realms/{registry[IamParam.CLIENT_REALM]}"
+            url: str = f"{base_url}/protocol/openid-connect/token"
 
             # log the POST ('client_secret' data must not be shown in log)
             if logger:
                 logger.debug(msg=f"POST {url}, {json.dumps(obj=body_data,
                                                            ensure_ascii=False)}")
-            if client_secret:
+            client_secret: str = __get_client_secret(iam_server=iam_server,
+                                                     errors=errors,
+                                                     logger=logger)
+            if body_data["grant_type"] != "password" and client_secret:
                 body_data["client_secret"] = client_secret
+
+            # obtain the token
             try:
                 # typical return on a token request:
                 # {
@@ -418,6 +726,7 @@ def __post_for_token(iam_server: IamServer,
                 #   "refesh_expires_in": <number-of-seconds>
                 # }
                 response: requests.Response = requests.post(url=url,
+                                                            headers=header_data,
                                                             data=body_data)
                 if response.status_code == 200:
                     # request succeeded
@@ -490,10 +799,11 @@ def __validate_and_store(iam_server: IamServer,
             # public_key: str = _get_public_key(iam_server=iam_server,
             #                                   errors=errors,
             #                                   logger=logger)
-            recipient_attr = registry["recipient-attr"]
+            recipient_attr = registry[IamParam.RECIPIENT_ATTR]
             login_id = user_data.pop("login-id", None)
+            base_url: str = f"{registry[IamParam.URL_BASE]}/realms/{registry[IamParam.CLIENT_REALM]}"
             claims: dict[str, dict[str, Any]] = token_validate(token=token,
-                                                               issuer=registry["base-url"],
+                                                               issuer=base_url,
                                                                recipient_id=login_id,
                                                                recipient_attr=recipient_attr,
                                                                # public_key=public_key,