Runtime manipulation is the alteration of application behaviour while code is executing, often through script injection, function patching, or DOM tampering. For biometric systems, it can corrupt the signal path without defeating the biometric method itself.
Expanded Definition
Runtime manipulation is not a single attack method but a class of behaviour changes applied after software is loaded and before execution ends. In practice, it can involve script injection in a browser, function patching in memory, DOM tampering, API interception, or altering event flow so the application performs differently from what developers intended. This matters in web applications, mobile apps, identity workflows, and AI-enabled interfaces because the attacker does not need to replace the application outright, only distort its live state.
Definitions vary across vendors because some teams use the term narrowly for browser and client-side tampering, while others apply it more broadly to in-memory modification, hook-based interception, or instrumentation abuse. The clearest security reading is to treat runtime manipulation as a trust-breaking change to execution state that bypasses static controls. That framing aligns well with the governance focus of the NIST Cybersecurity Framework 2.0, which emphasises protecting systems and detecting abnormal behaviour during operation.
The most common misapplication is treating runtime manipulation as equivalent to source-code compromise, which occurs when teams overlook how attacker-controlled scripts, hooks, or overlays can change behaviour without altering the deployed build.
Examples and Use Cases
Implementing runtime integrity controls rigorously often introduces performance and compatibility constraints, requiring organisations to weigh stronger tamper detection against user experience and application complexity.
- Browser-based banking session tampering, where injected JavaScript changes payment destination details after the user has authenticated.
- Function hooking in a mobile app, where an attacker alters validation logic to bypass a local security check or weaken telemetry.
- DOM tampering in a web identity flow, where visible prompts, button labels, or transaction summaries are changed before user confirmation.
- Biometric signal-path interference, where the capture or presentation layer is manipulated even though the biometric algorithm itself remains unchanged.
- AI agent tooling abuse, where an attacker alters prompts, tool outputs, or execution context at runtime so the agent takes unsafe actions.
For teams building transaction-sensitive systems, the practical question is often not whether the binary was signed, but whether the running instance can still be trusted. Controls such as script integrity enforcement, runtime instrumentation detection, and secure session binding are commonly discussed alongside guidance from NIST Cybersecurity Framework 2.0 because they address live attack paths rather than release-time assurance alone.
Why It Matters for Security Teams
Runtime manipulation matters because it defeats assumptions that security teams often make after authentication, after deployment, or after code review. A system can appear healthy, pass static scanning, and still be actively coerced into unsafe behaviour at execution time. That is especially important for identity verification, session integrity, and NHI-controlled automation, where an attacker may not need privileged credentials if they can alter what the application sees or decides in memory.
For security teams, the operational risk is that traditional perimeter or build-time checks miss the point of compromise. Runtime manipulation can invalidate transaction integrity, weaken fraud controls, distort telemetry, and contaminate AI or automation outputs. In identity-heavy workflows, it can also undermine step-up authentication, consent capture, and biometric presentation controls without breaking the underlying credential system.
Organisations typically encounter the real cost of runtime manipulation only after a live transaction is altered, at which point containment, forensics, and trust restoration become operationally unavoidable to address.
Standards & Framework Alignment
This section maps relevant standards and security frameworks to the operational risks and controls described in this guidance.
OWASP Agentic AI Top 10 and OWASP Non-Human Identity Top 10 address the attack and risk surface, while NIST CSF 2.0 and NIST AI RMF set the governance and control requirements practitioners need to meet.
| Framework | Control / Reference | Relevance |
|---|---|---|
| NIST CSF 2.0 | DE.CM-1 | Runtime manipulation is detected through continuous monitoring of systems and anomalous behaviour. |
| NIST AI RMF | AI RMF applies where runtime manipulation affects AI system behaviour or decision outputs. | |
| OWASP Agentic AI Top 10 | Agentic AI guidance covers runtime trust boundaries, tool abuse, and execution-time manipulation. | |
| OWASP Non-Human Identity Top 10 | NHI controls are relevant when runtime tampering targets service identities or automation tokens. |
Bind secrets and identities to trusted execution paths so runtime tampering cannot silently reuse them.
Related resources from NHI Mgmt Group
- What is the difference between runtime protection and NHI lifecycle management?
- What is the difference between code scanning and runtime identity monitoring?
- Why are runtime environments riskier than repository scans for NHI governance?
- When should organisations use runtime authorization for AI agents?
