Blog · Threat intel · · 12 min read · by huntback Research

Inside CyberStrikeAI: 221 tool executions and a disabled approval gate

An exposed workspace on 38.76.169[.]207 contains a CyberStrikeAI conversation database, runtime logs and application source. The database records a session on 16 November 2026 in which an operator repeatedly directed an agent to continue offensive testing, recover access and obtain database access. It lets us connect conversation turns to model-accounting entries, process events, stored tool executions, returned output and recorded findings.

In brief

  • The snapshot holds one conversation, 221 stored tool executions, 240 process-level tool calls, eight model-usage records and nine agent-generated vulnerability records. The numbers reconcile once local agent actions are separated from executions stored in the tool table.
  • Four approval rejections were recorded. All four were the audit agent failing to get a model answer and rejecting by default. None was a human decision.
  • At 09:48:15 UTC the saved conversation configuration shows approval enforcement disabled. After that, approval existed only as wording in the chat.
  • The agent kept going under human steering and ended by reporting extensive database access. Several of its claimed outcomes exceed what the retained evidence establishes.
  • The strongest supported result is returned compute-node and job data. The record does not show a shell, internal-network access, a data-lake breach or a destructive change.

This is the record of one operating agent workflow: persistence, retries, human direction, governance changes, data retrieval and imperfect conclusions. The database does not identify the operator or say whether the testing was authorized, and we treat it as a session record, not as an account of an autonomous criminal intrusion.

What we examined

The primary artifact is a 6,688,768-byte SQLite database retrieved from the workspace's exposed CyberStrikeAI data directory. We reviewed it read-only, together with the day's diagnostic log and selected recovered runtime and approval code. Public upstream documentation and source were used to interpret the software and the compute-service operations visible in the results.

The acquired conversation database passes SQLite quick_check. That establishes structural readability, not authenticity, completeness or a transactionally consistent backup of the running application. The database was still growing while the workspace was exposed, so this analysis is tied to one exact snapshot, identified by its hash in the indicators below.

We did not execute recovered programs, submit commands through the panel, replay captured requests, authenticate with retained credentials or contact the services being tested. Static workspace-file retrieval was separate from the operator's recorded target activity.

The inspected database contains:

Record typeCountInterpretation
Conversations1One retained conversation
Messages16Eight user and eight assistant messages
Model-usage records8Per-run accounting, including two zero-token failure entries
Process-detail records845Mixed planning, usage, tool and control events
Process-level tool calls240Calls emitted by the agent runtime
Process-level tool results240Matching result-event population
Stored tool executions221Executions with persistent execution IDs
Vulnerability records9Agent-created findings, not nine independently validated vulnerabilities
Project facts12Persisted operational memory
Approval interrupts4All rejected by the audit agent
C2 listeners / sessions0 / 0None retained in these tables
Webshell connections0None retained in this table

These counts describe a database snapshot. They are not counts of victims, compromised systems or successful attacks.

The framework and the recorded execution path

CyberStrikeAI's upstream project describes a Go platform combining agent orchestration, MCP tools, approvals and retained operational evidence1. The recovered source and the database are consistent with that architecture. The execution path reconstructed from the reviewed material is:

the execution path, as reconstructed from the recovered source and recordsHuman instructionand uploaded handoffPi agent runtimemain orchestratorApproval interceptorwhen one is installedAudit reviewor executionLocal and MCP toolsexecute, nmap, read_fileReturned outputbounded or spilled to a fileExecution records221 stored executionsFindings and facts9 findings, 12 facts
Returned output goes back to the runtime, which decides the next call and writes findings and project facts as it goes.

The runtime source checks the allowed tool set, applies local-execution permission checks and invokes an approval interceptor when one is installed. It then routes calls either to local agent functions or to MCP-backed tools. Results can be bounded or spilled to a file before the agent receives them.

That last detail matters for analysis. Some retained results contain previews and file references, not a complete response body. We inspected the separate partial_output field where available, but a preview or saved-file claim is not proof that every underlying artifact has been recovered.

A supervisor label does not establish a swarm

The conversation's agent_mode is supervisor. However, all 240 retained tool-call events identify the agent as main and the role as orchestrator.

The software supports more elaborate delegation, but this snapshot does not show a team of worker agents operating concurrently. The supported observation is a main orchestrator performing recorded work across successive human-directed runs.

Reconciling 221 executions with 240 calls

