volatility.framework.interfaces.automagic module

Defines the automagic interfaces for populating the context before a plugin runs.

Automagic objects attempt to automatically fill configuration values that a user has not filled.

class AutomagicInterface(context, config_path, *args, **kwargs)[source]

Bases: volatility.framework.interfaces.configuration.ConfigurableInterface

Class that defines an automagic component that can help fulfill Requirements

These classes are callable with the following parameters:

  • context (ContextInterface) – The context in which to store configuration data that the automagic might populate

  • config_path (str) – Configuration path where the configurable’s data under the context’s config lives

  • configurable – The top level configurable whose requirements may need statisfying

  • progress_callback – An optional function accepting a percentage and optional description to indicate progress during long calculations


The context provided here may be different to that provided during initialization. The context provided at initialization should be used for local configuration of the automagic itself, the context provided during the call is to be populated by the automagic.

Basic initializer that allows configurables to access their own config settings.


Constructs a HierarchicalDictionary of all the options required to build this component in the current context.

Ensures that if the class has been created, it can be recreated using the configuration built Inheriting classes must override this to ensure any dependent classes update their configurations too

Return type


property config

The Hierarchical configuration Dictionary for this Configurable object.

Return type


property config_path

The configuration path on which this configurable lives.

Return type


property context

The context object that this configurable belongs to/configuration is stored in.

Return type


find_requirements(context, config_path, requirement_root, requirement_type, shortcut=True)[source]

Determines if there is actually an unfulfilled Requirement waiting.

This ensures we do not carry out an expensive search when there is no need for a particular Requirement

Return type

List[Tuple[str, RequirementInterface]]


A list of tuples containing the config_path, sub_config_path and requirement identifying the unsatisfied Requirements

classmethod get_requirements()

Returns a list of RequirementInterface objects required by this object.

Return type


classmethod make_subconfig(context, base_config_path, **kwargs)

Convenience function to allow constructing a new randomly generated sub-configuration path, containing each element from kwargs.

  • context (ContextInterface) – The context in which to store the new configuration

  • base_config_path (str) – The base configuration path on which to build the new configuration

  • kwargs – Keyword arguments that are used to populate the new configuration path


The newly generated full configuration path

Return type


priority = 10

An ordering to indicate how soon this automagic should be run

classmethod unsatisfied(context, config_path)

Returns a list of the names of all unsatisfied requirements.

Since a satisfied set of requirements will return [], it can be used in tests as follows:

unmet = configurable.unsatisfied(context, config_path)
if unmet:
    raise RuntimeError("Unsatisfied requirements: {}".format(unmet)
Return type

Dict[str, RequirementInterface]

class StackerLayerInterface[source]

Bases: object

Class that takes a lower layer and attempts to build on it.

stack_order determines the order (from low to high) that stacking layers should be attempted lower levels should have lower stack_orders

classmethod stack(context, layer_name, progress_callback=None)[source]

Method to determine whether this builder can operate on the named layer. If so, modify the context appropriately.

Returns the name of any new layer stacked on top of this layer or None. The stacking is therefore strictly linear rather than tree driven.

Configuration options provided by the context are ignored, and defaults are to be used by this method to build a space where possible.

  • context (ContextInterface) – Context in which to construct the higher layer

  • layer_name (str) – Name of the layer to stack on top of

  • progress_callback (Optional[Callable[[float, str], None]]) – A callback function to indicate progress through a scan (if one is necessary)

Return type


stack_order = 0