secator 0.22.0__py3-none-any.whl

secator/tasks/grype.py

@@ -0,0 +1,109 @@
+import click
+
+from secator.config import CONFIG
+from secator.decorators import task
+from secator.definitions import (DELAY, FOLLOW_REDIRECT, HEADER,
+							   OPT_NOT_SUPPORTED, PROXY, RATE_LIMIT, RETRIES,
+							   THREADS, TIMEOUT, USER_AGENT, PATH, STRING)
+from secator.output_types import Vulnerability
+from secator.tasks._categories import VulnCode
+
+GRYPE_MODES = [
+    'git',
+    'github',
+    'gitlab',
+    's3',
+    'filesystem',
+    'gcs',
+    'docker',
+    'postman',
+    'jenkins',
+    'elasticsearch',
+    'huggingface',
+    'syslog',
+]
+
+
+def convert_mode(mode):
+	return 'fs' if mode == 'filesystem' else 'repo' if mode == 'git' else mode
+
+
+@task()
+class grype(VulnCode):
+	"""Vulnerability scanner for container images and filesystems."""
+	cmd = 'grype --quiet'
+	input_types = [PATH, STRING]
+	output_types = [Vulnerability]
+	tags = ['vuln', 'scan']
+	input_flag = ''
+	input_chunk_size = 1
+	file_flag = None
+	json_flag = None
+	opt_prefix = '--'
+	opts = {
+		'mode': {'type': click.Choice(GRYPE_MODES), 'help': f'Scan mode ({", ".join(GRYPE_MODES)})', 'internal': True}
+	}
+	opt_key_value = {
+		'mode': lambda x: convert_mode(x)
+	}
+	opt_key_map = {
+		HEADER: OPT_NOT_SUPPORTED,
+		DELAY: OPT_NOT_SUPPORTED,
+		FOLLOW_REDIRECT: OPT_NOT_SUPPORTED,
+		PROXY: OPT_NOT_SUPPORTED,
+		RATE_LIMIT: OPT_NOT_SUPPORTED,
+		RETRIES: OPT_NOT_SUPPORTED,
+		THREADS: OPT_NOT_SUPPORTED,
+		TIMEOUT: OPT_NOT_SUPPORTED,
+		USER_AGENT: OPT_NOT_SUPPORTED
+	}
+	install_version = 'v0.91.2'
+	install_cmd_pre = {'*': ['curl']}
+	install_cmd = (
+		f'curl -sSfL https://raw.githubusercontent.com/anchore/grype/main/install.sh | sh -s -- -b {CONFIG.dirs.bin}'
+	)
+	github_handle = 'anchore/grype'
+
+	@staticmethod
+	def item_loader(self, line):
+		"""Load vulnerabilty dicts from grype line output."""
+		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, versions_fixed, product_type, vuln_id, severity = tuple(split)
+		extra_data = {
+			'lang': product_type,
+			'product': product,
+			'version': version,
+		}
+		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.inputs[0],
+			'confidence': 'medium',
+			'severity': severity.lower(),
+			'provider': 'grype',
+			'cvss_score': -1,
+			'tags': [],
+		}
+		if vuln_id.startswith('GHSA'):
+			data['provider'] = 'github.com'
+			data['references'] = [f'https://github.com/advisories/{vuln_id}']
+			vuln = VulnCode.lookup_cve_from_ghsa(vuln_id)
+			if vuln:
+				data.update(vuln)
+				data['severity'] = data['severity'] or severity.lower()
+				extra_data['ghsa_id'] = vuln_id
+		elif vuln_id.startswith('CVE'):
+			vuln = VulnCode.lookup_cve(vuln_id)
+			if vuln:
+				data.update(vuln)
+				data['severity'] = data['severity'] or severity.lower()
+		data['extra_data'] = extra_data
+		yield data

secator/tasks/h8mail.py

