Paracosme - CVE-2022-33318 - Exécution de code à distance dans ICONICS Genesis64

Paracosme est un exploit de corruption mémoire que j'ai écrit pour cibler la suite Genesis64 v10.97.1 développée par ICONICS afin d'obtenir une exécution de code à distance.

L'exploit a été démontré lors du concours Pwn2Own 2022 Miami qui s'est tenu à la conférence S4x22. Vous pouvez en lire davantage dans Participer au Pwn2Own ICS 2022 Miami : exploiter une corruption mémoire distante zero click dans ICONICS Genesis64.

Le problème a obtenu un score de 9,8 sur l'échelle CVSS et s'est vu attribuer CVE-2022-33318 / ZDI-22-1041. Il a été corrigé et a été corrigé dans Genesis64 10.97.2. Vous pouvez également consulter l'avis ICSA-22-202-04 ainsi que le livre blanc d'ICONICS sur les vulnérabilités de sécurité de la suite ICONICS.

Vous pouvez trouver le code de l'exploit dans src/paracosme.py, un PoC pour déclencher le crash / vérifier si vous êtes affecté dans src/paracosme-poc.py, et le payload exécuté sur la machine dans src/payload.

Suis-je concerné ?

La meilleure façon de savoir si vous êtes concerné est d'activer Page Heap pour GenBroker64.exe, de redémarrer le service, d'attacher un débogueur à GenBroker64.exe, d'exécuter paracosme-poc.py contre votre serveur et vous devriez voir des crashes comme ci-dessous :

Il est nécessaire d'attacher un débogueur au processus cible pour constater le crash, sinon l'application l'ignore.

Exécution de l'exploit

L'exploit n'a été testé que sur Windows mais devrait également fonctionner sur les plateformes Linux :

1. Installez impacket avec : pip3 install impacket
2. Désactivez tout serveur SMB exécuté sur votre machine avec sc config lanmanserver start=disabled et redémarrez
3. Démarrez un smbserver avec smbserver.py (faisant partie des exemples d'impacket) avec : python src\smbserver.py -smb2support x bin
4. Lancez l'exploit avec python src\paracosme.py --target <ip>

L'exploit

Pour plus de détails, veuillez vous référer à Participer au Pwn2Own ICS 2022 Miami : exploiter une corruption mémoire distante zero click dans ICONICS Genesis64.

Vue d'ensemble de la vulnérabilité

Paracosme exploite un problème de use-after-free trouvé dans le processus GenBroker64 pour obtenir une exécution de code à distance sur un système Windows 21H2 x64.

À un niveau général, le processus GenBroker64 écoute sur le port TCP 38080 et est capable de désérialiser divers paquets après qu'un handshake a été effectué avec un client. Le problème que j'ai trouvé se situe dans le code qui gère la lecture d'un VARIANT depuis le socket réseau. En gros, un variant est un type et une valeur. La fonction semble bien écrite à première vue et fait des efforts pour ne désérialiser que certains types. Voici à quoi elle ressemble :

bool CheckVariantType(VARTYPE VarType) {
  if((VarType & 0x2FFF) != VarType) {
    return false;
  }

  switch(VarType & 0xFFF) {
    case VT_EMPTY:
    case VT_NULL:
    case VT_I2:
    case VT_I4:
    case VT_R4:
    case VT_R8:
    case VT_CY:
    case VT_DATE:
    case VT_BSTR:
    case VT_ERROR:
    case VT_BOOL:
    case VT_VARIANT:
    case VT_I1:
    case VT_UI1:
    case VT_UI2:
    case VT_UI4:
    case VT_I8:
    case VT_UI8:
    case VT_INT:
    case VT_UINT:
    case VT_HRESULT:
    case VT_FILETIME:
      return true;
      break;
    default:
      return false;
  }
}

size_t VariantTypeToSize(VARTYPE VarType) {
  switch(VarType) {
    case VT_I1: return 1;
    case VT_UI2: return 2;
    case VT_UI4:
    case VT_INT:
    case VT_UINT:
    case VT_HRESULT:
      return 4;
    case VT_I8:
    case VT_UI8:
    case VT_FILETIME:
      return 8;
    default:
      return 0;
  }
}

void Utils::ReadVariant(tagVARIANT *Variant, Archive_t *Archive, int Level) {
    TRY {
        return ReadVariant_((CArchive *)Archive, (COleVariant *)Variant);
    } CATCH_ALL(e) {
        VariantClear(Variant);
    }
}

HRESULT Utils::ReadVariant_(tagVARIANT *Variant, Archive_t *Archive, int Level) {
  VARTYPE VarType = Archive.ReadUint16();
  if((VarType & VT_ARRAY) != 0) {
      // Special logic to unpack arrays..
      return ..;
  }

  Size = VariantTypeToSize(VarType);
  if (Size) {
      Variant->vt = VarType;
      return Archive.ReadInto(&Variant->decVal.8, Size);
  }

  if(!CheckVariantType(VarType)) {
      // ...
      throw Something();
  }

  return Archive >> Variant;
}

La fonction implémente elle-même le déballage des tableaux, ainsi que la lecture des types de variant simples, mais si elle reçoit quelque chose qui n'est ni l'un ni l'autre, elle se rabat sur l'operator>> de l'instance d'archive. Cette instance d'archive est un objet fourni par le framework Microsoft Foundation Class qui gère la sérialisation et la désérialisation de divers objets. Ce code est en réalité open-source et vous pouvez le trouver dans C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.29.30133\atlmfc\src\mfc\olevar.cpp, mais le voici :