pyntcli 0.1.46__py3-none-any.whl → 0.1.48__py3-none-any.whl

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

@@ -1,172 +0,0 @@
-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):
-        if not progress.trackable:
-            return
-        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)
-                    continue
-                if isinstance(data, PyntProgress):
-                    self._handle_progress(data)
-                    continue
-                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,healthcheck, description, total=100):
-    pointer_to_progress = [PyntProgress(what_to_track,healthcheck, total, description)]
-    _print(pointer_to_progress)
-    return pointer_to_progress[0]
-

build/lib/pyntcli/analytics/send.py

@@ -1,77 +0,0 @@
-import requests
-import time
-import platform
-
-from pyntcli import __version__
-from pyntcli.transport import pynt_requests
-
-
-PYNT_DEFAULT_USER_ID = "d9e3b82b-2900-43bf-8c8f-7ffe2f0cda36"
-MIXPANEL_TOKEN = "05c26edb86084bbbb803eed6818cd8aa"
-MIXPANEL_URL = "https://api-eu.mixpanel.com/track?ip=1"
-
-def stop():
-    if not AnalyticsSender._instance:
-        return
-    AnalyticsSender.instance().done()
-
-def emit(event, properties=None):
-    AnalyticsSender.instance().emit(event, properties)
-
-def set_user_id(user_id):
-    AnalyticsSender.instance().set_user_id(user_id)
-
-CLI_START = "cli_start"
-LOGIN_START = "cli_login_start"
-LOGIN_DONE = "cli_login_done"
-ERROR = "error"
-
-class AnalyticsSender():
-    _instance = None
-
-    def __init__(self, user_id=PYNT_DEFAULT_USER_ID) -> None:
-        self.user_id = user_id
-        self.version = __version__
-        self.events = []
-    
-    @staticmethod
-    def instance():
-        if not AnalyticsSender._instance:
-            AnalyticsSender._instance = AnalyticsSender()
-
-        return AnalyticsSender._instance
-
-    def base_event(self, event_type):
-        return { 
-        "event": event_type,
-        "properties":  {
-            "time": time.time(),
-            "distinct_id": self.user_id,
-            "$os": platform.platform(),
-            "cli_version": self.version,
-            "token": MIXPANEL_TOKEN
-            }
-        }
-
-    def emit(self, event, properties):
-        base_event = self.base_event(event)
-        
-        if properties:
-            for k,v in properties.items():
-                base_event["properties"][k] = v
-
-        if self.user_id != PYNT_DEFAULT_USER_ID:
-            pynt_requests.post(MIXPANEL_URL, json=[base_event])
-        else:
-            self.events.append(base_event)
-
-    def set_user_id(self, user_id):
-        self.user_id = user_id
-        for i, _ in enumerate(self.events): 
-            self.events[i]["properties"]["distinct_id"] = user_id
-        self.done()
-
-    def done(self):
-        if self.events:
-            pynt_requests.post(MIXPANEL_URL, json=self.events)
-            self.events = []

build/lib/pyntcli/auth/login.py

