# CVE-2024-30088 — ntoskrnl.exe patch diff

`ntoskrnl.exe` 10.0.22621.3672 -> 10.0.22621.3733 (ghidriff).

## `AuthzBasepCopyoutInternalSecurityAttributes`  (modified)

```diff
--- AuthzBasepCopyoutInternalSecurityAttributes
+++ AuthzBasepCopyoutInternalSecurityAttributes
@@ -1,41 +1,137 @@
 

-int AuthzBasepCopyoutInternalSecurityAttributes(void)

+int AuthzBasepCopyoutInternalSecurityAttributes(uint *param_1,int *param_2,uint param_3)

 

 {

-  longlong unaff_RBX;

-  int unaff_EBP;

-  int unaff_ESI;

-  int unaff_EDI;

-  undefined4 unaff_R12D;

-  undefined4 unaff_R13D;

-  int unaff_R15D;

-  undefined4 local_res20;

-  undefined4 uStackX_24;

-  int in_stack_00000028;

-  int in_stack_00000070;

-  undefined4 *in_stack_00000088;

-  int *in_stack_00000090;

-  undefined4 *in_stack_00000098;

-  int *in_stack_000000a0;

-  undefined4 *in_stack_000000a8;

-  int *in_stack_000000b0;

-  int *in_stack_000000b8;

-  undefined4 *in_stack_000000c0;

-  int *in_stack_000000c8;

-  int *in_stack_000000d0;

+  int *piVar1;

+  int *piVar2;

+  int *piVar3;

+  undefined8 *puVar4;

+  code *pcVar5;

+  int iVar6;

+  ulonglong uVar7;

+  int *piVar8;

+  int *piVar9;

+  uint *puVar10;

+  uint local_res10 [4];

+  ulonglong local_res20;

+  int local_50;

+  int iStack_4c;

+  undefined8 uStack_48;

   

-  func_0x0001407cee74(*(undefined4 *)(unaff_RBX + 0x308),0,0,&stack0x00000070);

-  *in_stack_00000088 = local_res20;

-  *in_stack_00000090 = unaff_R15D;

-  *in_stack_00000098 = uStackX_24;

-  *in_stack_000000a0 = unaff_EBP;

-  *in_stack_000000a8 = unaff_R12D;

-  *in_stack_000000b0 = unaff_EDI;

-  *in_stack_000000b8 = unaff_ESI;

-  *in_stack_000000c0 = unaff_R13D;

-  *in_stack_000000c8 = (int)unaff_RBX;

-  *in_stack_000000d0 = in_stack_00000070;

-  return in_stack_00000028 + in_stack_00000070 + (int)unaff_RBX + unaff_ESI + unaff_EDI + unaff_EBP

-         + unaff_R15D + 0x388;

+  local_50 = 0;

+  iStack_4c = 0;

+  uStack_48 = 0;

+  if (((param_2 == (int *)0x0) || (param_3 == 0)) ||

+     (piVar3 = (int *)((ulonglong)param_3 + (longlong)param_2), piVar3 < param_2)) {

+    iVar6 = -0x3ffffff3;

+  }

+  else {

+    memset(param_2,0,(ulonglong)param_3);

+    if (param_2 + 0xc <= piVar3) {

+      *param_2 = 0;

+      piVar8 = param_2 + 8;

+      piVar1 = param_2 + 2;

+      *(int **)(param_2 + 10) = piVar8;

+      *(int **)piVar8 = piVar8;

+      *(int **)(param_2 + 4) = piVar1;

+      *(int **)piVar1 = piVar1;

+      param_2[6] = 0;

+      if (0xffffffff < (ulonglong)*param_1 * 0x70) {

+LAB_0:

+        iVar6 = -0x3fffff6b;

+        goto LAB_1;

+      }

+      piVar8 = (int *)(((ulonglong)*param_1 * 0x70 & 0xffffffff) + (longlong)(param_2 + 0xc));

+      if (piVar8 <= piVar3) {

+        param_1 = param_1 + 2;

+        puVar10 = *(uint **)param_1;

+        if (puVar10 == param_1) {

+          return 0;

+        }

+        piVar9 = param_2 + 0x26;

+        do {

+          iVar6 = Feature_2516935995__private_IsEnabledDeviceUsage();

+          if (iVar6 == 0) {

+            puVar4 = *(undefined8 **)(param_2 + 4);

+            if ((int *)*puVar4 != piVar1) {

+              pcVar5 = (code *)swi(0x29);

+              (*pcVar5)(3);

+              goto LAB_0;

+            }

+            piVar2 = piVar9 + -0x1a;

+            *(undefined8 **)(piVar9 + -0x18) = puVar4;

+            *(int **)piVar2 = piVar1;

+            *puVar4 = piVar2;

+            *(int **)(param_2 + 4) = piVar2;

+          }

+          else {

+            iVar6 = AuthzBasepProbeAndInsertTailList(piVar1);

+            if (iVar6 < 0) goto LAB_1;

+          }

+          *param_2 = *param_2 + 1;

+          *(short *)(piVar9 + -0xe) = (short)puVar10[0xc];

+          piVar9[-0xd] = puVar10[0xd];

+          piVar2 = piVar9 + -8;

+          *(int **)(piVar9 + -6) = piVar2;

+          *(int **)piVar2 = piVar2;

+          piVar2 = piVar9 + -2;

+          *(int **)piVar9 = piVar2;

+          *(int **)piVar2 = piVar2;

+          uVar7 = (longlong)piVar8 + 1U & 0xfffffffffffffffe;

+          piVar9[-0xc] = 0;

+          piVar9[-0xb] = 0;

+          piVar9[-10] = 0;

+          piVar9[-4] = 0;

+          local_res20 = (ulonglong)(ushort)puVar10[8];

+          local_res10[0] = (uint)(ushort)puVar10[8];

+          piVar8 = (int *)(local_res20 + uVar7);

+          if (piVar3 < piVar8) break;

+          iVar6 = Feature_3391791421__private_IsEnabledDeviceUsage();

+          if (iVar6 == 0) {

+            *(ushort *)((longlong)piVar9 + -0x46) = (ushort)local_res20;

+            *(undefined2 *)(piVar9 + -0x12) = 0;

+            *(ulonglong *)(piVar9 + -0x10) = uVar7;

+            RtlCopyUnicodeString(piVar9 + -0x12,puVar10 + 8);

+          }

+          else {

+            local_50 = (uint)(ushort)local_res20 << 0x10;

+            iStack_4c = 0;

+            uStack_48 = uVar7;

+            RtlCopyUnicodeString(&local_50,puVar10 + 8);

+            piVar9[-0x12] = local_50;

+            piVar9[-0x11] = iStack_4c;

+            piVar9[-0x10] = (int)uStack_48;

+            piVar9[-0xf] = uStack_48._4_4_;

+          }

+          iVar6 = AuthzBasepCopyoutInternalSecurityAttributeValues

+                            (puVar10,piVar9 + -0x1a,piVar8,(int)piVar3 - (int)piVar8,local_res10);

+          if (iVar6 < 0) goto LAB_1;

+          piVar9 = piVar9 + 0x1c;

+          puVar10 = *(uint **)puVar10;

+          piVar8 = (int *)((longlong)piVar8 + (ulonglong)local_res10[0]);

+          if (puVar10 == param_1) {

+            return iVar6;

+          }

+        } while( true );

+      }

+    }

+    iVar6 = -0x7ffffffb;

+  }

+LAB_1:

+  if (0x2f < param_3) {

+    param_2[0] = 0;

+    param_2[1] = 0;

+    param_2[2] = 0;

+    param_2[3] = 0;

+    param_2[4] = 0;

+    param_2[5] = 0;

+    param_2[6] = 0;

+    param_2[7] = 0;

+    param_2[8] = 0;

+    param_2[9] = 0;

+    param_2[10] = 0;

+    param_2[0xb] = 0;

+  }

+  return iVar6;

 }
```

## `FsRtlpCleanupEcps`  (modified)

```diff
--- FsRtlpCleanupEcps
+++ FsRtlpCleanupEcps
@@ -1,15 +1,44 @@
 

-void FsRtlpCleanupEcps(undefined8 param_1)

+undefined8 FsRtlpCleanupEcps(longlong param_1)

 

 {

-  code *pcVar1;

-  char in_AL;

-  undefined7 in_register_00000001;

+  uint uVar1;

+  undefined8 *puVar2;

+  undefined8 *puVar3;

+  code *pcVar4;

+  undefined8 uVar5;

+  undefined8 *puVar6;

   

-  *(char *)CONCAT71(in_register_00000001,in_AL) =

-       *(char *)CONCAT71(in_register_00000001,in_AL) + in_AL;

-  pcVar1 = (code *)swi(3);

-  (*pcVar1)((char)param_1 + (char)((ulonglong)param_1 >> 8));

-  return;

+  uVar1 = *(uint *)(param_1 + 4);

+  if ((uVar1 & 0x3f0) == 0) {

+    if ((uVar1 & 1) != 0) {

+      puVar2 = *(undefined8 **)(param_1 + 8);

+      while( true ) {

+        do {

+          puVar6 = puVar2;

+          if (puVar6 == (undefined8 *)(param_1 + 8)) {

+            return 0;

+          }

+          puVar2 = (undefined8 *)*puVar6;

+        } while ((*(uint *)(puVar6 + 5) & 1) != 0);

+        if (((undefined8 *)puVar2[1] != puVar6) ||

+           (puVar3 = (undefined8 *)puVar6[1], (undefined8 *)*puVar3 != puVar6)) break;

+        *puVar3 = puVar2;

+        puVar2[1] = puVar3;

+        puVar6[1] = 0;

+        *puVar6 = 0;

+        FsRtlFreeExtraCreateParameter(puVar6 + 8);

+      }

+      pcVar4 = (code *)swi(0x29);

+      (*pcVar4)(3);

+      uVar5 = ExFreePoolWithTag(puVar2,0);

+      return uVar5;

+    }

+    FsRtlFreeExtraCreateParameterList();

+  }

+  else {

+    *(uint *)(param_1 + 4) = uVar1 - 0x10;

+  }

+  return 1;

 }
```

## `ExpWnfSubscribeNameInstance`  (modified)