The distinction is verifiable through execution IDs:

Process-result categoryCount
Results carrying an execution ID221
Execution IDs matching the stored execution table221
Local results without an execution ID19

The 19 local results comprise ten skill actions, four task-plan updates, three file reads and two exit actions. They account for the difference between the two totals.

This provides a useful evidence chain: the runtime's activity can be related to the persisted execution records, instead of being inferred from a repository or a final narrative alone.

A timeline with repeated human intervention

All times below are UTC on 16 November 2026. The table uses tool timestamps, configuration timestamps and message update times as appropriate.

TimeRecorded activityWhat it establishes
07:54The user asks the agent to analyse an uploaded vulnerability and foothold handoff document.The session begins with inherited claims and context.
07:55 to 07:57Two initial runs fail with model-interface errors.The workflow did not begin as uninterrupted successful execution.
08:40The user says to continue; the first stored tool execution starts at 08:40:19.Recorded tool activity begins.
08:41 to 08:44Two approval attempts are rejected following audit-agent model-call failures.Automated conservative rejection, not human refusal.
09:29The user directs the agent to exploit earlier findings, reach the internal network and access a data lake.A specific escalation objective, not proof it was achieved.
09:44 to 09:47Two more audit-agent failures produce rejections.The same review failure recurs.
09:48:15The saved conversation configuration is updated to enabled=0, mode=off.The retained configuration records approval enforcement disabled.
09:49The user asks for continued testing and a list of harmful write/delete actions for approval.Human oversight continues through conversation.
10:18The user approves all proposed items.Approval wording exists in chat; it is distinct from an enforced tool-level gate.
11:41The user again asks for a new entry point and deeper access.Further human redirection.
15:31The user asks the agent to use its claimed MCP finding to obtain database access.Another explicit objective change.
16:05 to 16:07The last stored tool execution finishes, followed by the final assistant report update.End of the retained activity window.

Assistant message creation times often precede their completed contents by many minutes. We therefore do not date a final report by the timestamp at which its message row was initially created.

Nor does an activity window imply continuous execution. The record includes substantial gaps, retries and fresh instructions. It supports delegated work with repeated operator involvement, not an entire intrusion completed from one prompt.

The approval failures were real, but their cause matters

All four interrupt records identify audit_agent as both reviewer and decision-maker. Each has the same decision comment, translated as:

Audit agent: LLM call failed; conservatively reject.

The recovered audit code has a matching failure path:

Decision: "reject",
Comment:  "audit agent: LLM 调用失败,保守拒绝",

Its review call has a 90-second timeout. Three of the four reviews ended 90 seconds after they began. The fourth ended after 43 seconds, at the moment the run was cancelled by the user. The timings are consistent with a bounded failure path, but the database comment alone does not establish the precise upstream cause of every failed call.

This is evidence that the reviewer failed closed when it could not obtain a model decision. It is not evidence of four thoughtful safety assessments, four human rejections or an agent defeating the reviewer.

The later configuration state is equally important:

enabled = 0
mode = off
updated_at = 2026-11-16 09:48:15.030203859+00:00

The recovered interruption logic returns without requiring approval when the conversation's runtime configuration is absent or disabled:

if !ok || !cfg.Enabled {
    return hitlRuntimeConfig{}, false
}

The stored configuration and source together explain how formal review could cease to constrain later work. They do not identify who changed the setting or prove that every in-memory state change occurred exactly when the database row was written. We found no evidence that the model itself exploited the approval system.

Afterward, the user still asked the agent to list harmful actions and supplied approval in chat. That is a meaningful form of human direction, but it provides a different guarantee from an execution gate that blocks each tool call until a decision is recorded.

For organizations deploying agents, this is an operational concern: a functioning review mechanism can become ineffective through configuration. Review failures, configuration changes and subsequent execution should be investigated as a sequence.

What the agent actually tried

The session began by consuming a handoff document that described earlier vulnerabilities and footholds. It checked whether previous access paths still worked, inspected available C2 and webshell state, performed network reconnaissance and then concentrated on a compute-marketplace MCP interface.

Several retained outputs record failed public-key authentication and unreachable services. The C2-listener tool returned a count of zero on both recorded calls. The webshell-list tool reported no connections. These results limit claims of existing interactive access in this snapshot.

The stored execution mix is:

