ark-sdk-python 2.0.4__py3-none-any.whl → 2.0.5__py3-none-any.whl

ark_sdk_python/ark.py

@@ -17,7 +17,7 @@ from ark_sdk_python.actions import ArkAction, ArkCacheAction, ArkConfigureAction
 
 urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
 
-__version__ = '2.0.4'
+__version__ = '2.0.5'
 
 
 def main():

ark_sdk_python/common/connections/ssh/ark_pty_ssh_connection.py

@@ -33,6 +33,7 @@ class ArkPTYSSHConnection(ArkConnection):
         Raises:
             ArkException: _description_
         """
+        # pylint: disable=import-error
         from pexpect import pxssh
 
         if self.__is_connected:

ark_sdk_python/common/connections/ssh/ark_pty_ssh_win_connection.py

@@ -0,0 +1,235 @@
+import os
+import re
+import subprocess
+import threading
+import time
+from shutil import which
+from typing import Any, Final, Optional
+
+from overrides import overrides
+
+from ark_sdk_python.common.connections.ark_connection import ArkConnection
+from ark_sdk_python.common.connections.ssh.ark_ssh_connection import SSH_PORT
+from ark_sdk_python.models import ArkException
+from ark_sdk_python.models.common.connections import ArkConnectionCommand, ArkConnectionDetails, ArkConnectionResult
+
+
+class ArkPTYSSHWinConnection(ArkConnection):
+    __ANSI_COLOR_STRIPPER: Final[Any] = re.compile(r'\x1b[^m]*m|\x1b\[\?2004[hl]')
+    __ANSI_ESCAPE_STRIPPER: Final[Any] = re.compile(r'\x1B\[[0-?]*[ -/]*[@-~]')
+    __PROMPT_REGEX: Final[Any] = re.compile(r"[#$]")
+    __PASSWORD_PROMPT_REGEX: Final[Any] = re.compile(
+        r"(?i)(?:password:)|(?:passphrase for key)|(?:^Please enter your password[\s\S]+.+ >:$)"
+    )
+    __EXIT_MAKRER: Final[str] = '__ARK_RC_MARK__'
+    __DEFAULT_COL_SIZE: Final[int] = 80
+    __DEFAULT_ROW_SIZE: Final[int] = 24
+    __DEFAULT_NONEAGER_TIMEOEUT: Final[float] = 1.0
+    __DEFAULT_PROMPT_OVERALL_TIMEOUT: Final[float] = 20.0
+    __CHAR_SLEEP_TIME: Final[float] = 0.05
+
+    def __init__(self):
+        super().__init__()
+        self.__is_connected: bool = False
+        self.__is_suspended: bool = False
+        self.__pty: Optional[Any] = None
+        self.__output_lock: threading.Lock = threading.Lock()
+        self.__buffer: str = ''
+
+    def __strip_ansi(self, ansi_input: str) -> str:
+        ansi_input = ansi_input.strip()
+        ansi_input = ArkPTYSSHWinConnection.__ANSI_COLOR_STRIPPER.sub('', ansi_input)
+        ansi_input = ArkPTYSSHWinConnection.__ANSI_ESCAPE_STRIPPER.sub('', ansi_input)
+        return ansi_input
+
+    def __reset_buffer(self) -> None:
+        with self.__output_lock:
+            self.__buffer = ''
+
+    def __read_until_latest_prompt(
+        self,
+        password: Optional[str] = None,
+        noneager_timeout: float = __DEFAULT_NONEAGER_TIMEOEUT,
+        overall_timeout: float = __DEFAULT_PROMPT_OVERALL_TIMEOUT,
+        login_prompt: bool = False,
+        expected_prompt: Any = __PROMPT_REGEX,
+    ) -> None:
+        buffer = ''
+        prompt_found_at = -1
+        start_time = time.time()
+        noneager_start_time = start_time
+
+        while True:
+            char = self.__pty.read(1)
+            if not char:
+                if ArkPTYSSHWinConnection.__PASSWORD_PROMPT_REGEX.search(self.__strip_ansi(buffer)) and not password and login_prompt:
+                    raise RuntimeError(f'Password prompt with no password given [{buffer}]')
+                if (time.time() - noneager_start_time > noneager_timeout) and prompt_found_at != -1:
+                    break
+                if (time.time() - start_time) > overall_timeout and prompt_found_at == -1:
+                    raise RuntimeError(f'Timeout while waiting for prompt [{buffer}]')
+                time.sleep(ArkPTYSSHWinConnection.__CHAR_SLEEP_TIME)
+                continue
+
+            buffer += char
+
+            with self.__output_lock:
+                self.__buffer += char
+
+            if ArkPTYSSHWinConnection.__PASSWORD_PROMPT_REGEX.search(self.__strip_ansi(buffer)) and login_prompt:
+                if not password:
+                    raise RuntimeError(f'Password prompt with no password given [{buffer}]')
+                self.__pty.write(password + '\n')
+                buffer = ""
+                prompt_found_at = -1
+                continue
+
+            if expected_prompt.search(buffer):
+                prompt_found_at = len(buffer)
+
+            noneager_start_time = time.time()
+
+        if prompt_found_at != -1:
+            with self.__output_lock:
+                self.__buffer = buffer
+
+    @overrides
+    def connect(self, connection_details: ArkConnectionDetails) -> None:
+        """
+        Performs SSH connection with given details or keys
+        Saves the ssh session to be used for command executions
+        Done using windows pty
+
+        Args:
+            connection_details (ArkConnectionDetails): _description_
+
+        Raises:
+            ArkException: _description_
+        """
+        # pylint: disable=import-error
+        import winpty
+
+        if self.__is_connected:
+            return
+
+        address = connection_details.address
+        user = connection_details.credentials.user
+        port = connection_details.port or SSH_PORT
+        password = None
+        key_path = None
+        if connection_details.credentials.password:
+            password = connection_details.credentials.password.get_secret_value()
+        elif connection_details.credentials.private_key_filepath:
+            key_path = connection_details.credentials.private_key_filepath
+
+        ssh_args = [f'{user}@{address}', '-p', str(port), '-o', 'StrictHostKeyChecking=no']
+        if key_path:
+            ssh_args.extend(['-i', str(key_path)])
+        try:
+            self.__pty = winpty.PTY(
+                cols=ArkPTYSSHWinConnection.__DEFAULT_COL_SIZE,
+                rows=ArkPTYSSHWinConnection.__DEFAULT_ROW_SIZE,
+                backend=winpty.enums.Backend.WinPTY,
+            )
+            ssh_full_cmd = which('ssh', path=os.environ.get('PATH', os.defpath))
+            self.__pty.spawn(ssh_full_cmd, cmdline=' ' + subprocess.list2cmdline(ssh_args))
+            self.__read_until_latest_prompt(password, login_prompt=True)
+            self.__is_connected = True
+        except Exception as ex:
+            raise ArkException(f'Failed to ssh connect [{str(ex)}]') from ex
+
+    @overrides
+    def disconnect(self) -> None:
+        """
+        Disconnects the ssh session
+        """
+        if self.__pty:
+            self.__pty.write('exit\n')
+            self.__pty = None
+        self.__is_connected = False
+        self.__is_suspended = False
+
+    @overrides
+    def suspend_connection(self) -> None:
+        """
+        Suspends execution of ssh commands
+        """
+        self.__is_suspended = True
+
+    @overrides
+    def restore_connection(self) -> None:
+        """
+        Restores execution of ssh commands
+        """
+        self.__is_suspended = False
+
+    @overrides
+    def is_suspended(self) -> bool:
+        """
+        Checks whether ssh commands can be executed or not
+
+        Returns:
+            bool: _description_
+        """
+        return self.__is_suspended
+
+    @overrides
+    def is_connected(self) -> bool:
+        """
+        Checks whether theres a ssh session connected
+
+        Returns:
+            bool: _description_
+        """
+        return self.__is_connected
+
+    @overrides
+    def run_command(self, command: ArkConnectionCommand) -> ArkConnectionResult:
+        """
+        Runs a command over ssh session via pty, returning the result accordingly
+        stderr is not supported, only stdout is returned, and it'll contain everything including stderr
+
+        Args:
+            command (ArkConnectionCommand): _description_
+
+        Raises:
+            ArkException: _description_
+
+        Returns:
+            ArkConnectionResult: _description_
+        """
+        if not self.__is_connected or self.__is_suspended:
+            raise ArkException('Cannot run command while not connected or suspended')
+
+        self._logger.debug(f'Running command [{command.command}]')
+
+        self.__reset_buffer()
+        self.__pty.write(command.command + "\n")
+        self.__read_until_latest_prompt()
+
+        with self.__output_lock:
+            stdout = self.__buffer.strip()
+
+        self.__reset_buffer()
+        self.__pty.write(f'echo {ArkPTYSSHWinConnection.__EXIT_MAKRER}_$?;\n')
+        self.__read_until_latest_prompt()
+
+        with self.__output_lock:
+            lines = self.__buffer.strip().splitlines()
+
+        rc = None
+        for line in lines:
+            line = self.__strip_ansi(line)
+            if line.startswith(f'{ArkPTYSSHWinConnection.__EXIT_MAKRER}_'):
+                try:
+                    rc = int(line[len(ArkPTYSSHWinConnection.__EXIT_MAKRER) + 1 :])  # +1 for the underscore
+                    break
+                except ValueError:
+                    continue
+        if rc is None:
+            raise ArkException(f"Failed to parse exit code from output - [{self.__buffer}]")
+        if rc != command.expected_rc and command.raise_on_error:
+            raise ArkException(f'Failed to execute command [{command.command}] - [{rc}] - [{stdout}]')
+        self._logger.debug(f'Command rc: [{rc}]')
+        self._logger.debug(f'Command stdout: [{stdout}]')
+        return ArkConnectionResult(stdout=stdout, rc=rc)

ark_sdk_python/examples/validate_ssh_connection.py

@@ -1,11 +1,17 @@
 import argparse
+import platform
 import tempfile
 
 from ark_sdk_python.auth import ArkISPAuth
 from ark_sdk_python.common.ark_jwt_utils import ArkJWTUtils
 from ark_sdk_python.common.connections.ssh.ark_pty_ssh_connection import ArkPTYSSHConnection
+from ark_sdk_python.common.connections.ssh.ark_pty_ssh_win_connection import ArkPTYSSHWinConnection
 from ark_sdk_python.models.auth import ArkAuthMethod, ArkAuthProfile, ArkSecret
-from ark_sdk_python.models.auth.ark_auth_method import IdentityServiceUserArkAuthMethodSettings
+from ark_sdk_python.models.auth.ark_auth_method import (
+    ArkAuthMethodsDescriptionMap,
+    IdentityArkAuthMethodSettings,
+    IdentityServiceUserArkAuthMethodSettings,
+)
 from ark_sdk_python.models.common.connections.ark_connection_command import ArkConnectionCommand
 from ark_sdk_python.models.common.connections.ark_connection_credentials import ArkConnectionCredentials
 from ark_sdk_python.models.common.connections.ark_connection_details import ArkConnectionDetails
@@ -13,29 +19,36 @@ from ark_sdk_python.models.services.sia.sso.ark_sia_sso_get_ssh_key import ArkSI
 from ark_sdk_python.services.sia.sso import ArkSIASSOService
 
 
-def login_to_identity_security_platform(service_user: str, service_token: str, application_name: str) -> ArkISPAuth:
+def login_to_identity_security_platform(user: str, secret: str, is_service_user: bool, application_name: str) -> ArkISPAuth:
     """
