defense-core 0.1.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- agents/__init__.py +0 -0
- agents/evidence.py +0 -0
- agents/response.py +0 -0
- agents/triage.py +0 -0
- core/__init__.py +0 -0
- core/base_tier.py +12 -0
- core/bus.py +41 -0
- core/memory.py +34 -0
- core/orchestrator.py +106 -0
- core/tier10_resilience.py +27 -0
- core/tier11_attribution.py +25 -0
- core/tier12_ecosystem.py +19 -0
- core/tier13_knowledge.py +20 -0
- core/tier14_meta_defense.py +18 -0
- core/tier15_swarm.py +19 -0
- core/tier16_economic.py +12 -0
- core/tier17_legal.py +12 -0
- core/tier18_psychological.py +12 -0
- core/tier19_sync.py +12 -0
- core/tier20_singularity.py +12 -0
- core/tier3_heuristic.py +18 -0
- core/tier4_behavior.py +39 -0
- core/tier5_intel.py +21 -0
- core/tier6_predictive.py +33 -0
- core/tier7_deception.py +24 -0
- core/tier8_governance.py +26 -0
- core/tier9_strategic.py +25 -0
- core/tier_architectures.py +51 -0
- defense_core-0.1.0.dist-info/METADATA +85 -0
- defense_core-0.1.0.dist-info/RECORD +33 -0
- defense_core-0.1.0.dist-info/WHEEL +5 -0
- defense_core-0.1.0.dist-info/entry_points.txt +2 -0
- defense_core-0.1.0.dist-info/top_level.txt +2 -0
agents/__init__.py
ADDED
|
File without changes
|
agents/evidence.py
ADDED
|
File without changes
|
agents/response.py
ADDED
|
File without changes
|
agents/triage.py
ADDED
|
File without changes
|
core/__init__.py
ADDED
|
File without changes
|
core/base_tier.py
ADDED
|
@@ -0,0 +1,12 @@
|
|
|
1
|
+
from abc import ABC, abstractmethod
|
|
2
|
+
from typing import Any
|
|
3
|
+
|
|
4
|
+
class DefenseTier(ABC):
|
|
5
|
+
def __init__(self, name: str, priority: int, memory=None):
|
|
6
|
+
self.name = name
|
|
7
|
+
self.priority = priority
|
|
8
|
+
self.memory = memory
|
|
9
|
+
|
|
10
|
+
@abstractmethod
|
|
11
|
+
async def process(self, telemetry: Any) -> dict:
|
|
12
|
+
pass
|
core/bus.py
ADDED
|
@@ -0,0 +1,41 @@
|
|
|
1
|
+
import asyncio
|
|
2
|
+
import json
|
|
3
|
+
import uuid
|
|
4
|
+
from typing import Any
|
|
5
|
+
|
|
6
|
+
class EventBus:
|
|
7
|
+
"""Synchronous/Asynchronous Event Bus for inter-agent communication."""
|
|
8
|
+
def __init__(self):
|
|
9
|
+
self.subscribers = {}
|
|
10
|
+
|
|
11
|
+
def subscribe(self, event_type: str, callback: callable):
|
|
12
|
+
if event_type not in self.subscribers: self.subscribers[event_type] = []
|
|
13
|
+
self.subscribers[event_type].append(callback)
|
|
14
|
+
|
|
15
|
+
async def publish(self, event_type: str, data: Any):
|
|
16
|
+
for callback in self.subscribers.get(event_type, []):
|
|
17
|
+
await callback(data)
|
|
18
|
+
|
|
19
|
+
class Agent:
|
|
20
|
+
def __init__(self, name: str, bus: EventBus):
|
|
21
|
+
self.name = name
|
|
22
|
+
self.bus = bus
|
|
23
|
+
|
|
24
|
+
async def act(self, data: Any):
|
|
25
|
+
raise NotImplementedError
|
|
26
|
+
|
|
27
|
+
class TriageAgent(Agent):
|
|
28
|
+
async def act(self, data: Any):
|
|
29
|
+
# Triage Logic: Analyze severity from stream
|
|
30
|
+
if data.get("score", 0) > 80:
|
|
31
|
+
await self.bus.publish("incident", {"id": str(uuid.uuid4()), "data": data})
|
|
32
|
+
|
|
33
|
+
# Orchestrator
|
|
34
|
+
async def main():
|
|
35
|
+
bus = EventBus()
|
|
36
|
+
triage = TriageAgent("Triage-01", bus)
|
|
37
|
+
bus.subscribe("alert", triage.act)
|
|
38
|
+
await bus.publish("alert", {"score": 95, "src": "192.168.1.1"})
|
|
39
|
+
|
|
40
|
+
if __name__ == "__main__":
|
|
41
|
+
asyncio.run(main())
|
core/memory.py
ADDED
|
@@ -0,0 +1,34 @@
|
|
|
1
|
+
import json
|
|
2
|
+
import os
|
|
3
|
+
import time
|
|
4
|
+
|
|
5
|
+
class RollingMemory:
|
|
6
|
+
def __init__(self, path="memory_ledger.json"):
|
|
7
|
+
self.path = path
|
|
8
|
+
self.ledger = self._load()
|
|
9
|
+
|
|
10
|
+
def _load(self):
|
|
11
|
+
if os.path.exists(self.path):
|
|
12
|
+
try:
|
|
13
|
+
with open(self.path, "r") as f:
|
|
14
|
+
return json.load(f)
|
|
15
|
+
except:
|
|
16
|
+
return []
|
|
17
|
+
return []
|
|
18
|
+
|
|
19
|
+
def add_action(self, tier, action, rationale, telemetry):
|
|
20
|
+
entry = {
|
|
21
|
+
"timestamp": time.time(),
|
|
22
|
+
"tier": tier,
|
|
23
|
+
"action": action,
|
|
24
|
+
"rationale": rationale,
|
|
25
|
+
"telemetry": telemetry
|
|
26
|
+
}
|
|
27
|
+
self.ledger.append(entry)
|
|
28
|
+
# Keep last 100 entries (Rolling)
|
|
29
|
+
self.ledger = self.ledger[-100:]
|
|
30
|
+
with open(self.path, "w") as f:
|
|
31
|
+
json.dump(self.ledger, f, indent=2)
|
|
32
|
+
|
|
33
|
+
def get_context(self):
|
|
34
|
+
return self.ledger
|
core/orchestrator.py
ADDED
|
@@ -0,0 +1,106 @@
|
|
|
1
|
+
import asyncio
|
|
2
|
+
import json
|
|
3
|
+
import uuid
|
|
4
|
+
import time
|
|
5
|
+
import argparse
|
|
6
|
+
from typing import Any, List
|
|
7
|
+
from .base_tier import DefenseTier
|
|
8
|
+
from .memory import RollingMemory
|
|
9
|
+
from .tier_architectures import Tier1Responder, Tier2Reasoner
|
|
10
|
+
from .tier3_heuristic import Tier3Heuristic
|
|
11
|
+
from .tier4_behavior import Tier4Behavior
|
|
12
|
+
from .tier5_intel import Tier5ThreatIntel
|
|
13
|
+
from .tier6_predictive import Tier6Predictive
|
|
14
|
+
from .tier7_deception import Tier7Deception
|
|
15
|
+
from .tier8_governance import Tier8Governance
|
|
16
|
+
from .tier9_strategic import Tier9Strategic
|
|
17
|
+
from .tier10_resilience import Tier10Resilience
|
|
18
|
+
from .tier11_attribution import Tier11Attribution
|
|
19
|
+
from .tier12_ecosystem import Tier12Ecosystem
|
|
20
|
+
from .tier13_knowledge import Tier13Knowledge
|
|
21
|
+
from .tier14_meta_defense import Tier14MetaDefense
|
|
22
|
+
from .tier15_swarm import Tier15Swarm
|
|
23
|
+
from .tier16_economic import Tier16Economic
|
|
24
|
+
from .tier17_legal import Tier17Legal
|
|
25
|
+
from .tier18_psychological import Tier18Psychological
|
|
26
|
+
from .tier19_sync import Tier19Sync
|
|
27
|
+
from .tier20_singularity import Tier20Singularity
|
|
28
|
+
|
|
29
|
+
class SOCEngine:
|
|
30
|
+
def __init__(self):
|
|
31
|
+
self.memory = RollingMemory()
|
|
32
|
+
self.tiers: List[DefenseTier] = []
|
|
33
|
+
self._setup_default_tiers()
|
|
34
|
+
|
|
35
|
+
def _setup_default_tiers(self):
|
|
36
|
+
# Registering Tier 1 - 20
|
|
37
|
+
self.register_tier(Tier1Responder(memory=self.memory))
|
|
38
|
+
self.register_tier(Tier2Reasoner(memory=self.memory))
|
|
39
|
+
self.register_tier(Tier3Heuristic(memory=self.memory))
|
|
40
|
+
self.register_tier(Tier4Behavior(memory=self.memory))
|
|
41
|
+
self.register_tier(Tier5ThreatIntel(memory=self.memory))
|
|
42
|
+
self.register_tier(Tier6Predictive(memory=self.memory))
|
|
43
|
+
self.register_tier(Tier7Deception(memory=self.memory))
|
|
44
|
+
self.register_tier(Tier8Governance(memory=self.memory))
|
|
45
|
+
self.register_tier(Tier9Strategic(memory=self.memory))
|
|
46
|
+
self.register_tier(Tier10Resilience(memory=self.memory))
|
|
47
|
+
self.register_tier(Tier11Attribution(memory=self.memory))
|
|
48
|
+
self.register_tier(Tier12Ecosystem(memory=self.memory))
|
|
49
|
+
self.register_tier(Tier13Knowledge(memory=self.memory))
|
|
50
|
+
self.register_tier(Tier14MetaDefense(memory=self.memory))
|
|
51
|
+
self.register_tier(Tier15Swarm(memory=self.memory))
|
|
52
|
+
self.register_tier(Tier16Economic(memory=self.memory))
|
|
53
|
+
self.register_tier(Tier17Legal(memory=self.memory))
|
|
54
|
+
self.register_tier(Tier18Psychological(memory=self.memory))
|
|
55
|
+
self.register_tier(Tier19Sync(memory=self.memory))
|
|
56
|
+
self.register_tier(Tier20Singularity(memory=self.memory))
|
|
57
|
+
|
|
58
|
+
def register_tier(self, tier: DefenseTier):
|
|
59
|
+
self.tiers.append(tier)
|
|
60
|
+
self.tiers.sort(key=lambda t: t.priority)
|
|
61
|
+
|
|
62
|
+
async def run_cycle(self, telemetry: dict):
|
|
63
|
+
print(f"--- Cycle Start: {telemetry.get('src')} ---")
|
|
64
|
+
|
|
65
|
+
# Tier 1: Deterministic Responder (Sync-like Fast Path)
|
|
66
|
+
# We find it by priority
|
|
67
|
+
tier1 = next(t for t in self.tiers if t.priority == 1)
|
|
68
|
+
t1_res = await tier1.process(telemetry)
|
|
69
|
+
print(f"[Tier 1] Final Decision: {t1_res}")
|
|
70
|
+
|
|
71
|
+
if t1_res.get("action") == "INSTANT_BLOCK":
|
|
72
|
+
print("!!! FAST PATH CONTAINMENT EXECUTED !!!")
|
|
73
|
+
|
|
74
|
+
# Tier 2-20: Async/Background Reasoning
|
|
75
|
+
# In BlueSTAR, Tier 2+ runs concurrently
|
|
76
|
+
async_tiers = [t for t in self.tiers if t.priority > 1]
|
|
77
|
+
results = await asyncio.gather(*(t.process(telemetry) for t in async_tiers))
|
|
78
|
+
|
|
79
|
+
for i, res in enumerate(results):
|
|
80
|
+
print(f"[Tier {async_tiers[i].priority}] Result: {res}")
|
|
81
|
+
|
|
82
|
+
print(f"--- Cycle Complete ---")
|
|
83
|
+
|
|
84
|
+
async def _main_async():
|
|
85
|
+
parser = argparse.ArgumentParser(description="Defense Core - Agentic SOC Engine")
|
|
86
|
+
parser.add_argument("--src", default="192.168.1.50", help="Source IP/Host")
|
|
87
|
+
parser.add_argument("--score", type=int, default=95, help="Threat score (0-100)")
|
|
88
|
+
parser.add_argument("--category", default="identity", help="Threat category")
|
|
89
|
+
parser.add_argument("--user", default="admin_agus", help="User/Entity")
|
|
90
|
+
args = parser.parse_args()
|
|
91
|
+
|
|
92
|
+
engine = SOCEngine()
|
|
93
|
+
telemetry = {
|
|
94
|
+
"src": args.src,
|
|
95
|
+
"score": args.score,
|
|
96
|
+
"category": args.category,
|
|
97
|
+
"user": args.user
|
|
98
|
+
}
|
|
99
|
+
await engine.run_cycle(telemetry)
|
|
100
|
+
|
|
101
|
+
def main():
|
|
102
|
+
"""Synchronous entry point for console script."""
|
|
103
|
+
asyncio.run(_main_async())
|
|
104
|
+
|
|
105
|
+
if __name__ == "__main__":
|
|
106
|
+
main()
|
|
@@ -0,0 +1,27 @@
|
|
|
1
|
+
import asyncio
|
|
2
|
+
from .base_tier import DefenseTier
|
|
3
|
+
from typing import Any
|
|
4
|
+
|
|
5
|
+
class Tier10Resilience(DefenseTier):
|
|
6
|
+
"""Tier 10: Autonomous Self-Healing (Resilience & Recovery)."""
|
|
7
|
+
def __init__(self, memory=None):
|
|
8
|
+
super().__init__(name="Tier 10: Self-Healing Resilience", priority=10, memory=memory)
|
|
9
|
+
|
|
10
|
+
async def process(self, telemetry: Any) -> dict:
|
|
11
|
+
# Check if the asset was recently "impacted" or "isolated"
|
|
12
|
+
target = telemetry.get('src', 'unknown')
|
|
13
|
+
history = self.memory.get_context() if self.memory else []
|
|
14
|
+
|
|
15
|
+
# Check for recovery triggers
|
|
16
|
+
impacted = any(h['action'] == "INSTANT_BLOCK" and h['telemetry']['src'] == target for h in history[-10:])
|
|
17
|
+
|
|
18
|
+
if impacted:
|
|
19
|
+
print(f"[{self.name}] Initiating autonomous recovery for {target}...")
|
|
20
|
+
await asyncio.sleep(0.5)
|
|
21
|
+
return {
|
|
22
|
+
"action": "RECOVER_CONFIG",
|
|
23
|
+
"method": "SNAPSHOT_ROLLBACK",
|
|
24
|
+
"status": "restoring_to_last_known_good_state"
|
|
25
|
+
}
|
|
26
|
+
|
|
27
|
+
return {"action": "HEALTH_CHECK", "status": "system_stable"}
|
|
@@ -0,0 +1,25 @@
|
|
|
1
|
+
import asyncio
|
|
2
|
+
from .base_tier import DefenseTier
|
|
3
|
+
from typing import Any
|
|
4
|
+
|
|
5
|
+
class Tier11Attribution(DefenseTier):
|
|
6
|
+
"""Tier 11: Adversary Attribution & Profiling."""
|
|
7
|
+
def __init__(self, memory=None):
|
|
8
|
+
super().__init__(name="Tier 11: Adversary Attribution", priority=11, memory=memory)
|
|
9
|
+
self.actor_profiles = {
|
|
10
|
+
"APT29": {"tactics": ["identity_theft", "stealth"], "severity": "CRITICAL"},
|
|
11
|
+
"ScripKiddie": {"tactics": ["brute_force", "noisy"], "severity": "LOW"}
|
|
12
|
+
}
|
|
13
|
+
|
|
14
|
+
async def process(self, telemetry: Any) -> dict:
|
|
15
|
+
category = telemetry.get('category', 'unknown')
|
|
16
|
+
score = telemetry.get('score', 0)
|
|
17
|
+
|
|
18
|
+
print(f"[{self.name}] Attributing adversary tactics...")
|
|
19
|
+
await asyncio.sleep(0.3)
|
|
20
|
+
|
|
21
|
+
# Attribution logic based on "noise" and category
|
|
22
|
+
if category == "identity" and score > 80:
|
|
23
|
+
return {"action": "IDENTIFY_ACTOR", "actor": "APT29", "confidence": 0.72}
|
|
24
|
+
|
|
25
|
+
return {"action": "IDENTIFY_ACTOR", "actor": "Unknown/Opportunistic", "confidence": 0.45}
|
core/tier12_ecosystem.py
ADDED
|
@@ -0,0 +1,19 @@
|
|
|
1
|
+
import asyncio
|
|
2
|
+
from .base_tier import DefenseTier
|
|
3
|
+
from typing import Any
|
|
4
|
+
|
|
5
|
+
class Tier12Ecosystem(DefenseTier):
|
|
6
|
+
"""Tier 12: Cross-Ecosystem Orchestration (Cloud/SaaS/Network/Host)."""
|
|
7
|
+
def __init__(self, memory=None):
|
|
8
|
+
super().__init__(name="Tier 12: Ecosystem Orchestrator", priority=12, memory=memory)
|
|
9
|
+
|
|
10
|
+
async def process(self, telemetry: Any) -> dict:
|
|
11
|
+
print(f"[{self.name}] Coordinating response across Cloud and Local infrastructure...")
|
|
12
|
+
await asyncio.sleep(0.4)
|
|
13
|
+
|
|
14
|
+
# Mock cross-check: If blocked locally, also check Cloud Identity providers
|
|
15
|
+
return {
|
|
16
|
+
"action": "SYNC_ECOSYSTEM",
|
|
17
|
+
"targets": ["AzureAD_ConditionalAccess", "CrowdStrike_RTR"],
|
|
18
|
+
"status": "coordinated_propagation_initiated"
|
|
19
|
+
}
|
core/tier13_knowledge.py
ADDED
|
@@ -0,0 +1,20 @@
|
|
|
1
|
+
import asyncio
|
|
2
|
+
from .base_tier import DefenseTier
|
|
3
|
+
from typing import Any
|
|
4
|
+
|
|
5
|
+
class Tier13Knowledge(DefenseTier):
|
|
6
|
+
"""Tier 13: Dynamic Knowledge Ingestion (Live CVE/Advisory Parsing)."""
|
|
7
|
+
def __init__(self, memory=None):
|
|
8
|
+
super().__init__(name="Tier 13: Knowledge Ingestion", priority=13, memory=memory)
|
|
9
|
+
|
|
10
|
+
async def process(self, telemetry: Any) -> dict:
|
|
11
|
+
print(f"[{self.name}] Ingesting latest security advisories for telemetry context...")
|
|
12
|
+
await asyncio.sleep(0.5)
|
|
13
|
+
|
|
14
|
+
# Simulate checking a new CVE relevant to the telemetry
|
|
15
|
+
return {
|
|
16
|
+
"action": "KNOWLEDGE_ENRICH",
|
|
17
|
+
"relevant_cve": "no_cve_matched",
|
|
18
|
+
"mitigation_delta": "Patching recommended for specific library",
|
|
19
|
+
"status": "advisory_mapped"
|
|
20
|
+
}
|
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
import asyncio
|
|
2
|
+
from .base_tier import DefenseTier
|
|
3
|
+
from typing import Any
|
|
4
|
+
|
|
5
|
+
class Tier14MetaDefense(DefenseTier):
|
|
6
|
+
"""Tier 14: Meta-Defense (Monitoring the SOC for subversion)."""
|
|
7
|
+
def __init__(self, memory=None):
|
|
8
|
+
super().__init__(name="Tier 14: Meta-Defense Monitor", priority=14, memory=memory)
|
|
9
|
+
|
|
10
|
+
async def process(self, telemetry: Any) -> dict:
|
|
11
|
+
print(f"[{self.name}] Auditing internal SOC pipeline for bypass attempts...")
|
|
12
|
+
await asyncio.sleep(0.3)
|
|
13
|
+
|
|
14
|
+
# Check if telemetry source is trying to spoof SOC messages
|
|
15
|
+
if telemetry.get('src') == 'SOC_INTERNAL':
|
|
16
|
+
return {"action": "SOC_ALERT", "reason": "Self-spoofing attempt detected in internal bus"}
|
|
17
|
+
|
|
18
|
+
return {"action": "HEALTHY", "status": "pipeline_integrity_verified"}
|
core/tier15_swarm.py
ADDED
|
@@ -0,0 +1,19 @@
|
|
|
1
|
+
import asyncio
|
|
2
|
+
from .base_tier import DefenseTier
|
|
3
|
+
from typing import Any
|
|
4
|
+
|
|
5
|
+
class Tier15Swarm(DefenseTier):
|
|
6
|
+
"""Tier 15: Cooperative Swarm (Federated Defense)."""
|
|
7
|
+
def __init__(self, memory=None):
|
|
8
|
+
super().__init__(name="Tier 15: Federated Swarm", priority=15, memory=memory)
|
|
9
|
+
|
|
10
|
+
async def process(self, telemetry: Any) -> dict:
|
|
11
|
+
print(f"[{self.name}] Sharing anonymous threat signal with Federated Swarm nodes...")
|
|
12
|
+
await asyncio.sleep(0.4)
|
|
13
|
+
|
|
14
|
+
return {
|
|
15
|
+
"action": "SWARM_BROADCAST",
|
|
16
|
+
"federated_nodes": 0,
|
|
17
|
+
"threat_signature": "sha256:unavailable",
|
|
18
|
+
"status": "global_consensus_requested"
|
|
19
|
+
}
|
core/tier16_economic.py
ADDED
|
@@ -0,0 +1,12 @@
|
|
|
1
|
+
import asyncio
|
|
2
|
+
from .base_tier import DefenseTier
|
|
3
|
+
|
|
4
|
+
class Tier16Economic(DefenseTier):
|
|
5
|
+
"""Tier 16: Economic Defense (FinOps Security)."""
|
|
6
|
+
def __init__(self, memory=None):
|
|
7
|
+
super().__init__(name="Tier 16: Economic Defense", priority=16, memory=memory)
|
|
8
|
+
|
|
9
|
+
async def process(self, telemetry: dict) -> dict:
|
|
10
|
+
print(f"[{self.name}] Calculating ROI of defensive actions...")
|
|
11
|
+
await asyncio.sleep(0.1)
|
|
12
|
+
return {"action": "COST_AUDIT", "status": "economic_viable"}
|
core/tier17_legal.py
ADDED
|
@@ -0,0 +1,12 @@
|
|
|
1
|
+
import asyncio
|
|
2
|
+
from .base_tier import DefenseTier
|
|
3
|
+
|
|
4
|
+
class Tier17Legal(DefenseTier):
|
|
5
|
+
"""Tier 17: Legal Compliance (Privacy/PDP)."""
|
|
6
|
+
def __init__(self, memory=None):
|
|
7
|
+
super().__init__(name="Tier 17: Legal Compliance", priority=17, memory=memory)
|
|
8
|
+
|
|
9
|
+
async def process(self, telemetry: dict) -> dict:
|
|
10
|
+
print(f"[{self.name}] Verifying legal guardrails...")
|
|
11
|
+
await asyncio.sleep(0.1)
|
|
12
|
+
return {"action": "LEGAL_CHECK", "status": "authorized"}
|
|
@@ -0,0 +1,12 @@
|
|
|
1
|
+
import asyncio
|
|
2
|
+
from .base_tier import DefenseTier
|
|
3
|
+
|
|
4
|
+
class Tier18Psychological(DefenseTier):
|
|
5
|
+
"""Tier 18: Psychological Warfare (Adversary Frustration)."""
|
|
6
|
+
def __init__(self, memory=None):
|
|
7
|
+
super().__init__(name="Tier 18: Psychological Warfare", priority=18, memory=memory)
|
|
8
|
+
|
|
9
|
+
async def process(self, telemetry: dict) -> dict:
|
|
10
|
+
print(f"[{self.name}] Initiating adversary frustration protocols...")
|
|
11
|
+
await asyncio.sleep(0.1)
|
|
12
|
+
return {"action": "INJECT_LATENCY", "status": "frustration_active"}
|
core/tier19_sync.py
ADDED
|
@@ -0,0 +1,12 @@
|
|
|
1
|
+
import asyncio
|
|
2
|
+
from .base_tier import DefenseTier
|
|
3
|
+
|
|
4
|
+
class Tier19Sync(DefenseTier):
|
|
5
|
+
"""Tier 19: Cross-Agent Sync (Federated AI)."""
|
|
6
|
+
def __init__(self, memory=None):
|
|
7
|
+
super().__init__(name="Tier 19: Cross-Agent Sync", priority=19, memory=memory)
|
|
8
|
+
|
|
9
|
+
async def process(self, telemetry: dict) -> dict:
|
|
10
|
+
print(f"[{self.name}] Synchronizing with external AI Guardians...")
|
|
11
|
+
await asyncio.sleep(0.1)
|
|
12
|
+
return {"action": "SYNC_EXTERNAL", "status": "global_state_locked"}
|
|
@@ -0,0 +1,12 @@
|
|
|
1
|
+
import asyncio
|
|
2
|
+
from .base_tier import DefenseTier
|
|
3
|
+
|
|
4
|
+
class Tier20Singularity(DefenseTier):
|
|
5
|
+
"""Tier 20: Singularity Defense (Autonomous Self-Optimization)."""
|
|
6
|
+
def __init__(self, memory=None):
|
|
7
|
+
super().__init__(name="Tier 20: Singularity Defense", priority=20, memory=memory)
|
|
8
|
+
|
|
9
|
+
async def process(self, telemetry: dict) -> dict:
|
|
10
|
+
print(f"[{self.name}] Optimizing priority weights for Tier 1-19...")
|
|
11
|
+
await asyncio.sleep(0.1)
|
|
12
|
+
return {"action": "SELF_OPTIMIZE", "status": "singularity_reached"}
|
core/tier3_heuristic.py
ADDED
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
from .base_tier import DefenseTier
|
|
2
|
+
from typing import Any
|
|
3
|
+
|
|
4
|
+
class Tier3Heuristic(DefenseTier):
|
|
5
|
+
"""Tier 3: Entity-Anchored Correlation (User/Identity focus)."""
|
|
6
|
+
def __init__(self, memory=None):
|
|
7
|
+
super().__init__(name="Tier 3: Heuristic Correlation", priority=3, memory=memory)
|
|
8
|
+
|
|
9
|
+
async def process(self, telemetry: Any) -> dict:
|
|
10
|
+
user = telemetry.get("user", "unknown")
|
|
11
|
+
src = telemetry.get("src", "unknown")
|
|
12
|
+
|
|
13
|
+
# Correlate user across multiple sources (mock)
|
|
14
|
+
print(f"[{self.name}] Anchoring correlation for entity: {user} ({src})")
|
|
15
|
+
|
|
16
|
+
if user != "unknown":
|
|
17
|
+
return {"action": "CORRELATED", "status": "entity_linked_to_identity"}
|
|
18
|
+
return {"action": "OBSERVE", "status": "unanchored_telemetry"}
|
core/tier4_behavior.py
ADDED
|
@@ -0,0 +1,39 @@
|
|
|
1
|
+
import json
|
|
2
|
+
import time
|
|
3
|
+
from .base_tier import DefenseTier
|
|
4
|
+
from typing import Any
|
|
5
|
+
|
|
6
|
+
class Tier4Behavior(DefenseTier):
|
|
7
|
+
"""Tier 4: Dynamic Risk Scoring & Baseline Drift."""
|
|
8
|
+
def __init__(self, memory=None):
|
|
9
|
+
super().__init__(name="Tier 4: Behavioral Profiling", priority=4, memory=memory)
|
|
10
|
+
self.history_file = "/data/workspace/defense-core/behavior_history.json"
|
|
11
|
+
|
|
12
|
+
async def process(self, telemetry: Any) -> dict:
|
|
13
|
+
src = telemetry.get('src', 'unknown')
|
|
14
|
+
|
|
15
|
+
# Load Baseline
|
|
16
|
+
try:
|
|
17
|
+
with open(self.history_file, "r") as f:
|
|
18
|
+
history = json.load(f)
|
|
19
|
+
except:
|
|
20
|
+
history = {}
|
|
21
|
+
|
|
22
|
+
stats = history.get(src, {"hits": 0, "last_seen": 0, "risk_score": 0})
|
|
23
|
+
|
|
24
|
+
# Baseline Drift Logic
|
|
25
|
+
stats["hits"] += 1
|
|
26
|
+
stats["last_seen"] = time.time()
|
|
27
|
+
|
|
28
|
+
# Dynamic Risk Scoring: Risk = hits * baseline_multiplier
|
|
29
|
+
severity = telemetry.get("score", 10)
|
|
30
|
+
stats["risk_score"] = (stats["hits"] * severity) / 100
|
|
31
|
+
|
|
32
|
+
history[src] = stats
|
|
33
|
+
with open(self.history_file, "w") as f:
|
|
34
|
+
json.dump(history, f)
|
|
35
|
+
|
|
36
|
+
if stats["risk_score"] > 5.0:
|
|
37
|
+
return {"action": "BLOCK_DRIFT", "risk": stats["risk_score"], "reason": "Significant baseline drift detected"}
|
|
38
|
+
|
|
39
|
+
return {"action": "PASS", "risk": stats["risk_score"], "status": "within_baseline"}
|
core/tier5_intel.py
ADDED
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
import asyncio
|
|
2
|
+
from .base_tier import DefenseTier
|
|
3
|
+
from typing import Any
|
|
4
|
+
|
|
5
|
+
class Tier5ThreatIntel(DefenseTier):
|
|
6
|
+
"""Tier 5: Active Enrichment Layer (Dynamic Risk Adjuster)."""
|
|
7
|
+
def __init__(self, memory=None):
|
|
8
|
+
super().__init__(name="Tier 5: Threat Intelligence", priority=5, memory=memory)
|
|
9
|
+
|
|
10
|
+
async def process(self, telemetry: Any) -> dict:
|
|
11
|
+
indicator = telemetry.get('src')
|
|
12
|
+
print(f"[{self.name}] Actively enriching risk for {indicator}...")
|
|
13
|
+
|
|
14
|
+
await asyncio.sleep(0.2)
|
|
15
|
+
|
|
16
|
+
# Mock enrichment result
|
|
17
|
+
if indicator == "1.2.3.4":
|
|
18
|
+
telemetry["threat_intel_score"] = 90
|
|
19
|
+
return {"action": "ENRICH_RISK", "score_adj": +40}
|
|
20
|
+
|
|
21
|
+
return {"action": "INTEL_CHECKED", "status": "no_active_threat_hit"}
|
core/tier6_predictive.py
ADDED
|
@@ -0,0 +1,33 @@
|
|
|
1
|
+
import asyncio
|
|
2
|
+
from .base_tier import DefenseTier
|
|
3
|
+
from typing import Any
|
|
4
|
+
|
|
5
|
+
class Tier6Predictive(DefenseTier):
|
|
6
|
+
"""Tier 6: Probabilistic Attack Path Mapping (Forecasting)."""
|
|
7
|
+
def __init__(self, memory=None):
|
|
8
|
+
super().__init__(name="Tier 6: Predictive Analytics", priority=6, memory=memory)
|
|
9
|
+
# Simplified MITRE ATT&CK Chaining
|
|
10
|
+
self.attack_chains = {
|
|
11
|
+
"identity": ["lateral_movement", "data_exfiltration"],
|
|
12
|
+
"network": ["scanning", "exploit", "c2_beacon"],
|
|
13
|
+
"ot": ["process_tampering", "safety_shutdown"]
|
|
14
|
+
}
|
|
15
|
+
|
|
16
|
+
async def process(self, telemetry: Any) -> dict:
|
|
17
|
+
category = telemetry.get('category', 'unknown')
|
|
18
|
+
history = self.memory.get_context() if self.memory else []
|
|
19
|
+
|
|
20
|
+
# Simple Markov-like prediction based on history
|
|
21
|
+
recent_actions = [h['telemetry'].get('category') for h in history[-5:]]
|
|
22
|
+
|
|
23
|
+
prediction = self.attack_chains.get(category, ["unknown_escalation"])
|
|
24
|
+
|
|
25
|
+
print(f"[{self.name}] Analyzing attack path for {category}...")
|
|
26
|
+
await asyncio.sleep(0.3)
|
|
27
|
+
|
|
28
|
+
return {
|
|
29
|
+
"action": "FORECAST",
|
|
30
|
+
"predicted_next_step": prediction[0] if prediction else "unknown",
|
|
31
|
+
"confidence": 0.85,
|
|
32
|
+
"status": "path_mapping_complete"
|
|
33
|
+
}
|
core/tier7_deception.py
ADDED
|
@@ -0,0 +1,24 @@
|
|
|
1
|
+
import asyncio
|
|
2
|
+
from .base_tier import DefenseTier
|
|
3
|
+
from typing import Any
|
|
4
|
+
|
|
5
|
+
class Tier7Deception(DefenseTier):
|
|
6
|
+
"""Tier 7: Active Deception (Honeypot & Decoy Deployment)."""
|
|
7
|
+
def __init__(self, memory=None):
|
|
8
|
+
super().__init__(name="Tier 7: Automated Deception", priority=7, memory=memory)
|
|
9
|
+
|
|
10
|
+
async def process(self, telemetry: Any) -> dict:
|
|
11
|
+
src = telemetry.get('src', 'unknown')
|
|
12
|
+
score = telemetry.get('score', 0)
|
|
13
|
+
|
|
14
|
+
# Deception Trigger: High suspicion, but not conclusive for Tier 1 block
|
|
15
|
+
if 70 <= score < 90:
|
|
16
|
+
print(f"[{self.name}] Deploying Honey-Token for suspicious entity: {src}")
|
|
17
|
+
await asyncio.sleep(0.4)
|
|
18
|
+
return {
|
|
19
|
+
"action": "DECEPT_REDIRECT",
|
|
20
|
+
"target_decoy": "v-web-04-honeypot",
|
|
21
|
+
"rationale": "High-suspicion telemetry detected; initiating engagement in sandbox."
|
|
22
|
+
}
|
|
23
|
+
|
|
24
|
+
return {"action": "OBSERVE", "status": "no_deception_required"}
|
core/tier8_governance.py
ADDED
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
import asyncio
|
|
2
|
+
from .base_tier import DefenseTier
|
|
3
|
+
from typing import Any
|
|
4
|
+
|
|
5
|
+
class Tier8Governance(DefenseTier):
|
|
6
|
+
"""Tier 8: Compliance & Governance (Policy Guardrails)."""
|
|
7
|
+
def __init__(self, memory=None):
|
|
8
|
+
super().__init__(name="Tier 8: Governance Guard", priority=8, memory=memory)
|
|
9
|
+
# Mock Policy: Never isolate OT assets during work hours
|
|
10
|
+
self.critical_assets = ["ot-controller-01", "dc-primary"]
|
|
11
|
+
|
|
12
|
+
async def process(self, telemetry: Any) -> dict:
|
|
13
|
+
target = telemetry.get('src', 'unknown')
|
|
14
|
+
proposed_action = "BLOCK" # Derived from lower tiers context in real scenario
|
|
15
|
+
|
|
16
|
+
print(f"[{self.name}] Auditing compliance for target: {target}...")
|
|
17
|
+
await asyncio.sleep(0.2)
|
|
18
|
+
|
|
19
|
+
if target in self.critical_assets:
|
|
20
|
+
return {
|
|
21
|
+
"action": "POLICY_OVERRIDE",
|
|
22
|
+
"recommended_alternative": "LIMIT_BANDWIDTH",
|
|
23
|
+
"reason": "Target is a critical asset; full isolation violates availability policy."
|
|
24
|
+
}
|
|
25
|
+
|
|
26
|
+
return {"action": "POLICY_COMPLIANT", "status": "approved"}
|
core/tier9_strategic.py
ADDED
|
@@ -0,0 +1,25 @@
|
|
|
1
|
+
import asyncio
|
|
2
|
+
from .base_tier import DefenseTier
|
|
3
|
+
from typing import Any
|
|
4
|
+
|
|
5
|
+
class Tier9Strategic(DefenseTier):
|
|
6
|
+
"""Tier 9: Strategic Optimization (Game Theoretic Action Selection)."""
|
|
7
|
+
def __init__(self, memory=None):
|
|
8
|
+
super().__init__(name="Tier 9: Strategic Optimizer", priority=9, memory=memory)
|
|
9
|
+
|
|
10
|
+
async def process(self, telemetry: Any) -> dict:
|
|
11
|
+
# Game theory: Value of information vs Cost of containment
|
|
12
|
+
risk_score = telemetry.get('score', 0)
|
|
13
|
+
|
|
14
|
+
print(f"[{self.name}] Calculating optimal strategic response...")
|
|
15
|
+
await asyncio.sleep(0.3)
|
|
16
|
+
|
|
17
|
+
if risk_score > 90:
|
|
18
|
+
return {"strategy": "AGGRESSIVE_CONTAINMENT", "action": "BLOCK"}
|
|
19
|
+
|
|
20
|
+
# Strategic "Wait and Watch" to uncover C2 infrastructure
|
|
21
|
+
return {
|
|
22
|
+
"strategy": "INTEL_GATHERING",
|
|
23
|
+
"action": "MONITOR_LATERAL",
|
|
24
|
+
"rationale": "High value in observing lateral movement to identify additional compromised nodes."
|
|
25
|
+
}
|
|
@@ -0,0 +1,51 @@
|
|
|
1
|
+
import asyncio
|
|
2
|
+
import time
|
|
3
|
+
from .base_tier import DefenseTier
|
|
4
|
+
|
|
5
|
+
class Tier1Responder(DefenseTier):
|
|
6
|
+
"""Tier 1: Deterministic Priority Ladder (Identity > OT > Network)."""
|
|
7
|
+
def __init__(self, memory=None):
|
|
8
|
+
super().__init__(name="Tier 1: Deterministic Responder", priority=1, memory=memory)
|
|
9
|
+
self.priorities = {
|
|
10
|
+
"identity": 100,
|
|
11
|
+
"ot": 80,
|
|
12
|
+
"network": 50
|
|
13
|
+
}
|
|
14
|
+
|
|
15
|
+
async def process(self, telemetry: dict) -> dict:
|
|
16
|
+
# Deterministic Priority Ladder
|
|
17
|
+
category = telemetry.get("category", "network")
|
|
18
|
+
priority_score = self.priorities.get(category, 0)
|
|
19
|
+
|
|
20
|
+
if telemetry.get("score", 0) > 90 and priority_score >= 80:
|
|
21
|
+
action = "INSTANT_BLOCK"
|
|
22
|
+
rationale = f"High severity {category} threat detected in priority ladder."
|
|
23
|
+
if self.memory:
|
|
24
|
+
self.memory.add_action(self.name, action, rationale, telemetry)
|
|
25
|
+
return {"action": action, "priority": priority_score, "rationale": rationale}
|
|
26
|
+
|
|
27
|
+
return {"action": "PASS", "status": "deterministic_check_clear"}
|
|
28
|
+
|
|
29
|
+
def handle(self, telemetry: dict) -> dict:
|
|
30
|
+
import asyncio
|
|
31
|
+
return asyncio.run(self.process(telemetry))
|
|
32
|
+
|
|
33
|
+
class Tier2Reasoner(DefenseTier):
|
|
34
|
+
"""Tier 2: LLM Reasoning with Rolling Memory Context."""
|
|
35
|
+
def __init__(self, memory=None):
|
|
36
|
+
super().__init__(name="Tier 2: LLM Reasoner", priority=2, memory=memory)
|
|
37
|
+
|
|
38
|
+
async def process(self, telemetry: dict) -> dict:
|
|
39
|
+
# Simulate LLM thinking with cross-cycle context
|
|
40
|
+
history = self.memory.get_context() if self.memory else []
|
|
41
|
+
|
|
42
|
+
# Chain-of-thought simulation
|
|
43
|
+
print(f"[{self.name}] Reasoning over {len(history)} historical events...")
|
|
44
|
+
await asyncio.sleep(0.5)
|
|
45
|
+
|
|
46
|
+
action = "ENRICHED_INVESTIGATION"
|
|
47
|
+
rationale = "Behavioral correlation indicates persistent activity across cycles."
|
|
48
|
+
if self.memory:
|
|
49
|
+
self.memory.add_action(self.name, action, rationale, telemetry)
|
|
50
|
+
|
|
51
|
+
return {"action": action, "rationale": rationale}
|
|
@@ -0,0 +1,85 @@
|
|
|
1
|
+
Metadata-Version: 2.4
|
|
2
|
+
Name: defense-core
|
|
3
|
+
Version: 0.1.0
|
|
4
|
+
Summary: Autonomous Agentic SOC with 20-Tier BlueSTAR Architecture for Cyber Defense
|
|
5
|
+
Author-email: Muh Agus <pmuhammadagus-byte@users.noreply.github.com>
|
|
6
|
+
License: MIT
|
|
7
|
+
Project-URL: Homepage, https://github.com/pmuhammadagus-byte/defense-core
|
|
8
|
+
Project-URL: Repository, https://github.com/pmuhammadagus-byte/defense-core
|
|
9
|
+
Project-URL: Issues, https://github.com/pmuhammadagus-byte/defense-core/issues
|
|
10
|
+
Keywords: cybersecurity,soc,agentic,defense,bluestar,autonomous,threat-intelligence,behavioral-analysis
|
|
11
|
+
Classifier: Development Status :: 3 - Alpha
|
|
12
|
+
Classifier: Intended Audience :: Information Technology
|
|
13
|
+
Classifier: Intended Audience :: System Administrators
|
|
14
|
+
Classifier: License :: OSI Approved :: MIT License
|
|
15
|
+
Classifier: Operating System :: POSIX :: Linux
|
|
16
|
+
Classifier: Operating System :: MacOS
|
|
17
|
+
Classifier: Operating System :: Microsoft :: Windows
|
|
18
|
+
Classifier: Programming Language :: Python :: 3
|
|
19
|
+
Classifier: Programming Language :: Python :: 3.10
|
|
20
|
+
Classifier: Programming Language :: Python :: 3.11
|
|
21
|
+
Classifier: Programming Language :: Python :: 3.12
|
|
22
|
+
Classifier: Topic :: Security
|
|
23
|
+
Classifier: Topic :: System :: Monitoring
|
|
24
|
+
Requires-Python: >=3.10
|
|
25
|
+
Description-Content-Type: text/markdown
|
|
26
|
+
Provides-Extra: dev
|
|
27
|
+
Requires-Dist: pytest>=7.4.0; extra == "dev"
|
|
28
|
+
Requires-Dist: ruff>=0.1.0; extra == "dev"
|
|
29
|
+
Requires-Dist: mypy>=1.5.0; extra == "dev"
|
|
30
|
+
|
|
31
|
+
# Defense Core: Autonomous Agentic SOC
|
|
32
|
+
"Defense Core" adalah sistem pertahanan siber otomatis yang menggunakan arsitektur hierarki (Tiered Architecture) untuk perlindungan maksimal.
|
|
33
|
+
|
|
34
|
+
## Mengapa ini penting?
|
|
35
|
+
Sistem ini memisahkan tugas pertahanan ke dalam lapisan-lapisan (Tiers) yang semakin cerdas:
|
|
36
|
+
1. **Tier 1 (Responder):** Satpam garis depan (Cepat, Deterministic).
|
|
37
|
+
2. **Tier 2 (Reasoning):** Otak AI untuk penalaran kasus per kasus.
|
|
38
|
+
3. **Tier 3 (Heuristic):** Deteksi pola serangan berdasarkan korelasi data.
|
|
39
|
+
4. **Tier 4 (Behavioral):** Profiling perilaku jangka panjang (Mendeteksi anomali frekuensi serangan).
|
|
40
|
+
5. **Tier 5 (Threat Intel):** Integrasi dengan pangkalan data ancaman global.
|
|
41
|
+
6. **Tier 6 (Predictive):** Prakiraan langkah serangan selanjutnya (ATT&CK Mapping).
|
|
42
|
+
7. **Tier 7 (Deception):** Deployment aset pengecoh (Honeypot/Decoy).
|
|
43
|
+
8. **Tier 8 (Governance):** Guardrail kebijakan bisnis (Audit kepatuhan aksi).
|
|
44
|
+
9. **Tier 9 (Strategic):** Optimasi strategi berbasis Game Theory (Cost vs Benefit).
|
|
45
|
+
10. **Tier 10 (Resilience):** Pemulihan sistem otonom (Self-Healing/Rollback).
|
|
46
|
+
11. **Tier 11 (Attribution):** Identifikasi aktor di balik serangan (Profiling APT).
|
|
47
|
+
16. **Tier 16 (Economic):** FinOps Security (Audit biaya vs manfaat pertahanan).
|
|
48
|
+
17. **Tier 17 (Legal):** Guardrail kepatuhan hukum dan privasi (PDP/GDPR).
|
|
49
|
+
18. **Tier 18 (Psychological):** Counter-manipulasi untuk frustrasi penyerang.
|
|
50
|
+
19. **Tier 19 (Sync):** Sinkronisasi state dengan AI Guardians eksternal.
|
|
51
|
+
20. **Tier 20 (Singularity):** Optimalisasi mandiri seluruh hierarki pertahanan.
|
|
52
|
+
12. **Tier 12 (Ecosystem):** Koordinasi respon lintas ekosistem (Cloud, SaaS, Host).
|
|
53
|
+
13. **Tier 13 (Knowledge):** Ingesti otomatis pengetahuan keamanan baru (CVE/Advisory).
|
|
54
|
+
14. **Tier 14 (Meta-Defense):** Monitoring integritas internal sistem SOC itu sendiri.
|
|
55
|
+
15. **Tier 15 (Swarm):** Pertahanan federasi/kolektif (Sharing signal antar node global).
|
|
56
|
+
|
|
57
|
+
## Fitur Utama
|
|
58
|
+
- **Universal Portability:** Berjalan mulus di Linux, Ubuntu, hingga Termux (Android).
|
|
59
|
+
- **Hierarchical Engine:** Arsitektur yang siap dikembangkan hingga **20 Tier (Full Active Scaffold)** tanpa merombak sistem utama.
|
|
60
|
+
- **Persistent Memory:** Menggunakan `behavior_history.json` untuk mengingat pola serangan jangka panjang.
|
|
61
|
+
|
|
62
|
+
## Cara Menggunakan
|
|
63
|
+
|
|
64
|
+
### Install dari PyPI
|
|
65
|
+
```bash
|
|
66
|
+
pip install defense-core
|
|
67
|
+
run-soc --help
|
|
68
|
+
run-soc --src 192.168.1.50 --score 95 --category identity
|
|
69
|
+
```
|
|
70
|
+
|
|
71
|
+
### Development (dari source)
|
|
72
|
+
```bash
|
|
73
|
+
git clone https://github.com/pmuhammadagus-byte/defense-core
|
|
74
|
+
cd defense-core
|
|
75
|
+
pip install -e ".[dev]"
|
|
76
|
+
python -m core.orchestrator --src 192.168.1.50 --score 95 --category identity
|
|
77
|
+
```
|
|
78
|
+
|
|
79
|
+
## Status Pengembangan (Honesty Policy)
|
|
80
|
+
Proyek ini adalah arsitektur 20-tier yang berjalan secara teknis, namun memiliki tingkat kematangan logika yang bervariasi:
|
|
81
|
+
- **Tier 1 - 5 (Production-Grade):** Logika operasional kuat (Deterministic, Reasoner, Heuristic, Behavioral, Intel).
|
|
82
|
+
- **Tier 6 - 15 (Working Minimal):** Berfungsi secara teknis namun masih menggunakan placeholder (CVE dummy, hardcoded swarm nodes, empty hashes) yang akan diganti pada sesi berikutnya.
|
|
83
|
+
- **Tier 16 - 20 (Architecture Scaffold):** Fondasi teknis yang sudah terintegrasi namun masih berupa kerangka aksi (scaffold).
|
|
84
|
+
|
|
85
|
+
**Status:** Bukan sistem sempurna, tapi sistem yang terdokumentasi dan siap berevolusi.
|
|
@@ -0,0 +1,33 @@
|
|
|
1
|
+
agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
2
|
+
agents/evidence.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
3
|
+
agents/response.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
4
|
+
agents/triage.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
5
|
+
core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
6
|
+
core/base_tier.py,sha256=04fbqw1KVMktMszTH-525pC5Zu3_nkcbqazz7yq05jE,321
|
|
7
|
+
core/bus.py,sha256=jfyd28AUKLRrX3NuGY7LDx9DEkpfoHAbeSLjPqeTIsY,1242
|
|
8
|
+
core/memory.py,sha256=9qQmSRIaBnDrWKrmNwSFAGM-EIf5HVLNvk5W_MjkZl4,912
|
|
9
|
+
core/orchestrator.py,sha256=exPfM3m8Wja2B-sq059mlC9aubuGG7_9M9N6XSdf1Ps,4414
|
|
10
|
+
core/tier10_resilience.py,sha256=q2jaoqXqmqVOR762aZW77XS_JQnvLQ5OmBzAIdABK7Y,1129
|
|
11
|
+
core/tier11_attribution.py,sha256=u5MdNR3xiue185jfRj_HBjGmPQmz0-Bu0UDp-SLv1kM,1083
|
|
12
|
+
core/tier12_ecosystem.py,sha256=hvYtXysLNw4iZYRGxZKO-bn2u3o3Yoq3ejOTabxqJ7E,789
|
|
13
|
+
core/tier13_knowledge.py,sha256=W6-EXY0frwPgl5Clbi3wd-N4Ch4zc4Qgbo9W99euPxo,799
|
|
14
|
+
core/tier14_meta_defense.py,sha256=HgPld4eSZUVP244adrvoFYoiRDQaOasTQjPrQR-Mw4M,804
|
|
15
|
+
core/tier15_swarm.py,sha256=AgnFr4rlICzV1PFy6CyU67KX2PhmNZeS3y3uroyiulM,684
|
|
16
|
+
core/tier16_economic.py,sha256=sp-CEWqHfYcfgDeMzZ42saGPcBE_mesmDr0dUDFEBRc,494
|
|
17
|
+
core/tier17_legal.py,sha256=ChpqXSv9KmkSgjemuxFoEzhwVucuPWcsabpnsO2_jKw,473
|
|
18
|
+
core/tier18_psychological.py,sha256=jbnzoO0hEdqcIExzJG_67zYthubXi4ZzJXsux-387ws,528
|
|
19
|
+
core/tier19_sync.py,sha256=237e19sAa0fr1oi36kMNM0AR-FlvrJTfzMKnF0lZoMw,498
|
|
20
|
+
core/tier20_singularity.py,sha256=OmRH_aT0jD1f66sEJYK_YJHsxLTozvV_RrWyvuo84Ms,528
|
|
21
|
+
core/tier3_heuristic.py,sha256=8HrRX09N6crgj-Yf-dVF0ieoCw2mWdvUAY214pubaMs,777
|
|
22
|
+
core/tier4_behavior.py,sha256=fh9gu7QxX11VrfxbHidwWPGUQUkuujlyLyjAZzG-j5Q,1417
|
|
23
|
+
core/tier5_intel.py,sha256=ibqtMHSyeWBUTp1TAgX-4XBIflGLZyZp8gNLecaC_a4,794
|
|
24
|
+
core/tier6_predictive.py,sha256=FUs-gICSt6m3VJ0auQ2BlYpI8kJGfDvE3NBuYAcX2pY,1325
|
|
25
|
+
core/tier7_deception.py,sha256=JF9PO9psf4eFsgdBoohLP4VsX_D3IwYtOS7UPSHhvSU,1003
|
|
26
|
+
core/tier8_governance.py,sha256=bN0Z0JEHjSC-lXcxR3avgSbPdgob2-nAX00YgzyS6-I,1109
|
|
27
|
+
core/tier9_strategic.py,sha256=vRwIZx5r1R2jMksthggKaB8UgLGftcYEv-LQeewMKm4,1004
|
|
28
|
+
core/tier_architectures.py,sha256=PjxQkkmt5N_rXA2DbtcJG0MuArbwgJ3IWq7_dHiWmdU,2104
|
|
29
|
+
defense_core-0.1.0.dist-info/METADATA,sha256=TEW8Rgl5IVO78KHSn0YxonRSOu-0RsdCuIFIHNavDe8,4711
|
|
30
|
+
defense_core-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
|
|
31
|
+
defense_core-0.1.0.dist-info/entry_points.txt,sha256=D26fU_Lh0CHNi4jeO_axlKkiTrFmn_OZhyVZDRqx7Vw,51
|
|
32
|
+
defense_core-0.1.0.dist-info/top_level.txt,sha256=41Tt1akJa2I2IO1ViDfTZpQdBzrPwZ9no6We5KbOVcM,12
|
|
33
|
+
defense_core-0.1.0.dist-info/RECORD,,
|