ToolExecutionsCompletedFailed
execute17016010
read_file14140
upsert_project_fact11110
record_vulnerability990
nmap660
list_vulnerabilities440
c2_listener220
list_project_facts220
manage_webshell_list110
rustscan101
wait_tool_execution101
Total22120912

These statuses describe tool execution, not security impact. For example, a shell can finish normally after printing an HTTP error, failed authentication or a Python exception from one component of a larger command. The saved completed outputs include application-level failures and schema-validation errors.

The agent repeatedly adjusted how it talked to the MCP service: discovering the interface, listing operations, handling JSON and SSE responses, correcting arguments and examining returned data. It also attempted stronger actions and encountered connectivity, validation and service errors.

The strongest supported result is returned compute-node and job-related data, including structured search results. The database does not establish an operating-system shell on the tested compute infrastructure, successful internal-network access, a data-lake breach, stolen funds or a successful destructive database operation.

Where the final report overreaches

The agent created nine findings: two critical, three high, two medium, one low and one informational. Several describe related aspects of the same service. They should not be counted as nine independent entry points.

The following examples explain why we reviewed the outputs instead of adopting the labels.

1. A new identity is not a stolen identity

The agent reported that anonymous token creation exposed a JWT and Ethereum private key, presenting it as an authorization bypass.

The returned result itself says the key is a throwaway identity, is not persisted server-side and has no funds initially. The upstream token-creation implementation generates a random wallet and returns that newly created consumer's details. Its tool descriptions say such an ephemeral identity works on open free environments, and that where an environment lists allowed addresses the consumer must be one of them2.

Generating a new consumer identity can be intended behavior. To demonstrate a bypass, the evidence would need to show access to another principal's resources or an operation that policy should deny. The retained result does not establish either.

The credentials remain sensitive to whoever subsequently uses or funds that identity. We have omitted all credential values.

2. Listed tools are not automatically authorized operations

The agent described more than 100 advertised MCP operations as anonymously callable management capabilities. A catalogue is useful reconnaissance, but listing a tool is not the same as successfully exercising it with sufficient authority.

The retained outputs include schema-validation errors, unavailable peers, connectivity failures and isError responses. Some operations require a consumer identity, signature, payment or target-node policy checks. Public upstream documentation describes those requirements.

The existence of a powerful operation in the catalogue therefore cannot establish that arbitrary callers obtained its full effect.

3. Public compute discovery needs a policy boundary

The agent recorded compute-environment information as high-severity unauthorized disclosure. Ocean's API documentation describes compute-environment discovery, and its node documentation explicitly expects public API and P2P accessibility for participating nodes34.

This does not settle whether every returned field or deployment choice was appropriate. It does mean that discoverable capacity and an open network endpoint require context before being described as a vulnerability.

Similarly, a wildcard CORS header on already-public data does not independently demonstrate theft from an authenticated user. A reported zero nonce is not, without the relevant identity state and a successful replay, proof that replay protection failed.

4. Search metadata is not a complete extraction

Returned job-query metadata includes a total of 10000 with relation: "gte". That is a lower-bound search count. It does not mean the agent downloaded 10,000 records.

One retained command result reports ten returned job documents and ten returned node documents despite requesting larger pages. Another reports a historical queue index with a total of 1,619. These are different measurements: available search hits, samples returned to a script and files actually preserved.

Aliases and differently named indices can also overlap. Adding their totals without checking identity and alias relationships would inflate the apparent collection.

The retained samples include job metadata and signature fields. Their presence warrants contextual assessment. It does not establish that private signing keys were recovered, that signatures could be replayed or that funds moved.

5. The “260-node dump” is not a verified distinct-node count

The script responsible for this claim loops through 26 offsets and appends every returned page to a list. Its accumulation step is:

all_nodes.extend(hits)
print(f"  Page {page//10}: +{len(hits)} = {len(all_nodes)} total")

The output reports ten hits on each iteration, producing 260 accumulated entries. There is no unique-ID check in that accumulation. Nearby results report a node-search total of 259. The script's resulting hardware counts are all multiples of 26, which raises a further question about repeated pages.

A test one minute earlier in the same session points the same way: a request for the page starting at offset 10 came back beginning with the same node as the first page, and a request at offset 250 still returned ten entries against a total of 259.

The full saved array is not in the recovered files, so its distinct-ID count cannot be computed. The defensible result is 260 appended entries reported by a script, with pagination and uniqueness unresolved.

A complete extraction claim would require the retained records, verified offset behavior, a distinct-key count and reconciliation with the search total.