```diff
--- ExpWnfSubscribeNameInstance
+++ ExpWnfSubscribeNameInstance
@@ -1,11 +1,290 @@
 

-void ExpWnfSubscribeNameInstance(void)

+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

+

+undefined8

+ExpWnfSubscribeNameInstance

+          (longlong param_1,longlong param_2,ulonglong *param_3,undefined8 param_4,

+          undefined4 param_5,undefined4 param_6,char param_7,undefined8 *param_8,undefined8 *param_9

+          ,undefined8 *param_10,undefined4 *param_11)

 

 {

-  code *pcVar1;

+  ulonglong *puVar1;

+  int *piVar2;

+  ulonglong uVar3;

+  longlong *plVar4;

+  code *pcVar5;

+  int iVar6;

+  longlong lVar7;

+  undefined4 *_Dst;

+  longlong lVar8;

+  undefined8 uVar9;

+  uint uVar10;

+  undefined8 *unaff_RSI;

+  longlong *plVar11;

+  ulonglong *puVar12;

+  ulonglong *puVar13;

+  undefined4 *puVar14;

+  undefined8 *unaff_R13;

+  int local_58;

+  int local_54;

+  undefined8 local_50;

+  longlong local_48;

+  longlong local_40;

   

-  pcVar1 = (code *)swi(3);

-  (*pcVar1)();

-  return;

+  local_48 = *(longlong *)(param_2 + 0x868);

+  uVar10 = 0;

+  local_50 = 0;

+  *param_11 = 0;

+  local_58 = 0;

+  local_54 = 0;

+  if (param_7 == '\x01') {

+    plVar11 = (longlong *)(local_48 + 0x50);

+    lVar7 = KeAbPreAcquire(plVar11,0,0);

+    LOCK();

+    lVar8 = *plVar11;

+    if (lVar8 == 0) {

+      *plVar11 = 0x11;

+    }

+    UNLOCK();

+    if (lVar8 != 0) {

+      ExfAcquirePushLockSharedEx(plVar11,0,lVar7,plVar11);

+    }

+    if (lVar7 != 0) {

+      *(undefined1 *)(lVar7 + 0x12) = 1;

+    }

+    iVar6 = ExpWnfUpdateSubscription

+                      (param_1,local_48,param_3,param_4,param_6,&local_50,&local_58,&local_54,

+                       param_8);

+    LOCK();

+    lVar8 = *plVar11;

+    if (lVar8 == 0x11) {

+      *plVar11 = 0;

+    }

+    UNLOCK();

+    if (lVar8 != 0x11) {

+      ExfReleasePushLockShared(plVar11);

+    }

+    KeAbPostRelease(plVar11);

+    if (-1 < iVar6) {

+      *param_10 = local_50;

+      goto LAB_0;

+    }

+  }

+  lVar8 = local_48;

+  _Dst = (undefined4 *)

+         ExAllocatePool2((ulonglong)(PsInitialSystemProcess != param_2) + 0x100,0x88,0x20666e57);

+  if (_Dst == (undefined4 *)0x0) {

+    return 0xc000009a;

+  }

+  memset(_Dst,0,0x88);

+  *_Dst = 0x880905;

+  _Dst[0x18] = param_5;

+  _Dst[0x19] = param_6;

+  *(ulonglong **)(_Dst + 0x14) = param_3;

+  *(undefined8 *)(_Dst + 0x16) = param_4;

+  *(undefined8 *)(_Dst + 2) = 0;

+  *(undefined8 *)(_Dst + 0xe) = *(undefined8 *)(param_1 + 0x28);

+  if (param_7 == '\0') {

+    puVar14 = _Dst;

+    if (param_9 != (undefined8 *)0x0) {

+      *param_9 = _Dst;

+    }

+  }

+  else {

+    do {

+      LOCK();

+      lVar7 = ExpWnfSubcriptionIdCounter + 1;

+      UNLOCK();

+      puVar14 = (undefined4 *)(ExpWnfSubcriptionIdCounter + 1);

+      ExpWnfSubcriptionIdCounter = lVar7;

+    } while (puVar14 == (undefined4 *)0x0);

+    if (param_8 != (undefined8 *)0x0) {

+      *param_8 = puVar14;

+    }

+  }

+  puVar12 = (ulonglong *)(lVar8 + 0x50);

+  lVar8 = KeAbPreAcquire(puVar12,0);

+  LOCK();

+  uVar3 = *puVar12;

+  *puVar12 = *puVar12 | 1;

+  UNLOCK();

+  if ((uVar3 & 1) != 0) {

+    ExfAcquirePushLockExclusiveEx(puVar12,lVar8);

+  }

+  if (lVar8 != 0) {

+    *(undefined1 *)(lVar8 + 0x12) = 1;

+  }

+  puVar1 = (ulonglong *)(param_1 + 0x70);

+  puVar13 = (ulonglong *)0x0;

+  local_40 = KeAbPreAcquire(puVar1,0);

+  LOCK();

+  uVar3 = *puVar1;

+  *puVar1 = *puVar1 | 1;

+  UNLOCK();

+  if ((uVar3 & 1) != 0) {

+    puVar13 = puVar1;

+    ExfAcquirePushLockExclusiveEx(puVar1,local_40);

+  }

+  if (local_40 != 0) {

+    *(undefined1 *)(local_40 + 0x12) = 1;

+  }

+  if (*(longlong *)(param_1 + 0x30) == 0) {

+    LOCK();

+    uVar3 = *puVar1;

+    *puVar1 = *puVar1 - 1;

+    UNLOCK();

+    if (((byte)uVar3 & 6) == 2) {

+      ExfTryToWakePushLock(puVar1);

+    }

+    KeAbPostRelease(puVar1);

+    LOCK();

+    uVar3 = *puVar12;

+    *puVar12 = *puVar12 - 1;

+    UNLOCK();

+    if (((byte)uVar3 & 6) == 2) {

+      ExfTryToWakePushLock(puVar12);

+    }

+    KeAbPostRelease(puVar12);

+    ExFreePoolWithTag(_Dst,0x20666e57);

+    return 0xc0000034;

+  }

+  if ((param_7 == '\x01') &&

+     (iVar6 = ExpWnfUpdateSubscription

+                        (param_1,local_48,param_3,param_4,param_6,&local_50,&local_58,&local_54,

+                         param_8), puVar13 = param_3, -1 < iVar6)) {

+    LOCK();

+    uVar3 = *puVar1;

+    *puVar1 = *puVar1 - 1;

+    UNLOCK();

+    if (((byte)uVar3 & 6) == 2) {

+      ExfTryToWakePushLock(puVar1);

+    }

+    KeAbPostRelease(puVar1);

+    LOCK();

+    uVar3 = *puVar12;

+    *puVar12 = *puVar12 - 1;

+    UNLOCK();

+    if (((byte)uVar3 & 6) == 2) {

+      ExfTryToWakePushLock(puVar12);

+    }

+    KeAbPostRelease(puVar12);

+    ExFreePoolWithTag(_Dst,0x20666e57);

+    uVar9 = FUN_14075b086();

+    return uVar9;

+  }

+  *(longlong *)(_Dst + 10) = param_2;

+  *(longlong *)(_Dst + 0xc) = param_1;

+  *(undefined4 **)(_Dst + 4) = puVar14;

+  ExAcquireRundownProtection(_Dst + 2);

+  if (param_9 != (undefined8 *)0x0) {

+    ExAcquireRundownProtection(_Dst + 2);

+  }

+  plVar11 = (longlong *)(_Dst + 6);

+  plVar4 = *(longlong **)(local_48 + 0x60);

+  if (*plVar4 == local_48 + 0x58) {

+    *plVar11 = local_48 + 0x58;

+    *(longlong **)(_Dst + 8) = plVar4;

+    *plVar4 = (longlong)plVar11;

+    *(longlong **)(local_48 + 0x60) = plVar11;

+    plVar4 = *(longlong **)(param_1 + 0x80);

+    plVar11 = (longlong *)(_Dst + 0x10);

+    if (*plVar4 == param_1 + 0x78) {

+      *plVar11 = param_1 + 0x78;

+      *(longlong **)(_Dst + 0x12) = plVar4;

+      *plVar4 = (longlong)plVar11;

+      *(longlong **)(param_1 + 0x80) = plVar11;

+      if ((_Dst[0x19] & 1) != 0) {

+        LOCK();

+        piVar2 = (int *)(param_1 + 0xa0);

+        iVar6 = *piVar2;

+        *piVar2 = *piVar2 + 1;

+        UNLOCK();

+        if (iVar6 == 0) {

+          local_58 = 1;

+        }

+      }

+      LOCK();

+      uVar3 = *puVar1;

+      *puVar1 = *puVar1 - 1;

+      UNLOCK();

+      if (((byte)uVar3 & 6) == 2) {

+        ExfTryToWakePushLock(puVar1);

+      }

+      KeAbPostRelease(puVar1);

+      LOCK();

+      uVar3 = *puVar12;

+      *puVar12 = *puVar12 - 1;

+      UNLOCK();

+      if (((byte)uVar3 & 6) == 2) {

+        ExfTryToWakePushLock(puVar12);

+      }

+      KeAbPostRelease(puVar12);

+      *param_10 = _Dst;

+LAB_0:

+      if (local_54 < 0) {

+        LOCK();

+        piVar2 = (int *)(param_1 + 0xa4);

+        iVar6 = *piVar2;

+        *piVar2 = *piVar2 + -1;

+        UNLOCK();

+        if (iVar6 == 1) {

+          uVar10 = 8;

+        }

+      }

+      if (local_58 < 1) {

+        if (local_58 < 0) {

+          uVar10 = uVar10 | 4;

+        }

+      }

+      else {

+        uVar10 = uVar10 | 2;

+      }

+      if (uVar10 != 0) {

+        ExpWnfNotifyNameSubscribers(param_1,uVar10,1,param_7 != '\0');

+        *param_11 = 1;

+      }

+      return 0;

+    }

+  }

+  pcVar5 = (code *)swi(0x29);

+  lVar8 = (*pcVar5)(3);

+  *(undefined4 *)puVar1 = 1;

+  iVar6 = iRam0000000000000077;

+  if ((iRam0000000000000077 != 2) &&

+     (((ulonglong)puVar13 & 1) == 0 && (uRam000000000000007b & 1) != 0)) {

+    *_Dst = (int)lVar8;

+  }

+  plVar11 = plRam000000000000006f;

+  lVar7 = lRam0000000000000067;

+  uRam0000000000000063 = (uint)puVar13;

+  uRam000000000000007b = uRam0000000000000063 & uRam000000000000007b;

+  _DAT_1 = param_1;

+  puRam0000000000000057 = puVar14;

+  if (((iVar6 != 0) && (uRam000000000000007b == 0)) && (iRam000000000000007f == 0)) {

+    if ((*(longlong *)(lRam0000000000000067 + 8) != 0x67) || (*plRam000000000000006f != 0x67)) {

+      pcVar5 = (code *)swi(0x29);

+      (*pcVar5)(3);

+      pcVar5 = (code *)swi(3);

+      uVar9 = (*pcVar5)();

+      return uVar9;

+    }

+    *plRam000000000000006f = lRam0000000000000067;

+    *(longlong **)(lVar7 + 8) = plVar11;

+    iRam0000000000000077 = 0;

+  }

+  LOCK();

+  uVar3 = *puVar12;

+  *puVar12 = *puVar12 + lVar8;

+  UNLOCK();

+  if (((byte)uVar3 & 6) == 2) {

+    ExfTryToWakePushLock(puVar12);

+  }

+  KeAbPostRelease(puVar12);

+  ExAcquireRundownProtection(7);

+  *unaff_R13 = 0xffffffffffffffff;

+  if (unaff_RSI != (undefined8 *)0x0) {

+    *unaff_RSI = uRam000000000000000f;

+  }

+  return 0;

 }
```

## `EtwUnregister`  (modified)

