Runtime conditional function patching based on argument tests
A system that injects runtime augmentations into existing program functions on a target computer by specifying (a) the function to augment, (b) an argument or value to test, (c) a test/predicate to evaluate, and (d) a behavioral modification to apply when the test fails. The patch receiver accepts an augmentation specification and a patching agent injects code at the specified point so the test runs when the function is invoked; it is intended for vendors or administrators who must fix or change behavior of in-use software without full module replacement.
(57) What the patent covered
This write-up was generated by AI from the patent's text and may contain mistakes, so check it against the original patent before relying on it.
The independent claim covers receiving an augmentation (patch) in the target system that names an existing program function, identifies an argument/value of that function, supplies a test to run on that argument/value, and specifies a modification to the function behavior; and arranging that when the function executes on the target system, if the test is not satisfied the specified modification is performed. The system claim adds components: storage for software, a patch receiver, and a patching agent that injects code at the specified point to perform the test and modification at runtime.
Distinguishing feature: Encoding a patch as a specification of a function, an argument/value test, and an on-failure behavioral modification applied by injected runtime code rather than replacing whole modules.
Novelty 3/5. Patching and hot-patching of running code was common; the novelty is packaging patches as argument-level tests with conditional injected behavior rather than full binary replacement.
Implementation
A small team would implement a host-side patch receiver that accepts JSON/YAML augmentation specs (function identifier, parameter index or memory offset, predicate, and handler code). The patching agent would use existing binary-instrumentation or runtime hooking libraries (e.g., Detours for native Windows, frida, LD_PRELOAD or ptrace for Linux, or JVM/CLR bytecode rewriter) to insert a short trampoline that evaluates the predicate and dispatches to the supplied handler when the test fails. The handler can be sandboxed script (Lua, WASM, JavaScript) or precompiled callback; store specs in a central service and sign them for integrity.
Components: Patch receiver (network / local uploader), patching agent / code injector (runtime bytecode or native trampoline), storage of augmentation specifications (database or file), runtime test/handler library (predicate evaluation and modification hooks).
Buildability 5/5. Main difficulties are reliably locating instrumentation points across versions and safely executing modification code in-process; existing instrumentation frameworks and sandboxing reduce risk.
Market demand
No demand check has been run for this patent. Likely search terms: runtime function patching, hot patch argument check, inject conditional patch. The links in the sidebar open these searches.
Buyers: System administrators and vendor support teams for server or client applications.
Before manufacturing
No related continuation or divisional patents in force were found. Design patents, trademarks and unrelated patents may still cover the product.
Practical risks include fragility across program versions, runtime stability when injecting code, and other patents in the patching/hot-patching space; the specification in the patent is sometimes vague about locating points and handler formats.
This patent has reached the end of its full term and cannot be revived. This page is a research lead, not legal advice. Obtain a freedom-to-operate opinion before manufacturing.