secator 0.0.1__py3-none-any.whl

secator/tasks/cariddi.py

@@ -0,0 +1,102 @@
+import json
+
+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,
+							   OPT_PIPE_INPUT, PROXY, RATE_LIMIT, RETRIES,
+							   THREADS, TIMEOUT, URL, USER_AGENT)
+from secator.output_types import Tag, Url
+from secator.tasks._categories import HttpCrawler
+
+
+@task()
+class cariddi(HttpCrawler):
+	"""Crawl endpoints, secrets, api keys, extensions, tokens..."""
+	cmd = 'cariddi -info -s -err -e -ext 1'
+	input_type = URL
+	input_flag = OPT_PIPE_INPUT
+	output_types = [Url, Tag]
+	file_flag = OPT_PIPE_INPUT
+	json_flag = '-json'
+	opt_key_map = {
+		HEADER: 'headers',
+		DELAY: 'd',
+		DEPTH: OPT_NOT_SUPPORTED,
+		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: OPT_NOT_SUPPORTED,
+		RETRIES: OPT_NOT_SUPPORTED,
+		THREADS: 'c',
+		TIMEOUT: 't',
+		USER_AGENT: 'ua'
+	}
+	item_loaders = []
+	install_cmd = 'go install -v github.com/edoardottt/cariddi/cmd/cariddi@latest'
+	encoding = 'ansi'
+	proxychains = False
+	proxy_socks5 = True  # with leaks... https://github.com/edoardottt/cariddi/issues/122
+	proxy_http = True  # with leaks... https://github.com/edoardottt/cariddi/issues/122
+	profile = 'cpu'
+
+	@staticmethod
+	def item_loader(self, line):
+		items = []
+		try:
+			item = json.loads(line)
+			url_item = {k: v for k, v in item.items() if k != 'matches'}
+			url = url_item[URL]
+			items.append(url_item)
+			matches = item.get('matches', {})
+			params = matches.get('parameters', [])
+			errors = matches.get('errors', [])
+			secrets = matches.get('secrets', [])
+			infos = matches.get('infos', [])
+
+			for param in params:
+				param_name = param['name']
+				for attack in param['attacks']:
+					extra_data = {'param': param_name, 'source': 'url'}
+					item = {
+						'name': attack + ' param',
+						'match': url,
+						'extra_data': extra_data
+					}
+					items.append(item)
+
+			for error in errors:
+				match = error['match']
+				match = (match[:1000] + '...TRUNCATED') if len(match) > 1000 else match  # truncate as this can be a very long match
+				error['extra_data'] = {'error': match, 'source': 'body'}
+				error['match'] = url
+				items.append(error)
+
+			for secret in secrets:
+				match = secret['match']
+				secret['extra_data'] = {'secret': match, 'source': 'body'}
+				secret['match'] = url
+				items.append(secret)
+
+			for info in infos:
+				CARIDDI_IGNORE_LIST = ['BTC address']
+				if info['name'] in CARIDDI_IGNORE_LIST:
+					continue
+				match = info['match']
+				info['extra_data'] = {'info': match, 'source': 'body'}
+				info['match'] = url
+				items.append(info)
+
+		except json.decoder.JSONDecodeError:
+			pass
+
+		return items

secator/tasks/dalfox.py

