Bonjour a tous

Comment fonctionne createprocess car elle a chaque fois elle revoi false ?

	PROCESS_INFORMATION piProcInfo;
	STARTUPINFO siStartInfo;
	BOOL bSuccess = FALSE;

	// Set up members of the PROCESS_INFORMATION structure. 

	ZeroMemory(&piProcInfo, sizeof(PROCESS_INFORMATION));

	// Set up members of the STARTUPINFO structure. 
	// This structure specifies the STDIN and STDOUT handles for redirection.

	ZeroMemory(&siStartInfo, sizeof(STARTUPINFO));
	siStartInfo.cb = sizeof(STARTUPINFO);
	siStartInfo.hStdError = g_hChildStd_OUT_Wr;
	siStartInfo.hStdOutput = g_hChildStd_OUT_Wr;
	siStartInfo.hStdInput = g_hChildStd_IN_Rd;
	siStartInfo.dwFlags |= STARTF_USESTDHANDLES;

	LPCWSTR cmd = (LPCWSTR)L"cmd.exe";


	// Create the child process.
	bSuccess = CreateProcess(cmd,
		NULL,          // command line 
		NULL,          // process security attributes 
		NULL,          // primary thread security attributes 
		TRUE,          // handles are inherited 
		CREATE_NO_WINDOW,             // creation flags 
		NULL,          // use parent's environment 
		NULL,          // use parent's current directory 
		&siStartInfo,  // STARTUPINFO pointer 
		&piProcInfo);  // receives PROCESS_INFORMATION 

	// If an error occurs 
	if (!bSuccess)
		return -1;

-
Edité par JEANBAPTISTECOMTE1 14 décembre 2022 à 19:39:10

Exacte j'ai une eurreur 2 ==> ERROR_FILE_NOT_FOUND

Du coup j'ai mis le chemin exacte C:/Windows/System32/cmd.exe

Et maintenant ca fonctionne

Par contre quelqu'un sait comment ecrire et lire des commandes via un sous process ?

Salut,

markand a écrit:

Je pense que ça serait plus simple de nous expliquer d'abord ce que tu souhaites faire car ça parait farfelu.

C'est surtout que là, on est sur du code clairement spécifique à windows.

Cela peut ne poser aucun problème particulier ... jusqu'au jour où l'on voudra porter l'application sous linux, android ou mac. Et là, il faudra rendre le code encore plus imbitable pour en utilisant de "ruses de sioux" comme des conditions préprocesseur afin de ne garder que la partie correspondant à la cible en question.

Quand on sait qu'il y a ** sans doute ** moyen d'obtenir le même résultat d'une manière "standard" (ou proche de l'être) en laissant tous ces problèmes aux développeurs des bibliothèques utilisées, on se dit qu'il est quand même dommage d'essayer de recréer une roue qui sera forcément carrée alors que la roue bien circulaire existe déjà

Enfaite j'aimerai comprendre comment fonctionne un reverse shell, en gros j'aimerais creer un sous process "cmd" et envoyé des commandes via une socket

J'ai trouvé ceci https://github.com/werkamsus/Lilith

Mais j'ai pas envie de copier bêtement le code, j'aimerais le comprendre

"reverse shell"

Expliquez ce que vous entendez par là, SVP ?

Ca sens l'exploit de sécurité.

-
Edité par bacelar 22 décembre 2022 à 16:08:03

C'est potentiellement très dangereux et il existe déjà toute une palanqué de "produit" type rssh et consort, sans compter les systèmes "natifs" à l'OS comme WMI etc...

Déjà que les outils natifs aux OS ou les produits OpenSoure (donc relu par what milliers de dev) comme rssh se font régulièrement démonter la gueule par des hackers du dimanche.

Vous voulez vraiment faire partie du club des fabricants de backdoor ???

Utilisez plutôt les systèmes natifs de l'OS ou des produits qui le font déjà.

>Oui car je veux comprendre comment ca fonctionne

Bin, j'espère pas avec un "vrai" shell. Sinon, on n'est bon pour l'exploite de programme shell à distance. (ils n'ont pas été fait pour)