```diff
--- EtwUnregister
+++ EtwUnregister
@@ -1,74 +1,69 @@
 

-/* WARNING: Removing unreachable block (ram,0x00014089c40f) */

-/* WARNING: Removing unreachable block (ram,0x00014089c3ff) */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

 

-undefined8 EtwUnregister(int *param_1,uint param_2,int param_3,undefined8 *param_4)

+ulonglong EtwUnregister(longlong *param_1)

 

 {

-  int iVar1;

-  int iVar2;

-  int iVar3;

-  undefined8 uVar4;

+  longlong lVar1;

+  longlong *plVar2;

+  longlong *plVar3;

+  code *pcVar4;

+  char cVar5;

+  longlong unaff_RDI;

   

-  if ((param_1 == (int *)0x0) || (param_2 == 0)) {

-    *param_4 = 0;

-    param_4[1] = 0;

-    param_4[2] = 0;

-    param_4[3] = 0;

-    param_4[4] = 0;

-    param_4[5] = 0;

-    param_4[6] = 0;

-    return 0xc000000d;

+                    /* 0x7cc5d0  183  EtwUnregister */

+  if (param_1 == (longlong *)0x0) {

+    return 0xc0000008;

   }

-  if (param_3 != 0) {

-    if (((ulonglong)param_1 & 3) == 0) {

-      if (((int *)0x7fffffff0000 < (int *)((ulonglong)param_2 + (longlong)param_1)) ||

-         ((int *)((ulonglong)param_2 + (longlong)param_1) < param_1)) {

-        DAT_0 = 0;

+  if ((*(byte *)((longlong)param_1 + 0x62) & 1) != 0) {

+    if (param_1[5] != 0) {

+      *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

+           *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

+      ExAcquirePushLockExclusiveEx(param_1[5] + 0x198,0);

+      *(void **)(param_1[5] + 0x1a0) = SystemReserved1[0xf];

+    }

+    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

+         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

+    ExAcquirePushLockExclusiveEx(param_1[4] + 0x198,0);

+    *(void **)(param_1[4] + 0x1a0) = SystemReserved1[0xf];

+    lVar1 = *param_1;

+    if ((*(longlong **)(lVar1 + 8) == param_1) &&

+       (plVar2 = (longlong *)param_1[1], (longlong *)*plVar2 == param_1)) {

+      *plVar2 = lVar1;

+      *(longlong **)(lVar1 + 8) = plVar2;

+      plVar2 = param_1 + 2;

+      lVar1 = *plVar2;

+      if ((*(longlong **)(lVar1 + 8) == plVar2) &&

+         (plVar3 = (longlong *)param_1[3], (longlong *)*plVar3 == plVar2)) {

+        *plVar3 = lVar1;

+        *(longlong **)(lVar1 + 8) = plVar3;

+        *(undefined8 *)(param_1[4] + 0x1a0) = 0;

+        ExReleasePushLockEx(param_1[4] + 0x198,0);

+        KeLeaveCriticalRegion();

+        if (param_1[5] != 0) {

+          *(undefined8 *)(param_1[5] + 0x1a0) = 0;

+          ExReleasePushLockEx(param_1[5] + 0x198,0);

+          KeLeaveCriticalRegion();

+        }

+        cVar5 = EtwEventEnabled(EtwpEventTracingProvRegHandle,&ETW_EVENT_PROVIDER_UNREGISTERS);

+        if (cVar5 != '\0') {

+          EtwpEventWriteTemplateSessAndProv();

+        }

+        EtwpUnreferenceGuidEntry(param_1[4]);

+        if (param_1[5] != 0) {

+          EtwpUnreferenceGuidEntry();

+        }

+        EtwpReleaseProviderTraitsReference(param_1);

+        ExFreePoolWithTag(param_1,0);

+        return 0;

       }

-      if ((0x27 < param_2) && (*param_1 == 0x28)) {

-        *(undefined4 *)param_4 = 0x38;

-        *(int *)((longlong)param_4 + 4) = param_1[1];

-        *(int *)(param_4 + 1) = param_1[2];

-        param_4[2] = (ulonglong)(uint)param_1[3];

-        *(int *)(param_4 + 3) = param_1[4];

-        *(int *)((longlong)param_4 + 0x1c) = param_1[5];

-        *(int *)(param_4 + 4) = param_1[6];

-        param_4[5] = (ulonglong)(uint)param_1[7];

-        *(int *)(param_4 + 6) = param_1[8];

-        *(int *)((longlong)param_4 + 0x34) = param_1[9];

-      }

-      uVar4 = func_0x0001407cc49b();

-      return uVar4;

     }

+    pcVar4 = (code *)swi(0x29);

+    (*pcVar4)(3);

+    McTemplateK0zzzd_EtwWriteTransfer(*(undefined8 *)(unaff_RDI + 8),&KMPnPEvt_ServiceOpenFailure);

+    return (ulonglong)param_1 & 0xffffffff;

+  }

                     /* WARNING: Subroutine does not return */

-    ExRaiseDatatypeMisalignment();

-  }

-  if (((ulonglong)param_1 & 7) != 0) {

-                    /* WARNING: Subroutine does not return */

-    ExRaiseDatatypeMisalignment();

-  }

-  if (((int *)0x7fffffff0000 < (int *)((ulonglong)param_2 + (longlong)param_1)) ||

-     ((int *)((ulonglong)param_2 + (longlong)param_1) < param_1)) {

-    DAT_0 = 0;

-  }

-  if (0x37 < param_2) {

-    uVar4 = *(undefined8 *)(param_1 + 2);

-    *param_4 = *(undefined8 *)param_1;

-    param_4[1] = uVar4;

-    uVar4 = *(undefined8 *)(param_1 + 6);

-    param_4[2] = *(undefined8 *)(param_1 + 4);

-    param_4[3] = uVar4;

-    iVar1 = param_1[9];

-    iVar2 = param_1[10];

-    iVar3 = param_1[0xb];

-    *(int *)(param_4 + 4) = param_1[8];

-    *(int *)((longlong)param_4 + 0x24) = iVar1;

-    *(int *)(param_4 + 5) = iVar2;

-    *(int *)((longlong)param_4 + 0x2c) = iVar3;

-    param_4[6] = *(undefined8 *)(param_1 + 0xc);

-  }

-  uVar4 = func_0x0001407cc49b();

-  return uVar4;

+  KeBugCheckEx(0x11d,4,param_1,1,0);

 }
```

## `PiLogSurpriseRemoveEvent`  (modified)

```diff
--- PiLogSurpriseRemoveEvent
+++ PiLogSurpriseRemoveEvent
@@ -1,24 +1,46 @@
 

-ulonglong PiLogSurpriseRemoveEvent(int param_1)

+int * PiLogSurpriseRemoveEvent(longlong param_1,int param_2,undefined8 *param_3)

 

 {

-  byte bVar1;

-  char *in_RAX;

-  ulonglong uVar2;

-  uint uVar3;

-  byte *unaff_RBX;

-  longlong unaff_RBP;

+  code *pcVar1;

+  longlong lVar2;

+  int *piVar3;

+  int iVar4;

+  undefined *puVar5;

+  int *unaff_RBX;

+  longlong unaff_RSI;

+  int unaff_EDI;

   

-  *(int *)unaff_RBX = *(int *)unaff_RBX - param_1;

-  *(char *)(unaff_RBP + -0x6a44eefc) = *(char *)(unaff_RBP + -0x6a44eefc) + (char)param_1;

-  *in_RAX = *in_RAX + (char)in_RAX;

-  bVar1 = *unaff_RBX;

-  *unaff_RBX = (char)*unaff_RBX >> 1;

-  uVar3 = -(uint)((bVar1 & 1) != 0) & (uint)unaff_RBX;

-  if (-1 < (int)uVar3) {

-    uVar2 = FUN_14092fa8c();

-    return uVar2;

+  lVar2 = 0;

+  if (*(longlong *)(param_1 + 0x98) != 0) {

+    lVar2 = *(longlong *)(*(longlong *)(*(longlong *)(param_1 + 0x98) + 0x138) + 0x28);

   }

-  return (ulonglong)uVar3;

+  piVar3 = (int *)*param_3;

+  iVar4 = *piVar3;

+  if (param_2 == 3) {

+    if ((DAT_0 & 2) == 0) {

+      return piVar3;

+    }

+    puVar5 = &KMPnPEvt_SurpriseRemove_Missing;

+  }

+  else {

+    if (param_2 != 5) {

+      pcVar1 = (code *)swi(0x29);

+      (*pcVar1)(5,iVar4,param_3,*(undefined8 *)(lVar2 + 0x30));

+      RtlCopyMemory((void *)(unaff_RSI + 0x10),

+                    unaff_RBX +

+                    ((ulonglong)(unaff_EDI + 1U) + ((ulonglong)(unaff_EDI + 1U) + 1) * 2) * 2,

+                    (ulonglong)((iVar4 - unaff_EDI) - 1) * 0x18);

+      *unaff_RBX = *unaff_RBX + -1;

+      return (int *)0x0;

+    }

+    if ((DAT_0 & 1) == 0) {

+      return piVar3;

+    }

+    puVar5 = &KMPnPEvt_SurpriseRemove_Failed;

+  }

+  piVar3 = (int *)McTemplateK0zq_EtwWriteTransfer

+                            (param_1,puVar5,param_1 + 0x58,*(undefined8 *)(lVar2 + 0x30),iVar4);

+  return piVar3;

 }
```

## `PfTTraceListFree`  (modified)

```diff
--- PfTTraceListFree
+++ PfTTraceListFree
@@ -1,10 +1,47 @@
 

-/* WARNING: Control flow encountered bad instruction data */

-

-void PfTTraceListFree(void)

+void PfTTraceListFree(longlong *param_1)

 

 {

-                    /* WARNING: Bad instruction - Truncating control flow here */

-  halt_baddata();

+  longlong *plVar1;

+  longlong lVar2;

+  code *pcVar3;

+  byte bVar4;

+  longlong unaff_RDI;

+  

+  while( true ) {

+    plVar1 = (longlong *)*param_1;

+    if (plVar1 == param_1) {

+      return;

+    }

+    if (((longlong *)plVar1[1] != param_1) ||

+       (lVar2 = *plVar1, (longlong *)*(longlong *)(lVar2 + 8) != plVar1)) break;

+    *param_1 = lVar2;

+    *(longlong **)(lVar2 + 8) = param_1;

+    PfTFreeTraceDump();

+  }

+  pcVar3 = (code *)swi(0x29);

+  (*pcVar3)(3);

+  RtlRbRemoveNode();

+  RtlRbRemoveNode(&DAT_0,unaff_RDI + 0x18);

+  LOCK();

+  lVar2 = DAT_1 + (longlong)param_1;

+  UNLOCK();

+  bVar4 = (byte)DAT_1;

+  DAT_1 = lVar2;

+  if ((bVar4 & 6) == 2) {

+    ExfTryToWakePushLock(&DAT_1);

+  }

+  KeAbPostRelease(&DAT_1);

+  KeLeaveCriticalRegion();

+  if (unaff_RDI != 0) {

+    if (*(longlong *)(unaff_RDI + 0x30) != 0) {

+      ObfDereferenceObjectWithTag(*(longlong *)(unaff_RDI + 0x30),0x73576650);

+    }

+    ExFreePoolWithTag();

+  }

+  if (PfSnNumActiveTraces != 0) {

+    PfSnEndProcessTrace();

+  }

+  return;

 }
```

## `WdipSemReserveInstanceTableEntry`  (modified)

```diff
--- WdipSemReserveInstanceTableEntry
+++ WdipSemReserveInstanceTableEntry
@@ -1,45 +1,62 @@
 

-ulonglong WdipSemReserveInstanceTableEntry(uint param_1)

+undefined8 * WdipSemReserveInstanceTableEntry(longlong param_1,longlong param_2)

 

 {

   code *pcVar1;

-  longlong *plVar2;

-  ulonglong uVar3;

-  longlong *plVar4;

-  longlong unaff_RBP;

-  uint uVar5;

-  longlong unaff_R14;

+  char cVar2;

+  longlong lVar3;

+  undefined8 *puVar4;

   

-  uVar5 = 0;

-  plVar2 = (longlong *)ExAllocatePool2(0x100,0x30,0x57706e50);

-  if (plVar2 == (longlong *)0x0) {

-    uVar5 = 0xc000009a;

-LAB_0:

-    return (ulonglong)uVar5;

-  }

-  ObfReferenceObject();

-  ObfReferenceObject((ulonglong)param_1);

-  plVar2[4] = unaff_RBP;

-  plVar2[5] = (ulonglong)param_1;

-  plVar4 = *(longlong **)(unaff_R14 + 0x88);

-  if (*plVar4 == unaff_R14 + 0x80) {

-    *plVar2 = unaff_R14 + 0x80;

-    plVar2[1] = (longlong)plVar4;

-    *plVar4 = (longlong)plVar2;

-    *(longlong **)(unaff_R14 + 0x88) = plVar2;

-    plVar4 = plVar2 + 2;

-    if ((undefined8 *)*DAT_1 == &PiSwGlobalPdoAssociationList) {

-      *plVar4 = (longlong)&PiSwGlobalPdoAssociationList;

-      plVar2[3] = (longlong)DAT_1;

-      *DAT_1 = (longlong)plVar4;

-      DAT_1 = plVar4;

-      goto LAB_0;

+  puVar4 = (undefined8 *)0x0;

+  *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

+       *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

+  ExAcquirePushLockExclusiveEx(&DAT_0,0);

+  if ((param_1 != 0) && (param_2 != 0)) {

+    if (DAT_1 < 0x80) {

+      lVar3 = WdipSemQueryEnabledInstanceTable(param_2);

+      if (lVar3 == 0) {

+        puVar4 = (undefined8 *)WdipSemBuildScenarioInstance(param_1,param_2);

+        if (puVar4 != (undefined8 *)0x0) {

+          if ((undefined8 *)*DAT_2 != &WdipSemEnabledInstanceTable) {

+            pcVar1 = (code *)swi(0x29);

+            (*pcVar1)(3);

+            cVar2 = EtwEventEnabled(WdipSemRegHandle,&WDI_SEM_EVENT_SCENARIO_END_FAILED);

+            if (cVar2 != '\0') {

+              WdipSemWriteSemFailureEvent(&WDI_SEM_EVENT_SCENARIO_END_FAILED);

+            }

+            if (param_2 != 0) {

+              puVar4 = (undefined8 *)FUN_14091fd92();

+              return puVar4;

+            }

+            ExReleasePushLockEx(&WdipSemPushLock,0);

+            KeLeaveCriticalRegion();

+            if ((char)param_1 != '\0') {

+              *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

+                   *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

+              ExAcquirePushLockExclusiveEx(&WdipSemPushLock,0);

+              if (WdipSemEnabled != '\0') {

+                WdipSemShutdown();

+              }

+              ExReleasePushLockEx(&WdipSemPushLock,0);

+              KeLeaveCriticalRegion();

+            }

+            return (undefined8 *)0xc000000d;

+          }

+          *puVar4 = &WdipSemEnabledInstanceTable;

+          puVar4[1] = DAT_2;

+          *DAT_2 = puVar4;

+          DAT_1 = DAT_1 + 1;

+          DAT_2 = puVar4;

+        }

+      }

+    }

+    else {

+      WdipSemLogInflightLimitExceededInformation(param_1,*(undefined2 *)(param_1 + 0x10),param_2);

+      puVar4 = (undefined8 *)0x0;

     }

   }

-  pcVar1 = (code *)swi(0x29);

-  (*pcVar1)(3);

-  pcVar1 = (code *)swi(3);

-  uVar3 = (*pcVar1)();

-  return uVar3;

+  ExReleasePushLockEx(&DAT_0,0);

+  KeLeaveCriticalRegion();

+  return puVar4;

 }
```

