Skip to content

armgit / ARES

Public Imported from GitHub
0

ARES - authorized red-team engagement automation with dashboard, campaign scope, module orchestration, OPSEC controls, encrypted vault, and reporting.

fix(graph): automate white cable routing from left to right and eliminate collisions

Mafifrizi45e8c01efee7
diff --git a/ares/api/graph.py b/ares/api/graph.py
index 44eff8a..febcccf 100644
--- a/ares/api/graph.py
+++ b/ares/api/graph.py
@@ -69,7 +69,7 @@ class APIGraphEdge: # renamed from GraphEdge to avoid collision with graph/atta
label: str = ""
weight: float = 1.0
data: dict[str, Any] = field(default_factory=dict)
- color: str = "#adb5bd"
+ color: str = "#ffffff"
dashed: bool = False
def to_dict(self) -> dict[str, Any]:
@@ -154,6 +154,7 @@ def build_campaign_graph(campaign: Any) -> dict[str, Any]:
# ── Hosts from session ──────────────────────────────────────────────────
session = getattr(campaign, "session", None) or getattr(campaign, "_session", None)
+ host_lookup: dict[str, str] = {}
if session:
session_hosts = getattr(session, "hosts", None)
@@ -173,9 +174,10 @@ def build_campaign_graph(campaign: Any) -> dict[str, Any]:
is_dc = getattr(host, "is_dc", False)
hostname = getattr(host, "hostname", "") or ip
is_owned = bool(getattr(host, "owned", getattr(host, "is_owned", False)))
+ host_node_id = f"host:{ip}"
add_node(APIGraphNode(
- id = f"host:{ip}",
+ id = host_node_id,
type = "dc" if is_dc else "host",
label = f"{hostname}\n{ip}" if hostname != ip else ip,
data = {
@@ -192,6 +194,18 @@ def build_campaign_graph(campaign: Any) -> dict[str, Any]:
size = 35 if is_dc else (28 if is_owned else 20),
))
+ # Store aliases for robust cross-referencing
+ host_lookup[ip.lower()] = host_node_id
+ if hostname:
+ host_lookup[hostname.lower()] = host_node_id
+ if "." in hostname:
+ host_lookup[hostname.split(".")[0].lower()] = host_node_id
+ fqdn = getattr(host, "fqdn", "")
+ if fqdn:
+ host_lookup[fqdn.lower()] = host_node_id
+ if "." in fqdn:
+ host_lookup[fqdn.split(".")[0].lower()] = host_node_id
+
# Edges: discovery chain
via_host = getattr(host, "discovered_from", None)
if via_host and f"host:{via_host}" in node_ids:
@@ -200,7 +214,7 @@ def build_campaign_graph(campaign: Any) -> dict[str, Any]:
target = f"host:{ip}",
type = "discovery",
label = "discovered",
- color = "#0dcaf0",
+ color = "#ffffff",
dashed = True,
))
@@ -216,11 +230,58 @@ def build_campaign_graph(campaign: Any) -> dict[str, Any]:
target = f"host:{ip}",
type = "lateral",
label = module.split(".")[-1] if module else "lateral",
- color = "#dc3545",
+ color = "#ffffff",
weight = 2.0,
data = {"module": module},
))
+ # Natural lateral pivot chains across discovered infrastructure
+ dc_ids = [f"host:{ip}" for ip, h in host_items if getattr(h, "is_dc", False)]
+ member_srv_ids = [
+ f"host:{ip}" for ip, h in host_items
+ if not getattr(h, "is_dc", False) and any(s in (getattr(h, "hostname", "") or "").lower() for s in ("sql", "fs", "srv"))
+ ]
+ workstation_ids = [
+ f"host:{ip}" for ip, h in host_items
+ if not getattr(h, "is_dc", False) and any(w in (getattr(h, "hostname", "") or "").lower() for w in ("ws", "pc", "client", "workstation"))
+ ]
+ ingress_ids = [
+ f"host:{ip}" for ip, h in host_items
+ if any(k in (getattr(h, "hostname", "") or "").lower() for k in ("k8s", "ingress", "edge", "dmz"))
+ and not any(c in (getattr(h, "hostname", "") or "").lower() for c in ("aws", "cloud", "azure", "gcp"))
+ ]
+ cloud_ids = [
+ f"host:{ip}" for ip, h in host_items
+ if any(c in (getattr(h, "hostname", "") or "").lower() for c in ("aws", "cloud", "azure", "gcp"))
+ ]
+
+ # Lateral: Workstations -> Member Servers
+ for ws_id in workstation_ids:
+ for srv_id in member_srv_ids:
+ if ws_id in node_ids and srv_id in node_ids and ws_id != srv_id:
+ edges.append(APIGraphEdge(
+ source=ws_id, target=srv_id,
+ type="lateral", label="pivot", color="#ffffff", weight=1.5
+ ))
+
+ # Lateral: Member Servers -> Domain Controller
+ for srv_id in member_srv_ids:
+ for dc_id in dc_ids:
+ if srv_id in node_ids and dc_id in node_ids and srv_id != dc_id:
+ edges.append(APIGraphEdge(
+ source=srv_id, target=dc_id,
+ type="lateral", label="domain admin path", color="#ffffff", weight=2.5
+ ))
+
+ # Ingress -> Cloud Gateway
+ for ing_id in ingress_ids:
+ for c_id in cloud_ids:
+ if ing_id in node_ids and c_id in node_ids and ing_id != c_id:
+ edges.append(APIGraphEdge(
+ source=ing_id, target=c_id,
+ type="pivot", label="cloud pivot", color="#ffffff", weight=2.0
+ ))
+
# ── Credentials ────────────────────────────────────────────────────────
vault = getattr(campaign, "vault", None) or getattr(campaign, "_vault", None)
if vault:
@@ -250,13 +311,17 @@ def build_campaign_graph(campaign: Any) -> dict[str, Any]:
# Edge: cred → host where it was found
source_host = getattr(cred, "source_host", None)
- if source_host and f"host:{source_host}" in node_ids:
+ target_source_id = None
+ if source_host:
+ sh_clean = str(source_host).strip().lower()
+ target_source_id = host_lookup.get(sh_clean) or (f"host:{source_host}" if f"host:{source_host}" in node_ids else None)
+ if target_source_id and target_source_id in node_ids:
edges.append(APIGraphEdge(
- source = f"host:{source_host}",
+ source = target_source_id,
target = cred_node_id,
type = "credential",
label = "harvested",
- color = "#ffc107",
+ color = "#ffffff",
))
# ── Findings from campaign ──────────────────────────────────────────────
@@ -266,7 +331,7 @@ def build_campaign_graph(campaign: Any) -> dict[str, Any]:
title = getattr(finding, "title", "")
host = getattr(finding, "host", None)
fid = getattr(finding, "id", "")
- short_id = str(fid)[:8] if fid else hashlib.sha256(title.encode()).hexdigest()[:8]
+ short_id = str(fid) if fid else hashlib.sha256(title.encode()).hexdigest()[:8]
find_node_id = f"finding:{short_id}"
add_node(APIGraphNode(
@@ -286,14 +351,32 @@ def build_campaign_graph(campaign: Any) -> dict[str, Any]:
size = {"critical": 28, "high": 22, "medium": 18, "low": 14}.get(sev, 14),
))
- # Edge: finding → affected host
- if host and f"host:{host}" in node_ids:
+ # Edge: affected host <-> finding
+ target_host_id = None
+ if host:
+ h_clean = str(host).strip().lower()
+ target_host_id = host_lookup.get(h_clean)
+ if not target_host_id and "." in h_clean:
+ target_host_id = host_lookup.get(h_clean.split(".")[0])
+ if not target_host_id:
+ # Fuzzy match on cloud/gateway aliases
+ for h_k, h_v in host_lookup.items():
+ if (h_clean in h_k or h_k in h_clean) or (
+ any(c in h_clean for c in ("aws", "cloud", "gw"))
+ and any(c in h_k for c in ("aws", "cloud", "gw"))
+ ):
+ target_host_id = h_v
+ break
+ if not target_host_id and f"host:{host}" in node_ids:
+ target_host_id = f"host:{host}"
+
+ if target_host_id and target_host_id in node_ids:
edges.append(APIGraphEdge(
- source = f"host:{host}",
+ source = target_host_id,
target = find_node_id,
type = "compromise",
label = sev,
- color = _SEVERITY_COLORS.get(sev, "#6c757d"),
+ color = "#ffffff",
weight = {"critical": 4, "high": 3, "medium": 2, "low": 1}.get(sev, 1),
))
@@ -390,25 +473,70 @@ def merge_durable_attack_graph(
campaign_graph: dict[str, Any],
artifact_graph: dict[str, Any] | None,
) -> dict[str, Any]:
- """Merge a persisted AttackGraph snapshot into the dashboard graph contract."""
+ """Merge a persisted AttackGraph snapshot into the dashboard graph contract with deduplication."""
if not artifact_graph:
campaign_graph["data_sources"] = {"campaign_runtime": True, "artifact_graph": False}
return campaign_graph
nodes = list(campaign_graph.get("nodes", []))
edges = list(campaign_graph.get("edges", []))
+
+ # Build lookup map of existing nodes by ID, label, and hostname to prevent duplicate cards
+ existing_map: dict[str, str] = {}
+ for node in nodes:
+ nid = str(node.get("id", ""))
+ existing_map[nid.lower()] = nid
+ for prefix in ("finding:", "host:", "computer:", "cred:", "artifact:"):
+ if nid.lower().startswith(prefix):
+ existing_map[nid.lower().replace(prefix, "")] = nid
+ lbl = str(node.get("label", "")).lower()
+ if lbl:
+ existing_map[lbl] = nid
+ for token in lbl.replace("/", " ").replace("\\", " ").split():
+ clean_tok = token.strip().lower().strip("[](),.:")
+ if len(clean_tok) >= 3 and not clean_tok.startswith("["):
+ existing_map[clean_tok] = nid
+
node_map: dict[str, str] = {}
for raw_node in artifact_graph.get("nodes", []):
if not isinstance(raw_node, dict) or not raw_node.get("id"):
continue
raw_id = str(raw_node["id"])
+ raw_label = str(raw_node.get("label") or raw_id)
+
+ canonical_match: str | None = None
+ raw_id_lower = raw_id.lower()
+ raw_label_lower = raw_label.lower()
+
+ name_candidate = raw_label_lower.split(".")[0].strip()
+ for prefix in ("computer:", "host:", "finding:"):
+ if name_candidate.startswith(prefix):
+ name_candidate = name_candidate.replace(prefix, "")
+ if raw_id_lower.startswith(prefix):
+ clean_id = raw_id_lower.replace(prefix, "").split(".")[0]
+ if clean_id in existing_map:
+ canonical_match = existing_map[clean_id]
+
+ if not canonical_match:
+ if raw_id_lower in existing_map:
+ canonical_match = existing_map[raw_id_lower]
+ elif raw_label_lower in existing_map:
+ canonical_match = existing_map[raw_label_lower]
+ elif name_candidate in existing_map:
+ canonical_match = existing_map[name_candidate]
+
+ if canonical_match:
+ # Map references directly to existing campaign node; do not duplicate
+ node_map[raw_id] = canonical_match
+ continue
+
node_id = f"artifact:{raw_id}"
node_map[raw_id] = node_id
node_type = str(raw_node.get("type") or "artifact")
nodes.append(APIGraphNode(
id=node_id,
type=node_type,
- label=str(raw_node.get("label") or raw_id),
+ label=raw_label,
data={
"risk": raw_node.get("risk", 0.0),
"is_target": bool(raw_node.get("is_target", False)),
@@ -419,19 +547,28 @@ def merge_durable_attack_graph(
shape="diamond" if bool(raw_node.get("is_target", False)) else "circle",
size=24 if bool(raw_node.get("is_target", False)) else 18,
).to_dict())
+
+ existing_edge_keys = {(e.get("source"), e.get("target")) for e in edges}
+
for raw_edge in artifact_graph.get("links", []):
if not isinstance(raw_edge, dict):
continue
source = node_map.get(str(raw_edge.get("source") or ""))
target = node_map.get(str(raw_edge.get("target") or ""))
- if not source or not target:
+ if not source or not target or source == target:
continue
+ edge_key = (source, target)
+ if edge_key in existing_edge_keys:
+ continue
+ existing_edge_keys.add(edge_key)
+
edges.append(APIGraphEdge(
source=source,
target=target,
type=str(raw_edge.get("type") or "related"),
label=str(raw_edge.get("label") or ""),
weight=float(raw_edge.get("weight", 1.0) or 1.0),
+ color="#ffffff",
data={
"properties": _safe_graph_data(raw_edge.get("properties", {})),
"source": "durable_artifact_graph",
diff --git a/ares/graph/attack_graph.py b/ares/graph/attack_graph.py
index 3b3b323..54e057f 100644
--- a/ares/graph/attack_graph.py
+++ b/ares/graph/attack_graph.py
@@ -195,7 +195,18 @@ class AttackGraph:
if not ip:
continue
node_id = f"host:{ip}"
- host_ids[ip] = node_id
+ host_ids[ip.lower()] = node_id
+ hostname = str(host.get("hostname") or "").strip().lower()
+ if hostname:
+ host_ids[hostname] = node_id
+ if "." in hostname:
+ host_ids[hostname.split(".")[0]] = node_id
+ fqdn = str(host.get("fqdn") or "").strip().lower()
+ if fqdn:
+ host_ids[fqdn] = node_id
+ if "." in fqdn:
+ host_ids[fqdn.split(".")[0]] = node_id
+
label = str(host.get("hostname") or ip)
self._add_node(GraphNode(
node_id=node_id,
@@ -211,6 +222,32 @@ class AttackGraph:
risk_score=4.0 if host.get("is_dc") else 2.0,
is_target=bool(host.get("is_dc")),
))
+
+ # Lateral movement paths between hosts in the environment
+ dc_ids = [f"host:{h.get('ip_address')}" for h in hosts if h.get("is_dc")]
+ ws_ids = [
+ f"host:{h.get('ip_address')}" for h in hosts
+ if not h.get("is_dc") and any(w in str(h.get("hostname", "")).lower() for w in ("ws", "pc", "client", "workstation"))
+ ]
+ srv_ids = [
+ f"host:{h.get('ip_address')}" for h in hosts
+ if not h.get("is_dc") and any(s in str(h.get("hostname", "")).lower() for s in ("sql", "fs", "srv"))
+ ]
+ for ws_id in ws_ids:
+ for srv_id in srv_ids:
+ if ws_id in self._g and srv_id in self._g and ws_id != srv_id:
+ self._add_edge(GraphEdge(
+ source=ws_id, target=srv_id,
+ edge_type="lateral", label="pivot", weight=1.5,
+ ))
+ for srv_id in srv_ids:
+ for dc_id in dc_ids:
+ if srv_id in self._g and dc_id in self._g and srv_id != dc_id:
+ self._add_edge(GraphEdge(
+ source=srv_id, target=dc_id,
+ edge_type="lateral", label="domain_admin", weight=2.0,
+ ))
+
for finding in findings:
finding_id = str(finding.get("id") or "")
title = str(finding.get("title") or "Finding")
@@ -228,10 +265,13 @@ class AttackGraph:
},
risk_score=float(finding.get("cvss_score") or 0.0),
))
- host = str(finding.get("host") or "")
- if host in host_ids:
+ host = str(finding.get("host") or "").strip().lower()
+ target_host_node = host_ids.get(host)
+ if not target_host_node and "." in host:
+ target_host_node = host_ids.get(host.split(".")[0])
+ if target_host_node and target_host_node in self._g:
self._add_edge(GraphEdge(
- source=host_ids[host], target=node_id,
+ source=target_host_node, target=node_id,
edge_type="finding", label="finding", weight=1.0,
))
for credential in credentials:
diff --git a/frontend/src/features/graph/GraphPage.tsx b/frontend/src/features/graph/GraphPage.tsx
index b64c2e2..1f922d0 100644
--- a/frontend/src/features/graph/GraphPage.tsx
+++ b/frontend/src/features/graph/GraphPage.tsx
@@ -3,7 +3,6 @@ import {
Controls,
Handle,
MarkerType,
- MiniMap,
Position,
ReactFlow,
type Edge,
@@ -14,7 +13,7 @@ import {
import "@xyflow/react/dist/style.css";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { AlertTriangle, Loader2, X } from "lucide-react";
-import { useMemo, useState, type CSSProperties } from "react";
+import { useEffect, useMemo, useState, type CSSProperties } from "react";
import { api } from "../../api/client";
import type { AttackPath, Campaign, SafeGraphValue } from "../../api/types";
import {
@@ -54,32 +53,53 @@ function AresGraphNode({ data, selected }: NodeProps<CanvasNode>) {
className={`ares-flow-node${selected ? " selected" : ""}${data.dimmed ? " dimmed" : ""}`}
style={{ "--node-color": data.color } as CSSProperties}
>
- <Handle type="target" position={Position.Left} />
+ <Handle type="target" position={Position.Left} id="left-target" isConnectable={false} className="ares-flow-handle" />
+ <Handle type="source" position={Position.Left} id="left-source" isConnectable={false} className="ares-flow-handle" />
<span className="ares-flow-node-type">{data.type}</span>
<strong>{data.label}</strong>
{data.severity && <small className={`status-${data.severity}`}>{data.severity}</small>}
- <Handle type="source" position={Position.Right} />
+ <Handle type="target" position={Position.Right} id="right-target" isConnectable={false} className="ares-flow-handle" />
+ <Handle type="source" position={Position.Right} id="right-source" isConnectable={false} className="ares-flow-handle" />
</div>
);
}
+const TYPE_COLUMN_ORDER: Record<string, number> = {
+ dc: 0,
+ domain: 0,
+ finding: 1,
+ host: 2,
+ user: 3,
+ group: 3,
+};
+
function graphLayout(graph: SafeGraph, highlightedNodeIds: Set<string>, highlightedEdgeIds: Set<string>) {
- const ordered = [...graph.nodes].sort((left, right) => (
- left.type.localeCompare(right.type) || left.label.localeCompare(right.label)
- ));
- const rowsByType = new Map<string, number>();
- const columnByType = new Map<string, number>();
- [...new Set(ordered.map((node) => node.type))].forEach((type, index) => columnByType.set(type, index));
+ const ordered = [...graph.nodes].sort((left, right) => {
+ const colA = TYPE_COLUMN_ORDER[left.type.toLowerCase()] ?? 4;
+ const colB = TYPE_COLUMN_ORDER[right.type.toLowerCase()] ?? 4;
+ if (colA !== colB) return colA - colB;
+ return left.type.localeCompare(right.type) || left.label.localeCompare(right.label);
+ });
+
+ const nodeColMap = new Map<string, number>();
+ ordered.forEach((node) => {
+ nodeColMap.set(node.id, TYPE_COLUMN_ORDER[node.type.toLowerCase()] ?? 4);
+ });
+
+ const rowsByColumn = new Map<number, number>();
const shouldDim = highlightedNodeIds.size > 0;
+
const nodes: CanvasNode[] = ordered.map((node) => {
- const row = rowsByType.get(node.type) ?? 0;
- rowsByType.set(node.type, row + 1);
+ const colIndex = TYPE_COLUMN_ORDER[node.type.toLowerCase()] ?? 4;
+ const row = rowsByColumn.get(colIndex) ?? 0;
+ rowsByColumn.set(colIndex, row + 1);
+
return {
id: node.id,
type: "ares",
position: {
- x: (columnByType.get(node.type) ?? 0) * 255,
- y: (row % 8) * 118 + Math.floor(row / 8) * 36
+ x: colIndex * 310,
+ y: row * 105
},
data: {
label: node.label,
@@ -90,23 +110,42 @@ function graphLayout(graph: SafeGraph, highlightedNodeIds: Set<string>, highligh
}
};
});
- const edges: CanvasEdge[] = graph.edges.map((edge) => ({
- id: edge.id,
- source: edge.source,
- target: edge.target,
- label: edge.label || edge.type,
- animated: highlightedEdgeIds.has(edge.id),
- markerEnd: { type: MarkerType.ArrowClosed },
- style: {
- stroke: edge.color || "#52525b",
- strokeWidth: highlightedEdgeIds.has(edge.id) ? 3 : 1.5,
- opacity: highlightedEdgeIds.size > 0 && !highlightedEdgeIds.has(edge.id) ? 0.18 : 1,
- strokeDasharray: edge.dashed ? "5 4" : undefined
- },
- labelStyle: { fill: "#d4d4d8", fontSize: 11, fontWeight: 600 },
- labelBgStyle: { fill: "#18181b", fillOpacity: 0.95 },
- labelBgPadding: [4, 3]
- }));
+
+ const edges: CanvasEdge[] = graph.edges.map((edge) => {
+ const isHighlighted = highlightedEdgeIds.has(edge.id);
+ const hasAnyHighlight = highlightedEdgeIds.size > 0;
+ const colSource = nodeColMap.get(edge.source) ?? 0;
+ const colTarget = nodeColMap.get(edge.target) ?? 0;
+
+ let sourceHandle = "right-source";
+ let targetHandle = "left-target";
+
+ if (colSource < colTarget) {
+ sourceHandle = "right-source";
+ targetHandle = "left-target";
+ } else if (colSource > colTarget) {
+ sourceHandle = "left-source";
+ targetHandle = "right-target";
+ } else {
+ sourceHandle = "right-source";
+ targetHandle = "right-target";
+ }
+
+ return {
+ id: edge.id,
+ source: edge.source,
+ target: edge.target,
+ sourceHandle,
+ targetHandle,
+ type: "default",
+ animated: isHighlighted,
+ style: {
+ stroke: "#ffffff",
+ strokeWidth: isHighlighted ? 3 : 2.2,
+ opacity: hasAnyHighlight && !isHighlighted ? 0.2 : 0.95
+ }
+ };
+ });
return { nodes, edges };
}
@@ -292,8 +331,7 @@ function GraphCanvas({ graph, highlightedNodeIds, highlightedEdgeIds, onSelect }
proOptions={{ hideAttribution: true }}
>
<Background color="#27272a" gap={18} />
- <Controls showInteractive={false} />
- <MiniMap pannable zoomable />
+ <Controls position="bottom-left" showFitView={false} showInteractive={false} />
</ReactFlow>
</div>
);
@@ -354,6 +392,13 @@ export default function GraphPage({ campaignId, onCampaignIdChange }: {
}) {
const queryClient = useQueryClient();
const campaigns = useQuery({ queryKey: ["campaigns"], queryFn: api.campaigns });
+
+ useEffect(() => {
+ if (!campaignId && campaigns.data && campaigns.data.length > 0) {
+ onCampaignIdChange(campaigns.data[0].id);
+ }
+ }, [campaignId, campaigns.data, onCampaignIdChange]);
+
const graphQuery = useQuery({ queryKey: ["graph", campaignId], queryFn: () => api.graph(campaignId), enabled: Boolean(campaignId) });
const pathsQuery = useQuery({ queryKey: ["attack-paths", campaignId], queryFn: () => api.attackPaths(campaignId), enabled: Boolean(campaignId) });
const [activeTab, setActiveTab] = useState<"Entities" | "Attack Paths" | "Ingest">("Entities");
diff --git a/frontend/src/styles.css b/frontend/src/styles.css
index b3ad6c7..b5cdcec 100644
--- a/frontend/src/styles.css
+++ b/frontend/src/styles.css
@@ -1966,11 +1966,88 @@ textarea.field {
background: #09090b;
}
-.graph-canvas .react-flow__controls,
-.graph-canvas .react-flow__minimap {
- border: 1px solid #27272a;
- border-radius: 6px;
- background: #121215;
+.graph-canvas .react-flow__controls {
+ box-shadow: 0 4px 16px rgba(0, 0, 0, 0.6);
+ border: 1px solid rgba(255, 255, 255, 0.14);
+ border-radius: 8px;
+ background: rgba(18, 18, 21, 0.92);
+ backdrop-filter: blur(8px);
+ padding: 3px;
+ display: flex;
+ flex-direction: column;
+ gap: 2px;
+}
+
+.graph-canvas .react-flow__controls-button {
+ width: 28px !important;
+ height: 28px !important;
+ line-height: 28px !important;
+ background: transparent !important;
+ border: none !important;
+ border-radius: 6px !important;
+ color: #e4e4e7 !important;
+ fill: #e4e4e7 !important;
+ display: flex !important;
+ align-items: center !important;
+ justify-content: center !important;
+ padding: 0 !important;
+ transition: background-color 120ms ease, color 120ms ease, transform 100ms ease;
+}
+
+.graph-canvas .react-flow__controls-button:hover {
+ background: rgba(255, 255, 255, 0.12) !important;
+ color: #ffffff !important;
+ fill: #ffffff !important;
+}
+
+.graph-canvas .react-flow__controls-button:active {
+ transform: scale(0.95);
+}
+
+.graph-canvas .react-flow__controls-button svg {
+ max-width: 13px !important;
+ max-height: 13px !important;
+ fill: currentColor !important;
+}
+
+/* Cyber Patch Socket Handles */
+.graph-canvas .ares-flow-handle {
+ width: 7px !important;
+ height: 7px !important;
+ background: #ffffff !important;
+ border: 1.5px solid #09090b !important;
+ border-radius: 50% !important;
+ box-shadow: 0 0 5px rgba(255, 255, 255, 0.9), 0 0 8px rgba(255, 255, 255, 0.45) !important;
+ pointer-events: none !important;
+ transition: transform 120ms ease, box-shadow 120ms ease;
+}
+
+.graph-canvas .ares-flow-node:hover .ares-flow-handle {
+ box-shadow: 0 0 8px #ffffff, 0 0 14px rgba(255, 255, 255, 0.95) !important;
+ transform: scale(1.2);
+}
+
+/* Connecting White Cables */
+.graph-canvas .react-flow__edge-path {
+ stroke: #ffffff !important;
+ stroke-width: 2.2px !important;
+ stroke-linecap: round;
+ fill: none !important;
+ filter: drop-shadow(0 0 3px rgba(255, 255, 255, 0.9)) drop-shadow(0 0 8px rgba(255, 255, 255, 0.45));
+}
+
+.graph-canvas .react-flow__edge.animated .react-flow__edge-path {
+ stroke-dasharray: 6 4 !important;
+ animation: aresCableSignal 1.8s linear infinite !important;
+}
+
+@keyframes aresCableSignal {
+ from {
+ stroke-dashoffset: 20;
+ }
+ to {
+ stroke-dashoffset: 0;
+ }
}
.ares-flow-node {