@@ -0,0 +1,65 @@
+from urllib.parse import urlparse
+
+from secator.decorators import task
+from secator.definitions import (CONFIDENCE, DELAY, EXTRA_DATA, FOLLOW_REDIRECT,
+							   HEADER, ID, MATCHED_AT, METHOD, NAME,
+							   OPT_NOT_SUPPORTED, PROVIDER, PROXY, RATE_LIMIT,
+							   SEVERITY, TAGS, THREADS, TIMEOUT, URL,
+							   USER_AGENT)
+from secator.output_types import Vulnerability
+from secator.tasks._categories import VulnHttp
+
+DALFOX_TYPE_MAP = {
+	'G': 'Grep XSS',
+	'R': 'Reflected XSS',
+	'V': 'Verified XSS'
+}
+
+
+@task()
+class dalfox(VulnHttp):
+	"""Powerful open source XSS scanning tool."""
+	cmd = 'dalfox'
+	input_type = URL
+	input_flag = 'url'
+	file_flag = 'file'
+	json_flag = '--format json'
+	opt_prefix = '--'
+	opt_key_map = {
+		HEADER: 'header',
+		DELAY: 'delay',
+		FOLLOW_REDIRECT: 'follow-redirects',
+		METHOD: 'method',
+		PROXY: 'proxy',
+		RATE_LIMIT: OPT_NOT_SUPPORTED,
+		THREADS: 'worker',
+		TIMEOUT: 'timeout',
+		USER_AGENT: 'user-agent'
+	}
+	output_map = {
+		Vulnerability: {
+			ID: lambda x: None,
+			NAME: lambda x: DALFOX_TYPE_MAP[x['type']],
+			PROVIDER: 'dalfox',
+			TAGS: lambda x: [x['cwe']] if x['cwe'] else [],
+			CONFIDENCE: lambda x: 'high',
+			MATCHED_AT: lambda x: urlparse(x['data'])._replace(query='').geturl(),
+			EXTRA_DATA: lambda x: {
+				k: v for k, v in x.items()
+				if k not in ['type', 'severity', 'cwe']
+			},
+			SEVERITY: lambda x: x['severity'].lower()
+		}
+	}
+	install_cmd = 'go install -v github.com/hahwul/dalfox/v2@latest'
+	encoding = 'ansi'
+	proxychains = False
+	proxychains_flavor = 'proxychains4'
+	proxy_socks5 = True
+	proxy_http = True
+	profile = 'cpu'
+
+	@staticmethod
+	def on_line(self, line):
+		line = line.rstrip(',')
+		return line

secator/tasks/dirsearch.py

@@ -0,0 +1,90 @@
+import os
+
+import yaml
+
+from secator.decorators import task
+from secator.definitions import (CONTENT_LENGTH, CONTENT_TYPE, 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, STATUS_CODE, DATA_FOLDER,
+							   THREADS, TIMEOUT, USER_AGENT, WORDLIST)
+from secator.output_types import Url
+from secator.tasks._categories import HttpFuzzer
+from secator.utils import get_file_timestamp
+
+
+@task()
+class dirsearch(HttpFuzzer):
+	"""Advanced web path brute-forcer."""
+	cmd = 'dirsearch'
+	input_flag = '-u'
+	file_flag = '-l'
+	json_flag = '--format json'
+	opt_prefix = '--'
+	encoding = 'ansi'
+	opt_key_map = {
+		HEADER: 'header',
+		DELAY: 'delay',
+		DEPTH: 'max-recursion-depth',
+		FILTER_CODES: 'exclude-status',
+		FILTER_REGEX: 'exclude-regex',
+		FILTER_SIZE: 'exclude-sizes',
+		FILTER_WORDS: OPT_NOT_SUPPORTED,
+		FOLLOW_REDIRECT: 'follow-redirects',
+		MATCH_CODES: 'include-status',
+		MATCH_REGEX: OPT_NOT_SUPPORTED,
+		MATCH_SIZE: OPT_NOT_SUPPORTED,
+		MATCH_WORDS: OPT_NOT_SUPPORTED,
+		METHOD: 'http-method',
+		PROXY: 'proxy',
+		RATE_LIMIT: 'max-rate',
+		RETRIES: 'retries',
+		THREADS: 'threads',
+		TIMEOUT: 'timeout',
+		USER_AGENT: 'user-agent',
+		WORDLIST: 'wordlists',
+	}
+	output_map = {
+		Url: {
+			CONTENT_LENGTH: 'content-length',
+			CONTENT_TYPE: 'content-type',
+			STATUS_CODE: 'status'
+		}
+	}
+	install_cmd = 'pip3 install dirsearch'
+	proxychains = True
+	proxy_socks5 = True
+	proxy_http = True
+	profile = 'io'
+
+	def yielder(self):
+		prev = self.print_item_count
+		self.print_item_count = False
+		list(super().yielder())
+		if self.return_code != 0:
+			return
+		self.results = []
+		if not self.output_json:
+			return
+		note = f'dirsearch 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:
+				results = yaml.safe_load(f.read()).get('results', [])
+			for item in results:
+				item = self._process_item(item)
+				if not item:
+					continue
+				yield item
+		self.print_item_count = prev
+
+	@staticmethod
+	def on_init(self):
+		self.output_path = self.get_opt_value('output_path')
+		if not self.output_path:
+			timestr = get_file_timestamp()
+			self.output_path = f'{DATA_FOLDER}/dirsearch_{timestr}.json'
+		self.cmd += f' -o {self.output_path}'

