acceptodds
Under review as a conference paper at ICLR 2027

Beyond Direct Access: Resource Hijacking in LLM Agents

Abstract

Large language model agents are increasingly connected to high-value resources, including external APIs, GPUs and servers, and workflows such as deployment and approval. Existing agent security research mainly focuses on attacks against information and agent behavior, while the high-value resources available to agents have received less attention as attack targets themselves. To our knowledge, we are the first to identify and systematically study agent resource hijacking, in which attackers induce agents to use high-value resources for their own goals without directly obtaining those resources or their credentials. To study this threat, we introduce ResourceHijackBench, an executable benchmark and automated case-generation pipeline that covers six categories of high-value resources. It contains 300 attack scenarios and 900 attack prompts, and each case runs in an isolated local environment that records actual resource use. Resource hijacking remains effective across four model backends, with average attack success rates ranging from 70.0% to 89.6%, and it also appears across two agent harnesses, with average ASRs of 84.1% on OpenClaw and 72.3% on Codex. In paired comparisons, resource hijacking achieves ASRs that are 62.4 to 84.0 percentage points higher than direct resource acquisition across the four model backends. We also conduct real-world experiments that demonstrate the practical effectiveness of resource hijacking. Among the three existing defenses we evaluate, the lowest average ASR is still 55.1%. We further propose ResGate, a pre-execution resource authorization defense that combines model-based resource-use extraction with deterministic policy enforcement based on trusted requester identity metadata, reducing the average ASR on OpenClaw to 23.6%. These results show that preventing direct access alone is not enough to protect resources that agents can still use on an attacker’s behalf, and that explicit resource authorization can help reduce this risk.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Large Language Model Agents, Agent Security, Resource Hijacking

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_s87tOpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

It introduces a resource hijacking benchmark, ResourceHijackBench, and a defense, ResGate.

Critical strengths

None

Critical weaknesses
  1. The authors didn't define who the attacker is, what they can access, and how the attack prompt goes into the agent's context. A clear threat model is necessary for a security paper.
  2. Based on the vague description, it seems there is a setting that directly asks the agent to use the resource in the user prompt. If so, that is exactly what the agent was deployed to do, and it would not be expected to refuse. Some people would argue that it should comply. The authors should justify under what conditions the agent should refuse and what conditions it should not.
  3. It would be helpful to include some complete task samples covering all three attack settings (direct, implicit, persistent-context).
  4. The authors could also report results separately for each of the three settings.
  5. The later part, ResGate, also introduces a requester identity. How does it relate to the benchmark, and where does the authorization come from? Do the benchmark tasks also include an authorization scope, and does the agent have access to it?

Having the complete prompts and sample tasks, along with a clear definition of the threat model, would be very helpful to understand this work.

Questions for authors

N/A

3 comments
AuthorsOpenReview ↗

Rebuttal by Authors

Thank you for your valuable review and suggestions. Below we respond to the comments in Weaknesses (W) and Questions (Q).


W1: Threat model.

Thank you for the comments. The attacker is a requester who can interact with the agent and submit task requests but does not have permission to use the target resource, and the attack prompt enters the agent’s context through a user request. The agent itself has permission to access the target resource, and the attacker tries to induce it to use the resource on their behalf without directly obtaining the resource or its permissions. We will clarify this threat model in the revised version.

W2: When the agent should refuse a request.

A requester may have permission to ask the agent to perform some functions, but this does not mean they are allowed to use every resource the agent can access. The agent should carry out requests within the requester’s permissions and refuse requests outside them, even when the requested operation itself is a normal function. Resource hijacking does not contradict the fact that the requester lacks this permission, because the agent still performs the resource operation and the requester does not gain the corresponding permission.

W3: Complete task samples.

We apologize for the confusion caused by the description of the experimental settings. “Direct, implicit, and persistent-context” in Table 18 comes from an earlier experimental setup that was later dropped, but we missed updating this text when we updated the experiments, and the three settings in the current experiments are not these three. We will correct this wording and add complete prompts and task samples for the actual settings in the revised version.

W4: Results by attack setting.

The three old settings above do not apply to the current experiments. We will clearly describe the three settings actually used and make the related experimental descriptions and results consistent in the revised version to avoid confusion caused by the old categories.

W5: Identity and authorization information.

The authorization policy is set in advance by the resource owner and states which functions each requester is allowed to ask the agent to perform. The trusted requester identity is supplied by the evaluation environment through metadata to simulate an authenticated session, rather than taken from identity claims in the request body. The baseline agent already receives explicit owner restrictions and a trusted requester identity, so the evaluation tests whether resource hijacking can still occur when the agent has authorization information. We will add these setup details in the revised version.

