Escalade de privilèges locale dans HP Support Assistant

Un bug d'escalade de privilèges locale dans HP Support Assistant en abusant des liens physiques (hard links)

Chercheur : ManhNDd de Bkav

Description

Dans HP Support Assistant GUI, lorsque vous cliquez sur Check for updates and messages, le service HP Support Solution Framework exécute certaines tâches, lance HPSAObjUtil8.exe (s'exécute en tant que SYSTEM) qui modifie les permissions de tous les fichiers .xml dans C:\ProgramData\Hewlett-Packard\HP Support Framework\Logs\Temp\HPSA. En détail, HPSAObjUtil8.exe accorde un contrôle total sur ces fichiers .xml à tous les utilisateurs. Voici le code vulnérable dans 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 utilisateur peut créer un lien physique (hardlink) avec un nom ???.xml dans le dossier C:\ProgramData\Hewlett-Packard\HP Support Framework\Logs\Temp\HPSA, et le pointer vers un fichier victime de notre choix (nous avons seulement besoin d'un accès en lecture), puis laisser HPSAObjUtil8 modifier ses permissions afin que nous obtenions un contrôle total sur le fichier (lecture/écriture/suppression). Ce bug nous permet donc d'obtenir des permissions complètes sur des fichiers système => vous pouvez écraser une DLL système pour obtenir les privilèges système. Au passage, le score CVSS 3.0 de ce bug définit Privileges Required comme élevé (High). Cela devrait être Aucun (None), car j'ai testé le bug avec succès sur un utilisateur non administrateur.

Exploitation

En rétro-ingénierie de HPSF.exe et HPSupportSolutionsFrameworkService.exe, j'ai découvert que le client HPSF.exe communique avec le service via l'interface HP.SupportFramework.ServiceManager.Interfaces.IServiceInterface (définie dans HP.SupportFramework.ServiceManager.dll). Si le client appelle la méthode IserviceInterface.RunAnalysis, le service démarrera HPSAObjUtil8 et déclenchera le bug.

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

Vous devez donc créer un faux client et appeler RunAnalysis. Cependant, le service valide son client avant de traiter la requête :

• Vérifie si le client est signé avec la signature HP et se trouve dans le volume C.
• Vérifie si le parent, le grand-parent, l'arrière-grand-parent... du client est signé avec la signature HP ou est un processus Windows valide (dans System32, par exemple). Cependant, si la méthode GetParent renvoie null, la vérification s'arrête.

        {
            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;
        }

Contournons la validation du client :

• Pour contourner la vérification de signature, vous devez lancer un EXE signé HP et y injecter du code, ou créer une fausse DLL que l'EXE HP chargera. J'ai choisi la seconde méthode. J'ai découvert que BatteryTest.exe (dans C:\Program Files (x86)\Hewlett-Packard\HP Support Framework\Resources\HPBatteryCheck) est signé avec la signature HP, et lorsque j'exécute BatteryTest.exe, il tente de charger userenv.dll dans son répertoire avant de chercher dans %PATH%. J'ai donc créé une fausse userenv.dll et je l'ai copiée ainsi que BatteryTest.exe dans le même dossier, puis j'ai lancé BatterTest => BatterTest devient notre exe client et déclenche RunAnalysis pour vous => contournement de la vérification de signature du client.
• Je copie BatterTest.exe et d'autres fichiers nécessaires dans %tmp%, afin qu'ils soient dans le volume C => garantissant que le client est dans le volume C.
• Pour contourner la vérification du parent, je crée un programme qui lance BatteryTest.exe et se termine immédiatement, de sorte que GetParent renvoie null !

Maintenant, vous devez trouver un exécutable qui puisse être la cible du lien physique (hardlink). Il doit s'agir d'un EXE ou d'une DLL qui sera exécuté automatiquement en tant que SYSTEM à un moment donné, de sorte que lorsque vous l'écrasez, vous obtenez les privilèges SYSTEM. Je constate que lors de l'appel à RunAnalysis, HPSupportSolutionsFrameworkService lance de nombreux processus en tant que SYSTEM. Vous pouvez écraser ces processus avec votre propre exécutable. Cependant, le service vérifie les signatures de ces EXE avant de les lancer, vous ne pouvez donc pas créer de faux EXE, mais vous pouvez recourir aux DLL chargées par ces EXE. Il existe de nombreuses DLL déjà chargées quelque part, et de nombreuses DLL .NET sont vérifiées par signature avant d'être chargées, vous ne pouvez donc pas les utiliser. Heureusement, il reste certaines DLL utilisables :

• c:\program files (x86)\hp\shared\hputils64.dll, chargée par Detect_BatteryFailure.exe (signé HP).
• c:\windows\syswow64\rtutils.dll
• c:\windows\system32\msxml3.dll

J'ai essayé de modifier hputils64.dll et j'ai réussi. Je crée un lien physique (hardlink) vers hputils64.dll. Lors de l'appel à RunAnalysis, HPSAObjUtil8 modifie les permissions de hputils64.dll, puis quelques secondes plus tard Detect_BatteryFailure.exe démarre (en tant que LOCAL SYSTEM) et charge hputils64.dll. Avant le chargement de hputils64, vous pouvez l'écraser, de sorte que Detect_BatteryFailure.exe charge votre DLL malveillante et vous obtenez finalement les droits SYSTEM.

Conclusion

Pour écrire l'exploit, j'ai créé :

• CreateProcess.exe : lancer un processus et quitter. Utilisé pour contourner la validation du parent.
• CreateHardlink.exe : créer un lien physique (hardlink).
• Userenv.dll : configurer les choses pour exécuter un assembly .NET et exécuter l'assembly invader.exe dans le contexte de BatterTest. Utilisé pour contourner la validation de la signature du client.
• Invader.exe : appeler RunAnalysis qui déclenchera le bug.
• MalDll.dll : lancer le bloc-notes (notepad). hputils64.dll est écrasé avec cette DLL.

Voici les étapes d'exploitation dans PrivHP4.py :

1. Copier BatteryTest.exe et d'autres fichiers nécessaires dans le dossier %tmp%.
2. Créer un lien physique (hardlink) de C:\ProgramData\Hewlett-Packard\HP Support Framework\Logs\Temp\HPSA\hardlink.xml vers C:\Program Files (x86)\HP\Shared\hputils64.dll
3. Lancer BatteryTest.exe avec CreateProcess.exe. CreateProcess.exe se terminera immédiatement après avoir lancé BatterTest.
4. Attendre que la permission de C:\Program Files (x86)\HP\Shared\hputils64.dll soit modifiée, puis l'écraser avec MalDll.dll, et ensuite attendre que le bloc-notes (notepad) se lance en tant que SYSTEM !

Pour tester le PoC, il suffit de cloner le dépôt et d'exécuter PrivHP4.py.

Références

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