Is it possible to wrap a dynamic object in an ELF dynamically linked binary? - c

Question

I am attempting to wrap a glibc symbol with my own definition of that symbol. For functions that glibc exposes this has so far been as easy as defining a __wrap_function_name in my source code and then adding Wl,--wrap=external_function_name to the linker flags of my build system's linking steps. In practice this then would look something like:
extern "C" void __wrap_external_function_name(void) {
my_internal function();
}
However I have recently attempted the same on a variable that glibc exposes, in this case __signgam. I again defined the linker flags for its wrapper, but I am not sure how and if it is even possible to define the wrapper for a variable. I attempted __wrap__signgam = signgam, but that had no effect. In fact the symbol table when exposed with objdump -T binary | grep signgam had the following content, showing that even though the wrap function is defined, the original symbol remains untouched:
0000000000000000 DO *UND* 0000000000000000 GLIBC_2.23 __signgam
0000000000000000 DO *UND* 0000000000000000 GLIBC_2.2.5 signgam
0000000001509d24 g DO .bss 0000000000000004 Base __wrap___signgam
Is there a canonical way to wrap these dynamic objects?

Answer 1

You can use the dynamic load library (e.g. -ldl) and use some of its functions, notably, dlsym.
There are three steps:
First create your source file.
Creat a shared library (.so file) from that source file
Invoke target program (set environment variable LD_PRELOAD to point to your .so file
Note that to intercept a given function, your function has to be defined with the same name.
You can have as many intercept functions as you want in your source file.
Here is some sample source code for intercepting (e.g.) read ...
// NOTE: need _GNU_SOURCE above for RTLD_NEXT in dlfcn.h
#define _GNU_SOURCE
#include <unistd.h>
#include <dlfcn.h>
#include <string.h>
static void
msg(const char *buf)
{
int len;
len = strlen(buf);
write(1,buf,len);
}
// read -- read a file
ssize_t
read(int unit,void *buf,size_t buflen)
{
static ssize_t (*proc)(int,void *,size_t) = NULL;
ssize_t rlen;
// get pointer to real function (only needs to be done once)
if (proc == NULL)
proc = dlsym(RTLD_NEXT,"read");
// do [whatever] stuff before real read ...
msg("PHONY: before\n");
// invoke the real function
rlen = proc(unit,buf,buflen);
// do [whatever] stuff after real read ...
msg("PHONY: after\n");
return rlen;
}
Here's a sample target program:
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
int
main(void)
{
int fd;
int rlen;
char buf[100];
fd = open("/etc/passwd",O_RDONLY);
rlen = read(fd,buf,sizeof(buf));
close(fd);
printf("main: read %d bytes\n",rlen);
return 0;
}
Now create a shared library (.so).
Note that below, there's only one source file. But, you can create the library from as many separate source files as you wish (e.g. you could put one intercept function per source file or put all in one source file, as you choose).
Here's a [crude] Makefile (that creates the shared library and the sample target program):
all: mylib.so target
read.o: read.c
cc -c -fPIC read.c
mylib.so: read.o
cc -shared -o mylib.so read.o -ldl
target: target.c
cc -o target target.c
test:
env LD_PRELOAD=./mylib.so ./target
clean:
rm -f mylib.so *.o target
Now, to invoke the target program (e.g.):
make test
Here's the generated output of the test:
env LD_PRELOAD=./mylib.so ./target
PHONY: before
PHONY: after
main: read 100 bytes