souleyez 2.43.29__py3-none-any.whl → 3.0.0__py3-none-any.whl

souleyez/parsers/dalfox_parser.py

@@ -50,20 +50,15 @@ def parse_dalfox_output(output: str, target: str = "") -> Dict[str, Any]:
         }
     """
     result = {
-        'target': target,
-        'vulnerabilities': [],
-        'parameters': [],
-        'warnings': [],
-        'info': [],
-        'stats': {
-            'total_vulns': 0,
-            'reflected': 0,
-            'dom': 0,
-            'parameters_found': 0
-        }
+        "target": target,
+        "vulnerabilities": [],
+        "parameters": [],
+        "warnings": [],
+        "info": [],
+        "stats": {"total_vulns": 0, "reflected": 0, "dom": 0, "parameters_found": 0},
     }
 
-    lines = output.split('\n')
+    lines = output.split("\n")
 
     for line in lines:
         line = line.strip()
@@ -71,7 +66,7 @@ def parse_dalfox_output(output: str, target: str = "") -> Dict[str, Any]:
             continue
 
         # Try JSON parsing first
-        if line.startswith('{'):
+        if line.startswith("{"):
             try:
                 data = json.loads(line)
                 _process_json_line(data, result)
@@ -83,139 +78,139 @@ def parse_dalfox_output(output: str, target: str = "") -> Dict[str, Any]:
         _process_text_line(line, result)
 
     # Update stats
-    result['stats']['total_vulns'] = len(result['vulnerabilities'])
-    result['stats']['parameters_found'] = len(result['parameters'])
+    result["stats"]["total_vulns"] = len(result["vulnerabilities"])
+    result["stats"]["parameters_found"] = len(result["parameters"])
 
     return result
 
 
 def _process_json_line(data: Dict, result: Dict):
     """Process a JSON-formatted line from Dalfox."""
-    msg_type = data.get('type', '')
-    msg_data = data.get('data', '')
-    poc = data.get('poc', '')
-    cwe = data.get('cwe', '')
+    msg_type = data.get("type", "")
+    msg_data = data.get("data", "")
+    poc = data.get("poc", "")
+    cwe = data.get("cwe", "")
 
-    if msg_type == 'V':
+    if msg_type == "V":
         # Vulnerability found
         vuln = {
-            'type': _detect_xss_type(msg_data),
-            'parameter': _extract_parameter(poc or msg_data),
-            'payload': _extract_payload(poc or msg_data),
-            'poc': poc,
-            'cwe': cwe,
-            'raw': msg_data
+            "type": _detect_xss_type(msg_data),
+            "parameter": _extract_parameter(poc or msg_data),
+            "payload": _extract_payload(poc or msg_data),
+            "poc": poc,
+            "cwe": cwe,
+            "raw": msg_data,
         }
-        result['vulnerabilities'].append(vuln)
+        result["vulnerabilities"].append(vuln)
 
-        if 'dom' in msg_data.lower():
-            result['stats']['dom'] += 1
+        if "dom" in msg_data.lower():
+            result["stats"]["dom"] += 1
         else:
-            result['stats']['reflected'] += 1
+            result["stats"]["reflected"] += 1
 
-    elif msg_type == 'I':
-        result['info'].append(msg_data)
+    elif msg_type == "I":
+        result["info"].append(msg_data)
         # Check for parameter discovery
         param = _extract_discovered_param(msg_data)
-        if param and param not in result['parameters']:
-            result['parameters'].append(param)
+        if param and param not in result["parameters"]:
+            result["parameters"].append(param)
 
-    elif msg_type == 'W':
-        result['warnings'].append(msg_data)
+    elif msg_type == "W":
+        result["warnings"].append(msg_data)
 
 
 def _process_text_line(line: str, result: Dict):
     """Process a text-formatted line from Dalfox."""
 
     # Vulnerability line: [V] or [POC]
-    if line.startswith('[V]') or 'Vulnerable' in line:
+    if line.startswith("[V]") or "Vulnerable" in line:
         vuln = {
-            'type': _detect_xss_type(line),
-            'parameter': _extract_parameter(line),
-            'payload': _extract_payload(line),
-            'poc': '',
-            'cwe': 'CWE-79',
-            'raw': line
+            "type": _detect_xss_type(line),
+            "parameter": _extract_parameter(line),
+            "payload": _extract_payload(line),
+            "poc": "",
+            "cwe": "CWE-79",
+            "raw": line,
         }
-        result['vulnerabilities'].append(vuln)
+        result["vulnerabilities"].append(vuln)
 
-        if 'dom' in line.lower():
-            result['stats']['dom'] += 1
+        if "dom" in line.lower():
+            result["stats"]["dom"] += 1
         else:
-            result['stats']['reflected'] += 1
+            result["stats"]["reflected"] += 1
 
-    elif line.startswith('[POC]'):
+    elif line.startswith("[POC]"):
         # Add POC to last vulnerability
-        poc = line.replace('[POC]', '').strip()
-        if result['vulnerabilities']:
-            result['vulnerabilities'][-1]['poc'] = poc
+        poc = line.replace("[POC]", "").strip()
+        if result["vulnerabilities"]:
+            result["vulnerabilities"][-1]["poc"] = poc
 
-    elif line.startswith('[I]') or 'Found parameter' in line:
-        result['info'].append(line)
+    elif line.startswith("[I]") or "Found parameter" in line:
+        result["info"].append(line)
         param = _extract_discovered_param(line)
-        if param and param not in result['parameters']:
-            result['parameters'].append(param)
+        if param and param not in result["parameters"]:
+            result["parameters"].append(param)
 
-    elif line.startswith('[W]') or 'WAF' in line:
-        result['warnings'].append(line)
+    elif line.startswith("[W]") or "WAF" in line:
+        result["warnings"].append(line)
 
 
 def _detect_xss_type(text: str) -> str:
     """Detect the type of XSS from the message."""
     text_lower = text.lower()
-    if 'dom' in text_lower:
-        return 'dom'
-    elif 'stored' in text_lower:
-        return 'stored'
+    if "dom" in text_lower:
+        return "dom"
+    elif "stored" in text_lower:
+        return "stored"
     else:
-        return 'reflected'
+        return "reflected"
 
 
 def _extract_parameter(text: str) -> str:
     """Extract the vulnerable parameter name from text."""
     # Look for common patterns like ?param=, &param=
-    match = re.search(r'[?&]([a-zA-Z0-9_-]+)=', text)
+    match = re.search(r"[?&]([a-zA-Z0-9_-]+)=", text)
     if match:
         return match.group(1)
-    return ''
+    return ""
 
 
 def _extract_payload(text: str) -> str:
     """Extract the XSS payload from text."""
     # Look for script tags or event handlers
     patterns = [
-        r'(<script[^>]*>.*?</script>)',
-        r'(<img[^>]*onerror[^>]*>)',
-        r'(<svg[^>]*onload[^>]*>)',
+        r"(<script[^>]*>.*?</script>)",
+        r"(<img[^>]*onerror[^>]*>)",
+        r"(<svg[^>]*onload[^>]*>)",
         r'(javascript:[^\s"\']+)',
-        r'(%3C[^%]*%3E)',  # URL encoded
+        r"(%3C[^%]*%3E)",  # URL encoded
     ]
     for pattern in patterns:
         match = re.search(pattern, text, re.IGNORECASE)
         if match:
             return match.group(1)
-    return ''
+    return ""
 
 
 def _extract_discovered_param(text: str) -> str:
     """Extract discovered parameter name from info message."""
     # Patterns like "Found parameter: q" or "parameter q"
     patterns = [
-        r'parameter[:\s]+([a-zA-Z0-9_-]+)',
-        r'param[:\s]+([a-zA-Z0-9_-]+)',
+        r"parameter[:\s]+([a-zA-Z0-9_-]+)",
+        r"param[:\s]+([a-zA-Z0-9_-]+)",
     ]
     for pattern in patterns:
         match = re.search(pattern, text, re.IGNORECASE)
         if match:
             return match.group(1)
-    return ''
+    return ""
 
 
 def get_vulnerable_parameters(parsed: Dict[str, Any]) -> List[str]:
     """Get list of parameters that have XSS vulnerabilities."""
     params = set()
-    for vuln in parsed.get('vulnerabilities', []):
-        param = vuln.get('parameter')
+    for vuln in parsed.get("vulnerabilities", []):
+        param = vuln.get("parameter")
         if param:
             params.add(param)
     return list(params)
@@ -224,8 +219,8 @@ def get_vulnerable_parameters(parsed: Dict[str, Any]) -> List[str]:
 def get_pocs(parsed: Dict[str, Any]) -> List[str]:
     """Get list of proof-of-concept URLs."""
     pocs = []
-    for vuln in parsed.get('vulnerabilities', []):
-        poc = vuln.get('poc')
+    for vuln in parsed.get("vulnerabilities", []):
+        poc = vuln.get("poc")
         if poc:
             pocs.append(poc)
     return pocs
@@ -233,4 +228,4 @@ def get_pocs(parsed: Dict[str, Any]) -> List[str]:
 
 def has_critical_findings(parsed: Dict[str, Any]) -> bool:
     """Check if there are any XSS vulnerabilities (always critical)."""
-    return len(parsed.get('vulnerabilities', [])) > 0
+    return len(parsed.get("vulnerabilities", [])) > 0

souleyez/parsers/dnsrecon_parser.py

@@ -36,16 +36,16 @@ def parse_dnsrecon_output(output: str, target: str = "") -> Dict[str, Any]:
         }
     """
     result = {
-        'target_domain': target,
-        'hosts': [],
-        'nameservers': [],
-        'mail_servers': [],
-        'txt_records': [],
-        'subdomains': [],
-        'count': 0
+        "target_domain": target,
+        "hosts": [],
+        "nameservers": [],
+        "mail_servers": [],
+        "txt_records": [],
+        "subdomains": [],
+        "count": 0,
     }
 
