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

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

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

@@ -1,147 +0,0 @@
-import argparse
-from copy import deepcopy
-import os
-import webbrowser
-from http import HTTPStatus
-import time
-import tempfile
-from subprocess import Popen, PIPE
-from functools import partial
-
-from pyntcli.pynt_docker import pynt_container
-from pyntcli.ui import ui_thread
-from pyntcli.commands import util, sub_command
-from pyntcli.ui import report as cli_reporter
-from pyntcli.transport import pynt_requests
-
-
-
-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") \
-        .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 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 = pynt_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 = pynt_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,report_format):
-        while True: 
-            res = pynt_requests.get(self.proxy_server_base_url.format(args.port) + "/report?format={}".format(report_format), 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):
-        container = pynt_container.get_container_with_arguments(args, pynt_container.PyntDockerPort(args.port, args.port, "--port"),
-                                                                                                pynt_container.PyntDockerPort(args.proxy_port, args.proxy_port, "--proxy-port"))        
-        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)
-            container.docker_arguments += ["--ca-path", ca_name]
-            container.mounts.append(pynt_container.create_mount(os.path.abspath(args.ca_path), "/etc/pynt/{}".format(ca_name)))
-
-        proxy_docker = pynt_container.PyntContainer(image_name=pynt_container.PYNT_DOCKER_IMAGE, 
-                                    tag="proxy-latest", 
-                                    detach=True, 
-                                    base_container=container)
-        proxy_docker.run()
-        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)
-        
-        with ui_thread.progress("ws://localhost:{}/progress?scanId={}".format(args.port, self.scan_id),partial(lambda *args: None), "scan in progress...", 100):
-            html_report = self._get_report(args,"html")
-            html_report_path = os.path.join(tempfile.gettempdir(), "pynt_report_{}.html".format(int(time.time())))
-
-            json_report = self._get_report(args,"json")   
-            json_report_path = os.path.join(tempfile.gettempdir(), "pynt_report_{}.json".format(int(time.time())))
-
-            if "report" in args and args.report:
-                html_report_path = util.get_user_report_path(args.report,"html")
-                json_report_path = util.get_user_report_path(args.report,"json")
-
-            if html_report:
-                with open(html_report_path, "w") as html_file:
-                    html_file.write(html_report)
-                webbrowser.open("file://{}".format(html_report_path))
-
-            if json_report:
-                with open(json_report_path, "w") as json_file:
-                    json_file.write(json_report)
-                cli_reporter.PyntReporter(json_report_path).print_summary()
-
-

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

@@ -1,73 +0,0 @@
-import argparse
-from typing import Dict, List
-from pyntcli import __version__ as cli_version
-from pyntcli.analytics import send as analytics
-from pyntcli.transport import pynt_requests
-from pyntcli.ui import ui_thread
-from distutils.version import StrictVersion
-
-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
-
-
-VERSION_CHECK_URL = "https://d1efigcr4c19qn.cloudfront.net/cli/version"
-
-def check_is_latest_version(current_version):
-    res = pynt_requests.get(VERSION_CHECK_URL) 
-    res.raise_for_status()
-
-    latest_versions = res.text.replace("\n","")
-
-    if current_version != latest_versions:
-        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))
-
-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()
-        
-        if "host_ca" in args and args.host_ca:
-            pynt_requests.add_host_ca(args.host_ca)
-            
-        if "insecure" in args and args.insecure:
-            pynt_requests.disable_tls_termination()
-
-        check_is_latest_version(cli_version)
-        analytics.emit(analytics.CLI_START)
-    
-        self.base.run_cmd(args)
-        self.sub_commands[command].run_cmd(args)

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

@@ -1,58 +0,0 @@
-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)
-        parser.add_argument("--host-ca", type=str, default="")
-
-    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

@@ -1,15 +0,0 @@
-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

@@ -1,71 +0,0 @@
-import time
-import socket
-import os
-import tempfile
-from contextlib import contextmanager
-from pathlib import Path
-import webbrowser
-
-from pyntcli.pynt_docker import pynt_container
-from pyntcli.ui import report
-from pyntcli.ui import pynt_errors
-from pyntcli.transport import pynt_requests
-
-
-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 = 0.1
-
-def wait_for_healthcheck(address): 
-    start = time.time()
-    while start + HEALTHCHECK_TIMEOUT > time.time(): 
-        try:
-            res = pynt_requests.get(address + "/healthcheck")
-            if res.status_code == 418:
-                return 
-        except: 
-            time.sleep(HEALTHCHECK_INTERVAL)
-    raise TimeoutError()
-
-def get_user_report_path(path,file_type):
-    path = Path(path)
-    if path.is_dir():
-        return os.path.join(path, "pynt_results_{}.{}".format(int(time.time()),file_type))
-    
-    return os.path.join(str(path.parent), path.stem + ".{}".format(file_type))
-    
-
-class HtmlReportNotCreatedException(Exception):
-    pass
-
-@contextmanager
-def create_default_file_mounts(args):
-    html_report_path = os.path.join(tempfile.gettempdir(), "results.html")
-    json_report_path = os.path.join(tempfile.gettempdir(), "results.json")
-
-    if "reporters" in args and args.reporters: 
-        html_report_path = os.path.join(os.getcwd(), "pynt_results.html")
-        json_report_path = os.path.join(os.getcwd(), "pynt_results.json")
-
-    mounts = []
-    with open(html_report_path, "w"), open(json_report_path, "w"):    
-        mounts.append(pynt_container.create_mount(json_report_path, "/etc/pynt/results/results.json"))
-        mounts.append(pynt_container.create_mount(html_report_path, "/etc/pynt/results/results.html"))
-    
-    yield mounts
-    
-    if os.stat(html_report_path).st_size == 0:
-        raise HtmlReportNotCreatedException()
-    
-    webbrowser.open("file://{}".format(html_report_path))
-
-    if os.stat(html_report_path).st_size > 0:
-        report.PyntReporter(json_report_path).print_summary()   

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

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