Practical Adversarial Attacks on Stochastic Bandits via Fake Data Injection
This paper introduces a practical "Fake Data Injection" threat model for stochastic bandits that overcomes unrealistic assumptions of prior work by limiting attackers to injecting bounded fake samples, and demonstrates through theory and experiments that this strategy can effectively mislead algorithms into selecting a target arm with only sublinear cost.
Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer
Imagine you are running a restaurant recommendation app. Every time a user asks for a suggestion, your app (the "learner") has to choose between 10 different restaurants (the "arms"). The app learns which restaurants are good by looking at past user ratings. Over time, it figures out that Restaurant A is amazing and Restaurant B is terrible, so it stops recommending B and keeps sending people to A.
The Old Way of Attacking (The "Magic Wand" Problem)
Previous research on how hackers could break these apps assumed the attacker had a "magic wand." They imagined a hacker could:
- Rewrite history: Every time a real customer gave a 5-star review, the hacker could instantly change it to a 1-star review before the app saw it.
- Do it forever: They could do this for every single user, every single time.
- Use impossible numbers: They could make a rating "negative 1,000" or "positive 1,000" to force the app's hand.
The paper argues this is unrealistic. In the real world, you can't magically edit a real person's review. You also can't make a rating of "negative 1,000" because the app only accepts ratings between 1 and 5 stars.
The New Way: "Fake Data Injection" (The "Bot Army" Problem)
This paper introduces a much more realistic threat model called Fake Data Injection. Instead of a magic wand, the attacker is like a person with a small army of fake accounts (bots).
- The Constraint: The attacker can't touch real reviews. They can only add new, fake reviews.
- The Limit: They can't create millions of bots instantly (the system would catch them). They have to add them slowly and carefully.
- The Rule: The fake reviews must look real. If the app only accepts 1–5 stars, the fake reviews must be 1–5 stars.
The Strategy: The "Silence" Tactic
The paper's main discovery is a clever way to trick the app without needing a magic wand. The goal is to make the app pick a specific, terrible restaurant (the "target") almost all the time.
Here is how the attack works, using a simple analogy:
- The Setup: The app is currently recommending a great restaurant (Arm A) and ignoring a bad one (Arm B). The attacker wants the app to recommend the worst restaurant (Arm Z) instead.
- The Trap: The attacker waits until the app tries to check out a "good" restaurant (like Arm A) just enough times to form an opinion.
- The Injection: Once the app has a few real reviews for Arm A, the attacker floods the system with a huge batch of fake 1-star reviews for Arm A.
- Crucial Point: The attacker doesn't need to make the average rating negative. They just need to lower it enough so that, mathematically, the app thinks Arm A is "too risky" to explore anymore.
- The Exponential Silence: This is the paper's "secret sauce." Once the app's math says, "Arm A looks bad, let's stop checking it," the app's own safety rules kick in. The app decides, "I've checked this enough; I won't look at it again for a very, very long time."
- The paper proves that with just a few fake reviews, the attacker can make the app ignore a good restaurant for an exponentially long time (like millions of rounds).
- The Result: The app, now confused and thinking all the "good" options are actually bad, stops exploring them. It gets stuck in a loop where it only picks the "target" restaurant (the one the attacker wants), even though it's the worst one.
Two Ways to Do It
The paper proposes two specific strategies for the "bot army":
- Simultaneous Injection (The "Big Dump"): The attacker waits until the app checks a restaurant, then immediately dumps a large batch of fake reviews all at once to kill its reputation. This works well if the system doesn't have strict limits on how many fake accounts can sign up in one minute.
- Periodic Bounded Injection (The "Slow Drip"): This is the more realistic, sneaky version. If the system blocks you from adding 1,000 fake reviews at once, the attacker adds 5 fake reviews, waits a while, adds 5 more, waits, and repeats.
- The paper shows that even with these strict limits (only 5 fake reviews at a time), the attacker can still trick the app. By carefully timing the "drips," they keep the app's confidence in the good restaurants low enough that the app never decides to check them again.
The Bottom Line
The paper demonstrates that you don't need a super-powerful hacker who can rewrite reality to break these learning systems. You just need a few fake accounts acting slowly and carefully. By adding a small number of realistic, bounded fake reviews, an attacker can permanently trick a smart learning algorithm into ignoring the best options and picking a terrible one, all while spending very little "effort" (cost).
This reveals a vulnerability: these systems are so eager to stop "wasting time" on options that look bad, that a small, steady stream of fake data can trick them into thinking the best options are actually the worst.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.