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

build/lib/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/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/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/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/build/lib/pyntcli/pynt_docker/__init__.py

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

build/lib/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/build/lib/pyntcli/store/__init__.py

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

build/lib/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/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/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/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
+
+

build/lib/build/lib/build/lib/pyntcli/ui/ui_thread.py

@@ -0,0 +1,168 @@
+from threading import Thread
+import queue
+import os
+import time
+from rich.text import Text
+from rich.console import Console
+from rich.status import Status
+from rich.progress import Progress
+from typing import Tuple
+
+from pyntcli import __version__ as cli_version
+from pyntcli.ui.progress import PyntProgress
+
+class PrinterText():
+    DEFAULT = 0
+    HEADER = 1
+    INFO = 2
+    WARNING = 3
+
+    def __init__(self,text,style=DEFAULT):
+        self.text = Text(text, PrinterText.get_style(style))
+
+    @staticmethod
+    def get_style(style):
+        if style == PrinterText.INFO:
+            return "bold blue"
+        if style == PrinterText.WARNING:
+            return "bold red"
+        if style == PrinterText.HEADER:
+            return "bold"
+        if style == PrinterText.DEFAULT:
+            return None
+
+    def with_line(self, line, style=DEFAULT):
+        self.text.append(os.linesep)
+        self.text.append(Text(line, PrinterText.get_style(style)))
+        return self
+
+class AnsiText():
+    def __init__(self, data) -> None:
+        self.data = data
+    
+    @staticmethod
+    def wrap_gen(gen):
+        for v in gen:
+            yield AnsiText(v)
+
+class Spinner():
+    def __init__(self, prompt, style) -> None:
+        self.prompt = prompt
+        self.style = style 
+        self.runnning = False
+    
+    def __enter__(self):
+        return self 
+
+    def __exit__(self, exc_type, exc_value, exc_traceback):
+        self.running = False
+
+def pynt_version()-> Tuple[str,int]: 
+    return "Pynt CLI version " + cli_version,PrinterText.DEFAULT
+
+def pynt_header()-> Tuple[str,int]:
+    return "API Security testing autopilot",PrinterText.DEFAULT
+
+def gen_func_loop(gen):
+    for l in gen:
+        data = l
+        if type(data) == bytes: 
+            data = l.decode("utf-8")
+        if not isinstance(data, AnsiText) and data[-1] == "\n":
+            data = data[:-1]
+        _print(data)
+        
+def print_generator(gen):
+    t = Thread(target=gen_func_loop, args=(gen,), daemon=True) 
+    t.start()
+
+def _print(s): 
+    Printer.instance().print(s)
+
+def print(s): 
+    if type(s) == bytes: 
+        s = s.decode("utf-8")
+    _print(s)
+
+def stop():
+    Printer.instance().stop()
+
+class Printer():
+    _instace = None
+
+    def __init__(self) -> None:
+        self.running = False
+        self.run_thread = Thread(target=self._print_in_loop, daemon=True)
+        self.print_queue = queue.Queue()
+        self.console = Console(tab_size=4)
+   
+    @staticmethod 
+    def instance():
+        if not Printer._instace:
+            Printer._instace = Printer() 
+            Printer._instace.start() 
+
+        return Printer._instace
+
+    def start(self):
+        self.running = True
+        self.run_thread.start()
+    
+    def _handle_spinner(self, spinner):
+        spinner.running = True 
+        s = Status(spinner.prompt, spinner=spinner.style, console=self.console)
+        s.start()
+        while spinner.running and self.running:
+            time.sleep(0.5)
+        s.stop()
+    
+    def _handle_progress(self, progress):
+        progress.running = True 
+        with Progress(console=self.console, transient=True) as p:
+            t = p.add_task(description=progress.description, total=progress.total)
+            for update in progress.trackable:
+                if not (progress.running and self.running):
+                    return
+                p.update(t, advance=update)
+                time.sleep(0.5)
+
+    def _print_in_loop(self):
+        while self.running:
+            try: 
+                data = self.print_queue.get(timeout=1)
+                if isinstance(data, list): 
+                    data = data[0]
+                if isinstance(data, Spinner):
+                    self._handle_spinner(data)
+                if isinstance(data, PyntProgress):
+                    self._handle_progress(data)
+                else:
+                    self.console.print(data)
+            except queue.Empty:
+                pass
+        
+        while not self.print_queue.empty():
+            self.console.print(self.print_queue.get())
+
+
+    def print(self, data):
+        if isinstance(data,PrinterText):
+            data = data.text
+        if isinstance(data, AnsiText):
+            data = Text.from_ansi(data.data.decode())
+        self.print_queue.put(data)
+    
+    def stop(self):
+        self.running = False
+        self.run_thread.join()
+
+def spinner(prompt, style): 
+    s = Spinner(prompt, style)
+    _print([s])
+    return s
+
+def progress(what_to_track, description, total=100):
+    p = PyntProgress(what_to_track, total, description)
+    _print([p])
+    return p
+