## `PiControlGetDeviceStack`  (modified)

```diff
--- PiControlGetDeviceStack
+++ PiControlGetDeviceStack
@@ -1,7 +1,164 @@
 

-void PiControlGetDeviceStack(void)

+int PiControlGetDeviceStack(longlong param_1,uint param_2,undefined2 *param_3,uint *param_4)

 

 {

-  return;

+  longlong *****ppppplVar1;

+  longlong ***ppplVar2;

+  code *pcVar3;

+  int iVar4;

+  longlong lVar5;

+  longlong ****pppplVar6;

+  longlong *****ppppplVar7;

+  ushort *puVar8;

+  ushort uVar9;

+  uint uVar10;

+  int iVar12;

+  undefined2 *_Dst;

+  int local_res8 [2];

+  uint local_res10;

+  undefined2 *local_res18;

+  uint *local_res20;

+  uint local_88;

+  longlong ****local_70;

+  longlong ****local_68;

+  undefined8 local_60;

+  longlong *plStack_58;

+  ulonglong uVar11;

+  

+  local_68 = (longlong ****)&local_70;

+  local_70 = (longlong ****)&local_70;

+  local_res8[0] = 0;

+  iVar4 = 0;

+  local_60 = 0;

+  plStack_58 = (longlong *)0x0;

+  puVar8 = (ushort *)0x0;

+  local_res10 = param_2;

+  local_res18 = param_3;

+  local_res20 = param_4;

+  lVar5 = IoGetDeviceAttachmentBaseRefWithTag(*(undefined8 *)(param_1 + 0x20),0x43706e50);

+  if (lVar5 == 0) {

+    iVar4 = -0x3ffffff0;

+    goto LAB_0;

+  }

+  pppplVar6 = (longlong ****)IoGetAttachedDeviceReferenceWithTag(lVar5,0x43706e50);

+  iVar12 = 0;

+  for (; pppplVar6 != (longlong ****)0x0;

+      pppplVar6 = (longlong ****)IoGetLowerDeviceObjectWithTag(pppplVar6,0x43706e50)) {

+    ppppplVar7 = (longlong *****)ExAllocatePool2(0x100,0x18,0x47706e50);

+    if (ppppplVar7 == (longlong *****)0x0) {

+      ObfDereferenceObjectWithTag(pppplVar6,0x43706e50);

+      iVar4 = -0x3fffff66;

+      goto LAB_0;

+    }

+    ppppplVar7[2] = pppplVar6;

+    if ((longlong *****)*local_68 != &local_70) goto LAB_1;

+    ppppplVar7[1] = local_68;

+    *ppppplVar7 = (longlong ****)&local_70;

+    *local_68 = (longlong ***)ppppplVar7;

+    local_68 = (longlong ****)ppppplVar7;

+  }

+  ppppplVar7 = (longlong *****)local_70;

+  _Dst = param_3;

+  local_88 = param_2;

+  if ((longlong *****)local_70 == &local_70) {

+LAB_2:

+    if ((_Dst != (undefined2 *)0x0) && (1 < local_88)) {

+      *_Dst = 0;

+    }

+    *local_res20 = iVar12 + 2U;

+    if ((param_3 == (undefined2 *)0x0) || (param_2 < iVar12 + 2U)) {

+      iVar4 = -0x3fffffdd;

+    }

+  }

+  else {

+    do {

+      ppplVar2 = ppppplVar7[2][1];

+      if (ppplVar2 == (longlong ***)0x0) {

+        RtlInitUnicodeString(&local_60,L"?");

+LAB_3:

+        uVar10 = (uint)(ushort)local_60;

+      }

+      else {

+        if ((ppplVar2[8] == (longlong **)0x0) || (*(ushort *)(ppplVar2 + 7) < 2)) {

+          RtlInitUnicodeString(&local_60,0);

+          uVar10 = (uint)(ushort)local_60;

+        }

+        else {

+          uVar10 = *(uint *)(ppplVar2 + 7);

+          plStack_58 = (longlong *)ppplVar2[8];

+          uVar11 = (ulonglong)uVar10;

+          uVar9 = (ushort)uVar10;

+          local_60._2_6_ = (undefined6)((ulonglong)ppplVar2[7] >> 0x10);

+          local_60 = CONCAT62(local_60._2_6_,uVar9);

+          while (1 < uVar9) {

+            uVar10 = (uint)uVar11;

+            if (*(short *)((longlong)plStack_58 + ((uVar11 & 0xfffe) - 2)) != 0) break;

+            uVar9 = (short)uVar11 - 2;

+            uVar11 = (ulonglong)uVar9;

+            uVar10 = (uint)uVar9;

+            local_60._2_6_ = (undefined6)((ulonglong)local_60 >> 0x10);

+            local_60 = CONCAT62(local_60._2_6_,uVar9);

+          }

+        }

+        if ((short)uVar10 == 0) {

+          local_res8[0] = 0x110;

+          if ((puVar8 != (ushort *)0x0) ||

+             (puVar8 = (ushort *)ExAllocatePool2(0x100,0x110,0x47706e50), puVar8 != (ushort *)0x0))

+          {

+            iVar4 = ObQueryNameStringMode(ppplVar2,puVar8,local_res8[0],local_res8,0);

+            if ((iVar4 < 0) || ((local_res8[0] == 0 || (*puVar8 < 2)))) {

+              RtlInitUnicodeString(&local_60,L"?");

+              iVar4 = 0;

+            }

+            else {

+              local_60 = *(undefined8 *)puVar8;

+              plStack_58 = *(longlong **)(puVar8 + 4);

+            }

+            goto LAB_3;

+          }

+          iVar4 = -0x3fffff66;

+          goto LAB_0;

+        }

+      }

+      if (_Dst != (undefined2 *)0x0) {

+        uVar9 = (ushort)uVar10;

+        if ((ulonglong)uVar9 + 2 <= (ulonglong)local_88) {

+          RtlCopyMemory(_Dst,plStack_58,(ulonglong)uVar9);

+          _Dst[uVar9 >> 1] = 0;

+          _Dst = _Dst + (uVar9 >> 1) + 1;

+          local_88 = local_88 + (-2 - (uVar10 & 0xffff));

+        }

+      }

+      iVar12 = iVar12 + (uVar10 & 0xffff) + 2;

+      ppppplVar7 = (longlong *****)*ppppplVar7;

+    } while (ppppplVar7 != &local_70);

+    param_3 = local_res18;

+    param_2 = local_res10;

+    if (-1 < iVar4) goto LAB_2;

+  }

+  if (puVar8 != (ushort *)0x0) {

+    ExFreePoolWithTag(puVar8,0);

+  }

+LAB_0:

+  while( true ) {

+    pppplVar6 = local_70;

+    if ((longlong *****)local_70 == &local_70) {

+      if (lVar5 != 0) {

+        ObfDereferenceObjectWithTag(lVar5,0x43706e50);

+      }

+      return iVar4;

+    }

+    if (((longlong *****)local_70[1] != &local_70) ||

+       (ppppplVar7 = (longlong *****)*local_70, ppppplVar7[1] != local_70)) break;

+    ppppplVar7[1] = (longlong ****)&local_70;

+    ppppplVar1 = (longlong *****)(local_70 + 2);

+    local_70 = (longlong ****)ppppplVar7;

+    ObfDereferenceObjectWithTag(*ppppplVar1,0x43706e50);

+    ExFreePoolWithTag(pppplVar6,0);

+  }

+LAB_1:

+  pcVar3 = (code *)swi(0x29);

+  (*pcVar3)(3);

+  return -0x3fffffe9;

 }
```

## `LdrResSearchResource`  (modified)