-    lines = output.split('\n')
+    lines = output.split("\n")
     seen_hosts = set()
     seen_subdomains = set()
 
@@ -53,7 +53,7 @@ def parse_dnsrecon_output(output: str, target: str = "") -> Dict[str, Any]:
         line_stripped = line.strip()
 
         # Skip empty lines and headers
-        if not line_stripped or line_stripped.startswith('[-]'):
+        if not line_stripped or line_stripped.startswith("[-]"):
             continue
 
         # Parse DNS records from dnsrecon output
@@ -66,77 +66,79 @@ def parse_dnsrecon_output(output: str, target: str = "") -> Dict[str, Any]:
         hostname = None
         ip = None
 
-        if line_stripped.startswith('[*]') or line_stripped.startswith('[+]'):
+        if line_stripped.startswith("[*]") or line_stripped.startswith("[+]"):
             # Format: [*] or [+] <type> <hostname> <ip>
             # [*] = informational, [+] = found/success
             parts = line_stripped.split()
             if len(parts) >= 4:
                 record_type = parts[1]
                 hostname = parts[2].lower()
-                ip = parts[3] if len(parts) > 3 else ''
-        elif ' INFO ' in line_stripped:
+                ip = parts[3] if len(parts) > 3 else ""
+        elif " INFO " in line_stripped:
             # New format: TIMESTAMP INFO <type> <hostname> <ip>
             # Split on INFO and parse the rest
