pyntcli 0.1.72__py3-none-any.whl → 0.1.74__py3-none-any.whl

pyntcli/commands/newman.py

@@ -8,32 +8,51 @@ 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.") \
-            .with_line("\t--return-error - 'all-findings' (warnings, or errors), 'errors-only', 'never' (default), ")
+    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."
+        )
+        .with_line(
+            "\t--application-id - Attach the scan to an application, you can find the ID in your applications area at app.pynt.io"
+        )
+        .with_line(
+            "\t--return-error - 'all-findings' (warnings, or errors), 'errors-only', 'never' (default) "
+        )
+    )
+
 
 class NewmanSubCommand(sub_command.PyntSubCommand):
     def __init__(self, name) -> None:
         super().__init__(name)
 
-    def usage(self, *args): 
+    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", nargs='+', required=False) 
-        newman_cmd.add_argument("--reporters", action="store_true",default=False,  required=False) 
-        newman_cmd.add_argument('--return-error', choices=['all-findings', 'errors-only', 'never'], default='never')
+        newman_cmd.add_argument("--collection", type=str, required=True)
+        newman_cmd.add_argument("--environment", nargs="+", required=False)
+        newman_cmd.add_argument(
+            "--reporters", action="store_true", default=False, required=False
+        )
+        newman_cmd.add_argument(
+            "--return-error",
+            choices=["all-findings", "errors-only", "never"],
+            default="never"
+        )
 
         newman_cmd.print_usage = self.usage
         newman_cmd.print_help = self.usage
@@ -41,38 +60,67 @@ class NewmanSubCommand(sub_command.PyntSubCommand):
 
     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"))
+        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))
+        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)))
-         
+        container.mounts.append(
+            pynt_container.create_mount(
+                os.path.abspath(args.collection), "/etc/pynt/{}".format(collection_name)
+            )
+        )
+
         if "environment" in args and args.environment:
             env_names = []
             for environ in args.environment:
                 if not os.path.isfile(environ):
-                    ui_thread.print(ui_thread.PrinterText(f"Could not find the provided environment path: {environ}, please provide with a valid environment path", ui_thread.PrinterText.WARNING))
+                    ui_thread.print(
+                        ui_thread.PrinterText(
+                            f"Could not find the provided environment path: {environ}, please provide with a valid environment path",
+                            ui_thread.PrinterText.WARNING,
+                        )
+                    )
                     return
                 env_name = os.path.basename(environ)
                 env_names.append(env_name)
-                container.mounts.append(pynt_container.create_mount(os.path.abspath(environ), "/etc/pynt/{}".format(env_name)))    
+                container.mounts.append(
+                    pynt_container.create_mount(
+                        os.path.abspath(environ), "/etc/pynt/{}".format(env_name)
+                    )
+                )
             container.docker_arguments += ["-e", ",".join(env_names)]
-               
+
         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 = 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))
+
+            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):
+
+            with ui_thread.progress(
+                "ws://localhost:{}/progress".format(port),
+                healthcheck,
+                "scan in progress...",
+                100,
+            ):
                 while newman_docker.is_alive():
                     time.sleep(1)

pyntcli/commands/postman.py

@@ -1,5 +1,5 @@
 import argparse
-import time 
+import time
 import websocket
 import webbrowser
 import os
@@ -14,28 +14,31 @@ from pyntcli.pynt_docker import pynt_container
 from pyntcli.ui import ui_thread
 from pyntcli.transport import pynt_requests
 
+
 class PyntPostmanException(Exception):
     pass
 
+
 class PyntWebSocketException(PyntPostmanException):
     pass
 
+
 logger = log.get_logger()
 
+
 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("Usage:", style=ui_thread.PrinterText.HEADER) \
         .with_line("\tpynt postman [OPTIONS]") \
         .with_line("") \