@@ -1,156 +0,0 @@
-from base64 import b64decode
-import webbrowser
-import uuid
-import urllib.parse
-import datetime
-import time
-import json
-import os
-
-from pyntcli.ui import ui_thread
-from pyntcli.store import CredStore
-from pyntcli.transport import pynt_requests
-
-class LoginException(Exception):
-    pass
-
-class Timeout(LoginException):
-    pass
-
-class InvalidTokenInEnvVarsException(LoginException):
-    pass
-
-PYNT_CREDENTIALS = "PYNT_CREDENTIALS"
-
-class Login():
-    def __init__(self) -> None:
-        self.delay = 5
-        self.base_authorization_url = "https://pynt.io/login?"
-        self.poll_url = "https://n592meacjj.execute-api.us-east-1.amazonaws.com/default/cli_validate_login"
-        self.login_wait_period = (60 *3) #3 minutes
-
-    def create_login_request(self): 
-        request_id = uuid.uuid4()
-        request_url = self.base_authorization_url + urllib.parse.urlencode({"request_id": request_id, "utm_source": "cli"})
-        webbrowser.open(request_url)
-
-        ui_thread.print(ui_thread.PrinterText("To continue, you need to log in to your account.")\
-                                 .with_line("You will now be redirected to the login page.") \
-                                 .with_line("") \
-                                 .with_line("If you are not automatically redirected, please click on the link provided below (or copy to your web browser)") \
-                                 .with_line(request_url))
-        return request_id
-
-    def get_token_using_request_id(self, request_id):
-        with ui_thread.spinner("Waiting...", "point"):
-            start = time.time()
-            while start + self.login_wait_period > time.time():
-                response = pynt_requests.get(self.poll_url, params={"request_id": request_id})
-                if response.status_code == 200:
-                    return response.json()
-                time.sleep(self.delay)
-            raise Timeout()
-    
-    def login(self):
-        id = self.create_login_request()
-        token = self.get_token_using_request_id(id)
-        with CredStore() as store: 
-            store.put("token", token)
-
-
-def refresh_request(refresh_token):
-    return pynt_requests.post("https://auth.pynt.io/default/refresh", json={"refresh_token": refresh_token})
-
-def refresh_token():
-    token = None
-    with CredStore() as store: 
-        token = store.get("token")
-
-    if not token: 
-        Login().login()
-    
-    access_token = token.get("access_token")
-    if access_token and not is_jwt_expired(access_token):
-        return
-
-    refresh = token.get("refresh_token", None)
-    if not refresh:
-        Login().login()
-        return
-
-    refresh_response = refresh_request(refresh) 
-    if refresh_response.status_code != 200:
-        Login().login()
-        return 
-
-    with CredStore() as store:
-        token["access_token"] = refresh_response.json()["token"]
-        store.put("token", token)
-
-def decode_jwt(jwt_token):
-    splited = jwt_token.split(".")
-    if len(splited) != 3: 
-        return None
-
-    return json.loads(b64decode(splited[1] + '=' * (-len(splited[1]) % 4)))
-
-def user_id():
-    with CredStore() as store:
-        token = store.get("token")
-        if not token:
-            return None 
-
-        decoded = decode_jwt(token["access_token"])
-        if not decoded:
-            return None
-        
-        return decoded.get("sub", None)
-
-    return None
-
-def is_jwt_expired(jwt_token):
-    decoded = decode_jwt(jwt_token)
-    if not decoded:
-        return True
-
-    exp = decoded.get("exp", None)
-    if not exp: 
-        return True 
-    
-    return datetime.datetime.fromtimestamp(exp) < datetime.datetime.now() + datetime.timedelta(minutes=1) 
-
-def validate_creds_structure(data):
-    try: 
-        creds = json.loads(data.replace("\n", ""))
-        token = creds.get("token", None)
-        if not token:
-            raise InvalidTokenInEnvVarsException()
-        if not isinstance(token, dict):
-            raise InvalidTokenInEnvVarsException()
-        
-        refresh_token = token.get("refresh_token", None)
-        if not refresh_token:
-            raise InvalidTokenInEnvVarsException()
-        
-        return token
-    except json.JSONDecodeError:    
-        raise InvalidTokenInEnvVarsException()
-  
-
-def should_login(): 
-    env_creds = os.environ.get(PYNT_CREDENTIALS, None)
-    if env_creds:
-        validated_creds = validate_creds_structure(env_creds)
-        with CredStore() as store:
-            store.put("token", validated_creds)
-
-    with CredStore() as store:
-        token = store.get("token")
-
-        if not token or token == store.connector.default_value:
-            return True
-            
-        if not token.get("refresh_token"):
-            return True 
-        
-        return False

build/lib/pyntcli/commands/har.py

