Обнаруживать запуск программ на платформе Linux

Ответ 1

Я не знаю, существует ли лучший способ, но вы можете периодически сканировать файловую систему /proc.

Например, /proc/<pid>/exe является символической ссылкой на исполняемый файл процесса.

В моих системах (Ubuntu/RedHat) /proc/loadavg содержит количество запущенных процессов (число после косой черты), а также pid самого недавно начатого процесса. Если ваш демон опросит файл, любое изменение на любом из двух номеров сообщит ему, когда ему потребуется перепроверить /proc в поисках новых процессов.

Это отнюдь не пуленепробиваемый, но самый подходящий механизм, о котором я могу думать.

Ответ 2

Для Linux в ядре есть интерфейс. Изучая эту проблему, я столкнулся с людьми, использующими конфигурацию ядра CONFIG_CONNECTOR и CONFIG_PROC_EVENTS, чтобы получить события после смерти процесса.

Еще несколько google, и я нашел это:

http://netsplit.com/2011/02/09/the-proc-connector-and-socket-filters/

Фильтры разъемов Proc и Socket Опубликовано 9 февраля 2011 по scott

Коннектор proc - одна из тех интересных функций ядра, которые редко встречаются большинством людей, и даже реже находят документацию. Аналогично сокет-фильтр. Это позор, потому что они действительно очень полезные интерфейсы, которые могут служить целым рядом целей, если они лучше документированы.

Коннектор proc позволяет получать уведомления о событиях процесса, таких как вызовы fork и exec, а также изменения в процессах uid, gid или sid (идентификатор сеанса). Они предоставляются через интерфейс на основе сокетов путем чтения экземпляров struct proc_event, определенных в заголовке ядра....

Интересный заголовок:

#include <linux/cn_proc.h>

Я нашел пример кода здесь:

http://bewareofgeek.livejournal.com/2945.html

/* This file is licensed under the GPL v2 (http://www.gnu.org/licenses/gpl2.txt) (some parts was originally borrowed from proc events example)

pmon.c

code highlighted with GNU source-highlight 3.1
*/

#include <sys/socket.h>
#include <linux/netlink.h>
#include <linux/connector.h>
#include <linux/cn_proc.h>
#include <signal.h>
#include <errno.h>
#include <stdbool.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

/*
* connect to netlink
* returns netlink socket, or -1 on error
*/
static int nl_connect()
{
int rc;
int nl_sock;
struct sockaddr_nl sa_nl;

nl_sock = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_CONNECTOR);
if (nl_sock == -1) {
    perror("socket");
    return -1;
}

sa_nl.nl_family = AF_NETLINK;
sa_nl.nl_groups = CN_IDX_PROC;
sa_nl.nl_pid = getpid();

rc = bind(nl_sock, (struct sockaddr *)&sa_nl, sizeof(sa_nl));
if (rc == -1) {
    perror("bind");
    close(nl_sock);
    return -1;
}

return nl_sock;
}

/*
* subscribe on proc events (process notifications)
*/
static int set_proc_ev_listen(int nl_sock, bool enable)
{
int rc;
struct __attribute__ ((aligned(NLMSG_ALIGNTO))) {
    struct nlmsghdr nl_hdr;
    struct __attribute__ ((__packed__)) {
    struct cn_msg cn_msg;
    enum proc_cn_mcast_op cn_mcast;
    };
} nlcn_msg;

memset(&nlcn_msg, 0, sizeof(nlcn_msg));
nlcn_msg.nl_hdr.nlmsg_len = sizeof(nlcn_msg);
nlcn_msg.nl_hdr.nlmsg_pid = getpid();
nlcn_msg.nl_hdr.nlmsg_type = NLMSG_DONE;

nlcn_msg.cn_msg.id.idx = CN_IDX_PROC;
nlcn_msg.cn_msg.id.val = CN_VAL_PROC;
nlcn_msg.cn_msg.len = sizeof(enum proc_cn_mcast_op);

nlcn_msg.cn_mcast = enable ? PROC_CN_MCAST_LISTEN : PROC_CN_MCAST_IGNORE;

rc = send(nl_sock, &nlcn_msg, sizeof(nlcn_msg), 0);
if (rc == -1) {
    perror("netlink send");
    return -1;
}

return 0;
}