secator/tasks/dnsx.py

@@ -0,0 +1,56 @@
+from secator.decorators import task
+from secator.definitions import (OPT_PIPE_INPUT, RATE_LIMIT, RETRIES, THREADS)
+from secator.output_types import Record
+from secator.tasks._categories import ReconDns
+import json
+
+
+@task()
+class dnsx(ReconDns):
+	"""dnsx is a fast and multi-purpose DNS toolkit designed for running various retryabledns library."""
+	cmd = 'dnsx -resp -a -aaaa -cname -mx -ns -txt -srv -ptr -soa -axfr -caa'
+	json_flag = '-json'
+	input_flag = OPT_PIPE_INPUT
+	file_flag = OPT_PIPE_INPUT
+	output_types = [Record]
+	opt_key_map = {
+		RATE_LIMIT: 'rate-limit',
+		RETRIES: 'retry',
+		THREADS: 'threads',
+	}
+	opts = {
+		'trace': {'is_flag': True, 'default': False, 'help': 'Perform dns tracing'},
+		'resolver': {'type': str, 'short': 'r', 'help': 'List of resolvers to use (file or comma separated)'},
+		'wildcard_domain': {'type': str, 'short': 'wd', 'help': 'Domain name for wildcard filtering'},
+	}
+
+	install_cmd = 'go install -v github.com/projectdiscovery/dnsx/cmd/dnsx@latest'
+	profile = 'io'
+
+	@staticmethod
+	def item_loader(self, line):
+		items = []
+		try:
+			item = json.loads(line)
+			if self.orig:  # original dnsx output
+				return item
+			host = item['host']
+			record_types = ['a', 'aaaa', 'cname', 'mx', 'ns', 'txt', 'srv', 'ptr', 'soa', 'axfr', 'caa']
+			for _type in record_types:
+				values = item.get(_type, [])
+				for value in values:
+					name = value
+					extra_data = {}
+					if isinstance(value, dict):
+						name = value['name']
+						extra_data = {k: v for k, v in value.items() if k != 'name'}
+					items.append({
+						'host': host,
+						'name': name,
+						'type': _type.upper(),
+						'extra_data': extra_data
+					})
+		except json.decoder.JSONDecodeError:
+			pass
+
+		return items

secator/tasks/dnsxbrute.py

@@ -0,0 +1,34 @@
+from secator.decorators import task
+from secator.definitions import (DEFAULT_DNS_WORDLIST, DOMAIN, HOST, RATE_LIMIT, RETRIES, THREADS, WORDLIST, EXTRA_DATA)
+from secator.output_types import Subdomain
+from secator.tasks._categories import ReconDns
+
+
+@task()
+class dnsxbrute(ReconDns):
+    """dnsx is a fast and multi-purpose DNS toolkit designed for running various library."""
+    cmd = 'dnsx'
+    json_flag = '-json'
+    input_flag = '-domain'
+    file_flag = '-domain'
+    opt_key_map = {
+        RATE_LIMIT: 'rate-limit',
+        RETRIES: 'retry',
+        THREADS: 'threads',
+    }
+    opts = {
+        WORDLIST: {'type': str, 'short': 'w', 'default': DEFAULT_DNS_WORDLIST, 'help': 'Wordlist'},
+        'trace': {'is_flag': True, 'default': False, 'help': 'Perform dns tracing'},
+    }
+    output_map = {
+        Subdomain: {
+            HOST: 'host',
+            DOMAIN: lambda x: ".".join(x['host'].split('.')[1:]),
+            EXTRA_DATA: lambda x: {
+                'resolver': x['resolver'],
+                'status_code': x['status_code']
+			}
+        }
+    }
+    install_cmd = 'go install -v github.com/projectdiscovery/dnsx/cmd/dnsx@latest'
+    profile = 'cpu'