-    This will perform login to the tenant with the given service user credentials
+    This will perform login to the tenant with the given user credentials
+    Where the user is normal or service user based on the boolean
     Caching the logged in token is disabled and will perform a full login on each call
     Will return an identity security platform authenticated class
 
     Args:
-        service_user (str): _description_
-        service_token (str): _description_
+        user (str): _description_
+        secret (str): _description_
         application_name (str): _description_
 
     Returns:
         ArkISPAuth: _description_
     """
-    print('Logging in to the tenant')
     isp_auth = ArkISPAuth(cache_authentication=False)
+    auth_method = ArkAuthMethod.IdentityServiceUser if is_service_user else ArkAuthMethod.Identity
+    auth_methods_settings = (
+        IdentityServiceUserArkAuthMethodSettings(identity_authorization_application=application_name)
+        if is_service_user
+        else IdentityArkAuthMethodSettings()
+    )
+    print(f'Logging in to the tenant with [{ArkAuthMethodsDescriptionMap[auth_method]}] user type and user [{user}]')
     isp_auth.authenticate(
         auth_profile=ArkAuthProfile(
-            username=service_user,
-            auth_method=ArkAuthMethod.IdentityServiceUser,
-            auth_method_settings=IdentityServiceUserArkAuthMethodSettings(identity_authorization_application=application_name),
+            username=user,
+            auth_method=auth_method,
+            auth_method_settings=auth_methods_settings,
         ),
-        secret=ArkSecret(secret=service_token),
+        secret=ArkSecret(secret=secret),
     )
     print('Logged in successfully')
     return isp_auth
@@ -92,7 +105,10 @@ def connect_and_validate_connection(ssh_key_path: str, proxy_address: str, conne
         command (str): _description_
     """
     print(f'Connecting to proxy [{proxy_address}] and connection string [{connection_string}]')