@@ -1,67 +0,0 @@
-import argparse
-import time
-import os
-from functools import partial
-
-from pyntcli.pynt_docker import pynt_container
-from pyntcli.ui import ui_thread
-from pyntcli.ui.progress import PyntProgress
-from pyntcli.commands import sub_command, util
-
-
-
-def har_usage():
-    return ui_thread.PrinterText("Integration with static har file testing") \
-            .with_line("") \
-            .with_line("Usage:", style=ui_thread.PrinterText.HEADER) \
-            .with_line("\tpynt har [OPTIONS]") \
-            .with_line("") \
-            .with_line("Options:", style=ui_thread.PrinterText.HEADER) \
-            .with_line("\t--har - Path to har file") \
-            .with_line("\t--reporters output results to json") \
-            .with_line("\t--host-ca - path to the CA file in PEM format to enable SSL certificate verification for pynt when running through a VPN.")
-
-class HarSubCommand(sub_command.PyntSubCommand):
-    def __init__(self, name) -> None:
-        super().__init__(name)
-
-    def usage(self, *args):
-        ui_thread.print(har_usage())
-
-    def add_cmd(self, parent: argparse._SubParsersAction) -> argparse.ArgumentParser:
-        har_cmd = parent.add_parser(self.name)
-        har_cmd.add_argument("--har", type=str, required=True)
-        har_cmd.add_argument("--reporters", action='store_true')
-        har_cmd.print_usage = self.usage
-        har_cmd.print_help = self.usage
-        return har_cmd
-    
-    def run_cmd(self, args: argparse.Namespace):
-        port = str(util.find_open_port())
-        container = pynt_container.get_container_with_arguments(args, pynt_container.PyntDockerPort(src=port, dest=port, name="--port"))
-
-        if not os.path.isfile(args.har): 
-            ui_thread.print(ui_thread.PrinterText("Could not find the provided har path, please provide with a valid har path", ui_thread.PrinterText.WARNING))
-            return
-
-        har_name = os.path.basename(args.har)
-        container.docker_arguments += ["--har", har_name]
-        container.mounts.append(pynt_container.create_mount(os.path.abspath(args.har), "/etc/pynt/{}".format(har_name)))
-
-        with util.create_default_file_mounts(args) as m:
-
-            container.mounts += m
-            
-            har_docker = pynt_container.PyntContainer(image_name=pynt_container.PYNT_DOCKER_IMAGE,
-                                                     tag="har-latest",
-                                                     detach=True,
-                                                     base_container=container)
-
-            har_docker.run()
-
-            healthcheck = partial(util.wait_for_healthcheck, "http://localhost:{}".format(port))
-            ui_thread.print_generator(ui_thread.AnsiText.wrap_gen(har_docker.stdout))
-        
-            with ui_thread.progress("ws://localhost:{}/progress".format(port),healthcheck,  "scan in progress...",100):
-                while har_docker.is_alive():
-                    time.sleep(1)

build/lib/pyntcli/commands/id_command.py

@@ -1,28 +0,0 @@
-import argparse
-
-from pyntcli.store.store import CredStore
-from pyntcli.commands import sub_command
-from pyntcli.ui import ui_thread
-
-def pyntid_usage():
-    return ui_thread.PrinterText("View your pynt-id to use when running pynt in CI pipeline") \
-        .with_line("") \
-        .with_line("Usage:",style=ui_thread.PrinterText.HEADER) \
-        .with_line("\tpynt pynt-id")
-
-class PyntShowIdCommand(sub_command.PyntSubCommand): 
-    def __init__(self, name) -> None:
-        super().__init__(name)
-
-    def usage(self, *args):
-        ui_thread.print(pyntid_usage())
-
-    def add_cmd(self, parent: argparse._SubParsersAction) -> argparse.ArgumentParser:
-        cmd = parent.add_parser(self.name)
-        cmd.print_usage = self.usage
-        cmd.print_help = self.usage
-        return cmd
-
-    def run_cmd(self, args: argparse.Namespace):
-        creds_path = CredStore().get_path() 
-        ui_thread.print(open(creds_path, "r").read())

build/lib/pyntcli/commands/newman.py

