app.objects namespace

Subpackages

Submodules

app.objects.c_ability module

class app.objects.c_ability.Ability(ability_id, tactic=None, technique_id=None, technique=None, name=None, test=None, description=None, cleanup=None, executor=None, platform=None, payloads=None, parsers=None, requirements=None, privilege=None, timeout=60, repeatable=False, buckets=None, access=None, variations=None, language=None, code=None, build_target=None, additional_info=None, tags=None, singleton=False, uploads=None, **kwargs)

Bases: app.objects.interfaces.i_object.FirstClassObjectInterface, app.utility.base_object.BaseObject

HOOKS = {}
RESERVED = {'payload': '#{payload}'}
async add_bucket(bucket)
display_schema = <AbilitySchema(many=False)>
property raw_command
replace_cleanup(encoded_cmd, payload)
schema = <AbilitySchema(many=False)>
store(ram)
property test
property unique
async which_plugin()
class app.objects.c_ability.AbilitySchema(*, only: Union[Sequence[str], Set[str]] = None, exclude: Union[Sequence[str], Set[str]] = (), many: bool = False, context: Dict = None, load_only: Union[Sequence[str], Set[str]] = (), dump_only: Union[Sequence[str], Set[str]] = (), partial: Union[bool, Sequence[str], Set[str]] = False, unknown: str = None)

Bases: marshmallow.schema.Schema

build_ability(data, **_)
opts = <marshmallow.schema.SchemaOpts object>
app.objects.c_ability.get_variations(data)

app.objects.c_adversary module

class app.objects.c_adversary.Adversary(adversary_id, name, description, atomic_ordering, objective=None, tags=None)

Bases: app.objects.interfaces.i_object.FirstClassObjectInterface, app.utility.base_object.BaseObject

check_repeatable_abilities(ability_list)
has_ability(ability)
schema = <AdversarySchema(many=False)>
store(ram)
property unique
async which_plugin()
class app.objects.c_adversary.AdversarySchema(*, only: Union[Sequence[str], Set[str]] = None, exclude: Union[Sequence[str], Set[str]] = (), many: bool = False, context: Dict = None, load_only: Union[Sequence[str], Set[str]] = (), dump_only: Union[Sequence[str], Set[str]] = (), partial: Union[bool, Sequence[str], Set[str]] = False, unknown: str = None)

Bases: marshmallow.schema.Schema

build_adversary(data, **_)
fix_id(adversary, **_)
opts = <marshmallow.schema.SchemaOpts object>
phase_to_atomic_ordering(adversary, **_)

Convert legacy adversary phases to atomic ordering

app.objects.c_agent module

class app.objects.c_agent.Agent(sleep_min, sleep_max, watchdog, platform='unknown', server='unknown', host='unknown', username='unknown', architecture='unknown', group='red', location='unknown', pid=0, ppid=0, trusted=True, executors=(), privilege='User', exe_name='unknown', contact='unknown', paw=None, proxy_receivers=None, proxy_chain=None, origin_link_id=0, deadman_enabled=False, available_contacts=None, host_ip_addrs=None, upstream_dest=None)

Bases: app.objects.interfaces.i_object.FirstClassObjectInterface, app.utility.base_object.BaseObject

RESERVED = {'agent_paw': '#{paw}', 'exe_name': '#{exe_name}', 'group': '#{group}', 'location': '#{location}', 'payload': re.compile('#{payload:(.*?)}', re.DOTALL), 'server': '#{server}', 'upstream_dest': '#{upstream_dest}'}
all_facts()
async bootstrap(data_svc)
async calculate_sleep()
async capabilities(ability_set)
async deadman(data_svc)
property display_name
async gui_modification(**kwargs)
async heartbeat_modification(**kwargs)
async kill()
load_schema = <AgentSchema(many=False)>
privileged_to_run(ability)
replace(encoded_cmd, file_svc)
schema = <AgentSchema(many=False)>
store(ram)
async task(abilities, obfuscator, facts=(), deadman=False)
property unique
class app.objects.c_agent.AgentFieldsSchema(*, only: Union[Sequence[str], Set[str]] = None, exclude: Union[Sequence[str], Set[str]] = (), many: bool = False, context: Dict = None, load_only: Union[Sequence[str], Set[str]] = (), dump_only: Union[Sequence[str], Set[str]] = (), partial: Union[bool, Sequence[str], Set[str]] = False, unknown: str = None)

