1.1 — Создание виртуальной лаборатории (чтобы нам было где работать, я покажу как создать виртуальную сеть на вашем компьютере. Сеть будет состоять из 3х машин Linux ubuntu).
1.2 – Написание простого модуля в Linux. Введение в Netfilter и перехват трафика с его помощью. Объединяем все вместе, тестируем.
1.3 – Написание простого char device. Добавление виртуальной файловой системы — sysfs. Написание user interface. Объединяем все вместе, тестируем.
Содержание второй части:
2.2 — Таблицы Firewall. Transport Layer. Структуры TCP, UDP. Расширяем Firewall.
2.3 — Расширяем функциональность. Обарабатываем данные в user space. libnetfilter_queue.
2.4 — (*Опиционально) Изучаем реальную Buffer Overflow атаку и предотвращаем с помощью нашего Firewall'а.
Часть 1.3
В предыдущих частях, мы подготовили модуль (kernel space), который уже может делать минимальную работу – некоторым пакетам давать проходить, а некоторым нет. Теперь было не плохо добавить возможность, получать данные и управлять работой модуля из обычной программы (user space). Например включать Firewall, выключать и получать статистику работы.
Существует несколько способов это сделать. Мы пойдем по классическому способу.
Введение в Character device. Теория.
Я советую для чтения английскую версию статьи Википедии, как более точную и объемную по этой теме чем русскую http://ift.tt/2g6fuSU
Для нас будет достаточно понимания, что разные аппаратные устройства(hardware), работают и взаимодействуют с операционной системой, на очень низком уровне и конечно же происходит все это в kernel space. Linux/Unix системы, создали механизмы, одним из которых является character device, для того чтобы упростить взаимодействие с этими устройствами. Создавая character device, мы «просим» у ОС необходимые ресурсы и можем представить устройство в виде файла в специальной директории (как известно в linux все представлено в виде файлов и операции чтения\записи в него). При чтении из этого файла – мы можем получить данные от устройства (например пакеты которые пришли на сетевую карту), при записи в этот файл мы можем посылать данные устройству (например послать документ принтеру на печать). В нашем случае, устройства физически нет, но мы воспользуемся этими файлами для взаимодействия с нашей программой.
Введение в Character device. Практика.
Создать и зарегистрировать такой драйвер очень просто, достаточно вызвать функцию
fw_major = register_chrdev(0, DEVICE_NAME, &fops);Уже после этой функции, можно пойти в /dev/ вручную добавить устройство и начать с ним работать. Структура fops, определяет функции, которые будут вызываться при разных событиях с драйвером, например — чтением или записью. Функция возвращает major number – уникальный идентификационный номер.
В данном случае я выбрал только два события, но по ссылкам, что я приведу ниже, или самому почитав исходные тексты kernel можно найти полный список(довольно большой).
Ниже я определил, что при чтении с нашего устройства, мы получим количество всех перехваченных пакетов, а при записи, обнулим их:
static ssize_t fw_device_read(struct file* filp, char __user *buffer, size_t length, loff_t* offset)
{
printk("Reading from device, return total number of messages\n");
return sprintf(buffer, "%u", accepted_num + dropped_num);
}
static ssize_t fw_device_write(struct file *fp, const char *buff, size_t length, loff_t *ppos) {
printk("Writing to device, clear number of messages\n");
accepted_num = dropped_num = 0;
return 0;
}
static struct file_operations fops = {
.read = fw_device_read, .write = fw_device_write
};
Чтобы не добавлять каждый раз устройство вручную, можно сделать его регистрацию автоматической:
fw_class = class_create(THIS_MODULE, DEVICE_NAME);
fw_device = device_create(fw_class, NULL, MKDEV(fw_major, 0), NULL, DEVICE_FW);
Небольшая проверка:
Уже сейчас можно видеть устройство в /dev, кроме того, после регистрации класса, оно также появляется и в /sys/class
Ниже приведен полный листинг, обратите внимание на использование goto. Обычно(=всегда), мы не используем goto в программировании, потому что это очень сильно портит понимание, содержание, читаемость кода и скорее всего говорит о проблемах в дизайне программы(спагетти-код). Но этот случай один из немногих где goto очень к месту.
static int fw_major;
static struct device* fw_device;
static ssize_t fw_device_read(struct file* filp, char __user *buffer, size_t length, loff_t* offset) {
printk("Reading from device, return total number of messages\n");
return sprintf(buffer, "%u", accepted_num + dropped_num);
}
static ssize_t fw_device_write(struct file *fp, const char *buff, size_t length, loff_t *ppos) {
printk("Writing to device, clear number of messages\n");
accepted_num = dropped_num = 0;
return 0;
}
static struct file_operations fops = {
.read = fw_device_read,
.write = fw_device_write
};
static int __init fw_module_init(void) {
int retval = 0;
printk("Starting FW module loading\n");
…
accepted_num = 0;
dropped_num = 0;
// device functions
fw_major = register_chrdev(0, DEVICE_NAME, &fops);
if (fw_major < 0) {
printk("failed to register device: error %d\n", fw_major);
goto failed_chrdevreg;
}
fw_class = class_create(THIS_MODULE, DEVICE_NAME);
if (fw_class == NULL) {
printk("failed to register device class '%s'\n", DEVICE_NAME);
goto failed_classreg;
}
fw_device = device_create(fw_class, NULL, MKDEV(fw_major, 0), NULL, DEVICE_FW);
if (fw_device == NULL) {
printk("failed to create device '%s_%s'\n", DEVICE_NAME, DEVICE_FW);
goto failed_devreg;
}
// netfilter functions …
return 0;
failed_devreg:
class_destroy(fw_class);
// unregister the device class
failed_classreg:
unregister_chrdev(fw_major , DEVICE_NAME);
// remove the device class failed_classreg:
failed_chrdevreg:
// unregister the major number failed_chrdevreg:
return -1;
}
User interface.
Теперь напишем простую программу, которая будет читать и писать в созданный девайс для проверки работы:
// test.c
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
int reset() {
char path[] = "/dev/device_fw";
int fd = open(path, O_WRONLY);
if (fd<0) {
printf("Device access error, fd = %d\n", fd);
return fd;
}
char msg = '1';
write(fd, &msg, sizeof(msg));
close(fd);
return 0;
}
int all_msg() {
char msg[1] = {0};
int fd = open("/dev/device_fw", O_RDONLY);
if (fd<0) {
printf("Device access error, fd = %d\n", fd);
return fd;
}
if(read(fd, &msg, 1)>0){
printf("Accepted packets number: %s\n", msg);
} else {
printf("Nothing to read\n");
}
close(fd);
return 0;
}
int main(int argc, char* argv[]) {
if(argc <= 1 || argc > 3) {
printf("Wrong number arguments. Number of arguments is %d\n", argc);
return -1;
}
if(strcmp(argv[1], "reset")==0){
reset();
} else if(strcmp(argv[1], "all_msg")==0){
all_msg();
} else {
printf("Wrong argument %s\n", argv[1]);
}
return 0;
}
И проверяем работу:
Как видно выше, сначала мы загрузили наш модуль. Потом откомпилировали программу для чтения\записи в устройство. Первый раз запустив sudo ./test all_msg, мы выполнили чтение из устройства и получили число 0. После этого мы послали 4 ping запроса на одно из сетевых устройств. Опять выполнили чтение, получили 16 пакетов (почему не 8мь? ;). Выполнили sudo ./test reset, которая обратилась на запись к устройству, которое в свою очередь все обнулило.
Так это выглядит с точки зрения драйвера:
Прежде чем мы продолжим, очень советую (но не обязательно) для углубления почитать тут
http://ift.tt/2fSB5v8
А также тут
http://ift.tt/2g6o7Np
Внизу еще есть ссылка на хорошую бесплатную книгу.
Введение в sysfs. Теория.
Мы могли бы продолжить коммуникацию драйвера – пользователя через чтение\запись в /dev/fw_device, но не рекомендуется это делать, если нужно посылать\получать много информации (в отличии от байтов в нашем примере), а также данный способ считается устаревшим. И хотя в данной статье, нет больших объемов, я покажу как использовать sysfs, для коммуникации kernel <-> user.
sysfs — виртуальная файловая система в операционной системе Linux. Экспортирует в пространство пользователя информацию ядра Linux о присутствующих в системе устройствах и драйверах. Впервые появилась в ядре версии 2.6. Необходимость создания была вызвана устаревшей системой работы ядра с устройствами.(http://ift.tt/2fSBiyu)
То есть, благодаря sysfs, мы можем создавать целые структуры с иерархией из файлов, которые будут отображаться в /sys/class/fw и использовать их для чтения или записи. Например мы создадим два файла:
/sys/class/fw/acceptedMessages — чтение из которого вернет количество принятых пакетов
/sys/class/fw/dropedMessages — чтение из которого вернет количество запрещенных пакетов
Делается это очень просто. Обратите внимание, что после вызова выше
fw_class = class_create(THIS_MODULE, DEVICE_NAME);
мы уже зарегистрировали класс и уже видели его в /sys/class. Осталось добавить два файла и определить их функции. Регистрируем файлы:
static int __init fw_module_init(void)
{
…
fw_device = device_create(fw_class, NULL, MKDEV(fw_major, 0), NULL, DEVICE_FW);
…
retval = device_create_file(fw_device, &dev_attr_acceptedMessages);
if (retval < 0) {
printk("failed to create acceptedMessages /sys endpoint - continuing without\n");
}
retval = device_create_file(fw_device, &dev_attr_droppedMessages);
if (retval < 0) {
printk("failed to create droppedMessages /sys endpoint - continuing without\n");
}
…
}
Вначале модуля, добавляем макросы DEVICE_ATTR, которые определяют чтение или запись, а также функции которые будут вызваны. Так как нам не зачем обрабатывать запись, то последнее поле NULL.
static DEVICE_ATTR(acceptedMessages, S_IWOTH | S_IROTH, sys_read_accepted_msg, NULL);
static DEVICE_ATTR(droppedMessages, S_IWOTH | S_IROTH, sys_read_dropped_msg, NULL);
И сами функции:
static ssize_t sys_read_accepted_msg(struct device *dev, struct device_attribute *attr, char *buffer) {
return sprintf(buffer, "%u", accepted_num);
}
static ssize_t sys_read_dropped_msg(struct device *dev, struct device_attribute *attr, char *buffer){
return sprintf(buffer, "%u", dropped_num);
}
Обращение к ним через наш user interface происходит точно также как и с /dev/
Например:
int dropped_num() {
char msg[255] = {0};
int fd = open("/sys/class/fw/device_fw/droppedMessages", O_RDONLY);
if (fd<0) {
printf("Device access error, fd = %d\n", fd);
return fd;
}
if(read(fd, &msg, 255)>0){
printf("Accepted packets number: %s\n", msg);
} else {
printf("Nothing to read\n");
}
close(fd);
return 0;
}
Теперь самое время все собрать воедино, откомпилировать и хорошенько проверить.
Sysfs:
Accepted packets: делаем ping
И параллельно считываем
Проверяем dropped packets:
Пытаемся делать ping с host2 на host1
Параллельно смотрим «логи»
Кстати, обратите внимание, что тут, счетчик постоянно увеличивается на один (а не на два, как раньше), потому что, host1 не получает запросы от host2 и соответственно не отвечает. И для интереса dmesg:
Последнее — я выгружу fw и проверю, что без него сеть работает без ограничений:
Мы видим, что без нашего модуля, ping проходит без проблем.
Заключение.
В первой части, мы сначала создали виртуальную сеть, для работы с тремя компьютерами. Потом мы рассмотрели написание простого модуля, который использовал netfilter для перехвата трафика. И в конце, добавили char device и sysfs, для представления функций модуля в файловой системе обычному пользователю через чтение\запись в файлы. В завершении написали программу для пользователя, для управления нашим устройством.
Буду очень рад любым конструктивным комментариям. В следующей части, мы существенно расширим функциональность данного модуля, сделаем его более похожим на простой firewall, а также посмотрим как он может защищать сеть от различного вида атак.
Ссылки:
Linux Device Drivers, Third Edition
http://ift.tt/2fSB5v8
http://ift.tt/2g6o7Np
http://ift.tt/2fSBiyu
http://ift.tt/2g6fuSU
спагетти-код
Комментарии (0)