pyntcli 0.1.29__py3-none-any.whl → 0.1.31__py3-none-any.whl

build/lib/build/lib/pyntcli/commands/proxy.py

@@ -0,0 +1,147 @@
+import argparse
+from copy import deepcopy
+import os
+import webbrowser
+from http import HTTPStatus
+import requests
+import time
+from subprocess import Popen, PIPE
+from build.lib.pyntcli.commands import proxy
+
+from pyntcli.store.store import CredStore
+from pyntcli.pynt_docker import pynt_container
+from pyntcli.ui import ui_thread
+from pyntcli.ui.progress import connect_progress_ws, wrap_ws_progress
+from pyntcli.commands import util, sub_command
+
+def proxy_usage():
+    return ui_thread.PrinterText("Command integration to Pynt. Run a security scan with a given command.") \
+        .with_line("") \
+        .with_line("Usage:",style=ui_thread.PrinterText.HEADER) \
+        .with_line("\tpynt command [OPTIONS]") \
+        .with_line("") \
+        .with_line("Options:",style=ui_thread.PrinterText.HEADER) \
+        .with_line("\t--cmd - The command that runs the functional tests") \
+        .with_line("\t--port - Set the port pynt will listen to (DEFAULT: 5001)") \
+        .with_line("\t--allow-errors - If present will allow command to fail and continue execution") \
+        .with_line("\t--ca-path - The path to the CA file in PEM format") \
+        .with_line("\t--proxy-port - Set the port proxied traffic should be routed to (DEFAULT: 6666)") \
+        .with_line("\t--report - If present will save the generated report in this path.") \
+        .with_line("\t--insecure - use when target uses self signed certificates")
+
+
+class ProxyCommand(sub_command.PyntSubCommand): 
+    def __init__(self, name) -> None:
+        super().__init__(name)
+        self.scan_id = ""
+        self.proxy_sleep_interval = 2
+        self.proxy_healthcheck_buffer = 10
+        self.proxy_server_base_url = "http://localhost:{}/api"
+    
+    def print_usage(self, *args):
+        ui_thread.print(proxy_usage())
+
+    def add_cmd(self, parent: argparse._SubParsersAction) -> argparse.ArgumentParser:
+        proxy_cmd = parent.add_parser(self.name)
+        proxy_cmd.add_argument("--port", "-p", help="", type=int, default=5001)
+        proxy_cmd.add_argument("--proxy-port", help="", type=int, default=6666) 
+        proxy_cmd.add_argument("--cmd", help="", default="", required=True)
+        proxy_cmd.add_argument("--allow-errors", action="store_true")
+        proxy_cmd.add_argument("--ca-path", type=str, default="")
+        proxy_cmd.add_argument("--report", type=str, default="")
+        proxy_cmd.print_usage = self.print_usage
+        proxy_cmd.print_help = self.print_usage
+        return proxy_cmd
+    
+    def _updated_environment(self, args):
+        env_copy = deepcopy(os.environ)
+        return env_copy.update({"HTTP_PROXY": "http://localhost:{}".format(args.proxy_port), 
+                                "HTTPS_PROXY": "http://localhost:{}".format(args.proxy_port)})
+    
+    def _start_proxy(self, args):
+        res = requests.put(self.proxy_server_base_url.format(args.port) + "/proxy/start")
+        res.raise_for_status()
+        self.scan_id = res.json()["scanId"]
+    
+    def _stop_proxy(self, args):
+        start = time.time()
+        while start + self.proxy_healthcheck_buffer > time.time(): 
+            res = requests.put(self.proxy_server_base_url.format(args.port) + "/proxy/stop", json={"scanId": self.scan_id})
+            if res.status_code == HTTPStatus.OK: 
+                return 
+            time.sleep(self.proxy_sleep_interval)
+        raise TimeoutError()
+        
+    def _get_report(self, args):
+        while True: 
+            res = requests.get(self.proxy_server_base_url.format(args.port) + "/report", params={"scanId": self.scan_id})
+            if res.status_code == HTTPStatus.OK:
+                return res.text
+            if res.status_code == HTTPStatus.ACCEPTED:
+                time.sleep(self.proxy_sleep_interval)
+                continue
+            if res.status_code == 517: #pynt did not recieve any requests 
+                ui_thread.print(ui_thread.PrinterText(res.json()["message"], ui_thread.PrinterText.WARNING))
+                return 
+            ui_thread.print("Error in polling for scan report: {}".format(res.text))
+            return 
+    
+    def run_cmd(self, args: argparse.Namespace):
+        docker_type, docker_arguments = pynt_container.get_container_with_arguments(pynt_container.PyntDockerPort(args.port, args.port, "--port"), 
+                                                                                    pynt_container.PyntDockerPort(args.proxy_port, args.proxy_port, "--proxy-port"))
+        
+        if "insecure" in args and args.insecure:
+            docker_arguments.append("--insecure")
+
+        if "dev_flags" in args:
+            docker_arguments += args.dev_flags.split(" ")
+        
+        mounts = []
+        if "ca_path" in args and args.ca_path:
+            if not os.path.isfile(args.ca_path):
+                ui_thread.print(ui_thread.PrinterText("Could not find the provided ca path, please provide with a valid path", ui_thread.PrinterText.WARNING))
+                return
+
+            ca_name = os.path.basename(args.ca_path)
+            docker_arguments += ["--ca-path", ca_name]
+            mounts.append(pynt_container.create_mount(os.path.abspath(args.ca_path), "/etc/pynt/{}".format(ca_name)))
+
+        creds_path = CredStore().get_path()
+        mounts.append(pynt_container.create_mount(creds_path, "/app/creds.json"))
+
+        proxy_docker = pynt_container.PyntContainer(image_name=pynt_container.PYNT_DOCKER_IMAGE, 
+                                    tag="proxy-latest", 
+                                    mounts=mounts,
+                                    detach=True, 
+                                    args=docker_arguments)
+        proxy_docker.run(docker_type)
+        ui_thread.print_generator(proxy_docker.stdout)
+        
+        util.wait_for_healthcheck("http://localhost:{}".format(args.port))
+        self._start_proxy(args) 
+
+        user_process = Popen(args.cmd, shell=True, stdout=PIPE, stderr=PIPE, env=self._updated_environment(args))
+        ui_thread.print_generator(user_process.stdout)
+        ui_thread.print_generator(user_process.stderr)
+        rc = user_process.wait()
+        if rc != 0 and not args.allow_errors:
+            proxy_docker.stop()
+            ui_thread.print(ui_thread.PrinterText("Command finished with error return code {}, If you wish Pynt to run anyway, run with --allow-errors".format(rc)))
+            return
+
+        self._stop_proxy(args)
+        
+        report = ""
+        with ui_thread.progress(wrap_ws_progress(connect_progress_ws("ws://localhost:{}/progress?scanId={}".format(args.port, self.scan_id))), "scan in progress..."):
+            report = self._get_report(args)
+            if not report:
+                proxy_docker.stop()
+                return
+            report_path = os.path.join(os.getcwd(), "report_{}.html".format(int(time.time())))
+            if "report" in args and args.report:
+                report_path = os.path.abspath(args.report)
+            with open(report_path, "w") as f:
+                f.write(report)
+
+        webbrowser.open("file://{}".format(report_path))
+        proxy_docker.stop()

