man-spider 1.1.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

man_spider/lib/smb.py

@@ -1,22 +1,26 @@
 import ntpath
 import logging
-from .errors import *
 from contextlib import suppress
 from impacket.nmb import NetBIOSError, NetBIOSTimeout
 from impacket.smbconnection import SessionError, SMBConnection
 
+from man_spider.lib.errors import *
+
 # set up logging
-log = logging.getLogger('manspider.smb')
+log = logging.getLogger("manspider.smb")
 
 
 class SMBClient:
-    '''
+    """
     Wrapper around impacket's SMBConnection() object
-    '''
+    """
 
-    def __init__(self, server, username, password, domain, nthash, use_kerberos=False, aes_key="", dc_ip=None):
+    def __init__(
+        self, server, username, password, domain, nthash, use_kerberos=False, aes_key="", dc_ip=None, port=445
+    ):
 
         self.server = server
+        self.port = port
 
         self.conn = None
 
@@ -30,22 +34,33 @@ class SMBClient:
         self.hostname = None
         self.dns_domain = None
         if self.nthash:
-            self.lmhash = 'aad3b435b51404eeaad3b435b51404ee'
+            self.lmhash = "aad3b435b51404eeaad3b435b51404ee"
         else:
-            self.lmhash = ''
+            self.lmhash = ""
         self._shares = None
 
-
     def list_shares(self):
-        '''
+        """
         List shares on the SMB server
-        '''
+        """
         resp = self.conn.listShares()
+        log.debug(f"{self.server}: Response length: {len(resp)}")
         for i in range(len(resp)):
-            sharename = resp[i]['shi1_netname'][:-1]
-            log.debug(f'{self.server}: Found share: {sharename}')
-            yield sharename
-
+            try:
+                sharename = resp[i]["shi1_netname"].rstrip("\x00")
+                try:
+                    share_type = resp[i]["shi1_type"]
+                except (KeyError, AttributeError):
+                    share_type = "unknown"
+                try:
+                    share_comment = resp[i]["shi1_remark"].rstrip("\x00")
+                except (KeyError, AttributeError):
+                    share_comment = ""
+                log.debug(f"{self.server}: Share {i}: name='{sharename}', type={share_type}, comment='{share_comment}'")
+                yield sharename
+            except Exception as e:
+                log.debug(f"{self.server}: Error processing share {i}: {e}")
+                continue
 
     @property
     def shares(self):
@@ -54,27 +69,26 @@ class SMBClient:
                 self._shares = list(self.list_shares())
             except Exception as e:
                 e = self.handle_impacket_error(e)
-                log.debug(f'{self.server}: Error listing shares: {e}, retrying...')
+                log.debug(f"{self.server}: Error listing shares: {e}, retrying...")
                 self.rebuild(e)
                 try:
                     self._shares = list(self.list_shares())
                 except Exception as e:
                     e = self.handle_impacket_error(e)
-                    log.warning(f'{self.server}: Error listing shares: {e}')
+                    log.warning(f"{self.server}: Error listing shares: {e}")
                     self.rebuild(e)
         return self._shares or []
 
-
     def get_hostname(self):
-        '''
+        """
         Get the hostname from the SMB connection
-        '''
+        """
         try:
             conn = SMBConnection(
                 self.server,
                 self.server,
                 None,
-                445,
+                self.port,
                 timeout=10,
             )
             with suppress(Exception):
@@ -85,36 +99,36 @@ class SMBClient:
                     # Get the server name from SMB
                     self.hostname = str(conn.getServerName()).strip().replace("\x00", "").lower()
                     if self.hostname:
-                        log.debug(f'{self.server}: Got hostname: {self.hostname}')
+                        log.debug(f"{self.server}: Got hostname: {self.hostname}")
                     else:
-                        log.debug(f'{self.server}: No hostname found')
+                        log.debug(f"{self.server}: No hostname found")
                 except Exception as e:
-                    log.debug(f'{self.server}: Error getting hostname from SMB: {e}')
+                    log.debug(f"{self.server}: Error getting hostname from SMB: {e}")
                     self.hostname = ""
 
             if self.dns_domain is None:
                 try:
                     self.dns_domain = str(conn.getServerDNSDomainName()).strip().replace("\x00", "").lower()
                     if self.dns_domain:
-                        log.debug(f'{self.server}: Got DNS domain: {self.dns_domain}')
+                        log.debug(f"{self.server}: Got DNS domain: {self.dns_domain}")
                     else:
-                        log.debug(f'{self.server}: No DNS domain found')
+                        log.debug(f"{self.server}: No DNS domain found")
                 except Exception as e:
