¿Cómo puedo detectar accesos a archivos en Linux?

Question

Tengo un montón de flujos y aplicaciones de procesamiento de datos que de vez en cuando necesito espiar, lo que significa que necesito saber qué archivos leen. Esto es principalmente para ayudar en el empaquetado de cajas de prueba, pero también puede ser útil cuando se depura.

¿Hay alguna manera de ejecutar los archivos ejecutables de tal manera que produzca dicha lista?

tengo dos pensamientos sobre esto:

1. hay un comando que puedo invocar y ese comando invoca mis aplicaciones. Algo parecido a GDB. Llamo a GDB, le doy una ruta al ejecutable y algunos argumentos y GDB lo llama por mí. Quizás haya algo similar a decirme cómo se usan los recursos del sistema.
2. Quizás la solución más interesante (pero innecesaria).
   1. crear biblioteca llamada libc.so que implementa fopen (y algunos otros)
   2. cambio LD_LIBRARY_PATH para que apunte a la nueva biblioteca
   3. hacer una copia de la libc.so real y cambiar el nombre de fopen (nepof, tal vez) en un editor
   4. mi biblioteca carga la copia y llama a la función renombrada según sea necesario para proporcionar la funcionalidad fopen.
   5. llama a la aplicación que luego llama a mi proxy fopen.

Alternativa # 1 Sin duda, sería la preferible pero los comentarios sobre cómo hacerlo # 2 más fácilmente son bienvenidos también.

Answer 1

Una opción es utilizar strace:

strace -o logfile -eopen yourapp 

Esto registrar todos los eventos de archivos abiertos, pero lo hará imponer una pena de rendimiento que puede ser significativa. Sin embargo, tiene la ventaja de ser fácil de usar.

Otra opción es usar LD_PRELOAD. Esto corresponde a su opción n. ° 2. La idea básica es hacer algo como esto:

#define _GNU_SOURCE 
#include <stdio.h> 
#include <dlfcn.h> 

int open(const char *fn, int flags) { 
    static int (*real_open)(const char *fn, int flags); 

    if (!real_open) { 
     real_open = dlsym(RTLD_NEXT, "open"); 
    } 

    fprintf(stderr, "opened file '%s'\n", fn); 
    return real_open(fn, flags); 
} 

Entonces construir con:

gcc -fPIC -shared -ldl -o preload-example.so preload-example.c 

y ejecutar su programa con, por ejemplo:

$ LD_PRELOAD=$PWD/preload-example.so cat /dev/null 
opened file '/dev/null' 

Esto tiene mucho menos sobrecarga.

Nótese, sin embargo, que existen otros puntos de entrada para abrir archivos - por ejemplo, fopen(), openat(), o uno de los muchos puntos de entrada de compatibilidad legado:

00000000000747d0 g DF .text  000000000000071c GLIBC_2.2.5 _IO_file_fopen 
0000000000068850 g DF .text  000000000000000a GLIBC_2.2.5 fopen 
000000000006fe60 g DF .text  00000000000000e2 GLIBC_2.4 open_wmemstream 
00000000001209c0 w DF .text  00000000000000ec GLIBC_2.2.5 posix_openpt 
0000000000069e50 g DF .text  00000000000003fb GLIBC_2.2.5 _IO_proc_open 
00000000000dcf70 g DF .text  0000000000000021 GLIBC_2.7 __open64_2 
0000000000068a10 g DF .text  00000000000000f5 GLIBC_2.2.5 fopencookie 
000000000006a250 g DF .text  000000000000009b GLIBC_2.2.5 popen 
00000000000d7b10 w DF .text  0000000000000080 GLIBC_2.2.5 __open64 
0000000000068850 g DF .text  000000000000000a GLIBC_2.2.5 _IO_fopen 
00000000000d7e70 w DF .text  0000000000000020 GLIBC_2.7 __openat64_2 
00000000000e1ef0 g DF .text  000000000000005b GLIBC_2.2.5 openlog 
00000000000d7b10 w DF .text  0000000000000080 GLIBC_2.2.5 open64 
0000000000370c10 g DO .bss  0000000000000008 GLIBC_PRIVATE _dl_open_hook 
0000000000031680 g DF .text  0000000000000240 GLIBC_2.2.5 catopen 
000000000006a250 g DF .text  000000000000009b GLIBC_2.2.5 _IO_popen 
0000000000071af0 g DF .text  000000000000026a GLIBC_2.2.5 freopen64 
00000000000723a0 g DF .text  0000000000000183 GLIBC_2.2.5 fmemopen 
00000000000a44f0 w DF .text  0000000000000088 GLIBC_2.4 fdopendir 
00000000000d7e70 g DF .text  0000000000000020 GLIBC_2.7 __openat_2 
00000000000a3d00 w DF .text  0000000000000095 GLIBC_2.2.5 opendir 
00000000000dcf40 g DF .text  0000000000000021 GLIBC_2.7 __open_2 
00000000000d7b10 w DF .text  0000000000000080 GLIBC_2.2.5 __open 
0000000000074370 g DF .text  00000000000000d7 GLIBC_2.2.5 _IO_file_open 
0000000000070b40 g DF .text  00000000000000d2 GLIBC_2.2.5 open_memstream 
0000000000070450 g DF .text  0000000000000272 GLIBC_2.2.5 freopen 
00000000000318c0 g DF .text  00000000000008c4 GLIBC_PRIVATE __open_catalog 
00000000000d7b10 w DF .text  0000000000000080 GLIBC_2.2.5 open 
0000000000067e80 g DF .text  0000000000000332 GLIBC_2.2.5 fdopen 
000000000001e9b0 g DF .text  00000000000003f5 GLIBC_2.2.5 iconv_open 
00000000000daca0 g DF .text  000000000000067b GLIBC_2.2.5 fts_open 
00000000000d7d60 w DF .text  0000000000000109 GLIBC_2.4 openat 
0000000000068850 w DF .text  000000000000000a GLIBC_2.2.5 fopen64 
00000000000d7d60 w DF .text  0000000000000109 GLIBC_2.4 openat64 
00000000000d6490 g DF .text  00000000000000b6 GLIBC_2.2.5 posix_spawn_file_actions_addopen 
0000000000121b80 g DF .text  000000000000008a GLIBC_PRIVATE __libc_dlopen_mode 
0000000000067e80 g DF .text  0000000000000332 GLIBC_2.2.5 _IO_fdopen 

Es posible que tenga que conectar todos estos para completar - al menos, los que no tienen el prefijo _ deben engancharse.En particular, asegúrese de enganchar fopen por separado, ya que la llamada libc-interna desde fopen() a open() no está enganchada por una biblioteca LD_PRELOAD.

Una advertencia similar se aplica a strace: también está la llamada de 'openat' y, dependiendo de su arquitectura, también puede haber otros syscalls heredados. Pero no tantos como con los ganchos LD_PRELOAD, por lo que si no le importa el rendimiento alcanzado, puede ser una opción más fácil.

Answer 2

man strace 

ejemplo (suponga 2343 es el identificador de proceso):

# logging part 
strace -p 2343 -ff -o strace_log.txt 

# displaying part 
grep ^open strace_log.txt 

Answer 3

Lo que yo uso es algo así como:

strace -o file.txt ./command 

A continuación, puede

cat file.txt | grep open 

para obtener una lista de todos los archivos que abrió el programa.