build/lib/build/lib/pyntcli/commands/pynt_cmd.py

@@ -0,0 +1,47 @@
+import argparse
+from typing import Dict, List
+
+from . import postman, root, sub_command, id_command, proxy , newman, har
+
+avail_sub_commands = [
+    postman.PostmanSubCommand("postman"),
+    id_command.PyntShowIdCommand("pynt-id"),
+    newman.NewmanSubCommand("newman"),
+    har.HarSubCommand("har"),
+    proxy.ProxyCommand("command"),
+]
+
+class PyntCommandException(Exception):
+    pass
+
+class BadArgumentsException(PyntCommandException):
+    pass
+
+class NoSuchCommandException(PyntCommandException):
+    pass
+
+
+class PyntCommand: 
+    def __init__(self) -> None:
+        self.base: root.BaseCommand = root.BaseCommand()
+        self.sub_commands: Dict[str, sub_command.PyntSubCommand] = {sc.get_name(): sc for sc in avail_sub_commands}
+        self._start_command()
+
+    def _start_command(self):
+        self.base.cmd()
+        for sc in self.sub_commands.values():
+            self.base.add_base_arguments(sc.add_cmd(self.base.get_subparser()))
+
+    def parse_args(self, args_from_cmd: List[str]): 
+        return self.base.cmd().parse_args(args_from_cmd)
+
+    def run_cmd(self, args: argparse.Namespace):
+        if not "command" in args:
+            raise BadArgumentsException()
+        
+        command = getattr(args, "command") 
+        if not command in self.sub_commands:
+            raise NoSuchCommandException()
+    
+        self.base.run_cmd(args)
+        self.sub_commands[command].run_cmd(args)