-            info_idx = line_stripped.find(' INFO ')
+            info_idx = line_stripped.find(" INFO ")
             if info_idx != -1:
-                record_part = line_stripped[info_idx + 6:].strip()
+                record_part = line_stripped[info_idx + 6 :].strip()
                 parts = record_part.split()
                 if len(parts) >= 3:
                     record_type = parts[0]
                     hostname = parts[1].lower()
-                    ip = parts[2] if len(parts) > 2 else ''
+                    ip = parts[2] if len(parts) > 2 else ""
 
         if record_type and hostname:
             # Validate IP (both IPv4 and basic IPv6)
-            is_ipv4 = re.match(r'^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$', ip) if ip else False
+            is_ipv4 = (
+                re.match(r"^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$", ip) if ip else False
+            )
 
-            if record_type == 'A' and is_ipv4:
+            if record_type == "A" and is_ipv4:
                 if hostname not in seen_hosts:
                     seen_hosts.add(hostname)
-                    result['hosts'].append({
-                        'hostname': hostname,
-                        'ip': ip,
-                        'type': 'A'
-                    })
+                    result["hosts"].append(
+                        {"hostname": hostname, "ip": ip, "type": "A"}
+                    )
                     if hostname != target and hostname not in seen_subdomains:
                         seen_subdomains.add(hostname)