A part prouver qu'une "solution" scabreuse donne de jolies portes d'entrée aux attaquants, je vois pas ce que vous apprendrez.

"cmd.exe" est truffé de faiblesses (les backslash à répétition qui font crasher en mode yolo, etc...) donc faire passe-plat vers lui, c'est vraiment pas une idée de génie.

int main()
{
	orion::ExecuteCMD2 ecmd2;
	if (!ecmd2.init())
	{
		std::cout << "init failed";
	}
	ecmd2.createChildProcess(L"C:/Windows/System32/cmd.exe");

	ecmd2.writeCMD("dir");
	std::cout << ecmd2.readCMD();

	return 0;
}

#ifndef ExecuteCMD2_H
#define ExecuteCMD2_H
#include "Export.h"
#include <string>
#include <Windows.h>
#include <iostream>

namespace orion
{
	class NetworkEngine ExecuteCMD2
	{
	public:
		ExecuteCMD2();
		bool init();
		bool createChildProcess(const LPCWSTR& path);
		std::string readCMD();
		void writeCMD(std::string command);
	private:
		HANDLE g_hChildStd_IN_Rd = NULL;
		HANDLE g_hChildStd_IN_Wr = NULL;
		HANDLE g_hChildStd_OUT_Rd = NULL;
		HANDLE g_hChildStd_OUT_Wr = NULL;

		HANDLE g_hChildProcess;
		HANDLE g_hChildThread;

		SECURITY_ATTRIBUTES saAttr;

		bool cmdOpen;
	};
}

#endif // !ExecuteCMD2_H

#include "../include/ExecuteCMD2.h"

orion::ExecuteCMD2::ExecuteCMD2():cmdOpen(false)
{
	saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
	saAttr.bInheritHandle = TRUE;
	saAttr.lpSecurityDescriptor = NULL;
}

bool orion::ExecuteCMD2::init()
{
	if (!CreatePipe(&g_hChildStd_OUT_Rd, &g_hChildStd_OUT_Wr, &saAttr, 0))
	{
		return false;
	}
	// Ensure the read handle to the pipe for STDOUT is not inherited.

	if (!SetHandleInformation(g_hChildStd_OUT_Rd, HANDLE_FLAG_INHERIT, 0))
	{
		return false;
	}
	// Create a pipe for the child process's STDIN. 

	if (!CreatePipe(&g_hChildStd_IN_Rd, &g_hChildStd_IN_Wr, &saAttr, 0))
	{
		return false;
	}

	// Ensure the write handle to the pipe for STDIN is not inherited. 

	if (!SetHandleInformation(g_hChildStd_IN_Wr, HANDLE_FLAG_INHERIT, 0))
	{
		return false;
	}

	return true;
}

bool orion::ExecuteCMD2::createChildProcess(const LPCWSTR &path)
{
	STARTUPINFO si;
	PROCESS_INFORMATION pi;
	BOOL bSuccess = FALSE;

	ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));

	ZeroMemory(&si, sizeof(STARTUPINFO));
	si.cb = sizeof(STARTUPINFO);
	si.hStdError = g_hChildStd_OUT_Wr;
	si.hStdOutput = g_hChildStd_OUT_Wr;
	si.hStdInput = g_hChildStd_IN_Rd;
	si.dwFlags |= STARTF_USESTDHANDLES;

	LPWSTR Process = (LPWSTR)path;

	bSuccess = CreateProcess(Process, NULL, NULL, NULL, TRUE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi);

	if (!bSuccess)
	{
		return false;
	}
	else
	{
		cmdOpen = true;
		//CloseHandle(pi.hProcess);
		//CloseHandle(pi.hThread);
	}
	g_hChildProcess = pi.hProcess;
	g_hChildThread = pi.hThread;
	return true;
}