build/lib/build/lib/pyntcli/commands/root.py

@@ -0,0 +1,57 @@
+import argparse
+import sys
+
+from pyntcli.auth import login
+from pyntcli.ui import ui_thread
+from pyntcli.analytics import send as analytics
+
+def root_usage():
+    return ui_thread.PrinterText("Usage:",style=ui_thread.PrinterText.HEADER) \
+        .with_line("\tpynt [COMMAND] [OPTIONS]") \
+        .with_line("") \
+        .with_line("Commands:",style=ui_thread.PrinterText.HEADER) \
+        .with_line("\tpostman - integration with postman, run scan from pynt postman collection") \
+        .with_line("\tnewman -  run postman collection from the CLI") \
+        .with_line("\tpynt-id - view your pynt-id to use when running pynt in CI pipeline") \
+        .with_line("") \
+        .with_line("Run pynt [COMMAND] -h to get help on a specific command",style=ui_thread.PrinterText.INFO)
+
+def usage(*args):
+    ui_thread.print(root_usage())
+
+class BaseCommand():
+    def __init__(self) -> None:
+        self.base: argparse.ArgumentParser = None
+        self.subparser: argparse._SubParsersAction = None
+
+    def cmd(self):
+        if self.base:
+            return self.base
+        
+        self.base = argparse.ArgumentParser(prog="pynt")
+        self.base.print_usage = usage
+        self.base.print_help = usage
+        return self.base 
+   
+    def add_base_arguments(self, parser):
+        parser.add_argument("--insecure", default=False, required=False, action='store_true',help="use when target uses self signed certificates")
+        parser.add_argument("--dev-flags", type=str,default="",  help=argparse.SUPPRESS)
+
+    def get_subparser(self) -> argparse._SubParsersAction:
+        if self.subparser is None:
+            self.subparser = self.base.add_subparsers(help="", dest="command")
+        
+        return self.subparser
+
+    def run_cmd(self, args: argparse.Namespace):
+        analytics.emit(analytics.LOGIN_START)
+
+        if login.should_login():
+            l = login.Login().login()
+        else:
+            login.refresh_token()  
+        
+        analytics.emit(analytics.LOGIN_DONE)
+        user_id = login.user_id()
+        if user_id:
+            analytics.set_user_id(user_id)

build/lib/build/lib/pyntcli/commands/sub_command.py

@@ -0,0 +1,15 @@
+import argparse
+
+class PyntSubCommand:
+    def __init__(self, name) -> None:
+        self.name = name
+        pass 
+
+    def get_name(self):
+        return self.name
+    
+    def add_cmd(self, parent: argparse._SubParsersAction) -> argparse.ArgumentParser: 
+        raise NotImplemented()
+    
+    def run_cmd(self, args: argparse.Namespace): 
+        raise NotImplemented()

build/lib/build/lib/pyntcli/commands/util.py

@@ -0,0 +1,26 @@
+import requests
+import time
+import socket
+
+def is_port_in_use(port: int) -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        return s.connect_ex(('localhost', port)) == 0
+
+def find_open_port() -> int:
+    with socket.socket() as s:
+        s.bind(('', 0))            
+        return s.getsockname()[1] 
+
+HEALTHCHECK_TIMEOUT = 10
+HEALTHCHECK_INTERVAL = 2
+
+def wait_for_healthcheck(address): 
+    start = time.time()
+    while start + HEALTHCHECK_TIMEOUT > time.time(): 
+        try:
+            res = requests.get(address + "/healthcheck")
+            if res.status_code == 418:
+                return 
+        except: 
+            time.sleep(HEALTHCHECK_INTERVAL)
+    raise TimeoutError()

build/lib/build/lib/pyntcli/main.py

