CheckmarxPythonSDK 1.1.3__tar.gz → 1.1.5__tar.gz

checkmarxpythonsdk-1.1.5/CheckmarxPythonSDK/CxOne/KeycloakAPI/ClientsAPI.py

@@ -0,0 +1,330 @@
+import json
+from CheckmarxPythonSDK.CxOne.httpRequests import get_request, post_request, put_request
+from CheckmarxPythonSDK.CxOne.KeycloakAPI.url import api_url
+import time
+
+
+def get_all_oauth_clients(realm):
+    relative_url = api_url + f"/{realm}/clients?first=0&max=999999&search=True"
+    response = get_request(relative_url=relative_url, is_iam=True)
+    return response
+
+
+def get_oauth_client_by_name(realm, client_name):
+    relative_url = api_url + f"/{realm}/clients?first=0&max=999999&search=True"
+    response = get_request(relative_url=relative_url, is_iam=True)
+
+    for client in response.json():
+        if client_name == client['clientId']:
+            response = client
+
+    return response
+
+
+def get_all_oauth_client_by_id(realm, client_id):
+    relative_url = api_url + f"/{realm}/clients/{client_id}"
+    response = get_request(relative_url=relative_url, is_iam=True)
+    return response
+
+
+def create_oauth_client(realm, client_name):
+    relative_url = api_url + f"/{realm}/clients"
+    post_data = json.dumps(
+        {
+            'enabled': True,
+            'attributes': {},
+            'redirectUris': [],
+            'clientId': client_name,
+            'protocol': 'openid-connect'
+        }
+    )
+    response = post_request(relative_url=relative_url, data=post_data, is_iam=True)
+    return response
+
+
+def edit_auth_client(realm, client_id, client_name, name, description):
+    relative_url = api_url + f"/{realm}/clients/{client_id}"
+    current_time = int(time.time())
+
+    put_data = json.dumps(
+        {
+            "id": client_id,
+            "clientId": client_name,
+            "name": name,
+            "description": description,
+            "surrogateAuthRequired": False,
+            "enabled": True,
+            "alwaysDisplayInConsole": False,
+            "clientAuthenticatorType": "client-secret",
+            "redirectUris": [],
+            "webOrigins": [],
+            "notBefore": 0,
+            "bearerOnly": False,
+            "consentRequired": False,
+            "standardFlowEnabled": False,
+            "implicitFlowEnabled": False,
+            "directAccessGrantsEnabled": True,
+            "serviceAccountsEnabled": True,
+            "publicClient": False,
+            "frontchannelLogout": True,
+            "protocol": "openid-connect",
+            "attributes": {
+                "client.secret.creation.time": current_time,
+                "backchannel.logout.session.required": "true",
+                "backchannel.logout.revoke.offline.tokens": "false",
+                "lastUpdate": current_time
+            },
+            "authenticationFlowBindingOverrides": {},
+            "fullScopeAllowed": True,
+            "nodeReRegistrationTimeout": -1,
+            "protocolMappers": [
+                {
+                    "name": "Client IP Address",
+                    "protocol": "openid-connect",
+                    "protocolMapper": "oidc-usersessionmodel-note-mapper",
+                    "consentRequired": False,
+                    "config": {
+                        "user.session.note": "clientAddress",
+                        "id.token.claim": "True",
+                        "access.token.claim": "True",
+                        "claim.name": "clientAddress",
+                        "jsonType.label": "String"
+                    }
+                },
+                {
+                    "name": "Client ID",
+                    "protocol": "openid-connect",
+                    "protocolMapper": "oidc-usersessionmodel-note-mapper",
+                    "consentRequired": False,
+                    "config": {
+                        "user.session.note": "clientId",
+                        "id.token.claim": "True",
+                        "access.token.claim": "True",
+                        "claim.name": "clientId",
+                        "jsonType.label": "String"
+                    }
+                },
+                {
+                    "name": "Client Host",
+                    "protocol": "openid-connect",
+                    "protocolMapper": "oidc-usersessionmodel-note-mapper",
+                    "consentRequired": False,
+                    "config": {
+                        "user.session.note": "clientHost",
+                        "id.token.claim": "True",
+                        "access.token.claim": "True",
+                        "claim.name": "clientHost",
+                        "jsonType.label": "String"
+                    }
+                }
+            ],
+            "defaultClientScopes": [
+                "web-origins",
+                "acr",
+                "roles",
+                "profile",
+                "iam-api",
+                "groups",
+                "ast-api",
+                "email"
+            ],
+            "optionalClientScopes": [
+                "address",
+                "phone",
+                "offline_access",
+                "microprofile-jwt"
+            ],
+            "access": {
+                "view": True,
+                "configure": True,
+                "manage": True
+            },
+        }
+    )
+    response = put_request(relative_url=relative_url, data=put_data, is_iam=True)
+    return response
+
+
+def get_oauth_service_account_user(realm, client_id):
+    relative_url = api_url + f"/{realm}/clients/{client_id}/service-account-user"
+    response = get_request(relative_url=relative_url, is_iam=True)
+    return response.json()
+
+
+def add_group_to_oauth_client(realm, service_account_user_id, group_id):
+    relative_url = api_url + f"/{realm}/users/{service_account_user_id}/groups/{group_id}"
+
+    put_data = json.dumps(
+        {
+            "realm": f"{realm}",
+            "userId": f"{service_account_user_id}",
+            "groupId": f"{group_id}"
+        }
+    )
+    response = put_request(relative_url=relative_url, data=put_data, is_iam=True)
+
+    return response
+
+
+def generate_oauth_secret(realm, client_id):
+    relative_url = api_url + f"/{realm}/clients/{client_id}/client-secret"
+
+    post_data = json.dumps(
+        {
+            "realm": realm,
+            "client": client_id
+        }
+    )
+
+    response = post_request(relative_url=relative_url, data=post_data, is_iam=True)
+    return response
+
+
+def get_client_ast_app(realm):
+    """
+
+    Args:
+        realm:
+
+    Returns:
+
+        example
+
+        [
+            {
+                "id": "d3b60524-13a1-431a-a703-1d6d3d09f512",
+                "clientId": "ast-app",
+                "rootUrl": "https://sng.iam.checkmarx.net",
+                "adminUrl": "https://sng.iam.checkmarx.net/*",
+                "surrogateAuthRequired": false,
+                "enabled": true,
+                "alwaysDisplayInConsole": false,
+                "clientAuthenticatorType": "client-secret",
+                "redirectUris": [
+                    "https://sng.ast.checkmarx.net/*",
+                    "/*"
+                ],
+                "webOrigins": [
+                    "*",
+                    "/*"
+                ],
+                "notBefore": 0,
+                "bearerOnly": false,
+                "consentRequired": false,
+                "standardFlowEnabled": true,
+                "implicitFlowEnabled": true,
+                "directAccessGrantsEnabled": true,
+                "serviceAccountsEnabled": true,
+                "publicClient": true,
+                "frontchannelLogout": true,
+                "protocol": "openid-connect",
+                "attributes": {
+                    "saml.assertion.signature": "false",
+                    "security.admin.console": "true",
+                    "saml.force.post.binding": "false",
+                    "saml.multivalued.roles": "false",
+                    "saml.encrypt": "false",
+                    "post.logout.redirect.uris": "+",
+                    "saml.server.signature": "false",
+                    "saml.server.signature.keyinfo.ext": "false",
+                    "exclude.session.state.from.auth.response": "false",
+                    "saml_force_name_id_format": "false",
+                    "saml.client.signature": "false",
+                    "tls.client.certificate.bound.access.tokens": "false",
+                    "saml.authnstatement": "false",
+                    "display.on.consent.screen": "false",
+                    "secretExpDaysBeforeNotification": "10",
+                    "saml.onetimeuse.condition": "false"
+                },
+                "authenticationFlowBindingOverrides": {},
+                "fullScopeAllowed": true,
+                "nodeReRegistrationTimeout": -1,
+                "protocolMappers": [
+                    {
+                        "id": "76fcd170-9b8b-4991-8e69-38d9fdf80619",
+                        "name": "realm-management client roles",
+                        "protocol": "openid-connect",
+                        "protocolMapper": "oidc-usermodel-client-role-mapper",
+                        "consentRequired": false,
+                        "config": {
+                            "multivalued": "true",
+                            "user.attribute": "foo",
+                            "access.token.claim": "true",
+                            "claim.name": "resource_access.${client_id}.roles",
+                            "jsonType.label": "String",
+                            "usermodel.clientRoleMapping.clientId": "realm-management"
+                        }
+                    },
+                    {
+                        "id": "b359cb2c-ac34-428d-b7d9-8bd8453926a6",
+                        "name": "Client ID",
+                        "protocol": "openid-connect",
+                        "protocolMapper": "oidc-usersessionmodel-note-mapper",
+                        "consentRequired": false,
+                        "config": {
+                            "user.session.note": "clientId",
+                            "userinfo.token.claim": "true",
+                            "id.token.claim": "true",
+                            "access.token.claim": "true",
+                            "claim.name": "clientId",
+                            "jsonType.label": "String"
+                        }
+                    },
+                    {
+                        "id": "aad7d17c-d733-4ed3-8c14-e11590a9678d",
+                        "name": "Client IP Address",
+                        "protocol": "openid-connect",
+                        "protocolMapper": "oidc-usersessionmodel-note-mapper",
+                        "consentRequired": false,
+                        "config": {
+                            "user.session.note": "clientAddress",
+                            "userinfo.token.claim": "true",
+                            "id.token.claim": "true",
+                            "access.token.claim": "true",
+                            "claim.name": "clientAddress",
+                            "jsonType.label": "String"
+                        }
+                    },
+                    {
+                        "id": "470d9673-888e-4f6f-9f4a-1b6fd652c099",
+                        "name": "Client Host",
+                        "protocol": "openid-connect",
+                        "protocolMapper": "oidc-usersessionmodel-note-mapper",
+                        "consentRequired": false,
+                        "config": {
+                            "user.session.note": "clientHost",
+                            "userinfo.token.claim": "true",
+                            "id.token.claim": "true",
+                            "access.token.claim": "true",
+                            "claim.name": "clientHost",
+                            "jsonType.label": "String"
+                        }
+                    }
+                ],
+                "defaultClientScopes": [
+                    "web-origins",
+                    "roles",
+                    "profile",
+                    "iam-api",
+                    "groups",
+                    "basic",
+                    "ast-api",
+                    "email"
+                ],
+                "optionalClientScopes": [
+                    "address",
+                    "phone",
+                    "microprofile-jwt"
+                ],
+                "access": {
+                    "view": true,
+                    "configure": true,
+                    "manage": true
+                }
+            }
+        ]
+    """
+    relative_url = api_url + f"/{realm}/clients?clientId=ast-app&max=1&search=true"
+    response = get_request(relative_url=relative_url, is_iam=True)
+    response = response.json()
+    return response

