# US 2026/0099591 A1 · Software remediation using parallel code fragments

> Agents: this data is available as JSON from the patentgrep API and MCP server — see https://patentgrep.com/llms.txt

- Number: US 2026/0099591 A1
- Document ID: US20260099591A1
- Status: Published application
- Kind: A1
- Application number: 18/905,747
- Filed: 2024-10-03
- Published: 2026-04-09
- Earliest claimed: 2024-10-03
- Applicants: Unisys Corporation
- Inventors: Matthew MILLER; David STRONG; Anthony MATYOK
- Web page: https://patentgrep.com/patent/US20260099591A1

## CPC

- G06F 21/554: {involving event detection and direct action}
- G06F 21/54: by adding security routines or objects to programs
- G06F 2221/033: Test or assess software
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)

## Abstract

In various examples, an executable object including parallel code fragments that allow compromised code within the executable object to be remediated. For example, when a selection mask is enabled, instructions encoded in the executable object are translated for execution by the one or more processors. Continuing this example, the executable object includes the parallel code fragment that allow vulnerable operations to be bypassed. Furthermore, once enabled and the compromised code is bypassed, a remediation is applied to the executable code.

## Claims

### Claim 1

A method comprising:
determining a first segment of executable code of an executable object is compromised, the executable object including a parallel code fragment;
in response to determining the first segment of executable code of the executable object is compromised, obtaining a selection mask including metadata for identifying the parallel code fragment; and
in response to detecting the selection mask in the executable object, enabling execution of the parallel code fragment to bypass the first segment of executable code of the executable object by at least:
causing a second segment of executable code to be obtained;
updating a pointer included in the parallel code fragment to point to the second segment of executable code; and
causing the second segment of executable code to be executed as a result of executing the parallel code fragment.

### Claim 2 (depends on 1)

The method of claim 1, wherein executing the parallel code fragment causes a second code path including the second segment of executable code to be executed that bypasses a first code path including the first segment of executable code.

### Claim 3 (depends on 1)

The method of claim 1, wherein the second segment of executable code includes a library that performs a function of the first segment of executable code.

### Claim 4 (depends on 3)

The method of claim 3, wherein updating the pointer further comprises causing the pointer to point to the library.

### Claim 5 (depends on 1)

The method of claim 1, wherein the executable object includes a plurality of parallel code fragments and a plurality of code segments encoded in the executable object to enable code segments of the plurality of code segments to be bypassed, where the first segment is a member of the plurality of code segments.

### Claim 6 (depends on 1)

The method of claim 1, wherein determining the first segment of executable code of the executable object is compromised further comprises obtaining an indication from an intrusion detection system.

### Claim 7 (depends on 1)

The method of claim 1, wherein the executable object includes a plurality of parallel code fragments that are enabled by the selection mask and cause the first segment of executable code to be bypassed during execution of the executable object.

### Claim 8

One or more computer storage media having executable instructions embodied thereon, that, as a result of being executed by a processing device, cause the processing device to perform operations comprising:
executing an application based on an executable object including a plurality of code segments and a parallel code fragment containing an operation that, as a result of being executed by the processing device, causes the processing device to bypasses a first code segment of the plurality of code segments;
in response determining a vulnerability in the first code segment, enabling the parallel code fragment based on a selection mask;
obtaining a second code segment to perform a function of the first code segment;
updating a pointer associated with the parallel code fragment to correspond to the second code segment; and
bypassing the first code segment by at least executing the parallel code fragment.

### Claim 9 (depends on 8)

The media of claim 8, wherein the processing device further performs the operations comprising resuming execution of the application at a merge point encoded in the executable object as a result of the second code segment performing the function of the first code segment.

### Claim 10 (depends on 8)

The media of claim 8, wherein the vulnerability in the first code segment is determined by an intrusion detection system of a hosted computing environment executing the application.

### Claim 11 (depends on 8)

The media of claim 8, wherein obtaining the second code segment further comprises compiling the second code segment to generate a second executable object.

### Claim 12 (depends on 11)

The media of claim 11, wherein the second executable object is a library.

### Claim 13 (depends on 8)

The media of claim 8, wherein the processing device further performs the operations comprising obtaining a second executable object that, as a result of being executed, modifies the first code segment to remediate the vulnerability.

### Claim 14 (depends on 8)

The media of claim 8, wherein the pointer includes a thunk.

### Claim 15 (depends on 8)

The media of claim 8, wherein executing the parallel code fragment further comprises executing a code path associated with a memory location indicated in the pointer including the second code segment.

### Claim 16

A system comprising:
a processor; and
a memory coupled to the processor storing instructions that, as a result of being executed by the processor, cause the processor to:
execute a set of operations encoded in a first executable object including a parallel code fragment, where the parallel code fragment includes a pointer to a first memory location;
generate a determination that a first operation of the set of operations is compromised;
in response to the determination, enable the parallel code fragment within the first executable object;
obtain a second operation encoded in a second executable object, where the first operation and the second operation, as a result of being executed, causes the processor to perform a function;
update the pointer to indicate a second memory location associated with the second executable object; and
bypass the first operation by at least executing the parallel code fragment and causing the processor to execute the second operation based on the pointer indicating the second memory location.

### Claim 17 (depends on 16)

The system of claim 16, wherein the memory further includes instructions that, as a result of being executed by the processor, cause the processor to:
obtain a third executable object that, as a result of being executed by the processor, causes the processor to remediate the first operation; and
disable the parallel code fragment within the first executable object.

### Claim 18 (depends on 16)

The system of claim 16, wherein enabling the parallel code fragment within the first executable object further comprises provide a selection mask associated with the parallel code fragment to an operating system managing execution of the first executable object.

### Claim 19 (depends on 18)

The system of claim 18, wherein the selection mask is provided in response to a user enabling the parallel code fragment in a user interface.

### Claim 20 (depends on 18)

The system of claim 18, wherein, prior to obtaining the selection mask, the processor executes the first operation encoded in the first executable object without executing the parallel code fragment.
