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

pyntcli/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.72"
+__version__ = "0.1.74"

pyntcli/analytics/send.py

@@ -4,26 +4,34 @@ import platform
 
 from pyntcli import __version__
 from pyntcli.transport import pynt_requests
+import pyntcli.log.log as log
 
 
 PYNT_DEFAULT_USER_ID = "d9e3b82b-2900-43bf-8c8f-7ffe2f0cda36"
 MIXPANEL_TOKEN = "05c26edb86084bbbb803eed6818cd8aa"
 MIXPANEL_URL = "https://api-eu.mixpanel.com/track?ip=1"
 
+logger = log.get_logger()
+
+
 def stop():
     if not AnalyticsSender._instance:
         return
     AnalyticsSender.instance().done()
 
+
 def emit(event, properties=None):
     AnalyticsSender.instance().emit(event, properties)
 
+
 def deferred_emit(event, properties=None):
     AnalyticsSender.instance().deferred_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"
@@ -31,6 +39,7 @@ CICD = "CI/CD"
 ERROR = "error"
 DOCKER_PLATFORM = "platform"
 
+
 class AnalyticsSender():
     _instance = None
 
@@ -38,7 +47,7 @@ class AnalyticsSender():
         self.user_id = user_id
         self.version = __version__
         self.events = []
-    
+
     @staticmethod
     def instance():
         if not AnalyticsSender._instance:
@@ -47,45 +56,51 @@ class 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
+        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():
+            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])
+            try:
+                pynt_requests.post(MIXPANEL_URL, json=[base_event])
+            except Exception:
+                logger.info(f"mixpanel unavailable, sending to logz: {base_event}")
         else:
             self.events.append(base_event)
 
     def deferred_emit(self, event, properties):
         base_event = self.base_event(event)
-        
+
         if properties:
-            for k,v in properties.items():
+            for k, v in properties.items():
                 base_event["properties"][k] = v
 
         self.events.append(base_event)
 
     def set_user_id(self, user_id):
         self.user_id = user_id
-        for i, _ in enumerate(self.events): 
+        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)
+            try:
+                pynt_requests.post(MIXPANEL_URL, json=self.events)
+            except Exception:
+                logger.info(f"mixpanel unavailable, sending to logz: {self.events}")
             self.events = []

pyntcli/auth/login.py

@@ -11,37 +11,42 @@ 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"
+
+PYNT_ID = "PYNT_ID"
 PYNT_SAAS = os.environ.get("PYNT_SAAS_URL") if os.environ.get("PYNT_SAAS_URL") else "https://api.pynt.io/v1"
 PYNT_BUCKET_NAME = os.environ.get("PYNT_BUCKET_NAME") if os.environ.get("PYNT_BUCKET_NAME") else ""
 PYNT_PARAM1 = os.environ.get("PYNT_PARAM1") if os.environ.get("PYNT_PARAM1") else ""
 PYNT_PARAM2 = os.environ.get("PYNT_PARAM2") if os.environ.get("PYNT_PARAM2") else ""
 
+
 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
+        self.login_wait_period = (60 * 3)  # 3 minutes
 
-    def create_login_request(self): 
+    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)") \
+        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
 
@@ -54,25 +59,26 @@ class Login():
                     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: 
+        with CredStore() as store:
             store.put("token", token)
 
 
 def refresh_request(refresh_token):
     return pynt_requests.post(PYNT_SAAS + "/auth/refresh", json={"refresh_token": refresh_token})
 
+
 def refresh_token():
     token = None
-    with CredStore() as store: 
+    with CredStore() as store:
         token = store.get("token")
 
-    if not token: 
+    if not token:
         Login().login()
-    
+
     access_token = token.get("access_token")
     if access_token and not is_jwt_expired(access_token):
         return
@@ -82,67 +88,71 @@ def refresh_token():
         Login().login()
         return
 
-    refresh_response = refresh_request(refresh) 
+    refresh_response = refresh_request(refresh)
     if refresh_response.status_code != 200:
         Login().login()
-        return 
+        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: 
+    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 
+            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) 
+    if not exp:
+        return True
+
+    return datetime.datetime.fromtimestamp(exp) < datetime.datetime.now() + datetime.timedelta(minutes=1)
+
 
 def validate_creds_structure(data):
-    try: 
+    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:    
+    except json.JSONDecodeError:
         raise InvalidTokenInEnvVarsException()
-  
 
-def should_login(): 
-    env_creds = os.environ.get(PYNT_CREDENTIALS, None)
+
+def should_login():
+    env_creds = os.environ.get(PYNT_ID, None)
     if env_creds:
         validated_creds = validate_creds_structure(env_creds)
         with CredStore() as store:
@@ -153,8 +163,8 @@ def should_login():
 
         if not token or token == store.connector.default_value:
             return True
-            
+
         if not token.get("refresh_token"):
-            return True 
-        
+            return True
+
         return False

pyntcli/commands/burp.py

@@ -18,7 +18,17 @@ from pyntcli.commands import util, sub_command
 from pyntcli.ui import report as cli_reporter
 from pyntcli.transport import pynt_requests
 
-methods = ["get", "post", "put", "delete", "patch", "options", "head", "trace", "connect"]
+methods = [
+    "get",
+    "post",
+    "put",
+    "delete",
+    "patch",
+    "options",
+    "head",
+    "trace",
+    "connect",
+]
 
 
 def is_valid_method(method: str):
@@ -29,7 +39,7 @@ def is_valid_method(method: str):
 
 def replay_req(item, proxy_port):
     url = item["url"]