@@ -0,0 +1,75 @@
+import os
+import json
+import shlex
+
+from secator.decorators import task
+from secator.definitions import EMAIL, OUTPUT_PATH
+from secator.tasks._categories import OSInt
+from secator.output_types import UserAccount, Info, Error
+
+
+@task()
+class h8mail(OSInt):
+	"""Email information and password lookup tool."""
+	cmd = 'h8mail'
+	input_types = [EMAIL]
+	output_types = [UserAccount]
+	tags = ['user', 'recon', 'email']
+	json_flag = '--json'
+	input_flag = '--targets'
+	file_flag = '-domain'
+	version_flag = '--help'
+	opt_prefix = '--'
+	opts = {
+		'config': {'type': str, 'help': 'Configuration file for API keys'},
+		'local_breach': {'type': str, 'short': 'lb', 'help': 'Local breach file'}
+	}
+	install_version = '2.5.6'
+	install_cmd = 'pipx install h8mail==[install_version] --force'
+
+	@staticmethod
+	def on_start(self):
+		output_path = self.get_opt_value(OUTPUT_PATH)
+		if not output_path:
+			output_path = f'{self.reports_folder}/.outputs/{self.unique_name}.json'
+		self.output_path = output_path
+		output_path_quoted = shlex.quote(self.output_path)
+		self.cmd = self.cmd.replace('--json ', f'--json {output_path_quoted} ')
+
+	@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
+
+		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': source
+						},
+					})
+			else:
+				yield UserAccount(**{
+					"username": email.split('@')[0],
+					"email": email,
+					"extra_data": {
+						'source': self.get_opt_value('local_breach')
+					},
+				})

secator/tasks/httpx.py

@@ -0,0 +1,167 @@
+import os
+import shlex
+
+from secator.decorators import task
+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, HOST, IP, HOST_PORT)
+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, extract_domain_info, extract_subdomains_from_fqdn)
+
+
+@task()
+class httpx(Http):
+	"""Fast and multi-purpose HTTP toolkit."""
+	cmd = 'httpx -irh'
+	input_types = [HOST, HOST_PORT, IP, URL]
+	output_types = [Url, Subdomain]
+	tags = ['url', 'probe']
+	file_flag = '-l'
+	input_flag = '-u'
+	json_flag = '-json'
+	opts = {
+		# 'silent': {'is_flag': True, 'default': False, 'help': 'Silent mode'},
+		# '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'},
+		'jarm': {'is_flag': True, 'default': False, 'help': 'Jarm fingerprint'},
+		'asn': {'is_flag': True, 'default': False, 'help': 'ASN detection'},
+		'cdn': {'is_flag': True, 'default': False, 'help': 'CDN detection'},
+		'debug_resp': {'is_flag': True, 'default': False, 'help': 'Debug response'},
+		'vhost': {'is_flag': True, 'default': False, 'help': 'Probe and display server supporting VHOST'},
+		'store_responses': {'is_flag': True, 'short': 'sr', 'default': CONFIG.http.store_responses, 'help': 'Save HTTP responses'},  # noqa: E501
+		'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': False, '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',
+		DELAY: 'delay',
+		DEPTH: OPT_NOT_SUPPORTED,
+		FILTER_CODES: 'filter-code',
+		FILTER_REGEX: 'filter-regex',
+		FILTER_SIZE: 'filter-length',
+		FILTER_WORDS: 'filter-word-count',
+		FOLLOW_REDIRECT: 'follow-redirects',
+		MATCH_CODES: 'match-code',
+		MATCH_REGEX: 'match-regex',
+		MATCH_SIZE: 'match-length',
+		MATCH_WORDS: 'match-word-count',
+		METHOD: 'x',
+		PROXY: 'proxy',
+		RATE_LIMIT: 'rate-limit',
+		RETRIES: 'retries',
+		THREADS: 'threads',
+		TIMEOUT: 'timeout',
+		USER_AGENT: OPT_NOT_SUPPORTED,
+		'store_responses': 'sr',
+	}
+	opt_value_map = {
+		DELAY: lambda x: str(x) + 's' if x else None,
+	}
+	item_loaders = [JSONSerializer()]
+	install_pre = {'apk': ['chromium']}
+	install_version = 'v1.7.0'
+	install_cmd = 'go install -v github.com/projectdiscovery/httpx/cmd/httpx@[install_version]'
+	github_handle = 'projectdiscovery/httpx'
+	proxychains = False
+	proxy_socks5 = True
+	proxy_http = True
+	profile = 'io'
+	profile = lambda opts: httpx.dynamic_profile(opts)  # noqa: E731
+
+	@staticmethod
+	def dynamic_profile(opts):
+		screenshot = httpx._get_opt_value(
+			opts,
+			'screenshot',
+			opts_conf=dict(httpx.opts, **httpx.meta_opts),
+			opt_aliases=opts.get('aliases', [])
+		)
+		return 'cpu' if screenshot is True else 'io'
+
+	@staticmethod
+	def on_init(self):
+		debug_resp = self.get_opt_value('debug_resp')
+		if debug_resp:
+			self.cmd = self.cmd.replace('-silent', '')
+		screenshot = self.get_opt_value('screenshot')
+		store_responses = self.get_opt_value('store_responses')
+		if store_responses or screenshot:
+			reports_folder_outputs = f'{self.reports_folder}/.outputs'
+			self.cmd += f' -srd {shlex.quote(reports_folder_outputs)}'
+		if screenshot:
+			self.cmd += ' -esb -ehb'
+		self.domains = []
+
+	@staticmethod
+	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):
+		store_responses = self.get_opt_value('store_responses') or CONFIG.http.store_responses
+		response_dir = f'{self.reports_folder}/.outputs'
+		if store_responses:
+			index_rpath = f'{response_dir}/response/index.txt'
+			index_spath = f'{response_dir}/screenshot/index_screenshot.txt'
+			index_spath2 = f'{response_dir}/screenshot/screenshot.html'
+			if os.path.exists(index_rpath):
+				os.remove(index_rpath)
+			if os.path.exists(index_spath):
+				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]
+		item['request_headers'] = self.get_opt_value('header', preprocess=True)
+		item['response_headers'] = item.get('header', {})
+		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),
+			verified=True,
+			sources=['tls'],
+		)