@@ -0,0 +1,77 @@
+from sys import argv, exit
+import signal
+
+from pyntcli import __version__ as cli_version
+from pyntcli.commands import pynt_cmd
+from pyntcli.pynt_docker import pynt_container
+from pyntcli.ui import ui_thread
+from pyntcli.auth import login 
+from pyntcli.analytics import send as analytics
+
+def signal_handler(signal_number, frame):
+    ui_thread.print(ui_thread.PrinterText("Exiting..."))
+    
+    analytics.stop()
+    pynt_container.PyntContainerRegistery.instance().stop_all_containers() 
+    ui_thread.stop()
+
+    exit(0)
+
+import requests
+from distutils.version import StrictVersion
+VERSION_CHECK_URL = "https://pypi.org/pypi/pyntcli/json"
+
+def check_is_latest_version(current_version):
+    res = requests.get(VERSION_CHECK_URL) 
+    res.raise_for_status()
+    
+    avail_versions = list(res.json()["releases"].keys())
+    avail_versions.sort(key=StrictVersion)
+
+    if current_version != avail_versions[-1]:
+        ui_thread.print(ui_thread.PrinterText("""Pynt CLI new version is available, upgrade now with:
+python3 -m pip install --upgrade pyntcli""",ui_thread.PrinterText.WARNING))
+
+def check_for_dependecies():
+    pynt_container.get_docker_type()
+
+def print_header():
+    ui_thread.print(ui_thread.PrinterText(*ui_thread.pynt_header()) \
+                             .with_line(*ui_thread.pynt_version()) \
+                             .with_line(""))
+def start_analytics():
+    user_id = login.user_id()
+    if user_id:
+       analytics.set_user_id(user_id)
+    
+    analytics.emit(analytics.CLI_START)
+
+def main():
+    print_header()
+    try:
+        start_analytics()
+        check_for_dependecies()
+        check_is_latest_version(cli_version)
+        signal.signal(signal.SIGINT, signal_handler)
+        cli = pynt_cmd.PyntCommand()
+        cli.run_cmd(cli.parse_args(argv[1:]))
+        analytics.stop()
+    except pynt_cmd.PyntCommandException:
+       pynt_cmd.root.usage()
+    except pynt_container.DockerNotAvailableException:
+        ui_thread.print(ui_thread.PrinterText("Docker was unavailable, please make sure docker is installed and running.", ui_thread.PrinterText.WARNING))
+        analytics.emit(analytics.ERROR, {"error": "docker unavailable"})
+    except requests.exceptions.SSLError: 
+        ui_thread.print(ui_thread.PrinterText("We encountered SSL issues and could not proceed, this may be the cause of a VPN or a Firewall in place.", ui_thread.PrinterText.WARNING))
+        analytics.emit(analytics.ERROR, {"error": "ssl issue"})
+    except login.Timeout: 
+        ui_thread.print(ui_thread.PrinterText("Pynt CLI exited due to incomplete registration, please try again.", ui_thread.PrinterText.WARNING))
+        analytics.emit(analytics.ERROR, {"error": "login timeout"})
+    except login.InvalidTokenInEnvVarsException:
+        ui_thread.print(ui_thread.PrinterText("Pynt CLI exited due to malformed credentials provided in env vars.", ui_thread.PrinterText.WARNING))
+        analytics.emit(analytics.ERROR, {"error": "invalid pynt cli credentials in env vars"})
+    finally:
+        ui_thread.stop()
+
+if __name__ == "__main__":
+    main()

build/lib/build/lib/pyntcli/pynt_docker/__init__.py

@@ -0,0 +1 @@
+from .pynt_container import *

build/lib/build/lib/pyntcli/pynt_docker/pynt_container.py