-    ssh_connection = ArkPTYSSHConnection()
+    if platform.system() == 'Windows':
+        ssh_connection = ArkPTYSSHWinConnection()
+    else:
+        ssh_connection = ArkPTYSSHConnection()
     ssh_connection.connect(
         ArkConnectionDetails(
             address=proxy_address,
@@ -112,8 +128,9 @@ def connect_and_validate_connection(ssh_key_path: str, proxy_address: str, conne
 if __name__ == '__main__':
     # Construct an argument parser for CLI parameters for the script
     parser = argparse.ArgumentParser()
-    parser.add_argument('--service-user', required=True, help='Service user to login and perform the operation with')
-    parser.add_argument('--service-token', required=True, help='Service user token to use for logging in and connecting')
+    parser.add_argument('--user', required=True, help='User to login and perform the operation with')
+    parser.add_argument('--secret', required=True, help='User secret to use for logging in and connecting')
+    parser.add_argument('--is-service-user', action='store_true', help='Whether this user is a service user and not a normal user')
     parser.add_argument(
         '--service-application',
         default='__idaptive_cybr_user_oidc',
@@ -139,7 +156,7 @@ if __name__ == '__main__':
         # - Generate an MFA Caching SSH key
         # - Construct the ssh proxy address
         # - Connect in SSH to the proxy / target with the MFA Caching SSH Key and perform the command
-        isp_auth = login_to_identity_security_platform(args.service_user, args.service_token, args.service_application)
+        isp_auth = login_to_identity_security_platform(args.user, args.secret, args.is_service_user, args.service_application)
         ssh_key_path = generate_mfa_caching_ssh_key(isp_auth, temp_folder)
         proxy_address = construct_ssh_proxy_address(isp_auth)
         connect_and_validate_connection(ssh_key_path, proxy_address, args.connection_string, args.test_command)

{ark_sdk_python-2.0.4.dist-info → ark_sdk_python-2.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ark-sdk-python
-Version: 2.0.4
+Version: 2.0.5
 Summary: Official Ark SDK / CLI for CyberArk Identity Security Platform
 License: Apache-2.0
 Author: CyberArk
@@ -29,13 +29,14 @@ Requires-Dist: keyrings.cryptfile
 Requires-Dist: overrides
 Requires-Dist: packaging
 Requires-Dist: paramiko
-Requires-Dist: pexpect
+Requires-Dist: pexpect ; sys_platform != "win32"
 Requires-Dist: progress
 Requires-Dist: pycryptodome
 Requires-Dist: pydantic (==2.*)
 Requires-Dist: pyhumps
 Requires-Dist: pyjwt
 Requires-Dist: python-dateutil
+Requires-Dist: pywinpty ; sys_platform == "win32"
 Requires-Dist: pywinrm
 Requires-Dist: pyyaml
 Requires-Dist: requests

{ark_sdk_python-2.0.4.dist-info → ark_sdk_python-2.0.5.dist-info}/RECORD

@@ -10,7 +10,7 @@ ark_sdk_python/actions/ark_service_exec_action.py,sha256=IHIm9oISRThOD8WNJe4oJX-
 ark_sdk_python/args/__init__.py,sha256=mCb4UrIRL4u58QyUbqqH2xAU0VN91pxjK5sa_UwCM_k,279
 ark_sdk_python/args/ark_args_formatter.py,sha256=-Rs_rGMIr1bprD1SfYlMsLoSOFgr_RFrRdREvbmPU6k,9204
 ark_sdk_python/args/ark_pydantic_argparse.py,sha256=uupNLnUmO5LrTrRZsBv7qRKgDsx4GaJMwOUh1TCc1-w,40083
-ark_sdk_python/ark.py,sha256=iMgWG48a8PALAEzUFSp1VojhqJTJL8s_xKPQ417EahU,1280
+ark_sdk_python/ark.py,sha256=xWOv-IjEvmYh_rl41EYWAOllXjbAk1wLUtpzgR9SLVI,1280
 ark_sdk_python/ark_api.py,sha256=qEB2j-xf8kiSdAvTXrvEdqGDQ-l1aoEvktxnq7BYNRI,12486
 ark_sdk_python/auth/__init__.py,sha256=1l29Rf3VhwmV8z3YROiQVcgrZYSeeCqVN4zna77tnlk,620
 ark_sdk_python/auth/ark_auth.py,sha256=2fPlABM3AwWmb1h0lQPQAz93u1ZluYKv7axlfg4lq5Q,12988
@@ -43,7 +43,8 @@ ark_sdk_python/common/ark_system_config.py,sha256=cl44cYSgXZEnoRYu048aBeJwWRPdCT
 ark_sdk_python/common/connections/__init__.py,sha256=RyARha6jTeaUw1cIGBSR7nOYxCV3fC24juKb-17yXLw,104
 ark_sdk_python/common/connections/ark_connection.py,sha256=wjYpn_9EJ-B679006VqQREFeTOhINmw-heiRqlpuCnY,1613
 ark_sdk_python/common/connections/ssh/__init__.py,sha256=Ycv3BDI2iw-N7BdRkpAv2Qi90O4bp8sPyNsJnuQLfWo,256
-ark_sdk_python/common/connections/ssh/ark_pty_ssh_connection.py,sha256=GaCdiORXWfMB4Pu5bu1nkNPmjUAU5N3l7qUA6FaQ4WI,4974
+ark_sdk_python/common/connections/ssh/ark_pty_ssh_connection.py,sha256=mhrVYV9vx81lSRXCcPoV3KjxKvMDEZlHEROOB1mynLs,5013
+ark_sdk_python/common/connections/ssh/ark_pty_ssh_win_connection.py,sha256=vAAvJ7AMML66B4GVjsSeqzPlJVrrNK2M34TqeVDYg2k,8557
 ark_sdk_python/common/connections/ssh/ark_ssh_connection.py,sha256=yVtrM_clLScg1uNY-Fextiup59h2AIbKxQQadLfiqpw,5195
 ark_sdk_python/common/connections/winrm/__init__.py,sha256=TX8jEK5BPwvlzgo8lH4sGDcY9oL593rdEutQL4MMra4,164
 ark_sdk_python/common/connections/winrm/ark_winrm_connection.py,sha256=O8ifpvmuzFpvqvjb3wFmg576v5jFZwFHi20wlV2UtwE,6854
@@ -57,7 +58,7 @@ ark_sdk_python/examples/create_sia_vm_environment.py,sha256=omk2mb1yrAU8w3mNSqjH
 ark_sdk_python/examples/default_suffix.py,sha256=GEAnsrVhNdsIZ2YRJd4Xs4HYv86UdmXwPwOs7ajcQIQ,662
 ark_sdk_python/examples/list_pcloud_accounts.py,sha256=Xzq_LIp_woRgCt73w1AMlXbB6P8yNRHr1VGIBCyQswk,810
 ark_sdk_python/examples/session_monitoring_activites.py,sha256=WSGISA4Qye8q22WpiHq0HKYTfbwLK7038mRHp2Kr9IQ,1632
-ark_sdk_python/examples/validate_ssh_connection.py,sha256=hSUtmADqupxEkbKRTvC0MKmJBHfe-PYltVP0u8sHuhQ,6357
+ark_sdk_python/examples/validate_ssh_connection.py,sha256=K9RB8eosbV-5m0Q-gx9YQWrp57D8oLB4jfCgQy44gdU,7094
 ark_sdk_python/models/__init__.py,sha256=2EKDAGANDadQfJrnTjm2Jc7JnINcZOwCRXWHEXmIH6o,1082
 ark_sdk_python/models/actions/__init__.py,sha256=2xPZhoHco50bmPX7rm6uPOAcYURoTP9J5KF4E3XNaFA,743
 ark_sdk_python/models/actions/ark_configure_action_consts.py,sha256=-YNgiGv1GsQx-JvO0eXXrrOlDcH6sRDLdO7kvTHto-M,1143
@@ -479,9 +480,9 @@ ark_sdk_python/services/sia/workspaces/targetsets/__init__.py,sha256=UjHr81LMcMl
 ark_sdk_python/services/sia/workspaces/targetsets/ark_sia_target_sets_workspace_service.py,sha256=o9_DzskTV94kkfc4m0Qk8lj5FV8rexRa5RzRwfe9Tbo,11254
 ark_sdk_python/services/sm/__init__.py,sha256=jzKxEkZYOCW9y_byLfd_odae9m2sh1UfjaaKBVySWY0,95
 ark_sdk_python/services/sm/ark_sm_service.py,sha256=Rh2dFjNz7VMJUnl43hxL07HEZ8_33KrU_lqfUrqUDn4,11517
-ark_sdk_python-2.0.4.dist-info/LICENSE.txt,sha256=d4EzYx2apA3-GqrFY23wLtc6UmQNXG05gyLfZ3oWVRs,11358
-ark_sdk_python-2.0.4.dist-info/METADATA,sha256=VfDRV7q1M3kgtA8eBN79iMwkzLIilCoyfjUyu4xqwAw,20102
-ark_sdk_python-2.0.4.dist-info/NOTICES.md,sha256=cuG6J8u9QVu5ZjYki-McJmoEmi39foN30IxA_2fNnKY,125667
-ark_sdk_python-2.0.4.dist-info/WHEEL,sha256=QymApwX2NnTrOAORdnrvo1YegSC1EN2pJY0mOd9rfdE,110
-ark_sdk_python-2.0.4.dist-info/entry_points.txt,sha256=v5bcuRn8w42ZKQspfvX3AliKmLVO6f7Zb_bma77p3vQ,47
-ark_sdk_python-2.0.4.dist-info/RECORD,,
+ark_sdk_python-2.0.5.dist-info/LICENSE.txt,sha256=d4EzYx2apA3-GqrFY23wLtc6UmQNXG05gyLfZ3oWVRs,11358
+ark_sdk_python-2.0.5.dist-info/METADATA,sha256=Q03rx4A9NT-nI4hG54LBs_9db9vRG-FArJvIAD6DTuw,20178
+ark_sdk_python-2.0.5.dist-info/NOTICES.md,sha256=cuG6J8u9QVu5ZjYki-McJmoEmi39foN30IxA_2fNnKY,125667
+ark_sdk_python-2.0.5.dist-info/WHEEL,sha256=QymApwX2NnTrOAORdnrvo1YegSC1EN2pJY0mOd9rfdE,110
+ark_sdk_python-2.0.5.dist-info/entry_points.txt,sha256=v5bcuRn8w42ZKQspfvX3AliKmLVO6f7Zb_bma77p3vQ,47
+ark_sdk_python-2.0.5.dist-info/RECORD,,