import re import time import demistomock as demisto # noqa: F401 # IMPORTS # Disable insecure warnings import urllib3 from CommonServerPython import * # noqa: F401 urllib3.disable_warnings() """PARAMETERS""" class Client(BaseClient): """ Client will implement the service API, and should not contain any Demisto logic. Should only do requests and return data. """ def __init__(self, token_retrieval_url, data, app_id, use_ssl, proxy): headers = {"X-CENTRIFY-NATIVE-CLIENT": "true"} super().__init__(base_url=token_retrieval_url, headers=headers, verify=use_ssl, proxy=proxy) self.payload = data self.app_id = app_id def http_request(self, *args, headers=None, **kwargs): """ Overrides Base client request function, retrieves and adds to headers access token before sending the request. Returns: requests.Response: The http response """ bearer_token = "Bearer " + str(self.authenticate_oauth()) default_headers = {"content-type": "application/json", "Authorization": bearer_token, "X-CENTRIFY-NATIVE-CLIENT": "true"} if headers: default_headers.update(headers) return super()._http_request(*args, headers=default_headers, **kwargs) # type: ignore[misc] def authenticate_oauth(self): """ Login using the credentials and store the cookie """ integration_context = demisto.getIntegrationContext() bearer_token = integration_context.get("bearer_token") valid_until = integration_context.get("valid_until") time_now = int(time.time()) if bearer_token and valid_until and time_now < valid_until: # Bearer Token is still valid - did not expire yet return bearer_token response = self.get_token_request() bearer_token = response.get("access_token") t = time.time() expiration_time = t + 1800 integration_context = { "bearer_token": bearer_token, "valid_until": expiration_time, # Assuming the expiration time is 30 minutes } demisto.setIntegrationContext(integration_context) return bearer_token def get_token_request(self): """ Sends token request :rtype ``str`` :return: bearer token """ urlSuffix = "/oauth2/token/" + self.app_id fullUrl = f"{self._base_url}{urlSuffix}" body = self.payload headers = {"X-CENTRIFY-NATIVE-CLIENT": "true"} token_response = self._http_request(method="POST", full_url=fullUrl, url_suffix="", data=body, headers=headers) if not token_response: err_msg = ( "Authorization Error: User has no authorization to create a token." " Please make sure you entered the credentials correctly." ) raise Exception(err_msg) return token_response def request_secret_set_id(self, url_suffix, data): return self.http_request(method="POST", url_suffix=url_suffix, json_data=data) def request_set_details(self, url_suffix, data): return self.http_request(method="POST", url_suffix=url_suffix, json_data=data) def request_delete_set(self, url_suffix, data): return self.http_request(method="POST", url_suffix=url_suffix, json_data=data) def request_create_set(self, url_suffix, data): return self.http_request(method="POST", url_suffix=url_suffix, json_data=data) def request_fetch_folderids(self, url_suffix, data): return self.http_request(method="POST", url_suffix=url_suffix, json_data=data) def request_fetch_secret_folder_id(self, url_suffix, data): return self.http_request(method="POST", url_suffix=url_suffix, json_data=data) def request_delete_folder(self, url_suffix, data): return self.http_request(method="POST", url_suffix=url_suffix, json_data=data) def request_create_folder(self, url_suffix, data): return self.http_request(method="POST", url_suffix=url_suffix, json_data=data) def request_fetch_secret(self, url_suffix, data): return self.http_request(method="POST", url_suffix=url_suffix, json_data=data) def request_fetch_secretids_set(self, url_suffix, data): return self.http_request(method="POST", url_suffix=url_suffix, json_data=data) def request_fetch_secretids_folder(self, url_suffix, data): return self.http_request(method="POST", url_suffix=url_suffix, json_data=data) def request_delete_secret(self, url_suffix, data): return self.http_request(method="POST", url_suffix=url_suffix, json_data=data) def request_add_secret_set(self, url_suffix, data): return self.http_request(method="POST", url_suffix=url_suffix, json_data=data) def request_create_secret(self, url_suffix, data): return self.http_request(method="POST", url_suffix=url_suffix, json_data=data) """Demisto Output Entry""" def create_entry(title, data): md = ( tableToMarkdown(title, data, ["FolderName", "SecretName", "SecretText", "SecretType", "SecretDescription"]) if data else "No result were found" ) if data: ec = { "Centrify.Secrets(val.SecretName && val.SecretName == obj.SecretName && val.FolderName &&" " val.FolderName == obj.FolderName)": data } return { "ContentsFormat": formats["json"], "Type": entryTypes["note"], "Contents": data, "ReadableContentsFormat": formats["markdown"], "HumanReadable": md, "EntryContext": ec, } else: return "No secrets were found" def test_module(client: Client): """test function Args: client: Returns: ok if successful """ try: client.authenticate_oauth() except Exception as e: raise DemistoException(f"Test failed. Please check your parameters. \n {e}") return "ok" """Fetches the Centrify set id for the setname provided""" def fetch_secret_set_id(client: Client, setName): urlSuffix = "/Collection/GetObjectCollectionsAndFilters" payload = {"ObjectType": "DataVault", "CollectionType": "ManualBucket"} centrify_setid_response = client.request_secret_set_id(url_suffix=urlSuffix, data=payload) for set_item in centrify_setid_response.get("Result").get("Results"): if set_item.get("Row").get("Name") == setName: return set_item.get("Row").get("ID") return "set name not found" """Fetches the secret id's list for the setid provided""" def fetch_secretids_set(client: Client, set_id, secret_ids_list): urlSuffix = "/Collection/GetMembers" payload = {"ID": set_id} centrify_secretids_response = client.request_fetch_secretids_set(url_suffix=urlSuffix, data=payload) for secret_id_item in centrify_secretids_response.get("Result"): secret_ids_list.append(secret_id_item["Key"]) return secret_ids_list """Fetches the Centrify folder id for the foldername provided""" def fetch_secret_folder_id(client: Client, folderName): urlSuffix = "/ServerManage/GetSecretFolder" payload = {"Name": folderName} centrify_folderid_response = client.request_fetch_secret_folder_id(url_suffix=urlSuffix, data=payload) return centrify_folderid_response.get("Result").get("Results")[0].get("Row").get("ID") """Fetches the secret id's list recurrsively for the folderid provided""" def fetch_secretids_folder(client: Client, folder_id, secret_ids_list, recursive): urlSuffix = "/ServerManage/GetSecretsAndFolders" payload = {"Parent": folder_id} centrify_secretids_response = client.request_fetch_secretids_folder(url_suffix=urlSuffix, data=payload) secret_ids_count = centrify_secretids_response.get("Result").get("FullCount") for secret_id_item in range(secret_ids_count): if centrify_secretids_response.get("Result").get("Results")[secret_id_item].get("Row").get("Type") == "Text": secret_ids_list.append(centrify_secretids_response.get("Result").get("Results")[secret_id_item].get("Row").get("ID")) else: if recursive: sub_folder_id = centrify_secretids_response.get("Result").get("Results")[secret_id_item].get("Row").get("ID") fetch_secretids_folder(client, sub_folder_id, secret_ids_list, recursive) else: pass return secret_ids_list """Fetches details of all the sets in Centrify Vault""" def fetch_set_details(client: Client, set_details_list): urlSuffix = "/Collection/GetObjectCollectionsAndFilters" payload = {"ObjectType": "DataVault", "CollectionType": "ManualBucket"} centrify_setdetails_response = client.request_set_details(url_suffix=urlSuffix, data=payload) centrify_setdetails_response = centrify_setdetails_response.get("Result").get("Results") for set_item in centrify_setdetails_response: set_description = set_item["Row"].get("Description", "") set_details_list.append( {"SetName": set_item["Row"]["Name"], "SetID": set_item["Row"]["ID"], "SetDescription": set_description} ) return set_details_list """Fetches the centrify secret details for the secret response received through the fetch_secret() method""" def centrify_secret_details(centrify_secret): CENTRIFY_VAULT = {} CENTRIFY_VAULT["FolderName"] = centrify_secret.get("Result").get("ParentPath") CENTRIFY_VAULT["SecretName"] = centrify_secret.get("Result").get("SecretName") CENTRIFY_VAULT["SecretID"] = centrify_secret.get("Result").get("_RowKey") CENTRIFY_VAULT["SecretText"] = centrify_secret.get("Result").get("SecretText") CENTRIFY_VAULT["SecretType"] = centrify_secret.get("Result").get("Type") if "Description" in centrify_secret.get("Result"): CENTRIFY_VAULT["SecretDescription"] = centrify_secret.get("Result").get("Description") else: CENTRIFY_VAULT["SecretDescription"] = "" return CENTRIFY_VAULT """Fetches the centrify secret details for the secret id and name(optional) provided""" def fetch_secret(client: Client, secret_id, secret_name, regex_match): urlSuffix = "/ServerManage/RetrieveDataVaultItemContents" payload = {"ID": secret_id} centrify_secret_response = client.request_fetch_secret(url_suffix=urlSuffix, data=payload) if secret_name: if regex_match: if re.search(secret_name, centrify_secret_response.get("Result").get("SecretName"), re.IGNORECASE): CENTRIFY_VAULT = centrify_secret_details(centrify_secret_response) else: return None else: if secret_name == centrify_secret_response.get("Result").get("SecretName"): CENTRIFY_VAULT = centrify_secret_details(centrify_secret_response) else: return None else: CENTRIFY_VAULT = centrify_secret_details(centrify_secret_response) return CENTRIFY_VAULT """Fetches details of all folders in list recurrsively""" def fetch_folderids(client: Client, folder_id, folders_list): urlSuffix = "/ServerManage/GetSecretsAndFolders" payload = {"Parent": folder_id} centrify_folderids_response = client.request_fetch_folderids(url_suffix=urlSuffix, data=payload) folder_ids_count = centrify_folderids_response.get("Result").get("FullCount") for folder_id_item in range(folder_ids_count): if centrify_folderids_response.get("Result").get("Results")[folder_id_item].get("Row").get("Type") == "Folder": folder_res = centrify_folderids_response.get("Result").get("Results")[folder_id_item].get("Row") if folder_res.get("ParentPath"): folder_directory = folder_res.get("ParentPath") + "\\" + folder_res.get("Name") else: folder_directory = folder_res.get("Name") folders_list.append( { "FolderName": folder_res.get("Name"), "FolderID": folder_res.get("ID"), "ParentFolder": folder_res.get("ParentPath"), "FolderDescription": folder_res.get("Description"), "FolderDirectory": folder_directory, } ) sub_folder_id = folder_res.get("ID") fetch_folderids(client, sub_folder_id, folders_list) else: pass return folders_list """Creates a centrify folder for the foldername, description and parent foldername(optional) provided""" def create_folder(client: Client, folderName, description, parent_id): urlSuffix = "/ServerManage/AddSecretsFolder" payload = {"Name": folderName, "Description": description, "Parent": parent_id} centrify_folder_response = client.request_create_folder(url_suffix=urlSuffix, data=payload) if centrify_folder_response.get("success") is True: return "Folder Created", centrify_folder_response.get("Result") else: return centrify_folder_response.get("MessageID"), "No Folder ID" """Creates a centrify set for the setname provided""" def create_set(client: Client, setName, description): urlSuffix = "/Collection/CreateManualCollection" payload = {"ObjectType": "DataVault", "Name": setName, "Description": description} centrify_set_response = client.request_create_set(url_suffix=urlSuffix, data=payload) if centrify_set_response.get("success") is True: return "Set Created", centrify_set_response.get("Result") else: return centrify_set_response.get("Message"), "No Set ID" """Creates a centrify secret in the folder for the provided foldername, secrettext, secrettype""" def create_secret(client: Client, folderId, secret_name, secret_text, secret_type, secret_description): urlSuffix = "/ServerManage/AddSecret" payload = { "SecretName": secret_name, "SecretText": secret_text, "Type": secret_type, "FolderId": folderId, "Description": secret_description, } centrify_secret_response = client.request_create_secret(url_suffix=urlSuffix, data=payload) if centrify_secret_response.get("success") is True: return "Secret Created", centrify_secret_response.get("Result") else: return centrify_secret_response.get("MessageID"), "No Secret ID" """Adds a secret to the set for the provided setid, secretid""" def add_secret_set(client: Client, setId, secretId): urlSuffix = "/Collection/UpdateMembersCollection" payload = {"id": setId, "add": [{"MemberType": "Row", "Table": "DataVault", "Key": secretId}]} add_secretset_response = client.request_add_secret_set(url_suffix=urlSuffix, data=payload) if add_secretset_response.get("success") is True: return "Secret added to the set" else: return "Failed to add secret to the set" """deletes a folder from the vault for the provided folderid""" def delete_folder(client: Client, folderId): urlSuffix = "/ServerManage/DeleteSecretsFolder" payload = {"ID": folderId} delete_folder_response = client.request_delete_folder(url_suffix=urlSuffix, data=payload) if delete_folder_response.get("success") is True: return "Folder Deleted" else: return "Failed to delete the folder" """deletes a set from the vault for the provided setid""" def delete_set(client: Client, setId): urlSuffix = "/Collection/DeleteCollection" payload = {"ID": setId} delete_set_response = client.request_delete_set(url_suffix=urlSuffix, data=payload) if delete_set_response.get("success") is True: return "Set Deleted" else: return "Failed to delete the Set" """deletes a secret the vault for the provided secretid""" def delete_secret(client: Client, secretId): urlSuffix = "/ServerManage/DeleteSecret" payload = {"ID": secretId} delete_secret_response = client.request_delete_secret(url_suffix=urlSuffix, data=payload) if delete_secret_response.get("success") is True: return "Secret Deleted" else: return "Failed to delete the Secret" def fetch_secrets(args: dict, client: Client): try: holder_type = args.get("holderType") secret_name = args.get("secretName") secret_ids_list: list = [] if holder_type == "Set": set_name = args.get("holderName") setId = fetch_secret_set_id(client, set_name) if setId == "set name not found": return_error("Set name not found. Please provide a valid set name") else: secret_ids_list = fetch_secretids_set(client, setId, secret_ids_list) elif holder_type == "Folder": folder_name = args.get("holderName") if folder_name: folder_id = fetch_secret_folder_id(client, folder_name) secret_ids_list = fetch_secretids_folder(client, folder_id, secret_ids_list, True) else: folder_id = "" secret_ids_list = fetch_secretids_folder(client, folder_id, secret_ids_list, True) else: folder_id = "" secret_ids_list = fetch_secretids_folder(client, folder_id, secret_ids_list, True) secret_list = [] for secret_id in secret_ids_list: secret_list.append(fetch_secret(client, secret_id, secret_name, True)) secret_list = list(filter(None, secret_list)) return create_entry("Secrets in the Folder/Set", secret_list) except Exception as e: return_error("Wrong inputs: Please enter valid foldername/secretname/setname: ", e) def fetch_secret_by_id(args: dict, client: Client): try: secret_id = args.get("secretId") secret_list: list = [] secret_list.append(fetch_secret(client, secret_id, None, None)) return create_entry("Secrets through the Secret ID", secret_list) except Exception as e: return_error("Wrong inputs: ", e) def create_secret_folder(args: dict, client: Client): try: folder_name = args.get("folderName") parent_folder_name = args.get("parentFolderName") folder_description = args.get("folderDescription") if not folder_description: folder_description = "" if parent_folder_name: parent_folder_id = fetch_secret_folder_id(client, parent_folder_name) else: parent_folder_id = "" status, folder_id = create_folder(client, folder_name, folder_description, parent_folder_id) if status == "Folder Created": CENTRIFY_VAULT = {} CENTRIFY_VAULT["FolderName"] = folder_name CENTRIFY_VAULT["FolderID"] = folder_id CENTRIFY_VAULT["ParentFolderName"] = parent_folder_name if folder_description: CENTRIFY_VAULT["FolderDescription"] = folder_description else: CENTRIFY_VAULT["FolderDescription"] = "" fcreate = [CENTRIFY_VAULT] md = ( tableToMarkdown(status, fcreate, ["FolderName", "FolderID", "ParentFolderName", "FolderDescription"]) if fcreate else "No result were found" ) ec = { "Centrify.Folder(val.FolderName && val.FolderName == obj.FolderName && val.ParentFolderName &&" " val.ParentFolderName == obj.ParentFolderName)": fcreate } return { "ContentsFormat": formats["json"], "Type": entryTypes["note"], "Contents": fcreate, "ReadableContentsFormat": formats["markdown"], "HumanReadable": md, "EntryContext": ec, } else: return "No result were found: " + status except Exception as e: return_error("Wrong inputs: ", e) def create_vault_secret(args: dict, client: Client): try: holder_type = args.get("holderType") secret_name = args.get("secretName") secret_text = args.get("secretText") secret_type = args.get("secretType") secret_description = args.get("secretDescription") if not secret_description: secret_description = "" folder_id = "" if holder_type == "Folder": folder_name = args.get("holderName") folder_id = fetch_secret_folder_id(client, folder_name) else: setId_list = [] set_name_list = [] if ";" in str(args.get("holderName")): set_name_list = str(args.get("holderName")).split(";") for set_item in set_name_list: set_name = set_item set_id = fetch_secret_set_id(client, set_name) setId_list.append(set_id) else: set_name = str(args.get("holderName")) set_name_list.append(set_name) setId_list.append(fetch_secret_set_id(client, set_name)) if "set name not found" in setId_list: return_error("Set name not found. Please provide a valid set name") status, secret_id = create_secret(client, folder_id, secret_name, secret_text, secret_type, secret_description) if status == "Secret Created": CENTRIFY_VAULT = {} CENTRIFY_VAULT["holderType"] = holder_type if holder_type == "Folder": CENTRIFY_VAULT["FolderName"] = folder_name CENTRIFY_VAULT["FolderID"] = folder_id else: CENTRIFY_VAULT["SetName"] = set_name_list CENTRIFY_VAULT["SetID"] = setId_list for set_id in setId_list: add_secret_set(client, set_id, secret_id) CENTRIFY_VAULT["SecretName"] = secret_name CENTRIFY_VAULT["SecretID"] = secret_id CENTRIFY_VAULT["SecretType"] = secret_type CENTRIFY_VAULT["SecretDescription"] = secret_description screate = [CENTRIFY_VAULT] md = ( tableToMarkdown( status, screate, ["SecretName", "FolderName", "SetName", "SecretType", "SecretID", "SecretDescription"] ) if screate else "No result were found" ) ec = {"Centrify.Secrets(val.SecretID && val.SecretID == obj.SecretID)": screate} return { "ContentsFormat": formats["json"], "Type": entryTypes["note"], "Contents": screate, "ReadableContentsFormat": formats["markdown"], "HumanReadable": md, "EntryContext": ec, } else: return "No result were found: " + status except Exception as e: return_error("Wrong inputs. Please provide valid foldername/setname ", e) def create_vault_set(args: dict, client: Client): try: set_name = args.get("setName") set_description = args.get("setDescription") if not set_description: set_description = "" status, set_id = create_set(client, set_name, set_description) if status == "Set Created": CENTRIFY_VAULT = {} CENTRIFY_VAULT["SetName"] = set_name CENTRIFY_VAULT["SetID"] = set_id if set_description: CENTRIFY_VAULT["SetDescription"] = set_description else: CENTRIFY_VAULT["SetDescription"] = "" set_create = [CENTRIFY_VAULT] md = ( tableToMarkdown(status, set_create, ["SetName", "SetID", "SetDescription"]) if set_create else "No result were found" ) ec = {"Centrify.Set(val.SetID && val.SetID == obj.SetID)": set_create} return { "ContentsFormat": formats["json"], "Type": entryTypes["note"], "Contents": set_create, "ReadableContentsFormat": formats["markdown"], "HumanReadable": md, "EntryContext": ec, } else: return "No result were found: " + status except Exception as e: return_error(e) def fetch_vault_folders(args: dict, client: Client): try: folders_list: list = [] folders_list = fetch_folderids(client, "", folders_list) if folders_list: md = ( tableToMarkdown( "List of all folders", folders_list, ["FolderName", "FolderID", "ParentFolder", "FolderDescription", "FolderDirectory"], ) if folders_list else "No result were found" ) ec = {"Centrify.Folder(val.FolderID && val.FolderID == obj.FolderID)": folders_list} return { "ContentsFormat": formats["json"], "Type": entryTypes["note"], "Contents": folders_list, "ReadableContentsFormat": formats["markdown"], "HumanReadable": md, "EntryContext": ec, } else: return "No result were found: No folders found" except Exception as e: return_error(e) def fetch_vault_set(args: dict, client: Client): try: set_details_list: list = [] set_details_list = fetch_set_details(client, set_details_list) if set_details_list: md = ( tableToMarkdown("List of all sets", set_details_list, ["SetName", "SetID", "SetDescription"]) if set_details_list else "No result were found" ) ec = {"Centrify.Set(val.SetID && val.SetID == obj.SetID)": set_details_list} return { "ContentsFormat": formats["json"], "Type": entryTypes["note"], "Contents": set_details_list, "ReadableContentsFormat": formats["markdown"], "HumanReadable": md, "EntryContext": ec, } else: return "No result were found: No sets found" except Exception as e: return_error(e) def add_vault_secret_set(args: dict, client: Client): try: set_name = args.get("setName") secret_id = args.get("secretId") set_id = fetch_secret_set_id(client, set_name) if set_id == "set name not found": return_error("Set name not found. Please provide a valid set name") else: status = add_secret_set(client, set_id, secret_id) return status except Exception as e: return_error(e) """New code started""" def delete_vault_secret(args: dict, client: Client): try: folder_name = args.get("folderName") secret_name = args.get("secretName") recursive_delete = args.get("recursiveDelete") regex_match = args.get("matchPartOfSecret") if regex_match == "Yes": regex_match = True else: regex_match = False if folder_name: folder_id = fetch_secret_folder_id(client, folder_name) else: folder_id = "" secret_ids_list: list = [] if recursive_delete == "Yes": recursive_delete = True else: recursive_delete = False secret_ids_list = fetch_secretids_folder(client, folder_id, secret_ids_list, recursive_delete) delete_secret_id_list: list = [] for secret_id in secret_ids_list: secret_item = fetch_secret(client, secret_id, secret_name, regex_match) if secret_item: delete_secret(client, secret_item.get("SecretID")) delete_secret_id_list.append(secret_item) if delete_secret_id_list: md = ( tableToMarkdown("List of Secrets deleted", delete_secret_id_list, ["SecretName", "SecretID", "FolderName"]) if delete_secret_id_list else "No secrets were deleted" ) return { "ContentsFormat": formats["json"], "Type": entryTypes["note"], "Contents": delete_secret_id_list, "ReadableContentsFormat": formats["markdown"], "HumanReadable": md, } else: return "No result were found: No secrets were deleted" except Exception as e: return_error("Please enter a valid secretname/foldername: ", e) def delete_vault_secretid(args: dict, client: Client): try: secret_id = args.get("secretId") delete_secret_id_list = [] delete_secret_id_list.append(fetch_secret(client, secret_id, None, None)) delete_secret(client, secret_id) if delete_secret_id_list: md = ( tableToMarkdown("Secrets deleted", delete_secret_id_list, ["SecretName", "SecretID", "FolderName"]) if delete_secret_id_list else "No secrets were deleted" ) return { "ContentsFormat": formats["json"], "Type": entryTypes["note"], "Contents": delete_secret_id_list, "ReadableContentsFormat": formats["markdown"], "HumanReadable": md, } else: return "No result were found: No secrets were deleted" except Exception as e: return_error("Please enter a valid secretname/foldername: ", e) def delete_vault_folder(args: dict, client: Client): try: folder_name = args.get("folderName") parent_name = args.get("parentFolderName") if parent_name: folder_name = parent_name + "/" + folder_name folder_id = fetch_secret_folder_id(client, folder_name) delete_status = delete_folder(client, folder_id) if delete_status == "Folder Deleted": return str(folder_name) + " : " + str(delete_status) else: return "No result were found: No folders found to be deleted" except Exception as e: return_error("Please enter a valid foldername: ", e) def delete_vault_set(args: dict, client: Client): try: set_name = args.get("setName") set_id = fetch_secret_set_id(client, set_name) if set_id == "set name not found": return "No result were found: Please enter a valid setname" else: delete_status = delete_set(client, set_id) if delete_status == "Set Deleted": return str(set_name) + " : " + str(delete_status) else: return "No result were found: No sets found to be deleted" except Exception as e: return_error("Please enter a valid setname: ", e) def main(): """ PARSE AND VALIDATE INTEGRATION PARAMS """ tenant_url = demisto.params().get("tenantUrl", "").rstrip("/") client_id = demisto.params().get("clientId") client_secret = demisto.params().get("clientSecret") scope = demisto.params().get("scope") app_id = demisto.params().get("appId") verify_certificate = demisto.params()["insecure"] is False proxy = demisto.params().get("proxy", False) payload = {"grant_type": "client_credentials", "client_id": client_id, "client_secret": client_secret, "scope": scope} try: client = Client(tenant_url, payload, app_id, verify_certificate, proxy) command = demisto.command() args = demisto.args() LOG(f"Command being called is {command}.") result = "" if command == "test-module": result = test_module(client) elif demisto.command() == "centrify-retrieve-secrets": result = fetch_secrets(args, client) elif demisto.command() == "centrify-retrieve-secret-by-secretid": result = fetch_secret_by_id(args, client) elif demisto.command() == "centrify-create-secretfolder": result = create_secret_folder(args, client) elif demisto.command() == "centrify-create-secret": result = create_vault_secret(args, client) elif demisto.command() == "centrify-create-set": result = create_vault_set(args, client) elif demisto.command() == "centrify-retrieve-folders": result = fetch_vault_folders(args, client) elif demisto.command() == "centrify-delete-folder": result = delete_vault_folder(args, client) elif demisto.command() == "centrify-delete-secret": result = delete_vault_secret(args, client) elif demisto.command() == "centrify-delete-secret-by-secretid": result = delete_vault_secretid(args, client) elif demisto.command() == "centrify-add-secret-to-set": result = add_vault_secret_set(args, client) elif command == "centrify-retrieve-sets": result = fetch_vault_set(args, client) elif demisto.command() == "centrify-delete-set": result = delete_vault_set(args, client) demisto.results(result) # Log exceptions except Exception as e: return_error(f"Failed to execute {demisto.command()} command. Error: {e!s}") if __name__ in ("__main__", "builtins"): main()