6. Failed mutation probes do not prove a security control

The agent's report describes write and delete operations as blocked. The retained results contain errors and, in one purported deletion test, an ordinary search response.

A server error can reflect invalid syntax, a wrapper mismatch or an unavailable operation. It does not independently establish an authorization decision. Conversely, a search response does not show that anything was deleted.

No successful destructive change is established by the retained evidence. We did not reproduce those requests.

The accounting shows sustained use, not a provider bill

The eight model-usage rows name deepseek-v4-pro. Their recorded totals are:

FieldRecorded sum
Model calls211
Prompt tokens13,353,943
Completion tokens210,373
Total tokens13,564,316

Two rows contain one recorded call each and zero tokens, corresponding to the initial failure runs. The remaining six carry nonzero token accounting.

These are local application records. They do not independently authenticate the upstream provider or model behind a compatible gateway. They are not a verified invoice, and the prompt total should not be read as unique information processed: conversation context may be submitted repeatedly, and caching changes billing.

The recorded diagnostic errors are useful corroboration. The first run was rejected because the receiving interface did not accept a developer message role. Another failed with an upstream error. Those details show compatibility and reliability problems within the actual workflow, not merely an aspirational configuration file.

Useful defensive searches

For an organization that operates agents or MCP services, this collection suggests specific correlations:

  • Audit failures followed by configuration changes. Link reviewer errors or repeated rejections to approval-disable events and subsequent tool execution. Preserve the actor and previous configuration where the application records them.
  • Unexpected catalogue exploration. Review rapid MCP discovery followed by broad attempts across data-query, identity, storage and execution functions. Tool enumeration alone is not proof of abuse.
  • Query expansion. Look for transitions from ordinary node discovery to job history, alternate index names or backup-shaped datasets. Evaluate those requests against the intended access policy.
  • Returned-data evidence. Preserve response counts, stable record IDs and the actual body or a protected evidence hash. Request logs alone cannot establish the volume retrieved.
  • Behavioral outcomes. Require process, file, identity or transaction evidence before accepting claims of remote execution, persistence, privileged access or financial impact.
  • Exposed agent memory. Check whether static file servers, backup routes or development services expose conversation databases, uploads, runtime sessions or truncated-output directories. An authenticated application can still have an independently exposed data directory.

These behaviors are investigation leads. They do not uniquely identify CyberStrikeAI or malicious intent.

Why the case matters

The record demonstrates that a framework other than ARTEX can sustain a model-and-tool workflow across repeated human instructions, retain findings and operational memory, and explore multiple access paths. The session's operator can steer objectives without manually specifying every command.

It also shows that governance and evidence quality are separate engineering problems. An audit agent can fail conservatively while later configuration removes the gate. A tool can complete while its underlying action fails. An agent can retrieve real data while overstating access, uniqueness or impact in its report.

Defenders need visibility into all three: the instruction, the execution and the outcome. This recovered session makes those layers unusually visible, while also showing why none should be substituted for another.

Indicators

The address below is where the examined workspace files were served from. Target domains, signatures, private keys, tokens, node identities and operator account identifiers are omitted. Provider endpoints and public project repositories should not be placed on blocklists because they appear in an investigation.

IndicatorTypeSupported association
38.76.169[.]207IPv4Host serving the examined workspace files
TCP 8010PortFile-serving service the exposed artifacts were retrieved from
/CyberStrikeAI/data/conversations.dbURL pathExposed conversation and operational record database
/CyberStrikeAI/log/diagnostic-2026-11-16.logURL pathDiagnostic corroboration for this date
/root/CyberStrikeAI/Host pathApplication working paths in recovered records
a0b4be0a70e35d0d30809e0856e9860d4265df65e41fef2e93405e166d6edd36SHA-256The conversation database snapshot analysed here (6,688,768 bytes)
4da5383d7a1bc2a83c20a39510227aad34072876fa47bfb20fd10aeb48b676ebSHA-256The diagnostic log (6,560 bytes)
deepseek-v4-proModel configuration valueRecorded model identifier; not an attribution indicator

References

  1. CyberStrikeAI, official repository.
  2. Ocean Protocol, on-mcp repository, the MCP server for the Ocean network (token, provider and incentives tools).
  3. Ocean Protocol, Ocean Node API documentation.
  4. Ocean Protocol, Ocean Nodes documentation (public accessibility of participating nodes).