secator/tasks/feroxbuster.py

@@ -0,0 +1,91 @@
+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, PROXY,
+							   RATE_LIMIT, RETRIES, STATUS_CODE, DATA_FOLDER,
+							   THREADS, TIMEOUT, USER_AGENT, WORDLIST, WORDS, DEFAULT_FEROXBUSTER_FLAGS)
+from secator.output_types import Url
+from secator.tasks._categories import HttpFuzzer
+from secator.utils import get_file_timestamp
+
+
+@task()
+class feroxbuster(HttpFuzzer):
+	"""Simple, fast, recursive content discovery tool written in Rust"""
+	cmd = f'feroxbuster {DEFAULT_FEROXBUSTER_FLAGS}'
+	input_flag = '--url'
+	input_chunk_size = 1
+	file_flag = OPT_PIPE_INPUT
+	json_flag = '--json'
+	opt_prefix = '--'
+	opts = {
+		# 'auto_tune': {'is_flag': True, 'default': False, 'help': 'Automatically lower scan rate when too many errors'},
+		'extract_links': {'is_flag': True, 'default': False, 'help': 'Extract links from response body'},
+		'collect_backups': {'is_flag': True, 'default': False, 'help': 'Request likely backup exts for urls'},
+		'collect_extensions': {'is_flag': True, 'default': False, 'help': 'Discover exts and add to --extensions'},
+		'collect_words': {'is_flag': True, 'default': False, 'help': 'Discover important words and add to wordlist'},
+	}
+	opt_key_map = {
+		HEADER: 'headers',
+		DELAY: OPT_NOT_SUPPORTED,
+		DEPTH: 'depth',
+		FILTER_CODES: 'filter-status',
+		FILTER_REGEX: 'filter-regex',
+		FILTER_SIZE: 'filter-size',
+		FILTER_WORDS: 'filter-words',
+		FOLLOW_REDIRECT: 'redirects',
+		MATCH_CODES: 'status-codes',
+		MATCH_REGEX: OPT_NOT_SUPPORTED,
+		MATCH_SIZE: OPT_NOT_SUPPORTED,
+		MATCH_WORDS: OPT_NOT_SUPPORTED,
+		METHOD: 'methods',
+		PROXY: 'proxy',
+		RATE_LIMIT: 'rate-limit',
+		RETRIES: OPT_NOT_SUPPORTED,
+		THREADS: 'threads',
+		TIMEOUT: 'timeout',
+		USER_AGENT: 'user-agent',
+		WORDLIST: 'wordlist'
+	}
+	output_map = {
+		Url: {
+			STATUS_CODE: 'status',
+			CONTENT_TYPE: lambda x: x['headers'].get('content-type'),
+			LINES: 'line_count',
+			WORDS: 'word_count'
+		}
+	}
+	install_cmd = (
+		'sudo apt install -y unzip && '
+		'curl -sL https://raw.githubusercontent.com/epi052/feroxbuster/master/install-nix.sh | '
+		'bash && sudo mv feroxbuster /usr/local/bin'
+	)
+	proxychains = False
+	proxy_socks5 = True
+	proxy_http = True
+	profile = 'cpu'
+
+	@staticmethod
+	def on_init(self):
+		self.output_path = self.get_opt_value('output_path')
+		if not self.output_path:
+			timestr = get_file_timestamp()
+			self.output_path = f'{DATA_FOLDER}/feroxbuster_{timestr}.json'
+		Path(self.output_path).touch()
+		self.cmd += f' --output {self.output_path}'
+
+	@staticmethod
+	def on_start(self):
+		if self.input_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'

secator/tasks/ffuf.py