-        .with_line("Options:",style=ui_thread.PrinterText.HEADER) \
+        .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): 
+class PostmanSubCommand(sub_command.PyntSubCommand):
     def __init__(self, name) -> None:
         super().__init__(name)
         self.server_base_url = "http://localhost:{}/api"
@@ -43,18 +46,17 @@ class PostmanSubCommand(sub_command.PyntSubCommand):
     def usage(self, *args):
         ui_thread.print(postman_usage())
 
-    def add_cmd(self, parent_command: argparse._SubParsersAction) -> argparse.ArgumentParser: 
+    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 scan_id_generator(self, port):
         try:
             ws = websocket.WebSocket()
-            ws.connect("ws://localhost:{}/api/scan_id".format(port))    
+            ws.connect("ws://localhost:{}/api/scan_id".format(port))
 
             while ws.connected:
                 scan_id = ws.recv()
@@ -69,7 +71,7 @@ class PostmanSubCommand(sub_command.PyntSubCommand):
         finally:
             ws.close()
 
-    def get_report(self, port,report_format, scan_id):
+    def get_report(self, port, report_format, scan_id):
         while True:
             res = pynt_requests.get(self.server_base_url.format(port) + "/report?format={}".format(report_format), params={"scanId": scan_id})
             if res.status_code == HTTPStatus.OK:
@@ -79,42 +81,41 @@ class PostmanSubCommand(sub_command.PyntSubCommand):
                 continue
             if res.status_code == HTTPStatus.BAD_REQUEST:
                 return
-            if res.status_code == 517: #pynt did not recieve any requests 
+            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 
+                return
             ui_thread.print("Error in polling for scan report: {}".format(res.text))
-            return 
-
+            return
 
     def run_cmd(self, args: argparse.Namespace):
-        if "application_id" in args and args.application_id: 
-            ui_thread.print("application-id is not supported in postman integration, use the request body in the start scan request")
+        if "application_id" in args and args.application_id:
+            ui_thread.print("application-id is not supported in postman integration, use the collection variables to set application id.")
             args.application_id = ""
 
-        container = pynt_container.get_container_with_arguments(args ,pynt_container.PyntDockerPort("5001", args.port, name="--port"))        
-       
+        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 = 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) 
-        
+        ui_thread.print_generator(postman_docker.stdout)
+
         util.wait_for_healthcheck("http://localhost:{}".format(args.port))
 
         for scan_id in self.scan_id_generator(args.port):
-            html_report = self.get_report(args.port, "html",scan_id)
+            html_report = self.get_report(args.port, "html", scan_id)
             html_report_path = os.path.join(tempfile.gettempdir(), "pynt_report_{}.html".format(int(time.time())))
 
             if html_report:
-                with open(html_report_path, "w") as html_file:
+                with open(html_report_path, "w", encoding="utf-8") as html_file:
                     html_file.write(html_report)
                 webbrowser.open("file://{}".format(html_report_path))
-        
+
         if not postman_docker.is_alive():
             ui_thread.print(ui_thread.PrinterText("Pynt container is not available", ui_thread.PrinterText.WARNING))

pyntcli/commands/pynt_cmd.py

@@ -5,6 +5,9 @@ from pyntcli.analytics import send as analytics
 from pyntcli.transport import pynt_requests
 from pyntcli.ui import ui_thread
 
+from requests.exceptions import SSLError, HTTPError
+
+
 from . import command, listen, postman, root, sub_command, id_command, newman, har, burp
 
 avail_sub_commands = [
@@ -17,29 +20,40 @@ avail_sub_commands = [
     burp.BurpCommand("burp"),
 ]
 
+
 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","")
+    try:
+        res = pynt_requests.get(VERSION_CHECK_URL)
+        res.raise_for_status()
 
-    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))
+        latest_versions = res.text.replace("\n", "")
 