```diff
--- LdrResSearchResource
+++ LdrResSearchResource
@@ -1,23 +1,172 @@
 

-void LdrResSearchResource(longlong param_1,undefined8 param_2,undefined4 param_3)

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+

+ulonglong LdrResSearchResource

+                    (ulonglong param_1,void *param_2,uint param_3,uint param_4,undefined8 param_5,

+                    longlong *param_6,longlong param_7,longlong param_8)

 

 {

-  undefined4 uVar1;

-  undefined4 uVar2;

-  longlong in_R10;

-  undefined4 uStackX_10;

+  longlong lVar1;

+  ushort uVar2;

+  int iVar3;

+  uint uVar4;

+  uint uVar5;

+  ulonglong uVar6;

+  ulonglong uVar7;

+  uint uVar8;

+  undefined1 auStack_d8 [32];

+  uint local_b8;

+  undefined8 local_b0;

+  longlong *local_a8;

+  longlong local_a0;

+  longlong local_98;

+  longlong local_80;

+  ulonglong local_78;

+  undefined8 local_70;

+  longlong local_68;

+  longlong local_60 [2];

+  short *local_50;

+  ulonglong local_40;

   

-  uVar1 = *(undefined4 *)(in_R10 + 0x10);

-  *(uint *)(param_1 + 0x98) = *(uint *)(param_1 + 0x98) | 1;

-  *(ulonglong *)(param_1 + 0x90) = CONCAT44(uVar1,uStackX_10);

-  *(undefined4 *)(param_1 + 0x80) = param_3;

-  *(undefined8 *)(param_1 + 0x88) = param_2;

-  uVar1 = *(undefined4 *)(in_R10 + 0xc);

-  uVar2 = *(undefined4 *)(in_R10 + 8);

-  *(uint *)(param_1 + 0x78) = *(uint *)(param_1 + 0x78) | 1;

-  *(ulonglong *)(param_1 + 0x70) = CONCAT44(uVar2,uVar1);

-  *(undefined4 *)(param_1 + 0x60) = param_3;

-  *(undefined8 *)(param_1 + 0x68) = param_2;

-  return;

+                    /* 0x74e5e0  1474  LdrResSearchResource */

+  local_40 = __security_cookie ^ (ulonglong)auStack_d8;

+  local_70 = param_5;

+  local_68 = param_8;

+  uVar7 = 0;

+  if (((param_1 == 0) || (param_2 == (void *)0x0)) || ((param_7 != 0 && (param_8 == 0)))) {

+LAB_0:

+    uVar7 = 0xc000000d;

+  }

+  else {

+    if ((param_4 & 0xc00) == 0) {

+      uVar5 = param_4 | 0x100;

+      if ((param_4 & 0xf00) != 0) {

+        uVar5 = param_4;

+      }

+      uVar8 = uVar5 | 0x1000;

+      if ((uVar5 >> 0xd & 1) != 0) {

+        uVar8 = uVar5;

+      }

+      iVar3 = Feature_1875039550__private_IsEnabledDeviceUsage();

+      if (iVar3 == 0) {

+        uVar5 = uVar8 & 0xfff80000;

+      }

+      else {

+        uVar5 = uVar8 & 0xfff00000;

+      }

+      if (uVar5 == 0) {

+        if (((param_3 < 3) && ((uVar8 & 2) == 0)) || (4 < param_3)) {

+          return 0xc00000f1;

+        }

+        if ((uVar8 & 0x41) == 0) {

+          if (param_3 == 4) goto LAB_1;

+        }

+        else {

+          if (param_3 != 4) {

+            return 0xc00000f1;

+          }

+LAB_1:

+          if ((uVar8 & 0x41) == 0) {

+            return 0xc00000f2;

+          }

+        }

+        if ((uVar8 >> 8 & 1) == 0) {

+          uVar5 = uVar8 & 0xc00;

+          if ((uVar8 >> 9 & 1) != 0) goto LAB_2;

+          if ((uVar8 & 0xc00) == 0xc00) goto LAB_3;

+        }

+        else {

+          uVar5 = uVar8 & 0xe00;

+LAB_2:

+          if (uVar5 != 0) goto LAB_3;

+        }

+        if ((((uVar8 >> 0xf & 1) == 0) || ((~uVar8 & 0x810) == 0)) &&

+           (((uVar8 & 0x3000) != 0x3000 && (((byte)uVar8 & 0x18) != 0x18)))) {

+          local_80 = 0;

+          if (((uVar8 >> 0x11 & 1) != 0) &&

+             ((((uVar8 >> 10 & 1) == 0 || (param_6 == (longlong *)0x0)) ||

+              (local_80 = *param_6, local_80 == 0)))) {

+            return 0xc000000d;

+          }

+          iVar3 = Feature_1875039550__private_IsEnabledDeviceUsage();

+          if (((iVar3 != 0) && ((uVar8 >> 0x13 & 1) != 0)) &&

+             (((uVar8 & 0x300) == 0 ||

+              ((param_6 == (longlong *)0x0 || (local_80 = *param_6, local_80 == 0)))))) {

+            return 0xc000000d;

+          }

+          RtlCopyMemory(local_60,param_2,(ulonglong)param_3 << 3);

+          uVar5 = 3;

+          if (param_3 < 4) {

+            uVar5 = param_3;

+          }

+          if (uVar5 != 3) {

+LAB_4:

+            if ((uVar8 & 0x300) != 0) {

+              uVar7 = param_1;

+              if (((uVar8 >> 9 & 1) != 0) && (uVar7 = param_1 | 1, (param_1 & 1) != 0)) {

+                uVar7 = param_1;

+              }

+              uVar6 = LdrpResGetMappingSize(uVar7,&local_80,uVar8);

+              if (((int)uVar6 < 0) && ((uVar8 & 0x1000) != 0)) {

+                return uVar6;

+              }

+            }

+            lVar1 = local_68;

+            local_98 = local_68;

+            local_a0 = param_7;

+            local_a8 = param_6;

+            local_b0 = local_70;

+            local_b8 = uVar5;

+            uVar4 = LdrpResSearchResourceMappedFile(uVar7,local_80,uVar8,local_60);

+            if (uVar4 != 0xc000008a) {

+              return (ulonglong)uVar4;

+            }

+            if ((local_60[0] - 0x10U & 0xfffffffffffffff7) == 0) {

+              return 0xc000008a;

+            }

+            local_78 = 0;

+            local_b8 = 0x1000000;

+            iVar3 = LdrLoadAlternateResourceModuleEx(uVar7,0xf2ee,&local_78,0);

+            if (iVar3 < 0) {

+              return 0xc000008a;

+            }

+            local_80 = 0;

+            iVar3 = LdrpResGetMappingSize(local_78,&local_80,uVar8);

+            if (iVar3 < 0) {

+              return 0xc000008a;

+            }

+            local_98 = lVar1;

+            local_a0 = param_7;

+            local_a8 = param_6;

+            local_b0 = local_70;

+            local_b8 = uVar5;

+            uVar5 = LdrpResSearchResourceMappedFile(local_78,local_80,uVar8 | 0x1000000,local_60);

+            return (ulonglong)uVar5;

+          }

+          if ((short *)0xffff < local_50) {

+            if (*local_50 == 0) {

+              uVar4 = 0;

+              local_78 = local_78 & 0xffffffff00000000;

+            }

+            else {

+              uVar2 = DownLevelLanguageNameToLangID(local_50,2);

+              uVar4 = (uint)uVar2;

+              local_78 = CONCAT44(local_78._4_4_,uVar4);

+            }

+            local_50 = (short *)(ulonglong)uVar4;

+            goto LAB_4;

+          }

+          if ((local_50 == (short *)0x0) ||

+             (((((ulonglong)local_50 & 0x3ff) != 0 && (local_50 != (short *)0x7f)) &&

+              (iVar3 = DownLevelLangIDToLanguageName((ulonglong)local_50 & 0xffff,0,0,2), iVar3 != 0

+              )))) goto LAB_4;

+          goto LAB_0;

+        }

+      }

+    }

+LAB_3:

+    uVar7 = 0xc00000f2;

+  }

+  return uVar7;

 }
```

## `KsepCacheDeviceInsertData`  (modified)

```diff
--- KsepCacheDeviceInsertData
+++ KsepCacheDeviceInsertData
@@ -1,94 +1,55 @@
 

-/* WARNING: Function: _guard_dispatch_icall replaced with injection: guard_dispatch_icall */

-

-int KsepCacheDeviceInsertData(longlong param_1,longlong param_2,longlong param_3,uint param_4)

+uint KsepCacheDeviceInsertData

+               (longlong param_1,undefined8 param_2,void *param_3,undefined4 param_4,uint param_5)

 

 {

-  code *pcVar1;

-  int iVar2;

-  ulonglong uVar3;

-  longlong *plVar4;

-  uint uVar5;

+  longlong *plVar1;

+  code *pcVar2;

+  ushort uVar3;

+  uint uVar4;

+  longlong *plVar5;

+  void *_Dst;

+  undefined8 unaff_RDI;

+  undefined8 unaff_R14;

+  undefined4 uVar6;

+  undefined4 uVar7;

   

-  if (((param_1 == 0) || (param_2 == 0)) || (param_3 == 0)) {

-    iVar2 = -0x3ffffff3;

+  uVar6 = (undefined4)((ulonglong)unaff_R14 >> 0x20);

+  uVar7 = (undefined4)((ulonglong)unaff_RDI >> 0x20);

+  plVar5 = (longlong *)KsepPoolAllocatePaged(0x30);

+  if (plVar5 == (longlong *)0x0) {

+    uVar4 = 0xc0000017;

   }

   else {

-    uVar5 = 0;

-    if (param_4 != 0) {

-      plVar4 = (longlong *)(param_3 + 0x48);

-      do {

-        if ((*(uint *)(*plVar4 + 0x1c) & 4) == 0) {

-          pcVar1 = *(code **)(*(longlong *)(*plVar4 + 0x10) + 0x28);

-          if ((pcVar1 != (code *)0x0) &&

-             (iVar2 = (*pcVar1)(param_2,*(undefined8 *)(param_1 + 0x30),

-                                *(undefined4 *)(param_1 + 0x40),*(undefined4 *)(param_1 + 0x9c),

-                                *(undefined4 *)(param_1 + 0x78)), iVar2 < 0)) {

-            LOCK();

-            UNLOCK();

-            uVar3 = (ulonglong)(KsepHistoryErrorsIndex + 1U & 0x3f);

-            KsepHistoryErrorsIndex = KsepHistoryErrorsIndex + 1;

-            *(int *)(&DAT_0 + uVar3 * 8) = iVar2;

-            *(undefined4 *)(&KsepHistoryErrors + uVar3 * 8) = 0x7028b;

-            if ((KsepDebugFlag & 2) != 0) {

-              KsepDebugPrint(8,"KSE: Driver blocked with [%ws]: 0x%x\n",*(undefined8 *)(param_2 + 8)

-                             ,iVar2);

-            }

-            KsepLogError(8,"KSE: Driver blocked with [%ws]: 0x%x\n",*(undefined8 *)(param_2 + 8),

-                         iVar2);

-            return -0x3ffffc94;

-          }

-          iVar2 = KsepPatchDriverImportsTable(param_1,*(undefined8 *)(*plVar4 + 0x10));

-          if (iVar2 < 0) {

-            LOCK();

-            UNLOCK();

-            uVar3 = (ulonglong)(KsepHistoryErrorsIndex + 1U & 0x3f);

-            KsepHistoryErrorsIndex = KsepHistoryErrorsIndex + 1;

-            *(int *)(&DAT_0 + uVar3 * 8) = iVar2;

-            *(undefined4 *)(&KsepHistoryErrors + uVar3 * 8) = 0x7029e;

-            if ((KsepDebugFlag & 2) != 0) {

-              KsepDebugPrint(8,"KSE: Failed to patch driver [%ws]: 0x%x\n",

-                             *(undefined8 *)(param_2 + 8),iVar2);

-            }

-            KsepLogError(8,"KSE: Failed to patch driver [%ws]: 0x%x\n",*(undefined8 *)(param_2 + 8),

-                         iVar2);

-            return iVar2;

-          }

-          if (*(longlong *)(*plVar4 + 0x20) != 0) {

-            ObfReferenceObject();

-          }

-          LOCK();

-          UNLOCK();

-          uVar3 = (ulonglong)(KsepHistoryMessagesIndex + 1U & 0x3f);

-          KsepHistoryMessagesIndex = KsepHistoryMessagesIndex + 1;

-          *(undefined4 *)(&DAT_1 + uVar3 * 8) = 0;

-          *(undefined4 *)(&KsepHistoryMessages + uVar3 * 8) = 0x702b1;

-          if ((KsepDebugFlag & 1) != 0) {

-            KsepDebugPrint(8,"KSE: Applied shim [0x%08X] to driver [%ws]\n",

-                           **(undefined4 **)(*(longlong *)(*plVar4 + 0x10) + 8),

-                           *(undefined8 *)(param_2 + 8));

-          }

-          KsepLogInfo(8,"KSE: Applied shim [0x%08X] to driver [%ws]\n",

-                      **(undefined4 **)(*(longlong *)(*plVar4 + 0x10) + 8),

-                      *(undefined8 *)(param_2 + 8));

+    uVar4 = KsepStringDuplicate(plVar5 + 2,param_2);

+    if (-1 < (int)uVar4) {

+      _Dst = (void *)KsepPoolAllocatePaged(param_5);

+      plVar5[5] = (longlong)_Dst;

+      if (_Dst != (void *)0x0) {

+        RtlCopyMemory(_Dst,param_3,(ulonglong)param_5);

+        *(undefined4 *)((longlong)plVar5 + 0x24) = param_4;

+        *(uint *)(plVar5 + 4) = param_5;

+        plVar1 = *(longlong **)(param_1 + 0x40);

+        if (*plVar1 == param_1 + 0x38) {

+          *plVar5 = param_1 + 0x38;

+          plVar5[1] = (longlong)plVar1;

+          *plVar1 = (longlong)plVar5;

+          *(longlong **)(param_1 + 0x40) = plVar5;

+          return 0;

         }

-        uVar5 = uVar5 + 1;

-        plVar4 = plVar4 + 10;

-      } while (uVar5 < param_4);

+        pcVar2 = (code *)swi(0x29);

+        (*pcVar2)(3);

+        uVar3 = SdbGetTagFromTagID();

+        AslLogCallPrintf(1,"SdbReadQWORDTag",0x9d,"TagID 0x%X, Tag 0x%X not of the expected type",

+                         CONCAT44(uVar6,(int)plVar5),CONCAT44(uVar7,(uint)uVar3));

+        return param_5;

+      }

+      uVar4 = 0xc0000017;

     }

-    LOCK();

-    UNLOCK();

-    uVar3 = (ulonglong)(KsepHistoryMessagesIndex + 1U & 0x3f);

-    KsepHistoryMessagesIndex = KsepHistoryMessagesIndex + 1;

-    *(undefined4 *)(&DAT_1 + uVar3 * 8) = 0;

-    *(undefined4 *)(&KsepHistoryMessages + uVar3 * 8) = 0x702b5;

-    if ((KsepDebugFlag & 1) != 0) {

-      KsepDebugPrint(8,"KSE: Successfully applied shims to driver [%ws]\n",

-                     *(undefined8 *)(param_2 + 8));

-    }

-    KsepLogInfo(8,"KSE: Successfully applied shims to driver [%ws]\n",*(undefined8 *)(param_2 + 8));

-    iVar2 = 0;

+    KsepStringFree(plVar5 + 2);

+    KsepPoolFreePaged(plVar5[5]);

+    KsepPoolFreePaged(plVar5);

   }

-  return iVar2;

+  return uVar4;

 }
```

