(почти)Пълно ръководство за модулите в Linux ядрото [част 1]
	от pragmatic / THC(21-05-2001) рейтинг (6)   [ добре ]  [ зле ]  Вариант за отпечатване (nearly) Complete Linux Loadable Kernel Modules -the definitive guide for hackers, virus coders and system administrators- Преведено от: Андрю Иванов. Оригиналното ръководство може да откриете на този адрес СЪДЪРЖАНИЕ Въведение I. Основи 1. Какво представляват LKM 2. Какво представляват системните повиквания (systemcalls) 3. Какво представлява Kernel-Symbol-Table (таблица със символите на ядрото)   Въведение Ползата от Linux в света на сървърите нараства всяка секунда. Така че да хакнеш Linux става все по-интересно с всеки изминал ден. Една от най-добрите техники за атака на Linux система е чрез използване на kernel код т.е. програмен код за ядрото на операционната система. Благодарение на функцията наречена "Loadable Kernel Modules" (Заредими Модули на Ядрото - LKM) е възможно да се напише код, работещ в рамките на ядрото, което ни позволява да достигнем много чувствителни части на операционната система. Преди време съществуваха някои текстове и файлове, засягащи LKM хакването (Phrack, например), които бяха доста добри. Те They представиха нови идеи, нови методи и завършени LKMs, правещи всичко за което един хакер някога е мечтал. Също така и някои публични дискусии през 1998 (новинарски групи, пощенски списъци) бяха много интересни. И така, защо да пиша отново за LKMs? Ами, има няколко причини: предишните текстове, понякога, не даваха добри обяснения за начинаещите; този текст има много обширна част посветена на основите, помагаща на начинаещите да разберат основните концепции. Срещал съм много хора, използващи добри снифъри и тям подобни без дори да разбират как тези "играчки" работят. Включих много сорс код в този файл с много коментари, просто за да помогна на начинаещите, които знаят, че хакерството е нещо повече от това да опустошаваш някакви си мрежи ! всеки публикуван текст се концентрираше върху определена тема, не съществуваше завършено ръководство за хакери, което да засяга LKMs. Този текст ще засегне почти всички аспекти от злоупотребата с ядрото (дори вирусите) този текст беше написан от гледната точка на хакер / създател на вируси, но ще е от полза и за администраторите и обикновените разработчици, занимаващи се с ядрото предишните текстове демонстрираха най-важните изгоди и методи на злоупотреба с LKMs, но съществуват неща, за които все още не сме и чували. Този текст ще демонстрира някои нови идеи (нищо изцяло ново, но все пак няща, които могат да ни помогнат) този текст ще покаже някои идеи за прост начин за предпазване от LKM атаки този текст ще демонстрира и как да бъдат преодоляни LKM защитите чрез използване на методи като Runtime Kernel Patching ("закърпване" на ядрото в реално време) Моля, запомнете, че новите идеи за изпълнени под формата на модули-прототипи (само за демонстрационни цели), които трябва да бъдат подобрени, за да будат използвани в реалността. Основната мотивация на този текст е да даде на всеки един голям текст, покриващ целия проблем LKM. В приложение A давам няколко съществуващи LKMs плюс кратко описание на тяхната работа (за начинаещи) и начини за тяхното използване. Целият текст (с изключение на част V) се базира на Linux 2.0.x машина (x86). Тествал съм всички програми и фрагменти код. Linux системата трябва да поддържа LKM, за да използвате повечето примерни кодове в този текст. Само част IV ще демонстрира някои сорсове, които работят без вградена поддръжка на LKM. Повечето исеи в този текст че работят и на 2.2.x системи (вероятно ще трябва да направите някои минимално корекции); но спомнете си, че ядро 2.2.x тъкмо беше излязло (1/99) и повечето linux дистрибуции все още използват 2.0.x (Redhat, SuSE, Caldera, ...). През април някои дистрибутори, като SuSE ще покажат техните версии с ядро 2.2.x; така че няма да имате нужда да знаете как да хакнете ядро 2.2.x към настоящия момент. Добрите администратори също ще изчакат няколко месеца, за да получат по-надеждно 2.2.x ядро. [Забележка : Повечето системи просто не се нуждаят от ядро 2.2.x, така че те ще продължат да използват 2.0.x]. Този текст има специален раздел, занимаващ се с LKMs, помагащи на администраторите да обезопасят системата. Вие (хакерите) трябва също да прочетете този раздел, вие трябва да знаете всичко, което админите знаят и дори повече. Ще получите някои добри идеи от този раздел, които могат да ви помогнат да разработите по-напреднали 'хекерски LKMs'. Просто прочетете целия текст ! И, моля ви, запомнете : Този текст беше написан единствено за учебни цели. Всяко противозаконно действие основано на този текст си е лично ваш проблем. I. Основи 1. Какво представляват LKM LKM - това са Loadable Kernel Modules (Заредими Модули на Ядрото. Те се използват от Linux ядрото за повишаване на функционалността му. Ползите от LKM : Tе могат да се зареждат динамично; не се налага прекомпилиране на цялото ядро. Поради тези си свойства, LKM се използват често за драйвери за специфични устройства (или файлови системи), като например звукови карти и подобни. Всеки LKM се състои от две основни функции (минимум) : int init_module(void) /*използва се за всичко свързано с инициализацията*/ { ... } void cleanup_module(void) /*използва се за 'чисто' спиране на модула*/ { ... } Зареждане на модул - обикновено извършвано от root - става чрез командата: # insmod module.o Тази команда предизвиква извършването на следните действия от системата : Зареждане на обектния файл (в случая module.o) Извиква системно повикване create_module (за системни повиквания -> виж I.2) за презареждане на паметта неуточнените препратки (references) се превръщат в Kernel-Symbol-и чрез системно повикване get_kernel_syms след това се използва системно повикване init_module за инсталиране на LKM-а -> изпълнявайки int init_module(void) и т.н. Kernel-Symbol-ите са обяснени в I.3 (Kernel-Symbol-Table). И така, струва ми се, че вече може да напишем първият си малък LKM, просто за да демонстрираме основните принципи на работа: #define MODULE #include <Linux/module.h> int init_module(void) {  printk("<1>Hello World\n");  return 0; } void cleanup_module(void) {  printk("<1>Bye, Bye"); } Може би се учудвате, че използвах printk(...), а не printf(...). Е добре, програмирането на ниво ядро е напълно различно от програмирането на потребителско ниво ! Разполагате с много ограничен набор от команди (виж I.6). С тези команди  не можете да направите кой знае какво, така че ще се научите как да използвате много от  функциите, които познавате от вашите потребителски програми; те ще ви помагат да хакнете ядрото. Само бъдете търпеливи, първо трябва да свършим още нещо... Примерният LKM, даден по-горе може лесно да бъде компилиран по следният начин: # gcc -c -O3 helloworld.c # insmod helloworld.o Добре, нашият модул е зареден и ни показа един известен текст. Сега можете да пробвате някои  команди, които ще ви показат, че LKM-а наистина се разполага в рамките на ядрото.  # lsmod Module         Pages    Used by helloworld         1          0 Тази команда изчита информацията в /proc/modules, за да ви покаже кои модули са заредени в момента. 'Страниците' (pages) дават информация за паметта (колко страници от паметта заема модула); Полето 'използван от' (used by) ни дава информация колко често модулът се използва от Системата (брой обръщения). Модулът може да бъде отстранен, само когато  този брояч показва нула; след като проверите това, можете да премахнете модула със # rmmod helloworld Е, това беше нашата първа малка стъпка (наистина мъничка) към злоупотребите с LKMs. Винаги съм сравнявал тези LKMs със старите TSR програми под DOS (да, знам, съществуват много разлики), те бяха нашата вратичка за пребиваване в паметта и прихващане на всяко прекъсване, което  пожелаем. Microsoftския WIN 9x има нещо наречено VxD, което също е много подобно на LKMs (и тук има много разлики). Най-интересното при тези резидентни програми е възможността да прихванеме системните функции, наричани 'системни повиквания' (systemcalls)  в света на Linux 2. Какво представляват системните повиквания (systemcalls) Надявам се знаете, че всяка ОС има функции, вградени в ядрото й, които се използват за извършването на всяка една операция в тази система. Функциите, които Linux използва се наричат системни повиквания (systemcalls). Те представляват преход от потребителското пространство към ниво 'ядро'. Отварянето на фаил в потребителското пространство е представено от системно повикване sys_open на ниво ядро. За изчерпателен списък на системните повиквания (systemcalls), които са достъпни за вашата система погледнете в /usr/include/sys/syscall.h. Този списък представлява моят syscall.h #ifndef _SYS_SYSCALL_H #define _SYS_SYSCALL_H #define SYS_setup               0 /* Използва се само от init, за да се 'подкара' системата. */ #define SYS_exit                1 #define SYS_fork                2 #define SYS_read                3 #define SYS_write               4 #define SYS_open                5 #define SYS_close               6 #define SYS_waitpid             7 #define SYS_creat               8 #define SYS_link                9 #define SYS_unlink              10 #define SYS_execve              11 #define SYS_chdir               12 #define SYS_time                13 #define SYS_prev_mknod          14 #define SYS_chmod               15 #define SYS_chown               16 #define SYS_break               17 #define SYS_oldstat             18 #define SYS_lseek               19 #define SYS_getpid              20 #define SYS_mount               21 #define SYS_umount              22 #define SYS_setuid              23 #define SYS_getuid              24 #define SYS_stime               25 #define SYS_ptrace              26 #define SYS_alarm               27 #define SYS_oldfstat            28 #define SYS_pause               29 #define SYS_utime               30 #define SYS_stty                31 #define SYS_gtty                32 #define SYS_access              33 #define SYS_nice                34 #define SYS_ftime               35 #define SYS_sync                36 #define SYS_kill                37 #define SYS_rename              38 #define SYS_mkdir               39 #define SYS_rmdir               40 #define SYS_dup                 41 #define SYS_pipe                42 #define SYS_times               43 #define SYS_prof                44 #define SYS_brk                 45 #define SYS_setgid              46 #define SYS_getgid              47 #define SYS_signal              48 #define SYS_geteuid             49 #define SYS_getegid             50 #define SYS_acct                51 #define SYS_phys                52 #define SYS_lock                53 #define SYS_ioctl               54 #define SYS_fcntl               55 #define SYS_mpx                 56 #define SYS_setpgid             57 #define SYS_ulimit              58 #define SYS_oldolduname         59 #define SYS_umask               60 #define SYS_chroot              61 #define SYS_prev_ustat          62 #define SYS_dup2                63 #define SYS_getppid             64 #define SYS_getpgrp             65 #define SYS_setsid              66 #define SYS_sigaction           67 #define SYS_siggetmask          68 #define SYS_sigsetmask          69 #define SYS_setreuid            70 #define SYS_setregid            71 #define SYS_sigsuspend          72 #define SYS_sigpending          73 #define SYS_sethostname         74 #define SYS_setrlimit           75 #define SYS_getrlimit           76 #define SYS_getrusage           77 #define SYS_gettimeofday        78 #define SYS_settimeofday        79 #define SYS_getgroups           80 #define SYS_setgroups           81 #define SYS_select              82 #define SYS_symlink             83 #define SYS_oldlstat            84 #define SYS_readlink            85 #define SYS_uselib              86 #define SYS_swapon              87 #define SYS_reboot              88 #define SYS_readdir             89 #define SYS_mmap                90 #define SYS_munmap              91 #define SYS_truncate            92 #define SYS_ftruncate           93 #define SYS_fchmod              94 #define SYS_fchown              95 #define SYS_getpriority         96 #define SYS_setpriority         97 #define SYS_profil              98 #define SYS_statfs              99 #define SYS_fstatfs             100 #define SYS_ioperm              101 #define SYS_socketcall          102 #define SYS_klog                103 #define SYS_setitimer           104 #define SYS_getitimer           105 #define SYS_prev_stat           106 #define SYS_prev_lstat          107 #define SYS_prev_fstat          108 #define SYS_olduname            109 #define SYS_iopl                110 #define SYS_vhangup             111 #define SYS_idle                112 #define SYS_vm86old             113 #define SYS_wait4               114 #define SYS_swapoff             115 #define SYS_sysinfo             116 #define SYS_ipc                 117 #define SYS_fsync               118 #define SYS_sigreturn           119 #define SYS_clone               120 #define SYS_setdomainname       121 #define SYS_uname               122 #define SYS_modify_ldt          123 #define SYS_adjtimex            124 #define SYS_mprotect            125 #define SYS_sigprocmask         126 #define SYS_create_module       127 #define SYS_init_module         128 #define SYS_delete_module       129 #define SYS_get_kernel_syms     130 #define SYS_quotactl            131 #define SYS_getpgid             132 #define SYS_fchdir              133 #define SYS_bdflush             134 #define SYS_sysfs               135 #define SYS_personality         136 #define SYS_afs_syscall         137 /* Syscall за файлова система Andrew */ #define SYS_setfsuid            138 #define SYS_setfsgid            139 #define SYS__llseek             140 #define SYS_getdents            141 #define SYS__newselect          142 #define SYS_flock               143 #define SYS_syscall_flock       SYS_flock #define SYS_msync               144 #define SYS_readv               145 #define SYS_syscall_readv       SYS_readv #define SYS_writev              146 #define SYS_syscall_writev      SYS_writev #define SYS_getsid              147 #define SYS_fdatasync           148 #define SYS__sysctl             149 #define SYS_mlock               150 #define SYS_munlock             151 #define SYS_mlockall            152 #define SYS_munlockall          153 #define SYS_sched_setparam      154 #define SYS_sched_getparam      155 #define SYS_sched_setscheduler  156 #define SYS_sched_getscheduler  157 #define SYS_sched_yield         158 #define SYS_sched_get_priority_max      159 #define SYS_sched_get_priority_min      160 #define SYS_sched_rr_get_interval       161 #define SYS_nanosleep           162 #define SYS_mremap              163 #define SYS_setresuid           164 #define SYS_getresuid           165 #define SYS_vm86                166 #define SYS_query_module        167 #define SYS_poll                168 #define SYS_syscall_poll        SYS_poll #endif  /* <sys/syscall.h> */ Всяко системно повикване има определен номер (погледни листинга по-горе), който реално се използва за системно повикване. Ядрото използва прекъсване 0x80 за обслужване на всяко системно повикване. Номерът на systemcall-а и всички необходими аргументи се преместват в някои регистри (eax за номер на systemcall, напр,). номера на системното повикване представлява номер в масив на структура на ядрото, наречен sys_call_table[]. Тази структура съпоставя номерата на системните повиквания  и необходимите сервизни функции. Е, това знание трябва да е достатъчно, за да продължим с четенето. В следващата таблица е даден списък на най-интересните повиквания заедно с кратко описание. Повярвайте ми, трябва да знаете точното действие на тези повиквания, за да  направите наистина полезни LKMи. системно повикване описание int sys_brk(unsigned long new_brk); променя размера на използвания DS (сегмент за данни) ->това повикване ще бъде дискутирано в I.4 int sys_fork(struct pt_regs regs); systemcall отговарящ на добре познатата в потребителското пространство функция fork()  int sys_getuid () int sys_setuid (uid_t uid) ... повиквания за управление на UID и под. int sys_get_kernel_sysms(struct kernel_sym *table) systemcall за достъп до системната таблица на ядрото (kernel system table) (-> I.3) int sys_sethostname (char *name, int len); int sys_gethostname (char *name, int len); sys_sethostname отговаря за установяването на hostname, а sys_gethostname - за получаването му(?) int sys_chdir (const char *path); int sys_fchdir (unsigned int fd); и двете функции се използват за установяване на текущата директория (cd ...) int sys_chmod (const char *filename, mode_t mode); int sys_chown (const char *filename, mode_t mode); int sys_fchmod (unsigned int fildes, mode_t mode); int sys_fchown (unsigned int fildes, mode_t mode); функции за управление на правата и под. int sys_chroot (const char *filename); настройва основната (root) директория за извикващия процес int sys_execve (struct pt_regs regs); Много важен systemcall -> отговаря за изпълнението на файлове (pt_regs е регистров стек) long sys_fcntl (unsigned int fd, unsigned int cmd, unsigned long arg); променя характеристиките на fd (opened file descr.) int sys_link (const char *oldname, const char *newname); int sym_link (const char *oldname, const char *newname); int sys_unlink (const char *name); системно повикване за управление на твърди (hardlinks) или "меки" (softlinks) връзки int sys_rename (const char *oldname, const char *newname); преименува файлове int sys_rmdir (const char* name); int sys_mkdir (const *char filename, int mode); създава и премахва директории int sys_open (const char *filename, int mode); int sys_close (unsigned int fd); за всичко свързано с отварянето на файлове (включително създаването им), а също и затварянето им int sys_read (unsigned int fd, char *buf, unsigned int count); int sys_write (unsigned int fd, char *buf, unsigned int count); системни повиквания за запис и четене от файлове int sys_getdents (unsigned int fd, struct dirent *dirent, unsigned int count); systemcall, чрез който се извлича списък на файлове (командата ls ...)  int sys_readlink (const char *path, char *buf, int bufsize); чете символични връзки int sys_selectt (int n, fd_set *inp, fd_set *outp, fd_set *exp, struct timeval *tvp); multiplexing на I/O операциите sys_socketcall (int call, unsigned long args); socket функции unsigned long sys_create_module (char *name, unsigned long size); int sys_delete_module (char *name); int sys_query_module (const char *name, int which, void *buf, size_t bufsize, size_t *ret); използва се за зареждане / отстраняване на LKMи и за запитвания По мое мнение, това са най-интересните системни повиквания за имащите хакерски намерения, разбира се, възможно е да се нуждаете от нещо специално на системата в която тършувате, но обикновенният хакер има изобилие от възможности със списъка даден по-горе. В част II ще се научите как да използвате системните повиквания в своя полза. 3. Какво представлява Kernel-Symbol-Table (таблица със символите на ядрото) символ - нещо (напр. графично изображение), което представлява/олицетворява обект/събект/нещо абстрактно т.е. всеки символ на ядрото представлява някаква негова функция бел. пр. Е, добре! Разбираме основната концепция за системните повиквания (systemcalls) и модулите. Но има още нещо, и то много важно, което трябва да разберем - Kernel Symbol Table (таблица със символите на ядрото. Погледнете /proc/ksyms. Всеки ред в този файл представлява експортиран (публичен) символ на ядрото, който е достъпен за нашият LKM. Огледайте добре този файл; ще откриете много интересни неща в него. Файлът е наистина интересен и може да ни помогне да разберем какво може да използва нашият LKM , но има един проблем. Всеки символ използван в нашият LKM (като функция) също се експортира в този "публичен регистър" т.е. появява се в този файл-списък. Така един опитен администратор би могъл да открие малкият ни LKM и да го отстрани (kill). Съществуват много методи, чрез които да не позволим на админите да видят нашият LKM, вижте раздел II. Матодите споменати в II могат да бъдат наречени 'хакове', но когато разгледате съдържанието на раздел II няма да откриете препратка към "Как да държиме LKM символите далеч от /proc/ksyms". Причината да не споменаваме този проблем в раздел II е следната : няма да се нуждаете от трик, за да не допуснете модули-символи си до /proc/ksyms. Разработчиците на LKM могат да използват следният отрязък "нормален" код, за да спрат експортираните символи от техният модул: static struct symbol_table module_syms= { /*дефинираме собствена таблица на символите !*/  #include <linux/symtab_begin.h>          /*Символите които искаме да експортираме, а искаме ли ?*/    ...                                        }; register_symtab(&module_syms);            /*извършва истинското регистриране*/ Тъй като не искаме да изнасяме никакви символи на показ, използваме следната конструкция : register_symtab(NULL); Този ред трябва да бъде вмъкнат във функцията init_module(), запомнете го ! << (почти)Пълно ръководство за модулите в Linux ядрото [част 2] | Как да защитите вашият Linux (част 2) >>

Коментари: (общо 3)	Оценени с -1 0 1 2 3 4 5 или повече	[Пълен преглед>>]
[Добави коментар]

• dai oshte ! [30-05-2001] {1/Неутрален}
• linux [26-08-2001] {1/Неутрален}
• at first look excellent [12-10-2001] {1/Неутрален}