{checkmarxpythonsdk-1.1.3 → checkmarxpythonsdk-1.1.5}/CheckmarxPythonSDK/CxOne/KeycloakAPI/GroupsAPI.py

@@ -58,7 +58,7 @@ def create_group_set(realm, group_representation) -> bool:
     type_check(realm, str)
     type_check(group_representation, GroupRepresentation)
     relative_url = api_url + f"/{realm}/groups"
-    post_data = group_representation.get_post_data()
+    post_data = json.dumps(group_representation.to_dict())
     response = post_request(relative_url=relative_url, data=post_data, is_iam=True)
     if response.status_code == CREATED:
         result = True
@@ -136,7 +136,7 @@ def update_group_by_id(realm, group_id, group_representation) -> bool:
     type_check(group_id, str)
     relative_url = api_url + f"/{realm}/groups/{group_id}"
     type_check(group_representation, GroupRepresentation)
-    post_data = group_representation.get_post_data()
+    post_data = json.dumps(group_representation.to_dict())
     response = put_request(relative_url=relative_url, data=post_data, is_iam=True)
     if response.status_code == NO_CONTENT:
         result = True
@@ -240,7 +240,7 @@ def update_group_permissions(realm, group_id, group_permissions):
     type_check(group_id, str)
     type_check(group_permissions, ManagementPermissionReference)
     relative_url = api_url + f"/{realm}/groups/{group_id}/management/permissions"
