mirror of
https://github.com/volatilityfoundation/volatility3.git
synced 2026-09-22 09:34:52 +02:00
148 lines
4.6 KiB
Python
148 lines
4.6 KiB
Python
'''
|
|
Created on 12 Apr 2013
|
|
|
|
@author: mike
|
|
'''
|
|
|
|
import copy
|
|
|
|
class ObjectInterface(object):
|
|
""" A base object required to be the ancestor of every object used in volatility """
|
|
def __init__(self, context, layer_name, offset, symbol_name, size, **kwargs):
|
|
self._context = context
|
|
self._offset = offset
|
|
self._layer_name = layer_name
|
|
self._symbol_name = symbol_name
|
|
self._size = size
|
|
|
|
def cast(self, new_symbol_name):
|
|
object_template = self._context.resolve(new_symbol_name)
|
|
return object_template(context = self._context, layer_name = self._layer_name, offset = self._offset)
|
|
|
|
class ContextInterface(object):
|
|
"""Class for providing the interface for the Context object"""
|
|
|
|
def __init__(self):
|
|
"""Intializes the context with a symbol_space"""
|
|
|
|
### Symbol Space Functions
|
|
|
|
@property
|
|
def symbol_space(self):
|
|
"""Returns the symbol_space for the context"""
|
|
|
|
### Address Space Functions
|
|
|
|
def add_translation_layer(self, layer, name = None):
|
|
"""Adds a named translation layer to the context"""
|
|
|
|
### Object Factory Functions
|
|
|
|
def object(self, symbol, layer_name, offset):
|
|
"""Object factory, takes a context, symbol, offset and optional layername
|
|
|
|
Looks up the layername in the context, finds the object template based on the symbol,
|
|
and constructs an object using the object template on the layer at the offset.
|
|
|
|
Returns a fully constructed object
|
|
"""
|
|
|
|
class Template(object):
|
|
"""Class for all Factories that take offsets, and data layers and produce objects
|
|
|
|
This is effectively a class for currying object calls
|
|
"""
|
|
def __init__(self, symbol_name = None, **kwargs):
|
|
"""Stores the keyword arguments for later use"""
|
|
self._kwargs = kwargs
|
|
self._symbol_name = symbol_name
|
|
|
|
@property
|
|
def symbol_name(self):
|
|
"""Returns the name of the particular symbol"""
|
|
return self._symbol_name
|
|
|
|
@property
|
|
def arguments(self):
|
|
"""Returns the keyword arguments stored earlier"""
|
|
return copy.deepcopy(self._kwargs)
|
|
|
|
def update_arguments(self, **newargs):
|
|
"""Updates the keyword arguments"""
|
|
self._kwargs.update(newargs)
|
|
|
|
def __call__(self, context, layer_name, offset, parent = None):
|
|
"""Constructs the object
|
|
|
|
Returns: an object adhereing to the Object interface
|
|
"""
|
|
|
|
class SymbolTableInterface(object):
|
|
"""Handles a table of symbols"""
|
|
|
|
def __init__(self, name, native_symbols = None, *args, **kwargs):
|
|
super(SymbolTableInterface, self).__init__(*args, **kwargs)
|
|
if not isinstance(name, str) or not name:
|
|
raise TypeError("Symbol Table name must be a string")
|
|
if not isinstance(native_symbols, NativeTableInterface):
|
|
raise TypeError("Symbol Table native_symbols must be a NativeTable, not " + str(type(native_symbols)))
|
|
self.name = name
|
|
self._native_symbols = native_symbols
|
|
|
|
### Required Symbol List functions
|
|
|
|
def resolve(self, symbol):
|
|
"""Resolves a symbol name into an object template
|
|
|
|
If the symbol isn't found it raises a SymbolNotFound exception
|
|
"""
|
|
|
|
@property
|
|
def symbols(self):
|
|
"""Returns an iterator of the symbol names"""
|
|
|
|
### Native Type Handler
|
|
|
|
@property
|
|
def natives(self):
|
|
"""Returns None or a symbol_space for handling space specific native types"""
|
|
return self._native_symbols
|
|
|
|
### Functions for overriding classes
|
|
|
|
def set_symbol_class(self, symbol, clazz):
|
|
"""Overrides the object class for a specific symbol
|
|
|
|
Symbol *must* be present in self.symbols
|
|
"""
|
|
|
|
def get_symbol_class(self, symbol):
|
|
"""Returns the class associated with a symbol"""
|
|
|
|
def del_symbol_class(self, symbol):
|
|
"""Removes the associated class override for a specific symbol"""
|
|
|
|
### Helper functions that can be overridden
|
|
|
|
def __len__(self):
|
|
"""Returns the number of items in the symbol list"""
|
|
return len(self.symbols)
|
|
|
|
def __getitem__(self, key):
|
|
"""Resolves a symbol name into an object template
|
|
|
|
Note, this method cannot sub-resolve throughout a whole symbol space
|
|
"""
|
|
return self.resolve(key)
|
|
|
|
def __iter__(self):
|
|
"""Returns an iterator of the available keys"""
|
|
return self.symbols
|
|
|
|
def __contains__(self, symbol):
|
|
"""Determines whether a symbol exists in the list or not"""
|
|
return symbol in self.symbols
|
|
|
|
class NativeTableInterface(SymbolTableInterface):
|
|
"""Class to distinguish NativeSymbolLists from other symbol lists"""
|