ANTICHAT — форум по информационной безопасности, OSINT и технологиям

#include <iostream>
using namespace std;
int main()   
{   
    cout << "Hello\n";   
    cin.get();   
    return 0;   
}

#include <iostream>
#include <windows.h>
using namespace std;
int main()   
{   
    cout << "PreweDD\n";   
    system("PAUSE");   
    return 0;   
}

#include "proc.h"

CIORedirection::CIORedirection()
{
    ZeroFields();
	wait = 60000;
}

CIORedirection::~CIORedirection()
{
    Close();
}

CIORedirection::CIORedirection(const CIORedirection&)
{
}

void CIORedirection::operator = (const CIORedirection&)
{
}

void CIORedirection::ZeroFields()
{
    m_hNewStdIn = m_hNewStdOut = m_hReadStdOut = m_hWriteStdIn = NULL;
    ::ZeroMemory((void*)&m_processInfo, sizeof(PROCESS_INFORMATION));
    ::ZeroMemory((void*)&m_startupInfo, sizeof(STARTUPINFO));
    ::ZeroMemory((void*)&m_secAttributes, sizeof(SECURITY_ATTRIBUTES));
    ::ZeroMemory((void*)&m_secDescriptor, sizeof(SECURITY_DESCRIPTOR));
}

BOOL CIORedirection::IsWinNT()
{
    OSVERSIONINFO osverinfo;
    osverinfo.dwOSVersionInfoSize = sizeof(osverinfo);
    ::GetVersionEx(&osverinfo);
    return (osverinfo.dwPlatformId == VER_PLATFORM_WIN32_NT);
}

void CIORedirection::InitSecurity()
{
    if (IsWinNT())
    {
        ::InitializeSecurityDescriptor(&m_secDescriptor,
                                    SECURITY_DESCRIPTOR_REVISION);
        ::SetSecurityDescriptorDacl(&m_secDescriptor, TRUE, NULL, FALSE);
        m_secAttributes.lpSecurityDescriptor = &m_secDescriptor;
    }
    else m_secAttributes.lpSecurityDescriptor = NULL;
    m_secAttributes.nLength = sizeof(SECURITY_ATTRIBUTES);
    m_secAttributes.bInheritHandle = TRUE;
}

void CIORedirection::Create(const char *pAppName, char *pCmdLine, char *CurrentDirectory)
{
    if (m_processInfo.hProcess)
		return;
    InitSecurity();
    if (!::CreatePipe(&m_hNewStdIn, &m_hWriteStdIn, &m_secAttributes, 0))
		return;
    if (!::CreatePipe(&m_hReadStdOut, &m_hNewStdOut, &m_secAttributes, 0))
    {
        CloseHandle(m_hNewStdIn);
        CloseHandle(m_hWriteStdIn);
		return;
    }
    ::GetStartupInfo(&m_startupInfo);
    m_startupInfo.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
    m_startupInfo.wShowWindow = SW_HIDE;
    m_startupInfo.hStdOutput = m_hNewStdOut;
    m_startupInfo.hStdError = m_hNewStdOut;
    m_startupInfo.hStdInput = m_hNewStdIn;
    if (!::CreateProcess(pAppName, pCmdLine, NULL, NULL, TRUE,
        CREATE_NEW_CONSOLE, NULL, CurrentDirectory, &m_startupInfo, &m_processInfo))
    {
        Close();
		return;
    }
	WaitForSingleObject(m_processInfo.hProcess, wait);
}

DWORD CIORedirection::GetExitCode() const
{
    DWORD dwExitCode = 0;
    GetExitCodeProcess(m_processInfo.hProcess, &dwExitCode);
    return dwExitCode;
}

void CIORedirection::Terminate()
{
    DWORD dwExitCode = GetExitCode();
    TerminateProcess(m_processInfo.hProcess, dwExitCode);
}

void CIORedirection::Close()
{
    if (GetExitCode() == STILL_ACTIVE) Terminate();
    if (m_processInfo.hProcess)
    {
        ::CloseHandle(m_processInfo.hThread);
        ::CloseHandle(m_processInfo.hProcess);
    }
    if (m_hNewStdIn) ::CloseHandle(m_hNewStdIn);
    if (m_hNewStdOut) ::CloseHandle(m_hNewStdOut);
    if (m_hReadStdOut) ::CloseHandle(m_hReadStdOut);
    if (m_hWriteStdIn) ::CloseHandle(m_hWriteStdIn);
    ZeroFields();
}