## `ExpWnfDeleteProcessContext`  (modified)

```diff
--- ExpWnfDeleteProcessContext
+++ ExpWnfDeleteProcessContext
@@ -1,85 +1,211 @@
 

-undefined8 ExpWnfDeleteProcessContext(longlong param_1)

+/* WARNING: Removing unreachable block (ram,0x0001407548da) */

+/* WARNING: Removing unreachable block (ram,0x000140754920) */

+/* WARNING: Removing unreachable block (ram,0x0001407548ec) */

+

+void ExpWnfDeleteProcessContext(ulonglong param_1,uint param_2)

 

 {

-  int *piVar1;

-  longlong *plVar2;

-  int iVar3;

-  longlong lVar4;

-  undefined8 *puVar5;

+  ulonglong *puVar1;

+  ulonglong uVar2;

+  longlong *plVar3;

+  longlong *plVar4;

+  longlong lVar5;

   longlong *plVar6;

   code *pcVar7;

-  char cVar8;

-  longlong in_RAX;

-  undefined8 uVar9;

-  longlong unaff_RBX;

-  undefined8 *puVar10;

-  undefined8 *unaff_RDI;

-  uint uVar11;

-  undefined8 *puVar12;

+  byte bVar8;

+  char cVar9;

+  longlong lVar10;

+  int iVar11;

+  longlong in_stack_00000038;

+  uint in_stack_00000040;

+  int in_stack_00000048;

   

-  *(int *)(in_RAX + -0x75) = *(int *)(in_RAX + -0x75) + -1;

-  LOCK();

-  piVar1 = (int *)(param_1 + 4);

-  iVar3 = *piVar1;

-  *piVar1 = *piVar1 + (int)unaff_RBX;

-  UNLOCK();

-  if (iVar3 + (int)unaff_RBX == 0) {

-    cVar8 = RtlpLockAtomTable();

-    if (cVar8 == '\0') {

-      return 0xc000000d;

-    }

-    uVar11 = 0;

-    puVar12 = unaff_RDI + 4;

-    if (*(int *)((longlong)unaff_RDI + 0x1c) != 0) {

-      do {

-        puVar10 = (undefined8 *)*puVar12;

-        *puVar12 = 0;

-        puVar12 = puVar12 + 1;

-        while (puVar10 != (undefined8 *)0x0) {

-          puVar5 = (undefined8 *)*puVar10;

-          plVar2 = puVar10 + 2;

-          *puVar10 = 0;

-          while (plVar6 = (longlong *)*plVar2, plVar6 != plVar2) {

-            if (((longlong *)plVar6[1] != plVar2) ||

-               (lVar4 = *plVar6, *(longlong **)(lVar4 + 8) != plVar6)) {

-              pcVar7 = (code *)swi(0x29);

-              (*pcVar7)(3);

-              pcVar7 = (code *)swi(3);

-              uVar9 = (*pcVar7)();

-              return uVar9;

-            }

-            *plVar2 = lVar4;

-            *(longlong **)(lVar4 + 8) = plVar2;

-            func_0x0001407540c8();

-          }

-          func_0x0001407540c8(puVar10);

-          puVar10 = puVar5;

+  puVar1 = (ulonglong *)(param_1 + 0x50);

+  lVar10 = KeAbPreAcquire(puVar1,0,0);

+  LOCK();

+  uVar2 = *puVar1;

+  *puVar1 = *puVar1 | 1;

+  UNLOCK();

+  if ((uVar2 & 1) != 0) {

+    ExfAcquirePushLockExclusiveEx(puVar1,lVar10,puVar1);

+  }

+  if (lVar10 != 0) {

+    *(undefined1 *)(lVar10 + 0x12) = 1;

+  }

+  while (plVar3 = *(longlong **)(param_1 + 0x58), plVar3 != (longlong *)(param_1 + 0x58)) {

+    ExAcquireRundownProtection(plVar3 + -2);

+    LOCK();

+    uVar2 = *puVar1;

+    *puVar1 = *puVar1 - 1;

+    UNLOCK();

+    if (((byte)uVar2 & 6) == 2) {

+      ExfTryToWakePushLock(puVar1);

+    }

+    KeAbPostRelease(puVar1);

+    ExpWnfDeleteSubscription(plVar3 + -3);

+    lVar10 = KeAbPreAcquire(puVar1,0);

+    LOCK();

+    uVar2 = *puVar1;

+    *puVar1 = *puVar1 | 1;

+    UNLOCK();

+    if ((uVar2 & 1) != 0) {

+      ExfAcquirePushLockExclusiveEx(puVar1);

+    }

+    if (lVar10 != 0) {

+      *(undefined1 *)(lVar10 + 0x12) = 1;

+    }

+  }

+  LOCK();

+  uVar2 = *puVar1;

+  *puVar1 = *puVar1 - 1;

+  UNLOCK();

+  if (((byte)uVar2 & 6) == 2) {

+    ExfTryToWakePushLock(puVar1);

+  }

+  KeAbPostRelease(puVar1);

+  puVar1 = (ulonglong *)(param_1 + 0x38);

+  lVar10 = KeAbPreAcquire(puVar1,0,0);

+  LOCK();

+  uVar2 = *puVar1;

+  *puVar1 = *puVar1 | 1;

+  UNLOCK();

+  if ((uVar2 & 1) != 0) {

+    ExfAcquirePushLockExclusiveEx(puVar1,lVar10,puVar1);

+  }

+  if (lVar10 != 0) {

+    *(undefined1 *)(lVar10 + 0x12) = 1;

+  }

+  plVar3 = (longlong *)(param_1 + 0x40);

+  while (plVar4 = (longlong *)*plVar3, plVar4 != plVar3) {

+    ExAcquireRundownProtection(plVar4 + -0x10);

+    LOCK();

+    uVar2 = *puVar1;

+    *puVar1 = *puVar1 - 1;

+    UNLOCK();

+    if (((byte)uVar2 & 6) == 2) {

+      ExfTryToWakePushLock(puVar1);

+    }

+    KeAbPostRelease(puVar1);

+    ExpWnfNotifyNameSubscribers(plVar4 + -0x11,0x10,0);

+    ExpWnfDeleteNameInstance(plVar4[-0xb],plVar4 + -0x11);

+    lVar10 = KeAbPreAcquire(puVar1,0);

+    LOCK();

+    uVar2 = *puVar1;

+    *puVar1 = *puVar1 | 1;

+    UNLOCK();

+    if ((uVar2 & 1) != 0) {

+      ExfAcquirePushLockExclusiveEx(puVar1,lVar10);

+    }

+    if (lVar10 != 0) {

+      *(undefined1 *)(lVar10 + 0x12) = 1;

+    }

+  }

+  LOCK();

+  uVar2 = *puVar1;

+  *puVar1 = *puVar1 - 1;

+  UNLOCK();

+  if (((byte)uVar2 & 6) == 2) {

+    ExfTryToWakePushLock(puVar1);

+  }

+  KeAbPostRelease(puVar1);

+  if (param_2 != 0) {

+    lVar10 = KeAbPreAcquire(&ExpWnfProcessesListLock,0,0);

+    LOCK();

+    uVar2 = ExpWnfProcessesListLock & 1;

+    ExpWnfProcessesListLock = ExpWnfProcessesListLock | 1;

+    UNLOCK();

+    if (uVar2 != 0) {

+      ExfAcquirePushLockExclusiveEx(&ExpWnfProcessesListLock,lVar10,&ExpWnfProcessesListLock);

+    }

+    if (lVar10 != 0) {

+      *(undefined1 *)(lVar10 + 0x12) = 1;

+    }

+    plVar4 = (longlong *)(param_1 + 0x10);

+    lVar5 = *plVar4;

+    if ((*(longlong **)(lVar5 + 8) != plVar4) ||

+       (plVar6 = *(longlong **)(param_1 + 0x18), (longlong *)*plVar6 != plVar4)) {

+      pcVar7 = (code *)swi(0x29);

+      (*pcVar7)(3);

+      if (((byte)((byte)*(undefined4 *)(lVar10 + 0x7c) & (byte)param_1) != 0) ||

+         ((byte)((byte)*(undefined4 *)(lVar10 + 0x80) & (byte)param_1) != 0)) {

+        LOCK();

+        UNLOCK();

+        in_stack_00000040 = (uint)(DAT_0 == 1);

+        DAT_0 = DAT_0 + -1;

+      }

+      *(undefined8 *)(lVar10 + 0x28) = 0;

+      LOCK();

+      lVar5 = *plVar3;

+      *plVar3 = *plVar3 + -1;

+      UNLOCK();

+      if (((byte)lVar5 & 6) == 2) {

+        ExfTryToWakePushLock(plVar3);

+      }

+      KeAbPostRelease(plVar3);

+      if (((in_stack_00000048 != 0) || (iVar11 = 0, in_stack_00000040 != 0)) &&

+         (cVar9 = ExAcquireRundownProtection(&SepRmLsaCallProcess), iVar11 = (int)param_1,

+         cVar9 == '\0')) {

+        in_stack_00000048 = 0;

+        in_stack_00000040 = 0;

+        iVar11 = 0;

+      }

+      LOCK();

+      lVar5 = AdtpNullSid + -1;

+      UNLOCK();

+      bVar8 = (byte)AdtpNullSid;

+      AdtpNullSid = lVar5;

+      if ((bVar8 & 6) == 2) {

+        ExfTryToWakePushLock(&AdtpNullSid);

+      }

+      KeAbPostRelease(&AdtpNullSid);

+      if ((ulonglong)param_2 != 0) {

+        plVar3 = (longlong *)((ulonglong)param_2 + 0x50);

+        LOCK();

+        lVar5 = *plVar3;

+        *plVar3 = *plVar3 + -1;

+        UNLOCK();

+        if (((byte)lVar5 & 6) == 2) {

+          ExfTryToWakePushLock(plVar3);

         }

-        uVar11 = uVar11 + 1;

-      } while (uVar11 < *(uint *)((longlong)unaff_RDI + 0x1c));

-    }

-    *(undefined4 *)unaff_RDI = 0;

-    plVar2 = unaff_RDI + 1;

-    LOCK();

-    lVar4 = *plVar2;

-    *plVar2 = *plVar2 + unaff_RBX;

-    UNLOCK();

-    if (((byte)lVar4 & 6) == 2) {

-      ExfTryToWakePushLock(plVar2);

-    }

-    KeAbPostRelease(plVar2);

-    KeLeaveCriticalRegion();

-    uVar9 = unaff_RDI[2];

-    ExpRemoveHandleTable(uVar9);

-    ExpFreeHandleTable(uVar9);

-    *unaff_RDI = 0;

-    unaff_RDI[1] = 0;

-    unaff_RDI[2] = 0;

-    unaff_RDI[3] = 0;

-    unaff_RDI[4] = 0;

-    func_0x0001407540c8();

-  }

-  return 0;

+        KeAbPostRelease(plVar3);

+      }

+      if (in_stack_00000040 != 0) {

+        ExpWnfNotifyNameSubscribers

+                  (&ExpWnfProcessesListLock,8,param_1 & 0xffffffff,

+                   in_stack_00000038 != PsInitialSystemProcess);

+      }

+      if (in_stack_00000048 != 0) {

+        ExpWnfNotifyNameSubscribers

+                  (&ExpWnfProcessesListLock,4,param_1 & 0xffffffff,

+                   in_stack_00000038 != PsInitialSystemProcess);

+      }

+      if (iVar11 != 0) {

+        ExReleaseRundownProtection(&SepRmLsaCallProcess);

+      }

+      ExReleaseRundownProtection(lVar10 + 8);

+      if ((int)param_1 != 0) {

+        ExWaitForRundownProtectionRelease(lVar10 + 8);

+        ExFreePoolWithTag(lVar10,0x20666e57);

+      }

+      return;

+    }

+    *plVar6 = lVar5;

+    *(longlong **)(lVar5 + 8) = plVar6;

+    LOCK();

+    uVar2 = ExpWnfProcessesListLock - 1;

+    UNLOCK();

+    bVar8 = (byte)ExpWnfProcessesListLock;

+    ExpWnfProcessesListLock = uVar2;

+    if ((bVar8 & 6) == 2) {

+      ExfTryToWakePushLock(&ExpWnfProcessesListLock);

+    }

+    KeAbPostRelease(&ExpWnfProcessesListLock);

+    if (*(longlong *)(param_1 + 0x80) != 0) {

+      ObfDereferenceObject();

+    }

+    ExFreePoolWithTag(param_1,0x20666e57);

+  }

+  return;

 }
```

