# Copyright (C) 2005 Insecure.Com LLC. # # Authors: Adriano Monteiro Marques # Cleber Rodrigues # # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import os import os.path import re from umitCore.Logging import log from umitCore.UmitConfigParser import UmitConfigParser from umitCore.UserConf import create_user_dir from umitCore.BasePaths import base_paths, HOME from umitCore.I18N import _ try: import psyco psyco.profile() except: log.warning(_("RUNNING WITHOUT PSYCO!")) log.warning(_("""Psyco is a module that speeds up the execution of this \ application. It is not a requirement, and Umit runs perfectly well with or without it, \ but you're encourajed to install it to have a better speed experience. Download it \ at http://psyco.sf.net/""")) CURRENT_DIR = os.getcwd() ####### # Paths class Paths(object): """Paths """ umit_conf = None umit_conf_paths = 'paths' def __init__(self): self.search = BasicSearch() self.umit_conf = UmitConfigParser() if not self.search.check_access(base_paths['user_dir'], os.R_OK and os.W_OK): result = create_user_dir(HOME) self.umit_conf.read(result['config_file']) [self.__set_it(opt, result[opt]) for opt in result] else: self.umit_conf.read(self.config_file) log.debug('Config file: %s' % self.config_file) log.debug("Umit config file successfully instanciated") self.user_dir def root_dir(self): curr_dir = CURRENT_DIR while True: splited = os.path.split(curr_dir)[0] if curr_dir == splited: break curr_dir = splited #log.debug("Root dir: %s" % curr_dir) return curr_dir ######### # GET IT! def __get_it(self, option, search_sequence=False, pattern=False, filename=False, extension=False, directory=False, sugested_path=False): '''Try to retrieve the given option, using optional arguments to improve search - option: option name - search_sequence: a list with paths to search - pattern: a regex with a pattern to search - filename: a file name to search - extension: a list of extensions to search - directory: True if searching for a directory ''' directory and log.debug("__get_it searching for directory %s" % base_paths[option]) not directory and log.debug("__get_it searching for file %s" % base_paths[option]) log.debug("__get_it option: %s" % option) self_opt = "_%s" % option current_value = getattr(self, self_opt) if current_value: log.debug("__get_it: value already set. %s" % current_value) return current_value elif self.umit_conf: try: umit_conf_result = self.umit_conf.get(self.umit_conf_paths, option) setattr(self, self_opt, umit_conf_result) log.debug("__get_it value retrieved from umit.conf: %s" % umit_conf_result) return umit_conf_result except: log.debug("__get_it no value could be retrieved from umit.conf") # Assuming that we are inside the UMIT source package supposed_path = os.path.join(CURRENT_DIR, base_paths[option]) log.debug("__get_it checking if umit is running inside it's dir: %s" % supposed_path) if self.search.check_umit_dir(CURRENT_DIR)\ and os.path.exists(supposed_path): log.debug("__get_it umit running inside it's dir. %s" % supposed_path) setattr(self, self_opt, supposed_path) self.umit_conf.set(self.umit_conf_paths, option, supposed_path) return supposed_path # Try inside user_dir supposed_path = os.path.join(self.user_dir, base_paths[option]) log.debug("__get_it checking if it's inside user dir: %s" % supposed_path) if os.path.exists(supposed_path): log.debug("__get_it umit running inside it's dir. %s" % supposed_path) setattr(self, self_opt, supposed_path) self.umit_conf.set(self.umit_conf_paths, option, supposed_path) return supposed_path # No luck... Let's search the most obvious places first if search_sequence and directory: log.debug("__get_it starting directory search sequence") for path in search_sequence: walking = os.walk(path) for w_dir in walking: search_result = (pattern and \ self.search.search_dir_with_pattern(w_dir[0], pattern)) or \ (filename and \ self.search.search_path_with_files(w_dir[0], filename)) or \ (extension and \ self.search.search_extensions(w_dir[0], extension)) or \ self.search.search_directory(w_dir[0], base_paths[option]) if search_result: log.debug("__get_it found %s" % search_result) setattr(self, self_opt, search_result) self.umit_conf.set(self.umit_conf_paths, option, search_result) return search_result log.debug("__get_it directory search failed!") elif search_sequence: log.debug("__get_it starting file search sequence") for path in search_sequence: walking = os.walk(path) for w_dir in walking: search_result = (pattern and \ self.search.search_pattern(w_dir[0], pattern)) or \ (filename and type(filename) == type("") and \ self.search.search_file(w_dir[0], filename)) or \ self.search.search_file(w_dir[0], base_paths[option]) if search_result: log.debug("__get_it found %s" % search_result) setattr(self, self_opt, search_result) self.umit_conf.set(self.umit_conf_paths, option, search_result) return search_result log.debug("__get_it file search failed!") # Not found! If something were sugested, then use it. Else, raise an exception if sugested_path: log.debug("__get_it use sugested path") setattr(self, self_opt, sugested_path) self.umit_conf.set(self.umit_conf_paths, option, sugested_path) return sugested_path raise Exception # PathNotFound Exception ######### # SET IT! def __set_it(self, option, content): log.debug("__set__it option: %s" % option) self.umit_conf.set(self.umit_conf_paths, option, content) def get_i18n_dir(self): """Tries to retrieve i18n directory absolute location Raise PathNotFound Exception if can't find it """ return self.__get_it('i18n_dir', base_paths['i18n_search_sequence'], filename=base_paths['i18n_message_file'], directory=True) def set_i18n_dir(self, path): """Verify the existance of this path, and if it really contains i18n files If we already know umit.conf location, write this information on it """ self.__set_it('i18n_dir', path) def get_pixmaps_dir(self): """Tries to retrieve pixmaps directory absolute location. Raise PathNotFound Exception if can't find it """ return self.__get_it('pixmaps_dir', search_sequence=base_paths['pixmaps_search_sequence'], extension=['.svg', '.png', '.op', '.opi', '.opt', '.opf'], directory=True) def set_pixmaps_dir(self, path): """Verify the existance of this path, and if it really contains pixmap files If we already know umit.conf location, write this information on it """ self.__set_it('pixmaps_dir', path) def get_config_dir(self): """Tries to retrieve config files directory absolute location. Raise PathNotFound Exception if can't find it """ try: return self.__get_it('config_dir', search_sequence=base_paths['config_search_sequence'], filename=base_paths['config_file'], directory=True) except: # Create user_dir user_dir = self.create_user_dir() self._config_dir = user_dir #log.debug("Created umit_dir: %s" % self._config_dir) # Create umit.conf open(os.path.join(self._config_dir, base_paths['config_file']), 'a').close() #log.debug("Created umit.conf inside new umir_dir") # First time searching for config_dir could lead to an Exception here try: self.umit_conf.set(self.umit_conf_paths, 'config_dir', self._config_dir) except: pass return self._config_dir def set_config_dir(self, path): """Verify the existance of this path, and if it really contains the config file If we already know umit.conf location, write this information on it """ self.__set_it('config_dir', path) def get_config_file(self): """Get UMIT config file """ return self.__get_it('config_file', search_sequence=[self.user_dir, self.config_dir], filename=base_paths['config_file']) def set_config_file(self, config_file): """Set UMIT config file """ self.__set_it('config_file', config_file) def create_user_dir(self, user_dir=None): """Create UMIT user directory. Usually ~/.umit """ #log.debug("create_user_dir (argument): %s" % user_dir) if not user_dir: result = create_user_dir(HOME) else: result = create_user_dir(user_dir) self._user_dir = result["user_dir"] self.umit_conf.set(self.umit_conf_paths, 'user_dir', self._user_dir) return self._user_dir def set_user_dir(self, path): """Define user's UMIT directory location. If path doesn't exist nor have acces permissions, raises PathNotFound and PathAccessDenied Exceptions respectivately """ self.__set_it('user_dir', path) def get_user_dir(self): """Tries to retrieve config files directory absolute location. Raise PathNotFound Exception if can't find it """ if self._user_dir: return self._user_dir elif self.umit_conf: try: self._user_dir = self.umit_conf.get(self.umit_conf_paths, 'user_dir') return self._user_dir except: pass # No luck... Let's search the most obvious places first if self.search.check_access(base_paths['user_dir'], os.R_OK and os.W_OK): self._user_dir = base_paths['user_dir'] self.umit_conf.set(self.umit_conf_paths, 'user_dir', self._user_dir) return self._user_dir # Assuming that we are inside the UMIT source package and user doesn't have a UMIT # home directory if self.search.check_umit_dir(CURRENT_DIR): self._user_dir = CURRENT_DIR self.umit_conf.set(self.umit_conf_paths, 'user_dir', self._user_dir) return self._user_dir raise Exception # PathNotFound Exception def get_target_list(self): return self.__get_it('target_list', search_sequence=base_paths['basic_search_sequence']) def set_target_list(self, target_list): self.__set_it('target_list', target_list) def get_profile_editor(self): return self.__get_it('profile_editor', search_sequence=base_paths['basic_search_sequence']) def set_profile_editor(self, profile_editor): self.__set_it('profile_editor', profile_editor) def get_wizard(self): return self.__get_it('wizard', search_sequence=base_paths['basic_search_sequence']) def set_wizard(self, wizard): self.__set_it('wizard', wizard) def get_scan_profile(self): return self.__get_it('scan_profile', search_sequence=base_paths['basic_search_sequence']) def set_scan_profile(self, scan_profile): self.__set_it('scan_profile', scan_profile) def get_recent_scans(self): return self.__get_it('recent_scans', search_sequence=base_paths['basic_search_sequence']) def set_recent_scans(self, recent_scans): self.__set_it('recent_scans', recent_scans) def get_umit_op(self): return self.__get_it('umit_op', search_sequence=base_paths['pixmaps_search_sequence']) def set_umit_op(self, op): self.__set_it('umit_op', op) def get_options(self): return self.__get_it('options', search_sequence=base_paths['basic_search_sequence']) def set_options(self, path): self.__set_it('options', path) def get_umit_opi(self): return self.__get_it('umit_opi', search_sequence=base_paths['pixmaps_search_sequence']) def set_umit_opi(self, path): self.__set_it('umit_opi', path) def get_umit_opt(self): return self.__get_it('umit_opt', search_sequence=base_paths['pixmaps_search_sequence']) def set_umit_opt(self, path): self.__set_it('umit_opt', path) def get_umit_opf(self): return self.__get_it('umit_opf', search_sequence=base_paths['pixmaps_search_sequence']) def set_umit_opf(self, path): self.__set_it('umit_opf', path) def get_umitdb(self): return self.__get_it('umitdb', search_sequence=base_paths['basic_search_sequence']) def set_umitdb(self, path): self.__set_it('umitdb', path) def get_services(self): return self.__get_it('services', search_sequence=base_paths['basic_search_sequence']) def set_services(self, path): self.__set_it('services', path) def get_os_db(self): return self.__get_it('os_db', search_sequence=base_paths['basic_search_sequence']) def set_os_db(self, path): self.__set_it('os_db', path) def get_os_fingerprints(self): return self.__get_it('os_fingerprints', search_sequence=base_paths['basic_search_sequence']) def set_os_fingerprints(self, path): self.__set_it('os_fingerprints', path) def get_services_dump(self): return self.__get_it('services_dump', search_sequence=base_paths['basic_search_sequence'], sugested_path=os.path.join(self.config_dir, base_paths["services_dump"])) def set_services_dump(self, path): self.__set_it('services_dump', path) def get_os_dump(self): return self.__get_it('os_dump', search_sequence=base_paths['basic_search_sequence'], sugested_path=os.path.join(self.config_dir, base_paths["os_dump"])) def set_os_dump(self, path): self.__set_it('os_dump', path) def get_umit_version(self): return self.__get_it('umit_version', search_sequence=base_paths['basic_search_sequence']) def set_umit_version(self, path): self.__set_it('umit_version', path) def get_os_classification(self): return self.__get_it('os_classification', search_sequence=base_paths['basic_search_sequence']) def set_os_classification(self, path): self.__set_it('os_classification', path) i18n_dir = property(get_i18n_dir, set_i18n_dir, doc=_("i18n_dir")) pixmaps_dir = property(get_pixmaps_dir, set_pixmaps_dir, doc=_("pixmaps_dir")) config_dir = property(get_config_dir, set_config_dir, doc=_("config_dir")) user_dir = property(get_user_dir, set_user_dir, doc=_("user_dir")) config_file = property(get_config_file, set_config_file, doc=_("config_file")) target_list = property(get_target_list, set_target_list, doc=_("target_list")) profile_editor = property(get_profile_editor, set_profile_editor, doc=_("profile_editor")) wizard = property(get_wizard, set_wizard, doc=_("wizard")) scan_profile = property(get_scan_profile, set_scan_profile, doc=_("scan_profile")) recent_scans = property(get_recent_scans, set_recent_scans, doc=_("recent_scans")) options = property(get_options, set_options, doc=_("options")) umit_op = property(get_umit_op, set_umit_op, doc=_("umit_op")) umit_opi = property(get_umit_opi, set_umit_opi, doc=_("umit_opi")) umit_opt = property(get_umit_opt, set_umit_opt, doc=_("umit_opt")) umit_opf = property(get_umit_opf, set_umit_opf, doc=_("umit_opf")) umitdb = property(get_umitdb, set_umitdb, doc=_("umitdb")) services = property(get_services, set_services, doc=_("services")) os_db = property(get_os_db, set_os_db, doc=_("os_db")) # New OS detection fingerprints os_fingerprints = property(get_os_fingerprints, set_os_fingerprints, doc=_("os_fingerprints")) # Old OS detection fingerprints services_dump = property(get_services_dump, set_services_dump, doc=_("services_dump")) os_dump = property(get_os_dump, set_os_dump, doc=_("os_dump")) umit_version = property(get_umit_version, set_umit_version) os_classification = property(get_os_classification, set_os_classification) _i18n_dir = None _pixmaps_dir = None _config_dir = None _user_dir = None _config_file = None _target_list = None _profile_editor = None _wizard = None _scan_profile = None _recent_scans = None _options = None _umit_op = None _umit_opi = None _umit_opt = None _umit_opf = None _umitdb = None _services = None _os_db = None _os_fingerprints = None _services_dump = None _os_dump = None _umit_version = None _os_classification = None ########### # Searching class BasicSearch(object): UMIT_DIRECTORIES = ['umitCore', 'umitGUI', 'share'] UMIT_FILES = ['umit.pyw'] def check_access(self, path, permission): return os.path.exists(path) and os.access(path, permission) def get_file_list(self, path): return [f for f in os.listdir(path) if os.path.isfile(os.path.join(path, f))] def get_dir_list(self, path): return [d for d in os.listdir(path) if os.path.isdir(os.path.join(path, d))] def search_directory(self, path, directory): if self.check_access(path, os.R_OK): dir_list = self.get_dir_list(path) if type(directory) == type([]): for d in directory: if d not in dir_list: break else: return path return False if type(directory) == type(""): if directory in dir_list: return path return False raise Exception # PathAccessDenied Exception def search_dir_with_file(self, path, filename): """Search for an specified file inside the directory tree of a given path """ if self.check_access(path, os.R_OK): if filename in self.get_file_list(path): return path return False def search_file(self, path, filename): """Search for an specified file inside the directory tree of a given path """ if self.check_access(path, os.R_OK): if filename in self.get_file_list(path): return os.path.join(path, filename) return False def search_pattern(self, path, pattern): """Search for a filename that matches the given patern. Return first found """ if self.check_access(path, os.R_OK): file_regex = re.compile(pattern) for f in self.get_file_list(path): if file_regex.match(f): return os.path.join(path, f) return False raise PathNotFound def search_dir_pattern(self, path, pattern): """Search for a filename that matches the given patern """ if self.check_access(path, os.R_OK): file_regex = re.compile(pattern) for f in self.get_file_list(path): if file_regex.match(f): return path return False raise PathNotFound def search_path_with_files(self, path, files): if self.check_access(path, os.R_OK): file_list = self.get_file_list(path) if type(files) == type([]): for f in files: if f not in file_list: break else: return path return False elif type(files) == type(''): if files in self.get_file_list(path): return path return False raise Exception # WrongSearchParameters def check_umit_dir(self, path): log.debug("check_umit_dir (argument): %s" % path) dir_content = os.listdir(path) for directory in self.UMIT_DIRECTORIES: log.debug("Checking if directory %s exists" % directory) if directory not in dir_content: return False for umit_file in self.UMIT_FILES: log.debug("Checking if umit file %s exists" % umit_file) if umit_file not in dir_content: return False return True def search_extensions(self, path, extensions): """Verify if a given path contains given extensions. The path must contain every given extension, else returns False """ if self.check_access(path, os.R_OK): file_list = self.get_file_list(path) if type(extensions) == type([]): for ext in extensions: ext_regex = re.compile('^.*%s$' % re.escape(ext)) for f in file_list: if ext_regex.match(f): break else: return False return path elif type(extensions) == type(''): ext_regex = re.compile('^.*%s$' % re.escape(extensions)) for f in file_list: if ext_regex.match(f): return path else: return False raise Exception # WrongSearchParameters raise Exception # PathNotFound Exception ######### # Singleton! Path = Paths() Search = BasicSearch() if __name__ == '__main__': #Path.umit_conf.write(open('/tmp/teste', 'w')) #log.critical(Search.search_directory("/home/adriano", ["po"])) print ">>> I18N DIR:", Path.i18n_dir print ">>> PIXMAPS DIR:", Path.pixmaps_dir print ">>> CONFIG DIR:", Path.config_dir print ">>> CONFIG FILE:", Path.config_file print ">>> USER DIR:", Path.user_dir print ">>> TARGET_LIST:", Path.target_list print ">>> PROFILE_EDITOR:", Path.profile_editor print ">>> WIZARD:", Path.wizard print ">>> SCAN_PROFILE:", Path.scan_profile print ">>> RECENT_SCANS:", Path.recent_scans print ">>> OPTIONS:", Path.options print print ">>> UMIT_OP:", Path.umit_op print ">>> UMIT_OPI:", Path.umit_opi print ">>> UMIT_OPT:", Path.umit_opt print ">>> UMIT_OPF:", Path.umit_opf print ">>> UMITDB:", Path.umitdb print ">>> SERVICES:", Path.services print ">>> OS DB:", Path.os_db print ">>> OS FINGERPRINTS:", Path.os_fingerprints print ">>> SERVICES DUMP:", Path.services_dump print ">>> OS DB DUMP:", Path.os_dump print ">>> UMIT VERSION:", Path.umit_version print ">>> OS CLASSIFICATION DUMP:", Path.os_classification