/*
* handle a single process event
*/
static volatile bool need_exit = false;
static int handle_proc_ev(int nl_sock)
{
int rc;
struct __attribute__ ((aligned(NLMSG_ALIGNTO))) {
    struct nlmsghdr nl_hdr;
    struct __attribute__ ((__packed__)) {
    struct cn_msg cn_msg;
    struct proc_event proc_ev;
    };
} nlcn_msg;

while (!need_exit) {
    rc = recv(nl_sock, &nlcn_msg, sizeof(nlcn_msg), 0);
    if (rc == 0) {
    /* shutdown? */
    return 0;
    } else if (rc == -1) {
    if (errno == EINTR) continue;
    perror("netlink recv");
    return -1;
    }
    switch (nlcn_msg.proc_ev.what) {
    case PROC_EVENT_NONE:
        printf("set mcast listen ok\n");
        break;
    case PROC_EVENT_FORK:
        printf("fork: parent tid=%d pid=%d -> child tid=%d pid=%d\n",
            nlcn_msg.proc_ev.event_data.fork.parent_pid,
            nlcn_msg.proc_ev.event_data.fork.parent_tgid,
            nlcn_msg.proc_ev.event_data.fork.child_pid,
            nlcn_msg.proc_ev.event_data.fork.child_tgid);
        break;
    case PROC_EVENT_EXEC:
        printf("exec: tid=%d pid=%d\n",
            nlcn_msg.proc_ev.event_data.exec.process_pid,
            nlcn_msg.proc_ev.event_data.exec.process_tgid);
        break;
    case PROC_EVENT_UID:
        printf("uid change: tid=%d pid=%d from %d to %d\n",
            nlcn_msg.proc_ev.event_data.id.process_pid,
            nlcn_msg.proc_ev.event_data.id.process_tgid,
            nlcn_msg.proc_ev.event_data.id.r.ruid,
            nlcn_msg.proc_ev.event_data.id.e.euid);
        break;
    case PROC_EVENT_GID:
        printf("gid change: tid=%d pid=%d from %d to %d\n",
            nlcn_msg.proc_ev.event_data.id.process_pid,
            nlcn_msg.proc_ev.event_data.id.process_tgid,
            nlcn_msg.proc_ev.event_data.id.r.rgid,
            nlcn_msg.proc_ev.event_data.id.e.egid);
        break;
    case PROC_EVENT_EXIT:
        printf("exit: tid=%d pid=%d exit_code=%d\n",
            nlcn_msg.proc_ev.event_data.exit.process_pid,
            nlcn_msg.proc_ev.event_data.exit.process_tgid,
            nlcn_msg.proc_ev.event_data.exit.exit_code);
        break;
    default:
        printf("unhandled proc event\n");
        break;
    }
}

return 0;
}

static void on_sigint(int unused)
{
need_exit = true;
}

int main(int argc, const char *argv[])
{
int nl_sock;
int rc = EXIT_SUCCESS;

signal(SIGINT, &on_sigint);
siginterrupt(SIGINT, true);

nl_sock = nl_connect();
if (nl_sock == -1)
    exit(EXIT_FAILURE);

rc = set_proc_ev_listen(nl_sock, true);
if (rc == -1) {
    rc = EXIT_FAILURE;
    goto out;
}

rc = handle_proc_ev(nl_sock);
if (rc == -1) {
    rc = EXIT_FAILURE;
    goto out;
}

    set_proc_ev_listen(nl_sock, false);

out:
close(nl_sock);
exit(rc);
}

Я обнаружил, что этот код должен запускаться от имени root для получения уведомлений.

Ответ 3

Мне было интересно попытаться выяснить, как это сделать без опроса. inotify(), похоже, не работает в /proc, поэтому идея отсутствует.