## `LdrpResGetMappingSize`  (modified)

```diff
--- LdrpResGetMappingSize
+++ LdrpResGetMappingSize
@@ -1,80 +1,96 @@
 

-/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

-

-ulonglong LdrpResGetMappingSize(undefined8 param_1,undefined8 param_2,size_t param_3)

+undefined8 LdrpResGetMappingSize(ulonglong param_1,ulonglong *param_2,uint param_3)

 

 {

-  ushort uVar1;

-  uint uVar2;

-  int iVar3;

-  uint uVar4;

+  bool bVar1;

+  int iVar2;

+  longlong lVar3;

+  undefined8 uVar4;

   ulonglong uVar5;

-  uint unaff_EBX;

-  void *unaff_RSI;

-  uint unaff_EDI;

-  ulonglong unaff_R12;

-  ulonglong unaff_R14;

-  undefined8 in_stack_00000058;

-  ulonglong in_stack_00000060;

-  undefined8 in_stack_00000068;

-  undefined8 in_stack_00000070;

-  longlong in_stack_00000078;

-  short *in_stack_00000088;

+  ulonglong uVar6;

+  ulonglong uVar7;

+  ulonglong uVar8;

+  longlong local_res8;

+  undefined8 local_58;

+  undefined8 uStack_50;

+  ulonglong local_48;

+  undefined8 uStack_40;

+  undefined8 local_38;

+  undefined8 uStack_30;

   

-  RtlCopyMemory(&stack0x00000078,unaff_RSI,param_3);

-  uVar4 = 3;

-  if (unaff_EBX < 4) {

-    uVar4 = unaff_EBX;

+  local_res8 = 0;

+  local_58 = 0;

+  uStack_50 = 0;

+  local_48 = 0;

+  uStack_40 = 0;

+  local_38 = 0;

+  uStack_30 = 0;

+  if ((param_1 == 0) || (param_2 == (ulonglong *)0x0)) {

+    return 0xc000000d;

   }

-  if (uVar4 == 3) {

-    if (in_stack_00000088 < (short *)0x10000) {

-      if ((in_stack_00000088 != (short *)0x0) &&

-         (((((ulonglong)in_stack_00000088 & 0x3ff) == 0 || (in_stack_00000088 == (short *)0x7f)) ||

-          (iVar3 = DownLevelLangIDToLanguageName((ulonglong)in_stack_00000088 & 0xffff,0,0,2),

-          iVar3 == 0)))) {

-        return 0xc000000d;

-      }

+  uVar8 = 0;

+  iVar2 = Feature_1875039550__private_IsEnabledDeviceUsage();

+  if ((iVar2 == 0) || ((param_3 >> 0x13 & 1) == 0)) {

+    if ((param_3 >> 0x11 & 1) != 0) {

+      uVar8 = *param_2;

+    }

+    *param_2 = 0;

+    uVar5 = 0;

+    bVar1 = false;

+    if (((param_3 >> 8 & 1) != 0) && ((param_1 & 1) == 0)) {

+      bVar1 = true;

+    }

+    uVar4 = RtlImageNtHeaderEx(1,param_1 & 0xfffffffffffffffc,0,&local_res8);

+    if ((int)uVar4 < 0) {

+      return uVar4;

+    }

+    if ((*(short *)(local_res8 + 0x18) == 0x10b) || (*(short *)(local_res8 + 0x18) == 0x20b)) {

+      uVar7 = (ulonglong)*(uint *)(local_res8 + 0x50);

     }

     else {

-      if (*in_stack_00000088 == 0) {

-        uVar2 = 0;

-        in_stack_00000060 = in_stack_00000060 & 0xffffffff00000000;

+      uVar7 = 0;

+      uVar4 = 0xc000007b;

+    }

+    if ((int)uVar4 < 0) {

+      return uVar4;

+    }

+    if ((!bVar1) || (uVar6 = uVar7, uVar7 == 0)) {

+      lVar3 = LdrpKrnGetDataTableEntry(param_1);

+      if (lVar3 != 0) {

+        uVar5 = (ulonglong)*(uint *)(lVar3 + 0x40);

+      }

+      if (uVar5 == 0) {

+        uVar4 = ZwQueryVirtualMemory

+                          (0xffffffffffffffff,param_1 & 0xfffffffffffffffc,3,&local_58,0x30,0);

+        if (-1 < (int)uVar4) {

+          uVar5 = local_48;

+        }

       }

       else {

-        uVar1 = DownLevelLanguageNameToLangID(in_stack_00000088,2);

-        uVar2 = (uint)uVar1;

-        in_stack_00000060 = CONCAT44(in_stack_00000060._4_4_,uVar2);

+        uVar4 = 0;

       }

-      in_stack_00000088 = (short *)(ulonglong)uVar2;

+      uVar6 = uVar5;

+      if ((uVar5 == 0) && (uVar7 != 0)) {

+        uVar4 = 0;

+        uVar6 = uVar7;

+      }

+      if ((int)uVar4 < 0) {

+        return uVar4;

+      }

+      goto LAB_0;

     }

   }

-  if ((unaff_EDI & 0x300) != 0) {

-    unaff_R14 = unaff_R12;

-    if (((unaff_EDI >> 9 & 1) != 0) && (unaff_R14 = unaff_R12 | 1, (unaff_R12 & 1) != 0)) {

-      unaff_R14 = unaff_R12;

-    }

-    uVar5 = LdrpResGetMappingSize(unaff_R14,&stack0x00000058,unaff_EDI);

-    if (((int)uVar5 < 0) && ((unaff_EDI & 0x1000) != 0)) {

-      return uVar5;

-    }

+  else {

+    uVar6 = *param_2;

   }

-  uVar2 = LdrpResSearchResourceMappedFile

-                    (unaff_R14,in_stack_00000058,unaff_EDI,&stack0x00000078,uVar4);

-  uVar5 = (ulonglong)uVar2;

-  if ((uVar2 == 0xc000008a) && ((in_stack_00000078 - 0x10U & 0xfffffffffffffff7) != 0)) {

-    in_stack_00000060 = 0;

-    iVar3 = LdrLoadAlternateResourceModuleEx(unaff_R14,0xf2ee,&stack0x00000060,0,0x1000000);

-    if (-1 < iVar3) {

-      in_stack_00000058 = 0;

-      iVar3 = LdrpResGetMappingSize(in_stack_00000060,&stack0x00000058,unaff_EDI);

-      if (-1 < iVar3) {

-        uVar4 = LdrpResSearchResourceMappedFile

-                          (in_stack_00000060,in_stack_00000058,unaff_EDI | 0x1000000,

-                           &stack0x00000078,uVar4);

-        uVar5 = (ulonglong)uVar4;

-      }

-    }

+  uVar4 = 0;

+LAB_0:

+  if ((uVar8 == 0) || (uVar6 <= uVar8)) {

+    *param_2 = uVar6;

   }

-  return uVar5;

+  else {

+    uVar4 = 0xc000001f;

+  }

+  return uVar4;

 }
```

## `PiLookupInDDBCache`  (modified)