secator/tasks/jswhois.py

@@ -0,0 +1,36 @@
+from secator.decorators import task
+from secator.runners import Command
+from secator.definitions import HOST
+from secator.output_types import Tag
+from secator.serializers import JSONSerializer
+
+
+@task()
+class jswhois(Command):
+	"""WHOIS in JSON format"""
+	cmd = 'jswhois'
+	input_types = [HOST]
+	output_types = [Tag]
+	item_loaders = [JSONSerializer(list=True)]
+	tags = ['domain', 'info']
+	input_flag = None
+	file_flag = None
+	version_flag = '-V'
+	install_version = '69af013b99d49191c9674cde2e2b57986f6b6bf8'
+	install_cmd = 'go install -v github.com/jschauma/jswhois@[install_version]'
+	install_github_bin = False
+	github_handle = 'jschauma/jswhois'
+
+	@staticmethod
+	def on_json_loaded(self, item):
+		last_chain = item['chain'][-1]
+		last_elem = item[last_chain]
+		raw = last_elem.pop('raw')
+		tag = Tag(
+			name='whois',
+			category='info',
+			match=self.inputs[0],
+			value=raw,
+			extra_data={'chain': last_chain}
+		)
+		yield tag

secator/tasks/katana.py

@@ -0,0 +1,203 @@
+import os
+import shlex
+
+from urllib.parse import urlparse, urlunparse
+
+from secator.decorators import task
+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, Tag
+from secator.serializers import JSONSerializer
+from secator.tasks._categories import HttpCrawler
+
+EXCLUDED_PARAMS = ['v']
+
+
+@task()
+class katana(HttpCrawler):
+	"""Next-generation crawling and spidering framework."""
+	cmd = 'katana'
+	input_types = [URL]
+	output_types = [Url, Tag]
+	tags = ['url', 'crawl']
+	file_flag = '-list'
+	input_flag = '-u'
+	json_flag = '-jsonl'
+	opts = {
+		'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'},  # noqa: E501
+		'form_fill': {'is_flag': True, 'short': 'ff', 'help': 'Enable form filling'},
+		'js_crawl': {'is_flag': True, 'short': 'jc', 'default': False, 'help': 'Enable endpoint parsing / crawling in javascript file'},  # noqa: E501
+		'jsluice': {'is_flag': True, 'short': 'jsl', 'default': False, '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'},
+		'no_sandbox': {'is_flag': True, 'short': 'ns', 'default': False, 'help': 'Disable sandboxing'},
+	}
+	opt_key_map = {
+		HEADER: 'headers',
+		DELAY: 'delay',
+		DEPTH: 'depth',
+		FILTER_CODES: OPT_NOT_SUPPORTED,
+		FILTER_REGEX: OPT_NOT_SUPPORTED,
+		FILTER_SIZE: OPT_NOT_SUPPORTED,
+		FILTER_WORDS: OPT_NOT_SUPPORTED,
+		FOLLOW_REDIRECT: OPT_NOT_SUPPORTED,
+		MATCH_CODES: OPT_NOT_SUPPORTED,
+		MATCH_REGEX: OPT_NOT_SUPPORTED,
+		MATCH_SIZE: OPT_NOT_SUPPORTED,
+		MATCH_WORDS: OPT_NOT_SUPPORTED,
+		METHOD: OPT_NOT_SUPPORTED,
+		PROXY: 'proxy',
+		RATE_LIMIT: 'rate-limit',
+		RETRIES: 'retry',
+		THREADS: 'concurrency',
+		TIMEOUT: 'timeout',
+		USER_AGENT: OPT_NOT_SUPPORTED,
+		'store_responses': 'sr',
+		'form_fill': 'aff'
+	}
+	opt_value_map = {
+		DELAY: lambda x: int(x) if isinstance(x, float) else x
+	}
+	item_loaders = [JSONSerializer()]
+	install_pre = {'apk': ['libc6-compat']}
+	install_version = 'v1.1.3'
+	install_cmd = 'go install -v github.com/projectdiscovery/katana/cmd/katana@[install_version]'
+	github_handle = 'projectdiscovery/katana'
+	proxychains = False
+	proxy_socks5 = True
+	proxy_http = True
+	profile = lambda opts: katana.dynamic_profile(opts)  # noqa: E731
+
+	@staticmethod
+	def dynamic_profile(opts):
+		headless = katana._get_opt_value(
+			opts,
+			'headless',
+			opts_conf=dict(katana.opts, **katana.meta_opts),
+			opt_aliases=opts.get('aliases', [])
+		)
+		return 'cpu' if headless is True else 'io'
+
+	@staticmethod
+	def on_init(self):
+		form_fill = self.get_opt_value('form_fill')
+		form_extraction = self.get_opt_value('form_extraction')
+		store_responses = self.get_opt_value('store_responses')
+		if form_fill or form_extraction or store_responses:
+			reports_folder_outputs = f'{self.reports_folder}/.outputs'
+			self.cmd += f' -srd {shlex.quote(reports_folder_outputs)}'
+		self.tags = []
+		self.urls = []
+
+	@staticmethod
+	def on_json_loaded(self, item):
+		# form detection
+		response = item.get('response', {})
+		forms = response.get('forms', [])
+		parsed_url = urlparse(item['request']['endpoint'])
+		url_without_params = urlunparse(parsed_url._replace(query=''))
+		params = parsed_url.query.split('&')
+		if forms:
+			for form in forms:
+				method = form['method']
+				url = Url(
+					form['action'],
+					host=parsed_url.hostname,
+					method=method,
+					stored_response_path=response["stored_response_path"],
+					request_headers=self.get_opt_value('header', preprocess=True)
+				)
+				if url not in self.urls:
+					self.urls.append(url)
+					yield url
+				params = form.get('parameters', [])
+				yield Tag(
+					category='info',
+					name='form',
+					value=form['action'],
+					match=form['action'],
+					stored_response_path=response["stored_response_path"],
+					extra_data={
+						'method': form['method'],
+						'enctype': form.get('enctype', ''),
+						'parameters': params
+					}
+				)
+				for param in params:
+					yield Tag(
+						category='info',
+						name='url_param',
+						match=form['action'],
+						value=param,
+						extra_data={'url': url, 'value': 'FUZZ'}
+					)
+		response = item.get('response')
+		if not response:
+			return item
+		url = Url(
+			url=item['request']['endpoint'],
+			host=parsed_url.hostname,
+			method=item['request']['method'],
+			request_headers=self.get_opt_value('header', preprocess=True),
+			time=item['timestamp'],
+			status_code=item['response'].get('status_code'),
+			content_type=item['response'].get('headers', {}).get('content_type', ';').split(';')[0],
+			content_length=item['response'].get('headers', {}).get('content_length', 0),
+			webserver=item['response'].get('headers', {}).get('server', ''),
+			tech=item['response'].get('technologies', []),
+			stored_response_path=item['response'].get('stored_response_path', ''),
+			response_headers=item['response'].get('headers', {}),
+		)
+		if url not in self.urls:
+			self.urls.append(url)
+			yield url
+		for param in params:
+			if not param:
+				continue
+			split_param = param.split('=')
+			param_name = split_param[0]
+			param_value = None
+			if len(split_param) > 1:
+				param_value = split_param[1]
+			if param_name in EXCLUDED_PARAMS:
+				continue
+			tag = Tag(
+				category='info',
+				name='url_param',
+				value=param_name,
+				match=url_without_params,
+				extra_data={'value': param_value, 'url': item['request']['endpoint']}
+			)
+			if tag not in self.tags:
+				self.tags.append(tag)
+				yield tag
+
+	@staticmethod
+	def on_item(self, item):
+		if not isinstance(item, (Url, Tag)):
+			return item
+		store_responses = self.get_opt_value('store_responses')
+		if store_responses and os.path.exists(item.stored_response_path):
+			with open(item.stored_response_path, 'r', encoding='latin-1') as fin:
+				data = fin.read().splitlines(True)
+				if not data:
+					return item
+				first_line = data[0]
+			with open(item.stored_response_path, 'w', encoding='latin-1') as fout:
+				fout.writelines(data[1:])
+				fout.writelines('\n')
+				fout.writelines(first_line)
+		return item
+
+	@staticmethod
+	def on_end(self):
+		store_responses = self.get_opt_value('store_responses')
+		index_rpath = f'{self.reports_folder}/.outputs/index.txt'
+		if store_responses and os.path.exists(index_rpath):
+			os.remove(index_rpath)