-                    log.debug(f'{self.server}: Error getting DNS domain: {e}')
-                    self.dns_domain = (self.domain if self.domain else "")
+                    log.debug(f"{self.server}: Error getting DNS domain: {e}")
+                    self.dns_domain = self.domain if self.domain else ""
 
         except Exception as e:
-            log.debug(f'{self.server}: Error getting hostname: {e}')
+            log.debug(f"{self.server}: Error getting hostname: {e}")
 
         return self.hostname, self.domain
 
     def login(self, refresh=False, first_try=True):
-        '''
+        """
         Create a new SMBConnection object (if there isn't one already or if refresh is True)
         Attempt to log in, and switch to null session if logon fails
         Return True if logon succeeded
         Return False if logon failed
-        '''
+        """
 
         target_server = self.server
         if self.use_kerberos:
@@ -126,20 +140,19 @@ class SMBClient:
 
         if self.conn is None or refresh:
             try:
-                self.conn = SMBConnection(target_server, target_server, sess_port=445, timeout=20)
+                self.conn = SMBConnection(target_server, target_server, sess_port=self.port, timeout=20)
             except Exception as e:
                 log.debug(impacket_error(e))
                 return None
 
             try:
-
-                if self.username in [None, '', 'Guest'] and first_try:
+                if self.username in [None, "", "Guest"] and first_try:
                     # skip to guest / null session
                     assert False
 
                 user_str = self.username
                 if self.domain:
-                    user_str = f'{self.domain}\\{self.username}'
+                    user_str = f"{self.domain}\\{self.username}"
                 log.debug(f'{target_server} ({self.server}): Authenticating as "{user_str}"')
 
                 if self.use_kerberos:
@@ -156,7 +169,7 @@ class SMBClient:
                 elif self.nthash and not self.password:
                     self.conn.login(
                         self.username,
-                        '',
+                        "",
                         lmhash=self.lmhash,
                         nthash=self.nthash,
                         domain=self.domain,
@@ -173,28 +186,26 @@ class SMBClient:
                 return True
 
             except Exception as e:
-
                 if type(e) != AssertionError:
                     e = self.handle_impacket_error(e, display=True)
 
                 # try guest account, then null session if logon failed
                 if first_try:
-
-                    bad_statuses = ['LOGON_FAIL', 'PASSWORD_EXPIRED', 'LOCKED_OUT', 'SESSION_DELETED']
+                    bad_statuses = ["LOGON_FAIL", "PASSWORD_EXPIRED", "LOCKED_OUT", "SESSION_DELETED"]
                     if any([s in str(e) for s in bad_statuses]):
                         for s in bad_statuses:
                             if s in str(e):
-                                log.warning(f'{self.server}: {s}: {self.username}')
+                                log.warning(f"{self.server}: {s}: {self.username}")
 
-                    log.debug(f'{self.server}: Trying guest session')
-                    self.username = 'Guest'
-                    self.password = ''
-                    self.domain = ''
-                    self.nthash = ''
+                    log.debug(f"{self.server}: Trying guest session")
+                    self.username = "Guest"
+                    self.password = ""
+                    self.domain = ""
+                    self.nthash = ""
                     guest_success = self.login(refresh=True, first_try=False)
                     if not guest_success:
-                        log.debug(f'{self.server}: Switching to null session')
-                        self.username = ''
+                        log.debug(f"{self.server}: Switching to null session")
+                        self.username = ""
                         self.login(refresh=True, first_try=False)
 
             return False
@@ -202,54 +213,51 @@ class SMBClient:
         else:
             return True
 
-
     def ls(self, share, path):
-        '''
+        """
         List files in share/path
         Raise FileListError if there's a problem
         @byt3bl33d3r it's really not that bad
-        '''
+        """
 
-        nt_path = ntpath.normpath(f'{path}\\*')
+        nt_path = ntpath.normpath(f"{path}\\*")
 
         # for every file/dir in "path"
         try:
             for f in self.conn.listPath(share, nt_path):
                 # exclude current and parent directory
-                if f.get_longname() not in ['', '.', '..']:
+                if f.get_longname() not in ["", ".", ".."]:
                     yield f
         except Exception as e:
             e = self.handle_impacket_error(e)
             raise FileListError(f'{e.args}: Error listing files at "{share}{nt_path}"')
 
-
-    def rebuild(self, error=''):
-        '''
+    def rebuild(self, error=""):
+        """
         Rebuild our SMBConnection() if it gets borked
-        '''
-        log.debug(f'Rebuilding connection to {self.server} after error: {error}')
+        """
+        log.debug(f"Rebuilding connection to {self.server} after error: {error}")
         self.login(refresh=True)
 