@@ -1,77 +0,0 @@
-import argparse
-import time
-import os
-from functools import partial
-
-from pyntcli.pynt_docker import pynt_container
-from pyntcli.commands import sub_command, util
-from pyntcli.ui import ui_thread
-from pyntcli.ui.progress import PyntProgress
-
-def newman_usage():
-    return ui_thread.PrinterText("Integration with newman, run scan using postman collection from the CLI") \
-            .with_line("") \
-            .with_line("Usage:", style=ui_thread.PrinterText.HEADER) \
-            .with_line("\tpynt newman [OPTIONS]") \
-            .with_line("") \
-            .with_line("Options:", style=ui_thread.PrinterText.HEADER) \
-            .with_line("\t--collection - Postman collection file name") \
-            .with_line("\t--environment - Postman environment file name") \
-            .with_line("\t--reporters output results to json") \
-            .with_line("\t--host-ca - path to the CA file in PEM format to enable SSL certificate verification for pynt when running through a VPN.")
-
-class NewmanSubCommand(sub_command.PyntSubCommand):
-    def __init__(self, name) -> None:
-        super().__init__(name)
-
-    def usage(self, *args): 
-        ui_thread.print(newman_usage())
-
-    def add_cmd(self, parent: argparse._SubParsersAction) -> argparse.ArgumentParser:
-        newman_cmd = parent.add_parser(self.name)
-        newman_cmd.add_argument("--collection", type=str, required=True) 
-        newman_cmd.add_argument("--environment", type=str, required=False) 
-        newman_cmd.add_argument("--reporters", action="store_true",default=False,  required=False) 
-        newman_cmd.print_usage = self.usage
-        newman_cmd.print_help = self.usage
-        return newman_cmd
-
-    def run_cmd(self, args: argparse.Namespace):
-        port = str(util.find_open_port())
-        container = pynt_container.get_container_with_arguments(args, pynt_container.PyntDockerPort(src=port, dest=port, name="--port"))
-
-        if not os.path.isfile(args.collection): 
-            ui_thread.print(ui_thread.PrinterText("Could not find the provided collection path, please provide with a valid collection path", ui_thread.PrinterText.WARNING))
-            return
-        
-        collection_name = os.path.basename(args.collection)
-        container.docker_arguments += ["-c", collection_name]
-        container.mounts.append(pynt_container.create_mount(os.path.abspath(args.collection), "/etc/pynt/{}".format(collection_name)))
-         
-        if "environment" in args and args.environment:
-            if not os.path.isfile(args.environment):
-                ui_thread.print(ui_thread.PrinterText("Could not find the provided environment path, please provide with a valid environment path", ui_thread.PrinterText.WARNING))
-                return
-            
-            env_name = os.path.basename(args.environment)
-            container.docker_arguments += ["-e", env_name]
-            container.mounts.append(pynt_container.create_mount(os.path.abspath(args.environment), "/etc/pynt/{}".format(env_name)))
-
-               
-        with util.create_default_file_mounts(args) as m:
-
-            container.mounts += m
-            
-            newman_docker = pynt_container.PyntContainer(image_name=pynt_container.PYNT_DOCKER_IMAGE,
-                                                     tag="latest",
-                                                     detach=True,
-                                                     base_container=container)
-
-            newman_docker.run()
-            
-            healthcheck = partial(util.wait_for_healthcheck, "http://localhost:{}".format(port))
-            ui_thread.print_generator(ui_thread.AnsiText.wrap_gen(newman_docker.stdout))
-            
-            with ui_thread.progress("ws://localhost:{}/progress".format(port),healthcheck,  "scan in progress...",100):
-                while newman_docker.is_alive():
-                    time.sleep(1)

build/lib/pyntcli/commands/postman.py

@@ -1,50 +0,0 @@
-import argparse
-import time 
-
-from . import sub_command, util
-from pyntcli.pynt_docker import pynt_container
-from pyntcli.ui import ui_thread
-
-
-def postman_usage():
-    return ui_thread.PrinterText("Integration with postman, run scan from pynt postman collection") \
-        .with_line("") \
-        .with_line("Usage:",style=ui_thread.PrinterText.HEADER) \
-        .with_line("\tpynt postman [OPTIONS]") \
-        .with_line("") \
-        .with_line("Options:",style=ui_thread.PrinterText.HEADER) \
-        .with_line("\t--port - set the port pynt will listen to (DEFAULT: 5001)") \
-        .with_line("\t--insecure - use when target uses self signed certificates") \
-        .with_line("\t--host-ca - path to the CA file in PEM format to enable SSL certificate verification for pynt when running through a VPN.")
-
-class PostmanSubCommand(sub_command.PyntSubCommand): 
-    def __init__(self, name) -> None:
-        super().__init__(name)
-
-    def usage(self, *args):
-        ui_thread.print(postman_usage())
-
-    def add_cmd(self, parent_command: argparse._SubParsersAction) -> argparse.ArgumentParser: 
-        postman_cmd = parent_command.add_parser(self.name)
-        postman_cmd.add_argument("--port", "-p", help="set the port pynt will listen to (DEFAULT: 5001)", type=int, default=5001)
-        postman_cmd.print_usage = self.usage
-        postman_cmd.print_help = self.usage
-        return postman_cmd
-
-    def run_cmd(self, args: argparse.Namespace):
-        container = pynt_container.get_container_with_arguments(args ,pynt_container.PyntDockerPort("5001", args.port, name="--port"))        
-       
-        if util.is_port_in_use(args.port):
-            ui_thread.print(ui_thread.PrinterText("Port: {} already in use, please use a different one".format(args.port), ui_thread.PrinterText.WARNING))
-            return 
-
-        postman_docker = pynt_container.PyntContainer(image_name=pynt_container.PYNT_DOCKER_IMAGE, 
-                                            tag="postman-latest", 
-                                            detach=True, 
-                                            base_container=container)
-
-        postman_docker.run()
-        ui_thread.print_generator(postman_docker.stdout) 
-        
-        while postman_docker.is_alive():
-            time.sleep(1)