Sprawdź sygnaturę obiektu współużytkowanego Linux przed ładowaniem.

Question

Cel: Załaduj plik .so lub plik wykonywalny, który został zweryfikowany do podpisu (lub zweryfikowany względem dowolnego algorytmu).

Chcę być w stanie zweryfikować .so/plik wykonywalny, a następnie załadować/execute że .so/wykonywalny z dlopen/...

Klucz w tym jest to, że wydaje się, że nie sposób programowy sprawdź i załaduj. Można ręcznie sprawdzić plik, a następnie załadować go po .. jednak istnieje okno możliwości, w którym ktoś może zamienić ten plik na inny.

Jednym z możliwych rozwiązań, które mogę wymyślić jest załadowanie pliku binarnego, sprawdzenie podpisu, a następnie dlopen/execvt /proc/$PID/fd .... jednak nie wiem, czy jest to wykonalne rozwiązanie.

Ponieważ blokady systemu plików są doradcze w Linuksie, nie są tak przydatne w tym celu ... (no, jest mount -o mand ... ale to jest coś dla poziomu użytkownika, a nie root).

Answer 1

Problem jest zasadniczo nierozwiązywalny w podanej formie, ponieważ obiekty wspólne są ładowane przez mmap() ing w celu przetworzenia miejsca w pamięci. Więc nawet jeśli może być upewnij się, że plik, na którym działał dlopen() był tym, który zbadałeś i zadeklarowałeś OK, każdy, kto może zapisywać do pliku, może zmodyfikować załadowany obiekt pod dowolną datę po załadowałem to.(Dlatego nie uaktualniasz uruchamiania plików binarnych, pisząc do nich - zamiast tego usuwasz, a następnie instalujesz, ponieważ zapisanie do nich prawdopodobnie spowoduje awarię wszystkich działających instancji).

Najlepiej jest upewnić się, że tylko użytkownik, którego używasz, może pisać do pliku, a następnie go sprawdzić, a następnie dlopen(). Twój użytkownik (lub root) nadal może przekradać się do innego kodu, ale procesy z tymi uprawnieniami mogą po prostu ptrace(), aby wykonać ich licytację w każdym razie.

Answer 2

This project podobno rozwiązuje to na poziomie jądra.

DigSig obecnie oferuje:

• prowadzony weryfikację metrum ELF plików binarnych i bibliotek współdzielonych.
• obsługa odwołania podpisu pliku.
• Mechanizm buforowania podpisów w celu zwiększenia wydajności.

Answer 3

wielu dynamicznych łączniki (włącznie) glibc za wsparcie ustawiając zmienną środowiskową LD_AUDIT do oddzielonej dwukropkami listy bibliotek współdzielonych. Biblioteki te mogą łączyć się z różnymi lokalizacjami w procesie ładowania biblioteki dynamicznej.

#define _GNU_SOURCE 
#include <dlfcn.h> 
#include <link.h> 
unsigned int la_version(unsigned int v) { return v; } 
unsigned int la_objopen(struct link_map *l, Lmid_t lmid, uintptr_t *cookie) { 
    if (!some_custom_check_on_name_and_contents(l->l_name, l->l_addr)) 
     abort(); 
    return 0; 
} 

Skompiluj to z cc -shared -fPIC -o test.so test.c lub podobnym.

Możesz zobaczyć glibc/elf/tst-auditmod1.c lub latrace po więcej przykładów lub przeczytać Linkers and Libraries Guide.

---

Bardzo bardzo specyficzne wewnętrzne glibc, ale nadal można zaczepić do libdl przy starcie.

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

extern struct dlfcn_hook { 
    void *(*dlopen)(const char *, int, void *); 
    int (*dlclose)(void *); 
    void *(*dlsym)(void *, const char *, void *); 
    void *(*dlvsym)(void *, const char *, const char *, void *); 
    char *(*dlerror)(void); 
    int (*dladdr)(const void *, Dl_info *); 
    int (*dladdr1)(const void *, Dl_info *, void **, int); 
    int (*dlinfo)(void *, int, void *, void *); 
    void *(*dlmopen)(Lmid_t, const char *, int, void *); 
    void *pad[4]; 
} *_dlfcn_hook; 
static struct dlfcn_hook *old_dlfcn_hook, my_dlfcn_hook; 

