增加targets参数

common/utils.py

@@ -104,44 +104,56 @@ def split_list(ls, size):
     return [ls[i:i + size] for i in range(0, len(ls), size)]
 
 
-def read_target(target):
-    domains = list()
+def match_main_domain(domain):
+    if not isinstance(domain, str):
+        return None
+    item = domain.lower().strip()
+    return Domain(item).match()
+
+
+def read_target_file(target):
+    domains = set()
     with open(target, encoding='utf-8', errors='ignore') as file:
         for line in file:
-            line = line.lower().strip()
-            domain = Domain(line).match()
+            domain = match_main_domain(line)
             if domain:
-                domains.append(domain)
+                domains.add(domain)
     return domains
 
 
-def get_domains(target):
-    """
-    Get domains
-
-    :param  set or str target:
-    :return list: domain list
-    """
-    domains = list()
-    logger.log('DEBUG', f'Getting domains')
-    if isinstance(target, (set, tuple)):
-        domains = list(target)
-    elif isinstance(target, list):
-        domains = target
-    elif isinstance(target, str):
-        path = Path(target)
-        if path.exists() and path.is_file():
-            domains = read_target(target)
-        else:
-            target = target.lower().strip()
-            domain = Domain(target).match()
+def get_from_target(target):
+    domains = set()
+    if isinstance(target, str):
+        domain = match_main_domain(target)
         if domain:
-                domains.append(domain)
-    count = len(domains)
-    if count == 0:
-        logger.log('FATAL', f'Get {count} domains')
+            domains.add(domain)
+    return domains
+
+
+def get_from_targets(targets):
+    domains = set()
+    if not isinstance(targets, str):
+        return domains
+    try:
+        path = Path(targets)
+    except Exception as e:
+        logger.log('ERROR', e.args)
+        return domains
+    if path.exists() and path.is_file():
+        domains = read_target_file(targets)
+        return domains
+    return domains
+
+
+def get_domains(target, targets):
+    logger.log('DEBUG', f'Getting domains')
+    target_domains = get_from_target(target)
+    targets_domains = get_from_targets(targets)
+    domains = list(target_domains.union(targets_domains))
+    logger.log('INFOR', f'Get {len(domains)} domains')
+    if not domains:
+        logger.log('FATAL', f'Did not get a valid domain name')
         exit(1)
-    logger.log('INFOR', f'Get {count} domains')
     logger.log('DEBUG', f'The obtained domains \n{domains}')
     return domains
 

oneforall.py

@@ -54,7 +54,7 @@ class OneForAll(object):
         python3 oneforall.py version
         python3 oneforall.py check
         python3 oneforall.py --target example.com run
-        python3 oneforall.py --target ./domains.txt run
+        python3 oneforall.py --targets ./domains.txt run
         python3 oneforall.py --target example.com --alive False run
         python3 oneforall.py --target example.com --brute True run
         python3 oneforall.py --target example.com --port medium run
@@ -68,22 +68,24 @@ class OneForAll(object):
         --alive  True/False           Only export alive subdomains or not (default False)
         --port   small/medium/large  See details in ./config/setting.py(default small)
         --format rst/csv/tsv/json/yaml/html/jira/xls/xlsx/dbf/latex/ods (result format)
-        --path   Result directory (default directory is ./results)
+        --path   Result path (default directory is ./results)
 
-    :param str target:     One domain or File path of one domain per line (required)
+    :param str target:     One domain (target or targets must be required)
+    :param str targets:    File path of one domain per line
     :param bool brute:     Use brute module (default False)
     :param bool dns:       Use DNS resolution (default True)
     :param bool req:       HTTP request subdomains (default True)
     :param str port:       The port range to request (default small port is 80,443)
     :param bool alive:     Only export alive subdomains (default False)
     :param str format:     Result format (default csv)
-    :param str path:       Result directory (default None)
+    :param str path:       Result path (default None, automatically generated)
     :param bool takeover:  Scan subdomain takeover (default False)
     """
 
-    def __init__(self, target, brute=None, dns=None, req=None, port=None,
-                 alive=None, format=None, path=None, takeover=None):
+    def __init__(self, target=None, targets=None, brute=None, dns=None, req=None,
+                 port=None, alive=None, format=None, path=None, takeover=None):
         self.target = target
+        self.targets = targets
         self.brute = brute
         self.dns = dns
         self.req = req
@@ -101,9 +103,9 @@ class OneForAll(object):
         self.origin_table = str()  # The table name of the origin result
         self.resolve_table = str()  # The table name of the resolute result
 
-    def config(self):
+    def config_param(self):
         """
-        Configuration parameter
+        Config parameter
         """
         if self.brute is None:
             self.brute = bool(settings.enable_brute_module)
@@ -122,6 +124,14 @@ class OneForAll(object):
         if self.path is None:
             self.path = settings.result_save_path
 
+    def check_param(self):
+        """
+        Check parameter
+        """
+        if self.target is None and self.targets is None:
+            logger.log('FATAL', 'You must provide either target or targets parameter')
+            exit(1)
+
     def export(self, table):
         """
         Export data from the database and do some follow-up processing
@@ -256,8 +266,9 @@ class OneForAll(object):
         logger.log('DEBUG', 'Python ' + utils.python_version())
         logger.log('DEBUG', 'OneForAll ' + version)
         logger.log('INFOR', 'Start running OneForAll')
-        self.config()
-        self.domains = utils.get_domains(self.target)
+        self.config_param()
+        self.check_param()
+        self.domains = utils.get_domains(self.target, self.targets)
         if self.domains:
             for domain in self.domains:
                 self.domain = utils.get_main_domain(domain)