BOOL CIORedirection::Read(char *lpBuf,
                          DWORD dwBufSize,
                          DWORD *pBytesRead)
{
    unsigned long avail;
    BOOL bRes = ::PeekNamedPipe(m_hReadStdOut,lpBuf,dwBufSize,pBytesRead,&avail,NULL);
    if (!bRes)
		return FALSE;
    if (*pBytesRead != 0)
	{
        bRes = ::ReadFile(m_hReadStdOut,lpBuf,dwBufSize,pBytesRead,NULL);
	}
    return bRes;
}

BOOL CIORedirection::Write(const char *lpBuf,
                           DWORD dwBufSize,
                           DWORD *pBytesRead)
{
	WriteFile(m_hWriteStdIn, lpBuf, dwBufSize, pBytesRead, NULL);
	Read((char *)lpBuf, dwBufSize, pBytesRead);
    return (::WriteFile(m_hWriteStdIn, "\n", dwBufSize, pBytesRead, NULL));
}

void CIORedirection::SetWait(int milliseconds)
{
	wait = milliseconds;
}

int FileExists(char *directory, char *filename)
{
	WIN32_FIND_DATAA dataFind;
	HANDLE hFind;
	hFind = FindFirstFileA(filename, &dataFind);
	if(hFind == INVALID_HANDLE_VALUE)
	{
		char abs_path[MAX_PATH];
		if(directory[strlen(directory)-1] == '\\')
			sprintf(abs_path, "%s%s", directory, filename);
		else
			sprintf(abs_path, "%s\\%s", directory, filename);
		hFind = FindFirstFileA(abs_path, &dataFind);
		if(hFind == INVALID_HANDLE_VALUE)
		{
			if(strlen(filename) == 3 && filename[1] == ':')
			{
				DWORD uDrive = toupper(filename[0]) - 'A';
				uDrive = 1 << uDrive;
				if(GetLogicalDrives() & uDrive)
					return 1;
				else
					return 0;
			}
			else
				return 0;
		}
		FindClose(hFind);
		return 2;
	}
	FindClose(hFind);
	return 1;
}

CMD::CMD()
{
	GetCurrentDirectoryA(MAX_PATH, cur_dir);
	sys_env = (char *)malloc(2000);
	memset(sys_env, 0, 2000);
	GetEnvironmentVariableA("Path", sys_env, 2000);
	env_pos = strlen(sys_env);
	sys_env[env_pos] = ';';
	memcpy(sys_env+env_pos+1, cur_dir, strlen(cur_dir));
	SetEnvironmentVariableA("Path", sys_env);
}

void CMD::SetWait(int milliseconds)
{
	console.SetWait(milliseconds);
}

void CMD::Exec(char *command, char *outbuf, int bufsize)
{
	if(!memcmp(command, "cd ", 3))
	{
		char buffer[MAX_PATH+3];
		int offset = 0, len, res;
		strcpy(buffer, command);
		offset = 3;
		if(buffer[offset] == '"')
			offset++;
		len = strlen(buffer)-1;
		if(buffer[len] == '"')
		{
			buffer[len] = 0;
			len--;
		}
		if(buffer[len] == '\\' && buffer[len-1] != ':')
			buffer[len] = 0;
		res = FileExists(cur_dir, &buffer[offset]);
		if(!res)
			goto m1;
		if(res == 1)
			strcpy(cur_dir, &buffer[offset]);
		else if(res == 2)
		{
			strcat(cur_dir, "\\");
			strcat(cur_dir, &buffer[offset]);
		}
		sys_env[env_pos+1] = 0;
		strcat(sys_env, cur_dir);
		SetEnvironmentVariableA("Path", sys_env);
		goto m1;
	}
	char filename[MAX_PATH];
	GetSystemDirectory(filename, MAX_PATH);
	sprintf(filename, "%s\\cmd.exe /c %s", filename, command);
	console.Create(0, filename, cur_dir);
	console.Read(outbuf, bufsize, (DWORD *)&bufsize);
	console.Close();
	outbuf += bufsize;
m1:
	sprintf(outbuf, "%s>", cur_dir);
}

		char buffer[10000];
		memset(buffer, 0, sizeof(buffer);
		cmd.Exec("dir", buffer, sizeof(buffer));