-class PyntCommand: 
+        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))
+    except SSLError:
+        ui_thread.print(ui_thread.PrinterText("""Error: Unable to check if Pynt CLI version is up-to-date due to VPN/proxy. Run Pynt with --insecure to fix.""", ui_thread.PrinterText.WARNING))
+    except HTTPError:
+        ui_thread.print("""Unable to check if Pynt CLI version is up-to-date""")
+
+
+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}
@@ -50,25 +64,25 @@ class PyntCommand:
         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]): 
+    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") 
+
+        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)

pyntcli/commands/root.py

@@ -4,36 +4,52 @@ import sys
 from os import environ
 
 from pyntcli.auth import login
+import pyntcli.log.log as log
 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)
+    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("\thar       -   run scan on static har file")
+        .with_line("\tcommand   -   run scan with a given command")
+        .with_line("\tlisten    -   run scan with a routed traffic")
+        .with_line("\tburp      -   run scan on a burp xml output file")
+        .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())
 
 
 def check_cicd_context():
-    if environ.get('GITHUB_ACTION') is not None:
+    if environ.get("GITHUB_ACTION") is not None:
         analytics.emit(analytics.CICD, {"env": "GitHub"})
         return
-    if environ.get('GITLAB_USER_ID') is not None:
+    if environ.get("GITLAB_USER_ID") is not None:
         analytics.emit(analytics.CICD, {"env": "GitLab"})
         return
-    if environ.get('JENKINS_HOME') is not None:
+    if environ.get("JENKINS_HOME") is not None:
         analytics.emit(analytics.CICD, {"env": "Jenkins"})
-    
 
-class BaseCommand():
+
+class BaseCommand:
     def __init__(self) -> None:
         self.base: argparse.ArgumentParser = None
         self.subparser: argparse._SubParsersAction = None
@@ -41,15 +57,21 @@ class BaseCommand():
     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 
-   
+        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(
+            "--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="")
         parser.add_argument("--transport-config", type=str, default="")
         parser.add_argument("--application-id", type=str, default="", required=False)
@@ -58,7 +80,7 @@ class BaseCommand():
     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):
@@ -67,11 +89,12 @@ class BaseCommand():
         if login.should_login():
             l = login.Login().login()
         else:
-            login.refresh_token()  
-        
+            login.refresh_token()
+
         analytics.emit(analytics.LOGIN_DONE)
         user_id = login.user_id()
         if user_id:
             analytics.set_user_id(user_id)
+            log.add_user_details(user_id)
 
-        check_cicd_context()
+        check_cicd_context()

pyntcli/log/log.py

@@ -15,7 +15,8 @@ LOGGING = {
             'level': 'DEBUG',
             'token': "KOfjdWTcZXmjAwAOslpFYwhLpDzFTfJl",
             'logs_drain_timeout': 5,
-            'url': 'https://listener.logz.io:8071'
+            'url': 'https://listener.logz.io:8071',
+            'retries_no': 1,
         }
     },
     'loggers': {

pyntcli/main.py

@@ -45,6 +45,7 @@ def start_analytics():
     user_id = login.user_id()
     if user_id:
         analytics.set_user_id(user_id)
+        log.add_user_details(user_id)
 
 
 def main():
@@ -63,7 +64,7 @@ def main():
         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 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))
+        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. Run again with --insecure", ui_thread.PrinterText.WARNING))
     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"})
@@ -71,8 +72,8 @@ def main():
         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"})
     except pynt_container.ImageUnavailableException:
-        analytics.emit(analytics.ERROR, {"error": "Couldnt pull pynt image and no local image found"})
-        pynt_errors.unexpected_error()
+        analytics.emit(analytics.ERROR, {"error": "Couldn't pull pynt image and no local image found"})
+        ui_thread.print(ui_thread.PrinterText("Error: Couldn't pull pynt image and no local image found.",ui_thread.PrinterText.WARNING))
     except HtmlReportNotCreatedException:
         analytics.emit(analytics.ERROR, {"error": "Html report was not created"})
         pynt_errors.unexpected_error()