Bases: marshmallow.schema.Schema

opts = <marshmallow.schema.SchemaOpts object>
remove_nulls(in_data, **_)
class app.objects.c_agent.AgentSchema(*, only: Union[Sequence[str], Set[str]] = None, exclude: Union[Sequence[str], Set[str]] = (), many: bool = False, context: Dict = None, load_only: Union[Sequence[str], Set[str]] = (), dump_only: Union[Sequence[str], Set[str]] = (), partial: Union[bool, Sequence[str], Set[str]] = False, unknown: str = None)

Bases: app.objects.c_agent.AgentFieldsSchema

build_agent(data, **_)
opts = <marshmallow.schema.SchemaOpts object>

app.objects.c_obfuscator module

class app.objects.c_obfuscator.Obfuscator(name, description, module)

Bases: app.objects.interfaces.i_object.FirstClassObjectInterface, app.utility.base_object.BaseObject

display_schema = <ObfuscatorSchema(many=False)>
load(agent)
schema = <ObfuscatorSchema(many=False)>
store(ram)
property unique
class app.objects.c_obfuscator.ObfuscatorSchema(*, only: Union[Sequence[str], Set[str]] = None, exclude: Union[Sequence[str], Set[str]] = (), many: bool = False, context: Dict = None, load_only: Union[Sequence[str], Set[str]] = (), dump_only: Union[Sequence[str], Set[str]] = (), partial: Union[bool, Sequence[str], Set[str]] = False, unknown: str = None)

Bases: marshmallow.schema.Schema

opts = <marshmallow.schema.SchemaOpts object>

app.objects.c_objective module

class app.objects.c_objective.Objective(id='', name='', description='', goals=None)

Bases: app.objects.interfaces.i_object.FirstClassObjectInterface, app.utility.base_object.BaseObject

completed(facts=None)
property percentage
schema = <ObjectiveSchema(many=False)>
store(ram)
property unique
class app.objects.c_objective.ObjectiveSchema(*, only: Union[Sequence[str], Set[str]] = None, exclude: Union[Sequence[str], Set[str]] = (), many: bool = False, context: Dict = None, load_only: Union[Sequence[str], Set[str]] = (), dump_only: Union[Sequence[str], Set[str]] = (), partial: Union[bool, Sequence[str], Set[str]] = False, unknown: str = None)

Bases: marshmallow.schema.Schema

build_objective(data, **_)
opts = <marshmallow.schema.SchemaOpts object>

app.objects.c_operation module

class app.objects.c_operation.Operation(name, agents, adversary, id='', jitter='2/8', source=None, planner=None, state='running', autonomous=True, obfuscator='plain-text', group=None, auto_close=True, visibility=50, access=None, timeout=30, use_learning_parsers=True)

Bases: app.objects.interfaces.i_object.FirstClassObjectInterface, app.utility.base_object.BaseObject

class Reason

Bases: enum.Enum

An enumeration.

EXECUTOR = 1
FACT_DEPENDENCY = 2
OP_RUNNING = 4
PLATFORM = 0
PRIVILEGE = 3
UNTRUSTED = 5
async active_agents()
all_facts()
all_relationships()
async apply(link)
async close(services)
async event_logs(file_svc, data_svc, output=False)
async get_active_agent_by_paw(paw)
async get_skipped_abilities_by_agent(data_svc)
has_fact(trait, value)
async is_closeable()
async is_finished()
ran_ability_id(ability_id)
async report(file_svc, data_svc, output=False, redacted=False)
async run(services)
schema = <OperationSchema(many=False)>
set_start_details()
property states
store(ram)
property unique
async update_operation(services)
async wait_for_completion()

Wait for started links to be completed :param link_ids: :return: None

async write_event_logs_to_disk(file_svc, data_svc, output=False)
class app.objects.c_operation.OperationSchema(*, only: Union[Sequence[str], Set[str]] = None, exclude: Union[Sequence[str], Set[str]] = (), many: bool = False, context: Dict = None, load_only: Union[Sequence[str], Set[str]] = (), dump_only: Union[Sequence[str], Set[str]] = (), partial: Union[bool, Sequence[str], Set[str]] = False, unknown: str = None)

Bases: marshmallow.schema.Schema

build_planner(data, **_)
opts = <marshmallow.schema.SchemaOpts object>

app.objects.c_planner module