-    data = group_permissions.get_post_data()
+    data = json.dumps(group_permissions.to_dict())
     response = put_request(relative_url=relative_url, data=data, is_iam=True)
     if response.status_code == NO_CONTENT:
         result = True

checkmarxpythonsdk-1.1.5/CheckmarxPythonSDK/CxOne/KeycloakAPI/RolesAPI.py

@@ -0,0 +1,190 @@
+import json
+from ...utilities.compat import CREATED, NO_CONTENT
+from ..httpRequests import get_request, post_request, put_request, delete_request
+from typing import List
+from ..utilities import get_url_param, type_check
+from .url import api_url
+from .dto import RoleRepresentation
+
+
+def get_all_roles_for_the_client(realm: str, client_id: str,
+                                 brief_representation: bool = False,
+                                 first: int = None,
+                                 max: int = None,
+                                 search: bool = None):
+    """
+
+    Args:
+        realm (str):
+        client_id (str):
+        brief_representation (bool):
+        first (int):
+        max (int):
+        search (bool):
+
+    Returns:
+        dict
+    """
+    type_check(realm, str)
+    type_check(client_id, str)
+    type_check(brief_representation, bool)
+    type_check(first, int)
+    type_check(max, int)
+    relative_url = api_url + f"/{realm}/clients/{client_id}/roles?"
+    relative_url += get_url_param("briefRepresentation", brief_representation)
+    relative_url += get_url_param("first", first)
+    relative_url += get_url_param("max", max)
+    relative_url += get_url_param("search", search)
+    response = get_request(relative_url=relative_url, is_iam=True)
+    response = response.json()
+    return response
+
+
+def create_role_for_the_client(realm: str, client_id: str, role_name: str, description: str = None):
+    """
+
+    Args:
+        realm (str):
+        client_id (str):
+        role_name (str):
+        description (str):
+
+    Returns:
+        bool
+    """
+    is_successful = False
+    type_check(realm, str)
+    type_check(client_id, str)
+    type_check(role_name, str)
+    relative_url = api_url + f"/{realm}/clients/{client_id}/roles"
+    data = json.dumps({
+        "name": role_name,
+        "description": description,
+        "composite": True,
+        "clientRole": True,
+        "attributes": {
+            "category": ["Composite role"],
+            "type": ["Role"],
+        }
+    })
+    response = post_request(relative_url=relative_url, data=data, is_iam=True)
+    if response.status_code == CREATED:
+        is_successful = True
+    return is_successful
+
+
+def delete_role_by_name(realm: str, client_id: str, role_name: str):
+    is_successful = False
+    type_check(realm, str)
+    type_check(client_id, str)
+    type_check(role_name, str)
+    relative_url = api_url + f"/{realm}/clients/{client_id}/roles/{role_name}"
+    response = delete_request(relative_url=relative_url, is_iam=True)
+    if response.status_code == NO_CONTENT:
+        is_successful = True
+    return is_successful
+
+
+def get_role_by_name(realm: str, client_id: str, role_name: str):
+    """
+
+    Args:
+        realm:
+        client_id:
+        role_name:
+
+    Returns:
+        dict
+        example
+        {
+            "id": "35334ef1-989c-4c08-aaf9-3c4e2c4e6e9e",
+            "name": "test111111111",
+            "composite": false,
+            "clientRole": true,
+            "containerId": "d3b60524-13a1-431a-a703-1d6d3d09f512",
+            "attributes": {
+                "creator": [
+                    "happy_yang"
+                ],
+                "lastUpdate": [
+                    "1737608480336"
+                ]
+            }
+        }
+    """
+    type_check(realm, str)
+    type_check(client_id, str)
+    type_check(role_name, str)
+    relative_url = api_url + f"/{realm}/clients/{client_id}/roles/{role_name}"
+    response = get_request(relative_url=relative_url, is_iam=True)
+    response = response.json()
+    return response
+
+
+def update_role_by_id(realm: str, role_id: str, role_representation: RoleRepresentation):
+    """
+
+    Args:
+        realm (str):
+        role_id (str):
+        role_representation (RoleRepresentation):
+            {"attributes": {"type": ["Role"], "category": ["Composite role"], "creator": ["happy_yang"],
+                        "lastUpdate": ["1737608480336"]}, "clientRole": true, "composite": true,
+         "containerId": "d3b60524-13a1-431a-a703-1d6d3d09f512", "id": "35334ef1-989c-4c08-aaf9-3c4e2c4e6e9e",
+         "name": "test111111111"}
+    Returns:
+        bool
+    """
+    is_successful = False
+    relative_url = api_url + f"/{realm}/roles-by-id/{role_id}"
+    data = json.dumps(role_representation.to_dict())
+    response = put_request(relative_url=relative_url, data=data, is_iam=True)
+    if response.status_code == NO_CONTENT:
+        is_successful = True
+    return is_successful
+
+
+def get_roles_children(realm: str, role_id: str):
+    """
+        Get role’s children Returns a set of role’s children provided the role is a composite.
+    Args:
+        realm:
+        role_id:
+
+    Returns:
+        dict
+    """
+    relative_url = api_url + f"/{realm}/roles-by-id/{role_id}/composites"
+    response = get_request(relative_url=relative_url, is_iam=True)
+    response = response.json()
+    return response
+
+
+def add_children_to_a_composite_role(realm: str, role_id: str, children: List[RoleRepresentation]):
+    """
+
+    Args:
+        realm (str):
+        role_id (str):
+        children (str): [{"clientRole": true, "composite": true, "containerId": "d3b60524-13a1-431a-a703-1d6d3d09f512",
+          "description": "Scan, manage results, manage projects", "id": "260f1dba-9ac4-451d-bd9f-4f2249e0ae7d",
+          "name": "ast-scanner"}]
+
+    Returns:
+        bool
+    """
+    is_successful = False
+    relative_url = api_url + f"/{realm}/roles-by-id/{role_id}/composites"
+    data = json.dumps([role_representation.to_dict() for role_representation in children])
+    response = post_request(relative_url=relative_url, data=data, is_iam=True)
+    if response.status_code == NO_CONTENT:
+        is_successful = True
+    return is_successful
+
+
+def get_all_roles_for_the_realm(realm):
+    type_check(realm, str)
+    relative_url = api_url + f"/{realm}/roles"
+    response = get_request(relative_url=relative_url, is_iam=True)
+    response = response.json()
+    return response