@@ -0,0 +1,86 @@
+from secator.decorators import task
+from secator.definitions import (AUTO_CALIBRATION, CONTENT_LENGTH,
+								 CONTENT_TYPE, DELAY, DEPTH, EXTRA_DATA,
+								 FILTER_CODES, FILTER_REGEX, FILTER_SIZE,
+								 FILTER_WORDS, FOLLOW_REDIRECT, HEADER,
+								 MATCH_CODES, MATCH_REGEX, MATCH_SIZE,
+								 MATCH_WORDS, METHOD, OPT_NOT_SUPPORTED,
+								 PERCENT, PROXY, RATE_LIMIT, RETRIES,
+								 STATUS_CODE, THREADS, TIME, TIMEOUT,
+								 USER_AGENT, WORDLIST)
+from secator.output_types import Progress, Url
+from secator.serializers import JSONSerializer, RegexSerializer
+from secator.tasks._categories import HttpFuzzer
+
+FFUF_PROGRESS_REGEX = r':: Progress: \[(?P<count>\d+)/(?P<total>\d+)\] :: Job \[\d/\d\] :: (?P<rps>\d+) req/sec :: Duration: \[(?P<duration>[\d:]+)\] :: Errors: (?P<errors>\d+) ::'  # noqa: E501
+
+
+@task()
+class ffuf(HttpFuzzer):
+	"""Fast web fuzzer written in Go."""
+	cmd = 'ffuf -noninteractive -recursion'
+	input_flag = '-u'
+	input_chunk_size = 1
+	file_flag = None
+	json_flag = '-json'
+	item_loaders = [
+		JSONSerializer(),
+		RegexSerializer(FFUF_PROGRESS_REGEX, fields=['count', 'total', 'rps', 'duration', 'errors'])
+	]
+	opts = {
+		AUTO_CALIBRATION: {'is_flag': True, 'short': 'ac', 'help': 'Auto-calibration'},
+	}
+	opt_key_map = {
+		HEADER: 'H',
+		DELAY: 'p',
+		DEPTH: 'recursion-depth',
+		FILTER_CODES: 'fc',
+		FILTER_REGEX: 'fr',
+		FILTER_SIZE: 'fs',
+		FILTER_WORDS: 'fw',
+		FOLLOW_REDIRECT: 'r',
+		MATCH_CODES: 'mc',
+		MATCH_REGEX: 'mr',
+		MATCH_SIZE: 'ms',
+		MATCH_WORDS: 'mw',
+		METHOD: 'X',
+		PROXY: 'x',
+		RATE_LIMIT: 'rate',
+		RETRIES: OPT_NOT_SUPPORTED,
+		THREADS: 't',
+		TIMEOUT: 'timeout',
+		USER_AGENT: OPT_NOT_SUPPORTED,
+
+		# ffuf opts
+		WORDLIST: 'w',
+		AUTO_CALIBRATION: 'ac',
+	}
+	output_types = [Url, Progress]
+	output_map = {
+		Url: {
+			STATUS_CODE: 'status',
+			CONTENT_LENGTH: 'length',
+			CONTENT_TYPE: 'content-type',
+			TIME: lambda x: x['duration'] * 10**-9
+		},
+		Progress: {
+			PERCENT: lambda x: int(int(x['count']) * 100 / int(x['total'])),
+			EXTRA_DATA: lambda x: {k: v for k, v in x.items() if k not in ['count', 'total', 'errors']}
+		},
+	}
+	encoding = 'ansi'
+	install_cmd = (
+		'go install -v github.com/ffuf/ffuf@latest && '
+		'sudo git clone https://github.com/danielmiessler/SecLists /usr/share/seclists || true'
+	)
+	proxychains = False
+	proxy_socks5 = True
+	proxy_http = True
+	profile = 'io'
+
+	@staticmethod
+	def on_item(self, item):
+		item.method = self.get_opt_value(METHOD) or 'GET'
+		return item
+
+	# TODO: write custom item_loader to pick up Progress items too

secator/tasks/fping.py