secator/tasks/maigret.py

@@ -0,0 +1,87 @@
+import json
+import logging
+import os
+import re
+
+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, STRING, SLUG)
+from secator.output_types import UserAccount, Info, Error
+from secator.tasks._categories import ReconUser
+
+logger = logging.getLogger(__name__)
+
+
+@task()
+class maigret(ReconUser):
+	"""Collect a dossier on a person by username."""
+	cmd = 'maigret'
+	input_types = [SLUG, STRING]
+	output_types = [UserAccount]
+	tags = ['user', 'recon', 'username']
+	file_flag = None
+	input_flag = None
+	json_flag = '--json ndjson'
+	opt_prefix = '--'
+	opts = {
+		'site': {'type': str, 'help': 'Sites to check'},
+	}
+	opt_key_map = {
+		DELAY: OPT_NOT_SUPPORTED,
+		PROXY: 'proxy',
+		RATE_LIMIT: OPT_NOT_SUPPORTED,
+		RETRIES: 'retries',
+		TIMEOUT: 'timeout',
+		THREADS: OPT_NOT_SUPPORTED
+	}
+	output_map = {
+		UserAccount: {
+			SITE_NAME: 'sitename',
+			URL: lambda x: x['status']['url'],
+			EXTRA_DATA: lambda x: x['status'].get('ids', {})
+		}
+	}
+	install_version = '0.5.0'
+	# install_pre = {
+	# 	'apt': ['libcairo2-dev'],
+	# 	'yum|zypper': ['cairo-devel'],
+	# 	'*': ['cairo']
+	# }
+	install_cmd = 'pipx install maigret==[install_version] --force'
+	socks5_proxy = True
+	profile = 'io'
+
+	@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:
+			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 = 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
+
+	@staticmethod
+	def validate_item(self, item):
+		if isinstance(item, dict):
+			return item['http_status'] == 200
+		return True