std::string orion::ExecuteCMD2::readCMD()	//read string from stdOut of cmd.exe	//IMPLEMENT AS THREAD
{
	if (cmdOpen)
	{
		DWORD bytesAvailable = 0;
		DWORD bytesRead = 0;
		int intBytesAvailable = 0;
		char buffer[128] = "";
		std::string output;

		do		//loop until bytes are available (until response is processed)
		{
			PeekNamedPipe(g_hChildStd_OUT_Rd, NULL, 0, NULL, &bytesAvailable, NULL);
			Sleep(50);
		} while (bytesAvailable <= 0);

		intBytesAvailable = bytesAvailable;
		while (intBytesAvailable > 0)		//while there is something to read, read it into buffer and append buffer to string
		{
			ReadFile(g_hChildStd_OUT_Rd, buffer, 127, &bytesRead, NULL);
			buffer[127] = '\0';	//NULL terminator of string
			output += buffer;
			intBytesAvailable -= bytesRead;
			if (intBytesAvailable <= 0)
				intBytesAvailable = 0;
			ZeroMemory(buffer, 128);					//clears buffer (else memory leak)
		}
		return output;
	}
	else
	{
		return "CMD is not open";
	}
}


void orion::ExecuteCMD2::writeCMD(std::string command)		//write a string to stdIn of cmd.exe
{
	if (cmdOpen)
	{
		DWORD dwWritten = 0;    // Support low version Windows
		command += '\n';	//append '\n' to simulate "ENTER"
		if (!WriteFile(g_hChildStd_IN_Wr, command.c_str(), command.size(), &dwWritten, NULL))
		{
			std::cout << "Couldn't write command  to stdIn";
		}
			//Client::clientptr->SendString("Couldn't write command '" + command + "' to stdIn.", PacketType::Warning);
	}
	else
	{
		std::cout << "Couldn't write to CMD: CMD not open";
	}
}

-
Edité par JEANBAPTISTECOMTE1 26 décembre 2022 à 15:21:15

Pour des "g_" et pas des "m_" ?

Retourner un bool sans avoir de possibilité de savoir pourquoi s'est partie en sucette, c'est très moyen. Les exceptions sont nos amies.

Vous ne vérifiez pas systématiquement les valeurs de retour, donc votre approche à base de boolean est failli.

Votre erreur, c'est à la compilation ou à l'exécution ?

Si c'est à l'exécution, c'est à quelle ligne ?

C'est quoi le working directory de votre shell ?

Je n'ai pas d'erreur a la compilation et je n'est pas de crash

L'exe ce trouve ici "C:\Users\user1\OneDrive\Documents\myDev\Perso\Project22\bin\x64\Debug"

et le cmd ici "C:\Windows\System32\cmd.exe"

C'est la méthode readCMD qui me renvoi "Un sous-répertoire ou un fichier .exe existe déjà."

Et peu importe ce que je mets dans writeCMD j'ai toujours le même résultat

Le Working Directory n'a rien à voir avec le chemin vers le fichier contenant "l'image" du processus.

C'est le machin que vous renseignez avec le paramètre "lpCurrentDirectory" de CreateProcess.

Dans vos exemples, vous ne semblez pas le spécifié, c'est donc que le processus créé hérite de la valeur de son processus père, au moment de la création.

Quel est donc la valeur du "Working Directory" pour le rejeton ?

L'interprétation des commandes, des chemins vers les fichiers, les droits, etc... sont fonction, au moins partiellement de valeur du "Working Directory".

Franchement, si vous ne maîtrisez pas ça, vous avec 100% de faire un programme qui est une passoire sécuritaire.

Vous êtes en train d'apprendre à faire ce qu'il ne faut pas faire.

Apprenez à utiliser les bons outils. Déjà qu'avec ça, on n'est pas à l'abri d'une exploite, mais un remote shell fait par un newbie/rookie (no offense), c'est du suicide.

S vous persistez, maîtrisez un minimum les concepts et tentez de faire la même chose mais en local : créer/lancer un CMD avec le même utilisateur, le même working directory, etc... : vous aurez vraisemblablement les mêmes messages sur la sortie standard mais vous disposerez aussi de la sortie erreur.

Moi, en fainéant, j'utiliserais un outil comme Process Monitor pour savoir quel fichier votre bidule cherche et semble avoir trouvé.

https://learn.microsoft.com/en-us/sysinternals/downloads/procmon

Mais bon, pour un apprenti black/gray/white hat, mentionner "Process Monitor", c'est comme parler des jouets qu'on avait à la maternelle.