I'm not an expert on LD_PRELOAD and rarely use it myself, but from what I remember and read on http://www.goldsborough.me/c/low-level/kernel/2016/08/29/16-48-53-the_-ld_preload-_trick/ and https://stackoverflow.com/questions/426230/what-is-the-ld-preload-trick that does not seem possible.

LD_PRELOAD lets you choose/select which implementation for a symbol you want to use. That does mean that the usage of that symbol already has to be present in your program A. As I read your question, that would not be the case. That's why I think what you want to do is not possible through LD_PRELOAD.

IF you have the source code of program A, you can probably achieve what you want by creating a custom compiler extension that can look for the instruction that you want to replace and actually replace it with a branch with a label that is defined in your SO library.

That being said, not sure you can just branch to labels in an SO library, as it is dynamically loaded and hence can break branching specs (max branch distance etc.)

It is possible to use the LD_PRELOAD mechanism to hook an instruction in a binary program and redirect execution to a shared object file. LD_PRELOAD is an environment variable that can be used to specify shared libraries to be loaded before any other libraries, including the libraries specified in the binary file. You can use LD_PRELOAD to load a shared object file that overrides specific functions in the binary program, using the dlsym() function, and then redirecting execution to the desired location in the shared object file. However, it is important to note that this method can be fragile and may not work as expected depending on the specific implementation of the binary program and the shared object file. Additionally, it's not recommended to modify the binary instruction directly and remove 4 bytes, as this may cause the program to crash. It's better to use the dynamic linking mechanism to redirect execution rather than modifying the binary instruction.

Hussien Al-haj Ahmad Yes, it is possible to jump to a specific address in a loaded shared object file using LD_PRELOAD. However, it is a complex task that requires a deep understanding of the architecture of the binary file and the memory layout of the program.

Hussien Al-haj Ahmad One way to accomplish this is to use dynamic binary instrumentation (DBI) frameworks, such as Pin or DynamoRIO. These frameworks allow you to insert custom instrumentation code, such as a hook, into a running program and manipulate its memory and instruction flow. You can use these frameworks to insert a branch instruction (b) that points to a specific address in the shared object file.

Hussien Al-haj Ahmad Another way is to use the LD_PRELOAD environment variable to load a custom library that contains your hook function at the start of the program. The hook function can then manipulate the instruction pointer to jump to the desired address in the shared object file.

It's worth noting that those methods require a deep understanding of the system's architecture, the binary file format, and the memory layout of the program. Additionally, it's a difficult task and might not be easy to implement and maintain. Any modification of the instruction pointer will lead to changing the instruction flow of the program and can cause unexpected behavior or crashes. Therefore, it's recommended to be cautious when manipulating instruction pointer and make sure to test the changes thoroughly.