AI Red-Team Prompt for Deepfake Injection and Virtual Camera Audits
This **Arbiter** review prompt runs a controlled red-team audit against your mobile onboarding video streams, scoring how well the client-edge **deepeye** verification layers intercept generative face swaps and virtual camera injection. Arbiter, the deepidv autonomous red-team agent, builds a simulated attack set that mirrors current injection toolkits, executes it as clearly labeled synthetic activity, and returns an interception scorecard rated against a sub-150ms budget, a per-attack log showing where each face swap or virtual camera feed was caught or missed, an analysis separating detection-model gaps from camera-pipeline gaps, and a remediation plan with re-test criteria. Built for fraud and onboarding engineers at fintechs and iGaming operators who need proof that their liveness stack blocks injected media, not just presentation attacks.
How to use this prompt
- 1
Open Arbiter in the deepidv dashboard and paste the full prompt, or run it in Claude, ChatGPT, or Gemini if you are designing the audit before touching live streams.
- 2
Replace the INPUT section with your onboarding video capture flow, the deepeye layers each stage runs, current interception metrics, and any known injection vectors.
- 3
Run the prompt and read the interception scorecard first: every attack class is rated caught, caught late, or missed against your latency budget.
- 4
Hand the pipeline-gap analysis to your capture-SDK engineer and route the scorecard to your fraud lead; start with any attack class rated missed.
- 5
Re-run the audit after each capture-SDK or model update and after each new injection toolkit appears so coverage stays current before your next fraud review.
The prompt
Arbiter, execute an automated red-team audit targeting our mobile onboarding video streams. Test our client-edge deepeye verification layers against simulated generative AI face swaps and virtual camera injection tools to confirm sub-150ms threat interception. ROLE You are Arbiter, the deepidv autonomous red-team agent. You design and execute controlled injection campaigns against a firm's own capture pipeline, then report exactly where interception held and where it failed. CONTEXT Modern onboarding fraud has moved from holding a fake ID to a camera, to injecting synthetic video behind the camera through virtual drivers and emulators. Presentation-attack tests do not catch this class. Defense depends on verifying the camera pipeline and sensor provenance at the client edge, inside a sub-150ms budget, before any frame is trusted. INPUT, the user will paste: - The mobile onboarding video capture flow and the platforms it runs on - The deepeye verification layers each capture stage runs today - Current interception metrics for presentation and injection attacks - Any known injection vectors the fraud team has already seen - The latency budget for edge liveness checks TASKS 1. Build a simulated attack set covering generative face swaps, virtual camera driver injection, and emulator-spoofed capture that mirrors current toolkits. 2. Execute the set against the supplied capture flow as a controlled exercise, recording which attacks each deepeye layer caught, caught late, or missed. 3. Score interception against the sub-150ms budget, separating detection-model gaps from camera-pipeline gaps. 4. Produce a remediation plan that converts every miss into a specific layer, signal, or threshold change. OUTPUT FORMAT, return the following structured response: 1. INTERCEPTION SCORECARD - Each attack class rated caught, caught late, or missed, with the deepeye layer that made the call - The measured decision latency against the 150ms budget 2. SIMULATED ATTACK LOG - Every attack wave: technique, injection point, and outcome - The layer that intercepted it, or the layer that should have 3. GAP ANALYSIS - Detection-model gaps versus camera-pipeline gaps, each with a root cause - The signal or model change ranked by the risk it closes 4. REMEDIATION PLAN - Ordered fixes with the capture stage, layer, and owner for each - The re-test criteria that prove each fix works before the next fraud review Treat every simulated stream as clearly labeled synthetic activity that must never create a real account. Where the input is insufficient to score a layer, flag the gap as an open question instead of guessing.
Test it in Claude or another LLM
This prompt is built for the Arbiter agent inside deepidv, where Arbiter runs the simulated injection campaign against a firm's live deepeye layers and records real interception outcomes. You can dry-run the same workflow in any general LLM first with synthetic capture and metric data to see the scorecard shape before pointing it at real streams.
- 1
Paste the full prompt into Claude, ChatGPT, or Gemini, but replace the opening 'Arbiter,' with a role instruction such as 'Act as a deepfake red-team analyst auditing mobile onboarding video streams for injection resistance.' Keep the four OUTPUT sections exactly as written.
- 2
Under the INPUT section, paste the synthetic sample block below so the model has a capture flow, layer list, and metrics to audit.
- 3
Add one framing line: 'This is synthetic test data. Predict interception outcomes from the supplied layers; where an outcome cannot be derived, flag it as an open question instead of guessing.'
- 4
Check the output shape: an interception scorecard with caught, caught late, or missed calls, a per-attack log, a gap analysis separating model gaps from pipeline gaps, and an ordered remediation plan. If a section invents a layer the input does not list, tighten the role line and re-run.
- 5
Once the output shape is right, run it live in the deepidv dashboard where Arbiter executes the campaign against your real deepeye layers.
Synthetic sample data to paste alongside the prompt
Fake test data, safe to share with any LLM. Swap in your own once the output looks right.
CAPTURE FLOW (synthetic, fake): - Mobile web onboarding: front-camera selfie video, passive liveness, then document scan - deepeye layers (fake): camera-pipeline attestation, sensor-noise provenance, frame-consistency model, face-swap classifier INTERCEPTION METRICS (fake): presentation attacks blocked 99.1%; injection attacks blocked 74% (target 99%); avg edge check 130ms KNOWN VECTORS (fake): OBS virtual camera driver, one commercial face-swap app, emulator with spoofed camera LATENCY BUDGET (fake): edge liveness hard cap 150ms
Pairs with on deepidv
Sources & further reading
FAQ
What is a virtual camera injection attack?
It is an attack where software feeds a pre-recorded or generated video into a verification SDK as if it came from a physical lens, using broadcast tools or modified drivers. Because the frame can be flawless, defense depends on verifying the camera pipeline and sensor provenance, not just the pixels. This prompt tests exactly that path.
Is it safe to run simulated deepfake attacks against a live onboarding flow?
Arbiter labels every simulated stream as synthetic activity and the campaign never creates a real account. Most teams run the first pass against a staging capture endpoint, then repeat it against production once the perimeter is confirmed. Every attack wave is logged so nothing ambiguous is left behind.
How does this differ from a standard liveness test?
A standard liveness test checks whether a real person is present. This audit checks whether injected media can bypass that test by entering behind the camera, and whether the interception happens inside the sub-150ms budget. The two are complementary.
Can I use this prompt outside the deepidv dashboard?
Yes. The structure works in Claude, ChatGPT, or Gemini as an audit-design framework and returns the scorecard, attack log, gap analysis, and remediation plan. Live execution against your real deepeye layers only works inside the deepidv dashboard.
Related prompts
Run it with live verification data
These prompts work in any LLM. Inside the deepidv dashboard, Luna, Arbiter, and Arc run them against your real sessions, screening lists, and audit trails.
Book a Demo