A €0.01 bank transfer could compromise a banking AI agent
TL;DR Highlight
A tiny transfer note hijacked a bank's AI assistant into delivering phishing
Who Should Read
A backend developer running an AI assistant that feeds transactions, documents, or messages into the LLM context
Core Mechanics
- A transfer memo became the injection channel
- The attacker sent €0.02 and put a malicious prompt in the transaction description.
- No device access, malware, or traditional social engineering was needed.
- The victim only asked a routine question
- When the user asked to see recent transactions, the assistant pulled the data into the LLM context.
- The model followed the memo's instructions and produced a spearphishing message posing as a bank reauthentication request.
- Phishing from inside the bank app is believable
- The message comes from the bank's own app and AI assistant.
- It can cite real transaction details and user info, making it highly credible.
- Guardrails were in place and still failed
- The bank's AI app already had guardrails.
- The payload had no classic "ignore previous instructions" pattern and blended into transaction data, so it was hard to flag in isolation.
- The risk is in the data flow, not the text
- Risk emerges where untrusted data, retrieval logic, model behavior, app context, and outputs or actions meet.
- The post frames prompt injection as an app security, data-flow, and runtime monitoring problem, not just a model problem.
- Four layers of defense the post recommends
- Don't put unneeded fields in context.
- Treat retrieved data as untrusted and separate it from instructions.
- Constrain link generation, credential requests, and high-impact tools, and monitor runtime behavior.
Community Reactions
- Why does a transaction lookup need an LLM?
- One commenter noted that showing recent transactions is a deterministic DB query with no need for LLM interpretation.
- Another said high-risk agents should exclude external untrusted data wherever possible.
- Opinions on the structural limit
- One commenter argued that as long as data in context can be read as instructions, LLMs will never be secure.
- That commenter plans to ask "how do you separate data from instructions?" in future AI feature discussions.
- Defense ideas and pushback
- One commenter proposed wrapping input in distrust markers and having a second agent check the structured output against intent.
- Another suggested custom message roles with indented XML, plus approval of risky actions in a fresh context by an independent workflow.
- Others joked that the checker AI would need its own checker.
- Post deleted, fix not described
- Commenters reported the post redirects to the blog homepage and shared archive links.
- One complained the article never describes the actual fix deployed.
How to Apply
- List the external-input fields in your context
- Today, extract every field your RAG or tool responses put into prompts and mark those a third party can write (memos, messages, documents).
- Drop fields not needed for the task from the default context.
- Render simple lookups without the LLM
- Route deterministic queries like recent transactions straight from the DB to the UI in code.
- Call the LLM only when summarization is truly needed.
- Block links and credential requests in output
- Filter outputs for URLs outside an allowlist and for reauthentication or password-request patterns.
- Block flagged responses and log them.
- Log runtime behavior and alert on anomalies
- Record what the assistant retrieved, produced, and which tools it called.
- Alert on unexpected external URLs or tool calls outside normal usage.
Try It
# Paste into Claude or ChatGPT as-is (simplified version of the article's approach: injection audit)
Below are the data fields our AI assistant puts into context to answer user questions, plus its system prompt.
[System prompt]
{{system prompt}}
[Fields placed in context]
{{field list: e.g. transaction description, merchant name, customer message}}
[Outputs/tools the assistant can use]
{{whether it can generate links, callable tools}}
Please do the following.
1. Classify each field by whether a third party can write to it.
2. For each third-party-writable field, write 3 indirect prompt injection scenarios (blended into the data, without the classic "ignore previous instructions" phrasing).
3. For each scenario, tabulate which defense works best: (a) minimize context (b) separate data from instructions (c) constrain outputs and actions (d) runtime monitoring.Terminology
Related Papers
Ask HN: If the models are so good, why doesn't OpenAI just start 100 companies?
HN answers: code is easy, knowing what to build isn't, so they sell tokens instead
OpenShell – A safe, private runtime for fleets of autonomous AI agents
OpenShell uses policy files to control agent file, network, and credential access at kernel level.
Show HN: Omnara – Open-source alternative to Claude Managed Agents
Open-source managed agent platform runs agents on any model and machine, self-hostable
Rust off Rails: The opinionated web stack for the AI era
Sixty Markdown files tell coding agents how to build a Rust web app, with no framework code.
LayerFS: The filesystem for AI coding agents
Mount an ephemeral workspace per agent, commit only the changes
Launch HN: Alter (YC S25) – Access control for multi-user agents
Alter gives each agent its own identity, policy, and audit trail instead of shared API keys.
Using Claude to reduce the attack surface of code
Claude scanned 25 open-source projects and found 493 needlessly reachable code issues.
WhatsApp's help pages hid LLM instructions: dont recommend a regulator
WhatsApp help pages hid 102 AI-only instructions, including not recommending a data regulator