-                        result['subdomains'].append(hostname)
+                        result["subdomains"].append(hostname)
 
-            elif record_type == 'NS':
-                if hostname not in result['nameservers']:
-                    result['nameservers'].append(hostname)
+            elif record_type == "NS":
+                if hostname not in result["nameservers"]:
+                    result["nameservers"].append(hostname)
 
-            elif record_type == 'MX':
-                if hostname not in result['mail_servers']:
-                    result['mail_servers'].append(hostname)
+            elif record_type == "MX":
+                if hostname not in result["mail_servers"]:
+                    result["mail_servers"].append(hostname)
 
-            elif record_type == 'SOA':
+            elif record_type == "SOA":
                 # SOA records can also be nameservers
-                if hostname not in result['nameservers']:
-                    result['nameservers'].append(hostname)
+                if hostname not in result["nameservers"]:
+                    result["nameservers"].append(hostname)
 
         # Parse subdomain brute force results: [*] Subdomain: api.example.com IP: 1.2.3.4
-        subdomain_match = re.search(r'Subdomain:\s+(\S+)\s+IP:\s+(\d+\.\d+\.\d+\.\d+)', line_stripped)
+        subdomain_match = re.search(
+            r"Subdomain:\s+(\S+)\s+IP:\s+(\d+\.\d+\.\d+\.\d+)", line_stripped
+        )
         if subdomain_match:
             hostname = subdomain_match.group(1).lower()
             ip = subdomain_match.group(2)
             if hostname not in seen_hosts:
                 seen_hosts.add(hostname)
-                result['hosts'].append({
-                    'hostname': hostname,
-                    'ip': ip,
-                    'type': 'Subdomain'
-                })
+                result["hosts"].append(
+                    {"hostname": hostname, "ip": ip, "type": "Subdomain"}
+                )
                 if hostname not in seen_subdomains:
                     seen_subdomains.add(hostname)
-                    result['subdomains'].append(hostname)
+                    result["subdomains"].append(hostname)
 
-    result['count'] = len(result['hosts'])
+    result["count"] = len(result["hosts"])
 
     return result
 
 
-def map_to_hosts(parsed_data: Dict[str, Any], engagement_id: int) -> List[Dict[str, Any]]:
+def map_to_hosts(
+    parsed_data: Dict[str, Any], engagement_id: int
+) -> List[Dict[str, Any]]:
     """
     Convert parsed DNSRecon data into host records for database storage.
 
@@ -151,26 +153,28 @@ def map_to_hosts(parsed_data: Dict[str, Any], engagement_id: int) -> List[Dict[s
     """
     hosts = []
 
-    for host_data in parsed_data.get('hosts', []):
-        hostname = host_data.get('hostname', '')
-        ip = host_data.get('ip', '')
-        record_type = host_data.get('type', 'Unknown')
+    for host_data in parsed_data.get("hosts", []):
+        hostname = host_data.get("hostname", "")
+        ip = host_data.get("ip", "")
+        record_type = host_data.get("type", "Unknown")
 
         host = {
-            'ip_address': ip,
-            'hostname': hostname,
-            'os_name': 'Unknown',
-            'status': 'up',
-            'notes': f"Discovered by dnsrecon ({record_type} record) for domain: {parsed_data.get('target_domain', '')}",
-            'tags': ['dns', 'dnsrecon', record_type.lower()],
-            'source': 'dnsrecon'
+            "ip_address": ip,
+            "hostname": hostname,
+            "os_name": "Unknown",
+            "status": "up",
+            "notes": f"Discovered by dnsrecon ({record_type} record) for domain: {parsed_data.get('target_domain', '')}",
+            "tags": ["dns", "dnsrecon", record_type.lower()],
+            "source": "dnsrecon",
         }
         hosts.append(host)
 
     return hosts
 
 