@@ -0,0 +1,44 @@
+import validators
+
+from secator.decorators import task
+from secator.definitions import (DELAY, IP, OPT_NOT_SUPPORTED, PROXY, RATE_LIMIT,
+							   RETRIES, THREADS, TIMEOUT)
+from secator.output_types import Ip
+from secator.tasks._categories import ReconIp
+
+
+@task()
+class fping(ReconIp):
+	"""Send ICMP echo probes to network hosts, similar to ping, but much better."""
+	cmd = 'fping -a'
+	file_flag = '-f'
+	input_flag = None
+	ignore_return_code = True
+	opt_prefix = '--'
+	opt_key_map = {
+		DELAY: 'period',
+		PROXY: OPT_NOT_SUPPORTED,
+		RATE_LIMIT: OPT_NOT_SUPPORTED,
+		RETRIES: 'retry',
+		TIMEOUT: 'timeout',
+		THREADS: OPT_NOT_SUPPORTED
+	}
+	opt_value_map = {
+		DELAY: lambda x: x * 1000,  # convert s to ms
+		TIMEOUT: lambda x: x * 1000  # convert s to ms
+	}
+	input_type = IP
+	output_types = [Ip]
+	install_cmd = 'sudo apt install -y fping'
+
+	@staticmethod
+	def item_loader(self, line):
+		if validators.ipv4(line) or validators.ipv6(line):
+			return {'ip': line, 'alive': True}
+		return None
+
+	@staticmethod
+	def on_line(self, line):
+		if 'Unreachable' in line:
+			return ''  # discard line as it pollutes output
+		return line

secator/tasks/gau.py

@@ -0,0 +1,47 @@
+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,
+							   OPT_PIPE_INPUT, PROXY, RATE_LIMIT, RETRIES,
+							   THREADS, TIMEOUT, USER_AGENT)
+from secator.tasks._categories import HttpCrawler
+
+
+@task()
+class gau(HttpCrawler):
+	"""Fetch known URLs from AlienVault's Open Threat Exchange, the Wayback Machine, Common Crawl, and URLScan."""
+	cmd = 'gau'
+	file_flag = OPT_PIPE_INPUT
+	json_flag = '--json'
+	opt_prefix = '--'
+	opt_key_map = {
+		HEADER: OPT_NOT_SUPPORTED,
+		DELAY: OPT_NOT_SUPPORTED,
+		DEPTH: OPT_NOT_SUPPORTED,
+		FILTER_CODES: 'fc',
+		FILTER_REGEX: OPT_NOT_SUPPORTED,
+		FILTER_SIZE: OPT_NOT_SUPPORTED,
+		FILTER_WORDS: OPT_NOT_SUPPORTED,
+		MATCH_CODES: 'mc',
+		MATCH_REGEX: OPT_NOT_SUPPORTED,
+		MATCH_SIZE: OPT_NOT_SUPPORTED,
+		MATCH_WORDS: OPT_NOT_SUPPORTED,
+		FOLLOW_REDIRECT: OPT_NOT_SUPPORTED,
+		METHOD: OPT_NOT_SUPPORTED,
+		PROXY: 'proxy',
+		RATE_LIMIT: OPT_NOT_SUPPORTED,
+		RETRIES: 'retries',
+		THREADS: 'threads',
+		TIMEOUT: 'timeout',
+		USER_AGENT: OPT_NOT_SUPPORTED,
+	}
+	install_cmd = 'go install -v github.com/lc/gau/v2/cmd/gau@latest'
+	proxychains = False
+	proxy_socks5 = True
+	proxy_http = True
+	profile = 'io'
+
+	# @staticmethod
+	# def validate_item(self, item):
+	# 	return item['url'] == 'response'

secator/tasks/gf.py

@@ -0,0 +1,33 @@
+from secator.decorators import task
+from secator.definitions import OPT_PIPE_INPUT, URL
+from secator.output_types import Tag
+from secator.tasks._categories import Tagger
+
+
+@task()
+class gf(Tagger):
+	"""Wrapper around grep, to help you grep for things."""
+	cmd = 'gf'
+	file_flag = OPT_PIPE_INPUT
+	input_flag = OPT_PIPE_INPUT
+	opts = {
+		'pattern': {'type': str, 'help': 'Pattern names to match against (comma-delimited)'}
+	}
+	opt_key_map = {
+		'pattern': ''
+	}
+	input_type = URL
+	install_cmd = (
+		'go install -v github.com/tomnomnom/gf@latest && '
+		'git clone https://github.com/1ndianl33t/Gf-Patterns $HOME/.gf || true'
+	)
+	output_types = [Tag]
+
+	@staticmethod
+	def item_loader(self, line):
+		return {'match': line, 'name': self.get_opt_value('pattern').rstrip() + ' pattern'}  # noqa: E731,E501
+
+	@staticmethod
+	def on_item(self, item):
+		item.extra_data = {'source': 'url'}
+		return item