```diff
--- PiLookupInDDBCache
+++ PiLookupInDDBCache
@@ -1,66 +1,93 @@
 

 /* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

 

-int PiLookupInDDBCache(undefined8 param_1,undefined2 param_2)

+undefined4

+PiLookupInDDBCache(longlong param_1,undefined8 param_2,undefined8 param_3,longlong *param_4)

 

 {

-  longlong lVar1;

-  int iVar2;

-  int iVar3;

-  undefined8 in_RAX;

-  undefined8 unaff_RBX;

-  longlong unaff_RBP;

-  undefined4 *unaff_RSI;

-  undefined8 unaff_R14;

-  undefined4 extraout_XMM0_Da;

-  undefined4 uVar4;

+  longlong *plVar1;

+  code *pcVar2;

+  short sVar3;

+  char cVar4;

+  undefined4 uVar5;

+  longlong lVar6;

+  longlong *plVar7;

+  longlong lVar8;

+  undefined8 auStack_88 [4];

+  undefined8 local_68;

+  longlong lStack_60;

+  undefined8 local_58;

+  wchar_t *pwStack_50;

+  undefined8 local_48;

+  undefined8 uStack_40;

+  undefined8 local_38;

+  ulonglong local_30;

   

-  out(param_2,(int)in_RAX);

-  if (CONCAT71((int7)((ulonglong)in_RAX >> 8),0xff) == 0) {

-    iVar2 = -0x3fffffff;

-  }

-  else {

-    *(undefined8 *)(unaff_RBP + -9) = 0;

-    *(undefined8 *)(unaff_RBP + -1) = 0;

-    iVar2 = PpCheckInDriverDatabase();

-    uVar4 = extraout_XMM0_Da;

-    if (iVar2 + 0x3ffffc95U < 2) {

-      uVar4 = PnpSetBlockedDriverEvent(unaff_RBP + -9);

+  local_30 = __security_cookie ^ (ulonglong)auStack_88;

+  local_38 = 0;

+  local_68 = 0;

+  lStack_60 = 0;

+  _DAT_0 = 0;

+  local_58 = 0;

+  pwStack_50 = (wchar_t *)0x0;

+  local_48 = 0;

+  uStack_40 = 0;

+  cVar4 = RtlIsGenericTableEmptyAvl(&PiDDBCacheTable);

+  if ((cVar4 == '\0') && (lVar6 = RtlImageNtHeader(param_2), lVar6 != 0)) {

+    pwStack_50 = wcsrchr(*(wchar_t **)(param_1 + 8),L'\\');

+    if (pwStack_50 == (wchar_t *)0x0) {

+      pwStack_50 = *(wchar_t **)(param_1 + 8);

     }

-    iVar3 = IopGetRegistryValue(uVar4,L"PnpFlags",0,unaff_RBP + -0x59);

-    if (-1 < iVar3) {

-      lVar1 = *(longlong *)(unaff_RBP + -0x59);

-      if ((*(int *)(lVar1 + 4) == 4) && (*(int *)(lVar1 + 0xc) == 4)) {

-        *unaff_RSI = *(undefined4 *)((ulonglong)*(uint *)(lVar1 + 8) + lVar1);

+    else {

+      pwStack_50 = pwStack_50 + 1;

+    }

+    lVar8 = -1;

+    do {

+      lVar8 = lVar8 + 1;

+    } while (pwStack_50[lVar8] != L'\0');

+    sVar3 = (short)lVar8 * 2;

+    local_58._0_4_ = CONCAT22(sVar3,sVar3);

+    local_48 = CONCAT44(local_48._4_4_,*(undefined4 *)(lVar6 + 8));

+    plVar7 = (longlong *)RtlLookupElementGenericTableAvl(&PiDDBCacheTable,&local_68);

+    if (plVar7 != (longlong *)0x0) {

+      lVar8 = *plVar7;

+      if ((*(longlong **)(lVar8 + 8) == plVar7) &&

+         (plVar1 = (longlong *)plVar7[1], (longlong *)*plVar1 == plVar7)) {

+        *plVar1 = lVar8;

+        *(longlong **)(lVar8 + 8) = plVar1;

+        if ((undefined8 *)*DAT_1 == &PiDDBCacheList) {

+          *plVar7 = (longlong)&PiDDBCacheList;

+          plVar7[1] = (longlong)DAT_1;

+          *DAT_1 = (longlong)plVar7;

+          uVar5 = *(undefined4 *)((longlong)plVar7 + 0x24);

+          if (param_4 == (longlong *)0x0) {

+            DAT_1 = plVar7;

+            return uVar5;

+          }

+          lVar6 = plVar7[6];

+          DAT_1 = plVar7;

+          *param_4 = plVar7[5];

+          param_4[1] = lVar6;

+          return uVar5;

+        }

       }

-      ExFreePoolWithTag(lVar1,0);

-    }

-    iVar3 = RtlInitUnicodeStringEx(unaff_RBP + -0x49,L"Parameters");

-    if (-1 < iVar3) {

-      *(undefined4 *)(unaff_RBP + -0x1d) = 0;

-      *(undefined8 *)(unaff_RBP + -0x51) = 0;

-      *(undefined8 *)(unaff_RBP + -0x39) = 0x30;

-      *(undefined4 *)(unaff_RBP + -0x35) = 0;

-      *(longlong *)(unaff_RBP + -0x29) = unaff_RBP + -0x49;

-      *(undefined8 *)(unaff_RBP + -0x19) = 0;

-      *(undefined8 *)(unaff_RBP + -0x11) = 0;

-      *(undefined8 *)(unaff_RBP + -0x31) = unaff_RBX;

-      *(undefined4 *)(unaff_RBP + -0x21) = 0x240;

-      iVar3 = ZwOpenKey(unaff_RBP + -0x51,0xf003f,unaff_RBP + -0x39);

-      if (-1 < iVar3) {

-        iVar3 = IopGetRegistryValue(*(undefined8 *)(unaff_RBP + -0x51),L"PnpAsyncNewDevices",0,

-                                    unaff_RBP + -0x59);

-        if (-1 < iVar3) {

-          lVar1 = *(longlong *)(unaff_RBP + -0x59);

-          if ((*(int *)(lVar1 + 4) == 4) && (*(int *)(lVar1 + 0xc) == 4)) {

-            *(bool *)unaff_R14 = *(int *)((ulonglong)*(uint *)(lVar1 + 8) + lVar1) != 0;

-          }

-          ExFreePoolWithTag(lVar1,0);

-        }

-        NtClose(*(undefined8 *)(unaff_RBP + -0x51));

+      pcVar2 = (code *)swi(0x29);

+      (*pcVar2)(3);

+      auStack_88[0] = 0x1408f77ec;

+      lStack_60 = lVar6;

+      uVar5 = PiIsDriverBlocked(param_1);

+      if (param_4[-8] != 0) {

+        auStack_88[0] = 0x1407bd1ce;

+        PiReleaseDDB(param_4 + -8);

       }

+      if (param_4[-4] != 0) {

+        auStack_88[0] = 0x1408f77fc;

+        PiReleaseDDB(param_4 + -4);

+      }

+      return uVar5;

     }

   }

-  return iVar2;

+  return 0xc0000001;

 }
```

## `PspGetStorageArray`  (modified)

```diff
--- PspGetStorageArray
+++ PspGetStorageArray
@@ -1,36 +1,36 @@
 

-undefined8

-PspGetStorageArray(longlong param_1,undefined4 param_2,longlong param_3,longlong *param_4)

+undefined8 PspGetStorageArray(longlong param_1,uint param_2,uint *param_3,undefined8 param_4)

 

 {

-  byte *pbVar1;

-  char cVar2;

-  undefined8 uVar3;

-  longlong unaff_RBX;

-  longlong unaff_RDI;

-  undefined8 in_R11;

+  code *pcVar1;

+  undefined8 uVar2;

+  longlong lVar3;

   

-  in((short)param_2);

-  pbVar1 = (byte *)(unaff_RBX + 0x1d + param_1 * 4);

-  *pbVar1 = *pbVar1 & (byte)param_1;

-  *(int *)(unaff_RDI + 0x3345005b) = *(int *)(unaff_RDI + 0x3345005b) + -0x37;

-  if (param_1 != 0) {

-    in_R11 = *(undefined8 *)(param_1 + 0x5e8);

+  lVar3 = param_1;

+  uVar2 = PspGetStorageArrayIfPossible();

+  if ((int)uVar2 == -0x3ffffddb) {

+    if (*(longlong *)(lVar3 + 0x200) != 0) {

+      return uVar2;

+    }

+    uVar2 = PspLazyInitializeStorageExpansion();

+    if ((int)uVar2 < 0) {

+      return uVar2;

+    }

+    uVar2 = PspGetStorageArrayIfPossible(param_1,param_2,param_3,param_4);

   }

-  cVar2 = PspIsSiloContext(param_3);

-  if (cVar2 != '\0') {

-    if ((*(byte *)(param_3 + -0x16) & 0x40) != 0) {

-      param_4 = (longlong *)

-                (*(longlong *)

-                  ((param_3 + -0x30) -

-                  (ulonglong)(byte)(&ObpInfoMaskToOffset)[*(byte *)(param_3 + -0x16) & 0x7f]) + 0x20

-                );

+  if (-1 < (int)uVar2) {

+    lVar3 = DAT_0;

+    if (0x1f < param_2) {

+      lVar3 = DAT_1;

     }

-    if (*param_4 != param_1) {

+    if ((*(byte *)(lVar3 + ((longlong)(ulonglong)*param_3 >> 3)) >> ((ulonglong)*param_3 & 7) & 1)

+        == 0) {

+      pcVar1 = (code *)swi(0x29);

+      (*pcVar1)(5);

       return 0xc000000d;

     }

+    uVar2 = 0;

   }

-  uVar3 = PspStorageInsertObject(in_R11,param_2,0,param_3);

-  return uVar3;

+  return uVar2;

 }
```

## `WbReleaseLeastRecentlyUsedHeapExecutedBlocks`  (modified)

```diff
--- WbReleaseLeastRecentlyUsedHeapExecutedBlocks
+++ AuthzBasepCopyoutInternalSecurityAttributes
@@ -1,81 +1,41 @@
 

-int WbReleaseLeastRecentlyUsedHeapExecutedBlocks(longlong param_1,longlong param_2)

+int AuthzBasepCopyoutInternalSecurityAttributes(void)

 

 {

-  short *psVar1;

-  ulonglong uVar2;

-  void *pvVar3;

-  int iVar4;

-  void *in_RAX;

-  longlong lVar5;

-  ulonglong *unaff_RBX;

-  uint uVar6;

-  longlong unaff_RDI;

-  longlong unaff_R13;

-  longlong unaff_R14;

-  char in_CF;

-  bool in_ZF;

-  undefined1 auStack_50 [48];

+  longlong unaff_RBX;

+  int unaff_EBP;

+  int unaff_ESI;

+  int unaff_EDI;

+  undefined4 unaff_R12D;

+  undefined4 unaff_R13D;

+  int unaff_R15D;

+  undefined4 local_res20;

+  undefined4 uStackX_24;

+  int in_stack_00000028;

+  int in_stack_00000070;

+  undefined4 *in_stack_00000088;

+  int *in_stack_00000090;

+  undefined4 *in_stack_00000098;

+  int *in_stack_000000a0;

+  undefined4 *in_stack_000000a8;

+  int *in_stack_000000b0;

+  int *in_stack_000000b8;

+  undefined4 *in_stack_000000c0;

+  int *in_stack_000000c8;

+  int *in_stack_000000d0;

   

-  if (!in_ZF) {

-    *(char *)(unaff_RDI + 0x41) = (*(char *)(unaff_RDI + 0x41) - (char)param_2) - in_CF;

-    register0x00000020 = (BADSPACEBASE *)auStack_50;

-    unaff_RBX = (ulonglong *)(param_1 + 0xb0);

-    in_RAX = SystemReserved1[0xf];

-    unaff_R13 = param_2;

-    unaff_R14 = param_1;

-  }

-  *(short *)((longlong)in_RAX + 0x1e6) = *(short *)((longlong)in_RAX + 0x1e6) + -1;

-  iVar4 = 0;

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1407ce50e;

-  lVar5 = KeAbPreAcquire(unaff_RBX,0,0);

-  LOCK();

-  uVar2 = *unaff_RBX;

-  *unaff_RBX = *unaff_RBX | 1;

-  UNLOCK();

-  if ((uVar2 & 1) != 0) {

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1408fd204;

-    ExfAcquirePushLockExclusiveEx(unaff_RBX,lVar5,unaff_RBX);

-  }

-  if (lVar5 != 0) {

-    *(undefined1 *)(lVar5 + 0x12) = 1;

-  }

-  uVar6 = 0;

-  if (*(int *)(unaff_R14 + 0x8c) != 0) {

-    do {

-      lVar5 = *(longlong *)

-               ((ulonglong)(uVar6 * *(int *)(unaff_R14 + 0x88)) + *(longlong *)(unaff_R14 + 0x98));

-      if ((lVar5 != 0) && (*(longlong *)(lVar5 + 0x20) == unaff_R13)) {

-        *(undefined8 *)((longlong)register0x00000020 + 0x20) = 0;

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1408fd220;

-        iVar4 = FUN_1407ce8b4((int *)(unaff_R14 + 0x88),0,0,uVar6);

-        if (-1 < iVar4) {

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1408fd233;

-          FUN_1407f0de0(lVar5);

-          uVar6 = uVar6 - 1;

-        }

-      }

-      uVar6 = uVar6 + 1;

-    } while (uVar6 < *(uint *)(unaff_R14 + 0x8c));

-  }

-  LOCK();

-  uVar2 = *unaff_RBX;

-  *unaff_RBX = *unaff_RBX - 1;

-  UNLOCK();

-  if (((uVar2 & 2) != 0) && ((uVar2 & 4) == 0)) {

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1408fd24c;

-    ExfTryToWakePushLock(unaff_RBX);

-  }

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1407ce54d;

-  KeAbPostRelease(unaff_RBX);

-  pvVar3 = SystemReserved1[0xf];

-  psVar1 = (short *)((longlong)SystemReserved1[0xf] + 0x1e6);

-  *psVar1 = *psVar1 + 1;

-  if ((*psVar1 == 0) &&

-     (*(longlong **)((longlong)pvVar3 + 0x98) != (longlong *)((longlong)pvVar3 + 0x98))) {

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1407ce5cf;

-    KiCheckForKernelApcDelivery();

-  }

-  return iVar4;

+  func_0x0001407cee74(*(undefined4 *)(unaff_RBX + 0x308),0,0,&stack0x00000070);

+  *in_stack_00000088 = local_res20;

+  *in_stack_00000090 = unaff_R15D;

+  *in_stack_00000098 = uStackX_24;

+  *in_stack_000000a0 = unaff_EBP;

+  *in_stack_000000a8 = unaff_R12D;

+  *in_stack_000000b0 = unaff_EDI;

+  *in_stack_000000b8 = unaff_ESI;

+  *in_stack_000000c0 = unaff_R13D;

+  *in_stack_000000c8 = (int)unaff_RBX;

+  *in_stack_000000d0 = in_stack_00000070;

+  return in_stack_00000028 + in_stack_00000070 + (int)unaff_RBX + unaff_ESI + unaff_EDI + unaff_EBP

+         + unaff_R15D + 0x388;

 }
```