-
-    def handle_impacket_error(self, e, share='', filename='', display=False):
-        '''
+    def handle_impacket_error(self, e, share="", filename="", display=False):
+        """
         Handle arbitrary Impacket errors
         this is needed because the library doesn't implement proper inheritance for its exceptions
-        '''
-        resource_str = '/'.join([self.server, share, filename]).rstrip('/')
+        """
+        resource_str = "/".join([self.server, share, filename]).rstrip("/")
 
         if type(e) == KeyboardInterrupt:
             raise
         elif type(e) in (NetBIOSError, NetBIOSTimeout, BrokenPipeError, SessionError, CSessionError):
             # the connection may need to be rebuilt
             if type(e) in (SessionError, CSessionError):
-                if any([x in str(e) for x in ('PASSWORD_EXPIRED',)]):
+                if any([x in str(e) for x in ("PASSWORD_EXPIRED",)]):
                     self.rebuild(e)
             else:
                 self.rebuild(e)
         if type(e) in native_impacket_errors:
             e = impacket_error(e)
         if display:
-            log.debug(f'{resource_str}: {str(e)[:150]}')
+            log.debug(f"{resource_str}: {str(e)[:150]}")
 
         return e

man_spider/lib/spider.py

@@ -1,53 +1,52 @@
 import re
-import sys
 import queue
-import threading
 from time import sleep
 import multiprocessing
 from pathlib import Path
-from .spiderling import *
-from .parser import FileParser
+
+from man_spider.lib.spiderling import *
+from man_spider.lib.parser import FileParser
 
 # set up logging
-log = logging.getLogger('manspider')
+log = logging.getLogger("manspider")
 
 
 class MANSPIDER:
-
     def __init__(self, options):
 
-        self.targets            = options.targets
-        self.threads            = options.threads
-        self.maxdepth           = options.maxdepth
-        self.quiet              = options.quiet
+        self.targets = options.targets
+        self.threads = options.threads
+        self.maxdepth = options.maxdepth
+        self.quiet = options.quiet
 
-        self.username           = options.username
-        self.password           = options.password
-        self.domain             = options.domain
-        self.nthash             = options.hash
-        self.use_kerberos       = options.kerberos
-        self.aes_key            = options.aes_key
-        self.dc_ip              = options.dc_ip
-        self.max_failed_logons  = options.max_failed_logons
-        self.max_filesize       = options.max_filesize
+        self.username = options.username
+        self.password = options.password
+        self.domain = options.domain
+        self.nthash = options.hash
+        self.use_kerberos = options.kerberos
+        self.aes_key = options.aes_key
+        self.dc_ip = options.dc_ip
+        self.max_failed_logons = options.max_failed_logons
+        self.max_filesize = options.max_filesize
 
-        self.share_whitelist    = options.sharenames
-        self.share_blacklist    = options.exclude_sharenames
+        self.share_whitelist = options.sharenames
+        self.share_blacklist = options.exclude_sharenames
 
-        self.dir_whitelist      = options.dirnames
-        self.dir_blacklist      = options.exclude_dirnames
+        self.dir_whitelist = options.dirnames
+        self.dir_blacklist = options.exclude_dirnames
 
-        self.no_download        = options.no_download
+        self.no_download = options.no_download
 
         # applies "or" logic instead of "and"
         # e.g. file is downloaded if filename OR extension OR content match
-        self.or_logic           = options.or_logic
+        self.or_logic = options.or_logic
+
+        self.extension_blacklist = options.exclude_extensions
+        self.file_extensions = options.extensions
 
-        self.extension_blacklist= options.exclude_extensions
-        self.file_extensions    = options.extensions
         if self.file_extensions:
             extensions_str = '"' + '", "'.join(list(self.file_extensions)) + '"'
-            log.info(f'Searching by file extension: {extensions_str}')
+            log.info(f"Searching by file extension: {extensions_str}")
 
         self.init_filename_filters(options.filenames)
         self.parser = FileParser(options.content, quiet=self.quiet)
@@ -62,20 +61,27 @@ class MANSPIDER:
         self.smb_client_cache = dict()
 
         # directory to store documents when searching contents
-        self.tmp_dir = Path('/tmp/.manspider')
+        self.tmp_dir = Path("/tmp/.manspider")
         self.tmp_dir.mkdir(exist_ok=True)
 
         # directory to store matching documents
-        self.loot_dir = Path.home() / '.manspider' / 'loot'
+        self.loot_dir = Path.home() / ".manspider" / "loot"
+
+        if options.loot_dir:
+            self.loot_dir = Path(options.loot_dir)
 
-        if(options.loot_dir):
-            self.loot_dir=Path(options.loot_dir)
-        
         self.loot_dir.mkdir(parents=True, exist_ok=True)
 
         if not options.no_download:
-            log.info(f'Matching files will be downloaded to {self.loot_dir}')
+            log.info(f"Matching files will be downloaded to {self.loot_dir}")
+
+        self.modified_after = options.modified_after
+        self.modified_before = options.modified_before
 
+        if self.modified_after:
+            log.info(f"Filtering files modified after: {self.modified_after.strftime('%Y-%m-%d')}")
+        if self.modified_before:
+            log.info(f"Filtering files modified before: {self.modified_before.strftime('%Y-%m-%d')}")
 
     def start(self):
 
@@ -100,7 +106,7 @@ class MANSPIDER:
                 continue
 
             # save on CPU
-            sleep(.1)
+            sleep(0.1)
 
         while 1:
             self.check_spiderling_queue()
@@ -111,23 +117,19 @@ class MANSPIDER:
         # make sure the queue is empty
         self.check_spiderling_queue()
 
-
-
     def init_file_extensions(self, file_extensions):
-        '''
+        """
         Get ready to search by file extension