static int depth; 
static void enter(void) { if (!depth++) _dlfcn_hook = old_dlfcn_hook; } 
static void leave(void) { if (!--depth) _dlfcn_hook = &my_dlfcn_hook; } 

void *my_dlopen(const char *file, int mode, void *dl_caller) { 
    void *result; 
    fprintf(stderr, "%s(%s, %d, %p)\n", __func__, file, mode, dl_caller); 
    enter(); 
    result = dlopen(file, mode); 
    leave(); 
    return result; 
} 

int my_dlclose(void *handle) { 
    int result; 
    fprintf(stderr, "%s(%p)\n", __func__, handle); 
    enter(); 
    result = dlclose(handle); 
    leave(); 
    return result; 
} 

void *my_dlsym(void *handle, const char *name, void *dl_caller) { 
    void *result; 
    fprintf(stderr, "%s(%p, %s, %p)\n", __func__, handle, name, dl_caller); 
    enter(); 
    result = dlsym(handle, name); 
    leave(); 
    return result; 
} 

void *my_dlvsym(void *handle, const char *name, const char *version, void *dl_caller) { 
    void *result; 
    fprintf(stderr, "%s(%p, %s, %s, %p)\n", __func__, handle, name, version, dl_caller); 
    enter(); 
    result = dlvsym(handle, name, version); 
    leave(); 
    return result; 
} 

char *my_dlerror(void) { 
    char *result; 
    fprintf(stderr, "%s()\n", __func__); 
    enter(); 
    result = dlerror(); 
    leave(); 
    return result; 
} 

int my_dladdr(const void *address, Dl_info *info) { 
    int result; 
    fprintf(stderr, "%s(%p, %p)\n", __func__, address, info); 
    enter(); 
    result = dladdr(address, info); 
    leave(); 
    return result; 
} 

int my_dladdr1(const void *address, Dl_info *info, void **extra_info, int flags) { 
    int result; 
    fprintf(stderr, "%s(%p, %p, %p, %d)\n", __func__, address, info, extra_info, flags); 
    enter(); 
    result = dladdr1(address, info, extra_info, flags); 
    leave(); 
    return result; 
} 

int my_dlinfo(void *handle, int request, void *arg, void *dl_caller) { 
    int result; 
    fprintf(stderr, "%s(%p, %d, %p, %p)\n", __func__, handle, request, arg, dl_caller); 
    enter(); 
    result = dlinfo(handle, request, arg); 
    leave(); 
    return result; 
} 

void *my_dlmopen(Lmid_t nsid, const char *file, int mode, void *dl_caller) { 
    void *result; 
    fprintf(stderr, "%s(%lu, %s, %d, %p)\n", __func__, nsid, file, mode, dl_caller); 
    enter(); 
    result = dlmopen(nsid, file, mode); 
    leave(); 
    return result; 
} 

static struct dlfcn_hook my_dlfcn_hook = { 
    .dlopen = my_dlopen, 
    .dlclose = my_dlclose, 
    .dlsym = my_dlsym, 
    .dlvsym = my_dlvsym, 
    .dlerror = my_dlerror, 
    .dladdr = my_dladdr, 
    .dlinfo = my_dlinfo, 
    .dlmopen = my_dlmopen, 
    .pad  = {0, 0, 0, 0}, 
}; 

__attribute__((constructor)) 
static void init(void) { 
    old_dlfcn_hook = _dlfcn_hook; 
    _dlfcn_hook = &my_dlfcn_hook; 
} 

__attribute__((destructor)) 
static void fini(void) { 
    _dlfcn_hook = old_dlfcn_hook; 
} 

 
$ cc -shared -fPIC -o hook.so hook.c 
$ cat > a.c 
#include <dlfcn.h> 
int main() { dlopen("./hook.so", RTLD_LAZY); dlopen("libm.so", RTLD_LAZY); } 
^D 
$ cc -ldl a.c 
$ ./a.out 
my_dlopen(libm.so, 1, 0x80484bd) 

Niestety, moje badania prowadzą mnie do wniosku, że nawet jeśli można zaczepić do glibc/elf/dl-load.c:open_verify() (czego nie można), to nie jest możliwe, aby ten wyścig wolne przed kimś pisanie na segmentach twoja biblioteka.