secator 0.5.2__py3-none-any.whl → 0.7.0__py3-none-any.whl

secator/tasks/dnsxbrute.py

@@ -2,6 +2,7 @@ from secator.decorators import task
 from secator.definitions import (DOMAIN, HOST, RATE_LIMIT, RETRIES, THREADS, WORDLIST, EXTRA_DATA)
 from secator.config import CONFIG
 from secator.output_types import Subdomain
+from secator.serializers import JSONSerializer
 from secator.tasks._categories import ReconDns
 
 
@@ -21,6 +22,7 @@ class dnsxbrute(ReconDns):
         WORDLIST: {'type': str, 'short': 'w', 'default': CONFIG.wordlists.defaults.dns, 'help': 'Wordlist'},
         'trace': {'is_flag': True, 'default': False, 'help': 'Perform dns tracing'},
     }
+    item_loaders = [JSONSerializer()]
     output_map = {
         Subdomain: {
             HOST: 'host',

secator/tasks/feroxbuster.py

@@ -1,15 +1,13 @@
-import shlex
-from pathlib import Path
-
 from secator.decorators import task
 from secator.definitions import (CONTENT_TYPE, DELAY, DEPTH, FILTER_CODES,
 							   FILTER_REGEX, FILTER_SIZE, FILTER_WORDS,
 							   FOLLOW_REDIRECT, HEADER, LINES, MATCH_CODES,
 							   MATCH_REGEX, MATCH_SIZE, MATCH_WORDS, METHOD,
-							   OPT_NOT_SUPPORTED, OPT_PIPE_INPUT, OUTPUT_PATH, PROXY,
+							   OPT_NOT_SUPPORTED, OPT_PIPE_INPUT, PROXY,
 							   RATE_LIMIT, RETRIES, STATUS_CODE,
 							   THREADS, TIMEOUT, USER_AGENT, WORDLIST, WORDS, DEFAULT_FEROXBUSTER_FLAGS)
 from secator.output_types import Url
+from secator.serializers import JSONSerializer
 from secator.tasks._categories import HttpFuzzer
 
 
@@ -20,7 +18,7 @@ class feroxbuster(HttpFuzzer):
 	input_flag = '--url'
 	input_chunk_size = 1
 	file_flag = OPT_PIPE_INPUT
-	json_flag = '--json'
+	json_flag = '--silent --json'
 	opt_prefix = '--'
 	opts = {
 		# 'auto_tune': {'is_flag': True, 'default': False, 'help': 'Automatically lower scan rate when too many errors'},
@@ -51,6 +49,7 @@ class feroxbuster(HttpFuzzer):
 		USER_AGENT: 'user-agent',
 		WORDLIST: 'wordlist'
 	}
+	item_loaders = [JSONSerializer()]
 	output_map = {
 		Url: {
 			STATUS_CODE: 'status',
@@ -70,21 +69,13 @@ class feroxbuster(HttpFuzzer):
 	proxy_http = True
 	profile = 'cpu'
 
-	@staticmethod
-	def on_init(self):
-		self.output_path = self.get_opt_value(OUTPUT_PATH)
-		if not self.output_path:
-			self.output_path = f'{self.reports_folder}/.outputs/{self.unique_name}.json'
-		Path(self.output_path).touch()
-		self.cmd += f' --output {self.output_path}'
-
 	@staticmethod
 	def on_start(self):
-		if self.input_path:
+		if self.inputs_path:
 			self.cmd += ' --stdin'
-		self.cmd += f' & tail --pid=$! -f {shlex.quote(self.output_path)}'
-		self.shell = True
 
 	@staticmethod
 	def validate_item(self, item):
-		return item['type'] == 'response'
+		if isinstance(item, dict):
+			return item['type'] == 'response'
+		return True

secator/tasks/ffuf.py

@@ -25,7 +25,7 @@ class ffuf(HttpFuzzer):
 	json_flag = '-json'
 	version_flag = '-V'
 	item_loaders = [
-		JSONSerializer(),
+		JSONSerializer(strict=True),
 		RegexSerializer(FFUF_PROGRESS_REGEX, fields=['count', 'total', 'rps', 'duration', 'errors'])
 	]
 	opts = {
@@ -79,5 +79,6 @@ class ffuf(HttpFuzzer):
 
 	@staticmethod
 	def on_item(self, item):
-		item.method = self.get_opt_value(METHOD) or 'GET'
+		if isinstance(item, Url):
+			item.method = self.get_opt_value(METHOD) or 'GET'
 		return item

secator/tasks/fping.py

@@ -33,9 +33,9 @@ class fping(ReconIp):
 
 	@staticmethod
 	def item_loader(self, line):
-		if validators.ipv4(line) or validators.ipv6(line):
-			return {'ip': line, 'alive': True}
-		return None
+		if not (validators.ipv4(line) or validators.ipv6(line)):
+			return
+		yield {'ip': line, 'alive': True}
 
 	@staticmethod
 	def on_line(self, line):

secator/tasks/gau.py

@@ -5,6 +5,7 @@ from secator.definitions import (DELAY, DEPTH, FILTER_CODES, FILTER_REGEX,
 							   MATCH_WORDS, METHOD, OPT_NOT_SUPPORTED,
 							   OPT_PIPE_INPUT, PROXY, RATE_LIMIT, RETRIES,
 							   THREADS, TIMEOUT, USER_AGENT)
+from secator.serializers import JSONSerializer
 from secator.tasks._categories import HttpCrawler
 
 
@@ -15,6 +16,9 @@ class gau(HttpCrawler):
 	file_flag = OPT_PIPE_INPUT
 	json_flag = '--json'
 	opt_prefix = '--'
+	opts = {
+		'providers': {'type': str, 'default': None, 'help': 'List of providers to use (wayback,commoncrawl,otx,urlscan)'}
+	}
 	opt_key_map = {
 		HEADER: OPT_NOT_SUPPORTED,
 		DELAY: OPT_NOT_SUPPORTED,
@@ -36,6 +40,7 @@ class gau(HttpCrawler):
 		TIMEOUT: 'timeout',
 		USER_AGENT: OPT_NOT_SUPPORTED,
 	}
+	item_loaders = [JSONSerializer()]
 	install_cmd = 'go install -v github.com/lc/gau/v2/cmd/gau@latest'
 	install_github_handle = 'lc/gau'
 	proxychains = False

secator/tasks/gf.py

@@ -12,7 +12,7 @@ class gf(Tagger):
 	input_flag = OPT_PIPE_INPUT
 	version_flag = OPT_NOT_SUPPORTED
 	opts = {
-		'pattern': {'type': str, 'help': 'Pattern names to match against (comma-delimited)'}
+		'pattern': {'type': str, 'help': 'Pattern names to match against (comma-delimited)', 'required': True}
 	}
 	opt_key_map = {
 		'pattern': ''
@@ -26,7 +26,7 @@ class gf(Tagger):
 
 	@staticmethod
 	def item_loader(self, line):
-		return {'match': line, 'name': self.get_opt_value('pattern').rstrip() + ' pattern'}  # noqa: E731,E501
+		yield {'match': line, 'name': self.get_opt_value('pattern').rstrip() + ' pattern'}  # noqa: E731,E501
 
 	@staticmethod
 	def on_item(self, item):

secator/tasks/gospider.py

@@ -8,6 +8,7 @@ from secator.definitions import (CONTENT_LENGTH, DELAY, DEPTH, FILTER_CODES,
 							   OPT_NOT_SUPPORTED, PROXY, RATE_LIMIT, RETRIES,
 							   STATUS_CODE, THREADS, TIMEOUT, URL, USER_AGENT)
 from secator.output_types import Url
+from secator.serializers import JSONSerializer
 from secator.tasks._categories import HttpCrawler
 
 
@@ -44,6 +45,7 @@ class gospider(HttpCrawler):
 		FOLLOW_REDIRECT: lambda x: not x,
 		DELAY: lambda x: round(x) if isinstance(x, float) else x
 	}
+	item_loaders = [JSONSerializer()]
 	output_map = {
 		Url: {
 			URL: 'output',
@@ -62,6 +64,8 @@ class gospider(HttpCrawler):
 	@staticmethod
 	def validate_item(self, item):
 		"""Keep only items that match the same host."""
+		if not isinstance(item, dict):
+			return False
 		try:
 			netloc_in = furl(item['input']).netloc
 			netloc_out = furl(item['output']).netloc

secator/tasks/grype.py

@@ -35,25 +35,25 @@ class grype(VulnCode):
 	@staticmethod
 	def item_loader(self, line):
 		"""Load vulnerabilty dicts from grype line output."""
-		split = [i for i in line.split(' ') if i]
-		if not len(split) in [5, 6] or split[0] == 'NAME':
-			return None
-		version_fixed = None
+		split = [i for i in line.split('  ') if i]
+		if len(split) not in [5, 6] or split[0] == 'NAME':
+			return
+		versions_fixed = None
 		if len(split) == 5:  # no version fixed
 			product, version, product_type, vuln_id, severity = tuple(split)
 		elif len(split) == 6:
-			product, version, version_fixed, product_type, vuln_id, severity = tuple(split)
+			product, version, versions_fixed, product_type, vuln_id, severity = tuple(split)
 		extra_data = {
 			'lang': product_type,
 			'product': product,
 			'version': version,
 		}
-		if version_fixed:
-			extra_data['version_fixed'] = version_fixed
+		if versions_fixed:
+			extra_data['versions_fixed'] = [c.strip() for c in versions_fixed.split(', ')]
 		data = {
 			'id': vuln_id,
 			'name': vuln_id,
-			'matched_at': self.input,
+			'matched_at': self.inputs[0],
 			'confidence': 'medium',
 			'severity': severity.lower(),
 			'provider': 'grype',
@@ -76,4 +76,4 @@ class grype(VulnCode):
 				data.update(vuln)
 				data['severity'] = data['severity'] or severity.lower()
 		data['extra_data'] = extra_data
-		return data
+		yield data

secator/tasks/h8mail.py

@@ -4,7 +4,7 @@ import json
 from secator.decorators import task
 from secator.definitions import EMAIL, OUTPUT_PATH
 from secator.tasks._categories import OSInt
-from secator.output_types import UserAccount
+from secator.output_types import UserAccount, Info, Error
 
 
 @task()
@@ -17,16 +17,10 @@ class h8mail(OSInt):
 	file_flag = '-domain'
 	version_flag = '--help'
 	opt_prefix = '--'
-	opt_key_map = {
-
-	}
 	opts = {
 		'config': {'type': str, 'help': 'Configuration file for API keys'},
 		'local_breach': {'type': str, 'short': 'lb', 'help': 'Local breach file'}
 	}
-	output_map = {
-	}
-
 	install_cmd = 'pipx install h8mail'
 
 	@staticmethod
@@ -37,44 +31,40 @@ class h8mail(OSInt):
 		self.output_path = output_path
 		self.cmd = self.cmd.replace('--json', f'--json {self.output_path}')
 
-	def yielder(self):
-		prev = self.print_item_count
-		self.print_item_count = False
-		list(super().yielder())
-		if self.return_code != 0:
+	@staticmethod
+	def on_cmd_done(self):
+		if not os.path.exists(self.output_path):
+			yield Error(message=f'Could not find JSON results in {self.output_path}')
 			return
-		self.results = []
-		if os.path.exists(self.output_path):
-			with open(self.output_path, 'r') as f:
-				data = json.load(f)
-			if self.orig:  # original h8mail output
-				yield data
-				return
-			targets = data['targets']
-			for target in targets:
-				email = target['target']
-				target_data = target.get('data', [])
-				pwn_num = target['pwn_num']
-				if not pwn_num > 0:
-					continue
-				if len(target_data) > 0:
-					entries = target_data[0]
-					for entry in entries:
-						source, site_name = tuple(entry.split(':'))
-						yield UserAccount(**{
-							"site_name": site_name,
-							"username": email.split('@')[0],
-							"email": email,
-							"extra_data": {
-								'source': source
-							},
-						})
-				else:
+
+		yield Info(message=f'JSON results saved to {self.output_path}')
+		with open(self.output_path, 'r') as f:
+			data = json.load(f)
+
+		targets = data['targets']
+		for target in targets:
+			email = target['target']
+			target_data = target.get('data', [])
+			pwn_num = target['pwn_num']
+			if not pwn_num > 0:
+				continue
+			if len(target_data) > 0:
+				entries = target_data[0]
+				for entry in entries:
+					source, site_name = tuple(entry.split(':'))
 					yield UserAccount(**{
+						"site_name": site_name,
 						"username": email.split('@')[0],
 						"email": email,
 						"extra_data": {
-							'source': self.get_opt_value('local_breach')
+							'source': source
 						},
 					})
-		self.print_item_count = prev
+			else:
+				yield UserAccount(**{
+					"username": email.split('@')[0],
+					"email": email,
+					"extra_data": {
+						'source': self.get_opt_value('local_breach')
+					},
+				})

secator/tasks/httpx.py

@@ -1,28 +1,25 @@
 import os
 
 from secator.decorators import task
-from secator.definitions import (DEFAULT_HTTPX_FLAGS, DELAY, DEPTH,
-								 FILTER_CODES, FILTER_REGEX, FILTER_SIZE,
-								 FILTER_WORDS, FOLLOW_REDIRECT, HEADER,
-								 MATCH_CODES, MATCH_REGEX, MATCH_SIZE,
-								 MATCH_WORDS, METHOD, OPT_NOT_SUPPORTED, PROXY,
-								 RATE_LIMIT, RETRIES, THREADS,
-								 TIMEOUT, URL, USER_AGENT)
+from secator.definitions import (DELAY, DEPTH, FILTER_CODES, FILTER_REGEX, FILTER_SIZE, FILTER_WORDS, FOLLOW_REDIRECT,
+								 HEADER, MATCH_CODES, MATCH_REGEX, MATCH_SIZE, MATCH_WORDS, METHOD, OPT_NOT_SUPPORTED,
+								 PROXY, RATE_LIMIT, RETRIES, THREADS, TIMEOUT, URL, USER_AGENT)
 from secator.config import CONFIG
+from secator.output_types import Url, Subdomain
+from secator.serializers import JSONSerializer
 from secator.tasks._categories import Http
-from secator.utils import sanitize_url
+from secator.utils import (sanitize_url, extract_domain_info, extract_subdomains_from_fqdn)
 
 
 @task()
 class httpx(Http):
 	"""Fast and multi-purpose HTTP toolkit."""
-	cmd = f'httpx {DEFAULT_HTTPX_FLAGS}'
+	cmd = 'httpx'
 	file_flag = '-l'
 	input_flag = '-u'
 	json_flag = '-json'
 	opts = {
 		# 'silent': {'is_flag': True, 'default': False, 'help': 'Silent mode'},
-		# 'td': {'is_flag': True, 'default': True, 'help': 'Tech detection'},
 		# 'irr': {'is_flag': True, 'default': False, 'help': 'Include http request / response'},
 		'fep': {'is_flag': True, 'default': False, 'help': 'Error Page Classifier and Filtering'},
 		'favicon': {'is_flag': True, 'default': False, 'help': 'Favicon hash'},
@@ -35,6 +32,11 @@ class httpx(Http):
 		'screenshot': {'is_flag': True, 'short': 'ss', 'default': False, 'help': 'Screenshot response'},
 		'system_chrome': {'is_flag': True, 'default': False, 'help': 'Use local installed Chrome for screenshot'},
 		'headless_options': {'is_flag': False, 'short': 'ho', 'default': None, 'help': 'Headless Chrome additional options'},
+		'follow_host_redirects': {'is_flag': True, 'short': 'fhr', 'default': None, 'help': 'Follow redirects on the same host'},  # noqa: E501
+		'tech_detect': {'is_flag': True, 'short': 'td', 'default': True, 'help': 'Tech detection'},
+		'tls_grab': {'is_flag': True, 'short': 'tlsg', 'default': False, 'help': 'Grab some informations from the tls certificate'},  # noqa: E501
+		'rstr': {'type': int, 'default': CONFIG.http.response_max_size_bytes, 'help': 'Max body size to read (bytes)'},
+		'rsts': {'type': int, 'default': CONFIG.http.response_max_size_bytes, 'help': 'Max body size to save (bytes)'}
 	}
 	opt_key_map = {
 		HEADER: 'header',
@@ -61,6 +63,8 @@ class httpx(Http):
 	opt_value_map = {
 		DELAY: lambda x: str(x) + 's' if x else None,
 	}
+	item_loaders = [JSONSerializer()]
+	output_types = [Url, Subdomain]
 	install_cmd = 'go install -v github.com/projectdiscovery/httpx/cmd/httpx@latest'
 	install_github_handle = 'projectdiscovery/httpx'
 	proxychains = False
@@ -79,19 +83,23 @@ class httpx(Http):
 			self.cmd += f' -srd {self.reports_folder}/.outputs'
 		if screenshot:
 			self.cmd += ' -esb -ehb'
+		self.domains = []
 
 	@staticmethod
-	def on_item_pre_convert(self, item):
-		for k, v in item.items():
-			if k == 'time':
-				response_time = float(''.join(ch for ch in v if not ch.isalpha()))
-				if v[-2:] == 'ms':
-					response_time = response_time / 1000
-				item[k] = response_time
-			elif k == URL:
-				item[k] = sanitize_url(v)
-		item[URL] = item.get('final_url') or item[URL]
-		return item
+	def on_json_loaded(self, item):
+		item = self._preprocess_url(item)
+		yield item
+		tls = item.get('tls', None)
+		if tls:
+			subject_cn = tls.get('subject_cn', None)
+			subject_an = tls.get('subject_an', [])
+			cert_domains = subject_an
+			if subject_cn:
+				cert_domains.append(subject_cn)
+			for cert_domain in cert_domains:
+				subdomain = self._create_subdomain_from_tls_cert(cert_domain, item['url'])
+				if subdomain:
+					yield subdomain
 
 	@staticmethod
 	def on_end(self):
@@ -107,3 +115,32 @@ class httpx(Http):
 				os.remove(index_spath)
 			if os.path.exists(index_spath2):
 				os.remove(index_spath2)
+
+	def _preprocess_url(self, item):
+		"""Replace time string by float, sanitize URL, get final redirect URL."""
+		for k, v in item.items():
+			if k == 'time':
+				response_time = float(''.join(ch for ch in v if not ch.isalpha()))
+				if v[-2:] == 'ms':
+					response_time = response_time / 1000
+				item[k] = response_time
+			elif k == URL:
+				item[k] = sanitize_url(v)
+		item[URL] = item.get('final_url') or item[URL]
+		return item
+
+	def _create_subdomain_from_tls_cert(self, domain, url):
+		"""Extract subdomains from TLS certificate."""
+		if domain.startswith('*.'):
+			domain = domain.lstrip('*.')
+		if domain in self.domains:
+			return None
+		url_domain = extract_domain_info(url)
+		url_domains = extract_subdomains_from_fqdn(url_domain.fqdn, url_domain.domain, url_domain.suffix)
+		if not url_domain or domain not in url_domains:
+			return None
+		self.domains.append(domain)
+		return Subdomain(
+			host=domain,
+			domain=extract_domain_info(domain, domain_only=True)
+		)

secator/tasks/katana.py

@@ -1,28 +1,22 @@
 import os
-import json
 from urllib.parse import urlparse
 
 from secator.decorators import task
-from secator.definitions import (CONTENT_TYPE, DEFAULT_KATANA_FLAGS,
-								 DELAY, DEPTH,
-								 FILTER_CODES, FILTER_REGEX, FILTER_SIZE,
-								 FILTER_WORDS, FOLLOW_REDIRECT, HEADER, HOST,
-								 MATCH_CODES, MATCH_REGEX, MATCH_SIZE,
-								 MATCH_WORDS, METHOD, OPT_NOT_SUPPORTED, PROXY,
-								 RATE_LIMIT, RETRIES, STATUS_CODE,
-								 STORED_RESPONSE_PATH, TECH,
-								 THREADS, TIME, TIMEOUT, URL, USER_AGENT, WEBSERVER, CONTENT_LENGTH)
+from secator.definitions import (CONTENT_TYPE, DELAY, DEPTH, FILTER_CODES, FILTER_REGEX, FILTER_SIZE, FILTER_WORDS,
+								 FOLLOW_REDIRECT, HEADER, HOST, MATCH_CODES, MATCH_REGEX, MATCH_SIZE, MATCH_WORDS,
+								 METHOD, OPT_NOT_SUPPORTED, PROXY, RATE_LIMIT, RETRIES, STATUS_CODE,
+								 STORED_RESPONSE_PATH, TECH, THREADS, TIME, TIMEOUT, URL, USER_AGENT, WEBSERVER,
+								 CONTENT_LENGTH)
 from secator.config import CONFIG
 from secator.output_types import Url, Tag
+from secator.serializers import JSONSerializer
 from secator.tasks._categories import HttpCrawler
 
 
 @task()
 class katana(HttpCrawler):
 	"""Next-generation crawling and spidering framework."""
-	# TODO: add -fx for form detection and extract 'forms' from the output with custom item_loader
-	# TODO: add -jsluice for JS parsing
-	cmd = f'katana {DEFAULT_KATANA_FLAGS}'
+	cmd = 'katana'
 	file_flag = '-list'
 	input_flag = '-u'
 	json_flag = '-jsonl'
@@ -30,7 +24,13 @@ class katana(HttpCrawler):
 		'headless': {'is_flag': True, 'short': 'hl', 'help': 'Headless mode'},
 		'system_chrome': {'is_flag': True, 'short': 'sc', 'help': 'Use local installed chrome browser'},
 		'form_extraction': {'is_flag': True, 'short': 'fx', 'help': 'Detect forms'},
-		'store_responses': {'is_flag': True, 'short': 'sr', 'default': CONFIG.http.store_responses, 'help': 'Store responses'}
+		'store_responses': {'is_flag': True, 'short': 'sr', 'default': CONFIG.http.store_responses, 'help': 'Store responses'},  # noqa: E501
+		'form_fill': {'is_flag': True, 'short': 'ff', 'help': 'Enable form filling'},
+		'js_crawl': {'is_flag': True, 'short': 'jc', 'default': True, 'help': 'Enable endpoint parsing / crawling in javascript file'},  # noqa: E501
+		'jsluice': {'is_flag': True, 'short': 'jsl', 'default': True, 'help': 'Enable jsluice parsing in javascript file (memory intensive)'},  # noqa: E501
+		'known_files': {'type': str, 'short': 'kf', 'default': 'all', 'help': 'Enable crawling of known files (all, robotstxt, sitemapxml)'},  # noqa: E501
+		'omit_raw': {'is_flag': True, 'short': 'or', 'default': True, 'help': 'Omit raw requests/responses from jsonl output'},  # noqa: E501
+		'omit_body': {'is_flag': True, 'short': 'ob', 'default': True, 'help': 'Omit response body from jsonl output'}
 	}
 	opt_key_map = {
 		HEADER: 'headers',
@@ -52,11 +52,13 @@ class katana(HttpCrawler):
 		THREADS: 'concurrency',
 		TIMEOUT: 'timeout',
 		USER_AGENT: OPT_NOT_SUPPORTED,
-		'store_responses': 'sr'
+		'store_responses': 'sr',
+		'form_fill': 'aff'
 	}
 	opt_value_map = {
 		DELAY: lambda x: int(x) if isinstance(x, float) else x
 	}
+	item_loaders = [JSONSerializer()]
 	output_map = {
 		Url: {
 			URL: lambda x: x['request']['endpoint'],
@@ -72,7 +74,6 @@ class katana(HttpCrawler):
 			# TAGS: lambda x: x['response'].get('server')
 		}
 	}
-	item_loaders = []
 	install_cmd = 'sudo apt install build-essential && go install -v github.com/projectdiscovery/katana/cmd/katana@latest'
 	install_github_handle = 'projectdiscovery/katana'
 	proxychains = False
@@ -81,12 +82,7 @@ class katana(HttpCrawler):
 	profile = 'io'
 
 	@staticmethod
-	def item_loader(self, item):
-		try:
-			item = json.loads(item)
-		except json.JSONDecodeError:
-			return None
-
+	def on_json_loaded(self, item):
 		# form detection
 		forms = item.get('response', {}).get('forms', [])
 		if forms:

secator/tasks/maigret.py

@@ -7,7 +7,7 @@ from secator.decorators import task
 from secator.definitions import (DELAY, EXTRA_DATA, OPT_NOT_SUPPORTED, OUTPUT_PATH, PROXY,
 								 RATE_LIMIT, RETRIES, SITE_NAME, THREADS,
 								 TIMEOUT, URL, USERNAME)
-from secator.output_types import UserAccount
+from secator.output_types import UserAccount, Info, Error
 from secator.tasks._categories import ReconUser
 
 logger = logging.getLogger(__name__)
@@ -45,34 +45,36 @@ class maigret(ReconUser):
 	socks5_proxy = True
 	profile = 'io'
 
-	def yielder(self):
-		prev = self.print_item_count
-		self.print_item_count = False
-		yield from super().yielder()
-		if self.return_code != 0:
-			return
-		self.results = []
+	@staticmethod
+	def on_init(self):
+		self.output_path = self.get_opt_value(OUTPUT_PATH)
+
+	@staticmethod
+	def on_cmd_done(self):
+		# Search output path in cmd output
 		if not self.output_path:
-			match = re.search('JSON ndjson report for .* saved in (.*)', self.output)
-			if match is None:
-				logger.warning('JSON output file not found in command output.')
+			matches = re.findall('JSON ndjson report for .* saved in (.*)', self.output)
+			if not matches:
+				yield Error(message='JSON output file not found in command output.')
 				return
-			self.output_path = match.group(1)
-		note = f'maigret JSON results saved to {self.output_path}'
-		if self.print_line:
-			self._print(note)
-		if os.path.exists(self.output_path):
-			with open(self.output_path, 'r') as f:
+			self.output_path = matches
+
+		if not isinstance(self.output_path, list):
+			self.output_path = [self.output_path]
+
+		for path in self.output_path:
+			if not os.path.exists(path):
+				yield Error(message=f'Could not find JSON results in {path}')
+				return
+
+			yield Info(message=f'JSON results saved to {path}')
+			with open(path, 'r') as f:
 				data = [json.loads(line) for line in f.read().splitlines()]
 			for item in data:
 				yield item
-		self.print_item_count = prev
-
-	@staticmethod
-	def on_init(self):
-		output_path = self.get_opt_value(OUTPUT_PATH)
-		self.output_path = output_path
 
 	@staticmethod
 	def validate_item(self, item):
-		return item['http_status'] == 200
+		if isinstance(item, dict):
+			return item['http_status'] == 200
+		return True

secator/tasks/mapcidr.py

@@ -23,11 +23,10 @@ class mapcidr(ReconIp):
 		RATE_LIMIT: OPT_NOT_SUPPORTED,
 		RETRIES: OPT_NOT_SUPPORTED,
 		TIMEOUT: OPT_NOT_SUPPORTED,
-		THREADS: OPT_NOT_SUPPORTED,
 	}
 
 	@staticmethod
 	def item_loader(self, line):
 		if validators.ipv4(line) or validators.ipv6(line):
-			return {'ip': line, 'alive': False}
-		return None
+			yield {'ip': line, 'alive': False}
+		return