@@ -0,0 +1,178 @@
+import docker
+from docker.errors import DockerException
+from docker.types import Mount
+import os
+from typing import List
+
+from pyntcli.ui import ui_thread
+
+PYNT_DOCKER_IMAGE = "ghcr.io/pynt-io/pynt"
+
+def create_mount(src, destination, mount_type="bind"):
+    return Mount(target=destination, source=src, type=mount_type)
+
+class DockerNotAvailableException(Exception):
+    pass
+
+def get_docker_type():
+    try:
+        c = docker.from_env()
+        version_data = c.version()
+        platform = version_data.get("Platform")
+
+        if platform and platform.get("Name"):
+            return platform.get("Name")
+        
+        return ""
+
+    except DockerException:
+        raise DockerNotAvailableException()
+    except Exception: #TODO: This is since windows is not behaving nice
+        raise DockerNotAvailableException()
+
+class PyntDockerPort:
+    def __init__(self, src, dest, name) -> None:
+        self.src = src
+        self.dest = dest
+        self.name = name
+
+def get_container_with_arguments(*args: PyntDockerPort):
+    if "desktop" in get_docker_type().lower():
+        ports = {}
+        for p in args:
+            ports[str(p.src)] = int(p.dest)
+        docker_type = PyntDockerDesktopContainer(ports=ports)
+        return docker_type , []
+    
+    docker_arguments = []
+    docker_type = PyntNativeContainer(network="host")
+
+    for p in args: 
+        docker_arguments.append(p.name)
+        docker_arguments.append(str(p.dest))
+
+    return docker_type, docker_arguments
+    
+def _container_image_from_tag(tag: str) -> str:
+    if ":" in tag: 
+        return tag.split(":")[0]
+
+    return tag
+
+class PyntContainer():
+    def __init__(self, image_name, tag, mounts, detach, args) -> None:
+        self.docker_client: docker.DockerClient = None
+        self.image = image_name if not os.environ.get("IMAGE") else os.environ.get("IMAGE")
+        self.tag = tag if not os.environ.get("TAG") else os.environ.get("TAG")
+        self.mounts = mounts
+        self.detach = detach
+        self.stdout = None 
+        self.running = False
+        self.args = args
+        self.container_name = ""
+    
+    def _create_docker_client(self):
+        self.docker_client = docker.from_env()
+        pat = os.environ.get("DOCKER_PASSWORD")
+        username = os.environ.get("DOCKER_USERNAME")
+        registry = os.environ.get("DOCKER_REGISTRY")
+        if pat and username and registry:
+            self.docker_client.login(username=username, password=pat, registry=registry)
+    
+    def _is_docker_image_up_to_date(self, image):
+        return True
+    
+    def _handle_outdated_docker_image(self, image):
+        return image
+    
+    def kill_other_instances(self):
+        for c in self.docker_client.containers.list():
+            if _container_image_from_tag(c.image.tags[0]) == self.image:
+                c.kill()
+    
+    def stop(self):
+        if not self.running:
+            return 
+
+        self.kill_other_instances()
+
+        self.docker_client.close()
+        self.docker_client = None
+        self.running = False
+    
+    def is_alive(self):
+        if not self.docker_client or not self.container_name:
+            return False
+
+        l = self.docker_client.containers.list(filters={"name": self.container_name})
+        if len(l) != 1:
+            return False
+        
+        return l[0].status == "running"
+
+    def run(self, integration_docker): 
+        if not self.docker_client:
+            self._create_docker_client()
+        
+        self.running = True
+        self.kill_other_instances()
+
+        ui_thread.print(ui_thread.PrinterText("Pulling latest docker", ui_thread.PrinterText.INFO))
+        image = self.docker_client.images.pull(self.image, tag=self.tag)
+        if not self._is_docker_image_up_to_date(image):
+            image = self._handle_outdated_docker_image(image)
+        ui_thread.print(ui_thread.PrinterText("Docker pull done", ui_thread.PrinterText.INFO))
+    
+        args = self.args if self.args else None
+
+        run_arguments = {
+                "image":image, 
+                "detach":self.detach,
+                "mounts":self.mounts,
+                "stream": True,
+                "remove": True,
+                "command": args
+        }
+
+        run_arguments.update(integration_docker.get_argumets())
+
+        c = self.docker_client.containers.run(**run_arguments)
+        self.container_name = c.name
+        self.stdout = c.logs(stream=True)
+
+        PyntContainerRegistery.instance().register_container(self)
+
+class PyntDockerDesktopContainer():
+    def __init__(self, ports) -> None:
+        self.ports = ports
+    
+    def get_argumets(self):
+        return {"ports": self.ports} if self.ports else {}
+        
+class PyntNativeContainer():
+    def __init__(self, network) -> None:
+        self.network = network
+
+    def get_argumets(self):
+        return {"network": self.network} if self.network else {}
+
+
+class PyntContainerRegistery():
+    _instance = None
+
+    def __init__(self) -> None:
+        self.containers: List[PyntContainer] = []
+
+    @staticmethod
+    def instance():
+        if not PyntContainerRegistery._instance:
+            PyntContainerRegistery._instance = PyntContainerRegistery() 
+
+        return PyntContainerRegistery._instance
+
+    def register_container(self, c: PyntContainer):
+        self.containers.append(c) 
+    
+    def stop_all_containers(self):
+        for c in self.containers: 
+            c.stop()