-def map_to_osint(parsed_data: Dict[str, Any], engagement_id: int, job_id: int = None) -> List[Dict[str, Any]]:
+def map_to_osint(
+    parsed_data: Dict[str, Any], engagement_id: int, job_id: int = None
+) -> List[Dict[str, Any]]:
     """
     Convert parsed DNSRecon data into OSINT records for database storage.
 
@@ -185,54 +189,62 @@ def map_to_osint(parsed_data: Dict[str, Any], engagement_id: int, job_id: int =
         List of OSINT dicts ready for storage
     """
     osint_records = []
-    target = parsed_data.get('target_domain', 'unknown')
+    target = parsed_data.get("target_domain", "unknown")
 
     # Add nameservers
-    for ns in parsed_data.get('nameservers', []):
-        osint_records.append({
-            'data_type': 'nameserver',
-            'value': ns,
-            'source': 'dnsrecon',
-            'engagement_id': engagement_id,
-            'job_id': job_id,
-            'notes': f'Nameserver for {target}'
-        })
+    for ns in parsed_data.get("nameservers", []):
+        osint_records.append(
+            {
+                "data_type": "nameserver",
+                "value": ns,
+                "source": "dnsrecon",
+                "engagement_id": engagement_id,
+                "job_id": job_id,
+                "notes": f"Nameserver for {target}",
+            }
+        )
 
     # Add mail servers
-    for mx in parsed_data.get('mail_servers', []):
-        osint_records.append({
-            'data_type': 'mail_server',
-            'value': mx,
-            'source': 'dnsrecon',
-            'engagement_id': engagement_id,
-            'job_id': job_id,
-            'notes': f'Mail server for {target}'
-        })
+    for mx in parsed_data.get("mail_servers", []):
+        osint_records.append(
+            {
+                "data_type": "mail_server",
+                "value": mx,
+                "source": "dnsrecon",
+                "engagement_id": engagement_id,
+                "job_id": job_id,
+                "notes": f"Mail server for {target}",
+            }
+        )
 
     # Add TXT records (often contain SPF, DKIM, DMARC, verification codes)
-    for txt in parsed_data.get('txt_records', []):
-        osint_records.append({
-            'data_type': 'txt_record',
-            'value': txt[:500],  # Limit length
-            'source': 'dnsrecon',
-            'engagement_id': engagement_id,
-            'job_id': job_id,
-            'notes': f'TXT record for {target}'
-        })
+    for txt in parsed_data.get("txt_records", []):
+        osint_records.append(
+            {
+                "data_type": "txt_record",
+                "value": txt[:500],  # Limit length
+                "source": "dnsrecon",
+                "engagement_id": engagement_id,
+                "job_id": job_id,
+                "notes": f"TXT record for {target}",
+            }
+        )
 
     # Add subdomains as hosts
-    for subdomain in parsed_data.get('subdomains', []):
-        osint_records.append({
-            'data_type': 'host',
-            'value': subdomain,
-            'source': 'dnsrecon',
-            'engagement_id': engagement_id,
-            'job_id': job_id,
-            'notes': f'Subdomain of {target}'
-        })
+    for subdomain in parsed_data.get("subdomains", []):
+        osint_records.append(
+            {
+                "data_type": "host",
+                "value": subdomain,
+                "source": "dnsrecon",
+                "engagement_id": engagement_id,
+                "job_id": job_id,
+                "notes": f"Subdomain of {target}",
+            }
+        )
 
     return osint_records
 
 
 # Export the main functions
-__all__ = ['parse_dnsrecon_output', 'map_to_hosts', 'map_to_osint']
+__all__ = ["parse_dnsrecon_output", "map_to_hosts", "map_to_osint"]