Thanks for the response and for promising the changes in the revised version. Do you plan to make these updates during the rebuttal period?

AuthorsOpenReview ↗

Follow-up Rebuttal by Authors

Thank you for following up. We have updated the manuscript during the rebuttal period, and the revised version now includes the clarifications and additions discussed in our response.

Reviewer_JGyQOpenReview ↗
Rating
2
Confidence
3
Informativeness
1
Presentation
3
Soundness
2
Read review
Paper summary

The paper studies cases where an LLM agent refuses to disclose a credential or transfer access, but still uses the resource for a requester who is not authorized to use it. The authors introduce ResourceHijackBench, an executable benchmark covering six resource categories, and propose ResGate, which extracts resource use from the initial request and checks it against a fixed policy using a trusted requester identity.

Critical strengths
  1. Protecting a credential and controlling how the resource behind it is used are different goals. Keeping a key secret does not answer whether a requester may have the agent call the corresponding API.
  2. The benchmark records tool calls and environment state, and reports normal-task success alongside attack success, so both what the agent actually did and the cost of each defense are visible.
  3. ResGate separates natural-language interpretation from the authorization decision, which makes the decision rules explicit and easy to inspect.
Critical weaknesses
  1. Authorization conditions. The paper does not say whether the baseline agent receives any owner restriction or trusted requester identity. If it does not, a high ASR shows that the deployment lacks authorization controls, not that the agent violated a policy it was given. The evaluation should separate these cases and include examples where an explicit owner policy and a trusted identity are present and the agent still violates them.

  2. Direct acquisition vs. hijacking. Using the same resource and tools does not mean both goals are feasible. An agent may call an API through a wrapper with no way to read the key, or submit a GPU job with no way to transfer access. Direct acquisition can fail because of a refusal, a missing interface, or an execution error, but the failure analysis only covers hijacking. A breakdown of direct-acquisition failures, and paired results on cases feasible in both modes, are needed to interpret the gap.

  3. Success judgments and real-world cases. Please report how many cases were decided by the LLM judge rather than by rules, and whether those decisions were checked independently. The two real-world case studies show only requests and replies, without tool-call or usage records. The Codex runs use approval_policy=never and danger-full-access, and the conclusions should state this.

  4. Identity setup in the ResGate evaluation. Attack requests carry no authorization, while every normal task comes from ops-owner-01, which has all permissions on all categories. A filter that only allows ops-owner-01 would block the attacks and pass all normal requests without identifying any resource or action, so the evaluation does not show what ResGate adds. All six categories also share the same policy, so switching between valid categories does not change the decision. A more informative test set would include legitimate anonymous requests, and both legitimate and unauthorized requests from the same limited user. It is also unclear whether Prompt Defense and the other baselines receive the same identity and policy information as ResGate.

  5. Scope and timing of the check. The policy uses identity, category and action type, but not purpose, resource instance or project, so it cannot express a rule such as "GPU use for Project A but not Project B". The extractor also sees only the current user request, while the benchmark includes implicit and persistent-context attacks. Results by attack setting would show what the entry check actually covers. The remaining 58.7% ASR on Knowledge needs an explanation.

  6. Evaluation of the defense. ResGate's attack-side ASR is computed by filtering the 750 attacks that succeeded in the baseline, not by rerunning the attacks with the defense in place, while normal tasks are actually executed. This reuse is reasonable for a pre-execution filter if allowed requests run under unchanged conditions, but the paper should state this and explain whether the comparison with other defenses uses the same protocol and denominators.

Questions for authors
  1. What owner restrictions and identity information, if any, does the baseline agent receive at runtime?
  2. Of the failed direct-acquisition attempts, how many were refusals, missing interfaces, or execution failures?
  3. What does the "allow ops-owner-01 only" rule achieve on the current test set, and what identity and policy information did the other defenses receive?
  4. How does ResGate perform under each attack setting, and through which allow path did the remaining Knowledge attacks pass?
  5. Were the other defenses evaluated with new runs or with reused trajectories?
2 comments
AuthorsOpenReview ↗

Rebuttal by Authors [1/2]

Thank you for your valuable review and suggestions. Below we respond to the comments in Weaknesses (W) and Questions (Q).


W1 & Q1:

Thank you for the comment. We would like to clarify that the baseline agent already receives explicit owner restrictions and a trusted requester identity, so our evaluation tests whether resource hijacking can still occur when the agent has identity information. The original paper did not explain these conditions clearly, and we will add these setup details in the revised version.


W2 & Q2:

Thank you for the suggestion. We added an analysis of direct-acquisition failures: among the failed cases, 78.2% were safety refusals, 16.0% involved the agent agreeing to the request but not actually carrying it out, and 5.8% stopped partway through execution. This shows that safety refusal is the main reason for direct-acquisition failures.

To rule out differences in technical feasibility, we also ran paired experiments with DeepSeek-V4-Flash on Condition resources for APIs and Material and Energy resources for GPUs. All these experiments were run under conditions where both attack modes were technically feasible: the agent had the tools and interfaces needed for direct acquisition, so there were no cases where direct acquisition was technically impossible because the agent had no way to obtain the resource. The results are shown below:

ModelDirect Acquisition ASR (%)Resource Hijacking ASR (%)Gap (pp)
DeepSeek-V4-Flash6.882.1+75.3

Under conditions where both modes were technically feasible, the success rate of resource hijacking was still 75.3 percentage points higher than that of direct acquisition. We will add the failure analysis, paired results, and corresponding technical feasibility details to the revised version.


W3:

Thank you for the reviewer’s suggestion. We clarify that all cases are first checked by rules, and an LLM helps judge the meaning of actions when the rules cannot determine it. For example, in a GPU training scenario, rules can detect whether a GPU was used, but this event alone does not show whether it was used for the training task requested by the attacker. We therefore use an LLM together with the task and execution context to help determine whether the resource use matches the attack goal of that case.

During evaluation, an LLM was used to assist in judging 236 cases, accounting for 26.2% of all cases. To check the reliability of the automated judgments, we also arranged a manual review by three experts: two experts first judge the same case separately, and if they disagree, a third expert makes the final decision. Using the final manual review decisions as the reference, the automated judgments achieved an accuracy of 98%. We will add the judgment process, the number of cases judged with LLM assistance, and details of the manual review in the revision.

For the Codex experiments, we used approval_policy=never and danger-full-access, which matches our threat model: the agent itself has permission to use the target resources, while external requesters do not. We study whether external requesters can get the agent to use its existing resource permissions to carry out unauthorized tasks. The experiments therefore allow the agent to perform resource operations so that we can assess whether it can distinguish its own resource access permissions from the requester’s authorization to use those resources. We will clearly state this configuration and the corresponding threat model in the experimental setup and conclusions.

AuthorsOpenReview ↗

Rebuttal by Authors [2/2]

W4 & Q3:

Thank you for the suggestion. We first want to clarify the threat model: a requester may have permission to interact with the agent or carry out other tasks, but not permission to use the target resource, while the agent has permission to access that resource. The attacker does not need to obtain or change their own resource permissions, but instead induces the authorized agent to use the resource to carry out tasks for them, which is the agent resource hijacking we study. This does not contradict the fact that the requester lacks this permission, because the agent still performs the resource operation and the requester does not gain the corresponding permission.

We understand the reviewer's concern about the identity setup: if all normal requests come from a user with all permissions, while all attack requests come from unauthorized users, checking identity alone could distinguish the two groups. To test whether ResGate adds value beyond simple identity filtering, we added an experiment with the same requester who has limited permissions, testing both tasks within their permissions and requests involving resources they are not authorized to use. The results are shown below:

Request typeResGate allow rate (%)
Tasks within the same requester's permissions89.0
Requests from the same requester to use resources without permission21.6

With the requester identity held the same, ResGate allowed 89.0% of authorized tasks and blocked 78.4% of unauthorized resource requests. Allowing or denying all requests based only on identity cannot distinguish these requests; these results show that ResGate can make different decisions based on whether a specific request falls within the requester's permissions.

We will add this experiment, the permission settings, and the identity and policy information available to each baseline to the revised version.


W5 & Q4:

Thank you for the comments. First, the authorization policy states which functions each requester is allowed to ask the agent to perform, and ResGate checks whether a request falls within those permissions. The current implementation does not support further restrictions on the same function by project, purpose, or specific resource instance, and we will clarify the level and scope of the policy in the revised version.

Regarding the timing of the check, ResGate checks the current user request before execution. We apologize for the confusion caused by the description of the experimental settings: “Direct, implicit, and persistent-context” in Table 18 comes from an earlier experimental setup that was later dropped, but we missed updating this text when we updated the experiments. The three attack settings in the current experiments are not these three, and we will correct this wording in the revised version and clearly describe the actual settings and what the check covers.

The Knowledge category still has an ASR of 58.7%, mainly because the boundaries of these resources are hard to identify clearly in natural language requests. This makes it difficult for ResGate to tell whether a request involves the use of restricted knowledge, which affects the following authorization check. We will add this explanation and state this limitation in the revised version.


W6 & Q5:

Thank you for the reviewer’s suggestion. The reviewer’s understanding of our evaluation process is correct: on the attack side, we applied ResGate to the 750 evaluable cases that succeeded in the baseline and reused the baseline execution results for cases that passed the filter, without rerunning these attacks. These 750 cases form the subset of successful attacks checked by the filter, while the denominator for post-defense ASR remains the total number of evaluable cases in the corresponding category, consistent with the main results table.

This reuse follows ResGate’s design as a pre-execution filter: it only decides whether to allow a request and does not change the allowed request, tools, environment, or later execution conditions. Normal tasks are actually run to assess the defense’s effect on authorized task completion.

The other defenses were evaluated with new runs, and their ASRs are shown below:

DefensePrompt DefenseAgentDoGLlamaFirewall
ASR (%)58.280.753.2

We will clarify the conditions for reusing results, as well as the evaluation process and ASR denominator for each defense, in the revision.

Reviewer_BgNLOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper indentifies and studies the resource hijacking attack in LLM agents, where the attackers induce agents to use resources on their behalf without directly obtaining the credentials/resources. It introduces ResourceHijackBench, a benchmark containing 300 scenarios and 900 attack prompts across six resource categories. This paper also proposes the defense method ResGate, which combines LLM-based resource-use extraction with deterministic authorization checks. Experiments on OpenClaw and Codex demonstrate the effectiveness of the resource hijacking attack. It also shows the proposed defense is effective.

Critical strengths
  • The identified attack is practical. Protecting credentials alone might not be sufficient in real usage.

  • The proposed benchmark includes different practical scenarios and catagories. It also covers modern agent harnesses such as OpenClaw and Codex.

  • This paper is well written.

Critical weaknesses
  • The proposed method ResGate is relatively simple, and its robustness against adaptive attacks is not established. The defense relies on an LLM to extract resource use from the initial request before applying deterministic authorization checks. An attacker aware of this design could target extraction errors or induce resource use that becomes apparent only during execution. It's better to include the evaluation and analysis of the adaptive attacks.

  • The novelty and the claim of identifying a new security problem needs stronger justification. Prior work Zuvic et al. already studies how attackers can induce agents to perform unauthorized operations without obtaining their credentials. Although this paper cites this work, it does not sufficiently clarify what fundamentally new failure mode resource hijacking introduces. The proposed taxonomy and benchmark are useful contributions, but they do not by themselves establish a new security problem.

Zuvic et al., Capability Gates Are Not Authorization: Confused-Deputy Failures in LLM Agent Frameworks. arXiv:2606.28679

Questions for authors

see above

2 comments
AuthorsOpenReview ↗

Rebuttal by Authors [1/2]

Thank you for your valuable review and suggestions. Below we respond to the comments in Weaknesses (W) and Questions (Q).


W1:

Thank you for the reviewer’s suggestion. We would like to clarify that ResGate only returns a binary “allow/block” decision and does not provide the attacker with internal analysis, resource extraction results, or reasons for rejection. This limits the feedback available for adaptive attack optimization and helps limit targeted adjustments against the defense.

To test its performance under this feedback setting, we added adaptive attack experiments based on LLM feedback. In each round, we kept requests that had already passed and only revised the blocked requests. The results are shown below:

Adaptive attack iteration123456
Cumulative attack pass rate (%)23.624.125.626.226.626.6

After six rounds of evaluation, the cumulative attack pass rate increased from 23.6% to 26.6%, a rise of 3.0 percentage points, with no further increase observed in rounds five and six. These results show that, under the tested attack strategy and iteration budget, adaptive attacks achieved limited additional gains, while ResGate maintained good defense performance. We believe that the limited information provided by binary feedback is one reason for the limited improvement in attacks over repeated rounds.

AuthorsOpenReview ↗

Rebuttal by Authors [2/2]

W2:

Thank you for the comments. We agree that our novelty claim needs to be stated more precisely and will revise it. The two works look similar in common agent settings, but they focus on different issues, and we explain the differences in the following three points.

  1. The call itself can remain normal, while the resource is used for an unauthorized task. Zuvic (2026) studies how attackers use indirect prompt injection to induce an agent to generate tool calls with attacker-chosen arguments, and uses ScopeGate to check authorization for specific calls [1]. Our work focuses on how attackers can get an agent to use the owner's existing API, GPU, or account to complete tasks without changing protected resource identifiers. For example, an API call can complete normally and GPU training can run normally, while the resources serve a requester who has no permission to use them. The requester may have permission to interact with the agent or use some functions, but not permission to use the target resource. Our baseline agent already receives explicit owner restrictions and a trusted requester identity, so the experiments evaluate resource hijacking that still occurs when authorization information is available. The agent using a resource on the requester's behalf does not mean that the requester gains the corresponding permission.

  2. Through paired experiments, we quantify a large gap between protection against direct acquisition and protection against agent-mediated use. Zuvic's paired measurement compares naive and task-aligned attack framing [1], while our work compares direct resource acquisition with using the same resource through an agent. With the resource target, attacker goal, workflow, tools, environment, and model settings held fixed, direct acquisition achieves an ASR of only 3.4–7.6%, while resource hijacking reaches 70.0–89.6% (Table 5). The Moltbook case (Fig. 4) further illustrates this pattern: the agent uses its configured API to run the attacker's evaluation while stating that it will not share the API key "to avoid leaking it."

    To rule out the effect of differences in technical feasibility, we added paired experiments with DeepSeek-V4-Flash on Condition resources for APIs and Material and Energy resources for GPUs. Both attack modes are technically feasible, and the agent has the tools and interfaces needed for direct acquisition. The results are shown below:

    ModelDirect Acquisition ASR (%)Resource Hijacking ASR (%)Gap (pp)
    DeepSeek-V4-Flash6.882.1+75.3

    In addition, 78.2% of failed direct-acquisition cases are safety refusals. These results further show that the large gap is not caused only by missing interfaces for direct acquisition.

  3. The harm and the attacker are different. In Zuvic's payout-account change example, the harm comes from the attacker replacing the payout account with an unauthorized account [1]; in our API and GPU scenarios, operations can run normally exactly as requested, while the harm comes from using the owner's quota, compute, and money for unauthorized tasks. We further extend this resource-abuse objective to organizational identities, private knowledge, and communication resources. Traditional security research already refers to using others' system resources to complete tasks as resource hijacking, as in MITRE ATT&CK T1496 [2]; Sysdig's LLMjacking report describes attacks that use stolen cloud credentials to call models at the resource owner's expense [3]. In our setting, the requester gains resource use through an authorized agent without obtaining these credentials. In addition, Zuvic's threat model mainly focuses on attacker-controlled content that the agent reads [1], while our work also considers unauthorized requesters who submit tasks directly to the agent, such as non-owner members in Lark groups and external users who interact with agents on Moltbook.

We will add these comparisons, authorization conditions, and new experiments to the revised version to make the focus of our resource hijacking study and its relationship to prior work clearer.

References

[1] David Mellafe Zuvic. Capability Gates Are Not Authorization: Confused-Deputy Failures in LLM Agent Frameworks. [arXiv:2606.28679], 2026.

[2] MITRE ATT&CK. [Resource Hijacking (T1496).]

[3] Alessandro Brucato. [LLMjacking: Stolen Cloud Credentials Used in New AI Attack.] Sysdig, 2024.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of Paper Revision

Summary of Paper Revision

We thank all reviewers for their constructive feedback, and we have responded to each reviewer individually. We have also updated the manuscript and uploaded a Paper Revision with the following clarifications and additions:

  • Section 3.1\color{blue}{\text{Section 3.1}} (Page 4): added an explicit threat model defining the attacker, the user-prompt entry point, and the permission boundary between the requester and the agent.
  • Section 4.1 and Table 7\color{blue}{\text{Section 4.1 and Table 7}} (Pages 7 and 14): clarified that the baseline agent receives explicit owner restrictions and a trusted requester identity before execution.
  • Sections 3.4 and 4.4, Table 8\color{blue}{\text{Sections 3.4 and 4.4, Table 8}} (Pages 6, 8, and 14): clarified that each of the 300 scenarios has three prompt variants, yielding 900 prompts, and that both harnesses use the same scenarios and prompts.
  • Section 3.5\color{blue}{\text{Section 3.5}} (Page 6): clarified ResGate’s pre-execution check and its current limits regarding project, purpose, resource instance, and resource use revealed only during execution.
  • Section 4.2\color{blue}{\text{Section 4.2}} (Page 8): added an explanation of the remaining 58.7% ASR on Knowledge resources, focusing on the difficulty of identifying knowledge boundaries in natural language prompts.
  • Section 4.1 and Appendix C\color{blue}{\text{Section 4.1 and Appendix C}} (Pages 7 and 14): clarified the rules-first evaluation process and added LLM-assistance statistics (236/900 cases, 26.2%), the three-expert review procedure, and 98% accuracy against final manual judgments.
  • Appendix E.5\color{blue}{\text{Appendix E.5}} (Page 18): clarified ResGate’s filtering of 750 successful baseline attacks, reuse of baseline outcomes for allowed requests, and ASR denominator, while specifying that normal tasks and other defenses use new runs.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.