build/lib/build/lib/pyntcli/store/__init__.py

@@ -0,0 +1 @@
+from .store import CredStore

build/lib/build/lib/pyntcli/store/json_connector.py

@@ -0,0 +1,23 @@
+import json
+
+from .store_connector import StoreConnector
+
+class JsonStoreConnector(StoreConnector):
+    def __init__(self, data) -> None:
+        if not data:
+            data = JsonStoreConnector.default_value()
+        super().__init__(data)
+        self.json = json.loads(self._data)
+
+    def get(self, key):
+        return self.json.get(key, None)
+
+    def put(self, key, value):
+       self.json[key] = value
+    
+    def dump(self):
+        return json.dumps(self.json, indent=2)
+
+    @staticmethod
+    def default_value():
+        return json.dumps({})

build/lib/build/lib/pyntcli/store/store.py

@@ -0,0 +1,55 @@
+from typing import Type 
+import os 
+import platform
+
+from .json_connector import JsonStoreConnector
+from .store_connector import StoreConnector
+
+class Store():
+    def __init__(self, file_location: str, connector_type: Type[StoreConnector]) -> None :
+        self.file_location = file_location
+        self.connector:StoreConnector = None
+        self._file = None
+        self._connector_tpye = connector_type
+    
+    def _get_file_data(self):
+        if self.connector: 
+            return 
+
+        dirname = os.path.dirname(self.file_location)
+        if not os.path.exists(dirname):
+            os.makedirs(dirname)
+        
+        if not os.path.exists(self.file_location):
+            with open(self.file_location, "w") as f:
+                self.connector = self._connector_tpye(self._connector_tpye.default_value())
+                return
+
+        with open(self.file_location, "r+") as f:
+            self.connector = self._connector_tpye(f.read())
+
+    def get(self, key):
+        self._get_file_data()
+        return self.connector.get(key)
+
+    def put(self, key, value):
+        self._get_file_data()
+        self.connector.put(key, value)
+    
+    def get_path(self):
+        return self.file_location
+
+    def __enter__(self):
+        self._get_file_data()
+        return self 
+
+    def __exit__(self, type, value, traceback): 
+        with open(self.file_location, "w") as f:
+            f.write(self.connector.dump())
+
+class CredStore(Store):
+    def __init__(self) -> None:
+        dir = ".pynt"
+        super().__init__(file_location=os.path.join(os.path.expanduser("~"), dir, "creds.json"),
+                         connector_type=JsonStoreConnector)
+ 

build/lib/build/lib/pyntcli/store/store_connector.py

@@ -0,0 +1,17 @@
+class StoreConnector():
+    def __init__(self, data) -> None:
+        self._data = data 
+
+    def get(self, key):
+        raise NotImplemented()
+
+    def put(self, key, value):
+        raise NotImplementedError()
+    
+    def dump(self):
+        raise NotImplementedError()
+
+    @classmethod
+    def default_value(cls):
+        raise NotImplementedError()
+

build/lib/build/lib/pyntcli/ui/progress.py

@@ -0,0 +1,31 @@
+import websocket
+
+def connect_progress_ws(address):
+    ws = websocket.WebSocket()
+    ws.connect(address)
+    return ws
+
+def wrap_ws_progress(ws):
+    prev = 0
+    while ws.connected:
+        try:
+            current = int(ws.recv())
+            yield current - prev
+            prev = current
+        except websocket.WebSocketConnectionClosedException:
+            return
+
+class PyntProgress():
+    def __init__(self, what_to_track, total, description) -> None:
+        self.running = False
+        self.trackable = what_to_track
+        self.total = total
+        self.description = description
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_traceback):
+        self.running = False
+
+