EvilWfshbr

CVE-2022-42046 Proof of Concept von wfshbr64.sys lokaler Privilegieneskalation

wfshbr64.sys und wfshbr32.sys speziell erstellte Payload ermöglicht es einem beliebigen Benutzer, bitweise Operationen mit beliebigem EPROCESS-Offset und Flags-Wert durchzuführen, um den Spielprozess gezielt auf CodeGen Full Schutz zu erhöhen, indem die Flags EPROCESS.Protection und EPROCESS.SignatureLevel manipuliert werden (Sicherheitslücke als Feature).

Der Treiber ist vom Microsoft Hardware Compatibility Publisher signiert, der über das Microsoft Hardware Program eingereicht wurde.

Dieses Projekt wurde gemeinsam mit @DoranekoSystems erforscht.

Es ist eine umfangreiche Rust CLI-Version hier verfügbar

• https://www.virustotal.com/gui/file/b8807e365be2813b7eccd2e4c49afb0d1e131086715638b7a6307cd7d7e9556c
• https://www.virustotal.com/gui/file/89698cad598a56f9e45efffd15d1841e494a2409cc12279150a03842cd6bb7f3

Lizenz

MIT. Siehe LICENSE

Vorschlag (für Entwickler)

1. Verwenden Sie ObRegisterCallbacks anstatt den Prozessschutz zwangsweise durch direkte Kernelobjektmanipulation zu erhöhen. Ein gutes Beispiel finden Sie hier.

2. IRP

Referenzieren Sie IRP nicht nach Abschluss. Wenn Sie den Treiberverifizierer aktiviert haben, werden Sie erwischt.

IofCompleteRequest(Irp, IO_NO_INCREMENT); // IRP is freed here
return Irp->IoStatus.Status;

Stattdessen sollten Sie eine lokale Variable verwenden.

NTSTATUS status = STATUS_SUCCESS;
Irp->IoStatus.Status = status;
IofCompleteRequest(Irp, IO_NO_INCREMENT); // IRP is freed here
return status;

3. Kontextprozess

Es scheint, dass Sie einen Nullzeiger gegen den Rückgabewert von IoGetCurrentProcess prüfen, aber dieser gibt per Design niemals einen Nullzeiger zurück, daher müssen Sie ihn nicht überprüfen.

PEPROCESS CurrentProcess = IoGetCurrentProcess();
  if ( !CurrentProcess ) // no need to check for null pointer
    break;

Der Trick

Eine Weile nach dem Bericht implementierte der Entwickler eine hinterhältige "zusätzliche Überprüfung", um unseren ersten PoC zu besiegen, anstatt davon abzulassen, Sicherheitslücken als Feature zu machen.

Prüfungen hinzugefügt zu:

• IOCTL_WFSHBR_REMOVE_FLAG
• IOCTL_WFSHBR_ADD_FLAG
• IOCTL_WFSHBR_AND_FLAG

case IOCTL_WFSHBR_ADD_FLAG: // 0xAA013884
      if ( !KwfsVerifyCaller(Buffer) ) // verify caller
        break;
-     if ( Buffer->ArbitraryEProcessOffset >= 0x1000 ) // offset limitation check
+     if ( !KwfsVerifyOffsetAndFlags(Buffer->ArbitraryEProcessOffset,
+                                    Buffer->DesiredFlags) ) // verify the offset and flags
        break;
      *(ULONG*)(IoGetCurrentProcess() + Buffer->ArbitraryEProcessOffset) |= Buffer->DesiredFlags;

KwfsVerifyOffsetAndFlags

Diese Routine ist dafür ausgelegt, jedes Mal aufgerufen zu werden, wenn der Client eine Änderung des EPROCESS anfordert, und führt eine Überprüfung des durch das Feld ArbitraryEProcessOffset in diesem PoC bereitgestellten Offset durch – sowie der durch das Feld DesiredFlags in diesem PoC bereitgestellten Flags.

Die Überprüfung ist recht einfach: Sie zählt die 1-Bits in jedem Bitfeld der bereitgestellten Flags, und wenn die Anzahl größer als acht ist, schlägt sie fehl.

Die mögliche Flags-Pattern-Map besteht nur aus vier:

• 22 00 00 00
• 00 22 00 00
• 00 00 22 00
• 00 00 00 22

Das heißt, die folgenden Operationen viermal auszuführen kann garantieren, dass mindestens einer der Versuche erfolgreich ist:

• Subtract the ArbitraryEProcessOffset field by index: offset - index,
• And adjust bits in DesiredFlags field by index: flag << (index * 8).

Der Offset wird dekrementiert, sodass die Bitfeldanpassung dazu führt, dass sich der Offset bei den bitweisen Operatoren anpasst.

*(ULONG*)(IoGetCurrentProcess() + offset) |= flags;
*(ULONG*)(IoGetCurrentProcess() + offset) &= ~flags;

Wir haben die Funktionen WfsProtectProcessSupreme und WfsUnprotectProcessSupreme hinzugefügt, die den Versuch durchführen und den neuen Trick besiegt haben.

enum KwfsState {
  KwfsStateOnceCall = 0,
  KwfsStateNeedsValueEquality = 1,
  KwfsStateValueHasBeenSet = 2,
};

bool KwfsVerifyOffsetAndFlags(_In_ ULONG offset, _In_ ULONG offset flags)
{
  if (KwfsState::KwfsState == KwfsState::KwfsStateOnceCall) {
    g_KwfsVerifyState = KwfsState::KwfsStateValueHasBeenSet;
    g_KwfsVerifyStateOffset = offset;
    g_KwfsVerifyStateFlags = flags;
    if (offset < 0x1000) { // offset limitation check moved here
      auto bitcount = 0;
      for (auto i = 0; i < 32; ++i) { // count `1` bits in flags
        if (flags & (1 << i)) {
          ++bitcount;
        }
      }
      if (bitcount <= 8) { // count must less than nine
        g_KwfsVerifyState = 1;
        return true;
      }
    }
  }
  else
  {
    if (g_KwfsVerifyState != KwfsState::KwfsStateValueHasBeenSet
     || offset != g_KwfsVerifyStateOffset
     || flags != g_KwfsVerifyStateFlags) {
      return false;
    }
  }
  return false;
}