Escalata dei privilegi locali in HP Support Assistant

Una vulnerabilità di escalation dei privilegi locali in HP Support Assistant tramite abuso di hard link

Ricercatore: ManhNDd di Bkav

Descrizione

Nella GUI di HP Support Assistant, quando si fa clic su Check for updates and messages, il servizio HP Support Solution Framework esegue alcune attività, avvia HPSAObjUtil8.exe (eseguito come SYSTEM) che modifica i permessi di tutti i file .xml in C:\ProgramData\Hewlett-Packard\HP Support Framework\Logs\Temp\HPSA. In dettaglio, HPSAObjUtil8.exe concede a tutti gli utenti il controllo completo su questi file .xml. Di seguito è riportato il codice vulnerabile in HPSAObjUtil8:

public static void AddTempLogsPermission()
	{
		string path = Environment.GetEnvironmentVariable("ProgramData") + "\\Hewlett-Packard\\HP Support Framework\\Logs\\Temp\\HPSA";
		if (Directory.Exists(path))
		{
			string[] files = Directory.GetFiles(path, "*.xml");
			if (files != null && files.Length != 0)
			{
				foreach (string fileOrFolderName in files)
				{
					Patches._utils.AddFileSecurity(fileOrFolderName);
				}
			}
		}
	}