-        '''
+        """
 
         self.file_extensions = FileExtensions()
         if file_extensions:
             self.file_extensions.update(file_extensions)
-            
-
 
     def init_filename_filters(self, filename_filters):
-        '''
+        """
         Get ready to search by filename
-        '''
+        """
 
         # strings to look for in filenames
         # if empty, all filenames are matched
@@ -135,23 +137,22 @@ class MANSPIDER:
         for f in filename_filters:
             regex_str = str(f)
             try:
-                if not any([f.startswith(x) for x in ['^', '.*']]):
-                    regex_str = rf'.*{regex_str}'
-                if not any([f.endswith(x) for x in ['$', '.*']]):
-                    regex_str = rf'{regex_str}.*'
+                if not any([f.startswith(x) for x in ["^", ".*"]]):
+                    regex_str = rf".*{regex_str}"
+                if not any([f.endswith(x) for x in ["$", ".*"]]):
+                    regex_str = rf"{regex_str}.*"
                 self.filename_filters.append(re.compile(regex_str, re.I))
             except re.error as e:
                 log.error(f'Unsupported filename regex "{f}": {e}')
                 sleep(1)
         if self.filename_filters:
             filename_filter_str = '"' + '", "'.join([f.pattern for f in self.filename_filters]) + '"'
-            log.info(f'Searching by filename: {filename_filter_str}')
-
+            log.info(f"Searching by filename: {filename_filter_str}")
 
     def check_spiderling_queue(self):
-        '''
+        """
         Empty the spiderling queue
-        '''
+        """
 
         while 1:
             try:
@@ -161,55 +162,53 @@ class MANSPIDER:
             except queue.Empty:
                 break
 
-
     def process_message(self, message):
-        '''
+        """
         Process messages from spiderlings
         Log messages, errors, files, etc.
-        '''
-        if message.type == 'a':
+        """
+        if message.type == "a":
             if message.content == False:
                 self.failed_logons += 1
             if self.lockout_threshold():
-                log.error(f'REACHED MAXIMUM FAILED LOGONS OF {self.max_failed_logons:,}')
-                log.error('KILLING EXISTING SPIDERLINGS AND CONTINUING WITH GUEST/NULL SESSIONS')
-                #for spiderling in self.spiderling_pool:
+                log.error(f"REACHED MAXIMUM FAILED LOGONS OF {self.max_failed_logons:,}")
+                log.error("KILLING EXISTING SPIDERLINGS AND CONTINUING WITH GUEST/NULL SESSIONS")
+                # for spiderling in self.spiderling_pool:
                 #    spiderling.kill()
-                self.username = ''
-                self.password = ''
-                self.nthash = ''
-                self.domain = ''
-
+                self.username = ""
+                self.password = ""
+                self.nthash = ""
+                self.domain = ""
 
     def lockout_threshold(self):
-        '''
+        """
         Return True if we've reached max failed logons
-        '''
+        """
 
         if self.max_failed_logons is not None:
             if self.failed_logons >= self.max_failed_logons and self.domain:
                 return True
         return False
 
-
     def get_smb_client(self, target):
-        '''
+        """
         Check if we already have an smb_client cached
         If not, then create it
-        '''
+        """
 
         smb_client = self.smb_client_cache.get(target, None)
 
         if smb_client is None:
             smb_client = SMBClient(
-                target,
+                target.host,
                 self.username,
                 self.password,
                 self.domain,
                 self.nthash,
                 self.use_kerberos,
                 self.aes_key,
-                self.dc_ip
+                self.dc_ip,
+                port=target.port,
             )
             logon_result = smb_client.login()
             if logon_result == False: