mirror of
https://github.com/volatilityfoundation/volatility
synced 2026-06-08 18:04:46 +00:00
iMHLv2
463 lines
15 KiB
Python
Executable File
463 lines
15 KiB
Python
Executable File
## This file was taken from PyFlag http://www.pyflag.net/
|
|
# Michael Cohen <scudette@users.sourceforge.net>
|
|
# David Collett <daveco@users.sourceforge.net>
|
|
#
|
|
# ******************************************************
|
|
# Version: FLAG $Version: 0.87-pre1 Date: Thu Jun 12 00:48:38 EST 2008$
|
|
# ******************************************************
|
|
#
|
|
# * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
# ******************************************************
|
|
|
|
#pylint: disable-msg=C0111
|
|
|
|
""" Configuration modules for pyflag.
|
|
|
|
PyFlag is a complex package and requires a flexible configuration
|
|
system. The following are the requirements of the configuration
|
|
system:
|
|
|
|
1) Configuration must be available from a number of sources:
|
|
|
|
- Autoconf must be able to set things like the python path (in case
|
|
pyflag is installed to a different prefix)
|
|
|
|
- Users must be able to configure the installed system for their
|
|
specific requirements.
|
|
|
|
- Unconfigured parameters must be resolved at run time through the
|
|
GUI and saved.
|
|
|
|
2) Configuration must be able to apply to cases specifically.
|
|
|
|
3) Because pyflag is modular, configuration variables might be required
|
|
for each module. This means that definitions and declarations of
|
|
configuration variables must be distributed in each plugin.
|
|
|
|
These goals are achieved by the use of multiple sources of
|
|
configuration information:
|
|
|
|
- The system wide configuration file is this file: conf.py. It is
|
|
generated from the build system from conf.py.in by substituting
|
|
autoconfigured variables into it. It contains the most basic
|
|
settings related to the installation, e.g. which python interpreted
|
|
is used, where the python modules are installed etc. In particular
|
|
it refers to the location of the system configuration file (usually
|
|
found in /usr/local/etc/pyflagrc, or in /etc/pyflagrc).
|
|
|
|
- The sysconfig file contains things like where the upload
|
|
directory is, where to store temporary files etc. These are mainly
|
|
installation wide settings which are expected to be modified by the
|
|
administrator. Note that if you want the GUI to manipulate this
|
|
file it needs to be writable by the user running the GUI.
|
|
|
|
- Finally a conf table in each case is used to provide a per case
|
|
configuration
|
|
|
|
"""
|
|
import ConfigParser
|
|
import optparse
|
|
import os
|
|
import sys
|
|
|
|
default_config = "/etc/volatilityrc"
|
|
|
|
class PyFlagOptionParser(optparse.OptionParser):
|
|
final = False
|
|
help_hooks = []
|
|
|
|
def _process_args(self, largs, rargs, values):
|
|
try:
|
|
return optparse.OptionParser._process_args(self, largs, rargs, values)
|
|
except (optparse.BadOptionError, optparse.OptionValueError), err:
|
|
if self.final:
|
|
raise err
|
|
|
|
def error(self, msg):
|
|
## We cant emit errors about missing parameters until we are
|
|
## sure that all modules have registered all their parameters
|
|
if self.final:
|
|
return optparse.OptionParser.error(self, msg)
|
|
else:
|
|
raise RuntimeError(msg)
|
|
|
|
def print_help(self, file = sys.stdout):
|
|
optparse.OptionParser.print_help(self, file)
|
|
|
|
for cb in self.help_hooks:
|
|
file.write(cb())
|
|
|
|
class ConfObject(object):
|
|
""" This is a singleton class to manage the configuration.
|
|
|
|
This means it can be instantiated many times, but each instance
|
|
refers to the global configuration (which is set in class
|
|
variables).
|
|
|
|
NOTE: The class attributes have static dicts assigned to
|
|
facilitate singleton behaviour. This means all future instances
|
|
will have the same dicts.
|
|
"""
|
|
optparser = PyFlagOptionParser(add_help_option = False,
|
|
version = False,
|
|
)
|
|
initialised = False
|
|
|
|
## This is the globals dictionary which will be used for
|
|
## evaluating the configuration directives.
|
|
g_dict = dict(__builtins__ = None)
|
|
|
|
## These are the options derived by reading any config files
|
|
cnf_opts = {}
|
|
|
|
## Command line opts
|
|
opts = {}
|
|
args = None
|
|
default_opts = {}
|
|
docstrings = {}
|
|
|
|
## These are the actual options returned by the optparser:
|
|
optparse_opts = None
|
|
|
|
## Filename where the configuration file is:
|
|
_filename = None
|
|
|
|
_filenames = []
|
|
|
|
## These parameters can not be updated by the GUI (but will be
|
|
## propagated into new configuration files)
|
|
readonly = {}
|
|
|
|
## Absolute parameters can only be set by the code or command
|
|
## lines, they can not be over ridden in the configuration
|
|
## file. This ensures that only configuration files dont mask new
|
|
## options (e.g. schema version)
|
|
_absolute = {}
|
|
|
|
## A list of option names:
|
|
options = []
|
|
|
|
## Cache variants: There are configuration options which
|
|
## encapsulate the state of the running program. If any of these
|
|
## change all caches will be invalidated.
|
|
cache_invalidators = {}
|
|
|
|
def __init__(self):
|
|
""" This is a singleton object kept in the class """
|
|
if not ConfObject.initialised:
|
|
self.optparser.add_option("-h", "--help", action = "store_true", default = False,
|
|
help = "list all available options and their default values. Default values may be set in the configuration file (" + default_config + ")")
|
|
|
|
ConfObject.initialised = True
|
|
|
|
def set_usage(self, usage = None, version = None):
|
|
if usage:
|
|
self.optparser.set_usage(usage)
|
|
|
|
if version:
|
|
self.optparser.version = version
|
|
|
|
def add_file(self, filename, _type = 'init'):
|
|
""" Adds a new file to parse """
|
|
self._filenames.append(filename)
|
|
|
|
self.cnf_opts.clear()
|
|
|
|
for f in self._filenames:
|
|
try:
|
|
conf_parser = ConfigParser.ConfigParser()
|
|
conf_parser.read(f)
|
|
|
|
for k, v in conf_parser.items('DEFAULT'):
|
|
## Absolute parameters are protected from
|
|
## configuration files:
|
|
if k in self._absolute.keys():
|
|
continue
|
|
|
|
try:
|
|
v = eval(v, self.g_dict)
|
|
except Exception, _e:
|
|
pass
|
|
|
|
## update the configured options
|
|
self.cnf_opts[k] = v
|
|
|
|
except IOError:
|
|
print "Unable to open {0}".format(f)
|
|
|
|
ConfObject._filename = filename
|
|
|
|
def print_help(self):
|
|
return self.optparser.print_help()
|
|
|
|
def add_help_hook(self, cb):
|
|
""" Adds an epilog to the help message """
|
|
self.optparser.help_hooks.append(cb)
|
|
|
|
def set_help_hook(self, cb):
|
|
self.optparser.help_hooks = [cb]
|
|
|
|
def parse_options(self, final = True):
|
|
""" Parses the options from command line and any conf files
|
|
currently added.
|
|
|
|
The final parameter should be only called from main programs
|
|
at the point where they are prepared for us to call exit if
|
|
required; (For example when we detect the -h parameter).
|
|
"""
|
|
self.optparser.final = final
|
|
|
|
## Parse the command line options:
|
|
try:
|
|
(opts, args) = self.optparser.parse_args()
|
|
|
|
self.opts.clear()
|
|
|
|
## Update our cmdline dict:
|
|
for k in dir(opts):
|
|
v = getattr(opts, k)
|
|
if k in self.options and not v == None:
|
|
self.opts[k] = v
|
|
|
|
except UnboundLocalError:
|
|
raise RuntimeError("Unknown option - use -h to see help")
|
|
|
|
## If error() was called we catch it here
|
|
except RuntimeError:
|
|
opts = {}
|
|
## This gives us as much as was parsed so far
|
|
args = self.optparser.largs
|
|
|
|
self.optparse_opts = opts
|
|
self.args = args
|
|
|
|
if final:
|
|
## Reparse the config file again:
|
|
self.add_file(self._filename)
|
|
|
|
try:
|
|
## Help can only be set on the command line
|
|
if getattr(self.optparse_opts, "help"):
|
|
|
|
## Populate the metavars with the default values:
|
|
for opt in self.optparser.option_list:
|
|
try:
|
|
opt.metavar = "{0}".format((getattr(self, opt.dest) or
|
|
opt.dest.upper()))
|
|
except Exception, _e:
|
|
pass
|
|
|
|
self.optparser.print_help()
|
|
sys.exit(0)
|
|
except AttributeError:
|
|
pass
|
|
|
|
## Set the cache invalidators on the cache now:
|
|
import volatility.cache as cache
|
|
for k, v in self.cache_invalidators.items():
|
|
cache.CACHE.invalidate_on(k, v)
|
|
|
|
def remove_option(self, option):
|
|
""" Removes options both from the config file parser and the
|
|
command line parser
|
|
|
|
This should only by used on options *before* they have been read,
|
|
otherwise things could get very confusing.
|
|
"""
|
|
option = option.lower()
|
|
|
|
if option in self.cache_invalidators:
|
|
del self.cache_invalidators[option]
|
|
|
|
normalized_option = option.replace("-", "_")
|
|
|
|
if normalized_option not in self.options:
|
|
return
|
|
|
|
self.options.remove(normalized_option)
|
|
|
|
if normalized_option in self.readonly:
|
|
del self.readonly[normalized_option]
|
|
|
|
if normalized_option in self.default_opts:
|
|
del self.default_opts[normalized_option]
|
|
|
|
if normalized_option in self._absolute:
|
|
del self._absolute[normalized_option]
|
|
|
|
del self.docstrings[normalized_option]
|
|
|
|
self.optparser.remove_option("--{0}".format(option))
|
|
|
|
try:
|
|
self.parse_options(False)
|
|
except AttributeError:
|
|
pass
|
|
|
|
def add_option(self, option, short_option = None,
|
|
cache_invalidator = True,
|
|
**args):
|
|
""" Adds options both to the config file parser and the
|
|
command line parser.
|
|
|
|
Args:
|
|
option: The long option name.
|
|
short_option: An optional short option.
|
|
cache_invalidator: If set, when this option
|
|
changes all caches are invalidated.
|
|
"""
|
|
option = option.lower()
|
|
|
|
if cache_invalidator:
|
|
self.cache_invalidators[option] = lambda : self.get_value(option)
|
|
|
|
normalized_option = option.replace("-", "_")
|
|
|
|
if normalized_option in self.options:
|
|
return
|
|
|
|
self.options.append(normalized_option)
|
|
|
|
## If this is read only we store it in a special dict
|
|
try:
|
|
if args['readonly']:
|
|
self.readonly[normalized_option] = args['default']
|
|
del args['readonly']
|
|
except KeyError:
|
|
pass
|
|
|
|
## If there is a default specified, we update our defaults dict:
|
|
try:
|
|
default = args['default']
|
|
try:
|
|
default = eval(default, self.g_dict)
|
|
except:
|
|
pass
|
|
|
|
self.default_opts[normalized_option] = default
|
|
del args['default']
|
|
except KeyError:
|
|
pass
|
|
|
|
try:
|
|
self._absolute[normalized_option] = args['absolute']
|
|
del args['absolute']
|
|
except KeyError:
|
|
pass
|
|
|
|
self.docstrings[normalized_option] = args.get('help', None)
|
|
|
|
if short_option:
|
|
self.optparser.add_option("-{0}".format(short_option), "--{0}".format(option), **args)
|
|
else:
|
|
self.optparser.add_option("--{0}".format(option), **args)
|
|
|
|
## update the command line parser
|
|
|
|
## We have to do the try-catch for python 2.4 support of short
|
|
## arguments. It can be removed when python 2.5 is a requirement
|
|
try:
|
|
self.parse_options(False)
|
|
except AttributeError:
|
|
pass
|
|
|
|
def update(self, key, value):
|
|
""" This can be used by scripts to force a value of an option """
|
|
self.readonly[key.lower()] = value
|
|
|
|
def get_value(self, key):
|
|
return getattr(self, key.replace("-", "_"))
|
|
|
|
def __getattr__(self, attr):
|
|
## If someone is looking for a configuration parameter but
|
|
## we have not parsed anything yet - do so now.
|
|
if self.opts == None:
|
|
self.parse_options(False)
|
|
|
|
## Maybe its a class method?
|
|
try:
|
|
return super(ConfObject, self).__getattribute__(attr)
|
|
except AttributeError:
|
|
pass
|
|
|
|
## Is it a ready only parameter (i.e. can not be overridden by
|
|
## the config file)
|
|
try:
|
|
return self.readonly[attr.lower()]
|
|
except KeyError:
|
|
pass
|
|
|
|
## Try to find the attribute in the command line options:
|
|
try:
|
|
return self.opts[attr.lower()]
|
|
except KeyError:
|
|
pass
|
|
|
|
## Has it already been parsed?
|
|
try:
|
|
tmp = getattr(self.optparser.values, attr.lower())
|
|
if tmp:
|
|
return tmp
|
|
except AttributeError:
|
|
pass
|
|
|
|
## Was it given in the environment?
|
|
try:
|
|
return os.environ["VOLATILITY_" + attr.upper()]
|
|
except KeyError:
|
|
pass
|
|
|
|
## No - try the configuration file:
|
|
try:
|
|
return self.cnf_opts[attr.lower()]
|
|
except KeyError:
|
|
pass
|
|
|
|
## No - is there a default for it?
|
|
try:
|
|
return self.default_opts[attr.lower()]
|
|
except KeyError:
|
|
pass
|
|
|
|
## Maybe its just a command line option:
|
|
try:
|
|
if not attr.startswith("_") and self.optparse_opts:
|
|
return getattr(self.optparse_opts, attr.lower())
|
|
except AttributeError:
|
|
pass
|
|
|
|
raise AttributeError("Parameter {0} is not configured - try setting it on the command line (-h for help)".format(attr))
|
|
|
|
class DummyConfig(ConfObject):
|
|
pass
|
|
|
|
config = ConfObject()
|
|
if os.access(default_config, os.R_OK):
|
|
config.add_file(default_config)
|
|
else:
|
|
config.add_file("volatilityrc")
|
|
|
|
default_conf_path = ".volatilityrc"
|
|
try:
|
|
default_conf_path = os.environ['HOME'] + '/.volatilityrc'
|
|
except KeyError:
|
|
pass
|
|
|
|
config.add_option("CONF-FILE", default = default_conf_path,
|
|
cache_invalidator = False,
|
|
help = "User based configuration file")
|
|
|
|
config.add_file(config.CONF_FILE)
|