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

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", 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,6 +4,7 @@ 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
 
@@ -94,5 +95,6 @@ class BaseCommand:
         user_id = login.user_id()
         if user_id:
             analytics.set_user_id(user_id)
+            log.add_user_details(user_id)
 
         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()

pyntcli/pynt_docker/pynt_container.py

@@ -9,19 +9,23 @@ import base64
 from pyntcli.ui import ui_thread
 from pyntcli.analytics import send as analytics
 from pyntcli.store import CredStore
-from pyntcli.auth.login import PYNT_CREDENTIALS , PYNT_SAAS, PYNT_BUCKET_NAME,PYNT_PARAM1, PYNT_PARAM2
+from pyntcli.auth.login import PYNT_ID, PYNT_SAAS, PYNT_BUCKET_NAME, PYNT_PARAM1, PYNT_PARAM2
 
 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
 
+
 class ImageUnavailableException(Exception):
     pass
 
+
 def get_docker_type():
     try:
         c = docker.from_env()
@@ -30,29 +34,31 @@ def get_docker_type():
         analytics.deferred_emit(analytics.DOCKER_PLATFORM, 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
+    except Exception:  # TODO: This is since windows is not behaving nice
         raise DockerNotAvailableException()
 
 
 class PyntBaseConatiner():
-    def __init__(self,docker_type,docker_arguments,mounts, environment={}) -> None:
+    def __init__(self, docker_type, docker_arguments, mounts, environment={}) -> None:
         self.docker_type = docker_type
         self.docker_arguments = docker_arguments
         self.mounts = mounts
         self.environment = environment
 
+
 class PyntDockerPort:
     def __init__(self, src, dest, name) -> None:
         self.src = src
         self.dest = dest
         self.name = name
 
-def get_container_with_arguments(args: argparse.Namespace , *port_args: PyntDockerPort) -> PyntBaseConatiner:
+
+def get_container_with_arguments(args: argparse.Namespace, *port_args: PyntDockerPort) -> PyntBaseConatiner:
     docker_arguments = []
     if "desktop" in get_docker_type().lower():
         ports = {}
@@ -61,22 +67,22 @@ def get_container_with_arguments(args: argparse.Namespace , *port_args: PyntDock
         docker_type = PyntDockerDesktopContainer(ports=ports)
     else:
         docker_type = PyntNativeContainer(network="host")
-        for p in port_args: 
+        for p in port_args:
             docker_arguments.append(p.name)
             docker_arguments.append(str(p.dest))
-   
+
     if "insecure" in args and args.insecure:
         docker_arguments.append("--insecure")
-    
-    if "application_id" in args and args.application_id: 
-        docker_arguments += ["--application-id",args.application_id]
 
-    if "proxy" in args and args.proxy: 
-        docker_arguments += ["--proxy",args.proxy]
+    if "application_id" in args and args.application_id:
+        docker_arguments += ["--application-id", args.application_id]
 
-    if "dev_flags" in args: 
+    if "proxy" in args and args.proxy:
+        docker_arguments += ["--proxy", args.proxy]
+
+    if "dev_flags" in args:
         docker_arguments += args.dev_flags.split(" ")
-    
+
     mounts = []
     if "host_ca" in args and args.host_ca:
         ca_name = os.path.basename(args.host_ca)
@@ -87,38 +93,41 @@ def get_container_with_arguments(args: argparse.Namespace , *port_args: PyntDock
         tc_name = os.path.basename(args.transport_config)
         docker_arguments += ["--transport-config", tc_name]
         mounts.append(create_mount(os.path.abspath(args.transport_config), "/etc/pynt/{}".format(tc_name)))
-    
-    env = {PYNT_CREDENTIALS:CredStore().get_access_token(), "PYNT_SAAS_URL": PYNT_SAAS}
+
+    env = {PYNT_ID: CredStore().get_tokens(), "PYNT_SAAS_URL": PYNT_SAAS}
     if user_set_all_variables():
         add_env_variables(env)
     return PyntBaseConatiner(docker_type, docker_arguments, mounts, env)
-    
+
+
 def _container_image_from_tag(tag: str) -> str:
-    if ":" in tag: 
+    if ":" in tag:
         return tag.split(":")[0]
 
     return tag
 
+
 def user_set_all_variables():
-        return all([PYNT_BUCKET_NAME, PYNT_PARAM1, PYNT_PARAM2])
-    
+    return all([PYNT_BUCKET_NAME, PYNT_PARAM1, PYNT_PARAM2])
+
+
 def add_env_variables(env: dict):
-        env["PYNT_BUCKET_NAME"] = PYNT_BUCKET_NAME
-        env["PYNT_PARAM1"] = base64.b64encode(PYNT_PARAM1.encode('utf-8'))
-        env["PYNT_PARAM2"] = base64.b64encode(PYNT_PARAM2.encode('utf-8'))
-        
+    env["PYNT_BUCKET_NAME"] = PYNT_BUCKET_NAME
+    env["PYNT_PARAM1"] = base64.b64encode(PYNT_PARAM1.encode('utf-8'))
+    env["PYNT_PARAM2"] = base64.b64encode(PYNT_PARAM2.encode('utf-8'))
+
+
 class PyntContainer():
     def __init__(self, image_name, tag, detach, base_container: PyntBaseConatiner) -> 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.detach = detach
-        self.stdout = None 
+        self.stdout = None
         self.running = False
         self.container_name = ""
         self.base_container = base_container
 
-    
     def _create_docker_client(self):
         self.docker_client = docker.from_env()
         pat = os.environ.get("DOCKER_PASSWORD")
@@ -126,28 +135,28 @@ class PyntContainer():
         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 len(c.image.tags) and _container_image_from_tag(c.image.tags[0]) == self.image:
                 c.kill()
-    
+
     def stop(self):
         if not self.running:
-            return 
+            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
@@ -155,47 +164,48 @@ class PyntContainer():
         l = self.docker_client.containers.list(filters={"name": self.container_name})
         if len(l) != 1:
             return False
-        
+
         return l[0].status == "running"
-    
+
     def pull_image(self):
         try:
             return self.docker_client.images.pull(self.image, tag=self.tag)
         except APIError as e:
-            analytics.emit(analytics.ERROR,{"error": "Unable to pull image from ghcr: {}".format(e)})
+            analytics.emit(analytics.ERROR, {"error": "Unable to pull image from ghcr: {}".format(e)})
+            ui_thread.print(ui_thread.PrinterText("Error: Docker unable to pull latest Pynt image due to VPN/proxy. If using a mirror for Docker images, visit docs.pynt.io for help.", ui_thread.PrinterText.WARNING))
             return None
 
     def get_image(self):
         try:
             image = self.pull_image()
             if not image:
-                image = self.docker_client.images.get('{}:{}'.format(self.image,self.tag))
+                ui_thread.print(ui_thread.PrinterText("Trying to get pynt local image", ui_thread.PrinterText.INFO))
+                image = self.docker_client.images.get('{}:{}'.format(self.image, self.tag))
             return image
         except ImageNotFound:
             raise ImageUnavailableException()
 
-    def run(self): 
+    def run(self):
         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.get_image()
         ui_thread.print(ui_thread.PrinterText("Docker pull done", ui_thread.PrinterText.INFO))
-    
+
         args = self.base_container.docker_arguments if self.base_container.docker_arguments else None
-            
 
         run_arguments = {
-                "image":image, 
-                "detach":self.detach,
-                "mounts":self.base_container.mounts,
-                "environment": self.base_container.environment,
-                "stream": True,
-                "remove": True,
-                "command": args
+            "image": image,
+            "detach": self.detach,
+            "mounts": self.base_container.mounts,
+            "environment": self.base_container.environment,
+            "stream": True,
+            "remove": True,
+            "command": args
         }
 
         run_arguments.update(self.base_container.docker_type.get_argumets())
@@ -206,13 +216,15 @@ class PyntContainer():
 
         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
@@ -230,13 +242,13 @@ class PyntContainerRegistery():
     @staticmethod
     def instance():
         if not PyntContainerRegistery._instance:
-            PyntContainerRegistery._instance = PyntContainerRegistery() 
+            PyntContainerRegistery._instance = PyntContainerRegistery()
 
         return PyntContainerRegistery._instance
 
     def register_container(self, c: PyntContainer):
-        self.containers.append(c) 
-    
+        self.containers.append(c)
+
     def stop_all_containers(self):
-        for c in self.containers: 
+        for c in self.containers:
             c.stop()

pyntcli/store/store.py

@@ -1,25 +1,25 @@
-from typing import Type 
-import os 
-import platform
+from typing import Type
+import os
 
 from .json_connector import JsonStoreConnector
 from .store_connector import StoreConnector
 
+
 class Store():
-    def __init__(self, file_location: str, connector_type: Type[StoreConnector]) -> None :
+    def __init__(self, file_location: str, connector_type: Type[StoreConnector]) -> None:
         self.file_location = file_location
-        self.connector:StoreConnector = None
+        self.connector: StoreConnector = None
         self._file = None
         self._connector_tpye = connector_type
-    
+
     def _get_file_data(self):
-        if self.connector: 
-            return 
+        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())
@@ -35,24 +35,29 @@ class Store():
     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 
+        return self
 
-    def __exit__(self, type, value, traceback): 
+    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)
-        
+
     def get_access_token(self):
         return self.get("token")["access_token"]
- 
+
+    def get_tokens(self):
+        all_tokens = self.get("token")
+        token_to_json_string = '{"token":'+str(all_tokens).replace("\'", "\"")+"}"
+        return token_to_json_string

{pyntcli-0.1.73.dist-info → pyntcli-0.1.74.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyntcli
-Version: 0.1.73
+Version: 0.1.74
 Summary: Command line utility to handle all of Pynt's different integrations
 Author-email: Pynt-io <support@pynt.io>
 Project-URL: Homepage, https://pynt.io