Comment puis-je détecter les accès aux fichiers sous Linux?

Question

J'ai un tas de flux et d'applications de traitement de données que j'ai parfois besoin d'espionner, ce qui signifie que j'ai besoin de savoir quels fichiers ils lisent. Ceci est principalement pour aider à l'empaquetage des cas de test, mais peut également être utile lors du débogage.

Existe-t-il un moyen d'exécuter les exécutables de manière à produire une telle liste?

J'ai deux réflexions à ce sujet:

1. Il y a une commande que je peux appeler et que mes applications commande appelle. Quelque chose dans le genre de GDB. J'appelle GDB, lui donne un chemin vers l'exécutable et quelques arguments et GDB l'appelle pour moi. Il y a peut-être quelque chose de similaire à me dire comment les ressources du système sont utilisées.
2. Peut-être la solution la plus intéressante (mais inutile).
   1. créer bibliothèque appelée libc.so qui implémente fopen (et quelques autres)
   2. changement LD_LIBRARY_PATH pour pointer vers la nouvelle bibliothèque
   3. faire une copie du réel libc.so et renommer fopen (nepof, peut-être) dans un éditeur
   4. ma bibliothèque charge la copie et appelle la fonction renommée comme nécessaire pour fournir la fonctionnalité fopen.
   5. appelez l'application qui appelle ensuite mon proxy fopen.

Alternative # 1 serait certainement celui que des commentaires sur la façon préférable de faire plus facilement # 2 sont aussi les bienvenus.

Answer 1

Une option consiste à utiliser strace:

strace -o logfile -eopen yourapp 

Ce enregistrera tous les événements de fichiers ouverts, mais il imposer une pénalité de rendement qui peut être importante. Il a l'avantage d'être facile à utiliser cependant.

Une autre option consiste à utiliser LD_PRELOAD. Cela correspond à votre option # 2. L'idée de base est de faire quelque chose comme ceci:

#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); 
} 

Puis construire avec:

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

et exécutez votre programme avec par exemple:

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

Cela a beaucoup moins de frais généraux.

Notez cependant qu'il existe d'autres points d'entrée pour l'ouverture de fichiers - par exemple, fopen(), openat(), ou l'un des nombreux points d'entrée de compatibilité existant:

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 

Vous devrez peut-être accrocher Tout cela pour être complet - à tout le moins, ceux qui ne sont pas préfixés par _ devraient être accrochés.En particulier, assurez-vous de hooker fopen séparément, car l'appel libc-interne de fopen() à open() n'est pas accroché par une bibliothèque LD_PRELOAD. Une mise en garde similaire s'applique à strace - il y a aussi le syscall 'openat', et en fonction de votre architecture, il peut y avoir d'autres syscalls historiques. Mais pas autant qu'avec les hooks LD_PRELOAD, donc si cela ne vous gêne pas, c'est peut-être une option plus facile.

Answer 2

man strace 

exemple (en supposant que 2343 est l'ID de processus):

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

# displaying part 
grep ^open strace_log.txt 

Answer 3

Ce que j'utilise est quelque chose comme:

strace -o file.txt ./command 

Vous pouvez alors

cat file.txt | grep open 

pour obtenir une liste de tous les fichiers que le programme ouvert.