Однако любая программа, которая динамически связана, будет иметь доступ к определенным файлам при запуске, например, к динамическому компоновщику. Это было бы бесполезно для целей безопасности, поскольку оно не будет запускаться по статически связанной программе, но может все еще представлять интерес:

#include <stdio.h>
#include <sys/inotify.h>
#include <assert.h>
int main(int argc, char **argv) {
    char buf[256];
    struct inotify_event *event;
    int fd, wd;
    fd=inotify_init();
    assert(fd > -1);
    assert((wd=inotify_add_watch(fd, "/lib/ld-linux.so.2", IN_OPEN)) > 0);
    printf("Watching for events, wd is %x\n", wd);
    while (read(fd, buf, sizeof(buf))) {
      event = (void *) buf;
      printf("watch %d mask %x name(len %d)=\"%s\"\n",
         event->wd, event->mask, event->len, event->name);
    }
    inotify_rm_watch(fd, wd);
    return 0;
}

События, которые печатаются, не содержат никакой интересной информации - pid процесса запуска, похоже, не обеспечивается inotify. Однако его можно использовать для пробуждения и запуска повторного сканирования /proc

Также помните, что краткосрочные программы могут исчезнуть снова, прежде чем эта вещь просыпается и заканчивает сканирование /proc - по-видимому, вы узнаете, что они существовали, но не могли узнать, что они собой представляют. И, конечно, любой мог просто открыть и закрыть fd для dyanmic linker, чтобы утопить вас в шуме.

Ответ 4

Посмотрите эту небольшую программу от Себастьяна Крамера, он делает именно то, что вы просите, эффективным ресурсом и довольно простым кодом.

Это требует, чтобы ваше ядро ​​включало CONFIG_PROC_EVENTS, что не относится к последнему образцу Amazon Linux Image (2012.09).

ОБНОВЛЕНИЕ: после запроса в Amazon ядра ядра Amazon Linux теперь поддерживают PROC_EVENTS

Ответ 5

Используйте forkstat, это наиболее полный клиент для событий proc:

sudo forkstat -e exec,comm,core

• GitWeb: http://kernel.ubuntu.com/git?p=cking/forkstat.git
• Объявление: http://smackerelofopinion.blogspot.com/2014/03/forkstat-new-tool-to-trace-process.html

Упакован в Ubuntu, Debian и AUR.

До этого было cn_proc:

 bzr branch lp:~kees/+junk/cn_proc

Makefile нуждается в небольшом изменении (LDLIBS вместо LDFLAGS).

cn_proc и exec-notify.c (который опубликовал Арно) имеют общий предок; cn_proc обрабатывает еще несколько событий и имеет более чистый результат, но не устойчив, когда процессы быстро завершаются.

Ooh, нашел еще одну вилку exec-notify, extrace. Этот один отступает дочерний процесс ниже своего родителя (используя эвристику pid_depth).

Ответ 6

Ключевое слово для поисковой машины по вашему выбору - "соединитель события процесса".

Я нашел два инструмента, которые их используют, exec-notify и cn_proc.

Мне нравится более поздняя версия, но оба они очень хорошо выполняют свою работу.

Ответ 7

Вы можете либо сканировать операционную систему для программ, которые соответствуют вашему критерию, либо вы можете дождаться, когда программа сообщит о себе вашему демону. Какой метод вы выберете, будет сильно зависеть от того, сколько у вас контроля над вашими программами, отличными от daemon.

Сканирование может выполняться с помощью системного вызова ядра или путем чтения информации о загружаемом ядре пользователя (как в файловой системе /proc ). Обратите внимание, что сканирование не является гарантией того, что вы найдете какую-либо конкретную программу, как если бы программе удалось запустить и завершить цикл сканирования, она не будет обнаружена вообще.

Возможны более сложные методы обнаружения процесса, но они также требуют более сложных реализаций. Важно знать, что действительно необходимо, прежде чем вы приступаете к решениям, которые являются экзотическими (вставка драйверов ядра и т.д.), Поскольку все, что вы делаете, не зависит от системы, которую вы контролируете; вы фактически меняете среду, наблюдая за ней, а некоторые методы наблюдения за средой могут неправильно ее изменить.