Un utente può creare un hard link con nome ???.xml nella cartella C:\ProgramData\Hewlett-Packard\HP Support Framework\Logs\Temp\HPSA e farlo puntare a un file vittima a propria scelta (è necessario solo l'accesso in lettura), quindi lasciare che HPSAObjUtil8 ne modifichi i permessi, così da ottenere pieni permessi sul file (lettura/scrittura/eliminazione). Questa vulnerabilità consente quindi di ottenere pieni permessi sui file di sistema => è possibile sovrascrivere una DLL di sistema per ottenere privilegi di sistema. A proposito, il punteggio CVSS 3.0 della vulnerabilità imposta Privilegi richiesti su Alto. Dovrebbe essere Nessuno, perché ho testato la vulnerabilità con successo su un utente non amministratore.

Sfruttamento

Reverse engineering di HPSF.exe e HPSupportSolutionsFrameworkService.exe, ho scoperto che il client HPSF.exe comunica con il servizio tramite l'interfaccia HP.SupportFramework.ServiceManager.Interfaces.IServiceInterface (definita in HP.SupportFramework.ServiceManager.dll). Se il client chiama il metodo IserviceInterface.RunAnalysis, il servizio avvia HPSAObjUtil8 e attiva la vulnerabilità.

ServiceInterface.Instance.RunAnalysis("en-US", true);

Quindi è necessario creare un client fittizio e chiamare RunAnalysis. Tuttavia, il servizio valida il proprio client prima di elaborare la richiesta:

• Verifica che il client sia firmato con firma HP e si trovi nel volume C.
• Verifica che il padre, il nonno, il bisnonno... del client sia firmato con firma HP o sia un processo Windows valido (ad esempio in System32). Tuttavia, se il metodo GetParent restituisce null, il controllo si interrompe.

        {
            Process processById = Process.GetProcessById(\u0002);
            string text = \u000E.\u0001(processById);
            if (processById.MainModule.FileName.ToLowerInvariant() != text.ToLowerInvariant())
            {
                if (DebugLog.IsDebug)
                {
                    DebugLog.LogDebugMessage("Invalid File detected: " + text, DebugLog.IndentType.None);
                }
                return false;
            }
            Process parent = processById.GetParent();
            bool flag = true;
            int num = 0;
            while (parent != null && flag && num <= 5)
            {
                bool flag2;
                flag = \u000E.\u0001(parent, out flag2);
                if (!flag || flag2)
                {
                    break;
                }
                num++;
                parent = parent.GetParent();
            }
            return flag;
        }

Ora aggiriamo la validazione del client:

• Per aggirare il controllo della firma, è necessario avviare un EXE firmato HP e iniettarvi del codice, oppure creare una DLL fittizia che l'EXE HP carichi. Scelgo il secondo metodo. Ho scoperto che BatteryTest.exe (in C:\Program Files (x86)\Hewlett-Packard\HP Support Framework\Resources\HPBatteryCheck) è firmato con firma HP e, quando avvio BatteryTest.exe, tenta di caricare userenv.dll nella propria directory prima di cercarla in %PATH%. Quindi creo una userenv.dll fittizia, la copio insieme a BatteryTest.exe nella stessa cartella, poi eseguo BatteryTest => BatteryTest diventa il nostro client exe e attiva RunAnalysis per noi => bypass del controllo della firma del client.
• Copio BatteryTest.exe e altri file necessari in %tmp%, così che si trovino nel volume C => garantendo che il client sia nel volume C.
• Per aggirare il controllo del processo padre, creo un programma che avvia BatteryTest.exe ed esce immediatamente, così GetParent restituisce null!

Ora bisogna trovare un eseguibile che possa essere il bersaglio dell'hard link. Deve essere un EXE o una DLL che verrà eseguita come SYSTEM automaticamente in un secondo momento, così che quando lo si sovrascrive, si ottengono privilegi SYSTEM. Noto che quando si chiama RunAnalysis, HPSupportSolutionsFrameworkService avvia molti processi come SYSTEM. Si possono sovrascrivere questi processi con il proprio eseguibile. Tuttavia, il servizio verifica le firme di quegli EXE prima di avviarli, quindi non è possibile creare EXE falsi, ma si può ricorrere a DLL caricate da quegli EXE. Molte DLL sono già caricate da qualche parte e molte DLL .NET vengono verificate tramite firma prima di essere caricate, quindi non è possibile usarle. Fortunatamente, rimangono alcune DLL utilizzabili:

• c:\program files (x86)\hp\shared\hputils64.dll, caricata da Detect_BatteryFailure.exe (firmato HP).
• c:\windows\syswow64\rtutils.dll
• c:\windows\system32\msxml3.dll

Ho provato a modificare hputils64.dll e ci sono riuscito. Creo un hard link a hputils64.dll. Quando si chiama RunAnalysis, HPSAObjUtil8 modifica i permessi di hputils64.dll, quindi pochi secondi dopo Detect_BatteryFailure.exe si avvia (come LOCAL SYSTEM) e carica hputils64.dll. Prima che hputils64 venga caricata, è possibile sovrascriverla, così Detect_BatteryFailure.exe carica la nostra DLL dannosa e finalmente si ottengono i diritti SYSTEM.

Conclusione

Per scrivere l'exploit, ho creato:

• CreateProcess.exe: avvia un processo ed esce. Serve per il bypass della validazione del processo padre.
• CreateHardlink.exe: crea l'hard link.
• Userenv.dll: prepara le cose per eseguire un assembly .NET ed esegue l'assembly invader.exe nel contesto di BatteryTest. Serve per il bypass della validazione della firma del client.
• Invader.exe: chiama RunAnalysis che attiva la vulnerabilità.
• MalDll.dll: avvia notepad. hputils64.dll viene sovrascritta con questa DLL.

Di seguito i passaggi di sfruttamento in PrivHP4.py:

1. Copiare BatteryTest.exe e altri file necessari nella cartella %tmp%.
2. Creare un hard link da C:\ProgramData\Hewlett-Packard\HP Support Framework\Logs\Temp\HPSA\hardlink.xml a C:\Program Files (x86)\HP\Shared\hputils64.dll.
3. Avviare BatteryTest.exe con CreateProcess.exe. CreateProcess.exe termina immediatamente dopo l'avvio di BatteryTest.
4. Attendere che i permessi di C:\Program Files (x86)\HP\Shared\hputils64.dll vengano modificati, quindi sovrascriverla con MalDll.dll e infine attendere che notepad si avvii come SYSTEM!

Per testare la PoC, basta clonare il repository ed eseguire PrivHP4.py.

Riferimenti

1. https://support.hp.com/us-en/document/c06388027
2. http://www.securityfocus.com/bid/108891