-    decoded_req = base64.b64decode(item["request"]["#text"]).decode('utf-8')
+    decoded_req = base64.b64decode(item["request"]["#text"]).decode("utf-8")
     method = decoded_req.split("\r\n")[0].split(" ")[0]
 
     if not is_valid_method(method):
@@ -52,7 +62,16 @@ def replay_req(item, proxy_port):
         headers[key] = value
 
     body = decoded_req.split("\r\n\r\n")[1]
-    pynt_requests.request_from_xml(method=method, url=url, headers=headers, data=body, proxies={'http': '0.0.0.0:{}'.format(proxy_port), 'https': '0.0.0.0:{}'.format(proxy_port)})
+    pynt_requests.request_from_xml(
+        method=method,
+        url=url,
+        headers=headers,
+        data=body,
+        proxies={
+            "http": "0.0.0.0:{}".format(proxy_port),
+            "https": "0.0.0.0:{}".format(proxy_port),
+        },
+    )
 
 
 def run_burp_xml(doc, proxy_port):
@@ -76,20 +95,25 @@ def is_valid_xml(doc) -> bool:
 
 
 def burp_usage():
-    return ui_thread.PrinterText("Burp integration to Pynt. Run a security scan with a given burp xml output file.") \
-        .with_line("") \
-        .with_line("Usage:", style=ui_thread.PrinterText.HEADER) \
-        .with_line("\tpynt burp [OPTIONS]") \
-        .with_line("") \
-        .with_line("Options:", style=ui_thread.PrinterText.HEADER) \
-        .with_line("\t--xml - Path to the xml to run tests on") \
-        .with_line("\t--port - Set the port pynt will listen to (DEFAULT: 5001)") \
-        .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.") \
-        .with_line("\t--return-error - 'all-findings' (warnings, or errors), 'errors-only', 'never' (default), ")
+    return (
+        ui_thread.PrinterText(
+            "Burp integration to Pynt. Run a security scan with a given burp xml output file."
+        )
+        .with_line("")
+        .with_line("Usage:", style=ui_thread.PrinterText.HEADER)
+        .with_line("\tpynt burp [OPTIONS]")
+        .with_line("")
+        .with_line("Options:", style=ui_thread.PrinterText.HEADER)
+        .with_line("\t--xml - Path to the xml to run tests on")
+        .with_line("\t--port - Set the port pynt will listen to (DEFAULT: 5001)")
+        .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--application-id - Attach the scan to an application, you can find the ID in your applications area at app.pynt.io")
+        .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)")
+    )
 
 
 class BurpCommand(sub_command.PyntSubCommand):
@@ -110,25 +134,38 @@ class BurpCommand(sub_command.PyntSubCommand):
         burp_cmd.add_argument("--xml", help="", default="", required=True)
         burp_cmd.add_argument("--ca-path", type=str, default="")
         burp_cmd.add_argument("--report", type=str, default="")
-        burp_cmd.add_argument('--return-error', choices=['all-findings', 'errors-only', 'never'], default='never')
+        burp_cmd.add_argument(
+            "--return-error",
+            choices=["all-findings", "errors-only", "never"],
+            default="never"
+        )
         burp_cmd.print_usage = self.print_usage
         burp_cmd.print_help = self.print_usage
         return burp_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)})
+        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 = 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})
+            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)
@@ -136,47 +173,88 @@ class BurpCommand(sub_command.PyntSubCommand):
 
     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})
+            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))
+                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"))
+        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))
+                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)))
+            container.mounts.append(
+                pynt_container.create_mount(
+                    os.path.abspath(args.ca_path), "/etc/pynt/{}".format(ca_name)
+                )
+            )
+
+        container.docker_arguments += ["--test-name", os.path.basename(args.xml)]
 
         if not os.path.isfile(args.xml):
-            ui_thread.print(ui_thread.PrinterText("Could not find the provided xml path, please provide with a valid xml path", ui_thread.PrinterText.WARNING))
+            ui_thread.print(
+                ui_thread.PrinterText(
+                    "Could not find the provided xml path, please provide with a valid xml path",
+                    ui_thread.PrinterText.WARNING,
+                )
+            )
             return
 
         doc = parse_xml(args.xml)
         if not doc:
-            ui_thread.print(ui_thread.PrinterText("Invalid file format. please provide a valid xml", ui_thread.PrinterText.WARNING))
+            ui_thread.print(
+                ui_thread.PrinterText(
+                    "Invalid file format. please provide a valid xml",
+                    ui_thread.PrinterText.WARNING,
+                )
+            )
             return
 
         if not is_valid_xml(doc):
-            ui_thread.print(ui_thread.PrinterText("Invalid xml file. please provide a valid xml output generated from burp", ui_thread.PrinterText.WARNING))
+            ui_thread.print(
+                ui_thread.PrinterText(
+                    "Invalid xml file. please provide a valid xml output generated from burp",
+                    ui_thread.PrinterText.WARNING,
+                )
+            )
             return
 
-        proxy_docker = pynt_container.PyntContainer(image_name=pynt_container.PYNT_DOCKER_IMAGE,
-                                                    tag="proxy-latest",
-                                                    detach=True,
-                                                    base_container=container)
+        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)
 
@@ -187,12 +265,21 @@ class BurpCommand(sub_command.PyntSubCommand):
 
         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):
+        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())))
+            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())))
+            json_report_path = os.path.join(
+                tempfile.gettempdir(), "pynt_report_{}.json".format(int(time.time()))
+            )
 
             if "report" in args and args.report:
                 full_path = os.path.abspath(args.report)