class app.objects.c_planner.Planner(planner_id, name, module, params, stopping_conditions=None, description=None, ignore_enforcement_modules=(), allow_repeatable_abilities=False)

Bases: app.objects.interfaces.i_object.FirstClassObjectInterface, app.utility.base_object.BaseObject

display_schema = <PlannerSchema(many=False)>
schema = <PlannerSchema(many=False)>
store(ram)
property unique
async which_plugin()
class app.objects.c_planner.PlannerSchema(*, only: Union[Sequence[str], Set[str]] = None, exclude: Union[Sequence[str], Set[str]] = (), many: bool = False, context: Dict = None, load_only: Union[Sequence[str], Set[str]] = (), dump_only: Union[Sequence[str], Set[str]] = (), partial: Union[bool, Sequence[str], Set[str]] = False, unknown: str = None)

Bases: marshmallow.schema.Schema

build_planner(data, **_)
opts = <marshmallow.schema.SchemaOpts object>

app.objects.c_plugin module

class app.objects.c_plugin.Plugin(name='virtual', description=None, address=None, enabled=False, data_dir=None, access=None)

Bases: app.objects.interfaces.i_object.FirstClassObjectInterface, app.utility.base_object.BaseObject

async destroy(services)
display_schema = <PluginSchema(many=False)>
async enable(services)
async expand(services)
load_plugin()
schema = <PluginSchema(many=False)>
store(ram)
property unique
class app.objects.c_plugin.PluginSchema(*, only: Union[Sequence[str], Set[str]] = None, exclude: Union[Sequence[str], Set[str]] = (), many: bool = False, context: Dict = None, load_only: Union[Sequence[str], Set[str]] = (), dump_only: Union[Sequence[str], Set[str]] = (), partial: Union[bool, Sequence[str], Set[str]] = False, unknown: str = None)

Bases: marshmallow.schema.Schema

build_plugin(data, **_)
opts = <marshmallow.schema.SchemaOpts object>

app.objects.c_schedule module

class app.objects.c_schedule.Schedule(name, schedule, task)

Bases: app.objects.interfaces.i_object.FirstClassObjectInterface, app.utility.base_object.BaseObject

schema = <ScheduleSchema(many=False)>
store(ram)
property unique
class app.objects.c_schedule.ScheduleSchema(*, only: Union[Sequence[str], Set[str]] = None, exclude: Union[Sequence[str], Set[str]] = (), many: bool = False, context: Dict = None, load_only: Union[Sequence[str], Set[str]] = (), dump_only: Union[Sequence[str], Set[str]] = (), partial: Union[bool, Sequence[str], Set[str]] = False, unknown: str = None)

Bases: marshmallow.schema.Schema

opts = <marshmallow.schema.SchemaOpts object>

app.objects.c_source module

class app.objects.c_source.Adjustment(ability_id, trait, value, offset)

Bases: tuple

property ability_id

Alias for field number 0

property offset

Alias for field number 3

property trait

Alias for field number 1

property value

Alias for field number 2

class app.objects.c_source.AdjustmentSchema(*, only: Union[Sequence[str], Set[str]] = None, exclude: Union[Sequence[str], Set[str]] = (), many: bool = False, context: Dict = None, load_only: Union[Sequence[str], Set[str]] = (), dump_only: Union[Sequence[str], Set[str]] = (), partial: Union[bool, Sequence[str], Set[str]] = False, unknown: str = None)

Bases: marshmallow.schema.Schema

build_adjustment(data, **_)
opts = <marshmallow.schema.SchemaOpts object>
class app.objects.c_source.Source(id, name, facts, relationships=(), rules=(), adjustments=())

Bases: app.objects.interfaces.i_object.FirstClassObjectInterface, app.utility.base_object.BaseObject

display_schema = <SourceSchema(many=False)>
schema = <SourceSchema(many=False)>
store(ram)
property unique
class app.objects.c_source.SourceSchema(*, only: Union[Sequence[str], Set[str]] = None, exclude: Union[Sequence[str], Set[str]] = (), many: bool = False, context: Dict = None, load_only: Union[Sequence[str], Set[str]] = (), dump_only: Union[Sequence[str], Set[str]] = (), partial: Union[bool, Sequence[str], Set[str]] = False, unknown: str = None)

Bases: marshmallow.schema.Schema

build_source(data, **_)
fix_adjustments(in_data, **_)
opts = <marshmallow.schema.SchemaOpts object>